ZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtY2xhc3MtdXNiX2hvc3QgYi9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWNsYXNzLXV3Yl9yYy13dXNiaGMKc2ltaWxhcml0eSBpbmRleCA4OCUKcmVuYW1lIGZyb20gRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1jbGFzcy11c2JfaG9zdApyZW5hbWUgdG8gRG9jdW1lbnRhdGlvbi9BQkkvdGVzdGluZy9zeXNmcy1jbGFzcy11d2JfcmMtd3VzYmhjCmluZGV4IDQ2YjY2YWQxLi40ZTgxMDZmIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL0FCSS90ZXN0aW5nL3N5c2ZzLWNsYXNzLXVzYl9ob3N0CisrKyBiL0RvY3VtZW50YXRpb24vQUJJL3Rlc3Rpbmcvc3lzZnMtY2xhc3MtdXdiX3JjLXd1c2JoYwpAQCAtMSw0ICsxLDQgQEAKLVdoYXQ6ICAgICAgICAgICAvc3lzL2NsYXNzL3VzYl9ob3N0L3VzYl9ob3N0Ti93dXNiX2NoaWQKK1doYXQ6ICAgICAgICAgICAvc3lzL2NsYXNzL3V3Yl9yYy91d2JOL3d1c2JoYy93dXNiX2NoaWQKIERhdGU6ICAgICAgICAgICBKdWx5IDIwMDgKIEtlcm5lbFZlcnNpb246ICAyLjYuMjcKIENvbnRhY3Q6ICAgICAgICBEYXZpZCBWcmFiZWwgPGRhdmlkLnZyYWJlbEBjc3IuY29tPgpAQCAtOSw3ICs5LDcgQEAKIAogICAgICAgICAgICAgICAgIFNldCBhbiBhbGwgemVybyBDSElEIHRvIHN0b3AgdGhlIGhvc3QgY29udHJvbGxlci4KIAotV2hhdDogICAgICAgICAgIC9zeXMvY2xhc3MvdXNiX2hvc3QvdXNiX2hvc3ROL3d1c2JfdHJ1c3RfdGltZW91dAorV2hhdDogICAgICAgICAgIC9zeXMvY2xhc3MvdXdiX3JjL3V3Yk4vd3VzYmhjL3d1c2JfdHJ1c3RfdGltZW91dAogRGF0ZTogICAgICAgICAgIEp1bHkgMjAwOAogS2VybmVsVmVyc2lvbjogIDIuNi4yNwogQ29udGFjdDogICAgICAgIERhdmlkIFZyYWJlbCA8ZGF2aWQudnJhYmVsQGNzci5jb20+CmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2RlYnVnZ2luZy12aWEtb2hjaTEzOTQudHh0IGIvRG9jdW1lbnRhdGlvbi9kZWJ1Z2dpbmctdmlhLW9oY2kxMzk0LnR4dAppbmRleCA1OWE5MWU1Li42MTFmNWE1IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2RlYnVnZ2luZy12aWEtb2hjaTEzOTQudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZGVidWdnaW5nLXZpYS1vaGNpMTM5NC50eHQKQEAgLTY0LDE0ICs2NCwxNCBAQAogCiBCZXJuaGFyZCBLYWluZGwgZW5oYW5jZWQgZmlyZXNjb3BlIHRvIHN1cHBvcnQgYWNjZXNzaW5nIDY0LWJpdCBtYWNoaW5lcwogZnJvbSAzMi1iaXQgZmlyZXNjb3BlIGFuZCB2aWNlIHZlcnNhOgotLSBmdHA6Ly9mdHAuc3VzZS5kZS9wcml2YXRlL2JrL2ZpcmV3aXJlL3Rvb2xzL2ZpcmVzY29wZS0wLjIuMi50YXIuYnoyCistIGh0dHA6Ly9oYWxvYmF0ZXMuZGUvZmlyZXdpcmUvZmlyZXNjb3BlLTAuMi4yLnRhci5iejIKIAogYW5kIGhlIGltcGxlbWVudGVkIGZhc3Qgc3lzdGVtIGR1bXAgKGFscGhhIHZlcnNpb24gLSByZWFkIFJFQURNRS50eHQpOgotLSBmdHA6Ly9mdHAuc3VzZS5kZS9wcml2YXRlL2JrL2ZpcmV3aXJlL3Rvb2xzL2ZpcmVkdW1wLTAuMS50YXIuYnoyCistIGh0dHA6Ly9oYWxvYmF0ZXMuZGUvZmlyZXdpcmUvZmlyZWR1bXAtMC4xLnRhci5iejIKIAogVGhlcmUgaXMgYWxzbyBhIGdkYiBwcm94eSBmb3IgZmlyZXdpcmUgd2hpY2ggYWxsb3dzIHRvIHVzZSBnZGIgdG8gYWNjZXNzCiBkYXRhIHdoaWNoIGNhbiBiZSByZWZlcmVuY2VkIGZyb20gc3ltYm9scyBmb3VuZCBieSBnZGIgaW4gdm1saW51eDoKLS0gZnRwOi8vZnRwLnN1c2UuZGUvcHJpdmF0ZS9iay9maXJld2lyZS90b29scy9maXJlcHJveHktMC4zMy50YXIuYnoyCistIGh0dHA6Ly9oYWxvYmF0ZXMuZGUvZmlyZXdpcmUvZmlyZXByb3h5LTAuMzMudGFyLmJ6MgogCiBUaGUgbGF0ZXN0IHZlcnNpb24gb2YgdGhpcyBnZGIgcHJveHkgKGZpcmVwcm94eS0wLjM0KSBjYW4gY29tbXVuaWNhdGUgKG5vdAogeWV0IHN0YWJsZSkgd2l0aCBrZ2RiIG92ZXIgYW4gbWVtb3J5LWJhc2VkIGNvbW11bmljYXRpb24gbW9kdWxlIChrZ2Rib20pLgpAQCAtMTc4LDcgKzE3OCw3IEBACiAKIE5vdGVzCiAtLS0tLQotRG9jdW1lbnRhdGlvbiBhbmQgc3BlY2lmaWNhdGlvbnM6IGZ0cDovL2Z0cC5zdXNlLmRlL3ByaXZhdGUvYmsvZmlyZXdpcmUvZG9jcworRG9jdW1lbnRhdGlvbiBhbmQgc3BlY2lmaWNhdGlvbnM6IGh0dHA6Ly9oYWxvYmF0ZXMuZGUvZmlyZXdpcmUvCiAKIEZpcmVXaXJlIGlzIGEgdHJhZGVtYXJrIG9mIEFwcGxlIEluYy4gLSBmb3IgbW9yZSBpbmZvcm1hdGlvbiBwbGVhc2UgcmVmZXIgdG86CiBodHRwOi8vZW4ud2lraXBlZGlhLm9yZy93aWtpL0ZpcmVXaXJlCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZlYXR1cmUtcmVtb3ZhbC1zY2hlZHVsZS50eHQgYi9Eb2N1bWVudGF0aW9uL2ZlYXR1cmUtcmVtb3ZhbC1zY2hlZHVsZS50eHQKaW5kZXggODlhNDdiNS4uYmM2OTNmZiAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9mZWF0dXJlLXJlbW92YWwtc2NoZWR1bGUudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmVhdHVyZS1yZW1vdmFsLXNjaGVkdWxlLnR4dApAQCAtNDE4LDYgKzQxOCwxNCBAQAogV2h5OglTaG91bGQgYmUgaW1wbGVtZW50ZWQgaW4gdXNlcnNwYWNlLCBwb2xpY3kgZGFlbW9uLgogV2hvOglKb2hhbm5lcyBCZXJnIDxqb2hhbm5lc0BzaXBzb2x1dGlvbnMubmV0PgogCistLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworV2hhdDoJQ09ORklHX0lOT1RJRlkKK1doZW46CTIuNi4zMworV2h5OglsYXN0IHVzZXIgKGF1ZGl0KSB3aWxsIGJlIGNvbnZlcnRlZCB0byB0aGUgbmV3ZXIgbW9yZSBnZW5lcmljCisJYW5kIG1vcmUgZWFzaWx5IG1haW50YWluZWQgZnNub3RpZnkgc3Vic3lzdGVtCitXaG86CUVyaWMgUGFyaXMgPGVwYXJpc0ByZWRoYXQuY29tPgorCiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKIFdoYXQ6CWxvY2tfcG9saWN5X3J3c2VtXyogYW5kIHVubG9ja19wb2xpY3lfcndzZW1fKiB3aWxsIG5vdCBiZQpAQCAtNDUxLDMgKzQ1OSwzMyBAQAogCXdpbGwgYWxzbyBhbGxvdyBtYWtpbmcgQUxTQSBPU1MgZW11bGF0aW9uIGluZGVwZW5kZW50IG9mCiAJc291bmRfY29yZS4gIFRoZSBkZXBlbmRlbmN5IHdpbGwgYmUgYnJva2VuIHRoZW4gdG9vLgogV2hvOglUZWp1biBIZW8gPHRqQGtlcm5lbC5vcmc+CisKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworV2hhdDoJU3VwcG9ydCBmb3IgVk13YXJlJ3MgZ3Vlc3QgcGFyYXZpcnR1bGlhemF0aW9uIHRlY2huaXF1ZSBbVk1JXSB3aWxsIGJlCisJZHJvcHBlZC4KK1doZW46CTIuNi4zNyBvciBlYXJsaWVyLgorV2h5OglXaXRoIHRoZSByZWNlbnQgaW5ub3ZhdGlvbnMgaW4gQ1BVIGhhcmR3YXJlIGFjY2VsZXJhdGlvbiB0ZWNobm9sb2dpZXMKKwlmcm9tIEludGVsIGFuZCBBTUQsIFZNd2FyZSByYW4gYSBmZXcgZXhwZXJpbWVudHMgdG8gY29tcGFyZSB0aGVzZQorCXRlY2huaXF1ZXMgdG8gZ3Vlc3QgcGFyYXZpcnR1YWxpemF0aW9uIHRlY2huaXF1ZSBvbiBWTXdhcmUncyBwbGF0Zm9ybS4KKwlUaGVzZSBoYXJkd2FyZSBhc3Npc3RlZCB2aXJ0dWFsaXphdGlvbiB0ZWNobmlxdWVzIGhhdmUgb3V0cGVyZm9ybWVkIHRoZQorCXBlcmZvcm1hbmNlIGJlbmVmaXRzIHByb3ZpZGVkIGJ5IFZNSSBpbiBtb3N0IG9mIHRoZSB3b3JrbG9hZHMuIFZNd2FyZQorCWV4cGVjdHMgdGhhdCB0aGVzZSBoYXJkd2FyZSBmZWF0dXJlcyB3aWxsIGJlIHViaXF1aXRvdXMgaW4gYSBjb3VwbGUgb2YKKwl5ZWFycywgYXMgYSByZXN1bHQsIFZNd2FyZSBoYXMgc3RhcnRlZCBhIHBoYXNlZCByZXRpcmVtZW50IG9mIHRoaXMKKwlmZWF0dXJlIGZyb20gdGhlIGh5cGVydmlzb3IuIFdlIHdpbGwgYmUgcmVtb3ZpbmcgdGhpcyBmZWF0dXJlIGZyb20gdGhlCisJS2VybmVsIHRvby4gUmlnaHQgbm93IHdlIGFyZSB0YXJnZXRpbmcgMi42LjM3IGJ1dCBjYW4gcmV0aXJlIGVhcmxpZXIgaWYKKwl0ZWNobmljYWwgcmVhc29ucyAocmVhZCBvcHBvcnR1bml0eSB0byByZW1vdmUgbWFqb3IgY2h1bmsgb2YgcHZvcHMpCisJYXJpc2UuCisKKwlQbGVhc2Ugbm90ZSB0aGF0IFZNSSBoYXMgYWx3YXlzIGJlZW4gYW4gb3B0aW1pemF0aW9uIGFuZCBub24tVk1JIGtlcm5lbHMKKwlzdGlsbCB3b3JrIGZpbmUgb24gVk13YXJlJ3MgcGxhdGZvcm0uCisJTGF0ZXN0IHZlcnNpb25zIG9mIFZNd2FyZSdzIHByb2R1Y3Qgd2hpY2ggc3VwcG9ydCBWTUkgYXJlLAorCVdvcmtzdGF0aW9uIDcuMCBhbmQgVlNwaGVyZSA0LjAgb24gRVNYIHNpZGUsIGZ1dHVyZSBtYWludGFpbmVuY2UKKwlyZWxlYXNlcyBmb3IgdGhlc2UgcHJvZHVjdHMgd2lsbCBjb250aW51ZSBzdXBwb3J0aW5nIFZNSS4KKworCUZvciBtb3JlIGRldGFpbHMgYWJvdXQgVk1JIHJldGlyZW1lbnQgdGFrZSBhIGxvb2sgYXQgdGhpcywKKwlodHRwOi8vYmxvZ3Mudm13YXJlLmNvbS9ndWVzdG9zZ3VpZGUvMjAwOS8wOS92bWktcmV0aXJlbWVudC5odG1sCisKK1dobzoJQWxvayBOIEthdGFyaWEgPGFrYXRhcmlhQHZtd2FyZS5jb20+CisKKy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZXh0My50eHQgYi9Eb2N1bWVudGF0aW9uL2ZpbGVzeXN0ZW1zL2V4dDMudHh0CmluZGV4IDU3MGY5YmQuLjA1ZDVjZjEgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZXh0My50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9maWxlc3lzdGVtcy9leHQzLnR4dApAQCAtMTIzLDEwICsxMjMsMTggQEAKIAogc2I9bgkJCVVzZSBhbHRlcm5hdGUgc3VwZXJibG9jayBhdCB0aGlzIGxvY2F0aW9uLgogCi1xdW90YQotbm9xdW90YQotZ3JwcXVvdGEKLXVzcnF1b3RhCitxdW90YQkJCVRoZXNlIG9wdGlvbnMgYXJlIGlnbm9yZWQgYnkgdGhlIGZpbGVzeXN0ZW0uIFRoZXkKK25vcXVvdGEJCQlhcmUgdXNlZCBvbmx5IGJ5IHF1b3RhIHRvb2xzIHRvIHJlY29nbml6ZSB2b2x1bWVzCitncnBxdW90YQkJd2hlcmUgcXVvdGEgc2hvdWxkIGJlIHR1cm5lZCBvbi4gU2VlIGRvY3VtZW50YXRpb24KK3VzcnF1b3RhCQlpbiB0aGUgcXVvdGEtdG9vbHMgcGFja2FnZSBmb3IgbW9yZSBkZXRhaWxzCisJCQkoaHR0cDovL3NvdXJjZWZvcmdlLm5ldC9wcm9qZWN0cy9saW51eHF1b3RhKS4KKworanFmbXQ9PHF1b3RhIHR5cGU+CVRoZXNlIG9wdGlvbnMgdGVsbCBmaWxlc3lzdGVtIGRldGFpbHMgYWJvdXQgcXVvdGEKK3VzcmpxdW90YT08ZmlsZT4Jc28gdGhhdCBxdW90YSBpbmZvcm1hdGlvbiBjYW4gYmUgcHJvcGVybHkgdXBkYXRlZAorZ3JwanF1b3RhPTxmaWxlPglkdXJpbmcgam91cm5hbCByZXBsYXkuIFRoZXkgcmVwbGFjZSB0aGUgYWJvdmUKKwkJCXF1b3RhIG9wdGlvbnMuIFNlZSBkb2N1bWVudGF0aW9uIGluIHRoZSBxdW90YS10b29scworCQkJcGFja2FnZSBmb3IgbW9yZSBkZXRhaWxzCisJCQkoaHR0cDovL3NvdXJjZWZvcmdlLm5ldC9wcm9qZWN0cy9saW51eHF1b3RhKS4KIAogYmgJCSgqKQlleHQzIGFzc29jaWF0ZXMgYnVmZmVyIGhlYWRzIHRvIGRhdGEgcGFnZXMgdG8KIG5vYmgJCQkoYSkgY2FjaGUgZGlzayBibG9jayBtYXBwaW5nIGluZm9ybWF0aW9uCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZsZXhpYmxlLWFycmF5cy50eHQgYi9Eb2N1bWVudGF0aW9uL2ZsZXhpYmxlLWFycmF5cy50eHQKaW5kZXggODRlYjI2OC4uY2I4YTNhMCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9mbGV4aWJsZS1hcnJheXMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vZmxleGlibGUtYXJyYXlzLnR4dApAQCAtMSw1ICsxLDUgQEAKIFVzaW5nIGZsZXhpYmxlIGFycmF5cyBpbiB0aGUga2VybmVsCi1MYXN0IHVwZGF0ZWQgZm9yIDIuNi4zMQorTGFzdCB1cGRhdGVkIGZvciAyLjYuMzIKIEpvbmF0aGFuIENvcmJldCA8Y29yYmV0QGx3bi5uZXQ+CiAKIExhcmdlIGNvbnRpZ3VvdXMgbWVtb3J5IGFsbG9jYXRpb25zIGNhbiBiZSB1bnJlbGlhYmxlIGluIHRoZSBMaW51eCBrZXJuZWwuCkBAIC00MCw2ICs0MCwxMyBAQAogdGhlIGN1cnJlbnQgY29kZSwgdXNpbmcgZmxhZ3MgdG8gYXNrIGZvciBoaWdoIG1lbW9yeSBpcyBsaWtlbHkgdG8gbGVhZCB0bwogbm90YWJseSB1bnBsZWFzYW50IHNpZGUgZWZmZWN0cy4KIAorSXQgaXMgYWxzbyBwb3NzaWJsZSB0byBkZWZpbmUgZmxleGlibGUgYXJyYXlzIGF0IGNvbXBpbGUgdGltZSB3aXRoOgorCisgICAgREVGSU5FX0ZMRVhfQVJSQVkobmFtZSwgZWxlbWVudF9zaXplLCB0b3RhbCk7CisKK1RoaXMgbWFjcm8gd2lsbCByZXN1bHQgaW4gYSBkZWZpbml0aW9uIG9mIGFuIGFycmF5IHdpdGggdGhlIGdpdmVuIG5hbWU7IHRoZQorZWxlbWVudCBzaXplIGFuZCB0b3RhbCB3aWxsIGJlIGNoZWNrZWQgZm9yIHZhbGlkaXR5IGF0IGNvbXBpbGUgdGltZS4KKwogU3RvcmluZyBkYXRhIGludG8gYSBmbGV4aWJsZSBhcnJheSBpcyBhY2NvbXBsaXNoZWQgd2l0aCBhIGNhbGwgdG86CiAKICAgICBpbnQgZmxleF9hcnJheV9wdXQoc3RydWN0IGZsZXhfYXJyYXkgKmFycmF5LCB1bnNpZ25lZCBpbnQgZWxlbWVudF9uciwKQEAgLTc2LDE2ICs4MywzMCBAQAogTm90ZSB0aGF0IGl0IGlzIHBvc3NpYmxlIHRvIGdldCBiYWNrIGEgdmFsaWQgcG9pbnRlciBmb3IgYW4gZWxlbWVudCB3aGljaAogaGFzIG5ldmVyIGJlZW4gc3RvcmVkIGluIHRoZSBhcnJheS4gIE1lbW9yeSBmb3IgYXJyYXkgZWxlbWVudHMgaXMgYWxsb2NhdGVkCiBvbmUgcGFnZSBhdCBhIHRpbWU7IGEgc2luZ2xlIGFsbG9jYXRpb24gY291bGQgcHJvdmlkZSBtZW1vcnkgZm9yIHNldmVyYWwKLWFkamFjZW50IGVsZW1lbnRzLiAgVGhlIGZsZXhpYmxlIGFycmF5IGNvZGUgZG9lcyBub3Qga25vdyBpZiBhIHNwZWNpZmljCi1lbGVtZW50IGhhcyBiZWVuIHdyaXR0ZW47IGl0IG9ubHkga25vd3MgaWYgdGhlIGFzc29jaWF0ZWQgbWVtb3J5IGlzCi1wcmVzZW50LiAgU28gYSBmbGV4X2FycmF5X2dldCgpIGNhbGwgb24gYW4gZWxlbWVudCB3aGljaCB3YXMgbmV2ZXIgc3RvcmVkCi1pbiB0aGUgYXJyYXkgaGFzIHRoZSBwb3RlbnRpYWwgdG8gcmV0dXJuIGEgcG9pbnRlciB0byByYW5kb20gZGF0YS4gIElmIHRoZQotY2FsbGVyIGRvZXMgbm90IGhhdmUgYSBzZXBhcmF0ZSB3YXkgdG8ga25vdyB3aGljaCBlbGVtZW50cyB3ZXJlIGFjdHVhbGx5Ci1zdG9yZWQsIGl0IG1pZ2h0IGJlIHdpc2UsIGF0IGxlYXN0LCB0byBhZGQgR0ZQX1pFUk8gdG8gdGhlIGZsYWdzIGFyZ3VtZW50Ci10byBlbnN1cmUgdGhhdCBhbGwgZWxlbWVudHMgYXJlIHplcm9lZC4KK2FkamFjZW50IGVsZW1lbnRzLiAgRmxleGlibGUgYXJyYXkgZWxlbWVudHMgYXJlIG5vcm1hbGx5IGluaXRpYWxpemVkIHRvIHRoZQordmFsdWUgRkxFWF9BUlJBWV9GUkVFIChkZWZpbmVkIGFzIDB4NmMgaW4gPGxpbnV4L3BvaXNvbi5oPiksIHNvIGVycm9ycworaW52b2x2aW5nIHRoYXQgbnVtYmVyIHByb2JhYmx5IHJlc3VsdCBmcm9tIHVzZSBvZiB1bnN0b3JlZCBhcnJheSBlbnRyaWVzLgorTm90ZSB0aGF0LCBpZiBhcnJheSBlbGVtZW50cyBhcmUgYWxsb2NhdGVkIHdpdGggX19HRlBfWkVSTywgdGhleSB3aWxsIGJlCitpbml0aWFsaXplZCB0byB6ZXJvIGFuZCB0aGlzIHBvaXNvbmluZyB3aWxsIG5vdCBoYXBwZW4uCiAKLVRoZXJlIGlzIG5vIHdheSB0byByZW1vdmUgYSBzaW5nbGUgZWxlbWVudCBmcm9tIHRoZSBhcnJheS4gIEl0IGlzIHBvc3NpYmxlLAotdGhvdWdoLCB0byByZW1vdmUgYWxsIGVsZW1lbnRzIHdpdGggYSBjYWxsIHRvOgorSW5kaXZpZHVhbCBlbGVtZW50cyBpbiB0aGUgYXJyYXkgY2FuIGJlIGNsZWFyZWQgd2l0aDoKKworICAgIGludCBmbGV4X2FycmF5X2NsZWFyKHN0cnVjdCBmbGV4X2FycmF5ICphcnJheSwgdW5zaWduZWQgaW50IGVsZW1lbnRfbnIpOworCitUaGlzIGZ1bmN0aW9uIHdpbGwgc2V0IHRoZSBnaXZlbiBlbGVtZW50IHRvIEZMRVhfQVJSQVlfRlJFRSBhbmQgcmV0dXJuCit6ZXJvLiAgSWYgc3RvcmFnZSBmb3IgdGhlIGluZGljYXRlZCBlbGVtZW50IGlzIG5vdCBhbGxvY2F0ZWQgZm9yIHRoZSBhcnJheSwKK2ZsZXhfYXJyYXlfY2xlYXIoKSB3aWxsIHJldHVybiAtRUlOVkFMIGluc3RlYWQuICBOb3RlIHRoYXQgY2xlYXJpbmcgYW4KK2VsZW1lbnQgZG9lcyBub3QgcmVsZWFzZSB0aGUgc3RvcmFnZSBhc3NvY2lhdGVkIHdpdGggaXQ7IHRvIHJlZHVjZSB0aGUKK2FsbG9jYXRlZCBzaXplIG9mIGFuIGFycmF5LCBjYWxsOgorCisgICAgaW50IGZsZXhfYXJyYXlfc2hyaW5rKHN0cnVjdCBmbGV4X2FycmF5ICphcnJheSk7CisKK1RoZSByZXR1cm4gdmFsdWUgd2lsbCBiZSB0aGUgbnVtYmVyIG9mIHBhZ2VzIG9mIG1lbW9yeSBhY3R1YWxseSBmcmVlZC4KK1RoaXMgZnVuY3Rpb24gd29ya3MgYnkgc2Nhbm5pbmcgdGhlIGFycmF5IGZvciBwYWdlcyBjb250YWluaW5nIG5vdGhpbmcgYnV0CitGTEVYX0FSUkFZX0ZSRUUgYnl0ZXMsIHNvICgxKSBpdCBjYW4gYmUgZXhwZW5zaXZlLCBhbmQgKDIpIGl0IHdpbGwgbm90IHdvcmsKK2lmIHRoZSBhcnJheSdzIHBhZ2VzIGFyZSBhbGxvY2F0ZWQgd2l0aCBfX0dGUF9aRVJPLgorCitJdCBpcyBwb3NzaWJsZSB0byByZW1vdmUgYWxsIGVsZW1lbnRzIG9mIGFuIGFycmF5IHdpdGggYSBjYWxsIHRvOgogCiAgICAgdm9pZCBmbGV4X2FycmF5X2ZyZWVfcGFydHMoc3RydWN0IGZsZXhfYXJyYXkgKmFycmF5KTsKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9od21vbi9zeXNmcy1pbnRlcmZhY2UgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3N5c2ZzLWludGVyZmFjZQppbmRleCBkY2JkNTAyLi44MmRlZjg4IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2h3bW9uL3N5c2ZzLWludGVyZmFjZQorKysgYi9Eb2N1bWVudGF0aW9uL2h3bW9uL3N5c2ZzLWludGVyZmFjZQpAQCAtMzUzLDEwICszNTMsMjAgQEAKIAkJCQlVbml0OiBtaWNyb1dhdHQKIAkJCQlSTwogCi1wb3dlclsxLSpdX2F2ZXJhZ2VfaW50ZXJ2YWwJUG93ZXIgdXNlIGF2ZXJhZ2luZyBpbnRlcnZhbAorcG93ZXJbMS0qXV9hdmVyYWdlX2ludGVydmFsCVBvd2VyIHVzZSBhdmVyYWdpbmcgaW50ZXJ2YWwuICBBIHBvbGwKKwkJCQlub3RpZmljYXRpb24gaXMgc2VudCB0byB0aGlzIGZpbGUgaWYgdGhlCisJCQkJaGFyZHdhcmUgY2hhbmdlcyB0aGUgYXZlcmFnaW5nIGludGVydmFsLgogCQkJCVVuaXQ6IG1pbGxpc2Vjb25kcwogCQkJCVJXCiAKK3Bvd2VyWzEtKl1fYXZlcmFnZV9pbnRlcnZhbF9tYXgJTWF4aW11bSBwb3dlciB1c2UgYXZlcmFnaW5nIGludGVydmFsCisJCQkJVW5pdDogbWlsbGlzZWNvbmRzCisJCQkJUk8KKworcG93ZXJbMS0qXV9hdmVyYWdlX2ludGVydmFsX21pbglNaW5pbXVtIHBvd2VyIHVzZSBhdmVyYWdpbmcgaW50ZXJ2YWwKKwkJCQlVbml0OiBtaWxsaXNlY29uZHMKKwkJCQlSTworCiBwb3dlclsxLSpdX2F2ZXJhZ2VfaGlnaGVzdAlIaXN0b3JpY2FsIGF2ZXJhZ2UgbWF4aW11bSBwb3dlciB1c2UKIAkJCQlVbml0OiBtaWNyb1dhdHQKIAkJCQlSTwpAQCAtMzY1LDYgKzM3NSwxOCBAQAogCQkJCVVuaXQ6IG1pY3JvV2F0dAogCQkJCVJPCiAKK3Bvd2VyWzEtKl1fYXZlcmFnZV9tYXgJCUEgcG9sbCBub3RpZmljYXRpb24gaXMgc2VudCB0bworCQkJCXBvd2VyWzEtKl1fYXZlcmFnZSB3aGVuIHBvd2VyIHVzZQorCQkJCXJpc2VzIGFib3ZlIHRoaXMgdmFsdWUuCisJCQkJVW5pdDogbWljcm9XYXR0CisJCQkJUlcKKworcG93ZXJbMS0qXV9hdmVyYWdlX21pbgkJQSBwb2xsIG5vdGlmaWNhdGlvbiBpcyBzZW50IHRvCisJCQkJcG93ZXJbMS0qXV9hdmVyYWdlIHdoZW4gcG93ZXIgdXNlCisJCQkJc2lua3MgYmVsb3cgdGhpcyB2YWx1ZS4KKwkJCQlVbml0OiBtaWNyb1dhdHQKKwkJCQlSVworCiBwb3dlclsxLSpdX2lucHV0CQlJbnN0YW50YW5lb3VzIHBvd2VyIHVzZQogCQkJCVVuaXQ6IG1pY3JvV2F0dAogCQkJCVJPCkBAIC0zODEsNiArNDAzLDM5IEBACiAJCQkJYXZlcmFnZV9oaWdoZXN0IGFuZCBhdmVyYWdlX2xvd2VzdC4KIAkJCQlXTwogCitwb3dlclsxLSpdX2FjY3VyYWN5CQlBY2N1cmFjeSBvZiB0aGUgcG93ZXIgbWV0ZXIuCisJCQkJVW5pdDogUGVyY2VudAorCQkJCVJPCisKK3Bvd2VyWzEtKl1fYWxhcm0JCTEgaWYgdGhlIHN5c3RlbSBpcyBkcmF3aW5nIG1vcmUgcG93ZXIgdGhhbiB0aGUKKwkJCQljYXAgYWxsb3dzOyAwIG90aGVyd2lzZS4gIEEgcG9sbCBub3RpZmljYXRpb24gaXMKKwkJCQlzZW50IHRvIHRoaXMgZmlsZSB3aGVuIHRoZSBwb3dlciB1c2UgZXhjZWVkcyB0aGUKKwkJCQljYXAuICBUaGlzIGZpbGUgb25seSBhcHBlYXJzIGlmIHRoZSBjYXAgaXMga25vd24KKwkJCQl0byBiZSBlbmZvcmNlZCBieSBoYXJkd2FyZS4KKwkJCQlSTworCitwb3dlclsxLSpdX2NhcAkJCUlmIHBvd2VyIHVzZSByaXNlcyBhYm92ZSB0aGlzIGxpbWl0LCB0aGUKKwkJCQlzeXN0ZW0gc2hvdWxkIHRha2UgYWN0aW9uIHRvIHJlZHVjZSBwb3dlciB1c2UuCisJCQkJQSBwb2xsIG5vdGlmaWNhdGlvbiBpcyBzZW50IHRvIHRoaXMgZmlsZSBpZiB0aGUKKwkJCQljYXAgaXMgY2hhbmdlZCBieSB0aGUgaGFyZHdhcmUuICBUaGUgKl9jYXAKKwkJCQlmaWxlcyBvbmx5IGFwcGVhciBpZiB0aGUgY2FwIGlzIGtub3duIHRvIGJlCisJCQkJZW5mb3JjZWQgYnkgaGFyZHdhcmUuCisJCQkJVW5pdDogbWljcm9XYXR0CisJCQkJUlcKKworcG93ZXJbMS0qXV9jYXBfaHlzdAkJTWFyZ2luIG9mIGh5c3RlcmVzaXMgYnVpbHQgYXJvdW5kIGNhcHBpbmcgYW5kCisJCQkJbm90aWZpY2F0aW9uLgorCQkJCVVuaXQ6IG1pY3JvV2F0dAorCQkJCVJXCisKK3Bvd2VyWzEtKl1fY2FwX21heAkJTWF4aW11bSBjYXAgdGhhdCBjYW4gYmUgc2V0LgorCQkJCVVuaXQ6IG1pY3JvV2F0dAorCQkJCVJPCisKK3Bvd2VyWzEtKl1fY2FwX21pbgkJTWluaW11bSBjYXAgdGhhdCBjYW4gYmUgc2V0LgorCQkJCVVuaXQ6IG1pY3JvV2F0dAorCQkJCVJPCisKICoqKioqKioqKioKICogRW5lcmd5ICoKICoqKioqKioqKioKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vaW5maW5pYmFuZC91c2VyX21hZC50eHQgYi9Eb2N1bWVudGF0aW9uL2luZmluaWJhbmQvdXNlcl9tYWQudHh0CmluZGV4IDc0NDY4N2QuLjhhMzY2OTUgMTAwNjQ0Ci0tLSBhL0RvY3VtZW50YXRpb24vaW5maW5pYmFuZC91c2VyX21hZC50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9pbmZpbmliYW5kL3VzZXJfbWFkLnR4dApAQCAtMTI4LDggKzEyOCw4IEBACiAgIFRvIGNyZWF0ZSB0aGUgYXBwcm9wcmlhdGUgY2hhcmFjdGVyIGRldmljZSBmaWxlcyBhdXRvbWF0aWNhbGx5IHdpdGgKICAgdWRldiwgYSBydWxlIGxpa2UKIAotICAgIEtFUk5FTD0idW1hZCoiLCBOQU1FPSJpbmZpbmliYW5kLyVrIgotICAgIEtFUk5FTD0iaXNzbSoiLCBOQU1FPSJpbmZpbmliYW5kLyVrIgorICAgIEtFUk5FTD09InVtYWQqIiwgTkFNRT0iaW5maW5pYmFuZC8layIKKyAgICBLRVJORUw9PSJpc3NtKiIsIE5BTUU9ImluZmluaWJhbmQvJWsiCiAKICAgY2FuIGJlIHVzZWQuICBUaGlzIHdpbGwgY3JlYXRlIGRldmljZSBub2RlcyBuYW1lZAogCmRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2luZmluaWJhbmQvdXNlcl92ZXJicy50eHQgYi9Eb2N1bWVudGF0aW9uL2luZmluaWJhbmQvdXNlcl92ZXJicy50eHQKaW5kZXggZjg0NzUwMS4uYWZlM2Y4ZCAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9pbmZpbmliYW5kL3VzZXJfdmVyYnMudHh0CisrKyBiL0RvY3VtZW50YXRpb24vaW5maW5pYmFuZC91c2VyX3ZlcmJzLnR4dApAQCAtNTgsNyArNTgsNyBAQAogICBUbyBjcmVhdGUgdGhlIGFwcHJvcHJpYXRlIGNoYXJhY3RlciBkZXZpY2UgZmlsZXMgYXV0b21hdGljYWxseSB3aXRoCiAgIHVkZXYsIGEgcnVsZSBsaWtlCiAKLSAgICBLRVJORUw9InV2ZXJicyoiLCBOQU1FPSJpbmZpbmliYW5kLyVrIgorICAgIEtFUk5FTD09InV2ZXJicyoiLCBOQU1FPSJpbmZpbmliYW5kLyVrIgogCiAgIGNhbiBiZSB1c2VkLiAgVGhpcyB3aWxsIGNyZWF0ZSBkZXZpY2Ugbm9kZXMgbmFtZWQKIApkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9sZ3Vlc3QvbGd1ZXN0LmMgYi9Eb2N1bWVudGF0aW9uL2xndWVzdC9sZ3Vlc3QuYwppbmRleCBiYTkzNzNmLi4wOThkZTViIDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL2xndWVzdC9sZ3Vlc3QuYworKysgYi9Eb2N1bWVudGF0aW9uL2xndWVzdC9sZ3Vlc3QuYwpAQCAtNDIsNyArNDIsNiBAQAogI2luY2x1ZGUgPHNpZ25hbC5oPgogI2luY2x1ZGUgImxpbnV4L2xndWVzdF9sYXVuY2hlci5oIgogI2luY2x1ZGUgImxpbnV4L3ZpcnRpb19jb25maWcuaCIKLSNpbmNsdWRlIDxsaW51eC92aXJ0aW9faWRzLmg+CiAjaW5jbHVkZSAibGludXgvdmlydGlvX25ldC5oIgogI2luY2x1ZGUgImxpbnV4L3ZpcnRpb19ibGsuaCIKICNpbmNsdWRlICJsaW51eC92aXJ0aW9fY29uc29sZS5oIgpkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9zY3NpL2hwdGlvcC50eHQgYi9Eb2N1bWVudGF0aW9uL3Njc2kvaHB0aW9wLnR4dAppbmRleCBhNmViNGFkLi45NjA1MTc5IDEwMDY0NAotLS0gYS9Eb2N1bWVudGF0aW9uL3Njc2kvaHB0aW9wLnR4dAorKysgYi9Eb2N1bWVudGF0aW9uL3Njc2kvaHB0aW9wLnR4dApAQCAtMyw2ICszLDI1IEBACiBDb250cm9sbGVyIFJlZ2lzdGVyIE1hcAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogCitGb3IgUlI0NHh4IEludGVsIElPUCBiYXNlZCBhZGFwdGVycywgdGhlIGNvbnRyb2xsZXIgSU9QIGlzIGFjY2Vzc2VkIHZpYSBQQ0kgQkFSMCBhbmQgQkFSMjoKKworICAgICBCQVIwIG9mZnNldCAgICBSZWdpc3RlcgorICAgICAgICAgICAgMHgxMUM1QyBMaW5rIEludGVyZmFjZSBJUlEgU2V0CisgICAgICAgICAgICAweDExQzYwIExpbmsgSW50ZXJmYWNlIElSUSBDbGVhcgorCisgICAgIEJBUjIgb2Zmc2V0ICAgIFJlZ2lzdGVyCisgICAgICAgICAgICAweDEwICAgIEluYm91bmQgTWVzc2FnZSBSZWdpc3RlciAwCisgICAgICAgICAgICAweDE0ICAgIEluYm91bmQgTWVzc2FnZSBSZWdpc3RlciAxCisgICAgICAgICAgICAweDE4ICAgIE91dGJvdW5kIE1lc3NhZ2UgUmVnaXN0ZXIgMAorICAgICAgICAgICAgMHgxQyAgICBPdXRib3VuZCBNZXNzYWdlIFJlZ2lzdGVyIDEKKyAgICAgICAgICAgIDB4MjAgICAgSW5ib3VuZCBEb29yYmVsbCBSZWdpc3RlcgorICAgICAgICAgICAgMHgyNCAgICBJbmJvdW5kIEludGVycnVwdCBTdGF0dXMgUmVnaXN0ZXIKKyAgICAgICAgICAgIDB4MjggICAgSW5ib3VuZCBJbnRlcnJ1cHQgTWFzayBSZWdpc3RlcgorICAgICAgICAgICAgMHgzMCAgICBPdXRib3VuZCBJbnRlcnJ1cHQgU3RhdHVzIFJlZ2lzdGVyCisgICAgICAgICAgICAweDM0ICAgIE91dGJvdW5kIEludGVycnVwdCBNYXNrIFJlZ2lzdGVyCisgICAgICAgICAgICAweDQwICAgIEluYm91bmQgUXVldWUgUG9ydAorICAgICAgICAgICAgMHg0NCAgICBPdXRib3VuZCBRdWV1ZSBQb3J0CisKIEZvciBJbnRlbCBJT1AgYmFzZWQgYWRhcHRlcnMsIHRoZSBjb250cm9sbGVyIElPUCBpcyBhY2Nlc3NlZCB2aWEgUENJIEJBUjA6CiAKICAgICAgQkFSMCBvZmZzZXQgICAgUmVnaXN0ZXIKQEAgLTkzLDcgKzExMiw3IEBACiAKIAogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLUNvcHlyaWdodCAoQykgMjAwNi0yMDA3IEhpZ2hQb2ludCBUZWNobm9sb2dpZXMsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KK0NvcHlyaWdodCAoQykgMjAwNi0yMDA5IEhpZ2hQb2ludCBUZWNobm9sb2dpZXMsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KIAogICBUaGlzIGZpbGUgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vc291bmQvYWxzYS9IRC1BdWRpby1Nb2RlbHMudHh0IGIvRG9jdW1lbnRhdGlvbi9zb3VuZC9hbHNhL0hELUF1ZGlvLU1vZGVscy50eHQKaW5kZXggNzVmZGRiNC4uNGM3ZjlhZSAxMDA2NDQKLS0tIGEvRG9jdW1lbnRhdGlvbi9zb3VuZC9hbHNhL0hELUF1ZGlvLU1vZGVscy50eHQKKysrIGIvRG9jdW1lbnRhdGlvbi9zb3VuZC9hbHNhL0hELUF1ZGlvLU1vZGVscy50eHQKQEAgLTM1OSw2ICszNTksNyBAQAogICA1c3RhY2stbm8tZnAJRDk2NSA1c3RhY2sgd2l0aG91dCBmcm9udCBwYW5lbAogICBkZWxsLTNzdGFjawlEZWxsIERpbWVuc2lvbiBFNTIwCiAgIGRlbGwtYmlvcwlGaXhlcyB3aXRoIERlbGwgQklPUyBzZXR1cAorICB2b2xrbm9iCUZpeGVzIHdpdGggdm9sdW1lLWtub2Igd2lkZ2V0IDB4MjQKICAgYXV0bwkJQklPUyBzZXR1cCAoZGVmYXVsdCkKIAogU1RBQzkySEQ3MUIqCmRpZmYgLS1naXQgYS9NQUlOVEFJTkVSUyBiL01BSU5UQUlORVJTCmluZGV4IGUxZGE5MjUuLmVjZTlmNjAgMTAwNjQ0Ci0tLSBhL01BSU5UQUlORVJTCisrKyBiL01BSU5UQUlORVJTCkBAIC02NSw0MyArNjUsNTEgQEAKIAogOC4JSGFwcHkgaGFja2luZy4KIAotCQktLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorRGVzY3JpcHRpb25zIG9mIHNlY3Rpb24gZW50cmllczoKIAotTWFpbnRhaW5lcnMgTGlzdCAodHJ5IHRvIGxvb2sgZm9yIG1vc3QgcHJlY2lzZSBhcmVhcyBmaXJzdCkKKwlQOiBQZXJzb24gKG9ic29sZXRlKQorCU06IE1haWwgcGF0Y2hlcyB0bzogRnVsbE5hbWUgPGFkZHJlc3NAZG9tYWluPgorCUw6IE1haWxpbmcgbGlzdCB0aGF0IGlzIHJlbGV2YW50IHRvIHRoaXMgYXJlYQorCVc6IFdlYi1wYWdlIHdpdGggc3RhdHVzL2luZm8KKwlUOiBTQ00gdHJlZSB0eXBlIGFuZCBsb2NhdGlvbi4gIFR5cGUgaXMgb25lIG9mOiBnaXQsIGhnLCBxdWlsdCwgc3RnaXQuCisJUzogU3RhdHVzLCBvbmUgb2YgdGhlIGZvbGxvd2luZzoKKwkgICBTdXBwb3J0ZWQ6CVNvbWVvbmUgaXMgYWN0dWFsbHkgcGFpZCB0byBsb29rIGFmdGVyIHRoaXMuCisJICAgTWFpbnRhaW5lZDoJU29tZW9uZSBhY3R1YWxseSBsb29rcyBhZnRlciBpdC4KKwkgICBPZGQgRml4ZXM6CUl0IGhhcyBhIG1haW50YWluZXIgYnV0IHRoZXkgZG9uJ3QgaGF2ZSB0aW1lIHRvIGRvCisJCQltdWNoIG90aGVyIHRoYW4gdGhyb3cgdGhlIG9kZCBwYXRjaCBpbi4gU2VlIGJlbG93Li4KKwkgICBPcnBoYW46CU5vIGN1cnJlbnQgbWFpbnRhaW5lciBbYnV0IG1heWJlIHlvdSBjb3VsZCB0YWtlIHRoZQorCQkJcm9sZSBhcyB5b3Ugd3JpdGUgeW91ciBuZXcgY29kZV0uCisJICAgT2Jzb2xldGU6CU9sZCBjb2RlLiBTb21ldGhpbmcgdGFnZ2VkIG9ic29sZXRlIGdlbmVyYWxseSBtZWFucworCQkJaXQgaGFzIGJlZW4gcmVwbGFjZWQgYnkgYSBiZXR0ZXIgc3lzdGVtIGFuZCB5b3UKKwkJCXNob3VsZCBiZSB1c2luZyB0aGF0LgorCUY6IEZpbGVzIGFuZCBkaXJlY3RvcmllcyB3aXRoIHdpbGRjYXJkIHBhdHRlcm5zLgorCSAgIEEgdHJhaWxpbmcgc2xhc2ggaW5jbHVkZXMgYWxsIGZpbGVzIGFuZCBzdWJkaXJlY3RvcnkgZmlsZXMuCisJICAgRjoJZHJpdmVycy9uZXQvCWFsbCBmaWxlcyBpbiBhbmQgYmVsb3cgZHJpdmVycy9uZXQKKwkgICBGOglkcml2ZXJzL25ldC8qCWFsbCBmaWxlcyBpbiBkcml2ZXJzL25ldCwgYnV0IG5vdCBiZWxvdworCSAgIEY6CSovbmV0LyoJCWFsbCBmaWxlcyBpbiAiYW55IHRvcCBsZXZlbCBkaXJlY3RvcnkiL25ldAorCSAgIE9uZSBwYXR0ZXJuIHBlciBsaW5lLiAgTXVsdGlwbGUgRjogbGluZXMgYWNjZXB0YWJsZS4KKwlYOiBGaWxlcyBhbmQgZGlyZWN0b3JpZXMgdGhhdCBhcmUgTk9UIG1haW50YWluZWQsIHNhbWUgcnVsZXMgYXMgRjoKKwkgICBGaWxlcyBleGNsdXNpb25zIGFyZSB0ZXN0ZWQgYmVmb3JlIGZpbGUgbWF0Y2hlcy4KKwkgICBDYW4gYmUgdXNlZnVsIGZvciBleGNsdWRpbmcgYSBzcGVjaWZpYyBzdWJkaXJlY3RvcnksIGZvciBpbnN0YW5jZToKKwkgICBGOgluZXQvCisJICAgWDoJbmV0L2lwdjYvCisJICAgbWF0Y2hlcyBhbGwgZmlsZXMgaW4gYW5kIGJlbG93IG5ldCBleGNsdWRpbmcgbmV0L2lwdjYvCisJSzogS2V5d29yZCBwZXJsIGV4dGVuZGVkIHJlZ2V4IHBhdHRlcm4gdG8gbWF0Y2ggY29udGVudCBpbiBhCisJICAgcGF0Y2ggb3IgZmlsZS4gIEZvciBpbnN0YW5jZToKKwkgICBLOiBvZl9nZXRfcHJvZmlsZQorCSAgICAgIG1hdGNoZXMgcGF0Y2hlcyBvciBmaWxlcyB0aGF0IGNvbnRhaW4gIm9mX2dldF9wcm9maWxlIgorCSAgIEs6IFxiKHByaW50a3xwcl8oaW5mb3xlcnIpKVxiCisJICAgICAgbWF0Y2hlcyBwYXRjaGVzIG9yIGZpbGVzIHRoYXQgY29udGFpbiBvbmUgb3IgbW9yZSBvZiB0aGUgd29yZHMKKwkgICAgICBwcmludGssIHByX2luZm8gb3IgcHJfZXJyCisJICAgT25lIHJlZ2V4IHBhdHRlcm4gcGVyIGxpbmUuICBNdWx0aXBsZSBLOiBsaW5lcyBhY2NlcHRhYmxlLgogCiBOb3RlOiBGb3IgdGhlIGhhcmQgb2YgdGhpbmtpbmcsIHRoaXMgbGlzdCBpcyBtZWFudCB0byByZW1haW4gaW4gYWxwaGFiZXRpY2FsCiBvcmRlci4gSWYgeW91IGNvdWxkIGFkZCB5b3Vyc2VsdmVzIHRvIGl0IGluIGFscGhhYmV0aWNhbCBvcmRlciB0aGF0IHdvdWxkIGJlCiBzbyBtdWNoIGVhc2llciBbRWRdCiAKLVA6IFBlcnNvbiAob2Jzb2xldGUpCi1NOiBNYWlsIHBhdGNoZXMgdG86IEZ1bGxOYW1lIDxhZGRyZXNzQGRvbWFpbj4KLUw6IE1haWxpbmcgbGlzdCB0aGF0IGlzIHJlbGV2YW50IHRvIHRoaXMgYXJlYQotVzogV2ViLXBhZ2Ugd2l0aCBzdGF0dXMvaW5mbwotVDogU0NNIHRyZWUgdHlwZSBhbmQgbG9jYXRpb24uICBUeXBlIGlzIG9uZSBvZjogZ2l0LCBoZywgcXVpbHQsIHN0Z2l0LgotUzogU3RhdHVzLCBvbmUgb2YgdGhlIGZvbGxvd2luZzoKK01haW50YWluZXJzIExpc3QgKHRyeSB0byBsb29rIGZvciBtb3N0IHByZWNpc2UgYXJlYXMgZmlyc3QpCiAKLQlTdXBwb3J0ZWQ6CVNvbWVvbmUgaXMgYWN0dWFsbHkgcGFpZCB0byBsb29rIGFmdGVyIHRoaXMuCi0JTWFpbnRhaW5lZDoJU29tZW9uZSBhY3R1YWxseSBsb29rcyBhZnRlciBpdC4KLQlPZGQgRml4ZXM6CUl0IGhhcyBhIG1haW50YWluZXIgYnV0IHRoZXkgZG9uJ3QgaGF2ZSB0aW1lIHRvIGRvCi0JCQltdWNoIG90aGVyIHRoYW4gdGhyb3cgdGhlIG9kZCBwYXRjaCBpbi4gU2VlIGJlbG93Li4KLQlPcnBoYW46CQlObyBjdXJyZW50IG1haW50YWluZXIgW2J1dCBtYXliZSB5b3UgY291bGQgdGFrZSB0aGUKLQkJCXJvbGUgYXMgeW91IHdyaXRlIHlvdXIgbmV3IGNvZGVdLgotCU9ic29sZXRlOglPbGQgY29kZS4gU29tZXRoaW5nIHRhZ2dlZCBvYnNvbGV0ZSBnZW5lcmFsbHkgbWVhbnMKLQkJCWl0IGhhcyBiZWVuIHJlcGxhY2VkIGJ5IGEgYmV0dGVyIHN5c3RlbSBhbmQgeW91Ci0JCQlzaG91bGQgYmUgdXNpbmcgdGhhdC4KLQotRjogRmlsZXMgYW5kIGRpcmVjdG9yaWVzIHdpdGggd2lsZGNhcmQgcGF0dGVybnMuCi0gICBBIHRyYWlsaW5nIHNsYXNoIGluY2x1ZGVzIGFsbCBmaWxlcyBhbmQgc3ViZGlyZWN0b3J5IGZpbGVzLgotCUY6CWRyaXZlcnMvbmV0LwlhbGwgZmlsZXMgaW4gYW5kIGJlbG93IGRyaXZlcnMvbmV0Ci0JRjoJZHJpdmVycy9uZXQvKglhbGwgZmlsZXMgaW4gZHJpdmVycy9uZXQsIGJ1dCBub3QgYmVsb3cKLQlGOgkqL25ldC8qCQlhbGwgZmlsZXMgaW4gImFueSB0b3AgbGV2ZWwgZGlyZWN0b3J5Ii9uZXQKLSAgIE9uZSBwYXR0ZXJuIHBlciBsaW5lLiAgTXVsdGlwbGUgRjogbGluZXMgYWNjZXB0YWJsZS4KLVg6IEZpbGVzIGFuZCBkaXJlY3RvcmllcyB0aGF0IGFyZSBOT1QgbWFpbnRhaW5lZCwgc2FtZSBydWxlcyBhcyBGOgotICAgRmlsZXMgZXhjbHVzaW9ucyBhcmUgdGVzdGVkIGJlZm9yZSBmaWxlIG1hdGNoZXMuCi0gICBDYW4gYmUgdXNlZnVsIGZvciBleGNsdWRpbmcgYSBzcGVjaWZpYyBzdWJkaXJlY3RvcnksIGZvciBpbnN0YW5jZToKLQlGOgluZXQvCi0JWDoJbmV0L2lwdjYvCi0gICBtYXRjaGVzIGFsbCBmaWxlcyBpbiBhbmQgYmVsb3cgbmV0IGV4Y2x1ZGluZyBuZXQvaXB2Ni8KKwkJLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIAogM0M1MDUgTkVUV09SSyBEUklWRVIKIE06CVBoaWxpcCBCbHVuZGVsbCA8cGhpbGJAZ251Lm9yZz4KQEAgLTU3Nyw2ICs1ODUsMTEgQEAKIEw6CWxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZyAobW9kZXJhdGVkIGZvciBub24tc3Vic2NyaWJlcnMpCiBTOglNYWludGFpbmVkCiAKK0FSTS9DT05URUMgTUlDUk85IE1BQ0hJTkUgU1VQUE9SVAorTToJSHViZXJ0IEZldXJzdGVpbiA8aHViZXJ0LmZldXJzdGVpbkBjb250ZWMuYXQ+CitTOglNYWludGFpbmVkCitGOglhcmNoL2FybS9tYWNoLWVwOTN4eC9taWNybzkuYworCiBBUk0vQ09SR0kgTUFDSElORSBTVVBQT1JUCiBNOglSaWNoYXJkIFB1cmRpZSA8cnB1cmRpZUBycHN5cy5uZXQ+CiBTOglNYWludGFpbmVkCkBAIC05ODcsNyArMTAwMCw3IEBACiAKIEFUTQogTToJQ2hhcyBXaWxsaWFtcyA8Y2hhc0BjbWYubnJsLm5hdnkubWlsPgotTDoJbGludXgtYXRtLWdlbmVyYWxAbGlzdHMuc291cmNlZm9yZ2UubmV0IChzdWJzY3JpYmVycy1vbmx5KQorTDoJbGludXgtYXRtLWdlbmVyYWxAbGlzdHMuc291cmNlZm9yZ2UubmV0IChtb2RlcmF0ZWQgZm9yIG5vbi1zdWJzY3JpYmVycykKIEw6CW5ldGRldkB2Z2VyLmtlcm5lbC5vcmcKIFc6CWh0dHA6Ly9saW51eC1hdG0uc291cmNlZm9yZ2UubmV0CiBTOglNYWludGFpbmVkCkBAIC0xMjMxLDYgKzEyNDQsMTMgQEAKIFM6CVN1cHBvcnRlZAogRjoJZHJpdmVycy9uZXQvdGczLioKIAorQlJPQ0FERSBCRkEgRkMgU0NTSSBEUklWRVIKK1A6ICAgICAgSmluZyBIdWFuZworTTogICAgICBodWFuZ2pAYnJvY2FkZS5jb20KK0w6ICAgICAgbGludXgtc2NzaUB2Z2VyLmtlcm5lbC5vcmcKK1M6ICAgICAgU3VwcG9ydGVkCitGOiAgICAgIGRyaXZlcnMvc2NzaS9iZmEvCisKIEJTRyAoYmxvY2sgbGF5ZXIgZ2VuZXJpYyBzZyB2NCBkcml2ZXIpCiBNOglGVUpJVEEgVG9tb25vcmkgPGZ1aml0YS50b21vbm9yaUBsYWIubnR0LmNvLmpwPgogTDoJbGludXgtc2NzaUB2Z2VyLmtlcm5lbC5vcmcKQEAgLTIwNTgsNyArMjA3OCw3IEBACiBGOglmcy8qCiAKIEZJTlRFSyBGNzUzNzVTIEhBUkRXQVJFIE1PTklUT1IgQU5EIEZBTiBDT05UUk9MTEVSIERSSVZFUgotTToJUmlrdSBWb2lwaW8gPHJpa3UudmlwaW9AaWtpLmZpPgorTToJUmlrdSBWb2lwaW8gPHJpa3Uudm9pcGlvQGlraS5maT4KIEw6CWxtLXNlbnNvcnNAbG0tc2Vuc29ycy5vcmcKIFM6CU1haW50YWluZWQKIEY6CWRyaXZlcnMvaHdtb24vZjc1Mzc1cy5jCkBAIC0yMTM5LDcgKzIxNTksNyBAQAogRjoJYXJjaC9wb3dlcnBjL3N5c2Rldi9xZV9saWIvCiBGOglhcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vKnFlLmgKIAotRlJFRVNDQUxFIFVTQiBQRVJJUEhFUklBTCBEUklWRVJTCitGUkVFU0NBTEUgVVNCIFBFUklQSEVSQUwgRFJJVkVSUwogTToJTGkgWWFuZyA8bGVvbGlAZnJlZXNjYWxlLmNvbT4KIEw6CWxpbnV4LXVzYkB2Z2VyLmtlcm5lbC5vcmcKIEw6CWxpbnV4cHBjLWRldkBvemxhYnMub3JnCkBAIC0yMTkwLDE4ICsyMjEwLDYgQEAKIEY6CWZzL2ZzY2FjaGUvCiBGOglpbmNsdWRlL2xpbnV4L2ZzY2FjaGUqLmgKIAotVFJBQ0lORwotTToJU3RldmVuIFJvc3RlZHQgPHJvc3RlZHRAZ29vZG1pcy5vcmc+Ci1NOglGcmVkZXJpYyBXZWlzYmVja2VyIDxmd2Vpc2JlY0BnbWFpbC5jb20+Ci1NOglJbmdvIE1vbG5hciA8bWluZ29AcmVkaGF0LmNvbT4KLVQ6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvdGlwL2xpbnV4LTIuNi10aXAuZ2l0IHRyYWNpbmcvY29yZQotUzoJTWFpbnRhaW5lZAotRjoJRG9jdW1lbnRhdGlvbi90cmFjZS9mdHJhY2UudHh0Ci1GOglhcmNoLyovKi8qL2Z0cmFjZS5oCi1GOglhcmNoLyova2VybmVsL2Z0cmFjZS5jCi1GOglpbmNsdWRlLyovZnRyYWNlLmggaW5jbHVkZS90cmFjZS8gaW5jbHVkZS9saW51eC90cmFjZSouaAotRjoJa2VybmVsL3RyYWNlLwotCiBGVUpJVFNVIEZSLVYgKEZSVikgUE9SVAogTToJRGF2aWQgSG93ZWxscyA8ZGhvd2VsbHNAcmVkaGF0LmNvbT4KIFM6CU1haW50YWluZWQKQEAgLTIyNjAsOSArMjI2OCw4IEBACiBGOglpbmNsdWRlL2FzbS1nZW5lcmljCiAKIEdFTkVSSUMgVUlPIERSSVZFUiBGT1IgUENJIERFVklDRVMKLU06CU1pY2hhZWwgUy4gVHNpcmtpbiA8bXN0QHJlZGhhdC5jb20+CitNOgkiTWljaGFlbCBTLiBUc2lya2luIiA8bXN0QHJlZGhhdC5jb20+CiBMOglrdm1Admdlci5rZXJuZWwub3JnCi1MOglsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCiBTOglTdXBwb3J0ZWQKIEY6CWRyaXZlcnMvdWlvL3Vpb19wY2lfZ2VuZXJpYy5jCiAKQEAgLTI2MDMsNiArMjYxMCw3IEBACiBXOglodHRwOi8vd3d3LmxpbnV4MTM5NC5vcmcvCiBUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L2llZWUxMzk0L2xpbnV4MTM5NC0yLjYuZ2l0CiBTOglNYWludGFpbmVkCitGOglEb2N1bWVudGF0aW9uL2RlYnVnZ2luZy12aWEtb2hjaTEzOTQudHh0CiBGOglkcml2ZXJzL2llZWUxMzk0LwogCiBJRUVFIDEzOTQgUkFXIEkvTyBEUklWRVIKQEAgLTI5OTEsOCArMjk5OSw4IEBACiAKIEtFUk5FTCBKQU5JVE9SUwogTDoJa2VybmVsLWphbml0b3JzQHZnZXIua2VybmVsLm9yZwotVzoJaHR0cDovL3d3dy5rZXJuZWxqYW5pdG9ycy5vcmcvCi1TOglNYWludGFpbmVkCitXOglodHRwOi8vamFuaXRvci5rZXJuZWxuZXdiaWVzLm9yZy8KK1M6CU9kZCBGaXhlcwogCiBLRVJORUwgTkZTRCwgU1VOUlBDLCBBTkQgTE9DS0QgU0VSVkVSUwogTToJIkouIEJydWNlIEZpZWxkcyIgPGJmaWVsZHNAZmllbGRzZXMub3JnPgpAQCAtMzY1NCw2ICszNjYyLDcgQEAKIE06CSJEYXZpZCBTLiBNaWxsZXIiIDxkYXZlbUBkYXZlbWxvZnQubmV0PgogTDoJbmV0ZGV2QHZnZXIua2VybmVsLm9yZwogVzoJaHR0cDovL3d3dy5saW51eGZvdW5kYXRpb24ub3JnL2VuL05ldAorVzoJaHR0cDovL3BhdGNod29yay5vemxhYnMub3JnL3Byb2plY3QvbmV0ZGV2L2xpc3QvCiBUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L2RhdmVtL25ldC0yLjYuZ2l0CiBTOglNYWludGFpbmVkCiBGOgluZXQvCkBAIC0zNzcxLDcgKzM3ODAsNyBAQAogRjoJZHJpdmVycy92aWRlby9udmlkaWEvCiAKIE9NQVAgU1VQUE9SVAotTToJIlRvbnkgTGluZGdyZW4gPHRvbnlAYXRvbWlkZS5jb20+IiA8dG9ueUBhdG9taWRlLmNvbT4KK006CVRvbnkgTGluZGdyZW4gPHRvbnlAYXRvbWlkZS5jb20+CiBMOglsaW51eC1vbWFwQHZnZXIua2VybmVsLm9yZwogVzoJaHR0cDovL3d3dy5tdXJ1LmNvbS9saW51eC9vbWFwLwogVzoJaHR0cDovL2xpbnV4Lm9tYXAuY29tLwpAQCAtMzg3Niw2ICszODg1LDE1IEBACiBGOglEb2N1bWVudGF0aW9uL2kyYy9idXNzZXMvaTJjLW9jb3JlcwogRjoJZHJpdmVycy9pMmMvYnVzc2VzL2kyYy1vY29yZXMuYwogCitPUEVOIEZJUk1XQVJFIEFORCBGTEFUVEVORUQgREVWSUNFIFRSRUUKK006CUdyYW50IExpa2VseSA8Z3JhbnQubGlrZWx5QHNlY3JldGxhYi5jYT4KK0w6CWRldmljZXRyZWUtZGlzY3Vzc0BsaXN0cy5vemxhYnMub3JnCitXOglodHRwOi8vZmR0LnNlY3JldGxhYi5jYQorUzoJTWFpbnRhaW5lZAorRjoJZHJpdmVycy9vZgorRjoJaW5jbHVkZS9saW51eC9vZiouaAorSzoJb2ZfZ2V0X3Byb3BlcnR5CisKIE9QUk9GSUxFCiBNOglSb2JlcnQgUmljaHRlciA8cm9iZXJ0LnJpY2h0ZXJAYW1kLmNvbT4KIEw6CW9wcm9maWxlLWxpc3RAbGlzdHMuc2YubmV0CkBAIC00MDY0LDYgKzQwODIsMTMgQEAKIE06CVBhdWwgTWFja2VycmFzIDxwYXVsdXNAc2FtYmEub3JnPgogTToJSW5nbyBNb2xuYXIgPG1pbmdvQGVsdGUuaHU+CiBTOglTdXBwb3J0ZWQKK0Y6CWtlcm5lbC9wZXJmX2V2ZW50LmMKK0Y6CWluY2x1ZGUvbGludXgvcGVyZl9ldmVudC5oCitGOglhcmNoLyovKi9rZXJuZWwvcGVyZl9ldmVudC5jCitGOglhcmNoLyovaW5jbHVkZS9hc20vcGVyZl9ldmVudC5oCitGOglhcmNoLyovbGliL3BlcmZfZXZlbnQuYworRjoJYXJjaC8qL2tlcm5lbC9wZXJmX2NhbGxjaGFpbi5jCitGOgl0b29scy9wZXJmLwogCiBQRVJTT05BTElUWSBIQU5ETElORwogTToJQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBpbmZyYWRlYWQub3JnPgpAQCAtNDMwNCw3ICs0MzI5LDcgQEAKIFJBTElOSyBSVDJYMDAgV0lSRUxFU1MgTEFOIERSSVZFUgogUDoJcnQyeDAwIHByb2plY3QKIEw6CWxpbnV4LXdpcmVsZXNzQHZnZXIua2VybmVsLm9yZwotTDoJdXNlcnNAcnQyeDAwLnNlcmlhbG1vbmtleS5jb20KK0w6CXVzZXJzQHJ0MngwMC5zZXJpYWxtb25rZXkuY29tIChtb2RlcmF0ZWQgZm9yIG5vbi1zdWJzY3JpYmVycykKIFc6CWh0dHA6Ly9ydDJ4MDAuc2VyaWFsbW9ua2V5LmNvbS8KIFM6CU1haW50YWluZWQKIFQ6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvaXZkL3J0MngwMC5naXQKQEAgLTQ1MTMsMTIgKzQ1MzgsMTEgQEAKIEY6CWluY2x1ZGUvbGludXgvc2NoZWQuaAogCiBTQ09SRSBBUkNISVRFQ1RVUkUKLVA6CUNoZW4gTGlxaW4KLU06CWxpcWluLmNoZW5Ac3VucGx1c2N0LmNvbQotUDoJTGVubm94IFd1Ci1NOglsZW5ub3gud3VAZ21haWwuY29tCitNOglDaGVuIExpcWluIDxsaXFpbi5jaGVuQHN1bnBsdXNjdC5jb20+CitNOglMZW5ub3ggV3UgPGxlbm5veC53dUBnbWFpbC5jb20+CiBXOglodHRwOi8vd3d3LnN1bnBsdXNjdC5jb20KIFM6CVN1cHBvcnRlZAorRjoJYXJjaC9zY29yZS8KIAogU0NTSSBDRFJPTSBEUklWRVIKIE06CUplbnMgQXhib2UgPGF4Ym9lQGtlcm5lbC5kaz4KQEAgLTQ1OTEsMjAgKzQ2MTUsMjAgQEAKIEY6CWRyaXZlcnMvbW1jL2hvc3Qvc2RyaWNvaF9jcy5jCiAKIFNFQ1VSRSBESUdJVEFMIEhPU1QgQ09OVFJPTExFUiBJTlRFUkZBQ0UgKFNESENJKSBEUklWRVIKLVM6ICAgICBPcnBoYW4KLUw6ICAgICBsaW51eC1tbWNAdmdlci5rZXJuZWwub3JnCi1GOiAgICAgZHJpdmVycy9tbWMvaG9zdC9zZGhjaS4qCitTOglPcnBoYW4KK0w6CWxpbnV4LW1tY0B2Z2VyLmtlcm5lbC5vcmcKK0Y6CWRyaXZlcnMvbW1jL2hvc3Qvc2RoY2kuKgogCiBTRUNVUkUgRElHSVRBTCBIT1NUIENPTlRST0xMRVIgSU5URVJGQUNFLCBPUEVOIEZJUk1XQVJFIEJJTkRJTkdTIChTREhDSS1PRikKIE06CUFudG9uIFZvcm9udHNvdiA8YXZvcm9udHNvdkBydS5tdmlzdGEuY29tPgogTDoJbGludXhwcGMtZGV2QG96bGFicy5vcmcKLUw6ICAgICBsaW51eC1tbWNAdmdlci5rZXJuZWwub3JnCitMOglsaW51eC1tbWNAdmdlci5rZXJuZWwub3JnCiBTOglNYWludGFpbmVkCi1GOiAgICAgZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1vZi4qCitGOglkcml2ZXJzL21tYy9ob3N0L3NkaGNpLW9mLioKIAogU0VDVVJFIERJR0lUQUwgSE9TVCBDT05UUk9MTEVSIElOVEVSRkFDRSAoU0RIQ0kpIFNBTVNVTkcgRFJJVkVSCiBNOglCZW4gRG9va3MgPGJlbi1saW51eEBmbHVmZi5vcmc+Ci1MOiAgICAgbGludXgtbW1jQHZnZXIua2VybmVsLm9yZworTDoJbGludXgtbW1jQHZnZXIua2VybmVsLm9yZwogUzoJTWFpbnRhaW5lZAogRjoJZHJpdmVycy9tbWMvaG9zdC9zZGhjaS1zM2MuYwogCkBAIC00NjQ2LDYgKzQ2NzAsMTQgQEAKIEY6CWluY2x1ZGUvbGludXgvYXRhLmgKIEY6CWluY2x1ZGUvbGludXgvbGliYXRhLmgKIAorU0VSVkVSIEVOR0lORVMgMTBHYnBzIGlTQ1NJIC0gQmxhZGVFbmdpbmUgMiBEUklWRVIKK1A6ICAgICBKYXlhbW9oYW4gS2FsbGlja2FsCitNOiAgICAgamF5YW1vaGFua0BzZXJ2ZXJlbmdpbmVzLmNvbQorTDogICAgIGxpbnV4LXNjc2lAdmdlci5rZXJuZWwub3JnCitXOiAgICAgaHR0cDovL3d3dy5zZXJ2ZXJlbmdpbmVzLmNvbQorUzogICAgIFN1cHBvcnRlZAorRjogICAgIGRyaXZlcnMvc2NzaS9iZTJpc2NzaS8KKwogU0VSVkVSIEVOR0lORVMgMTBHYnBzIE5JQyAtIEJsYWRlRW5naW5lIDIgRFJJVkVSCiBNOglTYXRoeWEgUGVybGEgPHNhdGh5YXBAc2VydmVyZW5naW5lcy5jb20+CiBNOglTdWJidSBTZWV0aGFyYW1hbiA8c3ViYnVzQHNlcnZlcmVuZ2luZXMuY29tPgpAQCAtNDY5OSw4ICs0NzMxLDcgQEAKIEY6CWRyaXZlcnMvdXNiL2hvc3Qvb2hjaS1saDdhNDAqCiAKIFNJTVBMRSBGSVJNV0FSRSBJTlRFUkZBQ0UgKFNGSSkKLVA6CUxlbiBCcm93bgotTToJbGVuYkBrZXJuZWwub3JnCitNOglMZW4gQnJvd24gPGxlbmJAa2VybmVsLm9yZz4KIEw6CXNmaS1kZXZlbEBzaW1wbGVmaXJtd2FyZS5vcmcKIFc6CWh0dHA6Ly9zaW1wbGVmaXJtd2FyZS5vcmcvCiBUOglnaXQgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9rZXJuZWwvZ2l0L2xlbmIvbGludXgtc2ZpLTIuNi5naXQKQEAgLTUxNDgsNiArNTE3OSwyMCBAQAogUzoJTWFpbnRhaW5lZAogRjoJZHJpdmVycy9jaGFyL3RwbS8KIAorVFJBQ0lORworTToJU3RldmVuIFJvc3RlZHQgPHJvc3RlZHRAZ29vZG1pcy5vcmc+CitNOglGcmVkZXJpYyBXZWlzYmVja2VyIDxmd2Vpc2JlY0BnbWFpbC5jb20+CitNOglJbmdvIE1vbG5hciA8bWluZ29AcmVkaGF0LmNvbT4KK1Q6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvdGlwL2xpbnV4LTIuNi10aXAuZ2l0IHRyYWNpbmcvY29yZQorUzoJTWFpbnRhaW5lZAorRjoJRG9jdW1lbnRhdGlvbi90cmFjZS9mdHJhY2UudHh0CitGOglhcmNoLyovKi8qL2Z0cmFjZS5oCitGOglhcmNoLyova2VybmVsL2Z0cmFjZS5jCitGOglpbmNsdWRlLyovZnRyYWNlLmgKK0Y6CWluY2x1ZGUvbGludXgvdHJhY2UqLmgKK0Y6CWluY2x1ZGUvdHJhY2UvCitGOglrZXJuZWwvdHJhY2UvCisKIFRSSVZJQUwgUEFUQ0hFUwogTToJSmlyaSBLb3NpbmEgPHRyaXZpYWxAa2VybmVsLm9yZz4KIFQ6CWdpdCBnaXQ6Ly9naXQua2VybmVsLm9yZy9wdWIvc2NtL2xpbnV4L2tlcm5lbC9naXQvamlrb3MvdHJpdmlhbC5naXQKQEAgLTU2MzYsNiArNTY4MSwxMyBAQAogRjoJZHJpdmVycy92bHlucS92bHlucS5jCiBGOglpbmNsdWRlL2xpbnV4L3ZseW5xLmgKIAorVk1XQVJFIFZNWE5FVDMgRVRIRVJORVQgRFJJVkVSCitNOiAgICAgU2hyZXlhcyBCaGF0ZXdhcmEgPHNiaGF0ZXdhcmFAdm13YXJlLmNvbT4KK006ICAgICBWTXdhcmUsIEluYy4gPHB2LWRyaXZlcnNAdm13YXJlLmNvbT4KK0w6ICAgICBuZXRkZXZAdmdlci5rZXJuZWwub3JnCitTOiAgICAgTWFpbnRhaW5lZAorRjogICAgIGRyaXZlcnMvbmV0L3ZteG5ldDMvCisKIFZPTFRBR0UgQU5EIENVUlJFTlQgUkVHVUxBVE9SIEZSQU1FV09SSwogTToJTGlhbSBHaXJkd29vZCA8bHJnQHNsaW1sb2dpYy5jby51az4KIE06CU1hcmsgQnJvd24gPGJyb29uaWVAb3BlbnNvdXJjZS53b2xmc29ubWljcm8uY29tPgpAQCAtNTcwNyw4ICs1NzU5LDcgQEAKIEY6CWRyaXZlcnMvc2NzaS93ZDcwMDAuYwogCiBXSU5CT05EIENJUiBEUklWRVIKLVA6CURhdmlkIEjkcmRlbWFuCi1NOglkYXZpZEBoYXJkZW1hbi5udQorTToJRGF2aWQgSMOkcmRlbWFuIDxkYXZpZEBoYXJkZW1hbi5udT4KIFM6CU1haW50YWluZWQKIEY6CWRyaXZlcnMvaW5wdXQvbWlzYy93aW5ib25kLWNpci5jCiAKQEAgLTU3NjUsOSArNTgxNiw3IEBACiBGOglpbmNsdWRlL2xpbnV4L3dtOTd4eC5oCiAKIFdPTEZTT04gTUlDUk9FTEVDVFJPTklDUyBQTUlDIERSSVZFUlMKLVA6CU1hcmsgQnJvd24KLU06CWJyb29uaWVAb3BlbnNvdXJjZS53b2xmc29ubWljcm8uY29tCi1MOglsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCitNOglNYXJrIEJyb3duIDxicm9vbmllQG9wZW5zb3VyY2Uud29sZnNvbm1pY3JvLmNvbT4KIFQ6CWdpdCBnaXQ6Ly9vcGVuc291cmNlLndvbGZzb25taWNyby5jb20vbGludXgtMi42LWF1ZGlvcGx1cwogVzoJaHR0cDovL29wZW5zb3VyY2Uud29sZnNvbm1pY3JvLmNvbS9ub2RlLzgKIFM6CVN1cHBvcnRlZApkaWZmIC0tZ2l0IGEvTWFrZWZpbGUgYi9NYWtlZmlsZQppbmRleCBlNTA1NjlhLi45NDI1ZDFkIDEwMDY0NAotLS0gYS9NYWtlZmlsZQorKysgYi9NYWtlZmlsZQpAQCAtMSw3ICsxLDcgQEAKIFZFUlNJT04gPSAyCiBQQVRDSExFVkVMID0gNgogU1VCTEVWRUwgPSAzMgotRVhUUkFWRVJTSU9OID0gLXJjMworRVhUUkFWRVJTSU9OID0gLXJjNQogTkFNRSA9IE1hbi1FYXRpbmcgU2VhbHMgb2YgQW50aXF1aXR5CiAKICMgKkRPQ1VNRU5UQVRJT04qCkBAIC0xNzksNDYgKzE3OSw5IEBACiAjIEFsdGVybmF0aXZlbHkgQ1JPU1NfQ09NUElMRSBjYW4gYmUgc2V0IGluIHRoZSBlbnZpcm9ubWVudC4KICMgRGVmYXVsdCB2YWx1ZSBmb3IgQ1JPU1NfQ09NUElMRSBpcyBub3QgdG8gcHJlZml4IGV4ZWN1dGFibGVzCiAjIE5vdGU6IFNvbWUgYXJjaGl0ZWN0dXJlcyBhc3NpZ24gQ1JPU1NfQ09NUElMRSBpbiB0aGVpciBhcmNoLyovTWFrZWZpbGUKLSMKLSMgVG8gZm9yY2UgQVJDSCBhbmQgQ1JPU1NfQ09NUElMRSBzZXR0aW5ncyBpbmNsdWRlIGtlcm5lbC4qIGZpbGVzCi0jIGluIHRoZSBrZXJuZWwgdHJlZSAtIGRvIG5vdCBwYXRjaCB0aGlzIGZpbGUuCiBleHBvcnQgS0JVSUxEX0JVSUxESE9TVCA6PSAkKFNVQkFSQ0gpCi0KLSMgS2J1aWxkIHNhdmUgdGhlIEFSQ0ggYW5kIENST1NTX0NPTVBJTEUgc2V0dGluZyBpbiBrZXJuZWwuKiBmaWxlcy4KLSMgUmVzdG9yZSB0aGVzZSBzZXR0aW5ncyBhbmQgY2hlY2sgdGhhdCB1c2VyIGRpZCBub3Qgc3BlY2lmeQotIyBjb25mbGljdGluZyB2YWx1ZXMuCi0KLXNhdmVkX2FyY2ggIDo9ICQoc2hlbGwgY2F0IGluY2x1ZGUvZ2VuZXJhdGVkL2tlcm5lbC5hcmNoICAyPiAvZGV2L251bGwpCi1zYXZlZF9jcm9zcyA6PSAkKHNoZWxsIGNhdCBpbmNsdWRlL2dlbmVyYXRlZC9rZXJuZWwuY3Jvc3MgMj4gL2Rldi9udWxsKQotCi1pZm5lcSAoJChDUk9TU19DT01QSUxFKSwpCi0gICAgICAgIGlmbmVxICgkKHNhdmVkX2Nyb3NzKSwpCi0gICAgICAgICAgICAgICAgaWZuZXEgKCQoQ1JPU1NfQ09NUElMRSksJChzYXZlZF9jcm9zcykpCi0gICAgICAgICAgICAgICAgICAgICAgICAkKGVycm9yIENST1NTX0NPTVBJTEUgY2hhbmdlZCBmcm9tIFwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIiQoc2F2ZWRfY3Jvc3MpIiB0byBcCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB0byAiJChDUk9TU19DT01QSUxFKSIuIFwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVzZSAibWFrZSBtcnByb3BlciIgdG8gZml4IGl0IHVwKQotICAgICAgICAgICAgICAgIGVuZGlmCi0gICAgICAgIGVuZGlmCi1lbHNlCi0gICAgQ1JPU1NfQ09NUElMRSA6PSAkKHNhdmVkX2Nyb3NzKQotZW5kaWYKLQotaWZuZXEgKCQoQVJDSCksKQotICAgICAgICBpZm5lcSAoJChzYXZlZF9hcmNoKSwpCi0gICAgICAgICAgICAgICAgaWZuZXEgKCQoc2F2ZWRfYXJjaCksJChBUkNIKSkKLSAgICAgICAgICAgICAgICAgICAgICAgICQoZXJyb3IgQVJDSCBjaGFuZ2VkIGZyb20gXAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiJChzYXZlZF9hcmNoKSIgdG8gIiQoQVJDSCkiLiBcCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVc2UgIm1ha2UgbXJwcm9wZXIiIHRvIGZpeCBpdCB1cCkKLSAgICAgICAgICAgICAgICBlbmRpZgotICAgICAgICBlbmRpZgotZWxzZQotICAgICAgICBpZm5lcSAoJChzYXZlZF9hcmNoKSwpCi0gICAgICAgICAgICAgICAgQVJDSCA6PSAkKHNhdmVkX2FyY2gpCi0gICAgICAgIGVsc2UKLSAgICAgICAgICAgICAgICBBUkNIIDo9ICQoU1VCQVJDSCkKLSAgICAgICAgZW5kaWYKLWVuZGlmCitBUkNICQk/PSAkKFNVQkFSQ0gpCitDUk9TU19DT01QSUxFCT89CiAKICMgQXJjaGl0ZWN0dXJlIGFzIHByZXNlbnQgaW4gY29tcGlsZS5oCiBVVFNfTUFDSElORSAJOj0gJChBUkNIKQpAQCAtNDgzLDExICs0NDYsNiBAQAogaW5jbHVkZSAkKHNyY3RyZWUpL2FyY2gvJChTUkNBUkNIKS9NYWtlZmlsZQogZXhwb3J0IEtCVUlMRF9ERUZDT05GSUcgS0JVSUxEX0tDT05GSUcKIAotIyBzYXZlIEFSQ0ggJiBDUk9TU19DT01QSUxFIHNldHRpbmdzCi0kKHNoZWxsIG1rZGlyIC1wIGluY2x1ZGUvZ2VuZXJhdGVkICYmICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKLSAgICAgICAgZWNobyAkKEFSQ0gpICAgICAgICAgID4gaW5jbHVkZS9nZW5lcmF0ZWQva2VybmVsLmFyY2ggJiYgXAotICAgICAgICBlY2hvICQoQ1JPU1NfQ09NUElMRSkgPiBpbmNsdWRlL2dlbmVyYXRlZC9rZXJuZWwuY3Jvc3MpCi0KIGNvbmZpZzogc2NyaXB0c19iYXNpYyBvdXRwdXRtYWtlZmlsZSBGT1JDRQogCSQoUSlta2RpciAtcCBpbmNsdWRlL2xpbnV4IGluY2x1ZGUvY29uZmlnCiAJJChRKSQoTUFLRSkgJChidWlsZCk9c2NyaXB0cy9rY29uZmlnICRACmRpZmYgLS1naXQgYS9hcmNoL2FybS9jb25maWdzL29tYXAzX2JlYWdsZV9kZWZjb25maWcgYi9hcmNoL2FybS9jb25maWdzL29tYXAzX2JlYWdsZV9kZWZjb25maWcKaW5kZXggMzU3ZDQwMi4uYjNjOGNjZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vY29uZmlncy9vbWFwM19iZWFnbGVfZGVmY29uZmlnCisrKyBiL2FyY2gvYXJtL2NvbmZpZ3Mvb21hcDNfYmVhZ2xlX2RlZmNvbmZpZwpAQCAtOTY5LDcgKzk2OSw2IEBACiAjCiBDT05GSUdfVVNCX09UR19VVElMUz15CiAjIENPTkZJR19VU0JfR1BJT19WQlVTIGlzIG5vdCBzZXQKLSMgQ09ORklHX0lTUDEzMDFfT01BUCBpcyBub3Qgc2V0CiBDT05GSUdfVFdMNDAzMF9VU0I9eQogIyBDT05GSUdfTk9QX1VTQl9YQ0VJViBpcyBub3Qgc2V0CiBDT05GSUdfTU1DPXkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2JpdG9wcy5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vYml0b3BzLmgKaW5kZXggNjNhNDgxZi4uMzM4ZmYxOSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vaW5jbHVkZS9hc20vYml0b3BzLmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vYml0b3BzLmgKQEAgLTg0LDcgKzg0LDcgQEAKIAkqcCA9IHJlcyB8IG1hc2s7CiAJcmF3X2xvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKIAotCXJldHVybiByZXMgJiBtYXNrOworCXJldHVybiAocmVzICYgbWFzaykgIT0gMDsKIH0KIAogc3RhdGljIGlubGluZSBpbnQKQEAgLTEwMSw3ICsxMDEsNyBAQAogCSpwID0gcmVzICYgfm1hc2s7CiAJcmF3X2xvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKIAotCXJldHVybiByZXMgJiBtYXNrOworCXJldHVybiAocmVzICYgbWFzaykgIT0gMDsKIH0KIAogc3RhdGljIGlubGluZSBpbnQKQEAgLTExOCw3ICsxMTgsNyBAQAogCSpwID0gcmVzIF4gbWFzazsKIAlyYXdfbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogCi0JcmV0dXJuIHJlcyAmIG1hc2s7CisJcmV0dXJuIChyZXMgJiBtYXNrKSAhPSAwOwogfQogCiAjaW5jbHVkZSA8YXNtLWdlbmVyaWMvYml0b3BzL25vbi1hdG9taWMuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC90aW1lLmMgYi9hcmNoL2FybS9rZXJuZWwvdGltZS5jCmluZGV4IDRjZGM0YTAuLmQzOGNkZjIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC90aW1lLmMKKysrIGIvYXJjaC9hcm0va2VybmVsL3RpbWUuYwpAQCAtMjEsNiArMjEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L3RpbWUuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbXAuaD4KICNpbmNsdWRlIDxsaW51eC90aW1leC5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvdHJhcHMuYyBiL2FyY2gvYXJtL2tlcm5lbC90cmFwcy5jCmluZGV4IDQ2N2I2OWUuLmY4MzhmMzYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC90cmFwcy5jCisrKyBiL2FyY2gvYXJtL2tlcm5lbC90cmFwcy5jCkBAIC00NSwyMSArNDUsMjEgQEAKIF9fc2V0dXAoInVzZXJfZGVidWc9IiwgdXNlcl9kZWJ1Z19zZXR1cCk7CiAjZW5kaWYKIAotc3RhdGljIHZvaWQgZHVtcF9tZW0oY29uc3QgY2hhciAqc3RyLCB1bnNpZ25lZCBsb25nIGJvdHRvbSwgdW5zaWduZWQgbG9uZyB0b3ApOworc3RhdGljIHZvaWQgZHVtcF9tZW0oY29uc3QgY2hhciAqLCBjb25zdCBjaGFyICosIHVuc2lnbmVkIGxvbmcsIHVuc2lnbmVkIGxvbmcpOwogCiB2b2lkIGR1bXBfYmFja3RyYWNlX2VudHJ5KHVuc2lnbmVkIGxvbmcgd2hlcmUsIHVuc2lnbmVkIGxvbmcgZnJvbSwgdW5zaWduZWQgbG9uZyBmcmFtZSkKIHsKICNpZmRlZiBDT05GSUdfS0FMTFNZTVMKLQlwcmludGsoIls8JTA4bHg+XSAiLCB3aGVyZSk7Ci0JcHJpbnRfc3ltYm9sKCIoJXMpICIsIHdoZXJlKTsKLQlwcmludGsoImZyb20gWzwlMDhseD5dICIsIGZyb20pOwotCXByaW50X3N5bWJvbCgiKCVzKVxuIiwgZnJvbSk7CisJY2hhciBzeW0xW0tTWU1fU1lNQk9MX0xFTl0sIHN5bTJbS1NZTV9TWU1CT0xfTEVOXTsKKwlzcHJpbnRfc3ltYm9sKHN5bTEsIHdoZXJlKTsKKwlzcHJpbnRfc3ltYm9sKHN5bTIsIGZyb20pOworCXByaW50aygiWzwlMDhseD5dICglcykgZnJvbSBbPCUwOGx4Pl0gKCVzKVxuIiwgd2hlcmUsIHN5bTEsIGZyb20sIHN5bTIpOwogI2Vsc2UKIAlwcmludGsoIkZ1bmN0aW9uIGVudGVyZWQgYXQgWzwlMDhseD5dIGZyb20gWzwlMDhseD5dXG4iLCB3aGVyZSwgZnJvbSk7CiAjZW5kaWYKIAogCWlmIChpbl9leGNlcHRpb25fdGV4dCh3aGVyZSkpCi0JCWR1bXBfbWVtKCJFeGNlcHRpb24gc3RhY2siLCBmcmFtZSArIDQsIGZyYW1lICsgNCArIHNpemVvZihzdHJ1Y3QgcHRfcmVncykpOworCQlkdW1wX21lbSgiIiwgIkV4Y2VwdGlvbiBzdGFjayIsIGZyYW1lICsgNCwgZnJhbWUgKyA0ICsgc2l6ZW9mKHN0cnVjdCBwdF9yZWdzKSk7CiB9CiAKICNpZm5kZWYgQ09ORklHX0FSTV9VTldJTkQKQEAgLTgxLDkgKzgxLDEwIEBACiAvKgogICogRHVtcCBvdXQgdGhlIGNvbnRlbnRzIG9mIHNvbWUgbWVtb3J5IG5pY2VseS4uLgogICovCi1zdGF0aWMgdm9pZCBkdW1wX21lbShjb25zdCBjaGFyICpzdHIsIHVuc2lnbmVkIGxvbmcgYm90dG9tLCB1bnNpZ25lZCBsb25nIHRvcCkKK3N0YXRpYyB2b2lkIGR1bXBfbWVtKGNvbnN0IGNoYXIgKmx2bCwgY29uc3QgY2hhciAqc3RyLCB1bnNpZ25lZCBsb25nIGJvdHRvbSwKKwkJICAgICB1bnNpZ25lZCBsb25nIHRvcCkKIHsKLQl1bnNpZ25lZCBsb25nIHAgPSBib3R0b20gJiB+MzE7CisJdW5zaWduZWQgbG9uZyBmaXJzdDsKIAltbV9zZWdtZW50X3QgZnM7CiAJaW50IGk7CiAKQEAgLTk1LDMzICs5NiwzNyBAQAogCWZzID0gZ2V0X2ZzKCk7CiAJc2V0X2ZzKEtFUk5FTF9EUyk7CiAKLQlwcmludGsoIiVzKDB4JTA4bHggdG8gMHglMDhseClcbiIsIHN0ciwgYm90dG9tLCB0b3ApOworCXByaW50aygiJXMlcygweCUwOGx4IHRvIDB4JTA4bHgpXG4iLCBsdmwsIHN0ciwgYm90dG9tLCB0b3ApOwogCi0JZm9yIChwID0gYm90dG9tICYgfjMxOyBwIDwgdG9wOykgewotCQlwcmludGsoIiUwNGx4OiAiLCBwICYgMHhmZmZmKTsKKwlmb3IgKGZpcnN0ID0gYm90dG9tICYgfjMxOyBmaXJzdCA8IHRvcDsgZmlyc3QgKz0gMzIpIHsKKwkJdW5zaWduZWQgbG9uZyBwOworCQljaGFyIHN0cltzaXplb2YoIiAxMjM0NTY3OCIpICogOCArIDFdOwogCi0JCWZvciAoaSA9IDA7IGkgPCA4OyBpKyssIHAgKz0gNCkgewotCQkJdW5zaWduZWQgaW50IHZhbDsKKwkJbWVtc2V0KHN0ciwgJyAnLCBzaXplb2Yoc3RyKSk7CisJCXN0cltzaXplb2Yoc3RyKSAtIDFdID0gJ1wwJzsKIAotCQkJaWYgKHAgPCBib3R0b20gfHwgcCA+PSB0b3ApCi0JCQkJcHJpbnRrKCIgICAgICAgICAiKTsKLQkJCWVsc2UgewotCQkJCV9fZ2V0X3VzZXIodmFsLCAodW5zaWduZWQgbG9uZyAqKXApOwotCQkJCXByaW50aygiJTA4eCAiLCB2YWwpOworCQlmb3IgKHAgPSBmaXJzdCwgaSA9IDA7IGkgPCA4ICYmIHAgPCB0b3A7IGkrKywgcCArPSA0KSB7CisJCQlpZiAocCA+PSBib3R0b20gJiYgcCA8IHRvcCkgeworCQkJCXVuc2lnbmVkIGxvbmcgdmFsOworCQkJCWlmIChfX2dldF91c2VyKHZhbCwgKHVuc2lnbmVkIGxvbmcgKilwKSA9PSAwKQorCQkJCQlzcHJpbnRmKHN0ciArIGkgKiA5LCAiICUwOGx4IiwgdmFsKTsKKwkJCQllbHNlCisJCQkJCXNwcmludGYoc3RyICsgaSAqIDksICIgPz8/Pz8/Pz8iKTsKIAkJCX0KIAkJfQotCQlwcmludGsgKCJcbiIpOworCQlwcmludGsoIiVzJTA0bHg6JXNcbiIsIGx2bCwgZmlyc3QgJiAweGZmZmYsIHN0cik7CiAJfQogCiAJc2V0X2ZzKGZzKTsKIH0KIAotc3RhdGljIHZvaWQgZHVtcF9pbnN0cihzdHJ1Y3QgcHRfcmVncyAqcmVncykKK3N0YXRpYyB2b2lkIGR1bXBfaW5zdHIoY29uc3QgY2hhciAqbHZsLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKIHsKIAl1bnNpZ25lZCBsb25nIGFkZHIgPSBpbnN0cnVjdGlvbl9wb2ludGVyKHJlZ3MpOwogCWNvbnN0IGludCB0aHVtYiA9IHRodW1iX21vZGUocmVncyk7CiAJY29uc3QgaW50IHdpZHRoID0gdGh1bWIgPyA0IDogODsKIAltbV9zZWdtZW50X3QgZnM7CisJY2hhciBzdHJbc2l6ZW9mKCIwMDAwMDAwMCAiKSAqIDUgKyAyICsgMV0sICpwID0gc3RyOwogCWludCBpOwogCiAJLyoKQEAgLTEzMiw3ICsxMzcsNiBAQAogCWZzID0gZ2V0X2ZzKCk7CiAJc2V0X2ZzKEtFUk5FTF9EUyk7CiAKLQlwcmludGsoIkNvZGU6ICIpOwogCWZvciAoaSA9IC00OyBpIDwgMTsgaSsrKSB7CiAJCXVuc2lnbmVkIGludCB2YWwsIGJhZDsKIApAQCAtMTQyLDEzICsxNDYsMTQgQEAKIAkJCWJhZCA9IF9fZ2V0X3VzZXIodmFsLCAmKCh1MzIgKilhZGRyKVtpXSk7CiAKIAkJaWYgKCFiYWQpCi0JCQlwcmludGsoaSA9PSAwID8gIiglMCp4KSAiIDogIiUwKnggIiwgd2lkdGgsIHZhbCk7CisJCQlwICs9IHNwcmludGYocCwgaSA9PSAwID8gIiglMCp4KSAiIDogIiUwKnggIiwKKwkJCQkJd2lkdGgsIHZhbCk7CiAJCWVsc2UgewotCQkJcHJpbnRrKCJiYWQgUEMgdmFsdWUuIik7CisJCQlwICs9IHNwcmludGYocCwgImJhZCBQQyB2YWx1ZSIpOwogCQkJYnJlYWs7CiAJCX0KIAl9Ci0JcHJpbnRrKCJcbiIpOworCXByaW50aygiJXNDb2RlOiAlc1xuIiwgbHZsLCBzdHIpOwogCiAJc2V0X2ZzKGZzKTsKIH0KQEAgLTIyNCwxOCArMjI5LDE5IEBACiAJc3RydWN0IHRhc2tfc3RydWN0ICp0c2sgPSB0aHJlYWQtPnRhc2s7CiAJc3RhdGljIGludCBkaWVfY291bnRlcjsKIAotCXByaW50aygiSW50ZXJuYWwgZXJyb3I6ICVzOiAleCBbIyVkXSIgU19QUkVFTVBUIFNfU01QICJcbiIsCisJcHJpbnRrKEtFUk5fRU1FUkcgIkludGVybmFsIGVycm9yOiAlczogJXggWyMlZF0iIFNfUFJFRU1QVCBTX1NNUCAiXG4iLAogCSAgICAgICBzdHIsIGVyciwgKytkaWVfY291bnRlcik7CisJc3lzZnNfcHJpbnRrX2xhc3RfZmlsZSgpOwogCXByaW50X21vZHVsZXMoKTsKIAlfX3Nob3dfcmVncyhyZWdzKTsKLQlwcmludGsoIlByb2Nlc3MgJXMgKHBpZDogJWQsIHN0YWNrIGxpbWl0ID0gMHglcClcbiIsCi0JCXRzay0+Y29tbSwgdGFza19waWRfbnIodHNrKSwgdGhyZWFkICsgMSk7CisJcHJpbnRrKEtFUk5fRU1FUkcgIlByb2Nlc3MgJS4qcyAocGlkOiAlZCwgc3RhY2sgbGltaXQgPSAweCVwKVxuIiwKKwkJVEFTS19DT01NX0xFTiwgdHNrLT5jb21tLCB0YXNrX3BpZF9ucih0c2spLCB0aHJlYWQgKyAxKTsKIAogCWlmICghdXNlcl9tb2RlKHJlZ3MpIHx8IGluX2ludGVycnVwdCgpKSB7Ci0JCWR1bXBfbWVtKCJTdGFjazogIiwgcmVncy0+QVJNX3NwLAorCQlkdW1wX21lbShLRVJOX0VNRVJHLCAiU3RhY2s6ICIsIHJlZ3MtPkFSTV9zcCwKIAkJCSBUSFJFQURfU0laRSArICh1bnNpZ25lZCBsb25nKXRhc2tfc3RhY2tfcGFnZSh0c2spKTsKIAkJZHVtcF9iYWNrdHJhY2UocmVncywgdHNrKTsKLQkJZHVtcF9pbnN0cihyZWdzKTsKKwkJZHVtcF9pbnN0cihLRVJOX0VNRVJHLCByZWdzKTsKIAl9CiB9CiAKQEAgLTI1MCwxMyArMjU2LDE0IEBACiAKIAlvb3BzX2VudGVyKCk7CiAKLQljb25zb2xlX3ZlcmJvc2UoKTsKIAlzcGluX2xvY2tfaXJxKCZkaWVfbG9jayk7CisJY29uc29sZV92ZXJib3NlKCk7CiAJYnVzdF9zcGlubG9ja3MoMSk7CiAJX19kaWUoc3RyLCBlcnIsIHRocmVhZCwgcmVncyk7CiAJYnVzdF9zcGlubG9ja3MoMCk7CiAJYWRkX3RhaW50KFRBSU5UX0RJRSk7CiAJc3Bpbl91bmxvY2tfaXJxKCZkaWVfbG9jayk7CisJb29wc19leGl0KCk7CiAKIAlpZiAoaW5faW50ZXJydXB0KCkpCiAJCXBhbmljKCJGYXRhbCBleGNlcHRpb24gaW4gaW50ZXJydXB0Iik7CkBAIC0yNjQsNyArMjcxLDYgQEAKIAlpZiAocGFuaWNfb25fb29wcykKIAkJcGFuaWMoIkZhdGFsIGV4Y2VwdGlvbiIpOwogCi0Jb29wc19leGl0KCk7CiAJZG9fZXhpdChTSUdTRUdWKTsKIH0KIApAQCAtMzQ5LDcgKzM1NSw3IEBACiAJaWYgKHVzZXJfZGVidWcgJiBVREJHX1VOREVGSU5FRCkgewogCQlwcmludGsoS0VSTl9JTkZPICIlcyAoJWQpOiB1bmRlZmluZWQgaW5zdHJ1Y3Rpb246IHBjPSVwXG4iLAogCQkJY3VycmVudC0+Y29tbSwgdGFza19waWRfbnIoY3VycmVudCksIHBjKTsKLQkJZHVtcF9pbnN0cihyZWdzKTsKKwkJZHVtcF9pbnN0cihLRVJOX0lORk8sIHJlZ3MpOwogCX0KICNlbmRpZgogCkBAIC00MDAsNyArNDA2LDcgQEAKIAlpZiAodXNlcl9kZWJ1ZyAmIFVEQkdfU1lTQ0FMTCkgewogCQlwcmludGsoS0VSTl9FUlIgIlslZF0gJXM6IG9ic29sZXRlIHN5c3RlbSBjYWxsICUwOHguXG4iLAogCQkJdGFza19waWRfbnIoY3VycmVudCksIGN1cnJlbnQtPmNvbW0sIG4pOwotCQlkdW1wX2luc3RyKHJlZ3MpOworCQlkdW1wX2luc3RyKEtFUk5fRVJSLCByZWdzKTsKIAl9CiAjZW5kaWYKIApAQCAtNTc5LDcgKzU4NSw3IEBACiAJaWYgKHVzZXJfZGVidWcgJiBVREJHX1NZU0NBTEwpIHsKIAkJcHJpbnRrKCJbJWRdICVzOiBhcm0gc3lzY2FsbCAlZFxuIiwKIAkJICAgICAgIHRhc2tfcGlkX25yKGN1cnJlbnQpLCBjdXJyZW50LT5jb21tLCBubyk7Ci0JCWR1bXBfaW5zdHIocmVncyk7CisJCWR1bXBfaW5zdHIoIiIsIHJlZ3MpOwogCQlpZiAodXNlcl9tb2RlKHJlZ3MpKSB7CiAJCQlfX3Nob3dfcmVncyhyZWdzKTsKIAkJCWNfYmFja3RyYWNlKHJlZ3MtPkFSTV9mcCwgcHJvY2Vzc29yX21vZGUocmVncykpOwpAQCAtNjU2LDcgKzY2Miw3IEBACiAJaWYgKHVzZXJfZGVidWcgJiBVREJHX0JBREFCT1JUKSB7CiAJCXByaW50ayhLRVJOX0VSUiAiWyVkXSAlczogYmFkIGRhdGEgYWJvcnQ6IGNvZGUgJWQgaW5zdHIgMHglMDhseFxuIiwKIAkJCXRhc2tfcGlkX25yKGN1cnJlbnQpLCBjdXJyZW50LT5jb21tLCBjb2RlLCBpbnN0cik7Ci0JCWR1bXBfaW5zdHIocmVncyk7CisJCWR1bXBfaW5zdHIoS0VSTl9FUlIsIHJlZ3MpOwogCQlzaG93X3B0ZShjdXJyZW50LT5tbSwgYWRkcik7CiAJfQogI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWJjbXJpbmcvY29yZS5jIGIvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2NvcmUuYwppbmRleCA0YjRmNjkyLi5lNTkwYmJlIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWJjbXJpbmcvY29yZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtYmNtcmluZy9jb3JlLmMKQEAgLTI3MSwxMiArMjcxLDEyIEBACiAJLmhhbmRsZXIgPSBiY21yaW5nX3RpbWVyX2ludGVycnVwdCwKIH07CiAKLXN0YXRpYyBjeWNsZV90IGJjbXJpbmdfZ2V0X2N5Y2xlc190aW1lcjEodm9pZCkKK3N0YXRpYyBjeWNsZV90IGJjbXJpbmdfZ2V0X2N5Y2xlc190aW1lcjEoc3RydWN0IGNsb2Nrc291cmNlICpjcykKIHsKIAlyZXR1cm4gfnJlYWRsKFRJTUVSMV9WQV9CQVNFICsgVElNRVJfVkFMVUUpOwogfQogCi1zdGF0aWMgY3ljbGVfdCBiY21yaW5nX2dldF9jeWNsZXNfdGltZXIzKHZvaWQpCitzdGF0aWMgY3ljbGVfdCBiY21yaW5nX2dldF9jeWNsZXNfdGltZXIzKHN0cnVjdCBjbG9ja3NvdXJjZSAqY3MpCiB7CiAJcmV0dXJuIH5yZWFkbChUSU1FUjNfVkFfQkFTRSArIFRJTUVSX1ZBTFVFKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvc3lzdGVtLmggYi9hcmNoL2FybS9tYWNoLWJjbXJpbmcvaW5jbHVkZS9tYWNoL3N5c3RlbS5oCmluZGV4IGNkYmY5M2MuLjM4YjM3MDYgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtYmNtcmluZy9pbmNsdWRlL21hY2gvc3lzdGVtLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1iY21yaW5nL2luY2x1ZGUvbWFjaC9zeXN0ZW0uaApAQCAtMjksNyArMjksNyBAQAogCWNwdV9kb19pZGxlKCk7CiB9CiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBhcmNoX3Jlc2V0KGNoYXIgbW9kZSwgY2hhciAqY21kKQorc3RhdGljIGlubGluZSB2b2lkIGFyY2hfcmVzZXQoY2hhciBtb2RlLCBjb25zdCBjaGFyICpjbWQpCiB7CiAJcHJpbnRrKCJhcmNoX3Jlc2V0OiVjICV4XG4iLCBtb2RlLCBiY21yaW5nX2FyY2hfd2FybV9yZWJvb3QpOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9LY29uZmlnIGIvYXJjaC9hcm0vbWFjaC1lcDkzeHgvS2NvbmZpZwppbmRleCBkNzI5MWM2Li45MTY3YzNkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9LY29uZmlnCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L0tjb25maWcKQEAgLTE3LDEzICsxNywzMSBAQAogCWJvb2wgIjB4MDAwMDAwMDAgLSBTRENFMy9TeW5jQm9vdCIKIAloZWxwCiAJICBTZWxlY3QgdGhpcyBvcHRpb24gaWYgeW91IHdhbnQgc3VwcG9ydCBmb3IgRVA5M3h4IGJvYXJkcyB3aXRoIHRoZQotCSAgZmlyc3QgU0RSQU0gYmFuayBhdCAweDAwMDAwMDAwCisJICBmaXJzdCBTRFJBTSBiYW5rIGF0IDB4MDAwMDAwMDAuCiAKIGNvbmZpZyBFUDkzWFhfU0RDRTBfUEhZU19PRkZTRVQKIAlib29sICIweGMwMDAwMDAwIC0gU0RDRU8iCiAJaGVscAogCSAgU2VsZWN0IHRoaXMgb3B0aW9uIGlmIHlvdSB3YW50IHN1cHBvcnQgZm9yIEVQOTN4eCBib2FyZHMgd2l0aCB0aGUKLQkgIGZpcnN0IFNEUkFNIGJhbmsgYXQgMHhjMDAwMDAwMAorCSAgZmlyc3QgU0RSQU0gYmFuayBhdCAweGMwMDAwMDAwLgorCitjb25maWcgRVA5M1hYX1NEQ0UxX1BIWVNfT0ZGU0VUCisJYm9vbCAiMHhkMDAwMDAwMCAtIFNEQ0UxIgorCWhlbHAKKwkgIFNlbGVjdCB0aGlzIG9wdGlvbiBpZiB5b3Ugd2FudCBzdXBwb3J0IGZvciBFUDkzeHggYm9hcmRzIHdpdGggdGhlCisJICBmaXJzdCBTRFJBTSBiYW5rIGF0IDB4ZDAwMDAwMDAuCisKK2NvbmZpZyBFUDkzWFhfU0RDRTJfUEhZU19PRkZTRVQKKwlib29sICIweGUwMDAwMDAwIC0gU0RDRTIiCisJaGVscAorCSAgU2VsZWN0IHRoaXMgb3B0aW9uIGlmIHlvdSB3YW50IHN1cHBvcnQgZm9yIEVQOTN4eCBib2FyZHMgd2l0aCB0aGUKKwkgIGZpcnN0IFNEUkFNIGJhbmsgYXQgMHhlMDAwMDAwMC4KKworY29uZmlnIEVQOTNYWF9TRENFM19BU1lOQ19QSFlTX09GRlNFVAorCWJvb2wgIjB4ZjAwMDAwMDAgLSBTRENFMy9Bc3luY0Jvb3QiCisJaGVscAorCSAgU2VsZWN0IHRoaXMgb3B0aW9uIGlmIHlvdSB3YW50IHN1cHBvcnQgZm9yIEVQOTN4eCBib2FyZHMgd2l0aCB0aGUKKwkgIGZpcnN0IFNEUkFNIGJhbmsgYXQgMHhmMDAwMDAwMC4KIAogZW5kY2hvaWNlCiAKQEAgLTExMiwyOCArMTMwLDM2IEBACiAJYm9vbAogCiBjb25maWcgTUFDSF9NSUNSTzlICi0JYm9vbCAiU3VwcG9ydCBDb250ZWMgSHlwZXJjb250cm9sIE1pY3JvOS1IIgorCWJvb2wgIlN1cHBvcnQgQ29udGVjIE1pY3JvOS1IaWdoIgogCWRlcGVuZHMgb24gRVA5M1hYX1NEQ0UzX1NZTkNfUEhZU19PRkZTRVQKIAlzZWxlY3QgTUFDSF9NSUNSTzkKIAloZWxwCiAJICBTYXkgJ1knIGhlcmUgaWYgeW91IHdhbnQgeW91ciBrZXJuZWwgdG8gc3VwcG9ydCB0aGUKLQkgIENvbnRlYyBIeXBlcmNvbnRyb2wgTWljcm85LUggYm9hcmQuCisJICBDb250ZWMgTWljcm85LUhpZ2ggYm9hcmQuCiAKIGNvbmZpZyBNQUNIX01JQ1JPOU0KLQlib29sICJTdXBwb3J0IENvbnRlYyBIeXBlcmNvbnRyb2wgTWljcm85LU0iCi0JZGVwZW5kcyBvbiBFUDkzWFhfU0RDRTNfU1lOQ19QSFlTX09GRlNFVAorCWJvb2wgIlN1cHBvcnQgQ29udGVjIE1pY3JvOS1NaWQiCisJZGVwZW5kcyBvbiBFUDkzWFhfU0RDRTNfQVNZTkNfUEhZU19PRkZTRVQKIAlzZWxlY3QgTUFDSF9NSUNSTzkKIAloZWxwCiAJICBTYXkgJ1knIGhlcmUgaWYgeW91IHdhbnQgeW91ciBrZXJuZWwgdG8gc3VwcG9ydCB0aGUKLQkgIENvbnRlYyBIeXBlcmNvbnRyb2wgTWljcm85LU0gYm9hcmQuCisJICBDb250ZWMgTWljcm85LU1pZCBib2FyZC4KIAogY29uZmlnIE1BQ0hfTUlDUk85TAotCWJvb2wgIlN1cHBvcnQgQ29udGVjIEh5cGVyY29udHJvbCBNaWNybzktTCIKKwlib29sICJTdXBwb3J0IENvbnRlYyBNaWNybzktTGl0ZSIKIAlkZXBlbmRzIG9uIEVQOTNYWF9TRENFM19TWU5DX1BIWVNfT0ZGU0VUCiAJc2VsZWN0IE1BQ0hfTUlDUk85CiAJaGVscAogCSAgU2F5ICdZJyBoZXJlIGlmIHlvdSB3YW50IHlvdXIga2VybmVsIHRvIHN1cHBvcnQgdGhlCi0JICBDb250ZWMgSHlwZXJjb250cm9sIE1pY3JvOS1MIGJvYXJkLgorCSAgQ29udGVjIE1pY3JvOS1MaXRlIGJvYXJkLgorCitjb25maWcgTUFDSF9NSUNSTzlTCisJYm9vbCAiU3VwcG9ydCBDb250ZWMgTWljcm85LVNsaW0iCisJZGVwZW5kcyBvbiBFUDkzWFhfU0RDRTNfQVNZTkNfUEhZU19PRkZTRVQKKwlzZWxlY3QgTUFDSF9NSUNSTzkKKwloZWxwCisJICBTYXkgJ1knIGhlcmUgaWYgeW91IHdhbnQgeW91ciBrZXJuZWwgdG8gc3VwcG9ydCB0aGUKKwkgIENvbnRlYyBNaWNybzktU2xpbSBib2FyZC4KIAogY29uZmlnIE1BQ0hfVFM3MlhYCiAJYm9vbCAiU3VwcG9ydCBUZWNobm9sb2dpYyBTeXN0ZW1zIFRTLTcyeHggU0JDIgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvTWFrZWZpbGUuYm9vdCBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L01ha2VmaWxlLmJvb3QKaW5kZXggMjdhMDg1YS4uMGFkMzNmMSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvTWFrZWZpbGUuYm9vdAorKysgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9NYWtlZmlsZS5ib290CkBAIC0zLDMgKzMsMTIgQEAKIAogICAgenJlbGFkZHItJChDT05GSUdfRVA5M1hYX1NEQ0UwX1BIWVNfT0ZGU0VUKQkJOj0gMHhjMDAwODAwMAogcGFyYW1zX3BoeXMtJChDT05GSUdfRVA5M1hYX1NEQ0UwX1BIWVNfT0ZGU0VUKQkJOj0gMHhjMDAwMDEwMAorCisgICB6cmVsYWRkci0kKENPTkZJR19FUDkzWFhfU0RDRTFfUEhZU19PRkZTRVQpCQk6PSAweGQwMDA4MDAwCitwYXJhbXNfcGh5cy0kKENPTkZJR19FUDkzWFhfU0RDRTFfUEhZU19PRkZTRVQpCQk6PSAweGQwMDAwMTAwCisKKyAgIHpyZWxhZGRyLSQoQ09ORklHX0VQOTNYWF9TRENFMl9QSFlTX09GRlNFVCkJCTo9IDB4ZTAwMDgwMDAKK3BhcmFtc19waHlzLSQoQ09ORklHX0VQOTNYWF9TRENFMl9QSFlTX09GRlNFVCkJCTo9IDB4ZTAwMDAxMDAKKworICAgenJlbGFkZHItJChDT05GSUdfRVA5M1hYX1NEQ0UzX0FTWU5DX1BIWVNfT0ZGU0VUKQk6PSAweGYwMDA4MDAwCitwYXJhbXNfcGh5cy0kKENPTkZJR19FUDkzWFhfU0RDRTNfQVNZTkNfUEhZU19PRkZTRVQpCTo9IDB4ZjAwMDAxMDAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L2Nsb2NrLmMgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9jbG9jay5jCmluZGV4IGRkYTE5Y2Q3Li4xZDBmOWQ4IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9jbG9jay5jCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2Nsb2NrLmMKQEAgLTE2LDEzICsxNiwxNiBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KKworI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KIAogI2luY2x1ZGUgPGFzbS9jbGtkZXYuaD4KICNpbmNsdWRlIDxhc20vZGl2NjQuaD4KLSNpbmNsdWRlIDxtYWNoL2hhcmR3YXJlLmg+CiAKIAogc3RydWN0IGNsayB7CisJc3RydWN0IGNsawkqcGFyZW50OwogCXVuc2lnbmVkIGxvbmcJcmF0ZTsKIAlpbnQJCXVzZXJzOwogCWludAkJc3dfbG9ja2VkOwpAQCAtMzksNDAgKzQyLDYwIEBACiBzdGF0aWMgaW50IHNldF9rZXl0Y2hjbGtfcmF0ZShzdHJ1Y3QgY2xrICpjbGssIHVuc2lnbmVkIGxvbmcgcmF0ZSk7CiBzdGF0aWMgaW50IHNldF9kaXZfcmF0ZShzdHJ1Y3QgY2xrICpjbGssIHVuc2lnbmVkIGxvbmcgcmF0ZSk7CiAKKworc3RhdGljIHN0cnVjdCBjbGsgY2xrX3h0YWxpID0geworCS5yYXRlCQk9IEVQOTNYWF9FWFRfQ0xLX1JBVEUsCit9Owogc3RhdGljIHN0cnVjdCBjbGsgY2xrX3VhcnQxID0geworCS5wYXJlbnQJCT0gJmNsa194dGFsaSwKIAkuc3dfbG9ja2VkCT0gMSwKIAkuZW5hYmxlX3JlZwk9IEVQOTNYWF9TWVNDT05fREVWQ0ZHLAogCS5lbmFibGVfbWFzawk9IEVQOTNYWF9TWVNDT05fREVWQ0ZHX1UxRU4sCiAJLmdldF9yYXRlCT0gZ2V0X3VhcnRfcmF0ZSwKIH07CiBzdGF0aWMgc3RydWN0IGNsayBjbGtfdWFydDIgPSB7CisJLnBhcmVudAkJPSAmY2xrX3h0YWxpLAogCS5zd19sb2NrZWQJPSAxLAogCS5lbmFibGVfcmVnCT0gRVA5M1hYX1NZU0NPTl9ERVZDRkcsCiAJLmVuYWJsZV9tYXNrCT0gRVA5M1hYX1NZU0NPTl9ERVZDRkdfVTJFTiwKIAkuZ2V0X3JhdGUJPSBnZXRfdWFydF9yYXRlLAogfTsKIHN0YXRpYyBzdHJ1Y3QgY2xrIGNsa191YXJ0MyA9IHsKKwkucGFyZW50CQk9ICZjbGtfeHRhbGksCiAJLnN3X2xvY2tlZAk9IDEsCiAJLmVuYWJsZV9yZWcJPSBFUDkzWFhfU1lTQ09OX0RFVkNGRywKIAkuZW5hYmxlX21hc2sJPSBFUDkzWFhfU1lTQ09OX0RFVkNGR19VM0VOLAogCS5nZXRfcmF0ZQk9IGdldF91YXJ0X3JhdGUsCiB9Owotc3RhdGljIHN0cnVjdCBjbGsgY2xrX3BsbDE7Ci1zdGF0aWMgc3RydWN0IGNsayBjbGtfZjsKLXN0YXRpYyBzdHJ1Y3QgY2xrIGNsa19oOwotc3RhdGljIHN0cnVjdCBjbGsgY2xrX3A7Ci1zdGF0aWMgc3RydWN0IGNsayBjbGtfcGxsMjsKK3N0YXRpYyBzdHJ1Y3QgY2xrIGNsa19wbGwxID0geworCS5wYXJlbnQJCT0gJmNsa194dGFsaSwKK307CitzdGF0aWMgc3RydWN0IGNsayBjbGtfZiA9IHsKKwkucGFyZW50CQk9ICZjbGtfcGxsMSwKK307CitzdGF0aWMgc3RydWN0IGNsayBjbGtfaCA9IHsKKwkucGFyZW50CQk9ICZjbGtfcGxsMSwKK307CitzdGF0aWMgc3RydWN0IGNsayBjbGtfcCA9IHsKKwkucGFyZW50CQk9ICZjbGtfcGxsMSwKK307CitzdGF0aWMgc3RydWN0IGNsayBjbGtfcGxsMiA9IHsKKwkucGFyZW50CQk9ICZjbGtfeHRhbGksCit9Owogc3RhdGljIHN0cnVjdCBjbGsgY2xrX3VzYl9ob3N0ID0geworCS5wYXJlbnQJCT0gJmNsa19wbGwyLAogCS5lbmFibGVfcmVnCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlQsCiAJLmVuYWJsZV9tYXNrCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlRfVVNIX0VOLAogfTsKIHN0YXRpYyBzdHJ1Y3QgY2xrIGNsa19rZXlwYWQgPSB7CisJLnBhcmVudAkJPSAmY2xrX3h0YWxpLAogCS5zd19sb2NrZWQJPSAxLAogCS5lbmFibGVfcmVnCT0gRVA5M1hYX1NZU0NPTl9LRVlUQ0hDTEtESVYsCiAJLmVuYWJsZV9tYXNrCT0gRVA5M1hYX1NZU0NPTl9LRVlUQ0hDTEtESVZfS0VOLAogCS5zZXRfcmF0ZQk9IHNldF9rZXl0Y2hjbGtfcmF0ZSwKIH07CiBzdGF0aWMgc3RydWN0IGNsayBjbGtfcHdtID0geworCS5wYXJlbnQJCT0gJmNsa194dGFsaSwKIAkucmF0ZQkJPSBFUDkzWFhfRVhUX0NMS19SQVRFLAogfTsKIApAQCAtODUsNTAgKzEwOCw2MiBAQAogCiAvKiBETUEgQ2xvY2tzICovCiBzdGF0aWMgc3RydWN0IGNsayBjbGtfbTJwMCA9IHsKKwkucGFyZW50CQk9ICZjbGtfaCwKIAkuZW5hYmxlX3JlZwk9IEVQOTNYWF9TWVNDT05fUFdSQ05ULAogCS5lbmFibGVfbWFzawk9IEVQOTNYWF9TWVNDT05fUFdSQ05UX0RNQV9NMlAwLAogfTsKIHN0YXRpYyBzdHJ1Y3QgY2xrIGNsa19tMnAxID0geworCS5wYXJlbnQJCT0gJmNsa19oLAogCS5lbmFibGVfcmVnCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlQsCiAJLmVuYWJsZV9tYXNrCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlRfRE1BX00yUDEsCiB9Owogc3RhdGljIHN0cnVjdCBjbGsgY2xrX20ycDIgPSB7CisJLnBhcmVudAkJPSAmY2xrX2gsCiAJLmVuYWJsZV9yZWcJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVCwKIAkuZW5hYmxlX21hc2sJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVF9ETUFfTTJQMiwKIH07CiBzdGF0aWMgc3RydWN0IGNsayBjbGtfbTJwMyA9IHsKKwkucGFyZW50CQk9ICZjbGtfaCwKIAkuZW5hYmxlX3JlZwk9IEVQOTNYWF9TWVNDT05fUFdSQ05ULAogCS5lbmFibGVfbWFzawk9IEVQOTNYWF9TWVNDT05fUFdSQ05UX0RNQV9NMlAzLAogfTsKIHN0YXRpYyBzdHJ1Y3QgY2xrIGNsa19tMnA0ID0geworCS5wYXJlbnQJCT0gJmNsa19oLAogCS5lbmFibGVfcmVnCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlQsCiAJLmVuYWJsZV9tYXNrCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlRfRE1BX00yUDQsCiB9Owogc3RhdGljIHN0cnVjdCBjbGsgY2xrX20ycDUgPSB7CisJLnBhcmVudAkJPSAmY2xrX2gsCiAJLmVuYWJsZV9yZWcJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVCwKIAkuZW5hYmxlX21hc2sJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVF9ETUFfTTJQNSwKIH07CiBzdGF0aWMgc3RydWN0IGNsayBjbGtfbTJwNiA9IHsKKwkucGFyZW50CQk9ICZjbGtfaCwKIAkuZW5hYmxlX3JlZwk9IEVQOTNYWF9TWVNDT05fUFdSQ05ULAogCS5lbmFibGVfbWFzawk9IEVQOTNYWF9TWVNDT05fUFdSQ05UX0RNQV9NMlA2LAogfTsKIHN0YXRpYyBzdHJ1Y3QgY2xrIGNsa19tMnA3ID0geworCS5wYXJlbnQJCT0gJmNsa19oLAogCS5lbmFibGVfcmVnCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlQsCiAJLmVuYWJsZV9tYXNrCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlRfRE1BX00yUDcsCiB9Owogc3RhdGljIHN0cnVjdCBjbGsgY2xrX20ycDggPSB7CisJLnBhcmVudAkJPSAmY2xrX2gsCiAJLmVuYWJsZV9yZWcJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVCwKIAkuZW5hYmxlX21hc2sJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVF9ETUFfTTJQOCwKIH07CiBzdGF0aWMgc3RydWN0IGNsayBjbGtfbTJwOSA9IHsKKwkucGFyZW50CQk9ICZjbGtfaCwKIAkuZW5hYmxlX3JlZwk9IEVQOTNYWF9TWVNDT05fUFdSQ05ULAogCS5lbmFibGVfbWFzawk9IEVQOTNYWF9TWVNDT05fUFdSQ05UX0RNQV9NMlA5LAogfTsKIHN0YXRpYyBzdHJ1Y3QgY2xrIGNsa19tMm0wID0geworCS5wYXJlbnQJCT0gJmNsa19oLAogCS5lbmFibGVfcmVnCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlQsCiAJLmVuYWJsZV9tYXNrCT0gRVA5M1hYX1NZU0NPTl9QV1JDTlRfRE1BX00yTTAsCiB9Owogc3RhdGljIHN0cnVjdCBjbGsgY2xrX20ybTEgPSB7CisJLnBhcmVudAkJPSAmY2xrX2gsCiAJLmVuYWJsZV9yZWcJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVCwKIAkuZW5hYmxlX21hc2sJPSBFUDkzWFhfU1lTQ09OX1BXUkNOVF9ETUFfTTJNMSwKIH07CkBAIC0xMzcsNiArMTcyLDcgQEAKIAl7IC5kZXZfaWQgPSBkZXYsIC5jb25faWQgPSBjb24sIC5jbGsgPSBjayB9CiAKIHN0YXRpYyBzdHJ1Y3QgY2xrX2xvb2t1cCBjbG9ja3NbXSA9IHsKKwlJTklUX0NLKE5VTEwsCQkJInh0YWxpIiwJJmNsa194dGFsaSksCiAJSU5JVF9DSygiYXBiOnVhcnQxIiwJCU5VTEwsCQkmY2xrX3VhcnQxKSwKIAlJTklUX0NLKCJhcGI6dWFydDIiLAkJTlVMTCwJCSZjbGtfdWFydDIpLAogCUlOSVRfQ0soImFwYjp1YXJ0MyIsCQlOVUxMLAkJJmNsa191YXJ0MyksCkBAIC0xNjMsNDggKzE5OSw4NCBAQAogCUlOSVRfQ0soTlVMTCwJCQkibTJtMSIsCQkmY2xrX20ybTEpLAogfTsKIAorc3RhdGljIERFRklORV9TUElOTE9DSyhjbGtfbG9jayk7CisKK3N0YXRpYyB2b2lkIF9fY2xrX2VuYWJsZShzdHJ1Y3QgY2xrICpjbGspCit7CisJaWYgKCFjbGstPnVzZXJzKyspIHsKKwkJaWYgKGNsay0+cGFyZW50KQorCQkJX19jbGtfZW5hYmxlKGNsay0+cGFyZW50KTsKKworCQlpZiAoY2xrLT5lbmFibGVfcmVnKSB7CisJCQl1MzIgdjsKKworCQkJdiA9IF9fcmF3X3JlYWRsKGNsay0+ZW5hYmxlX3JlZyk7CisJCQl2IHw9IGNsay0+ZW5hYmxlX21hc2s7CisJCQlpZiAoY2xrLT5zd19sb2NrZWQpCisJCQkJZXA5M3h4X3N5c2Nvbl9zd2xvY2tlZF93cml0ZSh2LCBjbGstPmVuYWJsZV9yZWcpOworCQkJZWxzZQorCQkJCV9fcmF3X3dyaXRlbCh2LCBjbGstPmVuYWJsZV9yZWcpOworCQl9CisJfQorfQogCiBpbnQgY2xrX2VuYWJsZShzdHJ1Y3QgY2xrICpjbGspCiB7Ci0JaWYgKCFjbGstPnVzZXJzKysgJiYgY2xrLT5lbmFibGVfcmVnKSB7Ci0JCXUzMiB2YWx1ZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JCXZhbHVlID0gX19yYXdfcmVhZGwoY2xrLT5lbmFibGVfcmVnKTsKLQkJdmFsdWUgfD0gY2xrLT5lbmFibGVfbWFzazsKLQkJaWYgKGNsay0+c3dfbG9ja2VkKQotCQkJZXA5M3h4X3N5c2Nvbl9zd2xvY2tlZF93cml0ZSh2YWx1ZSwgY2xrLT5lbmFibGVfcmVnKTsKLQkJZWxzZQotCQkJX19yYXdfd3JpdGVsKHZhbHVlLCBjbGstPmVuYWJsZV9yZWcpOwotCX0KKwlpZiAoIWNsaykKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmY2xrX2xvY2ssIGZsYWdzKTsKKwlfX2Nsa19lbmFibGUoY2xrKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjbGtfbG9jaywgZmxhZ3MpOwogCiAJcmV0dXJuIDA7CiB9CiBFWFBPUlRfU1lNQk9MKGNsa19lbmFibGUpOwogCitzdGF0aWMgdm9pZCBfX2Nsa19kaXNhYmxlKHN0cnVjdCBjbGsgKmNsaykKK3sKKwlpZiAoIS0tY2xrLT51c2VycykgeworCQlpZiAoY2xrLT5lbmFibGVfcmVnKSB7CisJCQl1MzIgdjsKKworCQkJdiA9IF9fcmF3X3JlYWRsKGNsay0+ZW5hYmxlX3JlZyk7CisJCQl2ICY9IH5jbGstPmVuYWJsZV9tYXNrOworCQkJaWYgKGNsay0+c3dfbG9ja2VkKQorCQkJCWVwOTN4eF9zeXNjb25fc3dsb2NrZWRfd3JpdGUodiwgY2xrLT5lbmFibGVfcmVnKTsKKwkJCWVsc2UKKwkJCQlfX3Jhd193cml0ZWwodiwgY2xrLT5lbmFibGVfcmVnKTsKKwkJfQorCisJCWlmIChjbGstPnBhcmVudCkKKwkJCV9fY2xrX2Rpc2FibGUoY2xrLT5wYXJlbnQpOworCX0KK30KKwogdm9pZCBjbGtfZGlzYWJsZShzdHJ1Y3QgY2xrICpjbGspCiB7Ci0JaWYgKCEtLWNsay0+dXNlcnMgJiYgY2xrLT5lbmFibGVfcmVnKSB7Ci0JCXUzMiB2YWx1ZTsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCi0JCXZhbHVlID0gX19yYXdfcmVhZGwoY2xrLT5lbmFibGVfcmVnKTsKLQkJdmFsdWUgJj0gfmNsay0+ZW5hYmxlX21hc2s7Ci0JCWlmIChjbGstPnN3X2xvY2tlZCkKLQkJCWVwOTN4eF9zeXNjb25fc3dsb2NrZWRfd3JpdGUodmFsdWUsIGNsay0+ZW5hYmxlX3JlZyk7Ci0JCWVsc2UKLQkJCV9fcmF3X3dyaXRlbCh2YWx1ZSwgY2xrLT5lbmFibGVfcmVnKTsKLQl9CisJaWYgKCFjbGspCisJCXJldHVybjsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZjbGtfbG9jaywgZmxhZ3MpOworCV9fY2xrX2Rpc2FibGUoY2xrKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjbGtfbG9jaywgZmxhZ3MpOwogfQogRVhQT1JUX1NZTUJPTChjbGtfZGlzYWJsZSk7CiAKIHN0YXRpYyB1bnNpZ25lZCBsb25nIGdldF91YXJ0X3JhdGUoc3RydWN0IGNsayAqY2xrKQogeworCXVuc2lnbmVkIGxvbmcgcmF0ZSA9IGNsa19nZXRfcmF0ZShjbGstPnBhcmVudCk7CiAJdTMyIHZhbHVlOwogCiAJdmFsdWUgPSBfX3Jhd19yZWFkbChFUDkzWFhfU1lTQ09OX1BXUkNOVCk7CiAJaWYgKHZhbHVlICYgRVA5M1hYX1NZU0NPTl9QV1JDTlRfVUFSVEJBVUQpCi0JCXJldHVybiBFUDkzWFhfRVhUX0NMS19SQVRFOworCQlyZXR1cm4gcmF0ZTsKIAllbHNlCi0JCXJldHVybiBFUDkzWFhfRVhUX0NMS19SQVRFIC8gMjsKKwkJcmV0dXJuIHJhdGUgLyAyOwogfQogCiB1bnNpZ25lZCBsb25nIGNsa19nZXRfcmF0ZShzdHJ1Y3QgY2xrICpjbGspCkBAIC0yNDQsMTYgKzMxNiwxNiBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgdW5zaWduZWQgbG9uZyBjYWxjX2Nsa19kaXYodW5zaWduZWQgbG9uZyByYXRlLCBpbnQgKnBzZWwsIGludCAqZXNlbCwKLQkJCQkgIGludCAqcGRpdiwgaW50ICpkaXYpCitzdGF0aWMgaW50IGNhbGNfY2xrX2RpdihzdHJ1Y3QgY2xrICpjbGssIHVuc2lnbmVkIGxvbmcgcmF0ZSwKKwkJCWludCAqcHNlbCwgaW50ICplc2VsLCBpbnQgKnBkaXYsIGludCAqZGl2KQogewotCXVuc2lnbmVkIGxvbmcgbWF4X3JhdGUsIGJlc3RfcmF0ZSA9IDAsCi0JCWFjdHVhbF9yYXRlID0gMCwgbWNsa19yYXRlID0gMCwgcmF0ZV9lcnIgPSAtMTsKKwlzdHJ1Y3QgY2xrICptY2xrOworCXVuc2lnbmVkIGxvbmcgbWF4X3JhdGUsIGFjdHVhbF9yYXRlLCBtY2xrX3JhdGUsIHJhdGVfZXJyID0gLTE7CiAJaW50IGksIGZvdW5kID0gMCwgX19kaXYgPSAwLCBfX3BkaXYgPSAwOwogCiAJLyogRG9uJ3QgZXhjZWVkIHRoZSBtYXhpbXVtIHJhdGUgKi8KIAltYXhfcmF0ZSA9IG1heChtYXgoY2xrX3BsbDEucmF0ZSAvIDQsIGNsa19wbGwyLnJhdGUgLyA0KSwKLQkJICAgICAgICh1bnNpZ25lZCBsb25nKUVQOTNYWF9FWFRfQ0xLX1JBVEUgLyA0KTsKKwkJICAgICAgIGNsa194dGFsaS5yYXRlIC8gNCk7CiAJcmF0ZSA9IG1pbihyYXRlLCBtYXhfcmF0ZSk7CiAKIAkvKgpAQCAtMjY3LDExICszMzksMTIgQEAKIAkgKi8KIAlmb3IgKGkgPSAwOyBpIDwgMzsgaSsrKSB7CiAJCWlmIChpID09IDApCi0JCQltY2xrX3JhdGUgPSBFUDkzWFhfRVhUX0NMS19SQVRFICogMjsKKwkJCW1jbGsgPSAmY2xrX3h0YWxpOwogCQllbHNlIGlmIChpID09IDEpCi0JCQltY2xrX3JhdGUgPSBjbGtfcGxsMS5yYXRlICogMjsKLQkJZWxzZSBpZiAoaSA9PSAyKQotCQkJbWNsa19yYXRlID0gY2xrX3BsbDIucmF0ZSAqIDI7CisJCQltY2xrID0gJmNsa19wbGwxOworCQllbHNlCisJCQltY2xrID0gJmNsa19wbGwyOworCQltY2xrX3JhdGUgPSBtY2xrLT5yYXRlICogMjsKIAogCQkvKiBUcnkgZWFjaCBwcmVkaXZpZGVyIHZhbHVlICovCiAJCWZvciAoX19wZGl2ID0gNDsgX19wZGl2IDw9IDY7IF9fcGRpdisrKSB7CkBAIC0yODYsNyArMzU5LDggQEAKIAkJCQkqZGl2ID0gX19kaXY7CiAJCQkJKnBzZWwgPSAoaSA9PSAyKTsKIAkJCQkqZXNlbCA9IChpICE9IDApOwotCQkJCWJlc3RfcmF0ZSA9IGFjdHVhbF9yYXRlOworCQkJCWNsay0+cGFyZW50ID0gbWNsazsKKwkJCQljbGstPnJhdGUgPSBhY3R1YWxfcmF0ZTsKIAkJCQlyYXRlX2VyciA9IGFicyhhY3R1YWxfcmF0ZSAtIHJhdGUpOwogCQkJCWZvdW5kID0gMTsKIAkJCX0KQEAgLTI5NCwyMSArMzY4LDE5IEBACiAJfQogCiAJaWYgKCFmb3VuZCkKLQkJcmV0dXJuIDA7CisJCXJldHVybiAtRUlOVkFMOwogCi0JcmV0dXJuIGJlc3RfcmF0ZTsKKwlyZXR1cm4gMDsKIH0KIAogc3RhdGljIGludCBzZXRfZGl2X3JhdGUoc3RydWN0IGNsayAqY2xrLCB1bnNpZ25lZCBsb25nIHJhdGUpCiB7Ci0JdW5zaWduZWQgbG9uZyBhY3R1YWxfcmF0ZTsKLQlpbnQgcHNlbCA9IDAsIGVzZWwgPSAwLCBwZGl2ID0gMCwgZGl2ID0gMDsKKwlpbnQgZXJyLCBwc2VsID0gMCwgZXNlbCA9IDAsIHBkaXYgPSAwLCBkaXYgPSAwOwogCXUzMiB2YWw7CiAKLQlhY3R1YWxfcmF0ZSA9IGNhbGNfY2xrX2RpdihyYXRlLCAmcHNlbCwgJmVzZWwsICZwZGl2LCAmZGl2KTsKLQlpZiAoYWN0dWFsX3JhdGUgPT0gMCkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JY2xrLT5yYXRlID0gYWN0dWFsX3JhdGU7CisJZXJyID0gY2FsY19jbGtfZGl2KGNsaywgcmF0ZSwgJnBzZWwsICZlc2VsLCAmcGRpdiwgJmRpdik7CisJaWYgKGVycikKKwkJcmV0dXJuIGVycjsKIAogCS8qIENsZWFyIHRoZSBlc2VsLCBwc2VsLCBwZGl2IGFuZCBkaXYgYml0cyAqLwogCXZhbCA9IF9fcmF3X3JlYWRsKGNsay0+ZW5hYmxlX3JlZyk7CkBAIC0zNDQsNyArNDE2LDcgQEAKIAl1bnNpZ25lZCBsb25nIGxvbmcgcmF0ZTsKIAlpbnQgaTsKIAotCXJhdGUgPSBFUDkzWFhfRVhUX0NMS19SQVRFOworCXJhdGUgPSBjbGtfeHRhbGkucmF0ZTsKIAlyYXRlICo9ICgoY29uZmlnX3dvcmQgPj4gMTEpICYgMHgxZikgKyAxOwkJLyogWDFGQkQgKi8KIAlyYXRlICo9ICgoY29uZmlnX3dvcmQgPj4gNSkgJiAweDNmKSArIDE7CQkvKiBYMkZCRCAqLwogCWRvX2RpdihyYXRlLCAoY29uZmlnX3dvcmQgJiAweDFmKSArIDEpOwkJCS8qIFgySVBEICovCkBAIC0zNzcsNyArNDQ5LDcgQEAKIAogCXZhbHVlID0gX19yYXdfcmVhZGwoRVA5M1hYX1NZU0NPTl9DTE9DS19TRVQxKTsKIAlpZiAoISh2YWx1ZSAmIDB4MDA4MDAwMDApKSB7CQkJLyogUExMMSBieXBhc3NlZD8gICovCi0JCWNsa19wbGwxLnJhdGUgPSBFUDkzWFhfRVhUX0NMS19SQVRFOworCQljbGtfcGxsMS5yYXRlID0gY2xrX3h0YWxpLnJhdGU7CiAJfSBlbHNlIHsKIAkJY2xrX3BsbDEucmF0ZSA9IGNhbGNfcGxsX3JhdGUodmFsdWUpOwogCX0KQEAgLTM4OCw3ICs0NjAsNyBAQAogCiAJdmFsdWUgPSBfX3Jhd19yZWFkbChFUDkzWFhfU1lTQ09OX0NMT0NLX1NFVDIpOwogCWlmICghKHZhbHVlICYgMHgwMDA4MDAwMCkpIHsJCQkvKiBQTEwyIGJ5cGFzc2VkPyAgKi8KLQkJY2xrX3BsbDIucmF0ZSA9IEVQOTNYWF9FWFRfQ0xLX1JBVEU7CisJCWNsa19wbGwyLnJhdGUgPSBjbGtfeHRhbGkucmF0ZTsKIAl9IGVsc2UgaWYgKHZhbHVlICYgMHgwMDA0MDAwMCkgewkJLyogUExMMiBlbmFibGVkPyAgKi8KIAkJY2xrX3BsbDIucmF0ZSA9IGNhbGNfcGxsX3JhdGUodmFsdWUpOwogCX0gZWxzZSB7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9jb3JlLmMgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9jb3JlLmMKaW5kZXggZjdlYmVkOS4uZjk1ZGMxNiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvY29yZS5jCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2NvcmUuYwpAQCAtNTUwLDEzICs1NTAsMTEgQEAKIAlwbGF0Zm9ybV9kZXZpY2VfcmVnaXN0ZXIoJmVwOTN4eF9ldGhfZGV2aWNlKTsKIH0KIAotc3RhdGljIHN0cnVjdCBpMmNfZ3Bpb19wbGF0Zm9ybV9kYXRhIGVwOTN4eF9pMmNfZGF0YSA9IHsKLQkuc2RhX3BpbgkJPSBFUDkzWFhfR1BJT19MSU5FX0VFREFULAotCS5zZGFfaXNfb3Blbl9kcmFpbgk9IDAsCi0JLnNjbF9waW4JCT0gRVA5M1hYX0dQSU9fTElORV9FRUNMSywKLQkuc2NsX2lzX29wZW5fZHJhaW4JPSAwLAotCS51ZGVsYXkJCQk9IDIsCi19OworCisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogRVA5M3h4IGkyYyBwZXJpcGhlcmFsIGhhbmRsaW5nCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK3N0YXRpYyBzdHJ1Y3QgaTJjX2dwaW9fcGxhdGZvcm1fZGF0YSBlcDkzeHhfaTJjX2RhdGE7CiAKIHN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGVwOTN4eF9pMmNfZGV2aWNlID0gewogCS5uYW1lCQkJPSAiaTJjLWdwaW8iLApAQCAtNTY0LDggKzU2MiwyNSBAQAogCS5kZXYucGxhdGZvcm1fZGF0YQk9ICZlcDkzeHhfaTJjX2RhdGEsCiB9OwogCi12b2lkIF9faW5pdCBlcDkzeHhfcmVnaXN0ZXJfaTJjKHN0cnVjdCBpMmNfYm9hcmRfaW5mbyAqZGV2aWNlcywgaW50IG51bSkKK3ZvaWQgX19pbml0IGVwOTN4eF9yZWdpc3Rlcl9pMmMoc3RydWN0IGkyY19ncGlvX3BsYXRmb3JtX2RhdGEgKmRhdGEsCisJCQkJc3RydWN0IGkyY19ib2FyZF9pbmZvICpkZXZpY2VzLCBpbnQgbnVtKQogeworCS8qCisJICogU2V0IHRoZSBFRVBST00gaW50ZXJmYWNlIHBpbiBkcml2ZSB0eXBlIGNvbnRyb2wuCisJICogRGVmaW5lcyB0aGUgZHJpdmVyIHR5cGUgZm9yIHRoZSBFRUNMSyBhbmQgRUVEQVQgcGlucyBhcyBlaXRoZXIKKwkgKiBvcGVuIGRyYWluLCB3aGljaCB3aWxsIHJlcXVpcmUgYW4gZXh0ZXJuYWwgcHVsbC11cCwgb3IgYSBub3JtYWwKKwkgKiBDTU9TIGRyaXZlci4KKwkgKi8KKwlpZiAoZGF0YS0+c2RhX2lzX29wZW5fZHJhaW4gJiYgZGF0YS0+c2RhX3BpbiAhPSBFUDkzWFhfR1BJT19MSU5FX0VFREFUKQorCQlwcl93YXJuaW5nKCJlcDkzeHg6IHNkYSAhPSBFRURBVCwgb3BlbiBkcmFpbiBoYXMgbm8gZWZmZWN0XG4iKTsKKwlpZiAoZGF0YS0+c2NsX2lzX29wZW5fZHJhaW4gJiYgZGF0YS0+c2NsX3BpbiAhPSBFUDkzWFhfR1BJT19MSU5FX0VFQ0xLKQorCQlwcl93YXJuaW5nKCJlcDkzeHg6IHNjbCAhPSBFRUNMSywgb3BlbiBkcmFpbiBoYXMgbm8gZWZmZWN0XG4iKTsKKworCV9fcmF3X3dyaXRlbCgoZGF0YS0+c2RhX2lzX29wZW5fZHJhaW4gPDwgMSkgfAorCQkgICAgIChkYXRhLT5zY2xfaXNfb3Blbl9kcmFpbiA8PCAwKSwKKwkJICAgICBFUDkzWFhfR1BJT19FRURSSVZFKTsKKworCWVwOTN4eF9pMmNfZGF0YSA9ICpkYXRhOwogCWkyY19yZWdpc3Rlcl9ib2FyZF9pbmZvKDAsIGRldmljZXMsIG51bSk7CiAJcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZlcDkzeHhfaTJjX2RldmljZSk7CiB9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9lZGI5M3h4LmMgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9lZGI5M3h4LmMKaW5kZXggNzMxNDVhZS4uY2E3MWNmMSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvZWRiOTN4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2VkYjkzeHguYwpAQCAtMjcsOCArMjcsMTAgQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+Ci0jaW5jbHVkZSA8bGludXgvaTJjLmg+CiAjaW5jbHVkZSA8bGludXgvbXRkL3BoeXNtYXAuaD4KKyNpbmNsdWRlIDxsaW51eC9ncGlvLmg+CisjaW5jbHVkZSA8bGludXgvaTJjLmg+CisjaW5jbHVkZSA8bGludXgvaTJjLWdwaW8uaD4KIAogI2luY2x1ZGUgPG1hY2gvaGFyZHdhcmUuaD4KIApAQCAtNzYsMTMgKzc4LDI2IEBACiAJLnBoeV9pZAkJPSAxLAogfTsKIAotc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBfX2luaXRkYXRhIGVkYjkzeHhhX2kyY19kYXRhW10gPSB7CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBFREI5M3h4IGkyYyBwZXJpcGhlcmFsIGhhbmRsaW5nCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KK3N0YXRpYyBzdHJ1Y3QgaTJjX2dwaW9fcGxhdGZvcm1fZGF0YSBlZGI5M3h4X2kyY19ncGlvX2RhdGEgPSB7CisJLnNkYV9waW4JCT0gRVA5M1hYX0dQSU9fTElORV9FRURBVCwKKwkuc2RhX2lzX29wZW5fZHJhaW4JPSAwLAorCS5zY2xfcGluCQk9IEVQOTNYWF9HUElPX0xJTkVfRUVDTEssCisJLnNjbF9pc19vcGVuX2RyYWluCT0gMCwKKwkudWRlbGF5CQkJPSAwLAkvKiBkZWZhdWx0IHRvIDEwMCBrSHogKi8KKwkudGltZW91dAkJPSAwLAkvKiBkZWZhdWx0IHRvIDEwMCBtcyAqLworfTsKKworc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBfX2luaXRkYXRhIGVkYjkzeHhhX2kyY19ib2FyZF9pbmZvW10gPSB7CiAJewogCQlJMkNfQk9BUkRfSU5GTygiaXNsMTIwOCIsIDB4NmYpLAogCX0sCiB9OwogCi1zdGF0aWMgc3RydWN0IGkyY19ib2FyZF9pbmZvIF9faW5pdGRhdGEgZWRiOTN4eF9pMmNfZGF0YVtdID0geworc3RhdGljIHN0cnVjdCBpMmNfYm9hcmRfaW5mbyBfX2luaXRkYXRhIGVkYjkzeHhfaTJjX2JvYXJkX2luZm9bXSA9IHsKIAl7CiAJCUkyQ19CT0FSRF9JTkZPKCJkczEzMzciLCAweDY4KSwKIAl9LApAQCAtOTIsMTIgKzEwNywxNCBAQAogewogCWlmIChtYWNoaW5lX2lzX2VkYjkzMDJhKCkgfHwgbWFjaGluZV9pc19lZGI5MzA3YSgpIHx8CiAJICAgIG1hY2hpbmVfaXNfZWRiOTMxNWEoKSkgewotCQllcDkzeHhfcmVnaXN0ZXJfaTJjKGVkYjkzeHhhX2kyY19kYXRhLAotCQkJCUFSUkFZX1NJWkUoZWRiOTN4eGFfaTJjX2RhdGEpKTsKKwkJZXA5M3h4X3JlZ2lzdGVyX2kyYygmZWRiOTN4eF9pMmNfZ3Bpb19kYXRhLAorCQkJCSAgICBlZGI5M3h4YV9pMmNfYm9hcmRfaW5mbywKKwkJCQkgICAgQVJSQVlfU0laRShlZGI5M3h4YV9pMmNfYm9hcmRfaW5mbykpOwogCX0gZWxzZSBpZiAobWFjaGluZV9pc19lZGI5MzA3KCkgfHwgbWFjaGluZV9pc19lZGI5MzEyKCkgfHwKIAkJICAgbWFjaGluZV9pc19lZGI5MzE1KCkpIHsKLQkJZXA5M3h4X3JlZ2lzdGVyX2kyYyhlZGI5M3h4X2kyY19kYXRhLAotCQkJCUFSUkFZX1NJWkUoZWRiOTN4eF9pMmNfZGF0YSkpOworCQllcDkzeHhfcmVnaXN0ZXJfaTJjKCZlZGI5M3h4X2kyY19ncGlvX2RhdGEKKwkJCQkgICAgZWRiOTN4eF9pMmNfYm9hcmRfaW5mbywKKwkJCQkgICAgQVJSQVlfU0laRShlZGI5M3h4X2kyY19ib2FyZF9pbmZvKSk7CiAJfQogfQogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9pbmNsdWRlL21hY2gvZXA5M3h4LXJlZ3MuaCBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2luY2x1ZGUvbWFjaC9lcDkzeHgtcmVncy5oCmluZGV4IDBmYmY4N2IuLmIxZjkzN2UgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L2luY2x1ZGUvbWFjaC9lcDkzeHgtcmVncy5oCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2luY2x1ZGUvbWFjaC9lcDkzeHgtcmVncy5oCkBAIC01MiwyNSArNTIsMjcgQEAKICNkZWZpbmUgRVA5M1hYX0FIQl9WSVJUX0JBU0UJCTB4ZmVmMDAwMDAKICNkZWZpbmUgRVA5M1hYX0FIQl9TSVpFCQkJMHgwMDEwMDAwMAogCisjZGVmaW5lIEVQOTNYWF9BSEJfUEhZUyh4KQkJKEVQOTNYWF9BSEJfUEhZU19CQVNFICsgKHgpKQogI2RlZmluZSBFUDkzWFhfQUhCX0lPTUVNKHgpCQlJT01FTShFUDkzWFhfQUhCX1ZJUlRfQkFTRSArICh4KSkKIAogI2RlZmluZSBFUDkzWFhfQVBCX1BIWVNfQkFTRQkJMHg4MDgwMDAwMAogI2RlZmluZSBFUDkzWFhfQVBCX1ZJUlRfQkFTRQkJMHhmZWQwMDAwMAogI2RlZmluZSBFUDkzWFhfQVBCX1NJWkUJCQkweDAwMjAwMDAwCiAKKyNkZWZpbmUgRVA5M1hYX0FQQl9QSFlTKHgpCQkoRVA5M1hYX0FQQl9QSFlTX0JBU0UgKyAoeCkpCiAjZGVmaW5lIEVQOTNYWF9BUEJfSU9NRU0oeCkJCUlPTUVNKEVQOTNYWF9BUEJfVklSVF9CQVNFICsgKHgpKQogCiAKIC8qIEFIQiBwZXJpcGhlcmFscyAqLwogI2RlZmluZSBFUDkzWFhfRE1BX0JBU0UJCQlFUDkzWFhfQUhCX0lPTUVNKDB4MDAwMDAwMDApCiAKLSNkZWZpbmUgRVA5M1hYX0VUSEVSTkVUX1BIWVNfQkFTRQkoRVA5M1hYX0FIQl9QSFlTX0JBU0UgKyAweDAwMDEwMDAwKQorI2RlZmluZSBFUDkzWFhfRVRIRVJORVRfUEhZU19CQVNFCUVQOTNYWF9BSEJfUEhZUygweDAwMDEwMDAwKQogI2RlZmluZSBFUDkzWFhfRVRIRVJORVRfQkFTRQkJRVA5M1hYX0FIQl9JT01FTSgweDAwMDEwMDAwKQogCi0jZGVmaW5lIEVQOTNYWF9VU0JfUEhZU19CQVNFCQkoRVA5M1hYX0FIQl9QSFlTX0JBU0UgKyAweDAwMDIwMDAwKQorI2RlZmluZSBFUDkzWFhfVVNCX1BIWVNfQkFTRQkJRVA5M1hYX0FIQl9QSFlTKDB4MDAwMjAwMDApCiAjZGVmaW5lIEVQOTNYWF9VU0JfQkFTRQkJCUVQOTNYWF9BSEJfSU9NRU0oMHgwMDAyMDAwMCkKIAotI2RlZmluZSBFUDkzWFhfUkFTVEVSX1BIWVNfQkFTRQkJKEVQOTNYWF9BSEJfUEhZU19CQVNFICsgMHgwMDAzMDAwMCkKKyNkZWZpbmUgRVA5M1hYX1JBU1RFUl9QSFlTX0JBU0UJCUVQOTNYWF9BSEJfUEhZUygweDAwMDMwMDAwKQogI2RlZmluZSBFUDkzWFhfUkFTVEVSX0JBU0UJCUVQOTNYWF9BSEJfSU9NRU0oMHgwMDAzMDAwMCkKIAogI2RlZmluZSBFUDkzWFhfR1JBUEhJQ1NfQUNDRUxfQkFTRQlFUDkzWFhfQUhCX0lPTUVNKDB4MDAwNDAwMDApCkBAIC0xMTIsMjEgKzExNCwxMCBAQAogCiAjZGVmaW5lIEVQOTNYWF9HUElPX0JBU0UJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDA0MDAwMCkKICNkZWZpbmUgRVA5M1hYX0dQSU9fUkVHKHgpCQkoRVA5M1hYX0dQSU9fQkFTRSArICh4KSkKLSNkZWZpbmUgRVA5M1hYX0dQSU9fRl9JTlRfVFlQRTEJCUVQOTNYWF9HUElPX1JFRygweDRjKQotI2RlZmluZSBFUDkzWFhfR1BJT19GX0lOVF9UWVBFMgkJRVA5M1hYX0dQSU9fUkVHKDB4NTApCi0jZGVmaW5lIEVQOTNYWF9HUElPX0ZfSU5UX0FDSwkJRVA5M1hYX0dQSU9fUkVHKDB4NTQpCi0jZGVmaW5lIEVQOTNYWF9HUElPX0ZfSU5UX0VOQUJMRQlFUDkzWFhfR1BJT19SRUcoMHg1OCkKICNkZWZpbmUgRVA5M1hYX0dQSU9fRl9JTlRfU1RBVFVTCUVQOTNYWF9HUElPX1JFRygweDVjKQotI2RlZmluZSBFUDkzWFhfR1BJT19BX0lOVF9UWVBFMQkJRVA5M1hYX0dQSU9fUkVHKDB4OTApCi0jZGVmaW5lIEVQOTNYWF9HUElPX0FfSU5UX1RZUEUyCQlFUDkzWFhfR1BJT19SRUcoMHg5NCkKLSNkZWZpbmUgRVA5M1hYX0dQSU9fQV9JTlRfQUNLCQlFUDkzWFhfR1BJT19SRUcoMHg5OCkKLSNkZWZpbmUgRVA5M1hYX0dQSU9fQV9JTlRfRU5BQkxFCUVQOTNYWF9HUElPX1JFRygweDljKQogI2RlZmluZSBFUDkzWFhfR1BJT19BX0lOVF9TVEFUVVMJRVA5M1hYX0dQSU9fUkVHKDB4YTApCi0jZGVmaW5lIEVQOTNYWF9HUElPX0JfSU5UX1RZUEUxCQlFUDkzWFhfR1BJT19SRUcoMHhhYykKLSNkZWZpbmUgRVA5M1hYX0dQSU9fQl9JTlRfVFlQRTIJCUVQOTNYWF9HUElPX1JFRygweGIwKQotI2RlZmluZSBFUDkzWFhfR1BJT19CX0lOVF9BQ0sJCUVQOTNYWF9HUElPX1JFRygweGI0KQotI2RlZmluZSBFUDkzWFhfR1BJT19CX0lOVF9FTkFCTEUJRVA5M1hYX0dQSU9fUkVHKDB4YjgpCiAjZGVmaW5lIEVQOTNYWF9HUElPX0JfSU5UX1NUQVRVUwlFUDkzWFhfR1BJT19SRUcoMHhiYykKKyNkZWZpbmUgRVA5M1hYX0dQSU9fRUVEUklWRQkJRVA5M1hYX0dQSU9fUkVHKDB4YzgpCiAKICNkZWZpbmUgRVA5M1hYX0FBQ19CQVNFCQkJRVA5M1hYX0FQQl9JT01FTSgweDAwMDgwMDAwKQogCkBAIC0xMzQsMTMgKzEyNSwxMyBAQAogCiAjZGVmaW5lIEVQOTNYWF9JUkRBX0JBU0UJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDBiMDAwMCkKIAotI2RlZmluZSBFUDkzWFhfVUFSVDFfUEhZU19CQVNFCQkoRVA5M1hYX0FQQl9QSFlTX0JBU0UgKyAweDAwMGMwMDAwKQorI2RlZmluZSBFUDkzWFhfVUFSVDFfUEhZU19CQVNFCQlFUDkzWFhfQVBCX1BIWVMoMHgwMDBjMDAwMCkKICNkZWZpbmUgRVA5M1hYX1VBUlQxX0JBU0UJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDBjMDAwMCkKIAotI2RlZmluZSBFUDkzWFhfVUFSVDJfUEhZU19CQVNFCQkoRVA5M1hYX0FQQl9QSFlTX0JBU0UgKyAweDAwMGQwMDAwKQorI2RlZmluZSBFUDkzWFhfVUFSVDJfUEhZU19CQVNFCQlFUDkzWFhfQVBCX1BIWVMoMHgwMDBkMDAwMCkKICNkZWZpbmUgRVA5M1hYX1VBUlQyX0JBU0UJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDBkMDAwMCkKIAotI2RlZmluZSBFUDkzWFhfVUFSVDNfUEhZU19CQVNFCQkoRVA5M1hYX0FQQl9QSFlTX0JBU0UgKyAweDAwMGUwMDAwKQorI2RlZmluZSBFUDkzWFhfVUFSVDNfUEhZU19CQVNFCQlFUDkzWFhfQVBCX1BIWVMoMHgwMDBlMDAwMCkKICNkZWZpbmUgRVA5M1hYX1VBUlQzX0JBU0UJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDBlMDAwMCkKIAogI2RlZmluZSBFUDkzWFhfS0VZX01BVFJJWF9CQVNFCQlFUDkzWFhfQVBCX0lPTUVNKDB4MDAwZjAwMDApCkBAIC0xNDgsMTAgKzEzOSwxMCBAQAogI2RlZmluZSBFUDkzWFhfQURDX0JBU0UJCQlFUDkzWFhfQVBCX0lPTUVNKDB4MDAxMDAwMDApCiAjZGVmaW5lIEVQOTNYWF9UT1VDSFNDUkVFTl9CQVNFCQlFUDkzWFhfQVBCX0lPTUVNKDB4MDAxMDAwMDApCiAKLSNkZWZpbmUgRVA5M1hYX1BXTV9QSFlTX0JBU0UJCShFUDkzWFhfQVBCX1BIWVNfQkFTRSArIDB4MDAxMTAwMDApCisjZGVmaW5lIEVQOTNYWF9QV01fUEhZU19CQVNFCQlFUDkzWFhfQVBCX1BIWVMoMHgwMDExMDAwMCkKICNkZWZpbmUgRVA5M1hYX1BXTV9CQVNFCQkJRVA5M1hYX0FQQl9JT01FTSgweDAwMTEwMDAwKQogCi0jZGVmaW5lIEVQOTNYWF9SVENfUEhZU19CQVNFCQkoRVA5M1hYX0FQQl9QSFlTX0JBU0UgKyAweDAwMTIwMDAwKQorI2RlZmluZSBFUDkzWFhfUlRDX1BIWVNfQkFTRQkJRVA5M1hYX0FQQl9QSFlTKDB4MDAxMjAwMDApCiAjZGVmaW5lIEVQOTNYWF9SVENfQkFTRQkJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDEyMDAwMCkKIAogI2RlZmluZSBFUDkzWFhfU1lTQ09OX0JBU0UJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDEzMDAwMCkKQEAgLTIxOCw2ICsyMDksMTcgQEAKICNkZWZpbmUgRVA5M1hYX1NZU0NPTl9LRVlUQ0hDTEtESVZfQURJVgkoMTw8MTYpCiAjZGVmaW5lIEVQOTNYWF9TWVNDT05fS0VZVENIQ0xLRElWX0tFTgkoMTw8MTUpCiAjZGVmaW5lIEVQOTNYWF9TWVNDT05fS0VZVENIQ0xLRElWX0tESVYJKDE8PDApCisjZGVmaW5lIEVQOTNYWF9TWVNDT05fU1lTQ0ZHCQlFUDkzWFhfU1lTQ09OX1JFRygweDljKQorI2RlZmluZSBFUDkzWFhfU1lTQ09OX1NZU0NGR19SRVZfTUFTSwkoMHhmMDAwMDAwMCkKKyNkZWZpbmUgRVA5M1hYX1NZU0NPTl9TWVNDRkdfUkVWX1NISUZUCSgyOCkKKyNkZWZpbmUgRVA5M1hYX1NZU0NPTl9TWVNDRkdfU0JPT1QJKDE8PDgpCisjZGVmaW5lIEVQOTNYWF9TWVNDT05fU1lTQ0ZHX0xDU043CSgxPDw3KQorI2RlZmluZSBFUDkzWFhfU1lTQ09OX1NZU0NGR19MQ1NONgkoMTw8NikKKyNkZWZpbmUgRVA5M1hYX1NZU0NPTl9TWVNDRkdfTEFTRE8JKDE8PDUpCisjZGVmaW5lIEVQOTNYWF9TWVNDT05fU1lTQ0ZHX0xFRURBCSgxPDw0KQorI2RlZmluZSBFUDkzWFhfU1lTQ09OX1NZU0NGR19MRUVDTEsJKDE8PDMpCisjZGVmaW5lIEVQOTNYWF9TWVNDT05fU1lTQ0ZHX0xDU04yCSgxPDwxKQorI2RlZmluZSBFUDkzWFhfU1lTQ09OX1NZU0NGR19MQ1NOMQkoMTw8MCkKICNkZWZpbmUgRVA5M1hYX1NZU0NPTl9TV0xPQ0sJCUVQOTNYWF9TWVNDT05fUkVHKDB4YzApCiAKICNkZWZpbmUgRVA5M1hYX1dBVENIRE9HX0JBU0UJCUVQOTNYWF9BUEJfSU9NRU0oMHgwMDE0MDAwMCkKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L2luY2x1ZGUvbWFjaC9ncGlvLmggYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9pbmNsdWRlL21hY2gvZ3Bpby5oCmluZGV4IDBhMTQ5OGEuLmM5OTFiMTQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L2luY2x1ZGUvbWFjaC9ncGlvLmgKKysrIGIvYXJjaC9hcm0vbWFjaC1lcDkzeHgvaW5jbHVkZS9tYWNoL2dwaW8uaApAQCAtMTE0LDE3ICsxMTQsOSBAQAogICogICAgICAgICAgQjAuLkI3ICAoNy4uMTUpIHRvIGlycSA3Mi4uNzksIGFuZAogICogICAgICAgICAgRjAuLkY3ICgxNi4uMjQpIHRvIGlycSA4MC4uODcuCiAgKi8KLXN0YXRpYyBpbmxpbmUgaW50IGdwaW9fdG9faXJxKHVuc2lnbmVkIGdwaW8pCi17Ci0JaWYgKGdwaW8gPD0gRVA5M1hYX0dQSU9fTElORV9NQVhfSVJRKQotCQlyZXR1cm4gNjQgKyBncGlvOworI2RlZmluZSBncGlvX3RvX2lycShncGlvKQlcCisJKCgoZ3BpbykgPD0gRVA5M1hYX0dQSU9fTElORV9NQVhfSVJRKSA/ICg2NCArIChncGlvKSkgOiAtRUlOVkFMKQogCi0JcmV0dXJuIC1FSU5WQUw7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IGlycV90b19ncGlvKHVuc2lnbmVkIGlycSkKLXsKLQlyZXR1cm4gaXJxIC0gZ3Bpb190b19pcnEoMCk7Ci19CisjZGVmaW5lIGlycV90b19ncGlvKGlycSkJKChpcnEpIC0gZ3Bpb190b19pcnEoMCkpCiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvaW5jbHVkZS9tYWNoL21lbW9yeS5oIGIvYXJjaC9hcm0vbWFjaC1lcDkzeHgvaW5jbHVkZS9tYWNoL21lbW9yeS5oCmluZGV4IDkyNWIxMmUuLjU1NDA2NGUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L2luY2x1ZGUvbWFjaC9tZW1vcnkuaAorKysgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9pbmNsdWRlL21hY2gvbWVtb3J5LmgKQEAgLTksNiArOSwxMiBAQAogI2RlZmluZSBQSFlTX09GRlNFVAkJVUwoMHgwMDAwMDAwMCkKICNlbGlmIGRlZmluZWQoQ09ORklHX0VQOTNYWF9TRENFMF9QSFlTX09GRlNFVCkKICNkZWZpbmUgUEhZU19PRkZTRVQJCVVMKDB4YzAwMDAwMDApCisjZWxpZiBkZWZpbmVkKENPTkZJR19FUDkzWFhfU0RDRTFfUEhZU19PRkZTRVQpCisjZGVmaW5lIFBIWVNfT0ZGU0VUCQlVTCgweGQwMDAwMDAwKQorI2VsaWYgZGVmaW5lZChDT05GSUdfRVA5M1hYX1NEQ0UyX1BIWVNfT0ZGU0VUKQorI2RlZmluZSBQSFlTX09GRlNFVAkJVUwoMHhlMDAwMDAwMCkKKyNlbGlmIGRlZmluZWQoQ09ORklHX0VQOTNYWF9TRENFM19BU1lOQ19QSFlTX09GRlNFVCkKKyNkZWZpbmUgUEhZU19PRkZTRVQJCVVMKDB4ZjAwMDAwMDApCiAjZWxzZQogI2Vycm9yICJLY29uZmlnIGJ1ZzogTm8gRVA5M3h4IFBIWVNfT0ZGU0VUIHNldCIKICNlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgvaW5jbHVkZS9tYWNoL3BsYXRmb3JtLmggYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9pbmNsdWRlL21hY2gvcGxhdGZvcm0uaAppbmRleCAwMWEwZjA4Li5hM2VjMzNmIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9pbmNsdWRlL21hY2gvcGxhdGZvcm0uaAorKysgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9pbmNsdWRlL21hY2gvcGxhdGZvcm0uaApAQCAtNCw2ICs0LDcgQEAKIAogI2lmbmRlZiBfX0FTU0VNQkxZX18KIAorc3RydWN0IGkyY19ncGlvX3BsYXRmb3JtX2RhdGE7CiBzdHJ1Y3QgaTJjX2JvYXJkX2luZm87CiBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlOwogc3RydWN0IGVwOTN4eGZiX21hY2hfaW5mbzsKQEAgLTMzLDcgKzM0LDggQEAKIH0KIAogdm9pZCBlcDkzeHhfcmVnaXN0ZXJfZXRoKHN0cnVjdCBlcDkzeHhfZXRoX2RhdGEgKmRhdGEsIGludCBjb3B5X2FkZHIpOwotdm9pZCBlcDkzeHhfcmVnaXN0ZXJfaTJjKHN0cnVjdCBpMmNfYm9hcmRfaW5mbyAqZGV2aWNlcywgaW50IG51bSk7Cit2b2lkIGVwOTN4eF9yZWdpc3Rlcl9pMmMoc3RydWN0IGkyY19ncGlvX3BsYXRmb3JtX2RhdGEgKmRhdGEsCisJCQkgc3RydWN0IGkyY19ib2FyZF9pbmZvICpkZXZpY2VzLCBpbnQgbnVtKTsKIHZvaWQgZXA5M3h4X3JlZ2lzdGVyX2ZiKHN0cnVjdCBlcDkzeHhmYl9tYWNoX2luZm8gKmRhdGEpOwogdm9pZCBlcDkzeHhfcmVnaXN0ZXJfcHdtKGludCBwd20wLCBpbnQgcHdtMSk7CiBpbnQgZXA5M3h4X3B3bV9hY3F1aXJlX2dwaW8oc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldik7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWVwOTN4eC9taWNybzkuYyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L21pY3JvOS5jCmluZGV4IDBhMzEzZTguLmQ4M2I4MDQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L21pY3JvOS5jCisrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L21pY3JvOS5jCkBAIC0yLDcgKzIsOSBAQAogICogIGxpbnV4L2FyY2gvYXJtL21hY2gtZXA5M3h4L21pY3JvOS5jCiAgKgogICogQ29weXJpZ2h0IChDKSAyMDA2IENvbnRlYyBTdGV1ZXJ1bmdzdGVjaG5payAmIEF1dG9tYXRpb24gR21iSAotICogICAgICAgICAgICAgICAgICAgTWFuZnJlZCBHcnViZXIgPG1hbmZyZWQuZ3J1YmVyQGNvbnRlYy5hdD4KKyAqICAgICAgICAgICAgICAgICAgICBNYW5mcmVkIEdydWJlciA8bS5ncnViZXJAdGlyb2wuY29tPgorICogQ29weXJpZ2h0IChDKSAyMDA5IENvbnRlYyBTdGV1ZXJ1bmdzdGVjaG5payAmIEF1dG9tYXRpb24gR21iSAorICogICAgICAgICAgICAgICAgICAgIEh1YmVydCBGZXVyc3RlaW4gPGh1YmVydC5mZXVyc3RlaW5AY29udGVjLmF0PgogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwpAQCAtMjAsMTA0ICsyMiwxMjQgQEAKICNpbmNsdWRlIDxhc20vbWFjaC9hcmNoLmg+CiAKIAotc3RhdGljIHN0cnVjdCBlcDkzeHhfZXRoX2RhdGEgbWljcm85X2V0aF9kYXRhID0gewotCS5waHlfaWQJCT0gMHgxZiwKLX07CisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogTWljcm85IE5PUiBGbGFzaAorICoKKyAqIE1pY3JvOS1IaWdoIGhhcyB1cCB0byA2NE1CIG9mIDMyLWJpdCBmbGFzaCBvbiBDUzEKKyAqIE1pY3JvOS1NaWQgaGFzIHVwIHRvIDY0TUIgb2YgZWl0aGVyIDMyLWJpdCBvciAxNi1iaXQgZmxhc2ggb24gQ1MxCisgKiBNaWNybzktTGl0ZSB1c2VzIGEgc2VwZXJhdGUgTVREIG1hcCBkcml2ZXIgZm9yIGZsYXNoIHN1cHBvcnQKKyAqIE1pY3JvOS1TbGltIGhhcyB1cCB0byA2NE1CIG9mIGVpdGhlciAzMi1iaXQgb3IgMTYtYml0IGZsYXNoIG9uIENTMQorICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCitzdGF0aWMgc3RydWN0IHBoeXNtYXBfZmxhc2hfZGF0YSBtaWNybzlfZmxhc2hfZGF0YTsKIAotc3RhdGljIHZvaWQgX19pbml0IG1pY3JvOV9pbml0KHZvaWQpCi17Ci0JZXA5M3h4X3JlZ2lzdGVyX2V0aCgmbWljcm85X2V0aF9kYXRhLCAxKTsKLX0KLQotLyoKLSAqIE1pY3JvOS1ICi0gKi8KLSNpZmRlZiBDT05GSUdfTUFDSF9NSUNSTzlICi1zdGF0aWMgc3RydWN0IHBoeXNtYXBfZmxhc2hfZGF0YSBtaWNybzloX2ZsYXNoX2RhdGEgPSB7Ci0JLndpZHRoCQk9IDQsCi19OwotCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIG1pY3JvOWhfZmxhc2hfcmVzb3VyY2UgPSB7CitzdGF0aWMgc3RydWN0IHJlc291cmNlIG1pY3JvOV9mbGFzaF9yZXNvdXJjZSA9IHsKIAkuc3RhcnQJCT0gRVA5M1hYX0NTMV9QSFlTX0JBU0UsCiAJLmVuZAkJPSBFUDkzWFhfQ1MxX1BIWVNfQkFTRSArIFNaXzY0TSAtIDEsCiAJLmZsYWdzCQk9IElPUkVTT1VSQ0VfTUVNLAogfTsKIAotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgbWljcm85aF9mbGFzaCA9IHsKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIG1pY3JvOV9mbGFzaCA9IHsKIAkubmFtZQkJPSAicGh5c21hcC1mbGFzaCIsCiAJLmlkCQk9IDAsCiAJLmRldgkJPSB7Ci0JCS5wbGF0Zm9ybV9kYXRhCT0gJm1pY3JvOWhfZmxhc2hfZGF0YSwKKwkJLnBsYXRmb3JtX2RhdGEJPSAmbWljcm85X2ZsYXNoX2RhdGEsCiAJfSwKIAkubnVtX3Jlc291cmNlcwk9IDEsCi0JLnJlc291cmNlCT0gJm1pY3JvOWhfZmxhc2hfcmVzb3VyY2UsCisJLnJlc291cmNlCT0gJm1pY3JvOV9mbGFzaF9yZXNvdXJjZSwKIH07CiAKLXN0YXRpYyB2b2lkIF9faW5pdCBtaWNybzloX2luaXQodm9pZCkKK3N0YXRpYyB2b2lkIF9faW5pdCBfX21pY3JvOV9yZWdpc3Rlcl9mbGFzaCh1bnNpZ25lZCBpbnQgd2lkdGgpCiB7Ci0JcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZtaWNybzloX2ZsYXNoKTsKKwltaWNybzlfZmxhc2hfZGF0YS53aWR0aCA9IHdpZHRoOworCisJcGxhdGZvcm1fZGV2aWNlX3JlZ2lzdGVyKCZtaWNybzlfZmxhc2gpOwogfQogCi1zdGF0aWMgdm9pZCBfX2luaXQgbWljcm85aF9pbml0X21hY2hpbmUodm9pZCkKK3N0YXRpYyB1bnNpZ25lZCBpbnQgX19pbml0IG1pY3JvOV9kZXRlY3RfYm9vdHdpZHRoKHZvaWQpCit7CisJdTMyIHY7CisKKwkvKiBEZXRlY3QgdGhlIGJ1cyB3aWR0aCBvZiB0aGUgZXh0ZXJuYWwgZmxhc2ggbWVtb3J5ICovCisJdiA9IF9fcmF3X3JlYWRsKEVQOTNYWF9TWVNDT05fU1lTQ0ZHKTsKKwlpZiAodiAmIEVQOTNYWF9TWVNDT05fU1lTQ0ZHX0xDU043KQorCQlyZXR1cm4gNDsgLyogMzItYml0ICovCisJZWxzZQorCQlyZXR1cm4gMjsgLyogMTYtYml0ICovCit9CisKK3N0YXRpYyB2b2lkIF9faW5pdCBtaWNybzlfcmVnaXN0ZXJfZmxhc2godm9pZCkKK3sKKwlpZiAobWFjaGluZV9pc19taWNybzkoKSkKKwkJX19taWNybzlfcmVnaXN0ZXJfZmxhc2goNCk7CisJZWxzZSBpZiAobWFjaGluZV9pc19taWNybzltKCkgfHwgbWFjaGluZV9pc19taWNybzlzKCkpCisJCV9fbWljcm85X3JlZ2lzdGVyX2ZsYXNoKG1pY3JvOV9kZXRlY3RfYm9vdHdpZHRoKCkpOworfQorCisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBNaWNybzkgRXRoZXJuZXQKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworc3RhdGljIHN0cnVjdCBlcDkzeHhfZXRoX2RhdGEgbWljcm85X2V0aF9kYXRhID0geworCS5waHlfaWQJCT0gMHgxZiwKK307CisKKworc3RhdGljIHZvaWQgX19pbml0IG1pY3JvOV9pbml0X21hY2hpbmUodm9pZCkKIHsKIAllcDkzeHhfaW5pdF9kZXZpY2VzKCk7Ci0JbWljcm85X2luaXQoKTsKLQltaWNybzloX2luaXQoKTsKKwllcDkzeHhfcmVnaXN0ZXJfZXRoKCZtaWNybzlfZXRoX2RhdGEsIDEpOworCW1pY3JvOV9yZWdpc3Rlcl9mbGFzaCgpOwogfQogCi1NQUNISU5FX1NUQVJUKE1JQ1JPOSwgIkNvbnRlYyBIeXBlcmNvbnRyb2wgTWljcm85LUgiKQotCS8qIE1haW50YWluZXI6IE1hbmZyZWQgR3J1YmVyIDxtYW5mcmVkLmdydWJlckBjb250ZWMuYXQ+ICovCisKKyNpZmRlZiBDT05GSUdfTUFDSF9NSUNSTzlICitNQUNISU5FX1NUQVJUKE1JQ1JPOSwgIkNvbnRlYyBNaWNybzktSGlnaCIpCisJLyogTWFpbnRhaW5lcjogSHViZXJ0IEZldXJzdGVpbiA8aHViZXJ0LmZldXJzdGVpbkBjb250ZWMuYXQ+ICovCiAJLnBoeXNfaW8JPSBFUDkzWFhfQVBCX1BIWVNfQkFTRSwKIAkuaW9fcGdfb2Zmc3QJPSAoKEVQOTNYWF9BUEJfVklSVF9CQVNFKSA+PiAxOCkgJiAweGZmZmMsCiAJLmJvb3RfcGFyYW1zCT0gRVA5M1hYX1NEQ0UzX1BIWVNfQkFTRV9TWU5DICsgMHgxMDAsCiAJLm1hcF9pbwkJPSBlcDkzeHhfbWFwX2lvLAogCS5pbml0X2lycQk9IGVwOTN4eF9pbml0X2lycSwKIAkudGltZXIJCT0gJmVwOTN4eF90aW1lciwKLQkuaW5pdF9tYWNoaW5lCT0gbWljcm85aF9pbml0X21hY2hpbmUsCisJLmluaXRfbWFjaGluZQk9IG1pY3JvOV9pbml0X21hY2hpbmUsCiBNQUNISU5FX0VORAogI2VuZGlmCiAKLS8qCi0gKiBNaWNybzktTQotICovCiAjaWZkZWYgQ09ORklHX01BQ0hfTUlDUk85TQotc3RhdGljIHZvaWQgX19pbml0IG1pY3JvOW1faW5pdF9tYWNoaW5lKHZvaWQpCi17Ci0JZXA5M3h4X2luaXRfZGV2aWNlcygpOwotCW1pY3JvOV9pbml0KCk7Ci19Ci0KLU1BQ0hJTkVfU1RBUlQoTUlDUk85TSwgIkNvbnRlYyBIeXBlcmNvbnRyb2wgTWljcm85LU0iKQotCS8qIE1haW50YWluZXI6IE1hbmZyZWQgR3J1YmVyIDxtYW5mcmVkLmdydWJlckBjb250ZWMuYXQ+ICovCitNQUNISU5FX1NUQVJUKE1JQ1JPOU0sICJDb250ZWMgTWljcm85LU1pZCIpCisJLyogTWFpbnRhaW5lcjogSHViZXJ0IEZldXJzdGVpbiA8aHViZXJ0LmZldXJzdGVpbkBjb250ZWMuYXQ+ICovCiAJLnBoeXNfaW8JPSBFUDkzWFhfQVBCX1BIWVNfQkFTRSwKIAkuaW9fcGdfb2Zmc3QJPSAoKEVQOTNYWF9BUEJfVklSVF9CQVNFKSA+PiAxOCkgJiAweGZmZmMsCi0JLmJvb3RfcGFyYW1zCT0gRVA5M1hYX1NEQ0UzX1BIWVNfQkFTRV9TWU5DICsgMHgxMDAsCisJLmJvb3RfcGFyYW1zCT0gRVA5M1hYX1NEQ0UzX1BIWVNfQkFTRV9BU1lOQyArIDB4MTAwLAogCS5tYXBfaW8JCT0gZXA5M3h4X21hcF9pbywKIAkuaW5pdF9pcnEJPSBlcDkzeHhfaW5pdF9pcnEsCiAJLnRpbWVyCQk9ICZlcDkzeHhfdGltZXIsCi0JLmluaXRfbWFjaGluZQk9IG1pY3JvOW1faW5pdF9tYWNoaW5lLAorCS5pbml0X21hY2hpbmUJPSBtaWNybzlfaW5pdF9tYWNoaW5lLAogTUFDSElORV9FTkQKICNlbmRpZgogCi0vKgotICogTWljcm85LUwKLSAqLwogI2lmZGVmIENPTkZJR19NQUNIX01JQ1JPOUwKLXN0YXRpYyB2b2lkIF9faW5pdCBtaWNybzlsX2luaXRfbWFjaGluZSh2b2lkKQotewotCWVwOTN4eF9pbml0X2RldmljZXMoKTsKLQltaWNybzlfaW5pdCgpOwotfQotCi1NQUNISU5FX1NUQVJUKE1JQ1JPOUwsICJDb250ZWMgSHlwZXJjb250cm9sIE1pY3JvOS1MIikKLQkvKiBNYWludGFpbmVyOiBNYW5mcmVkIEdydWJlciA8bWFuZnJlZC5ncnViZXJAY29udGVjLmF0PiAqLworTUFDSElORV9TVEFSVChNSUNSTzlMLCAiQ29udGVjIE1pY3JvOS1MaXRlIikKKwkvKiBNYWludGFpbmVyOiBIdWJlcnQgRmV1cnN0ZWluIDxodWJlcnQuZmV1cnN0ZWluQGNvbnRlYy5hdD4gKi8KIAkucGh5c19pbwk9IEVQOTNYWF9BUEJfUEhZU19CQVNFLAogCS5pb19wZ19vZmZzdAk9ICgoRVA5M1hYX0FQQl9WSVJUX0JBU0UpID4+IDE4KSAmIDB4ZmZmYywKIAkuYm9vdF9wYXJhbXMJPSBFUDkzWFhfU0RDRTNfUEhZU19CQVNFX1NZTkMgKyAweDEwMCwKIAkubWFwX2lvCQk9IGVwOTN4eF9tYXBfaW8sCiAJLmluaXRfaXJxCT0gZXA5M3h4X2luaXRfaXJxLAogCS50aW1lcgkJPSAmZXA5M3h4X3RpbWVyLAotCS5pbml0X21hY2hpbmUJPSBtaWNybzlsX2luaXRfbWFjaGluZSwKKwkuaW5pdF9tYWNoaW5lCT0gbWljcm85X2luaXRfbWFjaGluZSwKIE1BQ0hJTkVfRU5ECiAjZW5kaWYKIAorI2lmZGVmIENPTkZJR19NQUNIX01JQ1JPOVMKK01BQ0hJTkVfU1RBUlQoTUlDUk85UywgIkNvbnRlYyBNaWNybzktU2xpbSIpCisJLyogTWFpbnRhaW5lcjogSHViZXJ0IEZldXJzdGVpbiA8aHViZXJ0LmZldXJzdGVpbkBjb250ZWMuYXQ+ICovCisJLnBoeXNfaW8JPSBFUDkzWFhfQVBCX1BIWVNfQkFTRSwKKwkuaW9fcGdfb2Zmc3QJPSAoKEVQOTNYWF9BUEJfVklSVF9CQVNFKSA+PiAxOCkgJiAweGZmZmMsCisJLmJvb3RfcGFyYW1zCT0gRVA5M1hYX1NEQ0UzX1BIWVNfQkFTRV9BU1lOQyArIDB4MTAwLAorCS5tYXBfaW8JCT0gZXA5M3h4X21hcF9pbywKKwkuaW5pdF9pcnEJPSBlcDkzeHhfaW5pdF9pcnEsCisJLnRpbWVyCQk9ICZlcDkzeHhfdGltZXIsCisJLmluaXRfbWFjaGluZQk9IG1pY3JvOV9pbml0X21hY2hpbmUsCitNQUNISU5FX0VORAorI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLWludGVncmF0b3IvcGNpX3YzLmMgYi9hcmNoL2FybS9tYWNoLWludGVncmF0b3IvcGNpX3YzLmMKaW5kZXggOTAxY2MyMC4uMTQ4ZDI1ZiAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1pbnRlZ3JhdG9yL3BjaV92My5jCisrKyBiL2FyY2gvYXJtL21hY2gtaW50ZWdyYXRvci9wY2lfdjMuYwpAQCAtMzEsNiArMzEsNyBAQAogCiAjaW5jbHVkZSA8bWFjaC9oYXJkd2FyZS5oPgogI2luY2x1ZGUgPGFzbS9pcnEuaD4KKyNpbmNsdWRlIDxhc20vc2lnbmFsLmg+CiAjaW5jbHVkZSA8YXNtL3N5c3RlbS5oPgogI2luY2x1ZGUgPGFzbS9tYWNoL3BjaS5oPgogI2luY2x1ZGUgPGFzbS9pcnFfcmVncy5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC1yeDUxLXBlcmlwaGVyYWxzLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLXJ4NTEtcGVyaXBoZXJhbHMuYwppbmRleCBiNDVhZDMxLi4yYjBlYjFiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLXJ4NTEtcGVyaXBoZXJhbHMuYworKysgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLXJ4NTEtcGVyaXBoZXJhbHMuYwpAQCAtMzgsNDkgKzM4LDQ5IEBACiAKIHN0YXRpYyBpbnQgYm9hcmRfa2V5bWFwW10gPSB7CiAJS0VZKDAsIDAsIEtFWV9RKSwKLQlLRVkoMCwgMSwgS0VZX1cpLAotCUtFWSgwLCAyLCBLRVlfRSksCi0JS0VZKDAsIDMsIEtFWV9SKSwKLQlLRVkoMCwgNCwgS0VZX1QpLAotCUtFWSgwLCA1LCBLRVlfWSksCi0JS0VZKDAsIDYsIEtFWV9VKSwKLQlLRVkoMCwgNywgS0VZX0kpLAotCUtFWSgxLCAwLCBLRVlfTyksCisJS0VZKDAsIDEsIEtFWV9PKSwKKwlLRVkoMCwgMiwgS0VZX1ApLAorCUtFWSgwLCAzLCBLRVlfQ09NTUEpLAorCUtFWSgwLCA0LCBLRVlfQkFDS1NQQUNFKSwKKwlLRVkoMCwgNiwgS0VZX0EpLAorCUtFWSgwLCA3LCBLRVlfUyksCisJS0VZKDEsIDAsIEtFWV9XKSwKIAlLRVkoMSwgMSwgS0VZX0QpLAotCUtFWSgxLCAyLCBLRVlfRE9UKSwKLQlLRVkoMSwgMywgS0VZX1YpLAotCUtFWSgxLCA0LCBLRVlfRE9XTiksCi0JS0VZKDIsIDAsIEtFWV9QKSwKLQlLRVkoMiwgMSwgS0VZX0YpLAorCUtFWSgxLCAyLCBLRVlfRiksCisJS0VZKDEsIDMsIEtFWV9HKSwKKwlLRVkoMSwgNCwgS0VZX0gpLAorCUtFWSgxLCA1LCBLRVlfSiksCisJS0VZKDEsIDYsIEtFWV9LKSwKKwlLRVkoMSwgNywgS0VZX0wpLAorCUtFWSgyLCAwLCBLRVlfRSksCisJS0VZKDIsIDEsIEtFWV9ET1QpLAogCUtFWSgyLCAyLCBLRVlfVVApLAotCUtFWSgyLCAzLCBLRVlfQiksCi0JS0VZKDIsIDQsIEtFWV9SSUdIVCksCi0JS0VZKDMsIDAsIEtFWV9DT01NQSksCi0JS0VZKDMsIDEsIEtFWV9HKSwKLQlLRVkoMywgMiwgS0VZX0VOVEVSKSwKKwlLRVkoMiwgMywgS0VZX0VOVEVSKSwKKwlLRVkoMiwgNSwgS0VZX1opLAorCUtFWSgyLCA2LCBLRVlfWCksCisJS0VZKDIsIDcsIEtFWV9DKSwKKwlLRVkoMywgMCwgS0VZX1IpLAorCUtFWSgzLCAxLCBLRVlfViksCisJS0VZKDMsIDIsIEtFWV9CKSwKIAlLRVkoMywgMywgS0VZX04pLAotCUtFWSg0LCAwLCBLRVlfQkFDS1NQQUNFKSwKLQlLRVkoNCwgMSwgS0VZX0gpLAotCUtFWSg0LCAzLCBLRVlfTSksCisJS0VZKDMsIDQsIEtFWV9NKSwKKwlLRVkoMywgNSwgS0VZX1NQQUNFKSwKKwlLRVkoMywgNiwgS0VZX1NQQUNFKSwKKwlLRVkoMywgNywgS0VZX0xFRlQpLAorCUtFWSg0LCAwLCBLRVlfVCksCisJS0VZKDQsIDEsIEtFWV9ET1dOKSwKKwlLRVkoNCwgMiwgS0VZX1JJR0hUKSwKIAlLRVkoNCwgNCwgS0VZX0xFRlRDVFJMKSwKLQlLRVkoNSwgMSwgS0VZX0opLAotCUtFWSg1LCAyLCBLRVlfWiksCi0JS0VZKDUsIDMsIEtFWV9TUEFDRSksCi0JS0VZKDUsIDQsIEtFWV9MRUZUU0hJRlQpLAotCUtFWSg2LCAwLCBLRVlfQSksCi0JS0VZKDYsIDEsIEtFWV9LKSwKLQlLRVkoNiwgMiwgS0VZX1gpLAotCUtFWSg2LCAzLCBLRVlfU1BBQ0UpLAotCUtFWSg2LCA0LCBLRVlfRk4pLAotCUtFWSg3LCAwLCBLRVlfUyksCi0JS0VZKDcsIDEsIEtFWV9MKSwKLQlLRVkoNywgMiwgS0VZX0MpLAotCUtFWSg3LCAzLCBLRVlfTEVGVCksCi0JS0VZKDB4ZmYsIDAsIEtFWV9GNiksCi0JS0VZKDB4ZmYsIDEsIEtFWV9GNyksCi0JS0VZKDB4ZmYsIDIsIEtFWV9GOCksCi0JS0VZKDB4ZmYsIDQsIEtFWV9GOSksCi0JS0VZKDB4ZmYsIDUsIEtFWV9GMTApLAorCUtFWSg0LCA1LCBLRVlfUklHSFRBTFQpLAorCUtFWSg0LCA2LCBLRVlfTEVGVFNISUZUKSwKKwlLRVkoNSwgMCwgS0VZX1kpLAorCUtFWSg2LCAwLCBLRVlfVSksCisJS0VZKDcsIDAsIEtFWV9JKSwKKwlLRVkoNywgMSwgS0VZX0Y3KSwKKwlLRVkoNywgMiwgS0VZX0Y4KSwKKwlLRVkoMHhmZiwgMiwgS0VZX0Y5KSwKKwlLRVkoMHhmZiwgNCwgS0VZX0YxMCksCisJS0VZKDB4ZmYsIDUsIEtFWV9GMTEpLAogfTsKIAogc3RhdGljIHN0cnVjdCBtYXRyaXhfa2V5bWFwX2RhdGEgYm9hcmRfbWFwX2RhdGEgPSB7CkBAIC00NDQsNyArNDQ0LDcgQEAKIAkJcng1MV90d2xkYXRhLnZhdXgzID0gJnJ4NTFfdmF1eDNfY2FtOwogCQlyeDUxX3R3bGRhdGEudm1tYzIgPSAmcng1MV92bW1jMjsKIAl9Ci0Jb21hcF9yZWdpc3Rlcl9pMmNfYnVzKDEsIDI2MDAsIHJ4NTFfcGVyaXBoZXJhbHNfaTJjX2JvYXJkX2luZm9fMSwKKwlvbWFwX3JlZ2lzdGVyX2kyY19idXMoMSwgMjIwMCwgcng1MV9wZXJpcGhlcmFsc19pMmNfYm9hcmRfaW5mb18xLAogCQkJQVJSQVlfU0laRShyeDUxX3BlcmlwaGVyYWxzX2kyY19ib2FyZF9pbmZvXzEpKTsKIAlvbWFwX3JlZ2lzdGVyX2kyY19idXMoMiwgMTAwLCBOVUxMLCAwKTsKIAlvbWFwX3JlZ2lzdGVyX2kyY19idXMoMywgNDAwLCBOVUxMLCAwKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtem9vbTIuYyBiL2FyY2gvYXJtL21hY2gtb21hcDIvYm9hcmQtem9vbTIuYwppbmRleCBiN2IzMjIwLi5mZDMzNjlkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2JvYXJkLXpvb20yLmMKKysrIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9ib2FyZC16b29tMi5jCkBAIC0yNSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8bWFjaC9rZXlwYWQuaD4KIAogI2luY2x1ZGUgIm1tYy10d2w0MDMwLmgiCisjaW5jbHVkZSAic2RyYW0tbWljcm9uLW10NDZoMzJtMzJsZi02LmgiCiAKIC8qIFpvb20yIGhhcyBRd2VydHkga2V5Ym9hcmQqLwogc3RhdGljIGludCBib2FyZF9rZXltYXBbXSA9IHsKQEAgLTIxMyw3ICsyMTQsOCBAQAogewogCW9tYXBfYm9hcmRfY29uZmlnID0gem9vbTJfY29uZmlnOwogCW9tYXBfYm9hcmRfY29uZmlnX3NpemUgPSBBUlJBWV9TSVpFKHpvb20yX2NvbmZpZyk7Ci0Jb21hcDJfaW5pdF9jb21tb25faHcoTlVMTCwgTlVMTCk7CisJb21hcDJfaW5pdF9jb21tb25faHcobXQ0NmgzMm0zMmxmNl9zZHJjX3BhcmFtcywKKwkJCQkgbXQ0NmgzMm0zMmxmNl9zZHJjX3BhcmFtcyk7CiAJb21hcF9pbml0X2lycSgpOwogCW9tYXBfZ3Bpb19pbml0KCk7CiB9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrMjR4eC5jIGIvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9jazI0eHguYwppbmRleCBiYzVkM2FjLi5lMmRiZWRkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrMjR4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2syNHh4LmMKQEAgLTc2OSw2ICs3NjksNyBAQAogCQlpZiAoYy0+Y3B1ICYgY3B1X21hc2spIHsKIAkJCWNsa2Rldl9hZGQoJmMtPmxrKTsKIAkJCWNsa19yZWdpc3RlcihjLT5say5jbGspOworCQkJb21hcDJfaW5pdF9jbGtfY2xrZG0oYy0+bGsuY2xrKTsKIAkJfQogCiAJLyogQ2hlY2sgdGhlIE1QVSByYXRlIHNldCBieSBib290bG9hZGVyICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmMgYi9hcmNoL2FybS9tYWNoLW9tYXAyL2Nsb2NrZG9tYWluLmMKaW5kZXggNGVmN2I0Zi4uNThhZmY4NCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1vbWFwMi9jbG9ja2RvbWFpbi5jCisrKyBiL2FyY2gvYXJtL21hY2gtb21hcDIvY2xvY2tkb21haW4uYwpAQCAtMTM3LDYgKzEzNywzNiBAQAogCX0KIH0KIAorLyoKKyAqIF9vbWFwMl9jbGtkbV9zZXRfaHdzdXAgLSBzZXQgdGhlIGh3c3VwIGlkbGUgdHJhbnNpdGlvbiBiaXQKKyAqIEBjbGtkbTogc3RydWN0IGNsb2NrZG9tYWluICoKKyAqIEBlbmFibGU6IGludCAwIHRvIGRpc2FibGUsIDEgdG8gZW5hYmxlCisgKgorICogSW50ZXJuYWwgaGVscGVyIGZvciBhY3R1YWxseSBzd2l0Y2hpbmcgdGhlIGJpdCB0aGF0IGNvbnRyb2xzIGh3c3VwCisgKiBpZGxlIHRyYW5zaXRpb25zIGZvciBjbGtkbS4KKyAqLworc3RhdGljIHZvaWQgX29tYXAyX2Nsa2RtX3NldF9od3N1cChzdHJ1Y3QgY2xvY2tkb21haW4gKmNsa2RtLCBpbnQgZW5hYmxlKQoreworCXUzMiB2OworCisJaWYgKGNwdV9pc19vbWFwMjR4eCgpKSB7CisJCWlmIChlbmFibGUpCisJCQl2ID0gT01BUDI0WFhfQ0xLU1RDVFJMX0VOQUJMRV9BVVRPOworCQllbHNlCisJCQl2ID0gT01BUDI0WFhfQ0xLU1RDVFJMX0RJU0FCTEVfQVVUTzsKKwl9IGVsc2UgaWYgKGNwdV9pc19vbWFwMzR4eCgpKSB7CisJCWlmIChlbmFibGUpCisJCQl2ID0gT01BUDM0WFhfQ0xLU1RDVFJMX0VOQUJMRV9BVVRPOworCQllbHNlCisJCQl2ID0gT01BUDM0WFhfQ0xLU1RDVFJMX0RJU0FCTEVfQVVUTzsKKwl9IGVsc2UgeworCQlCVUcoKTsKKwl9CisKKwljbV9ybXdfbW9kX3JlZ19iaXRzKGNsa2RtLT5jbGt0cmN0cmxfbWFzaywKKwkJCSAgICB2IDw8IF9fZmZzKGNsa2RtLT5jbGt0cmN0cmxfbWFzayksCisJCQkgICAgY2xrZG0tPnB3cmRtLnB0ci0+cHJjbV9vZmZzLCBDTV9DTEtTVENUUkwpOworfQogCiBzdGF0aWMgc3RydWN0IGNsb2NrZG9tYWluICpfY2xrZG1fbG9va3VwKGNvbnN0IGNoYXIgKm5hbWUpCiB7CkBAIC00NTYsOCArNDg2LDYgQEAKICAqLwogdm9pZCBvbWFwMl9jbGtkbV9hbGxvd19pZGxlKHN0cnVjdCBjbG9ja2RvbWFpbiAqY2xrZG0pCiB7Ci0JdTMyIHY7Ci0KIAlpZiAoIWNsa2RtKQogCQlyZXR1cm47CiAKQEAgLTQ3MywxOCArNTAxLDcgQEAKIAlpZiAoYXRvbWljX3JlYWQoJmNsa2RtLT51c2Vjb3VudCkgPiAwKQogCQlfY2xrZG1fYWRkX2F1dG9kZXBzKGNsa2RtKTsKIAotCWlmIChjcHVfaXNfb21hcDI0eHgoKSkKLQkJdiA9IE9NQVAyNFhYX0NMS1NUQ1RSTF9FTkFCTEVfQVVUTzsKLQllbHNlIGlmIChjcHVfaXNfb21hcDM0eHgoKSkKLQkJdiA9IE9NQVAzNFhYX0NMS1NUQ1RSTF9FTkFCTEVfQVVUTzsKLQllbHNlCi0JCUJVRygpOwotCi0KLQljbV9ybXdfbW9kX3JlZ19iaXRzKGNsa2RtLT5jbGt0cmN0cmxfbWFzaywKLQkJCSAgICB2IDw8IF9fZmZzKGNsa2RtLT5jbGt0cmN0cmxfbWFzayksCi0JCQkgICAgY2xrZG0tPnB3cmRtLnB0ci0+cHJjbV9vZmZzLAotCQkJICAgIENNX0NMS1NUQ1RSTCk7CisJX29tYXAyX2Nsa2RtX3NldF9od3N1cChjbGtkbSwgMSk7CiAKIAlwd3JkbV9jbGtkbV9zdGF0ZV9zd2l0Y2goY2xrZG0pOwogfQpAQCAtNTAwLDggKzUxNyw2IEBACiAgKi8KIHZvaWQgb21hcDJfY2xrZG1fZGVueV9pZGxlKHN0cnVjdCBjbG9ja2RvbWFpbiAqY2xrZG0pCiB7Ci0JdTMyIHY7Ci0KIAlpZiAoIWNsa2RtKQogCQlyZXR1cm47CiAKQEAgLTUxNCwxNiArNTI5LDcgQEAKIAlwcl9kZWJ1ZygiY2xvY2tkb21haW46IGRpc2FibGluZyBhdXRvbWF0aWMgaWRsZSB0cmFuc2l0aW9ucyBmb3IgJXNcbiIsCiAJCSBjbGtkbS0+bmFtZSk7CiAKLQlpZiAoY3B1X2lzX29tYXAyNHh4KCkpCi0JCXYgPSBPTUFQMjRYWF9DTEtTVENUUkxfRElTQUJMRV9BVVRPOwotCWVsc2UgaWYgKGNwdV9pc19vbWFwMzR4eCgpKQotCQl2ID0gT01BUDM0WFhfQ0xLU1RDVFJMX0RJU0FCTEVfQVVUTzsKLQllbHNlCi0JCUJVRygpOwotCi0JY21fcm13X21vZF9yZWdfYml0cyhjbGtkbS0+Y2xrdHJjdHJsX21hc2ssCi0JCQkgICAgdiA8PCBfX2ZmcyhjbGtkbS0+Y2xrdHJjdHJsX21hc2spLAotCQkJICAgIGNsa2RtLT5wd3JkbS5wdHItPnByY21fb2ZmcywgQ01fQ0xLU1RDVFJMKTsKKwlfb21hcDJfY2xrZG1fc2V0X2h3c3VwKGNsa2RtLCAwKTsKIAogCWlmIChhdG9taWNfcmVhZCgmY2xrZG0tPnVzZWNvdW50KSA+IDApCiAJCV9jbGtkbV9kZWxfYXV0b2RlcHMoY2xrZG0pOwpAQCAtNTY5LDEwICs1NzUsMTQgQEAKIAl2ID0gb21hcDJfY2xrZG1fY2xrdHJjdHJsX3JlYWQoY2xrZG0pOwogCiAJaWYgKChjcHVfaXNfb21hcDM0eHgoKSAmJiB2ID09IE9NQVAzNFhYX0NMS1NUQ1RSTF9FTkFCTEVfQVVUTykgfHwKLQkgICAgKGNwdV9pc19vbWFwMjR4eCgpICYmIHYgPT0gT01BUDI0WFhfQ0xLU1RDVFJMX0VOQUJMRV9BVVRPKSkKKwkgICAgKGNwdV9pc19vbWFwMjR4eCgpICYmIHYgPT0gT01BUDI0WFhfQ0xLU1RDVFJMX0VOQUJMRV9BVVRPKSkgeworCQkvKiBEaXNhYmxlIEhXIHRyYW5zaXRpb25zIHdoZW4gd2UgYXJlIGNoYW5naW5nIGRlcHMgKi8KKwkJX29tYXAyX2Nsa2RtX3NldF9od3N1cChjbGtkbSwgMCk7CiAJCV9jbGtkbV9hZGRfYXV0b2RlcHMoY2xrZG0pOwotCWVsc2UKKwkJX29tYXAyX2Nsa2RtX3NldF9od3N1cChjbGtkbSwgMSk7CisJfSBlbHNlIHsKIAkJb21hcDJfY2xrZG1fd2FrZXVwKGNsa2RtKTsKKwl9CiAKIAlwd3JkbV93YWl0X3RyYW5zaXRpb24oY2xrZG0tPnB3cmRtLnB0cik7CiAJcHdyZG1fY2xrZG1fc3RhdGVfc3dpdGNoKGNsa2RtKTsKQEAgLTYyMywxMCArNjMzLDE0IEBACiAJdiA9IG9tYXAyX2Nsa2RtX2Nsa3RyY3RybF9yZWFkKGNsa2RtKTsKIAogCWlmICgoY3B1X2lzX29tYXAzNHh4KCkgJiYgdiA9PSBPTUFQMzRYWF9DTEtTVENUUkxfRU5BQkxFX0FVVE8pIHx8Ci0JICAgIChjcHVfaXNfb21hcDI0eHgoKSAmJiB2ID09IE9NQVAyNFhYX0NMS1NUQ1RSTF9FTkFCTEVfQVVUTykpCisJICAgIChjcHVfaXNfb21hcDI0eHgoKSAmJiB2ID09IE9NQVAyNFhYX0NMS1NUQ1RSTF9FTkFCTEVfQVVUTykpIHsKKwkJLyogRGlzYWJsZSBIVyB0cmFuc2l0aW9ucyB3aGVuIHdlIGFyZSBjaGFuZ2luZyBkZXBzICovCisJCV9vbWFwMl9jbGtkbV9zZXRfaHdzdXAoY2xrZG0sIDApOwogCQlfY2xrZG1fZGVsX2F1dG9kZXBzKGNsa2RtKTsKLQllbHNlCisJCV9vbWFwMl9jbGtkbV9zZXRfaHdzdXAoY2xrZG0sIDEpOworCX0gZWxzZSB7CiAJCW9tYXAyX2Nsa2RtX3NsZWVwKGNsa2RtKTsKKwl9CiAKIAlwd3JkbV9jbGtkbV9zdGF0ZV9zd2l0Y2goY2xrZG0pOwogCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9jcHVmcmVxLXB4YTJ4eC5jIGIvYXJjaC9hcm0vbWFjaC1weGEvY3B1ZnJlcS1weGEyeHguYwppbmRleCAzYThlZTIyLi45ODNjYzhjIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tYWNoLXB4YS9jcHVmcmVxLXB4YTJ4eC5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL2NwdWZyZXEtcHhhMnh4LmMKQEAgLTE1NSw3ICsxNTUsNyBAQAogCiBzdGF0aWMgcHhhX2ZyZXFzX3QgcHhhMjd4X2ZyZXFzW10gPSB7CiAJezEwNDAwMCwgMTA0MDAwLCBQWEEyN3hfQ0NDUigxLAkgOCwgMiksIDAsIENDTEtDRkcyKDEsIDAsIDEpLCAgOTAwMDAwLCAxNzA1MDAwIH0sCi0JezE1NjAwMCwgMTA0MDAwLCBQWEEyN3hfQ0NDUigxLAkgOCwgNiksIDAsIENDTEtDRkcyKDEsIDEsIDEpLCAxMDAwMDAwLCAxNzA1MDAwIH0sCisJezE1NjAwMCwgMTA0MDAwLCBQWEEyN3hfQ0NDUigxLAkgOCwgMyksIDAsIENDTEtDRkcyKDEsIDAsIDEpLCAxMDAwMDAwLCAxNzA1MDAwIH0sCiAJezIwODAwMCwgMjA4MDAwLCBQWEEyN3hfQ0NDUigwLCAxNiwgMiksIDEsIENDTEtDRkcyKDAsIDAsIDEpLCAxMTgwMDAwLCAxNzA1MDAwIH0sCiAJezMxMjAwMCwgMjA4MDAwLCBQWEEyN3hfQ0NDUigxLCAxNiwgMyksIDEsIENDTEtDRkcyKDEsIDAsIDEpLCAxMjUwMDAwLCAxNzA1MDAwIH0sCiAJezQxNjAwMCwgMjA4MDAwLCBQWEEyN3hfQ0NDUigxLCAxNiwgNCksIDEsIENDTEtDRkcyKDEsIDAsIDEpLCAxMzUwMDAwLCAxNzA1MDAwIH0sCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tYWNoLXB4YS9jc2I3MjYuYyBiL2FyY2gvYXJtL21hY2gtcHhhL2NzYjcyNi5jCmluZGV4IDc5MTQxZjguLjk2NTQ4MGUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21hY2gtcHhhL2NzYjcyNi5jCisrKyBiL2FyY2gvYXJtL21hY2gtcHhhL2NzYjcyNi5jCkBAIC0yMzgsNyArMjM4LDcgQEAKIH07CiAKIHN0cnVjdCBzbXNjOTExeF9wbGF0Zm9ybV9jb25maWcgY3NiNzI2X2xhbl9jb25maWcgPSB7Ci0JLmlycV90eXBlCT0gU01TQzkxMVhfSVJRX1BPTEFSSVRZX0FDVElWRV9MT1csCisJLmlycV9wb2xhcml0eQk9IFNNU0M5MTFYX0lSUV9QT0xBUklUWV9BQ1RJVkVfTE9XLAogCS5pcnFfdHlwZQk9IFNNU0M5MTFYX0lSUV9UWVBFX1BVU0hfUFVMTCwKIAkuZmxhZ3MJCT0gU01TQzkxMVhfVVNFXzMyQklULAogCS5waHlfaW50ZXJmYWNlCT0gUEhZX0lOVEVSRkFDRV9NT0RFX01JSSwKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtc2ExMTAwL01ha2VmaWxlIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvTWFrZWZpbGUKaW5kZXggOGE1NTQ2ZS4uYmI3YjgxOSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vbWFjaC1zYTExMDAvTWFrZWZpbGUKKysrIGIvYXJjaC9hcm0vbWFjaC1zYTExMDAvTWFrZWZpbGUKQEAgLTI1LDYgKzI1LDcgQEAKIAogb2JqLSQoQ09ORklHX1NBMTEwMF9DT0xMSUUpCQkrPSBjb2xsaWUubwogCitvYmotJChDT05GSUdfU0ExMTAwX0gzMTAwKQkJKz0gaDM2MDAubwogb2JqLSQoQ09ORklHX1NBMTEwMF9IMzYwMCkJCSs9IGgzNjAwLm8KIAogb2JqLSQoQ09ORklHX1NBMTEwMF9IQUNLS0lUKQkJKz0gaGFja2tpdC5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9jYWNoZS12Ni5TIGIvYXJjaC9hcm0vbW0vY2FjaGUtdjYuUwppbmRleCA4ZjVjMTNmLi4yOTVlMjVkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9jYWNoZS12Ni5TCisrKyBiL2FyY2gvYXJtL21tL2NhY2hlLXY2LlMKQEAgLTEyLDYgKzEyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGFzbS9hc3NlbWJsZXIuaD4KKyNpbmNsdWRlIDxhc20vdW53aW5kLmg+CiAKICNpbmNsdWRlICJwcm9jLW1hY3Jvcy5TIgogCkBAIC0xMjEsMTEgKzEyMiwxMyBAQAogICoJLSB0aGUgSWNhY2hlIGRvZXMgbm90IHJlYWQgZGF0YSBmcm9tIHRoZSB3cml0ZSBidWZmZXIKICAqLwogRU5UUlkodjZfY29oZXJlbnRfdXNlcl9yYW5nZSkKLQorIFVOV0lORCguZm5zdGFydAkJKQogI2lmZGVmIEhBUlZBUkRfQ0FDSEUKIAliaWMJcjAsIHIwLCAjQ0FDSEVfTElORV9TSVpFIC0gMQotMToJbWNyCXAxNSwgMCwgcjAsIGM3LCBjMTAsIDEJCUAgY2xlYW4gRCBsaW5lCisxOgorIFVTRVIoCW1jcglwMTUsIDAsIHIwLCBjNywgYzEwLCAxCSkJQCBjbGVhbiBEIGxpbmUKIAlhZGQJcjAsIHIwLCAjQ0FDSEVfTElORV9TSVpFCisyOgogCWNtcAlyMCwgcjEKIAlibG8JMWIKICNlbmRpZgpAQCAtMTQzLDYgKzE0NiwxOSBAQAogCW1vdglwYywgbHIKIAogLyoKKyAqIEZhdWx0IGhhbmRsaW5nIGZvciB0aGUgY2FjaGUgb3BlcmF0aW9uIGFib3ZlLiBJZiB0aGUgdmlydHVhbCBhZGRyZXNzIGluIHIwCisgKiBpc24ndCBtYXBwZWQsIGp1c3QgdHJ5IHRoZSBuZXh0IHBhZ2UuCisgKi8KKzkwMDE6CisJbW92CXIwLCByMCwgbHNyICMxMgorCW1vdglyMCwgcjAsIGxzbCAjMTIKKwlhZGQJcjAsIHIwLCAjNDA5NgorCWIJMmIKKyBVTldJTkQoLmZuZW5kCQkpCitFTkRQUk9DKHY2X2NvaGVyZW50X3VzZXJfcmFuZ2UpCitFTkRQUk9DKHY2X2NvaGVyZW50X2tlcm5fcmFuZ2UpCisKKy8qCiAgKgl2Nl9mbHVzaF9rZXJuX2RjYWNoZV9wYWdlKGthZGRyKQogICoKICAqCUVuc3VyZSB0aGF0IHRoZSBkYXRhIGhlbGQgaW4gdGhlIHBhZ2Uga2FkZHIgaXMgd3JpdHRlbiBiYWNrCmRpZmYgLS1naXQgYS9hcmNoL2FybS9tbS9jYWNoZS12Ny5TIGIvYXJjaC9hcm0vbW0vY2FjaGUtdjcuUwppbmRleCBiZGEwZWMzLi5lMWJkOTc1IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9jYWNoZS12Ny5TCisrKyBiL2FyY2gvYXJtL21tL2NhY2hlLXY3LlMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGFzbS9hc3NlbWJsZXIuaD4KKyNpbmNsdWRlIDxhc20vdW53aW5kLmg+CiAKICNpbmNsdWRlICJwcm9jLW1hY3Jvcy5TIgogCkBAIC0xNTMsMTMgKzE1NCwxNiBAQAogICoJLSB0aGUgSWNhY2hlIGRvZXMgbm90IHJlYWQgZGF0YSBmcm9tIHRoZSB3cml0ZSBidWZmZXIKICAqLwogRU5UUlkodjdfY29oZXJlbnRfdXNlcl9yYW5nZSkKKyBVTldJTkQoLmZuc3RhcnQJCSkKIAlkY2FjaGVfbGluZV9zaXplIHIyLCByMwogCXN1YglyMywgcjIsICMxCiAJYmljCXIwLCByMCwgcjMKLTE6CW1jcglwMTUsIDAsIHIwLCBjNywgYzExLCAxCQlAIGNsZWFuIEQgbGluZSB0byB0aGUgcG9pbnQgb2YgdW5pZmljYXRpb24KKzE6CisgVVNFUigJbWNyCXAxNSwgMCwgcjAsIGM3LCBjMTEsIDEJKQlAIGNsZWFuIEQgbGluZSB0byB0aGUgcG9pbnQgb2YgdW5pZmljYXRpb24KIAlkc2IKLQltY3IJcDE1LCAwLCByMCwgYzcsIGM1LCAxCQlAIGludmFsaWRhdGUgSSBsaW5lCisgVVNFUigJbWNyCXAxNSwgMCwgcjAsIGM3LCBjNSwgMQkpCUAgaW52YWxpZGF0ZSBJIGxpbmUKIAlhZGQJcjAsIHIwLCByMgorMjoKIAljbXAJcjAsIHIxCiAJYmxvCTFiCiAJbW92CXIwLCAjMApAQCAtMTY3LDYgKzE3MSwxNyBAQAogCWRzYgogCWlzYgogCW1vdglwYywgbHIKKworLyoKKyAqIEZhdWx0IGhhbmRsaW5nIGZvciB0aGUgY2FjaGUgb3BlcmF0aW9uIGFib3ZlLiBJZiB0aGUgdmlydHVhbCBhZGRyZXNzIGluIHIwCisgKiBpc24ndCBtYXBwZWQsIGp1c3QgdHJ5IHRoZSBuZXh0IHBhZ2UuCisgKi8KKzkwMDE6CisJbW92CXIwLCByMCwgbHNyICMxMgorCW1vdglyMCwgcjAsIGxzbCAjMTIKKwlhZGQJcjAsIHIwLCAjNDA5NgorCWIJMmIKKyBVTldJTkQoLmZuZW5kCQkpCiBFTkRQUk9DKHY3X2NvaGVyZW50X2tlcm5fcmFuZ2UpCiBFTkRQUk9DKHY3X2NvaGVyZW50X3VzZXJfcmFuZ2UpCiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL2ZhdWx0LWFybXYuYyBiL2FyY2gvYXJtL21tL2ZhdWx0LWFybXYuYwppbmRleCBiYzAwOTlkLi5kMGQxN2I2IDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9mYXVsdC1hcm12LmMKKysrIGIvYXJjaC9hcm0vbW0vZmF1bHQtYXJtdi5jCkBAIC0xNTMsMTQgKzE1MywxMSBAQAogCiAJcGFnZSA9IHBmbl90b19wYWdlKHBmbik7CiAJbWFwcGluZyA9IHBhZ2VfbWFwcGluZyhwYWdlKTsKLQlpZiAobWFwcGluZykgewogI2lmbmRlZiBDT05GSUdfU01QCi0JCWludCBkaXJ0eSA9IHRlc3RfYW5kX2NsZWFyX2JpdChQR19kY2FjaGVfZGlydHksICZwYWdlLT5mbGFncyk7Ci0KLQkJaWYgKGRpcnR5KQotCQkJX19mbHVzaF9kY2FjaGVfcGFnZShtYXBwaW5nLCBwYWdlKTsKKwlpZiAodGVzdF9hbmRfY2xlYXJfYml0KFBHX2RjYWNoZV9kaXJ0eSwgJnBhZ2UtPmZsYWdzKSkKKwkJX19mbHVzaF9kY2FjaGVfcGFnZShtYXBwaW5nLCBwYWdlKTsKICNlbmRpZgotCisJaWYgKG1hcHBpbmcpIHsKIAkJaWYgKGNhY2hlX2lzX3ZpdnQoKSkKIAkJCW1ha2VfY29oZXJlbnQobWFwcGluZywgdm1hLCBhZGRyLCBwZm4pOwogCQllbHNlIGlmICh2bWEtPnZtX2ZsYWdzICYgVk1fRVhFQykKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL2ZhdWx0LmMgYi9hcmNoL2FybS9tbS9mYXVsdC5jCmluZGV4IGFlMGUyNWYuLjEwZTA2ODAgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21tL2ZhdWx0LmMKKysrIGIvYXJjaC9hcm0vbW0vZmF1bHQuYwpAQCAtMjkyLDYgKzI5MiwxMSBAQAogCQkgKiBkb3duX3JlYWQoKQogCQkgKi8KIAkJbWlnaHRfc2xlZXAoKTsKKyNpZmRlZiBDT05GSUdfREVCVUdfVk0KKwkJaWYgKCF1c2VyX21vZGUocmVncykgJiYKKwkJICAgICFzZWFyY2hfZXhjZXB0aW9uX3RhYmxlcyhyZWdzLT5BUk1fcGMpKQorCQkJZ290byBub19jb250ZXh0OworI2VuZGlmCiAJfQogCiAJZmF1bHQgPSBfX2RvX3BhZ2VfZmF1bHQobW0sIGFkZHIsIGZzciwgdHNrKTsKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21tL2hpZ2htZW0uYyBiL2FyY2gvYXJtL21tL2hpZ2htZW0uYwppbmRleCA3M2NhZTU3Li4zMGY4MmZiIDEwMDY0NAotLS0gYS9hcmNoL2FybS9tbS9oaWdobWVtLmMKKysrIGIvYXJjaC9hcm0vbW0vaGlnaG1lbS5jCkBAIC00Niw2ICs0Niw4IEBACiAJaWYgKCFQYWdlSGlnaE1lbShwYWdlKSkKIAkJcmV0dXJuIHBhZ2VfYWRkcmVzcyhwYWdlKTsKIAorCWRlYnVnX2ttYXBfYXRvbWljKHR5cGUpOworCiAJa21hcCA9IGttYXBfaGlnaF9nZXQocGFnZSk7CiAJaWYgKGttYXApCiAJCXJldHVybiBrbWFwOwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vaW5pdC5jIGIvYXJjaC9hcm0vbW0vaW5pdC5jCmluZGV4IDg3N2M0OTIuLjQwOTQwZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL21tL2luaXQuYworKysgYi9hcmNoL2FybS9tbS9pbml0LmMKQEAgLTQ4Myw3ICs0ODMsNyBAQAogCS8qCiAJICogQ29udmVydCBzdGFydF9wZm4vZW5kX3BmbiB0byBhIHN0cnVjdCBwYWdlIHBvaW50ZXIuCiAJICovCi0Jc3RhcnRfcGcgPSBwZm5fdG9fcGFnZShzdGFydF9wZm4pOworCXN0YXJ0X3BnID0gcGZuX3RvX3BhZ2Uoc3RhcnRfcGZuIC0gMSkgKyAxOwogCWVuZF9wZyA9IHBmbl90b19wYWdlKGVuZF9wZm4pOwogCiAJLyoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL3BsYXQtb21hcC9kbWEuYyBiL2FyY2gvYXJtL3BsYXQtb21hcC9kbWEuYwppbmRleCBmZDMxNTRhLi4wZWI2NzZkIDEwMDY0NAotLS0gYS9hcmNoL2FybS9wbGF0LW9tYXAvZG1hLmMKKysrIGIvYXJjaC9hcm0vcGxhdC1vbWFwL2RtYS5jCkBAIC04MjksMTAgKzgyOSwxMCBAQAogICoKICAqIEBwYXJhbSBhcmJfcmF0ZQogICogQHBhcmFtIG1heF9maWZvX2RlcHRoCi0gKiBAcGFyYW0gdHBhcmFtcyAtIE51bWJlciBvZiB0aGVyZWFkcyB0byByZXNlcnZlIDogRE1BX1RIUkVBRF9SRVNFUlZFX05PUk0KLSAqIAkJCQkJCSAgICBETUFfVEhSRUFEX1JFU0VSVkVfT05FVAotICogCQkJCQkJICAgIERNQV9USFJFQURfUkVTRVJWRV9UV09UCi0gKiAJCQkJCQkgICAgRE1BX1RIUkVBRF9SRVNFUlZFX1RIUkVFVAorICogQHBhcmFtIHRwYXJhbXMgLSBOdW1iZXIgb2YgdGhyZWFkcyB0byByZXNlcnZlIDogRE1BX1RIUkVBRF9SRVNFUlZFX05PUk0KKyAqIAkJCQkJCSAgIERNQV9USFJFQURfUkVTRVJWRV9PTkVUCisgKiAJCQkJCQkgICBETUFfVEhSRUFEX1JFU0VSVkVfVFdPVAorICogCQkJCQkJICAgRE1BX1RIUkVBRF9SRVNFUlZFX1RIUkVFVAogICovCiB2b2lkCiBvbWFwX2RtYV9zZXRfZ2xvYmFsX3BhcmFtcyhpbnQgYXJiX3JhdGUsIGludCBtYXhfZmlmb19kZXB0aCwgaW50IHRwYXJhbXMpCkBAIC04NDQsMTEgKzg0NCwxNCBAQAogCQlyZXR1cm47CiAJfQogCisJaWYgKG1heF9maWZvX2RlcHRoID09IDApCisJCW1heF9maWZvX2RlcHRoID0gMTsKIAlpZiAoYXJiX3JhdGUgPT0gMCkKIAkJYXJiX3JhdGUgPSAxOwogCi0JcmVnID0gKGFyYl9yYXRlICYgMHhmZikgPDwgMTY7Ci0JcmVnIHw9ICgweGZmICYgbWF4X2ZpZm9fZGVwdGgpOworCXJlZyA9IDB4ZmYgJiBtYXhfZmlmb19kZXB0aDsKKwlyZWcgfD0gKDB4MyAmIHRwYXJhbXMpIDw8IDEyOworCXJlZyB8PSAoYXJiX3JhdGUgJiAweGZmKSA8PCAxNjsKIAogCWRtYV93cml0ZShyZWcsIEdDUik7CiB9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LW9tYXAvbWNic3AuYyBiL2FyY2gvYXJtL3BsYXQtb21hcC9tY2JzcC5jCmluZGV4IDg4YWM5NzYuLmU2NjRiOTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL3BsYXQtb21hcC9tY2JzcC5jCisrKyBiL2FyY2gvYXJtL3BsYXQtb21hcC9tY2JzcC5jCkBAIC01OTUsNyArNTk1LDcgQEAKIAlyeCAmPSAxOwogCWlmIChjcHVfaXNfb21hcDI0MzAoKSB8fCBjcHVfaXNfb21hcDM0eHgoKSkgewogCQl3ID0gT01BUF9NQ0JTUF9SRUFEKGlvX2Jhc2UsIFJDQ1IpOwotCQl3IHw9ICh0eCA/IFJESVNBQkxFIDogMCk7CisJCXcgfD0gKHJ4ID8gUkRJU0FCTEUgOiAwKTsKIAkJT01BUF9NQ0JTUF9XUklURShpb19iYXNlLCBSQ0NSLCB3KTsKIAl9CiAJdyA9IE9NQVBfTUNCU1BfUkVBRChpb19iYXNlLCBTUENSMSk7CmRpZmYgLS1naXQgYS9hcmNoL2FybS9wbGF0LXMzYzI0eHgvYWRjLmMgYi9hcmNoL2FybS9wbGF0LXMzYzI0eHgvYWRjLmMKaW5kZXggMTExMTdhNy4uNGQzNmI3OCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vcGxhdC1zM2MyNHh4L2FkYy5jCisrKyBiL2FyY2gvYXJtL3BsYXQtczNjMjR4eC9hZGMuYwpAQCAtMTQsNiArMTQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgogI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9BRElfQlNELnR4dCBiL2FyY2gvYmxhY2tmaW4vQURJX0JTRC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTAxZDBiNgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYmxhY2tmaW4vQURJX0JTRC50eHQKQEAgLTAsMCArMSw0MSBAQAorVGhpcyBCU0QtU3R5bGUgTGljZW5zZSBhcHBsaWVzIHRvIGEgZmV3IGZpbGVzIGluIC4vYXJjaC9ibGFja2ZpbiBkaXJlY3RvcnksCithbmQgaXMgaW5jbHVkZWQgaGVyZSwgc28gcGVvcGxlIHVuZGVyc3RhbmQgd2hpY2ggY29kZSB0aGV5IGNhbiB1c2Ugb3V0c2lkZQordGhlIExpbnV4IGtlcm5lbCwgaW4gbm9uLUdQTCBiYXNlZCBwcm9qZWN0cy4KKworVXNpbmcgdGhlIGZpbGVzIHJlbGVhc2VkIHVuZGVyIHRoZSAiQURJIEJTRCIgbGljZW5zZSwgbXVzdCBjb21wbHkgd2l0aAordGhlc2UgbGljZW5zZSB0ZXJtcy4KKworLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworQ29weXJpZ2h0IEFuYWxvZyBEZXZpY2VzLCBJbmMuCisKK0FsbCByaWdodHMgcmVzZXJ2ZWQuCisKK1JlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCithcmUgbWV0OgorICAtIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICAtIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluCisgICAgdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICAgIGRpc3RyaWJ1dGlvbi4KKyAgLSBOZWl0aGVyIHRoZSBuYW1lIG9mIEFuYWxvZyBEZXZpY2VzLCBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgICAgY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkCisgICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICAtIFRoZSB1c2Ugb2YgdGhpcyBzb2Z0d2FyZSBtYXkgb3IgbWF5IG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IHJpZ2h0cworICAgIG9mIG9uZSBvciBtb3JlIHBhdGVudCBob2xkZXJzLiAgVGhpcyBsaWNlbnNlIGRvZXMgbm90IHJlbGVhc2UgeW91CisgICAgZnJvbSB0aGUgcmVxdWlyZW1lbnQgdGhhdCB5b3Ugb2J0YWluIHNlcGFyYXRlIGxpY2Vuc2VzIGZyb20gdGhlc2UKKyAgICBwYXRlbnQgaG9sZGVycyB0byB1c2UgdGhpcyBzb2Z0d2FyZS4KKworVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBTkFMT0cgREVWSUNFUyAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUgorSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgTk9OLUlORlJJTkdFTUVOVCwKK01FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuCitJTiBOTyBFVkVOVCBTSEFMTCBBTkFMT0cgREVWSUNFUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULAorSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywKK0JVVCBOT1QgTElNSVRFRCBUTywgSU5URUxMRUNUVUFMIFBST1BFUlRZIFJJR0hUUywgUFJPQ1VSRU1FTlQgT0YKK1NVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUgorQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksCitXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUgorT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRgorQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vS2NvbmZpZyBiL2FyY2gvYmxhY2tmaW4vS2NvbmZpZwppbmRleCA5YTAxZDQ0Li5hZTZhNjBmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL0tjb25maWcKKysrIGIvYXJjaC9ibGFja2Zpbi9LY29uZmlnCkBAIC00Nyw2ICs0Nyw5IEBACiBjb25maWcgR0VORVJJQ19JUlFfUFJPQkUKIAlkZWZfYm9vbCB5CiAKK2NvbmZpZyBHRU5FUklDX0hBUkRJUlFTX05PX19ET19JUlEKKwlkZWZfYm9vbCB5CisKIGNvbmZpZyBHRU5FUklDX0dQSU8KIAlkZWZfYm9vbCB5CiAKQEAgLTIyOSw3ICsyMzIsNyBAQAogCiBjb25maWcgU01QCiAJZGVwZW5kcyBvbiBCRjU2MQotCXNlbGVjdCBHRU5FUklDX1RJTUUKKwlzZWxlY3QgR0VORVJJQ19DTE9DS0VWRU5UUwogCWJvb2wgIlN5bW1ldHJpYyBtdWx0aS1wcm9jZXNzaW5nIHN1cHBvcnQiCiAJLS0taGVscC0tLQogCSAgVGhpcyBlbmFibGVzIHN1cHBvcnQgZm9yIHN5c3RlbXMgd2l0aCBtb3JlIHRoYW4gb25lIENQVSwKQEAgLTYxMywxMiArNjE2LDEwIEBACiBzb3VyY2Uga2VybmVsL0tjb25maWcuaHoKIAogY29uZmlnIEdFTkVSSUNfVElNRQotCWJvb2wgIkdlbmVyaWMgdGltZSIKLQlkZWZhdWx0IHkKKwlkZWZfYm9vbCB5CiAKIGNvbmZpZyBHRU5FUklDX0NMT0NLRVZFTlRTCiAJYm9vbCAiR2VuZXJpYyBjbG9jayBldmVudHMiCi0JZGVwZW5kcyBvbiBHRU5FUklDX1RJTUUKIAlkZWZhdWx0IHkKIAogY2hvaWNlCkBAIC02NTMsNiArNjU0LDEwIEBACiAJZGVwZW5kcyBvbiBHRU5FUklDX0NMT0NLRVZFTlRTCiAJZGVwZW5kcyBvbiAhVElDS1NPVVJDRV9HUFRNUjAKIAorY29uZmlnIEFSQ0hfVVNFU19HRVRUSU1FT0ZGU0VUCisJZGVwZW5kcyBvbiAhR0VORVJJQ19DTE9DS0VWRU5UUworCWRlZl9ib29sIHkKKwogc291cmNlIGtlcm5lbC90aW1lL0tjb25maWcKIAogY29tbWVudCAiTWlzYyIKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYXRvbWljLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2F0b21pYy5oCmluZGV4IDg4ZjM2ZDUuLmQyN2M2MjcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYXRvbWljLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9hdG9taWMuaApAQCAtMSwzICsxLDkgQEAKKy8qCivCoCogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCivCoCoKK8KgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCivCoCovCisKICNpZm5kZWYgX19BUkNIX0JMQUNLRklOX0FUT01JQ19fCiAjZGVmaW5lIF9fQVJDSF9CTEFDS0ZJTl9BVE9NSUNfXwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW4tZ2xvYmFsLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW4tZ2xvYmFsLmgKaW5kZXggYWVmMDU5NC4uMTAwNjRmOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9iZmluLWdsb2JhbC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYmZpbi1nbG9iYWwuaApAQCAtMSwyOSArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9iZmluLWdsb2JhbC5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjogKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgR2xvYmFsIGV4dGVybiBkZWZpbmVzIGZvciBibGFja2ZpbgorICogR2xvYmFsIGV4dGVybiBkZWZpbmVzIGZvciBibGFja2ZpbgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqIENvcHlyaWdodCAyMDA2LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0JGSU5fR0xPQkFMX0hfCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW41eHhfc3BpLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW41eHhfc3BpLmgKaW5kZXggYzI4MWM2My4uZWQ0ZjhjNiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9iZmluNXh4X3NwaS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYmZpbjV4eF9zcGkuaApAQCAtMyw4ICszLDYgQEAKICAqCiAgKiBDb3B5cmlnaHQgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCiAgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9iZmluX3JvdGFyeS5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9iZmluX3JvdGFyeS5oCmluZGV4IDQyNWVjZTYuLmFiZGIyYWYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYmZpbl9yb3RhcnkuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW5fcm90YXJ5LmgKQEAgLTEsNiArMSwxMCBAQAogLyoKICAqIGJvYXJkIGluaXRpYWxpemF0aW9uIHNob3VsZCBwdXQgb25lIG9mIHRoZXNlIHN0cnVjdHVyZXMgaW50byBwbGF0Zm9ybV9kYXRhCiAgKiBhbmQgcGxhY2UgdGhlIGJmaW4tcm90YXJ5IG9udG8gcGxhdGZvcm1fYnVzIG5hbWVkICJiZmluLXJvdGFyeSIuCisgKgorICogQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9CRklOX1JPVEFSWV9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW5fc2ltcGxlX3RpbWVyLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JmaW5fc2ltcGxlX3RpbWVyLmgKaW5kZXggZmNjYmI1OS4uNTI0OGMxMyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9iZmluX3NpbXBsZV90aW1lci5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYmZpbl9zaW1wbGVfdGltZXIuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNi0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfYmZpbl9zaW1wbGVfdGltZXJfaF8KICNkZWZpbmUgX2JmaW5fc2ltcGxlX3RpbWVyX2hfCiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYml0b3BzLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JpdG9wcy5oCmluZGV4IGRhZmZhNzEuLmEyZmYzZmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYml0b3BzLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9iaXRvcHMuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfQkxBQ0tGSU5fQklUT1BTX0gKICNkZWZpbmUgX0JMQUNLRklOX0JJVE9QU19ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYmxhY2tmaW4uaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYmxhY2tmaW4uaAppbmRleCA0ZDQ0Mzk1Li5lYjdjMTQ0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2JsYWNrZmluLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9ibGFja2Zpbi5oCkBAIC0xLDYgKzEsOSBAQAogLyoKLSAqIENvbW1vbiBoZWFkZXIgZmlsZSBmb3IgYmxhY2tmaW4gZmFtaWx5IG9mIHByb2Nlc3NvcnMuCisgKiBDb21tb24gaGVhZGVyIGZpbGUgZm9yIEJsYWNrZmluIGZhbWlseSBvZiBwcm9jZXNzb3JzLgogICoKK8KgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KK8KgKgorwqAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9CTEFDS0ZJTl9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9idWcuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYnVnLmgKaW5kZXggNjU1ZTQ5NS4uNmY0NTQ4YSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9idWcuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2J1Zy5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9CTEFDS0ZJTl9CVUdfSAogI2RlZmluZSBfQkxBQ0tGSU5fQlVHX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9ieXRlb3JkZXIuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vYnl0ZW9yZGVyLmgKaW5kZXggM2U2OTEwNi4uOTU1ODQxNiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9ieXRlb3JkZXIuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2J5dGVvcmRlci5oCkBAIC0xLDYgKzEgQEAKLSNpZm5kZWYgX0JMQUNLRklOX0JZVEVPUkRFUl9ICi0jZGVmaW5lIF9CTEFDS0ZJTl9CWVRFT1JERVJfSAotCiAjaW5jbHVkZSA8bGludXgvYnl0ZW9yZGVyL2xpdHRsZV9lbmRpYW4uaD4KLQotI2VuZGlmCQkJCS8qIF9CTEFDS0ZJTl9CWVRFT1JERVJfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jYWNoZS5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jYWNoZS5oCmluZGV4IDQ3NzA1MGEuLjg1NDJiYzMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY2FjaGUuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NhY2hlLmgKQEAgLTEsNiArMSw5IEBACiAvKgotICogaW5jbHVkZS9hc20tYmxhY2tmaW4vY2FjaGUuaAorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCisKICNpZm5kZWYgX19BUkNIX0JMQUNLRklOX0NBQ0hFX0gKICNkZWZpbmUgX19BUkNIX0JMQUNLRklOX0NBQ0hFX0gKIApAQCAtMzUsMTAgKzM4LDEwIEBACiAKICNpZiBkZWZpbmVkKENPTkZJR19TTVApICYmIFwKICAgICAhZGVmaW5lZChDT05GSUdfQkZJTl9DQUNIRV9DT0hFUkVOVCkKLSMgaWYgZGVmaW5lZChDT05GSUdfQkZJTl9JQ0FDSEVBQkxFKSB8fCBkZWZpbmVkKENPTkZJR19CRklOX0wyX0lDQUNIRUFCTEUpCisjIGlmIGRlZmluZWQoQ09ORklHX0JGSU5fRVhUTUVNX0lDQUNIRUFCTEUpIHx8IGRlZmluZWQoQ09ORklHX0JGSU5fTDJfSUNBQ0hFQUJMRSkKICMgZGVmaW5lIF9fQVJDSF9TWU5DX0NPUkVfSUNBQ0hFCiAjIGVuZGlmCi0jIGlmIGRlZmluZWQoQ09ORklHX0JGSU5fRENBQ0hFQUJMRSkgfHwgZGVmaW5lZChDT05GSUdfQkZJTl9MMl9EQ0FDSEVBQkxFKQorIyBpZiBkZWZpbmVkKENPTkZJR19CRklOX0VYVE1FTV9EQ0FDSEVBQkxFKSB8fCBkZWZpbmVkKENPTkZJR19CRklOX0wyX0RDQUNIRUFCTEUpCiAjIGRlZmluZSBfX0FSQ0hfU1lOQ19DT1JFX0RDQUNIRQogIyBlbmRpZgogI2lmbmRlZiBfX0FTU0VNQkxZX18KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKaW5kZXggN2U1NTU0OWUuLmFmMDNhMzYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCkBAIC0xLDMwICsxLDkgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL2NhY2hlZmx1c2guaAotICogQmFzZWQgb246CSBpbmNsdWRlL2FzbS1tNjhrbm9tbXUvY2FjaGVmbHVzaC5oCi0gKiBBdXRob3I6ICAgICAgIExHIFNvZnQgSW5kaWEKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IChDKSAyMDA0IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqIENyZWF0ZWQ6ICAgICAgVHVlIFNlcCAyMSAyMDA0Ci0gKiBEZXNjcmlwdGlvbjogIEJsYWNrZmluIGxvdy1sZXZlbCBjYWNoZSByb3V0aW5lcyBhZGFwdGVkIGZyb20gdGhlIGkzODYKLSAqIAkJIGFuZCBQUEMgdmVyc2lvbnMgYnkgR3JlZyBVbmdlcmVyIChnZXJnQHNuYXBnZWFyLmNvbSkKKyAqIEJsYWNrZmluIGxvdy1sZXZlbCBjYWNoZSByb3V0aW5lcwogICoKLSAqIE1vZGlmaWVkOgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfQkxBQ0tGSU5fQ0FDSEVGTFVTSF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NkZWZfTFBCbGFja2Zpbi5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jZGVmX0xQQmxhY2tmaW4uaAppbmRleCAzNWY4NDFiLi44Nzc4ZTBmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NkZWZfTFBCbGFja2Zpbi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY2RlZl9MUEJsYWNrZmluLmgKQEAgLTEsMzAgKzEsOCBAQAotIC8qCi0gICogRmlsZTogICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtY29tbW9uL2NkZWZfTFBCbGFja2Zpbi5oCi0gICogQmFzZWQgb246Ci0gICogQXV0aG9yOiAgICAgIHVua25vd24KLSAgKiAgICAgICAgICAgICAgQ09QWVJJR0hUIDIwMDUgQW5hbG9nIERldmljZXMKLSAgKiBDcmVhdGVkOiAgICAgPwotICAqIERlc2NyaXB0aW9uOgotICAqCi0gICogTW9kaWZpZWQ6Ci0gICoKLSAgKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICAqCi0gICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAgKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAgKgotICAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gICoKLSAgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAgKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KLSAgKi8KKy8qCisgKiBDb3B5cmlnaHQgMjAwNS0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KIAogI2lmbmRlZiBfQ0RFRl9MUEJMQUNLRklOX0gKICNkZWZpbmUgX0NERUZfTFBCTEFDS0ZJTl9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NoZWNrc3VtLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NoZWNrc3VtLmgKaW5kZXggNzkzNTgxZi4uYTIzNDE1YiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jaGVja3N1bS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY2hlY2tzdW0uaApAQCAtMSw5ICsxLDE0IEBACisvKgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAgICAgIGFrYmFyLmh1c3NhaW5AbGluZW8uY29tCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgorICovCisKICNpZm5kZWYgX0JGSU5fQ0hFQ0tTVU1fSAogI2RlZmluZSBfQkZJTl9DSEVDS1NVTV9ICiAKIC8qCi0gKiBNT0RJRklFRCBGT1IgQkZJTiBBcHJpbCAzMCwgMjAwMSBha2Jhci5odXNzYWluQGxpbmVvLmNvbQotICoKICAqIGNvbXB1dGVzIHRoZSBjaGVja3N1bSBvZiBhIG1lbW9yeSBibG9jayBhdCBidWZmLCBsZW5ndGggbGVuLAogICogYW5kIGFkZHMgaW4gInN1bSIgKDMyLWJpdCkKICAqCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2Nsb2Nrcy5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jbG9ja3MuaAppbmRleCAwMzNiYmE5Li5mODBkYWQ1IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2Nsb2Nrcy5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY2xvY2tzLmgKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1jb21tb24vY2xvY2tzLmgKLSAqIEJhc2VkIG9uOiAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzNy9iZjUzNy5oCi0gKiBBdXRob3I6CSBSb2JpbiBHZXR6IDxyZ2V0ekBibGFja2Zpbi51Y2xpbnV4Lm9yZz4KKyAqIENvbW1vbiBDbG9jayBkZWZpbml0aW9ucyBmb3IgdmFyaW91cyBrZXJuZWwgZmlsZXMKICAqCi0gKiBDcmVhdGVkOiAgICAgIDI1SnVsMDcKLSAqIERlc2NyaXB0aW9uOiAgQ29tbW9uIENsb2NrIGRlZmluaXRpb25zIGZvciB2YXJpb3VzIGtlcm5lbCBmaWxlcworICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDcgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0JGSU5fQ0xPQ0tTX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY29udGV4dC5TIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jb250ZXh0LlMKaW5kZXggZjhhNjY0Zi4uNWRmZmFmNSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jb250ZXh0LlMKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jb250ZXh0LlMKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9rZXJuZWwvY29udGV4dC5TCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogLyoKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY3BsYi5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jcGxiLmgKaW5kZXggZDE4ZDE2OC4uZmRhOTYyNiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jcGxiLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jcGxiLmgKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vY3BsYi5oCi0gKiBCYXNlZCBvbjogICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzcvYmY1MzcuaAotICogQXV0aG9yOiAgICAgICBSb2JpbiBHZXR6IDxyZ2V0ekBibGFja2Zpbi51Y2xpbnV4Lm9yZz4KKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6ICAgICAgMjAwMAotICogRGVzY3JpcHRpb246ICBDb21tb24gQ1BMQiBkZWZpbml0aW9ucyBmb3IgQ1BMQiBpbml0Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDcgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0NQTEJfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jcGxiaW5pdC5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jcGxiaW5pdC5oCmluZGV4IDA1YjE0YTYuLmYzMTVjODMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY3BsYmluaXQuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NwbGJpbml0LmgKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vY3BsYmluaXQuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb21tb24gQ1BMQiBkZWZpbml0aW9ucyBmb3IgQ1BMQiBpbml0CiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgorICogQ29weXJpZ2h0IDIwMDYtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX19BU01fQ1BMQklOSVRfSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NwdS5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jcHUuaAppbmRleCBmYWRmYTgyLi5iMTkxZGM2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2NwdS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vY3B1LmgKQEAgLTEsMjMgKzEsOCBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9jcHUuaC4KLSAqIEF1dGhvcjogICAgICAgUGhpbGlwcGUgR2VydW0gPHJwbUB4ZW5vbWFpLm9yZz4KKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICAgICAgICAgICAgUGhpbGlwcGUgR2VydW0gPHJwbUB4ZW5vbWFpLm9yZz4KICAqCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfX0FTTV9CTEFDS0ZJTl9DUFVfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9kZWZfTFBCbGFja2Zpbi5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9kZWZfTFBCbGFja2Zpbi5oCmluZGV4IDYzNDFlZWIuLjI1OTA2NDYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZGVmX0xQQmxhY2tmaW4uaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2RlZl9MUEJsYWNrZmluLmgKQEAgLTEsMzIgKzEsMTAgQEAKLSAvKgotICAqIEZpbGU6ICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWNvbW1vbi9kZWZfTFBCbGFja2Zpbi5oCi0gICogQmFzZWQgb246Ci0gICogQXV0aG9yOiAgICAgIHVua25vd24KLSAgKiAgICAgICAgICAgICAgQ09QWVJJR0hUIDIwMDUgQW5hbG9nIERldmljZXMKLSAgKiBDcmVhdGVkOiAgICAgPwotICAqIERlc2NyaXB0aW9uOgotICAqCi0gICogTW9kaWZpZWQ6Ci0gICoKLSAgKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICAqCi0gICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAgKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAgKgotICAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gICoKLSAgKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAgKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KLSAgKi8KLQotLyogTFAgQmxhY2tmaW4gQ09SRSBSRUdJU1RFUiBCSVQgJiBBRERSRVNTIERFRklOSVRJT05TIEZPUiBBRFNQLUJGNTMyLzMzICovCisvKgorICogQmxhY2tmaW4gY29yZSByZWdpc3RlciBiaXQgJiBhZGRyZXNzIGRlZmluaXRpb25zCisgKgorICogQ29weXJpZ2h0IDIwMDUtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciBHUEwtMiAob3IgbGF0ZXIpLgorICovCiAKICNpZm5kZWYgX0RFRl9MUEJMQUNLRklOX0gKICNkZWZpbmUgX0RFRl9MUEJMQUNLRklOX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZG1hLW1hcHBpbmcuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZG1hLW1hcHBpbmcuaAppbmRleCBlZDZiMWYzLi43YTIzZDgyIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2RtYS1tYXBwaW5nLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9kbWEtbWFwcGluZy5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9CTEFDS0ZJTl9ETUFfTUFQUElOR19ICiAjZGVmaW5lIF9CTEFDS0ZJTl9ETUFfTUFQUElOR19ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZHBtYy5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9kcG1jLmgKaW5kZXggOTZlODIwOC4uOTI1ZTY2YyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9kcG1jLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9kcG1jLmgKQEAgLTEsOSArMSwxMSBAQAogLyoKLSAqIGluY2x1ZGUvYXNtLWJsYWNrZmluL2RwbWMuaCAtICBNaXNjZWxsYW5lb3VzIElPQ1RMIGNvbW1hbmRzIGZvciBEeW5hbWljIFBvd2VyCi0gKiAgIAkJCSAJTWFuYWdlbWVudCBDb250cm9sbGVyIERyaXZlci4KKyAqIE1pc2NlbGxhbmVvdXMgSU9DVEwgY29tbWFuZHMgZm9yIER5bmFtaWMgUG93ZXIgTWFuYWdlbWVudCBDb250cm9sbGVyIERyaXZlcgorICoKICAqIENvcHlyaWdodCAoQykgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2UgSW5jLgogICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMgogICovCisKICNpZm5kZWYgX0JMQUNLRklOX0RQTUNfSF8KICNkZWZpbmUgX0JMQUNLRklOX0RQTUNfSF8KIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9lYXJseV9wcmludGsuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZWFybHlfcHJpbnRrLmgKaW5kZXggNTNhNzYyYi4uNjhhOTEwZCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9lYXJseV9wcmludGsuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2Vhcmx5X3ByaW50ay5oCkBAIC0xLDI3ICsxLDExIEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9lYXJseV9wcmludGsuaAotICogQXV0aG9yOiAgICAgICBSb2JpbiBHZXR6IDxyZ2V0ekBibGFja2Zpbi51Y2xpbnV4Lm9yZworICogZnVuY3Rpb24gcHJvdG90cHllcyBmb3IgZWFybHkgcHJpbnRrCiAgKgotICogQ3JlYXRlZDogICAgICAxNEF1ZzIwMDcKLSAqIERlc2NyaXB0aW9uOiAgZnVuY3Rpb24gcHJvdG90cHllcyBmb3IgZWFybHkgcHJpbnRrCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAotCiAjaWZuZGVmIF9fQVNNX0VBUkxZX1BSSU5US19IX18KICNkZWZpbmUgX19BU01fRUFSTFlfUFJJTlRLX0hfXwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2VsZi5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9lbGYuaAppbmRleCBjODIzZThlLi44ZTA3NjRjIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2VsZi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZWxmLmgKQEAgLTEsNCArMSw4IEBACi0vKiBDaGFuZ2VzIG1hZGUgYnkgIExHIFNvZnQgT2N0IDIwMDQqLworLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLwogCiAjaWZuZGVmIF9fQVNNQkZJTl9FTEZfSAogI2RlZmluZSBfX0FTTUJGSU5fRUxGX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZW50cnkuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZW50cnkuaAppbmRleCA1NWI4MDhmLi5hNjg4NmY2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2VudHJ5LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9lbnRyeS5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9fQkZJTl9FTlRSWV9ICiAjZGVmaW5lIF9fQkZJTl9FTlRSWV9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZmNudGwuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZmNudGwuaAppbmRleCA5YzQwMzcxLi44NzI3YjJiIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2ZjbnRsLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9mY250bC5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9CRklOX0ZDTlRMX0gKICNkZWZpbmUgX0JGSU5fRkNOVExfSAogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2ZpeGVkX2NvZGUuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZml4ZWRfY29kZS5oCmluZGV4IDMyYzRkNDkuLjczZmU1M2UgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZml4ZWRfY29kZS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZml4ZWRfY29kZS5oCkBAIC0xLDUgKzEsMTEgQEAKLS8qIFRoaXMgZmlsZSBkZWZpbmVzIHRoZSBmaXhlZCBhZGRyZXNzZXMgd2hlcmUgdXNlcnNwYWNlIHByb2dyYW1zIGNhbiBmaW5kCi0gICBhdG9taWMgY29kZSBzZXF1ZW5jZXMuICAqLworLyoKKyAqIFRoaXMgZmlsZSBkZWZpbmVzIHRoZSBmaXhlZCBhZGRyZXNzZXMgd2hlcmUgdXNlcnNwYWNlIHByb2dyYW1zCisgKiBjYW4gZmluZCBhdG9taWMgY29kZSBzZXF1ZW5jZXMuCisgKgorICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgorICovCiAKICNpZm5kZWYgX19CRklOX0FTTV9GSVhFRF9DT0RFX0hfXwogI2RlZmluZSBfX0JGSU5fQVNNX0ZJWEVEX0NPREVfSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2ZsYXQuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZmxhdC5oCmluZGV4IDczM2ExNzguLmMxMzE0YzUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZmxhdC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZmxhdC5oCkBAIC0xLDggKzEsOSBAQAogLyoKLSAqIGluY2x1ZGUvYXNtLWJsYWNrZmluL2ZsYXQuaCAtLSB1Q2xpbnV4IGZsYXQtZm9ybWF0IGV4ZWN1dGFibGVzCisgKiB1Q2xpbnV4IGZsYXQtZm9ybWF0IGV4ZWN1dGFibGVzCiAgKgotICogQ29weXJpZ2h0IChDKSAyMDAzLAorICogQ29weXJpZ2h0IDIwMDMtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yCiAgKi8KIAogI2lmbmRlZiBfX0JMQUNLRklOX0ZMQVRfSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2dwaW8uaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZ3Bpby5oCmluZGV4IGZlMTM5NjEuLjViNDRkMDUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZ3Bpby5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vZ3Bpby5oCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL2JmaW5fZ3Bpby5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoJIE1pY2hhZWwgSGVubmVyaWNoIChoZW5uZXJpY2hAYmxhY2tmaW4udWNsaW51eC5vcmcpCisgKiBDb3B5cmlnaHQgMjAwNi0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX19BUkNIX0JMQUNLRklOX0dQSU9fSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2hhcmRpcnEuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vaGFyZGlycS5oCmluZGV4IDBiNzhiODcuLmMwNzhkZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vaGFyZGlycS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vaGFyZGlycS5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9fQkZJTl9IQVJESVJRX0gKICNkZWZpbmUgX19CRklOX0hBUkRJUlFfSAogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2lvLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2lvLmgKaW5kZXggMzcwNTNlYy4uZDFmNTAyOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9pby5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vaW8uaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfQkZJTl9JT19ICiAjZGVmaW5lIF9CRklOX0lPX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9pcnEuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vaXJxLmgKaW5kZXggNDJhMTVmNS4uZTdjMDYyMyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9pcnEuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2lycS5oCkBAIC0xLDE3ICsxLDEwIEBACiAvKgotICogVGhpcyBmaWxlIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMKLSAqIExpY2Vuc2UuICBTZWUgdGhlIGZpbGUgQ09QWUlORyBpbiB0aGUgbWFpbiBkaXJlY3Rvcnkgb2YgdGhpcyBhcmNoaXZlCi0gKiBmb3IgbW9yZSBkZXRhaWxzLgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAyMDAzIEh1VGFvCisgKiAgICAgICAgICAgICAgICAyMDAyIEFyY3R1cnVzIE5ldHdvcmtzIEluYy4gKHd3dy5hcmN0dXJ1c25ldHdvcmtzLmNvbQorICogICAgICAgICAgICAgICAgICAgICAgIFRlZCBNYSA8bWF0ZWRAc3ltcGF0aWNvLmNhPgogICoKLSAqIENoYW5nZWQgYnkgSHVUYW8gQXByMTgsIDIwMDMKLSAqCi0gKiBDb3B5cmlnaHQgd2FzIG1pc3Npbmcgd2hlbiBJIGdvdCB0aGUgY29kZSBzbyB0b29rIGZyb20gTUlQUyBhcmNoIC4uLk1hVGVkLS0tCi0gKiBDb3B5cmlnaHQgKEMpIDE5OTQgYnkgV2FsZG9yZiBHTUJILCB3cml0dGVuIGJ5IFJhbGYgQmFlY2hsZQotICogQ29weXJpZ2h0IChDKSAxOTk1LCA5NiwgOTcsIDk4LCA5OSwgMjAwMCwgMjAwMSBieSBSYWxmIEJhZWNobGUKLSAqCi0gKiBBZGFwdGVkIGZvciBCbGFja0ZpbiAoQURJKSBieSBUZWQgTWEgPG1hdGVkQHN5bXBhdGljby5jYT4KLSAqIENvcHlyaWdodCAoYykgMjAwMiBBcmN0dXJ1cyBOZXR3b3JrcyBJbmMuICh3d3cuYXJjdHVydXNuZXR3b3Jrcy5jb20pCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDIgTGluZW8sIEluYy4gPG1hdHR3QGxpbmVvLmNvbT4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMgogICovCiAKICNpZm5kZWYgX0JGSU5fSVJRX0hfCkBAIC0xOSw2ICsxMiw4IEBACiAKICNpbmNsdWRlIDxsaW51eC9pcnFmbGFncy5oPgogCisjaW5jbHVkZSA8bWFjaC9hbm9tYWx5Lmg+CisKIC8qIFNZU19JUlFTIGFuZCBOUl9JUlFTIGFyZSBkZWZpbmVkIGluIDxtYWNoLWJmNXh4L2lycS5oPiAqLwogI2luY2x1ZGUgPG1hY2gvaXJxLmg+CiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vaXJxX2hhbmRsZXIuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vaXJxX2hhbmRsZXIuaAppbmRleCA3ZDllMmQzLi43ZmJlNDIzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2lycV9oYW5kbGVyLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9pcnFfaGFuZGxlci5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9JUlFfSEFORExFUl9ICiAjZGVmaW5lIF9JUlFfSEFORExFUl9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbDFsYXlvdXQuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbDFsYXlvdXQuaAppbmRleCA3OWRiZWZhYS4uYzg3ZTY4NiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9sMWxheW91dC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbDFsYXlvdXQuaApAQCAtMSw2ICsxLDkgQEAKIC8qCi0gKiBsMWxheW91dC5oCiAgKiBEZWZpbmVzIGEgbGF5b3V0IG9mIEwxIHNjcmF0Y2hwYWQgbWVtb3J5IHRoYXQgdXNlcnNwYWNlIGNhbiByZWx5IG9uLgorICoKKyAqIENvcHlyaWdodCAyMDA2LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9MMUxBWU9VVF9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9saW5rYWdlLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2xpbmthZ2UuaAppbmRleCA1YTgyMmJiLi5mN2Q2ZDQ3IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2xpbmthZ2UuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL2xpbmthZ2UuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfX0FTTV9MSU5LQUdFX0gKICNkZWZpbmUgX19BU01fTElOS0FHRV9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbW11LmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL21tdS5oCmluZGV4IGRiZmQ2ODYuLjI2ZjZiNzAgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbW11LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9tbXUuaApAQCAtMSw4ICsxLDEzIEBACisvKgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAyMDAyIERhdmlkIE1jQ3VsbG91Z2ggPGRhdmlkbUBzbmFwZ2Vhci5jb20+CisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yLgorICovCisKICNpZm5kZWYgX19NTVVfSAogI2RlZmluZSBfX01NVV9ICiAKLS8qIENvcHlyaWdodCAoQykgMjAwMiwgRGF2aWQgTWNDdWxsb3VnaCA8ZGF2aWRtQHNuYXBnZWFyLmNvbT4gKi8KLQogc3RydWN0IHNyYW1fbGlzdF9zdHJ1Y3QgewogCXN0cnVjdCBzcmFtX2xpc3Rfc3RydWN0ICpuZXh0OwogCXZvaWQgKmFkZHI7CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL21tdV9jb250ZXh0LmgKaW5kZXggMDQwNDEwYi4uNGEzYmUzNyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9tbXVfY29udGV4dC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbW11X2NvbnRleHQuaApAQCAtMSwzMCArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tbXVfY29udGV4dC5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfX0JMQUNLRklOX01NVV9DT05URVhUX0hfXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9tb2R1bGUuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbW9kdWxlLmgKaW5kZXggZTMxMjhkZi4uOWMxY2ZmZiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9tb2R1bGUuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL21vZHVsZS5oCkBAIC0xLDMgKzEsOSBAQAorLyoKK8KgKiBDb3B5cmlnaHQgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KK8KgKgorwqAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KK8KgKi8KKwogI2lmbmRlZiBfQVNNX0JGSU5fTU9EVUxFX0gKICNkZWZpbmUgX0FTTV9CRklOX01PRFVMRV9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbXV0ZXguaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vbXV0ZXguaAppbmRleCA1Y2M2NDFjLi5mNzI2ZTNhIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL211dGV4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9tdXRleC5oCkBAIC00LDYgKzQsMTAgQEAKICAqIFRPRE86IGltcGxlbWVudCBvcHRpbWl6ZWQgcHJpbWl0aXZlcyBpbnN0ZWFkLCBvciBsZWF2ZSB0aGUgZ2VuZXJpYwogICogaW1wbGVtZW50YXRpb24gaW4gcGxhY2UsIG9yIHBpY2sgdGhlIGF0b21pY194Y2hnKCkgYmFzZWQgZ2VuZXJpYwogICogaW1wbGVtZW50YXRpb24uIChzZWUgYXNtLWdlbmVyaWMvbXV0ZXgteGNoZy5oIGZvciBkZXRhaWxzKQorICoKKyAqIENvcHlyaWdodCAyMDA2LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9BU01fTVVURVhfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9uYW5kLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL25hbmQuaAppbmRleCBhZmJhYWZhLi4zYWU4YjU2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL25hbmQuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL25hbmQuaApAQCAtMSwxMyArMSw5IEBACi0vKiBsaW51eC9pbmNsdWRlL2FzbS1ibGFja2Zpbi9uYW5kLmgKLSAqCi0gKiBDb3B5cmlnaHQgKGMpIDIwMDcgQW5hbG9nIERldmljZXMsIEluYy4KLSAqCUJyeWFuIFd1IDxicnlhbi53dUBhbmFsb2cuY29tPgotICoKKy8qCiAgKiBCRjVYWCAtIE5BTkQgZmxhc2ggY29udHJvbGxlciBwbGF0ZnJvbV9kZXZpY2UgaW5mbwogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzLCBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yCiAgKi8KIAogLyogc3RydWN0IGJmNXh4X25hbmRfcGxhdGZvcm0KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcGFnZS5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wYWdlLmgKaW5kZXggMjlkY2Y3NS4uOTQ0YTA3YyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wYWdlLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wYWdlLmgKQEAgLTEsMyArMSw5IEBACisvKgorwqAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorwqAqCivCoCogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgorwqAqLworCiAjaWZuZGVmIF9CTEFDS0ZJTl9QQUdFX0gKICNkZWZpbmUgX0JMQUNLRklOX1BBR0VfSAogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3BhZ2Vfb2Zmc2V0LmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3BhZ2Vfb2Zmc2V0LmgKaW5kZXggY2JhZmYyNC4uZDA2YTg5YjggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcGFnZV9vZmZzZXQuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3BhZ2Vfb2Zmc2V0LmgKQEAgLTEsNSArMSwxMCBAQAotCi0vKiBUaGlzIGhhbmRsZXMgdGhlIG1lbW9yeSBtYXAuLiAqLworLyoKKyAqIFRoaXMgaGFuZGxlcyB0aGUgbWVtb3J5IG1hcAorICoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLwogCiAjaWZkZWYgQ09ORklHX0JMQUNLRklOCiAjZGVmaW5lIFBBR0VfT0ZGU0VUX1JBVwkJMHgwMDAwMDAwMApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wZGEuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcGRhLmgKaW5kZXggYTZmOTU2OS4uZDQ5YmIyNiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wZGEuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3BkYS5oCkBAIC0xLDIzICsxLDggQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcGRhLmgKLSAqIEF1dGhvcjogICAgICAgUGhpbGlwcGUgR2VydW0gPHJwbUB4ZW5vbWFpLm9yZz4KKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICAgICAgICAgICAgUGhpbGlwcGUgR2VydW0gPHJwbUB4ZW5vbWFpLm9yZz4KICAqCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfQVNNX0JMQUNLRklOX1BEQV9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3BndGFibGUuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcGd0YWJsZS5oCmluZGV4IDc4M2M4ZjcuLjgyMWM2OTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcGd0YWJsZS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcGd0YWJsZS5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9CTEFDS0ZJTl9QR1RBQkxFX0gKICNkZWZpbmUgX0JMQUNLRklOX1BHVEFCTEVfSAogCkBAIC05Miw2ICs5OCwxMiBAQAogI2RlZmluZQlWTUFMTE9DX1NUQVJUCTAKICNkZWZpbmUJVk1BTExPQ19FTkQJMHhmZmZmZmZmZgogCisvKiBwcm92aWRlIGEgc3BlY2lhbCBnZXRfdW5tYXBwZWRfYXJlYSBmb3IgZnJhbWVidWZmZXIgbW1hcHMgb2Ygbm9tbXUgKi8KK2V4dGVybiB1bnNpZ25lZCBsb25nIGdldF9mYl91bm1hcHBlZF9hcmVhKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBsb25nLAorCQkJCQkgIHVuc2lnbmVkIGxvbmcsIHVuc2lnbmVkIGxvbmcsCisJCQkJCSAgdW5zaWduZWQgbG9uZyk7CisjZGVmaW5lIEhBVkVfQVJDSF9GQl9VTk1BUFBFRF9BUkVBCisKICNpbmNsdWRlIDxhc20tZ2VuZXJpYy9wZ3RhYmxlLmg+CiAKICNlbmRpZgkJCQkvKiBfQkxBQ0tGSU5fUEdUQUJMRV9IICovCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3BvbGwuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcG9sbC5oCmluZGV4IGEwNTU2NjcuLjA3MmQ4OTYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcG9sbC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcG9sbC5oCkBAIC0xLDMgKzEsMTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKgorICovCisKICNpZm5kZWYgX19CRklOX1BPTExfSAogI2RlZmluZSBfX0JGSU5fUE9MTF9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcG9ydG11eC5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wb3J0bXV4LmgKaW5kZXggODhlYjVjMC4uZWRkOGVmMyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wb3J0bXV4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wb3J0bXV4LmgKQEAgLTEsNiArMSw5IEBACiAvKgotICogQ29tbW9uIGhlYWRlciBmaWxlIGZvciBibGFja2ZpbiBmYW1pbHkgb2YgcHJvY2Vzc29ycy4KKyAqIENvbW1vbiBoZWFkZXIgZmlsZSBmb3IgQmxhY2tmaW4gZmFtaWx5IG9mIHByb2Nlc3NvcnMKICAqCivCoCogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCivCoCoKK8KgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfUE9SVE1VWF9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wb3NpeF90eXBlcy5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wb3NpeF90eXBlcy5oCmluZGV4IDgwYzlkNjQuLjQxYmMxODcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcG9zaXhfdHlwZXMuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3Bvc2l4X3R5cGVzLmgKQEAgLTEsMyArMSw5IEBACisvKgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgorICovCisKICNpZm5kZWYgX19BUkNIX0JGSU5fUE9TSVhfVFlQRVNfSAogI2RlZmluZSBfX0FSQ0hfQkZJTl9QT1NJWF9UWVBFU19ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcHJvY2Vzc29yLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3Byb2Nlc3Nvci5oCmluZGV4IGEzNmFkOGQuLmFlYTg4MDIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcHJvY2Vzc29yLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wcm9jZXNzb3IuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfX0FTTV9CRklOX1BST0NFU1NPUl9ICiAjZGVmaW5lIF9fQVNNX0JGSU5fUFJPQ0VTU09SX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wdHJhY2UuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vcHRyYWNlLmgKaW5kZXggZTNmMDg2ZC4uMjcyOTBjOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9wdHJhY2UuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3B0cmFjZS5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9CRklOX1BUUkFDRV9ICiAjZGVmaW5lIF9CRklOX1BUUkFDRV9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc2VjdGlvbnMuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc2VjdGlvbnMuaAppbmRleCBhZTRkYWUxLi4xZjUzODFmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NlY3Rpb25zLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zZWN0aW9ucy5oCkBAIC0xLDMgKzEsOSBAQAorLyoKK8KgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KK8KgKgorwqAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KK8KgKi8KKwogI2lmbmRlZiBfQkxBQ0tGSU5fU0VDVElPTlNfSAogI2RlZmluZSBfQkxBQ0tGSU5fU0VDVElPTlNfSAogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NlZ21lbnQuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc2VnbWVudC5oCmluZGV4IDAyY2ZkMDkuLmY4ZTE5ODQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc2VnbWVudC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc2VnbWVudC5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9CRklOX1NFR01FTlRfSAogI2RlZmluZSBfQkZJTl9TRUdNRU5UX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zaWdjb250ZXh0LmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NpZ2NvbnRleHQuaAppbmRleCBjZTAwYjAzLi5jZTQwODFhIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NpZ2NvbnRleHQuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NpZ2NvbnRleHQuaApAQCAtMSwzICsxLDkgQEAKKy8qCivCoCogQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCivCoCoKK8KgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCivCoCovCisKICNpZm5kZWYgX0FTTV9CTEFDS0ZJTl9TSUdDT05URVhUX0gKICNkZWZpbmUgX0FTTV9CTEFDS0ZJTl9TSUdDT05URVhUX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zaWdpbmZvLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NpZ2luZm8uaAppbmRleCBlY2E0NTY1Li4zZTgxMzA2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NpZ2luZm8uaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NpZ2luZm8uaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfQkZJTl9TSUdJTkZPX0gKICNkZWZpbmUgX0JGSU5fU0lHSU5GT19ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc21wLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NtcC5oCmluZGV4IDExOGRlZWUuLjZhMGZlOTQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc21wLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zbXAuaApAQCAtMSwyMyArMSw4IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NtcC5oCi0gKiBBdXRob3I6ICAgICAgIFBoaWxpcHBlIEdlcnVtIDxycG1AeGVub21haS5vcmc+CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgICAgICAgICAgICBQaGlsaXBwZSBHZXJ1bSA8cnBtQHhlbm9tYWkub3JnPgogICoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDcgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9fQVNNX0JMQUNLRklOX1NNUF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NwaW5sb2NrLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NwaW5sb2NrLmgKaW5kZXggZDZmZjRiNS4uYjBjN2YwZSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zcGlubG9jay5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3BpbmxvY2suaApAQCAtMSwzICsxLDkgQEAKKy8qCivCoCogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCivCoCoKK8KgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCivCoCovCisKICNpZm5kZWYgX19CRklOX1NQSU5MT0NLX0gKICNkZWZpbmUgX19CRklOX1NQSU5MT0NLX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zcGlubG9ja190eXBlcy5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zcGlubG9ja190eXBlcy5oCmluZGV4IGIxZTNjNGMuLmJlNzU3NjIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3BpbmxvY2tfdHlwZXMuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3NwaW5sb2NrX3R5cGVzLmgKQEAgLTEsMyArMSw5IEBACisvKgorICogQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9fQVNNX1NQSU5MT0NLX1RZUEVTX0gKICNkZWZpbmUgX19BU01fU1BJTkxPQ0tfVFlQRVNfSAogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3N0YXQuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3RhdC5oCmluZGV4IGQyYjZmMTEuLjJlMjc2NjUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3RhdC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3RhdC5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMi4KKyAqLworCiAjaWZuZGVmIF9CRklOX1NUQVRfSAogI2RlZmluZSBfQkZJTl9TVEFUX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zdHJpbmcuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3RyaW5nLmgKaW5kZXggMzIxZjRkOS4uZDdmMGNjYiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zdHJpbmcuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3N0cmluZy5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9CTEFDS0ZJTl9TVFJJTkdfSF8KICNkZWZpbmUgX0JMQUNLRklOX1NUUklOR19IXwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3N3YWIuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3dhYi5oCmluZGV4IGQ0NDIxMTMuLjg5ZGU2NTAgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3dhYi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3dhYi5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfQkxBQ0tGSU5fU1dBQl9ICiAjZGVmaW5lIF9CTEFDS0ZJTl9TV0FCX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zeXN0ZW0uaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vc3lzdGVtLmgKaW5kZXggODVlOGYxNi4uZGRlMTliMSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS9zeXN0ZW0uaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3N5c3RlbS5oCkBAIC0xLDM0ICsxLDggQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgaW5jbHVkZS9hc20vc3lzdGVtLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOiAgICAgIFRvbnkgS291ICh0b255a29AbGluZW8uY2EpCi0gKiAgICAgICAgICAgICAgQ29weXJpZ2h0IChjKSAyMDAyIEFyY3R1cnVzIE5ldHdvcmtzIEluYy4KLSAqICAgICAgICAgICAgICAgICAgICAod3d3LmFyY3R1cnVzbmV0d29ya3MuY29tKQotICogICAgICAgICAgICAgIENvcHlyaWdodCAoYykgMjAwMyBNZXRyb3dlcmtzICh3d3cubWV0cm93ZXJrcy5jb20pCi0gKiAgICAgICAgICAgICAgQ29weXJpZ2h0IChjKSAyMDA0IEFuYWxvZyBEZXZpY2UgSW5jLgotICogQ3JlYXRlZDogICAgIDI1SmFuMjAwMSAtIFRvbnkgS291Ci0gKiBEZXNjcmlwdGlvbjogc3lzdGVtLmggaW5jbHVkZSBmaWxlCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgVG9ueSBLb3UgKHRvbnlrb0BsaW5lby5jYSkKICAqCi0gKiBNb2RpZmllZDogICAgIDIyU2VwMjAwNiAtIFJvYmluIEdldHoKLSAqICAgICAgICAgICAgICAgIC0gbW92ZSBpbmNsdWRlIGJsYWNrZmluLmggZG93biwgc28gSSBjYW4gZ2V0IGFjY2VzcyB0bwotICogICAgICAgICAgICAgICAgICAgaXJxIGZ1bmN0aW9ucyBpbiBvdGhlciBpbmNsdWRlIGZpbGVzLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2lmbmRlZiBfQkxBQ0tGSU5fU1lTVEVNX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaAppbmRleCAyYmJmZGQ5Li5hZmIzYTg2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3RocmVhZF9pbmZvLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS90aHJlYWRfaW5mby5oCkBAIC0xLDI3ICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL3RocmVhZF9pbmZvLmgKLSAqIEJhc2VkIG9uOiAgICAgaW5jbHVkZS9hc20tbTY4a25vbW11L3RocmVhZF9pbmZvLmgKLSAqIEF1dGhvcjogICAgICAgTEcgU29mdCBJbmRpYQotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgKEMpIDIwMDQtMjAwNSBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKiBDcmVhdGVkOiAgICAgIFR1ZSBTZXAgMjEgMjAwNAotICogRGVzY3JpcHRpb246ICBCbGFja2ZpbiBsb3ctbGV2ZWwgdGhyZWFkIGluZm9ybWF0aW9uCi0gKiBNb2RpZmllZDoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfQVNNX1RIUkVBRF9JTkZPX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdGxiLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3RsYi5oCmluZGV4IDg5YTEyZWUuLmE3NGFlMDggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdGxiLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS90bGIuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfQkxBQ0tGSU5fVExCX0gKICNkZWZpbmUgX0JMQUNLRklOX1RMQl9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdHJhY2UuaCBiL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdHJhY2UuaAppbmRleCAzMTJiNTk2Li42MDlhZDNjIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3RyYWNlLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS90cmFjZS5oCkBAIC0xLDYgKzEsOSBAQAogLyoKLSAqIENvbW1vbiBoZWFkZXIgZmlsZSBmb3IgYmxhY2tmaW4gZmFtaWx5IG9mIHByb2Nlc3NvcnMuCisgKiBoZWFkZXIgZmlsZSBmb3IgaGFyZHdhcmUgdHJhY2UgZnVuY3Rpb25zCiAgKgorICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0JMQUNLRklOX1RSQUNFXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS90cmFwcy5oIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS90cmFwcy5oCmluZGV4IDNjZGM0NTQuLjlmZTBkYTYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdHJhcHMuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3RyYXBzLmgKQEAgLTEsMTMgKzEsMTAgQEAKIC8qCi0gKiAgbGludXgvaW5jbHVkZS9hc20vdHJhcHMuaAorICogIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICAgIDIwMDEgTGluZW8sIEluYworICogICAgICAgICAgICAgICAgICAgICAgICBUb255IEtvdQorICogICAgICAgICAgICAgICAgIDE5OTMgSGFtaXNoIE1hY2RvbmFsZAogICoKLSAqICBDb3B5cmlnaHQgKEMpIDE5OTMgICAgICAgIEhhbWlzaCBNYWNkb25hbGQKLSAqCi0gKiAgTGluZW8sIEluYyAgICBKdWwgMjAwMSAgICBUb255IEtvdQotICoKLSAqIFRoaXMgZmlsZSBpcyBzdWJqZWN0IHRvIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljCi0gKiBMaWNlbnNlLiAgU2VlIHRoZSBmaWxlIENPUFlJTkcgaW4gdGhlIG1haW4gZGlyZWN0b3J5IG9mIHRoaXMgYXJjaGl2ZQotICogZm9yIG1vcmUgZGV0YWlscy4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMgogICovCiAKICNpZm5kZWYgX0JGSU5fVFJBUFNfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS91YWNjZXNzLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3VhY2Nlc3MuaAppbmRleCAyZjQ2OWExLi5jMDNiODUzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3VhY2Nlc3MuaAorKysgYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3VhY2Nlc3MuaApAQCAtMSw0ICsxLDcgQEAKLS8qIENoYW5nZXMgbWFkZSBieSBMaW5lbyBJbmMuICAgIE1heSAyMDAxCisvKgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICoKICAqIEJhc2VkIG9uOiBpbmNsdWRlL2FzbS1tNjhrbm9tbXUvdWFjY2Vzcy5oCiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdW5pc3RkLmggYi9hcmNoL2JsYWNrZmluL2luY2x1ZGUvYXNtL3VuaXN0ZC5oCmluZGV4IDAyYjE1MjkuLjc3OWJlMDIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vaW5jbHVkZS9hc20vdW5pc3RkLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9pbmNsdWRlL2FzbS91bmlzdGQuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfX0FTTV9CRklOX1VOSVNURF9ICiAjZGVmaW5lIF9fQVNNX0JGSU5fVU5JU1REX0gKIC8qCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9hc20tb2Zmc2V0cy5jIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvYXNtLW9mZnNldHMuYwppbmRleCBmMDVkMWI5Li5iZDMyYzA5IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9hc20tb2Zmc2V0cy5jCisrKyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2FzbS1vZmZzZXRzLmMKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9rZXJuZWwvYXNtLW9mZnNldHMuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBnZW5lcmF0ZSBkZWZpbml0aW9ucyBuZWVkZWQgYnkgYXNzZW1ibHkgbGFuZ3VhZ2UgbW9kdWxlcwogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIGdlbmVyYXRlIGRlZmluaXRpb25zIG5lZWRlZCBieSBhc3NlbWJseSBsYW5ndWFnZSBtb2R1bGVzLgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L3N0ZGRlZi5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvYmZpbl9kbWFfNXh4LmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9iZmluX2RtYV81eHguYwppbmRleCAzODQ4NjhkLi4xZjE3MDIxIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9iZmluX2RtYV81eHguYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9iZmluX2RtYV81eHguYwpAQCAtMiw2ICsyLDcgQEAKICAqIGJmaW5fZG1hXzV4eC5jIC0gQmxhY2tmaW4gRE1BIGltcGxlbWVudGF0aW9uCiAgKgogICogQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgogICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2JmaW5fZ3Bpby5jIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvYmZpbl9ncGlvLmMKaW5kZXggZmM0NjgxYy4uMjI3MDVlZSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvYmZpbl9ncGlvLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvYmZpbl9ncGlvLmMKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9rZXJuZWwvYmZpbl9ncGlvLmMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOiAgICAgICBNaWNoYWVsIEhlbm5lcmljaCAoaGVubmVyaWNoQGJsYWNrZmluLnVjbGludXgub3JnKQorICogR1BJTyBBYnN0cmFjdGlvbiBMYXllcgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIEdQSU8gQWJzdHJhY3Rpb24gTGF5ZXIKKyAqIENvcHlyaWdodCAyMDA2LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGItbXB1L2NwbGJpbml0LmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9jcGxiLW1wdS9jcGxiaW5pdC5jCmluZGV4IDM2MTkzZWUuLmY3YjljZGMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGItbXB1L2NwbGJpbml0LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYi1tcHUvY3BsYmluaXQuYwpAQCAtMSwyNSArMSwxMSBAQAogLyoKICAqIEJsYWNrZmluIENQTEIgaW5pdGlhbGl6YXRpb24KICAqCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDcgQW5hbG9nIERldmljZXMgSW5jLgorICogQ29weXJpZ2h0IDIwMDgtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KKwogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogCiAjaW5jbHVkZSA8YXNtL2JsYWNrZmluLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9jcGxiLW1wdS9jcGxibWdyLmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9jcGxiLW1wdS9jcGxibWdyLmMKaW5kZXggOGUxZTllOS4uNjllMGU1MyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYi1tcHUvY3BsYm1nci5jCisrKyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGItbXB1L2NwbGJtZ3IuYwpAQCAtMSwyMiArMSwxMSBAQAogLyoKLSAqICAgICAgICAgICAgICAgQmxhY2tmaW4gQ1BMQiBleGNlcHRpb24gaGFuZGxpbmcuCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDcgQW5hbG9nIERldmljZXMgSW5jLgorICogQmxhY2tmaW4gQ1BMQiBleGNlcHRpb24gaGFuZGxpbmcgZm9yIHdoZW4gTVBVIGluIG9uCiAgKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KKwogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGItbm9tcHUvY3BsYmluaXQuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGItbm9tcHUvY3BsYmluaXQuYwppbmRleCA1ZDhhZDUwLi5mZDlhMmYzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9jcGxiLW5vbXB1L2NwbGJpbml0LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYi1ub21wdS9jcGxiaW5pdC5jCkBAIC0xLDI0ICsxLDkgQEAKIC8qCiAgKiBCbGFja2ZpbiBDUExCIGluaXRpYWxpemF0aW9uCiAgKgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGItbm9tcHUvY3BsYm1nci5jIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYi1ub21wdS9jcGxibWdyLmMKaW5kZXggZDllYTQ2Yy4uNWI4ODg2MSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYi1ub21wdS9jcGxibWdyLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYi1ub21wdS9jcGxibWdyLmMKQEAgLTEsMjYgKzEsMTQgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL2NwbGItbm9tcHUtYy9jcGxibWdyLmMKICAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYi1tcHUvY3BsYm1nci5jCiAgKiBBdXRob3I6ICAgICAgIE1pY2hhZWwgTWNUZXJuYW4gPG1tY3Rlcm5hbkBhaXJ2YW5hLmNvbT4KICAqCi0gKiBDcmVhdGVkOiAgICAgIDAxTm92MjAwOAogICogRGVzY3JpcHRpb246ICBDUExCIG1pc3MgaGFuZGxlci4KICAqCiAgKiBNb2RpZmllZDoKICAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDggQWlydmFuYSBJbmMuCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDcgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwOC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGJpbmZvLmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9jcGxiaW5mby5jCmluZGV4IDY0ZDc4MzAuLjBiZGFhNTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2NwbGJpbmZvLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvY3BsYmluZm8uYwpAQCAtMiw2ICsyLDcgQEAKICAqIGFyY2gvYmxhY2tmaW4va2VybmVsL2NwbGJpbmZvLmMgLSBkaXNwbGF5IENQTEIgc3RhdHVzCiAgKgogICogQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgogICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKQEAgLTExMSwyNCArMTEyLDIxIEBACiAJLnNob3cgID0gY3BsYmluZm9fc2hvdywKIH07CiAKKyNkZWZpbmUgQ1BMQklORk9fRENQTEJfRkxBRyAweDgwMDAwMDAwCisKIHN0YXRpYyBpbnQgY3BsYmluZm9fb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKIHsKLQljaGFyIGJ1ZlsyNTZdLCAqcGF0aCwgKnA7CisJc3RydWN0IHByb2NfZGlyX2VudHJ5ICpwZGUgPSBQREUoZmlsZS0+Zl9wYXRoLmRlbnRyeS0+ZF9pbm9kZSk7CisJY2hhciBjcGxiX3R5cGU7CiAJdW5zaWduZWQgaW50IGNwdTsKLQljaGFyICpzX2NwdSwgKnNfY3BsYjsKIAlpbnQgcmV0OwogCXN0cnVjdCBzZXFfZmlsZSAqbTsKIAlzdHJ1Y3QgY3BsYmluZm9fZGF0YSAqY2RhdGE7CiAKLQlwYXRoID0gZF9wYXRoKCZmaWxlLT5mX3BhdGgsIGJ1Ziwgc2l6ZW9mKGJ1ZikpOwotCWlmIChJU19FUlIocGF0aCkpCi0JCXJldHVybiBQVFJfRVJSKHBhdGgpOwotCXNfY3B1ID0gc3Ryc3RyKHBhdGgsICIvY3B1Iik7Ci0Jc19jcGxiID0gc3RycmNocihwYXRoLCAnLycpOwotCWlmICghc19jcHUgfHwgIXNfY3BsYikKLQkJcmV0dXJuIC1FSU5WQUw7CisJY3B1ID0gKHVuc2lnbmVkIGludClwZGUtPmRhdGE7CisJY3BsYl90eXBlID0gY3B1ICYgQ1BMQklORk9fRENQTEJfRkxBRyA/ICdEJyA6ICdJJzsKKwljcHUgJj0gfkNQTEJJTkZPX0RDUExCX0ZMQUc7CiAKLQljcHUgPSBzaW1wbGVfc3RydG91bChzX2NwdSArIDQsICZwLCAxMCk7CiAJaWYgKCFjcHVfb25saW5lKGNwdSkpCiAJCXJldHVybiAtRU5PREVWOwogCkBAIC0xMzksNyArMTM3LDcgQEAKIAljZGF0YSA9IG0tPnByaXZhdGU7CiAKIAljZGF0YS0+cG9zID0gMDsKLQljZGF0YS0+Y3BsYl90eXBlID0gdG91cHBlcihzX2NwbGJbMV0pOworCWNkYXRhLT5jcGxiX3R5cGUgPSBjcGxiX3R5cGU7CiAJY3BsYmluZm9fc2VxX2luaXQoY2RhdGEsIGNwdSk7CiAKIAlyZXR1cm4gMDsKQEAgLTE2OCw4ICsxNjYsMTAgQEAKIAkJaWYgKCFjcHVfZGlyKQogCQkJcmV0dXJuIC1FTk9NRU07CiAKLQkJcHJvY19jcmVhdGUoImljcGxiIiwgU19JUlVHTywgY3B1X2RpciwgJmNwbGJpbmZvX2ZvcHMpOwotCQlwcm9jX2NyZWF0ZSgiZGNwbGIiLCBTX0lSVUdPLCBjcHVfZGlyLCAmY3BsYmluZm9fZm9wcyk7CisJCXByb2NfY3JlYXRlX2RhdGEoImljcGxiIiwgU19JUlVHTywgY3B1X2RpciwgJmNwbGJpbmZvX2ZvcHMsCisJCQkodm9pZCAqKWNwdSk7CisJCXByb2NfY3JlYXRlX2RhdGEoImRjcGxiIiwgU19JUlVHTywgY3B1X2RpciwgJmNwbGJpbmZvX2ZvcHMsCisJCQkodm9pZCAqKShjcHUgfCBDUExCSU5GT19EQ1BMQl9GTEFHKSk7CiAJfQogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9kbWEtbWFwcGluZy5jIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZG1hLW1hcHBpbmcuYwppbmRleCAyZjYyYTlmLi5lNzRlNzRkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9kbWEtbWFwcGluZy5jCisrKyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2RtYS1tYXBwaW5nLmMKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9rZXJuZWwvZG1hLW1hcHBpbmcuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBEeW5hbWljIERNQSBtYXBwaW5nIHN1cHBvcnQKICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBEeW5hbWljIERNQSBtYXBwaW5nIHN1cHBvcnQuCisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2Vhcmx5X3ByaW50ay5jIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZWFybHlfcHJpbnRrLmMKaW5kZXggOTMxYzc4Yi4uODRlZDgzNyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZWFybHlfcHJpbnRrLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZWFybHlfcHJpbnRrLmMKQEAgLTEsMjUgKzEsMTAgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL2Vhcmx5X3ByaW50ay5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gveDg2XzY0L2tlcm5lbC9lYXJseV9wcmludGsuYwotICogQXV0aG9yOiAgICAgICBSb2JpbiBHZXR6IDxyZ2V0ekBibGFja2Zpbi51Y2xpbnV4Lm9yZworICogYWxsb3cgYSBjb25zb2xlIHRvIGJlIHVzZWQgZm9yIGVhcmx5IHByaW50aworICogZGVyaXZlZCBmcm9tIGFyY2gveDg2L2tlcm5lbC9lYXJseV9wcmludGsuYwogICoKLSAqIENyZWF0ZWQ6ICAgICAgMTRBdWcyMDA3Ci0gKiBEZXNjcmlwdGlvbjogIGFsbG93IGEgY29uc29sZSB0byBiZSB1c2VkIGZvciBlYXJseSBwcmludGsKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMgogICovCiAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2VudHJ5LlMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9lbnRyeS5TCmluZGV4IDNmODc2OWIuLmYyN2RjMjIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2VudHJ5LlMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZW50cnkuUwpAQCAtMSwzMCArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2tlcm5lbC9lbnRyeS5TCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZml4ZWRfY29kZS5TIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZml4ZWRfY29kZS5TCmluZGV4IDBkMmQ5ZTAuLjA1NjU5MTcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2ZpeGVkX2NvZGUuUworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9maXhlZF9jb2RlLlMKQEAgLTYsNyArNiwxMiBAQAogICogVGhlc2UgYXJlIGFsaWduZWQgdG8gMTYgYnl0ZXMsIHNvIHRoYXQgd2UgaGF2ZSBzb21lIHNwYWNlIHRvIHJlcGxhY2UKICAqIHRoZXNlIHNlcXVlbmNlcyB3aXRoIHNvbWV0aGluZyBlbHNlIChlLmcuIGtlcm5lbCB0cmFwcyBpZiB3ZSBldmVyIGRvCiAgKiBCRjU2MSBTTVApLgorICoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLworCiAjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC91bmlzdGQuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2ZsYXQuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2ZsYXQuYwppbmRleCBkMTg4YjI0Li5hODhkYWRkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9mbGF0LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvZmxhdC5jCkBAIC0xLDIxICsxLDcgQEAKIC8qCi0gKiAgYXJjaC9ibGFja2Zpbi9rZXJuZWwvZmxhdC5jCisgKiBDb3B5cmlnaHQgMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogIENvcHlyaWdodCAoQykgMjAwNyBBbmFsb2cgRGV2aWNlcywgSW5jLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKLSAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BICAwMjExMS0xMzA3ICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMi4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9pbml0X3Rhc2suYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2luaXRfdGFzay5jCmluZGV4IGMyNmMzNGQuLjExOGM1YjkgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2luaXRfdGFzay5jCisrKyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2luaXRfdGFzay5jCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL2luaXRfdGFzay5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFRoaXMgZmlsZSBjb250YWlucyB0aGUgc2ltcGxlIERNQSBJbXBsZW1lbnRhdGlvbiBmb3IgQmxhY2tmaW4KLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW0uaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL2lycWNoaXAuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL2lycWNoaXAuYwppbmRleCA0YjVmZDM2Li5kYjlmOWM5IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9pcnFjaGlwLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvaXJxY2hpcC5jCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL2lycWNoaXAuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBUaGlzIGZpbGUgY29udGFpbnMgdGhlIHNpbXBsZSBETUEgSW1wbGVtZW50YXRpb24gZm9yIEJsYWNrZmluCi0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbF9zdGF0Lmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL21vZHVsZS5jCmluZGV4IDY3ZmM3YTUuLmE2ZGZhNmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL21vZHVsZS5jCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL21vZHVsZS5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjZGVmaW5lIHByX2ZtdChmbXQpICJtb2R1bGUgJXM6ICIgZm10CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9wcm9jZXNzLmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9wcm9jZXNzLmMKaW5kZXggZjViMjg2MS4uNDMwYWUzOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvcHJvY2Vzcy5jCisrKyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL3Byb2Nlc3MuYwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2tlcm5lbC9wcm9jZXNzLmMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQmxhY2tmaW4gYXJjaGl0ZWN0dXJlLWRlcGVuZGVudCBwcm9jZXNzIGhhbmRsaW5nCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgQmxhY2tmaW4gYXJjaGl0ZWN0dXJlLWRlcGVuZGVudCBwcm9jZXNzIGhhbmRsaW5nLgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvcHRyYWNlLmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9wdHJhY2UuYwppbmRleCAzMGY0ODI4Li4wOTgyYjVkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9wdHJhY2UuYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9wdHJhY2UuYwpAQCAtMSwzMCArMSw4IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2tlcm5lbC9wdHJhY2UuYwotICogQmFzZWQgb246ICAgICBUYWtlbiBmcm9tIGxpbnV4L2tlcm5lbC9wdHJhY2UuYwotICogQXV0aG9yOiAgICAgICBsaW51eC9rZXJuZWwvcHRyYWNlLmMgaXMgYnkgUm9zcyBCaXJvIDEvMjMvOTIsIGVkaXRlZCBieSBMaW51cyBUb3J2YWxkcworICogbGludXgva2VybmVsL3B0cmFjZS5jIGlzIGJ5IFJvc3MgQmlybyAxLzIzLzkyLCBlZGl0ZWQgYnkgTGludXMgVG9ydmFsZHMKKyAqIHRoZXNlIG1vZGlmaWNhdGlvbnMgYXJlIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6ICAgICAgMS8yMy85MgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvc2V0dXAuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL3NldHVwLmMKaW5kZXggMzY5NTM1Yi4uYzIwMmE0NCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvc2V0dXAuYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9zZXR1cC5jCkBAIC0xLDkgKzEsNSBAQAogLyoKLSAqIGFyY2gvYmxhY2tmaW4va2VybmVsL3NldHVwLmMKLSAqCi0gKiBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKICAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvc2hhZG93X2NvbnNvbGUuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL3NoYWRvd19jb25zb2xlLmMKaW5kZXggOGI4YzcxMC4uNTU3ZTlmZSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvc2hhZG93X2NvbnNvbGUuYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9zaGFkb3dfY29uc29sZS5jCkBAIC00LDggKzQsNiBAQAogICoKICAqIENvcHlyaWdodCAyMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCiAgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvc2lnbmFsLmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9zaWduYWwuYwppbmRleCBkYmMzYmJmLi45ZDkwYzE4IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC9zaWduYWwuYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9zaWduYWwuYwpAQCAtMSwzMCArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2tlcm5lbC9zaWduYWwuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L3NpZ25hbC5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvc3lzX2JmaW4uYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL3N5c19iZmluLmMKaW5kZXggM2RhNjBmYi4uYWZjZWYxMiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvc3lzX2JmaW4uYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC9zeXNfYmZpbi5jCkBAIC0xLDMyICsxLDEwIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2tlcm5lbC9zeXNfYmZpbi5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIGNvbnRhaW5zIHZhcmlvdXMgcmFuZG9tIHN5c3RlbSBjYWxscyB0aGF0IGhhdmUgYSBub24tc3RhbmRhcmQKKyAqIGNhbGxpbmcgc2VxdWVuY2Ugb24gdGhlIExpbnV4L0JsYWNrZmluIHBsYXRmb3JtLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFRoaXMgZmlsZSBjb250YWlucyB2YXJpb3VzIHJhbmRvbSBzeXN0ZW0gY2FsbHMgdGhhdAotICogICAgICAgICAgICAgICBoYXZlIGEgbm9uLXN0YW5kYXJkIGNhbGxpbmcgc2VxdWVuY2Ugb24gdGhlIExpbnV4L2JmaW4KLSAqICAgICAgICAgICAgICAgcGxhdGZvcm0uCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KQEAgLTkxLDMgKzY5LDE0IEBACiB7CiAJcmV0dXJuIHNhZmVfZG1hX21lbWNweShkZXN0LCBzcmMsIGxlbik7CiB9CisKKyNpZiBkZWZpbmVkKENPTkZJR19GQikgfHwgZGVmaW5lZChDT05GSUdfRkJfTU9EVUxFKQorI2luY2x1ZGUgPGxpbnV4L2ZiLmg+Cit1bnNpZ25lZCBsb25nIGdldF9mYl91bm1hcHBlZF9hcmVhKHN0cnVjdCBmaWxlICpmaWxwLCB1bnNpZ25lZCBsb25nIG9yaWdfYWRkciwKKwl1bnNpZ25lZCBsb25nIGxlbiwgdW5zaWduZWQgbG9uZyBwZ29mZiwgdW5zaWduZWQgbG9uZyBmbGFncykKK3sKKwlzdHJ1Y3QgZmJfaW5mbyAqaW5mbyA9IGZpbHAtPnByaXZhdGVfZGF0YTsKKwlyZXR1cm4gKHVuc2lnbmVkIGxvbmcpaW5mby0+c2NyZWVuX2Jhc2U7Cit9CitFWFBPUlRfU1lNQk9MKGdldF9mYl91bm1hcHBlZF9hcmVhKTsKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdGltZS10cy5jIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdGltZS10cy5jCmluZGV4IGY5NzE1NzYuLjM1OWNmYjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL3RpbWUtdHMuYworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC90aW1lLXRzLmMKQEAgLTEsMTMgKzEsMTMgQEAKIC8qCi0gKiBsaW51eC9hcmNoL2tlcm5lbC90aW1lLXRzLmMKLSAqCiAgKiBCYXNlZCBvbiBhcm0gY2xvY2tldmVudHMgaW1wbGVtZW50YXRpb24gYW5kIG9sZCBiZmluIHRpbWUgdGljay4KICAqCi0gKiBDb3B5cmlnaHQoQykgMjAwOCwgR2VvVGVjaG5vbG9naWVzLCBWaXRqYSBNYWthcm92CisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IEFuYWxvZyBEZXZpY3MgSW5jLgorICogICAgICAgICAgICAgICAgMjAwOCBHZW9UZWNobm9sb2dpZXMKKyAqICAgICAgICAgICAgICAgICAgICAgVml0amEgTWFrYXJvdgogICoKLSAqIFRoaXMgY29kZSBpcyBsaWNlbmNlZCB1bmRlciB0aGUgR1BMIHZlcnNpb24gMi4gRm9yIGRldGFpbHMgc2VlCi0gKiBrZXJuZWwtYmFzZS9DT1BZSU5HLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yCiAgKi8KKwogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3Byb2ZpbGUuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL3RpbWUuYyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL3RpbWUuYwppbmRleCBhZGI1NGFhLi5iZDNiNTNkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2tlcm5lbC90aW1lLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdGltZS5jCkBAIC0xNCw2ICsxNCw3IEBACiAjaW5jbHVkZSA8bGludXgvdGltZS5oPgogI2luY2x1ZGUgPGxpbnV4L2lycS5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KIAogI2luY2x1ZGUgPGFzbS9ibGFja2Zpbi5oPgogI2luY2x1ZGUgPGFzbS90aW1lLmg+CkBAIC04MSwxMSArODIsMTEgQEAKICNlbmRpZgogfQogCisjaWZkZWYgQ09ORklHX0FSQ0hfVVNFU19HRVRUSU1FT0ZGU0VUCiAvKgogICogU2hvdWxkIHJldHVybiB1c2Vjb25kcyBzaW5jZSBsYXN0IHRpbWVyIHRpY2sKICAqLwotI2lmbmRlZiBDT05GSUdfR0VORVJJQ19USU1FCi1zdGF0aWMgdW5zaWduZWQgbG9uZyBnZXR0aW1lb2Zmc2V0KHZvaWQpCit1MzIgYXJjaF9nZXR0aW1lb2Zmc2V0KHZvaWQpCiB7CiAJdW5zaWduZWQgbG9uZyBvZmZzZXQ7CiAJdW5zaWduZWQgbG9uZyBjbG9ja3NfcGVyX2ppZmZ5OwpAQCAtMTg0LDY1ICsxODUsNiBAQAogCXRpbWVfc2NoZWRfaW5pdCh0aW1lcl9pbnRlcnJ1cHQpOwogfQogCi0jaWZuZGVmIENPTkZJR19HRU5FUklDX1RJTUUKLXZvaWQgZG9fZ2V0dGltZW9mZGF5KHN0cnVjdCB0aW1ldmFsICp0dikKLXsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCXVuc2lnbmVkIGxvbmcgc2VxOwotCXVuc2lnbmVkIGxvbmcgdXNlYywgc2VjOwotCi0JZG8gewotCQlzZXEgPSByZWFkX3NlcWJlZ2luX2lycXNhdmUoJnh0aW1lX2xvY2ssIGZsYWdzKTsKLQkJdXNlYyA9IGdldHRpbWVvZmZzZXQoKTsKLQkJc2VjID0geHRpbWUudHZfc2VjOwotCQl1c2VjICs9ICh4dGltZS50dl9uc2VjIC8gTlNFQ19QRVJfVVNFQyk7Ci0JfQotCXdoaWxlIChyZWFkX3NlcXJldHJ5X2lycXJlc3RvcmUoJnh0aW1lX2xvY2ssIHNlcSwgZmxhZ3MpKTsKLQotCXdoaWxlICh1c2VjID49IFVTRUNfUEVSX1NFQykgewotCQl1c2VjIC09IFVTRUNfUEVSX1NFQzsKLQkJc2VjKys7Ci0JfQotCi0JdHYtPnR2X3NlYyA9IHNlYzsKLQl0di0+dHZfdXNlYyA9IHVzZWM7Ci19Ci1FWFBPUlRfU1lNQk9MKGRvX2dldHRpbWVvZmRheSk7Ci0KLWludCBkb19zZXR0aW1lb2ZkYXkoc3RydWN0IHRpbWVzcGVjICp0dikKLXsKLQl0aW1lX3Qgd3RtX3NlYywgc2VjID0gdHYtPnR2X3NlYzsKLQlsb25nIHd0bV9uc2VjLCBuc2VjID0gdHYtPnR2X25zZWM7Ci0KLQlpZiAoKHVuc2lnbmVkIGxvbmcpdHYtPnR2X25zZWMgPj0gTlNFQ19QRVJfU0VDKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCXdyaXRlX3NlcWxvY2tfaXJxKCZ4dGltZV9sb2NrKTsKLQkvKgotCSAqIFRoaXMgaXMgcmV2b2x0aW5nLiBXZSBuZWVkIHRvIHNldCB0aGUgeHRpbWUudHZfdXNlYwotCSAqIGNvcnJlY3RseS4gSG93ZXZlciwgdGhlIHZhbHVlIGluIHRoaXMgbG9jYXRpb24gaXMKLQkgKiBpcyB2YWx1ZSBhdCB0aGUgbGFzdCB0aWNrLgotCSAqIERpc2NvdmVyIHdoYXQgY29ycmVjdGlvbiBnZXR0aW1lb2ZkYXkKLQkgKiB3b3VsZCBoYXZlIGRvbmUsIGFuZCB0aGVuIHVuZG8gaXQhCi0JICovCi0JbnNlYyAtPSAoZ2V0dGltZW9mZnNldCgpICogTlNFQ19QRVJfVVNFQyk7Ci0KLQl3dG1fc2VjID0gd2FsbF90b19tb25vdG9uaWMudHZfc2VjICsgKHh0aW1lLnR2X3NlYyAtIHNlYyk7Ci0Jd3RtX25zZWMgPSB3YWxsX3RvX21vbm90b25pYy50dl9uc2VjICsgKHh0aW1lLnR2X25zZWMgLSBuc2VjKTsKLQotCXNldF9ub3JtYWxpemVkX3RpbWVzcGVjKCZ4dGltZSwgc2VjLCBuc2VjKTsKLQlzZXRfbm9ybWFsaXplZF90aW1lc3BlYygmd2FsbF90b19tb25vdG9uaWMsIHd0bV9zZWMsIHd0bV9uc2VjKTsKLQotCW50cF9jbGVhcigpOwotCi0Jd3JpdGVfc2VxdW5sb2NrX2lycSgmeHRpbWVfbG9jayk7Ci0JY2xvY2tfd2FzX3NldCgpOwotCi0JcmV0dXJuIDA7Ci19Ci1FWFBPUlRfU1lNQk9MKGRvX3NldHRpbWVvZmRheSk7Ci0jZW5kaWYgLyogIUNPTkZJR19HRU5FUklDX1RJTUUgKi8KLQogLyoKICAqIFNjaGVkdWxlciBjbG9jayAtIHJldHVybnMgY3VycmVudCB0aW1lIGluIG5hbm9zZWMgdW5pdHMuCiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4va2VybmVsL3RyYXBzLmMgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC90cmFwcy5jCmluZGV4IDU2NDY0Y2IuLjZiNzMyNWQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4va2VybmVsL3RyYXBzLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdHJhcHMuYwpAQCAtMSwzMCArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2tlcm5lbC90cmFwcy5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjogICAgICAgSGFtaXNoIE1hY2RvbmFsZAorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgdXNlcyBTL1cgaW50ZXJydXB0IDE1IGZvciB0aGUgc3lzdGVtIGNhbGxzCi0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2J1Zy5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdm1saW51eC5sZHMuUyBiL2FyY2gvYmxhY2tmaW4va2VybmVsL3ZtbGludXgubGRzLlMKaW5kZXggZmZkOTBmYi4uMTBlMTI1MyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9rZXJuZWwvdm1saW51eC5sZHMuUworKysgYi9hcmNoL2JsYWNrZmluL2tlcm5lbC92bWxpbnV4Lmxkcy5TCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL3ZtbGludXgubGRzLlMKLSAqIEJhc2VkIG9uOiAgICAgbm9uZSAtIG9yaWdpbmFsIHdvcmsKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6ICAgICAgVHVlIFNlcCAyMSAyMDA0Ci0gKiBEZXNjcmlwdGlvbjogIE1hc3RlciBsaW5rZXIgc2NyaXB0IGZvciBibGFja2ZpbiBhcmNoaXRlY3R1cmUKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjZGVmaW5lIFZNTElOVVhfU1lNQk9MKF9zeW1fKSBfIyNfc3ltXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvYXNobGRpMy5jIGIvYXJjaC9ibGFja2Zpbi9saWIvYXNobGRpMy5jCmluZGV4IGE4YzI3OWUuLmFiNjlkODcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL2FzaGxkaTMuYworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9hc2hsZGkzLmMKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9saWIvYXNobGRpMy5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgImdjY2xpYi5oIgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvYXNocmRpMy5jIGIvYXJjaC9ibGFja2Zpbi9saWIvYXNocmRpMy5jCmluZGV4IGEwZDM0MTkuLmI1YjM1MWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL2FzaHJkaTMuYworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9hc2hyZGkzLmMKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9saWIvYXNocmRpMy5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgImdjY2xpYi5oIgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvY2hlY2tzdW0uYyBiL2FyY2gvYmxhY2tmaW4vbGliL2NoZWNrc3VtLmMKaW5kZXggY2Q2MDVlNy4uYzYyOTY5ZCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9saWIvY2hlY2tzdW0uYworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9jaGVja3N1bS5jCkBAIC0xLDMyICsxLDEyIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2xpYi9jaGVja3N1bS5jCi0gKiBCYXNlZCBvbjogICAgIG5vbmUgLSBvcmlnaW5hbCB3b3JrCi0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBBbiBpbXBsZW1lbnRhdGlvbiBvZiB0aGUgVENQL0lQIHByb3RvY29sIHN1aXRlIGZvciB0aGUgTElOVVgKLSAqICAgICAgICAgICAgICAgb3BlcmF0aW5nIHN5c3RlbS4gIElORVQgaXMgaW1wbGVtZW50ZWQgdXNpbmcgdGhlICBCU0QgU29ja2V0Ci0gKiAgICAgICAgICAgICAgIGludGVyZmFjZSBhcyB0aGUgbWVhbnMgb2YgY29tbXVuaWNhdGlvbiB3aXRoIHRoZSB1c2VyIGxldmVsLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqIEFuIGltcGxlbWVudGF0aW9uIG9mIHRoZSBUQ1AvSVAgcHJvdG9jb2wgc3VpdGUgZm9yIHRoZSBMSU5VWCBvcGVyYXRpbmcKKyAqIHN5c3RlbS4gSU5FVCBpcyBpbXBsZW1lbnRlZCB1c2luZyB0aGUgQlNEIFNvY2tldCBpbnRlcmZhY2UgYXMgdGhlCisgKiBtZWFucyBvZiBjb21tdW5pY2F0aW9uIHdpdGggdGhlIHVzZXIgbGV2ZWwuCiAgKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvZGl2c2kzLlMgYi9hcmNoL2JsYWNrZmluL2xpYi9kaXZzaTMuUwppbmRleCAyYWM1OWM3Li5mODljNWE0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2xpYi9kaXZzaTMuUworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9kaXZzaTMuUwpAQCAtMSwxMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2xpYi9kaXZzaTMuUwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICAxNiAvIDMyIGJpdCBzaWduZWQgZGl2aXNpb24uCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCisgKgorICogMTYgLyAzMiBiaXQgc2lnbmVkIGRpdmlzaW9uLgogICogICAgICAgICAgICAgICAgIFNwZWNpYWwgY2FzZXMgOgogICogICAgICAgICAgICAgICAgICAgICAgMSkgIElmKG51bWVyYXRvciA9PSAwKQogICogICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAwCkBAIC0yMiwyNSArMjEsNiBAQAogICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFIwIC0gUXVvdGllbnQgICAgKG8pCiAgKiAgICAgICAgICAgICAgICAgUmVnaXN0ZXJzIFVzZWQgOiBSMi1SNyxQMC1QMgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKICAqLwogCiAuZ2xvYmFsICAgX19fZGl2c2kzOwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvZ2NjbGliLmggYi9hcmNoL2JsYWNrZmluL2xpYi9nY2NsaWIuaAppbmRleCA5Y2NkMzlhLi43MjRmMDdmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2xpYi9nY2NsaWIuaAorKysgYi9hcmNoL2JsYWNrZmluL2xpYi9nY2NsaWIuaApAQCAtMSwzMCArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2xpYi9nY2NsaWIuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNkZWZpbmUgQklUU19QRVJfVU5JVCAgOApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvbHNocmRpMy5jIGIvYXJjaC9ibGFja2Zpbi9saWIvbHNocmRpMy5jCmluZGV4IGU1N2JmNmYuLjUzZjE3NDEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL2xzaHJkaTMuYworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9sc2hyZGkzLmMKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9saWIvbHNocmRpMy5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgImdjY2xpYi5oIgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvbWVtY2hyLlMgYi9hcmNoL2JsYWNrZmluL2xpYi9tZW1jaHIuUwppbmRleCA1ZGE0MjgxLi41NDJlNDBmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2xpYi9tZW1jaHIuUworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9tZW1jaHIuUwpAQCAtMSwzMCArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2xpYi9tZW1jaHIuUwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2xpYi9tZW1jbXAuUyBiL2FyY2gvYmxhY2tmaW4vbGliL21lbWNtcC5TCmluZGV4IDIxOWZhMjguLmNlNWI5ZjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL21lbWNtcC5TCisrKyBiL2FyY2gvYmxhY2tmaW4vbGliL21lbWNtcC5TCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbGliL21lbWNtcC5TCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbGliL21lbWNweS5TIGIvYXJjaC9ibGFja2Zpbi9saWIvbWVtY3B5LlMKaW5kZXggZTY1NGExOC4uYzMxYmYyMiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9saWIvbWVtY3B5LlMKKysrIGIvYXJjaC9ibGFja2Zpbi9saWIvbWVtY3B5LlMKQEAgLTEsMzYgKzEsMTMgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbGliL21lbWNweS5TCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIGludGVybmFsIHZlcnNpb24gb2YgbWVtY3B5KCksIGlzc3VlZCBieSB0aGUgY29tcGlsZXIgdG8gY29weSBibG9ja3Mgb2YKKyAqIGRhdGEgYXJvdW5kLiBUaGlzIGlzIHJlYWxseSBtZW1tb3ZlKCkgLSBpdCBoYXMgdG8gYmUgYWJsZSB0byBkZWFsIHdpdGgKKyAqIHBvc3NpYmxlIG92ZXJsYXBzLCBiZWNhdXNlIHRoYXQgYW1iaWd1aXR5IGlzIHdoZW4gdGhlIGNvbXBpbGVyIGdpdmVzIHVwCisgKiBhbmQgY2FsbHMgYSBmdW5jdGlvbi4gV2UgaGF2ZSBvdXIgb3duLCBpbnRlcm5hbCB2ZXJzaW9uIHNvIHRoYXQgd2UgZ2V0CisgKiBzb21ldGhpbmcgd2UgdHJ1c3QsIGV2ZW4gaWYgdGhlIHVzZXIgaGFzIHJlZGVmaW5lZCB0aGUgbm9ybWFsIHN5bWJvbC4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBpbnRlcm5hbCB2ZXJzaW9uIG9mIG1lbWNweSgpLCBpc3N1ZWQgYnkgdGhlIGNvbXBpbGVyCi0gKiAgICAgICAgICAgICAgIHRvIGNvcHkgYmxvY2tzIG9mIGRhdGEgYXJvdW5kLgotICogICAgICAgICAgICAgICBUaGlzIGlzIHJlYWxseSBtZW1tb3ZlKCkgLSBpdCBoYXMgdG8gYmUgYWJsZSB0byBkZWFsIHdpdGgKLSAqICAgICAgICAgICAgICAgcG9zc2libGUgb3ZlcmxhcHMsIGJlY2F1c2UgdGhhdCBhbWJpZ3VpdHkgaXMgd2hlbiB0aGUgY29tcGlsZXIKLSAqICAgICAgICAgICAgICAgZ2l2ZXMgdXAgYW5kIGNhbGxzIGEgZnVuY3Rpb24uIFdlIGhhdmUgb3VyIG93biwgaW50ZXJuYWwgdmVyc2lvbgotICogICAgICAgICAgICAgICBzbyB0aGF0IHdlIGdldCBzb21ldGhpbmcgd2UgdHJ1c3QsIGV2ZW4gaWYgdGhlIHVzZXIgaGFzIHJlZGVmaW5lZAotICogICAgICAgICAgICAgICB0aGUgbm9ybWFsIHN5bWJvbC4KKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvbWVtbW92ZS5TIGIvYXJjaC9ibGFja2Zpbi9saWIvbWVtbW92ZS5TCmluZGV4IDMzZjg2NTMuLjgwYzI0MGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL21lbW1vdmUuUworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9tZW1tb3ZlLlMKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9saWIvbWVtbW92ZS5TCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA1LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbGliL21lbXNldC5TIGIvYXJjaC9ibGFja2Zpbi9saWIvbWVtc2V0LlMKaW5kZXggODE1OTEzNi4uYzMwZDk5YiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9saWIvbWVtc2V0LlMKKysrIGIvYXJjaC9ibGFja2Zpbi9saWIvbWVtc2V0LlMKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9saWIvbWVtc2V0LlMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvbW9kc2kzLlMgYi9hcmNoL2JsYWNrZmluL2xpYi9tb2RzaTMuUwppbmRleCBjYTFkZDM5Li44YjBjN2Q0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2xpYi9tb2RzaTMuUworKysgYi9hcmNoL2JsYWNrZmluL2xpYi9tb2RzaTMuUwpAQCAtMSwzNiArMSwxMiBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9saWIvbW9kc2kzLlMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogVGhpcyBwcm9ncmFtIGNvbXB1dGVzIDMyIGJpdCBzaWduZWQgcmVtYWluZGVyLiBJdCBjYWxscyBkaXYzMiBmdW5jdGlvbgorICogZm9yIHF1b3RpZW50IGVzdGltYXRpb24uCisgKiAgIFJlZ2lzdGVycyBpbjogIFIwLCBSMSA9IE51bWVyYXRvci8gRGVub21pbmF0b3IKKyAqICAgUmVnaXN0ZXJzIG91dDogUjAgICAgID0gUmVtYWluZGVyCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgVGhpcyBwcm9ncmFtIGNvbXB1dGVzIDMyIGJpdCBzaWduZWQgcmVtYWluZGVyLiBJdCBjYWxscyBkaXYzMiBmdW5jdGlvbgotICogICAgICAgICAgICAgICBmb3IgcXVvdGllbnQgZXN0aW1hdGlvbi4KKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqICAgICAgICAgICAgICAgUmVnaXN0ZXJzIHVzZWQgOgotICogICAgICAgICAgICAgICBOdW1lcmF0b3IvIERlbm9taW5hdG9yIGluICBSMCwgUjEKLSAqICAgICAgICAgICAgICAgICBSMCAgLSAgcmV0dXJucyByZW1haW5kZXIuCi0gKiAgICAgICAgICAgICAgICAgUjItUjcKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogLmdsb2JhbCBfX19tb2RzaTM7CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2xpYi9tdWxkaTMuUyBiL2FyY2gvYmxhY2tmaW4vbGliL211bGRpMy5TCmluZGV4IGFiZGUxMjAuLjk1M2EzOGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL211bGRpMy5TCisrKyBiL2FyY2gvYmxhY2tmaW4vbGliL211bGRpMy5TCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCisgKi8KKwogLmFsaWduIDIKIC5nbG9iYWwgX19fbXVsZGkzOwogLnR5cGUgX19fbXVsZGkzLCBTVFRfRlVOQzsKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbGliL291dHMuUyBiL2FyY2gvYmxhY2tmaW4vbGliL291dHMuUwppbmRleCA0Njg1YjdhLi4yNTBmNGQ0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2xpYi9vdXRzLlMKKysrIGIvYXJjaC9ibGFja2Zpbi9saWIvb3V0cy5TCkBAIC0xLDMwICsxLDExIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2xpYi9vdXRzLlMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOiAgICAgICBCYXMgVmVybWV1bGVuIDxiYXNAYnV5d2F5cy5ubD4KKyAqIEltcGxlbWVudGF0aW9uIG9mIG91dHN7YndsfSBmb3IgQmxhY2tGaW4gcHJvY2Vzc29ycyB1c2luZyB6ZXJvIG92ZXJoZWFkIGxvb3BzLgogICoKLSAqIENyZWF0ZWQ6ICAgICAgVHVlIE1hciAyMiAxNToyNzoyNCBDRVNUIDIwMDUKLSAqIERlc2NyaXB0aW9uOiAgSW1wbGVtZW50YXRpb24gb2Ygb3V0c3tid2x9IGZvciBCbGFja0ZpbiBwcm9jZXNzb3JzIHVzaW5nIHplcm8gb3ZlcmhlYWQgbG9vcHMuCisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgIDIwMDUgQnV5V2F5cyBCVgorICogICAgICAgICAgICAgICAgICAgICAgQmFzIFZlcm1ldWxlbiA8YmFzQGJ1eXdheXMubmw+CiAgKgotICogTW9kaWZpZWQ6ICAgICBDb3B5cmlnaHQgKEMpIDIwMDUgQmFzIFZlcm1ldWxlbiwgQnV5V2F5cyBCViA8YmFzQGJ1eXdheXMubmw+Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2xpYi9zbXVsc2kzX2hpZ2hwYXJ0LlMgYi9hcmNoL2JsYWNrZmluL2xpYi9zbXVsc2kzX2hpZ2hwYXJ0LlMKaW5kZXggZTM4M2NkMy4uOTllZThjNSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9saWIvc211bHNpM19oaWdocGFydC5TCisrKyBiL2FyY2gvYmxhY2tmaW4vbGliL3NtdWxzaTNfaGlnaHBhcnQuUwpAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQorICovCisKIC5hbGlnbiAyCiAuZ2xvYmFsIF9fX3NtdWxzaTNfaGlnaHBhcnQ7CiAudHlwZSBfX19zbXVsc2kzX2hpZ2hwYXJ0LCBTVFRfRlVOQzsKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbGliL3VkaXZzaTMuUyBiL2FyY2gvYmxhY2tmaW4vbGliL3VkaXZzaTMuUwppbmRleCA1OGZkOTZkLi45N2U5MDQzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL2xpYi91ZGl2c2kzLlMKKysrIGIvYXJjaC9ibGFja2Zpbi9saWIvdWRpdnNpMy5TCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbGliL3VkaXZzaTMuUwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpbmNsdWRlIDxsaW51eC9saW5rYWdlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL2xpYi91bW9kc2kzLlMgYi9hcmNoL2JsYWNrZmluL2xpYi91bW9kc2kzLlMKaW5kZXggNGYyYjc2ZS4uMTY4ZWJhNyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9saWIvdW1vZHNpMy5TCisrKyBiL2FyY2gvYmxhY2tmaW4vbGliL3Vtb2RzaTMuUwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL2xpYi91bW9kc2kzLlMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogbGliZ2NjMSByb3V0aW5lcyBmb3IgQmxhY2tmaW4gNXh4CiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgbGliZ2NjMSByb3V0aW5lcyBmb3IgQmxhY2tmaW4gNXh4CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2lmZGVmIENPTkZJR19BUklUSE1FVElDX09QU19MMQpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9saWIvdW11bHNpM19oaWdocGFydC5TIGIvYXJjaC9ibGFja2Zpbi9saWIvdW11bHNpM19oaWdocGFydC5TCmluZGV4IDY3Yjc5OTMuLjA1MTgyNGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbGliL3VtdWxzaTNfaGlnaHBhcnQuUworKysgYi9hcmNoL2JsYWNrZmluL2xpYi91bXVsc2kzX2hpZ2hwYXJ0LlMKQEAgLTEsMyArMSw5IEBACisvKgorICogQ29weXJpZ2h0IDIwMDcgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKKyAqLworCiAuYWxpZ24gMgogLmdsb2JhbCBfX191bXVsc2kzX2hpZ2hwYXJ0OwogLnR5cGUgX19fdW11bHNpM19oaWdocGFydCwgU1RUX0ZVTkM7CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvYm9hcmRzL2V6YnJkLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvYm9hcmRzL2V6YnJkLmMKaW5kZXggMDNlNGE5OS4uMDE5NzVjMCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2JvYXJkcy9lemJyZC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9ib2FyZHMvZXpicmQuYwpAQCAtMSwzMSArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvYm9hcmRzL2V6YnJkLmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2JvYXJkcy9lemJyZC5jCi0gKiBBdXRob3I6ICAgICAgIEJyeWFuIFd1IDxjb29sb25leUBrZXJuZWwub3JnPgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CkBAIC01NzEsMTkgKzU0OSw2IEBACiB9OwogI2VuZGlmCiAKLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYmZpbl9ncGlvc19yZXNvdXJjZXMgPSB7Ci0JLnN0YXJ0ID0gMCwKLQkuZW5kICAgPSBNQVhfQkxBQ0tGSU5fR1BJT1MgLSAxLAotCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAotfTsKLQotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYmZpbl9ncGlvc19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAic2ltcGxlLWdwaW8iLAotCS5pZCA9IC0xLAotCS5udW1fcmVzb3VyY2VzID0gMSwKLQkucmVzb3VyY2UgPSAmYmZpbl9ncGlvc19yZXNvdXJjZXMsCi19OwotCiBzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IGNjbGtfdmxldl9kYXRhc2hlZXRbXSA9CiB7CiAJVlJQQUlSKFZMRVZfMTAwLCA0MDAwMDAwMDApLApAQCAtNjYwLDggKzYyNSw2IEBACiAjaWYgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVApIHx8IGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQX01PRFVMRSkKIAkmZXpicmRfZmxhc2hfZGV2aWNlLAogI2VuZGlmCi0KLQkmYmZpbl9ncGlvc19kZXZpY2UsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCBlemJyZF9pbml0KHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvZG1hLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvZG1hLmMKaW5kZXggNjk4ZTg4Yy4uNzhiNDM2MCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2RtYS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9kbWEuYwpAQCAtMSwzMSArMSwxMSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2RtYS5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjogICAgICAgQnJ5YW4gV3UgPGNvb2xvbmV5QGtlcm5lbC5vcmc+CisgKiB0aGUgc2ltcGxlIERNQSBJbXBsZW1lbnRhdGlvbiBmb3IgQmxhY2tmaW4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBUaGlzIGZpbGUgY29udGFpbnMgdGhlIHNpbXBsZSBETUEgSW1wbGVtZW50YXRpb24gZm9yIEJsYWNrZmluCisgKiBDb3B5cmlnaHQgMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCisKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KIAogI2luY2x1ZGUgPGFzbS9ibGFja2Zpbi5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9iZjUxOC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9iZjUxOC5oCmluZGV4IDc4ZGExYTAuLjg1NmIzMzAgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvYmY1MTguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2JmNTE4LmgKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUxOC9iZjUxOC5oCi0gKiBCYXNlZCBvbjoJaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9iZjUyNy5oCi0gKiBBdXRob3I6CU1pY2hhZWwgSGVubmVyaWNoIChtaWNoYWVsLmhlbm5lcmljaEBhbmFsb2cuY29tKQorICogQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNZU1RFTSBNTVIgUkVHSVNURVIgQU5EIE1FTU9SWSBNQVAgRk9SIEFEU1AtQkY1MTgKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfX01BQ0hfQkY1MThfSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9iZmluX3NlcmlhbF81eHguaAppbmRleCBkYmFkZTkzLi45NzBkMzEwIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIGZpbGU6ICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTE4L2JmaW5fc2VyaWFsXzV4eC5oCi0gKiBiYXNlZCBvbjoKLSAqIGF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIGNyZWF0ZWQ6Ci0gKiBkZXNjcmlwdGlvbjoKLSAqCWJsYWNrZmluIHNlcmlhbCBkcml2ZXIgaGVhZCBmaWxlCi0gKiByZXY6Ci0gKgotICogbW9kaWZpZWQ6Ci0gKgotICoKLSAqIGJ1Z3M6ICAgICAgICAgZW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiB0aGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCB3aXRob3V0IGFueSB3YXJyYW50eTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBtZXJjaGFudGFiaWxpdHkgb3IgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2UuICBzZWUgdGhlCi0gKiBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIHlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIGNvcHlpbmcuCi0gKiBpZiBub3QsIHdyaXRlIHRvIHRoZSBmcmVlIHNvZnR3YXJlIGZvdW5kYXRpb24sCi0gKiA1OSB0ZW1wbGUgcGxhY2UgLSBzdWl0ZSAzMzAsIGJvc3RvbiwgbWEgMDIxMTEtMTMwNywgdXNhLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L3NlcmlhbC5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oCmluZGV4IDgzNDIxZDMuLjZjZmIyNDYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUxOC9ibGFja2Zpbi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2lmbmRlZiBfTUFDSF9CTEFDS0ZJTl9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MTIuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvY2RlZkJGNTEyLmgKaW5kZXggODIwYzEzYy4uNDkzMDIwZCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MTIuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2NkZWZCRjUxMi5oCkBAIC0xLDMyICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MTgvY2RlZmJmNTEyLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDgtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgc3lzdGVtIG1tciByZWdpc3RlciBtYXAKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0NERUZfQkY1MTJfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MTQuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvY2RlZkJGNTE0LmgKaW5kZXggZGZlNDkyZC4uZTFkOTk5MSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MTQuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2NkZWZCRjUxNC5oCkBAIC0xLDMyICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MTgvY2RlZmJmNTE0LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDgtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgc3lzdGVtIG1tciByZWdpc3RlciBtYXAKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2lmbmRlZiBfQ0RFRl9CRjUxNF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2NkZWZCRjUxNi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MTYuaAppbmRleCAxNGRmNDNkLi42YjM2NGVkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2NkZWZCRjUxNi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvY2RlZkJGNTE2LmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUxOC9jZGVmYmY1MTYuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTE2X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvY2RlZkJGNTE4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2NkZWZCRjUxOC5oCmluZGV4IGJhZmIzNzAuLjkyOWI5MDYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvY2RlZkJGNTE4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MTguaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTE4L2NkZWZiZjUxOC5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIHN5c3RlbSBtbXIgcmVnaXN0ZXIgbWFwCi0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX0NERUZfQkY1MThfSApAQCAtMjExLDYgKzE4Niw0NyBAQAogI2RlZmluZSBiZmluX3JlYWRfRU1BQ19UWENfQUJPUlQoKQkJYmZpbl9yZWFkMzIoRU1BQ19UWENfQUJPUlQpCiAjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19UWENfQUJPUlQodmFsKQkJYmZpbl93cml0ZTMyKEVNQUNfVFhDX0FCT1JULCB2YWwpCiAKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX0NUTCgpICAgICAgICAgICAgICAgIGJmaW5fcmVhZDE2KEVNQUNfUFRQX0NUTCkKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9DVEwodmFsKSAgICAgICAgICAgIGJmaW5fd3JpdGUxNihFTUFDX1BUUF9DVEwsIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX0lFKCkgICAgICAgICAgICAgICAgIGJmaW5fcmVhZDE2KEVNQUNfUFRQX0lFKQorI2RlZmluZSBiZmluX3dyaXRlX0VNQUNfUFRQX0lFKHZhbCkgICAgICAgICAgICAgYmZpbl93cml0ZTE2KEVNQUNfUFRQX0lFLCB2YWwpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9JU1RBVCgpICAgICAgICAgICAgICBiZmluX3JlYWQxNihFTUFDX1BUUF9JU1RBVCkKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9JU1RBVCh2YWwpICAgICAgICAgIGJmaW5fd3JpdGUxNihFTUFDX1BUUF9JU1RBVCwgdmFsKQorI2RlZmluZSBiZmluX3JlYWRfRU1BQ19QVFBfRk9GRigpICAgICAgICAgICAgICAgYmZpbl9yZWFkMzIoRU1BQ19QVFBfRk9GRikKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9GT0ZGKHZhbCkgICAgICAgICAgIGJmaW5fd3JpdGUzMihFTUFDX1BUUF9GT0ZGLCB2YWwpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9GVjEoKSAgICAgICAgICAgICAgICBiZmluX3JlYWQzMihFTUFDX1BUUF9GVjEpCisjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19QVFBfRlYxKHZhbCkgICAgICAgICAgICBiZmluX3dyaXRlMzIoRU1BQ19QVFBfRlYxLCB2YWwpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9GVjIoKSAgICAgICAgICAgICAgICBiZmluX3JlYWQzMihFTUFDX1BUUF9GVjIpCisjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19QVFBfRlYyKHZhbCkgICAgICAgICAgICBiZmluX3dyaXRlMzIoRU1BQ19QVFBfRlYyLCB2YWwpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9GVjMoKSAgICAgICAgICAgICAgICBiZmluX3JlYWQzMihFTUFDX1BUUF9GVjMpCisjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19QVFBfRlYzKHZhbCkgICAgICAgICAgICBiZmluX3dyaXRlMzIoRU1BQ19QVFBfRlYzLCB2YWwpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9BRERFTkQoKSAgICAgICAgICAgICBiZmluX3JlYWQzMihFTUFDX1BUUF9BRERFTkQpCisjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19QVFBfQURERU5EKHZhbCkgICAgICAgICBiZmluX3dyaXRlMzIoRU1BQ19QVFBfQURERU5ELCB2YWwpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9BQ0NSKCkgICAgICAgICAgICAgICBiZmluX3JlYWQzMihFTUFDX1BUUF9BQ0NSKQorI2RlZmluZSBiZmluX3dyaXRlX0VNQUNfUFRQX0FDQ1IodmFsKSAgICAgICAgICAgYmZpbl93cml0ZTMyKEVNQUNfUFRQX0FDQ1IsIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX09GRlNFVCgpICAgICAgICAgICAgIGJmaW5fcmVhZDMyKEVNQUNfUFRQX09GRlNFVCkKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9PRkZTRVQodmFsKSAgICAgICAgIGJmaW5fd3JpdGUzMihFTUFDX1BUUF9PRkZTRVQsIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX1RJTUVMTygpICAgICAgICAgICAgIGJmaW5fcmVhZDMyKEVNQUNfUFRQX1RJTUVMTykKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9USU1FTE8odmFsKSAgICAgICAgIGJmaW5fd3JpdGUzMihFTUFDX1BUUF9USU1FTE8sIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX1RJTUVISSgpICAgICAgICAgICAgIGJmaW5fcmVhZDMyKEVNQUNfUFRQX1RJTUVISSkKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9USU1FSEkodmFsKSAgICAgICAgIGJmaW5fd3JpdGUzMihFTUFDX1BUUF9USU1FSEksIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX1JYU05BUExPKCkgICAgICAgICAgIGJmaW5fcmVhZDMyKEVNQUNfUFRQX1JYU05BUExPKQorI2RlZmluZSBiZmluX3JlYWRfRU1BQ19QVFBfUlhTTkFQSEkoKSAgICAgICAgICAgYmZpbl9yZWFkMzIoRU1BQ19QVFBfUlhTTkFQSEkpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9UWFNOQVBMTygpICAgICAgICAgICBiZmluX3JlYWQzMihFTUFDX1BUUF9UWFNOQVBMTykKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX1RYU05BUEhJKCkgICAgICAgICAgIGJmaW5fcmVhZDMyKEVNQUNfUFRQX1RYU05BUEhJKQorI2RlZmluZSBiZmluX3JlYWRfRU1BQ19QVFBfQUxBUk1MTygpICAgICAgICAgICAgYmZpbl9yZWFkMzIoRU1BQ19QVFBfQUxBUk1MTykKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9BTEFSTUxPKHZhbCkgICAgICAgIGJmaW5fd3JpdGUzMihFTUFDX1BUUF9BTEFSTUxPLCB2YWwpCisjZGVmaW5lIGJmaW5fcmVhZF9FTUFDX1BUUF9BTEFSTUhJKCkgICAgICAgICAgICBiZmluX3JlYWQzMihFTUFDX1BUUF9BTEFSTUhJKQorI2RlZmluZSBiZmluX3dyaXRlX0VNQUNfUFRQX0FMQVJNSEkodmFsKSAgICAgICAgYmZpbl93cml0ZTMyKEVNQUNfUFRQX0FMQVJNSEksIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX0lEX09GRigpICAgICAgICAgICAgIGJmaW5fcmVhZDE2KEVNQUNfUFRQX0lEX09GRikKKyNkZWZpbmUgYmZpbl93cml0ZV9FTUFDX1BUUF9JRF9PRkYodmFsKSAgICAgICAgIGJmaW5fd3JpdGUxNihFTUFDX1BUUF9JRF9PRkYsIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX0lEX1NOQVAoKSAgICAgICAgICAgIGJmaW5fcmVhZDMyKEVNQUNfUFRQX0lEX1NOQVApCisjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19QVFBfSURfU05BUCh2YWwpICAgICAgICBiZmluX3dyaXRlMzIoRU1BQ19QVFBfSURfU05BUCwgdmFsKQorI2RlZmluZSBiZmluX3JlYWRfRU1BQ19QVFBfUFBTX1NUQVJUSEkoKSAgICAgICAgYmZpbl9yZWFkMzIoRU1BQ19QVFBfUFBTX1NUQVJUSEkpCisjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19QVFBfUFBTX1NUQVJUSEkodmFsKSAgICBiZmluX3dyaXRlMzIoRU1BQ19QVFBfUFBTX1NUQVJUSEksIHZhbCkKKyNkZWZpbmUgYmZpbl9yZWFkX0VNQUNfUFRQX1BQU19QRVJJT0QoKSAgICAgICAgIGJmaW5fcmVhZDMyKEVNQUNfUFRQX1BQU19QRVJJT0QpCisjZGVmaW5lIGJmaW5fd3JpdGVfRU1BQ19QVFBfUFBTX1BFUklPRCh2YWwpICAgICBiZmluX3dyaXRlMzIoRU1BQ19QVFBfUFBTX1BFUklPRCwgdmFsKQorCiAvKiBSZW1vdmFibGUgU3RvcmFnZSBJbnRlcmZhY2UgUmVnaXN0ZXJzICovCiAKICNkZWZpbmUgYmZpbl9yZWFkX1JTSV9QV1JfQ1RMKCkgICAgICAgIGJmaW5fcmVhZDE2KFJTSV9QV1JfQ09OVFJPTCkKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvY2RlZkJGNTF4X2Jhc2UuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvY2RlZkJGNTF4X2Jhc2UuaAppbmRleCBlZTNkNDczLi4xZDk3MGRmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2NkZWZCRjUxeF9iYXNlLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MXhfYmFzZS5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MTgvY2RlZkJGNTF4X2Jhc2UuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX0NERUZfQkY1MlhfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9kZWZCRjUxMi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9kZWZCRjUxMi5oCmluZGV4IGE5NmNhOTAuLjliNTA1YmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvZGVmQkY1MTIuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2RlZkJGNTEyLmgKQEAgLTEsMzEgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUxOC9kZWZCRjUxMi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0RFRl9CRjUxMl9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2RlZkJGNTE0LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2RlZkJGNTE0LmgKaW5kZXggNTZlZTVhNy4uYjVhZGNhMiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9kZWZCRjUxNC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvZGVmQkY1MTQuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTE4L2RlZkJGNTE0LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDgtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaWZuZGVmIF9ERUZfQkY1MTRfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9kZWZCRjUxNi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9kZWZCRjUxNi5oCmluZGV4IGRmYzkzODQuLjdlYjE4NzcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvZGVmQkY1MTYuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2RlZkJGNTE2LmgKQEAgLTEsMzEgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUxOC9kZWZCRjUxNi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2lmbmRlZiBfREVGX0JGNTE2X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvZGVmQkY1MTguaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvZGVmQkY1MTguaAppbmRleCA2ZTk4MmFiLi43OTRjZjA2ZSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9kZWZCRjUxOC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvZGVmQkY1MTguaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTE4L2RlZkJGNTE4LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDgtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaWZuZGVmIF9ERUZfQkY1MThfSApAQCAtNjQ4LDQgKzYyNCwzMiBAQAogCiAjZGVmaW5lICAgICAgICAgICAgICAgICAgICAgICBSV1IgIDB4MSAgICAgICAgLyogUmVhZCBXYWl0IFJlcXVlc3QgKi8KIAorLyogQml0IG1hc2tzIGZvciBFTUFDX1BUUF9DVEwgKi8KKworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgUFRQX0VOICAweDEgICAgICAgIC8qIEVuYWJsZSB0aGUgUFRQX1RTWU5DIG1vZHVsZSAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICAgIFRMICAweDIgICAgICAgIC8qIFRpbWVzdGFtcCBsb2NrIGNvbnRyb2wgKi8KKyNkZWZpbmUgICAgICAgICAgICAgICAgICAgICAgQVNFTiAgMHgxMCAgICAgICAvKiBBdXhpbGlhcnkgc25hcHNob3QgY29udHJvbCAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgIFBQU0VOICAweDgwICAgICAgIC8qIFB1bHNlLXBlci1zZWNvbmQgKFBQUykgY29udHJvbCAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgIENLT0VOICAweDIwMDAgICAgIC8qIENsb2NrIG91dHB1dCBjb250cm9sICovCisKKy8qIEJpdCBtYXNrcyBmb3IgRU1BQ19QVFBfSUUgKi8KKworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICBBTElFICAweDEgICAgICAgIC8qIEFsYXJtIGludGVycnVwdCBlbmFibGUgKi8KKyNkZWZpbmUgICAgICAgICAgICAgICAgICAgICBSWEVJRSAgMHgyICAgICAgICAvKiBSZWNlaXZlIGV2ZW50IGludGVycnVwdCBlbmFibGUgKi8KKyNkZWZpbmUgICAgICAgICAgICAgICAgICAgICBSWEdJRSAgMHg0ICAgICAgICAvKiBSZWNlaXZlIGdlbmVyYWwgaW50ZXJydXB0IGVuYWJsZSAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICBUWElFICAweDggICAgICAgIC8qIFRyYW5zbWl0IGludGVycnVwdCBlbmFibGUgKi8KKyNkZWZpbmUgICAgICAgICAgICAgICAgICAgICBSWE9WRSAgMHgxMCAgICAgICAvKiBSZWNlaXZlIG92ZXJydW4gZXJyb3IgaW50ZXJydXB0IGVuYWJsZSAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgIFRYT1ZFICAweDIwICAgICAgIC8qIFRyYW5zbWl0IG92ZXJydW4gZXJyb3IgaW50ZXJydXB0IGVuYWJsZSAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICBBU0lFICAweDQwICAgICAgIC8qIEF1eGlsaWFyeSBzbmFwc2hvdCBpbnRlcnJ1cHQgZW5hYmxlICovCisKKy8qIEJpdCBtYXNrcyBmb3IgRU1BQ19QVFBfSVNUQVQgKi8KKworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICAgQUxTICAweDEgICAgICAgIC8qIEFsYXJtIHN0YXR1cyAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICBSWEVMICAweDIgICAgICAgIC8qIFJlY2VpdmUgZXZlbnQgaW50ZXJydXB0IHN0YXR1cyAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICBSWEdMICAweDQgICAgICAgIC8qIFJlY2VpdmUgZ2VuZXJhbCBpbnRlcnJ1cHQgc3RhdHVzICovCisjZGVmaW5lICAgICAgICAgICAgICAgICAgICAgIFRYVEwgIDB4OCAgICAgICAgLyogVHJhbnNtaXQgc25hcHNob3Qgc3RhdHVzICovCisjZGVmaW5lICAgICAgICAgICAgICAgICAgICAgIFJYT1YgIDB4MTAgICAgICAgLyogUmVjZWl2ZSBzbmFwc2hvdCBvdmVycnVuIHN0YXR1cyAqLworI2RlZmluZSAgICAgICAgICAgICAgICAgICAgICBUWE9WICAweDIwICAgICAgIC8qIFRyYW5zbWl0IHNuYXBzaG90IG92ZXJydW4gc3RhdHVzICovCisjZGVmaW5lICAgICAgICAgICAgICAgICAgICAgICBBU0wgIDB4NDAgICAgICAgLyogQXV4aWxpYXJ5IHNuYXBzaG90IGludGVycnVwdCBzdGF0dXMgKi8KKwogI2VuZGlmIC8qIF9ERUZfQkY1MThfSCAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9kZWZCRjUxeF9iYXNlLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2RlZkJGNTF4X2Jhc2UuaAppbmRleCAxYmVjOGQxLi5lMDZmNDExIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2RlZkJGNTF4X2Jhc2UuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2RlZkJGNTF4X2Jhc2UuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTE4L2RlZkJGNTF4X2Jhc2UuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaWZuZGVmIF9ERUZfQkY1MVhfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9ncGlvLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2dwaW8uaAppbmRleCA5NzU3NjgzLi5iYmFiMmQ3IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2dwaW8uaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2dwaW8uaApAQCAtMSw3ICsxLDQgQEAKIC8qCi0gKiBGaWxlOiBhcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2dwaW8uaAotICogQnVnczogRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgogICogQ29weXJpZ2h0IChDKSAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9pcnEuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbmNsdWRlL21hY2gvaXJxLmgKaW5kZXggM2ZmMGYwOS4uMTRlNTJlYyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9pcnEuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL2lycS5oCkBAIC0xLDMyICsxLDcgQEAKIC8qCi0gKiBmaWxlOglpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTE4L2lycS5oCi0gKiBiYXNlZCBvbjoJaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9pcnEuaAotICogYXV0aG9yOglNaWNoYWVsIEhlbm5lcmljaCAobWljaGFlbC5oZW5uZXJpY2hAYW5hbG9nLmNvbSkKKyAqIENvcHlyaWdodCAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBjcmVhdGVkOgotICogZGVzY3JpcHRpb246Ci0gKglzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICogcmV2OgotICoKLSAqIG1vZGlmaWVkOgotICoKLSAqCi0gKiBidWdzOiAgICAgICAgIGVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgd2l0aG91dCBhbnkgd2FycmFudHk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogbWVyY2hhbnRhYmlsaXR5IG9yIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlLiAgc2VlIHRoZQotICogZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiB5b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBjb3B5aW5nLgotICogaWYgbm90LCB3cml0ZSB0byB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uLAotICogNTkgdGVtcGxlIHBsYWNlIC0gc3VpdGUgMzMwLCBib3N0b24sIG1hIDAyMTExLTEzMDcsIHVzYS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX0JGNTE4X0lSUV9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2luY2x1ZGUvbWFjaC9wb3J0bXV4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAppbmRleCBhMGZjNzdmLi5lMzUyOTEwIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW5jbHVkZS9tYWNoL3BvcnRtdXguaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKKyAqLworCiAjaWZuZGVmIF9NQUNIX1BPUlRNVVhfSF8KICNkZWZpbmUgX01BQ0hfUE9SVE1VWF9IXwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW50cy1wcmlvcml0eS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2ludHMtcHJpb3JpdHkuYwppbmRleCAzMTUxZmQ1Li5iYjA1YmVmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MTgvaW50cy1wcmlvcml0eS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUxOC9pbnRzLXByaW9yaXR5LmMKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTE4L2ludHMtcHJpb3JpdHkuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW50cy1wcmlvcml0eS5jCi0gKiBBdXRob3I6ICAgICAgIEJyeWFuIFd1IDxjb29sb25leUBrZXJuZWwub3JnPgorICogU2V0IHVwIHRoZSBpbnRlcnJ1cHQgcHJpb3JpdGllcwogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNldCB1cCB0aGUgaW50ZXJydXB0IHByaW9yaXRpZXMKKyAqIENvcHlyaWdodCAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2JvYXJkcy9jbV9iZjUyNy5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2JvYXJkcy9jbV9iZjUyNy5jCmluZGV4IDA4YTNmMDEuLmYxOTk2YjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9ib2FyZHMvY21fYmY1MjcuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvYm9hcmRzL2NtX2JmNTI3LmMKQEAgLTEsMzEgKzEsMTAgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9ib2FyZHMvY20tYmY1MjcuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3N0YW1wLmMKLSAqIEF1dGhvcjogICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgIDIwMDgtMjAwOSBCbHVldGVjaG5peAorICogICAgICAgICAgICAgICAgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKKyAqICAgICAgICAgICAgICAgICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgpAQCAtNjE2LDEyICs1OTUsNiBAQAogfTsKICNlbmRpZiAgLyogc3BpIG1hc3RlciBhbmQgZGV2aWNlcyAqLwogCi0jaWYgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzKSB8fCBkZWZpbmVkKENPTkZJR19GQl9CRklOXzczOTNfTU9EVUxFKQotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYmZpbl9mYl9hZHY3MzkzX2RldmljZSA9IHsKLQkubmFtZSA9ICJiZmluLWFkdjczOTMiLAotfTsKLSNlbmRpZgotCiAjaWYgZGVmaW5lZChDT05GSUdfTVREX0dQSU9fQUREUikgfHwgZGVmaW5lZChDT05GSUdfTVREX0dQSU9fQUREUl9NT0RVTEUpCiBzdGF0aWMgc3RydWN0IG10ZF9wYXJ0aXRpb24gY21fcGFydGl0aW9uc1tdID0gewogCXsKQEAgLTc4Niw2ICs3NTksMTEgQEAKIAkJLmlycSA9IElSUV9QRjgsCiAJfSwKICNlbmRpZgorI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKKwl7CisJCUkyQ19CT0FSRF9JTkZPKCJiZmluLWFkdjczOTMiLCAweDJCKSwKKwl9LAorI2VuZGlmCiB9OwogCiAjaWYgZGVmaW5lZChDT05GSUdfU0VSSUFMX0JGSU5fU1BPUlQpIHx8IGRlZmluZWQoQ09ORklHX1NFUklBTF9CRklOX1NQT1JUX01PRFVMRSkKQEAgLTgyMSwxOSArNzk5LDYgQEAKIH07CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX2dwaW9zX3Jlc291cmNlcyA9IHsKLQkuc3RhcnQgPSAwLAotCS5lbmQgICA9IE1BWF9CTEFDS0ZJTl9HUElPUyAtIDEsCi0JLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi19OwotCi1zdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBiZmluX2dwaW9zX2RldmljZSA9IHsKLQkubmFtZSA9ICJzaW1wbGUtZ3BpbyIsCi0JLmlkID0gLTEsCi0JLm51bV9yZXNvdXJjZXMgPSAxLAotCS5yZXNvdXJjZSA9ICZiZmluX2dwaW9zX3Jlc291cmNlcywKLX07Ci0KIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgY2Nsa192bGV2X2RhdGFzaGVldFtdID0KIHsKIAlWUlBBSVIoVkxFVl8xMDAsIDQwMDAwMDAwMCksCkBAIC05MDksMTAgKzg3NCw2IEBACiAJJmJmaW5fc3BpMF9kZXZpY2UsCiAjZW5kaWYKIAotI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKLQkmYmZpbl9mYl9hZHY3MzkzX2RldmljZSwKLSNlbmRpZgotCiAjaWYgZGVmaW5lZChDT05GSUdfU0VSSUFMX0JGSU4pIHx8IGRlZmluZWQoQ09ORklHX1NFUklBTF9CRklOX01PRFVMRSkKIAkmYmZpbl91YXJ0X2RldmljZSwKICNlbmRpZgpAQCAtOTQyLDggKzkwMyw2IEBACiAjaWYgZGVmaW5lZChDT05GSUdfTVREX0dQSU9fQUREUikgfHwgZGVmaW5lZChDT05GSUdfTVREX0dQSU9fQUREUl9NT0RVTEUpCiAJJmNtX2ZsYXNoX2RldmljZSwKICNlbmRpZgotCi0JJmJmaW5fZ3Bpb3NfZGV2aWNlLAogfTsKIAogc3RhdGljIGludCBfX2luaXQgY21faW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2JvYXJkcy9lemJyZC5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2JvYXJkcy9lemJyZC5jCmluZGV4IDY4YjRjODAuLmNhZDIzYjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9ib2FyZHMvZXpicmQuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvYm9hcmRzL2V6YnJkLmMKQEAgLTEsMzEgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2JvYXJkcy9lemJyZC5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvc3RhbXAuYwotICogQXV0aG9yOiAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CkBAIC02MTEsMTkgKzU4OSw2IEBACiB9OwogI2VuZGlmCiAKLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYmZpbl9ncGlvc19yZXNvdXJjZXMgPSB7Ci0JLnN0YXJ0ID0gMCwKLQkuZW5kICAgPSBNQVhfQkxBQ0tGSU5fR1BJT1MgLSAxLAotCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAotfTsKLQotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYmZpbl9ncGlvc19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAic2ltcGxlLWdwaW8iLAotCS5pZCA9IC0xLAotCS5udW1fcmVzb3VyY2VzID0gMSwKLQkucmVzb3VyY2UgPSAmYmZpbl9ncGlvc19yZXNvdXJjZXMsCi19OwotCiBzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IGNjbGtfdmxldl9kYXRhc2hlZXRbXSA9CiB7CiAJVlJQQUlSKFZMRVZfMTAwLCA0MDAwMDAwMDApLApAQCAtNzMyLDggKzY5Nyw2IEBACiAjaWYgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVApIHx8IGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQX01PRFVMRSkKIAkmZXpicmRfZmxhc2hfZGV2aWNlLAogI2VuZGlmCi0KLQkmYmZpbl9ncGlvc19kZXZpY2UsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCBlemJyZF9pbml0KHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvYm9hcmRzL2V6a2l0LmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvYm9hcmRzL2V6a2l0LmMKaW5kZXggMjg0OWIwOS4uZjA5NjY1ZiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2JvYXJkcy9lemtpdC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9ib2FyZHMvZXpraXQuYwpAQCAtMSwzMSArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvYm9hcmRzL2V6a2l0LmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9zdGFtcC5jCi0gKiBBdXRob3I6ICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KQEAgLTcxNiwxMiArNjk0LDYgQEAKIH07CiAjZW5kaWYKIAotI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZmJfYWR2NzM5M19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAiYmZpbi1hZHY3MzkzIiwKLX07Ci0jZW5kaWYKLQogI2lmIGRlZmluZWQoQ09ORklHX1NFUklBTF9CRklOKSB8fCBkZWZpbmVkKENPTkZJR19TRVJJQUxfQkZJTl9NT0RVTEUpCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fdWFydF9yZXNvdXJjZXNbXSA9IHsKICNpZmRlZiBDT05GSUdfU0VSSUFMX0JGSU5fVUFSVDAKQEAgLTgzNyw2ICs4MDksMTEgQEAKIAkJLmlycSA9IElSUV9QRjgsCiAJfSwKICNlbmRpZgorI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKKwl7CisJCUkyQ19CT0FSRF9JTkZPKCJiZmluLWFkdjczOTMiLCAweDJCKSwKKwl9LAorI2VuZGlmCiB9OwogCiAjaWYgZGVmaW5lZChDT05GSUdfU0VSSUFMX0JGSU5fU1BPUlQpIHx8IGRlZmluZWQoQ09ORklHX1NFUklBTF9CRklOX1NQT1JUX01PRFVMRSkKQEAgLTkwNSwxOSArODgyLDYgQEAKIH07CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX2dwaW9zX3Jlc291cmNlcyA9IHsKLQkuc3RhcnQgPSAwLAotCS5lbmQgICA9IE1BWF9CTEFDS0ZJTl9HUElPUyAtIDEsCi0JLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi19OwotCi1zdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBiZmluX2dwaW9zX2RldmljZSA9IHsKLQkubmFtZSA9ICJzaW1wbGUtZ3BpbyIsCi0JLmlkID0gLTEsCi0JLm51bV9yZXNvdXJjZXMgPSAxLAotCS5yZXNvdXJjZSA9ICZiZmluX2dwaW9zX3Jlc291cmNlcywKLX07Ci0KIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgY2Nsa192bGV2X2RhdGFzaGVldFtdID0KIHsKIAlWUlBBSVIoVkxFVl8xMDAsIDQwMDAwMDAwMCksCkBAIC0xMDAxLDEwICs5NjUsNiBAQAogCSZiZjUyeF90MzUwbWNxYl9kZXZpY2UsCiAjZW5kaWYKIAotI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKLQkmYmZpbl9mYl9hZHY3MzkzX2RldmljZSwKLSNlbmRpZgotCiAjaWYgZGVmaW5lZChDT05GSUdfU0VSSUFMX0JGSU4pIHx8IGRlZmluZWQoQ09ORklHX1NFUklBTF9CRklOX01PRFVMRSkKIAkmYmZpbl91YXJ0X2RldmljZSwKICNlbmRpZgpAQCAtMTAzOCw4ICs5OTgsNiBAQAogI2lmIGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQKSB8fCBkZWZpbmVkKENPTkZJR19NVERfUEhZU01BUF9NT0RVTEUpCiAJJmV6a2l0X2ZsYXNoX2RldmljZSwKICNlbmRpZgotCi0JJmJmaW5fZ3Bpb3NfZGV2aWNlLAogfTsKIAogc3RhdGljIGludCBfX2luaXQgZXpraXRfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2RtYS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2RtYS5jCmluZGV4IDIzMTg3NzUuLjdiYzc1NzcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9kbWEuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvZG1hLmMKQEAgLTEsMzEgKzEsMTEgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9kbWEuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBUaGlzIGZpbGUgY29udGFpbnMgdGhlIHNpbXBsZSBETUEgSW1wbGVtZW50YXRpb24gZm9yIEJsYWNrZmluCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgVGhpcyBmaWxlIGNvbnRhaW5zIHRoZSBzaW1wbGUgRE1BIEltcGxlbWVudGF0aW9uIGZvciBCbGFja2ZpbgorICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDcgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCisKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KIAogI2luY2x1ZGUgPGFzbS9ibGFja2Zpbi5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9iZjUyNy5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9iZjUyNy5oCmluZGV4IDM4MzJhYWIuLmZmNjhjODggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvYmY1MjcuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2JmNTI3LmgKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9iZjUyNy5oCi0gKiBCYXNlZCBvbjoJaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzNy9iZjUzNy5oCi0gKiBBdXRob3I6CU1pY2hhZWwgSGVubmVyaWNoIChtaWNoYWVsLmhlbm5lcmljaEBhbmFsb2cuY29tKQorICogQ29weXJpZ2h0IDIwMDctMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgU1lTVEVNIE1NUiBSRUdJU1RFUiBBTkQgTUVNT1JZIE1BUCBGT1IgQURTUC1CRjUyNwotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9fTUFDSF9CRjUyN19IX18KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oCmluZGV4IGViZDZjZWIuLmMxZDU1YjggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9iZmluX3NlcmlhbF81eHguaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogZmlsZTogICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MjcvYmZpbl9zZXJpYWxfNXh4LmgKLSAqIGJhc2VkIG9uOgotICogYXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDctMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogY3JlYXRlZDoKLSAqIGRlc2NyaXB0aW9uOgotICoJYmxhY2tmaW4gc2VyaWFsIGRyaXZlciBoZWFkIGZpbGUKLSAqIHJldjoKLSAqCi0gKiBtb2RpZmllZDoKLSAqCi0gKgotICogYnVnczogICAgICAgICBlbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiB0aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBmcmVlIHNvZnR3YXJlIGZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IHdpdGhvdXQgYW55IHdhcnJhbnR5OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIG1lcmNoYW50YWJpbGl0eSBvciBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZS4gIHNlZSB0aGUKLSAqIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogeW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgY29weWluZy4KLSAqIGlmIG5vdCwgd3JpdGUgdG8gdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbiwKLSAqIDU5IHRlbXBsZSBwbGFjZSAtIHN1aXRlIDMzMCwgYm9zdG9uLCBtYSAwMjExMS0xMzA3LCB1c2EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvc2VyaWFsLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmgKaW5kZXggZWE5Y2IwZi4uZTdkNjAzNCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTI3L2JsYWNrZmluLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDctMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaWZuZGVmIF9NQUNIX0JMQUNLRklOX0hfCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2NkZWZCRjUyMi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9jZGVmQkY1MjIuaAppbmRleCA2NjNjMmJiLi4xMDc5YWY4IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2NkZWZCRjUyMi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvY2RlZkJGNTIyLmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9jZGVmYmY1MjIuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTIyX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvY2RlZkJGNTI1LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2NkZWZCRjUyNS5oCmluZGV4IDAwMzc3ZWIuLmRjMzExOWU5IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2NkZWZCRjUyNS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvY2RlZkJGNTI1LmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9jZGVmYmY1MjUuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTI1X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvY2RlZkJGNTI3LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2NkZWZCRjUyNy5oCmluZGV4IGZjYThkYjcuLmQ2NTc5NDQ5IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2NkZWZCRjUyNy5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvY2RlZkJGNTI3LmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9jZGVmYmY1MjcuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTI3X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvY2RlZkJGNTJ4X2Jhc2UuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvY2RlZkJGNTJ4X2Jhc2UuaAppbmRleCAxZmU3NmQ4Li43MDE0ZGRlIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2NkZWZCRjUyeF9iYXNlLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9jZGVmQkY1MnhfYmFzZS5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MjcvY2RlZkJGNTJ4X2Jhc2UuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2lmbmRlZiBfQ0RFRl9CRjUyWF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2RlZkJGNTIyLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2RlZkJGNTIyLmgKaW5kZXggMGE4Y2RjZC4uY2IxMzlhMiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9kZWZCRjUyMi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZGVmQkY1MjIuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTI3L2RlZkJGNTIyLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaWZuZGVmIF9ERUZfQkY1MjJfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9kZWZCRjUyNS5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9kZWZCRjUyNS5oCmluZGV4IDVjZDc1NzYuLjgyYWJlZmMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZGVmQkY1MjUuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2RlZkJGNTI1LmgKQEAgLTEsMzEgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9kZWZCRjUyNS5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2lmbmRlZiBfREVGX0JGNTI1X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZGVmQkY1MjcuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZGVmQkY1MjcuaAppbmRleCBmMDQwZjM2Li41NzBhMTI1IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2RlZkJGNTI3LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9kZWZCRjUyNy5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MjcvZGVmQkY1MjcuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0RFRl9CRjUyN19ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2RlZkJGNTJ4X2Jhc2UuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZGVmQkY1MnhfYmFzZS5oCmluZGV4IDY4YjU1ZDAuLmY4MjE3MDAgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZGVmQkY1MnhfYmFzZS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZGVmQkY1MnhfYmFzZS5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MjcvZGVmQkY1MnhfYmFzZS5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2lmbmRlZiBfREVGX0JGNTJYX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvZ3Bpby5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9ncGlvLmgKaW5kZXggMDZiNmVlYi4uMTA0YmZmOCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9ncGlvLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9ncGlvLmgKQEAgLTEsNyArMSw0IEBACiAvKgotICogRmlsZTogYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9ncGlvLmgKLSAqIEJ1Z3M6IEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKICAqIENvcHlyaWdodCAoQykgMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvaXJxLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL2lycS5oCmluZGV4IDhlYTY2MGQuLmFhNjU3OWEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbmNsdWRlL21hY2gvaXJxLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9pcnEuaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogZmlsZToJaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUyNy9pcnEuaAotICogYmFzZWQgb246CWluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzcvaXJxLmgKLSAqIGF1dGhvcjoJTWljaGFlbCBIZW5uZXJpY2ggKG1pY2hhZWwuaGVubmVyaWNoQGFuYWxvZy5jb20pCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBjcmVhdGVkOgotICogZGVzY3JpcHRpb246Ci0gKglzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICogcmV2OgotICoKLSAqIG1vZGlmaWVkOgotICoKLSAqCi0gKiBidWdzOiAgICAgICAgIGVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgd2l0aG91dCBhbnkgd2FycmFudHk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogbWVyY2hhbnRhYmlsaXR5IG9yIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlLiAgc2VlIHRoZQotICogZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiB5b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBjb3B5aW5nLgotICogaWYgbm90LCB3cml0ZSB0byB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uLAotICogNTkgdGVtcGxlIHBsYWNlIC0gc3VpdGUgMzMwLCBib3N0b24sIG1hIDAyMTExLTEzMDcsIHVzYS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX0JGNTI3X0lSUV9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2luY2x1ZGUvbWFjaC9wb3J0bXV4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAppbmRleCA3MmIxNjUyLi5kNDUxOGI2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW5jbHVkZS9tYWNoL3BvcnRtdXguaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKKyAqLworCiAjaWZuZGVmIF9NQUNIX1BPUlRNVVhfSF8KICNkZWZpbmUgX01BQ0hfUE9SVE1VWF9IXwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW50cy1wcmlvcml0eS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTI3L2ludHMtcHJpb3JpdHkuYwppbmRleCBmOGM4YWNkLi40NGNhMjE1IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MjcvaW50cy1wcmlvcml0eS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUyNy9pbnRzLXByaW9yaXR5LmMKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2ludHMtcHJpb3JpdHkuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW50cy1wcmlvcml0eS5jCi0gKiBBdXRob3I6ICAgICAgIE1pY2hhZWwgSGVubmVyaWNoIChtaWNoYWVsLmhlbm5lcmljaEBhbmFsb2cuY29tKQorICogU2V0IHVwIHRoZSBpbnRlcnJ1cHQgcHJpb3JpdGllcwogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNldCB1cCB0aGUgaW50ZXJydXB0IHByaW9yaXRpZXMKKyAqIENvcHlyaWdodCAyMDA3LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvYm9hcmRzL0g4NjA2LmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvYm9hcmRzL0g4NjA2LmMKaW5kZXggNmMyYjQ3Zi4uNDNmNDNhMCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9IODYwNi5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvSDg2MDYuYwpAQCAtMSwzMiArMSwxMSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL0g4NjA2LmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL3N0YW1wLmMKLSAqIEF1dGhvcjogICAgICAgSmF2aWVyIEhlcnJlcm8gPGpoZXJyZXJvQGh2c2lzdGVtYXMuZXM+CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAyMDA3LTIwMDggSFYgU2lzdGVtYXMgUy5MLgorICogICAgICAgICAgICAgICAgICAgICAgSmF2aWVyIEhlcnJlcm8gPGpoZXJyZXJvQGh2c2lzdGVtYXMuZXM+CisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOiAgICAgIDIwMDcKLSAqIERlc2NyaXB0aW9uOiAgQm9hcmQgSW5mbyBGaWxlIGZvciB0aGUgSFYgU2lzdGVtYXMgSDg2MDYgYm9hcmQKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jCi0gKgkJIENvcHlyaWdodCAyMDA3LDIwMDggSFYgU2lzdGVtYXMgUy5MLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvYmxhY2tzdGFtcC5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9ibGFja3N0YW1wLmMKaW5kZXggODIwOGQ2Ny4uYjU4MDg4NCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9ibGFja3N0YW1wLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9ibGFja3N0YW1wLmMKQEAgLTEsMTYgKzEsMTAgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ibGFja3N0YW1wLmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL3N0YW1wLmMKLSAqIEF1dGhvcjogICAgICAgQmVuamFtaW4gTWF0dGhld3MgPGJtYXRAbGxlLnJvY2hlc3Rlci5lZHU+Ci0gKiAgICAgICAgICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CisgKiBCb2FyZCBJbmZvIEZpbGUgZm9yIHRoZSBCbGFja1N0YW1wCiAgKgotICogQ3JlYXRlZDogICAgICAyMDA4Ci0gKiBEZXNjcmlwdGlvbjogIEJvYXJkIEluZm8gRmlsZSBmb3IgdGhlIEJsYWNrU3RhbXAKLSAqCi0gKiBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKICAqIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLworICogICAgICAgICAgICAgICAgMjAwOCBCZW5qYW1pbiBNYXR0aGV3cyA8Ym1hdEBsbGUucm9jaGVzdGVyLmVkdT4KKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKICAqIE1vcmUgaW5mbyBhYm91dCB0aGUgQmxhY2tTdGFtcCBhdDoKICAqIAlodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvZ2YvcHJvamVjdC9ibGFja3N0YW1wLwpAQCAtMjgxLDE5ICsyNzUsNiBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fZ3Bpb3NfcmVzb3VyY2VzID0gewotCS5zdGFydCA9IDAsCi0JLmVuZCAgID0gTUFYX0JMQUNLRklOX0dQSU9TIC0gMSwKLQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZ3Bpb3NfZGV2aWNlID0gewotCS5uYW1lID0gInNpbXBsZS1ncGlvIiwKLQkuaWQgPSAtMSwKLQkubnVtX3Jlc291cmNlcyA9IDEsCi0JLnJlc291cmNlID0gJmJmaW5fZ3Bpb3NfcmVzb3VyY2VzLAotfTsKLQogI2lmIGRlZmluZWQoQ09ORklHX0kyQ19HUElPKSB8fCBkZWZpbmVkKENPTkZJR19JMkNfR1BJT19NT0RVTEUpCiAjaW5jbHVkZSA8bGludXgvaTJjLWdwaW8uaD4KIApAQCAtMzg0LDggKzM2NSw2IEBACiAjaWYgZGVmaW5lZChDT05GSUdfSTJDX0dQSU8pIHx8IGRlZmluZWQoQ09ORklHX0kyQ19HUElPX01PRFVMRSkKIAkmaTJjX2dwaW9fZGV2aWNlLAogI2VuZGlmCi0KLQkmYmZpbl9ncGlvc19kZXZpY2UsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCBibGFja3N0YW1wX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvY21fYmY1MzMuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvY21fYmY1MzMuYwppbmRleCA3NDQzYjI2Li43ZmMzYjg2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvYm9hcmRzL2NtX2JmNTMzLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9jbV9iZjUzMy5jCkBAIC0xLDMwICsxLDEwIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvYm9hcmRzL2NtX2JmNTMzLmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9lemtpdC5jCi0gKiBBdXRob3I6ICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+IENvcHlyaWdodCAyMDA1CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAyMDA4LTIwMDkgQmx1ZXRlY2huaXgKKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKLSAqIENyZWF0ZWQ6ICAgICAgMjAwNQotICogRGVzY3JpcHRpb246ICBCb2FyZCBkZXNjcmlwdGlvbiBmaWxlCi0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KQEAgLTI2MSwxOSArMjQxLDYgQEAKIH07CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX2dwaW9zX3Jlc291cmNlcyA9IHsKLQkuc3RhcnQgPSAwLAotCS5lbmQgICA9IE1BWF9CTEFDS0ZJTl9HUElPUyAtIDEsCi0JLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi19OwotCi1zdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBiZmluX2dwaW9zX2RldmljZSA9IHsKLQkubmFtZSA9ICJzaW1wbGUtZ3BpbyIsCi0JLmlkID0gLTEsCi0JLm51bV9yZXNvdXJjZXMgPSAxLAotCS5yZXNvdXJjZSA9ICZiZmluX2dwaW9zX3Jlc291cmNlcywKLX07Ci0KICNpZiBkZWZpbmVkKENPTkZJR19TRVJJQUxfQkZJTikgfHwgZGVmaW5lZChDT05GSUdfU0VSSUFMX0JGSU5fTU9EVUxFKQogc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX3VhcnRfcmVzb3VyY2VzW10gPSB7CiAJewpAQCAtNTA2LDggKzQ3Myw2IEBACiAjaWYgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVApIHx8IGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQX01PRFVMRSkKIAkmcGFyYV9mbGFzaF9kZXZpY2UsCiAjZW5kaWYKLQotCSZiZmluX2dwaW9zX2RldmljZSwKIH07CiAKIHN0YXRpYyBpbnQgX19pbml0IGNtX2JmNTMzX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvZXpraXQuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvZXpraXQuYwppbmRleCBmZDUxOGUzLi5kNDY4OWRjIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvYm9hcmRzL2V6a2l0LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9lemtpdC5jCkBAIC0xLDMxICsxLDkgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9lemtpdC5jCi0gKiBCYXNlZCBvbjogICAgIE9yaWdpbmFsIFdvcmsKLSAqIEF1dGhvcjogICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICAgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKKyAqICAgICAgICAgICAgICAgICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CiAgKgotICogQ3JlYXRlZDogICAgICAyMDA1Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDogICAgIFJvYmluIEdldHogPHJnZXR6QGJsYWNrZmluLnVjbGludXgub3JnPiAtIE5hbWVkIHRoZSBib2FyZHMKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KQEAgLTMzLDEyICsxMSwxNCBAQAogI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KICNpbmNsdWRlIDxsaW51eC9tdGQvcGFydGl0aW9ucy5oPgogI2luY2x1ZGUgPGxpbnV4L210ZC9wbGF0LXJhbS5oPgorI2luY2x1ZGUgPGxpbnV4L210ZC9waHlzbWFwLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpL3NwaS5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaS9mbGFzaC5oPgogI2lmIGRlZmluZWQoQ09ORklHX1VTQl9JU1AxMzYyX0hDRCkgfHwgZGVmaW5lZChDT05GSUdfVVNCX0lTUDEzNjJfSENEX01PRFVMRSkKICNpbmNsdWRlIDxsaW51eC91c2IvaXNwMTM2Mi5oPgogI2VuZGlmCiAjaW5jbHVkZSA8bGludXgvaXJxLmg+CisjaW5jbHVkZSA8bGludXgvaTJjLmg+CiAjaW5jbHVkZSA8YXNtL2RtYS5oPgogI2luY2x1ZGUgPGFzbS9iZmluNXh4X3NwaS5oPgogI2luY2x1ZGUgPGFzbS9wb3J0bXV4Lmg+CkBAIC01NiwxMiArMzYsNiBAQAogfTsKICNlbmRpZgogCi0jaWYgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzKSB8fCBkZWZpbmVkKENPTkZJR19GQl9CRklOXzczOTNfTU9EVUxFKQotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYmZpbl9mYl9hZHY3MzkzX2RldmljZSA9IHsKLQkubmFtZSA9ICJiZmluLWFkdjczOTMiLAotfTsKLSNlbmRpZgotCiAvKgogICogIFVTQi1MQU4gRXpFeHRlbmRlciBib2FyZAogICogIERyaXZlciBuZWVkcyB0byBrbm93IGFkZHJlc3MsIGlycSBhbmQgZmxhZyBwaW4uCkBAIC05OCw1NCArNzIsNjkgQEAKIH07CiAjZW5kaWYKIAotI2lmIGRlZmluZWQoQ09ORklHX01URF9QU0Q0MjU2RykgfHwgZGVmaW5lZChDT05GSUdfTVREX1BTRDQyNTZHX01PRFVMRSkKLXN0YXRpYyBjb25zdCBjaGFyICptYXBfcHJvYmVzW10gPSB7Ci0JInN0bV9mbGFzaCIsCi0JTlVMTCwKKyNpZiBkZWZpbmVkKENPTkZJR19NVERfUEhZU01BUCkgfHwgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVBfTU9EVUxFKQorc3RhdGljIHN0cnVjdCBtdGRfcGFydGl0aW9uIGV6a2l0X3BhcnRpdGlvbnNfYVtdID0geworCXsKKwkJLm5hbWUgICAgICAgPSAiYm9vdGxvYWRlcihub3IgYSkiLAorCQkuc2l6ZSAgICAgICA9IDB4NDAwMDAsCisJCS5vZmZzZXQgICAgID0gMCwKKwl9LCB7CisJCS5uYW1lICAgICAgID0gImxpbnV4IGtlcm5lbChub3IgYSkiLAorCQkuc2l6ZSAgICAgICA9IE1URFBBUlRfU0laX0ZVTEwsCisJCS5vZmZzZXQgICAgID0gTVREUEFSVF9PRlNfQVBQRU5ELAorCX0sCiB9OwogCi1zdGF0aWMgc3RydWN0IHBsYXRkYXRhX210ZF9yYW0gc3RtX3ByaV9kYXRhX2EgPSB7Ci0JLm1hcG5hbWUgICAgPSAiRmxhc2ggQSBQcmltYXJ5IiwKLQkubWFwX3Byb2JlcyA9IG1hcF9wcm9iZXMsCi0JLmJhbmt3aWR0aCAgPSAyLAorc3RhdGljIHN0cnVjdCBwaHlzbWFwX2ZsYXNoX2RhdGEgZXpraXRfZmxhc2hfZGF0YV9hID0geworCS53aWR0aCAgICAgID0gMiwKKwkucGFydHMgICAgICA9IGV6a2l0X3BhcnRpdGlvbnNfYSwKKwkubnJfcGFydHMgICA9IEFSUkFZX1NJWkUoZXpraXRfcGFydGl0aW9uc19hKSwKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2Ugc3RtX3ByaV9yZXNvdXJjZV9hID0geworc3RhdGljIHN0cnVjdCByZXNvdXJjZSBlemtpdF9mbGFzaF9yZXNvdXJjZV9hID0gewogCS5zdGFydCA9IDB4MjAwMDAwMDAsCiAJLmVuZCAgID0gMHgyMDBmZmZmZiwKIAkuZmxhZ3MgPSBJT1JFU09VUkNFX01FTSwKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIHN0bV9wcmlfZGV2aWNlX2EgPSB7Ci0JLm5hbWUgICAgICAgICAgPSAibXRkLXJhbSIsCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBlemtpdF9mbGFzaF9kZXZpY2VfYSA9IHsKKwkubmFtZSAgICAgICAgICA9ICJwaHlzbWFwLWZsYXNoIiwKIAkuaWQgICAgICAgICAgICA9IDAsCiAJLmRldiA9IHsKLQkJLnBsYXRmb3JtX2RhdGEgPSAmc3RtX3ByaV9kYXRhX2EsCisJCS5wbGF0Zm9ybV9kYXRhID0gJmV6a2l0X2ZsYXNoX2RhdGFfYSwKIAl9LAogCS5udW1fcmVzb3VyY2VzID0gMSwKLQkucmVzb3VyY2UgICAgICA9ICZzdG1fcHJpX3Jlc291cmNlX2EsCisJLnJlc291cmNlICAgICAgPSAmZXpraXRfZmxhc2hfcmVzb3VyY2VfYSwKIH07CiAKLXN0YXRpYyBzdHJ1Y3QgcGxhdGRhdGFfbXRkX3JhbSBzdG1fcHJpX2RhdGFfYiA9IHsKLQkubWFwbmFtZSAgICA9ICJGbGFzaCBCIFByaW1hcnkiLAotCS5tYXBfcHJvYmVzID0gbWFwX3Byb2JlcywKLQkuYmFua3dpZHRoICA9IDIsCitzdGF0aWMgc3RydWN0IG10ZF9wYXJ0aXRpb24gZXpraXRfcGFydGl0aW9uc19iW10gPSB7CisJeworCQkubmFtZSAgID0gImZpbGUgc3lzdGVtKG5vciBiKSIsCisJCS5zaXplICAgPSBNVERQQVJUX1NJWl9GVUxMLAorCQkub2Zmc2V0ID0gTVREUEFSVF9PRlNfQVBQRU5ELAorCX0sCiB9OwogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIHN0bV9wcmlfcmVzb3VyY2VfYiA9IHsKK3N0YXRpYyBzdHJ1Y3QgcGh5c21hcF9mbGFzaF9kYXRhIGV6a2l0X2ZsYXNoX2RhdGFfYiA9IHsKKwkud2lkdGggICAgICA9IDIsCisJLnBhcnRzICAgICAgPSBlemtpdF9wYXJ0aXRpb25zX2IsCisJLm5yX3BhcnRzICAgPSBBUlJBWV9TSVpFKGV6a2l0X3BhcnRpdGlvbnNfYiksCit9OworCitzdGF0aWMgc3RydWN0IHJlc291cmNlIGV6a2l0X2ZsYXNoX3Jlc291cmNlX2IgPSB7CiAJLnN0YXJ0ID0gMHgyMDEwMDAwMCwKIAkuZW5kICAgPSAweDIwMWZmZmZmLAogCS5mbGFncyA9IElPUkVTT1VSQ0VfTUVNLAogfTsKIAotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2Ugc3RtX3ByaV9kZXZpY2VfYiA9IHsKLQkubmFtZSAgICAgICAgICA9ICJtdGQtcmFtIiwKK3N0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGV6a2l0X2ZsYXNoX2RldmljZV9iID0geworCS5uYW1lICAgICAgICAgID0gInBoeXNtYXAtZmxhc2giLAogCS5pZCAgICAgICAgICAgID0gNCwKIAkuZGV2ID0gewotCQkucGxhdGZvcm1fZGF0YSA9ICZzdG1fcHJpX2RhdGFfYiwKKwkJLnBsYXRmb3JtX2RhdGEgPSAmZXpraXRfZmxhc2hfZGF0YV9iLAogCX0sCiAJLm51bV9yZXNvdXJjZXMgPSAxLAotCS5yZXNvdXJjZSAgICAgID0gJnN0bV9wcmlfcmVzb3VyY2VfYiwKKwkucmVzb3VyY2UgICAgICA9ICZlemtpdF9mbGFzaF9yZXNvdXJjZV9iLAogfTsKICNlbmRpZgogCkBAIC00MDAsMTkgKzM4OSw2IEBACiB9OwogI2VuZGlmCiAKLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYmZpbl9ncGlvc19yZXNvdXJjZXMgPSB7Ci0JLnN0YXJ0ID0gMCwKLQkuZW5kICAgPSBNQVhfQkxBQ0tGSU5fR1BJT1MgLSAxLAotCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAotfTsKLQotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYmZpbl9ncGlvc19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAic2ltcGxlLWdwaW8iLAotCS5pZCA9IC0xLAotCS5udW1fcmVzb3VyY2VzID0gMSwKLQkucmVzb3VyY2UgPSAmYmZpbl9ncGlvc19yZXNvdXJjZXMsCi19OwotCiAjaWYgZGVmaW5lZChDT05GSUdfSTJDX0dQSU8pIHx8IGRlZmluZWQoQ09ORklHX0kyQ19HUElPX01PRFVMRSkKICNpbmNsdWRlIDxsaW51eC9pMmMtZ3Bpby5oPgogCkBAIC00NjAsMTMgKzQzNiwyMSBAQAogCX0sCiB9OwogCitzdGF0aWMgc3RydWN0IGkyY19ib2FyZF9pbmZvIF9faW5pdGRhdGEgYmZpbl9pMmNfYm9hcmRfaW5mb1tdID0geworI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKKwl7CisJCUkyQ19CT0FSRF9JTkZPKCJiZmluLWFkdjczOTMiLCAweDJCKSwKKwl9LAorI2VuZGlmCit9OworCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZXpraXRfZGV2aWNlc1tdIF9faW5pdGRhdGEgPSB7CiAKIAkmYmZpbl9kcG1jLAogCi0jaWYgZGVmaW5lZChDT05GSUdfTVREX1BTRDQyNTZHKSB8fCBkZWZpbmVkKENPTkZJR19NVERfUFNENDI1NkdfTU9EVUxFKQotCSZzdG1fcHJpX2RldmljZV9hLAotCSZzdG1fcHJpX2RldmljZV9iLAorI2lmIGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQKSB8fCBkZWZpbmVkKENPTkZJR19NVERfUEhZU01BUF9NT0RVTEUpCisJJmV6a2l0X2ZsYXNoX2RldmljZV9hLAorCSZlemtpdF9mbGFzaF9kZXZpY2VfYiwKICNlbmRpZgogCiAjaWYgZGVmaW5lZChDT05GSUdfTVREX1BMQVRSQU0pIHx8IGRlZmluZWQoQ09ORklHX01URF9QTEFUUkFNX01PRFVMRSkKQEAgLTQ4MiwxMCArNDY2LDYgQEAKIAkmYmZpbl9zcGkwX2RldmljZSwKICNlbmRpZgogCi0jaWYgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzKSB8fCBkZWZpbmVkKENPTkZJR19GQl9CRklOXzczOTNfTU9EVUxFKQotCSZiZmluX2ZiX2FkdjczOTNfZGV2aWNlLAotI2VuZGlmCi0KICNpZiBkZWZpbmVkKENPTkZJR19SVENfRFJWX0JGSU4pIHx8IGRlZmluZWQoQ09ORklHX1JUQ19EUlZfQkZJTl9NT0RVTEUpCiAJJnJ0Y19kZXZpY2UsCiAjZW5kaWYKQEAgLTUwNyw4ICs0ODcsNiBAQAogI2lmIGRlZmluZWQoQ09ORklHX0kyQ19HUElPKSB8fCBkZWZpbmVkKENPTkZJR19JMkNfR1BJT19NT0RVTEUpCiAJJmkyY19ncGlvX2RldmljZSwKICNlbmRpZgotCi0JJmJmaW5fZ3Bpb3NfZGV2aWNlLAogfTsKIAogc3RhdGljIGludCBfX2luaXQgZXpraXRfaW5pdCh2b2lkKQpAQCAtNTE2LDYgKzQ5NCw4IEBACiAJcHJpbnRrKEtFUk5fSU5GTyAiJXMoKTogcmVnaXN0ZXJpbmcgZGV2aWNlIHJlc291cmNlc1xuIiwgX19mdW5jX18pOwogCXBsYXRmb3JtX2FkZF9kZXZpY2VzKGV6a2l0X2RldmljZXMsIEFSUkFZX1NJWkUoZXpraXRfZGV2aWNlcykpOwogCXNwaV9yZWdpc3Rlcl9ib2FyZF9pbmZvKGJmaW5fc3BpX2JvYXJkX2luZm8sIEFSUkFZX1NJWkUoYmZpbl9zcGlfYm9hcmRfaW5mbykpOworCWkyY19yZWdpc3Rlcl9ib2FyZF9pbmZvKDAsIGJmaW5faTJjX2JvYXJkX2luZm8sCisJCQkJQVJSQVlfU0laRShiZmluX2kyY19ib2FyZF9pbmZvKSk7CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvaXAweC5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9pcDB4LmMKaW5kZXggZjE5YjYzMzcuLjY0NGJlNWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvaXAweC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvaXAweC5jCkBAIC0xLDM0ICsxLDEyIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaXAweC5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9iZjEuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvc3RhbXAuYwotICogQXV0aG9yOiAgICAgICBJdmFuIERhbm92IDxpZGFub3ZAZ21haWwuY29tPgotICogICAgICAgICAgICAgICBNb2RpZmllZCBmb3IgSVAwWCBEYXZpZCBSb3dlCisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgIDIwMDcgRGF2aWQgUm93ZQorICogICAgICAgICAgICAgICAgMjAwNiBJbnRyYXRyYWRlIEx0ZC4KKyAqICAgICAgICAgICAgICAgICAgICAgSXZhbiBEYW5vdiA8aWRhbm92QGdtYWlsLmNvbT4KKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CiAgKgotICogQ3JlYXRlZDogICAgICAyMDA3Ci0gKiBEZXNjcmlwdGlvbjogIEJvYXJkIGluZm8gZmlsZSBmb3IgdGhlIElQMDQvSVAwOCBib2FyZHMsIHdoaWNoCi0gKiAgICAgICAgICAgICAgIGFyZSBkZXJpdmVkIGZyb20gdGhlIEJsYWNrZmluT25lIFYyLjAgYm9hcmRzLgotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDT3B5cmlnaHQgMjAwNyBEYXZpZCBSb3dlCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA2IEludHJhdHJhZGUgTHRkLgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KQEAgLTE0NSw3ICsxMjMsNiBAQAogCS5jdGxfcmVnID0gMHgxMDAwLAkJLyogQ1BPTD0wLENQSEE9MCxTYW5kaXNrIDFHIHdvcmsgKi8KIAkuZW5hYmxlX2RtYSA9IDAsCQkvKiBpZiAxIC0gYmxvY2shISEgKi8KIAkuYml0c19wZXJfd29yZCA9IDgsCi0JLmNzX2NoYW5nZV9wZXJfd29yZCA9IDAsCiB9OwogI2VuZGlmCiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvc3RhbXAuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvc3RhbXAuYwppbmRleCA3MjlmZDdjLi44MmY3MGVmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvYm9hcmRzL3N0YW1wLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9zdGFtcC5jCkBAIC0xLDMxICsxLDkgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9zdGFtcC5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9lemtpdC5jCi0gKiBBdXRob3I6ICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKLSAqIENyZWF0ZWQ6ICAgICAgMjAwNQotICogRGVzY3JpcHRpb246ICBCb2FyZCBJbmZvIEZpbGUgZm9yIHRoZSBCRjUzMy1TVEFNUAotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgpAQCAtOTUsMTIgKzczLDYgQEAKIH07CiAjZW5kaWYKIAotI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZmJfYWR2NzM5M19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAiYmZpbi1hZHY3MzkzIiwKLX07Ci0jZW5kaWYKLQogI2lmIGRlZmluZWQoQ09ORklHX1VTQl9ORVQyMjcyKSB8fCBkZWZpbmVkKENPTkZJR19VU0JfTkVUMjI3Ml9NT0RVTEUpCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIG5ldDIyNzJfYmZpbl9yZXNvdXJjZXNbXSA9IHsKIAl7CkBAIC00MzYsMTkgKzQwOCw2IEBACiB9OwogI2VuZGlmCiAKLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYmZpbl9ncGlvc19yZXNvdXJjZXMgPSB7Ci0JLnN0YXJ0ID0gMCwKLQkuZW5kICAgPSBNQVhfQkxBQ0tGSU5fR1BJT1MgLSAxLAotCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAotfTsKLQotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYmZpbl9ncGlvc19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAic2ltcGxlLWdwaW8iLAotCS5pZCA9IC0xLAotCS5udW1fcmVzb3VyY2VzID0gMSwKLQkucmVzb3VyY2UgPSAmYmZpbl9ncGlvc19yZXNvdXJjZXMsCi19OwotCiAjaWYgZGVmaW5lZChDT05GSUdfSTJDX0dQSU8pIHx8IGRlZmluZWQoQ09ORklHX0kyQ19HUElPX01PRFVMRSkKICNpbmNsdWRlIDxsaW51eC9pMmMtZ3Bpby5oPgogCkBAIC00ODcsNiArNDQ2LDExIEBACiAJCS5pcnEgPSAzOSwKIAl9LAogI2VuZGlmCisjaWYgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzKSB8fCBkZWZpbmVkKENPTkZJR19GQl9CRklOXzczOTNfTU9EVUxFKQorCXsKKwkJSTJDX0JPQVJEX0lORk8oImJmaW4tYWR2NzM5MyIsIDB4MkIpLAorCX0sCisjZW5kaWYKIH07CiAKIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgY2Nsa192bGV2X2RhdGFzaGVldFtdID0KQEAgLTUyOCwxMCArNDkyLDYgQEAKIAkmc21jOTF4X2RldmljZSwKICNlbmRpZgogCi0jaWYgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzKSB8fCBkZWZpbmVkKENPTkZJR19GQl9CRklOXzczOTNfTU9EVUxFKQotCSZiZmluX2ZiX2FkdjczOTNfZGV2aWNlLAotI2VuZGlmCi0KICNpZiBkZWZpbmVkKENPTkZJR19VU0JfTkVUMjI3MikgfHwgZGVmaW5lZChDT05GSUdfVVNCX05FVDIyNzJfTU9EVUxFKQogCSZuZXQyMjcyX2JmaW5fZGV2aWNlLAogI2VuZGlmCkBAIC01NjMsOCArNTIzLDYgQEAKIAkmaTJjX2dwaW9fZGV2aWNlLAogI2VuZGlmCiAKLQkmYmZpbl9ncGlvc19kZXZpY2UsCi0KICNpZiBkZWZpbmVkKENPTkZJR19NVERfQkZJTl9BU1lOQykgfHwgZGVmaW5lZChDT05GSUdfTVREX0JGSU5fQVNZTkNfTU9EVUxFKQogCSZzdGFtcF9mbGFzaF9kZXZpY2UsCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9kbWEuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9kbWEuYwppbmRleCA3YTQ0M2MzLi40YTE0YTQ2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvZG1hLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2RtYS5jCkBAIC0xLDMxICsxLDExIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvZG1hLmMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogc2ltcGxlIERNQSBJbXBsZW1lbnRhdGlvbiBmb3IgQmxhY2tmaW4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBUaGlzIGZpbGUgY29udGFpbnMgdGhlIHNpbXBsZSBETUEgSW1wbGVtZW50YXRpb24gZm9yIEJsYWNrZmluCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KKwogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogCiAjaW5jbHVkZSA8YXNtL2JsYWNrZmluLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2JmNTMzLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2JmNTMzLmgKaW5kZXggY2Y0NDI3Yy4uZTNlMDVmOCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9iZjUzMy5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvYmY1MzMuaApAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTMzL2JmNTMzLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogU1lTVEVNIE1NUiBSRUdJU1RFUiBBTkQgTUVNT1JZIE1BUCBGT1IgQURTUC1CRjU2MQogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNZU1RFTSBNTVIgUkVHSVNURVIgQU5EIE1FTU9SWSBNQVAgRk9SIEFEU1AtQkY1NjEKKyAqIENvcHlyaWdodCAyMDA1LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9fTUFDSF9CRjUzM19IX18KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oCmluZGV4IDY5NjViNDAuLjllMWYzZGUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9iZmluX3NlcmlhbF81eHguaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogZmlsZTogICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzMvYmZpbl9zZXJpYWxfNXh4LmgKLSAqIGJhc2VkIG9uOgotICogYXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDYtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogY3JlYXRlZDoKLSAqIGRlc2NyaXB0aW9uOgotICoJYmxhY2tmaW4gc2VyaWFsIGRyaXZlciBoZWFkIGZpbGUKLSAqIHJldjoKLSAqCi0gKiBtb2RpZmllZDoKLSAqCi0gKgotICogYnVnczogICAgICAgICBlbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiB0aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBmcmVlIHNvZnR3YXJlIGZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IHdpdGhvdXQgYW55IHdhcnJhbnR5OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIG1lcmNoYW50YWJpbGl0eSBvciBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZS4gIHNlZSB0aGUKLSAqIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogeW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgY29weWluZy4KLSAqIGlmIG5vdCwgd3JpdGUgdG8gdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbiwKLSAqIDU5IHRlbXBsZSBwbGFjZSAtIHN1aXRlIDMzMCwgYm9zdG9uLCBtYSAwMjExMS0xMzA3LCB1c2EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvc2VyaWFsLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmgKaW5kZXggNDk5ZTg5Ny4uZjRiZDZkZiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTMzL2JsYWNrZmluLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDUtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX01BQ0hfQkxBQ0tGSU5fSF8KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvY2RlZkJGNTMyLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2NkZWZCRjUzMi5oCmluZGV4IGJiYzNjODMuLmZlYjIzOTIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvY2RlZkJGNTMyLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9jZGVmQkY1MzIuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTMzL2NkZWZCRjUzMi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA1LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTMyX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvZGVmQkY1MzIuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvZGVmQkY1MzIuaAppbmRleCA3ZjQ2MzMyLi4wMmIzMjhlIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2RlZkJGNTMyLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9kZWZCRjUzMi5oCkBAIC0xLDQ4ICsxLDEwIEBACi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0gKgotICogVGhpcyBmaWxlIGlzIHN1YmplY3QgdG8gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgUHVibGljCi0gKiBMaWNlbnNlLiBTZWUgdGhlIGZpbGUgIkNPUFlJTkciIGluIHRoZSBtYWluIGRpcmVjdG9yeSBvZiB0aGlzIGFyY2hpdmUKLSAqIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogTm9uLUdQTCBMaWNlbnNlIGFsc28gYXZhaWxhYmxlIGFzIHBhcnQgb2YgVmlzdWFsRFNQKysKLSAqIGh0dHA6Ly93d3cuYW5hbG9nLmNvbS9wcm9jZXNzb3JzL3Jlc291cmNlcy9jcm9zc2NvcmUvdmlzdWFsRHNwRGV2U29mdHdhcmUuaHRtbAotICoKLSAqIChjKSBDb3B5cmlnaHQgMjAwMS0yMDA1IEFuYWxvZyBEZXZpY2VzLCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQKLSAqCi0gKiBUaGlzIGZpbGUgdW5kZXIgc291cmNlIGNvZGUgY29udHJvbCwgcGxlYXNlIHNlbmQgYnVncyBvciBjaGFuZ2VzIHRvOgotICogZHNwdG9vbHMuc3VwcG9ydEBhbmFsb2cuY29tCi0gKgotICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzMvZGVmQkY1MzIuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBTeXN0ZW0gJiBNTVIgYml0IGFuZCBBZGRyZXNzIGRlZmluaXRpb25zIGZvciBBRFNQLUJGNTMyCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgorICogQ29weXJpZ2h0IDIwMDUtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCi0vKiBTWVNURU0gJiBNTSBSRUdJU1RFUiBCSVQgJiBBRERSRVNTIERFRklOSVRJT05TIEZPUiBBRFNQLUJGNTMyICovCiAKICNpZm5kZWYgX0RFRl9CRjUzMl9ICiAjZGVmaW5lIF9ERUZfQkY1MzJfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9ncGlvLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2dwaW8uaAppbmRleCBlNDVjMTcwLi4yYWYxOWQ2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2dwaW8uaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2dwaW8uaApAQCAtMSw3ICsxLDQgQEAKIC8qCi0gKiBGaWxlOiBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2dwaW8uaAotICogQnVnczogRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgogICogQ29weXJpZ2h0IChDKSAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9pcnEuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvaXJxLmgKaW5kZXggZGIxZTM0Ni4uYzMxNDk4YiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2luY2x1ZGUvbWFjaC9pcnEuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL2lycS5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzMvZGVmQkY1MzIuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNS0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyCiAgKi8KIAogI2lmbmRlZiBfQkY1MzNfSVJRX0hfCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW5jbHVkZS9tYWNoL3BvcnRtdXguaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvcG9ydG11eC5oCmluZGV4IDJmNTljZTAuLjA3NWRhZTEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvcG9ydG11eC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbmNsdWRlL21hY2gvcG9ydG11eC5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgorICovCisKICNpZm5kZWYgX01BQ0hfUE9SVE1VWF9IXwogI2RlZmluZSBfTUFDSF9QT1JUTVVYX0hfCiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbnRzLXByaW9yaXR5LmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW50cy1wcmlvcml0eS5jCmluZGV4IGY1MTk5NGIuLjhmNzE0Y2YgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbnRzLXByaW9yaXR5LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2ludHMtcHJpb3JpdHkuYwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW50cy1wcmlvcml0eS5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjogICAgICAgTWljaGFlbCBIZW5uZXJpY2gKKyAqIFNldCB1cCB0aGUgaW50ZXJydXB0IHByaW9yaXRpZXMKICAqCi0gKiBDcmVhdGVkOiAgICAgID8KLSAqIERlc2NyaXB0aW9uOiAgU2V0IHVwIHRoZSBpbnRlcnJ1cHQgcHJpb3JpdGllcworICogQ29weXJpZ2h0IDIwMDUtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvY21fYmY1MzdlLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL2NtX2JmNTM3ZS5jCmluZGV4IDg3YWNiN2QuLmM4NWY0ZDcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvY21fYmY1MzdlLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9jbV9iZjUzN2UuYwpAQCAtMSwzMSArMSwxMCBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9jbV9iZjUzNy5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvZXpraXQuYwotICogQXV0aG9yOiAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgMjAwOC0yMDA5IEJsdWV0ZWNobml4CisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOiAgICAgIDIwMDUKLSAqIERlc2NyaXB0aW9uOiAgQm9hcmQgZGVzY3JpcHRpb24gZmlsZQotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgpAQCAtMjk3LDE5ICsyNzYsNiBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fZ3Bpb3NfcmVzb3VyY2VzID0gewotCS5zdGFydCA9IDAsCi0JLmVuZCAgID0gTUFYX0JMQUNLRklOX0dQSU9TIC0gMSwKLQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZ3Bpb3NfZGV2aWNlID0gewotCS5uYW1lID0gInNpbXBsZS1ncGlvIiwKLQkuaWQgPSAtMSwKLQkubnVtX3Jlc291cmNlcyA9IDEsCi0JLnJlc291cmNlID0gJmJmaW5fZ3Bpb3NfcmVzb3VyY2VzLAotfTsKLQogI2lmIGRlZmluZWQoQ09ORklHX01URF9HUElPX0FERFIpIHx8IGRlZmluZWQoQ09ORklHX01URF9HUElPX0FERFJfTU9EVUxFKQogc3RhdGljIHN0cnVjdCBtdGRfcGFydGl0aW9uIGNtX3BhcnRpdGlvbnNbXSA9IHsKIAl7CkBAIC02OTksOCArNjY1LDYgQEAKICNpZiBkZWZpbmVkKENPTkZJR19NVERfR1BJT19BRERSKSB8fCBkZWZpbmVkKENPTkZJR19NVERfR1BJT19BRERSX01PRFVMRSkKIAkmY21fZmxhc2hfZGV2aWNlLAogI2VuZGlmCi0KLQkmYmZpbl9ncGlvc19kZXZpY2UsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCBjbV9iZjUzN2VfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9jbV9iZjUzN3UuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvY21fYmY1Mzd1LmMKaW5kZXggODIxOWRjMy4uZWExMWFhOCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9jbV9iZjUzN3UuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL2NtX2JmNTM3dS5jCkBAIC0xLDMxICsxLDEwIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL2NtX2JmNTM3dS5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvZXpraXQuYwotICogQXV0aG9yOiAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgMjAwOC0yMDA5IEJsdWV0ZWNobml4CisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOiAgICAgIDIwMDUKLSAqIERlc2NyaXB0aW9uOiAgQm9hcmQgZGVzY3JpcHRpb24gZmlsZQotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgpAQCAtMjk4LDE5ICsyNzcsNiBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fZ3Bpb3NfcmVzb3VyY2VzID0gewotCS5zdGFydCA9IDAsCi0JLmVuZCAgID0gTUFYX0JMQUNLRklOX0dQSU9TIC0gMSwKLQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZ3Bpb3NfZGV2aWNlID0gewotCS5uYW1lID0gInNpbXBsZS1ncGlvIiwKLQkuaWQgPSAtMSwKLQkubnVtX3Jlc291cmNlcyA9IDEsCi0JLnJlc291cmNlID0gJmJmaW5fZ3Bpb3NfcmVzb3VyY2VzLAotfTsKLQogI2lmIGRlZmluZWQoQ09ORklHX01URF9HUElPX0FERFIpIHx8IGRlZmluZWQoQ09ORklHX01URF9HUElPX0FERFJfTU9EVUxFKQogc3RhdGljIHN0cnVjdCBtdGRfcGFydGl0aW9uIGNtX3BhcnRpdGlvbnNbXSA9IHsKIAl7CkBAIC02MDUsOCArNTcxLDYgQEAKICNpZiBkZWZpbmVkKENPTkZJR19NVERfR1BJT19BRERSKSB8fCBkZWZpbmVkKENPTkZJR19NVERfR1BJT19BRERSX01PRFVMRSkKIAkmY21fZmxhc2hfZGV2aWNlLAogI2VuZGlmCi0KLQkmYmZpbl9ncGlvc19kZXZpY2UsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCBjbV9iZjUzN3VfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9taW5vdGF1ci5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9taW5vdGF1ci5jCmluZGV4IDM5OWY4MWQuLjBkYTkyNzIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvbWlub3RhdXIuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL21pbm90YXVyLmMKQEAgLTEsNCArMSwxMCBAQAogLyoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgIDIwMDgtMjAwOSBDYW1icmlkZ2UgU2lnbmFsIFByb2Nlc3NpbmcKKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3BuYXYxMC5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9wbmF2MTAuYwppbmRleCAxMGIzNWI4Li45YmEyOTA0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3BuYXYxMC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvcG5hdjEwLmMKQEAgLTEsMzEgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9zdGFtcC5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvZXpraXQuYwotICogQXV0aG9yOiAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CkBAIC0zMDIsNyArMjgwLDYgQEAKIAogI2lmIGRlZmluZWQoQ09ORklHX1RPVUNIU0NSRUVOX0FENzg3NykgfHwgZGVmaW5lZChDT05GSUdfVE9VQ0hTQ1JFRU5fQUQ3ODc3X01PRFVMRSkKIHN0YXRpYyBzdHJ1Y3QgYmZpbjV4eF9zcGlfY2hpcCBzcGlfYWQ3ODc3X2NoaXBfaW5mbyA9IHsKLQkuY3NfY2hhbmdlX3Blcl93b3JkID0gMCwKIAkuZW5hYmxlX2RtYSA9IDAsCiAJLmJpdHNfcGVyX3dvcmQgPSAxNiwKIH07CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3N0YW1wLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3N0YW1wLmMKaW5kZXggOWRiNmI0MC4uYzQ2YmFhNSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9zdGFtcC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvc3RhbXAuYwpAQCAtMSwzMSArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3N0YW1wLmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2JvYXJkcy9lemtpdC5jCi0gKiBBdXRob3I6ICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KQEAgLTEyMSwxOSArOTksNiBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fZ3Bpb3NfcmVzb3VyY2VzID0gewotCS5zdGFydCA9IDAsCi0JLmVuZCAgID0gTUFYX0JMQUNLRklOX0dQSU9TIC0gMSwKLQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZ3Bpb3NfZGV2aWNlID0gewotCS5uYW1lID0gInNpbXBsZS1ncGlvIiwKLQkuaWQgPSAtMSwKLQkubnVtX3Jlc291cmNlcyA9IDEsCi0JLnJlc291cmNlID0gJmJmaW5fZ3Bpb3NfcmVzb3VyY2VzLAotfTsKLQogI2lmIGRlZmluZWQoQ09ORklHX0JGSU5fQ0ZQQ01DSUEpIHx8IGRlZmluZWQoQ09ORklHX0JGSU5fQ0ZQQ01DSUFfTU9EVUxFKQogc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX3BjbWNpYV9jZl9yZXNvdXJjZXNbXSA9IHsKIAl7CkBAIC0xMDc4LDEyICsxMDQzLDYgQEAKIH07CiAjZW5kaWYKIAotI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5MykgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzX01PRFVMRSkKLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZmJfYWR2NzM5M19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAiYmZpbi1hZHY3MzkzIiwKLX07Ci0jZW5kaWYKLQogI2lmIGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fTFEwMzVRMSkgfHwgZGVmaW5lZChDT05GSUdfRkJfQkZJTl9MUTAzNVExX01PRFVMRSkKICNpbmNsdWRlIDxhc20vYmZpbi1scTAzNXExLmg+CiAKQEAgLTE0OTgsNiArMTQ1NywxMSBAQAogCQkucGxhdGZvcm1fZGF0YSA9ICh2b2lkICopJmFkcDU1ODhfZ3Bpb19kYXRhLAogCX0sCiAjZW5kaWYKKyNpZiBkZWZpbmVkKENPTkZJR19GQl9CRklOXzczOTMpIHx8IGRlZmluZWQoQ09ORklHX0ZCX0JGSU5fNzM5M19NT0RVTEUpCisJeworCQlJMkNfQk9BUkRfSU5GTygiYmZpbi1hZHY3MzkzIiwgMHgyQiksCisJfSwKKyNlbmRpZgogfTsKIAogI2lmIGRlZmluZWQoQ09ORklHX1NFUklBTF9CRklOX1NQT1JUKSB8fCBkZWZpbmVkKENPTkZJR19TRVJJQUxfQkZJTl9TUE9SVF9NT0RVTEUpCkBAIC0xNjY4LDEwICsxNjMyLDYgQEAKIAkmYmZpbl9scTAzNXExX2RldmljZSwKICNlbmRpZgogCi0jaWYgZGVmaW5lZChDT05GSUdfRkJfQkZJTl83MzkzKSB8fCBkZWZpbmVkKENPTkZJR19GQl9CRklOXzczOTNfTU9EVUxFKQotCSZiZmluX2ZiX2FkdjczOTNfZGV2aWNlLAotI2VuZGlmCi0KICNpZiBkZWZpbmVkKENPTkZJR19TRVJJQUxfQkZJTikgfHwgZGVmaW5lZChDT05GSUdfU0VSSUFMX0JGSU5fTU9EVUxFKQogCSZiZmluX3VhcnRfZGV2aWNlLAogI2VuZGlmCkBAIC0xNzAyLDggKzE2NjIsNiBAQAogCSZiZmluX2RldmljZV9ncGlva2V5cywKICNlbmRpZgogCi0JJmJmaW5fZ3Bpb3NfZGV2aWNlLAotCiAjaWYgZGVmaW5lZChDT05GSUdfTVREX05BTkRfUExBVEZPUk0pIHx8IGRlZmluZWQoQ09ORklHX01URF9OQU5EX1BMQVRGT1JNX01PRFVMRSkKIAkmYmZpbl9hc3luY19uYW5kX2RldmljZSwKICNlbmRpZgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy90Y21fYmY1MzcuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvdGNtX2JmNTM3LmMKaW5kZXggNjEzNTNmNy4uNTcxNjNiNiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy90Y21fYmY1MzcuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3RjbV9iZjUzNy5jCkBAIC0xLDMxICsxLDEwIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL3RjbV9iZjUzNy5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvY21fYmY1MzcuYwotICogQXV0aG9yOiAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgMjAwOC0yMDA5IEJsdWV0ZWNobml4CisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOiAgICAgIDIwMDUKLSAqIERlc2NyaXB0aW9uOiAgQm9hcmQgZGVzY3JpcHRpb24gZmlsZQotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgpAQCAtMjk4LDE5ICsyNzcsNiBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fZ3Bpb3NfcmVzb3VyY2VzID0gewotCS5zdGFydCA9IDAsCi0JLmVuZCAgID0gTUFYX0JMQUNLRklOX0dQSU9TIC0gMSwKLQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZ3Bpb3NfZGV2aWNlID0gewotCS5uYW1lID0gInNpbXBsZS1ncGlvIiwKLQkuaWQgPSAtMSwKLQkubnVtX3Jlc291cmNlcyA9IDEsCi0JLnJlc291cmNlID0gJmJmaW5fZ3Bpb3NfcmVzb3VyY2VzLAotfTsKLQogI2lmIGRlZmluZWQoQ09ORklHX01URF9HUElPX0FERFIpIHx8IGRlZmluZWQoQ09ORklHX01URF9HUElPX0FERFJfTU9EVUxFKQogc3RhdGljIHN0cnVjdCBtdGRfcGFydGl0aW9uIGNtX3BhcnRpdGlvbnNbXSA9IHsKIAl7CkBAIC02MDcsOCArNTczLDYgQEAKICNpZiBkZWZpbmVkKENPTkZJR19NVERfR1BJT19BRERSKSB8fCBkZWZpbmVkKENPTkZJR19NVERfR1BJT19BRERSX01PRFVMRSkKIAkmY21fZmxhc2hfZGV2aWNlLAogI2VuZGlmCi0KLQkmYmZpbl9ncGlvc19kZXZpY2UsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCB0Y21fYmY1MzdfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2RtYS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2RtYS5jCmluZGV4IGQyM2ZjMGUuLjVjOGM0ZWQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9kbWEuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvZG1hLmMKQEAgLTEsMzEgKzEsMTEgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9kbWEuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBUaGlzIGZpbGUgY29udGFpbnMgdGhlIHNpbXBsZSBETUEgSW1wbGVtZW50YXRpb24gZm9yIEJsYWNrZmluCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDcgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogVGhpcyBmaWxlIGNvbnRhaW5zIHRoZSBzaW1wbGUgRE1BIEltcGxlbWVudGF0aW9uIGZvciBCbGFja2ZpbgogICovCisKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KIAogI2luY2x1ZGUgPGFzbS9ibGFja2Zpbi5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9iZjUzNy5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9iZjUzNy5oCmluZGV4IGYxOTRhODQuLjE3ZmFiNDQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvYmY1MzcuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2JmNTM3LmgKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzNy9iZjUzNy5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIFN5c3RlbSBNTVIgUmVnaXN0ZXIgYW5kIG1lbW9yeSBtYXAgZm9yIEFEU1AtQkY1MzcKICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBTWVNURU0gTU1SIFJFR0lTVEVSIEFORCBNRU1PUlkgTUFQIEZPUiBBRFNQLUJGNTM3CisgKiBDb3B5cmlnaHQgMjAwNS0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfX01BQ0hfQkY1MzdfSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9iZmluX3NlcmlhbF81eHguaAppbmRleCBlOTVkNTRmLi42MzVjOTFjIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIGZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzNy9iZmluX3NlcmlhbF81eHguaAotICogYmFzZWQgb246Ci0gKiBhdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNi0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBjcmVhdGVkOgotICogZGVzY3JpcHRpb246Ci0gKglibGFja2ZpbiBzZXJpYWwgZHJpdmVyIGhlYWRlciBmaWxlcwotICogcmV2OgotICoKLSAqIG1vZGlmaWVkOgotICoKLSAqCi0gKiBidWdzOiAgICAgICAgIGVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgd2l0aG91dCBhbnkgd2FycmFudHk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogbWVyY2hhbnRhYmlsaXR5IG9yIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlLiAgc2VlIHRoZQotICogZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiB5b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBjb3B5aW5nLgotICogaWYgbm90LCB3cml0ZSB0byB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uLAotICogNTkgdGVtcGxlIHBsYWNlIC0gc3VpdGUgMzMwLCBib3N0b24sIG1hIDAyMTExLTEzMDcsIHVzYS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpbmNsdWRlIDxsaW51eC9zZXJpYWwuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaAppbmRleCA5ZWU4ODM0Li5lYWIwMDZkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oCkBAIC0xLDMyICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzcvYmxhY2tmaW4uaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX01BQ0hfQkxBQ0tGSU5fSF8KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvY2RlZkJGNTM0LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2NkZWZCRjUzNC5oCmluZGV4IDVmOGI1ZjguLjkxODI1YzkgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvY2RlZkJGNTM0LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9jZGVmQkY1MzQuaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTM3L2NkZWZiZjUzNC5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA1LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIHN5c3RlbSBtbXIgcmVnaXN0ZXIgbWFwCi0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX0NERUZfQkY1MzRfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9jZGVmQkY1MzcuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvY2RlZkJGNTM3LmgKaW5kZXggYjhmYzk0OS4uOTM2M2MzOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9jZGVmQkY1MzcuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2NkZWZCRjUzNy5oCkBAIC0xLDMyICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzcvY2RlZkJGNTM3LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDUtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoJU3lzdGVtIE1NUiBSZWdpc3RlciBNYXAKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTM3X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvZGVmQkY1MzQuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvZGVmQkY1MzQuaAppbmRleCBhMzIyN2Y5Li5jZWJiMTRmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2RlZkJGNTM0LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9kZWZCRjUzNC5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzcvY2RlZkJGNTM3LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDUtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaWZuZGVmIF9ERUZfQkY1MzRfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9kZWZCRjUzNy5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9kZWZCRjUzNy5oCmluZGV4IDNkNmM4M2UuLjhjYjVkNWMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvZGVmQkY1MzcuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2RlZkJGNTM3LmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIGZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzNy9kZWZiZjUzNy5oCi0gKiBiYXNlZCBvbjoKLSAqIGF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA1LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIGNyZWF0ZWQ6Ci0gKiBkZXNjcmlwdGlvbjoKLSAqCXN5c3RlbSBtbXIgcmVnaXN0ZXIgbWFwCi0gKiByZXY6Ci0gKgotICogbW9kaWZpZWQ6Ci0gKgotICoKLSAqIGJ1Z3M6ICAgICAgICAgZW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiB0aGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCB3aXRob3V0IGFueSB3YXJyYW50eTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBtZXJjaGFudGFiaWxpdHkgb3IgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2UuICBzZWUgdGhlCi0gKiBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIHlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIGNvcHlpbmcuCi0gKiBpZiBub3QsIHdyaXRlIHRvIHRoZSBmcmVlIHNvZnR3YXJlIGZvdW5kYXRpb24sCi0gKiA1OSB0ZW1wbGUgcGxhY2UgLSBzdWl0ZSAzMzAsIGJvc3RvbiwgbWEgMDIxMTEtMTMwNywgdXNhLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0RFRl9CRjUzN19ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2dwaW8uaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvZ3Bpby5oCmluZGV4IGQ3N2EzMWUuLjEwNGJmZjggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvZ3Bpby5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvZ3Bpby5oCkBAIC0xLDcgKzEsNCBAQAogLyoKLSAqIEZpbGU6IGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvZ3Bpby5oCi0gKiBCdWdzOiBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2lycS5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9pcnEuaAppbmRleCBiMmE3MWQ1Li4wZGVmYTk0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL2lycS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbmNsdWRlL21hY2gvaXJxLmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIGZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzNy9pcnEuaAotICogYmFzZWQgb246Ci0gKiBhdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNS0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBjcmVhdGVkOgotICogZGVzY3JpcHRpb246Ci0gKglzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICogcmV2OgotICoKLSAqIG1vZGlmaWVkOgotICoKLSAqCi0gKiBidWdzOiAgICAgICAgIGVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgd2l0aG91dCBhbnkgd2FycmFudHk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogbWVyY2hhbnRhYmlsaXR5IG9yIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlLiAgc2VlIHRoZQotICogZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiB5b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBjb3B5aW5nLgotICogaWYgbm90LCB3cml0ZSB0byB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uLAotICogNTkgdGVtcGxlIHBsYWNlIC0gc3VpdGUgMzMwLCBib3N0b24sIG1hIDAyMTExLTEzMDcsIHVzYS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNpZm5kZWYgX0JGNTM3X0lSUV9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2luY2x1ZGUvbWFjaC9wb3J0bXV4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAppbmRleCA4NzI4NWU3Li5kYTk3NjAzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW5jbHVkZS9tYWNoL3BvcnRtdXguaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIKKyAqLworCiAjaWZuZGVmIF9NQUNIX1BPUlRNVVhfSF8KICNkZWZpbmUgX01BQ0hfUE9SVE1VWF9IXwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW50cy1wcmlvcml0eS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2ludHMtcHJpb3JpdHkuYwppbmRleCA1MWM0ODA4Li5mNjUwMDYyIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW50cy1wcmlvcml0eS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9pbnRzLXByaW9yaXR5LmMKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2ludHMtcHJpb3JpdHkuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvaW50cy1wcmlvcml0eS5jCi0gKiBBdXRob3I6ICAgICAgIE1pY2hhZWwgSGVubmVyaWNoCisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBTZXQgdXAgdGhlIGludGVycnVwdCBwcmlvcml0aWVzCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogU2V0IHVwIHRoZSBpbnRlcnJ1cHQgcHJpb3JpdGllcwogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9ib2FyZHMvZXpraXQuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9ib2FyZHMvZXpraXQuYwppbmRleCBmMmFjM2IwLi4xNGFmNWMyIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvYm9hcmRzL2V6a2l0LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2JvYXJkcy9lemtpdC5jCkBAIC0xLDMxICsxLDkgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9ib2FyZHMvZXpraXQuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvYm9hcmRzL2V6a2l0LmMKLSAqIEF1dGhvcjogICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICAgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKKyAqICAgICAgICAgICAgICAgICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CkBAIC0yMzcsNyArMjE1LDYgQEAKIHN0YXRpYyBzdHJ1Y3QgYmZpbjV4eF9zcGlfY2hpcCBzcGlfZmxhc2hfY2hpcF9pbmZvID0gewogCS5lbmFibGVfZG1hID0gMCwgICAgICAgICAvKiB1c2UgZG1hIHRyYW5zZmVyIHdpdGggdGhpcyBjaGlwKi8KIAkuYml0c19wZXJfd29yZCA9IDgsCi0JLmNzX2NoYW5nZV9wZXJfd29yZCA9IDAsCiB9OwogI2VuZGlmCiAKQEAgLTUwNiwxOSArNDgzLDYgQEAKICNlbmRpZgogI2VuZGlmCiAKLXN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYmZpbl9ncGlvc19yZXNvdXJjZXMgPSB7Ci0JLnN0YXJ0ID0gMCwKLQkuZW5kICAgPSBNQVhfQkxBQ0tGSU5fR1BJT1MgLSAxLAotCS5mbGFncyA9IElPUkVTT1VSQ0VfSVJRLAotfTsKLQotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgYmZpbl9ncGlvc19kZXZpY2UgPSB7Ci0JLm5hbWUgPSAic2ltcGxlLWdwaW8iLAotCS5pZCA9IC0xLAotCS5udW1fcmVzb3VyY2VzID0gMSwKLQkucmVzb3VyY2UgPSAmYmZpbl9ncGlvc19yZXNvdXJjZXMsCi19OwotCiAjaWYgZGVmaW5lZChDT05GSUdfS0VZQk9BUkRfR1BJTykgfHwgZGVmaW5lZChDT05GSUdfS0VZQk9BUkRfR1BJT19NT0RVTEUpCiAjaW5jbHVkZSA8bGludXgvZ3Bpb19rZXlzLmg+CiAKQEAgLTY1OCw4ICs2MjIsNiBAQAogCSZiZmluX2RldmljZV9ncGlva2V5cywKICNlbmRpZgogCi0JJmJmaW5fZ3Bpb3NfZGV2aWNlLAotCiAjaWYgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVApIHx8IGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQX01PRFVMRSkKIAkmZXpraXRfZmxhc2hfZGV2aWNlLAogI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvZG1hLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvZG1hLmMKaW5kZXggZDY4MzdmYi4uNWRjMDIyNSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2RtYS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9kbWEuYwpAQCAtMSwzMSArMSwxMSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2RtYS5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIHRoZSBzaW1wbGUgRE1BIEltcGxlbWVudGF0aW9uIGZvciBCbGFja2ZpbgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFRoaXMgZmlsZSBjb250YWlucyB0aGUgc2ltcGxlIERNQSBJbXBsZW1lbnRhdGlvbiBmb3IgQmxhY2tmaW4KKyAqIENvcHlyaWdodCAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCisKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KIAogI2luY2x1ZGUgPGFzbS9ibGFja2Zpbi5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9iZjUzOC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9iZjUzOC5oCmluZGV4IDljOGFiYjMuLjBjZjViZjggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvYmY1MzguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2JmNTM4LmgKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzOC9iZjUzOC5oCi0gKiBCYXNlZCBvbjoJaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzNy9iZjUzNy5oCi0gKiBBdXRob3I6CU1pY2hhZWwgSGVubmVyaWNoIChtaWNoYWVsLmhlbm5lcmljaEBhbmFsb2cuY29tKQorICogU1lTVEVNIE1NUiBSRUdJU1RFUiBBTkQgTUVNT1JZIE1BUCBGT1IgQURTUC1CRjUzOAogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNZU1RFTSBNTVIgUkVHSVNURVIgQU5EIE1FTU9SWSBNQVAgRk9SIEFEU1AtQkY1MjcKKyAqIENvcHlyaWdodCAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfX01BQ0hfQkY1MzhfSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9iZmluX3NlcmlhbF81eHguaAppbmRleCA5OTlmMjM5Li41YzE0ODE0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIGZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzOC9iZmluX3NlcmlhbF81eHguaAotICogYmFzZWQgb246Ci0gKiBhdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBjcmVhdGVkOgotICogZGVzY3JpcHRpb246Ci0gKglibGFja2ZpbiBzZXJpYWwgZHJpdmVyIGhlYWRlciBmaWxlcwotICogcmV2OgotICoKLSAqIG1vZGlmaWVkOgotICoKLSAqCi0gKiBidWdzOiAgICAgICAgIGVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgd2l0aG91dCBhbnkgd2FycmFudHk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogbWVyY2hhbnRhYmlsaXR5IG9yIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlLiAgc2VlIHRoZQotICogZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiB5b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBjb3B5aW5nLgotICogaWYgbm90LCB3cml0ZSB0byB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uLAotICogNTkgdGVtcGxlIHBsYWNlIC0gc3VpdGUgMzMwLCBib3N0b24sIG1hIDAyMTExLTEzMDcsIHVzYS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvc2VyaWFsLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmgKaW5kZXggNWVjZWUxNi4uMjc4ZTg5NCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTM4L2JsYWNrZmluLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDgtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfTUFDSF9CTEFDS0ZJTl9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MzguaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvY2RlZkJGNTM4LmgKaW5kZXggMWRlNjc1MS4uNDAxZWJkNyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9jZGVmQkY1MzguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2NkZWZCRjUzOC5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzgvY2RlZkJGNTM4LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDgtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTM4X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvZGVmQkY1MzkuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvZGVmQkY1MzkuaAppbmRleCAxYzU4OTE0Li41ZjZjMzRkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2RlZkJGNTM5LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9kZWZCRjUzOS5oCkBAIC0xLDQ3ICsxLDkgQEAKLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKLSAqCi0gKiBUaGlzIGZpbGUgaXMgc3ViamVjdCB0byB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBQdWJsaWMKLSAqIExpY2Vuc2UuIFNlZSB0aGUgZmlsZSAiQ09QWUlORyIgaW4gdGhlIG1haW4gZGlyZWN0b3J5IG9mIHRoaXMgYXJjaGl2ZQotICogZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBOb24tR1BMIExpY2Vuc2UgYWxzbyBhdmFpbGFibGUgYXMgcGFydCBvZiBWaXN1YWxEU1ArKwotICogaHR0cDovL3d3dy5hbmFsb2cuY29tL3Byb2Nlc3NvcnMvcmVzb3VyY2VzL2Nyb3NzY29yZS92aXN1YWxEc3BEZXZTb2Z0d2FyZS5odG1sCi0gKgotICogKGMpIENvcHlyaWdodCAyMDAxLTIwMDUgQW5hbG9nIERldmljZXMsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZAotICoKLSAqIFRoaXMgZmlsZSB1bmRlciBzb3VyY2UgY29kZSBjb250cm9sLCBwbGVhc2Ugc2VuZCBidWdzIG9yIGNoYW5nZXMgdG86Ci0gKiBkc3B0b29scy5zdXBwb3J0QGFuYWxvZy5jb20KLSAqCi0gKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjUzOC9kZWZCRjUzOS5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA4LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KKwogLyogU1lTVEVNICYgTU0gUkVHSVNURVIgQklUICYgQUREUkVTUyBERUZJTklUSU9OUyBGT1IgQURTUC1CRjUzOC85ICovCiAKICNpZm5kZWYgX0RFRl9CRjUzOV9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2dwaW8uaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvZ3Bpby5oCmluZGV4IDMwZjRmNzIuLjI5NWM3OGEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvZ3Bpby5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvZ3Bpby5oCkBAIC0xLDcgKzEsNCBAQAogLyoKLSAqIEZpbGU6IGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvZ3Bpby5oCi0gKiBCdWdzOiBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2lycS5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9pcnEuaAppbmRleCBmZGM4N2ZlLi5hNGI3ZmNiIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL2lycS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbmNsdWRlL21hY2gvaXJxLmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIGZpbGU6CWluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1MzgvaXJxLmgKLSAqIGJhc2VkIG9uOglpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTM3L2lycS5oCi0gKiBhdXRob3I6CU1pY2hhZWwgSGVubmVyaWNoIChtaWNoYWVsLmhlbm5lcmljaEBhbmFsb2cuY29tKQorICogQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIGNyZWF0ZWQ6Ci0gKiBkZXNjcmlwdGlvbjoKLSAqCXN5c3RlbSBtbXIgcmVnaXN0ZXIgbWFwCi0gKiByZXY6Ci0gKgotICogbW9kaWZpZWQ6Ci0gKgotICoKLSAqIGJ1Z3M6ICAgICAgICAgZW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiB0aGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCB3aXRob3V0IGFueSB3YXJyYW50eTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBtZXJjaGFudGFiaWxpdHkgb3IgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2UuICBzZWUgdGhlCi0gKiBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIHlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIGNvcHlpbmcuCi0gKiBpZiBub3QsIHdyaXRlIHRvIHRoZSBmcmVlIHNvZnR3YXJlIGZvdW5kYXRpb24sCi0gKiA1OSB0ZW1wbGUgcGxhY2UgLSBzdWl0ZSAzMzAsIGJvc3RvbiwgbWEgMDIxMTEtMTMwNywgdXNhLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0JGNTM4X0lSUV9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2luY2x1ZGUvbWFjaC9wb3J0bXV4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAppbmRleCBjOGRiMjY0Li42MTIxY2Y4IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL3BvcnRtdXguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW5jbHVkZS9tYWNoL3BvcnRtdXguaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfTUFDSF9QT1JUTVVYX0hfCiAjZGVmaW5lIF9NQUNIX1BPUlRNVVhfSF8KIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2ludHMtcHJpb3JpdHkuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbnRzLXByaW9yaXR5LmMKaW5kZXggNzBkMTdlNS4uMWZhNzkzYyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM4L2ludHMtcHJpb3JpdHkuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1MzgvaW50cy1wcmlvcml0eS5jCkBAIC0xLDMwICsxLDkgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzOC9pbnRzLXByaW9yaXR5LmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTMzL2ludHMtcHJpb3JpdHkuYwotICogQXV0aG9yOiAgICAgICBNaWNoYWVsIEhlbm5lcmljaAorICogU2V0IHVwIHRoZSBpbnRlcnJ1cHQgcHJpb3JpdGllcwogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNldCB1cCB0aGUgaW50ZXJydXB0IHByaW9yaXRpZXMKKyAqIENvcHlyaWdodCAyMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9ib2FyZHMvY21fYmY1NDguYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9ib2FyZHMvY21fYmY1NDguYwppbmRleCBlNTY1YWFlLi5jY2RjZDZkIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvYm9hcmRzL2NtX2JmNTQ4LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2JvYXJkcy9jbV9iZjU0OC5jCkBAIC0xLDMxICsxLDEwIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvYm9hcmRzL2NtX2JmNTQ4LmMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTM3L2JvYXJkcy9lemtpdC5jCi0gKiBBdXRob3I6ICAgICAgIEFpZGFuIFdpbGxpYW1zIDxhaWRhbkBuaWN0YS5jb20uYXU+CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAyMDA4LTIwMDkgQmx1ZXRlY2huaXgKKyAqICAgICAgICAgICAgICAgIDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCisgKiAgICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDUgTmF0aW9uYWwgSUNUIEF1c3RyYWxpYSAoTklDVEEpCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KQEAgLTM4MCwxOSArMzU5LDYgQEAKIH07CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX2dwaW9zX3Jlc291cmNlcyA9IHsKLQkuc3RhcnQgPSAwLAotCS5lbmQgICA9IE1BWF9CTEFDS0ZJTl9HUElPUyAtIDEsCi0JLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi19OwotCi1zdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBiZmluX2dwaW9zX2RldmljZSA9IHsKLQkubmFtZSA9ICJzaW1wbGUtZ3BpbyIsCi0JLmlkID0gLTEsCi0JLm51bV9yZXNvdXJjZXMgPSAxLAotCS5yZXNvdXJjZSA9ICZiZmluX2dwaW9zX3Jlc291cmNlcywKLX07Ci0KICNpZiBkZWZpbmVkKENPTkZJR19QQVRBX0JGNTRYKSB8fCBkZWZpbmVkKENPTkZJR19QQVRBX0JGNTRYX01PRFVMRSkKIHN0YXRpYyBzdHJ1Y3QgcmVzb3VyY2UgYmZpbl9hdGFwaV9yZXNvdXJjZXNbXSA9IHsKIAl7CkBAIC01NDYsMTMgKzUxMiwxMSBAQAogc3RhdGljIHN0cnVjdCBiZmluNXh4X3NwaV9jaGlwIHNwaV9mbGFzaF9jaGlwX2luZm8gPSB7CiAJLmVuYWJsZV9kbWEgPSAwLCAgICAgICAgIC8qIHVzZSBkbWEgdHJhbnNmZXIgd2l0aCB0aGlzIGNoaXAqLwogCS5iaXRzX3Blcl93b3JkID0gOCwKLQkuY3NfY2hhbmdlX3Blcl93b3JkID0gMCwKIH07CiAjZW5kaWYKIAogI2lmIGRlZmluZWQoQ09ORklHX1RPVUNIU0NSRUVOX0FENzg3NykgfHwgZGVmaW5lZChDT05GSUdfVE9VQ0hTQ1JFRU5fQUQ3ODc3X01PRFVMRSkKIHN0YXRpYyBzdHJ1Y3QgYmZpbjV4eF9zcGlfY2hpcCBzcGlfYWQ3ODc3X2NoaXBfaW5mbyA9IHsKLQkuY3NfY2hhbmdlX3Blcl93b3JkID0gMCwKIAkuZW5hYmxlX2RtYSA9IDAsCiAJLmJpdHNfcGVyX3dvcmQgPSAxNiwKIH07CkBAIC04NTMsOCArODE3LDYgQEAKICNpZiBkZWZpbmVkKENPTkZJR19NVERfUEhZU01BUCkgfHwgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVBfTU9EVUxFKQogCSZwYXJhX2ZsYXNoX2RldmljZSwKICNlbmRpZgotCi0JJmJmaW5fZ3Bpb3NfZGV2aWNlLAogfTsKIAogc3RhdGljIGludCBfX2luaXQgY21fYmY1NDhfaW5pdCh2b2lkKQpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2JvYXJkcy9lemtpdC5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2JvYXJkcy9lemtpdC5jCmluZGV4IGM2NmYzODAuLjFhNTI4NmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9ib2FyZHMvZXpraXQuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvYm9hcmRzL2V6a2l0LmMKQEAgLTEsMzEgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2JvYXJkcy9lemtpdC5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzNy9ib2FyZHMvZXpraXQuYwotICogQXV0aG9yOiAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CkBAIC0yMDgsNyArMTg2LDYgQEAKICNlbmRpZgogCiAjaWYgZGVmaW5lZChDT05GSUdfSU5QVVRfQURYTDM0WCkgfHwgZGVmaW5lZChDT05GSUdfSU5QVVRfQURYTDM0WF9NT0RVTEUpCi0jaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KICNpbmNsdWRlIDxsaW51eC9zcGkvYWR4bDM0eC5oPgogc3RhdGljIGNvbnN0IHN0cnVjdCBhZHhsMzR4X3BsYXRmb3JtX2RhdGEgYWR4bDM0eF9pbmZvID0gewogCS54X2F4aXNfb2Zmc2V0ID0gMCwKQEAgLTYzNiw3ICs2MTMsNiBAQAogc3RhdGljIHN0cnVjdCBiZmluNXh4X3NwaV9jaGlwIHNwaV9mbGFzaF9jaGlwX2luZm8gPSB7CiAJLmVuYWJsZV9kbWEgPSAwLCAgICAgICAgIC8qIHVzZSBkbWEgdHJhbnNmZXIgd2l0aCB0aGlzIGNoaXAqLwogCS5iaXRzX3Blcl93b3JkID0gOCwKLQkuY3NfY2hhbmdlX3Blcl93b3JkID0gMCwKIH07CiAjZW5kaWYKIApAQCAtNjUwLDcgKzYyNiw2IEBACiAKICNpZiBkZWZpbmVkKENPTkZJR19UT1VDSFNDUkVFTl9BRDc4NzcpIHx8IGRlZmluZWQoQ09ORklHX1RPVUNIU0NSRUVOX0FENzg3N19NT0RVTEUpCiBzdGF0aWMgc3RydWN0IGJmaW41eHhfc3BpX2NoaXAgc3BpX2FkNzg3N19jaGlwX2luZm8gPSB7Ci0JLmNzX2NoYW5nZV9wZXJfd29yZCA9IDAsCiAJLmVuYWJsZV9kbWEgPSAwLAogCS5iaXRzX3Blcl93b3JkID0gMTYsCiB9OwpAQCAtNjgxLDcgKzY1Niw2IEBACiBzdGF0aWMgc3RydWN0IGJmaW41eHhfc3BpX2NoaXAgc3BpX2FkeGwzNHhfY2hpcF9pbmZvID0gewogCS5lbmFibGVfZG1hID0gMCwgICAgICAgICAvKiB1c2UgZG1hIHRyYW5zZmVyIHdpdGggdGhpcyBjaGlwKi8KIAkuYml0c19wZXJfd29yZCA9IDgsCi0JLmNzX2NoYW5nZV9wZXJfd29yZCA9IDAsCiB9OwogI2VuZGlmCiAKQEAgLTkwOCwxOSArODgyLDYgQEAKIH07CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX2dwaW9zX3Jlc291cmNlcyA9IHsKLQkuc3RhcnQgPSAwLAotCS5lbmQgICA9IE1BWF9CTEFDS0ZJTl9HUElPUyAtIDEsCi0JLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi19OwotCi1zdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBiZmluX2dwaW9zX2RldmljZSA9IHsKLQkubmFtZSA9ICJzaW1wbGUtZ3BpbyIsCi0JLmlkID0gLTEsCi0JLm51bV9yZXNvdXJjZXMgPSAxLAotCS5yZXNvdXJjZSA9ICZiZmluX2dwaW9zX3Jlc291cmNlcywKLX07Ci0KIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBpbnQgY2Nsa192bGV2X2RhdGFzaGVldFtdID0KIHsKIC8qCkBAIC0xMDI4LDggKzk4OSw2IEBACiAJJmJmaW5fZGV2aWNlX2dwaW9rZXlzLAogI2VuZGlmCiAKLQkmYmZpbl9ncGlvc19kZXZpY2UsCi0KICNpZiBkZWZpbmVkKENPTkZJR19NVERfUEhZU01BUCkgfHwgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVBfTU9EVUxFKQogCSZlemtpdF9mbGFzaF9kZXZpY2UsCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9kbWEuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9kbWEuYwppbmRleCBkOTIzOWJjLi4wMzlhNmQ5IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvZG1hLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2RtYS5jCkBAIC0xLDMwICsxLDkgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9kbWEuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiB0aGUgc2ltcGxlIERNQSBJbXBsZW1lbnRhdGlvbiBmb3IgQmxhY2tmaW4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBUaGlzIGZpbGUgY29udGFpbnMgdGhlIHNpbXBsZSBETUEgSW1wbGVtZW50YXRpb24gZm9yIEJsYWNrZmluCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9iZjU0OC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9iZjU0OC5oCmluZGV4IGNkMzFmNzIuLjdiZWFkNWMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvYmY1NDguaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JmNTQ4LmgKQEAgLTEsMzAgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjU0OC9iZjU0OC5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFN5c3RlbSBNTVIgcmVnaXN0ZXIgYW5kIG1lbW9yeSBtYXAgZm9yIEFEU1AtQkY1NDgKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfX01BQ0hfQkY1NDhfSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JmNTR4LWxxMDQzLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JmNTR4LWxxMDQzLmgKaW5kZXggOWM3Y2E2Mi4uODgyMWVmZSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9iZjU0eC1scTA0My5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvYmY1NHgtbHEwNDMuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBCRjU0WF9MUTA0M19ICiAjZGVmaW5lIEJGNTRYX0xRMDQzX0gKIApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9iZjU0eF9rZXlzLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JmNTR4X2tleXMuaAppbmRleCAxZmI0ZWM3Li40OTMzOGFlIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JmNTR4X2tleXMuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JmNTR4X2tleXMuaApAQCAtMSwzICsxLDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCisgKi8KKwogI2lmbmRlZiBfQkZJTl9LUEFEX0gKICNkZWZpbmUgX0JGSU5fS1BBRF9ICiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oCmluZGV4IDJkMWI1ZmEuLmRkNDRhYTcgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9iZmluX3NlcmlhbF81eHguaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogZmlsZTogICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDgvYmZpbl9zZXJpYWxfNXh4LmgKLSAqIGJhc2VkIG9uOgotICogYXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDctMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogY3JlYXRlZDoKLSAqIGRlc2NyaXB0aW9uOgotICoJYmxhY2tmaW4gc2VyaWFsIGRyaXZlciBoZWFkIGZpbGUKLSAqIHJldjoKLSAqCi0gKiBtb2RpZmllZDoKLSAqCi0gKgotICogYnVnczogICAgICAgICBlbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiB0aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBmcmVlIHNvZnR3YXJlIGZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IHdpdGhvdXQgYW55IHdhcnJhbnR5OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIG1lcmNoYW50YWJpbGl0eSBvciBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZS4gIHNlZSB0aGUKLSAqIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogeW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgY29weWluZy4KLSAqIGlmIG5vdCwgd3JpdGUgdG8gdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbiwKLSAqIDU5IHRlbXBsZSBwbGFjZSAtIHN1aXRlIDMzMCwgYm9zdG9uLCBtYSAwMjExMS0xMzA3LCB1c2EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L3NlcmlhbC5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oCmluZGV4IDMxODY2N2IuLjEzMzAyYjYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjU0OC9ibGFja2Zpbi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX01BQ0hfQkxBQ0tGSU5fSF8KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTQyLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0Mi5oCmluZGV4IDA3YWVmYjkuLjQyZjRhOTQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTQyLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NDIuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTQ4L2NkZWZCRjU0Mi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfQ0RFRl9CRjU0Ml9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0NC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NDQuaAppbmRleCA0MzFhNjkyLi4yMjA3Nzk5IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0NC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTQ0LmgKQEAgLTEsMzEgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjU0OC9jZGVmQkY1NDQuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0NERUZfQkY1NDRfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NDcuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTQ3LmgKaW5kZXggOTMzNzZlOS4uNDIzNDIxNSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NDcuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0Ny5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDgvY2RlZkJGNTQ3LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfQ0RFRl9CRjU0OF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0OC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NDguaAppbmRleCA5Y2Q3NDM4Li5kZjg0MTgwIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0OC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTQ4LmgKQEAgLTEsMzEgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjU0OC9jZGVmQkY1NDguaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0NERUZfQkY1NDhfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NDkuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTQ5LmgKaW5kZXggZWFkMzYwYi4uMzRjODRjNyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NDkuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0OS5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDkvY2RlZkJGNTQ5LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9DREVGX0JGNTQ5X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTR4X2Jhc2UuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvY2RlZkJGNTR4X2Jhc2UuaAppbmRleCA2ZTYzNmM0Li5hMmU5ZDk4IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2NkZWZCRjU0eF9iYXNlLmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9jZGVmQkY1NHhfYmFzZS5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDgvY2RlZkJGNTR4X2Jhc2UuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0NERUZfQkY1NFhfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9kZWZCRjU0Mi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9kZWZCRjU0Mi5oCmluZGV4IGIxMzE2NTQuLmQzYmM2ZDEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZGVmQkY1NDIuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTQyLmgKQEAgLTEsMzEgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjU0OC9kZWZCRjU0Mi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2lmbmRlZiBfREVGX0JGNTQyX0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZGVmQkY1NDQuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZGVmQkY1NDQuaAppbmRleCBjMmM3ODViLi5kZDQxNGFlIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTQ0LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9kZWZCRjU0NC5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDgvZGVmQkY1NDQuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0RFRl9CRjU0NF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTQ3LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTQ3LmgKaW5kZXggNjYxZjBkOC4uNWE5ZGJhYiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9kZWZCRjU0Ny5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZGVmQkY1NDcuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTQ4L2RlZkJGNTQ3LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgQURJIEJTRCBsaWNlbnNlIG9yIHRoZSBHUEwtMiAob3IgbGF0ZXIpCiAgKi8KIAogI2lmbmRlZiBfREVGX0JGNTQ4X0gKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZGVmQkY1NDguaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZGVmQkY1NDguaAppbmRleCA4NWQ0YmFkLi44MmNkNTkzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTQ4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9kZWZCRjU0OC5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDgvZGVmQkY1NDguaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0RFRl9CRjU0OF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTQ5LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTQ5LmgKaW5kZXggMDk2NzM0NS4uNmZjNmUzOSAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9kZWZCRjU0OS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZGVmQkY1NDkuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTQ4L2RlZkJGNTQ5LmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIFJldjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBDT1BZSU5HLgotICogSWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLAotICogNTkgVGVtcGxlIFBsYWNlIC0gU3VpdGUgMzMwLCBCb3N0b24sIE1BIDAyMTExLTEzMDcsIFVTQS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBREkgQlNEIGxpY2Vuc2Ugb3IgdGhlIEdQTC0yIChvciBsYXRlcikKICAqLwogCiAjaWZuZGVmIF9ERUZfQkY1NDlfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9kZWZCRjU0eF9iYXNlLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTR4X2Jhc2UuaAppbmRleCBlMDIyZTg5Li44NTkwYzhjIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTR4X2Jhc2UuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2RlZkJGNTR4X2Jhc2UuaApAQCAtMSwzMSArMSw3IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTQ4L2RlZkJGNTR4X2Jhc2UuaAotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246Ci0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0RFRl9CRjU0WF9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2dwaW8uaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZ3Bpby5oCmluZGV4IDNhMjA1MTcuLjg1MGUzOWQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZ3Bpby5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvZ3Bpby5oCkBAIC0xLDM0ICsxLDggQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDgvZ3Bpby5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoJIE1pY2hhZWwgSGVubmVyaWNoIChoZW5uZXJpY2hAYmxhY2tmaW4udWNsaW51eC5vcmcpCi0gKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKLQotCiAjZGVmaW5lIEdQSU9fUEEwCTAKICNkZWZpbmUgR1BJT19QQTEJMQogI2RlZmluZSBHUElPX1BBMgkyCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2lycS5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9pcnEuaAppbmRleCBmMTk0NjI1Li4xMDZkYjA1IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW5jbHVkZS9tYWNoL2lycS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvaXJxLmgKQEAgLTEsMzIgKzEsNyBAQAogLyoKLSAqIGZpbGU6CWluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NDgvaXJxLmgKLSAqIGJhc2VkIG9uOglpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTM3L2lycS5oCi0gKiBhdXRob3I6CVJveSBIdWFuZyAocm95Lmh1YW5nQGFuYWxvZy5jb20pCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBjcmVhdGVkOgotICogZGVzY3JpcHRpb246Ci0gKglzeXN0ZW0gbW1yIHJlZ2lzdGVyIG1hcAotICogcmV2OgotICoKLSAqIG1vZGlmaWVkOgotICoKLSAqCi0gKiBidWdzOiAgICAgICAgIGVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKQotICogYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogdGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgd2l0aG91dCBhbnkgd2FycmFudHk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogbWVyY2hhbnRhYmlsaXR5IG9yIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlLiAgc2VlIHRoZQotICogZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiB5b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IHNlZSB0aGUgZmlsZSBjb3B5aW5nLgotICogaWYgbm90LCB3cml0ZSB0byB0aGUgZnJlZSBzb2Z0d2FyZSBmb3VuZGF0aW9uLAotICogNTkgdGVtcGxlIHBsYWNlIC0gc3VpdGUgMzMwLCBib3N0b24sIG1hIDAyMTExLTEzMDcsIHVzYS4KKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9CRjU0OF9JUlFfSF8KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbmNsdWRlL21hY2gvcG9ydG11eC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9wb3J0bXV4LmgKaW5kZXggY2UzNzJiYS4uODlhZDZhOCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9wb3J0bXV4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2luY2x1ZGUvbWFjaC9wb3J0bXV4LmgKQEAgLTEsMyArMSw5IEBACisvKgorICogQ29weXJpZ2h0IDIwMDctMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgorICovCisKICNpZm5kZWYgX01BQ0hfUE9SVE1VWF9IXwogI2RlZmluZSBfTUFDSF9QT1JUTVVYX0hfCiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbnRzLXByaW9yaXR5LmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NDgvaW50cy1wcmlvcml0eS5jCmluZGV4IDlkZDBmYTMuLjQ4ZGQzYTQgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU0OC9pbnRzLXByaW9yaXR5LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTQ4L2ludHMtcHJpb3JpdHkuYwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW50cy1wcmlvcml0eS5jCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9pbnRzLXByaW9yaXR5LmMKLSAqIEF1dGhvcjogICAgICAgTWljaGFlbCBIZW5uZXJpY2gKKyAqIENvcHlyaWdodCAyMDA3LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNldCB1cCB0aGUgaW50ZXJydXB0IHByaW9yaXRpZXMKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBTZXQgdXAgdGhlIGludGVycnVwdCBwcmlvcml0aWVzCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2F0b21pYy5TIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2F0b21pYy5TCmluZGV4IDk0MzliYzYuLjAyNjFhNWUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9hdG9taWMuUworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvYXRvbWljLlMKQEAgLTEsMjMgKzEsOCBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2F0b21pYy5TCi0gKiBBdXRob3I6ICAgICAgIFBoaWxpcHBlIEdlcnVtIDxycG1AeGVub21haS5vcmc+CisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICBQaGlsaXBwZSBHZXJ1bSA8cnBtQHhlbm9tYWkub3JnPgogICoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDcgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvbGlua2FnZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2JvYXJkcy9jbV9iZjU2MS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2JvYXJkcy9jbV9iZjU2MS5jCmluZGV4IDY1NzdlY2YuLmRmYzhkNWIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9ib2FyZHMvY21fYmY1NjEuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvYm9hcmRzL2NtX2JmNTYxLmMKQEAgLTEsMzAgKzEsMTAgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjUzMy9ib2FyZHMvY21fYmY1NjEuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzMvYm9hcmRzL2V6a2l0LmMKLSAqIEF1dGhvcjogICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4gQ29weXJpZ2h0IDIwMDUKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICAyMDA4LTIwMDkgQmx1ZXRlY2huaXgKKyAqICAgICAgICAgICAgICAgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKKyAqICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKLSAqIENyZWF0ZWQ6ICAgICAgMjAwNgotICogRGVzY3JpcHRpb246ICBCb2FyZCBkZXNjcmlwdGlvbiBmaWxlCi0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KQEAgLTI4NSwxOSArMjY1LDYgQEAKIH07CiAjZW5kaWYKIAotc3RhdGljIHN0cnVjdCByZXNvdXJjZSBiZmluX2dwaW9zX3Jlc291cmNlcyA9IHsKLQkuc3RhcnQgPSAwLAotCS5lbmQgICA9IE1BWF9CTEFDS0ZJTl9HUElPUyAtIDEsCi0JLmZsYWdzID0gSU9SRVNPVVJDRV9JUlEsCi19OwotCi1zdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBiZmluX2dwaW9zX2RldmljZSA9IHsKLQkubmFtZSA9ICJzaW1wbGUtZ3BpbyIsCi0JLmlkID0gLTEsCi0JLm51bV9yZXNvdXJjZXMgPSAxLAotCS5yZXNvdXJjZSA9ICZiZmluX2dwaW9zX3Jlc291cmNlcywKLX07Ci0KICNpZiBkZWZpbmVkKENPTkZJR19VU0JfSVNQMTM2Ml9IQ0QpIHx8IGRlZmluZWQoQ09ORklHX1VTQl9JU1AxMzYyX0hDRF9NT0RVTEUpCiBzdGF0aWMgc3RydWN0IHJlc291cmNlIGlzcDEzNjJfaGNkX3Jlc291cmNlc1tdID0gewogCXsKQEAgLTUzMiw4ICs0OTksNiBAQAogI2lmIGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQKSB8fCBkZWZpbmVkKENPTkZJR19NVERfUEhZU01BUF9NT0RVTEUpCiAJJnBhcmFfZmxhc2hfZGV2aWNlLAogI2VuZGlmCi0KLQkmYmZpbl9ncGlvc19kZXZpY2UsCiB9OwogCiBzdGF0aWMgaW50IF9faW5pdCBjbV9iZjU2MV9pbml0KHZvaWQpCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvYm9hcmRzL2V6a2l0LmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvYm9hcmRzL2V6a2l0LmMKaW5kZXggY2FlZDk2Yi4uOWUyZDhjZiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2JvYXJkcy9lemtpdC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9ib2FyZHMvZXpraXQuYwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvZXpraXQuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBDb3B5cmlnaHQgMjAwNC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgMjAwNSBOYXRpb25hbCBJQ1QgQXVzdHJhbGlhIChOSUNUQSkKKyAqICAgICAgICAgICAgICAgICAgICBBaWRhbiBXaWxsaWFtcyA8YWlkYW5AbmljdGEuY29tLmF1PgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgpAQCAtMzg3LDE5ICszNjYsNiBAQAogfTsKICNlbmRpZgogCi1zdGF0aWMgc3RydWN0IHJlc291cmNlIGJmaW5fZ3Bpb3NfcmVzb3VyY2VzID0gewotCS5zdGFydCA9IDAsCi0JLmVuZCAgID0gTUFYX0JMQUNLRklOX0dQSU9TIC0gMSwKLQkuZmxhZ3MgPSBJT1JFU09VUkNFX0lSUSwKLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlIGJmaW5fZ3Bpb3NfZGV2aWNlID0gewotCS5uYW1lID0gInNpbXBsZS1ncGlvIiwKLQkuaWQgPSAtMSwKLQkubnVtX3Jlc291cmNlcyA9IDEsCi0JLnJlc291cmNlID0gJmJmaW5fZ3Bpb3NfcmVzb3VyY2VzLAotfTsKLQogI2lmIGRlZmluZWQoQ09ORklHX0kyQ19HUElPKSB8fCBkZWZpbmVkKENPTkZJR19JMkNfR1BJT19NT0RVTEUpCiAjaW5jbHVkZSA8bGludXgvaTJjLWdwaW8uaD4KIApAQCAtNDkzLDggKzQ1OSw2IEBACiAJJmlzcDEzNjJfaGNkX2RldmljZSwKICNlbmRpZgogCi0JJmJmaW5fZ3Bpb3NfZGV2aWNlLAotCiAjaWYgZGVmaW5lZChDT05GSUdfTVREX1BIWVNNQVApIHx8IGRlZmluZWQoQ09ORklHX01URF9QSFlTTUFQX01PRFVMRSkKIAkmZXpraXRfZmxhc2hfZGV2aWNlLAogI2VuZGlmCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvYm9hcmRzL3RlcGxhLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvYm9hcmRzL3RlcGxhLmMKaW5kZXggNmY3N2RiZS4uOGJhNzI1MiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2JvYXJkcy90ZXBsYS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9ib2FyZHMvdGVwbGEuYwpAQCAtMSwxNSArMSwxMyBAQAogLyoKLSAqICBGaWxlOiBhcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvdGVwbGEuYworICogQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKQorICogICAgICAgICAgICAgICAgICAgICAgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KICAqCi0gKiAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKiAgT25seSBTTVNDOTFDMTExMSB3YXMgcmVnaXN0ZXJlZCwgbWF5IGRvIG1vcmUgbGF0ZXIuCisgKiBUaGFua3MgdG8gSmFtZXkgSGlja3MuCiAgKgotICogIENvcHlyaWdodCAyMDA1IE5hdGlvbmFsIElDVCBBdXN0cmFsaWEgKE5JQ1RBKSwgQWlkYW4gV2lsbGlhbXMgPGFpZGFuQG5pY3RhLmNvbS5hdT4KLSAqICBUaGFua3MgdG8gSmFtZXkgSGlja3MuCisgKiBPbmx5IFNNU0M5MUMxMTExIHdhcyByZWdpc3RlcmVkLCBtYXkgZG8gbW9yZSBsYXRlci4KICAqCi0gKiAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMiBhcwotICogIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2RldmljZS5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2RtYS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2RtYS5jCmluZGV4IDQyYjAwMzcuLmM5MzhjM2MgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9kbWEuYworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvZG1hLmMKQEAgLTEsMzEgKzEsMTEgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9kbWEuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiB0aGUgc2ltcGxlIERNQSBJbXBsZW1lbnRhdGlvbiBmb3IgQmxhY2tmaW4KICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBUaGlzIGZpbGUgY29udGFpbnMgdGhlIHNpbXBsZSBETUEgSW1wbGVtZW50YXRpb24gZm9yIEJsYWNrZmluCisgKiBDb3B5cmlnaHQgMjAwNy0yMDA4IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KKwogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogCiAjaW5jbHVkZSA8YXNtL2JsYWNrZmluLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2JmNTYxLmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2JmNTYxLmgKaW5kZXggOTk2ODM2Mi4uOWY5YTM2NyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9iZjU2MS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvYmY1NjEuaApAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTYxL2JmNTYxLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogU1lTVEVNIE1NUiBSRUdJU1RFUiBBTkQgTUVNT1JZIE1BUCBGT1IgQURTUC1CRjU2MQogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjogIFNZU1RFTSBNTVIgUkVHSVNURVIgQU5EIE1FTU9SWSBNQVAgRk9SIEFEU1AtQkY1NjEKKyAqIENvcHlyaWdodCAyMDA1LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA2IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaWZuZGVmIF9fTUFDSF9CRjU2MV9IX18KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmggYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2JmaW5fc2VyaWFsXzV4eC5oCmluZGV4IGZkNWU4ODcuLmUzM2UxNTggMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvYmZpbl9zZXJpYWxfNXh4LmgKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9iZmluX3NlcmlhbF81eHguaApAQCAtMSwzMiArMSw3IEBACiAvKgotICogZmlsZTogICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NjEvYmZpbl9zZXJpYWxfNXh4LmgKLSAqIGJhc2VkIG9uOgotICogYXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDYtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogY3JlYXRlZDoKLSAqIGRlc2NyaXB0aW9uOgotICoJYmxhY2tmaW4gc2VyaWFsIGRyaXZlciBoZWFkIGZpbGUKLSAqIHJldjoKLSAqCi0gKiBtb2RpZmllZDoKLSAqCi0gKgotICogYnVnczogICAgICAgICBlbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiB0aGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBnbnUgZ2VuZXJhbCBwdWJsaWMgbGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBmcmVlIHNvZnR3YXJlIGZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIHRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IHdpdGhvdXQgYW55IHdhcnJhbnR5OyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIG1lcmNoYW50YWJpbGl0eSBvciBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZS4gIHNlZSB0aGUKLSAqIGdudSBnZW5lcmFsIHB1YmxpYyBsaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogeW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgZ251IGdlbmVyYWwgcHVibGljIGxpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgY29weWluZy4KLSAqIGlmIG5vdCwgd3JpdGUgdG8gdGhlIGZyZWUgc29mdHdhcmUgZm91bmRhdGlvbiwKLSAqIDU5IHRlbXBsZSBwbGFjZSAtIHN1aXRlIDMzMCwgYm9zdG9uLCBtYSAwMjExMS0xMzA3LCB1c2EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L3NlcmlhbC5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9ibGFja2Zpbi5oCmluZGV4IDhiZTMxMzUuLjY3ZDZiZGMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvYmxhY2tmaW4uaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2JsYWNrZmluLmgKQEAgLTEsMzEgKzEsNyBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgaW5jbHVkZS9hc20tYmxhY2tmaW4vbWFjaC1iZjU2MS9ibGFja2Zpbi5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA1LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfTUFDSF9CTEFDS0ZJTl9IXwpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9jZGVmQkY1NjEuaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvY2RlZkJGNTYxLmgKaW5kZXggOWQ5ODU4Yy4uODFlY2RiNyAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9jZGVmQkY1NjEuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2NkZWZCRjU2MS5oCkBAIC0xLDMxICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGluY2x1ZGUvYXNtLWJsYWNrZmluL21hY2gtYmY1NjEvY2RlZkJGNTYxLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDUtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgQyBQT0lOVEVSUyBUTyBTWVNURU0gTU1SIFJFR0lTVEVSIEFORCBNRU1PUlkgTUFQIEZPUiBBRFNQLUJGNTYxCi0gKgotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpZm5kZWYgX0NERUZfQkY1NjFfSApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9kZWZCRjU2MS5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9kZWZCRjU2MS5oCmluZGV4IDVmYzBmMDUuLmEzMWU1MDkgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvZGVmQkY1NjEuaAorKysgYi9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2RlZkJGNTYxLmgKQEAgLTEsMzIgKzEsNyBAQAotCiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTYxL2RlZkJGNTYxLmgKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQ29weXJpZ2h0IDIwMDUtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgotICogU1lTVEVNIE1NUiBSRUdJU1RFUiBBTkQgTUVNT1JZIE1BUCBGT1IgQURTUC1CRjU2MQotICogUmV2OgotICoKLSAqIE1vZGlmaWVkOgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyLCBvciAoYXQgeW91ciBvcHRpb24pCi0gKiBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgc2VlIHRoZSBmaWxlIENPUFlJTkcuCi0gKiBJZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCi0gKiA1OSBUZW1wbGUgUGxhY2UgLSBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgMDIxMTEtMTMwNywgVVNBLgorICogTGljZW5zZWQgdW5kZXIgdGhlIEFESSBCU0QgbGljZW5zZSBvciB0aGUgR1BMLTIgKG9yIGxhdGVyKQogICovCiAKICNpZm5kZWYgX0RFRl9CRjU2MV9ICmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2dwaW8uaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvZ3Bpby5oCmluZGV4IDc4ODJmNzkuLmE2NTFhOGMgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvZ3Bpby5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvZ3Bpby5oCkBAIC0xLDcgKzEsNCBAQAogLyoKLSAqIEZpbGU6IGFyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvZ3Bpby5oCi0gKiBCdWdzOiBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCiAgKiBDb3B5cmlnaHQgKEMpIDIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2lycS5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9pcnEuaAppbmRleCA2Njk4Mzg5Li43YjIwOGRiIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL2lycS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvaXJxLmgKQEAgLTEsMzIgKzEsNyBAQAotCiAvKgotICogRmlsZTogICAgICAgICBpbmNsdWRlL2FzbS1ibGFja2Zpbi9tYWNoLWJmNTYxL2lycS5oCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA1LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBSZXY6Ci0gKgotICogTW9kaWZpZWQ6Ci0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikKLSAqIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBzZWUgdGhlIGZpbGUgQ09QWUlORy4KLSAqIElmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwKLSAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfQkY1NjFfSVJRX0hfCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL3BvcnRtdXguaCBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvcG9ydG11eC5oCmluZGV4IDJlNWFkNjMuLjNhN2I0NmIgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvcG9ydG11eC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvcG9ydG11eC5oCkBAIC0xLDMgKzEsOSBAQAorLyoKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICoKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KKyAqLworCiAjaWZuZGVmIF9NQUNIX1BPUlRNVVhfSF8KICNkZWZpbmUgX01BQ0hfUE9SVE1VWF9IXwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL3NtcC5oIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2luY2x1ZGUvbWFjaC9zbXAuaAppbmRleCBmOWU2NWViLi4zOTBjN2Y0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW5jbHVkZS9tYWNoL3NtcC5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbmNsdWRlL21hY2gvc21wLmgKQEAgLTEsMyArMSw5IEBACisvKgorICogQ29weXJpZ2h0IDIwMDctMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKgorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgorICovCisKICNpZm5kZWYgX01BQ0hfQkY1NjFfU01QCiAjZGVmaW5lIF9NQUNIX0JGNTYxX1NNUAogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW50cy1wcmlvcml0eS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2ludHMtcHJpb3JpdHkuYwppbmRleCA5ZDJmMjMzLi5iNDQyNDE3IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvaW50cy1wcmlvcml0eS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9pbnRzLXByaW9yaXR5LmMKQEAgLTEsMzAgKzEsOSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2ludHMtcHJpb3JpdHkuYwotICogQmFzZWQgb246ICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1MzcvaW50cy1wcmlvcml0eS5jCi0gKiBBdXRob3I6ICAgICAgIE1pY2hhZWwgSGVubmVyaWNoCisgKiBTZXQgdXAgdGhlIGludGVycnVwdCBwcmlvcml0aWVzCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOiAgU2V0IHVwIHRoZSBpbnRlcnJ1cHQgcHJpb3JpdGllcworICogQ29weXJpZ2h0IDIwMDUtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9zZWNvbmRhcnkuUyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9zZWNvbmRhcnkuUwppbmRleCBmNzJhNmFmLi44ZTYwNTAzIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvc2Vjb25kYXJ5LlMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL3NlY29uZGFyeS5TCkBAIC0xLDI2ICsxLDEwIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvc2Vjb25kYXJ5LlMKLSAqIEJhc2VkIG9uOiAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL2hlYWQuUwotICogQXV0aG9yOiAgICAgICBQaGlsaXBwZSBHZXJ1bSA8cnBtQHhlbm9tYWkub3JnPgorICogQkY1NjEgY29yZUIgYm9vdHN0cmFwIGZpbGUKICAqCi0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgorICogICAgICAgICAgICAgICBQaGlsaXBwZSBHZXJ1bSA8cnBtQHhlbm9tYWkub3JnPgogICoKLSAqIERlc2NyaXB0aW9uOiAgQkY1NjEgY29yZUIgYm9vdHN0cmFwIGZpbGUKLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2xpbmthZ2UuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9zbXAuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9zbXAuYwppbmRleCA4YzEwNzAxLi41MTBmNTc2IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtYmY1NjEvc21wLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWJmNTYxL3NtcC5jCkBAIC0xLDIzICsxLDggQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1iZjU2MS9zbXAuYwotICogQXV0aG9yOiAgICAgICBQaGlsaXBwZSBHZXJ1bSA8cnBtQHhlbm9tYWkub3JnPgorICogQ29weXJpZ2h0IDIwMDctMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgIFBoaWxpcHBlIEdlcnVtIDxycG1AeGVub21haS5vcmc+CiAgKgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2FyY2hfY2hlY2tzLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2FyY2hfY2hlY2tzLmMKaW5kZXggNTk5OGQ4Ni4uOWRiYWZjZCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9hcmNoX2NoZWNrcy5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vYXJjaF9jaGVja3MuYwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2FyY2hfY2hlY2tzLmMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgkgUm9iaW4gR2V0eiA8cmdldHpAYmxhY2tmaW4udWNsaW51eC5vcmc+CisgKiBEbyBzb21lIGNoZWNraW5nIHRvIG1ha2Ugc3VyZSB0aGluZ3MgYXJlIE9LCiAgKgotICogQ3JlYXRlZDogICAgICAyNUp1bDA3Ci0gKiBEZXNjcmlwdGlvbjogIERvIHNvbWUgY2hlY2tpbmcgdG8gbWFrZSBzdXJlIHRoaW5ncyBhcmUgT0sKKyAqIENvcHlyaWdodCAyMDA3LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNC0yMDA3IEFuYWxvZyBEZXZpY2VzIEluYy4KLSAqCi0gKiBCdWdzOiAgICAgICAgIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCiAjaW5jbHVkZSA8YXNtL2ZpeGVkX2NvZGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vY2FjaGUtYy5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9jYWNoZS1jLmMKaW5kZXggNGViYmQ3OC4uYTYwYTI0ZiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9jYWNoZS1jLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9jYWNoZS1jLmMKQEAgLTMsOCArMyw2IEBACiAgKgogICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgogICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vY2FjaGUuUyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vY2FjaGUuUwppbmRleCBkOTY2NmZlLi5lYTU0MDMxIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2NhY2hlLlMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9jYWNoZS5TCkBAIC0zLDggKzMsNiBAQAogICoKICAqIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKICAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlci4KICAqLwogCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2NwdWZyZXEuYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vY3B1ZnJlcS5jCmluZGV4IDg1YzY1ODAuLjAxNTA2NTAgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vY3B1ZnJlcS5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vY3B1ZnJlcS5jCkBAIC0xLDMwICsxLDkgQEAKIC8qCi0gKiBGaWxlOgkgYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9jcHVmcmVxLmMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogQmxhY2tmaW4gY29yZSBjbG9jayBzY2FsaW5nCiAgKgotICogQ3JlYXRlZDoKLSAqIERlc2NyaXB0aW9uOgkgQmxhY2tmaW4gY29yZSBjbG9jayBzY2FsaW5nCisgKiBDb3B5cmlnaHQgMjAwOC0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqCQkgQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczoJIEVudGVyIGJ1Z3MgYXQgaHR0cDovL2JsYWNrZmluLnVjbGludXgub3JnLwotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLgkgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BCTAyMTEwLTEzMDEJVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgpkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9lbnRyeS5TIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9lbnRyeS5TCmluZGV4IDFlN2NhYzIuLjk0YTAzNzUgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vZW50cnkuUworKysgYi9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2VudHJ5LlMKQEAgLTEsMzIgKzEsMTEgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vZW50cnkuUwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6ICAgICAgIExpbnVzIFRvcnZhbGRzCisgKiBDb250YWlucyB0aGUgc3lzdGVtLWNhbGwgYW5kIGZhdWx0IGxvdy1sZXZlbCBoYW5kbGluZyByb3V0aW5lcy4KKyAqIFRoaXMgYWxzbyBjb250YWlucyB0aGUgdGltZXItaW50ZXJydXB0IGhhbmRsZXIsIGFzIHdlbGwgYXMgYWxsCisgKiBpbnRlcnJ1cHRzIGFuZCBmYXVsdHMgdGhhdCBjYW4gcmVzdWx0IGluIGEgdGFzay1zd2l0Y2guCiAgKgotICogQ3JlYXRlZDogICAgICA/Ci0gKiBEZXNjcmlwdGlvbjogIGNvbnRhaW5zIHRoZSBzeXN0ZW0tY2FsbCBhbmQgZmF1bHQgbG93LWxldmVsIGhhbmRsaW5nIHJvdXRpbmVzLgotICogICAgICAgICAgICAgICBUaGlzIGFsc28gY29udGFpbnMgdGhlIHRpbWVyLWludGVycnVwdCBoYW5kbGVyLCBhcyB3ZWxsIGFzIGFsbAotICogICAgICAgICAgICAgICBpbnRlcnJ1cHRzIGFuZCBmYXVsdHMgdGhhdCBjYW4gcmVzdWx0IGluIGEgdGFzay1zd2l0Y2guCisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogLyogTk9URTogVGhpcyBjb2RlIGhhbmRsZXMgc2lnbmFsLXJlY29nbml0aW9uLCB3aGljaCBoYXBwZW5zIGV2ZXJ5IHRpbWUKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vaGVhZC5TIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9oZWFkLlMKaW5kZXggOWM3OWRmZS4uY2FiMGEwMCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9oZWFkLlMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9oZWFkLlMKQEAgLTMsOCArMyw2IEBACiAgKgogICogQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgogICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vaW50ZXJydXB0LlMgYi9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2ludGVycnVwdC5TCmluZGV4IDgyZDQxN2UuLjgwODVmZjEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vaW50ZXJydXB0LlMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9pbnRlcnJ1cHQuUwpAQCAtMSwzMSArMSwxMSBAQAogLyoKLSAqIEZpbGU6ICAgICAgICAgYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9pbnRlcnJ1cHQuUwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6ICAgICAgIEQuIEplZmYgRGlvbm5lIDxqZWZmQHJ5ZWhhbS5lZS5yeWVyc29uLmNhPgorICogSW50ZXJydXB0IEVudHJpZXMKKyAqCisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KKyAqICAgICAgICAgICAgICAgRC4gSmVmZiBEaW9ubmUgPGplZmZAcnllaGFtLmVlLnJ5ZXJzb24uY2E+CiAgKiAgICAgICAgICAgICAgIEtlbm5ldGggQWxiYW5vd3NraSA8a2phaGRzQGtqYWhkcy5jb20+CiAgKgotICogQ3JlYXRlZDogICAgICA/Ci0gKiBEZXNjcmlwdGlvbjogIEludGVycnVwdCBFbnRyaWVzCi0gKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxhc20vYmxhY2tmaW4uaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vaW50cy1wcmlvcml0eS5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9pbnRzLXByaW9yaXR5LmMKaW5kZXggNmZmZGE3OC4uNjYwZWExYiAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9pbnRzLXByaW9yaXR5LmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9pbnRzLXByaW9yaXR5LmMKQEAgLTEsMzMgKzEsMTQgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vaW50cy1wcmlvcml0eS5jCisgKiBTZXQgdXAgdGhlIGludGVycnVwdCBwcmlvcml0aWVzCiAgKgotICogRGVzY3JpcHRpb246ICBTZXQgdXAgdGhlIGludGVycnVwdCBwcmlvcml0aWVzCisgKiBDb3B5cmlnaHQgIDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAgMjAwMyBCYXMgVmVybWV1bGVuIDxiYXNAYnV5d2F5cy5ubD4KKyAqICAgICAgICAgICAgICAgICAyMDAyIEFyY3R1cnVzIE5ldHdvcmtzIEluYy4gTWFUZWQgPG1hdGVkQHN5bXBhdGljby5jYT4KKyAqICAgICAgICAgICAgMjAwMC0yMDAxIExpbmVvLCBJbmMuIEQuIEplZmZmIERpb25uZSA8amVmZkBsaW5lby5jYT4KKyAqICAgICAgICAgICAgICAgICAxOTk5IEQuIEplZmYgRGlvbm5lIDxqZWZmQHVjbGludXgub3JnPgorICogICAgICAgICAgICAgICAgIDE5OTYgUm9tYW4gWmlwcGVsCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIDE5OTYgUm9tYW4gWmlwcGVsCi0gKiAgICAgICAgICAgICAgIDE5OTkgRC4gSmVmZiBEaW9ubmUgPGplZmZAdWNsaW51eC5vcmc+Ci0gKiAgICAgICAgICAgICAgIDIwMDAtMjAwMSBMaW5lbywgSW5jLiBELiBKZWZmZiBEaW9ubmUgPGplZmZAbGluZW8uY2E+Ci0gKiAgICAgICAgICAgICAgIDIwMDIgQXJjdHVydXMgTmV0d29ya3MgSW5jLiBNYVRlZCA8bWF0ZWRAc3ltcGF0aWNvLmNhPgotICogICAgICAgICAgICAgICAyMDAzIE1ldHJvd2Vya3MvTW90b3JvbGEKLSAqICAgICAgICAgICAgICAgMjAwMyBCYXMgVmVybWV1bGVuIDxiYXNAYnV5d2F5cy5ubD4KLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIKICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2lycXBhbmljLmMgYi9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2lycXBhbmljLmMKaW5kZXggODgzZTMyNC4uYzY0OTYyNCAxMDA2NDQKLS0tIGEvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9pcnFwYW5pYy5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vaXJxcGFuaWMuYwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL2lycXBhbmljLmMKLSAqIEJhc2VkIG9uOgotICogQXV0aG9yOgorICogcGFuaWMga2VybmVsIHdpdGggZHVtcCBpbmZvcm1hdGlvbgogICoKLSAqIENyZWF0ZWQ6ICAgICAgPwotICogRGVzY3JpcHRpb246ICBwYW5pYyBrZXJuZWwgd2l0aCBkdW1wIGluZm9ybWF0aW9uCisgKiBDb3B5cmlnaHQgMjAwNS0yMDA5IEFuYWxvZyBEZXZpY2VzIEluYy4KICAqCi0gKiBNb2RpZmllZDogICAgIHJnZXR6IC0gYWRkZWQgY2FjaGUgY2hlY2tpbmcgY29kZSAxNEZlYjA2Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDYgQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vcG0uYyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vcG0uYwppbmRleCAwZTNkNGZmLi44ODM3YmU0IDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL3BtLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9wbS5jCkBAIC0xLDM1ICsxLDExIEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL3BtLmMKLSAqIEJhc2VkIG9uOiAgICAgYXJtL21hY2gtb21hcC9wbS5jCi0gKiBBdXRob3I6ICAgICAgIENsaWZmIEJyYWtlIDxjYnJha2VAYWNjZWxlbnQuY29tPiBDb3B5cmlnaHQgKGMpIDIwMDEKKyAqIEJsYWNrZmluIHBvd2VyIG1hbmFnZW1lbnQKICAqCi0gKiBDcmVhdGVkOiAgICAgIDIwMDEKLSAqIERlc2NyaXB0aW9uOiAgQmxhY2tmaW4gcG93ZXIgbWFuYWdlbWVudAorICogQ29weXJpZ2h0IDIwMDYtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6ICAgICBOaWNvbGFzIFBpdHJlIC0gUFhBMjUwIHN1cHBvcnQKLSAqICAgICAgICAgICAgICAgIENvcHlyaWdodCAoYykgMjAwMiBNb250YSBWaXN0YSBTb2Z0d2FyZSwgSW5jLgotICogICAgICAgICAgICAgICBEYXZpZCBTaW5nbGV0b24gLSBPTUFQMTUxMAotICogICAgICAgICAgICAgICAgQ29weXJpZ2h0IChjKSAyMDAyIE1vbnRhIFZpc3RhIFNvZnR3YXJlLCBJbmMuCi0gKiAgICAgICAgICAgICAgIERpcmsgQmVobWUgPGRpcmsuYmVobWVAZGUuYm9zY2guY29tPiAtIE9NQVAxNTEwLzE2MTAKLSAqICAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yCisgKiBiYXNlZCBvbiBhcm0vbWFjaC1vbWFwL3BtLmMKKyAqICAgIENvcHlyaWdodCAyMDAxLCBDbGlmZiBCcmFrZSA8Y2JyYWtlQGFjY2VsZW50LmNvbT4gYW5kIG90aGVycwogICovCiAKICNpbmNsdWRlIDxsaW51eC9zdXNwZW5kLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL3NtcC5jIGIvYXJjaC9ibGFja2Zpbi9tYWNoLWNvbW1vbi9zbXAuYwppbmRleCAzNDllZTNmLi5kOTg1ODVmIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21hY2gtY29tbW9uL3NtcC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbWFjaC1jb21tb24vc21wLmMKQEAgLTEsMjQgKzEsMTAgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4va2VybmVsL3NtcC5jCi0gKiBBdXRob3I6ICAgICAgIFBoaWxpcHBlIEdlcnVtIDxycG1AeGVub21haS5vcmc+Ci0gKiBJUEkgbWFuYWdlbWVudCBiYXNlZCBvbiBhcmNoL2FybS9rZXJuZWwvc21wLmMuCisgKiBJUEkgbWFuYWdlbWVudCBiYXNlZCBvbiBhcmNoL2FybS9rZXJuZWwvc21wLmMgKENvcHlyaWdodCAyMDAyIEFSTSBMaW1pdGVkKQogICoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDcgQW5hbG9nIERldmljZXMgSW5jLgorICogQ29weXJpZ2h0IDIwMDctMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCisgKiAgICAgICAgICAgICAgICAgICAgICAgICBQaGlsaXBwZSBHZXJ1bSA8cnBtQHhlbm9tYWkub3JnPgogICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Ci0gKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQotICogdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKLSAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCi0gKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQotICogR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMi4KICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21tL2JsYWNrZmluX3NyYW0uaCBiL2FyY2gvYmxhY2tmaW4vbW0vYmxhY2tmaW5fc3JhbS5oCmluZGV4IGJjMDA2MjguLmZiMGIxNTkgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbW0vYmxhY2tmaW5fc3JhbS5oCisrKyBiL2FyY2gvYmxhY2tmaW4vbW0vYmxhY2tmaW5fc3JhbS5oCkBAIC0xLDMwICsxLDkgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbW0vYmxhY2tmaW5fc3JhbS5oCi0gKiBCYXNlZCBvbjogICAgIGFyY2gvYmxhY2tmaW4vbW0vYmxhY2tmaW5fc3JhbS5jCi0gKiBBdXRob3I6ICAgICAgIE1pa2UgRnJ5c2luZ2VyCisgKiBMb2NhbCBwcm90b3R5cGVzIG1lYW50IGZvciBpbnRlcm5hbCB1c2Ugb25seQogICoKLSAqIENyZWF0ZWQ6ICAgICAgQXVnIDIwMDYKLSAqIERlc2NyaXB0aW9uOiAgTG9jYWwgcHJvdG90eXBlcyBtZWFudCBmb3IgaW50ZXJuYWwgdXNlIG9ubHkKKyAqIENvcHlyaWdodCAyMDA2LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIE1vZGlmaWVkOgotICogICAgICAgICAgICAgICBDb3B5cmlnaHQgMjAwNiBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2lmbmRlZiBfX0JMQUNLRklOX1NSQU1fSF9fCmRpZmYgLS1naXQgYS9hcmNoL2JsYWNrZmluL21tL2luaXQuYyBiL2FyY2gvYmxhY2tmaW4vbW0vaW5pdC5jCmluZGV4IGI4OGNlN2YuLmJiOWM5OGYgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbW0vaW5pdC5jCisrKyBiL2FyY2gvYmxhY2tmaW4vbW0vaW5pdC5jCkBAIC0xLDMwICsxLDcgQEAKIC8qCi0gKiBGaWxlOiAgICAgICAgIGFyY2gvYmxhY2tmaW4vbW0vaW5pdC5jCi0gKiBCYXNlZCBvbjoKLSAqIEF1dGhvcjoKKyAqIENvcHlyaWdodCAyMDA0LTIwMDkgQW5hbG9nIERldmljZXMgSW5jLgogICoKLSAqIENyZWF0ZWQ6Ci0gKiBEZXNjcmlwdGlvbjoKLSAqCi0gKiBNb2RpZmllZDoKLSAqICAgICAgICAgICAgICAgQ29weXJpZ2h0IDIwMDQtMjAwNyBBbmFsb2cgRGV2aWNlcyBJbmMuCi0gKgotICogQnVnczogICAgICAgICBFbnRlciBidWdzIGF0IGh0dHA6Ly9ibGFja2Zpbi51Y2xpbnV4Lm9yZy8KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKLSAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yCi0gKiAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgotICoKLSAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAotICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKLSAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCi0gKgotICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKLSAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSB0aGUgZmlsZSBDT1BZSU5HLCBvciB3cml0ZQotICogdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKLSAqIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSAgVVNBCisgKiBMaWNlbnNlZCB1bmRlciB0aGUgR1BMLTIgb3IgbGF0ZXIuCiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L3N3YXAuaD4KZGlmZiAtLWdpdCBhL2FyY2gvYmxhY2tmaW4vbW0vaXNyYW0tZHJpdmVyLmMgYi9hcmNoL2JsYWNrZmluL21tL2lzcmFtLWRyaXZlci5jCmluZGV4IGJlYjFhNjAuLjg0Y2RjNWEgMTAwNjQ0Ci0tLSBhL2FyY2gvYmxhY2tmaW4vbW0vaXNyYW0tZHJpdmVyLmMKKysrIGIvYXJjaC9ibGFja2Zpbi9tbS9pc3JhbS1kcml2ZXIuYwpAQCAtMSwxOSArMSw5IEBACiAvKgotICogRGVzY3JpcHRpb246IEluc3RydWN0aW9uIFNSQU0gYWNjZXNzb3IgZnVuY3Rpb25zIGZvciB0aGUgQmxhY2tmaW4KKyAqIEluc3RydWN0aW9uIFNSQU0gYWNjZXNzb3IgZnVuY3Rpb25zIGZvciB0aGUgQmxhY2tmaW4KICAqCiAgKiBDb3B5cmlnaHQgMjAwOCBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogQnVnczogRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQotICogYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgc2VlIHRoZSBmaWxlIENPUFlJTkcsIG9yIHdyaXRlCi0gKiB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAotICogNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BICAwMjExMC0xMzAxICBVU0EKKyAqIExpY2Vuc2VkIHVuZGVyIHRoZSBHUEwtMiBvciBsYXRlcgogICovCiAKICNkZWZpbmUgcHJfZm10KGZtdCkgImlzcmFtOiAiIGZtdApkaWZmIC0tZ2l0IGEvYXJjaC9ibGFja2Zpbi9tbS9zcmFtLWFsbG9jLmMgYi9hcmNoL2JsYWNrZmluL21tL3NyYW0tYWxsb2MuYwppbmRleCBlYjYzYWIzLi5mMDY4YzExIDEwMDY0NAotLS0gYS9hcmNoL2JsYWNrZmluL21tL3NyYW0tYWxsb2MuYworKysgYi9hcmNoL2JsYWNrZmluL21tL3NyYW0tYWxsb2MuYwpAQCAtMSwzMCArMSw5IEBACiAvKgotICogRmlsZTogICAgICAgICBhcmNoL2JsYWNrZmluL21tL3NyYW0tYWxsb2MuYwotICogQmFzZWQgb246Ci0gKiBBdXRob3I6CisgKiBTUkFNIGFsbG9jYXRvciBmb3IgQmxhY2tmaW4gb24tY2hpcCBtZW1vcnkKICAqCi0gKiBDcmVhdGVkOgotICogRGVzY3JpcHRpb246ICBTUkFNIGFsbG9jYXRvciBmb3IgQmxhY2tmaW4gTDEgYW5kIEwyIG1lbW9yeQorICogQ29weXJpZ2h0IDIwMDQtMjAwOSBBbmFsb2cgRGV2aWNlcyBJbmMuCiAgKgotICogTW9kaWZpZWQ6Ci0gKiAgICAgICAgICAgICAgIENvcHlyaWdodCAyMDA0LTIwMDggQW5hbG9nIERldmljZXMgSW5jLgotICoKLSAqIEJ1Z3M6ICAgICAgICAgRW50ZXIgYnVncyBhdCBodHRwOi8vYmxhY2tmaW4udWNsaW51eC5vcmcvCi0gKgotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgotICogKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KLSAqCi0gKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKLSAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCi0gKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCi0gKiBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotICoKLSAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0gKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCBzZWUgdGhlIGZpbGUgQ09QWUlORywgb3Igd3JpdGUKLSAqIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCi0gKiA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgIDAyMTEwLTEzMDEgIFVTQQorICogTGljZW5zZWQgdW5kZXIgdGhlIEdQTC0yIG9yIGxhdGVyLgogICovCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KZGlmZiAtLWdpdCBhL2FyY2gvZnJ2L2tlcm5lbC9zaWduYWwuYyBiL2FyY2gvZnJ2L2tlcm5lbC9zaWduYWwuYwppbmRleCA2YjBhMmI2Li4wOTc0YzBlIDEwMDY0NAotLS0gYS9hcmNoL2Zydi9rZXJuZWwvc2lnbmFsLmMKKysrIGIvYXJjaC9mcnYva2VybmVsL3NpZ25hbC5jCkBAIC01MjcsNyArNTI3LDcgQEAKIAogbm9fc2lnbmFsOgogCS8qIERpZCB3ZSBjb21lIGZyb20gYSBzeXN0ZW0gY2FsbD8gKi8KLQlpZiAoX19mcmFtZS0+c3lzY2FsbG5vID49IDApIHsKKwlpZiAoX19mcmFtZS0+c3lzY2FsbG5vICE9IC0xKSB7CiAJCS8qIFJlc3RhcnQgdGhlIHN5c3RlbSBjYWxsIC0gbm8gaGFuZGxlcnMgcHJlc2VudCAqLwogCQlzd2l0Y2ggKF9fZnJhbWUtPmdyOCkgewogCQljYXNlIC1FUkVTVEFSVE5PSEFORDoKZGlmZiAtLWdpdCBhL2FyY2gvbTMyci9rZXJuZWwvc21wLmMgYi9hcmNoL20zMnIva2VybmVsL3NtcC5jCmluZGV4IDFiNzU5OGUuLjhhODhmMWYgMTAwNjQ0Ci0tLSBhL2FyY2gvbTMyci9rZXJuZWwvc21wLmMKKysrIGIvYXJjaC9tMzJyL2tlcm5lbC9zbXAuYwpAQCAtMTcsNiArMTcsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvaXJxLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvc21wLmg+CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvaW5jbHVkZS9hc20vZmlybXdhcmUuaCBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9maXJtd2FyZS5oCmluZGV4IDNhMTc5ODIuLjIwNzc4YTQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9maXJtd2FyZS5oCisrKyBiL2FyY2gvcG93ZXJwYy9pbmNsdWRlL2FzbS9maXJtd2FyZS5oCkBAIC0zNyw3ICszNyw3IEBACiAjZGVmaW5lIEZXX0ZFQVRVUkVfVklPCQlBU01fQ09OU1QoMHgwMDAwMDAwMDAwMDA0MDAwKQogI2RlZmluZSBGV19GRUFUVVJFX1JETUEJCUFTTV9DT05TVCgweDAwMDAwMDAwMDAwMDgwMDApCiAjZGVmaW5lIEZXX0ZFQVRVUkVfTExBTgkJQVNNX0NPTlNUKDB4MDAwMDAwMDAwMDAxMDAwMCkKLSNkZWZpbmUgRldfRkVBVFVSRV9CVUxLCQlBU01fQ09OU1QoMHgwMDAwMDAwMDAwMDIwMDAwKQorI2RlZmluZSBGV19GRUFUVVJFX0JVTEtfUkVNT1ZFCUFTTV9DT05TVCgweDAwMDAwMDAwMDAwMjAwMDApCiAjZGVmaW5lIEZXX0ZFQVRVUkVfWERBQlIJQVNNX0NPTlNUKDB4MDAwMDAwMDAwMDA0MDAwMCkKICNkZWZpbmUgRldfRkVBVFVSRV9NVUxUSVRDRQlBU01fQ09OU1QoMHgwMDAwMDAwMDAwMDgwMDAwKQogI2RlZmluZSBGV19GRUFUVVJFX1NQTFBBUglBU01fQ09OU1QoMHgwMDAwMDAwMDAwMTAwMDAwKQpAQCAtNDUsOCArNDUsNyBAQAogI2RlZmluZSBGV19GRUFUVVJFX0xQQVIJCUFTTV9DT05TVCgweDAwMDAwMDAwMDA0MDAwMDApCiAjZGVmaW5lIEZXX0ZFQVRVUkVfUFMzX0xWMQlBU01fQ09OU1QoMHgwMDAwMDAwMDAwODAwMDAwKQogI2RlZmluZSBGV19GRUFUVVJFX0JFQVQJCUFTTV9DT05TVCgweDAwMDAwMDAwMDEwMDAwMDApCi0jZGVmaW5lIEZXX0ZFQVRVUkVfQlVMS19SRU1PVkUJQVNNX0NPTlNUKDB4MDAwMDAwMDAwMjAwMDAwMCkKLSNkZWZpbmUgRldfRkVBVFVSRV9DTU8JCUFTTV9DT05TVCgweDAwMDAwMDAwMDQwMDAwMDApCisjZGVmaW5lIEZXX0ZFQVRVUkVfQ01PCQlBU01fQ09OU1QoMHgwMDAwMDAwMDAyMDAwMDAwKQogCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogCkBAIC01OCw4ICs1Nyw5IEBACiAJCUZXX0ZFQVRVUkVfUEVSRiB8IEZXX0ZFQVRVUkVfRFVNUCB8IEZXX0ZFQVRVUkVfSU5URVJSVVBUIHwKIAkJRldfRkVBVFVSRV9NSUdSQVRFIHwgRldfRkVBVFVSRV9QRVJGTU9OIHwgRldfRkVBVFVSRV9DUlEgfAogCQlGV19GRUFUVVJFX1ZJTyB8IEZXX0ZFQVRVUkVfUkRNQSB8IEZXX0ZFQVRVUkVfTExBTiB8Ci0JCUZXX0ZFQVRVUkVfQlVMSyB8IEZXX0ZFQVRVUkVfWERBQlIgfCBGV19GRUFUVVJFX01VTFRJVENFIHwKLQkJRldfRkVBVFVSRV9TUExQQVIgfCBGV19GRUFUVVJFX0xQQVIgfCBGV19GRUFUVVJFX0NNTywKKwkJRldfRkVBVFVSRV9CVUxLX1JFTU9WRSB8IEZXX0ZFQVRVUkVfWERBQlIgfAorCQlGV19GRUFUVVJFX01VTFRJVENFIHwgRldfRkVBVFVSRV9TUExQQVIgfCBGV19GRUFUVVJFX0xQQVIgfAorCQlGV19GRUFUVVJFX0NNTywKIAlGV19GRUFUVVJFX1BTRVJJRVNfQUxXQVlTID0gMCwKIAlGV19GRUFUVVJFX0lTRVJJRVNfUE9TU0lCTEUgPSBGV19GRUFUVVJFX0lTRVJJRVMgfCBGV19GRUFUVVJFX0xQQVIsCiAJRldfRkVBVFVSRV9JU0VSSUVTX0FMV0FZUyA9IEZXX0ZFQVRVUkVfSVNFUklFUyB8IEZXX0ZFQVRVUkVfTFBBUiwKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3B1dGFibGUuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvY3B1dGFibGUuYwppbmRleCAwYjljOTEzLi4wM2M4NjJiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL2NwdXRhYmxlLmMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9jcHV0YWJsZS5jCkBAIC03MTEsNiArNzExLDggQEAKIAkJLmNwdV9zZXR1cAkJPSBfX3NldHVwX2NwdV83NTAsCiAJCS5tYWNoaW5lX2NoZWNrCQk9IG1hY2hpbmVfY2hlY2tfZ2VuZXJpYywKIAkJLnBsYXRmb3JtCQk9ICJwcGM3NTAiLAorCQkub3Byb2ZpbGVfY3B1X3R5cGUgICAgICA9ICJwcGMvNzUwIiwKKwkJLm9wcm9maWxlX3R5cGUJCT0gUFBDX09QUk9GSUxFX0c0LAogCX0sCiAJewkvKiA3NDUvNzU1ICovCiAJCS5wdnJfbWFzawkJPSAweGZmZmZmMDAwLApkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL2tlcm5lbC9lbnRyeV82NC5TIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC9lbnRyeV82NC5TCmluZGV4IDkwMGUwZWUuLmY5ZmQ1NGIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvZW50cnlfNjQuUworKysgYi9hcmNoL3Bvd2VycGMva2VybmVsL2VudHJ5XzY0LlMKQEAgLTEwMzgsOCArMTAzOCw3IEBACiAJICogV2UgYXJlIGluIGEgbW9kdWxlIHVzaW5nIHRoZSBtb2R1bGUncyBUT0MuCiAJICogU3dpdGNoIHRvIG91ciBUT0MgdG8gcnVuIGluc2lkZSB0aGUgY29yZSBrZXJuZWwuCiAJICovCi0JTE9BRF9SRUdfSU1NRURJQVRFKHI0LGZ0cmFjZV9yZXR1cm5fdG9faGFuZGxlcikKLQlsZAlyMiwgOChyNCkKKwlsZAlyMiwgUEFDQVRPQyhyMTMpCiAKIAlibAkuZnRyYWNlX3JldHVybl90b19oYW5kbGVyCiAJbm9wCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL2tnZGIuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwva2dkYi5jCmluZGV4IGZlOGY3MWQuLjY0MWM3NGIgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwva2dkYi5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwva2dkYi5jCkBAIC0yODIsMTIgKzI4Miw2IEBACiB7CiAJdW5zaWduZWQgbG9uZyAqcHRyID0gZ2RiX3JlZ3M7CiAJaW50IHJlZzsKLSNpZmRlZiBDT05GSUdfU1BFCi0JdW5pb24gewotCQl1MzIgdjMyWzJdOwotCQl1NjQgdjY0OwotCX0gYWNjOwotI2VuZGlmCiAKIAlmb3IgKHJlZyA9IDA7IHJlZyA8IDMyOyByZWcrKykKIAkJVU5QQUNLNjQocmVncy0+Z3ByW3JlZ10sIHB0cik7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3BjaS1jb21tb24uYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGNpLWNvbW1vbi5jCmluZGV4IGJiODIwOWUuLmU4ZGZkYmQgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGNpLWNvbW1vbi5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcGNpLWNvbW1vbi5jCkBAIC0xMTkwLDcgKzExOTAsNyBAQAogICogUmVwYXJlbnQgcmVzb3VyY2UgY2hpbGRyZW4gb2YgcHIgdGhhdCBjb25mbGljdCB3aXRoIHJlcwogICogdW5kZXIgcmVzLCBhbmQgbWFrZSByZXMgcmVwbGFjZSB0aG9zZSBjaGlsZHJlbi4KICAqLwotc3RhdGljIGludCBfX2luaXQgcmVwYXJlbnRfcmVzb3VyY2VzKHN0cnVjdCByZXNvdXJjZSAqcGFyZW50LAorc3RhdGljIGludCByZXBhcmVudF9yZXNvdXJjZXMoc3RydWN0IHJlc291cmNlICpwYXJlbnQsCiAJCQkJICAgICBzdHJ1Y3QgcmVzb3VyY2UgKnJlcykKIHsKIAlzdHJ1Y3QgcmVzb3VyY2UgKnAsICoqcHA7CmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMva2VybmVsL3Byb2Nlc3MuYyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcHJvY2Vzcy5jCmluZGV4IDExNjhjNWYuLjJlYzFlYWUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvcHJvY2Vzcy5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvcHJvY2Vzcy5jCkBAIC0xMDE2LDkgKzEwMTYsMTMgQEAKICNpZmRlZiBDT05GSUdfRlVOQ1RJT05fR1JBUEhfVFJBQ0VSCiAJaW50IGN1cnJfZnJhbWUgPSBjdXJyZW50LT5jdXJyX3JldF9zdGFjazsKIAlleHRlcm4gdm9pZCByZXR1cm5fdG9faGFuZGxlcih2b2lkKTsKLQl1bnNpZ25lZCBsb25nIGFkZHIgPSAodW5zaWduZWQgbG9uZylyZXR1cm5fdG9faGFuZGxlcjsKKwl1bnNpZ25lZCBsb25nIHJ0aCA9ICh1bnNpZ25lZCBsb25nKXJldHVybl90b19oYW5kbGVyOworCXVuc2lnbmVkIGxvbmcgbXJ0aCA9IC0xOwogI2lmZGVmIENPTkZJR19QUEM2NAotCWFkZHIgPSAqKHVuc2lnbmVkIGxvbmcqKWFkZHI7CisJZXh0ZXJuIHZvaWQgbW9kX3JldHVybl90b19oYW5kbGVyKHZvaWQpOworCXJ0aCA9ICoodW5zaWduZWQgbG9uZyAqKXJ0aDsKKwltcnRoID0gKHVuc2lnbmVkIGxvbmcpbW9kX3JldHVybl90b19oYW5kbGVyOworCW1ydGggPSAqKHVuc2lnbmVkIGxvbmcgKiltcnRoOwogI2VuZGlmCiAjZW5kaWYKIApAQCAtMTA0NCw3ICsxMDQ4LDcgQEAKIAkJaWYgKCFmaXJzdGZyYW1lIHx8IGlwICE9IGxyKSB7CiAJCQlwcmludGsoIlsiUkVHIl0gWyJSRUciXSAlcFMiLCBzcCwgaXAsICh2b2lkICopaXApOwogI2lmZGVmIENPTkZJR19GVU5DVElPTl9HUkFQSF9UUkFDRVIKLQkJCWlmIChpcCA9PSBhZGRyICYmIGN1cnJfZnJhbWUgPj0gMCkgeworCQkJaWYgKChpcCA9PSBydGggfHwgaXAgPT0gbXJ0aCkgJiYgY3Vycl9mcmFtZSA+PSAwKSB7CiAJCQkJcHJpbnRrKCIgKCVwUykiLAogCQkJCSAgICAgICAodm9pZCAqKWN1cnJlbnQtPnJldF9zdGFja1tjdXJyX2ZyYW1lXS5yZXQpOwogCQkJCWN1cnJfZnJhbWUtLTsKZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvdm1saW51eC5sZHMuUyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwvdm1saW51eC5sZHMuUwppbmRleCBmNTY0MjkzLi4yNzczNWE3IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMva2VybmVsL3ZtbGludXgubGRzLlMKKysrIGIvYXJjaC9wb3dlcnBjL2tlcm5lbC92bWxpbnV4Lmxkcy5TCkBAIC0yMzYsNiArMjM2LDcgQEAKIAkJUkVBRF9NT1NUTFlfREFUQShMMV9DQUNIRV9CWVRFUykKIAl9CiAKKwkuID0gQUxJR04oUEFHRV9TSVpFKTsKIAkuZGF0YV9ub3NhdmUgOiBBVChBRERSKC5kYXRhX25vc2F2ZSkgLSBMT0FEX09GRlNFVCkgewogCQlOT1NBVkVfREFUQQogCX0KZGlmZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9tbS9zbGJfbG93LlMgYi9hcmNoL3Bvd2VycGMvbW0vc2xiX2xvdy5TCmluZGV4IGJjNDRkYzQuLjk1Y2UzNTUgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9tbS9zbGJfbG93LlMKKysrIGIvYXJjaC9wb3dlcnBjL21tL3NsYl9sb3cuUwpAQCAtNzIsMTkgKzcyLDE3IEBACiAxOgogI2VuZGlmIC8qIENPTkZJR19TUEFSU0VNRU1fVk1FTU1BUCAqLwogCi0JLyogdm1hbGxvYy9pb3JlbWFwIG1hcHBpbmcgZW5jb2RpbmcgYml0cywgdGhlICJsaSIgaW5zdHJ1Y3Rpb25zIGJlbG93Ci0JICogd2lsbCBiZSBwYXRjaGVkIGJ5IHRoZSBrZXJuZWwgYXQgYm9vdAorCS8qIHZtYWxsb2MgbWFwcGluZyBnZXRzIHRoZSBlbmNvZGluZyBmcm9tIHRoZSBQQUNBIGFzIHRoZSBtYXBwaW5nCisJICogY2FuIGJlIGRlbW90ZWQgZnJvbSA2NEsgLT4gNEsgZHluYW1pY2FsbHkgb24gc29tZSBtYWNoaW5lcwogCSAqLwotQkVHSU5fRlRSX1NFQ1RJT04KLQkvKiBjaGVjayB3aGV0aGVyIHRoaXMgaXMgaW4gdm1hbGxvYyBvciBpb3JlbWFwIHNwYWNlICovCiAJY2xybGRpCXIxMSxyMTAsNDgKIAljbXBsZGkJcjExLChWTUFMTE9DX1NJWkUgPj4gMjgpIC0gMQogCWJndAk1ZgogCWxoeglyMTEsUEFDQVZNQUxMT0NTTExQKHIxMykKIAliCTZmCiA1OgotRU5EX0ZUUl9TRUNUSU9OX0lGQ0xSKENQVV9GVFJfQ0lfTEFSR0VfUEFHRSkKLV9HTE9CQUwoc2xiX21pc3Nfa2VybmVsX2xvYWRfaW8pCisJLyogSU8gbWFwcGluZyAqLworCV9HTE9CQUwoc2xiX21pc3Nfa2VybmVsX2xvYWRfaW8pCiAJbGkJcjExLDAKIDY6CiBCRUdJTl9GVFJfU0VDVElPTgpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9jZWxsL2F4b25fbXNpLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvYXhvbl9tc2kuYwppbmRleCBhY2E1NzQxLi5hODZjMzRiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvYXhvbl9tc2kuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL2NlbGwvYXhvbl9tc2kuYwpAQCAtMzY1LDcgKzM2NSw3IEBACiAJCXByaW50ayhLRVJOX0VSUgogCQkgICAgICAgImF4b25fbXNpOiBjb3VsZG4ndCBwYXJzZSBkY3IgcHJvcGVydGllcyBvbiAlc1xuIiwKIAkJCWRuLT5mdWxsX25hbWUpOwotCQlnb3RvIG91dDsKKwkJZ290byBvdXRfZnJlZV9tc2ljOwogCX0KIAogCW1zaWMtPmRjcl9ob3N0ID0gZGNyX21hcChkbiwgZGNyX2Jhc2UsIGRjcl9sZW4pOwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL3BsYXRmb3Jtcy9wb3dlcm1hYy9sb3dfaTJjLmMgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL2xvd19pMmMuYwppbmRleCAyMTIyNmI3Li40MTRjYTk4IDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL2xvd19pMmMuYworKysgYi9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3Bvd2VybWFjL2xvd19pMmMuYwpAQCAtNTQwLDggKzU0MCwxMSBAQAogCS8qIE1ha2Ugc3VyZSBJUlEgaXMgZGlzYWJsZWQgKi8KIAlrd193cml0ZV9yZWcocmVnX2llciwgMCk7CiAKLQkvKiBSZXF1ZXN0IGNoaXAgaW50ZXJydXB0ICovCi0JaWYgKHJlcXVlc3RfaXJxKGhvc3QtPmlycSwga3dfaTJjX2lycSwgMCwgImtleXdlc3QgaTJjIiwgaG9zdCkpCisJLyogUmVxdWVzdCBjaGlwIGludGVycnVwdC4gV2Ugc2V0IElSUUZfVElNRVIgYmVjYXVzZSB3ZSBkb24ndAorCSAqIHdhbnQgdGhhdCBpbnRlcnJ1cHQgZGlzYWJsZWQgYmV0d2VlbiB0aGUgMiBwYXNzZXMgb2YgZHJpdmVyCisJICogc3VzcGVuZCBvciB3ZSdsbCBoYXZlIGlzc3VlcyBydW5uaW5nIHRoZSBwZnVuY3MKKwkgKi8KKwlpZiAocmVxdWVzdF9pcnEoaG9zdC0+aXJxLCBrd19pMmNfaXJxLCBJUlFGX1RJTUVSLCAia2V5d2VzdCBpMmMiLCBob3N0KSkKIAkJaG9zdC0+aXJxID0gTk9fSVJROwogCiAJcHJpbnRrKEtFUk5fSU5GTyAiS2V5V2VzdCBpMmMgQDB4JTA4eCBpcnEgJWQgJXNcbiIsCmRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvcGxhdGZvcm1zL3BzZXJpZXMvZmlybXdhcmUuYyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9maXJtd2FyZS5jCmluZGV4IDVhNzA3ZGEuLjBhMTRkOGMgMTAwNjQ0Ci0tLSBhL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9maXJtd2FyZS5jCisrKyBiL2FyY2gvcG93ZXJwYy9wbGF0Zm9ybXMvcHNlcmllcy9maXJtd2FyZS5jCkBAIC01MSwxMSArNTEsMTAgQEAKIAl7RldfRkVBVFVSRV9WSU8sCQkiaGNhbGwtdmlvIn0sCiAJe0ZXX0ZFQVRVUkVfUkRNQSwJCSJoY2FsbC1yZG1hIn0sCiAJe0ZXX0ZFQVRVUkVfTExBTiwJCSJoY2FsbC1sTEFOIn0sCi0Je0ZXX0ZFQVRVUkVfQlVMSywJCSJoY2FsbC1idWxrIn0sCisJe0ZXX0ZFQVRVUkVfQlVMS19SRU1PVkUsCSJoY2FsbC1idWxrIn0sCiAJe0ZXX0ZFQVRVUkVfWERBQlIsCQkiaGNhbGwteGRhYnIifSwKIAl7RldfRkVBVFVSRV9NVUxUSVRDRSwJCSJoY2FsbC1tdWx0aS10Y2UifSwKIAl7RldfRkVBVFVSRV9TUExQQVIsCQkiaGNhbGwtc3BscGFyIn0sCi0Je0ZXX0ZFQVRVUkVfQlVMS19SRU1PVkUsCSJoY2FsbC1idWxrIn0sCiB9OwogCiAvKiBCdWlsZCB1cCB0aGUgZmlybXdhcmUgZmVhdHVyZXMgYml0bWFzayB1c2luZyB0aGUgY29udGVudHMgb2YKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9oeXBmcy9oeXBmc19kaWFnLmMgYi9hcmNoL3MzOTAvaHlwZnMvaHlwZnNfZGlhZy5jCmluZGV4IDcwNGRkMzkuLjc3ZGY3MjYgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9oeXBmcy9oeXBmc19kaWFnLmMKKysrIGIvYXJjaC9zMzkwL2h5cGZzL2h5cGZzX2RpYWcuYwpAQCAtNDM4LDcgKzQzOCw3IEBACiAJCX0KIAkJaWYgKGRpYWcyMDQoKHVuc2lnbmVkIGxvbmcpU1VCQ19TVElCNiB8CiAJCQkgICAgKHVuc2lnbmVkIGxvbmcpSU5GT19FWFQsIHBhZ2VzLCBidWYpID49IDApIHsKLQkJCWRpYWcyMDRfc3RvcmVfc2MgPSBTVUJDX1NUSUI3OworCQkJZGlhZzIwNF9zdG9yZV9zYyA9IFNVQkNfU1RJQjY7CiAJCQlkaWFnMjA0X2luZm9fdHlwZSA9IElORk9fRVhUOwogCQkJZ290byBvdXQ7CiAJCX0KZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9kZWxheS5oIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2RlbGF5LmgKaW5kZXggYTM1NmM5NS4uOGEwOTZiOCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2RlbGF5LmgKKysrIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2RlbGF5LmgKQEAgLTE0LDEwICsxNCwxMSBAQAogI2lmbmRlZiBfUzM5MF9ERUxBWV9ICiAjZGVmaW5lIF9TMzkwX0RFTEFZX0gKIAotZXh0ZXJuIHZvaWQgX191ZGVsYXkodW5zaWduZWQgbG9uZyB1c2Vjcyk7Ci1leHRlcm4gdm9pZCB1ZGVsYXlfc2ltcGxlKHVuc2lnbmVkIGxvbmcgdXNlY3MpOworZXh0ZXJuIHZvaWQgX191ZGVsYXkodW5zaWduZWQgbG9uZyBsb25nIHVzZWNzKTsKK2V4dGVybiB2b2lkIHVkZWxheV9zaW1wbGUodW5zaWduZWQgbG9uZyBsb25nIHVzZWNzKTsKIGV4dGVybiB2b2lkIF9fZGVsYXkodW5zaWduZWQgbG9uZyBsb29wcyk7CiAKLSNkZWZpbmUgdWRlbGF5KG4pIF9fdWRlbGF5KG4pCisjZGVmaW5lIHVkZWxheShuKSBfX3VkZWxheSgodW5zaWduZWQgbG9uZyBsb25nKSAobikpCisjZGVmaW5lIG1kZWxheShuKSBfX3VkZWxheSgodW5zaWduZWQgbG9uZyBsb25nKSAobikgKiAxMDAwKQogCiAjZW5kaWYgLyogZGVmaW5lZChfUzM5MF9ERUxBWV9IKSAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2VsZi5oIGIvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL2VsZi5oCmluZGV4IDc0ZDBiYmIuLmU4ODU0NDIgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9lbGYuaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vZWxmLmgKQEAgLTkyLDYgKzkyLDE4IEBACiAvKiBLZWVwIHRoaXMgdGhlIGxhc3QgZW50cnkuICAqLwogI2RlZmluZSBSXzM5MF9OVU0JNjEKIAorLyogQml0cyBwcmVzZW50IGluIEFUX0hXQ0FQLiAqLworI2RlZmluZSBIV0NBUF9TMzkwX0VTQU4zCTEKKyNkZWZpbmUgSFdDQVBfUzM5MF9aQVJDSAkyCisjZGVmaW5lIEhXQ0FQX1MzOTBfU1RGTEUJNAorI2RlZmluZSBIV0NBUF9TMzkwX01TQQkJOAorI2RlZmluZSBIV0NBUF9TMzkwX0xESVNQCTE2CisjZGVmaW5lIEhXQ0FQX1MzOTBfRUlNTQkJMzIKKyNkZWZpbmUgSFdDQVBfUzM5MF9ERlAJCTY0CisjZGVmaW5lIEhXQ0FQX1MzOTBfSFBBR0UJMTI4CisjZGVmaW5lIEhXQ0FQX1MzOTBfRVRGM0VICTI1NgorI2RlZmluZSBIV0NBUF9TMzkwX0hJR0hfR1BSUwk1MTIKKwogLyoKICAqIFRoZXNlIGFyZSB1c2VkIHRvIHNldCBwYXJhbWV0ZXJzIGluIHRoZSBjb3JlIGR1bXBzLgogICovCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vcHRyYWNlLmggYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vcHRyYWNlLmgKaW5kZXggNTM5MjYzZi4uOTVkY2YxOCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL3B0cmFjZS5oCisrKyBiL2FyY2gvczM5MC9pbmNsdWRlL2FzbS9wdHJhY2UuaApAQCAtMzExLDYgKzMxMSwxMCBAQAogCV9fdTMyCQlvcmlnX2dwcjI7CiB9IHMzOTBfY29tcGF0X3JlZ3M7CiAKK3R5cGVkZWYgc3RydWN0Cit7CisJX191MzIJCWdwcnNfaGlnaFtOVU1fR1BSU107Cit9IHMzOTBfY29tcGF0X3JlZ3NfaGlnaDsKIAogI2lmZGVmIF9fS0VSTkVMX18KIApkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2luY2x1ZGUvYXNtL3Vjb250ZXh0LmggYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vdWNvbnRleHQuaAppbmRleCBkNjliZWMwLi5jZmI4NzRlIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvaW5jbHVkZS9hc20vdWNvbnRleHQuaAorKysgYi9hcmNoL3MzOTAvaW5jbHVkZS9hc20vdWNvbnRleHQuaApAQCAtOSw2ICs5LDIxIEBACiAjaWZuZGVmIF9BU01fUzM5MF9VQ09OVEVYVF9ICiAjZGVmaW5lIF9BU01fUzM5MF9VQ09OVEVYVF9ICiAKKyNkZWZpbmUgVUNfRVhURU5ERUQJMHgwMDAwMDAwMQorCisjaWZuZGVmIF9fczM5MHhfXworCitzdHJ1Y3QgdWNvbnRleHRfZXh0ZW5kZWQgeworCXVuc2lnbmVkIGxvbmcJICB1Y19mbGFnczsKKwlzdHJ1Y3QgdWNvbnRleHQgICp1Y19saW5rOworCXN0YWNrX3QJCSAgdWNfc3RhY2s7CisJX3NpZ3JlZ3MJICB1Y19tY29udGV4dDsKKwl1bnNpZ25lZCBsb25nCSAgdWNfc2lnbWFza1syXTsKKwl1bnNpZ25lZCBsb25nCSAgdWNfZ3Byc19oaWdoWzE2XTsKK307CisKKyNlbmRpZgorCiBzdHJ1Y3QgdWNvbnRleHQgewogCXVuc2lnbmVkIGxvbmcJICB1Y19mbGFnczsKIAlzdHJ1Y3QgdWNvbnRleHQgICp1Y19saW5rOwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2tlcm5lbC9jb21wYXRfc2lnbmFsLmMgYi9hcmNoL3MzOTAva2VybmVsL2NvbXBhdF9zaWduYWwuYwppbmRleCBiNTM3Y2IwLi5lZWU5OTk4IDEwMDY0NAotLS0gYS9hcmNoL3MzOTAva2VybmVsL2NvbXBhdF9zaWduYWwuYworKysgYi9hcmNoL3MzOTAva2VybmVsL2NvbXBhdF9zaWduYWwuYwpAQCAtMzksNiArMzksNyBAQAogCXN0cnVjdCBzaWdjb250ZXh0MzIgc2M7CiAJX3NpZ3JlZ3MzMiBzcmVnczsKIAlpbnQgc2lnbm87CisJX191MzIgZ3Byc19oaWdoW05VTV9HUFJTXTsKIAlfX3U4IHJldGNvZGVbUzM5MF9TWVNDQUxMX1NJWkVdOwogfSBzaWdmcmFtZTMyOwogCkBAIC00OCw2ICs0OSw3IEBACiAJX191OCByZXRjb2RlW1MzOTBfU1lTQ0FMTF9TSVpFXTsKIAljb21wYXRfc2lnaW5mb190IGluZm87CiAJc3RydWN0IHVjb250ZXh0MzIgdWM7CisJX191MzIgZ3Byc19oaWdoW05VTV9HUFJTXTsKIH0gcnRfc2lnZnJhbWUzMjsKIAogaW50IGNvcHlfc2lnaW5mb190b191c2VyMzIoY29tcGF0X3NpZ2luZm9fdCBfX3VzZXIgKnRvLCBzaWdpbmZvX3QgKmZyb20pCkBAIC0zNDQsNiArMzQ2LDMwIEBACiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBpbnQgc2F2ZV9zaWdyZWdzX2dwcnNfaGlnaChzdHJ1Y3QgcHRfcmVncyAqcmVncywgX191MzIgX191c2VyICp1cmVncykKK3sKKwlfX3UzMiBncHJzX2hpZ2hbTlVNX0dQUlNdOworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IE5VTV9HUFJTOyBpKyspCisJCWdwcnNfaGlnaFtpXSA9IHJlZ3MtPmdwcnNbaV0gPj4gMzI7CisKKwlyZXR1cm4gX19jb3B5X3RvX3VzZXIodXJlZ3MsICZncHJzX2hpZ2gsIHNpemVvZihncHJzX2hpZ2gpKTsKK30KKworc3RhdGljIGludCByZXN0b3JlX3NpZ3JlZ3NfZ3Byc19oaWdoKHN0cnVjdCBwdF9yZWdzICpyZWdzLCBfX3UzMiBfX3VzZXIgKnVyZWdzKQoreworCV9fdTMyIGdwcnNfaGlnaFtOVU1fR1BSU107CisJaW50IGVyciwgaTsKKworCWVyciA9IF9fY29weV9mcm9tX3VzZXIoJmdwcnNfaGlnaCwgdXJlZ3MsIHNpemVvZihncHJzX2hpZ2gpKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCWZvciAoaSA9IDA7IGkgPCBOVU1fR1BSUzsgaSsrKQorCQkqKF9fdTMyICopJnJlZ3MtPmdwcnNbaV0gPSBncHJzX2hpZ2hbaV07CisJcmV0dXJuIDA7Cit9CisKIGFzbWxpbmthZ2UgbG9uZyBzeXMzMl9zaWdyZXR1cm4odm9pZCkKIHsKIAlzdHJ1Y3QgcHRfcmVncyAqcmVncyA9IHRhc2tfcHRfcmVncyhjdXJyZW50KTsKQEAgLTM2Myw2ICszODksOCBAQAogCiAJaWYgKHJlc3RvcmVfc2lncmVnczMyKHJlZ3MsICZmcmFtZS0+c3JlZ3MpKQogCQlnb3RvIGJhZGZyYW1lOworCWlmIChyZXN0b3JlX3NpZ3JlZ3NfZ3Byc19oaWdoKHJlZ3MsIGZyYW1lLT5ncHJzX2hpZ2gpKQorCQlnb3RvIGJhZGZyYW1lOwogCiAJcmV0dXJuIHJlZ3MtPmdwcnNbMl07CiAKQEAgLTM5NCw2ICs0MjIsOCBAQAogCiAJaWYgKHJlc3RvcmVfc2lncmVnczMyKHJlZ3MsICZmcmFtZS0+dWMudWNfbWNvbnRleHQpKQogCQlnb3RvIGJhZGZyYW1lOworCWlmIChyZXN0b3JlX3NpZ3JlZ3NfZ3Byc19oaWdoKHJlZ3MsIGZyYW1lLT5ncHJzX2hpZ2gpKQorCQlnb3RvIGJhZGZyYW1lOwogCiAJZXJyID0gX19nZXRfdXNlcihzc19zcCwgJmZyYW1lLT51Yy51Y19zdGFjay5zc19zcCk7CiAJc3Quc3Nfc3AgPSBjb21wYXRfcHRyKHNzX3NwKTsKQEAgLTQ3NCw2ICs1MDQsOCBAQAogCiAJaWYgKHNhdmVfc2lncmVnczMyKHJlZ3MsICZmcmFtZS0+c3JlZ3MpKQogCQlnb3RvIGdpdmVfc2lnc2VndjsKKwlpZiAoc2F2ZV9zaWdyZWdzX2dwcnNfaGlnaChyZWdzLCBmcmFtZS0+Z3Byc19oaWdoKSkKKwkJZ290byBnaXZlX3NpZ3NlZ3Y7CiAJaWYgKF9fcHV0X3VzZXIoKHVuc2lnbmVkIGxvbmcpICZmcmFtZS0+c3JlZ3MsICZmcmFtZS0+c2Muc3JlZ3MpKQogCQlnb3RvIGdpdmVfc2lnc2VndjsKIApAQCAtNTI5LDEzICs1NjEsMTQgQEAKIAkJZ290byBnaXZlX3NpZ3NlZ3Y7CiAKIAkvKiBDcmVhdGUgdGhlIHVjb250ZXh0LiAgKi8KLQllcnIgfD0gX19wdXRfdXNlcigwLCAmZnJhbWUtPnVjLnVjX2ZsYWdzKTsKKwllcnIgfD0gX19wdXRfdXNlcihVQ19FWFRFTkRFRCwgJmZyYW1lLT51Yy51Y19mbGFncyk7CiAJZXJyIHw9IF9fcHV0X3VzZXIoMCwgJmZyYW1lLT51Yy51Y19saW5rKTsKIAllcnIgfD0gX19wdXRfdXNlcihjdXJyZW50LT5zYXNfc3Nfc3AsICZmcmFtZS0+dWMudWNfc3RhY2suc3Nfc3ApOwogCWVyciB8PSBfX3B1dF91c2VyKHNhc19zc19mbGFncyhyZWdzLT5ncHJzWzE1XSksCiAJICAgICAgICAgICAgICAgICAgJmZyYW1lLT51Yy51Y19zdGFjay5zc19mbGFncyk7CiAJZXJyIHw9IF9fcHV0X3VzZXIoY3VycmVudC0+c2FzX3NzX3NpemUsICZmcmFtZS0+dWMudWNfc3RhY2suc3Nfc2l6ZSk7CiAJZXJyIHw9IHNhdmVfc2lncmVnczMyKHJlZ3MsICZmcmFtZS0+dWMudWNfbWNvbnRleHQpOworCWVyciB8PSBzYXZlX3NpZ3JlZ3NfZ3Byc19oaWdoKHJlZ3MsIGZyYW1lLT5ncHJzX2hpZ2gpOwogCWVyciB8PSBfX2NvcHlfdG9fdXNlcigmZnJhbWUtPnVjLnVjX3NpZ21hc2ssIHNldCwgc2l6ZW9mKCpzZXQpKTsKIAlpZiAoZXJyKQogCQlnb3RvIGdpdmVfc2lnc2VndjsKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvY29tcGF0X3dyYXBwZXIuUyBiL2FyY2gvczM5MC9rZXJuZWwvY29tcGF0X3dyYXBwZXIuUwppbmRleCA2ODJmYjY5Li5jYmQ5OTAxIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAva2VybmVsL2NvbXBhdF93cmFwcGVyLlMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9jb21wYXRfd3JhcHBlci5TCkBAIC00MDksNyArNDA5LDcgQEAKIAkuZ2xvYmwJc3lzMzJfdHJ1bmNhdGVfd3JhcHBlcgogc3lzMzJfdHJ1bmNhdGVfd3JhcHBlcjoKIAlsbGd0cgklcjIsJXIyCQkJIyBjb25zdCBjaGFyICoKLQlsbGdmcgklcjMsJXIzCQkJIyB1bnNpZ25lZCBsb25nCisJbGdmcgklcjMsJXIzCQkJIyBsb25nCiAJamcJc3lzX3RydW5jYXRlCQkjIGJyYW5jaCB0byBzeXN0ZW0gY2FsbAogCiAJLmdsb2JsCXN5czMyX2Z0cnVuY2F0ZV93cmFwcGVyCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAva2VybmVsL2Z0cmFjZS5jIGIvYXJjaC9zMzkwL2tlcm5lbC9mdHJhY2UuYwppbmRleCA1N2JkY2IxLi5mNWZlMzRkIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAva2VybmVsL2Z0cmFjZS5jCisrKyBiL2FyY2gvczM5MC9rZXJuZWwvZnRyYWNlLmMKQEAgLTE4NSw5ICsxODUsNiBAQAogewogCXN0cnVjdCBmdHJhY2VfZ3JhcGhfZW50IHRyYWNlOwogCi0JLyogTm1pJ3MgYXJlIGN1cnJlbnRseSB1bnN1cHBvcnRlZC4gKi8KLQlpZiAodW5saWtlbHkoaW5fbm1pKCkpKQotCQlnb3RvIG91dDsKIAlpZiAodW5saWtlbHkoYXRvbWljX3JlYWQoJmN1cnJlbnQtPnRyYWNpbmdfZ3JhcGhfcGF1c2UpKSkKIAkJZ290byBvdXQ7CiAJaWYgKGZ0cmFjZV9wdXNoX3JldHVybl90cmFjZShwYXJlbnQsIGlwLCAmdHJhY2UuZGVwdGgsIDApID09IC1FQlVTWSkKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL3MzOTAva2VybmVsL21vZHVsZS5jCmluZGV4IGFiMmUzZWQuLjYzOTM4MGEgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvbW9kdWxlLmMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9tb2R1bGUuYwpAQCAtNTUsNiArNTUsOCBAQAogLyogRnJlZSBtZW1vcnkgcmV0dXJuZWQgZnJvbSBtb2R1bGVfYWxsb2MgKi8KIHZvaWQgbW9kdWxlX2ZyZWUoc3RydWN0IG1vZHVsZSAqbW9kLCB2b2lkICptb2R1bGVfcmVnaW9uKQogeworCXZmcmVlKG1vZC0+YXJjaC5zeW1pbmZvKTsKKwltb2QtPmFyY2guc3ltaW5mbyA9IE5VTEw7CiAJdmZyZWUobW9kdWxlX3JlZ2lvbik7CiB9CiAKQEAgLTQwMiw2ICs0MDQsNyBAQAogCQkgICAgc3RydWN0IG1vZHVsZSAqbWUpCiB7CiAJdmZyZWUobWUtPmFyY2guc3ltaW5mbyk7CisJbWUtPmFyY2guc3ltaW5mbyA9IE5VTEw7CiAJcmV0dXJuIG1vZHVsZV9idWdfZmluYWxpemUoaGRyLCBzZWNoZHJzLCBtZSk7CiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvcHJvY2Vzc29yLmMgYi9hcmNoL3MzOTAva2VybmVsL3Byb2Nlc3Nvci5jCmluZGV4IDgwMmM4YWIuLjA3MjlmMzYgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvcHJvY2Vzc29yLmMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9wcm9jZXNzb3IuYwpAQCAtMzEsOSArMzEsOSBAQAogCiBzdGF0aWMgaW50IHNob3dfY3B1aW5mbyhzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQgKnYpCiB7Ci0Jc3RhdGljIGNvbnN0IGNoYXIgKmh3Y2FwX3N0cls5XSA9IHsKKwlzdGF0aWMgY29uc3QgY2hhciAqaHdjYXBfc3RyWzEwXSA9IHsKIAkJImVzYW4zIiwgInphcmNoIiwgInN0ZmxlIiwgIm1zYSIsICJsZGlzcCIsICJlaW1tIiwgImRmcCIsCi0JCSJlZGF0IiwgImV0ZjNlaCIKKwkJImVkYXQiLCAiZXRmM2VoIiwgImhpZ2hncHJzIgogCX07CiAJc3RydWN0IF9sb3djb3JlICpsYzsKIAl1bnNpZ25lZCBsb25nIG4gPSAodW5zaWduZWQgbG9uZykgdiAtIDE7CkBAIC00OCw3ICs0OCw3IEBACiAJCQkgICBudW1fb25saW5lX2NwdXMoKSwgbG9vcHNfcGVyX2ppZmZ5Lyg1MDAwMDAvSFopLAogCQkJICAgKGxvb3BzX3Blcl9qaWZmeS8oNTAwMC9IWikpJTEwMCk7CiAJCXNlcV9wdXRzKG0sICJmZWF0dXJlc1x0OiAiKTsKLQkJZm9yIChpID0gMDsgaSA8IDk7IGkrKykKKwkJZm9yIChpID0gMDsgaSA8IDEwOyBpKyspCiAJCQlpZiAoaHdjYXBfc3RyW2ldICYmIChlbGZfaHdjYXAgJiAoMVVMIDw8IGkpKSkKIAkJCQlzZXFfcHJpbnRmKG0sICIlcyAiLCBod2NhcF9zdHJbaV0pOwogCQlzZXFfcHV0cyhtLCAiXG4iKTsKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvcHRyYWNlLmMgYi9hcmNoL3MzOTAva2VybmVsL3B0cmFjZS5jCmluZGV4IGE4NzM4NjcuLjY1M2M2YTEgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvcHRyYWNlLmMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9wdHJhY2UuYwpAQCAtNTcsNiArNTcsNyBAQAogZW51bSBzMzkwX3JlZ3NldCB7CiAJUkVHU0VUX0dFTkVSQUwsCiAJUkVHU0VUX0ZQLAorCVJFR1NFVF9HRU5FUkFMX0VYVEVOREVELAogfTsKIAogc3RhdGljIHZvaWQKQEAgLTg3OSw2ICs4ODAsNjcgQEAKIAlyZXR1cm4gcmM7CiB9CiAKK3N0YXRpYyBpbnQgczM5MF9jb21wYXRfcmVnc19oaWdoX2dldChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCB1c2VyX3JlZ3NldCAqcmVnc2V0LAorCQkJCSAgICAgdW5zaWduZWQgaW50IHBvcywgdW5zaWduZWQgaW50IGNvdW50LAorCQkJCSAgICAgdm9pZCAqa2J1Ziwgdm9pZCBfX3VzZXIgKnVidWYpCit7CisJY29tcGF0X3Vsb25nX3QgKmdwcnNfaGlnaDsKKworCWdwcnNfaGlnaCA9IChjb21wYXRfdWxvbmdfdCAqKQorCQkmdGFza19wdF9yZWdzKHRhcmdldCktPmdwcnNbcG9zIC8gc2l6ZW9mKGNvbXBhdF91bG9uZ190KV07CisJaWYgKGtidWYpIHsKKwkJY29tcGF0X3Vsb25nX3QgKmsgPSBrYnVmOworCQl3aGlsZSAoY291bnQgPiAwKSB7CisJCQkqaysrID0gKmdwcnNfaGlnaDsKKwkJCWdwcnNfaGlnaCArPSAyOworCQkJY291bnQgLT0gc2l6ZW9mKCprKTsKKwkJfQorCX0gZWxzZSB7CisJCWNvbXBhdF91bG9uZ190IF9fdXNlciAqdSA9IHVidWY7CisJCXdoaWxlIChjb3VudCA+IDApIHsKKwkJCWlmIChfX3B1dF91c2VyKCpncHJzX2hpZ2gsIHUrKykpCisJCQkJcmV0dXJuIC1FRkFVTFQ7CisJCQlncHJzX2hpZ2ggKz0gMjsKKwkJCWNvdW50IC09IHNpemVvZigqdSk7CisJCX0KKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgczM5MF9jb21wYXRfcmVnc19oaWdoX3NldChzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRhcmdldCwKKwkJCQkgICAgIGNvbnN0IHN0cnVjdCB1c2VyX3JlZ3NldCAqcmVnc2V0LAorCQkJCSAgICAgdW5zaWduZWQgaW50IHBvcywgdW5zaWduZWQgaW50IGNvdW50LAorCQkJCSAgICAgY29uc3Qgdm9pZCAqa2J1ZiwgY29uc3Qgdm9pZCBfX3VzZXIgKnVidWYpCit7CisJY29tcGF0X3Vsb25nX3QgKmdwcnNfaGlnaDsKKwlpbnQgcmMgPSAwOworCisJZ3Byc19oaWdoID0gKGNvbXBhdF91bG9uZ190ICopCisJCSZ0YXNrX3B0X3JlZ3ModGFyZ2V0KS0+Z3Byc1twb3MgLyBzaXplb2YoY29tcGF0X3Vsb25nX3QpXTsKKwlpZiAoa2J1ZikgeworCQljb25zdCBjb21wYXRfdWxvbmdfdCAqayA9IGtidWY7CisJCXdoaWxlIChjb3VudCA+IDApIHsKKwkJCSpncHJzX2hpZ2ggPSAqaysrOworCQkJKmdwcnNfaGlnaCArPSAyOworCQkJY291bnQgLT0gc2l6ZW9mKCprKTsKKwkJfQorCX0gZWxzZSB7CisJCWNvbnN0IGNvbXBhdF91bG9uZ190ICBfX3VzZXIgKnUgPSB1YnVmOworCQl3aGlsZSAoY291bnQgPiAwICYmICFyYykgeworCQkJdW5zaWduZWQgbG9uZyB3b3JkOworCQkJcmMgPSBfX2dldF91c2VyKHdvcmQsIHUrKyk7CisJCQlpZiAocmMpCisJCQkJYnJlYWs7CisJCQkqZ3Byc19oaWdoID0gd29yZDsKKwkJCSpncHJzX2hpZ2ggKz0gMjsKKwkJCWNvdW50IC09IHNpemVvZigqdSk7CisJCX0KKwl9CisKKwlyZXR1cm4gcmM7Cit9CisKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNlcl9yZWdzZXQgczM5MF9jb21wYXRfcmVnc2V0c1tdID0gewogCVtSRUdTRVRfR0VORVJBTF0gPSB7CiAJCS5jb3JlX25vdGVfdHlwZSA9IE5UX1BSU1RBVFVTLApAQCAtODk2LDYgKzk1OCwxNCBAQAogCQkuZ2V0ID0gczM5MF9mcHJlZ3NfZ2V0LAogCQkuc2V0ID0gczM5MF9mcHJlZ3Nfc2V0LAogCX0sCisJW1JFR1NFVF9HRU5FUkFMX0VYVEVOREVEXSA9IHsKKwkJLmNvcmVfbm90ZV90eXBlID0gTlRfUFJYU1RBVFVTLAorCQkubiA9IHNpemVvZihzMzkwX2NvbXBhdF9yZWdzX2hpZ2gpIC8gc2l6ZW9mKGNvbXBhdF9sb25nX3QpLAorCQkuc2l6ZSA9IHNpemVvZihjb21wYXRfbG9uZ190KSwKKwkJLmFsaWduID0gc2l6ZW9mKGNvbXBhdF9sb25nX3QpLAorCQkuZ2V0ID0gczM5MF9jb21wYXRfcmVnc19oaWdoX2dldCwKKwkJLnNldCA9IHMzOTBfY29tcGF0X3JlZ3NfaGlnaF9zZXQsCisJfSwKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdXNlcl9yZWdzZXRfdmlldyB1c2VyX3MzOTBfY29tcGF0X3ZpZXcgPSB7CmRpZmYgLS1naXQgYS9hcmNoL3MzOTAva2VybmVsL3NldHVwLmMgYi9hcmNoL3MzOTAva2VybmVsL3NldHVwLmMKaW5kZXggOWVkMTNhMS4uMDYxNDc5ZiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2tlcm5lbC9zZXR1cC5jCisrKyBiL2FyY2gvczM5MC9rZXJuZWwvc2V0dXAuYwpAQCAtNzI5LDcgKzcyOSw3IEBACiAKIAlpZiAoKGZhY2lsaXR5X2xpc3QgJiAoMVVMIDw8ICgzMSAtIDIyKSkpCiAJICAgICYmIChmYWNpbGl0eV9saXN0ICYgKDFVTCA8PCAoMzEgLSAzMCkpKSkKLQkJZWxmX2h3Y2FwIHw9IDFVTCA8PCA4OworCQllbGZfaHdjYXAgfD0gSFdDQVBfUzM5MF9FVEYzRUg7CiAKIAkvKgogCSAqIENoZWNrIGZvciBhZGRpdGlvbmFsIGZhY2lsaXRpZXMgd2l0aCBzdG9yZS1mYWNpbGl0eS1saXN0LWV4dGVuZGVkLgpAQCAtNzQ4LDExICs3NDgsMjAgQEAKIAkgICAgX19zdGZsZSgmZmFjaWxpdHlfbGlzdF9leHRlbmRlZCwgMSkgPiAwKSB7CiAJCWlmICgoZmFjaWxpdHlfbGlzdF9leHRlbmRlZCAmICgxVUxMIDw8ICg2MyAtIDQyKSkpCiAJCSAgICAmJiAoZmFjaWxpdHlfbGlzdF9leHRlbmRlZCAmICgxVUxMIDw8ICg2MyAtIDQ0KSkpKQotCQkJZWxmX2h3Y2FwIHw9IDFVTCA8PCA2OworCQkJZWxmX2h3Y2FwIHw9IEhXQ0FQX1MzOTBfREZQOwogCX0KIAorCS8qCisJICogSHVnZSBwYWdlIHN1cHBvcnQgSFdDQVBfUzM5MF9IUEFHRSBpcyBiaXQgNy4KKwkgKi8KIAlpZiAoTUFDSElORV9IQVNfSFBBR0UpCi0JCWVsZl9od2NhcCB8PSAxVUwgPDwgNzsKKwkJZWxmX2h3Y2FwIHw9IEhXQ0FQX1MzOTBfSFBBR0U7CisKKwkvKgorCSAqIDY0LWJpdCByZWdpc3RlciBzdXBwb3J0IGZvciAzMS1iaXQgcHJvY2Vzc2VzCisJICogSFdDQVBfUzM5MF9ISUdIX0dQUlMgaXMgYml0IDkuCisJICovCisJZWxmX2h3Y2FwIHw9IEhXQ0FQX1MzOTBfSElHSF9HUFJTOwogCiAJc3dpdGNoIChTMzkwX2xvd2NvcmUuY3B1X2lkLm1hY2hpbmUpIHsKIAljYXNlIDB4OTY3MjoKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9rZXJuZWwvc3dzdXNwX2FzbTY0LlMgYi9hcmNoL3MzOTAva2VybmVsL3N3c3VzcF9hc202NC5TCmluZGV4IGZlOTI3ZDAuLjdjODY1M2UgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvc3dzdXNwX2FzbTY0LlMKKysrIGIvYXJjaC9zMzkwL2tlcm5lbC9zd3N1c3BfYXNtNjQuUwpAQCAtNDMsNyArNDMsNyBAQAogCWxnaGkJJXIxLDB4MTAwMAogCiAJLyogU2F2ZSBDUFUgYWRkcmVzcyAqLwotCXN0YXAJX19MQ19DUFVfQUREUkVTUyglcjEpCisJc3RhcAlfX0xDX0NQVV9BRERSRVNTKCVyMCkKIAogCS8qIFN0b3JlIHJlZ2lzdGVycyAqLwogCW12YwkweDMxOCg0LCVyMSksX19TRl9FTVBUWSglcjE1KQkvKiBtb3ZlIHByZWZpeCB0byBsb3djb3JlICovCkBAIC02OSw4ICs2OSwyMSBAQAogCXN0bWcJJXIwLCVyMTUsMHgyODAoJXIxKQkJLyogc3RvcmUgZ2VuZXJhbCByZWdpc3RlcnMgKi8KIAogCXN0cHQJMHgzMjgoJXIxKQkJCS8qIHN0b3JlIHRpbWVyICovCisJc3RjawlfX1NGX0VNUFRZKCVyMTUpCQkvKiBzdG9yZSBjbG9jayAqLwogCXN0Y2tjCTB4MzMwKCVyMSkJCQkvKiBzdG9yZSBjbG9jayBjb21wYXJhdG9yICovCiAKKwkvKiBVcGRhdGUgY3B1dGltZSBhY2NvdW50aW5nIGJlZm9yZSBnb2luZyB0byBzbGVlcCAqLworCWxnCSVyMCxfX0xDX0xBU1RfVVBEQVRFX1RJTUVSCisJc2xnCSVyMCwweDMyOCglcjEpCisJYWxnCSVyMCxfX0xDX1NZU1RFTV9USU1FUgorCXN0ZwklcjAsX19MQ19TWVNURU1fVElNRVIKKwltdmMJX19MQ19MQVNUX1VQREFURV9USU1FUig4KSwweDMyOCglcjEpCisJbGcJJXIwLF9fTENfTEFTVF9VUERBVEVfQ0xPQ0sKKwlzbGcJJXIwLF9fU0ZfRU1QVFkoJXIxNSkKKwlhbGcJJXIwLF9fTENfU1RFQUxfVElNRVIKKwlzdGcJJXIwLF9fTENfU1RFQUxfVElNRVIKKwltdmMJX19MQ19MQVNUX1VQREFURV9DTE9DSyg4KSxfX1NGX0VNUFRZKCVyMTUpCisKIAkvKiBBY3RpdmF0ZSBEQVQgKi8KIAlzdG9zbQlfX1NGX0VNUFRZKCVyMTUpLDB4MDQKIApAQCAtMTU5LDggKzE3Miw3IEBACiAJbGFybAklcjEsLkxyZXN1bWVfY3B1CQkvKiBSZXN1bWUgQ1BVIGFkZHJlc3M6IHIyICovCiAJc3RhcAkwKCVyMSkKIAlsbGdoCSVyMiwwKCVyMSkKLQlsZ2hpCSVyMywweDEwMDAKLQlsbGdoCSVyMSxfX0xDX0NQVV9BRERSRVNTKCVyMykJLyogU3VzcGVuZCBDUFUgYWRkcmVzczogcjEgKi8KKwlsbGdoCSVyMSxfX0xDX0NQVV9BRERSRVNTKCVyMCkJLyogU3VzcGVuZCBDUFUgYWRkcmVzczogcjEgKi8KIAljZ3IJJXIxLCVyMgogCWplCXJlc3RvcmVfcmVnaXN0ZXJzCQkvKiByMSA9IHIyIC0+IG5vdGhpbmcgdG8gZG8gKi8KIAlsYXJsCSVyNCwuTHJlc3RhcnRfc3VzcGVuZF9wc3cJLyogU2V0IG5ldyByZXN0YXJ0IFBTVyAqLwpAQCAtMjAwLDggKzIxMiwxMSBAQAogCiByZXN0b3JlX3JlZ2lzdGVyczoKIAkvKiBSZXN0b3JlIHJlZ2lzdGVycyAqLwotCWxnaGkJJXIxMywweDEwMDAJCS8qICVyMSA9IHBvaW50ZXIgdG8gc2F2ZSBhcmFlICovCisJbGdoaQklcjEzLDB4MTAwMAkJLyogJXIxID0gcG9pbnRlciB0byBzYXZlIGFyZWEgKi8KIAorCS8qIElnbm9yZSB0aW1lIHNwZW50IGluIHN1c3BlbmRlZCBzdGF0ZS4gKi8KKwlsbGdmCSVyMSwweDMxOCglcjEzKQorCXN0Y2sJX19MQ19MQVNUX1VQREFURV9DTE9DSyglcjEpCiAJc3B0CTB4MzI4KCVyMTMpCQkvKiByZXByb2dyYW0gdGltZXIgKi8KIAkvL3Nja2MJMHgzMzAoJXIxMykJCS8qIHNldCBjbG9jayBjb21wYXJhdG9yICovCiAKQEAgLTIyOSw5ICsyNDQsNiBAQAogCS8qIExvYWQgb2xkIHN0YWNrICovCiAJbGcJJXIxNSwweDJmOCglcjEzKQogCi0JLyogUG9pbnRlciB0byBzYXZlIGFyZWEgKi8KLQlsZ2hpCSVyMTMsMHgxMDAwCi0KIAkvKiBSZXN0b3JlIHByZWZpeCByZWdpc3RlciAqLwogCXNweAkweDMxOCglcjEzKQogCmRpZmYgLS1naXQgYS9hcmNoL3MzOTAva2VybmVsL3Zkc28uYyBiL2FyY2gvczM5MC9rZXJuZWwvdmRzby5jCmluZGV4IDQ1YTNlOWEuLmFkZmIzMmEgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvdmRzby5jCisrKyBiL2FyY2gvczM5MC9rZXJuZWwvdmRzby5jCkBAIC0yNDcsNiArMjQ3LDEzIEBACiAJfQogCiAJLyoKKwkgKiBQdXQgdkRTTyBiYXNlIGludG8gbW0gc3RydWN0LiBXZSBuZWVkIHRvIGRvIHRoaXMgYmVmb3JlIGNhbGxpbmcKKwkgKiBpbnN0YWxsX3NwZWNpYWxfbWFwcGluZyBvciB0aGUgcGVyZiBjb3VudGVyIG1tYXAgdHJhY2tpbmcgY29kZQorCSAqIHdpbGwgZmFpbCB0byByZWNvZ25pc2UgaXQgYXMgYSB2RFNPIChzaW5jZSBhcmNoX3ZtYV9uYW1lIGZhaWxzKS4KKwkgKi8KKwljdXJyZW50LT5tbS0+Y29udGV4dC52ZHNvX2Jhc2UgPSB2ZHNvX2Jhc2U7CisKKwkvKgogCSAqIG91ciB2bWEgZmxhZ3MgZG9uJ3QgaGF2ZSBWTV9XUklURSBzbyBieSBkZWZhdWx0LCB0aGUgcHJvY2VzcwogCSAqIGlzbid0IGFsbG93ZWQgdG8gd3JpdGUgdGhvc2UgcGFnZXMuCiAJICogZ2RiIGNhbiBicmVhayB0aGF0IHdpdGggcHRyYWNlIGludGVyZmFjZSwgYW5kIHRodXMgdHJpZ2dlciBDT1cKQEAgLTI2NywxNCArMjc0LDcgQEAKIAkJCQkgICAgIFZNX0FMV0FZU0RVTVAsCiAJCQkJICAgICB2ZHNvX3BhZ2VsaXN0KTsKIAlpZiAocmMpCi0JCWdvdG8gb3V0X3VwOwotCi0JLyogUHV0IHZEU08gYmFzZSBpbnRvIG1tIHN0cnVjdCAqLwotCWN1cnJlbnQtPm1tLT5jb250ZXh0LnZkc29fYmFzZSA9IHZkc29fYmFzZTsKLQotCXVwX3dyaXRlKCZtbS0+bW1hcF9zZW0pOwotCXJldHVybiAwOwotCisJCWN1cnJlbnQtPm1tLT5jb250ZXh0LnZkc29fYmFzZSA9IDA7CiBvdXRfdXA6CiAJdXBfd3JpdGUoJm1tLT5tbWFwX3NlbSk7CiAJcmV0dXJuIHJjOwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2tlcm5lbC92bWxpbnV4Lmxkcy5TIGIvYXJjaC9zMzkwL2tlcm5lbC92bWxpbnV4Lmxkcy5TCmluZGV4IGJjMTVlZjkuLmE2OGFjMTAgMTAwNjQ0Ci0tLSBhL2FyY2gvczM5MC9rZXJuZWwvdm1saW51eC5sZHMuUworKysgYi9hcmNoL3MzOTAva2VybmVsL3ZtbGludXgubGRzLlMKQEAgLTUxLDYgKzUxLDcgQEAKIAogCS4gPSBBTElHTihQQUdFX1NJWkUpOwogCV9lc2hhcmVkID0gLjsJCS8qIEVuZCBvZiBzaGFyZWFibGUgZGF0YSAqLworCV9zZGF0YSA9IC47CQkvKiBTdGFydCBvZiBkYXRhIHNlY3Rpb24gKi8KIAogCUVYQ0VQVElPTl9UQUJMRSgxNikgOmRhdGEKIApkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL2xpYi9kZWxheS5jIGIvYXJjaC9zMzkwL2xpYi9kZWxheS5jCmluZGV4IDk3YzFlY2E4Li43NTJiMzYyIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvbGliL2RlbGF5LmMKKysrIGIvYXJjaC9zMzkwL2xpYi9kZWxheS5jCkBAIC0yNSwxMyArMjUsMTMgQEAKIAlhc20gdm9sYXRpbGUoIjA6IGJyY3QgJTAsMGIiIDogOiAiZCIgKChsb29wcy8yKSArIDEpKTsKIH0KIAotc3RhdGljIHZvaWQgX191ZGVsYXlfZGlzYWJsZWQodW5zaWduZWQgbG9uZyB1c2VjcykKK3N0YXRpYyB2b2lkIF9fdWRlbGF5X2Rpc2FibGVkKHVuc2lnbmVkIGxvbmcgbG9uZyB1c2VjcykKIHsKIAl1bnNpZ25lZCBsb25nIG1hc2ssIGNyMCwgY3IwX3NhdmVkOwogCXU2NCBjbG9ja19zYXZlZDsKIAogCWNsb2NrX3NhdmVkID0gbG9jYWxfdGlja19kaXNhYmxlKCk7Ci0Jc2V0X2Nsb2NrX2NvbXBhcmF0b3IoZ2V0X2Nsb2NrKCkgKyAoKHU2NCkgdXNlY3MgPDwgMTIpKTsKKwlzZXRfY2xvY2tfY29tcGFyYXRvcihnZXRfY2xvY2soKSArICh1c2VjcyA8PCAxMikpOwogCV9fY3RsX3N0b3JlKGNyMF9zYXZlZCwgMCwgMCk7CiAJY3IwID0gKGNyMF9zYXZlZCAmIDB4ZmZmZjAwZTApIHwgMHgwMDAwMDgwMDsKIAlfX2N0bF9sb2FkKGNyMCAsIDAsIDApOwpAQCAtNDYsMjAgKzQ2LDI1IEBACiAJc2V0X2Nsb2NrX2NvbXBhcmF0b3IoUzM5MF9sb3djb3JlLmNsb2NrX2NvbXBhcmF0b3IpOwogfQogCi1zdGF0aWMgdm9pZCBfX3VkZWxheV9lbmFibGVkKHVuc2lnbmVkIGxvbmcgdXNlY3MpCitzdGF0aWMgdm9pZCBfX3VkZWxheV9lbmFibGVkKHVuc2lnbmVkIGxvbmcgbG9uZyB1c2VjcykKIHsKIAl1bnNpZ25lZCBsb25nIG1hc2s7Ci0JdTY0IGVuZCwgdGltZTsKKwl1NjQgY2xvY2tfc2F2ZWQ7CisJdTY0IGVuZDsKIAogCW1hc2sgPSBwc3dfa2VybmVsX2JpdHMgfCBQU1dfTUFTS19XQUlUIHwgUFNXX01BU0tfRVhUIHwgUFNXX01BU0tfSU87Ci0JZW5kID0gZ2V0X2Nsb2NrKCkgKyAoKHU2NCkgdXNlY3MgPDwgMTIpOworCWVuZCA9IGdldF9jbG9jaygpICsgKHVzZWNzIDw8IDEyKTsKIAlkbyB7Ci0JCXRpbWUgPSBlbmQgPCBTMzkwX2xvd2NvcmUuY2xvY2tfY29tcGFyYXRvciA/Ci0JCQllbmQgOiBTMzkwX2xvd2NvcmUuY2xvY2tfY29tcGFyYXRvcjsKLQkJc2V0X2Nsb2NrX2NvbXBhcmF0b3IodGltZSk7CisJCWNsb2NrX3NhdmVkID0gMDsKKwkJaWYgKGVuZCA8IFMzOTBfbG93Y29yZS5jbG9ja19jb21wYXJhdG9yKSB7CisJCQljbG9ja19zYXZlZCA9IGxvY2FsX3RpY2tfZGlzYWJsZSgpOworCQkJc2V0X2Nsb2NrX2NvbXBhcmF0b3IoZW5kKTsKKwkJfQogCQl0cmFjZV9oYXJkaXJxc19vbigpOwogCQlfX2xvYWRfcHN3X21hc2sobWFzayk7CiAJCWxvY2FsX2lycV9kaXNhYmxlKCk7CisJCWlmIChjbG9ja19zYXZlZCkKKwkJCWxvY2FsX3RpY2tfZW5hYmxlKGNsb2NrX3NhdmVkKTsKIAl9IHdoaWxlIChnZXRfY2xvY2soKSA8IGVuZCk7CiAJc2V0X2Nsb2NrX2NvbXBhcmF0b3IoUzM5MF9sb3djb3JlLmNsb2NrX2NvbXBhcmF0b3IpOwogfQpAQCAtNjcsNyArNzIsNyBAQAogLyoKICAqIFdhaXRzIGZvciAndXNlY3MnIG1pY3Jvc2Vjb25kcyB1c2luZyB0aGUgVE9EIGNsb2NrIGNvbXBhcmF0b3IuCiAgKi8KLXZvaWQgX191ZGVsYXkodW5zaWduZWQgbG9uZyB1c2VjcykKK3ZvaWQgX191ZGVsYXkodW5zaWduZWQgbG9uZyBsb25nIHVzZWNzKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKQEAgLTEwMSwxMSArMTA2LDExIEBACiAgKiBTaW1wbGUgdWRlbGF5IHZhcmlhbnQuIFRvIGJlIHVzZWQgb24gc3RhcnR1cCBhbmQgcmVib290CiAgKiB3aGVuIHRoZSBpbnRlcnJ1cHQgaGFuZGxlciBpc24ndCB3b3JraW5nLgogICovCi12b2lkIHVkZWxheV9zaW1wbGUodW5zaWduZWQgbG9uZyB1c2VjcykKK3ZvaWQgdWRlbGF5X3NpbXBsZSh1bnNpZ25lZCBsb25nIGxvbmcgdXNlY3MpCiB7CiAJdTY0IGVuZDsKIAotCWVuZCA9IGdldF9jbG9jaygpICsgKCh1NjQpIHVzZWNzIDw8IDEyKTsKKwllbmQgPSBnZXRfY2xvY2soKSArICh1c2VjcyA8PCAxMik7CiAJd2hpbGUgKGdldF9jbG9jaygpIDwgZW5kKQogCQljcHVfcmVsYXgoKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9saWIvdWFjY2Vzc19tdmNvcy5jIGIvYXJjaC9zMzkwL2xpYi91YWNjZXNzX212Y29zLmMKaW5kZXggM2YxNWFhZi4uNThkYTNmNCAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL2xpYi91YWNjZXNzX212Y29zLmMKKysrIGIvYXJjaC9zMzkwL2xpYi91YWNjZXNzX212Y29zLmMKQEAgLTM2LDcgKzM2LDcgQEAKIAl0bXAxID0gLTQwOTZVTDsKIAlhc20gdm9sYXRpbGUoCiAJCSIwOiAuaW5zbiBzcywweGM4MDAwMDAwMDAwMCwwKCUwLCUyKSwwKCUxKSwwXG4iCi0JCSIgICBqeiAgICA3ZlxuIgorCQkiOToganogICAgN2ZcbiIKIAkJIjE6IkFMUiIgICUwLCUzXG4iCiAJCSIgICJTTFIiICAlMSwlM1xuIgogCQkiICAiU0xSIiAgJTIsJTNcbiIKQEAgLTQ3LDcgKzQ3LDcgQEAKIAkJIiAgIkNMUiIgICUwLCU0XG4iCS8qIGNvcHkgY3Jvc3NlcyBuZXh0IHBhZ2UgYm91bmRhcnk/ICovCiAJCSIgICBqbmggICA0ZlxuIgogCQkiMzogLmluc24gc3MsMHhjODAwMDAwMDAwMDAsMCglNCwlMiksMCglMSksMFxuIgotCQkiICAiU0xSIiAgJTAsJTRcbiIKKwkJIjEwOiJTTFIiICAlMCwlNFxuIgogCQkiICAiQUxSIiAgJTIsJTRcbiIKIAkJIjQ6IkxISSIgICU0LC0xXG4iCiAJCSIgICJBTFIiICAlNCwlMFxuIgkvKiBjb3B5IHJlbWFpbmluZyBzaXplLCBzdWJ0cmFjdCAxICovCkBAIC02MSw3ICs2MSw3IEBACiAJCSIgICBqICAgICA4ZlxuIgogCQkiNzoiU0xSIiAgJTAsJTBcbiIKIAkJIjg6IFxuIgotCQlFWF9UQUJMRSgwYiwyYikgRVhfVEFCTEUoM2IsNGIpCisJCUVYX1RBQkxFKDBiLDJiKSBFWF9UQUJMRSgzYiw0YikgRVhfVEFCTEUoOWIsMmIpIEVYX1RBQkxFKDEwYiw0YikKIAkJOiAiK2EiIChzaXplKSwgIithIiAocHRyKSwgIithIiAoeCksICIrYSIgKHRtcDEpLCAiPWEiICh0bXAyKQogCQk6ICJkIiAocmVnMCkgOiAiY2MiLCAibWVtb3J5Iik7CiAJcmV0dXJuIHNpemU7CkBAIC04Miw3ICs4Miw3IEBACiAJdG1wMSA9IC00MDk2VUw7CiAJYXNtIHZvbGF0aWxlKAogCQkiMDogLmluc24gc3MsMHhjODAwMDAwMDAwMDAsMCglMCwlMSksMCglMiksMFxuIgotCQkiICAganogICAgNGZcbiIKKwkJIjY6IGp6ICAgIDRmXG4iCiAJCSIxOiJBTFIiICAlMCwlM1xuIgogCQkiICAiU0xSIiAgJTEsJTNcbiIKIAkJIiAgIlNMUiIgICUyLCUzXG4iCkBAIC05MywxMSArOTMsMTEgQEAKIAkJIiAgIkNMUiIgICUwLCU0XG4iCS8qIGNvcHkgY3Jvc3NlcyBuZXh0IHBhZ2UgYm91bmRhcnk/ICovCiAJCSIgICBqbmggICA1ZlxuIgogCQkiMzogLmluc24gc3MsMHhjODAwMDAwMDAwMDAsMCglNCwlMSksMCglMiksMFxuIgotCQkiICAiU0xSIiAgJTAsJTRcbiIKKwkJIjc6IlNMUiIgICUwLCU0XG4iCiAJCSIgICBqICAgICA1ZlxuIgogCQkiNDoiU0xSIiAgJTAsJTBcbiIKIAkJIjU6IFxuIgotCQlFWF9UQUJMRSgwYiwyYikgRVhfVEFCTEUoM2IsNWIpCisJCUVYX1RBQkxFKDBiLDJiKSBFWF9UQUJMRSgzYiw1YikgRVhfVEFCTEUoNmIsMmIpIEVYX1RBQkxFKDdiLDViKQogCQk6ICIrYSIgKHNpemUpLCAiK2EiIChwdHIpLCAiK2EiICh4KSwgIithIiAodG1wMSksICI9YSIgKHRtcDIpCiAJCTogImQiIChyZWcwKSA6ICJjYyIsICJtZW1vcnkiKTsKIAlyZXR1cm4gc2l6ZTsKZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9saWIvdWFjY2Vzc19zdGQuYyBiL2FyY2gvczM5MC9saWIvdWFjY2Vzc19zdGQuYwppbmRleCBkMmZmYmFkLi4wN2RlYWVlIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvbGliL3VhY2Nlc3Nfc3RkLmMKKysrIGIvYXJjaC9zMzkwL2xpYi91YWNjZXNzX3N0ZC5jCkBAIC0zNiwxMiArMzYsMTIgQEAKIAl0bXAxID0gLTI1NlVMOwogCWFzbSB2b2xhdGlsZSgKIAkJIjA6IG12Y3AgIDAoJTAsJTIpLDAoJTEpLCUzXG4iCi0JCSIgICBqeiAgICA4ZlxuIgorCQkiMTA6anogICAgOGZcbiIKIAkJIjE6IkFMUiIgICUwLCUzXG4iCiAJCSIgICBsYSAgICAlMSwyNTYoJTEpXG4iCiAJCSIgICBsYSAgICAlMiwyNTYoJTIpXG4iCiAJCSIyOiBtdmNwICAwKCUwLCUyKSwwKCUxKSwlM1xuIgotCQkiICAgam56ICAgMWJcbiIKKwkJIjExOmpueiAgIDFiXG4iCiAJCSIgICBqICAgICA4ZlxuIgogCQkiMzogbGEgICAgJTQsMjU1KCUxKVxuIgkvKiAlNCA9IHB0ciArIDI1NSAqLwogCQkiICAiTEhJIiAgJTMsLTQwOTZcbiIKQEAgLTUwLDcgKzUwLDcgQEAKIAkJIiAgIkNMUiIgICUwLCU0XG4iCS8qIGNvcHkgY3Jvc3NlcyBuZXh0IHBhZ2UgYm91bmRhcnk/ICovCiAJCSIgICBqbmggICA1ZlxuIgogCQkiNDogbXZjcCAgMCglNCwlMiksMCglMSksJTNcbiIKLQkJIiAgIlNMUiIgICUwLCU0XG4iCisJCSIxMjoiU0xSIiAgJTAsJTRcbiIKIAkJIiAgIkFMUiIgICUyLCU0XG4iCiAJCSI1OiJMSEkiICAlNCwtMVxuIgogCQkiICAiQUxSIiAgJTQsJTBcbiIJLyogY29weSByZW1haW5pbmcgc2l6ZSwgc3VidHJhY3QgMSAqLwpAQCAtNjUsNiArNjUsNyBAQAogCQkiODoiU0xSIiAgJTAsJTBcbiIKIAkJIjk6IFxuIgogCQlFWF9UQUJMRSgwYiwzYikgRVhfVEFCTEUoMmIsM2IpIEVYX1RBQkxFKDRiLDViKQorCQlFWF9UQUJMRSgxMGIsM2IpIEVYX1RBQkxFKDExYiwzYikgRVhfVEFCTEUoMTJiLDViKQogCQk6ICIrYSIgKHNpemUpLCAiK2EiIChwdHIpLCAiK2EiICh4KSwgIithIiAodG1wMSksICI9YSIgKHRtcDIpCiAJCTogOiAiY2MiLCAibWVtb3J5Iik7CiAJcmV0dXJuIHNpemU7CkBAIC04NSwxMiArODYsMTIgQEAKIAl0bXAxID0gLTI1NlVMOwogCWFzbSB2b2xhdGlsZSgKIAkJIjA6IG12Y3MgIDAoJTAsJTEpLDAoJTIpLCUzXG4iCi0JCSIgICBqeiAgICA1ZlxuIgorCQkiNzoganogICAgNWZcbiIKIAkJIjE6IkFMUiIgICUwLCUzXG4iCiAJCSIgICBsYSAgICAlMSwyNTYoJTEpXG4iCiAJCSIgICBsYSAgICAlMiwyNTYoJTIpXG4iCiAJCSIyOiBtdmNzICAwKCUwLCUxKSwwKCUyKSwlM1xuIgotCQkiICAgam56ICAgMWJcbiIKKwkJIjg6IGpueiAgIDFiXG4iCiAJCSIgICBqICAgICA1ZlxuIgogCQkiMzogbGEgICAgJTQsMjU1KCUxKVxuIiAvKiAlNCA9IHB0ciArIDI1NSAqLwogCQkiICAiTEhJIiAgJTMsLTQwOTZcbiIKQEAgLTk5LDExICsxMDAsMTIgQEAKIAkJIiAgIkNMUiIgICUwLCU0XG4iCS8qIGNvcHkgY3Jvc3NlcyBuZXh0IHBhZ2UgYm91bmRhcnk/ICovCiAJCSIgICBqbmggICA2ZlxuIgogCQkiNDogbXZjcyAgMCglNCwlMSksMCglMiksJTNcbiIKLQkJIiAgIlNMUiIgICUwLCU0XG4iCisJCSI5OiJTTFIiICAlMCwlNFxuIgogCQkiICAgaiAgICAgNmZcbiIKIAkJIjU6IlNMUiIgICUwLCUwXG4iCiAJCSI2OiBcbiIKIAkJRVhfVEFCTEUoMGIsM2IpIEVYX1RBQkxFKDJiLDNiKSBFWF9UQUJMRSg0Yiw2YikKKwkJRVhfVEFCTEUoN2IsM2IpIEVYX1RBQkxFKDhiLDNiKSBFWF9UQUJMRSg5Yiw2YikKIAkJOiAiK2EiIChzaXplKSwgIithIiAocHRyKSwgIithIiAoeCksICIrYSIgKHRtcDEpLCAiPWEiICh0bXAyKQogCQk6IDogImNjIiwgIm1lbW9yeSIpOwogCXJldHVybiBzaXplOwpkaWZmIC0tZ2l0IGEvYXJjaC9zMzkwL21tL3BndGFibGUuYyBiL2FyY2gvczM5MC9tbS9wZ3RhYmxlLmMKaW5kZXggYzYwYmZiMy4uMjc1N2M1NiAxMDA2NDQKLS0tIGEvYXJjaC9zMzkwL21tL3BndGFibGUuYworKysgYi9hcmNoL3MzOTAvbW0vcGd0YWJsZS5jCkBAIC0yNzksNyArMjc5LDEwIEBACiAJLyogbGV0cyBjaGVjayBpZiB3ZSBhcmUgYWxsb3dlZCB0byByZXBsYWNlIHRoZSBtbSAqLwogCXRhc2tfbG9jayh0c2spOwogCWlmICghdHNrLT5tbSB8fCBhdG9taWNfcmVhZCgmdHNrLT5tbS0+bW1fdXNlcnMpID4gMSB8fAotCSAgICB0c2stPm1tICE9IHRzay0+YWN0aXZlX21tIHx8ICFobGlzdF9lbXB0eSgmdHNrLT5tbS0+aW9jdHhfbGlzdCkpIHsKKyNpZmRlZiBDT05GSUdfQUlPCisJICAgICFobGlzdF9lbXB0eSgmdHNrLT5tbS0+aW9jdHhfbGlzdCkgfHwKKyNlbmRpZgorCSAgICB0c2stPm1tICE9IHRzay0+YWN0aXZlX21tKSB7CiAJCXRhc2tfdW5sb2NrKHRzayk7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KQEAgLTI5NSw3ICsyOTgsMTAgQEAKIAkvKiBOb3cgbGV0cyBjaGVjayBhZ2FpbiBpZiBzb21ldGhpbmcgaGFwcGVuZWQgKi8KIAl0YXNrX2xvY2sodHNrKTsKIAlpZiAoIXRzay0+bW0gfHwgYXRvbWljX3JlYWQoJnRzay0+bW0tPm1tX3VzZXJzKSA+IDEgfHwKLQkgICAgdHNrLT5tbSAhPSB0c2stPmFjdGl2ZV9tbSB8fCAhaGxpc3RfZW1wdHkoJnRzay0+bW0tPmlvY3R4X2xpc3QpKSB7CisjaWZkZWYgQ09ORklHX0FJTworCSAgICAhaGxpc3RfZW1wdHkoJnRzay0+bW0tPmlvY3R4X2xpc3QpIHx8CisjZW5kaWYKKwkgICAgdHNrLT5tbSAhPSB0c2stPmFjdGl2ZV9tbSkgewogCQltbXB1dChtbSk7CiAJCXRhc2tfdW5sb2NrKHRzayk7CiAJCXJldHVybiAtRUlOVkFMOwpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9LY29uZmlnIGIvYXJjaC9zaC9LY29uZmlnCmluZGV4IGI5NDA0MjQuLjBkYzdlM2MgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvS2NvbmZpZworKysgYi9hcmNoL3NoL0tjb25maWcKQEAgLTM3LDcgKzM3LDYgQEAKIAlzZWxlY3QgSEFWRV9GVFJBQ0VfTUNPVU5UX1JFQ09SRAogCXNlbGVjdCBIQVZFX0RZTkFNSUNfRlRSQUNFCiAJc2VsZWN0IEhBVkVfRlVOQ1RJT05fVFJBQ0VfTUNPVU5UX1RFU1QKLQlzZWxlY3QgSEFWRV9GVFJBQ0VfU1lTQ0FMTFMKIAlzZWxlY3QgSEFWRV9GVU5DVElPTl9HUkFQSF9UUkFDRVIKIAlzZWxlY3QgSEFWRV9BUkNIX0tHREIKIAlzZWxlY3QgQVJDSF9ISUJFUk5BVElPTl9QT1NTSUJMRSBpZiBNTVUKZGlmZiAtLWdpdCBhL2FyY2gvc2gvYm9hcmRzL2JvYXJkLW1hZ2ljcGFuZWxyMi5jIGIvYXJjaC9zaC9ib2FyZHMvYm9hcmQtbWFnaWNwYW5lbHIyLmMKaW5kZXggMGEzN2M4Yi4uOTlmZmM1ZiAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib2FyZHMvYm9hcmQtbWFnaWNwYW5lbHIyLmMKKysrIGIvYXJjaC9zaC9ib2FyZHMvYm9hcmQtbWFnaWNwYW5lbHIyLmMKQEAgLTIwNSw4ICsyMDUsNiBAQAogCiBzdGF0aWMgdm9pZCBfX2luaXQgbXByMl9zZXR1cChjaGFyICoqY21kbGluZV9wKQogewotCV9fc2V0X2lvX3BvcnRfYmFzZSgweGEwMDAwMDAwKTsKLQogCS8qIHNldCBQaW4gU2VsZWN0IFJlZ2lzdGVyIEE6CiAJICogL1BDQ19DRDEsIC9QQ0NfQ0QyLCAgUENDX0JWRDEsIFBDQ19CVkQyLAogCSAqIC9JT0lTMTYsICBJUlE0LAlJUlE1LAkgIFVTQjFkX1NVU1BFTkQKZGlmZiAtLWdpdCBhL2FyY2gvc2gvYm9hcmRzL21hY2gtZHJlYW1jYXN0L3NldHVwLmMgYi9hcmNoL3NoL2JvYXJkcy9tYWNoLWRyZWFtY2FzdC9zZXR1cC5jCmluZGV4IGViZTk5MjIuLmE0Yjc0MDIgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvYm9hcmRzL21hY2gtZHJlYW1jYXN0L3NldHVwLmMKKysrIGIvYXJjaC9zaC9ib2FyZHMvbWFjaC1kcmVhbWNhc3Qvc2V0dXAuYwpAQCAtNDIsOCArNDIsNiBAQAogCS8qIEFja25vd2xlZGdlIGFueSBwcmV2aW91cyBldmVudHMgKi8KIAkvKiBYWFggKi8KIAotCV9fc2V0X2lvX3BvcnRfYmFzZSgweGEwMDAwMDAwKTsKLQogCS8qIEFzc2lnbiBhbGwgdmlydHVhbCBJUlFzIHRvIHRoZSBTeXN0ZW0gQVNJQyBpbnQuIGhhbmRsZXIgKi8KIAlmb3IgKGkgPSBIV19FVkVOVF9JUlFfQkFTRTsgaSA8IEhXX0VWRU5UX0lSUV9NQVg7IGkrKykKIAkJc2V0X2lycV9jaGlwX2FuZF9oYW5kbGVyKGksICZzeXN0ZW1hc2ljX2ludCwKZGlmZiAtLWdpdCBhL2FyY2gvc2gvYm9hcmRzL21hY2gtZWNvdmVjMjQvc2V0dXAuYyBiL2FyY2gvc2gvYm9hcmRzL21hY2gtZWNvdmVjMjQvc2V0dXAuYwppbmRleCA1Zjk4ODFlMS4uM2IxY2ViNCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9ib2FyZHMvbWFjaC1lY292ZWMyNC9zZXR1cC5jCisrKyBiL2FyY2gvc2gvYm9hcmRzL21hY2gtZWNvdmVjMjQvc2V0dXAuYwpAQCAtMTgsNiArMTgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvdXNiL3I4YTY2NTk3Lmg+CiAjaW5jbHVkZSA8bGludXgvaTJjLmg+CisjaW5jbHVkZSA8bGludXgvaTJjL3RzYzIwMDcuaD4KICNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgogI2luY2x1ZGUgPHZpZGVvL3NoX21vYmlsZV9sY2RjLmg+CiAjaW5jbHVkZSA8bWVkaWEvc2hfbW9iaWxlX2NldS5oPgpAQCAtMzgsNiArMzksMjAgQEAKICAqICAweDE4MDBfMDAwMCAgTUZJICAgICAgICAgICAgICAxNmJpdAogICovCiAKKy8qIFNXSVRDSAorICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqIERTMlsxXSA9IEZsYXNoUk9NIHdyaXRlIHByb3RlY3QgIE9OICAgICA6IHdyaXRlIHByb3RlY3QKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE9GRiAgICA6IE5vIHdyaXRlIHByb3RlY3QKKyAqIERTMlsyXSA9IFJNSUkgLyBUUywgU0NJRiAgICAgICAgIE9OICAgICA6IFJNSUkKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE9GRiAgICA6IFRTLCBTQ0lGMworICogRFMyWzNdID0gQ2FtZXJhIC8gVmlkZW8gICAgICAgICAgT04gICAgIDogQ2FtZXJhCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBPRkYgICAgOiBOVFNDL1BBTCAoSU4pCisgKiBEUzJbNV0gPSBOVFNDX09VVCBDbG9jayAgICAgICAgICBPTiAgICAgOiBPbiBib2FyZCBPU0MKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE9GRiAgICA6IFNINzcyNCBEVl9DTEsKKyAqIERTMls2LTddID0gTU1DIC8gU0QgICAgICAgICAgICAgIE9OLU9GRiA6IFNECisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBPRkYtT04gOiBNTUMKKyAqLworCiAvKiBIZWFydGJlYXQgKi8KIHN0YXRpYyB1bnNpZ25lZCBjaGFyIGxlZF9wb3NbXSA9IHsgMCwgMSwgMiwgMyB9Owogc3RhdGljIHN0cnVjdCBoZWFydGJlYXRfZGF0YSBoZWFydGJlYXRfZGF0YSA9IHsKQEAgLTcwLDcgKzg1LDcgQEAKIAkJLm5hbWUgPSAiYm9vdCBsb2FkZXIiLAogCQkub2Zmc2V0ID0gMCwKIAkJLnNpemUgPSAoNSAqIDEwMjQgKiAxMDI0KSwKLQkJLm1hc2tfZmxhZ3MgPSBNVERfQ0FQX1JPTSwKKwkJLm1hc2tfZmxhZ3MgPSBNVERfV1JJVEVBQkxFLCAgLyogZm9yY2UgcmVhZC1vbmx5ICovCiAJfSwgewogCQkubmFtZSA9ICJmcmVlLWFyZWEiLAogCQkub2Zmc2V0ID0gTVREUEFSVF9PRlNfQVBQRU5ELApAQCAtMzc2LDYgKzM5MSw0MyBAQAogCX0sCiB9OwogCisvKiBUb3VjaFNjcmVlbiAqLworI2RlZmluZSBJUlEwIDMyCitzdGF0aWMgaW50IHRzX2dldF9wZW5kb3duX3N0YXRlKHZvaWQpCit7CisJaW50IHZhbCA9IDA7CisJZ3Bpb19mcmVlKEdQSU9fRk5fSU5UQ19JUlEwKTsKKwlncGlvX3JlcXVlc3QoR1BJT19QVFowLCBOVUxMKTsKKwlncGlvX2RpcmVjdGlvbl9pbnB1dChHUElPX1BUWjApOworCisJdmFsID0gZ3Bpb19nZXRfdmFsdWUoR1BJT19QVFowKTsKKworCWdwaW9fZnJlZShHUElPX1BUWjApOworCWdwaW9fcmVxdWVzdChHUElPX0ZOX0lOVENfSVJRMCwgTlVMTCk7CisKKwlyZXR1cm4gdmFsID8gMCA6IDE7Cit9CisKK3N0YXRpYyBpbnQgdHNfaW5pdCh2b2lkKQoreworCWdwaW9fcmVxdWVzdChHUElPX0ZOX0lOVENfSVJRMCwgTlVMTCk7CisJcmV0dXJuIDA7Cit9CisKK3N0cnVjdCB0c2MyMDA3X3BsYXRmb3JtX2RhdGEgdHNjMjAwN19pbmZvID0geworCS5tb2RlbAkJCT0gMjAwNywKKwkueF9wbGF0ZV9vaG1zCQk9IDE4MCwKKwkuZ2V0X3BlbmRvd25fc3RhdGUJPSB0c19nZXRfcGVuZG93bl9zdGF0ZSwKKwkuaW5pdF9wbGF0Zm9ybV9odwk9IHRzX2luaXQsCit9OworCitzdGF0aWMgc3RydWN0IGkyY19ib2FyZF9pbmZvIHRzX2kyY19jbGllbnRzID0geworCUkyQ19CT0FSRF9JTkZPKCJ0c2MyMDA3IiwgMHg0OCksCisJLnR5cGUJCT0gInRzYzIwMDciLAorCS5wbGF0Zm9ybV9kYXRhCT0gJnRzYzIwMDdfaW5mbywKKwkuaXJxCQk9IElSUTAsCit9OworCiBzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSAqZWNvdmVjX2RldmljZXNbXSBfX2luaXRkYXRhID0gewogCSZoZWFydGJlYXRfZGV2aWNlLAogCSZub3JfZmxhc2hfZGV2aWNlLApAQCAtNDYwLDYgKzUxMiwxMSBAQAogI2RlZmluZSBJT0RSSVZFQSAgMHhBNDA1MDE4QQogc3RhdGljIGludCBfX2luaXQgYXJjaF9zZXR1cCh2b2lkKQogeworCS8qIGVuYWJsZSBTVEFUVVMwLCBTVEFUVVMyIGFuZCBQRFNUQVRVUyAqLworCWdwaW9fcmVxdWVzdChHUElPX0ZOX1NUQVRVUzAsIE5VTEwpOworCWdwaW9fcmVxdWVzdChHUElPX0ZOX1NUQVRVUzIsIE5VTEwpOworCWdwaW9fcmVxdWVzdChHUElPX0ZOX1BEU1RBVFVTLCBOVUxMKTsKKwogCS8qIGVuYWJsZSBTQ0lGQTAgKi8KIAlncGlvX3JlcXVlc3QoR1BJT19GTl9TQ0lGMF9UWEQsIE5VTEwpOwogCWdwaW9fcmVxdWVzdChHUElPX0ZOX1NDSUYwX1JYRCwgTlVMTCk7CkBAIC01OTAsNiArNjQ3LDEwIEBACiAJCSAqLwogCQlncGlvX3JlcXVlc3QoR1BJT19QVEY0LCBOVUxMKTsKIAkJZ3Bpb19kaXJlY3Rpb25fb3V0cHV0KEdQSU9fUFRGNCwgMSk7CisKKwkJLyogZW5hYmxlIFRvdWNoU2NyZWVuICovCisJCWkyY19yZWdpc3Rlcl9ib2FyZF9pbmZvKDAsICZ0c19pMmNfY2xpZW50cywgMSk7CisJCXNldF9pcnFfdHlwZShJUlEwLCBJUlFfVFlQRV9MRVZFTF9MT1cpOwogCX0KIAogCS8qIGVuYWJsZSBDRVUwICovCmRpZmYgLS1naXQgYS9hcmNoL3NoL2JvYXJkcy9tYWNoLWxhbmRpc2svZ2lvLmMgYi9hcmNoL3NoL2JvYXJkcy9tYWNoLWxhbmRpc2svZ2lvLmMKaW5kZXggMjVjZGY3MzUuLjUyODAxMzEgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvYm9hcmRzL21hY2gtbGFuZGlzay9naW8uYworKysgYi9hcmNoL3NoL2JvYXJkcy9tYWNoLWxhbmRpc2svZ2lvLmMKQEAgLTE0LDcgKzE0LDYgQEAKICAqLwogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KLSNpbmNsdWRlIDxsaW51eC9zbXBfbG9jay5oPgogI2luY2x1ZGUgPGxpbnV4L2tkZXZfdC5oPgogI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4KICNpbmNsdWRlIDxsaW51eC9mcy5oPgpAQCAtMzUsNyArMzQsNyBAQAogCWludCBtaW5vcjsKIAlpbnQgcmV0ID0gLUVOT0VOVDsKIAotCWxvY2tfa2VybmVsKCk7CisJcHJlZW1wdF9kaXNhYmxlKCk7CiAJbWlub3IgPSBNSU5PUihpbm9kZS0+aV9yZGV2KTsKIAlpZiAobWlub3IgPCBERVZDT1VOVCkgewogCQlpZiAob3BlbkNudCA+IDApIHsKQEAgLTQ1LDcgKzQ0LDcgQEAKIAkJCXJldCA9IDA7CiAJCX0KIAl9Ci0JdW5sb2NrX2tlcm5lbCgpOworCXByZWVtcHRfZW5hYmxlKCk7CiAJcmV0dXJuIHJldDsKIH0KIApAQCAtNjAsOCArNTksNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IGdpb19pb2N0bChzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlscCwKLQkJCSAgICAgdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCitzdGF0aWMgbG9uZyBnaW9faW9jdGwoc3RydWN0IGZpbGUgKmZpbHAsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQogewogCXVuc2lnbmVkIGludCBkYXRhOwogCXN0YXRpYyB1bnNpZ25lZCBpbnQgYWRkciA9IDA7CkBAIC0xMjksNyArMTI3LDcgQEAKIAkub3duZXIgPSBUSElTX01PRFVMRSwKIAkub3BlbiA9IGdpb19vcGVuLAkvKiBvcGVuICovCiAJLnJlbGVhc2UgPSBnaW9fY2xvc2UsCS8qIHJlbGVhc2UgKi8KLQkuaW9jdGwgPSBnaW9faW9jdGwsCS8qIGlvY3RsICovCisJLnVubG9ja2VkX2lvY3RsID0gZ2lvX2lvY3RsLAogfTsKIAogc3RhdGljIGludCBfX2luaXQgZ2lvX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL2NwdS9zaDMvZW50cnkuUyBiL2FyY2gvc2gva2VybmVsL2NwdS9zaDMvZW50cnkuUwppbmRleCAwMTUxOTMzLi5iYjQwN2VmIDEwMDY0NAotLS0gYS9hcmNoL3NoL2tlcm5lbC9jcHUvc2gzL2VudHJ5LlMKKysrIGIvYXJjaC9zaC9rZXJuZWwvY3B1L3NoMy9lbnRyeS5TCkBAIC0xNTIsOCArMTUyLDYgQEAKIAltb3YubAkxZiwgcjAKIAltb3YubAlAcjAsIHI2CiAKLQlzdGkKLQogCW1vdi5sCTNmLCByMAogCW1vdi5sCTRmLCByMQogCW1vdglyMTUsIHI0CmRpZmYgLS1naXQgYS9hcmNoL3NoL2tlcm5lbC9lbnRyeS1jb21tb24uUyBiL2FyY2gvc2gva2VybmVsL2VudHJ5LWNvbW1vbi5TCmluZGV4IDY4ZDkyMjMuLjNlYjg0OTMgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gva2VybmVsL2VudHJ5LWNvbW1vbi5TCisrKyBiL2FyY2gvc2gva2VybmVsL2VudHJ5LWNvbW1vbi5TCkBAIC0xMjEsNyArMTIxLDcgQEAKIEVOVFJZKHJlc3VtZV91c2Vyc3BhY2UpCiAJISByODogY3VycmVudF90aHJlYWRfaW5mbwogCWNsaQotCVRSQUNFX0lSUVNfT2ZGCisJVFJBQ0VfSVJRU19PRkYKIAltb3YubAlAKFRJX0ZMQUdTLHI4KSwgcjAJCSEgY3VycmVudF90aHJlYWRfaW5mby0+ZmxhZ3MKIAl0c3QJIyhfVElGX1dPUktfTUFTSyAmIDB4ZmYpLCByMAogCWJ0L3MJX19yZXN0b3JlX2FsbApkaWZmIC0tZ2l0IGEvYXJjaC9zaC9rZXJuZWwvZnRyYWNlLmMgYi9hcmNoL3NoL2tlcm5lbC9mdHJhY2UuYwppbmRleCBhM2RjYzZkLi4yYzQ4ZTI2IDEwMDY0NAotLS0gYS9hcmNoL3NoL2tlcm5lbC9mdHJhY2UuYworKysgYi9hcmNoL3NoL2tlcm5lbC9mdHJhY2UuYwpAQCAtMjkxLDMxICsyOTEsNDggQEAKIAlyZXR1cm4gc3lzY2FsbHNfbWV0YWRhdGFbbnJdOwogfQogCi12b2lkIGFyY2hfaW5pdF9mdHJhY2Vfc3lzY2FsbHModm9pZCkKK2ludCBzeXNjYWxsX25hbWVfdG9fbnIoY2hhciAqbmFtZSkKK3sKKwlpbnQgaTsKKworCWlmICghc3lzY2FsbHNfbWV0YWRhdGEpCisJCXJldHVybiAtMTsKKwlmb3IgKGkgPSAwOyBpIDwgTlJfc3lzY2FsbHM7IGkrKykKKwkJaWYgKHN5c2NhbGxzX21ldGFkYXRhW2ldKQorCQkJaWYgKCFzdHJjbXAoc3lzY2FsbHNfbWV0YWRhdGFbaV0tPm5hbWUsIG5hbWUpKQorCQkJCXJldHVybiBpOworCXJldHVybiAtMTsKK30KKwordm9pZCBzZXRfc3lzY2FsbF9lbnRlcl9pZChpbnQgbnVtLCBpbnQgaWQpCit7CisJc3lzY2FsbHNfbWV0YWRhdGFbbnVtXS0+ZW50ZXJfaWQgPSBpZDsKK30KKwordm9pZCBzZXRfc3lzY2FsbF9leGl0X2lkKGludCBudW0sIGludCBpZCkKK3sKKwlzeXNjYWxsc19tZXRhZGF0YVtudW1dLT5leGl0X2lkID0gaWQ7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IGFyY2hfaW5pdF9mdHJhY2Vfc3lzY2FsbHModm9pZCkKIHsKIAlpbnQgaTsKIAlzdHJ1Y3Qgc3lzY2FsbF9tZXRhZGF0YSAqbWV0YTsKIAl1bnNpZ25lZCBsb25nICoqcHN5c19zeXNjYWxsX3RhYmxlID0gJnN5c19jYWxsX3RhYmxlOwotCXN0YXRpYyBhdG9taWNfdCByZWZzOwotCi0JaWYgKGF0b21pY19pbmNfcmV0dXJuKCZyZWZzKSAhPSAxKQotCQlnb3RvIGVuZDsKIAogCXN5c2NhbGxzX21ldGFkYXRhID0ga3phbGxvYyhzaXplb2YoKnN5c2NhbGxzX21ldGFkYXRhKSAqCiAJCQkJCUZUUkFDRV9TWVNDQUxMX01BWCwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFzeXNjYWxsc19tZXRhZGF0YSkgewogCQlXQVJOX09OKDEpOwotCQlyZXR1cm47CisJCXJldHVybiAtRU5PTUVNOwogCX0KIAogCWZvciAoaSA9IDA7IGkgPCBGVFJBQ0VfU1lTQ0FMTF9NQVg7IGkrKykgewogCQltZXRhID0gZmluZF9zeXNjYWxsX21ldGEocHN5c19zeXNjYWxsX3RhYmxlW2ldKTsKIAkJc3lzY2FsbHNfbWV0YWRhdGFbaV0gPSBtZXRhOwogCX0KLQlyZXR1cm47CiAKLQkvKiBQYXJhbm9pZDogYXZvaWQgb3ZlcmZsb3cgKi8KLWVuZDoKLQlhdG9taWNfZGVjKCZyZWZzKTsKKwlyZXR1cm4gMDsKIH0KK2FyY2hfaW5pdGNhbGwoYXJjaF9pbml0X2Z0cmFjZV9zeXNjYWxscyk7CiAjZW5kaWYgLyogQ09ORklHX0ZUUkFDRV9TWVNDQUxMUyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9rZXJuZWwvaW9fZ2VuZXJpYy5jIGIvYXJjaC9zaC9rZXJuZWwvaW9fZ2VuZXJpYy5jCmluZGV4IDRmZjUwNzIuLmI4ZmE2NTIgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gva2VybmVsL2lvX2dlbmVyaWMuYworKysgYi9hcmNoL3NoL2tlcm5lbC9pb19nZW5lcmljLmMKQEAgLTE0Nyw2ICsxNDcsOSBAQAogCiB2b2lkIF9faW9tZW0gKmdlbmVyaWNfaW9wb3J0X21hcCh1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGludCBzaXplKQogeworCWlmIChQWFNFRyhhZGRyKSA+PSBQMVNFRykKKwkJcmV0dXJuICh2b2lkIF9faW9tZW0gKilhZGRyOworCiAJcmV0dXJuICh2b2lkIF9faW9tZW0gKikoYWRkciArIGdlbmVyaWNfaW9fYmFzZSk7CiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL21hY2h2ZWMuYyBiL2FyY2gvc2gva2VybmVsL21hY2h2ZWMuYwppbmRleCA1NDhmNjYwLi5jYmNlNjM5IDEwMDY0NAotLS0gYS9hcmNoL3NoL2tlcm5lbC9tYWNodmVjLmMKKysrIGIvYXJjaC9zaC9rZXJuZWwvbWFjaHZlYy5jCkBAIC0xNCw2ICsxNCw3IEBACiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8YXNtL21hY2h2ZWMuaD4KICNpbmNsdWRlIDxhc20vc2VjdGlvbnMuaD4KKyNpbmNsdWRlIDxhc20vYWRkcnNwYWNlLmg+CiAjaW5jbHVkZSA8YXNtL3NldHVwLmg+CiAjaW5jbHVkZSA8YXNtL2lvLmg+CiAjaW5jbHVkZSA8YXNtL2lycS5oPgpAQCAtMTMzLDQgKzEzNCw2IEBACiAKIAlpZiAoIXNoX212Lm12X25yX2lycXMpCiAJCXNoX212Lm12X25yX2lycXMgPSBOUl9JUlFTOworCisJX19zZXRfaW9fcG9ydF9iYXNlKFAyU0VHKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL3NldHVwLmMgYi9hcmNoL3NoL2tlcm5lbC9zZXR1cC5jCmluZGV4IGY5ZDQ0ZjguLjk5YjRmYjUgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gva2VybmVsL3NldHVwLmMKKysrIGIvYXJjaC9zaC9rZXJuZWwvc2V0dXAuYwpAQCAtNTQ5LDYgKzU0OSw4IEBACiAKIAlpZiAoY3B1ID09IDApCiAJCXNlcV9wcmludGYobSwgIm1hY2hpbmVcdFx0OiAlc1xuIiwgZ2V0X3N5c3RlbV90eXBlKCkpOworCWVsc2UKKwkJc2VxX3ByaW50ZihtLCAiXG4iKTsKIAogCXNlcV9wcmludGYobSwgInByb2Nlc3Nvclx0OiAlZFxuIiwgY3B1KTsKIAlzZXFfcHJpbnRmKG0sICJjcHUgZmFtaWx5XHQ6ICVzXG4iLCBpbml0X3V0c25hbWUoKS0+bWFjaGluZSk7CmRpZmYgLS1naXQgYS9hcmNoL3NoL2tlcm5lbC9zaF9rc3ltc18zMi5jIGIvYXJjaC9zaC9rZXJuZWwvc2hfa3N5bXNfMzIuYwppbmRleCA4ZGJlMjZiLi44NmMyNzA0IDEwMDY0NAotLS0gYS9hcmNoL3NoL2tlcm5lbC9zaF9rc3ltc18zMi5jCisrKyBiL2FyY2gvc2gva2VybmVsL3NoX2tzeW1zXzMyLmMKQEAgLTg0LDYgKzg0LDcgQEAKIERFQ0xBUkVfRVhQT1JUKF9fbW92c3RyX2k0X2V2ZW4pOwogREVDTEFSRV9FWFBPUlQoX19tb3ZzdHJfaTRfb2RkKTsKIERFQ0xBUkVfRVhQT1JUKF9fbW92c3RyU0kxMl9pNCk7CitERUNMQVJFX0VYUE9SVChfX21vdm1lbSk7CiBERUNMQVJFX0VYUE9SVChfX21vdm1lbV9pNF9ldmVuKTsKIERFQ0xBUkVfRVhQT1JUKF9fbW92bWVtX2k0X29kZCk7CiBERUNMQVJFX0VYUE9SVChfX21vdm1lbVNJMTJfaTQpOwpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9rZXJuZWwvc2lnbmFsXzMyLmMgYi9hcmNoL3NoL2tlcm5lbC9zaWduYWxfMzIuYwppbmRleCA2NzI5NzAzLi4zZGIzNzQyIDEwMDY0NAotLS0gYS9hcmNoL3NoL2tlcm5lbC9zaWduYWxfMzIuYworKysgYi9hcmNoL3NoL2tlcm5lbC9zaWduYWxfMzIuYwpAQCAtMTQ1LDcgKzE0NSw3IEBACiB7CiAJc3RydWN0IHRhc2tfc3RydWN0ICp0c2sgPSBjdXJyZW50OwogCi0JaWYgKCEoY3VycmVudF9jcHVfZGF0YS5mbGFncyAmIENQVV9IQVNfRlBVKSkKKwlpZiAoIShib290X2NwdV9kYXRhLmZsYWdzICYgQ1BVX0hBU19GUFUpKQogCQlyZXR1cm4gMDsKIAogCXNldF91c2VkX21hdGgoKTsKQEAgLTE1OCw3ICsxNTgsNyBAQAogewogCXN0cnVjdCB0YXNrX3N0cnVjdCAqdHNrID0gY3VycmVudDsKIAotCWlmICghKGN1cnJlbnRfY3B1X2RhdGEuZmxhZ3MgJiBDUFVfSEFTX0ZQVSkpCisJaWYgKCEoYm9vdF9jcHVfZGF0YS5mbGFncyAmIENQVV9IQVNfRlBVKSkKIAkJcmV0dXJuIDA7CiAKIAlpZiAoIXVzZWRfbWF0aCgpKSB7CkBAIC0xOTksNyArMTk5LDcgQEAKICN1bmRlZiBDT1BZCiAKICNpZmRlZiBDT05GSUdfU0hfRlBVCi0JaWYgKGN1cnJlbnRfY3B1X2RhdGEuZmxhZ3MgJiBDUFVfSEFTX0ZQVSkgeworCWlmIChib290X2NwdV9kYXRhLmZsYWdzICYgQ1BVX0hBU19GUFUpIHsKIAkJaW50IG93bmVkX2ZwOwogCQlzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzayA9IGN1cnJlbnQ7CiAKQEAgLTQ3Miw2ICs0NzIsNyBAQAogCQllcnIgfD0gX19wdXRfdXNlcihPUl9SMF9SMCwgJmZyYW1lLT5yZXRjb2RlWzZdKTsKIAkJZXJyIHw9IF9fcHV0X3VzZXIoKF9fTlJfcnRfc2lncmV0dXJuKSwgJmZyYW1lLT5yZXRjb2RlWzddKTsKIAkJcmVncy0+cHIgPSAodW5zaWduZWQgbG9uZykgZnJhbWUtPnJldGNvZGU7CisJCWZsdXNoX2ljYWNoZV9yYW5nZShyZWdzLT5wciwgcmVncy0+cHIgKyBzaXplb2YoZnJhbWUtPnJldGNvZGUpKTsKIAl9CiAKIAlpZiAoZXJyKQpAQCAtNDk3LDggKzQ5OCw2IEBACiAJcHJfZGVidWcoIlNJRyBkZWxpdmVyICglczolZCk6IHNwPSVwIHBjPSUwOGx4IHByPSUwOGx4XG4iLAogCQkgY3VycmVudC0+Y29tbSwgdGFza19waWRfbnIoY3VycmVudCksIGZyYW1lLCByZWdzLT5wYywgcmVncy0+cHIpOwogCi0JZmx1c2hfaWNhY2hlX3JhbmdlKHJlZ3MtPnByLCByZWdzLT5wciArIHNpemVvZihmcmFtZS0+cmV0Y29kZSkpOwotCiAJcmV0dXJuIDA7CiAKIGdpdmVfc2lnc2VndjoKZGlmZiAtLWdpdCBhL2FyY2gvc2gva2VybmVsL3NtcC5jIGIvYXJjaC9zaC9rZXJuZWwvc21wLmMKaW5kZXggNDQyZDhkNC4uMTYwZGIxMCAxMDA2NDQKLS0tIGEvYXJjaC9zaC9rZXJuZWwvc21wLmMKKysrIGIvYXJjaC9zaC9rZXJuZWwvc21wLmMKQEAgLTM1LDYgKzM1LDggQEAKIHsKIAlzdHJ1Y3Qgc2hfY3B1aW5mbyAqYyA9IGNwdV9kYXRhICsgY3B1OwogCisJbWVtY3B5KGMsICZib290X2NwdV9kYXRhLCBzaXplb2Yoc3RydWN0IHNoX2NwdWluZm8pKTsKKwogCWMtPmxvb3BzX3Blcl9qaWZmeSA9IGxvb3BzX3Blcl9qaWZmeTsKIH0KIApkaWZmIC0tZ2l0IGEvYXJjaC9zaC9rZXJuZWwvdHJhcHNfMzIuYyBiL2FyY2gvc2gva2VybmVsL3RyYXBzXzMyLmMKaW5kZXggNjliYjE2NS4uN2EyZWUzYSAxMDA2NDQKLS0tIGEvYXJjaC9zaC9rZXJuZWwvdHJhcHNfMzIuYworKysgYi9hcmNoL3NoL2tlcm5lbC90cmFwc18zMi5jCkBAIC0yNSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8bGludXgva2V4ZWMuaD4KICNpbmNsdWRlIDxsaW51eC9saW1pdHMuaD4KICNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CisjaW5jbHVkZSA8bGludXgvc3lzZnMuaD4KICNpbmNsdWRlIDxhc20vc3lzdGVtLmg+CiAjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KICNpbmNsdWRlIDxhc20vZnB1Lmg+CkBAIC01NCw4ICs1NSw4IEBACiAvKiBiaXRmaWVsZDogMTogd2FybiAyOiBmaXh1cCA0OiBzaWduYWwgLT4gY29tYmluYXRpb25zIDJ8NCAmJiAxfDJ8NCBhcmUgbm90CiAgICB2YWxpZCEgKi8KIHN0YXRpYyBpbnQgc2VfdXNlcm1vZGUgPSAzOwotLyogMDogbm8gd2FybmluZyAxOiBwcmludCBhIHdhcm5pbmcgbWVzc2FnZSAqLwotc3RhdGljIGludCBzZV9rZXJubW9kZV93YXJuID0gMTsKKy8qIDA6IG5vIHdhcm5pbmcgMTogcHJpbnQgYSB3YXJuaW5nIG1lc3NhZ2UsIGRpc2FibGVkIGJ5IGRlZmF1bHQgKi8KK3N0YXRpYyBpbnQgc2Vfa2Vybm1vZGVfd2FybjsKIAogI2lmZGVmIENPTkZJR19QUk9DX0ZTCiBzdGF0aWMgY29uc3QgY2hhciAqc2VfdXNlcm1vZGVfYWN0aW9uW10gPSB7CkBAIC0xNTksMTIgKzE2MCwxMiBAQAogCiAJb29wc19lbnRlcigpOwogCi0JY29uc29sZV92ZXJib3NlKCk7CiAJc3Bpbl9sb2NrX2lycSgmZGllX2xvY2spOworCWNvbnNvbGVfdmVyYm9zZSgpOwogCWJ1c3Rfc3BpbmxvY2tzKDEpOwogCiAJcHJpbnRrKCIlczogJTA0bHggWyMlZF1cbiIsIHN0ciwgZXJyICYgMHhmZmZmLCArK2RpZV9jb3VudGVyKTsKLQorCXN5c2ZzX3ByaW50a19sYXN0X2ZpbGUoKTsKIAlwcmludF9tb2R1bGVzKCk7CiAJc2hvd19yZWdzKHJlZ3MpOwogCkBAIC0xODAsNiArMTgxLDcgQEAKIAlidXN0X3NwaW5sb2NrcygwKTsKIAlhZGRfdGFpbnQoVEFJTlRfRElFKTsKIAlzcGluX3VubG9ja19pcnEoJmRpZV9sb2NrKTsKKwlvb3BzX2V4aXQoKTsKIAogCWlmIChrZXhlY19zaG91bGRfY3Jhc2goY3VycmVudCkpCiAJCWNyYXNoX2tleGVjKHJlZ3MpOwpAQCAtMTkwLDcgKzE5Miw2IEBACiAJaWYgKHBhbmljX29uX29vcHMpCiAJCXBhbmljKCJGYXRhbCBleGNlcHRpb24iKTsKIAotCW9vcHNfZXhpdCgpOwogCWRvX2V4aXQoU0lHU0VHVik7CiB9CiAKZGlmZiAtLWdpdCBhL2FyY2gvc2gvbW0vY2FjaGUtc2g0LmMgYi9hcmNoL3NoL21tL2NhY2hlLXNoNC5jCmluZGV4IGIyNDUzYmIuLjUxOWUyZDEgMTAwNjQ0Ci0tLSBhL2FyY2gvc2gvbW0vY2FjaGUtc2g0LmMKKysrIGIvYXJjaC9zaC9tbS9jYWNoZS1zaDQuYwpAQCAtMjYsNyArMjYsNyBAQAogI2RlZmluZSBNQVhfRENBQ0hFX1BBR0VTCTY0CS8qIFhYWDogVHVuZSBmb3Igd2F5cyAqLwogI2RlZmluZSBNQVhfSUNBQ0hFX1BBR0VTCTMyCiAKLXN0YXRpYyB2b2lkIF9fZmx1c2hfY2FjaGVfNDA5Nih1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgcGh5cywKK3N0YXRpYyB2b2lkIF9fZmx1c2hfY2FjaGVfb25lKHVuc2lnbmVkIGxvbmcgYWRkciwgdW5zaWduZWQgbG9uZyBwaHlzLAogCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgZXhlY19vZmZzZXQpOwogCiAvKgpAQCAtNDMsNyArNDMsNyBAQAogICogQ2FsbGVkIGZyb20ga2VybmVsL21vZHVsZS5jOnN5c19pbml0X21vZHVsZSBhbmQgcm91dGluZSBmb3IgYS5vdXQgZm9ybWF0LAogICogc2lnbmFsIGhhbmRsZXIgY29kZSBhbmQga3Byb2JlcyBjb2RlCiAgKi8KLXN0YXRpYyB2b2lkIHNoNF9mbHVzaF9pY2FjaGVfcmFuZ2Uodm9pZCAqYXJncykKK3N0YXRpYyB2b2lkIF9fdXNlc19qdW1wX3RvX3VuY2FjaGVkIHNoNF9mbHVzaF9pY2FjaGVfcmFuZ2Uodm9pZCAqYXJncykKIHsKIAlzdHJ1Y3QgZmx1c2hlcl9kYXRhICpkYXRhID0gYXJnczsKIAl1bnNpZ25lZCBsb25nIHN0YXJ0LCBlbmQ7CkBAIC04OSw4ICs4OSw3IEBACiAJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfY2FjaGVfNDA5Nih1bnNpZ25lZCBsb25nIHN0YXJ0LAotCQkJCSAgICB1bnNpZ25lZCBsb25nIHBoeXMpCitzdGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfY2FjaGVfb25lKHVuc2lnbmVkIGxvbmcgc3RhcnQsIHVuc2lnbmVkIGxvbmcgcGh5cykKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzLCBleGVjX29mZnNldCA9IDA7CiAKQEAgLTEwMyw4ICsxMDIsNyBAQAogCQlleGVjX29mZnNldCA9IDB4MjAwMDAwMDA7CiAKIAlsb2NhbF9pcnFfc2F2ZShmbGFncyk7Ci0JX19mbHVzaF9jYWNoZV80MDk2KHN0YXJ0IHwgU0hfQ0FDSEVfQVNTT0MsCi0JCQkgICBQMVNFR0FERFIocGh5cyksIGV4ZWNfb2Zmc2V0KTsKKwlfX2ZsdXNoX2NhY2hlX29uZShzdGFydCB8IFNIX0NBQ0hFX0FTU09DLCBQMVNFR0FERFIocGh5cyksIGV4ZWNfb2Zmc2V0KTsKIAlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiB9CiAKQEAgLTEyOSw4ICsxMjcsOCBAQAogCiAJCS8qIExvb3AgYWxsIHRoZSBELWNhY2hlICovCiAJCW4gPSBib290X2NwdV9kYXRhLmRjYWNoZS5uX2FsaWFzZXM7Ci0JCWZvciAoaSA9IDA7IGkgPCBuOyBpKyssIGFkZHIgKz0gNDA5NikKLQkJCWZsdXNoX2NhY2hlXzQwOTYoYWRkciwgcGh5cyk7CisJCWZvciAoaSA9IDA7IGkgPCBuOyBpKyssIGFkZHIgKz0gUEFHRV9TSVpFKQorCQkJZmx1c2hfY2FjaGVfb25lKGFkZHIsIHBoeXMpOwogCX0KIAogCXdtYigpOwpAQCAtMzE4LDExICszMTYsMTEgQEAKIAkvKiBXZSBvbmx5IG5lZWQgdG8gZmx1c2ggRC1jYWNoZSB3aGVuIHdlIGhhdmUgYWxpYXMgKi8KIAlpZiAoKGFkZHJlc3NecGh5cykgJiBhbGlhc19tYXNrKSB7CiAJCS8qIExvb3AgNEsgb2YgdGhlIEQtY2FjaGUgKi8KLQkJZmx1c2hfY2FjaGVfNDA5NigKKwkJZmx1c2hfY2FjaGVfb25lKAogCQkJQ0FDSEVfT0NfQUREUkVTU19BUlJBWSB8IChhZGRyZXNzICYgYWxpYXNfbWFzayksCiAJCQlwaHlzKTsKIAkJLyogTG9vcCBhbm90aGVyIDRLIG9mIHRoZSBELWNhY2hlICovCi0JCWZsdXNoX2NhY2hlXzQwOTYoCisJCWZsdXNoX2NhY2hlX29uZSgKIAkJCUNBQ0hFX09DX0FERFJFU1NfQVJSQVkgfCAocGh5cyAmIGFsaWFzX21hc2spLAogCQkJcGh5cyk7CiAJfQpAQCAtMzM3LDcgKzMzNSw3IEBACiAJCSAqIGtlcm5lbCBoYXMgbmV2ZXIgZXhlY3V0ZWQgdGhlIGNvZGUgdGhyb3VnaCBpdHMgaWRlbnRpdHkKIAkJICogdHJhbnNsYXRpb24uCiAJCSAqLwotCQlmbHVzaF9jYWNoZV80MDk2KAorCQlmbHVzaF9jYWNoZV9vbmUoCiAJCQlDQUNIRV9JQ19BRERSRVNTX0FSUkFZIHwgKGFkZHJlc3MgJiBhbGlhc19tYXNrKSwKIAkJCXBoeXMpOwogCX0KQEAgLTM5Myw3ICszOTEsNyBAQAogfQogCiAvKioKLSAqIF9fZmx1c2hfY2FjaGVfNDA5NgorICogX19mbHVzaF9jYWNoZV9vbmUKICAqCiAgKiBAYWRkcjogIGFkZHJlc3MgaW4gbWVtb3J5IG1hcHBlZCBjYWNoZSBhcnJheQogICogQHBoeXM6ICBQMSBhZGRyZXNzIHRvIGZsdXNoIChoYXMgdG8gbWF0Y2ggdGFncyBpZiBhZGRyIGhhcyAnQScgYml0CkBAIC00MDYsNyArNDA0LDcgQEAKICAqIG9wZXJhdGlvbiAocHVyZ2Uvd3JpdGUtYmFjaykgaXMgc2VsZWN0ZWQgYnkgdGhlIGxvd2VyIDIgYml0cyBvZgogICogJ3BoeXMnLgogICovCi1zdGF0aWMgdm9pZCBfX2ZsdXNoX2NhY2hlXzQwOTYodW5zaWduZWQgbG9uZyBhZGRyLCB1bnNpZ25lZCBsb25nIHBoeXMsCitzdGF0aWMgdm9pZCBfX2ZsdXNoX2NhY2hlX29uZSh1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgcGh5cywKIAkJCSAgICAgICB1bnNpZ25lZCBsb25nIGV4ZWNfb2Zmc2V0KQogewogCWludCB3YXlfY291bnQ7CmRpZmYgLS1naXQgYS9hcmNoL3NoL21tL2NhY2hlLXNoNzcwNS5jIGIvYXJjaC9zaC9tbS9jYWNoZS1zaDc3MDUuYwppbmRleCAyY2FkZWUyLi4yNjAxOTM1IDEwMDY0NAotLS0gYS9hcmNoL3NoL21tL2NhY2hlLXNoNzcwNS5jCisrKyBiL2FyY2gvc2gvbW0vY2FjaGUtc2g3NzA1LmMKQEAgLTc4LDcgKzc4LDcgQEAKIC8qCiAgKiBXcml0ZWJhY2smSW52YWxpZGF0ZSB0aGUgRC1jYWNoZSBvZiB0aGUgcGFnZQogICovCi1zdGF0aWMgdm9pZCBfX2ZsdXNoX2RjYWNoZV9wYWdlKHVuc2lnbmVkIGxvbmcgcGh5cykKK3N0YXRpYyB2b2lkIF9fdXNlc19qdW1wX3RvX3VuY2FjaGVkIF9fZmx1c2hfZGNhY2hlX3BhZ2UodW5zaWduZWQgbG9uZyBwaHlzKQogewogCXVuc2lnbmVkIGxvbmcgd2F5cywgd2F5c2l6ZSwgYWRkcnN0YXJ0OwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CkBAIC0xNDQsNyArMTQ0LDcgQEAKIAkJX19mbHVzaF9kY2FjaGVfcGFnZShQSFlTQUREUihwYWdlX2FkZHJlc3MocGFnZSkpKTsKIH0KIAotc3RhdGljIHZvaWQgc2g3NzA1X2ZsdXNoX2NhY2hlX2FsbCh2b2lkICphcmdzKQorc3RhdGljIHZvaWQgX191c2VzX2p1bXBfdG9fdW5jYWNoZWQgc2g3NzA1X2ZsdXNoX2NhY2hlX2FsbCh2b2lkICphcmdzKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKZGlmZiAtLWdpdCBhL2FyY2gvc2gvbW0vY2FjaGUuYyBiL2FyY2gvc2gvbW0vY2FjaGUuYwppbmRleCAzNWMzN2I3Li5hMmRjN2Y5IDEwMDY0NAotLS0gYS9hcmNoL3NoL21tL2NhY2hlLmMKKysrIGIvYXJjaC9zaC9tbS9jYWNoZS5jCkBAIC0xMjgsNyArMTI4LDcgQEAKIAkJcmV0dXJuOwogCiAJcGFnZSA9IHBmbl90b19wYWdlKHBmbik7Ci0JaWYgKHBmbl92YWxpZChwZm4pICYmIHBhZ2VfbWFwcGluZyhwYWdlKSkgeworCWlmIChwZm5fdmFsaWQocGZuKSkgewogCQlpbnQgZGlydHkgPSB0ZXN0X2FuZF9jbGVhcl9iaXQoUEdfZGNhY2hlX2RpcnR5LCAmcGFnZS0+ZmxhZ3MpOwogCQlpZiAoZGlydHkpIHsKIAkJCXVuc2lnbmVkIGxvbmcgYWRkciA9ICh1bnNpZ25lZCBsb25nKXBhZ2VfYWRkcmVzcyhwYWdlKTsKQEAgLTI2NSw2ICsyNjUsOCBAQAogCiB2b2lkIF9faW5pdCBjcHVfY2FjaGVfaW5pdCh2b2lkKQogeworCXVuc2lnbmVkIGludCBjYWNoZV9kaXNhYmxlZCA9ICEoX19yYXdfcmVhZGwoQ0NSKSAmIENDUl9DQUNIRV9FTkFCTEUpOworCiAJY29tcHV0ZV9hbGlhcygmYm9vdF9jcHVfZGF0YS5pY2FjaGUpOwogCWNvbXB1dGVfYWxpYXMoJmJvb3RfY3B1X2RhdGEuZGNhY2hlKTsKIAljb21wdXRlX2FsaWFzKCZib290X2NwdV9kYXRhLnNjYWNoZSk7CkBAIC0yNzMsNiArMjc1LDEzIEBACiAJX19mbHVzaF9wdXJnZV9yZWdpb24JCT0gbm9vcF9fZmx1c2hfcmVnaW9uOwogCV9fZmx1c2hfaW52YWxpZGF0ZV9yZWdpb24JPSBub29wX19mbHVzaF9yZWdpb247CiAKKwkvKgorCSAqIE5vIGZsdXNoaW5nIGlzIG5lY2Vzc2FyeSBpbiB0aGUgZGlzYWJsZWQgY2FjaGUgY2FzZSBzbyB3ZSBjYW4KKwkgKiBqdXN0IGtlZXAgdGhlIG5vb3AgZnVuY3Rpb25zIGluIGxvY2FsX2ZsdXNoXy4uKCkgYW5kIF9fZmx1c2hfLi4oKQorCSAqLworCWlmICh1bmxpa2VseShjYWNoZV9kaXNhYmxlZCkpCisJCWdvdG8gc2tpcDsKKwogCWlmIChib290X2NwdV9kYXRhLmZhbWlseSA9PSBDUFVfRkFNSUxZX1NIMikgewogCQlleHRlcm4gdm9pZCBfX3dlYWsgc2gyX2NhY2hlX2luaXQodm9pZCk7CiAKQEAgLTMxMiw1ICszMjEsNiBAQAogCQlzaDVfY2FjaGVfaW5pdCgpOwogCX0KIAorc2tpcDoKIAllbWl0X2NhY2hlX3BhcmFtcygpOwogfQpkaWZmIC0tZ2l0IGEvYXJjaC9zaC9tbS9pb3JlbWFwXzMyLmMgYi9hcmNoL3NoL21tL2lvcmVtYXBfMzIuYwppbmRleCBjMzI1MDYxLi5hODZlYWE5IDEwMDY0NAotLS0gYS9hcmNoL3NoL21tL2lvcmVtYXBfMzIuYworKysgYi9hcmNoL3NoL21tL2lvcmVtYXBfMzIuYwpAQCAtODMsNyArODMsNyBAQAogCSAqCiAJICogUE1CIGVudHJpZXMgYXJlIGFsbCBwcmUtZmF1bHRlZC4KIAkgKi8KLQlpZiAodW5saWtlbHkoc2l6ZSA+PSAweDEwMDAwMDApKSB7CisJaWYgKHVubGlrZWx5KHBoeXNfYWRkciA+PSBQMVNFRykpIHsKIAkJdW5zaWduZWQgbG9uZyBtYXBwZWQgPSBwbWJfcmVtYXAoYWRkciwgcGh5c19hZGRyLCBzaXplLCBmbGFncyk7CiAKIAkJaWYgKGxpa2VseShtYXBwZWQpKSB7CmRpZmYgLS1naXQgYS9hcmNoL3NoL21tL3BtYi5jIGIvYXJjaC9zaC9tbS9wbWIuYwppbmRleCBiMWE3MTRhLi5hYWRlMzExIDEwMDY0NAotLS0gYS9hcmNoL3NoL21tL3BtYi5jCisrKyBiL2FyY2gvc2gvbW0vcG1iLmMKQEAgLTMzLDYgKzMzLDggQEAKIAogI2RlZmluZSBOUl9QTUJfRU5UUklFUwkxNgogCitzdGF0aWMgdm9pZCBfX3BtYl91bm1hcChzdHJ1Y3QgcG1iX2VudHJ5ICopOworCiBzdGF0aWMgc3RydWN0IGttZW1fY2FjaGUgKnBtYl9jYWNoZTsKIHN0YXRpYyB1bnNpZ25lZCBsb25nIHBtYl9tYXA7CiAKQEAgLTIxOCw5ICsyMjAsMTAgQEAKIGxvbmcgcG1iX3JlbWFwKHVuc2lnbmVkIGxvbmcgdmFkZHIsIHVuc2lnbmVkIGxvbmcgcGh5cywKIAkgICAgICAgdW5zaWduZWQgbG9uZyBzaXplLCB1bnNpZ25lZCBsb25nIGZsYWdzKQogewotCXN0cnVjdCBwbWJfZW50cnkgKnBtYnA7CisJc3RydWN0IHBtYl9lbnRyeSAqcG1icCwgKnBtYmU7CiAJdW5zaWduZWQgbG9uZyB3YW50ZWQ7CiAJaW50IHBtYl9mbGFncywgaTsKKwlsb25nIGVycjsKIAogCS8qIENvbnZlcnQgdHlwaWNhbCBwZ3Byb3QgdmFsdWUgdG8gdGhlIFBNQiBlcXVpdmFsZW50ICovCiAJaWYgKGZsYWdzICYgX1BBR0VfQ0FDSEFCTEUpIHsKQEAgLTIzNiwyMCArMjM5LDIyIEBACiAKIGFnYWluOgogCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHBtYl9zaXplcyk7IGkrKykgewotCQlzdHJ1Y3QgcG1iX2VudHJ5ICpwbWJlOwogCQlpbnQgcmV0OwogCiAJCWlmIChzaXplIDwgcG1iX3NpemVzW2ldLnNpemUpCiAJCQljb250aW51ZTsKIAogCQlwbWJlID0gcG1iX2FsbG9jKHZhZGRyLCBwaHlzLCBwbWJfZmxhZ3MgfCBwbWJfc2l6ZXNbaV0uZmxhZyk7Ci0JCWlmIChJU19FUlIocG1iZSkpCi0JCQlyZXR1cm4gUFRSX0VSUihwbWJlKTsKKwkJaWYgKElTX0VSUihwbWJlKSkgeworCQkJZXJyID0gUFRSX0VSUihwbWJlKTsKKwkJCWdvdG8gb3V0OworCQl9CiAKIAkJcmV0ID0gc2V0X3BtYl9lbnRyeShwbWJlKTsKIAkJaWYgKHJldCAhPSAwKSB7CiAJCQlwbWJfZnJlZShwbWJlKTsKLQkJCXJldHVybiAtRUJVU1k7CisJCQllcnIgPSAtRUJVU1k7CisJCQlnb3RvIG91dDsKIAkJfQogCiAJCXBoeXMJKz0gcG1iX3NpemVzW2ldLnNpemU7CkBAIC0yNjQsMTIgKzI2OSwyNSBAQAogCQkJcG1icC0+bGluayA9IHBtYmU7CiAKIAkJcG1icCA9IHBtYmU7CisKKwkJLyoKKwkJICogSW5zdGVhZCBvZiB0cnlpbmcgc21hbGxlciBzaXplcyBvbiBldmVyeSBpdGVyYXRpb24KKwkJICogKGV2ZW4gaWYgd2Ugc3VjY2VlZCBpbiBhbGxvY2F0aW5nIHNwYWNlKSwgdHJ5IHVzaW5nCisJCSAqIHBtYl9zaXplc1tpXS5zaXplIGFnYWluLgorCQkgKi8KKwkJaS0tOwogCX0KIAogCWlmIChzaXplID49IDB4MTAwMDAwMCkKIAkJZ290byBhZ2FpbjsKIAogCXJldHVybiB3YW50ZWQgLSBzaXplOworCitvdXQ6CisJaWYgKHBtYnApCisJCV9fcG1iX3VubWFwKHBtYnApOworCisJcmV0dXJuIGVycjsKIH0KIAogdm9pZCBwbWJfdW5tYXAodW5zaWduZWQgbG9uZyBhZGRyKQpAQCAtMjgzLDEyICszMDEsMTkgQEAKIAlpZiAodW5saWtlbHkoIXBtYmUpKQogCQlyZXR1cm47CiAKKwlfX3BtYl91bm1hcChwbWJlKTsKK30KKworc3RhdGljIHZvaWQgX19wbWJfdW5tYXAoc3RydWN0IHBtYl9lbnRyeSAqcG1iZSkKK3sKIAlXQVJOX09OKCF0ZXN0X2JpdChwbWJlLT5lbnRyeSwgJnBtYl9tYXApKTsKIAogCWRvIHsKIAkJc3RydWN0IHBtYl9lbnRyeSAqcG1ibGluayA9IHBtYmU7CiAKLQkJY2xlYXJfcG1iX2VudHJ5KHBtYmUpOworCQlpZiAocG1iZS0+ZW50cnkgIT0gUE1CX05PX0VOVFJZKQorCQkJY2xlYXJfcG1iX2VudHJ5KHBtYmUpOworCiAJCXBtYmUgPSBwbWJsaW5rLT5saW5rOwogCiAJCXBtYl9mcmVlKHBtYmxpbmspOwpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9rZXJuZWwvbGRjLmMgYi9hcmNoL3NwYXJjL2tlcm5lbC9sZGMuYwppbmRleCBhZGY1ZjI3Li5jYjNjNzJjIDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL2tlcm5lbC9sZGMuYworKysgYi9hcmNoL3NwYXJjL2tlcm5lbC9sZGMuYwpAQCAtMTI0MiwxMyArMTI0MiwxMyBAQAogCXNucHJpbnRmKGxwLT50eF9pcnFfbmFtZSwgTERDX0lSUV9OQU1FX01BWCwgIiVzIFRYIiwgbmFtZSk7CiAKIAllcnIgPSByZXF1ZXN0X2lycShscC0+Y2ZnLnJ4X2lycSwgbGRjX3J4LAotCQkJICBJUlFGX1NBTVBMRV9SQU5ET00gfCBJUlFGX1NIQVJFRCwKKwkJCSAgSVJRRl9TQU1QTEVfUkFORE9NIHwgSVJRRl9ESVNBQkxFRCB8IElSUUZfU0hBUkVELAogCQkJICBscC0+cnhfaXJxX25hbWUsIGxwKTsKIAlpZiAoZXJyKQogCQlyZXR1cm4gZXJyOwogCiAJZXJyID0gcmVxdWVzdF9pcnEobHAtPmNmZy50eF9pcnEsIGxkY190eCwKLQkJCSAgSVJRRl9TQU1QTEVfUkFORE9NIHwgSVJRRl9TSEFSRUQsCisJCQkgIElSUUZfU0FNUExFX1JBTkRPTSB8IElSUUZfRElTQUJMRUQgfCBJUlFGX1NIQVJFRCwKIAkJCSAgbHAtPnR4X2lycV9uYW1lLCBscCk7CiAJaWYgKGVycikgewogCQlmcmVlX2lycShscC0+Y2ZnLnJ4X2lycSwgbHApOwpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9rZXJuZWwvcGVyZl9ldmVudC5jIGIvYXJjaC9zcGFyYy9rZXJuZWwvcGVyZl9ldmVudC5jCmluZGV4IDA0ZGI5MjcuLmZhNTkzNmUgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMva2VybmVsL3BlcmZfZXZlbnQuYworKysgYi9hcmNoL3NwYXJjL2tlcm5lbC9wZXJmX2V2ZW50LmMKQEAgLTQzNyw3ICs0MzcsNyBAQAogCS5sb3dlcl9zaGlmdAk9IDYsCiAJLmV2ZW50X21hc2sJPSAweGZmZiwKIAkuaHZfYml0CQk9IDB4OCwKLQkuaXJxX2JpdAk9IDB4MDMsCisJLmlycV9iaXQJPSAweDMwLAogCS51cHBlcl9ub3AJPSAweDIyMCwKIAkubG93ZXJfbm9wCT0gMHgyMjAsCiB9OwpkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9tbS9pbml0XzY0LmMgYi9hcmNoL3NwYXJjL21tL2luaXRfNjQuYwppbmRleCBhNzBhNWUxLi4xODg2ZDM3IDEwMDY0NAotLS0gYS9hcmNoL3NwYXJjL21tL2luaXRfNjQuYworKysgYi9hcmNoL3NwYXJjL21tL2luaXRfNjQuYwpAQCAtMjY1LDcgKzI2NSw3IEBACiAJc3RydWN0IHBhZ2UgKnBhZ2U7CiAKIAlwYWdlID0gcGZuX3RvX3BhZ2UocGZuKTsKLQlpZiAocGFnZSAmJiBwYWdlX21hcHBpbmcocGFnZSkpIHsKKwlpZiAocGFnZSkgewogCQl1bnNpZ25lZCBsb25nIHBnX2ZsYWdzOwogCiAJCXBnX2ZsYWdzID0gcGFnZS0+ZmxhZ3M7CmRpZmYgLS1naXQgYS9hcmNoL3VtL2RyaXZlcnMvbGluZS5jIGIvYXJjaC91bS9kcml2ZXJzL2xpbmUuYwppbmRleCAxNGExMDJlLi5jZjhhOTdmIDEwMDY0NAotLS0gYS9hcmNoL3VtL2RyaXZlcnMvbGluZS5jCisrKyBiL2FyY2gvdW0vZHJpdmVycy9saW5lLmMKQEAgLTUsNiArNSw3IEBACiAKICNpbmNsdWRlICJsaW51eC9pcnFyZXR1cm4uaCIKICNpbmNsdWRlICJsaW51eC9rZC5oIgorI2luY2x1ZGUgImxpbnV4L3NjaGVkLmgiCiAjaW5jbHVkZSAiY2hhbl9rZXJuLmgiCiAjaW5jbHVkZSAiaXJxX2tlcm4uaCIKICNpbmNsdWRlICJpcnFfdXNlci5oIgpkaWZmIC0tZ2l0IGEvYXJjaC91bS9kcml2ZXJzL3BvcnRfa2Vybi5jIGIvYXJjaC91bS9kcml2ZXJzL3BvcnRfa2Vybi5jCmluZGV4IDE5OTMwMDguLjRlYmM4YTMgMTAwNjQ0Ci0tLSBhL2FyY2gvdW0vZHJpdmVycy9wb3J0X2tlcm4uYworKysgYi9hcmNoL3VtL2RyaXZlcnMvcG9ydF9rZXJuLmMKQEAgLTcsNiArNyw3IEBACiAjaW5jbHVkZSAibGludXgvaW50ZXJydXB0LmgiCiAjaW5jbHVkZSAibGludXgvbGlzdC5oIgogI2luY2x1ZGUgImxpbnV4L211dGV4LmgiCisjaW5jbHVkZSAibGludXgvd29ya3F1ZXVlLmgiCiAjaW5jbHVkZSAiYXNtL2F0b21pYy5oIgogI2luY2x1ZGUgImluaXQuaCIKICNpbmNsdWRlICJpcnFfa2Vybi5oIgpkaWZmIC0tZ2l0IGEvYXJjaC91bS9rZXJuZWwvaXJxLmMgYi9hcmNoL3VtL2tlcm5lbC9pcnEuYwppbmRleCA0NTRjZGI0Li4wMzkyNzBiIDEwMDY0NAotLS0gYS9hcmNoL3VtL2tlcm5lbC9pcnEuYworKysgYi9hcmNoL3VtL2tlcm5lbC9pcnEuYwpAQCAtMTAsNiArMTAsNyBAQAogI2luY2x1ZGUgImxpbnV4L2ludGVycnVwdC5oIgogI2luY2x1ZGUgImxpbnV4L2tlcm5lbF9zdGF0LmgiCiAjaW5jbHVkZSAibGludXgvbW9kdWxlLmgiCisjaW5jbHVkZSAibGludXgvc2NoZWQuaCIKICNpbmNsdWRlICJsaW51eC9zZXFfZmlsZS5oIgogI2luY2x1ZGUgImFzLWxheW91dC5oIgogI2luY2x1ZGUgImtlcm5fdXRpbC5oIgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvS2NvbmZpZyBiL2FyY2gveDg2L0tjb25maWcKaW5kZXggYzg3NmJhYy4uMDdlMDExNCAxMDA2NDQKLS0tIGEvYXJjaC94ODYvS2NvbmZpZworKysgYi9hcmNoL3g4Ni9LY29uZmlnCkBAIC00OTEsNyArNDkxLDcgQEAKIHNvdXJjZSAiYXJjaC94ODYveGVuL0tjb25maWciCiAKIGNvbmZpZyBWTUkKLQlib29sICJWTUkgR3Vlc3Qgc3VwcG9ydCIKKwlib29sICJWTUkgR3Vlc3Qgc3VwcG9ydCAoREVQUkVDQVRFRCkiCiAJc2VsZWN0IFBBUkFWSVJUCiAJZGVwZW5kcyBvbiBYODZfMzIKIAktLS1oZWxwLS0tCkBAIC01MDAsNiArNTAwLDE1IEBACiAJICBhdCB0aGUgbW9tZW50KSwgYnkgbGlua2luZyB0aGUga2VybmVsIHRvIGEgR1BMLWVkIFJPTSBtb2R1bGUKIAkgIHByb3ZpZGVkIGJ5IHRoZSBoeXBlcnZpc29yLgogCisJICBBcyBvZiBTZXB0ZW1iZXIgMjAwOSwgVk13YXJlIGhhcyBzdGFydGVkIGEgcGhhc2VkIHJldGlyZW1lbnQKKwkgIG9mIHRoaXMgZmVhdHVyZSBmcm9tIFZNd2FyZSdzIHByb2R1Y3RzLiBQbGVhc2Ugc2VlCisJICBmZWF0dXJlLXJlbW92YWwtc2NoZWR1bGUudHh0IGZvciBkZXRhaWxzLiAgSWYgeW91IGFyZQorCSAgcGxhbm5pbmcgdG8gZW5hYmxlIHRoaXMgb3B0aW9uLCBwbGVhc2Ugbm90ZSB0aGF0IHlvdSBjYW5ub3QKKwkgIGxpdmUgbWlncmF0ZSBhIFZNSSBlbmFibGVkIFZNIHRvIGEgZnV0dXJlIFZNd2FyZSBwcm9kdWN0LAorCSAgd2hpY2ggZG9lc24ndCBzdXBwb3J0IFZNSS4gU28gaWYgeW91IGV4cGVjdCB5b3VyIGtlcm5lbCB0bworCSAgc2VhbWxlc3NseSBtaWdyYXRlIHRvIG5ld2VyIFZNd2FyZSBwcm9kdWN0cywga2VlcCB0aGlzCisJICBkaXNhYmxlZC4KKwogY29uZmlnIEtWTV9DTE9DSwogCWJvb2wgIktWTSBwYXJhdmlydHVhbGl6ZWQgY2xvY2siCiAJc2VsZWN0IFBBUkFWSVJUCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9ib290L3NldHVwLmxkIGIvYXJjaC94ODYvYm9vdC9zZXR1cC5sZAppbmRleCAwZjZlYzQ1NS4uMDNjMDY4MyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvYm9vdC9zZXR1cC5sZAorKysgYi9hcmNoL3g4Ni9ib290L3NldHVwLmxkCkBAIC01Myw2ICs1Myw5IEBACiAKIAkvRElTQ0FSRC8gOiB7ICooLm5vdGUqKSB9CiAKKwkvKgorCSAqIFRoZSBBU1NFUlQoKSBzaW5rIHRvIC4gaXMgaW50ZW50aW9uYWwsIGZvciBiaW51dGlscyAyLjE0IGNvbXBhdGliaWxpdHk6CisJICovCiAJLiA9IEFTU0VSVChfZW5kIDw9IDB4ODAwMCwgIlNldHVwIHRvbyBiaWchIik7CiAJLiA9IEFTU0VSVChoZHIgPT0gMHgxZjEsICJUaGUgc2V0dXAgaGVhZGVyIGhhcyB0aGUgd3Jvbmcgb2Zmc2V0ISIpOwogCS8qIE5lY2Vzc2FyeSBmb3IgdGhlIHZlcnktb2xkLWxvYWRlciBjaGVjayB0byB3b3JrLi4uICovCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9jcnlwdG8vYWVzbmktaW50ZWxfZ2x1ZS5jIGIvYXJjaC94ODYvY3J5cHRvL2Flc25pLWludGVsX2dsdWUuYwppbmRleCA1ODVlZGViLi40OWM1NTJjIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9jcnlwdG8vYWVzbmktaW50ZWxfZ2x1ZS5jCisrKyBiL2FyY2gveDg2L2NyeXB0by9hZXNuaS1pbnRlbF9nbHVlLmMKQEAgLTgyLDcgKzgyLDcgQEAKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCi0JaWYgKGlycV9mcHVfdXNhYmxlKCkpCisJaWYgKCFpcnFfZnB1X3VzYWJsZSgpKQogCQllcnIgPSBjcnlwdG9fYWVzX2V4cGFuZF9rZXkoY3R4LCBpbl9rZXksIGtleV9sZW4pOwogCWVsc2UgewogCQlrZXJuZWxfZnB1X2JlZ2luKCk7CkBAIC0xMDMsNyArMTAzLDcgQEAKIHsKIAlzdHJ1Y3QgY3J5cHRvX2Flc19jdHggKmN0eCA9IGFlc19jdHgoY3J5cHRvX3RmbV9jdHgodGZtKSk7CiAKLQlpZiAoaXJxX2ZwdV91c2FibGUoKSkKKwlpZiAoIWlycV9mcHVfdXNhYmxlKCkpCiAJCWNyeXB0b19hZXNfZW5jcnlwdF94ODYoY3R4LCBkc3QsIHNyYyk7CiAJZWxzZSB7CiAJCWtlcm5lbF9mcHVfYmVnaW4oKTsKQEAgLTExNiw3ICsxMTYsNyBAQAogewogCXN0cnVjdCBjcnlwdG9fYWVzX2N0eCAqY3R4ID0gYWVzX2N0eChjcnlwdG9fdGZtX2N0eCh0Zm0pKTsKIAotCWlmIChpcnFfZnB1X3VzYWJsZSgpKQorCWlmICghaXJxX2ZwdV91c2FibGUoKSkKIAkJY3J5cHRvX2Flc19kZWNyeXB0X3g4NihjdHgsIGRzdCwgc3JjKTsKIAllbHNlIHsKIAkJa2VybmVsX2ZwdV9iZWdpbigpOwpAQCAtMzQyLDcgKzM0Miw3IEBACiAJc3RydWN0IGNyeXB0b19hYmxrY2lwaGVyICp0Zm0gPSBjcnlwdG9fYWJsa2NpcGhlcl9yZXF0Zm0ocmVxKTsKIAlzdHJ1Y3QgYXN5bmNfYWVzX2N0eCAqY3R4ID0gY3J5cHRvX2FibGtjaXBoZXJfY3R4KHRmbSk7CiAKLQlpZiAoaXJxX2ZwdV91c2FibGUoKSkgeworCWlmICghaXJxX2ZwdV91c2FibGUoKSkgewogCQlzdHJ1Y3QgYWJsa2NpcGhlcl9yZXF1ZXN0ICpjcnlwdGRfcmVxID0KIAkJCWFibGtjaXBoZXJfcmVxdWVzdF9jdHgocmVxKTsKIAkJbWVtY3B5KGNyeXB0ZF9yZXEsIHJlcSwgc2l6ZW9mKCpyZXEpKTsKQEAgLTM2Myw3ICszNjMsNyBAQAogCXN0cnVjdCBjcnlwdG9fYWJsa2NpcGhlciAqdGZtID0gY3J5cHRvX2FibGtjaXBoZXJfcmVxdGZtKHJlcSk7CiAJc3RydWN0IGFzeW5jX2Flc19jdHggKmN0eCA9IGNyeXB0b19hYmxrY2lwaGVyX2N0eCh0Zm0pOwogCi0JaWYgKGlycV9mcHVfdXNhYmxlKCkpIHsKKwlpZiAoIWlycV9mcHVfdXNhYmxlKCkpIHsKIAkJc3RydWN0IGFibGtjaXBoZXJfcmVxdWVzdCAqY3J5cHRkX3JlcSA9CiAJCQlhYmxrY2lwaGVyX3JlcXVlc3RfY3R4KHJlcSk7CiAJCW1lbWNweShjcnlwdGRfcmVxLCByZXEsIHNpemVvZigqcmVxKSk7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnQuaAppbmRleCA4YWViY2M0Li5lZmIzODk5IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydC5oCisrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0LmgKQEAgLTg0MCw0MiArODQwLDIyIEBACiAKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBfX3Jhd19sb2NhbF9zYXZlX2ZsYWdzKHZvaWQpCiB7Ci0JdW5zaWduZWQgbG9uZyBmOwotCi0JYXNtIHZvbGF0aWxlKHBhcmF2aXJ0X2FsdChQQVJBVklSVF9DQUxMKQotCQkgICAgIDogIj1hIihmKQotCQkgICAgIDogcGFyYXZpcnRfdHlwZShwdl9pcnFfb3BzLnNhdmVfZmwpLAotCQkgICAgICAgcGFyYXZpcnRfY2xvYmJlcihDTEJSX0VBWCkKLQkJICAgICA6ICJtZW1vcnkiLCAiY2MiKTsKLQlyZXR1cm4gZjsKKwlyZXR1cm4gUFZPUF9DQUxMRUUwKHVuc2lnbmVkIGxvbmcsIHB2X2lycV9vcHMuc2F2ZV9mbCk7CiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCByYXdfbG9jYWxfaXJxX3Jlc3RvcmUodW5zaWduZWQgbG9uZyBmKQogewotCWFzbSB2b2xhdGlsZShwYXJhdmlydF9hbHQoUEFSQVZJUlRfQ0FMTCkKLQkJICAgICA6ICI9YSIoZikKLQkJICAgICA6IFBWX0ZMQUdTX0FSRyhmKSwKLQkJICAgICAgIHBhcmF2aXJ0X3R5cGUocHZfaXJxX29wcy5yZXN0b3JlX2ZsKSwKLQkJICAgICAgIHBhcmF2aXJ0X2Nsb2JiZXIoQ0xCUl9FQVgpCi0JCSAgICAgOiAibWVtb3J5IiwgImNjIik7CisJUFZPUF9WQ0FMTEVFMShwdl9pcnFfb3BzLnJlc3RvcmVfZmwsIGYpOwogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgcmF3X2xvY2FsX2lycV9kaXNhYmxlKHZvaWQpCiB7Ci0JYXNtIHZvbGF0aWxlKHBhcmF2aXJ0X2FsdChQQVJBVklSVF9DQUxMKQotCQkgICAgIDoKLQkJICAgICA6IHBhcmF2aXJ0X3R5cGUocHZfaXJxX29wcy5pcnFfZGlzYWJsZSksCi0JCSAgICAgICBwYXJhdmlydF9jbG9iYmVyKENMQlJfRUFYKQotCQkgICAgIDogIm1lbW9yeSIsICJlYXgiLCAiY2MiKTsKKwlQVk9QX1ZDQUxMRUUwKHB2X2lycV9vcHMuaXJxX2Rpc2FibGUpOwogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgcmF3X2xvY2FsX2lycV9lbmFibGUodm9pZCkKIHsKLQlhc20gdm9sYXRpbGUocGFyYXZpcnRfYWx0KFBBUkFWSVJUX0NBTEwpCi0JCSAgICAgOgotCQkgICAgIDogcGFyYXZpcnRfdHlwZShwdl9pcnFfb3BzLmlycV9lbmFibGUpLAotCQkgICAgICAgcGFyYXZpcnRfY2xvYmJlcihDTEJSX0VBWCkKLQkJICAgICA6ICJtZW1vcnkiLCAiZWF4IiwgImNjIik7CisJUFZPUF9WQ0FMTEVFMChwdl9pcnFfb3BzLmlycV9lbmFibGUpOwogfQogCiBzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgX19yYXdfbG9jYWxfaXJxX3NhdmUodm9pZCkKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmggYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9wYXJhdmlydF90eXBlcy5oCmluZGV4IGRkMGY1YjMuLjkzNTc0NzMgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BhcmF2aXJ0X3R5cGVzLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vcGFyYXZpcnRfdHlwZXMuaApAQCAtNDk0LDEwICs0OTQsMTEgQEAKICNkZWZpbmUgRVhUUkFfQ0xPQkJFUlMKICNkZWZpbmUgVkVYVFJBX0NMT0JCRVJTCiAjZWxzZSAgLyogQ09ORklHX1g4Nl82NCAqLworLyogW3JlXWF4IGlzbid0IGFuIGFyZywgYnV0IHRoZSByZXR1cm4gdmFsICovCiAjZGVmaW5lIFBWT1BfVkNBTExfQVJHUwkJCQkJXAogCXVuc2lnbmVkIGxvbmcgX19lZGkgPSBfX2VkaSwgX19lc2kgPSBfX2VzaSwJXAotCQlfX2VkeCA9IF9fZWR4LCBfX2VjeCA9IF9fZWN4Ci0jZGVmaW5lIFBWT1BfQ0FMTF9BUkdTCQlQVk9QX1ZDQUxMX0FSR1MsIF9fZWF4CisJCV9fZWR4ID0gX19lZHgsIF9fZWN4ID0gX19lY3gsIF9fZWF4ID0gX19lYXgKKyNkZWZpbmUgUFZPUF9DQUxMX0FSR1MJCVBWT1BfVkNBTExfQVJHUwogCiAjZGVmaW5lIFBWT1BfQ0FMTF9BUkcxKHgpCQkiRCIgKCh1bnNpZ25lZCBsb25nKSh4KSkKICNkZWZpbmUgUFZPUF9DQUxMX0FSRzIoeCkJCSJTIiAoKHVuc2lnbmVkIGxvbmcpKHgpKQpAQCAtNTA5LDYgKzUxMCw3IEBACiAJCQkJIj1jIiAoX19lY3gpCiAjZGVmaW5lIFBWT1BfQ0FMTF9DTE9CQkVSUwlQVk9QX1ZDQUxMX0NMT0JCRVJTLCAiPWEiIChfX2VheCkKIAorLyogdm9pZCBmdW5jdGlvbnMgYXJlIHN0aWxsIGFsbG93ZWQgW3JlXWF4IGZvciBzY3JhdGNoICovCiAjZGVmaW5lIFBWT1BfVkNBTExFRV9DTE9CQkVSUwkiPWEiIChfX2VheCkKICNkZWZpbmUgUFZPUF9DQUxMRUVfQ0xPQkJFUlMJUFZPUF9WQ0FMTEVFX0NMT0JCRVJTCiAKQEAgLTU4Myw4ICs1ODUsOCBAQAogCQkgICAgICAgVkVYVFJBX0NMT0JCRVJTLAkJCQkJXAogCQkgICAgICAgcHJlLCBwb3N0LCAjI19fVkFfQVJHU19fKQogCi0jZGVmaW5lIF9fUFZPUF9WQ0FMTEVFU0FWRShyZXR0eXBlLCBvcCwgcHJlLCBwb3N0LCAuLi4pCQkJXAotCV9fX19QVk9QX0NBTEwocmV0dHlwZSwgb3AuZnVuYywgQ0xCUl9SRVRfUkVHLAkJCVwKKyNkZWZpbmUgX19QVk9QX1ZDQUxMRUVTQVZFKG9wLCBwcmUsIHBvc3QsIC4uLikJCQkJXAorCV9fX19QVk9QX1ZDQUxMKG9wLmZ1bmMsIENMQlJfUkVUX1JFRywJCQkJXAogCQkgICAgICBQVk9QX1ZDQUxMRUVfQ0xPQkJFUlMsICwJCQkJXAogCQkgICAgICBwcmUsIHBvc3QsICMjX19WQV9BUkdTX18pCiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNtL3V2L3V2X2h1Yi5oIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vdXYvdXZfaHViLmgKaW5kZXggMDRlYjZjOS4uZDE0MTRhZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS9hc20vdXYvdXZfaHViLmgKKysrIGIvYXJjaC94ODYvaW5jbHVkZS9hc20vdXYvdXZfaHViLmgKQEAgLTE5LDYgKzE5LDggQEAKICNpbmNsdWRlIDxhc20vdHlwZXMuaD4KICNpbmNsdWRlIDxhc20vcGVyY3B1Lmg+CiAjaW5jbHVkZSA8YXNtL3V2L3V2X21tcnMuaD4KKyNpbmNsdWRlIDxhc20vaXJxX3ZlY3RvcnMuaD4KKyNpbmNsdWRlIDxhc20vaW9fYXBpYy5oPgogCiAKIC8qCkBAIC0xMTQsNyArMTE2LDcgQEAKIC8qCiAgKiBUaGUgbGFyZ2VzdCBwb3NzaWJsZSBOQVNJRCBvZiBhIEMgb3IgTSBicmljayAoKyAyKQogICovCi0jZGVmaW5lIFVWX01BWF9OQVNJRF9WQUxVRQkoVVZfTUFYX05VTUFMSU5LX05PREVTICogMikKKyNkZWZpbmUgVVZfTUFYX05BU0lEX1ZBTFVFCShVVl9NQVhfTlVNQUxJTktfQkxBREVTICogMikKIAogc3RydWN0IHV2X3NjaXJfcyB7CiAJc3RydWN0IHRpbWVyX2xpc3QgdGltZXI7CkBAIC0yMzAsNiArMjMyLDIwIEBACiAJcmV0dXJuIHV2X3NvY19waHlzX3JhbV90b19ncGEoX19wYSh2KSk7CiB9CiAKKy8qIGdub2RlIC0+IHBub2RlICovCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgdXZfZ3BhX3RvX2dub2RlKHVuc2lnbmVkIGxvbmcgZ3BhKQoreworCXJldHVybiBncGEgPj4gdXZfaHViX2luZm8tPm1fdmFsOworfQorCisvKiBncGEgLT4gcG5vZGUgKi8KK3N0YXRpYyBpbmxpbmUgaW50IHV2X2dwYV90b19wbm9kZSh1bnNpZ25lZCBsb25nIGdwYSkKK3sKKwl1bnNpZ25lZCBsb25nIG5fbWFzayA9ICgxVUwgPDwgdXZfaHViX2luZm8tPm5fdmFsKSAtIDE7CisKKwlyZXR1cm4gdXZfZ3BhX3RvX2dub2RlKGdwYSkgJiBuX21hc2s7Cit9CisKIC8qIHBub2RlLCBvZmZzZXQgLS0+IHNvY2tldCB2aXJ0dWFsICovCiBzdGF0aWMgaW5saW5lIHZvaWQgKnV2X3Bub2RlX29mZnNldF90b192YWRkcihpbnQgcG5vZGUsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0KQogewpAQCAtNDIxLDkgKzQzNywxNCBAQAogc3RhdGljIGlubGluZSB2b2lkIHV2X2h1Yl9zZW5kX2lwaShpbnQgcG5vZGUsIGludCBhcGljaWQsIGludCB2ZWN0b3IpCiB7CiAJdW5zaWduZWQgbG9uZyB2YWw7CisJdW5zaWduZWQgbG9uZyBkbW9kZSA9IGRlc3RfRml4ZWQ7CisKKwlpZiAodmVjdG9yID09IE5NSV9WRUNUT1IpCisJCWRtb2RlID0gZGVzdF9OTUk7CiAKIAl2YWwgPSAoMVVMIDw8IFVWSF9JUElfSU5UX1NFTkRfU0hGVCkgfAogCQkJKChhcGljaWQpIDw8IFVWSF9JUElfSU5UX0FQSUNfSURfU0hGVCkgfAorCQkJKGRtb2RlIDw8IFVWSF9JUElfSU5UX0RFTElWRVJZX01PREVfU0hGVCkgfAogCQkJKHZlY3RvciA8PCBVVkhfSVBJX0lOVF9WRUNUT1JfU0hGVCk7CiAJdXZfd3JpdGVfZ2xvYmFsX21tcjY0KHBub2RlLCBVVkhfSVBJX0lOVCwgdmFsKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hY3BpL3JlYWxtb2RlL3dha2V1cC5sZHMuUyBiL2FyY2gveDg2L2tlcm5lbC9hY3BpL3JlYWxtb2RlL3dha2V1cC5sZHMuUwppbmRleCA3ZGEwMGI3Li4wNjBmZmY4IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvYWNwaS9yZWFsbW9kZS93YWtldXAubGRzLlMKKysrIGIvYXJjaC94ODYva2VybmVsL2FjcGkvcmVhbG1vZGUvd2FrZXVwLmxkcy5TCkBAIC01Nyw1ICs1Nyw4IEBACiAJCSooLm5vdGUqKQogCX0KIAorCS8qCisJICogVGhlIEFTU0VSVCgpIHNpbmsgdG8gLiBpcyBpbnRlbnRpb25hbCwgZm9yIGJpbnV0aWxzIDIuMTQgY29tcGF0aWJpbGl0eToKKwkgKi8KIAkuID0gQVNTRVJUKF9lbmQgPD0gV0FLRVVQX1NJWkUsICJXYWtldXAgdG9vIGJpZyEiKTsKIH0KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9hcGljL3gyYXBpY191dl94LmMgYi9hcmNoL3g4Ni9rZXJuZWwvYXBpYy94MmFwaWNfdXZfeC5jCmluZGV4IGY1ZjU4ODYuLjMyNmMyNTQgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9hcGljL3gyYXBpY191dl94LmMKKysrIGIvYXJjaC94ODYva2VybmVsL2FwaWMveDJhcGljX3V2X3guYwpAQCAtMzUyLDE0ICszNTIsMTQgQEAKIAogCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHJlZGlyX2FkZHJzKTsgaSsrKSB7CiAJCWFsaWFzLnYgPSB1dl9yZWFkX2xvY2FsX21tcihyZWRpcl9hZGRyc1tpXS5hbGlhcyk7Ci0JCWlmIChhbGlhcy5zLmJhc2UgPT0gMCkgeworCQlpZiAoYWxpYXMucy5lbmFibGUgJiYgYWxpYXMucy5iYXNlID09IDApIHsKIAkJCSpzaXplID0gKDFVTCA8PCBhbGlhcy5zLm1fYWxpYXMpOwogCQkJcmVkaXJlY3QudiA9IHV2X3JlYWRfbG9jYWxfbW1yKHJlZGlyX2FkZHJzW2ldLnJlZGlyZWN0KTsKIAkJCSpiYXNlID0gKHVuc2lnbmVkIGxvbmcpcmVkaXJlY3Qucy5kZXN0X2Jhc2UgPDwgREVTVF9TSElGVDsKIAkJCXJldHVybjsKIAkJfQogCX0KLQlCVUcoKTsKKwkqYmFzZSA9ICpzaXplID0gMDsKIH0KIAogZW51bSBtYXBfdHlwZSB7bWFwX3diLCBtYXBfdWN9OwpAQCAtNjE5LDEyICs2MTksMTIgQEAKIAkJdXZfY3B1X2h1Yl9pbmZvKGNwdSktPmxvd21lbV9yZW1hcF9iYXNlID0gbG93bWVtX3JlZGlyX2Jhc2U7CiAJCXV2X2NwdV9odWJfaW5mbyhjcHUpLT5sb3dtZW1fcmVtYXBfdG9wID0gbG93bWVtX3JlZGlyX3NpemU7CiAJCXV2X2NwdV9odWJfaW5mbyhjcHUpLT5tX3ZhbCA9IG1fdmFsOwotCQl1dl9jcHVfaHViX2luZm8oY3B1KS0+bl92YWwgPSBtX3ZhbDsKKwkJdXZfY3B1X2h1Yl9pbmZvKGNwdSktPm5fdmFsID0gbl92YWw7CiAJCXV2X2NwdV9odWJfaW5mbyhjcHUpLT5udW1hX2JsYWRlX2lkID0gYmxhZGU7CiAJCXV2X2NwdV9odWJfaW5mbyhjcHUpLT5ibGFkZV9wcm9jZXNzb3JfaWQgPSBsY3B1OwogCQl1dl9jcHVfaHViX2luZm8oY3B1KS0+cG5vZGUgPSBwbm9kZTsKIAkJdXZfY3B1X2h1Yl9pbmZvKGNwdSktPnBub2RlX21hc2sgPSBwbm9kZV9tYXNrOwotCQl1dl9jcHVfaHViX2luZm8oY3B1KS0+Z3BhX21hc2sgPSAoMSA8PCAobV92YWwgKyBuX3ZhbCkpIC0gMTsKKwkJdXZfY3B1X2h1Yl9pbmZvKGNwdSktPmdwYV9tYXNrID0gKDFVTCA8PCAobV92YWwgKyBuX3ZhbCkpIC0gMTsKIAkJdXZfY3B1X2h1Yl9pbmZvKGNwdSktPmdub2RlX3VwcGVyID0gZ25vZGVfdXBwZXI7CiAJCXV2X2NwdV9odWJfaW5mbyhjcHUpLT5nbm9kZV9leHRyYSA9IGdub2RlX2V4dHJhOwogCQl1dl9jcHVfaHViX2luZm8oY3B1KS0+Z2xvYmFsX21tcl9iYXNlID0gbW1yX2Jhc2U7CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L21jaGVjay9tY2UuYyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvbWNoZWNrL21jZS5jCmluZGV4IGIxNTk4YTkuLjcyMWE3N2MgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC9jcHUvbWNoZWNrL21jZS5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9jcHUvbWNoZWNrL21jZS5jCkBAIC0xMjE0LDcgKzEyMTQsOCBAQAogCXJkbXNybChNU1JfSUEzMl9NQ0dfQ0FQLCBjYXApOwogCiAJYiA9IGNhcCAmIE1DR19CQU5LQ05UX01BU0s7Ci0JcHJpbnRrKEtFUk5fSU5GTyAibWNlOiBDUFUgc3VwcG9ydHMgJWQgTUNFIGJhbmtzXG4iLCBiKTsKKwlpZiAoIWJhbmtzKQorCQlwcmludGsoS0VSTl9JTkZPICJtY2U6IENQVSBzdXBwb3J0cyAlZCBNQ0UgYmFua3NcbiIsIGIpOwogCiAJaWYgKGIgPiBNQVhfTlJfQkFOS1MpIHsKIAkJcHJpbnRrKEtFUk5fV0FSTklORwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL2NwdS9tY2hlY2svbWNlX2ludGVsLmMgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L21jaGVjay9tY2VfaW50ZWwuYwppbmRleCA4ODlmNjY1Li43Yzc4NTYzIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvY3B1L21jaGVjay9tY2VfaW50ZWwuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvY3B1L21jaGVjay9tY2VfaW50ZWwuYwpAQCAtOCw2ICs4LDcgQEAKICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvcGVyY3B1Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxhc20vYXBpYy5oPgogI2luY2x1ZGUgPGFzbS9wcm9jZXNzb3IuaD4KICNpbmNsdWRlIDxhc20vbXNyLmg+CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvZTgyMC5jIGIvYXJjaC94ODYva2VybmVsL2U4MjAuYwppbmRleCA4NTQxOWJiLi5kMTdkNDgyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvZTgyMC5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC9lODIwLmMKQEAgLTEzNzgsOCArMTM3OCw4IEBACiAJaWYgKG1iIDwgMTYpCiAJCXJldHVybiAxMDI0KjEwMjQ7CiAKLQkvKiBUbyAzMk1CIGZvciBhbnl0aGluZyBhYm92ZSB0aGF0ICovCi0JcmV0dXJuIDMyKjEwMjQqMTAyNDsKKwkvKiBUbyA2NE1CIGZvciBhbnl0aGluZyBhYm92ZSB0aGF0ICovCisJcmV0dXJuIDY0KjEwMjQqMTAyNDsKIH0KIAogI2RlZmluZSBNQVhfUkVTT1VSQ0VfU0laRSAoKHJlc291cmNlX3NpemVfdCktMSkKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9pcnEuYyBiL2FyY2gveDg2L2tlcm5lbC9pcnEuYwppbmRleCA3NDY1NmQxLi4wNGJiZDUyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvaXJxLmMKKysrIGIvYXJjaC94ODYva2VybmVsL2lycS5jCkBAIC02MywxMCArNjMsMTAgQEAKIAlmb3JfZWFjaF9vbmxpbmVfY3B1KGopCiAJCXNlcV9wcmludGYocCwgIiUxMHUgIiwgaXJxX3N0YXRzKGopLT5pcnFfc3B1cmlvdXNfY291bnQpOwogCXNlcV9wcmludGYocCwgIiAgU3B1cmlvdXMgaW50ZXJydXB0c1xuIik7Ci0Jc2VxX3ByaW50ZihwLCAiJSpzOiAiLCBwcmVjLCAiQ05UIik7CisJc2VxX3ByaW50ZihwLCAiJSpzOiAiLCBwcmVjLCAiUE1JIik7CiAJZm9yX2VhY2hfb25saW5lX2NwdShqKQogCQlzZXFfcHJpbnRmKHAsICIlMTB1ICIsIGlycV9zdGF0cyhqKS0+YXBpY19wZXJmX2lycXMpOwotCXNlcV9wcmludGYocCwgIiAgUGVyZm9ybWFuY2UgY291bnRlciBpbnRlcnJ1cHRzXG4iKTsKKwlzZXFfcHJpbnRmKHAsICIgIFBlcmZvcm1hbmNlIG1vbml0b3JpbmcgaW50ZXJydXB0c1xuIik7CiAJc2VxX3ByaW50ZihwLCAiJSpzOiAiLCBwcmVjLCAiUE5EIik7CiAJZm9yX2VhY2hfb25saW5lX2NwdShqKQogCQlzZXFfcHJpbnRmKHAsICIlMTB1ICIsIGlycV9zdGF0cyhqKS0+YXBpY19wZW5kaW5nX2lycXMpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3BjaS1kbWEuYyBiL2FyY2gveDg2L2tlcm5lbC9wY2ktZG1hLmMKaW5kZXggZDIwMDA5Yi4uYjJhNzFkYyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3BjaS1kbWEuYworKysgYi9hcmNoL3g4Ni9rZXJuZWwvcGNpLWRtYS5jCkBAIC0zMTEsNyArMzExLDcgQEAKIAlhbWRfaW9tbXVfc2h1dGRvd24oKTsKIH0KIC8qIE11c3QgZXhlY3V0ZSBhZnRlciBQQ0kgc3Vic3lzdGVtICovCi1mc19pbml0Y2FsbChwY2lfaW9tbXVfaW5pdCk7Cityb290ZnNfaW5pdGNhbGwocGNpX2lvbW11X2luaXQpOwogCiAjaWZkZWYgQ09ORklHX1BDSQogLyogTWFueSBWSUEgYnJpZGdlcyBzZWVtIHRvIGNvcnJ1cHQgZGF0YSBmb3IgREFDLiBEaXNhYmxlIGl0IGhlcmUgKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9wY2ktZ2FydF82NC5jIGIvYXJjaC94ODYva2VybmVsL3BjaS1nYXJ0XzY0LmMKaW5kZXggOThhODI3ZS4uYTdmMWI2NCAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3BjaS1nYXJ0XzY0LmMKKysrIGIvYXJjaC94ODYva2VybmVsL3BjaS1nYXJ0XzY0LmMKQEAgLTE2LDYgKzE2LDcgQEAKICNpbmNsdWRlIDxsaW51eC9hZ3BfYmFja2VuZC5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC9yZWJvb3QuYyBiL2FyY2gveDg2L2tlcm5lbC9yZWJvb3QuYwppbmRleCAyNzM0OWY5Li5hMWEzY2RkIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvcmVib290LmMKKysrIGIvYXJjaC94ODYva2VybmVsL3JlYm9vdC5jCkBAIC00LDYgKzQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3BtLmg+CiAjaW5jbHVkZSA8bGludXgvZWZpLmg+CiAjaW5jbHVkZSA8bGludXgvZG1pLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC90Ym9vdC5oPgogI2luY2x1ZGUgPGFjcGkvcmVib290Lmg+CiAjaW5jbHVkZSA8YXNtL2lvLmg+CmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvdGltZS5jIGIvYXJjaC94ODYva2VybmVsL3RpbWUuYwppbmRleCBkY2IwMGQyLi5iZTI1NzM0IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvdGltZS5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC90aW1lLmMKQEAgLTM4LDcgKzM4LDggQEAKICNpZmRlZiBDT05GSUdfRlJBTUVfUE9JTlRFUgogCQlyZXR1cm4gKih1bnNpZ25lZCBsb25nICopKHJlZ3MtPmJwICsgc2l6ZW9mKGxvbmcpKTsKICNlbHNlCi0JCXVuc2lnbmVkIGxvbmcgKnNwID0gKHVuc2lnbmVkIGxvbmcgKilyZWdzLT5zcDsKKwkJdW5zaWduZWQgbG9uZyAqc3AgPQorCQkJKHVuc2lnbmVkIGxvbmcgKilrZXJuZWxfc3RhY2tfcG9pbnRlcihyZWdzKTsKIAkJLyoKIAkJICogUmV0dXJuIGFkZHJlc3MgaXMgZWl0aGVyIGRpcmVjdGx5IGF0IHN0YWNrIHBvaW50ZXIKIAkJICogb3IgYWJvdmUgYSBzYXZlZCBmbGFncy4gRWZsYWdzIGhhcyBiaXRzIDIyLTMxIHplcm8sCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvdGxiX3V2LmMgYi9hcmNoL3g4Ni9rZXJuZWwvdGxiX3V2LmMKaW5kZXggNTAzYzFmMi4uMTc0MGM4NSAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3RsYl91di5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC90bGJfdXYuYwpAQCAtMjMsOCArMjMsNiBAQAogc3RhdGljIHN0cnVjdCBiYXVfY29udHJvbAkqKnV2X2JhdV90YWJsZV9iYXNlcyBfX3JlYWRfbW9zdGx5Owogc3RhdGljIGludAkJCXV2X2JhdV9yZXRyeV9saW1pdCBfX3JlYWRfbW9zdGx5OwogCi0vKiBwb3NpdGlvbiBvZiBwbm9kZSAod2hpY2ggaXMgbmFzaWQ+PjEpOiAqLwotc3RhdGljIGludAkJCXV2X25zaGlmdCBfX3JlYWRfbW9zdGx5OwogLyogYmFzZSBwbm9kZSBpbiB0aGlzIHBhcnRpdGlvbiAqLwogc3RhdGljIGludAkJCXV2X3BhcnRpdGlvbl9iYXNlX3Bub2RlIF9fcmVhZF9tb3N0bHk7CiAKQEAgLTcyMyw3ICs3MjEsNyBAQAogCUJVR19PTighYWRwKTsKIAogCXBhID0gdXZfZ3BhKGFkcCk7IC8qIG5lZWQgdGhlIHJlYWwgbmFzaWQqLwotCW4gPSBwYSA+PiB1dl9uc2hpZnQ7CisJbiA9IHV2X2dwYV90b19wbm9kZShwYSk7CiAJbSA9IHBhICYgdXZfbW1hc2s7CiAKIAl1dl93cml0ZV9nbG9iYWxfbW1yNjQocG5vZGUsIFVWSF9MQl9CQVVfU0JfREVTQ1JJUFRPUl9CQVNFLApAQCAtNzc4LDcgKzc3Niw3IEBACiAJICogbmVlZCB0aGUgcG5vZGUgb2Ygd2hlcmUgdGhlIG1lbW9yeSB3YXMgcmVhbGx5IGFsbG9jYXRlZAogCSAqLwogCXBhID0gdXZfZ3BhKHBxcCk7Ci0JcG4gPSBwYSA+PiB1dl9uc2hpZnQ7CisJcG4gPSB1dl9ncGFfdG9fcG5vZGUocGEpOwogCXV2X3dyaXRlX2dsb2JhbF9tbXI2NChwbm9kZSwKIAkJCSAgICAgIFVWSF9MQl9CQVVfSU5URF9QQVlMT0FEX1FVRVVFX0ZJUlNULAogCQkJICAgICAgKCh1bnNpZ25lZCBsb25nKXBuIDw8IFVWX1BBWUxPQURRX1BOT0RFX1NISUZUKSB8CkBAIC04NDMsOCArODQxLDcgQEAKIAkJCQkgICAgICAgR0ZQX0tFUk5FTCwgY3B1X3RvX25vZGUoY3VyX2NwdSkpOwogCiAJdXZfYmF1X3JldHJ5X2xpbWl0ID0gMTsKLQl1dl9uc2hpZnQgPSB1dl9odWJfaW5mby0+bl92YWw7Ci0JdXZfbW1hc2sgPSAoMVVMIDw8IHV2X2h1Yl9pbmZvLT5uX3ZhbCkgLSAxOworCXV2X21tYXNrID0gKDFVTCA8PCB1dl9odWJfaW5mby0+bV92YWwpIC0gMTsKIAluYmxhZGVzID0gdXZfbnVtX3Bvc3NpYmxlX2JsYWRlcygpOwogCiAJdXZfYmF1X3RhYmxlX2Jhc2VzID0gKHN0cnVjdCBiYXVfY29udHJvbCAqKikKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC90cmFtcG9saW5lLmMgYi9hcmNoL3g4Ni9rZXJuZWwvdHJhbXBvbGluZS5jCmluZGV4IDY5OWY3ZWUuLmNkMDIyMTIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2tlcm5lbC90cmFtcG9saW5lLmMKKysrIGIvYXJjaC94ODYva2VybmVsL3RyYW1wb2xpbmUuYwpAQCAtMyw4ICszLDE2IEBACiAjaW5jbHVkZSA8YXNtL3RyYW1wb2xpbmUuaD4KICNpbmNsdWRlIDxhc20vZTgyMC5oPgogCisjaWYgZGVmaW5lZChDT05GSUdfWDg2XzY0KSAmJiBkZWZpbmVkKENPTkZJR19BQ1BJX1NMRUVQKQorI2RlZmluZSBfX3RyYW1waW5pdAorI2RlZmluZSBfX3RyYW1waW5pdGRhdGEKKyNlbHNlCisjZGVmaW5lIF9fdHJhbXBpbml0IF9fY3B1aW5pdAorI2RlZmluZSBfX3RyYW1waW5pdGRhdGEgX19jcHVpbml0ZGF0YQorI2VuZGlmCisKIC8qIHJlYWR5IGZvciB4ODZfNjQgYW5kIHg4NiAqLwotdW5zaWduZWQgY2hhciAqX19jcHVpbml0ZGF0YSB0cmFtcG9saW5lX2Jhc2UgPSBfX3ZhKFRSQU1QT0xJTkVfQkFTRSk7Cit1bnNpZ25lZCBjaGFyICpfX3RyYW1waW5pdGRhdGEgdHJhbXBvbGluZV9iYXNlID0gX192YShUUkFNUE9MSU5FX0JBU0UpOwogCiB2b2lkIF9faW5pdCByZXNlcnZlX3RyYW1wb2xpbmVfbWVtb3J5KHZvaWQpCiB7CkBAIC0yNiw3ICszNCw3IEBACiAgKiBib290c3RyYXAgaW50byB0aGUgcGFnZSBjb25jZXJuZWQuIFRoZSBjYWxsZXIKICAqIGhhcyBtYWRlIHN1cmUgaXQncyBzdWl0YWJseSBhbGlnbmVkLgogICovCi11bnNpZ25lZCBsb25nIF9fY3B1aW5pdCBzZXR1cF90cmFtcG9saW5lKHZvaWQpCit1bnNpZ25lZCBsb25nIF9fdHJhbXBpbml0IHNldHVwX3RyYW1wb2xpbmUodm9pZCkKIHsKIAltZW1jcHkodHJhbXBvbGluZV9iYXNlLCB0cmFtcG9saW5lX2RhdGEsIFRSQU1QT0xJTkVfU0laRSk7CiAJcmV0dXJuIHZpcnRfdG9fcGh5cyh0cmFtcG9saW5lX2Jhc2UpOwpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva2VybmVsL3RyYW1wb2xpbmVfNjQuUyBiL2FyY2gveDg2L2tlcm5lbC90cmFtcG9saW5lXzY0LlMKaW5kZXggNTk2ZDU0Yy4uM2FmMmRmZiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3RyYW1wb2xpbmVfNjQuUworKysgYi9hcmNoL3g4Ni9rZXJuZWwvdHJhbXBvbGluZV82NC5TCkBAIC0zMiw4ICszMiwxMiBAQAogI2luY2x1ZGUgPGFzbS9zZWdtZW50Lmg+CiAjaW5jbHVkZSA8YXNtL3Byb2Nlc3Nvci1mbGFncy5oPgogCisjaWZkZWYgQ09ORklHX0FDUElfU0xFRVAKKy5zZWN0aW9uIC5yb2RhdGEsICJhIiwgQHByb2diaXRzCisjZWxzZQogLyogV2UgY2FuIGZyZWUgdXAgdGhlIHRyYW1wb2xpbmUgYWZ0ZXIgYm9vdHVwIGlmIGNwdSBob3RwbHVnIGlzIG5vdCBzdXBwb3J0ZWQuICovCiBfX0NQVUlOSVRST0RBVEEKKyNlbmRpZgogLmNvZGUxNgogCiBFTlRSWSh0cmFtcG9saW5lX2RhdGEpCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvdm1pXzMyLmMgYi9hcmNoL3g4Ni9rZXJuZWwvdm1pXzMyLmMKaW5kZXggMzFlNmY2Yy4uZDQzMGU0YyAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3ZtaV8zMi5jCisrKyBiL2FyY2gveDg2L2tlcm5lbC92bWlfMzIuYwpAQCAtNjQ4LDcgKzY0OCw3IEBACiAKIAlwdl9pbmZvLnBhcmF2aXJ0X2VuYWJsZWQgPSAxOwogCXB2X2luZm8ua2VybmVsX3JwbCA9IGtlcm5lbF9jcyAmIFNFR01FTlRfUlBMX01BU0s7Ci0JcHZfaW5mby5uYW1lID0gInZtaSI7CisJcHZfaW5mby5uYW1lID0gInZtaSBbZGVwcmVjYXRlZF0iOwogCiAJcHZfaW5pdF9vcHMucGF0Y2ggPSB2bWlfcGF0Y2g7CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2tlcm5lbC92bWxpbnV4Lmxkcy5TIGIvYXJjaC94ODYva2VybmVsL3ZtbGludXgubGRzLlMKaW5kZXggOTI5MjlmYi4uM2M2OGZlMiAxMDA2NDQKLS0tIGEvYXJjaC94ODYva2VybmVsL3ZtbGludXgubGRzLlMKKysrIGIvYXJjaC94ODYva2VybmVsL3ZtbGludXgubGRzLlMKQEAgLTMwNSw2ICszMDUsOSBAQAogCiAKICNpZmRlZiBDT05GSUdfWDg2XzMyCisvKgorICogVGhlIEFTU0VSVCgpIHNpbmsgdG8gLiBpcyBpbnRlbnRpb25hbCwgZm9yIGJpbnV0aWxzIDIuMTQgY29tcGF0aWJpbGl0eToKKyAqLwogLiA9IEFTU0VSVCgoX2VuZCAtIExPQURfT0ZGU0VUIDw9IEtFUk5FTF9JTUFHRV9TSVpFKSwKIAkgICAia2VybmVsIGltYWdlIGJpZ2dlciB0aGFuIEtFUk5FTF9JTUFHRV9TSVpFIik7CiAjZWxzZQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYva3ZtL2k4MjU0LmMgYi9hcmNoL3g4Ni9rdm0vaTgyNTQuYwppbmRleCA4MmFkNTIzLi4xNDRlN2Y2IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rdm0vaTgyNTQuYworKysgYi9hcmNoL3g4Ni9rdm0vaTgyNTQuYwpAQCAtMTE2LDcgKzExNiw3IEBACiAJICogaXRzZWxmIHdpdGggdGhlIGluaXRpYWwgY291bnQgYW5kIGNvbnRpbnVlcyBjb3VudGluZwogCSAqIGZyb20gdGhlcmUuCiAJICovCi0JcmVtYWluaW5nID0gaHJ0aW1lcl9leHBpcmVzX3JlbWFpbmluZygmcHMtPnBpdF90aW1lci50aW1lcik7CisJcmVtYWluaW5nID0gaHJ0aW1lcl9nZXRfcmVtYWluaW5nKCZwcy0+cGl0X3RpbWVyLnRpbWVyKTsKIAllbGFwc2VkID0gcHMtPnBpdF90aW1lci5wZXJpb2QgLSBrdGltZV90b19ucyhyZW1haW5pbmcpOwogCWVsYXBzZWQgPSBtb2RfNjQoZWxhcHNlZCwgcHMtPnBpdF90aW1lci5wZXJpb2QpOwogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rdm0vbGFwaWMuYyBiL2FyY2gveDg2L2t2bS9sYXBpYy5jCmluZGV4IDcwMjQyMjQuLjIzYzIxNzYgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS9sYXBpYy5jCisrKyBiL2FyY2gveDg2L2t2bS9sYXBpYy5jCkBAIC01MjEsNyArNTIxLDcgQEAKIAlpZiAoYXBpY19nZXRfcmVnKGFwaWMsIEFQSUNfVE1JQ1QpID09IDApCiAJCXJldHVybiAwOwogCi0JcmVtYWluaW5nID0gaHJ0aW1lcl9leHBpcmVzX3JlbWFpbmluZygmYXBpYy0+bGFwaWNfdGltZXIudGltZXIpOworCXJlbWFpbmluZyA9IGhydGltZXJfZ2V0X3JlbWFpbmluZygmYXBpYy0+bGFwaWNfdGltZXIudGltZXIpOwogCWlmIChrdGltZV90b19ucyhyZW1haW5pbmcpIDwgMCkKIAkJcmVtYWluaW5nID0ga3RpbWVfc2V0KDAsIDApOwogCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9rdm0vbW11LmMgYi9hcmNoL3g4Ni9rdm0vbW11LmMKaW5kZXggNjg1YTRmZi4uODE4YjkyYSAxMDA2NDQKLS0tIGEvYXJjaC94ODYva3ZtL21tdS5jCisrKyBiL2FyY2gveDg2L2t2bS9tbXUuYwpAQCAtNzQ4LDcgKzc0OCw4IEBACiAJcmV0dXJuIHdyaXRlX3Byb3RlY3RlZDsKIH0KIAotc3RhdGljIGludCBrdm1fdW5tYXBfcm1hcHAoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nICpybWFwcCwgdTY0IGRhdGEpCitzdGF0aWMgaW50IGt2bV91bm1hcF9ybWFwcChzdHJ1Y3Qga3ZtICprdm0sIHVuc2lnbmVkIGxvbmcgKnJtYXBwLAorCQkJICAgdW5zaWduZWQgbG9uZyBkYXRhKQogewogCXU2NCAqc3B0ZTsKIAlpbnQgbmVlZF90bGJfZmx1c2ggPSAwOwpAQCAtNzYzLDcgKzc2NCw4IEBACiAJcmV0dXJuIG5lZWRfdGxiX2ZsdXNoOwogfQogCi1zdGF0aWMgaW50IGt2bV9zZXRfcHRlX3JtYXBwKHN0cnVjdCBrdm0gKmt2bSwgdW5zaWduZWQgbG9uZyAqcm1hcHAsIHU2NCBkYXRhKQorc3RhdGljIGludCBrdm1fc2V0X3B0ZV9ybWFwcChzdHJ1Y3Qga3ZtICprdm0sIHVuc2lnbmVkIGxvbmcgKnJtYXBwLAorCQkJICAgICB1bnNpZ25lZCBsb25nIGRhdGEpCiB7CiAJaW50IG5lZWRfZmx1c2ggPSAwOwogCXU2NCAqc3B0ZSwgbmV3X3NwdGU7CkBAIC03OTksOSArODAxLDEwIEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQga3ZtX2hhbmRsZV9odmEoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nIGh2YSwgdTY0IGRhdGEsCitzdGF0aWMgaW50IGt2bV9oYW5kbGVfaHZhKHN0cnVjdCBrdm0gKmt2bSwgdW5zaWduZWQgbG9uZyBodmEsCisJCQkgIHVuc2lnbmVkIGxvbmcgZGF0YSwKIAkJCSAgaW50ICgqaGFuZGxlcikoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nICpybWFwcCwKLQkJCQkJIHU2NCBkYXRhKSkKKwkJCQkJIHVuc2lnbmVkIGxvbmcgZGF0YSkpCiB7CiAJaW50IGksIGo7CiAJaW50IHJldHZhbCA9IDA7CkBAIC04NDYsMTAgKzg0OSwxMSBAQAogCiB2b2lkIGt2bV9zZXRfc3B0ZV9odmEoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nIGh2YSwgcHRlX3QgcHRlKQogewotCWt2bV9oYW5kbGVfaHZhKGt2bSwgaHZhLCAodTY0KSZwdGUsIGt2bV9zZXRfcHRlX3JtYXBwKTsKKwlrdm1faGFuZGxlX2h2YShrdm0sIGh2YSwgKHVuc2lnbmVkIGxvbmcpJnB0ZSwga3ZtX3NldF9wdGVfcm1hcHApOwogfQogCi1zdGF0aWMgaW50IGt2bV9hZ2Vfcm1hcHAoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nICpybWFwcCwgdTY0IGRhdGEpCitzdGF0aWMgaW50IGt2bV9hZ2Vfcm1hcHAoc3RydWN0IGt2bSAqa3ZtLCB1bnNpZ25lZCBsb25nICpybWFwcCwKKwkJCSB1bnNpZ25lZCBsb25nIGRhdGEpCiB7CiAJdTY0ICpzcHRlOwogCWludCB5b3VuZyA9IDA7CmRpZmYgLS1naXQgYS9hcmNoL3h0ZW5zYS9rZXJuZWwvdGltZS5jIGIvYXJjaC94dGVuc2Eva2VybmVsL3RpbWUuYwppbmRleCAxOTA4NWZmLi4xOWY3ZGYzIDEwMDY0NAotLS0gYS9hcmNoL3h0ZW5zYS9rZXJuZWwvdGltZS5jCisrKyBiL2FyY2gveHRlbnNhL2tlcm5lbC90aW1lLmMKQEAgLTEzLDYgKzEzLDcgQEAKICAqLwogCiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3RpbWUuaD4KICNpbmNsdWRlIDxsaW51eC9jbG9ja3NvdXJjZS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgpkaWZmIC0tZ2l0IGEvYmxvY2svYmxrLWNvcmUuYyBiL2Jsb2NrL2Jsay1jb3JlLmMKaW5kZXggODFmMzQzMS4uYWMwZmExMCAxMDA2NDQKLS0tIGEvYmxvY2svYmxrLWNvcmUuYworKysgYi9ibG9jay9ibGstY29yZS5jCkBAIC03MCw3ICs3MCw3IEBACiAJCXBhcnRfc3RhdF9pbmMoY3B1LCBwYXJ0LCBtZXJnZXNbcnddKTsKIAllbHNlIHsKIAkJcGFydF9yb3VuZF9zdGF0cyhjcHUsIHBhcnQpOwotCQlwYXJ0X2luY19pbl9mbGlnaHQocGFydCk7CisJCXBhcnRfaW5jX2luX2ZsaWdodChwYXJ0LCBydyk7CiAJfQogCiAJcGFydF9zdGF0X3VubG9jaygpOwpAQCAtMTAzMCw5ICsxMDMwLDkgQEAKIAlpZiAobm93ID09IHBhcnQtPnN0YW1wKQogCQlyZXR1cm47CiAKLQlpZiAocGFydC0+aW5fZmxpZ2h0KSB7CisJaWYgKHBhcnRfaW5fZmxpZ2h0KHBhcnQpKSB7CiAJCV9fcGFydF9zdGF0X2FkZChjcHUsIHBhcnQsIHRpbWVfaW5fcXVldWUsCi0JCQkJcGFydC0+aW5fZmxpZ2h0ICogKG5vdyAtIHBhcnQtPnN0YW1wKSk7CisJCQkJcGFydF9pbl9mbGlnaHQocGFydCkgKiAobm93IC0gcGFydC0+c3RhbXApKTsKIAkJX19wYXJ0X3N0YXRfYWRkKGNwdSwgcGFydCwgaW9fdGlja3MsIChub3cgLSBwYXJ0LT5zdGFtcCkpOwogCX0KIAlwYXJ0LT5zdGFtcCA9IG5vdzsKQEAgLTE3MzksNyArMTczOSw3IEBACiAJCXBhcnRfc3RhdF9pbmMoY3B1LCBwYXJ0LCBpb3NbcnddKTsKIAkJcGFydF9zdGF0X2FkZChjcHUsIHBhcnQsIHRpY2tzW3J3XSwgZHVyYXRpb24pOwogCQlwYXJ0X3JvdW5kX3N0YXRzKGNwdSwgcGFydCk7Ci0JCXBhcnRfZGVjX2luX2ZsaWdodChwYXJ0KTsKKwkJcGFydF9kZWNfaW5fZmxpZ2h0KHBhcnQsIHJ3KTsKIAogCQlwYXJ0X3N0YXRfdW5sb2NrKCk7CiAJfQpAQCAtMjQ5MiwxNCArMjQ5Miw2IEBACiB9CiBFWFBPUlRfU1lNQk9MKGtibG9ja2Rfc2NoZWR1bGVfd29yayk7CiAKLWludCBrYmxvY2tkX3NjaGVkdWxlX2RlbGF5ZWRfd29yayhzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSwKLQkJCQkgIHN0cnVjdCBkZWxheWVkX3dvcmsgKndvcmssCi0JCQkJICB1bnNpZ25lZCBsb25nIGRlbGF5KQotewotCXJldHVybiBxdWV1ZV9kZWxheWVkX3dvcmsoa2Jsb2NrZF93b3JrcXVldWUsIHdvcmssIGRlbGF5KTsKLX0KLUVYUE9SVF9TWU1CT0woa2Jsb2NrZF9zY2hlZHVsZV9kZWxheWVkX3dvcmspOwotCiBpbnQgX19pbml0IGJsa19kZXZfaW5pdCh2b2lkKQogewogCUJVSUxEX0JVR19PTihfX1JFUV9OUl9CSVRTID4gOCAqCmRpZmYgLS1naXQgYS9ibG9jay9ibGstbWVyZ2UuYyBiL2Jsb2NrL2Jsay1tZXJnZS5jCmluZGV4IGIwZGU4NTcuLjk5Y2I1Y2YgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay1tZXJnZS5jCisrKyBiL2Jsb2NrL2Jsay1tZXJnZS5jCkBAIC0zNTEsNyArMzUxLDcgQEAKIAkJcGFydCA9IGRpc2tfbWFwX3NlY3Rvcl9yY3UocmVxLT5ycV9kaXNrLCBibGtfcnFfcG9zKHJlcSkpOwogCiAJCXBhcnRfcm91bmRfc3RhdHMoY3B1LCBwYXJ0KTsKLQkJcGFydF9kZWNfaW5fZmxpZ2h0KHBhcnQpOworCQlwYXJ0X2RlY19pbl9mbGlnaHQocGFydCwgcnFfZGF0YV9kaXIocmVxKSk7CiAKIAkJcGFydF9zdGF0X3VubG9jaygpOwogCX0KZGlmZiAtLWdpdCBhL2Jsb2NrL2Jsay1zZXR0aW5ncy5jIGIvYmxvY2svYmxrLXNldHRpbmdzLmMKaW5kZXggZTA2OTViYy4uNjZkNGFhOCAxMDA2NDQKLS0tIGEvYmxvY2svYmxrLXNldHRpbmdzLmMKKysrIGIvYmxvY2svYmxrLXNldHRpbmdzLmMKQEAgLTI0Miw3ICsyNDIsNyBAQAogLyoqCiAgKiBibGtfcXVldWVfbWF4X2Rpc2NhcmRfc2VjdG9ycyAtIHNldCBtYXggc2VjdG9ycyBmb3IgYSBzaW5nbGUgZGlzY2FyZAogICogQHE6ICB0aGUgcmVxdWVzdCBxdWV1ZSBmb3IgdGhlIGRldmljZQotICogQG1heF9kaXNjYXJkOiBtYXhpbXVtIG51bWJlciBvZiBzZWN0b3JzIHRvIGRpc2NhcmQKKyAqIEBtYXhfZGlzY2FyZF9zZWN0b3JzOiBtYXhpbXVtIG51bWJlciBvZiBzZWN0b3JzIHRvIGRpc2NhcmQKICAqKi8KIHZvaWQgYmxrX3F1ZXVlX21heF9kaXNjYXJkX3NlY3RvcnMoc3RydWN0IHJlcXVlc3RfcXVldWUgKnEsCiAJCXVuc2lnbmVkIGludCBtYXhfZGlzY2FyZF9zZWN0b3JzKQpkaWZmIC0tZ2l0IGEvYmxvY2svYmxrLXRhZy5jIGIvYmxvY2svYmxrLXRhZy5jCmluZGV4IDJlNWNmZWIuLjZiMGY1MmMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2Jsay10YWcuYworKysgYi9ibG9jay9ibGstdGFnLmMKQEAgLTM1OSw3ICszNTksNyBAQAogCQltYXhfZGVwdGggLT0gMjsKIAkJaWYgKCFtYXhfZGVwdGgpCiAJCQltYXhfZGVwdGggPSAxOwotCQlpZiAocS0+aW5fZmxpZ2h0WzBdID4gbWF4X2RlcHRoKQorCQlpZiAocS0+aW5fZmxpZ2h0W0JMS19SV19BU1lOQ10gPiBtYXhfZGVwdGgpCiAJCQlyZXR1cm4gMTsKIAl9CiAKZGlmZiAtLWdpdCBhL2Jsb2NrL2NmcS1pb3NjaGVkLmMgYi9ibG9jay9jZnEtaW9zY2hlZC5jCmluZGV4IDljNGI2NzkuLjA2OWE2MTAgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2NmcS1pb3NjaGVkLmMKKysrIGIvYmxvY2svY2ZxLWlvc2NoZWQuYwpAQCAtMTUwLDcgKzE1MCw3IEBACiAJICogaWRsZSB3aW5kb3cgbWFuYWdlbWVudAogCSAqLwogCXN0cnVjdCB0aW1lcl9saXN0IGlkbGVfc2xpY2VfdGltZXI7Ci0Jc3RydWN0IGRlbGF5ZWRfd29yayB1bnBsdWdfd29yazsKKwlzdHJ1Y3Qgd29ya19zdHJ1Y3QgdW5wbHVnX3dvcms7CiAKIAlzdHJ1Y3QgY2ZxX3F1ZXVlICphY3RpdmVfcXVldWU7CiAJc3RydWN0IGNmcV9pb19jb250ZXh0ICphY3RpdmVfY2ljOwpAQCAtMjMwLDcgKzIzMCw3IEBACiAJYmxrX2FkZF90cmFjZV9tc2coKGNmcWQpLT5xdWV1ZSwgImNmcSAiIGZtdCwgIyNhcmdzKQogCiBzdGF0aWMgdm9pZCBjZnFfZGlzcGF0Y2hfaW5zZXJ0KHN0cnVjdCByZXF1ZXN0X3F1ZXVlICosIHN0cnVjdCByZXF1ZXN0ICopOwotc3RhdGljIHN0cnVjdCBjZnFfcXVldWUgKmNmcV9nZXRfcXVldWUoc3RydWN0IGNmcV9kYXRhICosIGludCwKK3N0YXRpYyBzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFfZ2V0X3F1ZXVlKHN0cnVjdCBjZnFfZGF0YSAqLCBib29sLAogCQkJCSAgICAgICBzdHJ1Y3QgaW9fY29udGV4dCAqLCBnZnBfdCk7CiBzdGF0aWMgc3RydWN0IGNmcV9pb19jb250ZXh0ICpjZnFfY2ljX2xvb2t1cChzdHJ1Y3QgY2ZxX2RhdGEgKiwKIAkJCQkJCXN0cnVjdCBpb19jb250ZXh0ICopOwpAQCAtMjQxLDQwICsyNDEsMzUgQEAKIH0KIAogc3RhdGljIGlubGluZSBzdHJ1Y3QgY2ZxX3F1ZXVlICpjaWNfdG9fY2ZxcShzdHJ1Y3QgY2ZxX2lvX2NvbnRleHQgKmNpYywKLQkJCQkJICAgIGludCBpc19zeW5jKQorCQkJCQkgICAgYm9vbCBpc19zeW5jKQogewotCXJldHVybiBjaWMtPmNmcXFbISFpc19zeW5jXTsKKwlyZXR1cm4gY2ljLT5jZnFxW2lzX3N5bmNdOwogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgY2ljX3NldF9jZnFxKHN0cnVjdCBjZnFfaW9fY29udGV4dCAqY2ljLAotCQkJCXN0cnVjdCBjZnFfcXVldWUgKmNmcXEsIGludCBpc19zeW5jKQorCQkJCXN0cnVjdCBjZnFfcXVldWUgKmNmcXEsIGJvb2wgaXNfc3luYykKIHsKLQljaWMtPmNmcXFbISFpc19zeW5jXSA9IGNmcXE7CisJY2ljLT5jZnFxW2lzX3N5bmNdID0gY2ZxcTsKIH0KIAogLyoKICAqIFdlIHJlZ2FyZCBhIHJlcXVlc3QgYXMgU1lOQywgaWYgaXQncyBlaXRoZXIgYSByZWFkIG9yIGhhcyB0aGUgU1lOQyBiaXQKICAqIHNldCAoaW4gd2hpY2ggY2FzZSBpdCBjb3VsZCBhbHNvIGJlIGRpcmVjdCBXUklURSkuCiAgKi8KLXN0YXRpYyBpbmxpbmUgaW50IGNmcV9iaW9fc3luYyhzdHJ1Y3QgYmlvICpiaW8pCitzdGF0aWMgaW5saW5lIGJvb2wgY2ZxX2Jpb19zeW5jKHN0cnVjdCBiaW8gKmJpbykKIHsKLQlpZiAoYmlvX2RhdGFfZGlyKGJpbykgPT0gUkVBRCB8fCBiaW9fcndfZmxhZ2dlZChiaW8sIEJJT19SV19TWU5DSU8pKQotCQlyZXR1cm4gMTsKLQotCXJldHVybiAwOworCXJldHVybiBiaW9fZGF0YV9kaXIoYmlvKSA9PSBSRUFEIHx8IGJpb19yd19mbGFnZ2VkKGJpbywgQklPX1JXX1NZTkNJTyk7CiB9CiAKIC8qCiAgKiBzY2hlZHVsZXIgcnVuIG9mIHF1ZXVlLCBpZiB0aGVyZSBhcmUgcmVxdWVzdHMgcGVuZGluZyBhbmQgbm8gb25lIGluIHRoZQogICogZHJpdmVyIHRoYXQgd2lsbCByZXN0YXJ0IHF1ZXVlaW5nCiAgKi8KLXN0YXRpYyBpbmxpbmUgdm9pZCBjZnFfc2NoZWR1bGVfZGlzcGF0Y2goc3RydWN0IGNmcV9kYXRhICpjZnFkLAotCQkJCQkgdW5zaWduZWQgbG9uZyBkZWxheSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBjZnFfc2NoZWR1bGVfZGlzcGF0Y2goc3RydWN0IGNmcV9kYXRhICpjZnFkKQogewogCWlmIChjZnFkLT5idXN5X3F1ZXVlcykgewogCQljZnFfbG9nKGNmcWQsICJzY2hlZHVsZSBkaXNwYXRjaCIpOwotCQlrYmxvY2tkX3NjaGVkdWxlX2RlbGF5ZWRfd29yayhjZnFkLT5xdWV1ZSwgJmNmcWQtPnVucGx1Z193b3JrLAotCQkJCQkJZGVsYXkpOworCQlrYmxvY2tkX3NjaGVkdWxlX3dvcmsoY2ZxZC0+cXVldWUsICZjZnFkLT51bnBsdWdfd29yayk7CiAJfQogfQogCkBAIC0yOTAsNyArMjg1LDcgQEAKICAqIGlmIGEgcXVldWUgaXMgbWFya2VkIHN5bmMgYW5kIGhhcyBzeW5jIGlvIHF1ZXVlZC4gQSBzeW5jIHF1ZXVlIHdpdGggYXN5bmMKICAqIGlvIG9ubHksIHNob3VsZCBub3QgZ2V0IGZ1bGwgc3luYyBzbGljZSBsZW5ndGguCiAgKi8KLXN0YXRpYyBpbmxpbmUgaW50IGNmcV9wcmlvX3NsaWNlKHN0cnVjdCBjZnFfZGF0YSAqY2ZxZCwgaW50IHN5bmMsCitzdGF0aWMgaW5saW5lIGludCBjZnFfcHJpb19zbGljZShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIGJvb2wgc3luYywKIAkJCQkgdW5zaWduZWQgc2hvcnQgcHJpbykKIHsKIAljb25zdCBpbnQgYmFzZV9zbGljZSA9IGNmcWQtPmNmcV9zbGljZVtzeW5jXTsKQEAgLTMxOCw3ICszMTMsNyBAQAogICogaXNuJ3QgdmFsaWQgdW50aWwgdGhlIGZpcnN0IHJlcXVlc3QgZnJvbSB0aGUgZGlzcGF0Y2ggaXMgYWN0aXZhdGVkCiAgKiBhbmQgdGhlIHNsaWNlIHRpbWUgc2V0LgogICovCi1zdGF0aWMgaW5saW5lIGludCBjZnFfc2xpY2VfdXNlZChzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFxKQorc3RhdGljIGlubGluZSBib29sIGNmcV9zbGljZV91c2VkKHN0cnVjdCBjZnFfcXVldWUgKmNmcXEpCiB7CiAJaWYgKGNmcV9jZnFxX3NsaWNlX25ldyhjZnFxKSkKIAkJcmV0dXJuIDA7CkBAIC00OTMsNyArNDg4LDcgQEAKICAqIHdlIHdpbGwgc2VydmljZSB0aGUgcXVldWVzLgogICovCiBzdGF0aWMgdm9pZCBjZnFfc2VydmljZV90cmVlX2FkZChzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIHN0cnVjdCBjZnFfcXVldWUgKmNmcXEsCi0JCQkJIGludCBhZGRfZnJvbnQpCisJCQkJIGJvb2wgYWRkX2Zyb250KQogewogCXN0cnVjdCByYl9ub2RlICoqcCwgKnBhcmVudDsKIAlzdHJ1Y3QgY2ZxX3F1ZXVlICpfX2NmcXE7CkBAIC01MDksMTEgKzUwNCwyMCBAQAogCQl9IGVsc2UKIAkJCXJiX2tleSArPSBqaWZmaWVzOwogCX0gZWxzZSBpZiAoIWFkZF9mcm9udCkgeworCQkvKgorCQkgKiBHZXQgb3VyIHJiIGtleSBvZmZzZXQuIFN1YnRyYWN0IGFueSByZXNpZHVhbCBzbGljZQorCQkgKiB2YWx1ZSBjYXJyaWVkIGZyb20gbGFzdCBzZXJ2aWNlLiBBIG5lZ2F0aXZlIHJlc2lkCisJCSAqIGNvdW50IGluZGljYXRlcyBzbGljZSBvdmVycnVuLCBhbmQgdGhpcyBzaG91bGQgcG9zaXRpb24KKwkJICogdGhlIG5leHQgc2VydmljZSB0aW1lIGZ1cnRoZXIgYXdheSBpbiB0aGUgdHJlZS4KKwkJICovCiAJCXJiX2tleSA9IGNmcV9zbGljZV9vZmZzZXQoY2ZxZCwgY2ZxcSkgKyBqaWZmaWVzOwotCQlyYl9rZXkgKz0gY2ZxcS0+c2xpY2VfcmVzaWQ7CisJCXJiX2tleSAtPSBjZnFxLT5zbGljZV9yZXNpZDsKIAkJY2ZxcS0+c2xpY2VfcmVzaWQgPSAwOwotCX0gZWxzZQotCQlyYl9rZXkgPSAwOworCX0gZWxzZSB7CisJCXJiX2tleSA9IC1IWjsKKwkJX19jZnFxID0gY2ZxX3JiX2ZpcnN0KCZjZnFkLT5zZXJ2aWNlX3RyZWUpOworCQlyYl9rZXkgKz0gX19jZnFxID8gX19jZnFxLT5yYl9rZXkgOiBqaWZmaWVzOworCX0KIAogCWlmICghUkJfRU1QVFlfTk9ERSgmY2ZxcS0+cmJfbm9kZSkpIHsKIAkJLyoKQEAgLTU0Nyw3ICs1NTEsNyBAQAogCQkJbiA9ICYoKnApLT5yYl9sZWZ0OwogCQllbHNlIGlmIChjZnFfY2xhc3NfaWRsZShjZnFxKSA+IGNmcV9jbGFzc19pZGxlKF9fY2ZxcSkpCiAJCQluID0gJigqcCktPnJiX3JpZ2h0OwotCQllbHNlIGlmIChyYl9rZXkgPCBfX2NmcXEtPnJiX2tleSkKKwkJZWxzZSBpZiAodGltZV9iZWZvcmUocmJfa2V5LCBfX2NmcXEtPnJiX2tleSkpCiAJCQluID0gJigqcCktPnJiX2xlZnQ7CiAJCWVsc2UKIAkJCW4gPSAmKCpwKS0+cmJfcmlnaHQ7CkBAIC04MjcsOCArODMxLDEwIEBACiAJICogcmVwb3NpdGlvbiBpbiBmaWZvIGlmIG5leHQgaXMgb2xkZXIgdGhhbiBycQogCSAqLwogCWlmICghbGlzdF9lbXB0eSgmcnEtPnF1ZXVlbGlzdCkgJiYgIWxpc3RfZW1wdHkoJm5leHQtPnF1ZXVlbGlzdCkgJiYKLQkgICAgdGltZV9iZWZvcmUobmV4dC0+c3RhcnRfdGltZSwgcnEtPnN0YXJ0X3RpbWUpKQorCSAgICB0aW1lX2JlZm9yZShycV9maWZvX3RpbWUobmV4dCksIHJxX2ZpZm9fdGltZShycSkpKSB7CiAJCWxpc3RfbW92ZSgmcnEtPnF1ZXVlbGlzdCwgJm5leHQtPnF1ZXVlbGlzdCk7CisJCXJxX3NldF9maWZvX3RpbWUocnEsIHJxX2ZpZm9fdGltZShuZXh0KSk7CisJfQogCiAJY2ZxX3JlbW92ZV9yZXF1ZXN0KG5leHQpOwogfQpAQCAtODQ0LDcgKzg1MCw3IEBACiAJICogRGlzYWxsb3cgbWVyZ2Ugb2YgYSBzeW5jIGJpbyBpbnRvIGFuIGFzeW5jIHJlcXVlc3QuCiAJICovCiAJaWYgKGNmcV9iaW9fc3luYyhiaW8pICYmICFycV9pc19zeW5jKHJxKSkKLQkJcmV0dXJuIDA7CisJCXJldHVybiBmYWxzZTsKIAogCS8qCiAJICogTG9va3VwIHRoZSBjZnFxIHRoYXQgdGhpcyBiaW8gd2lsbCBiZSBxdWV1ZWQgd2l0aC4gQWxsb3cKQEAgLTg1MiwxMyArODU4LDEwIEBACiAJICovCiAJY2ljID0gY2ZxX2NpY19sb29rdXAoY2ZxZCwgY3VycmVudC0+aW9fY29udGV4dCk7CiAJaWYgKCFjaWMpCi0JCXJldHVybiAwOworCQlyZXR1cm4gZmFsc2U7CiAKIAljZnFxID0gY2ljX3RvX2NmcXEoY2ljLCBjZnFfYmlvX3N5bmMoYmlvKSk7Ci0JaWYgKGNmcXEgPT0gUlFfQ0ZRUShycSkpCi0JCXJldHVybiAxOwotCi0JcmV0dXJuIDA7CisJcmV0dXJuIGNmcXEgPT0gUlFfQ0ZRUShycSk7CiB9CiAKIHN0YXRpYyB2b2lkIF9fY2ZxX3NldF9hY3RpdmVfcXVldWUoc3RydWN0IGNmcV9kYXRhICpjZnFkLApAQCAtODg2LDcgKzg4OSw3IEBACiAgKi8KIHN0YXRpYyB2b2lkCiBfX2NmcV9zbGljZV9leHBpcmVkKHN0cnVjdCBjZnFfZGF0YSAqY2ZxZCwgc3RydWN0IGNmcV9xdWV1ZSAqY2ZxcSwKLQkJICAgIGludCB0aW1lZF9vdXQpCisJCSAgICBib29sIHRpbWVkX291dCkKIHsKIAljZnFfbG9nX2NmcXEoY2ZxZCwgY2ZxcSwgInNsaWNlIGV4cGlyZWQgdD0lZCIsIHRpbWVkX291dCk7CiAKQEAgLTkxNCw3ICs5MTcsNyBAQAogCX0KIH0KIAotc3RhdGljIGlubGluZSB2b2lkIGNmcV9zbGljZV9leHBpcmVkKHN0cnVjdCBjZnFfZGF0YSAqY2ZxZCwgaW50IHRpbWVkX291dCkKK3N0YXRpYyBpbmxpbmUgdm9pZCBjZnFfc2xpY2VfZXhwaXJlZChzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIGJvb2wgdGltZWRfb3V0KQogewogCXN0cnVjdCBjZnFfcXVldWUgKmNmcXEgPSBjZnFkLT5hY3RpdmVfcXVldWU7CiAKQEAgLTEwMjYsNyArMTAyOSw3IEBACiAgKi8KIHN0YXRpYyBzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFfY2xvc2VfY29vcGVyYXRvcihzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsCiAJCQkJCSAgICAgIHN0cnVjdCBjZnFfcXVldWUgKmN1cl9jZnFxLAotCQkJCQkgICAgICBpbnQgcHJvYmUpCisJCQkJCSAgICAgIGJvb2wgcHJvYmUpCiB7CiAJc3RydWN0IGNmcV9xdWV1ZSAqY2ZxcTsKIApAQCAtMTA5MCw2ICsxMDkzLDE1IEBACiAJaWYgKCFjaWMgfHwgIWF0b21pY19yZWFkKCZjaWMtPmlvYy0+bnJfdGFza3MpKQogCQlyZXR1cm47CiAKKwkvKgorCSAqIElmIG91ciBhdmVyYWdlIHRoaW5rIHRpbWUgaXMgbGFyZ2VyIHRoYW4gdGhlIHJlbWFpbmluZyB0aW1lCisJICogc2xpY2UsIHRoZW4gZG9uJ3QgaWRsZS4gVGhpcyBhdm9pZHMgb3ZlcnJ1bm5pbmcgdGhlIGFsbG90dGVkCisJICogdGltZSBzbGljZS4KKwkgKi8KKwlpZiAoc2FtcGxlX3ZhbGlkKGNpYy0+dHRpbWVfc2FtcGxlcykgJiYKKwkgICAgKGNmcXEtPnNsaWNlX2VuZCAtIGppZmZpZXMgPCBjaWMtPnR0aW1lX21lYW4pKQorCQlyZXR1cm47CisKIAljZnFfbWFya19jZnFxX3dhaXRfcmVxdWVzdChjZnFxKTsKIAogCS8qCkBAIC0xMTI5LDkgKzExNDEsNyBAQAogICovCiBzdGF0aWMgc3RydWN0IHJlcXVlc3QgKmNmcV9jaGVja19maWZvKHN0cnVjdCBjZnFfcXVldWUgKmNmcXEpCiB7Ci0Jc3RydWN0IGNmcV9kYXRhICpjZnFkID0gY2ZxcS0+Y2ZxZDsKLQlzdHJ1Y3QgcmVxdWVzdCAqcnE7Ci0JaW50IGZpZm87CisJc3RydWN0IHJlcXVlc3QgKnJxID0gTlVMTDsKIAogCWlmIChjZnFfY2ZxcV9maWZvX2V4cGlyZShjZnFxKSkKIAkJcmV0dXJuIE5VTEw7CkBAIC0xMTQxLDEzICsxMTUxLDExIEBACiAJaWYgKGxpc3RfZW1wdHkoJmNmcXEtPmZpZm8pKQogCQlyZXR1cm4gTlVMTDsKIAotCWZpZm8gPSBjZnFfY2ZxcV9zeW5jKGNmcXEpOwogCXJxID0gcnFfZW50cnlfZmlmbyhjZnFxLT5maWZvLm5leHQpOwotCi0JaWYgKHRpbWVfYmVmb3JlKGppZmZpZXMsIHJxLT5zdGFydF90aW1lICsgY2ZxZC0+Y2ZxX2ZpZm9fZXhwaXJlW2ZpZm9dKSkKKwlpZiAodGltZV9iZWZvcmUoamlmZmllcywgcnFfZmlmb190aW1lKHJxKSkpCiAJCXJxID0gTlVMTDsKIAotCWNmcV9sb2dfY2ZxcShjZnFkLCBjZnFxLCAiZmlmbz0lcCIsIHJxKTsKKwljZnFfbG9nX2NmcXEoY2ZxcS0+Y2ZxZCwgY2ZxcSwgImZpZm89JXAiLCBycSk7CiAJcmV0dXJuIHJxOwogfQogCkBAIC0xMjQ4LDY3ICsxMjU2LDIxIEBACiAJcmV0dXJuIGRpc3BhdGNoZWQ7CiB9CiAKLS8qCi0gKiBEaXNwYXRjaCBhIHJlcXVlc3QgZnJvbSBjZnFxLCBtb3ZpbmcgdGhlbSB0byB0aGUgcmVxdWVzdCBxdWV1ZQotICogZGlzcGF0Y2ggbGlzdC4KLSAqLwotc3RhdGljIHZvaWQgY2ZxX2Rpc3BhdGNoX3JlcXVlc3Qoc3RydWN0IGNmcV9kYXRhICpjZnFkLCBzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFxKQorc3RhdGljIGJvb2wgY2ZxX21heV9kaXNwYXRjaChzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIHN0cnVjdCBjZnFfcXVldWUgKmNmcXEpCiB7Ci0Jc3RydWN0IHJlcXVlc3QgKnJxOwotCi0JQlVHX09OKFJCX0VNUFRZX1JPT1QoJmNmcXEtPnNvcnRfbGlzdCkpOwotCi0JLyoKLQkgKiBmb2xsb3cgZXhwaXJlZCBwYXRoLCBlbHNlIGdldCBmaXJzdCBuZXh0IGF2YWlsYWJsZQotCSAqLwotCXJxID0gY2ZxX2NoZWNrX2ZpZm8oY2ZxcSk7Ci0JaWYgKCFycSkKLQkJcnEgPSBjZnFxLT5uZXh0X3JxOwotCi0JLyoKLQkgKiBpbnNlcnQgcmVxdWVzdCBpbnRvIGRyaXZlciBkaXNwYXRjaCBsaXN0Ci0JICovCi0JY2ZxX2Rpc3BhdGNoX2luc2VydChjZnFkLT5xdWV1ZSwgcnEpOwotCi0JaWYgKCFjZnFkLT5hY3RpdmVfY2ljKSB7Ci0JCXN0cnVjdCBjZnFfaW9fY29udGV4dCAqY2ljID0gUlFfQ0lDKHJxKTsKLQotCQlhdG9taWNfbG9uZ19pbmMoJmNpYy0+aW9jLT5yZWZjb3VudCk7Ci0JCWNmcWQtPmFjdGl2ZV9jaWMgPSBjaWM7Ci0JfQotfQotCi0vKgotICogRmluZCB0aGUgY2ZxcSB0aGF0IHdlIG5lZWQgdG8gc2VydmljZSBhbmQgbW92ZSBhIHJlcXVlc3QgZnJvbSB0aGF0IHRvIHRoZQotICogZGlzcGF0Y2ggbGlzdAotICovCi1zdGF0aWMgaW50IGNmcV9kaXNwYXRjaF9yZXF1ZXN0cyhzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSwgaW50IGZvcmNlKQotewotCXN0cnVjdCBjZnFfZGF0YSAqY2ZxZCA9IHEtPmVsZXZhdG9yLT5lbGV2YXRvcl9kYXRhOwotCXN0cnVjdCBjZnFfcXVldWUgKmNmcXE7CiAJdW5zaWduZWQgaW50IG1heF9kaXNwYXRjaDsKIAotCWlmICghY2ZxZC0+YnVzeV9xdWV1ZXMpCi0JCXJldHVybiAwOwotCi0JaWYgKHVubGlrZWx5KGZvcmNlKSkKLQkJcmV0dXJuIGNmcV9mb3JjZWRfZGlzcGF0Y2goY2ZxZCk7Ci0KLQljZnFxID0gY2ZxX3NlbGVjdF9xdWV1ZShjZnFkKTsKLQlpZiAoIWNmcXEpCi0JCXJldHVybiAwOwotCiAJLyoKIAkgKiBEcmFpbiBhc3luYyByZXF1ZXN0cyBiZWZvcmUgd2Ugc3RhcnQgc3luYyBJTwogCSAqLwogCWlmIChjZnFfY2ZxcV9pZGxlX3dpbmRvdyhjZnFxKSAmJiBjZnFkLT5ycV9pbl9kcml2ZXJbQkxLX1JXX0FTWU5DXSkKLQkJcmV0dXJuIDA7CisJCXJldHVybiBmYWxzZTsKIAogCS8qCiAJICogSWYgdGhpcyBpcyBhbiBhc3luYyBxdWV1ZSBhbmQgd2UgaGF2ZSBzeW5jIElPIGluIGZsaWdodCwgbGV0IGl0IHdhaXQKIAkgKi8KIAlpZiAoY2ZxZC0+c3luY19mbGlnaHQgJiYgIWNmcV9jZnFxX3N5bmMoY2ZxcSkpCi0JCXJldHVybiAwOworCQlyZXR1cm4gZmFsc2U7CiAKIAltYXhfZGlzcGF0Y2ggPSBjZnFkLT5jZnFfcXVhbnR1bTsKIAlpZiAoY2ZxX2NsYXNzX2lkbGUoY2ZxcSkpCkBAIC0xMzIyLDEzICsxMjg0LDEzIEBACiAJCSAqIGlkbGUgcXVldWUgbXVzdCBhbHdheXMgb25seSBoYXZlIGEgc2luZ2xlIElPIGluIGZsaWdodAogCQkgKi8KIAkJaWYgKGNmcV9jbGFzc19pZGxlKGNmcXEpKQotCQkJcmV0dXJuIDA7CisJCQlyZXR1cm4gZmFsc2U7CiAKIAkJLyoKIAkJICogV2UgaGF2ZSBvdGhlciBxdWV1ZXMsIGRvbid0IGFsbG93IG1vcmUgSU8gZnJvbSB0aGlzIG9uZQogCQkgKi8KIAkJaWYgKGNmcWQtPmJ1c3lfcXVldWVzID4gMSkKLQkJCXJldHVybiAwOworCQkJcmV0dXJuIGZhbHNlOwogCiAJCS8qCiAJCSAqIFNvbGUgcXVldWUgdXNlciwgYWxsb3cgYmlnZ2VyIHNsaWNlCkBAIC0xMzUyLDEzICsxMzE0LDcyIEBACiAJCQltYXhfZGlzcGF0Y2ggPSBkZXB0aDsKIAl9CiAKLQlpZiAoY2ZxcS0+ZGlzcGF0Y2hlZCA+PSBtYXhfZGlzcGF0Y2gpCisJLyoKKwkgKiBJZiB3ZSdyZSBiZWxvdyB0aGUgY3VycmVudCBtYXgsIGFsbG93IGEgZGlzcGF0Y2gKKwkgKi8KKwlyZXR1cm4gY2ZxcS0+ZGlzcGF0Y2hlZCA8IG1heF9kaXNwYXRjaDsKK30KKworLyoKKyAqIERpc3BhdGNoIGEgcmVxdWVzdCBmcm9tIGNmcXEsIG1vdmluZyB0aGVtIHRvIHRoZSByZXF1ZXN0IHF1ZXVlCisgKiBkaXNwYXRjaCBsaXN0LgorICovCitzdGF0aWMgYm9vbCBjZnFfZGlzcGF0Y2hfcmVxdWVzdChzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIHN0cnVjdCBjZnFfcXVldWUgKmNmcXEpCit7CisJc3RydWN0IHJlcXVlc3QgKnJxOworCisJQlVHX09OKFJCX0VNUFRZX1JPT1QoJmNmcXEtPnNvcnRfbGlzdCkpOworCisJaWYgKCFjZnFfbWF5X2Rpc3BhdGNoKGNmcWQsIGNmcXEpKQorCQlyZXR1cm4gZmFsc2U7CisKKwkvKgorCSAqIGZvbGxvdyBleHBpcmVkIHBhdGgsIGVsc2UgZ2V0IGZpcnN0IG5leHQgYXZhaWxhYmxlCisJICovCisJcnEgPSBjZnFfY2hlY2tfZmlmbyhjZnFxKTsKKwlpZiAoIXJxKQorCQlycSA9IGNmcXEtPm5leHRfcnE7CisKKwkvKgorCSAqIGluc2VydCByZXF1ZXN0IGludG8gZHJpdmVyIGRpc3BhdGNoIGxpc3QKKwkgKi8KKwljZnFfZGlzcGF0Y2hfaW5zZXJ0KGNmcWQtPnF1ZXVlLCBycSk7CisKKwlpZiAoIWNmcWQtPmFjdGl2ZV9jaWMpIHsKKwkJc3RydWN0IGNmcV9pb19jb250ZXh0ICpjaWMgPSBSUV9DSUMocnEpOworCisJCWF0b21pY19sb25nX2luYygmY2ljLT5pb2MtPnJlZmNvdW50KTsKKwkJY2ZxZC0+YWN0aXZlX2NpYyA9IGNpYzsKKwl9CisKKwlyZXR1cm4gdHJ1ZTsKK30KKworLyoKKyAqIEZpbmQgdGhlIGNmcXEgdGhhdCB3ZSBuZWVkIHRvIHNlcnZpY2UgYW5kIG1vdmUgYSByZXF1ZXN0IGZyb20gdGhhdCB0byB0aGUKKyAqIGRpc3BhdGNoIGxpc3QKKyAqLworc3RhdGljIGludCBjZnFfZGlzcGF0Y2hfcmVxdWVzdHMoc3RydWN0IHJlcXVlc3RfcXVldWUgKnEsIGludCBmb3JjZSkKK3sKKwlzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQgPSBxLT5lbGV2YXRvci0+ZWxldmF0b3JfZGF0YTsKKwlzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFxOworCisJaWYgKCFjZnFkLT5idXN5X3F1ZXVlcykKKwkJcmV0dXJuIDA7CisKKwlpZiAodW5saWtlbHkoZm9yY2UpKQorCQlyZXR1cm4gY2ZxX2ZvcmNlZF9kaXNwYXRjaChjZnFkKTsKKworCWNmcXEgPSBjZnFfc2VsZWN0X3F1ZXVlKGNmcWQpOworCWlmICghY2ZxcSkKIAkJcmV0dXJuIDA7CiAKIAkvKgotCSAqIERpc3BhdGNoIGEgcmVxdWVzdCBmcm9tIHRoaXMgY2ZxcQorCSAqIERpc3BhdGNoIGEgcmVxdWVzdCBmcm9tIHRoaXMgY2ZxcSwgaWYgaXQgaXMgYWxsb3dlZAogCSAqLwotCWNmcV9kaXNwYXRjaF9yZXF1ZXN0KGNmcWQsIGNmcXEpOworCWlmICghY2ZxX2Rpc3BhdGNoX3JlcXVlc3QoY2ZxZCwgY2ZxcSkpCisJCXJldHVybiAwOworCiAJY2ZxcS0+c2xpY2VfZGlzcGF0Y2grKzsKIAljZnFfY2xlYXJfY2ZxcV9tdXN0X2Rpc3BhdGNoKGNmcXEpOwogCkBAIC0xMzk5LDcgKzE0MjAsNyBAQAogCiAJaWYgKHVubGlrZWx5KGNmcWQtPmFjdGl2ZV9xdWV1ZSA9PSBjZnFxKSkgewogCQlfX2NmcV9zbGljZV9leHBpcmVkKGNmcWQsIGNmcXEsIDApOwotCQljZnFfc2NoZWR1bGVfZGlzcGF0Y2goY2ZxZCwgMCk7CisJCWNmcV9zY2hlZHVsZV9kaXNwYXRjaChjZnFkKTsKIAl9CiAKIAlrbWVtX2NhY2hlX2ZyZWUoY2ZxX3Bvb2wsIGNmcXEpOwpAQCAtMTQ5NCw3ICsxNTE1LDcgQEAKIHsKIAlpZiAodW5saWtlbHkoY2ZxcSA9PSBjZnFkLT5hY3RpdmVfcXVldWUpKSB7CiAJCV9fY2ZxX3NsaWNlX2V4cGlyZWQoY2ZxZCwgY2ZxcSwgMCk7Ci0JCWNmcV9zY2hlZHVsZV9kaXNwYXRjaChjZnFkLCAwKTsKKwkJY2ZxX3NjaGVkdWxlX2Rpc3BhdGNoKGNmcWQpOwogCX0KIAogCWNmcV9wdXRfcXVldWUoY2ZxcSk7CkBAIC0xNjU4LDcgKzE2NzksNyBAQAogfQogCiBzdGF0aWMgdm9pZCBjZnFfaW5pdF9jZnFxKHN0cnVjdCBjZnFfZGF0YSAqY2ZxZCwgc3RydWN0IGNmcV9xdWV1ZSAqY2ZxcSwKLQkJCSAgcGlkX3QgcGlkLCBpbnQgaXNfc3luYykKKwkJCSAgcGlkX3QgcGlkLCBib29sIGlzX3N5bmMpCiB7CiAJUkJfQ0xFQVJfTk9ERSgmY2ZxcS0+cmJfbm9kZSk7CiAJUkJfQ0xFQVJfTk9ERSgmY2ZxcS0+cF9ub2RlKTsKQEAgLTE2NzgsNyArMTY5OSw3IEBACiB9CiAKIHN0YXRpYyBzdHJ1Y3QgY2ZxX3F1ZXVlICoKLWNmcV9maW5kX2FsbG9jX3F1ZXVlKHN0cnVjdCBjZnFfZGF0YSAqY2ZxZCwgaW50IGlzX3N5bmMsCitjZnFfZmluZF9hbGxvY19xdWV1ZShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIGJvb2wgaXNfc3luYywKIAkJICAgICBzdHJ1Y3QgaW9fY29udGV4dCAqaW9jLCBnZnBfdCBnZnBfbWFzaykKIHsKIAlzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFxLCAqbmV3X2NmcXEgPSBOVUxMOwpAQCAtMTc0Miw3ICsxNzYzLDcgQEAKIH0KIAogc3RhdGljIHN0cnVjdCBjZnFfcXVldWUgKgotY2ZxX2dldF9xdWV1ZShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIGludCBpc19zeW5jLCBzdHJ1Y3QgaW9fY29udGV4dCAqaW9jLAorY2ZxX2dldF9xdWV1ZShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIGJvb2wgaXNfc3luYywgc3RydWN0IGlvX2NvbnRleHQgKmlvYywKIAkgICAgICBnZnBfdCBnZnBfbWFzaykKIHsKIAljb25zdCBpbnQgaW9wcmlvID0gdGFza19pb3ByaW8oaW9jKTsKQEAgLTE5NzcsNyArMTk5OCwxMCBAQAogCSAgICAoIWNmcWQtPmNmcV9sYXRlbmN5ICYmIGNmcWQtPmh3X3RhZyAmJiBDSUNfU0VFS1koY2ljKSkpCiAJCWVuYWJsZV9pZGxlID0gMDsKIAllbHNlIGlmIChzYW1wbGVfdmFsaWQoY2ljLT50dGltZV9zYW1wbGVzKSkgewotCQlpZiAoY2ljLT50dGltZV9tZWFuID4gY2ZxZC0+Y2ZxX3NsaWNlX2lkbGUpCisJCXVuc2lnbmVkIGludCBzbGljZV9pZGxlID0gY2ZxZC0+Y2ZxX3NsaWNlX2lkbGU7CisJCWlmIChzYW1wbGVfdmFsaWQoY2ljLT5zZWVrX3NhbXBsZXMpICYmIENJQ19TRUVLWShjaWMpKQorCQkJc2xpY2VfaWRsZSA9IG1zZWNzX3RvX2ppZmZpZXMoQ0ZRX01JTl9UVCk7CisJCWlmIChjaWMtPnR0aW1lX21lYW4gPiBzbGljZV9pZGxlKQogCQkJZW5hYmxlX2lkbGUgPSAwOwogCQllbHNlCiAJCQllbmFibGVfaWRsZSA9IDE7CkBAIC0xOTk2LDcgKzIwMjAsNyBAQAogICogQ2hlY2sgaWYgbmV3X2NmcXEgc2hvdWxkIHByZWVtcHQgdGhlIGN1cnJlbnRseSBhY3RpdmUgcXVldWUuIFJldHVybiAwIGZvcgogICogbm8gb3IgaWYgd2UgYXJlbid0IHN1cmUsIGEgMSB3aWxsIGNhdXNlIGEgcHJlZW1wdC4KICAqLwotc3RhdGljIGludAorc3RhdGljIGJvb2wKIGNmcV9zaG91bGRfcHJlZW1wdChzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQsIHN0cnVjdCBjZnFfcXVldWUgKm5ld19jZnFxLAogCQkgICBzdHJ1Y3QgcmVxdWVzdCAqcnEpCiB7CkBAIC0yMDA0LDQ4ICsyMDI4LDQ4IEBACiAKIAljZnFxID0gY2ZxZC0+YWN0aXZlX3F1ZXVlOwogCWlmICghY2ZxcSkKLQkJcmV0dXJuIDA7CisJCXJldHVybiBmYWxzZTsKIAogCWlmIChjZnFfc2xpY2VfdXNlZChjZnFxKSkKLQkJcmV0dXJuIDE7CisJCXJldHVybiB0cnVlOwogCiAJaWYgKGNmcV9jbGFzc19pZGxlKG5ld19jZnFxKSkKLQkJcmV0dXJuIDA7CisJCXJldHVybiBmYWxzZTsKIAogCWlmIChjZnFfY2xhc3NfaWRsZShjZnFxKSkKLQkJcmV0dXJuIDE7CisJCXJldHVybiB0cnVlOwogCiAJLyoKIAkgKiBpZiB0aGUgbmV3IHJlcXVlc3QgaXMgc3luYywgYnV0IHRoZSBjdXJyZW50bHkgcnVubmluZyBxdWV1ZSBpcwogCSAqIG5vdCwgbGV0IHRoZSBzeW5jIHJlcXVlc3QgaGF2ZSBwcmlvcml0eS4KIAkgKi8KIAlpZiAocnFfaXNfc3luYyhycSkgJiYgIWNmcV9jZnFxX3N5bmMoY2ZxcSkpCi0JCXJldHVybiAxOworCQlyZXR1cm4gdHJ1ZTsKIAogCS8qCiAJICogU28gYm90aCBxdWV1ZXMgYXJlIHN5bmMuIExldCB0aGUgbmV3IHJlcXVlc3QgZ2V0IGRpc2sgdGltZSBpZgogCSAqIGl0J3MgYSBtZXRhZGF0YSByZXF1ZXN0IGFuZCB0aGUgY3VycmVudCBxdWV1ZSBpcyBkb2luZyByZWd1bGFyIElPLgogCSAqLwogCWlmIChycV9pc19tZXRhKHJxKSAmJiAhY2ZxcS0+bWV0YV9wZW5kaW5nKQotCQlyZXR1cm4gMTsKKwkJcmV0dXJuIGZhbHNlOwogCiAJLyoKIAkgKiBBbGxvdyBhbiBSVCByZXF1ZXN0IHRvIHByZS1lbXB0IGFuIG9uZ29pbmcgbm9uLVJUIGNmcXEgdGltZXNsaWNlLgogCSAqLwogCWlmIChjZnFfY2xhc3NfcnQobmV3X2NmcXEpICYmICFjZnFfY2xhc3NfcnQoY2ZxcSkpCi0JCXJldHVybiAxOworCQlyZXR1cm4gdHJ1ZTsKIAogCWlmICghY2ZxZC0+YWN0aXZlX2NpYyB8fCAhY2ZxX2NmcXFfd2FpdF9yZXF1ZXN0KGNmcXEpKQotCQlyZXR1cm4gMDsKKwkJcmV0dXJuIGZhbHNlOwogCiAJLyoKIAkgKiBpZiB0aGlzIHJlcXVlc3QgaXMgYXMtZ29vZCBhcyBvbmUgd2Ugd291bGQgZXhwZWN0IGZyb20gdGhlCiAJICogY3VycmVudCBjZnFxLCBsZXQgaXQgcHJlZW1wdAogCSAqLwogCWlmIChjZnFfcnFfY2xvc2UoY2ZxZCwgcnEpKQotCQlyZXR1cm4gMTsKKwkJcmV0dXJuIHRydWU7CiAKLQlyZXR1cm4gMDsKKwlyZXR1cm4gZmFsc2U7CiB9CiAKIC8qCkBAIC0yMTMwLDYgKzIxNTQsNyBAQAogCiAJY2ZxX2FkZF9ycV9yYihycSk7CiAKKwlycV9zZXRfZmlmb190aW1lKHJxLCBqaWZmaWVzICsgY2ZxZC0+Y2ZxX2ZpZm9fZXhwaXJlW3JxX2lzX3N5bmMocnEpXSk7CiAJbGlzdF9hZGRfdGFpbCgmcnEtPnF1ZXVlbGlzdCwgJmNmcXEtPmZpZm8pOwogCiAJY2ZxX3JxX2VucXVldWVkKGNmcWQsIGNmcXEsIHJxKTsKQEAgLTIyMTEsNyArMjIzNiw3IEBACiAJfQogCiAJaWYgKCFycV9pbl9kcml2ZXIoY2ZxZCkpCi0JCWNmcV9zY2hlZHVsZV9kaXNwYXRjaChjZnFkLCAwKTsKKwkJY2ZxX3NjaGVkdWxlX2Rpc3BhdGNoKGNmcWQpOwogfQogCiAvKgpAQCAtMjMwOSw3ICsyMzM0LDcgQEAKIAlzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQgPSBxLT5lbGV2YXRvci0+ZWxldmF0b3JfZGF0YTsKIAlzdHJ1Y3QgY2ZxX2lvX2NvbnRleHQgKmNpYzsKIAljb25zdCBpbnQgcncgPSBycV9kYXRhX2RpcihycSk7Ci0JY29uc3QgaW50IGlzX3N5bmMgPSBycV9pc19zeW5jKHJxKTsKKwljb25zdCBib29sIGlzX3N5bmMgPSBycV9pc19zeW5jKHJxKTsKIAlzdHJ1Y3QgY2ZxX3F1ZXVlICpjZnFxOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKQEAgLTIzNDEsNyArMjM2Niw3IEBACiAJaWYgKGNpYykKIAkJcHV0X2lvX2NvbnRleHQoY2ljLT5pb2MpOwogCi0JY2ZxX3NjaGVkdWxlX2Rpc3BhdGNoKGNmcWQsIDApOworCWNmcV9zY2hlZHVsZV9kaXNwYXRjaChjZnFkKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKHEtPnF1ZXVlX2xvY2ssIGZsYWdzKTsKIAljZnFfbG9nKGNmcWQsICJzZXRfcmVxdWVzdCBmYWlsIik7CiAJcmV0dXJuIDE7CkBAIC0yMzUwLDcgKzIzNzUsNyBAQAogc3RhdGljIHZvaWQgY2ZxX2tpY2tfcXVldWUoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQogewogCXN0cnVjdCBjZnFfZGF0YSAqY2ZxZCA9Ci0JCWNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgY2ZxX2RhdGEsIHVucGx1Z193b3JrLndvcmspOworCQljb250YWluZXJfb2Yod29yaywgc3RydWN0IGNmcV9kYXRhLCB1bnBsdWdfd29yayk7CiAJc3RydWN0IHJlcXVlc3RfcXVldWUgKnEgPSBjZnFkLT5xdWV1ZTsKIAogCXNwaW5fbG9ja19pcnEocS0+cXVldWVfbG9jayk7CkBAIC0yNDA0LDcgKzI0MjksNyBAQAogZXhwaXJlOgogCWNmcV9zbGljZV9leHBpcmVkKGNmcWQsIHRpbWVkX291dCk7CiBvdXRfa2ljazoKLQljZnFfc2NoZWR1bGVfZGlzcGF0Y2goY2ZxZCwgMCk7CisJY2ZxX3NjaGVkdWxlX2Rpc3BhdGNoKGNmcWQpOwogb3V0X2NvbnQ6CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShjZnFkLT5xdWV1ZS0+cXVldWVfbG9jaywgZmxhZ3MpOwogfQpAQCAtMjQxMiw3ICsyNDM3LDcgQEAKIHN0YXRpYyB2b2lkIGNmcV9zaHV0ZG93bl90aW1lcl93cShzdHJ1Y3QgY2ZxX2RhdGEgKmNmcWQpCiB7CiAJZGVsX3RpbWVyX3N5bmMoJmNmcWQtPmlkbGVfc2xpY2VfdGltZXIpOwotCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmY2ZxZC0+dW5wbHVnX3dvcmspOworCWNhbmNlbF93b3JrX3N5bmMoJmNmcWQtPnVucGx1Z193b3JrKTsKIH0KIAogc3RhdGljIHZvaWQgY2ZxX3B1dF9hc3luY19xdWV1ZXMoc3RydWN0IGNmcV9kYXRhICpjZnFkKQpAQCAtMjQ5NCw3ICsyNTE5LDcgQEAKIAljZnFkLT5pZGxlX3NsaWNlX3RpbWVyLmZ1bmN0aW9uID0gY2ZxX2lkbGVfc2xpY2VfdGltZXI7CiAJY2ZxZC0+aWRsZV9zbGljZV90aW1lci5kYXRhID0gKHVuc2lnbmVkIGxvbmcpIGNmcWQ7CiAKLQlJTklUX0RFTEFZRURfV09SSygmY2ZxZC0+dW5wbHVnX3dvcmssIGNmcV9raWNrX3F1ZXVlKTsKKwlJTklUX1dPUksoJmNmcWQtPnVucGx1Z193b3JrLCBjZnFfa2lja19xdWV1ZSk7CiAKIAljZnFkLT5jZnFfcXVhbnR1bSA9IGNmcV9xdWFudHVtOwogCWNmcWQtPmNmcV9maWZvX2V4cGlyZVswXSA9IGNmcV9maWZvX2V4cGlyZVswXTsKZGlmZiAtLWdpdCBhL2Jsb2NrL2VsZXZhdG9yLmMgYi9ibG9jay9lbGV2YXRvci5jCmluZGV4IDE5NzViNjEuLmE4NDcwNDYgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2VsZXZhdG9yLmMKKysrIGIvYmxvY2svZWxldmF0b3IuYwpAQCAtMTA1OSw5ICsxMDU5LDcgQEAKIAkJcmV0dXJuIGNvdW50OwogCiAJc3RybGNweShlbGV2YXRvcl9uYW1lLCBuYW1lLCBzaXplb2YoZWxldmF0b3JfbmFtZSkpOwotCXN0cnN0cmlwKGVsZXZhdG9yX25hbWUpOwotCi0JZSA9IGVsZXZhdG9yX2dldChlbGV2YXRvcl9uYW1lKTsKKwllID0gZWxldmF0b3JfZ2V0KHN0cnN0cmlwKGVsZXZhdG9yX25hbWUpKTsKIAlpZiAoIWUpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJlbGV2YXRvcjogdHlwZSAlcyBub3QgZm91bmRcbiIsIGVsZXZhdG9yX25hbWUpOwogCQlyZXR1cm4gLUVJTlZBTDsKZGlmZiAtLWdpdCBhL2Jsb2NrL2dlbmhkLmMgYi9ibG9jay9nZW5oZC5jCmluZGV4IDVhMDg2MWQuLjUxN2U0MzMgMTAwNjQ0Ci0tLSBhL2Jsb2NrL2dlbmhkLmMKKysrIGIvYmxvY2svZ2VuaGQuYwpAQCAtODY5LDYgKzg2OSw3IEBACiBzdGF0aWMgREVWSUNFX0FUVFIoYWxpZ25tZW50X29mZnNldCwgU19JUlVHTywgZGlza19hbGlnbm1lbnRfb2Zmc2V0X3Nob3csIE5VTEwpOwogc3RhdGljIERFVklDRV9BVFRSKGNhcGFiaWxpdHksIFNfSVJVR08sIGRpc2tfY2FwYWJpbGl0eV9zaG93LCBOVUxMKTsKIHN0YXRpYyBERVZJQ0VfQVRUUihzdGF0LCBTX0lSVUdPLCBwYXJ0X3N0YXRfc2hvdywgTlVMTCk7CitzdGF0aWMgREVWSUNFX0FUVFIoaW5mbGlnaHQsIFNfSVJVR08sIHBhcnRfaW5mbGlnaHRfc2hvdywgTlVMTCk7CiAjaWZkZWYgQ09ORklHX0ZBSUxfTUFLRV9SRVFVRVNUCiBzdGF0aWMgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgZGV2X2F0dHJfZmFpbCA9CiAJX19BVFRSKG1ha2UtaXQtZmFpbCwgU19JUlVHT3xTX0lXVVNSLCBwYXJ0X2ZhaWxfc2hvdywgcGFydF9mYWlsX3N0b3JlKTsKQEAgLTg4OCw2ICs4ODksNyBAQAogCSZkZXZfYXR0cl9hbGlnbm1lbnRfb2Zmc2V0LmF0dHIsCiAJJmRldl9hdHRyX2NhcGFiaWxpdHkuYXR0ciwKIAkmZGV2X2F0dHJfc3RhdC5hdHRyLAorCSZkZXZfYXR0cl9pbmZsaWdodC5hdHRyLAogI2lmZGVmIENPTkZJR19GQUlMX01BS0VfUkVRVUVTVAogCSZkZXZfYXR0cl9mYWlsLmF0dHIsCiAjZW5kaWYKQEAgLTEwNTMsNyArMTA1NSw3IEBACiAJCQkgICBwYXJ0X3N0YXRfcmVhZChoZCwgbWVyZ2VzWzFdKSwKIAkJCSAgICh1bnNpZ25lZCBsb25nIGxvbmcpcGFydF9zdGF0X3JlYWQoaGQsIHNlY3RvcnNbMV0pLAogCQkJICAgamlmZmllc190b19tc2VjcyhwYXJ0X3N0YXRfcmVhZChoZCwgdGlja3NbMV0pKSwKLQkJCSAgIGhkLT5pbl9mbGlnaHQsCisJCQkgICBwYXJ0X2luX2ZsaWdodChoZCksCiAJCQkgICBqaWZmaWVzX3RvX21zZWNzKHBhcnRfc3RhdF9yZWFkKGhkLCBpb190aWNrcykpLAogCQkJICAgamlmZmllc190b19tc2VjcyhwYXJ0X3N0YXRfcmVhZChoZCwgdGltZV9pbl9xdWV1ZSkpCiAJCQkpOwpkaWZmIC0tZ2l0IGEvY3J5cHRvL2FlYWQuYyBiL2NyeXB0by9hZWFkLmMKaW5kZXggZDlhYTczMy4uMGE1NWRhNyAxMDA2NDQKLS0tIGEvY3J5cHRvL2FlYWQuYworKysgYi9jcnlwdG8vYWVhZC5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcnRuZXRsaW5rLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL0tjb25maWcgYi9kcml2ZXJzL2FjcGkvS2NvbmZpZwppbmRleCAwZWQ0MmQ4Li45M2QyYzc5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvS2NvbmZpZworKysgYi9kcml2ZXJzL2FjcGkvS2NvbmZpZwpAQCAtMjE4LDEwICsyMTgsMTAgQEAKIAlkZXBlbmRzIG9uIFg4NgogCWhlbHAKIAkgIEFDUEkgNC4wIGRlZmluZXMgcHJvY2Vzc29yIEFnZ3JlZ2F0b3IsIHdoaWNoIGVuYWJsZXMgT1MgdG8gcGVyZm9ybQotCSAgc3BlY2ZpYyBwcm9jZXNzb3IgY29uZmlndXJhdGlvbiBhbmQgY29udHJvbCB0aGF0IGFwcGxpZXMgdG8gYWxsCisJICBzcGVjaWZpYyBwcm9jZXNzb3IgY29uZmlndXJhdGlvbiBhbmQgY29udHJvbCB0aGF0IGFwcGxpZXMgdG8gYWxsCiAJICBwcm9jZXNzb3JzIGluIHRoZSBwbGF0Zm9ybS4gQ3VycmVudGx5IG9ubHkgbG9naWNhbCBwcm9jZXNzb3IgaWRsaW5nCiAJICBpcyBkZWZpbmVkLCB3aGljaCBpcyB0byByZWR1Y2UgcG93ZXIgY29uc3VtcHRpb24uIFRoaXMgZHJpdmVyCi0JICBzdXBwb3J0IHRoZSBuZXcgZGV2aWNlLgorCSAgc3VwcG9ydHMgdGhlIG5ldyBkZXZpY2UuCiAKIGNvbmZpZyBBQ1BJX1RIRVJNQUwKIAl0cmlzdGF0ZSAiVGhlcm1hbCBab25lIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL2FjLmMgYi9kcml2ZXJzL2FjcGkvYWMuYwppbmRleCA5OGI5NjkwLi5iNmVkNjBiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvYWMuYworKysgYi9kcml2ZXJzL2FjcGkvYWMuYwpAQCAtMjQ1LDYgKzI0NSw3IEBACiAJCWFjcGlfYnVzX2dlbmVyYXRlX25ldGxpbmtfZXZlbnQoZGV2aWNlLT5wbnAuZGV2aWNlX2NsYXNzLAogCQkJCQkJICBkZXZfbmFtZSgmZGV2aWNlLT5kZXYpLCBldmVudCwKIAkJCQkJCSAgKHUzMikgYWMtPnN0YXRlKTsKKwkJYWNwaV9ub3RpZmllcl9jYWxsX2NoYWluKGRldmljZSwgZXZlbnQsICh1MzIpIGFjLT5zdGF0ZSk7CiAjaWZkZWYgQ09ORklHX0FDUElfU1lTRlNfUE9XRVIKIAkJa29iamVjdF91ZXZlbnQoJmFjLT5jaGFyZ2VyLmRldi0+a29iaiwgS09CSl9DSEFOR0UpOwogI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvYnV0dG9uLmMgYi9kcml2ZXJzL2FjcGkvYnV0dG9uLmMKaW5kZXggOTMzNWI4Ny4uMGM5YzZhOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9hY3BpL2J1dHRvbi5jCisrKyBiL2RyaXZlcnMvYWNwaS9idXR0b24uYwpAQCAtMjUxLDYgKzI1MSw5IEBACiAJYWNwaV9zdGF0dXMgc3RhdHVzOwogCXVuc2lnbmVkIGxvbmcgbG9uZyBzdGF0ZTsKIAorCWlmICghbGlkX2RldmljZSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKIAlzdGF0dXMgPSBhY3BpX2V2YWx1YXRlX2ludGVnZXIobGlkX2RldmljZS0+aGFuZGxlLCAiX0xJRCIsIE5VTEwsCiAJCQkJICAgICAgICZzdGF0ZSk7CiAJaWYgKEFDUElfRkFJTFVSRShzdGF0dXMpKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3BjaV9yb290LmMgYi9kcml2ZXJzL2FjcGkvcGNpX3Jvb3QuYwppbmRleCAzMTEyMjIxLi4xYWY4MDgxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvcGNpX3Jvb3QuYworKysgYi9kcml2ZXJzL2FjcGkvcGNpX3Jvb3QuYwpAQCAtMzg5LDYgKzM4OSwxNyBAQAogCiAJCXBidXMgPSBwZGV2LT5zdWJvcmRpbmF0ZTsKIAkJcGNpX2Rldl9wdXQocGRldik7CisKKwkJLyoKKwkJICogVGhpcyBmdW5jdGlvbiBtYXkgYmUgY2FsbGVkIGZvciBhIG5vbi1QQ0kgZGV2aWNlIHRoYXQgaGFzIGEKKwkJICogUENJIHBhcmVudCAoZWcuIGEgZGlzayB1bmRlciBhIFBDSSBTQVRBIGNvbnRyb2xsZXIpLiAgSW4gdGhhdAorCQkgKiBjYXNlIHBkZXYtPnN1Ym9yZGluYXRlIHdpbGwgYmUgTlVMTCBmb3IgdGhlIHBhcmVudC4KKwkJICovCisJCWlmICghcGJ1cykgeworCQkJZGV2X2RiZygmcGRldi0+ZGV2LCAiTm90IGEgUENJLXRvLVBDSSBicmlkZ2VcbiIpOworCQkJcGRldiA9IE5VTEw7CisJCQlicmVhazsKKwkJfQogCX0KIG91dDoKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUobm9kZSwgdG1wLCAmZGV2aWNlX2xpc3QsIG5vZGUpCmRpZmYgLS1naXQgYS9kcml2ZXJzL2FjcGkvdmlkZW8uYyBiL2RyaXZlcnMvYWNwaS92aWRlby5jCmluZGV4IGY2ZTU0YmYuLjY0ZTNjNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS92aWRlby5jCisrKyBiL2RyaXZlcnMvYWNwaS92aWRlby5jCkBAIC0xMTA5LDcgKzExMDksMTIgQEAKIAkgKi8KIAogCS8qIERvZXMgdGhpcyBkZXZpY2Ugc3VwcG9ydCB2aWRlbyBzd2l0Y2hpbmc/ICovCi0JaWYgKHZpZGVvLT5jYXAuX0RPUykgeworCWlmICh2aWRlby0+Y2FwLl9ET1MgfHwgdmlkZW8tPmNhcC5fRE9EKSB7CisJCWlmICghdmlkZW8tPmNhcC5fRE9TKSB7CisJCQlwcmludGsoS0VSTl9XQVJOSU5HIEZXX0JVRworCQkJCSJBQ1BJKCVzKSBkZWZpbmVzIF9ET0QgYnV0IG5vdCBfRE9TXG4iLAorCQkJCWFjcGlfZGV2aWNlX2JpZCh2aWRlby0+ZGV2aWNlKSk7CisJCX0KIAkJdmlkZW8tPmZsYWdzLm11bHRpaGVhZCA9IDE7CiAJCXN0YXR1cyA9IDA7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL3ZpZGVvX2RldGVjdC5jIGIvZHJpdmVycy9hY3BpL3ZpZGVvX2RldGVjdC5jCmluZGV4IDcwMzJmMjUuLjU3NTU5M2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYWNwaS92aWRlb19kZXRlY3QuYworKysgYi9kcml2ZXJzL2FjcGkvdmlkZW9fZGV0ZWN0LmMKQEAgLTg0LDcgKzg0LDcgQEAKIAkJcmV0dXJuIDA7CiAKIAkvKiBEb2VzIHRoaXMgZGV2aWNlIGFibGUgdG8gc3VwcG9ydCB2aWRlbyBzd2l0Y2hpbmcgPyAqLwotCWlmIChBQ1BJX1NVQ0NFU1MoYWNwaV9nZXRfaGFuZGxlKGRldmljZS0+aGFuZGxlLCAiX0RPRCIsICZoX2R1bW15KSkgJiYKKwlpZiAoQUNQSV9TVUNDRVNTKGFjcGlfZ2V0X2hhbmRsZShkZXZpY2UtPmhhbmRsZSwgIl9ET0QiLCAmaF9kdW1teSkpIHx8CiAJICAgIEFDUElfU1VDQ0VTUyhhY3BpX2dldF9oYW5kbGUoZGV2aWNlLT5oYW5kbGUsICJfRE9TIiwgJmhfZHVtbXkpKSkKIAkJdmlkZW9fY2FwcyB8PSBBQ1BJX1ZJREVPX09VVFBVVF9TV0lUQ0hJTkc7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL2FoY2kuYyBiL2RyaXZlcnMvYXRhL2FoY2kuYwppbmRleCA0ZWRjYTZlLi5hMDZmNWQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9haGNpLmMKKysrIGIvZHJpdmVycy9hdGEvYWhjaS5jCkBAIC01NzUsNyArNTc1LDcgQEAKIAl7IFBDSV9WREVWSUNFKEFUSSwgMHg0Mzk1KSwgYm9hcmRfYWhjaV9zYjcwMCB9LCAvKiBBVEkgU0I3MDAvODAwICovCiAKIAkvKiBBTUQgKi8KLQl7IFBDSV9WREVWSUNFKEFNRCwgMHg3ODAwKSwgYm9hcmRfYWhjaSB9LCAvKiBBTUQgU0I5MDAgKi8KKwl7IFBDSV9WREVWSUNFKEFNRCwgMHg3ODAwKSwgYm9hcmRfYWhjaSB9LCAvKiBBTUQgSHVkc29uLTIgKi8KIAkvKiBBTUQgaXMgdXNpbmcgUkFJRCBjbGFzcyBvbmx5IGZvciBhaGNpIGNvbnRyb2xsZXJzICovCiAJeyBQQ0lfVkVORE9SX0lEX0FNRCwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwgUENJX0FOWV9JRCwKIAkgIFBDSV9DTEFTU19TVE9SQUdFX1JBSUQgPDwgOCwgMHhmZmZmZmYsIGJvYXJkX2FoY2kgfSwKQEAgLTYwNSw2ICs2MDUsNyBAQAogCXsgUENJX1ZERVZJQ0UoTlZJRElBLCAweDA1NTkpLCBib2FyZF9haGNpX3llc25jcSB9LAkvKiBNQ1A2NyAqLwogCXsgUENJX1ZERVZJQ0UoTlZJRElBLCAweDA1NWEpLCBib2FyZF9haGNpX3llc25jcSB9LAkvKiBNQ1A2NyAqLwogCXsgUENJX1ZERVZJQ0UoTlZJRElBLCAweDA1NWIpLCBib2FyZF9haGNpX3llc25jcSB9LAkvKiBNQ1A2NyAqLworCXsgUENJX1ZERVZJQ0UoTlZJRElBLCAweDA1ODApLCBib2FyZF9haGNpX3llc25jcSB9LAkvKiBMaW51eCBJRCAqLwogCXsgUENJX1ZERVZJQ0UoTlZJRElBLCAweDA3ZjApLCBib2FyZF9haGNpX3llc25jcSB9LAkvKiBNQ1A3MyAqLwogCXsgUENJX1ZERVZJQ0UoTlZJRElBLCAweDA3ZjEpLCBib2FyZF9haGNpX3llc25jcSB9LAkvKiBNQ1A3MyAqLwogCXsgUENJX1ZERVZJQ0UoTlZJRElBLCAweDA3ZjIpLCBib2FyZF9haGNpX3llc25jcSB9LAkvKiBNQ1A3MyAqLwpAQCAtMjg4NCw2ICsyODg1LDcgQEAKIAlyZXR1cm4gcGRldi0+YnVzLT5udW1iZXIgPT0gKHZhbCA+PiA4KSAmJiBwZGV2LT5kZXZmbiA9PSAodmFsICYgMHhmZik7CiB9CiAKKyNpZmRlZiBDT05GSUdfQVRBX0FDUEkKIHN0YXRpYyB2b2lkIGFoY2lfZ3RmX2ZpbHRlcl93b3JrYXJvdW5kKHN0cnVjdCBhdGFfaG9zdCAqaG9zdCkKIHsKIAlzdGF0aWMgY29uc3Qgc3RydWN0IGRtaV9zeXN0ZW1faWQgc3lzaWRzW10gPSB7CkBAIC0yOTI3LDYgKzI5MjksMTAgQEAKIAkJCQlkZXYtPmd0Zl9maWx0ZXIgfD0gZmlsdGVyOwogCX0KIH0KKyNlbHNlCitzdGF0aWMgaW5saW5lIHZvaWQgYWhjaV9ndGZfZmlsdGVyX3dvcmthcm91bmQoc3RydWN0IGF0YV9ob3N0ICpob3N0KQore30KKyNlbmRpZgogCiBzdGF0aWMgaW50IGFoY2lfaW5pdF9vbmUoc3RydWN0IHBjaV9kZXYgKnBkZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICplbnQpCiB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2F0YS9saWJhdGEtY29yZS5jIGIvZHJpdmVycy9hdGEvbGliYXRhLWNvcmUuYwppbmRleCBiNTI1YTA5Li5kN2YwZjFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9saWJhdGEtY29yZS5jCisrKyBiL2RyaXZlcnMvYXRhL2xpYmF0YS1jb3JlLmMKQEAgLTUwMjgsMTIgKzUwMjgsMTQgQEAKIAkJCXFjLT5mbGFncyB8PSBBVEFfUUNGTEFHX0ZBSUxFRDsKIAogCQlpZiAodW5saWtlbHkocWMtPmZsYWdzICYgQVRBX1FDRkxBR19GQUlMRUQpKSB7Ci0JCQlpZiAoIWF0YV90YWdfaW50ZXJuYWwocWMtPnRhZykpIHsKLQkJCQkvKiBhbHdheXMgZmlsbCByZXN1bHQgVEYgZm9yIGZhaWxlZCBxYyAqLwotCQkJCWZpbGxfcmVzdWx0X3RmKHFjKTsKKwkJCS8qIGFsd2F5cyBmaWxsIHJlc3VsdCBURiBmb3IgZmFpbGVkIHFjICovCisJCQlmaWxsX3Jlc3VsdF90ZihxYyk7CisKKwkJCWlmICghYXRhX3RhZ19pbnRlcm5hbChxYy0+dGFnKSkKIAkJCQlhdGFfcWNfc2NoZWR1bGVfZWgocWMpOwotCQkJCXJldHVybjsKLQkJCX0KKwkJCWVsc2UKKwkJCQlfX2F0YV9xY19jb21wbGV0ZShxYyk7CisJCQlyZXR1cm47CiAJCX0KIAogCQlXQVJOX09OX09OQ0UoYXAtPnBmbGFncyAmIEFUQV9QRkxBR19GUk9aRU4pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvbGliYXRhLWVoLmMgYi9kcml2ZXJzL2F0YS9saWJhdGEtZWguYwppbmRleCAwYTk3ODIyLi5iYmEyYWU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9saWJhdGEtZWguYworKysgYi9kcml2ZXJzL2F0YS9saWJhdGEtZWguYwpAQCAtMjk4MSwxMiArMjk4MSwxNCBAQAogCSAqIGRldmljZSBkZXRlY3Rpb24gbWVzc2FnZXMgYmFja3dhcmRzLgogCSAqLwogCWF0YV9mb3JfZWFjaF9kZXYoZGV2LCBsaW5rLCBBTEwpIHsKLQkJaWYgKCEobmV3X21hc2sgJiAoMSA8PCBkZXYtPmRldm5vKSkgfHwKLQkJICAgIGRldi0+Y2xhc3MgPT0gQVRBX0RFVl9QTVApCisJCWlmICghKG5ld19tYXNrICYgKDEgPDwgZGV2LT5kZXZubykpKQogCQkJY29udGludWU7CiAKIAkJZGV2LT5jbGFzcyA9IGVoYy0+Y2xhc3Nlc1tkZXYtPmRldm5vXTsKIAorCQlpZiAoZGV2LT5jbGFzcyA9PSBBVEFfREVWX1BNUCkKKwkJCWNvbnRpbnVlOworCiAJCWVoYy0+aS5mbGFncyB8PSBBVEFfRUhJX1BSSU5USU5GTzsKIAkJcmMgPSBhdGFfZGV2X2NvbmZpZ3VyZShkZXYpOwogCQllaGMtPmkuZmxhZ3MgJj0gfkFUQV9FSElfUFJJTlRJTkZPOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvcGF0YV9hdGlpeHAuYyBiL2RyaXZlcnMvYXRhL3BhdGFfYXRpaXhwLmMKaW5kZXggYWE0YjNmNi4uYWU0NDU0ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9hdGEvcGF0YV9hdGlpeHAuYworKysgYi9kcml2ZXJzL2F0YS9wYXRhX2F0aWl4cC5jCkBAIC0yNDYsNyArMjQ2LDcgQEAKIAl7IFBDSV9WREVWSUNFKEFUSSwgUENJX0RFVklDRV9JRF9BVElfSVhQNDAwX0lERSksIH0sCiAJeyBQQ0lfVkRFVklDRShBVEksIFBDSV9ERVZJQ0VfSURfQVRJX0lYUDYwMF9JREUpLCB9LAogCXsgUENJX1ZERVZJQ0UoQVRJLCBQQ0lfREVWSUNFX0lEX0FUSV9JWFA3MDBfSURFKSwgfSwKLQl7IFBDSV9WREVWSUNFKEFNRCwgUENJX0RFVklDRV9JRF9BTURfU0I5MDBfSURFKSwgfSwKKwl7IFBDSV9WREVWSUNFKEFNRCwgUENJX0RFVklDRV9JRF9BTURfSFVEU09OMl9JREUpLCB9LAogCiAJeyB9LAogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL3BhdGFfc2MxMjAwLmMgYi9kcml2ZXJzL2F0YS9wYXRhX3NjMTIwMC5jCmluZGV4IGY0OTgxNGQuLjNiYmVkODMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3BhdGFfc2MxMjAwLmMKKysrIGIvZHJpdmVycy9hdGEvcGF0YV9zYzEyMDAuYwpAQCAtMjM1LDggKzIzNSw3IEBACiAJCS51ZG1hX21hc2sgPSBBVEFfVURNQTIsCiAJCS5wb3J0X29wcyA9ICZzYzEyMDBfcG9ydF9vcHMKIAl9OwotCS8qIENhbid0IGVuYWJsZSBwb3J0IDIgeWV0LCBzZWUgdG9wIGNvbW1lbnRzICovCi0JY29uc3Qgc3RydWN0IGF0YV9wb3J0X2luZm8gKnBwaVtdID0geyAmaW5mbywgfTsKKwljb25zdCBzdHJ1Y3QgYXRhX3BvcnRfaW5mbyAqcHBpW10gPSB7ICZpbmZvLCBOVUxMIH07CiAKIAlyZXR1cm4gYXRhX3BjaV9zZmZfaW5pdF9vbmUoZGV2LCBwcGksICZzYzEyMDBfc2h0LCBOVUxMKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL3BhdGFfdmlhLmMgYi9kcml2ZXJzL2F0YS9wYXRhX3ZpYS5jCmluZGV4IDQ1NjU3Y2EuLjg4OTg0YjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3BhdGFfdmlhLmMKKysrIGIvZHJpdmVycy9hdGEvcGF0YV92aWEuYwpAQCAtMTExLDcgKzExMSw3IEBACiAJeyAidnQ4MjUxIiwJUENJX0RFVklDRV9JRF9WSUFfODI1MSwgICAgIDB4MDAsIDB4MmYsIFZJQV9VRE1BXzEzMyB8IFZJQV9CQURfQVNUIH0sCiAJeyAiY3g3MDAiLAlQQ0lfREVWSUNFX0lEX1ZJQV9DWDcwMCwgICAgMHgwMCwgMHgyZiwgVklBX1VETUFfMTMzIHwgVklBX0JBRF9BU1QgfCBWSUFfU0FUQV9QQVRBIH0sCiAJeyAidnQ2NDEwIiwJUENJX0RFVklDRV9JRF9WSUFfNjQxMCwgICAgIDB4MDAsIDB4MmYsIFZJQV9VRE1BXzEzMyB8IFZJQV9CQURfQVNUIHwgVklBX05PX0VOQUJMRVMgfSwKLQl7ICJ2dDY0MTUiLAlQQ0lfREVWSUNFX0lEX1ZJQV82NDE1LCAgICAgMHgwMCwgMHgyZiwgVklBX1VETUFfMTMzIHwgVklBX0JBRF9BU1QgfCBWSUFfTk9fRU5BQkxFUyB9LAorCXsgInZ0NjQxNSIsCVBDSV9ERVZJQ0VfSURfVklBXzY0MTUsICAgICAweDAwLCAweGZmLCBWSUFfVURNQV8xMzMgfCBWSUFfQkFEX0FTVCB8IFZJQV9OT19FTkFCTEVTIH0sCiAJeyAidnQ4MjM3YSIsCVBDSV9ERVZJQ0VfSURfVklBXzgyMzdBLCAgICAweDAwLCAweDJmLCBWSUFfVURNQV8xMzMgfCBWSUFfQkFEX0FTVCB9LAogCXsgInZ0ODIzNyIsCVBDSV9ERVZJQ0VfSURfVklBXzgyMzcsICAgICAweDAwLCAweDJmLCBWSUFfVURNQV8xMzMgfCBWSUFfQkFEX0FTVCB9LAogCXsgInZ0ODIzNSIsCVBDSV9ERVZJQ0VfSURfVklBXzgyMzUsICAgICAweDAwLCAweDJmLCBWSUFfVURNQV8xMzMgfCBWSUFfQkFEX0FTVCB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9hdGEvc2F0YV9tdi5jIGIvZHJpdmVycy9hdGEvc2F0YV9tdi5jCmluZGV4IDE3ZjlmZjkuLjZmNTA5M2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYXRhL3NhdGFfbXYuYworKysgYi9kcml2ZXJzL2F0YS9zYXRhX212LmMKQEAgLTEzODIsNiArMTM4MiwyNSBAQAogCSAqLwogCWlmIChwcC0+cHBfZmxhZ3MgJiBNVl9QUF9GTEFHX0RFTEFZRURfRUgpCiAJCXJldHVybiBBVEFfREVGRVJfUE9SVDsKKworCS8qIFBJTyBjb21tYW5kcyBuZWVkIGV4Y2x1c2l2ZSBsaW5rOiBubyBvdGhlciBjb21tYW5kcyBbRE1BIG9yIFBJT10KKwkgKiBjYW4gcnVuIGNvbmN1cnJlbnRseS4KKwkgKiBzZXQgZXhjbF9saW5rIHdoZW4gd2Ugd2FudCB0byBzZW5kIGEgUElPIGNvbW1hbmQgaW4gRE1BIG1vZGUKKwkgKiBvciBhIG5vbi1OQ1EgY29tbWFuZCBpbiBOQ1EgbW9kZS4KKwkgKiBXaGVuIHdlIHJlY2VpdmUgYSBjb21tYW5kIGZyb20gdGhhdCBsaW5rLCBhbmQgdGhlcmUgYXJlIG5vCisJICogb3V0c3RhbmRpbmcgY29tbWFuZHMsIG1hcmsgYSBmbGFnIHRvIGNsZWFyIGV4Y2xfbGluayBhbmQgbGV0CisJICogdGhlIGNvbW1hbmQgZ28gdGhyb3VnaC4KKwkgKi8KKwlpZiAodW5saWtlbHkoYXAtPmV4Y2xfbGluaykpIHsKKwkJaWYgKGxpbmsgPT0gYXAtPmV4Y2xfbGluaykgeworCQkJaWYgKGFwLT5ucl9hY3RpdmVfbGlua3MpCisJCQkJcmV0dXJuIEFUQV9ERUZFUl9QT1JUOworCQkJcWMtPmZsYWdzIHw9IEFUQV9RQ0ZMQUdfQ0xFQVJfRVhDTDsKKwkJCXJldHVybiAwOworCQl9IGVsc2UKKwkJCXJldHVybiBBVEFfREVGRVJfUE9SVDsKKwl9CisKIAkvKgogCSAqIElmIHRoZSBwb3J0IGlzIGNvbXBsZXRlbHkgaWRsZSwgdGhlbiBhbGxvdyB0aGUgbmV3IHFjLgogCSAqLwpAQCAtMTM5NSw4ICsxNDE0LDE0IEBACiAJICogZG9lc24ndCBhbGxvdyBpdC4KIAkgKi8KIAlpZiAoKHBwLT5wcF9mbGFncyAmIE1WX1BQX0ZMQUdfRURNQV9FTikgJiYKLQkgICAgKHBwLT5wcF9mbGFncyAmIE1WX1BQX0ZMQUdfTkNRX0VOKSAmJiBhdGFfaXNfbmNxKHFjLT50Zi5wcm90b2NvbCkpCi0JCXJldHVybiAwOworCSAgICAocHAtPnBwX2ZsYWdzICYgTVZfUFBfRkxBR19OQ1FfRU4pKSB7CisJCWlmIChhdGFfaXNfbmNxKHFjLT50Zi5wcm90b2NvbCkpCisJCQlyZXR1cm4gMDsKKwkJZWxzZSB7CisJCQlhcC0+ZXhjbF9saW5rID0gbGluazsKKwkJCXJldHVybiBBVEFfREVGRVJfUE9SVDsKKwkJfQorCX0KIAogCXJldHVybiBBVEFfREVGRVJfUE9SVDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvYXRhL3NhdGFfbnYuYyBiL2RyaXZlcnMvYXRhL3NhdGFfbnYuYwppbmRleCA4NmE0MDU4Li4xZWI0ZTAyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2F0YS9zYXRhX252LmMKKysrIGIvZHJpdmVycy9hdGEvc2F0YV9udi5jCkBAIC0xNTk0LDkgKzE1OTQsMjEgQEAKIAkgICAgIWF0YV9kZXZfZW5hYmxlZChsaW5rLT5kZXZpY2UpKQogCQlzYXRhX2xpbmtfaGFyZHJlc2V0KGxpbmssIHNhdGFfZGViX3RpbWluZ19ob3RwbHVnLCBkZWFkbGluZSwKIAkJCQkgICAgTlVMTCwgTlVMTCk7Ci0JZWxzZSBpZiAoIShlaGMtPmkuZmxhZ3MgJiBBVEFfRUhJX1FVSUVUKSkKLQkJYXRhX2xpbmtfcHJpbnRrKGxpbmssIEtFUk5fSU5GTywKLQkJCQkibnY6IHNraXBwaW5nIGhhcmRyZXNldCBvbiBvY2N1cGllZCBwb3J0XG4iKTsKKwllbHNlIHsKKwkJY29uc3QgdW5zaWduZWQgbG9uZyAqdGltaW5nID0gc2F0YV9laGNfZGViX3RpbWluZyhlaGMpOworCQlpbnQgcmM7CisKKwkJaWYgKCEoZWhjLT5pLmZsYWdzICYgQVRBX0VISV9RVUlFVCkpCisJCQlhdGFfbGlua19wcmludGsobGluaywgS0VSTl9JTkZPLCAibnY6IHNraXBwaW5nICIKKwkJCQkJImhhcmRyZXNldCBvbiBvY2N1cGllZCBwb3J0XG4iKTsKKworCQkvKiBtYWtlIHN1cmUgdGhlIGxpbmsgaXMgb25saW5lICovCisJCXJjID0gc2F0YV9saW5rX3Jlc3VtZShsaW5rLCB0aW1pbmcsIGRlYWRsaW5lKTsKKwkJLyogd2hpbmUgYWJvdXQgcGh5IHJlc3VtZSBmYWlsdXJlIGJ1dCBwcm9jZWVkICovCisJCWlmIChyYyAmJiByYyAhPSAtRU9QTk9UU1VQUCkKKwkJCWF0YV9saW5rX3ByaW50ayhsaW5rLCBLRVJOX1dBUk5JTkcsICJmYWlsZWQgdG8gcmVzdW1lICIKKwkJCQkJImxpbmsgKGVycm5vPSVkKVxuIiwgcmMpOworCX0KIAogCS8qIGRldmljZSBzaWduYXR1cmUgYWNxdWlzaXRpb24gaXMgdW5yZWxpYWJsZSAqLwogCXJldHVybiAtRUFHQUlOOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9jY2lzcy5jIGIvZHJpdmVycy9ibG9jay9jY2lzcy5jCmluZGV4IGZiNWJlMmQuLjYzOTllNTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvYmxvY2svY2Npc3MuYworKysgYi9kcml2ZXJzL2Jsb2NrL2NjaXNzLmMKQEAgLTY4LDYgKzY4LDEyIEBACiBNT0RVTEVfVkVSU0lPTigiMy42LjIwIik7CiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiAKK3N0YXRpYyBpbnQgY2Npc3NfYWxsb3dfaHBzYTsKK21vZHVsZV9wYXJhbShjY2lzc19hbGxvd19ocHNhLCBpbnQsIFNfSVJVR098U19JV1VTUik7CitNT0RVTEVfUEFSTV9ERVNDKGNjaXNzX2FsbG93X2hwc2EsCisJIlByZXZlbnQgY2Npc3MgZHJpdmVyIGZyb20gYWNjZXNzaW5nIGhhcmR3YXJlIGtub3duIHRvIGJlICIKKwkiIHN1cHBvcnRlZCBieSB0aGUgaHBzYSBkcml2ZXIiKTsKKwogI2luY2x1ZGUgImNjaXNzX2NtZC5oIgogI2luY2x1ZGUgImNjaXNzLmgiCiAjaW5jbHVkZSA8bGludXgvY2Npc3NfaW9jdGwuaD4KQEAgLTEwMSw4ICsxMDcsNiBAQAogCXtQQ0lfVkVORE9SX0lEX0hQLCAgICAgUENJX0RFVklDRV9JRF9IUF9DSVNTRSwgICAgIDB4MTAzQywgMHgzMjQ5fSwKIAl7UENJX1ZFTkRPUl9JRF9IUCwgICAgIFBDSV9ERVZJQ0VfSURfSFBfQ0lTU0UsICAgICAweDEwM0MsIDB4MzI0QX0sCiAJe1BDSV9WRU5ET1JfSURfSFAsICAgICBQQ0lfREVWSUNFX0lEX0hQX0NJU1NFLCAgICAgMHgxMDNDLCAweDMyNEJ9LAotCXtQQ0lfVkVORE9SX0lEX0hQLCAgICAgUENJX0FOWV9JRCwJUENJX0FOWV9JRCwgUENJX0FOWV9JRCwKLQkJUENJX0NMQVNTX1NUT1JBR0VfUkFJRCA8PCA4LCAweGZmZmYgPDwgOCwgMH0sCiAJezAsfQogfTsKIApAQCAtMTIzLDggKzEyNyw2IEBACiAJezB4NDA5RDBFMTEsICJTbWFydCBBcnJheSA2NDAwIEVNIiwgJlNBNV9hY2Nlc3N9LAogCXsweDQwOTEwRTExLCAiU21hcnQgQXJyYXkgNmkiLCAmU0E1X2FjY2Vzc30sCiAJezB4MzIyNTEwM0MsICJTbWFydCBBcnJheSBQNjAwIiwgJlNBNV9hY2Nlc3N9LAotCXsweDMyMjMxMDNDLCAiU21hcnQgQXJyYXkgUDgwMCIsICZTQTVfYWNjZXNzfSwKLQl7MHgzMjM0MTAzQywgIlNtYXJ0IEFycmF5IFA0MDAiLCAmU0E1X2FjY2Vzc30sCiAJezB4MzIzNTEwM0MsICJTbWFydCBBcnJheSBQNDAwaSIsICZTQTVfYWNjZXNzfSwKIAl7MHgzMjExMTAzQywgIlNtYXJ0IEFycmF5IEUyMDBpIiwgJlNBNV9hY2Nlc3N9LAogCXsweDMyMTIxMDNDLCAiU21hcnQgQXJyYXkgRTIwMCIsICZTQTVfYWNjZXNzfSwKQEAgLTEzMiw2ICsxMzQsMTAgQEAKIAl7MHgzMjE0MTAzQywgIlNtYXJ0IEFycmF5IEUyMDBpIiwgJlNBNV9hY2Nlc3N9LAogCXsweDMyMTUxMDNDLCAiU21hcnQgQXJyYXkgRTIwMGkiLCAmU0E1X2FjY2Vzc30sCiAJezB4MzIzNzEwM0MsICJTbWFydCBBcnJheSBFNTAwIiwgJlNBNV9hY2Nlc3N9LAorLyogY29udHJvbGxlcnMgYmVsb3cgdGhpcyBsaW5lIGFyZSBhbHNvIHN1cHBvcnRlZCBieSB0aGUgaHBzYSBkcml2ZXIuICovCisjZGVmaW5lIEhQU0FfQk9VTkRBUlkgMHgzMjIzMTAzQworCXsweDMyMjMxMDNDLCAiU21hcnQgQXJyYXkgUDgwMCIsICZTQTVfYWNjZXNzfSwKKwl7MHgzMjM0MTAzQywgIlNtYXJ0IEFycmF5IFA0MDAiLCAmU0E1X2FjY2Vzc30sCiAJezB4MzIzRDEwM0MsICJTbWFydCBBcnJheSBQNzAwbSIsICZTQTVfYWNjZXNzfSwKIAl7MHgzMjQxMTAzQywgIlNtYXJ0IEFycmF5IFAyMTIiLCAmU0E1X2FjY2Vzc30sCiAJezB4MzI0MzEwM0MsICJTbWFydCBBcnJheSBQNDEwIiwgJlNBNV9hY2Nlc3N9LApAQCAtMTQwLDcgKzE0Niw2IEBACiAJezB4MzI0OTEwM0MsICJTbWFydCBBcnJheSBQODEyIiwgJlNBNV9hY2Nlc3N9LAogCXsweDMyNEExMDNDLCAiU21hcnQgQXJyYXkgUDcxMm0iLCAmU0E1X2FjY2Vzc30sCiAJezB4MzI0QjEwM0MsICJTbWFydCBBcnJheSBQNzExbSIsICZTQTVfYWNjZXNzfSwKLQl7MHhGRkZGMTAzQywgIlVua25vd24gU21hcnQgQXJyYXkiLCAmU0E1X2FjY2Vzc30sCiB9OwogCiAvKiBIb3cgbG9uZyB0byB3YWl0IChpbiBtaWxsaXNlY29uZHMpIGZvciBib2FyZCB0byBnbyBpbnRvIHNpbXBsZSBtb2RlICovCkBAIC0zNzU0LDcgKzM3NTksMjcgQEAKIAlfX3U2NCBjZmdfb2Zmc2V0OwogCV9fdTMyIGNmZ19iYXNlX2FkZHI7CiAJX191NjQgY2ZnX2Jhc2VfYWRkcl9pbmRleDsKLQlpbnQgaSwgZXJyOworCWludCBpLCBwcm9kX2luZGV4LCBlcnI7CisKKwlzdWJzeXN0ZW1fdmVuZG9yX2lkID0gcGRldi0+c3Vic3lzdGVtX3ZlbmRvcjsKKwlzdWJzeXN0ZW1fZGV2aWNlX2lkID0gcGRldi0+c3Vic3lzdGVtX2RldmljZTsKKwlib2FyZF9pZCA9ICgoKF9fdTMyKSAoc3Vic3lzdGVtX2RldmljZV9pZCA8PCAxNikgJiAweGZmZmYwMDAwKSB8CisJCSAgICBzdWJzeXN0ZW1fdmVuZG9yX2lkKTsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHByb2R1Y3RzKTsgaSsrKSB7CisJCS8qIFN0YW5kIGFzaWRlIGZvciBocHNhIGRyaXZlciBvbiByZXF1ZXN0ICovCisJCWlmIChjY2lzc19hbGxvd19ocHNhICYmIHByb2R1Y3RzW2ldLmJvYXJkX2lkID09IEhQU0FfQk9VTkRBUlkpCisJCQlyZXR1cm4gLUVOT0RFVjsKKwkJaWYgKGJvYXJkX2lkID09IHByb2R1Y3RzW2ldLmJvYXJkX2lkKQorCQkJYnJlYWs7CisJfQorCXByb2RfaW5kZXggPSBpOworCWlmIChwcm9kX2luZGV4ID09IEFSUkFZX1NJWkUocHJvZHVjdHMpKSB7CisJCWRldl93YXJuKCZwZGV2LT5kZXYsCisJCQkidW5yZWNvZ25pemVkIGJvYXJkIElEOiAweCUwOGx4LCBpZ25vcmluZy5cbiIsCisJCQkodW5zaWduZWQgbG9uZykgYm9hcmRfaWQpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CiAKIAkvKiBjaGVjayB0byBzZWUgaWYgY29udHJvbGxlciBoYXMgYmVlbiBkaXNhYmxlZCAqLwogCS8qIEJFRk9SRSB0cnlpbmcgdG8gZW5hYmxlIGl0ICovCkBAIC0zNzc4LDExICszODAzLDYgQEAKIAkJcmV0dXJuIGVycjsKIAl9CiAKLQlzdWJzeXN0ZW1fdmVuZG9yX2lkID0gcGRldi0+c3Vic3lzdGVtX3ZlbmRvcjsKLQlzdWJzeXN0ZW1fZGV2aWNlX2lkID0gcGRldi0+c3Vic3lzdGVtX2RldmljZTsKLQlib2FyZF9pZCA9ICgoKF9fdTMyKSAoc3Vic3lzdGVtX2RldmljZV9pZCA8PCAxNikgJiAweGZmZmYwMDAwKSB8Ci0JCSAgICBzdWJzeXN0ZW1fdmVuZG9yX2lkKTsKLQogI2lmZGVmIENDSVNTX0RFQlVHCiAJcHJpbnRrKCJjb21tYW5kID0gJXhcbiIsIGNvbW1hbmQpOwogCXByaW50aygiaXJxID0gJXhcbiIsIHBkZXYtPmlycSk7CkBAIC0zODY4LDE0ICszODg4LDkgQEAKIAkgKiBsZWF2ZSBhIGxpdHRsZSByb29tIGZvciBpb2N0bCBjYWxscy4KIAkgKi8KIAljLT5tYXhfY29tbWFuZHMgPSByZWFkbCgmKGMtPmNmZ3RhYmxlLT5DbWRzT3V0TWF4KSk7Ci0JZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUocHJvZHVjdHMpOyBpKyspIHsKLQkJaWYgKGJvYXJkX2lkID09IHByb2R1Y3RzW2ldLmJvYXJkX2lkKSB7Ci0JCQljLT5wcm9kdWN0X25hbWUgPSBwcm9kdWN0c1tpXS5wcm9kdWN0X25hbWU7Ci0JCQljLT5hY2Nlc3MgPSAqKHByb2R1Y3RzW2ldLmFjY2Vzcyk7Ci0JCQljLT5ucl9jbWRzID0gYy0+bWF4X2NvbW1hbmRzIC0gNDsKLQkJCWJyZWFrOwotCQl9Ci0JfQorCWMtPnByb2R1Y3RfbmFtZSA9IHByb2R1Y3RzW3Byb2RfaW5kZXhdLnByb2R1Y3RfbmFtZTsKKwljLT5hY2Nlc3MgPSAqKHByb2R1Y3RzW3Byb2RfaW5kZXhdLmFjY2Vzcyk7CisJYy0+bnJfY21kcyA9IGMtPm1heF9jb21tYW5kcyAtIDQ7CiAJaWYgKChyZWFkYigmYy0+Y2ZndGFibGUtPlNpZ25hdHVyZVswXSkgIT0gJ0MnKSB8fAogCSAgICAocmVhZGIoJmMtPmNmZ3RhYmxlLT5TaWduYXR1cmVbMV0pICE9ICdJJykgfHwKIAkgICAgKHJlYWRiKCZjLT5jZmd0YWJsZS0+U2lnbmF0dXJlWzJdKSAhPSAnUycpIHx8CkBAIC0zODg0LDI3ICszODk5LDYgQEAKIAkJZXJyID0gLUVOT0RFVjsKIAkJZ290byBlcnJfb3V0X2ZyZWVfcmVzOwogCX0KLQkvKiBXZSBkaWRuJ3QgZmluZCB0aGUgY29udHJvbGxlciBpbiBvdXIgbGlzdC4gV2Uga25vdyB0aGUKLQkgKiBzaWduYXR1cmUgaXMgdmFsaWQuIElmIGl0J3MgYW4gSFAgZGV2aWNlIGxldCdzIHRyeSB0bwotCSAqIGJpbmQgdG8gdGhlIGRldmljZSBhbmQgZmlyZSBpdCB1cC4gT3RoZXJ3aXNlIHdlIGJhaWwuCi0JICovCi0JaWYgKGkgPT0gQVJSQVlfU0laRShwcm9kdWN0cykpIHsKLQkJaWYgKHN1YnN5c3RlbV92ZW5kb3JfaWQgPT0gUENJX1ZFTkRPUl9JRF9IUCkgewotCQkJYy0+cHJvZHVjdF9uYW1lID0gcHJvZHVjdHNbaS0xXS5wcm9kdWN0X25hbWU7Ci0JCQljLT5hY2Nlc3MgPSAqKHByb2R1Y3RzW2ktMV0uYWNjZXNzKTsKLQkJCWMtPm5yX2NtZHMgPSBjLT5tYXhfY29tbWFuZHMgLSA0OwotCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiY2Npc3M6IFRoaXMgaXMgYW4gdW5rbm93biAiCi0JCQkJIlNtYXJ0IEFycmF5IGNvbnRyb2xsZXIuXG4iCi0JCQkJImNjaXNzOiBQbGVhc2UgdXBkYXRlIHRvIHRoZSBsYXRlc3QgZHJpdmVyICIKLQkJCQkiYXZhaWxhYmxlIGZyb20gd3d3LmhwLmNvbS5cbiIpOwotCQl9IGVsc2UgewotCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiY2Npc3M6IFNvcnJ5LCBJIGRvbid0IGtub3cgaG93IgotCQkJCSIgdG8gYWNjZXNzIHRoZSBTbWFydCBBcnJheSBjb250cm9sbGVyICUwOGx4XG4iCi0JCQkJCSwgKHVuc2lnbmVkIGxvbmcpYm9hcmRfaWQpOwotCQkJZXJyID0gLUVOT0RFVjsKLQkJCWdvdG8gZXJyX291dF9mcmVlX3JlczsKLQkJfQotCX0KICNpZmRlZiBDT05GSUdfWDg2CiAJewogCQkvKiBOZWVkIHRvIGVuYWJsZSBwcmVmZXRjaCBpbiB0aGUgU0NTSSBjb3JlIGZvciA2NDAwIGluIHg4NiAqLwpAQCAtNDI1NCw3ICs0MjQ4LDcgQEAKIAltdXRleF9pbml0KCZoYmFbaV0tPmJ1c3lfc2h1dHRpbmdfZG93bik7CiAKIAlpZiAoY2Npc3NfcGNpX2luaXQoaGJhW2ldLCBwZGV2KSAhPSAwKQotCQlnb3RvIGNsZWFuMDsKKwkJZ290byBjbGVhbl9ub19yZWxlYXNlX3JlZ2lvbnM7CiAKIAlzcHJpbnRmKGhiYVtpXS0+ZGV2bmFtZSwgImNjaXNzJWQiLCBpKTsKIAloYmFbaV0tPmN0bHIgPSBpOwpAQCAtNDM5MSwxMyArNDM4NSwxNCBAQAogY2xlYW4xOgogCWNjaXNzX2Rlc3Ryb3lfaGJhX3N5c2ZzX2VudHJ5KGhiYVtpXSk7CiBjbGVhbjA6CisJcGNpX3JlbGVhc2VfcmVnaW9ucyhwZGV2KTsKK2NsZWFuX25vX3JlbGVhc2VfcmVnaW9uczoKIAloYmFbaV0tPmJ1c3lfaW5pdGlhbGl6aW5nID0gMDsKIAogCS8qCiAJICogRGVsaWJlcmF0ZWx5IG9taXQgcGNpX2Rpc2FibGVfZGV2aWNlKCk6IGl0IGRvZXMgc29tZXRoaW5nIG5hc3R5IHRvCiAJICogU21hcnQgQXJyYXkgY29udHJvbGxlcnMgdGhhdCBwY2lfZW5hYmxlX2RldmljZSBkb2VzIG5vdCB1bmRvCiAJICovCi0JcGNpX3JlbGVhc2VfcmVnaW9ucyhwZGV2KTsKIAlwY2lfc2V0X2RydmRhdGEocGRldiwgTlVMTCk7CiAJZnJlZV9oYmEoaSk7CiAJcmV0dXJuIC0xOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay9sb29wLmMgYi9kcml2ZXJzL2Jsb2NrL2xvb3AuYwppbmRleCBlZGRhOWVhLi5iZDExMmM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL2xvb3AuYworKysgYi9kcml2ZXJzL2Jsb2NrL2xvb3AuYwpAQCAtOTQ5LDcgKzk0OSw3IEBACiAJbG8tPmxvX3N0YXRlID0gTG9fdW5ib3VuZDsKIAkvKiBUaGlzIGlzIHNhZmU6IG9wZW4oKSBpcyBzdGlsbCBob2xkaW5nIGEgcmVmZXJlbmNlLiAqLwogCW1vZHVsZV9wdXQoVEhJU19NT0RVTEUpOwotCWlmIChtYXhfcGFydCA+IDApCisJaWYgKG1heF9wYXJ0ID4gMCAmJiBiZGV2KQogCQlpb2N0bF9ieV9iZGV2KGJkZXYsIEJMS1JSUEFSVCwgMCk7CiAJbXV0ZXhfdW5sb2NrKCZsby0+bG9fY3RsX211dGV4KTsKIAkvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ibG9jay92aXJ0aW9fYmxrLmMgYi9kcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYwppbmRleCA0M2YxOTM4Li41MTA0MmYwYmE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYworKysgYi9kcml2ZXJzL2Jsb2NrL3ZpcnRpb19ibGsuYwpAQCAtMyw3ICszLDYgQEAKICNpbmNsdWRlIDxsaW51eC9ibGtkZXYuaD4KICNpbmNsdWRlIDxsaW51eC9oZHJlZy5oPgogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpby5oPgotI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19pZHMuaD4KICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fYmxrLmg+CiAjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxpc3QuaD4KIApAQCAtMTgzLDM0ICsxODIsNiBAQAogCQl2YmxrLT52cS0+dnFfb3BzLT5raWNrKHZibGstPnZxKTsKIH0KIAotLyogcmV0dXJuIEFUQSBpZGVudGlmeSBkYXRhCi0gKi8KLXN0YXRpYyBpbnQgdmlydGJsa19pZGVudGlmeShzdHJ1Y3QgZ2VuZGlzayAqZGlzaywgdm9pZCAqYXJncCkKLXsKLQlzdHJ1Y3QgdmlydGlvX2JsayAqdmJsayA9IGRpc2stPnByaXZhdGVfZGF0YTsKLQl2b2lkICpvcGFxdWU7Ci0JaW50IGVyciA9IC1FTk9NRU07Ci0KLQlvcGFxdWUgPSBrbWFsbG9jKFZJUlRJT19CTEtfSURfQllURVMsIEdGUF9LRVJORUwpOwotCWlmICghb3BhcXVlKQotCQlnb3RvIG91dDsKLQotCWVyciA9IHZpcnRpb19jb25maWdfYnVmKHZibGstPnZkZXYsIFZJUlRJT19CTEtfRl9JREVOVElGWSwKLQkJb2Zmc2V0b2Yoc3RydWN0IHZpcnRpb19ibGtfY29uZmlnLCBpZGVudGlmeSksIG9wYXF1ZSwKLQkJVklSVElPX0JMS19JRF9CWVRFUyk7Ci0KLQlpZiAoZXJyKQotCQlnb3RvIG91dF9rZnJlZTsKLQotCWlmIChjb3B5X3RvX3VzZXIoYXJncCwgb3BhcXVlLCBWSVJUSU9fQkxLX0lEX0JZVEVTKSkKLQkJZXJyID0gLUVGQVVMVDsKLQotb3V0X2tmcmVlOgotCWtmcmVlKG9wYXF1ZSk7Ci1vdXQ6Ci0JcmV0dXJuIGVycjsKLX0KLQogc3RhdGljIHZvaWQgdmlydGJsa19wcmVwYXJlX2ZsdXNoKHN0cnVjdCByZXF1ZXN0X3F1ZXVlICpxLCBzdHJ1Y3QgcmVxdWVzdCAqcmVxKQogewogCXJlcS0+Y21kX3R5cGUgPSBSRVFfVFlQRV9MSU5VWF9CTE9DSzsKQEAgLTIyMiwxMCArMTkzLDYgQEAKIHsKIAlzdHJ1Y3QgZ2VuZGlzayAqZGlzayA9IGJkZXYtPmJkX2Rpc2s7CiAJc3RydWN0IHZpcnRpb19ibGsgKnZibGsgPSBkaXNrLT5wcml2YXRlX2RhdGE7Ci0Jdm9pZCBfX3VzZXIgKmFyZ3AgPSAodm9pZCBfX3VzZXIgKilkYXRhOwotCi0JaWYgKGNtZCA9PSBIRElPX0dFVF9JREVOVElUWSkKLQkJcmV0dXJuIHZpcnRibGtfaWRlbnRpZnkoZGlzaywgYXJncCk7CiAKIAkvKgogCSAqIE9ubHkgYWxsb3cgdGhlIGdlbmVyaWMgU0NTSSBpb2N0bHMgaWYgdGhlIGhvc3QgY2FuIHN1cHBvcnQgaXQuCkBAIC0yMzMsNyArMjAwLDggQEAKIAlpZiAoIXZpcnRpb19oYXNfZmVhdHVyZSh2YmxrLT52ZGV2LCBWSVJUSU9fQkxLX0ZfU0NTSSkpCiAJCXJldHVybiAtRU5PVFRZOwogCi0JcmV0dXJuIHNjc2lfY21kX2lvY3RsKGRpc2stPnF1ZXVlLCBkaXNrLCBtb2RlLCBjbWQsIGFyZ3ApOworCXJldHVybiBzY3NpX2NtZF9pb2N0bChkaXNrLT5xdWV1ZSwgZGlzaywgbW9kZSwgY21kLAorCQkJICAgICAgKHZvaWQgX191c2VyICopZGF0YSk7CiB9CiAKIC8qIFdlIHByb3ZpZGUgZ2V0Z2VvIG9ubHkgdG8gcGxlYXNlIHNvbWUgb2xkIGJvb3Rsb2FkZXIvcGFydGl0aW9uaW5nIHRvb2xzICovCkBAIC0zMzIsNyArMzAwLDYgQEAKIAl9CiAKIAl2YmxrLT5kaXNrLT5xdWV1ZS0+cXVldWVkYXRhID0gdmJsazsKLQlxdWV1ZV9mbGFnX3NldF91bmxvY2tlZChRVUVVRV9GTEFHX1ZJUlQsIHZibGstPmRpc2stPnF1ZXVlKTsKIAogCWlmIChpbmRleCA8IDI2KSB7CiAJCXNwcmludGYodmJsay0+ZGlzay0+ZGlza19uYW1lLCAidmQlYyIsICdhJyArIGluZGV4ICUgMjYpOwpAQCAtNDQ1LDcgKzQxMiw3IEBACiBzdGF0aWMgdW5zaWduZWQgaW50IGZlYXR1cmVzW10gPSB7CiAJVklSVElPX0JMS19GX0JBUlJJRVIsIFZJUlRJT19CTEtfRl9TRUdfTUFYLCBWSVJUSU9fQkxLX0ZfU0laRV9NQVgsCiAJVklSVElPX0JMS19GX0dFT01FVFJZLCBWSVJUSU9fQkxLX0ZfUk8sIFZJUlRJT19CTEtfRl9CTEtfU0laRSwKLQlWSVJUSU9fQkxLX0ZfU0NTSSwgVklSVElPX0JMS19GX0lERU5USUZZLCBWSVJUSU9fQkxLX0ZfRkxVU0gKKwlWSVJUSU9fQkxLX0ZfU0NTSSwgVklSVElPX0JMS19GX0ZMVVNICiB9OwogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2FwcGxpY29tLmMgYi9kcml2ZXJzL2NoYXIvYXBwbGljb20uYwppbmRleCA3M2EwNzY1Li5mZTJjYjJmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvYXBwbGljb20uYworKysgYi9kcml2ZXJzL2NoYXIvYXBwbGljb20uYwpAQCAtMjMsNiArMjMsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiAjaW5jbHVkZSA8bGludXgvbWlzY2RldmljZS5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL2VwY2EuYyBiL2RyaXZlcnMvY2hhci9lcGNhLmMKaW5kZXggOWQ1ODllMy4uZGRlNTEzNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2VwY2EuYworKysgYi9kcml2ZXJzL2NoYXIvZXBjYS5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zZXJpYWwuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvZ2VuZXJpY19zZXJpYWwuYyBiL2RyaXZlcnMvY2hhci9nZW5lcmljX3NlcmlhbC5jCmluZGV4IDllNGU1NjkuLmQ0MDBjYmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9nZW5lcmljX3NlcmlhbC5jCisrKyBiL2RyaXZlcnMvY2hhci9nZW5lcmljX3NlcmlhbC5jCkBAIC0yMiw2ICsyMiw3IEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvdHR5Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zZXJpYWwuaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxpbnV4L2dlbmVyaWNfc2VyaWFsLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvZ2VucnRjLmMgYi9kcml2ZXJzL2NoYXIvZ2VucnRjLmMKaW5kZXggYWFjMDk4NS4uMzFlN2M5MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2dlbnJ0Yy5jCisrKyBiL2RyaXZlcnMvY2hhci9nZW5ydGMuYwpAQCAtNDMsNiArNDMsNyBAQAogI2RlZmluZSBSVENfVkVSU0lPTgkiMS4wNyIKIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KICNpbmNsdWRlIDxsaW51eC9taXNjZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvZmNudGwuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9od19yYW5kb20vdmlydGlvLXJuZy5jIGIvZHJpdmVycy9jaGFyL2h3X3JhbmRvbS92aXJ0aW8tcm5nLmMKaW5kZXggOTYyOTY4Zi4uOTE1MTU3ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2h3X3JhbmRvbS92aXJ0aW8tcm5nLmMKKysrIGIvZHJpdmVycy9jaGFyL2h3X3JhbmRvbS92aXJ0aW8tcm5nLmMKQEAgLTIxLDcgKzIxLDYgQEAKICNpbmNsdWRlIDxsaW51eC9zY2F0dGVybGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvLmg+Ci0jaW5jbHVkZSA8bGludXgvdmlydGlvX2lkcy5oPgogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19ybmcuaD4KIAogLyogVGhlIGhvc3Qgd2lsbCBmaWxsIGFueSBidWZmZXIgd2UgZ2l2ZSBpdCB3aXRoIHN3ZWV0LCBzd2VldCByYW5kb21uZXNzLiAgV2UKQEAgLTExNyw3ICsxMTYsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCB2aXJ0cm5nX3JlbW92ZShzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldikKK3N0YXRpYyB2b2lkIF9fZGV2ZXhpdCB2aXJ0cm5nX3JlbW92ZShzdHJ1Y3QgdmlydGlvX2RldmljZSAqdmRldikKIHsKIAl2ZGV2LT5jb25maWctPnJlc2V0KHZkZXYpOwogCWh3cm5nX3VucmVnaXN0ZXIoJnZpcnRpb19od3JuZyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvaXN0YWxsaW9uLmMgYi9kcml2ZXJzL2NoYXIvaXN0YWxsaW9uLmMKaW5kZXggYWIyZjMzNC4uNDAyODM4ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL2lzdGFsbGlvbi5jCisrKyBiL2RyaXZlcnMvY2hhci9pc3RhbGxpb24uYwpAQCAtMTksNiArMTksNyBAQAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9ub3pvbWkuYyBiL2RyaXZlcnMvY2hhci9ub3pvbWkuYwppbmRleCBlYzU4ZDhjLi5kMzQwMGIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvbm96b21pLmMKKysrIGIvZHJpdmVycy9jaGFyL25vem9taS5jCkBAIC00OCw2ICs0OCw3IEBACiAjaW5jbHVkZSA8bGludXgvdHR5Lmg+CiAjaW5jbHVkZSA8bGludXgvdHR5X2RyaXZlci5oPgogI2luY2x1ZGUgPGxpbnV4L3R0eV9mbGlwLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zZXJpYWwuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9rbW9kLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvcHR5LmMgYi9kcml2ZXJzL2NoYXIvcHR5LmMKaW5kZXggZTA2NmM0Zi4uNjJmMjgyZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3B0eS5jCisrKyBiL2RyaXZlcnMvY2hhci9wdHkuYwpAQCAtMTgsNiArMTgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3R0eS5oPgogI2luY2x1ZGUgPGxpbnV4L3R0eV9mbGlwLmg+CiAjaW5jbHVkZSA8bGludXgvZmNudGwuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L21ham9yLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9yaW8vcmlvY21kLmMgYi9kcml2ZXJzL2NoYXIvcmlvL3Jpb2NtZC5jCmluZGV4IDAxZjI2NTQuLmYxMjEzNTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9yaW8vcmlvY21kLmMKKysrIGIvZHJpdmVycy9jaGFyL3Jpby9yaW9jbWQuYwpAQCAtMzIsNiArMzIsNyBAQAogKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiAjaW5jbHVkZSA8bGludXgvdHR5Lmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvcmlvL3Jpb2N0cmwuYyBiL2RyaXZlcnMvY2hhci9yaW8vcmlvY3RybC5jCmluZGV4IDc0MzM5NTUuLjc4MDUwNjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9yaW8vcmlvY3RybC5jCisrKyBiL2RyaXZlcnMvY2hhci9yaW8vcmlvY3RybC5jCkBAIC0zMSw2ICszMSw3IEBACiAqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KICNpbmNsdWRlIDxhc20vaW8uaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9yaW8vcmlvdHR5LmMgYi9kcml2ZXJzL2NoYXIvcmlvL3Jpb3R0eS5jCmluZGV4IDJmYjQ5ZTguLjQ3ZmFiN2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9yaW8vcmlvdHR5LmMKKysrIGIvZHJpdmVycy9jaGFyL3Jpby9yaW90dHkuYwpAQCAtMzMsNiArMzMsNyBAQAogI2RlZmluZSBfX0VYUExJQ0lUX0RFRl9IX18KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiAjaW5jbHVkZSA8bGludXgvdHR5Lmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvcnRjLmMgYi9kcml2ZXJzL2NoYXIvcnRjLmMKaW5kZXggZTBkMGY4Yi4uYmM0YWIzZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3J0Yy5jCisrKyBiL2RyaXZlcnMvY2hhci9ydGMuYwpAQCAtNzQsNiArNzQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zeXNjdGwuaD4KICNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CiAjaW5jbHVkZSA8bGludXgvYmNkLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvc2VyX2EyMjMyLmMgYi9kcml2ZXJzL2NoYXIvc2VyX2EyMjMyLmMKaW5kZXggMzNhMmI1My4uOTYxMDg2MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3Nlcl9hMjIzMi5jCisrKyBiL2RyaXZlcnMvY2hhci9zZXJfYTIyMzIuYwpAQCAtODksNiArODksNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC90dHkuaD4KIAogI2luY2x1ZGUgPGFzbS9zZXR1cC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL3NvbnlwaS5jIGIvZHJpdmVycy9jaGFyL3NvbnlwaS5jCmluZGV4IGZkM2RjZWQuLjhjMjYyYWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci9zb255cGkuYworKysgYi9kcml2ZXJzL2NoYXIvc29ueXBpLmMKQEAgLTM2LDYgKzM2LDcgQEAKICAqLwogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9pbnB1dC5oPgogI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci9zdGFsbGlvbi5jIGIvZHJpdmVycy9jaGFyL3N0YWxsaW9uLmMKaW5kZXggNTNlNTA0Zi4uZGI2ZGNmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3N0YWxsaW9uLmMKKysrIGIvZHJpdmVycy9jaGFyL3N0YWxsaW9uLmMKQEAgLTI3LDYgKzI3LDcgQEAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L3R0eS5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL3RsY2xrLmMgYi9kcml2ZXJzL2NoYXIvdGxjbGsuYwppbmRleCA4ZjIyODRiLi44MGVhNmJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2NoYXIvdGxjbGsuYworKysgYi9kcml2ZXJzL2NoYXIvdGxjbGsuYwpAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgkvKiBwcmludGsoKSAqLwogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CQkvKiBldmVyeXRoaW5nLi4uICovCiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4JLyogZXJyb3IgY29kZXMgKi8KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9pb3BvcnQuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci90cG0vdHBtLmMgYi9kcml2ZXJzL2NoYXIvdHBtL3RwbS5jCmluZGV4IDQ1ZDU4MDAuLjQ3YzJkMjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci90cG0vdHBtLmMKKysrIGIvZHJpdmVycy9jaGFyL3RwbS90cG0uYwpAQCAtNjk2LDggKzY5Niw3IEBACiAKIAljbWQuaGVhZGVyLmluID0gcGNycmVhZF9oZWFkZXI7CiAJY21kLnBhcmFtcy5wY3JyZWFkX2luLnBjcl9pZHggPSBjcHVfdG9fYmUzMihwY3JfaWR4KTsKLQlCVUdfT04oY21kLmhlYWRlci5pbi5sZW5ndGggPiBSRUFEX1BDUl9SRVNVTFRfU0laRSk7Ci0JcmMgPSB0cmFuc21pdF9jbWQoY2hpcCwgJmNtZCwgY21kLmhlYWRlci5pbi5sZW5ndGgsCisJcmMgPSB0cmFuc21pdF9jbWQoY2hpcCwgJmNtZCwgUkVBRF9QQ1JfUkVTVUxUX1NJWkUsCiAJCQkgICJhdHRlbXB0aW5nIHRvIHJlYWQgYSBwY3IgdmFsdWUiKTsKIAogCWlmIChyYyA9PSAwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jaGFyL3R0eV9idWZmZXIuYyBiL2RyaXZlcnMvY2hhci90dHlfYnVmZmVyLmMKaW5kZXggMzEwODk5MS4uNjZmYTRlMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3R0eV9idWZmZXIuYworKysgYi9kcml2ZXJzL2NoYXIvdHR5X2J1ZmZlci5jCkBAIC00MDIsMjggKzQwMiwyNiBAQAogCQljb250YWluZXJfb2Yod29yaywgc3RydWN0IHR0eV9zdHJ1Y3QsIGJ1Zi53b3JrLndvcmspOwogCXVuc2lnbmVkIGxvbmcgCWZsYWdzOwogCXN0cnVjdCB0dHlfbGRpc2MgKmRpc2M7Ci0Jc3RydWN0IHR0eV9idWZmZXIgKnRidWYsICpoZWFkOwotCWNoYXIgKmNoYXJfYnVmOwotCXVuc2lnbmVkIGNoYXIgKmZsYWdfYnVmOwogCiAJZGlzYyA9IHR0eV9sZGlzY19yZWYodHR5KTsKIAlpZiAoZGlzYyA9PSBOVUxMKQkvKiAgIVRUWV9MRElTQyAqLwogCQlyZXR1cm47CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmdHR5LT5idWYubG9jaywgZmxhZ3MpOwotCS8qIFNvIHdlIGtub3cgYSBmbHVzaCBpcyBydW5uaW5nICovCi0Jc2V0X2JpdChUVFlfRkxVU0hJTkcsICZ0dHktPmZsYWdzKTsKLQloZWFkID0gdHR5LT5idWYuaGVhZDsKLQlpZiAoaGVhZCAhPSBOVUxMKSB7Ci0JCXR0eS0+YnVmLmhlYWQgPSBOVUxMOwotCQlmb3IgKDs7KSB7Ci0JCQlpbnQgY291bnQgPSBoZWFkLT5jb21taXQgLSBoZWFkLT5yZWFkOworCisJaWYgKCF0ZXN0X2FuZF9zZXRfYml0KFRUWV9GTFVTSElORywgJnR0eS0+ZmxhZ3MpKSB7CisJCXN0cnVjdCB0dHlfYnVmZmVyICpoZWFkOworCQl3aGlsZSAoKGhlYWQgPSB0dHktPmJ1Zi5oZWFkKSAhPSBOVUxMKSB7CisJCQlpbnQgY291bnQ7CisJCQljaGFyICpjaGFyX2J1ZjsKKwkJCXVuc2lnbmVkIGNoYXIgKmZsYWdfYnVmOworCisJCQljb3VudCA9IGhlYWQtPmNvbW1pdCAtIGhlYWQtPnJlYWQ7CiAJCQlpZiAoIWNvdW50KSB7CiAJCQkJaWYgKGhlYWQtPm5leHQgPT0gTlVMTCkKIAkJCQkJYnJlYWs7Ci0JCQkJdGJ1ZiA9IGhlYWQ7Ci0JCQkJaGVhZCA9IGhlYWQtPm5leHQ7Ci0JCQkJdHR5X2J1ZmZlcl9mcmVlKHR0eSwgdGJ1Zik7CisJCQkJdHR5LT5idWYuaGVhZCA9IGhlYWQtPm5leHQ7CisJCQkJdHR5X2J1ZmZlcl9mcmVlKHR0eSwgaGVhZCk7CiAJCQkJY29udGludWU7CiAJCQl9CiAJCQkvKiBMZGlzYyBvciB1c2VyIGlzIHRyeWluZyB0byBmbHVzaCB0aGUgYnVmZmVycwpAQCAtNDQ1LDkgKzQ0Myw5IEBACiAJCQkJCQkJZmxhZ19idWYsIGNvdW50KTsKIAkJCXNwaW5fbG9ja19pcnFzYXZlKCZ0dHktPmJ1Zi5sb2NrLCBmbGFncyk7CiAJCX0KLQkJLyogUmVzdG9yZSB0aGUgcXVldWUgaGVhZCAqLwotCQl0dHktPmJ1Zi5oZWFkID0gaGVhZDsKKwkJY2xlYXJfYml0KFRUWV9GTFVTSElORywgJnR0eS0+ZmxhZ3MpOwogCX0KKwogCS8qIFdlIG1heSBoYXZlIGEgZGVmZXJyZWQgcmVxdWVzdCB0byBmbHVzaCB0aGUgaW5wdXQgYnVmZmVyLAogCSAgIGlmIHNvIHB1bGwgdGhlIGNoYWluIHVuZGVyIHRoZSBsb2NrIGFuZCBlbXB0eSB0aGUgcXVldWUgKi8KIAlpZiAodGVzdF9iaXQoVFRZX0ZMVVNIUEVORElORywgJnR0eS0+ZmxhZ3MpKSB7CkBAIC00NTUsNyArNDUzLDYgQEAKIAkJY2xlYXJfYml0KFRUWV9GTFVTSFBFTkRJTkcsICZ0dHktPmZsYWdzKTsKIAkJd2FrZV91cCgmdHR5LT5yZWFkX3dhaXQpOwogCX0KLQljbGVhcl9iaXQoVFRZX0ZMVVNISU5HLCAmdHR5LT5mbGFncyk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmdHR5LT5idWYubG9jaywgZmxhZ3MpOwogCiAJdHR5X2xkaXNjX2RlcmVmKGRpc2MpOwpAQCAtNDcxLDcgKzQ2OCw3IEBACiAgKi8KIHZvaWQgdHR5X2ZsdXNoX3RvX2xkaXNjKHN0cnVjdCB0dHlfc3RydWN0ICp0dHkpCiB7Ci0JZmx1c2hfdG9fbGRpc2MoJnR0eS0+YnVmLndvcmsud29yayk7CisJZmx1c2hfZGVsYXllZF93b3JrKCZ0dHktPmJ1Zi53b3JrKTsKIH0KIAogLyoqCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NoYXIvdmlydGlvX2NvbnNvbGUuYyBiL2RyaXZlcnMvY2hhci92aXJ0aW9fY29uc29sZS5jCmluZGV4IDBkMzI4YjUuLmEwMzVhZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2hhci92aXJ0aW9fY29uc29sZS5jCisrKyBiL2RyaXZlcnMvY2hhci92aXJ0aW9fY29uc29sZS5jCkBAIC0zMSw3ICszMSw2IEBACiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpby5oPgotI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19pZHMuaD4KICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fY29uc29sZS5oPgogI2luY2x1ZGUgImh2Y19jb25zb2xlLmgiCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY2hhci92dF9pb2N0bC5jIGIvZHJpdmVycy9jaGFyL3Z0X2lvY3RsLmMKaW5kZXggNmIzNmVlNS4uZWQ4NmQzYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9jaGFyL3Z0X2lvY3RsLmMKKysrIGIvZHJpdmVycy9jaGFyL3Z0X2lvY3RsLmMKQEAgLTE1MzIsNyArMTUzMiw3IEBACiAKIAljYXNlIFBJT19VTklNQVA6CiAJY2FzZSBHSU9fVU5JTUFQOgotCQlyZXQgPSBkb191bmltYXBfaW9jdGwoY21kLCB1cCwgcGVybSwgdmMpOworCQlyZXQgPSBjb21wYXRfdW5pbWFwX2lvY3RsKGNtZCwgdXAsIHBlcm0sIHZjKTsKIAkJYnJlYWs7CiAKIAkvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jcHVpZGxlL2NwdWlkbGUuYyBiL2RyaXZlcnMvY3B1aWRsZS9jcHVpZGxlLmMKaW5kZXggYWQ0MWYxOS4uMTJmZGQzOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9jcHVpZGxlL2NwdWlkbGUuYworKysgYi9kcml2ZXJzL2NwdWlkbGUvY3B1aWRsZS5jCkBAIC03Niw4ICs3NiwxMSBAQAogI2VuZGlmCiAJLyogYXNrIHRoZSBnb3Zlcm5vciBmb3IgdGhlIG5leHQgc3RhdGUgKi8KIAluZXh0X3N0YXRlID0gY3B1aWRsZV9jdXJyX2dvdmVybm9yLT5zZWxlY3QoZGV2KTsKLQlpZiAobmVlZF9yZXNjaGVkKCkpCisJaWYgKG5lZWRfcmVzY2hlZCgpKSB7CisJCWxvY2FsX2lycV9lbmFibGUoKTsKIAkJcmV0dXJuOworCX0KKwogCXRhcmdldF9zdGF0ZSA9ICZkZXYtPnN0YXRlc1tuZXh0X3N0YXRlXTsKIAogCS8qIGVudGVyIHRoZSBzdGF0ZSBhbmQgdXBkYXRlIHN0YXRzICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL2NyeXB0by9wYWRsb2NrLXNoYS5jIGIvZHJpdmVycy9jcnlwdG8vcGFkbG9jay1zaGEuYwppbmRleCA3NmNiNmIzLi4wYWY4MDU3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2NyeXB0by9wYWRsb2NrLXNoYS5jCisrKyBiL2RyaXZlcnMvY3J5cHRvL3BhZGxvY2stc2hhLmMKQEAgLTI0LDYgKzI0LDEyIEBACiAjaW5jbHVkZSA8YXNtL2kzODcuaD4KICNpbmNsdWRlICJwYWRsb2NrLmgiCiAKKyNpZmRlZiBDT05GSUdfNjRCSVQKKyNkZWZpbmUgU1RBQ0tfQUxJR04gMTYKKyNlbHNlCisjZGVmaW5lIFNUQUNLX0FMSUdOIDQKKyNlbmRpZgorCiBzdHJ1Y3QgcGFkbG9ja19zaGFfZGVzYyB7CiAJc3RydWN0IHNoYXNoX2Rlc2MgZmFsbGJhY2s7CiB9OwpAQCAtNjQsNyArNzAsOSBAQAogCS8qIFdlIGNhbid0IHN0b3JlIGRpcmVjdGx5IHRvICpvdXQgYXMgaXQgbWF5IGJlIHVuYWxpZ25lZC4gKi8KIAkvKiBCVFcgRG9uJ3QgcmVkdWNlIHRoZSBidWZmZXIgc2l6ZSBiZWxvdyAxMjggQnl0ZXMhCiAJICogICAgIFBhZExvY2sgbWljcm9jb2RlIG5lZWRzIGl0IHRoYXQgYmlnLiAqLwotCWNoYXIgcmVzdWx0WzEyOF0gX19hdHRyaWJ1dGVfXyAoKGFsaWduZWQoUEFETE9DS19BTElHTk1FTlQpKSk7CisJY2hhciBidWZbMTI4ICsgUEFETE9DS19BTElHTk1FTlQgLSBTVEFDS19BTElHTl0gX19hdHRyaWJ1dGVfXworCQkoKGFsaWduZWQoU1RBQ0tfQUxJR04pKSk7CisJY2hhciAqcmVzdWx0ID0gUFRSX0FMSUdOKCZidWZbMF0sIFBBRExPQ0tfQUxJR05NRU5UKTsKIAlzdHJ1Y3QgcGFkbG9ja19zaGFfZGVzYyAqZGN0eCA9IHNoYXNoX2Rlc2NfY3R4KGRlc2MpOwogCXN0cnVjdCBzaGExX3N0YXRlIHN0YXRlOwogCXVuc2lnbmVkIGludCBzcGFjZTsKQEAgLTEyOCw3ICsxMzYsOSBAQAogCS8qIFdlIGNhbid0IHN0b3JlIGRpcmVjdGx5IHRvICpvdXQgYXMgaXQgbWF5IGJlIHVuYWxpZ25lZC4gKi8KIAkvKiBCVFcgRG9uJ3QgcmVkdWNlIHRoZSBidWZmZXIgc2l6ZSBiZWxvdyAxMjggQnl0ZXMhCiAJICogICAgIFBhZExvY2sgbWljcm9jb2RlIG5lZWRzIGl0IHRoYXQgYmlnLiAqLwotCWNoYXIgcmVzdWx0WzEyOF0gX19hdHRyaWJ1dGVfXyAoKGFsaWduZWQoUEFETE9DS19BTElHTk1FTlQpKSk7CisJY2hhciBidWZbMTI4ICsgUEFETE9DS19BTElHTk1FTlQgLSBTVEFDS19BTElHTl0gX19hdHRyaWJ1dGVfXworCQkoKGFsaWduZWQoU1RBQ0tfQUxJR04pKSk7CisJY2hhciAqcmVzdWx0ID0gUFRSX0FMSUdOKCZidWZbMF0sIFBBRExPQ0tfQUxJR05NRU5UKTsKIAlzdHJ1Y3QgcGFkbG9ja19zaGFfZGVzYyAqZGN0eCA9IHNoYXNoX2Rlc2NfY3R4KGRlc2MpOwogCXN0cnVjdCBzaGEyNTZfc3RhdGUgc3RhdGU7CiAJdW5zaWduZWQgaW50IHNwYWNlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9lZGFjL2FtZDY0X2VkYWMuYyBiL2RyaXZlcnMvZWRhYy9hbWQ2NF9lZGFjLmMKaW5kZXggNGY0YWM4Mi4uZDQ1NjBkOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL2FtZDY0X2VkYWMuYworKysgYi9kcml2ZXJzL2VkYWMvYW1kNjRfZWRhYy5jCkBAIC0xMTIyLDcgKzExMjIsNyBAQAogCQlkZWJ1Z2YwKCJSZWFkaW5nIEs4X0RSQU1fQkFTRV9MT1cgZmFpbGVkXG4iKTsKIAogCS8qIEV4dHJhY3QgcGFydHMgaW50byBzZXBhcmF0ZSBkYXRhIGVudHJpZXMgKi8KLQlwdnQtPmRyYW1fYmFzZVtkcmFtXSA9ICgodTY0KSBsb3cgJiAweEZGRkYwMDAwKSA8PCAyNDsKKwlwdnQtPmRyYW1fYmFzZVtkcmFtXSA9ICgodTY0KSBsb3cgJiAweEZGRkYwMDAwKSA8PCA4OwogCXB2dC0+ZHJhbV9JbnRsdkVuW2RyYW1dID0gKGxvdyA+PiA4KSAmIDB4NzsKIAlwdnQtPmRyYW1fcndfZW5bZHJhbV0gPSAobG93ICYgMHgzKTsKIApAQCAtMTEzNSw3ICsxMTM1LDcgQEAKIAkgKiBFeHRyYWN0IHBhcnRzIGludG8gc2VwYXJhdGUgZGF0YSBlbnRyaWVzLiBMaW1pdCBpcyB0aGUgSElHSEVTVCBtZW1vcnkKIAkgKiBsb2NhdGlvbiBvZiB0aGUgcmVnaW9uLCBzbyBsb3dlciAyNCBiaXRzIG5lZWQgdG8gYmUgYWxsIG9uZXMKIAkgKi8KLQlwdnQtPmRyYW1fbGltaXRbZHJhbV0gPSAoKCh1NjQpIGxvdyAmIDB4RkZGRjAwMDApIDw8IDI0KSB8IDB4MDBGRkZGRkY7CisJcHZ0LT5kcmFtX2xpbWl0W2RyYW1dID0gKCgodTY0KSBsb3cgJiAweEZGRkYwMDAwKSA8PCA4KSB8IDB4MDBGRkZGRkY7CiAJcHZ0LT5kcmFtX0ludGx2U2VsW2RyYW1dID0gKGxvdyA+PiA4KSAmIDB4NzsKIAlwdnQtPmRyYW1fRHN0Tm9kZVtkcmFtXSA9IChsb3cgJiAweDcpOwogfQpAQCAtMTM2OSw3ICsxMzY5LDcgQEAKIAlwdnQtPmRyYW1fSW50bHZFbltkcmFtXSA9IChsb3dfYmFzZSA+PiA4KSAmIDB4NzsKIAogCXB2dC0+ZHJhbV9iYXNlW2RyYW1dID0gKCgodTY0KWhpZ2hfYmFzZSAmIDB4MDAwMDAwRkYpIDw8IDQwKSB8Ci0JCQkgICAgICAgKCgodTY0KWxvd19iYXNlICAmIDB4RkZGRjAwMDApIDw8IDI0KTsKKwkJCSAgICAgICAoKCh1NjQpbG93X2Jhc2UgICYgMHhGRkZGMDAwMCkgPDwgOCk7CiAKIAlsb3dfb2Zmc2V0ID0gSzhfRFJBTV9MSU1JVF9MT1cgKyAoZHJhbSA8PCAzKTsKIAloaWdoX29mZnNldCA9IEYxMF9EUkFNX0xJTUlUX0hJR0ggKyAoZHJhbSA8PCAzKTsKQEAgLTEzOTEsNyArMTM5MSw3IEBACiAJICogbWVtb3J5IGxvY2F0aW9uIG9mIHRoZSByZWdpb24sIHNvIGxvdyAyNCBiaXRzIG5lZWQgdG8gYmUgYWxsIG9uZXMuCiAJICovCiAJcHZ0LT5kcmFtX2xpbWl0W2RyYW1dID0gKCgodTY0KWhpZ2hfbGltaXQgJiAweDAwMDAwMEZGKSA8PCA0MCkgfAotCQkJCSgoKHU2NCkgbG93X2xpbWl0ICYgMHhGRkZGMDAwMCkgPDwgMjQpIHwKKwkJCQkoKCh1NjQpIGxvd19saW1pdCAmIDB4RkZGRjAwMDApIDw8IDgpIHwKIAkJCQkweDAwRkZGRkZGOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvaTUwMDBfZWRhYy5jIGIvZHJpdmVycy9lZGFjL2k1MDAwX2VkYWMuYwppbmRleCBkMzM1MDg2Li43N2E5NTc5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2VkYWMvaTUwMDBfZWRhYy5jCisrKyBiL2RyaXZlcnMvZWRhYy9pNTAwMF9lZGFjLmMKQEAgLTExNzMsNyArMTE3Myw3IEBACiAJCQlwY2lfcmVhZF9jb25maWdfd29yZChwdnQtPmJyYW5jaF8xLCB3aGVyZSwKIAkJCQkJJnB2dC0+YjFfbXRyW3Nsb3Rfcm93XSk7CiAJCQlkZWJ1Z2YyKCJNVFIlZCB3aGVyZT0weCV4IEIxIHZhbHVlPTB4JXhcbiIsIHNsb3Rfcm93LAotCQkJCXdoZXJlLCBwdnQtPmIwX210cltzbG90X3Jvd10pOworCQkJCXdoZXJlLCBwdnQtPmIxX210cltzbG90X3Jvd10pOwogCQl9IGVsc2UgewogCQkJcHZ0LT5iMV9tdHJbc2xvdF9yb3ddID0gMDsKIAkJfQpAQCAtMTIzMiw3ICsxMjMyLDcgQEAKIAlzdHJ1Y3QgY3Nyb3dfaW5mbyAqcF9jc3JvdzsKIAlpbnQgZW1wdHksIGNoYW5uZWxfY291bnQ7CiAJaW50IG1heF9jc3Jvd3M7Ci0JaW50IG10cjsKKwlpbnQgbXRyLCBtdHIxOwogCWludCBjc3Jvd19tZWdzOwogCWludCBjaGFubmVsOwogCWludCBjc3JvdzsKQEAgLTEyNTEsOSArMTI1MSwxMCBAQAogCiAJCS8qIHVzZSBicmFuY2ggMCBmb3IgdGhlIGJhc2lzICovCiAJCW10ciA9IHB2dC0+YjBfbXRyW2Nzcm93ID4+IDFdOworCQltdHIxID0gcHZ0LT5iMV9tdHJbY3Nyb3cgPj4gMV07CiAKIAkJLyogaWYgbm8gRElNTVMgb24gdGhpcyByb3csIGNvbnRpbnVlICovCi0JCWlmICghTVRSX0RJTU1TX1BSRVNFTlQobXRyKSkKKwkJaWYgKCFNVFJfRElNTVNfUFJFU0VOVChtdHIpICYmICFNVFJfRElNTVNfUFJFU0VOVChtdHIxKSkKIAkJCWNvbnRpbnVlOwogCiAJCS8qIEZBS0UgT1VUIFZBTFVFUywgRklYTUUgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvZWRhYy9pNTQwMF9lZGFjLmMgYi9kcml2ZXJzL2VkYWMvaTU0MDBfZWRhYy5jCmluZGV4IGIwOGI2ZDguLmY5OWQxMDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZWRhYy9pNTQwMF9lZGFjLmMKKysrIGIvZHJpdmVycy9lZGFjL2k1NDAwX2VkYWMuYwpAQCAtNDYsOSArNDYsMTAgQEAKIC8qIExpbWl0cyBmb3IgaTU0MDAgKi8KICNkZWZpbmUgTlVNX01UUlNfUEVSX0JSQU5DSAk0CiAjZGVmaW5lIENIQU5ORUxTX1BFUl9CUkFOQ0gJMgorI2RlZmluZSBNQVhfRElNTVNfUEVSX0NIQU5ORUwJTlVNX01UUlNfUEVSX0JSQU5DSAogI2RlZmluZQlNQVhfQ0hBTk5FTFMJCTQKLSNkZWZpbmUgTUFYX0RJTU1TCQkoTUFYX0NIQU5ORUxTICogNCkJLyogVXAgdG8gNCBESU1NJ3MgcGVyIGNoYW5uZWwgKi8KLSNkZWZpbmUgTUFYX0NTUk9XUwkJKE1BWF9ESU1NUyAqIDIpCQkvKiBtYXggcG9zc2libGUgY3Nyb3dzIHBlciBjaGFubmVsICovCisvKiBtYXggcG9zc2libGUgY3Nyb3dzIHBlciBjaGFubmVsICovCisjZGVmaW5lIE1BWF9DU1JPV1MJCShNQVhfRElNTVNfUEVSX0NIQU5ORUwpCiAKIC8qIERldmljZSAxNiwKICAqIEZ1bmN0aW9uIDA6IFN5c3RlbSBBZGRyZXNzCkBAIC0zMzEsNyArMzMyLDYgQEAKIAogc3RydWN0IGk1NDAwX2RpbW1faW5mbyB7CiAJaW50IG1lZ2FieXRlczsJCS8qIHNpemUsIDAgbWVhbnMgbm90IHByZXNlbnQgICovCi0JaW50IGR1YWxfcmFuazsKIH07CiAKIC8qIGRyaXZlciBwcml2YXRlIGRhdGEgc3RydWN0dXJlICovCkBAIC04NDksMTEgKzg0OSw5IEBACiAJaW50IG47CiAKIAkvKiBUaGVyZSBpcyBvbmUgTVRSIGZvciBlYWNoIHNsb3QgcGFpciBvZiBGQi1ESU1NcywKLQkgICBFYWNoIHNsb3QgbWF5IGhhdmUgb25lIG9yIHR3byByYW5rcyAoMiBjc3Jvd3MpLAogCSAgIEVhY2ggc2xvdCBwYWlyIG1heSBiZSBhdCBicmFuY2ggMCBvciBicmFuY2ggMS4KLQkgICBTbywgY3Nyb3cgc2hvdWxkIGJlIGRpdmlkZWQgYnkgZWlnaHQKIAkgKi8KLQluID0gY3Nyb3cgPj4gMzsKKwluID0gY3Nyb3c7CiAKIAlpZiAobiA+PSBOVU1fTVRSU19QRVJfQlJBTkNIKSB7CiAJCWRlYnVnZjAoIkVSUk9SOiB0cnlpbmcgdG8gYWNjZXNzIGFuIGludmFsaWQgY3Nyb3c6ICVkXG4iLApAQCAtOTA1LDI1ICs5MDMsMjIgQEAKIAkJYW1iX3ByZXNlbnRfcmVnID0gZGV0ZXJtaW5lX2FtYl9wcmVzZW50X3JlZyhwdnQsIGNoYW5uZWwpOwogCiAJCS8qIERldGVybWluZSBpZiB0aGVyZSBpcyBhIERJTU0gcHJlc2VudCBpbiB0aGlzIERJTU0gc2xvdCAqLwotCQlpZiAoYW1iX3ByZXNlbnRfcmVnICYgKDEgPDwgKGNzcm93ID4+IDEpKSkgewotCQkJZGluZm8tPmR1YWxfcmFuayA9IE1UUl9ESU1NX1JBTksobXRyKTsKKwkJaWYgKGFtYl9wcmVzZW50X3JlZyAmICgxIDw8IGNzcm93KSkgeworCQkJLyogU3RhcnQgd2l0aCB0aGUgbnVtYmVyIG9mIGJpdHMgZm9yIGEgQmFuaworCQkJICogb24gdGhlIERSQU0gKi8KKwkJCWFkZHJCaXRzID0gTVRSX0RSQU1fQkFOS1NfQUREUl9CSVRTKG10cik7CisJCQkvKiBBZGQgdGhlbnVtYmVyIG9mIFJPVyBiaXRzICovCisJCQlhZGRyQml0cyArPSBNVFJfRElNTV9ST1dTX0FERFJfQklUUyhtdHIpOworCQkJLyogYWRkIHRoZSBudW1iZXIgb2YgQ09MVU1OIGJpdHMgKi8KKwkJCWFkZHJCaXRzICs9IE1UUl9ESU1NX0NPTFNfQUREUl9CSVRTKG10cik7CisJCQkvKiBhZGQgdGhlIG51bWJlciBvZiBSQU5LIGJpdHMgKi8KKwkJCWFkZHJCaXRzICs9IE1UUl9ESU1NX1JBTksobXRyKTsKIAotCQkJaWYgKCEoKGRpbmZvLT5kdWFsX3JhbmsgPT0gMCkgJiYKLQkJCQkoKGNzcm93ICYgMHgxKSA9PSAweDEpKSkgewotCQkJCS8qIFN0YXJ0IHdpdGggdGhlIG51bWJlciBvZiBiaXRzIGZvciBhIEJhbmsKLQkJCQkgKiBvbiB0aGUgRFJBTSAqLwotCQkJCWFkZHJCaXRzID0gTVRSX0RSQU1fQkFOS1NfQUREUl9CSVRTKG10cik7Ci0JCQkJLyogQWRkIHRoZW51bWJlciBvZiBST1cgYml0cyAqLwotCQkJCWFkZHJCaXRzICs9IE1UUl9ESU1NX1JPV1NfQUREUl9CSVRTKG10cik7Ci0JCQkJLyogYWRkIHRoZSBudW1iZXIgb2YgQ09MVU1OIGJpdHMgKi8KLQkJCQlhZGRyQml0cyArPSBNVFJfRElNTV9DT0xTX0FERFJfQklUUyhtdHIpOworCQkJYWRkckJpdHMgKz0gNjsJLyogYWRkIDY0IGJpdHMgcGVyIERJTU0gKi8KKwkJCWFkZHJCaXRzIC09IDIwOwkvKiBkaXZpZGUgYnkgMl5eMjAgKi8KKwkJCWFkZHJCaXRzIC09IDM7CS8qIDggYml0cyBwZXIgYnl0ZXMgKi8KIAotCQkJCWFkZHJCaXRzICs9IDY7CS8qIGFkZCA2NCBiaXRzIHBlciBESU1NICovCi0JCQkJYWRkckJpdHMgLT0gMjA7CS8qIGRpdmlkZSBieSAyXl4yMCAqLwotCQkJCWFkZHJCaXRzIC09IDM7CS8qIDggYml0cyBwZXIgYnl0ZXMgKi8KLQotCQkJCWRpbmZvLT5tZWdhYnl0ZXMgPSAxIDw8IGFkZHJCaXRzOwotCQkJfQorCQkJZGluZm8tPm1lZ2FieXRlcyA9IDEgPDwgYWRkckJpdHM7CiAJCX0KIAl9CiB9CkBAIC05NTEsMTIgKzk0NiwxMiBAQAogCQlyZXR1cm47CiAJfQogCi0JLyogU2NhbiBhbGwgdGhlIGFjdHVhbCBDU1JPV1MgKHdoaWNoIGlzICMgb2YgRElNTVMgKiAyKQorCS8qIFNjYW4gYWxsIHRoZSBhY3R1YWwgQ1NST1dTCiAJICogYW5kIGNhbGN1bGF0ZSB0aGUgaW5mb3JtYXRpb24gZm9yIGVhY2ggRElNTQogCSAqIFN0YXJ0IHdpdGggdGhlIGhpZ2hlc3QgY3Nyb3cgZmlyc3QsIHRvIGRpc3BsYXkgaXQgZmlyc3QKIAkgKiBhbmQgd29yayB0b3dhcmQgdGhlIDB0aCBjc3JvdwogCSAqLwotCW1heF9jc3Jvd3MgPSBwdnQtPm1heGRpbW1wZXJjaCAqIDI7CisJbWF4X2Nzcm93cyA9IHB2dC0+bWF4ZGltbXBlcmNoOwogCWZvciAoY3Nyb3cgPSBtYXhfY3Nyb3dzIC0gMTsgY3Nyb3cgPj0gMDsgY3Nyb3ctLSkgewogCiAJCS8qIG9uIGFuIG9kZCBjc3JvdywgZmlyc3Qgb3V0cHV0IGEgJ2JvdW5kYXJ5JyBtYXJrZXIsCkBAIC0xMDY0LDcgKzEwNTksNyBAQAogCiAJLyogR2V0IHRoZSBzZXQgb2YgTVRSWzAtM10gcmVncyBieSBlYWNoIGJyYW5jaCAqLwogCWZvciAoc2xvdF9yb3cgPSAwOyBzbG90X3JvdyA8IE5VTV9NVFJTX1BFUl9CUkFOQ0g7IHNsb3Rfcm93KyspIHsKLQkJaW50IHdoZXJlID0gTVRSMCArIChzbG90X3JvdyAqIHNpemVvZih1MzIpKTsKKwkJaW50IHdoZXJlID0gTVRSMCArIChzbG90X3JvdyAqIHNpemVvZih1MTYpKTsKIAogCQkvKiBCcmFuY2ggMCBzZXQgb2YgTVRSIHJlZ2lzdGVycyAqLwogCQlwY2lfcmVhZF9jb25maWdfd29yZChwdnQtPmJyYW5jaF8wLCB3aGVyZSwKQEAgLTExNDYsNyArMTE0MSw3IEBACiAJcHZ0ID0gbWNpLT5wdnRfaW5mbzsKIAogCWNoYW5uZWxfY291bnQgPSBwdnQtPm1heGNoOwotCW1heF9jc3Jvd3MgPSBwdnQtPm1heGRpbW1wZXJjaCAqIDI7CisJbWF4X2Nzcm93cyA9IHB2dC0+bWF4ZGltbXBlcmNoOwogCiAJZW1wdHkgPSAxOwkJLyogQXNzdW1lIE5PIG1lbW9yeSAqLwogCkBAIC0xMjE1LDI4ICsxMjEwLDYgQEAKIH0KIAogLyoKLSAqIGk1NDAwX2dldF9kaW1tX2FuZF9jaGFubmVsX2NvdW50cyhwZGV2LCAmbnVtX2Nzcm93cywgJm51bV9jaGFubmVscykKLSAqCi0gKglhc2sgdGhlIGRldmljZSBob3cgbWFueSBjaGFubmVscyBhcmUgcHJlc2VudCBhbmQgaG93IG1hbnkgQ1NST1dTCi0gKgkgYXMgd2VsbAotICovCi1zdGF0aWMgdm9pZCBpNTQwMF9nZXRfZGltbV9hbmRfY2hhbm5lbF9jb3VudHMoc3RydWN0IHBjaV9kZXYgKnBkZXYsCi0JCQkJCWludCAqbnVtX2RpbW1zX3Blcl9jaGFubmVsLAotCQkJCQlpbnQgKm51bV9jaGFubmVscykKLXsKLQl1OCB2YWx1ZTsKLQotCS8qIE5lZWQgdG8gcmV0cmlldmUganVzdCBob3cgbWFueSBjaGFubmVscyBhbmQgZGltbXMgcGVyIGNoYW5uZWwgYXJlCi0JICogc3VwcG9ydGVkIG9uIHRoaXMgbWVtb3J5IGNvbnRyb2xsZXIKLQkgKi8KLQlwY2lfcmVhZF9jb25maWdfYnl0ZShwZGV2LCBNQVhESU1NUEVSQ0gsICZ2YWx1ZSk7Ci0JKm51bV9kaW1tc19wZXJfY2hhbm5lbCA9IChpbnQpdmFsdWUgKiAyOwotCi0JcGNpX3JlYWRfY29uZmlnX2J5dGUocGRldiwgTUFYQ0gsICZ2YWx1ZSk7Ci0JKm51bV9jaGFubmVscyA9IChpbnQpdmFsdWU7Ci19Ci0KLS8qCiAgKglpNTQwMF9wcm9iZTEJUHJvYmUgZm9yIE9ORSBpbnN0YW5jZSBvZiBkZXZpY2UgdG8gc2VlIGlmIGl0IGlzCiAgKgkJCXByZXNlbnQuCiAgKglyZXR1cm46CkBAIC0xMjYzLDIyICsxMjM2LDE2IEBACiAJaWYgKFBDSV9GVU5DKHBkZXYtPmRldmZuKSAhPSAwKQogCQlyZXR1cm4gLUVOT0RFVjsKIAotCS8qIEFzayB0aGUgZGV2aWNlcyBmb3IgdGhlIG51bWJlciBvZiBDU1JPV1MgYW5kIENIQU5ORUxTIHNvCi0JICogdGhhdCB3ZSBjYW4gY2FsY3VsYXRlIHRoZSBtZW1vcnkgcmVzb3VyY2VzLCBldGMKLQkgKgotCSAqIFRoZSBDaGlwc2V0IHdpbGwgcmVwb3J0IHdoYXQgaXQgY2FuIGhhbmRsZSB3aGljaCB3aWxsIGJlIGdyZWF0ZXIKLQkgKiBvciBlcXVhbCB0byB3aGF0IHRoZSBtb3RoZXJib2FyZCBtYW51ZmFjdHVyZXIgd2lsbCBpbXBsZW1lbnQuCi0JICoKLQkgKiBBcyB3ZSBkb24ndCBoYXZlIGEgbW90aGVyYm9hcmQgaWRlbnRpZmljYXRpb24gcm91dGluZSB0byBkZXRlcm1pbmUKKwkvKiBBcyB3ZSBkb24ndCBoYXZlIGEgbW90aGVyYm9hcmQgaWRlbnRpZmljYXRpb24gcm91dGluZSB0byBkZXRlcm1pbmUKIAkgKiBhY3R1YWwgbnVtYmVyIG9mIHNsb3RzL2RpbW1zIHBlciBjaGFubmVsLCB3ZSB0aHVzIHV0aWxpemUgdGhlCiAJICogcmVzb3VyY2UgYXMgc3BlY2lmaWVkIGJ5IHRoZSBjaGlwc2V0LiBUaHVzLCB3ZSBtaWdodCBoYXZlCiAJICogaGF2ZSBtb3JlIERJTU1zIHBlciBjaGFubmVsIHRoYW4gYWN0dWFsbHkgb24gdGhlIG1vYm8sIGJ1dCB0aGlzCiAJICogYWxsb3dzIHRoZSBkcml2ZXIgdG8gc3VwcG9ydCB1cHRvIHRoZSBjaGlwc2V0IG1heCwgd2l0aG91dAogCSAqIHNvbWUgZmFuY3kgbW9ibyBkZXRlcm1pbmF0aW9uLgogCSAqLwotCWk1NDAwX2dldF9kaW1tX2FuZF9jaGFubmVsX2NvdW50cyhwZGV2LCAmbnVtX2RpbW1zX3Blcl9jaGFubmVsLAotCQkJCQkmbnVtX2NoYW5uZWxzKTsKLQludW1fY3Nyb3dzID0gbnVtX2RpbW1zX3Blcl9jaGFubmVsICogMjsKKwludW1fZGltbXNfcGVyX2NoYW5uZWwgPSBNQVhfRElNTVNfUEVSX0NIQU5ORUw7CisJbnVtX2NoYW5uZWxzID0gTUFYX0NIQU5ORUxTOworCW51bV9jc3Jvd3MgPSBudW1fZGltbXNfcGVyX2NoYW5uZWw7CiAKIAlkZWJ1Z2YwKCJNQzogJXMoKTogTnVtYmVyIG9mIC0gQ2hhbm5lbHM9ICVkICBESU1NUz0gJWQgIENTUk9XUz0gJWRcbiIsCiAJCV9fZnVuY19fLCBudW1fY2hhbm5lbHMsIG51bV9kaW1tc19wZXJfY2hhbm5lbCwgbnVtX2Nzcm93cyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2VkYWMvbXBjODV4eF9lZGFjLmMgYi9kcml2ZXJzL2VkYWMvbXBjODV4eF9lZGFjLmMKaW5kZXggMTU3ZjY1MC4uY2YyNzQwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9lZGFjL21wYzg1eHhfZWRhYy5jCisrKyBiL2RyaXZlcnMvZWRhYy9tcGM4NXh4X2VkYWMuYwpAQCAtMjYsNyArMjYsOSBAQAogI2luY2x1ZGUgIm1wYzg1eHhfZWRhYy5oIgogCiBzdGF0aWMgaW50IGVkYWNfZGV2X2lkeDsKKyNpZmRlZiBDT05GSUdfUENJCiBzdGF0aWMgaW50IGVkYWNfcGNpX2lkeDsKKyNlbmRpZgogc3RhdGljIGludCBlZGFjX21jX2lkeDsKIAogc3RhdGljIHUzMiBvcmlnX2Rkcl9lcnJfZGlzYWJsZTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZmlyZXdpcmUvc2JwMi5jIGIvZHJpdmVycy9maXJld2lyZS9zYnAyLmMKaW5kZXggNTBmMDE3Ni4uOThkYmJkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9maXJld2lyZS9zYnAyLmMKKysrIGIvZHJpdmVycy9maXJld2lyZS9zYnAyLmMKQEAgLTE4OCwxNCArMTg4LDcgQEAKIC8qIEltcG9zc2libGUgbG9naW5faWQsIHRvIGRldGVjdCBsb2dvdXQgYXR0ZW1wdCBiZWZvcmUgc3VjY2Vzc2Z1bCBsb2dpbiAqLwogI2RlZmluZSBJTlZBTElEX0xPR0lOX0lEIDB4MTAwMDAKIAotLyoKLSAqIFBlciBzZWN0aW9uIDcuNC44IG9mIHRoZSBTQlAtMiBzcGVjLCBhIG1ndF9PUkJfdGltZW91dCB2YWx1ZSBjYW4gYmUKLSAqIHByb3ZpZGVkIGluIHRoZSBjb25maWcgcm9tLiBNb3N0IGRldmljZXMgZG8gcHJvdmlkZSBhIHZhbHVlLCB3aGljaAotICogd2UnbGwgdXNlIGZvciBsb2dpbiBtYW5hZ2VtZW50IG9yYnMsIGJ1dCB3aXRoIHNvbWUgc2FuZSBsaW1pdHMuCi0gKi8KLSNkZWZpbmUgU0JQMl9NSU5fTE9HSU5fT1JCX1RJTUVPVVQJNTAwMFUJLyogVGltZW91dCBpbiBtcyAqLwotI2RlZmluZSBTQlAyX01BWF9MT0dJTl9PUkJfVElNRU9VVAk0MDAwMFUJLyogVGltZW91dCBpbiBtcyAqLwotI2RlZmluZSBTQlAyX09SQl9USU1FT1VUCQkyMDAwVQkvKiBUaW1lb3V0IGluIG1zICovCisjZGVmaW5lIFNCUDJfT1JCX1RJTUVPVVQJCTIwMDBVCQkvKiBUaW1lb3V0IGluIG1zICovCiAjZGVmaW5lIFNCUDJfT1JCX05VTEwJCQkweDgwMDAwMDAwCiAjZGVmaW5lIFNCUDJfUkVUUllfTElNSVQJCTB4ZgkJLyogMTUgcmV0cmllcyAqLwogI2RlZmluZSBTQlAyX0NZQ0xFX0xJTUlUCQkoMHhjOCA8PCAxMikJLyogMjAwIDEyNXVzIGN5Y2xlcyAqLwpAQCAtMTAzNCw3ICsxMDI3LDYgQEAKIHsKIAlzdHJ1Y3QgZndfY3NyX2l0ZXJhdG9yIGNpOwogCWludCBrZXksIHZhbHVlOwotCXVuc2lnbmVkIGludCB0aW1lb3V0OwogCiAJZndfY3NyX2l0ZXJhdG9yX2luaXQoJmNpLCBkaXJlY3RvcnkpOwogCXdoaWxlIChmd19jc3JfaXRlcmF0b3JfbmV4dCgmY2ksICZrZXksICZ2YWx1ZSkpIHsKQEAgLTEwNTksMTcgKzEwNTEsNyBAQAogCiAJCWNhc2UgU0JQMl9DU1JfVU5JVF9DSEFSQUNURVJJU1RJQ1M6CiAJCQkvKiB0aGUgdGltZW91dCB2YWx1ZSBpcyBzdG9yZWQgaW4gNTAwbXMgdW5pdHMgKi8KLQkJCXRpbWVvdXQgPSAoKHVuc2lnbmVkIGludCkgdmFsdWUgPj4gOCAmIDB4ZmYpICogNTAwOwotCQkJdGltZW91dCA9IG1heCh0aW1lb3V0LCBTQlAyX01JTl9MT0dJTl9PUkJfVElNRU9VVCk7Ci0JCQl0Z3QtPm1ndF9vcmJfdGltZW91dCA9Ci0JCQkJICBtaW4odGltZW91dCwgU0JQMl9NQVhfTE9HSU5fT1JCX1RJTUVPVVQpOwotCi0JCQlpZiAodGltZW91dCA+IHRndC0+bWd0X29yYl90aW1lb3V0KQotCQkJCWZ3X25vdGlmeSgiJXM6IGNvbmZpZyByb20gY29udGFpbnMgJWRzICIKLQkJCQkJICAibWFuYWdlbWVudCBPUkIgdGltZW91dCwgbGltaXRpbmcgIgotCQkJCQkgICJ0byAlZHNcbiIsIHRndC0+YnVzX2lkLAotCQkJCQkgIHRpbWVvdXQgLyAxMDAwLAotCQkJCQkgIHRndC0+bWd0X29yYl90aW1lb3V0IC8gMTAwMCk7CisJCQl0Z3QtPm1ndF9vcmJfdGltZW91dCA9ICh2YWx1ZSA+PiA4ICYgMHhmZikgKiA1MDA7CiAJCQlicmVhazsKIAogCQljYXNlIFNCUDJfQ1NSX0xPR0lDQUxfVU5JVF9OVU1CRVI6CkBAIC0xMDg3LDYgKzEwNjksMjIgQEAKIAlyZXR1cm4gMDsKIH0KIAorLyoKKyAqIFBlciBzZWN0aW9uIDcuNC44IG9mIHRoZSBTQlAtMiBzcGVjLCBhIG1ndF9PUkJfdGltZW91dCB2YWx1ZSBjYW4gYmUKKyAqIHByb3ZpZGVkIGluIHRoZSBjb25maWcgcm9tLiBNb3N0IGRldmljZXMgZG8gcHJvdmlkZSBhIHZhbHVlLCB3aGljaAorICogd2UnbGwgdXNlIGZvciBsb2dpbiBtYW5hZ2VtZW50IG9yYnMsIGJ1dCB3aXRoIHNvbWUgc2FuZSBsaW1pdHMuCisgKi8KK3N0YXRpYyB2b2lkIHNicDJfY2xhbXBfbWFuYWdlbWVudF9vcmJfdGltZW91dChzdHJ1Y3Qgc2JwMl90YXJnZXQgKnRndCkKK3sKKwl1bnNpZ25lZCBpbnQgdGltZW91dCA9IHRndC0+bWd0X29yYl90aW1lb3V0OworCisJaWYgKHRpbWVvdXQgPiA0MDAwMCkKKwkJZndfbm90aWZ5KCIlczogJWRzIG1ndF9PUkJfdGltZW91dCBsaW1pdGVkIHRvIDQwc1xuIiwKKwkJCSAgdGd0LT5idXNfaWQsIHRpbWVvdXQgLyAxMDAwKTsKKworCXRndC0+bWd0X29yYl90aW1lb3V0ID0gY2xhbXBfdmFsKHRpbWVvdXQsIDUwMDAsIDQwMDAwKTsKK30KKwogc3RhdGljIHZvaWQgc2JwMl9pbml0X3dvcmthcm91bmRzKHN0cnVjdCBzYnAyX3RhcmdldCAqdGd0LCB1MzIgbW9kZWwsCiAJCQkJICB1MzIgZmlybXdhcmVfcmV2aXNpb24pCiB7CkBAIC0xMTcxLDYgKzExNjksNyBAQAogCQkJICAgICAgICZmaXJtd2FyZV9yZXZpc2lvbikgPCAwKQogCQlnb3RvIGZhaWxfdGd0X3B1dDsKIAorCXNicDJfY2xhbXBfbWFuYWdlbWVudF9vcmJfdGltZW91dCh0Z3QpOwogCXNicDJfaW5pdF93b3JrYXJvdW5kcyh0Z3QsIG1vZGVsLCBmaXJtd2FyZV9yZXZpc2lvbik7CiAKIAkvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncGlvL3R3bDQwMzAtZ3Bpby5jIGIvZHJpdmVycy9ncGlvL3R3bDQwMzAtZ3Bpby5jCmluZGV4IGFmYWQxNDcuLjQ5Mzg0YTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3Bpby90d2w0MDMwLWdwaW8uYworKysgYi9kcml2ZXJzL2dwaW8vdHdsNDAzMC1ncGlvLmMKQEAgLTQ2MCw3ICs0NjAsOCBAQAogCXJldHVybiByZXQ7CiB9CiAKLXN0YXRpYyBpbnQgX19kZXZleGl0IGdwaW9fdHdsNDAzMF9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKKy8qIENhbm5vdCB1c2UgX19kZXZleGl0IGFzIGdwaW9fdHdsNDAzMF9wcm9iZSgpIGNhbGxzIHVzICovCitzdGF0aWMgaW50IGdwaW9fdHdsNDAzMF9yZW1vdmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIHsKIAlzdHJ1Y3QgdHdsNDAzMF9ncGlvX3BsYXRmb3JtX2RhdGEgKnBkYXRhID0gcGRldi0+ZGV2LnBsYXRmb3JtX2RhdGE7CiAJaW50IHN0YXR1czsKQEAgLTQ5Myw3ICs0OTQsNyBAQAogCS5kcml2ZXIubmFtZQk9ICJ0d2w0MDMwX2dwaW8iLAogCS5kcml2ZXIub3duZXIJPSBUSElTX01PRFVMRSwKIAkucHJvYmUJCT0gZ3Bpb190d2w0MDMwX3Byb2JlLAotCS5yZW1vdmUJCT0gX19kZXZleGl0X3AoZ3Bpb190d2w0MDMwX3JlbW92ZSksCisJLnJlbW92ZQkJPSBncGlvX3R3bDQwMzBfcmVtb3ZlLAogfTsKIAogc3RhdGljIGludCBfX2luaXQgZ3Bpb190d2w0MDMwX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZG1hLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2RtYS5jCmluZGV4IDQ1ZDUwN2UuLjkyYWViOTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZG1hLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kbWEuYwpAQCAtMTQ2OCw2ICsxNDY4LDcgQEAKIAlzcGluX2xvY2tfaW5pdCgmZGV2X3ByaXYtPnVzZXJfaXJxX2xvY2spOwogCXNwaW5fbG9ja19pbml0KCZkZXZfcHJpdi0+ZXJyb3JfbG9jayk7CiAJZGV2X3ByaXYtPnVzZXJfaXJxX3JlZmNvdW50ID0gMDsKKwlkZXZfcHJpdi0+dHJhY2VfaXJxX3NlcW5vID0gMDsKIAogCXJldCA9IGRybV92YmxhbmtfaW5pdChkZXYsIEk5MTVfTlVNX1BJUEUpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaAppbmRleCBiMjRiMmQxLi42MDM1ZDNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgKQEAgLTIwMiw2ICsyMDIsNyBAQAogCXNwaW5sb2NrX3QgdXNlcl9pcnFfbG9jazsKIAkvKiogUmVmY291bnQgZm9yIGk5MTVfdXNlcl9pcnFfZ2V0KCkgdmVyc3VzIGk5MTVfdXNlcl9pcnFfcHV0KCkuICovCiAJaW50IHVzZXJfaXJxX3JlZmNvdW50OworCXUzMiB0cmFjZV9pcnFfc2Vxbm87CiAJLyoqIENhY2hlZCB2YWx1ZSBvZiBJTVIgdG8gYXZvaWQgcmVhZHMgaW4gdXBkYXRpbmcgdGhlIGJpdGZpZWxkICovCiAJdTMyIGlycV9tYXNrX3JlZzsKIAl1MzIgcGlwZXN0YXRbMl07CkBAIC02NjUsNiArNjY2LDcgQEAKIGV4dGVybiBpbnQgaTkxNV9pcnFfd2FpdChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB2b2lkICpkYXRhLAogCQkJIHN0cnVjdCBkcm1fZmlsZSAqZmlsZV9wcml2KTsKIHZvaWQgaTkxNV91c2VyX2lycV9nZXQoc3RydWN0IGRybV9kZXZpY2UgKmRldik7Cit2b2lkIGk5MTVfdHJhY2VfaXJxX2dldChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgc2Vxbm8pOwogdm9pZCBpOTE1X3VzZXJfaXJxX3B1dChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KTsKIGV4dGVybiB2b2lkIGk5MTVfZW5hYmxlX2ludGVycnVwdCAoc3RydWN0IGRybV9kZXZpY2UgKmRldik7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2dlbS5jCmluZGV4IDQwNzI3ZDQuLmFiZmMyN2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZ2VtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9nZW0uYwpAQCAtMTc3MCw3ICsxNzcwLDcgQEAKIAlkcm1faTkxNV9wcml2YXRlX3QgKmRldl9wcml2ID0gZGV2LT5kZXZfcHJpdmF0ZTsKIAl1aW50MzJfdCBzZXFubzsKIAotCWlmICghZGV2X3ByaXYtPmh3X3N0YXR1c19wYWdlKQorCWlmICghZGV2X3ByaXYtPmh3X3N0YXR1c19wYWdlIHx8IGxpc3RfZW1wdHkoJmRldl9wcml2LT5tbS5yZXF1ZXN0X2xpc3QpKQogCQlyZXR1cm47CiAKIAlzZXFubyA9IGk5MTVfZ2V0X2dlbV9zZXFubyhkZXYpOwpAQCAtMTc5NCw2ICsxNzk0LDEyIEBACiAJCX0gZWxzZQogCQkJYnJlYWs7CiAJfQorCisJaWYgKHVubGlrZWx5IChkZXZfcHJpdi0+dHJhY2VfaXJxX3NlcW5vICYmCisJCSAgICAgIGk5MTVfc2Vxbm9fcGFzc2VkKGRldl9wcml2LT50cmFjZV9pcnFfc2Vxbm8sIHNlcW5vKSkpIHsKKwkJaTkxNV91c2VyX2lycV9wdXQoZGV2KTsKKwkJZGV2X3ByaXYtPnRyYWNlX2lycV9zZXFubyA9IDA7CisJfQogfQogCiB2b2lkCkBAIC0zMzUyLDcgKzMzNTgsNyBAQAogCWV4ZWNfc3RhcnQgPSAodWludDMyX3QpIGV4ZWNfb2Zmc2V0ICsgZXhlYy0+YmF0Y2hfc3RhcnRfb2Zmc2V0OwogCWV4ZWNfbGVuID0gKHVpbnQzMl90KSBleGVjLT5iYXRjaF9sZW47CiAKLQl0cmFjZV9pOTE1X2dlbV9yZXF1ZXN0X3N1Ym1pdChkZXYsIGRldl9wcml2LT5tbS5uZXh0X2dlbV9zZXFubyk7CisJdHJhY2VfaTkxNV9nZW1fcmVxdWVzdF9zdWJtaXQoZGV2LCBkZXZfcHJpdi0+bW0ubmV4dF9nZW1fc2Vxbm8gKyAxKTsKIAogCWNvdW50ID0gbmJveCA/IG5ib3ggOiAxOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2lycS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9pcnEuYwppbmRleCA0ZGZlZWM3Li5jM2NlZmZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X2lycS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfaXJxLmMKQEAgLTcyNSw2ICs3MjUsMTYgQEAKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZkZXZfcHJpdi0+dXNlcl9pcnFfbG9jaywgaXJxZmxhZ3MpOwogfQogCit2b2lkIGk5MTVfdHJhY2VfaXJxX2dldChzdHJ1Y3QgZHJtX2RldmljZSAqZGV2LCB1MzIgc2Vxbm8pCit7CisJZHJtX2k5MTVfcHJpdmF0ZV90ICpkZXZfcHJpdiA9IChkcm1faTkxNV9wcml2YXRlX3QgKikgZGV2LT5kZXZfcHJpdmF0ZTsKKworCWlmIChkZXZfcHJpdi0+dHJhY2VfaXJxX3NlcW5vID09IDApCisJCWk5MTVfdXNlcl9pcnFfZ2V0KGRldik7CisKKwlkZXZfcHJpdi0+dHJhY2VfaXJxX3NlcW5vID0gc2Vxbm87Cit9CisKIHN0YXRpYyBpbnQgaTkxNV93YWl0X2lycShzdHJ1Y3QgZHJtX2RldmljZSAqIGRldiwgaW50IGlycV9ucikKIHsKIAlkcm1faTkxNV9wcml2YXRlX3QgKmRldl9wcml2ID0gKGRybV9pOTE1X3ByaXZhdGVfdCAqKSBkZXYtPmRldl9wcml2YXRlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV90cmFjZS5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV90cmFjZS5oCmluZGV4IDU1NjdhNDAuLjAxODQwZDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfdHJhY2UuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3RyYWNlLmgKQEAgLTE1OCwxNiArMTU4LDE3IEBACiAJICAgIFRQX0FSR1MoZGV2LCBzZXFubyksCiAKIAkgICAgVFBfU1RSVUNUX19lbnRyeSgKLQkJCSAgICAgX19maWVsZChzdHJ1Y3QgZHJtX2RldmljZSAqLCBkZXYpCisJCQkgICAgIF9fZmllbGQodTMyLCBkZXYpCiAJCQkgICAgIF9fZmllbGQodTMyLCBzZXFubykKIAkJCSAgICAgKSwKIAogCSAgICBUUF9mYXN0X2Fzc2lnbigKLQkJCSAgIF9fZW50cnktPmRldiA9IGRldjsKKwkJCSAgIF9fZW50cnktPmRldiA9IGRldi0+cHJpbWFyeS0+aW5kZXg7CiAJCQkgICBfX2VudHJ5LT5zZXFubyA9IHNlcW5vOworCQkJICAgaTkxNV90cmFjZV9pcnFfZ2V0KGRldiwgc2Vxbm8pOwogCQkJICAgKSwKIAotCSAgICBUUF9wcmludGsoImRldj0lcCwgc2Vxbm89JXUiLCBfX2VudHJ5LT5kZXYsIF9fZW50cnktPnNlcW5vKQorCSAgICBUUF9wcmludGsoImRldj0ldSwgc2Vxbm89JXUiLCBfX2VudHJ5LT5kZXYsIF9fZW50cnktPnNlcW5vKQogKTsKIAogVFJBQ0VfRVZFTlQoaTkxNV9nZW1fcmVxdWVzdF9mbHVzaCwKQEAgLTE3OCwyMCArMTc5LDIwIEBACiAJICAgIFRQX0FSR1MoZGV2LCBzZXFubywgZmx1c2hfZG9tYWlucywgaW52YWxpZGF0ZV9kb21haW5zKSwKIAogCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAotCQkJICAgICBfX2ZpZWxkKHN0cnVjdCBkcm1fZGV2aWNlICosIGRldikKKwkJCSAgICAgX19maWVsZCh1MzIsIGRldikKIAkJCSAgICAgX19maWVsZCh1MzIsIHNlcW5vKQogCQkJICAgICBfX2ZpZWxkKHUzMiwgZmx1c2hfZG9tYWlucykKIAkJCSAgICAgX19maWVsZCh1MzIsIGludmFsaWRhdGVfZG9tYWlucykKIAkJCSAgICAgKSwKIAogCSAgICBUUF9mYXN0X2Fzc2lnbigKLQkJCSAgIF9fZW50cnktPmRldiA9IGRldjsKKwkJCSAgIF9fZW50cnktPmRldiA9IGRldi0+cHJpbWFyeS0+aW5kZXg7CiAJCQkgICBfX2VudHJ5LT5zZXFubyA9IHNlcW5vOwogCQkJICAgX19lbnRyeS0+Zmx1c2hfZG9tYWlucyA9IGZsdXNoX2RvbWFpbnM7CiAJCQkgICBfX2VudHJ5LT5pbnZhbGlkYXRlX2RvbWFpbnMgPSBpbnZhbGlkYXRlX2RvbWFpbnM7CiAJCQkgICApLAogCi0JICAgIFRQX3ByaW50aygiZGV2PSVwLCBzZXFubz0ldSwgZmx1c2g9JTA0eCwgaW52YWxpZGF0ZT0lMDR4IiwKKwkgICAgVFBfcHJpbnRrKCJkZXY9JXUsIHNlcW5vPSV1LCBmbHVzaD0lMDR4LCBpbnZhbGlkYXRlPSUwNHgiLAogCQkgICAgICBfX2VudHJ5LT5kZXYsIF9fZW50cnktPnNlcW5vLAogCQkgICAgICBfX2VudHJ5LT5mbHVzaF9kb21haW5zLCBfX2VudHJ5LT5pbnZhbGlkYXRlX2RvbWFpbnMpCiApOwpAQCAtMjA0LDE2ICsyMDUsMTYgQEAKIAkgICAgVFBfQVJHUyhkZXYsIHNlcW5vKSwKIAogCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAotCQkJICAgICBfX2ZpZWxkKHN0cnVjdCBkcm1fZGV2aWNlICosIGRldikKKwkJCSAgICAgX19maWVsZCh1MzIsIGRldikKIAkJCSAgICAgX19maWVsZCh1MzIsIHNlcW5vKQogCQkJICAgICApLAogCiAJICAgIFRQX2Zhc3RfYXNzaWduKAotCQkJICAgX19lbnRyeS0+ZGV2ID0gZGV2OworCQkJICAgX19lbnRyeS0+ZGV2ID0gZGV2LT5wcmltYXJ5LT5pbmRleDsKIAkJCSAgIF9fZW50cnktPnNlcW5vID0gc2Vxbm87CiAJCQkgICApLAogCi0JICAgIFRQX3ByaW50aygiZGV2PSVwLCBzZXFubz0ldSIsIF9fZW50cnktPmRldiwgX19lbnRyeS0+c2Vxbm8pCisJICAgIFRQX3ByaW50aygiZGV2PSV1LCBzZXFubz0ldSIsIF9fZW50cnktPmRldiwgX19lbnRyeS0+c2Vxbm8pCiApOwogCiBUUkFDRV9FVkVOVChpOTE1X2dlbV9yZXF1ZXN0X3JldGlyZSwKQEAgLTIyMywxNiArMjI0LDE2IEBACiAJICAgIFRQX0FSR1MoZGV2LCBzZXFubyksCiAKIAkgICAgVFBfU1RSVUNUX19lbnRyeSgKLQkJCSAgICAgX19maWVsZChzdHJ1Y3QgZHJtX2RldmljZSAqLCBkZXYpCisJCQkgICAgIF9fZmllbGQodTMyLCBkZXYpCiAJCQkgICAgIF9fZmllbGQodTMyLCBzZXFubykKIAkJCSAgICAgKSwKIAogCSAgICBUUF9mYXN0X2Fzc2lnbigKLQkJCSAgIF9fZW50cnktPmRldiA9IGRldjsKKwkJCSAgIF9fZW50cnktPmRldiA9IGRldi0+cHJpbWFyeS0+aW5kZXg7CiAJCQkgICBfX2VudHJ5LT5zZXFubyA9IHNlcW5vOwogCQkJICAgKSwKIAotCSAgICBUUF9wcmludGsoImRldj0lcCwgc2Vxbm89JXUiLCBfX2VudHJ5LT5kZXYsIF9fZW50cnktPnNlcW5vKQorCSAgICBUUF9wcmludGsoImRldj0ldSwgc2Vxbm89JXUiLCBfX2VudHJ5LT5kZXYsIF9fZW50cnktPnNlcW5vKQogKTsKIAogVFJBQ0VfRVZFTlQoaTkxNV9nZW1fcmVxdWVzdF93YWl0X2JlZ2luLApAQCAtMjQyLDE2ICsyNDMsMTYgQEAKIAkgICAgVFBfQVJHUyhkZXYsIHNlcW5vKSwKIAogCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAotCQkJICAgICBfX2ZpZWxkKHN0cnVjdCBkcm1fZGV2aWNlICosIGRldikKKwkJCSAgICAgX19maWVsZCh1MzIsIGRldikKIAkJCSAgICAgX19maWVsZCh1MzIsIHNlcW5vKQogCQkJICAgICApLAogCiAJICAgIFRQX2Zhc3RfYXNzaWduKAotCQkJICAgX19lbnRyeS0+ZGV2ID0gZGV2OworCQkJICAgX19lbnRyeS0+ZGV2ID0gZGV2LT5wcmltYXJ5LT5pbmRleDsKIAkJCSAgIF9fZW50cnktPnNlcW5vID0gc2Vxbm87CiAJCQkgICApLAogCi0JICAgIFRQX3ByaW50aygiZGV2PSVwLCBzZXFubz0ldSIsIF9fZW50cnktPmRldiwgX19lbnRyeS0+c2Vxbm8pCisJICAgIFRQX3ByaW50aygiZGV2PSV1LCBzZXFubz0ldSIsIF9fZW50cnktPmRldiwgX19lbnRyeS0+c2Vxbm8pCiApOwogCiBUUkFDRV9FVkVOVChpOTE1X2dlbV9yZXF1ZXN0X3dhaXRfZW5kLApAQCAtMjYxLDE2ICsyNjIsMTYgQEAKIAkgICAgVFBfQVJHUyhkZXYsIHNlcW5vKSwKIAogCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAotCQkJICAgICBfX2ZpZWxkKHN0cnVjdCBkcm1fZGV2aWNlICosIGRldikKKwkJCSAgICAgX19maWVsZCh1MzIsIGRldikKIAkJCSAgICAgX19maWVsZCh1MzIsIHNlcW5vKQogCQkJICAgICApLAogCiAJICAgIFRQX2Zhc3RfYXNzaWduKAotCQkJICAgX19lbnRyeS0+ZGV2ID0gZGV2OworCQkJICAgX19lbnRyeS0+ZGV2ID0gZGV2LT5wcmltYXJ5LT5pbmRleDsKIAkJCSAgIF9fZW50cnktPnNlcW5vID0gc2Vxbm87CiAJCQkgICApLAogCi0JICAgIFRQX3ByaW50aygiZGV2PSVwLCBzZXFubz0ldSIsIF9fZW50cnktPmRldiwgX19lbnRyeS0+c2Vxbm8pCisJICAgIFRQX3ByaW50aygiZGV2PSV1LCBzZXFubz0ldSIsIF9fZW50cnktPmRldiwgX19lbnRyeS0+c2Vxbm8pCiApOwogCiBUUkFDRV9FVkVOVChpOTE1X3Jpbmdfd2FpdF9iZWdpbiwKQEAgLTI4MCwxNCArMjgxLDE0IEBACiAJICAgIFRQX0FSR1MoZGV2KSwKIAogCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAotCQkJICAgICBfX2ZpZWxkKHN0cnVjdCBkcm1fZGV2aWNlICosIGRldikKKwkJCSAgICAgX19maWVsZCh1MzIsIGRldikKIAkJCSAgICAgKSwKIAogCSAgICBUUF9mYXN0X2Fzc2lnbigKLQkJCSAgIF9fZW50cnktPmRldiA9IGRldjsKKwkJCSAgIF9fZW50cnktPmRldiA9IGRldi0+cHJpbWFyeS0+aW5kZXg7CiAJCQkgICApLAogCi0JICAgIFRQX3ByaW50aygiZGV2PSVwIiwgX19lbnRyeS0+ZGV2KQorCSAgICBUUF9wcmludGsoImRldj0ldSIsIF9fZW50cnktPmRldikKICk7CiAKIFRSQUNFX0VWRU5UKGk5MTVfcmluZ193YWl0X2VuZCwKQEAgLTI5NywxNCArMjk4LDE0IEBACiAJICAgIFRQX0FSR1MoZGV2KSwKIAogCSAgICBUUF9TVFJVQ1RfX2VudHJ5KAotCQkJICAgICBfX2ZpZWxkKHN0cnVjdCBkcm1fZGV2aWNlICosIGRldikKKwkJCSAgICAgX19maWVsZCh1MzIsIGRldikKIAkJCSAgICAgKSwKIAogCSAgICBUUF9mYXN0X2Fzc2lnbigKLQkJCSAgIF9fZW50cnktPmRldiA9IGRldjsKKwkJCSAgIF9fZW50cnktPmRldiA9IGRldi0+cHJpbWFyeS0+aW5kZXg7CiAJCQkgICApLAogCi0JICAgIFRQX3ByaW50aygiZGV2PSVwIiwgX19lbnRyeS0+ZGV2KQorCSAgICBUUF9wcmludGsoImRldj0ldSIsIF9fZW50cnktPmRldikKICk7CiAKICNlbmRpZiAvKiBfSTkxNV9UUkFDRV9IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCmluZGV4IGZmYTM5NjcuLjNjMTQyNDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKQEAgLTMwOTUsNyArMzA5NSw2IEBACiAJc3RydWN0IGRybV9nZW1fb2JqZWN0ICpibzsKIAlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqb2JqX3ByaXY7CiAJaW50IHBpcGUgPSBpbnRlbF9jcnRjLT5waXBlOwotCWludCBwbGFuZSA9IGludGVsX2NydGMtPnBsYW5lOwogCXVpbnQzMl90IGNvbnRyb2wgPSAocGlwZSA9PSAwKSA/IENVUkFDTlRSIDogQ1VSQkNOVFI7CiAJdWludDMyX3QgYmFzZSA9IChwaXBlID09IDApID8gQ1VSQUJBU0UgOiBDVVJCQkFTRTsKIAl1aW50MzJfdCB0ZW1wID0gSTkxNV9SRUFEKGNvbnRyb2wpOwpAQCAtMzE4Miw5ICszMTgxLDYgQEAKIAkJZHJtX2dlbV9vYmplY3RfdW5yZWZlcmVuY2UoaW50ZWxfY3J0Yy0+Y3Vyc29yX2JvKTsKIAl9CiAKLQlpZiAoKElTX0k5NjVHKGRldikgfHwgcGxhbmUgPT0gMCkpCi0JCWludGVsX3VwZGF0ZV9mYmMoY3J0YywgJmNydGMtPm1vZGUpOwotCiAJbXV0ZXhfdW5sb2NrKCZkZXYtPnN0cnVjdF9tdXRleCk7CiAKIAlpbnRlbF9jcnRjLT5jdXJzb3JfYWRkciA9IGFkZHI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9oZG1pLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9oZG1pLmMKaW5kZXggZmEzMDRlMS4uNjYzYWI2ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfaGRtaS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2hkbWkuYwpAQCAtMjIzLDcgKzIyMyw3IEBACiAKIAljb25uZWN0b3IgPSAmaW50ZWxfb3V0cHV0LT5iYXNlOwogCWRybV9jb25uZWN0b3JfaW5pdChkZXYsIGNvbm5lY3RvciwgJmludGVsX2hkbWlfY29ubmVjdG9yX2Z1bmNzLAotCQkJICAgRFJNX01PREVfQ09OTkVDVE9SX0RWSUQpOworCQkJICAgRFJNX01PREVfQ09OTkVDVE9SX0hETUlBKTsKIAlkcm1fY29ubmVjdG9yX2hlbHBlcl9hZGQoY29ubmVjdG9yLCAmaW50ZWxfaGRtaV9jb25uZWN0b3JfaGVscGVyX2Z1bmNzKTsKIAogCWludGVsX291dHB1dC0+dHlwZSA9IElOVEVMX09VVFBVVF9IRE1JOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdHYuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3R2LmMKaW5kZXggYzY0ZWFiNC4uOWNhOTE3OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfdHYuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF90di5jCkBAIC0xMDgyLDcgKzEwODIsOCBAQAogCWNvbnN0IHN0cnVjdCB0dl9tb2RlICp0dl9tb2RlID0gaW50ZWxfdHZfbW9kZV9maW5kKGludGVsX291dHB1dCk7CiAKIAkvKiBFbnN1cmUgVFYgcmVmcmVzaCBpcyBjbG9zZSB0byBkZXNpcmVkIHJlZnJlc2ggKi8KLQlpZiAodHZfbW9kZSAmJiBhYnModHZfbW9kZS0+cmVmcmVzaCAtIGRybV9tb2RlX3ZyZWZyZXNoKG1vZGUpKSA8IDEwKQorCWlmICh0dl9tb2RlICYmIGFicyh0dl9tb2RlLT5yZWZyZXNoIC0gZHJtX21vZGVfdnJlZnJlc2gobW9kZSkgKiAxMDAwKQorCQkJCTwgMTAwMCkKIAkJcmV0dXJuIE1PREVfT0s7CiAJcmV0dXJuIE1PREVfQ0xPQ0tfUkFOR0U7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2hpZC9oaWQtY29yZS5jIGIvZHJpdmVycy9oaWQvaGlkLWNvcmUuYwppbmRleCBiZTM0ZDMyLi43ZDA1YzRiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2hpZC9oaWQtY29yZS5jCisrKyBiL2RyaXZlcnMvaGlkL2hpZC1jb3JlLmMKQEAgLTEwNjYsNyArMTA2Niw3IEBACiAgKiBAdHlwZTogSElEIHJlcG9ydCB0eXBlIChISURfKl9SRVBPUlQpCiAgKiBAZGF0YTogcmVwb3J0IGNvbnRlbnRzCiAgKiBAc2l6ZTogc2l6ZSBvZiBkYXRhIHBhcmFtZXRlcgotICogQGludGVycnVwdDogY2FsbGVkIGZyb20gYXRvbWljPworICogQGludGVycnVwdDogZGlzdGluZ3Vpc2ggYmV0d2VlbiBpbnRlcnJ1cHQgYW5kIGNvbnRyb2wgdHJhbnNmZXJzCiAgKgogICogVGhpcyBpcyBkYXRhIGVudHJ5IGZvciBsb3dlciBsYXllcnMuCiAgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL2hpZC10d2luaGFuLmMgYi9kcml2ZXJzL2hpZC9oaWQtdHdpbmhhbi5jCmluZGV4IGIwNWY2MDIuLmM0MGFmYzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaGlkL2hpZC10d2luaGFuLmMKKysrIGIvZHJpdmVycy9oaWQvaGlkLXR3aW5oYW4uYwpAQCAtMTMyLDEyICsxMzIsMTIgQEAKIAkuaW5wdXRfbWFwcGluZyA9IHR3aW5oYW5faW5wdXRfbWFwcGluZywKIH07CiAKLXN0YXRpYyBpbnQgdHdpbmhhbl9pbml0KHZvaWQpCitzdGF0aWMgaW50IF9faW5pdCB0d2luaGFuX2luaXQodm9pZCkKIHsKIAlyZXR1cm4gaGlkX3JlZ2lzdGVyX2RyaXZlcigmdHdpbmhhbl9kcml2ZXIpOwogfQogCi1zdGF0aWMgdm9pZCB0d2luaGFuX2V4aXQodm9pZCkKK3N0YXRpYyB2b2lkIF9fZXhpdCB0d2luaGFuX2V4aXQodm9pZCkKIHsKIAloaWRfdW5yZWdpc3Rlcl9kcml2ZXIoJnR3aW5oYW5fZHJpdmVyKTsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaGlkL2hpZHJhdy5jIGIvZHJpdmVycy9oaWQvaGlkcmF3LmMKaW5kZXggYmEwNTI3NS4uY2RkMTM2OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9oaWQvaGlkcmF3LmMKKysrIGIvZHJpdmVycy9oaWQvaGlkcmF3LmMKQEAgLTQ4LDEwICs0OCw5IEBACiAJY2hhciAqcmVwb3J0OwogCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwogCisJbXV0ZXhfbG9jaygmbGlzdC0+cmVhZF9tdXRleCk7CisKIAl3aGlsZSAocmV0ID09IDApIHsKLQotCQltdXRleF9sb2NrKCZsaXN0LT5yZWFkX211dGV4KTsKLQogCQlpZiAobGlzdC0+aGVhZCA9PSBsaXN0LT50YWlsKSB7CiAJCQlhZGRfd2FpdF9xdWV1ZSgmbGlzdC0+aGlkcmF3LT53YWl0LCAmd2FpdCk7CiAJCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9LY29uZmlnIGIvZHJpdmVycy9od21vbi9LY29uZmlnCmluZGV4IDY4NTc1NjAuLjcwMGU5M2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaHdtb24vS2NvbmZpZworKysgYi9kcml2ZXJzL2h3bW9uL0tjb25maWcKQEAgLTY3NSw3ICs2NzUsNyBAQAogCiBjb25maWcgU0VOU09SU19TM0MKIAl0cmlzdGF0ZSAiUzNDMjRYWC9TM0M2NFhYIEluYnVpbHQgQURDIgotCWRlcGVuZHMgb24gQVJDSF9TM0MyNDEwIHx8IEFSQ0hfUzNDNjRYWAorCWRlcGVuZHMgb24gQVJDSF9TM0MyNDEwCiAJaGVscAogCSAgSWYgeW91IHNheSB5ZXMgaGVyZSB5b3UgZ2V0IHN1cHBvcnQgZm9yIHRoZSBvbi1ib2FyZCBBRENzIG9mCiAJICB0aGUgU2Ftc3VuZyBTM0MyNFhYIG9yIFMzQzY0WFggc2VyaWVzIG9mIFNvQwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9od21vbi9hc3VzX2F0azAxMTAuYyBiL2RyaXZlcnMvaHdtb24vYXN1c19hdGswMTEwLmMKaW5kZXggZmU0ZmEyOS4uNWEzZWUwMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9hc3VzX2F0azAxMTAuYworKysgYi9kcml2ZXJzL2h3bW9uL2FzdXNfYXRrMDExMC5jCkBAIC0zNSwxOCArMzUsMjIgQEAKICNkZWZpbmUgTUVUSE9EX09MRF9FTlVNX0ZBTgkiRlNJRiIKIAogI2RlZmluZSBBVEtfTVVYX0hXTU9OCQkweDAwMDAwMDA2VUxMCisjZGVmaW5lIEFUS19NVVhfTUdNVAkJMHgwMDAwMDAxMVVMTAogCiAjZGVmaW5lIEFUS19DTEFTU19NQVNLCQkweGZmMDAwMDAwVUxMCiAjZGVmaW5lIEFUS19DTEFTU19GUkVRX0NUTAkweDAzMDAwMDAwVUxMCiAjZGVmaW5lIEFUS19DTEFTU19GQU5fQ1RMCTB4MDQwMDAwMDBVTEwKICNkZWZpbmUgQVRLX0NMQVNTX0hXTU9OCQkweDA2MDAwMDAwVUxMCisjZGVmaW5lIEFUS19DTEFTU19NR01UCQkweDExMDAwMDAwVUxMCiAKICNkZWZpbmUgQVRLX1RZUEVfTUFTSwkJMHgwMGZmMDAwMFVMTAogI2RlZmluZSBIV01PTl9UWVBFX1ZPTFQJCTB4MDAwMjAwMDBVTEwKICNkZWZpbmUgSFdNT05fVFlQRV9URU1QCQkweDAwMDMwMDAwVUxMCiAjZGVmaW5lIEhXTU9OX1RZUEVfRkFOCQkweDAwMDQwMDAwVUxMCiAKLSNkZWZpbmUgSFdNT05fU0VOU09SX0lEX01BU0sJMHgwMDAwZmZmZlVMTAorI2RlZmluZSBBVEtfRUxFTUVOVF9JRF9NQVNLCTB4MDAwMGZmZmZVTEwKKworI2RlZmluZSBBVEtfRUNfSUQJCTB4MTEwNjAwMDRVTEwKIAogZW51bSBhdGtfcGFja19tZW1iZXIgewogCUhXTU9OX1BBQ0tfRkxBR1MsCkBAIC04OSw2ICs5Myw5IEBACiAJLyogbmV3IGludGVmYWNlICovCiAJYWNwaV9oYW5kbGUgZW51bWVyYXRlX2hhbmRsZTsKIAlhY3BpX2hhbmRsZSByZWFkX2hhbmRsZTsKKwlhY3BpX2hhbmRsZSB3cml0ZV9oYW5kbGU7CisKKwlib29sIGRpc2FibGVfZWM7CiAKIAlpbnQgdm9sdGFnZV9jb3VudDsKIAlpbnQgdGVtcGVyYXR1cmVfY291bnQ7CkBAIC0xMjksOSArMTM2LDIyIEBACiAJY2hhciBjb25zdCAqYWNwaV9uYW1lOwogfTsKIAotc3RydWN0IGF0a19hY3BpX2J1ZmZlcl91NjQgewotCXVuaW9uIGFjcGlfb2JqZWN0IGJ1ZjsKLQl1NjQgdmFsdWU7CisvKiBSZXR1cm4gYnVmZmVyIGZvcm1hdDoKKyAqIFswLTNdICJ2YWx1ZSIgaXMgdmFsaWQgZmxhZworICogWzQtN10gdmFsdWUKKyAqIFs4LSBdIHVua25vd24gc3R1ZmYgb24gbmV3ZXIgbW9ib3MKKyAqLworc3RydWN0IGF0a19hY3BpX3JldF9idWZmZXIgeworCXUzMiBmbGFnczsKKwl1MzIgdmFsdWU7CisJdTggZGF0YVtdOworfTsKKworLyogSW5wdXQgYnVmZmVyIHVzZWQgZm9yIEdJVE0gYW5kIFNJVE0gbWV0aG9kcyAqLworc3RydWN0IGF0a19hY3BpX2lucHV0X2J1ZiB7CisJdTMyIGlkOworCXUzMiBwYXJhbTE7CisJdTMyIHBhcmFtMjsKIH07CiAKIHN0YXRpYyBpbnQgYXRrX2FkZChzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSk7CkBAIC00MzksNTIgKzQ1OSwxNDcgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHVuaW9uIGFjcGlfb2JqZWN0ICphdGtfZ2dycChzdHJ1Y3QgYXRrX2RhdGEgKmRhdGEsIHUxNiBtdXgpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmRhdGEtPmFjcGlfZGV2LT5kZXY7CisJc3RydWN0IGFjcGlfYnVmZmVyIGJ1ZjsKKwlhY3BpX3N0YXR1cyByZXQ7CisJc3RydWN0IGFjcGlfb2JqZWN0X2xpc3QgcGFyYW1zOworCXVuaW9uIGFjcGlfb2JqZWN0IGlkOworCXVuaW9uIGFjcGlfb2JqZWN0ICpwYWNrOworCisJaWQudHlwZSA9IEFDUElfVFlQRV9JTlRFR0VSOworCWlkLmludGVnZXIudmFsdWUgPSBtdXg7CisJcGFyYW1zLmNvdW50ID0gMTsKKwlwYXJhbXMucG9pbnRlciA9ICZpZDsKKworCWJ1Zi5sZW5ndGggPSBBQ1BJX0FMTE9DQVRFX0JVRkZFUjsKKwlyZXQgPSBhY3BpX2V2YWx1YXRlX29iamVjdChkYXRhLT5lbnVtZXJhdGVfaGFuZGxlLCBOVUxMLCAmcGFyYW1zLCAmYnVmKTsKKwlpZiAocmV0ICE9IEFFX09LKSB7CisJCWRldl9lcnIoZGV2LCAiR0dSUFslI3hdIEFDUEkgZXhjZXB0aW9uOiAlc1xuIiwgbXV4LAorCQkJCWFjcGlfZm9ybWF0X2V4Y2VwdGlvbihyZXQpKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTyk7CisJfQorCXBhY2sgPSBidWYucG9pbnRlcjsKKwlpZiAocGFjay0+dHlwZSAhPSBBQ1BJX1RZUEVfUEFDS0FHRSkgeworCQkvKiBFeGVjdXRpb24gd2FzIHN1Y2Nlc3NmdWwsIGJ1dCB0aGUgaWQgd2FzIG5vdCBmb3VuZCAqLworCQlBQ1BJX0ZSRUUocGFjayk7CisJCXJldHVybiBFUlJfUFRSKC1FTk9FTlQpOworCX0KKworCWlmIChwYWNrLT5wYWNrYWdlLmNvdW50IDwgMSkgeworCQlkZXZfZXJyKGRldiwgIkdHUlBbJSN4XSBwYWNrYWdlIGlzIHRvbyBzbWFsbFxuIiwgbXV4KTsKKwkJQUNQSV9GUkVFKHBhY2spOworCQlyZXR1cm4gRVJSX1BUUigtRUlPKTsKKwl9CisJcmV0dXJuIHBhY2s7Cit9CisKK3N0YXRpYyB1bmlvbiBhY3BpX29iamVjdCAqYXRrX2dpdG0oc3RydWN0IGF0a19kYXRhICpkYXRhLCB1NjQgaWQpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmRhdGEtPmFjcGlfZGV2LT5kZXY7CisJc3RydWN0IGF0a19hY3BpX2lucHV0X2J1ZiBidWY7CisJdW5pb24gYWNwaV9vYmplY3QgdG1wOworCXN0cnVjdCBhY3BpX29iamVjdF9saXN0IHBhcmFtczsKKwlzdHJ1Y3QgYWNwaV9idWZmZXIgcmV0OworCXVuaW9uIGFjcGlfb2JqZWN0ICpvYmo7CisJYWNwaV9zdGF0dXMgc3RhdHVzOworCisJYnVmLmlkID0gaWQ7CisJYnVmLnBhcmFtMSA9IDA7CisJYnVmLnBhcmFtMiA9IDA7CisKKwl0bXAudHlwZSA9IEFDUElfVFlQRV9CVUZGRVI7CisJdG1wLmJ1ZmZlci5wb2ludGVyID0gKHU4ICopJmJ1ZjsKKwl0bXAuYnVmZmVyLmxlbmd0aCA9IHNpemVvZihidWYpOworCisJcGFyYW1zLmNvdW50ID0gMTsKKwlwYXJhbXMucG9pbnRlciA9ICh2b2lkICopJnRtcDsKKworCXJldC5sZW5ndGggPSBBQ1BJX0FMTE9DQVRFX0JVRkZFUjsKKwlzdGF0dXMgPSBhY3BpX2V2YWx1YXRlX29iamVjdF90eXBlZChkYXRhLT5yZWFkX2hhbmRsZSwgTlVMTCwgJnBhcmFtcywKKwkJCSZyZXQsIEFDUElfVFlQRV9CVUZGRVIpOworCWlmIChzdGF0dXMgIT0gQUVfT0spIHsKKwkJZGV2X3dhcm4oZGV2LCAiR0lUTVslI2xseF0gQUNQSSBleGNlcHRpb246ICVzXG4iLCBpZCwKKwkJCQlhY3BpX2Zvcm1hdF9leGNlcHRpb24oc3RhdHVzKSk7CisJCXJldHVybiBFUlJfUFRSKC1FSU8pOworCX0KKwlvYmogPSByZXQucG9pbnRlcjsKKworCS8qIFNhbml0eSBjaGVjayAqLworCWlmIChvYmotPmJ1ZmZlci5sZW5ndGggPCA4KSB7CisJCWRldl93YXJuKGRldiwgIlVuZXhwZWN0ZWQgQVNCRiBsZW5ndGg6ICV1XG4iLAorCQkJCW9iai0+YnVmZmVyLmxlbmd0aCk7CisJCUFDUElfRlJFRShvYmopOworCQlyZXR1cm4gRVJSX1BUUigtRUlPKTsKKwl9CisJcmV0dXJuIG9iajsKK30KKworc3RhdGljIHVuaW9uIGFjcGlfb2JqZWN0ICphdGtfc2l0bShzdHJ1Y3QgYXRrX2RhdGEgKmRhdGEsCisJCXN0cnVjdCBhdGtfYWNwaV9pbnB1dF9idWYgKmJ1ZikKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmZGF0YS0+YWNwaV9kZXYtPmRldjsKKwlzdHJ1Y3QgYWNwaV9vYmplY3RfbGlzdCBwYXJhbXM7CisJdW5pb24gYWNwaV9vYmplY3QgdG1wOworCXN0cnVjdCBhY3BpX2J1ZmZlciByZXQ7CisJdW5pb24gYWNwaV9vYmplY3QgKm9iajsKKwlhY3BpX3N0YXR1cyBzdGF0dXM7CisKKwl0bXAudHlwZSA9IEFDUElfVFlQRV9CVUZGRVI7CisJdG1wLmJ1ZmZlci5wb2ludGVyID0gKHU4ICopYnVmOworCXRtcC5idWZmZXIubGVuZ3RoID0gc2l6ZW9mKCpidWYpOworCisJcGFyYW1zLmNvdW50ID0gMTsKKwlwYXJhbXMucG9pbnRlciA9ICZ0bXA7CisKKwlyZXQubGVuZ3RoID0gQUNQSV9BTExPQ0FURV9CVUZGRVI7CisJc3RhdHVzID0gYWNwaV9ldmFsdWF0ZV9vYmplY3RfdHlwZWQoZGF0YS0+d3JpdGVfaGFuZGxlLCBOVUxMLCAmcGFyYW1zLAorCQkJJnJldCwgQUNQSV9UWVBFX0JVRkZFUik7CisJaWYgKHN0YXR1cyAhPSBBRV9PSykgeworCQlkZXZfd2FybihkZXYsICJTSVRNWyUjeF0gQUNQSSBleGNlcHRpb246ICVzXG4iLCBidWYtPmlkLAorCQkJCWFjcGlfZm9ybWF0X2V4Y2VwdGlvbihzdGF0dXMpKTsKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTyk7CisJfQorCW9iaiA9IHJldC5wb2ludGVyOworCisJLyogU2FuaXR5IGNoZWNrICovCisJaWYgKG9iai0+YnVmZmVyLmxlbmd0aCA8IDgpIHsKKwkJZGV2X3dhcm4oZGV2LCAiVW5leHBlY3RlZCBBU0JGIGxlbmd0aDogJXVcbiIsCisJCQkJb2JqLT5idWZmZXIubGVuZ3RoKTsKKwkJQUNQSV9GUkVFKG9iaik7CisJCXJldHVybiBFUlJfUFRSKC1FSU8pOworCX0KKwlyZXR1cm4gb2JqOworfQorCiBzdGF0aWMgaW50IGF0a19yZWFkX3ZhbHVlX25ldyhzdHJ1Y3QgYXRrX3NlbnNvcl9kYXRhICpzZW5zb3IsIHU2NCAqdmFsdWUpCiB7CiAJc3RydWN0IGF0a19kYXRhICpkYXRhID0gc2Vuc29yLT5kYXRhOwogCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZkYXRhLT5hY3BpX2Rldi0+ZGV2OwotCXN0cnVjdCBhY3BpX29iamVjdF9saXN0IHBhcmFtczsKLQlzdHJ1Y3QgYWNwaV9idWZmZXIgcmV0OwotCXVuaW9uIGFjcGlfb2JqZWN0IGlkOwotCXN0cnVjdCBhdGtfYWNwaV9idWZmZXJfdTY0IHRtcDsKLQlhY3BpX3N0YXR1cyBzdGF0dXM7CisJdW5pb24gYWNwaV9vYmplY3QgKm9iajsKKwlzdHJ1Y3QgYXRrX2FjcGlfcmV0X2J1ZmZlciAqYnVmOworCWludCBlcnIgPSAwOwogCi0JaWQudHlwZSA9IEFDUElfVFlQRV9JTlRFR0VSOwotCWlkLmludGVnZXIudmFsdWUgPSBzZW5zb3ItPmlkOworCW9iaiA9IGF0a19naXRtKGRhdGEsIHNlbnNvci0+aWQpOworCWlmIChJU19FUlIob2JqKSkKKwkJcmV0dXJuIFBUUl9FUlIob2JqKTsKIAotCXBhcmFtcy5jb3VudCA9IDE7Ci0JcGFyYW1zLnBvaW50ZXIgPSAmaWQ7Ci0KLQl0bXAuYnVmLnR5cGUgPSBBQ1BJX1RZUEVfQlVGRkVSOwotCXRtcC5idWYuYnVmZmVyLnBvaW50ZXIgPSAodTggKikmdG1wLnZhbHVlOwotCXRtcC5idWYuYnVmZmVyLmxlbmd0aCA9IHNpemVvZih1NjQpOwotCXJldC5sZW5ndGggPSBzaXplb2YodG1wKTsKLQlyZXQucG9pbnRlciA9ICZ0bXA7Ci0KLQlzdGF0dXMgPSBhY3BpX2V2YWx1YXRlX29iamVjdF90eXBlZChkYXRhLT5yZWFkX2hhbmRsZSwgTlVMTCwgJnBhcmFtcywKLQkJCSZyZXQsIEFDUElfVFlQRV9CVUZGRVIpOwotCWlmIChzdGF0dXMgIT0gQUVfT0spIHsKLQkJZGV2X3dhcm4oZGV2LCAiJXM6IEFDUEkgZXhjZXB0aW9uOiAlc1xuIiwgX19mdW5jX18sCi0JCQkJYWNwaV9mb3JtYXRfZXhjZXB0aW9uKHN0YXR1cykpOwotCQlyZXR1cm4gLUVJTzsKLQl9Ci0KLQkvKiBSZXR1cm4gYnVmZmVyIGZvcm1hdDoKLQkgKiBbMC0zXSAidmFsdWUiIGlzIHZhbGlkIGZsYWcKLQkgKiBbNC03XSB2YWx1ZQotCSAqLwotCWlmICghKHRtcC52YWx1ZSAmIDB4ZmZmZmZmZmYpKSB7CisJYnVmID0gKHN0cnVjdCBhdGtfYWNwaV9yZXRfYnVmZmVyICopb2JqLT5idWZmZXIucG9pbnRlcjsKKwlpZiAoYnVmLT5mbGFncyA9PSAwKSB7CiAJCS8qIFRoZSByZWFkaW5nIGlzIG5vdCB2YWxpZCwgcG9zc2libGUgY2F1c2VzOgogCQkgKiAtIHNlbnNvciBmYWlsdXJlCiAJCSAqIC0gZW51bWVyYXRpb24gd2FzIEZVQkFSIChhbmQgd2UgZGlkbid0IG5vdGljZSkKIAkJICovCi0JCWRldl9pbmZvKGRldiwgIkZhaWx1cmU6ICUjbGx4XG4iLCB0bXAudmFsdWUpOwotCQlyZXR1cm4gLUVJTzsKKwkJZGV2X3dhcm4oZGV2LCAiUmVhZCBmYWlsZWQsIHNlbnNvciA9ICUjbGx4XG4iLCBzZW5zb3ItPmlkKTsKKwkJZXJyID0gLUVJTzsKKwkJZ290byBvdXQ7CiAJfQogCi0JKnZhbHVlID0gKHRtcC52YWx1ZSAmIDB4ZmZmZmZmZmYwMDAwMDAwMFVMTCkgPj4gMzI7Ci0KLQlyZXR1cm4gMDsKKwkqdmFsdWUgPSBidWYtPnZhbHVlOworb3V0OgorCUFDUElfRlJFRShvYmopOworCXJldHVybiBlcnI7CiB9CiAKIHN0YXRpYyBpbnQgYXRrX3JlYWRfdmFsdWUoc3RydWN0IGF0a19zZW5zb3JfZGF0YSAqc2Vuc29yLCB1NjQgKnZhbHVlKQpAQCAtNzEzLDQyICs4MjgsMTQwIEBACiAJcmV0dXJuIHJldDsKIH0KIAorc3RhdGljIGludCBhdGtfZWNfcHJlc2VudChzdHJ1Y3QgYXRrX2RhdGEgKmRhdGEpCit7CisJc3RydWN0IGRldmljZSAqZGV2ID0gJmRhdGEtPmFjcGlfZGV2LT5kZXY7CisJdW5pb24gYWNwaV9vYmplY3QgKnBhY2s7CisJdW5pb24gYWNwaV9vYmplY3QgKmVjOworCWludCByZXQ7CisJaW50IGk7CisKKwlwYWNrID0gYXRrX2dncnAoZGF0YSwgQVRLX01VWF9NR01UKTsKKwlpZiAoSVNfRVJSKHBhY2spKSB7CisJCWlmIChQVFJfRVJSKHBhY2spID09IC1FTk9FTlQpIHsKKwkJCS8qIFRoZSBNR01UIGNsYXNzIGRvZXMgbm90IGV4aXN0cyAtIHRoYXQncyBvayAqLworCQkJZGV2X2RiZyhkZXYsICJDbGFzcyAlI2xseCBub3QgZm91bmRcbiIsIEFUS19NVVhfTUdNVCk7CisJCQlyZXR1cm4gMDsKKwkJfQorCQlyZXR1cm4gUFRSX0VSUihwYWNrKTsKKwl9CisKKwkvKiBTZWFyY2ggdGhlIEVDICovCisJZWMgPSBOVUxMOworCWZvciAoaSA9IDA7IGkgPCBwYWNrLT5wYWNrYWdlLmNvdW50OyBpKyspIHsKKwkJdW5pb24gYWNwaV9vYmplY3QgKm9iaiA9ICZwYWNrLT5wYWNrYWdlLmVsZW1lbnRzW2ldOworCQl1bmlvbiBhY3BpX29iamVjdCAqaWQ7CisKKwkJaWYgKG9iai0+dHlwZSAhPSBBQ1BJX1RZUEVfUEFDS0FHRSkKKwkJCWNvbnRpbnVlOworCisJCWlkID0gJm9iai0+cGFja2FnZS5lbGVtZW50c1swXTsKKwkJaWYgKGlkLT50eXBlICE9IEFDUElfVFlQRV9JTlRFR0VSKQorCQkJY29udGludWU7CisKKwkJaWYgKGlkLT5pbnRlZ2VyLnZhbHVlID09IEFUS19FQ19JRCkgeworCQkJZWMgPSBvYmo7CisJCQlicmVhazsKKwkJfQorCX0KKworCXJldCA9IChlYyAhPSBOVUxMKTsKKwlpZiAoIXJldCkKKwkJLyogVGhlIHN5c3RlbSBoYXMgbm8gRUMgKi8KKwkJZGV2X2RiZyhkZXYsICJFQyBub3QgZm91bmRcbiIpOworCisJQUNQSV9GUkVFKHBhY2spOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgYXRrX2VjX2VuYWJsZWQoc3RydWN0IGF0a19kYXRhICpkYXRhKQoreworCXN0cnVjdCBkZXZpY2UgKmRldiA9ICZkYXRhLT5hY3BpX2Rldi0+ZGV2OworCXVuaW9uIGFjcGlfb2JqZWN0ICpvYmo7CisJc3RydWN0IGF0a19hY3BpX3JldF9idWZmZXIgKmJ1ZjsKKwlpbnQgZXJyOworCisJb2JqID0gYXRrX2dpdG0oZGF0YSwgQVRLX0VDX0lEKTsKKwlpZiAoSVNfRVJSKG9iaikpIHsKKwkJZGV2X2VycihkZXYsICJVbmFibGUgdG8gcXVlcnkgRUMgc3RhdHVzXG4iKTsKKwkJcmV0dXJuIFBUUl9FUlIob2JqKTsKKwl9CisJYnVmID0gKHN0cnVjdCBhdGtfYWNwaV9yZXRfYnVmZmVyICopb2JqLT5idWZmZXIucG9pbnRlcjsKKworCWlmIChidWYtPmZsYWdzID09IDApIHsKKwkJZGV2X2VycihkZXYsICJVbmFibGUgdG8gcXVlcnkgRUMgc3RhdHVzXG4iKTsKKwkJZXJyID0gLUVJTzsKKwl9IGVsc2UgeworCQllcnIgPSAoYnVmLT52YWx1ZSAhPSAwKTsKKwkJZGV2X2RiZyhkZXYsICJFQyBpcyAlc2FibGVkXG4iLAorCQkJCWVyciA/ICJlbiIgOiAiZGlzIik7CisJfQorCisJQUNQSV9GUkVFKG9iaik7CisJcmV0dXJuIGVycjsKK30KKworc3RhdGljIGludCBhdGtfZWNfY3RsKHN0cnVjdCBhdGtfZGF0YSAqZGF0YSwgaW50IGVuYWJsZSkKK3sKKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmZGF0YS0+YWNwaV9kZXYtPmRldjsKKwl1bmlvbiBhY3BpX29iamVjdCAqb2JqOworCXN0cnVjdCBhdGtfYWNwaV9pbnB1dF9idWYgc2l0bTsKKwlzdHJ1Y3QgYXRrX2FjcGlfcmV0X2J1ZmZlciAqZWNfcmV0OworCWludCBlcnIgPSAwOworCisJc2l0bS5pZCA9IEFUS19FQ19JRDsKKwlzaXRtLnBhcmFtMSA9IGVuYWJsZTsKKwlzaXRtLnBhcmFtMiA9IDA7CisKKwlvYmogPSBhdGtfc2l0bShkYXRhLCAmc2l0bSk7CisJaWYgKElTX0VSUihvYmopKSB7CisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvICVzYWJsZSB0aGUgRUNcbiIsCisJCQkJZW5hYmxlID8gImVuIiA6ICJkaXMiKTsKKwkJcmV0dXJuIFBUUl9FUlIob2JqKTsKKwl9CisJZWNfcmV0ID0gKHN0cnVjdCBhdGtfYWNwaV9yZXRfYnVmZmVyICopb2JqLT5idWZmZXIucG9pbnRlcjsKKwlpZiAoZWNfcmV0LT5mbGFncyA9PSAwKSB7CisJCWRldl9lcnIoZGV2LCAiRmFpbGVkIHRvICVzYWJsZSB0aGUgRUNcbiIsCisJCQkJZW5hYmxlID8gImVuIiA6ICJkaXMiKTsKKwkJZXJyID0gLUVJTzsKKwl9IGVsc2UgeworCQlkZXZfaW5mbyhkZXYsICJFQyAlc2FibGVkXG4iLAorCQkJCWVuYWJsZSA/ICJlbiIgOiAiZGlzIik7CisJfQorCisJQUNQSV9GUkVFKG9iaik7CisJcmV0dXJuIGVycjsKK30KKwogc3RhdGljIGludCBhdGtfZW51bWVyYXRlX25ld19od21vbihzdHJ1Y3QgYXRrX2RhdGEgKmRhdGEpCiB7CiAJc3RydWN0IGRldmljZSAqZGV2ID0gJmRhdGEtPmFjcGlfZGV2LT5kZXY7Ci0Jc3RydWN0IGFjcGlfYnVmZmVyIGJ1ZjsKLQlhY3BpX3N0YXR1cyByZXQ7Ci0Jc3RydWN0IGFjcGlfb2JqZWN0X2xpc3QgcGFyYW1zOwotCXVuaW9uIGFjcGlfb2JqZWN0IGlkOwogCXVuaW9uIGFjcGlfb2JqZWN0ICpwYWNrOwogCWludCBlcnI7CiAJaW50IGk7CiAKKwllcnIgPSBhdGtfZWNfcHJlc2VudChkYXRhKTsKKwlpZiAoZXJyIDwgMCkKKwkJcmV0dXJuIGVycjsKKwlpZiAoZXJyKSB7CisJCWVyciA9IGF0a19lY19lbmFibGVkKGRhdGEpOworCQlpZiAoZXJyIDwgMCkKKwkJCXJldHVybiBlcnI7CisJCS8qIElmIHRoZSBFQyB3YXMgZGlzYWJsZWQgd2Ugd2lsbCBkaXNhYmxlIGl0IGFnYWluIG9uIHVubG9hZCAqLworCQlkYXRhLT5kaXNhYmxlX2VjID0gZXJyOworCisJCWVyciA9IGF0a19lY19jdGwoZGF0YSwgMSk7CisJCWlmIChlcnIpIHsKKwkJCWRhdGEtPmRpc2FibGVfZWMgPSBmYWxzZTsKKwkJCXJldHVybiBlcnI7CisJCX0KKwl9CisKIAlkZXZfZGJnKGRldiwgIkVudW1lcmF0aW5nIGh3bW9uIHNlbnNvcnNcbiIpOwogCi0JaWQudHlwZSA9IEFDUElfVFlQRV9JTlRFR0VSOwotCWlkLmludGVnZXIudmFsdWUgPSBBVEtfTVVYX0hXTU9OOwotCXBhcmFtcy5jb3VudCA9IDE7Ci0JcGFyYW1zLnBvaW50ZXIgPSAmaWQ7Ci0KLQlidWYubGVuZ3RoID0gQUNQSV9BTExPQ0FURV9CVUZGRVI7Ci0JcmV0ID0gYWNwaV9ldmFsdWF0ZV9vYmplY3RfdHlwZWQoZGF0YS0+ZW51bWVyYXRlX2hhbmRsZSwgTlVMTCwgJnBhcmFtcywKLQkJCSZidWYsIEFDUElfVFlQRV9QQUNLQUdFKTsKLQlpZiAocmV0ICE9IEFFX09LKSB7Ci0JCWRldl93YXJuKGRldiwgTUVUSE9EX0VOVU1FUkFURSAiOiBBQ1BJIGV4Y2VwdGlvbjogJXNcbiIsCi0JCQkJYWNwaV9mb3JtYXRfZXhjZXB0aW9uKHJldCkpOwotCQlyZXR1cm4gLUVOT0RFVjsKLQl9Ci0KLQkvKiBSZXN1bHQgbXVzdCBiZSBhIHBhY2thZ2UgKi8KLQlwYWNrID0gYnVmLnBvaW50ZXI7Ci0KLQlpZiAocGFjay0+cGFja2FnZS5jb3VudCA8IDEpIHsKLQkJZGV2X2RiZyhkZXYsICIlczogaHdtb24gcGFja2FnZSBpcyB0b28gc21hbGw6ICVkXG4iLCBfX2Z1bmNfXywKLQkJCQlwYWNrLT5wYWNrYWdlLmNvdW50KTsKLQkJZXJyID0gLUVJTlZBTDsKLQkJZ290byBvdXQ7Ci0JfQorCXBhY2sgPSBhdGtfZ2dycChkYXRhLCBBVEtfTVVYX0hXTU9OKTsKKwlpZiAoSVNfRVJSKHBhY2spKQorCQlyZXR1cm4gUFRSX0VSUihwYWNrKTsKIAogCWZvciAoaSA9IDA7IGkgPCBwYWNrLT5wYWNrYWdlLmNvdW50OyBpKyspIHsKIAkJdW5pb24gYWNwaV9vYmplY3QgKm9iaiA9ICZwYWNrLT5wYWNrYWdlLmVsZW1lbnRzW2ldOwpAQCAtNzU4LDggKzk3MSw3IEBACiAKIAllcnIgPSBkYXRhLT52b2x0YWdlX2NvdW50ICsgZGF0YS0+dGVtcGVyYXR1cmVfY291bnQgKyBkYXRhLT5mYW5fY291bnQ7CiAKLW91dDoKLQlBQ1BJX0ZSRUUoYnVmLnBvaW50ZXIpOworCUFDUElfRlJFRShwYWNrKTsKIAlyZXR1cm4gZXJyOwogfQogCkBAIC04OTUsNiArMTEwNywxNSBAQAogCX0KIAlkYXRhLT5yZWFkX2hhbmRsZSA9IHJldDsKIAorCS8qIERlLW11bHRpcGxleGVyICh3cml0ZSkgKi8KKwlzdGF0dXMgPSBhY3BpX2dldF9oYW5kbGUoZGF0YS0+YXRrX2hhbmRsZSwgTUVUSE9EX1dSSVRFLCAmcmV0KTsKKwlpZiAoc3RhdHVzICE9IEFFX09LKSB7CisJCWRldl9kYmcoZGV2LCAibWV0aG9kICIgTUVUSE9EX1JFQUQgIiBub3QgZm91bmQ6ICVzXG4iLAorCQkJCSBhY3BpX2Zvcm1hdF9leGNlcHRpb24oc3RhdHVzKSk7CisJCXJldHVybiAtRU5PREVWOworCX0KKwlkYXRhLT53cml0ZV9oYW5kbGUgPSByZXQ7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtOTE1LDYgKzExMzYsNyBAQAogCWRhdGEtPmFjcGlfZGV2ID0gZGV2aWNlOwogCWRhdGEtPmF0a19oYW5kbGUgPSBkZXZpY2UtPmhhbmRsZTsKIAlJTklUX0xJU1RfSEVBRCgmZGF0YS0+c2Vuc29yX2xpc3QpOworCWRhdGEtPmRpc2FibGVfZWMgPSBmYWxzZTsKIAogCWJ1Zi5sZW5ndGggPSBBQ1BJX0FMTE9DQVRFX0JVRkZFUjsKIAlyZXQgPSBhY3BpX2V2YWx1YXRlX29iamVjdF90eXBlZChkYXRhLT5hdGtfaGFuZGxlLCBCT0FSRF9JRCwgTlVMTCwKQEAgLTk3Myw2ICsxMTk1LDggQEAKIGNsZWFudXA6CiAJYXRrX2ZyZWVfc2Vuc29ycyhkYXRhKTsKIG91dDoKKwlpZiAoZGF0YS0+ZGlzYWJsZV9lYykKKwkJYXRrX2VjX2N0bChkYXRhLCAwKTsKIAlrZnJlZShkYXRhKTsKIAlyZXR1cm4gZXJyOwogfQpAQCAtOTg4LDYgKzEyMTIsMTEgQEAKIAlhdGtfZnJlZV9zZW5zb3JzKGRhdGEpOwogCWh3bW9uX2RldmljZV91bnJlZ2lzdGVyKGRhdGEtPmh3bW9uX2Rldik7CiAKKwlpZiAoZGF0YS0+ZGlzYWJsZV9lYykgeworCQlpZiAoYXRrX2VjX2N0bChkYXRhLCAwKSkKKwkJCWRldl9lcnIoJmRldmljZS0+ZGV2LCAiRmFpbGVkIHRvIGRpc2FibGUgRUNcbiIpOworCX0KKwogCWtmcmVlKGRhdGEpOwogCiAJcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2h3bW9uL2hwX2FjY2VsLmMgYi9kcml2ZXJzL2h3bW9uL2hwX2FjY2VsLmMKaW5kZXggNjY3OTg1NC4uYmU0NzVlOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9od21vbi9ocF9hY2NlbC5jCisrKyBiL2RyaXZlcnMvaHdtb24vaHBfYWNjZWwuYwpAQCAtMTk3LDExICsxOTcsMTMgQEAKIAlBWElTX0RNSV9NQVRDSCgiSFAyMTMzIiwgIkhQIDIxMzMiLCB4eV9yb3RhdGVkX2xlZnQpLAogCUFYSVNfRE1JX01BVENIKCJIUDIxNDAiLCAiSFAgMjE0MCIsIHh5X3N3YXBfaW52ZXJ0ZWQpLAogCUFYSVNfRE1JX01BVENIKCJOQzY1M3giLCAiSFAgQ29tcGFxIDY1MyIsIHh5X3JvdGF0ZWRfbGVmdF91c2QpLAotCUFYSVNfRE1JX01BVENIKCJOQzY3M3giLCAiSFAgQ29tcGFxIDY3MyIsIHh5X3JvdGF0ZWRfbGVmdF91c2QpLAorCUFYSVNfRE1JX01BVENIKCJOQzY3MzBiIiwgIkhQIENvbXBhcSA2NzMwYiIsIHh5X3JvdGF0ZWRfbGVmdF91c2QpLAorCUFYSVNfRE1JX01BVENIKCJOQzY3MzBzIiwgIkhQIENvbXBhcSA2NzMwcyIsIHh5X3N3YXApLAogCUFYSVNfRE1JX01BVENIKCJOQzY1MXh4IiwgIkhQIENvbXBhcSA2NTEiLCB4eV9yb3RhdGVkX3JpZ2h0KSwKIAlBWElTX0RNSV9NQVRDSCgiTkM2NzEweCIsICJIUCBDb21wYXEgNjcxMCIsIHh5X3N3YXBfeXpfaW52ZXJ0ZWQpLAogCUFYSVNfRE1JX01BVENIKCJOQzY3MTV4IiwgIkhQIENvbXBhcSA2NzE1IiwgeV9pbnZlcnRlZCksCiAJQVhJU19ETUlfTUFUQ0goIk5DNjkzeHgiLCAiSFAgRWxpdGVCb29rIDY5MyIsIHh5X3JvdGF0ZWRfcmlnaHQpLAorCUFYSVNfRE1JX01BVENIKCJOQzY5M3h4IiwgIkhQIEVsaXRlQm9vayA4NTMiLCB4eV9zd2FwKSwKIAkvKiBJbnRlbC1iYXNlZCBIUCBQYXZpbGlvbiBkdjUgKi8KIAlBWElTX0RNSV9NQVRDSDIoIkhQRFY1X0kiLAogCQkJUFJPRFVDVF9OQU1FLCAiSFAgUGF2aWxpb24gZHY1IiwKQEAgLTIxNCw2ICsyMTYsNyBAQAogCQkJeV9pbnZlcnRlZCksCiAJQVhJU19ETUlfTUFUQ0goIkRWNyIsICJIUCBQYXZpbGlvbiBkdjciLCB4X2ludmVydGVkKSwKIAlBWElTX0RNSV9NQVRDSCgiSFA4NzEwIiwgIkhQIENvbXBhcSA4NzEwIiwgeV9pbnZlcnRlZCksCisJQVhJU19ETUlfTUFUQ0goIkhEWDE4IiwgIkhQIEhEWCAxOCIsIHhfaW52ZXJ0ZWQpLAogCXsgTlVMTCwgfQogLyogTGFwdG9wIG1vZGVscyB3aXRob3V0IGF4aXMgaW5mbyAoeWV0KToKICAqICJOQzY5MTAiICJIUCBDb21wYXEgNjkxMCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaHdtb24vc2h0MTUuYyBiL2RyaXZlcnMvaHdtb24vc2h0MTUuYwppbmRleCAzMDNjMDI2Li5lYmUzOGI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2h3bW9uL3NodDE1LmMKKysrIGIvZHJpdmVycy9od21vbi9zaHQxNS5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8bGludXgvaHdtb24tc3lzZnMuaD4KICNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgogI2luY2x1ZGUgPGxpbnV4L3BsYXRmb3JtX2RldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9qaWZmaWVzLmg+CiAjaW5jbHVkZSA8bGludXgvZXJyLmg+CkBAIC02MjIsNyArNjIzLDEyIEBACiB9CiAKIAotc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgc2h0X2RyaXZlcnNbXSA9IHsKKy8qCisgKiBzaHRfZHJpdmVycyBzaW11bHRhbmVvdXNseSByZWZlcnMgdG8gX19kZXZpbml0IGFuZCBfX2RldmV4aXQgZnVuY3Rpb24KKyAqIHdoaWNoIGNhdXNlcyBzcHVyaW91cyBzZWN0aW9uIG1pc21hdGNoIHdhcm5pbmcuIFNvIHVzZSBfX3JlZmRhdGEgdG8KKyAqIGdldCByaWQgZnJvbSB0aGlzLgorICovCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBfX3JlZmRhdGEgc2h0X2RyaXZlcnNbXSA9IHsKIAl7CiAJCS5kcml2ZXIgPSB7CiAJCQkubmFtZSA9ICJzaHQxMCIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lkZS9hdGlpeHAuYyBiL2RyaXZlcnMvaWRlL2F0aWl4cC5jCmluZGV4IDYzOTZjM2EuLjgzNzMyMmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaWRlL2F0aWl4cC5jCisrKyBiL2RyaXZlcnMvaWRlL2F0aWl4cC5jCkBAIC0xNzcsNyArMTc3LDcgQEAKIAl7IFBDSV9WREVWSUNFKEFUSSwgUENJX0RFVklDRV9JRF9BVElfSVhQNDAwX0lERSksIDAgfSwKIAl7IFBDSV9WREVWSUNFKEFUSSwgUENJX0RFVklDRV9JRF9BVElfSVhQNjAwX0lERSksIDEgfSwKIAl7IFBDSV9WREVWSUNFKEFUSSwgUENJX0RFVklDRV9JRF9BVElfSVhQNzAwX0lERSksIDAgfSwKLQl7IFBDSV9WREVWSUNFKEFNRCwgUENJX0RFVklDRV9JRF9BTURfU0I5MDBfSURFKSwgMCB9LAorCXsgUENJX1ZERVZJQ0UoQU1ELCBQQ0lfREVWSUNFX0lEX0FNRF9IVURTT04yX0lERSksIDAgfSwKIAl7IDAsIH0sCiB9OwogTU9EVUxFX0RFVklDRV9UQUJMRShwY2ksIGF0aWl4cF9wY2lfdGJsKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaWVlZTEzOTQvcmF3MTM5NC5jIGIvZHJpdmVycy9pZWVlMTM5NC9yYXcxMzk0LmMKaW5kZXggMGJjM2Q3OC4uOGFhNTZhYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pZWVlMTM5NC9yYXcxMzk0LmMKKysrIGIvZHJpdmVycy9pZWVlMTM5NC9yYXcxMzk0LmMKQEAgLTI5LDYgKzI5LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9mcy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pZWVlMTM5NC92aWRlbzEzOTQuYyBiL2RyaXZlcnMvaWVlZTEzOTQvdmlkZW8xMzk0LmMKaW5kZXggZDI4N2JhNy4uOTQ5MDY0YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pZWVlMTM5NC92aWRlbzEzOTQuYworKysgYi9kcml2ZXJzL2llZWUxMzk0L3ZpZGVvMTM5NC5jCkBAIC0zMCw2ICszMCw3IEBACiAgKi8KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9saXN0Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvd2FpdC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvYWRkci5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvYWRkci5jCmluZGV4IDViZTFiZDQuLmJkMDc4MDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL2FkZHIuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS9hZGRyLmMKQEAgLTM5Myw3ICszOTMsNyBAQAogCiAJCWZvcl9lYWNoX25ldGRldigmaW5pdF9uZXQsIGRldikKIAkJCWlmIChpcHY2X2Noa19hZGRyKCZpbml0X25ldCwKLQkJCQkJICAmKChzdHJ1Y3Qgc29ja2FkZHJfaW42ICopIGFkZHIpLT5zaW42X2FkZHIsCisJCQkJCSAgJigoc3RydWN0IHNvY2thZGRyX2luNiAqKSBkc3RfaW4pLT5zaW42X2FkZHIsCiAJCQkJCSAgZGV2LCAxKSkKIAkJCQlicmVhazsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvaXdjbS5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvaXdjbS5jCmluZGV4IDU1ZDA5M2EuLjBmODk5MDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL2l3Y20uYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS9pd2NtLmMKQEAgLTQwLDYgKzQwLDcgQEAKICNpbmNsdWRlIDxsaW51eC9pZHIuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9yYnRyZWUuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CiAjaW5jbHVkZSA8bGludXgvY29tcGxldGlvbi5oPgpAQCAtMzYyLDcgKzM2Myw5IEBACiAJCSAqIEluIGVpdGhlciBjYXNlLCBtdXN0IHRlbGwgdGhlIHByb3ZpZGVyIHRvIHJlamVjdC4KIAkJICovCiAJCWNtX2lkX3ByaXYtPnN0YXRlID0gSVdfQ01fU1RBVEVfREVTVFJPWUlORzsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY21faWRfcHJpdi0+bG9jaywgZmxhZ3MpOwogCQljbV9pZC0+ZGV2aWNlLT5pd2NtLT5yZWplY3QoY21faWQsIE5VTEwsIDApOworCQlzcGluX2xvY2tfaXJxc2F2ZSgmY21faWRfcHJpdi0+bG9jaywgZmxhZ3MpOwogCQlicmVhazsKIAljYXNlIElXX0NNX1NUQVRFX0NPTk5fU0VOVDoKIAljYXNlIElXX0NNX1NUQVRFX0RFU1RST1lJTkc6CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91Y21hLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvY29yZS91Y21hLmMKaW5kZXggNDM0NmEyNC4uYmI5NmQzYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2NvcmUvdWNtYS5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9jb3JlL3VjbWEuYwpAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ZpbGUuaD4KICNpbmNsdWRlIDxsaW51eC9tdXRleC5oPgogI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2lkci5oPgogI2luY2x1ZGUgPGxpbnV4L2luLmg+CiAjaW5jbHVkZSA8bGludXgvaW42Lmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvY3hnYjMvaXdjaF9wcm92aWRlci5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2N4Z2IzL2l3Y2hfcHJvdmlkZXIuYwppbmRleCA2ODk1NTIzLi5lZDcxNzU1IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvY3hnYjMvaXdjaF9wcm92aWRlci5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9jeGdiMy9pd2NoX3Byb3ZpZGVyLmMKQEAgLTM3LDYgKzM3LDcgQEAKICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9ldGh0b29sLmg+CiAjaW5jbHVkZSA8bGludXgvcnRuZXRsaW5rLmg+CkBAIC0xMTk5LDExICsxMjAwLDE0IEBACiAJCXByb3BzLT5zdGF0ZSA9IElCX1BPUlRfRE9XTjsKIAllbHNlIHsKIAkJaW5ldGRldiA9IGluX2Rldl9nZXQobmV0ZGV2KTsKLQkJaWYgKGluZXRkZXYtPmlmYV9saXN0KQotCQkJcHJvcHMtPnN0YXRlID0gSUJfUE9SVF9BQ1RJVkU7Ci0JCWVsc2UKKwkJaWYgKGluZXRkZXYpIHsKKwkJCWlmIChpbmV0ZGV2LT5pZmFfbGlzdCkKKwkJCQlwcm9wcy0+c3RhdGUgPSBJQl9QT1JUX0FDVElWRTsKKwkJCWVsc2UKKwkJCQlwcm9wcy0+c3RhdGUgPSBJQl9QT1JUX0lOSVQ7CisJCQlpbl9kZXZfcHV0KGluZXRkZXYpOworCQl9IGVsc2UKIAkJCXByb3BzLT5zdGF0ZSA9IElCX1BPUlRfSU5JVDsKLQkJaW5fZGV2X3B1dChpbmV0ZGV2KTsKIAl9CiAKIAlwcm9wcy0+cG9ydF9jYXBfZmxhZ3MgPQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2N4Z2IzL2l3Y2hfcXAuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9jeGdiMy9pd2NoX3FwLmMKaW5kZXggNmU4NjUzNC4uMWNlY2Y5OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2N4Z2IzL2l3Y2hfcXAuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvY3hnYjMvaXdjaF9xcC5jCkBAIC0yOSw2ICsyOSw3IEBACiAgKiBDT05ORUNUSU9OIFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIgREVBTElOR1MgSU4gVEhFCiAgKiBTT0ZUV0FSRS4KICAqLworI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSAiaXdjaF9wcm92aWRlci5oIgogI2luY2x1ZGUgIml3Y2guaCIKICNpbmNsdWRlICJpd2NoX2NtLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZHJpdmVyLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfZHJpdmVyLmMKaW5kZXggMDRlODhiNi4uMDEzZDEzOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2RyaXZlci5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9kcml2ZXIuYwpAQCAtMzEsNiArMzEsNyBAQAogICogU09GVFdBUkUuCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9pZHIuaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9pYmE3MjIwLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfaWJhNzIyMC5jCmluZGV4IGIyYTlkNGMuLmE4MDU0MDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9pYmE3MjIwLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2liYTcyMjAuYwpAQCAtMzcsNiArMzcsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2lvLmg+CiAjaW5jbHVkZSA8cmRtYS9pYl92ZXJicy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2ludHIuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9pbnRyLmMKaW5kZXggNmMyMWI0Yi4uYzBhMDNhYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX2ludHIuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfaW50ci5jCkBAIC0zMyw2ICszMyw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAKICNpbmNsdWRlICJpcGF0aF9rZXJuZWwuaCIKICNpbmNsdWRlICJpcGF0aF92ZXJicy5oIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3FwLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfcXAuYwppbmRleCAzYTVhODliLi5jYjJkM2VmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfcXAuYworKysgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfcXAuYwpAQCAtMzIsNiArMzIsNyBAQAogICovCiAKICNpbmNsdWRlIDxsaW51eC9lcnIuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KIAogI2luY2x1ZGUgImlwYXRoX3ZlcmJzLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfcnVjLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfcnVjLmMKaW5kZXggMjI5NjgzMi4uMWY5NWJiYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3J1Yy5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF9ydWMuYwpAQCAtMzEsNiArMzEsNyBAQAogICogU09GVFdBUkUuCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KIAogI2luY2x1ZGUgImlwYXRoX3ZlcmJzLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfdWQuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91ZC5jCmluZGV4IDYwNzZjYjYuLjc0MjA3MTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91ZC5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91ZC5jCkBAIC0zMSw2ICszMSw3IEBACiAgKiBTT0ZUV0FSRS4KICAqLwogCisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxyZG1hL2liX3NtaS5oPgogCiAjaW5jbHVkZSAiaXBhdGhfdmVyYnMuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91c2VyX3BhZ2VzLmMgYi9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfdXNlcl9wYWdlcy5jCmluZGV4IDg1NTkxMWUuLjgyODc4ZTMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91c2VyX3BhZ2VzLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3VzZXJfcGFnZXMuYwpAQCAtMzMsNiArMzMsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogCiAjaW5jbHVkZSAiaXBhdGhfa2VybmVsLmgiCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91c2VyX3NkbWEuYyBiL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF91c2VyX3NkbWEuYwppbmRleCA3YmZmNGI5Li5iZTc4ZjY2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvaHcvaXBhdGgvaXBhdGhfdXNlcl9zZG1hLmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3VzZXJfc2RtYS5jCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9kbWFwb29sLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L2hpZ2htZW0uaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5maW5pYmFuZC9ody9pcGF0aC9pcGF0aF92ZXJic19tY2FzdC5jIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3ZlcmJzX21jYXN0LmMKaW5kZXggZDczZTMyMi4uNjkyM2UxZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3ZlcmJzX21jYXN0LmMKKysrIGIvZHJpdmVycy9pbmZpbmliYW5kL2h3L2lwYXRoL2lwYXRoX3ZlcmJzX21jYXN0LmMKQEAgLTMyLDYgKzMyLDcgQEAKICAqLwogCiAjaW5jbHVkZSA8bGludXgvcmN1bGlzdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAKICNpbmNsdWRlICJpcGF0aF92ZXJicy5oIgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lzZXIvaXNjc2lfaXNlci5jIGIvZHJpdmVycy9pbmZpbmliYW5kL3VscC9pc2VyL2lzY3NpX2lzZXIuYwppbmRleCAwYmE2ZWM4Li5hZGQ5MTg4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2luZmluaWJhbmQvdWxwL2lzZXIvaXNjc2lfaXNlci5jCisrKyBiL2RyaXZlcnMvaW5maW5pYmFuZC91bHAvaXNlci9pc2NzaV9pc2VyLmMKQEAgLTQyNiw3ICs0MjYsNyBAQAogCSAqIGJlY2F1c2Ugd2UgcHJlYWxsb2NhdGUgc28gbWFueSByZXNvdXJjZXMKIAkgKi8KIAljbHNfc2Vzc2lvbiA9IGlzY3NpX3Nlc3Npb25fc2V0dXAoJmlzY3NpX2lzZXJfdHJhbnNwb3J0LCBzaG9zdCwKLQkJCQkJICBJU0NTSV9ERUZfWE1JVF9DTURTX01BWCwKKwkJCQkJICBJU0NTSV9ERUZfWE1JVF9DTURTX01BWCwgMCwKIAkJCQkJICBzaXplb2Yoc3RydWN0IGlzY3NpX2lzZXJfdGFzayksCiAJCQkJCSAgaW5pdGlhbF9jbWRzbiwgMCk7CiAJaWYgKCFjbHNfc2Vzc2lvbikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvaW5wdXQuYyBiL2RyaXZlcnMvaW5wdXQvaW5wdXQuYwppbmRleCBjNmY4OGViLi5jYzc2M2M5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2lucHV0LmMKKysrIGIvZHJpdmVycy9pbnB1dC9pbnB1dC5jCkBAIC03ODIsMTAgKzc4MiwyOSBAQAogCXJldHVybiAwOwogfQogCit1bmlvbiBpbnB1dF9zZXFfc3RhdGUgeworCXN0cnVjdCB7CisJCXVuc2lnbmVkIHNob3J0IHBvczsKKwkJYm9vbCBtdXRleF9hY3F1aXJlZDsKKwl9OworCXZvaWQgKnA7Cit9OworCiBzdGF0aWMgdm9pZCAqaW5wdXRfZGV2aWNlc19zZXFfc3RhcnQoc3RydWN0IHNlcV9maWxlICpzZXEsIGxvZmZfdCAqcG9zKQogewotCWlmIChtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmlucHV0X211dGV4KSkKLQkJcmV0dXJuIE5VTEw7CisJdW5pb24gaW5wdXRfc2VxX3N0YXRlICpzdGF0ZSA9ICh1bmlvbiBpbnB1dF9zZXFfc3RhdGUgKikmc2VxLT5wcml2YXRlOworCWludCBlcnJvcjsKKworCS8qIFdlIG5lZWQgdG8gZml0IGludG8gc2VxLT5wcml2YXRlIHBvaW50ZXIgKi8KKwlCVUlMRF9CVUdfT04oc2l6ZW9mKHVuaW9uIGlucHV0X3NlcV9zdGF0ZSkgIT0gc2l6ZW9mKHNlcS0+cHJpdmF0ZSkpOworCisJZXJyb3IgPSBtdXRleF9sb2NrX2ludGVycnVwdGlibGUoJmlucHV0X211dGV4KTsKKwlpZiAoZXJyb3IpIHsKKwkJc3RhdGUtPm11dGV4X2FjcXVpcmVkID0gZmFsc2U7CisJCXJldHVybiBFUlJfUFRSKGVycm9yKTsKKwl9CisKKwlzdGF0ZS0+bXV0ZXhfYWNxdWlyZWQgPSB0cnVlOwogCiAJcmV0dXJuIHNlcV9saXN0X3N0YXJ0KCZpbnB1dF9kZXZfbGlzdCwgKnBvcyk7CiB9CkBAIC03OTUsOSArODE0LDEyIEBACiAJcmV0dXJuIHNlcV9saXN0X25leHQodiwgJmlucHV0X2Rldl9saXN0LCBwb3MpOwogfQogCi1zdGF0aWMgdm9pZCBpbnB1dF9kZXZpY2VzX3NlcV9zdG9wKHN0cnVjdCBzZXFfZmlsZSAqc2VxLCB2b2lkICp2KQorc3RhdGljIHZvaWQgaW5wdXRfc2VxX3N0b3Aoc3RydWN0IHNlcV9maWxlICpzZXEsIHZvaWQgKnYpCiB7Ci0JbXV0ZXhfdW5sb2NrKCZpbnB1dF9tdXRleCk7CisJdW5pb24gaW5wdXRfc2VxX3N0YXRlICpzdGF0ZSA9ICh1bmlvbiBpbnB1dF9zZXFfc3RhdGUgKikmc2VxLT5wcml2YXRlOworCisJaWYgKHN0YXRlLT5tdXRleF9hY3F1aXJlZCkKKwkJbXV0ZXhfdW5sb2NrKCZpbnB1dF9tdXRleCk7CiB9CiAKIHN0YXRpYyB2b2lkIGlucHV0X3NlcV9wcmludF9iaXRtYXAoc3RydWN0IHNlcV9maWxlICpzZXEsIGNvbnN0IGNoYXIgKm5hbWUsCkBAIC04NjEsNyArODgzLDcgQEAKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgc2VxX29wZXJhdGlvbnMgaW5wdXRfZGV2aWNlc19zZXFfb3BzID0gewogCS5zdGFydAk9IGlucHV0X2RldmljZXNfc2VxX3N0YXJ0LAogCS5uZXh0CT0gaW5wdXRfZGV2aWNlc19zZXFfbmV4dCwKLQkuc3RvcAk9IGlucHV0X2RldmljZXNfc2VxX3N0b3AsCisJLnN0b3AJPSBpbnB1dF9zZXFfc3RvcCwKIAkuc2hvdwk9IGlucHV0X2RldmljZXNfc2VxX3Nob3csCiB9OwogCkBAIC04ODEsNDAgKzkwMyw0OSBAQAogCiBzdGF0aWMgdm9pZCAqaW5wdXRfaGFuZGxlcnNfc2VxX3N0YXJ0KHN0cnVjdCBzZXFfZmlsZSAqc2VxLCBsb2ZmX3QgKnBvcykKIHsKLQlpZiAobXV0ZXhfbG9ja19pbnRlcnJ1cHRpYmxlKCZpbnB1dF9tdXRleCkpCi0JCXJldHVybiBOVUxMOworCXVuaW9uIGlucHV0X3NlcV9zdGF0ZSAqc3RhdGUgPSAodW5pb24gaW5wdXRfc2VxX3N0YXRlICopJnNlcS0+cHJpdmF0ZTsKKwlpbnQgZXJyb3I7CiAKLQlzZXEtPnByaXZhdGUgPSAodm9pZCAqKSh1bnNpZ25lZCBsb25nKSpwb3M7CisJLyogV2UgbmVlZCB0byBmaXQgaW50byBzZXEtPnByaXZhdGUgcG9pbnRlciAqLworCUJVSUxEX0JVR19PTihzaXplb2YodW5pb24gaW5wdXRfc2VxX3N0YXRlKSAhPSBzaXplb2Yoc2VxLT5wcml2YXRlKSk7CisKKwllcnJvciA9IG11dGV4X2xvY2tfaW50ZXJydXB0aWJsZSgmaW5wdXRfbXV0ZXgpOworCWlmIChlcnJvcikgeworCQlzdGF0ZS0+bXV0ZXhfYWNxdWlyZWQgPSBmYWxzZTsKKwkJcmV0dXJuIEVSUl9QVFIoZXJyb3IpOworCX0KKworCXN0YXRlLT5tdXRleF9hY3F1aXJlZCA9IHRydWU7CisJc3RhdGUtPnBvcyA9ICpwb3M7CisKIAlyZXR1cm4gc2VxX2xpc3Rfc3RhcnQoJmlucHV0X2hhbmRsZXJfbGlzdCwgKnBvcyk7CiB9CiAKIHN0YXRpYyB2b2lkICppbnB1dF9oYW5kbGVyc19zZXFfbmV4dChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdiwgbG9mZl90ICpwb3MpCiB7Ci0Jc2VxLT5wcml2YXRlID0gKHZvaWQgKikodW5zaWduZWQgbG9uZykoKnBvcyArIDEpOwotCXJldHVybiBzZXFfbGlzdF9uZXh0KHYsICZpbnB1dF9oYW5kbGVyX2xpc3QsIHBvcyk7Ci19CisJdW5pb24gaW5wdXRfc2VxX3N0YXRlICpzdGF0ZSA9ICh1bmlvbiBpbnB1dF9zZXFfc3RhdGUgKikmc2VxLT5wcml2YXRlOwogCi1zdGF0aWMgdm9pZCBpbnB1dF9oYW5kbGVyc19zZXFfc3RvcChzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKLXsKLQltdXRleF91bmxvY2soJmlucHV0X211dGV4KTsKKwlzdGF0ZS0+cG9zID0gKnBvcyArIDE7CisJcmV0dXJuIHNlcV9saXN0X25leHQodiwgJmlucHV0X2hhbmRsZXJfbGlzdCwgcG9zKTsKIH0KIAogc3RhdGljIGludCBpbnB1dF9oYW5kbGVyc19zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2ZpbGUgKnNlcSwgdm9pZCAqdikKIHsKIAlzdHJ1Y3QgaW5wdXRfaGFuZGxlciAqaGFuZGxlciA9IGNvbnRhaW5lcl9vZih2LCBzdHJ1Y3QgaW5wdXRfaGFuZGxlciwgbm9kZSk7CisJdW5pb24gaW5wdXRfc2VxX3N0YXRlICpzdGF0ZSA9ICh1bmlvbiBpbnB1dF9zZXFfc3RhdGUgKikmc2VxLT5wcml2YXRlOwogCi0Jc2VxX3ByaW50ZihzZXEsICJOOiBOdW1iZXI9JWxkIE5hbWU9JXMiLAotCQkgICAodW5zaWduZWQgbG9uZylzZXEtPnByaXZhdGUsIGhhbmRsZXItPm5hbWUpOworCXNlcV9wcmludGYoc2VxLCAiTjogTnVtYmVyPSV1IE5hbWU9JXMiLCBzdGF0ZS0+cG9zLCBoYW5kbGVyLT5uYW1lKTsKIAlpZiAoaGFuZGxlci0+Zm9wcykKIAkJc2VxX3ByaW50ZihzZXEsICIgTWlub3I9JWQiLCBoYW5kbGVyLT5taW5vcik7CiAJc2VxX3B1dGMoc2VxLCAnXG4nKTsKIAogCXJldHVybiAwOwogfQorCiBzdGF0aWMgY29uc3Qgc3RydWN0IHNlcV9vcGVyYXRpb25zIGlucHV0X2hhbmRsZXJzX3NlcV9vcHMgPSB7CiAJLnN0YXJ0CT0gaW5wdXRfaGFuZGxlcnNfc2VxX3N0YXJ0LAogCS5uZXh0CT0gaW5wdXRfaGFuZGxlcnNfc2VxX25leHQsCi0JLnN0b3AJPSBpbnB1dF9oYW5kbGVyc19zZXFfc3RvcCwKKwkuc3RvcAk9IGlucHV0X3NlcV9zdG9wLAogCS5zaG93CT0gaW5wdXRfaGFuZGxlcnNfc2VxX3Nob3csCiB9OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2pveXN0aWNrL3hwYWQuYyBiL2RyaXZlcnMvaW5wdXQvam95c3RpY2sveHBhZC5jCmluZGV4IDIzODhjZjUuLjc5ZTNlZGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvam95c3RpY2sveHBhZC5jCisrKyBiL2RyaXZlcnMvaW5wdXQvam95c3RpY2sveHBhZC5jCkBAIC0xNDMsNiArMTQzLDcgQEAKIAl7IDB4MTJhYiwgMHg4ODA5LCAiWGJveCBERFIgZGFuY2VwYWQiLCBNQVBfRFBBRF9UT19CVVRUT05TLCBYVFlQRV9YQk9YIH0sCiAJeyAweDE0MzAsIDB4NDc0OCwgIlJlZE9jdGFuZSBHdWl0YXIgSGVybyBYLXBsb3JlciIsIE1BUF9EUEFEX1RPX0FYRVMsIFhUWVBFX1hCT1gzNjAgfSwKIAl7IDB4MTQzMCwgMHg4ODg4LCAiVFg2NTAwKyBEYW5jZSBQYWQgKGZpcnN0IGdlbmVyYXRpb24pIiwgTUFQX0RQQURfVE9fQlVUVE9OUywgWFRZUEVfWEJPWCB9LAorCXsgMHgxNDZiLCAweDA2MDEsICJCaWdCZW4gSW50ZXJhY3RpdmUgWEJPWCAzNjAgQ29udHJvbGxlciIsIE1BUF9EUEFEX1RPX0FYRVMsIFhUWVBFX1hCT1gzNjAgfSwKIAl7IDB4MDQ1ZSwgMHgwMjhlLCAiTWljcm9zb2Z0IFgtQm94IDM2MCBwYWQiLCBNQVBfRFBBRF9UT19BWEVTLCBYVFlQRV9YQk9YMzYwIH0sCiAJeyAweDFiYWQsIDB4MDAwMywgIkhhcm1vbml4IFJvY2sgQmFuZCBEcnVta2l0IiwgTUFQX0RQQURfVE9fQlVUVE9OUywgWFRZUEVfWEJPWDM2MCB9LAogCXsgMHhmZmZmLCAweGZmZmYsICJDaGluZXNlLW1hZGUgWGJveCBDb250cm9sbGVyIiwgTUFQX0RQQURfVE9fQVhFUywgWFRZUEVfWEJPWCB9LApAQCAtMjA5LDYgKzIxMCw3IEBACiAJWFBBRF9YQk9YMzYwX1ZFTkRPUigweDA3MzgpLAkJLyogTWFkIENhdHogWC1Cb3ggMzYwIGNvbnRyb2xsZXJzICovCiAJWFBBRF9YQk9YMzYwX1ZFTkRPUigweDBlNmYpLAkJLyogMHgwZTZmIFgtQm94IDM2MCBjb250cm9sbGVycyAqLwogCVhQQURfWEJPWDM2MF9WRU5ET1IoMHgxNDMwKSwJCS8qIFJlZE9jdGFuZSBYLUJveCAzNjAgY29udHJvbGxlcnMgKi8KKwlYUEFEX1hCT1gzNjBfVkVORE9SKDB4MTQ2YiksCQkvKiBCaWdCZW4gSW50ZXJhY3RpdmUgQ29udHJvbGxlcnMgKi8KIAlYUEFEX1hCT1gzNjBfVkVORE9SKDB4MWJhZCksCQkvKiBSb2NrIEJhbmQgRHJ1bXMgKi8KIAl7IH0KIH07CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2F0a2JkLmMgYi9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2F0a2JkLmMKaW5kZXggNDcwOWUxNS4uYTY1MTIzNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9hdGtiZC5jCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvYXRrYmQuYwpAQCAtNTc0LDExICs1NzQsMjIgQEAKIAogCW11dGV4X2xvY2soJmF0a2JkLT5ldmVudF9tdXRleCk7CiAKLQlpZiAodGVzdF9hbmRfY2xlYXJfYml0KEFUS0JEX0xFRF9FVkVOVF9CSVQsICZhdGtiZC0+ZXZlbnRfbWFzaykpCi0JCWF0a2JkX3NldF9sZWRzKGF0a2JkKTsKKwlpZiAoIWF0a2JkLT5lbmFibGVkKSB7CisJCS8qCisJCSAqIFNlcmlvIHBvcnRzIGFyZSByZXN1bWVkIGFzeW5jaHJvbm91c2x5IHNvIHdoaWxlIGRyaXZlciBjb3JlCisJCSAqIHRoaW5rcyB0aGF0IGRldmljZSBpcyBhbHJlYWR5IGZ1bGx5IG9wZXJhdGlvbmFsIGluIHJlYWxpdHkKKwkJICogaXQgbWF5IG5vdCBiZSByZWFkeSB5ZXQuIEluIHRoaXMgY2FzZSB3ZSBuZWVkIHRvIGtlZXAKKwkJICogcmVzY2hlZHVsaW5nIHRpbGwgcmVjb25uZWN0IGNvbXBsZXRlcy4KKwkJICovCisJCXNjaGVkdWxlX2RlbGF5ZWRfd29yaygmYXRrYmQtPmV2ZW50X3dvcmssCisJCQkJCW1zZWNzX3RvX2ppZmZpZXMoMTAwKSk7CisJfSBlbHNlIHsKKwkJaWYgKHRlc3RfYW5kX2NsZWFyX2JpdChBVEtCRF9MRURfRVZFTlRfQklULCAmYXRrYmQtPmV2ZW50X21hc2spKQorCQkJYXRrYmRfc2V0X2xlZHMoYXRrYmQpOwogCi0JaWYgKHRlc3RfYW5kX2NsZWFyX2JpdChBVEtCRF9SRVBfRVZFTlRfQklULCAmYXRrYmQtPmV2ZW50X21hc2spKQotCQlhdGtiZF9zZXRfcmVwZWF0X3JhdGUoYXRrYmQpOworCQlpZiAodGVzdF9hbmRfY2xlYXJfYml0KEFUS0JEX1JFUF9FVkVOVF9CSVQsICZhdGtiZC0+ZXZlbnRfbWFzaykpCisJCQlhdGtiZF9zZXRfcmVwZWF0X3JhdGUoYXRrYmQpOworCX0KIAogCW11dGV4X3VubG9jaygmYXRrYmQtPmV2ZW50X211dGV4KTsKIH0KQEAgLTc3MCw2ICs3ODEsMzAgQEAKIAlyZXR1cm4gMzsKIH0KIAorc3RhdGljIGludCBhdGtiZF9yZXNldF9zdGF0ZShzdHJ1Y3QgYXRrYmQgKmF0a2JkKQoreworICAgICAgICBzdHJ1Y3QgcHMyZGV2ICpwczJkZXYgPSAmYXRrYmQtPnBzMmRldjsKKwl1bnNpZ25lZCBjaGFyIHBhcmFtWzFdOworCisvKgorICogU2V0IHRoZSBMRURzIHRvIGEgcHJlZGVmaW5lZCBzdGF0ZSAoYWxsIG9mZikuCisgKi8KKworCXBhcmFtWzBdID0gMDsKKwlpZiAocHMyX2NvbW1hbmQocHMyZGV2LCBwYXJhbSwgQVRLQkRfQ01EX1NFVExFRFMpKQorCQlyZXR1cm4gLTE7CisKKy8qCisgKiBTZXQgYXV0b3JlcGVhdCB0byBmYXN0ZXN0IHBvc3NpYmxlLgorICovCisKKwlwYXJhbVswXSA9IDA7CisJaWYgKHBzMl9jb21tYW5kKHBzMmRldiwgcGFyYW0sIEFUS0JEX0NNRF9TRVRSRVApKQorCQlyZXR1cm4gLTE7CisKKwlyZXR1cm4gMDsKK30KKwogc3RhdGljIGludCBhdGtiZF9hY3RpdmF0ZShzdHJ1Y3QgYXRrYmQgKmF0a2JkKQogewogCXN0cnVjdCBwczJkZXYgKnBzMmRldiA9ICZhdGtiZC0+cHMyZGV2OwpAQCAtODUyLDI5ICs4ODcsNiBAQAogfTsKIAogLyoKLSAqIEludmVudGVjIHN5c3RlbSB3aXRoIGJyb2tlbiBrZXkgcmVsZWFzZSBvbiB2b2x1bWUga2V5cwotICovCi1zdGF0aWMgdW5zaWduZWQgaW50IGF0a2JkX2ludmVudGVjX2ZvcmNlZF9yZWxlYXNlX2tleXNbXSA9IHsKLQkweGFlLCAweGIwLCAtMVUKLX07Ci0KLS8qCi0gKiBQZXJmb3JtIGZpeHVwIGZvciBIUCBQYXZpbGlvbiBaVjYxMDAgbGFwdG9wIHRoYXQgZG9lc24ndCBnZW5lcmF0ZSByZWxlYXNlCi0gKiBmb3IgaXRzIHZvbHVtZSBidXR0b25zCi0gKi8KLXN0YXRpYyB1bnNpZ25lZCBpbnQgYXRrYmRfaHBfenY2MTAwX2ZvcmNlZF9yZWxlYXNlX2tleXNbXSA9IHsKLQkweGFlLCAweGIwLCAtMVUKLX07Ci0KLS8qCi0gKiBQZXJmb3JtIGZpeHVwIGZvciBIUCAoQ29tcGFxKSBQcmVzYXJpbyBSNDAwMCBSNDEwMCBSNDIwMCB0aGF0IGRvbid0IGdlbmVyYXRlCi0gKiByZWxlYXNlIGZvciB0aGVpciB2b2x1bWUgYnV0dG9ucwotICovCi1zdGF0aWMgdW5zaWduZWQgaW50IGF0a2JkX2hwX3I0MDAwX2ZvcmNlZF9yZWxlYXNlX2tleXNbXSA9IHsKLQkweGFlLCAweGIwLCAtMVUKLX07Ci0KLS8qCiAgKiBTYW1zdW5nIE5DMTAsTkMyMCB3aXRoIEZuK0Y/IGtleSByZWxlYXNlIG5vdCB3b3JraW5nCiAgKi8KIHN0YXRpYyB1bnNpZ25lZCBpbnQgYXRrYmRfc2Ftc3VuZ19mb3JjZWRfcmVsZWFzZV9rZXlzW10gPSB7CkBAIC04ODIsMTQgKzg5NCw2IEBACiB9OwogCiAvKgotICogVGhlIHZvbHVtZSB1cCBhbmQgdm9sdW1lIGRvd24gc3BlY2lhbCBrZXlzIG9uIGEgRnVqaXRzdSBBbWlsbyBQQSAxNTEwIGxhcHRvcAotICogZG8gbm90IGdlbmVyYXRlIHJlbGVhc2UgZXZlbnRzIHNvIHdlIGhhdmUgdG8gZG8gaXQgb3Vyc2VsdmVzLgotICovCi1zdGF0aWMgdW5zaWduZWQgaW50IGF0a2JkX2FtaWxvX3BhMTUxMF9mb3JjZWRfcmVsZWFzZV9rZXlzW10gPSB7Ci0JMHhiMCwgMHhhZSwgLTFVCi19OwotCi0vKgogICogQW1pbG8gUGkgMzUyNSBrZXkgcmVsZWFzZSBmb3IgRm4rVm9sdW1lIGtleXMgbm90IHdvcmtpbmcKICAqLwogc3RhdGljIHVuc2lnbmVkIGludCBhdGtiZF9hbWlsb19waTM1MjVfZm9yY2VkX3JlbGVhc2Vfa2V5c1tdID0gewpAQCAtOTExLDYgKzkxNSwxNCBAQAogfTsKIAogLyoKKyAqIE1hbnkgbm90ZWJvb2tzIGRvbid0IHNlbmQga2V5IHJlbGVhc2UgZXZlbnQgZm9yIHZvbHVtZSB1cC9kb3duCisgKiBrZXlzLCB3aXRoIGtleSBsaXN0IGJlbG93IGNvbW1vbiBhbW9uZyB0aGVtCisgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQgYXRrYmRfdm9sdW1lX2ZvcmNlZF9yZWxlYXNlX2tleXNbXSA9IHsKKwkweGFlLCAweGIwLCAtMVUKK307CisKKy8qCiAgKiBhdGtiZF9zZXRfa2V5Y29kZV90YWJsZSgpIGluaXRpYWxpemVzIGtleWJvYXJkJ3Mga2V5Y29kZSB0YWJsZQogICogYWNjb3JkaW5nIHRvIHRoZSBzZWxlY3RlZCBzY2FuY29kZSBzZXQKICAqLwpAQCAtMTA4Nyw2ICsxMDk5LDcgQEAKIAkJfQogCiAJCWF0a2JkLT5zZXQgPSBhdGtiZF9zZWxlY3Rfc2V0KGF0a2JkLCBhdGtiZF9zZXQsIGF0a2JkX2V4dHJhKTsKKwkJYXRrYmRfcmVzZXRfc3RhdGUoYXRrYmQpOwogCQlhdGtiZF9hY3RpdmF0ZShhdGtiZCk7CiAKIAl9IGVsc2UgewpAQCAtMTI2Nyw2ICsxMjgwLDcgQEAKIAogCQlhdGtiZC0+ZGV2ID0gbmV3X2RldjsKIAkJYXRrYmQtPnNldCA9IGF0a2JkX3NlbGVjdF9zZXQoYXRrYmQsIGF0a2JkLT5zZXQsIHZhbHVlKTsKKwkJYXRrYmRfcmVzZXRfc3RhdGUoYXRrYmQpOwogCQlhdGtiZF9hY3RpdmF0ZShhdGtiZCk7CiAJCWF0a2JkX3NldF9rZXljb2RlX3RhYmxlKGF0a2JkKTsKIAkJYXRrYmRfc2V0X2RldmljZV9hdHRycyhhdGtiZCk7CkBAIC0xNTQ4LDcgKzE1NjIsNyBAQAogCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJQYXZpbGlvbiBaVjYxMDAiKSwKIAkJfSwKIAkJLmNhbGxiYWNrID0gYXRrYmRfc2V0dXBfZm9yY2VkX3JlbGVhc2UsCi0JCS5kcml2ZXJfZGF0YSA9IGF0a2JkX2hwX3p2NjEwMF9mb3JjZWRfcmVsZWFzZV9rZXlzLAorCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF92b2x1bWVfZm9yY2VkX3JlbGVhc2Vfa2V5cywKIAl9LAogCXsKIAkJLmlkZW50ID0gIkhQIFByZXNhcmlvIFI0MDAwIiwKQEAgLTE1NTcsNyArMTU3MSw3IEBACiAJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlByZXNhcmlvIFI0MDAwIiksCiAJCX0sCiAJCS5jYWxsYmFjayA9IGF0a2JkX3NldHVwX2ZvcmNlZF9yZWxlYXNlLAotCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF9ocF9yNDAwMF9mb3JjZWRfcmVsZWFzZV9rZXlzLAorCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF92b2x1bWVfZm9yY2VkX3JlbGVhc2Vfa2V5cywKIAl9LAogCXsKIAkJLmlkZW50ID0gIkhQIFByZXNhcmlvIFI0MTAwIiwKQEAgLTE1NjYsNyArMTU4MCw3IEBACiAJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlByZXNhcmlvIFI0MTAwIiksCiAJCX0sCiAJCS5jYWxsYmFjayA9IGF0a2JkX3NldHVwX2ZvcmNlZF9yZWxlYXNlLAotCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF9ocF9yNDAwMF9mb3JjZWRfcmVsZWFzZV9rZXlzLAorCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF92b2x1bWVfZm9yY2VkX3JlbGVhc2Vfa2V5cywKIAl9LAogCXsKIAkJLmlkZW50ID0gIkhQIFByZXNhcmlvIFI0MjAwIiwKQEAgLTE1NzUsNyArMTU4OSw3IEBACiAJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlByZXNhcmlvIFI0MjAwIiksCiAJCX0sCiAJCS5jYWxsYmFjayA9IGF0a2JkX3NldHVwX2ZvcmNlZF9yZWxlYXNlLAotCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF9ocF9yNDAwMF9mb3JjZWRfcmVsZWFzZV9rZXlzLAorCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF92b2x1bWVfZm9yY2VkX3JlbGVhc2Vfa2V5cywKIAl9LAogCXsKIAkJLmlkZW50ID0gIkludmVudGVjIFN5bXBob255IiwKQEAgLTE1ODQsNyArMTU5OCw3IEBACiAJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIlNZTVBIT05ZIDYuMC83LjAiKSwKIAkJfSwKIAkJLmNhbGxiYWNrID0gYXRrYmRfc2V0dXBfZm9yY2VkX3JlbGVhc2UsCi0JCS5kcml2ZXJfZGF0YSA9IGF0a2JkX2ludmVudGVjX2ZvcmNlZF9yZWxlYXNlX2tleXMsCisJCS5kcml2ZXJfZGF0YSA9IGF0a2JkX3ZvbHVtZV9mb3JjZWRfcmVsZWFzZV9rZXlzLAogCX0sCiAJewogCQkuaWRlbnQgPSAiU2Ftc3VuZyBOQzEwIiwKQEAgLTE2MjAsNyArMTYzNCw3IEBACiAJCQlETUlfTUFUQ0goRE1JX1BST0RVQ1RfTkFNRSwgIkFNSUxPIFBhIDE1MTAiKSwKIAkJfSwKIAkJLmNhbGxiYWNrID0gYXRrYmRfc2V0dXBfZm9yY2VkX3JlbGVhc2UsCi0JCS5kcml2ZXJfZGF0YSA9IGF0a2JkX2FtaWxvX3BhMTUxMF9mb3JjZWRfcmVsZWFzZV9rZXlzLAorCQkuZHJpdmVyX2RhdGEgPSBhdGtiZF92b2x1bWVfZm9yY2VkX3JlbGVhc2Vfa2V5cywKIAl9LAogCXsKIAkJLmlkZW50ID0gIkZ1aml0c3UgQW1pbG8gUGkgMzUyNSIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2hpbGtiZC5jIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9oaWxrYmQuYwppbmRleCBlOWQ2MzllLi41ZjcyNDQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL2hpbGtiZC5jCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvaGlsa2JkLmMKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9oaWwuaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxhc20vaXJxLmg+CiAjaWZkZWYgQ09ORklHX0hQMzAwCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL3N1bmtiZC5jIGIvZHJpdmVycy9pbnB1dC9rZXlib2FyZC9zdW5rYmQuYwppbmRleCA0NzJiNTY2Li5hOTlhMDRiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L2tleWJvYXJkL3N1bmtiZC5jCisrKyBiL2RyaXZlcnMvaW5wdXQva2V5Ym9hcmQvc3Vua2JkLmMKQEAgLTI3LDYgKzI3LDcgQEAKICAqLwogCiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbWlzYy9ocF9zZGNfcnRjLmMgYi9kcml2ZXJzL2lucHV0L21pc2MvaHBfc2RjX3J0Yy5jCmluZGV4IDIxNmE1NTkuLmVhODIxYjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbWlzYy9ocF9zZGNfcnRjLmMKKysrIGIvZHJpdmVycy9pbnB1dC9taXNjL2hwX3NkY19ydGMuYwpAQCAtMjA5LDcgKzIwOSw3IEBACiAKIC8qIFJlYWQgdGhlIGk4MDQyIGZhc3QgaGFuZHNoYWtlIHRpbWVyICovCiBzdGF0aWMgaW5saW5lIGludCBocF9zZGNfcnRjX3JlYWRfZmhzKHN0cnVjdCB0aW1ldmFsICpyZXMpIHsKLQl1aW50NjRfdCByYXc7CisJaW50NjRfdCByYXc7CiAJdW5zaWduZWQgaW50IHRlbm1zOwogCiAJcmF3ID0gaHBfc2RjX3J0Y19yZWFkX2k4MDQydGltZXIoSFBfU0RDX0NNRF9MT0FEX0ZIUywgMik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L21pc2Mvcm90YXJ5X2VuY29kZXIuYyBiL2RyaXZlcnMvaW5wdXQvbWlzYy9yb3RhcnlfZW5jb2Rlci5jCmluZGV4IGM4MDZmYmYuLjNiOWY1ODggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbWlzYy9yb3RhcnlfZW5jb2Rlci5jCisrKyBiL2RyaXZlcnMvaW5wdXQvbWlzYy9yb3RhcnlfZW5jb2Rlci5jCkBAIC0xMDYsOCArMTA2LDggQEAKIAlzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dDsKIAlpbnQgZXJyOwogCi0JaWYgKCFwZGF0YSB8fCAhcGRhdGEtPnN0ZXBzKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImludmFsaWQgcGxhdGZvcm0gZGF0YVxuIik7CisJaWYgKCFwZGF0YSkgeworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJtaXNzaW5nIHBsYXRmb3JtIGRhdGFcbiIpOwogCQlyZXR1cm4gLUVOT0VOVDsKIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbWlzYy9zcGFyY3Nwa3IuYyBiL2RyaXZlcnMvaW5wdXQvbWlzYy9zcGFyY3Nwa3IuYwppbmRleCBjNGY0MjMxLi5iMDY0NDE5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L21pc2Mvc3BhcmNzcGtyLmMKKysrIGIvZHJpdmVycy9pbnB1dC9taXNjL3NwYXJjc3Brci5jCkBAIC0yMzAsNyArMjMwLDcgQEAKIAlyZXR1cm4gZXJyOwogfQogCi1zdGF0aWMgaW50IGJiY19yZW1vdmUoc3RydWN0IG9mX2RldmljZSAqb3ApCitzdGF0aWMgaW50IF9fZGV2ZXhpdCBiYmNfcmVtb3ZlKHN0cnVjdCBvZl9kZXZpY2UgKm9wKQogewogCXN0cnVjdCBzcGFyY3Nwa3Jfc3RhdGUgKnN0YXRlID0gZGV2X2dldF9kcnZkYXRhKCZvcC0+ZGV2KTsKIAlzdHJ1Y3QgaW5wdXRfZGV2ICppbnB1dF9kZXYgPSBzdGF0ZS0+aW5wdXRfZGV2OwpAQCAtMzA4LDcgKzMwOCw3IEBACiAJcmV0dXJuIGVycjsKIH0KIAotc3RhdGljIGludCBncm92ZXJfcmVtb3ZlKHN0cnVjdCBvZl9kZXZpY2UgKm9wKQorc3RhdGljIGludCBfX2RldmV4aXQgZ3JvdmVyX3JlbW92ZShzdHJ1Y3Qgb2ZfZGV2aWNlICpvcCkKIHsKIAlzdHJ1Y3Qgc3BhcmNzcGtyX3N0YXRlICpzdGF0ZSA9IGRldl9nZXRfZHJ2ZGF0YSgmb3AtPmRldik7CiAJc3RydWN0IGdyb3Zlcl9iZWVwX2luZm8gKmluZm8gPSAmc3RhdGUtPnUuZ3JvdmVyOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9taXNjL3dpc3Ryb25fYnRucy5jIGIvZHJpdmVycy9pbnB1dC9taXNjL3dpc3Ryb25fYnRucy5jCmluZGV4IDExZmQwMzguLmE5MzIxNzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbWlzYy93aXN0cm9uX2J0bnMuYworKysgYi9kcml2ZXJzL2lucHV0L21pc2Mvd2lzdHJvbl9idG5zLmMKQEAgLTkzNiw2ICs5MzYsMTUgQEAKIAl9LAogCXsKIAkJLmNhbGxiYWNrID0gZG1pX21hdGNoZWQsCisJCS5pZGVudCA9ICJNZWRpb24gTUQgNDIyMDAiLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIk1lZGlvbiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJXSU0gMjAzMCIpLAorCQl9LAorCQkuZHJpdmVyX2RhdGEgPSBrZXltYXBfZnNfYW1pbG9fcHJvX3YyMDAwCisJfSwKKwl7CisJCS5jYWxsYmFjayA9IGRtaV9tYXRjaGVkLAogCQkuaWRlbnQgPSAiTWVkaW9uIE1EIDk2NTAwIiwKIAkJLm1hdGNoZXMgPSB7CiAJCQlETUlfTUFUQ0goRE1JX1NZU19WRU5ET1IsICJNRURJT05QQyIpLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9tb3VzZS9sb2dpcHMycHAuYyBiL2RyaXZlcnMvaW5wdXQvbW91c2UvbG9naXBzMnBwLmMKaW5kZXggZGU3NDVkNy4uYWI1ZGM1ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pbnB1dC9tb3VzZS9sb2dpcHMycHAuYworKysgYi9kcml2ZXJzL2lucHV0L21vdXNlL2xvZ2lwczJwcC5jCkBAIC0yMTksNyArMjE5LDcgQEAKIAkJCQlQUzJQUF9XSEVFTCB8IFBTMlBQX1NJREVfQlROIHwgUFMyUFBfVEFTS19CVE4gfAogCQkJCVBTMlBQX0VYVFJBX0JUTiB8IFBTMlBQX05BVl9CVE4gfCBQUzJQUF9IV0hFRUwgfSwKIAkJeyA3MiwJUFMyUFBfS0lORF9UUkFDS01BTiwJMCB9LAkJCS8qIFQtQ0gxMTogVHJhY2tNYW4gTWFyYmxlICovCi0JCXsgNzMsCTAsCQkJUFMyUFBfU0lERV9CVE4gfSwKKwkJeyA3MywJUFMyUFBfS0lORF9UUkFDS01BTiwJUFMyUFBfU0lERV9CVE4gfSwJLyogVHJhY2tNYW4gRlggKi8KIAkJeyA3NSwJUFMyUFBfS0lORF9XSEVFTCwJUFMyUFBfV0hFRUwgfSwKIAkJeyA3NiwJUFMyUFBfS0lORF9XSEVFTCwJUFMyUFBfV0hFRUwgfSwKIAkJeyA3OSwJUFMyUFBfS0lORF9UUkFDS01BTiwJUFMyUFBfV0hFRUwgfSwJCS8qIFRyYWNrTWFuIHdpdGggd2hlZWwgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvbW91c2Uvc3luYXB0aWNzLmMgYi9kcml2ZXJzL2lucHV0L21vdXNlL3N5bmFwdGljcy5jCmluZGV4IGI2NmZmMWEuLmY0YTYxMjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvbW91c2Uvc3luYXB0aWNzLmMKKysrIGIvZHJpdmVycy9pbnB1dC9tb3VzZS9zeW5hcHRpY3MuYwpAQCAtNjUyLDYgKzY1MiwxNiBAQAogCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiVE9TSElCQSIpLAogCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJQT1JURUdFIE0zMDAiKSwKIAkJfSwKKworCX0sCisJeworCQkuaWRlbnQgPSAiVG9zaGliYSBQb3J0ZWdlIE0zMDAiLAorCQkubWF0Y2hlcyA9IHsKKwkJCURNSV9NQVRDSChETUlfU1lTX1ZFTkRPUiwgIlRPU0hJQkEiKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9OQU1FLCAiUG9ydGFibGUgUEMiKSwKKwkJCURNSV9NQVRDSChETUlfUFJPRFVDVF9WRVJTSU9OLCAiVmVyc2lvbiAxLjAiKSwKKwkJfSwKKwogCX0sCiAJeyB9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9zZXJpby9LY29uZmlnIGIvZHJpdmVycy9pbnB1dC9zZXJpby9LY29uZmlnCmluZGV4IGM0YjNmYmQuLmFhNTMzY2UgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vS2NvbmZpZworKysgYi9kcml2ZXJzL2lucHV0L3NlcmlvL0tjb25maWcKQEAgLTQsNyArNCw3IEBACiBjb25maWcgU0VSSU8KIAl0cmlzdGF0ZSAiU2VyaWFsIEkvTyBzdXBwb3J0IiBpZiBFTUJFRERFRCB8fCAhWDg2CiAJZGVmYXVsdCB5Ci0JLS0taGVscC0tLQorCWhlbHAKIAkgIFNheSBZZXMgaGVyZSBpZiB5b3UgaGF2ZSBhbnkgaW5wdXQgZGV2aWNlIHRoYXQgdXNlcyBzZXJpYWwgSS9PIHRvCiAJICBjb21tdW5pY2F0ZSB3aXRoIHRoZSBzeXN0ZW0uIFRoaXMgaW5jbHVkZXMgdGhlCiAJICAJCSogc3RhbmRhcmQgQVQga2V5Ym9hcmQgYW5kIFBTLzIgbW91c2UgKgpAQCAtMjIsNyArMjIsNyBAQAogCXRyaXN0YXRlICJpODA0MiBQQyBLZXlib2FyZCBjb250cm9sbGVyIiBpZiBFTUJFRERFRCB8fCAhWDg2CiAJZGVmYXVsdCB5CiAJZGVwZW5kcyBvbiAhUEFSSVNDICYmICghQVJNIHx8IEFSQ0hfU0hBUksgfHwgRk9PVEJSSURHRV9IT1NUKSAmJiAhTTY4SyAmJiAhQkxBQ0tGSU4KLQktLS1oZWxwLS0tCisJaGVscAogCSAgaTgwNDIgaXMgdGhlIGNoaXAgb3ZlciB3aGljaCB0aGUgc3RhbmRhcmQgQVQga2V5Ym9hcmQgYW5kIFBTLzIKIAkgIG1vdXNlIGFyZSBjb25uZWN0ZWQgdG8gdGhlIGNvbXB1dGVyLiBJZiB5b3UgdXNlIHRoZXNlIGRldmljZXMsCiAJICB5b3UnbGwgbmVlZCB0byBzYXkgWSBoZXJlLgpAQCAtMzUsNyArMzUsNyBAQAogY29uZmlnIFNFUklPX1NFUlBPUlQKIAl0cmlzdGF0ZSAiU2VyaWFsIHBvcnQgbGluZSBkaXNjaXBsaW5lIgogCWRlZmF1bHQgeQotCS0tLWhlbHAtLS0KKwloZWxwCiAJICBTYXkgWSBoZXJlIGlmIHlvdSBwbGFuIHRvIHVzZSBhbiBpbnB1dCBkZXZpY2UgKG1vdXNlLCBqb3lzdGljaywKIAkgIHRhYmxldCwgNmRvZikgdGhhdCBjb21tdW5pY2F0ZXMgb3ZlciB0aGUgUlMyMzIgc2VyaWFsIChDT00pIHBvcnQuCiAKQEAgLTQ5LDcgKzQ5LDcgQEAKIGNvbmZpZyBTRVJJT19DVDgyQzcxMAogCXRyaXN0YXRlICJjdDgyYzcxMCBBdXggcG9ydCBjb250cm9sbGVyIgogCWRlcGVuZHMgb24gWDg2Ci0JLS0taGVscC0tLQorCWhlbHAKIAkgIFNheSBZIGhlcmUgaWYgeW91IGhhdmUgYSBUZXhhcyBJbnN0cnVtZW50cyBUcmF2ZWxNYXRlIG5vdGVib29rCiAJICBlcXVpcHBlZCB3aXRoIHRoZSBjdDgyYzcxMCBjaGlwIGFuZCB3YW50IHRvIHVzZSBhIG1vdXNlIGNvbm5lY3RlZAogCSAgdG8gdGhlICJRdWlja1BvcnQiLgpAQCAtNjYsNyArNjYsNyBAQAogY29uZmlnIFNFUklPX1BBUktCRAogCXRyaXN0YXRlICJQYXJhbGxlbCBwb3J0IGtleWJvYXJkIGFkYXB0ZXIiCiAJZGVwZW5kcyBvbiBQQVJQT1JUCi0JLS0taGVscC0tLQorCWhlbHAKIAkgIFNheSBZIGhlcmUgaWYgeW91IGJ1aWx0IGEgc2ltcGxlIHBhcmFsbGVsIHBvcnQgYWRhcHRlciB0byBhdHRhY2gKIAkgIGFuIGFkZGl0aW9uYWwgQVQga2V5Ym9hcmQsIFhUIGtleWJvYXJkIG9yIFBTLzIgbW91c2UuCiAKQEAgLTEyNCw3ICsxMjQsNyBAQAogCXRyaXN0YXRlICJIUCBTeXN0ZW0gRGV2aWNlIENvbnRyb2xsZXIgaTgwNDIgU3VwcG9ydCIKIAlkZXBlbmRzIG9uIChHU0MgfHwgSFAzMDApICYmIFNFUklPCiAJZGVmYXVsdCB5Ci0JLS0taGVscC0tLQorCWhlbHAKIAkgIFRoaXMgb3B0aW9uIGVuYWJsZXMgc3VwcG9ydCBmb3IgdGhlICJTeXN0ZW0gRGV2aWNlCiAJICBDb250cm9sbGVyIiwgYW4gaTgwNDIgY2FycnlpbmcgbWljcm9jb2RlIHRvIG1hbmFnZSBhCiAJICBmZXcgbWlzY2VsbGFuZW91cyBkZXZpY2VzIG9uIHNvbWUgSGV3bGV0dCBQYWNrYXJkIHN5c3RlbXMuCkBAIC0xNjgsNiArMTY4LDcgQEAKIAogY29uZmlnIFNFUklPX0xJQlBTMgogCXRyaXN0YXRlICJQUy8yIGRyaXZlciBsaWJyYXJ5IiBpZiBFTUJFRERFRAorCWRlcGVuZHMgb24gU0VSSU9fSTgwNDIgfHwgU0VSSU9fSTgwNDI9bgogCWhlbHAKIAkgIFNheSBZIGhlcmUgaWYgeW91IGFyZSB1c2luZyBhIGRyaXZlciBmb3IgZGV2aWNlIGNvbm5lY3RlZAogCSAgdG8gYSBQUy8yIHBvcnQsIHN1Y2ggYXMgUFMvMiBtb3VzZSBvciBzdGFuZGFyZCBBVCBrZXlib2FyZC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vaTgwNDIteDg2aWE2NGlvLmggYi9kcml2ZXJzL2lucHV0L3NlcmlvL2k4MDQyLXg4NmlhNjRpby5oCmluZGV4IGEzOWJjNGUuLmE1Mzc5MjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vaTgwNDIteDg2aWE2NGlvLmgKKysrIGIvZHJpdmVycy9pbnB1dC9zZXJpby9pODA0Mi14ODZpYTY0aW8uaApAQCAtMzI3LDYgKzMyNywxNyBAQAogCQl9LAogCX0sCiAJeworCQkvKgorCQkgKiBSZXNldCBhbmQgR0VUIElEIGNvbW1hbmRzIGlzc3VlZCB2aWEgS0JEIHBvcnQgYXJlCisJCSAqIHNvbWV0aW1lcyBiZWluZyBkZWxpdmVyZWQgdG8gQVVYMy4KKwkJICovCisJCS5pZGVudCA9ICJTb255IFZhaW8gRlotMjQwRSIsCisJCS5tYXRjaGVzID0geworCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiU29ueSBDb3Jwb3JhdGlvbiIpLAorCQkJRE1JX01BVENIKERNSV9QUk9EVUNUX05BTUUsICJWR04tRloyNDBFIiksCisJCX0sCisJfSwKKwl7CiAJCS5pZGVudCA9ICJBbW9pIE02MzYvQTczNyIsCiAJCS5tYXRjaGVzID0gewogCQkJRE1JX01BVENIKERNSV9TWVNfVkVORE9SLCAiQW1vaSBFbGVjdHJvbmljcyBDTy4sTFRELiIpLApAQCAtNjYxLDcgKzY3Miw3IEBACiBzdGF0aWMgaW50IF9faW5pdCBpODA0Ml9wbnBfaW5pdCh2b2lkKQogewogCWNoYXIga2JkX2lycV9zdHJbNF0gPSB7IDAgfSwgYXV4X2lycV9zdHJbNF0gPSB7IDAgfTsKLQlpbnQgcG5wX2RhdGFfYnVzdGVkID0gZmFsc2U7CisJYm9vbCBwbnBfZGF0YV9idXN0ZWQgPSBmYWxzZTsKIAlpbnQgZXJyOwogCiAjaWZkZWYgQ09ORklHX1g4NgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9zZXJpby9pODA0Mi5jIGIvZHJpdmVycy9pbnB1dC9zZXJpby9pODA0Mi5jCmluZGV4IGJjNTZlNTIuLmEzMTU3ODEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vaTgwNDIuYworKysgYi9kcml2ZXJzL2lucHV0L3NlcmlvL2k4MDQyLmMKQEAgLTYwOSw2ICs2MDksOCBAQAogCXN0ciA9IGk4MDQyX3JlYWRfc3RhdHVzKCk7CiAJaWYgKHN0ciAmIEk4MDQyX1NUUl9PQkYpIHsKIAkJZGF0YSA9IGk4MDQyX3JlYWRfZGF0YSgpOworCQlkYmcoIiUwMnggPC0gaTgwNDIgKGF1eF90ZXN0X2lycSwgJXMpIiwKKwkJCWRhdGEsIHN0ciAmIEk4MDQyX1NUUl9BVVhEQVRBID8gImF1eCIgOiAia2JkIik7CiAJCWlmIChpODA0Ml9pcnFfYmVpbmdfdGVzdGVkICYmCiAJCSAgICBkYXRhID09IDB4YTUgJiYgKHN0ciAmIEk4MDQyX1NUUl9BVVhEQVRBKSkKIAkJCWNvbXBsZXRlKCZpODA0Ml9hdXhfaXJxX2RlbGl2ZXJlZCk7CkBAIC03NTAsNiArNzUyLDcgQEAKICAqIEFVWCBJUlEgd2FzIG5ldmVyIGRlbGl2ZXJlZCBzbyB3ZSBuZWVkIHRvIGZsdXNoIHRoZSBjb250cm9sbGVyIHRvCiAgKiBnZXQgcmlkIG9mIHRoZSBieXRlIHdlIHB1dCB0aGVyZTsgb3RoZXJ3aXNlIGtleWJvYXJkIG1heSBub3Qgd29yay4KICAqLworCQlkYmcoIiAgICAgLS0gaTgwNDIgKGF1eCBpcnEgdGVzdCB0aW1lb3V0KSIpOwogCQlpODA0Ml9mbHVzaCgpOwogCQlyZXR2YWwgPSAtMTsKIAl9CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L3NlcmlvL2xpYnBzMi5jIGIvZHJpdmVycy9pbnB1dC9zZXJpby9saWJwczIuYwppbmRleCA3NjliYTY1Li5mMzg3NmFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3NlcmlvL2xpYnBzMi5jCisrKyBiL2RyaXZlcnMvaW5wdXQvc2VyaW8vbGlicHMyLmMKQEAgLTEzLDYgKzEzLDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvaW5wdXQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vc2VyaW9fcmF3LmMgYi9kcml2ZXJzL2lucHV0L3NlcmlvL3NlcmlvX3Jhdy5jCmluZGV4IGIwMzAwOWIuLjI3ZmRhYWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvaW5wdXQvc2VyaW8vc2VyaW9fcmF3LmMKKysrIGIvZHJpdmVycy9pbnB1dC9zZXJpby9zZXJpb19yYXcuYwpAQCAtOSw2ICs5LDcgQEAKICAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L3NtcF9sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvcG9sbC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pbnB1dC9zZXJpby9zZXJwb3J0LmMgYi9kcml2ZXJzL2lucHV0L3NlcmlvL3NlcnBvcnQuYwppbmRleCBiOTY5NGI2Li42ZDM0NTExIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3NlcmlvL3NlcnBvcnQuYworKysgYi9kcml2ZXJzL2lucHV0L3NlcmlvL3NlcnBvcnQuYwpAQCAtMTUsNiArMTUsNyBAQAogCiAjaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL2FkNzg3OS5jIGIvZHJpdmVycy9pbnB1dC90b3VjaHNjcmVlbi9hZDc4NzkuYwppbmRleCBmMDYzMzJjLi5jMjFlNmQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lucHV0L3RvdWNoc2NyZWVuL2FkNzg3OS5jCisrKyBiL2RyaXZlcnMvaW5wdXQvdG91Y2hzY3JlZW4vYWQ3ODc5LmMKQEAgLTY0NSw3ICs2NDUsNyBAQAogCQlrZnJlZSh0cyk7CiAJfQogCi0JcmV0dXJuIDA7CisJcmV0dXJuIGVycm9yOwogfQogCiBzdGF0aWMgaW50IF9fZGV2ZXhpdCBhZDc4NzlfcmVtb3ZlKHN0cnVjdCBzcGlfZGV2aWNlICpzcGkpCkBAIC03MzIsNyArNzMyLDcgQEAKIAkJa2ZyZWUodHMpOwogCX0KIAotCXJldHVybiAwOworCXJldHVybiBlcnJvcjsKIH0KIAogc3RhdGljIGludCBfX2RldmV4aXQgYWQ3ODc5X3JlbW92ZShzdHJ1Y3QgaTJjX2NsaWVudCAqY2xpZW50KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2NhcGkva2NhcGkuYyBiL2RyaXZlcnMvaXNkbi9jYXBpL2tjYXBpLmMKaW5kZXggNTdkMjYzNi4uZGM1MDZhYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL2NhcGkva2NhcGkuYworKysgYi9kcml2ZXJzL2lzZG4vY2FwaS9rY2FwaS5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CiAjaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KICNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oaXNheC9hcmNvZmkuYyBiL2RyaXZlcnMvaXNkbi9oaXNheC9hcmNvZmkuYwppbmRleCBkMzBjZTViLi44NWE4ZmQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGlzYXgvYXJjb2ZpLmMKKysrIGIvZHJpdmVycy9pc2RuL2hpc2F4L2FyY29maS5jCkBAIC0xMCw2ICsxMCw3IEBACiAgKgogICovCiAgCisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlICJoaXNheC5oIgogI2luY2x1ZGUgImlzZG5sMS5oIgogI2luY2x1ZGUgImlzYWMuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfMmJkczAuYyBiL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfMmJkczAuYwppbmRleCA1YzQ2YTcxLi44ZDIyZjUwIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGlzYXgvaGZjXzJiZHMwLmMKKysrIGIvZHJpdmVycy9pc2RuL2hpc2F4L2hmY18yYmRzMC5jCkBAIC0xMSw2ICsxMSw3IEBACiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgImhpc2F4LmgiCiAjaW5jbHVkZSAiaGZjXzJiZHMwLmgiCiAjaW5jbHVkZSAiaXNkbmwxLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaGlzYXgvaGZjX3BjaS5jIGIvZHJpdmVycy9pc2RuL2hpc2F4L2hmY19wY2kuYwppbmRleCBkMTEwYTc3Li4xMDkxNDczIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaGlzYXgvaGZjX3BjaS5jCisrKyBiL2RyaXZlcnMvaXNkbi9oaXNheC9oZmNfcGNpLmMKQEAgLTIwLDYgKzIwLDcgQEAKICNpbmNsdWRlICJoZmNfcGNpLmgiCiAjaW5jbHVkZSAiaXNkbmwxLmgiCiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KIAogc3RhdGljIGNvbnN0IGNoYXIgKmhmY3BjaV9yZXZpc2lvbiA9ICIkUmV2aXNpb246IDEuNDguMi40ICQiOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX3Byb2Njb25mLmMgYi9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fcHJvY2NvbmYuYwppbmRleCA4ZjlmNDkxLi45MGIzNWUxIDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fcHJvY2NvbmYuYworKysgYi9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fcHJvY2NvbmYuYwpAQCAtMTEsNiArMTEsNyBAQAogICoKICAqLwogCisjaW5jbHVkZSA8bGludXgvY3JlZC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KICNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fcHJvY2xvZy5jIGIvZHJpdmVycy9pc2RuL2h5c2RuL2h5c2RuX3Byb2Nsb2cuYwppbmRleCA4OTkxZDJjLi44YmNhZTI4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vaHlzZG4vaHlzZG5fcHJvY2xvZy5jCisrKyBiL2RyaXZlcnMvaXNkbi9oeXNkbi9oeXNkbl9wcm9jbG9nLmMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9wb2xsLmg+CiAjaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KIAogI2luY2x1ZGUgImh5c2RuX2RlZnMuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvaXNkbi9wY2JpdC9kcnYuYyBiL2RyaXZlcnMvaXNkbi9wY2JpdC9kcnYuYwppbmRleCA4YzY2YmNiLi4xMjNjMWQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vcGNiaXQvZHJ2LmMKKysrIGIvZHJpdmVycy9pc2RuL3BjYml0L2Rydi5jCkBAIC0yMyw2ICsyMyw3IEBACiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vcGNiaXQvbGF5ZXIyLmMgYi9kcml2ZXJzL2lzZG4vcGNiaXQvbGF5ZXIyLmMKaW5kZXggZTA3NWU4ZC4uMzBmMGY0NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9pc2RuL3BjYml0L2xheWVyMi5jCisrKyBiL2RyaXZlcnMvaXNkbi9wY2JpdC9sYXllcjIuYwpAQCAtMjcsNiArMjcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL2lzZG4vc2MvaW5pdC5jIGIvZHJpdmVycy9pc2RuL3NjL2luaXQuYwppbmRleCBkZDBhY2QwLi41YTA3NzQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL2lzZG4vc2MvaW5pdC5jCisrKyBiL2RyaXZlcnMvaXNkbi9zYy9pbml0LmMKQEAgLTgsNiArOCw3IEBACiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlICJpbmNsdWRlcy5oIgogI2luY2x1ZGUgImhhcmR3YXJlLmgiCiAjaW5jbHVkZSAiY2FyZC5oIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9sZ3Vlc3QvaW50ZXJydXB0c19hbmRfdHJhcHMuYyBiL2RyaXZlcnMvbGd1ZXN0L2ludGVycnVwdHNfYW5kX3RyYXBzLmMKaW5kZXggMTg2NDgxOC4uZGFhZjg2NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9sZ3Vlc3QvaW50ZXJydXB0c19hbmRfdHJhcHMuYworKysgYi9kcml2ZXJzL2xndWVzdC9pbnRlcnJ1cHRzX2FuZF90cmFwcy5jCkBAIC0xNiw2ICsxNiw3IEBACiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSAibGcuaCIKIAogLyogQWxsb3cgR3Vlc3RzIHRvIHVzZSBhIG5vbi0xMjggKGllLiBub24tTGludXgpIHN5c2NhbGwgdHJhcC4gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWFjaW50b3NoL3ZpYS1wbXUuYyBiL2RyaXZlcnMvbWFjaW50b3NoL3ZpYS1wbXUuYwppbmRleCBiNDBmYjliLi42ZjMwOGE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21hY2ludG9zaC92aWEtcG11LmMKKysrIGIvZHJpdmVycy9tYWNpbnRvc2gvdmlhLXBtdS5jCkBAIC00MDUsNyArNDA1LDExIEBACiAJCXByaW50ayhLRVJOX0VSUiAidmlhLXBtdTogY2FuJ3QgbWFwIGludGVycnVwdFxuIik7CiAJCXJldHVybiAtRU5PREVWOwogCX0KLQlpZiAocmVxdWVzdF9pcnEoaXJxLCB2aWFfcG11X2ludGVycnVwdCwgMCwgIlZJQS1QTVUiLCAodm9pZCAqKTApKSB7CisJLyogV2Ugc2V0IElSUUZfVElNRVIgYmVjYXVzZSB3ZSBkb24ndCB3YW50IHRoZSBpbnRlcnJ1cHQgdG8gYmUgZGlzYWJsZWQKKwkgKiBiZXR3ZWVuIHRoZSAyIHBhc3NlcyBvZiBkcml2ZXIgc3VzcGVuZCwgd2UgY29udHJvbCBvdXIgb3duIGRpc2FibGluZworCSAqIGZvciB0aGF0IG9uZQorCSAqLworCWlmIChyZXF1ZXN0X2lycShpcnEsIHZpYV9wbXVfaW50ZXJydXB0LCBJUlFGX1RJTUVSLCAiVklBLVBNVSIsICh2b2lkICopMCkpIHsKIAkJcHJpbnRrKEtFUk5fRVJSICJ2aWEtcG11OiBjYW4ndCByZXF1ZXN0IGlycSAlZFxuIiwgaXJxKTsKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQpAQCAtNDE5LDcgKzQyMyw3IEBACiAJCQlncGlvX2lycSA9IGlycV9vZl9wYXJzZV9hbmRfbWFwKGdwaW9fbm9kZSwgMCk7CiAKIAkJaWYgKGdwaW9faXJxICE9IE5PX0lSUSkgewotCQkJaWYgKHJlcXVlc3RfaXJxKGdwaW9faXJxLCBncGlvMV9pbnRlcnJ1cHQsIDAsCisJCQlpZiAocmVxdWVzdF9pcnEoZ3Bpb19pcnEsIGdwaW8xX2ludGVycnVwdCwgSVJRRl9USU1FUiwKIAkJCQkJIkdQSU8xIEFEQiIsICh2b2lkICopMCkpCiAJCQkJcHJpbnRrKEtFUk5fRVJSICJwbXU6IGNhbid0IGdldCBpcnEgJWQiCiAJCQkJICAgICAgICIgKEdQSU8xKVxuIiwgZ3Bpb19pcnEpOwpAQCAtOTI1LDggKzkyOSw3IEBACiAKICNpZmRlZiBDT05GSUdfQURCCiAvKiBTZW5kIGFuIEFEQiBjb21tYW5kICovCi1zdGF0aWMgaW50Ci1wbXVfc2VuZF9yZXF1ZXN0KHN0cnVjdCBhZGJfcmVxdWVzdCAqcmVxLCBpbnQgc3luYykKK3N0YXRpYyBpbnQgcG11X3NlbmRfcmVxdWVzdChzdHJ1Y3QgYWRiX3JlcXVlc3QgKnJlcSwgaW50IHN5bmMpCiB7CiAJaW50IGksIHJldDsKIApAQCAtMTAwNSwxNiArMTAwOCwxMSBAQAogfQogCiAvKiBFbmFibGUvZGlzYWJsZSBhdXRvcG9sbGluZyAqLwotc3RhdGljIGludAotcG11X2FkYl9hdXRvcG9sbChpbnQgZGV2cykKK3N0YXRpYyBpbnQgX19wbXVfYWRiX2F1dG9wb2xsKGludCBkZXZzKQogewogCXN0cnVjdCBhZGJfcmVxdWVzdCByZXE7CiAKLQlpZiAoKHZpYXMgPT0gTlVMTCkgfHwgKCFwbXVfZnVsbHlfaW5pdGVkKSB8fCAhcG11X2hhc19hZGIpCi0JCXJldHVybiAtRU5YSU87Ci0KIAlpZiAoZGV2cykgewotCQlhZGJfZGV2X21hcCA9IGRldnM7CiAJCXBtdV9yZXF1ZXN0KCZyZXEsIE5VTEwsIDUsIFBNVV9BREJfQ01ELCAwLCAweDg2LAogCQkJICAgIGFkYl9kZXZfbWFwID4+IDgsIGFkYl9kZXZfbWFwKTsKIAkJcG11X2FkYl9mbGFncyA9IDI7CkBAIC0xMDI3LDkgKzEwMjUsMTcgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGludCBwbXVfYWRiX2F1dG9wb2xsKGludCBkZXZzKQoreworCWlmICgodmlhcyA9PSBOVUxMKSB8fCAoIXBtdV9mdWxseV9pbml0ZWQpIHx8ICFwbXVfaGFzX2FkYikKKwkJcmV0dXJuIC1FTlhJTzsKKworCWFkYl9kZXZfbWFwID0gZGV2czsKKwlyZXR1cm4gX19wbXVfYWRiX2F1dG9wb2xsKGRldnMpOworfQorCiAvKiBSZXNldCB0aGUgQURCIGJ1cyAqLwotc3RhdGljIGludAotcG11X2FkYl9yZXNldF9idXModm9pZCkKK3N0YXRpYyBpbnQgcG11X2FkYl9yZXNldF9idXModm9pZCkKIHsKIAlzdHJ1Y3QgYWRiX3JlcXVlc3QgcmVxOwogCWludCBzYXZlX2F1dG9wb2xsID0gYWRiX2Rldl9tYXA7CkBAIC0xMDM4LDEzICsxMDQ0LDEzIEBACiAJCXJldHVybiAtRU5YSU87CiAKIAkvKiBhbnlvbmUgZ290IGEgYmV0dGVyIGlkZWE/PyAqLwotCXBtdV9hZGJfYXV0b3BvbGwoMCk7CisJX19wbXVfYWRiX2F1dG9wb2xsKDApOwogCi0JcmVxLm5ieXRlcyA9IDU7CisJcmVxLm5ieXRlcyA9IDQ7CiAJcmVxLmRvbmUgPSBOVUxMOwogCXJlcS5kYXRhWzBdID0gUE1VX0FEQl9DTUQ7Ci0JcmVxLmRhdGFbMV0gPSAwOwotCXJlcS5kYXRhWzJdID0gQURCX0JVU1JFU0VUOworCXJlcS5kYXRhWzFdID0gQURCX0JVU1JFU0VUOworCXJlcS5kYXRhWzJdID0gMDsKIAlyZXEuZGF0YVszXSA9IDA7CiAJcmVxLmRhdGFbNF0gPSAwOwogCXJlcS5yZXBseV9sZW4gPSAwOwpAQCAtMTA1Niw3ICsxMDYyLDcgQEAKIAlwbXVfd2FpdF9jb21wbGV0ZSgmcmVxKTsKIAogCWlmIChzYXZlX2F1dG9wb2xsICE9IDApCi0JCXBtdV9hZGJfYXV0b3BvbGwoc2F2ZV9hdXRvcG9sbCk7CisJCV9fcG11X2FkYl9hdXRvcG9sbChzYXZlX2F1dG9wb2xsKTsKIAogCXJldHVybiAwOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1leGNlcHRpb24tc3RvcmUuYyBiL2RyaXZlcnMvbWQvZG0tZXhjZXB0aW9uLXN0b3JlLmMKaW5kZXggNTU2YWNmZi4uN2RiZTY1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS1leGNlcHRpb24tc3RvcmUuYworKysgYi9kcml2ZXJzL21kL2RtLWV4Y2VwdGlvbi1zdG9yZS5jCkBAIC0xMzgsMTYgKzEzOCw2IEBACiB9CiBFWFBPUlRfU1lNQk9MKGRtX2V4Y2VwdGlvbl9zdG9yZV90eXBlX3VucmVnaXN0ZXIpOwogCi0vKgotICogUm91bmQgYSBudW1iZXIgdXAgdG8gdGhlIG5lYXJlc3QgJ3NpemUnIGJvdW5kYXJ5LiAgc2l6ZSBtdXN0Ci0gKiBiZSBhIHBvd2VyIG9mIDIuCi0gKi8KLXN0YXRpYyB1bG9uZyByb3VuZF91cCh1bG9uZyBuLCB1bG9uZyBzaXplKQotewotCXNpemUtLTsKLQlyZXR1cm4gKG4gKyBzaXplKSAmIH5zaXplOwotfQotCiBzdGF0aWMgaW50IHNldF9jaHVua19zaXplKHN0cnVjdCBkbV9leGNlcHRpb25fc3RvcmUgKnN0b3JlLAogCQkJICBjb25zdCBjaGFyICpjaHVua19zaXplX2FyZywgY2hhciAqKmVycm9yKQogewpAQCAtMTU1LDcgKzE0NSw4IEBACiAJY2hhciAqdmFsdWU7CiAKIAljaHVua19zaXplX3Vsb25nID0gc2ltcGxlX3N0cnRvdWwoY2h1bmtfc2l6ZV9hcmcsICZ2YWx1ZSwgMTApOwotCWlmICgqY2h1bmtfc2l6ZV9hcmcgPT0gJ1wwJyB8fCAqdmFsdWUgIT0gJ1wwJykgeworCWlmICgqY2h1bmtfc2l6ZV9hcmcgPT0gJ1wwJyB8fCAqdmFsdWUgIT0gJ1wwJyB8fAorCSAgICBjaHVua19zaXplX3Vsb25nID4gVUlOVF9NQVgpIHsKIAkJKmVycm9yID0gIkludmFsaWQgY2h1bmsgc2l6ZSI7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KQEAgLTE2NSw0MCArMTU2LDM1IEBACiAJCXJldHVybiAwOwogCX0KIAotCS8qCi0JICogQ2h1bmsgc2l6ZSBtdXN0IGJlIG11bHRpcGxlIG9mIHBhZ2Ugc2l6ZS4gIFNpbGVudGx5Ci0JICogcm91bmQgdXAgaWYgaXQncyBub3QuCi0JICovCi0JY2h1bmtfc2l6ZV91bG9uZyA9IHJvdW5kX3VwKGNodW5rX3NpemVfdWxvbmcsIFBBR0VfU0laRSA+PiA5KTsKLQotCXJldHVybiBkbV9leGNlcHRpb25fc3RvcmVfc2V0X2NodW5rX3NpemUoc3RvcmUsIGNodW5rX3NpemVfdWxvbmcsCisJcmV0dXJuIGRtX2V4Y2VwdGlvbl9zdG9yZV9zZXRfY2h1bmtfc2l6ZShzdG9yZSwKKwkJCQkJCSAodW5zaWduZWQpIGNodW5rX3NpemVfdWxvbmcsCiAJCQkJCQkgZXJyb3IpOwogfQogCiBpbnQgZG1fZXhjZXB0aW9uX3N0b3JlX3NldF9jaHVua19zaXplKHN0cnVjdCBkbV9leGNlcHRpb25fc3RvcmUgKnN0b3JlLAotCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgY2h1bmtfc2l6ZV91bG9uZywKKwkJCQkgICAgICB1bnNpZ25lZCBjaHVua19zaXplLAogCQkJCSAgICAgIGNoYXIgKiplcnJvcikKIHsKIAkvKiBDaGVjayBjaHVua19zaXplIGlzIGEgcG93ZXIgb2YgMiAqLwotCWlmICghaXNfcG93ZXJfb2ZfMihjaHVua19zaXplX3Vsb25nKSkgeworCWlmICghaXNfcG93ZXJfb2ZfMihjaHVua19zaXplKSkgewogCQkqZXJyb3IgPSAiQ2h1bmsgc2l6ZSBpcyBub3QgYSBwb3dlciBvZiAyIjsKIAkJcmV0dXJuIC1FSU5WQUw7CiAJfQogCiAJLyogVmFsaWRhdGUgdGhlIGNodW5rIHNpemUgYWdhaW5zdCB0aGUgZGV2aWNlIGJsb2NrIHNpemUgKi8KLQlpZiAoY2h1bmtfc2l6ZV91bG9uZyAlIChiZGV2X2xvZ2ljYWxfYmxvY2tfc2l6ZShzdG9yZS0+Y293LT5iZGV2KSA+PiA5KSkgeworCWlmIChjaHVua19zaXplICUgKGJkZXZfbG9naWNhbF9ibG9ja19zaXplKHN0b3JlLT5jb3ctPmJkZXYpID4+IDkpKSB7CiAJCSplcnJvciA9ICJDaHVuayBzaXplIGlzIG5vdCBhIG11bHRpcGxlIG9mIGRldmljZSBibG9ja3NpemUiOwogCQlyZXR1cm4gLUVJTlZBTDsKIAl9CiAKLQlpZiAoY2h1bmtfc2l6ZV91bG9uZyA+IElOVF9NQVggPj4gU0VDVE9SX1NISUZUKSB7CisJaWYgKGNodW5rX3NpemUgPiBJTlRfTUFYID4+IFNFQ1RPUl9TSElGVCkgewogCQkqZXJyb3IgPSAiQ2h1bmsgc2l6ZSBpcyB0b28gaGlnaCI7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAotCXN0b3JlLT5jaHVua19zaXplID0gY2h1bmtfc2l6ZV91bG9uZzsKLQlzdG9yZS0+Y2h1bmtfbWFzayA9IGNodW5rX3NpemVfdWxvbmcgLSAxOwotCXN0b3JlLT5jaHVua19zaGlmdCA9IGZmcyhjaHVua19zaXplX3Vsb25nKSAtIDE7CisJc3RvcmUtPmNodW5rX3NpemUgPSBjaHVua19zaXplOworCXN0b3JlLT5jaHVua19tYXNrID0gY2h1bmtfc2l6ZSAtIDE7CisJc3RvcmUtPmNodW5rX3NoaWZ0ID0gZmZzKGNodW5rX3NpemUpIC0gMTsKIAogCXJldHVybiAwOwogfQpAQCAtMjUxLDcgKzIzNyw3IEBACiAKIAlyID0gc2V0X2NodW5rX3NpemUodG1wX3N0b3JlLCBhcmd2WzJdLCAmdGktPmVycm9yKTsKIAlpZiAocikKLQkJZ290byBiYWRfY293OworCQlnb3RvIGJhZF9jdHI7CiAKIAlyID0gdHlwZS0+Y3RyKHRtcF9zdG9yZSwgMCwgTlVMTCk7CiAJaWYgKHIpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWQvZG0tZXhjZXB0aW9uLXN0b3JlLmggYi9kcml2ZXJzL21kL2RtLWV4Y2VwdGlvbi1zdG9yZS5oCmluZGV4IDgxMmM3MTguLjhhMjIzYTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWQvZG0tZXhjZXB0aW9uLXN0b3JlLmgKKysrIGIvZHJpdmVycy9tZC9kbS1leGNlcHRpb24tc3RvcmUuaApAQCAtMTAxLDkgKzEwMSw5IEBACiAJc3RydWN0IGRtX2RldiAqY293OwogCiAJLyogU2l6ZSBvZiBkYXRhIGJsb2NrcyBzYXZlZCAtIG11c3QgYmUgYSBwb3dlciBvZiAyICovCi0JY2h1bmtfdCBjaHVua19zaXplOwotCWNodW5rX3QgY2h1bmtfbWFzazsKLQljaHVua190IGNodW5rX3NoaWZ0OworCXVuc2lnbmVkIGNodW5rX3NpemU7CisJdW5zaWduZWQgY2h1bmtfbWFzazsKKwl1bnNpZ25lZCBjaHVua19zaGlmdDsKIAogCXZvaWQgKmNvbnRleHQ7CiB9OwpAQCAtMTY5LDcgKzE2OSw3IEBACiBpbnQgZG1fZXhjZXB0aW9uX3N0b3JlX3R5cGVfdW5yZWdpc3RlcihzdHJ1Y3QgZG1fZXhjZXB0aW9uX3N0b3JlX3R5cGUgKnR5cGUpOwogCiBpbnQgZG1fZXhjZXB0aW9uX3N0b3JlX3NldF9jaHVua19zaXplKHN0cnVjdCBkbV9leGNlcHRpb25fc3RvcmUgKnN0b3JlLAotCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgY2h1bmtfc2l6ZV91bG9uZywKKwkJCQkgICAgICB1bnNpZ25lZCBjaHVua19zaXplLAogCQkJCSAgICAgIGNoYXIgKiplcnJvcik7CiAKIGludCBkbV9leGNlcHRpb25fc3RvcmVfY3JlYXRlKHN0cnVjdCBkbV90YXJnZXQgKnRpLCBpbnQgYXJnYywgY2hhciAqKmFyZ3YsCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLWxvZy11c2Vyc3BhY2UtYmFzZS5jIGIvZHJpdmVycy9tZC9kbS1sb2ctdXNlcnNwYWNlLWJhc2UuYwppbmRleCA2NTJiZDMzLi43YWMyYzE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLWxvZy11c2Vyc3BhY2UtYmFzZS5jCisrKyBiL2RyaXZlcnMvbWQvZG0tbG9nLXVzZXJzcGFjZS1iYXNlLmMKQEAgLTE1Niw3ICsxNTYsNyBAQAogCX0KIAogCS8qIFRoZSBwdHIgdmFsdWUgaXMgc3VmZmljaWVudCBmb3IgbG9jYWwgdW5pcXVlIGlkICovCi0JbGMtPmx1aWQgPSAodWludDY0X3QpbGM7CisJbGMtPmx1aWQgPSAodW5zaWduZWQgbG9uZylsYzsKIAogCWxjLT50aSA9IHRpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLXNuYXAtcGVyc2lzdGVudC5jIGIvZHJpdmVycy9tZC9kbS1zbmFwLXBlcnNpc3RlbnQuYwppbmRleCBkNWIyZTA4Li4wYzc0NjQyIDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXNuYXAtcGVyc2lzdGVudC5jCisrKyBiL2RyaXZlcnMvbWQvZG0tc25hcC1wZXJzaXN0ZW50LmMKQEAgLTI4NCwxMiArMjg0LDEzIEBACiB7CiAJaW50IHI7CiAJc3RydWN0IGRpc2tfaGVhZGVyICpkaDsKLQljaHVua190IGNodW5rX3NpemU7CisJdW5zaWduZWQgY2h1bmtfc2l6ZTsKIAlpbnQgY2h1bmtfc2l6ZV9zdXBwbGllZCA9IDE7CiAJY2hhciAqY2h1bmtfZXJyOwogCiAJLyoKLQkgKiBVc2UgZGVmYXVsdCBjaHVuayBzaXplIChvciBoYXJkc2VjdF9zaXplLCBpZiBsYXJnZXIpIGlmIG5vbmUgc3VwcGxpZWQKKwkgKiBVc2UgZGVmYXVsdCBjaHVuayBzaXplIChvciBsb2dpY2FsX2Jsb2NrX3NpemUsIGlmIGxhcmdlcikKKwkgKiBpZiBub25lIHN1cHBsaWVkCiAJICovCiAJaWYgKCFwcy0+c3RvcmUtPmNodW5rX3NpemUpIHsKIAkJcHMtPnN0b3JlLT5jaHVua19zaXplID0gbWF4KERNX0NIVU5LX1NJWkVfREVGQVVMVF9TRUNUT1JTLApAQCAtMzM0LDEwICszMzUsOSBAQAogCQlyZXR1cm4gMDsKIAogCWlmIChjaHVua19zaXplX3N1cHBsaWVkKQotCQlETVdBUk4oImNodW5rIHNpemUgJWxsdSBpbiBkZXZpY2UgbWV0YWRhdGEgb3ZlcnJpZGVzICIKLQkJICAgICAgICJ0YWJsZSBjaHVuayBzaXplIG9mICVsbHUuIiwKLQkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpY2h1bmtfc2l6ZSwKLQkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpcHMtPnN0b3JlLT5jaHVua19zaXplKTsKKwkJRE1XQVJOKCJjaHVuayBzaXplICV1IGluIGRldmljZSBtZXRhZGF0YSBvdmVycmlkZXMgIgorCQkgICAgICAgInRhYmxlIGNodW5rIHNpemUgb2YgJXUuIiwKKwkJICAgICAgIGNodW5rX3NpemUsIHBzLT5zdG9yZS0+Y2h1bmtfc2l6ZSk7CiAKIAkvKiBXZSBoYWQgYSBib2d1cyBjaHVua19zaXplLiBGaXggc3R1ZmYgdXAuICovCiAJZnJlZV9hcmVhKHBzKTsKQEAgLTM0NSw4ICszNDUsOCBAQAogCXIgPSBkbV9leGNlcHRpb25fc3RvcmVfc2V0X2NodW5rX3NpemUocHMtPnN0b3JlLCBjaHVua19zaXplLAogCQkJCQkgICAgICAmY2h1bmtfZXJyKTsKIAlpZiAocikgewotCQlETUVSUigiaW52YWxpZCBvbi1kaXNrIGNodW5rIHNpemUgJWxsdTogJXMuIiwKLQkJICAgICAgKHVuc2lnbmVkIGxvbmcgbG9uZyljaHVua19zaXplLCBjaHVua19lcnIpOworCQlETUVSUigiaW52YWxpZCBvbi1kaXNrIGNodW5rIHNpemUgJXU6ICVzLiIsCisJCSAgICAgIGNodW5rX3NpemUsIGNodW5rX2Vycik7CiAJCXJldHVybiByOwogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZC9kbS1zbmFwLmMgYi9kcml2ZXJzL21kL2RtLXNuYXAuYwppbmRleCA1N2YxYmY3Li4zYTNiYTQ2IDEwMDY0NAotLS0gYS9kcml2ZXJzL21kL2RtLXNuYXAuYworKysgYi9kcml2ZXJzL21kL2RtLXNuYXAuYwpAQCAtMjk2LDYgKzI5Niw3IEBACiAgKi8KIHN0YXRpYyBpbnQgcmVnaXN0ZXJfc25hcHNob3Qoc3RydWN0IGRtX3NuYXBzaG90ICpzbmFwKQogeworCXN0cnVjdCBkbV9zbmFwc2hvdCAqbDsKIAlzdHJ1Y3Qgb3JpZ2luICpvLCAqbmV3X287CiAJc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiA9IHNuYXAtPm9yaWdpbi0+YmRldjsKIApAQCAtMzE5LDcgKzMyMCwxMSBAQAogCQlfX2luc2VydF9vcmlnaW4obyk7CiAJfQogCi0JbGlzdF9hZGRfdGFpbCgmc25hcC0+bGlzdCwgJm8tPnNuYXBzaG90cyk7CisJLyogU29ydCB0aGUgbGlzdCBhY2NvcmRpbmcgdG8gY2h1bmsgc2l6ZSwgbGFyZ2VzdC1maXJzdCBzbWFsbGVzdC1sYXN0ICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeShsLCAmby0+c25hcHNob3RzLCBsaXN0KQorCQlpZiAobC0+c3RvcmUtPmNodW5rX3NpemUgPCBzbmFwLT5zdG9yZS0+Y2h1bmtfc2l6ZSkKKwkJCWJyZWFrOworCWxpc3RfYWRkX3RhaWwoJnNuYXAtPmxpc3QsICZsLT5saXN0KTsKIAogCXVwX3dyaXRlKCZfb3JpZ2luc19sb2NrKTsKIAlyZXR1cm4gMDsKQEAgLTY2OCw2ICs2NzMsMTEgQEAKIAliaW9fbGlzdF9pbml0KCZzLT5xdWV1ZWRfYmlvcyk7CiAJSU5JVF9XT1JLKCZzLT5xdWV1ZWRfYmlvc193b3JrLCBmbHVzaF9xdWV1ZWRfYmlvcyk7CiAKKwlpZiAoIXMtPnN0b3JlLT5jaHVua19zaXplKSB7CisJCXRpLT5lcnJvciA9ICJDaHVuayBzaXplIG5vdCBzZXQiOworCQlnb3RvIGJhZF9sb2FkX2FuZF9yZWdpc3RlcjsKKwl9CisKIAkvKiBBZGQgc25hcHNob3QgdG8gdGhlIGxpc3Qgb2Ygc25hcHNob3RzIGZvciB0aGlzIG9yaWdpbiAqLwogCS8qIEV4Y2VwdGlvbnMgYXJlbid0IHRyaWdnZXJlZCB0aWxsIHNuYXBzaG90X3Jlc3VtZSgpIGlzIGNhbGxlZCAqLwogCWlmIChyZWdpc3Rlcl9zbmFwc2hvdChzKSkgewpAQCAtOTUxLDcgKzk2MSw3IEBACiAKIAlzcmMuYmRldiA9IGJkZXY7CiAJc3JjLnNlY3RvciA9IGNodW5rX3RvX3NlY3RvcihzLT5zdG9yZSwgcGUtPmUub2xkX2NodW5rKTsKLQlzcmMuY291bnQgPSBtaW4ocy0+c3RvcmUtPmNodW5rX3NpemUsIGRldl9zaXplIC0gc3JjLnNlY3Rvcik7CisJc3JjLmNvdW50ID0gbWluKChzZWN0b3JfdClzLT5zdG9yZS0+Y2h1bmtfc2l6ZSwgZGV2X3NpemUgLSBzcmMuc2VjdG9yKTsKIAogCWRlc3QuYmRldiA9IHMtPnN0b3JlLT5jb3ctPmJkZXY7CiAJZGVzdC5zZWN0b3IgPSBjaHVua190b19zZWN0b3Iocy0+c3RvcmUsIHBlLT5lLm5ld19jaHVuayk7CkBAIC0xMTQyLDYgKzExNTIsOCBAQAogCXVuc2lnbmVkIHN6ID0gMDsKIAlzdHJ1Y3QgZG1fc25hcHNob3QgKnNuYXAgPSB0aS0+cHJpdmF0ZTsKIAorCWRvd25fd3JpdGUoJnNuYXAtPmxvY2spOworCiAJc3dpdGNoICh0eXBlKSB7CiAJY2FzZSBTVEFUVVNUWVBFX0lORk86CiAJCWlmICghc25hcC0+dmFsaWQpCkBAIC0xMTczLDYgKzExODUsOCBAQAogCQlicmVhazsKIAl9CiAKKwl1cF93cml0ZSgmc25hcC0+bG9jayk7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTM4OCw3ICsxNDAyLDcgQEAKIAlzdHJ1Y3QgZG1fZGV2ICpkZXYgPSB0aS0+cHJpdmF0ZTsKIAlzdHJ1Y3QgZG1fc25hcHNob3QgKnNuYXA7CiAJc3RydWN0IG9yaWdpbiAqbzsKLQljaHVua190IGNodW5rX3NpemUgPSAwOworCXVuc2lnbmVkIGNodW5rX3NpemUgPSAwOwogCiAJZG93bl9yZWFkKCZfb3JpZ2luc19sb2NrKTsKIAlvID0gX19sb29rdXBfb3JpZ2luKGRldi0+YmRldik7CkBAIC0xNDY1LDcgKzE0NzksNyBAQAogCXIgPSBkbV9yZWdpc3Rlcl90YXJnZXQoJnNuYXBzaG90X3RhcmdldCk7CiAJaWYgKHIpIHsKIAkJRE1FUlIoInNuYXBzaG90IHRhcmdldCByZWdpc3RlciBmYWlsZWQgJWQiLCByKTsKLQkJcmV0dXJuIHI7CisJCWdvdG8gYmFkX3JlZ2lzdGVyX3NuYXBzaG90X3RhcmdldDsKIAl9CiAKIAlyID0gZG1fcmVnaXN0ZXJfdGFyZ2V0KCZvcmlnaW5fdGFyZ2V0KTsKQEAgLTE1MjIsNiArMTUzNiw5IEBACiAJZG1fdW5yZWdpc3Rlcl90YXJnZXQoJm9yaWdpbl90YXJnZXQpOwogYmFkMToKIAlkbV91bnJlZ2lzdGVyX3RhcmdldCgmc25hcHNob3RfdGFyZ2V0KTsKKworYmFkX3JlZ2lzdGVyX3NuYXBzaG90X3RhcmdldDoKKwlkbV9leGNlcHRpb25fc3RvcmVfZXhpdCgpOwogCXJldHVybiByOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL21kL2RtLmMgYi9kcml2ZXJzL21kL2RtLmMKaW5kZXggMjNlNzZmZS4uNzI0ZWZjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZC9kbS5jCisrKyBiL2RyaXZlcnMvbWQvZG0uYwpAQCAtNDcsNiArNDcsNyBAQAogCWF0b21pY190IGlvX2NvdW50OwogCXN0cnVjdCBiaW8gKmJpbzsKIAl1bnNpZ25lZCBsb25nIHN0YXJ0X3RpbWU7CisJc3BpbmxvY2tfdCBlbmRpb19sb2NrOwogfTsKIAogLyoKQEAgLTEzMCw3ICsxMzEsNyBAQAogCS8qCiAJICogQSBsaXN0IG9mIGlvcyB0aGF0IGFycml2ZWQgd2hpbGUgd2Ugd2VyZSBzdXNwZW5kZWQuCiAJICovCi0JYXRvbWljX3QgcGVuZGluZzsKKwlhdG9taWNfdCBwZW5kaW5nWzJdOwogCXdhaXRfcXVldWVfaGVhZF90IHdhaXQ7CiAJc3RydWN0IHdvcmtfc3RydWN0IHdvcms7CiAJc3RydWN0IGJpb19saXN0IGRlZmVycmVkOwpAQCAtNDUzLDEzICs0NTQsMTQgQEAKIHsKIAlzdHJ1Y3QgbWFwcGVkX2RldmljZSAqbWQgPSBpby0+bWQ7CiAJaW50IGNwdTsKKwlpbnQgcncgPSBiaW9fZGF0YV9kaXIoaW8tPmJpbyk7CiAKIAlpby0+c3RhcnRfdGltZSA9IGppZmZpZXM7CiAKIAljcHUgPSBwYXJ0X3N0YXRfbG9jaygpOwogCXBhcnRfcm91bmRfc3RhdHMoY3B1LCAmZG1fZGlzayhtZCktPnBhcnQwKTsKIAlwYXJ0X3N0YXRfdW5sb2NrKCk7Ci0JZG1fZGlzayhtZCktPnBhcnQwLmluX2ZsaWdodCA9IGF0b21pY19pbmNfcmV0dXJuKCZtZC0+cGVuZGluZyk7CisJZG1fZGlzayhtZCktPnBhcnQwLmluX2ZsaWdodFtyd10gPSBhdG9taWNfaW5jX3JldHVybigmbWQtPnBlbmRpbmdbcnddKTsKIH0KIAogc3RhdGljIHZvaWQgZW5kX2lvX2FjY3Qoc3RydWN0IGRtX2lvICppbykKQEAgLTQ3OSw4ICs0ODEsOSBAQAogCSAqIEFmdGVyIHRoaXMgaXMgZGVjcmVtZW50ZWQgdGhlIGJpbyBtdXN0IG5vdCBiZSB0b3VjaGVkIGlmIGl0IGlzCiAJICogYSBiYXJyaWVyLgogCSAqLwotCWRtX2Rpc2sobWQpLT5wYXJ0MC5pbl9mbGlnaHQgPSBwZW5kaW5nID0KLQkJYXRvbWljX2RlY19yZXR1cm4oJm1kLT5wZW5kaW5nKTsKKwlkbV9kaXNrKG1kKS0+cGFydDAuaW5fZmxpZ2h0W3J3XSA9IHBlbmRpbmcgPQorCQlhdG9taWNfZGVjX3JldHVybigmbWQtPnBlbmRpbmdbcnddKTsKKwlwZW5kaW5nICs9IGF0b21pY19yZWFkKCZtZC0+cGVuZGluZ1tyd14weDFdKTsKIAogCS8qIG51ZGdlIGFueW9uZSB3YWl0aW5nIG9uIHN1c3BlbmQgcXVldWUgKi8KIAlpZiAoIXBlbmRpbmcpCkBAIC01NzYsOCArNTc5LDEyIEBACiAJc3RydWN0IG1hcHBlZF9kZXZpY2UgKm1kID0gaW8tPm1kOwogCiAJLyogUHVzaC1iYWNrIHN1cGVyc2VkZXMgYW55IEkvTyBlcnJvcnMgKi8KLQlpZiAoZXJyb3IgJiYgIShpby0+ZXJyb3IgPiAwICYmIF9fbm9mbHVzaF9zdXNwZW5kaW5nKG1kKSkpCi0JCWlvLT5lcnJvciA9IGVycm9yOworCWlmICh1bmxpa2VseShlcnJvcikpIHsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJmlvLT5lbmRpb19sb2NrLCBmbGFncyk7CisJCWlmICghKGlvLT5lcnJvciA+IDAgJiYgX19ub2ZsdXNoX3N1c3BlbmRpbmcobWQpKSkKKwkJCWlvLT5lcnJvciA9IGVycm9yOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpby0+ZW5kaW9fbG9jaywgZmxhZ3MpOworCX0KIAogCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZpby0+aW9fY291bnQpKSB7CiAJCWlmIChpby0+ZXJyb3IgPT0gRE1fRU5ESU9fUkVRVUVVRSkgewpAQCAtMTIyNCw2ICsxMjMxLDcgQEAKIAlhdG9taWNfc2V0KCZjaS5pby0+aW9fY291bnQsIDEpOwogCWNpLmlvLT5iaW8gPSBiaW87CiAJY2kuaW8tPm1kID0gbWQ7CisJc3Bpbl9sb2NrX2luaXQoJmNpLmlvLT5lbmRpb19sb2NrKTsKIAljaS5zZWN0b3IgPSBiaW8tPmJpX3NlY3RvcjsKIAljaS5zZWN0b3JfY291bnQgPSBiaW9fc2VjdG9ycyhiaW8pOwogCWlmICh1bmxpa2VseShiaW9fZW1wdHlfYmFycmllcihiaW8pKSkKQEAgLTE3ODUsNyArMTc5Myw4IEBACiAJaWYgKCFtZC0+ZGlzaykKIAkJZ290byBiYWRfZGlzazsKIAotCWF0b21pY19zZXQoJm1kLT5wZW5kaW5nLCAwKTsKKwlhdG9taWNfc2V0KCZtZC0+cGVuZGluZ1swXSwgMCk7CisJYXRvbWljX3NldCgmbWQtPnBlbmRpbmdbMV0sIDApOwogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJm1kLT53YWl0KTsKIAlJTklUX1dPUksoJm1kLT53b3JrLCBkbV93cV93b3JrKTsKIAlpbml0X3dhaXRxdWV1ZV9oZWFkKCZtZC0+ZXZlbnRxKTsKQEAgLTE4MTksNiArMTgyOCw3IEBACiBiYWRfYmRldjoKIAlkZXN0cm95X3dvcmtxdWV1ZShtZC0+d3EpOwogYmFkX3RocmVhZDoKKwlkZWxfZ2VuZGlzayhtZC0+ZGlzayk7CiAJcHV0X2Rpc2sobWQtPmRpc2spOwogYmFkX2Rpc2s6CiAJYmxrX2NsZWFudXBfcXVldWUobWQtPnF1ZXVlKTsKQEAgLTIwODgsNyArMjA5OCw4IEBACiAJCQkJYnJlYWs7CiAJCQl9CiAJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKHEtPnF1ZXVlX2xvY2ssIGZsYWdzKTsKLQkJfSBlbHNlIGlmICghYXRvbWljX3JlYWQoJm1kLT5wZW5kaW5nKSkKKwkJfSBlbHNlIGlmICghYXRvbWljX3JlYWQoJm1kLT5wZW5kaW5nWzBdKSAmJgorCQkJCQkhYXRvbWljX3JlYWQoJm1kLT5wZW5kaW5nWzFdKSkKIAkJCWJyZWFrOwogCiAJCWlmIChpbnRlcnJ1cHRpYmxlID09IFRBU0tfSU5URVJSVVBUSUJMRSAmJgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS9kdmIvZHZiLWNvcmUvZHZiX25ldC5jIGIvZHJpdmVycy9tZWRpYS9kdmIvZHZiLWNvcmUvZHZiX25ldC5jCmluZGV4IDhjOWFlMGEuLjAyNDFhN2MgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVkaWEvZHZiL2R2Yi1jb3JlL2R2Yl9uZXQuYworKysgYi9kcml2ZXJzL21lZGlhL2R2Yi9kdmItY29yZS9kdmJfbmV0LmMKQEAgLTYzLDYgKzYzLDcgQEAKICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGxpbnV4L2NyYzMyLmg+CiAjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogCiAjaW5jbHVkZSAiZHZiX2RlbXV4LmgiCiAjaW5jbHVkZSAiZHZiX25ldC5oIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby9tZXllLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL21leWUuYwppbmRleCA0YjFiYzA1Li4wMWUxZWVmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL21leWUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL21leWUuYwpAQCAtMjgsNiArMjgsNyBAQAogICovCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvdmlkZW9kZXYuaD4KICNpbmNsdWRlIDxtZWRpYS92NGwyLWNvbW1vbi5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby92aWRlb2J1Zi1jb3JlLmMgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3ZpZGVvYnVmLWNvcmUuYwppbmRleCBmMWNjZjk4Li44ZTkzYzZmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21lZGlhL3ZpZGVvL3ZpZGVvYnVmLWNvcmUuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3ZpZGVvYnVmLWNvcmUuYwpAQCAtMTcsNiArMTcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZWRpYS92aWRlby92aWRlb2J1Zi1kbWEtc2cuYyBiL2RyaXZlcnMvbWVkaWEvdmlkZW8vdmlkZW9idWYtZG1hLXNnLmMKaW5kZXggNTNjZGQ2Ny4uMDMyZWJhZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tZWRpYS92aWRlby92aWRlb2J1Zi1kbWEtc2cuYworKysgYi9kcml2ZXJzL21lZGlhL3ZpZGVvL3ZpZGVvYnVmLWRtYS1zZy5jCkBAIC0yMSw2ICsyMSw3IEBACiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWVzc2FnZS9mdXNpb24vbXB0bGFuLmMgYi9kcml2ZXJzL21lc3NhZ2UvZnVzaW9uL21wdGxhbi5jCmluZGV4IGJjMmVjMjEuLjM0ZjNmMzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWVzc2FnZS9mdXNpb24vbXB0bGFuLmMKKysrIGIvZHJpdmVycy9tZXNzYWdlL2Z1c2lvbi9tcHRsYW4uYwpAQCAtNTYsNiArNTYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9mcy5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAKICNkZWZpbmUgbXlfVkVSU0lPTglNUFRfTElOVVhfVkVSU0lPTl9DT01NT04KICNkZWZpbmUgTVlOQU0JCSJtcHRsYW4iCmRpZmYgLS1naXQgYS9kcml2ZXJzL21mZC90d2w0MDMwLWNvcmUuYyBiL2RyaXZlcnMvbWZkL3R3bDQwMzAtY29yZS5jCmluZGV4IGU0MjRjZjYuLmU4MzJlOTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWZkL3R3bDQwMzAtY29yZS5jCisrKyBiL2RyaXZlcnMvbWZkL3R3bDQwMzAtY29yZS5jCkBAIC00ODAsNyArNDgwLDYgQEAKIGFkZF9jaGlsZHJlbihzdHJ1Y3QgdHdsNDAzMF9wbGF0Zm9ybV9kYXRhICpwZGF0YSwgdW5zaWduZWQgbG9uZyBmZWF0dXJlcykKIHsKIAlzdHJ1Y3QgZGV2aWNlCSpjaGlsZDsKLQlzdHJ1Y3QgZGV2aWNlCSp1c2JfdHJhbnNjZWl2ZXIgPSBOVUxMOwogCiAJaWYgKHR3bF9oYXNfYmNpKCkgJiYgcGRhdGEtPmJjaSAmJiAhKGZlYXR1cmVzICYgVFBTX1NVQlNFVCkpIHsKIAkJY2hpbGQgPSBhZGRfY2hpbGQoMywgInR3bDQwMzBfYmNpIiwKQEAgLTUzMiwxNiArNTMxLDYxIEBACiAJfQogCiAJaWYgKHR3bF9oYXNfdXNiKCkgJiYgcGRhdGEtPnVzYikgeworCisJCXN0YXRpYyBzdHJ1Y3QgcmVndWxhdG9yX2NvbnN1bWVyX3N1cHBseSB1c2IxdjUgPSB7CisJCQkuc3VwcGx5ID0JInVzYjF2NSIsCisJCX07CisJCXN0YXRpYyBzdHJ1Y3QgcmVndWxhdG9yX2NvbnN1bWVyX3N1cHBseSB1c2IxdjggPSB7CisJCQkuc3VwcGx5ID0JInVzYjF2OCIsCisJCX07CisJCXN0YXRpYyBzdHJ1Y3QgcmVndWxhdG9yX2NvbnN1bWVyX3N1cHBseSB1c2IzdjEgPSB7CisJCQkuc3VwcGx5ID0JInVzYjN2MSIsCisJCX07CisKKwkvKiBGaXJzdCBhZGQgdGhlIHJlZ3VsYXRvcnMgc28gdGhhdCB0aGV5IGNhbiBiZSB1c2VkIGJ5IHRyYW5zY2VpdmVyICovCisJCWlmICh0d2xfaGFzX3JlZ3VsYXRvcigpKSB7CisJCQkvKiB0aGlzIGlzIGEgdGVtcGxhdGUgdGhhdCBnZXRzIGNvcGllZCAqLworCQkJc3RydWN0IHJlZ3VsYXRvcl9pbml0X2RhdGEgdXNiX2ZpeGVkID0geworCQkJCS5jb25zdHJhaW50cy52YWxpZF9tb2Rlc19tYXNrID0KKwkJCQkJUkVHVUxBVE9SX01PREVfTk9STUFMCisJCQkJCXwgUkVHVUxBVE9SX01PREVfU1RBTkRCWSwKKwkJCQkuY29uc3RyYWludHMudmFsaWRfb3BzX21hc2sgPQorCQkJCQlSRUdVTEFUT1JfQ0hBTkdFX01PREUKKwkJCQkJfCBSRUdVTEFUT1JfQ0hBTkdFX1NUQVRVUywKKwkJCX07CisKKwkJCWNoaWxkID0gYWRkX3JlZ3VsYXRvcl9saW5rZWQoVFdMNDAzMF9SRUdfVlVTQjFWNSwKKwkJCQkJCSAgICAgICZ1c2JfZml4ZWQsICZ1c2IxdjUsIDEpOworCQkJaWYgKElTX0VSUihjaGlsZCkpCisJCQkJcmV0dXJuIFBUUl9FUlIoY2hpbGQpOworCisJCQljaGlsZCA9IGFkZF9yZWd1bGF0b3JfbGlua2VkKFRXTDQwMzBfUkVHX1ZVU0IxVjgsCisJCQkJCQkgICAgICAmdXNiX2ZpeGVkLCAmdXNiMXY4LCAxKTsKKwkJCWlmIChJU19FUlIoY2hpbGQpKQorCQkJCXJldHVybiBQVFJfRVJSKGNoaWxkKTsKKworCQkJY2hpbGQgPSBhZGRfcmVndWxhdG9yX2xpbmtlZChUV0w0MDMwX1JFR19WVVNCM1YxLAorCQkJCQkJICAgICAgJnVzYl9maXhlZCwgJnVzYjN2MSwgMSk7CisJCQlpZiAoSVNfRVJSKGNoaWxkKSkKKwkJCQlyZXR1cm4gUFRSX0VSUihjaGlsZCk7CisKKwkJfQorCiAJCWNoaWxkID0gYWRkX2NoaWxkKDAsICJ0d2w0MDMwX3VzYiIsCiAJCQkJcGRhdGEtPnVzYiwgc2l6ZW9mKCpwZGF0YS0+dXNiKSwKIAkJCQl0cnVlLAogCQkJCS8qIGlycTAgPSBVU0JfUFJFUywgaXJxMSA9IFVTQiAqLwogCQkJCXBkYXRhLT5pcnFfYmFzZSArIDggKyAyLCBwZGF0YS0+aXJxX2Jhc2UgKyA0KTsKKwogCQlpZiAoSVNfRVJSKGNoaWxkKSkKIAkJCXJldHVybiBQVFJfRVJSKGNoaWxkKTsKIAogCQkvKiB3ZSBuZWVkIHRvIGNvbm5lY3QgcmVndWxhdG9ycyB0byB0aGlzIHRyYW5zY2VpdmVyICovCi0JCXVzYl90cmFuc2NlaXZlciA9IGNoaWxkOworCQlpZiAodHdsX2hhc19yZWd1bGF0b3IoKSAmJiBjaGlsZCkgeworCQkJdXNiMXY1LmRldiA9IGNoaWxkOworCQkJdXNiMXY4LmRldiA9IGNoaWxkOworCQkJdXNiM3YxLmRldiA9IGNoaWxkOworCQl9CiAJfQogCiAJaWYgKHR3bF9oYXNfd2F0Y2hkb2coKSkgewpAQCAtNTgwLDQ3ICs2MjQsNiBAQAogCQkJcmV0dXJuIFBUUl9FUlIoY2hpbGQpOwogCX0KIAotCWlmICh0d2xfaGFzX3JlZ3VsYXRvcigpICYmIHVzYl90cmFuc2NlaXZlcikgewotCQlzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9jb25zdW1lcl9zdXBwbHkgdXNiMXY1ID0gewotCQkJLnN1cHBseSA9CSJ1c2IxdjUiLAotCQl9OwotCQlzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9jb25zdW1lcl9zdXBwbHkgdXNiMXY4ID0gewotCQkJLnN1cHBseSA9CSJ1c2IxdjgiLAotCQl9OwotCQlzdGF0aWMgc3RydWN0IHJlZ3VsYXRvcl9jb25zdW1lcl9zdXBwbHkgdXNiM3YxID0gewotCQkJLnN1cHBseSA9CSJ1c2IzdjEiLAotCQl9OwotCi0JCS8qIHRoaXMgaXMgYSB0ZW1wbGF0ZSB0aGF0IGdldHMgY29waWVkICovCi0JCXN0cnVjdCByZWd1bGF0b3JfaW5pdF9kYXRhIHVzYl9maXhlZCA9IHsKLQkJCS5jb25zdHJhaW50cy52YWxpZF9tb2Rlc19tYXNrID0KLQkJCQkgIFJFR1VMQVRPUl9NT0RFX05PUk1BTAotCQkJCXwgUkVHVUxBVE9SX01PREVfU1RBTkRCWSwKLQkJCS5jb25zdHJhaW50cy52YWxpZF9vcHNfbWFzayA9Ci0JCQkJICBSRUdVTEFUT1JfQ0hBTkdFX01PREUKLQkJCQl8IFJFR1VMQVRPUl9DSEFOR0VfU1RBVFVTLAotCQl9OwotCi0JCXVzYjF2NS5kZXYgPSB1c2JfdHJhbnNjZWl2ZXI7Ci0JCXVzYjF2OC5kZXYgPSB1c2JfdHJhbnNjZWl2ZXI7Ci0JCXVzYjN2MS5kZXYgPSB1c2JfdHJhbnNjZWl2ZXI7Ci0KLQkJY2hpbGQgPSBhZGRfcmVndWxhdG9yX2xpbmtlZChUV0w0MDMwX1JFR19WVVNCMVY1LCAmdXNiX2ZpeGVkLAotCQkJCSZ1c2IxdjUsIDEpOwotCQlpZiAoSVNfRVJSKGNoaWxkKSkKLQkJCXJldHVybiBQVFJfRVJSKGNoaWxkKTsKLQotCQljaGlsZCA9IGFkZF9yZWd1bGF0b3JfbGlua2VkKFRXTDQwMzBfUkVHX1ZVU0IxVjgsICZ1c2JfZml4ZWQsCi0JCQkJJnVzYjF2OCwgMSk7Ci0JCWlmIChJU19FUlIoY2hpbGQpKQotCQkJcmV0dXJuIFBUUl9FUlIoY2hpbGQpOwotCi0JCWNoaWxkID0gYWRkX3JlZ3VsYXRvcl9saW5rZWQoVFdMNDAzMF9SRUdfVlVTQjNWMSwgJnVzYl9maXhlZCwKLQkJCQkmdXNiM3YxLCAxKTsKLQkJaWYgKElTX0VSUihjaGlsZCkpCi0JCQlyZXR1cm4gUFRSX0VSUihjaGlsZCk7Ci0JfQotCiAJLyogbWF5YmUgYWRkIExET3MgdGhhdCBhcmUgb21pdHRlZCBvbiBjb3N0LXJlZHVjZWQgcGFydHMgKi8KIAlpZiAodHdsX2hhc19yZWd1bGF0b3IoKSAmJiAhKGZlYXR1cmVzICYgVFBTX1NVQlNFVCkpIHsKIAkJY2hpbGQgPSBhZGRfcmVndWxhdG9yKFRXTDQwMzBfUkVHX1ZQTEwyLCBwZGF0YS0+dnBsbDIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tZmQvdWNiMXgwMC1jb3JlLmMgYi9kcml2ZXJzL21mZC91Y2IxeDAwLWNvcmUuYwppbmRleCBmZWE5MDg1Li42MGMzOTg4IDEwMDY0NAotLS0gYS9kcml2ZXJzL21mZC91Y2IxeDAwLWNvcmUuYworKysgYi9kcml2ZXJzL21mZC91Y2IxeDAwLWNvcmUuYwpAQCAtMTgsNiArMTgsNyBAQAogICovCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvaHBpbG8uYyBiL2RyaXZlcnMvbWlzYy9ocGlsby5jCmluZGV4IDFhZDI3YzYuLmE5MmEzYTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9ocGlsby5jCisrKyBiL2RyaXZlcnMvbWlzYy9ocGlsby5jCkBAIC0xOCw2ICsxOCw3IEBACiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL21pc2MvaWJtYXNtL2NvbW1hbmQuYyBiL2RyaXZlcnMvbWlzYy9pYm1hc20vY29tbWFuZC5jCmluZGV4IDI3NmQzZmIuLmUyMDMxNzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9pYm1hc20vY29tbWFuZC5jCisrKyBiL2RyaXZlcnMvbWlzYy9pYm1hc20vY29tbWFuZC5jCkBAIC0yMiw2ICsyMiw3IEBACiAgKgogICovCiAKKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgImlibWFzbS5oIgogI2luY2x1ZGUgImxvd2xldmVsLmgiCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWlzYy9pYm1hc20vZXZlbnQuYyBiL2RyaXZlcnMvbWlzYy9pYm1hc20vZXZlbnQuYwppbmRleCA2OGEwYTViLi41NzJkNDFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL21pc2MvaWJtYXNtL2V2ZW50LmMKKysrIGIvZHJpdmVycy9taXNjL2libWFzbS9ldmVudC5jCkBAIC0yMiw2ICsyMiw3IEBACiAgKgogICovCiAKKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgImlibWFzbS5oIgogI2luY2x1ZGUgImxvd2xldmVsLmgiCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWlzYy9pYm1hc20vcl9oZWFydGJlYXQuYyBiL2RyaXZlcnMvbWlzYy9pYm1hc20vcl9oZWFydGJlYXQuYwppbmRleCBiZWM5ZTJjLi4yZGU0ODdhIDEwMDY0NAotLS0gYS9kcml2ZXJzL21pc2MvaWJtYXNtL3JfaGVhcnRiZWF0LmMKKysrIGIvZHJpdmVycy9taXNjL2libWFzbS9yX2hlYXJ0YmVhdC5jCkBAIC0yMCw2ICsyMCw3IEBACiAgKgogICovCiAKKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgImlibWFzbS5oIgogI2luY2x1ZGUgImRvdF9jb21tYW5kLmgiCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbWlzYy9waGFudG9tLmMgYi9kcml2ZXJzL21pc2MvcGhhbnRvbS5jCmluZGV4IDkwYTk1Y2UuLjA0YzI3MjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbWlzYy9waGFudG9tLmMKKysrIGIvZHJpdmVycy9taXNjL3BoYW50b20uYwpAQCAtMjIsNiArMjIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4KICNpbmNsdWRlIDxsaW51eC9waGFudG9tLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbXBfbG9jay5oPgogCiAjaW5jbHVkZSA8YXNtL2F0b21pYy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tbWMvaG9zdC9hdDkxX21jaS5jIGIvZHJpdmVycy9tbWMvaG9zdC9hdDkxX21jaS5jCmluZGV4IGU1NTZkNDIuLjYzOTI0ZTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbW1jL2hvc3QvYXQ5MV9tY2kuYworKysgYi9kcml2ZXJzL21tYy9ob3N0L2F0OTFfbWNpLmMKQEAgLTcyLDcgKzcyLDYgQEAKICNpbmNsdWRlIDxhc20vaXJxLmg+CiAjaW5jbHVkZSA8YXNtL2dwaW8uaD4KIAotI2luY2x1ZGUgPGFzbS9tYWNoL21tYy5oPgogI2luY2x1ZGUgPG1hY2gvYm9hcmQuaD4KICNpbmNsdWRlIDxtYWNoL2NwdS5oPgogI2luY2x1ZGUgPG1hY2gvYXQ5MV9tY2kuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbW1jL2hvc3Qvb21hcF9oc21tYy5jIGIvZHJpdmVycy9tbWMvaG9zdC9vbWFwX2hzbW1jLmMKaW5kZXggNDQ4N2NjMC4uMGFlY2FhZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tbWMvaG9zdC9vbWFwX2hzbW1jLmMKKysrIGIvZHJpdmVycy9tbWMvaG9zdC9vbWFwX2hzbW1jLmMKQEAgLTIwMTMsNyArMjAxMyw3IEBACiBzdGF0aWMgaW50IF9faW5pdCBvbWFwX2hzbW1jX2luaXQodm9pZCkKIHsKIAkvKiBSZWdpc3RlciB0aGUgTU1DIGRyaXZlciAqLwotCXJldHVybiBwbGF0Zm9ybV9kcml2ZXJfcmVnaXN0ZXIoJm9tYXBfaHNtbWNfZHJpdmVyKTsKKwlyZXR1cm4gcGxhdGZvcm1fZHJpdmVyX3Byb2JlKCZvbWFwX2hzbW1jX2RyaXZlciwgb21hcF9oc21tY19wcm9iZSk7CiB9CiAKIHN0YXRpYyB2b2lkIF9fZXhpdCBvbWFwX2hzbW1jX2NsZWFudXAodm9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbW1jL2hvc3QvcHhhbWNpLmMgYi9kcml2ZXJzL21tYy9ob3N0L3B4YW1jaS5jCmluZGV4IDVlMGIxNTIuLmIwMGQ2NzMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbW1jL2hvc3QvcHhhbWNpLmMKKysrIGIvZHJpdmVycy9tbWMvaG9zdC9weGFtY2kuYwpAQCAtNjkzLDcgKzY5Myw3IEBACiAJaWYgKGdwaW9faXNfdmFsaWQoZ3Bpb19ybykpIHsKIAkJcmV0ID0gZ3Bpb19yZXF1ZXN0KGdwaW9fcm8sICJtbWMgY2FyZCByZWFkIG9ubHkiKTsKIAkJaWYgKHJldCkgewotCQkJZGV2X2VycigmcGRldi0+ZGV2LCAiRmFpbGVkIHJlcXVlc3RpbmcgZ3Bpb19ybyAlZFxuIiwgZ3Bpb19wb3dlcik7CisJCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgcmVxdWVzdGluZyBncGlvX3JvICVkXG4iLCBncGlvX3JvKTsKIAkJCWdvdG8gZXJyX2dwaW9fcm87CiAJCX0KIAkJZ3Bpb19kaXJlY3Rpb25faW5wdXQoZ3Bpb19ybyk7CkBAIC03MDEsNyArNzAxLDcgQEAKIAlpZiAoZ3Bpb19pc192YWxpZChncGlvX2NkKSkgewogCQlyZXQgPSBncGlvX3JlcXVlc3QoZ3Bpb19jZCwgIm1tYyBjYXJkIGRldGVjdCIpOwogCQlpZiAocmV0KSB7Ci0JCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgcmVxdWVzdGluZyBncGlvX2NkICVkXG4iLCBncGlvX3Bvd2VyKTsKKwkJCWRldl9lcnIoJnBkZXYtPmRldiwgIkZhaWxlZCByZXF1ZXN0aW5nIGdwaW9fY2QgJWRcbiIsIGdwaW9fY2QpOwogCQkJZ290byBlcnJfZ3Bpb19jZDsKIAkJfQogCQlncGlvX2RpcmVjdGlvbl9pbnB1dChncGlvX2NkKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbXRkL2RldmljZXMvbTI1cDgwLmMgYi9kcml2ZXJzL210ZC9kZXZpY2VzL20yNXA4MC5jCmluZGV4IDM3OWMzMTYuLjRjMTkyNjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbXRkL2RldmljZXMvbTI1cDgwLmMKKysrIGIvZHJpdmVycy9tdGQvZGV2aWNlcy9tMjVwODAuYwpAQCAtMjEsNiArMjEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CiAjaW5jbHVkZSA8bGludXgvbWF0aDY0Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KIAogI2luY2x1ZGUgPGxpbnV4L210ZC9tdGQuaD4KICNpbmNsdWRlIDxsaW51eC9tdGQvcGFydGl0aW9ucy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9tdGQvZGV2aWNlcy9zc3QyNWwuYyBiL2RyaXZlcnMvbXRkL2RldmljZXMvc3N0MjVsLmMKaW5kZXggYzJiYWYzMy4uMGExMTcyMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9tdGQvZGV2aWNlcy9zc3QyNWwuYworKysgYi9kcml2ZXJzL210ZC9kZXZpY2VzL3NzdDI1bC5jCkBAIC0yMCw2ICsyMCw3IEBACiAjaW5jbHVkZSA8bGludXgvZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvbXV0ZXguaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogCiAjaW5jbHVkZSA8bGludXgvbXRkL210ZC5oPgogI2luY2x1ZGUgPGxpbnV4L210ZC9wYXJ0aXRpb25zLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9LY29uZmlnIGIvZHJpdmVycy9uZXQvS2NvbmZpZwppbmRleCA3MTI3NzYwLi5lMTljYTRiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9LY29uZmlnCisrKyBiL2RyaXZlcnMvbmV0L0tjb25maWcKQEAgLTE3NDEsNiArMTc0MSw3IEBACiBjb25maWcgS1M4ODUxX01MTAogCXRyaXN0YXRlICJNaWNyZWwgS1M4ODUxIE1MTCIKIAlkZXBlbmRzIG9uIEhBU19JT01FTQorCXNlbGVjdCBNSUkKIAloZWxwCiAJICBUaGlzIHBsYXRmb3JtIGRyaXZlciBpcyBmb3IgTWljcmVsIEtTODg1MSBBZGRyZXNzL2RhdGEgYnVzCiAJICBtdWx0aXBsZXhlZCBuZXR3b3JrIGNoaXAuCkBAIC0yNDgyLDYgKzI0ODMsOCBAQAogCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZS4gVGhlIG1vZHVsZQogCSAgd2lsbCBiZSBjYWxsZWQgczZnbWFjLgogCitzb3VyY2UgImRyaXZlcnMvbmV0L3N0bW1hYy9LY29uZmlnIgorCiBlbmRpZiAjIE5FVERFVl8xMDAwCiAKICMKQEAgLTMyMzAsNCArMzIzMywxMiBAQAogCSAgVGhpcyBpcyB0aGUgdmlydHVhbCBuZXR3b3JrIGRyaXZlciBmb3IgdmlydGlvLiAgSXQgY2FuIGJlIHVzZWQgd2l0aAogICAgICAgICAgIGxndWVzdCBvciBRRU1VIGJhc2VkIFZNTXMgKGxpa2UgS1ZNIG9yIFhlbikuICBTYXkgWSBvciBNLgogCitjb25maWcgVk1YTkVUMworICAgICAgIHRyaXN0YXRlICJWTXdhcmUgVk1YTkVUMyBldGhlcm5ldCBkcml2ZXIiCisgICAgICAgZGVwZW5kcyBvbiBQQ0kgJiYgWDg2ICYmIElORVQKKyAgICAgICBoZWxwCisgICAgICAgICBUaGlzIGRyaXZlciBzdXBwb3J0cyBWTXdhcmUncyB2bXhuZXQzIHZpcnR1YWwgZXRoZXJuZXQgTklDLgorICAgICAgICAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlCisgICAgICAgICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgdm14bmV0My4KKwogZW5kaWYgIyBORVRERVZJQ0VTCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9NYWtlZmlsZSBiL2RyaXZlcnMvbmV0L01ha2VmaWxlCmluZGV4IGQ4NjZiOGMuLjI0NjMyM2QgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L01ha2VmaWxlCisrKyBiL2RyaXZlcnMvbmV0L01ha2VmaWxlCkBAIC0yLDYgKzIsMTAgQEAKICMgTWFrZWZpbGUgZm9yIHRoZSBMaW51eCBuZXR3b3JrIChldGhlcmNhcmQpIGRldmljZSBkcml2ZXJzLgogIwogCitvYmotJChDT05GSUdfTUlJKSArPSBtaWkubworb2JqLSQoQ09ORklHX01ESU8pICs9IG1kaW8ubworb2JqLSQoQ09ORklHX1BIWUxJQikgKz0gcGh5LworCiBvYmotJChDT05GSUdfVElfREFWSU5DSV9FTUFDKSArPSBkYXZpbmNpX2VtYWMubwogCiBvYmotJChDT05GSUdfRTEwMDApICs9IGUxMDAwLwpAQCAtMjYsNiArMzAsNyBAQAogb2JqLSQoQ09ORklHX0VOSUMpICs9IGVuaWMvCiBvYmotJChDT05GSUdfSk1FKSArPSBqbWUubwogb2JqLSQoQ09ORklHX0JFMk5FVCkgKz0gYmVuZXQvCitvYmotJChDT05GSUdfVk1YTkVUMykgKz0gdm14bmV0My8KIAogZ2lhbmZhcl9kcml2ZXItb2JqcyA6PSBnaWFuZmFyLm8gXAogCQlnaWFuZmFyX2V0aHRvb2wubyBcCkBAIC05NSwxNSArMTAwLDEyIEBACiBvYmotJChDT05GSUdfQURBUFRFQ19TVEFSRklSRSkgKz0gc3RhcmZpcmUubwogb2JqLSQoQ09ORklHX1JJT05FVCkgKz0gcmlvbmV0Lm8KIG9iai0kKENPTkZJR19TSF9FVEgpICs9IHNoX2V0aC5vCitvYmotJChDT05GSUdfU1RNTUFDX0VUSCkgKz0gc3RtbWFjLwogCiAjCiAjIGVuZCBsaW5rIG9yZGVyIHNlY3Rpb24KICMKIAotb2JqLSQoQ09ORklHX01JSSkgKz0gbWlpLm8KLW9iai0kKENPTkZJR19NRElPKSArPSBtZGlvLm8KLW9iai0kKENPTkZJR19QSFlMSUIpICs9IHBoeS8KLQogb2JqLSQoQ09ORklHX1NVTkRBTkNFKSArPSBzdW5kYW5jZS5vCiBvYmotJChDT05GSUdfSEFNQUNISSkgKz0gaGFtYWNoaS5vCiBvYmotJChDT05GSUdfTkVUKSArPSBTcGFjZS5vIGxvb3BiYWNrLm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2FjZW5pYy5jIGIvZHJpdmVycy9uZXQvYWNlbmljLmMKaW5kZXggNWYwYjA1Yy4uZDgyYTlhOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYWNlbmljLmMKKysrIGIvZHJpdmVycy9uZXQvYWNlbmljLmMKQEAgLTEyMDksNyArMTIwOSw4IEBACiAJbWVtc2V0KGFwLT5pbmZvLCAwLCBzaXplb2Yoc3RydWN0IGFjZV9pbmZvKSk7CiAJbWVtc2V0KGFwLT5za2IsIDAsIHNpemVvZihzdHJ1Y3QgYWNlX3NrYikpOwogCi0JaWYgKGFjZV9sb2FkX2Zpcm13YXJlKGRldikpCisJZWNvZGUgPSBhY2VfbG9hZF9maXJtd2FyZShkZXYpOworCWlmIChlY29kZSkKIAkJZ290byBpbml0X2Vycm9yOwogCiAJYXAtPmZ3X3J1bm5pbmcgPSAwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5jIGIvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5jCmluZGV4IDg5ODc2YWQuLjI4YTBlZGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JlbmV0L2JlX2NtZHMuYworKysgYi9kcml2ZXJzL25ldC9iZW5ldC9iZV9jbWRzLmMKQEAgLTI0MywxNSArMjQzLDI2IEBACiAKIGludCBiZV9jbWRfUE9TVChzdHJ1Y3QgYmVfYWRhcHRlciAqYWRhcHRlcikKIHsKLQl1MTYgc3RhZ2UsIGVycm9yOworCXUxNiBzdGFnZTsKKwlpbnQgc3RhdHVzLCB0aW1lb3V0ID0gMDsKIAotCWVycm9yID0gYmVfUE9TVF9zdGFnZV9nZXQoYWRhcHRlciwgJnN0YWdlKTsKLQlpZiAoZXJyb3IgfHwgc3RhZ2UgIT0gUE9TVF9TVEFHRV9BUk1GV19SRFkpIHsKLQkJZGV2X2VycigmYWRhcHRlci0+cGRldi0+ZGV2LCAiUE9TVCBmYWlsZWQuXG4iKTsKLQkJcmV0dXJuIC0xOwotCX0KKwlkbyB7CisJCXN0YXR1cyA9IGJlX1BPU1Rfc3RhZ2VfZ2V0KGFkYXB0ZXIsICZzdGFnZSk7CisJCWlmIChzdGF0dXMpIHsKKwkJCWRldl9lcnIoJmFkYXB0ZXItPnBkZXYtPmRldiwgIlBPU1QgZXJyb3I7IHN0YWdlPTB4JXhcbiIsCisJCQkJc3RhZ2UpOworCQkJcmV0dXJuIC0xOworCQl9IGVsc2UgaWYgKHN0YWdlICE9IFBPU1RfU1RBR0VfQVJNRldfUkRZKSB7CisJCQlzZXRfY3VycmVudF9zdGF0ZShUQVNLX0lOVEVSUlVQVElCTEUpOworCQkJc2NoZWR1bGVfdGltZW91dCgyICogSFopOworCQkJdGltZW91dCArPSAyOworCQl9IGVsc2UgeworCQkJcmV0dXJuIDA7CisJCX0KKwl9IHdoaWxlICh0aW1lb3V0IDwgMjApOwogCi0JcmV0dXJuIDA7CisJZGV2X2VycigmYWRhcHRlci0+cGRldi0+ZGV2LCAiUE9TVCB0aW1lb3V0OyBzdGFnZT0weCV4XG4iLCBzdGFnZSk7CisJcmV0dXJuIC0xOwogfQogCiBzdGF0aWMgaW5saW5lIHZvaWQgKmVtYmVkZGVkX3BheWxvYWQoc3RydWN0IGJlX21jY193cmIgKndyYikKQEAgLTcyOSw4ICs3NDAsOCBAQAogLyogQ3JlYXRlIGFuIHJ4IGZpbHRlcmluZyBwb2xpY3kgY29uZmlndXJhdGlvbiBvbiBhbiBpL2YKICAqIFVzZXMgbWJveAogICovCi1pbnQgYmVfY21kX2lmX2NyZWF0ZShzdHJ1Y3QgYmVfYWRhcHRlciAqYWRhcHRlciwgdTMyIGZsYWdzLCB1OCAqbWFjLAotCQlib29sIHBtYWNfaW52YWxpZCwgdTMyICppZl9oYW5kbGUsIHUzMiAqcG1hY19pZCkKK2ludCBiZV9jbWRfaWZfY3JlYXRlKHN0cnVjdCBiZV9hZGFwdGVyICphZGFwdGVyLCB1MzIgY2FwX2ZsYWdzLCB1MzIgZW5fZmxhZ3MsCisJCXU4ICptYWMsIGJvb2wgcG1hY19pbnZhbGlkLCB1MzIgKmlmX2hhbmRsZSwgdTMyICpwbWFjX2lkKQogewogCXN0cnVjdCBiZV9tY2Nfd3JiICp3cmI7CiAJc3RydWN0IGJlX2NtZF9yZXFfaWZfY3JlYXRlICpyZXE7CkBAIC03NDYsOCArNzU3LDggQEAKIAliZV9jbWRfaGRyX3ByZXBhcmUoJnJlcS0+aGRyLCBDTURfU1VCU1lTVEVNX0NPTU1PTiwKIAkJT1BDT0RFX0NPTU1PTl9OVFdLX0lOVEVSRkFDRV9DUkVBVEUsIHNpemVvZigqcmVxKSk7CiAKLQlyZXEtPmNhcGFiaWxpdHlfZmxhZ3MgPSBjcHVfdG9fbGUzMihmbGFncyk7Ci0JcmVxLT5lbmFibGVfZmxhZ3MgPSBjcHVfdG9fbGUzMihmbGFncyk7CisJcmVxLT5jYXBhYmlsaXR5X2ZsYWdzID0gY3B1X3RvX2xlMzIoY2FwX2ZsYWdzKTsKKwlyZXEtPmVuYWJsZV9mbGFncyA9IGNwdV90b19sZTMyKGVuX2ZsYWdzKTsKIAlyZXEtPnBtYWNfaW52YWxpZCA9IHBtYWNfaW52YWxpZDsKIAlpZiAoIXBtYWNfaW52YWxpZCkKIAkJbWVtY3B5KHJlcS0+bWFjX2FkZHIsIG1hYywgRVRIX0FMRU4pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5oIGIvZHJpdmVycy9uZXQvYmVuZXQvYmVfY21kcy5oCmluZGV4IGE4NmY5MTcuLjQ5OTUzNzggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2JlbmV0L2JlX2NtZHMuaAorKysgYi9kcml2ZXJzL25ldC9iZW5ldC9iZV9jbWRzLmgKQEAgLTcyMCw4ICs3MjAsOSBAQAogZXh0ZXJuIGludCBiZV9jbWRfcG1hY19hZGQoc3RydWN0IGJlX2FkYXB0ZXIgKmFkYXB0ZXIsIHU4ICptYWNfYWRkciwKIAkJCXUzMiBpZl9pZCwgdTMyICpwbWFjX2lkKTsKIGV4dGVybiBpbnQgYmVfY21kX3BtYWNfZGVsKHN0cnVjdCBiZV9hZGFwdGVyICphZGFwdGVyLCB1MzIgaWZfaWQsIHUzMiBwbWFjX2lkKTsKLWV4dGVybiBpbnQgYmVfY21kX2lmX2NyZWF0ZShzdHJ1Y3QgYmVfYWRhcHRlciAqYWRhcHRlciwgdTMyIGlmX2ZsYWdzLCB1OCAqbWFjLAotCQkJYm9vbCBwbWFjX2ludmFsaWQsIHUzMiAqaWZfaGFuZGxlLCB1MzIgKnBtYWNfaWQpOworZXh0ZXJuIGludCBiZV9jbWRfaWZfY3JlYXRlKHN0cnVjdCBiZV9hZGFwdGVyICphZGFwdGVyLCB1MzIgY2FwX2ZsYWdzLAorCQkJdTMyIGVuX2ZsYWdzLCB1OCAqbWFjLCBib29sIHBtYWNfaW52YWxpZCwKKwkJCXUzMiAqaWZfaGFuZGxlLCB1MzIgKnBtYWNfaWQpOwogZXh0ZXJuIGludCBiZV9jbWRfaWZfZGVzdHJveShzdHJ1Y3QgYmVfYWRhcHRlciAqYWRhcHRlciwgdTMyIGlmX2hhbmRsZSk7CiBleHRlcm4gaW50IGJlX2NtZF9lcV9jcmVhdGUoc3RydWN0IGJlX2FkYXB0ZXIgKmFkYXB0ZXIsCiAJCQlzdHJ1Y3QgYmVfcXVldWVfaW5mbyAqZXEsIGludCBlcV9kZWxheSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9iZW5ldC9iZV9tYWluLmMgYi9kcml2ZXJzL25ldC9iZW5ldC9iZV9tYWluLmMKaW5kZXggNmQ1ZTgxZi4uMWY5NDFmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYmVuZXQvYmVfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L2JlbmV0L2JlX21haW4uYwpAQCAtMTYyMCwxOSArMTYyMCwyMiBAQAogc3RhdGljIGludCBiZV9zZXR1cChzdHJ1Y3QgYmVfYWRhcHRlciAqYWRhcHRlcikKIHsKIAlzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2ID0gYWRhcHRlci0+bmV0ZGV2OwotCXUzMiBpZl9mbGFnczsKKwl1MzIgY2FwX2ZsYWdzLCBlbl9mbGFnczsKIAlpbnQgc3RhdHVzOwogCi0JaWZfZmxhZ3MgPSBCRV9JRl9GTEFHU19CUk9BRENBU1QgfCBCRV9JRl9GTEFHU19QUk9NSVNDVU9VUyB8Ci0JCUJFX0lGX0ZMQUdTX01DQVNUX1BST01JU0NVT1VTIHwgQkVfSUZfRkxBR1NfVU5UQUdHRUQgfAotCQlCRV9JRl9GTEFHU19QQVNTX0wzTDRfRVJST1JTOwotCXN0YXR1cyA9IGJlX2NtZF9pZl9jcmVhdGUoYWRhcHRlciwgaWZfZmxhZ3MsIG5ldGRldi0+ZGV2X2FkZHIsCi0JCQlmYWxzZS8qIHBtYWNfaW52YWxpZCAqLywgJmFkYXB0ZXItPmlmX2hhbmRsZSwKLQkJCSZhZGFwdGVyLT5wbWFjX2lkKTsKKwljYXBfZmxhZ3MgPSBCRV9JRl9GTEFHU19VTlRBR0dFRCB8IEJFX0lGX0ZMQUdTX0JST0FEQ0FTVCB8CisJCQlCRV9JRl9GTEFHU19NQ0FTVF9QUk9NSVNDVU9VUyB8CisJCQlCRV9JRl9GTEFHU19QUk9NSVNDVU9VUyB8CisJCQlCRV9JRl9GTEFHU19QQVNTX0wzTDRfRVJST1JTOworCWVuX2ZsYWdzID0gQkVfSUZfRkxBR1NfVU5UQUdHRUQgfCBCRV9JRl9GTEFHU19CUk9BRENBU1QgfAorCQkJQkVfSUZfRkxBR1NfUEFTU19MM0w0X0VSUk9SUzsKKworCXN0YXR1cyA9IGJlX2NtZF9pZl9jcmVhdGUoYWRhcHRlciwgY2FwX2ZsYWdzLCBlbl9mbGFncywKKwkJCW5ldGRldi0+ZGV2X2FkZHIsIGZhbHNlLyogcG1hY19pbnZhbGlkICovLAorCQkJJmFkYXB0ZXItPmlmX2hhbmRsZSwgJmFkYXB0ZXItPnBtYWNfaWQpOwogCWlmIChzdGF0dXMgIT0gMCkKIAkJZ290byBkb19ub25lOwogCi0KIAlzdGF0dXMgPSBiZV90eF9xdWV1ZXNfY3JlYXRlKGFkYXB0ZXIpOwogCWlmIChzdGF0dXMgIT0gMCkKIAkJZ290byBpZl9kZXN0cm95OwpAQCAtMjA1NSw2ICsyMDU4LDEwIEBACiAJaWYgKHN0YXR1cykKIAkJcmV0dXJuIHN0YXR1czsKIAorCXN0YXR1cyA9IGJlX2NtZF9yZXNldF9mdW5jdGlvbihhZGFwdGVyKTsKKwlpZiAoc3RhdHVzKQorCQlyZXR1cm4gc3RhdHVzOworCiAJc3RhdHVzID0gYmVfY21kX2dldF9md192ZXIoYWRhcHRlciwgYWRhcHRlci0+ZndfdmVyKTsKIAlpZiAoc3RhdHVzKQogCQlyZXR1cm4gc3RhdHVzOwpAQCAtMjEwOCwxMCArMjExNSw2IEBACiAJaWYgKHN0YXR1cykKIAkJZ290byBmcmVlX25ldGRldjsKIAotCXN0YXR1cyA9IGJlX2NtZF9yZXNldF9mdW5jdGlvbihhZGFwdGVyKTsKLQlpZiAoc3RhdHVzKQotCQlnb3RvIGN0cmxfY2xlYW47Ci0KIAlzdGF0dXMgPSBiZV9zdGF0c19pbml0KGFkYXB0ZXIpOwogCWlmIChzdGF0dXMpCiAJCWdvdG8gY3RybF9jbGVhbjsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2JvbmRpbmcvYm9uZF9zeXNmcy5jIGIvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX3N5c2ZzLmMKaW5kZXggZmY0NDlkZS4uODc2MmEyNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX3N5c2ZzLmMKKysrIGIvZHJpdmVycy9uZXQvYm9uZGluZy9ib25kX3N5c2ZzLmMKQEAgLTIyLDYgKzIyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3N5c2Rldi5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2Nhbi9zamExMDAwL3NqYTEwMDBfb2ZfcGxhdGZvcm0uYyBiL2RyaXZlcnMvbmV0L2Nhbi9zamExMDAwL3NqYTEwMDBfb2ZfcGxhdGZvcm0uYwppbmRleCAzMzczNTYwLi45ZGQwNzZhIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9jYW4vc2phMTAwMC9zamExMDAwX29mX3BsYXRmb3JtLmMKKysrIGIvZHJpdmVycy9uZXQvY2FuL3NqYTEwMDAvc2phMTAwMF9vZl9wbGF0Zm9ybS5jCkBAIC0yMTMsNiArMjEzLDcgQEAKIAl7LmNvbXBhdGlibGUgPSAibnhwLHNqYTEwMDAifSwKIAl7fSwKIH07CitNT0RVTEVfREVWSUNFX1RBQkxFKG9mLCBzamExMDAwX29mcF90YWJsZSk7CiAKIHN0YXRpYyBzdHJ1Y3Qgb2ZfcGxhdGZvcm1fZHJpdmVyIHNqYTEwMDBfb2ZwX2RyaXZlciA9IHsKIAkub3duZXIgPSBUSElTX01PRFVMRSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2RhdmluY2lfZW1hYy5jIGIvZHJpdmVycy9uZXQvZGF2aW5jaV9lbWFjLmMKaW5kZXggNjVhMmQwYi4uZjcyYzU2ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZGF2aW5jaV9lbWFjLmMKKysrIGIvZHJpdmVycy9uZXQvZGF2aW5jaV9lbWFjLmMKQEAgLTMzMyw2ICszMzMsOSBAQAogI2RlZmluZSBFTUFDX0RNNjQ2WF9NQUNfRU9JX0MwX1JYRU4JKDB4MDEpCiAjZGVmaW5lIEVNQUNfRE02NDZYX01BQ19FT0lfQzBfVFhFTgkoMHgwMikKIAorLyogRU1BQyBTdGF0cyBDbGVhciBNYXNrICovCisjZGVmaW5lIEVNQUNfU1RBVFNfQ0xSX01BU0sgICAgKDB4RkZGRkZGRkYpCisKIC8qKiBuZXRfYnVmX29iajogRU1BQyBuZXR3b3JrIGJ1ZmZlcmRhdGEgc3RydWN0dXJlCiAgKgogICogRU1BQyBuZXR3b3JrIGJ1ZmZlciBkYXRhIHN0cnVjdHVyZQpAQCAtMjU0OCw0MCArMjU1MSw0OSBAQAogc3RhdGljIHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICplbWFjX2Rldl9nZXRuZXRzdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqbmRldikKIHsKIAlzdHJ1Y3QgZW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYobmRldik7CisJdTMyIG1hY19jb250cm9sOworCXUzMiBzdGF0c19jbGVhcl9tYXNrOwogCiAJLyogdXBkYXRlIGVtYWMgaGFyZHdhcmUgc3RhdHMgYW5kIHJlc2V0IHRoZSByZWdpc3RlcnMqLwogCisJbWFjX2NvbnRyb2wgPSBlbWFjX3JlYWQoRU1BQ19NQUNDT05UUk9MKTsKKworCWlmIChtYWNfY29udHJvbCAmIEVNQUNfTUFDQ09OVFJPTF9HTUlJRU4pCisJCXN0YXRzX2NsZWFyX21hc2sgPSBFTUFDX1NUQVRTX0NMUl9NQVNLOworCWVsc2UKKwkJc3RhdHNfY2xlYXJfbWFzayA9IDA7CisKIAlwcml2LT5uZXRfZGV2X3N0YXRzLm11bHRpY2FzdCArPSBlbWFjX3JlYWQoRU1BQ19SWE1DQVNURlJBTUVTKTsKLQllbWFjX3dyaXRlKEVNQUNfUlhNQ0FTVEZSQU1FUywgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKKwllbWFjX3dyaXRlKEVNQUNfUlhNQ0FTVEZSQU1FUywgc3RhdHNfY2xlYXJfbWFzayk7CiAKIAlwcml2LT5uZXRfZGV2X3N0YXRzLmNvbGxpc2lvbnMgKz0gKGVtYWNfcmVhZChFTUFDX1RYQ09MTElTSU9OKSArCiAJCQkJCSAgIGVtYWNfcmVhZChFTUFDX1RYU0lOR0xFQ09MTCkgKwogCQkJCQkgICBlbWFjX3JlYWQoRU1BQ19UWE1VTFRJQ09MTCkpOwotCWVtYWNfd3JpdGUoRU1BQ19UWENPTExJU0lPTiwgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKLQllbWFjX3dyaXRlKEVNQUNfVFhTSU5HTEVDT0xMLCBFTUFDX0FMTF9NVUxUSV9SRUdfVkFMVUUpOwotCWVtYWNfd3JpdGUoRU1BQ19UWE1VTFRJQ09MTCwgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKKwllbWFjX3dyaXRlKEVNQUNfVFhDT0xMSVNJT04sIHN0YXRzX2NsZWFyX21hc2spOworCWVtYWNfd3JpdGUoRU1BQ19UWFNJTkdMRUNPTEwsIHN0YXRzX2NsZWFyX21hc2spOworCWVtYWNfd3JpdGUoRU1BQ19UWE1VTFRJQ09MTCwgc3RhdHNfY2xlYXJfbWFzayk7CiAKIAlwcml2LT5uZXRfZGV2X3N0YXRzLnJ4X2xlbmd0aF9lcnJvcnMgKz0gKGVtYWNfcmVhZChFTUFDX1JYT1ZFUlNJWkVEKSArCiAJCQkJCQllbWFjX3JlYWQoRU1BQ19SWEpBQkJFUikgKwogCQkJCQkJZW1hY19yZWFkKEVNQUNfUlhVTkRFUlNJWkVEKSk7Ci0JZW1hY193cml0ZShFTUFDX1JYT1ZFUlNJWkVELCBFTUFDX0FMTF9NVUxUSV9SRUdfVkFMVUUpOwotCWVtYWNfd3JpdGUoRU1BQ19SWEpBQkJFUiwgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKLQllbWFjX3dyaXRlKEVNQUNfUlhVTkRFUlNJWkVELCBFTUFDX0FMTF9NVUxUSV9SRUdfVkFMVUUpOworCWVtYWNfd3JpdGUoRU1BQ19SWE9WRVJTSVpFRCwgc3RhdHNfY2xlYXJfbWFzayk7CisJZW1hY193cml0ZShFTUFDX1JYSkFCQkVSLCBzdGF0c19jbGVhcl9tYXNrKTsKKwllbWFjX3dyaXRlKEVNQUNfUlhVTkRFUlNJWkVELCBzdGF0c19jbGVhcl9tYXNrKTsKIAogCXByaXYtPm5ldF9kZXZfc3RhdHMucnhfb3Zlcl9lcnJvcnMgKz0gKGVtYWNfcmVhZChFTUFDX1JYU09GT1ZFUlJVTlMpICsKIAkJCQkJICAgICAgIGVtYWNfcmVhZChFTUFDX1JYTU9GT1ZFUlJVTlMpKTsKLQllbWFjX3dyaXRlKEVNQUNfUlhTT0ZPVkVSUlVOUywgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKLQllbWFjX3dyaXRlKEVNQUNfUlhNT0ZPVkVSUlVOUywgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKKwllbWFjX3dyaXRlKEVNQUNfUlhTT0ZPVkVSUlVOUywgc3RhdHNfY2xlYXJfbWFzayk7CisJZW1hY193cml0ZShFTUFDX1JYTU9GT1ZFUlJVTlMsIHN0YXRzX2NsZWFyX21hc2spOwogCiAJcHJpdi0+bmV0X2Rldl9zdGF0cy5yeF9maWZvX2Vycm9ycyArPSBlbWFjX3JlYWQoRU1BQ19SWERNQU9WRVJSVU5TKTsKLQllbWFjX3dyaXRlKEVNQUNfUlhETUFPVkVSUlVOUywgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKKwllbWFjX3dyaXRlKEVNQUNfUlhETUFPVkVSUlVOUywgc3RhdHNfY2xlYXJfbWFzayk7CiAKIAlwcml2LT5uZXRfZGV2X3N0YXRzLnR4X2NhcnJpZXJfZXJyb3JzICs9CiAJCWVtYWNfcmVhZChFTUFDX1RYQ0FSUklFUlNFTlNFKTsKLQllbWFjX3dyaXRlKEVNQUNfVFhDQVJSSUVSU0VOU0UsIEVNQUNfQUxMX01VTFRJX1JFR19WQUxVRSk7CisJZW1hY193cml0ZShFTUFDX1RYQ0FSUklFUlNFTlNFLCBzdGF0c19jbGVhcl9tYXNrKTsKIAogCXByaXYtPm5ldF9kZXZfc3RhdHMudHhfZmlmb19lcnJvcnMgPSBlbWFjX3JlYWQoRU1BQ19UWFVOREVSUlVOKTsKLQllbWFjX3dyaXRlKEVNQUNfVFhVTkRFUlJVTiwgRU1BQ19BTExfTVVMVElfUkVHX1ZBTFVFKTsKKwllbWFjX3dyaXRlKEVNQUNfVFhVTkRFUlJVTiwgc3RhdHNfY2xlYXJfbWFzayk7CiAKIAlyZXR1cm4gJnByaXYtPm5ldF9kZXZfc3RhdHM7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9kZXBjYS5jIGIvZHJpdmVycy9uZXQvZGVwY2EuYwppbmRleCA5Njg2YzFmLi43YTNiZGFjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9kZXBjYS5jCisrKyBiL2RyaXZlcnMvbmV0L2RlcGNhLmMKQEAgLTIzNyw2ICsyMzcsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZTEwMC5jIGIvZHJpdmVycy9uZXQvZTEwMC5jCmluZGV4IDY3OTk2NWMuLjVkMmY0OGYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2UxMDAuYworKysgYi9kcml2ZXJzL25ldC9lMTAwLmMKQEAgLTE1MSw2ICsxNTEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2VxbC5jIGIvZHJpdmVycy9uZXQvZXFsLmMKaW5kZXggZDRkOWEzZS4uZjViOTZjYWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2VxbC5jCisrKyBiL2RyaXZlcnMvbmV0L2VxbC5jCkBAIC0xMTEsNiArMTExLDcgQEAKICAqIFNvcnJ5LCBJIGhhZCB0byByZXdyaXRlIG1vc3Qgb2YgdGhpcyBmb3IgMi41LnggLURhdmVNCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ldGhvYy5jIGIvZHJpdmVycy9uZXQvZXRob2MuYwppbmRleCAzNGQwYzY5Li5mN2Q5YWM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ldGhvYy5jCisrKyBiL2RyaXZlcnMvbmV0L2V0aG9jLmMKQEAgLTE3LDYgKzE3LDcgQEAKICNpbmNsdWRlIDxsaW51eC9taWkuaD4KICNpbmNsdWRlIDxsaW51eC9waHkuaD4KICNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPG5ldC9ldGhvYy5oPgogCiBzdGF0aWMgaW50IGJ1ZmZlcl9zaXplID0gMHg4MDAwOyAvKiAzMiBLQnl0ZXMgKi8KQEAgLTIyMiwyNCArMjIzLDI1IEBACiAJdTMyIGFkZHI7CiB9OwogCi1zdGF0aWMgdTMyIGV0aG9jX3JlYWQoc3RydWN0IGV0aG9jICpkZXYsIGxvZmZfdCBvZmZzZXQpCitzdGF0aWMgaW5saW5lIHUzMiBldGhvY19yZWFkKHN0cnVjdCBldGhvYyAqZGV2LCBsb2ZmX3Qgb2Zmc2V0KQogewogCXJldHVybiBpb3JlYWQzMihkZXYtPmlvYmFzZSArIG9mZnNldCk7CiB9CiAKLXN0YXRpYyB2b2lkIGV0aG9jX3dyaXRlKHN0cnVjdCBldGhvYyAqZGV2LCBsb2ZmX3Qgb2Zmc2V0LCB1MzIgZGF0YSkKK3N0YXRpYyBpbmxpbmUgdm9pZCBldGhvY193cml0ZShzdHJ1Y3QgZXRob2MgKmRldiwgbG9mZl90IG9mZnNldCwgdTMyIGRhdGEpCiB7CiAJaW93cml0ZTMyKGRhdGEsIGRldi0+aW9iYXNlICsgb2Zmc2V0KTsKIH0KIAotc3RhdGljIHZvaWQgZXRob2NfcmVhZF9iZChzdHJ1Y3QgZXRob2MgKmRldiwgaW50IGluZGV4LCBzdHJ1Y3QgZXRob2NfYmQgKmJkKQorc3RhdGljIGlubGluZSB2b2lkIGV0aG9jX3JlYWRfYmQoc3RydWN0IGV0aG9jICpkZXYsIGludCBpbmRleCwKKwkJc3RydWN0IGV0aG9jX2JkICpiZCkKIHsKIAlsb2ZmX3Qgb2Zmc2V0ID0gRVRIT0NfQkRfQkFTRSArIChpbmRleCAqIHNpemVvZihzdHJ1Y3QgZXRob2NfYmQpKTsKIAliZC0+c3RhdCA9IGV0aG9jX3JlYWQoZGV2LCBvZmZzZXQgKyAwKTsKIAliZC0+YWRkciA9IGV0aG9jX3JlYWQoZGV2LCBvZmZzZXQgKyA0KTsKIH0KIAotc3RhdGljIHZvaWQgZXRob2Nfd3JpdGVfYmQoc3RydWN0IGV0aG9jICpkZXYsIGludCBpbmRleCwKK3N0YXRpYyBpbmxpbmUgdm9pZCBldGhvY193cml0ZV9iZChzdHJ1Y3QgZXRob2MgKmRldiwgaW50IGluZGV4LAogCQljb25zdCBzdHJ1Y3QgZXRob2NfYmQgKmJkKQogewogCWxvZmZfdCBvZmZzZXQgPSBFVEhPQ19CRF9CQVNFICsgKGluZGV4ICogc2l6ZW9mKHN0cnVjdCBldGhvY19iZCkpOwpAQCAtMjQ3LDMzICsyNDksMzMgQEAKIAlldGhvY193cml0ZShkZXYsIG9mZnNldCArIDQsIGJkLT5hZGRyKTsKIH0KIAotc3RhdGljIHZvaWQgZXRob2NfZW5hYmxlX2lycShzdHJ1Y3QgZXRob2MgKmRldiwgdTMyIG1hc2spCitzdGF0aWMgaW5saW5lIHZvaWQgZXRob2NfZW5hYmxlX2lycShzdHJ1Y3QgZXRob2MgKmRldiwgdTMyIG1hc2spCiB7CiAJdTMyIGltYXNrID0gZXRob2NfcmVhZChkZXYsIElOVF9NQVNLKTsKIAlpbWFzayB8PSBtYXNrOwogCWV0aG9jX3dyaXRlKGRldiwgSU5UX01BU0ssIGltYXNrKTsKIH0KIAotc3RhdGljIHZvaWQgZXRob2NfZGlzYWJsZV9pcnEoc3RydWN0IGV0aG9jICpkZXYsIHUzMiBtYXNrKQorc3RhdGljIGlubGluZSB2b2lkIGV0aG9jX2Rpc2FibGVfaXJxKHN0cnVjdCBldGhvYyAqZGV2LCB1MzIgbWFzaykKIHsKIAl1MzIgaW1hc2sgPSBldGhvY19yZWFkKGRldiwgSU5UX01BU0spOwogCWltYXNrICY9IH5tYXNrOwogCWV0aG9jX3dyaXRlKGRldiwgSU5UX01BU0ssIGltYXNrKTsKIH0KIAotc3RhdGljIHZvaWQgZXRob2NfYWNrX2lycShzdHJ1Y3QgZXRob2MgKmRldiwgdTMyIG1hc2spCitzdGF0aWMgaW5saW5lIHZvaWQgZXRob2NfYWNrX2lycShzdHJ1Y3QgZXRob2MgKmRldiwgdTMyIG1hc2spCiB7CiAJZXRob2Nfd3JpdGUoZGV2LCBJTlRfU09VUkNFLCBtYXNrKTsKIH0KIAotc3RhdGljIHZvaWQgZXRob2NfZW5hYmxlX3J4X2FuZF90eChzdHJ1Y3QgZXRob2MgKmRldikKK3N0YXRpYyBpbmxpbmUgdm9pZCBldGhvY19lbmFibGVfcnhfYW5kX3R4KHN0cnVjdCBldGhvYyAqZGV2KQogewogCXUzMiBtb2RlID0gZXRob2NfcmVhZChkZXYsIE1PREVSKTsKIAltb2RlIHw9IE1PREVSX1JYRU4gfCBNT0RFUl9UWEVOOwogCWV0aG9jX3dyaXRlKGRldiwgTU9ERVIsIG1vZGUpOwogfQogCi1zdGF0aWMgdm9pZCBldGhvY19kaXNhYmxlX3J4X2FuZF90eChzdHJ1Y3QgZXRob2MgKmRldikKK3N0YXRpYyBpbmxpbmUgdm9pZCBldGhvY19kaXNhYmxlX3J4X2FuZF90eChzdHJ1Y3QgZXRob2MgKmRldikKIHsKIAl1MzIgbW9kZSA9IGV0aG9jX3JlYWQoZGV2LCBNT0RFUik7CiAJbW9kZSAmPSB+KE1PREVSX1JYRU4gfCBNT0RFUl9UWEVOKTsKQEAgLTUwNyw3ICs1MDksNyBAQAogCQlyZXR1cm4gSVJRX05PTkU7CiAJfQogCi0JZXRob2NfYWNrX2lycShwcml2LCBJTlRfTUFTS19BTEwpOworCWV0aG9jX2Fja19pcnEocHJpdiwgcGVuZGluZyk7CiAKIAlpZiAocGVuZGluZyAmIElOVF9NQVNLX0JVU1kpIHsKIAkJZGV2X2VycigmZGV2LT5kZXYsICJwYWNrZXQgZHJvcHBlZFxuIik7CkBAIC02NjMsNyArNjY1LDggQEAKIAkJcmV0dXJuIHJldDsKIAogCS8qIGNhbGN1bGF0ZSB0aGUgbnVtYmVyIG9mIFRYL1JYIGJ1ZmZlcnMsIG1heGltdW0gMTI4IHN1cHBvcnRlZCAqLwotCW51bV9iZCA9IG1pbigxMjgsIChkZXYtPm1lbV9lbmQgLSBkZXYtPm1lbV9zdGFydCArIDEpIC8gRVRIT0NfQlVGU0laKTsKKwludW1fYmQgPSBtaW5fdCh1bnNpZ25lZCBpbnQsCisJCTEyOCwgKGRldi0+bWVtX2VuZCAtIGRldi0+bWVtX3N0YXJ0ICsgMSkgLyBFVEhPQ19CVUZTSVopOwogCXByaXYtPm51bV90eCA9IG1heChtaW5fdHgsIG51bV9iZCAvIDQpOwogCXByaXYtPm51bV9yeCA9IG51bV9iZCAtIHByaXYtPm51bV90eDsKIAlldGhvY193cml0ZShwcml2LCBUWF9CRF9OVU0sIHByaXYtPm51bV90eCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9ld3JrMy5jIGIvZHJpdmVycy9uZXQvZXdyazMuYwppbmRleCBiMmE1ZWM4Li5kZDRiYTAxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9ld3JrMy5jCisrKyBiL2RyaXZlcnMvbmV0L2V3cmszLmMKQEAgLTE0NSw2ICsxNDUsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZmVjLmMgYi9kcml2ZXJzL25ldC9mZWMuYwppbmRleCAyOTIzNDM4Li4xNmExZDU4IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9mZWMuYworKysgYi9kcml2ZXJzL25ldC9mZWMuYwpAQCAtMTY1NCw3ICsxNjU0LDcgQEAKICAgKgogICAqIGluZGV4IGlzIG9ubHkgdXNlZCBpbiBsZWdhY3kgY29kZQogICAqLwotaW50IF9faW5pdCBmZWNfZW5ldF9pbml0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIGludCBpbmRleCkKK3N0YXRpYyBpbnQgZmVjX2VuZXRfaW5pdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBpbnQgaW5kZXgpCiB7CiAJc3RydWN0IGZlY19lbmV0X3ByaXZhdGUgKmZlcCA9IG5ldGRldl9wcml2KGRldik7CiAJc3RydWN0IGJ1ZmRlc2MgKmNiZF9iYXNlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZmVjX21wYzUyeHguYyBiL2RyaXZlcnMvbmV0L2ZlY19tcGM1Mnh4LmMKaW5kZXggYzQwMTEzZi4uNjZkYWNlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZmVjX21wYzUyeHguYworKysgYi9kcml2ZXJzL25ldC9mZWNfbXBjNTJ4eC5jCkBAIC03NTksMTIgKzc1OSw2IEBACiAKIAltcGM1Mnh4X2ZlY19od19pbml0KGRldik7CiAKLQlpZiAocHJpdi0+cGh5ZGV2KSB7Ci0JCXBoeV9zdG9wKHByaXYtPnBoeWRldik7Ci0JCXBoeV93cml0ZShwcml2LT5waHlkZXYsIE1JSV9CTUNSLCBCTUNSX1JFU0VUKTsKLQkJcGh5X3N0YXJ0KHByaXYtPnBoeWRldik7Ci0JfQotCiAJYmNvbV9mZWNfcnhfcmVzZXQocHJpdi0+cnhfZG1hdHNrKTsKIAliY29tX2ZlY190eF9yZXNldChwcml2LT50eF9kbWF0c2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9mZWNfbXBjNTJ4eF9waHkuYyBiL2RyaXZlcnMvbmV0L2ZlY19tcGM1Mnh4X3BoeS5jCmluZGV4IDMxZTZkNjIuLmVlMGYzYzYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2ZlY19tcGM1Mnh4X3BoeS5jCisrKyBiL2RyaXZlcnMvbmV0L2ZlY19tcGM1Mnh4X3BoeS5jCkBAIC0xNTUsNiArMTU1LDcgQEAKIAl7IC5jb21wYXRpYmxlID0gIm1wYzUyMDBiLWZlYy1waHkiLCB9LAogCXt9CiB9OworTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgbXBjNTJ4eF9mZWNfbWRpb19tYXRjaCk7CiAKIHN0cnVjdCBvZl9wbGF0Zm9ybV9kcml2ZXIgbXBjNTJ4eF9mZWNfbWRpb19kcml2ZXIgPSB7CiAJLm5hbWUgPSAibXBjNTIwMGItZmVjLXBoeSIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9mb3JjZWRldGguYyBiL2RyaXZlcnMvbmV0L2ZvcmNlZGV0aC5jCmluZGV4IDBhMWMyYmIuLmUxZGE0NjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2ZvcmNlZGV0aC5jCisrKyBiL2RyaXZlcnMvbmV0L2ZvcmNlZGV0aC5jCkBAIC00OSw2ICs0OSw3IEBACiAjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9ldGh0b29sLmg+CiAjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2ZzX2VuZXQvZnNfZW5ldC1tYWluLmMgYi9kcml2ZXJzL25ldC9mc19lbmV0L2ZzX2VuZXQtbWFpbi5jCmluZGV4IDJiYzJkMmIuLmVjMmY1MDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2ZzX2VuZXQvZnNfZW5ldC1tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvZnNfZW5ldC9mc19lbmV0LW1haW4uYwpAQCAtMTExMCw2ICsxMTEwLDcgQEAKICNlbmRpZgogCXt9CiB9OworTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgZnNfZW5ldF9tYXRjaCk7CiAKIHN0YXRpYyBzdHJ1Y3Qgb2ZfcGxhdGZvcm1fZHJpdmVyIGZzX2VuZXRfZHJpdmVyID0gewogCS5uYW1lCT0gImZzX2VuZXQiLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZnNfZW5ldC9taWktYml0YmFuZy5jIGIvZHJpdmVycy9uZXQvZnNfZW5ldC9taWktYml0YmFuZy5jCmluZGV4IDkzYjQ4MWIuLjI0ZmY5ZjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2ZzX2VuZXQvbWlpLWJpdGJhbmcuYworKysgYi9kcml2ZXJzL25ldC9mc19lbmV0L21paS1iaXRiYW5nLmMKQEAgLTIyMSw2ICsyMjEsNyBAQAogCX0sCiAJe30sCiB9OworTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgZnNfZW5ldF9tZGlvX2JiX21hdGNoKTsKIAogc3RhdGljIHN0cnVjdCBvZl9wbGF0Zm9ybV9kcml2ZXIgZnNfZW5ldF9iYl9tZGlvX2RyaXZlciA9IHsKIAkubmFtZSA9ICJmc2wtYmItbWRpbyIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9mc19lbmV0L21paS1mZWMuYyBiL2RyaXZlcnMvbmV0L2ZzX2VuZXQvbWlpLWZlYy5jCmluZGV4IGEyZDY5YzEuLjk2ZWJhNDIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2ZzX2VuZXQvbWlpLWZlYy5jCisrKyBiL2RyaXZlcnMvbmV0L2ZzX2VuZXQvbWlpLWZlYy5jCkBAIC0yMTksNiArMjE5LDcgQEAKICNlbmRpZgogCXt9LAogfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIGZzX2VuZXRfbWRpb19mZWNfbWF0Y2gpOwogCiBzdGF0aWMgc3RydWN0IG9mX3BsYXRmb3JtX2RyaXZlciBmc19lbmV0X2ZlY19tZGlvX2RyaXZlciA9IHsKIAkubmFtZSA9ICJmc2wtZmVjLW1kaW8iLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvZnNsX3BxX21kaW8uYyBiL2RyaXZlcnMvbmV0L2ZzbF9wcV9tZGlvLmMKaW5kZXggZDE2NzA5MC4uNmFjNDY0OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvZnNsX3BxX21kaW8uYworKysgYi9kcml2ZXJzL25ldC9mc2xfcHFfbWRpby5jCkBAIC00MDcsNiArNDA3LDcgQEAKIAl9LAogCXt9LAogfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIGZzbF9wcV9tZGlvX21hdGNoKTsKIAogc3RhdGljIHN0cnVjdCBvZl9wbGF0Zm9ybV9kcml2ZXIgZnNsX3BxX21kaW9fZHJpdmVyID0gewogCS5uYW1lID0gImZzbC1wcV9tZGlvIiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2dpYW5mYXIuYyBiL2RyaXZlcnMvbmV0L2dpYW5mYXIuYwppbmRleCAxZTUyODlmLi41YmYzMWYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9naWFuZmFyLmMKKysrIGIvZHJpdmVycy9uZXQvZ2lhbmZhci5jCkBAIC0yMzI1LDkgKzIzMjUsNiBAQAogCXJldHVybiBJUlFfSEFORExFRDsKIH0KIAotLyogd29yayB3aXRoIGhvdHBsdWcgYW5kIGNvbGRwbHVnICovCi1NT0RVTEVfQUxJQVMoInBsYXRmb3JtOmZzbC1naWFuZmFyIik7Ci0KIHN0YXRpYyBzdHJ1Y3Qgb2ZfZGV2aWNlX2lkIGdmYXJfbWF0Y2hbXSA9CiB7CiAJewpAQCAtMjMzNiw2ICsyMzMzLDcgQEAKIAl9LAogCXt9LAogfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUob2YsIGdmYXJfbWF0Y2gpOwogCiAvKiBTdHJ1Y3R1cmUgZm9yIGEgZGV2aWNlIGRyaXZlciAqLwogc3RhdGljIHN0cnVjdCBvZl9wbGF0Zm9ybV9kcml2ZXIgZ2Zhcl9kcml2ZXIgPSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9oYW1hY2hpLmMgYi9kcml2ZXJzL25ldC9oYW1hY2hpLmMKaW5kZXggMWQ1MDY0YS4uZjc1MTlhNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaGFtYWNoaS5jCisrKyBiL2RyaXZlcnMvbmV0L2hhbWFjaGkuYwpAQCAtMTQ1LDYgKzE0NSw3IEBACiAvKiBUaW1lIGluIGppZmZpZXMgYmVmb3JlIGNvbmNsdWRpbmcgdGhlIHRyYW5zbWl0dGVyIGlzIGh1bmcuICovCiAjZGVmaW5lIFRYX1RJTUVPVVQgICg1KkhaKQogCisjaW5jbHVkZSA8bGludXgvY2FwYWJpbGl0eS5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaGFtcmFkaW8vYmF5Y29tX2VwcC5jIGIvZHJpdmVycy9uZXQvaGFtcmFkaW8vYmF5Y29tX2VwcC5jCmluZGV4IDdiY2FmN2MuLmUzNDRjODQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2hhbXJhZGlvL2JheWNvbV9lcHAuYworKysgYi9kcml2ZXJzL25ldC9oYW1yYWRpby9iYXljb21fZXBwLmMKQEAgLTQ0LDYgKzQ0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KICNpbmNsdWRlIDxsaW51eC9mcy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaGFtcmFkaW8vYmF5Y29tX3Nlcl9mZHguYyBiL2RyaXZlcnMvbmV0L2hhbXJhZGlvL2JheWNvbV9zZXJfZmR4LmMKaW5kZXggYWE0NDg4ZS4uZWQ2MGZkNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaGFtcmFkaW8vYmF5Y29tX3Nlcl9mZHguYworKysgYi9kcml2ZXJzL25ldC9oYW1yYWRpby9iYXljb21fc2VyX2ZkeC5jCkBAIC03MSw2ICs3MSw3IEBACiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAorI2luY2x1ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9pb3BvcnQuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2hhbXJhZGlvL2JheWNvbV9zZXJfaGR4LmMgYi9kcml2ZXJzL25ldC9oYW1yYWRpby9iYXljb21fc2VyX2hkeC5jCmluZGV4IDg4YzU5MzUuLjE2ODZmNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2hhbXJhZGlvL2JheWNvbV9zZXJfaGR4LmMKKysrIGIvZHJpdmVycy9uZXQvaGFtcmFkaW8vYmF5Y29tX3Nlcl9oZHguYwpAQCAtNjEsNiArNjEsNyBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKyNpbmNsdWRlIDxsaW51eC9jYXBhYmlsaXR5Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9oYW1yYWRpby9oZGxjZHJ2LmMgYi9kcml2ZXJzL25ldC9oYW1yYWRpby9oZGxjZHJ2LmMKaW5kZXggMDAxM2M0MC4uOTFjNTc5MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaGFtcmFkaW8vaGRsY2Rydi5jCisrKyBiL2RyaXZlcnMvbmV0L2hhbXJhZGlvL2hkbGNkcnYuYwpAQCAtNDIsNiArNDIsNyBAQAogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKKyNpbmNsdWRlIDxsaW51eC9jYXBhYmlsaXR5Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9uZXQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L2hwMTAwLmMgYi9kcml2ZXJzL25ldC9ocDEwMC5jCmluZGV4IGE5YTFhOTkuLmRkODY2NTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2hwMTAwLmMKKysrIGIvZHJpdmVycy9uZXQvaHAxMDAuYwpAQCAtOTgsNiArOTgsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaWJtX25ld2VtYWMvY29yZS5jIGIvZHJpdmVycy9uZXQvaWJtX25ld2VtYWMvY29yZS5jCmluZGV4IDg5YzgyYzUuLjNmYWU4NzUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2libV9uZXdlbWFjL2NvcmUuYworKysgYi9kcml2ZXJzL25ldC9pYm1fbmV3ZW1hYy9jb3JlLmMKQEAgLTI0LDYgKzI0LDcgQEAKICAqCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KQEAgLTQ0Myw3ICs0NDQsNyBAQAogCQlyZXQgfD0gRU1BQ19NUjFfVEZTXzJLOwogCQlicmVhazsKIAlkZWZhdWx0OgotCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogVW5rbm93biBSeCBGSUZPIHNpemUgJWRcbiIsCisJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBVbmtub3duIFR4IEZJRk8gc2l6ZSAlZFxuIiwKIAkJICAgICAgIGRldi0+bmRldi0+bmFtZSwgdHhfc2l6ZSk7CiAJfQogCkBAIC00NzAsNiArNDcxLDkgQEAKIAlEQkcyKGRldiwgIl9fZW1hYzRfY2FsY19iYXNlX21yMSIgTkwpOwogCiAJc3dpdGNoKHR4X3NpemUpIHsKKwljYXNlIDE2Mzg0OgorCQlyZXQgfD0gRU1BQzRfTVIxX1RGU18xNks7CisJCWJyZWFrOwogCWNhc2UgNDA5NjoKIAkJcmV0IHw9IEVNQUM0X01SMV9URlNfNEs7CiAJCWJyZWFrOwpAQCAtNDc3LDcgKzQ4MSw3IEBACiAJCXJldCB8PSBFTUFDNF9NUjFfVEZTXzJLOwogCQlicmVhazsKIAlkZWZhdWx0OgotCQlwcmludGsoS0VSTl9XQVJOSU5HICIlczogVW5rbm93biBSeCBGSUZPIHNpemUgJWRcbiIsCisJCXByaW50ayhLRVJOX1dBUk5JTkcgIiVzOiBVbmtub3duIFR4IEZJRk8gc2l6ZSAlZFxuIiwKIAkJICAgICAgIGRldi0+bmRldi0+bmFtZSwgdHhfc2l6ZSk7CiAJfQogCkBAIC0yOTg1LDYgKzI5ODksNyBAQAogCX0sCiAJe30sCiB9OworTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgZW1hY19tYXRjaCk7CiAKIHN0YXRpYyBzdHJ1Y3Qgb2ZfcGxhdGZvcm1fZHJpdmVyIGVtYWNfZHJpdmVyID0gewogCS5uYW1lID0gImVtYWMiLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaWJtX25ld2VtYWMvZW1hYy5oIGIvZHJpdmVycy9uZXQvaWJtX25ld2VtYWMvZW1hYy5oCmluZGV4IDBhZmMyY2YuLmQzNGFkZjkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2libV9uZXdlbWFjL2VtYWMuaAorKysgYi9kcml2ZXJzL25ldC9pYm1fbmV3ZW1hYy9lbWFjLmgKQEAgLTE1Myw2ICsxNTMsNyBAQAogI2RlZmluZSBFTUFDNF9NUjFfUkZTXzE2SwkJMHgwMDI4MDAwMAogI2RlZmluZSBFTUFDNF9NUjFfVEZTXzJLICAgICAgIAkJMHgwMDAyMDAwMAogI2RlZmluZSBFTUFDNF9NUjFfVEZTXzRLCQkweDAwMDMwMDAwCisjZGVmaW5lIEVNQUM0X01SMV9URlNfMTZLCQkweDAwMDUwMDAwCiAjZGVmaW5lIEVNQUM0X01SMV9UUgkJCTB4MDAwMDgwMDAKICNkZWZpbmUgRU1BQzRfTVIxX01XU1dfMDAxCQkweDAwMDAxMDAwCiAjZGVmaW5lIEVNQUM0X01SMV9KUFNNCQkJMHgwMDAwMDgwMApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaWdiL2lnYl9ldGh0b29sLmMgYi9kcml2ZXJzL25ldC9pZ2IvaWdiX2V0aHRvb2wuYwppbmRleCBkMDA0YzM1Li5kZWFlYThmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9pZ2IvaWdiX2V0aHRvb2wuYworKysgYi9kcml2ZXJzL25ldC9pZ2IvaWdiX2V0aHRvb2wuYwpAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L2lmX2V0aGVyLmg+CiAjaW5jbHVkZSA8bGludXgvZXRodG9vbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAKICNpbmNsdWRlICJpZ2IuaCIKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXJkYS9zYTExMDBfaXIuYyBiL2RyaXZlcnMvbmV0L2lyZGEvc2ExMTAwX2lyLmMKaW5kZXggMzhiZjdjZi4uYzQxMmU4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXJkYS9zYTExMDBfaXIuYworKysgYi9kcml2ZXJzL25ldC9pcmRhL3NhMTEwMF9pci5jCkBAIC0yMzIsOCArMjMyLDExIEBACiAJLyoKIAkgKiBFbnN1cmUgdGhhdCB0aGUgcG9ydHMgZm9yIHRoaXMgZGV2aWNlIGFyZSBzZXR1cCBjb3JyZWN0bHkuCiAJICovCi0JaWYgKHNpLT5wZGF0YS0+c3RhcnR1cCkKLQkJc2ktPnBkYXRhLT5zdGFydHVwKHNpLT5kZXYpOworCWlmIChzaS0+cGRhdGEtPnN0YXJ0dXApCXsKKwkJcmV0ID0gc2ktPnBkYXRhLT5zdGFydHVwKHNpLT5kZXYpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwl9CiAKIAkvKgogCSAqIENvbmZpZ3VyZSBQUEMgZm9yIElSREEgLSB3ZSB3YW50IHRvIGRyaXZlIFRYRDIgbG93LgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXJkYS90b2ltMzIzMi1zaXIuYyBiL2RyaXZlcnMvbmV0L2lyZGEvdG9pbTMyMzItc2lyLmMKaW5kZXggZmNmMjg3Yi4uOTllMWVjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXJkYS90b2ltMzIzMi1zaXIuYworKysgYi9kcml2ZXJzL25ldC9pcmRhL3RvaW0zMjMyLXNpci5jCkBAIC0xMjAsNiArMTIwLDcgQEAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogCiAjaW5jbHVkZSA8bmV0L2lyZGEvaXJkYS5oPgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9peHAyMDAwL2VucDI2MTEuYyBiL2RyaXZlcnMvbmV0L2l4cDIwMDAvZW5wMjYxMS5jCmluZGV4IGIwMmE5ODEuLjM0YTZjZmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2l4cDIwMDAvZW5wMjYxMS5jCisrKyBiL2RyaXZlcnMvbmV0L2l4cDIwMDAvZW5wMjYxMS5jCkBAIC0xMTksMjQgKzExOSw5IEBACiAJfQogfTsKIAotc3RydWN0IGVucDI2MTFfaXhwZGV2X3ByaXYKLXsKLQlzdHJ1Y3QgaXhwZGV2X3ByaXYJCWl4cGRldl9wcml2OwotCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzCQlzdGF0czsKLX07Ci0KIHN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZSAqbmRzWzNdOwogc3RhdGljIHN0cnVjdCB0aW1lcl9saXN0IGxpbmtfY2hlY2tfdGltZXI7CiAKLXN0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqZW5wMjYxMV9nZXRfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKLXsKLQlzdHJ1Y3QgZW5wMjYxMV9peHBkZXZfcHJpdiAqaXAgPSBuZXRkZXZfcHJpdihkZXYpOwotCi0JcG0zMzg2X2dldF9zdGF0cyhpcC0+aXhwZGV2X3ByaXYuY2hhbm5lbCwgJihpcC0+c3RhdHMpKTsKLQotCXJldHVybiAmKGlwLT5zdGF0cyk7Ci19Ci0KIC8qIEBAQCBQb2xsIHRoZSBTRlAgbW9kZGVmMCBsaW5lIHRvby4gICovCiAvKiBAQEAgVHJ5IHRvIHVzZSB0aGUgcG0zMzg2IERPT0wgaW50ZXJydXB0IGFzIHdlbGwuICAqLwogc3RhdGljIHZvaWQgZW5wMjYxMV9jaGVja19saW5rX3N0YXR1cyh1bnNpZ25lZCBsb25nIF9fZHVtbXkpCkBAIC0yMDMsMTQgKzE4OCwxMyBAQAogCiAJcG9ydHMgPSBwbTMzODZfcG9ydF9jb3VudCgpOwogCWZvciAoaSA9IDA7IGkgPCBwb3J0czsgaSsrKSB7Ci0JCW5kc1tpXSA9IGl4cGRldl9hbGxvYyhpLCBzaXplb2Yoc3RydWN0IGVucDI2MTFfaXhwZGV2X3ByaXYpKTsKKwkJbmRzW2ldID0gaXhwZGV2X2FsbG9jKGksIHNpemVvZihzdHJ1Y3QgaXhwZGV2X3ByaXYpKTsKIAkJaWYgKG5kc1tpXSA9PSBOVUxMKSB7CiAJCQl3aGlsZSAoLS1pID49IDApCiAJCQkJZnJlZV9uZXRkZXYobmRzW2ldKTsKIAkJCXJldHVybiAtRU5PTUVNOwogCQl9CiAKLQkJbmRzW2ldLT5nZXRfc3RhdHMgPSBlbnAyNjExX2dldF9zdGF0czsKIAkJcG0zMzg2X2luaXRfcG9ydChpKTsKIAkJcG0zMzg2X2dldF9tYWMoaSwgbmRzW2ldLT5kZXZfYWRkcik7CiAJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvaXhwMjAwMC9peHBkZXYuYyBiL2RyaXZlcnMvbmV0L2l4cDIwMDAvaXhwZGV2LmMKaW5kZXggMTI3MjQzNC4uOWFlZTBjYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvaXhwMjAwMC9peHBkZXYuYworKysgYi9kcml2ZXJzL25ldC9peHAyMDAwL2l4cGRldi5jCkBAIC0yMSw2ICsyMSw3IEBACiAjaW5jbHVkZSAiaXhwMjQwMF90eC51Y29kZSIKICNpbmNsdWRlICJpeHBkZXZfcHJpdi5oIgogI2luY2x1ZGUgIml4cGRldi5oIgorI2luY2x1ZGUgInBtMzM4Ni5oIgogCiAjZGVmaW5lIERSVl9NT0RVTEVfVkVSU0lPTgkiMC4yIgogCkBAIC0yNzEsNiArMjcyLDE1IEBACiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqaXhwZGV2X2dldF9zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCXN0cnVjdCBpeHBkZXZfcHJpdiAqaXAgPSBuZXRkZXZfcHJpdihkZXYpOworCisJcG0zMzg2X2dldF9zdGF0cyhpcC0+Y2hhbm5lbCwgJihkZXYtPnN0YXRzKSk7CisKKwlyZXR1cm4gJihkZXYtPnN0YXRzKTsKK30KKwogc3RhdGljIGNvbnN0IHN0cnVjdCBuZXRfZGV2aWNlX29wcyBpeHBkZXZfbmV0ZGV2X29wcyA9IHsKIAkubmRvX29wZW4JCT0gaXhwZGV2X29wZW4sCiAJLm5kb19zdG9wCQk9IGl4cGRldl9jbG9zZSwKQEAgLTI3OCw2ICsyODgsNyBAQAogCS5uZG9fY2hhbmdlX210dQkJPSBldGhfY2hhbmdlX210dSwKIAkubmRvX3ZhbGlkYXRlX2FkZHIJPSBldGhfdmFsaWRhdGVfYWRkciwKIAkubmRvX3NldF9tYWNfYWRkcmVzcwk9IGV0aF9tYWNfYWRkciwKKwkubmRvX2dldF9zdGF0cwkJPSBpeHBkZXZfZ2V0X3N0YXRzLAogI2lmZGVmIENPTkZJR19ORVRfUE9MTF9DT05UUk9MTEVSCiAJLm5kb19wb2xsX2NvbnRyb2xsZXIJPSBpeHBkZXZfcG9sbF9jb250cm9sbGVyLAogI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9rczg4NTEuYyBiL2RyaXZlcnMvbmV0L2tzODg1MS5jCmluZGV4IDIzNzgzNTguLmEyM2Y3MzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L2tzODg1MS5jCisrKyBiL2RyaXZlcnMvbmV0L2tzODg1MS5jCkBAIC0xNzEsNiArMTcxLDM2IEBACiB9CiAKIC8qKgorICoga3M4ODUxX3dycmVnOCAtIHdyaXRlIDhiaXQgcmVnaXN0ZXIgdmFsdWUgdG8gY2hpcAorICogQGtzOiBUaGUgY2hpcCBzdGF0ZQorICogQHJlZzogVGhlIHJlZ2lzdGVyIGFkZHJlc3MKKyAqIEB2YWw6IFRoZSB2YWx1ZSB0byB3cml0ZQorICoKKyAqIElzc3VlIGEgd3JpdGUgdG8gcHV0IHRoZSB2YWx1ZSBAdmFsIGludG8gdGhlIHJlZ2lzdGVyIHNwZWNpZmllZCBpbiBAcmVnLgorICovCitzdGF0aWMgdm9pZCBrczg4NTFfd3JyZWc4KHN0cnVjdCBrczg4NTFfbmV0ICprcywgdW5zaWduZWQgcmVnLCB1bnNpZ25lZCB2YWwpCit7CisJc3RydWN0IHNwaV90cmFuc2ZlciAqeGZlciA9ICZrcy0+c3BpX3hmZXIxOworCXN0cnVjdCBzcGlfbWVzc2FnZSAqbXNnID0gJmtzLT5zcGlfbXNnMTsKKwlfX2xlMTYgdHhiWzJdOworCWludCByZXQ7CisJaW50IGJpdDsKKworCWJpdCA9IDEgPDwgKHJlZyAmIDMpOworCisJdHhiWzBdID0gY3B1X3RvX2xlMTYoTUtfT1AoYml0LCByZWcpIHwgS1NfU1BJT1BfV1IpOworCXR4YlsxXSA9IHZhbDsKKworCXhmZXItPnR4X2J1ZiA9IHR4YjsKKwl4ZmVyLT5yeF9idWYgPSBOVUxMOworCXhmZXItPmxlbiA9IDM7CisKKwlyZXQgPSBzcGlfc3luYyhrcy0+c3BpZGV2LCBtc2cpOworCWlmIChyZXQgPCAwKQorCQlrc19lcnIoa3MsICJzcGlfc3luYygpIGZhaWxlZFxuIik7Cit9CisKKy8qKgogICoga3M4ODUxX3J4XzFtc2cgLSBzZWxlY3Qgd2hldGhlciB0byB1c2Ugb25lIG9yIHR3byBtZXNzYWdlcyBmb3Igc3BpIHJlYWQKICAqIEBrczogVGhlIGRldmljZSBzdHJ1Y3R1cmUKICAqCkBAIC0zMjIsMTMgKzM1MiwxMiBAQAogc3RhdGljIGludCBrczg4NTFfd3JpdGVfbWFjX2FkZHIoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3Qga3M4ODUxX25ldCAqa3MgPSBuZXRkZXZfcHJpdihkZXYpOwotCXUxNiAqbWNwID0gKHUxNiAqKWRldi0+ZGV2X2FkZHI7CisJaW50IGk7CiAKIAltdXRleF9sb2NrKCZrcy0+bG9jayk7CiAKLQlrczg4NTFfd3JyZWcxNihrcywgS1NfTUFSTCwgbWNwWzBdKTsKLQlrczg4NTFfd3JyZWcxNihrcywgS1NfTUFSTSwgbWNwWzFdKTsKLQlrczg4NTFfd3JyZWcxNihrcywgS1NfTUFSSCwgbWNwWzJdKTsKKwlmb3IgKGkgPSAwOyBpIDwgRVRIX0FMRU47IGkrKykKKwkJa3M4ODUxX3dycmVnOChrcywgS1NfTUFSKGkpLCBkZXYtPmRldl9hZGRyW2ldKTsKIAogCW11dGV4X3VubG9jaygma3MtPmxvY2spOwogCkBAIC05NTEsNyArOTgwLDcgQEAKIAkJCW1jcHRyID0gbWNwdHItPm5leHQ7CiAJCX0KIAotCQlyeGN0cmwucnhjcjEgPSBSWENSMV9SWE1FIHwgUlhDUjFfUlhBRSB8IFJYQ1IxX1JYUEFGTUE7CisJCXJ4Y3RybC5yeGNyMSA9IFJYQ1IxX1JYTUUgfCBSWENSMV9SWFBBRk1BOwogCX0gZWxzZSB7CiAJCS8qIGp1c3QgYWNjZXB0IGJyb2FkY2FzdCAvIHVuaWNhc3QgKi8KIAkJcnhjdHJsLnJ4Y3IxID0gUlhDUjFfUlhQQUZNQTsKQEAgLTEyMzksNiArMTI2OCw5IEBACiAJbmRldi0+bmV0ZGV2X29wcyA9ICZrczg4NTFfbmV0ZGV2X29wczsKIAluZGV2LT5pcnEgPSBzcGktPmlycTsKIAorCS8qIGlzc3VlIGEgZ2xvYmFsIHNvZnQgcmVzZXQgdG8gcmVzZXQgdGhlIGRldmljZS4gKi8KKwlrczg4NTFfc29mdF9yZXNldChrcywgR1JSX0dTUik7CisKIAkvKiBzaW1wbGUgY2hlY2sgZm9yIGEgdmFsaWQgY2hpcCBiZWluZyBjb25uZWN0ZWQgdG8gdGhlIGJ1cyAqLwogCiAJaWYgKChrczg4NTFfcmRyZWcxNihrcywgS1NfQ0lERVIpICYgfkNJREVSX1JFVl9NQVNLKSAhPSBDSURFUl9JRCkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQva3M4ODUxLmggYi9kcml2ZXJzL25ldC9rczg4NTEuaAppbmRleCA4NWFiZTE0Li5mNTJjMzEyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9rczg4NTEuaAorKysgYi9kcml2ZXJzL25ldC9rczg4NTEuaApAQCAtMTYsNiArMTYsNyBAQAogI2RlZmluZSBDQ1JfMzJQSU4JCQkJKDEgPDwgMCkKIAogLyogTUFDIGFkZHJlc3MgcmVnaXN0ZXJzICovCisjZGVmaW5lIEtTX01BUihfbSkJCQkJMHgxNSAtIChfbSkKICNkZWZpbmUgS1NfTUFSTAkJCQkJMHgxMAogI2RlZmluZSBLU19NQVJNCQkJCQkweDEyCiAjZGVmaW5lIEtTX01BUkgJCQkJCTB4MTQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L21seDQvbWFpbi5jIGIvZHJpdmVycy9uZXQvbWx4NC9tYWluLmMKaW5kZXggM2RkNDgxZS4uNWRkNzIyNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvbWx4NC9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvbWx4NC9tYWluLmMKQEAgLTEyODIsNiArMTI4Miw3IEBACiAJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHg2MzcyKSB9LCAvKiBNVDI1NDU4IENvbm5lY3RYIEVOIDEwR0JBU0UtVCAxMEdpZ0UgKi8KIAl7IFBDSV9WREVWSUNFKE1FTExBTk9YLCAweDY3NWEpIH0sIC8qIE1UMjU0NTggQ29ubmVjdFggRU4gMTBHQkFTRS1UK0dlbjIgMTBHaWdFICovCiAJeyBQQ0lfVkRFVklDRShNRUxMQU5PWCwgMHg2NzY0KSB9LCAvKiBNVDI2NDY4IENvbm5lY3RYIEVOIDEwR2lnRSBQQ0llIGdlbjIqLworCXsgUENJX1ZERVZJQ0UoTUVMTEFOT1gsIDB4Njc2ZSkgfSwgLyogTVQyNjQ3OCBDb25uZWN0WDIgNDBHaWdFIFBDSWUgZ2VuMiAqLwogCXsgMCwgfQogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvbmV0eGVuL25ldHhlbl9uaWNfbWFpbi5jIGIvZHJpdmVycy9uZXQvbmV0eGVuL25ldHhlbl9uaWNfbWFpbi5jCmluZGV4IDliOWVhYjEuLjdmYzE1ZTkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L25ldHhlbi9uZXR4ZW5fbmljX21haW4uYworKysgYi9kcml2ZXJzL25ldC9uZXR4ZW4vbmV0eGVuX25pY19tYWluLmMKQEAgLTU5NSw3ICs1OTUsOCBAQAogCXZvaWQgX19pb21lbSAqbWVtX3B0cjIgPSBOVUxMOwogCXZvaWQgX19pb21lbSAqZGJfcHRyID0gTlVMTDsKIAotCXVuc2lnbmVkIGxvbmcgbWVtX2Jhc2UsIG1lbV9sZW4sIGRiX2Jhc2UsIGRiX2xlbiA9IDAsIHBjaV9sZW4wID0gMDsKKwlyZXNvdXJjZV9zaXplX3QgbWVtX2Jhc2UsIGRiX2Jhc2U7CisJdW5zaWduZWQgbG9uZyBtZW1fbGVuLCBkYl9sZW4gPSAwLCBwY2lfbGVuMCA9IDA7CiAKIAlzdHJ1Y3QgcGNpX2RldiAqcGRldiA9IGFkYXB0ZXItPnBkZXY7CiAJaW50IHBjaV9mdW5jID0gYWRhcHRlci0+YWh3LnBjaV9mdW5jOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvbml1LmMgYi9kcml2ZXJzL25ldC9uaXUuYwppbmRleCBmOTM2NGQwLi5kNmM3YWM2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9uaXUuYworKysgYi9kcml2ZXJzL25ldC9uaXUuYwpAQCAtMzU0NSw3ICszNTQ1LDcgQEAKIAlycC0+cmNyX2luZGV4ID0gaW5kZXg7CiAKIAlza2JfcmVzZXJ2ZShza2IsIE5FVF9JUF9BTElHTik7Ci0JX19wc2tiX3B1bGxfdGFpbChza2IsIG1pbihsZW4sIE5JVV9SWFBVTExfTUFYKSk7CisJX19wc2tiX3B1bGxfdGFpbChza2IsIG1pbihsZW4sIFZMQU5fRVRIX0hMRU4pKTsKIAogCXJwLT5yeF9wYWNrZXRzKys7CiAJcnAtPnJ4X2J5dGVzICs9IHNrYi0+bGVuOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvbnM4MzgyMC5jIGIvZHJpdmVycy9uZXQvbnM4MzgyMC5jCmluZGV4IGM1OTRlMTkuLjU3ZmQ0ODMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L25zODM4MjAuYworKysgYi9kcml2ZXJzL25ldC9uczgzODIwLmMKQEAgLTExMSw2ICsxMTEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2NvbXBpbGVyLmg+CiAjaW5jbHVkZSA8bGludXgvcHJlZmV0Y2guaD4KICNpbmNsdWRlIDxsaW51eC9ldGh0b29sLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC90aW1lci5oPgogI2luY2x1ZGUgPGxpbnV4L2lmX3ZsYW4uaD4KICNpbmNsdWRlIDxsaW51eC9ydG5ldGxpbmsuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3BjbWNpYS8zYzU3NF9jcy5jIGIvZHJpdmVycy9uZXQvcGNtY2lhLzNjNTc0X2NzLmMKaW5kZXggZWU4YWQzZS4uYjU4OTY1YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcGNtY2lhLzNjNTc0X2NzLmMKKysrIGIvZHJpdmVycy9uZXQvcGNtY2lhLzNjNTc0X2NzLmMKQEAgLTI1MSw2ICsyNTEsNyBAQAogc3RhdGljIGludCBlbDNfaW9jdGwoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IGlmcmVxICpycSwgaW50IGNtZCk7CiBzdGF0aWMgY29uc3Qgc3RydWN0IGV0aHRvb2xfb3BzIG5ldGRldl9ldGh0b29sX29wczsKIHN0YXRpYyB2b2lkIHNldF9yeF9tb2RlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOworc3RhdGljIHZvaWQgc2V0X211bHRpY2FzdF9saXN0KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOwogCiBzdGF0aWMgdm9pZCB0YzU3NF9kZXRhY2goc3RydWN0IHBjbWNpYV9kZXZpY2UgKnBfZGV2KTsKIApAQCAtMjY2LDcgKzI2Nyw3IEBACiAJLm5kb190eF90aW1lb3V0IAk9IGVsM190eF90aW1lb3V0LAogCS5uZG9fZ2V0X3N0YXRzCQk9IGVsM19nZXRfc3RhdHMsCiAJLm5kb19kb19pb2N0bAkJPSBlbDNfaW9jdGwsCi0JLm5kb19zZXRfbXVsdGljYXN0X2xpc3QgPSBzZXRfcnhfbW9kZSwKKwkubmRvX3NldF9tdWx0aWNhc3RfbGlzdCA9IHNldF9tdWx0aWNhc3RfbGlzdCwKIAkubmRvX2NoYW5nZV9tdHUJCT0gZXRoX2NoYW5nZV9tdHUsCiAJLm5kb19zZXRfbWFjX2FkZHJlc3MgCT0gZXRoX21hY19hZGRyLAogCS5uZG9fdmFsaWRhdGVfYWRkcgk9IGV0aF92YWxpZGF0ZV9hZGRyLApAQCAtMTE2MSw2ICsxMTYyLDE2IEBACiAJCW91dHcoU2V0UnhGaWx0ZXIgfCBSeFN0YXRpb24gfCBSeEJyb2FkY2FzdCwgaW9hZGRyICsgRUwzX0NNRCk7CiB9CiAKK3N0YXRpYyB2b2lkIHNldF9tdWx0aWNhc3RfbGlzdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCXN0cnVjdCBlbDNfcHJpdmF0ZSAqbHAgPSBuZXRkZXZfcHJpdihkZXYpOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmbHAtPndpbmRvd19sb2NrLCBmbGFncyk7CisJc2V0X3J4X21vZGUoZGV2KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZscC0+d2luZG93X2xvY2ssIGZsYWdzKTsKK30KKwogc3RhdGljIGludCBlbDNfY2xvc2Uoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKIHsKIAl1bnNpZ25lZCBpbnQgaW9hZGRyID0gZGV2LT5iYXNlX2FkZHI7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9wY25ldDMyLmMgYi9kcml2ZXJzL25ldC9wY25ldDMyLmMKaW5kZXggNmQyOGIxOC4uYzFiM2YwOSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcGNuZXQzMi5jCisrKyBiL2RyaXZlcnMvbmV0L3BjbmV0MzIuYwpAQCAtMzEsNiArMzEsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcGh5L21kaW8tZ3Bpby5jIGIvZHJpdmVycy9uZXQvcGh5L21kaW8tZ3Bpby5jCmluZGV4IDI1MGUxMGYuLjg2NTlkMzQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3BoeS9tZGlvLWdwaW8uYworKysgYi9kcml2ZXJzL25ldC9waHkvbWRpby1ncGlvLmMKQEAgLTIzOCw2ICsyMzgsNyBAQAogCX0sCiAJe30sCiB9OworTU9EVUxFX0RFVklDRV9UQUJMRShvZiwgbWRpb19vZmdwaW9fbWF0Y2gpOwogCiBzdGF0aWMgc3RydWN0IG9mX3BsYXRmb3JtX2RyaXZlciBtZGlvX29mZ3Bpb19kcml2ZXIgPSB7CiAJLm5hbWUgPSAibWRpby1ncGlvIiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3FsZ2UvcWxnZS5oIGIvZHJpdmVycy9uZXQvcWxnZS9xbGdlLmgKaW5kZXggM2VjNmU4NS4uZTcyODVmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcWxnZS9xbGdlLmgKKysrIGIvZHJpdmVycy9uZXQvcWxnZS9xbGdlLmgKQEAgLTgwMyw2ICs4MDMsMTIgQEAKIAlNQl9DTURfU0VUX1BPUlRfQ0ZHID0gMHgwMDAwMDEyMiwKIAlNQl9DTURfR0VUX1BPUlRfQ0ZHID0gMHgwMDAwMDEyMywKIAlNQl9DTURfR0VUX0xJTktfU1RTID0gMHgwMDAwMDEyNCwKKwlNQl9DTURfU0VUX01HTU5UX1RGS19DVEwgPSAweDAwMDAwMTYwLCAvKiBTZXQgTWdtbnQgVHJhZmZpYyBDb250cm9sICovCisJTUJfU0VUX01QSV9URktfU1RPUCA9ICgxIDw8IDApLAorCU1CX1NFVF9NUElfVEZLX1JFU1VNRSA9ICgxIDw8IDEpLAorCU1CX0NNRF9HRVRfTUdNTlRfVEZLX0NUTCA9IDB4MDAwMDAxNjEsIC8qIEdldCBNZ21udCBUcmFmZmljIENvbnRyb2wgKi8KKwlNQl9HRVRfTVBJX1RGS19TVE9QUEVEID0gKDEgPDwgMCksCisJTUJfR0VUX01QSV9URktfRklGT19FTVBUWSA9ICgxIDw8IDEpLAogCiAJLyogTWFpbGJveCBDb21tYW5kIFN0YXR1cy4gKi8KIAlNQl9DTURfU1RTX0dPT0QgPSAweDAwMDA0MDAwLAkvKiBTdWNjZXNzLiAqLwpAQCAtMTE2OCw3ICsxMTc0LDcgQEAKICNkZWZpbmUgUlNTX1JJNiAweDQwCiAjZGVmaW5lIFJTU19SVDYgMHg4MAogCV9fbGUxNiBtYXNrOwotCV9fbGUzMiBoYXNoX2NxX2lkWzI1Nl07CisJdTggaGFzaF9jcV9pZFsxMDI0XTsKIAlfX2xlMzIgaXB2Nl9oYXNoX2tleVsxMF07CiAJX19sZTMyIGlwdjRfaGFzaF9rZXlbNF07CiB9IF9fYXR0cmlidXRlKChwYWNrZWQpKTsKQEAgLTE2MDYsNiArMTYxMiw4IEBACiBpbnQgcWxfbWJfYWJvdXRfZncoc3RydWN0IHFsX2FkYXB0ZXIgKnFkZXYpOwogdm9pZCBxbF9saW5rX29uKHN0cnVjdCBxbF9hZGFwdGVyICpxZGV2KTsKIHZvaWQgcWxfbGlua19vZmYoc3RydWN0IHFsX2FkYXB0ZXIgKnFkZXYpOworaW50IHFsX21iX3NldF9tZ21udF90cmFmZmljX2N0bChzdHJ1Y3QgcWxfYWRhcHRlciAqcWRldiwgdTMyIGNvbnRyb2wpOworaW50IHFsX3dhaXRfZmlmb19lbXB0eShzdHJ1Y3QgcWxfYWRhcHRlciAqcWRldik7CiAKICNpZiAxCiAjZGVmaW5lIFFMX0FMTF9EVU1QCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9xbGdlL3FsZ2VfbWFpbi5jIGIvZHJpdmVycy9uZXQvcWxnZS9xbGdlX21haW4uYwppbmRleCA2MTY4MDcxLi40OGI0NWRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9xbGdlL3FsZ2VfbWFpbi5jCisrKyBiL2RyaXZlcnMvbmV0L3FsZ2UvcWxnZV9tYWluLmMKQEAgLTMyMCw2ICszMjAsMzcgQEAKIAogCXN3aXRjaCAodHlwZSkgewogCWNhc2UgTUFDX0FERFJfVFlQRV9NVUxUSV9NQUM6CisJCXsKKwkJCXUzMiB1cHBlciA9IChhZGRyWzBdIDw8IDgpIHwgYWRkclsxXTsKKwkJCXUzMiBsb3dlciA9IChhZGRyWzJdIDw8IDI0KSB8IChhZGRyWzNdIDw8IDE2KSB8CisJCQkJCShhZGRyWzRdIDw8IDgpIHwgKGFkZHJbNV0pOworCisJCQlzdGF0dXMgPQorCQkJCXFsX3dhaXRfcmVnX3JkeShxZGV2LAorCQkJCU1BQ19BRERSX0lEWCwgTUFDX0FERFJfTVcsIDApOworCQkJaWYgKHN0YXR1cykKKwkJCQlnb3RvIGV4aXQ7CisJCQlxbF93cml0ZTMyKHFkZXYsIE1BQ19BRERSX0lEWCwgKG9mZnNldCsrKSB8CisJCQkJKGluZGV4IDw8IE1BQ19BRERSX0lEWF9TSElGVCkgfAorCQkJCXR5cGUgfCBNQUNfQUREUl9FKTsKKwkJCXFsX3dyaXRlMzIocWRldiwgTUFDX0FERFJfREFUQSwgbG93ZXIpOworCQkJc3RhdHVzID0KKwkJCQlxbF93YWl0X3JlZ19yZHkocWRldiwKKwkJCQlNQUNfQUREUl9JRFgsIE1BQ19BRERSX01XLCAwKTsKKwkJCWlmIChzdGF0dXMpCisJCQkJZ290byBleGl0OworCQkJcWxfd3JpdGUzMihxZGV2LCBNQUNfQUREUl9JRFgsIChvZmZzZXQrKykgfAorCQkJCShpbmRleCA8PCBNQUNfQUREUl9JRFhfU0hJRlQpIHwKKwkJCQl0eXBlIHwgTUFDX0FERFJfRSk7CisKKwkJCXFsX3dyaXRlMzIocWRldiwgTUFDX0FERFJfREFUQSwgdXBwZXIpOworCQkJc3RhdHVzID0KKwkJCQlxbF93YWl0X3JlZ19yZHkocWRldiwKKwkJCQlNQUNfQUREUl9JRFgsIE1BQ19BRERSX01XLCAwKTsKKwkJCWlmIChzdGF0dXMpCisJCQkJZ290byBleGl0OworCQkJYnJlYWs7CisJCX0KIAljYXNlIE1BQ19BRERSX1RZUEVfQ0FNX01BQzoKIAkJewogCQkJdTMyIGNhbV9vdXRwdXQ7CkBAIC0zNjUsMTYgKzM5NiwxNCBAQAogCQkJICAgYW5kIHBvc3NpYmx5IHRoZSBmdW5jdGlvbiBpZC4gIFJpZ2h0IG5vdyB3ZSBoYXJkY29kZQogCQkJICAgdGhlIHJvdXRlIGZpZWxkIHRvIE5JQyBjb3JlLgogCQkJICovCi0JCQlpZiAodHlwZSA9PSBNQUNfQUREUl9UWVBFX0NBTV9NQUMpIHsKLQkJCQljYW1fb3V0cHV0ID0gKENBTV9PVVRfUk9VVEVfTklDIHwKLQkJCQkJICAgICAgKHFkZXYtPgotCQkJCQkgICAgICAgZnVuYyA8PCBDQU1fT1VUX0ZVTkNfU0hJRlQpIHwKLQkJCQkJCSgwIDw8IENBTV9PVVRfQ1FfSURfU0hJRlQpKTsKLQkJCQlpZiAocWRldi0+dmxncnApCi0JCQkJCWNhbV9vdXRwdXQgfD0gQ0FNX09VVF9SVjsKLQkJCQkvKiByb3V0ZSB0byBOSUMgY29yZSAqLwotCQkJCXFsX3dyaXRlMzIocWRldiwgTUFDX0FERFJfREFUQSwgY2FtX291dHB1dCk7Ci0JCQl9CisJCQljYW1fb3V0cHV0ID0gKENBTV9PVVRfUk9VVEVfTklDIHwKKwkJCQkgICAgICAocWRldi0+CisJCQkJICAgICAgIGZ1bmMgPDwgQ0FNX09VVF9GVU5DX1NISUZUKSB8CisJCQkJCSgwIDw8IENBTV9PVVRfQ1FfSURfU0hJRlQpKTsKKwkJCWlmIChxZGV2LT52bGdycCkKKwkJCQljYW1fb3V0cHV0IHw9IENBTV9PVVRfUlY7CisJCQkvKiByb3V0ZSB0byBOSUMgY29yZSAqLworCQkJcWxfd3JpdGUzMihxZGV2LCBNQUNfQUREUl9EQVRBLCBjYW1fb3V0cHV0KTsKIAkJCWJyZWFrOwogCQl9CiAJY2FzZSBNQUNfQUREUl9UWVBFX1ZMQU46CkBAIC01NDYsMTQgKzU3NSwxNCBAQAogCQl9CiAJY2FzZSBSVF9JRFhfTUNBU1Q6CS8qIFBhc3MgdXAgQWxsIE11bHRpY2FzdCBmcmFtZXMuICovCiAJCXsKLQkJCXZhbHVlID0gUlRfSURYX0RTVF9DQU1fUSB8CS8qIGRlc3QgKi8KKwkJCXZhbHVlID0gUlRfSURYX0RTVF9ERkxUX1EgfAkvKiBkZXN0ICovCiAJCQkgICAgUlRfSURYX1RZUEVfTklDUSB8CS8qIHR5cGUgKi8KIAkJCSAgICAoUlRfSURYX0FMTE1VTFRJX1NMT1QgPDwgUlRfSURYX0lEWF9TSElGVCk7LyogaW5kZXggKi8KIAkJCWJyZWFrOwogCQl9CiAJY2FzZSBSVF9JRFhfTUNBU1RfTUFUQ0g6CS8qIFBhc3MgdXAgbWF0Y2hlZCBNdWx0aWNhc3QgZnJhbWVzLiAqLwogCQl7Ci0JCQl2YWx1ZSA9IFJUX0lEWF9EU1RfQ0FNX1EgfAkvKiBkZXN0ICovCisJCQl2YWx1ZSA9IFJUX0lEWF9EU1RfREZMVF9RIHwJLyogZGVzdCAqLwogCQkJICAgIFJUX0lEWF9UWVBFX05JQ1EgfAkvKiB0eXBlICovCiAJCQkgICAgKFJUX0lEWF9NQ0FTVF9NQVRDSF9TTE9UIDw8IFJUX0lEWF9JRFhfU0hJRlQpOy8qIGluZGV4ICovCiAJCQlicmVhazsKQEAgLTMwNzcsNiArMzEwNiwxMiBAQAogCiBzdGF0aWMgaW50IHFsX3N0YXJ0X3JzcyhzdHJ1Y3QgcWxfYWRhcHRlciAqcWRldikKIHsKKwl1OCBpbml0X2hhc2hfc2VlZFtdID0gezB4NmQsIDB4NWEsIDB4NTYsIDB4ZGEsIDB4MjUsIDB4NWIsIDB4MGUsIDB4YzIsCisJCQkJMHg0MSwgMHg2NywgMHgyNSwgMHgzZCwgMHg0MywgMHhhMywgMHg4ZiwKKwkJCQkweGIwLCAweGQwLCAweGNhLCAweDJiLCAweGNiLCAweGFlLCAweDdiLAorCQkJCTB4MzAsIDB4YjQsIDB4NzcsIDB4Y2IsIDB4MmQsIDB4YTMsIDB4ODAsCisJCQkJMHgzMCwgMHhmMiwgMHgwYywgMHg2YSwgMHg0MiwgMHhiNywgMHgzYiwKKwkJCQkweGJlLCAweGFjLCAweDAxLCAweGZhfTsKIAlzdHJ1Y3QgcmljYiAqcmljYiA9ICZxZGV2LT5yaWNiOwogCWludCBzdGF0dXMgPSAwOwogCWludCBpOwpAQCAtMzA4NiwyMSArMzEyMSwxNyBAQAogCiAJcmljYi0+YmFzZV9jcSA9IFJTU19MNEs7CiAJcmljYi0+ZmxhZ3MgPQotCSAgICAoUlNTX0w2SyB8IFJTU19MSSB8IFJTU19MQiB8IFJTU19MTSB8IFJTU19SSTQgfCBSU1NfUkk2IHwgUlNTX1JUNCB8Ci0JICAgICBSU1NfUlQ2KTsKLQlyaWNiLT5tYXNrID0gY3B1X3RvX2xlMTYocWRldi0+cnNzX3JpbmdfY291bnQgLSAxKTsKKwkJKFJTU19MNksgfCBSU1NfTEkgfCBSU1NfTEIgfCBSU1NfTE0gfCBSU1NfUlQ0IHwgUlNTX1JUNik7CisJcmljYi0+bWFzayA9IGNwdV90b19sZTE2KCh1MTYpKDB4M2ZmKSk7CiAKIAkvKgogCSAqIEZpbGwgb3V0IHRoZSBJbmRpcmVjdGlvbiBUYWJsZS4KIAkgKi8KLQlmb3IgKGkgPSAwOyBpIDwgMjU2OyBpKyspCi0JCWhhc2hfaWRbaV0gPSBpICYgKHFkZXYtPnJzc19yaW5nX2NvdW50IC0gMSk7CisJZm9yIChpID0gMDsgaSA8IDEwMjQ7IGkrKykKKwkJaGFzaF9pZFtpXSA9IChpICYgKHFkZXYtPnJzc19yaW5nX2NvdW50IC0gMSkpOwogCi0JLyoKLQkgKiBSYW5kb20gdmFsdWVzIGZvciB0aGUgSVB2NiBhbmQgSVB2NCBIYXNoIEtleXMuCi0JICovCi0JZ2V0X3JhbmRvbV9ieXRlcygodm9pZCAqKSZyaWNiLT5pcHY2X2hhc2hfa2V5WzBdLCA0MCk7Ci0JZ2V0X3JhbmRvbV9ieXRlcygodm9pZCAqKSZyaWNiLT5pcHY0X2hhc2hfa2V5WzBdLCAxNik7CisJbWVtY3B5KCh2b2lkICopJnJpY2ItPmlwdjZfaGFzaF9rZXlbMF0sIGluaXRfaGFzaF9zZWVkLCA0MCk7CisJbWVtY3B5KCh2b2lkICopJnJpY2ItPmlwdjRfaGFzaF9rZXlbMF0sIGluaXRfaGFzaF9zZWVkLCAxNik7CiAKIAlRUFJJTlRLKHFkZXYsIElGVVAsIERFQlVHLCAiSW5pdGlhbGl6aW5nIFJTUy5cbiIpOwogCkBAIC0zMjM5LDYgKzMyNzAsMTMgQEAKIAlxbF93cml0ZTMyKHFkZXYsIFNQTFRfSERSLCBTUExUX0hEUl9FUCB8CiAJCW1pbihTTUFMTF9CVUZGRVJfU0laRSwgTUFYX1NQTElUX1NJWkUpKTsKIAorCS8qIFNldCBSWCBwYWNrZXQgcm91dGluZyB0byB1c2UgcG9ydC9wY2kgZnVuY3Rpb24gb24gd2hpY2ggdGhlCisJICogcGFja2V0IGFycml2ZWQgb24gaW4gYWRkaXRpb24gdG8gdXN1YWwgZnJhbWUgcm91dGluZy4KKwkgKiBUaGlzIGlzIGhlbHBmdWwgb24gYm9uZGluZyB3aGVyZSBib3RoIGludGVyZmFjZXMgY2FuIGhhdmUKKwkgKiB0aGUgc2FtZSBNQUMgYWRkcmVzcy4KKwkgKi8KKwlxbF93cml0ZTMyKHFkZXYsIFJTVF9GTywgUlNUX0ZPX1JSX01BU0sgfCBSU1RfRk9fUlJfUkNWX0ZVTkNfQ1EpOworCiAJLyogU3RhcnQgdXAgdGhlIHJ4IHF1ZXVlcy4gKi8KIAlmb3IgKGkgPSAwOyBpIDwgcWRldi0+cnhfcmluZ19jb3VudDsgaSsrKSB7CiAJCXN0YXR1cyA9IHFsX3N0YXJ0X3J4X3JpbmcocWRldiwgJnFkZXYtPnJ4X3JpbmdbaV0pOwpAQCAtMzMxMSw2ICszMzQ5LDEzIEBACiAKIAllbmRfamlmZmllcyA9IGppZmZpZXMgKwogCQltYXgoKHVuc2lnbmVkIGxvbmcpMSwgdXNlY3NfdG9famlmZmllcygzMCkpOworCisJLyogU3RvcCBtYW5hZ2VtZW50IHRyYWZmaWMuICovCisJcWxfbWJfc2V0X21nbW50X3RyYWZmaWNfY3RsKHFkZXYsIE1CX1NFVF9NUElfVEZLX1NUT1ApOworCisJLyogV2FpdCBmb3IgdGhlIE5JQyBhbmQgTUdNTlQgRklGT3MgdG8gZW1wdHkuICovCisJcWxfd2FpdF9maWZvX2VtcHR5KHFkZXYpOworCiAJcWxfd3JpdGUzMihxZGV2LCBSU1RfRk8sIChSU1RfRk9fRlIgPDwgMTYpIHwgUlNUX0ZPX0ZSKTsKIAogCWRvIHsKQEAgLTMzMjYsNiArMzM3MSw4IEBACiAJCXN0YXR1cyA9IC1FVElNRURPVVQ7CiAJfQogCisJLyogUmVzdW1lIG1hbmFnZW1lbnQgdHJhZmZpYy4gKi8KKwlxbF9tYl9zZXRfbWdtbnRfdHJhZmZpY19jdGwocWRldiwgTUJfU0VUX01QSV9URktfUkVTVU1FKTsKIAlyZXR1cm4gc3RhdHVzOwogfQogCkBAIC0zNzA0LDYgKzM3NTEsMTIgQEAKIAlzdGF0dXMgPSBxbF9hZGFwdGVyX3VwKHFkZXYpOwogCWlmIChzdGF0dXMpCiAJCWdvdG8gZXJyb3I7CisKKwkvKiBSZXN0b3JlIHJ4IG1vZGUuICovCisJY2xlYXJfYml0KFFMX0FMTE1VTFRJLCAmcWRldi0+ZmxhZ3MpOworCWNsZWFyX2JpdChRTF9QUk9NSVNDVU9VUywgJnFkZXYtPmZsYWdzKTsKKwlxbGdlX3NldF9tdWx0aWNhc3RfbGlzdChxZGV2LT5uZGV2KTsKKwogCXJ0bmxfdW5sb2NrKCk7CiAJcmV0dXJuOwogZXJyb3I6CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9xbGdlL3FsZ2VfbXBpLmMgYi9kcml2ZXJzL25ldC9xbGdlL3FsZ2VfbXBpLmMKaW5kZXggYzJlNDMwNy4uOTllNThlMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvcWxnZS9xbGdlX21waS5jCisrKyBiL2RyaXZlcnMvbmV0L3FsZ2UvcWxnZV9tcGkuYwpAQCAtNzY4LDYgKzc2OCw5NSBAQAogCXJldHVybiBzdGF0dXM7CiB9CiAKK2ludCBxbF9tYl9zZXRfbWdtbnRfdHJhZmZpY19jdGwoc3RydWN0IHFsX2FkYXB0ZXIgKnFkZXYsIHUzMiBjb250cm9sKQoreworCXN0cnVjdCBtYm94X3BhcmFtcyBtYmM7CisJc3RydWN0IG1ib3hfcGFyYW1zICptYmNwID0gJm1iYzsKKwlpbnQgc3RhdHVzOworCisJbWVtc2V0KG1iY3AsIDAsIHNpemVvZihzdHJ1Y3QgbWJveF9wYXJhbXMpKTsKKworCW1iY3AtPmluX2NvdW50ID0gMTsKKwltYmNwLT5vdXRfY291bnQgPSAyOworCisJbWJjcC0+bWJveF9pblswXSA9IE1CX0NNRF9TRVRfTUdNTlRfVEZLX0NUTDsKKwltYmNwLT5tYm94X2luWzFdID0gY29udHJvbDsKKworCXN0YXR1cyA9IHFsX21haWxib3hfY29tbWFuZChxZGV2LCBtYmNwKTsKKwlpZiAoc3RhdHVzKQorCQlyZXR1cm4gc3RhdHVzOworCisJaWYgKG1iY3AtPm1ib3hfb3V0WzBdID09IE1CX0NNRF9TVFNfR09PRCkKKwkJcmV0dXJuIHN0YXR1czsKKworCWlmIChtYmNwLT5tYm94X291dFswXSA9PSBNQl9DTURfU1RTX0lOVkxEX0NNRCkgeworCQlRUFJJTlRLKHFkZXYsIERSViwgRVJSLAorCQkJIkNvbW1hbmQgbm90IHN1cHBvcnRlZCBieSBmaXJtd2FyZS5cbiIpOworCQlzdGF0dXMgPSAtRUlOVkFMOworCX0gZWxzZSBpZiAobWJjcC0+bWJveF9vdXRbMF0gPT0gTUJfQ01EX1NUU19FUlIpIHsKKwkJLyogVGhpcyBpbmRpY2F0ZXMgdGhhdCB0aGUgZmlybXdhcmUgaXMKKwkJICogYWxyZWFkeSBpbiB0aGUgc3RhdGUgd2UgYXJlIHRyeWluZyB0bworCQkgKiBjaGFuZ2UgaXQgdG8uCisJCSAqLworCQlRUFJJTlRLKHFkZXYsIERSViwgRVJSLAorCQkJIkNvbW1hbmQgcGFyYW1ldGVycyBtYWtlIG5vIGNoYW5nZS5cbiIpOworCX0KKwlyZXR1cm4gc3RhdHVzOworfQorCisvKiBSZXR1cm5zIGEgbmVnYXRpdmUgZXJyb3IgY29kZSBvciB0aGUgbWFpbGJveCBjb21tYW5kIHN0YXR1cy4gKi8KK3N0YXRpYyBpbnQgcWxfbWJfZ2V0X21nbW50X3RyYWZmaWNfY3RsKHN0cnVjdCBxbF9hZGFwdGVyICpxZGV2LCB1MzIgKmNvbnRyb2wpCit7CisJc3RydWN0IG1ib3hfcGFyYW1zIG1iYzsKKwlzdHJ1Y3QgbWJveF9wYXJhbXMgKm1iY3AgPSAmbWJjOworCWludCBzdGF0dXM7CisKKwltZW1zZXQobWJjcCwgMCwgc2l6ZW9mKHN0cnVjdCBtYm94X3BhcmFtcykpOworCSpjb250cm9sID0gMDsKKworCW1iY3AtPmluX2NvdW50ID0gMTsKKwltYmNwLT5vdXRfY291bnQgPSAxOworCisJbWJjcC0+bWJveF9pblswXSA9IE1CX0NNRF9HRVRfTUdNTlRfVEZLX0NUTDsKKworCXN0YXR1cyA9IHFsX21haWxib3hfY29tbWFuZChxZGV2LCBtYmNwKTsKKwlpZiAoc3RhdHVzKQorCQlyZXR1cm4gc3RhdHVzOworCisJaWYgKG1iY3AtPm1ib3hfb3V0WzBdID09IE1CX0NNRF9TVFNfR09PRCkgeworCQkqY29udHJvbCA9IG1iY3AtPm1ib3hfaW5bMV07CisJCXJldHVybiBzdGF0dXM7CisJfQorCisJaWYgKG1iY3AtPm1ib3hfb3V0WzBdID09IE1CX0NNRF9TVFNfSU5WTERfQ01EKSB7CisJCVFQUklOVEsocWRldiwgRFJWLCBFUlIsCisJCQkiQ29tbWFuZCBub3Qgc3VwcG9ydGVkIGJ5IGZpcm13YXJlLlxuIik7CisJCXN0YXR1cyA9IC1FSU5WQUw7CisJfSBlbHNlIGlmIChtYmNwLT5tYm94X291dFswXSA9PSBNQl9DTURfU1RTX0VSUikgeworCQlRUFJJTlRLKHFkZXYsIERSViwgRVJSLAorCQkJIkZhaWxlZCB0byBnZXQgTVBJIHRyYWZmaWMgY29udHJvbC5cbiIpOworCQlzdGF0dXMgPSAtRUlPOworCX0KKwlyZXR1cm4gc3RhdHVzOworfQorCitpbnQgcWxfd2FpdF9maWZvX2VtcHR5KHN0cnVjdCBxbF9hZGFwdGVyICpxZGV2KQoreworCWludCBjb3VudCA9IDU7CisJdTMyIG1nbW50X2ZpZm9fZW1wdHk7CisJdTMyIG5pY19maWZvX2VtcHR5OworCisJZG8geworCQluaWNfZmlmb19lbXB0eSA9IHFsX3JlYWQzMihxZGV2LCBTVFMpICYgU1RTX05GRTsKKwkJcWxfbWJfZ2V0X21nbW50X3RyYWZmaWNfY3RsKHFkZXYsICZtZ21udF9maWZvX2VtcHR5KTsKKwkJbWdtbnRfZmlmb19lbXB0eSAmPSBNQl9HRVRfTVBJX1RGS19GSUZPX0VNUFRZOworCQlpZiAobmljX2ZpZm9fZW1wdHkgJiYgbWdtbnRfZmlmb19lbXB0eSkKKwkJCXJldHVybiAwOworCQltc2xlZXAoMTAwKTsKKwl9IHdoaWxlIChjb3VudC0tID4gMCk7CisJcmV0dXJuIC1FVElNRURPVVQ7Cit9CisKIC8qIEFQSSBjYWxsZWQgaW4gd29yayB0aHJlYWQgY29udGV4dCB0byBzZXQgbmV3IFRYL1JYCiAgKiBtYXhpbXVtIGZyYW1lIHNpemUgdmFsdWVzIHRvIG1hdGNoIE1UVS4KICAqLwpAQCAtODc2LDYgKzk2NSw4IEBACiAJaW50IGVyciA9IDA7CiAKIAlydG5sX2xvY2soKTsKKwkvKiBCZWdpbiBwb2xsZWQgbW9kZSBmb3IgTVBJICovCisJcWxfd3JpdGUzMihxZGV2LCBJTlRSX01BU0ssIChJTlRSX01BU0tfUEkgPDwgMTYpKTsKIAogCXdoaWxlIChxbF9yZWFkMzIocWRldiwgU1RTKSAmIFNUU19QSSkgewogCQltZW1zZXQobWJjcCwgMCwgc2l6ZW9mKHN0cnVjdCBtYm94X3BhcmFtcykpOwpAQCAtODg4LDYgKzk3OSw4IEBACiAJCQlicmVhazsKIAl9CiAKKwkvKiBFbmQgcG9sbGVkIG1vZGUgZm9yIE1QSSAqLworCXFsX3dyaXRlMzIocWRldiwgSU5UUl9NQVNLLCAoSU5UUl9NQVNLX1BJIDw8IDE2KSB8IElOVFJfTUFTS19QSSk7CiAJcnRubF91bmxvY2soKTsKIAlxbF9lbmFibGVfY29tcGxldGlvbl9pbnRlcnJ1cHQocWRldiwgMCk7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9yODE2OS5jIGIvZHJpdmVycy9uZXQvcjgxNjkuYwppbmRleCA1MGM2YTNjLi44M2M0N2Q5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9yODE2OS5jCisrKyBiL2RyaXZlcnMvbmV0L3I4MTY5LmMKQEAgLTExNSw3ICsxMTUsOSBAQAogCVJUTF9HSUdBX01BQ19WRVJfMjIgPSAweDE2LCAvLyA4MTY4QwogCVJUTF9HSUdBX01BQ19WRVJfMjMgPSAweDE3LCAvLyA4MTY4Q1AKIAlSVExfR0lHQV9NQUNfVkVSXzI0ID0gMHgxOCwgLy8gODE2OENQCi0JUlRMX0dJR0FfTUFDX1ZFUl8yNSA9IDB4MTkgIC8vIDgxNjhECisJUlRMX0dJR0FfTUFDX1ZFUl8yNSA9IDB4MTksIC8vIDgxNjhECisJUlRMX0dJR0FfTUFDX1ZFUl8yNiA9IDB4MWEsIC8vIDgxNjhECisJUlRMX0dJR0FfTUFDX1ZFUl8yNyA9IDB4MWIgIC8vIDgxNjhEUAogfTsKIAogI2RlZmluZSBfUihOQU1FLE1BQyxNQVNLKSBcCkBAIC0xNTAsNyArMTUyLDkgQEAKIAlfUigiUlRMODE2OGMvODExMWMiLAlSVExfR0lHQV9NQUNfVkVSXzIyLCAweGZmN2UxODgwKSwgLy8gUENJLUUKIAlfUigiUlRMODE2OGNwLzgxMTFjcCIsCVJUTF9HSUdBX01BQ19WRVJfMjMsIDB4ZmY3ZTE4ODApLCAvLyBQQ0ktRQogCV9SKCJSVEw4MTY4Y3AvODExMWNwIiwJUlRMX0dJR0FfTUFDX1ZFUl8yNCwgMHhmZjdlMTg4MCksIC8vIFBDSS1FCi0JX1IoIlJUTDgxNjhkLzgxMTFkIiwJUlRMX0dJR0FfTUFDX1ZFUl8yNSwgMHhmZjdlMTg4MCkgIC8vIFBDSS1FCisJX1IoIlJUTDgxNjhkLzgxMTFkIiwJUlRMX0dJR0FfTUFDX1ZFUl8yNSwgMHhmZjdlMTg4MCksIC8vIFBDSS1FCisJX1IoIlJUTDgxNjhkLzgxMTFkIiwJUlRMX0dJR0FfTUFDX1ZFUl8yNiwgMHhmZjdlMTg4MCksIC8vIFBDSS1FCisJX1IoIlJUTDgxNjhkcC84MTExZHAiLAlSVExfR0lHQV9NQUNfVkVSXzI3LCAweGZmN2UxODgwKSAgLy8gUENJLUUKIH07CiAjdW5kZWYgX1IKIApAQCAtMjUzLDYgKzI1NywxMyBAQAogCURCR19SRUcJCQk9IDB4ZDEsCiAjZGVmaW5lCUZJWF9OQUtfMQkJCSgxIDw8IDQpCiAjZGVmaW5lCUZJWF9OQUtfMgkJCSgxIDw8IDMpCisJRUZVU0VBUgkJCT0gMHhkYywKKyNkZWZpbmUJRUZVU0VBUl9GTEFHCQkJMHg4MDAwMDAwMAorI2RlZmluZQlFRlVTRUFSX1dSSVRFX0NNRAkJMHg4MDAwMDAwMAorI2RlZmluZQlFRlVTRUFSX1JFQURfQ01ECQkweDAwMDAwMDAwCisjZGVmaW5lCUVGVVNFQVJfUkVHX01BU0sJCTB4MDNmZgorI2RlZmluZQlFRlVTRUFSX1JFR19TSElGVAkJOAorI2RlZmluZQlFRlVTRUFSX0RBVEFfTUFTSwkJMHhmZgogfTsKIAogZW51bSBydGxfcmVnaXN0ZXJfY29udGVudCB7CkBAIC01NjgsNiArNTc5LDE0IEBACiAJbWRpb193cml0ZShpb2FkZHIsIHJlZ19hZGRyLCBtZGlvX3JlYWQoaW9hZGRyLCByZWdfYWRkcikgfCB2YWx1ZSk7CiB9CiAKK3N0YXRpYyB2b2lkIG1kaW9fcGx1c19taW51cyh2b2lkIF9faW9tZW0gKmlvYWRkciwgaW50IHJlZ19hZGRyLCBpbnQgcCwgaW50IG0pCit7CisJaW50IHZhbDsKKworCXZhbCA9IG1kaW9fcmVhZChpb2FkZHIsIHJlZ19hZGRyKTsKKwltZGlvX3dyaXRlKGlvYWRkciwgcmVnX2FkZHIsICh2YWwgfCBwKSAmIH5tKTsKK30KKwogc3RhdGljIHZvaWQgcnRsX21kaW9fd3JpdGUoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IHBoeV9pZCwgaW50IGxvY2F0aW9uLAogCQkJICAgaW50IHZhbCkKIHsKQEAgLTY1MSw2ICs2NzAsMjQgQEAKIAlyZXR1cm4gdmFsdWU7CiB9CiAKK3N0YXRpYyB1OCBydGw4MTY4ZF9lZnVzZV9yZWFkKHZvaWQgX19pb21lbSAqaW9hZGRyLCBpbnQgcmVnX2FkZHIpCit7CisJdTggdmFsdWUgPSAweGZmOworCXVuc2lnbmVkIGludCBpOworCisJUlRMX1czMihFRlVTRUFSLCAocmVnX2FkZHIgJiBFRlVTRUFSX1JFR19NQVNLKSA8PCBFRlVTRUFSX1JFR19TSElGVCk7CisKKwlmb3IgKGkgPSAwOyBpIDwgMzAwOyBpKyspIHsKKwkJaWYgKFJUTF9SMzIoRUZVU0VBUikgJiBFRlVTRUFSX0ZMQUcpIHsKKwkJCXZhbHVlID0gUlRMX1IzMihFRlVTRUFSKSAmIEVGVVNFQVJfREFUQV9NQVNLOworCQkJYnJlYWs7CisJCX0KKwkJdWRlbGF5KDEwMCk7CisJfQorCisJcmV0dXJuIHZhbHVlOworfQorCiBzdGF0aWMgdm9pZCBydGw4MTY5X2lycV9tYXNrX2FuZF9hY2sodm9pZCBfX2lvbWVtICppb2FkZHIpCiB7CiAJUlRMX1cxNihJbnRyTWFzaywgMHgwMDAwKTsKQEAgLTEyNDMsNyArMTI4MCwxMCBAQAogCQlpbnQgbWFjX3ZlcnNpb247CiAJfSBtYWNfaW5mb1tdID0gewogCQkvKiA4MTY4RCBmYW1pbHkuICovCi0JCXsgMHg3YzgwMDAwMCwgMHgyODAwMDAwMCwJUlRMX0dJR0FfTUFDX1ZFUl8yNSB9LAorCQl7IDB4N2NmMDAwMDAsIDB4MjgzMDAwMDAsCVJUTF9HSUdBX01BQ19WRVJfMjYgfSwKKwkJeyAweDdjZjAwMDAwLCAweDI4MTAwMDAwLAlSVExfR0lHQV9NQUNfVkVSXzI1IH0sCisJCXsgMHg3YzgwMDAwMCwgMHgyODgwMDAwMCwJUlRMX0dJR0FfTUFDX1ZFUl8yNyB9LAorCQl7IDB4N2M4MDAwMDAsIDB4MjgwMDAwMDAsCVJUTF9HSUdBX01BQ19WRVJfMjYgfSwKIAogCQkvKiA4MTY4QyBmYW1pbHkuICovCiAJCXsgMHg3Y2YwMDAwMCwgMHgzY2EwMDAwMCwJUlRMX0dJR0FfTUFDX1ZFUl8yNCB9LApAQCAtMTY0OCw3NCArMTY4OCw5MDMgQEAKIAlydGw4MTY4Y18zX2h3X3BoeV9jb25maWcoaW9hZGRyKTsKIH0KIAotc3RhdGljIHZvaWQgcnRsODE2OGRfaHdfcGh5X2NvbmZpZyh2b2lkIF9faW9tZW0gKmlvYWRkcikKK3N0YXRpYyB2b2lkIHJ0bDgxNjhkXzFfaHdfcGh5X2NvbmZpZyh2b2lkIF9faW9tZW0gKmlvYWRkcikKIHsKLQlzdHJ1Y3QgcGh5X3JlZyBwaHlfcmVnX2luaXRfMFtdID0geworCXN0YXRpYyBzdHJ1Y3QgcGh5X3JlZyBwaHlfcmVnX2luaXRfMFtdID0gewogCQl7IDB4MWYsIDB4MDAwMSB9LAotCQl7IDB4MDksIDB4Mjc3MCB9LAotCQl7IDB4MDgsIDB4MDRkMCB9LAotCQl7IDB4MGIsIDB4YWQxNSB9LAotCQl7IDB4MGMsIDB4NWJmMCB9LAotCQl7IDB4MWMsIDB4ZjEwMSB9LAorCQl7IDB4MDYsIDB4NDA2NCB9LAorCQl7IDB4MDcsIDB4Mjg2MyB9LAorCQl7IDB4MDgsIDB4MDU5YyB9LAorCQl7IDB4MDksIDB4MjZiNCB9LAorCQl7IDB4MGEsIDB4NmExOSB9LAorCQl7IDB4MGIsIDB4ZGNjOCB9LAorCQl7IDB4MTAsIDB4ZjA2ZCB9LAorCQl7IDB4MTQsIDB4N2Y2OCB9LAorCQl7IDB4MTgsIDB4N2ZkOSB9LAorCQl7IDB4MWMsIDB4ZjBmZiB9LAorCQl7IDB4MWQsIDB4M2Q5YyB9LAogCQl7IDB4MWYsIDB4MDAwMyB9LAotCQl7IDB4MTQsIDB4OTRkNyB9LAotCQl7IDB4MTIsIDB4ZjRkNiB9LAotCQl7IDB4MDksIDB4Y2EwZiB9LAorCQl7IDB4MTIsIDB4ZjQ5ZiB9LAorCQl7IDB4MTMsIDB4MDcwYiB9LAorCQl7IDB4MWEsIDB4MDVhZCB9LAorCQl7IDB4MTQsIDB4OTRjMCB9CisJfTsKKwlzdGF0aWMgc3RydWN0IHBoeV9yZWcgcGh5X3JlZ19pbml0XzFbXSA9IHsKIAkJeyAweDFmLCAweDAwMDIgfSwKLQkJeyAweDBiLCAweDBiMTAgfSwKLQkJeyAweDBjLCAweGQxZjcgfSwKLQkJeyAweDFmLCAweDAwMDIgfSwKLQkJeyAweDA2LCAweDU0NjEgfSwKLQkJeyAweDFmLCAweDAwMDIgfSwKLQkJeyAweDA1LCAweDY2NjIgfSwKLQkJeyAweDFmLCAweDAwMDAgfSwKLQkJeyAweDE0LCAweDAwNjAgfSwKLQkJeyAweDFmLCAweDAwMDAgfSwKLQkJeyAweDBkLCAweGY4YTAgfSwKKwkJeyAweDA2LCAweDU1NjEgfSwKIAkJeyAweDFmLCAweDAwMDUgfSwKLQkJeyAweDA1LCAweGZmYzIgfQorCQl7IDB4MDUsIDB4ODMzMiB9LAorCQl7IDB4MDYsIDB4NTU2MSB9CisJfTsKKwlzdGF0aWMgc3RydWN0IHBoeV9yZWcgcGh5X3JlZ19pbml0XzJbXSA9IHsKKwkJeyAweDFmLCAweDAwMDUgfSwKKwkJeyAweDA1LCAweGZmYzIgfSwKKwkJeyAweDFmLCAweDAwMDUgfSwKKwkJeyAweDA1LCAweDgwMDAgfSwKKwkJeyAweDA2LCAweGY4ZjkgfSwKKwkJeyAweDA2LCAweGZhZWYgfSwKKwkJeyAweDA2LCAweDU5ZWUgfSwKKwkJeyAweDA2LCAweGY4ZWEgfSwKKwkJeyAweDA2LCAweDAwZWUgfSwKKwkJeyAweDA2LCAweGY4ZWIgfSwKKwkJeyAweDA2LCAweDAwZTAgfSwKKwkJeyAweDA2LCAweGY4N2MgfSwKKwkJeyAweDA2LCAweGUxZjggfSwKKwkJeyAweDA2LCAweDdkNTkgfSwKKwkJeyAweDA2LCAweDBmZWYgfSwKKwkJeyAweDA2LCAweDAxMzkgfSwKKwkJeyAweDA2LCAweDAyOWUgfSwKKwkJeyAweDA2LCAweDA2ZWYgfSwKKwkJeyAweDA2LCAweDEwMzkgfSwKKwkJeyAweDA2LCAweDA4OWYgfSwKKwkJeyAweDA2LCAweDJhZWUgfSwKKwkJeyAweDA2LCAweGY4ZWEgfSwKKwkJeyAweDA2LCAweDAwZWUgfSwKKwkJeyAweDA2LCAweGY4ZWIgfSwKKwkJeyAweDA2LCAweDAxZTAgfSwKKwkJeyAweDA2LCAweGY4N2MgfSwKKwkJeyAweDA2LCAweGUxZjggfSwKKwkJeyAweDA2LCAweDdkNTggfSwKKwkJeyAweDA2LCAweDQwOWUgfSwKKwkJeyAweDA2LCAweDBmMzkgfSwKKwkJeyAweDA2LCAweDQ2YWEgfSwKKwkJeyAweDA2LCAweDBiYmYgfSwKKwkJeyAweDA2LCAweDgyOTAgfSwKKwkJeyAweDA2LCAweGQ2ODIgfSwKKwkJeyAweDA2LCAweDk4MDIgfSwKKwkJeyAweDA2LCAweDAxNGYgfSwKKwkJeyAweDA2LCAweGFlMDkgfSwKKwkJeyAweDA2LCAweGJmODIgfSwKKwkJeyAweDA2LCAweDk4ZDYgfSwKKwkJeyAweDA2LCAweDgyYTAgfSwKKwkJeyAweDA2LCAweDAyMDEgfSwKKwkJeyAweDA2LCAweDRmZWYgfSwKKwkJeyAweDA2LCAweDk1ZmUgfSwKKwkJeyAweDA2LCAweGZkZmMgfSwKKwkJeyAweDA2LCAweDA1ZjggfSwKKwkJeyAweDA2LCAweGY5ZmEgfSwKKwkJeyAweDA2LCAweGVlZjggfSwKKwkJeyAweDA2LCAweGVhMDAgfSwKKwkJeyAweDA2LCAweGVlZjggfSwKKwkJeyAweDA2LCAweGViMDAgfSwKKwkJeyAweDA2LCAweGUyZjggfSwKKwkJeyAweDA2LCAweDdjZTMgfSwKKwkJeyAweDA2LCAweGY4N2QgfSwKKwkJeyAweDA2LCAweGE1MTEgfSwKKwkJeyAweDA2LCAweDExMTIgfSwKKwkJeyAweDA2LCAweGQyNDAgfSwKKwkJeyAweDA2LCAweGQ2NDQgfSwKKwkJeyAweDA2LCAweDQ0MDIgfSwKKwkJeyAweDA2LCAweDgyMTcgfSwKKwkJeyAweDA2LCAweGQyYTAgfSwKKwkJeyAweDA2LCAweGQ2YWEgfSwKKwkJeyAweDA2LCAweGFhMDIgfSwKKwkJeyAweDA2LCAweDgyMTcgfSwKKwkJeyAweDA2LCAweGFlMGYgfSwKKwkJeyAweDA2LCAweGE1NDQgfSwKKwkJeyAweDA2LCAweDQ0MDIgfSwKKwkJeyAweDA2LCAweGFlNGQgfSwKKwkJeyAweDA2LCAweGE1YWEgfSwKKwkJeyAweDA2LCAweGFhMDIgfSwKKwkJeyAweDA2LCAweGFlNDcgfSwKKwkJeyAweDA2LCAweGFmODIgfSwKKwkJeyAweDA2LCAweDEzZWUgfSwKKwkJeyAweDA2LCAweDgzNGUgfSwKKwkJeyAweDA2LCAweDAwZWUgfSwKKwkJeyAweDA2LCAweDgzNGQgfSwKKwkJeyAweDA2LCAweDBmZWUgfSwKKwkJeyAweDA2LCAweDgzNGMgfSwKKwkJeyAweDA2LCAweDBmZWUgfSwKKwkJeyAweDA2LCAweDgzNGYgfSwKKwkJeyAweDA2LCAweDAwZWUgfSwKKwkJeyAweDA2LCAweDgzNTEgfSwKKwkJeyAweDA2LCAweDAwZWUgfSwKKwkJeyAweDA2LCAweDgzNGEgfSwKKwkJeyAweDA2LCAweGZmZWUgfSwKKwkJeyAweDA2LCAweDgzNGIgfSwKKwkJeyAweDA2LCAweGZmZTAgfSwKKwkJeyAweDA2LCAweDgzMzAgfSwKKwkJeyAweDA2LCAweGUxODMgfSwKKwkJeyAweDA2LCAweDMxNTggfSwKKwkJeyAweDA2LCAweGZlZTQgfSwKKwkJeyAweDA2LCAweGY4OGEgfSwKKwkJeyAweDA2LCAweGU1ZjggfSwKKwkJeyAweDA2LCAweDhiZTAgfSwKKwkJeyAweDA2LCAweDgzMzIgfSwKKwkJeyAweDA2LCAweGUxODMgfSwKKwkJeyAweDA2LCAweDMzNTkgfSwKKwkJeyAweDA2LCAweDBmZTIgfSwKKwkJeyAweDA2LCAweDgzNGQgfSwKKwkJeyAweDA2LCAweDBjMjQgfSwKKwkJeyAweDA2LCAweDVhZjAgfSwKKwkJeyAweDA2LCAweDFlMTIgfSwKKwkJeyAweDA2LCAweGU0ZjggfSwKKwkJeyAweDA2LCAweDhjZTUgfSwKKwkJeyAweDA2LCAweGY4OGQgfSwKKwkJeyAweDA2LCAweGFmODIgfSwKKwkJeyAweDA2LCAweDEzZTAgfSwKKwkJeyAweDA2LCAweDgzNGYgfSwKKwkJeyAweDA2LCAweDEwZTQgfSwKKwkJeyAweDA2LCAweDgzNGYgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDRlNzggfSwKKwkJeyAweDA2LCAweDAwOWYgfSwKKwkJeyAweDA2LCAweDBhZTAgfSwKKwkJeyAweDA2LCAweDgzNGYgfSwKKwkJeyAweDA2LCAweGEwMTAgfSwKKwkJeyAweDA2LCAweGE1ZWUgfSwKKwkJeyAweDA2LCAweDgzNGUgfSwKKwkJeyAweDA2LCAweDAxZTAgfSwKKwkJeyAweDA2LCAweDgzNGUgfSwKKwkJeyAweDA2LCAweDc4MDUgfSwKKwkJeyAweDA2LCAweDllOWEgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDRlNzggfSwKKwkJeyAweDA2LCAweDA0OWUgfSwKKwkJeyAweDA2LCAweDEwZTAgfSwKKwkJeyAweDA2LCAweDgzNGUgfSwKKwkJeyAweDA2LCAweDc4MDMgfSwKKwkJeyAweDA2LCAweDllMGYgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDRlNzggfSwKKwkJeyAweDA2LCAweDAxOWUgfSwKKwkJeyAweDA2LCAweDA1YWUgfSwKKwkJeyAweDA2LCAweDBjYWYgfSwKKwkJeyAweDA2LCAweDgxZjggfSwKKwkJeyAweDA2LCAweGFmODEgfSwKKwkJeyAweDA2LCAweGEzYWYgfSwKKwkJeyAweDA2LCAweDgxZGMgfSwKKwkJeyAweDA2LCAweGFmODIgfSwKKwkJeyAweDA2LCAweDEzZWUgfSwKKwkJeyAweDA2LCAweDgzNDggfSwKKwkJeyAweDA2LCAweDAwZWUgfSwKKwkJeyAweDA2LCAweDgzNDkgfSwKKwkJeyAweDA2LCAweDAwZTAgfSwKKwkJeyAweDA2LCAweDgzNTEgfSwKKwkJeyAweDA2LCAweDEwZTQgfSwKKwkJeyAweDA2LCAweDgzNTEgfSwKKwkJeyAweDA2LCAweDU4MDEgfSwKKwkJeyAweDA2LCAweDlmZWEgfSwKKwkJeyAweDA2LCAweGQwMDAgfSwKKwkJeyAweDA2LCAweGQxODAgfSwKKwkJeyAweDA2LCAweDFmNjYgfSwKKwkJeyAweDA2LCAweGUyZjggfSwKKwkJeyAweDA2LCAweGVhZTMgfSwKKwkJeyAweDA2LCAweGY4ZWIgfSwKKwkJeyAweDA2LCAweDVhZjggfSwKKwkJeyAweDA2LCAweDFlMjAgfSwKKwkJeyAweDA2LCAweGU2ZjggfSwKKwkJeyAweDA2LCAweGVhZTUgfSwKKwkJeyAweDA2LCAweGY4ZWIgfSwKKwkJeyAweDA2LCAweGQzMDIgfSwKKwkJeyAweDA2LCAweGIzZmUgfSwKKwkJeyAweDA2LCAweGUyZjggfSwKKwkJeyAweDA2LCAweDdjZWYgfSwKKwkJeyAweDA2LCAweDMyNWIgfSwKKwkJeyAweDA2LCAweDgwZTMgfSwKKwkJeyAweDA2LCAweGY4N2QgfSwKKwkJeyAweDA2LCAweDllMDMgfSwKKwkJeyAweDA2LCAweDdkZmYgfSwKKwkJeyAweDA2LCAweGZmMGQgfSwKKwkJeyAweDA2LCAweDU4MWMgfSwKKwkJeyAweDA2LCAweDU1MWEgfSwKKwkJeyAweDA2LCAweDY1MTEgfSwKKwkJeyAweDA2LCAweGExOTAgfSwKKwkJeyAweDA2LCAweGQzZTIgfSwKKwkJeyAweDA2LCAweDgzNDggfSwKKwkJeyAweDA2LCAweGUzODMgfSwKKwkJeyAweDA2LCAweDQ5MWIgfSwKKwkJeyAweDA2LCAweDU2YWIgfSwKKwkJeyAweDA2LCAweDA4ZWYgfSwKKwkJeyAweDA2LCAweDU2ZTYgfSwKKwkJeyAweDA2LCAweDgzNDggfSwKKwkJeyAweDA2LCAweGU3ODMgfSwKKwkJeyAweDA2LCAweDQ5MTAgfSwKKwkJeyAweDA2LCAweGQxODAgfSwKKwkJeyAweDA2LCAweDFmNjYgfSwKKwkJeyAweDA2LCAweGEwMDQgfSwKKwkJeyAweDA2LCAweGI5ZTIgfSwKKwkJeyAweDA2LCAweDgzNDggfSwKKwkJeyAweDA2LCAweGUzODMgfSwKKwkJeyAweDA2LCAweDQ5ZWYgfSwKKwkJeyAweDA2LCAweDY1ZTIgfSwKKwkJeyAweDA2LCAweDgzNGEgfSwKKwkJeyAweDA2LCAweGUzODMgfSwKKwkJeyAweDA2LCAweDRiMWIgfSwKKwkJeyAweDA2LCAweDU2YWEgfSwKKwkJeyAweDA2LCAweDBlZWYgfSwKKwkJeyAweDA2LCAweDU2ZTYgfSwKKwkJeyAweDA2LCAweDgzNGEgfSwKKwkJeyAweDA2LCAweGU3ODMgfSwKKwkJeyAweDA2LCAweDRiZTIgfSwKKwkJeyAweDA2LCAweDgzNGQgfSwKKwkJeyAweDA2LCAweGU2ODMgfSwKKwkJeyAweDA2LCAweDRjZTAgfSwKKwkJeyAweDA2LCAweDgzNGQgfSwKKwkJeyAweDA2LCAweGEwMDAgfSwKKwkJeyAweDA2LCAweDBjYWYgfSwKKwkJeyAweDA2LCAweDgxZGMgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDRkMTAgfSwKKwkJeyAweDA2LCAweGU0ODMgfSwKKwkJeyAweDA2LCAweDRkYWUgfSwKKwkJeyAweDA2LCAweDA0ODAgfSwKKwkJeyAweDA2LCAweGU0ODMgfSwKKwkJeyAweDA2LCAweDRkZTAgfSwKKwkJeyAweDA2LCAweDgzNGUgfSwKKwkJeyAweDA2LCAweDc4MDMgfSwKKwkJeyAweDA2LCAweDllMGIgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDRlNzggfSwKKwkJeyAweDA2LCAweDA0OWUgfSwKKwkJeyAweDA2LCAweDA0ZWUgfSwKKwkJeyAweDA2LCAweDgzNGUgfSwKKwkJeyAweDA2LCAweDAyZTAgfSwKKwkJeyAweDA2LCAweDgzMzIgfSwKKwkJeyAweDA2LCAweGUxODMgfSwKKwkJeyAweDA2LCAweDMzNTkgfSwKKwkJeyAweDA2LCAweDBmZTIgfSwKKwkJeyAweDA2LCAweDgzNGQgfSwKKwkJeyAweDA2LCAweDBjMjQgfSwKKwkJeyAweDA2LCAweDVhZjAgfSwKKwkJeyAweDA2LCAweDFlMTIgfSwKKwkJeyAweDA2LCAweGU0ZjggfSwKKwkJeyAweDA2LCAweDhjZTUgfSwKKwkJeyAweDA2LCAweGY4OGQgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDMwZTEgfSwKKwkJeyAweDA2LCAweDgzMzEgfSwKKwkJeyAweDA2LCAweDY4MDEgfSwKKwkJeyAweDA2LCAweGU0ZjggfSwKKwkJeyAweDA2LCAweDhhZTUgfSwKKwkJeyAweDA2LCAweGY4OGIgfSwKKwkJeyAweDA2LCAweGFlMzcgfSwKKwkJeyAweDA2LCAweGVlODMgfSwKKwkJeyAweDA2LCAweDRlMDMgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDRjZTEgfSwKKwkJeyAweDA2LCAweDgzNGQgfSwKKwkJeyAweDA2LCAweDFiMDEgfSwKKwkJeyAweDA2LCAweDllMDQgfSwKKwkJeyAweDA2LCAweGFhYTEgfSwKKwkJeyAweDA2LCAweGFlYTggfSwKKwkJeyAweDA2LCAweGVlODMgfSwKKwkJeyAweDA2LCAweDRlMDQgfSwKKwkJeyAweDA2LCAweGVlODMgfSwKKwkJeyAweDA2LCAweDRmMDAgfSwKKwkJeyAweDA2LCAweGFlYWIgfSwKKwkJeyAweDA2LCAweGUwODMgfSwKKwkJeyAweDA2LCAweDRmNzggfSwKKwkJeyAweDA2LCAweDAzOWYgfSwKKwkJeyAweDA2LCAweDE0ZWUgfSwKKwkJeyAweDA2LCAweDgzNGUgfSwKKwkJeyAweDA2LCAweDA1ZDIgfSwKKwkJeyAweDA2LCAweDQwZDYgfSwKKwkJeyAweDA2LCAweDU1NTQgfSwKKwkJeyAweDA2LCAweDAyODIgfSwKKwkJeyAweDA2LCAweDE3ZDIgfSwKKwkJeyAweDA2LCAweGEwZDYgfSwKKwkJeyAweDA2LCAweGJhMDAgfSwKKwkJeyAweDA2LCAweDAyODIgfSwKKwkJeyAweDA2LCAweDE3ZmUgfSwKKwkJeyAweDA2LCAweGZkZmMgfSwKKwkJeyAweDA2LCAweDA1ZjggfSwKKwkJeyAweDA2LCAweGUwZjggfSwKKwkJeyAweDA2LCAweDYwZTEgfSwKKwkJeyAweDA2LCAweGY4NjEgfSwKKwkJeyAweDA2LCAweDY4MDIgfSwKKwkJeyAweDA2LCAweGU0ZjggfSwKKwkJeyAweDA2LCAweDYwZTUgfSwKKwkJeyAweDA2LCAweGY4NjEgfSwKKwkJeyAweDA2LCAweGUwZjggfSwKKwkJeyAweDA2LCAweDQ4ZTEgfSwKKwkJeyAweDA2LCAweGY4NDkgfSwKKwkJeyAweDA2LCAweDU4MGYgfSwKKwkJeyAweDA2LCAweDFlMDIgfSwKKwkJeyAweDA2LCAweGU0ZjggfSwKKwkJeyAweDA2LCAweDQ4ZTUgfSwKKwkJeyAweDA2LCAweGY4NDkgfSwKKwkJeyAweDA2LCAweGQwMDAgfSwKKwkJeyAweDA2LCAweDAyODIgfSwKKwkJeyAweDA2LCAweDViYmYgfSwKKwkJeyAweDA2LCAweDgzNTAgfSwKKwkJeyAweDA2LCAweGVmNDYgfSwKKwkJeyAweDA2LCAweGRjMTkgfSwKKwkJeyAweDA2LCAweGRkZDAgfSwKKwkJeyAweDA2LCAweDAxMDIgfSwKKwkJeyAweDA2LCAweDgyNWIgfSwKKwkJeyAweDA2LCAweDAyODIgfSwKKwkJeyAweDA2LCAweDc3ZTAgfSwKKwkJeyAweDA2LCAweGY4NjAgfSwKKwkJeyAweDA2LCAweGUxZjggfSwKKwkJeyAweDA2LCAweDYxNTggfSwKKwkJeyAweDA2LCAweGZkZTQgfSwKKwkJeyAweDA2LCAweGY4NjAgfSwKKwkJeyAweDA2LCAweGU1ZjggfSwKKwkJeyAweDA2LCAweDYxZmMgfSwKKwkJeyAweDA2LCAweDA0ZjkgfSwKKwkJeyAweDA2LCAweGZhZmIgfSwKKwkJeyAweDA2LCAweGM2YmYgfSwKKwkJeyAweDA2LCAweGY4NDAgfSwKKwkJeyAweDA2LCAweGJlODMgfSwKKwkJeyAweDA2LCAweDUwYTAgfSwKKwkJeyAweDA2LCAweDAxMDEgfSwKKwkJeyAweDA2LCAweDA3MWIgfSwKKwkJeyAweDA2LCAweDg5Y2YgfSwKKwkJeyAweDA2LCAweGQyMDggfSwKKwkJeyAweDA2LCAweGViZGIgfSwKKwkJeyAweDA2LCAweDE5YjIgfSwKKwkJeyAweDA2LCAweGZiZmYgfSwKKwkJeyAweDA2LCAweGZlZmQgfSwKKwkJeyAweDA2LCAweDA0ZjggfSwKKwkJeyAweDA2LCAweGUwZjggfSwKKwkJeyAweDA2LCAweDQ4ZTEgfSwKKwkJeyAweDA2LCAweGY4NDkgfSwKKwkJeyAweDA2LCAweDY4MDggfSwKKwkJeyAweDA2LCAweGU0ZjggfSwKKwkJeyAweDA2LCAweDQ4ZTUgfSwKKwkJeyAweDA2LCAweGY4NDkgfSwKKwkJeyAweDA2LCAweDU4ZjcgfSwKKwkJeyAweDA2LCAweGU0ZjggfSwKKwkJeyAweDA2LCAweDQ4ZTUgfSwKKwkJeyAweDA2LCAweGY4NDkgfSwKKwkJeyAweDA2LCAweGZjMDQgfSwKKwkJeyAweDA2LCAweDRkMjAgfSwKKwkJeyAweDA2LCAweDAwMDIgfSwKKwkJeyAweDA2LCAweDRlMjIgfSwKKwkJeyAweDA2LCAweDAwMDIgfSwKKwkJeyAweDA2LCAweDRkZGYgfSwKKwkJeyAweDA2LCAweGZmMDEgfSwKKwkJeyAweDA2LCAweDRlZGQgfSwKKwkJeyAweDA2LCAweGZmMDEgfSwKKwkJeyAweDA1LCAweDgzZDQgfSwKKwkJeyAweDA2LCAweDgwMDAgfSwKKwkJeyAweDA1LCAweDgzZDggfSwKKwkJeyAweDA2LCAweDgwNTEgfSwKKwkJeyAweDAyLCAweDYwMTAgfSwKKwkJeyAweDAzLCAweGRjMDAgfSwKKwkJeyAweDA1LCAweGZmZjYgfSwKKwkJeyAweDA2LCAweDAwZmMgfSwKKwkJeyAweDFmLCAweDAwMDAgfSwKKworCQl7IDB4MWYsIDB4MDAwMCB9LAorCQl7IDB4MGQsIDB4Zjg4MCB9LAorCQl7IDB4MWYsIDB4MDAwMCB9CiAJfTsKIAogCXJ0bF9waHlfd3JpdGUoaW9hZGRyLCBwaHlfcmVnX2luaXRfMCwgQVJSQVlfU0laRShwaHlfcmVnX2luaXRfMCkpOwogCi0JaWYgKG1kaW9fcmVhZChpb2FkZHIsIDB4MDYpID09IDB4YzQwMCkgewotCQlzdHJ1Y3QgcGh5X3JlZyBwaHlfcmVnX2luaXRfMVtdID0geworCW1kaW9fd3JpdGUoaW9hZGRyLCAweDFmLCAweDAwMDIpOworCW1kaW9fcGx1c19taW51cyhpb2FkZHIsIDB4MGIsIDB4MDAxMCwgMHgwMGVmKTsKKwltZGlvX3BsdXNfbWludXMoaW9hZGRyLCAweDBjLCAweGEyMDAsIDB4NWQwMCk7CisKKwlydGxfcGh5X3dyaXRlKGlvYWRkciwgcGh5X3JlZ19pbml0XzEsIEFSUkFZX1NJWkUocGh5X3JlZ19pbml0XzEpKTsKKworCWlmIChydGw4MTY4ZF9lZnVzZV9yZWFkKGlvYWRkciwgMHgwMSkgPT0gMHhiMSkgeworCQlzdHJ1Y3QgcGh5X3JlZyBwaHlfcmVnX2luaXRbXSA9IHsKKwkJCXsgMHgxZiwgMHgwMDAyIH0sCisJCQl7IDB4MDUsIDB4NjY5YSB9LAogCQkJeyAweDFmLCAweDAwMDUgfSwKLQkJCXsgMHgwMSwgMHgwMzAwIH0sCi0JCQl7IDB4MWYsIDB4MDAwMCB9LAotCQkJeyAweDExLCAweDQwMWMgfSwKLQkJCXsgMHgxNiwgMHg0MTAwIH0sCisJCQl7IDB4MDUsIDB4ODMzMCB9LAorCQkJeyAweDA2LCAweDY2OWEgfSwKKwkJCXsgMHgxZiwgMHgwMDAyIH0KKwkJfTsKKwkJaW50IHZhbDsKKworCQlydGxfcGh5X3dyaXRlKGlvYWRkciwgcGh5X3JlZ19pbml0LCBBUlJBWV9TSVpFKHBoeV9yZWdfaW5pdCkpOworCisJCXZhbCA9IG1kaW9fcmVhZChpb2FkZHIsIDB4MGQpOworCisJCWlmICgodmFsICYgMHgwMGZmKSAhPSAweDAwNmMpIHsKKwkJCXUzMiBzZXRbXSA9IHsKKwkJCQkweDAwNjUsIDB4MDA2NiwgMHgwMDY3LCAweDAwNjgsCisJCQkJMHgwMDY5LCAweDAwNmEsIDB4MDA2YiwgMHgwMDZjCisJCQl9OworCQkJaW50IGk7CisKKwkJCW1kaW9fd3JpdGUoaW9hZGRyLCAweDFmLCAweDAwMDIpOworCisJCQl2YWwgJj0gMHhmZjAwOworCQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoc2V0KTsgaSsrKQorCQkJCW1kaW9fd3JpdGUoaW9hZGRyLCAweDBkLCB2YWwgfCBzZXRbaV0pOworCQl9CisJfSBlbHNlIHsKKwkJc3RydWN0IHBoeV9yZWcgcGh5X3JlZ19pbml0W10gPSB7CisJCQl7IDB4MWYsIDB4MDAwMiB9LAorCQkJeyAweDA1LCAweDY2NjIgfSwKIAkJCXsgMHgxZiwgMHgwMDA1IH0sCi0JCQl7IDB4MDcsIDB4MDAxMCB9LAotCQkJeyAweDA1LCAweDgzZGMgfSwKLQkJCXsgMHgwNiwgMHgwODdkIH0sCi0JCQl7IDB4MDUsIDB4ODMwMCB9LAotCQkJeyAweDA2LCAweDAxMDEgfSwKLQkJCXsgMHgwNiwgMHgwNWY4IH0sCi0JCQl7IDB4MDYsIDB4ZjlmYSB9LAotCQkJeyAweDA2LCAweGZiZWYgfSwKLQkJCXsgMHgwNiwgMHg3OWUyIH0sCi0JCQl7IDB4MDYsIDB4ODM1ZiB9LAotCQkJeyAweDA2LCAweGUwZjggfSwKLQkJCXsgMHgwNiwgMHg5YWUxIH0sCi0JCQl7IDB4MDYsIDB4Zjg5YiB9LAotCQkJeyAweDA2LCAweGVmMzEgfSwKLQkJCXsgMHgwNiwgMHgzYjY1IH0sCi0JCQl7IDB4MDYsIDB4YWEwNyB9LAotCQkJeyAweDA2LCAweDgxZTQgfSwKLQkJCXsgMHgwNiwgMHhmODlhIH0sCi0JCQl7IDB4MDYsIDB4ZTVmOCB9LAotCQkJeyAweDA2LCAweDliYWYgfSwKLQkJCXsgMHgwNiwgMHgwNmFlIH0sCi0JCQl7IDB4MDUsIDB4ODNkYyB9LAotCQkJeyAweDA2LCAweDgzMDAgfSwKKwkJCXsgMHgwNSwgMHg4MzMwIH0sCisJCQl7IDB4MDYsIDB4NjY2MiB9CiAJCX07CiAKLQkJcnRsX3BoeV93cml0ZShpb2FkZHIsIHBoeV9yZWdfaW5pdF8xLAotCQkJICAgICAgQVJSQVlfU0laRShwaHlfcmVnX2luaXRfMSkpOworCQlydGxfcGh5X3dyaXRlKGlvYWRkciwgcGh5X3JlZ19pbml0LCBBUlJBWV9TSVpFKHBoeV9yZWdfaW5pdCkpOwogCX0KIAotCW1kaW9fd3JpdGUoaW9hZGRyLCAweDFmLCAweDAwMDApOworCW1kaW9fd3JpdGUoaW9hZGRyLCAweDFmLCAweDAwMDIpOworCW1kaW9fcGF0Y2goaW9hZGRyLCAweDBkLCAweDAzMDApOworCW1kaW9fcGF0Y2goaW9hZGRyLCAweDBmLCAweDAwMTApOworCisJbWRpb193cml0ZShpb2FkZHIsIDB4MWYsIDB4MDAwMik7CisJbWRpb19wbHVzX21pbnVzKGlvYWRkciwgMHgwMiwgMHgwMTAwLCAweDA2MDApOworCW1kaW9fcGx1c19taW51cyhpb2FkZHIsIDB4MDMsIDB4MDAwMCwgMHhlMDAwKTsKKworCXJ0bF9waHlfd3JpdGUoaW9hZGRyLCBwaHlfcmVnX2luaXRfMiwgQVJSQVlfU0laRShwaHlfcmVnX2luaXRfMikpOworfQorCitzdGF0aWMgdm9pZCBydGw4MTY4ZF8yX2h3X3BoeV9jb25maWcodm9pZCBfX2lvbWVtICppb2FkZHIpCit7CisJc3RhdGljIHN0cnVjdCBwaHlfcmVnIHBoeV9yZWdfaW5pdF8wW10gPSB7CisJCXsgMHgxZiwgMHgwMDAxIH0sCisJCXsgMHgwNiwgMHg0MDY0IH0sCisJCXsgMHgwNywgMHgyODYzIH0sCisJCXsgMHgwOCwgMHgwNTljIH0sCisJCXsgMHgwOSwgMHgyNmI0IH0sCisJCXsgMHgwYSwgMHg2YTE5IH0sCisJCXsgMHgwYiwgMHhkY2M4IH0sCisJCXsgMHgxMCwgMHhmMDZkIH0sCisJCXsgMHgxNCwgMHg3ZjY4IH0sCisJCXsgMHgxOCwgMHg3ZmQ5IH0sCisJCXsgMHgxYywgMHhmMGZmIH0sCisJCXsgMHgxZCwgMHgzZDljIH0sCisJCXsgMHgxZiwgMHgwMDAzIH0sCisJCXsgMHgxMiwgMHhmNDlmIH0sCisJCXsgMHgxMywgMHgwNzBiIH0sCisJCXsgMHgxYSwgMHgwNWFkIH0sCisJCXsgMHgxNCwgMHg5NGMwIH0sCisKKwkJeyAweDFmLCAweDAwMDIgfSwKKwkJeyAweDA2LCAweDU1NjEgfSwKKwkJeyAweDFmLCAweDAwMDUgfSwKKwkJeyAweDA1LCAweDgzMzIgfSwKKwkJeyAweDA2LCAweDU1NjEgfQorCX07CisJc3RhdGljIHN0cnVjdCBwaHlfcmVnIHBoeV9yZWdfaW5pdF8xW10gPSB7CisJCXsgMHgxZiwgMHgwMDA1IH0sCisJCXsgMHgwNSwgMHhmZmMyIH0sCisJCXsgMHgxZiwgMHgwMDA1IH0sCisJCXsgMHgwNSwgMHg4MDAwIH0sCisJCXsgMHgwNiwgMHhmOGY5IH0sCisJCXsgMHgwNiwgMHhmYWVlIH0sCisJCXsgMHgwNiwgMHhmOGVhIH0sCisJCXsgMHgwNiwgMHgwMGVlIH0sCisJCXsgMHgwNiwgMHhmOGViIH0sCisJCXsgMHgwNiwgMHgwMGUyIH0sCisJCXsgMHgwNiwgMHhmODdjIH0sCisJCXsgMHgwNiwgMHhlM2Y4IH0sCisJCXsgMHgwNiwgMHg3ZGE1IH0sCisJCXsgMHgwNiwgMHgxMTExIH0sCisJCXsgMHgwNiwgMHgxMmQyIH0sCisJCXsgMHgwNiwgMHg0MGQ2IH0sCisJCXsgMHgwNiwgMHg0NDQ0IH0sCisJCXsgMHgwNiwgMHgwMjgxIH0sCisJCXsgMHgwNiwgMHhjNmQyIH0sCisJCXsgMHgwNiwgMHhhMGQ2IH0sCisJCXsgMHgwNiwgMHhhYWFhIH0sCisJCXsgMHgwNiwgMHgwMjgxIH0sCisJCXsgMHgwNiwgMHhjNmFlIH0sCisJCXsgMHgwNiwgMHgwZmE1IH0sCisJCXsgMHgwNiwgMHg0NDQ0IH0sCisJCXsgMHgwNiwgMHgwMmFlIH0sCisJCXsgMHgwNiwgMHg0ZGE1IH0sCisJCXsgMHgwNiwgMHhhYWFhIH0sCisJCXsgMHgwNiwgMHgwMmFlIH0sCisJCXsgMHgwNiwgMHg0N2FmIH0sCisJCXsgMHgwNiwgMHg4MWMyIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0ZTAwIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0ZDBmIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0YzBmIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0ZjAwIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg1MTAwIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0YWZmIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0YmZmIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHgzMGUxIH0sCisJCXsgMHgwNiwgMHg4MzMxIH0sCisJCXsgMHgwNiwgMHg1OGZlIH0sCisJCXsgMHgwNiwgMHhlNGY4IH0sCisJCXsgMHgwNiwgMHg4YWU1IH0sCisJCXsgMHgwNiwgMHhmODhiIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHgzMmUxIH0sCisJCXsgMHgwNiwgMHg4MzMzIH0sCisJCXsgMHgwNiwgMHg1OTBmIH0sCisJCXsgMHgwNiwgMHhlMjgzIH0sCisJCXsgMHgwNiwgMHg0ZDBjIH0sCisJCXsgMHgwNiwgMHgyNDVhIH0sCisJCXsgMHgwNiwgMHhmMDFlIH0sCisJCXsgMHgwNiwgMHgxMmU0IH0sCisJCXsgMHgwNiwgMHhmODhjIH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHg4ZGFmIH0sCisJCXsgMHgwNiwgMHg4MWMyIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHg0ZjEwIH0sCisJCXsgMHgwNiwgMHhlNDgzIH0sCisJCXsgMHgwNiwgMHg0ZmUwIH0sCisJCXsgMHgwNiwgMHg4MzRlIH0sCisJCXsgMHgwNiwgMHg3ODAwIH0sCisJCXsgMHgwNiwgMHg5ZjBhIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHg0ZmEwIH0sCisJCXsgMHgwNiwgMHgxMGE1IH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0ZTAxIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHg0ZTc4IH0sCisJCXsgMHgwNiwgMHgwNTllIH0sCisJCXsgMHgwNiwgMHg5YWUwIH0sCisJCXsgMHgwNiwgMHg4MzRlIH0sCisJCXsgMHgwNiwgMHg3ODA0IH0sCisJCXsgMHgwNiwgMHg5ZTEwIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHg0ZTc4IH0sCisJCXsgMHgwNiwgMHgwMzllIH0sCisJCXsgMHgwNiwgMHgwZmUwIH0sCisJCXsgMHgwNiwgMHg4MzRlIH0sCisJCXsgMHgwNiwgMHg3ODAxIH0sCisJCXsgMHgwNiwgMHg5ZTA1IH0sCisJCXsgMHgwNiwgMHhhZTBjIH0sCisJCXsgMHgwNiwgMHhhZjgxIH0sCisJCXsgMHgwNiwgMHhhN2FmIH0sCisJCXsgMHgwNiwgMHg4MTUyIH0sCisJCXsgMHgwNiwgMHhhZjgxIH0sCisJCXsgMHgwNiwgMHg4YmFmIH0sCisJCXsgMHgwNiwgMHg4MWMyIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0ODAwIH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0OTAwIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHg1MTEwIH0sCisJCXsgMHgwNiwgMHhlNDgzIH0sCisJCXsgMHgwNiwgMHg1MTU4IH0sCisJCXsgMHgwNiwgMHgwMTlmIH0sCisJCXsgMHgwNiwgMHhlYWQwIH0sCisJCXsgMHgwNiwgMHgwMGQxIH0sCisJCXsgMHgwNiwgMHg4MDFmIH0sCisJCXsgMHgwNiwgMHg2NmUyIH0sCisJCXsgMHgwNiwgMHhmOGVhIH0sCisJCXsgMHgwNiwgMHhlM2Y4IH0sCisJCXsgMHgwNiwgMHhlYjVhIH0sCisJCXsgMHgwNiwgMHhmODFlIH0sCisJCXsgMHgwNiwgMHgyMGU2IH0sCisJCXsgMHgwNiwgMHhmOGVhIH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHhlYmQzIH0sCisJCXsgMHgwNiwgMHgwMmIzIH0sCisJCXsgMHgwNiwgMHhmZWUyIH0sCisJCXsgMHgwNiwgMHhmODdjIH0sCisJCXsgMHgwNiwgMHhlZjMyIH0sCisJCXsgMHgwNiwgMHg1YjgwIH0sCisJCXsgMHgwNiwgMHhlM2Y4IH0sCisJCXsgMHgwNiwgMHg3ZDllIH0sCisJCXsgMHgwNiwgMHgwMzdkIH0sCisJCXsgMHgwNiwgMHhmZmZmIH0sCisJCXsgMHgwNiwgMHgwZDU4IH0sCisJCXsgMHgwNiwgMHgxYzU1IH0sCisJCXsgMHgwNiwgMHgxYTY1IH0sCisJCXsgMHgwNiwgMHgxMWExIH0sCisJCXsgMHgwNiwgMHg5MGQzIH0sCisJCXsgMHgwNiwgMHhlMjgzIH0sCisJCXsgMHgwNiwgMHg0OGUzIH0sCisJCXsgMHgwNiwgMHg4MzQ5IH0sCisJCXsgMHgwNiwgMHgxYjU2IH0sCisJCXsgMHgwNiwgMHhhYjA4IH0sCisJCXsgMHgwNiwgMHhlZjU2IH0sCisJCXsgMHgwNiwgMHhlNjgzIH0sCisJCXsgMHgwNiwgMHg0OGU3IH0sCisJCXsgMHgwNiwgMHg4MzQ5IH0sCisJCXsgMHgwNiwgMHgxMGQxIH0sCisJCXsgMHgwNiwgMHg4MDFmIH0sCisJCXsgMHgwNiwgMHg2NmEwIH0sCisJCXsgMHgwNiwgMHgwNGI5IH0sCisJCXsgMHgwNiwgMHhlMjgzIH0sCisJCXsgMHgwNiwgMHg0OGUzIH0sCisJCXsgMHgwNiwgMHg4MzQ5IH0sCisJCXsgMHgwNiwgMHhlZjY1IH0sCisJCXsgMHgwNiwgMHhlMjgzIH0sCisJCXsgMHgwNiwgMHg0YWUzIH0sCisJCXsgMHgwNiwgMHg4MzRiIH0sCisJCXsgMHgwNiwgMHgxYjU2IH0sCisJCXsgMHgwNiwgMHhhYTBlIH0sCisJCXsgMHgwNiwgMHhlZjU2IH0sCisJCXsgMHgwNiwgMHhlNjgzIH0sCisJCXsgMHgwNiwgMHg0YWU3IH0sCisJCXsgMHgwNiwgMHg4MzRiIH0sCisJCXsgMHgwNiwgMHhlMjgzIH0sCisJCXsgMHgwNiwgMHg0ZGU2IH0sCisJCXsgMHgwNiwgMHg4MzRjIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHg0ZGEwIH0sCisJCXsgMHgwNiwgMHgwMDBjIH0sCisJCXsgMHgwNiwgMHhhZjgxIH0sCisJCXsgMHgwNiwgMHg4YmUwIH0sCisJCXsgMHgwNiwgMHg4MzRkIH0sCisJCXsgMHgwNiwgMHgxMGU0IH0sCisJCXsgMHgwNiwgMHg4MzRkIH0sCisJCXsgMHgwNiwgMHhhZTA0IH0sCisJCXsgMHgwNiwgMHg4MGU0IH0sCisJCXsgMHgwNiwgMHg4MzRkIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHg0ZTc4IH0sCisJCXsgMHgwNiwgMHgwMzllIH0sCisJCXsgMHgwNiwgMHgwYmUwIH0sCisJCXsgMHgwNiwgMHg4MzRlIH0sCisJCXsgMHgwNiwgMHg3ODA0IH0sCisJCXsgMHgwNiwgMHg5ZTA0IH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0ZTAyIH0sCisJCXsgMHgwNiwgMHhlMDgzIH0sCisJCXsgMHgwNiwgMHgzMmUxIH0sCisJCXsgMHgwNiwgMHg4MzMzIH0sCisJCXsgMHgwNiwgMHg1OTBmIH0sCisJCXsgMHgwNiwgMHhlMjgzIH0sCisJCXsgMHgwNiwgMHg0ZDBjIH0sCisJCXsgMHgwNiwgMHgyNDVhIH0sCisJCXsgMHgwNiwgMHhmMDFlIH0sCisJCXsgMHgwNiwgMHgxMmU0IH0sCisJCXsgMHgwNiwgMHhmODhjIH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHg4ZGUwIH0sCisJCXsgMHgwNiwgMHg4MzMwIH0sCisJCXsgMHgwNiwgMHhlMTgzIH0sCisJCXsgMHgwNiwgMHgzMTY4IH0sCisJCXsgMHgwNiwgMHgwMWU0IH0sCisJCXsgMHgwNiwgMHhmODhhIH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHg4YmFlIH0sCisJCXsgMHgwNiwgMHgzN2VlIH0sCisJCXsgMHgwNiwgMHg4MzRlIH0sCisJCXsgMHgwNiwgMHgwM2UwIH0sCisJCXsgMHgwNiwgMHg4MzRjIH0sCisJCXsgMHgwNiwgMHhlMTgzIH0sCisJCXsgMHgwNiwgMHg0ZDFiIH0sCisJCXsgMHgwNiwgMHgwMTllIH0sCisJCXsgMHgwNiwgMHgwNGFhIH0sCisJCXsgMHgwNiwgMHhhMWFlIH0sCisJCXsgMHgwNiwgMHhhOGVlIH0sCisJCXsgMHgwNiwgMHg4MzRlIH0sCisJCXsgMHgwNiwgMHgwNGVlIH0sCisJCXsgMHgwNiwgMHg4MzRmIH0sCisJCXsgMHgwNiwgMHgwMGFlIH0sCisJCXsgMHgwNiwgMHhhYmUwIH0sCisJCXsgMHgwNiwgMHg4MzRmIH0sCisJCXsgMHgwNiwgMHg3ODAzIH0sCisJCXsgMHgwNiwgMHg5ZjE0IH0sCisJCXsgMHgwNiwgMHhlZTgzIH0sCisJCXsgMHgwNiwgMHg0ZTA1IH0sCisJCXsgMHgwNiwgMHhkMjQwIH0sCisJCXsgMHgwNiwgMHhkNjU1IH0sCisJCXsgMHgwNiwgMHg1NDAyIH0sCisJCXsgMHgwNiwgMHg4MWM2IH0sCisJCXsgMHgwNiwgMHhkMmEwIH0sCisJCXsgMHgwNiwgMHhkNmJhIH0sCisJCXsgMHgwNiwgMHgwMDAyIH0sCisJCXsgMHgwNiwgMHg4MWM2IH0sCisJCXsgMHgwNiwgMHhmZWZkIH0sCisJCXsgMHgwNiwgMHhmYzA1IH0sCisJCXsgMHgwNiwgMHhmOGUwIH0sCisJCXsgMHgwNiwgMHhmODYwIH0sCisJCXsgMHgwNiwgMHhlMWY4IH0sCisJCXsgMHgwNiwgMHg2MTY4IH0sCisJCXsgMHgwNiwgMHgwMmU0IH0sCisJCXsgMHgwNiwgMHhmODYwIH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHg2MWUwIH0sCisJCXsgMHgwNiwgMHhmODQ4IH0sCisJCXsgMHgwNiwgMHhlMWY4IH0sCisJCXsgMHgwNiwgMHg0OTU4IH0sCisJCXsgMHgwNiwgMHgwZjFlIH0sCisJCXsgMHgwNiwgMHgwMmU0IH0sCisJCXsgMHgwNiwgMHhmODQ4IH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHg0OWQwIH0sCisJCXsgMHgwNiwgMHgwMDAyIH0sCisJCXsgMHgwNiwgMHg4MjBhIH0sCisJCXsgMHgwNiwgMHhiZjgzIH0sCisJCXsgMHgwNiwgMHg1MGVmIH0sCisJCXsgMHgwNiwgMHg0NmRjIH0sCisJCXsgMHgwNiwgMHgxOWRkIH0sCisJCXsgMHgwNiwgMHhkMDAxIH0sCisJCXsgMHgwNiwgMHgwMjgyIH0sCisJCXsgMHgwNiwgMHgwYTAyIH0sCisJCXsgMHgwNiwgMHg4MjI2IH0sCisJCXsgMHgwNiwgMHhlMGY4IH0sCisJCXsgMHgwNiwgMHg2MGUxIH0sCisJCXsgMHgwNiwgMHhmODYxIH0sCisJCXsgMHgwNiwgMHg1OGZkIH0sCisJCXsgMHgwNiwgMHhlNGY4IH0sCisJCXsgMHgwNiwgMHg2MGU1IH0sCisJCXsgMHgwNiwgMHhmODYxIH0sCisJCXsgMHgwNiwgMHhmYzA0IH0sCisJCXsgMHgwNiwgMHhmOWZhIH0sCisJCXsgMHgwNiwgMHhmYmM2IH0sCisJCXsgMHgwNiwgMHhiZmY4IH0sCisJCXsgMHgwNiwgMHg0MGJlIH0sCisJCXsgMHgwNiwgMHg4MzUwIH0sCisJCXsgMHgwNiwgMHhhMDAxIH0sCisJCXsgMHgwNiwgMHgwMTA3IH0sCisJCXsgMHgwNiwgMHgxYjg5IH0sCisJCXsgMHgwNiwgMHhjZmQyIH0sCisJCXsgMHgwNiwgMHgwOGViIH0sCisJCXsgMHgwNiwgMHhkYjE5IH0sCisJCXsgMHgwNiwgMHhiMmZiIH0sCisJCXsgMHgwNiwgMHhmZmZlIH0sCisJCXsgMHgwNiwgMHhmZDA0IH0sCisJCXsgMHgwNiwgMHhmOGUwIH0sCisJCXsgMHgwNiwgMHhmODQ4IH0sCisJCXsgMHgwNiwgMHhlMWY4IH0sCisJCXsgMHgwNiwgMHg0OTY4IH0sCisJCXsgMHgwNiwgMHgwOGU0IH0sCisJCXsgMHgwNiwgMHhmODQ4IH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHg0OTU4IH0sCisJCXsgMHgwNiwgMHhmN2U0IH0sCisJCXsgMHgwNiwgMHhmODQ4IH0sCisJCXsgMHgwNiwgMHhlNWY4IH0sCisJCXsgMHgwNiwgMHg0OWZjIH0sCisJCXsgMHgwNiwgMHgwNDRkIH0sCisJCXsgMHgwNiwgMHgyMDAwIH0sCisJCXsgMHgwNiwgMHgwMjRlIH0sCisJCXsgMHgwNiwgMHgyMjAwIH0sCisJCXsgMHgwNiwgMHgwMjRkIH0sCisJCXsgMHgwNiwgMHhkZmZmIH0sCisJCXsgMHgwNiwgMHgwMTRlIH0sCisJCXsgMHgwNiwgMHhkZGZmIH0sCisJCXsgMHgwNiwgMHgwMTAwIH0sCisJCXsgMHgwNSwgMHg4M2Q4IH0sCisJCXsgMHgwNiwgMHg4MDAwIH0sCisJCXsgMHgwMywgMHhkYzAwIH0sCisJCXsgMHgwNSwgMHhmZmY2IH0sCisJCXsgMHgwNiwgMHgwMGZjIH0sCisJCXsgMHgxZiwgMHgwMDAwIH0sCisKKwkJeyAweDFmLCAweDAwMDAgfSwKKwkJeyAweDBkLCAweGY4ODAgfSwKKwkJeyAweDFmLCAweDAwMDAgfQorCX07CisKKwlydGxfcGh5X3dyaXRlKGlvYWRkciwgcGh5X3JlZ19pbml0XzAsIEFSUkFZX1NJWkUocGh5X3JlZ19pbml0XzApKTsKKworCWlmIChydGw4MTY4ZF9lZnVzZV9yZWFkKGlvYWRkciwgMHgwMSkgPT0gMHhiMSkgeworCQlzdHJ1Y3QgcGh5X3JlZyBwaHlfcmVnX2luaXRbXSA9IHsKKwkJCXsgMHgxZiwgMHgwMDAyIH0sCisJCQl7IDB4MDUsIDB4NjY5YSB9LAorCQkJeyAweDFmLCAweDAwMDUgfSwKKwkJCXsgMHgwNSwgMHg4MzMwIH0sCisJCQl7IDB4MDYsIDB4NjY5YSB9LAorCisJCQl7IDB4MWYsIDB4MDAwMiB9CisJCX07CisJCWludCB2YWw7CisKKwkJcnRsX3BoeV93cml0ZShpb2FkZHIsIHBoeV9yZWdfaW5pdCwgQVJSQVlfU0laRShwaHlfcmVnX2luaXQpKTsKKworCQl2YWwgPSBtZGlvX3JlYWQoaW9hZGRyLCAweDBkKTsKKwkJaWYgKCh2YWwgJiAweDAwZmYpICE9IDB4MDA2YykgeworCQkJdTMyIHNldFtdID0geworCQkJCTB4MDA2NSwgMHgwMDY2LCAweDAwNjcsIDB4MDA2OCwKKwkJCQkweDAwNjksIDB4MDA2YSwgMHgwMDZiLCAweDAwNmMKKwkJCX07CisJCQlpbnQgaTsKKworCQkJbWRpb193cml0ZShpb2FkZHIsIDB4MWYsIDB4MDAwMik7CisKKwkJCXZhbCAmPSAweGZmMDA7CisJCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShzZXQpOyBpKyspCisJCQkJbWRpb193cml0ZShpb2FkZHIsIDB4MGQsIHZhbCB8IHNldFtpXSk7CisJCX0KKwl9IGVsc2UgeworCQlzdHJ1Y3QgcGh5X3JlZyBwaHlfcmVnX2luaXRbXSA9IHsKKwkJCXsgMHgxZiwgMHgwMDAyIH0sCisJCQl7IDB4MDUsIDB4MjY0MiB9LAorCQkJeyAweDFmLCAweDAwMDUgfSwKKwkJCXsgMHgwNSwgMHg4MzMwIH0sCisJCQl7IDB4MDYsIDB4MjY0MiB9CisJCX07CisKKwkJcnRsX3BoeV93cml0ZShpb2FkZHIsIHBoeV9yZWdfaW5pdCwgQVJSQVlfU0laRShwaHlfcmVnX2luaXQpKTsKKwl9CisKKwltZGlvX3dyaXRlKGlvYWRkciwgMHgxZiwgMHgwMDAyKTsKKwltZGlvX3BsdXNfbWludXMoaW9hZGRyLCAweDAyLCAweDAxMDAsIDB4MDYwMCk7CisJbWRpb19wbHVzX21pbnVzKGlvYWRkciwgMHgwMywgMHgwMDAwLCAweGUwMDApOworCisJbWRpb193cml0ZShpb2FkZHIsIDB4MWYsIDB4MDAwMSk7CisJbWRpb193cml0ZShpb2FkZHIsIDB4MTcsIDB4MGNjMCk7CisKKwltZGlvX3dyaXRlKGlvYWRkciwgMHgxZiwgMHgwMDAyKTsKKwltZGlvX3BhdGNoKGlvYWRkciwgMHgwZiwgMHgwMDE3KTsKKworCXJ0bF9waHlfd3JpdGUoaW9hZGRyLCBwaHlfcmVnX2luaXRfMSwgQVJSQVlfU0laRShwaHlfcmVnX2luaXRfMSkpOworfQorCitzdGF0aWMgdm9pZCBydGw4MTY4ZF8zX2h3X3BoeV9jb25maWcodm9pZCBfX2lvbWVtICppb2FkZHIpCit7CisJc3RydWN0IHBoeV9yZWcgcGh5X3JlZ19pbml0W10gPSB7CisJCXsgMHgxZiwgMHgwMDAyIH0sCisJCXsgMHgxMCwgMHgwMDA4IH0sCisJCXsgMHgwZCwgMHgwMDZjIH0sCisKKwkJeyAweDFmLCAweDAwMDAgfSwKKwkJeyAweDBkLCAweGY4ODAgfSwKKworCQl7IDB4MWYsIDB4MDAwMSB9LAorCQl7IDB4MTcsIDB4MGNjMCB9LAorCisJCXsgMHgxZiwgMHgwMDAxIH0sCisJCXsgMHgwYiwgMHhhNGQ4IH0sCisJCXsgMHgwOSwgMHgyODFjIH0sCisJCXsgMHgwNywgMHgyODgzIH0sCisJCXsgMHgwYSwgMHg2YjM1IH0sCisJCXsgMHgxZCwgMHgzZGE0IH0sCisJCXsgMHgxYywgMHhlZmZkIH0sCisJCXsgMHgxNCwgMHg3ZjUyIH0sCisJCXsgMHgxOCwgMHg3ZmM2IH0sCisJCXsgMHgwOCwgMHgwNjAxIH0sCisJCXsgMHgwNiwgMHg0MDYzIH0sCisJCXsgMHgxMCwgMHhmMDc0IH0sCisJCXsgMHgxZiwgMHgwMDAzIH0sCisJCXsgMHgxMywgMHgwNzg5IH0sCisJCXsgMHgxMiwgMHhmNGJkIH0sCisJCXsgMHgxYSwgMHgwNGZkIH0sCisJCXsgMHgxNCwgMHg4NGIwIH0sCisJCXsgMHgxZiwgMHgwMDAwIH0sCisJCXsgMHgwMCwgMHg5MjAwIH0sCisKKwkJeyAweDFmLCAweDAwMDUgfSwKKwkJeyAweDAxLCAweDAzNDAgfSwKKwkJeyAweDFmLCAweDAwMDEgfSwKKwkJeyAweDA0LCAweDQwMDAgfSwKKwkJeyAweDAzLCAweDFkMjEgfSwKKwkJeyAweDAyLCAweDBjMzIgfSwKKwkJeyAweDAxLCAweDAyMDAgfSwKKwkJeyAweDAwLCAweDU1NTQgfSwKKwkJeyAweDA0LCAweDQ4MDAgfSwKKwkJeyAweDA0LCAweDQwMDAgfSwKKwkJeyAweDA0LCAweGYwMDAgfSwKKwkJeyAweDAzLCAweGRmMDEgfSwKKwkJeyAweDAyLCAweGRmMjAgfSwKKwkJeyAweDAxLCAweDEwMWEgfSwKKwkJeyAweDAwLCAweGEwZmYgfSwKKwkJeyAweDA0LCAweGY4MDAgfSwKKwkJeyAweDA0LCAweGYwMDAgfSwKKwkJeyAweDFmLCAweDAwMDAgfSwKKworCQl7IDB4MWYsIDB4MDAwNyB9LAorCQl7IDB4MWUsIDB4MDAyMyB9LAorCQl7IDB4MTYsIDB4MDAwMCB9LAorCQl7IDB4MWYsIDB4MDAwMCB9CisJfTsKKworCXJ0bF9waHlfd3JpdGUoaW9hZGRyLCBwaHlfcmVnX2luaXQsIEFSUkFZX1NJWkUocGh5X3JlZ19pbml0KSk7CiB9CiAKIHN0YXRpYyB2b2lkIHJ0bDgxMDJlX2h3X3BoeV9jb25maWcodm9pZCBfX2lvbWVtICppb2FkZHIpCkBAIC0xNzkyLDcgKzI2NjEsMTMgQEAKIAkJcnRsODE2OGNwXzJfaHdfcGh5X2NvbmZpZyhpb2FkZHIpOwogCQlicmVhazsKIAljYXNlIFJUTF9HSUdBX01BQ19WRVJfMjU6Ci0JCXJ0bDgxNjhkX2h3X3BoeV9jb25maWcoaW9hZGRyKTsKKwkJcnRsODE2OGRfMV9od19waHlfY29uZmlnKGlvYWRkcik7CisJCWJyZWFrOworCWNhc2UgUlRMX0dJR0FfTUFDX1ZFUl8yNjoKKwkJcnRsODE2OGRfMl9od19waHlfY29uZmlnKGlvYWRkcik7CisJCWJyZWFrOworCWNhc2UgUlRMX0dJR0FfTUFDX1ZFUl8yNzoKKwkJcnRsODE2OGRfM19od19waHlfY29uZmlnKGlvYWRkcik7CiAJCWJyZWFrOwogCiAJZGVmYXVsdDoKQEAgLTI4NjMsNiArMzczOCw4IEBACiAJYnJlYWs7CiAKIAljYXNlIFJUTF9HSUdBX01BQ19WRVJfMjU6CisJY2FzZSBSVExfR0lHQV9NQUNfVkVSXzI2OgorCWNhc2UgUlRMX0dJR0FfTUFDX1ZFUl8yNzoKIAkJcnRsX2h3X3N0YXJ0XzgxNjhkKGlvYWRkciwgcGRldik7CiAJYnJlYWs7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NiMTAwMC5jIGIvZHJpdmVycy9uZXQvc2IxMDAwLmMKaW5kZXggZWUzNjZjNS4uYzljNzBhYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2IxMDAwLmMKKysrIGIvZHJpdmVycy9uZXQvc2IxMDAwLmMKQEAgLTM2LDYgKzM2LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NpczkwMC5jIGIvZHJpdmVycy9uZXQvc2lzOTAwLmMKaW5kZXggOTc5NDlkMC4uYzA3MmY3ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2lzOTAwLmMKKysrIGIvZHJpdmVycy9uZXQvc2lzOTAwLmMKQEAgLTUyLDYgKzUyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc2tmcC9za2ZkZGkuYyBiL2RyaXZlcnMvbmV0L3NrZnAvc2tmZGRpLmMKaW5kZXggMzhhNTA4Yi4uYjI3MTU2ZWFmIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9za2ZwL3NrZmRkaS5jCisrKyBiL2RyaXZlcnMvbmV0L3NrZnAvc2tmZGRpLmMKQEAgLTczLDYgKzczLDcgQEAKIAogLyogSW5jbHVkZSBmaWxlcyAqLwogCisjaW5jbHVkZSA8bGludXgvY2FwYWJpbGl0eS5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9za2dlLmMgYi9kcml2ZXJzL25ldC9za2dlLmMKaW5kZXggMDFmNjgxMS4uOGY1NDE0MyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvc2tnZS5jCisrKyBiL2RyaXZlcnMvbmV0L3NrZ2UuYwpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2NyYzMyLmg+CiAjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9kZWJ1Z2ZzLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L21paS5oPgogI2luY2x1ZGUgPGFzbS9pcnEuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3NsaXAuYyBiL2RyaXZlcnMvbmV0L3NsaXAuYwppbmRleCBlMTdjNTM1Li5mZTNjZWJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zbGlwLmMKKysrIGIvZHJpdmVycy9uZXQvc2xpcC5jCkBAIC02Nyw2ICs2Nyw3IEBACiAjaW5jbHVkZSA8YXNtL3N5c3RlbS5oPgogI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CiAjaW5jbHVkZSA8bGludXgvYml0b3BzLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL0tjb25maWcgYi9kcml2ZXJzL25ldC9zdG1tYWMvS2NvbmZpZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zNWVhYTUyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvc3RtbWFjL0tjb25maWcKQEAgLTAsMCArMSw1MyBAQAorY29uZmlnIFNUTU1BQ19FVEgKKwl0cmlzdGF0ZSAiU1RNaWNyb2VsZWN0cm9uaWNzIDEwLzEwMC8xMDAwIEV0aGVybmV0IGRyaXZlciIKKwlzZWxlY3QgTUlJCisJc2VsZWN0IFBIWUxJQgorCWRlcGVuZHMgb24gTkVUREVWSUNFUyAmJiBDUFVfU1VCVFlQRV9TVDQwCisJaGVscAorCSAgVGhpcyBpcyB0aGUgZHJpdmVyIGZvciB0aGUgU1QgTUFDIDEwLzEwMC8xMDAwIG9uLWNoaXAgRXRoZXJuZXQKKwkgIGNvbnRyb2xsZXJzLiBTVCBFdGhlcm5ldCBJUHMgYXJlIGJ1aWx0IGFyb3VuZCBhIFN5bm9wc3lzIElQIENvcmUuCisKK2lmIFNUTU1BQ19FVEgKKworY29uZmlnIFNUTU1BQ19EQQorCWJvb2wgIlNUTU1BQyBETUEgYXJiaXRyYXRpb24gc2NoZW1lIgorCWRlZmF1bHQgbgorCWhlbHAKKwkgIFNlbGVjdGluZyB0aGlzIG9wdGlvbiwgcnggaGFzIHByaW9yaXR5IG92ZXIgVHggKG9ubHkgZm9yIEdpZ2EKKwkgIEV0aGVybmV0IGRldmljZSkuCisJICBCeSBkZWZhdWx0LCB0aGUgRE1BIGFyYml0cmF0aW9uIHNjaGVtZSBpcyBiYXNlZCBvbiBSb3VuZC1yb2JpbgorCSAgKHJ4OnR4IHByaW9yaXR5IGlzIDE6MSkuCisKK2NvbmZpZyBTVE1NQUNfRFVBTF9NQUMKKwlib29sICJTVE1NQUM6IGR1YWwgbWFjIHN1cHBvcnQgKEVYUEVSSU1FTlRBTCkiCisJZGVmYXVsdCBuCisgICAgICAgIGRlcGVuZHMgb24gRVhQRVJJTUVOVEFMICYmIFNUTU1BQ19FVEggJiYgIVNUTU1BQ19USU1FUgorCWhlbHAKKwkgIFNvbWUgU1QgU29DcyAoZm9yIGV4YW1wbGUgdGhlIHN0eDcxNDEgYW5kIHN0eDcyMDBjMikgaGF2ZSB0d28KKwkgIEV0aGVybmV0IENvbnRyb2xsZXJzLiBUaGlzIG9wdGlvbiB0dXJucyBvbiB0aGUgc2Vjb25kIEV0aGVybmV0CisJICBkZXZpY2Ugb24gdGhpcyBraW5kIG9mIHBsYXRmb3Jtcy4KKworY29uZmlnIFNUTU1BQ19USU1FUgorCWJvb2wgIlNUTU1BQyBUaW1lciBvcHRpbWlzYXRpb24iCisJZGVmYXVsdCBuCisJaGVscAorCSAgVXNlIGFuIGV4dGVybmFsIHRpbWVyIGZvciBtaXRpZ2F0aW5nIHRoZSBudW1iZXIgb2YgbmV0d29yaworCSAgaW50ZXJydXB0cy4KKworY2hvaWNlCisgICAgICAgIHByb21wdCAiU2VsZWN0IFRpbWVyIGRldmljZSIKKyAgICAgICAgZGVwZW5kcyBvbiBTVE1NQUNfVElNRVIKKworY29uZmlnIFNUTU1BQ19UTVVfVElNRVIKKyAgICAgICAgYm9vbCAiVE1VIGNoYW5uZWwgMiIKKyAgICAgICAgZGVwZW5kcyBvbiBDUFVfU0g0CisJaGVscAorCitjb25maWcgU1RNTUFDX1JUQ19USU1FUgorICAgICAgICBib29sICJSZWFsIHRpbWUgY2xvY2siCisgICAgICAgIGRlcGVuZHMgb24gUlRDX0NMQVNTCisJaGVscAorCitlbmRjaG9pY2UKKworZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3N0bW1hYy9NYWtlZmlsZSBiL2RyaXZlcnMvbmV0L3N0bW1hYy9NYWtlZmlsZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iMmQ3YTU1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvc3RtbWFjL01ha2VmaWxlCkBAIC0wLDAgKzEsNCBAQAorb2JqLSQoQ09ORklHX1NUTU1BQ19FVEgpICs9IHN0bW1hYy5vCitzdG1tYWMtJChDT05GSUdfU1RNTUFDX1RJTUVSKSArPSBzdG1tYWNfdGltZXIubworc3RtbWFjLW9ianM6PSBzdG1tYWNfbWFpbi5vIHN0bW1hY19ldGh0b29sLm8gc3RtbWFjX21kaW8ubyBcCisJCW1hYzEwMC5vICBnbWFjLm8gJChzdG1tYWMteSkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3N0bW1hYy9jb21tb24uaCBiL2RyaXZlcnMvbmV0L3N0bW1hYy9jb21tb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNDllNTE4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvc3RtbWFjL2NvbW1vbi5oCkBAIC0wLDAgKzEsMzMwIEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICBTVE1NQUMgQ29tbW9uIEhlYWRlciBGaWxlCisKKyAgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIFNUTWljcm9lbGVjdHJvbmljcyBMdGQKKworICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLAorICB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKKyAgbW9yZSBkZXRhaWxzLgorCisgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nIHdpdGgKKyAgdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgIDUxIEZyYW5rbGluIFN0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisKKyAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAgdGhlIGZpbGUgY2FsbGVkICJDT1BZSU5HIi4KKworICBBdXRob3I6IEdpdXNlcHBlIENhdmFsbGFybyA8cGVwcGUuY2F2YWxsYXJvQHN0LmNvbT4KKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlICJkZXNjcy5oIgorI2luY2x1ZGUgPGxpbnV4L2lvLmg+CisKKy8qICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICAgRE1BIENSUyBDb250cm9sIGFuZCBTdGF0dXMgUmVnaXN0ZXIgTWFwcGluZworICogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworI2RlZmluZSBETUFfQlVTX01PREUJCTB4MDAwMDEwMDAJLyogQnVzIE1vZGUgKi8KKyNkZWZpbmUgRE1BX1hNVF9QT0xMX0RFTUFORAkweDAwMDAxMDA0CS8qIFRyYW5zbWl0IFBvbGwgRGVtYW5kICovCisjZGVmaW5lIERNQV9SQ1ZfUE9MTF9ERU1BTkQJMHgwMDAwMTAwOAkvKiBSZWNlaXZlZCBQb2xsIERlbWFuZCAqLworI2RlZmluZSBETUFfUkNWX0JBU0VfQUREUgkweDAwMDAxMDBjCS8qIFJlY2VpdmUgTGlzdCBCYXNlICovCisjZGVmaW5lIERNQV9UWF9CQVNFX0FERFIJMHgwMDAwMTAxMAkvKiBUcmFuc21pdCBMaXN0IEJhc2UgKi8KKyNkZWZpbmUgRE1BX1NUQVRVUwkJMHgwMDAwMTAxNAkvKiBTdGF0dXMgUmVnaXN0ZXIgKi8KKyNkZWZpbmUgRE1BX0NPTlRST0wJCTB4MDAwMDEwMTgJLyogQ3RybCAoT3BlcmF0aW9uYWwgTW9kZSkgKi8KKyNkZWZpbmUgRE1BX0lOVFJfRU5BCQkweDAwMDAxMDFjCS8qIEludGVycnVwdCBFbmFibGUgKi8KKyNkZWZpbmUgRE1BX01JU1NFRF9GUkFNRV9DVFIJMHgwMDAwMTAyMAkvKiBNaXNzZWQgRnJhbWUgQ291bnRlciAqLworI2RlZmluZSBETUFfQ1VSX1RYX0JVRl9BRERSCTB4MDAwMDEwNTAJLyogQ3VycmVudCBIb3N0IFR4IEJ1ZmZlciAqLworI2RlZmluZSBETUFfQ1VSX1JYX0JVRl9BRERSCTB4MDAwMDEwNTQJLyogQ3VycmVudCBIb3N0IFJ4IEJ1ZmZlciAqLworCisvKiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICAgRE1BIENvbnRyb2wgcmVnaXN0ZXIgZGVmaW5lcworICogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisjZGVmaW5lIERNQV9DT05UUk9MX1NUCQkweDAwMDAyMDAwCS8qIFN0YXJ0L1N0b3AgVHJhbnNtaXNzaW9uICovCisjZGVmaW5lIERNQV9DT05UUk9MX1NSCQkweDAwMDAwMDAyCS8qIFN0YXJ0L1N0b3AgUmVjZWl2ZSAqLworCisvKiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICAgRE1BIEludGVycnVwdCBFbmFibGUgcmVnaXN0ZXIgZGVmaW5lcworICogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisvKioqKiBOT1JNQUwgSU5URVJSVVBUICoqKiovCisjZGVmaW5lIERNQV9JTlRSX0VOQV9OSUUgMHgwMDAxMDAwMAkvKiBOb3JtYWwgU3VtbWFyeSAqLworI2RlZmluZSBETUFfSU5UUl9FTkFfVElFIDB4MDAwMDAwMDEJLyogVHJhbnNtaXQgSW50ZXJydXB0ICovCisjZGVmaW5lIERNQV9JTlRSX0VOQV9UVUUgMHgwMDAwMDAwNAkvKiBUcmFuc21pdCBCdWZmZXIgVW5hdmFpbGFibGUgKi8KKyNkZWZpbmUgRE1BX0lOVFJfRU5BX1JJRSAweDAwMDAwMDQwCS8qIFJlY2VpdmUgSW50ZXJydXB0ICovCisjZGVmaW5lIERNQV9JTlRSX0VOQV9FUkUgMHgwMDAwNDAwMAkvKiBFYXJseSBSZWNlaXZlICovCisKKyNkZWZpbmUgRE1BX0lOVFJfTk9STUFMCShETUFfSU5UUl9FTkFfTklFIHwgRE1BX0lOVFJfRU5BX1JJRSB8IFwKKwkJCURNQV9JTlRSX0VOQV9USUUpCisKKy8qKioqIEFCTk9STUFMIElOVEVSUlVQVCAqKioqLworI2RlZmluZSBETUFfSU5UUl9FTkFfQUlFIDB4MDAwMDgwMDAJLyogQWJub3JtYWwgU3VtbWFyeSAqLworI2RlZmluZSBETUFfSU5UUl9FTkFfRkJFIDB4MDAwMDIwMDAJLyogRmF0YWwgQnVzIEVycm9yICovCisjZGVmaW5lIERNQV9JTlRSX0VOQV9FVEUgMHgwMDAwMDQwMAkvKiBFYXJseSBUcmFuc21pdCAqLworI2RlZmluZSBETUFfSU5UUl9FTkFfUldFIDB4MDAwMDAyMDAJLyogUmVjZWl2ZSBXYXRjaGRvZyAqLworI2RlZmluZSBETUFfSU5UUl9FTkFfUlNFIDB4MDAwMDAxMDAJLyogUmVjZWl2ZSBTdG9wcGVkICovCisjZGVmaW5lIERNQV9JTlRSX0VOQV9SVUUgMHgwMDAwMDA4MAkvKiBSZWNlaXZlIEJ1ZmZlciBVbmF2YWlsYWJsZSAqLworI2RlZmluZSBETUFfSU5UUl9FTkFfVU5FIDB4MDAwMDAwMjAJLyogVHggVW5kZXJmbG93ICovCisjZGVmaW5lIERNQV9JTlRSX0VOQV9PVkUgMHgwMDAwMDAxMAkvKiBSZWNlaXZlIE92ZXJmbG93ICovCisjZGVmaW5lIERNQV9JTlRSX0VOQV9USkUgMHgwMDAwMDAwOAkvKiBUcmFuc21pdCBKYWJiZXIgKi8KKyNkZWZpbmUgRE1BX0lOVFJfRU5BX1RTRSAweDAwMDAwMDAyCS8qIFRyYW5zbWl0IFN0b3BwZWQgKi8KKworI2RlZmluZSBETUFfSU5UUl9BQk5PUk1BTAkoRE1BX0lOVFJfRU5BX0FJRSB8IERNQV9JTlRSX0VOQV9GQkUgfCBcCisJCQkJRE1BX0lOVFJfRU5BX1VORSkKKworLyogRE1BIGRlZmF1bHQgaW50ZXJydXB0IG1hc2sgKi8KKyNkZWZpbmUgRE1BX0lOVFJfREVGQVVMVF9NQVNLCShETUFfSU5UUl9OT1JNQUwgfCBETUFfSU5UUl9BQk5PUk1BTCkKKworLyogKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogIERNQSBTdGF0dXMgcmVnaXN0ZXIgZGVmaW5lcworICogKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKyNkZWZpbmUgRE1BX1NUQVRVU19HUEkJCTB4MTAwMDAwMDAJLyogUE1UIGludGVycnVwdCAqLworI2RlZmluZSBETUFfU1RBVFVTX0dNSQkJMHgwODAwMDAwMAkvKiBNTUMgaW50ZXJydXB0ICovCisjZGVmaW5lIERNQV9TVEFUVVNfR0xJCQkweDA0MDAwMDAwCS8qIEdNQUMgTGluZSBpbnRlcmZhY2UgaW50LiAqLworI2RlZmluZSBETUFfU1RBVFVTX0dNSQkJMHgwODAwMDAwMAorI2RlZmluZSBETUFfU1RBVFVTX0dMSQkJMHgwNDAwMDAwMAorI2RlZmluZSBETUFfU1RBVFVTX0VCX01BU0sJMHgwMDM4MDAwMAkvKiBFcnJvciBCaXRzIE1hc2sgKi8KKyNkZWZpbmUgRE1BX1NUQVRVU19FQl9UWF9BQk9SVAkweDAwMDgwMDAwCS8qIEVycm9yIEJpdHMgLSBUWCBBYm9ydCAqLworI2RlZmluZSBETUFfU1RBVFVTX0VCX1JYX0FCT1JUCTB4MDAxMDAwMDAJLyogRXJyb3IgQml0cyAtIFJYIEFib3J0ICovCisjZGVmaW5lIERNQV9TVEFUVVNfVFNfTUFTSwkweDAwNzAwMDAwCS8qIFRyYW5zbWl0IFByb2Nlc3MgU3RhdGUgKi8KKyNkZWZpbmUgRE1BX1NUQVRVU19UU19TSElGVAkyMAorI2RlZmluZSBETUFfU1RBVFVTX1JTX01BU0sJMHgwMDBlMDAwMAkvKiBSZWNlaXZlIFByb2Nlc3MgU3RhdGUgKi8KKyNkZWZpbmUgRE1BX1NUQVRVU19SU19TSElGVAkxNworI2RlZmluZSBETUFfU1RBVFVTX05JUwkweDAwMDEwMDAwCS8qIE5vcm1hbCBJbnRlcnJ1cHQgU3VtbWFyeSAqLworI2RlZmluZSBETUFfU1RBVFVTX0FJUwkweDAwMDA4MDAwCS8qIEFibm9ybWFsIEludGVycnVwdCBTdW1tYXJ5ICovCisjZGVmaW5lIERNQV9TVEFUVVNfRVJJCTB4MDAwMDQwMDAJLyogRWFybHkgUmVjZWl2ZSBJbnRlcnJ1cHQgKi8KKyNkZWZpbmUgRE1BX1NUQVRVU19GQkkJMHgwMDAwMjAwMAkvKiBGYXRhbCBCdXMgRXJyb3IgSW50ZXJydXB0ICovCisjZGVmaW5lIERNQV9TVEFUVVNfRVRJCTB4MDAwMDA0MDAJLyogRWFybHkgVHJhbnNtaXQgSW50ZXJydXB0ICovCisjZGVmaW5lIERNQV9TVEFUVVNfUldUCTB4MDAwMDAyMDAJLyogUmVjZWl2ZSBXYXRjaGRvZyBUaW1lb3V0ICovCisjZGVmaW5lIERNQV9TVEFUVVNfUlBTCTB4MDAwMDAxMDAJLyogUmVjZWl2ZSBQcm9jZXNzIFN0b3BwZWQgKi8KKyNkZWZpbmUgRE1BX1NUQVRVU19SVQkweDAwMDAwMDgwCS8qIFJlY2VpdmUgQnVmZmVyIFVuYXZhaWxhYmxlICovCisjZGVmaW5lIERNQV9TVEFUVVNfUkkJMHgwMDAwMDA0MAkvKiBSZWNlaXZlIEludGVycnVwdCAqLworI2RlZmluZSBETUFfU1RBVFVTX1VORgkweDAwMDAwMDIwCS8qIFRyYW5zbWl0IFVuZGVyZmxvdyAqLworI2RlZmluZSBETUFfU1RBVFVTX09WRgkweDAwMDAwMDEwCS8qIFJlY2VpdmUgT3ZlcmZsb3cgKi8KKyNkZWZpbmUgRE1BX1NUQVRVU19USlQJMHgwMDAwMDAwOAkvKiBUcmFuc21pdCBKYWJiZXIgVGltZW91dCAqLworI2RlZmluZSBETUFfU1RBVFVTX1RVCTB4MDAwMDAwMDQJLyogVHJhbnNtaXQgQnVmZmVyIFVuYXZhaWxhYmxlICovCisjZGVmaW5lIERNQV9TVEFUVVNfVFBTCTB4MDAwMDAwMDIJLyogVHJhbnNtaXQgUHJvY2VzcyBTdG9wcGVkICovCisjZGVmaW5lIERNQV9TVEFUVVNfVEkJMHgwMDAwMDAwMQkvKiBUcmFuc21pdCBJbnRlcnJ1cHQgKi8KKworLyogT3RoZXIgZGVmaW5lcyAqLworI2RlZmluZSBIQVNIX1RBQkxFX1NJWkUgNjQKKyNkZWZpbmUgUEFVU0VfVElNRSAweDIwMAorCisvKiBGbG93IENvbnRyb2wgZGVmaW5lcyAqLworI2RlZmluZSBGTE9XX09GRgkwCisjZGVmaW5lIEZMT1dfUlgJCTEKKyNkZWZpbmUgRkxPV19UWAkJMgorI2RlZmluZSBGTE9XX0FVVE8JKEZMT1dfVFggfCBGTE9XX1JYKQorCisvKiBETUEgU1RPUkUtQU5ELUZPUldBUkQgT3BlcmF0aW9uIE1vZGUgKi8KKyNkZWZpbmUgU0ZfRE1BX01PREUgMQorCisjZGVmaW5lIEhXX0NTVU0gMQorI2RlZmluZSBOT19IV19DU1VNIDAKKworLyogR01BQyBUWCBGSUZPIGlzIDhLLCBSeCBGSUZPIGlzIDE2SyAqLworI2RlZmluZSBCVUZfU0laRV8xNktpQiAxNjM4NAorI2RlZmluZSBCVUZfU0laRV84S2lCIDgxOTIKKyNkZWZpbmUgQlVGX1NJWkVfNEtpQiA0MDk2CisjZGVmaW5lIEJVRl9TSVpFXzJLaUIgMjA0OAorCisvKiBQb3dlciBEb3duIGFuZCBXT0wgKi8KKyNkZWZpbmUgUE1UX05PVF9TVVBQT1JURUQgMAorI2RlZmluZSBQTVRfU1VQUE9SVEVEIDEKKworLyogQ29tbW9uIE1BQyBkZWZpbmVzICovCisjZGVmaW5lIE1BQ19DVFJMX1JFRwkJMHgwMDAwMDAwMAkvKiBNQUMgQ29udHJvbCAqLworI2RlZmluZSBNQUNfRU5BQkxFX1RYCQkweDAwMDAwMDA4CS8qIFRyYW5zbWl0dGVyIEVuYWJsZSAqLworI2RlZmluZSBNQUNfUk5BQkxFX1JYCQkweDAwMDAwMDA0CS8qIFJlY2VpdmVyIEVuYWJsZSAqLworCisvKiBNQUMgTWFuYWdlbWVudCBDb3VudGVycyByZWdpc3RlciAqLworI2RlZmluZSBNTUNfQ09OVFJPTAkJMHgwMDAwMDEwMAkvKiBNTUMgQ29udHJvbCAqLworI2RlZmluZSBNTUNfSElHSF9JTlRSCQkweDAwMDAwMTA0CS8qIE1NQyBIaWdoIEludGVycnVwdCAqLworI2RlZmluZSBNTUNfTE9XX0lOVFIJCTB4MDAwMDAxMDgJLyogTU1DIExvdyBJbnRlcnJ1cHQgKi8KKyNkZWZpbmUgTU1DX0hJR0hfSU5UUl9NQVNLCTB4MDAwMDAxMGMJLyogTU1DIEhpZ2ggSW50ZXJydXB0IE1hc2sgKi8KKyNkZWZpbmUgTU1DX0xPV19JTlRSX01BU0sJMHgwMDAwMDExMAkvKiBNTUMgTG93IEludGVycnVwdCBNYXNrICovCisKKyNkZWZpbmUgTU1DX0NPTlRST0xfTUFYX0ZSTV9NQVNLCTB4MDAwM2ZmOAkvKiBNYXhpbXVtIEZyYW1lIFNpemUgKi8KKyNkZWZpbmUgTU1DX0NPTlRST0xfTUFYX0ZSTV9TSElGVAkzCisjZGVmaW5lIE1NQ19DT05UUk9MX01BWF9GUkFNRQkJMHg3RkYKKworc3RydWN0IHN0bW1hY19leHRyYV9zdGF0cyB7CisJLyogVHJhbnNtaXQgZXJyb3JzICovCisJdW5zaWduZWQgbG9uZyB0eF91bmRlcmZsb3cgX19fX2NhY2hlbGluZV9hbGlnbmVkOworCXVuc2lnbmVkIGxvbmcgdHhfY2FycmllcjsKKwl1bnNpZ25lZCBsb25nIHR4X2xvc3NjYXJyaWVyOworCXVuc2lnbmVkIGxvbmcgdHhfaGVhcnRiZWF0OworCXVuc2lnbmVkIGxvbmcgdHhfZGVmZXJyZWQ7CisJdW5zaWduZWQgbG9uZyB0eF92bGFuOworCXVuc2lnbmVkIGxvbmcgdHhfamFiYmVyOworCXVuc2lnbmVkIGxvbmcgdHhfZnJhbWVfZmx1c2hlZDsKKwl1bnNpZ25lZCBsb25nIHR4X3BheWxvYWRfZXJyb3I7CisJdW5zaWduZWQgbG9uZyB0eF9pcF9oZWFkZXJfZXJyb3I7CisJLyogUmVjZWl2ZSBlcnJvcnMgKi8KKwl1bnNpZ25lZCBsb25nIHJ4X2Rlc2M7CisJdW5zaWduZWQgbG9uZyByeF9wYXJ0aWFsOworCXVuc2lnbmVkIGxvbmcgcnhfcnVudDsKKwl1bnNpZ25lZCBsb25nIHJ4X3Rvb2xvbmc7CisJdW5zaWduZWQgbG9uZyByeF9jb2xsaXNpb247CisJdW5zaWduZWQgbG9uZyByeF9jcmM7CisJdW5zaWduZWQgbG9uZyByeF9sZW5naHQ7CisJdW5zaWduZWQgbG9uZyByeF9taWk7CisJdW5zaWduZWQgbG9uZyByeF9tdWx0aWNhc3Q7CisJdW5zaWduZWQgbG9uZyByeF9nbWFjX292ZXJmbG93OworCXVuc2lnbmVkIGxvbmcgcnhfd2F0Y2hkb2c7CisJdW5zaWduZWQgbG9uZyBkYV9yeF9maWx0ZXJfZmFpbDsKKwl1bnNpZ25lZCBsb25nIHNhX3J4X2ZpbHRlcl9mYWlsOworCXVuc2lnbmVkIGxvbmcgcnhfbWlzc2VkX2NudHI7CisJdW5zaWduZWQgbG9uZyByeF9vdmVyZmxvd19jbnRyOworCXVuc2lnbmVkIGxvbmcgcnhfdmxhbjsKKwkvKiBUeC9SeCBJUlEgZXJyb3JzICovCisJdW5zaWduZWQgbG9uZyB0eF91bmRlZmxvd19pcnE7CisJdW5zaWduZWQgbG9uZyB0eF9wcm9jZXNzX3N0b3BwZWRfaXJxOworCXVuc2lnbmVkIGxvbmcgdHhfamFiYmVyX2lycTsKKwl1bnNpZ25lZCBsb25nIHJ4X292ZXJmbG93X2lycTsKKwl1bnNpZ25lZCBsb25nIHJ4X2J1Zl91bmF2X2lycTsKKwl1bnNpZ25lZCBsb25nIHJ4X3Byb2Nlc3Nfc3RvcHBlZF9pcnE7CisJdW5zaWduZWQgbG9uZyByeF93YXRjaGRvZ19pcnE7CisJdW5zaWduZWQgbG9uZyB0eF9lYXJseV9pcnE7CisJdW5zaWduZWQgbG9uZyBmYXRhbF9idXNfZXJyb3JfaXJxOworCS8qIEV4dHJhIGluZm8gKi8KKwl1bnNpZ25lZCBsb25nIHRocmVzaG9sZDsKKwl1bnNpZ25lZCBsb25nIHR4X3BrdF9uOworCXVuc2lnbmVkIGxvbmcgcnhfcGt0X247CisJdW5zaWduZWQgbG9uZyBwb2xsX247CisJdW5zaWduZWQgbG9uZyBzY2hlZF90aW1lcl9uOworCXVuc2lnbmVkIGxvbmcgbm9ybWFsX2lycV9uOworfTsKKworLyogR01BQyBjb3JlIGNhbiBjb21wdXRlIHRoZSBjaGVja3N1bXMgaW4gSFcuICovCitlbnVtIHJ4X2ZyYW1lX3N0YXR1cyB7CisJZ29vZF9mcmFtZSA9IDAsCisJZGlzY2FyZF9mcmFtZSA9IDEsCisJY3N1bV9ub25lID0gMiwKK307CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBzdG1tYWNfc2V0X21hY19hZGRyKHVuc2lnbmVkIGxvbmcgaW9hZGRyLCB1OCBhZGRyWzZdLAorCQkJIHVuc2lnbmVkIGludCBoaWdoLCB1bnNpZ25lZCBpbnQgbG93KQoreworCXVuc2lnbmVkIGxvbmcgZGF0YTsKKworCWRhdGEgPSAoYWRkcls1XSA8PCA4KSB8IGFkZHJbNF07CisJd3JpdGVsKGRhdGEsIGlvYWRkciArIGhpZ2gpOworCWRhdGEgPSAoYWRkclszXSA8PCAyNCkgfCAoYWRkclsyXSA8PCAxNikgfCAoYWRkclsxXSA8PCA4KSB8IGFkZHJbMF07CisJd3JpdGVsKGRhdGEsIGlvYWRkciArIGxvdyk7CisKKwlyZXR1cm47Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBzdG1tYWNfZ2V0X21hY19hZGRyKHVuc2lnbmVkIGxvbmcgaW9hZGRyLAorCQkJCXVuc2lnbmVkIGNoYXIgKmFkZHIsIHVuc2lnbmVkIGludCBoaWdoLAorCQkJCXVuc2lnbmVkIGludCBsb3cpCit7CisJdW5zaWduZWQgaW50IGhpX2FkZHIsIGxvX2FkZHI7CisKKwkvKiBSZWFkIHRoZSBNQUMgYWRkcmVzcyBmcm9tIHRoZSBoYXJkd2FyZSAqLworCWhpX2FkZHIgPSByZWFkbChpb2FkZHIgKyBoaWdoKTsKKwlsb19hZGRyID0gcmVhZGwoaW9hZGRyICsgbG93KTsKKworCS8qIEV4dHJhY3QgdGhlIE1BQyBhZGRyZXNzIGZyb20gdGhlIGhpZ2ggYW5kIGxvdyB3b3JkcyAqLworCWFkZHJbMF0gPSBsb19hZGRyICYgMHhmZjsKKwlhZGRyWzFdID0gKGxvX2FkZHIgPj4gOCkgJiAweGZmOworCWFkZHJbMl0gPSAobG9fYWRkciA+PiAxNikgJiAweGZmOworCWFkZHJbM10gPSAobG9fYWRkciA+PiAyNCkgJiAweGZmOworCWFkZHJbNF0gPSBoaV9hZGRyICYgMHhmZjsKKwlhZGRyWzVdID0gKGhpX2FkZHIgPj4gOCkgJiAweGZmOworCisJcmV0dXJuOworfQorCitzdHJ1Y3Qgc3RtbWFjX29wcyB7CisJLyogTUFDIGNvcmUgaW5pdGlhbGl6YXRpb24gKi8KKwl2b2lkICgqY29yZV9pbml0KSAodW5zaWduZWQgbG9uZyBpb2FkZHIpIF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKwkvKiBETUEgY29yZSBpbml0aWFsaXphdGlvbiAqLworCWludCAoKmRtYV9pbml0KSAodW5zaWduZWQgbG9uZyBpb2FkZHIsIGludCBwYmwsIHUzMiBkbWFfdHgsIHUzMiBkbWFfcngpOworCS8qIER1bXAgTUFDIHJlZ2lzdGVycyAqLworCXZvaWQgKCpkdW1wX21hY19yZWdzKSAodW5zaWduZWQgbG9uZyBpb2FkZHIpOworCS8qIER1bXAgRE1BIHJlZ2lzdGVycyAqLworCXZvaWQgKCpkdW1wX2RtYV9yZWdzKSAodW5zaWduZWQgbG9uZyBpb2FkZHIpOworCS8qIFNldCB0eC9yeCB0aHJlc2hvbGQgaW4gdGhlIGNzcjYgcmVnaXN0ZXIKKwkgKiBBbiBpbnZhbGlkIHZhbHVlIGVuYWJsZXMgdGhlIHN0b3JlLWFuZC1mb3J3YXJkIG1vZGUgKi8KKwl2b2lkICgqZG1hX21vZGUpICh1bnNpZ25lZCBsb25nIGlvYWRkciwgaW50IHR4bW9kZSwgaW50IHJ4bW9kZSk7CisJLyogVG8gdHJhY2sgZXh0cmEgc3RhdGlzdGljIChpZiBzdXBwb3J0ZWQpICovCisJdm9pZCAoKmRtYV9kaWFnbm9zdGljX2ZyKSAodm9pZCAqZGF0YSwgc3RydWN0IHN0bW1hY19leHRyYV9zdGF0cyAqeCwKKwkJCQkgICB1bnNpZ25lZCBsb25nIGlvYWRkcik7CisJLyogUlggZGVzY3JpcHRvciByaW5nIGluaXRpYWxpemF0aW9uICovCisJdm9pZCAoKmluaXRfcnhfZGVzYykgKHN0cnVjdCBkbWFfZGVzYyAqcCwgdW5zaWduZWQgaW50IHJpbmdfc2l6ZSwKKwkJCQlpbnQgZGlzYWJsZV9yeF9pYyk7CisJLyogVFggZGVzY3JpcHRvciByaW5nIGluaXRpYWxpemF0aW9uICovCisJdm9pZCAoKmluaXRfdHhfZGVzYykgKHN0cnVjdCBkbWFfZGVzYyAqcCwgdW5zaWduZWQgaW50IHJpbmdfc2l6ZSk7CisKKwkvKiBJbnZva2VkIGJ5IHRoZSB4bWl0IGZ1bmN0aW9uIHRvIHByZXBhcmUgdGhlIHR4IGRlc2NyaXB0b3IgKi8KKwl2b2lkICgqcHJlcGFyZV90eF9kZXNjKSAoc3RydWN0IGRtYV9kZXNjICpwLCBpbnQgaXNfZnMsIGludCBsZW4sCisJCQkJIGludCBjc3VtX2ZsYWcpOworCS8qIFNldC9nZXQgdGhlIG93bmVyIG9mIHRoZSBkZXNjcmlwdG9yICovCisJdm9pZCAoKnNldF90eF9vd25lcikgKHN0cnVjdCBkbWFfZGVzYyAqcCk7CisJaW50ICgqZ2V0X3R4X293bmVyKSAoc3RydWN0IGRtYV9kZXNjICpwKTsKKwkvKiBJbnZva2VkIGJ5IHRoZSB4bWl0IGZ1bmN0aW9uIHRvIGNsb3NlIHRoZSB0eCBkZXNjcmlwdG9yICovCisJdm9pZCAoKmNsb3NlX3R4X2Rlc2MpIChzdHJ1Y3QgZG1hX2Rlc2MgKnApOworCS8qIENsZWFuIHRoZSB0eCBkZXNjcmlwdG9yIGFzIHNvb24gYXMgdGhlIHR4IGlycSBpcyByZWNlaXZlZCAqLworCXZvaWQgKCpyZWxlYXNlX3R4X2Rlc2MpIChzdHJ1Y3QgZG1hX2Rlc2MgKnApOworCS8qIENsZWFyIGludGVycnVwdCBvbiB0eCBmcmFtZSBjb21wbGV0aW9uLiBXaGVuIHRoaXMgYml0IGlzCisJICogc2V0IGFuIGludGVycnVwdCBoYXBwZW5zIGFzIHNvb24gYXMgdGhlIGZyYW1lIGlzIHRyYW5zbWl0dGVkICovCisJdm9pZCAoKmNsZWFyX3R4X2ljKSAoc3RydWN0IGRtYV9kZXNjICpwKTsKKwkvKiBMYXN0IHR4IHNlZ21lbnQgcmVwb3J0cyB0aGUgdHJhbnNtaXQgc3RhdHVzICovCisJaW50ICgqZ2V0X3R4X2xzKSAoc3RydWN0IGRtYV9kZXNjICpwKTsKKwkvKiBSZXR1cm4gdGhlIHRyYW5zbWl0IHN0YXR1cyBsb29raW5nIGF0IHRoZSBUREVTMSAqLworCWludCAoKnR4X3N0YXR1cykgKHZvaWQgKmRhdGEsIHN0cnVjdCBzdG1tYWNfZXh0cmFfc3RhdHMgKngsCisJCQkgIHN0cnVjdCBkbWFfZGVzYyAqcCwgdW5zaWduZWQgbG9uZyBpb2FkZHIpOworCS8qIEdldCB0aGUgYnVmZmVyIHNpemUgZnJvbSB0aGUgZGVzY3JpcHRvciAqLworCWludCAoKmdldF90eF9sZW4pIChzdHJ1Y3QgZG1hX2Rlc2MgKnApOworCS8qIEhhbmRsZSBleHRyYSBldmVudHMgb24gc3BlY2lmaWMgaW50ZXJydXB0cyBodyBkZXBlbmRlbnQgKi8KKwl2b2lkICgqaG9zdF9pcnFfc3RhdHVzKSAodW5zaWduZWQgbG9uZyBpb2FkZHIpOworCWludCAoKmdldF9yeF9vd25lcikgKHN0cnVjdCBkbWFfZGVzYyAqcCk7CisJdm9pZCAoKnNldF9yeF9vd25lcikgKHN0cnVjdCBkbWFfZGVzYyAqcCk7CisJLyogR2V0IHRoZSByZWNlaXZlIGZyYW1lIHNpemUgKi8KKwlpbnQgKCpnZXRfcnhfZnJhbWVfbGVuKSAoc3RydWN0IGRtYV9kZXNjICpwKTsKKwkvKiBSZXR1cm4gdGhlIHJlY2VwdGlvbiBzdGF0dXMgbG9va2luZyBhdCB0aGUgUkRFUzEgKi8KKwlpbnQgKCpyeF9zdGF0dXMpICh2b2lkICpkYXRhLCBzdHJ1Y3Qgc3RtbWFjX2V4dHJhX3N0YXRzICp4LAorCQkJICBzdHJ1Y3QgZG1hX2Rlc2MgKnApOworCS8qIE11bHRpY2FzdCBmaWx0ZXIgc2V0dGluZyAqLworCXZvaWQgKCpzZXRfZmlsdGVyKSAoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CisJLyogRmxvdyBjb250cm9sIHNldHRpbmcgKi8KKwl2b2lkICgqZmxvd19jdHJsKSAodW5zaWduZWQgbG9uZyBpb2FkZHIsIHVuc2lnbmVkIGludCBkdXBsZXgsCisJCQkgICB1bnNpZ25lZCBpbnQgZmMsIHVuc2lnbmVkIGludCBwYXVzZV90aW1lKTsKKwkvKiBTZXQgcG93ZXIgbWFuYWdlbWVudCBtb2RlIChlLmcuIG1hZ2ljIGZyYW1lKSAqLworCXZvaWQgKCpwbXQpICh1bnNpZ25lZCBsb25nIGlvYWRkciwgdW5zaWduZWQgbG9uZyBtb2RlKTsKKwkvKiBTZXQvR2V0IFVuaWNhc3QgTUFDIGFkZHJlc3NlcyAqLworCXZvaWQgKCpzZXRfdW1hY19hZGRyKSAodW5zaWduZWQgbG9uZyBpb2FkZHIsIHVuc2lnbmVkIGNoYXIgKmFkZHIsCisJCQkgICAgIHVuc2lnbmVkIGludCByZWdfbik7CisJdm9pZCAoKmdldF91bWFjX2FkZHIpICh1bnNpZ25lZCBsb25nIGlvYWRkciwgdW5zaWduZWQgY2hhciAqYWRkciwKKwkJCSAgICAgdW5zaWduZWQgaW50IHJlZ19uKTsKK307CisKK3N0cnVjdCBtYWNfbGluayB7CisJaW50IHBvcnQ7CisJaW50IGR1cGxleDsKKwlpbnQgc3BlZWQ7Cit9OworCitzdHJ1Y3QgbWlpX3JlZ3MgeworCXVuc2lnbmVkIGludCBhZGRyOwkvKiBNSUkgQWRkcmVzcyAqLworCXVuc2lnbmVkIGludCBkYXRhOwkvKiBNSUkgRGF0YSAqLworfTsKKworc3RydWN0IGh3X2NhcCB7CisJdW5zaWduZWQgaW50IHZlcnNpb247CS8qIENvcmUgVmVyc2lvbiByZWdpc3RlciAoR01BQykgKi8KKwl1bnNpZ25lZCBpbnQgcG10OwkvKiBQb3dlci1Eb3duIG1vZGUgKEdNQUMpICovCisJc3RydWN0IG1hY19saW5rIGxpbms7CisJc3RydWN0IG1paV9yZWdzIG1paTsKK307CisKK3N0cnVjdCBtYWNfZGV2aWNlX2luZm8geworCXN0cnVjdCBod19jYXAgaHc7CisJc3RydWN0IHN0bW1hY19vcHMgKm9wczsKK307CisKK3N0cnVjdCBtYWNfZGV2aWNlX2luZm8gKmdtYWNfc2V0dXAodW5zaWduZWQgbG9uZyBhZGRyKTsKK3N0cnVjdCBtYWNfZGV2aWNlX2luZm8gKm1hYzEwMF9zZXR1cCh1bnNpZ25lZCBsb25nIGFkZHIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL2Rlc2NzLmggYi9kcml2ZXJzL25ldC9zdG1tYWMvZGVzY3MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZDJhMGIyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvc3RtbWFjL2Rlc2NzLmgKQEAgLTAsMCArMSwxNjMgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgIEhlYWRlciBGaWxlIHRvIGRlc2NyaWJlIHRoZSBETUEgZGVzY3JpcHRvcnMKKyAgVXNlIGVuaGFuY2VkIGRlc2NyaXB0b3JzIGluIGNhc2Ugb2YgR01BQyBDb3Jlcy4KKworICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLAorICB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKKyAgbW9yZSBkZXRhaWxzLgorCisgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nIHdpdGgKKyAgdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgIDUxIEZyYW5rbGluIFN0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisKKyAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAgdGhlIGZpbGUgY2FsbGVkICJDT1BZSU5HIi4KKworICBBdXRob3I6IEdpdXNlcHBlIENhdmFsbGFybyA8cGVwcGUuY2F2YWxsYXJvQHN0LmNvbT4KKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCitzdHJ1Y3QgZG1hX2Rlc2MgeworCS8qIFJlY2VpdmUgZGVzY3JpcHRvciAqLworCXVuaW9uIHsKKwkJc3RydWN0IHsKKwkJCS8qIFJERVMwICovCisJCQl1MzIgcmVzZXJ2ZWQxOjE7CisJCQl1MzIgY3JjX2Vycm9yOjE7CisJCQl1MzIgZHJpYmJsaW5nOjE7CisJCQl1MzIgbWlpX2Vycm9yOjE7CisJCQl1MzIgcmVjZWl2ZV93YXRjaGRvZzoxOworCQkJdTMyIGZyYW1lX3R5cGU6MTsKKwkJCXUzMiBjb2xsaXNpb246MTsKKwkJCXUzMiBmcmFtZV90b29fbG9uZzoxOworCQkJdTMyIGxhc3RfZGVzY3JpcHRvcjoxOworCQkJdTMyIGZpcnN0X2Rlc2NyaXB0b3I6MTsKKwkJCXUzMiBtdWx0aWNhc3RfZnJhbWU6MTsKKwkJCXUzMiBydW5fZnJhbWU6MTsKKwkJCXUzMiBsZW5ndGhfZXJyb3I6MTsKKwkJCXUzMiBwYXJ0aWFsX2ZyYW1lX2Vycm9yOjE7CisJCQl1MzIgZGVzY3JpcHRvcl9lcnJvcjoxOworCQkJdTMyIGVycm9yX3N1bW1hcnk6MTsKKwkJCXUzMiBmcmFtZV9sZW5ndGg6MTQ7CisJCQl1MzIgZmlsdGVyaW5nX2ZhaWw6MTsKKwkJCXUzMiBvd246MTsKKwkJCS8qIFJERVMxICovCisJCQl1MzIgYnVmZmVyMV9zaXplOjExOworCQkJdTMyIGJ1ZmZlcjJfc2l6ZToxMTsKKwkJCXUzMiByZXNlcnZlZDI6MjsKKwkJCXUzMiBzZWNvbmRfYWRkcmVzc19jaGFpbmVkOjE7CisJCQl1MzIgZW5kX3Jpbmc6MTsKKwkJCXUzMiByZXNlcnZlZDM6NTsKKwkJCXUzMiBkaXNhYmxlX2ljOjE7CisJCX0gcng7CisJCXN0cnVjdCB7CisJCQkvKiBSREVTMCAqLworCQkJdTMyIHBheWxvYWRfY3N1bV9lcnJvcjoxOworCQkJdTMyIGNyY19lcnJvcjoxOworCQkJdTMyIGRyaWJibGluZzoxOworCQkJdTMyIGVycm9yX2dtaWk6MTsKKwkJCXUzMiByZWNlaXZlX3dhdGNoZG9nOjE7CisJCQl1MzIgZnJhbWVfdHlwZToxOworCQkJdTMyIGxhdGVfY29sbGlzaW9uOjE7CisJCQl1MzIgaXBjX2NzdW1fZXJyb3I6MTsKKwkJCXUzMiBsYXN0X2Rlc2NyaXB0b3I6MTsKKwkJCXUzMiBmaXJzdF9kZXNjcmlwdG9yOjE7CisJCQl1MzIgdmxhbl90YWc6MTsKKwkJCXUzMiBvdmVyZmxvd19lcnJvcjoxOworCQkJdTMyIGxlbmd0aF9lcnJvcjoxOworCQkJdTMyIHNhX2ZpbHRlcl9mYWlsOjE7CisJCQl1MzIgZGVzY3JpcHRvcl9lcnJvcjoxOworCQkJdTMyIGVycm9yX3N1bW1hcnk6MTsKKwkJCXUzMiBmcmFtZV9sZW5ndGg6MTQ7CisJCQl1MzIgZGFfZmlsdGVyX2ZhaWw6MTsKKwkJCXUzMiBvd246MTsKKwkJCS8qIFJERVMxICovCisJCQl1MzIgYnVmZmVyMV9zaXplOjEzOworCQkJdTMyIHJlc2VydmVkMToxOworCQkJdTMyIHNlY29uZF9hZGRyZXNzX2NoYWluZWQ6MTsKKwkJCXUzMiBlbmRfcmluZzoxOworCQkJdTMyIGJ1ZmZlcjJfc2l6ZToxMzsKKwkJCXUzMiByZXNlcnZlZDI6MjsKKwkJCXUzMiBkaXNhYmxlX2ljOjE7CisJCX0gZXJ4OwkJLyogLS0gZW5oYW5jZWQgLS0gKi8KKworCQkvKiBUcmFuc21pdCBkZXNjcmlwdG9yICovCisJCXN0cnVjdCB7CisJCQkvKiBUREVTMCAqLworCQkJdTMyIGRlZmVycmVkOjE7CisJCQl1MzIgdW5kZXJmbG93X2Vycm9yOjE7CisJCQl1MzIgZXhjZXNzaXZlX2RlZmVycmFsOjE7CisJCQl1MzIgY29sbGlzaW9uX2NvdW50OjQ7CisJCQl1MzIgaGVhcnRiZWF0X2ZhaWw6MTsKKwkJCXUzMiBleGNlc3NpdmVfY29sbGlzaW9uczoxOworCQkJdTMyIGxhdGVfY29sbGlzaW9uOjE7CisJCQl1MzIgbm9fY2FycmllcjoxOworCQkJdTMyIGxvc3NfY2FycmllcjoxOworCQkJdTMyIHJlc2VydmVkMTozOworCQkJdTMyIGVycm9yX3N1bW1hcnk6MTsKKwkJCXUzMiByZXNlcnZlZDI6MTU7CisJCQl1MzIgb3duOjE7CisJCQkvKiBUREVTMSAqLworCQkJdTMyIGJ1ZmZlcjFfc2l6ZToxMTsKKwkJCXUzMiBidWZmZXIyX3NpemU6MTE7CisJCQl1MzIgcmVzZXJ2ZWQzOjE7CisJCQl1MzIgZGlzYWJsZV9wYWRkaW5nOjE7CisJCQl1MzIgc2Vjb25kX2FkZHJlc3NfY2hhaW5lZDoxOworCQkJdTMyIGVuZF9yaW5nOjE7CisJCQl1MzIgY3JjX2Rpc2FibGU6MTsKKwkJCXUzMiByZXNlcnZlZDQ6MjsKKwkJCXUzMiBmaXJzdF9zZWdtZW50OjE7CisJCQl1MzIgbGFzdF9zZWdtZW50OjE7CisJCQl1MzIgaW50ZXJydXB0OjE7CisJCX0gdHg7CisJCXN0cnVjdCB7CisJCQkvKiBUREVTMCAqLworCQkJdTMyIGRlZmVycmVkOjE7CisJCQl1MzIgdW5kZXJmbG93X2Vycm9yOjE7CisJCQl1MzIgZXhjZXNzaXZlX2RlZmVycmFsOjE7CisJCQl1MzIgY29sbGlzaW9uX2NvdW50OjQ7CisJCQl1MzIgdmxhbl9mcmFtZToxOworCQkJdTMyIGV4Y2Vzc2l2ZV9jb2xsaXNpb25zOjE7CisJCQl1MzIgbGF0ZV9jb2xsaXNpb246MTsKKwkJCXUzMiBub19jYXJyaWVyOjE7CisJCQl1MzIgbG9zc19jYXJyaWVyOjE7CisJCQl1MzIgcGF5bG9hZF9lcnJvcjoxOworCQkJdTMyIGZyYW1lX2ZsdXNoZWQ6MTsKKwkJCXUzMiBqYWJiZXJfdGltZW91dDoxOworCQkJdTMyIGVycm9yX3N1bW1hcnk6MTsKKwkJCXUzMiBpcF9oZWFkZXJfZXJyb3I6MTsKKwkJCXUzMiB0aW1lX3N0YW1wX3N0YXR1czoxOworCQkJdTMyIHJlc2VydmVkMToyOworCQkJdTMyIHNlY29uZF9hZGRyZXNzX2NoYWluZWQ6MTsKKwkJCXUzMiBlbmRfcmluZzoxOworCQkJdTMyIGNoZWNrc3VtX2luc2VydGlvbjoyOworCQkJdTMyIHJlc2VydmVkMjoxOworCQkJdTMyIHRpbWVfc3RhbXBfZW5hYmxlOjE7CisJCQl1MzIgZGlzYWJsZV9wYWRkaW5nOjE7CisJCQl1MzIgY3JjX2Rpc2FibGU6MTsKKwkJCXUzMiBmaXJzdF9zZWdtZW50OjE7CisJCQl1MzIgbGFzdF9zZWdtZW50OjE7CisJCQl1MzIgaW50ZXJydXB0OjE7CisJCQl1MzIgb3duOjE7CisJCQkvKiBUREVTMSAqLworCQkJdTMyIGJ1ZmZlcjFfc2l6ZToxMzsKKwkJCXUzMiByZXNlcnZlZDM6MzsKKwkJCXUzMiBidWZmZXIyX3NpemU6MTM7CisJCQl1MzIgcmVzZXJ2ZWQ0OjM7CisJCX0gZXR4OwkJLyogLS0gZW5oYW5jZWQgLS0gKi8KKwl9IGRlczAxOworCXVuc2lnbmVkIGludCBkZXMyOworCXVuc2lnbmVkIGludCBkZXMzOworfTsKKworLyogVHJhbnNtaXQgY2hlY2tzdW0gaW5zZXJ0aW9uIGNvbnRyb2wgKi8KK2VudW0gdGRlc19jc3VtX2luc2VydGlvbiB7CisJY2ljX2Rpc2FibGVkID0gMCwJLyogQ2hlY2tzdW0gSW5zZXJ0aW9uIENvbnRyb2wgKi8KKwljaWNfb25seV9pcCA9IDEsCS8qIE9ubHkgSVAgaGVhZGVyICovCisJY2ljX25vX3BzZXVkb2hlYWRlciA9IDIsCS8qIElQIGhlYWRlciBidXQgcHNldWRvaGVhZGVyCisJCQkJCSAqIGlzIG5vdCBjYWxjdWxhdGVkICovCisJY2ljX2Z1bGwgPSAzLAkJLyogSVAgaGVhZGVyIGFuZCBwc2V1ZG9oZWFkZXIgKi8KK307CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zdG1tYWMvZ21hYy5jIGIvZHJpdmVycy9uZXQvc3RtbWFjL2dtYWMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iNjI0YmI1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvc3RtbWFjL2dtYWMuYwpAQCAtMCwwICsxLDY5MyBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAgVGhpcyBpcyB0aGUgZHJpdmVyIGZvciB0aGUgR01BQyBvbi1jaGlwIEV0aGVybmV0IGNvbnRyb2xsZXIgZm9yIFNUIFNvQ3MuCisgIERXQyBFdGhlciBNQUMgMTAvMTAwLzEwMDAgVW5pdmVyc2FsIHZlcnNpb24gMy40MWEgIGhhcyBiZWVuIHVzZWQgZm9yCisgIGRldmVsb3BpbmcgdGhpcyBjb2RlLgorCisgIENvcHlyaWdodCAoQykgMjAwNy0yMDA5ICBTVE1pY3JvZWxlY3Ryb25pY3MgTHRkCisKKyAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKworICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCisgIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvcgorICBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yCisgIG1vcmUgZGV0YWlscy4KKworICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZyB3aXRoCisgIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAorICA1MSBGcmFua2xpbiBTdCAtIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBLgorCisgIFRoZSBmdWxsIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluCisgIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisKKyAgQXV0aG9yOiBHaXVzZXBwZSBDYXZhbGxhcm8gPHBlcHBlLmNhdmFsbGFyb0BzdC5jb20+CisqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvY3JjMzIuaD4KKyNpbmNsdWRlIDxsaW51eC9taWkuaD4KKyNpbmNsdWRlIDxsaW51eC9waHkuaD4KKworI2luY2x1ZGUgInN0bW1hYy5oIgorI2luY2x1ZGUgImdtYWMuaCIKKworI3VuZGVmIEdNQUNfREVCVUcKKy8qI2RlZmluZSBHTUFDX0RFQlVHKi8KKyN1bmRlZiBGUkFNRV9GSUxURVJfREVCVUcKKy8qI2RlZmluZSBGUkFNRV9GSUxURVJfREVCVUcqLworI2lmZGVmIEdNQUNfREVCVUcKKyNkZWZpbmUgREJHKGZtdCwgYXJncy4uLikgIHByaW50ayhmbXQsICMjIGFyZ3MpCisjZWxzZQorI2RlZmluZSBEQkcoZm10LCBhcmdzLi4uKSAgZG8geyB9IHdoaWxlICgwKQorI2VuZGlmCisKK3N0YXRpYyB2b2lkIGdtYWNfZHVtcF9yZWdzKHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCWludCBpOworCXByX2luZm8oIlx0LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuIgorCSAgICAgICAiXHQgIEdNQUMgcmVnaXN0ZXJzIChiYXNlIGFkZHIgPSAweCU4eClcbiIKKwkgICAgICAgIlx0LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuIiwKKwkgICAgICAgKHVuc2lnbmVkIGludClpb2FkZHIpOworCisJZm9yIChpID0gMDsgaSA8IDU1OyBpKyspIHsKKwkJaW50IG9mZnNldCA9IGkgKiA0OworCQlwcl9pbmZvKCJcdFJlZyBOby4gJWQgKG9mZnNldCAweCV4KTogMHglMDh4XG4iLCBpLAorCQkgICAgICAgb2Zmc2V0LCByZWFkbChpb2FkZHIgKyBvZmZzZXQpKTsKKwl9CisJcmV0dXJuOworfQorCitzdGF0aWMgaW50IGdtYWNfZG1hX2luaXQodW5zaWduZWQgbG9uZyBpb2FkZHIsIGludCBwYmwsIHUzMiBkbWFfdHgsIHUzMiBkbWFfcngpCit7CisJdTMyIHZhbHVlID0gcmVhZGwoaW9hZGRyICsgRE1BX0JVU19NT0RFKTsKKwkvKiBETUEgU1cgcmVzZXQgKi8KKwl2YWx1ZSB8PSBETUFfQlVTX01PREVfU0ZUX1JFU0VUOworCXdyaXRlbCh2YWx1ZSwgaW9hZGRyICsgRE1BX0JVU19NT0RFKTsKKwlkbyB7fSB3aGlsZSAoKHJlYWRsKGlvYWRkciArIERNQV9CVVNfTU9ERSkgJiBETUFfQlVTX01PREVfU0ZUX1JFU0VUKSk7CisKKwl2YWx1ZSA9IC8qIERNQV9CVVNfTU9ERV9GQiB8ICovIERNQV9CVVNfTU9ERV80UEJMIHwKKwkgICAgKChwYmwgPDwgRE1BX0JVU19NT0RFX1BCTF9TSElGVCkgfAorCSAgICAgKHBibCA8PCBETUFfQlVTX01PREVfUlBCTF9TSElGVCkpOworCisjaWZkZWYgQ09ORklHX1NUTU1BQ19EQQorCXZhbHVlIHw9IERNQV9CVVNfTU9ERV9EQTsJLyogUnggaGFzIHByaW9yaXR5IG92ZXIgdHggKi8KKyNlbmRpZgorCXdyaXRlbCh2YWx1ZSwgaW9hZGRyICsgRE1BX0JVU19NT0RFKTsKKworCS8qIE1hc2sgaW50ZXJydXB0cyBieSB3cml0aW5nIHRvIENTUjcgKi8KKwl3cml0ZWwoRE1BX0lOVFJfREVGQVVMVF9NQVNLLCBpb2FkZHIgKyBETUFfSU5UUl9FTkEpOworCisJLyogVGhlIGJhc2UgYWRkcmVzcyBvZiB0aGUgUlgvVFggZGVzY3JpcHRvciBsaXN0cyBtdXN0IGJlIHdyaXR0ZW4gaW50bworCSAqIERNQSBDU1IzIGFuZCBDU1I0LCByZXNwZWN0aXZlbHkuICovCisJd3JpdGVsKGRtYV90eCwgaW9hZGRyICsgRE1BX1RYX0JBU0VfQUREUik7CisJd3JpdGVsKGRtYV9yeCwgaW9hZGRyICsgRE1BX1JDVl9CQVNFX0FERFIpOworCisJcmV0dXJuIDA7Cit9CisKKy8qIFRyYW5zbWl0IEZJRk8gZmx1c2ggb3BlcmF0aW9uICovCitzdGF0aWMgdm9pZCBnbWFjX2ZsdXNoX3R4X2ZpZm8odW5zaWduZWQgbG9uZyBpb2FkZHIpCit7CisJdTMyIGNzcjYgPSByZWFkbChpb2FkZHIgKyBETUFfQ09OVFJPTCk7CisJd3JpdGVsKChjc3I2IHwgRE1BX0NPTlRST0xfRlRGKSwgaW9hZGRyICsgRE1BX0NPTlRST0wpOworCisJZG8ge30gd2hpbGUgKChyZWFkbChpb2FkZHIgKyBETUFfQ09OVFJPTCkgJiBETUFfQ09OVFJPTF9GVEYpKTsKK30KKworc3RhdGljIHZvaWQgZ21hY19kbWFfb3BlcmF0aW9uX21vZGUodW5zaWduZWQgbG9uZyBpb2FkZHIsIGludCB0eG1vZGUsCisJCQkJICAgIGludCByeG1vZGUpCit7CisJdTMyIGNzcjYgPSByZWFkbChpb2FkZHIgKyBETUFfQ09OVFJPTCk7CisKKwlpZiAodHhtb2RlID09IFNGX0RNQV9NT0RFKSB7CisJCURCRyhLRVJOX0RFQlVHICJHTUFDOiBlbmFibGluZyBUWCBzdG9yZSBhbmQgZm9yd2FyZCBtb2RlXG4iKTsKKwkJLyogVHJhbnNtaXQgQ09FIHR5cGUgMiBjYW5ub3QgYmUgZG9uZSBpbiBjdXQtdGhyb3VnaCBtb2RlLiAqLworCQljc3I2IHw9IERNQV9DT05UUk9MX1RTRjsKKwkJLyogT3BlcmF0aW5nIG9uIHNlY29uZCBmcmFtZSBpbmNyZWFzZSB0aGUgcGVyZm9ybWFuY2UKKwkJICogZXNwZWNpYWxseSB3aGVuIHRyYW5zbWl0IHN0b3JlLWFuZC1mb3J3YXJkIGlzIHVzZWQuKi8KKwkJY3NyNiB8PSBETUFfQ09OVFJPTF9PU0Y7CisJfSBlbHNlIHsKKwkJREJHKEtFUk5fREVCVUcgIkdNQUM6IGRpc2FibGluZyBUWCBzdG9yZSBhbmQgZm9yd2FyZCBtb2RlIgorCQkJICAgICAgIiAodGhyZXNob2xkID0gJWQpXG4iLCB0eG1vZGUpOworCQljc3I2ICY9IH5ETUFfQ09OVFJPTF9UU0Y7CisJCWNzcjYgJj0gRE1BX0NPTlRST0xfVENfVFhfTUFTSzsKKwkJLyogU2V0IHRoZSB0cmFuc21pdCB0aHJlYXNob2xkICovCisJCWlmICh0eG1vZGUgPD0gMzIpCisJCQljc3I2IHw9IERNQV9DT05UUk9MX1RUQ18zMjsKKwkJZWxzZSBpZiAodHhtb2RlIDw9IDY0KQorCQkJY3NyNiB8PSBETUFfQ09OVFJPTF9UVENfNjQ7CisJCWVsc2UgaWYgKHR4bW9kZSA8PSAxMjgpCisJCQljc3I2IHw9IERNQV9DT05UUk9MX1RUQ18xMjg7CisJCWVsc2UgaWYgKHR4bW9kZSA8PSAxOTIpCisJCQljc3I2IHw9IERNQV9DT05UUk9MX1RUQ18xOTI7CisJCWVsc2UKKwkJCWNzcjYgfD0gRE1BX0NPTlRST0xfVFRDXzI1NjsKKwl9CisKKwlpZiAocnhtb2RlID09IFNGX0RNQV9NT0RFKSB7CisJCURCRyhLRVJOX0RFQlVHICJHTUFDOiBlbmFibGluZyBSWCBzdG9yZSBhbmQgZm9yd2FyZCBtb2RlXG4iKTsKKwkJY3NyNiB8PSBETUFfQ09OVFJPTF9SU0Y7CisJfSBlbHNlIHsKKwkJREJHKEtFUk5fREVCVUcgIkdNQUM6IGRpc2FibGluZyBSWCBzdG9yZSBhbmQgZm9yd2FyZCBtb2RlIgorCQkJICAgICAgIiAodGhyZXNob2xkID0gJWQpXG4iLCByeG1vZGUpOworCQljc3I2ICY9IH5ETUFfQ09OVFJPTF9SU0Y7CisJCWNzcjYgJj0gRE1BX0NPTlRST0xfVENfUlhfTUFTSzsKKwkJaWYgKHJ4bW9kZSA8PSAzMikKKwkJCWNzcjYgfD0gRE1BX0NPTlRST0xfUlRDXzMyOworCQllbHNlIGlmIChyeG1vZGUgPD0gNjQpCisJCQljc3I2IHw9IERNQV9DT05UUk9MX1JUQ182NDsKKwkJZWxzZSBpZiAocnhtb2RlIDw9IDk2KQorCQkJY3NyNiB8PSBETUFfQ09OVFJPTF9SVENfOTY7CisJCWVsc2UKKwkJCWNzcjYgfD0gRE1BX0NPTlRST0xfUlRDXzEyODsKKwl9CisKKwl3cml0ZWwoY3NyNiwgaW9hZGRyICsgRE1BX0NPTlRST0wpOworCXJldHVybjsKK30KKworLyogTm90IHlldCBpbXBsZW1lbnRlZCAtLS0gbm8gUk1PTiBtb2R1bGUgKi8KK3N0YXRpYyB2b2lkIGdtYWNfZG1hX2RpYWdub3N0aWNfZnIodm9pZCAqZGF0YSwgc3RydWN0IHN0bW1hY19leHRyYV9zdGF0cyAqeCwKKwkJCQkgICB1bnNpZ25lZCBsb25nIGlvYWRkcikKK3sKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIGdtYWNfZHVtcF9kbWFfcmVncyh1bnNpZ25lZCBsb25nIGlvYWRkcikKK3sKKwlpbnQgaTsKKwlwcl9pbmZvKCIgRE1BIHJlZ2lzdGVyc1xuIik7CisJZm9yIChpID0gMDsgaSA8IDIyOyBpKyspIHsKKwkJaWYgKChpIDwgOSkgfHwgKGkgPiAxNykpIHsKKwkJCWludCBvZmZzZXQgPSBpICogNDsKKwkJCXByX2VycigiXHQgUmVnIE5vLiAlZCAob2Zmc2V0IDB4JXgpOiAweCUwOHhcbiIsIGksCisJCQkgICAgICAgKERNQV9CVVNfTU9ERSArIG9mZnNldCksCisJCQkgICAgICAgcmVhZGwoaW9hZGRyICsgRE1BX0JVU19NT0RFICsgb2Zmc2V0KSk7CisJCX0KKwl9CisJcmV0dXJuOworfQorCitzdGF0aWMgaW50IGdtYWNfZ2V0X3R4X2ZyYW1lX3N0YXR1cyh2b2lkICpkYXRhLCBzdHJ1Y3Qgc3RtbWFjX2V4dHJhX3N0YXRzICp4LAorCQkJCSAgICBzdHJ1Y3QgZG1hX2Rlc2MgKnAsIHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCWludCByZXQgPSAwOworCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpzdGF0cyA9IChzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqKWRhdGE7CisKKwlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXR4LmVycm9yX3N1bW1hcnkpKSB7CisJCURCRyhLRVJOX0VSUiAiR01BQyBUWCBlcnJvci4uLiAweCUwOHhcbiIsIHAtPmRlczAxLmV0eCk7CisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5ldHguamFiYmVyX3RpbWVvdXQpKSB7CisJCQlEQkcoS0VSTl9FUlIgIlx0amFiYmVyX3RpbWVvdXQgZXJyb3JcbiIpOworCQkJeC0+dHhfamFiYmVyKys7CisJCX0KKworCQlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXR4LmZyYW1lX2ZsdXNoZWQpKSB7CisJCQlEQkcoS0VSTl9FUlIgIlx0ZnJhbWVfZmx1c2hlZCBlcnJvclxuIik7CisJCQl4LT50eF9mcmFtZV9mbHVzaGVkKys7CisJCQlnbWFjX2ZsdXNoX3R4X2ZpZm8oaW9hZGRyKTsKKwkJfQorCisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5ldHgubG9zc19jYXJyaWVyKSkgeworCQkJREJHKEtFUk5fRVJSICJcdGxvc3NfY2FycmllciBlcnJvclxuIik7CisJCQl4LT50eF9sb3NzY2FycmllcisrOworCQkJc3RhdHMtPnR4X2NhcnJpZXJfZXJyb3JzKys7CisJCX0KKwkJaWYgKHVubGlrZWx5KHAtPmRlczAxLmV0eC5ub19jYXJyaWVyKSkgeworCQkJREJHKEtFUk5fRVJSICJcdG5vX2NhcnJpZXIgZXJyb3JcbiIpOworCQkJeC0+dHhfY2FycmllcisrOworCQkJc3RhdHMtPnR4X2NhcnJpZXJfZXJyb3JzKys7CisJCX0KKwkJaWYgKHVubGlrZWx5KHAtPmRlczAxLmV0eC5sYXRlX2NvbGxpc2lvbikpIHsKKwkJCURCRyhLRVJOX0VSUiAiXHRsYXRlX2NvbGxpc2lvbiBlcnJvclxuIik7CisJCQlzdGF0cy0+Y29sbGlzaW9ucyArPSBwLT5kZXMwMS5ldHguY29sbGlzaW9uX2NvdW50OworCQl9CisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5ldHguZXhjZXNzaXZlX2NvbGxpc2lvbnMpKSB7CisJCQlEQkcoS0VSTl9FUlIgIlx0ZXhjZXNzaXZlX2NvbGxpc2lvbnNcbiIpOworCQkJc3RhdHMtPmNvbGxpc2lvbnMgKz0gcC0+ZGVzMDEuZXR4LmNvbGxpc2lvbl9jb3VudDsKKwkJfQorCQlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXR4LmV4Y2Vzc2l2ZV9kZWZlcnJhbCkpIHsKKwkJCURCRyhLRVJOX0lORk8gIlx0ZXhjZXNzaXZlIHR4X2RlZmVycmFsXG4iKTsKKwkJCXgtPnR4X2RlZmVycmVkKys7CisJCX0KKworCQlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXR4LnVuZGVyZmxvd19lcnJvcikpIHsKKwkJCURCRyhLRVJOX0VSUiAiXHR1bmRlcmZsb3cgZXJyb3JcbiIpOworCQkJZ21hY19mbHVzaF90eF9maWZvKGlvYWRkcik7CisJCQl4LT50eF91bmRlcmZsb3crKzsKKwkJfQorCisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5ldHguaXBfaGVhZGVyX2Vycm9yKSkgeworCQkJREJHKEtFUk5fRVJSICJcdFRYIElQIGhlYWRlciBjc3VtIGVycm9yXG4iKTsKKwkJCXgtPnR4X2lwX2hlYWRlcl9lcnJvcisrOworCQl9CisKKwkJaWYgKHVubGlrZWx5KHAtPmRlczAxLmV0eC5wYXlsb2FkX2Vycm9yKSkgeworCQkJREJHKEtFUk5fRVJSICJcdEFkZHIvUGF5bG9hZCBjc3VtIGVycm9yXG4iKTsKKwkJCXgtPnR4X3BheWxvYWRfZXJyb3IrKzsKKwkJCWdtYWNfZmx1c2hfdHhfZmlmbyhpb2FkZHIpOworCQl9CisKKwkJcmV0ID0gLTE7CisJfQorCisJaWYgKHVubGlrZWx5KHAtPmRlczAxLmV0eC5kZWZlcnJlZCkpIHsKKwkJREJHKEtFUk5fSU5GTyAiR01BQyBUWCBzdGF0dXM6IHR4IGRlZmVycmVkXG4iKTsKKwkJeC0+dHhfZGVmZXJyZWQrKzsKKwl9CisjaWZkZWYgU1RNTUFDX1ZMQU5fVEFHX1VTRUQKKwlpZiAocC0+ZGVzMDEuZXR4LnZsYW5fZnJhbWUpIHsKKwkJREJHKEtFUk5fSU5GTyAiR01BQyBUWCBzdGF0dXM6IFZMQU4gZnJhbWVcbiIpOworCQl4LT50eF92bGFuKys7CisJfQorI2VuZGlmCisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGdtYWNfZ2V0X3R4X2xlbihzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJcmV0dXJuIHAtPmRlczAxLmV0eC5idWZmZXIxX3NpemU7Cit9CisKK3N0YXRpYyBpbnQgZ21hY19jb2VfcmRlczAoaW50IGlwY19lcnIsIGludCB0eXBlLCBpbnQgcGF5bG9hZF9lcnIpCit7CisJaW50IHJldCA9IGdvb2RfZnJhbWU7CisJdTMyIHN0YXR1cyA9ICh0eXBlIDw8IDIgfCBpcGNfZXJyIDw8IDEgfCBwYXlsb2FkX2VycikgJiAweDc7CisKKwkvKiBiaXRzIDUgNyAwIHwgRnJhbWUgc3RhdHVzCisJICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCSAqICAgICAgMCAwIDAgfCBJRUVFIDgwMi4zIFR5cGUgZnJhbWUgKGxlbmdodCA8IDE1MzYgb2N0ZWN0cykKKwkgKiAgICAgIDEgMCAwIHwgSVB2NC82IE5vIENTVU0gZXJyb3JTLgorCSAqICAgICAgMSAwIDEgfCBJUHY0LzYgQ1NVTSBQQVlMT0FEIGVycm9yCisJICogICAgICAxIDEgMCB8IElQdjQvNiBDU1VNIElQIEhSIGVycm9yCisJICogICAgICAxIDEgMSB8IElQdjQvNiBJUCBQQVlMT0FEIEFORCBIRUFERVIgZXJyb3JTCisJICogICAgICAwIDAgMSB8IElQdjQvNiB1bnN1cHBvcnRlZCBJUCBQQVlMT0FECisJICogICAgICAwIDEgMSB8IENPRSBieXBhc3NlZC4uIG5vIElQdjQvNiBmcmFtZQorCSAqICAgICAgMCAxIDAgfCBSZXNlcnZlZC4KKwkgKi8KKwlpZiAoc3RhdHVzID09IDB4MCkgeworCQlEQkcoS0VSTl9JTkZPICJSWCBEZXMwIHN0YXR1czogSUVFRSA4MDIuMyBUeXBlIGZyYW1lLlxuIik7CisJCXJldCA9IGdvb2RfZnJhbWU7CisJfSBlbHNlIGlmIChzdGF0dXMgPT0gMHg0KSB7CisJCURCRyhLRVJOX0lORk8gIlJYIERlczAgc3RhdHVzOiBJUHY0LzYgTm8gQ1NVTSBlcnJvclMuXG4iKTsKKwkJcmV0ID0gZ29vZF9mcmFtZTsKKwl9IGVsc2UgaWYgKHN0YXR1cyA9PSAweDUpIHsKKwkJREJHKEtFUk5fRVJSICJSWCBEZXMwIHN0YXR1czogSVB2NC82IFBheWxvYWQgRXJyb3IuXG4iKTsKKwkJcmV0ID0gY3N1bV9ub25lOworCX0gZWxzZSBpZiAoc3RhdHVzID09IDB4NikgeworCQlEQkcoS0VSTl9FUlIgIlJYIERlczAgc3RhdHVzOiBJUHY0LzYgSGVhZGVyIEVycm9yLlxuIik7CisJCXJldCA9IGNzdW1fbm9uZTsKKwl9IGVsc2UgaWYgKHN0YXR1cyA9PSAweDcpIHsKKwkJREJHKEtFUk5fRVJSCisJCSAgICAiUlggRGVzMCBzdGF0dXM6IElQdjQvNiBIZWFkZXIgYW5kIFBheWxvYWQgRXJyb3IuXG4iKTsKKwkJcmV0ID0gY3N1bV9ub25lOworCX0gZWxzZSBpZiAoc3RhdHVzID09IDB4MSkgeworCQlEQkcoS0VSTl9FUlIKKwkJICAgICJSWCBEZXMwIHN0YXR1czogSVB2NC82IHVuc3VwcG9ydGVkIElQIFBBWUxPQUQuXG4iKTsKKwkJcmV0ID0gZGlzY2FyZF9mcmFtZTsKKwl9IGVsc2UgaWYgKHN0YXR1cyA9PSAweDMpIHsKKwkJREJHKEtFUk5fRVJSICJSWCBEZXMwIHN0YXR1czogTm8gSVB2NCwgSVB2NiBmcmFtZS5cbiIpOworCQlyZXQgPSBkaXNjYXJkX2ZyYW1lOworCX0KKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgaW50IGdtYWNfZ2V0X3J4X2ZyYW1lX3N0YXR1cyh2b2lkICpkYXRhLCBzdHJ1Y3Qgc3RtbWFjX2V4dHJhX3N0YXRzICp4LAorCQkJCSAgICBzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJaW50IHJldCA9IGdvb2RfZnJhbWU7CisJc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKnN0YXRzID0gKHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICopZGF0YTsKKworCWlmICh1bmxpa2VseShwLT5kZXMwMS5lcnguZXJyb3Jfc3VtbWFyeSkpIHsKKwkJREJHKEtFUk5fRVJSICJHTUFDIFJYIEVycm9yIFN1bW1hcnkuLi4gMHglMDh4XG4iLCBwLT5kZXMwMS5lcngpOworCQlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXJ4LmRlc2NyaXB0b3JfZXJyb3IpKSB7CisJCQlEQkcoS0VSTl9FUlIgIlx0ZGVzY3JpcHRvciBlcnJvclxuIik7CisJCQl4LT5yeF9kZXNjKys7CisJCQlzdGF0cy0+cnhfbGVuZ3RoX2Vycm9ycysrOworCQl9CisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5lcngub3ZlcmZsb3dfZXJyb3IpKSB7CisJCQlEQkcoS0VSTl9FUlIgIlx0b3ZlcmZsb3cgZXJyb3JcbiIpOworCQkJeC0+cnhfZ21hY19vdmVyZmxvdysrOworCQl9CisKKwkJaWYgKHVubGlrZWx5KHAtPmRlczAxLmVyeC5pcGNfY3N1bV9lcnJvcikpCisJCQlEQkcoS0VSTl9FUlIgIlx0SVBDIENzdW0gRXJyb3IvR2lhbnQgZnJhbWVcbiIpOworCisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5lcngubGF0ZV9jb2xsaXNpb24pKSB7CisJCQlEQkcoS0VSTl9FUlIgIlx0bGF0ZV9jb2xsaXNpb24gZXJyb3JcbiIpOworCQkJc3RhdHMtPmNvbGxpc2lvbnMrKzsKKwkJCXN0YXRzLT5jb2xsaXNpb25zKys7CisJCX0KKwkJaWYgKHVubGlrZWx5KHAtPmRlczAxLmVyeC5yZWNlaXZlX3dhdGNoZG9nKSkgeworCQkJREJHKEtFUk5fRVJSICJcdHJlY2VpdmVfd2F0Y2hkb2cgZXJyb3JcbiIpOworCQkJeC0+cnhfd2F0Y2hkb2crKzsKKwkJfQorCQlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXJ4LmVycm9yX2dtaWkpKSB7CisJCQlEQkcoS0VSTl9FUlIgIlx0UmVjZWl2ZSBFcnJvclxuIik7CisJCQl4LT5yeF9taWkrKzsKKwkJfQorCQlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXJ4LmNyY19lcnJvcikpIHsKKwkJCURCRyhLRVJOX0VSUiAiXHRDUkMgZXJyb3JcbiIpOworCQkJeC0+cnhfY3JjKys7CisJCQlzdGF0cy0+cnhfY3JjX2Vycm9ycysrOworCQl9CisJCXJldCA9IGRpc2NhcmRfZnJhbWU7CisJfQorCisJLyogQWZ0ZXIgYSBwYXlsb2FkIGNzdW0gZXJyb3IsIHRoZSBFUyBiaXQgaXMgc2V0LgorCSAqIEl0IGRvZXNuJ3QgbWF0Y2ggd2l0aCB0aGUgaW5mb3JtYXRpb24gcmVwb3J0ZWQgaW50byB0aGUgZGF0YWJvb2suCisJICogQXQgYW55IHJhdGUsIHdlIG5lZWQgdG8gdW5kZXJzdGFuZCBpZiB0aGUgQ1NVTSBodyBjb21wdXRhdGlvbiBpcyBvaworCSAqIGFuZCByZXBvcnQgdGhpcyBpbmZvIHRvIHRoZSB1cHBlciBsYXllcnMuICovCisJcmV0ID0gZ21hY19jb2VfcmRlczAocC0+ZGVzMDEuZXJ4LmlwY19jc3VtX2Vycm9yLAorCQlwLT5kZXMwMS5lcnguZnJhbWVfdHlwZSwgcC0+ZGVzMDEuZXJ4LnBheWxvYWRfY3N1bV9lcnJvcik7CisKKwlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXJ4LmRyaWJibGluZykpIHsKKwkJREJHKEtFUk5fRVJSICJHTUFDIFJYOiBkcmliYmxpbmcgZXJyb3JcbiIpOworCQlyZXQgPSBkaXNjYXJkX2ZyYW1lOworCX0KKwlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXJ4LnNhX2ZpbHRlcl9mYWlsKSkgeworCQlEQkcoS0VSTl9FUlIgIkdNQUMgUlggOiBTb3VyY2UgQWRkcmVzcyBmaWx0ZXIgZmFpbFxuIik7CisJCXgtPnNhX3J4X2ZpbHRlcl9mYWlsKys7CisJCXJldCA9IGRpc2NhcmRfZnJhbWU7CisJfQorCWlmICh1bmxpa2VseShwLT5kZXMwMS5lcnguZGFfZmlsdGVyX2ZhaWwpKSB7CisJCURCRyhLRVJOX0VSUiAiR01BQyBSWCA6IERlc3RpbmF0aW9uIEFkZHJlc3MgZmlsdGVyIGZhaWxcbiIpOworCQl4LT5kYV9yeF9maWx0ZXJfZmFpbCsrOworCQlyZXQgPSBkaXNjYXJkX2ZyYW1lOworCX0KKwlpZiAodW5saWtlbHkocC0+ZGVzMDEuZXJ4Lmxlbmd0aF9lcnJvcikpIHsKKwkJREJHKEtFUk5fRVJSICJHTUFDIFJYOiBsZW5ndGhfZXJyb3IgZXJyb3JcbiIpOworCQl4LT5yeF9sZW5naHQrKzsKKwkJcmV0ID0gZGlzY2FyZF9mcmFtZTsKKwl9CisjaWZkZWYgU1RNTUFDX1ZMQU5fVEFHX1VTRUQKKwlpZiAocC0+ZGVzMDEuZXJ4LnZsYW5fdGFnKSB7CisJCURCRyhLRVJOX0lORk8gIkdNQUMgUlg6IFZMQU4gZnJhbWUgdGFnZ2VkXG4iKTsKKwkJeC0+cnhfdmxhbisrOworCX0KKyNlbmRpZgorCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyB2b2lkIGdtYWNfaXJxX3N0YXR1cyh1bnNpZ25lZCBsb25nIGlvYWRkcikKK3sKKwl1MzIgaW50cl9zdGF0dXMgPSByZWFkbChpb2FkZHIgKyBHTUFDX0lOVF9TVEFUVVMpOworCisJLyogTm90IHVzZWQgZXZlbnRzIChlLmcuIE1NQyBpbnRlcnJ1cHRzKSBhcmUgbm90IGhhbmRsZWQuICovCisJaWYgKChpbnRyX3N0YXR1cyAmIG1tY190eF9pcnEpKQorCQlEQkcoS0VSTl9ERUJVRyAiR01BQzogTU1DIHR4IGludGVycnVwdDogMHglMDh4XG4iLAorCQkgICAgcmVhZGwoaW9hZGRyICsgR01BQ19NTUNfVFhfSU5UUikpOworCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIG1tY19yeF9pcnEpKQorCQlEQkcoS0VSTl9ERUJVRyAiR01BQzogTU1DIHJ4IGludGVycnVwdDogMHglMDh4XG4iLAorCQkgICAgcmVhZGwoaW9hZGRyICsgR01BQ19NTUNfUlhfSU5UUikpOworCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIG1tY19yeF9jc3VtX29mZmxvYWRfaXJxKSkKKwkJREJHKEtFUk5fREVCVUcgIkdNQUM6IE1NQyByeCBjc3VtIG9mZmxvYWQ6IDB4JTA4eFxuIiwKKwkJICAgIHJlYWRsKGlvYWRkciArIEdNQUNfTU1DX1JYX0NTVU1fT0ZGTE9BRCkpOworCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIHBtdF9pcnEpKSB7CisJCURCRyhLRVJOX0RFQlVHICJHTUFDOiByZWNlaXZlZCBNYWdpYyBmcmFtZVxuIik7CisJCS8qIGNsZWFyIHRoZSBQTVQgYml0cyA1IGFuZCA2IGJ5IHJlYWRpbmcgdGhlIFBNVAorCQkgKiBzdGF0dXMgcmVnaXN0ZXIuICovCisJCXJlYWRsKGlvYWRkciArIEdNQUNfUE1UKTsKKwl9CisKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIGdtYWNfY29yZV9pbml0KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIEdNQUNfQ09OVFJPTCk7CisJdmFsdWUgfD0gR01BQ19DT1JFX0lOSVQ7CisJd3JpdGVsKHZhbHVlLCBpb2FkZHIgKyBHTUFDX0NPTlRST0wpOworCisJLyogU1RCdXMgQnJpZGdlIENvbmZpZ3VyYXRpb24gKi8KKwkvKndyaXRlbCgweGM1NjA4LCBpb2FkZHIgKyAweDAwMDA3MDAwKTsqLworCisJLyogRnJlZXplIE1NQyBjb3VudGVycyAqLworCXdyaXRlbCgweDgsIGlvYWRkciArIEdNQUNfTU1DX0NUUkwpOworCS8qIE1hc2sgR01BQyBpbnRlcnJ1cHRzICovCisJd3JpdGVsKDB4MjA3LCBpb2FkZHIgKyBHTUFDX0lOVF9NQVNLKTsKKworI2lmZGVmIFNUTU1BQ19WTEFOX1RBR19VU0VECisJLyogVGFnIGRldGVjdGlvbiB3aXRob3V0IGZpbHRlcmluZyAqLworCXdyaXRlbCgweDAsIGlvYWRkciArIEdNQUNfVkxBTl9UQUcpOworI2VuZGlmCisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZCBnbWFjX3NldF91bWFjX2FkZHIodW5zaWduZWQgbG9uZyBpb2FkZHIsIHVuc2lnbmVkIGNoYXIgKmFkZHIsCisJCQkJdW5zaWduZWQgaW50IHJlZ19uKQoreworCXN0bW1hY19zZXRfbWFjX2FkZHIoaW9hZGRyLCBhZGRyLCBHTUFDX0FERFJfSElHSChyZWdfbiksCisJCQkJR01BQ19BRERSX0xPVyhyZWdfbikpOworfQorCitzdGF0aWMgdm9pZCBnbWFjX2dldF91bWFjX2FkZHIodW5zaWduZWQgbG9uZyBpb2FkZHIsIHVuc2lnbmVkIGNoYXIgKmFkZHIsCisJCQkJdW5zaWduZWQgaW50IHJlZ19uKQoreworCXN0bW1hY19nZXRfbWFjX2FkZHIoaW9hZGRyLCBhZGRyLCBHTUFDX0FERFJfSElHSChyZWdfbiksCisJCQkJR01BQ19BRERSX0xPVyhyZWdfbikpOworfQorCitzdGF0aWMgdm9pZCBnbWFjX3NldF9maWx0ZXIoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3sKKwl1bnNpZ25lZCBsb25nIGlvYWRkciA9IGRldi0+YmFzZV9hZGRyOworCXVuc2lnbmVkIGludCB2YWx1ZSA9IDA7CisKKwlEQkcoS0VSTl9JTkZPICIlczogIyBtY2FzdHMgJWQsICMgdW5pY2FzdCAlZFxuIiwKKwkgICAgX19mdW5jX18sIGRldi0+bWNfY291bnQsIGRldi0+dWNfY291bnQpOworCisJaWYgKGRldi0+ZmxhZ3MgJiBJRkZfUFJPTUlTQykKKwkJdmFsdWUgPSBHTUFDX0ZSQU1FX0ZJTFRFUl9QUjsKKwllbHNlIGlmICgoZGV2LT5tY19jb3VudCA+IEhBU0hfVEFCTEVfU0laRSkKKwkJICAgfHwgKGRldi0+ZmxhZ3MgJiBJRkZfQUxMTVVMVEkpKSB7CisJCXZhbHVlID0gR01BQ19GUkFNRV9GSUxURVJfUE07CS8qIHBhc3MgYWxsIG11bHRpICovCisJCXdyaXRlbCgweGZmZmZmZmZmLCBpb2FkZHIgKyBHTUFDX0hBU0hfSElHSCk7CisJCXdyaXRlbCgweGZmZmZmZmZmLCBpb2FkZHIgKyBHTUFDX0hBU0hfTE9XKTsKKwl9IGVsc2UgaWYgKGRldi0+bWNfY291bnQgPiAwKSB7CisJCWludCBpOworCQl1MzIgbWNfZmlsdGVyWzJdOworCQlzdHJ1Y3QgZGV2X21jX2xpc3QgKm1jbGlzdDsKKworCQkvKiBIYXNoIGZpbHRlciBmb3IgbXVsdGljYXN0ICovCisJCXZhbHVlID0gR01BQ19GUkFNRV9GSUxURVJfSE1DOworCisJCW1lbXNldChtY19maWx0ZXIsIDAsIHNpemVvZihtY19maWx0ZXIpKTsKKwkJZm9yIChpID0gMCwgbWNsaXN0ID0gZGV2LT5tY19saXN0OworCQkgICAgIG1jbGlzdCAmJiBpIDwgZGV2LT5tY19jb3VudDsgaSsrLCBtY2xpc3QgPSBtY2xpc3QtPm5leHQpIHsKKwkJCS8qIFRoZSB1cHBlciA2IGJpdHMgb2YgdGhlIGNhbGN1bGF0ZWQgQ1JDIGFyZSB1c2VkIHRvCisJCQkgICBpbmRleCB0aGUgY29udGVucyBvZiB0aGUgaGFzaCB0YWJsZSAqLworCQkJaW50IGJpdF9uciA9CisJCQkgICAgYml0cmV2MzIofmNyYzMyX2xlKH4wLCBtY2xpc3QtPmRtaV9hZGRyLCA2KSkgPj4gMjY7CisJCQkvKiBUaGUgbW9zdCBzaWduaWZpY2FudCBiaXQgZGV0ZXJtaW5lcyB0aGUgcmVnaXN0ZXIgdG8KKwkJCSAqIHVzZSAoSC9MKSB3aGlsZSB0aGUgb3RoZXIgNSBiaXRzIGRldGVybWluZSB0aGUgYml0CisJCQkgKiB3aXRoaW4gdGhlIHJlZ2lzdGVyLiAqLworCQkJbWNfZmlsdGVyW2JpdF9uciA+PiA1XSB8PSAxIDw8IChiaXRfbnIgJiAzMSk7CisJCX0KKwkJd3JpdGVsKG1jX2ZpbHRlclswXSwgaW9hZGRyICsgR01BQ19IQVNIX0xPVyk7CisJCXdyaXRlbChtY19maWx0ZXJbMV0sIGlvYWRkciArIEdNQUNfSEFTSF9ISUdIKTsKKwl9CisKKwkvKiBIYW5kbGUgbXVsdGlwbGUgdW5pY2FzdCBhZGRyZXNzZXMgKHBlcmZlY3QgZmlsdGVyaW5nKSovCisJaWYgKGRldi0+dWNfY291bnQgPiBHTUFDX01BWF9VTklDQVNUX0FERFJFU1NFUykKKwkJLyogU3dpdGNoIHRvIHByb21pc2N1b3VzIG1vZGUgaXMgbW9yZSB0aGFuIDE2IGFkZHJzCisJCSAgIGFyZSByZXF1aXJlZCAqLworCQl2YWx1ZSB8PSBHTUFDX0ZSQU1FX0ZJTFRFUl9QUjsKKwllbHNlIHsKKwkJaW50IGk7CisJCXN0cnVjdCBkZXZfYWRkcl9saXN0ICp1Y19wdHIgPSBkZXYtPnVjX2xpc3Q7CisKKwkJCWZvciAoaSA9IDA7IGkgPCBkZXYtPnVjX2NvdW50OyBpKyspIHsKKwkJCQlnbWFjX3NldF91bWFjX2FkZHIoaW9hZGRyLCB1Y19wdHItPmRhX2FkZHIsCisJCQkJCQlpICsgMSk7CisKKwkJCQlEQkcoS0VSTl9JTkZPICJcdCVkICIKKwkJCQkiLSBVbmljYXN0IGFkZHIgJTAyeDolMDJ4OiUwMng6JTAyeDolMDJ4OiIKKwkJCQkiJTAyeFxuIiwgaSArIDEsCisJCQkJdWNfcHRyLT5kYV9hZGRyWzBdLCB1Y19wdHItPmRhX2FkZHJbMV0sCisJCQkJdWNfcHRyLT5kYV9hZGRyWzJdLCB1Y19wdHItPmRhX2FkZHJbM10sCisJCQkJdWNfcHRyLT5kYV9hZGRyWzRdLCB1Y19wdHItPmRhX2FkZHJbNV0pOworCQkJCXVjX3B0ciA9IHVjX3B0ci0+bmV4dDsKKwkJfQorCX0KKworI2lmZGVmIEZSQU1FX0ZJTFRFUl9ERUJVRworCS8qIEVuYWJsZSBSZWNlaXZlIGFsbCBtb2RlICh0byBkZWJ1ZyBmaWx0ZXJpbmdfZmFpbCBlcnJvcnMpICovCisJdmFsdWUgfD0gR01BQ19GUkFNRV9GSUxURVJfUkE7CisjZW5kaWYKKwl3cml0ZWwodmFsdWUsIGlvYWRkciArIEdNQUNfRlJBTUVfRklMVEVSKTsKKworCURCRyhLRVJOX0lORk8gIlx0RnJhbWUgRmlsdGVyIHJlZzogMHglMDh4XG5cdEhhc2ggcmVnczogIgorCSAgICAiSEkgMHglMDh4LCBMTyAweCUwOHhcbiIsIHJlYWRsKGlvYWRkciArIEdNQUNfRlJBTUVfRklMVEVSKSwKKwkgICAgcmVhZGwoaW9hZGRyICsgR01BQ19IQVNIX0hJR0gpLCByZWFkbChpb2FkZHIgKyBHTUFDX0hBU0hfTE9XKSk7CisKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIGdtYWNfZmxvd19jdHJsKHVuc2lnbmVkIGxvbmcgaW9hZGRyLCB1bnNpZ25lZCBpbnQgZHVwbGV4LAorCQkJICAgdW5zaWduZWQgaW50IGZjLCB1bnNpZ25lZCBpbnQgcGF1c2VfdGltZSkKK3sKKwl1bnNpZ25lZCBpbnQgZmxvdyA9IDA7CisKKwlEQkcoS0VSTl9ERUJVRyAiR01BQyBGbG93LUNvbnRyb2w6XG4iKTsKKwlpZiAoZmMgJiBGTE9XX1JYKSB7CisJCURCRyhLRVJOX0RFQlVHICJcdFJlY2VpdmUgRmxvdy1Db250cm9sIE9OXG4iKTsKKwkJZmxvdyB8PSBHTUFDX0ZMT1dfQ1RSTF9SRkU7CisJfQorCWlmIChmYyAmIEZMT1dfVFgpIHsKKwkJREJHKEtFUk5fREVCVUcgIlx0VHJhbnNtaXQgRmxvdy1Db250cm9sIE9OXG4iKTsKKwkJZmxvdyB8PSBHTUFDX0ZMT1dfQ1RSTF9URkU7CisJfQorCisJaWYgKGR1cGxleCkgeworCQlEQkcoS0VSTl9ERUJVRyAiXHRkdXBsZXggbW9kZTogcGF1c2UgdGltZTogJWRcbiIsIHBhdXNlX3RpbWUpOworCQlmbG93IHw9IChwYXVzZV90aW1lIDw8IEdNQUNfRkxPV19DVFJMX1BUX1NISUZUKTsKKwl9CisKKwl3cml0ZWwoZmxvdywgaW9hZGRyICsgR01BQ19GTE9XX0NUUkwpOworCXJldHVybjsKK30KKworc3RhdGljIHZvaWQgZ21hY19wbXQodW5zaWduZWQgbG9uZyBpb2FkZHIsIHVuc2lnbmVkIGxvbmcgbW9kZSkKK3sKKwl1bnNpZ25lZCBpbnQgcG10ID0gMDsKKworCWlmIChtb2RlID09IFdBS0VfTUFHSUMpIHsKKwkJREJHKEtFUk5fREVCVUcgIkdNQUM6IFdPTCBNYWdpYyBmcmFtZVxuIik7CisJCXBtdCB8PSBwb3dlcl9kb3duIHwgbWFnaWNfcGt0X2VuOworCX0gZWxzZSBpZiAobW9kZSA9PSBXQUtFX1VDQVNUKSB7CisJCURCRyhLRVJOX0RFQlVHICJHTUFDOiBXT0wgb24gZ2xvYmFsIHVuaWNhc3RcbiIpOworCQlwbXQgfD0gZ2xvYmFsX3VuaWNhc3Q7CisJfQorCisJd3JpdGVsKHBtdCwgaW9hZGRyICsgR01BQ19QTVQpOworCXJldHVybjsKK30KKworc3RhdGljIHZvaWQgZ21hY19pbml0X3J4X2Rlc2Moc3RydWN0IGRtYV9kZXNjICpwLCB1bnNpZ25lZCBpbnQgcmluZ19zaXplLAorCQkJCWludCBkaXNhYmxlX3J4X2ljKQoreworCWludCBpOworCWZvciAoaSA9IDA7IGkgPCByaW5nX3NpemU7IGkrKykgeworCQlwLT5kZXMwMS5lcngub3duID0gMTsKKwkJcC0+ZGVzMDEuZXJ4LmJ1ZmZlcjFfc2l6ZSA9IEJVRl9TSVpFXzhLaUIgLSAxOworCQkvKiBUbyBzdXBwb3J0IGp1bWJvIGZyYW1lcyAqLworCQlwLT5kZXMwMS5lcnguYnVmZmVyMl9zaXplID0gQlVGX1NJWkVfOEtpQiAtIDE7CisJCWlmIChpID09IHJpbmdfc2l6ZSAtIDEpCisJCQlwLT5kZXMwMS5lcnguZW5kX3JpbmcgPSAxOworCQlpZiAoZGlzYWJsZV9yeF9pYykKKwkJCXAtPmRlczAxLmVyeC5kaXNhYmxlX2ljID0gMTsKKwkJcCsrOworCX0KKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIGdtYWNfaW5pdF90eF9kZXNjKHN0cnVjdCBkbWFfZGVzYyAqcCwgdW5zaWduZWQgaW50IHJpbmdfc2l6ZSkKK3sKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7IGkgPCByaW5nX3NpemU7IGkrKykgeworCQlwLT5kZXMwMS5ldHgub3duID0gMDsKKwkJaWYgKGkgPT0gcmluZ19zaXplIC0gMSkKKwkJCXAtPmRlczAxLmV0eC5lbmRfcmluZyA9IDE7CisJCXArKzsKKwl9CisKKwlyZXR1cm47Cit9CisKK3N0YXRpYyBpbnQgZ21hY19nZXRfdHhfb3duZXIoc3RydWN0IGRtYV9kZXNjICpwKQoreworCXJldHVybiBwLT5kZXMwMS5ldHgub3duOworfQorCitzdGF0aWMgaW50IGdtYWNfZ2V0X3J4X293bmVyKHN0cnVjdCBkbWFfZGVzYyAqcCkKK3sKKwlyZXR1cm4gcC0+ZGVzMDEuZXJ4Lm93bjsKK30KKworc3RhdGljIHZvaWQgZ21hY19zZXRfdHhfb3duZXIoc3RydWN0IGRtYV9kZXNjICpwKQoreworCXAtPmRlczAxLmV0eC5vd24gPSAxOworfQorCitzdGF0aWMgdm9pZCBnbWFjX3NldF9yeF9vd25lcihzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJcC0+ZGVzMDEuZXJ4Lm93biA9IDE7Cit9CisKK3N0YXRpYyBpbnQgZ21hY19nZXRfdHhfbHMoc3RydWN0IGRtYV9kZXNjICpwKQoreworCXJldHVybiBwLT5kZXMwMS5ldHgubGFzdF9zZWdtZW50OworfQorCitzdGF0aWMgdm9pZCBnbWFjX3JlbGVhc2VfdHhfZGVzYyhzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJaW50IHRlciA9IHAtPmRlczAxLmV0eC5lbmRfcmluZzsKKworCW1lbXNldChwLCAwLCBzaXplb2Yoc3RydWN0IGRtYV9kZXNjKSk7CisJcC0+ZGVzMDEuZXR4LmVuZF9yaW5nID0gdGVyOworCisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZCBnbWFjX3ByZXBhcmVfdHhfZGVzYyhzdHJ1Y3QgZG1hX2Rlc2MgKnAsIGludCBpc19mcywgaW50IGxlbiwKKwkJCQkgaW50IGNzdW1fZmxhZykKK3sKKwlwLT5kZXMwMS5ldHguZmlyc3Rfc2VnbWVudCA9IGlzX2ZzOworCWlmICh1bmxpa2VseShsZW4gPiBCVUZfU0laRV80S2lCKSkgeworCQlwLT5kZXMwMS5ldHguYnVmZmVyMV9zaXplID0gQlVGX1NJWkVfNEtpQjsKKwkJcC0+ZGVzMDEuZXR4LmJ1ZmZlcjJfc2l6ZSA9IGxlbiAtIEJVRl9TSVpFXzRLaUI7CisJfSBlbHNlIHsKKwkJcC0+ZGVzMDEuZXR4LmJ1ZmZlcjFfc2l6ZSA9IGxlbjsKKwl9CisJaWYgKGxpa2VseShjc3VtX2ZsYWcpKQorCQlwLT5kZXMwMS5ldHguY2hlY2tzdW1faW5zZXJ0aW9uID0gY2ljX2Z1bGw7Cit9CisKK3N0YXRpYyB2b2lkIGdtYWNfY2xlYXJfdHhfaWMoc3RydWN0IGRtYV9kZXNjICpwKQoreworCXAtPmRlczAxLmV0eC5pbnRlcnJ1cHQgPSAwOworfQorCitzdGF0aWMgdm9pZCBnbWFjX2Nsb3NlX3R4X2Rlc2Moc3RydWN0IGRtYV9kZXNjICpwKQoreworCXAtPmRlczAxLmV0eC5sYXN0X3NlZ21lbnQgPSAxOworCXAtPmRlczAxLmV0eC5pbnRlcnJ1cHQgPSAxOworfQorCitzdGF0aWMgaW50IGdtYWNfZ2V0X3J4X2ZyYW1lX2xlbihzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJcmV0dXJuIHAtPmRlczAxLmVyeC5mcmFtZV9sZW5ndGg7Cit9CisKK3N0cnVjdCBzdG1tYWNfb3BzIGdtYWNfZHJpdmVyID0geworCS5jb3JlX2luaXQgPSBnbWFjX2NvcmVfaW5pdCwKKwkuZHVtcF9tYWNfcmVncyA9IGdtYWNfZHVtcF9yZWdzLAorCS5kbWFfaW5pdCA9IGdtYWNfZG1hX2luaXQsCisJLmR1bXBfZG1hX3JlZ3MgPSBnbWFjX2R1bXBfZG1hX3JlZ3MsCisJLmRtYV9tb2RlID0gZ21hY19kbWFfb3BlcmF0aW9uX21vZGUsCisJLmRtYV9kaWFnbm9zdGljX2ZyID0gZ21hY19kbWFfZGlhZ25vc3RpY19mciwKKwkudHhfc3RhdHVzID0gZ21hY19nZXRfdHhfZnJhbWVfc3RhdHVzLAorCS5yeF9zdGF0dXMgPSBnbWFjX2dldF9yeF9mcmFtZV9zdGF0dXMsCisJLmdldF90eF9sZW4gPSBnbWFjX2dldF90eF9sZW4sCisJLnNldF9maWx0ZXIgPSBnbWFjX3NldF9maWx0ZXIsCisJLmZsb3dfY3RybCA9IGdtYWNfZmxvd19jdHJsLAorCS5wbXQgPSBnbWFjX3BtdCwKKwkuaW5pdF9yeF9kZXNjID0gZ21hY19pbml0X3J4X2Rlc2MsCisJLmluaXRfdHhfZGVzYyA9IGdtYWNfaW5pdF90eF9kZXNjLAorCS5nZXRfdHhfb3duZXIgPSBnbWFjX2dldF90eF9vd25lciwKKwkuZ2V0X3J4X293bmVyID0gZ21hY19nZXRfcnhfb3duZXIsCisJLnJlbGVhc2VfdHhfZGVzYyA9IGdtYWNfcmVsZWFzZV90eF9kZXNjLAorCS5wcmVwYXJlX3R4X2Rlc2MgPSBnbWFjX3ByZXBhcmVfdHhfZGVzYywKKwkuY2xlYXJfdHhfaWMgPSBnbWFjX2NsZWFyX3R4X2ljLAorCS5jbG9zZV90eF9kZXNjID0gZ21hY19jbG9zZV90eF9kZXNjLAorCS5nZXRfdHhfbHMgPSBnbWFjX2dldF90eF9scywKKwkuc2V0X3R4X293bmVyID0gZ21hY19zZXRfdHhfb3duZXIsCisJLnNldF9yeF9vd25lciA9IGdtYWNfc2V0X3J4X293bmVyLAorCS5nZXRfcnhfZnJhbWVfbGVuID0gZ21hY19nZXRfcnhfZnJhbWVfbGVuLAorCS5ob3N0X2lycV9zdGF0dXMgPSBnbWFjX2lycV9zdGF0dXMsCisJLnNldF91bWFjX2FkZHIgPSBnbWFjX3NldF91bWFjX2FkZHIsCisJLmdldF91bWFjX2FkZHIgPSBnbWFjX2dldF91bWFjX2FkZHIsCit9OworCitzdHJ1Y3QgbWFjX2RldmljZV9pbmZvICpnbWFjX3NldHVwKHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXN0cnVjdCBtYWNfZGV2aWNlX2luZm8gKm1hYzsKKwl1MzIgdWlkID0gcmVhZGwoaW9hZGRyICsgR01BQ19WRVJTSU9OKTsKKworCXByX2luZm8oIlx0R01BQyAtIHVzZXIgSUQ6IDB4JXgsIFN5bm9wc3lzIElEOiAweCV4XG4iLAorCSAgICAgICAoKHVpZCAmIDB4MDAwMGZmMDApID4+IDgpLCAodWlkICYgMHgwMDAwMDBmZikpOworCisJbWFjID0ga3phbGxvYyhzaXplb2YoY29uc3Qgc3RydWN0IG1hY19kZXZpY2VfaW5mbyksIEdGUF9LRVJORUwpOworCisJbWFjLT5vcHMgPSAmZ21hY19kcml2ZXI7CisJbWFjLT5ody5wbXQgPSBQTVRfU1VQUE9SVEVEOworCW1hYy0+aHcubGluay5wb3J0ID0gR01BQ19DT05UUk9MX1BTOworCW1hYy0+aHcubGluay5kdXBsZXggPSBHTUFDX0NPTlRST0xfRE07CisJbWFjLT5ody5saW5rLnNwZWVkID0gR01BQ19DT05UUk9MX0ZFUzsKKwltYWMtPmh3Lm1paS5hZGRyID0gR01BQ19NSUlfQUREUjsKKwltYWMtPmh3Lm1paS5kYXRhID0gR01BQ19NSUlfREFUQTsKKworCXJldHVybiBtYWM7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zdG1tYWMvZ21hYy5oIGIvZHJpdmVycy9uZXQvc3RtbWFjL2dtYWMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ODRhMzYzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvc3RtbWFjL2dtYWMuaApAQCAtMCwwICsxLDIwNCBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIFNUTWljcm9lbGVjdHJvbmljcyBMdGQKKworICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLAorICB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKKyAgbW9yZSBkZXRhaWxzLgorCisgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nIHdpdGgKKyAgdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgIDUxIEZyYW5rbGluIFN0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisKKyAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAgdGhlIGZpbGUgY2FsbGVkICJDT1BZSU5HIi4KKworICBBdXRob3I6IEdpdXNlcHBlIENhdmFsbGFybyA8cGVwcGUuY2F2YWxsYXJvQHN0LmNvbT4KKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNkZWZpbmUgR01BQ19DT05UUk9MCQkweDAwMDAwMDAwCS8qIENvbmZpZ3VyYXRpb24gKi8KKyNkZWZpbmUgR01BQ19GUkFNRV9GSUxURVIJMHgwMDAwMDAwNAkvKiBGcmFtZSBGaWx0ZXIgKi8KKyNkZWZpbmUgR01BQ19IQVNIX0hJR0gJCTB4MDAwMDAwMDgJLyogTXVsdGljYXN0IEhhc2ggVGFibGUgSGlnaCAqLworI2RlZmluZSBHTUFDX0hBU0hfTE9XCQkweDAwMDAwMDBjCS8qIE11bHRpY2FzdCBIYXNoIFRhYmxlIExvdyAqLworI2RlZmluZSBHTUFDX01JSV9BRERSCQkweDAwMDAwMDEwCS8qIE1JSSBBZGRyZXNzICovCisjZGVmaW5lIEdNQUNfTUlJX0RBVEEJCTB4MDAwMDAwMTQJLyogTUlJIERhdGEgKi8KKyNkZWZpbmUgR01BQ19GTE9XX0NUUkwJCTB4MDAwMDAwMTgJLyogRmxvdyBDb250cm9sICovCisjZGVmaW5lIEdNQUNfVkxBTl9UQUcJCTB4MDAwMDAwMWMJLyogVkxBTiBUYWcgKi8KKyNkZWZpbmUgR01BQ19WRVJTSU9OCQkweDAwMDAwMDIwCS8qIEdNQUMgQ09SRSBWZXJzaW9uICovCisjZGVmaW5lIEdNQUNfV0FLRVVQX0ZJTFRFUgkweDAwMDAwMDI4CS8qIFdha2UtdXAgRnJhbWUgRmlsdGVyICovCisKKyNkZWZpbmUgR01BQ19JTlRfU1RBVFVTCQkweDAwMDAwMDM4CS8qIGludGVycnVwdCBzdGF0dXMgcmVnaXN0ZXIgKi8KK2VudW0gZ21hY19pcnFfc3RhdHVzIHsKKwl0aW1lX3N0YW1wX2lycSA9IDB4MDIwMCwKKwltbWNfcnhfY3N1bV9vZmZsb2FkX2lycSA9IDB4MDA4MCwKKwltbWNfdHhfaXJxID0gMHgwMDQwLAorCW1tY19yeF9pcnEgPSAweDAwMjAsCisJbW1jX2lycSA9IDB4MDAxMCwKKwlwbXRfaXJxID0gMHgwMDA4LAorCXBjc19hbmVfaXJxID0gMHgwMDA0LAorCXBjc19saW5rX2lycSA9IDB4MDAwMiwKKwlyZ21paV9pcnEgPSAweDAwMDEsCit9OworI2RlZmluZSBHTUFDX0lOVF9NQVNLCQkweDAwMDAwMDNjCS8qIGludGVycnVwdCBtYXNrIHJlZ2lzdGVyICovCisKKy8qIFBNVCBDb250cm9sIGFuZCBTdGF0dXMgKi8KKyNkZWZpbmUgR01BQ19QTVQJCTB4MDAwMDAwMmMKK2VudW0gcG93ZXJfZXZlbnQgeworCXBvaW50ZXJfcmVzZXQgPSAweDgwMDAwMDAwLAorCWdsb2JhbF91bmljYXN0ID0gMHgwMDAwMDIwMCwKKwl3YWtlX3VwX3J4X2ZyYW1lID0gMHgwMDAwMDA0MCwKKwltYWdpY19mcmFtZSA9IDB4MDAwMDAwMjAsCisJd2FrZV91cF9mcmFtZV9lbiA9IDB4MDAwMDAwMDQsCisJbWFnaWNfcGt0X2VuID0gMHgwMDAwMDAwMiwKKwlwb3dlcl9kb3duID0gMHgwMDAwMDAwMSwKK307CisKKy8qIEdNQUMgSFcgQUREUiByZWdzICovCisjZGVmaW5lIEdNQUNfQUREUl9ISUdIKHJlZykJCSgweDAwMDAwMDQwKyhyZWcgKiA4KSkKKyNkZWZpbmUgR01BQ19BRERSX0xPVyhyZWcpCQkoMHgwMDAwMDA0NCsocmVnICogOCkpCisjZGVmaW5lIEdNQUNfTUFYX1VOSUNBU1RfQUREUkVTU0VTCTE2CisKKyNkZWZpbmUgR01BQ19BTl9DVFJMCTB4MDAwMDAwYzAJLyogQU4gY29udHJvbCAqLworI2RlZmluZSBHTUFDX0FOX1NUQVRVUwkweDAwMDAwMGM0CS8qIEFOIHN0YXR1cyAqLworI2RlZmluZSBHTUFDX0FORV9BRFYJMHgwMDAwMDBjOAkvKiBBdXRvLU5lZy4gQWR2ZXJ0aXNlbWVudCAqLworI2RlZmluZSBHTUFDX0FORV9MSU5LCTB4MDAwMDAwY2MJLyogQXV0by1OZWcuIGxpbmsgcGFydGVuZXIgYWJpbGl0eSAqLworI2RlZmluZSBHTUFDX0FORV9FWFAJMHgwMDAwMDBkMAkvKiBBTkUgZXhwYW5zaW9uICovCisjZGVmaW5lIEdNQUNfVEJJCTB4MDAwMDAwZDQJLyogVEJJIGV4dGVuZCBzdGF0dXMgKi8KKyNkZWZpbmUgR01BQ19HTUlJX1NUQVRVUyAweDAwMDAwMGQ4CS8qIFMvUi1HTUlJIHN0YXR1cyAqLworCisvKiBHTUFDIENvbmZpZ3VyYXRpb24gZGVmaW5lcyAqLworI2RlZmluZSBHTUFDX0NPTlRST0xfVEMJMHgwMTAwMDAwMAkvKiBUcmFuc21pdCBDb25mLiBpbiBSR01JSS9TR01JSSAqLworI2RlZmluZSBHTUFDX0NPTlRST0xfV0QJMHgwMDgwMDAwMAkvKiBEaXNhYmxlIFdhdGNoZG9nIG9uIHJlY2VpdmUgKi8KKyNkZWZpbmUgR01BQ19DT05UUk9MX0pECTB4MDA0MDAwMDAJLyogSmFiYmVyIGRpc2FibGUgKi8KKyNkZWZpbmUgR01BQ19DT05UUk9MX0JFCTB4MDAyMDAwMDAJLyogRnJhbWUgQnVyc3QgRW5hYmxlICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9KRQkweDAwMTAwMDAwCS8qIEp1bWJvIGZyYW1lICovCitlbnVtIGludGVyX2ZyYW1lX2dhcCB7CisJR01BQ19DT05UUk9MX0lGR184OCA9IDB4MDAwNDAwMDAsCisJR01BQ19DT05UUk9MX0lGR184MCA9IDB4MDAwMjAwMDAsCisJR01BQ19DT05UUk9MX0lGR180MCA9IDB4MDAwZTAwMDAsCit9OworI2RlZmluZSBHTUFDX0NPTlRST0xfRENSUwkweDAwMDEwMDAwIC8qIERpc2FibGUgY2FycmllciBzZW5zZSBkdXJpbmcgdHggKi8KKyNkZWZpbmUgR01BQ19DT05UUk9MX1BTCQkweDAwMDA4MDAwIC8qIFBvcnQgU2VsZWN0IDA6R01JIDE6TUlJICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9GRVMJMHgwMDAwNDAwMCAvKiBTcGVlZCAwOjEwIDE6MTAwICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9ETwkJMHgwMDAwMjAwMCAvKiBEaXNhYmxlIFJ4IE93biAqLworI2RlZmluZSBHTUFDX0NPTlRST0xfTE0JCTB4MDAwMDEwMDAgLyogTG9vcC1iYWNrIG1vZGUgKi8KKyNkZWZpbmUgR01BQ19DT05UUk9MX0RNCQkweDAwMDAwODAwIC8qIER1cGxleCBNb2RlICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9JUEMJMHgwMDAwMDQwMCAvKiBDaGVja3N1bSBPZmZsb2FkICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9EUgkJMHgwMDAwMDIwMCAvKiBEaXNhYmxlIFJldHJ5ICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9MVUQJMHgwMDAwMDEwMCAvKiBMaW5rIHVwL2Rvd24gKi8KKyNkZWZpbmUgR01BQ19DT05UUk9MX0FDUwkweDAwMDAwMDgwIC8qIEF1dG9tYXRpYyBQYWQgU3RyaXBwaW5nICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9EQwkJMHgwMDAwMDAxMCAvKiBEZWZlcnJhbCBDaGVjayAqLworI2RlZmluZSBHTUFDX0NPTlRST0xfVEUJCTB4MDAwMDAwMDggLyogVHJhbnNtaXR0ZXIgRW5hYmxlICovCisjZGVmaW5lIEdNQUNfQ09OVFJPTF9SRQkJMHgwMDAwMDAwNCAvKiBSZWNlaXZlciBFbmFibGUgKi8KKworI2RlZmluZSBHTUFDX0NPUkVfSU5JVCAoR01BQ19DT05UUk9MX0pEIHwgR01BQ19DT05UUk9MX1BTIHwgR01BQ19DT05UUk9MX0FDUyB8IFwKKwkJCUdNQUNfQ09OVFJPTF9JUEMgfCBHTUFDX0NPTlRST0xfSkUgfCBHTUFDX0NPTlRST0xfQkUpCisKKy8qIEdNQUMgRnJhbWUgRmlsdGVyIGRlZmluZXMgKi8KKyNkZWZpbmUgR01BQ19GUkFNRV9GSUxURVJfUFIJMHgwMDAwMDAwMQkvKiBQcm9taXNjdW91cyBNb2RlICovCisjZGVmaW5lIEdNQUNfRlJBTUVfRklMVEVSX0hVQwkweDAwMDAwMDAyCS8qIEhhc2ggVW5pY2FzdCAqLworI2RlZmluZSBHTUFDX0ZSQU1FX0ZJTFRFUl9ITUMJMHgwMDAwMDAwNAkvKiBIYXNoIE11bHRpY2FzdCAqLworI2RlZmluZSBHTUFDX0ZSQU1FX0ZJTFRFUl9EQUlGCTB4MDAwMDAwMDgJLyogREEgSW52ZXJzZSBGaWx0ZXJpbmcgKi8KKyNkZWZpbmUgR01BQ19GUkFNRV9GSUxURVJfUE0JMHgwMDAwMDAxMAkvKiBQYXNzIGFsbCBtdWx0aWNhc3QgKi8KKyNkZWZpbmUgR01BQ19GUkFNRV9GSUxURVJfREJGCTB4MDAwMDAwMjAJLyogRGlzYWJsZSBCcm9hZGNhc3QgZnJhbWVzICovCisjZGVmaW5lIEdNQUNfRlJBTUVfRklMVEVSX1NBSUYJMHgwMDAwMDEwMAkvKiBJbnZlcnNlIEZpbHRlcmluZyAqLworI2RlZmluZSBHTUFDX0ZSQU1FX0ZJTFRFUl9TQUYJMHgwMDAwMDIwMAkvKiBTb3VyY2UgQWRkcmVzcyBGaWx0ZXIgKi8KKyNkZWZpbmUgR01BQ19GUkFNRV9GSUxURVJfSFBGCTB4MDAwMDA0MDAJLyogSGFzaCBvciBwZXJmZWN0IEZpbHRlciAqLworI2RlZmluZSBHTUFDX0ZSQU1FX0ZJTFRFUl9SQQkweDgwMDAwMDAwCS8qIFJlY2VpdmUgYWxsIG1vZGUgKi8KKy8qIEdNSUkgQUREUiAgZGVmaW5lcyAqLworI2RlZmluZSBHTUFDX01JSV9BRERSX1dSSVRFCTB4MDAwMDAwMDIJLyogTUlJIFdyaXRlICovCisjZGVmaW5lIEdNQUNfTUlJX0FERFJfQlVTWQkweDAwMDAwMDAxCS8qIE1JSSBCdXN5ICovCisvKiBHTUFDIEZMT1cgQ1RSTCBkZWZpbmVzICovCisjZGVmaW5lIEdNQUNfRkxPV19DVFJMX1BUX01BU0sJMHhmZmZmMDAwMAkvKiBQYXVzZSBUaW1lIE1hc2sgKi8KKyNkZWZpbmUgR01BQ19GTE9XX0NUUkxfUFRfU0hJRlQJMTYKKyNkZWZpbmUgR01BQ19GTE9XX0NUUkxfUkZFCTB4MDAwMDAwMDQJLyogUnggRmxvdyBDb250cm9sIEVuYWJsZSAqLworI2RlZmluZSBHTUFDX0ZMT1dfQ1RSTF9URkUJMHgwMDAwMDAwMgkvKiBUeCBGbG93IENvbnRyb2wgRW5hYmxlICovCisjZGVmaW5lIEdNQUNfRkxPV19DVFJMX0ZDQl9CUEEJMHgwMDAwMDAwMQkvKiBGbG93IENvbnRyb2wgQnVzeSAuLi4gKi8KKworLyotLS0gRE1BIEJMT0NLIGRlZmluZXMgLS0tKi8KKy8qIERNQSBCdXMgTW9kZSByZWdpc3RlciBkZWZpbmVzICovCisjZGVmaW5lIERNQV9CVVNfTU9ERV9TRlRfUkVTRVQJMHgwMDAwMDAwMQkvKiBTb2Z0d2FyZSBSZXNldCAqLworI2RlZmluZSBETUFfQlVTX01PREVfREEJCTB4MDAwMDAwMDIJLyogQXJiaXRyYXRpb24gc2NoZW1lICovCisjZGVmaW5lIERNQV9CVVNfTU9ERV9EU0xfTUFTSwkweDAwMDAwMDdjCS8qIERlc2NyaXB0b3IgU2tpcCBMZW5ndGggKi8KKyNkZWZpbmUgRE1BX0JVU19NT0RFX0RTTF9TSElGVAkyCS8qICAgKGluIERXT1JEUykgICAgICAqLworLyogUHJvZ3JhbW1hYmxlIGJ1cnN0IGxlbmd0aCAocGFzc2VkIHRob3J1Z2ggcGxhdGZvcm0pKi8KKyNkZWZpbmUgRE1BX0JVU19NT0RFX1BCTF9NQVNLCTB4MDAwMDNmMDAJLyogUHJvZ3JhbW1hYmxlIEJ1cnN0IExlbiAqLworI2RlZmluZSBETUFfQlVTX01PREVfUEJMX1NISUZUCTgKKworZW51bSByeF90eF9wcmlvcml0eV9yYXRpbyB7CisJZG91YmxlX3JhdGlvID0gMHgwMDAwNDAwMCwJLyoyOjEgKi8KKwl0cmlwbGVfcmF0aW8gPSAweDAwMDA4MDAwLAkvKjM6MSAqLworCXF1YWRydXBsZV9yYXRpbyA9IDB4MDAwMGMwMDAsCS8qNDoxICovCit9OworCisjZGVmaW5lIERNQV9CVVNfTU9ERV9GQgkJMHgwMDAxMDAwMAkvKiBGaXhlZCBidXJzdCAqLworI2RlZmluZSBETUFfQlVTX01PREVfUlBCTF9NQVNLCTB4MDAzZTAwMDAJLyogUngtUHJvZ3JhbW1hYmxlIEJ1cnN0IExlbiAqLworI2RlZmluZSBETUFfQlVTX01PREVfUlBCTF9TSElGVAkxNworI2RlZmluZSBETUFfQlVTX01PREVfVVNQCTB4MDA4MDAwMDAKKyNkZWZpbmUgRE1BX0JVU19NT0RFXzRQQkwJMHgwMTAwMDAwMAorI2RlZmluZSBETUFfQlVTX01PREVfQUFMCTB4MDIwMDAwMDAKKworLyogRE1BIENSUyBDb250cm9sIGFuZCBTdGF0dXMgUmVnaXN0ZXIgTWFwcGluZyAqLworI2RlZmluZSBETUFfSE9TVF9UWF9ERVNDCSAgMHgwMDAwMTA0OAkvKiBDdXJyZW50IEhvc3QgVHggZGVzY3JpcHRvciAqLworI2RlZmluZSBETUFfSE9TVF9SWF9ERVNDCSAgMHgwMDAwMTA0YwkvKiBDdXJyZW50IEhvc3QgUnggZGVzY3JpcHRvciAqLworLyogIERNQSBCdXMgTW9kZSByZWdpc3RlciBkZWZpbmVzICovCisjZGVmaW5lIERNQV9CVVNfUFJfUkFUSU9fTUFTSwkgIDB4MDAwMGMwMDAJLyogUngvVHggcHJpb3JpdHkgcmF0aW8gKi8KKyNkZWZpbmUgRE1BX0JVU19QUl9SQVRJT19TSElGVAkgIDE0CisjZGVmaW5lIERNQV9CVVNfRkIJICAJICAweDAwMDEwMDAwCS8qIEZpeGVkIEJ1cnN0ICovCisKKy8qIERNQSBvcGVyYXRpb24gbW9kZSBkZWZpbmVzIChzdGFydC9zdG9wIHR4L3J4IGFyZSBwbGFjZWQgaW4gY29tbW9uIGhlYWRlcikqLworI2RlZmluZSBETUFfQ09OVFJPTF9EVAkJMHgwNDAwMDAwMCAvKiBEaXNhYmxlIERyb3AgVENQL0lQIGNzdW0gZXJyb3IgKi8KKyNkZWZpbmUgRE1BX0NPTlRST0xfUlNGCQkweDAyMDAwMDAwIC8qIFJlY2VpdmUgU3RvcmUgYW5kIEZvcndhcmQgKi8KKyNkZWZpbmUgRE1BX0NPTlRST0xfREZGCQkweDAxMDAwMDAwIC8qIERpc2FhYmxlIGZsdXNoaW5nICovCisvKiBUaGVzaG9sZCBmb3IgQWN0aXZhdGluZyB0aGUgRkMgKi8KK2VudW0gcmZhIHsKKwlhY3RfZnVsbF9taW51c18xID0gMHgwMDgwMDAwMCwKKwlhY3RfZnVsbF9taW51c18yID0gMHgwMDgwMDIwMCwKKwlhY3RfZnVsbF9taW51c18zID0gMHgwMDgwMDQwMCwKKwlhY3RfZnVsbF9taW51c180ID0gMHgwMDgwMDYwMCwKK307CisvKiBUaGVzaG9sZCBmb3IgRGVhY3RpdmF0aW5nIHRoZSBGQyAqLworZW51bSByZmQgeworCWRlYWNfZnVsbF9taW51c18xID0gMHgwMDQwMDAwMCwKKwlkZWFjX2Z1bGxfbWludXNfMiA9IDB4MDA0MDA4MDAsCisJZGVhY19mdWxsX21pbnVzXzMgPSAweDAwNDAxMDAwLAorCWRlYWNfZnVsbF9taW51c180ID0gMHgwMDQwMTgwMCwKK307CisjZGVmaW5lIERNQV9DT05UUk9MX1RTRgkJMHgwMDIwMDAwMCAvKiBUcmFuc21pdCAgU3RvcmUgYW5kIEZvcndhcmQgKi8KKyNkZWZpbmUgRE1BX0NPTlRST0xfRlRGCQkweDAwMTAwMDAwIC8qIEZsdXNoIHRyYW5zbWl0IEZJRk8gKi8KKworZW51bSB0dGNfY29udHJvbCB7CisJRE1BX0NPTlRST0xfVFRDXzY0ID0gMHgwMDAwMDAwMCwKKwlETUFfQ09OVFJPTF9UVENfMTI4ID0gMHgwMDAwNDAwMCwKKwlETUFfQ09OVFJPTF9UVENfMTkyID0gMHgwMDAwODAwMCwKKwlETUFfQ09OVFJPTF9UVENfMjU2ID0gMHgwMDAwYzAwMCwKKwlETUFfQ09OVFJPTF9UVENfNDAgPSAweDAwMDEwMDAwLAorCURNQV9DT05UUk9MX1RUQ18zMiA9IDB4MDAwMTQwMDAsCisJRE1BX0NPTlRST0xfVFRDXzI0ID0gMHgwMDAxODAwMCwKKwlETUFfQ09OVFJPTF9UVENfMTYgPSAweDAwMDFjMDAwLAorfTsKKyNkZWZpbmUgRE1BX0NPTlRST0xfVENfVFhfTUFTSwkweGZmZmUzZmZmCisKKyNkZWZpbmUgRE1BX0NPTlRST0xfRUZDCQkweDAwMDAwMTAwCisjZGVmaW5lIERNQV9DT05UUk9MX0ZFRgkJMHgwMDAwMDA4MAorI2RlZmluZSBETUFfQ09OVFJPTF9GVUYJCTB4MDAwMDAwNDAKKworZW51bSBydGNfY29udHJvbCB7CisJRE1BX0NPTlRST0xfUlRDXzY0ID0gMHgwMDAwMDAwMCwKKwlETUFfQ09OVFJPTF9SVENfMzIgPSAweDAwMDAwMDA4LAorCURNQV9DT05UUk9MX1JUQ185NiA9IDB4MDAwMDAwMTAsCisJRE1BX0NPTlRST0xfUlRDXzEyOCA9IDB4MDAwMDAwMTgsCit9OworI2RlZmluZSBETUFfQ09OVFJPTF9UQ19SWF9NQVNLCTB4ZmZmZmZmZTcKKworI2RlZmluZSBETUFfQ09OVFJPTF9PU0YJMHgwMDAwMDAwNAkvKiBPcGVyYXRlIG9uIHNlY29uZCBmcmFtZSAqLworCisvKiBNTUMgcmVnaXN0ZXJzIG9mZnNldCAqLworI2RlZmluZSBHTUFDX01NQ19DVFJMICAgICAgMHgxMDAKKyNkZWZpbmUgR01BQ19NTUNfUlhfSU5UUiAgIDB4MTA0CisjZGVmaW5lIEdNQUNfTU1DX1RYX0lOVFIgICAweDEwOAorI2RlZmluZSBHTUFDX01NQ19SWF9DU1VNX09GRkxPQUQgICAweDIwOApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL21hYzEwMC5jIGIvZHJpdmVycy9uZXQvc3RtbWFjL21hYzEwMC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjYyNTE3MWIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9zdG1tYWMvbWFjMTAwLmMKQEAgLTAsMCArMSw1MTcgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgIFRoaXMgaXMgdGhlIGRyaXZlciBmb3IgdGhlIE1BQyAxMC8xMDAgb24tY2hpcCBFdGhlcm5ldCBjb250cm9sbGVyCisgIGN1cnJlbnRseSB0ZXN0ZWQgb24gYWxsIHRoZSBTVCBib2FyZHMgYmFzZWQgb24gU1RiNzEwOSBhbmQgc3R4NzIwMCBTb0NzLgorCisgIERXQyBFdGhlciBNQUMgMTAvMTAwIFVuaXZlcnNhbCB2ZXJzaW9uIDQuMCBoYXMgYmVlbiB1c2VkIGZvciBkZXZlbG9waW5nCisgIHRoaXMgY29kZS4KKworICBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOSAgU1RNaWNyb2VsZWN0cm9uaWNzIEx0ZAorCisgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgIHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsCisgIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisKKyAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IKKyAgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvcgorICBtb3JlIGRldGFpbHMuCisKKyAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxvbmcgd2l0aAorICB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKKyAgNTEgRnJhbmtsaW4gU3QgLSBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQS4KKworICBUaGUgZnVsbCBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBpcyBpbmNsdWRlZCBpbiB0aGlzIGRpc3RyaWJ1dGlvbiBpbgorICB0aGUgZmlsZSBjYWxsZWQgIkNPUFlJTkciLgorCisgIEF1dGhvcjogR2l1c2VwcGUgQ2F2YWxsYXJvIDxwZXBwZS5jYXZhbGxhcm9Ac3QuY29tPgorKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2NyYzMyLmg+CisjaW5jbHVkZSA8bGludXgvbWlpLmg+CisjaW5jbHVkZSA8bGludXgvcGh5Lmg+CisKKyNpbmNsdWRlICJjb21tb24uaCIKKyNpbmNsdWRlICJtYWMxMDAuaCIKKworI3VuZGVmIE1BQzEwMF9ERUJVRworLyojZGVmaW5lIE1BQzEwMF9ERUJVRyovCisjaWZkZWYgTUFDMTAwX0RFQlVHCisjZGVmaW5lIERCRyhmbXQsIGFyZ3MuLi4pICBwcmludGsoZm10LCAjIyBhcmdzKQorI2Vsc2UKKyNkZWZpbmUgREJHKGZtdCwgYXJncy4uLikgIGRvIHsgfSB3aGlsZSAoMCkKKyNlbmRpZgorCitzdGF0aWMgdm9pZCBtYWMxMDBfY29yZV9pbml0KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIE1BQ19DT05UUk9MKTsKKworCXdyaXRlbCgodmFsdWUgfCBNQUNfQ09SRV9JTklUKSwgaW9hZGRyICsgTUFDX0NPTlRST0wpOworCisjaWZkZWYgU1RNTUFDX1ZMQU5fVEFHX1VTRUQKKwl3cml0ZWwoRVRIX1BfODAyMVEsIGlvYWRkciArIE1BQ19WTEFOMSk7CisjZW5kaWYKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9kdW1wX21hY19yZWdzKHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXByX2luZm8oIlx0LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLVxuIgorCSAgICAgICAiXHQgIE1BQzEwMCBDU1IgKGJhc2UgYWRkciA9IDB4JTh4KVxuIgorCSAgICAgICAiXHQtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tXG4iLAorCSAgICAgICAodW5zaWduZWQgaW50KWlvYWRkcik7CisJcHJfaW5mbygiXHRjb250cm9sIHJlZyAob2Zmc2V0IDB4JXgpOiAweCUwOHhcbiIsIE1BQ19DT05UUk9MLAorCSAgICAgICByZWFkbChpb2FkZHIgKyBNQUNfQ09OVFJPTCkpOworCXByX2luZm8oIlx0YWRkciBISSAob2Zmc2V0IDB4JXgpOiAweCUwOHhcbiAiLCBNQUNfQUREUl9ISUdILAorCSAgICAgICByZWFkbChpb2FkZHIgKyBNQUNfQUREUl9ISUdIKSk7CisJcHJfaW5mbygiXHRhZGRyIExPIChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwgTUFDX0FERFJfTE9XLAorCSAgICAgICByZWFkbChpb2FkZHIgKyBNQUNfQUREUl9MT1cpKTsKKwlwcl9pbmZvKCJcdG11bHRpY2FzdCBoYXNoIEhJIChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwKKwkJCU1BQ19IQVNIX0hJR0gsIHJlYWRsKGlvYWRkciArIE1BQ19IQVNIX0hJR0gpKTsKKwlwcl9pbmZvKCJcdG11bHRpY2FzdCBoYXNoIExPIChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwKKwkJCU1BQ19IQVNIX0xPVywgcmVhZGwoaW9hZGRyICsgTUFDX0hBU0hfTE9XKSk7CisJcHJfaW5mbygiXHRmbG93IGNvbnRyb2wgKG9mZnNldCAweCV4KTogMHglMDh4XG4iLAorCQlNQUNfRkxPV19DVFJMLCByZWFkbChpb2FkZHIgKyBNQUNfRkxPV19DVFJMKSk7CisJcHJfaW5mbygiXHRWTEFOMSB0YWcgKG9mZnNldCAweCV4KTogMHglMDh4XG4iLCBNQUNfVkxBTjEsCisJICAgICAgIHJlYWRsKGlvYWRkciArIE1BQ19WTEFOMSkpOworCXByX2luZm8oIlx0VkxBTjIgdGFnIChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwgTUFDX1ZMQU4yLAorCSAgICAgICByZWFkbChpb2FkZHIgKyBNQUNfVkxBTjIpKTsKKwlwcl9pbmZvKCJcblx0TUFDIG1hbmFnZW1lbnQgY291bnRlciByZWdpc3RlcnNcbiIpOworCXByX2luZm8oIlx0IE1NQyBjcnRsIChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwKKwkgICAgICAgTU1DX0NPTlRST0wsIHJlYWRsKGlvYWRkciArIE1NQ19DT05UUk9MKSk7CisJcHJfaW5mbygiXHQgTU1DIEhpZ2ggSW50ZXJydXB0IChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwKKwkgICAgICAgTU1DX0hJR0hfSU5UUiwgcmVhZGwoaW9hZGRyICsgTU1DX0hJR0hfSU5UUikpOworCXByX2luZm8oIlx0IE1NQyBMb3cgSW50ZXJydXB0IChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwKKwkgICAgICAgTU1DX0xPV19JTlRSLCByZWFkbChpb2FkZHIgKyBNTUNfTE9XX0lOVFIpKTsKKwlwcl9pbmZvKCJcdCBNTUMgSGlnaCBJbnRlcnJ1cHQgTWFzayAob2Zmc2V0IDB4JXgpOiAweCUwOHhcbiIsCisJICAgICAgIE1NQ19ISUdIX0lOVFJfTUFTSywgcmVhZGwoaW9hZGRyICsgTU1DX0hJR0hfSU5UUl9NQVNLKSk7CisJcHJfaW5mbygiXHQgTU1DIExvdyBJbnRlcnJ1cHQgTWFzayAob2Zmc2V0IDB4JXgpOiAweCUwOHhcbiIsCisJICAgICAgIE1NQ19MT1dfSU5UUl9NQVNLLCByZWFkbChpb2FkZHIgKyBNTUNfTE9XX0lOVFJfTUFTSykpOworCXJldHVybjsKK30KKworc3RhdGljIGludCBtYWMxMDBfZG1hX2luaXQodW5zaWduZWQgbG9uZyBpb2FkZHIsIGludCBwYmwsIHUzMiBkbWFfdHgsCisJCQkgICB1MzIgZG1hX3J4KQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIERNQV9CVVNfTU9ERSk7CisJLyogRE1BIFNXIHJlc2V0ICovCisJdmFsdWUgfD0gRE1BX0JVU19NT0RFX1NGVF9SRVNFVDsKKwl3cml0ZWwodmFsdWUsIGlvYWRkciArIERNQV9CVVNfTU9ERSk7CisJZG8ge30gd2hpbGUgKChyZWFkbChpb2FkZHIgKyBETUFfQlVTX01PREUpICYgRE1BX0JVU19NT0RFX1NGVF9SRVNFVCkpOworCisJLyogRW5hYmxlIEFwcGxpY2F0aW9uIEFjY2VzcyBieSB3cml0aW5nIHRvIERNQSBDU1IwICovCisJd3JpdGVsKERNQV9CVVNfTU9ERV9ERUZBVUxUIHwgKHBibCA8PCBETUFfQlVTX01PREVfUEJMX1NISUZUKSwKKwkgICAgICAgaW9hZGRyICsgRE1BX0JVU19NT0RFKTsKKworCS8qIE1hc2sgaW50ZXJydXB0cyBieSB3cml0aW5nIHRvIENTUjcgKi8KKwl3cml0ZWwoRE1BX0lOVFJfREVGQVVMVF9NQVNLLCBpb2FkZHIgKyBETUFfSU5UUl9FTkEpOworCisJLyogVGhlIGJhc2UgYWRkcmVzcyBvZiB0aGUgUlgvVFggZGVzY3JpcHRvciBsaXN0cyBtdXN0IGJlIHdyaXR0ZW4gaW50bworCSAqIERNQSBDU1IzIGFuZCBDU1I0LCByZXNwZWN0aXZlbHkuICovCisJd3JpdGVsKGRtYV90eCwgaW9hZGRyICsgRE1BX1RYX0JBU0VfQUREUik7CisJd3JpdGVsKGRtYV9yeCwgaW9hZGRyICsgRE1BX1JDVl9CQVNFX0FERFIpOworCisJcmV0dXJuIDA7Cit9CisKKy8qIFN0b3JlIGFuZCBGb3J3YXJkIGNhcGFiaWxpdHkgaXMgbm90IHVzZWQgYXQgYWxsLi4KKyAqIFRoZSB0cmFuc21pdCB0aHJlc2hvbGQgY2FuIGJlIHByb2dyYW1tZWQgYnkKKyAqIHNldHRpbmcgdGhlIFRUQyBiaXRzIGluIHRoZSBETUEgY29udHJvbCByZWdpc3Rlci4qLworc3RhdGljIHZvaWQgbWFjMTAwX2RtYV9vcGVyYXRpb25fbW9kZSh1bnNpZ25lZCBsb25nIGlvYWRkciwgaW50IHR4bW9kZSwKKwkJCQkgICAgICBpbnQgcnhtb2RlKQoreworCXUzMiBjc3I2ID0gcmVhZGwoaW9hZGRyICsgRE1BX0NPTlRST0wpOworCisJaWYgKHR4bW9kZSA8PSAzMikKKwkJY3NyNiB8PSBETUFfQ09OVFJPTF9UVENfMzI7CisJZWxzZSBpZiAodHhtb2RlIDw9IDY0KQorCQljc3I2IHw9IERNQV9DT05UUk9MX1RUQ182NDsKKwllbHNlCisJCWNzcjYgfD0gRE1BX0NPTlRST0xfVFRDXzEyODsKKworCXdyaXRlbChjc3I2LCBpb2FkZHIgKyBETUFfQ09OVFJPTCk7CisKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9kdW1wX2RtYV9yZWdzKHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCWludCBpOworCisJREJHKEtFUk5fREVCVUcgIk1BQzEwMCBETUEgQ1NSIFxuIik7CisJZm9yIChpID0gMDsgaSA8IDk7IGkrKykKKwkJcHJfZGVidWcoIlx0IENTUiVkIChvZmZzZXQgMHgleCk6IDB4JTA4eFxuIiwgaSwKKwkJICAgICAgIChETUFfQlVTX01PREUgKyBpICogNCksCisJCSAgICAgICByZWFkbChpb2FkZHIgKyBETUFfQlVTX01PREUgKyBpICogNCkpOworCURCRyhLRVJOX0RFQlVHICJcdCBDU1IyMCAob2Zmc2V0IDB4JXgpOiAweCUwOHhcbiIsCisJICAgIERNQV9DVVJfVFhfQlVGX0FERFIsIHJlYWRsKGlvYWRkciArIERNQV9DVVJfVFhfQlVGX0FERFIpKTsKKwlEQkcoS0VSTl9ERUJVRyAiXHQgQ1NSMjEgKG9mZnNldCAweCV4KTogMHglMDh4XG4iLAorCSAgICBETUFfQ1VSX1JYX0JVRl9BRERSLCByZWFkbChpb2FkZHIgKyBETUFfQ1VSX1JYX0JVRl9BRERSKSk7CisJcmV0dXJuOworfQorCisvKiBETUEgY29udHJvbGxlciBoYXMgdHdvIGNvdW50ZXJzIHRvIHRyYWNrIHRoZSBudW1iZXIgb2YKKyAgIHRoZSByZWNlaXZlIG1pc3NlZCBmcmFtZXMuICovCitzdGF0aWMgdm9pZCBtYWMxMDBfZG1hX2RpYWdub3N0aWNfZnIodm9pZCAqZGF0YSwgc3RydWN0IHN0bW1hY19leHRyYV9zdGF0cyAqeCwKKwkJCQkgICAgIHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICpzdGF0cyA9IChzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqKWRhdGE7CisJdTMyIGNzcjggPSByZWFkbChpb2FkZHIgKyBETUFfTUlTU0VEX0ZSQU1FX0NUUik7CisKKwlpZiAodW5saWtlbHkoY3NyOCkpIHsKKwkJaWYgKGNzcjggJiBETUFfTUlTU0VEX0ZSQU1FX09WRSkgeworCQkJc3RhdHMtPnJ4X292ZXJfZXJyb3JzICs9IDB4ODAwOworCQkJeC0+cnhfb3ZlcmZsb3dfY250ciArPSAweDgwMDsKKwkJfSBlbHNlIHsKKwkJCXVuc2lnbmVkIGludCBvdmVfY250cjsKKwkJCW92ZV9jbnRyID0gKChjc3I4ICYgRE1BX01JU1NFRF9GUkFNRV9PVkVfQ05UUikgPj4gMTcpOworCQkJc3RhdHMtPnJ4X292ZXJfZXJyb3JzICs9IG92ZV9jbnRyOworCQkJeC0+cnhfb3ZlcmZsb3dfY250ciArPSBvdmVfY250cjsKKwkJfQorCisJCWlmIChjc3I4ICYgRE1BX01JU1NFRF9GUkFNRV9PVkVfTSkgeworCQkJc3RhdHMtPnJ4X21pc3NlZF9lcnJvcnMgKz0gMHhmZmZmOworCQkJeC0+cnhfbWlzc2VkX2NudHIgKz0gMHhmZmZmOworCQl9IGVsc2UgeworCQkJdW5zaWduZWQgaW50IG1pc3NfZiA9IChjc3I4ICYgRE1BX01JU1NFRF9GUkFNRV9NX0NOVFIpOworCQkJc3RhdHMtPnJ4X21pc3NlZF9lcnJvcnMgKz0gbWlzc19mOworCQkJeC0+cnhfbWlzc2VkX2NudHIgKz0gbWlzc19mOworCQl9CisJfQorCXJldHVybjsKK30KKworc3RhdGljIGludCBtYWMxMDBfZ2V0X3R4X2ZyYW1lX3N0YXR1cyh2b2lkICpkYXRhLCBzdHJ1Y3Qgc3RtbWFjX2V4dHJhX3N0YXRzICp4LAorCQkJCSAgICAgIHN0cnVjdCBkbWFfZGVzYyAqcCwgdW5zaWduZWQgbG9uZyBpb2FkZHIpCit7CisJaW50IHJldCA9IDA7CisJc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKnN0YXRzID0gKHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICopZGF0YTsKKworCWlmICh1bmxpa2VseShwLT5kZXMwMS50eC5lcnJvcl9zdW1tYXJ5KSkgeworCQlpZiAodW5saWtlbHkocC0+ZGVzMDEudHgudW5kZXJmbG93X2Vycm9yKSkgeworCQkJeC0+dHhfdW5kZXJmbG93Kys7CisJCQlzdGF0cy0+dHhfZmlmb19lcnJvcnMrKzsKKwkJfQorCQlpZiAodW5saWtlbHkocC0+ZGVzMDEudHgubm9fY2FycmllcikpIHsKKwkJCXgtPnR4X2NhcnJpZXIrKzsKKwkJCXN0YXRzLT50eF9jYXJyaWVyX2Vycm9ycysrOworCQl9CisJCWlmICh1bmxpa2VseShwLT5kZXMwMS50eC5sb3NzX2NhcnJpZXIpKSB7CisJCQl4LT50eF9sb3NzY2FycmllcisrOworCQkJc3RhdHMtPnR4X2NhcnJpZXJfZXJyb3JzKys7CisJCX0KKwkJaWYgKHVubGlrZWx5KChwLT5kZXMwMS50eC5leGNlc3NpdmVfZGVmZXJyYWwpIHx8CisJCQkgICAgIChwLT5kZXMwMS50eC5leGNlc3NpdmVfY29sbGlzaW9ucykgfHwKKwkJCSAgICAgKHAtPmRlczAxLnR4LmxhdGVfY29sbGlzaW9uKSkpCisJCQlzdGF0cy0+Y29sbGlzaW9ucyArPSBwLT5kZXMwMS50eC5jb2xsaXNpb25fY291bnQ7CisJCXJldCA9IC0xOworCX0KKwlpZiAodW5saWtlbHkocC0+ZGVzMDEudHguaGVhcnRiZWF0X2ZhaWwpKSB7CisJCXgtPnR4X2hlYXJ0YmVhdCsrOworCQlzdGF0cy0+dHhfaGVhcnRiZWF0X2Vycm9ycysrOworCQlyZXQgPSAtMTsKKwl9CisJaWYgKHVubGlrZWx5KHAtPmRlczAxLnR4LmRlZmVycmVkKSkKKwkJeC0+dHhfZGVmZXJyZWQrKzsKKworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgbWFjMTAwX2dldF90eF9sZW4oc3RydWN0IGRtYV9kZXNjICpwKQoreworCXJldHVybiBwLT5kZXMwMS50eC5idWZmZXIxX3NpemU7Cit9CisKKy8qIFRoaXMgZnVuY3Rpb24gdmVyaWZpZXMgaWYgZWFjaCBpbmNvbWluZyBmcmFtZSBoYXMgc29tZSBlcnJvcnMKKyAqIGFuZCwgaWYgcmVxdWlyZWQsIHVwZGF0ZXMgdGhlIG11bHRpY2FzdCBzdGF0aXN0aWNzLgorICogSW4gY2FzZSBvZiBzdWNjZXNzLCBpdCByZXR1cm5zIGNzdW1fbm9uZSBiZWNhc3VlIHRoZSBkZXZpY2UKKyAqIGlzIG5vdCBhYmxlIHRvIGNvbXB1dGUgdGhlIGNzdW0gaW4gSFcuICovCitzdGF0aWMgaW50IG1hYzEwMF9nZXRfcnhfZnJhbWVfc3RhdHVzKHZvaWQgKmRhdGEsIHN0cnVjdCBzdG1tYWNfZXh0cmFfc3RhdHMgKngsCisJCQkJICAgICAgc3RydWN0IGRtYV9kZXNjICpwKQoreworCWludCByZXQgPSBjc3VtX25vbmU7CisJc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKnN0YXRzID0gKHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzICopZGF0YTsKKworCWlmICh1bmxpa2VseShwLT5kZXMwMS5yeC5sYXN0X2Rlc2NyaXB0b3IgPT0gMCkpIHsKKwkJcHJfd2FybmluZygibWFjMTAwIEVycm9yOiBPdmVyc2l6ZWQgRXRoZXJuZXQgIgorCQkJICAgImZyYW1lIHNwYW5uZWQgbXVsdGlwbGUgYnVmZmVyc1xuIik7CisJCXN0YXRzLT5yeF9sZW5ndGhfZXJyb3JzKys7CisJCXJldHVybiBkaXNjYXJkX2ZyYW1lOworCX0KKworCWlmICh1bmxpa2VseShwLT5kZXMwMS5yeC5lcnJvcl9zdW1tYXJ5KSkgeworCQlpZiAodW5saWtlbHkocC0+ZGVzMDEucnguZGVzY3JpcHRvcl9lcnJvcikpCisJCQl4LT5yeF9kZXNjKys7CisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5yeC5wYXJ0aWFsX2ZyYW1lX2Vycm9yKSkKKwkJCXgtPnJ4X3BhcnRpYWwrKzsKKwkJaWYgKHVubGlrZWx5KHAtPmRlczAxLnJ4LnJ1bl9mcmFtZSkpCisJCQl4LT5yeF9ydW50Kys7CisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5yeC5mcmFtZV90b29fbG9uZykpCisJCQl4LT5yeF90b29sb25nKys7CisJCWlmICh1bmxpa2VseShwLT5kZXMwMS5yeC5jb2xsaXNpb24pKSB7CisJCQl4LT5yeF9jb2xsaXNpb24rKzsKKwkJCXN0YXRzLT5jb2xsaXNpb25zKys7CisJCX0KKwkJaWYgKHVubGlrZWx5KHAtPmRlczAxLnJ4LmNyY19lcnJvcikpIHsKKwkJCXgtPnJ4X2NyYysrOworCQkJc3RhdHMtPnJ4X2NyY19lcnJvcnMrKzsKKwkJfQorCQlyZXQgPSBkaXNjYXJkX2ZyYW1lOworCX0KKwlpZiAodW5saWtlbHkocC0+ZGVzMDEucnguZHJpYmJsaW5nKSkKKwkJcmV0ID0gZGlzY2FyZF9mcmFtZTsKKworCWlmICh1bmxpa2VseShwLT5kZXMwMS5yeC5sZW5ndGhfZXJyb3IpKSB7CisJCXgtPnJ4X2xlbmdodCsrOworCQlyZXQgPSBkaXNjYXJkX2ZyYW1lOworCX0KKwlpZiAodW5saWtlbHkocC0+ZGVzMDEucngubWlpX2Vycm9yKSkgeworCQl4LT5yeF9taWkrKzsKKwkJcmV0ID0gZGlzY2FyZF9mcmFtZTsKKwl9CisJaWYgKHAtPmRlczAxLnJ4Lm11bHRpY2FzdF9mcmFtZSkgeworCQl4LT5yeF9tdWx0aWNhc3QrKzsKKwkJc3RhdHMtPm11bHRpY2FzdCsrOworCX0KKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBtYWMxMDBfaXJxX3N0YXR1cyh1bnNpZ25lZCBsb25nIGlvYWRkcikKK3sKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9zZXRfdW1hY19hZGRyKHVuc2lnbmVkIGxvbmcgaW9hZGRyLCB1bnNpZ25lZCBjaGFyICphZGRyLAorCQkJICB1bnNpZ25lZCBpbnQgcmVnX24pCit7CisJc3RtbWFjX3NldF9tYWNfYWRkcihpb2FkZHIsIGFkZHIsIE1BQ19BRERSX0hJR0gsIE1BQ19BRERSX0xPVyk7Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9nZXRfdW1hY19hZGRyKHVuc2lnbmVkIGxvbmcgaW9hZGRyLCB1bnNpZ25lZCBjaGFyICphZGRyLAorCQkJICB1bnNpZ25lZCBpbnQgcmVnX24pCit7CisJc3RtbWFjX2dldF9tYWNfYWRkcihpb2FkZHIsIGFkZHIsIE1BQ19BRERSX0hJR0gsIE1BQ19BRERSX0xPVyk7Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9zZXRfZmlsdGVyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJdW5zaWduZWQgbG9uZyBpb2FkZHIgPSBkZXYtPmJhc2VfYWRkcjsKKwl1MzIgdmFsdWUgPSByZWFkbChpb2FkZHIgKyBNQUNfQ09OVFJPTCk7CisKKwlpZiAoZGV2LT5mbGFncyAmIElGRl9QUk9NSVNDKSB7CisJCXZhbHVlIHw9IE1BQ19DT05UUk9MX1BSOworCQl2YWx1ZSAmPSB+KE1BQ19DT05UUk9MX1BNIHwgTUFDX0NPTlRST0xfSUYgfCBNQUNfQ09OVFJPTF9ITyB8CisJCQkgICBNQUNfQ09OVFJPTF9IUCk7CisJfSBlbHNlIGlmICgoZGV2LT5tY19jb3VudCA+IEhBU0hfVEFCTEVfU0laRSkKKwkJICAgfHwgKGRldi0+ZmxhZ3MgJiBJRkZfQUxMTVVMVEkpKSB7CisJCXZhbHVlIHw9IE1BQ19DT05UUk9MX1BNOworCQl2YWx1ZSAmPSB+KE1BQ19DT05UUk9MX1BSIHwgTUFDX0NPTlRST0xfSUYgfCBNQUNfQ09OVFJPTF9ITyk7CisJCXdyaXRlbCgweGZmZmZmZmZmLCBpb2FkZHIgKyBNQUNfSEFTSF9ISUdIKTsKKwkJd3JpdGVsKDB4ZmZmZmZmZmYsIGlvYWRkciArIE1BQ19IQVNIX0xPVyk7CisJfSBlbHNlIGlmIChkZXYtPm1jX2NvdW50ID09IDApIHsJLyogbm8gbXVsdGljYXN0ICovCisJCXZhbHVlICY9IH4oTUFDX0NPTlRST0xfUE0gfCBNQUNfQ09OVFJPTF9QUiB8IE1BQ19DT05UUk9MX0lGIHwKKwkJCSAgIE1BQ19DT05UUk9MX0hPIHwgTUFDX0NPTlRST0xfSFApOworCX0gZWxzZSB7CisJCWludCBpOworCQl1MzIgbWNfZmlsdGVyWzJdOworCQlzdHJ1Y3QgZGV2X21jX2xpc3QgKm1jbGlzdDsKKworCQkvKiBQZXJmZWN0IGZpbHRlciBtb2RlIGZvciBwaHlzaWNhbCBhZGRyZXNzIGFuZCBIYXNoCisJCSAgIGZpbHRlciBmb3IgbXVsdGljYXN0ICovCisJCXZhbHVlIHw9IE1BQ19DT05UUk9MX0hQOworCQl2YWx1ZSAmPSB+KE1BQ19DT05UUk9MX1BNIHwgTUFDX0NPTlRST0xfUFIgfCBNQUNfQ09OVFJPTF9JRgorCQkJICAgfCBNQUNfQ09OVFJPTF9ITyk7CisKKwkJbWVtc2V0KG1jX2ZpbHRlciwgMCwgc2l6ZW9mKG1jX2ZpbHRlcikpOworCQlmb3IgKGkgPSAwLCBtY2xpc3QgPSBkZXYtPm1jX2xpc3Q7CisJCSAgICAgbWNsaXN0ICYmIGkgPCBkZXYtPm1jX2NvdW50OyBpKyssIG1jbGlzdCA9IG1jbGlzdC0+bmV4dCkgeworCQkJLyogVGhlIHVwcGVyIDYgYml0cyBvZiB0aGUgY2FsY3VsYXRlZCBDUkMgYXJlIHVzZWQgdG8KKwkJCSAqIGluZGV4IHRoZSBjb250ZW5zIG9mIHRoZSBoYXNoIHRhYmxlICovCisJCQlpbnQgYml0X25yID0KKwkJCSAgICBldGhlcl9jcmMoRVRIX0FMRU4sIG1jbGlzdC0+ZG1pX2FkZHIpID4+IDI2OworCQkJLyogVGhlIG1vc3Qgc2lnbmlmaWNhbnQgYml0IGRldGVybWluZXMgdGhlIHJlZ2lzdGVyIHRvCisJCQkgKiB1c2UgKEgvTCkgd2hpbGUgdGhlIG90aGVyIDUgYml0cyBkZXRlcm1pbmUgdGhlIGJpdAorCQkJICogd2l0aGluIHRoZSByZWdpc3Rlci4gKi8KKwkJCW1jX2ZpbHRlcltiaXRfbnIgPj4gNV0gfD0gMSA8PCAoYml0X25yICYgMzEpOworCQl9CisJCXdyaXRlbChtY19maWx0ZXJbMF0sIGlvYWRkciArIE1BQ19IQVNIX0xPVyk7CisJCXdyaXRlbChtY19maWx0ZXJbMV0sIGlvYWRkciArIE1BQ19IQVNIX0hJR0gpOworCX0KKworCXdyaXRlbCh2YWx1ZSwgaW9hZGRyICsgTUFDX0NPTlRST0wpOworCisJREJHKEtFUk5fSU5GTyAiJXM6IENUUkwgcmVnOiAweCUwOHggSGFzaCByZWdzOiAiCisJICAgICJISSAweCUwOHgsIExPIDB4JTA4eFxuIiwKKwkgICAgX19mdW5jX18sIHJlYWRsKGlvYWRkciArIE1BQ19DT05UUk9MKSwKKwkgICAgcmVhZGwoaW9hZGRyICsgTUFDX0hBU0hfSElHSCksIHJlYWRsKGlvYWRkciArIE1BQ19IQVNIX0xPVykpOworCXJldHVybjsKK30KKworc3RhdGljIHZvaWQgbWFjMTAwX2Zsb3dfY3RybCh1bnNpZ25lZCBsb25nIGlvYWRkciwgdW5zaWduZWQgaW50IGR1cGxleCwKKwkJCSAgICAgdW5zaWduZWQgaW50IGZjLCB1bnNpZ25lZCBpbnQgcGF1c2VfdGltZSkKK3sKKwl1bnNpZ25lZCBpbnQgZmxvdyA9IE1BQ19GTE9XX0NUUkxfRU5BQkxFOworCisJaWYgKGR1cGxleCkKKwkJZmxvdyB8PSAocGF1c2VfdGltZSA8PCBNQUNfRkxPV19DVFJMX1BUX1NISUZUKTsKKwl3cml0ZWwoZmxvdywgaW9hZGRyICsgTUFDX0ZMT1dfQ1RSTCk7CisKKwlyZXR1cm47Cit9CisKKy8qIE5vIFBNVCBtb2R1bGUgc3VwcG9ydGVkIGluIG91ciBTb0MgIGZvciB0aGUgRXRoZXJuZXQgQ29udHJvbGxlci4gKi8KK3N0YXRpYyB2b2lkIG1hYzEwMF9wbXQodW5zaWduZWQgbG9uZyBpb2FkZHIsIHVuc2lnbmVkIGxvbmcgbW9kZSkKK3sKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9pbml0X3J4X2Rlc2Moc3RydWN0IGRtYV9kZXNjICpwLCB1bnNpZ25lZCBpbnQgcmluZ19zaXplLAorCQkJCWludCBkaXNhYmxlX3J4X2ljKQoreworCWludCBpOworCWZvciAoaSA9IDA7IGkgPCByaW5nX3NpemU7IGkrKykgeworCQlwLT5kZXMwMS5yeC5vd24gPSAxOworCQlwLT5kZXMwMS5yeC5idWZmZXIxX3NpemUgPSBCVUZfU0laRV8yS2lCIC0gMTsKKwkJaWYgKGkgPT0gcmluZ19zaXplIC0gMSkKKwkJCXAtPmRlczAxLnJ4LmVuZF9yaW5nID0gMTsKKwkJaWYgKGRpc2FibGVfcnhfaWMpCisJCQlwLT5kZXMwMS5yeC5kaXNhYmxlX2ljID0gMTsKKwkJcCsrOworCX0KKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9pbml0X3R4X2Rlc2Moc3RydWN0IGRtYV9kZXNjICpwLCB1bnNpZ25lZCBpbnQgcmluZ19zaXplKQoreworCWludCBpOworCWZvciAoaSA9IDA7IGkgPCByaW5nX3NpemU7IGkrKykgeworCQlwLT5kZXMwMS50eC5vd24gPSAwOworCQlpZiAoaSA9PSByaW5nX3NpemUgLSAxKQorCQkJcC0+ZGVzMDEudHguZW5kX3JpbmcgPSAxOworCQlwKys7CisJfQorCXJldHVybjsKK30KKworc3RhdGljIGludCBtYWMxMDBfZ2V0X3R4X293bmVyKHN0cnVjdCBkbWFfZGVzYyAqcCkKK3sKKwlyZXR1cm4gcC0+ZGVzMDEudHgub3duOworfQorCitzdGF0aWMgaW50IG1hYzEwMF9nZXRfcnhfb3duZXIoc3RydWN0IGRtYV9kZXNjICpwKQoreworCXJldHVybiBwLT5kZXMwMS5yeC5vd247Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9zZXRfdHhfb3duZXIoc3RydWN0IGRtYV9kZXNjICpwKQoreworCXAtPmRlczAxLnR4Lm93biA9IDE7Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9zZXRfcnhfb3duZXIoc3RydWN0IGRtYV9kZXNjICpwKQoreworCXAtPmRlczAxLnJ4Lm93biA9IDE7Cit9CisKK3N0YXRpYyBpbnQgbWFjMTAwX2dldF90eF9scyhzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJcmV0dXJuIHAtPmRlczAxLnR4Lmxhc3Rfc2VnbWVudDsKK30KKworc3RhdGljIHZvaWQgbWFjMTAwX3JlbGVhc2VfdHhfZGVzYyhzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJaW50IHRlciA9IHAtPmRlczAxLnR4LmVuZF9yaW5nOworCisJLyogY2xlYW4gZmllbGQgdXNlZCB3aXRoaW4gdGhlIHhtaXQgKi8KKwlwLT5kZXMwMS50eC5maXJzdF9zZWdtZW50ID0gMDsKKwlwLT5kZXMwMS50eC5sYXN0X3NlZ21lbnQgPSAwOworCXAtPmRlczAxLnR4LmJ1ZmZlcjFfc2l6ZSA9IDA7CisKKwkvKiBjbGVhbiBzdGF0dXMgcmVwb3J0ZWQgKi8KKwlwLT5kZXMwMS50eC5lcnJvcl9zdW1tYXJ5ID0gMDsKKwlwLT5kZXMwMS50eC51bmRlcmZsb3dfZXJyb3IgPSAwOworCXAtPmRlczAxLnR4Lm5vX2NhcnJpZXIgPSAwOworCXAtPmRlczAxLnR4Lmxvc3NfY2FycmllciA9IDA7CisJcC0+ZGVzMDEudHguZXhjZXNzaXZlX2RlZmVycmFsID0gMDsKKwlwLT5kZXMwMS50eC5leGNlc3NpdmVfY29sbGlzaW9ucyA9IDA7CisJcC0+ZGVzMDEudHgubGF0ZV9jb2xsaXNpb24gPSAwOworCXAtPmRlczAxLnR4LmhlYXJ0YmVhdF9mYWlsID0gMDsKKwlwLT5kZXMwMS50eC5kZWZlcnJlZCA9IDA7CisKKwkvKiBzZXQgdGVybWluYXRpb24gZmllbGQgKi8KKwlwLT5kZXMwMS50eC5lbmRfcmluZyA9IHRlcjsKKworCXJldHVybjsKK30KKworc3RhdGljIHZvaWQgbWFjMTAwX3ByZXBhcmVfdHhfZGVzYyhzdHJ1Y3QgZG1hX2Rlc2MgKnAsIGludCBpc19mcywgaW50IGxlbiwKKwkJCQkgICBpbnQgY3N1bV9mbGFnKQoreworCXAtPmRlczAxLnR4LmZpcnN0X3NlZ21lbnQgPSBpc19mczsKKwlwLT5kZXMwMS50eC5idWZmZXIxX3NpemUgPSBsZW47Cit9CisKK3N0YXRpYyB2b2lkIG1hYzEwMF9jbGVhcl90eF9pYyhzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJcC0+ZGVzMDEudHguaW50ZXJydXB0ID0gMDsKK30KKworc3RhdGljIHZvaWQgbWFjMTAwX2Nsb3NlX3R4X2Rlc2Moc3RydWN0IGRtYV9kZXNjICpwKQoreworCXAtPmRlczAxLnR4Lmxhc3Rfc2VnbWVudCA9IDE7CisJcC0+ZGVzMDEudHguaW50ZXJydXB0ID0gMTsKK30KKworc3RhdGljIGludCBtYWMxMDBfZ2V0X3J4X2ZyYW1lX2xlbihzdHJ1Y3QgZG1hX2Rlc2MgKnApCit7CisJcmV0dXJuIHAtPmRlczAxLnJ4LmZyYW1lX2xlbmd0aDsKK30KKworc3RydWN0IHN0bW1hY19vcHMgbWFjMTAwX2RyaXZlciA9IHsKKwkuY29yZV9pbml0ID0gbWFjMTAwX2NvcmVfaW5pdCwKKwkuZHVtcF9tYWNfcmVncyA9IG1hYzEwMF9kdW1wX21hY19yZWdzLAorCS5kbWFfaW5pdCA9IG1hYzEwMF9kbWFfaW5pdCwKKwkuZHVtcF9kbWFfcmVncyA9IG1hYzEwMF9kdW1wX2RtYV9yZWdzLAorCS5kbWFfbW9kZSA9IG1hYzEwMF9kbWFfb3BlcmF0aW9uX21vZGUsCisJLmRtYV9kaWFnbm9zdGljX2ZyID0gbWFjMTAwX2RtYV9kaWFnbm9zdGljX2ZyLAorCS50eF9zdGF0dXMgPSBtYWMxMDBfZ2V0X3R4X2ZyYW1lX3N0YXR1cywKKwkucnhfc3RhdHVzID0gbWFjMTAwX2dldF9yeF9mcmFtZV9zdGF0dXMsCisJLmdldF90eF9sZW4gPSBtYWMxMDBfZ2V0X3R4X2xlbiwKKwkuc2V0X2ZpbHRlciA9IG1hYzEwMF9zZXRfZmlsdGVyLAorCS5mbG93X2N0cmwgPSBtYWMxMDBfZmxvd19jdHJsLAorCS5wbXQgPSBtYWMxMDBfcG10LAorCS5pbml0X3J4X2Rlc2MgPSBtYWMxMDBfaW5pdF9yeF9kZXNjLAorCS5pbml0X3R4X2Rlc2MgPSBtYWMxMDBfaW5pdF90eF9kZXNjLAorCS5nZXRfdHhfb3duZXIgPSBtYWMxMDBfZ2V0X3R4X293bmVyLAorCS5nZXRfcnhfb3duZXIgPSBtYWMxMDBfZ2V0X3J4X293bmVyLAorCS5yZWxlYXNlX3R4X2Rlc2MgPSBtYWMxMDBfcmVsZWFzZV90eF9kZXNjLAorCS5wcmVwYXJlX3R4X2Rlc2MgPSBtYWMxMDBfcHJlcGFyZV90eF9kZXNjLAorCS5jbGVhcl90eF9pYyA9IG1hYzEwMF9jbGVhcl90eF9pYywKKwkuY2xvc2VfdHhfZGVzYyA9IG1hYzEwMF9jbG9zZV90eF9kZXNjLAorCS5nZXRfdHhfbHMgPSBtYWMxMDBfZ2V0X3R4X2xzLAorCS5zZXRfdHhfb3duZXIgPSBtYWMxMDBfc2V0X3R4X293bmVyLAorCS5zZXRfcnhfb3duZXIgPSBtYWMxMDBfc2V0X3J4X293bmVyLAorCS5nZXRfcnhfZnJhbWVfbGVuID0gbWFjMTAwX2dldF9yeF9mcmFtZV9sZW4sCisJLmhvc3RfaXJxX3N0YXR1cyA9IG1hYzEwMF9pcnFfc3RhdHVzLAorCS5zZXRfdW1hY19hZGRyID0gbWFjMTAwX3NldF91bWFjX2FkZHIsCisJLmdldF91bWFjX2FkZHIgPSBtYWMxMDBfZ2V0X3VtYWNfYWRkciwKK307CisKK3N0cnVjdCBtYWNfZGV2aWNlX2luZm8gKm1hYzEwMF9zZXR1cCh1bnNpZ25lZCBsb25nIGlvYWRkcikKK3sKKwlzdHJ1Y3QgbWFjX2RldmljZV9pbmZvICptYWM7CisKKwltYWMgPSBremFsbG9jKHNpemVvZihjb25zdCBzdHJ1Y3QgbWFjX2RldmljZV9pbmZvKSwgR0ZQX0tFUk5FTCk7CisKKwlwcl9pbmZvKCJcdE1BQyAxMC8xMDBcbiIpOworCisJbWFjLT5vcHMgPSAmbWFjMTAwX2RyaXZlcjsKKwltYWMtPmh3LnBtdCA9IFBNVF9OT1RfU1VQUE9SVEVEOworCW1hYy0+aHcubGluay5wb3J0ID0gTUFDX0NPTlRST0xfUFM7CisJbWFjLT5ody5saW5rLmR1cGxleCA9IE1BQ19DT05UUk9MX0Y7CisJbWFjLT5ody5saW5rLnNwZWVkID0gMDsKKwltYWMtPmh3Lm1paS5hZGRyID0gTUFDX01JSV9BRERSOworCW1hYy0+aHcubWlpLmRhdGEgPSBNQUNfTUlJX0RBVEE7CisKKwlyZXR1cm4gbWFjOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL21hYzEwMC5oIGIvZHJpdmVycy9uZXQvc3RtbWFjL21hYzEwMC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjBmOGYxMTAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9zdG1tYWMvbWFjMTAwLmgKQEAgLTAsMCArMSwxMTYgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgIE1BQyAxMC8xMDAgSGVhZGVyIEZpbGUKKworICBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOSAgU1RNaWNyb2VsZWN0cm9uaWNzIEx0ZAorCisgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgIHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsCisgIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisKKyAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IKKyAgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvcgorICBtb3JlIGRldGFpbHMuCisKKyAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxvbmcgd2l0aAorICB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKKyAgNTEgRnJhbmtsaW4gU3QgLSBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQS4KKworICBUaGUgZnVsbCBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBpcyBpbmNsdWRlZCBpbiB0aGlzIGRpc3RyaWJ1dGlvbiBpbgorICB0aGUgZmlsZSBjYWxsZWQgIkNPUFlJTkciLgorCisgIEF1dGhvcjogR2l1c2VwcGUgQ2F2YWxsYXJvIDxwZXBwZS5jYXZhbGxhcm9Ac3QuY29tPgorKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKgkgCQkJTUFDIEJMT0NLIGRlZmluZXMKKyAqLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KKy8qIE1BQyBDU1Igb2Zmc2V0ICovCisjZGVmaW5lIE1BQ19DT05UUk9MCTB4MDAwMDAwMDAJLyogTUFDIENvbnRyb2wgKi8KKyNkZWZpbmUgTUFDX0FERFJfSElHSAkweDAwMDAwMDA0CS8qIE1BQyBBZGRyZXNzIEhpZ2ggKi8KKyNkZWZpbmUgTUFDX0FERFJfTE9XCTB4MDAwMDAwMDgJLyogTUFDIEFkZHJlc3MgTG93ICovCisjZGVmaW5lIE1BQ19IQVNIX0hJR0gJMHgwMDAwMDAwYwkvKiBNdWx0aWNhc3QgSGFzaCBUYWJsZSBIaWdoICovCisjZGVmaW5lIE1BQ19IQVNIX0xPVwkweDAwMDAwMDEwCS8qIE11bHRpY2FzdCBIYXNoIFRhYmxlIExvdyAqLworI2RlZmluZSBNQUNfTUlJX0FERFIJMHgwMDAwMDAxNAkvKiBNSUkgQWRkcmVzcyAqLworI2RlZmluZSBNQUNfTUlJX0RBVEEJMHgwMDAwMDAxOAkvKiBNSUkgRGF0YSAqLworI2RlZmluZSBNQUNfRkxPV19DVFJMCTB4MDAwMDAwMWMJLyogRmxvdyBDb250cm9sICovCisjZGVmaW5lIE1BQ19WTEFOMQkweDAwMDAwMDIwCS8qIFZMQU4xIFRhZyAqLworI2RlZmluZSBNQUNfVkxBTjIJMHgwMDAwMDAyNAkvKiBWTEFOMiBUYWcgKi8KKworLyogTUFDIENUUkwgZGVmaW5lcyAqLworI2RlZmluZSBNQUNfQ09OVFJPTF9SQQkweDgwMDAwMDAwCS8qIFJlY2VpdmUgQWxsIE1vZGUgKi8KKyNkZWZpbmUgTUFDX0NPTlRST0xfQkxFCTB4NDAwMDAwMDAJLyogRW5kaWFuIE1vZGUgKi8KKyNkZWZpbmUgTUFDX0NPTlRST0xfSEJECTB4MTAwMDAwMDAJLyogSGVhcnRiZWF0IERpc2FibGUgKi8KKyNkZWZpbmUgTUFDX0NPTlRST0xfUFMJMHgwODAwMDAwMAkvKiBQb3J0IFNlbGVjdCAqLworI2RlZmluZSBNQUNfQ09OVFJPTF9EUk8JMHgwMDgwMDAwMAkvKiBEaXNhYmxlIFJlY2VpdmUgT3duICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0VYVF9MT09QQkFDSyAweDAwNDAwMDAwCS8qIFJlc2VydmVkIChleHQgbG9vcGJhY2s/KSAqLworI2RlZmluZSBNQUNfQ09OVFJPTF9PTQkweDAwMjAwMDAwCS8qIExvb3BiYWNrIE9wZXJhdGluZyBNb2RlICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0YJMHgwMDEwMDAwMAkvKiBGdWxsIER1cGxleCBNb2RlICovCisjZGVmaW5lIE1BQ19DT05UUk9MX1BNCTB4MDAwODAwMDAJLyogUGFzcyBBbGwgTXVsdGljYXN0ICovCisjZGVmaW5lIE1BQ19DT05UUk9MX1BSCTB4MDAwNDAwMDAJLyogUHJvbWlzY3VvdXMgTW9kZSAqLworI2RlZmluZSBNQUNfQ09OVFJPTF9JRgkweDAwMDIwMDAwCS8qIEludmVyc2UgRmlsdGVyaW5nICovCisjZGVmaW5lIE1BQ19DT05UUk9MX1BCCTB4MDAwMTAwMDAJLyogUGFzcyBCYWQgRnJhbWVzICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0hPCTB4MDAwMDgwMDAJLyogSGFzaCBPbmx5IEZpbHRlcmluZyBNb2RlICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0hQCTB4MDAwMDIwMDAJLyogSGFzaC9QZXJmZWN0IEZpbHRlcmluZyBNb2RlICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0xDQwkweDAwMDAxMDAwCS8qIExhdGUgQ29sbGlzaW9uIENvbnRyb2wgKi8KKyNkZWZpbmUgTUFDX0NPTlRST0xfREJGCTB4MDAwMDA4MDAJLyogRGlzYWJsZSBCcm9hZGNhc3QgRnJhbWVzICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0RSVFkJMHgwMDAwMDQwMAkvKiBEaXNhYmxlIFJldHJ5ICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0FTVFAJMHgwMDAwMDEwMAkvKiBBdXRvbWF0aWMgUGFkIFN0cmlwcGluZyAqLworI2RlZmluZSBNQUNfQ09OVFJPTF9CT0xNVF8xMAkweDAwMDAwMDAwCS8qIEJhY2sgT2ZmIExpbWl0IDEwICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0JPTE1UXzgJMHgwMDAwMDA0MAkvKiBCYWNrIE9mZiBMaW1pdCA4ICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0JPTE1UXzQJMHgwMDAwMDA4MAkvKiBCYWNrIE9mZiBMaW1pdCA0ICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0JPTE1UXzEJMHgwMDAwMDBjMAkvKiBCYWNrIE9mZiBMaW1pdCAxICovCisjZGVmaW5lIE1BQ19DT05UUk9MX0RDCQkweDAwMDAwMDIwCS8qIERlZmVycmFsIENoZWNrICovCisjZGVmaW5lIE1BQ19DT05UUk9MX1RFCQkweDAwMDAwMDA4CS8qIFRyYW5zbWl0dGVyIEVuYWJsZSAqLworI2RlZmluZSBNQUNfQ09OVFJPTF9SRQkJMHgwMDAwMDAwNAkvKiBSZWNlaXZlciBFbmFibGUgKi8KKworI2RlZmluZSBNQUNfQ09SRV9JTklUIChNQUNfQ09OVFJPTF9IQkQgfCBNQUNfQ09OVFJPTF9BU1RQKQorCisvKiBNQUMgRkxPVyBDVFJMIGRlZmluZXMgKi8KKyNkZWZpbmUgTUFDX0ZMT1dfQ1RSTF9QVF9NQVNLCTB4ZmZmZjAwMDAJLyogUGF1c2UgVGltZSBNYXNrICovCisjZGVmaW5lIE1BQ19GTE9XX0NUUkxfUFRfU0hJRlQJMTYKKyNkZWZpbmUgTUFDX0ZMT1dfQ1RSTF9QQVNTCTB4MDAwMDAwMDQJLyogUGFzcyBDb250cm9sIEZyYW1lcyAqLworI2RlZmluZSBNQUNfRkxPV19DVFJMX0VOQUJMRQkweDAwMDAwMDAyCS8qIEZsb3cgQ29udHJvbCBFbmFibGUgKi8KKyNkZWZpbmUgTUFDX0ZMT1dfQ1RSTF9QQVVTRQkweDAwMDAwMDAxCS8qIEZsb3cgQ29udHJvbCBCdXN5IC4uLiAqLworCisvKiBNSUkgQUREUiAgZGVmaW5lcyAqLworI2RlZmluZSBNQUNfTUlJX0FERFJfV1JJVEUJMHgwMDAwMDAwMgkvKiBNSUkgV3JpdGUgKi8KKyNkZWZpbmUgTUFDX01JSV9BRERSX0JVU1kJMHgwMDAwMDAwMQkvKiBNSUkgQnVzeSAqLworCisvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqIAkJCQlETUEgQkxPQ0sgZGVmaW5lcworICotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLworCisvKiBETUEgQnVzIE1vZGUgcmVnaXN0ZXIgZGVmaW5lcyAqLworI2RlZmluZSBETUFfQlVTX01PREVfREJPCTB4MDAxMDAwMDAJLyogRGVzY3JpcHRvciBCeXRlIE9yZGVyaW5nICovCisjZGVmaW5lIERNQV9CVVNfTU9ERV9CTEUJMHgwMDAwMDA4MAkvKiBCaWcgRW5kaWFuL0xpdHRsZSBFbmRpYW4gKi8KKyNkZWZpbmUgRE1BX0JVU19NT0RFX1BCTF9NQVNLCTB4MDAwMDNmMDAJLyogUHJvZ3JhbW1hYmxlIEJ1cnN0IExlbiAqLworI2RlZmluZSBETUFfQlVTX01PREVfUEJMX1NISUZUCTgKKyNkZWZpbmUgRE1BX0JVU19NT0RFX0RTTF9NQVNLCTB4MDAwMDAwN2MJLyogRGVzY3JpcHRvciBTa2lwIExlbmd0aCAqLworI2RlZmluZSBETUFfQlVTX01PREVfRFNMX1NISUZUCTIJLyogICAoaW4gRFdPUkRTKSAgICAgICovCisjZGVmaW5lIERNQV9CVVNfTU9ERV9CQVJfQlVTCTB4MDAwMDAwMDIJLyogQmFyLUJ1cyBBcmJpdHJhdGlvbiAqLworI2RlZmluZSBETUFfQlVTX01PREVfU0ZUX1JFU0VUCTB4MDAwMDAwMDEJLyogU29mdHdhcmUgUmVzZXQgKi8KKyNkZWZpbmUgRE1BX0JVU19NT0RFX0RFRkFVTFQJMHgwMDAwMDAwMAorCisvKiBETUEgQ29udHJvbCByZWdpc3RlciBkZWZpbmVzICovCisjZGVmaW5lIERNQV9DT05UUk9MX1NGCQkweDAwMjAwMDAwCS8qIFN0b3JlIEFuZCBGb3J3YXJkICovCisKKy8qIFRyYW5zbWl0IFRocmVzaG9sZCBDb250cm9sICovCitlbnVtIHR0Y19jb250cm9sIHsKKwlETUFfQ09OVFJPTF9UVENfREVGQVVMVCA9IDB4MDAwMDAwMDAsCS8qIFRocmVzaG9sZCBpcyAzMiBEV09SRFMgKi8KKwlETUFfQ09OVFJPTF9UVENfNjQgPSAweDAwMDA0MDAwLAkvKiBUaHJlc2hvbGQgaXMgNjQgRFdPUkRTICovCisJRE1BX0NPTlRST0xfVFRDXzEyOCA9IDB4MDAwMDgwMDAsCS8qIFRocmVzaG9sZCBpcyAxMjggRFdPUkRTICovCisJRE1BX0NPTlRST0xfVFRDXzI1NiA9IDB4MDAwMGMwMDAsCS8qIFRocmVzaG9sZCBpcyAyNTYgRFdPUkRTICovCisJRE1BX0NPTlRST0xfVFRDXzE4ID0gMHgwMDQwMDAwMCwJLyogVGhyZXNob2xkIGlzIDE4IERXT1JEUyAqLworCURNQV9DT05UUk9MX1RUQ18yNCA9IDB4MDA0MDQwMDAsCS8qIFRocmVzaG9sZCBpcyAyNCBEV09SRFMgKi8KKwlETUFfQ09OVFJPTF9UVENfMzIgPSAweDAwNDA4MDAwLAkvKiBUaHJlc2hvbGQgaXMgMzIgRFdPUkRTICovCisJRE1BX0NPTlRST0xfVFRDXzQwID0gMHgwMDQwYzAwMCwJLyogVGhyZXNob2xkIGlzIDQwIERXT1JEUyAqLworCURNQV9DT05UUk9MX1NFID0gMHgwMDAwMDAwOCwJLyogU3RvcCBPbiBFbXB0eSAqLworCURNQV9DT05UUk9MX09TRiA9IDB4MDAwMDAwMDQsCS8qIE9wZXJhdGUgT24gMm5kIEZyYW1lICovCit9OworCisvKiBTVE1BQzExMCBETUEgTWlzc2VkIEZyYW1lIENvdW50ZXIgcmVnaXN0ZXIgZGVmaW5lcyAqLworI2RlZmluZSBETUFfTUlTU0VEX0ZSQU1FX09WRQkweDEwMDAwMDAwCS8qIEZJRk8gT3ZlcmZsb3cgT3ZlcmZsb3cgKi8KKyNkZWZpbmUgRE1BX01JU1NFRF9GUkFNRV9PVkVfQ05UUiAweDBmZmUwMDAwCS8qIE92ZXJmbG93IEZyYW1lIENvdW50ZXIgKi8KKyNkZWZpbmUgRE1BX01JU1NFRF9GUkFNRV9PVkVfTQkweDAwMDEwMDAwCS8qIE1pc3NlZCBGcmFtZSBPdmVyZmxvdyAqLworI2RlZmluZSBETUFfTUlTU0VEX0ZSQU1FX01fQ05UUgkweDAwMDBmZmZmCS8qIE1pc3NlZCBGcmFtZSBDb3VpbnRlciAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hYy5oIGIvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hYy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjZkMmVhZTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9zdG1tYWMvc3RtbWFjLmgKQEAgLTAsMCArMSw5OCBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIFNUTWljcm9lbGVjdHJvbmljcyBMdGQKKworICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLAorICB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKKyAgbW9yZSBkZXRhaWxzLgorCisgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nIHdpdGgKKyAgdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgIDUxIEZyYW5rbGluIFN0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisKKyAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAgdGhlIGZpbGUgY2FsbGVkICJDT1BZSU5HIi4KKworICBBdXRob3I6IEdpdXNlcHBlIENhdmFsbGFybyA8cGVwcGUuY2F2YWxsYXJvQHN0LmNvbT4KKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNkZWZpbmUgRFJWX01PRFVMRV9WRVJTSU9OCSJPY3RfMDkiCisKKyNpZiBkZWZpbmVkKENPTkZJR19WTEFOXzgwMjFRKSB8fCBkZWZpbmVkKENPTkZJR19WTEFOXzgwMjFRX01PRFVMRSkKKyNkZWZpbmUgU1RNTUFDX1ZMQU5fVEFHX1VTRUQKKyNpbmNsdWRlIDxsaW51eC9pZl92bGFuLmg+CisjZW5kaWYKKworI2luY2x1ZGUgImNvbW1vbi5oIgorI2lmZGVmIENPTkZJR19TVE1NQUNfVElNRVIKKyNpbmNsdWRlICJzdG1tYWNfdGltZXIuaCIKKyNlbmRpZgorCitzdHJ1Y3Qgc3RtbWFjX3ByaXYgeworCS8qIEZyZXF1ZW50bHkgdXNlZCB2YWx1ZXMgYXJlIGtlcHQgYWRqYWNlbnQgZm9yIGNhY2hlIGVmZmVjdCAqLworCXN0cnVjdCBkbWFfZGVzYyAqZG1hX3R4IF9fX19jYWNoZWxpbmVfYWxpZ25lZDsKKwlkbWFfYWRkcl90IGRtYV90eF9waHk7CisJc3RydWN0IHNrX2J1ZmYgKip0eF9za2J1ZmY7CisJdW5zaWduZWQgaW50IGN1cl90eDsKKwl1bnNpZ25lZCBpbnQgZGlydHlfdHg7CisJdW5zaWduZWQgaW50IGRtYV90eF9zaXplOworCWludCB0eF9jb2U7CisJaW50IHR4X2NvYWxlc2NlOworCisJc3RydWN0IGRtYV9kZXNjICpkbWFfcnggOworCXVuc2lnbmVkIGludCBjdXJfcng7CisJdW5zaWduZWQgaW50IGRpcnR5X3J4OworCXN0cnVjdCBza19idWZmICoqcnhfc2tidWZmOworCWRtYV9hZGRyX3QgKnJ4X3NrYnVmZl9kbWE7CisJc3RydWN0IHNrX2J1ZmZfaGVhZCByeF9yZWN5Y2xlOworCisJc3RydWN0IG5ldF9kZXZpY2UgKmRldjsKKwlpbnQgaXNfZ21hYzsKKwlkbWFfYWRkcl90IGRtYV9yeF9waHk7CisJdW5zaWduZWQgaW50IGRtYV9yeF9zaXplOworCWludCByeF9jc3VtOworCXVuc2lnbmVkIGludCBkbWFfYnVmX3N6OworCXN0cnVjdCBkZXZpY2UgKmRldmljZTsKKwlzdHJ1Y3QgbWFjX2RldmljZV9pbmZvICptYWNfdHlwZTsKKworCXN0cnVjdCBzdG1tYWNfZXh0cmFfc3RhdHMgeHN0YXRzOworCXN0cnVjdCBuYXBpX3N0cnVjdCBuYXBpOworCisJcGh5X2ludGVyZmFjZV90IHBoeV9pbnRlcmZhY2U7CisJaW50IHBibDsKKwlpbnQgYnVzX2lkOworCWludCBwaHlfYWRkcjsKKwlpbnQgcGh5X21hc2s7CisJaW50ICgqcGh5X3Jlc2V0KSAodm9pZCAqcHJpdik7CisJdm9pZCAoKmZpeF9tYWNfc3BlZWQpICh2b2lkICpwcml2LCB1bnNpZ25lZCBpbnQgc3BlZWQpOworCXZvaWQgKmJzcF9wcml2OworCisJaW50IHBoeV9pcnE7CisJc3RydWN0IHBoeV9kZXZpY2UgKnBoeWRldjsKKwlpbnQgb2xkbGluazsKKwlpbnQgc3BlZWQ7CisJaW50IG9sZGR1cGxleDsKKwl1bnNpZ25lZCBpbnQgZmxvd19jdHJsOworCXVuc2lnbmVkIGludCBwYXVzZTsKKwlzdHJ1Y3QgbWlpX2J1cyAqbWlpOworCisJdTMyIG1zZ19lbmFibGU7CisJc3BpbmxvY2tfdCBsb2NrOworCWludCB3b2xvcHRzOworCWludCB3b2xlbmFibGVkOworCWludCBzaHV0ZG93bjsKKyNpZmRlZiBDT05GSUdfU1RNTUFDX1RJTUVSCisJc3RydWN0IHN0bW1hY190aW1lciAqdG07CisjZW5kaWYKKyNpZmRlZiBTVE1NQUNfVkxBTl9UQUdfVVNFRAorCXN0cnVjdCB2bGFuX2dyb3VwICp2bGdycDsKKyNlbmRpZgorfTsKKworZXh0ZXJuIGludCBzdG1tYWNfbWRpb191bnJlZ2lzdGVyKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KTsKK2V4dGVybiBpbnQgc3RtbWFjX21kaW9fcmVnaXN0ZXIoc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYpOworZXh0ZXJuIHZvaWQgc3RtbWFjX3NldF9ldGh0b29sX29wcyhzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3N0bW1hYy9zdG1tYWNfZXRodG9vbC5jIGIvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hY19ldGh0b29sLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjk0ZWJlNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L3N0bW1hYy9zdG1tYWNfZXRodG9vbC5jCkBAIC0wLDAgKzEsMzk1IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICBTVE1NQUMgRXRodG9vbCBzdXBwb3J0CisKKyAgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIFNUTWljcm9lbGVjdHJvbmljcyBMdGQKKworICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLAorICB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKKyAgbW9yZSBkZXRhaWxzLgorCisgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nIHdpdGgKKyAgdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgIDUxIEZyYW5rbGluIFN0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisKKyAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAgdGhlIGZpbGUgY2FsbGVkICJDT1BZSU5HIi4KKworICBBdXRob3I6IEdpdXNlcHBlIENhdmFsbGFybyA8cGVwcGUuY2F2YWxsYXJvQHN0LmNvbT4KKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L2V0aHRvb2wuaD4KKyNpbmNsdWRlIDxsaW51eC9taWkuaD4KKyNpbmNsdWRlIDxsaW51eC9waHkuaD4KKworI2luY2x1ZGUgInN0bW1hYy5oIgorCisjZGVmaW5lIFJFR19TUEFDRV9TSVpFCTB4MTA1NAorI2RlZmluZSBNQUMxMDBfRVRIVE9PTF9OQU1FCSJzdF9tYWMxMDAiCisjZGVmaW5lIEdNQUNfRVRIVE9PTF9OQU1FCSJzdF9nbWFjIgorCitzdHJ1Y3Qgc3RtbWFjX3N0YXRzIHsKKwljaGFyIHN0YXRfc3RyaW5nW0VUSF9HU1RSSU5HX0xFTl07CisJaW50IHNpemVvZl9zdGF0OworCWludCBzdGF0X29mZnNldDsKK307CisKKyNkZWZpbmUgU1RNTUFDX1NUQVQobSkJXAorCXsgI20sIEZJRUxEX1NJWkVPRihzdHJ1Y3Qgc3RtbWFjX2V4dHJhX3N0YXRzLCBtKSwJXAorCW9mZnNldG9mKHN0cnVjdCBzdG1tYWNfcHJpdiwgeHN0YXRzLm0pfQorCitzdGF0aWMgY29uc3Qgc3RydWN0ICBzdG1tYWNfc3RhdHMgc3RtbWFjX2dzdHJpbmdzX3N0YXRzW10gPSB7CisJU1RNTUFDX1NUQVQodHhfdW5kZXJmbG93KSwKKwlTVE1NQUNfU1RBVCh0eF9jYXJyaWVyKSwKKwlTVE1NQUNfU1RBVCh0eF9sb3NzY2FycmllciksCisJU1RNTUFDX1NUQVQodHhfaGVhcnRiZWF0KSwKKwlTVE1NQUNfU1RBVCh0eF9kZWZlcnJlZCksCisJU1RNTUFDX1NUQVQodHhfdmxhbiksCisJU1RNTUFDX1NUQVQocnhfdmxhbiksCisJU1RNTUFDX1NUQVQodHhfamFiYmVyKSwKKwlTVE1NQUNfU1RBVCh0eF9mcmFtZV9mbHVzaGVkKSwKKwlTVE1NQUNfU1RBVCh0eF9wYXlsb2FkX2Vycm9yKSwKKwlTVE1NQUNfU1RBVCh0eF9pcF9oZWFkZXJfZXJyb3IpLAorCVNUTU1BQ19TVEFUKHJ4X2Rlc2MpLAorCVNUTU1BQ19TVEFUKHJ4X3BhcnRpYWwpLAorCVNUTU1BQ19TVEFUKHJ4X3J1bnQpLAorCVNUTU1BQ19TVEFUKHJ4X3Rvb2xvbmcpLAorCVNUTU1BQ19TVEFUKHJ4X2NvbGxpc2lvbiksCisJU1RNTUFDX1NUQVQocnhfY3JjKSwKKwlTVE1NQUNfU1RBVChyeF9sZW5naHQpLAorCVNUTU1BQ19TVEFUKHJ4X21paSksCisJU1RNTUFDX1NUQVQocnhfbXVsdGljYXN0KSwKKwlTVE1NQUNfU1RBVChyeF9nbWFjX292ZXJmbG93KSwKKwlTVE1NQUNfU1RBVChyeF93YXRjaGRvZyksCisJU1RNTUFDX1NUQVQoZGFfcnhfZmlsdGVyX2ZhaWwpLAorCVNUTU1BQ19TVEFUKHNhX3J4X2ZpbHRlcl9mYWlsKSwKKwlTVE1NQUNfU1RBVChyeF9taXNzZWRfY250ciksCisJU1RNTUFDX1NUQVQocnhfb3ZlcmZsb3dfY250ciksCisJU1RNTUFDX1NUQVQodHhfdW5kZWZsb3dfaXJxKSwKKwlTVE1NQUNfU1RBVCh0eF9wcm9jZXNzX3N0b3BwZWRfaXJxKSwKKwlTVE1NQUNfU1RBVCh0eF9qYWJiZXJfaXJxKSwKKwlTVE1NQUNfU1RBVChyeF9vdmVyZmxvd19pcnEpLAorCVNUTU1BQ19TVEFUKHJ4X2J1Zl91bmF2X2lycSksCisJU1RNTUFDX1NUQVQocnhfcHJvY2Vzc19zdG9wcGVkX2lycSksCisJU1RNTUFDX1NUQVQocnhfd2F0Y2hkb2dfaXJxKSwKKwlTVE1NQUNfU1RBVCh0eF9lYXJseV9pcnEpLAorCVNUTU1BQ19TVEFUKGZhdGFsX2J1c19lcnJvcl9pcnEpLAorCVNUTU1BQ19TVEFUKHRocmVzaG9sZCksCisJU1RNTUFDX1NUQVQodHhfcGt0X24pLAorCVNUTU1BQ19TVEFUKHJ4X3BrdF9uKSwKKwlTVE1NQUNfU1RBVChwb2xsX24pLAorCVNUTU1BQ19TVEFUKHNjaGVkX3RpbWVyX24pLAorCVNUTU1BQ19TVEFUKG5vcm1hbF9pcnFfbiksCit9OworI2RlZmluZSBTVE1NQUNfU1RBVFNfTEVOIEFSUkFZX1NJWkUoc3RtbWFjX2dzdHJpbmdzX3N0YXRzKQorCit2b2lkIHN0bW1hY19ldGh0b29sX2dldGRydmluZm8oc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKKwkJCSAgICAgICBzdHJ1Y3QgZXRodG9vbF9kcnZpbmZvICppbmZvKQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisKKwlpZiAoIXByaXYtPmlzX2dtYWMpCisJCXN0cmNweShpbmZvLT5kcml2ZXIsIE1BQzEwMF9FVEhUT09MX05BTUUpOworCWVsc2UKKwkJc3RyY3B5KGluZm8tPmRyaXZlciwgR01BQ19FVEhUT09MX05BTUUpOworCisJc3RyY3B5KGluZm8tPnZlcnNpb24sIERSVl9NT0RVTEVfVkVSU0lPTik7CisJaW5mby0+ZndfdmVyc2lvblswXSA9ICdcMCc7CisJaW5mby0+bl9zdGF0cyA9IFNUTU1BQ19TVEFUU19MRU47CisJcmV0dXJuOworfQorCitpbnQgc3RtbWFjX2V0aHRvb2xfZ2V0c2V0dGluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IGV0aHRvb2xfY21kICpjbWQpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwlzdHJ1Y3QgcGh5X2RldmljZSAqcGh5ID0gcHJpdi0+cGh5ZGV2OworCWludCByYzsKKwlpZiAocGh5ID09IE5VTEwpIHsKKwkJcHJfZXJyKCIlczogJXM6IFBIWSBpcyBub3QgcmVnaXN0ZXJlZFxuIiwKKwkJICAgICAgIF9fZnVuY19fLCBkZXYtPm5hbWUpOworCQlyZXR1cm4gLUVOT0RFVjsKKwl9CisJaWYgKCFuZXRpZl9ydW5uaW5nKGRldikpIHsKKwkJcHJfZXJyKCIlczogaW50ZXJmYWNlIGlzIGRpc2FibGVkOiB3ZSBjYW5ub3QgdHJhY2sgIgorCQkibGluayBzcGVlZCAvIGR1cGxleCBzZXR0aW5nXG4iLCBkZXYtPm5hbWUpOworCQlyZXR1cm4gLUVCVVNZOworCX0KKwljbWQtPnRyYW5zY2VpdmVyID0gWENWUl9JTlRFUk5BTDsKKwlzcGluX2xvY2tfaXJxKCZwcml2LT5sb2NrKTsKKwlyYyA9IHBoeV9ldGh0b29sX2dzZXQocGh5LCBjbWQpOworCXNwaW5fdW5sb2NrX2lycSgmcHJpdi0+bG9jayk7CisJcmV0dXJuIHJjOworfQorCitpbnQgc3RtbWFjX2V0aHRvb2xfc2V0c2V0dGluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IGV0aHRvb2xfY21kICpjbWQpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwlzdHJ1Y3QgcGh5X2RldmljZSAqcGh5ID0gcHJpdi0+cGh5ZGV2OworCWludCByYzsKKworCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7CisJcmMgPSBwaHlfZXRodG9vbF9zc2V0KHBoeSwgY21kKTsKKwlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisKKwlyZXR1cm4gcmM7Cit9CisKK3UzMiBzdG1tYWNfZXRodG9vbF9nZXRtc2dsZXZlbChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisJcmV0dXJuIHByaXYtPm1zZ19lbmFibGU7Cit9CisKK3ZvaWQgc3RtbWFjX2V0aHRvb2xfc2V0bXNnbGV2ZWwoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdTMyIGxldmVsKQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisJcHJpdi0+bXNnX2VuYWJsZSA9IGxldmVsOworCit9CisKK2ludCBzdG1tYWNfY2hlY2tfaWZfcnVubmluZyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCWlmICghbmV0aWZfcnVubmluZyhkZXYpKQorCQlyZXR1cm4gLUVCVVNZOworCXJldHVybiAwOworfQorCitpbnQgc3RtbWFjX2V0aHRvb2xfZ2V0X3JlZ3NfbGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJcmV0dXJuIFJFR19TUEFDRV9TSVpFOworfQorCit2b2lkIHN0bW1hY19ldGh0b29sX2dyZWdzKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCisJCQkgIHN0cnVjdCBldGh0b29sX3JlZ3MgKnJlZ3MsIHZvaWQgKnNwYWNlKQoreworCWludCBpOworCXUzMiAqcmVnX3NwYWNlID0gKHUzMiAqKSBzcGFjZTsKKworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisKKwltZW1zZXQocmVnX3NwYWNlLCAweDAsIFJFR19TUEFDRV9TSVpFKTsKKworCWlmICghcHJpdi0+aXNfZ21hYykgeworCQkvKiBNQUMgcmVnaXN0ZXJzICovCisJCWZvciAoaSA9IDA7IGkgPCAxMjsgaSsrKQorCQkJcmVnX3NwYWNlW2ldID0gcmVhZGwoZGV2LT5iYXNlX2FkZHIgKyAoaSAqIDQpKTsKKwkJLyogRE1BIHJlZ2lzdGVycyAqLworCQlmb3IgKGkgPSAwOyBpIDwgOTsgaSsrKQorCQkJcmVnX3NwYWNlW2kgKyAxMl0gPQorCQkJICAgIHJlYWRsKGRldi0+YmFzZV9hZGRyICsgKERNQV9CVVNfTU9ERSArIChpICogNCkpKTsKKwkJcmVnX3NwYWNlWzIyXSA9IHJlYWRsKGRldi0+YmFzZV9hZGRyICsgRE1BX0NVUl9UWF9CVUZfQUREUik7CisJCXJlZ19zcGFjZVsyM10gPSByZWFkbChkZXYtPmJhc2VfYWRkciArIERNQV9DVVJfUlhfQlVGX0FERFIpOworCX0gZWxzZSB7CisJCS8qIE1BQyByZWdpc3RlcnMgKi8KKwkJZm9yIChpID0gMDsgaSA8IDU1OyBpKyspCisJCQlyZWdfc3BhY2VbaV0gPSByZWFkbChkZXYtPmJhc2VfYWRkciArIChpICogNCkpOworCQkvKiBETUEgcmVnaXN0ZXJzICovCisJCWZvciAoaSA9IDA7IGkgPCAyMjsgaSsrKQorCQkJcmVnX3NwYWNlW2kgKyA1NV0gPQorCQkJICAgIHJlYWRsKGRldi0+YmFzZV9hZGRyICsgKERNQV9CVVNfTU9ERSArIChpICogNCkpKTsKKwl9CisKKwlyZXR1cm47Cit9CisKK2ludCBzdG1tYWNfZXRodG9vbF9zZXRfdHhfY3N1bShzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCB1MzIgZGF0YSkKK3sKKwlpZiAoZGF0YSkKKwkJbmV0ZGV2LT5mZWF0dXJlcyB8PSBORVRJRl9GX0hXX0NTVU07CisJZWxzZQorCQluZXRkZXYtPmZlYXR1cmVzICY9IH5ORVRJRl9GX0hXX0NTVU07CisKKwlyZXR1cm4gMDsKK30KKwordTMyIHN0bW1hY19ldGh0b29sX2dldF9yeF9jc3VtKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKworCXJldHVybiBwcml2LT5yeF9jc3VtOworfQorCitzdGF0aWMgdm9pZAorc3RtbWFjX2dldF9wYXVzZXBhcmFtKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsCisJCSAgICAgIHN0cnVjdCBldGh0b29sX3BhdXNlcGFyYW0gKnBhdXNlKQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KG5ldGRldik7CisKKwlzcGluX2xvY2soJnByaXYtPmxvY2spOworCisJcGF1c2UtPnJ4X3BhdXNlID0gMDsKKwlwYXVzZS0+dHhfcGF1c2UgPSAwOworCXBhdXNlLT5hdXRvbmVnID0gcHJpdi0+cGh5ZGV2LT5hdXRvbmVnOworCisJaWYgKHByaXYtPmZsb3dfY3RybCAmIEZMT1dfUlgpCisJCXBhdXNlLT5yeF9wYXVzZSA9IDE7CisJaWYgKHByaXYtPmZsb3dfY3RybCAmIEZMT1dfVFgpCisJCXBhdXNlLT50eF9wYXVzZSA9IDE7CisKKwlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisJcmV0dXJuOworfQorCitzdGF0aWMgaW50CitzdG1tYWNfc2V0X3BhdXNlcGFyYW0oc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwKKwkJICAgICAgc3RydWN0IGV0aHRvb2xfcGF1c2VwYXJhbSAqcGF1c2UpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwlzdHJ1Y3QgcGh5X2RldmljZSAqcGh5ID0gcHJpdi0+cGh5ZGV2OworCWludCBuZXdfcGF1c2UgPSBGTE9XX09GRjsKKwlpbnQgcmV0ID0gMDsKKworCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7CisKKwlpZiAocGF1c2UtPnJ4X3BhdXNlKQorCQluZXdfcGF1c2UgfD0gRkxPV19SWDsKKwlpZiAocGF1c2UtPnR4X3BhdXNlKQorCQluZXdfcGF1c2UgfD0gRkxPV19UWDsKKworCXByaXYtPmZsb3dfY3RybCA9IG5ld19wYXVzZTsKKworCWlmIChwaHktPmF1dG9uZWcpIHsKKwkJaWYgKG5ldGlmX3J1bm5pbmcobmV0ZGV2KSkgeworCQkJc3RydWN0IGV0aHRvb2xfY21kIGNtZDsKKwkJCS8qIGF1dG8tbmVnb3RpYXRpb24gYXV0b21hdGljYWxseSByZXN0YXJ0ZWQgKi8KKwkJCWNtZC5jbWQgPSBFVEhUT09MX05XQVlfUlNUOworCQkJY21kLnN1cHBvcnRlZCA9IHBoeS0+c3VwcG9ydGVkOworCQkJY21kLmFkdmVydGlzaW5nID0gcGh5LT5hZHZlcnRpc2luZzsKKwkJCWNtZC5hdXRvbmVnID0gcGh5LT5hdXRvbmVnOworCQkJY21kLnNwZWVkID0gcGh5LT5zcGVlZDsKKwkJCWNtZC5kdXBsZXggPSBwaHktPmR1cGxleDsKKwkJCWNtZC5waHlfYWRkcmVzcyA9IHBoeS0+YWRkcjsKKwkJCXJldCA9IHBoeV9ldGh0b29sX3NzZXQocGh5LCAmY21kKTsKKwkJfQorCX0gZWxzZSB7CisJCXVuc2lnbmVkIGxvbmcgaW9hZGRyID0gbmV0ZGV2LT5iYXNlX2FkZHI7CisJCXByaXYtPm1hY190eXBlLT5vcHMtPmZsb3dfY3RybChpb2FkZHIsIHBoeS0+ZHVwbGV4LAorCQkJCQkgICAgICAgcHJpdi0+Zmxvd19jdHJsLCBwcml2LT5wYXVzZSk7CisJfQorCXNwaW5fdW5sb2NrKCZwcml2LT5sb2NrKTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZCBzdG1tYWNfZ2V0X2V0aHRvb2xfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKKwkJCQkgc3RydWN0IGV0aHRvb2xfc3RhdHMgKmR1bW15LCB1NjQgKmRhdGEpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwl1bnNpZ25lZCBsb25nIGlvYWRkciA9IGRldi0+YmFzZV9hZGRyOworCWludCBpOworCisJLyogVXBkYXRlIEhXIHN0YXRzIGlmIHN1cHBvcnRlZCAqLworCXByaXYtPm1hY190eXBlLT5vcHMtPmRtYV9kaWFnbm9zdGljX2ZyKCZkZXYtPnN0YXRzLCAmcHJpdi0+eHN0YXRzLAorCQkJCQkgICAgICAgaW9hZGRyKTsKKworCWZvciAoaSA9IDA7IGkgPCBTVE1NQUNfU1RBVFNfTEVOOyBpKyspIHsKKwkJY2hhciAqcCA9IChjaGFyICopcHJpdiArIHN0bW1hY19nc3RyaW5nc19zdGF0c1tpXS5zdGF0X29mZnNldDsKKwkJZGF0YVtpXSA9IChzdG1tYWNfZ3N0cmluZ3Nfc3RhdHNbaV0uc2l6ZW9mX3N0YXQgPT0KKwkJc2l6ZW9mKHU2NCkpID8gKCoodTY0ICopcCkgOiAoKih1MzIgKilwKTsKKwl9CisKKwlyZXR1cm47Cit9CisKK3N0YXRpYyBpbnQgc3RtbWFjX2dldF9zc2V0X2NvdW50KHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsIGludCBzc2V0KQoreworCXN3aXRjaCAoc3NldCkgeworCWNhc2UgRVRIX1NTX1NUQVRTOgorCQlyZXR1cm4gU1RNTUFDX1NUQVRTX0xFTjsKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVPUE5PVFNVUFA7CisJfQorfQorCitzdGF0aWMgdm9pZCBzdG1tYWNfZ2V0X3N0cmluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgdTMyIHN0cmluZ3NldCwgdTggKmRhdGEpCit7CisJaW50IGk7CisJdTggKnAgPSBkYXRhOworCisJc3dpdGNoIChzdHJpbmdzZXQpIHsKKwljYXNlIEVUSF9TU19TVEFUUzoKKwkJZm9yIChpID0gMDsgaSA8IFNUTU1BQ19TVEFUU19MRU47IGkrKykgeworCQkJbWVtY3B5KHAsIHN0bW1hY19nc3RyaW5nc19zdGF0c1tpXS5zdGF0X3N0cmluZywKKwkJCQlFVEhfR1NUUklOR19MRU4pOworCQkJcCArPSBFVEhfR1NUUklOR19MRU47CisJCX0KKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJV0FSTl9PTigxKTsKKwkJYnJlYWs7CisJfQorCXJldHVybjsKK30KKworLyogQ3VycmVudGx5IG9ubHkgc3VwcG9ydCBXT0wgdGhyb3VnaCBNYWdpYyBwYWNrZXQuICovCitzdGF0aWMgdm9pZCBzdG1tYWNfZ2V0X3dvbChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgZXRodG9vbF93b2xpbmZvICp3b2wpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKworCXNwaW5fbG9ja19pcnEoJnByaXYtPmxvY2spOworCWlmIChwcml2LT53b2xlbmFibGVkID09IFBNVF9TVVBQT1JURUQpIHsKKwkJd29sLT5zdXBwb3J0ZWQgPSBXQUtFX01BR0lDOworCQl3b2wtPndvbG9wdHMgPSBwcml2LT53b2xvcHRzOworCX0KKwlzcGluX3VubG9ja19pcnEoJnByaXYtPmxvY2spOworfQorCitzdGF0aWMgaW50IHN0bW1hY19zZXRfd29sKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBldGh0b29sX3dvbGluZm8gKndvbCkKK3sKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOworCXUzMiBzdXBwb3J0ID0gV0FLRV9NQUdJQzsKKworCWlmIChwcml2LT53b2xlbmFibGVkID09IFBNVF9OT1RfU1VQUE9SVEVEKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmICh3b2wtPndvbG9wdHMgJiB+c3VwcG9ydCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAod29sLT53b2xvcHRzID09IDApCisJCWRldmljZV9zZXRfd2FrZXVwX2VuYWJsZShwcml2LT5kZXZpY2UsIDApOworCWVsc2UKKwkJZGV2aWNlX3NldF93YWtldXBfZW5hYmxlKHByaXYtPmRldmljZSwgMSk7CisKKwlzcGluX2xvY2tfaXJxKCZwcml2LT5sb2NrKTsKKwlwcml2LT53b2xvcHRzID0gd29sLT53b2xvcHRzOworCXNwaW5fdW5sb2NrX2lycSgmcHJpdi0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBldGh0b29sX29wcyBzdG1tYWNfZXRodG9vbF9vcHMgPSB7CisJLmJlZ2luID0gc3RtbWFjX2NoZWNrX2lmX3J1bm5pbmcsCisJLmdldF9kcnZpbmZvID0gc3RtbWFjX2V0aHRvb2xfZ2V0ZHJ2aW5mbywKKwkuZ2V0X3NldHRpbmdzID0gc3RtbWFjX2V0aHRvb2xfZ2V0c2V0dGluZ3MsCisJLnNldF9zZXR0aW5ncyA9IHN0bW1hY19ldGh0b29sX3NldHNldHRpbmdzLAorCS5nZXRfbXNnbGV2ZWwgPSBzdG1tYWNfZXRodG9vbF9nZXRtc2dsZXZlbCwKKwkuc2V0X21zZ2xldmVsID0gc3RtbWFjX2V0aHRvb2xfc2V0bXNnbGV2ZWwsCisJLmdldF9yZWdzID0gc3RtbWFjX2V0aHRvb2xfZ3JlZ3MsCisJLmdldF9yZWdzX2xlbiA9IHN0bW1hY19ldGh0b29sX2dldF9yZWdzX2xlbiwKKwkuZ2V0X2xpbmsgPSBldGh0b29sX29wX2dldF9saW5rLAorCS5nZXRfcnhfY3N1bSA9IHN0bW1hY19ldGh0b29sX2dldF9yeF9jc3VtLAorCS5nZXRfdHhfY3N1bSA9IGV0aHRvb2xfb3BfZ2V0X3R4X2NzdW0sCisJLnNldF90eF9jc3VtID0gc3RtbWFjX2V0aHRvb2xfc2V0X3R4X2NzdW0sCisJLmdldF9zZyA9IGV0aHRvb2xfb3BfZ2V0X3NnLAorCS5zZXRfc2cgPSBldGh0b29sX29wX3NldF9zZywKKwkuZ2V0X3BhdXNlcGFyYW0gPSBzdG1tYWNfZ2V0X3BhdXNlcGFyYW0sCisJLnNldF9wYXVzZXBhcmFtID0gc3RtbWFjX3NldF9wYXVzZXBhcmFtLAorCS5nZXRfZXRodG9vbF9zdGF0cyA9IHN0bW1hY19nZXRfZXRodG9vbF9zdGF0cywKKwkuZ2V0X3N0cmluZ3MgPSBzdG1tYWNfZ2V0X3N0cmluZ3MsCisJLmdldF93b2wgPSBzdG1tYWNfZ2V0X3dvbCwKKwkuc2V0X3dvbCA9IHN0bW1hY19zZXRfd29sLAorCS5nZXRfc3NldF9jb3VudAk9IHN0bW1hY19nZXRfc3NldF9jb3VudCwKKyNpZmRlZiBORVRJRl9GX1RTTworCS5nZXRfdHNvID0gZXRodG9vbF9vcF9nZXRfdHNvLAorCS5zZXRfdHNvID0gZXRodG9vbF9vcF9zZXRfdHNvLAorI2VuZGlmCit9OworCit2b2lkIHN0bW1hY19zZXRfZXRodG9vbF9vcHMoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlTRVRfRVRIVE9PTF9PUFMobmV0ZGV2LCAmc3RtbWFjX2V0aHRvb2xfb3BzKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3N0bW1hYy9zdG1tYWNfbWFpbi5jIGIvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hY19tYWluLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzJmMTRkYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L3N0bW1hYy9zdG1tYWNfbWFpbi5jCkBAIC0wLDAgKzEsMjIwNCBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAgVGhpcyBpcyB0aGUgZHJpdmVyIGZvciB0aGUgU1QgTUFDIDEwLzEwMC8xMDAwIG9uLWNoaXAgRXRoZXJuZXQgY29udHJvbGxlcnMuCisgIFNUIEV0aGVybmV0IElQcyBhcmUgYnVpbHQgYXJvdW5kIGEgU3lub3BzeXMgSVAgQ29yZS4KKworICBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOSAgU1RNaWNyb2VsZWN0cm9uaWNzIEx0ZAorCisgIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgIHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UsCisgIHZlcnNpb24gMiwgYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCisKKyAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIGl0IHdpbGwgYmUgdXNlZnVsLCBidXQgV0lUSE9VVAorICBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IKKyAgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvcgorICBtb3JlIGRldGFpbHMuCisKKyAgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYWxvbmcgd2l0aAorICB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwKKyAgNTEgRnJhbmtsaW4gU3QgLSBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxIFVTQS4KKworICBUaGUgZnVsbCBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBpcyBpbmNsdWRlZCBpbiB0aGlzIGRpc3RyaWJ1dGlvbiBpbgorICB0aGUgZmlsZSBjYWxsZWQgIkNPUFlJTkciLgorCisgIEF1dGhvcjogR2l1c2VwcGUgQ2F2YWxsYXJvIDxwZXBwZS5jYXZhbGxhcm9Ac3QuY29tPgorCisgIERvY3VtZW50YXRpb24gYXZhaWxhYmxlIGF0OgorCWh0dHA6Ly93d3cuc3RsaW51eC5jb20KKyAgU3VwcG9ydCBhdmFpbGFibGUgYXQ6CisJaHR0cHM6Ly9idWd6aWxsYS5zdGxpbnV4LmNvbS8KKyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CisjaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wbGF0Zm9ybV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9pcC5oPgorI2luY2x1ZGUgPGxpbnV4L3RjcC5oPgorI2luY2x1ZGUgPGxpbnV4L3NrYnVmZi5oPgorI2luY2x1ZGUgPGxpbnV4L2V0aHRvb2wuaD4KKyNpbmNsdWRlIDxsaW51eC9pZl9ldGhlci5oPgorI2luY2x1ZGUgPGxpbnV4L2NyYzMyLmg+CisjaW5jbHVkZSA8bGludXgvbWlpLmg+CisjaW5jbHVkZSA8bGludXgvcGh5Lmg+CisjaW5jbHVkZSA8bGludXgvaWZfdmxhbi5oPgorI2luY2x1ZGUgPGxpbnV4L2RtYS1tYXBwaW5nLmg+CisjaW5jbHVkZSA8bGludXgvc3RtL3NvYy5oPgorI2luY2x1ZGUgInN0bW1hYy5oIgorCisjZGVmaW5lIFNUTU1BQ19SRVNPVVJDRV9OQU1FCSJzdG1tYWNldGgiCisjZGVmaW5lIFBIWV9SRVNPVVJDRV9OQU1FCSJzdG1tYWNwaHkiCisKKyN1bmRlZiBTVE1NQUNfREVCVUcKKy8qI2RlZmluZSBTVE1NQUNfREVCVUcqLworI2lmZGVmIFNUTU1BQ19ERUJVRworI2RlZmluZSBEQkcobmxldmVsLCBrbGV2ZWwsIGZtdCwgYXJncy4uLikgXAorCQkoKHZvaWQpKG5ldGlmX21zZ18jI25sZXZlbChwcml2KSAmJiBcCisJCXByaW50ayhLRVJOXyMja2xldmVsIGZtdCwgIyMgYXJncykpKQorI2Vsc2UKKyNkZWZpbmUgREJHKG5sZXZlbCwga2xldmVsLCBmbXQsIGFyZ3MuLi4pIGRvIHsgfSB3aGlsZSAoMCkKKyNlbmRpZgorCisjdW5kZWYgU1RNTUFDX1JYX0RFQlVHCisvKiNkZWZpbmUgU1RNTUFDX1JYX0RFQlVHKi8KKyNpZmRlZiBTVE1NQUNfUlhfREVCVUcKKyNkZWZpbmUgUlhfREJHKGZtdCwgYXJncy4uLikgIHByaW50ayhmbXQsICMjIGFyZ3MpCisjZWxzZQorI2RlZmluZSBSWF9EQkcoZm10LCBhcmdzLi4uKSAgZG8geyB9IHdoaWxlICgwKQorI2VuZGlmCisKKyN1bmRlZiBTVE1NQUNfWE1JVF9ERUJVRworLyojZGVmaW5lIFNUTU1BQ19YTUlUX0RFQlVHKi8KKyNpZmRlZiBTVE1NQUNfVFhfREVCVUcKKyNkZWZpbmUgVFhfREJHKGZtdCwgYXJncy4uLikgIHByaW50ayhmbXQsICMjIGFyZ3MpCisjZWxzZQorI2RlZmluZSBUWF9EQkcoZm10LCBhcmdzLi4uKSAgZG8geyB9IHdoaWxlICgwKQorI2VuZGlmCisKKyNkZWZpbmUgU1RNTUFDX0FMSUdOKHgpCUwxX0NBQ0hFX0FMSUdOKHgpCisjZGVmaW5lIEpVTUJPX0xFTgk5MDAwCisKKy8qIE1vZHVsZSBwYXJhbWV0ZXJzICovCisjZGVmaW5lIFRYX1RJTUVPIDUwMDAgLyogZGVmYXVsdCA1IHNlY29uZHMgKi8KK3N0YXRpYyBpbnQgd2F0Y2hkb2cgPSBUWF9USU1FTzsKK21vZHVsZV9wYXJhbSh3YXRjaGRvZywgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7CitNT0RVTEVfUEFSTV9ERVNDKHdhdGNoZG9nLCAiVHJhbnNtaXQgdGltZW91dCBpbiBtaWxsaXNlY29uZHMiKTsKKworc3RhdGljIGludCBkZWJ1ZyA9IC0xOwkJLyogLTE6IGRlZmF1bHQsIDA6IG5vIG91dHB1dCwgMTY6ICBhbGwgKi8KK21vZHVsZV9wYXJhbShkZWJ1ZywgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7CitNT0RVTEVfUEFSTV9ERVNDKGRlYnVnLCAiTWVzc2FnZSBMZXZlbCAoMDogbm8gb3V0cHV0LCAxNjogYWxsKSIpOworCitzdGF0aWMgaW50IHBoeWFkZHIgPSAtMTsKK21vZHVsZV9wYXJhbShwaHlhZGRyLCBpbnQsIFNfSVJVR08pOworTU9EVUxFX1BBUk1fREVTQyhwaHlhZGRyLCAiUGh5c2ljYWwgZGV2aWNlIGFkZHJlc3MiKTsKKworI2RlZmluZSBETUFfVFhfU0laRSAyNTYKK3N0YXRpYyBpbnQgZG1hX3R4c2l6ZSA9IERNQV9UWF9TSVpFOworbW9kdWxlX3BhcmFtKGRtYV90eHNpemUsIGludCwgU19JUlVHTyB8IFNfSVdVU1IpOworTU9EVUxFX1BBUk1fREVTQyhkbWFfdHhzaXplLCAiTnVtYmVyIG9mIGRlc2NyaXB0b3JzIGluIHRoZSBUWCBsaXN0Iik7CisKKyNkZWZpbmUgRE1BX1JYX1NJWkUgMjU2CitzdGF0aWMgaW50IGRtYV9yeHNpemUgPSBETUFfUlhfU0laRTsKK21vZHVsZV9wYXJhbShkbWFfcnhzaXplLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK01PRFVMRV9QQVJNX0RFU0MoZG1hX3J4c2l6ZSwgIk51bWJlciBvZiBkZXNjcmlwdG9ycyBpbiB0aGUgUlggbGlzdCIpOworCitzdGF0aWMgaW50IGZsb3dfY3RybCA9IEZMT1dfT0ZGOworbW9kdWxlX3BhcmFtKGZsb3dfY3RybCwgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7CitNT0RVTEVfUEFSTV9ERVNDKGZsb3dfY3RybCwgIkZsb3cgY29udHJvbCBhYmlsaXR5IFtvbi9vZmZdIik7CisKK3N0YXRpYyBpbnQgcGF1c2UgPSBQQVVTRV9USU1FOworbW9kdWxlX3BhcmFtKHBhdXNlLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK01PRFVMRV9QQVJNX0RFU0MocGF1c2UsICJGbG93IENvbnRyb2wgUGF1c2UgVGltZSIpOworCisjZGVmaW5lIFRDX0RFRkFVTFQgNjQKK3N0YXRpYyBpbnQgdGMgPSBUQ19ERUZBVUxUOworbW9kdWxlX3BhcmFtKHRjLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK01PRFVMRV9QQVJNX0RFU0ModGMsICJETUEgdGhyZXNob2xkIGNvbnRyb2wgdmFsdWUiKTsKKworI2RlZmluZSBSWF9OT19DT0FMRVNDRQkxCS8qIEFsd2F5cyBpbnRlcnJ1cHQgb24gY29tcGxldGlvbiAqLworI2RlZmluZSBUWF9OT19DT0FMRVNDRQktMQkvKiBObyBtb2RlcmF0aW9uIGJ5IGRlZmF1bHQgKi8KKworLyogUGF5IGF0dGVudGlvbiB0byB0dW5lIHRoaXMgcGFyYW1ldGVyOyB0YWtlIGNhcmUgb2YgYm90aAorICogaGFyZHdhcmUgY2FwYWJpbGl0eSBhbmQgbmV0d29yayBzdGFiaXRpbHkvcGVyZm9ybWFuY2UgaW1wYWN0LgorICogTWFueSB0ZXN0cyBzaG93ZWQgdGhhdCB+NG1zIGxhdGVuY3kgc2VlbXMgdG8gYmUgZ29vZCBlbm91Z2guICovCisjaWZkZWYgQ09ORklHX1NUTU1BQ19USU1FUgorI2RlZmluZSBERUZBVUxUX1BFUklPRElDX1JBVEUJMjU2CitzdGF0aWMgaW50IHRtcmF0ZSA9IERFRkFVTFRfUEVSSU9ESUNfUkFURTsKK21vZHVsZV9wYXJhbSh0bXJhdGUsIGludCwgU19JUlVHTyB8IFNfSVdVU1IpOworTU9EVUxFX1BBUk1fREVTQyh0bXJhdGUsICJFeHRlcm5hbCB0aW1lciBmcmVxLiAoZGVmYXVsdDogMjU2SHopIik7CisjZW5kaWYKKworI2RlZmluZSBETUFfQlVGRkVSX1NJWkUJQlVGX1NJWkVfMktpQgorc3RhdGljIGludCBidWZfc3ogPSBETUFfQlVGRkVSX1NJWkU7Cittb2R1bGVfcGFyYW0oYnVmX3N6LCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK01PRFVMRV9QQVJNX0RFU0MoYnVmX3N6LCAiRE1BIGJ1ZmZlciBzaXplIik7CisKKy8qIEluIGNhc2Ugb2YgR2lnYSBFVEgsIHdlIGNhbiBlbmFibGUvZGlzYWJsZSB0aGUgQ09FIGZvciB0aGUKKyAqIHRyYW5zbWl0IEhXIGNoZWNrc3VtIGNvbXB1dGF0aW9uLgorICogTm90ZSB0aGF0LCBpZiB0eCBjc3VtIGlzIG9mZiBpbiBIVywgU0cgd2lsbCBiZSBzdGlsbCBzdXBwb3J0ZWQuICovCitzdGF0aWMgaW50IHR4X2NvZSA9IEhXX0NTVU07Cittb2R1bGVfcGFyYW0odHhfY29lLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK01PRFVMRV9QQVJNX0RFU0ModHhfY29lLCAiR01BQyBDT0UgdHlwZSAyIFtvbi9vZmZdIik7CisKK3N0YXRpYyBjb25zdCB1MzIgZGVmYXVsdF9tc2dfbGV2ZWwgPSAoTkVUSUZfTVNHX0RSViB8IE5FVElGX01TR19QUk9CRSB8CisJCQkJICAgICAgTkVUSUZfTVNHX0xJTksgfCBORVRJRl9NU0dfSUZVUCB8CisJCQkJICAgICAgTkVUSUZfTVNHX0lGRE9XTiB8IE5FVElGX01TR19USU1FUik7CisKK3N0YXRpYyBpcnFyZXR1cm5fdCBzdG1tYWNfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCk7CitzdGF0aWMgbmV0ZGV2X3R4X3Qgc3RtbWFjX3htaXQoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CisKKy8qKgorICogc3RtbWFjX3ZlcmlmeV9hcmdzIC0gdmVyaWZ5IHRoZSBkcml2ZXIgcGFyYW1ldGVycy4KKyAqIERlc2NyaXB0aW9uOiBpdCB2ZXJpZmllcyBpZiBzb21lIHdyb25nIHBhcmFtZXRlciBpcyBwYXNzZWQgdG8gdGhlIGRyaXZlci4KKyAqIE5vdGUgdGhhdCB3cm9uZyBwYXJhbWV0ZXJzIGFyZSByZXBsYWNlZCB3aXRoIHRoZSBkZWZhdWx0IHZhbHVlcy4KKyAqLworc3RhdGljIHZvaWQgc3RtbWFjX3ZlcmlmeV9hcmdzKHZvaWQpCit7CisJaWYgKHVubGlrZWx5KHdhdGNoZG9nIDwgMCkpCisJCXdhdGNoZG9nID0gVFhfVElNRU87CisJaWYgKHVubGlrZWx5KGRtYV9yeHNpemUgPCAwKSkKKwkJZG1hX3J4c2l6ZSA9IERNQV9SWF9TSVpFOworCWlmICh1bmxpa2VseShkbWFfdHhzaXplIDwgMCkpCisJCWRtYV90eHNpemUgPSBETUFfVFhfU0laRTsKKwlpZiAodW5saWtlbHkoKGJ1Zl9zeiA8IERNQV9CVUZGRVJfU0laRSkgfHwgKGJ1Zl9zeiA+IEJVRl9TSVpFXzE2S2lCKSkpCisJCWJ1Zl9zeiA9IERNQV9CVUZGRVJfU0laRTsKKwlpZiAodW5saWtlbHkoZmxvd19jdHJsID4gMSkpCisJCWZsb3dfY3RybCA9IEZMT1dfQVVUTzsKKwllbHNlIGlmIChsaWtlbHkoZmxvd19jdHJsIDwgMCkpCisJCWZsb3dfY3RybCA9IEZMT1dfT0ZGOworCWlmICh1bmxpa2VseSgocGF1c2UgPCAwKSB8fCAocGF1c2UgPiAweGZmZmYpKSkKKwkJcGF1c2UgPSBQQVVTRV9USU1FOworCisJcmV0dXJuOworfQorCisjaWYgZGVmaW5lZChTVE1NQUNfWE1JVF9ERUJVRykgfHwgZGVmaW5lZChTVE1NQUNfUlhfREVCVUcpCitzdGF0aWMgdm9pZCBwcmludF9wa3QodW5zaWduZWQgY2hhciAqYnVmLCBpbnQgbGVuKQoreworCWludCBqOworCXByX2luZm8oImxlbiA9ICVkIGJ5dGUsIGJ1ZiBhZGRyOiAweCVwIiwgbGVuLCBidWYpOworCWZvciAoaiA9IDA7IGogPCBsZW47IGorKykgeworCQlpZiAoKGogJSAxNikgPT0gMCkKKwkJCXByX2luZm8oIlxuICUwM3g6Iiwgaik7CisJCXByX2luZm8oIiAlMDJ4IiwgYnVmW2pdKTsKKwl9CisJcHJfaW5mbygiXG4iKTsKKwlyZXR1cm47Cit9CisjZW5kaWYKKworLyogbWluaW11bSBudW1iZXIgb2YgZnJlZSBUWCBkZXNjcmlwdG9ycyByZXF1aXJlZCB0byB3YWtlIHVwIFRYIHByb2Nlc3MgKi8KKyNkZWZpbmUgU1RNTUFDX1RYX1RIUkVTSCh4KQkoeC0+ZG1hX3R4X3NpemUvNCkKKworc3RhdGljIGlubGluZSB1MzIgc3RtbWFjX3R4X2F2YWlsKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKwlyZXR1cm4gcHJpdi0+ZGlydHlfdHggKyBwcml2LT5kbWFfdHhfc2l6ZSAtIHByaXYtPmN1cl90eCAtIDE7Cit9CisKKy8qKgorICogc3RtbWFjX2FkanVzdF9saW5rCisgKiBAZGV2OiBuZXQgZGV2aWNlIHN0cnVjdHVyZQorICogRGVzY3JpcHRpb246IGl0IGFkanVzdHMgdGhlIGxpbmsgcGFyYW1ldGVycy4KKyAqLworc3RhdGljIHZvaWQgc3RtbWFjX2FkanVzdF9saW5rKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwlzdHJ1Y3QgcGh5X2RldmljZSAqcGh5ZGV2ID0gcHJpdi0+cGh5ZGV2OworCXVuc2lnbmVkIGxvbmcgaW9hZGRyID0gZGV2LT5iYXNlX2FkZHI7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlpbnQgbmV3X3N0YXRlID0gMDsKKwl1bnNpZ25lZCBpbnQgZmMgPSBwcml2LT5mbG93X2N0cmwsIHBhdXNlX3RpbWUgPSBwcml2LT5wYXVzZTsKKworCWlmIChwaHlkZXYgPT0gTlVMTCkKKwkJcmV0dXJuOworCisJREJHKHByb2JlLCBERUJVRywgInN0bW1hY19hZGp1c3RfbGluazogY2FsbGVkLiAgYWRkcmVzcyAlZCBsaW5rICVkXG4iLAorCSAgICBwaHlkZXYtPmFkZHIsIHBoeWRldi0+bGluayk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+bG9jaywgZmxhZ3MpOworCWlmIChwaHlkZXYtPmxpbmspIHsKKwkJdTMyIGN0cmwgPSByZWFkbChpb2FkZHIgKyBNQUNfQ1RSTF9SRUcpOworCisJCS8qIE5vdyB3ZSBtYWtlIHN1cmUgdGhhdCB3ZSBjYW4gYmUgaW4gZnVsbCBkdXBsZXggbW9kZS4KKwkJICogSWYgbm90LCB3ZSBvcGVyYXRlIGluIGhhbGYtZHVwbGV4IG1vZGUuICovCisJCWlmIChwaHlkZXYtPmR1cGxleCAhPSBwcml2LT5vbGRkdXBsZXgpIHsKKwkJCW5ld19zdGF0ZSA9IDE7CisJCQlpZiAoIShwaHlkZXYtPmR1cGxleCkpCisJCQkJY3RybCAmPSB+cHJpdi0+bWFjX3R5cGUtPmh3LmxpbmsuZHVwbGV4OworCQkJZWxzZQorCQkJCWN0cmwgfD0gcHJpdi0+bWFjX3R5cGUtPmh3LmxpbmsuZHVwbGV4OworCQkJcHJpdi0+b2xkZHVwbGV4ID0gcGh5ZGV2LT5kdXBsZXg7CisJCX0KKwkJLyogRmxvdyBDb250cm9sIG9wZXJhdGlvbiAqLworCQlpZiAocGh5ZGV2LT5wYXVzZSkKKwkJCXByaXYtPm1hY190eXBlLT5vcHMtPmZsb3dfY3RybChpb2FkZHIsIHBoeWRldi0+ZHVwbGV4LAorCQkJCQkJICAgICAgIGZjLCBwYXVzZV90aW1lKTsKKworCQlpZiAocGh5ZGV2LT5zcGVlZCAhPSBwcml2LT5zcGVlZCkgeworCQkJbmV3X3N0YXRlID0gMTsKKwkJCXN3aXRjaCAocGh5ZGV2LT5zcGVlZCkgeworCQkJY2FzZSAxMDAwOgorCQkJCWlmIChsaWtlbHkocHJpdi0+aXNfZ21hYykpCisJCQkJCWN0cmwgJj0gfnByaXYtPm1hY190eXBlLT5ody5saW5rLnBvcnQ7CisJCQkJYnJlYWs7CisJCQljYXNlIDEwMDoKKwkJCWNhc2UgMTA6CisJCQkJaWYgKHByaXYtPmlzX2dtYWMpIHsKKwkJCQkJY3RybCB8PSBwcml2LT5tYWNfdHlwZS0+aHcubGluay5wb3J0OworCQkJCQlpZiAocGh5ZGV2LT5zcGVlZCA9PSBTUEVFRF8xMDApIHsKKwkJCQkJCWN0cmwgfD0KKwkJCQkJCSAgICBwcml2LT5tYWNfdHlwZS0+aHcubGluay4KKwkJCQkJCSAgICBzcGVlZDsKKwkJCQkJfSBlbHNlIHsKKwkJCQkJCWN0cmwgJj0KKwkJCQkJCSAgICB+KHByaXYtPm1hY190eXBlLT5ody4KKwkJCQkJCSAgICAgIGxpbmsuc3BlZWQpOworCQkJCQl9CisJCQkJfSBlbHNlIHsKKwkJCQkJY3RybCAmPSB+cHJpdi0+bWFjX3R5cGUtPmh3LmxpbmsucG9ydDsKKwkJCQl9CisJCQkJcHJpdi0+Zml4X21hY19zcGVlZChwcml2LT5ic3BfcHJpdiwKKwkJCQkJCSAgICBwaHlkZXYtPnNwZWVkKTsKKwkJCQlicmVhazsKKwkJCWRlZmF1bHQ6CisJCQkJaWYgKG5ldGlmX21zZ19saW5rKHByaXYpKQorCQkJCQlwcl93YXJuaW5nKCIlczogU3BlZWQgKCVkKSBpcyBub3QgMTAiCisJCQkJICAgICAgICIgb3IgMTAwIVxuIiwgZGV2LT5uYW1lLCBwaHlkZXYtPnNwZWVkKTsKKwkJCQlicmVhazsKKwkJCX0KKworCQkJcHJpdi0+c3BlZWQgPSBwaHlkZXYtPnNwZWVkOworCQl9CisKKwkJd3JpdGVsKGN0cmwsIGlvYWRkciArIE1BQ19DVFJMX1JFRyk7CisKKwkJaWYgKCFwcml2LT5vbGRsaW5rKSB7CisJCQluZXdfc3RhdGUgPSAxOworCQkJcHJpdi0+b2xkbGluayA9IDE7CisJCX0KKwl9IGVsc2UgaWYgKHByaXYtPm9sZGxpbmspIHsKKwkJbmV3X3N0YXRlID0gMTsKKwkJcHJpdi0+b2xkbGluayA9IDA7CisJCXByaXYtPnNwZWVkID0gMDsKKwkJcHJpdi0+b2xkZHVwbGV4ID0gLTE7CisJfQorCisJaWYgKG5ld19zdGF0ZSAmJiBuZXRpZl9tc2dfbGluayhwcml2KSkKKwkJcGh5X3ByaW50X3N0YXR1cyhwaHlkZXYpOworCisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+bG9jaywgZmxhZ3MpOworCisJREJHKHByb2JlLCBERUJVRywgInN0bW1hY19hZGp1c3RfbGluazogZXhpdGluZ1xuIik7Cit9CisKKy8qKgorICogc3RtbWFjX2luaXRfcGh5IC0gUEhZIGluaXRpYWxpemF0aW9uCisgKiBAZGV2OiBuZXQgZGV2aWNlIHN0cnVjdHVyZQorICogRGVzY3JpcHRpb246IGl0IGluaXRpYWxpemVzIHRoZSBkcml2ZXIncyBQSFkgc3RhdGUsIGFuZCBhdHRhY2hlcyB0aGUgUEhZCisgKiB0byB0aGUgbWFjIGRyaXZlci4KKyAqICBSZXR1cm4gdmFsdWU6CisgKiAgMCBvbiBzdWNjZXNzCisgKi8KK3N0YXRpYyBpbnQgc3RtbWFjX2luaXRfcGh5KHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwlzdHJ1Y3QgcGh5X2RldmljZSAqcGh5ZGV2OworCWNoYXIgcGh5X2lkW0JVU19JRF9TSVpFXTsJLyogUEhZIHRvIGNvbm5lY3QgKi8KKwljaGFyIGJ1c19pZFtCVVNfSURfU0laRV07CisKKwlwcml2LT5vbGRsaW5rID0gMDsKKwlwcml2LT5zcGVlZCA9IDA7CisJcHJpdi0+b2xkZHVwbGV4ID0gLTE7CisKKwlpZiAocHJpdi0+cGh5X2FkZHIgPT0gLTEpIHsKKwkJLyogV2UgZG9uJ3QgaGF2ZSBhIFBIWSwgc28gZG8gbm90aGluZyAqLworCQlyZXR1cm4gMDsKKwl9CisKKwlzbnByaW50ZihidXNfaWQsIE1JSV9CVVNfSURfU0laRSwgIiV4IiwgcHJpdi0+YnVzX2lkKTsKKwlzbnByaW50ZihwaHlfaWQsIEJVU19JRF9TSVpFLCBQSFlfSURfRk1ULCBidXNfaWQsIHByaXYtPnBoeV9hZGRyKTsKKwlwcl9kZWJ1Zygic3RtbWFjX2luaXRfcGh5OiAgdHJ5aW5nIHRvIGF0dGFjaCB0byAlc1xuIiwgcGh5X2lkKTsKKworCXBoeWRldiA9IHBoeV9jb25uZWN0KGRldiwgcGh5X2lkLCAmc3RtbWFjX2FkanVzdF9saW5rLCAwLAorCQkJcHJpdi0+cGh5X2ludGVyZmFjZSk7CisKKwlpZiAoSVNfRVJSKHBoeWRldikpIHsKKwkJcHJfZXJyKCIlczogQ291bGQgbm90IGF0dGFjaCB0byBQSFlcbiIsIGRldi0+bmFtZSk7CisJCXJldHVybiBQVFJfRVJSKHBoeWRldik7CisJfQorCisJLyoKKwkgKiBCcm9rZW4gSFcgaXMgc29tZXRpbWVzIG1pc3NpbmcgdGhlIHB1bGwtdXAgcmVzaXN0b3Igb24gdGhlCisJICogTURJTyBsaW5lLCB3aGljaCByZXN1bHRzIGluIHJlYWRzIHRvIG5vbi1leGlzdGVudCBkZXZpY2VzIHJldHVybmluZworCSAqIDAgcmF0aGVyIHRoYW4gMHhmZmZmLiBDYXRjaCB0aGlzIGhlcmUgYW5kIHRyZWF0IDAgYXMgYSBub24tZXhpc3RlbnQKKwkgKiBkZXZpY2UgYXMgd2VsbC4KKwkgKiBOb3RlOiBwaHlkZXYtPnBoeV9pZCBpcyB0aGUgcmVzdWx0IG9mIHJlYWRpbmcgdGhlIFVJRCBQSFkgcmVnaXN0ZXJzLgorCSAqLworCWlmIChwaHlkZXYtPnBoeV9pZCA9PSAwKSB7CisJCXBoeV9kaXNjb25uZWN0KHBoeWRldik7CisJCXJldHVybiAtRU5PREVWOworCX0KKwlwcl9kZWJ1Zygic3RtbWFjX2luaXRfcGh5OiAgJXM6IGF0dGFjaGVkIHRvIFBIWSAoVUlEIDB4JXgpIgorCSAgICAgICAiIExpbmsgPSAlZFxuIiwgZGV2LT5uYW1lLCBwaHlkZXYtPnBoeV9pZCwgcGh5ZGV2LT5saW5rKTsKKworCXByaXYtPnBoeWRldiA9IHBoeWRldjsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgc3RtbWFjX21hY19lbmFibGVfcngodW5zaWduZWQgbG9uZyBpb2FkZHIpCit7CisJdTMyIHZhbHVlID0gcmVhZGwoaW9hZGRyICsgTUFDX0NUUkxfUkVHKTsKKwl2YWx1ZSB8PSBNQUNfUk5BQkxFX1JYOworCS8qIFNldCB0aGUgUkUgKHJlY2VpdmUgZW5hYmxlIGJpdCBpbnRvIHRoZSBNQUMgQ1RSTCByZWdpc3RlcikuICAqLworCXdyaXRlbCh2YWx1ZSwgaW9hZGRyICsgTUFDX0NUUkxfUkVHKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHN0bW1hY19tYWNfZW5hYmxlX3R4KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIE1BQ19DVFJMX1JFRyk7CisJdmFsdWUgfD0gTUFDX0VOQUJMRV9UWDsKKwkvKiBTZXQgdGhlIFRFICh0cmFuc21pdCBlbmFibGUgYml0IGludG8gdGhlIE1BQyBDVFJMIHJlZ2lzdGVyKS4gICovCisJd3JpdGVsKHZhbHVlLCBpb2FkZHIgKyBNQUNfQ1RSTF9SRUcpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgc3RtbWFjX21hY19kaXNhYmxlX3J4KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIE1BQ19DVFJMX1JFRyk7CisJdmFsdWUgJj0gfk1BQ19STkFCTEVfUlg7CisJd3JpdGVsKHZhbHVlLCBpb2FkZHIgKyBNQUNfQ1RSTF9SRUcpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgc3RtbWFjX21hY19kaXNhYmxlX3R4KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIE1BQ19DVFJMX1JFRyk7CisJdmFsdWUgJj0gfk1BQ19FTkFCTEVfVFg7CisJd3JpdGVsKHZhbHVlLCBpb2FkZHIgKyBNQUNfQ1RSTF9SRUcpOworfQorCisvKioKKyAqIGRpc3BsYXlfcmluZworICogQHA6IHBvaW50ZXIgdG8gdGhlIHJpbmcuCisgKiBAc2l6ZTogc2l6ZSBvZiB0aGUgcmluZy4KKyAqIERlc2NyaXB0aW9uOiBkaXNwbGF5IGFsbCB0aGUgZGVzY3JpcHRvcnMgd2l0aGluIHRoZSByaW5nLgorICovCitzdGF0aWMgdm9pZCBkaXNwbGF5X3Jpbmcoc3RydWN0IGRtYV9kZXNjICpwLCBpbnQgc2l6ZSkKK3sKKwlzdHJ1Y3QgdG1wX3MgeworCQl1NjQgYTsKKwkJdW5zaWduZWQgaW50IGI7CisJCXVuc2lnbmVkIGludCBjOworCX07CisJaW50IGk7CisJZm9yIChpID0gMDsgaSA8IHNpemU7IGkrKykgeworCQlzdHJ1Y3QgdG1wX3MgKnggPSAoc3RydWN0IHRtcF9zICopKHAgKyBpKTsKKwkJcHJfaW5mbygiXHQlZCBbMHgleF06IERFUzA9MHgleCBERVMxPTB4JXggQlVGMT0weCV4IEJVRjI9MHgleCIsCisJCSAgICAgICBpLCAodW5zaWduZWQgaW50KXZpcnRfdG9fcGh5cygmcFtpXSksCisJCSAgICAgICAodW5zaWduZWQgaW50KSh4LT5hKSwgKHVuc2lnbmVkIGludCkoKHgtPmEpID4+IDMyKSwKKwkJICAgICAgIHgtPmIsIHgtPmMpOworCQlwcl9pbmZvKCJcbiIpOworCX0KK30KKworLyoqCisgKiBpbml0X2RtYV9kZXNjX3JpbmdzIC0gaW5pdCB0aGUgUlgvVFggZGVzY3JpcHRvciByaW5ncworICogQGRldjogbmV0IGRldmljZSBzdHJ1Y3R1cmUKKyAqIERlc2NyaXB0aW9uOiAgdGhpcyBmdW5jdGlvbiBpbml0aWFsaXplcyB0aGUgRE1BIFJYL1RYIGRlc2NyaXB0b3JzCisgKiBhbmQgYWxsb2NhdGVzIHRoZSBzb2NrZXQgYnVmZmVycy4KKyAqLworc3RhdGljIHZvaWQgaW5pdF9kbWFfZGVzY19yaW5ncyhzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCWludCBpOworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisJc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwl1bnNpZ25lZCBpbnQgdHhzaXplID0gcHJpdi0+ZG1hX3R4X3NpemU7CisJdW5zaWduZWQgaW50IHJ4c2l6ZSA9IHByaXYtPmRtYV9yeF9zaXplOworCXVuc2lnbmVkIGludCBiZnNpemUgPSBwcml2LT5kbWFfYnVmX3N6OworCWludCBidWZmMl9uZWVkZWQgPSAwOworCWludCBkaXNfaWMgPSAwOworCisjaWZkZWYgQ09ORklHX1NUTU1BQ19USU1FUgorCS8qIFVzaW5nIFRpbWVycyBkaXNhYmxlIGludGVycnVwdHMgb24gY29tcGxldGlvbiBmb3IgdGhlIHJlY2VwdGlvbiAqLworCWRpc19pYyA9IDE7CisjZW5kaWYKKwkvKiBTZXQgdGhlIEJ1ZmZlciBzaXplIGFjY29yZGluZyB0byB0aGUgTVRVOworCSAqIGluZGVlZCwgaW4gY2FzZSBvZiBqdW1ibyB3ZSBuZWVkIHRvIGJ1bXAtdXAgdGhlIGJ1ZmZlciBzaXplcy4KKwkgKi8KKwlpZiAodW5saWtlbHkoZGV2LT5tdHUgPj0gQlVGX1NJWkVfOEtpQikpCisJCWJmc2l6ZSA9IEJVRl9TSVpFXzE2S2lCOworCWVsc2UgaWYgKHVubGlrZWx5KGRldi0+bXR1ID49IEJVRl9TSVpFXzRLaUIpKQorCQliZnNpemUgPSBCVUZfU0laRV84S2lCOworCWVsc2UgaWYgKHVubGlrZWx5KGRldi0+bXR1ID49IEJVRl9TSVpFXzJLaUIpKQorCQliZnNpemUgPSBCVUZfU0laRV80S2lCOworCWVsc2UgaWYgKHVubGlrZWx5KGRldi0+bXR1ID49IERNQV9CVUZGRVJfU0laRSkpCisJCWJmc2l6ZSA9IEJVRl9TSVpFXzJLaUI7CisJZWxzZQorCQliZnNpemUgPSBETUFfQlVGRkVSX1NJWkU7CisKKwkvKiBJZiB0aGUgTVRVIGV4Y2VlZHMgOGsgc28gdXNlIHRoZSBzZWNvbmQgYnVmZmVyIGluIHRoZSBjaGFpbiAqLworCWlmIChiZnNpemUgPj0gQlVGX1NJWkVfOEtpQikKKwkJYnVmZjJfbmVlZGVkID0gMTsKKworCURCRyhwcm9iZSwgSU5GTywgInN0bW1hYzogdHhzaXplICVkLCByeHNpemUgJWQsIGJmc2l6ZSAlZFxuIiwKKwkgICAgdHhzaXplLCByeHNpemUsIGJmc2l6ZSk7CisKKwlwcml2LT5yeF9za2J1ZmZfZG1hID0ga21hbGxvYyhyeHNpemUgKiBzaXplb2YoZG1hX2FkZHJfdCksIEdGUF9LRVJORUwpOworCXByaXYtPnJ4X3NrYnVmZiA9CisJICAgIGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBza19idWZmICopICogcnhzaXplLCBHRlBfS0VSTkVMKTsKKwlwcml2LT5kbWFfcnggPQorCSAgICAoc3RydWN0IGRtYV9kZXNjICopZG1hX2FsbG9jX2NvaGVyZW50KHByaXYtPmRldmljZSwKKwkJCQkJCSAgcnhzaXplICoKKwkJCQkJCSAgc2l6ZW9mKHN0cnVjdCBkbWFfZGVzYyksCisJCQkJCQkgICZwcml2LT5kbWFfcnhfcGh5LAorCQkJCQkJICBHRlBfS0VSTkVMKTsKKwlwcml2LT50eF9za2J1ZmYgPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3Qgc2tfYnVmZiAqKSAqIHR4c2l6ZSwKKwkJCQkgICAgICAgR0ZQX0tFUk5FTCk7CisJcHJpdi0+ZG1hX3R4ID0KKwkgICAgKHN0cnVjdCBkbWFfZGVzYyAqKWRtYV9hbGxvY19jb2hlcmVudChwcml2LT5kZXZpY2UsCisJCQkJCQkgIHR4c2l6ZSAqCisJCQkJCQkgIHNpemVvZihzdHJ1Y3QgZG1hX2Rlc2MpLAorCQkJCQkJICAmcHJpdi0+ZG1hX3R4X3BoeSwKKwkJCQkJCSAgR0ZQX0tFUk5FTCk7CisKKwlpZiAoKHByaXYtPmRtYV9yeCA9PSBOVUxMKSB8fCAocHJpdi0+ZG1hX3R4ID09IE5VTEwpKSB7CisJCXByX2VycigiJXM6RVJST1IgYWxsb2NhdGluZyB0aGUgRE1BIFR4L1J4IGRlc2NcbiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuOworCX0KKworCURCRyhwcm9iZSwgSU5GTywgInN0bW1hYyAoJXMpIERNQSBkZXNjIHJpbmdzOiB2aXJ0IGFkZHIgKFJ4ICVwLCAiCisJICAgICJUeCAlcClcblx0RE1BIHBoeSBhZGRyIChSeCAweCUwOHgsIFR4IDB4JTA4eClcbiIsCisJICAgIGRldi0+bmFtZSwgcHJpdi0+ZG1hX3J4LCBwcml2LT5kbWFfdHgsCisJICAgICh1bnNpZ25lZCBpbnQpcHJpdi0+ZG1hX3J4X3BoeSwgKHVuc2lnbmVkIGludClwcml2LT5kbWFfdHhfcGh5KTsKKworCS8qIFJYIElOSVRJQUxJWkFUSU9OICovCisJREJHKHByb2JlLCBJTkZPLCAic3RtbWFjOiBTS0IgYWRkcmVzc2VzOlxuIgorCQkJICJza2JcdFx0c2tiIGRhdGFcdGRtYSBkYXRhXG4iKTsKKworCWZvciAoaSA9IDA7IGkgPCByeHNpemU7IGkrKykgeworCQlzdHJ1Y3QgZG1hX2Rlc2MgKnAgPSBwcml2LT5kbWFfcnggKyBpOworCisJCXNrYiA9IG5ldGRldl9hbGxvY19za2JfaXBfYWxpZ24oZGV2LCBiZnNpemUpOworCQlpZiAodW5saWtlbHkoc2tiID09IE5VTEwpKSB7CisJCQlwcl9lcnIoIiVzOiBSeCBpbml0IGZhaWxzOyBza2IgaXMgTlVMTFxuIiwgX19mdW5jX18pOworCQkJYnJlYWs7CisJCX0KKwkJcHJpdi0+cnhfc2tidWZmW2ldID0gc2tiOworCQlwcml2LT5yeF9za2J1ZmZfZG1hW2ldID0gZG1hX21hcF9zaW5nbGUocHJpdi0+ZGV2aWNlLCBza2ItPmRhdGEsCisJCQkJCQliZnNpemUsIERNQV9GUk9NX0RFVklDRSk7CisKKwkJcC0+ZGVzMiA9IHByaXYtPnJ4X3NrYnVmZl9kbWFbaV07CisJCWlmICh1bmxpa2VseShidWZmMl9uZWVkZWQpKQorCQkJcC0+ZGVzMyA9IHAtPmRlczIgKyBCVUZfU0laRV84S2lCOworCQlEQkcocHJvYmUsIElORk8sICJbJXBdXHRbJXBdXHRbJXhdXG4iLCBwcml2LT5yeF9za2J1ZmZbaV0sCisJCQlwcml2LT5yeF9za2J1ZmZbaV0tPmRhdGEsIHByaXYtPnJ4X3NrYnVmZl9kbWFbaV0pOworCX0KKwlwcml2LT5jdXJfcnggPSAwOworCXByaXYtPmRpcnR5X3J4ID0gKHVuc2lnbmVkIGludCkoaSAtIHJ4c2l6ZSk7CisJcHJpdi0+ZG1hX2J1Zl9zeiA9IGJmc2l6ZTsKKwlidWZfc3ogPSBiZnNpemU7CisKKwkvKiBUWCBJTklUSUFMSVpBVElPTiAqLworCWZvciAoaSA9IDA7IGkgPCB0eHNpemU7IGkrKykgeworCQlwcml2LT50eF9za2J1ZmZbaV0gPSBOVUxMOworCQlwcml2LT5kbWFfdHhbaV0uZGVzMiA9IDA7CisJfQorCXByaXYtPmRpcnR5X3R4ID0gMDsKKwlwcml2LT5jdXJfdHggPSAwOworCisJLyogQ2xlYXIgdGhlIFJ4L1R4IGRlc2NyaXB0b3JzICovCisJcHJpdi0+bWFjX3R5cGUtPm9wcy0+aW5pdF9yeF9kZXNjKHByaXYtPmRtYV9yeCwgcnhzaXplLCBkaXNfaWMpOworCXByaXYtPm1hY190eXBlLT5vcHMtPmluaXRfdHhfZGVzYyhwcml2LT5kbWFfdHgsIHR4c2l6ZSk7CisKKwlpZiAobmV0aWZfbXNnX2h3KHByaXYpKSB7CisJCXByX2luZm8oIlJYIGRlc2NyaXB0b3IgcmluZzpcbiIpOworCQlkaXNwbGF5X3JpbmcocHJpdi0+ZG1hX3J4LCByeHNpemUpOworCQlwcl9pbmZvKCJUWCBkZXNjcmlwdG9yIHJpbmc6XG4iKTsKKwkJZGlzcGxheV9yaW5nKHByaXYtPmRtYV90eCwgdHhzaXplKTsKKwl9CisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZCBkbWFfZnJlZV9yeF9za2J1ZnMoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQoreworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IHByaXYtPmRtYV9yeF9zaXplOyBpKyspIHsKKwkJaWYgKHByaXYtPnJ4X3NrYnVmZltpXSkgeworCQkJZG1hX3VubWFwX3NpbmdsZShwcml2LT5kZXZpY2UsIHByaXYtPnJ4X3NrYnVmZl9kbWFbaV0sCisJCQkJCSBwcml2LT5kbWFfYnVmX3N6LCBETUFfRlJPTV9ERVZJQ0UpOworCQkJZGV2X2tmcmVlX3NrYl9hbnkocHJpdi0+cnhfc2tidWZmW2ldKTsKKwkJfQorCQlwcml2LT5yeF9za2J1ZmZbaV0gPSBOVUxMOworCX0KKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIGRtYV9mcmVlX3R4X3NrYnVmcyhzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgcHJpdi0+ZG1hX3R4X3NpemU7IGkrKykgeworCQlpZiAocHJpdi0+dHhfc2tidWZmW2ldICE9IE5VTEwpIHsKKwkJCXN0cnVjdCBkbWFfZGVzYyAqcCA9IHByaXYtPmRtYV90eCArIGk7CisJCQlpZiAocC0+ZGVzMikKKwkJCQlkbWFfdW5tYXBfc2luZ2xlKHByaXYtPmRldmljZSwgcC0+ZGVzMiwKKwkJCQkgcHJpdi0+bWFjX3R5cGUtPm9wcy0+Z2V0X3R4X2xlbihwKSwKKwkJCQkgRE1BX1RPX0RFVklDRSk7CisJCQlkZXZfa2ZyZWVfc2tiX2FueShwcml2LT50eF9za2J1ZmZbaV0pOworCQkJcHJpdi0+dHhfc2tidWZmW2ldID0gTlVMTDsKKwkJfQorCX0KKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIGZyZWVfZG1hX2Rlc2NfcmVzb3VyY2VzKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKwkvKiBSZWxlYXNlIHRoZSBETUEgVFgvUlggc29ja2V0IGJ1ZmZlcnMgKi8KKwlkbWFfZnJlZV9yeF9za2J1ZnMocHJpdik7CisJZG1hX2ZyZWVfdHhfc2tidWZzKHByaXYpOworCisJLyogRnJlZSB0aGUgcmVnaW9uIG9mIGNvbnNpc3RlbnQgbWVtb3J5IHByZXZpb3VzbHkgYWxsb2NhdGVkIGZvcgorCSAqIHRoZSBETUEgKi8KKwlkbWFfZnJlZV9jb2hlcmVudChwcml2LT5kZXZpY2UsCisJCQkgIHByaXYtPmRtYV90eF9zaXplICogc2l6ZW9mKHN0cnVjdCBkbWFfZGVzYyksCisJCQkgIHByaXYtPmRtYV90eCwgcHJpdi0+ZG1hX3R4X3BoeSk7CisJZG1hX2ZyZWVfY29oZXJlbnQocHJpdi0+ZGV2aWNlLAorCQkJICBwcml2LT5kbWFfcnhfc2l6ZSAqIHNpemVvZihzdHJ1Y3QgZG1hX2Rlc2MpLAorCQkJICBwcml2LT5kbWFfcngsIHByaXYtPmRtYV9yeF9waHkpOworCWtmcmVlKHByaXYtPnJ4X3NrYnVmZl9kbWEpOworCWtmcmVlKHByaXYtPnJ4X3NrYnVmZik7CisJa2ZyZWUocHJpdi0+dHhfc2tidWZmKTsKKworCXJldHVybjsKK30KKworLyoqCisgKiBzdG1tYWNfZG1hX3N0YXJ0X3R4CisgKiBAaW9hZGRyOiBkZXZpY2UgSS9PIGFkZHJlc3MKKyAqIERlc2NyaXB0aW9uOiAgdGhpcyBmdW5jdGlvbiBzdGFydHMgdGhlIERNQSB0eCBwcm9jZXNzLgorICovCitzdGF0aWMgdm9pZCBzdG1tYWNfZG1hX3N0YXJ0X3R4KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIERNQV9DT05UUk9MKTsKKwl2YWx1ZSB8PSBETUFfQ09OVFJPTF9TVDsKKwl3cml0ZWwodmFsdWUsIGlvYWRkciArIERNQV9DT05UUk9MKTsKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkIHN0bW1hY19kbWFfc3RvcF90eCh1bnNpZ25lZCBsb25nIGlvYWRkcikKK3sKKwl1MzIgdmFsdWUgPSByZWFkbChpb2FkZHIgKyBETUFfQ09OVFJPTCk7CisJdmFsdWUgJj0gfkRNQV9DT05UUk9MX1NUOworCXdyaXRlbCh2YWx1ZSwgaW9hZGRyICsgRE1BX0NPTlRST0wpOworCXJldHVybjsKK30KKworLyoqCisgKiBzdG1tYWNfZG1hX3N0YXJ0X3J4CisgKiBAaW9hZGRyOiBkZXZpY2UgSS9PIGFkZHJlc3MKKyAqIERlc2NyaXB0aW9uOiAgdGhpcyBmdW5jdGlvbiBzdGFydHMgdGhlIERNQSByeCBwcm9jZXNzLgorICovCitzdGF0aWMgdm9pZCBzdG1tYWNfZG1hX3N0YXJ0X3J4KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIERNQV9DT05UUk9MKTsKKwl2YWx1ZSB8PSBETUFfQ09OVFJPTF9TUjsKKwl3cml0ZWwodmFsdWUsIGlvYWRkciArIERNQV9DT05UUk9MKTsKKworCXJldHVybjsKK30KKworc3RhdGljIHZvaWQgc3RtbWFjX2RtYV9zdG9wX3J4KHVuc2lnbmVkIGxvbmcgaW9hZGRyKQoreworCXUzMiB2YWx1ZSA9IHJlYWRsKGlvYWRkciArIERNQV9DT05UUk9MKTsKKwl2YWx1ZSAmPSB+RE1BX0NPTlRST0xfU1I7CisJd3JpdGVsKHZhbHVlLCBpb2FkZHIgKyBETUFfQ09OVFJPTCk7CisKKwlyZXR1cm47Cit9CisKKy8qKgorICogIHN0bW1hY19kbWFfb3BlcmF0aW9uX21vZGUgLSBIVyBETUEgb3BlcmF0aW9uIG1vZGUKKyAqICBAcHJpdiA6IHBvaW50ZXIgdG8gdGhlIHByaXZhdGUgZGV2aWNlIHN0cnVjdHVyZS4KKyAqICBEZXNjcmlwdGlvbjogaXQgc2V0cyB0aGUgRE1BIG9wZXJhdGlvbiBtb2RlOiB0eC9yeCBETUEgdGhyZXNob2xkcworICogIG9yIFN0b3JlLUFuZC1Gb3J3YXJkIGNhcGFiaWxpdHkuIEl0IGFsc28gdmVyaWZpZXMgdGhlIENPRSBmb3IgdGhlCisgKiAgdHJhbnNtaXNzaW9uIGluIGNhc2Ugb2YgR2lnYSBFVEguCisgKi8KK3N0YXRpYyB2b2lkIHN0bW1hY19kbWFfb3BlcmF0aW9uX21vZGUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQoreworCWlmICghcHJpdi0+aXNfZ21hYykgeworCQkvKiBNQUMgMTAvMTAwICovCisJCXByaXYtPm1hY190eXBlLT5vcHMtPmRtYV9tb2RlKHByaXYtPmRldi0+YmFzZV9hZGRyLCB0YywgMCk7CisJCXByaXYtPnR4X2NvZSA9IE5PX0hXX0NTVU07CisJfSBlbHNlIHsKKwkJaWYgKChwcml2LT5kZXYtPm10dSA8PSBFVEhfREFUQV9MRU4pICYmICh0eF9jb2UpKSB7CisJCQlwcml2LT5tYWNfdHlwZS0+b3BzLT5kbWFfbW9kZShwcml2LT5kZXYtPmJhc2VfYWRkciwKKwkJCQkJCSAgICAgIFNGX0RNQV9NT0RFLCBTRl9ETUFfTU9ERSk7CisJCQl0YyA9IFNGX0RNQV9NT0RFOworCQkJcHJpdi0+dHhfY29lID0gSFdfQ1NVTTsKKwkJfSBlbHNlIHsKKwkJCS8qIENoZWNrc3VtIGNvbXB1dGF0aW9uIGlzIHBlcmZvcm1lZCBpbiBzb2Z0d2FyZS4gKi8KKwkJCXByaXYtPm1hY190eXBlLT5vcHMtPmRtYV9tb2RlKHByaXYtPmRldi0+YmFzZV9hZGRyLCB0YywKKwkJCQkJCSAgICAgIFNGX0RNQV9NT0RFKTsKKwkJCXByaXYtPnR4X2NvZSA9IE5PX0hXX0NTVU07CisJCX0KKwl9CisJdHhfY29lID0gcHJpdi0+dHhfY29lOworCisJcmV0dXJuOworfQorCisjaWZkZWYgU1RNTUFDX0RFQlVHCisvKioKKyAqIHNob3dfdHhfcHJvY2Vzc19zdGF0ZQorICogQHN0YXR1czogdHggZGVzY3JpcHRvciBzdGF0dXMgZmllbGQKKyAqIERlc2NyaXB0aW9uOiBpdCBzaG93cyB0aGUgVHJhbnNtaXQgUHJvY2VzcyBTdGF0ZSBmb3IgQ1NSNVsyMjoyMF0KKyAqLworc3RhdGljIHZvaWQgc2hvd190eF9wcm9jZXNzX3N0YXRlKHVuc2lnbmVkIGludCBzdGF0dXMpCit7CisJdW5zaWduZWQgaW50IHN0YXRlOworCXN0YXRlID0gKHN0YXR1cyAmIERNQV9TVEFUVVNfVFNfTUFTSykgPj4gRE1BX1NUQVRVU19UU19TSElGVDsKKworCXN3aXRjaCAoc3RhdGUpIHsKKwljYXNlIDA6CisJCXByX2luZm8oIi0gVFggKFN0b3BwZWQpOiBSZXNldCBvciBTdG9wIGNvbW1hbmRcbiIpOworCQlicmVhazsKKwljYXNlIDE6CisJCXByX2luZm8oIi0gVFggKFJ1bm5pbmcpOkZldGNoaW5nIHRoZSBUeCBkZXNjXG4iKTsKKwkJYnJlYWs7CisJY2FzZSAyOgorCQlwcl9pbmZvKCItIFRYIChSdW5uaW5nKTogV2FpdGluZyBmb3IgZW5kIG9mIHR4XG4iKTsKKwkJYnJlYWs7CisJY2FzZSAzOgorCQlwcl9pbmZvKCItIFRYIChSdW5uaW5nKTogUmVhZGluZyB0aGUgZGF0YSAiCisJCSAgICAgICAiYW5kIHF1ZXVpbmcgdGhlIGRhdGEgaW50byB0aGUgVHggYnVmXG4iKTsKKwkJYnJlYWs7CisJY2FzZSA2OgorCQlwcl9pbmZvKCItIFRYIChTdXNwZW5kZWQpOiBUeCBCdWZmIFVuZGVyZmxvdyAiCisJCSAgICAgICAib3IgYW4gdW5hdmFpbGFibGUgVHJhbnNtaXQgZGVzY3JpcHRvclxuIik7CisJCWJyZWFrOworCWNhc2UgNzoKKwkJcHJfaW5mbygiLSBUWCAoUnVubmluZyk6IENsb3NpbmcgVHggZGVzY3JpcHRvclxuIik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKwlyZXR1cm47Cit9CisKKy8qKgorICogc2hvd19yeF9wcm9jZXNzX3N0YXRlCisgKiBAc3RhdHVzOiByeCBkZXNjcmlwdG9yIHN0YXR1cyBmaWVsZAorICogRGVzY3JpcHRpb246IGl0IHNob3dzIHRoZSAgUmVjZWl2ZSBQcm9jZXNzIFN0YXRlIGZvciBDU1I1WzE5OjE3XQorICovCitzdGF0aWMgdm9pZCBzaG93X3J4X3Byb2Nlc3Nfc3RhdGUodW5zaWduZWQgaW50IHN0YXR1cykKK3sKKwl1bnNpZ25lZCBpbnQgc3RhdGU7CisJc3RhdGUgPSAoc3RhdHVzICYgRE1BX1NUQVRVU19SU19NQVNLKSA+PiBETUFfU1RBVFVTX1JTX1NISUZUOworCisJc3dpdGNoIChzdGF0ZSkgeworCWNhc2UgMDoKKwkJcHJfaW5mbygiLSBSWCAoU3RvcHBlZCk6IFJlc2V0IG9yIFN0b3AgY29tbWFuZFxuIik7CisJCWJyZWFrOworCWNhc2UgMToKKwkJcHJfaW5mbygiLSBSWCAoUnVubmluZyk6IEZldGNoaW5nIHRoZSBSeCBkZXNjXG4iKTsKKwkJYnJlYWs7CisJY2FzZSAyOgorCQlwcl9pbmZvKCItIFJYIChSdW5uaW5nKTpDaGVja2luZyBmb3IgZW5kIG9mIHBrdFxuIik7CisJCWJyZWFrOworCWNhc2UgMzoKKwkJcHJfaW5mbygiLSBSWCAoUnVubmluZyk6IFdhaXRpbmcgZm9yIFJ4IHBrdFxuIik7CisJCWJyZWFrOworCWNhc2UgNDoKKwkJcHJfaW5mbygiLSBSWCAoU3VzcGVuZGVkKTogVW5hdmFpbGFibGUgUnggYnVmXG4iKTsKKwkJYnJlYWs7CisJY2FzZSA1OgorCQlwcl9pbmZvKCItIFJYIChSdW5uaW5nKTogQ2xvc2luZyBSeCBkZXNjcmlwdG9yXG4iKTsKKwkJYnJlYWs7CisJY2FzZSA2OgorCQlwcl9pbmZvKCItIFJYKFJ1bm5pbmcpOiBGbHVzaGluZyB0aGUgY3VycmVudCBmcmFtZSIKKwkJICAgICAgICIgZnJvbSB0aGUgUnggYnVmXG4iKTsKKwkJYnJlYWs7CisJY2FzZSA3OgorCQlwcl9pbmZvKCItIFJYIChSdW5uaW5nKTogUXVldWluZyB0aGUgUnggZnJhbWUiCisJCSAgICAgICAiIGZyb20gdGhlIFJ4IGJ1ZiBpbnRvIG1lbW9yeVxuIik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKwlyZXR1cm47Cit9CisjZW5kaWYKKworLyoqCisgKiBzdG1tYWNfdHg6CisgKiBAcHJpdjogcHJpdmF0ZSBkcml2ZXIgc3RydWN0dXJlCisgKiBEZXNjcmlwdGlvbjogaXQgcmVjbGFpbXMgcmVzb3VyY2VzIGFmdGVyIHRyYW5zbWlzc2lvbiBjb21wbGV0ZXMuCisgKi8KK3N0YXRpYyB2b2lkIHN0bW1hY190eChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJdW5zaWduZWQgaW50IHR4c2l6ZSA9IHByaXYtPmRtYV90eF9zaXplOworCXVuc2lnbmVkIGxvbmcgaW9hZGRyID0gcHJpdi0+ZGV2LT5iYXNlX2FkZHI7CisKKwl3aGlsZSAocHJpdi0+ZGlydHlfdHggIT0gcHJpdi0+Y3VyX3R4KSB7CisJCWludCBsYXN0OworCQl1bnNpZ25lZCBpbnQgZW50cnkgPSBwcml2LT5kaXJ0eV90eCAlIHR4c2l6ZTsKKwkJc3RydWN0IHNrX2J1ZmYgKnNrYiA9IHByaXYtPnR4X3NrYnVmZltlbnRyeV07CisJCXN0cnVjdCBkbWFfZGVzYyAqcCA9IHByaXYtPmRtYV90eCArIGVudHJ5OworCisJCS8qIENoZWNrIGlmIHRoZSBkZXNjcmlwdG9yIGlzIG93bmVkIGJ5IHRoZSBETUEuICovCisJCWlmIChwcml2LT5tYWNfdHlwZS0+b3BzLT5nZXRfdHhfb3duZXIocCkpCisJCQlicmVhazsKKworCQkvKiBWZXJpZnkgdHggZXJyb3IgYnkgbG9va2luZyBhdCB0aGUgbGFzdCBzZWdtZW50ICovCisJCWxhc3QgPSBwcml2LT5tYWNfdHlwZS0+b3BzLT5nZXRfdHhfbHMocCk7CisJCWlmIChsaWtlbHkobGFzdCkpIHsKKwkJCWludCB0eF9lcnJvciA9CisJCQkgICAgcHJpdi0+bWFjX3R5cGUtPm9wcy0+dHhfc3RhdHVzKCZwcml2LT5kZXYtPnN0YXRzLAorCQkJCQkJCSAgICZwcml2LT54c3RhdHMsCisJCQkJCQkJICAgcCwgaW9hZGRyKTsKKwkJCWlmIChsaWtlbHkodHhfZXJyb3IgPT0gMCkpIHsKKwkJCQlwcml2LT5kZXYtPnN0YXRzLnR4X3BhY2tldHMrKzsKKwkJCQlwcml2LT54c3RhdHMudHhfcGt0X24rKzsKKwkJCX0gZWxzZQorCQkJCXByaXYtPmRldi0+c3RhdHMudHhfZXJyb3JzKys7CisJCX0KKwkJVFhfREJHKCIlczogY3VyciAlZCwgZGlydHkgJWRcbiIsIF9fZnVuY19fLAorCQkJcHJpdi0+Y3VyX3R4LCBwcml2LT5kaXJ0eV90eCk7CisKKwkJaWYgKGxpa2VseShwLT5kZXMyKSkKKwkJCWRtYV91bm1hcF9zaW5nbGUocHJpdi0+ZGV2aWNlLCBwLT5kZXMyLAorCQkJCQkgcHJpdi0+bWFjX3R5cGUtPm9wcy0+Z2V0X3R4X2xlbihwKSwKKwkJCQkJIERNQV9UT19ERVZJQ0UpOworCQlpZiAodW5saWtlbHkocC0+ZGVzMykpCisJCQlwLT5kZXMzID0gMDsKKworCQlpZiAobGlrZWx5KHNrYiAhPSBOVUxMKSkgeworCQkJLyoKKwkJCSAqIElmIHRoZXJlJ3Mgcm9vbSBpbiB0aGUgcXVldWUgKGxpbWl0IGl0IHRvIHNpemUpCisJCQkgKiB3ZSBhZGQgdGhpcyBza2IgYmFjayBpbnRvIHRoZSBwb29sLAorCQkJICogaWYgaXQncyB0aGUgcmlnaHQgc2l6ZS4KKwkJCSAqLworCQkJaWYgKChza2JfcXVldWVfbGVuKCZwcml2LT5yeF9yZWN5Y2xlKSA8CisJCQkJcHJpdi0+ZG1hX3J4X3NpemUpICYmCisJCQkJc2tiX3JlY3ljbGVfY2hlY2soc2tiLCBwcml2LT5kbWFfYnVmX3N6KSkKKwkJCQlfX3NrYl9xdWV1ZV9oZWFkKCZwcml2LT5yeF9yZWN5Y2xlLCBza2IpOworCQkJZWxzZQorCQkJCWRldl9rZnJlZV9za2Ioc2tiKTsKKworCQkJcHJpdi0+dHhfc2tidWZmW2VudHJ5XSA9IE5VTEw7CisJCX0KKworCQlwcml2LT5tYWNfdHlwZS0+b3BzLT5yZWxlYXNlX3R4X2Rlc2MocCk7CisKKwkJZW50cnkgPSAoKytwcml2LT5kaXJ0eV90eCkgJSB0eHNpemU7CisJfQorCWlmICh1bmxpa2VseShuZXRpZl9xdWV1ZV9zdG9wcGVkKHByaXYtPmRldikgJiYKKwkJICAgICBzdG1tYWNfdHhfYXZhaWwocHJpdikgPiBTVE1NQUNfVFhfVEhSRVNIKHByaXYpKSkgeworCQluZXRpZl90eF9sb2NrKHByaXYtPmRldik7CisJCWlmIChuZXRpZl9xdWV1ZV9zdG9wcGVkKHByaXYtPmRldikgJiYKKwkJICAgICBzdG1tYWNfdHhfYXZhaWwocHJpdikgPiBTVE1NQUNfVFhfVEhSRVNIKHByaXYpKSB7CisJCQlUWF9EQkcoIiVzOiByZXN0YXJ0IHRyYW5zbWl0XG4iLCBfX2Z1bmNfXyk7CisJCQluZXRpZl93YWtlX3F1ZXVlKHByaXYtPmRldik7CisJCX0KKwkJbmV0aWZfdHhfdW5sb2NrKHByaXYtPmRldik7CisJfQorCXJldHVybjsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHN0bW1hY19lbmFibGVfaXJxKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKyNpZm5kZWYgQ09ORklHX1NUTU1BQ19USU1FUgorCXdyaXRlbChETUFfSU5UUl9ERUZBVUxUX01BU0ssIHByaXYtPmRldi0+YmFzZV9hZGRyICsgRE1BX0lOVFJfRU5BKTsKKyNlbHNlCisJcHJpdi0+dG0tPnRpbWVyX3N0YXJ0KHRtcmF0ZSk7CisjZW5kaWYKK30KKworc3RhdGljIGlubGluZSB2b2lkIHN0bW1hY19kaXNhYmxlX2lycShzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisjaWZuZGVmIENPTkZJR19TVE1NQUNfVElNRVIKKwl3cml0ZWwoMCwgcHJpdi0+ZGV2LT5iYXNlX2FkZHIgKyBETUFfSU5UUl9FTkEpOworI2Vsc2UKKwlwcml2LT50bS0+dGltZXJfc3RvcCgpOworI2VuZGlmCit9CisKK3N0YXRpYyBpbnQgc3RtbWFjX2hhc193b3JrKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKwl1bnNpZ25lZCBpbnQgaGFzX3dvcmsgPSAwOworCWludCByeHJldCwgdHhfd29yayA9IDA7CisKKwlyeHJldCA9IHByaXYtPm1hY190eXBlLT5vcHMtPmdldF9yeF9vd25lcihwcml2LT5kbWFfcnggKworCQkocHJpdi0+Y3VyX3J4ICUgcHJpdi0+ZG1hX3J4X3NpemUpKTsKKworCWlmIChwcml2LT5kaXJ0eV90eCAhPSBwcml2LT5jdXJfdHgpCisJCXR4X3dvcmsgPSAxOworCisJaWYgKGxpa2VseSghcnhyZXQgfHwgdHhfd29yaykpCisJCWhhc193b3JrID0gMTsKKworCXJldHVybiBoYXNfd29yazsKK30KKworc3RhdGljIGlubGluZSB2b2lkIF9zdG1tYWNfc2NoZWR1bGUoc3RydWN0IHN0bW1hY19wcml2ICpwcml2KQoreworCWlmIChsaWtlbHkoc3RtbWFjX2hhc193b3JrKHByaXYpKSkgeworCQlzdG1tYWNfZGlzYWJsZV9pcnEocHJpdik7CisJCW5hcGlfc2NoZWR1bGUoJnByaXYtPm5hcGkpOworCX0KK30KKworI2lmZGVmIENPTkZJR19TVE1NQUNfVElNRVIKK3ZvaWQgc3RtbWFjX3NjaGVkdWxlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKworCXByaXYtPnhzdGF0cy5zY2hlZF90aW1lcl9uKys7CisKKwlfc3RtbWFjX3NjaGVkdWxlKHByaXYpOworCisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZCBzdG1tYWNfbm9fdGltZXJfc3RhcnRlZCh1bnNpZ25lZCBpbnQgeCkKK3s7Cit9OworCitzdGF0aWMgdm9pZCBzdG1tYWNfbm9fdGltZXJfc3RvcHBlZCh2b2lkKQorezsKK307CisjZW5kaWYKKworLyoqCisgKiBzdG1tYWNfdHhfZXJyOgorICogQHByaXY6IHBvaW50ZXIgdG8gdGhlIHByaXZhdGUgZGV2aWNlIHN0cnVjdHVyZQorICogRGVzY3JpcHRpb246IGl0IGNsZWFucyB0aGUgZGVzY3JpcHRvcnMgYW5kIHJlc3RhcnRzIHRoZSB0cmFuc21pc3Npb24KKyAqIGluIGNhc2Ugb2YgZXJyb3JzLgorICovCitzdGF0aWMgdm9pZCBzdG1tYWNfdHhfZXJyKHN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdikKK3sKKwluZXRpZl9zdG9wX3F1ZXVlKHByaXYtPmRldik7CisKKwlzdG1tYWNfZG1hX3N0b3BfdHgocHJpdi0+ZGV2LT5iYXNlX2FkZHIpOworCWRtYV9mcmVlX3R4X3NrYnVmcyhwcml2KTsKKwlwcml2LT5tYWNfdHlwZS0+b3BzLT5pbml0X3R4X2Rlc2MocHJpdi0+ZG1hX3R4LCBwcml2LT5kbWFfdHhfc2l6ZSk7CisJcHJpdi0+ZGlydHlfdHggPSAwOworCXByaXYtPmN1cl90eCA9IDA7CisJc3RtbWFjX2RtYV9zdGFydF90eChwcml2LT5kZXYtPmJhc2VfYWRkcik7CisKKwlwcml2LT5kZXYtPnN0YXRzLnR4X2Vycm9ycysrOworCW5ldGlmX3dha2VfcXVldWUocHJpdi0+ZGV2KTsKKworCXJldHVybjsKK30KKworLyoqCisgKiBzdG1tYWNfZG1hX2ludGVycnVwdCAtIEludGVycnVwdCBoYW5kbGVyIGZvciB0aGUgZHJpdmVyCisgKiBAZGV2OiBuZXQgZGV2aWNlIHN0cnVjdHVyZQorICogRGVzY3JpcHRpb246IEludGVycnVwdCBoYW5kbGVyIGZvciB0aGUgZHJpdmVyIChETUEpLgorICovCitzdGF0aWMgdm9pZCBzdG1tYWNfZG1hX2ludGVycnVwdChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCXVuc2lnbmVkIGxvbmcgaW9hZGRyID0gZGV2LT5iYXNlX2FkZHI7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwkvKiByZWFkIHRoZSBzdGF0dXMgcmVnaXN0ZXIgKENTUjUpICovCisJdTMyIGludHJfc3RhdHVzID0gcmVhZGwoaW9hZGRyICsgRE1BX1NUQVRVUyk7CisKKwlEQkcoaW50ciwgSU5GTywgIiVzOiBbQ1NSNTogMHglMDh4XVxuIiwgX19mdW5jX18sIGludHJfc3RhdHVzKTsKKworI2lmZGVmIFNUTU1BQ19ERUJVRworCS8qIEl0IGRpc3BsYXlzIHRoZSBETUEgdHJhbnNtaXQgcHJvY2VzcyBzdGF0ZSAoQ1NSNSByZWdpc3RlcikgKi8KKwlpZiAobmV0aWZfbXNnX3R4X2RvbmUocHJpdikpCisJCXNob3dfdHhfcHJvY2Vzc19zdGF0ZShpbnRyX3N0YXR1cyk7CisJaWYgKG5ldGlmX21zZ19yeF9zdGF0dXMocHJpdikpCisJCXNob3dfcnhfcHJvY2Vzc19zdGF0ZShpbnRyX3N0YXR1cyk7CisjZW5kaWYKKwkvKiBBQk5PUk1BTCBpbnRlcnJ1cHRzICovCisJaWYgKHVubGlrZWx5KGludHJfc3RhdHVzICYgRE1BX1NUQVRVU19BSVMpKSB7CisJCURCRyhpbnRyLCBJTkZPLCAiQ1NSNVsxNV0gRE1BIEFCTk9STUFMIElSUTogIik7CisJCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfVU5GKSkgeworCQkJREJHKGludHIsIElORk8sICJ0cmFuc21pdCB1bmRlcmZsb3dcbiIpOworCQkJaWYgKHVubGlrZWx5KHRjICE9IFNGX0RNQV9NT0RFKQorCQkJICAgICYmICh0YyA8PSAyNTYpKSB7CisJCQkJLyogVHJ5IHRvIGJ1bXAgdXAgdGhlIHRocmVzaG9sZCAqLworCQkJCXRjICs9IDY0OworCQkJCXByaXYtPm1hY190eXBlLT5vcHMtPmRtYV9tb2RlKGlvYWRkciwgdGMsCisJCQkJCSAgICAgIFNGX0RNQV9NT0RFKTsKKwkJCQlwcml2LT54c3RhdHMudGhyZXNob2xkID0gdGM7CisJCQl9CisJCQlzdG1tYWNfdHhfZXJyKHByaXYpOworCQkJcHJpdi0+eHN0YXRzLnR4X3VuZGVmbG93X2lycSsrOworCQl9CisJCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfVEpUKSkgeworCQkJREJHKGludHIsIElORk8sICJ0cmFuc21pdCBqYWJiZXJcbiIpOworCQkJcHJpdi0+eHN0YXRzLnR4X2phYmJlcl9pcnErKzsKKwkJfQorCQlpZiAodW5saWtlbHkoaW50cl9zdGF0dXMgJiBETUFfU1RBVFVTX09WRikpIHsKKwkJCURCRyhpbnRyLCBJTkZPLCAicmVjdiBvdmVyZmxvd1xuIik7CisJCQlwcml2LT54c3RhdHMucnhfb3ZlcmZsb3dfaXJxKys7CisJCX0KKwkJaWYgKHVubGlrZWx5KGludHJfc3RhdHVzICYgRE1BX1NUQVRVU19SVSkpIHsKKwkJCURCRyhpbnRyLCBJTkZPLCAicmVjZWl2ZSBidWZmZXIgdW5hdmFpbGFibGVcbiIpOworCQkJcHJpdi0+eHN0YXRzLnJ4X2J1Zl91bmF2X2lycSsrOworCQl9CisJCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfUlBTKSkgeworCQkJREJHKGludHIsIElORk8sICJyZWNlaXZlIHByb2Nlc3Mgc3RvcHBlZFxuIik7CisJCQlwcml2LT54c3RhdHMucnhfcHJvY2Vzc19zdG9wcGVkX2lycSsrOworCQl9CisJCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfUldUKSkgeworCQkJREJHKGludHIsIElORk8sICJyZWNlaXZlIHdhdGNoZG9nXG4iKTsKKwkJCXByaXYtPnhzdGF0cy5yeF93YXRjaGRvZ19pcnErKzsKKwkJfQorCQlpZiAodW5saWtlbHkoaW50cl9zdGF0dXMgJiBETUFfU1RBVFVTX0VUSSkpIHsKKwkJCURCRyhpbnRyLCBJTkZPLCAidHJhbnNtaXQgZWFybHkgaW50ZXJydXB0XG4iKTsKKwkJCXByaXYtPnhzdGF0cy50eF9lYXJseV9pcnErKzsKKwkJfQorCQlpZiAodW5saWtlbHkoaW50cl9zdGF0dXMgJiBETUFfU1RBVFVTX1RQUykpIHsKKwkJCURCRyhpbnRyLCBJTkZPLCAidHJhbnNtaXQgcHJvY2VzcyBzdG9wcGVkXG4iKTsKKwkJCXByaXYtPnhzdGF0cy50eF9wcm9jZXNzX3N0b3BwZWRfaXJxKys7CisJCQlzdG1tYWNfdHhfZXJyKHByaXYpOworCQl9CisJCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfRkJJKSkgeworCQkJREJHKGludHIsIElORk8sICJmYXRhbCBidXMgZXJyb3JcbiIpOworCQkJcHJpdi0+eHN0YXRzLmZhdGFsX2J1c19lcnJvcl9pcnErKzsKKwkJCXN0bW1hY190eF9lcnIocHJpdik7CisJCX0KKwl9CisKKwkvKiBUWC9SWCBOT1JNQUwgaW50ZXJydXB0cyAqLworCWlmIChpbnRyX3N0YXR1cyAmIERNQV9TVEFUVVNfTklTKSB7CisJCXByaXYtPnhzdGF0cy5ub3JtYWxfaXJxX24rKzsKKwkJaWYgKGxpa2VseSgoaW50cl9zdGF0dXMgJiBETUFfU1RBVFVTX1JJKSB8fAorCQkJIChpbnRyX3N0YXR1cyAmIChETUFfU1RBVFVTX1RJKSkpKQorCQkJCV9zdG1tYWNfc2NoZWR1bGUocHJpdik7CisJfQorCisJLyogT3B0aW9uYWwgaGFyZHdhcmUgYmxvY2tzLCBpbnRlcnJ1cHRzIHNob3VsZCBiZSBkaXNhYmxlZCAqLworCWlmICh1bmxpa2VseShpbnRyX3N0YXR1cyAmCisJCSAgICAgKERNQV9TVEFUVVNfR1BJIHwgRE1BX1NUQVRVU19HTUkgfCBETUFfU1RBVFVTX0dMSSkpKQorCQlwcl9pbmZvKCIlczogdW5leHBlY3RlZCBzdGF0dXMgJTA4eFxuIiwgX19mdW5jX18sIGludHJfc3RhdHVzKTsKKworCS8qIENsZWFyIHRoZSBpbnRlcnJ1cHQgYnkgd3JpdGluZyBhIGxvZ2ljIDEgdG8gdGhlIENTUjVbMTUtMF0gKi8KKwl3cml0ZWwoKGludHJfc3RhdHVzICYgMHgxZmZmZiksIGlvYWRkciArIERNQV9TVEFUVVMpOworCisJREJHKGludHIsIElORk8sICJcblxuIik7CisKKwlyZXR1cm47Cit9CisKKy8qKgorICogIHN0bW1hY19vcGVuIC0gb3BlbiBlbnRyeSBwb2ludCBvZiB0aGUgZHJpdmVyCisgKiAgQGRldiA6IHBvaW50ZXIgdG8gdGhlIGRldmljZSBzdHJ1Y3R1cmUuCisgKiAgRGVzY3JpcHRpb246CisgKiAgVGhpcyBmdW5jdGlvbiBpcyB0aGUgb3BlbiBlbnRyeSBwb2ludCBvZiB0aGUgZHJpdmVyLgorICogIFJldHVybiB2YWx1ZToKKyAqICAwIG9uIHN1Y2Nlc3MgYW5kIGFuIGFwcHJvcHJpYXRlICgtKXZlIGludGVnZXIgYXMgZGVmaW5lZCBpbiBlcnJuby5oCisgKiAgZmlsZSBvbiBmYWlsdXJlLgorICovCitzdGF0aWMgaW50IHN0bW1hY19vcGVuKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwl1bnNpZ25lZCBsb25nIGlvYWRkciA9IGRldi0+YmFzZV9hZGRyOworCWludCByZXQ7CisKKwkvKiBDaGVjayB0aGF0IHRoZSBNQUMgYWRkcmVzcyBpcyB2YWxpZC4gIElmIGl0cyBub3QsIHJlZnVzZQorCSAqIHRvIGJyaW5nIHRoZSBkZXZpY2UgdXAuIFRoZSB1c2VyIG11c3Qgc3BlY2lmeSBhbgorCSAqIGFkZHJlc3MgdXNpbmcgdGhlIGZvbGxvd2luZyBsaW51eCBjb21tYW5kOgorCSAqICAgICAgaWZjb25maWcgZXRoMCBodyBldGhlciB4eDp4eDp4eDp4eDp4eDp4eCAgKi8KKwlpZiAoIWlzX3ZhbGlkX2V0aGVyX2FkZHIoZGV2LT5kZXZfYWRkcikpIHsKKwkJcmFuZG9tX2V0aGVyX2FkZHIoZGV2LT5kZXZfYWRkcik7CisJCXByX3dhcm5pbmcoIiVzOiBnZW5lcmF0ZWQgcmFuZG9tIE1BQyBhZGRyZXNzICVwTVxuIiwgZGV2LT5uYW1lLAorCQkJZGV2LT5kZXZfYWRkcik7CisJfQorCisJc3RtbWFjX3ZlcmlmeV9hcmdzKCk7CisKKwlyZXQgPSBzdG1tYWNfaW5pdF9waHkoZGV2KTsKKwlpZiAodW5saWtlbHkocmV0KSkgeworCQlwcl9lcnIoIiVzOiBDYW5ub3QgYXR0YWNoIHRvIFBIWSAoZXJyb3I6ICVkKVxuIiwgX19mdW5jX18sIHJldCk7CisJCXJldHVybiByZXQ7CisJfQorCisJLyogUmVxdWVzdCB0aGUgSVJRIGxpbmVzICovCisJcmV0ID0gcmVxdWVzdF9pcnEoZGV2LT5pcnEsICZzdG1tYWNfaW50ZXJydXB0LAorCQkJICBJUlFGX1NIQVJFRCwgZGV2LT5uYW1lLCBkZXYpOworCWlmICh1bmxpa2VseShyZXQgPCAwKSkgeworCQlwcl9lcnIoIiVzOiBFUlJPUjogYWxsb2NhdGluZyB0aGUgSVJRICVkIChlcnJvcjogJWQpXG4iLAorCQkgICAgICAgX19mdW5jX18sIGRldi0+aXJxLCByZXQpOworCQlyZXR1cm4gcmV0OworCX0KKworI2lmZGVmIENPTkZJR19TVE1NQUNfVElNRVIKKwlwcml2LT50bSA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBzdG1tYWNfdGltZXIgKiksIEdGUF9LRVJORUwpOworCWlmICh1bmxpa2VseShwcml2LT50bSA9PSBOVUxMKSkgeworCQlwcl9lcnIoIiVzOiBFUlJPUjogdGltZXIgbWVtb3J5IGFsbG9jIGZhaWxlZCBcbiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCXByaXYtPnRtLT5mcmVxID0gdG1yYXRlOworCisJLyogVGVzdCBpZiB0aGUgSFcgdGltZXIgY2FuIGJlIGFjdHVhbGx5IHVzZWQuCisJICogSW4gY2FzZSBvZiBmYWlsdXJlIGNvbnRpbnVlIHdpdGggbm8gdGltZXIuICovCisJaWYgKHVubGlrZWx5KChzdG1tYWNfb3Blbl9leHRfdGltZXIoZGV2LCBwcml2LT50bSkpIDwgMCkpIHsKKwkJcHJfd2FybmluZygic3RtbWFjZXRoOiBjYW5ub3QgYXR0YWNoIHRoZSBIVyB0aW1lclxuIik7CisJCXRtcmF0ZSA9IDA7CisJCXByaXYtPnRtLT5mcmVxID0gMDsKKwkJcHJpdi0+dG0tPnRpbWVyX3N0YXJ0ID0gc3RtbWFjX25vX3RpbWVyX3N0YXJ0ZWQ7CisJCXByaXYtPnRtLT50aW1lcl9zdG9wID0gc3RtbWFjX25vX3RpbWVyX3N0b3BwZWQ7CisJfQorI2VuZGlmCisKKwkvKiBDcmVhdGUgYW5kIGluaXRpYWxpemUgdGhlIFRYL1JYIGRlc2NyaXB0b3JzIGNoYWlucy4gKi8KKwlwcml2LT5kbWFfdHhfc2l6ZSA9IFNUTU1BQ19BTElHTihkbWFfdHhzaXplKTsKKwlwcml2LT5kbWFfcnhfc2l6ZSA9IFNUTU1BQ19BTElHTihkbWFfcnhzaXplKTsKKwlwcml2LT5kbWFfYnVmX3N6ID0gU1RNTUFDX0FMSUdOKGJ1Zl9zeik7CisJaW5pdF9kbWFfZGVzY19yaW5ncyhkZXYpOworCisJLyogRE1BIGluaXRpYWxpemF0aW9uIGFuZCBTVyByZXNldCAqLworCWlmICh1bmxpa2VseShwcml2LT5tYWNfdHlwZS0+b3BzLT5kbWFfaW5pdChpb2FkZHIsCisJCXByaXYtPnBibCwgcHJpdi0+ZG1hX3R4X3BoeSwgcHJpdi0+ZG1hX3J4X3BoeSkgPCAwKSkgeworCisJCXByX2VycigiJXM6IERNQSBpbml0aWFsaXphdGlvbiBmYWlsZWRcbiIsIF9fZnVuY19fKTsKKwkJcmV0dXJuIC0xOworCX0KKworCS8qIENvcHkgdGhlIE1BQyBhZGRyIGludG8gdGhlIEhXICAqLworCXByaXYtPm1hY190eXBlLT5vcHMtPnNldF91bWFjX2FkZHIoaW9hZGRyLCBkZXYtPmRldl9hZGRyLCAwKTsKKwkvKiBJbml0aWFsaXplIHRoZSBNQUMgQ29yZSAqLworCXByaXYtPm1hY190eXBlLT5vcHMtPmNvcmVfaW5pdChpb2FkZHIpOworCisJcHJpdi0+c2h1dGRvd24gPSAwOworCisJLyogSW5pdGlhbGlzZSB0aGUgTU1DIChpZiBwcmVzZW50KSB0byBkaXNhYmxlIGFsbCBpbnRlcnJ1cHRzLiAqLworCXdyaXRlbCgweGZmZmZmZmZmLCBpb2FkZHIgKyBNTUNfSElHSF9JTlRSX01BU0spOworCXdyaXRlbCgweGZmZmZmZmZmLCBpb2FkZHIgKyBNTUNfTE9XX0lOVFJfTUFTSyk7CisKKwkvKiBFbmFibGUgdGhlIE1BQyBSeC9UeCAqLworCXN0bW1hY19tYWNfZW5hYmxlX3J4KGlvYWRkcik7CisJc3RtbWFjX21hY19lbmFibGVfdHgoaW9hZGRyKTsKKworCS8qIFNldCB0aGUgSFcgRE1BIG1vZGUgYW5kIHRoZSBDT0UgKi8KKwlzdG1tYWNfZG1hX29wZXJhdGlvbl9tb2RlKHByaXYpOworCisJLyogRXh0cmEgc3RhdGlzdGljcyAqLworCW1lbXNldCgmcHJpdi0+eHN0YXRzLCAwLCBzaXplb2Yoc3RydWN0IHN0bW1hY19leHRyYV9zdGF0cykpOworCXByaXYtPnhzdGF0cy50aHJlc2hvbGQgPSB0YzsKKworCS8qIFN0YXJ0IHRoZSBiYWxsIHJvbGxpbmcuLi4gKi8KKwlEQkcocHJvYmUsIERFQlVHLCAiJXM6IERNQSBSWC9UWCBwcm9jZXNzZXMgc3RhcnRlZC4uLlxuIiwgZGV2LT5uYW1lKTsKKwlzdG1tYWNfZG1hX3N0YXJ0X3R4KGlvYWRkcik7CisJc3RtbWFjX2RtYV9zdGFydF9yeChpb2FkZHIpOworCisjaWZkZWYgQ09ORklHX1NUTU1BQ19USU1FUgorCXByaXYtPnRtLT50aW1lcl9zdGFydCh0bXJhdGUpOworI2VuZGlmCisJLyogRHVtcCBETUEvTUFDIHJlZ2lzdGVycyAqLworCWlmIChuZXRpZl9tc2dfaHcocHJpdikpIHsKKwkJcHJpdi0+bWFjX3R5cGUtPm9wcy0+ZHVtcF9tYWNfcmVncyhpb2FkZHIpOworCQlwcml2LT5tYWNfdHlwZS0+b3BzLT5kdW1wX2RtYV9yZWdzKGlvYWRkcik7CisJfQorCisJaWYgKHByaXYtPnBoeWRldikKKwkJcGh5X3N0YXJ0KHByaXYtPnBoeWRldik7CisKKwluYXBpX2VuYWJsZSgmcHJpdi0+bmFwaSk7CisJc2tiX3F1ZXVlX2hlYWRfaW5pdCgmcHJpdi0+cnhfcmVjeWNsZSk7CisJbmV0aWZfc3RhcnRfcXVldWUoZGV2KTsKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiAgc3RtbWFjX3JlbGVhc2UgLSBjbG9zZSBlbnRyeSBwb2ludCBvZiB0aGUgZHJpdmVyCisgKiAgQGRldiA6IGRldmljZSBwb2ludGVyLgorICogIERlc2NyaXB0aW9uOgorICogIFRoaXMgaXMgdGhlIHN0b3AgZW50cnkgcG9pbnQgb2YgdGhlIGRyaXZlci4KKyAqLworc3RhdGljIGludCBzdG1tYWNfcmVsZWFzZShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisKKwkvKiBTdG9wIGFuZCBkaXNjb25uZWN0IHRoZSBQSFkgKi8KKwlpZiAocHJpdi0+cGh5ZGV2KSB7CisJCXBoeV9zdG9wKHByaXYtPnBoeWRldik7CisJCXBoeV9kaXNjb25uZWN0KHByaXYtPnBoeWRldik7CisJCXByaXYtPnBoeWRldiA9IE5VTEw7CisJfQorCisJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOworCisjaWZkZWYgQ09ORklHX1NUTU1BQ19USU1FUgorCS8qIFN0b3AgYW5kIHJlbGVhc2UgdGhlIHRpbWVyICovCisJc3RtbWFjX2Nsb3NlX2V4dF90aW1lcigpOworCWlmIChwcml2LT50bSAhPSBOVUxMKQorCQlrZnJlZShwcml2LT50bSk7CisjZW5kaWYKKwluYXBpX2Rpc2FibGUoJnByaXYtPm5hcGkpOworCXNrYl9xdWV1ZV9wdXJnZSgmcHJpdi0+cnhfcmVjeWNsZSk7CisKKwkvKiBGcmVlIHRoZSBJUlEgbGluZXMgKi8KKwlmcmVlX2lycShkZXYtPmlycSwgZGV2KTsKKworCS8qIFN0b3AgVFgvUlggRE1BIGFuZCBjbGVhciB0aGUgZGVzY3JpcHRvcnMgKi8KKwlzdG1tYWNfZG1hX3N0b3BfdHgoZGV2LT5iYXNlX2FkZHIpOworCXN0bW1hY19kbWFfc3RvcF9yeChkZXYtPmJhc2VfYWRkcik7CisKKwkvKiBSZWxlYXNlIGFuZCBmcmVlIHRoZSBSeC9UeCByZXNvdXJjZXMgKi8KKwlmcmVlX2RtYV9kZXNjX3Jlc291cmNlcyhwcml2KTsKKworCS8qIERpc2FibGUgdGhlIE1BQyBjb3JlICovCisJc3RtbWFjX21hY19kaXNhYmxlX3R4KGRldi0+YmFzZV9hZGRyKTsKKwlzdG1tYWNfbWFjX2Rpc2FibGVfcngoZGV2LT5iYXNlX2FkZHIpOworCisJbmV0aWZfY2Fycmllcl9vZmYoZGV2KTsKKworCXJldHVybiAwOworfQorCisvKgorICogVG8gcGVyZm9ybSBlbXVsYXRlZCBoYXJkd2FyZSBzZWdtZW50YXRpb24gb24gc2tiLgorICovCitzdGF0aWMgaW50IHN0bW1hY19zd190c28oc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQoreworCXN0cnVjdCBza19idWZmICpzZWdzLCAqY3Vycl9za2I7CisJaW50IGdzb19zZWdzID0gc2tiX3NoaW5mbyhza2IpLT5nc29fc2VnczsKKworCS8qIEVzdGltYXRlIHRoZSBudW1iZXIgb2YgZnJhZ21lbnRzIGluIHRoZSB3b3JzdCBjYXNlICovCisJaWYgKHVubGlrZWx5KHN0bW1hY190eF9hdmFpbChwcml2KSA8IGdzb19zZWdzKSkgeworCQluZXRpZl9zdG9wX3F1ZXVlKHByaXYtPmRldik7CisJCVRYX0RCRyhLRVJOX0VSUiAiJXM6IFRTTyBCVUchIFR4IFJpbmcgZnVsbCB3aGVuIHF1ZXVlIGF3YWtlXG4iLAorCQkgICAgICAgX19mdW5jX18pOworCQlpZiAoc3RtbWFjX3R4X2F2YWlsKHByaXYpIDwgZ3NvX3NlZ3MpCisJCQlyZXR1cm4gTkVUREVWX1RYX0JVU1k7CisKKwkJbmV0aWZfd2FrZV9xdWV1ZShwcml2LT5kZXYpOworCX0KKwlUWF9EQkcoIlx0c3RtbWFjX3N3X3Rzbzogc2VnbWVudGluZzogc2tiICVwIChsZW4gJWQpXG4iLAorCSAgICAgICBza2IsIHNrYi0+bGVuKTsKKworCXNlZ3MgPSBza2JfZ3NvX3NlZ21lbnQoc2tiLCBwcml2LT5kZXYtPmZlYXR1cmVzICYgfk5FVElGX0ZfVFNPKTsKKwlpZiAodW5saWtlbHkoSVNfRVJSKHNlZ3MpKSkKKwkJZ290byBzd190c29fZW5kOworCisJZG8geworCQljdXJyX3NrYiA9IHNlZ3M7CisJCXNlZ3MgPSBzZWdzLT5uZXh0OworCQlUWF9EQkcoIlx0XHRjdXJyZW50IHNrYi0+bGVuOiAlZCwgKmN1cnIgJXAsIgorCQkgICAgICAgIipuZXh0ICVwXG4iLCBjdXJyX3NrYi0+bGVuLCBjdXJyX3NrYiwgc2Vncyk7CisJCWN1cnJfc2tiLT5uZXh0ID0gTlVMTDsKKwkJc3RtbWFjX3htaXQoY3Vycl9za2IsIHByaXYtPmRldik7CisJfSB3aGlsZSAoc2Vncyk7CisKK3N3X3Rzb19lbmQ6CisJZGV2X2tmcmVlX3NrYihza2IpOworCisJcmV0dXJuIE5FVERFVl9UWF9PSzsKK30KKworc3RhdGljIHVuc2lnbmVkIGludCBzdG1tYWNfaGFuZGxlX2p1bWJvX2ZyYW1lcyhzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAorCQkJCQkgICAgICAgc3RydWN0IG5ldF9kZXZpY2UgKmRldiwKKwkJCQkJICAgICAgIGludCBjc3VtX2luc2VydGlvbikKK3sKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOworCXVuc2lnbmVkIGludCBub3BhZ2VkX2xlbiA9IHNrYl9oZWFkbGVuKHNrYik7CisJdW5zaWduZWQgaW50IHR4c2l6ZSA9IHByaXYtPmRtYV90eF9zaXplOworCXVuc2lnbmVkIGludCBlbnRyeSA9IHByaXYtPmN1cl90eCAlIHR4c2l6ZTsKKwlzdHJ1Y3QgZG1hX2Rlc2MgKmRlc2MgPSBwcml2LT5kbWFfdHggKyBlbnRyeTsKKworCWlmIChub3BhZ2VkX2xlbiA+IEJVRl9TSVpFXzhLaUIpIHsKKworCQlpbnQgYnVmMl9zaXplID0gbm9wYWdlZF9sZW4gLSBCVUZfU0laRV84S2lCOworCisJCWRlc2MtPmRlczIgPSBkbWFfbWFwX3NpbmdsZShwcml2LT5kZXZpY2UsIHNrYi0+ZGF0YSwKKwkJCQkJICAgIEJVRl9TSVpFXzhLaUIsIERNQV9UT19ERVZJQ0UpOworCQlkZXNjLT5kZXMzID0gZGVzYy0+ZGVzMiArIEJVRl9TSVpFXzRLaUI7CisJCXByaXYtPm1hY190eXBlLT5vcHMtPnByZXBhcmVfdHhfZGVzYyhkZXNjLCAxLCBCVUZfU0laRV84S2lCLAorCQkJCQkJICAgICBjc3VtX2luc2VydGlvbik7CisKKwkJZW50cnkgPSAoKytwcml2LT5jdXJfdHgpICUgdHhzaXplOworCQlkZXNjID0gcHJpdi0+ZG1hX3R4ICsgZW50cnk7CisKKwkJZGVzYy0+ZGVzMiA9IGRtYV9tYXBfc2luZ2xlKHByaXYtPmRldmljZSwKKwkJCQkJc2tiLT5kYXRhICsgQlVGX1NJWkVfOEtpQiwKKwkJCQkJYnVmMl9zaXplLCBETUFfVE9fREVWSUNFKTsKKwkJZGVzYy0+ZGVzMyA9IGRlc2MtPmRlczIgKyBCVUZfU0laRV80S2lCOworCQlwcml2LT5tYWNfdHlwZS0+b3BzLT5wcmVwYXJlX3R4X2Rlc2MoZGVzYywgMCwKKwkJCQkJCSAgICAgYnVmMl9zaXplLCBjc3VtX2luc2VydGlvbik7CisJCXByaXYtPm1hY190eXBlLT5vcHMtPnNldF90eF9vd25lcihkZXNjKTsKKwkJcHJpdi0+dHhfc2tidWZmW2VudHJ5XSA9IE5VTEw7CisJfSBlbHNlIHsKKwkJZGVzYy0+ZGVzMiA9IGRtYV9tYXBfc2luZ2xlKHByaXYtPmRldmljZSwgc2tiLT5kYXRhLAorCQkJCQlub3BhZ2VkX2xlbiwgRE1BX1RPX0RFVklDRSk7CisJCWRlc2MtPmRlczMgPSBkZXNjLT5kZXMyICsgQlVGX1NJWkVfNEtpQjsKKwkJcHJpdi0+bWFjX3R5cGUtPm9wcy0+cHJlcGFyZV90eF9kZXNjKGRlc2MsIDEsIG5vcGFnZWRfbGVuLAorCQkJCQkJICAgICBjc3VtX2luc2VydGlvbik7CisJfQorCXJldHVybiBlbnRyeTsKK30KKworLyoqCisgKiAgc3RtbWFjX3htaXQ6CisgKiAgQHNrYiA6IHRoZSBzb2NrZXQgYnVmZmVyCisgKiAgQGRldiA6IGRldmljZSBwb2ludGVyCisgKiAgRGVzY3JpcHRpb24gOiBUeCBlbnRyeSBwb2ludCBvZiB0aGUgZHJpdmVyLgorICovCitzdGF0aWMgbmV0ZGV2X3R4X3Qgc3RtbWFjX3htaXQoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOworCXVuc2lnbmVkIGludCB0eHNpemUgPSBwcml2LT5kbWFfdHhfc2l6ZTsKKwl1bnNpZ25lZCBpbnQgZW50cnk7CisJaW50IGksIGNzdW1faW5zZXJ0aW9uID0gMDsKKwlpbnQgbmZyYWdzID0gc2tiX3NoaW5mbyhza2IpLT5ucl9mcmFnczsKKwlzdHJ1Y3QgZG1hX2Rlc2MgKmRlc2MsICpmaXJzdDsKKworCWlmICh1bmxpa2VseShzdG1tYWNfdHhfYXZhaWwocHJpdikgPCBuZnJhZ3MgKyAxKSkgeworCQlpZiAoIW5ldGlmX3F1ZXVlX3N0b3BwZWQoZGV2KSkgeworCQkJbmV0aWZfc3RvcF9xdWV1ZShkZXYpOworCQkJLyogVGhpcyBpcyBhIGhhcmQgZXJyb3IsIGxvZyBpdC4gKi8KKwkJCXByX2VycigiJXM6IEJVRyEgVHggUmluZyBmdWxsIHdoZW4gcXVldWUgYXdha2VcbiIsCisJCQkJX19mdW5jX18pOworCQl9CisJCXJldHVybiBORVRERVZfVFhfQlVTWTsKKwl9CisKKwllbnRyeSA9IHByaXYtPmN1cl90eCAlIHR4c2l6ZTsKKworI2lmZGVmIFNUTU1BQ19YTUlUX0RFQlVHCisJaWYgKChza2ItPmxlbiA+IEVUSF9GUkFNRV9MRU4pIHx8IG5mcmFncykKKwkJcHJfaW5mbygic3RtbWFjIHhtaXQ6XG4iCisJCSAgICAgICAiXHRza2IgYWRkciAlcCAtIGxlbjogJWQgLSBub3BhZ2VkX2xlbjogJWRcbiIKKwkJICAgICAgICJcdG5fZnJhZ3M6ICVkIC0gaXBfc3VtbWVkOiAlZCAtICVzIGdzb1xuIiwKKwkJICAgICAgIHNrYiwgc2tiLT5sZW4sIHNrYl9oZWFkbGVuKHNrYiksIG5mcmFncywgc2tiLT5pcF9zdW1tZWQsCisJCSAgICAgICAhc2tiX2lzX2dzbyhza2IpID8gImlzbid0IiA6ICJpcyIpOworI2VuZGlmCisKKwlpZiAodW5saWtlbHkoc2tiX2lzX2dzbyhza2IpKSkKKwkJcmV0dXJuIHN0bW1hY19zd190c28ocHJpdiwgc2tiKTsKKworCWlmIChsaWtlbHkoKHNrYi0+aXBfc3VtbWVkID09IENIRUNLU1VNX1BBUlRJQUwpKSkgeworCQlpZiAobGlrZWx5KHByaXYtPnR4X2NvZSA9PSBOT19IV19DU1VNKSkKKwkJCXNrYl9jaGVja3N1bV9oZWxwKHNrYik7CisJCWVsc2UKKwkJCWNzdW1faW5zZXJ0aW9uID0gMTsKKwl9CisKKwlkZXNjID0gcHJpdi0+ZG1hX3R4ICsgZW50cnk7CisJZmlyc3QgPSBkZXNjOworCisjaWZkZWYgU1RNTUFDX1hNSVRfREVCVUcKKwlpZiAoKG5mcmFncyA+IDApIHx8IChza2ItPmxlbiA+IEVUSF9GUkFNRV9MRU4pKQorCQlwcl9kZWJ1Zygic3RtbWFjIHhtaXQ6IHNrYiBsZW46ICVkLCBub3BhZ2VkX2xlbjogJWQsXG4iCisJCSAgICAgICAiXHRcdG5fZnJhZ3M6ICVkLCBpcF9zdW1tZWQ6ICVkXG4iLAorCQkgICAgICAgc2tiLT5sZW4sIHNrYl9oZWFkbGVuKHNrYiksIG5mcmFncywgc2tiLT5pcF9zdW1tZWQpOworI2VuZGlmCisJcHJpdi0+dHhfc2tidWZmW2VudHJ5XSA9IHNrYjsKKwlpZiAodW5saWtlbHkoc2tiLT5sZW4gPj0gQlVGX1NJWkVfNEtpQikpIHsKKwkJZW50cnkgPSBzdG1tYWNfaGFuZGxlX2p1bWJvX2ZyYW1lcyhza2IsIGRldiwgY3N1bV9pbnNlcnRpb24pOworCQlkZXNjID0gcHJpdi0+ZG1hX3R4ICsgZW50cnk7CisJfSBlbHNlIHsKKwkJdW5zaWduZWQgaW50IG5vcGFnZWRfbGVuID0gc2tiX2hlYWRsZW4oc2tiKTsKKwkJZGVzYy0+ZGVzMiA9IGRtYV9tYXBfc2luZ2xlKHByaXYtPmRldmljZSwgc2tiLT5kYXRhLAorCQkJCQlub3BhZ2VkX2xlbiwgRE1BX1RPX0RFVklDRSk7CisJCXByaXYtPm1hY190eXBlLT5vcHMtPnByZXBhcmVfdHhfZGVzYyhkZXNjLCAxLCBub3BhZ2VkX2xlbiwKKwkJCQkJCSAgICAgY3N1bV9pbnNlcnRpb24pOworCX0KKworCWZvciAoaSA9IDA7IGkgPCBuZnJhZ3M7IGkrKykgeworCQlza2JfZnJhZ190ICpmcmFnID0gJnNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaV07CisJCWludCBsZW4gPSBmcmFnLT5zaXplOworCisJCWVudHJ5ID0gKCsrcHJpdi0+Y3VyX3R4KSAlIHR4c2l6ZTsKKwkJZGVzYyA9IHByaXYtPmRtYV90eCArIGVudHJ5OworCisJCVRYX0RCRygiXHRbZW50cnkgJWRdIHNlZ21lbnQgbGVuOiAlZFxuIiwgZW50cnksIGxlbik7CisJCWRlc2MtPmRlczIgPSBkbWFfbWFwX3BhZ2UocHJpdi0+ZGV2aWNlLCBmcmFnLT5wYWdlLAorCQkJCQkgIGZyYWctPnBhZ2Vfb2Zmc2V0LAorCQkJCQkgIGxlbiwgRE1BX1RPX0RFVklDRSk7CisJCXByaXYtPnR4X3NrYnVmZltlbnRyeV0gPSBOVUxMOworCQlwcml2LT5tYWNfdHlwZS0+b3BzLT5wcmVwYXJlX3R4X2Rlc2MoZGVzYywgMCwgbGVuLAorCQkJCQkJICAgICBjc3VtX2luc2VydGlvbik7CisJCXByaXYtPm1hY190eXBlLT5vcHMtPnNldF90eF9vd25lcihkZXNjKTsKKwl9CisKKwkvKiBJbnRlcnJ1cHQgb24gY29tcGxldGl0aW9uIG9ubHkgZm9yIHRoZSBsYXRlc3Qgc2VnbWVudCAqLworCXByaXYtPm1hY190eXBlLT5vcHMtPmNsb3NlX3R4X2Rlc2MoZGVzYyk7CisjaWZkZWYgQ09ORklHX1NUTU1BQ19USU1FUgorCS8qIENsZWFuIElDIHdoaWxlIHVzaW5nIHRpbWVycyAqLworCXByaXYtPm1hY190eXBlLT5vcHMtPmNsZWFyX3R4X2ljKGRlc2MpOworI2VuZGlmCisJLyogVG8gYXZvaWQgcmFpc2UgY29uZGl0aW9uICovCisJcHJpdi0+bWFjX3R5cGUtPm9wcy0+c2V0X3R4X293bmVyKGZpcnN0KTsKKworCXByaXYtPmN1cl90eCsrOworCisjaWZkZWYgU1RNTUFDX1hNSVRfREVCVUcKKwlpZiAobmV0aWZfbXNnX3BrdGRhdGEocHJpdikpIHsKKwkJcHJfaW5mbygic3RtbWFjIHhtaXQ6IGN1cnJlbnQ9JWQsIGRpcnR5PSVkLCBlbnRyeT0lZCwgIgorCQkgICAgICAgImZpcnN0PSVwLCBuZnJhZ3M9JWRcbiIsCisJCSAgICAgICAocHJpdi0+Y3VyX3R4ICUgdHhzaXplKSwgKHByaXYtPmRpcnR5X3R4ICUgdHhzaXplKSwKKwkJICAgICAgIGVudHJ5LCBmaXJzdCwgbmZyYWdzKTsKKwkJZGlzcGxheV9yaW5nKHByaXYtPmRtYV90eCwgdHhzaXplKTsKKwkJcHJfaW5mbygiPj4+IGZyYW1lIHRvIGJlIHRyYW5zbWl0dGVkOiAiKTsKKwkJcHJpbnRfcGt0KHNrYi0+ZGF0YSwgc2tiLT5sZW4pOworCX0KKyNlbmRpZgorCWlmICh1bmxpa2VseShzdG1tYWNfdHhfYXZhaWwocHJpdikgPD0gKE1BWF9TS0JfRlJBR1MgKyAxKSkpIHsKKwkJVFhfREJHKCIlczogc3RvcCB0cmFuc21pdHRlZCBwYWNrZXRzXG4iLCBfX2Z1bmNfXyk7CisJCW5ldGlmX3N0b3BfcXVldWUoZGV2KTsKKwl9CisKKwlkZXYtPnN0YXRzLnR4X2J5dGVzICs9IHNrYi0+bGVuOworCisJLyogQ1NSMSBlbmFibGVzIHRoZSB0cmFuc21pdCBETUEgdG8gY2hlY2sgZm9yIG5ldyBkZXNjcmlwdG9yICovCisJd3JpdGVsKDEsIGRldi0+YmFzZV9hZGRyICsgRE1BX1hNVF9QT0xMX0RFTUFORCk7CisKKwlyZXR1cm4gTkVUREVWX1RYX09LOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgc3RtbWFjX3J4X3JlZmlsbChzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYpCit7CisJdW5zaWduZWQgaW50IHJ4c2l6ZSA9IHByaXYtPmRtYV9yeF9zaXplOworCWludCBiZnNpemUgPSBwcml2LT5kbWFfYnVmX3N6OworCXN0cnVjdCBkbWFfZGVzYyAqcCA9IHByaXYtPmRtYV9yeDsKKworCWZvciAoOyBwcml2LT5jdXJfcnggLSBwcml2LT5kaXJ0eV9yeCA+IDA7IHByaXYtPmRpcnR5X3J4KyspIHsKKwkJdW5zaWduZWQgaW50IGVudHJ5ID0gcHJpdi0+ZGlydHlfcnggJSByeHNpemU7CisJCWlmIChsaWtlbHkocHJpdi0+cnhfc2tidWZmW2VudHJ5XSA9PSBOVUxMKSkgeworCQkJc3RydWN0IHNrX2J1ZmYgKnNrYjsKKworCQkJc2tiID0gX19za2JfZGVxdWV1ZSgmcHJpdi0+cnhfcmVjeWNsZSk7CisJCQlpZiAoc2tiID09IE5VTEwpCisJCQkJc2tiID0gbmV0ZGV2X2FsbG9jX3NrYl9pcF9hbGlnbihwcml2LT5kZXYsCisJCQkJCQkJCWJmc2l6ZSk7CisKKwkJCWlmICh1bmxpa2VseShza2IgPT0gTlVMTCkpCisJCQkJYnJlYWs7CisKKwkJCXByaXYtPnJ4X3NrYnVmZltlbnRyeV0gPSBza2I7CisJCQlwcml2LT5yeF9za2J1ZmZfZG1hW2VudHJ5XSA9CisJCQkgICAgZG1hX21hcF9zaW5nbGUocHJpdi0+ZGV2aWNlLCBza2ItPmRhdGEsIGJmc2l6ZSwKKwkJCQkJICAgRE1BX0ZST01fREVWSUNFKTsKKworCQkJKHAgKyBlbnRyeSktPmRlczIgPSBwcml2LT5yeF9za2J1ZmZfZG1hW2VudHJ5XTsKKwkJCWlmICh1bmxpa2VseShwcml2LT5pc19nbWFjKSkgeworCQkJCWlmIChiZnNpemUgPj0gQlVGX1NJWkVfOEtpQikKKwkJCQkJKHAgKyBlbnRyeSktPmRlczMgPQorCQkJCQkgICAgKHAgKyBlbnRyeSktPmRlczIgKyBCVUZfU0laRV84S2lCOworCQkJfQorCQkJUlhfREJHKEtFUk5fSU5GTyAiXHRyZWZpbGwgZW50cnkgIyVkXG4iLCBlbnRyeSk7CisJCX0KKwkJcHJpdi0+bWFjX3R5cGUtPm9wcy0+c2V0X3J4X293bmVyKHAgKyBlbnRyeSk7CisJfQorCXJldHVybjsKK30KKworc3RhdGljIGludCBzdG1tYWNfcngoc3RydWN0IHN0bW1hY19wcml2ICpwcml2LCBpbnQgbGltaXQpCit7CisJdW5zaWduZWQgaW50IHJ4c2l6ZSA9IHByaXYtPmRtYV9yeF9zaXplOworCXVuc2lnbmVkIGludCBlbnRyeSA9IHByaXYtPmN1cl9yeCAlIHJ4c2l6ZTsKKwl1bnNpZ25lZCBpbnQgbmV4dF9lbnRyeTsKKwl1bnNpZ25lZCBpbnQgY291bnQgPSAwOworCXN0cnVjdCBkbWFfZGVzYyAqcCA9IHByaXYtPmRtYV9yeCArIGVudHJ5OworCXN0cnVjdCBkbWFfZGVzYyAqcF9uZXh0OworCisjaWZkZWYgU1RNTUFDX1JYX0RFQlVHCisJaWYgKG5ldGlmX21zZ19odyhwcml2KSkgeworCQlwcl9kZWJ1ZygiPj4+IHN0bW1hY19yeDogZGVzY3JpcHRvciByaW5nOlxuIik7CisJCWRpc3BsYXlfcmluZyhwcml2LT5kbWFfcngsIHJ4c2l6ZSk7CisJfQorI2VuZGlmCisJY291bnQgPSAwOworCXdoaWxlICghcHJpdi0+bWFjX3R5cGUtPm9wcy0+Z2V0X3J4X293bmVyKHApKSB7CisJCWludCBzdGF0dXM7CisKKwkJaWYgKGNvdW50ID49IGxpbWl0KQorCQkJYnJlYWs7CisKKwkJY291bnQrKzsKKworCQluZXh0X2VudHJ5ID0gKCsrcHJpdi0+Y3VyX3J4KSAlIHJ4c2l6ZTsKKwkJcF9uZXh0ID0gcHJpdi0+ZG1hX3J4ICsgbmV4dF9lbnRyeTsKKwkJcHJlZmV0Y2gocF9uZXh0KTsKKworCQkvKiByZWFkIHRoZSBzdGF0dXMgb2YgdGhlIGluY29taW5nIGZyYW1lICovCisJCXN0YXR1cyA9IChwcml2LT5tYWNfdHlwZS0+b3BzLT5yeF9zdGF0dXMoJnByaXYtPmRldi0+c3RhdHMsCisJCQkJCQkJICZwcml2LT54c3RhdHMsIHApKTsKKwkJaWYgKHVubGlrZWx5KHN0YXR1cyA9PSBkaXNjYXJkX2ZyYW1lKSkKKwkJCXByaXYtPmRldi0+c3RhdHMucnhfZXJyb3JzKys7CisJCWVsc2UgeworCQkJc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwkJCS8qIExlbmd0aCBzaG91bGQgb21pdCB0aGUgQ1JDICovCisJCQlpbnQgZnJhbWVfbGVuID0KKwkJCSAgICBwcml2LT5tYWNfdHlwZS0+b3BzLT5nZXRfcnhfZnJhbWVfbGVuKHApIC0gNDsKKworI2lmZGVmIFNUTU1BQ19SWF9ERUJVRworCQkJaWYgKGZyYW1lX2xlbiA+IEVUSF9GUkFNRV9MRU4pCisJCQkJcHJfZGVidWcoIlx0UlggZnJhbWUgc2l6ZSAlZCwgQ09FIHN0YXR1czogJWRcbiIsCisJCQkJCWZyYW1lX2xlbiwgc3RhdHVzKTsKKworCQkJaWYgKG5ldGlmX21zZ19odyhwcml2KSkKKwkJCQlwcl9kZWJ1ZygiXHRkZXNjOiAlcCBbZW50cnkgJWRdIGJ1ZmY9MHgleFxuIiwKKwkJCQkJcCwgZW50cnksIHAtPmRlczIpOworI2VuZGlmCisJCQlza2IgPSBwcml2LT5yeF9za2J1ZmZbZW50cnldOworCQkJaWYgKHVubGlrZWx5KCFza2IpKSB7CisJCQkJcHJfZXJyKCIlczogSW5jb25zaXN0ZW50IFJ4IGRlc2NyaXB0b3IgY2hhaW5cbiIsCisJCQkJCXByaXYtPmRldi0+bmFtZSk7CisJCQkJcHJpdi0+ZGV2LT5zdGF0cy5yeF9kcm9wcGVkKys7CisJCQkJYnJlYWs7CisJCQl9CisJCQlwcmVmZXRjaChza2ItPmRhdGEgLSBORVRfSVBfQUxJR04pOworCQkJcHJpdi0+cnhfc2tidWZmW2VudHJ5XSA9IE5VTEw7CisKKwkJCXNrYl9wdXQoc2tiLCBmcmFtZV9sZW4pOworCQkJZG1hX3VubWFwX3NpbmdsZShwcml2LT5kZXZpY2UsCisJCQkJCSBwcml2LT5yeF9za2J1ZmZfZG1hW2VudHJ5XSwKKwkJCQkJIHByaXYtPmRtYV9idWZfc3osIERNQV9GUk9NX0RFVklDRSk7CisjaWZkZWYgU1RNTUFDX1JYX0RFQlVHCisJCQlpZiAobmV0aWZfbXNnX3BrdGRhdGEocHJpdikpIHsKKwkJCQlwcl9pbmZvKCIgZnJhbWUgcmVjZWl2ZWQgKCVkYnl0ZXMpIiwgZnJhbWVfbGVuKTsKKwkJCQlwcmludF9wa3Qoc2tiLT5kYXRhLCBmcmFtZV9sZW4pOworCQkJfQorI2VuZGlmCisJCQlza2ItPnByb3RvY29sID0gZXRoX3R5cGVfdHJhbnMoc2tiLCBwcml2LT5kZXYpOworCisJCQlpZiAodW5saWtlbHkoc3RhdHVzID09IGNzdW1fbm9uZSkpIHsKKwkJCQkvKiBhbHdheXMgZm9yIHRoZSBvbGQgbWFjIDEwLzEwMCAqLworCQkJCXNrYi0+aXBfc3VtbWVkID0gQ0hFQ0tTVU1fTk9ORTsKKwkJCQluZXRpZl9yZWNlaXZlX3NrYihza2IpOworCQkJfSBlbHNlIHsKKwkJCQlza2ItPmlwX3N1bW1lZCA9IENIRUNLU1VNX1VOTkVDRVNTQVJZOworCQkJCW5hcGlfZ3JvX3JlY2VpdmUoJnByaXYtPm5hcGksIHNrYik7CisJCQl9CisKKwkJCXByaXYtPmRldi0+c3RhdHMucnhfcGFja2V0cysrOworCQkJcHJpdi0+ZGV2LT5zdGF0cy5yeF9ieXRlcyArPSBmcmFtZV9sZW47CisJCQlwcml2LT5kZXYtPmxhc3RfcnggPSBqaWZmaWVzOworCQl9CisJCWVudHJ5ID0gbmV4dF9lbnRyeTsKKwkJcCA9IHBfbmV4dDsJLyogdXNlIHByZWZldGNoZWQgdmFsdWVzICovCisJfQorCisJc3RtbWFjX3J4X3JlZmlsbChwcml2KTsKKworCXByaXYtPnhzdGF0cy5yeF9wa3RfbiArPSBjb3VudDsKKworCXJldHVybiBjb3VudDsKK30KKworLyoqCisgKiAgc3RtbWFjX3BvbGwgLSBzdG1tYWMgcG9sbCBtZXRob2QgKE5BUEkpCisgKiAgQG5hcGkgOiBwb2ludGVyIHRvIHRoZSBuYXBpIHN0cnVjdHVyZS4KKyAqICBAYnVkZ2V0IDogbWF4aW11bSBudW1iZXIgb2YgcGFja2V0cyB0aGF0IHRoZSBjdXJyZW50IENQVSBjYW4gcmVjZWl2ZSBmcm9tCisgKgkgICAgICBhbGwgaW50ZXJmYWNlcy4KKyAqICBEZXNjcmlwdGlvbiA6CisgKiAgIFRoaXMgZnVuY3Rpb24gaW1wbGVtZW50cyB0aGUgdGhlIHJlY2VwdGlvbiBwcm9jZXNzLgorICogICBBbHNvIGl0IHJ1bnMgdGhlIFRYIGNvbXBsZXRpb24gdGhyZWFkCisgKi8KK3N0YXRpYyBpbnQgc3RtbWFjX3BvbGwoc3RydWN0IG5hcGlfc3RydWN0ICpuYXBpLCBpbnQgYnVkZ2V0KQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IGNvbnRhaW5lcl9vZihuYXBpLCBzdHJ1Y3Qgc3RtbWFjX3ByaXYsIG5hcGkpOworCWludCB3b3JrX2RvbmUgPSAwOworCisJcHJpdi0+eHN0YXRzLnBvbGxfbisrOworCXN0bW1hY190eChwcml2KTsKKwl3b3JrX2RvbmUgPSBzdG1tYWNfcngocHJpdiwgYnVkZ2V0KTsKKworCWlmICh3b3JrX2RvbmUgPCBidWRnZXQpIHsKKwkJbmFwaV9jb21wbGV0ZShuYXBpKTsKKwkJc3RtbWFjX2VuYWJsZV9pcnEocHJpdik7CisJfQorCXJldHVybiB3b3JrX2RvbmU7Cit9CisKKy8qKgorICogIHN0bW1hY190eF90aW1lb3V0CisgKiAgQGRldiA6IFBvaW50ZXIgdG8gbmV0IGRldmljZSBzdHJ1Y3R1cmUKKyAqICBEZXNjcmlwdGlvbjogdGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgd2hlbiBhIHBhY2tldCB0cmFuc21pc3Npb24gZmFpbHMgdG8KKyAqICAgY29tcGxldGUgd2l0aGluIGEgcmVhc29uYWJsZSB0bXJhdGUuIFRoZSBkcml2ZXIgd2lsbCBtYXJrIHRoZSBlcnJvciBpbiB0aGUKKyAqICAgbmV0ZGV2IHN0cnVjdHVyZSBhbmQgYXJyYW5nZSBmb3IgdGhlIGRldmljZSB0byBiZSByZXNldCB0byBhIHNhbmUgc3RhdGUKKyAqICAgaW4gb3JkZXIgdG8gdHJhbnNtaXQgYSBuZXcgcGFja2V0LgorICovCitzdGF0aWMgdm9pZCBzdG1tYWNfdHhfdGltZW91dChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisKKwkvKiBDbGVhciBUeCByZXNvdXJjZXMgYW5kIHJlc3RhcnQgdHJhbnNtaXR0aW5nIGFnYWluICovCisJc3RtbWFjX3R4X2Vycihwcml2KTsKKwlyZXR1cm47Cit9CisKKy8qIENvbmZpZ3VyYXRpb24gY2hhbmdlcyAocGFzc2VkIG9uIGJ5IGlmY29uZmlnKSAqLworc3RhdGljIGludCBzdG1tYWNfY29uZmlnKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBpZm1hcCAqbWFwKQoreworCWlmIChkZXYtPmZsYWdzICYgSUZGX1VQKQkvKiBjYW4ndCBhY3Qgb24gYSBydW5uaW5nIGludGVyZmFjZSAqLworCQlyZXR1cm4gLUVCVVNZOworCisJLyogRG9uJ3QgYWxsb3cgY2hhbmdpbmcgdGhlIEkvTyBhZGRyZXNzICovCisJaWYgKG1hcC0+YmFzZV9hZGRyICE9IGRldi0+YmFzZV9hZGRyKSB7CisJCXByX3dhcm5pbmcoIiVzOiBjYW4ndCBjaGFuZ2UgSS9PIGFkZHJlc3NcbiIsIGRldi0+bmFtZSk7CisJCXJldHVybiAtRU9QTk9UU1VQUDsKKwl9CisKKwkvKiBEb24ndCBhbGxvdyBjaGFuZ2luZyB0aGUgSVJRICovCisJaWYgKG1hcC0+aXJxICE9IGRldi0+aXJxKSB7CisJCXByX3dhcm5pbmcoIiVzOiBjYW4ndCBjaGFuZ2UgSVJRIG51bWJlciAlZFxuIiwKKwkJICAgICAgIGRldi0+bmFtZSwgZGV2LT5pcnEpOworCQlyZXR1cm4gLUVPUE5PVFNVUFA7CisJfQorCisJLyogaWdub3JlIG90aGVyIGZpZWxkcyAqLworCXJldHVybiAwOworfQorCisvKioKKyAqICBzdG1tYWNfbXVsdGljYXN0X2xpc3QgLSBlbnRyeSBwb2ludCBmb3IgbXVsdGljYXN0IGFkZHJlc3NpbmcKKyAqICBAZGV2IDogcG9pbnRlciB0byB0aGUgZGV2aWNlIHN0cnVjdHVyZQorICogIERlc2NyaXB0aW9uOgorICogIFRoaXMgZnVuY3Rpb24gaXMgYSBkcml2ZXIgZW50cnkgcG9pbnQgd2hpY2ggZ2V0cyBjYWxsZWQgYnkgdGhlIGtlcm5lbAorICogIHdoZW5ldmVyIG11bHRpY2FzdCBhZGRyZXNzZXMgbXVzdCBiZSBlbmFibGVkL2Rpc2FibGVkLgorICogIFJldHVybiB2YWx1ZToKKyAqICB2b2lkLgorICovCitzdGF0aWMgdm9pZCBzdG1tYWNfbXVsdGljYXN0X2xpc3Qoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOworCisJc3Bpbl9sb2NrKCZwcml2LT5sb2NrKTsKKwlwcml2LT5tYWNfdHlwZS0+b3BzLT5zZXRfZmlsdGVyKGRldik7CisJc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOworCXJldHVybjsKK30KKworLyoqCisgKiAgc3RtbWFjX2NoYW5nZV9tdHUgLSBlbnRyeSBwb2ludCB0byBjaGFuZ2UgTVRVIHNpemUgZm9yIHRoZSBkZXZpY2UuCisgKiAgQGRldiA6IGRldmljZSBwb2ludGVyLgorICogIEBuZXdfbXR1IDogdGhlIG5ldyBNVFUgc2l6ZSBmb3IgdGhlIGRldmljZS4KKyAqICBEZXNjcmlwdGlvbjogdGhlIE1heGltdW0gVHJhbnNmZXIgVW5pdCAoTVRVKSBpcyB1c2VkIGJ5IHRoZSBuZXR3b3JrIGxheWVyCisgKiAgdG8gZHJpdmUgcGFja2V0IHRyYW5zbWlzc2lvbi4gRXRoZXJuZXQgaGFzIGFuIE1UVSBvZiAxNTAwIG9jdGV0cworICogIChFVEhfREFUQV9MRU4pLiBUaGlzIHZhbHVlIGNhbiBiZSBjaGFuZ2VkIHdpdGggaWZjb25maWcuCisgKiAgUmV0dXJuIHZhbHVlOgorICogIDAgb24gc3VjY2VzcyBhbmQgYW4gYXBwcm9wcmlhdGUgKC0pdmUgaW50ZWdlciBhcyBkZWZpbmVkIGluIGVycm5vLmgKKyAqICBmaWxlIG9uIGZhaWx1cmUuCisgKi8KK3N0YXRpYyBpbnQgc3RtbWFjX2NoYW5nZV9tdHUoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgaW50IG5ld19tdHUpCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwlpbnQgbWF4X210dTsKKworCWlmIChuZXRpZl9ydW5uaW5nKGRldikpIHsKKwkJcHJfZXJyKCIlczogbXVzdCBiZSBzdG9wcGVkIHRvIGNoYW5nZSBpdHMgTVRVXG4iLCBkZXYtPm5hbWUpOworCQlyZXR1cm4gLUVCVVNZOworCX0KKworCWlmIChwcml2LT5pc19nbWFjKQorCQltYXhfbXR1ID0gSlVNQk9fTEVOOworCWVsc2UKKwkJbWF4X210dSA9IEVUSF9EQVRBX0xFTjsKKworCWlmICgobmV3X210dSA8IDQ2KSB8fCAobmV3X210dSA+IG1heF9tdHUpKSB7CisJCXByX2VycigiJXM6IGludmFsaWQgTVRVLCBtYXggTVRVIGlzOiAlZFxuIiwgZGV2LT5uYW1lLCBtYXhfbXR1KTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJZGV2LT5tdHUgPSBuZXdfbXR1OworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpcnFyZXR1cm5fdCBzdG1tYWNfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gKHN0cnVjdCBuZXRfZGV2aWNlICopZGV2X2lkOworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisKKwlpZiAodW5saWtlbHkoIWRldikpIHsKKwkJcHJfZXJyKCIlczogaW52YWxpZCBkZXYgcG9pbnRlclxuIiwgX19mdW5jX18pOworCQlyZXR1cm4gSVJRX05PTkU7CisJfQorCisJaWYgKHByaXYtPmlzX2dtYWMpIHsKKwkJdW5zaWduZWQgbG9uZyBpb2FkZHIgPSBkZXYtPmJhc2VfYWRkcjsKKwkJLyogVG8gaGFuZGxlIEdNQUMgb3duIGludGVycnVwdHMgKi8KKwkJcHJpdi0+bWFjX3R5cGUtPm9wcy0+aG9zdF9pcnFfc3RhdHVzKGlvYWRkcik7CisJfQorCXN0bW1hY19kbWFfaW50ZXJydXB0KGRldik7CisKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKKyNpZmRlZiBDT05GSUdfTkVUX1BPTExfQ09OVFJPTExFUgorLyogUG9sbGluZyByZWNlaXZlIC0gdXNlZCBieSBORVRDT05TT0xFIGFuZCBvdGhlciBkaWFnbm9zdGljIHRvb2xzCisgKiB0byBhbGxvdyBuZXR3b3JrIEkvTyB3aXRoIGludGVycnVwdHMgZGlzYWJsZWQuICovCitzdGF0aWMgdm9pZCBzdG1tYWNfcG9sbF9jb250cm9sbGVyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCit7CisJZGlzYWJsZV9pcnEoZGV2LT5pcnEpOworCXN0bW1hY19pbnRlcnJ1cHQoZGV2LT5pcnEsIGRldik7CisJZW5hYmxlX2lycShkZXYtPmlycSk7Cit9CisjZW5kaWYKKworLyoqCisgKiAgc3RtbWFjX2lvY3RsIC0gRW50cnkgcG9pbnQgZm9yIHRoZSBJb2N0bAorICogIEBkZXY6IERldmljZSBwb2ludGVyLgorICogIEBycTogQW4gSU9DVEwgc3BlY2VmaWMgc3RydWN0dXJlLCB0aGF0IGNhbiBjb250YWluIGEgcG9pbnRlciB0bworICogIGEgcHJvcHJpZXRhcnkgc3RydWN0dXJlIHVzZWQgdG8gcGFzcyBpbmZvcm1hdGlvbiB0byB0aGUgZHJpdmVyLgorICogIEBjbWQ6IElPQ1RMIGNvbW1hbmQKKyAqICBEZXNjcmlwdGlvbjoKKyAqICBDdXJyZW50bHkgdGhlcmUgYXJlIG5vIHNwZWNpYWwgZnVuY3Rpb25hbGl0eSBzdXBwb3J0ZWQgaW4gSU9DVEwsIGp1c3QgdGhlCisgKiAgcGh5X21paV9pb2N0bCguLi4pIGNhbiBiZSBpbnZva2VkLgorICovCitzdGF0aWMgaW50IHN0bW1hY19pb2N0bChzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3QgaWZyZXEgKnJxLCBpbnQgY21kKQoreworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisJaW50IHJldCA9IC1FT1BOT1RTVVBQOworCisJaWYgKCFuZXRpZl9ydW5uaW5nKGRldikpCisJCXJldHVybiAtRUlOVkFMOworCisJc3dpdGNoIChjbWQpIHsKKwljYXNlIFNJT0NHTUlJUEhZOgorCWNhc2UgU0lPQ0dNSUlSRUc6CisJY2FzZSBTSU9DU01JSVJFRzoKKwkJaWYgKCFwcml2LT5waHlkZXYpCisJCQlyZXR1cm4gLUVJTlZBTDsKKworCQlzcGluX2xvY2soJnByaXYtPmxvY2spOworCQlyZXQgPSBwaHlfbWlpX2lvY3RsKHByaXYtPnBoeWRldiwgaWZfbWlpKHJxKSwgY21kKTsKKwkJc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKwlyZXR1cm4gcmV0OworfQorCisjaWZkZWYgU1RNTUFDX1ZMQU5fVEFHX1VTRUQKK3N0YXRpYyB2b2lkIHN0bW1hY192bGFuX3J4X3JlZ2lzdGVyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsCisJCQkJICAgIHN0cnVjdCB2bGFuX2dyb3VwICpncnApCit7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKworCURCRyhwcm9iZSwgSU5GTywgIiVzOiBTZXR0aW5nIHZsZ3JwIHRvICVwXG4iLCBkZXYtPm5hbWUsIGdycCk7CisKKwlzcGluX2xvY2soJnByaXYtPmxvY2spOworCXByaXYtPnZsZ3JwID0gZ3JwOworCXNwaW5fdW5sb2NrKCZwcml2LT5sb2NrKTsKKworCXJldHVybjsKK30KKyNlbmRpZgorCitzdGF0aWMgY29uc3Qgc3RydWN0IG5ldF9kZXZpY2Vfb3BzIHN0bW1hY19uZXRkZXZfb3BzID0geworCS5uZG9fb3BlbiA9IHN0bW1hY19vcGVuLAorCS5uZG9fc3RhcnRfeG1pdCA9IHN0bW1hY194bWl0LAorCS5uZG9fc3RvcCA9IHN0bW1hY19yZWxlYXNlLAorCS5uZG9fY2hhbmdlX210dSA9IHN0bW1hY19jaGFuZ2VfbXR1LAorCS5uZG9fc2V0X211bHRpY2FzdF9saXN0ID0gc3RtbWFjX211bHRpY2FzdF9saXN0LAorCS5uZG9fdHhfdGltZW91dCA9IHN0bW1hY190eF90aW1lb3V0LAorCS5uZG9fZG9faW9jdGwgPSBzdG1tYWNfaW9jdGwsCisJLm5kb19zZXRfY29uZmlnID0gc3RtbWFjX2NvbmZpZywKKyNpZmRlZiBTVE1NQUNfVkxBTl9UQUdfVVNFRAorCS5uZG9fdmxhbl9yeF9yZWdpc3RlciA9IHN0bW1hY192bGFuX3J4X3JlZ2lzdGVyLAorI2VuZGlmCisjaWZkZWYgQ09ORklHX05FVF9QT0xMX0NPTlRST0xMRVIKKwkubmRvX3BvbGxfY29udHJvbGxlciA9IHN0bW1hY19wb2xsX2NvbnRyb2xsZXIsCisjZW5kaWYKKwkubmRvX3NldF9tYWNfYWRkcmVzcyA9IGV0aF9tYWNfYWRkciwKK307CisKKy8qKgorICogc3RtbWFjX3Byb2JlIC0gSW5pdGlhbGl6YXRpb24gb2YgdGhlIGFkYXB0ZXIgLgorICogQGRldiA6IGRldmljZSBwb2ludGVyCisgKiBEZXNjcmlwdGlvbjogVGhlIGZ1bmN0aW9uIGluaXRpYWxpemVzIHRoZSBuZXR3b3JrIGRldmljZSBzdHJ1Y3R1cmUgZm9yCisgKiB0aGUgU1RNTUFDIGRyaXZlci4gSXQgYWxzbyBjYWxscyB0aGUgbG93IGxldmVsIHJvdXRpbmVzCisgKiBpbiBvcmRlciB0byBpbml0IHRoZSBIVyAoaS5lLiB0aGUgRE1BIGVuZ2luZSkKKyAqLworc3RhdGljIGludCBzdG1tYWNfcHJvYmUoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3sKKwlpbnQgcmV0ID0gMDsKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOworCisJZXRoZXJfc2V0dXAoZGV2KTsKKworCWRldi0+bmV0ZGV2X29wcyA9ICZzdG1tYWNfbmV0ZGV2X29wczsKKwlzdG1tYWNfc2V0X2V0aHRvb2xfb3BzKGRldik7CisKKwlkZXYtPmZlYXR1cmVzIHw9IChORVRJRl9GX1NHIHwgTkVUSUZfRl9IV19DU1VNIHwgTkVUSUZfRl9ISUdIRE1BKTsKKwlkZXYtPndhdGNoZG9nX3RpbWVvID0gbXNlY3NfdG9famlmZmllcyh3YXRjaGRvZyk7CisjaWZkZWYgU1RNTUFDX1ZMQU5fVEFHX1VTRUQKKwkvKiBCb3RoIG1hYzEwMCBhbmQgZ21hYyBzdXBwb3J0IHJlY2VpdmUgVkxBTiB0YWcgZGV0ZWN0aW9uICovCisJZGV2LT5mZWF0dXJlcyB8PSBORVRJRl9GX0hXX1ZMQU5fUlg7CisjZW5kaWYKKwlwcml2LT5tc2dfZW5hYmxlID0gbmV0aWZfbXNnX2luaXQoZGVidWcsIGRlZmF1bHRfbXNnX2xldmVsKTsKKworCWlmIChwcml2LT5pc19nbWFjKQorCQlwcml2LT5yeF9jc3VtID0gMTsKKworCWlmIChmbG93X2N0cmwpCisJCXByaXYtPmZsb3dfY3RybCA9IEZMT1dfQVVUTzsJLyogUlgvVFggcGF1c2Ugb24gKi8KKworCXByaXYtPnBhdXNlID0gcGF1c2U7CisJbmV0aWZfbmFwaV9hZGQoZGV2LCAmcHJpdi0+bmFwaSwgc3RtbWFjX3BvbGwsIDY0KTsKKworCS8qIEdldCB0aGUgTUFDIGFkZHJlc3MgKi8KKwlwcml2LT5tYWNfdHlwZS0+b3BzLT5nZXRfdW1hY19hZGRyKGRldi0+YmFzZV9hZGRyLCBkZXYtPmRldl9hZGRyLCAwKTsKKworCWlmICghaXNfdmFsaWRfZXRoZXJfYWRkcihkZXYtPmRldl9hZGRyKSkKKwkJcHJfd2FybmluZygiXHRubyB2YWxpZCBNQUMgYWRkcmVzczsiCisJCQkicGxlYXNlLCB1c2UgaWZjb25maWcgb3Igbndod2NvbmZpZyFcbiIpOworCisJcmV0ID0gcmVnaXN0ZXJfbmV0ZGV2KGRldik7CisJaWYgKHJldCkgeworCQlwcl9lcnIoIiVzOiBFUlJPUiAlaSByZWdpc3RlcmluZyB0aGUgZGV2aWNlXG4iLAorCQkgICAgICAgX19mdW5jX18sIHJldCk7CisJCXJldHVybiAtRU5PREVWOworCX0KKworCURCRyhwcm9iZSwgREVCVUcsICIlczogU2NhdHRlci9HYXRoZXI6ICVzIC0gSFcgY2hlY2tzdW1zOiAlc1xuIiwKKwkgICAgZGV2LT5uYW1lLCAoZGV2LT5mZWF0dXJlcyAmIE5FVElGX0ZfU0cpID8gIm9uIiA6ICJvZmYiLAorCSAgICAoZGV2LT5mZWF0dXJlcyAmIE5FVElGX0ZfSFdfQ1NVTSkgPyAib24iIDogIm9mZiIpOworCisJc3Bpbl9sb2NrX2luaXQoJnByaXYtPmxvY2spOworCisJcmV0dXJuIHJldDsKK30KKworLyoqCisgKiBzdG1tYWNfbWFjX2RldmljZV9zZXR1cAorICogQGRldiA6IGRldmljZSBwb2ludGVyCisgKiBEZXNjcmlwdGlvbjogc2VsZWN0IGFuZCBpbml0aWFsaXNlIHRoZSBtYWMgZGV2aWNlIChtYWMxMDAgb3IgR21hYykuCisgKi8KK3N0YXRpYyBpbnQgc3RtbWFjX21hY19kZXZpY2Vfc2V0dXAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKK3sKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihkZXYpOworCXVuc2lnbmVkIGxvbmcgaW9hZGRyID0gZGV2LT5iYXNlX2FkZHI7CisKKwlzdHJ1Y3QgbWFjX2RldmljZV9pbmZvICpkZXZpY2U7CisKKwlpZiAocHJpdi0+aXNfZ21hYykKKwkJZGV2aWNlID0gZ21hY19zZXR1cChpb2FkZHIpOworCWVsc2UKKwkJZGV2aWNlID0gbWFjMTAwX3NldHVwKGlvYWRkcik7CisKKwlpZiAoIWRldmljZSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlwcml2LT5tYWNfdHlwZSA9IGRldmljZTsKKworCXByaXYtPndvbGVuYWJsZWQgPSBwcml2LT5tYWNfdHlwZS0+aHcucG10OwkvKiBQTVQgc3VwcG9ydGVkICovCisJaWYgKHByaXYtPndvbGVuYWJsZWQgPT0gUE1UX1NVUFBPUlRFRCkKKwkJcHJpdi0+d29sb3B0cyA9IFdBS0VfTUFHSUM7CQkvKiBNYWdpYyBGcmFtZSAqLworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgc3RtbWFjcGh5X2R2cl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBwbGF0X3N0bW1hY3BoeV9kYXRhICpwbGF0X2RhdDsKKwlwbGF0X2RhdCA9IChzdHJ1Y3QgcGxhdF9zdG1tYWNwaHlfZGF0YSAqKSgocGRldi0+ZGV2KS5wbGF0Zm9ybV9kYXRhKTsKKworCXByX2RlYnVnKCJzdG1tYWNwaHlfZHZyX3Byb2JlOiBhZGRlZCBwaHkgZm9yIGJ1cyAlZFxuIiwKKwkgICAgICAgcGxhdF9kYXQtPmJ1c19pZCk7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBzdG1tYWNwaHlfZHZyX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBzdG1tYWNwaHlfZHJpdmVyID0geworCS5kcml2ZXIgPSB7CisJCSAgIC5uYW1lID0gUEhZX1JFU09VUkNFX05BTUUsCisJCSAgIH0sCisJLnByb2JlID0gc3RtbWFjcGh5X2R2cl9wcm9iZSwKKwkucmVtb3ZlID0gc3RtbWFjcGh5X2R2cl9yZW1vdmUsCit9OworCisvKioKKyAqIHN0bW1hY19hc3NvY2lhdGVfcGh5CisgKiBAZGV2OiBwb2ludGVyIHRvIGRldmljZSBzdHJ1Y3R1cmUKKyAqIEBkYXRhOiBwb2ludHMgdG8gdGhlIHByaXZhdGUgc3RydWN0dXJlLgorICogRGVzY3JpcHRpb246IFNjYW5zIHRocm91Z2ggYWxsIHRoZSBQSFlzIHdlIGhhdmUgcmVnaXN0ZXJlZCBhbmQgY2hlY2tzIGlmCisgKiBhbnkgYXJlIGFzc29jaWF0ZWQgd2l0aCBvdXIgTUFDLiAgSWYgc28sIHRoZW4ganVzdCBmaWxsIGluCisgKiB0aGUgYmxhbmtzIGluIG91ciBsb2NhbCBjb250ZXh0IHN0cnVjdHVyZQorICovCitzdGF0aWMgaW50IHN0bW1hY19hc3NvY2lhdGVfcGh5KHN0cnVjdCBkZXZpY2UgKmRldiwgdm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSAoc3RydWN0IHN0bW1hY19wcml2ICopZGF0YTsKKwlzdHJ1Y3QgcGxhdF9zdG1tYWNwaHlfZGF0YSAqcGxhdF9kYXQ7CisKKwlwbGF0X2RhdCA9IChzdHJ1Y3QgcGxhdF9zdG1tYWNwaHlfZGF0YSAqKShkZXYtPnBsYXRmb3JtX2RhdGEpOworCisJREJHKHByb2JlLCBERUJVRywgIiVzOiBjaGVja2luZyBwaHkgZm9yIGJ1cyAlZFxuIiwgX19mdW5jX18sCisJCXBsYXRfZGF0LT5idXNfaWQpOworCisJLyogQ2hlY2sgdGhhdCB0aGlzIHBoeSBpcyBmb3IgdGhlIE1BQyBiZWluZyBpbml0aWFsaXNlZCAqLworCWlmIChwcml2LT5idXNfaWQgIT0gcGxhdF9kYXQtPmJ1c19pZCkKKwkJcmV0dXJuIDA7CisKKwkvKiBPSywgdGhpcyBQSFkgaXMgY29ubmVjdGVkIHRvIHRoZSBNQUMuCisJICAgR28gYWhlYWQgYW5kIGdldCB0aGUgcGFyYW1ldGVycyAqLworCURCRyhwcm9iZSwgREVCVUcsICIlczogT0suIEZvdW5kIFBIWSBjb25maWdcbiIsIF9fZnVuY19fKTsKKwlwcml2LT5waHlfaXJxID0KKwkgICAgcGxhdGZvcm1fZ2V0X2lycV9ieW5hbWUodG9fcGxhdGZvcm1fZGV2aWNlKGRldiksICJwaHlpcnEiKTsKKwlEQkcocHJvYmUsIERFQlVHLCAiJXM6IFBIWSBpcnEgb24gYnVzICVkIGlzICVkXG4iLCBfX2Z1bmNfXywKKwkgICAgcGxhdF9kYXQtPmJ1c19pZCwgcHJpdi0+cGh5X2lycSk7CisKKwkvKiBPdmVycmlkZSB3aXRoIGtlcm5lbCBwYXJhbWV0ZXJzIGlmIHN1cHBsaWVkIFhYWCBDUlMgWFhYCisJICogdGhpcyBuZWVkcyB0byBoYXZlIG11bHRpcGxlIGluc3RhbmNlcyAqLworCWlmICgocGh5YWRkciA+PSAwKSAmJiAocGh5YWRkciA8PSAzMSkpCisJCXBsYXRfZGF0LT5waHlfYWRkciA9IHBoeWFkZHI7CisKKwlwcml2LT5waHlfYWRkciA9IHBsYXRfZGF0LT5waHlfYWRkcjsKKwlwcml2LT5waHlfbWFzayA9IHBsYXRfZGF0LT5waHlfbWFzazsKKwlwcml2LT5waHlfaW50ZXJmYWNlID0gcGxhdF9kYXQtPmludGVyZmFjZTsKKwlwcml2LT5waHlfcmVzZXQgPSBwbGF0X2RhdC0+cGh5X3Jlc2V0OworCisJREJHKHByb2JlLCBERUJVRywgIiVzOiBleGl0aW5nXG4iLCBfX2Z1bmNfXyk7CisJcmV0dXJuIDE7CS8qIGZvcmNlcyBleGl0IG9mIGRyaXZlcl9mb3JfZWFjaF9kZXZpY2UoKSAqLworfQorCisvKioKKyAqIHN0bW1hY19kdnJfcHJvYmUKKyAqIEBwZGV2OiBwbGF0Zm9ybSBkZXZpY2UgcG9pbnRlcgorICogRGVzY3JpcHRpb246IHRoZSBkcml2ZXIgaXMgaW5pdGlhbGl6ZWQgdGhyb3VnaCBwbGF0Zm9ybV9kZXZpY2UuCisgKi8KK3N0YXRpYyBpbnQgc3RtbWFjX2R2cl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCWludCByZXQgPSAwOworCXN0cnVjdCByZXNvdXJjZSAqcmVzOworCXVuc2lnbmVkIGludCAqYWRkciA9IE5VTEw7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYgPSBOVUxMOworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdjsKKwlzdHJ1Y3QgcGxhdF9zdG1tYWNlbmV0X2RhdGEgKnBsYXRfZGF0OworCisJcHJfaW5mbygiU1RNTUFDIGRyaXZlcjpcblx0cGxhdGZvcm0gcmVnaXN0cmF0aW9uLi4uICIpOworCXJlcyA9IHBsYXRmb3JtX2dldF9yZXNvdXJjZShwZGV2LCBJT1JFU09VUkNFX01FTSwgMCk7CisJaWYgKCFyZXMpIHsKKwkJcmV0ID0gLUVOT0RFVjsKKwkJZ290byBvdXQ7CisJfQorCXByX2luZm8oImRvbmUhXG4iKTsKKworCWlmICghcmVxdWVzdF9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsIChyZXMtPmVuZCAtIHJlcy0+c3RhcnQpLAorCQkJCXBkZXYtPm5hbWUpKSB7CisJCXByX2VycigiJXM6IEVSUk9SOiBtZW1vcnkgYWxsb2NhdGlvbiBmYWlsZWQiCisJCSAgICAgICAiY2Fubm90IGdldCB0aGUgSS9PIGFkZHIgMHgleFxuIiwKKwkJICAgICAgIF9fZnVuY19fLCAodW5zaWduZWQgaW50KXJlcy0+c3RhcnQpOworCQlyZXQgPSAtRUJVU1k7CisJCWdvdG8gb3V0OworCX0KKworCWFkZHIgPSBpb3JlbWFwKHJlcy0+c3RhcnQsIChyZXMtPmVuZCAtIHJlcy0+c3RhcnQpKTsKKwlpZiAoIWFkZHIpIHsKKwkJcHJfZXJyKCIlczogRVJST1I6IG1lbW9yeSBtYXBwaW5nIGZhaWxlZCBcbiIsIF9fZnVuY19fKTsKKwkJcmV0ID0gLUVOT01FTTsKKwkJZ290byBvdXQ7CisJfQorCisJbmRldiA9IGFsbG9jX2V0aGVyZGV2KHNpemVvZihzdHJ1Y3Qgc3RtbWFjX3ByaXYpKTsKKwlpZiAoIW5kZXYpIHsKKwkJcHJfZXJyKCIlczogRVJST1I6IGFsbG9jYXRpbmcgdGhlIGRldmljZVxuIiwgX19mdW5jX18pOworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIG91dDsKKwl9CisKKwlTRVRfTkVUREVWX0RFVihuZGV2LCAmcGRldi0+ZGV2KTsKKworCS8qIEdldCB0aGUgTUFDIGluZm9ybWF0aW9uICovCisJbmRldi0+aXJxID0gcGxhdGZvcm1fZ2V0X2lycV9ieW5hbWUocGRldiwgIm1hY2lycSIpOworCWlmIChuZGV2LT5pcnEgPT0gLUVOWElPKSB7CisJCXByX2VycigiJXM6IEVSUk9SOiBNQUMgSVJRIGNvbmZpZ3VyYXRpb24gIgorCQkgICAgICAgImluZm9ybWF0aW9uIG5vdCBmb3VuZFxuIiwgX19mdW5jX18pOworCQlyZXQgPSAtRU5PREVWOworCQlnb3RvIG91dDsKKwl9CisKKwlwcml2ID0gbmV0ZGV2X3ByaXYobmRldik7CisJcHJpdi0+ZGV2aWNlID0gJihwZGV2LT5kZXYpOworCXByaXYtPmRldiA9IG5kZXY7CisJcGxhdF9kYXQgPSAoc3RydWN0IHBsYXRfc3RtbWFjZW5ldF9kYXRhICopKChwZGV2LT5kZXYpLnBsYXRmb3JtX2RhdGEpOworCXByaXYtPmJ1c19pZCA9IHBsYXRfZGF0LT5idXNfaWQ7CisJcHJpdi0+cGJsID0gcGxhdF9kYXQtPnBibDsJLyogVExJICovCisJcHJpdi0+aXNfZ21hYyA9IHBsYXRfZGF0LT5oYXNfZ21hYzsJLyogR01BQyBpcyBvbiBib2FyZCAqLworCisJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgbmRldik7CisKKwkvKiBTZXQgdGhlIEkvTyBiYXNlIGFkZHIgKi8KKwluZGV2LT5iYXNlX2FkZHIgPSAodW5zaWduZWQgbG9uZylhZGRyOworCisJLyogTUFDIEhXIHJldmljZSBkZXRlY3Rpb24gKi8KKwlyZXQgPSBzdG1tYWNfbWFjX2RldmljZV9zZXR1cChuZGV2KTsKKwlpZiAocmV0IDwgMCkKKwkJZ290byBvdXQ7CisKKwkvKiBOZXR3b3JrIERldmljZSBSZWdpc3RyYXRpb24gKi8KKwlyZXQgPSBzdG1tYWNfcHJvYmUobmRldik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJLyogYXNzb2NpYXRlIGEgUEhZIC0gaXQgaXMgcHJvdmlkZWQgYnkgYW5vdGhlciBwbGF0Zm9ybSBidXMgKi8KKwlpZiAoIWRyaXZlcl9mb3JfZWFjaF9kZXZpY2UKKwkgICAgKCYoc3RtbWFjcGh5X2RyaXZlci5kcml2ZXIpLCBOVUxMLCAodm9pZCAqKXByaXYsCisJICAgICBzdG1tYWNfYXNzb2NpYXRlX3BoeSkpIHsKKwkJcHJfZXJyKCJObyBQSFkgZGV2aWNlIGlzIGFzc29jaWF0ZWQgd2l0aCB0aGlzIE1BQyFcbiIpOworCQlyZXQgPSAtRU5PREVWOworCQlnb3RvIG91dDsKKwl9CisKKwlwcml2LT5maXhfbWFjX3NwZWVkID0gcGxhdF9kYXQtPmZpeF9tYWNfc3BlZWQ7CisJcHJpdi0+YnNwX3ByaXYgPSBwbGF0X2RhdC0+YnNwX3ByaXY7CisKKwlwcl9pbmZvKCJcdCVzIC0gKGRldi4gbmFtZTogJXMgLSBpZDogJWQsIElSUSAjJWRcbiIKKwkgICAgICAgIlx0SU8gYmFzZSBhZGRyOiAweCUwOHgpXG4iLCBuZGV2LT5uYW1lLCBwZGV2LT5uYW1lLAorCSAgICAgICBwZGV2LT5pZCwgbmRldi0+aXJxLCAodW5zaWduZWQgaW50KWFkZHIpOworCisJLyogTURJTyBidXMgUmVnaXN0cmF0aW9uICovCisJcHJfZGVidWcoIlx0TURJTyBidXMgKGlkOiAlZCkuLi4iLCBwcml2LT5idXNfaWQpOworCXJldCA9IHN0bW1hY19tZGlvX3JlZ2lzdGVyKG5kZXYpOworCWlmIChyZXQgPCAwKQorCQlnb3RvIG91dDsKKwlwcl9kZWJ1ZygicmVnaXN0ZXJlZCFcbiIpOworCitvdXQ6CisJaWYgKHJldCA8IDApIHsKKwkJcGxhdGZvcm1fc2V0X2RydmRhdGEocGRldiwgTlVMTCk7CisJCXJlbGVhc2VfbWVtX3JlZ2lvbihyZXMtPnN0YXJ0LCAocmVzLT5lbmQgLSByZXMtPnN0YXJ0KSk7CisJCWlmIChhZGRyICE9IE5VTEwpCisJCQlpb3VubWFwKGFkZHIpOworCX0KKworCXJldHVybiByZXQ7Cit9CisKKy8qKgorICogc3RtbWFjX2R2cl9yZW1vdmUKKyAqIEBwZGV2OiBwbGF0Zm9ybSBkZXZpY2UgcG9pbnRlcgorICogRGVzY3JpcHRpb246IHRoaXMgZnVuY3Rpb24gcmVzZXRzIHRoZSBUWC9SWCBwcm9jZXNzZXMsIGRpc2FibGVzIHRoZSBNQUMgUlgvVFgKKyAqIGNoYW5nZXMgdGhlIGxpbmsgc3RhdHVzLCByZWxlYXNlcyB0aGUgRE1BIGRlc2NyaXB0b3IgcmluZ3MsCisgKiB1bnJlZ2lzdGVycyB0aGUgTURJTyBidXMgYW5kIHVubWFwcyB0aGUgYWxsb2NhdGVkIG1lbW9yeS4KKyAqLworc3RhdGljIGludCBzdG1tYWNfZHZyX3JlbW92ZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQoreworCXN0cnVjdCBuZXRfZGV2aWNlICpuZGV2ID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisJc3RydWN0IHJlc291cmNlICpyZXM7CisKKwlwcl9pbmZvKCIlczpcblx0cmVtb3ZpbmcgZHJpdmVyIiwgX19mdW5jX18pOworCisJc3RtbWFjX2RtYV9zdG9wX3J4KG5kZXYtPmJhc2VfYWRkcik7CisJc3RtbWFjX2RtYV9zdG9wX3R4KG5kZXYtPmJhc2VfYWRkcik7CisKKwlzdG1tYWNfbWFjX2Rpc2FibGVfcngobmRldi0+YmFzZV9hZGRyKTsKKwlzdG1tYWNfbWFjX2Rpc2FibGVfdHgobmRldi0+YmFzZV9hZGRyKTsKKworCW5ldGlmX2NhcnJpZXJfb2ZmKG5kZXYpOworCisJc3RtbWFjX21kaW9fdW5yZWdpc3RlcihuZGV2KTsKKworCXBsYXRmb3JtX3NldF9kcnZkYXRhKHBkZXYsIE5VTEwpOworCXVucmVnaXN0ZXJfbmV0ZGV2KG5kZXYpOworCisJaW91bm1hcCgodm9pZCAqKW5kZXYtPmJhc2VfYWRkcik7CisJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKKwlyZWxlYXNlX21lbV9yZWdpb24ocmVzLT5zdGFydCwgKHJlcy0+ZW5kIC0gcmVzLT5zdGFydCkpOworCisJZnJlZV9uZXRkZXYobmRldik7CisKKwlyZXR1cm4gMDsKK30KKworI2lmZGVmIENPTkZJR19QTQorc3RhdGljIGludCBzdG1tYWNfc3VzcGVuZChzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2LCBwbV9tZXNzYWdlX3Qgc3RhdGUpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKmRldiA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KGRldik7CisJaW50IGRpc19pYyA9IDA7CisKKwlpZiAoIWRldiB8fCAhbmV0aWZfcnVubmluZyhkZXYpKQorCQlyZXR1cm4gMDsKKworCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7CisKKwlpZiAoc3RhdGUuZXZlbnQgPT0gUE1fRVZFTlRfU1VTUEVORCkgeworCQluZXRpZl9kZXZpY2VfZGV0YWNoKGRldik7CisJCW5ldGlmX3N0b3BfcXVldWUoZGV2KTsKKwkJaWYgKHByaXYtPnBoeWRldikKKwkJCXBoeV9zdG9wKHByaXYtPnBoeWRldik7CisKKyNpZmRlZiBDT05GSUdfU1RNTUFDX1RJTUVSCisJCXByaXYtPnRtLT50aW1lcl9zdG9wKCk7CisJCWRpc19pYyA9IDE7CisjZW5kaWYKKwkJbmFwaV9kaXNhYmxlKCZwcml2LT5uYXBpKTsKKworCQkvKiBTdG9wIFRYL1JYIERNQSAqLworCQlzdG1tYWNfZG1hX3N0b3BfdHgoZGV2LT5iYXNlX2FkZHIpOworCQlzdG1tYWNfZG1hX3N0b3BfcngoZGV2LT5iYXNlX2FkZHIpOworCQkvKiBDbGVhciB0aGUgUngvVHggZGVzY3JpcHRvcnMgKi8KKwkJcHJpdi0+bWFjX3R5cGUtPm9wcy0+aW5pdF9yeF9kZXNjKHByaXYtPmRtYV9yeCwKKwkJCQkJCSAgcHJpdi0+ZG1hX3J4X3NpemUsIGRpc19pYyk7CisJCXByaXYtPm1hY190eXBlLT5vcHMtPmluaXRfdHhfZGVzYyhwcml2LT5kbWFfdHgsCisJCQkJCQkgIHByaXYtPmRtYV90eF9zaXplKTsKKworCQlzdG1tYWNfbWFjX2Rpc2FibGVfdHgoZGV2LT5iYXNlX2FkZHIpOworCisJCWlmIChkZXZpY2VfbWF5X3dha2V1cCgmKHBkZXYtPmRldikpKSB7CisJCQkvKiBFbmFibGUgUG93ZXIgZG93biBtb2RlIGJ5IHByb2dyYW1taW5nIHRoZSBQTVQgcmVncyAqLworCQkJaWYgKHByaXYtPndvbGVuYWJsZWQgPT0gUE1UX1NVUFBPUlRFRCkKKwkJCQlwcml2LT5tYWNfdHlwZS0+b3BzLT5wbXQoZGV2LT5iYXNlX2FkZHIsCisJCQkJCQkJIHByaXYtPndvbG9wdHMpOworCQl9IGVsc2UgeworCQkJc3RtbWFjX21hY19kaXNhYmxlX3J4KGRldi0+YmFzZV9hZGRyKTsKKwkJfQorCX0gZWxzZSB7CisJCXByaXYtPnNodXRkb3duID0gMTsKKwkJLyogQWx0aG91Z2ggdGhpcyBjYW4gYXBwZWFyIHNsaWdodGx5IHJlZHVuZGFudCBpdCBhY3R1YWxseQorCQkgKiBtYWtlcyBmYXN0IHRoZSBzdGFuZGJ5IG9wZXJhdGlvbiBhbmQgZ3VhcmFudGVlcyB0aGUgZHJpdmVyCisJCSAqIHdvcmtpbmcgaWYgaGliZXJuYXRpb24gaXMgb24gbWVkaWEuICovCisJCXN0bW1hY19yZWxlYXNlKGRldik7CisJfQorCisJc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHN0bW1hY19yZXN1bWUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYoZGV2KTsKKwl1bnNpZ25lZCBsb25nIGlvYWRkciA9IGRldi0+YmFzZV9hZGRyOworCisJaWYgKCFuZXRpZl9ydW5uaW5nKGRldikpCisJCXJldHVybiAwOworCisJc3Bpbl9sb2NrKCZwcml2LT5sb2NrKTsKKworCWlmIChwcml2LT5zaHV0ZG93bikgeworCQkvKiBSZS1vcGVuIHRoZSBpbnRlcmZhY2UgYW5kIHJlLWluaXQgdGhlIE1BQy9ETUEKKwkJICAgYW5kIHRoZSByaW5ncy4gKi8KKwkJc3RtbWFjX29wZW4oZGV2KTsKKwkJZ290byBvdXRfcmVzdW1lOworCX0KKworCS8qIFBvd2VyIERvd24gYml0LCBpbnRvIHRoZSBQTSByZWdpc3RlciwgaXMgY2xlYXJlZAorCSAqIGF1dG9tYXRpY2FsbHkgYXMgc29vbiBhcyBhIG1hZ2ljIHBhY2tldCBvciBhIFdha2UtdXAgZnJhbWUKKwkgKiBpcyByZWNlaXZlZC4gQW55d2F5LCBpdCdzIGJldHRlciB0byBtYW51YWxseSBjbGVhcgorCSAqIHRoaXMgYml0IGJlY2F1c2UgaXQgY2FuIGdlbmVyYXRlIHByb2JsZW1zIHdoaWxlIHJlc3VtaW5nCisJICogZnJvbSBhbm90aGVyIGRldmljZXMgKGUuZy4gc2VyaWFsIGNvbnNvbGUpLiAqLworCWlmIChkZXZpY2VfbWF5X3dha2V1cCgmKHBkZXYtPmRldikpKQorCQlpZiAocHJpdi0+d29sZW5hYmxlZCA9PSBQTVRfU1VQUE9SVEVEKQorCQkJcHJpdi0+bWFjX3R5cGUtPm9wcy0+cG10KGRldi0+YmFzZV9hZGRyLCAwKTsKKworCW5ldGlmX2RldmljZV9hdHRhY2goZGV2KTsKKworCS8qIEVuYWJsZSB0aGUgTUFDIGFuZCBETUEgKi8KKwlzdG1tYWNfbWFjX2VuYWJsZV9yeChpb2FkZHIpOworCXN0bW1hY19tYWNfZW5hYmxlX3R4KGlvYWRkcik7CisJc3RtbWFjX2RtYV9zdGFydF90eChpb2FkZHIpOworCXN0bW1hY19kbWFfc3RhcnRfcngoaW9hZGRyKTsKKworI2lmZGVmIENPTkZJR19TVE1NQUNfVElNRVIKKwlwcml2LT50bS0+dGltZXJfc3RhcnQodG1yYXRlKTsKKyNlbmRpZgorCW5hcGlfZW5hYmxlKCZwcml2LT5uYXBpKTsKKworCWlmIChwcml2LT5waHlkZXYpCisJCXBoeV9zdGFydChwcml2LT5waHlkZXYpOworCisJbmV0aWZfc3RhcnRfcXVldWUoZGV2KTsKKworb3V0X3Jlc3VtZToKKwlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7CisJcmV0dXJuIDA7Cit9CisjZW5kaWYKKworc3RhdGljIHN0cnVjdCBwbGF0Zm9ybV9kcml2ZXIgc3RtbWFjX2RyaXZlciA9IHsKKwkuZHJpdmVyID0geworCQkgICAubmFtZSA9IFNUTU1BQ19SRVNPVVJDRV9OQU1FLAorCQkgICB9LAorCS5wcm9iZSA9IHN0bW1hY19kdnJfcHJvYmUsCisJLnJlbW92ZSA9IHN0bW1hY19kdnJfcmVtb3ZlLAorI2lmZGVmIENPTkZJR19QTQorCS5zdXNwZW5kID0gc3RtbWFjX3N1c3BlbmQsCisJLnJlc3VtZSA9IHN0bW1hY19yZXN1bWUsCisjZW5kaWYKKworfTsKKworLyoqCisgKiBzdG1tYWNfaW5pdF9tb2R1bGUgLSBFbnRyeSBwb2ludCBmb3IgdGhlIGRyaXZlcgorICogRGVzY3JpcHRpb246IFRoaXMgZnVuY3Rpb24gaXMgdGhlIGVudHJ5IHBvaW50IGZvciB0aGUgZHJpdmVyLgorICovCitzdGF0aWMgaW50IF9faW5pdCBzdG1tYWNfaW5pdF9tb2R1bGUodm9pZCkKK3sKKwlpbnQgcmV0OworCisJaWYgKHBsYXRmb3JtX2RyaXZlcl9yZWdpc3Rlcigmc3RtbWFjcGh5X2RyaXZlcikpIHsKKwkJcHJfZXJyKCJObyBQSFkgZGV2aWNlcyByZWdpc3RlcmVkIVxuIik7CisJCXJldHVybiAtRU5PREVWOworCX0KKworCXJldCA9IHBsYXRmb3JtX2RyaXZlcl9yZWdpc3Rlcigmc3RtbWFjX2RyaXZlcik7CisJcmV0dXJuIHJldDsKK30KKworLyoqCisgKiBzdG1tYWNfY2xlYW51cF9tb2R1bGUgLSBDbGVhbnVwIHJvdXRpbmUgZm9yIHRoZSBkcml2ZXIKKyAqIERlc2NyaXB0aW9uOiBUaGlzIGZ1bmN0aW9uIGlzIHRoZSBjbGVhbnVwIHJvdXRpbmUgZm9yIHRoZSBkcml2ZXIuCisgKi8KK3N0YXRpYyB2b2lkIF9fZXhpdCBzdG1tYWNfY2xlYW51cF9tb2R1bGUodm9pZCkKK3sKKwlwbGF0Zm9ybV9kcml2ZXJfdW5yZWdpc3Rlcigmc3RtbWFjcGh5X2RyaXZlcik7CisJcGxhdGZvcm1fZHJpdmVyX3VucmVnaXN0ZXIoJnN0bW1hY19kcml2ZXIpOworfQorCisjaWZuZGVmIE1PRFVMRQorc3RhdGljIGludCBfX2luaXQgc3RtbWFjX2NtZGxpbmVfb3B0KGNoYXIgKnN0cikKK3sKKwljaGFyICpvcHQ7CisKKwlpZiAoIXN0ciB8fCAhKnN0cikKKwkJcmV0dXJuIC1FSU5WQUw7CisJd2hpbGUgKChvcHQgPSBzdHJzZXAoJnN0ciwgIiwiKSkgIT0gTlVMTCkgeworCQlpZiAoIXN0cm5jbXAob3B0LCAiZGVidWc6IiwgNikpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyA2LCAwLCAodW5zaWduZWQgbG9uZyAqKSZkZWJ1Zyk7CisJCWVsc2UgaWYgKCFzdHJuY21wKG9wdCwgInBoeWFkZHI6IiwgOCkpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyA4LCAwLCAodW5zaWduZWQgbG9uZyAqKSZwaHlhZGRyKTsKKwkJZWxzZSBpZiAoIXN0cm5jbXAob3B0LCAiZG1hX3R4c2l6ZToiLCAxMSkpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyAxMSwgMCwKKwkJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgKikmZG1hX3R4c2l6ZSk7CisJCWVsc2UgaWYgKCFzdHJuY21wKG9wdCwgImRtYV9yeHNpemU6IiwgMTEpKQorCQkJc3RyaWN0X3N0cnRvdWwob3B0ICsgMTEsIDAsCisJCQkJICAgICAgICh1bnNpZ25lZCBsb25nICopJmRtYV9yeHNpemUpOworCQllbHNlIGlmICghc3RybmNtcChvcHQsICJidWZfc3o6IiwgNykpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyA3LCAwLCAodW5zaWduZWQgbG9uZyAqKSZidWZfc3opOworCQllbHNlIGlmICghc3RybmNtcChvcHQsICJ0YzoiLCAzKSkKKwkJCXN0cmljdF9zdHJ0b3VsKG9wdCArIDMsIDAsICh1bnNpZ25lZCBsb25nICopJnRjKTsKKwkJZWxzZSBpZiAoIXN0cm5jbXAob3B0LCAidHhfY29lOiIsIDcpKQorCQkJc3RyaWN0X3N0cnRvdWwob3B0ICsgNywgMCwgKHVuc2lnbmVkIGxvbmcgKikmdHhfY29lKTsKKwkJZWxzZSBpZiAoIXN0cm5jbXAob3B0LCAid2F0Y2hkb2c6IiwgOSkpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyA5LCAwLCAodW5zaWduZWQgbG9uZyAqKSZ3YXRjaGRvZyk7CisJCWVsc2UgaWYgKCFzdHJuY21wKG9wdCwgImZsb3dfY3RybDoiLCAxMCkpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyAxMCwgMCwKKwkJCQkgICAgICAgKHVuc2lnbmVkIGxvbmcgKikmZmxvd19jdHJsKTsKKwkJZWxzZSBpZiAoIXN0cm5jbXAob3B0LCAicGF1c2U6IiwgNikpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyA2LCAwLCAodW5zaWduZWQgbG9uZyAqKSZwYXVzZSk7CisjaWZkZWYgQ09ORklHX1NUTU1BQ19USU1FUgorCQllbHNlIGlmICghc3RybmNtcChvcHQsICJ0bXJhdGU6IiwgNykpCisJCQlzdHJpY3Rfc3RydG91bChvcHQgKyA3LCAwLCAodW5zaWduZWQgbG9uZyAqKSZ0bXJhdGUpOworI2VuZGlmCisJfQorCXJldHVybiAwOworfQorCitfX3NldHVwKCJzdG1tYWNldGg9Iiwgc3RtbWFjX2NtZGxpbmVfb3B0KTsKKyNlbmRpZgorCittb2R1bGVfaW5pdChzdG1tYWNfaW5pdF9tb2R1bGUpOworbW9kdWxlX2V4aXQoc3RtbWFjX2NsZWFudXBfbW9kdWxlKTsKKworTU9EVUxFX0RFU0NSSVBUSU9OKCJTVE1NQUMgMTAvMTAwLzEwMDAgRXRoZXJuZXQgZHJpdmVyIik7CitNT0RVTEVfQVVUSE9SKCJHaXVzZXBwZSBDYXZhbGxhcm8gPHBlcHBlLmNhdmFsbGFyb0BzdC5jb20+Iik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9zdG1tYWMvc3RtbWFjX21kaW8uYyBiL2RyaXZlcnMvbmV0L3N0bW1hYy9zdG1tYWNfbWRpby5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjg0OTg1NTIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9zdG1tYWMvc3RtbWFjX21kaW8uYwpAQCAtMCwwICsxLDIxNyBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAgU1RNTUFDIEV0aGVybmV0IERyaXZlciAtLSBNRElPIGJ1cyBpbXBsZW1lbnRhdGlvbgorICBQcm92aWRlcyBCdXMgaW50ZXJmYWNlIGZvciBNSUkgcmVnaXN0ZXJzCisKKyAgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIFNUTWljcm9lbGVjdHJvbmljcyBMdGQKKworICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlLAorICB2ZXJzaW9uIDIsIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgorCisgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKKyAgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCisgIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IKKyAgbW9yZSBkZXRhaWxzLgorCisgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFsb25nIHdpdGgKKyAgdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIEluYy4sCisgIDUxIEZyYW5rbGluIFN0IC0gRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisKKyAgVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAgdGhlIGZpbGUgY2FsbGVkICJDT1BZSU5HIi4KKworICBBdXRob3I6IENhcmwgU2hhdyA8Y2FybC5zaGF3QHN0LmNvbT4KKyAgTWFpbnRhaW5lcjogR2l1c2VwcGUgQ2F2YWxsYXJvIDxwZXBwZS5jYXZhbGxhcm9Ac3QuY29tPgorKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L21paS5oPgorI2luY2x1ZGUgPGxpbnV4L3BoeS5oPgorCisjaW5jbHVkZSAic3RtbWFjLmgiCisKKyNkZWZpbmUgTUlJX0JVU1kgMHgwMDAwMDAwMQorI2RlZmluZSBNSUlfV1JJVEUgMHgwMDAwMDAwMgorCisvKioKKyAqIHN0bW1hY19tZGlvX3JlYWQKKyAqIEBidXM6IHBvaW50cyB0byB0aGUgbWlpX2J1cyBzdHJ1Y3R1cmUKKyAqIEBwaHlhZGRyOiBNSUkgYWRkciByZWcgYml0cyAxNS0xMQorICogQHBoeXJlZzogTUlJIGFkZHIgcmVnIGJpdHMgMTAtNgorICogRGVzY3JpcHRpb246IGl0IHJlYWRzIGRhdGEgZnJvbSB0aGUgTUlJIHJlZ2lzdGVyIGZyb20gd2l0aGluIHRoZSBwaHkgZGV2aWNlLgorICogRm9yIHRoZSA3MTExIEdNQUMsIHdlIG11c3Qgc2V0IHRoZSBiaXQgMCBpbiB0aGUgTUlJIGFkZHJlc3MgcmVnaXN0ZXIgd2hpbGUKKyAqIGFjY2Vzc2luZyB0aGUgUEhZIHJlZ2lzdGVycy4KKyAqIEZvcnR1bmF0ZWx5LCBpdCBzZWVtcyB0aGlzIGhhcyBubyBkcmF3YmFjayBmb3IgdGhlIDcxMDkgTUFDLgorICovCitzdGF0aWMgaW50IHN0bW1hY19tZGlvX3JlYWQoc3RydWN0IG1paV9idXMgKmJ1cywgaW50IHBoeWFkZHIsIGludCBwaHlyZWcpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5kZXYgPSBidXMtPnByaXY7CisJc3RydWN0IHN0bW1hY19wcml2ICpwcml2ID0gbmV0ZGV2X3ByaXYobmRldik7CisJdW5zaWduZWQgbG9uZyBpb2FkZHIgPSBuZGV2LT5iYXNlX2FkZHI7CisJdW5zaWduZWQgaW50IG1paV9hZGRyZXNzID0gcHJpdi0+bWFjX3R5cGUtPmh3Lm1paS5hZGRyOworCXVuc2lnbmVkIGludCBtaWlfZGF0YSA9IHByaXYtPm1hY190eXBlLT5ody5taWkuZGF0YTsKKworCWludCBkYXRhOworCXUxNiByZWdWYWx1ZSA9ICgoKHBoeWFkZHIgPDwgMTEpICYgKDB4MDAwMEY4MDApKSB8CisJCQkoKHBoeXJlZyA8PCA2KSAmICgweDAwMDAwN0MwKSkpOworCXJlZ1ZhbHVlIHw9IE1JSV9CVVNZOwkvKiBpbiBjYXNlIG9mIEdNQUMgKi8KKworCWRvIHt9IHdoaWxlICgoKHJlYWRsKGlvYWRkciArIG1paV9hZGRyZXNzKSkgJiBNSUlfQlVTWSkgPT0gMSk7CisJd3JpdGVsKHJlZ1ZhbHVlLCBpb2FkZHIgKyBtaWlfYWRkcmVzcyk7CisJZG8ge30gd2hpbGUgKCgocmVhZGwoaW9hZGRyICsgbWlpX2FkZHJlc3MpKSAmIE1JSV9CVVNZKSA9PSAxKTsKKworCS8qIFJlYWQgdGhlIGRhdGEgZnJvbSB0aGUgTUlJIGRhdGEgcmVnaXN0ZXIgKi8KKwlkYXRhID0gKGludClyZWFkbChpb2FkZHIgKyBtaWlfZGF0YSk7CisKKwlyZXR1cm4gZGF0YTsKK30KKworLyoqCisgKiBzdG1tYWNfbWRpb193cml0ZQorICogQGJ1czogcG9pbnRzIHRvIHRoZSBtaWlfYnVzIHN0cnVjdHVyZQorICogQHBoeWFkZHI6IE1JSSBhZGRyIHJlZyBiaXRzIDE1LTExCisgKiBAcGh5cmVnOiBNSUkgYWRkciByZWcgYml0cyAxMC02CisgKiBAcGh5ZGF0YTogcGh5IGRhdGEKKyAqIERlc2NyaXB0aW9uOiBpdCB3cml0ZXMgdGhlIGRhdGEgaW50byB0aGUgTUlJIHJlZ2lzdGVyIGZyb20gd2l0aGluIHRoZSBkZXZpY2UuCisgKi8KK3N0YXRpYyBpbnQgc3RtbWFjX21kaW9fd3JpdGUoc3RydWN0IG1paV9idXMgKmJ1cywgaW50IHBoeWFkZHIsIGludCBwaHlyZWcsCisJCQkgICAgIHUxNiBwaHlkYXRhKQoreworCXN0cnVjdCBuZXRfZGV2aWNlICpuZGV2ID0gYnVzLT5wcml2OworCXN0cnVjdCBzdG1tYWNfcHJpdiAqcHJpdiA9IG5ldGRldl9wcml2KG5kZXYpOworCXVuc2lnbmVkIGxvbmcgaW9hZGRyID0gbmRldi0+YmFzZV9hZGRyOworCXVuc2lnbmVkIGludCBtaWlfYWRkcmVzcyA9IHByaXYtPm1hY190eXBlLT5ody5taWkuYWRkcjsKKwl1bnNpZ25lZCBpbnQgbWlpX2RhdGEgPSBwcml2LT5tYWNfdHlwZS0+aHcubWlpLmRhdGE7CisKKwl1MTYgdmFsdWUgPQorCSAgICAoKChwaHlhZGRyIDw8IDExKSAmICgweDAwMDBGODAwKSkgfCAoKHBoeXJlZyA8PCA2KSAmICgweDAwMDAwN0MwKSkpCisJICAgIHwgTUlJX1dSSVRFOworCisJdmFsdWUgfD0gTUlJX0JVU1k7CisKKwkvKiBXYWl0IHVudGlsIGFueSBleGlzdGluZyBNSUkgb3BlcmF0aW9uIGlzIGNvbXBsZXRlICovCisJZG8ge30gd2hpbGUgKCgocmVhZGwoaW9hZGRyICsgbWlpX2FkZHJlc3MpKSAmIE1JSV9CVVNZKSA9PSAxKTsKKworCS8qIFNldCB0aGUgTUlJIGFkZHJlc3MgcmVnaXN0ZXIgdG8gd3JpdGUgKi8KKwl3cml0ZWwocGh5ZGF0YSwgaW9hZGRyICsgbWlpX2RhdGEpOworCXdyaXRlbCh2YWx1ZSwgaW9hZGRyICsgbWlpX2FkZHJlc3MpOworCisJLyogV2FpdCB1bnRpbCBhbnkgZXhpc3RpbmcgTUlJIG9wZXJhdGlvbiBpcyBjb21wbGV0ZSAqLworCWRvIHt9IHdoaWxlICgoKHJlYWRsKGlvYWRkciArIG1paV9hZGRyZXNzKSkgJiBNSUlfQlVTWSkgPT0gMSk7CisKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiBzdG1tYWNfbWRpb19yZXNldAorICogQGJ1czogcG9pbnRzIHRvIHRoZSBtaWlfYnVzIHN0cnVjdHVyZQorICogRGVzY3JpcHRpb246IHJlc2V0IHRoZSBNSUkgYnVzCisgKi8KK3N0YXRpYyBpbnQgc3RtbWFjX21kaW9fcmVzZXQoc3RydWN0IG1paV9idXMgKmJ1cykKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZSAqbmRldiA9IGJ1cy0+cHJpdjsKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihuZGV2KTsKKwl1bnNpZ25lZCBsb25nIGlvYWRkciA9IG5kZXYtPmJhc2VfYWRkcjsKKwl1bnNpZ25lZCBpbnQgbWlpX2FkZHJlc3MgPSBwcml2LT5tYWNfdHlwZS0+aHcubWlpLmFkZHI7CisKKwlpZiAocHJpdi0+cGh5X3Jlc2V0KSB7CisJCXByX2RlYnVnKCJzdG1tYWNfbWRpb19yZXNldDogY2FsbGluZyBwaHlfcmVzZXRcbiIpOworCQlwcml2LT5waHlfcmVzZXQocHJpdi0+YnNwX3ByaXYpOworCX0KKworCS8qIFRoaXMgaXMgYSB3b3JrYXJvdW5kIGZvciBwcm9ibGVtcyB3aXRoIHRoZSBTVEUxMDFQIFBIWS4KKwkgKiBJdCBkb2Vzbid0IGNvbXBsZXRlIGl0cyByZXNldCB1bnRpbCBhdCBsZWFzdCBvbmUgY2xvY2sgY3ljbGUKKwkgKiBvbiBNREMsIHNvIHBlcmZvcm0gYSBkdW1teSBtZGlvIHJlYWQuCisJICovCisJd3JpdGVsKDAsIGlvYWRkciArIG1paV9hZGRyZXNzKTsKKworCXJldHVybiAwOworfQorCisvKioKKyAqIHN0bW1hY19tZGlvX3JlZ2lzdGVyCisgKiBAbmRldjogbmV0IGRldmljZSBzdHJ1Y3R1cmUKKyAqIERlc2NyaXB0aW9uOiBpdCByZWdpc3RlcnMgdGhlIE1JSSBidXMKKyAqLworaW50IHN0bW1hY19tZGlvX3JlZ2lzdGVyKHN0cnVjdCBuZXRfZGV2aWNlICpuZGV2KQoreworCWludCBlcnIgPSAwOworCXN0cnVjdCBtaWlfYnVzICpuZXdfYnVzOworCWludCAqaXJxbGlzdDsKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihuZGV2KTsKKwlpbnQgYWRkciwgZm91bmQ7CisKKwluZXdfYnVzID0gbWRpb2J1c19hbGxvYygpOworCWlmIChuZXdfYnVzID09IE5VTEwpCisJCXJldHVybiAtRU5PTUVNOworCisJaXJxbGlzdCA9IGt6YWxsb2Moc2l6ZW9mKGludCkgKiBQSFlfTUFYX0FERFIsIEdGUF9LRVJORUwpOworCWlmIChpcnFsaXN0ID09IE5VTEwpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBpcnFsaXN0X2FsbG9jX2ZhaWw7CisJfQorCisJLyogQXNzaWduIElSUSB0byBwaHkgYXQgYWRkcmVzcyBwaHlfYWRkciAqLworCWlmIChwcml2LT5waHlfYWRkciAhPSAtMSkKKwkJaXJxbGlzdFtwcml2LT5waHlfYWRkcl0gPSBwcml2LT5waHlfaXJxOworCisJbmV3X2J1cy0+bmFtZSA9ICJTVE1NQUMgTUlJIEJ1cyI7CisJbmV3X2J1cy0+cmVhZCA9ICZzdG1tYWNfbWRpb19yZWFkOworCW5ld19idXMtPndyaXRlID0gJnN0bW1hY19tZGlvX3dyaXRlOworCW5ld19idXMtPnJlc2V0ID0gJnN0bW1hY19tZGlvX3Jlc2V0OworCXNucHJpbnRmKG5ld19idXMtPmlkLCBNSUlfQlVTX0lEX1NJWkUsICIleCIsIHByaXYtPmJ1c19pZCk7CisJbmV3X2J1cy0+cHJpdiA9IG5kZXY7CisJbmV3X2J1cy0+aXJxID0gaXJxbGlzdDsKKwluZXdfYnVzLT5waHlfbWFzayA9IHByaXYtPnBoeV9tYXNrOworCW5ld19idXMtPnBhcmVudCA9IHByaXYtPmRldmljZTsKKwllcnIgPSBtZGlvYnVzX3JlZ2lzdGVyKG5ld19idXMpOworCWlmIChlcnIgIT0gMCkgeworCQlwcl9lcnIoIiVzOiBDYW5ub3QgcmVnaXN0ZXIgYXMgTURJTyBidXNcbiIsIG5ld19idXMtPm5hbWUpOworCQlnb3RvIGJ1c19yZWdpc3Rlcl9mYWlsOworCX0KKworCXByaXYtPm1paSA9IG5ld19idXM7CisKKwlmb3VuZCA9IDA7CisJZm9yIChhZGRyID0gMDsgYWRkciA8IDMyOyBhZGRyKyspIHsKKwkJc3RydWN0IHBoeV9kZXZpY2UgKnBoeWRldiA9IG5ld19idXMtPnBoeV9tYXBbYWRkcl07CisJCWlmIChwaHlkZXYpIHsKKwkJCWlmIChwcml2LT5waHlfYWRkciA9PSAtMSkgeworCQkJCXByaXYtPnBoeV9hZGRyID0gYWRkcjsKKwkJCQlwaHlkZXYtPmlycSA9IHByaXYtPnBoeV9pcnE7CisJCQkJaXJxbGlzdFthZGRyXSA9IHByaXYtPnBoeV9pcnE7CisJCQl9CisJCQlwcl9pbmZvKCIlczogUEhZIElEICUwOHggYXQgJWQgSVJRICVkICglcyklc1xuIiwKKwkJCSAgICAgICBuZGV2LT5uYW1lLCBwaHlkZXYtPnBoeV9pZCwgYWRkciwKKwkJCSAgICAgICBwaHlkZXYtPmlycSwgZGV2X25hbWUoJnBoeWRldi0+ZGV2KSwKKwkJCSAgICAgICAoYWRkciA9PSBwcml2LT5waHlfYWRkcikgPyAiIGFjdGl2ZSIgOiAiIik7CisJCQlmb3VuZCA9IDE7CisJCX0KKwl9CisKKwlpZiAoIWZvdW5kKQorCQlwcl93YXJuaW5nKCIlczogTm8gUEhZIGZvdW5kXG4iLCBuZGV2LT5uYW1lKTsKKworCXJldHVybiAwOworYnVzX3JlZ2lzdGVyX2ZhaWw6CisJa2ZyZWUoaXJxbGlzdCk7CitpcnFsaXN0X2FsbG9jX2ZhaWw6CisJa2ZyZWUobmV3X2J1cyk7CisJcmV0dXJuIGVycjsKK30KKworLyoqCisgKiBzdG1tYWNfbWRpb191bnJlZ2lzdGVyCisgKiBAbmRldjogbmV0IGRldmljZSBzdHJ1Y3R1cmUKKyAqIERlc2NyaXB0aW9uOiBpdCB1bnJlZ2lzdGVycyB0aGUgTUlJIGJ1cworICovCitpbnQgc3RtbWFjX21kaW9fdW5yZWdpc3RlcihzdHJ1Y3QgbmV0X2RldmljZSAqbmRldikKK3sKKwlzdHJ1Y3Qgc3RtbWFjX3ByaXYgKnByaXYgPSBuZXRkZXZfcHJpdihuZGV2KTsKKworCW1kaW9idXNfdW5yZWdpc3Rlcihwcml2LT5taWkpOworCXByaXYtPm1paS0+cHJpdiA9IE5VTEw7CisJa2ZyZWUocHJpdi0+bWlpKTsKKworCXJldHVybiAwOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hY190aW1lci5jIGIvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hY190aW1lci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI4MzhjNjUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9zdG1tYWMvc3RtbWFjX3RpbWVyLmMKQEAgLTAsMCArMSwxNDAgQEAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgIFNUTU1BQyBleHRlcm5hbCB0aW1lciBzdXBwb3J0LgorCisgIENvcHlyaWdodCAoQykgMjAwNy0yMDA5ICBTVE1pY3JvZWxlY3Ryb25pY3MgTHRkCisKKyAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKworICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCisgIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvcgorICBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yCisgIG1vcmUgZGV0YWlscy4KKworICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZyB3aXRoCisgIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAorICA1MSBGcmFua2xpbiBTdCAtIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBLgorCisgIFRoZSBmdWxsIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluCisgIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisKKyAgQXV0aG9yOiBHaXVzZXBwZSBDYXZhbGxhcm8gPHBlcHBlLmNhdmFsbGFyb0BzdC5jb20+CisqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KKyNpbmNsdWRlICJzdG1tYWNfdGltZXIuaCIKKworc3RhdGljIHZvaWQgc3RtbWFjX3RpbWVyX2hhbmRsZXIodm9pZCAqZGF0YSkKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gKHN0cnVjdCBuZXRfZGV2aWNlICopZGF0YTsKKworCXN0bW1hY19zY2hlZHVsZShkZXYpOworCisJcmV0dXJuOworfQorCisjZGVmaW5lIFNUTU1BQ19USU1FUl9NU0codGltZXIsIGZyZXEpIFwKK3ByaW50ayhLRVJOX0lORk8gInN0bW1hY190aW1lcjogJXMgVGltZXIgT04gKGZyZXEgJWRIeilcbiIsIHRpbWVyLCBmcmVxKTsKKworI2lmIGRlZmluZWQoQ09ORklHX1NUTU1BQ19SVENfVElNRVIpCisjaW5jbHVkZSA8bGludXgvcnRjLmg+CitzdGF0aWMgc3RydWN0IHJ0Y19kZXZpY2UgKnN0bW1hY19ydGM7CitzdGF0aWMgcnRjX3Rhc2tfdCBzdG1tYWNfdGFzazsKKworc3RhdGljIHZvaWQgc3RtbWFjX3J0Y19zdGFydCh1bnNpZ25lZCBpbnQgbmV3X2ZyZXEpCit7CisJcnRjX2lycV9zZXRfZnJlcShzdG1tYWNfcnRjLCAmc3RtbWFjX3Rhc2ssIG5ld19mcmVxKTsKKwlydGNfaXJxX3NldF9zdGF0ZShzdG1tYWNfcnRjLCAmc3RtbWFjX3Rhc2ssIDEpOworCXJldHVybjsKK30KKworc3RhdGljIHZvaWQgc3RtbWFjX3J0Y19zdG9wKHZvaWQpCit7CisJcnRjX2lycV9zZXRfc3RhdGUoc3RtbWFjX3J0YywgJnN0bW1hY190YXNrLCAwKTsKKwlyZXR1cm47Cit9CisKK2ludCBzdG1tYWNfb3Blbl9leHRfdGltZXIoc3RydWN0IG5ldF9kZXZpY2UgKmRldiwgc3RydWN0IHN0bW1hY190aW1lciAqdG0pCit7CisJc3RtbWFjX3Rhc2sucHJpdmF0ZV9kYXRhID0gZGV2OworCXN0bW1hY190YXNrLmZ1bmMgPSBzdG1tYWNfdGltZXJfaGFuZGxlcjsKKworCXN0bW1hY19ydGMgPSBydGNfY2xhc3Nfb3BlbihDT05GSUdfUlRDX0hDVE9TWVNfREVWSUNFKTsKKwlpZiAoc3RtbWFjX3J0YyA9PSBOVUxMKSB7CisJCXByX2Vycm9yKCJvcGVuIHJ0YyBkZXZpY2UgZmFpbGVkXG4iKTsKKwkJcmV0dXJuIC1FTk9ERVY7CisJfQorCisJcnRjX2lycV9yZWdpc3RlcihzdG1tYWNfcnRjLCAmc3RtbWFjX3Rhc2spOworCisJLyogUGVyaW9kaWMgbW9kZSBpcyBub3Qgc3VwcG9ydGVkICovCisJaWYgKChydGNfaXJxX3NldF9mcmVxKHN0bW1hY19ydGMsICZzdG1tYWNfdGFzaywgdG0tPmZyZXEpIDwgMCkpIHsKKwkJcHJfZXJyb3IoInNldCBwZXJpb2RpYyBmYWlsZWRcbiIpOworCQlydGNfaXJxX3VucmVnaXN0ZXIoc3RtbWFjX3J0YywgJnN0bW1hY190YXNrKTsKKwkJcnRjX2NsYXNzX2Nsb3NlKHN0bW1hY19ydGMpOworCQlyZXR1cm4gLTE7CisJfQorCisJU1RNTUFDX1RJTUVSX01TRyhDT05GSUdfUlRDX0hDVE9TWVNfREVWSUNFLCB0bS0+ZnJlcSk7CisKKwl0bS0+dGltZXJfc3RhcnQgPSBzdG1tYWNfcnRjX3N0YXJ0OworCXRtLT50aW1lcl9zdG9wID0gc3RtbWFjX3J0Y19zdG9wOworCisJcmV0dXJuIDA7Cit9CisKK2ludCBzdG1tYWNfY2xvc2VfZXh0X3RpbWVyKHZvaWQpCit7CisJcnRjX2lycV9zZXRfc3RhdGUoc3RtbWFjX3J0YywgJnN0bW1hY190YXNrLCAwKTsKKwlydGNfaXJxX3VucmVnaXN0ZXIoc3RtbWFjX3J0YywgJnN0bW1hY190YXNrKTsKKwlydGNfY2xhc3NfY2xvc2Uoc3RtbWFjX3J0Yyk7CisJcmV0dXJuIDA7Cit9CisKKyNlbGlmIGRlZmluZWQoQ09ORklHX1NUTU1BQ19UTVVfVElNRVIpCisjaW5jbHVkZSA8bGludXgvY2xrLmg+CisjZGVmaW5lIFRNVV9DSEFOTkVMICJ0bXUyX2NsayIKK3N0YXRpYyBzdHJ1Y3QgY2xrICp0aW1lcl9jbG9jazsKKworc3RhdGljIHZvaWQgc3RtbWFjX3RtdV9zdGFydCh1bnNpZ25lZCBpbnQgbmV3X2ZyZXEpCit7CisJY2xrX3NldF9yYXRlKHRpbWVyX2Nsb2NrLCBuZXdfZnJlcSk7CisJY2xrX2VuYWJsZSh0aW1lcl9jbG9jayk7CisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZCBzdG1tYWNfdG11X3N0b3Aodm9pZCkKK3sKKwljbGtfZGlzYWJsZSh0aW1lcl9jbG9jayk7CisJcmV0dXJuOworfQorCitpbnQgc3RtbWFjX29wZW5fZXh0X3RpbWVyKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYsIHN0cnVjdCBzdG1tYWNfdGltZXIgKnRtKQoreworCXRpbWVyX2Nsb2NrID0gY2xrX2dldChOVUxMLCBUTVVfQ0hBTk5FTCk7CisKKwlpZiAodGltZXJfY2xvY2sgPT0gTlVMTCkKKwkJcmV0dXJuIC0xOworCisJaWYgKHRtdTJfcmVnaXN0ZXJfdXNlcihzdG1tYWNfdGltZXJfaGFuZGxlciwgKHZvaWQgKilkZXYpIDwgMCkgeworCQl0aW1lcl9jbG9jayA9IE5VTEw7CisJCXJldHVybiAtMTsKKwl9CisKKwlTVE1NQUNfVElNRVJfTVNHKCJUTVUyIiwgdG0tPmZyZXEpOworCXRtLT50aW1lcl9zdGFydCA9IHN0bW1hY190bXVfc3RhcnQ7CisJdG0tPnRpbWVyX3N0b3AgPSBzdG1tYWNfdG11X3N0b3A7CisKKwlyZXR1cm4gMDsKK30KKworaW50IHN0bW1hY19jbG9zZV9leHRfdGltZXIodm9pZCkKK3sKKwljbGtfZGlzYWJsZSh0aW1lcl9jbG9jayk7CisJdG11Ml91bnJlZ2lzdGVyX3VzZXIoKTsKKwljbGtfcHV0KHRpbWVyX2Nsb2NrKTsKKwlyZXR1cm4gMDsKK30KKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hY190aW1lci5oIGIvZHJpdmVycy9uZXQvc3RtbWFjL3N0bW1hY190aW1lci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY3OTVjYWUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL25ldC9zdG1tYWMvc3RtbWFjX3RpbWVyLmgKQEAgLTAsMCArMSw0MSBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAgU1RNTUFDIGV4dGVybmFsIHRpbWVyIEhlYWRlciBGaWxlLgorCisgIENvcHlyaWdodCAoQykgMjAwNy0yMDA5ICBTVE1pY3JvZWxlY3Ryb25pY3MgTHRkCisKKyAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSwKKyAgdmVyc2lvbiAyLCBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KKworICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCisgIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvcgorICBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yCisgIG1vcmUgZGV0YWlscy4KKworICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZyB3aXRoCisgIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuLAorICA1MSBGcmFua2xpbiBTdCAtIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBLgorCisgIFRoZSBmdWxsIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluCisgIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisKKyAgQXV0aG9yOiBHaXVzZXBwZSBDYXZhbGxhcm8gPHBlcHBlLmNhdmFsbGFyb0BzdC5jb20+CisqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCitzdHJ1Y3Qgc3RtbWFjX3RpbWVyIHsKKwl2b2lkICgqdGltZXJfc3RhcnQpICh1bnNpZ25lZCBpbnQgbmV3X2ZyZXEpOworCXZvaWQgKCp0aW1lcl9zdG9wKSAodm9pZCk7CisJdW5zaWduZWQgaW50IGZyZXE7Cit9OworCisvKiBPcGVuIHRoZSBIVyB0aW1lciBkZXZpY2UgYW5kIHJldHVybiAwIGluIGNhc2Ugb2Ygc3VjY2VzcyAqLworaW50IHN0bW1hY19vcGVuX2V4dF90aW1lcihzdHJ1Y3QgbmV0X2RldmljZSAqZGV2LCBzdHJ1Y3Qgc3RtbWFjX3RpbWVyICp0bSk7CisvKiBTdG9wIHRoZSB0aW1lciBhbmQgcmVsZWFzZSBpdCAqLworaW50IHN0bW1hY19jbG9zZV9leHRfdGltZXIodm9pZCk7CisvKiBGdW5jdGlvbiB1c2VkIGZvciBzY2hlZHVsaW5nIHRhc2sgd2l0aGluIHRoZSBzdG1tYWMgKi8KK3ZvaWQgc3RtbWFjX3NjaGVkdWxlKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpOworCisjaWYgZGVmaW5lZChDT05GSUdfU1RNTUFDX1RNVV9USU1FUikKK2V4dGVybiBpbnQgdG11Ml9yZWdpc3Rlcl91c2VyKHZvaWQgKmZudCwgdm9pZCAqZGF0YSk7CitleHRlcm4gdm9pZCB0bXUyX3VucmVnaXN0ZXJfdXNlcih2b2lkKTsKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvc3VuZ2VtLmMgYi9kcml2ZXJzL25ldC9zdW5nZW0uYwppbmRleCAzMDVlYzNkLi43MDE5YTBkIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC9zdW5nZW0uYworKysgYi9kcml2ZXJzL25ldC9zdW5nZW0uYwpAQCAtMzgsNiArMzgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgogI2luY2x1ZGUgPGxpbnV4L2luLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3Rva2VucmluZy9pYm10ci5jIGIvZHJpdmVycy9uZXQvdG9rZW5yaW5nL2libXRyLmMKaW5kZXggNTI1YmJjNS4uMzZjYjI0MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdG9rZW5yaW5nL2libXRyLmMKKysrIGIvZHJpdmVycy9uZXQvdG9rZW5yaW5nL2libXRyLmMKQEAgLTEwOCw2ICsxMDgsNyBAQAogI2RlZmluZSBJQk1UUl9ERUJVR19NRVNTQUdFUyAwCiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogCiAjaWZkZWYgUENNQ0lBCQkvKiByZXF1aXJlZCBmb3IgaWJtdHJfY3MuYyB0byBidWlsZCAqLwogI3VuZGVmIE1PRFVMRQkJLyogeWVzLCByZWFsbHkgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3R5cGhvb24uYyBiL2RyaXZlcnMvbmV0L3R5cGhvb24uYwppbmRleCBkNmQzNDUyLi41OTIxZjViIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC90eXBob29uLmMKKysrIGIvZHJpdmVycy9uZXQvdHlwaG9vbi5jCkBAIC0xMDgsNiArMTA4LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdXNiL3BlZ2FzdXMuYyBiL2RyaXZlcnMvbmV0L3VzYi9wZWdhc3VzLmMKaW5kZXggNmZkYWJhOC4uZWQ0YTUwOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdXNiL3BlZ2FzdXMuYworKysgYi9kcml2ZXJzL25ldC91c2IvcGVnYXN1cy5jCkBAIC02Miw4ICs2MiwxMSBAQAogc3RhdGljIHN0cnVjdCB1c2JfZXRoX2RldiB1c2JfZGV2X2lkW10gPSB7CiAjZGVmaW5lCVBFR0FTVVNfREVWKHBuLCB2aWQsIHBpZCwgZmxhZ3MpCVwKIAl7Lm5hbWUgPSBwbiwgLnZlbmRvciA9IHZpZCwgLmRldmljZSA9IHBpZCwgLnByaXZhdGUgPSBmbGFnc30sCisjZGVmaW5lIFBFR0FTVVNfREVWX0NMQVNTKHBuLCB2aWQsIHBpZCwgZGNsYXNzLCBmbGFncykgXAorCVBFR0FTVVNfREVWKHBuLCB2aWQsIHBpZCwgZmxhZ3MpCiAjaW5jbHVkZSAicGVnYXN1cy5oIgogI3VuZGVmCVBFR0FTVVNfREVWCisjdW5kZWYJUEVHQVNVU19ERVZfQ0xBU1MKIAl7TlVMTCwgMCwgMCwgMH0sCiAJe05VTEwsIDAsIDAsIDB9CiB9OwpAQCAtNzEsOCArNzQsMTggQEAKIHN0YXRpYyBzdHJ1Y3QgdXNiX2RldmljZV9pZCBwZWdhc3VzX2lkc1tdID0gewogI2RlZmluZQlQRUdBU1VTX0RFVihwbiwgdmlkLCBwaWQsIGZsYWdzKSBcCiAJey5tYXRjaF9mbGFncyA9IFVTQl9ERVZJQ0VfSURfTUFUQ0hfREVWSUNFLCAuaWRWZW5kb3IgPSB2aWQsIC5pZFByb2R1Y3QgPSBwaWR9LAorLyoKKyAqIFRoZSBCZWxraW4gRjhUMDEyeHgxIGJsdWV0b290aCBhZGFwdG9yIGhhcyB0aGUgc2FtZSB2ZW5kb3IgYW5kIHByb2R1Y3QKKyAqIElEcyBhcyB0aGUgQmVsa2luIEY1RDUwNTAsIHNvIHdlIG5lZWQgdG8gdGVhY2ggdGhlIHBlZ2FzdXMgZHJpdmVyIHRvCisgKiBpZ25vcmUgYWRhcHRvcnMgYmVsb25naW5nIHRvIHRoZSAiV2lyZWxlc3MiIGNsYXNzIDB4RTAuIEZvciB0aGlzIG9uZQorICogY2FzZSBhbnl3YXksIHNlZWluZyBhcyB0aGUgcGVnYXN1cyBpcyBmb3IgIldpcmVkIiBhZGFwdG9ycy4KKyAqLworI2RlZmluZSBQRUdBU1VTX0RFVl9DTEFTUyhwbiwgdmlkLCBwaWQsIGRjbGFzcywgZmxhZ3MpIFwKKwl7Lm1hdGNoX2ZsYWdzID0gKFVTQl9ERVZJQ0VfSURfTUFUQ0hfREVWSUNFIHwgVVNCX0RFVklDRV9JRF9NQVRDSF9ERVZfQ0xBU1MpLCBcCisJLmlkVmVuZG9yID0gdmlkLCAuaWRQcm9kdWN0ID0gcGlkLCAuYkRldmljZUNsYXNzID0gZGNsYXNzfSwKICNpbmNsdWRlICJwZWdhc3VzLmgiCiAjdW5kZWYJUEVHQVNVU19ERVYKKyN1bmRlZglQRUdBU1VTX0RFVl9DTEFTUwogCXt9LAogCXt9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdXNiL3BlZ2FzdXMuaCBiL2RyaXZlcnMvbmV0L3VzYi9wZWdhc3VzLmgKaW5kZXggZjk2OGM4My4uNWQwMmYwMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdXNiL3BlZ2FzdXMuaAorKysgYi9kcml2ZXJzL25ldC91c2IvcGVnYXN1cy5oCkBAIC0yMDIsNyArMjAyLDExIEBACiAJCURFRkFVTFRfR1BJT19SRVNFVCB8IFBFR0FTVVNfSUkgKQogUEVHQVNVU19ERVYoICJBbGxpZWQgVGVsZXN5biBJbnQuIEFULVVTQjEwMCIsIFZFTkRPUl9BTExJRURURUwsIDB4YjEwMCwKIAkJREVGQVVMVF9HUElPX1JFU0VUIHwgUEVHQVNVU19JSSApCi1QRUdBU1VTX0RFViggIkJlbGtpbiBGNUQ1MDUwIFVTQiBFdGhlcm5ldCIsIFZFTkRPUl9CRUxLSU4sIDB4MDEyMSwKKy8qCisgKiBEaXN0aW5ndWlzaCBiZXR3ZWVuIHRoaXMgQmVsa2luIGFkYXB0b3IgYW5kIHRoZSBCZWxraW4gYmx1ZXRvb3RoIGFkYXB0b3JzCisgKiB3aXRoIHRoZSBzYW1lIHByb2R1Y3QgSURzIGJ5IGNoZWNraW5nIHRoZSBkZXZpY2UgY2xhc3MgdG9vLgorICovCitQRUdBU1VTX0RFVl9DTEFTUyggIkJlbGtpbiBGNUQ1MDUwIFVTQiBFdGhlcm5ldCIsIFZFTkRPUl9CRUxLSU4sIDB4MDEyMSwgMHgwMCwKIAkJREVGQVVMVF9HUElPX1JFU0VUIHwgUEVHQVNVU19JSSApCiBQRUdBU1VTX0RFViggIkJpbGxpb250b24gVVNCLTEwMCIsIFZFTkRPUl9CSUxMSU9OVE9OLCAweDA5ODYsCiAJCURFRkFVTFRfR1BJT19SRVNFVCApCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC92aXJ0aW9fbmV0LmMgYi9kcml2ZXJzL25ldC92aXJ0aW9fbmV0LmMKaW5kZXggOGQwMDk3Ni4uMzcwOWQ2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvdmlydGlvX25ldC5jCisrKyBiL2RyaXZlcnMvbmV0L3ZpcnRpb19uZXQuYwpAQCAtMjIsNyArMjIsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2V0aHRvb2wuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC92aXJ0aW8uaD4KLSNpbmNsdWRlIDxsaW51eC92aXJ0aW9faWRzLmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX25ldC5oPgogI2luY2x1ZGUgPGxpbnV4L3NjYXR0ZXJsaXN0Lmg+CiAjaW5jbHVkZSA8bGludXgvaWZfdmxhbi5oPgpAQCAtNDU0LDcgKzQ1Myw3IEBACiAJCXZpLT5kZXYtPnN0YXRzLnR4X2J5dGVzICs9IHNrYi0+bGVuOwogCQl2aS0+ZGV2LT5zdGF0cy50eF9wYWNrZXRzKys7CiAJCXRvdF9zZ3MgKz0gc2tiX3ZuZXRfaGRyKHNrYiktPm51bV9zZzsKLQkJa2ZyZWVfc2tiKHNrYik7CisJCWRldl9rZnJlZV9za2JfYW55KHNrYik7CiAJfQogCXJldHVybiB0b3Rfc2dzOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdm14bmV0My9NYWtlZmlsZSBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODgwZjUwOQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvTWFrZWZpbGUKQEAgLTAsMCArMSwzNSBAQAorIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKyMKKyMgTGludXggZHJpdmVyIGZvciBWTXdhcmUncyB2bXhuZXQzIGV0aGVybmV0IE5JQy4KKyMKKyMgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDksIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorIworIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorIyB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyMgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UgYW5kIG5vIGxhdGVyIHZlcnNpb24uCisjCisjIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyMgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorIyBNRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UsIEdPT0QgVElUTEUgb3IKKyMgTk9OIElORlJJTkdFTUVOVC4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUKKyMgZGV0YWlscy4KKyMKKyMgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyMgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKKyMgRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEgVVNBLgorIworIyBUaGUgZnVsbCBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBpcyBpbmNsdWRlZCBpbiB0aGlzIGRpc3RyaWJ1dGlvbiBpbgorIyB0aGUgZmlsZSBjYWxsZWQgIkNPUFlJTkciLgorIworIyBNYWludGFpbmVkIGJ5OiBTaHJleWFzIEJoYXRld2FyYSA8cHYtZHJpdmVyc0B2bXdhcmUuY29tPgorIworIworIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKworIworIyBNYWtlZmlsZSBmb3IgdGhlIFZNd2FyZSB2bXhuZXQzIGV0aGVybmV0IE5JQyBkcml2ZXIKKyMKKworb2JqLSQoQ09ORklHX1ZNWE5FVDMpICs9IHZteG5ldDMubworCit2bXhuZXQzLW9ianMgOj0gdm14bmV0M19kcnYubyB2bXhuZXQzX2V0aHRvb2wubwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvdm14bmV0My91cHQxX2RlZnMuaCBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvdXB0MV9kZWZzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzcxMDhmYgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvdXB0MV9kZWZzLmgKQEAgLTAsMCArMSw5NiBAQAorLyoKKyAqIExpbnV4IGRyaXZlciBmb3IgVk13YXJlJ3Mgdm14bmV0MyBldGhlcm5ldCBOSUMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA4LTIwMDksIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlIGFuZCBubyBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSwgR09PRCBUSVRMRSBvcgorICogTk9OIElORlJJTkdFTUVOVC4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUKKyAqIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisgKgorICogVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAqIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisgKgorICogTWFpbnRhaW5lZCBieTogU2hyZXlhcyBCaGF0ZXdhcmEgPHB2LWRyaXZlcnNAdm13YXJlLmNvbT4KKyAqCisgKi8KKworI2lmbmRlZiBfVVBUMV9ERUZTX0gKKyNkZWZpbmUgX1VQVDFfREVGU19ICisKK3N0cnVjdCBVUFQxX1R4U3RhdHMgeworCXU2NAkJCVRTT1BrdHNUeE9LOyAgLyogVFNPIHBrdHMgcG9zdC1zZWdtZW50YXRpb24gKi8KKwl1NjQJCQlUU09CeXRlc1R4T0s7CisJdTY0CQkJdWNhc3RQa3RzVHhPSzsKKwl1NjQJCQl1Y2FzdEJ5dGVzVHhPSzsKKwl1NjQJCQltY2FzdFBrdHNUeE9LOworCXU2NAkJCW1jYXN0Qnl0ZXNUeE9LOworCXU2NAkJCWJjYXN0UGt0c1R4T0s7CisJdTY0CQkJYmNhc3RCeXRlc1R4T0s7CisJdTY0CQkJcGt0c1R4RXJyb3I7CisJdTY0CQkJcGt0c1R4RGlzY2FyZDsKK307CisKK3N0cnVjdCBVUFQxX1J4U3RhdHMgeworCXU2NAkJCUxST1BrdHNSeE9LOyAgICAvKiBMUk8gcGt0cyAqLworCXU2NAkJCUxST0J5dGVzUnhPSzsgICAvKiBieXRlcyBmcm9tIExSTyBwa3RzICovCisJLyogdGhlIGZvbGxvd2luZyBjb3VudGVycyBhcmUgZm9yIHBrdHMgZnJvbSB0aGUgd2lyZSwgaS5lLiwgcHJlLUxSTyAqLworCXU2NAkJCXVjYXN0UGt0c1J4T0s7CisJdTY0CQkJdWNhc3RCeXRlc1J4T0s7CisJdTY0CQkJbWNhc3RQa3RzUnhPSzsKKwl1NjQJCQltY2FzdEJ5dGVzUnhPSzsKKwl1NjQJCQliY2FzdFBrdHNSeE9LOworCXU2NAkJCWJjYXN0Qnl0ZXNSeE9LOworCXU2NAkJCXBrdHNSeE91dE9mQnVmOworCXU2NAkJCXBrdHNSeEVycm9yOworfTsKKworLyogaW50ZXJydXB0IG1vZGVyYXRpb24gbGV2ZWwgKi8KK2VudW0geworCVVQVDFfSU1MX05PTkUJCT0gMCwgLyogbm8gaW50ZXJydXB0IG1vZGVyYXRpb24gKi8KKwlVUFQxX0lNTF9ISUdIRVNUCT0gNywgLyogbGVhc3QgaW50ciBnZW5lcmF0ZWQgKi8KKwlVUFQxX0lNTF9BREFQVElWRQk9IDgsIC8qIGFkcGF0aXZlIGludHIgbW9kZXJhdGlvbiAqLworfTsKKy8qIHZhbHVlcyBmb3IgVVBUMV9SU1NDb25mLmhhc2hGdW5jICovCitlbnVtIHsKKwlVUFQxX1JTU19IQVNIX1RZUEVfTk9ORSAgICAgID0gMHgwLAorCVVQVDFfUlNTX0hBU0hfVFlQRV9JUFY0ICAgICAgPSAweDAxLAorCVVQVDFfUlNTX0hBU0hfVFlQRV9UQ1BfSVBWNCAgPSAweDAyLAorCVVQVDFfUlNTX0hBU0hfVFlQRV9JUFY2ICAgICAgPSAweDA0LAorCVVQVDFfUlNTX0hBU0hfVFlQRV9UQ1BfSVBWNiAgPSAweDA4LAorfTsKKworZW51bSB7CisJVVBUMV9SU1NfSEFTSF9GVU5DX05PTkUgICAgICA9IDB4MCwKKwlVUFQxX1JTU19IQVNIX0ZVTkNfVE9FUExJVFogID0gMHgwMSwKK307CisKKyNkZWZpbmUgVVBUMV9SU1NfTUFYX0tFWV9TSVpFICAgICAgICA0MAorI2RlZmluZSBVUFQxX1JTU19NQVhfSU5EX1RBQkxFX1NJWkUgIDEyOAorCitzdHJ1Y3QgVVBUMV9SU1NDb25mIHsKKwl1MTYJCQloYXNoVHlwZTsKKwl1MTYJCQloYXNoRnVuYzsKKwl1MTYJCQloYXNoS2V5U2l6ZTsKKwl1MTYJCQlpbmRUYWJsZVNpemU7CisJdTgJCQloYXNoS2V5W1VQVDFfUlNTX01BWF9LRVlfU0laRV07CisJdTgJCQlpbmRUYWJsZVtVUFQxX1JTU19NQVhfSU5EX1RBQkxFX1NJWkVdOworfTsKKworLyogZmVhdHVyZXMgKi8KK2VudW0geworCVVQVDFfRl9SWENTVU0JCT0gMHgwMDAxLCAgIC8qIHJ4IGNzdW0gdmVyaWZpY2F0aW9uICovCisJVVBUMV9GX1JTUwkJPSAweDAwMDIsCisJVVBUMV9GX1JYVkxBTgkJPSAweDAwMDQsICAgLyogVkxBTiB0YWcgc3RyaXBwaW5nICovCisJVVBUMV9GX0xSTwkJPSAweDAwMDgsCit9OworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfZGVmcy5oIGIvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2RlZnMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kYzhlZTQ0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2RlZnMuaApAQCAtMCwwICsxLDUzNSBAQAorLyoKKyAqIExpbnV4IGRyaXZlciBmb3IgVk13YXJlJ3Mgdm14bmV0MyBldGhlcm5ldCBOSUMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA4LTIwMDksIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlIGFuZCBubyBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSwgR09PRCBUSVRMRSBvcgorICogTk9OIElORlJJTkdFTUVOVC4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUKKyAqIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisgKgorICogVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAqIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisgKgorICogTWFpbnRhaW5lZCBieTogU2hyZXlhcyBCaGF0ZXdhcmEgPHB2LWRyaXZlcnNAdm13YXJlLmNvbT4KKyAqCisgKi8KKworI2lmbmRlZiBfVk1YTkVUM19ERUZTX0hfCisjZGVmaW5lIF9WTVhORVQzX0RFRlNfSF8KKworI2luY2x1ZGUgInVwdDFfZGVmcy5oIgorCisvKiBhbGwgcmVnaXN0ZXJzIGFyZSAzMiBiaXQgd2lkZSAqLworLyogQkFSIDEgKi8KK2VudW0geworCVZNWE5FVDNfUkVHX1ZSUlMJPSAweDAsCS8qIFZteG5ldDMgUmV2aXNpb24gUmVwb3J0IFNlbGVjdGlvbiAqLworCVZNWE5FVDNfUkVHX1VWUlMJPSAweDgsCS8qIFVQVCBWZXJzaW9uIFJlcG9ydCBTZWxlY3Rpb24gKi8KKwlWTVhORVQzX1JFR19EU0FMCT0gMHgxMCwJLyogRHJpdmVyIFNoYXJlZCBBZGRyZXNzIExvdyAqLworCVZNWE5FVDNfUkVHX0RTQUgJPSAweDE4LAkvKiBEcml2ZXIgU2hhcmVkIEFkZHJlc3MgSGlnaCAqLworCVZNWE5FVDNfUkVHX0NNRAkJPSAweDIwLAkvKiBDb21tYW5kICovCisJVk1YTkVUM19SRUdfTUFDTAk9IDB4MjgsCS8qIE1BQyBBZGRyZXNzIExvdyAqLworCVZNWE5FVDNfUkVHX01BQ0gJPSAweDMwLAkvKiBNQUMgQWRkcmVzcyBIaWdoICovCisJVk1YTkVUM19SRUdfSUNSCQk9IDB4MzgsCS8qIEludGVycnVwdCBDYXVzZSBSZWdpc3RlciAqLworCVZNWE5FVDNfUkVHX0VDUgkJPSAweDQwCS8qIEV2ZW50IENhdXNlIFJlZ2lzdGVyICovCit9OworCisvKiBCQVIgMCAqLworZW51bSB7CisJVk1YTkVUM19SRUdfSU1SCQk9IDB4MCwJIC8qIEludGVycnVwdCBNYXNrIFJlZ2lzdGVyICovCisJVk1YTkVUM19SRUdfVFhQUk9ECT0gMHg2MDAsIC8qIFR4IFByb2R1Y2VyIEluZGV4ICovCisJVk1YTkVUM19SRUdfUlhQUk9ECT0gMHg4MDAsIC8qIFJ4IFByb2R1Y2VyIEluZGV4IGZvciByaW5nIDEgKi8KKwlWTVhORVQzX1JFR19SWFBST0QyCT0gMHhBMDAJIC8qIFJ4IFByb2R1Y2VyIEluZGV4IGZvciByaW5nIDIgKi8KK307CisKKyNkZWZpbmUgVk1YTkVUM19QVF9SRUdfU0laRSAgICAgNDA5NgkvKiBCQVIgMCAqLworI2RlZmluZSBWTVhORVQzX1ZEX1JFR19TSVpFICAgICA0MDk2CS8qIEJBUiAxICovCisKKyNkZWZpbmUgVk1YTkVUM19SRUdfQUxJR04gICAgICAgOAkvKiBBbGwgcmVnaXN0ZXJzIGFyZSA4LWJ5dGUgYWxpZ25lZC4gKi8KKyNkZWZpbmUgVk1YTkVUM19SRUdfQUxJR05fTUFTSyAgMHg3CisKKy8qIEkvTyBNYXBwZWQgYWNjZXNzIHRvIHJlZ2lzdGVycyAqLworI2RlZmluZSBWTVhORVQzX0lPX1RZUEVfUFQgICAgICAgICAgICAgIDAKKyNkZWZpbmUgVk1YTkVUM19JT19UWVBFX1ZEICAgICAgICAgICAgICAxCisjZGVmaW5lIFZNWE5FVDNfSU9fQUREUih0eXBlLCByZWcpICAgICAgKCgodHlwZSkgPDwgMjQpIHwgKChyZWcpICYgMHhGRkZGRkYpKQorI2RlZmluZSBWTVhORVQzX0lPX1RZUEUoYWRkcikgICAgICAgICAgICgoYWRkcikgPj4gMjQpCisjZGVmaW5lIFZNWE5FVDNfSU9fUkVHKGFkZHIpICAgICAgICAgICAgKChhZGRyKSAmIDB4RkZGRkZGKQorCitlbnVtIHsKKwlWTVhORVQzX0NNRF9GSVJTVF9TRVQgPSAweENBRkUwMDAwLAorCVZNWE5FVDNfQ01EX0FDVElWQVRFX0RFViA9IFZNWE5FVDNfQ01EX0ZJUlNUX1NFVCwKKwlWTVhORVQzX0NNRF9RVUlFU0NFX0RFViwKKwlWTVhORVQzX0NNRF9SRVNFVF9ERVYsCisJVk1YTkVUM19DTURfVVBEQVRFX1JYX01PREUsCisJVk1YTkVUM19DTURfVVBEQVRFX01BQ19GSUxURVJTLAorCVZNWE5FVDNfQ01EX1VQREFURV9WTEFOX0ZJTFRFUlMsCisJVk1YTkVUM19DTURfVVBEQVRFX1JTU0lEVCwKKwlWTVhORVQzX0NNRF9VUERBVEVfSU1MLAorCVZNWE5FVDNfQ01EX1VQREFURV9QTUNGRywKKwlWTVhORVQzX0NNRF9VUERBVEVfRkVBVFVSRSwKKwlWTVhORVQzX0NNRF9MT0FEX1BMVUdJTiwKKworCVZNWE5FVDNfQ01EX0ZJUlNUX0dFVCA9IDB4RjAwRDAwMDAsCisJVk1YTkVUM19DTURfR0VUX1FVRVVFX1NUQVRVUyA9IFZNWE5FVDNfQ01EX0ZJUlNUX0dFVCwKKwlWTVhORVQzX0NNRF9HRVRfU1RBVFMsCisJVk1YTkVUM19DTURfR0VUX0xJTkssCisJVk1YTkVUM19DTURfR0VUX1BFUk1fTUFDX0xPLAorCVZNWE5FVDNfQ01EX0dFVF9QRVJNX01BQ19ISSwKKwlWTVhORVQzX0NNRF9HRVRfRElEX0xPLAorCVZNWE5FVDNfQ01EX0dFVF9ESURfSEksCisJVk1YTkVUM19DTURfR0VUX0RFVl9FWFRSQV9JTkZPLAorCVZNWE5FVDNfQ01EX0dFVF9DT05GX0lOVFIKK307CisKK3N0cnVjdCBWbXhuZXQzX1R4RGVzYyB7CisJdTY0CQlhZGRyOworCisJdTMyCQlsZW46MTQ7CisJdTMyCQlnZW46MTsgICAgICAvKiBnZW5lcmF0aW9uIGJpdCAqLworCXUzMgkJcnN2ZDoxOworCXUzMgkJZHR5cGU6MTsgICAgLyogZGVzY3JpcHRvciB0eXBlICovCisJdTMyCQlleHQxOjE7CisJdTMyCQltc3Njb2Y6MTQ7ICAvKiBNU1MsIGNoZWNrc3VtIG9mZnNldCwgZmxhZ3MgKi8KKworCXUzMgkJaGxlbjoxMDsgICAgLyogaGVhZGVyIGxlbiAqLworCXUzMgkJb206MjsgICAgICAgLyogb2ZmbG9hZCBtb2RlICovCisJdTMyCQllb3A6MTsgICAgICAvKiBFbmQgT2YgUGFja2V0ICovCisJdTMyCQljcToxOyAgICAgICAvKiBjb21wbGV0aW9uIHJlcXVlc3QgKi8KKwl1MzIJCWV4dDI6MTsKKwl1MzIJCXRpOjE7ICAgICAgIC8qIFZMQU4gVGFnIEluc2VydGlvbiAqLworCXUzMgkJdGNpOjE2OyAgICAgLyogVGFnIHRvIEluc2VydCAqLworfTsKKworLyogVHhEZXNjLk9NIHZhbHVlcyAqLworI2RlZmluZSBWTVhORVQzX09NX05PTkUJCTAKKyNkZWZpbmUgVk1YTkVUM19PTV9DU1VNCQkyCisjZGVmaW5lIFZNWE5FVDNfT01fVFNPCQkzCisKKy8qIGZpZWxkcyBpbiBUeERlc2Mgd2UgYWNjZXNzIHcvbyB1c2luZyBiaXQgZmllbGRzICovCisjZGVmaW5lIFZNWE5FVDNfVFhEX0VPUF9TSElGVAkxMgorI2RlZmluZSBWTVhORVQzX1RYRF9DUV9TSElGVAkxMworI2RlZmluZSBWTVhORVQzX1RYRF9HRU5fU0hJRlQJMTQKKworI2RlZmluZSBWTVhORVQzX1RYRF9DUQkJKDEgPDwgVk1YTkVUM19UWERfQ1FfU0hJRlQpCisjZGVmaW5lIFZNWE5FVDNfVFhEX0VPUAkJKDEgPDwgVk1YTkVUM19UWERfRU9QX1NISUZUKQorI2RlZmluZSBWTVhORVQzX1RYRF9HRU4JCSgxIDw8IFZNWE5FVDNfVFhEX0dFTl9TSElGVCkKKworI2RlZmluZSBWTVhORVQzX0hEUl9DT1BZX1NJWkUgICAxMjgKKworCitzdHJ1Y3QgVm14bmV0M19UeERhdGFEZXNjIHsKKwl1OAkJZGF0YVtWTVhORVQzX0hEUl9DT1BZX1NJWkVdOworfTsKKworCitzdHJ1Y3QgVm14bmV0M19UeENvbXBEZXNjIHsKKwl1MzIJCXR4ZElkeDoxMjsgICAgLyogSW5kZXggb2YgdGhlIEVPUCBUeERlc2MgKi8KKwl1MzIJCWV4dDE6MjA7CisKKwl1MzIJCWV4dDI7CisJdTMyCQlleHQzOworCisJdTMyCQlyc3ZkOjI0OworCXUzMgkJdHlwZTo3OyAgICAgICAvKiBjb21wbGV0aW9uIHR5cGUgKi8KKwl1MzIJCWdlbjoxOyAgICAgICAgLyogZ2VuZXJhdGlvbiBiaXQgKi8KK307CisKKworc3RydWN0IFZteG5ldDNfUnhEZXNjIHsKKwl1NjQJCWFkZHI7CisKKwl1MzIJCWxlbjoxNDsKKwl1MzIJCWJ0eXBlOjE7ICAgICAgLyogQnVmZmVyIFR5cGUgKi8KKwl1MzIJCWR0eXBlOjE7ICAgICAgLyogRGVzY3JpcHRvciB0eXBlICovCisJdTMyCQlyc3ZkOjE1OworCXUzMgkJZ2VuOjE7ICAgICAgICAvKiBHZW5lcmF0aW9uIGJpdCAqLworCisJdTMyCQlleHQxOworfTsKKworLyogdmFsdWVzIG9mIFJYRC5CVFlQRSAqLworI2RlZmluZSBWTVhORVQzX1JYRF9CVFlQRV9IRUFEICAgMCAgICAvKiBoZWFkIG9ubHkgKi8KKyNkZWZpbmUgVk1YTkVUM19SWERfQlRZUEVfQk9EWSAgIDEgICAgLyogYm9keSBvbmx5ICovCisKKy8qIGZpZWxkcyBpbiBSeERlc2Mgd2UgYWNjZXNzIHcvbyB1c2luZyBiaXQgZmllbGRzICovCisjZGVmaW5lIFZNWE5FVDNfUlhEX0JUWVBFX1NISUZUICAxNAorI2RlZmluZSBWTVhORVQzX1JYRF9HRU5fU0hJRlQgICAgMzEKKworCitzdHJ1Y3QgVm14bmV0M19SeENvbXBEZXNjIHsKKwl1MzIJCXJ4ZElkeDoxMjsgICAgLyogSW5kZXggb2YgdGhlIFJ4RGVzYyAqLworCXUzMgkJZXh0MToyOworCXUzMgkJZW9wOjE7ICAgICAgICAvKiBFbmQgb2YgUGFja2V0ICovCisJdTMyCQlzb3A6MTsgICAgICAgIC8qIFN0YXJ0IG9mIFBhY2tldCAqLworCXUzMgkJcnFJRDoxMDsgICAgICAvKiByeCBxdWV1ZS9yaW5nIElEICovCisJdTMyCQlyc3NUeXBlOjQ7ICAgIC8qIFJTUyBoYXNoIHR5cGUgdXNlZCAqLworCXUzMgkJY25jOjE7ICAgICAgICAvKiBDaGVja3N1bSBOb3QgQ2FsY3VsYXRlZCAqLworCXUzMgkJZXh0MjoxOworCisJdTMyCQlyc3NIYXNoOyAgICAgIC8qIFJTUyBoYXNoIHZhbHVlICovCisKKwl1MzIJCWxlbjoxNDsgICAgICAgLyogZGF0YSBsZW5ndGggKi8KKwl1MzIJCWVycjoxOyAgICAgICAgLyogRXJyb3IgKi8KKwl1MzIJCXRzOjE7ICAgICAgICAgLyogVGFnIGlzIHN0cmlwcGVkICovCisJdTMyCQl0Y2k6MTY7ICAgICAgIC8qIFRhZyBzdHJpcHBlZCAqLworCisJdTMyCQljc3VtOjE2OworCXUzMgkJdHVjOjE7ICAgICAgICAvKiBUQ1AvVURQIENoZWNrc3VtIENvcnJlY3QgKi8KKwl1MzIJCXVkcDoxOyAgICAgICAgLyogVURQIHBhY2tldCAqLworCXUzMgkJdGNwOjE7ICAgICAgICAvKiBUQ1AgcGFja2V0ICovCisJdTMyCQlpcGM6MTsgICAgICAgIC8qIElQIENoZWNrc3VtIENvcnJlY3QgKi8KKwl1MzIJCXY2OjE7ICAgICAgICAgLyogSVB2NiAqLworCXUzMgkJdjQ6MTsgICAgICAgICAvKiBJUHY0ICovCisJdTMyCQlmcmc6MTsgICAgICAgIC8qIElQIEZyYWdtZW50ICovCisJdTMyCQlmY3M6MTsgICAgICAgIC8qIEZyYW1lIENSQyBjb3JyZWN0ICovCisJdTMyCQl0eXBlOjc7ICAgICAgIC8qIGNvbXBsZXRpb24gdHlwZSAqLworCXUzMgkJZ2VuOjE7ICAgICAgICAvKiBnZW5lcmF0aW9uIGJpdCAqLworfTsKKworLyogZmllbGRzIGluIFJ4Q29tcERlc2Mgd2UgYWNjZXNzIHZpYSBWbXhuZXQzX0dlbmVyaWNEZXNjLmR3b3JkWzNdICovCisjZGVmaW5lIFZNWE5FVDNfUkNEX1RVQ19TSElGVAkxNgorI2RlZmluZSBWTVhORVQzX1JDRF9JUENfU0hJRlQJMTkKKworLyogZmllbGRzIGluIFJ4Q29tcERlc2Mgd2UgYWNjZXNzIHZpYSBWbXhuZXQzX0dlbmVyaWNEZXNjLnF3b3JkWzFdICovCisjZGVmaW5lIFZNWE5FVDNfUkNEX1RZUEVfU0hJRlQJNTYKKyNkZWZpbmUgVk1YTkVUM19SQ0RfR0VOX1NISUZUCTYzCisKKy8qIGNzdW0gT0sgZm9yIFRDUC9VRFAgcGt0cyBvdmVyIElQICovCisjZGVmaW5lIFZNWE5FVDNfUkNEX0NTVU1fT0sgKDEgPDwgVk1YTkVUM19SQ0RfVFVDX1NISUZUIHwgXAorCQkJICAgICAxIDw8IFZNWE5FVDNfUkNEX0lQQ19TSElGVCkKKworLyogdmFsdWUgb2YgUnhDb21wRGVzYy5yc3NUeXBlICovCitlbnVtIHsKKwlWTVhORVQzX1JDRF9SU1NfVFlQRV9OT05FICAgICA9IDAsCisJVk1YTkVUM19SQ0RfUlNTX1RZUEVfSVBWNCAgICAgPSAxLAorCVZNWE5FVDNfUkNEX1JTU19UWVBFX1RDUElQVjQgID0gMiwKKwlWTVhORVQzX1JDRF9SU1NfVFlQRV9JUFY2ICAgICA9IDMsCisJVk1YTkVUM19SQ0RfUlNTX1RZUEVfVENQSVBWNiAgPSA0LAorfTsKKworCisvKiBhIHVuaW9uIGZvciBhY2Nlc3NpbmcgYWxsIGNtZC9jb21wbGV0aW9uIGRlc2NyaXB0b3JzICovCit1bmlvbiBWbXhuZXQzX0dlbmVyaWNEZXNjIHsKKwl1NjQJCQkJcXdvcmRbMl07CisJdTMyCQkJCWR3b3JkWzRdOworCXUxNgkJCQl3b3JkWzhdOworCXN0cnVjdCBWbXhuZXQzX1R4RGVzYwkJdHhkOworCXN0cnVjdCBWbXhuZXQzX1J4RGVzYwkJcnhkOworCXN0cnVjdCBWbXhuZXQzX1R4Q29tcERlc2MJdGNkOworCXN0cnVjdCBWbXhuZXQzX1J4Q29tcERlc2MJcmNkOworfTsKKworI2RlZmluZSBWTVhORVQzX0lOSVRfR0VOICAgICAgIDEKKworLyogTWF4IHNpemUgb2YgYSBzaW5nbGUgdHggYnVmZmVyICovCisjZGVmaW5lIFZNWE5FVDNfTUFYX1RYX0JVRl9TSVpFICAoMSA8PCAxNCkKKworLyogIyBvZiB0eCBkZXNjIG5lZWRlZCBmb3IgYSB0eCBidWZmZXIgc2l6ZSAqLworI2RlZmluZSBWTVhORVQzX1RYRF9ORUVERUQoc2l6ZSkgKCgoc2l6ZSkgKyBWTVhORVQzX01BWF9UWF9CVUZfU0laRSAtIDEpIC8gXAorCQkJCSAgVk1YTkVUM19NQVhfVFhfQlVGX1NJWkUpCisKKy8qIG1heCAjIG9mIHR4IGRlc2NzIGZvciBhIG5vbi10c28gcGt0ICovCisjZGVmaW5lIFZNWE5FVDNfTUFYX1RYRF9QRVJfUEtUIDE2CisKKy8qIE1heCBzaXplIG9mIGEgc2luZ2xlIHJ4IGJ1ZmZlciAqLworI2RlZmluZSBWTVhORVQzX01BWF9SWF9CVUZfU0laRSAgKCgxIDw8IDE0KSAtIDEpCisvKiBNaW5pbXVtIHNpemUgb2YgYSB0eXBlIDAgYnVmZmVyICovCisjZGVmaW5lIFZNWE5FVDNfTUlOX1QwX0JVRl9TSVpFICAxMjgKKyNkZWZpbmUgVk1YTkVUM19NQVhfQ1NVTV9PRkZTRVQgIDEwMjQKKworLyogUmluZyBiYXNlIGFkZHJlc3MgYWxpZ25tZW50ICovCisjZGVmaW5lIFZNWE5FVDNfUklOR19CQV9BTElHTiAgIDUxMgorI2RlZmluZSBWTVhORVQzX1JJTkdfQkFfTUFTSyAgICAoVk1YTkVUM19SSU5HX0JBX0FMSUdOIC0gMSkKKworLyogUmluZyBzaXplIG11c3QgYmUgYSBtdWx0aXBsZSBvZiAzMiAqLworI2RlZmluZSBWTVhORVQzX1JJTkdfU0laRV9BTElHTiAzMgorI2RlZmluZSBWTVhORVQzX1JJTkdfU0laRV9NQVNLICAoVk1YTkVUM19SSU5HX1NJWkVfQUxJR04gLSAxKQorCisvKiBNYXggcmluZyBzaXplICovCisjZGVmaW5lIFZNWE5FVDNfVFhfUklOR19NQVhfU0laRSAgIDQwOTYKKyNkZWZpbmUgVk1YTkVUM19UQ19SSU5HX01BWF9TSVpFICAgNDA5NgorI2RlZmluZSBWTVhORVQzX1JYX1JJTkdfTUFYX1NJWkUgICA0MDk2CisjZGVmaW5lIFZNWE5FVDNfUkNfUklOR19NQVhfU0laRSAgIDgxOTIKKworLyogYSBsaXN0IG9mIHJlYXNvbnMgZm9yIHF1ZXVlIHN0b3AgKi8KKworZW51bSB7CisgVk1YTkVUM19FUlJfTk9FT1AgICAgICAgID0gMHg4MDAwMDAwMCwgIC8qIGNhbm5vdCBmaW5kIHRoZSBFT1AgZGVzYyBvZiBhIHBrdCAqLworIFZNWE5FVDNfRVJSX1RYRF9SRVVTRSAgICA9IDB4ODAwMDAwMDEsICAvKiByZXVzZSBUeERlc2MgYmVmb3JlIHR4IGNvbXBsZXRpb24gKi8KKyBWTVhORVQzX0VSUl9CSUdfUEtUICAgICAgPSAweDgwMDAwMDAyLCAgLyogdG9vIG1hbnkgVHhEZXNjIGZvciBhIHBrdCAqLworIFZNWE5FVDNfRVJSX0RFU0NfTk9UX1NQVCA9IDB4ODAwMDAwMDMsICAvKiBkZXNjcmlwdG9yIHR5cGUgbm90IHN1cHBvcnRlZCAqLworIFZNWE5FVDNfRVJSX1NNQUxMX0JVRiAgICA9IDB4ODAwMDAwMDQsICAvKiB0eXBlIDAgYnVmZmVyIHRvbyBzbWFsbCAqLworIFZNWE5FVDNfRVJSX1NUUkVTUyAgICAgICA9IDB4ODAwMDAwMDUsICAvKiBzdHJlc3Mgb3B0aW9uIGZpcmluZyBpbiB2bWtlcm5lbCAqLworIFZNWE5FVDNfRVJSX1NXSVRDSCAgICAgICA9IDB4ODAwMDAwMDYsICAvKiBtb2RlIHN3aXRjaCBmYWlsdXJlICovCisgVk1YTkVUM19FUlJfVFhEX0lOVkFMSUQgID0gMHg4MDAwMDAwNywgIC8qIGludmFsaWQgVHhEZXNjICovCit9OworCisvKiBjb21wbGV0aW9uIGRlc2NyaXB0b3IgdHlwZXMgKi8KKyNkZWZpbmUgVk1YTkVUM19DRFRZUEVfVFhDT01QICAgICAgMCAgICAvKiBUeCBDb21wbGV0aW9uIERlc2NyaXB0b3IgKi8KKyNkZWZpbmUgVk1YTkVUM19DRFRZUEVfUlhDT01QICAgICAgMyAgICAvKiBSeCBDb21wbGV0aW9uIERlc2NyaXB0b3IgKi8KKworZW51bSB7CisJVk1YTkVUM19HT1NfQklUU19VTksgICAgPSAwLCAgIC8qIHVua25vd24gKi8KKwlWTVhORVQzX0dPU19CSVRTXzMyICAgICA9IDEsCisJVk1YTkVUM19HT1NfQklUU182NCAgICAgPSAyLAorfTsKKworI2RlZmluZSBWTVhORVQzX0dPU19UWVBFX0xJTlVYCTEKKworCitzdHJ1Y3QgVm14bmV0M19HT1NJbmZvIHsKKwl1MzIJCQkJZ29zQml0czoyOwkvKiAzMi1iaXQgb3IgNjQtYml0PyAqLworCXUzMgkJCQlnb3NUeXBlOjQ7ICAgLyogd2hpY2ggZ3Vlc3QgKi8KKwl1MzIJCQkJZ29zVmVyOjE2OyAgIC8qIGdvcyB2ZXJzaW9uICovCisJdTMyCQkJCWdvc01pc2M6MTA7ICAvKiBvdGhlciBpbmZvIGFib3V0IGdvcyAqLworfTsKKworCitzdHJ1Y3QgVm14bmV0M19Ecml2ZXJJbmZvIHsKKwl1MzIJCQkJdmVyc2lvbjsKKwlzdHJ1Y3QgVm14bmV0M19HT1NJbmZvCQlnb3M7CisJdTMyCQkJCXZteG5ldDNSZXZTcHQ7CisJdTMyCQkJCXVwdFZlclNwdDsKK307CisKKworI2RlZmluZSBWTVhORVQzX1JFVjFfTUFHSUMgIDB4YmFiZWZlZTEKKworLyoKKyAqIFF1ZXVlRGVzY1BBIG11c3QgYmUgMTI4IGJ5dGVzIGFsaWduZWQuIEl0IHBvaW50cyB0byBhbiBhcnJheSBvZgorICogVm14bmV0M19UeFF1ZXVlRGVzYyBmb2xsb3dlZCBieSBhbiBhcnJheSBvZiBWbXhuZXQzX1J4UXVldWVEZXNjLgorICogVGhlIG51bWJlciBvZiBWbXhuZXQzX1R4UXVldWVEZXNjL1ZteG5ldDNfUnhRdWV1ZURlc2MgYXJlIHNwZWNpZmllZCBieQorICogVm14bmV0M19NaXNjQ29uZi5udW1UeFF1ZXVlcy9udW1SeFF1ZXVlcywgcmVzcGVjdGl2ZWx5LgorICovCisjZGVmaW5lIFZNWE5FVDNfUVVFVUVfREVTQ19BTElHTiAgMTI4CisKKworc3RydWN0IFZteG5ldDNfTWlzY0NvbmYgeworCXN0cnVjdCBWbXhuZXQzX0RyaXZlckluZm8gZHJpdmVySW5mbzsKKwl1NjQJCXVwdEZlYXR1cmVzOworCXU2NAkJZGRQQTsgICAgICAgICAvKiBkcml2ZXIgZGF0YSBQQSAqLworCXU2NAkJcXVldWVEZXNjUEE7ICAvKiBxdWV1ZSBkZXNjcmlwdG9yIHRhYmxlIFBBICovCisJdTMyCQlkZExlbjsgICAgICAgIC8qIGRyaXZlciBkYXRhIGxlbiAqLworCXUzMgkJcXVldWVEZXNjTGVuOyAvKiBxdWV1ZSBkZXNjLiB0YWJsZSBsZW4gaW4gYnl0ZXMgKi8KKwl1MzIJCW10dTsKKwl1MTYJCW1heE51bVJ4U0c7CisJdTgJCW51bVR4UXVldWVzOworCXU4CQludW1SeFF1ZXVlczsKKwl1MzIJCXJlc2VydmVkWzRdOworfTsKKworCitzdHJ1Y3QgVm14bmV0M19UeFF1ZXVlQ29uZiB7CisJdTY0CQl0eFJpbmdCYXNlUEE7CisJdTY0CQlkYXRhUmluZ0Jhc2VQQTsKKwl1NjQJCWNvbXBSaW5nQmFzZVBBOworCXU2NAkJZGRQQTsgICAgICAgICAvKiBkcml2ZXIgZGF0YSAqLworCXU2NAkJcmVzZXJ2ZWQ7CisJdTMyCQl0eFJpbmdTaXplOyAgIC8qICMgb2YgdHggZGVzYyAqLworCXUzMgkJZGF0YVJpbmdTaXplOyAvKiAjIG9mIGRhdGEgZGVzYyAqLworCXUzMgkJY29tcFJpbmdTaXplOyAvKiAjIG9mIGNvbXAgZGVzYyAqLworCXUzMgkJZGRMZW47ICAgICAgICAvKiBzaXplIG9mIGRyaXZlciBkYXRhICovCisJdTgJCWludHJJZHg7CisJdTgJCV9wYWRbN107Cit9OworCisKK3N0cnVjdCBWbXhuZXQzX1J4UXVldWVDb25mIHsKKwl1NjQJCXJ4UmluZ0Jhc2VQQVsyXTsKKwl1NjQJCWNvbXBSaW5nQmFzZVBBOworCXU2NAkJZGRQQTsgICAgICAgICAgICAvKiBkcml2ZXIgZGF0YSAqLworCXU2NAkJcmVzZXJ2ZWQ7CisJdTMyCQlyeFJpbmdTaXplWzJdOyAgIC8qICMgb2YgcnggZGVzYyAqLworCXUzMgkJY29tcFJpbmdTaXplOyAgICAvKiAjIG9mIHJ4IGNvbXAgZGVzYyAqLworCXUzMgkJZGRMZW47ICAgICAgICAgICAvKiBzaXplIG9mIGRyaXZlciBkYXRhICovCisJdTgJCWludHJJZHg7CisJdTgJCV9wYWRbN107Cit9OworCisKK2VudW0gdm14bmV0M19pbnRyX21hc2tfbW9kZSB7CisJVk1YTkVUM19JTU1fQVVUTyAgID0gMCwKKwlWTVhORVQzX0lNTV9BQ1RJVkUgPSAxLAorCVZNWE5FVDNfSU1NX0xBWlkgICA9IDIKK307CisKK2VudW0gdm14bmV0M19pbnRyX3R5cGUgeworCVZNWE5FVDNfSVRfQVVUTyA9IDAsCisJVk1YTkVUM19JVF9JTlRYID0gMSwKKwlWTVhORVQzX0lUX01TSSAgPSAyLAorCVZNWE5FVDNfSVRfTVNJWCA9IDMKK307CisKKyNkZWZpbmUgVk1YTkVUM19NQVhfVFhfUVVFVUVTICA4CisjZGVmaW5lIFZNWE5FVDNfTUFYX1JYX1FVRVVFUyAgMTYKKy8qIGFkZGl0aW9uIDEgZm9yIGV2ZW50cyAqLworI2RlZmluZSBWTVhORVQzX01BWF9JTlRSUyAgICAgIDI1CisKKworc3RydWN0IFZteG5ldDNfSW50ckNvbmYgeworCWJvb2wJCWF1dG9NYXNrOworCXU4CQludW1JbnRyczsgICAgICAvKiAjIG9mIGludGVycnVwdHMgKi8KKwl1OAkJZXZlbnRJbnRySWR4OworCXU4CQltb2RMZXZlbHNbVk1YTkVUM19NQVhfSU5UUlNdOwkvKiBtb2RlcmF0aW9uIGxldmVsIGZvcgorCQkJCQkJCSAqIGVhY2ggaW50ciAqLworCXUzMgkJcmVzZXJ2ZWRbM107Cit9OworCisvKiBvbmUgYml0IHBlciBWTEFOIElELCB0aGUgc2l6ZSBpcyBpbiB0aGUgdW5pdHMgb2YgdTMyCSovCisjZGVmaW5lIFZNWE5FVDNfVkZUX1NJWkUgICg0MDk2IC8gKHNpemVvZih1MzIpICogOCkpCisKKworc3RydWN0IFZteG5ldDNfUXVldWVTdGF0dXMgeworCWJvb2wJCXN0b3BwZWQ7CisJdTgJCV9wYWRbM107CisJdTMyCQllcnJvcjsKK307CisKKworc3RydWN0IFZteG5ldDNfVHhRdWV1ZUN0cmwgeworCXUzMgkJdHhOdW1EZWZlcnJlZDsKKwl1MzIJCXR4VGhyZXNob2xkOworCXU2NAkJcmVzZXJ2ZWQ7Cit9OworCisKK3N0cnVjdCBWbXhuZXQzX1J4UXVldWVDdHJsIHsKKwlib29sCQl1cGRhdGVSeFByb2Q7CisJdTgJCV9wYWRbN107CisJdTY0CQlyZXNlcnZlZDsKK307CisKK2VudW0geworCVZNWE5FVDNfUlhNX1VDQVNUICAgICA9IDB4MDEsICAvKiB1bmljYXN0IG9ubHkgKi8KKwlWTVhORVQzX1JYTV9NQ0FTVCAgICAgPSAweDAyLCAgLyogbXVsdGljYXN0IHBhc3NpbmcgdGhlIGZpbHRlcnMgKi8KKwlWTVhORVQzX1JYTV9CQ0FTVCAgICAgPSAweDA0LCAgLyogYnJvYWRjYXN0IG9ubHkgKi8KKwlWTVhORVQzX1JYTV9BTExfTVVMVEkgPSAweDA4LCAgLyogYWxsIG11bHRpY2FzdCAqLworCVZNWE5FVDNfUlhNX1BST01JU0MgICA9IDB4MTAgIC8qIHByb21pc2N1b3VzICovCit9OworCitzdHJ1Y3QgVm14bmV0M19SeEZpbHRlckNvbmYgeworCXUzMgkJcnhNb2RlOyAgICAgICAvKiBWTVhORVQzX1JYTV94eHggKi8KKwl1MTYJCW1mVGFibGVMZW47ICAgLyogc2l6ZSBvZiB0aGUgbXVsdGljYXN0IGZpbHRlciB0YWJsZSAqLworCXUxNgkJX3BhZDE7CisJdTY0CQltZlRhYmxlUEE7ICAgIC8qIFBBIG9mIHRoZSBtdWx0aWNhc3QgZmlsdGVycyB0YWJsZSAqLworCXUzMgkJdmZUYWJsZVtWTVhORVQzX1ZGVF9TSVpFXTsgLyogdmxhbiBmaWx0ZXIgKi8KK307CisKKworI2RlZmluZSBWTVhORVQzX1BNX01BWF9GSUxURVJTICAgICAgICA2CisjZGVmaW5lIFZNWE5FVDNfUE1fTUFYX1BBVFRFUk5fU0laRSAgIDEyOAorI2RlZmluZSBWTVhORVQzX1BNX01BWF9NQVNLX1NJWkUgICAgICAoVk1YTkVUM19QTV9NQVhfUEFUVEVSTl9TSVpFIC8gOCkKKworI2RlZmluZSBWTVhORVQzX1BNX1dBS0VVUF9NQUdJQyAgICAgICAweDAxICAvKiB3YWtlIHVwIG9uIG1hZ2ljIHBrdHMgKi8KKyNkZWZpbmUgVk1YTkVUM19QTV9XQUtFVVBfRklMVEVSICAgICAgMHgwMiAgLyogd2FrZSB1cCBvbiBwa3RzIG1hdGNoaW5nCisJCQkJCSAgICAgKiBmaWx0ZXJzICovCisKKworc3RydWN0IFZteG5ldDNfUE1fUGt0RmlsdGVyIHsKKwl1OAkJbWFza1NpemU7CisJdTgJCXBhdHRlcm5TaXplOworCXU4CQltYXNrW1ZNWE5FVDNfUE1fTUFYX01BU0tfU0laRV07CisJdTgJCXBhdHRlcm5bVk1YTkVUM19QTV9NQVhfUEFUVEVSTl9TSVpFXTsKKwl1OAkJcGFkWzZdOworfTsKKworCitzdHJ1Y3QgVm14bmV0M19QTUNvbmYgeworCXUxNgkJd2FrZVVwRXZlbnRzOyAgLyogVk1YTkVUM19QTV9XQUtFVVBfeHh4ICovCisJdTgJCW51bUZpbHRlcnM7CisJdTgJCXBhZFs1XTsKKwlzdHJ1Y3QgVm14bmV0M19QTV9Qa3RGaWx0ZXIgZmlsdGVyc1tWTVhORVQzX1BNX01BWF9GSUxURVJTXTsKK307CisKKworc3RydWN0IFZteG5ldDNfVmFyaWFibGVMZW5Db25mRGVzYyB7CisJdTMyCQljb25mVmVyOworCXUzMgkJY29uZkxlbjsKKwl1NjQJCWNvbmZQQTsKK307CisKKworc3RydWN0IFZteG5ldDNfVHhRdWV1ZURlc2MgeworCXN0cnVjdCBWbXhuZXQzX1R4UXVldWVDdHJsCQljdHJsOworCXN0cnVjdCBWbXhuZXQzX1R4UXVldWVDb25mCQljb25mOworCisJLyogRHJpdmVyIHJlYWQgYWZ0ZXIgYSBHRVQgY29tbWFuZCAqLworCXN0cnVjdCBWbXhuZXQzX1F1ZXVlU3RhdHVzCQlzdGF0dXM7CisJc3RydWN0IFVQVDFfVHhTdGF0cwkJCXN0YXRzOworCXU4CQkJCQlfcGFkWzg4XTsgLyogMTI4IGFsaWduZWQgKi8KK307CisKKworc3RydWN0IFZteG5ldDNfUnhRdWV1ZURlc2MgeworCXN0cnVjdCBWbXhuZXQzX1J4UXVldWVDdHJsCQljdHJsOworCXN0cnVjdCBWbXhuZXQzX1J4UXVldWVDb25mCQljb25mOworCS8qIERyaXZlciByZWFkIGFmdGVyIGEgR0VUIGNvbW1hZCAqLworCXN0cnVjdCBWbXhuZXQzX1F1ZXVlU3RhdHVzCQlzdGF0dXM7CisJc3RydWN0IFVQVDFfUnhTdGF0cwkJCXN0YXRzOworCXU4CQkJCSAgICAgIF9fcGFkWzg4XTsgLyogMTI4IGFsaWduZWQgKi8KK307CisKKworc3RydWN0IFZteG5ldDNfRFNEZXZSZWFkIHsKKwkvKiByZWFkLW9ubHkgcmVnaW9uIGZvciBkZXZpY2UsIHJlYWQgYnkgZGV2IGluIHJlc3BvbnNlIHRvIGEgU0VUIGNtZCAqLworCXN0cnVjdCBWbXhuZXQzX01pc2NDb25mCQkJbWlzYzsKKwlzdHJ1Y3QgVm14bmV0M19JbnRyQ29uZgkJCWludHJDb25mOworCXN0cnVjdCBWbXhuZXQzX1J4RmlsdGVyQ29uZgkJcnhGaWx0ZXJDb25mOworCXN0cnVjdCBWbXhuZXQzX1ZhcmlhYmxlTGVuQ29uZkRlc2MJcnNzQ29uZkRlc2M7CisJc3RydWN0IFZteG5ldDNfVmFyaWFibGVMZW5Db25mRGVzYwlwbUNvbmZEZXNjOworCXN0cnVjdCBWbXhuZXQzX1ZhcmlhYmxlTGVuQ29uZkRlc2MJcGx1Z2luQ29uZkRlc2M7Cit9OworCisvKiBBbGwgc3RydWN0dXJlcyBpbiBEcml2ZXJTaGFyZWQgYXJlIHBhZGRlZCB0byBtdWx0aXBsZXMgb2YgOCBieXRlcyAqLworc3RydWN0IFZteG5ldDNfRHJpdmVyU2hhcmVkIHsKKwl1MzIJCQkJbWFnaWM7CisJLyogbWFrZSBkZXZSZWFkIHN0YXJ0IGF0IDY0Yml0IGJvdW5kYXJpZXMgKi8KKwl1MzIJCQkJCXBhZDsKKwlzdHJ1Y3QgVm14bmV0M19EU0RldlJlYWQJCWRldlJlYWQ7CisJdTMyCQkJCQllY3I7CisJdTMyCQkJCQlyZXNlcnZlZFs1XTsKK307CisKKworI2RlZmluZSBWTVhORVQzX0VDUl9SUUVSUiAgICAgICAoMSA8PCAwKQorI2RlZmluZSBWTVhORVQzX0VDUl9UUUVSUiAgICAgICAoMSA8PCAxKQorI2RlZmluZSBWTVhORVQzX0VDUl9MSU5LICAgICAgICAoMSA8PCAyKQorI2RlZmluZSBWTVhORVQzX0VDUl9ESUMgICAgICAgICAoMSA8PCAzKQorI2RlZmluZSBWTVhORVQzX0VDUl9ERUJVRyAgICAgICAoMSA8PCA0KQorCisvKiBmbGlwIHRoZSBnZW4gYml0IG9mIGEgcmluZyAqLworI2RlZmluZSBWTVhORVQzX0ZMSVBfUklOR19HRU4oZ2VuKSAoKGdlbikgPSAoZ2VuKSBeIDB4MSkKKworLyogb25seSB1c2UgdGhpcyBpZiBtb3ZpbmcgdGhlIGlkeCB3b24ndCBhZmZlY3QgdGhlIGdlbiBiaXQgKi8KKyNkZWZpbmUgVk1YTkVUM19JTkNfUklOR19JRFhfT05MWShpZHgsIHJpbmdfc2l6ZSkgXAorCWRvIHtcCisJCShpZHgpKys7XAorCQlpZiAodW5saWtlbHkoKGlkeCkgPT0gKHJpbmdfc2l6ZSkpKSB7XAorCQkJKGlkeCkgPSAwO1wKKwkJfSBcCisJfSB3aGlsZSAoMCkKKworI2RlZmluZSBWTVhORVQzX1NFVF9WRlRBQkxFX0VOVFJZKHZmVGFibGUsIHZpZCkgXAorCSh2ZlRhYmxlW3ZpZCA+PiA1XSB8PSAoMSA8PCAodmlkICYgMzEpKSkKKyNkZWZpbmUgVk1YTkVUM19DTEVBUl9WRlRBQkxFX0VOVFJZKHZmVGFibGUsIHZpZCkgXAorCSh2ZlRhYmxlW3ZpZCA+PiA1XSAmPSB+KDEgPDwgKHZpZCAmIDMxKSkpCisKKyNkZWZpbmUgVk1YTkVUM19WRlRBQkxFX0VOVFJZX0lTX1NFVCh2ZlRhYmxlLCB2aWQpIFwKKwkoKHZmVGFibGVbdmlkID4+IDVdICYgKDEgPDwgKHZpZCAmIDMxKSkpICE9IDApCisKKyNkZWZpbmUgVk1YTkVUM19NQVhfTVRVICAgICA5MDAwCisjZGVmaW5lIFZNWE5FVDNfTUlOX01UVSAgICAgNjAKKworI2RlZmluZSBWTVhORVQzX0xJTktfVVAgICAgICAgICAoMTAwMDAgPDwgMTYgfCAxKSAgICAvKiAxMCBHYnBzLCB1cCAqLworI2RlZmluZSBWTVhORVQzX0xJTktfRE9XTiAgICAgICAwCisKKyNlbmRpZiAvKiBfVk1YTkVUM19ERUZTX0hfICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfZHJ2LmMgYi9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfZHJ2LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDA0MzUzYQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvdm14bmV0M19kcnYuYwpAQCAtMCwwICsxLDI1NzQgQEAKKy8qCisgKiBMaW51eCBkcml2ZXIgZm9yIFZNd2FyZSdzIHZteG5ldDMgZXRoZXJuZXQgTklDLgorICoKKyAqIENvcHlyaWdodCAoQykgMjAwOC0yMDA5LCBWTXdhcmUsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlCisgKiBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSBhbmQgbm8gbGF0ZXIgdmVyc2lvbi4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UsIEdPT0QgVElUTEUgb3IKKyAqIE5PTiBJTkZSSU5HRU1FTlQuIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUKKyAqIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisgKgorICogVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAqIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisgKgorICogTWFpbnRhaW5lZCBieTogU2hyZXlhcyBCaGF0ZXdhcmEgPHB2LWRyaXZlcnNAdm13YXJlLmNvbT4KKyAqCisgKi8KKworI2luY2x1ZGUgInZteG5ldDNfaW50LmgiCisKK2NoYXIgdm14bmV0M19kcml2ZXJfbmFtZVtdID0gInZteG5ldDMiOworI2RlZmluZSBWTVhORVQzX0RSSVZFUl9ERVNDICJWTXdhcmUgdm14bmV0MyB2aXJ0dWFsIE5JQyBkcml2ZXIiCisKKworLyoKKyAqIFBDSSBEZXZpY2UgSUQgVGFibGUKKyAqIExhc3QgZW50cnkgbXVzdCBiZSBhbGwgMHMKKyAqLworc3RhdGljIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkIHZteG5ldDNfcGNpaWRfdGFibGVbXSA9IHsKKwl7UENJX1ZERVZJQ0UoVk1XQVJFLCBQQ0lfREVWSUNFX0lEX1ZNV0FSRV9WTVhORVQzKX0sCisJezB9Cit9OworCitNT0RVTEVfREVWSUNFX1RBQkxFKHBjaSwgdm14bmV0M19wY2lpZF90YWJsZSk7CisKK3N0YXRpYyBhdG9taWNfdCBkZXZpY2VzX2ZvdW5kOworCisKKy8qCisgKiAgICBFbmFibGUvRGlzYWJsZSB0aGUgZ2l2ZW4gaW50cgorICovCitzdGF0aWMgdm9pZAordm14bmV0M19lbmFibGVfaW50cihzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyLCB1bnNpZ25lZCBpbnRyX2lkeCkKK3sKKwlWTVhORVQzX1dSSVRFX0JBUjBfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0lNUiArIGludHJfaWR4ICogOCwgMCk7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZGlzYWJsZV9pbnRyKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIsIHVuc2lnbmVkIGludHJfaWR4KQoreworCVZNWE5FVDNfV1JJVEVfQkFSMF9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfSU1SICsgaW50cl9pZHggKiA4LCAxKTsKK30KKworCisvKgorICogICAgRW5hYmxlL0Rpc2FibGUgYWxsIGludHJzIHVzZWQgYnkgdGhlIGRldmljZQorICovCitzdGF0aWMgdm9pZAordm14bmV0M19lbmFibGVfYWxsX2ludHJzKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgYWRhcHRlci0+aW50ci5udW1faW50cnM7IGkrKykKKwkJdm14bmV0M19lbmFibGVfaW50cihhZGFwdGVyLCBpKTsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19kaXNhYmxlX2FsbF9pbnRycyhzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IGFkYXB0ZXItPmludHIubnVtX2ludHJzOyBpKyspCisJCXZteG5ldDNfZGlzYWJsZV9pbnRyKGFkYXB0ZXIsIGkpOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX2Fja19ldmVudHMoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciwgdTMyIGV2ZW50cykKK3sKKwlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0VDUiwgZXZlbnRzKTsKK30KKworCitzdGF0aWMgYm9vbAordm14bmV0M190cV9zdG9wcGVkKHN0cnVjdCB2bXhuZXQzX3R4X3F1ZXVlICp0cSwgc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwlyZXR1cm4gbmV0aWZfcXVldWVfc3RvcHBlZChhZGFwdGVyLT5uZXRkZXYpOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX3RxX3N0YXJ0KHN0cnVjdCB2bXhuZXQzX3R4X3F1ZXVlICp0cSwgc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwl0cS0+c3RvcHBlZCA9IGZhbHNlOworCW5ldGlmX3N0YXJ0X3F1ZXVlKGFkYXB0ZXItPm5ldGRldik7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfdHFfd2FrZShzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEsIHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJdHEtPnN0b3BwZWQgPSBmYWxzZTsKKwluZXRpZl93YWtlX3F1ZXVlKGFkYXB0ZXItPm5ldGRldik7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfdHFfc3RvcChzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEsIHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJdHEtPnN0b3BwZWQgPSB0cnVlOworCXRxLT5udW1fc3RvcCsrOworCW5ldGlmX3N0b3BfcXVldWUoYWRhcHRlci0+bmV0ZGV2KTsKK30KKworCisvKgorICogQ2hlY2sgdGhlIGxpbmsgc3RhdGUuIFRoaXMgbWF5IHN0YXJ0IG9yIHN0b3AgdGhlIHR4IHF1ZXVlLgorICovCitzdGF0aWMgdm9pZAordm14bmV0M19jaGVja19saW5rKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJdTMyIHJldDsKKworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELCBWTVhORVQzX0NNRF9HRVRfTElOSyk7CisJcmV0ID0gVk1YTkVUM19SRUFEX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCk7CisJYWRhcHRlci0+bGlua19zcGVlZCA9IHJldCA+PiAxNjsKKwlpZiAocmV0ICYgMSkgeyAvKiBMaW5rIGlzIHVwLiAqLworCQlwcmludGsoS0VSTl9JTkZPICIlczogTklDIExpbmsgaXMgVXAgJWQgTWJwc1xuIiwKKwkJICAgICAgIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwgYWRhcHRlci0+bGlua19zcGVlZCk7CisJCWlmICghbmV0aWZfY2Fycmllcl9vayhhZGFwdGVyLT5uZXRkZXYpKQorCQkJbmV0aWZfY2Fycmllcl9vbihhZGFwdGVyLT5uZXRkZXYpOworCisJCXZteG5ldDNfdHFfc3RhcnQoJmFkYXB0ZXItPnR4X3F1ZXVlLCBhZGFwdGVyKTsKKwl9IGVsc2UgeworCQlwcmludGsoS0VSTl9JTkZPICIlczogTklDIExpbmsgaXMgRG93blxuIiwKKwkJICAgICAgIGFkYXB0ZXItPm5ldGRldi0+bmFtZSk7CisJCWlmIChuZXRpZl9jYXJyaWVyX29rKGFkYXB0ZXItPm5ldGRldikpCisJCQluZXRpZl9jYXJyaWVyX29mZihhZGFwdGVyLT5uZXRkZXYpOworCisJCXZteG5ldDNfdHFfc3RvcCgmYWRhcHRlci0+dHhfcXVldWUsIGFkYXB0ZXIpOworCX0KK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19wcm9jZXNzX2V2ZW50cyhzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCXUzMiBldmVudHMgPSBhZGFwdGVyLT5zaGFyZWQtPmVjcjsKKwlpZiAoIWV2ZW50cykKKwkJcmV0dXJuOworCisJdm14bmV0M19hY2tfZXZlbnRzKGFkYXB0ZXIsIGV2ZW50cyk7CisKKwkvKiBDaGVjayBpZiBsaW5rIHN0YXRlIGhhcyBjaGFuZ2VkICovCisJaWYgKGV2ZW50cyAmIFZNWE5FVDNfRUNSX0xJTkspCisJCXZteG5ldDNfY2hlY2tfbGluayhhZGFwdGVyKTsKKworCS8qIENoZWNrIGlmIHRoZXJlIGlzIGFuIGVycm9yIG9uIHhtaXQvcmVjdiBxdWV1ZXMgKi8KKwlpZiAoZXZlbnRzICYgKFZNWE5FVDNfRUNSX1RRRVJSIHwgVk1YTkVUM19FQ1JfUlFFUlIpKSB7CisJCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJCSAgICAgICBWTVhORVQzX0NNRF9HRVRfUVVFVUVfU1RBVFVTKTsKKworCQlpZiAoYWRhcHRlci0+dHFkX3N0YXJ0LT5zdGF0dXMuc3RvcHBlZCkgeworCQkJcHJpbnRrKEtFUk5fRVJSICIlczogdHEgZXJyb3IgMHgleFxuIiwKKwkJCSAgICAgICBhZGFwdGVyLT5uZXRkZXYtPm5hbWUsCisJCQkgICAgICAgYWRhcHRlci0+dHFkX3N0YXJ0LT5zdGF0dXMuZXJyb3IpOworCQl9CisJCWlmIChhZGFwdGVyLT5ycWRfc3RhcnQtPnN0YXR1cy5zdG9wcGVkKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzOiBycSBlcnJvciAweCV4XG4iLAorCQkJICAgICAgIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwKKwkJCSAgICAgICBhZGFwdGVyLT5ycWRfc3RhcnQtPnN0YXR1cy5lcnJvcik7CisJCX0KKworCQlzY2hlZHVsZV93b3JrKCZhZGFwdGVyLT53b3JrKTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfdW5tYXBfdHhfYnVmKHN0cnVjdCB2bXhuZXQzX3R4X2J1Zl9pbmZvICp0YmksCisJCSAgICAgc3RydWN0IHBjaV9kZXYgKnBkZXYpCit7CisJaWYgKHRiaS0+bWFwX3R5cGUgPT0gVk1YTkVUM19NQVBfU0lOR0xFKQorCQlwY2lfdW5tYXBfc2luZ2xlKHBkZXYsIHRiaS0+ZG1hX2FkZHIsIHRiaS0+bGVuLAorCQkJCSBQQ0lfRE1BX1RPREVWSUNFKTsKKwllbHNlIGlmICh0YmktPm1hcF90eXBlID09IFZNWE5FVDNfTUFQX1BBR0UpCisJCXBjaV91bm1hcF9wYWdlKHBkZXYsIHRiaS0+ZG1hX2FkZHIsIHRiaS0+bGVuLAorCQkJICAgICAgIFBDSV9ETUFfVE9ERVZJQ0UpOworCWVsc2UKKwkJQlVHX09OKHRiaS0+bWFwX3R5cGUgIT0gVk1YTkVUM19NQVBfTk9ORSk7CisKKwl0YmktPm1hcF90eXBlID0gVk1YTkVUM19NQVBfTk9ORTsgLyogdG8gaGVscCBkZWJ1Z2dpbmcgKi8KK30KKworCitzdGF0aWMgaW50Cit2bXhuZXQzX3VubWFwX3BrdCh1MzIgZW9wX2lkeCwgc3RydWN0IHZteG5ldDNfdHhfcXVldWUgKnRxLAorCQkgIHN0cnVjdCBwY2lfZGV2ICpwZGV2LAlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCXN0cnVjdCBza19idWZmICpza2I7CisJaW50IGVudHJpZXMgPSAwOworCisJLyogbm8gb3V0IG9mIG9yZGVyIGNvbXBsZXRpb24gKi8KKwlCVUdfT04odHEtPmJ1Zl9pbmZvW2VvcF9pZHhdLnNvcF9pZHggIT0gdHEtPnR4X3JpbmcubmV4dDJjb21wKTsKKwlCVUdfT04odHEtPnR4X3JpbmcuYmFzZVtlb3BfaWR4XS50eGQuZW9wICE9IDEpOworCisJc2tiID0gdHEtPmJ1Zl9pbmZvW2VvcF9pZHhdLnNrYjsKKwlCVUdfT04oc2tiID09IE5VTEwpOworCXRxLT5idWZfaW5mb1tlb3BfaWR4XS5za2IgPSBOVUxMOworCisJVk1YTkVUM19JTkNfUklOR19JRFhfT05MWShlb3BfaWR4LCB0cS0+dHhfcmluZy5zaXplKTsKKworCXdoaWxlICh0cS0+dHhfcmluZy5uZXh0MmNvbXAgIT0gZW9wX2lkeCkgeworCQl2bXhuZXQzX3VubWFwX3R4X2J1Zih0cS0+YnVmX2luZm8gKyB0cS0+dHhfcmluZy5uZXh0MmNvbXAsCisJCQkJICAgICBwZGV2KTsKKworCQkvKiB1cGRhdGUgbmV4dDJjb21wIHcvbyB0eF9sb2NrLiBTaW5jZSB3ZSBhcmUgbWFya2luZyBtb3JlLAorCQkgKiBpbnN0ZWFkIG9mIGxlc3MsIHR4IHJpbmcgZW50cmllcyBhdmFpbCwgdGhlIHdvcnN0IGNhc2UgaXMKKwkJICogdGhhdCB0aGUgdHggcm91dGluZSBpbmNvcnJlY3RseSByZS1xdWV1ZXMgYSBwa3QgZHVlIHRvCisJCSAqIGluc3VmZmljaWVudCB0eCByaW5nIGVudHJpZXMuCisJCSAqLworCQl2bXhuZXQzX2NtZF9yaW5nX2Fkdl9uZXh0MmNvbXAoJnRxLT50eF9yaW5nKTsKKwkJZW50cmllcysrOworCX0KKworCWRldl9rZnJlZV9za2JfYW55KHNrYik7CisJcmV0dXJuIGVudHJpZXM7Cit9CisKKworc3RhdGljIGludAordm14bmV0M190cV90eF9jb21wbGV0ZShzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEsCisJCQlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBjb21wbGV0ZWQgPSAwOworCXVuaW9uIFZteG5ldDNfR2VuZXJpY0Rlc2MgKmdkZXNjOworCisJZ2Rlc2MgPSB0cS0+Y29tcF9yaW5nLmJhc2UgKyB0cS0+Y29tcF9yaW5nLm5leHQycHJvYzsKKwl3aGlsZSAoZ2Rlc2MtPnRjZC5nZW4gPT0gdHEtPmNvbXBfcmluZy5nZW4pIHsKKwkJY29tcGxldGVkICs9IHZteG5ldDNfdW5tYXBfcGt0KGdkZXNjLT50Y2QudHhkSWR4LCB0cSwKKwkJCQkJICAgICAgIGFkYXB0ZXItPnBkZXYsIGFkYXB0ZXIpOworCisJCXZteG5ldDNfY29tcF9yaW5nX2Fkdl9uZXh0MnByb2MoJnRxLT5jb21wX3JpbmcpOworCQlnZGVzYyA9IHRxLT5jb21wX3JpbmcuYmFzZSArIHRxLT5jb21wX3JpbmcubmV4dDJwcm9jOworCX0KKworCWlmIChjb21wbGV0ZWQpIHsKKwkJc3Bpbl9sb2NrKCZ0cS0+dHhfbG9jayk7CisJCWlmICh1bmxpa2VseSh2bXhuZXQzX3RxX3N0b3BwZWQodHEsIGFkYXB0ZXIpICYmCisJCQkgICAgIHZteG5ldDNfY21kX3JpbmdfZGVzY19hdmFpbCgmdHEtPnR4X3JpbmcpID4KKwkJCSAgICAgVk1YTkVUM19XQUtFX1FVRVVFX1RIUkVTSE9MRCh0cSkgJiYKKwkJCSAgICAgbmV0aWZfY2Fycmllcl9vayhhZGFwdGVyLT5uZXRkZXYpKSkgeworCQkJdm14bmV0M190cV93YWtlKHRxLCBhZGFwdGVyKTsKKwkJfQorCQlzcGluX3VubG9jaygmdHEtPnR4X2xvY2spOworCX0KKwlyZXR1cm4gY29tcGxldGVkOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX3RxX2NsZWFudXAoc3RydWN0IHZteG5ldDNfdHhfcXVldWUgKnRxLAorCQkgICBzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBpOworCisJd2hpbGUgKHRxLT50eF9yaW5nLm5leHQyY29tcCAhPSB0cS0+dHhfcmluZy5uZXh0MmZpbGwpIHsKKwkJc3RydWN0IHZteG5ldDNfdHhfYnVmX2luZm8gKnRiaTsKKwkJdW5pb24gVm14bmV0M19HZW5lcmljRGVzYyAqZ2Rlc2M7CisKKwkJdGJpID0gdHEtPmJ1Zl9pbmZvICsgdHEtPnR4X3JpbmcubmV4dDJjb21wOworCQlnZGVzYyA9IHRxLT50eF9yaW5nLmJhc2UgKyB0cS0+dHhfcmluZy5uZXh0MmNvbXA7CisKKwkJdm14bmV0M191bm1hcF90eF9idWYodGJpLCBhZGFwdGVyLT5wZGV2KTsKKwkJaWYgKHRiaS0+c2tiKSB7CisJCQlkZXZfa2ZyZWVfc2tiX2FueSh0YmktPnNrYik7CisJCQl0YmktPnNrYiA9IE5VTEw7CisJCX0KKwkJdm14bmV0M19jbWRfcmluZ19hZHZfbmV4dDJjb21wKCZ0cS0+dHhfcmluZyk7CisJfQorCisJLyogc2FuaXR5IGNoZWNrLCB2ZXJpZnkgYWxsIGJ1ZmZlcnMgYXJlIGluZGVlZCB1bm1hcHBlZCBhbmQgZnJlZWQgKi8KKwlmb3IgKGkgPSAwOyBpIDwgdHEtPnR4X3Jpbmcuc2l6ZTsgaSsrKSB7CisJCUJVR19PTih0cS0+YnVmX2luZm9baV0uc2tiICE9IE5VTEwgfHwKKwkJICAgICAgIHRxLT5idWZfaW5mb1tpXS5tYXBfdHlwZSAhPSBWTVhORVQzX01BUF9OT05FKTsKKwl9CisKKwl0cS0+dHhfcmluZy5nZW4gPSBWTVhORVQzX0lOSVRfR0VOOworCXRxLT50eF9yaW5nLm5leHQyZmlsbCA9IHRxLT50eF9yaW5nLm5leHQyY29tcCA9IDA7CisKKwl0cS0+Y29tcF9yaW5nLmdlbiA9IFZNWE5FVDNfSU5JVF9HRU47CisJdHEtPmNvbXBfcmluZy5uZXh0MnByb2MgPSAwOworfQorCisKK3ZvaWQKK3ZteG5ldDNfdHFfZGVzdHJveShzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEsCisJCSAgIHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJaWYgKHRxLT50eF9yaW5nLmJhc2UpIHsKKwkJcGNpX2ZyZWVfY29uc2lzdGVudChhZGFwdGVyLT5wZGV2LCB0cS0+dHhfcmluZy5zaXplICoKKwkJCQkgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1R4RGVzYyksCisJCQkJICAgIHRxLT50eF9yaW5nLmJhc2UsIHRxLT50eF9yaW5nLmJhc2VQQSk7CisJCXRxLT50eF9yaW5nLmJhc2UgPSBOVUxMOworCX0KKwlpZiAodHEtPmRhdGFfcmluZy5iYXNlKSB7CisJCXBjaV9mcmVlX2NvbnNpc3RlbnQoYWRhcHRlci0+cGRldiwgdHEtPmRhdGFfcmluZy5zaXplICoKKwkJCQkgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1R4RGF0YURlc2MpLAorCQkJCSAgICB0cS0+ZGF0YV9yaW5nLmJhc2UsIHRxLT5kYXRhX3JpbmcuYmFzZVBBKTsKKwkJdHEtPmRhdGFfcmluZy5iYXNlID0gTlVMTDsKKwl9CisJaWYgKHRxLT5jb21wX3JpbmcuYmFzZSkgeworCQlwY2lfZnJlZV9jb25zaXN0ZW50KGFkYXB0ZXItPnBkZXYsIHRxLT5jb21wX3Jpbmcuc2l6ZSAqCisJCQkJICAgIHNpemVvZihzdHJ1Y3QgVm14bmV0M19UeENvbXBEZXNjKSwKKwkJCQkgICAgdHEtPmNvbXBfcmluZy5iYXNlLCB0cS0+Y29tcF9yaW5nLmJhc2VQQSk7CisJCXRxLT5jb21wX3JpbmcuYmFzZSA9IE5VTEw7CisJfQorCWtmcmVlKHRxLT5idWZfaW5mbyk7CisJdHEtPmJ1Zl9pbmZvID0gTlVMTDsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M190cV9pbml0KHN0cnVjdCB2bXhuZXQzX3R4X3F1ZXVlICp0cSwKKwkJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwlpbnQgaTsKKworCS8qIHJlc2V0IHRoZSB0eCByaW5nIGNvbnRlbnRzIHRvIDAgYW5kIHJlc2V0IHRoZSB0eCByaW5nIHN0YXRlcyAqLworCW1lbXNldCh0cS0+dHhfcmluZy5iYXNlLCAwLCB0cS0+dHhfcmluZy5zaXplICoKKwkgICAgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1R4RGVzYykpOworCXRxLT50eF9yaW5nLm5leHQyZmlsbCA9IHRxLT50eF9yaW5nLm5leHQyY29tcCA9IDA7CisJdHEtPnR4X3JpbmcuZ2VuID0gVk1YTkVUM19JTklUX0dFTjsKKworCW1lbXNldCh0cS0+ZGF0YV9yaW5nLmJhc2UsIDAsIHRxLT5kYXRhX3Jpbmcuc2l6ZSAqCisJICAgICAgIHNpemVvZihzdHJ1Y3QgVm14bmV0M19UeERhdGFEZXNjKSk7CisKKwkvKiByZXNldCB0aGUgdHggY29tcCByaW5nIGNvbnRlbnRzIHRvIDAgYW5kIHJlc2V0IGNvbXAgcmluZyBzdGF0ZXMgKi8KKwltZW1zZXQodHEtPmNvbXBfcmluZy5iYXNlLCAwLCB0cS0+Y29tcF9yaW5nLnNpemUgKgorCSAgICAgICBzaXplb2Yoc3RydWN0IFZteG5ldDNfVHhDb21wRGVzYykpOworCXRxLT5jb21wX3JpbmcubmV4dDJwcm9jID0gMDsKKwl0cS0+Y29tcF9yaW5nLmdlbiA9IFZNWE5FVDNfSU5JVF9HRU47CisKKwkvKiByZXNldCB0aGUgYm9va2tlZXBpbmcgZGF0YSAqLworCW1lbXNldCh0cS0+YnVmX2luZm8sIDAsIHNpemVvZih0cS0+YnVmX2luZm9bMF0pICogdHEtPnR4X3Jpbmcuc2l6ZSk7CisJZm9yIChpID0gMDsgaSA8IHRxLT50eF9yaW5nLnNpemU7IGkrKykKKwkJdHEtPmJ1Zl9pbmZvW2ldLm1hcF90eXBlID0gVk1YTkVUM19NQVBfTk9ORTsKKworCS8qIHN0YXRzIGFyZSBub3QgcmVzZXQgKi8KK30KKworCitzdGF0aWMgaW50Cit2bXhuZXQzX3RxX2NyZWF0ZShzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEsCisJCSAgc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwlCVUdfT04odHEtPnR4X3JpbmcuYmFzZSB8fCB0cS0+ZGF0YV9yaW5nLmJhc2UgfHwKKwkgICAgICAgdHEtPmNvbXBfcmluZy5iYXNlIHx8IHRxLT5idWZfaW5mbyk7CisKKwl0cS0+dHhfcmluZy5iYXNlID0gcGNpX2FsbG9jX2NvbnNpc3RlbnQoYWRhcHRlci0+cGRldiwgdHEtPnR4X3Jpbmcuc2l6ZQorCQkJICAgKiBzaXplb2Yoc3RydWN0IFZteG5ldDNfVHhEZXNjKSwKKwkJCSAgICZ0cS0+dHhfcmluZy5iYXNlUEEpOworCWlmICghdHEtPnR4X3JpbmcuYmFzZSkgeworCQlwcmludGsoS0VSTl9FUlIgIiVzOiBmYWlsZWQgdG8gYWxsb2NhdGUgdHggcmluZ1xuIiwKKwkJICAgICAgIGFkYXB0ZXItPm5ldGRldi0+bmFtZSk7CisJCWdvdG8gZXJyOworCX0KKworCXRxLT5kYXRhX3JpbmcuYmFzZSA9IHBjaV9hbGxvY19jb25zaXN0ZW50KGFkYXB0ZXItPnBkZXYsCisJCQkgICAgIHRxLT5kYXRhX3Jpbmcuc2l6ZSAqCisJCQkgICAgIHNpemVvZihzdHJ1Y3QgVm14bmV0M19UeERhdGFEZXNjKSwKKwkJCSAgICAgJnRxLT5kYXRhX3JpbmcuYmFzZVBBKTsKKwlpZiAoIXRxLT5kYXRhX3JpbmcuYmFzZSkgeworCQlwcmludGsoS0VSTl9FUlIgIiVzOiBmYWlsZWQgdG8gYWxsb2NhdGUgZGF0YSByaW5nXG4iLAorCQkgICAgICAgYWRhcHRlci0+bmV0ZGV2LT5uYW1lKTsKKwkJZ290byBlcnI7CisJfQorCisJdHEtPmNvbXBfcmluZy5iYXNlID0gcGNpX2FsbG9jX2NvbnNpc3RlbnQoYWRhcHRlci0+cGRldiwKKwkJCSAgICAgdHEtPmNvbXBfcmluZy5zaXplICoKKwkJCSAgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1R4Q29tcERlc2MpLAorCQkJICAgICAmdHEtPmNvbXBfcmluZy5iYXNlUEEpOworCWlmICghdHEtPmNvbXBfcmluZy5iYXNlKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXM6IGZhaWxlZCB0byBhbGxvY2F0ZSB0eCBjb21wIHJpbmdcbiIsCisJCSAgICAgICBhZGFwdGVyLT5uZXRkZXYtPm5hbWUpOworCQlnb3RvIGVycjsKKwl9CisKKwl0cS0+YnVmX2luZm8gPSBrY2FsbG9jKHRxLT50eF9yaW5nLnNpemUsIHNpemVvZih0cS0+YnVmX2luZm9bMF0pLAorCQkJICAgICAgIEdGUF9LRVJORUwpOworCWlmICghdHEtPmJ1Zl9pbmZvKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXM6IGZhaWxlZCB0byBhbGxvY2F0ZSB0eCBidWZpbmZvXG4iLAorCQkgICAgICAgYWRhcHRlci0+bmV0ZGV2LT5uYW1lKTsKKwkJZ290byBlcnI7CisJfQorCisJcmV0dXJuIDA7CisKK2VycjoKKwl2bXhuZXQzX3RxX2Rlc3Ryb3kodHEsIGFkYXB0ZXIpOworCXJldHVybiAtRU5PTUVNOworfQorCisKKy8qCisgKiAgICBzdGFydGluZyBmcm9tIHJpbmctPm5leHQyZmlsbCwgYWxsb2NhdGUgcnggYnVmZmVycyBmb3IgdGhlIGdpdmVuIHJpbmcKKyAqICAgIG9mIHRoZSByeCBxdWV1ZSBhbmQgdXBkYXRlIHRoZSByeCBkZXNjLiBzdG9wIGFmdGVyIEBudW1fdG9fYWxsb2MgYnVmZmVycworICogICAgYXJlIGFsbG9jYXRlZCBvciBhbGxvY2F0aW9uIGZhaWxzCisgKi8KKworc3RhdGljIGludAordm14bmV0M19ycV9hbGxvY19yeF9idWYoc3RydWN0IHZteG5ldDNfcnhfcXVldWUgKnJxLCB1MzIgcmluZ19pZHgsCisJCQlpbnQgbnVtX3RvX2FsbG9jLCBzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBudW1fYWxsb2NhdGVkID0gMDsKKwlzdHJ1Y3Qgdm14bmV0M19yeF9idWZfaW5mbyAqcmJpX2Jhc2UgPSBycS0+YnVmX2luZm9bcmluZ19pZHhdOworCXN0cnVjdCB2bXhuZXQzX2NtZF9yaW5nICpyaW5nID0gJnJxLT5yeF9yaW5nW3JpbmdfaWR4XTsKKwl1MzIgdmFsOworCisJd2hpbGUgKG51bV9hbGxvY2F0ZWQgPCBudW1fdG9fYWxsb2MpIHsKKwkJc3RydWN0IHZteG5ldDNfcnhfYnVmX2luZm8gKnJiaTsKKwkJdW5pb24gVm14bmV0M19HZW5lcmljRGVzYyAqZ2Q7CisKKwkJcmJpID0gcmJpX2Jhc2UgKyByaW5nLT5uZXh0MmZpbGw7CisJCWdkID0gcmluZy0+YmFzZSArIHJpbmctPm5leHQyZmlsbDsKKworCQlpZiAocmJpLT5idWZfdHlwZSA9PSBWTVhORVQzX1JYX0JVRl9TS0IpIHsKKwkJCWlmIChyYmktPnNrYiA9PSBOVUxMKSB7CisJCQkJcmJpLT5za2IgPSBkZXZfYWxsb2Nfc2tiKHJiaS0+bGVuICsKKwkJCQkJCQkgTkVUX0lQX0FMSUdOKTsKKwkJCQlpZiAodW5saWtlbHkocmJpLT5za2IgPT0gTlVMTCkpIHsKKwkJCQkJcnEtPnN0YXRzLnJ4X2J1Zl9hbGxvY19mYWlsdXJlKys7CisJCQkJCWJyZWFrOworCQkJCX0KKwkJCQlyYmktPnNrYi0+ZGV2ID0gYWRhcHRlci0+bmV0ZGV2OworCisJCQkJc2tiX3Jlc2VydmUocmJpLT5za2IsIE5FVF9JUF9BTElHTik7CisJCQkJcmJpLT5kbWFfYWRkciA9IHBjaV9tYXBfc2luZ2xlKGFkYXB0ZXItPnBkZXYsCisJCQkJCQlyYmktPnNrYi0+ZGF0YSwgcmJpLT5sZW4sCisJCQkJCQlQQ0lfRE1BX0ZST01ERVZJQ0UpOworCQkJfSBlbHNlIHsKKwkJCQkvKiByeCBidWZmZXIgc2tpcHBlZCBieSB0aGUgZGV2aWNlICovCisJCQl9CisJCQl2YWwgPSBWTVhORVQzX1JYRF9CVFlQRV9IRUFEIDw8IFZNWE5FVDNfUlhEX0JUWVBFX1NISUZUOworCQl9IGVsc2UgeworCQkJQlVHX09OKHJiaS0+YnVmX3R5cGUgIT0gVk1YTkVUM19SWF9CVUZfUEFHRSB8fAorCQkJICAgICAgIHJiaS0+bGVuICAhPSBQQUdFX1NJWkUpOworCisJCQlpZiAocmJpLT5wYWdlID09IE5VTEwpIHsKKwkJCQlyYmktPnBhZ2UgPSBhbGxvY19wYWdlKEdGUF9BVE9NSUMpOworCQkJCWlmICh1bmxpa2VseShyYmktPnBhZ2UgPT0gTlVMTCkpIHsKKwkJCQkJcnEtPnN0YXRzLnJ4X2J1Zl9hbGxvY19mYWlsdXJlKys7CisJCQkJCWJyZWFrOworCQkJCX0KKwkJCQlyYmktPmRtYV9hZGRyID0gcGNpX21hcF9wYWdlKGFkYXB0ZXItPnBkZXYsCisJCQkJCQlyYmktPnBhZ2UsIDAsIFBBR0VfU0laRSwKKwkJCQkJCVBDSV9ETUFfRlJPTURFVklDRSk7CisJCQl9IGVsc2UgeworCQkJCS8qIHJ4IGJ1ZmZlcnMgc2tpcHBlZCBieSB0aGUgZGV2aWNlICovCisJCQl9CisJCQl2YWwgPSBWTVhORVQzX1JYRF9CVFlQRV9CT0RZIDw8IFZNWE5FVDNfUlhEX0JUWVBFX1NISUZUOworCQl9CisKKwkJQlVHX09OKHJiaS0+ZG1hX2FkZHIgPT0gMCk7CisJCWdkLT5yeGQuYWRkciA9IHJiaS0+ZG1hX2FkZHI7CisJCWdkLT5kd29yZFsyXSA9IChyaW5nLT5nZW4gPDwgVk1YTkVUM19SWERfR0VOX1NISUZUKSB8IHZhbCB8CisJCQkJcmJpLT5sZW47CisKKwkJbnVtX2FsbG9jYXRlZCsrOworCQl2bXhuZXQzX2NtZF9yaW5nX2Fkdl9uZXh0MmZpbGwocmluZyk7CisJfQorCXJxLT51bmNvbW1pdHRlZFtyaW5nX2lkeF0gKz0gbnVtX2FsbG9jYXRlZDsKKworCWRldl9kYmcoJmFkYXB0ZXItPm5ldGRldi0+ZGV2LAorCQkiYWxsb2NfcnhfYnVmOiAlZCBhbGxvY2F0ZWQsIG5leHQyZmlsbCAldSwgbmV4dDJjb21wICIKKwkJIiV1LCB1bmNvbW1pdGVkICV1XG4iLCBudW1fYWxsb2NhdGVkLCByaW5nLT5uZXh0MmZpbGwsCisJCXJpbmctPm5leHQyY29tcCwgcnEtPnVuY29tbWl0dGVkW3JpbmdfaWR4XSk7CisKKwkvKiBzbyB0aGF0IHRoZSBkZXZpY2UgY2FuIGRpc3Rpbmd1aXNoIGEgZnVsbCByaW5nIGFuZCBhbiBlbXB0eSByaW5nICovCisJQlVHX09OKG51bV9hbGxvY2F0ZWQgIT0gMCAmJiByaW5nLT5uZXh0MmZpbGwgPT0gcmluZy0+bmV4dDJjb21wKTsKKworCXJldHVybiBudW1fYWxsb2NhdGVkOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX2FwcGVuZF9mcmFnKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCBWbXhuZXQzX1J4Q29tcERlc2MgKnJjZCwKKwkJICAgIHN0cnVjdCB2bXhuZXQzX3J4X2J1Zl9pbmZvICpyYmkpCit7CisJc3RydWN0IHNrYl9mcmFnX3N0cnVjdCAqZnJhZyA9IHNrYl9zaGluZm8oc2tiKS0+ZnJhZ3MgKworCQlza2Jfc2hpbmZvKHNrYiktPm5yX2ZyYWdzOworCisJQlVHX09OKHNrYl9zaGluZm8oc2tiKS0+bnJfZnJhZ3MgPj0gTUFYX1NLQl9GUkFHUyk7CisKKwlmcmFnLT5wYWdlID0gcmJpLT5wYWdlOworCWZyYWctPnBhZ2Vfb2Zmc2V0ID0gMDsKKwlmcmFnLT5zaXplID0gcmNkLT5sZW47CisJc2tiLT5kYXRhX2xlbiArPSBmcmFnLT5zaXplOworCXNrYl9zaGluZm8oc2tiKS0+bnJfZnJhZ3MrKzsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19tYXBfcGt0KHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCB2bXhuZXQzX3R4X2N0eCAqY3R4LAorCQlzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEsIHN0cnVjdCBwY2lfZGV2ICpwZGV2LAorCQlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCXUzMiBkdzIsIGxlbjsKKwl1bnNpZ25lZCBsb25nIGJ1Zl9vZmZzZXQ7CisJaW50IGk7CisJdW5pb24gVm14bmV0M19HZW5lcmljRGVzYyAqZ2Rlc2M7CisJc3RydWN0IHZteG5ldDNfdHhfYnVmX2luZm8gKnRiaSA9IE5VTEw7CisKKwlCVUdfT04oY3R4LT5jb3B5X3NpemUgPiBza2JfaGVhZGxlbihza2IpKTsKKworCS8qIHVzZSB0aGUgcHJldmlvdXMgZ2VuIGJpdCBmb3IgdGhlIFNPUCBkZXNjICovCisJZHcyID0gKHRxLT50eF9yaW5nLmdlbiBeIDB4MSkgPDwgVk1YTkVUM19UWERfR0VOX1NISUZUOworCisJY3R4LT5zb3BfdHhkID0gdHEtPnR4X3JpbmcuYmFzZSArIHRxLT50eF9yaW5nLm5leHQyZmlsbDsKKwlnZGVzYyA9IGN0eC0+c29wX3R4ZDsgLyogYm90aCBsb29wcyBiZWxvdyBjYW4gYmUgc2tpcHBlZCAqLworCisJLyogbm8gbmVlZCB0byBtYXAgdGhlIGJ1ZmZlciBpZiBoZWFkZXJzIGFyZSBjb3BpZWQgKi8KKwlpZiAoY3R4LT5jb3B5X3NpemUpIHsKKwkJY3R4LT5zb3BfdHhkLT50eGQuYWRkciA9IHRxLT5kYXRhX3JpbmcuYmFzZVBBICsKKwkJCQkJdHEtPnR4X3JpbmcubmV4dDJmaWxsICoKKwkJCQkJc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1R4RGF0YURlc2MpOworCQljdHgtPnNvcF90eGQtPmR3b3JkWzJdID0gZHcyIHwgY3R4LT5jb3B5X3NpemU7CisJCWN0eC0+c29wX3R4ZC0+ZHdvcmRbM10gPSAwOworCisJCXRiaSA9IHRxLT5idWZfaW5mbyArIHRxLT50eF9yaW5nLm5leHQyZmlsbDsKKwkJdGJpLT5tYXBfdHlwZSA9IFZNWE5FVDNfTUFQX05PTkU7CisKKwkJZGV2X2RiZygmYWRhcHRlci0+bmV0ZGV2LT5kZXYsCisJCQkidHhkWyV1XTogMHglTHggMHgleCAweCV4XG4iLAorCQkJdHEtPnR4X3JpbmcubmV4dDJmaWxsLCBjdHgtPnNvcF90eGQtPnR4ZC5hZGRyLAorCQkJY3R4LT5zb3BfdHhkLT5kd29yZFsyXSwgY3R4LT5zb3BfdHhkLT5kd29yZFszXSk7CisJCXZteG5ldDNfY21kX3JpbmdfYWR2X25leHQyZmlsbCgmdHEtPnR4X3JpbmcpOworCisJCS8qIHVzZSB0aGUgcmlnaHQgZ2VuIGZvciBub24tU09QIGRlc2MgKi8KKwkJZHcyID0gdHEtPnR4X3JpbmcuZ2VuIDw8IFZNWE5FVDNfVFhEX0dFTl9TSElGVDsKKwl9CisKKwkvKiBsaW5lYXIgcGFydCBjYW4gdXNlIG11bHRpcGxlIHR4IGRlc2MgaWYgaXQncyBiaWcgKi8KKwlsZW4gPSBza2JfaGVhZGxlbihza2IpIC0gY3R4LT5jb3B5X3NpemU7CisJYnVmX29mZnNldCA9IGN0eC0+Y29weV9zaXplOworCXdoaWxlIChsZW4pIHsKKwkJdTMyIGJ1Zl9zaXplOworCisJCWJ1Zl9zaXplID0gbGVuID4gVk1YTkVUM19NQVhfVFhfQlVGX1NJWkUgPworCQkJICAgVk1YTkVUM19NQVhfVFhfQlVGX1NJWkUgOiBsZW47CisKKwkJdGJpID0gdHEtPmJ1Zl9pbmZvICsgdHEtPnR4X3JpbmcubmV4dDJmaWxsOworCQl0YmktPm1hcF90eXBlID0gVk1YTkVUM19NQVBfU0lOR0xFOworCQl0YmktPmRtYV9hZGRyID0gcGNpX21hcF9zaW5nbGUoYWRhcHRlci0+cGRldiwKKwkJCQlza2ItPmRhdGEgKyBidWZfb2Zmc2V0LCBidWZfc2l6ZSwKKwkJCQlQQ0lfRE1BX1RPREVWSUNFKTsKKworCQl0YmktPmxlbiA9IGJ1Zl9zaXplOyAvKiB0aGlzIGF1dG9tYXRpY2FsbHkgY29udmVydCAyXjE0IHRvIDAgKi8KKworCQlnZGVzYyA9IHRxLT50eF9yaW5nLmJhc2UgKyB0cS0+dHhfcmluZy5uZXh0MmZpbGw7CisJCUJVR19PTihnZGVzYy0+dHhkLmdlbiA9PSB0cS0+dHhfcmluZy5nZW4pOworCisJCWdkZXNjLT50eGQuYWRkciA9IHRiaS0+ZG1hX2FkZHI7CisJCWdkZXNjLT5kd29yZFsyXSA9IGR3MiB8IGJ1Zl9zaXplOworCQlnZGVzYy0+ZHdvcmRbM10gPSAwOworCisJCWRldl9kYmcoJmFkYXB0ZXItPm5ldGRldi0+ZGV2LAorCQkJInR4ZFsldV06IDB4JUx4IDB4JXggMHgleFxuIiwKKwkJCXRxLT50eF9yaW5nLm5leHQyZmlsbCwgZ2Rlc2MtPnR4ZC5hZGRyLAorCQkJZ2Rlc2MtPmR3b3JkWzJdLCBnZGVzYy0+ZHdvcmRbM10pOworCQl2bXhuZXQzX2NtZF9yaW5nX2Fkdl9uZXh0MmZpbGwoJnRxLT50eF9yaW5nKTsKKwkJZHcyID0gdHEtPnR4X3JpbmcuZ2VuIDw8IFZNWE5FVDNfVFhEX0dFTl9TSElGVDsKKworCQlsZW4gLT0gYnVmX3NpemU7CisJCWJ1Zl9vZmZzZXQgKz0gYnVmX3NpemU7CisJfQorCisJZm9yIChpID0gMDsgaSA8IHNrYl9zaGluZm8oc2tiKS0+bnJfZnJhZ3M7IGkrKykgeworCQlzdHJ1Y3Qgc2tiX2ZyYWdfc3RydWN0ICpmcmFnID0gJnNrYl9zaGluZm8oc2tiKS0+ZnJhZ3NbaV07CisKKwkJdGJpID0gdHEtPmJ1Zl9pbmZvICsgdHEtPnR4X3JpbmcubmV4dDJmaWxsOworCQl0YmktPm1hcF90eXBlID0gVk1YTkVUM19NQVBfUEFHRTsKKwkJdGJpLT5kbWFfYWRkciA9IHBjaV9tYXBfcGFnZShhZGFwdGVyLT5wZGV2LCBmcmFnLT5wYWdlLAorCQkJCQkgICAgIGZyYWctPnBhZ2Vfb2Zmc2V0LCBmcmFnLT5zaXplLAorCQkJCQkgICAgIFBDSV9ETUFfVE9ERVZJQ0UpOworCisJCXRiaS0+bGVuID0gZnJhZy0+c2l6ZTsKKworCQlnZGVzYyA9IHRxLT50eF9yaW5nLmJhc2UgKyB0cS0+dHhfcmluZy5uZXh0MmZpbGw7CisJCUJVR19PTihnZGVzYy0+dHhkLmdlbiA9PSB0cS0+dHhfcmluZy5nZW4pOworCisJCWdkZXNjLT50eGQuYWRkciA9IHRiaS0+ZG1hX2FkZHI7CisJCWdkZXNjLT5kd29yZFsyXSA9IGR3MiB8IGZyYWctPnNpemU7CisJCWdkZXNjLT5kd29yZFszXSA9IDA7CisKKwkJZGV2X2RiZygmYWRhcHRlci0+bmV0ZGV2LT5kZXYsCisJCQkidHhkWyV1XTogMHglbGx1ICV1ICV1XG4iLAorCQkJdHEtPnR4X3JpbmcubmV4dDJmaWxsLCBnZGVzYy0+dHhkLmFkZHIsCisJCQlnZGVzYy0+ZHdvcmRbMl0sIGdkZXNjLT5kd29yZFszXSk7CisJCXZteG5ldDNfY21kX3JpbmdfYWR2X25leHQyZmlsbCgmdHEtPnR4X3JpbmcpOworCQlkdzIgPSB0cS0+dHhfcmluZy5nZW4gPDwgVk1YTkVUM19UWERfR0VOX1NISUZUOworCX0KKworCWN0eC0+ZW9wX3R4ZCA9IGdkZXNjOworCisJLyogc2V0IHRoZSBsYXN0IGJ1Zl9pbmZvIGZvciB0aGUgcGt0ICovCisJdGJpLT5za2IgPSBza2I7CisJdGJpLT5zb3BfaWR4ID0gY3R4LT5zb3BfdHhkIC0gdHEtPnR4X3JpbmcuYmFzZTsKK30KKworCisvKgorICogICAgcGFyc2UgYW5kIGNvcHkgcmVsZXZhbnQgcHJvdG9jb2wgaGVhZGVyczoKKyAqICAgICAgRm9yIGEgdHNvIHBrdCwgcmVsZXZhbnQgaGVhZGVycyBhcmUgTDIvMy80IGluY2x1ZGluZyBvcHRpb25zCisgKiAgICAgIEZvciBhIHBrdCByZXF1ZXN0aW5nIGNzdW0gb2ZmbG9hZGluZywgdGhleSBhcmUgTDIvMyBhbmQgbWF5IGluY2x1ZGUgTDQKKyAqICAgICAgaWYgaXQncyBhIFRDUC9VRFAgcGt0CisgKgorICogUmV0dXJuczoKKyAqICAgIC0xOiAgZXJyb3IgaGFwcGVucyBkdXJpbmcgcGFyc2luZworICogICAgIDA6ICBwcm90b2NvbCBoZWFkZXJzIHBhcnNlZCwgYnV0IHRvbyBiaWcgdG8gYmUgY29waWVkCisgKiAgICAgMTogIHByb3RvY29sIGhlYWRlcnMgcGFyc2VkIGFuZCBjb3BpZWQKKyAqCisgKiBPdGhlciBlZmZlY3RzOgorICogICAgMS4gcmVsYXRlZCAqY3R4IGZpZWxkcyBhcmUgdXBkYXRlZC4KKyAqICAgIDIuIGN0eC0+Y29weV9zaXplIGlzICMgb2YgYnl0ZXMgY29waWVkCisgKiAgICAzLiB0aGUgcG9ydGlvbiBjb3BpZWQgaXMgZ3VhcmFudGVlZCB0byBiZSBpbiB0aGUgbGluZWFyIHBhcnQKKyAqCisgKi8KK3N0YXRpYyBpbnQKK3ZteG5ldDNfcGFyc2VfYW5kX2NvcHlfaGRyKHN0cnVjdCBza19idWZmICpza2IsIHN0cnVjdCB2bXhuZXQzX3R4X3F1ZXVlICp0cSwKKwkJCSAgIHN0cnVjdCB2bXhuZXQzX3R4X2N0eCAqY3R4LAorCQkJICAgc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwlzdHJ1Y3QgVm14bmV0M19UeERhdGFEZXNjICp0ZGQ7CisKKwlpZiAoY3R4LT5tc3MpIHsKKwkJY3R4LT5ldGhfaXBfaGRyX3NpemUgPSBza2JfdHJhbnNwb3J0X29mZnNldChza2IpOworCQljdHgtPmw0X2hkcl9zaXplID0gKChzdHJ1Y3QgdGNwaGRyICopCisJCQkJICAgc2tiX3RyYW5zcG9ydF9oZWFkZXIoc2tiKSktPmRvZmYgKiA0OworCQljdHgtPmNvcHlfc2l6ZSA9IGN0eC0+ZXRoX2lwX2hkcl9zaXplICsgY3R4LT5sNF9oZHJfc2l6ZTsKKwl9IGVsc2UgeworCQl1bnNpZ25lZCBpbnQgcHVsbF9zaXplOworCisJCWlmIChza2ItPmlwX3N1bW1lZCA9PSBDSEVDS1NVTV9QQVJUSUFMKSB7CisJCQljdHgtPmV0aF9pcF9oZHJfc2l6ZSA9IHNrYl90cmFuc3BvcnRfb2Zmc2V0KHNrYik7CisKKwkJCWlmIChjdHgtPmlwdjQpIHsKKwkJCQlzdHJ1Y3QgaXBoZHIgKmlwaCA9IChzdHJ1Y3QgaXBoZHIgKikKKwkJCQkJCSAgICBza2JfbmV0d29ya19oZWFkZXIoc2tiKTsKKwkJCQlpZiAoaXBoLT5wcm90b2NvbCA9PSBJUFBST1RPX1RDUCkgeworCQkJCQlwdWxsX3NpemUgPSBjdHgtPmV0aF9pcF9oZHJfc2l6ZSArCisJCQkJCQkgICAgc2l6ZW9mKHN0cnVjdCB0Y3BoZHIpOworCisJCQkJCWlmICh1bmxpa2VseSghcHNrYl9tYXlfcHVsbChza2IsCisJCQkJCQkJCXB1bGxfc2l6ZSkpKSB7CisJCQkJCQlnb3RvIGVycjsKKwkJCQkJfQorCQkJCQljdHgtPmw0X2hkcl9zaXplID0gKChzdHJ1Y3QgdGNwaGRyICopCisJCQkJCSAgIHNrYl90cmFuc3BvcnRfaGVhZGVyKHNrYikpLT5kb2ZmICogNDsKKwkJCQl9IGVsc2UgaWYgKGlwaC0+cHJvdG9jb2wgPT0gSVBQUk9UT19VRFApIHsKKwkJCQkJY3R4LT5sNF9oZHJfc2l6ZSA9CisJCQkJCQkJc2l6ZW9mKHN0cnVjdCB1ZHBoZHIpOworCQkJCX0gZWxzZSB7CisJCQkJCWN0eC0+bDRfaGRyX3NpemUgPSAwOworCQkJCX0KKwkJCX0gZWxzZSB7CisJCQkJLyogZm9yIHNpbXBsaWNpdHksIGRvbid0IGNvcHkgTDQgaGVhZGVycyAqLworCQkJCWN0eC0+bDRfaGRyX3NpemUgPSAwOworCQkJfQorCQkJY3R4LT5jb3B5X3NpemUgPSBjdHgtPmV0aF9pcF9oZHJfc2l6ZSArCisJCQkJCSBjdHgtPmw0X2hkcl9zaXplOworCQl9IGVsc2UgeworCQkJY3R4LT5ldGhfaXBfaGRyX3NpemUgPSAwOworCQkJY3R4LT5sNF9oZHJfc2l6ZSA9IDA7CisJCQkvKiBjb3B5IGFzIG11Y2ggYXMgYWxsb3dlZCAqLworCQkJY3R4LT5jb3B5X3NpemUgPSBtaW4oKHVuc2lnbmVkIGludClWTVhORVQzX0hEUl9DT1BZX1NJWkUKKwkJCQkJICAgICAsIHNrYl9oZWFkbGVuKHNrYikpOworCQl9CisKKwkJLyogbWFrZSBzdXJlIGhlYWRlcnMgYXJlIGFjY2Vzc2libGUgZGlyZWN0bHkgKi8KKwkJaWYgKHVubGlrZWx5KCFwc2tiX21heV9wdWxsKHNrYiwgY3R4LT5jb3B5X3NpemUpKSkKKwkJCWdvdG8gZXJyOworCX0KKworCWlmICh1bmxpa2VseShjdHgtPmNvcHlfc2l6ZSA+IFZNWE5FVDNfSERSX0NPUFlfU0laRSkpIHsKKwkJdHEtPnN0YXRzLm92ZXJzaXplZF9oZHIrKzsKKwkJY3R4LT5jb3B5X3NpemUgPSAwOworCQlyZXR1cm4gMDsKKwl9CisKKwl0ZGQgPSB0cS0+ZGF0YV9yaW5nLmJhc2UgKyB0cS0+dHhfcmluZy5uZXh0MmZpbGw7CisKKwltZW1jcHkodGRkLT5kYXRhLCBza2ItPmRhdGEsIGN0eC0+Y29weV9zaXplKTsKKwlkZXZfZGJnKCZhZGFwdGVyLT5uZXRkZXYtPmRldiwKKwkJImNvcHkgJXUgYnl0ZXMgdG8gZGF0YVJpbmdbJXVdXG4iLAorCQljdHgtPmNvcHlfc2l6ZSwgdHEtPnR4X3JpbmcubmV4dDJmaWxsKTsKKwlyZXR1cm4gMTsKKworZXJyOgorCXJldHVybiAtMTsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19wcmVwYXJlX3RzbyhzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAorCQkgICAgc3RydWN0IHZteG5ldDNfdHhfY3R4ICpjdHgpCit7CisJc3RydWN0IHRjcGhkciAqdGNwaCA9IChzdHJ1Y3QgdGNwaGRyICopc2tiX3RyYW5zcG9ydF9oZWFkZXIoc2tiKTsKKwlpZiAoY3R4LT5pcHY0KSB7CisJCXN0cnVjdCBpcGhkciAqaXBoID0gKHN0cnVjdCBpcGhkciAqKXNrYl9uZXR3b3JrX2hlYWRlcihza2IpOworCQlpcGgtPmNoZWNrID0gMDsKKwkJdGNwaC0+Y2hlY2sgPSB+Y3N1bV90Y3B1ZHBfbWFnaWMoaXBoLT5zYWRkciwgaXBoLT5kYWRkciwgMCwKKwkJCQkJCSBJUFBST1RPX1RDUCwgMCk7CisJfSBlbHNlIHsKKwkJc3RydWN0IGlwdjZoZHIgKmlwaCA9IChzdHJ1Y3QgaXB2NmhkciAqKXNrYl9uZXR3b3JrX2hlYWRlcihza2IpOworCQl0Y3BoLT5jaGVjayA9IH5jc3VtX2lwdjZfbWFnaWMoJmlwaC0+c2FkZHIsICZpcGgtPmRhZGRyLCAwLAorCQkJCQkgICAgICAgSVBQUk9UT19UQ1AsIDApOworCX0KK30KKworCisvKgorICogVHJhbnNtaXRzIGEgcGt0IHRocnUgYSBnaXZlbiB0cQorICogUmV0dXJuczoKKyAqICAgIE5FVERFVl9UWF9PSzogICAgICBkZXNjcmlwdG9ycyBhcmUgc2V0dXAgc3VjY2Vzc2Z1bGx5CisgKiAgICBORVRERVZfVFhfT0s6ICAgICAgZXJyb3Igb2NjdXJlZCwgdGhlIHBrdCBpcyBkcm9wcGVkCisgKiAgICBORVRERVZfVFhfQlVTWTogICAgdHggcmluZyBpcyBmdWxsLCBxdWV1ZSBpcyBzdG9wcGVkCisgKgorICogU2lkZS1lZmZlY3RzOgorICogICAgMS4gdHggcmluZyBtYXkgYmUgY2hhbmdlZAorICogICAgMi4gdHEgc3RhdHMgbWF5IGJlIHVwZGF0ZWQgYWNjb3JkaW5nbHkKKyAqICAgIDMuIHNoYXJlZC0+dHhOdW1EZWZlcnJlZCBtYXkgYmUgdXBkYXRlZAorICovCisKK3N0YXRpYyBpbnQKK3ZteG5ldDNfdHFfeG1pdChzdHJ1Y3Qgc2tfYnVmZiAqc2tiLCBzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEsCisJCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIsIHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYpCit7CisJaW50IHJldDsKKwl1MzIgY291bnQ7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3Qgdm14bmV0M190eF9jdHggY3R4OworCXVuaW9uIFZteG5ldDNfR2VuZXJpY0Rlc2MgKmdkZXNjOworCisJLyogY29uc2VydmF0aXZlbHkgZXN0aW1hdGUgIyBvZiBkZXNjcmlwdG9ycyB0byB1c2UgKi8KKwljb3VudCA9IFZNWE5FVDNfVFhEX05FRURFRChza2JfaGVhZGxlbihza2IpKSArCisJCXNrYl9zaGluZm8oc2tiKS0+bnJfZnJhZ3MgKyAxOworCisJY3R4LmlwdjQgPSAoc2tiLT5wcm90b2NvbCA9PSBfX2NvbnN0YW50X250b2hzKEVUSF9QX0lQKSk7CisKKwljdHgubXNzID0gc2tiX3NoaW5mbyhza2IpLT5nc29fc2l6ZTsKKwlpZiAoY3R4Lm1zcykgeworCQlpZiAoc2tiX2hlYWRlcl9jbG9uZWQoc2tiKSkgeworCQkJaWYgKHVubGlrZWx5KHBza2JfZXhwYW5kX2hlYWQoc2tiLCAwLCAwLAorCQkJCQkJICAgICAgR0ZQX0FUT01JQykgIT0gMCkpIHsKKwkJCQl0cS0+c3RhdHMuZHJvcF90c28rKzsKKwkJCQlnb3RvIGRyb3BfcGt0OworCQkJfQorCQkJdHEtPnN0YXRzLmNvcHlfc2tiX2hlYWRlcisrOworCQl9CisJCXZteG5ldDNfcHJlcGFyZV90c28oc2tiLCAmY3R4KTsKKwl9IGVsc2UgeworCQlpZiAodW5saWtlbHkoY291bnQgPiBWTVhORVQzX01BWF9UWERfUEVSX1BLVCkpIHsKKworCQkJLyogbm9uLXRzbyBwa3RzIG11c3Qgbm90IHVzZSBtb3JlIHRoYW4KKwkJCSAqIFZNWE5FVDNfTUFYX1RYRF9QRVJfUEtUIGVudHJpZXMKKwkJCSAqLworCQkJaWYgKHNrYl9saW5lYXJpemUoc2tiKSAhPSAwKSB7CisJCQkJdHEtPnN0YXRzLmRyb3BfdG9vX21hbnlfZnJhZ3MrKzsKKwkJCQlnb3RvIGRyb3BfcGt0OworCQkJfQorCQkJdHEtPnN0YXRzLmxpbmVhcml6ZWQrKzsKKworCQkJLyogcmVjYWxjdWxhdGUgdGhlICMgb2YgZGVzY3JpcHRvcnMgdG8gdXNlICovCisJCQljb3VudCA9IFZNWE5FVDNfVFhEX05FRURFRChza2JfaGVhZGxlbihza2IpKSArIDE7CisJCX0KKwl9CisKKwlyZXQgPSB2bXhuZXQzX3BhcnNlX2FuZF9jb3B5X2hkcihza2IsIHRxLCAmY3R4LCBhZGFwdGVyKTsKKwlpZiAocmV0ID49IDApIHsKKwkJQlVHX09OKHJldCA8PSAwICYmIGN0eC5jb3B5X3NpemUgIT0gMCk7CisJCS8qIGhkcnMgcGFyc2VkLCBjaGVjayBhZ2FpbnN0IG90aGVyIGxpbWl0cyAqLworCQlpZiAoY3R4Lm1zcykgeworCQkJaWYgKHVubGlrZWx5KGN0eC5ldGhfaXBfaGRyX3NpemUgKyBjdHgubDRfaGRyX3NpemUgPgorCQkJCSAgICAgVk1YTkVUM19NQVhfVFhfQlVGX1NJWkUpKSB7CisJCQkJZ290byBoZHJfdG9vX2JpZzsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCWlmIChza2ItPmlwX3N1bW1lZCA9PSBDSEVDS1NVTV9QQVJUSUFMKSB7CisJCQkJaWYgKHVubGlrZWx5KGN0eC5ldGhfaXBfaGRyX3NpemUgKworCQkJCQkgICAgIHNrYi0+Y3N1bV9vZmZzZXQgPgorCQkJCQkgICAgIFZNWE5FVDNfTUFYX0NTVU1fT0ZGU0VUKSkgeworCQkJCQlnb3RvIGhkcl90b29fYmlnOworCQkJCX0KKwkJCX0KKwkJfQorCX0gZWxzZSB7CisJCXRxLT5zdGF0cy5kcm9wX2hkcl9pbnNwZWN0X2VycisrOworCQlnb3RvIGRyb3BfcGt0OworCX0KKworCXNwaW5fbG9ja19pcnFzYXZlKCZ0cS0+dHhfbG9jaywgZmxhZ3MpOworCisJaWYgKGNvdW50ID4gdm14bmV0M19jbWRfcmluZ19kZXNjX2F2YWlsKCZ0cS0+dHhfcmluZykpIHsKKwkJdHEtPnN0YXRzLnR4X3JpbmdfZnVsbCsrOworCQlkZXZfZGJnKCZhZGFwdGVyLT5uZXRkZXYtPmRldiwKKwkJCSJ0eCBxdWV1ZSBzdG9wcGVkIG9uICVzLCBuZXh0MmNvbXAgJXUiCisJCQkiIG5leHQyZmlsbCAldVxuIiwgYWRhcHRlci0+bmV0ZGV2LT5uYW1lLAorCQkJdHEtPnR4X3JpbmcubmV4dDJjb21wLCB0cS0+dHhfcmluZy5uZXh0MmZpbGwpOworCisJCXZteG5ldDNfdHFfc3RvcCh0cSwgYWRhcHRlcik7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnRxLT50eF9sb2NrLCBmbGFncyk7CisJCXJldHVybiBORVRERVZfVFhfQlVTWTsKKwl9CisKKwkvKiBmaWxsIHR4IGRlc2NzIHJlbGF0ZWQgdG8gYWRkciAmIGxlbiAqLworCXZteG5ldDNfbWFwX3BrdChza2IsICZjdHgsIHRxLCBhZGFwdGVyLT5wZGV2LCBhZGFwdGVyKTsKKworCS8qIHNldHVwIHRoZSBFT1AgZGVzYyAqLworCWN0eC5lb3BfdHhkLT5kd29yZFszXSA9IFZNWE5FVDNfVFhEX0NRIHwgVk1YTkVUM19UWERfRU9QOworCisJLyogc2V0dXAgdGhlIFNPUCBkZXNjICovCisJZ2Rlc2MgPSBjdHguc29wX3R4ZDsKKwlpZiAoY3R4Lm1zcykgeworCQlnZGVzYy0+dHhkLmhsZW4gPSBjdHguZXRoX2lwX2hkcl9zaXplICsgY3R4Lmw0X2hkcl9zaXplOworCQlnZGVzYy0+dHhkLm9tID0gVk1YTkVUM19PTV9UU087CisJCWdkZXNjLT50eGQubXNzY29mID0gY3R4Lm1zczsKKwkJdHEtPnNoYXJlZC0+dHhOdW1EZWZlcnJlZCArPSAoc2tiLT5sZW4gLSBnZGVzYy0+dHhkLmhsZW4gKworCQkJCQkgICAgIGN0eC5tc3MgLSAxKSAvIGN0eC5tc3M7CisJfSBlbHNlIHsKKwkJaWYgKHNrYi0+aXBfc3VtbWVkID09IENIRUNLU1VNX1BBUlRJQUwpIHsKKwkJCWdkZXNjLT50eGQuaGxlbiA9IGN0eC5ldGhfaXBfaGRyX3NpemU7CisJCQlnZGVzYy0+dHhkLm9tID0gVk1YTkVUM19PTV9DU1VNOworCQkJZ2Rlc2MtPnR4ZC5tc3Njb2YgPSBjdHguZXRoX2lwX2hkcl9zaXplICsKKwkJCQkJICAgIHNrYi0+Y3N1bV9vZmZzZXQ7CisJCX0gZWxzZSB7CisJCQlnZGVzYy0+dHhkLm9tID0gMDsKKwkJCWdkZXNjLT50eGQubXNzY29mID0gMDsKKwkJfQorCQl0cS0+c2hhcmVkLT50eE51bURlZmVycmVkKys7CisJfQorCisJaWYgKHZsYW5fdHhfdGFnX3ByZXNlbnQoc2tiKSkgeworCQlnZGVzYy0+dHhkLnRpID0gMTsKKwkJZ2Rlc2MtPnR4ZC50Y2kgPSB2bGFuX3R4X3RhZ19nZXQoc2tiKTsKKwl9CisKKwl3bWIoKTsKKworCS8qIGZpbmFsbHkgZmxpcHMgdGhlIEdFTiBiaXQgb2YgdGhlIFNPUCBkZXNjICovCisJZ2Rlc2MtPmR3b3JkWzJdIF49IFZNWE5FVDNfVFhEX0dFTjsKKwlkZXZfZGJnKCZhZGFwdGVyLT5uZXRkZXYtPmRldiwKKwkJInR4ZFsldV06IFNPUCAweCVMeCAweCV4IDB4JXhcbiIsCisJCSh1MzIpKCh1bmlvbiBWbXhuZXQzX0dlbmVyaWNEZXNjICopY3R4LnNvcF90eGQgLQorCQl0cS0+dHhfcmluZy5iYXNlKSwgZ2Rlc2MtPnR4ZC5hZGRyLCBnZGVzYy0+ZHdvcmRbMl0sCisJCWdkZXNjLT5kd29yZFszXSk7CisKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ0cS0+dHhfbG9jaywgZmxhZ3MpOworCisJaWYgKHRxLT5zaGFyZWQtPnR4TnVtRGVmZXJyZWQgPj0gdHEtPnNoYXJlZC0+dHhUaHJlc2hvbGQpIHsKKwkJdHEtPnNoYXJlZC0+dHhOdW1EZWZlcnJlZCA9IDA7CisJCVZNWE5FVDNfV1JJVEVfQkFSMF9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfVFhQUk9ELAorCQkJCSAgICAgICB0cS0+dHhfcmluZy5uZXh0MmZpbGwpOworCX0KKwluZXRkZXYtPnRyYW5zX3N0YXJ0ID0gamlmZmllczsKKworCXJldHVybiBORVRERVZfVFhfT0s7CisKK2hkcl90b29fYmlnOgorCXRxLT5zdGF0cy5kcm9wX292ZXJzaXplZF9oZHIrKzsKK2Ryb3BfcGt0OgorCXRxLT5zdGF0cy5kcm9wX3RvdGFsKys7CisJZGV2X2tmcmVlX3NrYihza2IpOworCXJldHVybiBORVRERVZfVFhfT0s7Cit9CisKKworc3RhdGljIG5ldGRldl90eF90Cit2bXhuZXQzX3htaXRfZnJhbWUoc3RydWN0IHNrX2J1ZmYgKnNrYiwgc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwlzdHJ1Y3Qgdm14bmV0M190eF9xdWV1ZSAqdHEgPSAmYWRhcHRlci0+dHhfcXVldWU7CisKKwlyZXR1cm4gdm14bmV0M190cV94bWl0KHNrYiwgdHEsIGFkYXB0ZXIsIG5ldGRldik7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfcnhfY3N1bShzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyLAorCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiLAorCQl1bmlvbiBWbXhuZXQzX0dlbmVyaWNEZXNjICpnZGVzYykKK3sKKwlpZiAoIWdkZXNjLT5yY2QuY25jICYmIGFkYXB0ZXItPnJ4Y3N1bSkgeworCQkvKiB0eXBpY2FsIGNhc2U6IFRDUC9VRFAgb3ZlciBJUCBhbmQgYm90aCBjc3VtcyBhcmUgY29ycmVjdCAqLworCQlpZiAoKGdkZXNjLT5kd29yZFszXSAmIFZNWE5FVDNfUkNEX0NTVU1fT0spID09CisJCQkJCQkJVk1YTkVUM19SQ0RfQ1NVTV9PSykgeworCQkJc2tiLT5pcF9zdW1tZWQgPSBDSEVDS1NVTV9VTk5FQ0VTU0FSWTsKKwkJCUJVR19PTighKGdkZXNjLT5yY2QudGNwIHx8IGdkZXNjLT5yY2QudWRwKSk7CisJCQlCVUdfT04oIShnZGVzYy0+cmNkLnY0ICB8fCBnZGVzYy0+cmNkLnY2KSk7CisJCQlCVUdfT04oZ2Rlc2MtPnJjZC5mcmcpOworCQl9IGVsc2UgeworCQkJaWYgKGdkZXNjLT5yY2QuY3N1bSkgeworCQkJCXNrYi0+Y3N1bSA9IGh0b25zKGdkZXNjLT5yY2QuY3N1bSk7CisJCQkJc2tiLT5pcF9zdW1tZWQgPSBDSEVDS1NVTV9QQVJUSUFMOworCQkJfSBlbHNlIHsKKwkJCQlza2ItPmlwX3N1bW1lZCA9IENIRUNLU1VNX05PTkU7CisJCQl9CisJCX0KKwl9IGVsc2UgeworCQlza2ItPmlwX3N1bW1lZCA9IENIRUNLU1VNX05PTkU7CisJfQorfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX3J4X2Vycm9yKHN0cnVjdCB2bXhuZXQzX3J4X3F1ZXVlICpycSwgc3RydWN0IFZteG5ldDNfUnhDb21wRGVzYyAqcmNkLAorCQkgc3RydWN0IHZteG5ldDNfcnhfY3R4ICpjdHgsICBzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCXJxLT5zdGF0cy5kcm9wX2VycisrOworCWlmICghcmNkLT5mY3MpCisJCXJxLT5zdGF0cy5kcm9wX2ZjcysrOworCisJcnEtPnN0YXRzLmRyb3BfdG90YWwrKzsKKworCS8qCisJICogV2UgZG8gbm90IHVubWFwIGFuZCBjaGFpbiB0aGUgcnggYnVmZmVyIHRvIHRoZSBza2IuCisJICogV2UgYmFzaWNhbGx5IHByZXRlbmQgdGhpcyBidWZmZXIgaXMgbm90IHVzZWQgYW5kIHdpbGwgYmUgcmVjeWNsZWQKKwkgKiBieSB2bXhuZXQzX3JxX2FsbG9jX3J4X2J1ZigpCisJICovCisKKwkvKgorCSAqIGN0eC0+c2tiIG1heSBiZSBOVUxMIGlmIHRoaXMgaXMgdGhlIGZpcnN0IGFuZCB0aGUgb25seSBvbmUKKwkgKiBkZXNjIGZvciB0aGUgcGt0CisJICovCisJaWYgKGN0eC0+c2tiKQorCQlkZXZfa2ZyZWVfc2tiX2lycShjdHgtPnNrYik7CisKKwljdHgtPnNrYiA9IE5VTEw7Cit9CisKKworc3RhdGljIGludAordm14bmV0M19ycV9yeF9jb21wbGV0ZShzdHJ1Y3Qgdm14bmV0M19yeF9xdWV1ZSAqcnEsCisJCSAgICAgICBzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyLCBpbnQgcXVvdGEpCit7CisJc3RhdGljIHUzMiByeHByb2RfcmVnWzJdID0ge1ZNWE5FVDNfUkVHX1JYUFJPRCwgVk1YTkVUM19SRUdfUlhQUk9EMn07CisJdTMyIG51bV9yeGQgPSAwOworCXN0cnVjdCBWbXhuZXQzX1J4Q29tcERlc2MgKnJjZDsKKwlzdHJ1Y3Qgdm14bmV0M19yeF9jdHggKmN0eCA9ICZycS0+cnhfY3R4OworCisJcmNkID0gJnJxLT5jb21wX3JpbmcuYmFzZVtycS0+Y29tcF9yaW5nLm5leHQycHJvY10ucmNkOworCXdoaWxlIChyY2QtPmdlbiA9PSBycS0+Y29tcF9yaW5nLmdlbikgeworCQlzdHJ1Y3Qgdm14bmV0M19yeF9idWZfaW5mbyAqcmJpOworCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiOworCQlpbnQgbnVtX3RvX2FsbG9jOworCQlzdHJ1Y3QgVm14bmV0M19SeERlc2MgKnJ4ZDsKKwkJdTMyIGlkeCwgcmluZ19pZHg7CisKKwkJaWYgKG51bV9yeGQgPj0gcXVvdGEpIHsKKwkJCS8qIHdlIG1heSBzdG9wIGV2ZW4gYmVmb3JlIHdlIHNlZSB0aGUgRU9QIGRlc2Mgb2YKKwkJCSAqIHRoZSBjdXJyZW50IHBrdAorCQkJICovCisJCQlicmVhazsKKwkJfQorCQludW1fcnhkKys7CisKKwkJaWR4ID0gcmNkLT5yeGRJZHg7CisJCXJpbmdfaWR4ID0gcmNkLT5ycUlEID09IHJxLT5xaWQgPyAwIDogMTsKKworCQlyeGQgPSAmcnEtPnJ4X3JpbmdbcmluZ19pZHhdLmJhc2VbaWR4XS5yeGQ7CisJCXJiaSA9IHJxLT5idWZfaW5mb1tyaW5nX2lkeF0gKyBpZHg7CisKKwkJQlVHX09OKHJ4ZC0+YWRkciAhPSByYmktPmRtYV9hZGRyIHx8IHJ4ZC0+bGVuICE9IHJiaS0+bGVuKTsKKworCQlpZiAodW5saWtlbHkocmNkLT5lb3AgJiYgcmNkLT5lcnIpKSB7CisJCQl2bXhuZXQzX3J4X2Vycm9yKHJxLCByY2QsIGN0eCwgYWRhcHRlcik7CisJCQlnb3RvIHJjZF9kb25lOworCQl9CisKKwkJaWYgKHJjZC0+c29wKSB7IC8qIGZpcnN0IGJ1ZiBvZiB0aGUgcGt0ICovCisJCQlCVUdfT04ocnhkLT5idHlwZSAhPSBWTVhORVQzX1JYRF9CVFlQRV9IRUFEIHx8CisJCQkgICAgICAgcmNkLT5ycUlEICE9IHJxLT5xaWQpOworCisJCQlCVUdfT04ocmJpLT5idWZfdHlwZSAhPSBWTVhORVQzX1JYX0JVRl9TS0IpOworCQkJQlVHX09OKGN0eC0+c2tiICE9IE5VTEwgfHwgcmJpLT5za2IgPT0gTlVMTCk7CisKKwkJCWlmICh1bmxpa2VseShyY2QtPmxlbiA9PSAwKSkgeworCQkJCS8qIFByZXRlbmQgdGhlIHJ4IGJ1ZmZlciBpcyBza2lwcGVkLiAqLworCQkJCUJVR19PTighKHJjZC0+c29wICYmIHJjZC0+ZW9wKSk7CisJCQkJZGV2X2RiZygmYWRhcHRlci0+bmV0ZGV2LT5kZXYsCisJCQkJCSJyeFJpbmdbJXVdWyV1XSAwIGxlbmd0aFxuIiwKKwkJCQkJcmluZ19pZHgsIGlkeCk7CisJCQkJZ290byByY2RfZG9uZTsKKwkJCX0KKworCQkJY3R4LT5za2IgPSByYmktPnNrYjsKKwkJCXJiaS0+c2tiID0gTlVMTDsKKworCQkJcGNpX3VubWFwX3NpbmdsZShhZGFwdGVyLT5wZGV2LCByYmktPmRtYV9hZGRyLCByYmktPmxlbiwKKwkJCQkJIFBDSV9ETUFfRlJPTURFVklDRSk7CisKKwkJCXNrYl9wdXQoY3R4LT5za2IsIHJjZC0+bGVuKTsKKwkJfSBlbHNlIHsKKwkJCUJVR19PTihjdHgtPnNrYiA9PSBOVUxMKTsKKwkJCS8qIG5vbiBTT1AgYnVmZmVyIG11c3QgYmUgdHlwZSAxIGluIG1vc3QgY2FzZXMgKi8KKwkJCWlmIChyYmktPmJ1Zl90eXBlID09IFZNWE5FVDNfUlhfQlVGX1BBR0UpIHsKKwkJCQlCVUdfT04ocnhkLT5idHlwZSAhPSBWTVhORVQzX1JYRF9CVFlQRV9CT0RZKTsKKworCQkJCWlmIChyY2QtPmxlbikgeworCQkJCQlwY2lfdW5tYXBfcGFnZShhZGFwdGVyLT5wZGV2LAorCQkJCQkJICAgICAgIHJiaS0+ZG1hX2FkZHIsIHJiaS0+bGVuLAorCQkJCQkJICAgICAgIFBDSV9ETUFfRlJPTURFVklDRSk7CisKKwkJCQkJdm14bmV0M19hcHBlbmRfZnJhZyhjdHgtPnNrYiwgcmNkLCByYmkpOworCQkJCQlyYmktPnBhZ2UgPSBOVUxMOworCQkJCX0KKwkJCX0gZWxzZSB7CisJCQkJLyoKKwkJCQkgKiBUaGUgb25seSB0aW1lIGEgbm9uLVNPUCBidWZmZXIgaXMgdHlwZSAwIGlzCisJCQkJICogd2hlbiBpdCdzIEVPUCBhbmQgZXJyb3IgZmxhZyBpcyByYWlzZWQsIHdoaWNoCisJCQkJICogaGFzIGFscmVhZHkgYmVlbiBoYW5kbGVkLgorCQkJCSAqLworCQkJCUJVR19PTih0cnVlKTsKKwkJCX0KKwkJfQorCisJCXNrYiA9IGN0eC0+c2tiOworCQlpZiAocmNkLT5lb3ApIHsKKwkJCXNrYi0+bGVuICs9IHNrYi0+ZGF0YV9sZW47CisJCQlza2ItPnRydWVzaXplICs9IHNrYi0+ZGF0YV9sZW47CisKKwkJCXZteG5ldDNfcnhfY3N1bShhZGFwdGVyLCBza2IsCisJCQkJCSh1bmlvbiBWbXhuZXQzX0dlbmVyaWNEZXNjICopcmNkKTsKKwkJCXNrYi0+cHJvdG9jb2wgPSBldGhfdHlwZV90cmFucyhza2IsIGFkYXB0ZXItPm5ldGRldik7CisKKwkJCWlmICh1bmxpa2VseShhZGFwdGVyLT52bGFuX2dycCAmJiByY2QtPnRzKSkgeworCQkJCXZsYW5faHdhY2NlbF9yZWNlaXZlX3NrYihza2IsCisJCQkJCQlhZGFwdGVyLT52bGFuX2dycCwgcmNkLT50Y2kpOworCQkJfSBlbHNlIHsKKwkJCQluZXRpZl9yZWNlaXZlX3NrYihza2IpOworCQkJfQorCisJCQlhZGFwdGVyLT5uZXRkZXYtPmxhc3RfcnggPSBqaWZmaWVzOworCQkJY3R4LT5za2IgPSBOVUxMOworCQl9CisKK3JjZF9kb25lOgorCQkvKiBkZXZpY2UgbWF5IHNraXAgc29tZSByeCBkZXNjcyAqLworCQlycS0+cnhfcmluZ1tyaW5nX2lkeF0ubmV4dDJjb21wID0gaWR4OworCQlWTVhORVQzX0lOQ19SSU5HX0lEWF9PTkxZKHJxLT5yeF9yaW5nW3JpbmdfaWR4XS5uZXh0MmNvbXAsCisJCQkJCSAgcnEtPnJ4X3JpbmdbcmluZ19pZHhdLnNpemUpOworCisJCS8qIHJlZmlsbCByeCBidWZmZXJzIGZyZXF1ZW50bHkgdG8gYXZvaWQgc3RhcnZpbmcgdGhlIGgvdyAqLworCQludW1fdG9fYWxsb2MgPSB2bXhuZXQzX2NtZF9yaW5nX2Rlc2NfYXZhaWwocnEtPnJ4X3JpbmcgKworCQkJCQkJCSAgIHJpbmdfaWR4KTsKKwkJaWYgKHVubGlrZWx5KG51bV90b19hbGxvYyA+IFZNWE5FVDNfUlhfQUxMT0NfVEhSRVNIT0xEKHJxLAorCQkJCQkJCXJpbmdfaWR4LCBhZGFwdGVyKSkpIHsKKwkJCXZteG5ldDNfcnFfYWxsb2NfcnhfYnVmKHJxLCByaW5nX2lkeCwgbnVtX3RvX2FsbG9jLAorCQkJCQkJYWRhcHRlcik7CisKKwkJCS8qIGlmIG5lZWRlZCwgdXBkYXRlIHRoZSByZWdpc3RlciAqLworCQkJaWYgKHVubGlrZWx5KHJxLT5zaGFyZWQtPnVwZGF0ZVJ4UHJvZCkpIHsKKwkJCQlWTVhORVQzX1dSSVRFX0JBUjBfUkVHKGFkYXB0ZXIsCisJCQkJCXJ4cHJvZF9yZWdbcmluZ19pZHhdICsgcnEtPnFpZCAqIDgsCisJCQkJCXJxLT5yeF9yaW5nW3JpbmdfaWR4XS5uZXh0MmZpbGwpOworCQkJCXJxLT51bmNvbW1pdHRlZFtyaW5nX2lkeF0gPSAwOworCQkJfQorCQl9CisKKwkJdm14bmV0M19jb21wX3JpbmdfYWR2X25leHQycHJvYygmcnEtPmNvbXBfcmluZyk7CisJCXJjZCA9ICZycS0+Y29tcF9yaW5nLmJhc2VbcnEtPmNvbXBfcmluZy5uZXh0MnByb2NdLnJjZDsKKwl9CisKKwlyZXR1cm4gbnVtX3J4ZDsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19ycV9jbGVhbnVwKHN0cnVjdCB2bXhuZXQzX3J4X3F1ZXVlICpycSwKKwkJICAgc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwl1MzIgaSwgcmluZ19pZHg7CisJc3RydWN0IFZteG5ldDNfUnhEZXNjICpyeGQ7CisKKwlmb3IgKHJpbmdfaWR4ID0gMDsgcmluZ19pZHggPCAyOyByaW5nX2lkeCsrKSB7CisJCWZvciAoaSA9IDA7IGkgPCBycS0+cnhfcmluZ1tyaW5nX2lkeF0uc2l6ZTsgaSsrKSB7CisJCQlyeGQgPSAmcnEtPnJ4X3JpbmdbcmluZ19pZHhdLmJhc2VbaV0ucnhkOworCisJCQlpZiAocnhkLT5idHlwZSA9PSBWTVhORVQzX1JYRF9CVFlQRV9IRUFEICYmCisJCQkJCXJxLT5idWZfaW5mb1tyaW5nX2lkeF1baV0uc2tiKSB7CisJCQkJcGNpX3VubWFwX3NpbmdsZShhZGFwdGVyLT5wZGV2LCByeGQtPmFkZHIsCisJCQkJCQkgcnhkLT5sZW4sIFBDSV9ETUFfRlJPTURFVklDRSk7CisJCQkJZGV2X2tmcmVlX3NrYihycS0+YnVmX2luZm9bcmluZ19pZHhdW2ldLnNrYik7CisJCQkJcnEtPmJ1Zl9pbmZvW3JpbmdfaWR4XVtpXS5za2IgPSBOVUxMOworCQkJfSBlbHNlIGlmIChyeGQtPmJ0eXBlID09IFZNWE5FVDNfUlhEX0JUWVBFX0JPRFkgJiYKKwkJCQkJcnEtPmJ1Zl9pbmZvW3JpbmdfaWR4XVtpXS5wYWdlKSB7CisJCQkJcGNpX3VubWFwX3BhZ2UoYWRhcHRlci0+cGRldiwgcnhkLT5hZGRyLAorCQkJCQkgICAgICAgcnhkLT5sZW4sIFBDSV9ETUFfRlJPTURFVklDRSk7CisJCQkJcHV0X3BhZ2UocnEtPmJ1Zl9pbmZvW3JpbmdfaWR4XVtpXS5wYWdlKTsKKwkJCQlycS0+YnVmX2luZm9bcmluZ19pZHhdW2ldLnBhZ2UgPSBOVUxMOworCQkJfQorCQl9CisKKwkJcnEtPnJ4X3JpbmdbcmluZ19pZHhdLmdlbiA9IFZNWE5FVDNfSU5JVF9HRU47CisJCXJxLT5yeF9yaW5nW3JpbmdfaWR4XS5uZXh0MmZpbGwgPQorCQkJCQlycS0+cnhfcmluZ1tyaW5nX2lkeF0ubmV4dDJjb21wID0gMDsKKwkJcnEtPnVuY29tbWl0dGVkW3JpbmdfaWR4XSA9IDA7CisJfQorCisJcnEtPmNvbXBfcmluZy5nZW4gPSBWTVhORVQzX0lOSVRfR0VOOworCXJxLT5jb21wX3JpbmcubmV4dDJwcm9jID0gMDsKK30KKworCit2b2lkIHZteG5ldDNfcnFfZGVzdHJveShzdHJ1Y3Qgdm14bmV0M19yeF9xdWV1ZSAqcnEsCisJCQlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBpOworCWludCBqOworCisJLyogYWxsIHJ4IGJ1ZmZlcnMgbXVzdCBoYXZlIGFscmVhZHkgYmVlbiBmcmVlZCAqLworCWZvciAoaSA9IDA7IGkgPCAyOyBpKyspIHsKKwkJaWYgKHJxLT5idWZfaW5mb1tpXSkgeworCQkJZm9yIChqID0gMDsgaiA8IHJxLT5yeF9yaW5nW2ldLnNpemU7IGorKykKKwkJCQlCVUdfT04ocnEtPmJ1Zl9pbmZvW2ldW2pdLnBhZ2UgIT0gTlVMTCk7CisJCX0KKwl9CisKKworCWtmcmVlKHJxLT5idWZfaW5mb1swXSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKSB7CisJCWlmIChycS0+cnhfcmluZ1tpXS5iYXNlKSB7CisJCQlwY2lfZnJlZV9jb25zaXN0ZW50KGFkYXB0ZXItPnBkZXYsIHJxLT5yeF9yaW5nW2ldLnNpemUKKwkJCQkJICAgICogc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1J4RGVzYyksCisJCQkJCSAgICBycS0+cnhfcmluZ1tpXS5iYXNlLAorCQkJCQkgICAgcnEtPnJ4X3JpbmdbaV0uYmFzZVBBKTsKKwkJCXJxLT5yeF9yaW5nW2ldLmJhc2UgPSBOVUxMOworCQl9CisJCXJxLT5idWZfaW5mb1tpXSA9IE5VTEw7CisJfQorCisJaWYgKHJxLT5jb21wX3JpbmcuYmFzZSkgeworCQlwY2lfZnJlZV9jb25zaXN0ZW50KGFkYXB0ZXItPnBkZXYsIHJxLT5jb21wX3Jpbmcuc2l6ZSAqCisJCQkJICAgIHNpemVvZihzdHJ1Y3QgVm14bmV0M19SeENvbXBEZXNjKSwKKwkJCQkgICAgcnEtPmNvbXBfcmluZy5iYXNlLCBycS0+Y29tcF9yaW5nLmJhc2VQQSk7CisJCXJxLT5jb21wX3JpbmcuYmFzZSA9IE5VTEw7CisJfQorfQorCisKK3N0YXRpYyBpbnQKK3ZteG5ldDNfcnFfaW5pdChzdHJ1Y3Qgdm14bmV0M19yeF9xdWV1ZSAqcnEsCisJCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgICphZGFwdGVyKQoreworCWludCBpOworCisJLyogaW5pdGlhbGl6ZSBidWZfaW5mbyAqLworCWZvciAoaSA9IDA7IGkgPCBycS0+cnhfcmluZ1swXS5zaXplOyBpKyspIHsKKworCQkvKiAxc3QgYnVmIGZvciBhIHBrdCBpcyBza2J1ZmYgKi8KKwkJaWYgKGkgJSBhZGFwdGVyLT5yeF9idWZfcGVyX3BrdCA9PSAwKSB7CisJCQlycS0+YnVmX2luZm9bMF1baV0uYnVmX3R5cGUgPSBWTVhORVQzX1JYX0JVRl9TS0I7CisJCQlycS0+YnVmX2luZm9bMF1baV0ubGVuID0gYWRhcHRlci0+c2tiX2J1Zl9zaXplOworCQl9IGVsc2UgeyAvKiBzdWJzZXF1ZW50IGJ1ZnMgZm9yIGEgcGt0IGlzIGZyYWcgKi8KKwkJCXJxLT5idWZfaW5mb1swXVtpXS5idWZfdHlwZSA9IFZNWE5FVDNfUlhfQlVGX1BBR0U7CisJCQlycS0+YnVmX2luZm9bMF1baV0ubGVuID0gUEFHRV9TSVpFOworCQl9CisJfQorCWZvciAoaSA9IDA7IGkgPCBycS0+cnhfcmluZ1sxXS5zaXplOyBpKyspIHsKKwkJcnEtPmJ1Zl9pbmZvWzFdW2ldLmJ1Zl90eXBlID0gVk1YTkVUM19SWF9CVUZfUEFHRTsKKwkJcnEtPmJ1Zl9pbmZvWzFdW2ldLmxlbiA9IFBBR0VfU0laRTsKKwl9CisKKwkvKiByZXNldCBpbnRlcm5hbCBzdGF0ZSBhbmQgYWxsb2NhdGUgYnVmZmVycyBmb3IgYm90aCByaW5ncyAqLworCWZvciAoaSA9IDA7IGkgPCAyOyBpKyspIHsKKwkJcnEtPnJ4X3JpbmdbaV0ubmV4dDJmaWxsID0gcnEtPnJ4X3JpbmdbaV0ubmV4dDJjb21wID0gMDsKKwkJcnEtPnVuY29tbWl0dGVkW2ldID0gMDsKKworCQltZW1zZXQocnEtPnJ4X3JpbmdbaV0uYmFzZSwgMCwgcnEtPnJ4X3JpbmdbaV0uc2l6ZSAqCisJCSAgICAgICBzaXplb2Yoc3RydWN0IFZteG5ldDNfUnhEZXNjKSk7CisJCXJxLT5yeF9yaW5nW2ldLmdlbiA9IFZNWE5FVDNfSU5JVF9HRU47CisJfQorCWlmICh2bXhuZXQzX3JxX2FsbG9jX3J4X2J1ZihycSwgMCwgcnEtPnJ4X3JpbmdbMF0uc2l6ZSAtIDEsCisJCQkJICAgIGFkYXB0ZXIpID09IDApIHsKKwkJLyogYXQgbGVhc3QgaGFzIDEgcnggYnVmZmVyIGZvciB0aGUgMXN0IHJpbmcgKi8KKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCXZteG5ldDNfcnFfYWxsb2NfcnhfYnVmKHJxLCAxLCBycS0+cnhfcmluZ1sxXS5zaXplIC0gMSwgYWRhcHRlcik7CisKKwkvKiByZXNldCB0aGUgY29tcCByaW5nICovCisJcnEtPmNvbXBfcmluZy5uZXh0MnByb2MgPSAwOworCW1lbXNldChycS0+Y29tcF9yaW5nLmJhc2UsIDAsIHJxLT5jb21wX3Jpbmcuc2l6ZSAqCisJICAgICAgIHNpemVvZihzdHJ1Y3QgVm14bmV0M19SeENvbXBEZXNjKSk7CisJcnEtPmNvbXBfcmluZy5nZW4gPSBWTVhORVQzX0lOSVRfR0VOOworCisJLyogcmVzZXQgcnhjdHggKi8KKwlycS0+cnhfY3R4LnNrYiA9IE5VTEw7CisKKwkvKiBzdGF0cyBhcmUgbm90IHJlc2V0ICovCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludAordm14bmV0M19ycV9jcmVhdGUoc3RydWN0IHZteG5ldDNfcnhfcXVldWUgKnJxLCBzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBpOworCXNpemVfdCBzejsKKwlzdHJ1Y3Qgdm14bmV0M19yeF9idWZfaW5mbyAqYmk7CisKKwlmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKSB7CisKKwkJc3ogPSBycS0+cnhfcmluZ1tpXS5zaXplICogc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1J4RGVzYyk7CisJCXJxLT5yeF9yaW5nW2ldLmJhc2UgPSBwY2lfYWxsb2NfY29uc2lzdGVudChhZGFwdGVyLT5wZGV2LCBzeiwKKwkJCQkJCQkmcnEtPnJ4X3JpbmdbaV0uYmFzZVBBKTsKKwkJaWYgKCFycS0+cnhfcmluZ1tpXS5iYXNlKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzOiBmYWlsZWQgdG8gYWxsb2NhdGUgcnggcmluZyAlZFxuIiwKKwkJCSAgICAgICBhZGFwdGVyLT5uZXRkZXYtPm5hbWUsIGkpOworCQkJZ290byBlcnI7CisJCX0KKwl9CisKKwlzeiA9IHJxLT5jb21wX3Jpbmcuc2l6ZSAqIHNpemVvZihzdHJ1Y3QgVm14bmV0M19SeENvbXBEZXNjKTsKKwlycS0+Y29tcF9yaW5nLmJhc2UgPSBwY2lfYWxsb2NfY29uc2lzdGVudChhZGFwdGVyLT5wZGV2LCBzeiwKKwkJCQkJCSAgJnJxLT5jb21wX3JpbmcuYmFzZVBBKTsKKwlpZiAoIXJxLT5jb21wX3JpbmcuYmFzZSkgeworCQlwcmludGsoS0VSTl9FUlIgIiVzOiBmYWlsZWQgdG8gYWxsb2NhdGUgcnggY29tcCByaW5nXG4iLAorCQkgICAgICAgYWRhcHRlci0+bmV0ZGV2LT5uYW1lKTsKKwkJZ290byBlcnI7CisJfQorCisJc3ogPSBzaXplb2Yoc3RydWN0IHZteG5ldDNfcnhfYnVmX2luZm8pICogKHJxLT5yeF9yaW5nWzBdLnNpemUgKworCQkJCQkJICAgcnEtPnJ4X3JpbmdbMV0uc2l6ZSk7CisJYmkgPSBrbWFsbG9jKHN6LCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJpKSB7CisJCXByaW50ayhLRVJOX0VSUiAiJXM6IGZhaWxlZCB0byBhbGxvY2F0ZSByeCBidWZpbmZvXG4iLAorCQkgICAgICAgYWRhcHRlci0+bmV0ZGV2LT5uYW1lKTsKKwkJZ290byBlcnI7CisJfQorCW1lbXNldChiaSwgMCwgc3opOworCXJxLT5idWZfaW5mb1swXSA9IGJpOworCXJxLT5idWZfaW5mb1sxXSA9IGJpICsgcnEtPnJ4X3JpbmdbMF0uc2l6ZTsKKworCXJldHVybiAwOworCitlcnI6CisJdm14bmV0M19ycV9kZXN0cm95KHJxLCBhZGFwdGVyKTsKKwlyZXR1cm4gLUVOT01FTTsKK30KKworCitzdGF0aWMgaW50Cit2bXhuZXQzX2RvX3BvbGwoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciwgaW50IGJ1ZGdldCkKK3sKKwlpZiAodW5saWtlbHkoYWRhcHRlci0+c2hhcmVkLT5lY3IpKQorCQl2bXhuZXQzX3Byb2Nlc3NfZXZlbnRzKGFkYXB0ZXIpOworCisJdm14bmV0M190cV90eF9jb21wbGV0ZSgmYWRhcHRlci0+dHhfcXVldWUsIGFkYXB0ZXIpOworCXJldHVybiB2bXhuZXQzX3JxX3J4X2NvbXBsZXRlKCZhZGFwdGVyLT5yeF9xdWV1ZSwgYWRhcHRlciwgYnVkZ2V0KTsKK30KKworCitzdGF0aWMgaW50Cit2bXhuZXQzX3BvbGwoc3RydWN0IG5hcGlfc3RydWN0ICpuYXBpLCBpbnQgYnVkZ2V0KQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBjb250YWluZXJfb2YobmFwaSwKKwkJCQkJICBzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyLCBuYXBpKTsKKwlpbnQgcnhkX2RvbmU7CisKKwlyeGRfZG9uZSA9IHZteG5ldDNfZG9fcG9sbChhZGFwdGVyLCBidWRnZXQpOworCisJaWYgKHJ4ZF9kb25lIDwgYnVkZ2V0KSB7CisJCW5hcGlfY29tcGxldGUobmFwaSk7CisJCXZteG5ldDNfZW5hYmxlX2ludHIoYWRhcHRlciwgMCk7CisJfQorCXJldHVybiByeGRfZG9uZTsKK30KKworCisvKiBJbnRlcnJ1cHQgaGFuZGxlciBmb3Igdm14bmV0MyAgKi8KK3N0YXRpYyBpcnFyZXR1cm5fdAordm14bmV0M19pbnRyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKK3sKKwlzdHJ1Y3QgbmV0X2RldmljZSAqZGV2ID0gZGV2X2lkOworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihkZXYpOworCisJaWYgKHVubGlrZWx5KGFkYXB0ZXItPmludHIudHlwZSA9PSBWTVhORVQzX0lUX0lOVFgpKSB7CisJCXUzMiBpY3IgPSBWTVhORVQzX1JFQURfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfSUNSKTsKKwkJaWYgKHVubGlrZWx5KGljciA9PSAwKSkKKwkJCS8qIG5vdCBvdXJzICovCisJCQlyZXR1cm4gSVJRX05PTkU7CisJfQorCisKKwkvKiBkaXNhYmxlIGludHIgaWYgbmVlZGVkICovCisJaWYgKGFkYXB0ZXItPmludHIubWFza19tb2RlID09IFZNWE5FVDNfSU1NX0FDVElWRSkKKwkJdm14bmV0M19kaXNhYmxlX2ludHIoYWRhcHRlciwgMCk7CisKKwluYXBpX3NjaGVkdWxlKCZhZGFwdGVyLT5uYXBpKTsKKworCXJldHVybiBJUlFfSEFORExFRDsKK30KKworI2lmZGVmIENPTkZJR19ORVRfUE9MTF9DT05UUk9MTEVSCisKKworLyogbmV0cG9sbCBjYWxsYmFjay4gKi8KK3N0YXRpYyB2b2lkCit2bXhuZXQzX25ldHBvbGwoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwlpbnQgaXJxOworCisjaWZkZWYgQ09ORklHX1BDSV9NU0kKKwlpZiAoYWRhcHRlci0+aW50ci50eXBlID09IFZNWE5FVDNfSVRfTVNJWCkKKwkJaXJxID0gYWRhcHRlci0+aW50ci5tc2l4X2VudHJpZXNbMF0udmVjdG9yOworCWVsc2UKKyNlbmRpZgorCQlpcnEgPSBhZGFwdGVyLT5wZGV2LT5pcnE7CisKKwlkaXNhYmxlX2lycShpcnEpOworCXZteG5ldDNfaW50cihpcnEsIG5ldGRldik7CisJZW5hYmxlX2lycShpcnEpOworfQorI2VuZGlmCisKK3N0YXRpYyBpbnQKK3ZteG5ldDNfcmVxdWVzdF9pcnFzKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJaW50IGVycjsKKworI2lmZGVmIENPTkZJR19QQ0lfTVNJCisJaWYgKGFkYXB0ZXItPmludHIudHlwZSA9PSBWTVhORVQzX0lUX01TSVgpIHsKKwkJLyogd2Ugb25seSB1c2UgMSBNU0ktWCB2ZWN0b3IgKi8KKwkJZXJyID0gcmVxdWVzdF9pcnEoYWRhcHRlci0+aW50ci5tc2l4X2VudHJpZXNbMF0udmVjdG9yLAorCQkJCSAgdm14bmV0M19pbnRyLCAwLCBhZGFwdGVyLT5uZXRkZXYtPm5hbWUsCisJCQkJICBhZGFwdGVyLT5uZXRkZXYpOworCX0gZWxzZQorI2VuZGlmCisJaWYgKGFkYXB0ZXItPmludHIudHlwZSA9PSBWTVhORVQzX0lUX01TSSkgeworCQllcnIgPSByZXF1ZXN0X2lycShhZGFwdGVyLT5wZGV2LT5pcnEsIHZteG5ldDNfaW50ciwgMCwKKwkJCQkgIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwgYWRhcHRlci0+bmV0ZGV2KTsKKwl9IGVsc2UgeworCQllcnIgPSByZXF1ZXN0X2lycShhZGFwdGVyLT5wZGV2LT5pcnEsIHZteG5ldDNfaW50ciwKKwkJCQkgIElSUUZfU0hBUkVELCBhZGFwdGVyLT5uZXRkZXYtPm5hbWUsCisJCQkJICBhZGFwdGVyLT5uZXRkZXYpOworCX0KKworCWlmIChlcnIpCisJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIHJlcXVlc3QgaXJxICVzIChpbnRyIHR5cGU6JWQpLCBlcnJvciIKKwkJICAgICAgICI6JWRcbiIsIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwgYWRhcHRlci0+aW50ci50eXBlLCBlcnIpOworCisKKwlpZiAoIWVycikgeworCQlpbnQgaTsKKwkJLyogaW5pdCBvdXIgaW50ciBzZXR0aW5ncyAqLworCQlmb3IgKGkgPSAwOyBpIDwgYWRhcHRlci0+aW50ci5udW1faW50cnM7IGkrKykKKwkJCWFkYXB0ZXItPmludHIubW9kX2xldmVsc1tpXSA9IFVQVDFfSU1MX0FEQVBUSVZFOworCisJCS8qIG5leHQgc2V0dXAgaW50ciBpbmRleCBmb3IgYWxsIGludHIgc291cmNlcyAqLworCQlhZGFwdGVyLT50eF9xdWV1ZS5jb21wX3JpbmcuaW50cl9pZHggPSAwOworCQlhZGFwdGVyLT5yeF9xdWV1ZS5jb21wX3JpbmcuaW50cl9pZHggPSAwOworCQlhZGFwdGVyLT5pbnRyLmV2ZW50X2ludHJfaWR4ID0gMDsKKworCQlwcmludGsoS0VSTl9JTkZPICIlczogaW50ciB0eXBlICV1LCBtb2RlICV1LCAldSB2ZWN0b3JzICIKKwkJICAgICAgICJhbGxvY2F0ZWRcbiIsIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwgYWRhcHRlci0+aW50ci50eXBlLAorCQkgICAgICAgYWRhcHRlci0+aW50ci5tYXNrX21vZGUsIGFkYXB0ZXItPmludHIubnVtX2ludHJzKTsKKwl9CisKKwlyZXR1cm4gZXJyOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX2ZyZWVfaXJxcyhzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCUJVR19PTihhZGFwdGVyLT5pbnRyLnR5cGUgPT0gVk1YTkVUM19JVF9BVVRPIHx8CisJICAgICAgIGFkYXB0ZXItPmludHIubnVtX2ludHJzIDw9IDApOworCisJc3dpdGNoIChhZGFwdGVyLT5pbnRyLnR5cGUpIHsKKyNpZmRlZiBDT05GSUdfUENJX01TSQorCWNhc2UgVk1YTkVUM19JVF9NU0lYOgorCXsKKwkJaW50IGk7CisKKwkJZm9yIChpID0gMDsgaSA8IGFkYXB0ZXItPmludHIubnVtX2ludHJzOyBpKyspCisJCQlmcmVlX2lycShhZGFwdGVyLT5pbnRyLm1zaXhfZW50cmllc1tpXS52ZWN0b3IsCisJCQkJIGFkYXB0ZXItPm5ldGRldik7CisJCWJyZWFrOworCX0KKyNlbmRpZgorCWNhc2UgVk1YTkVUM19JVF9NU0k6CisJCWZyZWVfaXJxKGFkYXB0ZXItPnBkZXYtPmlycSwgYWRhcHRlci0+bmV0ZGV2KTsKKwkJYnJlYWs7CisJY2FzZSBWTVhORVQzX0lUX0lOVFg6CisJCWZyZWVfaXJxKGFkYXB0ZXItPnBkZXYtPmlycSwgYWRhcHRlci0+bmV0ZGV2KTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJQlVHX09OKHRydWUpOworCX0KK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M192bGFuX3J4X3JlZ2lzdGVyKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsIHN0cnVjdCB2bGFuX2dyb3VwICpncnApCit7CisJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJc3RydWN0IFZteG5ldDNfRHJpdmVyU2hhcmVkICpzaGFyZWQgPSBhZGFwdGVyLT5zaGFyZWQ7CisJdTMyICp2ZlRhYmxlID0gYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLnJ4RmlsdGVyQ29uZi52ZlRhYmxlOworCisJaWYgKGdycCkgeworCQkvKiBhZGQgdmxhbiByeCBzdHJpcHBpbmcuICovCisJCWlmIChhZGFwdGVyLT5uZXRkZXYtPmZlYXR1cmVzICYgTkVUSUZfRl9IV19WTEFOX1JYKSB7CisJCQlpbnQgaTsKKwkJCXN0cnVjdCBWbXhuZXQzX0RTRGV2UmVhZCAqZGV2UmVhZCA9ICZzaGFyZWQtPmRldlJlYWQ7CisJCQlhZGFwdGVyLT52bGFuX2dycCA9IGdycDsKKworCQkJLyogdXBkYXRlIEZFQVRVUkVTIHRvIGRldmljZSAqLworCQkJZGV2UmVhZC0+bWlzYy51cHRGZWF0dXJlcyB8PSBVUFQxX0ZfUlhWTEFOOworCQkJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCisJCQkJCSAgICAgICBWTVhORVQzX0NNRF9VUERBVEVfRkVBVFVSRSk7CisJCQkvKgorCQkJICogIENsZWFyIGVudGlyZSB2ZlRhYmxlOyB0aGVuIGVuYWJsZSB1bnRhZ2dlZCBwa3RzLgorCQkJICogIE5vdGU6IHNldHRpbmcgb25lIGVudHJ5IGluIHZmVGFibGUgdG8gbm9uLXplcm8gdHVybnMKKwkJCSAqICBvbiBWTEFOIHJ4IGZpbHRlcmluZy4KKwkJCSAqLworCQkJZm9yIChpID0gMDsgaSA8IFZNWE5FVDNfVkZUX1NJWkU7IGkrKykKKwkJCQl2ZlRhYmxlW2ldID0gMDsKKworCQkJVk1YTkVUM19TRVRfVkZUQUJMRV9FTlRSWSh2ZlRhYmxlLCAwKTsKKwkJCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX1ZMQU5fRklMVEVSUyk7CisJCX0gZWxzZSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzOiB2bGFuX3J4X3JlZ2lzdGVyIHdoZW4gZGV2aWNlIGhhcyAiCisJCQkgICAgICAgIm5vIE5FVElGX0ZfSFdfVkxBTl9SWFxuIiwgbmV0ZGV2LT5uYW1lKTsKKwkJfQorCX0gZWxzZSB7CisJCS8qIHJlbW92ZSB2bGFuIHJ4IHN0cmlwcGluZy4gKi8KKwkJc3RydWN0IFZteG5ldDNfRFNEZXZSZWFkICpkZXZSZWFkID0gJnNoYXJlZC0+ZGV2UmVhZDsKKwkJYWRhcHRlci0+dmxhbl9ncnAgPSBOVUxMOworCisJCWlmIChkZXZSZWFkLT5taXNjLnVwdEZlYXR1cmVzICYgVVBUMV9GX1JYVkxBTikgeworCQkJaW50IGk7CisKKwkJCWZvciAoaSA9IDA7IGkgPCBWTVhORVQzX1ZGVF9TSVpFOyBpKyspIHsKKwkJCQkvKiBjbGVhciBlbnRpcmUgdmZUYWJsZTsgdGhpcyBhbHNvIGRpc2FibGVzCisJCQkJICogVkxBTiByeCBmaWx0ZXJpbmcKKwkJCQkgKi8KKwkJCQl2ZlRhYmxlW2ldID0gMDsKKwkJCX0KKwkJCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX1ZMQU5fRklMVEVSUyk7CisKKwkJCS8qIHVwZGF0ZSBGRUFUVVJFUyB0byBkZXZpY2UgKi8KKwkJCWRldlJlYWQtPm1pc2MudXB0RmVhdHVyZXMgJj0gflVQVDFfRl9SWFZMQU47CisJCQlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwKKwkJCQkJICAgICAgIFZNWE5FVDNfQ01EX1VQREFURV9GRUFUVVJFKTsKKwkJfQorCX0KK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19yZXN0b3JlX3ZsYW4oc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwlpZiAoYWRhcHRlci0+dmxhbl9ncnApIHsKKwkJdTE2IHZpZDsKKwkJdTMyICp2ZlRhYmxlID0gYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLnJ4RmlsdGVyQ29uZi52ZlRhYmxlOworCQlib29sIGFjdGl2ZVZsYW4gPSBmYWxzZTsKKworCQlmb3IgKHZpZCA9IDA7IHZpZCA8IFZMQU5fR1JPVVBfQVJSQVlfTEVOOyB2aWQrKykgeworCQkJaWYgKHZsYW5fZ3JvdXBfZ2V0X2RldmljZShhZGFwdGVyLT52bGFuX2dycCwgdmlkKSkgeworCQkJCVZNWE5FVDNfU0VUX1ZGVEFCTEVfRU5UUlkodmZUYWJsZSwgdmlkKTsKKwkJCQlhY3RpdmVWbGFuID0gdHJ1ZTsKKwkJCX0KKwkJfQorCQlpZiAoYWN0aXZlVmxhbikgeworCQkJLyogY29udGludWUgdG8gYWxsb3cgdW50YWdnZWQgcGt0cyAqLworCQkJVk1YTkVUM19TRVRfVkZUQUJMRV9FTlRSWSh2ZlRhYmxlLCAwKTsKKwkJfQorCX0KK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M192bGFuX3J4X2FkZF92aWQoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgdTE2IHZpZCkKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwl1MzIgKnZmVGFibGUgPSBhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQucnhGaWx0ZXJDb25mLnZmVGFibGU7CisKKwlWTVhORVQzX1NFVF9WRlRBQkxFX0VOVFJZKHZmVGFibGUsIHZpZCk7CisJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCisJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX1ZMQU5fRklMVEVSUyk7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfdmxhbl9yeF9raWxsX3ZpZChzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCB1MTYgdmlkKQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCXUzMiAqdmZUYWJsZSA9IGFkYXB0ZXItPnNoYXJlZC0+ZGV2UmVhZC5yeEZpbHRlckNvbmYudmZUYWJsZTsKKworCVZNWE5FVDNfQ0xFQVJfVkZUQUJMRV9FTlRSWSh2ZlRhYmxlLCB2aWQpOworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJICAgICAgIFZNWE5FVDNfQ01EX1VQREFURV9WTEFOX0ZJTFRFUlMpOworfQorCisKK3N0YXRpYyB1OCAqCit2bXhuZXQzX2NvcHlfbWMoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwl1OCAqYnVmID0gTlVMTDsKKwl1MzIgc3ogPSBuZXRkZXYtPm1jX2NvdW50ICogRVRIX0FMRU47CisKKwkvKiBzdHJ1Y3QgVm14bmV0M19SeEZpbHRlckNvbmYubWZUYWJsZUxlbiBpcyB1MTYuICovCisJaWYgKHN6IDw9IDB4ZmZmZikgeworCQkvKiBXZSBtYXkgYmUgY2FsbGVkIHdpdGggQkggZGlzYWJsZWQgKi8KKwkJYnVmID0ga21hbGxvYyhzeiwgR0ZQX0FUT01JQyk7CisJCWlmIChidWYpIHsKKwkJCWludCBpOworCQkJc3RydWN0IGRldl9tY19saXN0ICptYyA9IG5ldGRldi0+bWNfbGlzdDsKKworCQkJZm9yIChpID0gMDsgaSA8IG5ldGRldi0+bWNfY291bnQ7IGkrKykgeworCQkJCUJVR19PTighbWMpOworCQkJCW1lbWNweShidWYgKyBpICogRVRIX0FMRU4sIG1jLT5kbWlfYWRkciwKKwkJCQkgICAgICAgRVRIX0FMRU4pOworCQkJCW1jID0gbWMtPm5leHQ7CisJCQl9CisJCX0KKwl9CisJcmV0dXJuIGJ1ZjsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19zZXRfbWMoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwlzdHJ1Y3QgVm14bmV0M19SeEZpbHRlckNvbmYgKnJ4Q29uZiA9CisJCQkJCSZhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQucnhGaWx0ZXJDb25mOworCXU4ICpuZXdfdGFibGUgPSBOVUxMOworCXUzMiBuZXdfbW9kZSA9IFZNWE5FVDNfUlhNX1VDQVNUOworCisJaWYgKG5ldGRldi0+ZmxhZ3MgJiBJRkZfUFJPTUlTQykKKwkJbmV3X21vZGUgfD0gVk1YTkVUM19SWE1fUFJPTUlTQzsKKworCWlmIChuZXRkZXYtPmZsYWdzICYgSUZGX0JST0FEQ0FTVCkKKwkJbmV3X21vZGUgfD0gVk1YTkVUM19SWE1fQkNBU1Q7CisKKwlpZiAobmV0ZGV2LT5mbGFncyAmIElGRl9BTExNVUxUSSkKKwkJbmV3X21vZGUgfD0gVk1YTkVUM19SWE1fQUxMX01VTFRJOworCWVsc2UKKwkJaWYgKG5ldGRldi0+bWNfY291bnQgPiAwKSB7CisJCQluZXdfdGFibGUgPSB2bXhuZXQzX2NvcHlfbWMobmV0ZGV2KTsKKwkJCWlmIChuZXdfdGFibGUpIHsKKwkJCQluZXdfbW9kZSB8PSBWTVhORVQzX1JYTV9NQ0FTVDsKKwkJCQlyeENvbmYtPm1mVGFibGVMZW4gPSBuZXRkZXYtPm1jX2NvdW50ICoKKwkJCQkJCSAgICAgRVRIX0FMRU47CisJCQkJcnhDb25mLT5tZlRhYmxlUEEgPSB2aXJ0X3RvX3BoeXMobmV3X3RhYmxlKTsKKwkJCX0gZWxzZSB7CisJCQkJcHJpbnRrKEtFUk5fSU5GTyAiJXM6IGZhaWxlZCB0byBjb3B5IG1jYXN0IGxpc3QiCisJCQkJICAgICAgICIsIHNldHRpbmcgQUxMX01VTFRJXG4iLCBuZXRkZXYtPm5hbWUpOworCQkJCW5ld19tb2RlIHw9IFZNWE5FVDNfUlhNX0FMTF9NVUxUSTsKKwkJCX0KKwkJfQorCisKKwlpZiAoIShuZXdfbW9kZSAmIFZNWE5FVDNfUlhNX01DQVNUKSkgeworCQlyeENvbmYtPm1mVGFibGVMZW4gPSAwOworCQlyeENvbmYtPm1mVGFibGVQQSA9IDA7CisJfQorCisJaWYgKG5ld19tb2RlICE9IHJ4Q29uZi0+cnhNb2RlKSB7CisJCXJ4Q29uZi0+cnhNb2RlID0gbmV3X21vZGU7CisJCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJCSAgICAgICBWTVhORVQzX0NNRF9VUERBVEVfUlhfTU9ERSk7CisJfQorCisJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCisJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX01BQ19GSUxURVJTKTsKKworCWtmcmVlKG5ld190YWJsZSk7Cit9CisKKworLyoKKyAqICAgU2V0IHVwIGRyaXZlcl9zaGFyZWQgYmFzZWQgb24gc2V0dGluZ3MgaW4gYWRhcHRlci4KKyAqLworCitzdGF0aWMgdm9pZAordm14bmV0M19zZXR1cF9kcml2ZXJfc2hhcmVkKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJc3RydWN0IFZteG5ldDNfRHJpdmVyU2hhcmVkICpzaGFyZWQgPSBhZGFwdGVyLT5zaGFyZWQ7CisJc3RydWN0IFZteG5ldDNfRFNEZXZSZWFkICpkZXZSZWFkID0gJnNoYXJlZC0+ZGV2UmVhZDsKKwlzdHJ1Y3QgVm14bmV0M19UeFF1ZXVlQ29uZiAqdHFjOworCXN0cnVjdCBWbXhuZXQzX1J4UXVldWVDb25mICpycWM7CisJaW50IGk7CisKKwltZW1zZXQoc2hhcmVkLCAwLCBzaXplb2YoKnNoYXJlZCkpOworCisJLyogZHJpdmVyIHNldHRpbmdzICovCisJc2hhcmVkLT5tYWdpYyA9IFZNWE5FVDNfUkVWMV9NQUdJQzsKKwlkZXZSZWFkLT5taXNjLmRyaXZlckluZm8udmVyc2lvbiA9IFZNWE5FVDNfRFJJVkVSX1ZFUlNJT05fTlVNOworCWRldlJlYWQtPm1pc2MuZHJpdmVySW5mby5nb3MuZ29zQml0cyA9IChzaXplb2Yodm9pZCAqKSA9PSA0ID8KKwkJCQlWTVhORVQzX0dPU19CSVRTXzMyIDogVk1YTkVUM19HT1NfQklUU182NCk7CisJZGV2UmVhZC0+bWlzYy5kcml2ZXJJbmZvLmdvcy5nb3NUeXBlID0gVk1YTkVUM19HT1NfVFlQRV9MSU5VWDsKKwlkZXZSZWFkLT5taXNjLmRyaXZlckluZm8udm14bmV0M1JldlNwdCA9IDE7CisJZGV2UmVhZC0+bWlzYy5kcml2ZXJJbmZvLnVwdFZlclNwdCA9IDE7CisKKwlkZXZSZWFkLT5taXNjLmRkUEEgPSB2aXJ0X3RvX3BoeXMoYWRhcHRlcik7CisJZGV2UmVhZC0+bWlzYy5kZExlbiA9IHNpemVvZihzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyKTsKKworCS8qIHNldCB1cCBmZWF0dXJlIGZsYWdzICovCisJaWYgKGFkYXB0ZXItPnJ4Y3N1bSkKKwkJZGV2UmVhZC0+bWlzYy51cHRGZWF0dXJlcyB8PSBVUFQxX0ZfUlhDU1VNOworCisJaWYgKGFkYXB0ZXItPmxybykgeworCQlkZXZSZWFkLT5taXNjLnVwdEZlYXR1cmVzIHw9IFVQVDFfRl9MUk87CisJCWRldlJlYWQtPm1pc2MubWF4TnVtUnhTRyA9IDEgKyBNQVhfU0tCX0ZSQUdTOworCX0KKwlpZiAoKGFkYXB0ZXItPm5ldGRldi0+ZmVhdHVyZXMgJiBORVRJRl9GX0hXX1ZMQU5fUlgpCisJCQkmJiBhZGFwdGVyLT52bGFuX2dycCkgeworCQlkZXZSZWFkLT5taXNjLnVwdEZlYXR1cmVzIHw9IFVQVDFfRl9SWFZMQU47CisJfQorCisJZGV2UmVhZC0+bWlzYy5tdHUgPSBhZGFwdGVyLT5uZXRkZXYtPm10dTsKKwlkZXZSZWFkLT5taXNjLnF1ZXVlRGVzY1BBID0gYWRhcHRlci0+cXVldWVfZGVzY19wYTsKKwlkZXZSZWFkLT5taXNjLnF1ZXVlRGVzY0xlbiA9IHNpemVvZihzdHJ1Y3QgVm14bmV0M19UeFF1ZXVlRGVzYykgKworCQkJCSAgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1J4UXVldWVEZXNjKTsKKworCS8qIHR4IHF1ZXVlIHNldHRpbmdzICovCisJQlVHX09OKGFkYXB0ZXItPnR4X3F1ZXVlLnR4X3JpbmcuYmFzZSA9PSBOVUxMKTsKKworCWRldlJlYWQtPm1pc2MubnVtVHhRdWV1ZXMgPSAxOworCXRxYyA9ICZhZGFwdGVyLT50cWRfc3RhcnQtPmNvbmY7CisJdHFjLT50eFJpbmdCYXNlUEEgICA9IGFkYXB0ZXItPnR4X3F1ZXVlLnR4X3JpbmcuYmFzZVBBOworCXRxYy0+ZGF0YVJpbmdCYXNlUEEgPSBhZGFwdGVyLT50eF9xdWV1ZS5kYXRhX3JpbmcuYmFzZVBBOworCXRxYy0+Y29tcFJpbmdCYXNlUEEgPSBhZGFwdGVyLT50eF9xdWV1ZS5jb21wX3JpbmcuYmFzZVBBOworCXRxYy0+ZGRQQSAgICAgICAgICAgPSB2aXJ0X3RvX3BoeXMoYWRhcHRlci0+dHhfcXVldWUuYnVmX2luZm8pOworCXRxYy0+dHhSaW5nU2l6ZSAgICAgPSBhZGFwdGVyLT50eF9xdWV1ZS50eF9yaW5nLnNpemU7CisJdHFjLT5kYXRhUmluZ1NpemUgICA9IGFkYXB0ZXItPnR4X3F1ZXVlLmRhdGFfcmluZy5zaXplOworCXRxYy0+Y29tcFJpbmdTaXplICAgPSBhZGFwdGVyLT50eF9xdWV1ZS5jb21wX3Jpbmcuc2l6ZTsKKwl0cWMtPmRkTGVuICAgICAgICAgID0gc2l6ZW9mKHN0cnVjdCB2bXhuZXQzX3R4X2J1Zl9pbmZvKSAqCisJCQkgICAgICB0cWMtPnR4UmluZ1NpemU7CisJdHFjLT5pbnRySWR4ICAgICAgICA9IGFkYXB0ZXItPnR4X3F1ZXVlLmNvbXBfcmluZy5pbnRyX2lkeDsKKworCS8qIHJ4IHF1ZXVlIHNldHRpbmdzICovCisJZGV2UmVhZC0+bWlzYy5udW1SeFF1ZXVlcyA9IDE7CisJcnFjID0gJmFkYXB0ZXItPnJxZF9zdGFydC0+Y29uZjsKKwlycWMtPnJ4UmluZ0Jhc2VQQVswXSA9IGFkYXB0ZXItPnJ4X3F1ZXVlLnJ4X3JpbmdbMF0uYmFzZVBBOworCXJxYy0+cnhSaW5nQmFzZVBBWzFdID0gYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1sxXS5iYXNlUEE7CisJcnFjLT5jb21wUmluZ0Jhc2VQQSAgPSBhZGFwdGVyLT5yeF9xdWV1ZS5jb21wX3JpbmcuYmFzZVBBOworCXJxYy0+ZGRQQSAgICAgICAgICAgID0gdmlydF90b19waHlzKGFkYXB0ZXItPnJ4X3F1ZXVlLmJ1Zl9pbmZvKTsKKwlycWMtPnJ4UmluZ1NpemVbMF0gICA9IGFkYXB0ZXItPnJ4X3F1ZXVlLnJ4X3JpbmdbMF0uc2l6ZTsKKwlycWMtPnJ4UmluZ1NpemVbMV0gICA9IGFkYXB0ZXItPnJ4X3F1ZXVlLnJ4X3JpbmdbMV0uc2l6ZTsKKwlycWMtPmNvbXBSaW5nU2l6ZSAgICA9IGFkYXB0ZXItPnJ4X3F1ZXVlLmNvbXBfcmluZy5zaXplOworCXJxYy0+ZGRMZW4gICAgICAgICAgID0gc2l6ZW9mKHN0cnVjdCB2bXhuZXQzX3J4X2J1Zl9pbmZvKSAqCisJCQkgICAgICAgKHJxYy0+cnhSaW5nU2l6ZVswXSArIHJxYy0+cnhSaW5nU2l6ZVsxXSk7CisJcnFjLT5pbnRySWR4ICAgICAgICAgPSBhZGFwdGVyLT5yeF9xdWV1ZS5jb21wX3JpbmcuaW50cl9pZHg7CisKKwkvKiBpbnRyIHNldHRpbmdzICovCisJZGV2UmVhZC0+aW50ckNvbmYuYXV0b01hc2sgPSBhZGFwdGVyLT5pbnRyLm1hc2tfbW9kZSA9PQorCQkJCSAgICAgVk1YTkVUM19JTU1fQVVUTzsKKwlkZXZSZWFkLT5pbnRyQ29uZi5udW1JbnRycyA9IGFkYXB0ZXItPmludHIubnVtX2ludHJzOworCWZvciAoaSA9IDA7IGkgPCBhZGFwdGVyLT5pbnRyLm51bV9pbnRyczsgaSsrKQorCQlkZXZSZWFkLT5pbnRyQ29uZi5tb2RMZXZlbHNbaV0gPSBhZGFwdGVyLT5pbnRyLm1vZF9sZXZlbHNbaV07CisKKwlkZXZSZWFkLT5pbnRyQ29uZi5ldmVudEludHJJZHggPSBhZGFwdGVyLT5pbnRyLmV2ZW50X2ludHJfaWR4OworCisJLyogcnggZmlsdGVyIHNldHRpbmdzICovCisJZGV2UmVhZC0+cnhGaWx0ZXJDb25mLnJ4TW9kZSA9IDA7CisJdm14bmV0M19yZXN0b3JlX3ZsYW4oYWRhcHRlcik7CisJLyogdGhlIHJlc3QgYXJlIGFscmVhZHkgemVyb2VkICovCit9CisKKworaW50Cit2bXhuZXQzX2FjdGl2YXRlX2RldihzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWludCBlcnI7CisJdTMyIHJldDsKKworCWRldl9kYmcoJmFkYXB0ZXItPm5ldGRldi0+ZGV2LAorCQkiJXM6IHNrYl9idWZfc2l6ZSAlZCwgcnhfYnVmX3Blcl9wa3QgJWQsIHJpbmcgc2l6ZXMiCisJCSIgJXUgJXUgJXVcbiIsIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwgYWRhcHRlci0+c2tiX2J1Zl9zaXplLAorCQlhZGFwdGVyLT5yeF9idWZfcGVyX3BrdCwgYWRhcHRlci0+dHhfcXVldWUudHhfcmluZy5zaXplLAorCQlhZGFwdGVyLT5yeF9xdWV1ZS5yeF9yaW5nWzBdLnNpemUsCisJCWFkYXB0ZXItPnJ4X3F1ZXVlLnJ4X3JpbmdbMV0uc2l6ZSk7CisKKwl2bXhuZXQzX3RxX2luaXQoJmFkYXB0ZXItPnR4X3F1ZXVlLCBhZGFwdGVyKTsKKwllcnIgPSB2bXhuZXQzX3JxX2luaXQoJmFkYXB0ZXItPnJ4X3F1ZXVlLCBhZGFwdGVyKTsKKwlpZiAoZXJyKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIGluaXQgcnggcXVldWUgZm9yICVzOiBlcnJvciAlZFxuIiwKKwkJICAgICAgIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwgZXJyKTsKKwkJZ290byBycV9lcnI7CisJfQorCisJZXJyID0gdm14bmV0M19yZXF1ZXN0X2lycXMoYWRhcHRlcik7CisJaWYgKGVycikgeworCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byBzZXR1cCBpcnEgZm9yICVzOiBlcnJvciAlZFxuIiwKKwkJICAgICAgIGFkYXB0ZXItPm5ldGRldi0+bmFtZSwgZXJyKTsKKwkJZ290byBpcnFfZXJyOworCX0KKworCXZteG5ldDNfc2V0dXBfZHJpdmVyX3NoYXJlZChhZGFwdGVyKTsKKworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfRFNBTCwKKwkJCSAgICAgICBWTVhORVQzX0dFVF9BRERSX0xPKGFkYXB0ZXItPnNoYXJlZF9wYSkpOworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfRFNBSCwKKwkJCSAgICAgICBWTVhORVQzX0dFVF9BRERSX0hJKGFkYXB0ZXItPnNoYXJlZF9wYSkpOworCisJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsCisJCQkgICAgICAgVk1YTkVUM19DTURfQUNUSVZBVEVfREVWKTsKKwlyZXQgPSBWTVhORVQzX1JFQURfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01EKTsKKworCWlmIChyZXQgIT0gMCkgeworCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byBhY3RpdmF0ZSBkZXYgJXM6IGVycm9yICV1XG4iLAorCQkgICAgICAgYWRhcHRlci0+bmV0ZGV2LT5uYW1lLCByZXQpOworCQllcnIgPSAtRUlOVkFMOworCQlnb3RvIGFjdGl2YXRlX2VycjsKKwl9CisJVk1YTkVUM19XUklURV9CQVIwX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19SWFBST0QsCisJCQkgICAgICAgYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5uZXh0MmZpbGwpOworCVZNWE5FVDNfV1JJVEVfQkFSMF9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfUlhQUk9EMiwKKwkJCSAgICAgICBhZGFwdGVyLT5yeF9xdWV1ZS5yeF9yaW5nWzFdLm5leHQyZmlsbCk7CisKKwkvKiBBcHBseSB0aGUgcnggZmlsdGVyIHNldHRpbnMgbGFzdC4gKi8KKwl2bXhuZXQzX3NldF9tYyhhZGFwdGVyLT5uZXRkZXYpOworCisJLyoKKwkgKiBDaGVjayBsaW5rIHN0YXRlIHdoZW4gZmlyc3QgYWN0aXZhdGluZyBkZXZpY2UuIEl0IHdpbGwgc3RhcnQgdGhlCisJICogdHggcXVldWUgaWYgdGhlIGxpbmsgaXMgdXAuCisJICovCisJdm14bmV0M19jaGVja19saW5rKGFkYXB0ZXIpOworCisJbmFwaV9lbmFibGUoJmFkYXB0ZXItPm5hcGkpOworCXZteG5ldDNfZW5hYmxlX2FsbF9pbnRycyhhZGFwdGVyKTsKKwljbGVhcl9iaXQoVk1YTkVUM19TVEFURV9CSVRfUVVJRVNDRUQsICZhZGFwdGVyLT5zdGF0ZSk7CisJcmV0dXJuIDA7CisKK2FjdGl2YXRlX2VycjoKKwlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0RTQUwsIDApOworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfRFNBSCwgMCk7CisJdm14bmV0M19mcmVlX2lycXMoYWRhcHRlcik7CitpcnFfZXJyOgorcnFfZXJyOgorCS8qIGZyZWUgdXAgYnVmZmVycyB3ZSBhbGxvY2F0ZWQgKi8KKwl2bXhuZXQzX3JxX2NsZWFudXAoJmFkYXB0ZXItPnJ4X3F1ZXVlLCBhZGFwdGVyKTsKKwlyZXR1cm4gZXJyOworfQorCisKK3ZvaWQKK3ZteG5ldDNfcmVzZXRfZGV2KHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19DTUQsIFZNWE5FVDNfQ01EX1JFU0VUX0RFVik7Cit9CisKKworaW50Cit2bXhuZXQzX3F1aWVzY2VfZGV2KHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJaWYgKHRlc3RfYW5kX3NldF9iaXQoVk1YTkVUM19TVEFURV9CSVRfUVVJRVNDRUQsICZhZGFwdGVyLT5zdGF0ZSkpCisJCXJldHVybiAwOworCisKKwlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwKKwkJCSAgICAgICBWTVhORVQzX0NNRF9RVUlFU0NFX0RFVik7CisJdm14bmV0M19kaXNhYmxlX2FsbF9pbnRycyhhZGFwdGVyKTsKKworCW5hcGlfZGlzYWJsZSgmYWRhcHRlci0+bmFwaSk7CisJbmV0aWZfdHhfZGlzYWJsZShhZGFwdGVyLT5uZXRkZXYpOworCWFkYXB0ZXItPmxpbmtfc3BlZWQgPSAwOworCW5ldGlmX2NhcnJpZXJfb2ZmKGFkYXB0ZXItPm5ldGRldik7CisKKwl2bXhuZXQzX3RxX2NsZWFudXAoJmFkYXB0ZXItPnR4X3F1ZXVlLCBhZGFwdGVyKTsKKwl2bXhuZXQzX3JxX2NsZWFudXAoJmFkYXB0ZXItPnJ4X3F1ZXVlLCBhZGFwdGVyKTsKKwl2bXhuZXQzX2ZyZWVfaXJxcyhhZGFwdGVyKTsKKwlyZXR1cm4gMDsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M193cml0ZV9tYWNfYWRkcihzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyLCB1OCAqbWFjKQoreworCXUzMiB0bXA7CisKKwl0bXAgPSAqKHUzMiAqKW1hYzsKKwlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX01BQ0wsIHRtcCk7CisKKwl0bXAgPSAobWFjWzVdIDw8IDgpIHwgbWFjWzRdOworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfTUFDSCwgdG1wKTsKK30KKworCitzdGF0aWMgaW50Cit2bXhuZXQzX3NldF9tYWNfYWRkcihzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCB2b2lkICpwKQoreworCXN0cnVjdCBzb2NrYWRkciAqYWRkciA9IHA7CisJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisKKwltZW1jcHkobmV0ZGV2LT5kZXZfYWRkciwgYWRkci0+c2FfZGF0YSwgbmV0ZGV2LT5hZGRyX2xlbik7CisJdm14bmV0M193cml0ZV9tYWNfYWRkcihhZGFwdGVyLCBhZGRyLT5zYV9kYXRhKTsKKworCXJldHVybiAwOworfQorCisKKy8qID09PT09PT09PT09PT09PT09PT09IGluaXRpYWxpemF0aW9uIGFuZCBjbGVhbnVwIHJvdXRpbmVzID09PT09PT09PT09PSAqLworCitzdGF0aWMgaW50Cit2bXhuZXQzX2FsbG9jX3BjaV9yZXNvdXJjZXMoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciwgYm9vbCAqZG1hNjQpCit7CisJaW50IGVycjsKKwl1bnNpZ25lZCBsb25nIG1taW9fc3RhcnQsIG1taW9fbGVuOworCXN0cnVjdCBwY2lfZGV2ICpwZGV2ID0gYWRhcHRlci0+cGRldjsKKworCWVyciA9IHBjaV9lbmFibGVfZGV2aWNlKHBkZXYpOworCWlmIChlcnIpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gZW5hYmxlIGFkYXB0ZXIgJXM6IGVycm9yICVkXG4iLAorCQkgICAgICAgcGNpX25hbWUocGRldiksIGVycik7CisJCXJldHVybiBlcnI7CisJfQorCisJaWYgKHBjaV9zZXRfZG1hX21hc2socGRldiwgRE1BX0JJVF9NQVNLKDY0KSkgPT0gMCkgeworCQlpZiAocGNpX3NldF9jb25zaXN0ZW50X2RtYV9tYXNrKHBkZXYsIERNQV9CSVRfTUFTSyg2NCkpICE9IDApIHsKKwkJCXByaW50ayhLRVJOX0VSUiAicGNpX3NldF9jb25zaXN0ZW50X2RtYV9tYXNrIGZhaWxlZCAiCisJCQkgICAgICAgImZvciBhZGFwdGVyICVzXG4iLCBwY2lfbmFtZShwZGV2KSk7CisJCQllcnIgPSAtRUlPOworCQkJZ290byBlcnJfc2V0X21hc2s7CisJCX0KKwkJKmRtYTY0ID0gdHJ1ZTsKKwl9IGVsc2UgeworCQlpZiAocGNpX3NldF9kbWFfbWFzayhwZGV2LCBETUFfQklUX01BU0soMzIpKSAhPSAwKSB7CisJCQlwcmludGsoS0VSTl9FUlIgInBjaV9zZXRfZG1hX21hc2sgZmFpbGVkIGZvciBhZGFwdGVyICIKKwkJCSAgICAgICAiJXNcbiIsCXBjaV9uYW1lKHBkZXYpKTsKKwkJCWVyciA9IC1FSU87CisJCQlnb3RvIGVycl9zZXRfbWFzazsKKwkJfQorCQkqZG1hNjQgPSBmYWxzZTsKKwl9CisKKwllcnIgPSBwY2lfcmVxdWVzdF9zZWxlY3RlZF9yZWdpb25zKHBkZXYsICgxIDw8IDIpIC0gMSwKKwkJCQkJICAgdm14bmV0M19kcml2ZXJfbmFtZSk7CisJaWYgKGVycikgeworCQlwcmludGsoS0VSTl9FUlIgIkZhaWxlZCB0byByZXF1ZXN0IHJlZ2lvbiBmb3IgYWRhcHRlciAlczogIgorCQkgICAgICAgImVycm9yICVkXG4iLCBwY2lfbmFtZShwZGV2KSwgZXJyKTsKKwkJZ290byBlcnJfc2V0X21hc2s7CisJfQorCisJcGNpX3NldF9tYXN0ZXIocGRldik7CisKKwltbWlvX3N0YXJ0ID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBkZXYsIDApOworCW1taW9fbGVuID0gcGNpX3Jlc291cmNlX2xlbihwZGV2LCAwKTsKKwlhZGFwdGVyLT5od19hZGRyMCA9IGlvcmVtYXAobW1pb19zdGFydCwgbW1pb19sZW4pOworCWlmICghYWRhcHRlci0+aHdfYWRkcjApIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gbWFwIGJhcjAgZm9yIGFkYXB0ZXIgJXNcbiIsCisJCSAgICAgICBwY2lfbmFtZShwZGV2KSk7CisJCWVyciA9IC1FSU87CisJCWdvdG8gZXJyX2lvcmVtYXA7CisJfQorCisJbW1pb19zdGFydCA9IHBjaV9yZXNvdXJjZV9zdGFydChwZGV2LCAxKTsKKwltbWlvX2xlbiA9IHBjaV9yZXNvdXJjZV9sZW4ocGRldiwgMSk7CisJYWRhcHRlci0+aHdfYWRkcjEgPSBpb3JlbWFwKG1taW9fc3RhcnQsIG1taW9fbGVuKTsKKwlpZiAoIWFkYXB0ZXItPmh3X2FkZHIxKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIG1hcCBiYXIxIGZvciBhZGFwdGVyICVzXG4iLAorCQkgICAgICAgcGNpX25hbWUocGRldikpOworCQllcnIgPSAtRUlPOworCQlnb3RvIGVycl9iYXIxOworCX0KKwlyZXR1cm4gMDsKKworZXJyX2JhcjE6CisJaW91bm1hcChhZGFwdGVyLT5od19hZGRyMCk7CitlcnJfaW9yZW1hcDoKKwlwY2lfcmVsZWFzZV9zZWxlY3RlZF9yZWdpb25zKHBkZXYsICgxIDw8IDIpIC0gMSk7CitlcnJfc2V0X21hc2s6CisJcGNpX2Rpc2FibGVfZGV2aWNlKHBkZXYpOworCXJldHVybiBlcnI7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZnJlZV9wY2lfcmVzb3VyY2VzKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJQlVHX09OKCFhZGFwdGVyLT5wZGV2KTsKKworCWlvdW5tYXAoYWRhcHRlci0+aHdfYWRkcjApOworCWlvdW5tYXAoYWRhcHRlci0+aHdfYWRkcjEpOworCXBjaV9yZWxlYXNlX3NlbGVjdGVkX3JlZ2lvbnMoYWRhcHRlci0+cGRldiwgKDEgPDwgMikgLSAxKTsKKwlwY2lfZGlzYWJsZV9kZXZpY2UoYWRhcHRlci0+cGRldik7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfYWRqdXN0X3J4X3Jpbmdfc2l6ZShzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCXNpemVfdCBzejsKKworCWlmIChhZGFwdGVyLT5uZXRkZXYtPm10dSA8PSBWTVhORVQzX01BWF9TS0JfQlVGX1NJWkUgLQorCQkJCSAgICBWTVhORVQzX01BWF9FVEhfSERSX1NJWkUpIHsKKwkJYWRhcHRlci0+c2tiX2J1Zl9zaXplID0gYWRhcHRlci0+bmV0ZGV2LT5tdHUgKworCQkJCQlWTVhORVQzX01BWF9FVEhfSERSX1NJWkU7CisJCWlmIChhZGFwdGVyLT5za2JfYnVmX3NpemUgPCBWTVhORVQzX01JTl9UMF9CVUZfU0laRSkKKwkJCWFkYXB0ZXItPnNrYl9idWZfc2l6ZSA9IFZNWE5FVDNfTUlOX1QwX0JVRl9TSVpFOworCisJCWFkYXB0ZXItPnJ4X2J1Zl9wZXJfcGt0ID0gMTsKKwl9IGVsc2UgeworCQlhZGFwdGVyLT5za2JfYnVmX3NpemUgPSBWTVhORVQzX01BWF9TS0JfQlVGX1NJWkU7CisJCXN6ID0gYWRhcHRlci0+bmV0ZGV2LT5tdHUgLSBWTVhORVQzX01BWF9TS0JfQlVGX1NJWkUgKworCQkJCQkgICAgVk1YTkVUM19NQVhfRVRIX0hEUl9TSVpFOworCQlhZGFwdGVyLT5yeF9idWZfcGVyX3BrdCA9IDEgKyAoc3ogKyBQQUdFX1NJWkUgLSAxKSAvIFBBR0VfU0laRTsKKwl9CisKKwkvKgorCSAqIGZvciBzaW1wbGljaXR5LCBmb3JjZSB0aGUgcmluZzAgc2l6ZSB0byBiZSBhIG11bHRpcGxlIG9mCisJICogcnhfYnVmX3Blcl9wa3QgKiBWTVhORVQzX1JJTkdfU0laRV9BTElHTgorCSAqLworCXN6ID0gYWRhcHRlci0+cnhfYnVmX3Blcl9wa3QgKiBWTVhORVQzX1JJTkdfU0laRV9BTElHTjsKKwlhZGFwdGVyLT5yeF9xdWV1ZS5yeF9yaW5nWzBdLnNpemUgPSAoYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5zaXplICsKKwkJCQkJICAgICBzeiAtIDEpIC8gc3ogKiBzejsKKwlhZGFwdGVyLT5yeF9xdWV1ZS5yeF9yaW5nWzBdLnNpemUgPSBtaW5fdCh1MzIsCisJCQkJCSAgICBhZGFwdGVyLT5yeF9xdWV1ZS5yeF9yaW5nWzBdLnNpemUsCisJCQkJCSAgICBWTVhORVQzX1JYX1JJTkdfTUFYX1NJWkUgLyBzeiAqIHN6KTsKK30KKworCitpbnQKK3ZteG5ldDNfY3JlYXRlX3F1ZXVlcyhzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyLCB1MzIgdHhfcmluZ19zaXplLAorCQkgICAgICB1MzIgcnhfcmluZ19zaXplLCB1MzIgcnhfcmluZzJfc2l6ZSkKK3sKKwlpbnQgZXJyOworCisJYWRhcHRlci0+dHhfcXVldWUudHhfcmluZy5zaXplICAgPSB0eF9yaW5nX3NpemU7CisJYWRhcHRlci0+dHhfcXVldWUuZGF0YV9yaW5nLnNpemUgPSB0eF9yaW5nX3NpemU7CisJYWRhcHRlci0+dHhfcXVldWUuY29tcF9yaW5nLnNpemUgPSB0eF9yaW5nX3NpemU7CisJYWRhcHRlci0+dHhfcXVldWUuc2hhcmVkID0gJmFkYXB0ZXItPnRxZF9zdGFydC0+Y3RybDsKKwlhZGFwdGVyLT50eF9xdWV1ZS5zdG9wcGVkID0gdHJ1ZTsKKwllcnIgPSB2bXhuZXQzX3RxX2NyZWF0ZSgmYWRhcHRlci0+dHhfcXVldWUsIGFkYXB0ZXIpOworCWlmIChlcnIpCisJCXJldHVybiBlcnI7CisKKwlhZGFwdGVyLT5yeF9xdWV1ZS5yeF9yaW5nWzBdLnNpemUgPSByeF9yaW5nX3NpemU7CisJYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1sxXS5zaXplID0gcnhfcmluZzJfc2l6ZTsKKwl2bXhuZXQzX2FkanVzdF9yeF9yaW5nX3NpemUoYWRhcHRlcik7CisJYWRhcHRlci0+cnhfcXVldWUuY29tcF9yaW5nLnNpemUgID0gYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5zaXplICsKKwkJCQkJICAgIGFkYXB0ZXItPnJ4X3F1ZXVlLnJ4X3JpbmdbMV0uc2l6ZTsKKwlhZGFwdGVyLT5yeF9xdWV1ZS5xaWQgID0gMDsKKwlhZGFwdGVyLT5yeF9xdWV1ZS5xaWQyID0gMTsKKwlhZGFwdGVyLT5yeF9xdWV1ZS5zaGFyZWQgPSAmYWRhcHRlci0+cnFkX3N0YXJ0LT5jdHJsOworCWVyciA9IHZteG5ldDNfcnFfY3JlYXRlKCZhZGFwdGVyLT5yeF9xdWV1ZSwgYWRhcHRlcik7CisJaWYgKGVycikKKwkJdm14bmV0M190cV9kZXN0cm95KCZhZGFwdGVyLT50eF9xdWV1ZSwgYWRhcHRlcik7CisKKwlyZXR1cm4gZXJyOworfQorCitzdGF0aWMgaW50Cit2bXhuZXQzX29wZW4oc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyOworCWludCBlcnI7CisKKwlhZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCXNwaW5fbG9ja19pbml0KCZhZGFwdGVyLT50eF9xdWV1ZS50eF9sb2NrKTsKKworCWVyciA9IHZteG5ldDNfY3JlYXRlX3F1ZXVlcyhhZGFwdGVyLCBWTVhORVQzX0RFRl9UWF9SSU5HX1NJWkUsCisJCQkJICAgIFZNWE5FVDNfREVGX1JYX1JJTkdfU0laRSwKKwkJCQkgICAgVk1YTkVUM19ERUZfUlhfUklOR19TSVpFKTsKKwlpZiAoZXJyKQorCQlnb3RvIHF1ZXVlX2VycjsKKworCWVyciA9IHZteG5ldDNfYWN0aXZhdGVfZGV2KGFkYXB0ZXIpOworCWlmIChlcnIpCisJCWdvdG8gYWN0aXZhdGVfZXJyOworCisJcmV0dXJuIDA7CisKK2FjdGl2YXRlX2VycjoKKwl2bXhuZXQzX3JxX2Rlc3Ryb3koJmFkYXB0ZXItPnJ4X3F1ZXVlLCBhZGFwdGVyKTsKKwl2bXhuZXQzX3RxX2Rlc3Ryb3koJmFkYXB0ZXItPnR4X3F1ZXVlLCBhZGFwdGVyKTsKK3F1ZXVlX2VycjoKKwlyZXR1cm4gZXJyOworfQorCisKK3N0YXRpYyBpbnQKK3ZteG5ldDNfY2xvc2Uoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCS8qCisJICogUmVzZXRfd29yayBtYXkgYmUgaW4gdGhlIG1pZGRsZSBvZiByZXNldHRpbmcgdGhlIGRldmljZSwgd2FpdCBmb3IgaXRzCisJICogY29tcGxldGlvbi4KKwkgKi8KKwl3aGlsZSAodGVzdF9hbmRfc2V0X2JpdChWTVhORVQzX1NUQVRFX0JJVF9SRVNFVFRJTkcsICZhZGFwdGVyLT5zdGF0ZSkpCisJCW1zbGVlcCgxKTsKKworCXZteG5ldDNfcXVpZXNjZV9kZXYoYWRhcHRlcik7CisKKwl2bXhuZXQzX3JxX2Rlc3Ryb3koJmFkYXB0ZXItPnJ4X3F1ZXVlLCBhZGFwdGVyKTsKKwl2bXhuZXQzX3RxX2Rlc3Ryb3koJmFkYXB0ZXItPnR4X3F1ZXVlLCBhZGFwdGVyKTsKKworCWNsZWFyX2JpdChWTVhORVQzX1NUQVRFX0JJVF9SRVNFVFRJTkcsICZhZGFwdGVyLT5zdGF0ZSk7CisKKworCXJldHVybiAwOworfQorCisKK3ZvaWQKK3ZteG5ldDNfZm9yY2VfY2xvc2Uoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcikKK3sKKwkvKgorCSAqIHdlIG11c3QgY2xlYXIgVk1YTkVUM19TVEFURV9CSVRfUkVTRVRUSU5HLCBvdGhlcndpc2UKKwkgKiB2bXhuZXQzX2Nsb3NlKCkgd2lsbCBkZWFkbG9jay4KKwkgKi8KKwlCVUdfT04odGVzdF9iaXQoVk1YTkVUM19TVEFURV9CSVRfUkVTRVRUSU5HLCAmYWRhcHRlci0+c3RhdGUpKTsKKworCS8qIHdlIG5lZWQgdG8gZW5hYmxlIE5BUEksIG90aGVyd2lzZSBkZXZfY2xvc2Ugd2lsbCBkZWFkbG9jayAqLworCW5hcGlfZW5hYmxlKCZhZGFwdGVyLT5uYXBpKTsKKwlkZXZfY2xvc2UoYWRhcHRlci0+bmV0ZGV2KTsKK30KKworCitzdGF0aWMgaW50Cit2bXhuZXQzX2NoYW5nZV9tdHUoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgaW50IG5ld19tdHUpCit7CisJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJaW50IGVyciA9IDA7CisKKwlpZiAobmV3X210dSA8IFZNWE5FVDNfTUlOX01UVSB8fCBuZXdfbXR1ID4gVk1YTkVUM19NQVhfTVRVKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChuZXdfbXR1ID4gMTUwMCAmJiAhYWRhcHRlci0+anVtYm9fZnJhbWUpCisJCXJldHVybiAtRUlOVkFMOworCisJbmV0ZGV2LT5tdHUgPSBuZXdfbXR1OworCisJLyoKKwkgKiBSZXNldF93b3JrIG1heSBiZSBpbiB0aGUgbWlkZGxlIG9mIHJlc2V0dGluZyB0aGUgZGV2aWNlLCB3YWl0IGZvciBpdHMKKwkgKiBjb21wbGV0aW9uLgorCSAqLworCXdoaWxlICh0ZXN0X2FuZF9zZXRfYml0KFZNWE5FVDNfU1RBVEVfQklUX1JFU0VUVElORywgJmFkYXB0ZXItPnN0YXRlKSkKKwkJbXNsZWVwKDEpOworCisJaWYgKG5ldGlmX3J1bm5pbmcobmV0ZGV2KSkgeworCQl2bXhuZXQzX3F1aWVzY2VfZGV2KGFkYXB0ZXIpOworCQl2bXhuZXQzX3Jlc2V0X2RldihhZGFwdGVyKTsKKworCQkvKiB3ZSBuZWVkIHRvIHJlLWNyZWF0ZSB0aGUgcnggcXVldWUgYmFzZWQgb24gdGhlIG5ldyBtdHUgKi8KKwkJdm14bmV0M19ycV9kZXN0cm95KCZhZGFwdGVyLT5yeF9xdWV1ZSwgYWRhcHRlcik7CisJCXZteG5ldDNfYWRqdXN0X3J4X3Jpbmdfc2l6ZShhZGFwdGVyKTsKKwkJYWRhcHRlci0+cnhfcXVldWUuY29tcF9yaW5nLnNpemUgID0KKwkJCQkJYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5zaXplICsKKwkJCQkJYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1sxXS5zaXplOworCQllcnIgPSB2bXhuZXQzX3JxX2NyZWF0ZSgmYWRhcHRlci0+cnhfcXVldWUsIGFkYXB0ZXIpOworCQlpZiAoZXJyKSB7CisJCQlwcmludGsoS0VSTl9FUlIgIiVzOiBmYWlsZWQgdG8gcmUtY3JlYXRlIHJ4IHF1ZXVlLCIKKwkJCQkiIGVycm9yICVkLiBDbG9zaW5nIGl0LlxuIiwgbmV0ZGV2LT5uYW1lLCBlcnIpOworCQkJZ290byBvdXQ7CisJCX0KKworCQllcnIgPSB2bXhuZXQzX2FjdGl2YXRlX2RldihhZGFwdGVyKTsKKwkJaWYgKGVycikgeworCQkJcHJpbnRrKEtFUk5fRVJSICIlczogZmFpbGVkIHRvIHJlLWFjdGl2YXRlLCBlcnJvciAlZC4gIgorCQkJCSJDbG9zaW5nIGl0XG4iLCBuZXRkZXYtPm5hbWUsIGVycik7CisJCQlnb3RvIG91dDsKKwkJfQorCX0KKworb3V0OgorCWNsZWFyX2JpdChWTVhORVQzX1NUQVRFX0JJVF9SRVNFVFRJTkcsICZhZGFwdGVyLT5zdGF0ZSk7CisJaWYgKGVycikKKwkJdm14bmV0M19mb3JjZV9jbG9zZShhZGFwdGVyKTsKKworCXJldHVybiBlcnI7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZGVjbGFyZV9mZWF0dXJlcyhzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyLCBib29sIGRtYTY0KQoreworCXN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYgPSBhZGFwdGVyLT5uZXRkZXY7CisKKwluZXRkZXYtPmZlYXR1cmVzID0gTkVUSUZfRl9TRyB8CisJCU5FVElGX0ZfSFdfQ1NVTSB8CisJCU5FVElGX0ZfSFdfVkxBTl9UWCB8CisJCU5FVElGX0ZfSFdfVkxBTl9SWCB8CisJCU5FVElGX0ZfSFdfVkxBTl9GSUxURVIgfAorCQlORVRJRl9GX1RTTyB8CisJCU5FVElGX0ZfVFNPNiB8CisJCU5FVElGX0ZfTFJPOworCisJcHJpbnRrKEtFUk5fSU5GTyAiZmVhdHVyZXM6IHNnIGNzdW0gdmxhbiBqZiB0c28gdHNvSVB2NiBscm8iKTsKKworCWFkYXB0ZXItPnJ4Y3N1bSA9IHRydWU7CisJYWRhcHRlci0+anVtYm9fZnJhbWUgPSB0cnVlOworCWFkYXB0ZXItPmxybyA9IHRydWU7CisKKwlpZiAoZG1hNjQpIHsKKwkJbmV0ZGV2LT5mZWF0dXJlcyB8PSBORVRJRl9GX0hJR0hETUE7CisJCXByaW50aygiIGhpZ2hETUEiKTsKKwl9CisKKwluZXRkZXYtPnZsYW5fZmVhdHVyZXMgPSBuZXRkZXYtPmZlYXR1cmVzOworCXByaW50aygiXG4iKTsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19yZWFkX21hY19hZGRyKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIsIHU4ICptYWMpCit7CisJdTMyIHRtcDsKKworCXRtcCA9IFZNWE5FVDNfUkVBRF9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19NQUNMKTsKKwkqKHUzMiAqKW1hYyA9IHRtcDsKKworCXRtcCA9IFZNWE5FVDNfUkVBRF9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19NQUNIKTsKKwltYWNbNF0gPSB0bXAgJiAweGZmOworCW1hY1s1XSA9ICh0bXAgPj4gOCkgJiAweGZmOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX2FsbG9jX2ludHJfcmVzb3VyY2VzKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpCit7CisJdTMyIGNmZzsKKworCS8qIGludHIgc2V0dGluZ3MgKi8KKwlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwKKwkJCSAgICAgICBWTVhORVQzX0NNRF9HRVRfQ09ORl9JTlRSKTsKKwljZmcgPSBWTVhORVQzX1JFQURfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01EKTsKKwlhZGFwdGVyLT5pbnRyLnR5cGUgPSBjZmcgJiAweDM7CisJYWRhcHRlci0+aW50ci5tYXNrX21vZGUgPSAoY2ZnID4+IDIpICYgMHgzOworCisJaWYgKGFkYXB0ZXItPmludHIudHlwZSA9PSBWTVhORVQzX0lUX0FVVE8pIHsKKwkJaW50IGVycjsKKworI2lmZGVmIENPTkZJR19QQ0lfTVNJCisJCWFkYXB0ZXItPmludHIubXNpeF9lbnRyaWVzWzBdLmVudHJ5ID0gMDsKKwkJZXJyID0gcGNpX2VuYWJsZV9tc2l4KGFkYXB0ZXItPnBkZXYsIGFkYXB0ZXItPmludHIubXNpeF9lbnRyaWVzLAorCQkJCSAgICAgIFZNWE5FVDNfTElOVVhfTUFYX01TSVhfVkVDVCk7CisJCWlmICghZXJyKSB7CisJCQlhZGFwdGVyLT5pbnRyLm51bV9pbnRycyA9IDE7CisJCQlhZGFwdGVyLT5pbnRyLnR5cGUgPSBWTVhORVQzX0lUX01TSVg7CisJCQlyZXR1cm47CisJCX0KKyNlbmRpZgorCisJCWVyciA9IHBjaV9lbmFibGVfbXNpKGFkYXB0ZXItPnBkZXYpOworCQlpZiAoIWVycikgeworCQkJYWRhcHRlci0+aW50ci5udW1faW50cnMgPSAxOworCQkJYWRhcHRlci0+aW50ci50eXBlID0gVk1YTkVUM19JVF9NU0k7CisJCQlyZXR1cm47CisJCX0KKwl9CisKKwlhZGFwdGVyLT5pbnRyLnR5cGUgPSBWTVhORVQzX0lUX0lOVFg7CisKKwkvKiBJTlQtWCByZWxhdGVkIHNldHRpbmcgKi8KKwlhZGFwdGVyLT5pbnRyLm51bV9pbnRycyA9IDE7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZnJlZV9pbnRyX3Jlc291cmNlcyhzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKQoreworCWlmIChhZGFwdGVyLT5pbnRyLnR5cGUgPT0gVk1YTkVUM19JVF9NU0lYKQorCQlwY2lfZGlzYWJsZV9tc2l4KGFkYXB0ZXItPnBkZXYpOworCWVsc2UgaWYgKGFkYXB0ZXItPmludHIudHlwZSA9PSBWTVhORVQzX0lUX01TSSkKKwkJcGNpX2Rpc2FibGVfbXNpKGFkYXB0ZXItPnBkZXYpOworCWVsc2UKKwkJQlVHX09OKGFkYXB0ZXItPmludHIudHlwZSAhPSBWTVhORVQzX0lUX0lOVFgpOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX3R4X3RpbWVvdXQoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwlhZGFwdGVyLT50eF90aW1lb3V0X2NvdW50Kys7CisKKwlwcmludGsoS0VSTl9FUlIgIiVzOiB0eCBoYW5nXG4iLCBhZGFwdGVyLT5uZXRkZXYtPm5hbWUpOworCXNjaGVkdWxlX3dvcmsoJmFkYXB0ZXItPndvcmspOworfQorCisKK3N0YXRpYyB2b2lkCit2bXhuZXQzX3Jlc2V0X3dvcmsoc3RydWN0IHdvcmtfc3RydWN0ICpkYXRhKQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXI7CisKKwlhZGFwdGVyID0gY29udGFpbmVyX29mKGRhdGEsIHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIsIHdvcmspOworCisJLyogaWYgYW5vdGhlciB0aHJlYWQgaXMgcmVzZXR0aW5nIHRoZSBkZXZpY2UsIG5vIG5lZWQgdG8gcHJvY2VlZCAqLworCWlmICh0ZXN0X2FuZF9zZXRfYml0KFZNWE5FVDNfU1RBVEVfQklUX1JFU0VUVElORywgJmFkYXB0ZXItPnN0YXRlKSkKKwkJcmV0dXJuOworCisJLyogaWYgdGhlIGRldmljZSBpcyBjbG9zZWQsIHdlIG11c3QgbGVhdmUgaXQgYWxvbmUgKi8KKwlpZiAobmV0aWZfcnVubmluZyhhZGFwdGVyLT5uZXRkZXYpKSB7CisJCXByaW50ayhLRVJOX0lORk8gIiVzOiByZXNldHRpbmdcbiIsIGFkYXB0ZXItPm5ldGRldi0+bmFtZSk7CisJCXZteG5ldDNfcXVpZXNjZV9kZXYoYWRhcHRlcik7CisJCXZteG5ldDNfcmVzZXRfZGV2KGFkYXB0ZXIpOworCQl2bXhuZXQzX2FjdGl2YXRlX2RldihhZGFwdGVyKTsKKwl9IGVsc2UgeworCQlwcmludGsoS0VSTl9JTkZPICIlczogYWxyZWFkeSBjbG9zZWRcbiIsIGFkYXB0ZXItPm5ldGRldi0+bmFtZSk7CisJfQorCisJY2xlYXJfYml0KFZNWE5FVDNfU1RBVEVfQklUX1JFU0VUVElORywgJmFkYXB0ZXItPnN0YXRlKTsKK30KKworCitzdGF0aWMgaW50IF9fZGV2aW5pdAordm14bmV0M19wcm9iZV9kZXZpY2Uoc3RydWN0IHBjaV9kZXYgKnBkZXYsCisJCSAgICAgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQoreworCXN0YXRpYyBjb25zdCBzdHJ1Y3QgbmV0X2RldmljZV9vcHMgdm14bmV0M19uZXRkZXZfb3BzID0geworCQkubmRvX29wZW4gPSB2bXhuZXQzX29wZW4sCisJCS5uZG9fc3RvcCA9IHZteG5ldDNfY2xvc2UsCisJCS5uZG9fc3RhcnRfeG1pdCA9IHZteG5ldDNfeG1pdF9mcmFtZSwKKwkJLm5kb19zZXRfbWFjX2FkZHJlc3MgPSB2bXhuZXQzX3NldF9tYWNfYWRkciwKKwkJLm5kb19jaGFuZ2VfbXR1ID0gdm14bmV0M19jaGFuZ2VfbXR1LAorCQkubmRvX2dldF9zdGF0cyA9IHZteG5ldDNfZ2V0X3N0YXRzLAorCQkubmRvX3R4X3RpbWVvdXQgPSB2bXhuZXQzX3R4X3RpbWVvdXQsCisJCS5uZG9fc2V0X211bHRpY2FzdF9saXN0ID0gdm14bmV0M19zZXRfbWMsCisJCS5uZG9fdmxhbl9yeF9yZWdpc3RlciA9IHZteG5ldDNfdmxhbl9yeF9yZWdpc3RlciwKKwkJLm5kb192bGFuX3J4X2FkZF92aWQgPSB2bXhuZXQzX3ZsYW5fcnhfYWRkX3ZpZCwKKwkJLm5kb192bGFuX3J4X2tpbGxfdmlkID0gdm14bmV0M192bGFuX3J4X2tpbGxfdmlkLAorI2lmZGVmIENPTkZJR19ORVRfUE9MTF9DT05UUk9MTEVSCisJCS5uZG9fcG9sbF9jb250cm9sbGVyID0gdm14bmV0M19uZXRwb2xsLAorI2VuZGlmCisJfTsKKwlpbnQgZXJyOworCWJvb2wgZG1hNjQgPSBmYWxzZTsgLyogc3R1cGlkIGdjYyAqLworCXUzMiB2ZXI7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldjsKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyOworCXU4IG1hY1tFVEhfQUxFTl07CisKKwluZXRkZXYgPSBhbGxvY19ldGhlcmRldihzaXplb2Yoc3RydWN0IHZteG5ldDNfYWRhcHRlcikpOworCWlmICghbmV0ZGV2KSB7CisJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIGFsbG9jIGV0aGVybmV0IGRldmljZSBmb3IgYWRhcHRlciAiCisJCQkiJXNcbiIsCXBjaV9uYW1lKHBkZXYpKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJcGNpX3NldF9kcnZkYXRhKHBkZXYsIG5ldGRldik7CisJYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJYWRhcHRlci0+bmV0ZGV2ID0gbmV0ZGV2OworCWFkYXB0ZXItPnBkZXYgPSBwZGV2OworCisJYWRhcHRlci0+c2hhcmVkID0gcGNpX2FsbG9jX2NvbnNpc3RlbnQoYWRhcHRlci0+cGRldiwKKwkJCSAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX0RyaXZlclNoYXJlZCksCisJCQkgICZhZGFwdGVyLT5zaGFyZWRfcGEpOworCWlmICghYWRhcHRlci0+c2hhcmVkKSB7CisJCXByaW50ayhLRVJOX0VSUiAiRmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSBmb3IgJXNcbiIsCisJCQlwY2lfbmFtZShwZGV2KSk7CisJCWVyciA9IC1FTk9NRU07CisJCWdvdG8gZXJyX2FsbG9jX3NoYXJlZDsKKwl9CisKKwlhZGFwdGVyLT50cWRfc3RhcnQgPSBwY2lfYWxsb2NfY29uc2lzdGVudChhZGFwdGVyLT5wZGV2LAorCQkJICAgICBzaXplb2Yoc3RydWN0IFZteG5ldDNfVHhRdWV1ZURlc2MpICsKKwkJCSAgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1J4UXVldWVEZXNjKSwKKwkJCSAgICAgJmFkYXB0ZXItPnF1ZXVlX2Rlc2NfcGEpOworCisJaWYgKCFhZGFwdGVyLT50cWRfc3RhcnQpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciAlc1xuIiwKKwkJCXBjaV9uYW1lKHBkZXYpKTsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBlcnJfYWxsb2NfcXVldWVfZGVzYzsKKwl9CisJYWRhcHRlci0+cnFkX3N0YXJ0ID0gKHN0cnVjdCBWbXhuZXQzX1J4UXVldWVEZXNjICopKGFkYXB0ZXItPnRxZF9zdGFydAorCQkJCQkJCSAgICArIDEpOworCisJYWRhcHRlci0+cG1fY29uZiA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1BNQ29uZiksIEdGUF9LRVJORUwpOworCWlmIChhZGFwdGVyLT5wbV9jb25mID09IE5VTEwpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5IGZvciAlc1xuIiwKKwkJCXBjaV9uYW1lKHBkZXYpKTsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBlcnJfYWxsb2NfcG07CisJfQorCisJZXJyID0gdm14bmV0M19hbGxvY19wY2lfcmVzb3VyY2VzKGFkYXB0ZXIsICZkbWE2NCk7CisJaWYgKGVyciA8IDApCisJCWdvdG8gZXJyX2FsbG9jX3BjaTsKKworCXZlciA9IFZNWE5FVDNfUkVBRF9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19WUlJTKTsKKwlpZiAodmVyICYgMSkgeworCQlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX1ZSUlMsIDEpOworCX0gZWxzZSB7CisJCXByaW50ayhLRVJOX0VSUiAiSW5jb21wYXRpYmxlIGgvdyB2ZXJzaW9uICgweCV4KSBmb3IgYWRhcHRlciIKKwkJICAgICAgICIgJXNcbiIsCXZlciwgcGNpX25hbWUocGRldikpOworCQllcnIgPSAtRUJVU1k7CisJCWdvdG8gZXJyX3ZlcjsKKwl9CisKKwl2ZXIgPSBWTVhORVQzX1JFQURfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfVVZSUyk7CisJaWYgKHZlciAmIDEpIHsKKwkJVk1YTkVUM19XUklURV9CQVIxX1JFRyhhZGFwdGVyLCBWTVhORVQzX1JFR19VVlJTLCAxKTsKKwl9IGVsc2UgeworCQlwcmludGsoS0VSTl9FUlIgIkluY29tcGF0aWJsZSB1cHQgdmVyc2lvbiAoMHgleCkgZm9yICIKKwkJICAgICAgICJhZGFwdGVyICVzXG4iLCB2ZXIsIHBjaV9uYW1lKHBkZXYpKTsKKwkJZXJyID0gLUVCVVNZOworCQlnb3RvIGVycl92ZXI7CisJfQorCisJdm14bmV0M19kZWNsYXJlX2ZlYXR1cmVzKGFkYXB0ZXIsIGRtYTY0KTsKKworCWFkYXB0ZXItPmRldl9udW1iZXIgPSBhdG9taWNfcmVhZCgmZGV2aWNlc19mb3VuZCk7CisJdm14bmV0M19hbGxvY19pbnRyX3Jlc291cmNlcyhhZGFwdGVyKTsKKworCXZteG5ldDNfcmVhZF9tYWNfYWRkcihhZGFwdGVyLCBtYWMpOworCW1lbWNweShuZXRkZXYtPmRldl9hZGRyLCAgbWFjLCBuZXRkZXYtPmFkZHJfbGVuKTsKKworCW5ldGRldi0+bmV0ZGV2X29wcyA9ICZ2bXhuZXQzX25ldGRldl9vcHM7CisJbmV0ZGV2LT53YXRjaGRvZ190aW1lbyA9IDUgKiBIWjsKKwl2bXhuZXQzX3NldF9ldGh0b29sX29wcyhuZXRkZXYpOworCisJSU5JVF9XT1JLKCZhZGFwdGVyLT53b3JrLCB2bXhuZXQzX3Jlc2V0X3dvcmspOworCisJbmV0aWZfbmFwaV9hZGQobmV0ZGV2LCAmYWRhcHRlci0+bmFwaSwgdm14bmV0M19wb2xsLCA2NCk7CisJU0VUX05FVERFVl9ERVYobmV0ZGV2LCAmcGRldi0+ZGV2KTsKKwllcnIgPSByZWdpc3Rlcl9uZXRkZXYobmV0ZGV2KTsKKworCWlmIChlcnIpIHsKKwkJcHJpbnRrKEtFUk5fRVJSICJGYWlsZWQgdG8gcmVnaXN0ZXIgYWRhcHRlciAlc1xuIiwKKwkJCXBjaV9uYW1lKHBkZXYpKTsKKwkJZ290byBlcnJfcmVnaXN0ZXI7CisJfQorCisJc2V0X2JpdChWTVhORVQzX1NUQVRFX0JJVF9RVUlFU0NFRCwgJmFkYXB0ZXItPnN0YXRlKTsKKwlhdG9taWNfaW5jKCZkZXZpY2VzX2ZvdW5kKTsKKwlyZXR1cm4gMDsKKworZXJyX3JlZ2lzdGVyOgorCXZteG5ldDNfZnJlZV9pbnRyX3Jlc291cmNlcyhhZGFwdGVyKTsKK2Vycl92ZXI6CisJdm14bmV0M19mcmVlX3BjaV9yZXNvdXJjZXMoYWRhcHRlcik7CitlcnJfYWxsb2NfcGNpOgorCWtmcmVlKGFkYXB0ZXItPnBtX2NvbmYpOworZXJyX2FsbG9jX3BtOgorCXBjaV9mcmVlX2NvbnNpc3RlbnQoYWRhcHRlci0+cGRldiwgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1R4UXVldWVEZXNjKSArCisJCQkgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1J4UXVldWVEZXNjKSwKKwkJCSAgICBhZGFwdGVyLT50cWRfc3RhcnQsIGFkYXB0ZXItPnF1ZXVlX2Rlc2NfcGEpOworZXJyX2FsbG9jX3F1ZXVlX2Rlc2M6CisJcGNpX2ZyZWVfY29uc2lzdGVudChhZGFwdGVyLT5wZGV2LCBzaXplb2Yoc3RydWN0IFZteG5ldDNfRHJpdmVyU2hhcmVkKSwKKwkJCSAgICBhZGFwdGVyLT5zaGFyZWQsIGFkYXB0ZXItPnNoYXJlZF9wYSk7CitlcnJfYWxsb2Nfc2hhcmVkOgorCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKKwlmcmVlX25ldGRldihuZXRkZXYpOworCXJldHVybiBlcnI7Cit9CisKKworc3RhdGljIHZvaWQgX19kZXZleGl0Cit2bXhuZXQzX3JlbW92ZV9kZXZpY2Uoc3RydWN0IHBjaV9kZXYgKnBkZXYpCit7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCWZsdXNoX3NjaGVkdWxlZF93b3JrKCk7CisKKwl1bnJlZ2lzdGVyX25ldGRldihuZXRkZXYpOworCisJdm14bmV0M19mcmVlX2ludHJfcmVzb3VyY2VzKGFkYXB0ZXIpOworCXZteG5ldDNfZnJlZV9wY2lfcmVzb3VyY2VzKGFkYXB0ZXIpOworCWtmcmVlKGFkYXB0ZXItPnBtX2NvbmYpOworCXBjaV9mcmVlX2NvbnNpc3RlbnQoYWRhcHRlci0+cGRldiwgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1R4UXVldWVEZXNjKSArCisJCQkgICAgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX1J4UXVldWVEZXNjKSwKKwkJCSAgICBhZGFwdGVyLT50cWRfc3RhcnQsIGFkYXB0ZXItPnF1ZXVlX2Rlc2NfcGEpOworCXBjaV9mcmVlX2NvbnNpc3RlbnQoYWRhcHRlci0+cGRldiwgc2l6ZW9mKHN0cnVjdCBWbXhuZXQzX0RyaXZlclNoYXJlZCksCisJCQkgICAgYWRhcHRlci0+c2hhcmVkLCBhZGFwdGVyLT5zaGFyZWRfcGEpOworCWZyZWVfbmV0ZGV2KG5ldGRldik7Cit9CisKKworI2lmZGVmIENPTkZJR19QTQorCitzdGF0aWMgaW50Cit2bXhuZXQzX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2aWNlKQoreworCXN0cnVjdCBwY2lfZGV2ICpwZGV2ID0gdG9fcGNpX2RldihkZXZpY2UpOworCXN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYgPSBwY2lfZ2V0X2RydmRhdGEocGRldik7CisJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJc3RydWN0IFZteG5ldDNfUE1Db25mICpwbUNvbmY7CisJc3RydWN0IGV0aGhkciAqZWhkcjsKKwlzdHJ1Y3QgYXJwaGRyICphaGRyOworCXU4ICphcnByZXE7CisJc3RydWN0IGluX2RldmljZSAqaW5fZGV2OworCXN0cnVjdCBpbl9pZmFkZHIgKmlmYTsKKwlpbnQgaSA9IDA7CisKKwlpZiAoIW5ldGlmX3J1bm5pbmcobmV0ZGV2KSkKKwkJcmV0dXJuIDA7CisKKwl2bXhuZXQzX2Rpc2FibGVfYWxsX2ludHJzKGFkYXB0ZXIpOworCXZteG5ldDNfZnJlZV9pcnFzKGFkYXB0ZXIpOworCXZteG5ldDNfZnJlZV9pbnRyX3Jlc291cmNlcyhhZGFwdGVyKTsKKworCW5ldGlmX2RldmljZV9kZXRhY2gobmV0ZGV2KTsKKwluZXRpZl9zdG9wX3F1ZXVlKG5ldGRldik7CisKKwkvKiBDcmVhdGUgd2FrZS11cCBmaWx0ZXJzLiAqLworCXBtQ29uZiA9IGFkYXB0ZXItPnBtX2NvbmY7CisJbWVtc2V0KHBtQ29uZiwgMCwgc2l6ZW9mKCpwbUNvbmYpKTsKKworCWlmIChhZGFwdGVyLT53b2wgJiBXQUtFX1VDQVNUKSB7CisJCXBtQ29uZi0+ZmlsdGVyc1tpXS5wYXR0ZXJuU2l6ZSA9IEVUSF9BTEVOOworCQlwbUNvbmYtPmZpbHRlcnNbaV0ubWFza1NpemUgPSAxOworCQltZW1jcHkocG1Db25mLT5maWx0ZXJzW2ldLnBhdHRlcm4sIG5ldGRldi0+ZGV2X2FkZHIsIEVUSF9BTEVOKTsKKwkJcG1Db25mLT5maWx0ZXJzW2ldLm1hc2tbMF0gPSAweDNGOyAvKiBMU0IgRVRIX0FMRU4gYml0cyAqLworCisJCXBtQ29uZi0+d2FrZVVwRXZlbnRzIHw9IFZNWE5FVDNfUE1fV0FLRVVQX0ZJTFRFUjsKKwkJaSsrOworCX0KKworCWlmIChhZGFwdGVyLT53b2wgJiBXQUtFX0FSUCkgeworCQlpbl9kZXYgPSBpbl9kZXZfZ2V0KG5ldGRldik7CisJCWlmICghaW5fZGV2KQorCQkJZ290byBza2lwX2FycDsKKworCQlpZmEgPSAoc3RydWN0IGluX2lmYWRkciAqKWluX2Rldi0+aWZhX2xpc3Q7CisJCWlmICghaWZhKQorCQkJZ290byBza2lwX2FycDsKKworCQlwbUNvbmYtPmZpbHRlcnNbaV0ucGF0dGVyblNpemUgPSBFVEhfSExFTiArIC8qIEV0aGVybmV0IGhlYWRlciovCisJCQlzaXplb2Yoc3RydWN0IGFycGhkcikgKwkJLyogQVJQIGhlYWRlciAqLworCQkJMiAqIEVUSF9BTEVOICsJCS8qIDIgRXRoZXJuZXQgYWRkcmVzc2VzKi8KKwkJCTIgKiBzaXplb2YodTMyKTsJLyoyIElQdjQgYWRkcmVzc2VzICovCisJCXBtQ29uZi0+ZmlsdGVyc1tpXS5tYXNrU2l6ZSA9CisJCQkocG1Db25mLT5maWx0ZXJzW2ldLnBhdHRlcm5TaXplIC0gMSkgLyA4ICsgMTsKKworCQkvKiBFVEhfUF9BUlAgaW4gRXRoZXJuZXQgaGVhZGVyLiAqLworCQllaGRyID0gKHN0cnVjdCBldGhoZHIgKilwbUNvbmYtPmZpbHRlcnNbaV0ucGF0dGVybjsKKwkJZWhkci0+aF9wcm90byA9IGh0b25zKEVUSF9QX0FSUCk7CisKKwkJLyogQVJQT1BfUkVRVUVTVCBpbiBBUlAgaGVhZGVyLiAqLworCQlhaGRyID0gKHN0cnVjdCBhcnBoZHIgKikmcG1Db25mLT5maWx0ZXJzW2ldLnBhdHRlcm5bRVRIX0hMRU5dOworCQlhaGRyLT5hcl9vcCA9IGh0b25zKEFSUE9QX1JFUVVFU1QpOworCQlhcnByZXEgPSAodTggKikoYWhkciArIDEpOworCisJCS8qIFRoZSBVbmljYXN0IElQdjQgYWRkcmVzcyBpbiAndGlwJyBmaWVsZC4gKi8KKwkJYXJwcmVxICs9IDIgKiBFVEhfQUxFTiArIHNpemVvZih1MzIpOworCQkqKHUzMiAqKWFycHJlcSA9IGlmYS0+aWZhX2FkZHJlc3M7CisKKwkJLyogVGhlIG1hc2sgZm9yIHRoZSByZWxldmFudCBiaXRzLiAqLworCQlwbUNvbmYtPmZpbHRlcnNbaV0ubWFza1swXSA9IDB4MDA7CisJCXBtQ29uZi0+ZmlsdGVyc1tpXS5tYXNrWzFdID0gMHgzMDsgLyogRVRIX1BfQVJQICovCisJCXBtQ29uZi0+ZmlsdGVyc1tpXS5tYXNrWzJdID0gMHgzMDsgLyogQVJQT1BfUkVRVUVTVCAqLworCQlwbUNvbmYtPmZpbHRlcnNbaV0ubWFza1szXSA9IDB4MDA7CisJCXBtQ29uZi0+ZmlsdGVyc1tpXS5tYXNrWzRdID0gMHhDMDsgLyogSVB2NCBUSVAgKi8KKwkJcG1Db25mLT5maWx0ZXJzW2ldLm1hc2tbNV0gPSAweDAzOyAvKiBJUHY0IFRJUCAqLworCQlpbl9kZXZfcHV0KGluX2Rldik7CisKKwkJcG1Db25mLT53YWtlVXBFdmVudHMgfD0gVk1YTkVUM19QTV9XQUtFVVBfRklMVEVSOworCQlpKys7CisJfQorCitza2lwX2FycDoKKwlpZiAoYWRhcHRlci0+d29sICYgV0FLRV9NQUdJQykKKwkJcG1Db25mLT53YWtlVXBFdmVudHMgfD0gVk1YTkVUM19QTV9XQUtFVVBfTUFHSUM7CisKKwlwbUNvbmYtPm51bUZpbHRlcnMgPSBpOworCisJYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLnBtQ29uZkRlc2MuY29uZlZlciA9IDE7CisJYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLnBtQ29uZkRlc2MuY29uZkxlbiA9IHNpemVvZigqcG1Db25mKTsKKwlhZGFwdGVyLT5zaGFyZWQtPmRldlJlYWQucG1Db25mRGVzYy5jb25mUEEgPSB2aXJ0X3RvX3BoeXMocG1Db25mKTsKKworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJICAgICAgIFZNWE5FVDNfQ01EX1VQREFURV9QTUNGRyk7CisKKwlwY2lfc2F2ZV9zdGF0ZShwZGV2KTsKKwlwY2lfZW5hYmxlX3dha2UocGRldiwgcGNpX2Nob29zZV9zdGF0ZShwZGV2LCBQTVNHX1NVU1BFTkQpLAorCQkJYWRhcHRlci0+d29sKTsKKwlwY2lfZGlzYWJsZV9kZXZpY2UocGRldik7CisJcGNpX3NldF9wb3dlcl9zdGF0ZShwZGV2LCBwY2lfY2hvb3NlX3N0YXRlKHBkZXYsIFBNU0dfU1VTUEVORCkpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludAordm14bmV0M19yZXN1bWUoc3RydWN0IGRldmljZSAqZGV2aWNlKQoreworCWludCBlcnI7CisJc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB0b19wY2lfZGV2KGRldmljZSk7CisJc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwlzdHJ1Y3QgVm14bmV0M19QTUNvbmYgKnBtQ29uZjsKKworCWlmICghbmV0aWZfcnVubmluZyhuZXRkZXYpKQorCQlyZXR1cm4gMDsKKworCS8qIERlc3Ryb3kgd2FrZS11cCBmaWx0ZXJzLiAqLworCXBtQ29uZiA9IGFkYXB0ZXItPnBtX2NvbmY7CisJbWVtc2V0KHBtQ29uZiwgMCwgc2l6ZW9mKCpwbUNvbmYpKTsKKworCWFkYXB0ZXItPnNoYXJlZC0+ZGV2UmVhZC5wbUNvbmZEZXNjLmNvbmZWZXIgPSAxOworCWFkYXB0ZXItPnNoYXJlZC0+ZGV2UmVhZC5wbUNvbmZEZXNjLmNvbmZMZW4gPSBzaXplb2YoKnBtQ29uZik7CisJYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLnBtQ29uZkRlc2MuY29uZlBBID0gdmlydF90b19waHlzKHBtQ29uZik7CisKKwluZXRpZl9kZXZpY2VfYXR0YWNoKG5ldGRldik7CisJcGNpX3NldF9wb3dlcl9zdGF0ZShwZGV2LCBQQ0lfRDApOworCXBjaV9yZXN0b3JlX3N0YXRlKHBkZXYpOworCWVyciA9IHBjaV9lbmFibGVfZGV2aWNlX21lbShwZGV2KTsKKwlpZiAoZXJyICE9IDApCisJCXJldHVybiBlcnI7CisKKwlwY2lfZW5hYmxlX3dha2UocGRldiwgUENJX0QwLCAwKTsKKworCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJICAgICAgIFZNWE5FVDNfQ01EX1VQREFURV9QTUNGRyk7CisJdm14bmV0M19hbGxvY19pbnRyX3Jlc291cmNlcyhhZGFwdGVyKTsKKwl2bXhuZXQzX3JlcXVlc3RfaXJxcyhhZGFwdGVyKTsKKwl2bXhuZXQzX2VuYWJsZV9hbGxfaW50cnMoYWRhcHRlcik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHN0cnVjdCBkZXZfcG1fb3BzIHZteG5ldDNfcG1fb3BzID0geworCS5zdXNwZW5kID0gdm14bmV0M19zdXNwZW5kLAorCS5yZXN1bWUgPSB2bXhuZXQzX3Jlc3VtZSwKK307CisjZW5kaWYKKworc3RhdGljIHN0cnVjdCBwY2lfZHJpdmVyIHZteG5ldDNfZHJpdmVyID0geworCS5uYW1lCQk9IHZteG5ldDNfZHJpdmVyX25hbWUsCisJLmlkX3RhYmxlCT0gdm14bmV0M19wY2lpZF90YWJsZSwKKwkucHJvYmUJCT0gdm14bmV0M19wcm9iZV9kZXZpY2UsCisJLnJlbW92ZQkJPSBfX2RldmV4aXRfcCh2bXhuZXQzX3JlbW92ZV9kZXZpY2UpLAorI2lmZGVmIENPTkZJR19QTQorCS5kcml2ZXIucG0JPSAmdm14bmV0M19wbV9vcHMsCisjZW5kaWYKK307CisKKworc3RhdGljIGludCBfX2luaXQKK3ZteG5ldDNfaW5pdF9tb2R1bGUodm9pZCkKK3sKKwlwcmludGsoS0VSTl9JTkZPICIlcyAtIHZlcnNpb24gJXNcbiIsIFZNWE5FVDNfRFJJVkVSX0RFU0MsCisJCVZNWE5FVDNfRFJJVkVSX1ZFUlNJT05fUkVQT1JUKTsKKwlyZXR1cm4gcGNpX3JlZ2lzdGVyX2RyaXZlcigmdm14bmV0M19kcml2ZXIpOworfQorCittb2R1bGVfaW5pdCh2bXhuZXQzX2luaXRfbW9kdWxlKTsKKworCitzdGF0aWMgdm9pZAordm14bmV0M19leGl0X21vZHVsZSh2b2lkKQoreworCXBjaV91bnJlZ2lzdGVyX2RyaXZlcigmdm14bmV0M19kcml2ZXIpOworfQorCittb2R1bGVfZXhpdCh2bXhuZXQzX2V4aXRfbW9kdWxlKTsKKworTU9EVUxFX0FVVEhPUigiVk13YXJlLCBJbmMuIik7CitNT0RVTEVfREVTQ1JJUFRJT04oVk1YTkVUM19EUklWRVJfREVTQyk7CitNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7CitNT0RVTEVfVkVSU0lPTihWTVhORVQzX0RSSVZFUl9WRVJTSU9OX1NUUklORyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfZXRodG9vbC5jIGIvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2V0aHRvb2wuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMmMxNWU0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9uZXQvdm14bmV0My92bXhuZXQzX2V0aHRvb2wuYwpAQCAtMCwwICsxLDU2NiBAQAorLyoKKyAqIExpbnV4IGRyaXZlciBmb3IgVk13YXJlJ3Mgdm14bmV0MyBldGhlcm5ldCBOSUMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA4LTIwMDksIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlIGFuZCBubyBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSwgR09PRCBUSVRMRSBvcgorICogTk9OIElORlJJTkdFTUVOVC4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUKKyAqIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisgKgorICogVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAqIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisgKgorICogTWFpbnRhaW5lZCBieTogU2hyZXlhcyBCaGF0ZXdhcmEgPHB2LWRyaXZlcnNAdm13YXJlLmNvbT4KKyAqCisgKi8KKworCisjaW5jbHVkZSAidm14bmV0M19pbnQuaCIKKworc3RydWN0IHZteG5ldDNfc3RhdF9kZXNjIHsKKwljaGFyIGRlc2NbRVRIX0dTVFJJTkdfTEVOXTsKKwlpbnQgIG9mZnNldDsKK307CisKKworc3RhdGljIHUzMgordm14bmV0M19nZXRfcnhfY3N1bShzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2KQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCXJldHVybiBhZGFwdGVyLT5yeGNzdW07Cit9CisKKworc3RhdGljIGludAordm14bmV0M19zZXRfcnhfY3N1bShzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCB1MzIgdmFsKQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCisJaWYgKGFkYXB0ZXItPnJ4Y3N1bSAhPSB2YWwpIHsKKwkJYWRhcHRlci0+cnhjc3VtID0gdmFsOworCQlpZiAobmV0aWZfcnVubmluZyhuZXRkZXYpKSB7CisJCQlpZiAodmFsKQorCQkJCWFkYXB0ZXItPnNoYXJlZC0+ZGV2UmVhZC5taXNjLnVwdEZlYXR1cmVzIHw9CisJCQkJCQkJCVVQVDFfRl9SWENTVU07CisJCQllbHNlCisJCQkJYWRhcHRlci0+c2hhcmVkLT5kZXZSZWFkLm1pc2MudXB0RmVhdHVyZXMgJj0KKwkJCQkJCQkJflVQVDFfRl9SWENTVU07CisKKwkJCVZNWE5FVDNfV1JJVEVfQkFSMV9SRUcoYWRhcHRlciwgVk1YTkVUM19SRUdfQ01ELAorCQkJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX0ZFQVRVUkUpOworCQl9CisJfQorCXJldHVybiAwOworfQorCisKKy8qIHBlciB0cSBzdGF0cyBtYWludGFpbmVkIGJ5IHRoZSBkZXZpY2UgKi8KK3N0YXRpYyBjb25zdCBzdHJ1Y3Qgdm14bmV0M19zdGF0X2Rlc2MKK3ZteG5ldDNfdHFfZGV2X3N0YXRzW10gPSB7CisJLyogZGVzY3JpcHRpb24sICAgICAgICAgb2Zmc2V0ICovCisJeyAiVFNPIHBrdHMgdHgiLCAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgVFNPUGt0c1R4T0spIH0sCisJeyAiVFNPIGJ5dGVzIHR4IiwgICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgVFNPQnl0ZXNUeE9LKSB9LAorCXsgInVjYXN0IHBrdHMgdHgiLCAgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIHVjYXN0UGt0c1R4T0spIH0sCisJeyAidWNhc3QgYnl0ZXMgdHgiLCAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgdWNhc3RCeXRlc1R4T0spIH0sCisJeyAibWNhc3QgcGt0cyB0eCIsICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfVHhTdGF0cywgbWNhc3RQa3RzVHhPSykgfSwKKwl7ICJtY2FzdCBieXRlcyB0eCIsICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9UeFN0YXRzLCBtY2FzdEJ5dGVzVHhPSykgfSwKKwl7ICJiY2FzdCBwa3RzIHR4IiwgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9UeFN0YXRzLCBiY2FzdFBrdHNUeE9LKSB9LAorCXsgImJjYXN0IGJ5dGVzIHR4IiwgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIGJjYXN0Qnl0ZXNUeE9LKSB9LAorCXsgInBrdHMgdHggZXJyIiwgICAgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIHBrdHNUeEVycm9yKSB9LAorCXsgInBrdHMgdHggZGlzY2FyZCIsICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1R4U3RhdHMsIHBrdHNUeERpc2NhcmQpIH0sCit9OworCisvKiBwZXIgdHEgc3RhdHMgbWFpbnRhaW5lZCBieSB0aGUgZHJpdmVyICovCitzdGF0aWMgY29uc3Qgc3RydWN0IHZteG5ldDNfc3RhdF9kZXNjCit2bXhuZXQzX3RxX2RyaXZlcl9zdGF0c1tdID0geworCS8qIGRlc2NyaXB0aW9uLCAgICAgICAgIG9mZnNldCAqLworCXsiZHJ2IGRyb3BwZWQgdHggdG90YWwiLCBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCisJCQkJCWRyb3BfdG90YWwpIH0sCisJeyAiICAgdG9vIG1hbnkgZnJhZ3MiLCAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQlkcm9wX3Rvb19tYW55X2ZyYWdzKSB9LAorCXsgIiAgIGdpYW50IGhkciIsICAgICAgIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKKwkJCQkJZHJvcF9vdmVyc2l6ZWRfaGRyKSB9LAorCXsgIiAgIGhkciBlcnIiLCAgICAgICAgIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cywKKwkJCQkJZHJvcF9oZHJfaW5zcGVjdF9lcnIpIH0sCisJeyAiICAgdHNvIiwgICAgICAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQlkcm9wX3RzbykgfSwKKwl7ICJyaW5nIGZ1bGwiLCAgICAgICAgICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCisJCQkJCXR4X3JpbmdfZnVsbCkgfSwKKwl7ICJwa3RzIGxpbmVhcml6ZWQiLCAgICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMsCisJCQkJCWxpbmVhcml6ZWQpIH0sCisJeyAiaGRyIGNsb25lZCIsICAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQljb3B5X3NrYl9oZWFkZXIpIH0sCisJeyAiZ2lhbnQgaGRyIiwgICAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzLAorCQkJCQlvdmVyc2l6ZWRfaGRyKSB9LAorfTsKKworLyogcGVyIHJxIHN0YXRzIG1haW50YWluZWQgYnkgdGhlIGRldmljZSAqLworc3RhdGljIGNvbnN0IHN0cnVjdCB2bXhuZXQzX3N0YXRfZGVzYwordm14bmV0M19ycV9kZXZfc3RhdHNbXSA9IHsKKwl7ICJMUk8gcGt0cyByeCIsICAgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBMUk9Qa3RzUnhPSykgfSwKKwl7ICJMUk8gYnl0ZSByeCIsICAgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBMUk9CeXRlc1J4T0spIH0sCisJeyAidWNhc3QgcGt0cyByeCIsICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgdWNhc3RQa3RzUnhPSykgfSwKKwl7ICJ1Y2FzdCBieXRlcyByeCIsICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCB1Y2FzdEJ5dGVzUnhPSykgfSwKKwl7ICJtY2FzdCBwa3RzIHJ4IiwgICAgICBvZmZzZXRvZihzdHJ1Y3QgVVBUMV9SeFN0YXRzLCBtY2FzdFBrdHNSeE9LKSB9LAorCXsgIm1jYXN0IGJ5dGVzIHJ4IiwgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1J4U3RhdHMsIG1jYXN0Qnl0ZXNSeE9LKSB9LAorCXsgImJjYXN0IHBrdHMgcngiLCAgICAgIG9mZnNldG9mKHN0cnVjdCBVUFQxX1J4U3RhdHMsIGJjYXN0UGt0c1J4T0spIH0sCisJeyAiYmNhc3QgYnl0ZXMgcngiLCAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgYmNhc3RCeXRlc1J4T0spIH0sCisJeyAicGt0cyByeCBvdXQgb2YgYnVmIiwgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgcGt0c1J4T3V0T2ZCdWYpIH0sCisJeyAicGt0cyByeCBlcnIiLCAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IFVQVDFfUnhTdGF0cywgcGt0c1J4RXJyb3IpIH0sCit9OworCisvKiBwZXIgcnEgc3RhdHMgbWFpbnRhaW5lZCBieSB0aGUgZHJpdmVyICovCitzdGF0aWMgY29uc3Qgc3RydWN0IHZteG5ldDNfc3RhdF9kZXNjCit2bXhuZXQzX3JxX2RyaXZlcl9zdGF0c1tdID0geworCS8qIGRlc2NyaXB0aW9uLCAgICAgICAgIG9mZnNldCAqLworCXsgImRydiBkcm9wcGVkIHJ4IHRvdGFsIiwgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzLAorCQkJCQkgICBkcm9wX3RvdGFsKSB9LAorCXsgIiAgIGVyciIsICAgICAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzLAorCQkJCQlkcm9wX2VycikgfSwKKwl7ICIgICBmY3MiLCAgICAgICAgICAgIG9mZnNldG9mKHN0cnVjdCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cywKKwkJCQkJZHJvcF9mY3MpIH0sCisJeyAicnggYnVmIGFsbG9jIGZhaWwiLCBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M19ycV9kcml2ZXJfc3RhdHMsCisJCQkJCXJ4X2J1Zl9hbGxvY19mYWlsdXJlKSB9LAorfTsKKworLyogZ2xvYWJsIHN0YXRzIG1haW50YWluZWQgYnkgdGhlIGRyaXZlciAqLworc3RhdGljIGNvbnN0IHN0cnVjdCB2bXhuZXQzX3N0YXRfZGVzYwordm14bmV0M19nbG9iYWxfc3RhdHNbXSA9IHsKKwkvKiBkZXNjcmlwdGlvbiwgICAgICAgICBvZmZzZXQgKi8KKwl7ICJ0eCB0aW1lb3V0IGNvdW50IiwgICBvZmZzZXRvZihzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyLAorCQkJCQkgdHhfdGltZW91dF9jb3VudCkgfQorfTsKKworCitzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyAqCit2bXhuZXQzX2dldF9zdGF0cyhzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2KQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXI7CisJc3RydWN0IHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzICpkcnZUeFN0YXRzOworCXN0cnVjdCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cyAqZHJ2UnhTdGF0czsKKwlzdHJ1Y3QgVVBUMV9UeFN0YXRzICpkZXZUeFN0YXRzOworCXN0cnVjdCBVUFQxX1J4U3RhdHMgKmRldlJ4U3RhdHM7CisJc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKm5ldF9zdGF0cyA9ICZuZXRkZXYtPnN0YXRzOworCisJYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisKKwkvKiBDb2xsZWN0IHRoZSBkZXYgc3RhdHMgaW50byB0aGUgc2hhcmVkIGFyZWEgKi8KKwlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwgVk1YTkVUM19DTURfR0VUX1NUQVRTKTsKKworCS8qIEFzc3VtaW5nIHRoYXQgd2UgaGF2ZSBhIHNpbmdsZSBxdWV1ZSBkZXZpY2UgKi8KKwlkZXZUeFN0YXRzID0gJmFkYXB0ZXItPnRxZF9zdGFydC0+c3RhdHM7CisJZGV2UnhTdGF0cyA9ICZhZGFwdGVyLT5ycWRfc3RhcnQtPnN0YXRzOworCisJLyogR2V0IGFjY2VzcyB0byB0aGUgZHJpdmVyIHN0YXRzIHBlciBxdWV1ZSAqLworCWRydlR4U3RhdHMgPSAmYWRhcHRlci0+dHhfcXVldWUuc3RhdHM7CisJZHJ2UnhTdGF0cyA9ICZhZGFwdGVyLT5yeF9xdWV1ZS5zdGF0czsKKworCW1lbXNldChuZXRfc3RhdHMsIDAsIHNpemVvZigqbmV0X3N0YXRzKSk7CisKKwluZXRfc3RhdHMtPnJ4X3BhY2tldHMgPSBkZXZSeFN0YXRzLT51Y2FzdFBrdHNSeE9LICsKKwkJCQlkZXZSeFN0YXRzLT5tY2FzdFBrdHNSeE9LICsKKwkJCQlkZXZSeFN0YXRzLT5iY2FzdFBrdHNSeE9LOworCisJbmV0X3N0YXRzLT50eF9wYWNrZXRzID0gZGV2VHhTdGF0cy0+dWNhc3RQa3RzVHhPSyArCisJCQkJZGV2VHhTdGF0cy0+bWNhc3RQa3RzVHhPSyArCisJCQkJZGV2VHhTdGF0cy0+YmNhc3RQa3RzVHhPSzsKKworCW5ldF9zdGF0cy0+cnhfYnl0ZXMgPSBkZXZSeFN0YXRzLT51Y2FzdEJ5dGVzUnhPSyArCisJCQkgICAgICBkZXZSeFN0YXRzLT5tY2FzdEJ5dGVzUnhPSyArCisJCQkgICAgICBkZXZSeFN0YXRzLT5iY2FzdEJ5dGVzUnhPSzsKKworCW5ldF9zdGF0cy0+dHhfYnl0ZXMgPSBkZXZUeFN0YXRzLT51Y2FzdEJ5dGVzVHhPSyArCisJCQkgICAgICBkZXZUeFN0YXRzLT5tY2FzdEJ5dGVzVHhPSyArCisJCQkgICAgICBkZXZUeFN0YXRzLT5iY2FzdEJ5dGVzVHhPSzsKKworCW5ldF9zdGF0cy0+cnhfZXJyb3JzID0gZGV2UnhTdGF0cy0+cGt0c1J4RXJyb3I7CisJbmV0X3N0YXRzLT50eF9lcnJvcnMgPSBkZXZUeFN0YXRzLT5wa3RzVHhFcnJvcjsKKwluZXRfc3RhdHMtPnJ4X2Ryb3BwZWQgPSBkcnZSeFN0YXRzLT5kcm9wX3RvdGFsOworCW5ldF9zdGF0cy0+dHhfZHJvcHBlZCA9IGRydlR4U3RhdHMtPmRyb3BfdG90YWw7CisJbmV0X3N0YXRzLT5tdWx0aWNhc3QgPSAgZGV2UnhTdGF0cy0+bWNhc3RQa3RzUnhPSzsKKworCXJldHVybiBuZXRfc3RhdHM7Cit9CisKK3N0YXRpYyBpbnQKK3ZteG5ldDNfZ2V0X3NzZXRfY291bnQoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgaW50IHNzZXQpCit7CisJc3dpdGNoIChzc2V0KSB7CisJY2FzZSBFVEhfU1NfU1RBVFM6CisJCXJldHVybiBBUlJBWV9TSVpFKHZteG5ldDNfdHFfZGV2X3N0YXRzKSArCisJCQlBUlJBWV9TSVpFKHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzKSArCisJCQlBUlJBWV9TSVpFKHZteG5ldDNfcnFfZGV2X3N0YXRzKSArCisJCQlBUlJBWV9TSVpFKHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzKSArCisJCQlBUlJBWV9TSVpFKHZteG5ldDNfZ2xvYmFsX3N0YXRzKTsKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVPUE5PVFNVUFA7CisJfQorfQorCisKK3N0YXRpYyBpbnQKK3ZteG5ldDNfZ2V0X3JlZ3NfbGVuKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYpCit7CisJcmV0dXJuIDIwICogc2l6ZW9mKHUzMik7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZ2V0X2RydmluZm8oc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgc3RydWN0IGV0aHRvb2xfZHJ2aW5mbyAqZHJ2aW5mbykKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCXN0cmxjcHkoZHJ2aW5mby0+ZHJpdmVyLCB2bXhuZXQzX2RyaXZlcl9uYW1lLCBzaXplb2YoZHJ2aW5mby0+ZHJpdmVyKSk7CisJZHJ2aW5mby0+ZHJpdmVyW3NpemVvZihkcnZpbmZvLT5kcml2ZXIpIC0gMV0gPSAnXDAnOworCisJc3RybGNweShkcnZpbmZvLT52ZXJzaW9uLCBWTVhORVQzX0RSSVZFUl9WRVJTSU9OX1JFUE9SVCwKKwkJc2l6ZW9mKGRydmluZm8tPnZlcnNpb24pKTsKKwlkcnZpbmZvLT5kcml2ZXJbc2l6ZW9mKGRydmluZm8tPnZlcnNpb24pIC0gMV0gPSAnXDAnOworCisJc3RybGNweShkcnZpbmZvLT5md192ZXJzaW9uLCAiTi9BIiwgc2l6ZW9mKGRydmluZm8tPmZ3X3ZlcnNpb24pKTsKKwlkcnZpbmZvLT5md192ZXJzaW9uW3NpemVvZihkcnZpbmZvLT5md192ZXJzaW9uKSAtIDFdID0gJ1wwJzsKKworCXN0cmxjcHkoZHJ2aW5mby0+YnVzX2luZm8sIHBjaV9uYW1lKGFkYXB0ZXItPnBkZXYpLAorCQlFVEhUT09MX0JVU0lORk9fTEVOKTsKKwlkcnZpbmZvLT5uX3N0YXRzID0gdm14bmV0M19nZXRfc3NldF9jb3VudChuZXRkZXYsIEVUSF9TU19TVEFUUyk7CisJZHJ2aW5mby0+dGVzdGluZm9fbGVuID0gMDsKKwlkcnZpbmZvLT5lZWR1bXBfbGVuICAgPSAwOworCWRydmluZm8tPnJlZ2R1bXBfbGVuICA9IHZteG5ldDNfZ2V0X3JlZ3NfbGVuKG5ldGRldik7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZ2V0X3N0cmluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgdTMyIHN0cmluZ3NldCwgdTggKmJ1ZikKK3sKKwlpZiAoc3RyaW5nc2V0ID09IEVUSF9TU19TVEFUUykgeworCQlpbnQgaTsKKworCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3RxX2Rldl9zdGF0cyk7IGkrKykgeworCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M190cV9kZXZfc3RhdHNbaV0uZGVzYywKKwkJCSAgICAgICBFVEhfR1NUUklOR19MRU4pOworCQkJYnVmICs9IEVUSF9HU1RSSU5HX0xFTjsKKwkJfQorCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cyk7IGkrKykgeworCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M190cV9kcml2ZXJfc3RhdHNbaV0uZGVzYywKKwkJCSAgICAgICBFVEhfR1NUUklOR19MRU4pOworCQkJYnVmICs9IEVUSF9HU1RSSU5HX0xFTjsKKwkJfQorCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3JxX2Rldl9zdGF0cyk7IGkrKykgeworCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M19ycV9kZXZfc3RhdHNbaV0uZGVzYywKKwkJCSAgICAgICBFVEhfR1NUUklOR19MRU4pOworCQkJYnVmICs9IEVUSF9HU1RSSU5HX0xFTjsKKwkJfQorCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cyk7IGkrKykgeworCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M19ycV9kcml2ZXJfc3RhdHNbaV0uZGVzYywKKwkJCSAgICAgICBFVEhfR1NUUklOR19MRU4pOworCQkJYnVmICs9IEVUSF9HU1RSSU5HX0xFTjsKKwkJfQorCQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX2dsb2JhbF9zdGF0cyk7IGkrKykgeworCQkJbWVtY3B5KGJ1Ziwgdm14bmV0M19nbG9iYWxfc3RhdHNbaV0uZGVzYywKKwkJCQlFVEhfR1NUUklOR19MRU4pOworCQkJYnVmICs9IEVUSF9HU1RSSU5HX0xFTjsKKwkJfQorCX0KK30KKworc3RhdGljIHUzMgordm14bmV0M19nZXRfZmxhZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikgeworCXJldHVybiBuZXRkZXYtPmZlYXR1cmVzOworfQorCitzdGF0aWMgaW50Cit2bXhuZXQzX3NldF9mbGFncyhzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LCB1MzIgZGF0YSkgeworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCXU4IGxyb19yZXF1ZXN0ZWQgPSAoZGF0YSAmIEVUSF9GTEFHX0xSTykgPT0gMCA/IDAgOiAxOworCXU4IGxyb19wcmVzZW50ID0gKG5ldGRldi0+ZmVhdHVyZXMgJiBORVRJRl9GX0xSTykgPT0gMCA/IDAgOiAxOworCisJaWYgKGxyb19yZXF1ZXN0ZWQgXiBscm9fcHJlc2VudCkgeworCQkvKiB0b2dnbGUgdGhlIExSTyBmZWF0dXJlKi8KKwkJbmV0ZGV2LT5mZWF0dXJlcyBePSBORVRJRl9GX0xSTzsKKworCQkvKiB1cGRhdGUgaGFyd2FyZSBMUk8gY2FwYWJpbGl0eSBhY2NvcmRpbmdseSAqLworCQlpZiAobHJvX3JlcXVlc3RlZCkKKwkJCWFkYXB0ZXItPnNoYXJlZC0+ZGV2UmVhZC5taXNjLnVwdEZlYXR1cmVzICY9IFVQVDFfRl9MUk87CisJCWVsc2UKKwkJCWFkYXB0ZXItPnNoYXJlZC0+ZGV2UmVhZC5taXNjLnVwdEZlYXR1cmVzICY9CisJCQkJCQkJCX5VUFQxX0ZfTFJPOworCQlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwKKwkJCQkgICAgICAgVk1YTkVUM19DTURfVVBEQVRFX0ZFQVRVUkUpOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZ2V0X2V0aHRvb2xfc3RhdHMoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwKKwkJCSAgc3RydWN0IGV0aHRvb2xfc3RhdHMgKnN0YXRzLCB1NjQgICpidWYpCit7CisJc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlciA9IG5ldGRldl9wcml2KG5ldGRldik7CisJdTggKmJhc2U7CisJaW50IGk7CisKKwlWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIFZNWE5FVDNfUkVHX0NNRCwgVk1YTkVUM19DTURfR0VUX1NUQVRTKTsKKworCS8qIHRoaXMgZG9lcyBhc3N1bWUgZWFjaCBjb3VudGVyIGlzIDY0LWJpdCB3aWRlICovCisKKwliYXNlID0gKHU4ICopJmFkYXB0ZXItPnRxZF9zdGFydC0+c3RhdHM7CisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M190cV9kZXZfc3RhdHMpOyBpKyspCisJCSpidWYrKyA9ICoodTY0ICopKGJhc2UgKyB2bXhuZXQzX3RxX2Rldl9zdGF0c1tpXS5vZmZzZXQpOworCisJYmFzZSA9ICh1OCAqKSZhZGFwdGVyLT50eF9xdWV1ZS5zdGF0czsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cyk7IGkrKykKKwkJKmJ1ZisrID0gKih1NjQgKikoYmFzZSArIHZteG5ldDNfdHFfZHJpdmVyX3N0YXRzW2ldLm9mZnNldCk7CisKKwliYXNlID0gKHU4ICopJmFkYXB0ZXItPnJxZF9zdGFydC0+c3RhdHM7CisJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodm14bmV0M19ycV9kZXZfc3RhdHMpOyBpKyspCisJCSpidWYrKyA9ICoodTY0ICopKGJhc2UgKyB2bXhuZXQzX3JxX2Rldl9zdGF0c1tpXS5vZmZzZXQpOworCisJYmFzZSA9ICh1OCAqKSZhZGFwdGVyLT5yeF9xdWV1ZS5zdGF0czsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cyk7IGkrKykKKwkJKmJ1ZisrID0gKih1NjQgKikoYmFzZSArIHZteG5ldDNfcnFfZHJpdmVyX3N0YXRzW2ldLm9mZnNldCk7CisKKwliYXNlID0gKHU4ICopYWRhcHRlcjsKKwlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRSh2bXhuZXQzX2dsb2JhbF9zdGF0cyk7IGkrKykKKwkJKmJ1ZisrID0gKih1NjQgKikoYmFzZSArIHZteG5ldDNfZ2xvYmFsX3N0YXRzW2ldLm9mZnNldCk7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZ2V0X3JlZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgc3RydWN0IGV0aHRvb2xfcmVncyAqcmVncywgdm9pZCAqcCkKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwl1MzIgKmJ1ZiA9IHA7CisKKwltZW1zZXQocCwgMCwgdm14bmV0M19nZXRfcmVnc19sZW4obmV0ZGV2KSk7CisKKwlyZWdzLT52ZXJzaW9uID0gMTsKKworCS8qIFVwZGF0ZSB2bXhuZXQzX2dldF9yZWdzX2xlbiBpZiB3ZSB3YW50IHRvIGR1bXAgbW9yZSByZWdpc3RlcnMgKi8KKworCS8qIG1ha2UgZWFjaCByaW5nIHVzZSBtdWx0aXBsZSBvZiAxNiBieXRlcyAqLworCWJ1ZlswXSA9IGFkYXB0ZXItPnR4X3F1ZXVlLnR4X3JpbmcubmV4dDJmaWxsOworCWJ1ZlsxXSA9IGFkYXB0ZXItPnR4X3F1ZXVlLnR4X3JpbmcubmV4dDJjb21wOworCWJ1ZlsyXSA9IGFkYXB0ZXItPnR4X3F1ZXVlLnR4X3JpbmcuZ2VuOworCWJ1ZlszXSA9IDA7CisKKwlidWZbNF0gPSBhZGFwdGVyLT50eF9xdWV1ZS5jb21wX3JpbmcubmV4dDJwcm9jOworCWJ1Zls1XSA9IGFkYXB0ZXItPnR4X3F1ZXVlLmNvbXBfcmluZy5nZW47CisJYnVmWzZdID0gYWRhcHRlci0+dHhfcXVldWUuc3RvcHBlZDsKKwlidWZbN10gPSAwOworCisJYnVmWzhdID0gYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5uZXh0MmZpbGw7CisJYnVmWzldID0gYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5uZXh0MmNvbXA7CisJYnVmWzEwXSA9IGFkYXB0ZXItPnJ4X3F1ZXVlLnJ4X3JpbmdbMF0uZ2VuOworCWJ1ZlsxMV0gPSAwOworCisJYnVmWzEyXSA9IGFkYXB0ZXItPnJ4X3F1ZXVlLnJ4X3JpbmdbMV0ubmV4dDJmaWxsOworCWJ1ZlsxM10gPSBhZGFwdGVyLT5yeF9xdWV1ZS5yeF9yaW5nWzFdLm5leHQyY29tcDsKKwlidWZbMTRdID0gYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1sxXS5nZW47CisJYnVmWzE1XSA9IDA7CisKKwlidWZbMTZdID0gYWRhcHRlci0+cnhfcXVldWUuY29tcF9yaW5nLm5leHQycHJvYzsKKwlidWZbMTddID0gYWRhcHRlci0+cnhfcXVldWUuY29tcF9yaW5nLmdlbjsKKwlidWZbMThdID0gMDsKKwlidWZbMTldID0gMDsKK30KKworCitzdGF0aWMgdm9pZAordm14bmV0M19nZXRfd29sKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsIHN0cnVjdCBldGh0b29sX3dvbGluZm8gKndvbCkKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCXdvbC0+c3VwcG9ydGVkID0gV0FLRV9VQ0FTVCB8IFdBS0VfQVJQIHwgV0FLRV9NQUdJQzsKKwl3b2wtPndvbG9wdHMgPSBhZGFwdGVyLT53b2w7Cit9CisKKworc3RhdGljIGludAordm14bmV0M19zZXRfd29sKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYsIHN0cnVjdCBldGh0b29sX3dvbGluZm8gKndvbCkKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKworCWlmICh3b2wtPndvbG9wdHMgJiAoV0FLRV9QSFkgfCBXQUtFX01DQVNUIHwgV0FLRV9CQ0FTVCB8CisJCQkgICAgV0FLRV9NQUdJQ1NFQ1VSRSkpIHsKKwkJcmV0dXJuIC1FT1BOT1RTVVBQOworCX0KKworCWFkYXB0ZXItPndvbCA9IHdvbC0+d29sb3B0czsKKworCWRldmljZV9zZXRfd2FrZXVwX2VuYWJsZSgmYWRhcHRlci0+cGRldi0+ZGV2LCBhZGFwdGVyLT53b2wpOworCisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIGludAordm14bmV0M19nZXRfc2V0dGluZ3Moc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwgc3RydWN0IGV0aHRvb2xfY21kICplY21kKQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCisJZWNtZC0+c3VwcG9ydGVkID0gU1VQUE9SVEVEXzEwMDAwYmFzZVRfRnVsbCB8IFNVUFBPUlRFRF8xMDAwYmFzZVRfRnVsbCB8CisJCQkgIFNVUFBPUlRFRF9UUDsKKwllY21kLT5hZHZlcnRpc2luZyA9IEFEVkVSVElTRURfVFA7CisJZWNtZC0+cG9ydCA9IFBPUlRfVFA7CisJZWNtZC0+dHJhbnNjZWl2ZXIgPSBYQ1ZSX0lOVEVSTkFMOworCisJaWYgKGFkYXB0ZXItPmxpbmtfc3BlZWQpIHsKKwkJZWNtZC0+c3BlZWQgPSBhZGFwdGVyLT5saW5rX3NwZWVkOworCQllY21kLT5kdXBsZXggPSBEVVBMRVhfRlVMTDsKKwl9IGVsc2UgeworCQllY21kLT5zcGVlZCA9IC0xOworCQllY21kLT5kdXBsZXggPSAtMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKKworc3RhdGljIHZvaWQKK3ZteG5ldDNfZ2V0X3JpbmdwYXJhbShzdHJ1Y3QgbmV0X2RldmljZSAqbmV0ZGV2LAorCQkgICAgICBzdHJ1Y3QgZXRodG9vbF9yaW5ncGFyYW0gKnBhcmFtKQoreworCXN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIgPSBuZXRkZXZfcHJpdihuZXRkZXYpOworCisJcGFyYW0tPnJ4X21heF9wZW5kaW5nID0gVk1YTkVUM19SWF9SSU5HX01BWF9TSVpFOworCXBhcmFtLT50eF9tYXhfcGVuZGluZyA9IFZNWE5FVDNfVFhfUklOR19NQVhfU0laRTsKKwlwYXJhbS0+cnhfbWluaV9tYXhfcGVuZGluZyA9IDA7CisJcGFyYW0tPnJ4X2p1bWJvX21heF9wZW5kaW5nID0gMDsKKworCXBhcmFtLT5yeF9wZW5kaW5nID0gYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5zaXplOworCXBhcmFtLT50eF9wZW5kaW5nID0gYWRhcHRlci0+dHhfcXVldWUudHhfcmluZy5zaXplOworCXBhcmFtLT5yeF9taW5pX3BlbmRpbmcgPSAwOworCXBhcmFtLT5yeF9qdW1ib19wZW5kaW5nID0gMDsKK30KKworCitzdGF0aWMgaW50Cit2bXhuZXQzX3NldF9yaW5ncGFyYW0oc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldiwKKwkJICAgICAgc3RydWN0IGV0aHRvb2xfcmluZ3BhcmFtICpwYXJhbSkKK3sKKwlzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyID0gbmV0ZGV2X3ByaXYobmV0ZGV2KTsKKwl1MzIgbmV3X3R4X3Jpbmdfc2l6ZSwgbmV3X3J4X3Jpbmdfc2l6ZTsKKwl1MzIgc3o7CisJaW50IGVyciA9IDA7CisKKwlpZiAocGFyYW0tPnR4X3BlbmRpbmcgPT0gMCB8fCBwYXJhbS0+dHhfcGVuZGluZyA+CisJCQkJCQlWTVhORVQzX1RYX1JJTkdfTUFYX1NJWkUpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKHBhcmFtLT5yeF9wZW5kaW5nID09IDAgfHwgcGFyYW0tPnJ4X3BlbmRpbmcgPgorCQkJCQkJVk1YTkVUM19SWF9SSU5HX01BWF9TSVpFKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCisJLyogcm91bmQgaXQgdXAgdG8gYSBtdWx0aXBsZSBvZiBWTVhORVQzX1JJTkdfU0laRV9BTElHTiAqLworCW5ld190eF9yaW5nX3NpemUgPSAocGFyYW0tPnR4X3BlbmRpbmcgKyBWTVhORVQzX1JJTkdfU0laRV9NQVNLKSAmCisJCQkJCQkJflZNWE5FVDNfUklOR19TSVpFX01BU0s7CisJbmV3X3R4X3Jpbmdfc2l6ZSA9IG1pbl90KHUzMiwgbmV3X3R4X3Jpbmdfc2l6ZSwKKwkJCQkgVk1YTkVUM19UWF9SSU5HX01BWF9TSVpFKTsKKwlpZiAobmV3X3R4X3Jpbmdfc2l6ZSA+IFZNWE5FVDNfVFhfUklOR19NQVhfU0laRSB8fCAobmV3X3R4X3Jpbmdfc2l6ZSAlCisJCQkJCQlWTVhORVQzX1JJTkdfU0laRV9BTElHTikgIT0gMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwkvKiByaW5nMCBoYXMgdG8gYmUgYSBtdWx0aXBsZSBvZgorCSAqIHJ4X2J1Zl9wZXJfcGt0ICogVk1YTkVUM19SSU5HX1NJWkVfQUxJR04KKwkgKi8KKwlzeiA9IGFkYXB0ZXItPnJ4X2J1Zl9wZXJfcGt0ICogVk1YTkVUM19SSU5HX1NJWkVfQUxJR047CisJbmV3X3J4X3Jpbmdfc2l6ZSA9IChwYXJhbS0+cnhfcGVuZGluZyArIHN6IC0gMSkgLyBzeiAqIHN6OworCW5ld19yeF9yaW5nX3NpemUgPSBtaW5fdCh1MzIsIG5ld19yeF9yaW5nX3NpemUsCisJCQkJIFZNWE5FVDNfUlhfUklOR19NQVhfU0laRSAvIHN6ICogc3opOworCWlmIChuZXdfcnhfcmluZ19zaXplID4gVk1YTkVUM19SWF9SSU5HX01BWF9TSVpFIHx8IChuZXdfcnhfcmluZ19zaXplICUKKwkJCQkJCQkgICBzeikgIT0gMCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlpZiAobmV3X3R4X3Jpbmdfc2l6ZSA9PSBhZGFwdGVyLT50eF9xdWV1ZS50eF9yaW5nLnNpemUgJiYKKwkJCW5ld19yeF9yaW5nX3NpemUgPT0gYWRhcHRlci0+cnhfcXVldWUucnhfcmluZ1swXS5zaXplKSB7CisJCXJldHVybiAwOworCX0KKworCS8qCisJICogUmVzZXRfd29yayBtYXkgYmUgaW4gdGhlIG1pZGRsZSBvZiByZXNldHRpbmcgdGhlIGRldmljZSwgd2FpdCBmb3IgaXRzCisJICogY29tcGxldGlvbi4KKwkgKi8KKwl3aGlsZSAodGVzdF9hbmRfc2V0X2JpdChWTVhORVQzX1NUQVRFX0JJVF9SRVNFVFRJTkcsICZhZGFwdGVyLT5zdGF0ZSkpCisJCW1zbGVlcCgxKTsKKworCWlmIChuZXRpZl9ydW5uaW5nKG5ldGRldikpIHsKKwkJdm14bmV0M19xdWllc2NlX2RldihhZGFwdGVyKTsKKwkJdm14bmV0M19yZXNldF9kZXYoYWRhcHRlcik7CisKKwkJLyogcmVjcmVhdGUgdGhlIHJ4IHF1ZXVlIGFuZCB0aGUgdHggcXVldWUgYmFzZWQgb24gdGhlCisJCSAqIG5ldyBzaXplcyAqLworCQl2bXhuZXQzX3RxX2Rlc3Ryb3koJmFkYXB0ZXItPnR4X3F1ZXVlLCBhZGFwdGVyKTsKKwkJdm14bmV0M19ycV9kZXN0cm95KCZhZGFwdGVyLT5yeF9xdWV1ZSwgYWRhcHRlcik7CisKKwkJZXJyID0gdm14bmV0M19jcmVhdGVfcXVldWVzKGFkYXB0ZXIsIG5ld190eF9yaW5nX3NpemUsCisJCQluZXdfcnhfcmluZ19zaXplLCBWTVhORVQzX0RFRl9SWF9SSU5HX1NJWkUpOworCQlpZiAoZXJyKSB7CisJCQkvKiBmYWlsZWQsIG1vc3QgbGlrZWx5IGJlY2F1c2Ugb2YgT09NLCB0cnkgZGVmYXVsdAorCQkJICogc2l6ZSAqLworCQkJcHJpbnRrKEtFUk5fRVJSICIlczogZmFpbGVkIHRvIGFwcGx5IG5ldyBzaXplcywgdHJ5IHRoZSIKKwkJCQkiIGRlZmF1bHQgb25lc1xuIiwgbmV0ZGV2LT5uYW1lKTsKKwkJCWVyciA9IHZteG5ldDNfY3JlYXRlX3F1ZXVlcyhhZGFwdGVyLAorCQkJCQkJICAgIFZNWE5FVDNfREVGX1RYX1JJTkdfU0laRSwKKwkJCQkJCSAgICBWTVhORVQzX0RFRl9SWF9SSU5HX1NJWkUsCisJCQkJCQkgICAgVk1YTkVUM19ERUZfUlhfUklOR19TSVpFKTsKKwkJCWlmIChlcnIpIHsKKwkJCQlwcmludGsoS0VSTl9FUlIgIiVzOiBmYWlsZWQgdG8gY3JlYXRlIHF1ZXVlcyAiCisJCQkJCSJ3aXRoIGRlZmF1bHQgc2l6ZXMuIENsb3NpbmcgaXRcbiIsCisJCQkJCW5ldGRldi0+bmFtZSk7CisJCQkJZ290byBvdXQ7CisJCQl9CisJCX0KKworCQllcnIgPSB2bXhuZXQzX2FjdGl2YXRlX2RldihhZGFwdGVyKTsKKwkJaWYgKGVycikKKwkJCXByaW50ayhLRVJOX0VSUiAiJXM6IGZhaWxlZCB0byByZS1hY3RpdmF0ZSwgZXJyb3IgJWQuIgorCQkJCSIgQ2xvc2luZyBpdFxuIiwgbmV0ZGV2LT5uYW1lLCBlcnIpOworCX0KKworb3V0OgorCWNsZWFyX2JpdChWTVhORVQzX1NUQVRFX0JJVF9SRVNFVFRJTkcsICZhZGFwdGVyLT5zdGF0ZSk7CisJaWYgKGVycikKKwkJdm14bmV0M19mb3JjZV9jbG9zZShhZGFwdGVyKTsKKworCXJldHVybiBlcnI7Cit9CisKKworc3RhdGljIHN0cnVjdCBldGh0b29sX29wcyB2bXhuZXQzX2V0aHRvb2xfb3BzID0geworCS5nZXRfc2V0dGluZ3MgICAgICA9IHZteG5ldDNfZ2V0X3NldHRpbmdzLAorCS5nZXRfZHJ2aW5mbyAgICAgICA9IHZteG5ldDNfZ2V0X2RydmluZm8sCisJLmdldF9yZWdzX2xlbiAgICAgID0gdm14bmV0M19nZXRfcmVnc19sZW4sCisJLmdldF9yZWdzICAgICAgICAgID0gdm14bmV0M19nZXRfcmVncywKKwkuZ2V0X3dvbCAgICAgICAgICAgPSB2bXhuZXQzX2dldF93b2wsCisJLnNldF93b2wgICAgICAgICAgID0gdm14bmV0M19zZXRfd29sLAorCS5nZXRfbGluayAgICAgICAgICA9IGV0aHRvb2xfb3BfZ2V0X2xpbmssCisJLmdldF9yeF9jc3VtICAgICAgID0gdm14bmV0M19nZXRfcnhfY3N1bSwKKwkuc2V0X3J4X2NzdW0gICAgICAgPSB2bXhuZXQzX3NldF9yeF9jc3VtLAorCS5nZXRfdHhfY3N1bSAgICAgICA9IGV0aHRvb2xfb3BfZ2V0X3R4X2NzdW0sCisJLnNldF90eF9jc3VtICAgICAgID0gZXRodG9vbF9vcF9zZXRfdHhfaHdfY3N1bSwKKwkuZ2V0X3NnICAgICAgICAgICAgPSBldGh0b29sX29wX2dldF9zZywKKwkuc2V0X3NnICAgICAgICAgICAgPSBldGh0b29sX29wX3NldF9zZywKKwkuZ2V0X3RzbyAgICAgICAgICAgPSBldGh0b29sX29wX2dldF90c28sCisJLnNldF90c28gICAgICAgICAgID0gZXRodG9vbF9vcF9zZXRfdHNvLAorCS5nZXRfc3RyaW5ncyAgICAgICA9IHZteG5ldDNfZ2V0X3N0cmluZ3MsCisJLmdldF9mbGFncwkgICA9IHZteG5ldDNfZ2V0X2ZsYWdzLAorCS5zZXRfZmxhZ3MJICAgPSB2bXhuZXQzX3NldF9mbGFncywKKwkuZ2V0X3NzZXRfY291bnQJICAgPSB2bXhuZXQzX2dldF9zc2V0X2NvdW50LAorCS5nZXRfZXRodG9vbF9zdGF0cyA9IHZteG5ldDNfZ2V0X2V0aHRvb2xfc3RhdHMsCisJLmdldF9yaW5ncGFyYW0gICAgID0gdm14bmV0M19nZXRfcmluZ3BhcmFtLAorCS5zZXRfcmluZ3BhcmFtICAgICA9IHZteG5ldDNfc2V0X3JpbmdwYXJhbSwKK307CisKK3ZvaWQgdm14bmV0M19zZXRfZXRodG9vbF9vcHMoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldikKK3sKKwlTRVRfRVRIVE9PTF9PUFMobmV0ZGV2LCAmdm14bmV0M19ldGh0b29sX29wcyk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfaW50LmggYi9kcml2ZXJzL25ldC92bXhuZXQzL3ZteG5ldDNfaW50LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2MwZDcwZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvbmV0L3ZteG5ldDMvdm14bmV0M19pbnQuaApAQCAtMCwwICsxLDM4OSBAQAorLyoKKyAqIExpbnV4IGRyaXZlciBmb3IgVk13YXJlJ3Mgdm14bmV0MyBldGhlcm5ldCBOSUMuCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA4LTIwMDksIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKKyAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlIGFuZCBubyBsYXRlciB2ZXJzaW9uLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSwgR09PRCBUSVRMRSBvcgorICogTk9OIElORlJJTkdFTUVOVC4gIFNlZSB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUKKyAqIGRldGFpbHMuCisgKgorICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCisgKiBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdCwgRmlmdGggRmxvb3IsIEJvc3RvbiwgTUEgMDIxMTAtMTMwMSBVU0EuCisgKgorICogVGhlIGZ1bGwgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4KKyAqIHRoZSBmaWxlIGNhbGxlZCAiQ09QWUlORyIuCisgKgorICogTWFpbnRhaW5lZCBieTogU2hyZXlhcyBCaGF0ZXdhcmEgPHB2LWRyaXZlcnNAdm13YXJlLmNvbT4KKyAqCisgKi8KKworI2lmbmRlZiBfVk1YTkVUM19JTlRfSAorI2RlZmluZSBfVk1YTkVUM19JTlRfSAorCisjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9ldGh0b29sLmg+CisjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKyNpbmNsdWRlIDxsaW51eC9ldGh0b29sLmg+CisjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9tb2R1bGVwYXJhbS5oPgorI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KKyNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L2hpZ2htZW0uaD4KKyNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CisjaW5jbHVkZSA8bGludXgvdGltZXIuaD4KKyNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8YXNtL2RtYS5oPgorI2luY2x1ZGUgPGFzbS9wYWdlLmg+CisKKyNpbmNsdWRlIDxsaW51eC90Y3AuaD4KKyNpbmNsdWRlIDxsaW51eC91ZHAuaD4KKyNpbmNsdWRlIDxsaW51eC9pcC5oPgorI2luY2x1ZGUgPGxpbnV4L2lwdjYuaD4KKyNpbmNsdWRlIDxsaW51eC9pbi5oPgorI2luY2x1ZGUgPGxpbnV4L2V0aGVyZGV2aWNlLmg+CisjaW5jbHVkZSA8YXNtL2NoZWNrc3VtLmg+CisjaW5jbHVkZSA8bGludXgvaWZfdmxhbi5oPgorI2luY2x1ZGUgPGxpbnV4L2lmX2FycC5oPgorI2luY2x1ZGUgPGxpbnV4L2luZXRkZXZpY2UuaD4KKworI2luY2x1ZGUgInZteG5ldDNfZGVmcy5oIgorCisjaWZkZWYgREVCVUcKKyMgZGVmaW5lIFZNWE5FVDNfRFJJVkVSX1ZFUlNJT05fUkVQT1JUIFZNWE5FVDNfRFJJVkVSX1ZFUlNJT05fU1RSSU5HIi1OQVBJKGRlYnVnKSIKKyNlbHNlCisjIGRlZmluZSBWTVhORVQzX0RSSVZFUl9WRVJTSU9OX1JFUE9SVCBWTVhORVQzX0RSSVZFUl9WRVJTSU9OX1NUUklORyItTkFQSSIKKyNlbmRpZgorCisKKy8qCisgKiBWZXJzaW9uIG51bWJlcnMKKyAqLworI2RlZmluZSBWTVhORVQzX0RSSVZFUl9WRVJTSU9OX1NUUklORyAgICIxLjAuNS4wLWsiCisKKy8qIGEgMzItYml0IGludCwgZWFjaCBieXRlIGVuY29kZSBhIHZlcmlvbiBudW1iZXIgaW4gVk1YTkVUM19EUklWRVJfVkVSU0lPTiAqLworI2RlZmluZSBWTVhORVQzX0RSSVZFUl9WRVJTSU9OX05VTSAgICAgIDB4MDEwMDA1MDAKKworCisvKgorICogQ2FwYWJpbGl0aWVzCisgKi8KKworZW51bSB7CisJVk1ORVRfQ0FQX1NHCSAgICAgICAgPSAweDAwMDEsIC8qIENhbiBkbyBzY2F0dGVyLWdhdGhlciB0cmFuc21pdHMuICovCisJVk1ORVRfQ0FQX0lQNF9DU1VNICAgICAgPSAweDAwMDIsIC8qIENhbiBjaGVja3N1bSBvbmx5IFRDUC9VRFAgb3ZlcgorCQkJCQkgICAqIElQdjQgKi8KKwlWTU5FVF9DQVBfSFdfQ1NVTSAgICAgICA9IDB4MDAwNCwgLyogQ2FuIGNoZWNrc3VtIGFsbCBwYWNrZXRzLiAqLworCVZNTkVUX0NBUF9ISUdIX0RNQSAgICAgID0gMHgwMDA4LCAvKiBDYW4gRE1BIHRvIGhpZ2ggbWVtb3J5LiAqLworCVZNTkVUX0NBUF9UT0UJICAgICAgICA9IDB4MDAxMCwgLyogU3VwcG9ydHMgVENQL0lQIG9mZmxvYWQuICovCisJVk1ORVRfQ0FQX1RTTwkgICAgICAgID0gMHgwMDIwLCAvKiBTdXBwb3J0cyBUQ1AgU2VnbWVudGF0aW9uCisJCQkJCSAgICogb2ZmbG9hZCAqLworCVZNTkVUX0NBUF9TV19UU08gICAgICAgID0gMHgwMDQwLCAvKiBTdXBwb3J0cyBTVyBUQ1AgU2VnbWVudGF0aW9uICovCisJVk1ORVRfQ0FQX1ZNWE5FVF9BUFJPTSAgPSAweDAwODAsIC8qIFZteG5ldCBBUFJPTSBzdXBwb3J0ICovCisJVk1ORVRfQ0FQX0hXX1RYX1ZMQU4gICAgPSAweDAxMDAsIC8qIENhbiB3ZSBkbyBWTEFOIHRhZ2dpbmcgaW4gSFcgKi8KKwlWTU5FVF9DQVBfSFdfUlhfVkxBTiAgICA9IDB4MDIwMCwgLyogQ2FuIHdlIGRvIFZMQU4gdW50YWdnaW5nIGluIEhXICovCisJVk1ORVRfQ0FQX1NXX1ZMQU4gICAgICAgPSAweDA0MDAsIC8qIFZMQU4gdGFnZ2luZy91bnRhZ2dpbmcgaW4gU1cgKi8KKwlWTU5FVF9DQVBfV0FLRV9QQ0tUX1JDViA9IDB4MDgwMCwgLyogQ2FuIHdha2Ugb24gbmV0d29yayBwYWNrZXQgcmVjdj8gKi8KKwlWTU5FVF9DQVBfRU5BQkxFX0lOVF9JTkxJTkUgPSAweDEwMDAsICAvKiBFbmFibGUgSW50ZXJydXB0IElubGluZSAqLworCVZNTkVUX0NBUF9FTkFCTEVfSEVBREVSX0NPUFkgPSAweDIwMDAsICAvKiBjb3B5IGhlYWRlciBmb3Igdm1rZXJuZWwgKi8KKwlWTU5FVF9DQVBfVFhfQ0hBSU4gICAgICA9IDB4NDAwMCwgLyogR3Vlc3QgY2FuIHVzZSBtdWx0aXBsZSB0eCBlbnRyaWVzCisJCQkJCSAgKiBmb3IgYSBwa3QgKi8KKwlWTU5FVF9DQVBfUlhfQ0hBSU4gICAgICA9IDB4ODAwMCwgLyogcGt0IGNhbiBzcGFuIG11bHRpcGxlIHJ4IGVudHJpZXMgKi8KKwlWTU5FVF9DQVBfTFBEICAgICAgICAgICA9IDB4MTAwMDAsIC8qIGxhcmdlIHBrdCBkZWxpdmVyeSAqLworCVZNTkVUX0NBUF9CUEYgICAgICAgICAgID0gMHgyMDAwMCwgLyogQlBGIFN1cHBvcnQgaW4gVk1YTkVUIFZpcnR1YWwgSFcqLworCVZNTkVUX0NBUF9TR19TUEFOX1BBR0VTID0gMHg0MDAwMCwgLyogU2NhdHRlci1nYXRoZXIgY2FuIHNwYW4gbXVsdGlwbGUqLworCQkJCQkgICAvKiBwYWdlcyB0cmFuc21pdHMgKi8KKwlWTU5FVF9DQVBfSVA2X0NTVU0gICAgICA9IDB4ODAwMDAsIC8qIENhbiBkbyBJUHY2IGNzdW0gb2ZmbG9hZC4gKi8KKwlWTU5FVF9DQVBfVFNPNiAgICAgICAgID0gMHgxMDAwMDAsIC8qIFRTTyBzZWcuIG9mZmxvYWQgZm9yIElQdjYgcGt0cy4gKi8KKwlWTU5FVF9DQVBfVFNPMjU2ayAgICAgID0gMHgyMDAwMDAsIC8qIENhbiBkbyBUU08gc2VnIG9mZmxvYWQgZm9yICovCisJCQkJCSAgIC8qIHBrdHMgdXAgdG8gMjU2a0IuICovCisJVk1ORVRfQ0FQX1VQVCAgICAgICAgICA9IDB4NDAwMDAwICAvKiBTdXBwb3J0IFVQVCAqLworfTsKKworLyoKKyAqIFBDSSB2ZW5kb3IgYW5kIGRldmljZSBJRHMuCisgKi8KKyNkZWZpbmUgUENJX1ZFTkRPUl9JRF9WTVdBUkUgICAgICAgICAgICAweDE1QUQKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9WTVdBUkVfVk1YTkVUMyAgICAweDA3QjAKKyNkZWZpbmUgTUFYX0VUSEVSTkVUX0NBUkRTCQkxMAorI2RlZmluZSBNQVhfUENJX1BBU1NUSFJVX0RFVklDRQkJNgorCitzdHJ1Y3Qgdm14bmV0M19jbWRfcmluZyB7CisJdW5pb24gVm14bmV0M19HZW5lcmljRGVzYyAqYmFzZTsKKwl1MzIJCXNpemU7CisJdTMyCQluZXh0MmZpbGw7CisJdTMyCQluZXh0MmNvbXA7CisJdTgJCWdlbjsKKwlkbWFfYWRkcl90CWJhc2VQQTsKK307CisKK3N0YXRpYyBpbmxpbmUgdm9pZAordm14bmV0M19jbWRfcmluZ19hZHZfbmV4dDJmaWxsKHN0cnVjdCB2bXhuZXQzX2NtZF9yaW5nICpyaW5nKQoreworCXJpbmctPm5leHQyZmlsbCsrOworCWlmICh1bmxpa2VseShyaW5nLT5uZXh0MmZpbGwgPT0gcmluZy0+c2l6ZSkpIHsKKwkJcmluZy0+bmV4dDJmaWxsID0gMDsKKwkJVk1YTkVUM19GTElQX1JJTkdfR0VOKHJpbmctPmdlbik7CisJfQorfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3ZteG5ldDNfY21kX3JpbmdfYWR2X25leHQyY29tcChzdHJ1Y3Qgdm14bmV0M19jbWRfcmluZyAqcmluZykKK3sKKwlWTVhORVQzX0lOQ19SSU5HX0lEWF9PTkxZKHJpbmctPm5leHQyY29tcCwgcmluZy0+c2l6ZSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50Cit2bXhuZXQzX2NtZF9yaW5nX2Rlc2NfYXZhaWwoc3RydWN0IHZteG5ldDNfY21kX3JpbmcgKnJpbmcpCit7CisJcmV0dXJuIChyaW5nLT5uZXh0MmNvbXAgPiByaW5nLT5uZXh0MmZpbGwgPyAwIDogcmluZy0+c2l6ZSkgKworCQlyaW5nLT5uZXh0MmNvbXAgLSByaW5nLT5uZXh0MmZpbGwgLSAxOworfQorCitzdHJ1Y3Qgdm14bmV0M19jb21wX3JpbmcgeworCXVuaW9uIFZteG5ldDNfR2VuZXJpY0Rlc2MgKmJhc2U7CisJdTMyICAgICAgICAgICAgICAgc2l6ZTsKKwl1MzIgICAgICAgICAgICAgICBuZXh0MnByb2M7CisJdTggICAgICAgICAgICAgICAgZ2VuOworCXU4ICAgICAgICAgICAgICAgIGludHJfaWR4OworCWRtYV9hZGRyX3QgICAgICAgICAgIGJhc2VQQTsKK307CisKK3N0YXRpYyBpbmxpbmUgdm9pZAordm14bmV0M19jb21wX3JpbmdfYWR2X25leHQycHJvYyhzdHJ1Y3Qgdm14bmV0M19jb21wX3JpbmcgKnJpbmcpCit7CisJcmluZy0+bmV4dDJwcm9jKys7CisJaWYgKHVubGlrZWx5KHJpbmctPm5leHQycHJvYyA9PSByaW5nLT5zaXplKSkgeworCQlyaW5nLT5uZXh0MnByb2MgPSAwOworCQlWTVhORVQzX0ZMSVBfUklOR19HRU4ocmluZy0+Z2VuKTsKKwl9Cit9CisKK3N0cnVjdCB2bXhuZXQzX3R4X2RhdGFfcmluZyB7CisJc3RydWN0IFZteG5ldDNfVHhEYXRhRGVzYyAqYmFzZTsKKwl1MzIgICAgICAgICAgICAgIHNpemU7CisJZG1hX2FkZHJfdCAgICAgICAgICBiYXNlUEE7Cit9OworCitlbnVtIHZteG5ldDNfYnVmX21hcF90eXBlIHsKKwlWTVhORVQzX01BUF9JTlZBTElEID0gMCwKKwlWTVhORVQzX01BUF9OT05FLAorCVZNWE5FVDNfTUFQX1NJTkdMRSwKKwlWTVhORVQzX01BUF9QQUdFLAorfTsKKworc3RydWN0IHZteG5ldDNfdHhfYnVmX2luZm8geworCXUzMiAgICAgIG1hcF90eXBlOworCXUxNiAgICAgIGxlbjsKKwl1MTYgICAgICBzb3BfaWR4OworCWRtYV9hZGRyX3QgIGRtYV9hZGRyOworCXN0cnVjdCBza19idWZmICpza2I7Cit9OworCitzdHJ1Y3Qgdm14bmV0M190cV9kcml2ZXJfc3RhdHMgeworCXU2NCBkcm9wX3RvdGFsOyAgICAgLyogIyBvZiBwa3RzIGRyb3BwZWQgYnkgdGhlIGRyaXZlciwgdGhlCisJCQkJKiBjb3VudGVycyBiZWxvdyB0cmFjayBkcm9wcGluZ3MgZHVlIHRvCisJCQkJKiBkaWZmZXJlbnQgcmVhc29ucworCQkJCSovCisJdTY0IGRyb3BfdG9vX21hbnlfZnJhZ3M7CisJdTY0IGRyb3Bfb3ZlcnNpemVkX2hkcjsKKwl1NjQgZHJvcF9oZHJfaW5zcGVjdF9lcnI7CisJdTY0IGRyb3BfdHNvOworCisJdTY0IHR4X3JpbmdfZnVsbDsKKwl1NjQgbGluZWFyaXplZDsgICAgICAgICAvKiAjIG9mIHBrdHMgbGluZWFyaXplZCAqLworCXU2NCBjb3B5X3NrYl9oZWFkZXI7ICAgIC8qICMgb2YgdGltZXMgd2UgaGF2ZSB0byBjb3B5IHNrYiBoZWFkZXIgKi8KKwl1NjQgb3ZlcnNpemVkX2hkcjsKK307CisKK3N0cnVjdCB2bXhuZXQzX3R4X2N0eCB7CisJYm9vbCAgIGlwdjQ7CisJdTE2IG1zczsKKwl1MzIgZXRoX2lwX2hkcl9zaXplOyAvKiBvbmx5IHZhbGlkIGZvciBwa3RzIHJlcXVlc3RpbmcgdHNvIG9yIGNzdW0KKwkJCQkgKiBvZmZsb2FkaW5nCisJCQkJICovCisJdTMyIGw0X2hkcl9zaXplOyAgICAgLyogb25seSB2YWxpZCBpZiBtc3MgIT0gMCAqLworCXUzMiBjb3B5X3NpemU7ICAgICAgIC8qICMgb2YgYnl0ZXMgY29waWVkIGludG8gdGhlIGRhdGEgcmluZyAqLworCXVuaW9uIFZteG5ldDNfR2VuZXJpY0Rlc2MgKnNvcF90eGQ7CisJdW5pb24gVm14bmV0M19HZW5lcmljRGVzYyAqZW9wX3R4ZDsKK307CisKK3N0cnVjdCB2bXhuZXQzX3R4X3F1ZXVlIHsKKwlzcGlubG9ja190ICAgICAgICAgICAgICAgICAgICAgIHR4X2xvY2s7CisJc3RydWN0IHZteG5ldDNfY21kX3JpbmcgICAgICAgICB0eF9yaW5nOworCXN0cnVjdCB2bXhuZXQzX3R4X2J1Zl9pbmZvICAgICAqYnVmX2luZm87CisJc3RydWN0IHZteG5ldDNfdHhfZGF0YV9yaW5nICAgICBkYXRhX3Jpbmc7CisJc3RydWN0IHZteG5ldDNfY29tcF9yaW5nICAgICAgICBjb21wX3Jpbmc7CisJc3RydWN0IFZteG5ldDNfVHhRdWV1ZUN0cmwgICAgICAgICAgICAqc2hhcmVkOworCXN0cnVjdCB2bXhuZXQzX3RxX2RyaXZlcl9zdGF0cyAgc3RhdHM7CisJYm9vbCAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdG9wcGVkOworCWludCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbnVtX3N0b3A7ICAvKiAjIG9mIHRpbWVzIHRoZSBxdWV1ZSBpcworCQkJCQkJICAgICogc3RvcHBlZCAqLworfSBfX2F0dHJpYnV0ZV9fKChfX2FsaWduZWRfXyhTTVBfQ0FDSEVfQllURVMpKSk7CisKK2VudW0gdm14bmV0M19yeF9idWZfdHlwZSB7CisJVk1YTkVUM19SWF9CVUZfTk9ORSA9IDAsCisJVk1YTkVUM19SWF9CVUZfU0tCID0gMSwKKwlWTVhORVQzX1JYX0JVRl9QQUdFID0gMgorfTsKKworc3RydWN0IHZteG5ldDNfcnhfYnVmX2luZm8geworCWVudW0gdm14bmV0M19yeF9idWZfdHlwZSBidWZfdHlwZTsKKwl1MTYgICAgIGxlbjsKKwl1bmlvbiB7CisJCXN0cnVjdCBza19idWZmICpza2I7CisJCXN0cnVjdCBwYWdlICAgICpwYWdlOworCX07CisJZG1hX2FkZHJfdCBkbWFfYWRkcjsKK307CisKK3N0cnVjdCB2bXhuZXQzX3J4X2N0eCB7CisJc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwl1MzIgc29wX2lkeDsKK307CisKK3N0cnVjdCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cyB7CisJdTY0IGRyb3BfdG90YWw7CisJdTY0IGRyb3BfZXJyOworCXU2NCBkcm9wX2ZjczsKKwl1NjQgcnhfYnVmX2FsbG9jX2ZhaWx1cmU7Cit9OworCitzdHJ1Y3Qgdm14bmV0M19yeF9xdWV1ZSB7CisJc3RydWN0IHZteG5ldDNfY21kX3JpbmcgICByeF9yaW5nWzJdOworCXN0cnVjdCB2bXhuZXQzX2NvbXBfcmluZyAgY29tcF9yaW5nOworCXN0cnVjdCB2bXhuZXQzX3J4X2N0eCAgICAgcnhfY3R4OworCXUzMiBxaWQ7ICAgICAgICAgICAgLyogcnFJRCBpbiBSQ0QgZm9yIGJ1ZmZlciBmcm9tIDFzdCByaW5nICovCisJdTMyIHFpZDI7ICAgICAgICAgICAvKiBycUlEIGluIFJDRCBmb3IgYnVmZmVyIGZyb20gMm5kIHJpbmcgKi8KKwl1MzIgdW5jb21taXR0ZWRbMl07IC8qICMgb2YgYnVmZmVycyBhbGxvY2F0ZWQgc2luY2UgbGFzdCBSWFBST0QKKwkJCQkqIHVwZGF0ZSAqLworCXN0cnVjdCB2bXhuZXQzX3J4X2J1Zl9pbmZvICAgICAqYnVmX2luZm9bMl07CisJc3RydWN0IFZteG5ldDNfUnhRdWV1ZUN0cmwgICAgICAgICAgICAqc2hhcmVkOworCXN0cnVjdCB2bXhuZXQzX3JxX2RyaXZlcl9zdGF0cyAgc3RhdHM7Cit9IF9fYXR0cmlidXRlX18oKF9fYWxpZ25lZF9fKFNNUF9DQUNIRV9CWVRFUykpKTsKKworI2RlZmluZSBWTVhORVQzX0xJTlVYX01BWF9NU0lYX1ZFQ1QgICAgIDEKKworc3RydWN0IHZteG5ldDNfaW50ciB7CisJZW51bSB2bXhuZXQzX2ludHJfbWFza19tb2RlICBtYXNrX21vZGU7CisJZW51bSB2bXhuZXQzX2ludHJfdHlwZSAgICAgICB0eXBlOwkvKiBNU0ktWCwgTVNJLCBvciBJTlR4PyAqLworCXU4ICBudW1faW50cnM7CQkJLyogIyBvZiBpbnRyIHZlY3RvcnMgKi8KKwl1OCAgZXZlbnRfaW50cl9pZHg7CQkvKiBpZHggb2YgdGhlIGludHIgdmVjdG9yIGZvciBldmVudCAqLworCXU4ICBtb2RfbGV2ZWxzW1ZNWE5FVDNfTElOVVhfTUFYX01TSVhfVkVDVF07IC8qIG1vZGVyYXRpb24gbGV2ZWwgKi8KKyNpZmRlZiBDT05GSUdfUENJX01TSQorCXN0cnVjdCBtc2l4X2VudHJ5IG1zaXhfZW50cmllc1tWTVhORVQzX0xJTlVYX01BWF9NU0lYX1ZFQ1RdOworI2VuZGlmCit9OworCisjZGVmaW5lIFZNWE5FVDNfU1RBVEVfQklUX1JFU0VUVElORyAgIDAKKyNkZWZpbmUgVk1YTkVUM19TVEFURV9CSVRfUVVJRVNDRUQgICAgMQorc3RydWN0IHZteG5ldDNfYWRhcHRlciB7CisJc3RydWN0IHZteG5ldDNfdHhfcXVldWUgICAgICAgICB0eF9xdWV1ZTsKKwlzdHJ1Y3Qgdm14bmV0M19yeF9xdWV1ZSAgICAgICAgIHJ4X3F1ZXVlOworCXN0cnVjdCBuYXBpX3N0cnVjdCAgICAgICAgICAgICAgbmFwaTsKKwlzdHJ1Y3Qgdmxhbl9ncm91cCAgICAgICAgICAgICAgKnZsYW5fZ3JwOworCisJc3RydWN0IHZteG5ldDNfaW50ciAgICAgICAgICAgICBpbnRyOworCisJc3RydWN0IFZteG5ldDNfRHJpdmVyU2hhcmVkICAgICpzaGFyZWQ7CisJc3RydWN0IFZteG5ldDNfUE1Db25mICAgICAgICAgICpwbV9jb25mOworCXN0cnVjdCBWbXhuZXQzX1R4UXVldWVEZXNjICAgICAqdHFkX3N0YXJ0OyAgICAgLyogZmlyc3QgdHggcXVldWUgZGVzYyAqLworCXN0cnVjdCBWbXhuZXQzX1J4UXVldWVEZXNjICAgICAqcnFkX3N0YXJ0OyAgICAgLyogZmlyc3QgcnggcXVldWUgZGVzYyAqLworCXN0cnVjdCBuZXRfZGV2aWNlICAgICAgICAgICAgICAqbmV0ZGV2OworCXN0cnVjdCBwY2lfZGV2ICAgICAgICAgICAgICAgICAqcGRldjsKKworCXU4CQkJCSpod19hZGRyMDsgLyogZm9yIEJBUiAwICovCisJdTgJCQkJKmh3X2FkZHIxOyAvKiBmb3IgQkFSIDEgKi8KKworCS8qIGZlYXR1cmUgY29udHJvbCAqLworCWJvb2wJCQkJcnhjc3VtOworCWJvb2wJCQkJbHJvOworCWJvb2wJCQkJanVtYm9fZnJhbWU7CisKKwkvKiByeCBidWZmZXIgcmVsYXRlZCAqLworCXVuc2lnbmVkCQkJc2tiX2J1Zl9zaXplOworCWludAkJcnhfYnVmX3Blcl9wa3Q7ICAvKiBvbmx5IGFwcGx5IHRvIHRoZSAxc3QgcmluZyAqLworCWRtYV9hZGRyX3QJCQlzaGFyZWRfcGE7CisJZG1hX2FkZHJfdCBxdWV1ZV9kZXNjX3BhOworCisJLyogV2FrZS1vbi1MQU4gKi8KKwl1MzIgICAgIHdvbDsKKworCS8qIExpbmsgc3BlZWQgKi8KKwl1MzIgICAgIGxpbmtfc3BlZWQ7IC8qIGluIG1icHMgKi8KKworCXU2NCAgICAgdHhfdGltZW91dF9jb3VudDsKKwlzdHJ1Y3Qgd29ya19zdHJ1Y3Qgd29yazsKKworCXVuc2lnbmVkIGxvbmcgIHN0YXRlOyAgICAvKiBWTVhORVQzX1NUQVRFX0JJVF94eHggKi8KKworCWludCBkZXZfbnVtYmVyOworfTsKKworI2RlZmluZSBWTVhORVQzX1dSSVRFX0JBUjBfUkVHKGFkYXB0ZXIsIHJlZywgdmFsKSAgXAorCXdyaXRlbCgodmFsKSwgKGFkYXB0ZXIpLT5od19hZGRyMCArIChyZWcpKQorI2RlZmluZSBWTVhORVQzX1JFQURfQkFSMF9SRUcoYWRhcHRlciwgcmVnKSAgICAgICAgXAorCXJlYWRsKChhZGFwdGVyKS0+aHdfYWRkcjAgKyAocmVnKSkKKworI2RlZmluZSBWTVhORVQzX1dSSVRFX0JBUjFfUkVHKGFkYXB0ZXIsIHJlZywgdmFsKSAgXAorCXdyaXRlbCgodmFsKSwgKGFkYXB0ZXIpLT5od19hZGRyMSArIChyZWcpKQorI2RlZmluZSBWTVhORVQzX1JFQURfQkFSMV9SRUcoYWRhcHRlciwgcmVnKSAgICAgICAgXAorCXJlYWRsKChhZGFwdGVyKS0+aHdfYWRkcjEgKyAocmVnKSkKKworI2RlZmluZSBWTVhORVQzX1dBS0VfUVVFVUVfVEhSRVNIT0xEKHRxKSAgKDUpCisjZGVmaW5lIFZNWE5FVDNfUlhfQUxMT0NfVEhSRVNIT0xEKHJxLCByaW5nX2lkeCwgYWRhcHRlcikgXAorCSgocnEpLT5yeF9yaW5nW3JpbmdfaWR4XS5zaXplID4+IDMpCisKKyNkZWZpbmUgVk1YTkVUM19HRVRfQUREUl9MTyhkbWEpICAgKCh1MzIpKGRtYSkpCisjZGVmaW5lIFZNWE5FVDNfR0VUX0FERFJfSEkoZG1hKSAgICgodTMyKSgoKHU2NCkoZG1hKSkgPj4gMzIpKQorCisvKiBtdXN0IGJlIGEgbXVsdGlwbGUgb2YgVk1YTkVUM19SSU5HX1NJWkVfQUxJR04gKi8KKyNkZWZpbmUgVk1YTkVUM19ERUZfVFhfUklOR19TSVpFICAgIDUxMgorI2RlZmluZSBWTVhORVQzX0RFRl9SWF9SSU5HX1NJWkUgICAgMjU2CisKKyNkZWZpbmUgVk1YTkVUM19NQVhfRVRIX0hEUl9TSVpFICAgIDIyCisjZGVmaW5lIFZNWE5FVDNfTUFYX1NLQl9CVUZfU0laRSAgICAoMyoxMDI0KQorCitpbnQKK3ZteG5ldDNfcXVpZXNjZV9kZXYoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcik7CisKK2ludAordm14bmV0M19hY3RpdmF0ZV9kZXYoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcik7CisKK3ZvaWQKK3ZteG5ldDNfZm9yY2VfY2xvc2Uoc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcik7CisKK3ZvaWQKK3ZteG5ldDNfcmVzZXRfZGV2KHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIpOworCit2b2lkCit2bXhuZXQzX3RxX2Rlc3Ryb3koc3RydWN0IHZteG5ldDNfdHhfcXVldWUgKnRxLAorCQkgICBzdHJ1Y3Qgdm14bmV0M19hZGFwdGVyICphZGFwdGVyKTsKKwordm9pZAordm14bmV0M19ycV9kZXN0cm95KHN0cnVjdCB2bXhuZXQzX3J4X3F1ZXVlICpycSwKKwkJICAgc3RydWN0IHZteG5ldDNfYWRhcHRlciAqYWRhcHRlcik7CisKK2ludAordm14bmV0M19jcmVhdGVfcXVldWVzKHN0cnVjdCB2bXhuZXQzX2FkYXB0ZXIgKmFkYXB0ZXIsCisJCSAgICAgIHUzMiB0eF9yaW5nX3NpemUsIHUzMiByeF9yaW5nX3NpemUsIHUzMiByeF9yaW5nMl9zaXplKTsKKworZXh0ZXJuIHZvaWQgdm14bmV0M19zZXRfZXRodG9vbF9vcHMoc3RydWN0IG5ldF9kZXZpY2UgKm5ldGRldik7CitleHRlcm4gc3RydWN0IG5ldF9kZXZpY2Vfc3RhdHMgKnZteG5ldDNfZ2V0X3N0YXRzKHN0cnVjdCBuZXRfZGV2aWNlICpuZXRkZXYpOworCitleHRlcm4gY2hhciB2bXhuZXQzX2RyaXZlcl9uYW1lW107CisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dhbi9jMTAxLmMgYi9kcml2ZXJzL25ldC93YW4vYzEwMS5jCmluZGV4IDk2OTNiMGYuLjBiZDg5OGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dhbi9jMTAxLmMKKysrIGIvZHJpdmVycy9uZXQvd2FuL2MxMDEuYwpAQCAtMTYsNiArMTYsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvY2FwYWJpbGl0eS5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2FuL2Nvc2EuYyBiL2RyaXZlcnMvbmV0L3dhbi9jb3NhLmMKaW5kZXggNjYzNjBhMi4uZTJjMzNjMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL2Nvc2EuYworKysgYi9kcml2ZXJzL25ldC93YW4vY29zYS5jCkBAIC03Niw2ICs3Niw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9wb2xsLmg+CiAjaW5jbHVkZSA8bGludXgvZnMuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dhbi9jeWN4X3gyNS5jIGIvZHJpdmVycy9uZXQvd2FuL2N5Y3hfeDI1LmMKaW5kZXggMjU3M2MxOC4uY2Q4Y2I5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL2N5Y3hfeDI1LmMKKysrIGIvZHJpdmVycy9uZXQvd2FuL2N5Y3hfeDI1LmMKQEAgLTg0LDYgKzg0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4JLyogcHJpbnRrKCksIGFuZCBvdGhlciB1c2VmdWwgc3R1ZmYgKi8KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4JLyogaW5saW5lIG1lbXNldCgpLCBldGMuICovCisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CQkvKiBrbWFsbG9jKCksIGtmcmVlKCkgKi8KICNpbmNsdWRlIDxsaW51eC9zdGRkZWYuaD4JLyogb2Zmc2V0b2YoKSwgZXRjLiAqLwogI2luY2x1ZGUgPGxpbnV4L3dhbnJvdXRlci5oPgkvKiBXQU4gcm91dGVyIGRlZmluaXRpb25zICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93YW4vZHNjYzQuYyBiL2RyaXZlcnMvbmV0L3dhbi9kc2NjNC5jCmluZGV4IDgxYzhhZWMuLjA3ZDAwYjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dhbi9kc2NjNC5jCisrKyBiL2RyaXZlcnMvbmV0L3dhbi9kc2NjNC5jCkBAIC04MSw2ICs4MSw3IEBACiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgogI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dhbi9mYXJzeW5jLmMgYi9kcml2ZXJzL25ldC93YW4vZmFyc3luYy5jCmluZGV4IDNlOTBlYjguLmJlZGEzODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dhbi9mYXJzeW5jLmMKKysrIGIvZHJpdmVycy9uZXQvd2FuL2ZhcnN5bmMuYwpAQCAtMTksNiArMTksNyBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L3ZlcnNpb24uaD4KICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9pZi5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2FuL2hkbGNfY2lzY28uYyBiL2RyaXZlcnMvbmV0L3dhbi9oZGxjX2Npc2NvLmMKaW5kZXggY2Y1ZmQxNy4uZjFiZmY5OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL2hkbGNfY2lzY28uYworKysgYi9kcml2ZXJzL25ldC93YW4vaGRsY19jaXNjby5jCkBAIC01OCw4ICs1OCw3IEBACiAJc3BpbmxvY2tfdCBsb2NrOwogCXVuc2lnbmVkIGxvbmcgbGFzdF9wb2xsOwogCWludCB1cDsKLQlpbnQgcmVxdWVzdF9zZW50OwotCXUzMiB0eHNlcTsgLyogVFggc2VxdWVuY2UgbnVtYmVyICovCisJdTMyIHR4c2VxOyAvKiBUWCBzZXF1ZW5jZSBudW1iZXIsIDAgPSBub25lICovCiAJdTMyIHJ4c2VxOyAvKiBSWCBzZXF1ZW5jZSBudW1iZXIgKi8KIH07CiAKQEAgLTE2Myw2ICsxNjIsNyBAQAogCXN0cnVjdCBjaXNjb19wYWNrZXQgKmNpc2NvX2RhdGE7CiAJc3RydWN0IGluX2RldmljZSAqaW5fZGV2OwogCV9fYmUzMiBhZGRyLCBtYXNrOworCXUzMiBhY2s7CiAKIAlpZiAoc2tiLT5sZW4gPCBzaXplb2Yoc3RydWN0IGhkbGNfaGVhZGVyKSkKIAkJZ290byByeF9lcnJvcjsKQEAgLTIyMyw4ICsyMjMsMTAgQEAKIAkJY2FzZSBDSVNDT19LRUVQQUxJVkVfUkVROgogCQkJc3Bpbl9sb2NrKCZzdC0+bG9jayk7CiAJCQlzdC0+cnhzZXEgPSBudG9obChjaXNjb19kYXRhLT5wYXIxKTsKLQkJCWlmIChzdC0+cmVxdWVzdF9zZW50ICYmCi0JCQkgICAgbnRvaGwoY2lzY29fZGF0YS0+cGFyMikgPT0gc3QtPnR4c2VxKSB7CisJCQlhY2sgPSBudG9obChjaXNjb19kYXRhLT5wYXIyKTsKKwkJCWlmIChhY2sgJiYgKGFjayA9PSBzdC0+dHhzZXEgfHwKKwkJCQkgICAgLyogb3VyIGN1cnJlbnQgUkVRIG1heSBiZSBpbiB0cmFuc2l0ICovCisJCQkJICAgIGFjayA9PSBzdC0+dHhzZXEgLSAxKSkgewogCQkJCXN0LT5sYXN0X3BvbGwgPSBqaWZmaWVzOwogCQkJCWlmICghc3QtPnVwKSB7CiAJCQkJCXUzMiBzZWMsIG1pbiwgaHJzLCBkYXlzOwpAQCAtMjc1LDcgKzI3Nyw2IEBACiAKIAljaXNjb19rZWVwYWxpdmVfc2VuZChkZXYsIENJU0NPX0tFRVBBTElWRV9SRVEsIGh0b25sKCsrc3QtPnR4c2VxKSwKIAkJCSAgICAgaHRvbmwoc3QtPnJ4c2VxKSk7Ci0Jc3QtPnJlcXVlc3Rfc2VudCA9IDE7CiAJc3Bpbl91bmxvY2soJnN0LT5sb2NrKTsKIAogCXN0LT50aW1lci5leHBpcmVzID0gamlmZmllcyArIHN0LT5zZXR0aW5ncy5pbnRlcnZhbCAqIEhaOwpAQCAtMjkzLDkgKzI5NCw3IEBACiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZzdC0+bG9jaywgZmxhZ3MpOwotCXN0LT51cCA9IDA7Ci0Jc3QtPnJlcXVlc3Rfc2VudCA9IDA7Ci0Jc3QtPnR4c2VxID0gc3QtPnJ4c2VxID0gMDsKKwlzdC0+dXAgPSBzdC0+dHhzZXEgPSBzdC0+cnhzZXEgPSAwOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0LT5sb2NrLCBmbGFncyk7CiAKIAlpbml0X3RpbWVyKCZzdC0+dGltZXIpOwpAQCAtMzE3LDggKzMxNiw3IEBACiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmc3QtPmxvY2ssIGZsYWdzKTsKIAluZXRpZl9kb3JtYW50X29uKGRldik7Ci0Jc3QtPnVwID0gMDsKLQlzdC0+cmVxdWVzdF9zZW50ID0gMDsKKwlzdC0+dXAgPSBzdC0+dHhzZXEgPSAwOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0LT5sb2NrLCBmbGFncyk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dhbi9uMi5jIGIvZHJpdmVycy9uZXQvd2FuL24yLmMKaW5kZXggODNkYTU5Ni4uNThjNjY4MSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2FuL24yLmMKKysrIGIvZHJpdmVycy9uZXQvd2FuL24yLmMKQEAgLTE4LDYgKzE4LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9mY250bC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2FuL3BjaTIwMHN5bi5jIGIvZHJpdmVycy9uZXQvd2FuL3BjaTIwMHN5bi5jCmluZGV4IGE1MmYyOWMuLmYxMzQwZmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dhbi9wY2kyMDBzeW4uYworKysgYi9kcml2ZXJzL25ldC93YW4vcGNpMjAwc3luLmMKQEAgLTE2LDYgKzE2LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KICNpbmNsdWRlIDxsaW51eC9mY250bC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWRtODIxMS5oIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYWRtODIxMS5oCmluZGV4IDRmNmFiMTMuLmIwN2U0ZDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2FkbTgyMTEuaAorKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9hZG04MjExLmgKQEAgLTI2Niw3ICsyNjYsNyBAQAogI2RlZmluZSBBRE04MjExX1NZTkNUTF9DUzEJKDEgPDwgMjgpCiAjZGVmaW5lIEFETTgyMTFfU1lOQ1RMX0NBTAkoMSA8PCAyNykKICNkZWZpbmUgQURNODIxMV9TWU5DVExfU0VMQ0FMCSgxIDw8IDI2KQotI2RlZmluZSBBRE04MjExX1NZTkNUTF9SRnR5cGUJKCgxIDw8IDI0KSB8fCAoMSA8PCAyMykgfHwgKDEgPDwgMjIpKQorI2RlZmluZSBBRE04MjExX1NZTkNUTF9SRnR5cGUJKCgxIDw8IDI0KSB8ICgxIDw8IDIzKSB8ICgxIDw8IDIyKSkKICNkZWZpbmUgQURNODIxMV9TWU5DVExfUkZNRAkoMSA8PCAyMikKICNkZWZpbmUgQURNODIxMV9TWU5DVExfR0VORVJBTAkoMHg3IDw8IDIyKQogLyogU1lOQ1RMIDIxOjAgRGF0YSAoU2k0MTI2OiAxOC1iaXQgZGF0YSwgNC1iaXQgYWRkcmVzcykgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9iNDMuaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9iNDMuaAppbmRleCBmYTE1NDlhLi42NjA3MTYyIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvYjQzLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2I0My5oCkBAIC02MDcsODIgKzYwNyw3IEBACiAJc3RydWN0IGllZWU4MDIxMV90eF9xdWV1ZV9wYXJhbXMgcDsKIH07CiAKLXN0cnVjdCBiNDNfd2xkZXY7Ci0KLS8qIERhdGEgc3RydWN0dXJlIGZvciB0aGUgV0xBTiBwYXJ0cyAoODAyLjExIGNvcmVzKSBvZiB0aGUgYjQzIGNoaXAuICovCi1zdHJ1Y3QgYjQzX3dsIHsKLQkvKiBQb2ludGVyIHRvIHRoZSBhY3RpdmUgd2lyZWxlc3MgZGV2aWNlIG9uIHRoaXMgY2hpcCAqLwotCXN0cnVjdCBiNDNfd2xkZXYgKmN1cnJlbnRfZGV2OwotCS8qIFBvaW50ZXIgdG8gdGhlIGllZWU4MDIxMSBoYXJkd2FyZSBkYXRhIHN0cnVjdHVyZSAqLwotCXN0cnVjdCBpZWVlODAyMTFfaHcgKmh3OwotCi0JLyogR2xvYmFsIGRyaXZlciBtdXRleC4gRXZlcnkgb3BlcmF0aW9uIG11c3QgcnVuIHdpdGggdGhpcyBtdXRleCBsb2NrZWQuICovCi0Jc3RydWN0IG11dGV4IG11dGV4OwotCS8qIEhhcmQtSVJRIHNwaW5sb2NrLiBUaGlzIGxvY2sgcHJvdGVjdHMgdGhpbmdzIHVzZWQgaW4gdGhlIGhhcmQtSVJRCi0JICogaGFuZGxlciwgb25seS4gVGhpcyBiYXNpY2FsbHkgaXMganVzdCB0aGUgSVJRIG1hc2sgcmVnaXN0ZXIuICovCi0Jc3BpbmxvY2tfdCBoYXJkaXJxX2xvY2s7Ci0KLQkvKiBUaGUgbnVtYmVyIG9mIHF1ZXVlcyB0aGF0IHdlcmUgcmVnaXN0ZXJlZCB3aXRoIHRoZSBtYWM4MDIxMSBzdWJzeXN0ZW0KLQkgKiBpbml0aWFsbHkuIFRoaXMgaXMgYSBiYWNrdXAgY29weSBvZiBody0+cXVldWVzIGluIGNhc2UgaHctPnF1ZXVlcyBoYXMKLQkgKiB0byBiZSBkeW5hbWljYWxseSBsb3dlcmVkIGF0IHJ1bnRpbWUgKEZpcm13YXJlIGRvZXMgbm90IHN1cHBvcnQgUW9TKS4KLQkgKiBody0+cXVldWVzIGhhcyB0byBiZSByZXN0b3JlZCB0byB0aGUgb3JpZ2luYWwgdmFsdWUgYmVmb3JlIHVucmVnaXN0ZXJpbmcKLQkgKiBmcm9tIHRoZSBtYWM4MDIxMSBzdWJzeXN0ZW0uICovCi0JdTE2IG1hYzgwMjExX2luaXRpYWxseV9yZWdpc3RlcmVkX3F1ZXVlczsKLQotCS8qIFdlIGNhbiBvbmx5IGhhdmUgb25lIG9wZXJhdGluZyBpbnRlcmZhY2UgKDgwMi4xMSBjb3JlKQotCSAqIGF0IGEgdGltZS4gR2VuZXJhbCBpbmZvcm1hdGlvbiBhYm91dCB0aGlzIGludGVyZmFjZSBmb2xsb3dzLgotCSAqLwotCi0Jc3RydWN0IGllZWU4MDIxMV92aWYgKnZpZjsKLQkvKiBUaGUgTUFDIGFkZHJlc3Mgb2YgdGhlIG9wZXJhdGluZyBpbnRlcmZhY2UuICovCi0JdTggbWFjX2FkZHJbRVRIX0FMRU5dOwotCS8qIEN1cnJlbnQgQlNTSUQgKi8KLQl1OCBic3NpZFtFVEhfQUxFTl07Ci0JLyogSW50ZXJmYWNlIHR5cGUuIChOTDgwMjExX0lGVFlQRV9YWFgpICovCi0JaW50IGlmX3R5cGU7Ci0JLyogSXMgdGhlIGNhcmQgb3BlcmF0aW5nIGluIEFQLCBTVEEgb3IgSUJTUyBtb2RlPyAqLwotCWJvb2wgb3BlcmF0aW5nOwotCS8qIGZpbHRlciBmbGFncyAqLwotCXVuc2lnbmVkIGludCBmaWx0ZXJfZmxhZ3M7Ci0JLyogU3RhdHMgYWJvdXQgdGhlIHdpcmVsZXNzIGludGVyZmFjZSAqLwotCXN0cnVjdCBpZWVlODAyMTFfbG93X2xldmVsX3N0YXRzIGllZWVfc3RhdHM7Ci0KLSNpZmRlZiBDT05GSUdfQjQzX0hXUk5HCi0Jc3RydWN0IGh3cm5nIHJuZzsKLQlib29sIHJuZ19pbml0aWFsaXplZDsKLQljaGFyIHJuZ19uYW1lWzMwICsgMV07Ci0jZW5kaWYgLyogQ09ORklHX0I0M19IV1JORyAqLwotCi0JLyogTGlzdCBvZiBhbGwgd2lyZWxlc3MgZGV2aWNlcyBvbiB0aGlzIGNoaXAgKi8KLQlzdHJ1Y3QgbGlzdF9oZWFkIGRldmxpc3Q7Ci0JdTggbnJfZGV2czsKLQotCWJvb2wgcmFkaW90YXBfZW5hYmxlZDsKLQlib29sIHJhZGlvX2VuYWJsZWQ7Ci0KLQkvKiBUaGUgYmVhY29uIHdlIGFyZSBjdXJyZW50bHkgdXNpbmcgKEFQIG9yIElCU1MgbW9kZSkuICovCi0Jc3RydWN0IHNrX2J1ZmYgKmN1cnJlbnRfYmVhY29uOwotCWJvb2wgYmVhY29uMF91cGxvYWRlZDsKLQlib29sIGJlYWNvbjFfdXBsb2FkZWQ7Ci0JYm9vbCBiZWFjb25fdGVtcGxhdGVzX3ZpcmdpbjsgLyogTmV2ZXIgd3JvdGUgdGhlIHRlbXBsYXRlcz8gKi8KLQlzdHJ1Y3Qgd29ya19zdHJ1Y3QgYmVhY29uX3VwZGF0ZV90cmlnZ2VyOwotCi0JLyogVGhlIGN1cnJlbnQgUU9TIHBhcmFtZXRlcnMgZm9yIHRoZSA0IHF1ZXVlcy4gKi8KLQlzdHJ1Y3QgYjQzX3Fvc19wYXJhbXMgcW9zX3BhcmFtc1s0XTsKLQotCS8qIFdvcmsgZm9yIGFkanVzdG1lbnQgb2YgdGhlIHRyYW5zbWlzc2lvbiBwb3dlci4KLQkgKiBUaGlzIGlzIHNjaGVkdWxlZCB3aGVuIHdlIGRldGVybWluZSB0aGF0IHRoZSBhY3R1YWwgVFggb3V0cHV0Ci0JICogcG93ZXIgZG9lc24ndCBtYXRjaCB3aGF0IHdlIHdhbnQuICovCi0Jc3RydWN0IHdvcmtfc3RydWN0IHR4cG93ZXJfYWRqdXN0X3dvcms7Ci0KLQkvKiBQYWNrZXQgdHJhbnNtaXQgd29yayAqLwotCXN0cnVjdCB3b3JrX3N0cnVjdCB0eF93b3JrOwotCS8qIFF1ZXVlIG9mIHBhY2tldHMgdG8gYmUgdHJhbnNtaXR0ZWQuICovCi0Jc3RydWN0IHNrX2J1ZmZfaGVhZCB0eF9xdWV1ZTsKLQotCS8qIFRoZSBkZXZpY2UgTEVEcy4gKi8KLQlzdHJ1Y3QgYjQzX2xlZHMgbGVkczsKLX07CitzdHJ1Y3QgYjQzX3dsOwogCiAvKiBUaGUgdHlwZSBvZiB0aGUgZmlybXdhcmUgZmlsZS4gKi8KIGVudW0gYjQzX2Zpcm13YXJlX2ZpbGVfdHlwZSB7CkBAIC04MjQsNiArNzQ5LDk3IEBACiAjZW5kaWYKIH07CiAKKy8qCisgKiBJbmNsdWRlIGdvZXMgaGVyZSB0byBhdm9pZCBhIGRlcGVuZGVuY3kgcHJvYmxlbS4KKyAqIEEgYmV0dGVyIGZpeCB3b3VsZCBiZSB0byBpbnRlZ3JhdGUgeG1pdC5oIGludG8gYjQzLmguCisgKi8KKyNpbmNsdWRlICJ4bWl0LmgiCisKKy8qIERhdGEgc3RydWN0dXJlIGZvciB0aGUgV0xBTiBwYXJ0cyAoODAyLjExIGNvcmVzKSBvZiB0aGUgYjQzIGNoaXAuICovCitzdHJ1Y3QgYjQzX3dsIHsKKwkvKiBQb2ludGVyIHRvIHRoZSBhY3RpdmUgd2lyZWxlc3MgZGV2aWNlIG9uIHRoaXMgY2hpcCAqLworCXN0cnVjdCBiNDNfd2xkZXYgKmN1cnJlbnRfZGV2OworCS8qIFBvaW50ZXIgdG8gdGhlIGllZWU4MDIxMSBoYXJkd2FyZSBkYXRhIHN0cnVjdHVyZSAqLworCXN0cnVjdCBpZWVlODAyMTFfaHcgKmh3OworCisJLyogR2xvYmFsIGRyaXZlciBtdXRleC4gRXZlcnkgb3BlcmF0aW9uIG11c3QgcnVuIHdpdGggdGhpcyBtdXRleCBsb2NrZWQuICovCisJc3RydWN0IG11dGV4IG11dGV4OworCS8qIEhhcmQtSVJRIHNwaW5sb2NrLiBUaGlzIGxvY2sgcHJvdGVjdHMgdGhpbmdzIHVzZWQgaW4gdGhlIGhhcmQtSVJRCisJICogaGFuZGxlciwgb25seS4gVGhpcyBiYXNpY2FsbHkgaXMganVzdCB0aGUgSVJRIG1hc2sgcmVnaXN0ZXIuICovCisJc3BpbmxvY2tfdCBoYXJkaXJxX2xvY2s7CisKKwkvKiBUaGUgbnVtYmVyIG9mIHF1ZXVlcyB0aGF0IHdlcmUgcmVnaXN0ZXJlZCB3aXRoIHRoZSBtYWM4MDIxMSBzdWJzeXN0ZW0KKwkgKiBpbml0aWFsbHkuIFRoaXMgaXMgYSBiYWNrdXAgY29weSBvZiBody0+cXVldWVzIGluIGNhc2UgaHctPnF1ZXVlcyBoYXMKKwkgKiB0byBiZSBkeW5hbWljYWxseSBsb3dlcmVkIGF0IHJ1bnRpbWUgKEZpcm13YXJlIGRvZXMgbm90IHN1cHBvcnQgUW9TKS4KKwkgKiBody0+cXVldWVzIGhhcyB0byBiZSByZXN0b3JlZCB0byB0aGUgb3JpZ2luYWwgdmFsdWUgYmVmb3JlIHVucmVnaXN0ZXJpbmcKKwkgKiBmcm9tIHRoZSBtYWM4MDIxMSBzdWJzeXN0ZW0uICovCisJdTE2IG1hYzgwMjExX2luaXRpYWxseV9yZWdpc3RlcmVkX3F1ZXVlczsKKworCS8qIFdlIGNhbiBvbmx5IGhhdmUgb25lIG9wZXJhdGluZyBpbnRlcmZhY2UgKDgwMi4xMSBjb3JlKQorCSAqIGF0IGEgdGltZS4gR2VuZXJhbCBpbmZvcm1hdGlvbiBhYm91dCB0aGlzIGludGVyZmFjZSBmb2xsb3dzLgorCSAqLworCisJc3RydWN0IGllZWU4MDIxMV92aWYgKnZpZjsKKwkvKiBUaGUgTUFDIGFkZHJlc3Mgb2YgdGhlIG9wZXJhdGluZyBpbnRlcmZhY2UuICovCisJdTggbWFjX2FkZHJbRVRIX0FMRU5dOworCS8qIEN1cnJlbnQgQlNTSUQgKi8KKwl1OCBic3NpZFtFVEhfQUxFTl07CisJLyogSW50ZXJmYWNlIHR5cGUuIChOTDgwMjExX0lGVFlQRV9YWFgpICovCisJaW50IGlmX3R5cGU7CisJLyogSXMgdGhlIGNhcmQgb3BlcmF0aW5nIGluIEFQLCBTVEEgb3IgSUJTUyBtb2RlPyAqLworCWJvb2wgb3BlcmF0aW5nOworCS8qIGZpbHRlciBmbGFncyAqLworCXVuc2lnbmVkIGludCBmaWx0ZXJfZmxhZ3M7CisJLyogU3RhdHMgYWJvdXQgdGhlIHdpcmVsZXNzIGludGVyZmFjZSAqLworCXN0cnVjdCBpZWVlODAyMTFfbG93X2xldmVsX3N0YXRzIGllZWVfc3RhdHM7CisKKyNpZmRlZiBDT05GSUdfQjQzX0hXUk5HCisJc3RydWN0IGh3cm5nIHJuZzsKKwlib29sIHJuZ19pbml0aWFsaXplZDsKKwljaGFyIHJuZ19uYW1lWzMwICsgMV07CisjZW5kaWYgLyogQ09ORklHX0I0M19IV1JORyAqLworCisJLyogTGlzdCBvZiBhbGwgd2lyZWxlc3MgZGV2aWNlcyBvbiB0aGlzIGNoaXAgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIGRldmxpc3Q7CisJdTggbnJfZGV2czsKKworCWJvb2wgcmFkaW90YXBfZW5hYmxlZDsKKwlib29sIHJhZGlvX2VuYWJsZWQ7CisKKwkvKiBUaGUgYmVhY29uIHdlIGFyZSBjdXJyZW50bHkgdXNpbmcgKEFQIG9yIElCU1MgbW9kZSkuICovCisJc3RydWN0IHNrX2J1ZmYgKmN1cnJlbnRfYmVhY29uOworCWJvb2wgYmVhY29uMF91cGxvYWRlZDsKKwlib29sIGJlYWNvbjFfdXBsb2FkZWQ7CisJYm9vbCBiZWFjb25fdGVtcGxhdGVzX3ZpcmdpbjsgLyogTmV2ZXIgd3JvdGUgdGhlIHRlbXBsYXRlcz8gKi8KKwlzdHJ1Y3Qgd29ya19zdHJ1Y3QgYmVhY29uX3VwZGF0ZV90cmlnZ2VyOworCisJLyogVGhlIGN1cnJlbnQgUU9TIHBhcmFtZXRlcnMgZm9yIHRoZSA0IHF1ZXVlcy4gKi8KKwlzdHJ1Y3QgYjQzX3Fvc19wYXJhbXMgcW9zX3BhcmFtc1s0XTsKKworCS8qIFdvcmsgZm9yIGFkanVzdG1lbnQgb2YgdGhlIHRyYW5zbWlzc2lvbiBwb3dlci4KKwkgKiBUaGlzIGlzIHNjaGVkdWxlZCB3aGVuIHdlIGRldGVybWluZSB0aGF0IHRoZSBhY3R1YWwgVFggb3V0cHV0CisJICogcG93ZXIgZG9lc24ndCBtYXRjaCB3aGF0IHdlIHdhbnQuICovCisJc3RydWN0IHdvcmtfc3RydWN0IHR4cG93ZXJfYWRqdXN0X3dvcms7CisKKwkvKiBQYWNrZXQgdHJhbnNtaXQgd29yayAqLworCXN0cnVjdCB3b3JrX3N0cnVjdCB0eF93b3JrOworCS8qIFF1ZXVlIG9mIHBhY2tldHMgdG8gYmUgdHJhbnNtaXR0ZWQuICovCisJc3RydWN0IHNrX2J1ZmZfaGVhZCB0eF9xdWV1ZTsKKworCS8qIFRoZSBkZXZpY2UgTEVEcy4gKi8KKwlzdHJ1Y3QgYjQzX2xlZHMgbGVkczsKKworI2lmZGVmIENPTkZJR19CNDNfUElPCisJLyoKKwkgKiBSWC9UWCBoZWFkZXIvdGFpbCBidWZmZXJzIHVzZWQgYnkgdGhlIGZyYW1lIHRyYW5zbWl0IGZ1bmN0aW9ucy4KKwkgKi8KKwlzdHJ1Y3QgYjQzX3J4aGRyX2Z3NCByeGhkcjsKKwlzdHJ1Y3QgYjQzX3R4aGRyIHR4aGRyOworCXU4IHJ4X3RhaWxbNF07CisJdTggdHhfdGFpbFs0XTsKKyNlbmRpZiAvKiBDT05GSUdfQjQzX1BJTyAqLworfTsKKwogc3RhdGljIGlubGluZSBzdHJ1Y3QgYjQzX3dsICpod190b19iNDNfd2woc3RydWN0IGllZWU4MDIxMV9odyAqaHcpCiB7CiAJcmV0dXJuIGh3LT5wcml2OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2xlZHMuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9sZWRzLmMKaW5kZXggZmJlM2Q0Zi4uMWU4ZGJhNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2xlZHMuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvbGVkcy5jCkBAIC0zNDgsOSArMzQ4LDkgQEAKIAl9CiB9CiAKLXZvaWQgYjQzX2xlZHNfdW5yZWdpc3RlcihzdHJ1Y3QgYjQzX3dsZGV2ICpkZXYpCit2b2lkIGI0M19sZWRzX3VucmVnaXN0ZXIoc3RydWN0IGI0M193bCAqd2wpCiB7Ci0Jc3RydWN0IGI0M19sZWRzICpsZWRzID0gJmRldi0+d2wtPmxlZHM7CisJc3RydWN0IGI0M19sZWRzICpsZWRzID0gJndsLT5sZWRzOwogCiAJYjQzX3VucmVnaXN0ZXJfbGVkKCZsZWRzLT5sZWRfdHgpOwogCWI0M191bnJlZ2lzdGVyX2xlZCgmbGVkcy0+bGVkX3J4KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9sZWRzLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvbGVkcy5oCmluZGV4IDk1OTJlNGMuLjRjNTYxODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9sZWRzLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL2xlZHMuaApAQCAtNjAsNyArNjAsNyBAQAogfTsKIAogdm9pZCBiNDNfbGVkc19yZWdpc3RlcihzdHJ1Y3QgYjQzX3dsZGV2ICpkZXYpOwotdm9pZCBiNDNfbGVkc191bnJlZ2lzdGVyKHN0cnVjdCBiNDNfd2xkZXYgKmRldik7Cit2b2lkIGI0M19sZWRzX3VucmVnaXN0ZXIoc3RydWN0IGI0M193bCAqd2wpOwogdm9pZCBiNDNfbGVkc19pbml0KHN0cnVjdCBiNDNfd2xkZXYgKmRldik7CiB2b2lkIGI0M19sZWRzX2V4aXQoc3RydWN0IGI0M193bGRldiAqZGV2KTsKIHZvaWQgYjQzX2xlZHNfc3RvcChzdHJ1Y3QgYjQzX3dsZGV2ICpkZXYpOwpAQCAtNzYsNyArNzYsNyBAQAogc3RhdGljIGlubGluZSB2b2lkIGI0M19sZWRzX3JlZ2lzdGVyKHN0cnVjdCBiNDNfd2xkZXYgKmRldikKIHsKIH0KLXN0YXRpYyBpbmxpbmUgdm9pZCBiNDNfbGVkc191bnJlZ2lzdGVyKHN0cnVjdCBiNDNfd2xkZXYgKmRldikKK3N0YXRpYyBpbmxpbmUgdm9pZCBiNDNfbGVkc191bnJlZ2lzdGVyKHN0cnVjdCBiNDNfd2wgKndsKQogewogfQogc3RhdGljIGlubGluZSB2b2lkIGI0M19sZWRzX2luaXQoc3RydWN0IGI0M193bGRldiAqZGV2KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL21haW4uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9tYWluLmMKaW5kZXggOWI5MDdhMy4uZGY2YjI2YSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL21haW4uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvbWFpbi5jCkBAIC0zODc0LDYgKzM4NzQsNyBAQAogewogCXN0cnVjdCBiNDNfd2wgKndsID0gZGV2LT53bDsKIAlzdHJ1Y3QgYjQzX3dsZGV2ICpvcmlnX2RldjsKKwl1MzIgbWFzazsKIAogcmVkbzoKIAlpZiAoIWRldiB8fCBiNDNfc3RhdHVzKGRldikgPCBCNDNfU1RBVF9TVEFSVEVEKQpAQCAtMzkyMCw3ICszOTIxLDggQEAKIAkJCWdvdG8gcmVkbzsKIAkJcmV0dXJuIGRldjsKIAl9Ci0JQjQzX1dBUk5fT04oYjQzX3JlYWQzMihkZXYsIEI0M19NTUlPX0dFTl9JUlFfTUFTSykpOworCW1hc2sgPSBiNDNfcmVhZDMyKGRldiwgQjQzX01NSU9fR0VOX0lSUV9NQVNLKTsKKwlCNDNfV0FSTl9PTihtYXNrICE9IDB4RkZGRkZGRkYgJiYgbWFzayk7CiAKIAkvKiBEcmFpbiB0aGUgVFggcXVldWUgKi8KIAl3aGlsZSAoc2tiX3F1ZXVlX2xlbigmd2wtPnR4X3F1ZXVlKSkKQEAgLTQ0OTksNiArNDUwMSw3IEBACiAKIAljYW5jZWxfd29ya19zeW5jKCYod2wtPmJlYWNvbl91cGRhdGVfdHJpZ2dlcikpOwogCisJd2lwaHlfcmZraWxsX3N0b3BfcG9sbGluZyhody0+d2lwaHkpOwogCW11dGV4X2xvY2soJndsLT5tdXRleCk7CiAJaWYgKGI0M19zdGF0dXMoZGV2KSA+PSBCNDNfU1RBVF9TVEFSVEVEKSB7CiAJCWRldiA9IGI0M193aXJlbGVzc19jb3JlX3N0b3AoZGV2KTsKQEAgLTQ5OTcsNyArNTAwMCw3IEBACiAKIAlpZiAobGlzdF9lbXB0eSgmd2wtPmRldmxpc3QpKSB7CiAJCWI0M19ybmdfZXhpdCh3bCk7Ci0JCWI0M19sZWRzX3VucmVnaXN0ZXIod2xkZXYpOworCQliNDNfbGVkc191bnJlZ2lzdGVyKHdsKTsKIAkJLyogTGFzdCBjb3JlIG9uIHRoZSBjaGlwIHVucmVnaXN0ZXJlZC4KIAkJICogV2UgY2FuIGRlc3Ryb3kgY29tbW9uIHN0cnVjdCBiNDNfd2wuCiAJCSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3Bpby5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3Bpby5jCmluZGV4IDljMTM5NzkuLjliOTA0NDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My9waW8uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMvcGlvLmMKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJ4bWl0LmgiCiAKICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAKIAogc3RhdGljIHUxNiBnZW5lcmF0ZV9jb29raWUoc3RydWN0IGI0M19waW9fdHhxdWV1ZSAqcSwKQEAgLTMzMSw2ICszMzIsNyBAQAogCQkJCXVuc2lnbmVkIGludCBkYXRhX2xlbikKIHsKIAlzdHJ1Y3QgYjQzX3dsZGV2ICpkZXYgPSBxLT5kZXY7CisJc3RydWN0IGI0M193bCAqd2wgPSBkZXYtPndsOwogCWNvbnN0IHU4ICpkYXRhID0gX2RhdGE7CiAKIAljdGwgfD0gQjQzX1BJT19UWENUTF9XUklURUxPIHwgQjQzX1BJT19UWENUTF9XUklURUhJOwpAQCAtMzQwLDEzICszNDIsMTIgQEAKIAkJCXEtPm1taW9fYmFzZSArIEI0M19QSU9fVFhEQVRBLAogCQkJc2l6ZW9mKHUxNikpOwogCWlmIChkYXRhX2xlbiAmIDEpIHsKLQkJdTggdGFpbFsyXSA9IHsgMCwgfTsKLQogCQkvKiBXcml0ZSB0aGUgbGFzdCBieXRlLiAqLwogCQljdGwgJj0gfkI0M19QSU9fVFhDVExfV1JJVEVISTsKIAkJYjQzX3Bpb3R4X3dyaXRlMTYocSwgQjQzX1BJT19UWENUTCwgY3RsKTsKLQkJdGFpbFswXSA9IGRhdGFbZGF0YV9sZW4gLSAxXTsKLQkJc3NiX2Jsb2NrX3dyaXRlKGRldi0+ZGV2LCB0YWlsLCAyLAorCQl3bC0+dHhfdGFpbFswXSA9IGRhdGFbZGF0YV9sZW4gLSAxXTsKKwkJd2wtPnR4X3RhaWxbMV0gPSAwOworCQlzc2JfYmxvY2tfd3JpdGUoZGV2LT5kZXYsIHdsLT50eF90YWlsLCAyLAogCQkJCXEtPm1taW9fYmFzZSArIEI0M19QSU9fVFhEQVRBLAogCQkJCXNpemVvZih1MTYpKTsKIAl9CkBAIC0zODEsNiArMzgyLDcgQEAKIAkJCQl1bnNpZ25lZCBpbnQgZGF0YV9sZW4pCiB7CiAJc3RydWN0IGI0M193bGRldiAqZGV2ID0gcS0+ZGV2OworCXN0cnVjdCBiNDNfd2wgKndsID0gZGV2LT53bDsKIAljb25zdCB1OCAqZGF0YSA9IF9kYXRhOwogCiAJY3RsIHw9IEI0M19QSU84X1RYQ1RMXzBfNyB8IEI0M19QSU84X1RYQ1RMXzhfMTUgfApAQCAtMzkxLDI5ICszOTMsMzEgQEAKIAkJCXEtPm1taW9fYmFzZSArIEI0M19QSU84X1RYREFUQSwKIAkJCXNpemVvZih1MzIpKTsKIAlpZiAoZGF0YV9sZW4gJiAzKSB7Ci0JCXU4IHRhaWxbNF0gPSB7IDAsIH07Ci0KKwkJd2wtPnR4X3RhaWxbM10gPSAwOwogCQkvKiBXcml0ZSB0aGUgbGFzdCBmZXcgYnl0ZXMuICovCiAJCWN0bCAmPSB+KEI0M19QSU84X1RYQ1RMXzhfMTUgfCBCNDNfUElPOF9UWENUTF8xNl8yMyB8CiAJCQkgQjQzX1BJTzhfVFhDVExfMjRfMzEpOwogCQlzd2l0Y2ggKGRhdGFfbGVuICYgMykgewogCQljYXNlIDM6CiAJCQljdGwgfD0gQjQzX1BJTzhfVFhDVExfMTZfMjMgfCBCNDNfUElPOF9UWENUTF84XzE1OwotCQkJdGFpbFswXSA9IGRhdGFbZGF0YV9sZW4gLSAzXTsKLQkJCXRhaWxbMV0gPSBkYXRhW2RhdGFfbGVuIC0gMl07Ci0JCQl0YWlsWzJdID0gZGF0YVtkYXRhX2xlbiAtIDFdOworCQkJd2wtPnR4X3RhaWxbMF0gPSBkYXRhW2RhdGFfbGVuIC0gM107CisJCQl3bC0+dHhfdGFpbFsxXSA9IGRhdGFbZGF0YV9sZW4gLSAyXTsKKwkJCXdsLT50eF90YWlsWzJdID0gZGF0YVtkYXRhX2xlbiAtIDFdOwogCQkJYnJlYWs7CiAJCWNhc2UgMjoKIAkJCWN0bCB8PSBCNDNfUElPOF9UWENUTF84XzE1OwotCQkJdGFpbFswXSA9IGRhdGFbZGF0YV9sZW4gLSAyXTsKLQkJCXRhaWxbMV0gPSBkYXRhW2RhdGFfbGVuIC0gMV07CisJCQl3bC0+dHhfdGFpbFswXSA9IGRhdGFbZGF0YV9sZW4gLSAyXTsKKwkJCXdsLT50eF90YWlsWzFdID0gZGF0YVtkYXRhX2xlbiAtIDFdOworCQkJd2wtPnR4X3RhaWxbMl0gPSAwOwogCQkJYnJlYWs7CiAJCWNhc2UgMToKLQkJCXRhaWxbMF0gPSBkYXRhW2RhdGFfbGVuIC0gMV07CisJCQl3bC0+dHhfdGFpbFswXSA9IGRhdGFbZGF0YV9sZW4gLSAxXTsKKwkJCXdsLT50eF90YWlsWzFdID0gMDsKKwkJCXdsLT50eF90YWlsWzJdID0gMDsKIAkJCWJyZWFrOwogCQl9CiAJCWI0M19waW90eF93cml0ZTMyKHEsIEI0M19QSU84X1RYQ1RMLCBjdGwpOwotCQlzc2JfYmxvY2tfd3JpdGUoZGV2LT5kZXYsIHRhaWwsIDQsCisJCXNzYl9ibG9ja193cml0ZShkZXYtPmRldiwgd2wtPnR4X3RhaWwsIDQsCiAJCQkJcS0+bW1pb19iYXNlICsgQjQzX1BJTzhfVFhEQVRBLAogCQkJCXNpemVvZih1MzIpKTsKIAl9CkBAIC00NDUsOCArNDQ5LDkgQEAKIHN0YXRpYyBpbnQgcGlvX3R4X2ZyYW1lKHN0cnVjdCBiNDNfcGlvX3R4cXVldWUgKnEsCiAJCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQogeworCXN0cnVjdCBiNDNfd2xkZXYgKmRldiA9IHEtPmRldjsKKwlzdHJ1Y3QgYjQzX3dsICp3bCA9IGRldi0+d2w7CiAJc3RydWN0IGI0M19waW9fdHhwYWNrZXQgKnBhY2s7Ci0Jc3RydWN0IGI0M190eGhkciB0eGhkcjsKIAl1MTYgY29va2llOwogCWludCBlcnI7CiAJdW5zaWduZWQgaW50IGhkcmxlbjsKQEAgLTQ1Nyw4ICs0NjIsOCBAQAogCQkJICBzdHJ1Y3QgYjQzX3Bpb190eHBhY2tldCwgbGlzdCk7CiAKIAljb29raWUgPSBnZW5lcmF0ZV9jb29raWUocSwgcGFjayk7Ci0JaGRybGVuID0gYjQzX3R4aGRyX3NpemUocS0+ZGV2KTsKLQllcnIgPSBiNDNfZ2VuZXJhdGVfdHhoZHIocS0+ZGV2LCAodTggKikmdHhoZHIsIHNrYiwKKwloZHJsZW4gPSBiNDNfdHhoZHJfc2l6ZShkZXYpOworCWVyciA9IGI0M19nZW5lcmF0ZV90eGhkcihkZXYsICh1OCAqKSZ3bC0+dHhoZHIsIHNrYiwKIAkJCQkgaW5mbywgY29va2llKTsKIAlpZiAoZXJyKQogCQlyZXR1cm4gZXJyOwpAQCAtNDY2LDE1ICs0NzEsMTUgQEAKIAlpZiAoaW5mby0+ZmxhZ3MgJiBJRUVFODAyMTFfVFhfQ1RMX1NFTkRfQUZURVJfRFRJTSkgewogCQkvKiBUZWxsIHRoZSBmaXJtd2FyZSBhYm91dCB0aGUgY29va2llIG9mIHRoZSBsYXN0CiAJCSAqIG1jYXN0IGZyYW1lLCBzbyBpdCBjYW4gY2xlYXIgdGhlIG1vcmUtZGF0YSBiaXQgaW4gaXQuICovCi0JCWI0M19zaG1fd3JpdGUxNihxLT5kZXYsIEI0M19TSE1fU0hBUkVELAorCQliNDNfc2htX3dyaXRlMTYoZGV2LCBCNDNfU0hNX1NIQVJFRCwKIAkJCQlCNDNfU0hNX1NIX01DQVNUQ09PS0lFLCBjb29raWUpOwogCX0KIAogCXBhY2stPnNrYiA9IHNrYjsKIAlpZiAocS0+cmV2ID49IDgpCi0JCXBpb190eF9mcmFtZV80Ynl0ZV9xdWV1ZShwYWNrLCAoY29uc3QgdTggKikmdHhoZHIsIGhkcmxlbik7CisJCXBpb190eF9mcmFtZV80Ynl0ZV9xdWV1ZShwYWNrLCAoY29uc3QgdTggKikmd2wtPnR4aGRyLCBoZHJsZW4pOwogCWVsc2UKLQkJcGlvX3R4X2ZyYW1lXzJieXRlX3F1ZXVlKHBhY2ssIChjb25zdCB1OCAqKSZ0eGhkciwgaGRybGVuKTsKKwkJcGlvX3R4X2ZyYW1lXzJieXRlX3F1ZXVlKHBhY2ssIChjb25zdCB1OCAqKSZ3bC0+dHhoZHIsIGhkcmxlbik7CiAKIAkvKiBSZW1vdmUgaXQgZnJvbSB0aGUgbGlzdCBvZiBhdmFpbGFibGUgcGFja2V0IHNsb3RzLgogCSAqIEl0IHdpbGwgYmUgcHV0IGJhY2sgd2hlbiB3ZSByZWNlaXZlIHRoZSBzdGF0dXMgcmVwb3J0LiAqLwpAQCAtNjE0LDE0ICs2MTksMTQgQEAKIHN0YXRpYyBib29sIHBpb19yeF9mcmFtZShzdHJ1Y3QgYjQzX3Bpb19yeHF1ZXVlICpxKQogewogCXN0cnVjdCBiNDNfd2xkZXYgKmRldiA9IHEtPmRldjsKLQlzdHJ1Y3QgYjQzX3J4aGRyX2Z3NCByeGhkcjsKKwlzdHJ1Y3QgYjQzX3dsICp3bCA9IGRldi0+d2w7CiAJdTE2IGxlbjsKIAl1MzIgbWFjc3RhdDsKIAl1bnNpZ25lZCBpbnQgaSwgcGFkZGluZzsKIAlzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwogCWNvbnN0IGNoYXIgKmVycl9tc2cgPSBOVUxMOwogCi0JbWVtc2V0KCZyeGhkciwgMCwgc2l6ZW9mKHJ4aGRyKSk7CisJbWVtc2V0KCZ3bC0+cnhoZHIsIDAsIHNpemVvZih3bC0+cnhoZHIpKTsKIAogCS8qIENoZWNrIGlmIHdlIGhhdmUgZGF0YSBhbmQgd2FpdCBmb3IgaXQgdG8gZ2V0IHJlYWR5LiAqLwogCWlmIChxLT5yZXYgPj0gOCkgewpAQCAtNjU5LDE2ICs2NjQsMTYgQEAKIAogCS8qIEdldCB0aGUgcHJlYW1ibGUgKFJYIGhlYWRlcikgKi8KIAlpZiAocS0+cmV2ID49IDgpIHsKLQkJc3NiX2Jsb2NrX3JlYWQoZGV2LT5kZXYsICZyeGhkciwgc2l6ZW9mKHJ4aGRyKSwKKwkJc3NiX2Jsb2NrX3JlYWQoZGV2LT5kZXYsICZ3bC0+cnhoZHIsIHNpemVvZih3bC0+cnhoZHIpLAogCQkJICAgICAgIHEtPm1taW9fYmFzZSArIEI0M19QSU84X1JYREFUQSwKIAkJCSAgICAgICBzaXplb2YodTMyKSk7CiAJfSBlbHNlIHsKLQkJc3NiX2Jsb2NrX3JlYWQoZGV2LT5kZXYsICZyeGhkciwgc2l6ZW9mKHJ4aGRyKSwKKwkJc3NiX2Jsb2NrX3JlYWQoZGV2LT5kZXYsICZ3bC0+cnhoZHIsIHNpemVvZih3bC0+cnhoZHIpLAogCQkJICAgICAgIHEtPm1taW9fYmFzZSArIEI0M19QSU9fUlhEQVRBLAogCQkJICAgICAgIHNpemVvZih1MTYpKTsKIAl9CiAJLyogU2FuaXR5IGNoZWNrcy4gKi8KLQlsZW4gPSBsZTE2X3RvX2NwdShyeGhkci5mcmFtZV9sZW4pOworCWxlbiA9IGxlMTZfdG9fY3B1KHdsLT5yeGhkci5mcmFtZV9sZW4pOwogCWlmICh1bmxpa2VseShsZW4gPiAweDcwMCkpIHsKIAkJZXJyX21zZyA9ICJsZW4gPiAweDcwMCI7CiAJCWdvdG8gcnhfZXJyb3I7CkBAIC02NzgsNyArNjgzLDcgQEAKIAkJZ290byByeF9lcnJvcjsKIAl9CiAKLQltYWNzdGF0ID0gbGUzMl90b19jcHUocnhoZHIubWFjX3N0YXR1cyk7CisJbWFjc3RhdCA9IGxlMzJfdG9fY3B1KHdsLT5yeGhkci5tYWNfc3RhdHVzKTsKIAlpZiAobWFjc3RhdCAmIEI0M19SWF9NQUNfRkNTRVJSKSB7CiAJCWlmICghKHEtPmRldi0+d2wtPmZpbHRlcl9mbGFncyAmIEZJRl9GQ1NGQUlMKSkgewogCQkJLyogRHJvcCBmcmFtZXMgd2l0aCBmYWlsZWQgRkNTLiAqLwpAQCAtNzAzLDI0ICs3MDgsMjIgQEAKIAkJCSAgICAgICBxLT5tbWlvX2Jhc2UgKyBCNDNfUElPOF9SWERBVEEsCiAJCQkgICAgICAgc2l6ZW9mKHUzMikpOwogCQlpZiAobGVuICYgMykgewotCQkJdTggdGFpbFs0XSA9IHsgMCwgfTsKLQogCQkJLyogUmVhZCB0aGUgbGFzdCBmZXcgYnl0ZXMuICovCi0JCQlzc2JfYmxvY2tfcmVhZChkZXYtPmRldiwgdGFpbCwgNCwKKwkJCXNzYl9ibG9ja19yZWFkKGRldi0+ZGV2LCB3bC0+cnhfdGFpbCwgNCwKIAkJCQkgICAgICAgcS0+bW1pb19iYXNlICsgQjQzX1BJTzhfUlhEQVRBLAogCQkJCSAgICAgICBzaXplb2YodTMyKSk7CiAJCQlzd2l0Y2ggKGxlbiAmIDMpIHsKIAkJCWNhc2UgMzoKLQkJCQlza2ItPmRhdGFbbGVuICsgcGFkZGluZyAtIDNdID0gdGFpbFswXTsKLQkJCQlza2ItPmRhdGFbbGVuICsgcGFkZGluZyAtIDJdID0gdGFpbFsxXTsKLQkJCQlza2ItPmRhdGFbbGVuICsgcGFkZGluZyAtIDFdID0gdGFpbFsyXTsKKwkJCQlza2ItPmRhdGFbbGVuICsgcGFkZGluZyAtIDNdID0gd2wtPnJ4X3RhaWxbMF07CisJCQkJc2tiLT5kYXRhW2xlbiArIHBhZGRpbmcgLSAyXSA9IHdsLT5yeF90YWlsWzFdOworCQkJCXNrYi0+ZGF0YVtsZW4gKyBwYWRkaW5nIC0gMV0gPSB3bC0+cnhfdGFpbFsyXTsKIAkJCQlicmVhazsKIAkJCWNhc2UgMjoKLQkJCQlza2ItPmRhdGFbbGVuICsgcGFkZGluZyAtIDJdID0gdGFpbFswXTsKLQkJCQlza2ItPmRhdGFbbGVuICsgcGFkZGluZyAtIDFdID0gdGFpbFsxXTsKKwkJCQlza2ItPmRhdGFbbGVuICsgcGFkZGluZyAtIDJdID0gd2wtPnJ4X3RhaWxbMF07CisJCQkJc2tiLT5kYXRhW2xlbiArIHBhZGRpbmcgLSAxXSA9IHdsLT5yeF90YWlsWzFdOwogCQkJCWJyZWFrOwogCQkJY2FzZSAxOgotCQkJCXNrYi0+ZGF0YVtsZW4gKyBwYWRkaW5nIC0gMV0gPSB0YWlsWzBdOworCQkJCXNrYi0+ZGF0YVtsZW4gKyBwYWRkaW5nIC0gMV0gPSB3bC0+cnhfdGFpbFswXTsKIAkJCQlicmVhazsKIAkJCX0KIAkJfQpAQCAtNzI5LDE3ICs3MzIsMTUgQEAKIAkJCSAgICAgICBxLT5tbWlvX2Jhc2UgKyBCNDNfUElPX1JYREFUQSwKIAkJCSAgICAgICBzaXplb2YodTE2KSk7CiAJCWlmIChsZW4gJiAxKSB7Ci0JCQl1OCB0YWlsWzJdID0geyAwLCB9OwotCiAJCQkvKiBSZWFkIHRoZSBsYXN0IGJ5dGUuICovCi0JCQlzc2JfYmxvY2tfcmVhZChkZXYtPmRldiwgdGFpbCwgMiwKKwkJCXNzYl9ibG9ja19yZWFkKGRldi0+ZGV2LCB3bC0+cnhfdGFpbCwgMiwKIAkJCQkgICAgICAgcS0+bW1pb19iYXNlICsgQjQzX1BJT19SWERBVEEsCiAJCQkJICAgICAgIHNpemVvZih1MTYpKTsKLQkJCXNrYi0+ZGF0YVtsZW4gKyBwYWRkaW5nIC0gMV0gPSB0YWlsWzBdOworCQkJc2tiLT5kYXRhW2xlbiArIHBhZGRpbmcgLSAxXSA9IHdsLT5yeF90YWlsWzBdOwogCQl9CiAJfQogCi0JYjQzX3J4KHEtPmRldiwgc2tiLCAmcnhoZHIpOworCWI0M19yeChxLT5kZXYsIHNrYiwgJndsLT5yeGhkcik7CiAKIAlyZXR1cm4gMTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3htaXQuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0My94bWl0LmMKaW5kZXggYWM5ZjYwMC4uZjRlOTY5NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzL3htaXQuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDMveG1pdC5jCkBAIC0yNyw3ICsyNyw3IEBACiAKICovCiAKLSNpbmNsdWRlICJ4bWl0LmgiCisjaW5jbHVkZSAiYjQzLmgiCiAjaW5jbHVkZSAicGh5X2NvbW1vbi5oIgogI2luY2x1ZGUgImRtYS5oIgogI2luY2x1ZGUgInBpby5oIgpAQCAtNjkwLDcgKzY5MCwxMCBAQAogCX0KIAogCW1lbWNweShJRUVFODAyMTFfU0tCX1JYQ0Ioc2tiKSwgJnN0YXR1cywgc2l6ZW9mKHN0YXR1cykpOworCisJbG9jYWxfYmhfZGlzYWJsZSgpOwogCWllZWU4MDIxMV9yeChkZXYtPndsLT5odywgc2tiKTsKKwlsb2NhbF9iaF9lbmFibGUoKTsKIAogI2lmIEI0M19ERUJVRwogCWRldi0+cnhfY291bnQrKzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0M2xlZ2FjeS9tYWluLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDNsZWdhY3kvbWFpbi5jCmluZGV4IDFkOTIyM2IuLjRiNjAxNDggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0M2xlZ2FjeS9tYWluLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzbGVnYWN5L21haW4uYwpAQCAtMzcsNiArMzcsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2Zpcm13YXJlLmg+CiAjaW5jbHVkZSA8bGludXgvd2lyZWxlc3MuaD4KICNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NrYnVmZi5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYS1tYXBwaW5nLmg+CiAjaW5jbHVkZSA8bmV0L2RzdC5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzbGVnYWN5L3BoeS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvYjQzbGVnYWN5L3BoeS5jCmluZGV4IDExMzE5ZWMuLmFhZjIyNzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2I0M2xlZ2FjeS9waHkuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9iNDNsZWdhY3kvcGh5LmMKQEAgLTMxLDYgKzMxLDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogCiAjaW5jbHVkZSAiYjQzbGVnYWN5LmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX2luZm8uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfaW5mby5jCmluZGV4IDZmYTE0YTQuLjRkZmI0MGEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfaW5mby5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfaW5mby5jCkBAIC0xLDYgKzEsNyBAQAogLyogSG9zdCBBUCBkcml2ZXIgSW5mbyBGcmFtZSBwcm9jZXNzaW5nIChwYXJ0IG9mIGhvc3RhcC5vIG1vZHVsZSkgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2lmX2FycC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSAiaG9zdGFwX3dsYW4uaCIKICNpbmNsdWRlICJob3N0YXAuaCIKICNpbmNsdWRlICJob3N0YXBfYXAuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfaW9jdGwuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2hvc3RhcC9ob3N0YXBfaW9jdGwuYwppbmRleCAzZjJiZGE4Li45NDE5Y2ViIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9ob3N0YXAvaG9zdGFwX2lvY3RsLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaG9zdGFwL2hvc3RhcF9pb2N0bC5jCkBAIC0xLDYgKzEsNyBAQAogLyogaW9jdGwoKSAobW9zdGx5IExpbnV4IFdpcmVsZXNzIEV4dGVuc2lvbnMpIHJvdXRpbmVzIGZvciBIb3N0IEFQIGRyaXZlciAqLwogCiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2V0aHRvb2wuaD4KICNpbmNsdWRlIDxsaW51eC9pZl9hcnAuaD4KICNpbmNsdWRlIDxuZXQvbGliODAyMTEuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2lwdzJ4MDAvaXB3MjIwMC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9pcHcyMjAwLmMKaW5kZXggOGQ1OGU2ZS4uODI3ODI0ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9pcHcyMjAwLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXB3MngwMC9pcHcyMjAwLmMKQEAgLTMwLDYgKzMwLDcgQEAKIAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlICJpcHcyMjAwLmgiCiAKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtMzk0NS1ycy5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtMzk0NS1ycy5jCmluZGV4IGExNmJkNDEuLmNiYjA1ODUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTM5NDUtcnMuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC0zOTQ1LXJzLmMKQEAgLTcwMiw3ICs3MDIsNyBAQAogCQl1OCBzdGFfaWQgPSBpd2xfZmluZF9zdGF0aW9uKHByaXYsIGhkci0+YWRkcjEpOwogCiAJCWlmIChzdGFfaWQgPT0gSVdMX0lOVkFMSURfU1RBVElPTikgewotCQkJSVdMX0RFQlVHX1JBVEUocHJpdiwgIkxROiBBREQgc3RhdGlvbiAlcG1cbiIsCisJCQlJV0xfREVCVUdfUkFURShwcml2LCAiTFE6IEFERCBzdGF0aW9uICVwTVxuIiwKIAkJCQkgICAgICAgaGRyLT5hZGRyMSk7CiAJCQlzdGFfaWQgPSBpd2xfYWRkX3N0YXRpb24ocHJpdiwgaGRyLT5hZGRyMSwgZmFsc2UsCiAJCQkJQ01EX0FTWU5DLCBOVUxMKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTM5NDUuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTM5NDUuYwppbmRleCBlNzBjNWIwLi5mMDU5YjQ5IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC0zOTQ1LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtMzk0NS5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CiAjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2tidWZmLmg+CiAjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvd2lyZWxlc3MuaD4KQEAgLTYxMCw3ICs2MTEsNyBAQAogCWlmIChyeF9zdGF0dXMuYmFuZCA9PSBJRUVFODAyMTFfQkFORF81R0haKQogCQlyeF9zdGF0dXMucmF0ZV9pZHggLT0gSVdMX0ZJUlNUX09GRE1fUkFURTsKIAotCXJ4X3N0YXR1cy5hbnRlbm5hID0gbGUxNl90b19jcHUocnhfaGRyLT5waHlfZmxhZ3MgJgorCXJ4X3N0YXR1cy5hbnRlbm5hID0gKGxlMTZfdG9fY3B1KHJ4X2hkci0+cGh5X2ZsYWdzKSAmCiAJCQkJCVJYX1JFU19QSFlfRkxBR1NfQU5URU5OQV9NU0spID4+IDQ7CiAKIAkvKiBzZXQgdGhlIHByZWFtYmxlIGZsYWcgaWYgYXBwcm9wcmlhdGUgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTQ5NjUuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTQ5NjUuYwppbmRleCBhMjJhMDUwLi42ZjcwM2EwIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC00OTY1LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtNDk2NS5jCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CiAjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2tidWZmLmg+CiAjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvd2lyZWxlc3MuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTUwMDAuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLTUwMDAuYwppbmRleCBlYjA4ZjQ0Li42ZTZmNTE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC01MDAwLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtNTAwMC5jCkBAIC0yOSw2ICsyOSw3IEBACiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CiAjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2tidWZmLmg+CiAjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvd2lyZWxlc3MuaD4KQEAgLTMxNyw3ICszMTgsNyBAQAogCQkJKHMzMilhdmVyYWdlX25vaXNlW2ldKSkgLyAxNTAwOwogCQkvKiBib3VuZCBnYWluIGJ5IDIgYml0cyB2YWx1ZSBtYXgsIDNyZCBiaXQgaXMgc2lnbiAqLwogCQlkYXRhLT5kZWx0YV9nYWluX2NvZGVbaV0gPQotCQkJbWluKGFicyhkZWx0YV9nKSwgQ0hBSU5fTk9JU0VfTUFYX0RFTFRBX0dBSU5fQ09ERSk7CisJCQltaW4oYWJzKGRlbHRhX2cpLCAobG9uZykgQ0hBSU5fTk9JU0VfTUFYX0RFTFRBX0dBSU5fQ09ERSk7CiAKIAkJaWYgKGRlbHRhX2cgPCAwKQogCQkJLyogc2V0IG5lZ2F0aXZlIHNpZ24gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWFnbi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLmMKaW5kZXggY2RjMDdjNC4uZWFhZmFlMCAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtYWduLmMKQEAgLTMzLDYgKzMzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9wY2kuaD4KICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9za2J1ZmYuaD4KICNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC93aXJlbGVzcy5oPgpAQCAtMzEwNSw4ICszMTA2LDggQEAKICBvdXRfcGNpX2Rpc2FibGVfZGV2aWNlOgogCXBjaV9kaXNhYmxlX2RldmljZShwZGV2KTsKICBvdXRfaWVlZTgwMjExX2ZyZWVfaHc6Ci0JaWVlZTgwMjExX2ZyZWVfaHcocHJpdi0+aHcpOwogCWl3bF9mcmVlX3RyYWZmaWNfbWVtKHByaXYpOworCWllZWU4MDIxMV9mcmVlX2h3KHByaXYtPmh3KTsKICBvdXQ6CiAJcmV0dXJuIGVycjsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWNvbW1hbmRzLmggYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1jb21tYW5kcy5oCmluZGV4IDJjNWM4OGYuLjRhZmFmNzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWNvbW1hbmRzLmgKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtY29tbWFuZHMuaApAQCAtMTE1NCw3ICsxMTU0LDcgQEAKICNkZWZpbmUgUlhfUkVTX1BIWV9GTEFHU19NT0RfQ0NLX01TSwkJY3B1X3RvX2xlMTYoMSA8PCAxKQogI2RlZmluZSBSWF9SRVNfUEhZX0ZMQUdTX1NIT1JUX1BSRUFNQkxFX01TSwljcHVfdG9fbGUxNigxIDw8IDIpCiAjZGVmaW5lIFJYX1JFU19QSFlfRkxBR1NfTkFSUk9XX0JBTkRfTVNLCWNwdV90b19sZTE2KDEgPDwgMykKLSNkZWZpbmUgUlhfUkVTX1BIWV9GTEFHU19BTlRFTk5BX01TSwkJY3B1X3RvX2xlMTYoMHhmMCkKKyNkZWZpbmUgUlhfUkVTX1BIWV9GTEFHU19BTlRFTk5BX01TSwkJMHhmMAogI2RlZmluZSBSWF9SRVNfUEhZX0ZMQUdTX0FOVEVOTkFfUE9TCQk0CiAKICNkZWZpbmUgUlhfUkVTX1NUQVRVU19TRUNfVFlQRV9NU0sJKDB4NyA8PCA4KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtY29yZS5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtY29yZS5jCmluZGV4IDQ4NGQ1YzEuLjJkYzkyODcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWNvcmUuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1jb3JlLmMKQEAgLTI5LDYgKzI5LDcgQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bmV0L21hYzgwMjExLmg+CiAKICNpbmNsdWRlICJpd2wtZWVwcm9tLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1lZXByb20uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5jCmluZGV4IDNkMmI5M2EuLmUxNGM5OTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5jCkBAIC00MTAsNyArNDEwLDYgQEAKIAkJCQkJdTE2ICp2YWxpZGJsb2NrYWRkcikKIHsKIAl1MTYgbmV4dF9saW5rX2FkZHIgPSAwLCBsaW5rX3ZhbHVlID0gMCwgdmFsaWRfYWRkcjsKLQlpbnQgcmV0ID0gMDsKIAlpbnQgdXNlZGJsb2NrcyA9IDA7CiAKIAkvKiBzZXQgYWRkcmVzc2luZyBtb2RlIHRvIGFic29sdXRlIHRvIHRyYXZlcnNlIHRoZSBsaW5rIGxpc3QgKi8KQEAgLTQzMCwyOSArNDI5LDI5IEBACiAJCSAqIGNoZWNrIGZvciBtb3JlIGJsb2NrIG9uIHRoZSBsaW5rIGxpc3QKIAkJICovCiAJCXZhbGlkX2FkZHIgPSBuZXh0X2xpbmtfYWRkcjsKLQkJbmV4dF9saW5rX2FkZHIgPSBsaW5rX3ZhbHVlOworCQluZXh0X2xpbmtfYWRkciA9IGxpbmtfdmFsdWUgKiBzaXplb2YodTE2KTsKIAkJSVdMX0RFQlVHX0lORk8ocHJpdiwgIk9UUCBibG9ja3MgJWQgYWRkciAweCV4XG4iLAogCQkJICAgICAgIHVzZWRibG9ja3MsIG5leHRfbGlua19hZGRyKTsKIAkJaWYgKGl3bF9yZWFkX290cF93b3JkKHByaXYsIG5leHRfbGlua19hZGRyLCAmbGlua192YWx1ZSkpCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAkJaWYgKCFsaW5rX3ZhbHVlKSB7CiAJCQkvKgotCQkJICogcmVhY2ggdGhlIGVuZCBvZiBsaW5rIGxpc3QsCisJCQkgKiByZWFjaCB0aGUgZW5kIG9mIGxpbmsgbGlzdCwgcmV0dXJuIHN1Y2Nlc3MgYW5kCiAJCQkgKiBzZXQgYWRkcmVzcyBwb2ludCB0byB0aGUgc3RhcnRpbmcgYWRkcmVzcwogCQkJICogb2YgdGhlIGltYWdlCiAJCQkgKi8KLQkJCWdvdG8gZG9uZTsKKwkJCSp2YWxpZGJsb2NrYWRkciA9IHZhbGlkX2FkZHI7CisJCQkvKiBza2lwIGZpcnN0IDIgYnl0ZXMgKGxpbmsgbGlzdCBwb2ludGVyKSAqLworCQkJKnZhbGlkYmxvY2thZGRyICs9IDI7CisJCQlyZXR1cm4gMDsKIAkJfQogCQkvKiBtb3JlIGluIHRoZSBsaW5rIGxpc3QsIGNvbnRpbnVlICovCiAJCXVzZWRibG9ja3MrKzsKLQl9IHdoaWxlICh1c2VkYmxvY2tzIDwgcHJpdi0+Y2ZnLT5tYXhfbGxfaXRlbXMpOwotCS8qIE9UUCBmdWxsLCB1c2UgbGFzdCBibG9jayAqLwotCUlXTF9ERUJVR19JTkZPKHByaXYsICJPVFAgaXMgZnVsbCwgdXNlIGxhc3QgYmxvY2tcbiIpOwotZG9uZToKLQkqdmFsaWRibG9ja2FkZHIgPSB2YWxpZF9hZGRyOwotCS8qIHNraXAgZmlyc3QgMiBieXRlcyAobGluayBsaXN0IHBvaW50ZXIpICovCi0JKnZhbGlkYmxvY2thZGRyICs9IDI7Ci0JcmV0dXJuIHJldDsKKwl9IHdoaWxlICh1c2VkYmxvY2tzIDw9IHByaXYtPmNmZy0+bWF4X2xsX2l0ZW1zKTsKKworCS8qIE9UUCBoYXMgbm8gdmFsaWQgYmxvY2tzICovCisJSVdMX0RFQlVHX0lORk8ocHJpdiwgIk9UUCBoYXMgbm8gdmFsaWQgYmxvY2tzXG4iKTsKKwlyZXR1cm4gLUVJTlZBTDsKIH0KIAogLyoqCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1lZXByb20uaCBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5oCmluZGV4IDZiNjhkYjcuLjgwYjllNDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5oCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWVlcHJvbS5oCkBAIC0yMjAsMzUgKzIyMCwzNSBAQAogICogU2VjdGlvbiAxMDogMi40IEdIeiA0ME1IeiBjaGFubmVsczogMTMyLCA0NCAoX2Fib3ZlXykKICAqLwogLyogMi40IEdIeiBiYW5kOiBDQ0sgKi8KLSNkZWZpbmUgRUVQUk9NX0xCX0NDS18yMF9DT01NT04gICAgICAgKCgweEFBKVwKKyNkZWZpbmUgRUVQUk9NX0xCX0NDS18yMF9DT01NT04gICAgICAgKCgweEE4KVwKIAkJfCBJTkRJUkVDVF9BRERSRVNTIHwgSU5ESVJFQ1RfUkVHVUxBVE9SWSkgICAvKiA4IGJ5dGVzICovCiAvKiAyLjQgR0h6IGJhbmQ6IDIwTUh6LUxlZ2FjeSwgMjBNSHotSFQsIDQwTUh6LUhUICovCi0jZGVmaW5lIEVFUFJPTV9MQl9PRkRNX0NPTU1PTiAgICAgICAoKDB4QjIpXAorI2RlZmluZSBFRVBST01fTEJfT0ZETV9DT01NT04gICAgICAgKCgweEIwKVwKIAkJfCBJTkRJUkVDVF9BRERSRVNTIHwgSU5ESVJFQ1RfUkVHVUxBVE9SWSkgICAvKiAyNCBieXRlcyAqLwogLyogNS4yIEdIeiBiYW5kOiAyME1Iei1MZWdhY3ksIDIwTUh6LUhULCA0ME1Iei1IVCAqLwotI2RlZmluZSBFRVBST01fSEJfT0ZETV9DT01NT04gICAgICAgKCgweENBKVwKKyNkZWZpbmUgRUVQUk9NX0hCX09GRE1fQ09NTU9OICAgICAgICgoMHhDOClcCiAJCXwgSU5ESVJFQ1RfQUREUkVTUyB8IElORElSRUNUX1JFR1VMQVRPUlkpICAgLyogMjQgYnl0ZXMgKi8KIC8qIDIuNEdIeiBiYW5kIGNoYW5uZWxzOgogICoJMUxlZ2FjeSwgMUhULCAyTGVnYWN5LCAySFQsIDEwTGVnYWN5LCAxMEhULCAxMUxlZ2FjeSwgMTFIVCAqLwotI2RlZmluZSBFRVBST01fTEJfT0ZETV8yMF9CQU5EICAgICAgICgoMHhFMilcCisjZGVmaW5lIEVFUFJPTV9MQl9PRkRNXzIwX0JBTkQgICAgICAgKCgweEUwKVwKIAkJfCBJTkRJUkVDVF9BRERSRVNTIHwgSU5ESVJFQ1RfUkVHVUxBVE9SWSkgICAvKiA2NCBieXRlcyAqLwogLyogMi40IEdIeiBiYW5kIEhUNDAgY2hhbm5lbHM6ICgxLCsxKSAoMiwrMSkgKDYsKzEpICg3LCsxKSAoOSwrMSkgKi8KLSNkZWZpbmUgRUVQUk9NX0xCX09GRE1fSFQ0MF9CQU5EICAgICAgICgoMHgxMjIpXAorI2RlZmluZSBFRVBST01fTEJfT0ZETV9IVDQwX0JBTkQgICAgICAgKCgweDEyMClcCiAJCXwgSU5ESVJFQ1RfQUREUkVTUyB8IElORElSRUNUX1JFR1VMQVRPUlkpICAgLyogNDAgYnl0ZXMgKi8KIC8qIDUuMkdIeiBiYW5kIGNoYW5uZWxzOiAzNkxlZ2FjeSwgMzZIVCwgNjRMZWdhY3ksIDY0SFQsIDEwMExlZ2FjeSwgMTAwSFQgKi8KLSNkZWZpbmUgRUVQUk9NX0hCX09GRE1fMjBfQkFORCAgICAgICAoKDB4MTRBKVwKKyNkZWZpbmUgRUVQUk9NX0hCX09GRE1fMjBfQkFORCAgICAgICAoKDB4MTQ4KVwKIAkJfCBJTkRJUkVDVF9BRERSRVNTIHwgSU5ESVJFQ1RfUkVHVUxBVE9SWSkgICAvKiA0OCBieXRlcyAqLwogLyogNS4yIEdIeiBiYW5kIEhUNDAgY2hhbm5lbHM6ICgzNiwrMSkgKDYwLCsxKSAoMTAwLCsxKSAqLwotI2RlZmluZSBFRVBST01fSEJfT0ZETV9IVDQwX0JBTkQgICAgICAgKCgweDE3QSlcCisjZGVmaW5lIEVFUFJPTV9IQl9PRkRNX0hUNDBfQkFORCAgICAgICAoKDB4MTc4KVwKIAkJfCBJTkRJUkVDVF9BRERSRVNTIHwgSU5ESVJFQ1RfUkVHVUxBVE9SWSkgICAvKiAyNCBieXRlcyAqLwogLyogMi40IEdIeiBiYW5kLCBjaGFubm5lbCAxMzogTGVnYWN5LCBIVCAqLwotI2RlZmluZSBFRVBST01fTEJfT0ZETV8yMF9DSEFOTkVMXzEzICAgICAgICgoMHgxOTIpXAorI2RlZmluZSBFRVBST01fTEJfT0ZETV8yMF9DSEFOTkVMXzEzICAgICAgICgoMHgxOTApXAogCQl8IElORElSRUNUX0FERFJFU1MgfCBJTkRJUkVDVF9SRUdVTEFUT1JZKSAgIC8qIDE2IGJ5dGVzICovCiAvKiA1LjIgR0h6IGJhbmQsIGNoYW5ubmVsIDE0MDogTGVnYWN5LCBIVCAqLwotI2RlZmluZSBFRVBST01fSEJfT0ZETV8yMF9DSEFOTkVMXzE0MCAgICAgICAoKDB4MUEyKVwKKyNkZWZpbmUgRUVQUk9NX0hCX09GRE1fMjBfQ0hBTk5FTF8xNDAgICAgICAgKCgweDFBMClcCiAJCXwgSU5ESVJFQ1RfQUREUkVTUyB8IElORElSRUNUX1JFR1VMQVRPUlkpICAgLyogMTYgYnl0ZXMgKi8KIC8qIDUuMiBHSHogYmFuZCwgSFQ0MCBjaGFubm5lbHMgKDEzMiwrMSkgKDQ0LCsxKSAqLwotI2RlZmluZSBFRVBST01fSEJfT0ZETV9IVDQwX0JBTkRfMSAgICAgICAoKDB4MUIyKVwKKyNkZWZpbmUgRUVQUk9NX0hCX09GRE1fSFQ0MF9CQU5EXzEgICAgICAgKCgweDFCMClcCiAJCXwgSU5ESVJFQ1RfQUREUkVTUyB8IElORElSRUNUX1JFR1VMQVRPUlkpICAgLyogMTYgYnl0ZXMgKi8KIAogCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1oY21kLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1oY21kLmMKaW5kZXggNTMyYzhkNi4uYTY4NTZkYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtaGNtZC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLWhjbWQuYwpAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxuZXQvbWFjODAyMTEuaD4KIAogI2luY2x1ZGUgIml3bC1kZXYuaCIgLyogRklYTUU6IHJlbW92ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtcnguYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLXJ4LmMKaW5kZXggOGUxYmI1My4uNDkzNjI2YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtcnguYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC1yeC5jCkBAIC0xMDQ0LDcgKzEwNDQsNyBAQAogCSAqIGFzIGEgYml0bWFzay4KIAkgKi8KIAlyeF9zdGF0dXMuYW50ZW5uYSA9Ci0JCWxlMTZfdG9fY3B1KHBoeV9yZXMtPnBoeV9mbGFncyAmIFJYX1JFU19QSFlfRkxBR1NfQU5URU5OQV9NU0spCisJCShsZTE2X3RvX2NwdShwaHlfcmVzLT5waHlfZmxhZ3MpICYgUlhfUkVTX1BIWV9GTEFHU19BTlRFTk5BX01TSykKIAkJPj4gUlhfUkVTX1BIWV9GTEFHU19BTlRFTk5BX1BPUzsKIAogCS8qIHNldCB0aGUgcHJlYW1ibGUgZmxhZyBpZiBhcHByb3ByaWF0ZSAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtdHguYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsLXR4LmMKaW5kZXggYzE4OTA3NS4uZmI5YmNmYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wtdHguYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bC10eC5jCkBAIC0yOCw2ICsyOCw3IEBACiAgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCiAKICNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bmV0L21hYzgwMjExLmg+CiAjaW5jbHVkZSAiaXdsLWVlcHJvbS5oIgogI2luY2x1ZGUgIml3bC1kZXYuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsMzk0NS1iYXNlLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd2x3aWZpL2l3bDM5NDUtYmFzZS5jCmluZGV4IGMzOTBkYmQuLmQwMGE4MDMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bHdpZmkvaXdsMzk0NS1iYXNlLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdsd2lmaS9pd2wzOTQ1LWJhc2UuYwpAQCAtMzMsNiArMzMsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgogI2luY2x1ZGUgPGxpbnV4L2RtYS1tYXBwaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NrYnVmZi5oPgogI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L3dpcmVsZXNzLmg+CkBAIC00MDk2LDggKzQwOTcsOCBAQAogCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKIAlwY2lfZGlzYWJsZV9kZXZpY2UocGRldik7CiAgb3V0X2llZWU4MDIxMV9mcmVlX2h3OgotCWllZWU4MDIxMV9mcmVlX2h3KHByaXYtPmh3KTsKIAlpd2xfZnJlZV90cmFmZmljX21lbShwcml2KTsKKwlpZWVlODAyMTFfZnJlZV9odyhwcml2LT5odyk7CiAgb3V0OgogCXJldHVybiBlcnI7CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9pd21jMzIwMHdpZmkvY2ZnODAyMTEuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9jZmc4MDIxMS5jCmluZGV4IGE1NmEyYjAuLmYzYzU1NjUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9jZmc4MDIxMS5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9jZmc4MDIxMS5jCkBAIC0yMyw2ICsyMyw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2V0aGVyZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvd2lyZWxlc3MuaD4KICNpbmNsdWRlIDxsaW51eC9pZWVlODAyMTEuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9jb21tYW5kcy5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL2NvbW1hbmRzLmMKaW5kZXggMjNiNTJmYS4uODQxNThiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL2NvbW1hbmRzLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL2NvbW1hbmRzLmMKQEAgLTQwLDYgKzQwLDcgQEAKICNpbmNsdWRlIDxsaW51eC93aXJlbGVzcy5oPgogI2luY2x1ZGUgPGxpbnV4L2V0aGVyZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvaWVlZTgwMjExLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KIAogI2luY2x1ZGUgIml3bS5oIgogI2luY2x1ZGUgImJ1cy5oIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL21haW4uYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9tYWluLmMKaW5kZXggZDY2OGU0Ny4uMjIyZWIyYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL21haW4uYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9pd21jMzIwMHdpZmkvbWFpbi5jCkBAIC0zOCw2ICszOCw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2llZWU4MDIxMS5oPgogI2luY2x1ZGUgPGxpbnV4L3dpcmVsZXNzLmg+CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2l3bWMzMjAwd2lmaS9yeC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL3J4LmMKaW5kZXggNDBkYmNiYy4uNzcxYTMwMSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL3J4LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvaXdtYzMyMDB3aWZpL3J4LmMKQEAgLTM4LDYgKzM4LDcgQEAKIAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC93aXJlbGVzcy5oPgogI2luY2x1ZGUgPGxpbnV4L2llZWU4MDIxMS5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvbGliZXJ0YXMvY21kLmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9jbWQuYwppbmRleCA2ODUwOTgxLi4wYTMyNGRjIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9jbWQuYworKysgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9jbWQuYwpAQCAtNiw2ICs2LDcgQEAKICNpbmNsdWRlIDxuZXQvaXdfaGFuZGxlci5oPgogI2luY2x1ZGUgPG5ldC9saWI4MDIxMS5oPgogI2luY2x1ZGUgPGxpbnV4L2tmaWZvLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlICJob3N0LmgiCiAjaW5jbHVkZSAiaG9zdGNtZC5oIgogI2luY2x1ZGUgImRlY2wuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2NtZHJlc3AuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL2NtZHJlc3AuYwppbmRleCBjNDJkM2ZhLi4yM2Y2ODQzIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy9jbWRyZXNwLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvbGliZXJ0YXMvY21kcmVzcC5jCkBAIC0zLDYgKzMsNyBAQAogICAqIHJlc3BvbnNlcyBhcyB3ZWxsIGFzIGV2ZW50cyBnZW5lcmF0ZWQgYnkgZmlybXdhcmUuCiAgICovCiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L2lmX2FycC5oPgogI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgogI2luY2x1ZGUgPGFzbS91bmFsaWduZWQuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL3R4LmMgYi9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy90eC5jCmluZGV4IDRjMDE4ZjcuLjhjMzc2NmE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9saWJlcnRhcy90eC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL2xpYmVydGFzL3R4LmMKQEAgLTMsNiArMyw3IEBACiAgICovCiAjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogCiAjaW5jbHVkZSAiaG9zdGNtZC5oIgogI2luY2x1ZGUgInJhZGlvdGFwLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9wcmlzbTU0L2lzbF9pb2N0bC5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcHJpc201NC9pc2xfaW9jdGwuYwppbmRleCA0Yzk3YzZhLi5iYzA4NDY0IDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC93aXJlbGVzcy9wcmlzbTU0L2lzbF9pb2N0bC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNsX2lvY3RsLmMKQEAgLTE5LDYgKzE5LDcgQEAKICAqCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L2NhcGFiaWxpdHkuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9pZl9hcnAuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNscGNpX2Rldi5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcHJpc201NC9pc2xwY2lfZGV2LmMKaW5kZXggZTI2ZDdiMy4uMjUwNWJlNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcHJpc201NC9pc2xwY2lfZGV2LmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcHJpc201NC9pc2xwY2lfZGV2LmMKQEAgLTIzLDYgKzIzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9uZXRkZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9ldGh0b29sLmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CiAjaW5jbHVkZSA8bGludXgvaWZfYXJwLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC93aXJlbGVzcy9wcmlzbTU0L2lzbHBjaV9tZ3QuYyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNscGNpX21ndC5jCmluZGV4IGY3YzY3N2UuLjY5ZDJmODggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNscGNpX21ndC5jCisrKyBiL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3ByaXNtNTQvaXNscGNpX21ndC5jCkBAIC0yMCw2ICsyMCw3IEBACiAjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KIAogI2luY2x1ZGUgPGFzbS9pby5oPgogI2luY2x1ZGUgPGFzbS9zeXN0ZW0uaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3dpcmVsZXNzL3J0MngwMC9ydDJ4MDBkZWJ1Zy5jIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGRlYnVnLmMKaW5kZXggN2IzZWU4Yy4uNjhiYzliYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGRlYnVnLmMKKysrIGIvZHJpdmVycy9uZXQvd2lyZWxlc3MvcnQyeDAwL3J0MngwMGRlYnVnLmMKQEAgLTI3LDYgKzI3LDcgQEAKICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9wb2xsLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CiAKICNpbmNsdWRlICJydDJ4MDAuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbmV0L3puZXQuYyBiL2RyaXZlcnMvbmV0L3puZXQuYwppbmRleCBhMDM4NGI2Li5iNDIzNDczIDEwMDY0NAotLS0gYS9kcml2ZXJzL25ldC96bmV0LmMKKysrIGIvZHJpdmVycy9uZXQvem5ldC5jCkBAIC0xNjksNyArMTY5LDYgQEAKIHN0YXRpYyBpbnQgem5ldF9yZXF1ZXN0X3Jlc291cmNlcyAoc3RydWN0IG5ldF9kZXZpY2UgKmRldikKIHsKIAlzdHJ1Y3Qgem5ldF9wcml2YXRlICp6bmV0ID0gbmV0ZGV2X3ByaXYoZGV2KTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJaWYgKHJlcXVlc3RfaXJxIChkZXYtPmlycSwgJnpuZXRfaW50ZXJydXB0LCAwLCAiWk5ldCIsIGRldikpCiAJCWdvdG8gZmFpbGVkOwpAQCAtMTg3LDEzICsxODYsOSBAQAogIGZyZWVfc2lhOgogCXJlbGVhc2VfcmVnaW9uICh6bmV0LT5zaWFfYmFzZSwgem5ldC0+c2lhX3NpemUpOwogIGZyZWVfdHhfZG1hOgotCWZsYWdzID0gY2xhaW1fZG1hX2xvY2soKTsKIAlmcmVlX2RtYSAoem5ldC0+dHhfZG1hKTsKLQlyZWxlYXNlX2RtYV9sb2NrIChmbGFncyk7CiAgZnJlZV9yeF9kbWE6Ci0JZmxhZ3MgPSBjbGFpbV9kbWFfbG9jaygpOwogCWZyZWVfZG1hICh6bmV0LT5yeF9kbWEpOwotCXJlbGVhc2VfZG1hX2xvY2sgKGZsYWdzKTsKICBmcmVlX2lycToKIAlmcmVlX2lycSAoZGV2LT5pcnEsIGRldik7CiAgZmFpbGVkOgpAQCAtMjAzLDE0ICsxOTgsMTEgQEAKIHN0YXRpYyB2b2lkIHpuZXRfcmVsZWFzZV9yZXNvdXJjZXMgKHN0cnVjdCBuZXRfZGV2aWNlICpkZXYpCiB7CiAJc3RydWN0IHpuZXRfcHJpdmF0ZSAqem5ldCA9IG5ldGRldl9wcml2KGRldik7Ci0JdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCXJlbGVhc2VfcmVnaW9uICh6bmV0LT5zaWFfYmFzZSwgem5ldC0+c2lhX3NpemUpOwogCXJlbGVhc2VfcmVnaW9uIChkZXYtPmJhc2VfYWRkciwgem5ldC0+aW9fc2l6ZSk7Ci0JZmxhZ3MgPSBjbGFpbV9kbWFfbG9jaygpOwogCWZyZWVfZG1hICh6bmV0LT50eF9kbWEpOwogCWZyZWVfZG1hICh6bmV0LT5yeF9kbWEpOwotCXJlbGVhc2VfZG1hX2xvY2sgKGZsYWdzKTsKIAlmcmVlX2lycSAoZGV2LT5pcnEsIGRldik7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvb3Byb2ZpbGUvZXZlbnRfYnVmZmVyLmMgYi9kcml2ZXJzL29wcm9maWxlL2V2ZW50X2J1ZmZlci5jCmluZGV4IDJiN2FlMzYuLjVkZjYwYTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvb3Byb2ZpbGUvZXZlbnRfYnVmZmVyLmMKKysrIGIvZHJpdmVycy9vcHJvZmlsZS9ldmVudF9idWZmZXIuYwpAQCAtMzUsMTIgKzM1LDIzIEBACiAvKiBhdG9taWNfdCBiZWNhdXNlIHdhaXRfZXZlbnQgY2hlY2tzIGl0IG91dHNpZGUgb2YgYnVmZmVyX211dGV4ICovCiBzdGF0aWMgYXRvbWljX3QgYnVmZmVyX3JlYWR5ID0gQVRPTUlDX0lOSVQoMCk7CiAKLS8qIEFkZCBhbiBlbnRyeSB0byB0aGUgZXZlbnQgYnVmZmVyLiBXaGVuIHdlCi0gKiBnZXQgbmVhciB0byB0aGUgZW5kIHdlIHdha2UgdXAgdGhlIHByb2Nlc3MKLSAqIHNsZWVwaW5nIG9uIHRoZSByZWFkKCkgb2YgdGhlIGZpbGUuCisvKgorICogQWRkIGFuIGVudHJ5IHRvIHRoZSBldmVudCBidWZmZXIuIFdoZW4gd2UgZ2V0IG5lYXIgdG8gdGhlIGVuZCB3ZQorICogd2FrZSB1cCB0aGUgcHJvY2VzcyBzbGVlcGluZyBvbiB0aGUgcmVhZCgpIG9mIHRoZSBmaWxlLiBUbyBwcm90ZWN0CisgKiB0aGUgZXZlbnRfYnVmZmVyIHRoaXMgZnVuY3Rpb24gbWF5IG9ubHkgYmUgY2FsbGVkIHdoZW4gYnVmZmVyX211dGV4CisgKiBpcyBzZXQuCiAgKi8KIHZvaWQgYWRkX2V2ZW50X2VudHJ5KHVuc2lnbmVkIGxvbmcgdmFsdWUpCiB7CisJLyoKKwkgKiBUaGlzIHNob3VsZG4ndCBoYXBwZW4gc2luY2UgYWxsIHdvcmtxdWV1ZXMgb3IgaGFuZGxlcnMgYXJlCisJICogY2FuY2VsZWQgb3IgZmx1c2hlZCBiZWZvcmUgdGhlIGV2ZW50IGJ1ZmZlciBpcyBmcmVlZC4KKwkgKi8KKwlpZiAoIWV2ZW50X2J1ZmZlcikgeworCQlXQVJOX09OX09OQ0UoMSk7CisJCXJldHVybjsKKwl9CisKIAlpZiAoYnVmZmVyX3BvcyA9PSBidWZmZXJfc2l6ZSkgewogCQlhdG9taWNfaW5jKCZvcHJvZmlsZV9zdGF0cy5ldmVudF9sb3N0X292ZXJmbG93KTsKIAkJcmV0dXJuOwpAQCAtNjksNyArODAsNiBAQAogCiBpbnQgYWxsb2NfZXZlbnRfYnVmZmVyKHZvaWQpCiB7Ci0JaW50IGVyciA9IC1FTk9NRU07CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZvcHJvZmlsZWZzX2xvY2ssIGZsYWdzKTsKQEAgLTgwLDIxICs5MCwyMiBAQAogCWlmIChidWZmZXJfd2F0ZXJzaGVkID49IGJ1ZmZlcl9zaXplKQogCQlyZXR1cm4gLUVJTlZBTDsKIAorCWJ1ZmZlcl9wb3MgPSAwOwogCWV2ZW50X2J1ZmZlciA9IHZtYWxsb2Moc2l6ZW9mKHVuc2lnbmVkIGxvbmcpICogYnVmZmVyX3NpemUpOwogCWlmICghZXZlbnRfYnVmZmVyKQotCQlnb3RvIG91dDsKKwkJcmV0dXJuIC1FTk9NRU07CiAKLQllcnIgPSAwOwotb3V0OgotCXJldHVybiBlcnI7CisJcmV0dXJuIDA7CiB9CiAKIAogdm9pZCBmcmVlX2V2ZW50X2J1ZmZlcih2b2lkKQogeworCW11dGV4X2xvY2soJmJ1ZmZlcl9tdXRleCk7CiAJdmZyZWUoZXZlbnRfYnVmZmVyKTsKLQorCWJ1ZmZlcl9wb3MgPSAwOwogCWV2ZW50X2J1ZmZlciA9IE5VTEw7CisJbXV0ZXhfdW5sb2NrKCZidWZmZXJfbXV0ZXgpOwogfQogCiAKQEAgLTE2Nyw2ICsxNzgsMTIgQEAKIAogCW11dGV4X2xvY2soJmJ1ZmZlcl9tdXRleCk7CiAKKwkvKiBNYXkgaGFwcGVuIGlmIHRoZSBidWZmZXIgaXMgZnJlZWQgZHVyaW5nIHBlbmRpbmcgcmVhZHMuICovCisJaWYgKCFldmVudF9idWZmZXIpIHsKKwkJcmV0dmFsID0gLUVJTlRSOworCQlnb3RvIG91dDsKKwl9CisKIAlhdG9taWNfc2V0KCZidWZmZXJfcmVhZHksIDApOwogCiAJcmV0dmFsID0gLUVGQVVMVDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2RtYXIuYyBiL2RyaXZlcnMvcGNpL2RtYXIuYwppbmRleCAxNGJiYWExLi4yMmIwMmM2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9kbWFyLmMKKysrIGIvZHJpdmVycy9wY2kvZG1hci5jCkBAIC0zNTQsNiArMzU0LDcgQEAKIAlzdHJ1Y3QgYWNwaV9kbWFyX2hhcmR3YXJlX3VuaXQgKmRyaGQ7CiAJc3RydWN0IGFjcGlfZG1hcl9yZXNlcnZlZF9tZW1vcnkgKnJtcnI7CiAJc3RydWN0IGFjcGlfZG1hcl9hdHNyICphdHNyOworCXN0cnVjdCBhY3BpX2RtYXJfcmhzYSAqcmhzYTsKIAogCXN3aXRjaCAoaGVhZGVyLT50eXBlKSB7CiAJY2FzZSBBQ1BJX0RNQVJfVFlQRV9IQVJEV0FSRV9VTklUOgpAQCAtMzc1LDYgKzM3NiwxMiBAQAogCQlhdHNyID0gY29udGFpbmVyX29mKGhlYWRlciwgc3RydWN0IGFjcGlfZG1hcl9hdHNyLCBoZWFkZXIpOwogCQlwcmludGsoS0VSTl9JTkZPIFBSRUZJWCAiQVRTUiBmbGFnczogJSN4XG4iLCBhdHNyLT5mbGFncyk7CiAJCWJyZWFrOworCWNhc2UgQUNQSV9ETUFSX0hBUkRXQVJFX0FGRklOSVRZOgorCQlyaHNhID0gY29udGFpbmVyX29mKGhlYWRlciwgc3RydWN0IGFjcGlfZG1hcl9yaHNhLCBoZWFkZXIpOworCQlwcmludGsoS0VSTl9JTkZPIFBSRUZJWCAiUkhTQSBiYXNlOiAlIzAxNkx4IHByb3hpbWl0eSBkb21haW46ICUjeFxuIiwKKwkJICAgICAgICh1bnNpZ25lZCBsb25nIGxvbmcpcmhzYS0+YmFzZV9hZGRyZXNzLAorCQkgICAgICAgcmhzYS0+cHJveGltaXR5X2RvbWFpbik7CisJCWJyZWFrOwogCX0KIH0KIApAQCAtNDU5LDkgKzQ2NiwxMyBAQAogCQkJcmV0ID0gZG1hcl9wYXJzZV9vbmVfYXRzcihlbnRyeV9oZWFkZXIpOwogI2VuZGlmCiAJCQlicmVhazsKKwkJY2FzZSBBQ1BJX0RNQVJfSEFSRFdBUkVfQUZGSU5JVFk6CisJCQkvKiBXZSBkb24ndCBkbyBhbnl0aGluZyB3aXRoIFJIU0EgKHlldD8pICovCisJCQlicmVhazsKIAkJZGVmYXVsdDoKIAkJCXByaW50ayhLRVJOX1dBUk5JTkcgUFJFRklYCi0JCQkJIlVua25vd24gRE1BUiBzdHJ1Y3R1cmUgdHlwZVxuIik7CisJCQkJIlVua25vd24gRE1BUiBzdHJ1Y3R1cmUgdHlwZSAlZFxuIiwKKwkJCQllbnRyeV9oZWFkZXItPnR5cGUpOwogCQkJcmV0ID0gMDsgLyogZm9yIGZvcndhcmQgY29tcGF0aWJpbGl0eSAqLwogCQkJYnJlYWs7CiAJCX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2hvdHBsdWcvY3BxcGhwLmggYi9kcml2ZXJzL3BjaS9ob3RwbHVnL2NwcXBocC5oCmluZGV4IDUzODM2MDAuLjljNmE5ZmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2hvdHBsdWcvY3BxcGhwLmgKKysrIGIvZHJpdmVycy9wY2kvaG90cGx1Zy9jcHFwaHAuaApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgPGFzbS9pby5oPgkJLyogZm9yIHJlYWQ/IGFuZCB3cml0ZT8gZnVuY3Rpb25zICovCiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4JLyogZm9yIGRlbGF5cyAqLwogI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4JLyogZm9yIHNpZ25hbF9wZW5kaW5nKCkgKi8KIAogI2RlZmluZSBNWV9OQU1FCSJjcHFwaHAiCiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL2ludGVsLWlvbW11LmMgYi9kcml2ZXJzL3BjaS9pbnRlbC1pb21tdS5jCmluZGV4IDg1NWRkN2MuLmIxZTk3ZTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL2ludGVsLWlvbW11LmMKKysrIGIvZHJpdmVycy9wY2kvaW50ZWwtaW9tbXUuYwpAQCAtNDgsNiArNDgsNyBAQAogCiAjZGVmaW5lIElTX0dGWF9ERVZJQ0UocGRldikgKChwZGV2LT5jbGFzcyA+PiAxNikgPT0gUENJX0JBU0VfQ0xBU1NfRElTUExBWSkKICNkZWZpbmUgSVNfSVNBX0RFVklDRShwZGV2KSAoKHBkZXYtPmNsYXNzID4+IDgpID09IFBDSV9DTEFTU19CUklER0VfSVNBKQorI2RlZmluZSBJU19BWkFMSUEocGRldikgKChwZGV2KS0+dmVuZG9yID09IDB4ODA4NiAmJiAocGRldiktPmRldmljZSA9PSAweDNhM2UpCiAKICNkZWZpbmUgSU9BUElDX1JBTkdFX1NUQVJUCSgweGZlZTAwMDAwKQogI2RlZmluZSBJT0FQSUNfUkFOR0VfRU5ECSgweGZlZWZmZmZmKQpAQCAtOTQsNiArOTUsNyBAQAogLyogZ2xvYmFsIGlvbW11IGxpc3QsIHNldCBOVUxMIGZvciBpZ25vcmVkIERNQVIgdW5pdHMgKi8KIHN0YXRpYyBzdHJ1Y3QgaW50ZWxfaW9tbXUgKipnX2lvbW11czsKIAorc3RhdGljIHZvaWQgX19pbml0IGNoZWNrX3R5bGVyc2J1cmdfaXNvY2godm9pZCk7CiBzdGF0aWMgaW50IHJ3YmZfcXVpcms7CiAKIC8qCkBAIC0xOTM0LDYgKzE5MzYsOSBAQAogfQogCiBzdGF0aWMgaW50IGlvbW11X2lkZW50aXR5X21hcHBpbmc7CisjZGVmaW5lIElERU5UTUFQX0FMTAkJMQorI2RlZmluZSBJREVOVE1BUF9HRlgJCTIKKyNkZWZpbmUgSURFTlRNQVBfQVpBTElBCQk0CiAKIHN0YXRpYyBpbnQgaW9tbXVfZG9tYWluX2lkZW50aXR5X21hcChzdHJ1Y3QgZG1hcl9kb21haW4gKmRvbWFpbiwKIAkJCQkgICAgIHVuc2lnbmVkIGxvbmcgbG9uZyBzdGFydCwKQEAgLTIxNTEsOCArMjE1NiwxNCBAQAogCiBzdGF0aWMgaW50IGlvbW11X3Nob3VsZF9pZGVudGl0eV9tYXAoc3RydWN0IHBjaV9kZXYgKnBkZXYsIGludCBzdGFydHVwKQogewotCWlmIChpb21tdV9pZGVudGl0eV9tYXBwaW5nID09IDIpCi0JCXJldHVybiBJU19HRlhfREVWSUNFKHBkZXYpOworCWlmICgoaW9tbXVfaWRlbnRpdHlfbWFwcGluZyAmIElERU5UTUFQX0FaQUxJQSkgJiYgSVNfQVpBTElBKHBkZXYpKQorCQlyZXR1cm4gMTsKKworCWlmICgoaW9tbXVfaWRlbnRpdHlfbWFwcGluZyAmIElERU5UTUFQX0dGWCkgJiYgSVNfR0ZYX0RFVklDRShwZGV2KSkKKwkJcmV0dXJuIDE7CisKKwlpZiAoIShpb21tdV9pZGVudGl0eV9tYXBwaW5nICYgSURFTlRNQVBfQUxMKSkKKwkJcmV0dXJuIDA7CiAKIAkvKgogCSAqIFdlIHdhbnQgdG8gc3RhcnQgb2ZmIHdpdGggYWxsIGRldmljZXMgaW4gdGhlIDE6MSBkb21haW4sIGFuZApAQCAtMjMzMiwxMSArMjM0MywxNCBAQAogCX0KIAogCWlmIChpb21tdV9wYXNzX3Rocm91Z2gpCi0JCWlvbW11X2lkZW50aXR5X21hcHBpbmcgPSAxOworCQlpb21tdV9pZGVudGl0eV9tYXBwaW5nIHw9IElERU5UTUFQX0FMTDsKKwogI2lmZGVmIENPTkZJR19ETUFSX0JST0tFTl9HRlhfV0EKLQllbHNlCi0JCWlvbW11X2lkZW50aXR5X21hcHBpbmcgPSAyOworCWlvbW11X2lkZW50aXR5X21hcHBpbmcgfD0gSURFTlRNQVBfR0ZYOwogI2VuZGlmCisKKwljaGVja190eWxlcnNidXJnX2lzb2NoKCk7CisKIAkvKgogCSAqIElmIHBhc3MgdGhyb3VnaCBpcyBub3Qgc2V0IG9yIG5vdCBlbmFibGVkLCBzZXR1cCBjb250ZXh0IGVudHJpZXMgZm9yCiAJICogaWRlbnRpdHkgbWFwcGluZ3MgZm9yIHJtcnIsIGdmeCwgYW5kIGlzYSBhbmQgbWF5IGZhbGwgYmFjayB0byBzdGF0aWMKQEAgLTM2NzAsMyArMzY4NCw2MSBAQAogfQogCiBERUNMQVJFX1BDSV9GSVhVUF9IRUFERVIoUENJX1ZFTkRPUl9JRF9JTlRFTCwgMHgyYTQwLCBxdWlya19pb21tdV9yd2JmKTsKKworLyogT24gVHlsZXJzYnVyZyBjaGlwc2V0cywgc29tZSBCSU9TZXMgaGF2ZSBiZWVuIGtub3duIHRvIGVuYWJsZSB0aGUKKyAgIElTT0NIIERNQVIgdW5pdCBmb3IgdGhlIEF6YWxpYSBzb3VuZCBkZXZpY2UsIGJ1dCBub3QgZ2l2ZSBpdCBhbnkKKyAgIFRMQiBlbnRyaWVzLCB3aGljaCBjYXVzZXMgaXQgdG8gZGVhZGxvY2suIENoZWNrIGZvciB0aGF0LiAgV2UgZG8KKyAgIHRoaXMgaW4gYSBmdW5jdGlvbiBjYWxsZWQgZnJvbSBpbml0X2RtYXJzKCksIGluc3RlYWQgb2YgaW4gYSBQQ0kKKyAgIHF1aXJrLCBiZWNhdXNlIHdlIGRvbid0IHdhbnQgdG8gcHJpbnQgdGhlIG9ibm94aW91cyAiQklPUyBicm9rZW4iCisgICBtZXNzYWdlIGlmIFZULWQgaXMgYWN0dWFsbHkgZGlzYWJsZWQuCisqLworc3RhdGljIHZvaWQgX19pbml0IGNoZWNrX3R5bGVyc2J1cmdfaXNvY2godm9pZCkKK3sKKwlzdHJ1Y3QgcGNpX2RldiAqcGRldjsKKwl1aW50MzJfdCB2dGlzb2NoY3RybDsKKworCS8qIElmIHRoZXJlJ3Mgbm8gQXphbGlhIGluIHRoZSBzeXN0ZW0gYW55d2F5LCBmb3JnZXQgaXQuICovCisJcGRldiA9IHBjaV9nZXRfZGV2aWNlKFBDSV9WRU5ET1JfSURfSU5URUwsIDB4M2EzZSwgTlVMTCk7CisJaWYgKCFwZGV2KQorCQlyZXR1cm47CisJcGNpX2Rldl9wdXQocGRldik7CisKKwkvKiBTeXN0ZW0gTWFuYWdlbWVudCBSZWdpc3RlcnMuIE1pZ2h0IGJlIGhpZGRlbiwgaW4gd2hpY2ggY2FzZQorCSAgIHdlIGNhbid0IGRvIHRoZSBzYW5pdHkgY2hlY2suIEJ1dCB0aGF0J3MgT0ssIGJlY2F1c2UgdGhlCisJICAga25vd24tYnJva2VuIEJJT1NlcyBfZG9uJ3RfIGFjdHVhbGx5IGhpZGUgaXQsIHNvIGZhci4gKi8KKwlwZGV2ID0gcGNpX2dldF9kZXZpY2UoUENJX1ZFTkRPUl9JRF9JTlRFTCwgMHgzNDJlLCBOVUxMKTsKKwlpZiAoIXBkZXYpCisJCXJldHVybjsKKworCWlmIChwY2lfcmVhZF9jb25maWdfZHdvcmQocGRldiwgMHgxODgsICZ2dGlzb2NoY3RybCkpIHsKKwkJcGNpX2Rldl9wdXQocGRldik7CisJCXJldHVybjsKKwl9CisKKwlwY2lfZGV2X3B1dChwZGV2KTsKKworCS8qIElmIEF6YWxpYSBETUEgaXMgcm91dGVkIHRvIHRoZSBub24taXNvY2ggRE1BUiB1bml0LCBmaW5lLiAqLworCWlmICh2dGlzb2NoY3RybCAmIDEpCisJCXJldHVybjsKKworCS8qIERyb3AgYWxsIGJpdHMgb3RoZXIgdGhhbiB0aGUgbnVtYmVyIG9mIFRMQiBlbnRyaWVzICovCisJdnRpc29jaGN0cmwgJj0gMHgxYzsKKworCS8qIElmIHdlIGhhdmUgdGhlIHJlY29tbWVuZGVkIG51bWJlciBvZiBUTEIgZW50cmllcyAoMTYpLCBmaW5lLiAqLworCWlmICh2dGlzb2NoY3RybCA9PSAweDEwKQorCQlyZXR1cm47CisKKwkvKiBaZXJvIFRMQiBlbnRyaWVzPyBZb3UgZ2V0IHRvIHJpZGUgdGhlIHNob3J0IGJ1cyB0byBzY2hvb2wuICovCisJaWYgKCF2dGlzb2NoY3RybCkgeworCQlXQVJOKDEsICJZb3VyIEJJT1MgaXMgYnJva2VuOyBETUEgcm91dGVkIHRvIElTT0NIIERNQVIgdW5pdCBidXQgbm8gVExCIHNwYWNlLlxuIgorCQkgICAgICJCSU9TIHZlbmRvcjogJXM7IFZlcjogJXM7IFByb2R1Y3QgVmVyc2lvbjogJXNcbiIsCisJCSAgICAgZG1pX2dldF9zeXN0ZW1faW5mbyhETUlfQklPU19WRU5ET1IpLAorCQkgICAgIGRtaV9nZXRfc3lzdGVtX2luZm8oRE1JX0JJT1NfVkVSU0lPTiksCisJCSAgICAgZG1pX2dldF9zeXN0ZW1faW5mbyhETUlfUFJPRFVDVF9WRVJTSU9OKSk7CisJCWlvbW11X2lkZW50aXR5X21hcHBpbmcgfD0gSURFTlRNQVBfQVpBTElBOworCQlyZXR1cm47CisJfQorCQorCXByaW50ayhLRVJOX1dBUk5JTkcgIkRNQVI6IFJlY29tbWVuZGVkIFRMQiBlbnRyaWVzIGZvciBJU09DSCB1bml0IGlzIDE2OyB5b3VyIEJJT1Mgc2V0ICVkXG4iLAorCSAgICAgICB2dGlzb2NoY3RybCk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3BjaS9wY2kuYyBiL2RyaXZlcnMvcGNpL3BjaS5jCmluZGV4IDZlZGVjZmYuLjRlNGMyOTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGNpL3BjaS5jCisrKyBiL2RyaXZlcnMvcGNpL3BjaS5jCkBAIC01MTMsNyArNTEzLDExIEBACiAJZWxzZSBpZiAoc3RhdGUgPT0gUENJX0QyIHx8IGRldi0+Y3VycmVudF9zdGF0ZSA9PSBQQ0lfRDIpCiAJCXVkZWxheShQQ0lfUE1fRDJfREVMQVkpOwogCi0JZGV2LT5jdXJyZW50X3N0YXRlID0gc3RhdGU7CisJcGNpX3JlYWRfY29uZmlnX3dvcmQoZGV2LCBkZXYtPnBtX2NhcCArIFBDSV9QTV9DVFJMLCAmcG1jc3IpOworCWRldi0+Y3VycmVudF9zdGF0ZSA9IChwbWNzciAmIFBDSV9QTV9DVFJMX1NUQVRFX01BU0spOworCWlmIChkZXYtPmN1cnJlbnRfc3RhdGUgIT0gc3RhdGUgJiYgcHJpbnRrX3JhdGVsaW1pdCgpKQorCQlkZXZfaW5mbygmZGV2LT5kZXYsICJSZWZ1c2VkIHRvIGNoYW5nZSBwb3dlciBzdGF0ZSwgIgorCQkJImN1cnJlbnRseSBpbiBEJWRcbiIsIGRldi0+Y3VycmVudF9zdGF0ZSk7CiAKIAkvKiBBY2NvcmRpbmcgdG8gc2VjdGlvbiA1LjQuMSBvZiB0aGUgIlBDSSBCVVMgUE9XRVIgTUFOQUdFTUVOVAogCSAqIElOVEVSRkFDRSBTUEVDSUZJQ0FUSU9OLCBSRVYuIDEuMiIsIGEgZGV2aWNlIHRyYW5zaXRpb25pbmcKQEAgLTI1NDIsMTAgKzI1NDYsMTAgQEAKIAogLyoqCiAgKiBwY2lfc2V0X3ZnYV9zdGF0ZSAtIHNldCBWR0EgZGVjb2RlIHN0YXRlIG9uIGRldmljZSBhbmQgcGFyZW50cyBpZiByZXF1ZXN0ZWQKLSAqIEBkZXYgdGhlIFBDSSBkZXZpY2UKLSAqIEBkZWNvZGUgLSB0cnVlID0gZW5hYmxlIGRlY29kaW5nLCBmYWxzZSA9IGRpc2FibGUgZGVjb2RpbmcKLSAqIEBjb21tYW5kX2JpdHMgUENJX0NPTU1BTkRfSU8gYW5kL29yIFBDSV9DT01NQU5EX01FTU9SWQotICogQGNoYW5nZV9icmlkZ2UgLSB0cmF2ZXJzZSBhbmNlc3RvcnMgYW5kIGNoYW5nZSBicmlkZ2VzCisgKiBAZGV2OiB0aGUgUENJIGRldmljZQorICogQGRlY29kZTogdHJ1ZSA9IGVuYWJsZSBkZWNvZGluZywgZmFsc2UgPSBkaXNhYmxlIGRlY29kaW5nCisgKiBAY29tbWFuZF9iaXRzOiBQQ0lfQ09NTUFORF9JTyBhbmQvb3IgUENJX0NPTU1BTkRfTUVNT1JZCisgKiBAY2hhbmdlX2JyaWRnZTogdHJhdmVyc2UgYW5jZXN0b3JzIGFuZCBjaGFuZ2UgYnJpZGdlcwogICovCiBpbnQgcGNpX3NldF92Z2Ffc3RhdGUoc3RydWN0IHBjaV9kZXYgKmRldiwgYm9vbCBkZWNvZGUsCiAJCSAgICAgIHVuc2lnbmVkIGludCBjb21tYW5kX2JpdHMsIGJvb2wgY2hhbmdlX2JyaWRnZSkKQEAgLTI3MTksMTcgKzI3MjMsNiBAQAogCXJldHVybiAxOwogfQogCi1zdGF0aWMgaW50IF9fZGV2aW5pdCBwY2lfaW5pdCh2b2lkKQotewotCXN0cnVjdCBwY2lfZGV2ICpkZXYgPSBOVUxMOwotCi0Jd2hpbGUgKChkZXYgPSBwY2lfZ2V0X2RldmljZShQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCBkZXYpKSAhPSBOVUxMKSB7Ci0JCXBjaV9maXh1cF9kZXZpY2UocGNpX2ZpeHVwX2ZpbmFsLCBkZXYpOwotCX0KLQotCXJldHVybiAwOwotfQotCiBzdGF0aWMgaW50IF9faW5pdCBwY2lfc2V0dXAoY2hhciAqc3RyKQogewogCXdoaWxlIChzdHIpIHsKQEAgLTI3NjcsOCArMjc2MCw2IEBACiB9CiBlYXJseV9wYXJhbSgicGNpIiwgcGNpX3NldHVwKTsKIAotZGV2aWNlX2luaXRjYWxsKHBjaV9pbml0KTsKLQogRVhQT1JUX1NZTUJPTChwY2lfcmVlbmFibGVfZGV2aWNlKTsKIEVYUE9SVF9TWU1CT0wocGNpX2VuYWJsZV9kZXZpY2VfaW8pOwogRVhQT1JUX1NZTUJPTChwY2lfZW5hYmxlX2RldmljZV9tZW0pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcGNpZS9hZXIvYWVyZHJ2LmMgYi9kcml2ZXJzL3BjaS9wY2llL2Flci9hZXJkcnYuYwppbmRleCAyY2U4ZjljLi40MGMzY2M1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2llL2Flci9hZXJkcnYuYworKysgYi9kcml2ZXJzL3BjaS9wY2llL2Flci9hZXJkcnYuYwpAQCAtMTcsNiArMTcsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9lcnJuby5oPgogI2luY2x1ZGUgPGxpbnV4L3BtLmg+CkBAIC01Miw3ICs1Myw3IEBACiAKIHN0YXRpYyBzdHJ1Y3QgcGNpZV9wb3J0X3NlcnZpY2VfZHJpdmVyIGFlcmRyaXZlciA9IHsKIAkubmFtZQkJPSAiYWVyIiwKLQkucG9ydF90eXBlCT0gUENJRV9BTllfUE9SVCwKKwkucG9ydF90eXBlCT0gUENJRV9SQ19QT1JULAogCS5zZXJ2aWNlCT0gUENJRV9QT1JUX1NFUlZJQ0VfQUVSLAogCiAJLnByb2JlCQk9IGFlcl9wcm9iZSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3BjaWUvcG9ydGRydl9wY2kuYyBiL2RyaXZlcnMvcGNpL3BjaWUvcG9ydGRydl9wY2kuYwppbmRleCA2ZGY1Yzk4Li5mNjM1ZTQ3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9wY2llL3BvcnRkcnZfcGNpLmMKKysrIGIvZHJpdmVycy9wY2kvcGNpZS9wb3J0ZHJ2X3BjaS5jCkBAIC0zMCw3ICszMCw2IEBACiBNT0RVTEVfTElDRU5TRSgiR1BMIik7CiAKIC8qIGdsb2JhbCBkYXRhICovCi1zdGF0aWMgY29uc3QgY2hhciBkZXZpY2VfbmFtZVtdID0gInBjaWVwb3J0LWRyaXZlciI7CiAKIHN0YXRpYyBpbnQgcGNpZV9wb3J0ZHJ2X3Jlc3RvcmVfY29uZmlnKHN0cnVjdCBwY2lfZGV2ICpkZXYpCiB7CkBAIC0yNjIsNyArMjYxLDcgQEAKIH07CiAKIHN0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciBwY2llX3BvcnRkcml2ZXIgPSB7Ci0JLm5hbWUJCT0gKGNoYXIgKilkZXZpY2VfbmFtZSwKKwkubmFtZQkJPSAicGNpZXBvcnQiLAogCS5pZF90YWJsZQk9ICZwb3J0X3BjaV9pZHNbMF0sCiAKIAkucHJvYmUJCT0gcGNpZV9wb3J0ZHJ2X3Byb2JlLApkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvcXVpcmtzLmMgYi9kcml2ZXJzL3BjaS9xdWlya3MuYwppbmRleCA2MDk5ZmFjLi4yNDVkMmNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9xdWlya3MuYworKysgYi9kcml2ZXJzL3BjaS9xdWlya3MuYwpAQCAtNjcwLDYgKzY3MCwyNSBAQAogfQogREVDTEFSRV9QQ0lfRklYVVBfSEVBREVSKFBDSV9WRU5ET1JfSURfVklBLAlQQ0lfREVWSUNFX0lEX1ZJQV84MjM1LAlxdWlya192dDgyMzVfYWNwaSk7CiAKKy8qCisgKiBUSSBYSU8yMDAwYSBQQ0llLVBDSSBCcmlkZ2UgZXJyb25lb3VzbHkgcmVwb3J0cyBpdCBzdXBwb3J0cyBmYXN0IGJhY2stdG8tYmFjazoKKyAqCURpc2FibGUgZmFzdCBiYWNrLXRvLWJhY2sgb24gdGhlIHNlY29uZGFyeSBidXMgc2VnbWVudAorICovCitzdGF0aWMgdm9pZCBfX2RldmluaXQgcXVpcmtfeGlvMjAwMGEoc3RydWN0IHBjaV9kZXYgKmRldikKK3sKKwlzdHJ1Y3QgcGNpX2RldiAqcGRldjsKKwl1MTYgY29tbWFuZDsKKworCWRldl93YXJuKCZkZXYtPmRldiwgIlRJIFhJTzIwMDBhIHF1aXJrIGRldGVjdGVkOyAiCisJCSJzZWNvbmRhcnkgYnVzIGZhc3QgYmFjay10by1iYWNrIHRyYW5zZmVycyBkaXNhYmxlZFxuIik7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShwZGV2LCAmZGV2LT5zdWJvcmRpbmF0ZS0+ZGV2aWNlcywgYnVzX2xpc3QpIHsKKwkJcGNpX3JlYWRfY29uZmlnX3dvcmQocGRldiwgUENJX0NPTU1BTkQsICZjb21tYW5kKTsKKwkJaWYgKGNvbW1hbmQgJiBQQ0lfQ09NTUFORF9GQVNUX0JBQ0spCisJCQlwY2lfd3JpdGVfY29uZmlnX3dvcmQocGRldiwgUENJX0NPTU1BTkQsIGNvbW1hbmQgJiB+UENJX0NPTU1BTkRfRkFTVF9CQUNLKTsKKwl9Cit9CitERUNMQVJFX1BDSV9GSVhVUF9GSU5BTChQQ0lfVkVORE9SX0lEX1RJLCBQQ0lfREVWSUNFX0lEX1RJX1hJTzIwMDBBLAorCQkJcXVpcmtfeGlvMjAwMGEpOwogCiAjaWZkZWYgQ09ORklHX1g4Nl9JT19BUElDIAogCkBAIC05OTAsNyArMTAwOSw3IEBACiAKIHN0YXRpYyB2b2lkIF9fZGV2aW5pdCBxdWlya19hbWRfaWRlX21vZGUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCiB7Ci0JLyogc2V0IFNCWDAwIFNBVEEgaW4gSURFIG1vZGUgdG8gQUhDSSBtb2RlICovCisJLyogc2V0IFNCWDAwL0h1ZHNvbi0yIFNBVEEgaW4gSURFIG1vZGUgdG8gQUhDSSBtb2RlICovCiAJdTggdG1wOwogCiAJcGNpX3JlYWRfY29uZmlnX2J5dGUocGRldiwgUENJX0NMQVNTX0RFVklDRSwgJnRtcCk7CkBAIC0xMDA5LDggKzEwMjgsOCBAQAogREVDTEFSRV9QQ0lfRklYVVBfUkVTVU1FX0VBUkxZKFBDSV9WRU5ET1JfSURfQVRJLCBQQ0lfREVWSUNFX0lEX0FUSV9JWFA2MDBfU0FUQSwgcXVpcmtfYW1kX2lkZV9tb2RlKTsKIERFQ0xBUkVfUENJX0ZJWFVQX0hFQURFUihQQ0lfVkVORE9SX0lEX0FUSSwgUENJX0RFVklDRV9JRF9BVElfSVhQNzAwX1NBVEEsIHF1aXJrX2FtZF9pZGVfbW9kZSk7CiBERUNMQVJFX1BDSV9GSVhVUF9SRVNVTUVfRUFSTFkoUENJX1ZFTkRPUl9JRF9BVEksIFBDSV9ERVZJQ0VfSURfQVRJX0lYUDcwMF9TQVRBLCBxdWlya19hbWRfaWRlX21vZGUpOwotREVDTEFSRV9QQ0lfRklYVVBfSEVBREVSKFBDSV9WRU5ET1JfSURfQU1ELCBQQ0lfREVWSUNFX0lEX0FNRF9TQjkwMF9TQVRBX0lERSwgcXVpcmtfYW1kX2lkZV9tb2RlKTsKLURFQ0xBUkVfUENJX0ZJWFVQX1JFU1VNRV9FQVJMWShQQ0lfVkVORE9SX0lEX0FNRCwgUENJX0RFVklDRV9JRF9BTURfU0I5MDBfU0FUQV9JREUsIHF1aXJrX2FtZF9pZGVfbW9kZSk7CitERUNMQVJFX1BDSV9GSVhVUF9IRUFERVIoUENJX1ZFTkRPUl9JRF9BTUQsIFBDSV9ERVZJQ0VfSURfQU1EX0hVRFNPTjJfU0FUQV9JREUsIHF1aXJrX2FtZF9pZGVfbW9kZSk7CitERUNMQVJFX1BDSV9GSVhVUF9SRVNVTUVfRUFSTFkoUENJX1ZFTkRPUl9JRF9BTUQsIFBDSV9ERVZJQ0VfSURfQU1EX0hVRFNPTjJfU0FUQV9JREUsIHF1aXJrX2FtZF9pZGVfbW9kZSk7CiAKIC8qCiAgKglTZXJ2ZXJ3b3JrcyBDU0I1IElERSBkb2VzIG5vdCBmdWxseSBzdXBwb3J0IG5hdGl2ZSBtb2RlCkBAIC0yNTcyLDYgKzI1OTEsMTkgQEAKIAl9CiAJcGNpX2RvX2ZpeHVwcyhkZXYsIHN0YXJ0LCBlbmQpOwogfQorCitzdGF0aWMgaW50IF9faW5pdCBwY2lfYXBwbHlfZmluYWxfcXVpcmtzKHZvaWQpCit7CisJc3RydWN0IHBjaV9kZXYgKmRldiA9IE5VTEw7CisKKwl3aGlsZSAoKGRldiA9IHBjaV9nZXRfZGV2aWNlKFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIGRldikpICE9IE5VTEwpIHsKKwkJcGNpX2ZpeHVwX2RldmljZShwY2lfZml4dXBfZmluYWwsIGRldik7CisJfQorCisJcmV0dXJuIDA7Cit9CisKK2ZzX2luaXRjYWxsX3N5bmMocGNpX2FwcGx5X2ZpbmFsX3F1aXJrcyk7CiAjZWxzZQogdm9pZCBwY2lfZml4dXBfZGV2aWNlKGVudW0gcGNpX2ZpeHVwX3Bhc3MgcGFzcywgc3RydWN0IHBjaV9kZXYgKmRldikge30KICNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9wY2kvc2V0dXAtYnVzLmMgYi9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYwppbmRleCBjYjFhMDI3Li4wOTU5NDMwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYworKysgYi9kcml2ZXJzL3BjaS9zZXR1cC1idXMuYwpAQCAtMjk5LDggKzI5OSwxNyBAQAogCQlyID0gYnVzLT5yZXNvdXJjZVtpXTsKIAkJaWYgKHIgPT0gJmlvcG9ydF9yZXNvdXJjZSB8fCByID09ICZpb21lbV9yZXNvdXJjZSkKIAkJCWNvbnRpbnVlOwotCQlpZiAociAmJiAoci0+ZmxhZ3MgJiB0eXBlX21hc2spID09IHR5cGUgJiYgIXItPnBhcmVudCkKLQkJCXJldHVybiByOworCQlpZiAociAmJiAoci0+ZmxhZ3MgJiB0eXBlX21hc2spID09IHR5cGUpIHsKKwkJCWlmICghci0+cGFyZW50KQorCQkJCXJldHVybiByOworCQkJLyoKKwkJCSAqIGlmIHRoZXJlIGlzIG5vIGNoaWxkIHVuZGVyIHRoYXQsIHdlIHNob3VsZCByZWxlYXNlCisJCQkgKiBhbmQgdXNlIGl0LiBkb24ndCBuZWVkIHRvIHJlc2V0IGl0LCBwYnVzX3NpemVfKiB3aWxsCisJCQkgKiBzZXQgaXQgYWdhaW4KKwkJCSAqLworCQkJaWYgKCFyLT5jaGlsZCAmJiAhcmVsZWFzZV9yZXNvdXJjZShyKSkKKwkJCQlyZXR1cm4gcjsKKwkJfQogCX0KIAlyZXR1cm4gTlVMTDsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGNpL3NldHVwLXJlcy5jIGIvZHJpdmVycy9wY2kvc2V0dXAtcmVzLmMKaW5kZXggNzA2ZjgyZC4uYzU0NTI2YiAxMDA2NDQKLS0tIGEvZHJpdmVycy9wY2kvc2V0dXAtcmVzLmMKKysrIGIvZHJpdmVycy9wY2kvc2V0dXAtcmVzLmMKQEAgLTIwNSw0MyArMjA1LDYgQEAKIAlyZXR1cm4gcmV0OwogfQogCi0jaWYgMAotaW50IHBjaV9hc3NpZ25fcmVzb3VyY2VfZml4ZWQoc3RydWN0IHBjaV9kZXYgKmRldiwgaW50IHJlc25vKQotewotCXN0cnVjdCBwY2lfYnVzICpidXMgPSBkZXYtPmJ1czsKLQlzdHJ1Y3QgcmVzb3VyY2UgKnJlcyA9IGRldi0+cmVzb3VyY2UgKyByZXNubzsKLQl1bnNpZ25lZCBpbnQgdHlwZV9tYXNrOwotCWludCBpLCByZXQgPSAtRUJVU1k7Ci0KLQl0eXBlX21hc2sgPSBJT1JFU09VUkNFX0lPIHwgSU9SRVNPVVJDRV9NRU0gfCBJT1JFU09VUkNFX1BSRUZFVENIOwotCi0JZm9yIChpID0gMDsgaSA8IFBDSV9CVVNfTlVNX1JFU09VUkNFUzsgaSsrKSB7Ci0JCXN0cnVjdCByZXNvdXJjZSAqciA9IGJ1cy0+cmVzb3VyY2VbaV07Ci0JCWlmICghcikKLQkJCWNvbnRpbnVlOwotCi0JCS8qIHR5cGVfbWFzayBtdXN0IG1hdGNoICovCi0JCWlmICgocmVzLT5mbGFncyBeIHItPmZsYWdzKSAmIHR5cGVfbWFzaykKLQkJCWNvbnRpbnVlOwotCi0JCXJldCA9IHJlcXVlc3RfcmVzb3VyY2UociwgcmVzKTsKLQotCQlpZiAocmV0ID09IDApCi0JCQlicmVhazsKLQl9Ci0KLQlpZiAocmV0KSB7Ci0JCWRldl9lcnIoJmRldi0+ZGV2LCAiQkFSICVkOiBjYW4ndCBhbGxvY2F0ZSAlcyByZXNvdXJjZSAlcFJcbiIsCi0JCQlyZXNubywgcmVzLT5mbGFncyAmIElPUkVTT1VSQ0VfSU8gPyAiSS9PIiA6ICJtZW0iLCByZXMpOwotCX0gZWxzZSBpZiAocmVzbm8gPCBQQ0lfQlJJREdFX1JFU09VUkNFUykgewotCQlwY2lfdXBkYXRlX3Jlc291cmNlKGRldiwgcmVzbm8pOwotCX0KLQotCXJldHVybiByZXQ7Ci19Ci1FWFBPUlRfU1lNQk9MX0dQTChwY2lfYXNzaWduX3Jlc291cmNlX2ZpeGVkKTsKLSNlbmRpZgotCiAvKiBTb3J0IHJlc291cmNlcyBieSBhbGlnbm1lbnQgKi8KIHZvaWQgcGRldl9zb3J0X3Jlc291cmNlcyhzdHJ1Y3QgcGNpX2RldiAqZGV2LCBzdHJ1Y3QgcmVzb3VyY2VfbGlzdCAqaGVhZCkKIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2VlZXBjLWxhcHRvcC5jIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvZWVlcGMtbGFwdG9wLmMKaW5kZXggNzQ5ZTIxMC4uZDM3OWU3NCAxMDA2NDQKLS0tIGEvZHJpdmVycy9wbGF0Zm9ybS94ODYvZWVlcGMtbGFwdG9wLmMKKysrIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvZWVlcGMtbGFwdG9wLmMKQEAgLTE1MCw2ICsxNTAsOCBAQAogLyogVGhlIGFjdHVhbCBkZXZpY2UgdGhlIGRyaXZlciBiaW5kcyB0byAqLwogc3RhdGljIHN0cnVjdCBlZWVwY19ob3RrICplaG90azsKIAorc3RhdGljIHZvaWQgZWVlcGNfcmZraWxsX2hvdHBsdWcoYm9vbCByZWFsKTsKKwogLyogUGxhdGZvcm0gZGV2aWNlL2RyaXZlciAqLwogc3RhdGljIGludCBlZWVwY19ob3RrX3RoYXcoc3RydWN0IGRldmljZSAqZGV2aWNlKTsKIHN0YXRpYyBpbnQgZWVlcGNfaG90a19yZXN0b3JlKHN0cnVjdCBkZXZpY2UgKmRldmljZSk7CkBAIC0zNDMsMTQgKzM0NSwyMyBAQAogc3RhdGljIGludCBlZWVwY19yZmtpbGxfc2V0KHZvaWQgKmRhdGEsIGJvb2wgYmxvY2tlZCkKIHsKIAl1bnNpZ25lZCBsb25nIGFzbCA9ICh1bnNpZ25lZCBsb25nKWRhdGE7Ci0JcmV0dXJuIHNldF9hY3BpKGFzbCwgIWJsb2NrZWQpOworCWludCByZXQ7CisKKwlpZiAoYXNsICE9IENNX0FTTF9XTEFOKQorCQlyZXR1cm4gc2V0X2FjcGkoYXNsLCAhYmxvY2tlZCk7CisKKwkvKiBoYWNrIHRvIGF2b2lkIHBhbmljIHdpdGggcnQyODYwc3RhICovCisJaWYgKGJsb2NrZWQpCisJCWVlZXBjX3Jma2lsbF9ob3RwbHVnKGZhbHNlKTsKKwlyZXQgPSBzZXRfYWNwaShhc2wsICFibG9ja2VkKTsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHJma2lsbF9vcHMgZWVlcGNfcmZraWxsX29wcyA9IHsKIAkuc2V0X2Jsb2NrID0gZWVlcGNfcmZraWxsX3NldCwKIH07CiAKLXN0YXRpYyB2b2lkIF9faW5pdCBlZWVwY19lbmFibGVfY2FtZXJhKHZvaWQpCitzdGF0aWMgdm9pZCBfX2RldmluaXQgZWVlcGNfZW5hYmxlX2NhbWVyYSh2b2lkKQogewogCS8qCiAJICogSWYgdGhlIGZvbGxvd2luZyBjYWxsIHRvIHNldF9hY3BpKCkgZmFpbHMsIGl0J3MgYmVjYXVzZSB0aGVyZSdzIG5vCkBAIC02NDMsMTMgKzY1NCwxMyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCBlZWVwY19yZmtpbGxfaG90cGx1Zyh2b2lkKQorc3RhdGljIHZvaWQgZWVlcGNfcmZraWxsX2hvdHBsdWcoYm9vbCByZWFsKQogewogCXN0cnVjdCBwY2lfZGV2ICpkZXY7CiAJc3RydWN0IHBjaV9idXMgKmJ1czsKLQlib29sIGJsb2NrZWQgPSBlZWVwY193bGFuX3Jma2lsbF9ibG9ja2VkKCk7CisJYm9vbCBibG9ja2VkID0gcmVhbCA/IGVlZXBjX3dsYW5fcmZraWxsX2Jsb2NrZWQoKSA6IHRydWU7CiAKLQlpZiAoZWhvdGstPndsYW5fcmZraWxsKQorCWlmIChyZWFsICYmIGVob3RrLT53bGFuX3Jma2lsbCkKIAkJcmZraWxsX3NldF9zd19zdGF0ZShlaG90ay0+d2xhbl9yZmtpbGwsIGJsb2NrZWQpOwogCiAJbXV0ZXhfbG9jaygmZWhvdGstPmhvdHBsdWdfbG9jayk7CkBAIC02OTIsNyArNzAzLDcgQEAKIAlpZiAoZXZlbnQgIT0gQUNQSV9OT1RJRllfQlVTX0NIRUNLKQogCQlyZXR1cm47CiAKLQllZWVwY19yZmtpbGxfaG90cGx1ZygpOworCWVlZXBjX3Jma2lsbF9ob3RwbHVnKHRydWUpOwogfQogCiBzdGF0aWMgdm9pZCBlZWVwY19ob3RrX25vdGlmeShzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSwgdTMyIGV2ZW50KQpAQCAtODUwLDcgKzg2MSw3IEBACiB7CiAJLyogUmVmcmVzaCBib3RoIHdsYW4gcmZraWxsIHN0YXRlIGFuZCBwY2kgaG90cGx1ZyAqLwogCWlmIChlaG90ay0+d2xhbl9yZmtpbGwpCi0JCWVlZXBjX3Jma2lsbF9ob3RwbHVnKCk7CisJCWVlZXBjX3Jma2lsbF9ob3RwbHVnKHRydWUpOwogCiAJaWYgKGVob3RrLT5ibHVldG9vdGhfcmZraWxsKQogCQlyZmtpbGxfc2V0X3N3X3N0YXRlKGVob3RrLT5ibHVldG9vdGhfcmZraWxsLApAQCAtOTkzLDcgKzEwMDQsNyBAQAogCSAqIFJlZnJlc2ggcGNpIGhvdHBsdWcgaW4gY2FzZSB0aGUgcmZraWxsIHN0YXRlIHdhcyBjaGFuZ2VkIGFmdGVyCiAJICogZWVlcGNfdW5yZWdpc3Rlcl9yZmtpbGxfbm90aWZpZXIoKQogCSAqLwotCWVlZXBjX3Jma2lsbF9ob3RwbHVnKCk7CisJZWVlcGNfcmZraWxsX2hvdHBsdWcodHJ1ZSk7CiAJaWYgKGVob3RrLT5ob3RwbHVnX3Nsb3QpCiAJCXBjaV9ocF9kZXJlZ2lzdGVyKGVob3RrLT5ob3RwbHVnX3Nsb3QpOwogCkBAIC0xMTA5LDcgKzExMjAsNyBAQAogCSAqIFJlZnJlc2ggcGNpIGhvdHBsdWcgaW4gY2FzZSB0aGUgcmZraWxsIHN0YXRlIHdhcyBjaGFuZ2VkIGR1cmluZwogCSAqIHNldHVwLgogCSAqLwotCWVlZXBjX3Jma2lsbF9ob3RwbHVnKCk7CisJZWVlcGNfcmZraWxsX2hvdHBsdWcodHJ1ZSk7CiAKIGV4aXQ6CiAJaWYgKHJlc3VsdCAmJiByZXN1bHQgIT0gLUVOT0RFVikKQEAgLTExODksNyArMTIwMCw3IEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgZWVlcGNfaG90a19hZGQoc3RydWN0IGFjcGlfZGV2aWNlICpkZXZpY2UpCitzdGF0aWMgaW50IF9fZGV2aW5pdCBlZWVwY19ob3RrX2FkZChzdHJ1Y3QgYWNwaV9kZXZpY2UgKmRldmljZSkKIHsKIAlzdHJ1Y3QgZGV2aWNlICpkZXY7CiAJaW50IHJlc3VsdDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2Z1aml0c3UtbGFwdG9wLmMgYi9kcml2ZXJzL3BsYXRmb3JtL3g4Ni9mdWppdHN1LWxhcHRvcC5jCmluZGV4IGYzNWFlZTUuLmJjZDRiYTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcGxhdGZvcm0veDg2L2Z1aml0c3UtbGFwdG9wLmMKKysrIGIvZHJpdmVycy9wbGF0Zm9ybS94ODYvZnVqaXRzdS1sYXB0b3AuYwpAQCAtOTQ0LDcgKzk0NCw3IEBACiAJc3RydWN0IGZ1aml0c3VfaG90a2V5X3QgKmZ1aml0c3VfaG90a2V5ID0gYWNwaV9kcml2ZXJfZGF0YShkZXZpY2UpOwogCXN0cnVjdCBpbnB1dF9kZXYgKmlucHV0ID0gZnVqaXRzdV9ob3RrZXktPmlucHV0OwogCi0jaWZkZWYgQ09ORklHX0xFRFNfQ0xBU1MKKyNpZiBkZWZpbmVkKENPTkZJR19MRURTX0NMQVNTKSB8fCBkZWZpbmVkKENPTkZJR19MRURTX0NMQVNTX01PRFVMRSkKIAlpZiAoZnVqaXRzdV9ob3RrZXktPmxvZ29sYW1wX3JlZ2lzdGVyZWQpCiAJCWxlZF9jbGFzc2Rldl91bnJlZ2lzdGVyKCZsb2dvbGFtcF9sZWQpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3J0Yy9pbnRlcmZhY2UuYyBiL2RyaXZlcnMvcnRjL2ludGVyZmFjZS5jCmluZGV4IDRjZGIzMWEuLmEwYzgxNjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvcnRjL2ludGVyZmFjZS5jCisrKyBiL2RyaXZlcnMvcnRjL2ludGVyZmFjZS5jCkBAIC0xMiw2ICsxMiw3IEBACiAqLwogCiAjaW5jbHVkZSA8bGludXgvcnRjLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9sb2cyLmg+CiAKIGludCBydGNfcmVhZF90aW1lKHN0cnVjdCBydGNfZGV2aWNlICpydGMsIHN0cnVjdCBydGNfdGltZSAqdG0pCmRpZmYgLS1naXQgYS9kcml2ZXJzL3J0Yy9ydGMtZGV2LmMgYi9kcml2ZXJzL3J0Yy9ydGMtZGV2LmMKaW5kZXggOGExMWRlOS4uNjIyMjdjZCAxMDA2NDQKLS0tIGEvZHJpdmVycy9ydGMvcnRjLWRldi5jCisrKyBiL2RyaXZlcnMvcnRjL3J0Yy1kZXYuYwpAQCAtMTMsNiArMTMsNyBAQAogCiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcnRjLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlICJydGMtY29yZS5oIgogCiBzdGF0aWMgZGV2X3QgcnRjX2RldnQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZC5jIGIvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2QuYwppbmRleCBkYWQwNDQ5Li5hYWNjYzhlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZC5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkLmMKQEAgLTI1MDgsOCArMjUwOCw2IEBACiAJZGV2aWNlLT5zdG9wcGVkICY9IH5EQVNEX1VOUkVTVU1FRF9QTTsKIAogCWRhc2Rfc2NoZWR1bGVfZGV2aWNlX2JoKGRldmljZSk7Ci0JaWYgKGRldmljZS0+YmxvY2spCi0JCWRhc2Rfc2NoZWR1bGVfYmxvY2tfYmgoZGV2aWNlLT5ibG9jayk7CiAKIAlpZiAoZGV2aWNlLT5kaXNjaXBsaW5lLT5yZXN0b3JlKQogCQlyYyA9IGRldmljZS0+ZGlzY2lwbGluZS0+cmVzdG9yZShkZXZpY2UpOwpAQCAtMjUyMCw2ICsyNTE4LDkgQEAKIAkJICovCiAJCWRldmljZS0+c3RvcHBlZCB8PSBEQVNEX1VOUkVTVU1FRF9QTTsKIAorCWlmIChkZXZpY2UtPmJsb2NrKQorCQlkYXNkX3NjaGVkdWxlX2Jsb2NrX2JoKGRldmljZS0+YmxvY2spOworCiAJZGFzZF9wdXRfZGV2aWNlKGRldmljZSk7CiAJcmV0dXJuIDA7CiB9CkBAIC0yNTMyLDYgKzI1MzMsNyBAQAogewogCXN0cnVjdCBkYXNkX2Njd19yZXEgKmNxcjsKIAlzdHJ1Y3QgY2N3MSAqY2N3OworCXVuc2lnbmVkIGxvbmcgKmlkYXc7CiAKIAljcXIgPSBkYXNkX3NtYWxsb2NfcmVxdWVzdChtYWdpYywgMSAvKiBSREMgKi8sIHJkY19idWZmZXJfc2l6ZSwgZGV2aWNlKTsKIApAQCAtMjU0NSw5ICsyNTQ3LDE3IEBACiAKIAljY3cgPSBjcXItPmNwYWRkcjsKIAljY3ctPmNtZF9jb2RlID0gQ0NXX0NNRF9SREM7Ci0JY2N3LT5jZGEgPSAoX191MzIpKGFkZHJfdClyZGNfYnVmZmVyOwotCWNjdy0+Y291bnQgPSByZGNfYnVmZmVyX3NpemU7CisJaWYgKGlkYWxfaXNfbmVlZGVkKHJkY19idWZmZXIsIHJkY19idWZmZXJfc2l6ZSkpIHsKKwkJaWRhdyA9ICh1bnNpZ25lZCBsb25nICopIChjcXItPmRhdGEpOworCQljY3ctPmNkYSA9IChfX3UzMikoYWRkcl90KSBpZGF3OworCQljY3ctPmZsYWdzID0gQ0NXX0ZMQUdfSURBOworCQlpZGF3ID0gaWRhbF9jcmVhdGVfd29yZHMoaWRhdywgcmRjX2J1ZmZlciwgcmRjX2J1ZmZlcl9zaXplKTsKKwl9IGVsc2UgeworCQljY3ctPmNkYSA9IChfX3UzMikoYWRkcl90KSByZGNfYnVmZmVyOworCQljY3ctPmZsYWdzID0gMDsKKwl9CiAKKwljY3ctPmNvdW50ID0gcmRjX2J1ZmZlcl9zaXplOwogCWNxci0+c3RhcnRkZXYgPSBkZXZpY2U7CiAJY3FyLT5tZW1kZXYgPSBkZXZpY2U7CiAJY3FyLT5leHBpcmVzID0gMTAqSFo7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF9lY2tkLmMgYi9kcml2ZXJzL3MzOTAvYmxvY2svZGFzZF9lY2tkLmMKaW5kZXggYWIzNTIxNy4uNDE3Yjk3YyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2Jsb2NrL2Rhc2RfZWNrZC5jCisrKyBiL2RyaXZlcnMvczM5MC9ibG9jay9kYXNkX2Vja2QuYwpAQCAtMjMzOCw2ICsyMzM4LDggQEAKIAkvKiBDYWxjdWxhdGUgbnVtYmVyIG9mIGJsb2Nrcy9yZWNvcmRzIHBlciB0cmFjay4gKi8KIAlibGtzaXplID0gYmxvY2stPmJwX2Jsb2NrOwogCWJsa19wZXJfdHJrID0gcmVjc19wZXJfdHJhY2soJnByaXZhdGUtPnJkY19kYXRhLCAwLCBibGtzaXplKTsKKwlpZiAoYmxrX3Blcl90cmsgPT0gMCkKKwkJcmV0dXJuIEVSUl9QVFIoLUVJTlZBTCk7CiAJLyogQ2FsY3VsYXRlIHJlY29yZCBpZCBvZiBmaXJzdCBhbmQgbGFzdCBibG9jay4gKi8KIAlmaXJzdF9yZWMgPSBmaXJzdF90cmsgPSBibGtfcnFfcG9zKHJlcSkgPj4gYmxvY2stPnMyYl9zaGlmdDsKIAlmaXJzdF9vZmZzID0gc2VjdG9yX2RpdihmaXJzdF90cmssIGJsa19wZXJfdHJrKTsKQEAgLTMyMTEsOCArMzIxMywxMCBAQAogaW50IGRhc2RfZWNrZF9yZXN0b3JlX2RldmljZShzdHJ1Y3QgZGFzZF9kZXZpY2UgKmRldmljZSkKIHsKIAlzdHJ1Y3QgZGFzZF9lY2tkX3ByaXZhdGUgKnByaXZhdGU7CisJc3RydWN0IGRhc2RfZWNrZF9jaGFyYWN0ZXJpc3RpY3MgdGVtcF9yZGNfZGF0YTsKIAlpbnQgaXNfa25vd24sIHJjOwogCXN0cnVjdCBkYXNkX3VpZCB0ZW1wX3VpZDsKKwl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJcHJpdmF0ZSA9IChzdHJ1Y3QgZGFzZF9lY2tkX3ByaXZhdGUgKikgZGV2aWNlLT5wcml2YXRlOwogCkBAIC0zMjI1LDcgKzMyMjksOCBAQAogCXJjID0gZGFzZF9lY2tkX2dlbmVyYXRlX3VpZChkZXZpY2UsICZwcml2YXRlLT51aWQpOwogCWRhc2RfZ2V0X3VpZChkZXZpY2UtPmNkZXYsICZ0ZW1wX3VpZCk7CiAJaWYgKG1lbWNtcCgmcHJpdmF0ZS0+dWlkLCAmdGVtcF91aWQsIHNpemVvZihzdHJ1Y3QgZGFzZF91aWQpKSAhPSAwKQotCQlkZXZfZXJyKCZkZXZpY2UtPmNkZXYtPmRldiwgIlRoZSBVSUQgb2YgdGhlIERBU0QgaGFzIGNoYW5nZWRcbiIpOworCQlkZXZfZXJyKCZkZXZpY2UtPmNkZXYtPmRldiwgIlRoZSBVSUQgb2YgdGhlIERBU0QgaGFzICIKKwkJCSJjaGFuZ2VkXG4iKTsKIAlpZiAocmMpCiAJCWdvdG8gb3V0X2VycjsKIAlkYXNkX3NldF91aWQoZGV2aWNlLT5jZGV2LCAmcHJpdmF0ZS0+dWlkKTsKQEAgLTMyNDUsMTUgKzMyNTAsMTcgQEAKIAlkYXNkX2Vja2RfcmVhZF9mZWF0dXJlcyhkZXZpY2UpOwogCiAJLyogUmVhZCBEZXZpY2UgQ2hhcmFjdGVyaXN0aWNzICovCi0JbWVtc2V0KCZwcml2YXRlLT5yZGNfZGF0YSwgMCwgc2l6ZW9mKHByaXZhdGUtPnJkY19kYXRhKSk7CiAJcmMgPSBkYXNkX2dlbmVyaWNfcmVhZF9kZXZfY2hhcnMoZGV2aWNlLCBEQVNEX0VDS0RfTUFHSUMsCi0JCQkJCSAmcHJpdmF0ZS0+cmRjX2RhdGEsIDY0KTsKKwkJCQkJICZ0ZW1wX3JkY19kYXRhLCA2NCk7CiAJaWYgKHJjKSB7CiAJCURCRl9FVkVOVChEQkZfV0FSTklORywKIAkJCSAgIlJlYWQgZGV2aWNlIGNoYXJhY3RlcmlzdGljcyBmYWlsZWQsIHJjPSVkIGZvciAiCiAJCQkgICJkZXZpY2U6ICVzIiwgcmMsIGRldl9uYW1lKCZkZXZpY2UtPmNkZXYtPmRldikpOwogCQlnb3RvIG91dF9lcnI7CiAJfQorCXNwaW5fbG9ja19pcnFzYXZlKGdldF9jY3dkZXZfbG9jayhkZXZpY2UtPmNkZXYpLCBmbGFncyk7CisJbWVtY3B5KCZwcml2YXRlLT5yZGNfZGF0YSwgJnRlbXBfcmRjX2RhdGEsIHNpemVvZih0ZW1wX3JkY19kYXRhKSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZShnZXRfY2N3ZGV2X2xvY2soZGV2aWNlLT5jZGV2KSwgZmxhZ3MpOwogCiAJLyogYWRkIGRldmljZSB0byBhbGlhcyBtYW5hZ2VtZW50ICovCiAJZGFzZF9hbGlhc19hZGRfZGV2aWNlKGRldmljZSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvY2hhci9yYXczMjcwLmMgYi9kcml2ZXJzL3MzOTAvY2hhci9yYXczMjcwLmMKaW5kZXggZDZhMDIyZi4uNjJkZGY1MiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2NoYXIvcmF3MzI3MC5jCisrKyBiL2RyaXZlcnMvczM5MC9jaGFyL3JhdzMyNzAuYwpAQCAtMTM2MSwxMSArMTM2MSwxMyBAQAogCiB2b2lkIHJhdzMyNzBfcG1fdW5mcmVlemUoc3RydWN0IHJhdzMyNzBfdmlldyAqdmlldykKIHsKKyNpZmRlZiBDT05GSUdfVE4zMjcwX0NPTlNPTEUKIAlzdHJ1Y3QgcmF3MzI3MCAqcnA7CiAKIAlycCA9IHZpZXctPmRldjsKIAlpZiAocnAgJiYgdGVzdF9iaXQoUkFXMzI3MF9GTEFHU19GUk9aRU4sICZycC0+ZmxhZ3MpKQogCQljY3dfZGV2aWNlX2ZvcmNlX2NvbnNvbGUoKTsKKyNlbmRpZgogfQogCiBzdGF0aWMgc3RydWN0IGNjd19kZXZpY2VfaWQgcmF3MzI3MF9pZFtdID0gewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NoYXIvc2NscF9hc3luYy5jIGIvZHJpdmVycy9zMzkwL2NoYXIvc2NscF9hc3luYy5jCmluZGV4IGRhYWVjMTguLmE0ZjY4ZTUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaGFyL3NjbHBfYXN5bmMuYworKysgYi9kcml2ZXJzL3MzOTAvY2hhci9zY2xwX2FzeW5jLmMKQEAgLTYyLDcgKzYyLDcgQEAKIAkucHJpb3JpdHkgPSBJTlRfTUFYLAogfTsKIAotc3RhdGljIGludCBwcm9jX2hhbmRsZXJfY2FsbGhvbWUoY3RsX3RhYmxlICpjdGwsIGludCB3cml0ZSwgc3RydWN0IGZpbGUgKmZpbHAsCitzdGF0aWMgaW50IHByb2NfaGFuZGxlcl9jYWxsaG9tZShzdHJ1Y3QgY3RsX3RhYmxlICpjdGwsIGludCB3cml0ZSwKIAkJCQkgdm9pZCBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90ICpjb3VudCwKIAkJCQkgbG9mZl90ICpwcG9zKQogewpAQCAtMTAwLDcgKzEwMCw3IEBACiAJewogCQkucHJvY25hbWUJPSAiY2FsbGhvbWUiLAogCQkubW9kZQkJPSAwNjQ0LAotCQkucHJvY19oYW5kbGVyCT0gJnByb2NfaGFuZGxlcl9jYWxsaG9tZSwKKwkJLnByb2NfaGFuZGxlcgk9IHByb2NfaGFuZGxlcl9jYWxsaG9tZSwKIAl9LAogCXsgLmN0bF9uYW1lID0gMCB9CiB9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NoYXIvc2NscF92dDIyMC5jIGIvZHJpdmVycy9zMzkwL2NoYXIvc2NscF92dDIyMC5jCmluZGV4IDE3ODcyNGYuLmI5ZDJhMDAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaGFyL3NjbHBfdnQyMjAuYworKysgYi9kcml2ZXJzL3MzOTAvY2hhci9zY2xwX3Z0MjIwLmMKQEAgLTcwNSwyMSArNzA1LDYgQEAKIH0KIF9faW5pdGNhbGwoc2NscF92dDIyMF90dHlfaW5pdCk7CiAKLSNpZmRlZiBDT05GSUdfU0NMUF9WVDIyMF9DT05TT0xFCi0KLXN0YXRpYyB2b2lkCi1zY2xwX3Z0MjIwX2Nvbl93cml0ZShzdHJ1Y3QgY29uc29sZSAqY29uLCBjb25zdCBjaGFyICpidWYsIHVuc2lnbmVkIGludCBjb3VudCkKLXsKLQlfX3NjbHBfdnQyMjBfd3JpdGUoKGNvbnN0IHVuc2lnbmVkIGNoYXIgKikgYnVmLCBjb3VudCwgMSwgMSwgMCk7Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgdHR5X2RyaXZlciAqCi1zY2xwX3Z0MjIwX2Nvbl9kZXZpY2Uoc3RydWN0IGNvbnNvbGUgKmMsIGludCAqaW5kZXgpCi17Ci0JKmluZGV4ID0gMDsKLQlyZXR1cm4gc2NscF92dDIyMF9kcml2ZXI7Ci19Ci0KIHN0YXRpYyB2b2lkIF9fc2NscF92dDIyMF9mbHVzaF9idWZmZXIodm9pZCkKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwpAQCAtNzc2LDYgKzc2MSwyMSBAQAogCX0KIH0KIAorI2lmZGVmIENPTkZJR19TQ0xQX1ZUMjIwX0NPTlNPTEUKKworc3RhdGljIHZvaWQKK3NjbHBfdnQyMjBfY29uX3dyaXRlKHN0cnVjdCBjb25zb2xlICpjb24sIGNvbnN0IGNoYXIgKmJ1ZiwgdW5zaWduZWQgaW50IGNvdW50KQoreworCV9fc2NscF92dDIyMF93cml0ZSgoY29uc3QgdW5zaWduZWQgY2hhciAqKSBidWYsIGNvdW50LCAxLCAxLCAwKTsKK30KKworc3RhdGljIHN0cnVjdCB0dHlfZHJpdmVyICoKK3NjbHBfdnQyMjBfY29uX2RldmljZShzdHJ1Y3QgY29uc29sZSAqYywgaW50ICppbmRleCkKK3sKKwkqaW5kZXggPSAwOworCXJldHVybiBzY2xwX3Z0MjIwX2RyaXZlcjsKK30KKwogc3RhdGljIGludAogc2NscF92dDIyMF9ub3RpZnkoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLAogCQkJICB1bnNpZ25lZCBsb25nIGV2ZW50LCB2b2lkICpkYXRhKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NoYXIvdGFwZV9ibG9jay5jIGIvZHJpdmVycy9zMzkwL2NoYXIvdGFwZV9ibG9jay5jCmluZGV4IDY0ZjU3ZWYuLjBjMDcwNWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaGFyL3RhcGVfYmxvY2suYworKysgYi9kcml2ZXJzL3MzOTAvY2hhci90YXBlX2Jsb2NrLmMKQEAgLTE2Miw5ICsxNjIsMTAgQEAKIAlzcGluX2xvY2tfaXJxKCZkZXZpY2UtPmJsa19kYXRhLnJlcXVlc3RfcXVldWVfbG9jayk7CiAJd2hpbGUgKAogCQkhYmxrX3F1ZXVlX3BsdWdnZWQocXVldWUpICYmCi0JCShyZXEgPSBibGtfZmV0Y2hfcmVxdWVzdChxdWV1ZSkpICYmCisJCWJsa19wZWVrX3JlcXVlc3QocXVldWUpICYmCiAJCW5yX3F1ZXVlZCA8IFRBUEVCTE9DS19NSU5fUkVRVUVVRQogCSkgeworCQlyZXEgPSBibGtfZmV0Y2hfcmVxdWVzdChxdWV1ZSk7CiAJCWlmIChycV9kYXRhX2RpcihyZXEpID09IFdSSVRFKSB7CiAJCQlEQkZfRVZFTlQoMSwgIlRCTE9DSzogUmVqZWN0aW5nIHdyaXRlIHJlcXVlc3RcbiIpOwogCQkJc3Bpbl91bmxvY2tfaXJxKCZkZXZpY2UtPmJsa19kYXRhLnJlcXVlc3RfcXVldWVfbG9jayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvY2lvL2JsYWNrbGlzdC5jIGIvZHJpdmVycy9zMzkwL2Npby9ibGFja2xpc3QuYwppbmRleCA2NTY1ZjAyLi43ZWFiOWFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvY2lvL2JsYWNrbGlzdC5jCisrKyBiL2RyaXZlcnMvczM5MC9jaW8vYmxhY2tsaXN0LmMKQEAgLTI2NSwxMyArMjY1LDExIEBACiBzdGF0aWMgdm9pZCAqCiBjaW9faWdub3JlX3Byb2Nfc2VxX3N0YXJ0KHN0cnVjdCBzZXFfZmlsZSAqcywgbG9mZl90ICpvZmZzZXQpCiB7Ci0Jc3RydWN0IGNjd2Rldl9pdGVyICppdGVyOworCXN0cnVjdCBjY3dkZXZfaXRlciAqaXRlciA9IHMtPnByaXZhdGU7CiAKIAlpZiAoKm9mZnNldCA+PSAoX19NQVhfU1VCQ0hBTk5FTCArIDEpICogKF9fTUFYX1NTSUQgKyAxKSkKIAkJcmV0dXJuIE5VTEw7Ci0JaXRlciA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBjY3dkZXZfaXRlciksIEdGUF9LRVJORUwpOwotCWlmICghaXRlcikKLQkJcmV0dXJuIEVSUl9QVFIoLUVOT01FTSk7CisJbWVtc2V0KGl0ZXIsIDAsIHNpemVvZigqaXRlcikpOwogCWl0ZXItPnNzaWQgPSAqb2Zmc2V0IC8gKF9fTUFYX1NVQkNIQU5ORUwgKyAxKTsKIAlpdGVyLT5kZXZubyA9ICpvZmZzZXQgJSAoX19NQVhfU1VCQ0hBTk5FTCArIDEpOwogCXJldHVybiBpdGVyOwpAQCAtMjgwLDggKzI3OCw2IEBACiBzdGF0aWMgdm9pZAogY2lvX2lnbm9yZV9wcm9jX3NlcV9zdG9wKHN0cnVjdCBzZXFfZmlsZSAqcywgdm9pZCAqaXQpCiB7Ci0JaWYgKCFJU19FUlIoaXQpKQotCQlrZnJlZShpdCk7CiB9CiAKIHN0YXRpYyB2b2lkICoKQEAgLTM3OCwxNCArMzc0LDE1IEBACiBzdGF0aWMgaW50CiBjaW9faWdub3JlX3Byb2Nfb3BlbihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKIHsKLQlyZXR1cm4gc2VxX29wZW4oZmlsZSwgJmNpb19pZ25vcmVfcHJvY19zZXFfb3BzKTsKKwlyZXR1cm4gc2VxX29wZW5fcHJpdmF0ZShmaWxlLCAmY2lvX2lnbm9yZV9wcm9jX3NlcV9vcHMsCisJCQkJc2l6ZW9mKHN0cnVjdCBjY3dkZXZfaXRlcikpOwogfQogCiBzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBjaW9faWdub3JlX3Byb2NfZm9wcyA9IHsKIAkub3BlbiAgICA9IGNpb19pZ25vcmVfcHJvY19vcGVuLAogCS5yZWFkICAgID0gc2VxX3JlYWQsCiAJLmxsc2VlayAgPSBzZXFfbHNlZWssCi0JLnJlbGVhc2UgPSBzZXFfcmVsZWFzZSwKKwkucmVsZWFzZSA9IHNlcV9yZWxlYXNlX3ByaXZhdGUsCiAJLndyaXRlICAgPSBjaW9faWdub3JlX3dyaXRlLAogfTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2Npby9jaHAuYyBiL2RyaXZlcnMvczM5MC9jaW8vY2hwLmMKaW5kZXggNDAwMDI4My4uOGFiNTE2MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL2Npby9jaHAuYworKysgYi9kcml2ZXJzL3MzOTAvY2lvL2NocC5jCkBAIC0zOTMsNyArMzkzLDYgQEAKIAljaHAtPnN0YXRlID0gMTsKIAljaHAtPmRldi5wYXJlbnQgPSAmY2hhbm5lbF9zdWJzeXN0ZW1zW2NocGlkLmNzc2lkXS0+ZGV2aWNlOwogCWNocC0+ZGV2LnJlbGVhc2UgPSBjaHBfcmVsZWFzZTsKLQlkZXZfc2V0X25hbWUoJmNocC0+ZGV2LCAiY2hwJXguJTAyeCIsIGNocGlkLmNzc2lkLCBjaHBpZC5pZCk7CiAKIAkvKiBPYnRhaW4gY2hhbm5lbCBwYXRoIGRlc2NyaXB0aW9uIGFuZCBmaWxsIGl0IGluLiAqLwogCXJldCA9IGNoc2NfZGV0ZXJtaW5lX2Jhc2VfY2hhbm5lbF9wYXRoX2Rlc2MoY2hwaWQsICZjaHAtPmRlc2MpOwpAQCAtNDExLDYgKzQxMCw3IEBACiAJfSBlbHNlIHsKIAkJY2hwLT5jbWcgPSAtMTsKIAl9CisJZGV2X3NldF9uYW1lKCZjaHAtPmRldiwgImNocCV4LiUwMngiLCBjaHBpZC5jc3NpZCwgY2hwaWQuaWQpOwogCiAJLyogbWFrZSBpdCBrbm93biB0byB0aGUgc3lzdGVtICovCiAJcmV0ID0gZGV2aWNlX3JlZ2lzdGVyKCZjaHAtPmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvY2lvL2RldmljZS5jIGIvZHJpdmVycy9zMzkwL2Npby9kZXZpY2UuYwppbmRleCBmNzgwYmRkLi4yNDkwYjc0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvY2lvL2RldmljZS5jCisrKyBiL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlLmMKQEAgLTEyNTAsOCArMTI1MCw3IEBACiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlzdHJ1Y3QgY2N3X2Rldl9pZCBkZXZfaWQ7CiAKLQljZGV2ID0gc2NoX2dldF9jZGV2KHNjaCk7Ci0JaWYgKGNkZXYpIHsKKwlpZiAoY2lvX2lzX2NvbnNvbGUoc2NoLT5zY2hpZCkpIHsKIAkJcmMgPSBzeXNmc19jcmVhdGVfZ3JvdXAoJnNjaC0+ZGV2LmtvYmosCiAJCQkJCSZpb19zdWJjaGFubmVsX2F0dHJfZ3JvdXApOwogCQlpZiAocmMpCkBAIC0xMjYwLDEzICsxMjU5LDEzIEBACiAJCQkJICAgICAgIjAuJXguJTA0eCAocmM9JWQpXG4iLAogCQkJCSAgICAgIHNjaC0+c2NoaWQuc3NpZCwgc2NoLT5zY2hpZC5zY2hfbm8sIHJjKTsKIAkJLyoKLQkJICogVGhpcyBzdWJjaGFubmVsIGFscmVhZHkgaGFzIGFuIGFzc29jaWF0ZWQgY2N3X2RldmljZS4KKwkJICogVGhlIGNvbnNvbGUgc3ViY2hhbm5lbCBhbHJlYWR5IGhhcyBhbiBhc3NvY2lhdGVkIGNjd19kZXZpY2UuCiAJCSAqIFRocm93IHRoZSBkZWxheWVkIHVldmVudCBmb3IgdGhlIHN1YmNoYW5uZWwsIHJlZ2lzdGVyCi0JCSAqIHRoZSBjY3dfZGV2aWNlIGFuZCBleGl0LiBUaGlzIGhhcHBlbnMgZm9yIGFsbCBlYXJseQotCQkgKiBkZXZpY2VzLCBlLmcuIHRoZSBjb25zb2xlLgorCQkgKiB0aGUgY2N3X2RldmljZSBhbmQgZXhpdC4KIAkJICovCiAJCWRldl9zZXRfdWV2ZW50X3N1cHByZXNzKCZzY2gtPmRldiwgMCk7CiAJCWtvYmplY3RfdWV2ZW50KCZzY2gtPmRldi5rb2JqLCBLT0JKX0FERCk7CisJCWNkZXYgPSBzY2hfZ2V0X2NkZXYoc2NoKTsKIAkJY2Rldi0+ZGV2Lmdyb3VwcyA9IGNjd2Rldl9hdHRyX2dyb3VwczsKIAkJZGV2aWNlX2luaXRpYWxpemUoJmNkZXYtPmRldik7CiAJCWNjd19kZXZpY2VfcmVnaXN0ZXIoY2Rldik7CkBAIC0xNjA5LDcgKzE2MDgsNyBAQAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCBkZXZpY2Vfc2V0X2Rpc2Nvbm5lY3RlZChzdHJ1Y3QgY2N3X2RldmljZSAqY2RldikKK3ZvaWQgY2N3X2RldmljZV9zZXRfZGlzY29ubmVjdGVkKHN0cnVjdCBjY3dfZGV2aWNlICpjZGV2KQogewogCWlmICghY2RldikKIAkJcmV0dXJuOwpAQCAtMTcwNSw3ICsxNzA0LDcgQEAKIAkJY2N3X2RldmljZV90cmlnZ2VyX3JlcHJvYmUoY2Rldik7CiAJCWJyZWFrOwogCWNhc2UgRElTQzoKLQkJZGV2aWNlX3NldF9kaXNjb25uZWN0ZWQoY2Rldik7CisJCWNjd19kZXZpY2Vfc2V0X2Rpc2Nvbm5lY3RlZChjZGV2KTsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKIAkJYnJlYWs7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvY2lvL2RldmljZS5oIGIvZHJpdmVycy9zMzkwL2Npby9kZXZpY2UuaAppbmRleCBlZDM5YTJjLi4yNDZjNjQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvY2lvL2RldmljZS5oCisrKyBiL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlLmgKQEAgLTEyNSw2ICsxMjUsNyBAQAogdm9pZCBjY3dfZGV2aWNlX3RyaWdnZXJfcmVwcm9iZShzdHJ1Y3QgY2N3X2RldmljZSAqKTsKIHZvaWQgY2N3X2RldmljZV9raWxsX2lvKHN0cnVjdCBjY3dfZGV2aWNlICopOwogaW50IGNjd19kZXZpY2Vfbm90aWZ5KHN0cnVjdCBjY3dfZGV2aWNlICosIGludCk7Cit2b2lkIGNjd19kZXZpY2Vfc2V0X2Rpc2Nvbm5lY3RlZChzdHJ1Y3QgY2N3X2RldmljZSAqY2Rldik7CiB2b2lkIGNjd19kZXZpY2Vfc2V0X25vdG9wZXIoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYpOwogCiAvKiBxZGlvIG5lZWRzIHRoaXMuICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvY2lvL2RldmljZV9mc20uYyBiL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlX2ZzbS5jCmluZGV4IGU3MjhjZTQuLmI5NjEzZDcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlX2ZzbS5jCisrKyBiL2RyaXZlcnMvczM5MC9jaW8vZGV2aWNlX2ZzbS5jCkBAIC0zODcsMTkgKzM4NywzNSBAQAogCiAJY2Rldi0+cHJpdmF0ZS0+c3RhdGUgPSBzdGF0ZTsKIAotCWlmIChzdGF0ZSA9PSBERVZfU1RBVEVfQk9YRUQpIHsKKwlzd2l0Y2ggKHN0YXRlKSB7CisJY2FzZSBERVZfU1RBVEVfQk9YRUQ6CiAJCUNJT19NU0dfRVZFTlQoMCwgIkJveGVkIGRldmljZSAlMDR4IG9uIHN1YmNoYW5uZWwgJTA0eFxuIiwKIAkJCSAgICAgIGNkZXYtPnByaXZhdGUtPmRldl9pZC5kZXZubywgc2NoLT5zY2hpZC5zY2hfbm8pOwogCQlpZiAoY2Rldi0+b25saW5lICYmICFjY3dfZGV2aWNlX25vdGlmeShjZGV2LCBDSU9fQk9YRUQpKQogCQkJY2N3X2RldmljZV9zY2hlZHVsZV9zY2hfdW5yZWdpc3RlcihjZGV2KTsKIAkJY2Rldi0+cHJpdmF0ZS0+ZmxhZ3MuZG9ub3RpZnkgPSAwOwotCX0KLQlpZiAoc3RhdGUgPT0gREVWX1NUQVRFX05PVF9PUEVSKSB7CisJCWJyZWFrOworCWNhc2UgREVWX1NUQVRFX05PVF9PUEVSOgogCQlDSU9fTVNHX0VWRU5UKDAsICJEZXZpY2UgJTA0eCBnb25lIG9uIHN1YmNoYW5uZWwgJTA0eFxuIiwKIAkJCSAgICAgIGNkZXYtPnByaXZhdGUtPmRldl9pZC5kZXZubywgc2NoLT5zY2hpZC5zY2hfbm8pOwogCQlpZiAoIWNjd19kZXZpY2Vfbm90aWZ5KGNkZXYsIENJT19HT05FKSkKIAkJCWNjd19kZXZpY2Vfc2NoZWR1bGVfc2NoX3VucmVnaXN0ZXIoY2Rldik7CisJCWVsc2UKKwkJCWNjd19kZXZpY2Vfc2V0X2Rpc2Nvbm5lY3RlZChjZGV2KTsKIAkJY2Rldi0+cHJpdmF0ZS0+ZmxhZ3MuZG9ub3RpZnkgPSAwOworCQlicmVhazsKKwljYXNlIERFVl9TVEFURV9ESVNDT05ORUNURUQ6CisJCUNJT19NU0dfRVZFTlQoMCwgIkRpc2Nvbm5lY3RlZCBkZXZpY2UgJTA0eCBvbiBzdWJjaGFubmVsICIKKwkJCSAgICAgICIlMDR4XG4iLCBjZGV2LT5wcml2YXRlLT5kZXZfaWQuZGV2bm8sCisJCQkgICAgICBzY2gtPnNjaGlkLnNjaF9ubyk7CisJCWlmICghY2N3X2RldmljZV9ub3RpZnkoY2RldiwgQ0lPX05PX1BBVEgpKQorCQkJY2N3X2RldmljZV9zY2hlZHVsZV9zY2hfdW5yZWdpc3RlcihjZGV2KTsKKwkJZWxzZQorCQkJY2N3X2RldmljZV9zZXRfZGlzY29ubmVjdGVkKGNkZXYpOworCQljZGV2LT5wcml2YXRlLT5mbGFncy5kb25vdGlmeSA9IDA7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJyZWFrOwogCX0KIAogCWlmIChjZGV2LT5wcml2YXRlLT5mbGFncy5kb25vdGlmeSkgewpAQCAtNjcxLDYgKzY4NywxMCBAQAogCQljY3dfZGV2aWNlX2RvbmUoY2RldiwgREVWX1NUQVRFX05PVF9PUEVSKTsKIAkJcmV0dXJuIDA7CiAJfQorCWlmIChjZGV2LT5wcml2YXRlLT5zdGF0ZSA9PSBERVZfU1RBVEVfQk9YRUQpIHsKKwkJY2N3X2RldmljZV9kb25lKGNkZXYsIERFVl9TVEFURV9CT1hFRCk7CisJCXJldHVybiAwOworCX0KIAlpZiAoY2N3X2RldmljZV9pc19vcnBoYW4oY2RldikpIHsKIAkJY2N3X2RldmljZV9kb25lKGNkZXYsIERFVl9TVEFURV9PRkZMSU5FKTsKIAkJcmV0dXJuIDA7CkBAIC03MzAsMTEgKzc1MCwxMCBAQAogc3RhdGljIHZvaWQgY2N3X2RldmljZV9nZW5lcmljX25vdG9wZXIoc3RydWN0IGNjd19kZXZpY2UgKmNkZXYsCiAJCQkJICAgICAgIGVudW0gZGV2X2V2ZW50IGRldl9ldmVudCkKIHsKLQlzdHJ1Y3Qgc3ViY2hhbm5lbCAqc2NoOwotCi0JY2N3X2RldmljZV9zZXRfbm90b3BlcihjZGV2KTsKLQlzY2ggPSB0b19zdWJjaGFubmVsKGNkZXYtPmRldi5wYXJlbnQpOwotCWNzc19zY2hlZHVsZV9ldmFsKHNjaC0+c2NoaWQpOworCWlmICghY2N3X2RldmljZV9ub3RpZnkoY2RldiwgQ0lPX0dPTkUpKQorCQljY3dfZGV2aWNlX3NjaGVkdWxlX3NjaF91bnJlZ2lzdGVyKGNkZXYpOworCWVsc2UKKwkJY2N3X2RldmljZV9zZXRfZGlzY29ubmVjdGVkKGNkZXYpOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL2NyeXB0by96Y3J5cHRfcGNpeGNjLmMgYi9kcml2ZXJzL3MzOTAvY3J5cHRvL3pjcnlwdF9wY2l4Y2MuYwppbmRleCBjMjBkNDc5Li41Njc3YjQwIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvY3J5cHRvL3pjcnlwdF9wY2l4Y2MuYworKysgYi9kcml2ZXJzL3MzOTAvY3J5cHRvL3pjcnlwdF9wY2l4Y2MuYwpAQCAtMzYxLDcgKzM2MSw3IEBACiAJCS5Ub0NhcmRMZW4xCT0gc2l6ZW9mICptc2cgLSBzaXplb2YobXNnLT5oZHIpLAogCQkuRnJvbUNhcmRMZW4xCT0gc2l6ZW9mICptc2cgLSBzaXplb2YobXNnLT5oZHIpLAogCX07Ci0Jc3RhdGljIHN0cnVjdCBDUFJCWCBzdGF0aWNfY3ByYnggPSB7CisJc3RhdGljIHN0cnVjdCBDUFJCWCBsb2NhbF9jcHJieCA9IHsKIAkJLmNwcmJfbGVuCT0gMHgwMGRjLAogCQkuY3ByYl92ZXJfaWQJPSAweDAyLAogCQkuZnVuY19pZAk9IHsweDU0LCAweDMyfSwKQEAgLTM3Miw3ICszNzIsNyBAQAogCiAJbXNnLT5oZHIgPSBzdGF0aWNfdHlwZTZfaGRyWDsKIAltc2ctPmhkci5Gcm9tQ2FyZExlbjIgPSByYW5kb21fbnVtYmVyX2xlbmd0aCwKLQltc2ctPmNwcmJ4ID0gc3RhdGljX2NwcmJ4OworCW1zZy0+Y3ByYnggPSBsb2NhbF9jcHJieDsKIAltc2ctPmNwcmJ4LnJwbF9kYXRhbCA9IHJhbmRvbV9udW1iZXJfbGVuZ3RoLAogCW1zZy0+Y3ByYnguZG9tYWluID0gQVBfUUlEX1FVRVVFKGFwX2Rldi0+cWlkKTsKIAltZW1jcHkobXNnLT5mdW5jdGlvbl9jb2RlLCBtc2ctPmhkci5mdW5jdGlvbl9jb2RlLCAweDAyKTsKQEAgLTU2MSw3ICs1NjEsOCBAQAogCQlpZiAobXNnLT5jcHJieC5jcHJiX3Zlcl9pZCA9PSAweDAyKQogCQkJcmV0dXJuIGNvbnZlcnRfdHlwZTg2X2ljYSh6ZGV2LCByZXBseSwKIAkJCQkJCSAgb3V0cHV0ZGF0YSwgb3V0cHV0ZGF0YWxlbmd0aCk7Ci0JCS8qIG5vIGJyZWFrLCBpbmNvcnJlY3QgY3ByYiB2ZXJzaW9uIGlzIGFuIHVua25vd24gcmVzcG9uc2UgKi8KKwkJLyogRmFsbCB0aHJvdWdoLCBubyBicmVhaywgaW5jb3JyZWN0IGNwcmIgdmVyc2lvbiBpcyBhbiB1bmtub3duCisJCSAqIHJlc3BvbnNlICovCiAJZGVmYXVsdDogLyogVW5rbm93biByZXNwb25zZSB0eXBlLCB0aGlzIHNob3VsZCBORVZFUiBFVkVSIGhhcHBlbiAqLwogCQl6ZGV2LT5vbmxpbmUgPSAwOwogCQlyZXR1cm4gLUVBR0FJTjsJLyogcmVwZWF0IHRoZSByZXF1ZXN0IG9uIGEgZGlmZmVyZW50IGRldmljZS4gKi8KQEAgLTU4Nyw3ICs1ODgsOCBAQAogCQl9CiAJCWlmIChtc2ctPmNwcmJ4LmNwcmJfdmVyX2lkID09IDB4MDIpCiAJCQlyZXR1cm4gY29udmVydF90eXBlODZfeGNyYih6ZGV2LCByZXBseSwgeGNSQik7Ci0JCS8qIG5vIGJyZWFrLCBpbmNvcnJlY3QgY3ByYiB2ZXJzaW9uIGlzIGFuIHVua25vd24gcmVzcG9uc2UgKi8KKwkJLyogRmFsbCB0aHJvdWdoLCBubyBicmVhaywgaW5jb3JyZWN0IGNwcmIgdmVyc2lvbiBpcyBhbiB1bmtub3duCisJCSAqIHJlc3BvbnNlICovCiAJZGVmYXVsdDogLyogVW5rbm93biByZXNwb25zZSB0eXBlLCB0aGlzIHNob3VsZCBORVZFUiBFVkVSIGhhcHBlbiAqLwogCQl4Y1JCLT5zdGF0dXMgPSAweDAwMDgwNDRETDsgLyogSEREX0ludmFsaWRQYXJtICovCiAJCXpkZXYtPm9ubGluZSA9IDA7CkBAIC02MTAsNyArNjEyLDggQEAKIAkJCXJldHVybiAtRUlOVkFMOwogCQlpZiAobXNnLT5jcHJieC5jcHJiX3Zlcl9pZCA9PSAweDAyKQogCQkJcmV0dXJuIGNvbnZlcnRfdHlwZTg2X3JuZyh6ZGV2LCByZXBseSwgZGF0YSk7Ci0JCS8qIG5vIGJyZWFrLCBpbmNvcnJlY3QgY3ByYiB2ZXJzaW9uIGlzIGFuIHVua25vd24gcmVzcG9uc2UgKi8KKwkJLyogRmFsbCB0aHJvdWdoLCBubyBicmVhaywgaW5jb3JyZWN0IGNwcmIgdmVyc2lvbiBpcyBhbiB1bmtub3duCisJCSAqIHJlc3BvbnNlICovCiAJZGVmYXVsdDogLyogVW5rbm93biByZXNwb25zZSB0eXBlLCB0aGlzIHNob3VsZCBORVZFUiBFVkVSIGhhcHBlbiAqLwogCQl6ZGV2LT5vbmxpbmUgPSAwOwogCQlyZXR1cm4gLUVBR0FJTjsJLyogcmVwZWF0IHRoZSByZXF1ZXN0IG9uIGEgZGlmZmVyZW50IGRldmljZS4gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvczM5MC9zY3NpL3pmY3BfYXV4LmMgYi9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2F1eC5jCmluZGV4IDFiZTZiZjcuLjBmNzlmM2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvczM5MC9zY3NpL3pmY3BfYXV4LmMKKysrIGIvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9hdXguYwpAQCAtODAsMjggKzgwLDM1IEBACiAKIHN0YXRpYyB2b2lkIF9faW5pdCB6ZmNwX2luaXRfZGV2aWNlX2NvbmZpZ3VyZShjaGFyICpidXNpZCwgdTY0IHd3cG4sIHU2NCBsdW4pCiB7CisJc3RydWN0IGNjd19kZXZpY2UgKmNjd2RldjsKIAlzdHJ1Y3QgemZjcF9hZGFwdGVyICphZGFwdGVyOwogCXN0cnVjdCB6ZmNwX3BvcnQgKnBvcnQ7CiAJc3RydWN0IHpmY3BfdW5pdCAqdW5pdDsKIAotCW11dGV4X2xvY2soJnpmY3BfZGF0YS5jb25maWdfbXV0ZXgpOwotCXJlYWRfbG9ja19pcnEoJnpmY3BfZGF0YS5jb25maWdfbG9jayk7Ci0JYWRhcHRlciA9IHpmY3BfZ2V0X2FkYXB0ZXJfYnlfYnVzaWQoYnVzaWQpOwotCWlmIChhZGFwdGVyKQotCQl6ZmNwX2FkYXB0ZXJfZ2V0KGFkYXB0ZXIpOwotCXJlYWRfdW5sb2NrX2lycSgmemZjcF9kYXRhLmNvbmZpZ19sb2NrKTsKKwljY3dkZXYgPSBnZXRfY2N3ZGV2X2J5X2J1c2lkKCZ6ZmNwX2Njd19kcml2ZXIsIGJ1c2lkKTsKKwlpZiAoIWNjd2RldikKKwkJcmV0dXJuOwogCisJaWYgKGNjd19kZXZpY2Vfc2V0X29ubGluZShjY3dkZXYpKQorCQlnb3RvIG91dF9jY3dkZXY7CisKKwltdXRleF9sb2NrKCZ6ZmNwX2RhdGEuY29uZmlnX211dGV4KTsKKwlhZGFwdGVyID0gZGV2X2dldF9kcnZkYXRhKCZjY3dkZXYtPmRldik7CiAJaWYgKCFhZGFwdGVyKQotCQlnb3RvIG91dF9hZGFwdGVyOwotCXBvcnQgPSB6ZmNwX3BvcnRfZW5xdWV1ZShhZGFwdGVyLCB3d3BuLCAwLCAwKTsKLQlpZiAoSVNfRVJSKHBvcnQpKQorCQlnb3RvIG91dF91bmxvY2s7CisJemZjcF9hZGFwdGVyX2dldChhZGFwdGVyKTsKKworCXBvcnQgPSB6ZmNwX2dldF9wb3J0X2J5X3d3cG4oYWRhcHRlciwgd3dwbik7CisJaWYgKCFwb3J0KQogCQlnb3RvIG91dF9wb3J0OworCisJemZjcF9wb3J0X2dldChwb3J0KTsKIAl1bml0ID0gemZjcF91bml0X2VucXVldWUocG9ydCwgbHVuKTsKIAlpZiAoSVNfRVJSKHVuaXQpKQogCQlnb3RvIG91dF91bml0OwogCW11dGV4X3VubG9jaygmemZjcF9kYXRhLmNvbmZpZ19tdXRleCk7Ci0JY2N3X2RldmljZV9zZXRfb25saW5lKGFkYXB0ZXItPmNjd19kZXZpY2UpOwogCisJemZjcF9lcnBfdW5pdF9yZW9wZW4odW5pdCwgMCwgImF1aWRjXzEiLCBOVUxMKTsKIAl6ZmNwX2VycF93YWl0KGFkYXB0ZXIpOwogCWZsdXNoX3dvcmsoJnVuaXQtPnNjc2lfd29yayk7CiAKQEAgLTExMSw4ICsxMTgsMTAgQEAKIAl6ZmNwX3BvcnRfcHV0KHBvcnQpOwogb3V0X3BvcnQ6CiAJemZjcF9hZGFwdGVyX3B1dChhZGFwdGVyKTsKLW91dF9hZGFwdGVyOgorb3V0X3VubG9jazoKIAltdXRleF91bmxvY2soJnpmY3BfZGF0YS5jb25maWdfbXV0ZXgpOworb3V0X2Njd2RldjoKKwlwdXRfZGV2aWNlKCZjY3dkZXYtPmRldik7CiAJcmV0dXJuOwogfQogCkBAIC01OTMsMTAgKzYwMiw4IEBACiAJaW50IHJldHZhbCA9IDA7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCWNhbmNlbF93b3JrX3N5bmMoJmFkYXB0ZXItPnNjYW5fd29yayk7CiAJY2FuY2VsX3dvcmtfc3luYygmYWRhcHRlci0+c3RhdF93b3JrKTsKIAl6ZmNwX2ZjX3drYV9wb3J0c19mb3JjZV9vZmZsaW5lKGFkYXB0ZXItPmdzKTsKLQl6ZmNwX2FkYXB0ZXJfc2NzaV91bnJlZ2lzdGVyKGFkYXB0ZXIpOwogCXN5c2ZzX3JlbW92ZV9ncm91cCgmYWRhcHRlci0+Y2N3X2RldmljZS0+ZGV2LmtvYmosCiAJCQkgICAmemZjcF9zeXNmc19hZGFwdGVyX2F0dHJzKTsKIAlkZXZfc2V0X2RydmRhdGEoJmFkYXB0ZXItPmNjd19kZXZpY2UtPmRldiwgTlVMTCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2Njdy5jIGIvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9jY3cuYwppbmRleCAwYzkwZjhlLi5lMDgzMzk0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2Njdy5jCisrKyBiL2RyaXZlcnMvczM5MC9zY3NpL3pmY3BfY2N3LmMKQEAgLTEwMiw2ICsxMDIsMTQgQEAKIAlhZGFwdGVyID0gZGV2X2dldF9kcnZkYXRhKCZjY3dfZGV2aWNlLT5kZXYpOwogCWlmICghYWRhcHRlcikKIAkJZ290byBvdXQ7CisJbXV0ZXhfdW5sb2NrKCZ6ZmNwX2RhdGEuY29uZmlnX211dGV4KTsKKworCWNhbmNlbF93b3JrX3N5bmMoJmFkYXB0ZXItPnNjYW5fd29yayk7CisKKwltdXRleF9sb2NrKCZ6ZmNwX2RhdGEuY29uZmlnX211dGV4KTsKKworCS8qIHRoaXMgYWxzbyByZW1vdmVzIHRoZSBzY3NpIGRldmljZXMsIHNvIGNhbGwgaXQgZmlyc3QgKi8KKwl6ZmNwX2FkYXB0ZXJfc2NzaV91bnJlZ2lzdGVyKGFkYXB0ZXIpOwogCiAJd3JpdGVfbG9ja19pcnEoJnpmY3BfZGF0YS5jb25maWdfbG9jayk7CiAJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKHBvcnQsIHAsICZhZGFwdGVyLT5wb3J0X2xpc3RfaGVhZCwgbGlzdCkgewpAQCAtMTE3LDExICsxMjUsOCBAQAogCXdyaXRlX3VubG9ja19pcnEoJnpmY3BfZGF0YS5jb25maWdfbG9jayk7CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUocG9ydCwgcCwgJnBvcnRfcmVtb3ZlX2xoLCBsaXN0KSB7Ci0JCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh1bml0LCB1LCAmdW5pdF9yZW1vdmVfbGgsIGxpc3QpIHsKLQkJCWlmICh1bml0LT5kZXZpY2UpCi0JCQkJc2NzaV9yZW1vdmVfZGV2aWNlKHVuaXQtPmRldmljZSk7CisJCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZSh1bml0LCB1LCAmdW5pdF9yZW1vdmVfbGgsIGxpc3QpCiAJCQl6ZmNwX3VuaXRfZGVxdWV1ZSh1bml0KTsKLQkJfQogCQl6ZmNwX3BvcnRfZGVxdWV1ZShwb3J0KTsKIAl9CiAJd2FpdF9ldmVudChhZGFwdGVyLT5yZW1vdmVfd3EsIGF0b21pY19yZWFkKCZhZGFwdGVyLT5yZWZjb3VudCkgPT0gMCk7CkBAIC0xOTIsMTMgKzE5Nyw5IEBACiAKIAltdXRleF9sb2NrKCZ6ZmNwX2RhdGEuY29uZmlnX211dGV4KTsKIAlhZGFwdGVyID0gZGV2X2dldF9kcnZkYXRhKCZjY3dfZGV2aWNlLT5kZXYpOwotCWlmICghYWRhcHRlcikKLQkJZ290byBvdXQ7Ci0KIAl6ZmNwX2VycF9hZGFwdGVyX3NodXRkb3duKGFkYXB0ZXIsIDAsICJjY3NvZmYxIiwgTlVMTCk7CiAJemZjcF9lcnBfd2FpdChhZGFwdGVyKTsKIAltdXRleF91bmxvY2soJnpmY3BfZGF0YS5jb25maWdfbXV0ZXgpOwotb3V0OgogCXJldHVybiAwOwogfQogCkBAIC0yNTMsMTMgKzI1NCwxNyBAQAogCiAJbXV0ZXhfbG9jaygmemZjcF9kYXRhLmNvbmZpZ19tdXRleCk7CiAJYWRhcHRlciA9IGRldl9nZXRfZHJ2ZGF0YSgmY2Rldi0+ZGV2KTsKKwlpZiAoIWFkYXB0ZXIpCisJCWdvdG8gb3V0OworCiAJemZjcF9lcnBfYWRhcHRlcl9zaHV0ZG93bihhZGFwdGVyLCAwLCAiY2NzaHV0MSIsIE5VTEwpOwogCXpmY3BfZXJwX3dhaXQoYWRhcHRlcik7CiAJemZjcF9lcnBfdGhyZWFkX2tpbGwoYWRhcHRlcik7CitvdXQ6CiAJbXV0ZXhfdW5sb2NrKCZ6ZmNwX2RhdGEuY29uZmlnX211dGV4KTsKIH0KIAotc3RhdGljIHN0cnVjdCBjY3dfZHJpdmVyIHpmY3BfY2N3X2RyaXZlciA9IHsKK3N0cnVjdCBjY3dfZHJpdmVyIHpmY3BfY2N3X2RyaXZlciA9IHsKIAkub3duZXIgICAgICAgPSBUSElTX01PRFVMRSwKIAkubmFtZSAgICAgICAgPSAiemZjcCIsCiAJLmlkcyAgICAgICAgID0gemZjcF9jY3dfZGV2aWNlX2lkLApAQCAtMjg0LDIwICsyODksMyBAQAogewogCXJldHVybiBjY3dfZHJpdmVyX3JlZ2lzdGVyKCZ6ZmNwX2Njd19kcml2ZXIpOwogfQotCi0vKioKLSAqIHpmY3BfZ2V0X2FkYXB0ZXJfYnlfYnVzaWQgLSBmaW5kIHpmY3BfYWRhcHRlciBzdHJ1Y3QKLSAqIEBidXNpZDogYnVzIGlkIHN0cmluZyBvZiB6ZmNwIGFkYXB0ZXIgdG8gZmluZAotICovCi1zdHJ1Y3QgemZjcF9hZGFwdGVyICp6ZmNwX2dldF9hZGFwdGVyX2J5X2J1c2lkKGNoYXIgKmJ1c2lkKQotewotCXN0cnVjdCBjY3dfZGV2aWNlICpjY3dfZGV2aWNlOwotCXN0cnVjdCB6ZmNwX2FkYXB0ZXIgKmFkYXB0ZXIgPSBOVUxMOwotCi0JY2N3X2RldmljZSA9IGdldF9jY3dkZXZfYnlfYnVzaWQoJnpmY3BfY2N3X2RyaXZlciwgYnVzaWQpOwotCWlmIChjY3dfZGV2aWNlKSB7Ci0JCWFkYXB0ZXIgPSBkZXZfZ2V0X2RydmRhdGEoJmNjd19kZXZpY2UtPmRldik7Ci0JCXB1dF9kZXZpY2UoJmNjd19kZXZpY2UtPmRldik7Ci0JfQotCXJldHVybiBhZGFwdGVyOwotfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9jZmRjLmMgYi9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2NmZGMuYwppbmRleCA4MzA1Yzg3Li5lZjY4MWRmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2NmZGMuYworKysgYi9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2NmZGMuYwpAQCAtODYsOCArODYsMjMgQEAKIHN0YXRpYyBzdHJ1Y3QgemZjcF9hZGFwdGVyICp6ZmNwX2NmZGNfZ2V0X2FkYXB0ZXIodTMyIGRldm5vKQogewogCWNoYXIgYnVzaWRbOV07CisJc3RydWN0IGNjd19kZXZpY2UgKmNjd2RldjsKKwlzdHJ1Y3QgemZjcF9hZGFwdGVyICphZGFwdGVyID0gTlVMTDsKKwogCXNucHJpbnRmKGJ1c2lkLCBzaXplb2YoYnVzaWQpLCAiMC4wLiUwNHgiLCBkZXZubyk7Ci0JcmV0dXJuIHpmY3BfZ2V0X2FkYXB0ZXJfYnlfYnVzaWQoYnVzaWQpOworCWNjd2RldiA9IGdldF9jY3dkZXZfYnlfYnVzaWQoJnpmY3BfY2N3X2RyaXZlciwgYnVzaWQpOworCWlmICghY2N3ZGV2KQorCQlnb3RvIG91dDsKKworCWFkYXB0ZXIgPSBkZXZfZ2V0X2RydmRhdGEoJmNjd2Rldi0+ZGV2KTsKKwlpZiAoIWFkYXB0ZXIpCisJCWdvdG8gb3V0X3B1dDsKKworCXpmY3BfYWRhcHRlcl9nZXQoYWRhcHRlcik7CitvdXRfcHV0OgorCXB1dF9kZXZpY2UoJmNjd2Rldi0+ZGV2KTsKK291dDoKKwlyZXR1cm4gYWRhcHRlcjsKIH0KIAogc3RhdGljIGludCB6ZmNwX2NmZGNfc2V0X2ZzZihzdHJ1Y3QgemZjcF9mc2ZfY2ZkYyAqZnNmX2NmZGMsIGludCBjb21tYW5kKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9leHQuaCBiL2RyaXZlcnMvczM5MC9zY3NpL3pmY3BfZXh0LmgKaW5kZXggMzY5MzViYy4uNjI5ZWRlYyAxMDA2NDQKLS0tIGEvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9leHQuaAorKysgYi9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2V4dC5oCkBAIC0yOCw3ICsyOCw3IEBACiAvKiB6ZmNwX2Njdy5jICovCiBleHRlcm4gaW50IHpmY3BfY2N3X3JlZ2lzdGVyKHZvaWQpOwogZXh0ZXJuIGludCB6ZmNwX2Njd19wcml2X3NjaChzdHJ1Y3QgemZjcF9hZGFwdGVyICopOwotZXh0ZXJuIHN0cnVjdCB6ZmNwX2FkYXB0ZXIgKnpmY3BfZ2V0X2FkYXB0ZXJfYnlfYnVzaWQoY2hhciAqKTsKK2V4dGVybiBzdHJ1Y3QgY2N3X2RyaXZlciB6ZmNwX2Njd19kcml2ZXI7CiAKIC8qIHpmY3BfY2ZkYy5jICovCiBleHRlcm4gc3RydWN0IG1pc2NkZXZpY2UgemZjcF9jZmRjX21pc2M7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2ZzZi5jIGIvZHJpdmVycy9zMzkwL3Njc2kvemZjcF9mc2YuYwppbmRleCBmMDljODYzLi4zOGE3ZTRhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3MzOTAvc2NzaS96ZmNwX2ZzZi5jCisrKyBiL2RyaXZlcnMvczM5MC9zY3NpL3pmY3BfZnNmLmMKQEAgLTEwNTgsMTEgKzEwNTgsMjUgQEAKIAlieXRlcyA9IHpmY3BfcWRpb19zYmFsc19mcm9tX3NnKGFkYXB0ZXItPnFkaW8sICZyZXEtPnF1ZXVlX3JlcSwKIAkJCQkJU0JBTF9GTEFHUzBfVFlQRV9XUklURV9SRUFELAogCQkJCQlzZ19yZXNwLCBtYXhfc2JhbHMpOworCXJlcS0+cXRjYi0+Ym90dG9tLnN1cHBvcnQucmVzcF9idWZfbGVuZ3RoID0gYnl0ZXM7CiAJaWYgKGJ5dGVzIDw9IDApCiAJCXJldHVybiAtRUlPOwogCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgemZjcF9mc2Zfc2V0dXBfY3RfZWxzKHN0cnVjdCB6ZmNwX2ZzZl9yZXEgKnJlcSwKKwkJCQkgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZ19yZXEsCisJCQkJIHN0cnVjdCBzY2F0dGVybGlzdCAqc2dfcmVzcCwKKwkJCQkgaW50IG1heF9zYmFscykKK3sKKwlpbnQgcmV0OworCisJcmV0ID0gemZjcF9mc2Zfc2V0dXBfY3RfZWxzX3NiYWxzKHJlcSwgc2dfcmVxLCBzZ19yZXNwLCBtYXhfc2JhbHMpOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKIAkvKiBjb21tb24gc2V0dGluZ3MgZm9yIGN0L2dzIGFuZCBlbHMgcmVxdWVzdHMgKi8KLQlyZXEtPnF0Y2ItPmJvdHRvbS5zdXBwb3J0LnJlc3BfYnVmX2xlbmd0aCA9IGJ5dGVzOwogCXJlcS0+cXRjYi0+Ym90dG9tLnN1cHBvcnQuc2VydmljZV9jbGFzcyA9IEZTRl9DTEFTU18zOwogCXJlcS0+cXRjYi0+Ym90dG9tLnN1cHBvcnQudGltZW91dCA9IDIgKiBSX0FfVE9WOwogCXpmY3BfZnNmX3N0YXJ0X3RpbWVyKHJlcSwgMiAqIFJfQV9UT1YgKyAxMCk7CkBAIC0xMDk0LDggKzExMDgsOCBAQAogCX0KIAogCXJlcS0+c3RhdHVzIHw9IFpGQ1BfU1RBVFVTX0ZTRlJFUV9DTEVBTlVQOwotCXJldCA9IHpmY3BfZnNmX3NldHVwX2N0X2Vsc19zYmFscyhyZXEsIGN0LT5yZXEsIGN0LT5yZXNwLAotCQkJCQkgIEZTRl9NQVhfU0JBTFNfUEVSX1JFUSk7CisJcmV0ID0gemZjcF9mc2Zfc2V0dXBfY3RfZWxzKHJlcSwgY3QtPnJlcSwgY3QtPnJlc3AsCisJCQkJICAgIEZTRl9NQVhfU0JBTFNfUEVSX1JFUSk7CiAJaWYgKHJldCkKIAkJZ290byBmYWlsZWRfc2VuZDsKIApAQCAtMTE5Miw3ICsxMjA2LDcgQEAKIAl9CiAKIAlyZXEtPnN0YXR1cyB8PSBaRkNQX1NUQVRVU19GU0ZSRVFfQ0xFQU5VUDsKLQlyZXQgPSB6ZmNwX2ZzZl9zZXR1cF9jdF9lbHNfc2JhbHMocmVxLCBlbHMtPnJlcSwgZWxzLT5yZXNwLCAyKTsKKwlyZXQgPSB6ZmNwX2ZzZl9zZXR1cF9jdF9lbHMocmVxLCBlbHMtPnJlcSwgZWxzLT5yZXNwLCAyKTsKIAogCWlmIChyZXQpCiAJCWdvdG8gZmFpbGVkX3NlbmQ7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvS2NvbmZpZyBiL2RyaXZlcnMvc2NzaS9LY29uZmlnCmluZGV4IDgyYmIzYjIuLmUxMWNjYTQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9LY29uZmlnCisrKyBiL2RyaXZlcnMvc2NzaS9LY29uZmlnCkBAIC0zNjYsNiArMzY2LDcgQEAKIAogc291cmNlICJkcml2ZXJzL3Njc2kvY3hnYjNpL0tjb25maWciCiBzb3VyY2UgImRyaXZlcnMvc2NzaS9ibngyaS9LY29uZmlnIgorc291cmNlICJkcml2ZXJzL3Njc2kvYmUyaXNjc2kvS2NvbmZpZyIKIAogY29uZmlnIFNHSVdEOTNfU0NTSQogCXRyaXN0YXRlICJTR0kgV0Q5M0M5MyBTQ1NJIERyaXZlciIKQEAgLTE4MjcsNiArMTgyOCwxNiBAQAogCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZTogdGhlCiAJICBtb2R1bGUgd2lsbCBiZSBjYWxsZWQgbGlic3JwLgogCitjb25maWcgU0NTSV9CRkFfRkMKKwl0cmlzdGF0ZSAiQnJvY2FkZSBCRkEgRmlicmUgQ2hhbm5lbCBTdXBwb3J0IgorCWRlcGVuZHMgb24gUENJICYmIFNDU0kKKwlzZWxlY3QgU0NTSV9GQ19BVFRSUworCWhlbHAKKwkgIFRoaXMgYmZhIGRyaXZlciBzdXBwb3J0cyBhbGwgQnJvY2FkZSBQQ0llIEZDL0ZDT0UgaG9zdCBhZGFwdGVycy4KKworCSAgVG8gY29tcGlsZSB0aGlzIGRyaXZlciBhcyBhIG1vZHVsZSwgY2hvb3NlIE0gaGVyZS4gVGhlIG1vZHVsZSB3aWxsCisJICBiZSBjYWxsZWQgYmZhLgorCiBlbmRpZiAjIFNDU0lfTE9XTEVWRUwKIAogc291cmNlICJkcml2ZXJzL3Njc2kvcGNtY2lhL0tjb25maWciCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvTWFrZWZpbGUgYi9kcml2ZXJzL3Njc2kvTWFrZWZpbGUKaW5kZXggNjFhOTRhZi4uM2FkNjFkYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL01ha2VmaWxlCisrKyBiL2RyaXZlcnMvc2NzaS9NYWtlZmlsZQpAQCAtODYsNiArODYsNyBAQAogb2JqLSQoQ09ORklHX1NDU0lfUUxBX0ZDKQkrPSBxbGEyeHh4Lwogb2JqLSQoQ09ORklHX1NDU0lfUUxBX0lTQ1NJKQkrPSBxbGE0eHh4Lwogb2JqLSQoQ09ORklHX1NDU0lfTFBGQykJCSs9IGxwZmMvCitvYmotJChDT05GSUdfU0NTSV9CRkFfRkMpCSs9IGJmYS8KIG9iai0kKENPTkZJR19TQ1NJX1BBUzE2KQkrPSBwYXMxNi5vCiBvYmotJChDT05GSUdfU0NTSV9UMTI4KQkJKz0gdDEyOC5vCiBvYmotJChDT05GSUdfU0NTSV9ETVgzMTkxRCkJKz0gZG14MzE5MWQubwpAQCAtMTMwLDYgKzEzMSw3IEBACiBvYmotJChDT05GSUdfUFMzX1JPTSkJCSs9IHBzM3JvbS5vCiBvYmotJChDT05GSUdfU0NTSV9DWEdCM19JU0NTSSkJKz0gbGliaXNjc2kubyBsaWJpc2NzaV90Y3AubyBjeGdiM2kvCiBvYmotJChDT05GSUdfU0NTSV9CTlgyX0lTQ1NJKQkrPSBsaWJpc2NzaS5vIGJueDJpLworb2JqLSQoQ09ORklHX0JFMklTQ1NJKQkJKz0gbGliaXNjc2kubyBiZTJpc2NzaS8KIG9iai0kKENPTkZJR19TQ1NJX1BNQ1JBSUQpCSs9IHBtY3JhaWQubwogCiBvYmotJChDT05GSUdfQVJNKQkJKz0gYXJtLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JlMmlzY3NpL0tjb25maWcgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvS2NvbmZpZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yOTUyZmNkCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JlMmlzY3NpL0tjb25maWcKQEAgLTAsMCArMSw4IEBACitjb25maWcgQkUySVNDU0kKKwl0cmlzdGF0ZSAiU2VydmVyRW5naW5lcycgMTBHYnBzIGlTQ1NJIC0gQmxhZGVFbmdpbmUgMiIKKwlkZXBlbmRzIG9uIFBDSSAmJiBTQ1NJCisJc2VsZWN0IFNDU0lfSVNDU0lfQVRUUlMKKworCWhlbHAKKwlUaGlzIGRyaXZlciBpbXBsZW1lbnRzIHRoZSBpU0NTSSBmdW5jdGlvbmFsaXR5IGZvciBTZXJ2ZXJFbmdpbmVzJworCTEwR2JwcyBTdG9yYWdlIGFkYXB0ZXIgLSBCbGFkZUVuZ2luZSAyLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JlMmlzY3NpL01ha2VmaWxlIGIvZHJpdmVycy9zY3NpL2JlMmlzY3NpL01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMxMWY0NDMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvTWFrZWZpbGUKQEAgLTAsMCArMSw4IEBACisjCisjIE1ha2VmaWxlIHRvIGJ1aWxkIHRoZSBpU0NTSSBkcml2ZXIgZm9yIFNlcnZlckVuZ2luZSdzIEJsYWRlRW5naW5lLgorIworIworCitvYmotJChDT05GSUdfQkUySVNDU0kpICs9IGJlMmlzY3NpLm8KKworYmUyaXNjc2kteSA6PSBiZV9pc2NzaS5vIGJlX21haW4ubyBiZV9tZ210Lm8gYmVfY21kcy5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmUuaCBiL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIzNjAyMGQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmUuaApAQCAtMCwwICsxLDE4MyBAQAorLyoqCisgKiBDb3B5cmlnaHQgKEMpIDIwMDUgLSAyMDA5IFNlcnZlckVuZ2luZXMKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgorICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyCisgKiBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4gIFRoZSBmdWxsIEdOVSBHZW5lcmFsCisgKiBQdWJsaWMgTGljZW5zZSBpcyBpbmNsdWRlZCBpbiB0aGlzIGRpc3RyaWJ1dGlvbiBpbiB0aGUgZmlsZSBjYWxsZWQgQ09QWUlORy4KKyAqCisgKiBDb250YWN0IEluZm9ybWF0aW9uOgorICogbGludXgtZHJpdmVyc0BzZXJ2ZXJlbmdpbmVzLmNvbQorICoKKyAqIFNlcnZlckVuZ2luZXMKKyAqIDIwOSBOLiBGYWlyIE9ha3MgQXZlCisgKiBTdW5ueXZhbGUsIENBIDk0MDg1CisgKi8KKworI2lmbmRlZiBCRUlTQ1NJX0gKKyNkZWZpbmUgQkVJU0NTSV9ICisKKyNpbmNsdWRlIDxsaW51eC9wY2kuaD4KKyNpbmNsdWRlIDxsaW51eC9pZl92bGFuLmg+CisKKyNkZWZpbmUgRldfVkVSX0xFTiAzMgorCitzdHJ1Y3QgYmVfZG1hX21lbSB7CisJdm9pZCAqdmE7CisJZG1hX2FkZHJfdCBkbWE7CisJdTMyIHNpemU7Cit9OworCitzdHJ1Y3QgYmVfcXVldWVfaW5mbyB7CisJc3RydWN0IGJlX2RtYV9tZW0gZG1hX21lbTsKKwl1MTYgbGVuOworCXUxNiBlbnRyeV9zaXplOwkJLyogU2l6ZSBvZiBhbiBlbGVtZW50IGluIHRoZSBxdWV1ZSAqLworCXUxNiBpZDsKKwl1MTYgdGFpbCwgaGVhZDsKKwlib29sIGNyZWF0ZWQ7CisJYXRvbWljX3QgdXNlZDsJCS8qIE51bWJlciBvZiB2YWxpZCBlbGVtZW50cyBpbiB0aGUgcXVldWUgKi8KK307CisKK3N0YXRpYyBpbmxpbmUgdTMyIE1PRFVMTyh1MTYgdmFsLCB1MTYgbGltaXQpCit7CisJV0FSTl9PTihsaW1pdCAmIChsaW1pdCAtIDEpKTsKKwlyZXR1cm4gdmFsICYgKGxpbWl0IC0gMSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBpbmRleF9pbmModTE2ICppbmRleCwgdTE2IGxpbWl0KQoreworCSppbmRleCA9IE1PRFVMTygoKmluZGV4ICsgMSksIGxpbWl0KTsKK30KKworc3RhdGljIGlubGluZSB2b2lkICpxdWV1ZV9oZWFkX25vZGUoc3RydWN0IGJlX3F1ZXVlX2luZm8gKnEpCit7CisJcmV0dXJuIHEtPmRtYV9tZW0udmEgKyBxLT5oZWFkICogcS0+ZW50cnlfc2l6ZTsKK30KKworc3RhdGljIGlubGluZSB2b2lkICpxdWV1ZV90YWlsX25vZGUoc3RydWN0IGJlX3F1ZXVlX2luZm8gKnEpCit7CisJcmV0dXJuIHEtPmRtYV9tZW0udmEgKyBxLT50YWlsICogcS0+ZW50cnlfc2l6ZTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHF1ZXVlX2hlYWRfaW5jKHN0cnVjdCBiZV9xdWV1ZV9pbmZvICpxKQoreworCWluZGV4X2luYygmcS0+aGVhZCwgcS0+bGVuKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIHF1ZXVlX3RhaWxfaW5jKHN0cnVjdCBiZV9xdWV1ZV9pbmZvICpxKQoreworCWluZGV4X2luYygmcS0+dGFpbCwgcS0+bGVuKTsKK30KKworLypJU0NTSSAqLworCitzdHJ1Y3QgYmVfZXFfb2JqIHsKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyBxOworCWNoYXIgZGVzY1szMl07CisKKwkvKiBBZGFwdGl2ZSBpbnRlcnJ1cHQgY29hbGVzY2luZyAoQUlDKSBpbmZvICovCisJYm9vbCBlbmFibGVfYWljOworCXUxNiBtaW5fZXFkOwkJLyogaW4gdXNlY3MgKi8KKwl1MTYgbWF4X2VxZDsJCS8qIGluIHVzZWNzICovCisJdTE2IGN1cl9lcWQ7CQkvKiBpbiB1c2VjcyAqLworfTsKKworc3RydWN0IGJlX21jY19vYmogeworCXN0cnVjdCBiZV9xdWV1ZV9pbmZvICpxOworCXN0cnVjdCBiZV9xdWV1ZV9pbmZvICpjcTsKK307CisKK3N0cnVjdCBiZV9jdHJsX2luZm8geworCXU4IF9faW9tZW0gKmNzcjsKKwl1OCBfX2lvbWVtICpkYjsJCS8qIERvb3IgQmVsbCAqLworCXU4IF9faW9tZW0gKnBjaWNmZzsJLyogUENJIGNvbmZpZyBzcGFjZSAqLworCXN0cnVjdCBwY2lfZGV2ICpwZGV2OworCisJLyogTWJveCB1c2VkIGZvciBjbWQgcmVxdWVzdC9yZXNwb25zZSAqLworCXNwaW5sb2NrX3QgbWJveF9sb2NrOwkvKiBGb3Igc2VyaWFsaXppbmcgbWJveCBjbWRzIHRvIEJFIGNhcmQgKi8KKwlzdHJ1Y3QgYmVfZG1hX21lbSBtYm94X21lbTsKKwkvKiBNYm94IG1lbSBpcyBhZGp1c3RlZCB0byBhbGlnbiB0byAxNiBieXRlcy4gVGhlIGFsbG9jYXRlZCBhZGRyCisJICogaXMgc3RvcmVkIGZvciBmcmVlaW5nIHB1cnBvc2UgKi8KKwlzdHJ1Y3QgYmVfZG1hX21lbSBtYm94X21lbV9hbGxvY2VkOworCisJLyogTUNDIFJpbmdzICovCisJc3RydWN0IGJlX21jY19vYmogbWNjX29iajsKKwlzcGlubG9ja190IG1jY19sb2NrOwkvKiBGb3Igc2VyaWFsaXppbmcgbWNjIGNtZHMgdG8gQkUgY2FyZCAqLworCXNwaW5sb2NrX3QgbWNjX2NxX2xvY2s7CisKKwkvKiBNQ0MgQXN5bmMgY2FsbGJhY2sgKi8KKwl2b2lkICgqYXN5bmNfY2IpICh2b2lkICphZGFwdGVyLCBib29sIGxpbmtfdXApOworCXZvaWQgKmFkYXB0ZXJfY3R4dDsKK307CisKKyNpbmNsdWRlICJiZV9jbWRzLmgiCisKKyNkZWZpbmUgUEFHRV9TSElGVF80SyAxMgorI2RlZmluZSBQQUdFX1NJWkVfNEsgKDEgPDwgUEFHRV9TSElGVF80SykKKworLyogUmV0dXJucyBudW1iZXIgb2YgcGFnZXMgc3Bhbm5lZCBieSB0aGUgZGF0YSBzdGFydGluZyBhdCB0aGUgZ2l2ZW4gYWRkciAqLworI2RlZmluZSBQQUdFU180S19TUEFOTkVEKF9hZGRyZXNzLCBzaXplKSAJCQkJXAorCQkoKHUzMikoKCgoc2l6ZV90KShfYWRkcmVzcykgJiAoUEFHRV9TSVpFXzRLIC0gMSkpICsgCVwKKwkJCShzaXplKSArIChQQUdFX1NJWkVfNEsgLSAxKSkgPj4gUEFHRV9TSElGVF80SykpCisKKy8qIEJ5dGUgb2Zmc2V0IGludG8gdGhlIHBhZ2UgY29ycmVzcG9uZGluZyB0byBnaXZlbiBhZGRyZXNzICovCisjZGVmaW5lIE9GRlNFVF9JTl9QQUdFKGFkZHIpCQkJCQkJXAorCQkoKHNpemVfdCkoYWRkcikgJiAoUEFHRV9TSVpFXzRLLTEpKQorCisvKiBSZXR1cm5zIGJpdCBvZmZzZXQgd2l0aGluIGEgRFdPUkQgb2YgYSBiaXRmaWVsZCAqLworI2RlZmluZSBBTUFQX0JJVF9PRkZTRVQoX3N0cnVjdCwgZmllbGQpICAJCQkJXAorCQkoKChzaXplX3QpJigoKF9zdHJ1Y3QgKikwKS0+ZmllbGQpKSUzMikKKworLyogUmV0dXJucyB0aGUgYml0IG1hc2sgb2YgdGhlIGZpZWxkIHRoYXQgaXMgTk9UIHNoaWZ0ZWQgaW50byBsb2NhdGlvbi4gKi8KK3N0YXRpYyBpbmxpbmUgdTMyIGFtYXBfbWFzayh1MzIgYml0c2l6ZSkKK3sKKwlyZXR1cm4gKGJpdHNpemUgPT0gMzIgPyAweEZGRkZGRkZGIDogKDEgPDwgYml0c2l6ZSkgLSAxKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGFtYXBfc2V0KHZvaWQgKnB0ciwgdTMyIGR3X29mZnNldCwgdTMyIG1hc2ssCisJCQkJCXUzMiBvZmZzZXQsIHUzMiB2YWx1ZSkKK3sKKwl1MzIgKmR3ID0gKHUzMiAqKSBwdHIgKyBkd19vZmZzZXQ7CisJKmR3ICY9IH4obWFzayA8PCBvZmZzZXQpOworCSpkdyB8PSAobWFzayAmIHZhbHVlKSA8PCBvZmZzZXQ7Cit9CisKKyNkZWZpbmUgQU1BUF9TRVRfQklUUyhfc3RydWN0LCBmaWVsZCwgcHRyLCB2YWwpCQkJCVwKKwkJYW1hcF9zZXQocHRyLAkJCQkJCVwKKwkJCW9mZnNldG9mKF9zdHJ1Y3QsIGZpZWxkKS8zMiwJCQlcCisJCQlhbWFwX21hc2soc2l6ZW9mKCgoX3N0cnVjdCAqKTApLT5maWVsZCkpLAlcCisJCQlBTUFQX0JJVF9PRkZTRVQoX3N0cnVjdCwgZmllbGQpLAkJXAorCQkJdmFsKQorCitzdGF0aWMgaW5saW5lIHUzMiBhbWFwX2dldCh2b2lkICpwdHIsIHUzMiBkd19vZmZzZXQsIHUzMiBtYXNrLCB1MzIgb2Zmc2V0KQoreworCXUzMiAqZHcgPSBwdHI7CisJcmV0dXJuIG1hc2sgJiAoKihkdyArIGR3X29mZnNldCkgPj4gb2Zmc2V0KTsKK30KKworI2RlZmluZSBBTUFQX0dFVF9CSVRTKF9zdHJ1Y3QsIGZpZWxkLCBwdHIpCQkJCVwKKwkJYW1hcF9nZXQocHRyLAkJCQkJCVwKKwkJCW9mZnNldG9mKF9zdHJ1Y3QsIGZpZWxkKS8zMiwJCQlcCisJCQlhbWFwX21hc2soc2l6ZW9mKCgoX3N0cnVjdCAqKTApLT5maWVsZCkpLAlcCisJCQlBTUFQX0JJVF9PRkZTRVQoX3N0cnVjdCwgZmllbGQpKQorCisjZGVmaW5lIGJlX2R3c19jcHVfdG9fbGUod3JiLCBsZW4pIHN3YXBfZHdzKHdyYiwgbGVuKQorI2RlZmluZSBiZV9kd3NfbGVfdG9fY3B1KHdyYiwgbGVuKSBzd2FwX2R3cyh3cmIsIGxlbikKK3N0YXRpYyBpbmxpbmUgdm9pZCBzd2FwX2R3cyh2b2lkICp3cmIsIGludCBsZW4pCit7CisjaWZkZWYgX19CSUdfRU5ESUFOCisJdTMyICpkdyA9IHdyYjsKKwlXQVJOX09OKGxlbiAlIDQpOworCWRvIHsKKwkJKmR3ID0gY3B1X3RvX2xlMzIoKmR3KTsKKwkJZHcrKzsKKwkJbGVuIC09IDQ7CisJfSB3aGlsZSAobGVuKTsKKyNlbmRpZiAvKiBfX0JJR19FTkRJQU4gKi8KK30KKworZXh0ZXJuIHZvaWQgYmVpc2NzaV9jcV9ub3RpZnkoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCwgdTE2IHFpZCwgYm9vbCBhcm0sCisJCQkgICAgICB1MTYgbnVtX3BvcHBlZCk7CisKKyNlbmRpZiAvKiBCRUlTQ1NJX0ggKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9jbWRzLmMgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfY21kcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA4MDA3YjYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfY21kcy5jCkBAIC0wLDAgKzEsNTIzIEBACisvKioKKyAqIENvcHlyaWdodCAoQykgMjAwNSAtIDIwMDkgU2VydmVyRW5naW5lcworICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLiAgVGhlIGZ1bGwgR05VIEdlbmVyYWwKKyAqIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluIHRoZSBmaWxlIGNhbGxlZCBDT1BZSU5HLgorICoKKyAqIENvbnRhY3QgSW5mb3JtYXRpb246CisgKiBsaW51eC1kcml2ZXJzQHNlcnZlcmVuZ2luZXMuY29tCisgKgorICogU2VydmVyRW5naW5lcworICogMjA5IE4uIEZhaXIgT2FrcyBBdmUKKyAqIFN1bm55dmFsZSwgQ0EgOTQwODUKKyAqLworCisjaW5jbHVkZSAiYmUuaCIKKyNpbmNsdWRlICJiZV9tZ210LmgiCisjaW5jbHVkZSAiYmVfbWFpbi5oIgorCitzdGF0aWMgaW5saW5lIGJvb2wgYmVfbWNjX2NvbXBsX2lzX25ldyhzdHJ1Y3QgYmVfbWNjX2NvbXBsICpjb21wbCkKK3sKKwlpZiAoY29tcGwtPmZsYWdzICE9IDApIHsKKwkJY29tcGwtPmZsYWdzID0gbGUzMl90b19jcHUoY29tcGwtPmZsYWdzKTsKKwkJV0FSTl9PTigoY29tcGwtPmZsYWdzICYgQ1FFX0ZMQUdTX1ZBTElEX01BU0spID09IDApOworCQlyZXR1cm4gdHJ1ZTsKKwl9IGVsc2UKKwkJcmV0dXJuIGZhbHNlOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgYmVfbWNjX2NvbXBsX3VzZShzdHJ1Y3QgYmVfbWNjX2NvbXBsICpjb21wbCkKK3sKKwljb21wbC0+ZmxhZ3MgPSAwOworfQorCitzdGF0aWMgaW50IGJlX21jY19jb21wbF9wcm9jZXNzKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsCisJCQkJc3RydWN0IGJlX21jY19jb21wbCAqY29tcGwpCit7CisJdTE2IGNvbXBsX3N0YXR1cywgZXh0ZF9zdGF0dXM7CisKKwliZV9kd3NfbGVfdG9fY3B1KGNvbXBsLCA0KTsKKworCWNvbXBsX3N0YXR1cyA9IChjb21wbC0+c3RhdHVzID4+IENRRV9TVEFUVVNfQ09NUExfU0hJRlQpICYKKwkJCQkJQ1FFX1NUQVRVU19DT01QTF9NQVNLOworCWlmIChjb21wbF9zdGF0dXMgIT0gTUNDX1NUQVRVU19TVUNDRVNTKSB7CisJCWV4dGRfc3RhdHVzID0gKGNvbXBsLT5zdGF0dXMgPj4gQ1FFX1NUQVRVU19FWFREX1NISUZUKSAmCisJCQkJCQlDUUVfU1RBVFVTX0VYVERfTUFTSzsKKwkJZGV2X2VycigmY3RybC0+cGRldi0+ZGV2LAorCQkJImVycm9yIGluIGNtZCBjb21wbGV0aW9uOiBzdGF0dXMoY29tcGwvZXh0ZCk9JWQvJWRcbiIsCisJCQljb21wbF9zdGF0dXMsIGV4dGRfc3RhdHVzKTsKKwkJcmV0dXJuIC0xOworCX0KKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGlubGluZSBib29sIGlzX2xpbmtfc3RhdGVfZXZ0KHUzMiB0cmFpbGVyKQoreworCXJldHVybiAoKCh0cmFpbGVyID4+IEFTWU5DX1RSQUlMRVJfRVZFTlRfQ09ERV9TSElGVCkgJgorCQlBU1lOQ19UUkFJTEVSX0VWRU5UX0NPREVfTUFTSykgPT0gQVNZTkNfRVZFTlRfQ09ERV9MSU5LX1NUQVRFKTsKK30KKwordm9pZCBiZWlzY3NpX2NxX25vdGlmeShzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsLCB1MTYgcWlkLCBib29sIGFybSwKKwkJICAgICAgIHUxNiBudW1fcG9wcGVkKQoreworCXUzMiB2YWwgPSAwOworCXZhbCB8PSBxaWQgJiBEQl9DUV9SSU5HX0lEX01BU0s7CisJaWYgKGFybSkKKwkJdmFsIHw9IDEgPDwgREJfQ1FfUkVBUk1fU0hJRlQ7CisJdmFsIHw9IG51bV9wb3BwZWQgPDwgREJfQ1FfTlVNX1BPUFBFRF9TSElGVDsKKwlpb3dyaXRlMzIodmFsLCBjdHJsLT5kYiArIERCX0NRX09GRlNFVCk7Cit9CisKK3N0YXRpYyBpbnQgYmVfbWJveF9kYl9yZWFkeV93YWl0KHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwpCit7CisjZGVmaW5lIGxvbmdfZGVsYXkgMjAwMAorCXZvaWQgX19pb21lbSAqZGIgPSBjdHJsLT5kYiArIE1QVV9NQUlMQk9YX0RCX09GRlNFVDsKKwlpbnQgY250ID0gMCwgd2FpdCA9IDU7CS8qIGluIHVzZWNzICovCisJdTMyIHJlYWR5OworCisJZG8geworCQlyZWFkeSA9IGlvcmVhZDMyKGRiKSAmIE1QVV9NQUlMQk9YX0RCX1JEWV9NQVNLOworCQlpZiAocmVhZHkpCisJCQlicmVhazsKKworCQlpZiAoY250ID4gNjAwMDAwMCkgeworCQkJZGV2X2VycigmY3RybC0+cGRldi0+ZGV2LCAibWJveF9kYiBwb2xsIHRpbWVkIG91dFxuIik7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQlpZiAoY250ID4gNTApIHsKKwkJCXdhaXQgPSBsb25nX2RlbGF5OworCQkJbWRlbGF5KGxvbmdfZGVsYXkgLyAxMDAwKTsKKwkJfSBlbHNlCisJCQl1ZGVsYXkod2FpdCk7CisJCWNudCArPSB3YWl0OworCX0gd2hpbGUgKHRydWUpOworCXJldHVybiAwOworfQorCitpbnQgYmVfbWJveF9ub3RpZnkoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCkKK3sKKwlpbnQgc3RhdHVzOworCXUzMiB2YWwgPSAwOworCXZvaWQgX19pb21lbSAqZGIgPSBjdHJsLT5kYiArIE1QVV9NQUlMQk9YX0RCX09GRlNFVDsKKwlzdHJ1Y3QgYmVfZG1hX21lbSAqbWJveF9tZW0gPSAmY3RybC0+bWJveF9tZW07CisJc3RydWN0IGJlX21jY19tYWlsYm94ICptYm94ID0gbWJveF9tZW0tPnZhOworCXN0cnVjdCBiZV9tY2NfY29tcGwgKmNvbXBsID0gJm1ib3gtPmNvbXBsOworCisJdmFsICY9IH5NUFVfTUFJTEJPWF9EQl9SRFlfTUFTSzsKKwl2YWwgfD0gTVBVX01BSUxCT1hfREJfSElfTUFTSzsKKwl2YWwgfD0gKHVwcGVyXzMyX2JpdHMobWJveF9tZW0tPmRtYSkgPj4gMikgPDwgMjsKKwlpb3dyaXRlMzIodmFsLCBkYik7CisKKwlzdGF0dXMgPSBiZV9tYm94X2RiX3JlYWR5X3dhaXQoY3RybCk7CisJaWYgKHN0YXR1cyAhPSAwKSB7CisJCVNFX0RFQlVHKERCR19MVkxfMSwgIiBiZV9tYm94X2RiX3JlYWR5X3dhaXQgZmFpbGVkIDFcbiIpOworCQlyZXR1cm4gc3RhdHVzOworCX0KKwl2YWwgPSAwOworCXZhbCAmPSB+TVBVX01BSUxCT1hfREJfUkRZX01BU0s7CisJdmFsICY9IH5NUFVfTUFJTEJPWF9EQl9ISV9NQVNLOworCXZhbCB8PSAodTMyKSAobWJveF9tZW0tPmRtYSA+PiA0KSA8PCAyOworCWlvd3JpdGUzMih2YWwsIGRiKTsKKworCXN0YXR1cyA9IGJlX21ib3hfZGJfcmVhZHlfd2FpdChjdHJsKTsKKwlpZiAoc3RhdHVzICE9IDApIHsKKwkJU0VfREVCVUcoREJHX0xWTF8xLCAiIGJlX21ib3hfZGJfcmVhZHlfd2FpdCBmYWlsZWQgMlxuIik7CisJCXJldHVybiBzdGF0dXM7CisJfQorCWlmIChiZV9tY2NfY29tcGxfaXNfbmV3KGNvbXBsKSkgeworCQlzdGF0dXMgPSBiZV9tY2NfY29tcGxfcHJvY2VzcyhjdHJsLCAmbWJveC0+Y29tcGwpOworCQliZV9tY2NfY29tcGxfdXNlKGNvbXBsKTsKKwkJaWYgKHN0YXR1cykgeworCQkJU0VfREVCVUcoREJHX0xWTF8xLCAiQWZ0ZXIgYmVfbWNjX2NvbXBsX3Byb2Nlc3MgXG4iKTsKKwkJCXJldHVybiBzdGF0dXM7CisJCX0KKwl9IGVsc2UgeworCQlkZXZfZXJyKCZjdHJsLT5wZGV2LT5kZXYsICJpbnZhbGlkIG1haWxib3ggY29tcGxldGlvblxuIik7CisJCXJldHVybiAtMTsKKwl9CisJcmV0dXJuIDA7Cit9CisKK3ZvaWQgYmVfd3JiX2hkcl9wcmVwYXJlKHN0cnVjdCBiZV9tY2Nfd3JiICp3cmIsIGludCBwYXlsb2FkX2xlbiwKKwkJCQlib29sIGVtYmVkZGVkLCB1OCBzZ2VfY250KQoreworCWlmIChlbWJlZGRlZCkKKwkJd3JiLT5lbWJlZGRlZCB8PSBNQ0NfV1JCX0VNQkVEREVEX01BU0s7CisJZWxzZQorCQl3cmItPmVtYmVkZGVkIHw9IChzZ2VfY250ICYgTUNDX1dSQl9TR0VfQ05UX01BU0spIDw8CisJCQkJCQlNQ0NfV1JCX1NHRV9DTlRfU0hJRlQ7CisJd3JiLT5wYXlsb2FkX2xlbmd0aCA9IHBheWxvYWRfbGVuOworCWJlX2R3c19jcHVfdG9fbGUod3JiLCA4KTsKK30KKwordm9pZCBiZV9jbWRfaGRyX3ByZXBhcmUoc3RydWN0IGJlX2NtZF9yZXFfaGRyICpyZXFfaGRyLAorCQkJdTggc3Vic3lzdGVtLCB1OCBvcGNvZGUsIGludCBjbWRfbGVuKQoreworCXJlcV9oZHItPm9wY29kZSA9IG9wY29kZTsKKwlyZXFfaGRyLT5zdWJzeXN0ZW0gPSBzdWJzeXN0ZW07CisJcmVxX2hkci0+cmVxdWVzdF9sZW5ndGggPSBjcHVfdG9fbGUzMihjbWRfbGVuIC0gc2l6ZW9mKCpyZXFfaGRyKSk7Cit9CisKK3N0YXRpYyB2b2lkIGJlX2NtZF9wYWdlX2FkZHJzX3ByZXBhcmUoc3RydWN0IHBoeXNfYWRkciAqcGFnZXMsIHUzMiBtYXhfcGFnZXMsCisJCQkJCQkJc3RydWN0IGJlX2RtYV9tZW0gKm1lbSkKK3sKKwlpbnQgaSwgYnVmX3BhZ2VzOworCXU2NCBkbWEgPSAodTY0KSBtZW0tPmRtYTsKKworCWJ1Zl9wYWdlcyA9IG1pbihQQUdFU180S19TUEFOTkVEKG1lbS0+dmEsIG1lbS0+c2l6ZSksIG1heF9wYWdlcyk7CisJZm9yIChpID0gMDsgaSA8IGJ1Zl9wYWdlczsgaSsrKSB7CisJCXBhZ2VzW2ldLmxvID0gY3B1X3RvX2xlMzIoZG1hICYgMHhGRkZGRkZGRik7CisJCXBhZ2VzW2ldLmhpID0gY3B1X3RvX2xlMzIodXBwZXJfMzJfYml0cyhkbWEpKTsKKwkJZG1hICs9IFBBR0VfU0laRV80SzsKKwl9Cit9CisKK3N0YXRpYyB1MzIgZXFfZGVsYXlfdG9fbXVsdCh1MzIgdXNlY19kZWxheSkKK3sKKyNkZWZpbmUgTUFYX0lOVFJfUkFURSA2NTEwNDIKKwljb25zdCB1MzIgcm91bmQgPSAxMDsKKwl1MzIgbXVsdGlwbGllcjsKKworCWlmICh1c2VjX2RlbGF5ID09IDApCisJCW11bHRpcGxpZXIgPSAwOworCWVsc2UgeworCQl1MzIgaW50ZXJydXB0X3JhdGUgPSAxMDAwMDAwIC8gdXNlY19kZWxheTsKKwkJaWYgKGludGVycnVwdF9yYXRlID09IDApCisJCQltdWx0aXBsaWVyID0gMTAyMzsKKwkJZWxzZSB7CisJCQltdWx0aXBsaWVyID0gKE1BWF9JTlRSX1JBVEUgLSBpbnRlcnJ1cHRfcmF0ZSkgKiByb3VuZDsKKwkJCW11bHRpcGxpZXIgLz0gaW50ZXJydXB0X3JhdGU7CisJCQltdWx0aXBsaWVyID0gKG11bHRpcGxpZXIgKyByb3VuZCAvIDIpIC8gcm91bmQ7CisJCQltdWx0aXBsaWVyID0gbWluKG11bHRpcGxpZXIsICh1MzIpIDEwMjMpOworCQl9CisJfQorCXJldHVybiBtdWx0aXBsaWVyOworfQorCitzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiX2Zyb21fbWJveChzdHJ1Y3QgYmVfZG1hX21lbSAqbWJveF9tZW0pCit7CisJcmV0dXJuICYoKHN0cnVjdCBiZV9tY2NfbWFpbGJveCAqKShtYm94X21lbS0+dmEpKS0+d3JiOworfQorCitpbnQgYmVpc2NzaV9jbWRfZXFfY3JlYXRlKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsCisJCQkgIHN0cnVjdCBiZV9xdWV1ZV9pbmZvICplcSwgaW50IGVxX2RlbGF5KQoreworCXN0cnVjdCBiZV9tY2Nfd3JiICp3cmIgPSB3cmJfZnJvbV9tYm94KCZjdHJsLT5tYm94X21lbSk7CisJc3RydWN0IGJlX2NtZF9yZXFfZXFfY3JlYXRlICpyZXEgPSBlbWJlZGRlZF9wYXlsb2FkKHdyYik7CisJc3RydWN0IGJlX2NtZF9yZXNwX2VxX2NyZWF0ZSAqcmVzcCA9IGVtYmVkZGVkX3BheWxvYWQod3JiKTsKKwlzdHJ1Y3QgYmVfZG1hX21lbSAqcV9tZW0gPSAmZXEtPmRtYV9tZW07CisJaW50IHN0YXR1czsKKworCXNwaW5fbG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwltZW1zZXQod3JiLCAwLCBzaXplb2YoKndyYikpOworCisJYmVfd3JiX2hkcl9wcmVwYXJlKHdyYiwgc2l6ZW9mKCpyZXEpLCB0cnVlLCAwKTsKKworCWJlX2NtZF9oZHJfcHJlcGFyZSgmcmVxLT5oZHIsIENNRF9TVUJTWVNURU1fQ09NTU9OLAorCQkJT1BDT0RFX0NPTU1PTl9FUV9DUkVBVEUsIHNpemVvZigqcmVxKSk7CisKKwlyZXEtPm51bV9wYWdlcyA9IGNwdV90b19sZTE2KFBBR0VTXzRLX1NQQU5ORUQocV9tZW0tPnZhLCBxX21lbS0+c2l6ZSkpOworCisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9lcV9jb250ZXh0LCBmdW5jLCByZXEtPmNvbnRleHQsCisJCQkJCQlQQ0lfRlVOQyhjdHJsLT5wZGV2LT5kZXZmbikpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfZXFfY29udGV4dCwgdmFsaWQsIHJlcS0+Y29udGV4dCwgMSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9lcV9jb250ZXh0LCBzaXplLCByZXEtPmNvbnRleHQsIDApOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfZXFfY29udGV4dCwgY291bnQsIHJlcS0+Y29udGV4dCwKKwkJCQkJX19pbG9nMl91MzIoZXEtPmxlbiAvIDI1NikpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfZXFfY29udGV4dCwgZGVsYXltdWx0LCByZXEtPmNvbnRleHQsCisJCQkJCWVxX2RlbGF5X3RvX211bHQoZXFfZGVsYXkpKTsKKwliZV9kd3NfY3B1X3RvX2xlKHJlcS0+Y29udGV4dCwgc2l6ZW9mKHJlcS0+Y29udGV4dCkpOworCisJYmVfY21kX3BhZ2VfYWRkcnNfcHJlcGFyZShyZXEtPnBhZ2VzLCBBUlJBWV9TSVpFKHJlcS0+cGFnZXMpLCBxX21lbSk7CisKKwlzdGF0dXMgPSBiZV9tYm94X25vdGlmeShjdHJsKTsKKwlpZiAoIXN0YXR1cykgeworCQllcS0+aWQgPSBsZTE2X3RvX2NwdShyZXNwLT5lcV9pZCk7CisJCWVxLT5jcmVhdGVkID0gdHJ1ZTsKKwl9CisJc3Bpbl91bmxvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJcmV0dXJuIHN0YXR1czsKK30KKworaW50IGJlX2NtZF9md19pbml0aWFsaXplKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwpCit7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlpbnQgc3RhdHVzOworCXU4ICplbmRpYW5fY2hlY2s7CisKKwlzcGluX2xvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJbWVtc2V0KHdyYiwgMCwgc2l6ZW9mKCp3cmIpKTsKKworCWVuZGlhbl9jaGVjayA9ICh1OCAqKSB3cmI7CisJKmVuZGlhbl9jaGVjaysrID0gMHhGRjsKKwkqZW5kaWFuX2NoZWNrKysgPSAweDEyOworCSplbmRpYW5fY2hlY2srKyA9IDB4MzQ7CisJKmVuZGlhbl9jaGVjaysrID0gMHhGRjsKKwkqZW5kaWFuX2NoZWNrKysgPSAweEZGOworCSplbmRpYW5fY2hlY2srKyA9IDB4NTY7CisJKmVuZGlhbl9jaGVjaysrID0gMHg3ODsKKwkqZW5kaWFuX2NoZWNrKysgPSAweEZGOworCWJlX2R3c19jcHVfdG9fbGUod3JiLCBzaXplb2YoKndyYikpOworCisJc3RhdHVzID0gYmVfbWJveF9ub3RpZnkoY3RybCk7CisJaWYgKHN0YXR1cykKKwkJU0VfREVCVUcoREJHX0xWTF8xLCAiYmVfY21kX2Z3X2luaXRpYWxpemUgRmFpbGVkIFxuIik7CisKKwlzcGluX3VubG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwlyZXR1cm4gc3RhdHVzOworfQorCitpbnQgYmVpc2NzaV9jbWRfY3FfY3JlYXRlKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsCisJCQkgIHN0cnVjdCBiZV9xdWV1ZV9pbmZvICpjcSwgc3RydWN0IGJlX3F1ZXVlX2luZm8gKmVxLAorCQkJICBib29sIHNvbF9ldnRzLCBib29sIG5vX2RlbGF5LCBpbnQgY29hbGVzY2Vfd20pCit7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9jcV9jcmVhdGUgKnJlcSA9IGVtYmVkZGVkX3BheWxvYWQod3JiKTsKKwlzdHJ1Y3QgYmVfY21kX3Jlc3BfY3FfY3JlYXRlICpyZXNwID0gZW1iZWRkZWRfcGF5bG9hZCh3cmIpOworCXN0cnVjdCBiZV9kbWFfbWVtICpxX21lbSA9ICZjcS0+ZG1hX21lbTsKKwl2b2lkICpjdHh0ID0gJnJlcS0+Y29udGV4dDsKKwlpbnQgc3RhdHVzOworCisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisKKwliZV93cmJfaGRyX3ByZXBhcmUod3JiLCBzaXplb2YoKnJlcSksIHRydWUsIDApOworCisJYmVfY21kX2hkcl9wcmVwYXJlKCZyZXEtPmhkciwgQ01EX1NVQlNZU1RFTV9DT01NT04sCisJCQlPUENPREVfQ09NTU9OX0NRX0NSRUFURSwgc2l6ZW9mKCpyZXEpKTsKKworCWlmICghcV9tZW0tPnZhKQorCQlTRV9ERUJVRyhEQkdfTFZMXzEsICJ1bmluaXRpYWxpemVkIHFfbWVtLT52YVxuIik7CisKKwlyZXEtPm51bV9wYWdlcyA9IGNwdV90b19sZTE2KFBBR0VTXzRLX1NQQU5ORUQocV9tZW0tPnZhLCBxX21lbS0+c2l6ZSkpOworCisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9jcV9jb250ZXh0LCBjb2FsZXNjd20sIGN0eHQsIGNvYWxlc2NlX3dtKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2NxX2NvbnRleHQsIG5vZGVsYXksIGN0eHQsIG5vX2RlbGF5KTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2NxX2NvbnRleHQsIGNvdW50LCBjdHh0LAorCQkgICAgICBfX2lsb2cyX3UzMihjcS0+bGVuIC8gMjU2KSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9jcV9jb250ZXh0LCB2YWxpZCwgY3R4dCwgMSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9jcV9jb250ZXh0LCBzb2xldmVudCwgY3R4dCwgc29sX2V2dHMpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfY3FfY29udGV4dCwgZXZlbnRhYmxlLCBjdHh0LCAxKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2NxX2NvbnRleHQsIGVxaWQsIGN0eHQsIGVxLT5pZCk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9jcV9jb250ZXh0LCBhcm1lZCwgY3R4dCwgMSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9jcV9jb250ZXh0LCBmdW5jLCBjdHh0LAorCQkgICAgICBQQ0lfRlVOQyhjdHJsLT5wZGV2LT5kZXZmbikpOworCWJlX2R3c19jcHVfdG9fbGUoY3R4dCwgc2l6ZW9mKHJlcS0+Y29udGV4dCkpOworCisJYmVfY21kX3BhZ2VfYWRkcnNfcHJlcGFyZShyZXEtPnBhZ2VzLCBBUlJBWV9TSVpFKHJlcS0+cGFnZXMpLCBxX21lbSk7CisKKwlzdGF0dXMgPSBiZV9tYm94X25vdGlmeShjdHJsKTsKKwlpZiAoIXN0YXR1cykgeworCQljcS0+aWQgPSBsZTE2X3RvX2NwdShyZXNwLT5jcV9pZCk7CisJCWNxLT5jcmVhdGVkID0gdHJ1ZTsKKwl9IGVsc2UKKwkJU0VfREVCVUcoREJHX0xWTF8xLCAiSW4gYmVfY21kX2NxX2NyZWF0ZSwgc3RhdHVzPW94JTA4eCBcbiIsCisJCQlzdGF0dXMpOworCXNwaW5fdW5sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCisJcmV0dXJuIHN0YXR1czsKK30KKworc3RhdGljIHUzMiBiZV9lbmNvZGVkX3FfbGVuKGludCBxX2xlbikKK3sKKwl1MzIgbGVuX2VuY29kZWQgPSBmbHMocV9sZW4pOwkvKiBsb2cyKGxlbikgKyAxICovCisJaWYgKGxlbl9lbmNvZGVkID09IDE2KQorCQlsZW5fZW5jb2RlZCA9IDA7CisJcmV0dXJuIGxlbl9lbmNvZGVkOworfQoraW50IGJlaXNjc2lfY21kX3FfZGVzdHJveShzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsLCBzdHJ1Y3QgYmVfcXVldWVfaW5mbyAqcSwKKwkJCSAgaW50IHF1ZXVlX3R5cGUpCit7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9xX2Rlc3Ryb3kgKnJlcSA9IGVtYmVkZGVkX3BheWxvYWQod3JiKTsKKwl1OCBzdWJzeXMgPSAwLCBvcGNvZGUgPSAwOworCWludCBzdGF0dXM7CisKKwlzcGluX2xvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJbWVtc2V0KHdyYiwgMCwgc2l6ZW9mKCp3cmIpKTsKKwliZV93cmJfaGRyX3ByZXBhcmUod3JiLCBzaXplb2YoKnJlcSksIHRydWUsIDApOworCisJc3dpdGNoIChxdWV1ZV90eXBlKSB7CisJY2FzZSBRVFlQRV9FUToKKwkJc3Vic3lzID0gQ01EX1NVQlNZU1RFTV9DT01NT047CisJCW9wY29kZSA9IE9QQ09ERV9DT01NT05fRVFfREVTVFJPWTsKKwkJYnJlYWs7CisJY2FzZSBRVFlQRV9DUToKKwkJc3Vic3lzID0gQ01EX1NVQlNZU1RFTV9DT01NT047CisJCW9wY29kZSA9IE9QQ09ERV9DT01NT05fQ1FfREVTVFJPWTsKKwkJYnJlYWs7CisJY2FzZSBRVFlQRV9XUkJROgorCQlzdWJzeXMgPSBDTURfU1VCU1lTVEVNX0lTQ1NJOworCQlvcGNvZGUgPSBPUENPREVfQ09NTU9OX0lTQ1NJX1dSQlFfREVTVFJPWTsKKwkJYnJlYWs7CisJY2FzZSBRVFlQRV9EUERVUToKKwkJc3Vic3lzID0gQ01EX1NVQlNZU1RFTV9JU0NTSTsKKwkJb3Bjb2RlID0gT1BDT0RFX0NPTU1PTl9JU0NTSV9ERUZRX0RFU1RST1k7CisJCWJyZWFrOworCWNhc2UgUVRZUEVfU0dMOgorCQlzdWJzeXMgPSBDTURfU1VCU1lTVEVNX0lTQ1NJOworCQlvcGNvZGUgPSBPUENPREVfQ09NTU9OX0lTQ1NJX0NGR19SRU1PVkVfU0dMX1BBR0VTOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlzcGluX3VubG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwkJQlVHKCk7CisJCXJldHVybiAtMTsKKwl9CisJYmVfY21kX2hkcl9wcmVwYXJlKCZyZXEtPmhkciwgc3Vic3lzLCBvcGNvZGUsIHNpemVvZigqcmVxKSk7CisJaWYgKHF1ZXVlX3R5cGUgIT0gUVRZUEVfU0dMKQorCQlyZXEtPmlkID0gY3B1X3RvX2xlMTYocS0+aWQpOworCisJc3RhdHVzID0gYmVfbWJveF9ub3RpZnkoY3RybCk7CisKKwlzcGluX3VubG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwlyZXR1cm4gc3RhdHVzOworfQorCitpbnQgYmVfY21kX2dldF9tYWNfYWRkcihzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsLCB1OCAqbWFjX2FkZHIpCit7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9nZXRfbWFjX2FkZHIgKnJlcSA9IGVtYmVkZGVkX3BheWxvYWQod3JiKTsKKwlpbnQgc3RhdHVzOworCisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisJYmVfd3JiX2hkcl9wcmVwYXJlKHdyYiwgc2l6ZW9mKCpyZXEpLCB0cnVlLCAwKTsKKwliZV9jbWRfaGRyX3ByZXBhcmUoJnJlcS0+aGRyLCBDTURfU1VCU1lTVEVNX0lTQ1NJLAorCQkJICAgT1BDT0RFX0NPTU1PTl9JU0NTSV9OVFdLX0dFVF9OSUNfQ09ORklHLAorCQkJICAgc2l6ZW9mKCpyZXEpKTsKKworCXN0YXR1cyA9IGJlX21ib3hfbm90aWZ5KGN0cmwpOworCWlmICghc3RhdHVzKSB7CisJCXN0cnVjdCBiZV9jbWRfcmVzcF9nZXRfbWFjX2FkZHIgKnJlc3AgPSBlbWJlZGRlZF9wYXlsb2FkKHdyYik7CisKKwkJbWVtY3B5KG1hY19hZGRyLCByZXNwLT5tYWNfYWRkcmVzcywgRVRIX0FMRU4pOworCX0KKworCXNwaW5fdW5sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCXJldHVybiBzdGF0dXM7Cit9CisKK2ludCBiZV9jbWRfY3JlYXRlX2RlZmF1bHRfcGR1X3F1ZXVlKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsCisJCQkJICAgIHN0cnVjdCBiZV9xdWV1ZV9pbmZvICpjcSwKKwkJCQkgICAgc3RydWN0IGJlX3F1ZXVlX2luZm8gKmRxLCBpbnQgbGVuZ3RoLAorCQkJCSAgICBpbnQgZW50cnlfc2l6ZSkKK3sKKwlzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiID0gd3JiX2Zyb21fbWJveCgmY3RybC0+bWJveF9tZW0pOworCXN0cnVjdCBiZV9kZWZxX2NyZWF0ZV9yZXEgKnJlcSA9IGVtYmVkZGVkX3BheWxvYWQod3JiKTsKKwlzdHJ1Y3QgYmVfZG1hX21lbSAqcV9tZW0gPSAmZHEtPmRtYV9tZW07CisJdm9pZCAqY3R4dCA9ICZyZXEtPmNvbnRleHQ7CisJaW50IHN0YXR1czsKKworCXNwaW5fbG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwltZW1zZXQod3JiLCAwLCBzaXplb2YoKndyYikpOworCisJYmVfd3JiX2hkcl9wcmVwYXJlKHdyYiwgc2l6ZW9mKCpyZXEpLCB0cnVlLCAwKTsKKworCWJlX2NtZF9oZHJfcHJlcGFyZSgmcmVxLT5oZHIsIENNRF9TVUJTWVNURU1fSVNDU0ksCisJCQkgICBPUENPREVfQ09NTU9OX0lTQ1NJX0RFRlFfQ1JFQVRFLCBzaXplb2YoKnJlcSkpOworCisJcmVxLT5udW1fcGFnZXMgPSBQQUdFU180S19TUEFOTkVEKHFfbWVtLT52YSwgcV9tZW0tPnNpemUpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfYmVfZGVmYXVsdF9wZHVfY29udGV4dCwgcnhfcGRpZCwgY3R4dCwgMCk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9iZV9kZWZhdWx0X3BkdV9jb250ZXh0LCByeF9wZGlkX3ZhbGlkLCBjdHh0LAorCQkgICAgICAxKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2JlX2RlZmF1bHRfcGR1X2NvbnRleHQsIHBjaV9mdW5jX2lkLCBjdHh0LAorCQkgICAgICBQQ0lfRlVOQyhjdHJsLT5wZGV2LT5kZXZmbikpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfYmVfZGVmYXVsdF9wZHVfY29udGV4dCwgcmluZ19zaXplLCBjdHh0LAorCQkgICAgICBiZV9lbmNvZGVkX3FfbGVuKGxlbmd0aCAvIHNpemVvZihzdHJ1Y3QgcGh5c19hZGRyKSkpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfYmVfZGVmYXVsdF9wZHVfY29udGV4dCwgZGVmYXVsdF9idWZmZXJfc2l6ZSwKKwkJICAgICAgY3R4dCwgZW50cnlfc2l6ZSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9iZV9kZWZhdWx0X3BkdV9jb250ZXh0LCBjcV9pZF9yZWN2LCBjdHh0LAorCQkgICAgICBjcS0+aWQpOworCisJYmVfZHdzX2NwdV90b19sZShjdHh0LCBzaXplb2YocmVxLT5jb250ZXh0KSk7CisKKwliZV9jbWRfcGFnZV9hZGRyc19wcmVwYXJlKHJlcS0+cGFnZXMsIEFSUkFZX1NJWkUocmVxLT5wYWdlcyksIHFfbWVtKTsKKworCXN0YXR1cyA9IGJlX21ib3hfbm90aWZ5KGN0cmwpOworCWlmICghc3RhdHVzKSB7CisJCXN0cnVjdCBiZV9kZWZxX2NyZWF0ZV9yZXNwICpyZXNwID0gZW1iZWRkZWRfcGF5bG9hZCh3cmIpOworCisJCWRxLT5pZCA9IGxlMTZfdG9fY3B1KHJlc3AtPmlkKTsKKwkJZHEtPmNyZWF0ZWQgPSB0cnVlOworCX0KKwlzcGluX3VubG9jaygmY3RybC0+bWJveF9sb2NrKTsKKworCXJldHVybiBzdGF0dXM7Cit9CisKK2ludCBiZV9jbWRfd3JicV9jcmVhdGUoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCwgc3RydWN0IGJlX2RtYV9tZW0gKnFfbWVtLAorCQkgICAgICAgc3RydWN0IGJlX3F1ZXVlX2luZm8gKndyYnEpCit7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlzdHJ1Y3QgYmVfd3JicV9jcmVhdGVfcmVxICpyZXEgPSBlbWJlZGRlZF9wYXlsb2FkKHdyYik7CisJc3RydWN0IGJlX3dyYnFfY3JlYXRlX3Jlc3AgKnJlc3AgPSBlbWJlZGRlZF9wYXlsb2FkKHdyYik7CisJaW50IHN0YXR1czsKKworCXNwaW5fbG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwltZW1zZXQod3JiLCAwLCBzaXplb2YoKndyYikpOworCisJYmVfd3JiX2hkcl9wcmVwYXJlKHdyYiwgc2l6ZW9mKCpyZXEpLCB0cnVlLCAwKTsKKworCWJlX2NtZF9oZHJfcHJlcGFyZSgmcmVxLT5oZHIsIENNRF9TVUJTWVNURU1fSVNDU0ksCisJCU9QQ09ERV9DT01NT05fSVNDU0lfV1JCUV9DUkVBVEUsIHNpemVvZigqcmVxKSk7CisJcmVxLT5udW1fcGFnZXMgPSBQQUdFU180S19TUEFOTkVEKHFfbWVtLT52YSwgcV9tZW0tPnNpemUpOworCWJlX2NtZF9wYWdlX2FkZHJzX3ByZXBhcmUocmVxLT5wYWdlcywgQVJSQVlfU0laRShyZXEtPnBhZ2VzKSwgcV9tZW0pOworCisJc3RhdHVzID0gYmVfbWJveF9ub3RpZnkoY3RybCk7CisJaWYgKCFzdGF0dXMpCisJCXdyYnEtPmlkID0gbGUxNl90b19jcHUocmVzcC0+Y2lkKTsKKwlzcGluX3VubG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwlyZXR1cm4gc3RhdHVzOworfQorCitpbnQgYmVfY21kX2lzY3NpX3Bvc3Rfc2dsX3BhZ2VzKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsCisJCQkJc3RydWN0IGJlX2RtYV9tZW0gKnFfbWVtLAorCQkJCXUzMiBwYWdlX29mZnNldCwgdTMyIG51bV9wYWdlcykKK3sKKwlzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiID0gd3JiX2Zyb21fbWJveCgmY3RybC0+bWJveF9tZW0pOworCXN0cnVjdCBiZV9wb3N0X3NnbF9wYWdlc19yZXEgKnJlcSA9IGVtYmVkZGVkX3BheWxvYWQod3JiKTsKKwlpbnQgc3RhdHVzOworCXVuc2lnbmVkIGludCBjdXJyX3BhZ2VzOworCXUzMiBpbnRlcm5hbF9wYWdlX29mZnNldCA9IDA7CisJdTMyIHRlbXBfbnVtX3BhZ2VzID0gbnVtX3BhZ2VzOworCisJaWYgKG51bV9wYWdlcyA9PSAweGZmKQorCQludW1fcGFnZXMgPSAxOworCisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCWRvIHsKKwkJbWVtc2V0KHdyYiwgMCwgc2l6ZW9mKCp3cmIpKTsKKwkJYmVfd3JiX2hkcl9wcmVwYXJlKHdyYiwgc2l6ZW9mKCpyZXEpLCB0cnVlLCAwKTsKKwkJYmVfY21kX2hkcl9wcmVwYXJlKCZyZXEtPmhkciwgQ01EX1NVQlNZU1RFTV9JU0NTSSwKKwkJCQkgICBPUENPREVfQ09NTU9OX0lTQ1NJX0NGR19QT1NUX1NHTF9QQUdFUywKKwkJCQkgICBzaXplb2YoKnJlcSkpOworCQljdXJyX3BhZ2VzID0gQkVfTlVNQkVSX09GX0ZJRUxEKHN0cnVjdCBiZV9wb3N0X3NnbF9wYWdlc19yZXEsCisJCQkJCQlwYWdlcyk7CisJCXJlcS0+bnVtX3BhZ2VzID0gbWluKG51bV9wYWdlcywgY3Vycl9wYWdlcyk7CisJCXJlcS0+cGFnZV9vZmZzZXQgPSBwYWdlX29mZnNldDsKKwkJYmVfY21kX3BhZ2VfYWRkcnNfcHJlcGFyZShyZXEtPnBhZ2VzLCByZXEtPm51bV9wYWdlcywgcV9tZW0pOworCQlxX21lbS0+ZG1hID0gcV9tZW0tPmRtYSArIChyZXEtPm51bV9wYWdlcyAqIFBBR0VfU0laRSk7CisJCWludGVybmFsX3BhZ2Vfb2Zmc2V0ICs9IHJlcS0+bnVtX3BhZ2VzOworCQlwYWdlX29mZnNldCArPSByZXEtPm51bV9wYWdlczsKKwkJbnVtX3BhZ2VzIC09IHJlcS0+bnVtX3BhZ2VzOworCisJCWlmICh0ZW1wX251bV9wYWdlcyA9PSAweGZmKQorCQkJcmVxLT5udW1fcGFnZXMgPSB0ZW1wX251bV9wYWdlczsKKworCQlzdGF0dXMgPSBiZV9tYm94X25vdGlmeShjdHJsKTsKKwkJaWYgKHN0YXR1cykgeworCQkJU0VfREVCVUcoREJHX0xWTF8xLAorCQkJCSAiRlcgQ01EIHRvIG1hcCBpc2NzaSBmcmFncyBmYWlsZWQuXG4iKTsKKwkJCWdvdG8gZXJyb3I7CisJCX0KKwl9IHdoaWxlIChudW1fcGFnZXMgPiAwKTsKK2Vycm9yOgorCXNwaW5fdW5sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCWlmIChzdGF0dXMgIT0gMCkKKwkJYmVpc2NzaV9jbWRfcV9kZXN0cm95KGN0cmwsIE5VTEwsIFFUWVBFX1NHTCk7CisJcmV0dXJuIHN0YXR1czsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9jbWRzLmggYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfY21kcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMyMGQ2ODYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfY21kcy5oCkBAIC0wLDAgKzEsODc3IEBACisvKioKKyAqIENvcHlyaWdodCAoQykgMjAwNSAtIDIwMDkgU2VydmVyRW5naW5lcworICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLiAgVGhlIGZ1bGwgR05VIEdlbmVyYWwKKyAqIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluIHRoZSBmaWxlIGNhbGxlZCBDT1BZSU5HLgorICoKKyAqIENvbnRhY3QgSW5mb3JtYXRpb246CisgKiBsaW51eC1kcml2ZXJzQHNlcnZlcmVuZ2luZXMuY29tCisgKgorICogU2VydmVyRW5naW5lcworICogMjA5IE4uIEZhaXIgT2FrcyBBdmUKKyAqIFN1bm55dmFsZSwgQ0EgOTQwODUKKyAqLworCisjaWZuZGVmIEJFSVNDU0lfQ01EU19ICisjZGVmaW5lIEJFSVNDU0lfQ01EU19ICisKKy8qKgorICogVGhlIGRyaXZlciBzZW5kcyBjb25maWd1cmF0aW9uIGFuZCBtYW5hZ2VtZW50cyBjb21tYW5kIHJlcXVlc3RzIHRvIHRoZQorICogZmlybXdhcmUgaW4gdGhlIEJFLiBUaGVzZSByZXF1ZXN0cyBhcmUgY29tbXVuaWNhdGVkIHRvIHRoZSBwcm9jZXNzb3IKKyAqIHVzaW5nIFdvcmsgUmVxdWVzdCBCbG9ja3MgKFdSQnMpIHN1Ym1pdHRlZCB0byB0aGUgTUNDLVdSQiByaW5nIG9yIHZpYSBvbmUKKyAqIFdSQiBpbnNpZGUgYSBNQUlMQk9YLgorICogVGhlIGNvbW1hbmRzIGFyZSBzZXJ2aWNlZCBieSB0aGUgQVJNIHByb2Nlc3NvciBpbiB0aGUgQmxhZGVFbmdpbmUncyBNUFUuCisgKi8KK3N0cnVjdCBiZV9zZ2UgeworCXUzMiBwYV9sbzsKKwl1MzIgcGFfaGk7CisJdTMyIGxlbjsKK307CisKKyNkZWZpbmUgTUNDX1dSQl9TR0VfQ05UX1NISUZUIDMJLyogYml0cyAzIC0gNyBvZiBkd29yZCAwICovCisjZGVmaW5lIE1DQ19XUkJfU0dFX0NOVF9NQVNLIDB4MUYJLyogYml0cyAzIC0gNyBvZiBkd29yZCAwICovCitzdHJ1Y3QgYmVfbWNjX3dyYiB7CisJdTMyIGVtYmVkZGVkOwkJLyogZHdvcmQgMCAqLworCXUzMiBwYXlsb2FkX2xlbmd0aDsJLyogZHdvcmQgMSAqLworCXUzMiB0YWcwOwkJLyogZHdvcmQgMiAqLworCXUzMiB0YWcxOwkJLyogZHdvcmQgMyAqLworCXUzMiByc3ZkOwkJLyogZHdvcmQgNCAqLworCXVuaW9uIHsKKwkJdTggZW1iZWRkZWRfcGF5bG9hZFsyMzZdOwkvKiB1c2VkIGJ5IGVtYmVkZGVkIGNtZHMgKi8KKwkJc3RydWN0IGJlX3NnZSBzZ2xbMTldOwkvKiB1c2VkIGJ5IG5vbi1lbWJlZGRlZCBjbWRzICovCisJfSBwYXlsb2FkOworfTsKKworI2RlZmluZSBDUUVfRkxBR1NfVkFMSURfTUFTSyAoMSA8PCAzMSkKKyNkZWZpbmUgQ1FFX0ZMQUdTX0FTWU5DX01BU0sgKDEgPDwgMzApCisKKy8qIENvbXBsZXRpb24gU3RhdHVzICovCisjZGVmaW5lIE1DQ19TVEFUVVNfU1VDQ0VTUyAweDAKKworI2RlZmluZSBDUUVfU1RBVFVTX0NPTVBMX01BU0sgMHhGRkZGCisjZGVmaW5lIENRRV9TVEFUVVNfQ09NUExfU0hJRlQgMAkvKiBiaXRzIDAgLSAxNSAqLworI2RlZmluZSBDUUVfU1RBVFVTX0VYVERfTUFTSyAweEZGRkYKKyNkZWZpbmUgQ1FFX1NUQVRVU19FWFREX1NISUZUIDAJCS8qIGJpdHMgMCAtIDE1ICovCisKK3N0cnVjdCBiZV9tY2NfY29tcGwgeworCXUzMiBzdGF0dXM7CQkvKiBkd29yZCAwICovCisJdTMyIHRhZzA7CQkvKiBkd29yZCAxICovCisJdTMyIHRhZzE7CQkvKiBkd29yZCAyICovCisJdTMyIGZsYWdzOwkJLyogZHdvcmQgMyAqLworfTsKKworLyoqKioqKioqKiBNYWlsYm94IGRvb3IgYmVsbCAqKioqKioqKioqKioqLworLyoqCisgKiBVc2VkIGZvciBkcml2ZXIgY29tbXVuaWNhdGlvbiB3aXRoIHRoZSBGVy4KKyAqIFRoZSBzb2Z0d2FyZSBtdXN0IHdyaXRlIHRoaXMgcmVnaXN0ZXIgdHdpY2UgdG8gcG9zdCBhbnkgY29tbWFuZC4gRmlyc3QsCisgKiBpdCB3cml0ZXMgdGhlIHJlZ2lzdGVyIHdpdGggaGk9MSBhbmQgdGhlIHVwcGVyIGJpdHMgb2YgdGhlIHBoeXNpY2FsIGFkZHJlc3MKKyAqIGZvciB0aGUgTUFJTEJPWCBzdHJ1Y3R1cmUuIFNvZnR3YXJlIG11c3QgcG9sbCB0aGUgcmVhZHkgYml0IHVudGlsIHRoaXMKKyAqIGlzIGFja25vd2xlZGdlZC4gVGhlbiwgc290d2FyZSB3cml0ZXMgdGhlIHJlZ2lzdGVyIHdpdGggaGk9MCB3aXRoIHRoZSBsb3dlcgorICogYml0cyBpbiB0aGUgYWRkcmVzcy4gSXQgbXVzdCBwb2xsIHRoZSByZWFkeSBiaXQgdW50aWwgdGhlIGNvbW1hbmQgaXMKKyAqIGNvbXBsZXRlLiBVcG9uIGNvbXBsZXRpb24sIHRoZSBNQUlMQk9YIHdpbGwgY29udGFpbiBhIHZhbGlkIGNvbXBsZXRpb24KKyAqIHF1ZXVlIGVudHJ5LgorICovCisjZGVmaW5lIE1QVV9NQUlMQk9YX0RCX09GRlNFVAkweDE2MAorI2RlZmluZSBNUFVfTUFJTEJPWF9EQl9SRFlfTUFTSwkweDEJLyogYml0IDAgKi8KKyNkZWZpbmUgTVBVX01BSUxCT1hfREJfSElfTUFTSwkweDIJLyogYml0IDEgKi8KKworLyoqKioqKioqKiogTVBVIHNlbXBob3JlICoqKioqKioqKioqKioqKioqKi8KKyNkZWZpbmUgTVBVX0VQX1NFTUFQSE9SRV9PRkZTRVQgMHhhYworI2RlZmluZSBFUF9TRU1BUEhPUkVfUE9TVF9TVEFHRV9NQVNLIDB4MDAwMEZGRkYKKyNkZWZpbmUgRVBfU0VNQVBIT1JFX1BPU1RfRVJSX01BU0sgMHgxCisjZGVmaW5lIEVQX1NFTUFQSE9SRV9QT1NUX0VSUl9TSElGVCAzMQorCisvKioqKioqKioqKiBNQ0MgZG9vciBiZWxsICoqKioqKioqKioqKi8KKyNkZWZpbmUgREJfTUNDUV9PRkZTRVQgMHgxNDAKKyNkZWZpbmUgREJfTUNDUV9SSU5HX0lEX01BU0sgMHg3RkYJCS8qIGJpdHMgMCAtIDEwICovCisvKiBOdW1iZXIgb2YgZW50cmllcyBwb3N0ZWQgKi8KKyNkZWZpbmUgREJfTUNDUV9OVU1fUE9TVEVEX1NISUZUIDE2CQkvKiBiaXRzIDE2IC0gMjkgKi8KKworLyogTVBVIHNlbXBob3JlIFBPU1Qgc3RhZ2UgdmFsdWVzICovCisjZGVmaW5lIFBPU1RfU1RBR0VfQVJNRldfUkRZCQkweGMwMDAJLyogRlcgaXMgZG9uZSB3aXRoIFBPU1QgKi8KKworLyoqCisgKiBXaGVuIHRoZSBhc3luYyBiaXQgb2YgbWNjX2NvbXBsIGlzIHNldCwgdGhlIGxhc3QgNCBieXRlcyBvZgorICogbWNjX2NvbXBsIGlzIGludGVycHJldGVkIGFzIGZvbGxvd3M6CisgKi8KKyNkZWZpbmUgQVNZTkNfVFJBSUxFUl9FVkVOVF9DT0RFX1NISUZUCTgJLyogYml0cyA4IC0gMTUgKi8KKyNkZWZpbmUgQVNZTkNfVFJBSUxFUl9FVkVOVF9DT0RFX01BU0sJMHhGRgorI2RlZmluZSBBU1lOQ19FVkVOVF9DT0RFX0xJTktfU1RBVEUJMHgxCitzdHJ1Y3QgYmVfYXN5bmNfZXZlbnRfdHJhaWxlciB7CisJdTMyIGNvZGU7Cit9OworCitlbnVtIHsKKwlBU1lOQ19FVkVOVF9MSU5LX0RPV04gPSAweDAsCisJQVNZTkNfRVZFTlRfTElOS19VUCA9IDB4MQorfTsKKworLyoqCisgKiBXaGVuIHRoZSBldmVudCBjb2RlIG9mIGFuIGFzeW5jIHRyYWlsZXIgaXMgbGluay1zdGF0ZSwgdGhlIG1jY19jb21wbAorICogbXVzdCBiZSBpbnRlcnByZXRlZCBhcyBmb2xsb3dzCisgKi8KK3N0cnVjdCBiZV9hc3luY19ldmVudF9saW5rX3N0YXRlIHsKKwl1OCBwaHlzaWNhbF9wb3J0OworCXU4IHBvcnRfbGlua19zdGF0dXM7CisJdTggcG9ydF9kdXBsZXg7CisJdTggcG9ydF9zcGVlZDsKKwl1OCBwb3J0X2ZhdWx0OworCXU4IHJzdmQwWzddOworCXN0cnVjdCBiZV9hc3luY19ldmVudF90cmFpbGVyIHRyYWlsZXI7Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgYmVfbWNjX21haWxib3ggeworCXN0cnVjdCBiZV9tY2Nfd3JiIHdyYjsKKwlzdHJ1Y3QgYmVfbWNjX2NvbXBsIGNvbXBsOworfTsKKworLyogVHlwZSBvZiBzdWJzeXN0ZW1zIHN1cHBvcnRlZCBieSBGVyAqLworI2RlZmluZSBDTURfU1VCU1lTVEVNX0NPTU1PTiAgICAweDEKKyNkZWZpbmUgQ01EX1NVQlNZU1RFTV9JU0NTSSAgICAgMHgyCisjZGVmaW5lIENNRF9TVUJTWVNURU1fRVRIICAgICAgIDB4MworI2RlZmluZSBDTURfU1VCU1lTVEVNX0lTQ1NJX0lOSSAweDYKKyNkZWZpbmUgQ01EX0NPTU1PTl9UQ1BfVVBMT0FEICAgMHgxCisKKy8qKgorICogTGlzdCBvZiBjb21tb24gb3Bjb2RlcyBzdWJzeXN0ZW0gIENNRF9TVUJTWVNURU1fQ09NTU9OCisgKiBUaGVzZSBvcGNvZGVzIGFyZSB1bmlxdWUgZm9yIGVhY2ggc3Vic3lzdGVtIGRlZmluZWQgYWJvdmUKKyAqLworI2RlZmluZSBPUENPREVfQ09NTU9OX0NRX0NSRUFURQkJCQkxMgorI2RlZmluZSBPUENPREVfQ09NTU9OX0VRX0NSRUFURQkJCQkxMworI2RlZmluZSBPUENPREVfQ09NTU9OX01DQ19DUkVBVEUgICAgICAgIAkJMjEKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9HRVRfQ05UTF9BVFRSSUJVVEVTICAgICAgICAgICAgICAgMzIKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9HRVRfRldfVkVSU0lPTgkJCTM1CisjZGVmaW5lIE9QQ09ERV9DT01NT05fTU9ESUZZX0VRX0RFTEFZCQkJNDEKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9GSVJNV0FSRV9DT05GSUcJCQk0MgorI2RlZmluZSBPUENPREVfQ09NTU9OX01DQ19ERVNUUk9ZICAgICAgICAJCTUzCisjZGVmaW5lIE9QQ09ERV9DT01NT05fQ1FfREVTVFJPWSAgICAgICAgCQk1NAorI2RlZmluZSBPUENPREVfQ09NTU9OX0VRX0RFU1RST1kgICAgICAgIAkJNTUKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9RVUVSWV9GSVJNV0FSRV9DT05GSUcJCTU4CisjZGVmaW5lIE9QQ09ERV9DT01NT05fRlVOQ1RJT05fUkVTRVQJCQk2MQorCisvKioKKyAqIExJU1Qgb2Ygb3Bjb2RlcyB0aGF0IGFyZSBjb21tb24gYmV0d2VlbiBJbml0aWF0b3IgYW5kIFRhcmdldAorICogdXNlZCBieSBDTURfU1VCU1lTVEVNX0lTQ1NJCisgKiBUaGVzZSBvcGNvZGVzIGFyZSB1bmlxdWUgZm9yIGVhY2ggc3Vic3lzdGVtIGRlZmluZWQgYWJvdmUKKyAqLworI2RlZmluZSBPUENPREVfQ09NTU9OX0lTQ1NJX0NGR19QT1NUX1NHTF9QQUdFUwkJMgorI2RlZmluZSBPUENPREVfQ09NTU9OX0lTQ1NJX0NGR19SRU1PVkVfU0dMX1BBR0VTICAgICAgICAzCisjZGVmaW5lIE9QQ09ERV9DT01NT05fSVNDU0lfTlRXS19HRVRfTklDX0NPTkZJRwkJNworI2RlZmluZSBPUENPREVfQ09NTU9OX0lTQ1NJX1NFVF9GUkFHTlVNX0JJVFNfRk9SX1NHTF9DUkEgNjEKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9JU0NTSV9ERUZRX0NSRUFURSAgICAgICAgICAgICAgICAgNjQKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9JU0NTSV9ERUZRX0RFU1RST1kgCQk2NQorI2RlZmluZSBPUENPREVfQ09NTU9OX0lTQ1NJX1dSQlFfQ1JFQVRFCQkJNjYKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9JU0NTSV9XUkJRX0RFU1RST1kgCQk2NworCitzdHJ1Y3QgYmVfY21kX3JlcV9oZHIgeworCXU4IG9wY29kZTsJCS8qIGR3b3JkIDAgKi8KKwl1OCBzdWJzeXN0ZW07CQkvKiBkd29yZCAwICovCisJdTggcG9ydF9udW1iZXI7CQkvKiBkd29yZCAwICovCisJdTggZG9tYWluOwkJLyogZHdvcmQgMCAqLworCXUzMiB0aW1lb3V0OwkJLyogZHdvcmQgMSAqLworCXUzMiByZXF1ZXN0X2xlbmd0aDsJLyogZHdvcmQgMiAqLworCXUzMiByc3ZkOwkJLyogZHdvcmQgMyAqLworfTsKKworc3RydWN0IGJlX2NtZF9yZXNwX2hkciB7CisJdTMyIGluZm87CQkvKiBkd29yZCAwICovCisJdTMyIHN0YXR1czsJCS8qIGR3b3JkIDEgKi8KKwl1MzIgcmVzcG9uc2VfbGVuZ3RoOwkvKiBkd29yZCAyICovCisJdTMyIGFjdHVhbF9yZXNwX2xlbjsJLyogZHdvcmQgMyAqLworfTsKKworc3RydWN0IHBoeXNfYWRkciB7CisJdTMyIGxvOworCXUzMiBoaTsKK307CisKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKgorICogQkUgQ29tbWFuZCBkZWZpbml0aW9ucyAqCisgKioqKioqKioqKioqKioqKioqKioqKioqKiovCisKKy8qKgorICogUHNldWRvIGFtYXAgZGVmaW5pdGlvbiBpbiB3aGljaCBlYWNoIGJpdCBvZiB0aGUgYWN0dWFsIHN0cnVjdHVyZSBpcyBkZWZpbmVkCisgKiBhcyBhIGJ5dGUgLSB1c2VkIHRvIGNhbGN1bGF0ZSBvZmZzZXQvc2hpZnQvbWFzayBvZiBlYWNoIGZpZWxkCisgKi8KK3N0cnVjdCBhbWFwX2VxX2NvbnRleHQgeworCXU4IGNpZHhbMTNdOwkJLyogZHdvcmQgMCAqLworCXU4IHJzdmQwWzNdOwkJLyogZHdvcmQgMCAqLworCXU4IGVwaWR4WzEzXTsJCS8qIGR3b3JkIDAgKi8KKwl1OCB2YWxpZDsJCS8qIGR3b3JkIDAgKi8KKwl1OCByc3ZkMTsJCS8qIGR3b3JkIDAgKi8KKwl1OCBzaXplOwkJLyogZHdvcmQgMCAqLworCXU4IHBpZHhbMTNdOwkJLyogZHdvcmQgMSAqLworCXU4IHJzdmQyWzNdOwkJLyogZHdvcmQgMSAqLworCXU4IHBkWzEwXTsJCS8qIGR3b3JkIDEgKi8KKwl1OCBjb3VudFszXTsJCS8qIGR3b3JkIDEgKi8KKwl1OCBzb2xldmVudDsJCS8qIGR3b3JkIDEgKi8KKwl1OCBzdGFsbGVkOwkJLyogZHdvcmQgMSAqLworCXU4IGFybWVkOwkJLyogZHdvcmQgMSAqLworCXU4IHJzdmQzWzRdOwkJLyogZHdvcmQgMiAqLworCXU4IGZ1bmNbOF07CQkvKiBkd29yZCAyICovCisJdTggcnN2ZDQ7CQkvKiBkd29yZCAyICovCisJdTggZGVsYXltdWx0WzEwXTsJLyogZHdvcmQgMiAqLworCXU4IHJzdmQ1WzJdOwkJLyogZHdvcmQgMiAqLworCXU4IHBoYXNlWzJdOwkJLyogZHdvcmQgMiAqLworCXU4IG5vZGVsYXk7CQkvKiBkd29yZCAyICovCisJdTggcnN2ZDZbNF07CQkvKiBkd29yZCAyICovCisJdTggcnN2ZDdbMzJdOwkJLyogZHdvcmQgMyAqLworfSBfX3BhY2tlZDsKKworc3RydWN0IGJlX2NtZF9yZXFfZXFfY3JlYXRlIHsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9oZHIgaGRyOwkvKiBkd1s0XSAqLworCXUxNiBudW1fcGFnZXM7CQkvKiBzd29yZCAqLworCXUxNiByc3ZkMDsJCS8qIHN3b3JkICovCisJdTggY29udGV4dFtzaXplb2Yoc3RydWN0IGFtYXBfZXFfY29udGV4dCkgLyA4XTsJLyogZHdbNF0gKi8KKwlzdHJ1Y3QgcGh5c19hZGRyIHBhZ2VzWzhdOworfSBfX3BhY2tlZDsKKworc3RydWN0IGJlX2NtZF9yZXNwX2VxX2NyZWF0ZSB7CisJc3RydWN0IGJlX2NtZF9yZXNwX2hkciByZXNwX2hkcjsKKwl1MTYgZXFfaWQ7CQkvKiBzd29yZCAqLworCXUxNiByc3ZkMDsJCS8qIHN3b3JkICovCit9IF9fcGFja2VkOworCitzdHJ1Y3QgbWFjX2FkZHIgeworCXUxNiBzaXplX29mX3N0cnVjdDsKKwl1OCBhZGRyW0VUSF9BTEVOXTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9jbWRfcmVxX21hY19xdWVyeSB7CisJc3RydWN0IGJlX2NtZF9yZXFfaGRyIGhkcjsKKwl1OCB0eXBlOworCXU4IHBlcm1hbmVudDsKKwl1MTYgaWZfaWQ7Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgYmVfY21kX3Jlc3BfbWFjX3F1ZXJ5IHsKKwlzdHJ1Y3QgYmVfY21kX3Jlc3BfaGRyIGhkcjsKKwlzdHJ1Y3QgbWFjX2FkZHIgbWFjOworfTsKKworLyoqKioqKioqKioqKioqKioqKioqIENyZWF0ZSBDUSAqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisvKioKKyAqIFBzZXVkbyBhbWFwIGRlZmluaXRpb24gaW4gd2hpY2ggZWFjaCBiaXQgb2YgdGhlIGFjdHVhbCBzdHJ1Y3R1cmUgaXMgZGVmaW5lZAorICogYXMgYSBieXRlIC0gdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9jcV9jb250ZXh0IHsKKwl1OCBjaWR4WzExXTsJCS8qIGR3b3JkIDAgKi8KKwl1OCByc3ZkMDsJCS8qIGR3b3JkIDAgKi8KKwl1OCBjb2FsZXNjd21bMl07CS8qIGR3b3JkIDAgKi8KKwl1OCBub2RlbGF5OwkJLyogZHdvcmQgMCAqLworCXU4IGVwaWR4WzExXTsJCS8qIGR3b3JkIDAgKi8KKwl1OCByc3ZkMTsJCS8qIGR3b3JkIDAgKi8KKwl1OCBjb3VudFsyXTsJCS8qIGR3b3JkIDAgKi8KKwl1OCB2YWxpZDsJCS8qIGR3b3JkIDAgKi8KKwl1OCBzb2xldmVudDsJCS8qIGR3b3JkIDAgKi8KKwl1OCBldmVudGFibGU7CQkvKiBkd29yZCAwICovCisJdTggcGlkeFsxMV07CQkvKiBkd29yZCAxICovCisJdTggcnN2ZDI7CQkvKiBkd29yZCAxICovCisJdTggcGRbMTBdOwkJLyogZHdvcmQgMSAqLworCXU4IGVxaWRbOF07CQkvKiBkd29yZCAxICovCisJdTggc3RhbGxlZDsJCS8qIGR3b3JkIDEgKi8KKwl1OCBhcm1lZDsJCS8qIGR3b3JkIDEgKi8KKwl1OCByc3ZkM1s0XTsJCS8qIGR3b3JkIDIgKi8KKwl1OCBmdW5jWzhdOwkJLyogZHdvcmQgMiAqLworCXU4IHJzdmQ0WzIwXTsJCS8qIGR3b3JkIDIgKi8KKwl1OCByc3ZkNVszMl07CQkvKiBkd29yZCAzICovCit9IF9fcGFja2VkOworCitzdHJ1Y3QgYmVfY21kX3JlcV9jcV9jcmVhdGUgeworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdTE2IG51bV9wYWdlczsKKwl1MTYgcnN2ZDA7CisJdTggY29udGV4dFtzaXplb2Yoc3RydWN0IGFtYXBfY3FfY29udGV4dCkgLyA4XTsKKwlzdHJ1Y3QgcGh5c19hZGRyIHBhZ2VzWzRdOworfSBfX3BhY2tlZDsKKworc3RydWN0IGJlX2NtZF9yZXNwX2NxX2NyZWF0ZSB7CisJc3RydWN0IGJlX2NtZF9yZXNwX2hkciBoZHI7CisJdTE2IGNxX2lkOworCXUxNiByc3ZkMDsKK30gX19wYWNrZWQ7CisKKy8qKioqKioqKioqKioqKioqKioqKiBDcmVhdGUgTUNDUSAqKioqKioqKioqKioqKioqKioqKioqKioqKiovCisvKioKKyAqIFBzZXVkbyBhbWFwIGRlZmluaXRpb24gaW4gd2hpY2ggZWFjaCBiaXQgb2YgdGhlIGFjdHVhbCBzdHJ1Y3R1cmUgaXMgZGVmaW5lZAorICogYXMgYSBieXRlIC0gdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9tY2NfY29udGV4dCB7CisJdTggY29uX2luZGV4WzE0XTsKKwl1OCByc3ZkMFsyXTsKKwl1OCByaW5nX3NpemVbNF07CisJdTggZmV0Y2hfd3JiOworCXU4IGZldGNoX3IydDsKKwl1OCBjcV9pZFsxMF07CisJdTggcHJvZF9pbmRleFsxNF07CisJdTggZmlkWzhdOworCXU4IHBkaWRbOV07CisJdTggdmFsaWQ7CisJdTggcnN2ZDFbMzJdOworCXU4IHJzdmQyWzMyXTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9jbWRfcmVxX21jY19jcmVhdGUgeworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdTE2IG51bV9wYWdlczsKKwl1MTYgcnN2ZDA7CisJdTggY29udGV4dFtzaXplb2Yoc3RydWN0IGFtYXBfbWNjX2NvbnRleHQpIC8gOF07CisJc3RydWN0IHBoeXNfYWRkciBwYWdlc1s4XTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9jbWRfcmVzcF9tY2NfY3JlYXRlIHsKKwlzdHJ1Y3QgYmVfY21kX3Jlc3BfaGRyIGhkcjsKKwl1MTYgaWQ7CisJdTE2IHJzdmQwOworfSBfX3BhY2tlZDsKKworLyoqKioqKioqKioqKioqKioqKioqIFEgRGVzdHJveSAgKioqKioqKioqKioqKioqKioqKioqKioqKioqLworLyogVHlwZSBvZiBRdWV1ZSB0byBiZSBkZXN0cm95ZWQgKi8KK2VudW0geworCVFUWVBFX0VRID0gMSwKKwlRVFlQRV9DUSwKKwlRVFlQRV9NQ0NRLAorCVFUWVBFX1dSQlEsCisJUVRZUEVfRFBEVVEsCisJUVRZUEVfU0dMCit9OworCitzdHJ1Y3QgYmVfY21kX3JlcV9xX2Rlc3Ryb3kgeworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdTE2IGlkOworCXUxNiBieXBhc3NfZmx1c2g7CS8qIHZhbGlkIG9ubHkgZm9yIHJ4IHEgZGVzdHJveSAqLworfSBfX3BhY2tlZDsKKworc3RydWN0IG1hY2FkZHIgeworCXU4IGJ5dGVbRVRIX0FMRU5dOworfTsKKworc3RydWN0IGJlX2NtZF9yZXFfbWNhc3RfbWFjX2NvbmZpZyB7CisJc3RydWN0IGJlX2NtZF9yZXFfaGRyIGhkcjsKKwl1MTYgbnVtX21hYzsKKwl1OCBwcm9taXNjdW91czsKKwl1OCBpbnRlcmZhY2VfaWQ7CisJc3RydWN0IG1hY2FkZHIgbWFjWzMyXTsKK30gX19wYWNrZWQ7CisKK3N0YXRpYyBpbmxpbmUgdm9pZCAqZW1iZWRkZWRfcGF5bG9hZChzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiKQoreworCXJldHVybiB3cmItPnBheWxvYWQuZW1iZWRkZWRfcGF5bG9hZDsKK30KKworc3RhdGljIGlubGluZSBzdHJ1Y3QgYmVfc2dlICpub25lbWJlZGRlZF9zZ2woc3RydWN0IGJlX21jY193cmIgKndyYikKK3sKKwlyZXR1cm4gJndyYi0+cGF5bG9hZC5zZ2xbMF07Cit9CisKKy8qKioqKioqKioqKioqKioqKioqKiBNb2RpZnkgRVEgRGVsYXkgKioqKioqKioqKioqKioqKioqKi8KK3N0cnVjdCBiZV9jbWRfcmVxX21vZGlmeV9lcV9kZWxheSB7CisJc3RydWN0IGJlX2NtZF9yZXFfaGRyIGhkcjsKKwl1MzIgbnVtX2VxOworCXN0cnVjdCB7CisJCXUzMiBlcV9pZDsKKwkJdTMyIHBoYXNlOworCQl1MzIgZGVsYXlfbXVsdGlwbGllcjsKKwl9IGRlbGF5WzhdOworfSBfX3BhY2tlZDsKKworLyoqKioqKioqKioqKioqKioqKioqIEdldCBNQUMgQUREUiAqKioqKioqKioqKioqKioqKioqLworCisjZGVmaW5lIEVUSF9BTEVOCTYKKworCitzdHJ1Y3QgYmVfY21kX3JlcV9nZXRfbWFjX2FkZHIgeworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdTMyIG5pY19wb3J0X2NvdW50OworCXUzMiBzcGVlZDsKKwl1MzIgbWF4X3NwZWVkOworCXUzMiBsaW5rX3N0YXRlOworCXUzMiBtYXhfZnJhbWVfc2l6ZTsKKwl1MTYgc2l6ZV9vZl9zdHJ1Y3R1cmU7CisJdTggbWFjX2FkZHJlc3NbRVRIX0FMRU5dOworCXUzMiByc3ZkWzIzXTsKK307CisKK3N0cnVjdCBiZV9jbWRfcmVzcF9nZXRfbWFjX2FkZHIgeworCXN0cnVjdCBiZV9jbWRfcmVzcF9oZHIgaGRyOworCXUzMiBuaWNfcG9ydF9jb3VudDsKKwl1MzIgc3BlZWQ7CisJdTMyIG1heF9zcGVlZDsKKwl1MzIgbGlua19zdGF0ZTsKKwl1MzIgbWF4X2ZyYW1lX3NpemU7CisJdTE2IHNpemVfb2Zfc3RydWN0dXJlOworCXU4IG1hY19hZGRyZXNzWzZdOworCXUzMiByc3ZkWzIzXTsKK307CisKK2ludCBiZWlzY3NpX2NtZF9lcV9jcmVhdGUoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCwKKwkJCSAgc3RydWN0IGJlX3F1ZXVlX2luZm8gKmVxLCBpbnQgZXFfZGVsYXkpOworCitpbnQgYmVpc2NzaV9jbWRfY3FfY3JlYXRlKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsCisJCQkgIHN0cnVjdCBiZV9xdWV1ZV9pbmZvICpjcSwgc3RydWN0IGJlX3F1ZXVlX2luZm8gKmVxLAorCQkJICBib29sIHNvbF9ldnRzLCBib29sIG5vX2RlbGF5LAorCQkJICBpbnQgbnVtX2NxZV9kbWFfY29hbGVzY2UpOworCitpbnQgYmVpc2NzaV9jbWRfcV9kZXN0cm95KHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsIHN0cnVjdCBiZV9xdWV1ZV9pbmZvICpxLAorCQkJICBpbnQgdHlwZSk7CitpbnQgYmVfcG9sbF9tY2Moc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCk7Cit1bnNpZ25lZCBjaGFyIG1nbXRfY2hlY2tfc3VwcG9ydGVkX2Z3KHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwpOworaW50IGJlX2NtZF9nZXRfbWFjX2FkZHIoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCwgdTggKm1hY19hZGRyKTsKKworLypJU0NTSSBGdW5jdHVpb25zICovCitpbnQgYmVfY21kX2Z3X2luaXRpYWxpemUoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCk7CisKK3N0cnVjdCBiZV9tY2Nfd3JiICp3cmJfZnJvbV9tYm94KHN0cnVjdCBiZV9kbWFfbWVtICptYm94X21lbSk7CisKK2ludCBiZV9tYm94X25vdGlmeShzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsKTsKKworaW50IGJlX2NtZF9jcmVhdGVfZGVmYXVsdF9wZHVfcXVldWUoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCwKKwkJCQkgICAgc3RydWN0IGJlX3F1ZXVlX2luZm8gKmNxLAorCQkJCSAgICBzdHJ1Y3QgYmVfcXVldWVfaW5mbyAqZHEsIGludCBsZW5ndGgsCisJCQkJICAgIGludCBlbnRyeV9zaXplKTsKKworaW50IGJlX2NtZF9pc2NzaV9wb3N0X3NnbF9wYWdlcyhzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsLAorCQkJCXN0cnVjdCBiZV9kbWFfbWVtICpxX21lbSwgdTMyIHBhZ2Vfb2Zmc2V0LAorCQkJCXUzMiBudW1fcGFnZXMpOworCitpbnQgYmVfY21kX3dyYnFfY3JlYXRlKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsIHN0cnVjdCBiZV9kbWFfbWVtICpxX21lbSwKKwkJICAgICAgIHN0cnVjdCBiZV9xdWV1ZV9pbmZvICp3cmJxKTsKKworc3RydWN0IGJlX2RlZmF1bHRfcGR1X2NvbnRleHQgeworCXUzMiBkd1s0XTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBhbWFwX2JlX2RlZmF1bHRfcGR1X2NvbnRleHQgeworCXU4IGRidWZfY2luZGV4WzEzXTsJLyogZHdvcmQgMCAqLworCXU4IHJzdmQwWzNdOwkJLyogZHdvcmQgMCAqLworCXU4IHJpbmdfc2l6ZVs0XTsJLyogZHdvcmQgMCAqLworCXU4IHJpbmdfc3RhdGVbNF07CS8qIGR3b3JkIDAgKi8KKwl1OCByc3ZkMVs4XTsJCS8qIGR3b3JkIDAgKi8KKwl1OCBkYnVmX3BpbmRleFsxM107CS8qIGR3b3JkIDEgKi8KKwl1OCByc3ZkMjsJCS8qIGR3b3JkIDEgKi8KKwl1OCBwY2lfZnVuY19pZFs4XTsJLyogZHdvcmQgMSAqLworCXU4IHJ4X3BkaWRbOV07CQkvKiBkd29yZCAxICovCisJdTggcnhfcGRpZF92YWxpZDsJLyogZHdvcmQgMSAqLworCXU4IGRlZmF1bHRfYnVmZmVyX3NpemVbMTZdOwkvKiBkd29yZCAyICovCisJdTggY3FfaWRfcmVjdlsxMF07CS8qIGR3b3JkIDIgKi8KKwl1OCByeF9wZGlkX25vdF92YWxpZDsJLyogZHdvcmQgMiAqLworCXU4IHJzdmQzWzVdOwkJLyogZHdvcmQgMiAqLworCXU4IHJzdmQ0WzMyXTsJCS8qIGR3b3JkIDMgKi8KK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9kZWZxX2NyZWF0ZV9yZXEgeworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdTE2IG51bV9wYWdlczsKKwl1OCB1bHBfbnVtOworCXU4IHJzdmQwOworCXN0cnVjdCBiZV9kZWZhdWx0X3BkdV9jb250ZXh0IGNvbnRleHQ7CisJc3RydWN0IHBoeXNfYWRkciBwYWdlc1s4XTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9kZWZxX2NyZWF0ZV9yZXNwIHsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9oZHIgaGRyOworCXUxNiBpZDsKKwl1MTYgcnN2ZDA7Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgYmVfcG9zdF9zZ2xfcGFnZXNfcmVxIHsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9oZHIgaGRyOworCXUxNiBudW1fcGFnZXM7CisJdTE2IHBhZ2Vfb2Zmc2V0OworCXUzMiByc3ZkMDsKKwlzdHJ1Y3QgcGh5c19hZGRyIHBhZ2VzWzI2XTsKKwl1MzIgcnN2ZDE7Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgYmVfd3JicV9jcmVhdGVfcmVxIHsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9oZHIgaGRyOworCXUxNiBudW1fcGFnZXM7CisJdTggdWxwX251bTsKKwl1OCByc3ZkMDsKKwlzdHJ1Y3QgcGh5c19hZGRyIHBhZ2VzWzhdOworfSBfX3BhY2tlZDsKKworc3RydWN0IGJlX3dyYnFfY3JlYXRlX3Jlc3AgeworCXN0cnVjdCBiZV9jbWRfcmVzcF9oZHIgcmVzcF9oZHI7CisJdTE2IGNpZDsKKwl1MTYgcnN2ZDA7Cit9IF9fcGFja2VkOworCisjZGVmaW5lIFNPTF9DSURfTUFTSwkJMHgwMDAwRkZDMAorI2RlZmluZSBTT0xfQ09ERV9NQVNLCQkweDAwMDAwMDNGCisjZGVmaW5lIFNPTF9XUkJfSU5ERVhfTUFTSwkweDAwRkYwMDAwCisjZGVmaW5lIFNPTF9DTURfV05EX01BU0sJMHhGRjAwMDAwMAorI2RlZmluZSBTT0xfUkVTX0NOVF9NQVNLCTB4N0ZGRkZGRkYKKyNkZWZpbmUgU09MX0VYUF9DTURfU05fTUFTSwkweEZGRkZGRkZGCisjZGVmaW5lIFNPTF9IV19TVFNfTUFTSwkJMHgwMDAwMDBGRgorI2RlZmluZSBTT0xfU1RTX01BU0sJCTB4MDAwMEZGMDAKKyNkZWZpbmUgU09MX1JFU1BfTUFTSwkJMHgwMEZGMDAwMAorI2RlZmluZSBTT0xfRkxBR1NfTUFTSwkJMHg3RjAwMDAwMAorI2RlZmluZSBTT0xfU19NQVNLCQkweDgwMDAwMDAwCisKK3N0cnVjdCBzb2xfY3FlIHsKKwl1MzIgZHdbNF07Cit9OworCitzdHJ1Y3QgYW1hcF9zb2xfY3FlIHsKKwl1OCBod19zdHNbOF07CQkvKiBkd29yZCAwICovCisJdTggaV9zdHNbOF07CQkvKiBkd29yZCAwICovCisJdTggaV9yZXNwWzhdOwkJLyogZHdvcmQgMCAqLworCXU4IGlfZmxhZ3NbN107CQkvKiBkd29yZCAwICovCisJdTggczsJCQkvKiBkd29yZCAwICovCisJdTggaV9leHBfY21kX3NuWzMyXTsJLyogZHdvcmQgMSAqLworCXU4IGNvZGVbNl07CQkvKiBkd29yZCAyICovCisJdTggY2lkWzEwXTsJCS8qIGR3b3JkIDIgKi8KKwl1OCB3cmJfaW5kZXhbOF07CS8qIGR3b3JkIDIgKi8KKwl1OCBpX2NtZF93bmRbOF07CS8qIGR3b3JkIDIgKi8KKwl1OCBpX3Jlc19jbnRbMzFdOwkvKiBkd29yZCAzICovCisJdTggdmFsaWQ7CQkvKiBkd29yZCAzICovCit9IF9fcGFja2VkOworCisKKy8qKgorICogUG9zdCBXUkIgUXVldWUgRG9vcmJlbGwgUmVnaXN0ZXIgdXNlZCBieSB0aGUgaG9zdCBTdG9yYWdlCisgKiBzdGFjayB0byBub3RpZnkgdGhlCisgKiBjb250cm9sbGVyIG9mIGEgcG9zdGVkIFdvcmsgUmVxdWVzdCBCbG9jaworICovCisjZGVmaW5lIERCX1dSQl9QT1NUX0NJRF9NQVNLCQkweDNGRgkvKiBiaXRzIDAgLSA5ICovCisjZGVmaW5lIERCX0RFRl9QRFVfV1JCX0lOREVYX01BU0sJMHhGRgkvKiBiaXRzIDAgLSA5ICovCisKKyNkZWZpbmUgREJfREVGX1BEVV9XUkJfSU5ERVhfU0hJRlQJMTYKKyNkZWZpbmUgREJfREVGX1BEVV9OVU1fUE9TVEVEX1NISUZUCTI0CisKK3N0cnVjdCBmcmFnbnVtX2JpdHNfZm9yX3NnbF9jcmFfaW4geworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdTMyIG51bV9iaXRzOworfSBfX3BhY2tlZDsKKworc3RydWN0IGlzY3NpX2NsZWFudXBfcmVxIHsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9oZHIgaGRyOworCXUxNiBjaHV0ZTsKKwl1OCBoZHJfcmluZ19pZDsKKwl1OCBkYXRhX3JpbmdfaWQ7CisKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBlcV9kZWxheSB7CisJdTMyIGVxX2lkOworCXUzMiBwaGFzZTsKKwl1MzIgZGVsYXlfbXVsdGlwbGllcjsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9lcV9kZWxheV9wYXJhbXNfaW4geworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdTMyIG51bV9lcTsKKwlzdHJ1Y3QgZXFfZGVsYXkgZGVsYXlbOF07Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgaXBfYWRkcmVzc19mb3JtYXQgeworCXUxNiBzaXplX29mX3N0cnVjdHVyZTsKKwl1OCByZXNlcnZlZDsKKwl1OCBpcF90eXBlOworCXU4IGlwX2FkZHJlc3NbMTZdOworCXUzMiByc3ZkMDsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCB0Y3BfY29ubmVjdF9hbmRfb2ZmbG9hZF9pbiB7CisJc3RydWN0IGJlX2NtZF9yZXFfaGRyIGhkcjsKKwlzdHJ1Y3QgaXBfYWRkcmVzc19mb3JtYXQgaXBfYWRkcmVzczsKKwl1MTYgdGNwX3BvcnQ7CisJdTE2IGNpZDsKKwl1MTYgY3FfaWQ7CisJdTE2IGRlZnFfaWQ7CisJc3RydWN0IHBoeXNfYWRkciBkYXRhb3V0X3RlbXBsYXRlX3BhOworCXUxNiBoZHJfcmluZ19pZDsKKwl1MTYgZGF0YV9yaW5nX2lkOworCXU4IGRvX29mZmxvYWQ7CisJdTggcnN2ZDBbM107Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgdGNwX2Nvbm5lY3RfYW5kX29mZmxvYWRfb3V0IHsKKwlzdHJ1Y3QgYmVfY21kX3Jlc3BfaGRyIGhkcjsKKwl1MzIgY29ubmVjdGlvbl9oYW5kbGU7CisJdTE2IGNpZDsKKwl1MTYgcnN2ZDA7CisKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9tY2Nfd3JiX2NvbnRleHQgeworCXN0cnVjdCBNQ0NfV1JCICp3cmI7CisJaW50ICp1c2Vyc19maW5hbF9zdGF0dXM7Cit9IF9fcGFja2VkOworCisjZGVmaW5lIERCX0RFRl9QRFVfUklOR19JRF9NQVNLCQkweDNGRgkvKiBiaXRzIDAgLSA5ICovCisjZGVmaW5lIERCX0RFRl9QRFVfQ1FQUk9DX01BU0sJCTB4M0ZGRgkvKiBiaXRzIDAgLSA5ICovCisjZGVmaW5lIERCX0RFRl9QRFVfUkVBUk1fU0hJRlQJCTE0CisjZGVmaW5lIERCX0RFRl9QRFVfRVZFTlRfU0hJRlQJCTE1CisjZGVmaW5lIERCX0RFRl9QRFVfQ1FQUk9DX1NISUZUCQkxNgorCitzdHJ1Y3QgZG1zZ19jcWUgeworCXUzMiBkd1s0XTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCB0Y3BfdXBsb2FkX3BhcmFtc19pbiB7CisJc3RydWN0IGJlX2NtZF9yZXFfaGRyIGhkcjsKKwl1MTYgaWQ7CisJdTE2IHVwbG9hZF90eXBlOworCXUzMiByZXNldF9zZXE7Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgdGNwX3VwbG9hZF9wYXJhbXNfb3V0IHsKKwl1MzIgZHdbMzJdOworfSBfX3BhY2tlZDsKKwordW5pb24gdGNwX3VwbG9hZF9wYXJhbXMgeworCXN0cnVjdCB0Y3BfdXBsb2FkX3BhcmFtc19pbiByZXF1ZXN0OworCXN0cnVjdCB0Y3BfdXBsb2FkX3BhcmFtc19vdXQgcmVzcG9uc2U7Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgYmVfdWxwX2Z3X2NmZyB7CisJdTMyIHVscF9tb2RlOworCXUzMiBldHhfYmFzZTsKKwl1MzIgZXR4X2NvdW50OworCXUzMiBzcV9iYXNlOworCXUzMiBzcV9jb3VudDsKKwl1MzIgcnFfYmFzZTsKKwl1MzIgcnFfY291bnQ7CisJdTMyIGRxX2Jhc2U7CisJdTMyIGRxX2NvdW50OworCXUzMiBscm9fYmFzZTsKKwl1MzIgbHJvX2NvdW50OworCXUzMiBpY2RfYmFzZTsKKwl1MzIgaWNkX2NvdW50OworfTsKKworc3RydWN0IGJlX2Z3X2NmZyB7CisJc3RydWN0IGJlX2NtZF9yZXFfaGRyIGhkcjsKKwl1MzIgYmVfY29uZmlnX251bWJlcjsKKwl1MzIgYXNpY19yZXZpc2lvbjsKKwl1MzIgcGh5c19wb3J0OworCXUzMiBmdW5jdGlvbl9tb2RlOworCXN0cnVjdCBiZV91bHBfZndfY2ZnIHVscFsyXTsKKwl1MzIgZnVuY3Rpb25fY2FwczsKK30gX19wYWNrZWQ7CisKKyNkZWZpbmUgQ01EX0lTQ1NJX0NPTU1BTkRfSU5WQUxJREFURSAgMQorI2RlZmluZSBJU0NTSV9PUENPREVfU0NTSV9EQVRBX09VVCAgICAgIDUKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9JU0NTSV9UQ1BfQ09OTkVDVF9BTkRfT0ZGTE9BRCA3MAorI2RlZmluZSBPUENPREVfSVNDU0lfSU5JX0RSSVZFUl9PRkZMT0FEX1NFU1NJT04gNDEKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9NT0RJRllfRVFfREVMQVkJNDEKKyNkZWZpbmUgT1BDT0RFX0NPTU1PTl9JU0NTSV9DTEVBTlVQCTU5CisjZGVmaW5lCU9QQ09ERV9DT01NT05fVENQX1VQTE9BRAk1NgorI2RlZmluZSBPUENPREVfQ09NTU9OX0lTQ1NJX0VSUk9SX1JFQ09WRVJZX0lOVkFMSURBVEVfQ09NTUFORFMgMQorLyogLS0tIENNRF9JU0NTSV9JTlZBTElEQVRFX0NPTk5FQ1RJT05fVFlQRSAtLS0gKi8KKyNkZWZpbmUgQ01EX0lTQ1NJX0NPTk5FQ1RJT05fSU5WQUxJREFURSAxCisjZGVmaW5lIENNRF9JU0NTSV9DT05ORUNUSU9OX0lTU1VFX1RDUF9SU1QgMgorI2RlZmluZSBPUENPREVfSVNDU0lfSU5JX0RSSVZFUl9JTlZBTElEQVRFX0NPTk5FQ1RJT04gNDIKKworI2RlZmluZSBJTklfV1JfQ01ECQkJMQkvKiBJbml0aWF0b3Igd3JpdGUgY29tbWFuZCAqLworI2RlZmluZSBJTklfVE1GX0NNRAkJCTIJLyogSW5pdGlhdG9yIFRNRiBjb21tYW5kICovCisjZGVmaW5lIElOSV9OT1BPVVRfQ01ECQkJMwkvKiBJbml0aWF0b3I7IFNlbmQgYSBOT1AtT1VUICovCisjZGVmaW5lIElOSV9SRF9DTUQJCQk1CS8qIEluaXRpYXRvciByZXF1ZXN0aW5nIHRvIHNlbmQKKwkJCQkJCSAqIGEgcmVhZCBjb21tYW5kCisJCQkJCQkgKi8KKyNkZWZpbmUgVEdUX0NUWF9VUERUX0NNRAkJNwkvKiBUYXJnZXQgY29udGV4dCB1cGRhdGUgKi8KKyNkZWZpbmUgVEdUX1NUU19DTUQJCQk4CS8qIFRhcmdldCBSMlQgYW5kIG90aGVyIEJIUworCQkJCQkJICogd2hlcmUgb25seSB0aGUgc3RhdHVzIG51bWJlcgorCQkJCQkJICogbmVlZCB0byBiZSB1cGRhdGVkCisJCQkJCQkgKi8KKyNkZWZpbmUgVEdUX0RBVEFJTl9DTUQJCQk5CS8qIFRhcmdldCBEYXRhLUlucyBpbiByZXNwb25zZQorCQkJCQkJICogdG8gcmVhZCBjb21tYW5kCisJCQkJCQkgKi8KKyNkZWZpbmUgVEdUX1NPU19QRFUJCQkxMAkvKiBUYXJnZXQ6c3RhbmRhbG9uZSBzdGF0dXMKKwkJCQkJCSAqIHJlc3BvbnNlCisJCQkJCQkgKi8KKyNkZWZpbmUgVEdUX0RNX0NNRAkJCTExCS8qIEluZGljYXRlcyB0aGF0IHRoZSBiaHMKKwkJCQkJCSAqICBwcmVwYXJlZGJ5CisJCQkJCQkgKiBkcml2ZXIgc2hvdWxkIG5vdCBiZSB0b3VjaGVkCisJCQkJCQkgKi8KKy8qIC0tLSBDTURfQ0hVVEVfVFlQRSAtLS0gKi8KKyNkZWZpbmUgQ01EX0NPTk5FQ1RJT05fQ0hVVEVfMAkJMQorI2RlZmluZSBDTURfQ09OTkVDVElPTl9DSFVURV8xCQkyCisjZGVmaW5lIENNRF9DT05ORUNUSU9OX0NIVVRFXzIJCTMKKworI2RlZmluZSBFUV9NQUpPUl9DT0RFX0NPTVBMRVRJT04JMAorCisjZGVmaW5lIENNRF9JU0NTSV9TRVNTSU9OX0RFTF9DRkdfRlJPTV9GTEFTSCAwCisjZGVmaW5lIENNRF9JU0NTSV9TRVNTSU9OX1NBVkVfQ0ZHX09OX0ZMQVNIIDEKKworLyogLS0tIENPTk5FQ1RJT05fVVBMT0FEX1BBUkFNUyAtLS0gKi8KKy8qIFRoZXNlIHBhcmFtZXRlcnMgYXJlIHVzZWQgdG8gZGVmaW5lIHRoZSB0eXBlIG9mIHVwbG9hZCBkZXNpcmVkLiAgKi8KKyNkZWZpbmUgQ09OTkVDVElPTl9VUExPQURfR1JBQ0VGVUwgICAgICAxCS8qIEdyYWNlZnVsIHVwbG9hZCAgKi8KKyNkZWZpbmUgQ09OTkVDVElPTl9VUExPQURfQUJPUlRfUkVTRVQgICAyCS8qIEFib3J0aXZlIHVwbG9hZCB3aXRoCisJCQkJCQkgKiByZXNldAorCQkJCQkJICovCisjZGVmaW5lIENPTk5FQ1RJT05fVVBMT0FEX0FCT1JUCQkzCS8qIEFib3J0aXZlIHVwbG9hZCB3aXRob3V0CisJCQkJCQkgKiByZXNldAorCQkJCQkJICovCisjZGVmaW5lIENPTk5FQ1RJT05fVVBMT0FEX0FCT1JUX1dJVEhfU0VRIDQJLyogQWJvcnRpdmUgdXBsb2FkIHdpdGggcmVzZXQsCisJCQkJCQkgKiBzZXF1ZW5jZSBudW1iZXIgYnkgZHJpdmVyICAqLworCisvKiBSZXR1cm5zIGJ5dGUgc2l6ZSBvZiBnaXZlbiBmaWVsZCB3aXRoIGEgc3RydWN0dXJlLiAqLworCisvKiBSZXR1cm5zIHRoZSBudW1iZXIgb2YgaXRlbXMgaW4gdGhlIGZpZWxkIGFycmF5LiAqLworI2RlZmluZSBCRV9OVU1CRVJfT0ZfRklFTEQoX3R5cGVfLCBfZmllbGRfKQlcCisJKEZJRUxEX1NJWkVPRihfdHlwZV8sIF9maWVsZF8pL3NpemVvZigoKChfdHlwZV8gKikwKS0+X2ZpZWxkX1swXSkpKVwKKworLyoqCisgKiBEaWZmZXJlbnQgdHlwZXMgb2YgaVNDU0kgY29tcGxldGlvbnMgdG8gaG9zdCBkcml2ZXIgZm9yIGJvdGggaW5pdGlhdG9yCisgKiBhbmQgdGFnZXQgbW9kZQorICogb2Ygb3BlcmF0aW9uLgorICovCisjZGVmaW5lIFNPTF9DTURfQ09NUExFVEUJCTEJLyogU29saWNpdGVkIGNvbW1hbmQgY29tcGxldGVkCisJCQkJCQkgKiBub3JtYWxseQorCQkJCQkJICovCisjZGVmaW5lIFNPTF9DTURfS0lMTEVEX0RBVEFfRElHRVNUX0VSUiAgMgkvKiBTb2xpY2l0ZWQgY29tbWFuZCBnb3QKKwkJCQkJCSAqIGludmFsaWRhdGVkIGludGVybmFsbHkgZHVlCisJCQkJCQkgKiB0byBEYXRhIERpZ2VzdCBlcnJvcgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfUERVX1NJWkVfRVhDRUVEU19EU0wgMwkvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseQorCQkJCQkJICogZHVlIHRvIGEgcmVjaWV2ZWQgUERVCisJCQkJCQkgKiBzaXplID4gRFNMCisJCQkJCQkgKi8KKyNkZWZpbmUgQ1hOX0tJTExFRF9CVVJTVF9MRU5fTUlTTUFUQ0ggICA0CS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0aSByZWNlaXZlZAorCQkJCQkJICogUERVIHNlcXVlbmNlIHNpemUgPgorCQkJCQkJICogRkJML01CTC4KKwkJCQkJCSAqLworI2RlZmluZSBDWE5fS0lMTEVEX0FIU19SQ1ZECQk1CS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBhIHJlY2lldmVkCisJCQkJCQkgKiBQRFUgSGRyIHRoYXQgaGFzCisJCQkJCQkgKiBBSFMgKi8KKyNkZWZpbmUgQ1hOX0tJTExFRF9IRFJfRElHRVNUX0VSUgk2CS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBIZHIgRGlnZXN0CisJCQkJCQkgKiBlcnJvcgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfVU5LTk9XTl9IRFIJCTcJLyogQ29ubmVjdGlvbiBnb3QgaW52YWxpZGF0ZWQKKwkJCQkJCSAqICBpbnRlcm5hbGx5CisJCQkJCQkgKiBkdWUgdG8gYSBiYWQgb3Bjb2RlIGluIHRoZQorCQkJCQkJICogcGR1IGhkcgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfU1RBTEVfSVRUX1RUVF9SQ1ZECTgJLyogQ29ubmVjdGlvbiBnb3QgaW52YWxpZGF0ZWQKKwkJCQkJCSAqIGludGVybmFsbHkgZHVlIHRvIGEgcmVjaWV2ZWQKKwkJCQkJCSAqIElUVC9UVFQgdGhhdCBkb2VzIG5vdCBiZWxvbmcKKwkJCQkJCSAqIHRvIHRoaXMgQ29ubmVjdGlvbgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfSU5WQUxJRF9JVFRfVFRUX1JDVkQgOQkvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gcmVjaWV2ZWQKKwkJCQkJCSAqIElUVC9UVFQgdmFsdWUgPiBNYXgKKwkJCQkJCSAqIFN1cHBvcnRlZCBJVFRzL1RUVHMKKwkJCQkJCSAqLworI2RlZmluZSBDWE5fS0lMTEVEX1JTVF9SQ1ZECQkxMAkvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gYW4KKwkJCQkJCSAqIGluY29taW5nIFRDUCBSU1QKKwkJCQkJCSAqLworI2RlZmluZSBDWE5fS0lMTEVEX1RJTUVEX09VVAkJMTEJLyogQ29ubmVjdGlvbiBnb3QgaW52YWxpZGF0ZWQKKwkJCQkJCSAqIGludGVybmFsbHkgZHVlIHRvIHRpbWVvdXQgb24KKwkJCQkJCSAqIHRjcCBzZWdtZW50IDEyIHJldHJhbnNtaXQKKwkJCQkJCSAqIGF0dGVtcHRzIGZhaWxlZAorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfUlNUX1NFTlQJCTEyCS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBUQ1AgUlNUCisJCQkJCQkgKiBzZW50IGJ5IHRoZSBUeCBzaWRlCisJCQkJCQkgKi8KKyNkZWZpbmUgQ1hOX0tJTExFRF9GSU5fUkNWRAkJMTMJLyogQ29ubmVjdGlvbiBnb3QgaW52YWxpZGF0ZWQKKwkJCQkJCSAqIGludGVybmFsbHkgZHVlIHRvIGFuCisJCQkJCQkgKiBpbmNvbWluZyBUQ1AgRklOLgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfQkFEX1VOU09MX1BEVV9SQ1ZECTE0CS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBiYWQKKwkJCQkJCSAqIHVuc29saWNpdGVkIFBEVSBVbnNvbGljaXRlZAorCQkJCQkJICogUERVcyBhcmUgUERVcyB3aXRoCisJCQkJCQkgKiBJVFQ9MHhmZmZmZmZmZgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfQkFEX1dSQl9JTkRFWF9FUlJPUgkxNQkvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gYmFkIFdSQgorCQkJCQkJICogaW5kZXguCisJCQkJCQkgKi8KKyNkZWZpbmUgQ1hOX0tJTExFRF9PVkVSX1JVTl9SRVNJRFVBTAkxNgkvKiBDb21tYW5kIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gcmVjaXZlZAorCQkJCQkJICogY29tbWFuZCBoYXMgcmVzaWR1YWwKKwkJCQkJCSAqIG92ZXIgcnVuIGJ5dGVzLgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfVU5ERVJfUlVOX1JFU0lEVUFMCTE3CS8qIENvbW1hbmQgZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byByZWNpdmVkCisJCQkJCQkgKiBjb21tYW5kIGhhcyByZXNpZHVhbCB1bmRlcgorCQkJCQkJICogcnVuIGJ5dGVzLgorCQkJCQkJICovCisjZGVmaW5lIENNRF9LSUxMRURfSU5WQUxJRF9TVEFUU05fUkNWRAkxOAkvKiBDb21tYW5kIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gYSByZWNpZXZlZAorCQkJCQkJICogUERVIGhhcyBhbiBpbnZhbGlkIFN0YXR1c1NOCisJCQkJCQkgKi8KKyNkZWZpbmUgQ01EX0tJTExFRF9JTlZBTElEX1IyVF9SQ1ZECTE5CS8qIENvbW1hbmQgZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBhIHJlY2lldmVkCisJCQkJCQkgKiBhbiBSMlQgd2l0aCBzb21lIGludmFsaWQKKwkJCQkJCSAqIGZpZWxkcyBpbiBpdAorCQkJCQkJICovCisjZGVmaW5lIENNRF9DWE5fS0lMTEVEX0xVTl9JTlZBTElECTIwCS8qIENvbW1hbmQgZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byByZWNlaXZlZAorCQkJCQkJICogUERVIGhhcyBhbiBpbnZhbGlkIExVTi4KKwkJCQkJCSAqLworI2RlZmluZSBDTURfQ1hOX0tJTExFRF9JQ0RfSU5WQUxJRAkyMQkvKiBDb21tYW5kIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gdGhlCisJCQkJCQkgKiBjb3JyZXNwb25kaW5nIElDRCBub3QgaW4gYQorCQkJCQkJICogdmFsaWQgc3RhdGUKKwkJCQkJCSAqLworI2RlZmluZSBDTURfQ1hOX0tJTExFRF9JVFRfSU5WQUxJRAkyMgkvKiBDb21tYW5kIGdvdCBpbnZhbGlkYXRlZCBkdWUKKwkJCQkJCSAqICB0byByZWNlaXZlZCBQRFUgaGFzIGFuCisJCQkJCQkgKiAgaW52YWxpZCBJVFQuCisJCQkJCQkgKi8KKyNkZWZpbmUgQ01EX0NYTl9LSUxMRURfU0VRX09VVE9GT1JERVIJMjMJLyogQ29tbWFuZCBnb3QgaW52YWxpZGF0ZWQgZHVlCisJCQkJCQkgKiB0byByZWNlaXZlZCBzZXF1ZW5jZSBidWZmZXIKKwkJCQkJCSAqIG9mZnNldCBpcyBvdXQgb2Ygb3JkZXIuCisJCQkJCQkgKi8KKyNkZWZpbmUgQ01EX0NYTl9LSUxMRURfSU5WQUxJRF9EQVRBU05fUkNWRCAyNAkvKiBDb21tYW5kIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gYQorCQkJCQkJICogcmVjaWV2ZWQgUERVIGhhcyBhbiBpbnZhbGlkCisJCQkJCQkgKiBEYXRhU04KKwkJCQkJCSAqLworI2RlZmluZSBDWE5fSU5WQUxJREFURV9OT1RJRlkJCTI1CS8qIENvbm5lY3Rpb24gaW52YWxpZGF0aW9uCisJCQkJCQkgKiBjb21wbGV0aW9uIG5vdGlmeS4KKwkJCQkJCSAqLworI2RlZmluZSBDWE5fSU5WQUxJREFURV9JTkRFWF9OT1RJRlkJMjYJLyogQ29ubmVjdGlvbiBpbnZhbGlkYXRpb24KKwkJCQkJCSAqIGNvbXBsZXRpb24KKwkJCQkJCSAqIHdpdGggZGF0YSBQRFUgaW5kZXguCisJCQkJCQkgKi8KKyNkZWZpbmUgQ01EX0lOVkFMSURBVEVEX05PVElGWQkJMjcJLyogQ29tbWFuZCBpbnZhbGlkYXRpb24KKwkJCQkJCSAqIGNvbXBsZXRpb25ub3RpZmlmeS4KKwkJCQkJCSAqLworI2RlZmluZSBVTlNPTF9IRFJfTk9USUZZCQkyOAkvKiBVbnNvbGljaXRlZCBoZWFkZXIgbm90aWZ5LiovCisjZGVmaW5lIFVOU09MX0RBVEFfTk9USUZZCQkyOQkvKiBVbnNvbGljaXRlZCBkYXRhIG5vdGlmeS4qLworI2RlZmluZSBVTlNPTF9EQVRBX0RJR0VTVF9FUlJPUl9OT1RJRlkgCTMwCS8qIFVuc29saWNpdGVkIGRhdGEgZGlnZXN0CisJCQkJCQkgKiBlcnJvciBub3RpZnkuCisJCQkJCQkgKi8KKyNkZWZpbmUgRFJJVkVSTVNHX05PVElGWQkJMzEJLyogVENQIGFja25vd2xlZGdlIGJhc2VkCisJCQkJCQkgKiBub3RpZmljYXRpb24uCisJCQkJCQkgKi8KKyNkZWZpbmUgQ1hOX0tJTExFRF9DTU5EX0RBVEFfTk9UX09OX1NBTUVfQ09OTiAzMiAvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICAqIGludGVybmFsbHkgZHVlIHRvIGNvbW1hbmQKKwkJCQkJCSAgKiBhbmQgZGF0YSBhcmUgbm90IG9uIHNhbWUKKwkJCQkJCSAgKiBjb25uZWN0aW9uLgorCQkJCQkJICAqLworI2RlZmluZSBTT0xfQ01EX0tJTExFRF9ESUZfRVJSCQkzMwkvKiBTb2xpY2l0ZWQgY29tbWFuZCBnb3QKKwkJCQkJCSAqICBpbnZhbGlkYXRlZCBpbnRlcm5hbGx5IGR1ZQorCQkJCQkJICogIHRvIERJRiBlcnJvcgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfU1lOX1JDVkQJCTM0CS8qIENvbm5lY3Rpb24gZ290IGludmFsaWRhdGVkCisJCQkJCQkgKiBpbnRlcm5hbGx5IGR1ZSB0byBpbmNvbWluZworCQkJCQkJICogVENQIFNZTgorCQkJCQkJICovCisjZGVmaW5lIENYTl9LSUxMRURfSU1NX0RBVEFfUkNWRAkzNQkvKiBDb25uZWN0aW9uIGdvdCBpbnZhbGlkYXRlZAorCQkJCQkJICogaW50ZXJuYWxseSBkdWUgdG8gYW4KKwkJCQkJCSAqIGluY29taW5nIFVuc29saWNpdGVkIFBEVQorCQkJCQkJICogdGhhdCBoYXMgaW1tZWRpYXRlIGRhdGEgb24KKwkJCQkJCSAqIHRoZSBjeG4KKwkJCQkJCSAqLworCit2b2lkIGJlX3dyYl9oZHJfcHJlcGFyZShzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiLCBpbnQgcGF5bG9hZF9sZW4sCisJCQlib29sIGVtYmVkZGVkLCB1OCBzZ2VfY250KTsKKwordm9pZCBiZV9jbWRfaGRyX3ByZXBhcmUoc3RydWN0IGJlX2NtZF9yZXFfaGRyICpyZXFfaGRyLAorCQkJdTggc3Vic3lzdGVtLCB1OCBvcGNvZGUsIGludCBjbWRfbGVuKTsKKworI2VuZGlmIC8qICFCRUlTQ1NJX0NNRFNfSCAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JlMmlzY3NpL2JlX2lzY3NpLmMgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfaXNjc2kuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yZmQyNTQ0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JlMmlzY3NpL2JlX2lzY3NpLmMKQEAgLTAsMCArMSw2MzggQEAKKy8qKgorICogQ29weXJpZ2h0IChDKSAyMDA1IC0gMjAwOSBTZXJ2ZXJFbmdpbmVzCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMgorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uICBUaGUgZnVsbCBHTlUgR2VuZXJhbAorICogUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4gdGhlIGZpbGUgY2FsbGVkIENPUFlJTkcuCisgKgorICogV3JpdHRlbiBieTogSmF5YW1vaGFuIEthbGxpY2thbCAoamF5YW1vaGFua0BzZXJ2ZXJlbmdpbmVzLmNvbSkKKyAqCisgKiBDb250YWN0IEluZm9ybWF0aW9uOgorICogbGludXgtZHJpdmVyc0BzZXJ2ZXJlbmdpbmVzLmNvbQorICoKKyAqIFNlcnZlckVuZ2luZXMKKyAqIDIwOSBOLiBGYWlyIE9ha3MgQXZlCisgKiBTdW5ueXZhbGUsIENBIDk0MDg1CisgKgorICovCisKKyNpbmNsdWRlIDxzY3NpL2xpYmlzY3NpLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX3RyYW5zcG9ydF9pc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV90cmFuc3BvcnQuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfY21uZC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfaG9zdC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorCisjaW5jbHVkZSAiYmVfaXNjc2kuaCIKKworZXh0ZXJuIHN0cnVjdCBpc2NzaV90cmFuc3BvcnQgYmVpc2NzaV9pc2NzaV90cmFuc3BvcnQ7CisKKy8qKgorICogYmVpc2NzaV9zZXNzaW9uX2NyZWF0ZSAtIGNyZWF0ZXMgYSBuZXcgaXNjc2kgc2Vzc2lvbgorICogQGNtZHNfbWF4OiBtYXggY29tbWFuZHMgc3VwcG9ydGVkCisgKiBAcWRlcHRoOiBtYXggcXVldWUgZGVwdGggc3VwcG9ydGVkCisgKiBAaW5pdGlhbF9jbWRzbjogaW5pdGlhbCBpc2NzaSBDTURTTgorICovCitzdHJ1Y3QgaXNjc2lfY2xzX3Nlc3Npb24gKmJlaXNjc2lfc2Vzc2lvbl9jcmVhdGUoc3RydWN0IGlzY3NpX2VuZHBvaW50ICplcCwKKwkJCQkJCSB1MTYgY21kc19tYXgsCisJCQkJCQkgdTE2IHFkZXB0aCwKKwkJCQkJCSB1MzIgaW5pdGlhbF9jbWRzbikKK3sKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdDsKKwlzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcDsKKwlzdHJ1Y3QgaXNjc2lfY2xzX3Nlc3Npb24gKmNsc19zZXNzaW9uOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYTsKKwlzdHJ1Y3QgaXNjc2lfc2Vzc2lvbiAqc2VzczsKKwlzdHJ1Y3QgYmVpc2NzaV9zZXNzaW9uICpiZWlzY3NpX3Nlc3M7CisJc3RydWN0IGJlaXNjc2lfaW9fdGFzayAqaW9fdGFzazsKKworCVNFX0RFQlVHKERCR19MVkxfOCwgIkluIGJlaXNjc2lfc2Vzc2lvbl9jcmVhdGVcbiIpOworCisJaWYgKCFlcCkgeworCQlTRV9ERUJVRyhEQkdfTFZMXzEsICJiZWlzY3NpX3Nlc3Npb25fY3JlYXRlOiBpbnZhbGlkIGVwIFxuIik7CisJCXJldHVybiBOVUxMOworCX0KKwliZWlzY3NpX2VwID0gZXAtPmRkX2RhdGE7CisJcGhiYSA9IGJlaXNjc2lfZXAtPnBoYmE7CisJc2hvc3QgPSBwaGJhLT5zaG9zdDsKKwlpZiAoY21kc19tYXggPiBiZWlzY3NpX2VwLT5waGJhLT5wYXJhbXMud3Jic19wZXJfY3huKSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgc2hvc3QsICJDYW5ub3QgaGFuZGxlICVkIGNtZHMuIgorCQkJICAgICAiTWF4IGNtZHMgcGVyIHNlc3Npb24gc3VwcG9ydGVkIGlzICVkLiBVc2luZyAlZC4gIgorCQkJICAgICAiXG4iLCBjbWRzX21heCwKKwkJCSAgICAgIGJlaXNjc2lfZXAtPnBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4sCisJCQkgICAgICBiZWlzY3NpX2VwLT5waGJhLT5wYXJhbXMud3Jic19wZXJfY3huKTsKKwkJY21kc19tYXggPSBiZWlzY3NpX2VwLT5waGJhLT5wYXJhbXMud3Jic19wZXJfY3huOworCX0KKworCSBjbHNfc2Vzc2lvbiA9IGlzY3NpX3Nlc3Npb25fc2V0dXAoJmJlaXNjc2lfaXNjc2lfdHJhbnNwb3J0LAorCQkJCQkgICBzaG9zdCwgY21kc19tYXgsCisJCQkJCSAgIHNpemVvZigqYmVpc2NzaV9zZXNzKSwKKwkJCQkJICAgc2l6ZW9mKCppb190YXNrKSwKKwkJCQkJICAgaW5pdGlhbF9jbWRzbiwgSVNDU0lfTUFYX1RBUkdFVCk7CisJaWYgKCFjbHNfc2Vzc2lvbikKKwkJcmV0dXJuIE5VTEw7CisJc2VzcyA9IGNsc19zZXNzaW9uLT5kZF9kYXRhOworCWJlaXNjc2lfc2VzcyA9IHNlc3MtPmRkX2RhdGE7CisJYmVpc2NzaV9zZXNzLT5iaHNfcG9vbCA9ICBwY2lfcG9vbF9jcmVhdGUoImJlaXNjc2lfYmhzX3Bvb2wiLAorCQkJCQkJICAgcGhiYS0+cGNpZGV2LAorCQkJCQkJICAgc2l6ZW9mKHN0cnVjdCBiZV9jbWRfYmhzKSwKKwkJCQkJCSAgIDY0LCAwKTsKKwlpZiAoIWJlaXNjc2lfc2Vzcy0+YmhzX3Bvb2wpCisJCWdvdG8gZGVzdHJveV9zZXNzOworCisJcmV0dXJuIGNsc19zZXNzaW9uOworZGVzdHJveV9zZXNzOgorCWlzY3NpX3Nlc3Npb25fdGVhcmRvd24oY2xzX3Nlc3Npb24pOworCXJldHVybiBOVUxMOworfQorCisvKioKKyAqIGJlaXNjc2lfc2Vzc2lvbl9kZXN0cm95IC0gZGVzdHJveXMgaXNjc2kgc2Vzc2lvbgorICogQGNsc19zZXNzaW9uOglwb2ludGVyIHRvIGlzY3NpIGNscyBzZXNzaW9uCisgKgorICogRGVzdHJveXMgaVNDU0kgc2Vzc2lvbiBpbnN0YW5jZSBhbmQgcmVsZWFzZXMKKyAqIHJlc291cmNlcyBhbGxvY2F0ZWQgZm9yIGl0LgorICovCit2b2lkIGJlaXNjc2lfc2Vzc2lvbl9kZXN0cm95KHN0cnVjdCBpc2NzaV9jbHNfc2Vzc2lvbiAqY2xzX3Nlc3Npb24pCit7CisJc3RydWN0IGlzY3NpX3Nlc3Npb24gKnNlc3MgPSBjbHNfc2Vzc2lvbi0+ZGRfZGF0YTsKKwlzdHJ1Y3QgYmVpc2NzaV9zZXNzaW9uICpiZWlzY3NpX3Nlc3MgPSBzZXNzLT5kZF9kYXRhOworCisJcGNpX3Bvb2xfZGVzdHJveShiZWlzY3NpX3Nlc3MtPmJoc19wb29sKTsKKwlpc2NzaV9zZXNzaW9uX3RlYXJkb3duKGNsc19zZXNzaW9uKTsKK30KKworLyoqCisgKiBiZWlzY3NpX2Nvbm5fY3JlYXRlIC0gY3JlYXRlIGFuIGluc3RhbmNlIG9mIGlzY3NpIGNvbm5lY3Rpb24KKyAqIEBjbHNfc2Vzc2lvbjogcHRyIHRvIGlzY3NpX2Nsc19zZXNzaW9uCisgKiBAY2lkOiBpc2NzaSBjaWQKKyAqLworc3RydWN0IGlzY3NpX2Nsc19jb25uICoKK2JlaXNjc2lfY29ubl9jcmVhdGUoc3RydWN0IGlzY3NpX2Nsc19zZXNzaW9uICpjbHNfc2Vzc2lvbiwgdTMyIGNpZCkKK3sKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmE7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3Q7CisJc3RydWN0IGlzY3NpX2Nsc19jb25uICpjbHNfY29ubjsKKwlzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm47CisJc3RydWN0IGlzY3NpX2Nvbm4gKmNvbm47CisJc3RydWN0IGlzY3NpX3Nlc3Npb24gKnNlc3M7CisJc3RydWN0IGJlaXNjc2lfc2Vzc2lvbiAqYmVpc2NzaV9zZXNzOworCisJU0VfREVCVUcoREJHX0xWTF84LCAiSW4gYmVpc2NzaV9jb25uX2NyZWF0ZSAsY2lkIgorCQkgImZyb20gaXNjc2kgbGF5ZXI9JWRcbiIsIGNpZCk7CisJc2hvc3QgPSBpc2NzaV9zZXNzaW9uX3RvX3Nob3N0KGNsc19zZXNzaW9uKTsKKwlwaGJhID0gaXNjc2lfaG9zdF9wcml2KHNob3N0KTsKKworCWNsc19jb25uID0gaXNjc2lfY29ubl9zZXR1cChjbHNfc2Vzc2lvbiwgc2l6ZW9mKCpiZWlzY3NpX2Nvbm4pLCBjaWQpOworCWlmICghY2xzX2Nvbm4pCisJCXJldHVybiBOVUxMOworCisJY29ubiA9IGNsc19jb25uLT5kZF9kYXRhOworCWJlaXNjc2lfY29ubiA9IGNvbm4tPmRkX2RhdGE7CisJYmVpc2NzaV9jb25uLT5lcCA9IE5VTEw7CisJYmVpc2NzaV9jb25uLT5waGJhID0gcGhiYTsKKwliZWlzY3NpX2Nvbm4tPmNvbm4gPSBjb25uOworCXNlc3MgPSBjbHNfc2Vzc2lvbi0+ZGRfZGF0YTsKKwliZWlzY3NpX3Nlc3MgPSBzZXNzLT5kZF9kYXRhOworCWJlaXNjc2lfY29ubi0+YmVpc2NzaV9zZXNzID0gYmVpc2NzaV9zZXNzOworCXJldHVybiBjbHNfY29ubjsKK30KKworLyoqCisgKiBiZWlzY3NpX2JpbmRjb25uX2NpZCAtIEJpbmQgdGhlIGJlaXNjc2lfY29ubiB3aXRoIHBoYmEgY29ubmVjdGlvbiB0YWJsZQorICogQGJlaXNjc2lfY29ubjogVGhlIHBvaW50ZXIgdG8gIGJlaXNjc2lfY29ubiBzdHJ1Y3R1cmUKKyAqIEBwaGJhOiBUaGUgcGhiYSBpbnN0YW5jZQorICogQGNpZDogVGhlIGNpZCB0byBmcmVlCisgKi8KK3N0YXRpYyBpbnQgYmVpc2NzaV9iaW5kY29ubl9jaWQoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJCXN0cnVjdCBiZWlzY3NpX2Nvbm4gKmJlaXNjc2lfY29ubiwKKwkJCQl1bnNpZ25lZCBpbnQgY2lkKQoreworCWlmIChwaGJhLT5jb25uX3RhYmxlW2NpZF0pIHsKKwkJU0VfREVCVUcoREJHX0xWTF8xLAorCQkJICJDb25uZWN0aW9uIHRhYmxlIGFscmVhZHkgb2NjdXBpZWQuIERldGVjdGVkIGNsYXNoXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfSBlbHNlIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LCAicGhiYS0+Y29ubl90YWJsZVslZF09JXAoYmVpc2NzaV9jb25uKSBcbiIsCisJCQkgY2lkLCBiZWlzY3NpX2Nvbm4pOworCQlwaGJhLT5jb25uX3RhYmxlW2NpZF0gPSBiZWlzY3NpX2Nvbm47CisJfQorCXJldHVybiAwOworfQorCisvKioKKyAqIGJlaXNjc2lfY29ubl9iaW5kIC0gQmluZHMgaXNjc2kgc2Vzc2lvbi9jb25uZWN0aW9uIHdpdGggVENQIGNvbm5lY3Rpb24KKyAqIEBjbHNfc2Vzc2lvbjogcG9pbnRlciB0byBpc2NzaSBjbHMgc2Vzc2lvbgorICogQGNsc19jb25uOiBwb2ludGVyIHRvIGlzY3NpIGNscyBjb25uCisgKiBAdHJhbnNwb3J0X2ZkOiBFUCBoYW5kbGUoNjQgYml0KQorICoKKyAqIFRoaXMgZnVuY3Rpb24gYmluZHMgdGhlIFRDUCBDb25uIHdpdGggaVNDU0kgQ29ubmVjdGlvbiBhbmQgU2Vzc2lvbi4KKyAqLworaW50IGJlaXNjc2lfY29ubl9iaW5kKHN0cnVjdCBpc2NzaV9jbHNfc2Vzc2lvbiAqY2xzX3Nlc3Npb24sCisJCSAgICAgIHN0cnVjdCBpc2NzaV9jbHNfY29ubiAqY2xzX2Nvbm4sCisJCSAgICAgIHU2NCB0cmFuc3BvcnRfZmQsIGludCBpc19sZWFkaW5nKQoreworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gY2xzX2Nvbm4tPmRkX2RhdGE7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uID0gY29ubi0+ZGRfZGF0YTsKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCA9CisJCShzdHJ1Y3QgU2NzaV9Ib3N0ICopaXNjc2lfc2Vzc2lvbl90b19zaG9zdChjbHNfc2Vzc2lvbik7CisJc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhID0gKHN0cnVjdCBiZWlzY3NpX2hiYSAqKWlzY3NpX2hvc3RfcHJpdihzaG9zdCk7CisJc3RydWN0IGJlaXNjc2lfZW5kcG9pbnQgKmJlaXNjc2lfZXA7CisJc3RydWN0IGlzY3NpX2VuZHBvaW50ICplcDsKKworCVNFX0RFQlVHKERCR19MVkxfOCwgIkluIGJlaXNjc2lfY29ubl9iaW5kXG4iKTsKKwllcCA9IGlzY3NpX2xvb2t1cF9lbmRwb2ludCh0cmFuc3BvcnRfZmQpOworCWlmICghZXApCisJCXJldHVybiAtRUlOVkFMOworCisJYmVpc2NzaV9lcCA9IGVwLT5kZF9kYXRhOworCisJaWYgKGlzY3NpX2Nvbm5fYmluZChjbHNfc2Vzc2lvbiwgY2xzX2Nvbm4sIGlzX2xlYWRpbmcpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChiZWlzY3NpX2VwLT5waGJhICE9IHBoYmEpIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LAorCQkJICJiZWlzY3NpX2VwLT5oYmE9JXAgbm90IGVxdWFsIHRvIHBoYmE9JXAgXG4iLAorCQkJIGJlaXNjc2lfZXAtPnBoYmEsIHBoYmEpOworCQlyZXR1cm4gLUVFWElTVDsKKwl9CisKKwliZWlzY3NpX2Nvbm4tPmJlaXNjc2lfY29ubl9jaWQgPSBiZWlzY3NpX2VwLT5lcF9jaWQ7CisJYmVpc2NzaV9jb25uLT5lcCA9IGJlaXNjc2lfZXA7CisJYmVpc2NzaV9lcC0+Y29ubiA9IGJlaXNjc2lfY29ubjsKKwlTRV9ERUJVRyhEQkdfTFZMXzgsICJiZWlzY3NpX2Nvbm49JXAgY29ubj0lcCBlcF9jaWQ9JWQgXG4iLAorCQkgYmVpc2NzaV9jb25uLCBjb25uLCBiZWlzY3NpX2VwLT5lcF9jaWQpOworCXJldHVybiBiZWlzY3NpX2JpbmRjb25uX2NpZChwaGJhLCBiZWlzY3NpX2Nvbm4sIGJlaXNjc2lfZXAtPmVwX2NpZCk7Cit9CisKKy8qKgorICogYmVpc2NzaV9jb25uX2dldF9wYXJhbSAtIGdldCB0aGUgaXNjc2kgcGFyYW1ldGVyCisgKiBAY2xzX2Nvbm46IHBvaW50ZXIgdG8gaXNjc2kgY2xzIGNvbm4KKyAqIEBwYXJhbTogcGFyYW1ldGVyIHR5cGUgaWRlbnRpZmllcgorICogQGJ1ZjogYnVmZmVyIHBvaW50ZXIKKyAqCisgKiByZXR1cm5zIGlzY3NpIHBhcmFtZXRlcgorICovCitpbnQgYmVpc2NzaV9jb25uX2dldF9wYXJhbShzdHJ1Y3QgaXNjc2lfY2xzX2Nvbm4gKmNsc19jb25uLAorCQkJICAgZW51bSBpc2NzaV9wYXJhbSBwYXJhbSwgY2hhciAqYnVmKQoreworCXN0cnVjdCBiZWlzY3NpX2VuZHBvaW50ICpiZWlzY3NpX2VwOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gY2xzX2Nvbm4tPmRkX2RhdGE7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uID0gY29ubi0+ZGRfZGF0YTsKKwlpbnQgbGVuID0gMDsKKworCWJlaXNjc2lfZXAgPSBiZWlzY3NpX2Nvbm4tPmVwOworCWlmICghYmVpc2NzaV9lcCkgeworCQlTRV9ERUJVRyhEQkdfTFZMXzEsCisJCQkgIkluIGJlaXNjc2lfY29ubl9nZXRfcGFyYW0gLCBubyBiZWlzY3NpX2VwXG4iKTsKKwkJcmV0dXJuIC0xOworCX0KKworCXN3aXRjaCAocGFyYW0pIHsKKwljYXNlIElTQ1NJX1BBUkFNX0NPTk5fUE9SVDoKKwkJbGVuID0gc3ByaW50ZihidWYsICIlaHVcbiIsIGJlaXNjc2lfZXAtPmRzdF90Y3Bwb3J0KTsKKwkJYnJlYWs7CisJY2FzZSBJU0NTSV9QQVJBTV9DT05OX0FERFJFU1M6CisJCWlmIChiZWlzY3NpX2VwLT5pcF90eXBlID09IEJFMl9JUFY0KQorCQkJbGVuID0gc3ByaW50ZihidWYsICIlcEk0XG4iLCAmYmVpc2NzaV9lcC0+ZHN0X2FkZHIpOworCQllbHNlCisJCQlsZW4gPSBzcHJpbnRmKGJ1ZiwgIiVwSTZcbiIsICZiZWlzY3NpX2VwLT5kc3Q2X2FkZHIpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlyZXR1cm4gaXNjc2lfY29ubl9nZXRfcGFyYW0oY2xzX2Nvbm4sIHBhcmFtLCBidWYpOworCX0KKwlyZXR1cm4gbGVuOworfQorCitpbnQgYmVpc2NzaV9zZXRfcGFyYW0oc3RydWN0IGlzY3NpX2Nsc19jb25uICpjbHNfY29ubiwKKwkJICAgICAgZW51bSBpc2NzaV9wYXJhbSBwYXJhbSwgY2hhciAqYnVmLCBpbnQgYnVmbGVuKQoreworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gY2xzX2Nvbm4tPmRkX2RhdGE7CisJc3RydWN0IGlzY3NpX3Nlc3Npb24gKnNlc3Npb24gPSBjb25uLT5zZXNzaW9uOworCWludCByZXQ7CisKKwlyZXQgPSBpc2NzaV9zZXRfcGFyYW0oY2xzX2Nvbm4sIHBhcmFtLCBidWYsIGJ1Zmxlbik7CisJaWYgKHJldCkKKwkJcmV0dXJuIHJldDsKKwkvKgorCSAqIElmIHVzZXJzcGFjZSB0cmllZCB0byBzZXQgdGhlIHZhbHVlIHRvIGhpZ2hlciB0aGFuIHdlIGNhbgorCSAqIHN1cHBvcnQgb3ZlcnJpZGUgaGVyZS4KKwkgKi8KKwlzd2l0Y2ggKHBhcmFtKSB7CisJY2FzZSBJU0NTSV9QQVJBTV9GSVJTVF9CVVJTVDoKKwkJaWYgKHNlc3Npb24tPmZpcnN0X2J1cnN0ID4gODE5MikKKwkJCXNlc3Npb24tPmZpcnN0X2J1cnN0ID0gODE5MjsKKwkJYnJlYWs7CisJY2FzZSBJU0NTSV9QQVJBTV9NQVhfUkVDVl9ETEVOR1RIOgorCQlpZiAoY29ubi0+bWF4X3JlY3ZfZGxlbmd0aCA+IDY1NTM2KQorCQkJY29ubi0+bWF4X3JlY3ZfZGxlbmd0aCA9IDY1NTM2OworCQlicmVhazsKKwljYXNlIElTQ1NJX1BBUkFNX01BWF9CVVJTVDoKKwkJaWYgKHNlc3Npb24tPmZpcnN0X2J1cnN0ID4gMjYyMTQ0KQorCQkJc2Vzc2lvbi0+Zmlyc3RfYnVyc3QgPSAyNjIxNDQ7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCXJldHVybiAwOworCX0KKworCXJldHVybiAwOworfQorCisvKioKKyAqIGJlaXNjc2lfZ2V0X2hvc3RfcGFyYW0gLSBnZXQgdGhlIGlzY3NpIHBhcmFtZXRlcgorICogQHNob3N0OiBwb2ludGVyIHRvIHNjc2lfaG9zdCBzdHJ1Y3R1cmUKKyAqIEBwYXJhbTogcGFyYW1ldGVyIHR5cGUgaWRlbnRpZmllcgorICogQGJ1ZjogYnVmZmVyIHBvaW50ZXIKKyAqCisgKiByZXR1cm5zIGhvc3QgcGFyYW1ldGVyCisgKi8KK2ludCBiZWlzY3NpX2dldF9ob3N0X3BhcmFtKHN0cnVjdCBTY3NpX0hvc3QgKnNob3N0LAorCQkJICAgZW51bSBpc2NzaV9ob3N0X3BhcmFtIHBhcmFtLCBjaGFyICpidWYpCit7CisJc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhID0gKHN0cnVjdCBiZWlzY3NpX2hiYSAqKWlzY3NpX2hvc3RfcHJpdihzaG9zdCk7CisJaW50IGxlbiA9IDA7CisKKwlzd2l0Y2ggKHBhcmFtKSB7CisJY2FzZSBJU0NTSV9IT1NUX1BBUkFNX0hXQUREUkVTUzoKKwkJYmVfY21kX2dldF9tYWNfYWRkcigmcGhiYS0+Y3RybCwgcGhiYS0+bWFjX2FkZHJlc3MpOworCQlsZW4gPSBzeXNmc19mb3JtYXRfbWFjKGJ1ZiwgcGhiYS0+bWFjX2FkZHJlc3MsIEVUSF9BTEVOKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0dXJuIGlzY3NpX2hvc3RfZ2V0X3BhcmFtKHNob3N0LCBwYXJhbSwgYnVmKTsKKwl9CisJcmV0dXJuIGxlbjsKK30KKworLyoqCisgKiBiZWlzY3NpX2Nvbm5fZ2V0X3N0YXRzIC0gZ2V0IHRoZSBpc2NzaSBzdGF0cworICogQGNsc19jb25uOiBwb2ludGVyIHRvIGlzY3NpIGNscyBjb25uCisgKiBAc3RhdHM6IHBvaW50ZXIgdG8gaXNjc2lfc3RhdHMgc3RydWN0dXJlCisgKgorICogcmV0dXJucyBpc2NzaSBzdGF0cworICovCit2b2lkIGJlaXNjc2lfY29ubl9nZXRfc3RhdHMoc3RydWN0IGlzY3NpX2Nsc19jb25uICpjbHNfY29ubiwKKwkJCSAgICBzdHJ1Y3QgaXNjc2lfc3RhdHMgKnN0YXRzKQoreworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gY2xzX2Nvbm4tPmRkX2RhdGE7CisKKwlTRV9ERUJVRyhEQkdfTFZMXzgsICJJbiBiZWlzY3NpX2Nvbm5fZ2V0X3N0YXRzXG4iKTsKKwlzdGF0cy0+dHhkYXRhX29jdGV0cyA9IGNvbm4tPnR4ZGF0YV9vY3RldHM7CisJc3RhdHMtPnJ4ZGF0YV9vY3RldHMgPSBjb25uLT5yeGRhdGFfb2N0ZXRzOworCXN0YXRzLT5kYXRhb3V0X3BkdXMgPSBjb25uLT5kYXRhb3V0X3BkdXNfY250OworCXN0YXRzLT5zY3NpcnNwX3BkdXMgPSBjb25uLT5zY3NpcnNwX3BkdXNfY250OworCXN0YXRzLT5zY3NpY21kX3BkdXMgPSBjb25uLT5zY3NpY21kX3BkdXNfY250OworCXN0YXRzLT5kYXRhaW5fcGR1cyA9IGNvbm4tPmRhdGFpbl9wZHVzX2NudDsKKwlzdGF0cy0+dG1mcnNwX3BkdXMgPSBjb25uLT50bWZyc3BfcGR1c19jbnQ7CisJc3RhdHMtPnRtZmNtZF9wZHVzID0gY29ubi0+dG1mY21kX3BkdXNfY250OworCXN0YXRzLT5yMnRfcGR1cyA9IGNvbm4tPnIydF9wZHVzX2NudDsKKwlzdGF0cy0+ZGlnZXN0X2VyciA9IDA7CisJc3RhdHMtPnRpbWVvdXRfZXJyID0gMDsKKwlzdGF0cy0+Y3VzdG9tX2xlbmd0aCA9IDA7CisJc3RyY3B5KHN0YXRzLT5jdXN0b21bMF0uZGVzYywgImVoX2Fib3J0X2NudCIpOworCXN0YXRzLT5jdXN0b21bMF0udmFsdWUgPSBjb25uLT5laF9hYm9ydF9jbnQ7Cit9CisKKy8qKgorICogYmVpc2NzaV9zZXRfcGFyYW1zX2Zvcl9vZmZsZCAtIGdldCB0aGUgcGFyYW1ldGVycyBmb3Igb2ZmbG9hZAorICogQGJlaXNjc2lfY29ubjogcG9pbnRlciB0byBiZWlzY3NpX2Nvbm4KKyAqIEBwYXJhbXM6IHBvaW50ZXIgdG8gb2ZmbG9hZF9wYXJhbXMgc3RydWN0dXJlCisgKi8KK3N0YXRpYyB2b2lkICBiZWlzY3NpX3NldF9wYXJhbXNfZm9yX29mZmxkKHN0cnVjdCBiZWlzY3NpX2Nvbm4gKmJlaXNjc2lfY29ubiwKKwkJCQkJICBzdHJ1Y3QgYmVpc2NzaV9vZmZsb2FkX3BhcmFtcyAqcGFyYW1zKQoreworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gYmVpc2NzaV9jb25uLT5jb25uOworCXN0cnVjdCBpc2NzaV9zZXNzaW9uICpzZXNzaW9uID0gY29ubi0+c2Vzc2lvbjsKKworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfYmVpc2NzaV9vZmZsb2FkX3BhcmFtcywgbWF4X2J1cnN0X2xlbmd0aCwKKwkJICAgICAgcGFyYW1zLCBzZXNzaW9uLT5tYXhfYnVyc3QpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfYmVpc2NzaV9vZmZsb2FkX3BhcmFtcywKKwkJICAgICAgbWF4X3NlbmRfZGF0YV9zZWdtZW50X2xlbmd0aCwgcGFyYW1zLAorCQkgICAgICBjb25uLT5tYXhfeG1pdF9kbGVuZ3RoKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2JlaXNjc2lfb2ZmbG9hZF9wYXJhbXMsIGZpcnN0X2J1cnN0X2xlbmd0aCwKKwkJICAgICAgcGFyYW1zLCBzZXNzaW9uLT5maXJzdF9idXJzdCk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLCBlcmwsIHBhcmFtcywKKwkJICAgICAgc2Vzc2lvbi0+ZXJsKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2JlaXNjc2lfb2ZmbG9hZF9wYXJhbXMsIGRkZSwgcGFyYW1zLAorCQkgICAgICBjb25uLT5kYXRhZGdzdF9lbik7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLCBoZGUsIHBhcmFtcywKKwkJICAgICAgY29ubi0+aGRyZGdzdF9lbik7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLCBpcjJ0LCBwYXJhbXMsCisJCSAgICAgIHNlc3Npb24tPmluaXRpYWxfcjJ0X2VuKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2JlaXNjc2lfb2ZmbG9hZF9wYXJhbXMsIGltZCwgcGFyYW1zLAorCQkgICAgICBzZXNzaW9uLT5pbW1fZGF0YV9lbik7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLCBleHBfc3RhdHNuLCBwYXJhbXMsCisJCSAgICAgIChjb25uLT5leHBfc3RhdHNuIC0gMSkpOworfQorCisvKioKKyAqIGJlaXNjc2lfY29ubl9zdGFydCAtIG9mZmxvYWQgb2Ygc2Vzc2lvbiB0byBjaGlwCisgKiBAY2xzX2Nvbm46IHBvaW50ZXIgdG8gYmVpc2NzaV9jb25uCisgKi8KK2ludCBiZWlzY3NpX2Nvbm5fc3RhcnQoc3RydWN0IGlzY3NpX2Nsc19jb25uICpjbHNfY29ubikKK3sKKwlzdHJ1Y3QgaXNjc2lfY29ubiAqY29ubiA9IGNsc19jb25uLT5kZF9kYXRhOworCXN0cnVjdCBiZWlzY3NpX2Nvbm4gKmJlaXNjc2lfY29ubiA9IGNvbm4tPmRkX2RhdGE7CisJc3RydWN0IGJlaXNjc2lfZW5kcG9pbnQgKmJlaXNjc2lfZXA7CisJc3RydWN0IGJlaXNjc2lfb2ZmbG9hZF9wYXJhbXMgcGFyYW1zOworCXN0cnVjdCBpc2NzaV9zZXNzaW9uICpzZXNzaW9uID0gY29ubi0+c2Vzc2lvbjsKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCA9IGlzY3NpX3Nlc3Npb25fdG9fc2hvc3Qoc2Vzc2lvbi0+Y2xzX3Nlc3Npb24pOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSA9IGlzY3NpX2hvc3RfcHJpdihzaG9zdCk7CisKKwltZW1zZXQoJnBhcmFtcywgMCwgc2l6ZW9mKHN0cnVjdCBiZWlzY3NpX29mZmxvYWRfcGFyYW1zKSk7CisJYmVpc2NzaV9lcCA9IGJlaXNjc2lfY29ubi0+ZXA7CisJaWYgKCFiZWlzY3NpX2VwKQorCQlTRV9ERUJVRyhEQkdfTFZMXzEsICJJbiBiZWlzY3NpX2Nvbm5fc3RhcnQgLCBubyBiZWlzY3NpX2VwXG4iKTsKKworCWZyZWVfbWdtdF9zZ2xfaGFuZGxlKHBoYmEsIGJlaXNjc2lfY29ubi0+cGxvZ2luX3NnbF9oYW5kbGUpOworCWJlaXNjc2lfY29ubi0+bG9naW5faW5fcHJvZ3Jlc3MgPSAwOworCWJlaXNjc2lfc2V0X3BhcmFtc19mb3Jfb2ZmbGQoYmVpc2NzaV9jb25uLCAmcGFyYW1zKTsKKwliZWlzY3NpX29mZmxvYWRfY29ubmVjdGlvbihiZWlzY3NpX2Nvbm4sICZwYXJhbXMpOworCWlzY3NpX2Nvbm5fc3RhcnQoY2xzX2Nvbm4pOworCXJldHVybiAwOworfQorCisvKioKKyAqIGJlaXNjc2lfZ2V0X2NpZCAtIEFsbG9jYXRlIGEgY2lkCisgKiBAcGhiYTogVGhlIHBoYmEgaW5zdGFuY2UKKyAqLworc3RhdGljIGludCBiZWlzY3NpX2dldF9jaWQoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXVuc2lnbmVkIHNob3J0IGNpZCA9IDB4RkZGRjsKKworCWlmICghcGhiYS0+YXZsYmxfY2lkcykKKwkJcmV0dXJuIGNpZDsKKworCWNpZCA9IHBoYmEtPmNpZF9hcnJheVtwaGJhLT5jaWRfYWxsb2MrK107CisJaWYgKHBoYmEtPmNpZF9hbGxvYyA9PSBwaGJhLT5wYXJhbXMuY3huc19wZXJfY3RybCkKKwkJcGhiYS0+Y2lkX2FsbG9jID0gMDsKKwlwaGJhLT5hdmxibF9jaWRzLS07CisJcmV0dXJuIGNpZDsKK30KKworLyoqCisgKiBiZWlzY3NpX29wZW5fY29ubiAtIEFzayBGVyB0byBvcGVuIGEgVENQIGNvbm5lY3Rpb24KKyAqIEBlcDoJZW5kcG9pbnQgdG8gYmUgdXNlZAorICogQHNyY19hZGRyOiBUaGUgc291cmNlIElQIGFkZHJlc3MKKyAqIEBkc3RfYWRkcjogVGhlIERlc3RpbmF0aW9uICBJUCBhZGRyZXNzCisgKgorICogQXNrcyB0aGUgRlcgdG8gb3BlbiBhIFRDUCBjb25uZWN0aW9uCisgKi8KK3N0YXRpYyBpbnQgYmVpc2NzaV9vcGVuX2Nvbm4oc3RydWN0IGlzY3NpX2VuZHBvaW50ICplcCwKKwkJCSAgICAgc3RydWN0IHNvY2thZGRyICpzcmNfYWRkciwKKwkJCSAgICAgc3RydWN0IHNvY2thZGRyICpkc3RfYWRkciwgaW50IG5vbl9ibG9ja2luZykKK3sKKwlzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcCA9IGVwLT5kZF9kYXRhOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSA9IGJlaXNjc2lfZXAtPnBoYmE7CisJaW50IHJldCA9IC0xOworCisJYmVpc2NzaV9lcC0+ZXBfY2lkID0gYmVpc2NzaV9nZXRfY2lkKHBoYmEpOworCWlmIChiZWlzY3NpX2VwLT5lcF9jaWQgPT0gMHhGRkZGKSB7CisJCVNFX0RFQlVHKERCR19MVkxfMSwgIk5vIGZyZWUgY2lkIGF2YWlsYWJsZVxuIik7CisJCXJldHVybiByZXQ7CisJfQorCVNFX0RFQlVHKERCR19MVkxfOCwgIkluIGJlaXNjc2lfb3Blbl9jb25uLCBlcF9jaWQ9JWQgIiwKKwkJIGJlaXNjc2lfZXAtPmVwX2NpZCk7CisJcGhiYS0+ZXBfYXJyYXlbYmVpc2NzaV9lcC0+ZXBfY2lkXSA9IGVwOworCWlmIChiZWlzY3NpX2VwLT5lcF9jaWQgPgorCSAgICAocGhiYS0+ZndfY29uZmlnLmlzY3NpX2NpZF9zdGFydCArIHBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsKSkgeworCQlTRV9ERUJVRyhEQkdfTFZMXzEsICJGYWlsZWQgaW4gYWxsb2NhdGUgaXNjc2kgY2lkXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwliZWlzY3NpX2VwLT5jaWRfdmxkID0gMDsKKwlyZXR1cm4gbWdtdF9vcGVuX2Nvbm5lY3Rpb24ocGhiYSwgZHN0X2FkZHIsIGJlaXNjc2lfZXApOworfQorCisvKioKKyAqIGJlaXNjc2lfcHV0X2NpZCAtIEZyZWUgdGhlIGNpZAorICogQHBoYmE6IFRoZSBwaGJhIGZvciB3aGljaCB0aGUgY2lkIGlzIGJlaW5nIGZyZWVkCisgKiBAY2lkOiBUaGUgY2lkIHRvIGZyZWUKKyAqLworc3RhdGljIHZvaWQgYmVpc2NzaV9wdXRfY2lkKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgdW5zaWduZWQgc2hvcnQgY2lkKQoreworCXBoYmEtPmF2bGJsX2NpZHMrKzsKKwlwaGJhLT5jaWRfYXJyYXlbcGhiYS0+Y2lkX2ZyZWUrK10gPSBjaWQ7CisJaWYgKHBoYmEtPmNpZF9mcmVlID09IHBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsKQorCQlwaGJhLT5jaWRfZnJlZSA9IDA7Cit9CisKKy8qKgorICogYmVpc2NzaV9mcmVlX2VwIC0gZnJlZSBlbmRwb2ludAorICogQGVwOglwb2ludGVyIHRvIGlzY3NpIGVuZHBvaW50IHN0cnVjdHVyZQorICovCitzdGF0aWMgdm9pZCBiZWlzY3NpX2ZyZWVfZXAoc3RydWN0IGlzY3NpX2VuZHBvaW50ICplcCkKK3sKKwlzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcCA9IGVwLT5kZF9kYXRhOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSA9IGJlaXNjc2lfZXAtPnBoYmE7CisKKwliZWlzY3NpX3B1dF9jaWQocGhiYSwgYmVpc2NzaV9lcC0+ZXBfY2lkKTsKKwliZWlzY3NpX2VwLT5waGJhID0gTlVMTDsKKwlpc2NzaV9kZXN0cm95X2VuZHBvaW50KGVwKTsKK30KKworLyoqCisgKiBiZWlzY3NpX2VwX2Nvbm5lY3QgLSBBc2sgY2hpcCB0byBjcmVhdGUgVENQIENvbm4KKyAqIEBzY3NpX2hvc3Q6IFBvaW50ZXIgdG8gc2NzaV9ob3N0IHN0cnVjdHVyZQorICogQGRzdF9hZGRyOiBUaGUgSVAgYWRkcmVzcyBvZiBUYXJnZXQKKyAqIEBub25fYmxvY2tpbmc6IGJsb2NraW5nIG9yIG5vbi1ibG9ja2luZyBjYWxsCisgKgorICogVGhpcyByb3V0aW5lcyBmaXJzdCBhc2tzIGNoaXAgdG8gY3JlYXRlIGEgY29ubmVjdGlvbiBhbmQgdGhlbiBhbGxvY2F0ZXMgYW4gRVAKKyAqLworc3RydWN0IGlzY3NpX2VuZHBvaW50ICoKK2JlaXNjc2lfZXBfY29ubmVjdChzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCwgc3RydWN0IHNvY2thZGRyICpkc3RfYWRkciwKKwkJICAgaW50IG5vbl9ibG9ja2luZykKK3sKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmE7CisJc3RydWN0IGJlaXNjc2lfZW5kcG9pbnQgKmJlaXNjc2lfZXA7CisJc3RydWN0IGlzY3NpX2VuZHBvaW50ICplcDsKKwlpbnQgcmV0OworCisJU0VfREVCVUcoREJHX0xWTF84LCAiSW4gYmVpc2NzaV9lcF9jb25uZWN0IFxuIik7CisJaWYgKHNob3N0KQorCQlwaGJhID0gaXNjc2lfaG9zdF9wcml2KHNob3N0KTsKKwllbHNlIHsKKwkJcmV0ID0gLUVOWElPOworCQlTRV9ERUJVRyhEQkdfTFZMXzEsICJzaG9zdCBpcyBOVUxMIFxuIik7CisJCXJldHVybiBFUlJfUFRSKHJldCk7CisJfQorCWVwID0gaXNjc2lfY3JlYXRlX2VuZHBvaW50KHNpemVvZihzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCkpOworCWlmICghZXApIHsKKwkJcmV0ID0gLUVOT01FTTsKKwkJcmV0dXJuIEVSUl9QVFIocmV0KTsKKwl9CisKKwliZWlzY3NpX2VwID0gZXAtPmRkX2RhdGE7CisJYmVpc2NzaV9lcC0+cGhiYSA9IHBoYmE7CisKKwlpZiAoYmVpc2NzaV9vcGVuX2Nvbm4oZXAsIE5VTEwsIGRzdF9hZGRyLCBub25fYmxvY2tpbmcpKSB7CisJCVNFX0RFQlVHKERCR19MVkxfMSwgIkZhaWxlZCBpbiBhbGxvY2F0ZSBpc2NzaSBjaWRcbiIpOworCQlyZXQgPSAtRU5PTUVNOworCQlnb3RvIGZyZWVfZXA7CisJfQorCisJcmV0dXJuIGVwOworCitmcmVlX2VwOgorCWJlaXNjc2lfZnJlZV9lcChlcCk7CisJcmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKworLyoqCisgKiBiZWlzY3NpX2VwX3BvbGwgLSBQb2xsIHRvIHNlZSBpZiBjb25uZWN0aW9uIGlzIGVzdGFibGlzaGVkCisgKiBAZXA6CWVuZHBvaW50IHRvIGJlIHVzZWQKKyAqIEB0aW1lb3V0X21zOiB0aW1lb3V0IHNwZWNpZmllZCBpbiBtaWxsaXNlY3MKKyAqCisgKiBQb2xsIHRvIHNlZSBpZiBUQ1AgY29ubmVjdGlvbiBlc3RhYmxpc2hlZAorICovCitpbnQgYmVpc2NzaV9lcF9wb2xsKHN0cnVjdCBpc2NzaV9lbmRwb2ludCAqZXAsIGludCB0aW1lb3V0X21zKQoreworCXN0cnVjdCBiZWlzY3NpX2VuZHBvaW50ICpiZWlzY3NpX2VwID0gZXAtPmRkX2RhdGE7CisKKwlTRV9ERUJVRyhEQkdfTFZMXzgsICJJbiAgYmVpc2NzaV9lcF9wb2xsXG4iKTsKKwlpZiAoYmVpc2NzaV9lcC0+Y2lkX3ZsZCA9PSAxKQorCQlyZXR1cm4gMTsKKwllbHNlCisJCXJldHVybiAwOworfQorCisvKioKKyAqIGJlaXNjc2lfY2xvc2VfY29ubiAtIFVwbG9hZCB0aGUgIGNvbm5lY3Rpb24KKyAqIEBlcDogVGhlIGlzY3NpIGVuZHBvaW50CisgKiBAZmxhZzogVGhlIHR5cGUgb2YgY29ubmVjdGlvbiBjbG9zdXJlCisgKi8KK3N0YXRpYyBpbnQgYmVpc2NzaV9jbG9zZV9jb25uKHN0cnVjdCBpc2NzaV9lbmRwb2ludCAqZXAsIGludCBmbGFnKQoreworCWludCByZXQgPSAwOworCXN0cnVjdCBiZWlzY3NpX2VuZHBvaW50ICpiZWlzY3NpX2VwID0gZXAtPmRkX2RhdGE7CisJc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhID0gYmVpc2NzaV9lcC0+cGhiYTsKKworCWlmIChNR01UX1NUQVRVU19TVUNDRVNTICE9CisJICAgIG1nbXRfdXBsb2FkX2Nvbm5lY3Rpb24ocGhiYSwgYmVpc2NzaV9lcC0+ZXBfY2lkLAorCQlDT05ORUNUSU9OX1VQTE9BRF9HUkFDRUZVTCkpIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LCAidXBsb2FkIGZhaWxlZCBmb3IgY2lkIDB4JXgiLAorCQkJIGJlaXNjc2lfZXAtPmVwX2NpZCk7CisJCXJldCA9IC0xOworCX0KKworCXJldHVybiByZXQ7Cit9CisKKy8qKgorICogYmVpc2NzaV9lcF9kaXNjb25uZWN0IC0gVGVhcnMgZG93biB0aGUgVENQIGNvbm5lY3Rpb24KKyAqIEBlcDoJZW5kcG9pbnQgdG8gYmUgdXNlZAorICoKKyAqIFRlYXJzIGRvd24gdGhlIFRDUCBjb25uZWN0aW9uCisgKi8KK3ZvaWQgYmVpc2NzaV9lcF9kaXNjb25uZWN0KHN0cnVjdCBpc2NzaV9lbmRwb2ludCAqZXApCit7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uOworCXN0cnVjdCBiZWlzY3NpX2VuZHBvaW50ICpiZWlzY3NpX2VwOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYTsKKwlpbnQgZmxhZyA9IDA7CisKKwliZWlzY3NpX2VwID0gZXAtPmRkX2RhdGE7CisJcGhiYSA9IGJlaXNjc2lfZXAtPnBoYmE7CisJU0VfREVCVUcoREJHX0xWTF84LCAiSW4gYmVpc2NzaV9lcF9kaXNjb25uZWN0XG4iKTsKKworCWlmIChiZWlzY3NpX2VwLT5jb25uKSB7CisJCWJlaXNjc2lfY29ubiA9IGJlaXNjc2lfZXAtPmNvbm47CisJCWlzY3NpX3N1c3BlbmRfcXVldWUoYmVpc2NzaV9jb25uLT5jb25uKTsKKwkJYmVpc2NzaV9jbG9zZV9jb25uKGVwLCBmbGFnKTsKKwl9CisKKwliZWlzY3NpX2ZyZWVfZXAoZXApOworfQorCisvKioKKyAqIGJlaXNjc2lfdW5iaW5kX2Nvbm5fdG9fY2lkIC0gVW5iaW5kIHRoZSBiZWlzY3NpX2Nvbm4gZnJvbSBwaGJhIGNvbm4gdGFibGUKKyAqIEBwaGJhOiBUaGUgcGhiYSBpbnN0YW5jZQorICogQGNpZDogVGhlIGNpZCB0byBmcmVlCisgKi8KK3N0YXRpYyBpbnQgYmVpc2NzaV91bmJpbmRfY29ubl90b19jaWQoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJCSAgICAgIHVuc2lnbmVkIGludCBjaWQpCit7CisJaWYgKHBoYmEtPmNvbm5fdGFibGVbY2lkXSkKKwkJcGhiYS0+Y29ubl90YWJsZVtjaWRdID0gTlVMTDsKKwllbHNlIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LCAiQ29ubmVjdGlvbiB0YWJsZSBOb3Qgb2NjdXBpZWQuIFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiBiZWlzY3NpX2Nvbm5fc3RvcCAtIEludmFsaWRhdGUgYW5kIHN0b3AgdGhlIGNvbm5lY3Rpb24KKyAqIEBjbHNfY29ubjogcG9pbnRlciB0byBnZXQgaXNjc2lfY29ubgorICogQGZsYWc6IFRoZSB0eXBlIG9mIGNvbm5lY3Rpb24gY2xvc3VyZQorICovCit2b2lkIGJlaXNjc2lfY29ubl9zdG9wKHN0cnVjdCBpc2NzaV9jbHNfY29ubiAqY2xzX2Nvbm4sIGludCBmbGFnKQoreworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gY2xzX2Nvbm4tPmRkX2RhdGE7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uID0gY29ubi0+ZGRfZGF0YTsKKwlzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcDsKKwlzdHJ1Y3QgaXNjc2lfc2Vzc2lvbiAqc2Vzc2lvbiA9IGNvbm4tPnNlc3Npb247CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QgPSBpc2NzaV9zZXNzaW9uX3RvX3Nob3N0KHNlc3Npb24tPmNsc19zZXNzaW9uKTsKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEgPSBpc2NzaV9ob3N0X3ByaXYoc2hvc3QpOworCXVuc2lnbmVkIGludCBzdGF0dXM7CisJdW5zaWduZWQgc2hvcnQgc2F2ZWNmZ19mbGFnID0gQ01EX0lTQ1NJX1NFU1NJT05fU0FWRV9DRkdfT05fRkxBU0g7CisKKwlTRV9ERUJVRyhEQkdfTFZMXzgsICJJbiBiZWlzY3NpX2Nvbm5fc3RvcFxuIik7CisJYmVpc2NzaV9lcCA9IGJlaXNjc2lfY29ubi0+ZXA7CisJaWYgKCFiZWlzY3NpX2VwKSB7CisJCVNFX0RFQlVHKERCR19MVkxfOCwgIkluIGJlaXNjc2lfY29ubl9zdG9wICwgbm8gYmVpc2NzaV9lcFxuIik7CisJCXJldHVybjsKKwl9CisJc3RhdHVzID0gbWdtdF9pbnZhbGlkYXRlX2Nvbm5lY3Rpb24ocGhiYSwgYmVpc2NzaV9lcCwKKwkJCQkJICAgIGJlaXNjc2lfZXAtPmVwX2NpZCwgMSwKKwkJCQkJICAgIHNhdmVjZmdfZmxhZyk7CisJaWYgKHN0YXR1cyAhPSBNR01UX1NUQVRVU19TVUNDRVNTKSB7CisJCVNFX0RFQlVHKERCR19MVkxfMSwKKwkJCSAibWdtdF9pbnZhbGlkYXRlX2Nvbm5lY3Rpb24gRmFpbGVkIGZvciBjaWQ9JWQgXG4iLAorCQkJIGJlaXNjc2lfZXAtPmVwX2NpZCk7CisJfQorCWJlaXNjc2lfdW5iaW5kX2Nvbm5fdG9fY2lkKHBoYmEsIGJlaXNjc2lfZXAtPmVwX2NpZCk7CisJaXNjc2lfY29ubl9zdG9wKGNsc19jb25uLCBmbGFnKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9pc2NzaS5oIGIvZHJpdmVycy9zY3NpL2JlMmlzY3NpL2JlX2lzY3NpLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjkyZmZjNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9pc2NzaS5oCkBAIC0wLDAgKzEsNzUgQEAKKy8qKgorICogQ29weXJpZ2h0IChDKSAyMDA1IC0gMjAwOSBTZXJ2ZXJFbmdpbmVzCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMgorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uICBUaGUgZnVsbCBHTlUgR2VuZXJhbAorICogUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4gdGhlIGZpbGUgY2FsbGVkIENPUFlJTkcuCisgKgorICogV3JpdHRlbiBieTogSmF5YW1vaGFuIEthbGxpY2thbCAoamF5YW1vaGFua0BzZXJ2ZXJlbmdpbmVzLmNvbSkKKyAqCisgKiBDb250YWN0IEluZm9ybWF0aW9uOgorICogbGludXgtZHJpdmVyc0BzZXJ2ZXJlbmdpbmVzLmNvbQorICoKKyAqIFNlcnZlckVuZ2luZXMKKyAqIDIwOSBOLiBGYWlyIE9ha3MgQXZlCisgKiBTdW5ueXZhbGUsIENBIDk0MDg1CisgKgorICovCisKKyNpZm5kZWYgX0JFX0lTQ1NJXworI2RlZmluZSBfQkVfSVNDU0lfCisKKyNpbmNsdWRlICJiZV9tYWluLmgiCisjaW5jbHVkZSAiYmVfbWdtdC5oIgorCisjZGVmaW5lIEJFMl9JUFY0ICAweDEKKyNkZWZpbmUgQkUyX0lQVjYgIDB4MTAKKwordm9pZCBiZWlzY3NpX29mZmxvYWRfY29ubmVjdGlvbihzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCQkJc3RydWN0IGJlaXNjc2lfb2ZmbG9hZF9wYXJhbXMgKnBhcmFtcyk7CisKK3ZvaWQgYmVpc2NzaV9vZmZsb2FkX2lzY3NpKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgc3RydWN0IGlzY3NpX2Nvbm4gKmNvbm4sCisJCQkgICBzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCQkgICB1bnNpZ25lZCBpbnQgZndfaGFuZGxlKTsKKworc3RydWN0IGlzY3NpX2Nsc19zZXNzaW9uICpiZWlzY3NpX3Nlc3Npb25fY3JlYXRlKHN0cnVjdCBpc2NzaV9lbmRwb2ludCAqZXAsCisJCQkJCQkgdWludDE2X3QgY21kc19tYXgsCisJCQkJCQkgdWludDE2X3QgcWRlcHRoLAorCQkJCQkJIHVpbnQzMl90IGluaXRpYWxfY21kc24pOworCit2b2lkIGJlaXNjc2lfc2Vzc2lvbl9kZXN0cm95KHN0cnVjdCBpc2NzaV9jbHNfc2Vzc2lvbiAqY2xzX3Nlc3Npb24pOworCitzdHJ1Y3QgaXNjc2lfY2xzX2Nvbm4gKmJlaXNjc2lfY29ubl9jcmVhdGUoc3RydWN0IGlzY3NpX2Nsc19zZXNzaW9uCisJCQkJCSAgICpjbHNfc2Vzc2lvbiwgdWludDMyX3QgY2lkKTsKKworaW50IGJlaXNjc2lfY29ubl9iaW5kKHN0cnVjdCBpc2NzaV9jbHNfc2Vzc2lvbiAqY2xzX3Nlc3Npb24sCisJCSAgICAgIHN0cnVjdCBpc2NzaV9jbHNfY29ubiAqY2xzX2Nvbm4sCisJCSAgICAgIHVpbnQ2NF90IHRyYW5zcG9ydF9mZCwgaW50IGlzX2xlYWRpbmcpOworCitpbnQgYmVpc2NzaV9jb25uX2dldF9wYXJhbShzdHJ1Y3QgaXNjc2lfY2xzX2Nvbm4gKmNsc19jb25uLAorCQkJICAgZW51bSBpc2NzaV9wYXJhbSBwYXJhbSwgY2hhciAqYnVmKTsKKworaW50IGJlaXNjc2lfZ2V0X2hvc3RfcGFyYW0oc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QsCisJCQkgICBlbnVtIGlzY3NpX2hvc3RfcGFyYW0gcGFyYW0sIGNoYXIgKmJ1Zik7CisKK2ludCBiZWlzY3NpX3NldF9wYXJhbShzdHJ1Y3QgaXNjc2lfY2xzX2Nvbm4gKmNsc19jb25uLAorCQkgICAgICBlbnVtIGlzY3NpX3BhcmFtIHBhcmFtLCBjaGFyICpidWYsIGludCBidWZsZW4pOworCitpbnQgYmVpc2NzaV9jb25uX3N0YXJ0KHN0cnVjdCBpc2NzaV9jbHNfY29ubiAqY2xzX2Nvbm4pOworCit2b2lkIGJlaXNjc2lfY29ubl9zdG9wKHN0cnVjdCBpc2NzaV9jbHNfY29ubiAqY2xzX2Nvbm4sIGludCBmbGFnKTsKKworc3RydWN0IGlzY3NpX2VuZHBvaW50ICpiZWlzY3NpX2VwX2Nvbm5lY3Qoc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QsCisJCQkJCSAgc3RydWN0IHNvY2thZGRyICpkc3RfYWRkciwKKwkJCQkJICBpbnQgbm9uX2Jsb2NraW5nKTsKKworaW50IGJlaXNjc2lfZXBfcG9sbChzdHJ1Y3QgaXNjc2lfZW5kcG9pbnQgKmVwLCBpbnQgdGltZW91dF9tcyk7CisKK3ZvaWQgYmVpc2NzaV9lcF9kaXNjb25uZWN0KHN0cnVjdCBpc2NzaV9lbmRwb2ludCAqZXApOworCit2b2lkIGJlaXNjc2lfY29ubl9nZXRfc3RhdHMoc3RydWN0IGlzY3NpX2Nsc19jb25uICpjbHNfY29ubiwKKwkJCSAgICBzdHJ1Y3QgaXNjc2lfc3RhdHMgKnN0YXRzKTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfbWFpbi5jIGIvZHJpdmVycy9zY3NpL2JlMmlzY3NpL2JlX21haW4uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40ZjFhY2EzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JlMmlzY3NpL2JlX21haW4uYwpAQCAtMCwwICsxLDMzOTAgQEAKKy8qKgorICogQ29weXJpZ2h0IChDKSAyMDA1IC0gMjAwOSBTZXJ2ZXJFbmdpbmVzCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKKyAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIHZlcnNpb24gMgorICogYXMgcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uICBUaGUgZnVsbCBHTlUgR2VuZXJhbAorICogUHVibGljIExpY2Vuc2UgaXMgaW5jbHVkZWQgaW4gdGhpcyBkaXN0cmlidXRpb24gaW4gdGhlIGZpbGUgY2FsbGVkIENPUFlJTkcuCisgKgorICogV3JpdHRlbiBieTogSmF5YW1vaGFuIEthbGxpY2thbCAoamF5YW1vaGFua0BzZXJ2ZXJlbmdpbmVzLmNvbSkKKyAqCisgKiBDb250YWN0IEluZm9ybWF0aW9uOgorICogbGludXgtZHJpdmVyc0BzZXJ2ZXJlbmdpbmVzLmNvbQorICoKKyAqICBTZXJ2ZXJFbmdpbmVzCisgKiAyMDkgTi4gRmFpciBPYWtzIEF2ZQorICogU3Vubnl2YWxlLCBDQSA5NDA4NQorICoKKyAqLworI2luY2x1ZGUgPGxpbnV4L3JlYm9vdC5oPgorI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvYmxrZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CisjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CisjaW5jbHVkZSA8bGludXgvc2VtYXBob3JlLmg+CisKKyNpbmNsdWRlIDxzY3NpL2xpYmlzY3NpLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX3RyYW5zcG9ydF9pc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV90cmFuc3BvcnQuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfY21uZC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9kZXZpY2UuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfaG9zdC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgImJlX21haW4uaCIKKyNpbmNsdWRlICJiZV9pc2NzaS5oIgorI2luY2x1ZGUgImJlX21nbXQuaCIKKworc3RhdGljIHVuc2lnbmVkIGludCBiZV9pb3BvbGxfYnVkZ2V0ID0gMTA7CitzdGF0aWMgdW5zaWduZWQgaW50IGJlX21heF9waHlzX3NpemUgPSA2NDsKK3N0YXRpYyB1bnNpZ25lZCBpbnQgZW5hYmxlX21zaXg7CisKK01PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBiZWlzY3NpX3BjaV9pZF90YWJsZSk7CitNT0RVTEVfREVTQ1JJUFRJT04oRFJWX0RFU0MgIiAiIEJVSUxEX1NUUik7CitNT0RVTEVfQVVUSE9SKCJTZXJ2ZXJFbmdpbmVzIENvcnBvcmF0aW9uIik7CitNT0RVTEVfTElDRU5TRSgiR1BMIik7Cittb2R1bGVfcGFyYW0oYmVfaW9wb2xsX2J1ZGdldCwgaW50LCAwKTsKK21vZHVsZV9wYXJhbShlbmFibGVfbXNpeCwgaW50LCAwKTsKK21vZHVsZV9wYXJhbShiZV9tYXhfcGh5c19zaXplLCB1aW50LCBTX0lSVUdPKTsKK01PRFVMRV9QQVJNX0RFU0MoYmVfbWF4X3BoeXNfc2l6ZSwgIk1heGltdW0gU2l6ZSAoSW4gS2lsb2J5dGVzKSBvZiBwaHlzaWNhbGx5IgorCQkJCSAgICJjb250aWd1b3VzIG1lbW9yeSB0aGF0IGNhbiBiZSBhbGxvY2F0ZWQuIgorCQkJCSAgICJSYW5nZSBpcyAxNiAtIDEyOCIpOworCitzdGF0aWMgaW50IGJlaXNjc2lfc2xhdmVfY29uZmlndXJlKHN0cnVjdCBzY3NpX2RldmljZSAqc2RldikKK3sKKwlibGtfcXVldWVfbWF4X3NlZ21lbnRfc2l6ZShzZGV2LT5yZXF1ZXN0X3F1ZXVlLCA2NTUzNik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2NzaV9ob3N0X3RlbXBsYXRlIGJlaXNjc2lfc2h0ID0geworCS5tb2R1bGUgPSBUSElTX01PRFVMRSwKKwkubmFtZSA9ICJTZXJ2ZXJFbmdpbmVzIDEwR2JlIG9wZW4taXNjc2kgSW5pdGlhdG9yIERyaXZlciIsCisJLnByb2NfbmFtZSA9IERSVl9OQU1FLAorCS5xdWV1ZWNvbW1hbmQgPSBpc2NzaV9xdWV1ZWNvbW1hbmQsCisJLmVoX2Fib3J0X2hhbmRsZXIgPSBpc2NzaV9laF9hYm9ydCwKKwkuY2hhbmdlX3F1ZXVlX2RlcHRoID0gaXNjc2lfY2hhbmdlX3F1ZXVlX2RlcHRoLAorCS5zbGF2ZV9jb25maWd1cmUgPSBiZWlzY3NpX3NsYXZlX2NvbmZpZ3VyZSwKKwkudGFyZ2V0X2FsbG9jID0gaXNjc2lfdGFyZ2V0X2FsbG9jLAorCS5laF9kZXZpY2VfcmVzZXRfaGFuZGxlciA9IGlzY3NpX2VoX2RldmljZV9yZXNldCwKKwkuZWhfdGFyZ2V0X3Jlc2V0X2hhbmRsZXIgPSBpc2NzaV9laF90YXJnZXRfcmVzZXQsCisJLnNnX3RhYmxlc2l6ZSA9IEJFSVNDU0lfU0dMSVNUX0VMRU1FTlRTLAorCS5jYW5fcXVldWUgPSBCRTJfSU9fREVQVEgsCisJLnRoaXNfaWQgPSAtMSwKKwkubWF4X3NlY3RvcnMgPSBCRUlTQ1NJX01BWF9TRUNUT1JTLAorCS5jbWRfcGVyX2x1biA9IEJFSVNDU0lfQ01EX1BFUl9MVU4sCisJLnVzZV9jbHVzdGVyaW5nID0gRU5BQkxFX0NMVVNURVJJTkcsCit9Oworc3RhdGljIHN0cnVjdCBzY3NpX3RyYW5zcG9ydF90ZW1wbGF0ZSAqYmVpc2NzaV9zY3NpX3RyYW5zcG9ydDsKKworLyotLS0tLS0tLS0tLS0tLS0tLS0tIFBDSSBEcml2ZXIgb3BlcmF0aW9ucyBhbmQgZGF0YSAtLS0tLS0tLS0tLS0tLS0tLSAqLworc3RhdGljIERFRklORV9QQ0lfREVWSUNFX1RBQkxFKGJlaXNjc2lfcGNpX2lkX3RhYmxlKSA9IHsKKwl7IFBDSV9ERVZJQ0UoQkVfVkVORE9SX0lELCBCRV9ERVZJQ0VfSUQxKSB9LAorCXsgUENJX0RFVklDRShCRV9WRU5ET1JfSUQsIE9DX0RFVklDRV9JRDEpIH0sCisJeyBQQ0lfREVWSUNFKEJFX1ZFTkRPUl9JRCwgT0NfREVWSUNFX0lEMikgfSwKKwl7IDAgfQorfTsKK01PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBiZWlzY3NpX3BjaV9pZF90YWJsZSk7CisKK3N0YXRpYyBzdHJ1Y3QgYmVpc2NzaV9oYmEgKmJlaXNjc2lfaGJhX2FsbG9jKHN0cnVjdCBwY2lfZGV2ICpwY2lkZXYpCit7CisJc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhOworCXN0cnVjdCBTY3NpX0hvc3QgKnNob3N0OworCisJc2hvc3QgPSBpc2NzaV9ob3N0X2FsbG9jKCZiZWlzY3NpX3NodCwgc2l6ZW9mKCpwaGJhKSwgMCk7CisJaWYgKCFzaG9zdCkgeworCQlkZXZfZXJyKCZwY2lkZXYtPmRldiwgImJlaXNjc2lfaGJhX2FsbG9jIC0iCisJCQkiaXNjc2lfaG9zdF9hbGxvYyBmYWlsZWQgXG4iKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCXNob3N0LT5kbWFfYm91bmRhcnkgPSBwY2lkZXYtPmRtYV9tYXNrOworCXNob3N0LT5tYXhfaWQgPSBCRTJfTUFYX1NFU1NJT05TOworCXNob3N0LT5tYXhfY2hhbm5lbCA9IDA7CisJc2hvc3QtPm1heF9jbWRfbGVuID0gQkVJU0NTSV9NQVhfQ01EX0xFTjsKKwlzaG9zdC0+bWF4X2x1biA9IEJFSVNDU0lfTlVNX01BWF9MVU47CisJc2hvc3QtPnRyYW5zcG9ydHQgPSBiZWlzY3NpX3Njc2lfdHJhbnNwb3J0OworCisJcGhiYSA9IGlzY3NpX2hvc3RfcHJpdihzaG9zdCk7CisJbWVtc2V0KHBoYmEsIDAsIHNpemVvZigqcGhiYSkpOworCXBoYmEtPnNob3N0ID0gc2hvc3Q7CisJcGhiYS0+cGNpZGV2ID0gcGNpX2Rldl9nZXQocGNpZGV2KTsKKworCWlmIChpc2NzaV9ob3N0X2FkZChzaG9zdCwgJnBoYmEtPnBjaWRldi0+ZGV2KSkKKwkJZ290byBmcmVlX2RldmljZXM7CisJcmV0dXJuIHBoYmE7CisKK2ZyZWVfZGV2aWNlczoKKwlwY2lfZGV2X3B1dChwaGJhLT5wY2lkZXYpOworCWlzY3NpX2hvc3RfZnJlZShwaGJhLT5zaG9zdCk7CisJcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGJlaXNjc2lfdW5tYXBfcGNpX2Z1bmN0aW9uKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlpZiAocGhiYS0+Y3NyX3ZhKSB7CisJCWlvdW5tYXAocGhiYS0+Y3NyX3ZhKTsKKwkJcGhiYS0+Y3NyX3ZhID0gTlVMTDsKKwl9CisJaWYgKHBoYmEtPmRiX3ZhKSB7CisJCWlvdW5tYXAocGhiYS0+ZGJfdmEpOworCQlwaGJhLT5kYl92YSA9IE5VTEw7CisJfQorCWlmIChwaGJhLT5wY2lfdmEpIHsKKwkJaW91bm1hcChwaGJhLT5wY2lfdmEpOworCQlwaGJhLT5wY2lfdmEgPSBOVUxMOworCX0KK30KKworc3RhdGljIGludCBiZWlzY3NpX21hcF9wY2lfYmFycyhzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkJc3RydWN0IHBjaV9kZXYgKnBjaWRldikKK3sKKwl1OCBfX2lvbWVtICphZGRyOworCisJYWRkciA9IGlvcmVtYXBfbm9jYWNoZShwY2lfcmVzb3VyY2Vfc3RhcnQocGNpZGV2LCAyKSwKKwkJCSAgICAgICBwY2lfcmVzb3VyY2VfbGVuKHBjaWRldiwgMikpOworCWlmIChhZGRyID09IE5VTEwpCisJCXJldHVybiAtRU5PTUVNOworCXBoYmEtPmN0cmwuY3NyID0gYWRkcjsKKwlwaGJhLT5jc3JfdmEgPSBhZGRyOworCXBoYmEtPmNzcl9wYS51LmE2NC5hZGRyZXNzID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBjaWRldiwgMik7CisKKwlhZGRyID0gaW9yZW1hcF9ub2NhY2hlKHBjaV9yZXNvdXJjZV9zdGFydChwY2lkZXYsIDQpLCAxMjggKiAxMDI0KTsKKwlpZiAoYWRkciA9PSBOVUxMKQorCQlnb3RvIHBjaV9tYXBfZXJyOworCXBoYmEtPmN0cmwuZGIgPSBhZGRyOworCXBoYmEtPmRiX3ZhID0gYWRkcjsKKwlwaGJhLT5kYl9wYS51LmE2NC5hZGRyZXNzID0gIHBjaV9yZXNvdXJjZV9zdGFydChwY2lkZXYsIDQpOworCisJYWRkciA9IGlvcmVtYXBfbm9jYWNoZShwY2lfcmVzb3VyY2Vfc3RhcnQocGNpZGV2LCAxKSwKKwkJCSAgICAgICBwY2lfcmVzb3VyY2VfbGVuKHBjaWRldiwgMSkpOworCWlmIChhZGRyID09IE5VTEwpCisJCWdvdG8gcGNpX21hcF9lcnI7CisJcGhiYS0+Y3RybC5wY2ljZmcgPSBhZGRyOworCXBoYmEtPnBjaV92YSA9IGFkZHI7CisJcGhiYS0+cGNpX3BhLnUuYTY0LmFkZHJlc3MgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGNpZGV2LCAxKTsKKwlyZXR1cm4gMDsKKworcGNpX21hcF9lcnI6CisJYmVpc2NzaV91bm1hcF9wY2lfZnVuY3Rpb24ocGhiYSk7CisJcmV0dXJuIC1FTk9NRU07Cit9CisKK3N0YXRpYyBpbnQgYmVpc2NzaV9lbmFibGVfcGNpKHN0cnVjdCBwY2lfZGV2ICpwY2lkZXYpCit7CisJaW50IHJldDsKKworCXJldCA9IHBjaV9lbmFibGVfZGV2aWNlKHBjaWRldik7CisJaWYgKHJldCkgeworCQlkZXZfZXJyKCZwY2lkZXYtPmRldiwgImJlaXNjc2lfZW5hYmxlX3BjaSAtIGVuYWJsZSBkZXZpY2UgIgorCQkJImZhaWxlZC4gUmV0dXJuaW5nIC1FTk9ERVZcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCWlmIChwY2lfc2V0X2NvbnNpc3RlbnRfZG1hX21hc2socGNpZGV2LCBETUFfQklUX01BU0soNjQpKSkgeworCQlyZXQgPSBwY2lfc2V0X2NvbnNpc3RlbnRfZG1hX21hc2socGNpZGV2LCBETUFfQklUX01BU0soMzIpKTsKKwkJaWYgKHJldCkgeworCQkJZGV2X2VycigmcGNpZGV2LT5kZXYsICJDb3VsZCBub3Qgc2V0IFBDSSBETUEgTWFza1xuIik7CisJCQlwY2lfZGlzYWJsZV9kZXZpY2UocGNpZGV2KTsKKwkJCXJldHVybiByZXQ7CisJCX0KKwl9CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmVfY3RybF9pbml0KHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgc3RydWN0IHBjaV9kZXYgKnBkZXYpCit7CisJc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCA9ICZwaGJhLT5jdHJsOworCXN0cnVjdCBiZV9kbWFfbWVtICptYm94X21lbV9hbGxvYyA9ICZjdHJsLT5tYm94X21lbV9hbGxvY2VkOworCXN0cnVjdCBiZV9kbWFfbWVtICptYm94X21lbV9hbGlnbiA9ICZjdHJsLT5tYm94X21lbTsKKwlpbnQgc3RhdHVzID0gMDsKKworCWN0cmwtPnBkZXYgPSBwZGV2OworCXN0YXR1cyA9IGJlaXNjc2lfbWFwX3BjaV9iYXJzKHBoYmEsIHBkZXYpOworCWlmIChzdGF0dXMpCisJCXJldHVybiBzdGF0dXM7CisKKwltYm94X21lbV9hbGxvYy0+c2l6ZSA9IHNpemVvZihzdHJ1Y3QgYmVfbWNjX21haWxib3gpICsgMTY7CisJbWJveF9tZW1fYWxsb2MtPnZhID0gcGNpX2FsbG9jX2NvbnNpc3RlbnQocGRldiwKKwkJCQkJCSAgbWJveF9tZW1fYWxsb2MtPnNpemUsCisJCQkJCQkgICZtYm94X21lbV9hbGxvYy0+ZG1hKTsKKwlpZiAoIW1ib3hfbWVtX2FsbG9jLT52YSkgeworCQliZWlzY3NpX3VubWFwX3BjaV9mdW5jdGlvbihwaGJhKTsKKwkJc3RhdHVzID0gLUVOT01FTTsKKwkJcmV0dXJuIHN0YXR1czsKKwl9CisKKwltYm94X21lbV9hbGlnbi0+c2l6ZSA9IHNpemVvZihzdHJ1Y3QgYmVfbWNjX21haWxib3gpOworCW1ib3hfbWVtX2FsaWduLT52YSA9IFBUUl9BTElHTihtYm94X21lbV9hbGxvYy0+dmEsIDE2KTsKKwltYm94X21lbV9hbGlnbi0+ZG1hID0gUFRSX0FMSUdOKG1ib3hfbWVtX2FsbG9jLT5kbWEsIDE2KTsKKwltZW1zZXQobWJveF9tZW1fYWxpZ24tPnZhLCAwLCBzaXplb2Yoc3RydWN0IGJlX21jY19tYWlsYm94KSk7CisJc3Bpbl9sb2NrX2luaXQoJmN0cmwtPm1ib3hfbG9jayk7CisJcmV0dXJuIHN0YXR1czsKK30KKworc3RhdGljIHZvaWQgYmVpc2NzaV9nZXRfcGFyYW1zKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlwaGJhLT5wYXJhbXMuaW9zX3Blcl9jdHJsID0gQkUyX0lPX0RFUFRIOworCXBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsID0gQkUyX01BWF9TRVNTSU9OUzsKKwlwaGJhLT5wYXJhbXMuYXN5bmNwZHVzX3Blcl9jdHJsID0gQkUyX0FTWU5DUERVUzsKKwlwaGJhLT5wYXJhbXMuaWNkc19wZXJfY3RybCA9IEJFMl9NQVhfSUNEUyAvIDI7CisJcGhiYS0+cGFyYW1zLm51bV9zZ2VfcGVyX2lvID0gQkUyX1NHRTsKKwlwaGJhLT5wYXJhbXMuZGVmcGR1X2hkcl9zeiA9IEJFMl9ERUZQRFVfSERSX1NaOworCXBoYmEtPnBhcmFtcy5kZWZwZHVfZGF0YV9zeiA9IEJFMl9ERUZQRFVfREFUQV9TWjsKKwlwaGJhLT5wYXJhbXMuZXFfdGltZXIgPSA2NDsKKwlwaGJhLT5wYXJhbXMubnVtX2VxX2VudHJpZXMgPQorCSAgICAoKChCRTJfQ01EU19QRVJfQ1hOICogMiArIEJFMl9MT0dPVVRTICsgQkUyX1RNRlMgKyBCRTJfQVNZTkNQRFVTKSAvCisJCQkJCQkJCTUxMikgKyAxKSAqIDUxMjsKKwlwaGJhLT5wYXJhbXMubnVtX2VxX2VudHJpZXMgPSAocGhiYS0+cGFyYW1zLm51bV9lcV9lbnRyaWVzIDwgMTAyNCkKKwkJCQk/IDEwMjQgOiBwaGJhLT5wYXJhbXMubnVtX2VxX2VudHJpZXM7CisJU0VfREVCVUcoREJHX0xWTF84LCAicGhiYS0+cGFyYW1zLm51bV9lcV9lbnRyaWVzPSVkIFxuIiwKKwkJIHBoYmEtPnBhcmFtcy5udW1fZXFfZW50cmllcyk7CisJcGhiYS0+cGFyYW1zLm51bV9jcV9lbnRyaWVzID0KKwkgICAgKCgoQkUyX0NNRFNfUEVSX0NYTiAqIDIgKyBCRTJfTE9HT1VUUyArIEJFMl9UTUZTICsgQkUyX0FTWU5DUERVUykgLworCQkJCQkJCQk1MTIpICsgMSkgKiA1MTI7CisJU0VfREVCVUcoREJHX0xWTF84LAorCQkicGhiYS0+cGFyYW1zLm51bV9jcV9lbnRyaWVzPSVkIEJFMl9DTURTX1BFUl9DWE49JWQiCisJCSJCRTJfTE9HT1VUUz0lZCBCRTJfVE1GUz0lZCBCRTJfQVNZTkNQRFVTPSVkIFxuIiwKKwkJcGhiYS0+cGFyYW1zLm51bV9jcV9lbnRyaWVzLCBCRTJfQ01EU19QRVJfQ1hOLAorCQlCRTJfTE9HT1VUUywgQkUyX1RNRlMsIEJFMl9BU1lOQ1BEVVMpOworCXBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4gPSAyNTY7Cit9CisKK3N0YXRpYyB2b2lkIGh3aV9yaW5nX2VxX2RiKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwKKwkJCSAgIHVuc2lnbmVkIGludCBpZCwgdW5zaWduZWQgaW50IGNscl9pbnRlcnJ1cHQsCisJCQkgICB1bnNpZ25lZCBpbnQgbnVtX3Byb2Nlc3NlZCwKKwkJCSAgIHVuc2lnbmVkIGNoYXIgcmVhcm0sIHVuc2lnbmVkIGNoYXIgZXZlbnQpCit7CisJdTMyIHZhbCA9IDA7CisJdmFsIHw9IGlkICYgREJfRVFfUklOR19JRF9NQVNLOworCWlmIChyZWFybSkKKwkJdmFsIHw9IDEgPDwgREJfRVFfUkVBUk1fU0hJRlQ7CisJaWYgKGNscl9pbnRlcnJ1cHQpCisJCXZhbCB8PSAxIDw8IERCX0VRX0NMUl9TSElGVDsKKwlpZiAoZXZlbnQpCisJCXZhbCB8PSAxIDw8IERCX0VRX0VWTlRfU0hJRlQ7CisJdmFsIHw9IG51bV9wcm9jZXNzZWQgPDwgREJfRVFfTlVNX1BPUFBFRF9TSElGVDsKKwlpb3dyaXRlMzIodmFsLCBwaGJhLT5kYl92YSArIERCX0VRX09GRlNFVCk7Cit9CisKKy8qKgorICogYmVfaXNyIC0gVGhlIGlzciByb3V0aW5lIG9mIHRoZSBkcml2ZXIuCisgKiBAaXJxOiBOb3QgdXNlZAorICogQGRldl9pZDogUG9pbnRlciB0byBob3N0IGFkYXB0ZXIgc3RydWN0dXJlCisgKi8KK3N0YXRpYyBpcnFyZXR1cm5fdCBiZV9pc3IoaW50IGlycSwgdm9pZCAqZGV2X2lkKQoreworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYTsKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0OworCXN0cnVjdCBiZV9lcV9lbnRyeSAqZXFlID0gTlVMTDsKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyAqZXE7CisJc3RydWN0IGJlX3F1ZXVlX2luZm8gKmNxOworCXVuc2lnbmVkIGxvbmcgZmxhZ3MsIGluZGV4OworCXVuc2lnbmVkIGludCBudW1fZXFfcHJvY2Vzc2VkOworCXN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmw7CisJaW50IGlzcjsKKworCXBoYmEgPSBkZXZfaWQ7CisJaWYgKCFlbmFibGVfbXNpeCkgeworCQljdHJsID0gJnBoYmEtPmN0cmw7OworCQlpc3IgPSBpb3JlYWQzMihjdHJsLT5jc3IgKyBDRVZfSVNSMF9PRkZTRVQgKworCQkJICAgICAgIChQQ0lfRlVOQyhjdHJsLT5wZGV2LT5kZXZmbikgKiBDRVZfSVNSX1NJWkUpKTsKKwkJaWYgKCFpc3IpCisJCQlyZXR1cm4gSVJRX05PTkU7CisJfQorCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcGh3aV9jb250ZXh0ID0gcGh3aV9jdHJsci0+cGh3aV9jdHh0OworCWVxID0gJnBod2lfY29udGV4dC0+YmVfZXEucTsKKwljcSA9ICZwaHdpX2NvbnRleHQtPmJlX2NxOworCWluZGV4ID0gMDsKKwllcWUgPSBxdWV1ZV90YWlsX25vZGUoZXEpOworCWlmICghZXFlKQorCQlTRV9ERUJVRyhEQkdfTFZMXzEsICJlcWUgaXMgTlVMTFxuIik7CisKKwludW1fZXFfcHJvY2Vzc2VkID0gMDsKKwlpZiAoYmxrX2lvcG9sbF9lbmFibGVkKSB7CisJCXdoaWxlIChlcWUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2VxX2VudHJ5LCB2YWxpZCkgLyAzMl0KKwkJCQkJJiBFUUVfVkFMSURfTUFTSykgeworCQkJaWYgKCFibGtfaW9wb2xsX3NjaGVkX3ByZXAoJnBoYmEtPmlvcG9sbCkpCisJCQkJYmxrX2lvcG9sbF9zY2hlZCgmcGhiYS0+aW9wb2xsKTsKKworCQkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9lcV9lbnRyeSwgdmFsaWQsIGVxZSwgMCk7CisJCQlxdWV1ZV90YWlsX2luYyhlcSk7CisJCQllcWUgPSBxdWV1ZV90YWlsX25vZGUoZXEpOworCQkJbnVtX2VxX3Byb2Nlc3NlZCsrOworCQkJU0VfREVCVUcoREJHX0xWTF84LCAiVmFsaWQgRVFFXG4iKTsKKwkJfQorCQlpZiAobnVtX2VxX3Byb2Nlc3NlZCkgeworCQkJaHdpX3JpbmdfZXFfZGIocGhiYSwgZXEtPmlkLCAwLAludW1fZXFfcHJvY2Vzc2VkLCAwLCAxKTsKKwkJCXJldHVybiBJUlFfSEFORExFRDsKKwkJfSBlbHNlCisJCQlyZXR1cm4gSVJRX05PTkU7CisJfSBlbHNlIHsKKwkJd2hpbGUgKGVxZS0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfZXFfZW50cnksIHZhbGlkKSAvIDMyXQorCQkJCQkJJiBFUUVfVkFMSURfTUFTSykgeworCisJCQlpZiAoKChlcWUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2VxX2VudHJ5LAorCQkJICAgICByZXNvdXJjZV9pZCkgLyAzMl0gJgorCQkJICAgICBFUUVfUkVTSURfTUFTSykgPj4gMTYpICE9IGNxLT5pZCkgeworCQkJCXNwaW5fbG9ja19pcnFzYXZlKCZwaGJhLT5pc3JfbG9jaywgZmxhZ3MpOworCQkJCXBoYmEtPnRvZG9fbWNjX2NxID0gMTsKKwkJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwaGJhLT5pc3JfbG9jaywgZmxhZ3MpOworCQkJfSBlbHNlIHsKKwkJCQlzcGluX2xvY2tfaXJxc2F2ZSgmcGhiYS0+aXNyX2xvY2ssIGZsYWdzKTsKKwkJCQlwaGJhLT50b2RvX2NxID0gMTsKKwkJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwaGJhLT5pc3JfbG9jaywgZmxhZ3MpOworCQkJfQorCQkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9lcV9lbnRyeSwgdmFsaWQsIGVxZSwgMCk7CisJCQlxdWV1ZV90YWlsX2luYyhlcSk7CisJCQllcWUgPSBxdWV1ZV90YWlsX25vZGUoZXEpOworCQkJbnVtX2VxX3Byb2Nlc3NlZCsrOworCQl9CisJCWlmIChwaGJhLT50b2RvX2NxIHx8IHBoYmEtPnRvZG9fbWNjX2NxKQorCQkJcXVldWVfd29yayhwaGJhLT53cSwgJnBoYmEtPndvcmtfY3FzKTsKKworCQlpZiAobnVtX2VxX3Byb2Nlc3NlZCkgeworCQkJaHdpX3JpbmdfZXFfZGIocGhiYSwgZXEtPmlkLCAwLCBudW1fZXFfcHJvY2Vzc2VkLCAxLCAxKTsKKwkJCXJldHVybiBJUlFfSEFORExFRDsKKwkJfSBlbHNlCisJCQlyZXR1cm4gSVJRX05PTkU7CisJfQorfQorCitzdGF0aWMgaW50IGJlaXNjc2lfaW5pdF9pcnFzKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgcGNpX2RldiAqcGNpZGV2ID0gcGhiYS0+cGNpZGV2OworCWludCByZXQ7CisKKwlyZXQgPSByZXF1ZXN0X2lycShwY2lkZXYtPmlycSwgYmVfaXNyLCBJUlFGX1NIQVJFRCwgImJlaXNjc2kiLCBwaGJhKTsKKwlpZiAocmV0KSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsICJiZWlzY3NpX2luaXRfaXJxcy0iCisJCQkgICAgICJGYWlsZWQgdG8gcmVnaXN0ZXIgaXJxXFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBod2lfcmluZ19jcV9kYihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkgICB1bnNpZ25lZCBpbnQgaWQsIHVuc2lnbmVkIGludCBudW1fcHJvY2Vzc2VkLAorCQkJICAgdW5zaWduZWQgY2hhciByZWFybSwgdW5zaWduZWQgY2hhciBldmVudCkKK3sKKwl1MzIgdmFsID0gMDsKKwl2YWwgfD0gaWQgJiBEQl9DUV9SSU5HX0lEX01BU0s7CisJaWYgKHJlYXJtKQorCQl2YWwgfD0gMSA8PCBEQl9DUV9SRUFSTV9TSElGVDsKKwl2YWwgfD0gbnVtX3Byb2Nlc3NlZCA8PCBEQl9DUV9OVU1fUE9QUEVEX1NISUZUOworCWlvd3JpdGUzMih2YWwsIHBoYmEtPmRiX3ZhICsgREJfQ1FfT0ZGU0VUKTsKK30KKworLyoKKyAqIGFzeW5jIHBkdXMgaW5jbHVkZQorICogYS4gdW5zb2xpY2l0ZWQgTk9QLUluICh0YXJnZXQgaW5pdGlhdGVkIE5PUC1JbikKKyAqIGIuIEFzeW5jIE1lc3NhZ2VzCisgKiBjLiBSZWplY3QgUERVCisgKiBkLiBMb2dpbiByZXNwb25zZQorICogVGhlc2UgaGVhZGVycyBhcnJpdmUgdW5wcm9jZXNzZWQgYnkgdGhlIEVQIGZpcm13YXJlIGFuZCBpU0NTSSBsYXllcgorICogcHJvY2VzcyB0aGVtCisgKi8KK3N0YXRpYyB1bnNpZ25lZCBpbnQKK2JlaXNjc2lfcHJvY2Vzc19hc3luY19wZHUoc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uLAorCQkJICBzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkgIHVuc2lnbmVkIHNob3J0IGNpZCwKKwkJCSAgc3RydWN0IHBkdV9iYXNlICpwcGR1LAorCQkJICB1bnNpZ25lZCBsb25nIHBkdV9sZW4sCisJCQkgIHZvaWQgKnBidWZmZXIsIHVuc2lnbmVkIGxvbmcgYnVmX2xlbikKK3sKKwlzdHJ1Y3QgaXNjc2lfY29ubiAqY29ubiA9IGJlaXNjc2lfY29ubi0+Y29ubjsKKwlzdHJ1Y3QgaXNjc2lfc2Vzc2lvbiAqc2Vzc2lvbiA9IGNvbm4tPnNlc3Npb247CisKKwlzd2l0Y2ggKHBwZHUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3BkdV9iYXNlLCBvcGNvZGUpIC8gMzJdICYKKwkJCQkJCVBEVUJBU0VfT1BDT0RFX01BU0spIHsKKwljYXNlIElTQ1NJX09QX05PT1BfSU46CisJCXBidWZmZXIgPSBOVUxMOworCQlidWZfbGVuID0gMDsKKwkJYnJlYWs7CisJY2FzZSBJU0NTSV9PUF9BU1lOQ19FVkVOVDoKKwkJYnJlYWs7CisJY2FzZSBJU0NTSV9PUF9SRUpFQ1Q6CisJCVdBUk5fT04oIXBidWZmZXIpOworCQlXQVJOX09OKCEoYnVmX2xlbiA9PSA0OCkpOworCQlTRV9ERUJVRyhEQkdfTFZMXzEsICJJbiBJU0NTSV9PUF9SRUpFQ1RcbiIpOworCQlicmVhazsKKwljYXNlIElTQ1NJX09QX0xPR0lOX1JTUDoKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgICJVbnJlY29nbml6ZWQgb3Bjb2RlIDB4JXggaW4gYXN5bmMgbXNnIFxuIiwKKwkJCSAgICAgKHBwZHUtPgorCQkJICAgICBkd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9wZHVfYmFzZSwgb3Bjb2RlKSAvIDMyXQorCQkJCQkJJiBQRFVCQVNFX09QQ09ERV9NQVNLKSk7CisJCXJldHVybiAxOworCX0KKworCXNwaW5fbG9ja19iaCgmc2Vzc2lvbi0+bG9jayk7CisJX19pc2NzaV9jb21wbGV0ZV9wZHUoY29ubiwgKHN0cnVjdCBpc2NzaV9oZHIgKilwcGR1LCBwYnVmZmVyLCBidWZfbGVuKTsKKwlzcGluX3VubG9ja19iaCgmc2Vzc2lvbi0+bG9jayk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3Qgc2dsX2hhbmRsZSAqYWxsb2NfaW9fc2dsX2hhbmRsZShzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEpCit7CisJc3RydWN0IHNnbF9oYW5kbGUgKnBzZ2xfaGFuZGxlOworCisJaWYgKHBoYmEtPmlvX3NnbF9obmRsX2F2YmwpIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LAorCQkJICJJbiBhbGxvY19pb19zZ2xfaGFuZGxlLGlvX3NnbF9hbGxvY19pbmRleD0lZCBcbiIsCisJCQkgcGhiYS0+aW9fc2dsX2FsbG9jX2luZGV4KTsKKwkJcHNnbF9oYW5kbGUgPSBwaGJhLT5pb19zZ2xfaG5kbF9iYXNlW3BoYmEtPgorCQkJCQkJaW9fc2dsX2FsbG9jX2luZGV4XTsKKwkJcGhiYS0+aW9fc2dsX2huZGxfYmFzZVtwaGJhLT5pb19zZ2xfYWxsb2NfaW5kZXhdID0gTlVMTDsKKwkJcGhiYS0+aW9fc2dsX2huZGxfYXZibC0tOworCQlpZiAocGhiYS0+aW9fc2dsX2FsbG9jX2luZGV4ID09IChwaGJhLT5wYXJhbXMuaW9zX3Blcl9jdHJsIC0gMSkpCisJCQlwaGJhLT5pb19zZ2xfYWxsb2NfaW5kZXggPSAwOworCQllbHNlCisJCQlwaGJhLT5pb19zZ2xfYWxsb2NfaW5kZXgrKzsKKwl9IGVsc2UKKwkJcHNnbF9oYW5kbGUgPSBOVUxMOworCXJldHVybiBwc2dsX2hhbmRsZTsKK30KKworc3RhdGljIHZvaWQKK2ZyZWVfaW9fc2dsX2hhbmRsZShzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsIHN0cnVjdCBzZ2xfaGFuZGxlICpwc2dsX2hhbmRsZSkKK3sKKwlTRV9ERUJVRyhEQkdfTFZMXzgsICJJbiBmcmVlXyxpb19zZ2xfZnJlZV9pbmRleD0lZCBcbiIsCisJCSBwaGJhLT5pb19zZ2xfZnJlZV9pbmRleCk7CisJaWYgKHBoYmEtPmlvX3NnbF9obmRsX2Jhc2VbcGhiYS0+aW9fc2dsX2ZyZWVfaW5kZXhdKSB7CisJCS8qCisJCSAqIHRoaXMgY2FuIGhhcHBlbiBpZiBjbGVhbl90YXNrIGlzIGNhbGxlZCBvbiBhIHRhc2sgdGhhdAorCQkgKiBmYWlsZWQgaW4geG1pdF90YXNrIG9yIGFsbG9jX3BkdS4KKwkJICovCisJCSBTRV9ERUJVRyhEQkdfTFZMXzgsCisJCQkgIkRvdWJsZSBGcmVlIGluIElPIFNHTCBpb19zZ2xfZnJlZV9pbmRleD0lZCwiCisJCQkgInZhbHVlIHRoZXJlPSVwIFxuIiwgcGhiYS0+aW9fc2dsX2ZyZWVfaW5kZXgsCisJCQkgcGhiYS0+aW9fc2dsX2huZGxfYmFzZVtwaGJhLT5pb19zZ2xfZnJlZV9pbmRleF0pOworCQlyZXR1cm47CisJfQorCXBoYmEtPmlvX3NnbF9obmRsX2Jhc2VbcGhiYS0+aW9fc2dsX2ZyZWVfaW5kZXhdID0gcHNnbF9oYW5kbGU7CisJcGhiYS0+aW9fc2dsX2huZGxfYXZibCsrOworCWlmIChwaGJhLT5pb19zZ2xfZnJlZV9pbmRleCA9PSAocGhiYS0+cGFyYW1zLmlvc19wZXJfY3RybCAtIDEpKQorCQlwaGJhLT5pb19zZ2xfZnJlZV9pbmRleCA9IDA7CisJZWxzZQorCQlwaGJhLT5pb19zZ2xfZnJlZV9pbmRleCsrOworfQorCisvKioKKyAqIGFsbG9jX3dyYl9oYW5kbGUgLSBUbyBhbGxvY2F0ZSBhIHdyYiBoYW5kbGUKKyAqIEBwaGJhOiBUaGUgaGJhIHBvaW50ZXIKKyAqIEBjaWQ6IFRoZSBjaWQgdG8gdXNlIGZvciBhbGxvY2F0aW9uCisgKiBAaW5kZXg6IGluZGV4IGFsbG9jYXRpb24gYW5kIHdyYiBpbmRleAorICoKKyAqIFRoaXMgaGFwcGVucyB1bmRlciBzZXNzaW9uX2xvY2sgdW50aWwgc3VibWlzc2lvbiB0byBjaGlwCisgKi8KK3N0cnVjdCB3cmJfaGFuZGxlICphbGxvY193cmJfaGFuZGxlKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgdW5zaWduZWQgaW50IGNpZCwKKwkJCQkgICAgaW50IGluZGV4KQoreworCXN0cnVjdCBod2lfd3JiX2NvbnRleHQgKnB3cmJfY29udGV4dDsKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IHdyYl9oYW5kbGUgKnB3cmJfaGFuZGxlOworCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcHdyYl9jb250ZXh0ID0gJnBod2lfY3RybHItPndyYl9jb250ZXh0W2NpZF07CisJcHdyYl9oYW5kbGUgPSBwd3JiX2NvbnRleHQtPnB3cmJfaGFuZGxlX2Jhc2VbaW5kZXhdOworCXB3cmJfaGFuZGxlLT53cmJfaW5kZXggPSBpbmRleDsKKwlwd3JiX2hhbmRsZS0+bnh0X3dyYl9pbmRleCA9IGluZGV4OworCXJldHVybiBwd3JiX2hhbmRsZTsKK30KKworLyoqCisgKiBmcmVlX3dyYl9oYW5kbGUgLSBUbyBmcmVlIHRoZSB3cmIgaGFuZGxlIGJhY2sgdG8gcG9vbAorICogQHBoYmE6IFRoZSBoYmEgcG9pbnRlcgorICogQHB3cmJfY29udGV4dDogVGhlIGNvbnRleHQgdG8gZnJlZSBmcm9tCisgKiBAcHdyYl9oYW5kbGU6IFRoZSB3cmJfaGFuZGxlIHRvIGZyZWUKKyAqCisgKiBUaGlzIGhhcHBlbnMgdW5kZXIgc2Vzc2lvbl9sb2NrIHVudGlsIHN1Ym1pc3Npb24gdG8gY2hpcAorICovCitzdGF0aWMgdm9pZAorZnJlZV93cmJfaGFuZGxlKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgc3RydWN0IGh3aV93cmJfY29udGV4dCAqcHdyYl9jb250ZXh0LAorCQlzdHJ1Y3Qgd3JiX2hhbmRsZSAqcHdyYl9oYW5kbGUpCit7CisJU0VfREVCVUcoREJHX0xWTF84LAorCQkgIkZSRUUgV1JCOiBwd3JiX2hhbmRsZT0lcCBmcmVlX2luZGV4PSVkPTB4JXgiCisJCSAid3JiX2hhbmRsZXNfYXZhaWxhYmxlPSVkIFxuIiwKKwkJIHB3cmJfaGFuZGxlLCBwd3JiX2NvbnRleHQtPmZyZWVfaW5kZXgsCisJCSBwd3JiX2NvbnRleHQtPmZyZWVfaW5kZXgsIHB3cmJfY29udGV4dC0+d3JiX2hhbmRsZXNfYXZhaWxhYmxlKTsKK30KKworc3RhdGljIHN0cnVjdCBzZ2xfaGFuZGxlICphbGxvY19tZ210X3NnbF9oYW5kbGUoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXN0cnVjdCBzZ2xfaGFuZGxlICpwc2dsX2hhbmRsZTsKKworCWlmIChwaGJhLT5laF9zZ2xfaG5kbF9hdmJsKSB7CisJCXBzZ2xfaGFuZGxlID0gcGhiYS0+ZWhfc2dsX2huZGxfYmFzZVtwaGJhLT5laF9zZ2xfYWxsb2NfaW5kZXhdOworCQlwaGJhLT5laF9zZ2xfaG5kbF9iYXNlW3BoYmEtPmVoX3NnbF9hbGxvY19pbmRleF0gPSBOVUxMOworCQlTRV9ERUJVRyhEQkdfTFZMXzgsICJtZ210X3NnbF9hbGxvY19pbmRleD0lZD0weCV4IFxuIiwKKwkJCSBwaGJhLT5laF9zZ2xfYWxsb2NfaW5kZXgsIHBoYmEtPmVoX3NnbF9hbGxvY19pbmRleCk7CisJCXBoYmEtPmVoX3NnbF9obmRsX2F2YmwtLTsKKwkJaWYgKHBoYmEtPmVoX3NnbF9hbGxvY19pbmRleCA9PQorCQkgICAgKHBoYmEtPnBhcmFtcy5pY2RzX3Blcl9jdHJsIC0gcGhiYS0+cGFyYW1zLmlvc19wZXJfY3RybCAtCisJCSAgICAgMSkpCisJCQlwaGJhLT5laF9zZ2xfYWxsb2NfaW5kZXggPSAwOworCQllbHNlCisJCQlwaGJhLT5laF9zZ2xfYWxsb2NfaW5kZXgrKzsKKwl9IGVsc2UKKwkJcHNnbF9oYW5kbGUgPSBOVUxMOworCXJldHVybiBwc2dsX2hhbmRsZTsKK30KKwordm9pZAorZnJlZV9tZ210X3NnbF9oYW5kbGUoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLCBzdHJ1Y3Qgc2dsX2hhbmRsZSAqcHNnbF9oYW5kbGUpCit7CisKKwlpZiAocGhiYS0+ZWhfc2dsX2huZGxfYmFzZVtwaGJhLT5laF9zZ2xfZnJlZV9pbmRleF0pIHsKKwkJLyoKKwkJICogdGhpcyBjYW4gaGFwcGVuIGlmIGNsZWFuX3Rhc2sgaXMgY2FsbGVkIG9uIGEgdGFzayB0aGF0CisJCSAqIGZhaWxlZCBpbiB4bWl0X3Rhc2sgb3IgYWxsb2NfcGR1LgorCQkgKi8KKwkJU0VfREVCVUcoREJHX0xWTF84LAorCQkJICJEb3VibGUgRnJlZSBpbiBlaCBTR0wgLGVoX3NnbF9mcmVlX2luZGV4PSVkIFxuIiwKKwkJCSBwaGJhLT5laF9zZ2xfZnJlZV9pbmRleCk7CisJCXJldHVybjsKKwl9CisJcGhiYS0+ZWhfc2dsX2huZGxfYmFzZVtwaGJhLT5laF9zZ2xfZnJlZV9pbmRleF0gPSBwc2dsX2hhbmRsZTsKKwlwaGJhLT5laF9zZ2xfaG5kbF9hdmJsKys7CisJaWYgKHBoYmEtPmVoX3NnbF9mcmVlX2luZGV4ID09CisJICAgIChwaGJhLT5wYXJhbXMuaWNkc19wZXJfY3RybCAtIHBoYmEtPnBhcmFtcy5pb3NfcGVyX2N0cmwgLSAxKSkKKwkJcGhiYS0+ZWhfc2dsX2ZyZWVfaW5kZXggPSAwOworCWVsc2UKKwkJcGhiYS0+ZWhfc2dsX2ZyZWVfaW5kZXgrKzsKK30KKworc3RhdGljIHZvaWQKK2JlX2NvbXBsZXRlX2lvKHN0cnVjdCBiZWlzY3NpX2Nvbm4gKmJlaXNjc2lfY29ubiwKKwkgICAgICAgc3RydWN0IGlzY3NpX3Rhc2sgKnRhc2ssIHN0cnVjdCBzb2xfY3FlICpwc29sKQoreworCXN0cnVjdCBiZWlzY3NpX2lvX3Rhc2sgKmlvX3Rhc2sgPSB0YXNrLT5kZF9kYXRhOworCXN0cnVjdCBiZV9zdGF0dXNfYmhzICpzdHNfYmhzID0KKwkJCQkoc3RydWN0IGJlX3N0YXR1c19iaHMgKilpb190YXNrLT5jbWRfYmhzOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gYmVpc2NzaV9jb25uLT5jb25uOworCXVuc2lnbmVkIGludCBzZW5zZV9sZW47CisJdW5zaWduZWQgY2hhciAqc2Vuc2U7CisJdTMyIHJlc2lkID0gMCwgZXhwX2NtZHNuLCBtYXhfY21kc247CisJdTggcnNwLCBzdGF0dXMsIGZsYWdzOworCisJZXhwX2NtZHNuID0gYmUzMl90b19jcHUocHNvbC0+CisJCQlkd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBpX2V4cF9jbWRfc24pIC8gMzJdCisJCQkmIFNPTF9FWFBfQ01EX1NOX01BU0spOworCW1heF9jbWRzbiA9IGJlMzJfdG9fY3B1KChwc29sLT4KKwkJCWR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfZXhwX2NtZF9zbikgLyAzMl0KKwkJCSYgU09MX0VYUF9DTURfU05fTUFTSykgKworCQkJKChwc29sLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBpX2NtZF93bmQpCisJCQkJLyAzMl0gJiBTT0xfQ01EX1dORF9NQVNLKSA+PiAyNCkgLSAxKTsKKwlyc3AgPSAoKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfcmVzcCkgLyAzMl0KKwkJCQkJCSYgU09MX1JFU1BfTUFTSykgPj4gMTYpOworCXN0YXR1cyA9ICgocHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgaV9zdHMpIC8gMzJdCisJCQkJCQkmIFNPTF9TVFNfTUFTSykgPj4gOCk7CisJZmxhZ3MgPSAoKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfZmxhZ3MpIC8gMzJdCisJCQkJCSYgU09MX0ZMQUdTX01BU0spID4+IDI0KSB8IDB4ODA7CisKKwl0YXNrLT5zYy0+cmVzdWx0ID0gKERJRF9PSyA8PCAxNikgfCBzdGF0dXM7CisJaWYgKHJzcCAhPSBJU0NTSV9TVEFUVVNfQ01EX0NPTVBMRVRFRCkgeworCQl0YXNrLT5zYy0+cmVzdWx0ID0gRElEX0VSUk9SIDw8IDE2OworCQlnb3RvIHVubWFwOworCX0KKworCS8qIGJpZGkgbm90IGluaXRpYWxseSBzdXBwb3J0ZWQgKi8KKwlpZiAoZmxhZ3MgJiAoSVNDU0lfRkxBR19DTURfVU5ERVJGTE9XIHwgSVNDU0lfRkxBR19DTURfT1ZFUkZMT1cpKSB7CisJCXJlc2lkID0gKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfcmVzX2NudCkgLworCQkJCTMyXSAmIFNPTF9SRVNfQ05UX01BU0spOworCisJCWlmICghc3RhdHVzICYmIChmbGFncyAmIElTQ1NJX0ZMQUdfQ01EX09WRVJGTE9XKSkKKwkJCXRhc2stPnNjLT5yZXN1bHQgPSBESURfRVJST1IgPDwgMTY7CisKKwkJaWYgKGZsYWdzICYgSVNDU0lfRkxBR19DTURfVU5ERVJGTE9XKSB7CisJCQlzY3NpX3NldF9yZXNpZCh0YXNrLT5zYywgcmVzaWQpOworCQkJaWYgKCFzdGF0dXMgJiYgKHNjc2lfYnVmZmxlbih0YXNrLT5zYykgLSByZXNpZCA8CisJCQkgICAgdGFzay0+c2MtPnVuZGVyZmxvdykpCisJCQkJdGFzay0+c2MtPnJlc3VsdCA9IERJRF9FUlJPUiA8PCAxNjsKKwkJfQorCX0KKworCWlmIChzdGF0dXMgPT0gU0FNX1NUQVRfQ0hFQ0tfQ09ORElUSU9OKSB7CisJCXNlbnNlID0gc3RzX2Jocy0+c2Vuc2VfaW5mbyArIHNpemVvZih1bnNpZ25lZCBzaG9ydCk7CisJCXNlbnNlX2xlbiA9CisJCSAgICBjcHVfdG9fYmUxNigodW5zaWduZWQgc2hvcnQpKHN0c19iaHMtPnNlbnNlX2luZm9bMF0pKTsKKwkJbWVtY3B5KHRhc2stPnNjLT5zZW5zZV9idWZmZXIsIHNlbnNlLAorCQkgICAgICAgbWluX3QodTE2LCBzZW5zZV9sZW4sIFNDU0lfU0VOU0VfQlVGRkVSU0laRSkpOworCX0KKwlpZiAoaW9fdGFzay0+Y21kX2Jocy0+aXNjc2lfaGRyLmZsYWdzICYgSVNDU0lfRkxBR19DTURfUkVBRCkgeworCQlpZiAocHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgaV9yZXNfY250KSAvIDMyXQorCQkJCQkJCSYgU09MX1JFU19DTlRfTUFTSykKKwkJCSBjb25uLT5yeGRhdGFfb2N0ZXRzICs9IChwc29sLT4KKwkJCSAgICAgIGR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfcmVzX2NudCkgLyAzMl0KKwkJCQkJCQkmIFNPTF9SRVNfQ05UX01BU0spOworCX0KK3VubWFwOgorCXNjc2lfZG1hX3VubWFwKGlvX3Rhc2stPnNjc2lfY21uZCk7CisJaXNjc2lfY29tcGxldGVfc2NzaV90YXNrKHRhc2ssIGV4cF9jbWRzbiwgbWF4X2NtZHNuKTsKK30KKworc3RhdGljIHZvaWQKK2JlX2NvbXBsZXRlX2xvZ291dChzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCSAgIHN0cnVjdCBpc2NzaV90YXNrICp0YXNrLCBzdHJ1Y3Qgc29sX2NxZSAqcHNvbCkKK3sKKwlzdHJ1Y3QgaXNjc2lfbG9nb3V0X3JzcCAqaGRyOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gYmVpc2NzaV9jb25uLT5jb25uOworCisJaGRyID0gKHN0cnVjdCBpc2NzaV9sb2dvdXRfcnNwICopdGFzay0+aGRyOworCWhkci0+dDJ3YWl0ID0gNTsKKwloZHItPnQycmV0YWluID0gMDsKKwloZHItPmZsYWdzID0gKChwc29sLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBpX2ZsYWdzKSAvIDMyXQorCQkJCQkmIFNPTF9GTEFHU19NQVNLKSA+PiAyNCkgfCAweDgwOworCWhkci0+cmVzcG9uc2UgPSAocHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgaV9yZXNwKSAvCisJCQkJCTMyXSAmIFNPTF9SRVNQX01BU0spOworCWhkci0+ZXhwX2NtZHNuID0gY3B1X3RvX2JlMzIocHNvbC0+CisJCQlkd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBpX2V4cF9jbWRfc24pIC8gMzJdCisJCQkJCSYgU09MX0VYUF9DTURfU05fTUFTSyk7CisJaGRyLT5tYXhfY21kc24gPSBiZTMyX3RvX2NwdSgocHNvbC0+CisJCQkgZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgaV9leHBfY21kX3NuKSAvIDMyXQorCQkJCQkmIFNPTF9FWFBfQ01EX1NOX01BU0spICsKKwkJCSgocHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgaV9jbWRfd25kKQorCQkJCQkvIDMyXSAmIFNPTF9DTURfV05EX01BU0spID4+IDI0KSAtIDEpOworCWhkci0+aGxlbmd0aCA9IDA7CisKKwlfX2lzY3NpX2NvbXBsZXRlX3BkdShjb25uLCAoc3RydWN0IGlzY3NpX2hkciAqKWhkciwgTlVMTCwgMCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZV9jb21wbGV0ZV90bWYoc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uLAorCQlzdHJ1Y3QgaXNjc2lfdGFzayAqdGFzaywgc3RydWN0IHNvbF9jcWUgKnBzb2wpCit7CisJc3RydWN0IGlzY3NpX3RtX3JzcCAqaGRyOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gYmVpc2NzaV9jb25uLT5jb25uOworCisJaGRyID0gKHN0cnVjdCBpc2NzaV90bV9yc3AgKil0YXNrLT5oZHI7CisJaGRyLT5mbGFncyA9ICgocHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgaV9mbGFncykgLyAzMl0KKwkJCQkJJiBTT0xfRkxBR1NfTUFTSykgPj4gMjQpIHwgMHg4MDsKKwloZHItPnJlc3BvbnNlID0gKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfcmVzcCkgLworCQkJCQkzMl0gJiBTT0xfUkVTUF9NQVNLKTsKKwloZHItPmV4cF9jbWRzbiA9IGNwdV90b19iZTMyKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsCisJCQkJICAgICBpX2V4cF9jbWRfc24pIC8gMzJdICYgU09MX0VYUF9DTURfU05fTUFTSyk7CisJaGRyLT5tYXhfY21kc24gPSBiZTMyX3RvX2NwdSgocHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwKKwkJCWlfZXhwX2NtZF9zbikgLyAzMl0gJiBTT0xfRVhQX0NNRF9TTl9NQVNLKSArCisJCQkoKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfY21kX3duZCkKKwkJCS8gMzJdICYgU09MX0NNRF9XTkRfTUFTSykgPj4gMjQpIC0gMSk7CisJX19pc2NzaV9jb21wbGV0ZV9wZHUoY29ubiwgKHN0cnVjdCBpc2NzaV9oZHIgKiloZHIsIE5VTEwsIDApOworfQorCitzdGF0aWMgdm9pZAoraHdpX2NvbXBsZXRlX2RydnJfbXNncyhzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCSAgICAgICBzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsIHN0cnVjdCBzb2xfY3FlICpwc29sKQoreworCXN0cnVjdCBod2lfd3JiX2NvbnRleHQgKnB3cmJfY29udGV4dDsKKwlzdHJ1Y3Qgd3JiX2hhbmRsZSAqcHdyYl9oYW5kbGU7CisJc3RydWN0IGh3aV9jb250cm9sbGVyICpwaHdpX2N0cmxyOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gYmVpc2NzaV9jb25uLT5jb25uOworCXN0cnVjdCBpc2NzaV9zZXNzaW9uICpzZXNzaW9uID0gY29ubi0+c2Vzc2lvbjsKKworCXBod2lfY3RybHIgPSBwaGJhLT5waHdpX2N0cmxyOworCXB3cmJfY29udGV4dCA9ICZwaHdpX2N0cmxyLT53cmJfY29udGV4dFsoKHBzb2wtPgorCQkJCWR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGNpZCkgLyAzMl0gJgorCQkJCVNPTF9DSURfTUFTSykgPj4gNildOworCXB3cmJfaGFuZGxlID0gcHdyYl9jb250ZXh0LT5wd3JiX2hhbmRsZV9iYXNlc3RkWygocHNvbC0+CisJCQkJZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgd3JiX2luZGV4KSAvCisJCQkJMzJdICYgU09MX1dSQl9JTkRFWF9NQVNLKSA+PiAxNildOworCXNwaW5fbG9ja19iaCgmc2Vzc2lvbi0+bG9jayk7CisJZnJlZV93cmJfaGFuZGxlKHBoYmEsIHB3cmJfY29udGV4dCwgcHdyYl9oYW5kbGUpOworCXNwaW5fdW5sb2NrX2JoKCZzZXNzaW9uLT5sb2NrKTsKK30KKworc3RhdGljIHZvaWQKK2JlX2NvbXBsZXRlX25vcGluX3Jlc3Aoc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uLAorCQkgICAgICAgc3RydWN0IGlzY3NpX3Rhc2sgKnRhc2ssIHN0cnVjdCBzb2xfY3FlICpwc29sKQoreworCXN0cnVjdCBpc2NzaV9ub3BpbiAqaGRyOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gYmVpc2NzaV9jb25uLT5jb25uOworCisJaGRyID0gKHN0cnVjdCBpc2NzaV9ub3BpbiAqKXRhc2stPmhkcjsKKwloZHItPmZsYWdzID0gKChwc29sLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBpX2ZsYWdzKSAvIDMyXQorCQkJJiBTT0xfRkxBR1NfTUFTSykgPj4gMjQpIHwgMHg4MDsKKwloZHItPmV4cF9jbWRzbiA9IGNwdV90b19iZTMyKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsCisJCQkJICAgICBpX2V4cF9jbWRfc24pIC8gMzJdICYgU09MX0VYUF9DTURfU05fTUFTSyk7CisJaGRyLT5tYXhfY21kc24gPSBiZTMyX3RvX2NwdSgocHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwKKwkJCWlfZXhwX2NtZF9zbikgLyAzMl0gJiBTT0xfRVhQX0NNRF9TTl9NQVNLKSArCisJCQkoKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGlfY21kX3duZCkKKwkJCS8gMzJdICYgU09MX0NNRF9XTkRfTUFTSykgPj4gMjQpIC0gMSk7CisJaGRyLT5vcGNvZGUgPSBJU0NTSV9PUF9OT09QX0lOOworCV9faXNjc2lfY29tcGxldGVfcGR1KGNvbm4sIChzdHJ1Y3QgaXNjc2lfaGRyICopaGRyLCBOVUxMLCAwKTsKK30KKworc3RhdGljIHZvaWQgaHdpX2NvbXBsZXRlX2NtZChzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCQkgICAgIHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgc3RydWN0IHNvbF9jcWUgKnBzb2wpCit7CisJc3RydWN0IGh3aV93cmJfY29udGV4dCAqcHdyYl9jb250ZXh0OworCXN0cnVjdCB3cmJfaGFuZGxlICpwd3JiX2hhbmRsZTsKKwlzdHJ1Y3QgaXNjc2lfd3JiICpwd3JiID0gTlVMTDsKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGlzY3NpX3Rhc2sgKnRhc2s7CisJc3RydWN0IGJlaXNjc2lfaW9fdGFzayAqaW9fdGFzazsKKwlzdHJ1Y3QgaXNjc2lfY29ubiAqY29ubiA9IGJlaXNjc2lfY29ubi0+Y29ubjsKKwlzdHJ1Y3QgaXNjc2lfc2Vzc2lvbiAqc2Vzc2lvbiA9IGNvbm4tPnNlc3Npb247CisKKwlwaHdpX2N0cmxyID0gcGhiYS0+cGh3aV9jdHJscjsKKworCXB3cmJfY29udGV4dCA9ICZwaHdpX2N0cmxyLT4KKwkJd3JiX2NvbnRleHRbKChwc29sLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBjaWQpIC8gMzJdCisJCSYgU09MX0NJRF9NQVNLKSA+PiA2KV07CisJcHdyYl9oYW5kbGUgPSBwd3JiX2NvbnRleHQtPnB3cmJfaGFuZGxlX2Jhc2VzdGRbKChwc29sLT4KKwkJCQlkd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCB3cmJfaW5kZXgpIC8KKwkJCQkzMl0gJiBTT0xfV1JCX0lOREVYX01BU0spID4+IDE2KV07CisKKwl0YXNrID0gcHdyYl9oYW5kbGUtPnBpb19oYW5kbGU7CisJaW9fdGFzayA9IHRhc2stPmRkX2RhdGE7CisJc3Bpbl9sb2NrX2JoKCZzZXNzaW9uLT5sb2NrKTsKKwlwd3JiID0gcHdyYl9oYW5kbGUtPnB3cmI7CisJc3dpdGNoICgocHdyYi0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCB0eXBlKSAvIDMyXSAmCisJCSBXUkJfVFlQRV9NQVNLKSA+PiAyOCkgeworCWNhc2UgSFdIX1RZUEVfSU86CisJY2FzZSBIV0hfVFlQRV9JT19SRDoKKwkJaWYgKCh0YXNrLT5oZHItPm9wY29kZSAmIElTQ1NJX09QQ09ERV9NQVNLKSA9PQorCQkgICAgSVNDU0lfT1BfTk9PUF9PVVQpIHsKKwkJCWJlX2NvbXBsZXRlX25vcGluX3Jlc3AoYmVpc2NzaV9jb25uLCB0YXNrLCBwc29sKTsKKwkJfSBlbHNlCisJCQliZV9jb21wbGV0ZV9pbyhiZWlzY3NpX2Nvbm4sIHRhc2ssIHBzb2wpOworCQlicmVhazsKKworCWNhc2UgSFdIX1RZUEVfTE9HT1VUOgorCQliZV9jb21wbGV0ZV9sb2dvdXQoYmVpc2NzaV9jb25uLCB0YXNrLCBwc29sKTsKKwkJYnJlYWs7CisKKwljYXNlIEhXSF9UWVBFX0xPR0lOOgorCQlTRV9ERUJVRyhEQkdfTFZMXzEsCisJCQkgIlx0XHQgTm8gSFdIX1RZUEVfTE9HSU4gRXhwZWN0ZWQgaW4gaHdpX2NvbXBsZXRlX2NtZCIKKwkJCSAiLSBTb2xpY2l0ZWQgcGF0aCBcbiIpOworCQlicmVhazsKKworCWNhc2UgSFdIX1RZUEVfVE1GOgorCQliZV9jb21wbGV0ZV90bWYoYmVpc2NzaV9jb25uLCB0YXNrLCBwc29sKTsKKwkJYnJlYWs7CisKKwljYXNlIEhXSF9UWVBFX05PUDoKKwkJYmVfY29tcGxldGVfbm9waW5fcmVzcChiZWlzY3NpX2Nvbm4sIHRhc2ssIHBzb2wpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCXNob3N0X3ByaW50ayhLRVJOX1dBUk5JTkcsIHBoYmEtPnNob3N0LAorCQkJICAgICJ3cmJfaW5kZXggMHgleCBDSUQgMHgleFxuIiwKKwkJCSAgICAoKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgdHlwZSkgLworCQkJCQkzMl0gJiBTT0xfV1JCX0lOREVYX01BU0spID4+IDE2KSwKKwkJCSAgICAoKHBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGNpZCkgLyAzMl0KKwkJCQkJJiBTT0xfQ0lEX01BU0spID4+IDYpKTsKKwkJYnJlYWs7CisJfQorCisJc3Bpbl91bmxvY2tfYmgoJnNlc3Npb24tPmxvY2spOworfQorCitzdGF0aWMgc3RydWN0IGxpc3RfaGVhZCAqaHdpX2dldF9hc3luY19idXN5X2xpc3Qoc3RydWN0IGh3aV9hc3luY19wZHVfY29udGV4dAorCQkJCQkgICpwYXN5bmNfY3R4LCB1bnNpZ25lZCBpbnQgaXNfaGVhZGVyLAorCQkJCQkgIHVuc2lnbmVkIGludCBob3N0X3dyaXRlX3B0cikKK3sKKwlpZiAoaXNfaGVhZGVyKQorCQlyZXR1cm4gJnBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2hvc3Rfd3JpdGVfcHRyXS4KKwkJICAgIGhlYWRlcl9idXN5X2xpc3Q7CisJZWxzZQorCQlyZXR1cm4gJnBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2hvc3Rfd3JpdGVfcHRyXS5kYXRhX2J1c3lfbGlzdDsKK30KKworc3RhdGljIHN0cnVjdCBhc3luY19wZHVfaGFuZGxlICoKK2h3aV9nZXRfYXN5bmNfaGFuZGxlKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwKKwkJICAgICBzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCSAgICAgc3RydWN0IGh3aV9hc3luY19wZHVfY29udGV4dCAqcGFzeW5jX2N0eCwKKwkJICAgICBzdHJ1Y3QgaV90X2RwZHVfY3FlICpwZHBkdV9jcWUsIHVuc2lnbmVkIGludCAqcGNxX2luZGV4KQoreworCXN0cnVjdCBiZV9idXNfYWRkcmVzcyBwaHlzX2FkZHI7CisJc3RydWN0IGxpc3RfaGVhZCAqcGJ1c3lfbGlzdDsKKwlzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSAqcGFzeW5jX2hhbmRsZSA9IE5VTEw7CisJaW50IGJ1ZmZlcl9sZW4gPSAwOworCXVuc2lnbmVkIGNoYXIgYnVmZmVyX2luZGV4ID0gLTE7CisJdW5zaWduZWQgY2hhciBpc19oZWFkZXIgPSAwOworCisJcGh5c19hZGRyLnUuYTMyLmFkZHJlc3NfbG8gPQorCSAgICBwZHBkdV9jcWUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2lfdF9kcGR1X2NxZSwgZGJfYWRkcl9sbykgLyAzMl0gLQorCSAgICAoKHBkcGR1X2NxZS0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfaV90X2RwZHVfY3FlLCBkcGwpIC8gMzJdCisJCQkJCQkmIFBEVUNRRV9EUExfTUFTSykgPj4gMTYpOworCXBoeXNfYWRkci51LmEzMi5hZGRyZXNzX2hpID0KKwkgICAgcGRwZHVfY3FlLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9pX3RfZHBkdV9jcWUsIGRiX2FkZHJfaGkpIC8gMzJdOworCisJcGh5c19hZGRyLnUuYTY0LmFkZHJlc3MgPQorCQkJKigodW5zaWduZWQgbG9uZyBsb25nICopKCZwaHlzX2FkZHIudS5hNjQuYWRkcmVzcykpOworCisJc3dpdGNoIChwZHBkdV9jcWUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2lfdF9kcGR1X2NxZSwgY29kZSkgLyAzMl0KKwkJCSYgUERVQ1FFX0NPREVfTUFTSykgeworCWNhc2UgVU5TT0xfSERSX05PVElGWToKKwkJaXNfaGVhZGVyID0gMTsKKworCQlwYnVzeV9saXN0ID0gaHdpX2dldF9hc3luY19idXN5X2xpc3QocGFzeW5jX2N0eCwgMSwKKwkJCShwZHBkdV9jcWUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2lfdF9kcGR1X2NxZSwKKwkJCWluZGV4KSAvIDMyXSAmIFBEVUNRRV9JTkRFWF9NQVNLKSk7CisKKwkJYnVmZmVyX2xlbiA9ICh1bnNpZ25lZCBpbnQpKHBoeXNfYWRkci51LmE2NC5hZGRyZXNzIC0KKwkJCQlwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIucGFfYmFzZS51LmE2NC5hZGRyZXNzKTsKKworCQlidWZmZXJfaW5kZXggPSBidWZmZXJfbGVuIC8KKwkJCQlwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuYnVmZmVyX3NpemU7CisKKwkJYnJlYWs7CisJY2FzZSBVTlNPTF9EQVRBX05PVElGWToKKwkJcGJ1c3lfbGlzdCA9IGh3aV9nZXRfYXN5bmNfYnVzeV9saXN0KHBhc3luY19jdHgsIDAsIChwZHBkdV9jcWUtPgorCQkJCQlkd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9pX3RfZHBkdV9jcWUsCisJCQkJCWluZGV4KSAvIDMyXSAmIFBEVUNRRV9JTkRFWF9NQVNLKSk7CisJCWJ1ZmZlcl9sZW4gPSAodW5zaWduZWQgbG9uZykocGh5c19hZGRyLnUuYTY0LmFkZHJlc3MgLQorCQkJCQlwYXN5bmNfY3R4LT5hc3luY19kYXRhLnBhX2Jhc2UudS4KKwkJCQkJYTY0LmFkZHJlc3MpOworCQlidWZmZXJfaW5kZXggPSBidWZmZXJfbGVuIC8gcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5idWZmZXJfc2l6ZTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcGJ1c3lfbGlzdCA9IE5VTEw7CisJCXNob3N0X3ByaW50ayhLRVJOX1dBUk5JTkcsIHBoYmEtPnNob3N0LAorCQkJIlVuZXhwZWN0ZWQgY29kZT0lZCBcbiIsCisJCQkgcGRwZHVfY3FlLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9pX3RfZHBkdV9jcWUsCisJCQkJCWNvZGUpIC8gMzJdICYgUERVQ1FFX0NPREVfTUFTSyk7CisJCXJldHVybiBOVUxMOworCX0KKworCVdBUk5fT04oIShidWZmZXJfaW5kZXggPD0gcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5udW1fZW50cmllcykpOworCVdBUk5fT04obGlzdF9lbXB0eShwYnVzeV9saXN0KSk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShwYXN5bmNfaGFuZGxlLCBwYnVzeV9saXN0LCBsaW5rKSB7CisJCVdBUk5fT04ocGFzeW5jX2hhbmRsZS0+Y29uc3VtZWQpOworCQlpZiAocGFzeW5jX2hhbmRsZS0+aW5kZXggPT0gYnVmZmVyX2luZGV4KQorCQkJYnJlYWs7CisJfQorCisJV0FSTl9PTighcGFzeW5jX2hhbmRsZSk7CisKKwlwYXN5bmNfaGFuZGxlLT5jcmkgPSAodW5zaWduZWQgc2hvcnQpYmVpc2NzaV9jb25uLT5iZWlzY3NpX2Nvbm5fY2lkOworCXBhc3luY19oYW5kbGUtPmlzX2hlYWRlciA9IGlzX2hlYWRlcjsKKwlwYXN5bmNfaGFuZGxlLT5idWZmZXJfbGVuID0gKChwZHBkdV9jcWUtPgorCQkJZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfaV90X2RwZHVfY3FlLCBkcGwpIC8gMzJdCisJCQkmIFBEVUNRRV9EUExfTUFTSykgPj4gMTYpOworCisJKnBjcV9pbmRleCA9IChwZHBkdV9jcWUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2lfdF9kcGR1X2NxZSwKKwkJCWluZGV4KSAvIDMyXSAmIFBEVUNRRV9JTkRFWF9NQVNLKTsKKwlyZXR1cm4gcGFzeW5jX2hhbmRsZTsKK30KKworc3RhdGljIHVuc2lnbmVkIGludAoraHdpX3VwZGF0ZV9hc3luY193cml0YWJsZXMoc3RydWN0IGh3aV9hc3luY19wZHVfY29udGV4dCAqcGFzeW5jX2N0eCwKKwkJCSAgIHVuc2lnbmVkIGludCBpc19oZWFkZXIsIHVuc2lnbmVkIGludCBjcV9pbmRleCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpwYnVzeV9saXN0OworCXN0cnVjdCBhc3luY19wZHVfaGFuZGxlICpwYXN5bmNfaGFuZGxlOworCXVuc2lnbmVkIGludCBudW1fZW50cmllcywgd3JpdGFibGVzID0gMDsKKwl1bnNpZ25lZCBpbnQgKnBlcF9yZWFkX3B0ciwgKnB3cml0YWJsZXM7CisKKworCWlmIChpc19oZWFkZXIpIHsKKwkJcGVwX3JlYWRfcHRyID0gJnBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5lcF9yZWFkX3B0cjsKKwkJcHdyaXRhYmxlcyA9ICZwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIud3JpdGFibGVzOworCQludW1fZW50cmllcyA9IHBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5udW1fZW50cmllczsKKwl9IGVsc2UgeworCQlwZXBfcmVhZF9wdHIgPSAmcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5lcF9yZWFkX3B0cjsKKwkJcHdyaXRhYmxlcyA9ICZwYXN5bmNfY3R4LT5hc3luY19kYXRhLndyaXRhYmxlczsKKwkJbnVtX2VudHJpZXMgPSBwYXN5bmNfY3R4LT5hc3luY19kYXRhLm51bV9lbnRyaWVzOworCX0KKworCXdoaWxlICgoKnBlcF9yZWFkX3B0cikgIT0gY3FfaW5kZXgpIHsKKwkJKCpwZXBfcmVhZF9wdHIpKys7CisJCSpwZXBfcmVhZF9wdHIgPSAoKnBlcF9yZWFkX3B0cikgJSBudW1fZW50cmllczsKKworCQlwYnVzeV9saXN0ID0gaHdpX2dldF9hc3luY19idXN5X2xpc3QocGFzeW5jX2N0eCwgaXNfaGVhZGVyLAorCQkJCQkJICAgICAqcGVwX3JlYWRfcHRyKTsKKwkJaWYgKHdyaXRhYmxlcyA9PSAwKQorCQkJV0FSTl9PTihsaXN0X2VtcHR5KHBidXN5X2xpc3QpKTsKKworCQlpZiAoIWxpc3RfZW1wdHkocGJ1c3lfbGlzdCkpIHsKKwkJCXBhc3luY19oYW5kbGUgPSBsaXN0X2VudHJ5KHBidXN5X2xpc3QtPm5leHQsCisJCQkJCQkgICBzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSwKKwkJCQkJCSAgIGxpbmspOworCQkJV0FSTl9PTighcGFzeW5jX2hhbmRsZSk7CisJCQlwYXN5bmNfaGFuZGxlLT5jb25zdW1lZCA9IDE7CisJCX0KKworCQl3cml0YWJsZXMrKzsKKwl9CisKKwlpZiAoIXdyaXRhYmxlcykgeworCQlTRV9ERUJVRyhEQkdfTFZMXzEsCisJCQkgIkR1cGxpY2F0ZSBub3RpZmljYXRpb24gcmVjZWl2ZWQgLSBpbmRleCAweCV4ISFcbiIsCisJCQkgY3FfaW5kZXgpOworCQlXQVJOX09OKDEpOworCX0KKworCSpwd3JpdGFibGVzID0gKnB3cml0YWJsZXMgKyB3cml0YWJsZXM7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBpbnQgaHdpX2ZyZWVfYXN5bmNfbXNnKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwKKwkJCQkgICAgICAgdW5zaWduZWQgaW50IGNyaSkKK3sKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9hc3luY19wZHVfY29udGV4dCAqcGFzeW5jX2N0eDsKKwlzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSAqcGFzeW5jX2hhbmRsZSwgKnRtcF9oYW5kbGU7CisJc3RydWN0IGxpc3RfaGVhZCAqcGxpc3Q7CisJdW5zaWduZWQgaW50IGkgPSAwOworCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcGFzeW5jX2N0eCA9IEhXSV9HRVRfQVNZTkNfUERVX0NUWChwaHdpX2N0cmxyKTsKKworCXBsaXN0ICA9ICZwYXN5bmNfY3R4LT5hc3luY19lbnRyeVtjcmldLndhaXRfcXVldWUubGlzdDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShwYXN5bmNfaGFuZGxlLCB0bXBfaGFuZGxlLCBwbGlzdCwgbGluaykgeworCQlsaXN0X2RlbCgmcGFzeW5jX2hhbmRsZS0+bGluayk7CisKKwkJaWYgKGkgPT0gMCkgeworCQkJbGlzdF9hZGRfdGFpbCgmcGFzeW5jX2hhbmRsZS0+bGluaywKKwkJCQkgICAgICAmcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLmZyZWVfbGlzdCk7CisJCQlwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuZnJlZV9lbnRyaWVzKys7CisJCQlpKys7CisJCX0gZWxzZSB7CisJCQlsaXN0X2FkZF90YWlsKCZwYXN5bmNfaGFuZGxlLT5saW5rLAorCQkJCSAgICAgICZwYXN5bmNfY3R4LT5hc3luY19kYXRhLmZyZWVfbGlzdCk7CisJCQlwYXN5bmNfY3R4LT5hc3luY19kYXRhLmZyZWVfZW50cmllcysrOworCQkJaSsrOworCQl9CisJfQorCisJSU5JVF9MSVNUX0hFQUQoJnBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2NyaV0ud2FpdF9xdWV1ZS5saXN0KTsKKwlwYXN5bmNfY3R4LT5hc3luY19lbnRyeVtjcmldLndhaXRfcXVldWUuaGRyX3JlY2VpdmVkID0gMDsKKwlwYXN5bmNfY3R4LT5hc3luY19lbnRyeVtjcmldLndhaXRfcXVldWUuYnl0ZXNfcmVjZWl2ZWQgPSAwOworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0IHBoeXNfYWRkciAqCitod2lfZ2V0X3JpbmdfYWRkcmVzcyhzdHJ1Y3QgaHdpX2FzeW5jX3BkdV9jb250ZXh0ICpwYXN5bmNfY3R4LAorCQkgICAgIHVuc2lnbmVkIGludCBpc19oZWFkZXIsIHVuc2lnbmVkIGludCBob3N0X3dyaXRlX3B0cikKK3sKKwlzdHJ1Y3QgcGh5c19hZGRyICpwYXN5bmNfc2dlID0gTlVMTDsKKworCWlmIChpc19oZWFkZXIpCisJCXBhc3luY19zZ2UgPSBwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIucmluZ19iYXNlOworCWVsc2UKKwkJcGFzeW5jX3NnZSA9IHBhc3luY19jdHgtPmFzeW5jX2RhdGEucmluZ19iYXNlOworCisJcmV0dXJuIHBhc3luY19zZ2UgKyBob3N0X3dyaXRlX3B0cjsKK30KKworc3RhdGljIHZvaWQgaHdpX3Bvc3RfYXN5bmNfYnVmZmVycyhzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkJICAgdW5zaWduZWQgaW50IGlzX2hlYWRlcikKK3sKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9hc3luY19wZHVfY29udGV4dCAqcGFzeW5jX2N0eDsKKwlzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSAqcGFzeW5jX2hhbmRsZTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICpwZnJlZV9saW5rLCAqcGJ1c3lfbGlzdDsKKwlzdHJ1Y3QgcGh5c19hZGRyICpwYXN5bmNfc2dlOworCXVuc2lnbmVkIGludCByaW5nX2lkLCBudW1fZW50cmllczsKKwl1bnNpZ25lZCBpbnQgaG9zdF93cml0ZV9udW07CisJdW5zaWduZWQgaW50IHdyaXRhYmxlczsKKwl1bnNpZ25lZCBpbnQgaSA9IDA7CisJdTMyIGRvb3JiZWxsID0gMDsKKworCXBod2lfY3RybHIgPSBwaGJhLT5waHdpX2N0cmxyOworCXBhc3luY19jdHggPSBIV0lfR0VUX0FTWU5DX1BEVV9DVFgocGh3aV9jdHJscik7CisKKwlpZiAoaXNfaGVhZGVyKSB7CisJCW51bV9lbnRyaWVzID0gcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLm51bV9lbnRyaWVzOworCQl3cml0YWJsZXMgPSBtaW4ocGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLndyaXRhYmxlcywKKwkJCQlwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuZnJlZV9lbnRyaWVzKTsKKwkJcGZyZWVfbGluayA9IHBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5mcmVlX2xpc3QubmV4dDsKKwkJaG9zdF93cml0ZV9udW0gPSBwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuaG9zdF93cml0ZV9wdHI7CisJCXJpbmdfaWQgPSBwaHdpX2N0cmxyLT5kZWZhdWx0X3BkdV9oZHIuaWQ7CisJfSBlbHNlIHsKKwkJbnVtX2VudHJpZXMgPSBwYXN5bmNfY3R4LT5hc3luY19kYXRhLm51bV9lbnRyaWVzOworCQl3cml0YWJsZXMgPSBtaW4ocGFzeW5jX2N0eC0+YXN5bmNfZGF0YS53cml0YWJsZXMsCisJCQkJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5mcmVlX2VudHJpZXMpOworCQlwZnJlZV9saW5rID0gcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5mcmVlX2xpc3QubmV4dDsKKwkJaG9zdF93cml0ZV9udW0gPSBwYXN5bmNfY3R4LT5hc3luY19kYXRhLmhvc3Rfd3JpdGVfcHRyOworCQlyaW5nX2lkID0gcGh3aV9jdHJsci0+ZGVmYXVsdF9wZHVfZGF0YS5pZDsKKwl9CisKKwl3cml0YWJsZXMgPSAod3JpdGFibGVzIC8gOCkgKiA4OworCWlmICh3cml0YWJsZXMpIHsKKwkJZm9yIChpID0gMDsgaSA8IHdyaXRhYmxlczsgaSsrKSB7CisJCQlwYnVzeV9saXN0ID0KKwkJCSAgICBod2lfZ2V0X2FzeW5jX2J1c3lfbGlzdChwYXN5bmNfY3R4LCBpc19oZWFkZXIsCisJCQkJCQkgICAgaG9zdF93cml0ZV9udW0pOworCQkJcGFzeW5jX2hhbmRsZSA9CisJCQkgICAgbGlzdF9lbnRyeShwZnJlZV9saW5rLCBzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSwKKwkJCQkJCQkJbGluayk7CisJCQlXQVJOX09OKCFwYXN5bmNfaGFuZGxlKTsKKwkJCXBhc3luY19oYW5kbGUtPmNvbnN1bWVkID0gMDsKKworCQkJcGZyZWVfbGluayA9IHBmcmVlX2xpbmstPm5leHQ7CisKKwkJCXBhc3luY19zZ2UgPSBod2lfZ2V0X3JpbmdfYWRkcmVzcyhwYXN5bmNfY3R4LAorCQkJCQkJaXNfaGVhZGVyLCBob3N0X3dyaXRlX251bSk7CisKKwkJCXBhc3luY19zZ2UtPmhpID0gcGFzeW5jX2hhbmRsZS0+cGEudS5hMzIuYWRkcmVzc19sbzsKKwkJCXBhc3luY19zZ2UtPmxvID0gcGFzeW5jX2hhbmRsZS0+cGEudS5hMzIuYWRkcmVzc19oaTsKKworCQkJbGlzdF9tb3ZlKCZwYXN5bmNfaGFuZGxlLT5saW5rLCBwYnVzeV9saXN0KTsKKworCQkJaG9zdF93cml0ZV9udW0rKzsKKwkJCWhvc3Rfd3JpdGVfbnVtID0gaG9zdF93cml0ZV9udW0gJSBudW1fZW50cmllczsKKwkJfQorCisJCWlmIChpc19oZWFkZXIpIHsKKwkJCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5ob3N0X3dyaXRlX3B0ciA9CisJCQkJCQkJaG9zdF93cml0ZV9udW07CisJCQlwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuZnJlZV9lbnRyaWVzIC09IHdyaXRhYmxlczsKKwkJCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci53cml0YWJsZXMgLT0gd3JpdGFibGVzOworCQkJcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLmJ1c3lfZW50cmllcyArPSB3cml0YWJsZXM7CisJCX0gZWxzZSB7CisJCQlwYXN5bmNfY3R4LT5hc3luY19kYXRhLmhvc3Rfd3JpdGVfcHRyID0gaG9zdF93cml0ZV9udW07CisJCQlwYXN5bmNfY3R4LT5hc3luY19kYXRhLmZyZWVfZW50cmllcyAtPSB3cml0YWJsZXM7CisJCQlwYXN5bmNfY3R4LT5hc3luY19kYXRhLndyaXRhYmxlcyAtPSB3cml0YWJsZXM7CisJCQlwYXN5bmNfY3R4LT5hc3luY19kYXRhLmJ1c3lfZW50cmllcyArPSB3cml0YWJsZXM7CisJCX0KKworCQlkb29yYmVsbCB8PSByaW5nX2lkICYgREJfREVGX1BEVV9SSU5HX0lEX01BU0s7CisJCWRvb3JiZWxsIHw9IDEgPDwgREJfREVGX1BEVV9SRUFSTV9TSElGVDsKKwkJZG9vcmJlbGwgfD0gMCA8PCBEQl9ERUZfUERVX0VWRU5UX1NISUZUOworCQlkb29yYmVsbCB8PSAod3JpdGFibGVzICYgREJfREVGX1BEVV9DUVBST0NfTUFTSykKKwkJCQkJPDwgREJfREVGX1BEVV9DUVBST0NfU0hJRlQ7CisKKwkJaW93cml0ZTMyKGRvb3JiZWxsLCBwaGJhLT5kYl92YSArIERCX1JYVUxQMF9PRkZTRVQpOworCX0KK30KKworc3RhdGljIHZvaWQgaHdpX2ZsdXNoX2RlZmF1bHRfcGR1X2J1ZmZlcihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkJCSBzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCQkJCSBzdHJ1Y3QgaV90X2RwZHVfY3FlICpwZHBkdV9jcWUpCit7CisJc3RydWN0IGh3aV9jb250cm9sbGVyICpwaHdpX2N0cmxyOworCXN0cnVjdCBod2lfYXN5bmNfcGR1X2NvbnRleHQgKnBhc3luY19jdHg7CisJc3RydWN0IGFzeW5jX3BkdV9oYW5kbGUgKnBhc3luY19oYW5kbGUgPSBOVUxMOworCXVuc2lnbmVkIGludCBjcV9pbmRleCA9IC0xOworCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcGFzeW5jX2N0eCA9IEhXSV9HRVRfQVNZTkNfUERVX0NUWChwaHdpX2N0cmxyKTsKKworCXBhc3luY19oYW5kbGUgPSBod2lfZ2V0X2FzeW5jX2hhbmRsZShwaGJhLCBiZWlzY3NpX2Nvbm4sIHBhc3luY19jdHgsCisJCQkJCSAgICAgcGRwZHVfY3FlLCAmY3FfaW5kZXgpOworCUJVR19PTihwYXN5bmNfaGFuZGxlLT5pc19oZWFkZXIgIT0gMCk7CisJaWYgKHBhc3luY19oYW5kbGUtPmNvbnN1bWVkID09IDApCisJCWh3aV91cGRhdGVfYXN5bmNfd3JpdGFibGVzKHBhc3luY19jdHgsIHBhc3luY19oYW5kbGUtPmlzX2hlYWRlciwKKwkJCQkJICAgY3FfaW5kZXgpOworCisJaHdpX2ZyZWVfYXN5bmNfbXNnKHBoYmEsIHBhc3luY19oYW5kbGUtPmNyaSk7CisJaHdpX3Bvc3RfYXN5bmNfYnVmZmVycyhwaGJhLCBwYXN5bmNfaGFuZGxlLT5pc19oZWFkZXIpOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50Citod2lfZndkX2FzeW5jX21zZyhzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4sCisJCSAgc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkgIHN0cnVjdCBod2lfYXN5bmNfcGR1X2NvbnRleHQgKnBhc3luY19jdHgsIHVuc2lnbmVkIHNob3J0IGNyaSkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpwbGlzdDsKKwlzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSAqcGFzeW5jX2hhbmRsZTsKKwl2b2lkICpwaGRyID0gTlVMTDsKKwl1bnNpZ25lZCBpbnQgaGRyX2xlbiA9IDAsIGJ1Zl9sZW4gPSAwOworCXVuc2lnbmVkIGludCBzdGF0dXMsIGluZGV4ID0gMCwgb2Zmc2V0ID0gMDsKKwl2b2lkICpwZmlyc3RfYnVmZmVyID0gTlVMTDsKKwl1bnNpZ25lZCBpbnQgbnVtX2J1ZiA9IDA7CisKKwlwbGlzdCA9ICZwYXN5bmNfY3R4LT5hc3luY19lbnRyeVtjcmldLndhaXRfcXVldWUubGlzdDsKKworCWxpc3RfZm9yX2VhY2hfZW50cnkocGFzeW5jX2hhbmRsZSwgcGxpc3QsIGxpbmspIHsKKwkJaWYgKGluZGV4ID09IDApIHsKKwkJCXBoZHIgPSBwYXN5bmNfaGFuZGxlLT5wYnVmZmVyOworCQkJaGRyX2xlbiA9IHBhc3luY19oYW5kbGUtPmJ1ZmZlcl9sZW47CisJCX0gZWxzZSB7CisJCQlidWZfbGVuID0gcGFzeW5jX2hhbmRsZS0+YnVmZmVyX2xlbjsKKwkJCWlmICghbnVtX2J1ZikgeworCQkJCXBmaXJzdF9idWZmZXIgPSBwYXN5bmNfaGFuZGxlLT5wYnVmZmVyOworCQkJCW51bV9idWYrKzsKKwkJCX0KKwkJCW1lbWNweShwZmlyc3RfYnVmZmVyICsgb2Zmc2V0LAorCQkJICAgICAgIHBhc3luY19oYW5kbGUtPnBidWZmZXIsIGJ1Zl9sZW4pOworCQkJb2Zmc2V0ID0gYnVmX2xlbjsKKwkJfQorCQlpbmRleCsrOworCX0KKworCXN0YXR1cyA9IGJlaXNjc2lfcHJvY2Vzc19hc3luY19wZHUoYmVpc2NzaV9jb25uLCBwaGJhLAorCQkJCQkgICBiZWlzY3NpX2Nvbm4tPmJlaXNjc2lfY29ubl9jaWQsCisJCQkJCSAgIHBoZHIsIGhkcl9sZW4sIHBmaXJzdF9idWZmZXIsCisJCQkJCSAgIGJ1Zl9sZW4pOworCisJaWYgKHN0YXR1cyA9PSAwKQorCQlod2lfZnJlZV9hc3luY19tc2cocGhiYSwgY3JpKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHVuc2lnbmVkIGludAoraHdpX2dhdGhlcl9hc3luY19wZHUoc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uLAorCQkgICAgIHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwKKwkJICAgICBzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSAqcGFzeW5jX2hhbmRsZSkKK3sKKwlzdHJ1Y3QgaHdpX2FzeW5jX3BkdV9jb250ZXh0ICpwYXN5bmNfY3R4OworCXN0cnVjdCBod2lfY29udHJvbGxlciAqcGh3aV9jdHJscjsKKwl1bnNpZ25lZCBpbnQgYnl0ZXNfbmVlZGVkID0gMCwgc3RhdHVzID0gMDsKKwl1bnNpZ25lZCBzaG9ydCBjcmkgPSBwYXN5bmNfaGFuZGxlLT5jcmk7CisJc3RydWN0IHBkdV9iYXNlICpwcGR1OworCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcGFzeW5jX2N0eCA9IEhXSV9HRVRfQVNZTkNfUERVX0NUWChwaHdpX2N0cmxyKTsKKworCWxpc3RfZGVsKCZwYXN5bmNfaGFuZGxlLT5saW5rKTsKKwlpZiAocGFzeW5jX2hhbmRsZS0+aXNfaGVhZGVyKSB7CisJCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5idXN5X2VudHJpZXMtLTsKKwkJaWYgKHBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2NyaV0ud2FpdF9xdWV1ZS5oZHJfcmVjZWl2ZWQpIHsKKwkJCWh3aV9mcmVlX2FzeW5jX21zZyhwaGJhLCBjcmkpOworCQkJQlVHKCk7CisJCX0KKworCQlwYXN5bmNfY3R4LT5hc3luY19lbnRyeVtjcmldLndhaXRfcXVldWUuYnl0ZXNfcmVjZWl2ZWQgPSAwOworCQlwYXN5bmNfY3R4LT5hc3luY19lbnRyeVtjcmldLndhaXRfcXVldWUuaGRyX3JlY2VpdmVkID0gMTsKKwkJcGFzeW5jX2N0eC0+YXN5bmNfZW50cnlbY3JpXS53YWl0X3F1ZXVlLmhkcl9sZW4gPQorCQkJCSh1bnNpZ25lZCBzaG9ydClwYXN5bmNfaGFuZGxlLT5idWZmZXJfbGVuOworCQlsaXN0X2FkZF90YWlsKCZwYXN5bmNfaGFuZGxlLT5saW5rLAorCQkJICAgICAgJnBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2NyaV0ud2FpdF9xdWV1ZS5saXN0KTsKKworCQlwcGR1ID0gcGFzeW5jX2hhbmRsZS0+cGJ1ZmZlcjsKKwkJYnl0ZXNfbmVlZGVkID0gKCgoKHBwZHUtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3BkdV9iYXNlLAorCQkJZGF0YV9sZW5faGkpIC8gMzJdICYgUERVQkFTRV9EQVRBTEVOSElfTUFTSykgPDwgOCkgJgorCQkJMHhGRkZGMDAwMCkgfCAoKGJlMTZfdG9fY3B1KChwcGR1LT4KKwkJCWR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3BkdV9iYXNlLCBkYXRhX2xlbl9sbykgLyAzMl0KKwkJCSYgUERVQkFTRV9EQVRBTEVOTE9fTUFTSykgPj4gMTYpKSAmIDB4MDAwMEZGRkYpKTsKKworCQlpZiAoc3RhdHVzID09IDApIHsKKwkJCXBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2NyaV0ud2FpdF9xdWV1ZS5ieXRlc19uZWVkZWQgPQorCQkJICAgIGJ5dGVzX25lZWRlZDsKKworCQkJaWYgKGJ5dGVzX25lZWRlZCA9PSAwKQorCQkJCXN0YXR1cyA9IGh3aV9md2RfYXN5bmNfbXNnKGJlaXNjc2lfY29ubiwgcGhiYSwKKwkJCQkJCQkgICBwYXN5bmNfY3R4LCBjcmkpOworCQl9CisJfSBlbHNlIHsKKwkJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5idXN5X2VudHJpZXMtLTsKKwkJaWYgKHBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2NyaV0ud2FpdF9xdWV1ZS5oZHJfcmVjZWl2ZWQpIHsKKwkJCWxpc3RfYWRkX3RhaWwoJnBhc3luY19oYW5kbGUtPmxpbmssCisJCQkJICAgICAgJnBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2NyaV0ud2FpdF9xdWV1ZS4KKwkJCQkgICAgICBsaXN0KTsKKwkJCXBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2NyaV0ud2FpdF9xdWV1ZS4KKwkJCQlieXRlc19yZWNlaXZlZCArPQorCQkJCSh1bnNpZ25lZCBzaG9ydClwYXN5bmNfaGFuZGxlLT5idWZmZXJfbGVuOworCisJCQlpZiAocGFzeW5jX2N0eC0+YXN5bmNfZW50cnlbY3JpXS53YWl0X3F1ZXVlLgorCQkJICAgIGJ5dGVzX3JlY2VpdmVkID49CisJCQkgICAgcGFzeW5jX2N0eC0+YXN5bmNfZW50cnlbY3JpXS53YWl0X3F1ZXVlLgorCQkJICAgIGJ5dGVzX25lZWRlZCkKKwkJCQlzdGF0dXMgPSBod2lfZndkX2FzeW5jX21zZyhiZWlzY3NpX2Nvbm4sIHBoYmEsCisJCQkJCQkJICAgcGFzeW5jX2N0eCwgY3JpKTsKKwkJfQorCX0KKwlyZXR1cm4gc3RhdHVzOworfQorCitzdGF0aWMgdm9pZCBod2lfcHJvY2Vzc19kZWZhdWx0X3BkdV9yaW5nKHN0cnVjdCBiZWlzY3NpX2Nvbm4gKmJlaXNjc2lfY29ubiwKKwkJCQkJIHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwKKwkJCQkJIHN0cnVjdCBpX3RfZHBkdV9jcWUgKnBkcGR1X2NxZSkKK3sKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9hc3luY19wZHVfY29udGV4dCAqcGFzeW5jX2N0eDsKKwlzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSAqcGFzeW5jX2hhbmRsZSA9IE5VTEw7CisJdW5zaWduZWQgaW50IGNxX2luZGV4ID0gLTE7CisKKwlwaHdpX2N0cmxyID0gcGhiYS0+cGh3aV9jdHJscjsKKwlwYXN5bmNfY3R4ID0gSFdJX0dFVF9BU1lOQ19QRFVfQ1RYKHBod2lfY3RybHIpOworCXBhc3luY19oYW5kbGUgPSBod2lfZ2V0X2FzeW5jX2hhbmRsZShwaGJhLCBiZWlzY3NpX2Nvbm4sIHBhc3luY19jdHgsCisJCQkJCSAgICAgcGRwZHVfY3FlLCAmY3FfaW5kZXgpOworCisJaWYgKHBhc3luY19oYW5kbGUtPmNvbnN1bWVkID09IDApCisJCWh3aV91cGRhdGVfYXN5bmNfd3JpdGFibGVzKHBhc3luY19jdHgsIHBhc3luY19oYW5kbGUtPmlzX2hlYWRlciwKKwkJCQkJICAgY3FfaW5kZXgpOworCWh3aV9nYXRoZXJfYXN5bmNfcGR1KGJlaXNjc2lfY29ubiwgcGhiYSwgcGFzeW5jX2hhbmRsZSk7CisJaHdpX3Bvc3RfYXN5bmNfYnVmZmVycyhwaGJhLCBwYXN5bmNfaGFuZGxlLT5pc19oZWFkZXIpOworfQorCitzdGF0aWMgdW5zaWduZWQgaW50IGJlaXNjc2lfcHJvY2Vzc19jcShzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEpCit7CisJc3RydWN0IGh3aV9jb250cm9sbGVyICpwaHdpX2N0cmxyOworCXN0cnVjdCBod2lfY29udGV4dF9tZW1vcnkgKnBod2lfY29udGV4dDsKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyAqY3E7CisJc3RydWN0IHNvbF9jcWUgKnNvbDsKKwlzdHJ1Y3QgZG1zZ19jcWUgKmRtc2c7CisJdW5zaWduZWQgaW50IG51bV9wcm9jZXNzZWQgPSAwOworCXVuc2lnbmVkIGludCB0b3RfbnVtcCA9IDA7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uOworCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcGh3aV9jb250ZXh0ID0gcGh3aV9jdHJsci0+cGh3aV9jdHh0OworCWNxID0gJnBod2lfY29udGV4dC0+YmVfY3E7CisJc29sID0gcXVldWVfdGFpbF9ub2RlKGNxKTsKKworCXdoaWxlIChzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIHZhbGlkKSAvIDMyXSAmCisJICAgICAgIENRRV9WQUxJRF9NQVNLKSB7CisJCWJlX2R3c19sZV90b19jcHUoc29sLCBzaXplb2Yoc3RydWN0IHNvbF9jcWUpKTsKKworCQliZWlzY3NpX2Nvbm4gPSBwaGJhLT5jb25uX3RhYmxlWyh1MzIpIChzb2wtPgorCQkJCSBkd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBjaWQpIC8gMzJdICYKKwkJCQkgU09MX0NJRF9NQVNLKSA+PiA2XTsKKworCQlpZiAoIWJlaXNjc2lfY29ubiB8fCAhYmVpc2NzaV9jb25uLT5lcCkgeworCQkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkJICAgICAiQ29ubmVjdGlvbiB0YWJsZSBlbXB0eSBmb3IgY2lkID0gJWRcbiIsCisJCQkJICAgICAodTMyKShzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsCisJCQkJICAgICBjaWQpIC8gMzJdICYgU09MX0NJRF9NQVNLKSA+PiA2KTsKKwkJCXJldHVybiAwOworCQl9CisKKwkJaWYgKG51bV9wcm9jZXNzZWQgPj0gMzIpIHsKKwkJCWh3aV9yaW5nX2NxX2RiKHBoYmEsIHBod2lfY29udGV4dC0+YmVfY3EuaWQsCisJCQkJCW51bV9wcm9jZXNzZWQsIDAsIDApOworCQkJdG90X251bXAgKz0gbnVtX3Byb2Nlc3NlZDsKKwkJCW51bV9wcm9jZXNzZWQgPSAwOworCQl9CisKKwkJc3dpdGNoICgodTMyKSBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGNvZGUpIC8KKwkJCTMyXSAmIENRRV9DT0RFX01BU0spIHsKKwkJY2FzZSBTT0xfQ01EX0NPTVBMRVRFOgorCQkJaHdpX2NvbXBsZXRlX2NtZChiZWlzY3NpX2Nvbm4sIHBoYmEsIHNvbCk7CisJCQlicmVhazsKKwkJY2FzZSBEUklWRVJNU0dfTk9USUZZOgorCQkJU0VfREVCVUcoREJHX0xWTF84LCAiUmVjZWl2ZWQgRFJJVkVSTVNHX05PVElGWSBcbiIpOworCQkJZG1zZyA9IChzdHJ1Y3QgZG1zZ19jcWUgKilzb2w7CisJCQlod2lfY29tcGxldGVfZHJ2cl9tc2dzKGJlaXNjc2lfY29ubiwgcGhiYSwgc29sKTsKKwkJCWJyZWFrOworCQljYXNlIFVOU09MX0hEUl9OT1RJRlk6CisJCWNhc2UgVU5TT0xfREFUQV9OT1RJRlk6CisJCQlTRV9ERUJVRyhEQkdfTFZMXzgsICJSZWNlaXZlZCBVTlNPTF9IRFIvREFUQV9OT1RJRllcbiIpOworCQkJaHdpX3Byb2Nlc3NfZGVmYXVsdF9wZHVfcmluZyhiZWlzY3NpX2Nvbm4sIHBoYmEsCisJCQkJCSAgICAgKHN0cnVjdCBpX3RfZHBkdV9jcWUgKilzb2wpOworCQkJYnJlYWs7CisJCWNhc2UgQ1hOX0lOVkFMSURBVEVfSU5ERVhfTk9USUZZOgorCQljYXNlIENNRF9JTlZBTElEQVRFRF9OT1RJRlk6CisJCWNhc2UgQ1hOX0lOVkFMSURBVEVfTk9USUZZOgorCQkJU0VfREVCVUcoREJHX0xWTF8xLAorCQkJCSAiSWdub3JpbmcgQ1EgRXJyb3Igbm90aWZpY2F0aW9uIGZvciBjbWQvY3huIgorCQkJCSAiaW52YWxpZGF0ZVxuIik7CisJCQlicmVhazsKKwkJY2FzZSBTT0xfQ01EX0tJTExFRF9EQVRBX0RJR0VTVF9FUlI6CisJCWNhc2UgQ01EX0tJTExFRF9JTlZBTElEX1NUQVRTTl9SQ1ZEOgorCQljYXNlIENNRF9LSUxMRURfSU5WQUxJRF9SMlRfUkNWRDoKKwkJY2FzZSBDTURfQ1hOX0tJTExFRF9MVU5fSU5WQUxJRDoKKwkJY2FzZSBDTURfQ1hOX0tJTExFRF9JQ0RfSU5WQUxJRDoKKwkJY2FzZSBDTURfQ1hOX0tJTExFRF9JVFRfSU5WQUxJRDoKKwkJY2FzZSBDTURfQ1hOX0tJTExFRF9TRVFfT1VUT0ZPUkRFUjoKKwkJY2FzZSBDTURfQ1hOX0tJTExFRF9JTlZBTElEX0RBVEFTTl9SQ1ZEOgorCQkJU0VfREVCVUcoREJHX0xWTF8xLAorCQkJCSAiQ1EgRXJyb3Igbm90aWZpY2F0aW9uIGZvciBjbWQuLiAiCisJCQkJICJjb2RlICVkIGNpZCAweCV4XG4iLAorCQkJCSBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGNvZGUpIC8KKwkJCQkgMzJdICYgQ1FFX0NPREVfTUFTSywKKwkJCQkgKHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgY2lkKSAvCisJCQkJIDMyXSAmIFNPTF9DSURfTUFTSykpOworCQkJYnJlYWs7CisJCWNhc2UgVU5TT0xfREFUQV9ESUdFU1RfRVJST1JfTk9USUZZOgorCQkJU0VfREVCVUcoREJHX0xWTF8xLAorCQkJCSAiRGlnZXN0IGVycm9yIG9uIGRlZiBwZHUgcmluZywgZHJvcHBpbmcuLlxuIik7CisJCQlod2lfZmx1c2hfZGVmYXVsdF9wZHVfYnVmZmVyKHBoYmEsIGJlaXNjc2lfY29ubiwKKwkJCQkJICAgICAoc3RydWN0IGlfdF9kcGR1X2NxZSAqKSBzb2wpOworCQkJYnJlYWs7CisJCWNhc2UgQ1hOX0tJTExFRF9QRFVfU0laRV9FWENFRURTX0RTTDoKKwkJY2FzZSBDWE5fS0lMTEVEX0JVUlNUX0xFTl9NSVNNQVRDSDoKKwkJY2FzZSBDWE5fS0lMTEVEX0FIU19SQ1ZEOgorCQljYXNlIENYTl9LSUxMRURfSERSX0RJR0VTVF9FUlI6CisJCWNhc2UgQ1hOX0tJTExFRF9VTktOT1dOX0hEUjoKKwkJY2FzZSBDWE5fS0lMTEVEX1NUQUxFX0lUVF9UVFRfUkNWRDoKKwkJY2FzZSBDWE5fS0lMTEVEX0lOVkFMSURfSVRUX1RUVF9SQ1ZEOgorCQljYXNlIENYTl9LSUxMRURfVElNRURfT1VUOgorCQljYXNlIENYTl9LSUxMRURfRklOX1JDVkQ6CisJCWNhc2UgQ1hOX0tJTExFRF9CQURfVU5TT0xfUERVX1JDVkQ6CisJCWNhc2UgQ1hOX0tJTExFRF9CQURfV1JCX0lOREVYX0VSUk9SOgorCQljYXNlIENYTl9LSUxMRURfT1ZFUl9SVU5fUkVTSURVQUw6CisJCWNhc2UgQ1hOX0tJTExFRF9VTkRFUl9SVU5fUkVTSURVQUw6CisJCWNhc2UgQ1hOX0tJTExFRF9DTU5EX0RBVEFfTk9UX09OX1NBTUVfQ09OTjoKKwkJCVNFX0RFQlVHKERCR19MVkxfMSwgIkNRIEVycm9yICVkLCByZXNldHRpbmcgQ0lEICIKKwkJCQkgIjB4JXguLi5cbiIsCisJCQkJIHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgY29kZSkgLworCQkJCSAzMl0gJiBDUUVfQ09ERV9NQVNLLAorCQkJCSBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGNpZCkgLworCQkJCSAzMl0gJiBDUUVfQ0lEX01BU0spOworCQkJaXNjc2lfY29ubl9mYWlsdXJlKGJlaXNjc2lfY29ubi0+Y29ubiwKKwkJCQkJICAgSVNDU0lfRVJSX0NPTk5fRkFJTEVEKTsKKwkJCWJyZWFrOworCQljYXNlIENYTl9LSUxMRURfUlNUX1NFTlQ6CisJCWNhc2UgQ1hOX0tJTExFRF9SU1RfUkNWRDoKKwkJCVNFX0RFQlVHKERCR19MVkxfMSwgIkNRIEVycm9yICVkLCByZXNldCByZWNlaXZlZC9zZW50ICIKKwkJCQkgIm9uIENJRCAweCV4Li4uXG4iLAorCQkJCSBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGNvZGUpIC8KKwkJCQkgMzJdICYgQ1FFX0NPREVfTUFTSywKKwkJCQkgc29sLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9zb2xfY3FlLCBjaWQpIC8KKwkJCQkgMzJdICYgQ1FFX0NJRF9NQVNLKTsKKwkJCWlzY3NpX2Nvbm5fZmFpbHVyZShiZWlzY3NpX2Nvbm4tPmNvbm4sCisJCQkJCSAgIElTQ1NJX0VSUl9DT05OX0ZBSUxFRCk7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCVNFX0RFQlVHKERCR19MVkxfMSwgIkNRIEVycm9yIEludmFsaWQgY29kZT0gJWQgIgorCQkJCSAicmVjZWl2ZWQgb24gQ0lEIDB4JXguLi5cbiIsCisJCQkJIHNvbC0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfc29sX2NxZSwgY29kZSkgLworCQkJCSAzMl0gJiBDUUVfQ09ERV9NQVNLLAorCQkJCSBzb2wtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX3NvbF9jcWUsIGNpZCkgLworCQkJCSAzMl0gJiBDUUVfQ0lEX01BU0spOworCQkJYnJlYWs7CisJCX0KKworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX3NvbF9jcWUsIHZhbGlkLCBzb2wsIDApOworCQlxdWV1ZV90YWlsX2luYyhjcSk7CisJCXNvbCA9IHF1ZXVlX3RhaWxfbm9kZShjcSk7CisJCW51bV9wcm9jZXNzZWQrKzsKKwl9CisKKwlpZiAobnVtX3Byb2Nlc3NlZCA+IDApIHsKKwkJdG90X251bXAgKz0gbnVtX3Byb2Nlc3NlZDsKKwkJaHdpX3JpbmdfY3FfZGIocGhiYSwgcGh3aV9jb250ZXh0LT5iZV9jcS5pZCwgbnVtX3Byb2Nlc3NlZCwKKwkJCSAgICAgICAxLCAwKTsKKwl9CisJcmV0dXJuIHRvdF9udW1wOworfQorCitzdGF0aWMgdm9pZCBiZWlzY3NpX3Byb2Nlc3NfYWxsX2NxcyhzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCit7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEgPQorCSAgICBjb250YWluZXJfb2Yod29yaywgc3RydWN0IGJlaXNjc2lfaGJhLCB3b3JrX2Nxcyk7CisKKwlpZiAocGhiYS0+dG9kb19tY2NfY3EpIHsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJnBoYmEtPmlzcl9sb2NrLCBmbGFncyk7CisJCXBoYmEtPnRvZG9fbWNjX2NxID0gMDsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGhiYS0+aXNyX2xvY2ssIGZsYWdzKTsKKwkJU0VfREVCVUcoREJHX0xWTF8xLCAiTUNDIEludGVycnVwdCBOb3QgZXhwZWN0ZWQgXG4iKTsKKwl9CisKKwlpZiAocGhiYS0+dG9kb19jcSkgeworCQlzcGluX2xvY2tfaXJxc2F2ZSgmcGhiYS0+aXNyX2xvY2ssIGZsYWdzKTsKKwkJcGhiYS0+dG9kb19jcSA9IDA7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBoYmEtPmlzcl9sb2NrLCBmbGFncyk7CisJCWJlaXNjc2lfcHJvY2Vzc19jcShwaGJhKTsKKwl9Cit9CisKK3N0YXRpYyBpbnQgYmVfaW9wb2xsKHN0cnVjdCBibGtfaW9wb2xsICppb3AsIGludCBidWRnZXQpCit7CisJc3RhdGljIHVuc2lnbmVkIGludCByZXQ7CisJc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhOworCisJcGhiYSA9IGNvbnRhaW5lcl9vZihpb3AsIHN0cnVjdCBiZWlzY3NpX2hiYSwgaW9wb2xsKTsKKworCXJldCA9IGJlaXNjc2lfcHJvY2Vzc19jcShwaGJhKTsKKwlpZiAocmV0IDwgYnVkZ2V0KSB7CisJCXN0cnVjdCBod2lfY29udHJvbGxlciAqcGh3aV9jdHJscjsKKwkJc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0OworCisJCXBod2lfY3RybHIgPSBwaGJhLT5waHdpX2N0cmxyOworCQlwaHdpX2NvbnRleHQgPSBwaHdpX2N0cmxyLT5waHdpX2N0eHQ7CisJCWJsa19pb3BvbGxfY29tcGxldGUoaW9wKTsKKwkJaHdpX3JpbmdfZXFfZGIocGhiYSwgcGh3aV9jb250ZXh0LT5iZV9lcS5xLmlkLCAwLAorCQkJCQkJCTAsIDEsIDEpOworCX0KKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgdm9pZAoraHdpX3dyaXRlX3NnbChzdHJ1Y3QgaXNjc2lfd3JiICpwd3JiLCBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnLAorCSAgICAgIHVuc2lnbmVkIGludCBudW1fc2csIHN0cnVjdCBiZWlzY3NpX2lvX3Rhc2sgKmlvX3Rhc2spCit7CisJc3RydWN0IGlzY3NpX3NnZSAqcHNnbDsKKwl1bnNpZ25lZCBzaG9ydCBzZ19sZW4sIGluZGV4OworCXVuc2lnbmVkIGludCBzZ2VfbGVuID0gMDsKKwl1bnNpZ25lZCBsb25nIGxvbmcgYWRkcjsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKmxfc2c7CisJdW5zaWduZWQgaW50IG9mZnNldDsKKworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBpc2NzaV9iaHNfYWRkcl9sbywgcHdyYiwKKwkJCQkgICAgICBpb190YXNrLT5iaHNfcGEudS5hMzIuYWRkcmVzc19sbyk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIGlzY3NpX2Joc19hZGRyX2hpLCBwd3JiLAorCQkJCSAgICAgIGlvX3Rhc2stPmJoc19wYS51LmEzMi5hZGRyZXNzX2hpKTsKKworCWxfc2cgPSBzZzsKKwlmb3IgKGluZGV4ID0gMDsgKGluZGV4IDwgbnVtX3NnKSAmJiAoaW5kZXggPCAyKTsgaW5kZXgrKywgc2dfbmV4dChzZykpIHsKKwkJaWYgKGluZGV4ID09IDApIHsKKwkJCXNnX2xlbiA9IHNnX2RtYV9sZW4oc2cpOworCQkJYWRkciA9ICh1NjQpIHNnX2RtYV9hZGRyZXNzKHNnKTsKKwkJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBzZ2UwX2FkZHJfbG8sIHB3cmIsCisJCQkJCQkJKGFkZHIgJiAweEZGRkZGRkZGKSk7CisJCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgc2dlMF9hZGRyX2hpLCBwd3JiLAorCQkJCQkJCShhZGRyID4+IDMyKSk7CisJCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgc2dlMF9sZW4sIHB3cmIsCisJCQkJCQkJc2dfbGVuKTsKKwkJCXNnZV9sZW4gPSBzZ19sZW47CisJCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgc2dlMF9sYXN0LCBwd3JiLAorCQkJCQkJCTEpOworCQl9IGVsc2UgeworCQkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHNnZTBfbGFzdCwgcHdyYiwKKwkJCQkJCQkwKTsKKwkJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBzZ2UxX3IydF9vZmZzZXQsCisJCQkJCQkJcHdyYiwgc2dlX2xlbik7CisJCQlzZ19sZW4gPSBzZ19kbWFfbGVuKHNnKTsKKwkJCWFkZHIgPSAodTY0KSBzZ19kbWFfYWRkcmVzcyhzZyk7CisJCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgc2dlMV9hZGRyX2xvLCBwd3JiLAorCQkJCQkJCShhZGRyICYgMHhGRkZGRkZGRikpOworCQkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHNnZTFfYWRkcl9oaSwgcHdyYiwKKwkJCQkJCQkoYWRkciA+PiAzMikpOworCQkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHNnZTFfbGVuLCBwd3JiLAorCQkJCQkJCXNnX2xlbik7CisJCX0KKwl9CisJcHNnbCA9IChzdHJ1Y3QgaXNjc2lfc2dlICopaW9fdGFzay0+cHNnbF9oYW5kbGUtPnBmcmFnOworCW1lbXNldChwc2dsLCAwLCBzaXplb2YoKnBzZ2wpICogQkUyX1NHRSk7CisKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgbGVuLCBwc2dsLCBpb190YXNrLT5iaHNfbGVuIC0gMik7CisKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgYWRkcl9oaSwgcHNnbCwKKwkJCWlvX3Rhc2stPmJoc19wYS51LmEzMi5hZGRyZXNzX2hpKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgYWRkcl9sbywgcHNnbCwKKwkJCWlvX3Rhc2stPmJoc19wYS51LmEzMi5hZGRyZXNzX2xvKTsKKworCWlmIChudW1fc2cgPT0gMikKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHNnZTFfbGFzdCwgcHdyYiwgMSk7CisJc2cgPSBsX3NnOworCXBzZ2wrKzsKKwlwc2dsKys7CisJb2Zmc2V0ID0gMDsKKwlmb3IgKGluZGV4ID0gMDsgaW5kZXggPCBudW1fc2c7IGluZGV4KyssIHNnX25leHQoc2cpLCBwc2dsKyspIHsKKwkJc2dfbGVuID0gc2dfZG1hX2xlbihzZyk7CisJCWFkZHIgPSAodTY0KSBzZ19kbWFfYWRkcmVzcyhzZyk7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfc2dlLCBhZGRyX2xvLCBwc2dsLAorCQkJCQkJKGFkZHIgJiAweEZGRkZGRkZGKSk7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfc2dlLCBhZGRyX2hpLCBwc2dsLAorCQkJCQkJKGFkZHIgPj4gMzIpKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV9zZ2UsIGxlbiwgcHNnbCwgc2dfbGVuKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV9zZ2UsIHNnZV9vZmZzZXQsIHBzZ2wsIG9mZnNldCk7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfc2dlLCBsYXN0X3NnZSwgcHNnbCwgMCk7CisJCW9mZnNldCArPSBzZ19sZW47CisJfQorCXBzZ2wtLTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgbGFzdF9zZ2UsIHBzZ2wsIDEpOworfQorCitzdGF0aWMgdm9pZCBod2lfd3JpdGVfYnVmZmVyKHN0cnVjdCBpc2NzaV93cmIgKnB3cmIsIHN0cnVjdCBpc2NzaV90YXNrICp0YXNrKQoreworCXN0cnVjdCBpc2NzaV9zZ2UgKnBzZ2w7CisJdW5zaWduZWQgbG9uZyBsb25nIGFkZHI7CisJc3RydWN0IGJlaXNjc2lfaW9fdGFzayAqaW9fdGFzayA9IHRhc2stPmRkX2RhdGE7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uID0gaW9fdGFzay0+Y29ubjsKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEgPSBiZWlzY3NpX2Nvbm4tPnBoYmE7CisKKwlpb190YXNrLT5iaHNfbGVuID0gc2l6ZW9mKHN0cnVjdCBiZV9ub25pb19iaHMpIC0gMjsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgaXNjc2lfYmhzX2FkZHJfbG8sIHB3cmIsCisJCQkJaW9fdGFzay0+YmhzX3BhLnUuYTMyLmFkZHJlc3NfbG8pOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBpc2NzaV9iaHNfYWRkcl9oaSwgcHdyYiwKKwkJCQlpb190YXNrLT5iaHNfcGEudS5hMzIuYWRkcmVzc19oaSk7CisKKwlpZiAodGFzay0+ZGF0YSkgeworCQlpZiAodGFzay0+ZGF0YV9jb3VudCkgeworCQkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIGRzcCwgcHdyYiwgMSk7CisJCQlhZGRyID0gKHU2NCkgcGNpX21hcF9zaW5nbGUocGhiYS0+cGNpZGV2LAorCQkJCQkJICAgIHRhc2stPmRhdGEsCisJCQkJCQkgICAgdGFzay0+ZGF0YV9jb3VudCwgMSk7CisJCX0gZWxzZSB7CisJCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgZHNwLCBwd3JiLCAwKTsKKwkJCWFkZHIgPSAwOworCQl9CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBzZ2UwX2FkZHJfbG8sIHB3cmIsCisJCQkJCQkoYWRkciAmIDB4RkZGRkZGRkYpKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHNnZTBfYWRkcl9oaSwgcHdyYiwKKwkJCQkJCShhZGRyID4+IDMyKSk7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBzZ2UwX2xlbiwgcHdyYiwKKwkJCQkJCXRhc2stPmRhdGFfY291bnQpOworCisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBzZ2UwX2xhc3QsIHB3cmIsIDEpOworCX0gZWxzZSB7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBkc3AsIHB3cmIsIDApOworCQlhZGRyID0gMDsKKwl9CisKKwlwc2dsID0gKHN0cnVjdCBpc2NzaV9zZ2UgKilpb190YXNrLT5wc2dsX2hhbmRsZS0+cGZyYWc7CisKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgbGVuLCBwc2dsLCBpb190YXNrLT5iaHNfbGVuKTsKKworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfc2dlLCBhZGRyX2hpLCBwc2dsLAorCQkgICAgICBpb190YXNrLT5iaHNfcGEudS5hMzIuYWRkcmVzc19oaSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV9zZ2UsIGFkZHJfbG8sIHBzZ2wsCisJCSAgICAgIGlvX3Rhc2stPmJoc19wYS51LmEzMi5hZGRyZXNzX2xvKTsKKwlpZiAodGFzay0+ZGF0YSkgeworCQlwc2dsKys7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfc2dlLCBhZGRyX2hpLCBwc2dsLCAwKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV9zZ2UsIGFkZHJfbG8sIHBzZ2wsIDApOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgbGVuLCBwc2dsLCAwKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV9zZ2UsIHNnZV9vZmZzZXQsIHBzZ2wsIDApOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgcnN2ZDAsIHBzZ2wsIDApOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgbGFzdF9zZ2UsIHBzZ2wsIDApOworCisJCXBzZ2wrKzsKKwkJaWYgKHRhc2stPmRhdGEpIHsKKwkJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfc2dlLCBhZGRyX2xvLCBwc2dsLAorCQkJCQkJKGFkZHIgJiAweEZGRkZGRkZGKSk7CisJCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgYWRkcl9oaSwgcHNnbCwKKwkJCQkJCShhZGRyID4+IDMyKSk7CisJCX0KKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV9zZ2UsIGxlbiwgcHNnbCwgMHgxMDYpOworCX0KKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgbGFzdF9zZ2UsIHBzZ2wsIDEpOworfQorCitzdGF0aWMgdm9pZCBiZWlzY3NpX2ZpbmRfbWVtX3JlcShzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEpCit7CisJdW5zaWduZWQgaW50IG51bV9jcV9wYWdlcywgbnVtX2VxX3BhZ2VzLCBudW1fYXN5bmNfcGR1X2J1Zl9wYWdlczsKKwl1bnNpZ25lZCBpbnQgbnVtX2FzeW5jX3BkdV9kYXRhX3BhZ2VzLCB3cmJfc3pfcGVyX2N4bjsKKwl1bnNpZ25lZCBpbnQgbnVtX2FzeW5jX3BkdV9idWZfc2dsX3BhZ2VzLCBudW1fYXN5bmNfcGR1X2RhdGFfc2dsX3BhZ2VzOworCisJbnVtX2NxX3BhZ2VzID0gUEFHRVNfUkVRVUlSRUQocGhiYS0+cGFyYW1zLm51bV9jcV9lbnRyaWVzICogXAorCQkJCSAgICAgIHNpemVvZihzdHJ1Y3Qgc29sX2NxZSkpOworCW51bV9lcV9wYWdlcyA9IFBBR0VTX1JFUVVJUkVEKHBoYmEtPnBhcmFtcy5udW1fZXFfZW50cmllcyAqIFwKKwkJCQkgICAgICBzaXplb2Yoc3RydWN0IGJlX2VxX2VudHJ5KSk7CisJbnVtX2FzeW5jX3BkdV9idWZfcGFnZXMgPQorCQkJUEFHRVNfUkVRVUlSRUQocGhiYS0+cGFyYW1zLmFzeW5jcGR1c19wZXJfY3RybCAqIFwKKwkJCQkgICAgICAgcGhiYS0+cGFyYW1zLmRlZnBkdV9oZHJfc3opOworCW51bV9hc3luY19wZHVfYnVmX3NnbF9wYWdlcyA9CisJCQlQQUdFU19SRVFVSVJFRChwaGJhLT5wYXJhbXMuYXN5bmNwZHVzX3Blcl9jdHJsICogXAorCQkJCSAgICAgICBzaXplb2Yoc3RydWN0IHBoeXNfYWRkcikpOworCW51bV9hc3luY19wZHVfZGF0YV9wYWdlcyA9CisJCQlQQUdFU19SRVFVSVJFRChwaGJhLT5wYXJhbXMuYXN5bmNwZHVzX3Blcl9jdHJsICogXAorCQkJCSAgICAgICBwaGJhLT5wYXJhbXMuZGVmcGR1X2RhdGFfc3opOworCW51bV9hc3luY19wZHVfZGF0YV9zZ2xfcGFnZXMgPQorCQkJUEFHRVNfUkVRVUlSRUQocGhiYS0+cGFyYW1zLmFzeW5jcGR1c19wZXJfY3RybCAqIFwKKwkJCQkgICAgICAgc2l6ZW9mKHN0cnVjdCBwaHlzX2FkZHIpKTsKKworCXBoYmEtPnBhcmFtcy5od2lfd3Nfc3ogPSBzaXplb2Yoc3RydWN0IGh3aV9jb250cm9sbGVyKTsKKworCXBoYmEtPm1lbV9yZXFbSVNDU0lfTUVNX0dMT0JBTF9IRUFERVJdID0gMiAqCisJCQkJCQkgQkVfSVNDU0lfUERVX0hFQURFUl9TSVpFOworCXBoYmEtPm1lbV9yZXFbSFdJX01FTV9BREROX0NPTlRFWFRdID0KKwkJCQkJICAgIHNpemVvZihzdHJ1Y3QgaHdpX2NvbnRleHRfbWVtb3J5KTsKKworCXBoYmEtPm1lbV9yZXFbSFdJX01FTV9DUV0gPSBudW1fY3FfcGFnZXMgKiBQQUdFX1NJWkU7CisJcGhiYS0+bWVtX3JlcVtIV0lfTUVNX0VRXSA9IG51bV9lcV9wYWdlcyAqIFBBR0VfU0laRTsKKworCXBoYmEtPm1lbV9yZXFbSFdJX01FTV9XUkJdID0gc2l6ZW9mKHN0cnVjdCBpc2NzaV93cmIpCisJICAgICogKHBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4pCisJICAgICogcGhiYS0+cGFyYW1zLmN4bnNfcGVyX2N0cmw7CisJd3JiX3N6X3Blcl9jeG4gPSAgc2l6ZW9mKHN0cnVjdCB3cmJfaGFuZGxlKSAqCisJCQkJIChwaGJhLT5wYXJhbXMud3Jic19wZXJfY3huKTsKKwlwaGJhLT5tZW1fcmVxW0hXSV9NRU1fV1JCSF0gPSByb3VuZHVwX3Bvd19vZl90d28oKHdyYl9zel9wZXJfY3huKSAqCisJCQkJcGhiYS0+cGFyYW1zLmN4bnNfcGVyX2N0cmwpOworCisJcGhiYS0+bWVtX3JlcVtIV0lfTUVNX1NHTEhdID0gc2l6ZW9mKHN0cnVjdCBzZ2xfaGFuZGxlKSAqCisJCXBoYmEtPnBhcmFtcy5pY2RzX3Blcl9jdHJsOworCXBoYmEtPm1lbV9yZXFbSFdJX01FTV9TR0VdID0gc2l6ZW9mKHN0cnVjdCBpc2NzaV9zZ2UpICoKKwkJcGhiYS0+cGFyYW1zLm51bV9zZ2VfcGVyX2lvICogcGhiYS0+cGFyYW1zLmljZHNfcGVyX2N0cmw7CisKKwlwaGJhLT5tZW1fcmVxW0hXSV9NRU1fQVNZTkNfSEVBREVSX0JVRl0gPQorCQludW1fYXN5bmNfcGR1X2J1Zl9wYWdlcyAqIFBBR0VfU0laRTsKKwlwaGJhLT5tZW1fcmVxW0hXSV9NRU1fQVNZTkNfREFUQV9CVUZdID0KKwkJbnVtX2FzeW5jX3BkdV9kYXRhX3BhZ2VzICogUEFHRV9TSVpFOworCXBoYmEtPm1lbV9yZXFbSFdJX01FTV9BU1lOQ19IRUFERVJfUklOR10gPQorCQludW1fYXN5bmNfcGR1X2J1Zl9zZ2xfcGFnZXMgKiBQQUdFX1NJWkU7CisJcGhiYS0+bWVtX3JlcVtIV0lfTUVNX0FTWU5DX0RBVEFfUklOR10gPQorCQludW1fYXN5bmNfcGR1X2RhdGFfc2dsX3BhZ2VzICogUEFHRV9TSVpFOworCXBoYmEtPm1lbV9yZXFbSFdJX01FTV9BU1lOQ19IRUFERVJfSEFORExFXSA9CisJCXBoYmEtPnBhcmFtcy5hc3luY3BkdXNfcGVyX2N0cmwgKgorCQlzaXplb2Yoc3RydWN0IGFzeW5jX3BkdV9oYW5kbGUpOworCXBoYmEtPm1lbV9yZXFbSFdJX01FTV9BU1lOQ19EQVRBX0hBTkRMRV0gPQorCQlwaGJhLT5wYXJhbXMuYXN5bmNwZHVzX3Blcl9jdHJsICoKKwkJc2l6ZW9mKHN0cnVjdCBhc3luY19wZHVfaGFuZGxlKTsKKwlwaGJhLT5tZW1fcmVxW0hXSV9NRU1fQVNZTkNfUERVX0NPTlRFWFRdID0KKwkJc2l6ZW9mKHN0cnVjdCBod2lfYXN5bmNfcGR1X2NvbnRleHQpICsKKwkJKHBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsICogc2l6ZW9mKHN0cnVjdCBod2lfYXN5bmNfZW50cnkpKTsKK30KKworc3RhdGljIGludCBiZWlzY3NpX2FsbG9jX21lbShzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEpCit7CisJc3RydWN0IGJlX21lbV9kZXNjcmlwdG9yICptZW1fZGVzY3I7CisJZG1hX2FkZHJfdCBidXNfYWRkOworCXN0cnVjdCBtZW1fYXJyYXkgKm1lbV9hcnIsICptZW1fYXJyX29yaWc7CisJdW5zaWduZWQgaW50IGksIGosIGFsbG9jX3NpemUsIGN1cnJfYWxsb2Nfc2l6ZTsKKworCXBoYmEtPnBod2lfY3RybHIgPSBrbWFsbG9jKHBoYmEtPnBhcmFtcy5od2lfd3Nfc3osIEdGUF9LRVJORUwpOworCWlmICghcGhiYS0+cGh3aV9jdHJscikKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlwaGJhLT5pbml0X21lbSA9IGtjYWxsb2MoU0VfTUVNX01BWCwgc2l6ZW9mKCptZW1fZGVzY3IpLAorCQkJCSBHRlBfS0VSTkVMKTsKKwlpZiAoIXBoYmEtPmluaXRfbWVtKSB7CisJCWtmcmVlKHBoYmEtPnBod2lfY3RybHIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwltZW1fYXJyX29yaWcgPSBrbWFsbG9jKHNpemVvZigqbWVtX2Fycl9vcmlnKSAqIEJFSVNDU0lfTUFYX0ZSQUdTX0lOSVQsCisJCQkgICAgICAgR0ZQX0tFUk5FTCk7CisJaWYgKCFtZW1fYXJyX29yaWcpIHsKKwkJa2ZyZWUocGhiYS0+aW5pdF9tZW0pOworCQlrZnJlZShwaGJhLT5waHdpX2N0cmxyKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJbWVtX2Rlc2NyID0gcGhiYS0+aW5pdF9tZW07CisJZm9yIChpID0gMDsgaSA8IFNFX01FTV9NQVg7IGkrKykgeworCQlqID0gMDsKKwkJbWVtX2FyciA9IG1lbV9hcnJfb3JpZzsKKwkJYWxsb2Nfc2l6ZSA9IHBoYmEtPm1lbV9yZXFbaV07CisJCW1lbXNldChtZW1fYXJyLCAwLCBzaXplb2Yoc3RydWN0IG1lbV9hcnJheSkgKgorCQkgICAgICAgQkVJU0NTSV9NQVhfRlJBR1NfSU5JVCk7CisJCWN1cnJfYWxsb2Nfc2l6ZSA9IG1pbihiZV9tYXhfcGh5c19zaXplICogMTAyNCwgYWxsb2Nfc2l6ZSk7CisJCWRvIHsKKwkJCW1lbV9hcnItPnZpcnR1YWxfYWRkcmVzcyA9IHBjaV9hbGxvY19jb25zaXN0ZW50KAorCQkJCQkJCXBoYmEtPnBjaWRldiwKKwkJCQkJCQljdXJyX2FsbG9jX3NpemUsCisJCQkJCQkJJmJ1c19hZGQpOworCQkJaWYgKCFtZW1fYXJyLT52aXJ0dWFsX2FkZHJlc3MpIHsKKwkJCQlpZiAoY3Vycl9hbGxvY19zaXplIDw9IEJFX01JTl9NRU1fU0laRSkKKwkJCQkJZ290byBmcmVlX21lbTsKKwkJCQlpZiAoY3Vycl9hbGxvY19zaXplIC0KKwkJCQkJcm91bmRkb3duX3Bvd19vZl90d28oY3Vycl9hbGxvY19zaXplKSkKKwkJCQkJY3Vycl9hbGxvY19zaXplID0gcm91bmRkb3duX3Bvd19vZl90d28KKwkJCQkJCQkgICAgIChjdXJyX2FsbG9jX3NpemUpOworCQkJCWVsc2UKKwkJCQkJY3Vycl9hbGxvY19zaXplID0gY3Vycl9hbGxvY19zaXplIC8gMjsKKwkJCX0gZWxzZSB7CisJCQkJbWVtX2Fyci0+YnVzX2FkZHJlc3MudS4KKwkJCQkgICAgYTY0LmFkZHJlc3MgPSAoX191NjQpIGJ1c19hZGQ7CisJCQkJbWVtX2Fyci0+c2l6ZSA9IGN1cnJfYWxsb2Nfc2l6ZTsKKwkJCQlhbGxvY19zaXplIC09IGN1cnJfYWxsb2Nfc2l6ZTsKKwkJCQljdXJyX2FsbG9jX3NpemUgPSBtaW4oYmVfbWF4X3BoeXNfc2l6ZSAqCisJCQkJCQkgICAgICAxMDI0LCBhbGxvY19zaXplKTsKKwkJCQlqKys7CisJCQkJbWVtX2FycisrOworCQkJfQorCQl9IHdoaWxlIChhbGxvY19zaXplKTsKKwkJbWVtX2Rlc2NyLT5udW1fZWxlbWVudHMgPSBqOworCQltZW1fZGVzY3ItPnNpemVfaW5fYnl0ZXMgPSBwaGJhLT5tZW1fcmVxW2ldOworCQltZW1fZGVzY3ItPm1lbV9hcnJheSA9IGttYWxsb2Moc2l6ZW9mKCptZW1fYXJyKSAqIGosCisJCQkJCSAgICAgICBHRlBfS0VSTkVMKTsKKwkJaWYgKCFtZW1fZGVzY3ItPm1lbV9hcnJheSkKKwkJCWdvdG8gZnJlZV9tZW07CisKKwkJbWVtY3B5KG1lbV9kZXNjci0+bWVtX2FycmF5LCBtZW1fYXJyX29yaWcsCisJCSAgICAgICBzaXplb2Yoc3RydWN0IG1lbV9hcnJheSkgKiBqKTsKKwkJbWVtX2Rlc2NyKys7CisJfQorCWtmcmVlKG1lbV9hcnJfb3JpZyk7CisJcmV0dXJuIDA7CitmcmVlX21lbToKKwltZW1fZGVzY3ItPm51bV9lbGVtZW50cyA9IGo7CisJd2hpbGUgKChpKSB8fCAoaikpIHsKKwkJZm9yIChqID0gbWVtX2Rlc2NyLT5udW1fZWxlbWVudHM7IGogPiAwOyBqLS0pIHsKKwkJCXBjaV9mcmVlX2NvbnNpc3RlbnQocGhiYS0+cGNpZGV2LAorCQkJCQkgICAgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaiAtIDFdLnNpemUsCisJCQkJCSAgICBtZW1fZGVzY3ItPm1lbV9hcnJheVtqIC0gMV0uCisJCQkJCSAgICB2aXJ0dWFsX2FkZHJlc3MsCisJCQkJCSAgICBtZW1fZGVzY3ItPm1lbV9hcnJheVtqIC0gMV0uCisJCQkJCSAgICBidXNfYWRkcmVzcy51LmE2NC5hZGRyZXNzKTsKKwkJfQorCQlpZiAoaSkgeworCQkJaS0tOworCQkJa2ZyZWUobWVtX2Rlc2NyLT5tZW1fYXJyYXkpOworCQkJbWVtX2Rlc2NyLS07CisJCX0KKwl9CisJa2ZyZWUobWVtX2Fycl9vcmlnKTsKKwlrZnJlZShwaGJhLT5pbml0X21lbSk7CisJa2ZyZWUocGhiYS0+cGh3aV9jdHJscik7CisJcmV0dXJuIC1FTk9NRU07Cit9CisKK3N0YXRpYyBpbnQgYmVpc2NzaV9nZXRfbWVtb3J5KHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwliZWlzY3NpX2ZpbmRfbWVtX3JlcShwaGJhKTsKKwlyZXR1cm4gYmVpc2NzaV9hbGxvY19tZW0ocGhiYSk7Cit9CisKK3N0YXRpYyB2b2lkIGlzY3NpX2luaXRfZ2xvYmFsX3RlbXBsYXRlcyhzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEpCit7CisJc3RydWN0IHBkdV9kYXRhX291dCAqcGRhdGFfb3V0OworCXN0cnVjdCBwZHVfbm9wX291dCAqcG5vcF9vdXQ7CisJc3RydWN0IGJlX21lbV9kZXNjcmlwdG9yICptZW1fZGVzY3I7CisKKwltZW1fZGVzY3IgPSBwaGJhLT5pbml0X21lbTsKKwltZW1fZGVzY3IgKz0gSVNDU0lfTUVNX0dMT0JBTF9IRUFERVI7CisJcGRhdGFfb3V0ID0KKwkgICAgKHN0cnVjdCBwZHVfZGF0YV9vdXQgKiltZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3M7CisJbWVtc2V0KHBkYXRhX291dCwgMCwgQkVfSVNDU0lfUERVX0hFQURFUl9TSVpFKTsKKworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfcGR1X2RhdGFfb3V0LCBvcGNvZGUsIHBkYXRhX291dCwKKwkJICAgICAgSUlPQ19TQ1NJX0RBVEEpOworCisJcG5vcF9vdXQgPQorCSAgICAoc3RydWN0IHBkdV9ub3Bfb3V0ICopKCh1bnNpZ25lZCBjaGFyICopbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0uCisJCQkJICAgdmlydHVhbF9hZGRyZXNzICsgQkVfSVNDU0lfUERVX0hFQURFUl9TSVpFKTsKKworCW1lbXNldChwbm9wX291dCwgMCwgQkVfSVNDU0lfUERVX0hFQURFUl9TSVpFKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX3BkdV9ub3Bfb3V0LCB0dHQsIHBub3Bfb3V0LCAweEZGRkZGRkZGKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX3BkdV9ub3Bfb3V0LCBmX2JpdCwgcG5vcF9vdXQsIDEpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfcGR1X25vcF9vdXQsIGlfYml0LCBwbm9wX291dCwgMCk7Cit9CisKK3N0YXRpYyB2b2lkIGJlaXNjc2lfaW5pdF93cmJfaGFuZGxlKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKm1lbV9kZXNjcl93cmJoLCAqbWVtX2Rlc2NyX3dyYjsKKwlzdHJ1Y3Qgd3JiX2hhbmRsZSAqcHdyYl9oYW5kbGU7CisJc3RydWN0IGh3aV9jb250cm9sbGVyICpwaHdpX2N0cmxyOworCXN0cnVjdCBod2lfd3JiX2NvbnRleHQgKnB3cmJfY29udGV4dDsKKwlzdHJ1Y3QgaXNjc2lfd3JiICpwd3JiOworCXVuc2lnbmVkIGludCBudW1fY3huX3dyYmg7CisJdW5zaWduZWQgaW50IG51bV9jeG5fd3JiLCBqLCBpZHgsIGluZGV4OworCisJbWVtX2Rlc2NyX3dyYmggPSBwaGJhLT5pbml0X21lbTsKKwltZW1fZGVzY3Jfd3JiaCArPSBIV0lfTUVNX1dSQkg7CisKKwltZW1fZGVzY3Jfd3JiID0gcGhiYS0+aW5pdF9tZW07CisJbWVtX2Rlc2NyX3dyYiArPSBIV0lfTUVNX1dSQjsKKworCWlkeCA9IDA7CisJcHdyYl9oYW5kbGUgPSBtZW1fZGVzY3Jfd3JiaC0+bWVtX2FycmF5W2lkeF0udmlydHVhbF9hZGRyZXNzOworCW51bV9jeG5fd3JiaCA9ICgobWVtX2Rlc2NyX3dyYmgtPm1lbV9hcnJheVtpZHhdLnNpemUpIC8KKwkJCSgoc2l6ZW9mKHN0cnVjdCB3cmJfaGFuZGxlKSkgKgorCQkJIHBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4pKTsKKwlwaHdpX2N0cmxyID0gcGhiYS0+cGh3aV9jdHJscjsKKworCWZvciAoaW5kZXggPSAwOyBpbmRleCA8IHBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsICogMjsgaW5kZXggKz0gMikgeworCQlwd3JiX2NvbnRleHQgPSAmcGh3aV9jdHJsci0+d3JiX2NvbnRleHRbaW5kZXhdOworCQlTRV9ERUJVRyhEQkdfTFZMXzgsICJjaWQ9JWQgcHdyYl9jb250ZXh0PSVwIFxuIiwgaW5kZXgsCisJCQkJCQlwd3JiX2NvbnRleHQpOworCQlwd3JiX2NvbnRleHQtPnB3cmJfaGFuZGxlX2Jhc2UgPQorCQkJCWt6YWxsb2Moc2l6ZW9mKHN0cnVjdCB3cmJfaGFuZGxlICopICoKKwkJCQkJcGhiYS0+cGFyYW1zLndyYnNfcGVyX2N4biwgR0ZQX0tFUk5FTCk7CisJCXB3cmJfY29udGV4dC0+cHdyYl9oYW5kbGVfYmFzZXN0ZCA9CisJCQkJa3phbGxvYyhzaXplb2Yoc3RydWN0IHdyYl9oYW5kbGUgKikgKgorCQkJCQlwaGJhLT5wYXJhbXMud3Jic19wZXJfY3huLCBHRlBfS0VSTkVMKTsKKwkJaWYgKG51bV9jeG5fd3JiaCkgeworCQkJcHdyYl9jb250ZXh0LT5hbGxvY19pbmRleCA9IDA7CisJCQlwd3JiX2NvbnRleHQtPndyYl9oYW5kbGVzX2F2YWlsYWJsZSA9IDA7CisJCQlmb3IgKGogPSAwOyBqIDwgcGhiYS0+cGFyYW1zLndyYnNfcGVyX2N4bjsgaisrKSB7CisJCQkJcHdyYl9jb250ZXh0LT5wd3JiX2hhbmRsZV9iYXNlW2pdID0gcHdyYl9oYW5kbGU7CisJCQkJcHdyYl9jb250ZXh0LT5wd3JiX2hhbmRsZV9iYXNlc3RkW2pdID0KKwkJCQkJCQkJcHdyYl9oYW5kbGU7CisJCQkJcHdyYl9jb250ZXh0LT53cmJfaGFuZGxlc19hdmFpbGFibGUrKzsKKwkJCQlwd3JiX2hhbmRsZSsrOworCQkJfQorCQkJcHdyYl9jb250ZXh0LT5mcmVlX2luZGV4ID0gMDsKKwkJCW51bV9jeG5fd3JiaC0tOworCQl9IGVsc2UgeworCQkJaWR4Kys7CisJCQlwd3JiX2hhbmRsZSA9CisJCQkgICAgbWVtX2Rlc2NyX3dyYmgtPm1lbV9hcnJheVtpZHhdLnZpcnR1YWxfYWRkcmVzczsKKwkJCW51bV9jeG5fd3JiaCA9CisJCQkgICAgKChtZW1fZGVzY3Jfd3JiaC0+bWVtX2FycmF5W2lkeF0uc2l6ZSkgLworCQkJICAgICAoKHNpemVvZihzdHJ1Y3Qgd3JiX2hhbmRsZSkpICoKKwkJCSAgICAgIHBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4pKTsKKwkJCXB3cmJfY29udGV4dC0+YWxsb2NfaW5kZXggPSAwOworCQkJZm9yIChqID0gMDsgaiA8IHBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG47IGorKykgeworCQkJCXB3cmJfY29udGV4dC0+cHdyYl9oYW5kbGVfYmFzZVtqXSA9IHB3cmJfaGFuZGxlOworCQkJCXB3cmJfY29udGV4dC0+cHdyYl9oYW5kbGVfYmFzZXN0ZFtqXSA9CisJCQkJICAgIHB3cmJfaGFuZGxlOworCQkJCXB3cmJfY29udGV4dC0+d3JiX2hhbmRsZXNfYXZhaWxhYmxlKys7CisJCQkJcHdyYl9oYW5kbGUrKzsKKwkJCX0KKwkJCXB3cmJfY29udGV4dC0+ZnJlZV9pbmRleCA9IDA7CisJCQludW1fY3huX3dyYmgtLTsKKwkJfQorCX0KKwlpZHggPSAwOworCXB3cmIgPSBtZW1fZGVzY3Jfd3JiLT5tZW1fYXJyYXlbaWR4XS52aXJ0dWFsX2FkZHJlc3M7CisJbnVtX2N4bl93cmIgPQorCSAgICAoKG1lbV9kZXNjcl93cmItPm1lbV9hcnJheVtpZHhdLnNpemUpIC8gKHNpemVvZihzdHJ1Y3QgaXNjc2lfd3JiKSkgKgorCSAgICAgcGhiYS0+cGFyYW1zLndyYnNfcGVyX2N4bik7CisKKwlmb3IgKGluZGV4ID0gMDsgaW5kZXggPCBwaGJhLT5wYXJhbXMuY3huc19wZXJfY3RybDsgaW5kZXggKz0gMikgeworCQlwd3JiX2NvbnRleHQgPSAmcGh3aV9jdHJsci0+d3JiX2NvbnRleHRbaW5kZXhdOworCQlpZiAobnVtX2N4bl93cmIpIHsKKwkJCWZvciAoaiA9IDA7IGogPCBwaGJhLT5wYXJhbXMud3Jic19wZXJfY3huOyBqKyspIHsKKwkJCQlwd3JiX2hhbmRsZSA9IHB3cmJfY29udGV4dC0+cHdyYl9oYW5kbGVfYmFzZVtqXTsKKwkJCQlwd3JiX2hhbmRsZS0+cHdyYiA9IHB3cmI7CisJCQkJcHdyYisrOworCQkJfQorCQkJbnVtX2N4bl93cmItLTsKKwkJfSBlbHNlIHsKKwkJCWlkeCsrOworCQkJcHdyYiA9IG1lbV9kZXNjcl93cmItPm1lbV9hcnJheVtpZHhdLnZpcnR1YWxfYWRkcmVzczsKKwkJCW51bV9jeG5fd3JiID0gKChtZW1fZGVzY3Jfd3JiLT5tZW1fYXJyYXlbaWR4XS5zaXplKSAvCisJCQkJCShzaXplb2Yoc3RydWN0IGlzY3NpX3dyYikpICoKKwkJCQkJcGhiYS0+cGFyYW1zLndyYnNfcGVyX2N4bik7CisJCQlmb3IgKGogPSAwOyBqIDwgcGhiYS0+cGFyYW1zLndyYnNfcGVyX2N4bjsgaisrKSB7CisJCQkJcHdyYl9oYW5kbGUgPSBwd3JiX2NvbnRleHQtPnB3cmJfaGFuZGxlX2Jhc2Vbal07CisJCQkJcHdyYl9oYW5kbGUtPnB3cmIgPSBwd3JiOworCQkJCXB3cmIrKzsKKwkJCX0KKwkJCW51bV9jeG5fd3JiLS07CisJCX0KKwl9Cit9CisKK3N0YXRpYyB2b2lkIGh3aV9pbml0X2FzeW5jX3BkdV9jdHgoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXN0cnVjdCBod2lfY29udHJvbGxlciAqcGh3aV9jdHJscjsKKwlzdHJ1Y3QgaGJhX3BhcmFtZXRlcnMgKnAgPSAmcGhiYS0+cGFyYW1zOworCXN0cnVjdCBod2lfYXN5bmNfcGR1X2NvbnRleHQgKnBhc3luY19jdHg7CisJc3RydWN0IGFzeW5jX3BkdV9oYW5kbGUgKnBhc3luY19oZWFkZXJfaCwgKnBhc3luY19kYXRhX2g7CisJdW5zaWduZWQgaW50IGluZGV4OworCXN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqbWVtX2Rlc2NyOworCisJbWVtX2Rlc2NyID0gKHN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqKXBoYmEtPmluaXRfbWVtOworCW1lbV9kZXNjciArPSBIV0lfTUVNX0FTWU5DX1BEVV9DT05URVhUOworCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcGh3aV9jdHJsci0+cGh3aV9jdHh0LT5wYXN5bmNfY3R4ID0gKHN0cnVjdCBod2lfYXN5bmNfcGR1X2NvbnRleHQgKikKKwkJCQltZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3M7CisJcGFzeW5jX2N0eCA9IHBod2lfY3RybHItPnBod2lfY3R4dC0+cGFzeW5jX2N0eDsKKwltZW1zZXQocGFzeW5jX2N0eCwgMCwgc2l6ZW9mKCpwYXN5bmNfY3R4KSk7CisKKwlwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIubnVtX2VudHJpZXMgPSBwLT5hc3luY3BkdXNfcGVyX2N0cmw7CisJcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLmJ1ZmZlcl9zaXplID0gcC0+ZGVmcGR1X2hkcl9zejsKKwlwYXN5bmNfY3R4LT5hc3luY19kYXRhLmJ1ZmZlcl9zaXplID0gcC0+ZGVmcGR1X2RhdGFfc3o7CisJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5udW1fZW50cmllcyA9IHAtPmFzeW5jcGR1c19wZXJfY3RybDsKKworCW1lbV9kZXNjciA9IChzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKilwaGJhLT5pbml0X21lbTsKKwltZW1fZGVzY3IgKz0gSFdJX01FTV9BU1lOQ19IRUFERVJfQlVGOworCWlmIChtZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3MpIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LAorCQkJICJod2lfaW5pdF9hc3luY19wZHVfY3R4IEhXSV9NRU1fQVNZTkNfSEVBREVSX0JVRiIKKwkJCSAidmE9JXAgXG4iLCBtZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3MpOworCX0gZWxzZQorCQlzaG9zdF9wcmludGsoS0VSTl9XQVJOSU5HLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgIk5vIFZpcnR1YWwgYWRkcmVzcyBcbiIpOworCisJcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLnZhX2Jhc2UgPQorCQkJbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0udmlydHVhbF9hZGRyZXNzOworCisJcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLnBhX2Jhc2UudS5hNjQuYWRkcmVzcyA9CisJCQltZW1fZGVzY3ItPm1lbV9hcnJheVswXS5idXNfYWRkcmVzcy51LmE2NC5hZGRyZXNzOworCisJbWVtX2Rlc2NyID0gKHN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqKXBoYmEtPmluaXRfbWVtOworCW1lbV9kZXNjciArPSBIV0lfTUVNX0FTWU5DX0hFQURFUl9SSU5HOworCWlmIChtZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3MpIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LAorCQkJICJod2lfaW5pdF9hc3luY19wZHVfY3R4IEhXSV9NRU1fQVNZTkNfSEVBREVSX1JJTkciCisJCQkgInZhPSVwIFxuIiwgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0udmlydHVhbF9hZGRyZXNzKTsKKwl9IGVsc2UKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgIk5vIFZpcnR1YWwgYWRkcmVzcyBcbiIpOworCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5yaW5nX2Jhc2UgPQorCQkJbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0udmlydHVhbF9hZGRyZXNzOworCisJbWVtX2Rlc2NyID0gKHN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqKXBoYmEtPmluaXRfbWVtOworCW1lbV9kZXNjciArPSBIV0lfTUVNX0FTWU5DX0hFQURFUl9IQU5ETEU7CisJaWYgKG1lbV9kZXNjci0+bWVtX2FycmF5WzBdLnZpcnR1YWxfYWRkcmVzcykgeworCQlTRV9ERUJVRyhEQkdfTFZMXzgsCisJCQkgImh3aV9pbml0X2FzeW5jX3BkdV9jdHggSFdJX01FTV9BU1lOQ19IRUFERVJfSEFORExFIgorCQkJICJ2YT0lcCBcbiIsIG1lbV9kZXNjci0+bWVtX2FycmF5WzBdLnZpcnR1YWxfYWRkcmVzcyk7CisJfSBlbHNlCisJCXNob3N0X3ByaW50ayhLRVJOX1dBUk5JTkcsIHBoYmEtPnNob3N0LAorCQkJICAgICJObyBWaXJ0dWFsIGFkZHJlc3MgXG4iKTsKKworCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5oYW5kbGVfYmFzZSA9CisJCQltZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3M7CisJcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLndyaXRhYmxlcyA9IDA7CisJSU5JVF9MSVNUX0hFQUQoJnBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5mcmVlX2xpc3QpOworCisJbWVtX2Rlc2NyID0gKHN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqKXBoYmEtPmluaXRfbWVtOworCW1lbV9kZXNjciArPSBIV0lfTUVNX0FTWU5DX0RBVEFfQlVGOworCWlmIChtZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3MpIHsKKwkJU0VfREVCVUcoREJHX0xWTF84LAorCQkJICJod2lfaW5pdF9hc3luY19wZHVfY3R4IEhXSV9NRU1fQVNZTkNfREFUQV9CVUYiCisJCQkgInZhPSVwIFxuIiwgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0udmlydHVhbF9hZGRyZXNzKTsKKwl9IGVsc2UKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgIk5vIFZpcnR1YWwgYWRkcmVzcyBcbiIpOworCXBhc3luY19jdHgtPmFzeW5jX2RhdGEudmFfYmFzZSA9CisJCQltZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3M7CisJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5wYV9iYXNlLnUuYTY0LmFkZHJlc3MgPQorCQkJbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0uYnVzX2FkZHJlc3MudS5hNjQuYWRkcmVzczsKKworCW1lbV9kZXNjciA9IChzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKilwaGJhLT5pbml0X21lbTsKKwltZW1fZGVzY3IgKz0gSFdJX01FTV9BU1lOQ19EQVRBX1JJTkc7CisJaWYgKG1lbV9kZXNjci0+bWVtX2FycmF5WzBdLnZpcnR1YWxfYWRkcmVzcykgeworCQlTRV9ERUJVRyhEQkdfTFZMXzgsCisJCQkgImh3aV9pbml0X2FzeW5jX3BkdV9jdHggSFdJX01FTV9BU1lOQ19EQVRBX1JJTkciCisJCQkgInZhPSVwIFxuIiwgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0udmlydHVhbF9hZGRyZXNzKTsKKwl9IGVsc2UKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgICJObyBWaXJ0dWFsIGFkZHJlc3MgXG4iKTsKKworCXBhc3luY19jdHgtPmFzeW5jX2RhdGEucmluZ19iYXNlID0KKwkJCW1lbV9kZXNjci0+bWVtX2FycmF5WzBdLnZpcnR1YWxfYWRkcmVzczsKKworCW1lbV9kZXNjciA9IChzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKilwaGJhLT5pbml0X21lbTsKKwltZW1fZGVzY3IgKz0gSFdJX01FTV9BU1lOQ19EQVRBX0hBTkRMRTsKKwlpZiAoIW1lbV9kZXNjci0+bWVtX2FycmF5WzBdLnZpcnR1YWxfYWRkcmVzcykKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgIk5vIFZpcnR1YWwgYWRkcmVzcyBcbiIpOworCisJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5oYW5kbGVfYmFzZSA9CisJCQltZW1fZGVzY3ItPm1lbV9hcnJheVswXS52aXJ0dWFsX2FkZHJlc3M7CisJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS53cml0YWJsZXMgPSAwOworCUlOSVRfTElTVF9IRUFEKCZwYXN5bmNfY3R4LT5hc3luY19kYXRhLmZyZWVfbGlzdCk7CisKKwlwYXN5bmNfaGVhZGVyX2ggPQorCQkoc3RydWN0IGFzeW5jX3BkdV9oYW5kbGUgKilwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuaGFuZGxlX2Jhc2U7CisJcGFzeW5jX2RhdGFfaCA9CisJCShzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSAqKXBhc3luY19jdHgtPmFzeW5jX2RhdGEuaGFuZGxlX2Jhc2U7CisKKwlmb3IgKGluZGV4ID0gMDsgaW5kZXggPCBwLT5hc3luY3BkdXNfcGVyX2N0cmw7IGluZGV4KyspIHsKKwkJcGFzeW5jX2hlYWRlcl9oLT5jcmkgPSAtMTsKKwkJcGFzeW5jX2hlYWRlcl9oLT5pbmRleCA9IChjaGFyKWluZGV4OworCQlJTklUX0xJU1RfSEVBRCgmcGFzeW5jX2hlYWRlcl9oLT5saW5rKTsKKwkJcGFzeW5jX2hlYWRlcl9oLT5wYnVmZmVyID0KKwkJCSh2b2lkICopKCh1bnNpZ25lZCBsb25nKQorCQkJKHBhc3luY19jdHgtPmFzeW5jX2hlYWRlci52YV9iYXNlKSArCisJCQkocC0+ZGVmcGR1X2hkcl9zeiAqIGluZGV4KSk7CisKKwkJcGFzeW5jX2hlYWRlcl9oLT5wYS51LmE2NC5hZGRyZXNzID0KKwkJCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5wYV9iYXNlLnUuYTY0LmFkZHJlc3MgKworCQkJKHAtPmRlZnBkdV9oZHJfc3ogKiBpbmRleCk7CisKKwkJbGlzdF9hZGRfdGFpbCgmcGFzeW5jX2hlYWRlcl9oLT5saW5rLAorCQkJCSZwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuZnJlZV9saXN0KTsKKwkJcGFzeW5jX2hlYWRlcl9oKys7CisJCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5mcmVlX2VudHJpZXMrKzsKKwkJcGFzeW5jX2N0eC0+YXN5bmNfaGVhZGVyLndyaXRhYmxlcysrOworCisJCUlOSVRfTElTVF9IRUFEKCZwYXN5bmNfY3R4LT5hc3luY19lbnRyeVtpbmRleF0ud2FpdF9xdWV1ZS5saXN0KTsKKwkJSU5JVF9MSVNUX0hFQUQoJnBhc3luY19jdHgtPmFzeW5jX2VudHJ5W2luZGV4XS4KKwkJCSAgICAgICBoZWFkZXJfYnVzeV9saXN0KTsKKwkJcGFzeW5jX2RhdGFfaC0+Y3JpID0gLTE7CisJCXBhc3luY19kYXRhX2gtPmluZGV4ID0gKGNoYXIpaW5kZXg7CisJCUlOSVRfTElTVF9IRUFEKCZwYXN5bmNfZGF0YV9oLT5saW5rKTsKKwkJcGFzeW5jX2RhdGFfaC0+cGJ1ZmZlciA9CisJCQkodm9pZCAqKSgodW5zaWduZWQgbG9uZykKKwkJCShwYXN5bmNfY3R4LT5hc3luY19kYXRhLnZhX2Jhc2UpICsKKwkJCShwLT5kZWZwZHVfZGF0YV9zeiAqIGluZGV4KSk7CisKKwkJcGFzeW5jX2RhdGFfaC0+cGEudS5hNjQuYWRkcmVzcyA9CisJCSAgICBwYXN5bmNfY3R4LT5hc3luY19kYXRhLnBhX2Jhc2UudS5hNjQuYWRkcmVzcyArCisJCSAgICAocC0+ZGVmcGR1X2RhdGFfc3ogKiBpbmRleCk7CisKKwkJbGlzdF9hZGRfdGFpbCgmcGFzeW5jX2RhdGFfaC0+bGluaywKKwkJCSAgICAgICZwYXN5bmNfY3R4LT5hc3luY19kYXRhLmZyZWVfbGlzdCk7CisJCXBhc3luY19kYXRhX2grKzsKKwkJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS5mcmVlX2VudHJpZXMrKzsKKwkJcGFzeW5jX2N0eC0+YXN5bmNfZGF0YS53cml0YWJsZXMrKzsKKworCQlJTklUX0xJU1RfSEVBRCgmcGFzeW5jX2N0eC0+YXN5bmNfZW50cnlbaW5kZXhdLmRhdGFfYnVzeV9saXN0KTsKKwl9CisKKwlwYXN5bmNfY3R4LT5hc3luY19oZWFkZXIuaG9zdF93cml0ZV9wdHIgPSAwOworCXBhc3luY19jdHgtPmFzeW5jX2hlYWRlci5lcF9yZWFkX3B0ciA9IC0xOworCXBhc3luY19jdHgtPmFzeW5jX2RhdGEuaG9zdF93cml0ZV9wdHIgPSAwOworCXBhc3luY19jdHgtPmFzeW5jX2RhdGEuZXBfcmVhZF9wdHIgPSAtMTsKK30KKworc3RhdGljIGludAorYmVfc2dsX2NyZWF0ZV9jb250aWd1b3VzKHZvaWQgKnZpcnR1YWxfYWRkcmVzcywKKwkJCSB1NjQgcGh5c2ljYWxfYWRkcmVzcywgdTMyIGxlbmd0aCwKKwkJCSBzdHJ1Y3QgYmVfZG1hX21lbSAqc2dsKQoreworCVdBUk5fT04oIXZpcnR1YWxfYWRkcmVzcyk7CisJV0FSTl9PTighcGh5c2ljYWxfYWRkcmVzcyk7CisJV0FSTl9PTighbGVuZ3RoID4gMCk7CisJV0FSTl9PTighc2dsKTsKKworCXNnbC0+dmEgPSB2aXJ0dWFsX2FkZHJlc3M7CisJc2dsLT5kbWEgPSBwaHlzaWNhbF9hZGRyZXNzOworCXNnbC0+c2l6ZSA9IGxlbmd0aDsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBiZV9zZ2xfZGVzdHJveV9jb250aWd1b3VzKHN0cnVjdCBiZV9kbWFfbWVtICpzZ2wpCit7CisJbWVtc2V0KHNnbCwgMCwgc2l6ZW9mKCpzZ2wpKTsKK30KKworc3RhdGljIHZvaWQKK2h3aV9idWlsZF9iZV9zZ2xfYXJyKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwKKwkJICAgICBzdHJ1Y3QgbWVtX2FycmF5ICpwbWVtLCBzdHJ1Y3QgYmVfZG1hX21lbSAqc2dsKQoreworCWlmIChzZ2wtPnZhKQorCQliZV9zZ2xfZGVzdHJveV9jb250aWd1b3VzKHNnbCk7CisKKwliZV9zZ2xfY3JlYXRlX2NvbnRpZ3VvdXMocG1lbS0+dmlydHVhbF9hZGRyZXNzLAorCQkJCSBwbWVtLT5idXNfYWRkcmVzcy51LmE2NC5hZGRyZXNzLAorCQkJCSBwbWVtLT5zaXplLCBzZ2wpOworfQorCitzdGF0aWMgdm9pZAoraHdpX2J1aWxkX2JlX3NnbF9ieV9vZmZzZXQoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJICAgc3RydWN0IG1lbV9hcnJheSAqcG1lbSwgc3RydWN0IGJlX2RtYV9tZW0gKnNnbCkKK3sKKwlpZiAoc2dsLT52YSkKKwkJYmVfc2dsX2Rlc3Ryb3lfY29udGlndW91cyhzZ2wpOworCisJYmVfc2dsX2NyZWF0ZV9jb250aWd1b3VzKCh1bnNpZ25lZCBjaGFyICopcG1lbS0+dmlydHVhbF9hZGRyZXNzLAorCQkJCSBwbWVtLT5idXNfYWRkcmVzcy51LmE2NC5hZGRyZXNzLAorCQkJCSBwbWVtLT5zaXplLCBzZ2wpOworfQorCitzdGF0aWMgaW50IGJlX2ZpbGxfcXVldWUoc3RydWN0IGJlX3F1ZXVlX2luZm8gKnEsCisJCXUxNiBsZW4sIHUxNiBlbnRyeV9zaXplLCB2b2lkICp2YWRkcmVzcykKK3sKKwlzdHJ1Y3QgYmVfZG1hX21lbSAqbWVtID0gJnEtPmRtYV9tZW07CisKKwltZW1zZXQocSwgMCwgc2l6ZW9mKCpxKSk7CisJcS0+bGVuID0gbGVuOworCXEtPmVudHJ5X3NpemUgPSBlbnRyeV9zaXplOworCW1lbS0+c2l6ZSA9IGxlbiAqIGVudHJ5X3NpemU7CisJbWVtLT52YSA9IHZhZGRyZXNzOworCWlmICghbWVtLT52YSkKKwkJcmV0dXJuIC1FTk9NRU07CisJbWVtc2V0KG1lbS0+dmEsIDAsIG1lbS0+c2l6ZSk7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgYmVpc2NzaV9jcmVhdGVfZXEoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJICAgICBzdHJ1Y3QgaHdpX2NvbnRleHRfbWVtb3J5ICpwaHdpX2NvbnRleHQpCit7CisJdW5zaWduZWQgaW50IGlkeDsKKwlpbnQgcmV0OworCXN0cnVjdCBiZV9xdWV1ZV9pbmZvICplcTsKKwlzdHJ1Y3QgYmVfZG1hX21lbSAqbWVtOworCXN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqbWVtX2Rlc2NyOworCXZvaWQgKmVxX3ZhZGRyZXNzOworCisJaWR4ID0gMDsKKwllcSA9ICZwaHdpX2NvbnRleHQtPmJlX2VxLnE7CisJbWVtID0gJmVxLT5kbWFfbWVtOworCW1lbV9kZXNjciA9IHBoYmEtPmluaXRfbWVtOworCW1lbV9kZXNjciArPSBIV0lfTUVNX0VROworCWVxX3ZhZGRyZXNzID0gbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaWR4XS52aXJ0dWFsX2FkZHJlc3M7CisKKwlyZXQgPSBiZV9maWxsX3F1ZXVlKGVxLCBwaGJhLT5wYXJhbXMubnVtX2VxX2VudHJpZXMsCisJCQkgICAgc2l6ZW9mKHN0cnVjdCBiZV9lcV9lbnRyeSksIGVxX3ZhZGRyZXNzKTsKKwlpZiAocmV0KSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkgICAgICJiZV9maWxsX3F1ZXVlIEZhaWxlZCBmb3IgRVEgXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwltZW0tPmRtYSA9IG1lbV9kZXNjci0+bWVtX2FycmF5W2lkeF0uYnVzX2FkZHJlc3MudS5hNjQuYWRkcmVzczsKKworCXJldCA9IGJlaXNjc2lfY21kX2VxX2NyZWF0ZSgmcGhiYS0+Y3RybCwgZXEsCisJCQkJICAgIHBod2lfY29udGV4dC0+YmVfZXEuY3VyX2VxZCk7CisJaWYgKHJldCkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LCAiYmVpc2NzaV9jbWRfZXFfY3JlYXRlIgorCQkJICAgICAiRmFpbGVkZm9yIEVRIFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCVNFX0RFQlVHKERCR19MVkxfOCwgImVxIGlkIGlzICVkXG4iLCBwaHdpX2NvbnRleHQtPmJlX2VxLnEuaWQpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IGJlaXNjc2lfY3JlYXRlX2NxKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwKKwkJCSAgICAgc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0KQoreworCXVuc2lnbmVkIGludCBpZHg7CisJaW50IHJldDsKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyAqY3EsICplcTsKKwlzdHJ1Y3QgYmVfZG1hX21lbSAqbWVtOworCXN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqbWVtX2Rlc2NyOworCXZvaWQgKmNxX3ZhZGRyZXNzOworCisJaWR4ID0gMDsKKwljcSA9ICZwaHdpX2NvbnRleHQtPmJlX2NxOworCWVxID0gJnBod2lfY29udGV4dC0+YmVfZXEucTsKKwltZW0gPSAmY3EtPmRtYV9tZW07CisJbWVtX2Rlc2NyID0gcGhiYS0+aW5pdF9tZW07CisJbWVtX2Rlc2NyICs9IEhXSV9NRU1fQ1E7CisJY3FfdmFkZHJlc3MgPSBtZW1fZGVzY3ItPm1lbV9hcnJheVtpZHhdLnZpcnR1YWxfYWRkcmVzczsKKwlyZXQgPSBiZV9maWxsX3F1ZXVlKGNxLCBwaGJhLT5wYXJhbXMuaWNkc19wZXJfY3RybCAvIDIsCisJCQkgICAgc2l6ZW9mKHN0cnVjdCBzb2xfY3FlKSwgY3FfdmFkZHJlc3MpOworCWlmIChyZXQpIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgImJlX2ZpbGxfcXVldWUgRmFpbGVkIGZvciBJU0NTSSBDUSBcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKworCW1lbS0+ZG1hID0gbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaWR4XS5idXNfYWRkcmVzcy51LmE2NC5hZGRyZXNzOworCXJldCA9IGJlaXNjc2lfY21kX2NxX2NyZWF0ZSgmcGhiYS0+Y3RybCwgY3EsIGVxLCBmYWxzZSwgZmFsc2UsIDApOworCWlmIChyZXQpIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgImJlaXNjc2lfY21kX2VxX2NyZWF0ZSBGYWlsZWQgZm9yIElTQ1NJIENRIFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCVNFX0RFQlVHKERCR19MVkxfOCwgImlzY3NpIGNxIGlkIGlzICVkXG4iLCBwaHdpX2NvbnRleHQtPmJlX2NxLmlkKTsKKwlTRV9ERUJVRyhEQkdfTFZMXzgsICJJU0NTSSBDUSBDUkVBVEVEXG4iKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorYmVpc2NzaV9jcmVhdGVfZGVmX2hkcihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCSAgICAgICBzdHJ1Y3QgaHdpX2NvbnRleHRfbWVtb3J5ICpwaHdpX2NvbnRleHQsCisJCSAgICAgICBzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHIsCisJCSAgICAgICB1bnNpZ25lZCBpbnQgZGVmX3BkdV9yaW5nX3N6KQoreworCXVuc2lnbmVkIGludCBpZHg7CisJaW50IHJldDsKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyAqZHEsICpjcTsKKwlzdHJ1Y3QgYmVfZG1hX21lbSAqbWVtOworCXN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqbWVtX2Rlc2NyOworCXZvaWQgKmRxX3ZhZGRyZXNzOworCisJaWR4ID0gMDsKKwlkcSA9ICZwaHdpX2NvbnRleHQtPmJlX2RlZl9oZHJxOworCWNxID0gJnBod2lfY29udGV4dC0+YmVfY3E7CisJbWVtID0gJmRxLT5kbWFfbWVtOworCW1lbV9kZXNjciA9IHBoYmEtPmluaXRfbWVtOworCW1lbV9kZXNjciArPSBIV0lfTUVNX0FTWU5DX0hFQURFUl9SSU5HOworCWRxX3ZhZGRyZXNzID0gbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaWR4XS52aXJ0dWFsX2FkZHJlc3M7CisJcmV0ID0gYmVfZmlsbF9xdWV1ZShkcSwgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0uc2l6ZSAvCisJCQkgICAgc2l6ZW9mKHN0cnVjdCBwaHlzX2FkZHIpLAorCQkJICAgIHNpemVvZihzdHJ1Y3QgcGh5c19hZGRyKSwgZHFfdmFkZHJlc3MpOworCWlmIChyZXQpIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgImJlX2ZpbGxfcXVldWUgRmFpbGVkIGZvciBERUYgUERVIEhEUlxuIik7CisJCXJldHVybiByZXQ7CisJfQorCW1lbS0+ZG1hID0gbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaWR4XS5idXNfYWRkcmVzcy51LmE2NC5hZGRyZXNzOworCXJldCA9IGJlX2NtZF9jcmVhdGVfZGVmYXVsdF9wZHVfcXVldWUoJnBoYmEtPmN0cmwsIGNxLCBkcSwKKwkJCQkJICAgICAgZGVmX3BkdV9yaW5nX3N6LAorCQkJCQkgICAgICBwaGJhLT5wYXJhbXMuZGVmcGR1X2hkcl9zeik7CisJaWYgKHJldCkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJICAgICAiYmVfY21kX2NyZWF0ZV9kZWZhdWx0X3BkdV9xdWV1ZSBGYWlsZWQgREVGSERSXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJcGh3aV9jdHJsci0+ZGVmYXVsdF9wZHVfaGRyLmlkID0gcGh3aV9jb250ZXh0LT5iZV9kZWZfaGRycS5pZDsKKwlTRV9ERUJVRyhEQkdfTFZMXzgsICJpc2NzaSBkZWYgcGR1IGlkIGlzICVkXG4iLAorCQkgcGh3aV9jb250ZXh0LT5iZV9kZWZfaGRycS5pZCk7CisJaHdpX3Bvc3RfYXN5bmNfYnVmZmVycyhwaGJhLCAxKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorYmVpc2NzaV9jcmVhdGVfZGVmX2RhdGEoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0LAorCQkJc3RydWN0IGh3aV9jb250cm9sbGVyICpwaHdpX2N0cmxyLAorCQkJdW5zaWduZWQgaW50IGRlZl9wZHVfcmluZ19zeikKK3sKKwl1bnNpZ25lZCBpbnQgaWR4OworCWludCByZXQ7CisJc3RydWN0IGJlX3F1ZXVlX2luZm8gKmRhdGFxLCAqY3E7CisJc3RydWN0IGJlX2RtYV9tZW0gKm1lbTsKKwlzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKm1lbV9kZXNjcjsKKwl2b2lkICpkcV92YWRkcmVzczsKKworCWlkeCA9IDA7CisJZGF0YXEgPSAmcGh3aV9jb250ZXh0LT5iZV9kZWZfZGF0YXE7CisJY3EgPSAmcGh3aV9jb250ZXh0LT5iZV9jcTsKKwltZW0gPSAmZGF0YXEtPmRtYV9tZW07CisJbWVtX2Rlc2NyID0gcGhiYS0+aW5pdF9tZW07CisJbWVtX2Rlc2NyICs9IEhXSV9NRU1fQVNZTkNfREFUQV9SSU5HOworCWRxX3ZhZGRyZXNzID0gbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaWR4XS52aXJ0dWFsX2FkZHJlc3M7CisJcmV0ID0gYmVfZmlsbF9xdWV1ZShkYXRhcSwgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0uc2l6ZSAvCisJCQkgICAgc2l6ZW9mKHN0cnVjdCBwaHlzX2FkZHIpLAorCQkJICAgIHNpemVvZihzdHJ1Y3QgcGh5c19hZGRyKSwgZHFfdmFkZHJlc3MpOworCWlmIChyZXQpIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgImJlX2ZpbGxfcXVldWUgRmFpbGVkIGZvciBERUYgUERVIERBVEFcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKwltZW0tPmRtYSA9IG1lbV9kZXNjci0+bWVtX2FycmF5W2lkeF0uYnVzX2FkZHJlc3MudS5hNjQuYWRkcmVzczsKKwlyZXQgPSBiZV9jbWRfY3JlYXRlX2RlZmF1bHRfcGR1X3F1ZXVlKCZwaGJhLT5jdHJsLCBjcSwgZGF0YXEsCisJCQkJCSAgICAgIGRlZl9wZHVfcmluZ19zeiwKKwkJCQkJICAgICAgcGhiYS0+cGFyYW1zLmRlZnBkdV9kYXRhX3N6KTsKKwlpZiAocmV0KSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkgICAgICJiZV9jbWRfY3JlYXRlX2RlZmF1bHRfcGR1X3F1ZXVlIEZhaWxlZCIKKwkJCSAgICAgIiBmb3IgREVGIFBEVSBEQVRBXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisJcGh3aV9jdHJsci0+ZGVmYXVsdF9wZHVfZGF0YS5pZCA9IHBod2lfY29udGV4dC0+YmVfZGVmX2RhdGFxLmlkOworCVNFX0RFQlVHKERCR19MVkxfOCwgImlzY3NpIGRlZiBkYXRhIGlkIGlzICVkXG4iLAorCQkgcGh3aV9jb250ZXh0LT5iZV9kZWZfZGF0YXEuaWQpOworCWh3aV9wb3N0X2FzeW5jX2J1ZmZlcnMocGhiYSwgMCk7CisJU0VfREVCVUcoREJHX0xWTF84LCAiREVGQVVMVCBQRFUgREFUQSBSSU5HIENSRUFURUQgXG4iKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludAorYmVpc2NzaV9wb3N0X3BhZ2VzKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKm1lbV9kZXNjcjsKKwlzdHJ1Y3QgbWVtX2FycmF5ICpwbV9hcnI7CisJdW5zaWduZWQgaW50IHBhZ2Vfb2Zmc2V0LCBpOworCXN0cnVjdCBiZV9kbWFfbWVtIHNnbDsKKwlpbnQgc3RhdHVzOworCisJbWVtX2Rlc2NyID0gcGhiYS0+aW5pdF9tZW07CisJbWVtX2Rlc2NyICs9IEhXSV9NRU1fU0dFOworCXBtX2FyciA9IG1lbV9kZXNjci0+bWVtX2FycmF5OworCisJcGFnZV9vZmZzZXQgPSAoc2l6ZW9mKHN0cnVjdCBpc2NzaV9zZ2UpICogcGhiYS0+cGFyYW1zLm51bV9zZ2VfcGVyX2lvICoKKwkJCXBoYmEtPmZ3X2NvbmZpZy5pc2NzaV9pY2Rfc3RhcnQpIC8gUEFHRV9TSVpFOworCWZvciAoaSA9IDA7IGkgPCBtZW1fZGVzY3ItPm51bV9lbGVtZW50czsgaSsrKSB7CisJCWh3aV9idWlsZF9iZV9zZ2xfYXJyKHBoYmEsIHBtX2FyciwgJnNnbCk7CisJCXN0YXR1cyA9IGJlX2NtZF9pc2NzaV9wb3N0X3NnbF9wYWdlcygmcGhiYS0+Y3RybCwgJnNnbCwKKwkJCQkJCXBhZ2Vfb2Zmc2V0LAorCQkJCQkJKHBtX2Fyci0+c2l6ZSAvIFBBR0VfU0laRSkpOworCQlwYWdlX29mZnNldCArPSBwbV9hcnItPnNpemUgLyBQQUdFX1NJWkU7CisJCWlmIChzdGF0dXMgIT0gMCkgeworCQkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCQkgICAgICJwb3N0IHNnbCBmYWlsZWQuXG4iKTsKKwkJCXJldHVybiBzdGF0dXM7CisJCX0KKwkJcG1fYXJyKys7CisJfQorCVNFX0RFQlVHKERCR19MVkxfOCwgIlBPU1RFRCBQQUdFUyBcbiIpOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50CitiZWlzY3NpX2NyZWF0ZV93cmJfcmluZ3Moc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJIHN0cnVjdCBod2lfY29udGV4dF9tZW1vcnkgKnBod2lfY29udGV4dCwKKwkJCSBzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHIpCit7CisJdW5zaWduZWQgaW50IHdyYl9tZW1faW5kZXgsIG9mZnNldCwgc2l6ZSwgbnVtX3dyYl9yaW5nczsKKwl1NjQgcGFfYWRkcl9sbzsKKwl1bnNpZ25lZCBpbnQgaWR4LCBudW0sIGk7CisJc3RydWN0IG1lbV9hcnJheSAqcHdyYl9hcnI7CisJdm9pZCAqd3JiX3ZhZGRyOworCXN0cnVjdCBiZV9kbWFfbWVtIHNnbDsKKwlzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKm1lbV9kZXNjcjsKKwlpbnQgc3RhdHVzOworCisJaWR4ID0gMDsKKwltZW1fZGVzY3IgPSBwaGJhLT5pbml0X21lbTsKKwltZW1fZGVzY3IgKz0gSFdJX01FTV9XUkI7CisJcHdyYl9hcnIgPSBrbWFsbG9jKHNpemVvZigqcHdyYl9hcnIpICogcGhiYS0+cGFyYW1zLmN4bnNfcGVyX2N0cmwsCisJCQkgICBHRlBfS0VSTkVMKTsKKwlpZiAoIXB3cmJfYXJyKSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkgICAgICJNZW1vcnkgYWxsb2MgZmFpbGVkIGluIGNyZWF0ZSB3cmIgcmluZy5cbiIpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisJd3JiX3ZhZGRyID0gbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaWR4XS52aXJ0dWFsX2FkZHJlc3M7CisJcGFfYWRkcl9sbyA9IG1lbV9kZXNjci0+bWVtX2FycmF5W2lkeF0uYnVzX2FkZHJlc3MudS5hNjQuYWRkcmVzczsKKwludW1fd3JiX3JpbmdzID0gbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaWR4XS5zaXplIC8KKwkJKHBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4gKiBzaXplb2Yoc3RydWN0IGlzY3NpX3dyYikpOworCisJZm9yIChudW0gPSAwOyBudW0gPCBwaGJhLT5wYXJhbXMuY3huc19wZXJfY3RybDsgbnVtKyspIHsKKwkJaWYgKG51bV93cmJfcmluZ3MpIHsKKwkJCXB3cmJfYXJyW251bV0udmlydHVhbF9hZGRyZXNzID0gd3JiX3ZhZGRyOworCQkJcHdyYl9hcnJbbnVtXS5idXNfYWRkcmVzcy51LmE2NC5hZGRyZXNzCT0gcGFfYWRkcl9sbzsKKwkJCXB3cmJfYXJyW251bV0uc2l6ZSA9IHBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4gKgorCQkJCQkgICAgc2l6ZW9mKHN0cnVjdCBpc2NzaV93cmIpOworCQkJd3JiX3ZhZGRyICs9IHB3cmJfYXJyW251bV0uc2l6ZTsKKwkJCXBhX2FkZHJfbG8gKz0gcHdyYl9hcnJbbnVtXS5zaXplOworCQkJbnVtX3dyYl9yaW5ncy0tOworCQl9IGVsc2UgeworCQkJaWR4Kys7CisJCQl3cmJfdmFkZHIgPSBtZW1fZGVzY3ItPm1lbV9hcnJheVtpZHhdLnZpcnR1YWxfYWRkcmVzczsKKwkJCXBhX2FkZHJfbG8gPSBtZW1fZGVzY3ItPm1lbV9hcnJheVtpZHhdLlwKKwkJCQkJYnVzX2FkZHJlc3MudS5hNjQuYWRkcmVzczsKKwkJCW51bV93cmJfcmluZ3MgPSBtZW1fZGVzY3ItPm1lbV9hcnJheVtpZHhdLnNpemUgLworCQkJCQkocGhiYS0+cGFyYW1zLndyYnNfcGVyX2N4biAqCisJCQkJCXNpemVvZihzdHJ1Y3QgaXNjc2lfd3JiKSk7CisJCQlwd3JiX2FycltudW1dLnZpcnR1YWxfYWRkcmVzcyA9IHdyYl92YWRkcjsKKwkJCXB3cmJfYXJyW251bV0uYnVzX2FkZHJlc3MudS5hNjQuYWRkcmVzc1wKKwkJCQkJCT0gcGFfYWRkcl9sbzsKKwkJCXB3cmJfYXJyW251bV0uc2l6ZSA9IHBoYmEtPnBhcmFtcy53cmJzX3Blcl9jeG4gKgorCQkJCQkJIHNpemVvZihzdHJ1Y3QgaXNjc2lfd3JiKTsKKwkJCXdyYl92YWRkciArPSBwd3JiX2FycltudW1dLnNpemU7CisJCQlwYV9hZGRyX2xvICAgKz0gcHdyYl9hcnJbbnVtXS5zaXplOworCQkJbnVtX3dyYl9yaW5ncy0tOworCQl9CisJfQorCWZvciAoaSA9IDA7IGkgPCBwaGJhLT5wYXJhbXMuY3huc19wZXJfY3RybDsgaSsrKSB7CisJCXdyYl9tZW1faW5kZXggPSAwOworCQlvZmZzZXQgPSAwOworCQlzaXplID0gMDsKKworCQlod2lfYnVpbGRfYmVfc2dsX2J5X29mZnNldChwaGJhLCAmcHdyYl9hcnJbaV0sICZzZ2wpOworCQlzdGF0dXMgPSBiZV9jbWRfd3JicV9jcmVhdGUoJnBoYmEtPmN0cmwsICZzZ2wsCisJCQkJCSAgICAmcGh3aV9jb250ZXh0LT5iZV93cmJxW2ldKTsKKwkJaWYgKHN0YXR1cyAhPSAwKSB7CisJCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJCSAgICAgIndyYnEgY3JlYXRlIGZhaWxlZC4iKTsKKwkJCXJldHVybiBzdGF0dXM7CisJCX0KKwkJcGh3aV9jdHJsci0+d3JiX2NvbnRleHRbaV0uY2lkID0gcGh3aV9jb250ZXh0LT5iZV93cmJxW2ldLmlkOworCX0KKwlrZnJlZShwd3JiX2Fycik7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyB2b2lkIGZyZWVfd3JiX2hhbmRsZXMoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXVuc2lnbmVkIGludCBpbmRleDsKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV93cmJfY29udGV4dCAqcHdyYl9jb250ZXh0OworCisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJZm9yIChpbmRleCA9IDA7IGluZGV4IDwgcGhiYS0+cGFyYW1zLmN4bnNfcGVyX2N0cmwgKiAyOyBpbmRleCArPSAyKSB7CisJCXB3cmJfY29udGV4dCA9ICZwaHdpX2N0cmxyLT53cmJfY29udGV4dFtpbmRleF07CisJCWtmcmVlKHB3cmJfY29udGV4dC0+cHdyYl9oYW5kbGVfYmFzZSk7CisJCWtmcmVlKHB3cmJfY29udGV4dC0+cHdyYl9oYW5kbGVfYmFzZXN0ZCk7CisJfQorfQorCitzdGF0aWMgdm9pZCBod2lfY2xlYW51cChzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEpCit7CisJc3RydWN0IGJlX3F1ZXVlX2luZm8gKnE7CisJc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCA9ICZwaGJhLT5jdHJsOworCXN0cnVjdCBod2lfY29udHJvbGxlciAqcGh3aV9jdHJscjsKKwlzdHJ1Y3QgaHdpX2NvbnRleHRfbWVtb3J5ICpwaHdpX2NvbnRleHQ7CisJaW50IGk7CisKKwlwaHdpX2N0cmxyID0gcGhiYS0+cGh3aV9jdHJscjsKKwlwaHdpX2NvbnRleHQgPSBwaHdpX2N0cmxyLT5waHdpX2N0eHQ7CisJZm9yIChpID0gMDsgaSA8IHBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsOyBpKyspIHsKKwkJcSA9ICZwaHdpX2NvbnRleHQtPmJlX3dyYnFbaV07CisJCWlmIChxLT5jcmVhdGVkKQorCQkJYmVpc2NzaV9jbWRfcV9kZXN0cm95KGN0cmwsIHEsIFFUWVBFX1dSQlEpOworCX0KKworCWZyZWVfd3JiX2hhbmRsZXMocGhiYSk7CisKKwlxID0gJnBod2lfY29udGV4dC0+YmVfZGVmX2hkcnE7CisJaWYgKHEtPmNyZWF0ZWQpCisJCWJlaXNjc2lfY21kX3FfZGVzdHJveShjdHJsLCBxLCBRVFlQRV9EUERVUSk7CisKKwlxID0gJnBod2lfY29udGV4dC0+YmVfZGVmX2RhdGFxOworCWlmIChxLT5jcmVhdGVkKQorCQliZWlzY3NpX2NtZF9xX2Rlc3Ryb3koY3RybCwgcSwgUVRZUEVfRFBEVVEpOworCisJYmVpc2NzaV9jbWRfcV9kZXN0cm95KGN0cmwsIE5VTEwsIFFUWVBFX1NHTCk7CisKKwlxID0gJnBod2lfY29udGV4dC0+YmVfY3E7CisJaWYgKHEtPmNyZWF0ZWQpCisJCWJlaXNjc2lfY21kX3FfZGVzdHJveShjdHJsLCBxLCBRVFlQRV9DUSk7CisKKwlxID0gJnBod2lfY29udGV4dC0+YmVfZXEucTsKKwlpZiAocS0+Y3JlYXRlZCkKKwkJYmVpc2NzaV9jbWRfcV9kZXN0cm95KGN0cmwsIHEsIFFUWVBFX0VRKTsKK30KKworc3RhdGljIGludCBod2lfaW5pdF9wb3J0KHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0OworCXVuc2lnbmVkIGludCBkZWZfcGR1X3Jpbmdfc3o7CisJc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCA9ICZwaGJhLT5jdHJsOworCWludCBzdGF0dXM7CisKKwlkZWZfcGR1X3Jpbmdfc3ogPQorCQlwaGJhLT5wYXJhbXMuYXN5bmNwZHVzX3Blcl9jdHJsICogc2l6ZW9mKHN0cnVjdCBwaHlzX2FkZHIpOworCXBod2lfY3RybHIgPSBwaGJhLT5waHdpX2N0cmxyOworCisJcGh3aV9jb250ZXh0ID0gcGh3aV9jdHJsci0+cGh3aV9jdHh0OworCXBod2lfY29udGV4dC0+YmVfZXEubWF4X2VxZCA9IDA7CisJcGh3aV9jb250ZXh0LT5iZV9lcS5taW5fZXFkID0gMDsKKwlwaHdpX2NvbnRleHQtPmJlX2VxLmN1cl9lcWQgPSA2NDsKKwlwaHdpX2NvbnRleHQtPmJlX2VxLmVuYWJsZV9haWMgPSBmYWxzZTsKKwliZV9jbWRfZndfaW5pdGlhbGl6ZSgmcGhiYS0+Y3RybCk7CisJc3RhdHVzID0gYmVpc2NzaV9jcmVhdGVfZXEocGhiYSwgcGh3aV9jb250ZXh0KTsKKwlpZiAoc3RhdHVzICE9IDApIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwgIkVRIG5vdCBjcmVhdGVkIFxuIik7CisJCWdvdG8gZXJyb3I7CisJfQorCisJc3RhdHVzID0gbWdtdF9jaGVja19zdXBwb3J0ZWRfZncoY3RybCk7CisJaWYgKHN0YXR1cyAhPSAwKSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkgICAgICJVbnN1cHBvcnRlZCBmdyB2ZXJzaW9uIFxuIik7CisJCWdvdG8gZXJyb3I7CisJfQorCisJc3RhdHVzID0gbWdtdF9nZXRfZndfY29uZmlnKGN0cmwsIHBoYmEpOworCWlmIChzdGF0dXMgIT0gMCkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJICAgICAiRXJyb3IgZ2V0dGluZyBmdyBjb25maWdcbiIpOworCQlnb3RvIGVycm9yOworCX0KKworCXN0YXR1cyA9IGJlaXNjc2lfY3JlYXRlX2NxKHBoYmEsIHBod2lfY29udGV4dCk7CisJaWYgKHN0YXR1cyAhPSAwKSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsICJDUSBub3QgY3JlYXRlZFxuIik7CisJCWdvdG8gZXJyb3I7CisJfQorCisJc3RhdHVzID0gYmVpc2NzaV9jcmVhdGVfZGVmX2hkcihwaGJhLCBwaHdpX2NvbnRleHQsIHBod2lfY3RybHIsCisJCQkJCWRlZl9wZHVfcmluZ19zeik7CisJaWYgKHN0YXR1cyAhPSAwKSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkgICAgICJEZWZhdWx0IEhlYWRlciBub3QgY3JlYXRlZFxuIik7CisJCWdvdG8gZXJyb3I7CisJfQorCisJc3RhdHVzID0gYmVpc2NzaV9jcmVhdGVfZGVmX2RhdGEocGhiYSwgcGh3aV9jb250ZXh0LAorCQkJCQkgcGh3aV9jdHJsciwgZGVmX3BkdV9yaW5nX3N6KTsKKwlpZiAoc3RhdHVzICE9IDApIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgIkRlZmF1bHQgRGF0YSBub3QgY3JlYXRlZFxuIik7CisJCWdvdG8gZXJyb3I7CisJfQorCisJc3RhdHVzID0gYmVpc2NzaV9wb3N0X3BhZ2VzKHBoYmEpOworCWlmIChzdGF0dXMgIT0gMCkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LCAiUG9zdCBTR0wgUGFnZXMgRmFpbGVkXG4iKTsKKwkJZ290byBlcnJvcjsKKwl9CisKKwlzdGF0dXMgPSBiZWlzY3NpX2NyZWF0ZV93cmJfcmluZ3MocGhiYSwJcGh3aV9jb250ZXh0LCBwaHdpX2N0cmxyKTsKKwlpZiAoc3RhdHVzICE9IDApIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgIldSQiBSaW5ncyBub3QgY3JlYXRlZFxuIik7CisJCWdvdG8gZXJyb3I7CisJfQorCisJU0VfREVCVUcoREJHX0xWTF84LCAiaHdpX2luaXRfcG9ydCBzdWNjZXNzXG4iKTsKKwlyZXR1cm4gMDsKKworZXJyb3I6CisJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwgImh3aV9pbml0X3BvcnQgZmFpbGVkIik7CisJaHdpX2NsZWFudXAocGhiYSk7CisJcmV0dXJuIC1FTk9NRU07Cit9CisKKworc3RhdGljIGludCBod2lfaW5pdF9jb250cm9sbGVyKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisKKwlwaHdpX2N0cmxyID0gcGhiYS0+cGh3aV9jdHJscjsKKwlpZiAoMSA9PSBwaGJhLT5pbml0X21lbVtIV0lfTUVNX0FERE5fQ09OVEVYVF0ubnVtX2VsZW1lbnRzKSB7CisJCXBod2lfY3RybHItPnBod2lfY3R4dCA9IChzdHJ1Y3QgaHdpX2NvbnRleHRfbWVtb3J5ICopcGhiYS0+CisJCSAgICBpbml0X21lbVtIV0lfTUVNX0FERE5fQ09OVEVYVF0ubWVtX2FycmF5WzBdLnZpcnR1YWxfYWRkcmVzczsKKwkJU0VfREVCVUcoREJHX0xWTF84LCAiIHBod2lfY3RybHItPnBod2lfY3R4dD0lcCBcbiIsCisJCQkgcGh3aV9jdHJsci0+cGh3aV9jdHh0KTsKKwl9IGVsc2UgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJICAgICAiSFdJX01FTV9BREROX0NPTlRFWFQgaXMgbW9yZSB0aGFuIG9uZSBlbGVtZW50LiIKKwkJCSAgICAgIkZhaWxpbmcgdG8gbG9hZFxuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCWlzY3NpX2luaXRfZ2xvYmFsX3RlbXBsYXRlcyhwaGJhKTsKKwliZWlzY3NpX2luaXRfd3JiX2hhbmRsZShwaGJhKTsKKwlod2lfaW5pdF9hc3luY19wZHVfY3R4KHBoYmEpOworCWlmIChod2lfaW5pdF9wb3J0KHBoYmEpICE9IDApIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgImh3aV9pbml0X2NvbnRyb2xsZXIgZmFpbGVkXG4iKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBiZWlzY3NpX2ZyZWVfbWVtKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKm1lbV9kZXNjcjsKKwlpbnQgaSwgajsKKworCW1lbV9kZXNjciA9IHBoYmEtPmluaXRfbWVtOworCWkgPSAwOworCWogPSAwOworCWZvciAoaSA9IDA7IGkgPCBTRV9NRU1fTUFYOyBpKyspIHsKKwkJZm9yIChqID0gbWVtX2Rlc2NyLT5udW1fZWxlbWVudHM7IGogPiAwOyBqLS0pIHsKKwkJCXBjaV9mcmVlX2NvbnNpc3RlbnQocGhiYS0+cGNpZGV2LAorCQkJICBtZW1fZGVzY3ItPm1lbV9hcnJheVtqIC0gMV0uc2l6ZSwKKwkJCSAgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaiAtIDFdLnZpcnR1YWxfYWRkcmVzcywKKwkJCSAgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbaiAtIDFdLmJ1c19hZGRyZXNzLgorCQkJCXUuYTY0LmFkZHJlc3MpOworCQl9CisJCWtmcmVlKG1lbV9kZXNjci0+bWVtX2FycmF5KTsKKwkJbWVtX2Rlc2NyKys7CisJfQorCWtmcmVlKHBoYmEtPmluaXRfbWVtKTsKKwlrZnJlZShwaGJhLT5waHdpX2N0cmxyKTsKK30KKworc3RhdGljIGludCBiZWlzY3NpX2luaXRfY29udHJvbGxlcihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEpCit7CisJaW50IHJldCA9IC1FTk9NRU07CisKKwlyZXQgPSBiZWlzY3NpX2dldF9tZW1vcnkocGhiYSk7CisJaWYgKHJldCA8IDApIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwgImJlaXNjc2lfZGV2X3Byb2JlIC0iCisJCQkgICAgICJGYWlsZWQgaW4gYmVpc2NzaV9hbGxvY19tZW1vcnkgXG4iKTsKKwkJcmV0dXJuIHJldDsKKwl9CisKKwlyZXQgPSBod2lfaW5pdF9jb250cm9sbGVyKHBoYmEpOworCWlmIChyZXQpCisJCWdvdG8gZnJlZV9pbml0OworCVNFX0RFQlVHKERCR19MVkxfOCwgIlJldHVybiBzdWNjZXNzIGZyb20gYmVpc2NzaV9pbml0X2NvbnRyb2xsZXIiKTsKKwlyZXR1cm4gMDsKKworZnJlZV9pbml0OgorCWJlaXNjc2lfZnJlZV9tZW0ocGhiYSk7CisJcmV0dXJuIC1FTk9NRU07Cit9CisKK3N0YXRpYyBpbnQgYmVpc2NzaV9pbml0X3NnbF9oYW5kbGUoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXN0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciAqbWVtX2Rlc2NyX3NnbGgsICptZW1fZGVzY3Jfc2c7CisJc3RydWN0IHNnbF9oYW5kbGUgKnBzZ2xfaGFuZGxlOworCXN0cnVjdCBpc2NzaV9zZ2UgKnBmcmFnOworCXVuc2lnbmVkIGludCBhcnJfaW5kZXgsIGksIGlkeDsKKworCXBoYmEtPmlvX3NnbF9obmRsX2F2YmwgPSAwOworCXBoYmEtPmVoX3NnbF9obmRsX2F2YmwgPSAwOworCW1lbV9kZXNjcl9zZ2xoID0gcGhiYS0+aW5pdF9tZW07CisJbWVtX2Rlc2NyX3NnbGggKz0gSFdJX01FTV9TR0xIOworCWlmICgxID09IG1lbV9kZXNjcl9zZ2xoLT5udW1fZWxlbWVudHMpIHsKKwkJcGhiYS0+aW9fc2dsX2huZGxfYmFzZSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBzZ2xfaGFuZGxlICopICoKKwkJCQkJCSBwaGJhLT5wYXJhbXMuaW9zX3Blcl9jdHJsLAorCQkJCQkJIEdGUF9LRVJORUwpOworCQlpZiAoIXBoYmEtPmlvX3NnbF9obmRsX2Jhc2UpIHsKKwkJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkJICAgICAiTWVtIEFsbG9jIEZhaWxlZC4gRmFpbGluZyB0byBsb2FkXG4iKTsKKwkJCXJldHVybiAtRU5PTUVNOworCQl9CisJCXBoYmEtPmVoX3NnbF9obmRsX2Jhc2UgPSBremFsbG9jKHNpemVvZihzdHJ1Y3Qgc2dsX2hhbmRsZSAqKSAqCisJCQkJCQkgKHBoYmEtPnBhcmFtcy5pY2RzX3Blcl9jdHJsIC0KKwkJCQkJCSBwaGJhLT5wYXJhbXMuaW9zX3Blcl9jdHJsKSwKKwkJCQkJCSBHRlBfS0VSTkVMKTsKKwkJaWYgKCFwaGJhLT5laF9zZ2xfaG5kbF9iYXNlKSB7CisJCQlrZnJlZShwaGJhLT5pb19zZ2xfaG5kbF9iYXNlKTsKKwkJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkJICAgICAiTWVtIEFsbG9jIEZhaWxlZC4gRmFpbGluZyB0byBsb2FkXG4iKTsKKwkJCXJldHVybiAtRU5PTUVNOworCQl9CisJfSBlbHNlIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwKKwkJCSAgICAgIkhXSV9NRU1fU0dMSCBpcyBtb3JlIHRoYW4gb25lIGVsZW1lbnQuIgorCQkJICAgICAiRmFpbGluZyB0byBsb2FkXG4iKTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCisJYXJyX2luZGV4ID0gMDsKKwlpZHggPSAwOworCXdoaWxlIChpZHggPCBtZW1fZGVzY3Jfc2dsaC0+bnVtX2VsZW1lbnRzKSB7CisJCXBzZ2xfaGFuZGxlID0gbWVtX2Rlc2NyX3NnbGgtPm1lbV9hcnJheVtpZHhdLnZpcnR1YWxfYWRkcmVzczsKKworCQlmb3IgKGkgPSAwOyBpIDwgKG1lbV9kZXNjcl9zZ2xoLT5tZW1fYXJyYXlbaWR4XS5zaXplIC8KKwkJICAgICAgc2l6ZW9mKHN0cnVjdCBzZ2xfaGFuZGxlKSk7IGkrKykgeworCQkJaWYgKGFycl9pbmRleCA8IHBoYmEtPnBhcmFtcy5pb3NfcGVyX2N0cmwpIHsKKwkJCQlwaGJhLT5pb19zZ2xfaG5kbF9iYXNlW2Fycl9pbmRleF0gPSBwc2dsX2hhbmRsZTsKKwkJCQlwaGJhLT5pb19zZ2xfaG5kbF9hdmJsKys7CisJCQkJYXJyX2luZGV4Kys7CisJCQl9IGVsc2UgeworCQkJCXBoYmEtPmVoX3NnbF9obmRsX2Jhc2VbYXJyX2luZGV4IC0KKwkJCQkJcGhiYS0+cGFyYW1zLmlvc19wZXJfY3RybF0gPQorCQkJCQkJCQlwc2dsX2hhbmRsZTsKKwkJCQlhcnJfaW5kZXgrKzsKKwkJCQlwaGJhLT5laF9zZ2xfaG5kbF9hdmJsKys7CisJCQl9CisJCQlwc2dsX2hhbmRsZSsrOworCQl9CisJCWlkeCsrOworCX0KKwlTRV9ERUJVRyhEQkdfTFZMXzgsCisJCSAicGhiYS0+aW9fc2dsX2huZGxfYXZibD0lZCIKKwkJICJwaGJhLT5laF9zZ2xfaG5kbF9hdmJsPSVkIFxuIiwKKwkJIHBoYmEtPmlvX3NnbF9obmRsX2F2YmwsCisJCSBwaGJhLT5laF9zZ2xfaG5kbF9hdmJsKTsKKwltZW1fZGVzY3Jfc2cgPSBwaGJhLT5pbml0X21lbTsKKwltZW1fZGVzY3Jfc2cgKz0gSFdJX01FTV9TR0U7CisJU0VfREVCVUcoREJHX0xWTF84LCAiXG4gbWVtX2Rlc2NyX3NnLT5udW1fZWxlbWVudHM9JWQgXG4iLAorCQkgbWVtX2Rlc2NyX3NnLT5udW1fZWxlbWVudHMpOworCWFycl9pbmRleCA9IDA7CisJaWR4ID0gMDsKKwl3aGlsZSAoaWR4IDwgbWVtX2Rlc2NyX3NnLT5udW1fZWxlbWVudHMpIHsKKwkJcGZyYWcgPSBtZW1fZGVzY3Jfc2ctPm1lbV9hcnJheVtpZHhdLnZpcnR1YWxfYWRkcmVzczsKKworCQlmb3IgKGkgPSAwOworCQkgICAgIGkgPCAobWVtX2Rlc2NyX3NnLT5tZW1fYXJyYXlbaWR4XS5zaXplKSAvCisJCSAgICAgKHNpemVvZihzdHJ1Y3QgaXNjc2lfc2dlKSAqIHBoYmEtPnBhcmFtcy5udW1fc2dlX3Blcl9pbyk7CisJCSAgICAgaSsrKSB7CisJCQlpZiAoYXJyX2luZGV4IDwgcGhiYS0+cGFyYW1zLmlvc19wZXJfY3RybCkKKwkJCQlwc2dsX2hhbmRsZSA9IHBoYmEtPmlvX3NnbF9obmRsX2Jhc2VbYXJyX2luZGV4XTsKKwkJCWVsc2UKKwkJCQlwc2dsX2hhbmRsZSA9IHBoYmEtPmVoX3NnbF9obmRsX2Jhc2VbYXJyX2luZGV4IC0KKwkJCQkJCXBoYmEtPnBhcmFtcy5pb3NfcGVyX2N0cmxdOworCQkJcHNnbF9oYW5kbGUtPnBmcmFnID0gcGZyYWc7CisJCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3NnZSwgYWRkcl9oaSwgcGZyYWcsIDApOworCQkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV9zZ2UsIGFkZHJfbG8sIHBmcmFnLCAwKTsKKwkJCXBmcmFnICs9IHBoYmEtPnBhcmFtcy5udW1fc2dlX3Blcl9pbzsKKwkJCXBzZ2xfaGFuZGxlLT5zZ2xfaW5kZXggPQorCQkJCXBoYmEtPmZ3X2NvbmZpZy5pc2NzaV9jaWRfc3RhcnQgKyBhcnJfaW5kZXgrKzsKKwkJfQorCQlpZHgrKzsKKwl9CisJcGhiYS0+aW9fc2dsX2ZyZWVfaW5kZXggPSAwOworCXBoYmEtPmlvX3NnbF9hbGxvY19pbmRleCA9IDA7CisJcGhiYS0+ZWhfc2dsX2ZyZWVfaW5kZXggPSAwOworCXBoYmEtPmVoX3NnbF9hbGxvY19pbmRleCA9IDA7CisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgaGJhX3NldHVwX2NpZF90YmxzKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlpbnQgaSwgbmV3X2NpZDsKKworCXBoYmEtPmNpZF9hcnJheSA9IGttYWxsb2Moc2l6ZW9mKHZvaWQgKikgKiBwaGJhLT5wYXJhbXMuY3huc19wZXJfY3RybCwKKwkJCQkgIEdGUF9LRVJORUwpOworCWlmICghcGhiYS0+Y2lkX2FycmF5KSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsCisJCQkgICAgICJGYWlsZWQgdG8gYWxsb2NhdGUgbWVtb3J5IGluICIKKwkJCSAgICAgImhiYV9zZXR1cF9jaWRfdGJsc1xuIik7CisJCXJldHVybiAtRU5PTUVNOworCX0KKwlwaGJhLT5lcF9hcnJheSA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBpc2NzaV9lbmRwb2ludCAqKSAqCisJCQkJIHBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsICogMiwgR0ZQX0tFUk5FTCk7CisJaWYgKCFwaGJhLT5lcF9hcnJheSkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJICAgICAiRmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSBpbiAiCisJCQkgICAgICJoYmFfc2V0dXBfY2lkX3RibHMgXG4iKTsKKwkJa2ZyZWUocGhiYS0+Y2lkX2FycmF5KTsKKwkJcmV0dXJuIC1FTk9NRU07CisJfQorCW5ld19jaWQgPSBwaGJhLT5md19jb25maWcuaXNjc2lfaWNkX3N0YXJ0OworCWZvciAoaSA9IDA7IGkgPCBwaGJhLT5wYXJhbXMuY3huc19wZXJfY3RybDsgaSsrKSB7CisJCXBoYmEtPmNpZF9hcnJheVtpXSA9IG5ld19jaWQ7CisJCW5ld19jaWQgKz0gMjsKKwl9CisJcGhiYS0+YXZsYmxfY2lkcyA9IHBoYmEtPnBhcmFtcy5jeG5zX3Blcl9jdHJsOworCXJldHVybiAwOworfQorCitzdGF0aWMgdW5zaWduZWQgY2hhciBod2lfZW5hYmxlX2ludHIoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwgPSAmcGhiYS0+Y3RybDsKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0OworCXN0cnVjdCBiZV9xdWV1ZV9pbmZvICplcTsKKwl1OCBfX2lvbWVtICphZGRyOworCXUzMiByZWc7CisJdTMyIGVuYWJsZWQ7CisKKwlwaHdpX2N0cmxyID0gcGhiYS0+cGh3aV9jdHJscjsKKwlwaHdpX2NvbnRleHQgPSBwaHdpX2N0cmxyLT5waHdpX2N0eHQ7CisKKwllcSA9ICZwaHdpX2NvbnRleHQtPmJlX2VxLnE7CisJYWRkciA9ICh1OCBfX2lvbWVtICopICgodTggX19pb21lbSAqKSBjdHJsLT5wY2ljZmcgKworCQkJUENJQ0ZHX01FTUJBUl9DVFJMX0lOVF9DVFJMX09GRlNFVCk7CisJcmVnID0gaW9yZWFkMzIoYWRkcik7CisJU0VfREVCVUcoREJHX0xWTF84LCAicmVnID14JTA4eCBcbiIsIHJlZyk7CisKKwllbmFibGVkID0gcmVnICYgTUVNQkFSX0NUUkxfSU5UX0NUUkxfSE9TVElOVFJfTUFTSzsKKwlpZiAoIWVuYWJsZWQpIHsKKwkJcmVnIHw9IE1FTUJBUl9DVFJMX0lOVF9DVFJMX0hPU1RJTlRSX01BU0s7CisJCVNFX0RFQlVHKERCR19MVkxfOCwgInJlZyA9eCUwOHggYWRkcj0lcCBcbiIsIHJlZywgYWRkcik7CisJCWlvd3JpdGUzMihyZWcsIGFkZHIpOworCQlTRV9ERUJVRyhEQkdfTFZMXzgsICJlcS0+aWQ9JWQgXG4iLCBlcS0+aWQpOworCisJCWh3aV9yaW5nX2VxX2RiKHBoYmEsIGVxLT5pZCwgMCwgMCwgMSwgMSk7CisJfSBlbHNlCisJCXNob3N0X3ByaW50ayhLRVJOX1dBUk5JTkcsIHBoYmEtPnNob3N0LAorCQkJICAgICAiSW4gaHdpX2VuYWJsZV9pbnRyLCBOb3QgRW5hYmxlZCBcbiIpOworCXJldHVybiB0cnVlOworfQorCitzdGF0aWMgdm9pZCBod2lfZGlzYWJsZV9pbnRyKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsID0gJnBoYmEtPmN0cmw7CisKKwl1OCBfX2lvbWVtICphZGRyID0gY3RybC0+cGNpY2ZnICsgUENJQ0ZHX01FTUJBUl9DVFJMX0lOVF9DVFJMX09GRlNFVDsKKwl1MzIgcmVnID0gaW9yZWFkMzIoYWRkcik7CisKKwl1MzIgZW5hYmxlZCA9IHJlZyAmIE1FTUJBUl9DVFJMX0lOVF9DVFJMX0hPU1RJTlRSX01BU0s7CisJaWYgKGVuYWJsZWQpIHsKKwkJcmVnICY9IH5NRU1CQVJfQ1RSTF9JTlRfQ1RSTF9IT1NUSU5UUl9NQVNLOworCQlpb3dyaXRlMzIocmVnLCBhZGRyKTsKKwl9IGVsc2UKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgICJJbiBod2lfZGlzYWJsZV9pbnRyLCBBbHJlYWR5IERpc2FibGVkIFxuIik7Cit9CisKK3N0YXRpYyBpbnQgYmVpc2NzaV9pbml0X3BvcnQoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCWludCByZXQ7CisKKwlyZXQgPSBiZWlzY3NpX2luaXRfY29udHJvbGxlcihwaGJhKTsKKwlpZiAocmV0IDwgMCkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJICAgICAiYmVpc2NzaV9kZXZfcHJvYmUgLSBGYWlsZWQgaW4iCisJCQkgICAgICJiZWlzY3NpX2luaXRfY29udHJvbGxlciBcbiIpOworCQlyZXR1cm4gcmV0OworCX0KKwlyZXQgPSBiZWlzY3NpX2luaXRfc2dsX2hhbmRsZShwaGJhKTsKKwlpZiAocmV0IDwgMCkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJICAgICAiYmVpc2NzaV9kZXZfcHJvYmUgLSBGYWlsZWQgaW4iCisJCQkgICAgICJiZWlzY3NpX2luaXRfc2dsX2hhbmRsZSBcbiIpOworCQlnb3RvIGRvX2NsZWFudXBfY3RybHI7CisJfQorCisJaWYgKGhiYV9zZXR1cF9jaWRfdGJscyhwaGJhKSkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LAorCQkJICAgICAiRmFpbGVkIGluIGhiYV9zZXR1cF9jaWRfdGJsc1xuIik7CisJCWtmcmVlKHBoYmEtPmlvX3NnbF9obmRsX2Jhc2UpOworCQlrZnJlZShwaGJhLT5laF9zZ2xfaG5kbF9iYXNlKTsKKwkJZ290byBkb19jbGVhbnVwX2N0cmxyOworCX0KKworCXJldHVybiByZXQ7CisKK2RvX2NsZWFudXBfY3RybHI6CisJaHdpX2NsZWFudXAocGhiYSk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgaHdpX3B1cmdlX2VxKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSkKK3sKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0OworCXN0cnVjdCBiZV9xdWV1ZV9pbmZvICplcTsKKwlzdHJ1Y3QgYmVfZXFfZW50cnkgKmVxZSA9IE5VTEw7CisKKwlwaHdpX2N0cmxyID0gcGhiYS0+cGh3aV9jdHJscjsKKwlwaHdpX2NvbnRleHQgPSBwaHdpX2N0cmxyLT5waHdpX2N0eHQ7CisJZXEgPSAmcGh3aV9jb250ZXh0LT5iZV9lcS5xOworCWVxZSA9IHF1ZXVlX3RhaWxfbm9kZShlcSk7CisKKwl3aGlsZSAoZXFlLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9lcV9lbnRyeSwgdmFsaWQpIC8gMzJdCisJCQkJCQkmIEVRRV9WQUxJRF9NQVNLKSB7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfZXFfZW50cnksIHZhbGlkLCBlcWUsIDApOworCQlxdWV1ZV90YWlsX2luYyhlcSk7CisJCWVxZSA9IHF1ZXVlX3RhaWxfbm9kZShlcSk7CisJfQorfQorCitzdGF0aWMgdm9pZCBiZWlzY3NpX2NsZWFuX3BvcnQoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXVuc2lnbmVkIGNoYXIgbWdtdF9zdGF0dXM7CisKKwltZ210X3N0YXR1cyA9IG1nbXRfZXBmd19jbGVhbnVwKHBoYmEsIENNRF9DT05ORUNUSU9OX0NIVVRFXzApOworCWlmIChtZ210X3N0YXR1cykKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgICJtZ210X2VwZndfY2xlYW51cCBGQUlMRUQgXG4iKTsKKwlod2lfY2xlYW51cChwaGJhKTsKKwlod2lfcHVyZ2VfZXEocGhiYSk7CisJa2ZyZWUocGhiYS0+aW9fc2dsX2huZGxfYmFzZSk7CisJa2ZyZWUocGhiYS0+ZWhfc2dsX2huZGxfYmFzZSk7CisJa2ZyZWUocGhiYS0+Y2lkX2FycmF5KTsKKwlrZnJlZShwaGJhLT5lcF9hcnJheSk7Cit9CisKK3ZvaWQKK2JlaXNjc2lfb2ZmbG9hZF9jb25uZWN0aW9uKHN0cnVjdCBiZWlzY3NpX2Nvbm4gKmJlaXNjc2lfY29ubiwKKwkJCSAgIHN0cnVjdCBiZWlzY3NpX29mZmxvYWRfcGFyYW1zICpwYXJhbXMpCit7CisJc3RydWN0IHdyYl9oYW5kbGUgKnB3cmJfaGFuZGxlOworCXN0cnVjdCBpc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiICpwd3JiID0gTlVMTDsKKwlzdHJ1Y3QgYmVfbWVtX2Rlc2NyaXB0b3IgKm1lbV9kZXNjcjsKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEgPSBiZWlzY3NpX2Nvbm4tPnBoYmE7CisJdTMyIGRvb3JiZWxsID0gMDsKKworCS8qCisJICogV2UgY2FuIGFsd2F5cyB1c2UgMCBoZXJlIGJlY2F1c2UgaXQgaXMgcmVzZXJ2ZWQgYnkgbGliaXNjc2kgZm9yCisJICogbG9naW4vc3RhcnR1cCByZWxhdGVkIHRhc2tzLgorCSAqLworCXB3cmJfaGFuZGxlID0gYWxsb2Nfd3JiX2hhbmRsZShwaGJhLCBiZWlzY3NpX2Nvbm4tPmJlaXNjc2lfY29ubl9jaWQsIDApOworCXB3cmIgPSAoc3RydWN0IGlzY3NpX3RhcmdldF9jb250ZXh0X3VwZGF0ZV93cmIgKilwd3JiX2hhbmRsZS0+cHdyYjsKKwltZW1zZXQocHdyYiwgMCwgc2l6ZW9mKCpwd3JiKSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiLAorCQkgICAgICBtYXhfYnVyc3RfbGVuZ3RoLCBwd3JiLCBwYXJhbXMtPmR3W29mZnNldG9mCisJCSAgICAgIChzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLAorCQkgICAgICBtYXhfYnVyc3RfbGVuZ3RoKSAvIDMyXSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiLAorCQkgICAgICBtYXhfc2VuZF9kYXRhX3NlZ21lbnRfbGVuZ3RoLCBwd3JiLAorCQkgICAgICBwYXJhbXMtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2JlaXNjc2lfb2ZmbG9hZF9wYXJhbXMsCisJCSAgICAgIG1heF9zZW5kX2RhdGFfc2VnbWVudF9sZW5ndGgpIC8gMzJdKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3RhcmdldF9jb250ZXh0X3VwZGF0ZV93cmIsCisJCSAgICAgIGZpcnN0X2J1cnN0X2xlbmd0aCwKKwkJICAgICAgcHdyYiwKKwkJICAgICAgcGFyYW1zLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLAorCQkgICAgICBmaXJzdF9idXJzdF9sZW5ndGgpIC8gMzJdKTsKKworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwgZXJsLCBwd3JiLAorCQkgICAgICAocGFyYW1zLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLAorCQkgICAgICBlcmwpIC8gMzJdICYgT0ZGTERfUEFSQU1TX0VSTCkpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwgZGRlLCBwd3JiLAorCQkgICAgICAocGFyYW1zLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLAorCQkgICAgICBkZGUpIC8gMzJdICYgT0ZGTERfUEFSQU1TX0RERSkgPj4gMik7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiLCBoZGUsIHB3cmIsCisJCSAgICAgIChwYXJhbXMtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2JlaXNjc2lfb2ZmbG9hZF9wYXJhbXMsCisJCSAgICAgIGhkZSkgLyAzMl0gJiBPRkZMRF9QQVJBTVNfSERFKSA+PiAzKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3RhcmdldF9jb250ZXh0X3VwZGF0ZV93cmIsIGlyMnQsIHB3cmIsCisJCSAgICAgIChwYXJhbXMtPmR3W29mZnNldG9mKHN0cnVjdCBhbWFwX2JlaXNjc2lfb2ZmbG9hZF9wYXJhbXMsCisJCSAgICAgIGlyMnQpIC8gMzJdICYgT0ZGTERfUEFSQU1TX0lSMlQpID4+IDQpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwgaW1kLCBwd3JiLAorCQkgICAgICAocGFyYW1zLT5kd1tvZmZzZXRvZihzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zLAorCQkgICAgICAgaW1kKSAvIDMyXSAmIE9GRkxEX1BBUkFNU19JTUQpID4+IDUpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwgc3RhdF9zbiwKKwkJICAgICAgcHdyYiwKKwkJICAgICAgKHBhcmFtcy0+ZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfYmVpc2NzaV9vZmZsb2FkX3BhcmFtcywKKwkJICAgICAgZXhwX3N0YXRzbikgLyAzMl0gKyAxKSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiLCB0eXBlLCBwd3JiLAorCQkgICAgICAweDcpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwgd3JiX2lkeCwKKwkJICAgICAgcHdyYiwgcHdyYl9oYW5kbGUtPndyYl9pbmRleCk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiLCBwdHIybmV4dHdyYiwKKwkJICAgICAgcHdyYiwgcHdyYl9oYW5kbGUtPm54dF93cmJfaW5kZXgpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwKKwkJCXNlc3Npb25fc3RhdGUsIHB3cmIsIDApOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwgY29tcGx0b25hY2ssCisJCSAgICAgIHB3cmIsIDEpOworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwgbm90cHJlZGJscSwKKwkJICAgICAgcHdyYiwgMCk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiLCBtb2RlLCBwd3JiLAorCQkgICAgICAwKTsKKworCW1lbV9kZXNjciA9IHBoYmEtPmluaXRfbWVtOworCW1lbV9kZXNjciArPSBJU0NTSV9NRU1fR0xPQkFMX0hFQURFUjsKKworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfdGFyZ2V0X2NvbnRleHRfdXBkYXRlX3dyYiwKKwkJCXBhZF9idWZmZXJfYWRkcl9oaSwgcHdyYiwKKwkJICAgICAgbWVtX2Rlc2NyLT5tZW1fYXJyYXlbMF0uYnVzX2FkZHJlc3MudS5hMzIuYWRkcmVzc19oaSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiLAorCQkJcGFkX2J1ZmZlcl9hZGRyX2xvLCBwd3JiLAorCQkgICAgICBtZW1fZGVzY3ItPm1lbV9hcnJheVswXS5idXNfYWRkcmVzcy51LmEzMi5hZGRyZXNzX2xvKTsKKworCWJlX2R3c19sZV90b19jcHUocHdyYiwgc2l6ZW9mKHN0cnVjdCBpc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiKSk7CisKKwlkb29yYmVsbCB8PSBiZWlzY3NpX2Nvbm4tPmJlaXNjc2lfY29ubl9jaWQgJiBEQl9XUkJfUE9TVF9DSURfTUFTSzsKKwlkb29yYmVsbCB8PSAocHdyYl9oYW5kbGUtPndyYl9pbmRleCAmIERCX0RFRl9QRFVfV1JCX0lOREVYX01BU0spIDw8CisJCQkJCURCX0RFRl9QRFVfV1JCX0lOREVYX1NISUZUOworCWRvb3JiZWxsIHw9IDEgPDwgREJfREVGX1BEVV9OVU1fUE9TVEVEX1NISUZUOworCisJaW93cml0ZTMyKGRvb3JiZWxsLCBwaGJhLT5kYl92YSArIERCX1RYVUxQMF9PRkZTRVQpOworfQorCitzdGF0aWMgdm9pZCBiZWlzY3NpX3BhcnNlX3BkdShzdHJ1Y3QgaXNjc2lfY29ubiAqY29ubiwgaXR0X3QgaXR0LAorCQkJICAgICAgaW50ICppbmRleCwgaW50ICphZ2UpCit7CisJKmluZGV4ID0gYmUzMl90b19jcHUoaXR0KSA+PiAxNjsKKwlpZiAoYWdlKQorCQkqYWdlID0gY29ubi0+c2Vzc2lvbi0+YWdlOworfQorCisvKioKKyAqIGJlaXNjc2lfYWxsb2NfcGR1IC0gYWxsb2NhdGVzIHBkdSBhbmQgcmVsYXRlZCByZXNvdXJjZXMKKyAqIEB0YXNrOiBsaWJpc2NzaSB0YXNrCisgKiBAb3Bjb2RlOiBvcGNvZGUgb2YgcGR1IGZvciB0YXNrCisgKgorICogVGhpcyBpcyBjYWxsZWQgd2l0aCB0aGUgc2Vzc2lvbiBsb2NrIGhlbGQuIEl0IHdpbGwgYWxsb2NhdGUKKyAqIHRoZSB3cmIgYW5kIHNnbCBpZiBuZWVkZWQgZm9yIHRoZSBjb21tYW5kLiBBbmQgaXQgd2lsbCBwcmVwCisgKiB0aGUgcGR1J3MgaXR0LiBiZWlzY3NpX3BhcnNlX3BkdSB3aWxsIGxhdGVyIHRyYW5zbGF0ZQorICogdGhlIHBkdSBpdHQgdG8gdGhlIGxpYmlzY3NpIHRhc2sgaXR0LgorICovCitzdGF0aWMgaW50IGJlaXNjc2lfYWxsb2NfcGR1KHN0cnVjdCBpc2NzaV90YXNrICp0YXNrLCB1aW50OF90IG9wY29kZSkKK3sKKwlzdHJ1Y3QgYmVpc2NzaV9pb190YXNrICppb190YXNrID0gdGFzay0+ZGRfZGF0YTsKKwlzdHJ1Y3QgaXNjc2lfY29ubiAqY29ubiA9IHRhc2stPmNvbm47CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uID0gY29ubi0+ZGRfZGF0YTsKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEgPSBiZWlzY3NpX2Nvbm4tPnBoYmE7CisJc3RydWN0IGh3aV93cmJfY29udGV4dCAqcHdyYl9jb250ZXh0OworCXN0cnVjdCBod2lfY29udHJvbGxlciAqcGh3aV9jdHJscjsKKwlpdHRfdCBpdHQ7CisJc3RydWN0IGJlaXNjc2lfc2Vzc2lvbiAqYmVpc2NzaV9zZXNzID0gYmVpc2NzaV9jb25uLT5iZWlzY3NpX3Nlc3M7CisJZG1hX2FkZHJfdCBwYWRkcjsKKworCWlvX3Rhc2stPmNtZF9iaHMgPSBwY2lfcG9vbF9hbGxvYyhiZWlzY3NpX3Nlc3MtPmJoc19wb29sLAorCQkJCQkgIEdGUF9LRVJORUwsICZwYWRkcik7CisKKwlpZiAoIWlvX3Rhc2stPmNtZF9iaHMpCisJCXJldHVybiAtRU5PTUVNOworCisJaW9fdGFzay0+YmhzX3BhLnUuYTY0LmFkZHJlc3MgPSBwYWRkcjsKKwlpb190YXNrLT5wd3JiX2hhbmRsZSA9IGFsbG9jX3dyYl9oYW5kbGUocGhiYSwKKwkJCQkJCWJlaXNjc2lfY29ubi0+YmVpc2NzaV9jb25uX2NpZCwKKwkJCQkJCXRhc2stPml0dCk7CisJaW9fdGFzay0+cHdyYl9oYW5kbGUtPnBpb19oYW5kbGUgPSB0YXNrOworCWlvX3Rhc2stPmNvbm4gPSBiZWlzY3NpX2Nvbm47CisKKwl0YXNrLT5oZHIgPSAoc3RydWN0IGlzY3NpX2hkciAqKSZpb190YXNrLT5jbWRfYmhzLT5pc2NzaV9oZHI7CisJdGFzay0+aGRyX21heCA9IHNpemVvZihzdHJ1Y3QgYmVfY21kX2Jocyk7CisKKwlpZiAodGFzay0+c2MpIHsKKwkJc3Bpbl9sb2NrKCZwaGJhLT5pb19zZ2xfbG9jayk7CisJCWlvX3Rhc2stPnBzZ2xfaGFuZGxlID0gYWxsb2NfaW9fc2dsX2hhbmRsZShwaGJhKTsKKwkJc3Bpbl91bmxvY2soJnBoYmEtPmlvX3NnbF9sb2NrKTsKKwkJaWYgKCFpb190YXNrLT5wc2dsX2hhbmRsZSkKKwkJCWdvdG8gZnJlZV9obmRsczsKKworCX0gZWxzZSB7CisJCWlvX3Rhc2stPnNjc2lfY21uZCA9IE5VTEw7CisJCWlmICgodGFzay0+aGRyLT5vcGNvZGUgJiBJU0NTSV9PUENPREVfTUFTSykgPT0gSVNDU0lfT1BfTE9HSU4pIHsKKwkJCWlmICghYmVpc2NzaV9jb25uLT5sb2dpbl9pbl9wcm9ncmVzcykgeworCQkJCXNwaW5fbG9jaygmcGhiYS0+bWdtdF9zZ2xfbG9jayk7CisJCQkJaW9fdGFzay0+cHNnbF9oYW5kbGUgPSAoc3RydWN0IHNnbF9oYW5kbGUgKikKKwkJCQkJCWFsbG9jX21nbXRfc2dsX2hhbmRsZShwaGJhKTsKKwkJCQlzcGluX3VubG9jaygmcGhiYS0+bWdtdF9zZ2xfbG9jayk7CisJCQkJaWYgKCFpb190YXNrLT5wc2dsX2hhbmRsZSkKKwkJCQkJZ290byBmcmVlX2huZGxzOworCisJCQkJYmVpc2NzaV9jb25uLT5sb2dpbl9pbl9wcm9ncmVzcyA9IDE7CisJCQkJYmVpc2NzaV9jb25uLT5wbG9naW5fc2dsX2hhbmRsZSA9CisJCQkJCQkJaW9fdGFzay0+cHNnbF9oYW5kbGU7CisJCQl9IGVsc2UgeworCQkJCWlvX3Rhc2stPnBzZ2xfaGFuZGxlID0KKwkJCQkJCWJlaXNjc2lfY29ubi0+cGxvZ2luX3NnbF9oYW5kbGU7CisJCQl9CisJCX0gZWxzZSB7CisJCQlzcGluX2xvY2soJnBoYmEtPm1nbXRfc2dsX2xvY2spOworCQkJaW9fdGFzay0+cHNnbF9oYW5kbGUgPSBhbGxvY19tZ210X3NnbF9oYW5kbGUocGhiYSk7CisJCQlzcGluX3VubG9jaygmcGhiYS0+bWdtdF9zZ2xfbG9jayk7CisJCQlpZiAoIWlvX3Rhc2stPnBzZ2xfaGFuZGxlKQorCQkJCWdvdG8gZnJlZV9obmRsczsKKwkJfQorCX0KKwlpdHQgPSAoaXR0X3QpIGNwdV90b19iZTMyKCgodW5zaWduZWQgaW50KXRhc2stPml0dCA8PCAxNikgfAorCQkJKHVuc2lnbmVkIGludCkoaW9fdGFzay0+cHNnbF9oYW5kbGUtPnNnbF9pbmRleCkpOworCWlvX3Rhc2stPmNtZF9iaHMtPmlzY3NpX2hkci5pdHQgPSBpdHQ7CisJcmV0dXJuIDA7CisKK2ZyZWVfaG5kbHM6CisJcGh3aV9jdHJsciA9IHBoYmEtPnBod2lfY3RybHI7CisJcHdyYl9jb250ZXh0ID0gJnBod2lfY3RybHItPndyYl9jb250ZXh0W2JlaXNjc2lfY29ubi0+YmVpc2NzaV9jb25uX2NpZF07CisJZnJlZV93cmJfaGFuZGxlKHBoYmEsIHB3cmJfY29udGV4dCwgaW9fdGFzay0+cHdyYl9oYW5kbGUpOworCWlvX3Rhc2stPnB3cmJfaGFuZGxlID0gTlVMTDsKKwlwY2lfcG9vbF9mcmVlKGJlaXNjc2lfc2Vzcy0+YmhzX3Bvb2wsIGlvX3Rhc2stPmNtZF9iaHMsCisJCSAgICAgIGlvX3Rhc2stPmJoc19wYS51LmE2NC5hZGRyZXNzKTsKKwlTRV9ERUJVRyhEQkdfTFZMXzEsICJBbGxvYyBvZiBTR0xfSUNEIEZhaWxlZCBcbiIpOworCXJldHVybiAtRU5PTUVNOworfQorCitzdGF0aWMgdm9pZCBiZWlzY3NpX2NsZWFudXBfdGFzayhzdHJ1Y3QgaXNjc2lfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgYmVpc2NzaV9pb190YXNrICppb190YXNrID0gdGFzay0+ZGRfZGF0YTsKKwlzdHJ1Y3QgaXNjc2lfY29ubiAqY29ubiA9IHRhc2stPmNvbm47CisJc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uID0gY29ubi0+ZGRfZGF0YTsKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEgPSBiZWlzY3NpX2Nvbm4tPnBoYmE7CisJc3RydWN0IGJlaXNjc2lfc2Vzc2lvbiAqYmVpc2NzaV9zZXNzID0gYmVpc2NzaV9jb25uLT5iZWlzY3NpX3Nlc3M7CisJc3RydWN0IGh3aV93cmJfY29udGV4dCAqcHdyYl9jb250ZXh0OworCXN0cnVjdCBod2lfY29udHJvbGxlciAqcGh3aV9jdHJscjsKKworCXBod2lfY3RybHIgPSBwaGJhLT5waHdpX2N0cmxyOworCXB3cmJfY29udGV4dCA9ICZwaHdpX2N0cmxyLT53cmJfY29udGV4dFtiZWlzY3NpX2Nvbm4tPmJlaXNjc2lfY29ubl9jaWRdOworCWlmIChpb190YXNrLT5wd3JiX2hhbmRsZSkgeworCQlmcmVlX3dyYl9oYW5kbGUocGhiYSwgcHdyYl9jb250ZXh0LCBpb190YXNrLT5wd3JiX2hhbmRsZSk7CisJCWlvX3Rhc2stPnB3cmJfaGFuZGxlID0gTlVMTDsKKwl9CisKKwlpZiAoaW9fdGFzay0+Y21kX2JocykgeworCQlwY2lfcG9vbF9mcmVlKGJlaXNjc2lfc2Vzcy0+YmhzX3Bvb2wsIGlvX3Rhc2stPmNtZF9iaHMsCisJCQkgICAgICBpb190YXNrLT5iaHNfcGEudS5hNjQuYWRkcmVzcyk7CisJfQorCisJaWYgKHRhc2stPnNjKSB7CisJCWlmIChpb190YXNrLT5wc2dsX2hhbmRsZSkgeworCQkJc3Bpbl9sb2NrKCZwaGJhLT5pb19zZ2xfbG9jayk7CisJCQlmcmVlX2lvX3NnbF9oYW5kbGUocGhiYSwgaW9fdGFzay0+cHNnbF9oYW5kbGUpOworCQkJc3Bpbl91bmxvY2soJnBoYmEtPmlvX3NnbF9sb2NrKTsKKwkJCWlvX3Rhc2stPnBzZ2xfaGFuZGxlID0gTlVMTDsKKwkJfQorCX0gZWxzZSB7CisJCWlmICgodGFzay0+aGRyLT5vcGNvZGUgJiBJU0NTSV9PUENPREVfTUFTSykgPT0gSVNDU0lfT1BfTE9HSU4pCisJCQlyZXR1cm47CisJCWlmIChpb190YXNrLT5wc2dsX2hhbmRsZSkgeworCQkJc3Bpbl9sb2NrKCZwaGJhLT5tZ210X3NnbF9sb2NrKTsKKwkJCWZyZWVfbWdtdF9zZ2xfaGFuZGxlKHBoYmEsIGlvX3Rhc2stPnBzZ2xfaGFuZGxlKTsKKwkJCXNwaW5fdW5sb2NrKCZwaGJhLT5tZ210X3NnbF9sb2NrKTsKKwkJCWlvX3Rhc2stPnBzZ2xfaGFuZGxlID0gTlVMTDsKKwkJfQorCX0KK30KKworc3RhdGljIGludCBiZWlzY3NpX2lvdGFzayhzdHJ1Y3QgaXNjc2lfdGFzayAqdGFzaywgc3RydWN0IHNjYXR0ZXJsaXN0ICpzZywKKwkJCSAgdW5zaWduZWQgaW50IG51bV9zZywgdW5zaWduZWQgaW50IHhmZXJsZW4sCisJCQkgIHVuc2lnbmVkIGludCB3cml0ZWRpcikKK3sKKworCXN0cnVjdCBiZWlzY3NpX2lvX3Rhc2sgKmlvX3Rhc2sgPSB0YXNrLT5kZF9kYXRhOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gdGFzay0+Y29ubjsKKwlzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4gPSBjb25uLT5kZF9kYXRhOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSA9IGJlaXNjc2lfY29ubi0+cGhiYTsKKwlzdHJ1Y3QgaXNjc2lfd3JiICpwd3JiID0gTlVMTDsKKwl1bnNpZ25lZCBpbnQgZG9vcmJlbGwgPSAwOworCisJcHdyYiA9IGlvX3Rhc2stPnB3cmJfaGFuZGxlLT5wd3JiOworCWlvX3Rhc2stPmNtZF9iaHMtPmlzY3NpX2hkci5leHBfc3RhdHNuID0gMDsKKwlpb190YXNrLT5iaHNfbGVuID0gc2l6ZW9mKHN0cnVjdCBiZV9jbWRfYmhzKTsKKworCWlmICh3cml0ZWRpcikgeworCQlTRV9ERUJVRyhEQkdfTFZMXzQsICIgV1JJVEUgQ29tbWFuZCBcdCIpOworCQltZW1zZXQoJmlvX3Rhc2stPmNtZF9iaHMtPmlzY3NpX2RhdGFfcGR1LCAwLCA0OCk7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfcGR1X2RhdGFfb3V0LCBpdHQsCisJCQkgICAgICAmaW9fdGFzay0+Y21kX2Jocy0+aXNjc2lfZGF0YV9wZHUsCisJCQkgICAgICAodW5zaWduZWQgaW50KWlvX3Rhc2stPmNtZF9iaHMtPmlzY3NpX2hkci5pdHQpOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX3BkdV9kYXRhX291dCwgb3Bjb2RlLAorCQkJICAgICAgJmlvX3Rhc2stPmNtZF9iaHMtPmlzY3NpX2RhdGFfcGR1LAorCQkJICAgICAgSVNDU0lfT1BDT0RFX1NDU0lfREFUQV9PVVQpOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX3BkdV9kYXRhX291dCwgZmluYWxfYml0LAorCQkJICAgICAgJmlvX3Rhc2stPmNtZF9iaHMtPmlzY3NpX2RhdGFfcGR1LCAxKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHR5cGUsIHB3cmIsIElOSV9XUl9DTUQpOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgZHNwLCBwd3JiLCAxKTsKKwl9IGVsc2UgeworCQlTRV9ERUJVRyhEQkdfTFZMXzQsICJSRUFEIENvbW1hbmQgXHQiKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHR5cGUsIHB3cmIsIElOSV9SRF9DTUQpOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgZHNwLCBwd3JiLCAwKTsKKwl9CisJbWVtY3B5KCZpb190YXNrLT5jbWRfYmhzLT5pc2NzaV9kYXRhX3BkdS4KKwkgICAgICAgZHdbb2Zmc2V0b2Yoc3RydWN0IGFtYXBfcGR1X2RhdGFfb3V0LCBsdW4pIC8gMzJdLAorCSAgICAgICBpb190YXNrLT5jbWRfYmhzLT5pc2NzaV9oZHIubHVuLCBzaXplb2Yoc3RydWN0IHNjc2lfbHVuKSk7CisKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgbHVuLCBwd3JiLAorCQkgICAgICBjcHVfdG9fYmUxNigodW5zaWduZWQgc2hvcnQpaW9fdGFzay0+Y21kX2Jocy0+aXNjc2lfaGRyLgorCQkJCSAgbHVuWzBdKSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHIydF9leHBfZHRsLCBwd3JiLCB4ZmVybGVuKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgd3JiX2lkeCwgcHdyYiwKKwkJICAgICAgaW9fdGFzay0+cHdyYl9oYW5kbGUtPndyYl9pbmRleCk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIGNtZHNuX2l0dCwgcHdyYiwKKwkJICAgICAgYmUzMl90b19jcHUodGFzay0+Y21kc24pKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgc2dsX2ljZF9pZHgsIHB3cmIsCisJCSAgICAgIGlvX3Rhc2stPnBzZ2xfaGFuZGxlLT5zZ2xfaW5kZXgpOworCisJaHdpX3dyaXRlX3NnbChwd3JiLCBzZywgbnVtX3NnLCBpb190YXNrKTsKKworCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCBwdHIybmV4dHdyYiwgcHdyYiwKKwkJICAgICAgaW9fdGFzay0+cHdyYl9oYW5kbGUtPm54dF93cmJfaW5kZXgpOworCWJlX2R3c19sZV90b19jcHUocHdyYiwgc2l6ZW9mKHN0cnVjdCBpc2NzaV93cmIpKTsKKworCWRvb3JiZWxsIHw9IGJlaXNjc2lfY29ubi0+YmVpc2NzaV9jb25uX2NpZCAmIERCX1dSQl9QT1NUX0NJRF9NQVNLOworCWRvb3JiZWxsIHw9IChpb190YXNrLT5wd3JiX2hhbmRsZS0+d3JiX2luZGV4ICYKKwkJICAgICBEQl9ERUZfUERVX1dSQl9JTkRFWF9NQVNLKSA8PCBEQl9ERUZfUERVX1dSQl9JTkRFWF9TSElGVDsKKwlkb29yYmVsbCB8PSAxIDw8IERCX0RFRl9QRFVfTlVNX1BPU1RFRF9TSElGVDsKKworCWlvd3JpdGUzMihkb29yYmVsbCwgcGhiYS0+ZGJfdmEgKyBEQl9UWFVMUDBfT0ZGU0VUKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiZWlzY3NpX210YXNrKHN0cnVjdCBpc2NzaV90YXNrICp0YXNrKQoreworCXN0cnVjdCBiZWlzY3NpX2lvX3Rhc2sgKmFib3J0ZWRfaW9fdGFzaywgKmlvX3Rhc2sgPSB0YXNrLT5kZF9kYXRhOworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uID0gdGFzay0+Y29ubjsKKwlzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4gPSBjb25uLT5kZF9kYXRhOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSA9IGJlaXNjc2lfY29ubi0+cGhiYTsKKwlzdHJ1Y3QgaXNjc2lfd3JiICpwd3JiID0gTlVMTDsKKwl1bnNpZ25lZCBpbnQgZG9vcmJlbGwgPSAwOworCXN0cnVjdCBpc2NzaV90YXNrICphYm9ydGVkX3Rhc2s7CisKKwlwd3JiID0gaW9fdGFzay0+cHdyYl9oYW5kbGUtPnB3cmI7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIGNtZHNuX2l0dCwgcHdyYiwKKwkJICAgICAgYmUzMl90b19jcHUodGFzay0+Y21kc24pKTsKKwlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgd3JiX2lkeCwgcHdyYiwKKwkJICAgICAgaW9fdGFzay0+cHdyYl9oYW5kbGUtPndyYl9pbmRleCk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHNnbF9pY2RfaWR4LCBwd3JiLAorCQkgICAgICBpb190YXNrLT5wc2dsX2hhbmRsZS0+c2dsX2luZGV4KTsKKworCXN3aXRjaCAodGFzay0+aGRyLT5vcGNvZGUgJiBJU0NTSV9PUENPREVfTUFTSykgeworCWNhc2UgSVNDU0lfT1BfTE9HSU46CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCB0eXBlLCBwd3JiLCBUR1RfRE1fQ01EKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIGRtc2csIHB3cmIsIDApOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgY21kc25faXR0LCBwd3JiLCAxKTsKKwkJaHdpX3dyaXRlX2J1ZmZlcihwd3JiLCB0YXNrKTsKKwkJYnJlYWs7CisJY2FzZSBJU0NTSV9PUF9OT09QX09VVDoKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHR5cGUsIHB3cmIsIElOSV9SRF9DTUQpOworCQlod2lfd3JpdGVfYnVmZmVyKHB3cmIsIHRhc2spOworCQlicmVhazsKKwljYXNlIElTQ1NJX09QX1RFWFQ6CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCB0eXBlLCBwd3JiLCBJTklfV1JfQ01EKTsKKwkJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIGRzcCwgcHdyYiwgMSk7CisJCWh3aV93cml0ZV9idWZmZXIocHdyYiwgdGFzayk7CisJCWJyZWFrOworCWNhc2UgSVNDU0lfT1BfU0NTSV9UTUZVTkM6CisJCWFib3J0ZWRfdGFzayA9IGlzY3NpX2l0dF90b190YXNrKGNvbm4sCisJCQkJCSgoc3RydWN0IGlzY3NpX3RtICopdGFzay0+aGRyKS0+cnR0KTsKKwkJIGlmICghYWJvcnRlZF90YXNrKQorCQkJcmV0dXJuIDA7CisJCWFib3J0ZWRfaW9fdGFzayA9IGFib3J0ZWRfdGFzay0+ZGRfZGF0YTsKKwkJaWYgKCFhYm9ydGVkX2lvX3Rhc2stPnNjc2lfY21uZCkKKwkJCXJldHVybiAwOworCisJCW1nbXRfaW52YWxpZGF0ZV9pY2RzKHBoYmEsCisJCQkJICAgICBhYm9ydGVkX2lvX3Rhc2stPnBzZ2xfaGFuZGxlLT5zZ2xfaW5kZXgsCisJCQkJICAgICBiZWlzY3NpX2Nvbm4tPmJlaXNjc2lfY29ubl9jaWQpOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgdHlwZSwgcHdyYiwgSU5JX1RNRl9DTUQpOworCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgZG1zZywgcHdyYiwgMCk7CisJCWh3aV93cml0ZV9idWZmZXIocHdyYiwgdGFzayk7CisJCWJyZWFrOworCWNhc2UgSVNDU0lfT1BfTE9HT1VUOgorCQlBTUFQX1NFVF9CSVRTKHN0cnVjdCBhbWFwX2lzY3NpX3dyYiwgZG1zZywgcHdyYiwgMCk7CisJCUFNQVBfU0VUX0JJVFMoc3RydWN0IGFtYXBfaXNjc2lfd3JiLCB0eXBlLCBwd3JiLAorCQkJCUhXSF9UWVBFX0xPR09VVCk7CisJCWh3aV93cml0ZV9idWZmZXIocHdyYiwgdGFzayk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJU0VfREVCVUcoREJHX0xWTF8xLCAib3Bjb2RlID0lZCBOb3Qgc3VwcG9ydGVkIFxuIiwKKwkJCSB0YXNrLT5oZHItPm9wY29kZSAmIElTQ1NJX09QQ09ERV9NQVNLKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHIydF9leHBfZHRsLCBwd3JiLAorCQkgICAgICBiZTMyX3RvX2NwdSh0YXNrLT5kYXRhX2NvdW50KSk7CisJQU1BUF9TRVRfQklUUyhzdHJ1Y3QgYW1hcF9pc2NzaV93cmIsIHB0cjJuZXh0d3JiLCBwd3JiLAorCQkgICAgICBpb190YXNrLT5wd3JiX2hhbmRsZS0+bnh0X3dyYl9pbmRleCk7CisJYmVfZHdzX2xlX3RvX2NwdShwd3JiLCBzaXplb2Yoc3RydWN0IGlzY3NpX3dyYikpOworCisJZG9vcmJlbGwgfD0gYmVpc2NzaV9jb25uLT5iZWlzY3NpX2Nvbm5fY2lkICYgREJfV1JCX1BPU1RfQ0lEX01BU0s7CisJZG9vcmJlbGwgfD0gKGlvX3Rhc2stPnB3cmJfaGFuZGxlLT53cmJfaW5kZXggJgorCQkgICAgIERCX0RFRl9QRFVfV1JCX0lOREVYX01BU0spIDw8IERCX0RFRl9QRFVfV1JCX0lOREVYX1NISUZUOworCWRvb3JiZWxsIHw9IDEgPDwgREJfREVGX1BEVV9OVU1fUE9TVEVEX1NISUZUOworCWlvd3JpdGUzMihkb29yYmVsbCwgcGhiYS0+ZGJfdmEgKyBEQl9UWFVMUDBfT0ZGU0VUKTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBiZWlzY3NpX3Rhc2tfeG1pdChzdHJ1Y3QgaXNjc2lfdGFzayAqdGFzaykKK3sKKwlzdHJ1Y3QgaXNjc2lfY29ubiAqY29ubiA9IHRhc2stPmNvbm47CisJc3RydWN0IGJlaXNjc2lfaW9fdGFzayAqaW9fdGFzayA9IHRhc2stPmRkX2RhdGE7CisJc3RydWN0IHNjc2lfY21uZCAqc2MgPSB0YXNrLT5zYzsKKwlzdHJ1Y3QgYmVpc2NzaV9jb25uICpiZWlzY3NpX2Nvbm4gPSBjb25uLT5kZF9kYXRhOworCXN0cnVjdCBzY2F0dGVybGlzdCAqc2c7CisJaW50IG51bV9zZzsKKwl1bnNpZ25lZCBpbnQgIHdyaXRlZGlyID0gMCwgeGZlcmxlbiA9IDA7CisKKwlTRV9ERUJVRyhEQkdfTFZMXzQsICJcbiBjaWQ9JWQgSW4gYmVpc2NzaV90YXNrX3htaXQgdGFzaz0lcCBjb25uPSVwIFx0IgorCQkgImJlaXNjc2lfY29ubj0lcCBcbiIsIGJlaXNjc2lfY29ubi0+YmVpc2NzaV9jb25uX2NpZCwKKwkJIHRhc2ssIGNvbm4sIGJlaXNjc2lfY29ubik7CisJaWYgKCFzYykKKwkJcmV0dXJuIGJlaXNjc2lfbXRhc2sodGFzayk7CisKKwlpb190YXNrLT5zY3NpX2NtbmQgPSBzYzsKKwludW1fc2cgPSBzY3NpX2RtYV9tYXAoc2MpOworCWlmIChudW1fc2cgPCAwKSB7CisJCVNFX0RFQlVHKERCR19MVkxfMSwgIiBzY3NpX2RtYV9tYXAgRmFpbGVkXG4iKQorCQlyZXR1cm4gbnVtX3NnOworCX0KKwlTRV9ERUJVRyhEQkdfTFZMXzQsICJ4ZmVybGVuPTB4JTA4eCBzY21kPSVwIG51bV9zZz0lZCBzZXJudW09JWx1XG4iLAorCQkgIChzY3NpX2J1ZmZsZW4oc2MpKSwgc2MsIG51bV9zZywgc2MtPnNlcmlhbF9udW1iZXIpOworCXhmZXJsZW4gPSBzY3NpX2J1ZmZsZW4oc2MpOworCXNnID0gc2NzaV9zZ2xpc3Qoc2MpOworCWlmIChzYy0+c2NfZGF0YV9kaXJlY3Rpb24gPT0gRE1BX1RPX0RFVklDRSkgeworCQl3cml0ZWRpciA9IDE7CisJCVNFX0RFQlVHKERCR19MVkxfNCwgInRhc2stPmltbV9jb3VudD0weCUwOHggXG4iLAorCQkJIHRhc2stPmltbV9jb3VudCk7CisJfSBlbHNlCisJCXdyaXRlZGlyID0gMDsKKwlyZXR1cm4gYmVpc2NzaV9pb3Rhc2sodGFzaywgc2csIG51bV9zZywgeGZlcmxlbiwgd3JpdGVkaXIpOworfQorCitzdGF0aWMgdm9pZCBiZWlzY3NpX3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAqcGNpZGV2KQoreworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSA9IE5VTEw7CisKKwlwaGJhID0gKHN0cnVjdCBiZWlzY3NpX2hiYSAqKXBjaV9nZXRfZHJ2ZGF0YShwY2lkZXYpOworCWlmICghcGhiYSkgeworCQlkZXZfZXJyKCZwY2lkZXYtPmRldiwgImJlaXNjc2lfcmVtb3ZlIGNhbGxlZCB3aXRoIG5vIHBoYmEgXG4iKTsKKwkJcmV0dXJuOworCX0KKworCWh3aV9kaXNhYmxlX2ludHIocGhiYSk7CisJaWYgKHBoYmEtPnBjaWRldi0+aXJxKQorCQlmcmVlX2lycShwaGJhLT5wY2lkZXYtPmlycSwgcGhiYSk7CisJZGVzdHJveV93b3JrcXVldWUocGhiYS0+d3EpOworCWlmIChibGtfaW9wb2xsX2VuYWJsZWQpCisJCWJsa19pb3BvbGxfZGlzYWJsZSgmcGhiYS0+aW9wb2xsKTsKKworCWJlaXNjc2lfY2xlYW5fcG9ydChwaGJhKTsKKwliZWlzY3NpX2ZyZWVfbWVtKHBoYmEpOworCWJlaXNjc2lfdW5tYXBfcGNpX2Z1bmN0aW9uKHBoYmEpOworCXBjaV9mcmVlX2NvbnNpc3RlbnQocGhiYS0+cGNpZGV2LAorCQkJICAgIHBoYmEtPmN0cmwubWJveF9tZW1fYWxsb2NlZC5zaXplLAorCQkJICAgIHBoYmEtPmN0cmwubWJveF9tZW1fYWxsb2NlZC52YSwKKwkJCSAgICBwaGJhLT5jdHJsLm1ib3hfbWVtX2FsbG9jZWQuZG1hKTsKKwlpc2NzaV9ob3N0X3JlbW92ZShwaGJhLT5zaG9zdCk7CisJcGNpX2Rldl9wdXQocGhiYS0+cGNpZGV2KTsKKwlpc2NzaV9ob3N0X2ZyZWUocGhiYS0+c2hvc3QpOworfQorCitzdGF0aWMgaW50IF9fZGV2aW5pdCBiZWlzY3NpX2Rldl9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqcGNpZGV2LAorCQkJCWNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICppZCkKK3sKKwlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEgPSBOVUxMOworCWludCByZXQ7CisKKwlyZXQgPSBiZWlzY3NpX2VuYWJsZV9wY2kocGNpZGV2KTsKKwlpZiAocmV0IDwgMCkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LCAiYmVpc2NzaV9kZXZfcHJvYmUtIgorCQkJICAgICAiRmFpbGVkIHRvIGVuYWJsZSBwY2kgZGV2aWNlIFxuIik7CisJCXJldHVybiByZXQ7CisJfQorCisJcGhiYSA9IGJlaXNjc2lfaGJhX2FsbG9jKHBjaWRldik7CisJaWYgKCFwaGJhKSB7CisJCWRldl9lcnIoJnBjaWRldi0+ZGV2LCAiYmVpc2NzaV9kZXZfcHJvYmUtIgorCQkJIiBGYWlsZWQgaW4gYmVpc2NzaV9oYmFfYWxsb2MgXG4iKTsKKwkJZ290byBkaXNhYmxlX3BjaTsKKwl9CisKKwlwY2lfc2V0X2RydmRhdGEocGNpZGV2LCBwaGJhKTsKKwlyZXQgPSBiZV9jdHJsX2luaXQocGhiYSwgcGNpZGV2KTsKKwlpZiAocmV0KSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsICJiZWlzY3NpX2Rldl9wcm9iZS0iCisJCQkJIkZhaWxlZCBpbiBiZV9jdHJsX2luaXRcbiIpOworCQlnb3RvIGhiYV9mcmVlOworCX0KKworCXNwaW5fbG9ja19pbml0KCZwaGJhLT5pb19zZ2xfbG9jayk7CisJc3Bpbl9sb2NrX2luaXQoJnBoYmEtPm1nbXRfc2dsX2xvY2spOworCXNwaW5fbG9ja19pbml0KCZwaGJhLT5pc3JfbG9jayk7CisJYmVpc2NzaV9nZXRfcGFyYW1zKHBoYmEpOworCXJldCA9IGJlaXNjc2lfaW5pdF9wb3J0KHBoYmEpOworCWlmIChyZXQgPCAwKSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsICJiZWlzY3NpX2Rldl9wcm9iZS0iCisJCQkgICAgICJGYWlsZWQgaW4gYmVpc2NzaV9pbml0X3BvcnRcbiIpOworCQlnb3RvIGZyZWVfcG9ydDsKKwl9CisKKwlzbnByaW50ZihwaGJhLT53cV9uYW1lLCBzaXplb2YocGhiYS0+d3FfbmFtZSksICJiZWlzY3NpX3FfaXJxJXUiLAorCQkgcGhiYS0+c2hvc3QtPmhvc3Rfbm8pOworCXBoYmEtPndxID0gY3JlYXRlX3NpbmdsZXRocmVhZF93b3JrcXVldWUocGhiYS0+d3FfbmFtZSk7CisJaWYgKCFwaGJhLT53cSkgeworCQlzaG9zdF9wcmludGsoS0VSTl9FUlIsIHBoYmEtPnNob3N0LCAiYmVpc2NzaV9kZXZfcHJvYmUtIgorCQkJCSJGYWlsZWQgdG8gYWxsb2NhdGUgd29yayBxdWV1ZVxuIik7CisJCWdvdG8gZnJlZV90d3E7CisJfQorCisJSU5JVF9XT1JLKCZwaGJhLT53b3JrX2NxcywgYmVpc2NzaV9wcm9jZXNzX2FsbF9jcXMpOworCisJaWYgKGJsa19pb3BvbGxfZW5hYmxlZCkgeworCQlibGtfaW9wb2xsX2luaXQoJnBoYmEtPmlvcG9sbCwgYmVfaW9wb2xsX2J1ZGdldCwgYmVfaW9wb2xsKTsKKwkJYmxrX2lvcG9sbF9lbmFibGUoJnBoYmEtPmlvcG9sbCk7CisJfQorCisJcmV0ID0gYmVpc2NzaV9pbml0X2lycXMocGhiYSk7CisJaWYgKHJldCA8IDApIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwgImJlaXNjc2lfZGV2X3Byb2JlLSIKKwkJCSAgICAgIkZhaWxlZCB0byBiZWlzY3NpX2luaXRfaXJxc1xuIik7CisJCWdvdG8gZnJlZV9ibGtlbmJsZDsKKwl9CisJcmV0ID0gaHdpX2VuYWJsZV9pbnRyKHBoYmEpOworCWlmIChyZXQgPCAwKSB7CisJCXNob3N0X3ByaW50ayhLRVJOX0VSUiwgcGhiYS0+c2hvc3QsICJiZWlzY3NpX2Rldl9wcm9iZS0iCisJCQkgICAgICJGYWlsZWQgdG8gaHdpX2VuYWJsZV9pbnRyXG4iKTsKKwkJZ290byBmcmVlX2N0cmxyOworCX0KKworCVNFX0RFQlVHKERCR19MVkxfOCwgIlxuXG5cbiBTVUNDRVNTIC0gRFJJVkVSIExPQURFRCBcblxuXG4iKTsKKwlyZXR1cm4gMDsKKworZnJlZV9jdHJscjoKKwlpZiAocGhiYS0+cGNpZGV2LT5pcnEpCisJCWZyZWVfaXJxKHBoYmEtPnBjaWRldi0+aXJxLCBwaGJhKTsKK2ZyZWVfYmxrZW5ibGQ6CisJZGVzdHJveV93b3JrcXVldWUocGhiYS0+d3EpOworCWlmIChibGtfaW9wb2xsX2VuYWJsZWQpCisJCWJsa19pb3BvbGxfZGlzYWJsZSgmcGhiYS0+aW9wb2xsKTsKK2ZyZWVfdHdxOgorCWJlaXNjc2lfY2xlYW5fcG9ydChwaGJhKTsKKwliZWlzY3NpX2ZyZWVfbWVtKHBoYmEpOworZnJlZV9wb3J0OgorCXBjaV9mcmVlX2NvbnNpc3RlbnQocGhiYS0+cGNpZGV2LAorCQkJICAgIHBoYmEtPmN0cmwubWJveF9tZW1fYWxsb2NlZC5zaXplLAorCQkJICAgIHBoYmEtPmN0cmwubWJveF9tZW1fYWxsb2NlZC52YSwKKwkJCSAgIHBoYmEtPmN0cmwubWJveF9tZW1fYWxsb2NlZC5kbWEpOworCWJlaXNjc2lfdW5tYXBfcGNpX2Z1bmN0aW9uKHBoYmEpOworaGJhX2ZyZWU6CisJaXNjc2lfaG9zdF9yZW1vdmUocGhiYS0+c2hvc3QpOworCXBjaV9kZXZfcHV0KHBoYmEtPnBjaWRldik7CisJaXNjc2lfaG9zdF9mcmVlKHBoYmEtPnNob3N0KTsKK2Rpc2FibGVfcGNpOgorCXBjaV9kaXNhYmxlX2RldmljZShwY2lkZXYpOworCXJldHVybiByZXQ7Cit9CisKK3N0cnVjdCBpc2NzaV90cmFuc3BvcnQgYmVpc2NzaV9pc2NzaV90cmFuc3BvcnQgPSB7CisJLm93bmVyID0gVEhJU19NT0RVTEUsCisJLm5hbWUgPSBEUlZfTkFNRSwKKwkuY2FwcyA9IENBUF9SRUNPVkVSWV9MMCB8IENBUF9IRFJER1NUIHwKKwkJQ0FQX01VTFRJX1IyVCB8IENBUF9EQVRBREdTVCB8IENBUF9EQVRBX1BBVEhfT0ZGTE9BRCwKKwkucGFyYW1fbWFzayA9IElTQ1NJX01BWF9SRUNWX0RMRU5HVEggfAorCQlJU0NTSV9NQVhfWE1JVF9ETEVOR1RIIHwKKwkJSVNDU0lfSERSREdTVF9FTiB8CisJCUlTQ1NJX0RBVEFER1NUX0VOIHwKKwkJSVNDU0lfSU5JVElBTF9SMlRfRU4gfAorCQlJU0NTSV9NQVhfUjJUIHwKKwkJSVNDU0lfSU1NX0RBVEFfRU4gfAorCQlJU0NTSV9GSVJTVF9CVVJTVCB8CisJCUlTQ1NJX01BWF9CVVJTVCB8CisJCUlTQ1NJX1BEVV9JTk9SREVSX0VOIHwKKwkJSVNDU0lfREFUQVNFUV9JTk9SREVSX0VOIHwKKwkJSVNDU0lfRVJMIHwKKwkJSVNDU0lfQ09OTl9QT1JUIHwKKwkJSVNDU0lfQ09OTl9BRERSRVNTIHwKKwkJSVNDU0lfRVhQX1NUQVRTTiB8CisJCUlTQ1NJX1BFUlNJU1RFTlRfUE9SVCB8CisJCUlTQ1NJX1BFUlNJU1RFTlRfQUREUkVTUyB8CisJCUlTQ1NJX1RBUkdFVF9OQU1FIHwgSVNDU0lfVFBHVCB8CisJCUlTQ1NJX1VTRVJOQU1FIHwgSVNDU0lfUEFTU1dPUkQgfAorCQlJU0NTSV9VU0VSTkFNRV9JTiB8IElTQ1NJX1BBU1NXT1JEX0lOIHwKKwkJSVNDU0lfRkFTVF9BQk9SVCB8IElTQ1NJX0FCT1JUX1RNTyB8CisJCUlTQ1NJX0xVX1JFU0VUX1RNTyB8CisJCUlTQ1NJX1BJTkdfVE1PIHwgSVNDU0lfUkVDVl9UTU8gfAorCQlJU0NTSV9JRkFDRV9OQU1FIHwgSVNDU0lfSU5JVElBVE9SX05BTUUsCisJLmhvc3RfcGFyYW1fbWFzayA9IElTQ1NJX0hPU1RfSFdBRERSRVNTIHwgSVNDU0lfSE9TVF9JUEFERFJFU1MgfAorCQkJCUlTQ1NJX0hPU1RfSU5JVElBVE9SX05BTUUsCisJLmNyZWF0ZV9zZXNzaW9uID0gYmVpc2NzaV9zZXNzaW9uX2NyZWF0ZSwKKwkuZGVzdHJveV9zZXNzaW9uID0gYmVpc2NzaV9zZXNzaW9uX2Rlc3Ryb3ksCisJLmNyZWF0ZV9jb25uID0gYmVpc2NzaV9jb25uX2NyZWF0ZSwKKwkuYmluZF9jb25uID0gYmVpc2NzaV9jb25uX2JpbmQsCisJLmRlc3Ryb3lfY29ubiA9IGlzY3NpX2Nvbm5fdGVhcmRvd24sCisJLnNldF9wYXJhbSA9IGJlaXNjc2lfc2V0X3BhcmFtLAorCS5nZXRfY29ubl9wYXJhbSA9IGJlaXNjc2lfY29ubl9nZXRfcGFyYW0sCisJLmdldF9zZXNzaW9uX3BhcmFtID0gaXNjc2lfc2Vzc2lvbl9nZXRfcGFyYW0sCisJLmdldF9ob3N0X3BhcmFtID0gYmVpc2NzaV9nZXRfaG9zdF9wYXJhbSwKKwkuc3RhcnRfY29ubiA9IGJlaXNjc2lfY29ubl9zdGFydCwKKwkuc3RvcF9jb25uID0gYmVpc2NzaV9jb25uX3N0b3AsCisJLnNlbmRfcGR1ID0gaXNjc2lfY29ubl9zZW5kX3BkdSwKKwkueG1pdF90YXNrID0gYmVpc2NzaV90YXNrX3htaXQsCisJLmNsZWFudXBfdGFzayA9IGJlaXNjc2lfY2xlYW51cF90YXNrLAorCS5hbGxvY19wZHUgPSBiZWlzY3NpX2FsbG9jX3BkdSwKKwkucGFyc2VfcGR1X2l0dCA9IGJlaXNjc2lfcGFyc2VfcGR1LAorCS5nZXRfc3RhdHMgPSBiZWlzY3NpX2Nvbm5fZ2V0X3N0YXRzLAorCS5lcF9jb25uZWN0ID0gYmVpc2NzaV9lcF9jb25uZWN0LAorCS5lcF9wb2xsID0gYmVpc2NzaV9lcF9wb2xsLAorCS5lcF9kaXNjb25uZWN0ID0gYmVpc2NzaV9lcF9kaXNjb25uZWN0LAorCS5zZXNzaW9uX3JlY292ZXJ5X3RpbWVkb3V0ID0gaXNjc2lfc2Vzc2lvbl9yZWNvdmVyeV90aW1lZG91dCwKK307CisKK3N0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciBiZWlzY3NpX3BjaV9kcml2ZXIgPSB7CisJLm5hbWUgPSBEUlZfTkFNRSwKKwkucHJvYmUgPSBiZWlzY3NpX2Rldl9wcm9iZSwKKwkucmVtb3ZlID0gYmVpc2NzaV9yZW1vdmUsCisJLmlkX3RhYmxlID0gYmVpc2NzaV9wY2lfaWRfdGFibGUKK307CisKK3N0YXRpYyBpbnQgX19pbml0IGJlaXNjc2lfbW9kdWxlX2luaXQodm9pZCkKK3sKKwlpbnQgcmV0OworCisJYmVpc2NzaV9zY3NpX3RyYW5zcG9ydCA9CisJCQlpc2NzaV9yZWdpc3Rlcl90cmFuc3BvcnQoJmJlaXNjc2lfaXNjc2lfdHJhbnNwb3J0KTsKKwlpZiAoIWJlaXNjc2lfc2NzaV90cmFuc3BvcnQpIHsKKwkJU0VfREVCVUcoREJHX0xWTF8xLAorCQkJICJiZWlzY3NpX21vZHVsZV9pbml0IC0gVW5hYmxlIHRvICByZWdpc3RlciBiZWlzY3NpIgorCQkJICJ0cmFuc3BvcnQuXG4iKTsKKwkJcmV0ID0gLUVOT01FTTsKKwl9CisJU0VfREVCVUcoREJHX0xWTF84LCAiSW4gYmVpc2NzaV9tb2R1bGVfaW5pdCwgdHQ9JXAgXG4iLAorCQkgJmJlaXNjc2lfaXNjc2lfdHJhbnNwb3J0KTsKKworCXJldCA9IHBjaV9yZWdpc3Rlcl9kcml2ZXIoJmJlaXNjc2lfcGNpX2RyaXZlcik7CisJaWYgKHJldCkgeworCQlTRV9ERUJVRyhEQkdfTFZMXzEsCisJCQkgImJlaXNjc2lfbW9kdWxlX2luaXQgLSBVbmFibGUgdG8gIHJlZ2lzdGVyIgorCQkJICJiZWlzY3NpIHBjaSBkcml2ZXIuXG4iKTsKKwkJZ290byB1bnJlZ2lzdGVyX2lzY3NpX3RyYW5zcG9ydDsKKwl9CisJcmV0dXJuIDA7CisKK3VucmVnaXN0ZXJfaXNjc2lfdHJhbnNwb3J0OgorCWlzY3NpX3VucmVnaXN0ZXJfdHJhbnNwb3J0KCZiZWlzY3NpX2lzY3NpX3RyYW5zcG9ydCk7CisJcmV0dXJuIHJldDsKK30KKworc3RhdGljIHZvaWQgX19leGl0IGJlaXNjc2lfbW9kdWxlX2V4aXQodm9pZCkKK3sKKwlwY2lfdW5yZWdpc3Rlcl9kcml2ZXIoJmJlaXNjc2lfcGNpX2RyaXZlcik7CisJaXNjc2lfdW5yZWdpc3Rlcl90cmFuc3BvcnQoJmJlaXNjc2lfaXNjc2lfdHJhbnNwb3J0KTsKK30KKworbW9kdWxlX2luaXQoYmVpc2NzaV9tb2R1bGVfaW5pdCk7Cittb2R1bGVfZXhpdChiZWlzY3NpX21vZHVsZV9leGl0KTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9tYWluLmggYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfbWFpbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUzYzliNzAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfbWFpbi5oCkBAIC0wLDAgKzEsODM3IEBACisvKioKKyAqIENvcHlyaWdodCAoQykgMjAwNSAtIDIwMDkgU2VydmVyRW5naW5lcworICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLiAgVGhlIGZ1bGwgR05VIEdlbmVyYWwKKyAqIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluIHRoZSBmaWxlIGNhbGxlZCBDT1BZSU5HLgorICoKKyAqIFdyaXR0ZW4gYnk6IEpheWFtb2hhbiBLYWxsaWNrYWwgKGpheWFtb2hhbmtAc2VydmVyZW5naW5lcy5jb20pCisgKgorICogQ29udGFjdCBJbmZvcm1hdGlvbjoKKyAqIGxpbnV4LWRyaXZlcnNAc2VydmVyZW5naW5lcy5jb20KKyAqCisgKiBTZXJ2ZXJFbmdpbmVzCisgKiAyMDkgTi4gRmFpciBPYWtzIEF2ZQorICogU3Vubnl2YWxlLCBDQSA5NDA4NQorICoKKyAqLworCisjaWZuZGVmIF9CRUlTQ1NJX01BSU5fCisjZGVmaW5lIF9CRUlTQ1NJX01BSU5fCisKKworI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgorI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgorI2luY2x1ZGUgPGxpbnV4L2luLmg+CisjaW5jbHVkZSA8bGludXgvYmxrLWlvcG9sbC5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX2RldmljZS5oPgorI2luY2x1ZGUgPHNjc2kvc2NzaV9ob3N0Lmg+CisjaW5jbHVkZSA8c2NzaS9pc2NzaV9wcm90by5oPgorI2luY2x1ZGUgPHNjc2kvbGliaXNjc2kuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfdHJhbnNwb3J0X2lzY3NpLmg+CisKKyNpbmNsdWRlICJiZS5oIgorCisKKworI2RlZmluZSBEUlZfTkFNRQkJImJlMmlzY3NpIgorI2RlZmluZSBCVUlMRF9TVFIJCSIyLjAuNTI3LjAiCisKKyNkZWZpbmUgQkVfTkFNRQkJCSJTZXJ2ZXJFbmdpbmVzIEJsYWRlRW5naW5lMiIgXAorCQkJCSJMaW51eCBpU0NTSSBEcml2ZXIgdmVyc2lvbiIgQlVJTERfU1RSCisjZGVmaW5lIERSVl9ERVNDCQlCRV9OQU1FICIgIiAiRHJpdmVyIgorCisjZGVmaW5lIEJFX1ZFTkRPUl9JRCAJCTB4MTlBMgorI2RlZmluZSBCRV9ERVZJQ0VfSUQxCQkweDIxMgorI2RlZmluZSBPQ19ERVZJQ0VfSUQxCQkweDcwMgorI2RlZmluZSBPQ19ERVZJQ0VfSUQyCQkweDcwMworCisjZGVmaW5lIEJFMl9NQVhfU0VTU0lPTlMJNjQKKyNkZWZpbmUgQkUyX0NNRFNfUEVSX0NYTgkxMjgKKyNkZWZpbmUgQkUyX0xPR09VVFMJCUJFMl9NQVhfU0VTU0lPTlMKKyNkZWZpbmUgQkUyX1RNRlMJCTE2CisjZGVmaW5lIEJFMl9OT1BPVVRfUkVRCQkxNgorI2RlZmluZSBCRTJfQVNZTkNQRFVTCQlCRTJfTUFYX1NFU1NJT05TCisjZGVmaW5lIEJFMl9NQVhfSUNEUwkJMjA0OAorI2RlZmluZSBCRTJfU0dFCQkJMzIKKyNkZWZpbmUgQkUyX0RFRlBEVV9IRFJfU1oJNjQKKyNkZWZpbmUgQkUyX0RFRlBEVV9EQVRBX1NaCTgxOTIKKyNkZWZpbmUgQkUyX0lPX0RFUFRIIFwKKwkoQkUyX01BWF9JQ0RTIC8gMiAtIChCRTJfTE9HT1VUUyArIEJFMl9UTUZTICsgQkUyX05PUE9VVF9SRVEpKQorCisjZGVmaW5lIEJFSVNDU0lfU0dMSVNUX0VMRU1FTlRTCUJFMl9TR0UKKworI2RlZmluZSBCRUlTQ1NJX01BWF9DTU5EUwkxMDI0CS8qIE1heCBJTydzIHBlciBDdHJsciBzaHQtPmNhbl9xdWV1ZSAqLworI2RlZmluZSBCRUlTQ1NJX0NNRF9QRVJfTFVOCTEyOAkvKiBzY3NpX2hvc3QtPmNtZF9wZXJfbHVuICovCisjZGVmaW5lIEJFSVNDU0lfTUFYX1NFQ1RPUlMJMjA0OAkvKiBzY3NpX2hvc3QtPm1heF9zZWN0b3JzICovCisKKyNkZWZpbmUgQkVJU0NTSV9NQVhfQ01EX0xFTgkxNgkvKiBzY3NpX2hvc3QtPm1heF9jbWRfbGVuICovCisjZGVmaW5lIEJFSVNDU0lfTlVNX01BWF9MVU4JMjU2CS8qIHNjc2lfaG9zdC0+bWF4X2x1biAqLworI2RlZmluZSBCRUlTQ1NJX05VTV9ERVZJQ0VTX1NVUFBPUlRFRAkweDAxCisjZGVmaW5lIEJFSVNDU0lfTUFYX0ZSQUdTX0lOSVQJMTkyCisjZGVmaW5lIEJFX05VTV9NU0lYX0VOVFJJRVMgCTEKKyNkZWZpbmUgTVBVX0VQX1NFTUFQSE9SRSAJMHhhYworCisjZGVmaW5lIEJFX1NFTlNFX0lORk9fU0laRQkJMjU4CisjZGVmaW5lIEJFX0lTQ1NJX1BEVV9IRUFERVJfU0laRQk2NAorI2RlZmluZSBCRV9NSU5fTUVNX1NJWkUJCQkxNjM4NAorCisjZGVmaW5lIElJT0NfU0NTSV9EQVRBICAgICAgICAgICAgICAgICAgMHgwNQkvKiBXcml0ZSBPcGVyYXRpb24gKi8KKworI2RlZmluZSBEQkdfTFZMCQkJCTB4MDAwMDAwMDEKKyNkZWZpbmUgREJHX0xWTF8xCQkJMHgwMDAwMDAwMQorI2RlZmluZSBEQkdfTFZMXzIJCQkweDAwMDAwMDAyCisjZGVmaW5lIERCR19MVkxfMwkJCTB4MDAwMDAwMDQKKyNkZWZpbmUgREJHX0xWTF80CQkJMHgwMDAwMDAwOAorI2RlZmluZSBEQkdfTFZMXzUJCQkweDAwMDAwMDEwCisjZGVmaW5lIERCR19MVkxfNgkJCTB4MDAwMDAwMjAKKyNkZWZpbmUgREJHX0xWTF83CQkJMHgwMDAwMDA0MAorI2RlZmluZSBEQkdfTFZMXzgJCQkweDAwMDAwMDgwCisKKyNkZWZpbmUgU0VfREVCVUcoZGVidWdfbWFzaywgZm10LCBhcmdzLi4uKQkJXAorZG8gewkJCQkJCQlcCisJaWYgKGRlYnVnX21hc2sgJiBEQkdfTFZMKSB7CQkJXAorCQlwcmludGsoS0VSTl9FUlIgIiglcygpOiVkKToiLCBfX2Z1bmNfXywgX19MSU5FX18pO1wKKwkJcHJpbnRrKGZtdCwgIyNhcmdzKTsJCQlcCisJfQkJCQkJCVwKK30gd2hpbGUgKDApOworCisvKioKKyAqIGhhcmR3YXJlIG5lZWRzIHRoZSBhc3luYyBQRFUgYnVmZmVycyB0byBiZSBwb3N0ZWQgaW4gbXVsdGlwbGVzIG9mIDgKKyAqIFNvIGhhdmUgYXRsZWFzdCA4IG9mIHRoZW0gYnkgZGVmYXVsdAorICovCisKKyNkZWZpbmUgSFdJX0dFVF9BU1lOQ19QRFVfQ1RYKHBod2kpCShwaHdpLT5waHdpX2N0eHQtPnBhc3luY19jdHgpCisKKy8qKioqKioqKiogTWVtb3J5IEJBUiByZWdpc3RlciAqKioqKioqKioqKiovCisjZGVmaW5lIFBDSUNGR19NRU1CQVJfQ1RSTF9JTlRfQ1RSTF9PRkZTRVQgCTB4ZmMKKy8qKgorICogSG9zdCBJbnRlcnJ1cHQgRW5hYmxlLCBpZiBzZXQgaW50ZXJydXB0cyBhcmUgZW5hYmxlZCBhbHRob3VnaCAiUENJIEludGVycnVwdAorICogRGlzYWJsZSIgbWF5IHN0aWxsIGdsb2JhbGx5IGJsb2NrIGludGVycnVwdHMgaW4gYWRkaXRpb24gdG8gaW5kaXZpZHVhbAorICogaW50ZXJydXB0IG1hc2tzOyBhIG1lY2hhbmlzbSBmb3IgdGhlIGRldmljZSBkcml2ZXIgdG8gYmxvY2sgYWxsIGludGVycnVwdHMKKyAqIGF0b21pY2FsbHkgd2l0aG91dCBoYXZpbmcgdG8gYXJiaXRyYXRlIGZvciB0aGUgUENJIEludGVycnVwdCBEaXNhYmxlIGJpdAorICogd2l0aCB0aGUgT1MuCisgKi8KKyNkZWZpbmUgTUVNQkFSX0NUUkxfSU5UX0NUUkxfSE9TVElOVFJfTUFTSwkoMSA8PCAyOSkJLyogYml0IDI5ICovCisKKy8qKioqKioqKiogSVNSMCBSZWdpc3RlciBvZmZzZXQgKioqKioqKioqKi8KKyNkZWZpbmUgQ0VWX0lTUjBfT0ZGU0VUIAkJCTB4QzE4CisjZGVmaW5lIENFVl9JU1JfU0laRQkJCQk0CisKKy8qKgorICogTWFjcm9zIGZvciByZWFkaW5nL3dyaXRpbmcgYSBwcm90ZWN0aW9uIGRvbWFpbiBvciBDU1IgcmVnaXN0ZXJzCisgKiBpbiBCbGFkZUVuZ2luZS4KKyAqLworCisjZGVmaW5lIERCX1RYVUxQMF9PRkZTRVQgMHg0MAorI2RlZmluZSBEQl9SWFVMUDBfT0ZGU0VUIDB4QTAKKy8qKioqKioqKiogRXZlbnQgUSBkb29yIGJlbGwgKioqKioqKioqKioqKi8KKyNkZWZpbmUgREJfRVFfT0ZGU0VUCQkJREJfQ1FfT0ZGU0VUCisjZGVmaW5lIERCX0VRX1JJTkdfSURfTUFTSwkJMHgxRkYJLyogYml0cyAwIC0gOCAqLworLyogQ2xlYXIgdGhlIGludGVycnVwdCBmb3IgdGhpcyBlcSAqLworI2RlZmluZSBEQl9FUV9DTFJfU0hJRlQJCQkoOSkJLyogYml0IDkgKi8KKy8qIE11c3QgYmUgMSAqLworI2RlZmluZSBEQl9FUV9FVk5UX1NISUZUCQkoMTApCS8qIGJpdCAxMCAqLworLyogTnVtYmVyIG9mIGV2ZW50IGVudHJpZXMgcHJvY2Vzc2VkICovCisjZGVmaW5lIERCX0VRX05VTV9QT1BQRURfU0hJRlQJCSgxNikJLyogYml0cyAxNiAtIDI4ICovCisvKiBSZWFybSBiaXQgKi8KKyNkZWZpbmUgREJfRVFfUkVBUk1fU0hJRlQJCSgyOSkJLyogYml0IDI5ICovCisKKy8qKioqKioqKiogQ29tcGwgUSBkb29yIGJlbGwgKioqKioqKioqKioqKi8KKyNkZWZpbmUgREJfQ1FfT0ZGU0VUIAkJCTB4MTIwCisjZGVmaW5lIERCX0NRX1JJTkdfSURfTUFTSwkJMHgzRkYJLyogYml0cyAwIC0gOSAqLworLyogTnVtYmVyIG9mIGV2ZW50IGVudHJpZXMgcHJvY2Vzc2VkICovCisjZGVmaW5lIERCX0NRX05VTV9QT1BQRURfU0hJRlQJCSgxNikgCS8qIGJpdHMgMTYgLSAyOCAqLworLyogUmVhcm0gYml0ICovCisjZGVmaW5lIERCX0NRX1JFQVJNX1NISUZUCQkoMjkpIAkvKiBiaXQgMjkgKi8KKworI2RlZmluZSBHRVRfSFdJX0NPTlRST0xMRVJfV1MocGMpCShwYy0+cGh3aV9jdHJscikKKyNkZWZpbmUgSFdJX0dFVF9ERUZfQlVGUV9JRChwYykgKCgoc3RydWN0IGh3aV9jb250cm9sbGVyICopXAorCQkoR0VUX0hXSV9DT05UUk9MTEVSX1dTKHBjKSkpLT5kZWZhdWx0X3BkdV9kYXRhLmlkKQorI2RlZmluZSBIV0lfR0VUX0RFRl9IRFJRX0lEKHBjKSAoKChzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKilcCisJCShHRVRfSFdJX0NPTlRST0xMRVJfV1MocGMpKSktPmRlZmF1bHRfcGR1X2hkci5pZCkKKworI2RlZmluZSBQQUdFU19SRVFVSVJFRCh4KSBcCisJKCh4IDwgUEFHRV9TSVpFKSA/IDEgOiAgKCh4ICsgUEFHRV9TSVpFIC0gMSkgLyBQQUdFX1NJWkUpKQorCitlbnVtIGJlX21lbV9lbnVtIHsKKwlIV0lfTUVNX0FERE5fQ09OVEVYVCwKKwlIV0lfTUVNX0NRLAorCUhXSV9NRU1fRVEsCisJSFdJX01FTV9XUkIsCisJSFdJX01FTV9XUkJILAorCUhXSV9NRU1fU0dMSCwJLyogNSAqLworCUhXSV9NRU1fU0dFLAorCUhXSV9NRU1fQVNZTkNfSEVBREVSX0JVRiwKKwlIV0lfTUVNX0FTWU5DX0RBVEFfQlVGLAorCUhXSV9NRU1fQVNZTkNfSEVBREVSX1JJTkcsCisJSFdJX01FTV9BU1lOQ19EQVRBX1JJTkcsCS8qIDEwICovCisJSFdJX01FTV9BU1lOQ19IRUFERVJfSEFORExFLAorCUhXSV9NRU1fQVNZTkNfREFUQV9IQU5ETEUsCisJSFdJX01FTV9BU1lOQ19QRFVfQ09OVEVYVCwKKwlJU0NTSV9NRU1fR0xPQkFMX0hFQURFUiwKKwlTRV9NRU1fTUFYICAJLyogMTUgKi8KK307CisKK3N0cnVjdCBiZV9idXNfYWRkcmVzczMyIHsKKwl1bnNpZ25lZCBpbnQgYWRkcmVzc19sbzsKKwl1bnNpZ25lZCBpbnQgYWRkcmVzc19oaTsKK307CisKK3N0cnVjdCBiZV9idXNfYWRkcmVzczY0IHsKKwl1bnNpZ25lZCBsb25nIGxvbmcgYWRkcmVzczsKK307CisKK3N0cnVjdCBiZV9idXNfYWRkcmVzcyB7CisJdW5pb24geworCQlzdHJ1Y3QgYmVfYnVzX2FkZHJlc3MzMiBhMzI7CisJCXN0cnVjdCBiZV9idXNfYWRkcmVzczY0IGE2NDsKKwl9IHU7Cit9OworCitzdHJ1Y3QgbWVtX2FycmF5IHsKKwlzdHJ1Y3QgYmVfYnVzX2FkZHJlc3MgYnVzX2FkZHJlc3M7CS8qIEJ1cyBhZGRyZXNzIG9mIGxvY2F0aW9uICovCisJdm9pZCAqdmlydHVhbF9hZGRyZXNzOwkJLyogdmlydHVhbCBhZGRyZXNzIHRvIHRoZSBsb2NhdGlvbiAqLworCXVuc2lnbmVkIGludCBzaXplOwkJLyogU2l6ZSByZXF1aXJlZCBieSBtZW1vcnkgYmxvY2sgKi8KK307CisKK3N0cnVjdCBiZV9tZW1fZGVzY3JpcHRvciB7CisJdW5zaWduZWQgaW50IGluZGV4OwkvKiBJbmRleCBvZiB0aGlzIG1lbW9yeSBwYXJhbWV0ZXIgKi8KKwl1bnNpZ25lZCBpbnQgY2F0ZWdvcnk7CS8qIHR5cGUgaW5kaWNhdGVzIGNhY2hlZC9ub24tY2FjaGVkICovCisJdW5zaWduZWQgaW50IG51bV9lbGVtZW50czsJLyogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoaXMKKwkJCQkJICogZGVzY3JpcHRvcgorCQkJCQkgKi8KKwl1bnNpZ25lZCBpbnQgYWxpZ25tZW50X21hc2s7CS8qIEFsaWdubWVudCBtYXNrIGZvciB0aGlzIGJsb2NrICovCisJdW5zaWduZWQgaW50IHNpemVfaW5fYnl0ZXM7CS8qIFNpemUgcmVxdWlyZWQgYnkgbWVtb3J5IGJsb2NrICovCisJc3RydWN0IG1lbV9hcnJheSAqbWVtX2FycmF5OworfTsKKworc3RydWN0IHNnbF9oYW5kbGUgeworCXVuc2lnbmVkIGludCBzZ2xfaW5kZXg7CisJc3RydWN0IGlzY3NpX3NnZSAqcGZyYWc7Cit9OworCitzdHJ1Y3QgaGJhX3BhcmFtZXRlcnMgeworCXVuc2lnbmVkIGludCBpb3NfcGVyX2N0cmw7CisJdW5zaWduZWQgaW50IGN4bnNfcGVyX2N0cmw7CisJdW5zaWduZWQgaW50IGFzeW5jcGR1c19wZXJfY3RybDsKKwl1bnNpZ25lZCBpbnQgaWNkc19wZXJfY3RybDsKKwl1bnNpZ25lZCBpbnQgbnVtX3NnZV9wZXJfaW87CisJdW5zaWduZWQgaW50IGRlZnBkdV9oZHJfc3o7CisJdW5zaWduZWQgaW50IGRlZnBkdV9kYXRhX3N6OworCXVuc2lnbmVkIGludCBudW1fY3FfZW50cmllczsKKwl1bnNpZ25lZCBpbnQgbnVtX2VxX2VudHJpZXM7CisJdW5zaWduZWQgaW50IHdyYnNfcGVyX2N4bjsKKwl1bnNpZ25lZCBpbnQgY3Jhc2htb2RlOworCXVuc2lnbmVkIGludCBoYmFfbnVtOworCisJdW5zaWduZWQgaW50IG1nbXRfd3Nfc3o7CisJdW5zaWduZWQgaW50IGh3aV93c19zejsKKworCXVuc2lnbmVkIGludCBldG87CisJdW5zaWduZWQgaW50IGxkdG87CisKKwl1bnNpZ25lZCBpbnQgZGJnX2ZsYWdzOworCXVuc2lnbmVkIGludCBudW1fY3huOworCisJdW5zaWduZWQgaW50IGVxX3RpbWVyOworCS8qKgorCSAqIFRoZXNlIGFyZSBjYWxjdWxhdGVkIGZyb20gb3RoZXIgcGFyYW1zLiBUaGV5J3JlIGhlcmUKKwkgKiBmb3IgZGVidWcgcHVycG9zZXMKKwkgKi8KKwl1bnNpZ25lZCBpbnQgbnVtX21jY19wYWdlczsKKwl1bnNpZ25lZCBpbnQgbnVtX21jY19jcV9wYWdlczsKKwl1bnNpZ25lZCBpbnQgbnVtX2NxX3BhZ2VzOworCXVuc2lnbmVkIGludCBudW1fZXFfcGFnZXM7CisKKwl1bnNpZ25lZCBpbnQgbnVtX2FzeW5jX3BkdV9idWZfcGFnZXM7CisJdW5zaWduZWQgaW50IG51bV9hc3luY19wZHVfYnVmX3NnbF9wYWdlczsKKwl1bnNpZ25lZCBpbnQgbnVtX2FzeW5jX3BkdV9idWZfY3FfcGFnZXM7CisKKwl1bnNpZ25lZCBpbnQgbnVtX2FzeW5jX3BkdV9oZHJfcGFnZXM7CisJdW5zaWduZWQgaW50IG51bV9hc3luY19wZHVfaGRyX3NnbF9wYWdlczsKKwl1bnNpZ25lZCBpbnQgbnVtX2FzeW5jX3BkdV9oZHJfY3FfcGFnZXM7CisKKwl1bnNpZ25lZCBpbnQgbnVtX3NnZTsKK307CisKK3N0cnVjdCBiZWlzY3NpX2hiYSB7CisJc3RydWN0IGhiYV9wYXJhbWV0ZXJzIHBhcmFtczsKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJdW5zaWduZWQgaW50IG1lbV9yZXFbU0VfTUVNX01BWF07CisJLyogUENJIEJBUiBtYXBwZWQgYWRkcmVzc2VzICovCisJdTggX19pb21lbSAqY3NyX3ZhOwkvKiBDU1IgKi8KKwl1OCBfX2lvbWVtICpkYl92YTsJLyogRG9vciAgQmVsbCAgKi8KKwl1OCBfX2lvbWVtICpwY2lfdmE7CS8qIFBDSSBDb25maWcgKi8KKwlzdHJ1Y3QgYmVfYnVzX2FkZHJlc3MgY3NyX3BhOwkvKiBDU1IgKi8KKwlzdHJ1Y3QgYmVfYnVzX2FkZHJlc3MgZGJfcGE7CS8qIENTUiAqLworCXN0cnVjdCBiZV9idXNfYWRkcmVzcyBwY2lfcGE7CS8qIENTUiAqLworCS8qIFBDSSByZXByZXNlbnRhdGlvbiBvZiBvdXIgSEJBICovCisJc3RydWN0IHBjaV9kZXYgKnBjaWRldjsKKwl1bnNpZ25lZCBpbnQgc3RhdGU7CisJdW5zaWduZWQgc2hvcnQgYXNpY19yZXZpc2lvbjsKKwlzdHJ1Y3QgYmxrX2lvcG9sbAlpb3BvbGw7CisJc3RydWN0IGJlX21lbV9kZXNjcmlwdG9yICppbml0X21lbTsKKworCXVuc2lnbmVkIHNob3J0IGlvX3NnbF9hbGxvY19pbmRleDsKKwl1bnNpZ25lZCBzaG9ydCBpb19zZ2xfZnJlZV9pbmRleDsKKwl1bnNpZ25lZCBzaG9ydCBpb19zZ2xfaG5kbF9hdmJsOworCXN0cnVjdCBzZ2xfaGFuZGxlICoqaW9fc2dsX2huZGxfYmFzZTsKKworCXVuc2lnbmVkIHNob3J0IGVoX3NnbF9hbGxvY19pbmRleDsKKwl1bnNpZ25lZCBzaG9ydCBlaF9zZ2xfZnJlZV9pbmRleDsKKwl1bnNpZ25lZCBzaG9ydCBlaF9zZ2xfaG5kbF9hdmJsOworCXN0cnVjdCBzZ2xfaGFuZGxlICoqZWhfc2dsX2huZGxfYmFzZTsKKwlzcGlubG9ja190IGlvX3NnbF9sb2NrOworCXNwaW5sb2NrX3QgbWdtdF9zZ2xfbG9jazsKKwlzcGlubG9ja190IGlzcl9sb2NrOworCXVuc2lnbmVkIGludCBhZ2U7CisJdW5zaWduZWQgc2hvcnQgYXZsYmxfY2lkczsKKwl1bnNpZ25lZCBzaG9ydCBjaWRfYWxsb2M7CisJdW5zaWduZWQgc2hvcnQgY2lkX2ZyZWU7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqY29ubl90YWJsZVtCRTJfTUFYX1NFU1NJT05TICogMl07CisJc3RydWN0IGxpc3RfaGVhZCBoYmFfcXVldWU7CisJdW5zaWduZWQgc2hvcnQgKmNpZF9hcnJheTsKKwlzdHJ1Y3QgaXNjc2lfZW5kcG9pbnQgKiplcF9hcnJheTsKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdDsKKwlzdHJ1Y3QgeworCQkvKioKKwkJICogZ3JvdXAgdG9nZXRoZXIgc2luY2UgdGhleSBhcmUgdXNlZCBtb3N0IGZyZXF1ZW50bHkKKwkJICogZm9yIGNpZCB0byBjcmkgY29udmVyc2lvbgorCQkgKi8KKwkJdW5zaWduZWQgaW50IGlzY3NpX2NpZF9zdGFydDsKKwkJdW5zaWduZWQgaW50IHBoeXNfcG9ydDsKKworCQl1bnNpZ25lZCBpbnQgaXNyX29mZnNldDsKKwkJdW5zaWduZWQgaW50IGlzY3NpX2ljZF9zdGFydDsKKwkJdW5zaWduZWQgaW50IGlzY3NpX2NpZF9jb3VudDsKKwkJdW5zaWduZWQgaW50IGlzY3NpX2ljZF9jb3VudDsKKwkJdW5zaWduZWQgaW50IHBjaV9mdW5jdGlvbjsKKworCQl1bnNpZ25lZCBzaG9ydCBjaWRfYWxsb2M7CisJCXVuc2lnbmVkIHNob3J0IGNpZF9mcmVlOworCQl1bnNpZ25lZCBzaG9ydCBhdmxibF9jaWRzOworCQlzcGlubG9ja190IGNpZF9sb2NrOworCX0gZndfY29uZmlnOworCisJdTggbWFjX2FkZHJlc3NbRVRIX0FMRU5dOworCXVuc2lnbmVkIHNob3J0IHRvZG9fY3E7CisJdW5zaWduZWQgc2hvcnQgdG9kb19tY2NfY3E7CisJY2hhciB3cV9uYW1lWzIwXTsKKwlzdHJ1Y3Qgd29ya3F1ZXVlX3N0cnVjdCAqd3E7CS8qIFRoZSBhY3R1YWsgd29yayBxdWV1ZSAqLworCXN0cnVjdCB3b3JrX3N0cnVjdCB3b3JrX2NxczsJLyogVGhlIHdvcmsgYmVpbmcgcXVldWVkICovCisJc3RydWN0IGJlX2N0cmxfaW5mbyBjdHJsOworfTsKKworc3RydWN0IGJlaXNjc2lfc2Vzc2lvbiB7CisJc3RydWN0IHBjaV9wb29sICpiaHNfcG9vbDsKK307CisKKy8qKgorICogc3RydWN0IGJlaXNjc2lfY29ubiAtIGlzY3NpIGNvbm5lY3Rpb24gc3RydWN0dXJlCisgKi8KK3N0cnVjdCBiZWlzY3NpX2Nvbm4geworCXN0cnVjdCBpc2NzaV9jb25uICpjb25uOworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYTsKKwl1MzIgZXhwX3N0YXRzbjsKKwl1MzIgYmVpc2NzaV9jb25uX2NpZDsKKwlzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqZXA7CisJdW5zaWduZWQgc2hvcnQgbG9naW5faW5fcHJvZ3Jlc3M7CisJc3RydWN0IHNnbF9oYW5kbGUgKnBsb2dpbl9zZ2xfaGFuZGxlOworCXN0cnVjdCBiZWlzY3NpX3Nlc3Npb24gKmJlaXNjc2lfc2VzczsKK307CisKKy8qIFRoaXMgc3RydWN0dXJlIGlzIHVzZWQgYnkgdGhlIGNoaXAgKi8KK3N0cnVjdCBwZHVfZGF0YV9vdXQgeworCXUzMiBkd1sxMl07Cit9OworLyoqCisgKiBQc2V1ZG8gYW1hcCBkZWZpbml0aW9uIGluIHdoaWNoIGVhY2ggYml0IG9mIHRoZSBhY3R1YWwgc3RydWN0dXJlIGlzIGRlZmluZWQKKyAqIGFzIGEgYnl0ZTogdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9wZHVfZGF0YV9vdXQgeworCXU4IG9wY29kZVs2XTsJCS8qIG9wY29kZSAqLworCXU4IHJzdmQwWzJdOwkJLyogc2hvdWxkIGJlIDAgKi8KKwl1OCByc3ZkMVs3XTsKKwl1OCBmaW5hbF9iaXQ7CQkvKiBGIGJpdCAqLworCXU4IHJzdmQyWzE2XTsKKwl1OCBhaHNfbGVuZ3RoWzhdOwkvKiBubyBBSFMgKi8KKwl1OCBkYXRhX2xlbl9oaVs4XTsKKwl1OCBkYXRhX2xlbl9sb1sxNl07CS8qIERhdGFTZWdtZW50TGVuZ3RoICovCisJdTggbHVuWzY0XTsKKwl1OCBpdHRbMzJdOwkJLyogSVRUOyBpbml0aWF0b3IgdGFzayB0YWcgKi8KKwl1OCB0dHRbMzJdOwkJLyogVFRUOyB2YWxpZCBmb3IgUjJUIG9yIDB4ZmZmZmZmZmYgKi8KKwl1OCByc3ZkM1szMl07CisJdTggZXhwX3N0YXRfc25bMzJdOworCXU4IHJzdmQ0WzMyXTsKKwl1OCBkYXRhX3NuWzMyXTsKKwl1OCBidWZmZXJfb2Zmc2V0WzMyXTsKKwl1OCByc3ZkNVszMl07Cit9OworCitzdHJ1Y3QgYmVfY21kX2JocyB7CisJc3RydWN0IGlzY3NpX2NtZCBpc2NzaV9oZHI7CisJdW5zaWduZWQgY2hhciBwYWQxWzE2XTsKKwlzdHJ1Y3QgcGR1X2RhdGFfb3V0IGlzY3NpX2RhdGFfcGR1OworCXVuc2lnbmVkIGNoYXIgcGFkMltCRV9TRU5TRV9JTkZPX1NJWkUgLQorCQkJc2l6ZW9mKHN0cnVjdCBwZHVfZGF0YV9vdXQpXTsKK307CisKK3N0cnVjdCBiZWlzY3NpX2lvX3Rhc2sgeworCXN0cnVjdCB3cmJfaGFuZGxlICpwd3JiX2hhbmRsZTsKKwlzdHJ1Y3Qgc2dsX2hhbmRsZSAqcHNnbF9oYW5kbGU7CisJc3RydWN0IGJlaXNjc2lfY29ubiAqY29ubjsKKwlzdHJ1Y3Qgc2NzaV9jbW5kICpzY3NpX2NtbmQ7CisJdW5zaWduZWQgaW50IGNtZF9zbjsKKwl1bnNpZ25lZCBpbnQgZmxhZ3M7CisJdW5zaWduZWQgc2hvcnQgY2lkOworCXVuc2lnbmVkIHNob3J0IGhlYWRlcl9sZW47CisKKwlzdHJ1Y3QgYmVfY21kX2JocyAqY21kX2JoczsKKwlzdHJ1Y3QgYmVfYnVzX2FkZHJlc3MgYmhzX3BhOworCXVuc2lnbmVkIHNob3J0IGJoc19sZW47Cit9OworCitzdHJ1Y3QgYmVfbm9uaW9fYmhzIHsKKwlzdHJ1Y3QgaXNjc2lfaGRyIGlzY3NpX2hkcjsKKwl1bnNpZ25lZCBjaGFyIHBhZDFbMTZdOworCXN0cnVjdCBwZHVfZGF0YV9vdXQgaXNjc2lfZGF0YV9wZHU7CisJdW5zaWduZWQgY2hhciBwYWQyW0JFX1NFTlNFX0lORk9fU0laRSAtCisJCQlzaXplb2Yoc3RydWN0IHBkdV9kYXRhX291dCldOworfTsKKworc3RydWN0IGJlX3N0YXR1c19iaHMgeworCXN0cnVjdCBpc2NzaV9jbWQgaXNjc2lfaGRyOworCXVuc2lnbmVkIGNoYXIgcGFkMVsxNl07CisJLyoqCisJICogVGhlIHBsdXMgMiBiZWxvdyBpcyB0byBob2xkIHRoZSBzZW5zZSBpbmZvIGxlbmd0aCB0aGF0IGdldHMKKwkgKiBETUEnZWQgYnkgUnhVTFAKKwkgKi8KKwl1bnNpZ25lZCBjaGFyIHNlbnNlX2luZm9bQkVfU0VOU0VfSU5GT19TSVpFXTsKK307CisKK3N0cnVjdCBpc2NzaV9zZ2UgeworCXUzMiBkd1s0XTsKK307CisKKy8qKgorICogUHNldWRvIGFtYXAgZGVmaW5pdGlvbiBpbiB3aGljaCBlYWNoIGJpdCBvZiB0aGUgYWN0dWFsIHN0cnVjdHVyZSBpcyBkZWZpbmVkCisgKiBhcyBhIGJ5dGU6IHVzZWQgdG8gY2FsY3VsYXRlIG9mZnNldC9zaGlmdC9tYXNrIG9mIGVhY2ggZmllbGQKKyAqLworc3RydWN0IGFtYXBfaXNjc2lfc2dlIHsKKwl1OCBhZGRyX2hpWzMyXTsKKwl1OCBhZGRyX2xvWzMyXTsKKwl1OCBzZ2Vfb2Zmc2V0WzIyXTsJLyogRFdPUkQgMiAqLworCXU4IHJzdmQwWzldOwkJLyogRFdPUkQgMiAqLworCXU4IGxhc3Rfc2dlOwkJLyogRFdPUkQgMiAqLworCXU4IGxlblsxN107CQkvKiBEV09SRCAzICovCisJdTggcnN2ZDFbMTVdOwkJLyogRFdPUkQgMyAqLworfTsKKworc3RydWN0IGJlaXNjc2lfb2ZmbG9hZF9wYXJhbXMgeworCXUzMiBkd1s1XTsKK307CisKKyNkZWZpbmUgT0ZGTERfUEFSQU1TX0VSTAkweDAwMDAwMDAzCisjZGVmaW5lIE9GRkxEX1BBUkFNU19EREUJMHgwMDAwMDAwNAorI2RlZmluZSBPRkZMRF9QQVJBTVNfSERFCTB4MDAwMDAwMDgKKyNkZWZpbmUgT0ZGTERfUEFSQU1TX0lSMlQJMHgwMDAwMDAxMAorI2RlZmluZSBPRkZMRF9QQVJBTVNfSU1ECTB4MDAwMDAwMjAKKworLyoqCisgKiBQc2V1ZG8gYW1hcCBkZWZpbml0aW9uIGluIHdoaWNoIGVhY2ggYml0IG9mIHRoZSBhY3R1YWwgc3RydWN0dXJlIGlzIGRlZmluZWQKKyAqIGFzIGEgYnl0ZTogdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9iZWlzY3NpX29mZmxvYWRfcGFyYW1zIHsKKwl1OCBtYXhfYnVyc3RfbGVuZ3RoWzMyXTsKKwl1OCBtYXhfc2VuZF9kYXRhX3NlZ21lbnRfbGVuZ3RoWzMyXTsKKwl1OCBmaXJzdF9idXJzdF9sZW5ndGhbMzJdOworCXU4IGVybFsyXTsKKwl1OCBkZGVbMV07CisJdTggaGRlWzFdOworCXU4IGlyMnRbMV07CisJdTggaW1kWzFdOworCXU4IHBhZFsyNl07CisJdTggZXhwX3N0YXRzblszMl07Cit9OworCisvKiB2b2lkIGh3aV9jb21wbGV0ZV9kcnZyX21zZ3Moc3RydWN0IGJlaXNjc2lfY29ubiAqYmVpc2NzaV9jb25uLAorCQlzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsIHN0cnVjdCBzb2xfY3FlICpwc29sKTsqLworCitzdHJ1Y3QgYXN5bmNfcGR1X2hhbmRsZSB7CisJc3RydWN0IGxpc3RfaGVhZCBsaW5rOworCXN0cnVjdCBiZV9idXNfYWRkcmVzcyBwYTsKKwl2b2lkICpwYnVmZmVyOworCXVuc2lnbmVkIGludCBjb25zdW1lZDsKKwl1bnNpZ25lZCBjaGFyIGluZGV4OworCXVuc2lnbmVkIGNoYXIgaXNfaGVhZGVyOworCXVuc2lnbmVkIHNob3J0IGNyaTsKKwl1bnNpZ25lZCBsb25nIGJ1ZmZlcl9sZW47Cit9OworCitzdHJ1Y3QgaHdpX2FzeW5jX2VudHJ5IHsKKwlzdHJ1Y3QgeworCQl1bnNpZ25lZCBjaGFyIGhkcl9yZWNlaXZlZDsKKwkJdW5zaWduZWQgY2hhciBoZHJfbGVuOworCQl1bnNpZ25lZCBzaG9ydCBieXRlc19yZWNlaXZlZDsKKwkJdW5zaWduZWQgaW50IGJ5dGVzX25lZWRlZDsKKwkJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworCX0gd2FpdF9xdWV1ZTsKKworCXN0cnVjdCBsaXN0X2hlYWQgaGVhZGVyX2J1c3lfbGlzdDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGRhdGFfYnVzeV9saXN0OworfTsKKworI2RlZmluZSBCRV9NSU5fQVNZTkNfRU5UUklFUyAxMjgKKworc3RydWN0IGh3aV9hc3luY19wZHVfY29udGV4dCB7CisJc3RydWN0IHsKKwkJc3RydWN0IGJlX2J1c19hZGRyZXNzIHBhX2Jhc2U7CisJCXZvaWQgKnZhX2Jhc2U7CisJCXZvaWQgKnJpbmdfYmFzZTsKKwkJc3RydWN0IGFzeW5jX3BkdV9oYW5kbGUgKmhhbmRsZV9iYXNlOworCisJCXVuc2lnbmVkIGludCBob3N0X3dyaXRlX3B0cjsKKwkJdW5zaWduZWQgaW50IGVwX3JlYWRfcHRyOworCQl1bnNpZ25lZCBpbnQgd3JpdGFibGVzOworCisJCXVuc2lnbmVkIGludCBmcmVlX2VudHJpZXM7CisJCXVuc2lnbmVkIGludCBidXN5X2VudHJpZXM7CisJCXVuc2lnbmVkIGludCBidWZmZXJfc2l6ZTsKKwkJdW5zaWduZWQgaW50IG51bV9lbnRyaWVzOworCisJCXN0cnVjdCBsaXN0X2hlYWQgZnJlZV9saXN0OworCX0gYXN5bmNfaGVhZGVyOworCisJc3RydWN0IHsKKwkJc3RydWN0IGJlX2J1c19hZGRyZXNzIHBhX2Jhc2U7CisJCXZvaWQgKnZhX2Jhc2U7CisJCXZvaWQgKnJpbmdfYmFzZTsKKwkJc3RydWN0IGFzeW5jX3BkdV9oYW5kbGUgKmhhbmRsZV9iYXNlOworCisJCXVuc2lnbmVkIGludCBob3N0X3dyaXRlX3B0cjsKKwkJdW5zaWduZWQgaW50IGVwX3JlYWRfcHRyOworCQl1bnNpZ25lZCBpbnQgd3JpdGFibGVzOworCisJCXVuc2lnbmVkIGludCBmcmVlX2VudHJpZXM7CisJCXVuc2lnbmVkIGludCBidXN5X2VudHJpZXM7CisJCXVuc2lnbmVkIGludCBidWZmZXJfc2l6ZTsKKwkJc3RydWN0IGxpc3RfaGVhZCBmcmVlX2xpc3Q7CisJCXVuc2lnbmVkIGludCBudW1fZW50cmllczsKKwl9IGFzeW5jX2RhdGE7CisKKwkvKioKKwkgKiBUaGlzIGlzIGEgdmFyeWluZyBzaXplIGxpc3QhIERvIG5vdCBhZGQgYW55dGhpbmcKKwkgKiBhZnRlciB0aGlzIGVudHJ5ISEKKwkgKi8KKwlzdHJ1Y3QgaHdpX2FzeW5jX2VudHJ5IGFzeW5jX2VudHJ5W0JFX01JTl9BU1lOQ19FTlRSSUVTXTsKK307CisKKyNkZWZpbmUgUERVQ1FFX0NPREVfTUFTSwkweDAwMDAwMDNGCisjZGVmaW5lIFBEVUNRRV9EUExfTUFTSwkJMHhGRkZGMDAwMAorI2RlZmluZSBQRFVDUUVfSU5ERVhfTUFTSwkweDAwMDBGRkZGCisKK3N0cnVjdCBpX3RfZHBkdV9jcWUgeworCXUzMiBkd1s0XTsKK30gX19wYWNrZWQ7CisKKy8qKgorICogUHNldWRvIGFtYXAgZGVmaW5pdGlvbiBpbiB3aGljaCBlYWNoIGJpdCBvZiB0aGUgYWN0dWFsIHN0cnVjdHVyZSBpcyBkZWZpbmVkCisgKiBhcyBhIGJ5dGU6IHVzZWQgdG8gY2FsY3VsYXRlIG9mZnNldC9zaGlmdC9tYXNrIG9mIGVhY2ggZmllbGQKKyAqLworc3RydWN0IGFtYXBfaV90X2RwZHVfY3FlIHsKKwl1OCBkYl9hZGRyX2hpWzMyXTsKKwl1OCBkYl9hZGRyX2xvWzMyXTsKKwl1OCBjb2RlWzZdOworCXU4IGNpZFsxMF07CisJdTggZHBsWzE2XTsKKwl1OCBpbmRleFsxNl07CisJdTggbnVtX2NvbnNbMTBdOworCXU4IHJzdmQwWzRdOworCXU4IGZpbmFsOworCXU4IHZhbGlkOworfSBfX3BhY2tlZDsKKworI2RlZmluZSBDUUVfVkFMSURfTUFTSwkweDgwMDAwMDAwCisjZGVmaW5lIENRRV9DT0RFX01BU0sJMHgwMDAwMDAzRgorI2RlZmluZSBDUUVfQ0lEX01BU0sJMHgwMDAwRkZDMAorCisjZGVmaW5lIEVRRV9WQUxJRF9NQVNLCQkweDAwMDAwMDAxCisjZGVmaW5lIEVRRV9NQUpPUkNPREVfTUFTSwkweDAwMDAwMDBFCisjZGVmaW5lIEVRRV9SRVNJRF9NQVNLCQkweEZGRkYwMDAwCisKK3N0cnVjdCBiZV9lcV9lbnRyeSB7CisJdTMyIGR3WzFdOworfSBfX3BhY2tlZDsKKworLyoqCisgKiBQc2V1ZG8gYW1hcCBkZWZpbml0aW9uIGluIHdoaWNoIGVhY2ggYml0IG9mIHRoZSBhY3R1YWwgc3RydWN0dXJlIGlzIGRlZmluZWQKKyAqIGFzIGEgYnl0ZTogdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9lcV9lbnRyeSB7CisJdTggdmFsaWQ7CQkvKiBEV09SRCAwICovCisJdTggbWFqb3JfY29kZVszXTsJLyogRFdPUkQgMCAqLworCXU4IG1pbm9yX2NvZGVbMTJdOwkvKiBEV09SRCAwICovCisJdTggcmVzb3VyY2VfaWRbMTZdOwkvKiBEV09SRCAwICovCisKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBjcV9kYiB7CisJdTMyIGR3WzFdOworfSBfX3BhY2tlZDsKKworLyoqCisgKiBQc2V1ZG8gYW1hcCBkZWZpbml0aW9uIGluIHdoaWNoIGVhY2ggYml0IG9mIHRoZSBhY3R1YWwgc3RydWN0dXJlIGlzIGRlZmluZWQKKyAqIGFzIGEgYnl0ZTogdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9jcV9kYiB7CisJdTggcWlkWzEwXTsKKwl1OCBldmVudFsxXTsKKwl1OCByc3ZkMFs1XTsKKwl1OCBudW1fcG9wcGVkWzEzXTsKKwl1OCByZWFybVsxXTsKKwl1OCByc3ZkMVsyXTsKK30gX19wYWNrZWQ7CisKK3ZvaWQgYmVpc2NzaV9wcm9jZXNzX2VxKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSk7CisKKworc3RydWN0IGlzY3NpX3dyYiB7CisJdTMyIGR3WzE2XTsKK30gX19wYWNrZWQ7CisKKyNkZWZpbmUgV1JCX1RZUEVfTUFTSyAweEYwMDAwMDAwCisKKy8qKgorICogUHNldWRvIGFtYXAgZGVmaW5pdGlvbiBpbiB3aGljaCBlYWNoIGJpdCBvZiB0aGUgYWN0dWFsIHN0cnVjdHVyZSBpcyBkZWZpbmVkCisgKiBhcyBhIGJ5dGU6IHVzZWQgdG8gY2FsY3VsYXRlIG9mZnNldC9zaGlmdC9tYXNrIG9mIGVhY2ggZmllbGQKKyAqLworc3RydWN0IGFtYXBfaXNjc2lfd3JiIHsKKwl1OCBsdW5bMTRdOwkJLyogRFdPUkQgMCAqLworCXU4IGx0OwkJCS8qIERXT1JEIDAgKi8KKwl1OCBpbnZsZDsJCS8qIERXT1JEIDAgKi8KKwl1OCB3cmJfaWR4WzhdOwkJLyogRFdPUkQgMCAqLworCXU4IGRzcDsJCQkvKiBEV09SRCAwICovCisJdTggZG1zZzsJCS8qIERXT1JEIDAgKi8KKwl1OCB1bmRyX3J1bjsJCS8qIERXT1JEIDAgKi8KKwl1OCBvdmVyX3J1bjsJCS8qIERXT1JEIDAgKi8KKwl1OCB0eXBlWzRdOwkJLyogRFdPUkQgMCAqLworCXU4IHB0cjJuZXh0d3JiWzhdOwkvKiBEV09SRCAxICovCisJdTggcjJ0X2V4cF9kdGxbMjRdOwkvKiBEV09SRCAxICovCisJdTggc2dsX2ljZF9pZHhbMTJdOwkvKiBEV09SRCAyICovCisJdTggcnN2ZDBbMjBdOwkJLyogRFdPUkQgMiAqLworCXU4IGV4cF9kYXRhX3NuWzMyXTsJLyogRFdPUkQgMyAqLworCXU4IGlzY3NpX2Joc19hZGRyX2hpWzMyXTsJLyogRFdPUkQgNCAqLworCXU4IGlzY3NpX2Joc19hZGRyX2xvWzMyXTsJLyogRFdPUkQgNSAqLworCXU4IGNtZHNuX2l0dFszMl07CS8qIERXT1JEIDYgKi8KKwl1OCBkaWZfcmVmX3RhZ1szMl07CS8qIERXT1JEIDcgKi8KKwl1OCBzZ2UwX2FkZHJfaGlbMzJdOwkvKiBEV09SRCA4ICovCisJdTggc2dlMF9hZGRyX2xvWzMyXTsJLyogRFdPUkQgOSAgKi8KKwl1OCBzZ2UwX29mZnNldFsyMl07CS8qIERXT1JEIDEwICovCisJdTggcGJzOwkJCS8qIERXT1JEIDEwICovCisJdTggZGlmX21vZGVbMl07CQkvKiBEV09SRCAxMCAqLworCXU4IHJzdmQxWzZdOwkJLyogRFdPUkQgMTAgKi8KKwl1OCBzZ2UwX2xhc3Q7CQkvKiBEV09SRCAxMCAqLworCXU4IHNnZTBfbGVuWzE3XTsJLyogRFdPUkQgMTEgKi8KKwl1OCBkaWZfbWV0YV90YWdbMTRdOwkvKiBEV09SRCAxMSAqLworCXU4IHNnZTBfaW5fZGRyOwkJLyogRFdPUkQgMTEgKi8KKwl1OCBzZ2UxX2FkZHJfaGlbMzJdOwkvKiBEV09SRCAxMiAqLworCXU4IHNnZTFfYWRkcl9sb1szMl07CS8qIERXT1JEIDEzICovCisJdTggc2dlMV9yMnRfb2Zmc2V0WzIyXTsJLyogRFdPUkQgMTQgKi8KKwl1OCByc3ZkMls5XTsJCS8qIERXT1JEIDE0ICovCisJdTggc2dlMV9sYXN0OwkJLyogRFdPUkQgMTQgKi8KKwl1OCBzZ2UxX2xlblsxN107CS8qIERXT1JEIDE1ICovCisJdTggcmVmX3NnbF9pY2RfaWR4WzEyXTsJLyogRFdPUkQgMTUgKi8KKwl1OCByc3ZkM1syXTsJCS8qIERXT1JEIDE1ICovCisJdTggc2dlMV9pbl9kZHI7CQkvKiBEV09SRCAxNSAqLworCit9IF9fcGFja2VkOworCitzdHJ1Y3Qgd3JiX2hhbmRsZSAqYWxsb2Nfd3JiX2hhbmRsZShzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsIHVuc2lnbmVkIGludCBjaWQsCisJCQkJICAgIGludCBpbmRleCk7Cit2b2lkCitmcmVlX21nbXRfc2dsX2hhbmRsZShzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsIHN0cnVjdCBzZ2xfaGFuZGxlICpwc2dsX2hhbmRsZSk7CisKK3N0cnVjdCBwZHVfbm9wX291dCB7CisJdTMyIGR3WzEyXTsKK307CisKKy8qKgorICogUHNldWRvIGFtYXAgZGVmaW5pdGlvbiBpbiB3aGljaCBlYWNoIGJpdCBvZiB0aGUgYWN0dWFsIHN0cnVjdHVyZSBpcyBkZWZpbmVkCisgKiBhcyBhIGJ5dGU6IHVzZWQgdG8gY2FsY3VsYXRlIG9mZnNldC9zaGlmdC9tYXNrIG9mIGVhY2ggZmllbGQKKyAqLworc3RydWN0IGFtYXBfcGR1X25vcF9vdXQgeworCXU4IG9wY29kZVs2XTsJCS8qIG9wY29kZSAweDAwICovCisJdTggaV9iaXQ7CQkvKiBJIEJpdCAqLworCXU4IHhfYml0OwkJLyogcmVzZXJ2ZWQ7IHNob3VsZCBiZSAwICovCisJdTggZnBfYml0X2ZpbGxlcjFbN107CisJdTggZl9iaXQ7CQkvKiBhbHdheXMgMSAqLworCXU4IHJlc2VydmVkMVsxNl07CisJdTggYWhzX2xlbmd0aFs4XTsJLyogbm8gQUhTICovCisJdTggZGF0YV9sZW5faGlbOF07CisJdTggZGF0YV9sZW5fbG9bMTZdOwkvKiBEYXRhU2VnbWVudExlbmd0aCAqLworCXU4IGx1bls2NF07CisJdTggaXR0WzMyXTsJCS8qIGluaXRpYXRvciBpZCBmb3IgcGluZyBvciAweGZmZmZmZmZmICovCisJdTggdHR0WzMyXTsJCS8qIHRhcmdldCBpZCBmb3IgcGluZyBvciAweGZmZmZmZmZmICovCisJdTggY21kX3NuWzMyXTsKKwl1OCBleHBfc3RhdF9zblszMl07CisJdTggcmVzZXJ2ZWQ1WzEyOF07Cit9OworCisjZGVmaW5lIFBEVUJBU0VfT1BDT0RFX01BU0sJMHgwMDAwMDAzRgorI2RlZmluZSBQRFVCQVNFX0RBVEFMRU5ISV9NQVNLCTB4MDAwMEZGMDAKKyNkZWZpbmUgUERVQkFTRV9EQVRBTEVOTE9fTUFTSwkweEZGRkYwMDAwCisKK3N0cnVjdCBwZHVfYmFzZSB7CisJdTMyIGR3WzE2XTsKK30gX19wYWNrZWQ7CisKKy8qKgorICogUHNldWRvIGFtYXAgZGVmaW5pdGlvbiBpbiB3aGljaCBlYWNoIGJpdCBvZiB0aGUgYWN0dWFsIHN0cnVjdHVyZSBpcyBkZWZpbmVkCisgKiBhcyBhIGJ5dGU6IHVzZWQgdG8gY2FsY3VsYXRlIG9mZnNldC9zaGlmdC9tYXNrIG9mIGVhY2ggZmllbGQKKyAqLworc3RydWN0IGFtYXBfcGR1X2Jhc2UgeworCXU4IG9wY29kZVs2XTsKKwl1OCBpX2JpdDsJCS8qIGltbWVkaWF0ZSBiaXQgKi8KKwl1OCB4X2JpdDsJCS8qIHJlc2VydmVkLCBhbHdheXMgMCAqLworCXU4IHJlc2VydmVkMVsyNF07CS8qIG9wY29kZS1zcGVjaWZpYyBmaWVsZHMgKi8KKwl1OCBhaHNfbGVuZ3RoWzhdOwkvKiBsZW5ndGggdW5pdHMgaXMgNCBieXRlIHdvcmRzICovCisJdTggZGF0YV9sZW5faGlbOF07CisJdTggZGF0YV9sZW5fbG9bMTZdOwkvKiBEYXRhc2VnbWVudExlbmd0aCAqLworCXU4IGx1bls2NF07CQkvKiBsdW4gb3Igb3Bjb2RlLXNwZWNpZmljIGZpZWxkcyAqLworCXU4IGl0dFszMl07CQkvKiBpbml0aWF0b3IgdGFzayB0YWcgKi8KKwl1OCByZXNlcnZlZDRbMjI0XTsKK307CisKK3N0cnVjdCBpc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiIHsKKwl1MzIgZHdbMTZdOworfSBfX3BhY2tlZDsKKworLyoqCisgKiBQc2V1ZG8gYW1hcCBkZWZpbml0aW9uIGluIHdoaWNoIGVhY2ggYml0IG9mIHRoZSBhY3R1YWwgc3RydWN0dXJlIGlzIGRlZmluZWQKKyAqIGFzIGEgYnl0ZTogdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9pc2NzaV90YXJnZXRfY29udGV4dF91cGRhdGVfd3JiIHsKKwl1OCBsdW5bMTRdOwkJLyogRFdPUkQgMCAqLworCXU4IGx0OwkJCS8qIERXT1JEIDAgKi8KKwl1OCBpbnZsZDsJCS8qIERXT1JEIDAgKi8KKwl1OCB3cmJfaWR4WzhdOwkJLyogRFdPUkQgMCAqLworCXU4IGRzcDsJCQkvKiBEV09SRCAwICovCisJdTggZG1zZzsJCS8qIERXT1JEIDAgKi8KKwl1OCB1bmRyX3J1bjsJCS8qIERXT1JEIDAgKi8KKwl1OCBvdmVyX3J1bjsJCS8qIERXT1JEIDAgKi8KKwl1OCB0eXBlWzRdOwkJLyogRFdPUkQgMCAqLworCXU4IHB0cjJuZXh0d3JiWzhdOwkvKiBEV09SRCAxICovCisJdTggbWF4X2J1cnN0X2xlbmd0aFsxOV07CS8qIERXT1JEIDEgKi8KKwl1OCByc3ZkMFs1XTsJCS8qIERXT1JEIDEgKi8KKwl1OCByc3ZkMVsxNV07CQkvKiBEV09SRCAyICovCisJdTggbWF4X3NlbmRfZGF0YV9zZWdtZW50X2xlbmd0aFsxN107CS8qIERXT1JEIDIgKi8KKwl1OCBmaXJzdF9idXJzdF9sZW5ndGhbMTRdOwkvKiBEV09SRCAzICovCisJdTggcnN2ZDJbMl07CQkvKiBEV09SRCAzICovCisJdTggdHhfd3JiaW5kZXhfZHJ2X21zZ1s4XTsJLyogRFdPUkQgMyAqLworCXU4IHJzdmQzWzVdOwkJLyogRFdPUkQgMyAqLworCXU4IHNlc3Npb25fc3RhdGVbM107CS8qIERXT1JEIDMgKi8KKwl1OCByc3ZkNFsxNl07CQkvKiBEV09SRCA0ICovCisJdTggdHhfanVtYm87CQkvKiBEV09SRCA0ICovCisJdTggaGRlOwkJCS8qIERXT1JEIDQgKi8KKwl1OCBkZGU7CQkJLyogRFdPUkQgNCAqLworCXU4IGVybFsyXTsJCS8qIERXT1JEIDQgKi8KKwl1OCBkb21haW5faWRbNV07CQkvKiBEV09SRCA0ICovCisJdTggbW9kZTsJCS8qIERXT1JEIDQgKi8KKwl1OCBpbWQ7CQkJLyogRFdPUkQgNCAqLworCXU4IGlyMnQ7CQkvKiBEV09SRCA0ICovCisJdTggbm90cHJlZGJscVsyXTsJLyogRFdPUkQgNCAqLworCXU4IGNvbXBsdG9uYWNrOwkJLyogRFdPUkQgNCAqLworCXU4IHN0YXRfc25bMzJdOwkJLyogRFdPUkQgNSAqLworCXU4IHBhZF9idWZmZXJfYWRkcl9oaVszMl07CS8qIERXT1JEIDYgKi8KKwl1OCBwYWRfYnVmZmVyX2FkZHJfbG9bMzJdOwkvKiBEV09SRCA3ICovCisJdTggcGFkX2FkZHJfaGlbMzJdOwkvKiBEV09SRCA4ICovCisJdTggcGFkX2FkZHJfbG9bMzJdOwkvKiBEV09SRCA5ICovCisJdTggcnN2ZDVbMzJdOwkJLyogRFdPUkQgMTAgKi8KKwl1OCByc3ZkNlszMl07CQkvKiBEV09SRCAxMSAqLworCXU4IHJzdmQ3WzMyXTsJCS8qIERXT1JEIDEyICovCisJdTggcnN2ZDhbMzJdOwkJLyogRFdPUkQgMTMgKi8KKwl1OCByc3ZkOVszMl07CQkvKiBEV09SRCAxNCAqLworCXU4IHJzdmQxMFszMl07CQkvKiBEV09SRCAxNSAqLworCit9IF9fcGFja2VkOworCitzdHJ1Y3QgYmVfcmluZyB7CisJdTMyIHBhZ2VzOwkJLyogcXVldWUgc2l6ZSBpbiBwYWdlcyAqLworCXUzMiBpZDsJCQkvKiBxdWV1ZSBpZCBhc3NpZ25lZCBieSBiZWtsaWIgKi8KKwl1MzIgbnVtOwkJLyogbnVtYmVyIG9mIGVsZW1lbnRzIGluIHF1ZXVlICovCisJdTMyIGNpZHg7CQkvKiBjb25zdW1lciBpbmRleCAqLworCXUzMiBwaWR4OwkJLyogcHJvZHVjZXIgaW5kZXggLS0gbm90IHVzZWQgYnkgbW9zdCByaW5ncyAqLworCXUzMiBpdGVtX3NpemU7CQkvKiBzaXplIGluIGJ5dGVzIG9mIG9uZSBvYmplY3QgKi8KKworCXZvaWQgKnZhOwkJLyogVGhlIHZpcnR1YWwgYWRkcmVzcyBvZiB0aGUgcmluZy4gIFRoaXMKKwkJCQkgKiBzaG91bGQgYmUgbGFzdCB0byBhbGxvdyAzMiAmIDY0IGJpdCBkZWJ1Z2dlcgorCQkJCSAqIGV4dGVuc2lvbnMgdG8gd29yay4KKwkJCQkgKi8KK307CisKK3N0cnVjdCBod2lfd3JiX2NvbnRleHQgeworCXN0cnVjdCBsaXN0X2hlYWQgd3JiX2hhbmRsZV9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQgd3JiX2hhbmRsZV9kcnZyX2xpc3Q7CisJc3RydWN0IHdyYl9oYW5kbGUgKipwd3JiX2hhbmRsZV9iYXNlOworCXN0cnVjdCB3cmJfaGFuZGxlICoqcHdyYl9oYW5kbGVfYmFzZXN0ZDsKKwlzdHJ1Y3QgaXNjc2lfd3JiICpwbGFzdF93cmI7CisJdW5zaWduZWQgc2hvcnQgYWxsb2NfaW5kZXg7CisJdW5zaWduZWQgc2hvcnQgZnJlZV9pbmRleDsKKwl1bnNpZ25lZCBzaG9ydCB3cmJfaGFuZGxlc19hdmFpbGFibGU7CisJdW5zaWduZWQgc2hvcnQgY2lkOworfTsKKworc3RydWN0IGh3aV9jb250cm9sbGVyIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGlvX3NnbF9saXN0OworCXN0cnVjdCBsaXN0X2hlYWQgZWhfc2dsX2xpc3Q7CisJc3RydWN0IHNnbF9oYW5kbGUgKnBzZ2xfaGFuZGxlX2Jhc2U7CisJdW5zaWduZWQgaW50IHdyYl9tZW1faW5kZXg7CisKKwlzdHJ1Y3QgaHdpX3dyYl9jb250ZXh0IHdyYl9jb250ZXh0W0JFMl9NQVhfU0VTU0lPTlMgKiAyXTsKKwlzdHJ1Y3QgbWNjX3dyYiAqcG1jY193cmJfYmFzZTsKKwlzdHJ1Y3QgYmVfcmluZyBkZWZhdWx0X3BkdV9oZHI7CisJc3RydWN0IGJlX3JpbmcgZGVmYXVsdF9wZHVfZGF0YTsKKwlzdHJ1Y3QgaHdpX2NvbnRleHRfbWVtb3J5ICpwaHdpX2N0eHQ7CisJdW5zaWduZWQgc2hvcnQgY3FfZXJyb3JzW0NYTl9LSUxMRURfQ01ORF9EQVRBX05PVF9PTl9TQU1FX0NPTk5dOworfTsKKworZW51bSBod2hfdHlwZV9lbnVtIHsKKwlIV0hfVFlQRV9JTyA9IDEsCisJSFdIX1RZUEVfTE9HT1VUID0gMiwKKwlIV0hfVFlQRV9UTUYgPSAzLAorCUhXSF9UWVBFX05PUCA9IDQsCisJSFdIX1RZUEVfSU9fUkQgPSA1LAorCUhXSF9UWVBFX0xPR0lOID0gMTEsCisJSFdIX1RZUEVfSU5WQUxJRCA9IDB4RkZGRkZGRkYKK307CisKK3N0cnVjdCB3cmJfaGFuZGxlIHsKKwllbnVtIGh3aF90eXBlX2VudW0gdHlwZTsKKwl1bnNpZ25lZCBzaG9ydCB3cmJfaW5kZXg7CisJdW5zaWduZWQgc2hvcnQgbnh0X3dyYl9pbmRleDsKKworCXN0cnVjdCBpc2NzaV90YXNrICpwaW9faGFuZGxlOworCXN0cnVjdCBpc2NzaV93cmIgKnB3cmI7Cit9OworCitzdHJ1Y3QgaHdpX2NvbnRleHRfbWVtb3J5IHsKKwlzdHJ1Y3QgYmVfZXFfb2JqIGJlX2VxOworCXN0cnVjdCBiZV9xdWV1ZV9pbmZvIGJlX2NxOworCXN0cnVjdCBiZV9xdWV1ZV9pbmZvIGJlX21jY19jcTsKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyBiZV9tY2M7CisKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyBiZV9kZWZfaGRycTsKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyBiZV9kZWZfZGF0YXE7CisKKwlzdHJ1Y3QgYmVfcXVldWVfaW5mbyBiZV93cmJxW0JFMl9NQVhfU0VTU0lPTlNdOworCXN0cnVjdCBiZV9tY2Nfd3JiX2NvbnRleHQgKnBiZV9tY2NfY29udGV4dDsKKworCXN0cnVjdCBod2lfYXN5bmNfcGR1X2NvbnRleHQgKnBhc3luY19jdHg7Cit9OworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9tZ210LmMgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfbWdtdC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEyZTY0NGYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfbWdtdC5jCkBAIC0wLDAgKzEsMzIxIEBACisvKioKKyAqIENvcHlyaWdodCAoQykgMjAwNSAtIDIwMDkgU2VydmVyRW5naW5lcworICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLiAgVGhlIGZ1bGwgR05VIEdlbmVyYWwKKyAqIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluIHRoZSBmaWxlIGNhbGxlZCBDT1BZSU5HLgorICoKKyAqIFdyaXR0ZW4gYnk6IEpheWFtb2hhbiBLYWxsaWNrYWwgKGpheWFtb2hhbmtAc2VydmVyZW5naW5lcy5jb20pCisgKgorICogQ29udGFjdCBJbmZvcm1hdGlvbjoKKyAqIGxpbnV4LWRyaXZlcnNAc2VydmVyZW5naW5lcy5jb20KKyAqCisgKiBTZXJ2ZXJFbmdpbmVzCisgKiAyMDkgTi4gRmFpciBPYWtzIEF2ZQorICogU3Vubnl2YWxlLCBDQSA5NDA4NQorICoKKyAqLworCisjaW5jbHVkZSAiYmVfbWdtdC5oIgorI2luY2x1ZGUgImJlX2lzY3NpLmgiCisKK3Vuc2lnbmVkIGNoYXIgbWdtdF9nZXRfZndfY29uZmlnKHN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwsCisJCQkJc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKQoreworCXN0cnVjdCBiZV9tY2Nfd3JiICp3cmIgPSB3cmJfZnJvbV9tYm94KCZjdHJsLT5tYm94X21lbSk7CisJc3RydWN0IGJlX2Z3X2NmZyAqcmVxID0gZW1iZWRkZWRfcGF5bG9hZCh3cmIpOworCWludCBzdGF0dXMgPSAwOworCisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisKKwliZV93cmJfaGRyX3ByZXBhcmUod3JiLCBzaXplb2YoKnJlcSksIHRydWUsIDApOworCisJYmVfY21kX2hkcl9wcmVwYXJlKCZyZXEtPmhkciwgQ01EX1NVQlNZU1RFTV9DT01NT04sCisJCQkgICBPUENPREVfQ09NTU9OX1FVRVJZX0ZJUk1XQVJFX0NPTkZJRywgc2l6ZW9mKCpyZXEpKTsKKworCXN0YXR1cyA9IGJlX21ib3hfbm90aWZ5KGN0cmwpOworCWlmICghc3RhdHVzKSB7CisJCXN0cnVjdCBiZV9md19jZmcgKnBmd19jZmc7CisJCXBmd19jZmcgPSByZXE7CisJCXBoYmEtPmZ3X2NvbmZpZy5waHlzX3BvcnQgPSBwZndfY2ZnLT5waHlzX3BvcnQ7CisJCXBoYmEtPmZ3X2NvbmZpZy5pc2NzaV9pY2Rfc3RhcnQgPQorCQkJCQlwZndfY2ZnLT51bHBbMF0uaWNkX2Jhc2U7CisJCXBoYmEtPmZ3X2NvbmZpZy5pc2NzaV9pY2RfY291bnQgPQorCQkJCQlwZndfY2ZnLT51bHBbMF0uaWNkX2NvdW50OworCQlwaGJhLT5md19jb25maWcuaXNjc2lfY2lkX3N0YXJ0ID0KKwkJCQkJcGZ3X2NmZy0+dWxwWzBdLnNxX2Jhc2U7CisJCXBoYmEtPmZ3X2NvbmZpZy5pc2NzaV9jaWRfY291bnQgPQorCQkJCQlwZndfY2ZnLT51bHBbMF0uc3FfY291bnQ7CisJfSBlbHNlIHsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgICJGYWlsZWQgaW4gbWdtdF9nZXRfZndfY29uZmlnIFxuIik7CisJfQorCisJc3Bpbl91bmxvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJcmV0dXJuIHN0YXR1czsKK30KKwordW5zaWduZWQgY2hhciBtZ210X2NoZWNrX3N1cHBvcnRlZF9mdyhzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsKQoreworCXN0cnVjdCBiZV9kbWFfbWVtIG5vbmVtYl9jbWQ7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlzdHJ1Y3QgYmVfbWdtdF9jb250cm9sbGVyX2F0dHJpYnV0ZXMgKnJlcTsKKwlzdHJ1Y3QgYmVfc2dlICpzZ2UgPSBub25lbWJlZGRlZF9zZ2wod3JiKTsKKwlpbnQgc3RhdHVzID0gMDsKKworCW5vbmVtYl9jbWQudmEgPSBwY2lfYWxsb2NfY29uc2lzdGVudChjdHJsLT5wZGV2LAorCQkJCXNpemVvZihzdHJ1Y3QgYmVfbWdtdF9jb250cm9sbGVyX2F0dHJpYnV0ZXMpLAorCQkJCSZub25lbWJfY21kLmRtYSk7CisJaWYgKG5vbmVtYl9jbWQudmEgPT0gTlVMTCkgeworCQlTRV9ERUJVRyhEQkdfTFZMXzEsCisJCQkgIkZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIG1nbXRfY2hlY2tfc3VwcG9ydGVkX2Z3IgorCQkJICJcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCW5vbmVtYl9jbWQuc2l6ZSA9IHNpemVvZihzdHJ1Y3QgYmVfbWdtdF9jb250cm9sbGVyX2F0dHJpYnV0ZXMpOworCXJlcSA9IG5vbmVtYl9jbWQudmE7CisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisJYmVfd3JiX2hkcl9wcmVwYXJlKHdyYiwgc2l6ZW9mKCpyZXEpLCBmYWxzZSwgMSk7CisJYmVfY21kX2hkcl9wcmVwYXJlKCZyZXEtPmhkciwgQ01EX1NVQlNZU1RFTV9DT01NT04sCisJCQkgICBPUENPREVfQ09NTU9OX0dFVF9DTlRMX0FUVFJJQlVURVMsIHNpemVvZigqcmVxKSk7CisJc2dlLT5wYV9oaSA9IGNwdV90b19sZTMyKHVwcGVyXzMyX2JpdHMobm9uZW1iX2NtZC5kbWEpKTsKKwlzZ2UtPnBhX2xvID0gY3B1X3RvX2xlMzIobm9uZW1iX2NtZC5kbWEgJiAweEZGRkZGRkZGKTsKKwlzZ2UtPmxlbiA9IGNwdV90b19sZTMyKG5vbmVtYl9jbWQuc2l6ZSk7CisKKwlzdGF0dXMgPSBiZV9tYm94X25vdGlmeShjdHJsKTsKKwlpZiAoIXN0YXR1cykgeworCQlzdHJ1Y3QgYmVfbWdtdF9jb250cm9sbGVyX2F0dHJpYnV0ZXNfcmVzcCAqcmVzcCA9IG5vbmVtYl9jbWQudmE7CisJCVNFX0RFQlVHKERCR19MVkxfOCwgIkZpcm13YXJlIHZlcnNpb24gb2YgQ01EOiAlc1xuIiwKKwkJCXJlc3AtPnBhcmFtcy5oYmFfYXR0cmlicy5mbGFzaHJvbV92ZXJzaW9uX3N0cmluZyk7CisJCVNFX0RFQlVHKERCR19MVkxfOCwgIkZpcm13YXJlIHZlcnNpb24gaXMgOiAlc1xuIiwKKwkJCXJlc3AtPnBhcmFtcy5oYmFfYXR0cmlicy5maXJtd2FyZV92ZXJzaW9uX3N0cmluZyk7CisJCVNFX0RFQlVHKERCR19MVkxfOCwKKwkJCSJEZXZlbG9wZXIgQnVpbGQsIG5vdCBwZXJmb3JtaW5nIHZlcnNpb24gY2hlY2suLi5cbiIpOworCisJfSBlbHNlCisJCVNFX0RFQlVHKERCR19MVkxfMSwgIiBGYWlsZWQgaW4gbWdtdF9jaGVja19zdXBwb3J0ZWRfZndcbiIpOworCWlmIChub25lbWJfY21kLnZhKQorCQlwY2lfZnJlZV9jb25zaXN0ZW50KGN0cmwtPnBkZXYsIG5vbmVtYl9jbWQuc2l6ZSwKKwkJCQkgICAgbm9uZW1iX2NtZC52YSwgbm9uZW1iX2NtZC5kbWEpOworCisJc3Bpbl91bmxvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJcmV0dXJuIHN0YXR1czsKK30KKwordW5zaWduZWQgY2hhciBtZ210X2VwZndfY2xlYW51cChzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsIHVuc2lnbmVkIHNob3J0IGNodXRlKQoreworCXN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwgPSAmcGhiYS0+Y3RybDsKKwlzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiID0gd3JiX2Zyb21fbWJveCgmY3RybC0+bWJveF9tZW0pOworCXN0cnVjdCBpc2NzaV9jbGVhbnVwX3JlcSAqcmVxID0gZW1iZWRkZWRfcGF5bG9hZCh3cmIpOworCWludCBzdGF0dXMgPSAwOworCisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisKKwliZV93cmJfaGRyX3ByZXBhcmUod3JiLCBzaXplb2YoKnJlcSksIHRydWUsIDApOworCWJlX2NtZF9oZHJfcHJlcGFyZSgmcmVxLT5oZHIsIENNRF9TVUJTWVNURU1fSVNDU0ksCisJCQkgICBPUENPREVfQ09NTU9OX0lTQ1NJX0NMRUFOVVAsIHNpemVvZigqcmVxKSk7CisKKwlyZXEtPmNodXRlID0gY2h1dGU7CisJcmVxLT5oZHJfcmluZ19pZCA9IDA7CisJcmVxLT5kYXRhX3JpbmdfaWQgPSAwOworCisJc3RhdHVzID0gYmVfbWJveF9ub3RpZnkoY3RybCk7CisJaWYgKHN0YXR1cykKKwkJc2hvc3RfcHJpbnRrKEtFUk5fV0FSTklORywgcGhiYS0+c2hvc3QsCisJCQkgICAgICIgbWdtdF9lcGZ3X2NsZWFudXAgLCBGQUlMRURcbiIpOworCXNwaW5fdW5sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCXJldHVybiBzdGF0dXM7Cit9CisKK3Vuc2lnbmVkIGNoYXIgbWdtdF9pbnZhbGlkYXRlX2ljZHMoc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJCSAgIHVuc2lnbmVkIGludCBpY2QsIHVuc2lnbmVkIGludCBjaWQpCit7CisJc3RydWN0IGJlX2RtYV9tZW0gbm9uZW1iX2NtZDsKKwlzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsID0gJnBoYmEtPmN0cmw7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlzdHJ1Y3QgYmVfc2dlICpzZ2UgPSBub25lbWJlZGRlZF9zZ2wod3JiKTsKKwlzdHJ1Y3QgaW52YWxpZGF0ZV9jb21tYW5kc19wYXJhbXNfaW4gKnJlcTsKKwlpbnQgc3RhdHVzID0gMDsKKworCW5vbmVtYl9jbWQudmEgPSBwY2lfYWxsb2NfY29uc2lzdGVudChjdHJsLT5wZGV2LAorCQkJCXNpemVvZihzdHJ1Y3QgaW52YWxpZGF0ZV9jb21tYW5kc19wYXJhbXNfaW4pLAorCQkJCSZub25lbWJfY21kLmRtYSk7CisJaWYgKG5vbmVtYl9jbWQudmEgPT0gTlVMTCkgeworCQlTRV9ERUJVRyhEQkdfTFZMXzEsCisJCQkgIkZhaWxlZCB0byBhbGxvY2F0ZSBtZW1vcnkgZm9yIgorCQkJICJtZ210X2ludmFsaWRhdGVfaWNkcyBcbiIpOworCQlyZXR1cm4gLTE7CisJfQorCW5vbmVtYl9jbWQuc2l6ZSA9IHNpemVvZihzdHJ1Y3QgaW52YWxpZGF0ZV9jb21tYW5kc19wYXJhbXNfaW4pOworCXJlcSA9IG5vbmVtYl9jbWQudmE7CisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisKKwliZV93cmJfaGRyX3ByZXBhcmUod3JiLCBzaXplb2YoKnJlcSksIGZhbHNlLCAxKTsKKwliZV9jbWRfaGRyX3ByZXBhcmUoJnJlcS0+aGRyLCBDTURfU1VCU1lTVEVNX0lTQ1NJLAorCQkJT1BDT0RFX0NPTU1PTl9JU0NTSV9FUlJPUl9SRUNPVkVSWV9JTlZBTElEQVRFX0NPTU1BTkRTLAorCQkJc2l6ZW9mKCpyZXEpKTsKKwlyZXEtPnJlZl9oYW5kbGUgPSAwOworCXJlcS0+Y2xlYW51cF90eXBlID0gQ01EX0lTQ1NJX0NPTU1BTkRfSU5WQUxJREFURTsKKwlyZXEtPmljZF9jb3VudCA9IDA7CisJcmVxLT50YWJsZVtyZXEtPmljZF9jb3VudF0uaWNkID0gaWNkOworCXJlcS0+dGFibGVbcmVxLT5pY2RfY291bnRdLmNpZCA9IGNpZDsKKwlzZ2UtPnBhX2hpID0gY3B1X3RvX2xlMzIodXBwZXJfMzJfYml0cyhub25lbWJfY21kLmRtYSkpOworCXNnZS0+cGFfbG8gPSBjcHVfdG9fbGUzMihub25lbWJfY21kLmRtYSAmIDB4RkZGRkZGRkYpOworCXNnZS0+bGVuID0gY3B1X3RvX2xlMzIobm9uZW1iX2NtZC5zaXplKTsKKworCXN0YXR1cyA9IGJlX21ib3hfbm90aWZ5KGN0cmwpOworCWlmIChzdGF0dXMpCisJCVNFX0RFQlVHKERCR19MVkxfMSwgIklDRFMgSW52YWxpZGF0aW9uIEZhaWxlZFxuIik7CisJc3Bpbl91bmxvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJaWYgKG5vbmVtYl9jbWQudmEpCisJCXBjaV9mcmVlX2NvbnNpc3RlbnQoY3RybC0+cGRldiwgbm9uZW1iX2NtZC5zaXplLAorCQkJCSAgICBub25lbWJfY21kLnZhLCBub25lbWJfY21kLmRtYSk7CisJcmV0dXJuIHN0YXR1czsKK30KKwordW5zaWduZWQgY2hhciBtZ210X2ludmFsaWRhdGVfY29ubmVjdGlvbihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkJCSBzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcCwKKwkJCQkJIHVuc2lnbmVkIHNob3J0IGNpZCwKKwkJCQkJIHVuc2lnbmVkIHNob3J0IGlzc3VlX3Jlc2V0LAorCQkJCQkgdW5zaWduZWQgc2hvcnQgc2F2ZWNmZ19mbGFnKQoreworCXN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwgPSAmcGhiYS0+Y3RybDsKKwlzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiID0gd3JiX2Zyb21fbWJveCgmY3RybC0+bWJveF9tZW0pOworCXN0cnVjdCBpc2NzaV9pbnZhbGlkYXRlX2Nvbm5lY3Rpb25fcGFyYW1zX2luICpyZXEgPQorCQkJCQkJZW1iZWRkZWRfcGF5bG9hZCh3cmIpOworCWludCBzdGF0dXMgPSAwOworCisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisKKwliZV93cmJfaGRyX3ByZXBhcmUod3JiLCBzaXplb2YoKnJlcSksIHRydWUsIDApOworCWJlX2NtZF9oZHJfcHJlcGFyZSgmcmVxLT5oZHIsIENNRF9TVUJTWVNURU1fSVNDU0lfSU5JLAorCQkJICAgT1BDT0RFX0lTQ1NJX0lOSV9EUklWRVJfSU5WQUxJREFURV9DT05ORUNUSU9OLAorCQkJICAgc2l6ZW9mKCpyZXEpKTsKKwlyZXEtPnNlc3Npb25faGFuZGxlID0gYmVpc2NzaV9lcC0+ZndfaGFuZGxlOworCXJlcS0+Y2lkID0gY2lkOworCWlmIChpc3N1ZV9yZXNldCkKKwkJcmVxLT5jbGVhbnVwX3R5cGUgPSBDTURfSVNDU0lfQ09OTkVDVElPTl9JU1NVRV9UQ1BfUlNUOworCWVsc2UKKwkJcmVxLT5jbGVhbnVwX3R5cGUgPSBDTURfSVNDU0lfQ09OTkVDVElPTl9JTlZBTElEQVRFOworCXJlcS0+c2F2ZV9jZmcgPSBzYXZlY2ZnX2ZsYWc7CisJc3RhdHVzID0gYmVfbWJveF9ub3RpZnkoY3RybCk7CisJaWYgKHN0YXR1cykKKwkJU0VfREVCVUcoREJHX0xWTF8xLCAiSW52YWxpZGF0aW9uIEZhaWxlZFxuIik7CisKKwlzcGluX3VubG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwlyZXR1cm4gc3RhdHVzOworfQorCit1bnNpZ25lZCBjaGFyIG1nbXRfdXBsb2FkX2Nvbm5lY3Rpb24oc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhLAorCQkJCXVuc2lnbmVkIHNob3J0IGNpZCwgdW5zaWduZWQgaW50IHVwbG9hZF9mbGFnKQoreworCXN0cnVjdCBiZV9jdHJsX2luZm8gKmN0cmwgPSAmcGhiYS0+Y3RybDsKKwlzdHJ1Y3QgYmVfbWNjX3dyYiAqd3JiID0gd3JiX2Zyb21fbWJveCgmY3RybC0+bWJveF9tZW0pOworCXN0cnVjdCB0Y3BfdXBsb2FkX3BhcmFtc19pbiAqcmVxID0gZW1iZWRkZWRfcGF5bG9hZCh3cmIpOworCWludCBzdGF0dXMgPSAwOworCisJc3Bpbl9sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCW1lbXNldCh3cmIsIDAsIHNpemVvZigqd3JiKSk7CisKKwliZV93cmJfaGRyX3ByZXBhcmUod3JiLCBzaXplb2YoKnJlcSksIHRydWUsIDApOworCWJlX2NtZF9oZHJfcHJlcGFyZSgmcmVxLT5oZHIsIENNRF9DT01NT05fVENQX1VQTE9BRCwKKwkJCSAgIE9QQ09ERV9DT01NT05fVENQX1VQTE9BRCwgc2l6ZW9mKCpyZXEpKTsKKwlyZXEtPmlkID0gKHVuc2lnbmVkIHNob3J0KWNpZDsKKwlyZXEtPnVwbG9hZF90eXBlID0gKHVuc2lnbmVkIGNoYXIpdXBsb2FkX2ZsYWc7CisJc3RhdHVzID0gYmVfbWJveF9ub3RpZnkoY3RybCk7CisJaWYgKHN0YXR1cykKKwkJU0VfREVCVUcoREJHX0xWTF8xLCAibWdtdF91cGxvYWRfY29ubmVjdGlvbiBGYWlsZWRcbiIpOworCXNwaW5fdW5sb2NrKCZjdHJsLT5tYm94X2xvY2spOworCXJldHVybiBzdGF0dXM7Cit9CisKK2ludCBtZ210X29wZW5fY29ubmVjdGlvbihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkgc3RydWN0IHNvY2thZGRyICpkc3RfYWRkciwKKwkJCSBzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcCkKK3sKKwlzdHJ1Y3QgaHdpX2NvbnRyb2xsZXIgKnBod2lfY3RybHI7CisJc3RydWN0IGh3aV9jb250ZXh0X21lbW9yeSAqcGh3aV9jb250ZXh0OworCXN0cnVjdCBzb2NrYWRkcl9pbiAqZGFkZHJfaW4gPSAoc3RydWN0IHNvY2thZGRyX2luICopZHN0X2FkZHI7CisJc3RydWN0IHNvY2thZGRyX2luNiAqZGFkZHJfaW42ID0gKHN0cnVjdCBzb2NrYWRkcl9pbjYgKilkc3RfYWRkcjsKKwlzdHJ1Y3QgYmVfY3RybF9pbmZvICpjdHJsID0gJnBoYmEtPmN0cmw7CisJc3RydWN0IGJlX21jY193cmIgKndyYiA9IHdyYl9mcm9tX21ib3goJmN0cmwtPm1ib3hfbWVtKTsKKwlzdHJ1Y3QgdGNwX2Nvbm5lY3RfYW5kX29mZmxvYWRfaW4gKnJlcSA9IGVtYmVkZGVkX3BheWxvYWQod3JiKTsKKwl1bnNpZ25lZCBzaG9ydCBkZWZfaGRyX2lkOworCXVuc2lnbmVkIHNob3J0IGRlZl9kYXRhX2lkOworCXN0cnVjdCBwaHlzX2FkZHIgdGVtcGxhdGVfYWRkcmVzcyA9IHsgMCwgMCB9OworCXN0cnVjdCBwaHlzX2FkZHIgKnB0ZW1wbGF0ZV9hZGRyZXNzOworCWludCBzdGF0dXMgPSAwOworCXVuc2lnbmVkIHNob3J0IGNpZCA9IGJlaXNjc2lfZXAtPmVwX2NpZDsKKworCXBod2lfY3RybHIgPSBwaGJhLT5waHdpX2N0cmxyOworCXBod2lfY29udGV4dCA9IHBod2lfY3RybHItPnBod2lfY3R4dDsKKwlkZWZfaGRyX2lkID0gKHVuc2lnbmVkIHNob3J0KUhXSV9HRVRfREVGX0hEUlFfSUQocGhiYSk7CisJZGVmX2RhdGFfaWQgPSAodW5zaWduZWQgc2hvcnQpSFdJX0dFVF9ERUZfQlVGUV9JRChwaGJhKTsKKworCXB0ZW1wbGF0ZV9hZGRyZXNzID0gJnRlbXBsYXRlX2FkZHJlc3M7CisJSVNDU0lfR0VUX1BEVV9URU1QTEFURV9BRERSRVNTKHBoYmEsIHB0ZW1wbGF0ZV9hZGRyZXNzKTsKKwlzcGluX2xvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJbWVtc2V0KHdyYiwgMCwgc2l6ZW9mKCp3cmIpKTsKKworCWJlX3dyYl9oZHJfcHJlcGFyZSh3cmIsIHNpemVvZigqcmVxKSwgdHJ1ZSwgMCk7CisJYmVfY21kX2hkcl9wcmVwYXJlKCZyZXEtPmhkciwgQ01EX1NVQlNZU1RFTV9JU0NTSSwKKwkJCSAgIE9QQ09ERV9DT01NT05fSVNDU0lfVENQX0NPTk5FQ1RfQU5EX09GRkxPQUQsCisJCQkgICBzaXplb2YoKnJlcSkpOworCWlmIChkc3RfYWRkci0+c2FfZmFtaWx5ID09IFBGX0lORVQpIHsKKwkJX19iZTMyIHNfYWRkciA9IGRhZGRyX2luLT5zaW5fYWRkci5zX2FkZHI7CisJCXJlcS0+aXBfYWRkcmVzcy5pcF90eXBlID0gQkUyX0lQVjQ7CisJCXJlcS0+aXBfYWRkcmVzcy5pcF9hZGRyZXNzWzBdID0gc19hZGRyICYgMHgwMDAwMDBmZjsKKwkJcmVxLT5pcF9hZGRyZXNzLmlwX2FkZHJlc3NbMV0gPSAoc19hZGRyICYgMHgwMDAwZmYwMCkgPj4gODsKKwkJcmVxLT5pcF9hZGRyZXNzLmlwX2FkZHJlc3NbMl0gPSAoc19hZGRyICYgMHgwMGZmMDAwMCkgPj4gMTY7CisJCXJlcS0+aXBfYWRkcmVzcy5pcF9hZGRyZXNzWzNdID0gKHNfYWRkciAmIDB4ZmYwMDAwMDApID4+IDI0OworCQlyZXEtPnRjcF9wb3J0ID0gbnRvaHMoZGFkZHJfaW4tPnNpbl9wb3J0KTsKKwkJYmVpc2NzaV9lcC0+ZHN0X2FkZHIgPSBkYWRkcl9pbi0+c2luX2FkZHIuc19hZGRyOworCQliZWlzY3NpX2VwLT5kc3RfdGNwcG9ydCA9IG50b2hzKGRhZGRyX2luLT5zaW5fcG9ydCk7CisJCWJlaXNjc2lfZXAtPmlwX3R5cGUgPSBCRTJfSVBWNDsKKwl9IGVsc2UgaWYgKGRzdF9hZGRyLT5zYV9mYW1pbHkgPT0gUEZfSU5FVDYpIHsKKwkJcmVxLT5pcF9hZGRyZXNzLmlwX3R5cGUgPSBCRTJfSVBWNjsKKwkJbWVtY3B5KCZyZXEtPmlwX2FkZHJlc3MuaXBfYWRkcmVzcywKKwkJICAgICAgICZkYWRkcl9pbjYtPnNpbjZfYWRkci5pbjZfdS51Nl9hZGRyOCwgMTYpOworCQlyZXEtPnRjcF9wb3J0ID0gbnRvaHMoZGFkZHJfaW42LT5zaW42X3BvcnQpOworCQliZWlzY3NpX2VwLT5kc3RfdGNwcG9ydCA9IG50b2hzKGRhZGRyX2luNi0+c2luNl9wb3J0KTsKKwkJbWVtY3B5KCZiZWlzY3NpX2VwLT5kc3Q2X2FkZHIsCisJCSAgICAgICAmZGFkZHJfaW42LT5zaW42X2FkZHIuaW42X3UudTZfYWRkcjgsIDE2KTsKKwkJYmVpc2NzaV9lcC0+aXBfdHlwZSA9IEJFMl9JUFY2OworCX0gZWxzZXsKKwkJc2hvc3RfcHJpbnRrKEtFUk5fRVJSLCBwaGJhLT5zaG9zdCwgInVua25vd24gYWRkciBmYW1pbHkgJWRcbiIsCisJCQkgICAgIGRzdF9hZGRyLT5zYV9mYW1pbHkpOworCQlzcGluX3VubG9jaygmY3RybC0+bWJveF9sb2NrKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwl9CisJcmVxLT5jaWQgPSBjaWQ7CisJcmVxLT5jcV9pZCA9IHBod2lfY29udGV4dC0+YmVfY3EuaWQ7CisJcmVxLT5kZWZxX2lkID0gZGVmX2hkcl9pZDsKKwlyZXEtPmhkcl9yaW5nX2lkID0gZGVmX2hkcl9pZDsKKwlyZXEtPmRhdGFfcmluZ19pZCA9IGRlZl9kYXRhX2lkOworCXJlcS0+ZG9fb2ZmbG9hZCA9IDE7CisJcmVxLT5kYXRhb3V0X3RlbXBsYXRlX3BhLmxvID0gcHRlbXBsYXRlX2FkZHJlc3MtPmxvOworCXJlcS0+ZGF0YW91dF90ZW1wbGF0ZV9wYS5oaSA9IHB0ZW1wbGF0ZV9hZGRyZXNzLT5oaTsKKwlzdGF0dXMgPSBiZV9tYm94X25vdGlmeShjdHJsKTsKKwlpZiAoIXN0YXR1cykgeworCQlzdHJ1Y3QgaXNjc2lfZW5kcG9pbnQgKmVwOworCQlzdHJ1Y3QgdGNwX2Nvbm5lY3RfYW5kX29mZmxvYWRfb3V0ICpwdGNwY25jdF9vdXQgPQorCQkJCQkJCWVtYmVkZGVkX3BheWxvYWQod3JiKTsKKworCQllcCA9IHBoYmEtPmVwX2FycmF5W3B0Y3BjbmN0X291dC0+Y2lkXTsKKwkJYmVpc2NzaV9lcCA9IGVwLT5kZF9kYXRhOworCQliZWlzY3NpX2VwLT5md19oYW5kbGUgPSAwOworCQliZWlzY3NpX2VwLT5jaWRfdmxkID0gMTsKKwkJU0VfREVCVUcoREJHX0xWTF84LCAibWdtdF9vcGVuX2Nvbm5lY3Rpb24gU3VjY2Vzc1xuIik7CisJfSBlbHNlCisJCVNFX0RFQlVHKERCR19MVkxfMSwgIm1nbXRfb3Blbl9jb25uZWN0aW9uIEZhaWxlZFxuIik7CisJc3Bpbl91bmxvY2soJmN0cmwtPm1ib3hfbG9jayk7CisJcmV0dXJuIHN0YXR1czsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZTJpc2NzaS9iZV9tZ210LmggYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfbWdtdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjAwZTgxNmUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmUyaXNjc2kvYmVfbWdtdC5oCkBAIC0wLDAgKzEsMjQ5IEBACisvKioKKyAqIENvcHlyaWdodCAoQykgMjAwNSAtIDIwMDkgU2VydmVyRW5naW5lcworICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCisgKiBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIKKyAqIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLiAgVGhlIGZ1bGwgR05VIEdlbmVyYWwKKyAqIFB1YmxpYyBMaWNlbnNlIGlzIGluY2x1ZGVkIGluIHRoaXMgZGlzdHJpYnV0aW9uIGluIHRoZSBmaWxlIGNhbGxlZCBDT1BZSU5HLgorICoKKyAqIFdyaXR0ZW4gYnk6IEpheWFtb2hhbiBLYWxsaWNrYWwgKGpheWFtb2hhbmtAc2VydmVyZW5naW5lcy5jb20pCisgKgorICogQ29udGFjdCBJbmZvcm1hdGlvbjoKKyAqIGxpbnV4LWRyaXZlcnNAc2VydmVyZW5naW5lcy5jb20KKyAqCisgKiBTZXJ2ZXJFbmdpbmVzCisgKiAyMDkgTi4gRmFpciBPYWtzIEF2ZQorICogU3Vubnl2YWxlLCBDQSA5NDA4NQorICoKKyAqLworCisjaWZuZGVmIF9CRUlTQ1NJX01HTVRfCisjZGVmaW5lIF9CRUlTQ1NJX01HTVRfCisKKyNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgorI2luY2x1ZGUgPGxpbnV4L2xpc3QuaD4KKyNpbmNsdWRlICJiZV9pc2NzaS5oIgorI2luY2x1ZGUgImJlX21haW4uaCIKKworLyoqCisgKiBQc2V1ZG8gYW1hcCBkZWZpbml0aW9uIGluIHdoaWNoIGVhY2ggYml0IG9mIHRoZSBhY3R1YWwgc3RydWN0dXJlIGlzIGRlZmluZWQKKyAqIGFzIGEgYnl0ZTogdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9tY2Nfc2dlIHsKKwl1OCBwYV9sb1szMl07CQkvKiBkd29yZCAwICovCisJdTggcGFfaGlbMzJdOwkJLyogZHdvcmQgMSAqLworCXU4IGxlbmd0aFszMl07CQkvKiBEV09SRCAyICovCit9IF9fcGFja2VkOworCisvKioKKyAqIFBzZXVkbyBhbWFwIGRlZmluaXRpb24gaW4gd2hpY2ggZWFjaCBiaXQgb2YgdGhlIGFjdHVhbCBzdHJ1Y3R1cmUgaXMgZGVmaW5lZAorICogYXMgYSBieXRlOiB1c2VkIHRvIGNhbGN1bGF0ZSBvZmZzZXQvc2hpZnQvbWFzayBvZiBlYWNoIGZpZWxkCisgKi8KK3N0cnVjdCBhbWFwX21jY193cmJfcGF5bG9hZCB7CisJdW5pb24geworCQlzdHJ1Y3QgYW1hcF9tY2Nfc2dlIHNnbFsxOV07CisJCXU4IGVtYmVkZGVkWzU5ICogMzJdOwkvKiBEV09SRFMgNTcgdG8gMTE1ICovCisJfSB1OworfSBfX3BhY2tlZDsKKworLyoqCisgKiBQc2V1ZG8gYW1hcCBkZWZpbml0aW9uIGluIHdoaWNoIGVhY2ggYml0IG9mIHRoZSBhY3R1YWwgc3RydWN0dXJlIGlzIGRlZmluZWQKKyAqIGFzIGEgYnl0ZTogdXNlZCB0byBjYWxjdWxhdGUgb2Zmc2V0L3NoaWZ0L21hc2sgb2YgZWFjaCBmaWVsZAorICovCitzdHJ1Y3QgYW1hcF9tY2Nfd3JiIHsKKwl1OCBlbWJlZGRlZDsJCS8qIERXT1JEIDAgKi8KKwl1OCByc3ZkMFsyXTsJCS8qIERXT1JEIDAgKi8KKwl1OCBzZ2VfY291bnRbNV07CS8qIERXT1JEIDAgKi8KKwl1OCByc3ZkMVsxNl07CQkvKiBEV09SRCAwICovCisJdTggc3BlY2lhbFs4XTsJCS8qIERXT1JEIDAgKi8KKwl1OCBwYXlsb2FkX2xlbmd0aFszMl07CisJdTggdGFnWzY0XTsJCS8qIERXT1JEIDIgKi8KKwl1OCByc3ZkMlszMl07CQkvKiBEV09SRCA0ICovCisJc3RydWN0IGFtYXBfbWNjX3dyYl9wYXlsb2FkIHBheWxvYWQ7Cit9OworCitzdHJ1Y3QgbWNjX3NnZSB7CisJdTMyIHBhX2xvOwkJLyogZHdvcmQgMCAqLworCXUzMiBwYV9oaTsJCS8qIGR3b3JkIDEgKi8KKwl1MzIgbGVuZ3RoOwkJLyogRFdPUkQgMiAqLworfSBfX3BhY2tlZDsKKworc3RydWN0IG1jY193cmJfcGF5bG9hZCB7CisJdW5pb24geworCQlzdHJ1Y3QgbWNjX3NnZSBzZ2xbMTldOworCQl1MzIgZW1iZWRkZWRbNTldOwkvKiBEV09SRFMgNTcgdG8gMTE1ICovCisJfSB1OworfSBfX3BhY2tlZDsKKworI2RlZmluZSBNQ0NfV1JCX0VNQkVEREVEX01BU0sgICAgICAgICAgICAgICAgMHgwMDAwMDAwMQorCitzdHJ1Y3QgbWNjX3dyYiB7CisJdTMyIGR3WzBdOwkJLyogRFdPUkQgMCAqLworCXUzMiBwYXlsb2FkX2xlbmd0aDsKKwl1MzIgdGFnWzJdOwkJLyogRFdPUkQgMiAqLworCXUzMiByc3ZkMlsxXTsJCS8qIERXT1JEIDQgKi8KKwlzdHJ1Y3QgbWNjX3dyYl9wYXlsb2FkIHBheWxvYWQ7Cit9OworCit1bnNpZ25lZCBjaGFyIG1nbXRfZXBmd19jbGVhbnVwKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgdW5zaWduZWQgc2hvcnQgY2h1dGUpOworaW50IG1nbXRfb3Blbl9jb25uZWN0aW9uKHN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYSwgc3RydWN0IHNvY2thZGRyICpkc3RfYWRkciwKKwkJCSBzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcCk7CisKK3Vuc2lnbmVkIGNoYXIgbWdtdF91cGxvYWRfY29ubmVjdGlvbihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkJICAgICB1bnNpZ25lZCBzaG9ydCBjaWQsCisJCQkJICAgICB1bnNpZ25lZCBpbnQgdXBsb2FkX2ZsYWcpOwordW5zaWduZWQgY2hhciBtZ210X2ludmFsaWRhdGVfaWNkcyhzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkJICAgdW5zaWduZWQgaW50IGljZCwgdW5zaWduZWQgaW50IGNpZCk7CisKK3N0cnVjdCBpc2NzaV9pbnZhbGlkYXRlX2Nvbm5lY3Rpb25fcGFyYW1zX2luIHsKKwlzdHJ1Y3QgYmVfY21kX3JlcV9oZHIgaGRyOworCXVuc2lnbmVkIGludCBzZXNzaW9uX2hhbmRsZTsKKwl1bnNpZ25lZCBzaG9ydCBjaWQ7CisJdW5zaWduZWQgc2hvcnQgdW51c2VkOworCXVuc2lnbmVkIHNob3J0IGNsZWFudXBfdHlwZTsKKwl1bnNpZ25lZCBzaG9ydCBzYXZlX2NmZzsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBpc2NzaV9pbnZhbGlkYXRlX2Nvbm5lY3Rpb25fcGFyYW1zX291dCB7CisJdW5zaWduZWQgaW50IHNlc3Npb25faGFuZGxlOworCXVuc2lnbmVkIHNob3J0IGNpZDsKKwl1bnNpZ25lZCBzaG9ydCB1bnVzZWQ7Cit9IF9fcGFja2VkOworCit1bmlvbiBpc2NzaV9pbnZhbGlkYXRlX2Nvbm5lY3Rpb25fcGFyYW1zIHsKKwlzdHJ1Y3QgaXNjc2lfaW52YWxpZGF0ZV9jb25uZWN0aW9uX3BhcmFtc19pbiByZXF1ZXN0OworCXN0cnVjdCBpc2NzaV9pbnZhbGlkYXRlX2Nvbm5lY3Rpb25fcGFyYW1zX291dCByZXNwb25zZTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBpbnZhbGlkYXRlX2NvbW1hbmRfdGFibGUgeworCXVuc2lnbmVkIHNob3J0IGljZDsKKwl1bnNpZ25lZCBzaG9ydCBjaWQ7Cit9IF9fcGFja2VkOworCitzdHJ1Y3QgaW52YWxpZGF0ZV9jb21tYW5kc19wYXJhbXNfaW4geworCXN0cnVjdCBiZV9jbWRfcmVxX2hkciBoZHI7CisJdW5zaWduZWQgaW50IHJlZl9oYW5kbGU7CisJdW5zaWduZWQgaW50IGljZF9jb3VudDsKKwlzdHJ1Y3QgaW52YWxpZGF0ZV9jb21tYW5kX3RhYmxlIHRhYmxlWzEyOF07CisJdW5zaWduZWQgc2hvcnQgY2xlYW51cF90eXBlOworCXVuc2lnbmVkIHNob3J0IHVudXNlZDsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBpbnZhbGlkYXRlX2NvbW1hbmRzX3BhcmFtc19vdXQgeworCXVuc2lnbmVkIGludCByZWZfaGFuZGxlOworCXVuc2lnbmVkIGludCBpY2RfY291bnQ7CisJdW5zaWduZWQgaW50IGljZF9zdGF0dXNbMTI4XTsKK30gX19wYWNrZWQ7CisKK3VuaW9uIGludmFsaWRhdGVfY29tbWFuZHNfcGFyYW1zIHsKKwlzdHJ1Y3QgaW52YWxpZGF0ZV9jb21tYW5kc19wYXJhbXNfaW4gcmVxdWVzdDsKKwlzdHJ1Y3QgaW52YWxpZGF0ZV9jb21tYW5kc19wYXJhbXNfb3V0IHJlc3BvbnNlOworfSBfX3BhY2tlZDsKKworc3RydWN0IG1nbXRfaGJhX2F0dHJpYnV0ZXMgeworCXU4IGZsYXNocm9tX3ZlcnNpb25fc3RyaW5nWzMyXTsKKwl1OCBtYW51ZmFjdHVyZXJfbmFtZVszMl07CisJdTMyIHN1cHBvcnRlZF9tb2RlczsKKwl1OCBzZWVwcm9tX3ZlcnNpb25fbG87CisJdTggc2VlcHJvbV92ZXJzaW9uX2hpOworCXU4IHJzdmQwWzJdOworCXUzMiBmd19jbWRfZGF0YV9zdHJ1Y3RfdmVyc2lvbjsKKwl1MzIgZXBfZndfZGF0YV9zdHJ1Y3RfdmVyc2lvbjsKKwl1MzIgZnV0dXJlX3Jlc2VydmVkWzEyXTsKKwl1MzIgZGVmYXVsdF9leHRlbmRlZF90aW1lb3V0OworCXU4IGNvbnRyb2xsZXJfbW9kZWxfbnVtYmVyWzMyXTsKKwl1OCBjb250cm9sbGVyX2Rlc2NyaXB0aW9uWzY0XTsKKwl1OCBjb250cm9sbGVyX3NlcmlhbF9udW1iZXJbMzJdOworCXU4IGlwX3ZlcnNpb25fc3RyaW5nWzMyXTsKKwl1OCBmaXJtd2FyZV92ZXJzaW9uX3N0cmluZ1szMl07CisJdTggYmlvc192ZXJzaW9uX3N0cmluZ1szMl07CisJdTggcmVkYm9vdF92ZXJzaW9uX3N0cmluZ1szMl07CisJdTggZHJpdmVyX3ZlcnNpb25fc3RyaW5nWzMyXTsKKwl1OCBmd19vbl9mbGFzaF92ZXJzaW9uX3N0cmluZ1szMl07CisJdTMyIGZ1bmN0aW9uYWxpdGllc19zdXBwb3J0ZWQ7CisJdTE2IG1heF9jZGJsZW5ndGg7CisJdTggYXNpY19yZXZpc2lvbjsKKwl1OCBnZW5lcmF0aW9uYWxfZ3VpZFsxNl07CisJdTggaGJhX3BvcnRfY291bnQ7CisJdTE2IGRlZmF1bHRfbGlua19kb3duX3RpbWVvdXQ7CisJdTggaXNjc2lfdmVyX21pbl9tYXg7CisJdTggbXVsdGlmdW5jdGlvbl9kZXZpY2U7CisJdTggY2FjaGVfdmFsaWQ7CisJdTggaGJhX3N0YXR1czsKKwl1OCBtYXhfZG9tYWluc19zdXBwb3J0ZWQ7CisJdTggcGh5X3BvcnQ7CisJdTMyIGZpcm13YXJlX3Bvc3Rfc3RhdHVzOworCXUzMiBoYmFfbXR1WzhdOworCXUzMiBmdXR1cmVfdTMyWzRdOworfSBfX3BhY2tlZDsKKworc3RydWN0IG1nbXRfY29udHJvbGxlcl9hdHRyaWJ1dGVzIHsKKwlzdHJ1Y3QgbWdtdF9oYmFfYXR0cmlidXRlcyBoYmFfYXR0cmliczsKKwl1MTYgcGNpX3ZlbmRvcl9pZDsKKwl1MTYgcGNpX2RldmljZV9pZDsKKwl1MTYgcGNpX3N1Yl92ZW5kb3JfaWQ7CisJdTE2IHBjaV9zdWJfc3lzdGVtX2lkOworCXU4IHBjaV9idXNfbnVtYmVyOworCXU4IHBjaV9kZXZpY2VfbnVtYmVyOworCXU4IHBjaV9mdW5jdGlvbl9udW1iZXI7CisJdTggaW50ZXJmYWNlX3R5cGU7CisJdTY0IHVuaXF1ZV9pZGVudGlmaWVyOworCXU4IG5ldGZpbHRlcnM7CisJdTggcnN2ZDBbM107CisJdTggZnV0dXJlX3UzMls0XTsKK30gX19wYWNrZWQ7CisKK3N0cnVjdCBiZV9tZ210X2NvbnRyb2xsZXJfYXR0cmlidXRlcyB7CisJc3RydWN0IGJlX2NtZF9yZXFfaGRyIGhkcjsKKwlzdHJ1Y3QgbWdtdF9jb250cm9sbGVyX2F0dHJpYnV0ZXMgcGFyYW1zOworfSBfX3BhY2tlZDsKKworc3RydWN0IGJlX21nbXRfY29udHJvbGxlcl9hdHRyaWJ1dGVzX3Jlc3AgeworCXN0cnVjdCBiZV9jbWRfcmVzcF9oZHIgaGRyOworCXN0cnVjdCBtZ210X2NvbnRyb2xsZXJfYXR0cmlidXRlcyBwYXJhbXM7Cit9IF9fcGFja2VkOworCisvKiBjb25maWd1cmF0aW9uIG1hbmFnZW1lbnQgKi8KKworI2RlZmluZSBHRVRfTUdNVF9DT05UUk9MTEVSX1dTKHBoYmEpICAgIChwaGJhLT5wbWdtdF93cykKKworLyogTUdNVCBDTUQgZmxhZ3MgKi8KKworI2RlZmluZSBNR01UX0NNREhfRlJFRSAgICAgICAgICAgICAgICAoMTw8MCkKKworLyogIC0tLSBNR01UX0VSUk9SX0NPREVTIC0tLSAqLworLyogIEVycm9yIENvZGVzIHJldHVybmVkIGluIHRoZSBzdGF0dXMgZmllbGQgb2YgdGhlIENNRCByZXNwb25zZSBoZWFkZXIgKi8KKyNkZWZpbmUgTUdNVF9TVEFUVVNfU1VDQ0VTUyAwCS8qIFRoZSBDTUQgY29tcGxldGVkIHdpdGhvdXQgZXJyb3JzICovCisjZGVmaW5lIE1HTVRfU1RBVFVTX0ZBSUxFRCAxCS8qIEVycm9yIHN0YXR1cyBpbiB0aGUgU3RhdHVzIGZpZWxkIG9mICovCisJCQkJLyogdGhlIENNRF9SRVNQT05TRV9IRUFERVIgICovCisKKyNkZWZpbmUgSVNDU0lfR0VUX1BEVV9URU1QTEFURV9BRERSRVNTKHBjLCBwYSkge1wKKyAgICBwYS0+bG8gPSBwaGJhLT5pbml0X21lbVtJU0NTSV9NRU1fR0xPQkFMX0hFQURFUl0ubWVtX2FycmF5WzBdLlwKKwkJCQkJYnVzX2FkZHJlc3MudS5hMzIuYWRkcmVzc19sbzsgIFwKKyAgICBwYS0+aGkgPSBwaGJhLT5pbml0X21lbVtJU0NTSV9NRU1fR0xPQkFMX0hFQURFUl0ubWVtX2FycmF5WzBdLlwKKwkJCQkJYnVzX2FkZHJlc3MudS5hMzIuYWRkcmVzc19oaTsgIFwKK30KKworc3RydWN0IGJlaXNjc2lfZW5kcG9pbnQgeworCXN0cnVjdCBiZWlzY3NpX2hiYSAqcGhiYTsKKwlzdHJ1Y3QgYmVpc2NzaV9zZXNzICpzZXNzOworCXN0cnVjdCBiZWlzY3NpX2Nvbm4gKmNvbm47CisJdW5zaWduZWQgc2hvcnQgaXBfdHlwZTsKKwljaGFyIGRzdDZfYWRkcltJU0NTSV9BRERSRVNTX0JVRl9MRU5dOworCXVuc2lnbmVkIGxvbmcgZHN0X2FkZHI7CisJdW5zaWduZWQgc2hvcnQgZXBfY2lkOworCXVuc2lnbmVkIGludCBmd19oYW5kbGU7CisJdTE2IGRzdF90Y3Bwb3J0OworCXUxNiBjaWRfdmxkOworfTsKKwordW5zaWduZWQgY2hhciBtZ210X2dldF9md19jb25maWcoc3RydWN0IGJlX2N0cmxfaW5mbyAqY3RybCwKKwkJCQkgc3RydWN0IGJlaXNjc2lfaGJhICpwaGJhKTsKKwordW5zaWduZWQgY2hhciBtZ210X2ludmFsaWRhdGVfY29ubmVjdGlvbihzdHJ1Y3QgYmVpc2NzaV9oYmEgKnBoYmEsCisJCQkJCSBzdHJ1Y3QgYmVpc2NzaV9lbmRwb2ludCAqYmVpc2NzaV9lcCwKKwkJCQkJIHVuc2lnbmVkIHNob3J0IGNpZCwKKwkJCQkJIHVuc2lnbmVkIHNob3J0IGlzc3VlX3Jlc2V0LAorCQkJCQkgdW5zaWduZWQgc2hvcnQgc2F2ZWNmZ19mbGFnKTsKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9NYWtlZmlsZSBiL2RyaXZlcnMvc2NzaS9iZmEvTWFrZWZpbGUKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWQ2MDA5NAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvTWFrZWZpbGUKQEAgLTAsMCArMSwxNSBAQAorb2JqLSQoQ09ORklHX1NDU0lfQkZBX0ZDKSA6PSBiZmEubworCitiZmEteSA6PSBiZmFkLm8gYmZhZF9pbnRyLm8gYmZhZF9vcy5vIGJmYWRfaW0ubyBiZmFkX2F0dHIubyBiZmFkX2Z3aW1nLm8KKworYmZhLXkgKz0gYmZhX2NvcmUubyBiZmFfaW9jLm8gYmZhX2lvY2ZjLm8gYmZhX2ZjeHAubyBiZmFfbHBzLm8KK2JmYS15ICs9IGJmYV9od19jYi5vIGJmYV9od19jdC5vIGJmYV9pbnRyLm8gYmZhX3RpbWVyLm8gYmZhX3Jwb3J0Lm8gCitiZmEteSArPSBiZmFfZmNwb3J0Lm8gYmZhX3BvcnQubyBiZmFfdWYubyBiZmFfc2dwZy5vIGJmYV9tb2R1bGUubyBiZmFfaW9pbS5vCitiZmEteSArPSBiZmFfaXRuaW0ubyBiZmFfZmNwaW0ubyBiZmFfdHNraW0ubyBiZmFfbG9nLm8gYmZhX2xvZ19tb2R1bGUubworYmZhLXkgKz0gYmZhX2NzZGVidWcubyBiZmFfc20ubyBwbG9nLm8KKworYmZhLXkgKz0gZmNidWlsZC5vIGZhYnJpYy5vIGZjcGltLm8gdmZhcGkubyBmY3B0bS5vIGJmYV9mY3MubyBiZmFfZmNzX3BvcnQubyAKK2JmYS15ICs9IGJmYV9mY3NfdWYubyBiZmFfZmNzX2xwb3J0Lm8gZmFiLm8gZmRtaS5vIG1zLm8gbnMubyBzY24ubyBsb29wLm8KK2JmYS15ICs9IGxwb3J0X2FwaS5vIG4ybi5vIHJwb3J0Lm8gcnBvcnRfYXBpLm8gcnBvcnRfZnRycy5vIHZwb3J0Lm8KKworY2NmbGFncy15IDo9IC1JJChvYmopIC1JJChvYmopL2luY2x1ZGUgLUkkKG9iaikvaW5jbHVkZS9jbmEKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NhbGxiYWNrX3ByaXYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NhbGxiYWNrX3ByaXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xZTMyNjVjCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfY2FsbGJhY2tfcHJpdi5oCkBAIC0wLDAgKzEsNTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9DQUxMQkFDS19QUklWX0hfXworI2RlZmluZSBfX0JGQV9DQUxMQkFDS19QUklWX0hfXworCisjaW5jbHVkZSA8Y3MvYmZhX3EuaD4KKwordHlwZWRlZiB2b2lkICAgICgqYmZhX2NiX2NiZm5fdCkgKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKKworLyoqCisgKiBHZW5lcmljIEJGQSBjYWxsYmFjayBlbGVtZW50LgorICovCitzdHJ1Y3QgYmZhX2NiX3FlX3MgeworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICBxZTsKKwliZmFfY2JfY2Jmbl90ICBjYmZuOworCWJmYV9ib29sZWFuX3QgICBvbmNlOworCXUzMgkJcnN2ZDsKKwl2b2lkICAgICAgICAgICAqY2Jhcmc7Cit9OworCisjZGVmaW5lIGJmYV9jYl9xdWV1ZShfX2JmYSwgX19oY2JfcWUsIF9fY2JmbiwgX19jYmFyZykgZG8gewkJXAorCShfX2hjYl9xZSktPmNiZm4gID0gKF9fY2Jmbik7ICAgICAgXAorCShfX2hjYl9xZSktPmNiYXJnID0gKF9fY2JhcmcpOyAgICAgIFwKKwlsaXN0X2FkZF90YWlsKCYoX19oY2JfcWUpLT5xZSwgJihfX2JmYSktPmNvbXBfcSk7ICAgICAgXAorfSB3aGlsZSAoMCkKKworI2RlZmluZSBiZmFfY2JfZGVxdWV1ZShfX2hjYl9xZSkJbGlzdF9kZWwoJihfX2hjYl9xZSktPnFlKQorCisjZGVmaW5lIGJmYV9jYl9xdWV1ZV9vbmNlKF9fYmZhLCBfX2hjYl9xZSwgX19jYmZuLCBfX2NiYXJnKSBkbyB7CVwKKwkoX19oY2JfcWUpLT5jYmZuICA9IChfX2NiZm4pOyAgICAgIFwKKwkoX19oY2JfcWUpLT5jYmFyZyA9IChfX2NiYXJnKTsgICAgICBcCisJaWYgKCEoX19oY2JfcWUpLT5vbmNlKSB7ICAgICAgXAorCQlsaXN0X2FkZF90YWlsKChfX2hjYl9xZSksICYoX19iZmEpLT5jb21wX3EpOyAgICAgIFwKKwkJKF9faGNiX3FlKS0+b25jZSA9IEJGQV9UUlVFOwkJCQlcCisJfQkJCQkJCQkJXAorfSB3aGlsZSAoMCkKKworI2RlZmluZSBiZmFfY2JfcXVldWVfZG9uZShfX2hjYl9xZSkgZG8gewkJCQlcCisJKF9faGNiX3FlKS0+b25jZSA9IEJGQV9GQUxTRTsJCQkJCVwKK30gd2hpbGUgKDApCisKKyNlbmRpZiAvKiBfX0JGQV9DQUxMQkFDS19QUklWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfY2JfaW9pbV9tYWNyb3MuaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NiX2lvaW1fbWFjcm9zLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDA1MGM4MwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NiX2lvaW1fbWFjcm9zLmgKQEAgLTAsMCArMSwyMDUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2NiX2lvaW1fbWFjcm9zLmggQkZBIElPSU0gZHJpdmVyIGludGVyZmFjZSBtYWNyb3MuCisgKi8KKworI2lmbmRlZiBfX0JGQV9IQ0JfSU9JTV9NQUNST1NfSF9fCisjZGVmaW5lIF9fQkZBX0hDQl9JT0lNX01BQ1JPU19IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKy8qCisgKiAjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KKyAqCisgKiAjaW5jbHVkZSA8c2NzaS9zY3NpLmg+ICNpbmNsdWRlIDxzY3NpL3Njc2lfY21uZC5oPiAjaW5jbHVkZQorICogPHNjc2kvc2NzaV9kZXZpY2UuaD4gI2luY2x1ZGUgPHNjc2kvc2NzaV9ob3N0Lmg+CisgKi8KKyNpbmNsdWRlICJiZmFkX2ltX2NvbXBhdC5oIgorCisvKgorICogdGFzayBhdHRyaWJ1dGUgdmFsdWVzIGluIEZDUC0yIEZDUF9DTU5EIElVCisgKi8KKyNkZWZpbmUgU0lNUExFX1EgICAgMAorI2RlZmluZSBIRUFEX09GX1EgICAxCisjZGVmaW5lIE9SREVSRURfUSAgIDIKKyNkZWZpbmUgQUNBX1EgICAgICAgNAorI2RlZmluZSBVTlRBR0dFRCAgICA1CisKK3N0YXRpYyBpbmxpbmUgbHVuX3QKK2JmYWRfaW50X3RvX2x1bih1MzIgbHVubykKK3sKKwl1bmlvbiB7CisJCXUxNiAgICAgICAgc2NzaV9sdW5bNF07CisJCWx1bl90ICAgICAgICAgICBiZmFfbHVuOworCX0gbHVuOworCisJbHVuLmJmYV9sdW4gICAgID0gMDsKKwlsdW4uc2NzaV9sdW5bMF0gPSBiZmFfb3NfaHRvbnMobHVubyk7CisKKwlyZXR1cm4gKGx1bi5iZmFfbHVuKTsKK30KKworLyoqCisgKiBHZXQgTFVOIGZvciB0aGUgSS9PIHJlcXVlc3QKKyAqLworI2RlZmluZSBiZmFfY2JfaW9pbV9nZXRfbHVuKF9fZGlvKQlcCisJYmZhZF9pbnRfdG9fbHVuKCgoc3RydWN0IHNjc2lfY21uZCAqKV9fZGlvKS0+ZGV2aWNlLT5sdW4pCisKKy8qKgorICogR2V0IENEQiBmb3IgdGhlIEkvTyByZXF1ZXN0CisgKi8KK3N0YXRpYyBpbmxpbmUgdTggKgorYmZhX2NiX2lvaW1fZ2V0X2NkYihzdHJ1Y3QgYmZhZF9pb2ltX3MgKmRpbykKK3sKKwlzdHJ1Y3Qgc2NzaV9jbW5kICpjbW5kID0gKHN0cnVjdCBzY3NpX2NtbmQgKilkaW87CisKKwlyZXR1cm4gKCh1OCAqKSBjbW5kLT5jbW5kKTsKK30KKworLyoqCisgKiBHZXQgSS9PIGRpcmVjdGlvbiAocmVhZC93cml0ZSkgZm9yIHRoZSBJL08gcmVxdWVzdAorICovCitzdGF0aWMgaW5saW5lIGVudW0gZmNwX2lvZGlyCitiZmFfY2JfaW9pbV9nZXRfaW9kaXIoc3RydWN0IGJmYWRfaW9pbV9zICpkaW8pCit7CisJc3RydWN0IHNjc2lfY21uZCAqY21uZCA9IChzdHJ1Y3Qgc2NzaV9jbW5kICopZGlvOworCWVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRtYWRpcjsKKworCWRtYWRpciA9IGNtbmQtPnNjX2RhdGFfZGlyZWN0aW9uOworCWlmIChkbWFkaXIgPT0gRE1BX1RPX0RFVklDRSkKKwkJcmV0dXJuIEZDUF9JT0RJUl9XUklURTsKKwllbHNlIGlmIChkbWFkaXIgPT0gRE1BX0ZST01fREVWSUNFKQorCQlyZXR1cm4gRkNQX0lPRElSX1JFQUQ7CisJZWxzZQorCQlyZXR1cm4gRkNQX0lPRElSX05PTkU7Cit9CisKKy8qKgorICogR2V0IElPIHNpemUgaW4gYnl0ZXMgZm9yIHRoZSBJL08gcmVxdWVzdAorICovCitzdGF0aWMgaW5saW5lIHUzMgorYmZhX2NiX2lvaW1fZ2V0X3NpemUoc3RydWN0IGJmYWRfaW9pbV9zICpkaW8pCit7CisJc3RydWN0IHNjc2lfY21uZCAqY21uZCA9IChzdHJ1Y3Qgc2NzaV9jbW5kICopZGlvOworCisJcmV0dXJuIChzY3NpX2J1ZmZsZW4oY21uZCkpOworfQorCisvKioKKyAqIEdldCB0aW1lb3V0IGZvciB0aGUgSS9PIHJlcXVlc3QKKyAqLworc3RhdGljIGlubGluZSB1OAorYmZhX2NiX2lvaW1fZ2V0X3RpbWVvdXQoc3RydWN0IGJmYWRfaW9pbV9zICpkaW8pCit7CisJc3RydWN0IHNjc2lfY21uZCAqY21uZCA9IChzdHJ1Y3Qgc2NzaV9jbW5kICopZGlvOworCS8qCisJICogVEJEOiBuZWVkIGEgdGltZW91dCBmb3Igc2NzaSBwYXNzdGhydQorCSAqLworCWlmIChjbW5kLT5kZXZpY2UtPmhvc3QgPT0gTlVMTCkKKwkJcmV0dXJuIDQ7CisKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiBHZXQgU0cgZWxlbWVudCBmb3IgdGhlIEkvTyByZXF1ZXN0IGdpdmVuIHRoZSBTRyBlbGVtZW50IGluZGV4CisgKi8KK3N0YXRpYyBpbmxpbmUgdW5pb24gYmZpX2FkZHJfdQorYmZhX2NiX2lvaW1fZ2V0X3NnYWRkcihzdHJ1Y3QgYmZhZF9pb2ltX3MgKmRpbywgaW50IHNnZWlkKQoreworCXN0cnVjdCBzY3NpX2NtbmQgKmNtbmQgPSAoc3RydWN0IHNjc2lfY21uZCAqKWRpbzsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnZTsKKwl1NjQgICAgICAgIGFkZHI7CisKKwlzZ2UgPSAoc3RydWN0IHNjYXR0ZXJsaXN0ICopc2NzaV9zZ2xpc3QoY21uZCkgKyBzZ2VpZDsKKwlhZGRyID0gKHU2NCkgc2dfZG1hX2FkZHJlc3Moc2dlKTsKKworCXJldHVybiAoKih1bmlvbiBiZmlfYWRkcl91ICopICZhZGRyKTsKK30KKworc3RhdGljIGlubGluZSB1MzIKK2JmYV9jYl9pb2ltX2dldF9zZ2xlbihzdHJ1Y3QgYmZhZF9pb2ltX3MgKmRpbywgaW50IHNnZWlkKQoreworCXN0cnVjdCBzY3NpX2NtbmQgKmNtbmQgPSAoc3RydWN0IHNjc2lfY21uZCAqKWRpbzsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnZTsKKwl1MzIgICAgICAgIGxlbjsKKworCXNnZSA9IChzdHJ1Y3Qgc2NhdHRlcmxpc3QgKilzY3NpX3NnbGlzdChjbW5kKSArIHNnZWlkOworCWxlbiA9IHNnX2RtYV9sZW4oc2dlKTsKKworCXJldHVybiBsZW47Cit9CisKKy8qKgorICogR2V0IENvbW1hbmQgUmVmZXJlbmNlIE51bWJlciBmb3IgdGhlIEkvTyByZXF1ZXN0LiAwIGlmIG5vbmUuCisgKi8KK3N0YXRpYyBpbmxpbmUgdTgKK2JmYV9jYl9pb2ltX2dldF9jcm4oc3RydWN0IGJmYWRfaW9pbV9zICpkaW8pCit7CisJcmV0dXJuIDA7Cit9CisKKy8qKgorICogR2V0IFNBTS0zIHByaW9yaXR5IGZvciB0aGUgSS9PIHJlcXVlc3QuIDAgaXMgZGVmYXVsdC4KKyAqLworc3RhdGljIGlubGluZSB1OAorYmZhX2NiX2lvaW1fZ2V0X3ByaW9yaXR5KHN0cnVjdCBiZmFkX2lvaW1fcyAqZGlvKQoreworCXJldHVybiAwOworfQorCisvKioKKyAqIEdldCB0YXNrIGF0dHJpYnV0ZXMgZm9yIHRoZSBJL08gcmVxdWVzdC4gRGVmYXVsdCBpcyBGQ1BfVEFTS19BVFRSX1NJTVBMRSgwKS4KKyAqLworc3RhdGljIGlubGluZSB1OAorYmZhX2NiX2lvaW1fZ2V0X3Rhc2thdHRyKHN0cnVjdCBiZmFkX2lvaW1fcyAqZGlvKQoreworCXN0cnVjdCBzY3NpX2NtbmQgKmNtbmQgPSAoc3RydWN0IHNjc2lfY21uZCAqKWRpbzsKKwl1OCAgICAgICAgIHRhc2tfYXR0ciA9IFVOVEFHR0VEOworCisJaWYgKGNtbmQtPmRldmljZS0+dGFnZ2VkX3N1cHBvcnRlZCkgeworCQlzd2l0Y2ggKGNtbmQtPnRhZykgeworCQljYXNlIEhFQURfT0ZfUVVFVUVfVEFHOgorCQkJdGFza19hdHRyID0gSEVBRF9PRl9ROworCQkJYnJlYWs7CisJCWNhc2UgT1JERVJFRF9RVUVVRV9UQUc6CisJCQl0YXNrX2F0dHIgPSBPUkRFUkVEX1E7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCXRhc2tfYXR0ciA9IFNJTVBMRV9ROworCQkJYnJlYWs7CisJCX0KKwl9CisKKwlyZXR1cm4gdGFza19hdHRyOworfQorCisvKioKKyAqIEdldCBDREIgbGVuZ3RoIGluIGJ5dGVzIGZvciB0aGUgSS9PIHJlcXVlc3QuIERlZmF1bHQgaXMgRkNQX0NNTkRfQ0RCX0xFTigxNikuCisgKi8KK3N0YXRpYyBpbmxpbmUgdTgKK2JmYV9jYl9pb2ltX2dldF9jZGJsZW4oc3RydWN0IGJmYWRfaW9pbV9zICpkaW8pCit7CisJc3RydWN0IHNjc2lfY21uZCAqY21uZCA9IChzdHJ1Y3Qgc2NzaV9jbW5kICopZGlvOworCisJcmV0dXJuIChjbW5kLT5jbWRfbGVuKTsKK30KKworCisKKyNlbmRpZiAvKiBfX0JGQV9IQ0JfSU9JTV9NQUNST1NfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9jZWUuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NlZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdhOTU5YzMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9jZWUuYwpAQCAtMCwwICsxLDQ5MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19jZWUuaD4KKyNpbmNsdWRlIDxjcy9iZmFfdHJjLmg+CisjaW5jbHVkZSA8Y3MvYmZhX2xvZy5oPgorI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorI2luY2x1ZGUgPGNlZS9iZmFfY2VlLmg+CisjaW5jbHVkZSA8YmZpL2JmaV9jZWUuaD4KKyNpbmNsdWRlIDxiZmkvYmZpLmg+CisjaW5jbHVkZSA8YmZhX2lvYy5oPgorI2luY2x1ZGUgPGNuYS9iZmFfY25hX3RyY21vZC5oPgorCitCRkFfVFJDX0ZJTEUoQ05BLCBDRUUpOworCisjZGVmaW5lIGJmYV9pb2NfcG9ydGlkKF9faW9jKSAoKF9faW9jKS0+cG9ydF9pZCkKKyNkZWZpbmUgYmZhX2xwdWlkKF9fYXJnKSBiZmFfaW9jX3BvcnRpZCgmKF9fYXJnKS0+aW9jKQorCitzdGF0aWMgdm9pZCAgICAgYmZhX2NlZV9mb3JtYXRfbGxkcF9jZmcoc3RydWN0IGJmYV9jZWVfbGxkcF9jZmdfcyAqbGxkcF9jZmcpOworc3RhdGljIHZvaWQgICAgIGJmYV9jZWVfZm9ybWF0X2RjYmN4X3N0YXRzKHN0cnVjdCBiZmFfY2VlX2RjYnhfc3RhdHNfcworCQkJCQkgICAqZGNiY3hfc3RhdHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9jZWVfZm9ybWF0X2xsZHBfc3RhdHMoc3RydWN0IGJmYV9jZWVfbGxkcF9zdGF0c19zCisJCQkJCSAgKmxsZHBfc3RhdHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9jZWVfZm9ybWF0X2NmZ19zdGF0cyhzdHJ1Y3QgYmZhX2NlZV9jZmdfc3RhdHNfcyAqY2ZnX3N0YXRzKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfY2VlX2Zvcm1hdF9jZWVfY2ZnKHZvaWQgKmJ1ZmZlcik7CitzdGF0aWMgdm9pZCAgICAgYmZhX2NlZV9mb3JtYXRfY2VlX3N0YXRzKHZvaWQgKmJ1ZmZlcik7CisKK3N0YXRpYyB2b2lkCitiZmFfY2VlX2Zvcm1hdF9jZWVfc3RhdHModm9pZCAqYnVmZmVyKQoreworCXN0cnVjdCBiZmFfY2VlX3N0YXRzX3MgKmNlZV9zdGF0cyA9IGJ1ZmZlcjsKKwliZmFfY2VlX2Zvcm1hdF9kY2JjeF9zdGF0cygmY2VlX3N0YXRzLT5kY2J4X3N0YXRzKTsKKwliZmFfY2VlX2Zvcm1hdF9sbGRwX3N0YXRzKCZjZWVfc3RhdHMtPmxsZHBfc3RhdHMpOworCWJmYV9jZWVfZm9ybWF0X2NmZ19zdGF0cygmY2VlX3N0YXRzLT5jZmdfc3RhdHMpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2NlZV9mb3JtYXRfY2VlX2NmZyh2b2lkICpidWZmZXIpCit7CisJc3RydWN0IGJmYV9jZWVfYXR0cl9zICpjZWVfY2ZnID0gYnVmZmVyOworCWJmYV9jZWVfZm9ybWF0X2xsZHBfY2ZnKCZjZWVfY2ZnLT5sbGRwX3JlbW90ZSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfY2VlX2Zvcm1hdF9kY2JjeF9zdGF0cyhzdHJ1Y3QgYmZhX2NlZV9kY2J4X3N0YXRzX3MgKmRjYmN4X3N0YXRzKQoreworCWRjYmN4X3N0YXRzLT5zdWJ0bHZzX3VucmVjb2duaXplZCA9CisJCWJmYV9vc19udG9obChkY2JjeF9zdGF0cy0+c3VidGx2c191bnJlY29nbml6ZWQpOworCWRjYmN4X3N0YXRzLT5uZWdvdGlhdGlvbl9mYWlsZWQgPQorCQliZmFfb3NfbnRvaGwoZGNiY3hfc3RhdHMtPm5lZ290aWF0aW9uX2ZhaWxlZCk7CisJZGNiY3hfc3RhdHMtPnJlbW90ZV9jZmdfY2hhbmdlZCA9CisJCWJmYV9vc19udG9obChkY2JjeF9zdGF0cy0+cmVtb3RlX2NmZ19jaGFuZ2VkKTsKKwlkY2JjeF9zdGF0cy0+dGx2c19yZWNlaXZlZCA9IGJmYV9vc19udG9obChkY2JjeF9zdGF0cy0+dGx2c19yZWNlaXZlZCk7CisJZGNiY3hfc3RhdHMtPnRsdnNfaW52YWxpZCA9IGJmYV9vc19udG9obChkY2JjeF9zdGF0cy0+dGx2c19pbnZhbGlkKTsKKwlkY2JjeF9zdGF0cy0+c2Vxbm8gPSBiZmFfb3NfbnRvaGwoZGNiY3hfc3RhdHMtPnNlcW5vKTsKKwlkY2JjeF9zdGF0cy0+YWNrbm8gPSBiZmFfb3NfbnRvaGwoZGNiY3hfc3RhdHMtPmFja25vKTsKKwlkY2JjeF9zdGF0cy0+cmVjdmRfc2Vxbm8gPSBiZmFfb3NfbnRvaGwoZGNiY3hfc3RhdHMtPnJlY3ZkX3NlcW5vKTsKKwlkY2JjeF9zdGF0cy0+cmVjdmRfYWNrbm8gPSBiZmFfb3NfbnRvaGwoZGNiY3hfc3RhdHMtPnJlY3ZkX2Fja25vKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9jZWVfZm9ybWF0X2xsZHBfc3RhdHMoc3RydWN0IGJmYV9jZWVfbGxkcF9zdGF0c19zICpsbGRwX3N0YXRzKQoreworCWxsZHBfc3RhdHMtPmZyYW1lc190cmFuc21pdHRlZCA9CisJCWJmYV9vc19udG9obChsbGRwX3N0YXRzLT5mcmFtZXNfdHJhbnNtaXR0ZWQpOworCWxsZHBfc3RhdHMtPmZyYW1lc19hZ2VkX291dCA9IGJmYV9vc19udG9obChsbGRwX3N0YXRzLT5mcmFtZXNfYWdlZF9vdXQpOworCWxsZHBfc3RhdHMtPmZyYW1lc19kaXNjYXJkZWQgPQorCQliZmFfb3NfbnRvaGwobGxkcF9zdGF0cy0+ZnJhbWVzX2Rpc2NhcmRlZCk7CisJbGxkcF9zdGF0cy0+ZnJhbWVzX2luX2Vycm9yID0gYmZhX29zX250b2hsKGxsZHBfc3RhdHMtPmZyYW1lc19pbl9lcnJvcik7CisJbGxkcF9zdGF0cy0+ZnJhbWVzX3JjdmQgPSBiZmFfb3NfbnRvaGwobGxkcF9zdGF0cy0+ZnJhbWVzX3JjdmQpOworCWxsZHBfc3RhdHMtPnRsdnNfZGlzY2FyZGVkID0gYmZhX29zX250b2hsKGxsZHBfc3RhdHMtPnRsdnNfZGlzY2FyZGVkKTsKKwlsbGRwX3N0YXRzLT50bHZzX3VucmVjb2duaXplZCA9CisJCWJmYV9vc19udG9obChsbGRwX3N0YXRzLT50bHZzX3VucmVjb2duaXplZCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfY2VlX2Zvcm1hdF9jZmdfc3RhdHMoc3RydWN0IGJmYV9jZWVfY2ZnX3N0YXRzX3MgKmNmZ19zdGF0cykKK3sKKwljZmdfc3RhdHMtPmNlZV9zdGF0dXNfZG93biA9IGJmYV9vc19udG9obChjZmdfc3RhdHMtPmNlZV9zdGF0dXNfZG93bik7CisJY2ZnX3N0YXRzLT5jZWVfc3RhdHVzX3VwID0gYmZhX29zX250b2hsKGNmZ19zdGF0cy0+Y2VlX3N0YXR1c191cCk7CisJY2ZnX3N0YXRzLT5jZWVfaHdfY2ZnX2NoYW5nZWQgPQorCQliZmFfb3NfbnRvaGwoY2ZnX3N0YXRzLT5jZWVfaHdfY2ZnX2NoYW5nZWQpOworCWNmZ19zdGF0cy0+cmVjdmRfaW52YWxpZF9jZmcgPQorCQliZmFfb3NfbnRvaGwoY2ZnX3N0YXRzLT5yZWN2ZF9pbnZhbGlkX2NmZyk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfY2VlX2Zvcm1hdF9sbGRwX2NmZyhzdHJ1Y3QgYmZhX2NlZV9sbGRwX2NmZ19zICpsbGRwX2NmZykKK3sKKwlsbGRwX2NmZy0+dGltZV90b19pbnRlcnZhbCA9IGJmYV9vc19udG9ocyhsbGRwX2NmZy0+dGltZV90b19pbnRlcnZhbCk7CisJbGxkcF9jZmctPmVuYWJsZWRfc3lzdGVtX2NhcCA9CisJCWJmYV9vc19udG9ocyhsbGRwX2NmZy0+ZW5hYmxlZF9zeXN0ZW1fY2FwKTsKK30KKworLyoqCisgKiBiZmFfY2VlX2F0dHJfbWVtaW5mbygpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gdm9pZAorICoKKyAqIEByZXR1cm4gU2l6ZSBvZiBETUEgcmVnaW9uCisgKi8KK3N0YXRpYyAgICAgICAgICB1MzIKK2JmYV9jZWVfYXR0cl9tZW1pbmZvKHZvaWQpCit7CisJcmV0dXJuIEJGQV9ST1VORFVQKHNpemVvZihzdHJ1Y3QgYmZhX2NlZV9hdHRyX3MpLCBCRkFfRE1BX0FMSUdOX1NaKTsKK30KKworLyoqCisgKiBiZmFfY2VlX3N0YXRzX21lbWluZm8oKQorICoKKyAqCisgKiBAcGFyYW1baW5dIHZvaWQKKyAqCisgKiBAcmV0dXJuIFNpemUgb2YgRE1BIHJlZ2lvbgorICovCitzdGF0aWMgICAgICAgICAgdTMyCitiZmFfY2VlX3N0YXRzX21lbWluZm8odm9pZCkKK3sKKwlyZXR1cm4gQkZBX1JPVU5EVVAoc2l6ZW9mKHN0cnVjdCBiZmFfY2VlX3N0YXRzX3MpLCBCRkFfRE1BX0FMSUdOX1NaKTsKK30KKworLyoqCisgKiBiZmFfY2VlX2dldF9hdHRyX2lzcigpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gY2VlIC0gUG9pbnRlciB0byB0aGUgQ0VFIG1vZHVsZQorICogICAgICAgICAgICBzdGF0dXMgLSBSZXR1cm4gc3RhdHVzIGZyb20gdGhlIGYvdworICoKKyAqIEByZXR1cm4gdm9pZAorICovCitzdGF0aWMgdm9pZAorYmZhX2NlZV9nZXRfYXR0cl9pc3Ioc3RydWN0IGJmYV9jZWVfcyAqY2VlLCBiZmFfc3RhdHVzX3Qgc3RhdHVzKQoreworCWNlZS0+Z2V0X2F0dHJfc3RhdHVzID0gc3RhdHVzOworCWJmYV90cmMoY2VlLCAwKTsKKwlpZiAoc3RhdHVzID09IEJGQV9TVEFUVVNfT0spIHsKKwkJYmZhX3RyYyhjZWUsIDApOworCQkvKgorCQkgKiBUaGUgcmVxdWVzdGVkIGRhdGEgaGFzIGJlZW4gY29waWVkIHRvIHRoZSBETUEgYXJlYSwgKnByb2Nlc3MKKwkJICogaXQuCisJCSAqLworCQltZW1jcHkoY2VlLT5hdHRyLCBjZWUtPmF0dHJfZG1hLmt2YSwKKwkJICAgICAgIHNpemVvZihzdHJ1Y3QgYmZhX2NlZV9hdHRyX3MpKTsKKwkJYmZhX2NlZV9mb3JtYXRfY2VlX2NmZyhjZWUtPmF0dHIpOworCX0KKwljZWUtPmdldF9hdHRyX3BlbmRpbmcgPSBCRkFfRkFMU0U7CisJaWYgKGNlZS0+Y2Jmbi5nZXRfYXR0cl9jYmZuKSB7CisJCWJmYV90cmMoY2VlLCAwKTsKKwkJY2VlLT5jYmZuLmdldF9hdHRyX2NiZm4oY2VlLT5jYmZuLmdldF9hdHRyX2NiYXJnLCBzdGF0dXMpOworCX0KKwliZmFfdHJjKGNlZSwgMCk7Cit9CisKKy8qKgorICogYmZhX2NlZV9nZXRfYXR0cl9pc3IoKQorICoKKyAqCisgKiBAcGFyYW1baW5dIGNlZSAtIFBvaW50ZXIgdG8gdGhlIENFRSBtb2R1bGUKKyAqICAgICAgICAgICAgc3RhdHVzIC0gUmV0dXJuIHN0YXR1cyBmcm9tIHRoZSBmL3cKKyAqCisgKiBAcmV0dXJuIHZvaWQKKyAqLworc3RhdGljIHZvaWQKK2JmYV9jZWVfZ2V0X3N0YXRzX2lzcihzdHJ1Y3QgYmZhX2NlZV9zICpjZWUsIGJmYV9zdGF0dXNfdCBzdGF0dXMpCit7CisJY2VlLT5nZXRfc3RhdHNfc3RhdHVzID0gc3RhdHVzOworCWJmYV90cmMoY2VlLCAwKTsKKwlpZiAoc3RhdHVzID09IEJGQV9TVEFUVVNfT0spIHsKKwkJYmZhX3RyYyhjZWUsIDApOworCQkvKgorCQkgKiBUaGUgcmVxdWVzdGVkIGRhdGEgaGFzIGJlZW4gY29waWVkIHRvIHRoZSBETUEgYXJlYSwgcHJvY2VzcworCQkgKiBpdC4KKwkJICovCisJCW1lbWNweShjZWUtPnN0YXRzLCBjZWUtPnN0YXRzX2RtYS5rdmEsCisJCSAgICAgICBzaXplb2Yoc3RydWN0IGJmYV9jZWVfc3RhdHNfcykpOworCQliZmFfY2VlX2Zvcm1hdF9jZWVfc3RhdHMoY2VlLT5zdGF0cyk7CisJfQorCWNlZS0+Z2V0X3N0YXRzX3BlbmRpbmcgPSBCRkFfRkFMU0U7CisJYmZhX3RyYyhjZWUsIDApOworCWlmIChjZWUtPmNiZm4uZ2V0X3N0YXRzX2NiZm4pIHsKKwkJYmZhX3RyYyhjZWUsIDApOworCQljZWUtPmNiZm4uZ2V0X3N0YXRzX2NiZm4oY2VlLT5jYmZuLmdldF9zdGF0c19jYmFyZywgc3RhdHVzKTsKKwl9CisJYmZhX3RyYyhjZWUsIDApOworfQorCisvKioKKyAqIGJmYV9jZWVfZ2V0X2F0dHJfaXNyKCkKKyAqCisgKgorICogQHBhcmFtW2luXSBjZWUgLSBQb2ludGVyIHRvIHRoZSBDRUUgbW9kdWxlCisgKiAgICAgICAgICAgIHN0YXR1cyAtIFJldHVybiBzdGF0dXMgZnJvbSB0aGUgZi93CisgKgorICogQHJldHVybiB2b2lkCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfY2VlX3Jlc2V0X3N0YXRzX2lzcihzdHJ1Y3QgYmZhX2NlZV9zICpjZWUsIGJmYV9zdGF0dXNfdCBzdGF0dXMpCit7CisJY2VlLT5yZXNldF9zdGF0c19zdGF0dXMgPSBzdGF0dXM7CisJY2VlLT5yZXNldF9zdGF0c19wZW5kaW5nID0gQkZBX0ZBTFNFOworCWlmIChjZWUtPmNiZm4ucmVzZXRfc3RhdHNfY2JmbikKKwkJY2VlLT5jYmZuLnJlc2V0X3N0YXRzX2NiZm4oY2VlLT5jYmZuLnJlc2V0X3N0YXRzX2NiYXJnLCBzdGF0dXMpOworfQorCisvKioKKyAqIGJmYV9jZWVfbWVtaW5mbygpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gdm9pZAorICoKKyAqIEByZXR1cm4gU2l6ZSBvZiBETUEgcmVnaW9uCisgKi8KK3UzMgorYmZhX2NlZV9tZW1pbmZvKHZvaWQpCit7CisJcmV0dXJuIChiZmFfY2VlX2F0dHJfbWVtaW5mbygpICsgYmZhX2NlZV9zdGF0c19tZW1pbmZvKCkpOworfQorCisvKioKKyAqIGJmYV9jZWVfbWVtX2NsYWltKCkKKyAqCisgKgorICogQHBhcmFtW2luXSBjZWUgQ0VFIG1vZHVsZSBwb2ludGVyCisgKiAJICAgICAgZG1hX2t2YSBLZXJuZWwgVmlydHVhbCBBZGRyZXNzIG9mIENFRSBETUEgTWVtb3J5CisgKiAJICAgICAgZG1hX3BhICBQaHlzaWNhbCBBZGRyZXNzIG9mIENFRSBETUEgTWVtb3J5CisgKgorICogQHJldHVybiB2b2lkCisgKi8KK3ZvaWQKK2JmYV9jZWVfbWVtX2NsYWltKHN0cnVjdCBiZmFfY2VlX3MgKmNlZSwgdTggKmRtYV9rdmEsIHU2NCBkbWFfcGEpCit7CisJY2VlLT5hdHRyX2RtYS5rdmEgPSBkbWFfa3ZhOworCWNlZS0+YXR0cl9kbWEucGEgPSBkbWFfcGE7CisJY2VlLT5zdGF0c19kbWEua3ZhID0gZG1hX2t2YSArIGJmYV9jZWVfYXR0cl9tZW1pbmZvKCk7CisJY2VlLT5zdGF0c19kbWEucGEgPSBkbWFfcGEgKyBiZmFfY2VlX2F0dHJfbWVtaW5mbygpOworCWNlZS0+YXR0ciA9IChzdHJ1Y3QgYmZhX2NlZV9hdHRyX3MgKilkbWFfa3ZhOworCWNlZS0+c3RhdHMgPQorCQkoc3RydWN0IGJmYV9jZWVfc3RhdHNfcyAqKShkbWFfa3ZhICsgYmZhX2NlZV9hdHRyX21lbWluZm8oKSk7Cit9CisKKy8qKgorICogYmZhX2NlZV9nZXRfYXR0cigpCisgKgorICogICBTZW5kIHRoZSByZXF1ZXN0IHRvIHRoZSBmL3cgdG8gZmV0Y2ggQ0VFIGF0dHJpYnV0ZXMuCisgKgorICogQHBhcmFtW2luXSBQb2ludGVyIHRvIHRoZSBDRUUgbW9kdWxlIGRhdGEgc3RydWN0dXJlLgorICoKKyAqIEByZXR1cm4gU3RhdHVzCisgKi8KKworYmZhX3N0YXR1c190CitiZmFfY2VlX2dldF9hdHRyKHN0cnVjdCBiZmFfY2VlX3MgKmNlZSwgc3RydWN0IGJmYV9jZWVfYXR0cl9zICphdHRyLAorCQkgYmZhX2NlZV9nZXRfYXR0cl9jYmZuX3QgY2Jmbiwgdm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmaV9jZWVfZ2V0X3JlcV9zICpjbWQ7CisKKwliZmFfYXNzZXJ0KChjZWUgIT0gTlVMTCkgJiYgKGNlZS0+aW9jICE9IE5VTEwpKTsKKwliZmFfdHJjKGNlZSwgMCk7CisJaWYgKCFiZmFfaW9jX2lzX29wZXJhdGlvbmFsKGNlZS0+aW9jKSkgeworCQliZmFfdHJjKGNlZSwgMCk7CisJCXJldHVybiBCRkFfU1RBVFVTX0lPQ19GQUlMVVJFOworCX0KKwlpZiAoY2VlLT5nZXRfYXR0cl9wZW5kaW5nID09IEJGQV9UUlVFKSB7CisJCWJmYV90cmMoY2VlLCAwKTsKKwkJcmV0dXJuIEJGQV9TVEFUVVNfREVWQlVTWTsKKwl9CisJY2VlLT5nZXRfYXR0cl9wZW5kaW5nID0gQkZBX1RSVUU7CisJY21kID0gKHN0cnVjdCBiZmlfY2VlX2dldF9yZXFfcyAqKWNlZS0+Z2V0X2NmZ19tYi5tc2c7CisJY2VlLT5hdHRyID0gYXR0cjsKKwljZWUtPmNiZm4uZ2V0X2F0dHJfY2JmbiA9IGNiZm47CisJY2VlLT5jYmZuLmdldF9hdHRyX2NiYXJnID0gY2Jhcmc7CisJYmZpX2gyaV9zZXQoY21kLT5taCwgQkZJX01DX0NFRSwgQkZJX0NFRV9IMklfR0VUX0NGR19SRVEsCisJCSAgICBiZmFfaW9jX3BvcnRpZChjZWUtPmlvYykpOworCWJmYV9kbWFfYmVfYWRkcl9zZXQoY21kLT5kbWFfYWRkciwgY2VlLT5hdHRyX2RtYS5wYSk7CisJYmZhX2lvY19tYm94X3F1ZXVlKGNlZS0+aW9jLCAmY2VlLT5nZXRfY2ZnX21iKTsKKwliZmFfdHJjKGNlZSwgMCk7CisKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiBiZmFfY2VlX2dldF9zdGF0cygpCisgKgorICogICBTZW5kIHRoZSByZXF1ZXN0IHRvIHRoZSBmL3cgdG8gZmV0Y2ggQ0VFIHN0YXRpc3RpY3MuCisgKgorICogQHBhcmFtW2luXSBQb2ludGVyIHRvIHRoZSBDRUUgbW9kdWxlIGRhdGEgc3RydWN0dXJlLgorICoKKyAqIEByZXR1cm4gU3RhdHVzCisgKi8KKworYmZhX3N0YXR1c190CitiZmFfY2VlX2dldF9zdGF0cyhzdHJ1Y3QgYmZhX2NlZV9zICpjZWUsIHN0cnVjdCBiZmFfY2VlX3N0YXRzX3MgKnN0YXRzLAorCQkgIGJmYV9jZWVfZ2V0X3N0YXRzX2NiZm5fdCBjYmZuLCB2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZpX2NlZV9nZXRfcmVxX3MgKmNtZDsKKworCWJmYV9hc3NlcnQoKGNlZSAhPSBOVUxMKSAmJiAoY2VlLT5pb2MgIT0gTlVMTCkpOworCisJaWYgKCFiZmFfaW9jX2lzX29wZXJhdGlvbmFsKGNlZS0+aW9jKSkgeworCQliZmFfdHJjKGNlZSwgMCk7CisJCXJldHVybiBCRkFfU1RBVFVTX0lPQ19GQUlMVVJFOworCX0KKwlpZiAoY2VlLT5nZXRfc3RhdHNfcGVuZGluZyA9PSBCRkFfVFJVRSkgeworCQliZmFfdHJjKGNlZSwgMCk7CisJCXJldHVybiBCRkFfU1RBVFVTX0RFVkJVU1k7CisJfQorCWNlZS0+Z2V0X3N0YXRzX3BlbmRpbmcgPSBCRkFfVFJVRTsKKwljbWQgPSAoc3RydWN0IGJmaV9jZWVfZ2V0X3JlcV9zICopY2VlLT5nZXRfc3RhdHNfbWIubXNnOworCWNlZS0+c3RhdHMgPSBzdGF0czsKKwljZWUtPmNiZm4uZ2V0X3N0YXRzX2NiZm4gPSBjYmZuOworCWNlZS0+Y2Jmbi5nZXRfc3RhdHNfY2JhcmcgPSBjYmFyZzsKKwliZmlfaDJpX3NldChjbWQtPm1oLCBCRklfTUNfQ0VFLCBCRklfQ0VFX0gySV9HRVRfU1RBVFNfUkVRLAorCQkgICAgYmZhX2lvY19wb3J0aWQoY2VlLT5pb2MpKTsKKwliZmFfZG1hX2JlX2FkZHJfc2V0KGNtZC0+ZG1hX2FkZHIsIGNlZS0+c3RhdHNfZG1hLnBhKTsKKwliZmFfaW9jX21ib3hfcXVldWUoY2VlLT5pb2MsICZjZWUtPmdldF9zdGF0c19tYik7CisJYmZhX3RyYyhjZWUsIDApOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogYmZhX2NlZV9yZXNldF9zdGF0cygpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gUG9pbnRlciB0byB0aGUgQ0VFIG1vZHVsZSBkYXRhIHN0cnVjdHVyZS4KKyAqCisgKiBAcmV0dXJuIFN0YXR1cworICovCisKK2JmYV9zdGF0dXNfdAorYmZhX2NlZV9yZXNldF9zdGF0cyhzdHJ1Y3QgYmZhX2NlZV9zICpjZWUsIGJmYV9jZWVfcmVzZXRfc3RhdHNfY2Jmbl90IGNiZm4sCisJCSAgICB2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZpX2NlZV9yZXNldF9zdGF0c19zICpjbWQ7CisKKwliZmFfYXNzZXJ0KChjZWUgIT0gTlVMTCkgJiYgKGNlZS0+aW9jICE9IE5VTEwpKTsKKwlpZiAoIWJmYV9pb2NfaXNfb3BlcmF0aW9uYWwoY2VlLT5pb2MpKSB7CisJCWJmYV90cmMoY2VlLCAwKTsKKwkJcmV0dXJuIEJGQV9TVEFUVVNfSU9DX0ZBSUxVUkU7CisJfQorCWlmIChjZWUtPnJlc2V0X3N0YXRzX3BlbmRpbmcgPT0gQkZBX1RSVUUpIHsKKwkJYmZhX3RyYyhjZWUsIDApOworCQlyZXR1cm4gQkZBX1NUQVRVU19ERVZCVVNZOworCX0KKwljZWUtPnJlc2V0X3N0YXRzX3BlbmRpbmcgPSBCRkFfVFJVRTsKKwljbWQgPSAoc3RydWN0IGJmaV9jZWVfcmVzZXRfc3RhdHNfcyAqKWNlZS0+cmVzZXRfc3RhdHNfbWIubXNnOworCWNlZS0+Y2Jmbi5yZXNldF9zdGF0c19jYmZuID0gY2JmbjsKKwljZWUtPmNiZm4ucmVzZXRfc3RhdHNfY2JhcmcgPSBjYmFyZzsKKwliZmlfaDJpX3NldChjbWQtPm1oLCBCRklfTUNfQ0VFLCBCRklfQ0VFX0gySV9SRVNFVF9TVEFUUywKKwkJICAgIGJmYV9pb2NfcG9ydGlkKGNlZS0+aW9jKSk7CisJYmZhX2lvY19tYm94X3F1ZXVlKGNlZS0+aW9jLCAmY2VlLT5yZXNldF9zdGF0c19tYik7CisJYmZhX3RyYyhjZWUsIDApOworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqIGJmYV9jZWVfaXNycygpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gUG9pbnRlciB0byB0aGUgQ0VFIG1vZHVsZSBkYXRhIHN0cnVjdHVyZS4KKyAqCisgKiBAcmV0dXJuIHZvaWQKKyAqLworCit2b2lkCitiZmFfY2VlX2lzcih2b2lkICpjYmFyZywgc3RydWN0IGJmaV9tYm1zZ19zICptKQoreworCXVuaW9uIGJmaV9jZWVfaTJoX21zZ191ICptc2c7CisJc3RydWN0IGJmaV9jZWVfZ2V0X3JzcF9zICpnZXRfcnNwOworCXN0cnVjdCBiZmFfY2VlX3MgKmNlZSA9IChzdHJ1Y3QgYmZhX2NlZV9zICopY2Jhcmc7CisJbXNnID0gKHVuaW9uIGJmaV9jZWVfaTJoX21zZ191ICopbTsKKwlnZXRfcnNwID0gKHN0cnVjdCBiZmlfY2VlX2dldF9yc3BfcyAqKW07CisJYmZhX3RyYyhjZWUsIG1zZy0+bWgubXNnX2lkKTsKKwlzd2l0Y2ggKG1zZy0+bWgubXNnX2lkKSB7CisJY2FzZSBCRklfQ0VFX0kySF9HRVRfQ0ZHX1JTUDoKKwkJYmZhX3RyYyhjZWUsIGdldF9yc3AtPmNtZF9zdGF0dXMpOworCQliZmFfY2VlX2dldF9hdHRyX2lzcihjZWUsIGdldF9yc3AtPmNtZF9zdGF0dXMpOworCQlicmVhazsKKwljYXNlIEJGSV9DRUVfSTJIX0dFVF9TVEFUU19SU1A6CisJCWJmYV9jZWVfZ2V0X3N0YXRzX2lzcihjZWUsIGdldF9yc3AtPmNtZF9zdGF0dXMpOworCQlicmVhazsKKwljYXNlIEJGSV9DRUVfSTJIX1JFU0VUX1NUQVRTX1JTUDoKKwkJYmZhX2NlZV9yZXNldF9zdGF0c19pc3IoY2VlLCBnZXRfcnNwLT5jbWRfc3RhdHVzKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogYmZhX2NlZV9oYmZhaWwoKQorICoKKyAqCisgKiBAcGFyYW1baW5dIFBvaW50ZXIgdG8gdGhlIENFRSBtb2R1bGUgZGF0YSBzdHJ1Y3R1cmUuCisgKgorICogQHJldHVybiB2b2lkCisgKi8KKwordm9pZAorYmZhX2NlZV9oYmZhaWwodm9pZCAqYXJnKQoreworCXN0cnVjdCBiZmFfY2VlX3MgKmNlZTsKKwljZWUgPSAoc3RydWN0IGJmYV9jZWVfcyAqKWFyZzsKKworCWlmIChjZWUtPmdldF9hdHRyX3BlbmRpbmcgPT0gQkZBX1RSVUUpIHsKKwkJY2VlLT5nZXRfYXR0cl9zdGF0dXMgPSBCRkFfU1RBVFVTX0ZBSUxFRDsKKwkJY2VlLT5nZXRfYXR0cl9wZW5kaW5nID0gQkZBX0ZBTFNFOworCQlpZiAoY2VlLT5jYmZuLmdldF9hdHRyX2NiZm4pIHsKKwkJCWNlZS0+Y2Jmbi5nZXRfYXR0cl9jYmZuKGNlZS0+Y2Jmbi5nZXRfYXR0cl9jYmFyZywKKwkJCQkJCUJGQV9TVEFUVVNfRkFJTEVEKTsKKwkJfQorCX0KKwlpZiAoY2VlLT5nZXRfc3RhdHNfcGVuZGluZyA9PSBCRkFfVFJVRSkgeworCQljZWUtPmdldF9zdGF0c19zdGF0dXMgPSBCRkFfU1RBVFVTX0ZBSUxFRDsKKwkJY2VlLT5nZXRfc3RhdHNfcGVuZGluZyA9IEJGQV9GQUxTRTsKKwkJaWYgKGNlZS0+Y2Jmbi5nZXRfc3RhdHNfY2JmbikgeworCQkJY2VlLT5jYmZuLmdldF9zdGF0c19jYmZuKGNlZS0+Y2Jmbi5nZXRfc3RhdHNfY2JhcmcsCisJCQkJCQkgQkZBX1NUQVRVU19GQUlMRUQpOworCQl9CisJfQorCWlmIChjZWUtPnJlc2V0X3N0YXRzX3BlbmRpbmcgPT0gQkZBX1RSVUUpIHsKKwkJY2VlLT5yZXNldF9zdGF0c19zdGF0dXMgPSBCRkFfU1RBVFVTX0ZBSUxFRDsKKwkJY2VlLT5yZXNldF9zdGF0c19wZW5kaW5nID0gQkZBX0ZBTFNFOworCQlpZiAoY2VlLT5jYmZuLnJlc2V0X3N0YXRzX2NiZm4pIHsKKwkJCWNlZS0+Y2Jmbi5yZXNldF9zdGF0c19jYmZuKGNlZS0+Y2Jmbi5yZXNldF9zdGF0c19jYmFyZywKKwkJCQkJCSAgIEJGQV9TVEFUVVNfRkFJTEVEKTsKKwkJfQorCX0KK30KKworLyoqCisgKiBiZmFfY2VlX2F0dGFjaCgpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gY2VlIC0gUG9pbnRlciB0byB0aGUgQ0VFIG1vZHVsZSBkYXRhIHN0cnVjdHVyZQorICogICAgICAgICAgICBpb2MgLSBQb2ludGVyIHRvIHRoZSBpb2MgbW9kdWxlIGRhdGEgc3RydWN0dXJlCisgKiAgICAgICAgICAgIGRldiAtIFBvaW50ZXIgdG8gdGhlIGRldmljZSBkcml2ZXIgbW9kdWxlIGRhdGEgc3RydWN0dXJlCisgKiAgICAgICAgICAgICAgICAgIFRoZSBkZXZpY2UgZHJpdmVyIHNwZWNpZmljIG1ib3ggSVNSIGZ1bmN0aW9ucyBoYXZlCisgKiAgICAgICAgICAgICAgICAgIHRoaXMgcG9pbnRlciBhcyBvbmUgb2YgdGhlIHBhcmFtZXRlcnMuCisgKiAgICAgICAgICAgIHRyY21vZCAtCisgKiAgICAgICAgICAgIGxvZ21vZCAtCisgKgorICogQHJldHVybiB2b2lkCisgKi8KK3ZvaWQKK2JmYV9jZWVfYXR0YWNoKHN0cnVjdCBiZmFfY2VlX3MgKmNlZSwgc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB2b2lkICpkZXYsCisJICAgICAgIHN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QsIHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtb2QpCit7CisJYmZhX2Fzc2VydChjZWUgIT0gTlVMTCk7CisJY2VlLT5kZXYgPSBkZXY7CisJY2VlLT50cmNtb2QgPSB0cmNtb2Q7CisJY2VlLT5sb2dtb2QgPSBsb2dtb2Q7CisJY2VlLT5pb2MgPSBpb2M7CisKKwliZmFfaW9jX21ib3hfcmVnaXNyKGNlZS0+aW9jLCBCRklfTUNfQ0VFLCBiZmFfY2VlX2lzciwgY2VlKTsKKwliZmFfaW9jX2hiZmFpbF9pbml0KCZjZWUtPmhiZmFpbCwgYmZhX2NlZV9oYmZhaWwsIGNlZSk7CisJYmZhX2lvY19oYmZhaWxfcmVnaXN0ZXIoY2VlLT5pb2MsICZjZWUtPmhiZmFpbCk7CisJYmZhX3RyYyhjZWUsIDApOworfQorCisvKioKKyAqIGJmYV9jZWVfZGV0YWNoKCkKKyAqCisgKgorICogQHBhcmFtW2luXSBjZWUgLSBQb2ludGVyIHRvIHRoZSBDRUUgbW9kdWxlIGRhdGEgc3RydWN0dXJlCisgKgorICogQHJldHVybiB2b2lkCisgKi8KK3ZvaWQKK2JmYV9jZWVfZGV0YWNoKHN0cnVjdCBiZmFfY2VlX3MgKmNlZSkKK3sKKwkvKgorCSAqIEZvciBub3csIGp1c3QgY2hlY2sgaWYgdGhlcmUgaXMgc29tZSBpb2N0bCBwZW5kaW5nIGFuZCBtYXJrIHRoYXQgYXMKKwkgKiBmYWlsZWQ/CisJICovCisJLyogYmZhX2NlZV9oYmZhaWwoY2VlKTsgKi8KK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NvcmUuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NvcmUuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40NGUyZDExCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfY29yZS5jCkBAIC0wLDAgKzEsNDAyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3BjaS5oPgorI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorI2luY2x1ZGUgPGJmYV9pb2NmYy5oPgorCisjZGVmaW5lIERFRl9DRkdfTlVNX0ZBQlJJQ1MgICAgICAgICAxCisjZGVmaW5lIERFRl9DRkdfTlVNX0xQT1JUUyAgICAgICAgICAyNTYKKyNkZWZpbmUgREVGX0NGR19OVU1fQ1FTICAgICAgICAgICAgIDQKKyNkZWZpbmUgREVGX0NGR19OVU1fSU9JTV9SRVFTICAgICAgIChCRkFfSU9JTV9NQVgpCisjZGVmaW5lIERFRl9DRkdfTlVNX1RTS0lNX1JFUVMgICAgICAxMjgKKyNkZWZpbmUgREVGX0NGR19OVU1fRkNYUF9SRVFTICAgICAgIDY0CisjZGVmaW5lIERFRl9DRkdfTlVNX1VGX0JVRlMgICAgICAgICA2NAorI2RlZmluZSBERUZfQ0ZHX05VTV9SUE9SVFMgICAgICAgICAgMTAyNAorI2RlZmluZSBERUZfQ0ZHX05VTV9JVE5JTVMgICAgICAgICAgKERFRl9DRkdfTlVNX1JQT1JUUykKKyNkZWZpbmUgREVGX0NGR19OVU1fVElOUyAgICAgICAgICAgIDI1NgorCisjZGVmaW5lIERFRl9DRkdfTlVNX1NHUEdTICAgICAgICAgICAyMDQ4CisjZGVmaW5lIERFRl9DRkdfTlVNX1JFUVFfRUxFTVMgICAgICAyNTYKKyNkZWZpbmUgREVGX0NGR19OVU1fUlNQUV9FTEVNUyAgICAgIDY0CisjZGVmaW5lIERFRl9DRkdfTlVNX1NCT09UX1RHVFMgICAgICAxNgorI2RlZmluZSBERUZfQ0ZHX05VTV9TQk9PVF9MVU5TICAgICAgMTYKKworLyoqCisgKiBVc2UgdGhpcyBmdW5jdGlvbiBxdWVyeSB0aGUgbWVtb3J5IHJlcXVpcmVtZW50IG9mIHRoZSBCRkEgbGlicmFyeS4KKyAqIFRoaXMgZnVuY3Rpb24gbmVlZHMgdG8gYmUgY2FsbGVkIGJlZm9yZSBiZmFfYXR0YWNoKCkgdG8gZ2V0IHRoZQorICogbWVtb3J5IHJlcXVpcmVkIG9mIHRoZSBCRkEgbGF5ZXIgZm9yIGEgZ2l2ZW4gZHJpdmVyIGNvbmZpZ3VyYXRpb24uCisgKgorICogVGhpcyBjYWxsIHdpbGwgZmFpbCwgaWYgdGhlIGNhcCBpcyBvdXQgb2YgcmFuZ2UgY29tcGFyZWQgdG8gcHJlLWRlZmluZWQKKyAqIHZhbHVlcyB3aXRoaW4gdGhlIEJGQSBsaWJyYXJ5CisgKgorICogQHBhcmFtW2luXSBjZmcgLSAJcG9pbnRlciB0byBiZmFfaW9jX2NmZ190LiBEcml2ZXIgbGF5ZXIgc2hvdWxkIGluZGljYXRlCisgKiAJCQlpdHMgY29uZmlndXJhdGlvbiBpbiB0aGlzIHN0cnVjdHVyZS4KKyAqCQkJVGhlIGRlZmF1bHQgdmFsdWVzIGZvciBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zIGNhbiBiZQorICoJCQlmZXRjaGVkIHVzaW5nIGJmYV9jZmdfZ2V0X2RlZmF1bHQoKSBBUEkuCisgKgorICogCQkJSWYgY2FwJ3MgYm91bmRhcnkgY2hlY2sgZmFpbHMsIHRoZSBsaWJyYXJ5IHdpbGwgdXNlCisgKgkJCXRoZSBkZWZhdWx0IGJmYV9jYXBfdCB2YWx1ZXMgKGFuZCBsb2cgYSB3YXJuaW5nIG1zZykuCisgKgorICogQHBhcmFtW291dF0gbWVtaW5mbyAtIHBvaW50ZXIgdG8gYmZhX21lbWluZm9fdC4gVGhpcyBjb250ZW50CisgKiAJCQlpbmRpY2F0ZXMgdGhlIG1lbW9yeSB0eXBlIChzZWUgYmZhX21lbV90eXBlX3QpIGFuZAorICoJCQlhbW91bnQgb2YgbWVtb3J5IHJlcXVpcmVkLgorICoKKyAqCQkJRHJpdmVyIHNob3VsZCBhbGxvY2F0ZSB0aGUgbWVtb3J5LCBwb3B1bGF0ZSB0aGUKKyAqCQkJc3RhcnRpbmcgYWRkcmVzcyBmb3IgZWFjaCBibG9jayBhbmQgcHJvdmlkZSB0aGUgc2FtZQorICoJCQlzdHJ1Y3R1cmUgYXMgaW5wdXQgcGFyYW1ldGVyIHRvIGJmYV9hdHRhY2goKSBjYWxsLgorICoKKyAqIEByZXR1cm4gdm9pZAorICoKKyAqIFNwZWNpYWwgQ29uc2lkZXJhdGlvbnM6IEBub3RlCisgKi8KK3ZvaWQKK2JmYV9jZmdfZ2V0X21lbWluZm8oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbykKK3sKKwlpbnQgICAgICAgICAgICAgaTsKKwl1MzIgICAgICAgIGttX2xlbiA9IDAsIGRtX2xlbiA9IDA7CisKKwliZmFfYXNzZXJ0KChjZmcgIT0gTlVMTCkgJiYgKG1lbWluZm8gIT0gTlVMTCkpOworCisJYmZhX29zX21lbXNldCgodm9pZCAqKW1lbWluZm8sIDAsIHNpemVvZihzdHJ1Y3QgYmZhX21lbWluZm9fcykpOworCW1lbWluZm8tPm1lbWluZm9bQkZBX01FTV9UWVBFX0tWQSAtIDFdLm1lbV90eXBlID0KKwkJQkZBX01FTV9UWVBFX0tWQTsKKwltZW1pbmZvLT5tZW1pbmZvW0JGQV9NRU1fVFlQRV9ETUEgLSAxXS5tZW1fdHlwZSA9CisJCUJGQV9NRU1fVFlQRV9ETUE7CisKKwliZmFfaW9jZmNfbWVtaW5mbyhjZmcsICZrbV9sZW4sICZkbV9sZW4pOworCisJZm9yIChpID0gMDsgaGFsX21vZHNbaV07IGkrKykKKwkJaGFsX21vZHNbaV0tPm1lbWluZm8oY2ZnLCAma21fbGVuLCAmZG1fbGVuKTsKKworCisJbWVtaW5mby0+bWVtaW5mb1tCRkFfTUVNX1RZUEVfS1ZBIC0gMV0ubWVtX2xlbiA9IGttX2xlbjsKKwltZW1pbmZvLT5tZW1pbmZvW0JGQV9NRU1fVFlQRV9ETUEgLSAxXS5tZW1fbGVuID0gZG1fbGVuOworfQorCisvKioKKyAqIFVzZSB0aGlzIGZ1bmN0aW9uIHRvIGRvIGF0dGFjaCB0aGUgZHJpdmVyIGluc3RhbmNlIHdpdGggdGhlIEJGQQorICogbGlicmFyeS4gVGhpcyBmdW5jdGlvbiB3aWxsIG5vdCB0cmlnZ2VyIGFueSBIVyBpbml0aWFsaXphdGlvbgorICogcHJvY2VzcyAod2hpY2ggd2lsbCBiZSBkb25lIGluIGJmYV9pbml0KCkgY2FsbCkKKyAqCisgKiBUaGlzIGNhbGwgd2lsbCBmYWlsLCBpZiB0aGUgY2FwIGlzIG91dCBvZiByYW5nZSBjb21wYXJlZCB0bworICogcHJlLWRlZmluZWQgdmFsdWVzIHdpdGhpbiB0aGUgQkZBIGxpYnJhcnkKKyAqCisgKiBAcGFyYW1bb3V0XQliZmEJUG9pbnRlciB0byBiZmFfdC4KKyAqIEBwYXJhbVtpbl0JYmZhZCAJT3BhcXVlIGhhbmRsZSBiYWNrIHRvIHRoZSBkcml2ZXIncyBJT0Mgc3RydWN0dXJlCisgKiBAcGFyYW1baW5dCWNmZwlQb2ludGVyIHRvIGJmYV9pb2NfY2ZnX3QuIFNob3VsZCBiZSBzYW1lIHN0cnVjdHVyZQorICogCQkJdGhhdCB3YXMgdXNlZCBpbiBiZmFfY2ZnX2dldF9tZW1pbmZvKCkuCisgKiBAcGFyYW1baW5dIAltZW1pbmZvIFBvaW50ZXIgdG8gYmZhX21lbWluZm9fdC4gVGhlIGRyaXZlciBzaG91bGQKKyAqIAkJCXVzZSB0aGUgYmZhX2NmZ19nZXRfbWVtaW5mbygpIGNhbGwgdG8KKyAqIAkJCWZpbmQgdGhlIG1lbW9yeSBibG9ja3MgcmVxdWlyZWQsIGFsbG9jYXRlIHRoZQorICogCQkJcmVxdWlyZWQgbWVtb3J5IGFuZCBwcm92aWRlIHRoZSBzdGFydGluZyBhZGRyZXNzZXMuCisgKiBAcGFyYW1baW5dIAlwY2lkZXYJcG9pbnRlciB0byBzdHJ1Y3QgYmZhX3BjaWRldl9zCisgKgorICogQHJldHVybgorICogdm9pZAorICoKKyAqIFNwZWNpYWwgQ29uc2lkZXJhdGlvbnM6CisgKgorICogQG5vdGUKKyAqCisgKi8KK3ZvaWQKK2JmYV9hdHRhY2goc3RydWN0IGJmYV9zICpiZmEsIHZvaWQgKmJmYWQsIHN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmNmZywKKwkgICAgICAgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1lbWluZm8sIHN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldikKK3sKKwlpbnQgICAgICAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX21lbV9lbGVtX3MgKm1lbGVtOworCisJYmZhLT5mY3MgPSBCRkFfRkFMU0U7CisKKwliZmFfYXNzZXJ0KChjZmcgIT0gTlVMTCkgJiYgKG1lbWluZm8gIT0gTlVMTCkpOworCisJLyoqCisJICogaW5pdGlhbGl6ZSBhbGwgbWVtb3J5IHBvaW50ZXJzIGZvciBpdGVyYXRpdmUgYWxsb2NhdGlvbgorCSAqLworCWZvciAoaSA9IDA7IGkgPCBCRkFfTUVNX1RZUEVfTUFYOyBpKyspIHsKKwkJbWVsZW0gPSBtZW1pbmZvLT5tZW1pbmZvICsgaTsKKwkJbWVsZW0tPmt2YV9jdXJwID0gbWVsZW0tPmt2YTsKKwkJbWVsZW0tPmRtYV9jdXJwID0gbWVsZW0tPmRtYTsKKwl9CisKKwliZmFfaW9jZmNfYXR0YWNoKGJmYSwgYmZhZCwgY2ZnLCBtZW1pbmZvLCBwY2lkZXYpOworCisJZm9yIChpID0gMDsgaGFsX21vZHNbaV07IGkrKykKKwkJaGFsX21vZHNbaV0tPmF0dGFjaChiZmEsIGJmYWQsIGNmZywgbWVtaW5mbywgcGNpZGV2KTsKKworfQorCisvKioKKyAqIFVzZSB0aGlzIGZ1bmN0aW9uIHRvIGRlbGV0ZSBhIEJGQSBJT0MuIElPQyBzaG91bGQgYmUgc3RvcHBlZCAoYnkKKyAqIGNhbGxpbmcgYmZhX3N0b3AoKSkgYmVmb3JlIHRoaXMgZnVuY3Rpb24gY2FsbC4KKyAqCisgKiBAcGFyYW1baW5dIGJmYSAtIHBvaW50ZXIgdG8gYmZhX3QuCisgKgorICogQHJldHVybgorICogdm9pZAorICoKKyAqIFNwZWNpYWwgQ29uc2lkZXJhdGlvbnM6CisgKgorICogQG5vdGUKKyAqLwordm9pZAorYmZhX2RldGFjaChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlpbnQJaTsKKworCWZvciAoaSA9IDA7IGhhbF9tb2RzW2ldOyBpKyspCisJCWhhbF9tb2RzW2ldLT5kZXRhY2goYmZhKTsKKworCWJmYV9pb2NmY19kZXRhY2goYmZhKTsKK30KKworCit2b2lkCitiZmFfaW5pdF90cmMoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QpCit7CisJYmZhLT50cmNtb2QgPSB0cmNtb2Q7Cit9CisKKwordm9pZAorYmZhX2luaXRfbG9nKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbW9kKQoreworCWJmYS0+bG9nbSA9IGxvZ21vZDsKK30KKworCit2b2lkCitiZmFfaW5pdF9hZW4oc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfYWVuX3MgKmFlbikKK3sKKwliZmEtPmFlbiA9IGFlbjsKK30KKwordm9pZAorYmZhX2luaXRfcGxvZyhzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9wbG9nX3MgKnBsb2cpCit7CisJYmZhLT5wbG9nID0gcGxvZzsKK30KKworLyoqCisgKiBJbml0aWFsaXplIElPQy4KKyAqCisgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgcmV0dXJuIGltbWVkaWF0ZWx5LCB3aGVuIHRoZSBJT0MgaW5pdGlhbGl6YXRpb24gaXMKKyAqIGNvbXBsZXRlZCwgdGhlIGJmYV9jYl9pbml0KCkgd2lsbCBiZSBjYWxsZWQuCisgKgorICogQHBhcmFtW2luXQliZmEJaW5zdGFuY2UKKyAqCisgKiBAcmV0dXJuIHZvaWQKKyAqCisgKiBTcGVjaWFsIENvbnNpZGVyYXRpb25zOgorICoKKyAqIEBub3RlCisgKiBXaGVuIHRoaXMgZnVuY3Rpb24gcmV0dXJucywgdGhlIGRyaXZlciBzaG91bGQgcmVnaXN0ZXIgdGhlIGludGVycnVwdCBzZXJ2aWNlCisgKiByb3V0aW5lKHMpIGFuZCBlbmFibGUgdGhlIGRldmljZSBpbnRlcnJ1cHRzLiBJZiB0aGlzIGlzIG5vdCBkb25lLAorICogYmZhX2NiX2luaXQoKSB3aWxsIG5ldmVyIGdldCBjYWxsZWQKKyAqLwordm9pZAorYmZhX2luaXQoc3RydWN0IGJmYV9zICpiZmEpCit7CisJYmZhX2lvY2ZjX2luaXQoYmZhKTsKK30KKworLyoqCisgKiBVc2UgdGhpcyBmdW5jdGlvbiBpbml0aWF0ZSB0aGUgSU9DIGNvbmZpZ3VyYXRpb24gc2V0dXAuIFRoaXMgZnVuY3Rpb24KKyAqIHdpbGwgcmV0dXJuIGltbWVkaWF0ZWx5LgorICoKKyAqIEBwYXJhbVtpbl0JYmZhCWluc3RhbmNlCisgKgorICogQHJldHVybiBOb25lCisgKi8KK3ZvaWQKK2JmYV9zdGFydChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwliZmFfaW9jZmNfc3RhcnQoYmZhKTsKK30KKworLyoqCisgKiBVc2UgdGhpcyBmdW5jdGlvbiBxdWllc2UgdGhlIElPQy4gVGhpcyBmdW5jdGlvbiB3aWxsIHJldHVybiBpbW1lZGlhdGVseSwKKyAqIHdoZW4gdGhlIElPQyBpcyBhY3R1YWxseSBzdG9wcGVkLCB0aGUgYmZhX2NiX3N0b3AoKSB3aWxsIGJlIGNhbGxlZC4KKyAqCisgKiBAcGFyYW1baW5dIAliZmEgLSBwb2ludGVyIHRvIGJmYV90LgorICoKKyAqIEByZXR1cm4gTm9uZQorICoKKyAqIFNwZWNpYWwgQ29uc2lkZXJhdGlvbnM6CisgKiBiZmFfY2Jfc3RvcCgpIGNvdWxkIGJlIGNhbGxlZCBiZWZvcmUgb3IgYWZ0ZXIgYmZhX3N0b3AoKSByZXR1cm5zLgorICoKKyAqIEBub3RlCisgKiBJbiBjYXNlIG9mIGFueSBmYWlsdXJlLCB3ZSBjb3VsZCBoYW5kbGUgaXQgYXV0b21hdGljYWxseSBieSBkb2luZyBhCisgKiByZXNldCBhbmQgdGhlbiBzdWNjZWVkIHRoZSBiZmFfc3RvcCgpIGNhbGwuCisgKi8KK3ZvaWQKK2JmYV9zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWJmYV9pb2NmY19zdG9wKGJmYSk7Cit9CisKK3ZvaWQKK2JmYV9jb21wX2RlcShzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGxpc3RfaGVhZCAqY29tcF9xKQoreworCUlOSVRfTElTVF9IRUFEKGNvbXBfcSk7CisJbGlzdF9zcGxpY2VfdGFpbF9pbml0KCZiZmEtPmNvbXBfcSwgY29tcF9xKTsKK30KKwordm9pZAorYmZhX2NvbXBfcHJvY2VzcyhzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGxpc3RfaGVhZCAqY29tcF9xKQoreworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICpxZTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAqcWVuOworCXN0cnVjdCBiZmFfY2JfcWVfcyAgICpoY2JfcWU7CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgY29tcF9xKSB7CisJCWhjYl9xZSA9IChzdHJ1Y3QgYmZhX2NiX3FlX3MgKikgcWU7CisJCWhjYl9xZS0+Y2JmbihoY2JfcWUtPmNiYXJnLCBCRkFfVFJVRSk7CisJfQorfQorCit2b2lkCitiZmFfY29tcF9mcmVlKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgbGlzdF9oZWFkICpjb21wX3EpCit7CisJc3RydWN0IGxpc3RfaGVhZCAgICAgICAgKnFlOworCXN0cnVjdCBiZmFfY2JfcWVfcyAgICpoY2JfcWU7CisKKwl3aGlsZSAoIWxpc3RfZW1wdHkoY29tcF9xKSkgeworCQliZmFfcV9kZXEoY29tcF9xLCAmcWUpOworCQloY2JfcWUgPSAoc3RydWN0IGJmYV9jYl9xZV9zICopIHFlOworCQloY2JfcWUtPmNiZm4oaGNiX3FlLT5jYmFyZywgQkZBX0ZBTFNFKTsKKwl9Cit9CisKK3ZvaWQKK2JmYV9hdHRhY2hfZmNzKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWJmYS0+ZmNzID0gQkZBX1RSVUU7Cit9CisKKy8qKgorICogUGVyaW9kaWMgdGltZXIgaGVhcnQgYmVhdCBmcm9tIGRyaXZlcgorICovCit2b2lkCitiZmFfdGltZXJfdGljayhzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwliZmFfdGltZXJfYmVhdCgmYmZhLT50aW1lcl9tb2QpOworfQorCisjaWZuZGVmIEJGQV9CSU9TX0JVSUxECisvKioKKyAqIFJldHVybiB0aGUgbGlzdCBvZiBQQ0kgdmVuZG9yL2RldmljZSBpZCBsaXN0cyBzdXBwb3J0ZWQgYnkgdGhpcworICogQkZBIGluc3RhbmNlLgorICovCit2b2lkCitiZmFfZ2V0X3BjaWlkcyhzdHJ1Y3QgYmZhX3BjaWlkX3MgKipwY2lpZHMsIGludCAqbnBjaWlkcykKK3sKKwlzdGF0aWMgc3RydWN0IGJmYV9wY2lpZF9zIF9fcGNpaWRzW10gPSB7CisJCXtCRkFfUENJX1ZFTkRPUl9JRF9CUk9DQURFLCBCRkFfUENJX0RFVklDRV9JRF9GQ184RzJQfSwKKwkJe0JGQV9QQ0lfVkVORE9SX0lEX0JST0NBREUsIEJGQV9QQ0lfREVWSUNFX0lEX0ZDXzhHMVB9LAorCQl7QkZBX1BDSV9WRU5ET1JfSURfQlJPQ0FERSwgQkZBX1BDSV9ERVZJQ0VfSURfQ1R9LAorCX07CisKKwkqbnBjaWlkcyA9IHNpemVvZihfX3BjaWlkcykgLyBzaXplb2YoX19wY2lpZHNbMF0pOworCSpwY2lpZHMgPSBfX3BjaWlkczsKK30KKworLyoqCisgKiBVc2UgdGhpcyBmdW5jdGlvbiBxdWVyeSB0aGUgZGVmYXVsdCBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zIHZhbHVlIChjb21waWxlZAorICogaW50byBCRkEgbGF5ZXIpLiBUaGUgT1MgZHJpdmVyIGNhbiB0aGVuIHR1cm4gYmFjayBhbmQgb3ZlcndyaXRlIGVudHJpZXMgdGhhdAorICogaGF2ZSBiZWVuIGNvbmZpZ3VyZWQgYnkgdGhlIHVzZXIuCisgKgorICogQHBhcmFtW2luXSBjZmcgLSBwb2ludGVyIHRvIGJmYV9pb2NfY2ZnX3QKKyAqCisgKiBAcmV0dXJuCisgKgl2b2lkCisgKgorICogU3BlY2lhbCBDb25zaWRlcmF0aW9uczoKKyAqIAlub3RlCisgKi8KK3ZvaWQKK2JmYV9jZmdfZ2V0X2RlZmF1bHQoc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnKQoreworCWNmZy0+ZndjZmcubnVtX2ZhYnJpY3MgPSBERUZfQ0ZHX05VTV9GQUJSSUNTOworCWNmZy0+ZndjZmcubnVtX2xwb3J0cyA9IERFRl9DRkdfTlVNX0xQT1JUUzsKKwljZmctPmZ3Y2ZnLm51bV9ycG9ydHMgPSBERUZfQ0ZHX05VTV9SUE9SVFM7CisJY2ZnLT5md2NmZy5udW1faW9pbV9yZXFzID0gREVGX0NGR19OVU1fSU9JTV9SRVFTOworCWNmZy0+ZndjZmcubnVtX3Rza2ltX3JlcXMgPSBERUZfQ0ZHX05VTV9UU0tJTV9SRVFTOworCWNmZy0+ZndjZmcubnVtX2ZjeHBfcmVxcyA9IERFRl9DRkdfTlVNX0ZDWFBfUkVRUzsKKwljZmctPmZ3Y2ZnLm51bV91Zl9idWZzID0gREVGX0NGR19OVU1fVUZfQlVGUzsKKwljZmctPmZ3Y2ZnLm51bV9jcXMgPSBERUZfQ0ZHX05VTV9DUVM7CisKKwljZmctPmRydmNmZy5udW1fcmVxcV9lbGVtcyA9IERFRl9DRkdfTlVNX1JFUVFfRUxFTVM7CisJY2ZnLT5kcnZjZmcubnVtX3JzcHFfZWxlbXMgPSBERUZfQ0ZHX05VTV9SU1BRX0VMRU1TOworCWNmZy0+ZHJ2Y2ZnLm51bV9zZ3BncyA9IERFRl9DRkdfTlVNX1NHUEdTOworCWNmZy0+ZHJ2Y2ZnLm51bV9zYm9vdF90Z3RzID0gREVGX0NGR19OVU1fU0JPT1RfVEdUUzsKKwljZmctPmRydmNmZy5udW1fc2Jvb3RfbHVucyA9IERFRl9DRkdfTlVNX1NCT09UX0xVTlM7CisJY2ZnLT5kcnZjZmcucGF0aF90b3YgPSBCRkFfRkNQSU1fUEFUSFRPVl9ERUY7CisJY2ZnLT5kcnZjZmcuaW9jX3JlY292ZXIgPSBCRkFfRkFMU0U7CisJY2ZnLT5kcnZjZmcuZGVsYXlfY29tcCA9IEJGQV9GQUxTRTsKKworfQorCit2b2lkCitiZmFfY2ZnX2dldF9taW4oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnKQoreworCWJmYV9jZmdfZ2V0X2RlZmF1bHQoY2ZnKTsKKwljZmctPmZ3Y2ZnLm51bV9pb2ltX3JlcXMgICA9IEJGQV9JT0lNX01JTjsKKwljZmctPmZ3Y2ZnLm51bV90c2tpbV9yZXFzICA9IEJGQV9UU0tJTV9NSU47CisJY2ZnLT5md2NmZy5udW1fZmN4cF9yZXFzICAgPSBCRkFfRkNYUF9NSU47CisJY2ZnLT5md2NmZy5udW1fdWZfYnVmcyAgICAgPSBCRkFfVUZfTUlOOworCWNmZy0+ZndjZmcubnVtX3Jwb3J0cyAgICAgID0gQkZBX1JQT1JUX01JTjsKKworCWNmZy0+ZHJ2Y2ZnLm51bV9zZ3BncyAgICAgID0gQkZBX1NHUEdfTUlOOworCWNmZy0+ZHJ2Y2ZnLm51bV9yZXFxX2VsZW1zID0gQkZBX1JFUVFfTkVMRU1TX01JTjsKKwljZmctPmRydmNmZy5udW1fcnNwcV9lbGVtcyA9IEJGQV9SU1BRX05FTEVNU19NSU47CisJY2ZnLT5kcnZjZmcubWluX2NmZyAgICAgICAgPSBCRkFfVFJVRTsKK30KKwordm9pZAorYmZhX2dldF9hdHRyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2lvY19hdHRyX3MgKmlvY19hdHRyKQoreworCWJmYV9pb2NfZ2V0X2F0dHIoJmJmYS0+aW9jLCBpb2NfYXR0cik7Cit9CisKKy8qKgorICogUmV0cmlldmUgZmlybXdhcmUgdHJhY2UgaW5mb3JtYXRpb24gb24gSU9DIGZhaWx1cmUuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2RlYnVnX2Z3c2F2ZShzdHJ1Y3QgYmZhX3MgKmJmYSwgdm9pZCAqdHJjZGF0YSwgaW50ICp0cmNsZW4pCit7CisJcmV0dXJuIGJmYV9pb2NfZGVidWdfZndzYXZlKCZiZmEtPmlvYywgdHJjZGF0YSwgdHJjbGVuKTsKK30KKworLyoqCisgKiAJCUZldGNoIGZpcm13YXJlIHRyYWNlIGRhdGEuCisgKgorICogQHBhcmFtW2luXQkJYmZhCQkJQkZBIGluc3RhbmNlCisgKiBAcGFyYW1bb3V0XQkJdHJjZGF0YQkJRmlybXdhcmUgdHJhY2UgYnVmZmVyCisgKiBAcGFyYW1baW4sb3V0XQl0cmNsZW4JCUZpcm13YXJlIHRyYWNlIGJ1ZmZlciBsZW4KKyAqCisgKiBAcmV0dmFsIEJGQV9TVEFUVVNfT0sJCQlGaXJtd2FyZSB0cmFjZSBpcyBmZXRjaGVkLgorICogQHJldHZhbCBCRkFfU1RBVFVTX0lOUFJPR1JFU1MJRmlybXdhcmUgdHJhY2UgZmV0Y2ggaXMgaW4gcHJvZ3Jlc3MuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2RlYnVnX2Z3dHJjKHN0cnVjdCBiZmFfcyAqYmZhLCB2b2lkICp0cmNkYXRhLCBpbnQgKnRyY2xlbikKK3sKKwlyZXR1cm4gYmZhX2lvY19kZWJ1Z19md3RyYygmYmZhLT5pb2MsIHRyY2RhdGEsIHRyY2xlbik7Cit9CisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NzZGVidWcuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2NzZGVidWcuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xYjcxZDM0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfY3NkZWJ1Zy5jCkBAIC0wLDAgKzEsNTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfcS5oPgorI2luY2x1ZGUgPGxvZy9iZmFfbG9nX2hhbC5oPgorCisvKioKKyAqICBjc19kZWJ1Z19hcGkKKyAqLworCisKK3ZvaWQKK2JmYV9wYW5pYyhpbnQgbGluZSwgY2hhciAqZmlsZSwgY2hhciAqcGFuaWNzdHIpCit7CisJYmZhX2xvZyhOVUxMLCBCRkFfTE9HX0hBTF9BU1NFUlQsIGZpbGUsIGxpbmUsIHBhbmljc3RyKTsKKwliZmFfb3NfcGFuaWMoKTsKK30KKwordm9pZAorYmZhX3NtX3BhbmljKHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtLCBpbnQgbGluZSwgY2hhciAqZmlsZSwgaW50IGV2ZW50KQoreworCWJmYV9sb2cobG9nbSwgQkZBX0xPR19IQUxfU01fQVNTRVJULCBmaWxlLCBsaW5lLCBldmVudCk7CisJYmZhX29zX3BhbmljKCk7Cit9CisKK2ludAorYmZhX3FfaXNfb25fcV9mdW5jKHN0cnVjdCBsaXN0X2hlYWQgKnEsIHN0cnVjdCBsaXN0X2hlYWQgKnFlKQoreworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICp0cWU7CisKKwl0cWUgPSBiZmFfcV9uZXh0KHEpOworCXdoaWxlICh0cWUgIT0gcSkgeworCQlpZiAodHFlID09IHFlKQorCQkJcmV0dXJuICgxKTsKKwkJdHFlID0gYmZhX3FfbmV4dCh0cWUpOworCQlpZiAodHFlID09IE5VTEwpCisJCQlicmVhazsKKwl9CisJcmV0dXJuICgwKTsKK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3BpbS5jIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNwaW0uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40MDFiYWJlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNwaW0uYwpAQCAtMCwwICsxLDE3NSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSA8YmZhLmg+CisjaW5jbHVkZSA8bG9nL2JmYV9sb2dfaGFsLmg+CisKK0JGQV9UUkNfRklMRShIQUwsIEZDUElNKTsKK0JGQV9NT0RVTEUoZmNwaW0pOworCisvKioKKyAqICBoYWxfZmNwaW1fbW9kIEJGQSBGQ1AgSW5pdGlhdG9yIE1vZGUgbW9kdWxlCisgKi8KKworLyoqCisgKiAJCUNvbXB1dGUgYW5kIHJldHVybiBtZW1vcnkgbmVlZGVkIGJ5IEZDUChpbSkgbW9kdWxlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2ZjcGltX21lbWluZm8oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKmttX2xlbiwKKwkJdTMyICpkbV9sZW4pCit7CisJYmZhX2l0bmltX21lbWluZm8oY2ZnLCBrbV9sZW4sIGRtX2xlbik7CisKKwkvKioKKwkgKiBJTyBtZW1vcnkKKwkgKi8KKwlpZiAoY2ZnLT5md2NmZy5udW1faW9pbV9yZXFzIDwgQkZBX0lPSU1fTUlOKQorCQljZmctPmZ3Y2ZnLm51bV9pb2ltX3JlcXMgPSBCRkFfSU9JTV9NSU47CisJZWxzZSBpZiAoY2ZnLT5md2NmZy5udW1faW9pbV9yZXFzID4gQkZBX0lPSU1fTUFYKQorCQljZmctPmZ3Y2ZnLm51bV9pb2ltX3JlcXMgPSBCRkFfSU9JTV9NQVg7CisKKwkqa21fbGVuICs9IGNmZy0+ZndjZmcubnVtX2lvaW1fcmVxcyAqCisJICAoc2l6ZW9mKHN0cnVjdCBiZmFfaW9pbV9zKSArIHNpemVvZihzdHJ1Y3QgYmZhX2lvaW1fc3BfcykpOworCisJKmRtX2xlbiArPSBjZmctPmZ3Y2ZnLm51bV9pb2ltX3JlcXMgKiBCRklfSU9JTV9TTlNMRU47CisKKwkvKioKKwkgKiB0YXNrIG1hbmFnZW1lbnQgY29tbWFuZCBtZW1vcnkKKwkgKi8KKwlpZiAoY2ZnLT5md2NmZy5udW1fdHNraW1fcmVxcyA8IEJGQV9UU0tJTV9NSU4pCisJCWNmZy0+ZndjZmcubnVtX3Rza2ltX3JlcXMgPSBCRkFfVFNLSU1fTUlOOworCSprbV9sZW4gKz0gY2ZnLT5md2NmZy5udW1fdHNraW1fcmVxcyAqIHNpemVvZihzdHJ1Y3QgYmZhX3Rza2ltX3MpOworfQorCisKK3N0YXRpYyB2b2lkCitiZmFfZmNwaW1fYXR0YWNoKHN0cnVjdCBiZmFfcyAqYmZhLCB2b2lkICpiZmFkLCBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCSAgICAgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1lbWluZm8sIHN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldikKK3sKKwlzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSA9IEJGQV9GQ1BJTV9NT0QoYmZhKTsKKworCWJmYV90cmMoYmZhLCBjZmctPmRydmNmZy5wYXRoX3Rvdik7CisJYmZhX3RyYyhiZmEsIGNmZy0+ZndjZmcubnVtX3Jwb3J0cyk7CisJYmZhX3RyYyhiZmEsIGNmZy0+ZndjZmcubnVtX2lvaW1fcmVxcyk7CisJYmZhX3RyYyhiZmEsIGNmZy0+ZndjZmcubnVtX3Rza2ltX3JlcXMpOworCisJZmNwaW0tPmJmYSAgICAgICAgICAgID0gYmZhOworCWZjcGltLT5udW1faXRuaW1zICAgICA9IGNmZy0+ZndjZmcubnVtX3Jwb3J0czsKKwlmY3BpbS0+bnVtX2lvaW1fcmVxcyAgPSBjZmctPmZ3Y2ZnLm51bV9pb2ltX3JlcXM7CisJZmNwaW0tPm51bV90c2tpbV9yZXFzID0gY2ZnLT5md2NmZy5udW1fdHNraW1fcmVxczsKKwlmY3BpbS0+cGF0aF90b3YgICAgICAgPSBjZmctPmRydmNmZy5wYXRoX3RvdjsKKwlmY3BpbS0+ZGVsYXlfY29tcAkgID0gY2ZnLT5kcnZjZmcuZGVsYXlfY29tcDsKKworCWJmYV9pdG5pbV9hdHRhY2goZmNwaW0sIG1lbWluZm8pOworCWJmYV90c2tpbV9hdHRhY2goZmNwaW0sIG1lbWluZm8pOworCWJmYV9pb2ltX2F0dGFjaChmY3BpbSwgbWVtaW5mbyk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNwaW1faW5pdGRvbmUoc3RydWN0IGJmYV9zICpiZmEpCit7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNwaW1fZGV0YWNoKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCisJYmZhX2lvaW1fZGV0YWNoKGZjcGltKTsKKwliZmFfdHNraW1fZGV0YWNoKGZjcGltKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3BpbV9zdGFydChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3BpbV9zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX2ZjcGltX2lvY2Rpc2FibGUoc3RydWN0IGJmYV9zICpiZmEpCit7CisJc3RydWN0IGJmYV9mY3BpbV9tb2RfcyAqZmNwaW0gPSBCRkFfRkNQSU1fTU9EKGJmYSk7CisJc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAqcWUsICpxZW47CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJmZjcGltLT5pdG5pbV9xKSB7CisJCWl0bmltID0gKHN0cnVjdCBiZmFfaXRuaW1fcyAqKSBxZTsKKwkJYmZhX2l0bmltX2lvY2Rpc2FibGUoaXRuaW0pOworCX0KK30KKwordm9pZAorYmZhX2ZjcGltX3BhdGhfdG92X3NldChzdHJ1Y3QgYmZhX3MgKmJmYSwgdTE2IHBhdGhfdG92KQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCisJZmNwaW0tPnBhdGhfdG92ID0gcGF0aF90b3YgKiAxMDAwOworCWlmIChmY3BpbS0+cGF0aF90b3YgPiBCRkFfRkNQSU1fUEFUSFRPVl9NQVgpCisJCWZjcGltLT5wYXRoX3RvdiA9IEJGQV9GQ1BJTV9QQVRIVE9WX01BWDsKK30KKwordTE2CitiZmFfZmNwaW1fcGF0aF90b3ZfZ2V0KHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCisJcmV0dXJuIChmY3BpbS0+cGF0aF90b3YgLyAxMDAwKTsKK30KKworYmZhX3N0YXR1c190CitiZmFfZmNwaW1fZ2V0X21vZHN0YXRzKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2ZjcGltX3N0YXRzX3MgKm1vZHN0YXRzKQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCisJKm1vZHN0YXRzID0gZmNwaW0tPnN0YXRzOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKK2JmYV9zdGF0dXNfdAorYmZhX2ZjcGltX2Nscl9tb2RzdGF0cyhzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSA9IEJGQV9GQ1BJTV9NT0QoYmZhKTsKKworCW1lbXNldCgmZmNwaW0tPnN0YXRzLCAwLCBzaXplb2Yoc3RydWN0IGJmYV9mY3BpbV9zdGF0c19zKSk7CisKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKwordm9pZAorYmZhX2ZjcGltX3FkZXB0aF9zZXQoc3RydWN0IGJmYV9zICpiZmEsIHUxNiBxX2RlcHRoKQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCisJYmZhX2Fzc2VydChxX2RlcHRoIDw9IEJGQV9JT0NGQ19RREVQVEhfTUFYKTsKKworCWZjcGltLT5xX2RlcHRoID0gcV9kZXB0aDsKK30KKwordTE2CitiZmFfZmNwaW1fcWRlcHRoX2dldChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSA9IEJGQV9GQ1BJTV9NT0QoYmZhKTsKKworCXJldHVybiAoZmNwaW0tPnFfZGVwdGgpOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjcGltX3ByaXYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjcGltX3ByaXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xNTMyMDZjCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNwaW1fcHJpdi5oCkBAIC0wLDAgKzEsMTg4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfRkNQSU1fUFJJVl9IX18KKyNkZWZpbmUgX19CRkFfRkNQSU1fUFJJVl9IX18KKworI2luY2x1ZGUgPGJmYV9mY3BpbS5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfZmNwaW0uaD4KKyNpbmNsdWRlIDxjcy9iZmFfd2MuaD4KKyNpbmNsdWRlICJiZmFfc2dwZ19wcml2LmgiCisKKyNkZWZpbmUgQkZBX0lUTklNX01JTiAgIDMyCisjZGVmaW5lIEJGQV9JVE5JTV9NQVggICAxMDI0CisKKyNkZWZpbmUgQkZBX0lPSU1fTUlOICAgIDgKKyNkZWZpbmUgQkZBX0lPSU1fTUFYICAgIDIwMDAKKworI2RlZmluZSBCRkFfVFNLSU1fTUlOICAgNAorI2RlZmluZSBCRkFfVFNLSU1fTUFYICAgNTEyCisjZGVmaW5lIEJGQV9GQ1BJTV9QQVRIVE9WX0RFRgkoMzAgKiAxMDAwKQkvKiBpbiBtaWxsaXNlY3MgKi8KKyNkZWZpbmUgQkZBX0ZDUElNX1BBVEhUT1ZfTUFYCSg5MCAqIDEwMDApCS8qIGluIG1pbGxpc2VjcyAqLworCisjZGVmaW5lIGJmYV9mY3BpbV9zdGF0cyhfX2ZjcGltLCBfX3N0YXRzKSAgIFwKKyAgICAoX19mY3BpbSktPnN0YXRzLl9fc3RhdHMgKysKKworc3RydWN0IGJmYV9mY3BpbV9tb2RfcyB7CisJc3RydWN0IGJmYV9zIAkqYmZhOworCXN0cnVjdCBiZmFfaXRuaW1fcyAJKml0bmltX2FycjsKKwlzdHJ1Y3QgYmZhX2lvaW1fcyAJKmlvaW1fYXJyOworCXN0cnVjdCBiZmFfaW9pbV9zcF9zICppb2ltX3NwX2FycjsKKwlzdHJ1Y3QgYmZhX3Rza2ltX3MgCSp0c2tpbV9hcnI7CisJc3RydWN0IGJmYV9kbWFfcwlzbnNiYXNlOworCWludAkJCW51bV9pdG5pbXM7CisJaW50CQkJbnVtX2lvaW1fcmVxczsKKwlpbnQJCQludW1fdHNraW1fcmVxczsKKwl1MzIJCXBhdGhfdG92OworCXUxNgkJcV9kZXB0aDsKKwl1MTYJCXJzdmQ7CisJc3RydWN0IGxpc3RfaGVhZCAJaXRuaW1fcTsgICAgICAgIC8qICBxdWV1ZSBvZiBhY3RpdmUgaXRuaW0gICAgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIAlpb2ltX2ZyZWVfcTsgICAgLyogIGZyZWUgSU8gcmVzb3VyY2VzICAgICAgICAqLworCXN0cnVjdCBsaXN0X2hlYWQgCWlvaW1fcmVzZnJlZV9xOyAvKiAgSU9zIHdhaXRpbmcgZm9yIGYvdyAgICAgICovCisJc3RydWN0IGxpc3RfaGVhZCAJaW9pbV9jb21wX3E7ICAgIC8qICBJTyBnbG9iYWwgY29tcCBRICAgICAgICAgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIAl0c2tpbV9mcmVlX3E7CisJdTMyCWlvc19hY3RpdmU7CS8qICBjdXJyZW50IGFjdGl2ZSBJT3MJICAgICAgKi8KKwl1MzIJZGVsYXlfY29tcDsKKwlzdHJ1Y3QgYmZhX2ZjcGltX3N0YXRzX3Mgc3RhdHM7Cit9OworCitzdHJ1Y3QgYmZhX2lvaW1fczsKK3N0cnVjdCBiZmFfdHNraW1fczsKKworLyoqCisgKiBCRkEgSU8gKGluaXRpYXRvciBtb2RlKQorICovCitzdHJ1Y3QgYmZhX2lvaW1fcyB7CisJc3RydWN0IGxpc3RfaGVhZCBxZTsJCS8qICBxdWV1ZSBlbGVtZW10ICAgICAgICAgICAgKi8KKwliZmFfc21fdAkJc207IAkvKiAgQkZBIGlvaW0gc3RhdGUgbWFjaGluZSAgICovCisJc3RydWN0IGJmYV9zIAkgICAgICAgICpiZmE7CS8qICBCRkEgbW9kdWxlICAgICAgICAgICAgICAgKi8KKwlzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zCSpmY3BpbTsJLyogIHBhcmVudCBmY3BpbSBtb2R1bGUgICAgICAqLworCXN0cnVjdCBiZmFfaXRuaW1fcyAJKml0bmltOwkvKiAgaS10LW4gbmV4dXMgZm9yIHRoaXMgSU8gICovCisJc3RydWN0IGJmYWRfaW9pbV9zIAkqZGlvOwkvKiAgZHJpdmVyIElPIGhhbmRsZSAgICAgICAgICovCisJdTE2CWlvdGFnOwkJLyogIEZXSSBJTyB0YWcgICAgICAgICAgICAgICAqLworCXUxNglhYm9ydF90YWc7CS8qICB1bnFpdWUgYWJvcnQgcmVxdWVzdCB0YWcgKi8KKwl1MTYJbnNnZXM7CQkvKiAgbnVtYmVyIG9mIFNHIGVsZW1lbnRzICAgICovCisJdTE2CW5zZ3BnczsJCS8qICBudW1iZXIgb2YgU0cgcGFnZXMgICAgICAgKi8KKwlzdHJ1Y3QgYmZhX3NncGdfcyAqc2dwZzsJLyogIGZpcnN0IFNHIHBhZ2UgICAgICAgICAgICAqLworCXN0cnVjdCBsaXN0X2hlYWQgc2dwZ19xOwkJLyogIGFsbG9jYXRlZCBTRyBwYWdlcyAgICAgICAqLworCXN0cnVjdCBiZmFfY2JfcWVfcyBoY2JfcWU7CS8qICBiZmEgY2FsbGJhY2sgcWVsZW0gICAgICAgKi8KKwliZmFfY2JfY2Jmbl90IGlvX2NiZm47CQkvKiAgSU8gY29tcGxldGlvbiBoYW5kbGVyICAgICovCisJc3RydWN0IGJmYV9pb2ltX3NwX3MgKmlvc3A7CS8qICBzbG93LXBhdGggSU8gaGFuZGxpbmcgICAgKi8KK307CisKK3N0cnVjdCBiZmFfaW9pbV9zcF9zIHsKKwlzdHJ1Y3QgYmZpX21zZ19zIAljb21wX3JzcG1zZzsJLyogIElPIGNvbXAgZi93IHJlc3BvbnNlICAgICAqLworCXU4CQkJKnNuc2luZm87CS8qICBzZW5zZSBpbmZvIGZvciB0aGlzIElPICAgKi8KKwlzdHJ1Y3QgYmZhX3NncGdfd3FlX3Mgc2dwZ193cWU7CS8qICB3YWl0cSBlbGVtIGZvciBzZ3BnICAgICAgKi8KKwlzdHJ1Y3QgYmZhX3JlcXFfd2FpdF9zIHJlcXFfd2FpdDsJLyogIHRvIHdhaXQgZm9yIHJvb20gaW4gcmVxcSAqLworCWJmYV9ib29sZWFuX3QJCWFib3J0X2V4cGxpY2l0OwkvKiAgYWJvcnRlZCBieSBPUyAgICAgICAgICAgICovCisJc3RydWN0IGJmYV90c2tpbV9zCSp0c2tpbTsJCS8qICBSZWxldmFudCBUTSBjbWQgICAgICAgICAgKi8KK307CisKKy8qKgorICogQkZBIFRhc2sgbWFuYWdlbWVudCBjb21tYW5kIChpbml0aWF0b3IgbW9kZSkKKyAqLworc3RydWN0IGJmYV90c2tpbV9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAgIHFlOworCWJmYV9zbV90CQlzbTsKKwlzdHJ1Y3QgYmZhX3MgICAgICAgICAgICAqYmZhOyAgICAgICAgLyogIEJGQSBtb2R1bGUgICovCisJc3RydWN0IGJmYV9mY3BpbV9tb2RfcyAgKmZjcGltOyAgICAgIC8qICBwYXJlbnQgZmNwaW0gbW9kdWxlICAgICAgKi8KKwlzdHJ1Y3QgYmZhX2l0bmltX3MgICAgICAqaXRuaW07ICAgICAgLyogIGktdC1uIG5leHVzIGZvciB0aGlzIElPICAqLworCXN0cnVjdCBiZmFkX3Rza2ltX3MgICAgICAgICAqZHRzazsgICAvKiAgZHJpdmVyIHRhc2sgbWdtdCBjbW5kICAgICovCisJYmZhX2Jvb2xlYW5fdCAgICAgICAgbm90aWZ5OyAgICAgICAgIC8qICBub3RpZnkgaXRuaW0gb24gVE0gY29tcCAgKi8KKwlsdW5fdCAgICAgICAgICAgICAgICBsdW47ICAgICAgICAgICAgLyogIGx1biBpZiBhcHBsaWNhYmxlICAgICAgICAqLworCWVudW0gZmNwX3RtX2NtbmQgICAgICAgIHRtX2NtbmQ7ICAgICAvKiAgdGFzayBtYW5hZ2VtZW50IGNvbW1hbmQgICovCisJdTE2ICAgICAgICAgICAgIHRza190YWc7ICAgICAgICAvKiAgRldJIElPIHRhZyAgICAgICAgICAgICAgICovCisJdTggICAgICAgICAgICAgIHRzZWNzOyAgICAgICAgICAvKiAgdGltZW91dCBpbiBzZWNvbmRzICAgICAgICovCisJc3RydWN0IGJmYV9yZXFxX3dhaXRfcyAgcmVxcV93YWl0OyAgIC8qICB0byB3YWl0IGZvciByb29tIGluIHJlcXEgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAgICAgICBpb19xOyAgICAvKiAgcXVldWUgb2YgYWZmZWN0ZWQgSU9zICAgICovCisJc3RydWN0IGJmYV93Y19zICAgICAgICAgICAgIHdjOyAgICAgIC8qICB3YWl0aW5nIGNvdW50ZXIgICAgICAgICAgKi8KKwlzdHJ1Y3QgYmZhX2NiX3FlX3MJaGNiX3FlOyAgICAgIC8qICBiZmEgY2FsbGJhY2sgcWVsZW0gICAgICAgKi8KKwllbnVtIGJmaV90c2tpbV9zdGF0dXMgICB0c2tfc3RhdHVzOyAgLyogIFRNIHN0YXR1cyAgICAgICAgICAgICAgICAqLworfTsKKworLyoqCisgKiBCRkEgaS10LW4gKGluaXRpYXRvciBtb2RlKQorICovCitzdHJ1Y3QgYmZhX2l0bmltX3MgeworCXN0cnVjdCBsaXN0X2hlYWQgICAgcWU7CQkvKiAgcXVldWUgZWxlbWVudCAgICAgICAgICAgICAgICovCisJYmZhX3NtX3QJICBzbTsJCS8qICBpLXQtbiBpbSBCRkEgc3RhdGUgbWFjaGluZSAgKi8KKwlzdHJ1Y3QgYmZhX3MgICAgICAqYmZhOwkJLyogIGJmYSBpbnN0YW5jZSAgICAgICAgICAgICAgICAqLworCXN0cnVjdCBiZmFfcnBvcnRfcyAqcnBvcnQ7CS8qICBiZmEgcnBvcnQgICAgICAgICAgICAgICAgICAgKi8KKwl2b2lkICAgICAgICAgICAqZGl0bjsJCS8qICBkcml2ZXIgaS10LW4gc3RydWN0dXJlICAgICAgKi8KKwlzdHJ1Y3QgYmZpX21oZHJfcyAgICAgIG1oZHI7CS8qICBwcmUtYnVpbHQgbWhkciAgICAgICAgICAgICAgKi8KKwl1OCAgICAgICAgIG1zZ19ubzsJCS8qICBpdG5pbS9ycG9ydCBmaXJtd2FyZSBoYW5kbGUgKi8KKwl1OCAgICAgICAgIHJlcXE7CQkvKiAgQ1EgZm9yIHJlcXVlc3RzICAgICAgICAgICAgICovCisJc3RydWN0IGJmYV9jYl9xZV9zICAgIGhjYl9xZTsJLyogIGJmYSBjYWxsYmFjayBxZWxlbSAgICAgICAgICAqLworCXN0cnVjdCBsaXN0X2hlYWQgcGVuZGluZ19xOwkvKiAgcXVldWUgb2YgcGVuZGluZyBJTyByZXF1ZXN0cyovCisJc3RydWN0IGxpc3RfaGVhZCBpb19xOwkJLyogIHF1ZXVlIG9mIGFjdGl2ZSBJTyByZXF1ZXN0cyAqLworCXN0cnVjdCBsaXN0X2hlYWQgaW9fY2xlYW51cF9xOwkvKiAgSU8gYmVpbmcgY2xlYW5lZCB1cCAgICAgICAgICovCisJc3RydWN0IGxpc3RfaGVhZCB0c2tfcTsJCS8qICBxdWV1ZSBvZiBhY3RpdmUgVE0gY29tbWFuZHMgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkICBkZWxheV9jb21wX3E7LyogIHF1ZXVlIG9mIGZhaWxlZCBpbmZsaWdodCBjbWRzICovCisJYmZhX2Jvb2xlYW5fdCAgIHNlcV9yZWM7CS8qICBTUUVSIHN1cHBvcnRlZCAgICAgICAgICAgICAgKi8KKwliZmFfYm9vbGVhbl90ICAgaXNfb25saW5lOwkvKiAgaXRuaW0gaXMgT05MSU5FIGZvciBJTyAgICAgICovCisJYmZhX2Jvb2xlYW5fdCAgIGlvdG92X2FjdGl2ZTsJLyogIElPIFRPViB0aW1lciBpcyBhY3RpdmUJICovCisJc3RydWN0IGJmYV93Y19zICAgICAgICB3YzsJLyogIHdhaXRpbmcgY291bnRlciAgICAgICAgICAgICAqLworCXN0cnVjdCBiZmFfdGltZXJfcyB0aW1lcjsJLyogIHBlbmRpbmcgSU8gVE9WCQkgKi8KKwlzdHJ1Y3QgYmZhX3JlcXFfd2FpdF9zIHJlcXFfd2FpdDsgLyogIHRvIHdhaXQgZm9yIHJvb20gaW4gcmVxcSAqLworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltOwkvKiAgZmNwaW0gbW9kdWxlICAgICAgICAgICAgICAgICovCisJc3RydWN0IGJmYV9pdG5pbV9oYWxfc3RhdHNfcwlzdGF0czsKK307CisKKyNkZWZpbmUgYmZhX2l0bmltX2lzX29ubGluZShfaXRuaW0pIChfaXRuaW0pLT5pc19vbmxpbmUKKyNkZWZpbmUgQkZBX0ZDUElNX01PRChfaGFsKSAoJihfaGFsKS0+bW9kdWxlcy5mY3BpbV9tb2QpCisjZGVmaW5lIEJGQV9JT0lNX0ZST01fVEFHKF9mY3BpbSwgX2lvdGFnKQlcCisJKCZmY3BpbS0+aW9pbV9hcnJbX2lvdGFnXSkKKyNkZWZpbmUgQkZBX1RTS0lNX0ZST01fVEFHKF9mY3BpbSwgX3RtdGFnKSAgICAgICAgICAgICAgICAgIFwKKyAgICAoJmZjcGltLT50c2tpbV9hcnJbX3RtdGFnICYgKGZjcGltLT5udW1fdHNraW1fcmVxcyAtIDEpXSkKKworLyoKKyAqIGZ1bmN0aW9uIHByb3RvdHlwZXMKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9pb2ltX2F0dGFjaChzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSwKKwkJCQkgICAgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1pbmZvKTsKK3ZvaWQgICAgICAgICAgICBiZmFfaW9pbV9kZXRhY2goc3RydWN0IGJmYV9mY3BpbV9tb2RfcyAqZmNwaW0pOwordm9pZCAgICAgICAgICAgIGJmYV9pb2ltX2lzcihzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmaV9tc2dfcyAqbXNnKTsKK3ZvaWQgICAgICAgICAgICBiZmFfaW9pbV9nb29kX2NvbXBfaXNyKHN0cnVjdCBiZmFfcyAqYmZhLAorCQkJCQlzdHJ1Y3QgYmZpX21zZ19zICptc2cpOwordm9pZCAgICAgICAgICAgIGJmYV9pb2ltX2NsZWFudXAoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0pOwordm9pZCAgICAgICAgICAgIGJmYV9pb2ltX2NsZWFudXBfdG0oc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sCisJCQkJCXN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0pOwordm9pZCAgICAgICAgICAgIGJmYV9pb2ltX2lvY2Rpc2FibGUoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0pOwordm9pZCAgICAgICAgICAgIGJmYV9pb2ltX3RvdihzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSk7CisKK3ZvaWQgICAgICAgICAgICBiZmFfdHNraW1fYXR0YWNoKHN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltLAorCQkJCSAgICAgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1pbmZvKTsKK3ZvaWQgICAgICAgICAgICBiZmFfdHNraW1fZGV0YWNoKHN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltKTsKK3ZvaWQgICAgICAgICAgICBiZmFfdHNraW1faXNyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZpX21zZ19zICptc2cpOwordm9pZCAgICAgICAgICAgIGJmYV90c2tpbV9pb2RvbmUoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSk7Cit2b2lkICAgICAgICAgICAgYmZhX3Rza2ltX2lvY2Rpc2FibGUoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSk7Cit2b2lkICAgICAgICAgICAgYmZhX3Rza2ltX2NsZWFudXAoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSk7CisKK3ZvaWQgICAgICAgICAgICBiZmFfaXRuaW1fbWVtaW5mbyhzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsIHUzMiAqa21fbGVuLAorCQkJCSAgICAgIHUzMiAqZG1fbGVuKTsKK3ZvaWQgICAgICAgICAgICBiZmFfaXRuaW1fYXR0YWNoKHN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltLAorCQkJCSAgICAgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1pbmZvKTsKK3ZvaWQgICAgICAgICAgICBiZmFfaXRuaW1fZGV0YWNoKHN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltKTsKK3ZvaWQgICAgICAgICAgICBiZmFfaXRuaW1faW9jZGlzYWJsZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltKTsKK3ZvaWQgICAgICAgICAgICBiZmFfaXRuaW1faXNyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZpX21zZ19zICptc2cpOwordm9pZCAgICAgICAgICAgIGJmYV9pdG5pbV9pb2RvbmUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSk7Cit2b2lkICAgICAgICAgICAgYmZhX2l0bmltX3Rza2RvbmUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSk7CitiZmFfYm9vbGVhbl90ICAgYmZhX2l0bmltX2hvbGRfaW8oc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSk7CisKKyNlbmRpZiAvKiBfX0JGQV9GQ1BJTV9QUklWX0hfXyAqLworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3BvcnQuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjcG9ydC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjk5MjQzNTkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3BvcnQuYwpAQCAtMCwwICsxLDE2NzEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX3Bwb3J0Lmg+CisjaW5jbHVkZSA8Y3MvYmZhX2RlYnVnLmg+CisjaW5jbHVkZSA8YWVuL2JmYV9hZW4uaD4KKyNpbmNsdWRlIDxjcy9iZmFfcGxvZy5oPgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuX3BvcnQuaD4KKworQkZBX1RSQ19GSUxFKEhBTCwgUFBPUlQpOworQkZBX01PRFVMRShwcG9ydCk7CisKKyNkZWZpbmUgYmZhX3Bwb3J0X2NhbGxiYWNrKF9fcHBvcnQsIF9fZXZlbnQpIGRvIHsJCQlcCisJaWYgKChfX3Bwb3J0KS0+YmZhLT5mY3MpIHsgICAgICBcCisJCShfX3Bwb3J0KS0+ZXZlbnRfY2JmbigoX19wcG9ydCktPmV2ZW50X2NiYXJnLCAoX19ldmVudCkpOyAgICAgIFwKKwl9IGVsc2UgewkJCQkJCQlcCisJCShfX3Bwb3J0KS0+aGNiX2V2ZW50ID0gKF9fZXZlbnQpOyAgICAgIFwKKwkJYmZhX2NiX3F1ZXVlKChfX3Bwb3J0KS0+YmZhLCAmKF9fcHBvcnQpLT5oY2JfcWUsCVwKKwkJX19iZmFfY2JfcG9ydF9ldmVudCwgKF9fcHBvcnQpKTsgICAgICBcCisJfQkJCQkJCQkJXAorfSB3aGlsZSAoMCkKKworLyoKKyAqIFRoZSBwb3J0IGlzIGNvbnNpZGVyZWQgZGlzYWJsZWQgaWYgY29ycmVzcG9uZGluZyBwaHlzaWNhbCBwb3J0IG9yIElPQyBhcmUKKyAqIGRpc2FibGVkIGV4cGxpY2l0bHkKKyAqLworI2RlZmluZSBCRkFfUE9SVF9JU19ESVNBQkxFRChiZmEpIFwKKwkoKGJmYV9wcG9ydF9pc19kaXNhYmxlZChiZmEpID09IEJGQV9UUlVFKSB8fCBcCisJKGJmYV9pb2NfaXNfZGlzYWJsZWQoJmJmYS0+aW9jKSA9PSBCRkFfVFJVRSkpCisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgYmZhX2Jvb2xlYW5fdCBiZmFfcHBvcnRfc2VuZF9lbmFibGUoc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0KTsKK3N0YXRpYyBiZmFfYm9vbGVhbl90IGJmYV9wcG9ydF9zZW5kX2Rpc2FibGUoc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfcHBvcnRfdXBkYXRlX2xpbmtpbmZvKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9wcG9ydF9yZXNldF9saW5raW5mbyhzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfcHBvcnRfc2V0X3d3bnMoc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBfX2JmYV9jYl9wb3J0X2V2ZW50KHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKK3N0YXRpYyB2b2lkICAgICBfX2JmYV9jYl9wb3J0X3N0YXRzKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKK3N0YXRpYyB2b2lkICAgICBfX2JmYV9jYl9wb3J0X3N0YXRzX2Nscih2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3BvcnRfc3RhdHNfdGltZW91dCh2b2lkICpjYmFyZyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3BvcnRfc3RhdHNfY2xyX3RpbWVvdXQodm9pZCAqY2JhcmcpOworCisvKioKKyAqICBiZmFfcHBvcnRfcHJpdmF0ZQorICovCisKKy8qKgorICogQkZBIHBvcnQgc3RhdGUgbWFjaGluZSBldmVudHMKKyAqLworZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgeworCUJGQV9QUE9SVF9TTV9TVEFSVCA9IDEsCS8qICBzdGFydCBwb3J0IHN0YXRlIG1hY2hpbmUgKi8KKwlCRkFfUFBPUlRfU01fU1RPUCA9IDIsCS8qICBzdG9wIHBvcnQgc3RhdGUgbWFjaGluZSAqLworCUJGQV9QUE9SVF9TTV9FTkFCTEUgPSAzLAkvKiAgZW5hYmxlIHBvcnQgKi8KKwlCRkFfUFBPUlRfU01fRElTQUJMRSA9IDQsCS8qICBkaXNhYmxlIHBvcnQgc3RhdGUgbWFjaGluZSAqLworCUJGQV9QUE9SVF9TTV9GV1JTUCA9IDUsCS8qICBmaXJtd2FyZSBlbmFibGUvZGlzYWJsZSByc3AgKi8KKwlCRkFfUFBPUlRfU01fTElOS1VQID0gNiwJLyogIGZpcm13YXJlIGxpbmt1cCBldmVudCAqLworCUJGQV9QUE9SVF9TTV9MSU5LRE9XTiA9IDcsCS8qICBmaXJtd2FyZSBsaW5rdXAgZG93biAqLworCUJGQV9QUE9SVF9TTV9RUkVTVU1FID0gOCwJLyogIENRIHNwYWNlIGF2YWlsYWJsZSAqLworCUJGQV9QUE9SVF9TTV9IV0ZBSUwgPSA5LAkvKiAgSU9DIGgvdyBmYWlsdXJlICovCit9OworCitzdGF0aWMgdm9pZCAgICAgYmZhX3Bwb3J0X3NtX3VuaW5pdChzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0LAorCQkJCSAgICBlbnVtIGJmYV9wcG9ydF9zbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3Bwb3J0X3NtX2VuYWJsaW5nX3F3YWl0KHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsCisJCQkJCSAgICBlbnVtIGJmYV9wcG9ydF9zbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3Bwb3J0X3NtX2VuYWJsaW5nKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsCisJCQkJICAgICAgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9wcG9ydF9zbV9saW5rZG93bihzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0LAorCQkJCSAgICAgIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfcHBvcnRfc21fbGlua3VwKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsCisJCQkJICAgIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfcHBvcnRfc21fZGlzYWJsaW5nKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsCisJCQkJICAgICAgIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfcHBvcnRfc21fZGlzYWJsaW5nX3F3YWl0KHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsCisJCQkJCSAgICAgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9wcG9ydF9zbV9kaXNhYmxlZChzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0LAorCQkJCSAgICAgIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfcHBvcnRfc21fc3RvcHBlZChzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0LAorCQkJCSAgICAgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9wcG9ydF9zbV9pb2Nkb3duKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsCisJCQkJICAgICBlbnVtIGJmYV9wcG9ydF9zbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3Bwb3J0X3NtX2lvY2ZhaWwoc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCwKKwkJCQkgICAgIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KTsKKworc3RhdGljIHN0cnVjdCBiZmFfc21fdGFibGVfcyBoYWxfcHBvcnRfc21fdGFibGVbXSA9IHsKKwl7QkZBX1NNKGJmYV9wcG9ydF9zbV91bmluaXQpLCBCRkFfUFBPUlRfU1RfVU5JTklUfSwKKwl7QkZBX1NNKGJmYV9wcG9ydF9zbV9lbmFibGluZ19xd2FpdCksIEJGQV9QUE9SVF9TVF9FTkFCTElOR19RV0FJVH0sCisJe0JGQV9TTShiZmFfcHBvcnRfc21fZW5hYmxpbmcpLCBCRkFfUFBPUlRfU1RfRU5BQkxJTkd9LAorCXtCRkFfU00oYmZhX3Bwb3J0X3NtX2xpbmtkb3duKSwgQkZBX1BQT1JUX1NUX0xJTktET1dOfSwKKwl7QkZBX1NNKGJmYV9wcG9ydF9zbV9saW5rdXApLCBCRkFfUFBPUlRfU1RfTElOS1VQfSwKKwl7QkZBX1NNKGJmYV9wcG9ydF9zbV9kaXNhYmxpbmdfcXdhaXQpLAorCSBCRkFfUFBPUlRfU1RfRElTQUJMSU5HX1FXQUlUfSwKKwl7QkZBX1NNKGJmYV9wcG9ydF9zbV9kaXNhYmxpbmcpLCBCRkFfUFBPUlRfU1RfRElTQUJMSU5HfSwKKwl7QkZBX1NNKGJmYV9wcG9ydF9zbV9kaXNhYmxlZCksIEJGQV9QUE9SVF9TVF9ESVNBQkxFRH0sCisJe0JGQV9TTShiZmFfcHBvcnRfc21fc3RvcHBlZCksIEJGQV9QUE9SVF9TVF9TVE9QUEVEfSwKKwl7QkZBX1NNKGJmYV9wcG9ydF9zbV9pb2Nkb3duKSwgQkZBX1BQT1JUX1NUX0lPQ0RPV059LAorCXtCRkFfU00oYmZhX3Bwb3J0X3NtX2lvY2ZhaWwpLCBCRkFfUFBPUlRfU1RfSU9DRE9XTn0sCit9OworCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X2Flbl9wb3N0KHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsIGVudW0gYmZhX3BvcnRfYWVuX2V2ZW50IGV2ZW50KQoreworCXVuaW9uIGJmYV9hZW5fZGF0YV91IGFlbl9kYXRhOworCXN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtb2QgPSBwcG9ydC0+YmZhLT5sb2dtOworCXd3bl90ICAgICAgICAgICBwd3duID0gcHBvcnQtPnB3d247CisJY2hhciAgICAgICAgICAgIHB3d25fcHRyW0JGQV9TVFJJTkdfMzJdOworCXN0cnVjdCBiZmFfaW9jX2F0dHJfcyBpb2NfYXR0cjsKKworCXd3bjJzdHIocHd3bl9wdHIsIHB3d24pOworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9QT1JUX0FFTl9PTkxJTkU6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX1BPUlRfT05MSU5FLCBwd3duX3B0cik7CisJCWJyZWFrOworCWNhc2UgQkZBX1BPUlRfQUVOX09GRkxJTkU6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX1BPUlRfT0ZGTElORSwgcHd3bl9wdHIpOworCQlicmVhazsKKwljYXNlIEJGQV9QT1JUX0FFTl9FTkFCTEU6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX1BPUlRfRU5BQkxFLCBwd3duX3B0cik7CisJCWJyZWFrOworCWNhc2UgQkZBX1BPUlRfQUVOX0RJU0FCTEU6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX1BPUlRfRElTQUJMRSwgcHd3bl9wdHIpOworCQlicmVhazsKKwljYXNlIEJGQV9QT1JUX0FFTl9ESVNDT05ORUNUOgorCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9QT1JUX0RJU0NPTk5FQ1QsIHB3d25fcHRyKTsKKwkJYnJlYWs7CisJY2FzZSBCRkFfUE9SVF9BRU5fUU9TX05FRzoKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fUE9SVF9RT1NfTkVHLCBwd3duX3B0cik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKworCWJmYV9pb2NfZ2V0X2F0dHIoJnBwb3J0LT5iZmEtPmlvYywgJmlvY19hdHRyKTsKKwlhZW5fZGF0YS5wb3J0LmlvY190eXBlID0gaW9jX2F0dHIuaW9jX3R5cGU7CisJYWVuX2RhdGEucG9ydC5wd3duID0gcHd3bjsKK30KKworc3RhdGljIHZvaWQKK2JmYV9wcG9ydF9zbV91bmluaXQoc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCwgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhwcG9ydC0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUFBPUlRfU01fU1RBUlQ6CisJCS8qKgorCQkgKiBTdGFydCBldmVudCBhZnRlciBJT0MgaXMgY29uZmlndXJlZCBhbmQgQkZBIGlzIHN0YXJ0ZWQuCisJCSAqLworCQlpZiAoYmZhX3Bwb3J0X3NlbmRfZW5hYmxlKHBwb3J0KSkKKwkJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9lbmFibGluZyk7CisJCWVsc2UKKwkJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9lbmFibGluZ19xd2FpdCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRU5BQkxFOgorCQkvKioKKwkJICogUG9ydCBpcyBwZXJzaXN0ZW50bHkgY29uZmlndXJlZCB0byBiZSBpbiBlbmFibGVkIHN0YXRlLiBEbworCQkgKiBub3QgY2hhbmdlIHN0YXRlLiBQb3J0IGVuYWJsaW5nIGlzIGRvbmUgd2hlbiBTVEFSVCBldmVudCBpcworCQkgKiByZWNlaXZlZC4KKwkJICovCisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRElTQUJMRToKKwkJLyoqCisJCSAqIElmIGEgcG9ydCBpcyBwZXJzaXN0ZW50bHkgY29uZmlndXJlZCB0byBiZSBkaXNhYmxlZCwgdGhlCisJCSAqIGZpcnN0IGV2ZW50IHdpbGwgYSBwb3J0IGRpc2FibGUgcmVxdWVzdC4KKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9kaXNhYmxlZCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21faW9jZG93bik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KHBwb3J0LT5iZmEsIGV2ZW50KTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcHBvcnRfc21fZW5hYmxpbmdfcXdhaXQoc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCwKKwkJCSAgICBlbnVtIGJmYV9wcG9ydF9zbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHBwb3J0LT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9QUE9SVF9TTV9RUkVTVU1FOgorCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fZW5hYmxpbmcpOworCQliZmFfcHBvcnRfc2VuZF9lbmFibGUocHBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX1NUT1A6CisJCWJmYV9yZXFxX3djYW5jZWwoJnBwb3J0LT5yZXFxX3dhaXQpOworCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fc3RvcHBlZCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRU5BQkxFOgorCQkvKioKKwkJICogQWxyZWFkeSBlbmFibGUgaXMgaW4gcHJvZ3Jlc3MuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0RJU0FCTEU6CisJCS8qKgorCQkgKiBKdXN0IHNlbmQgZGlzYWJsZSByZXF1ZXN0IHRvIGZpcm13YXJlIHdoZW4gcm9vbSBiZWNvbWVzCisJCSAqIGF2YWlsYWJsZSBpbiByZXF1ZXN0IHF1ZXVlLgorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2Rpc2FibGVkKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmcHBvcnQtPnJlcXFfd2FpdCk7CisJCWJmYV9wbG9nX3N0cihwcG9ydC0+YmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwKKwkJCSAgICAgQkZBX1BMX0VJRF9QT1JUX0RJU0FCTEUsIDAsICJQb3J0IERpc2FibGUiKTsKKwkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fRElTQUJMRSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fTElOS1VQOgorCWNhc2UgQkZBX1BQT1JUX1NNX0xJTktET1dOOgorCQkvKioKKwkJICogUG9zc2libGUgdG8gZ2V0IGxpbmsgZXZlbnRzIHdoZW4gZG9pbmcgYmFjay10by1iYWNrCisJCSAqIGVuYWJsZS9kaXNhYmxlcy4KKwkJICovCisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fSFdGQUlMOgorCQliZmFfcmVxcV93Y2FuY2VsKCZwcG9ydC0+cmVxcV93YWl0KTsKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2lvY2Rvd24pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChwcG9ydC0+YmZhLCBldmVudCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3NtX2VuYWJsaW5nKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocHBvcnQtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1BQT1JUX1NNX0ZXUlNQOgorCWNhc2UgQkZBX1BQT1JUX1NNX0xJTktET1dOOgorCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fbGlua2Rvd24pOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0xJTktVUDoKKwkJYmZhX3Bwb3J0X3VwZGF0ZV9saW5raW5mbyhwcG9ydCk7CisJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9saW5rdXApOworCisJCWJmYV9hc3NlcnQocHBvcnQtPmV2ZW50X2NiZm4pOworCQliZmFfcHBvcnRfY2FsbGJhY2socHBvcnQsIEJGQV9QUE9SVF9MSU5LVVApOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0VOQUJMRToKKwkJLyoqCisJCSAqIEFscmVhZHkgYmVpbmcgZW5hYmxlZC4KKwkJICovCisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRElTQUJMRToKKwkJaWYgKGJmYV9wcG9ydF9zZW5kX2Rpc2FibGUocHBvcnQpKQorCQkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2Rpc2FibGluZyk7CisJCWVsc2UKKwkJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9kaXNhYmxpbmdfcXdhaXQpOworCisJCWJmYV9wbG9nX3N0cihwcG9ydC0+YmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwKKwkJCSAgICAgQkZBX1BMX0VJRF9QT1JUX0RJU0FCTEUsIDAsICJQb3J0IERpc2FibGUiKTsKKwkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fRElTQUJMRSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fU1RPUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX3N0b3BwZWQpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2lvY2Rvd24pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChwcG9ydC0+YmZhLCBldmVudCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3NtX2xpbmtkb3duKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocHBvcnQtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1BQT1JUX1NNX0xJTktVUDoKKwkJYmZhX3Bwb3J0X3VwZGF0ZV9saW5raW5mbyhwcG9ydCk7CisJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9saW5rdXApOworCQliZmFfYXNzZXJ0KHBwb3J0LT5ldmVudF9jYmZuKTsKKwkJYmZhX3Bsb2dfc3RyKHBwb3J0LT5iZmEtPnBsb2csIEJGQV9QTF9NSURfSEFMLAorCQkJICAgICBCRkFfUExfRUlEX1BPUlRfU1RfQ0hBTkdFLCAwLCAiUG9ydCBMaW5rdXAiKTsKKwkJYmZhX3Bwb3J0X2NhbGxiYWNrKHBwb3J0LCBCRkFfUFBPUlRfTElOS1VQKTsKKwkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fT05MSU5FKTsKKwkJLyoqCisJCSAqIElmIFFvUyBpcyBlbmFibGVkIGFuZCBpdCBpcyBub3Qgb25saW5lLAorCQkgKiBTZW5kIGEgc2VwYXJhdGUgZXZlbnQuCisJCSAqLworCQlpZiAoKHBwb3J0LT5jZmcucW9zX2VuYWJsZWQpCisJCSAgICAmJiAoYmZhX29zX250b2hsKHBwb3J0LT5xb3NfYXR0ci5zdGF0ZSkgIT0gQkZBX1FPU19PTkxJTkUpKQorCQkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fUU9TX05FRyk7CisKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9QUE9SVF9TTV9MSU5LRE9XTjoKKwkJLyoqCisJCSAqIFBvc3NpYmxlIHRvIGdldCBsaW5rIGRvd24gZXZlbnQuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0VOQUJMRToKKwkJLyoqCisJCSAqIEFscmVhZHkgZW5hYmxlZC4KKwkJICovCisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRElTQUJMRToKKwkJaWYgKGJmYV9wcG9ydF9zZW5kX2Rpc2FibGUocHBvcnQpKQorCQkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2Rpc2FibGluZyk7CisJCWVsc2UKKwkJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9kaXNhYmxpbmdfcXdhaXQpOworCisJCWJmYV9wbG9nX3N0cihwcG9ydC0+YmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwKKwkJCSAgICAgQkZBX1BMX0VJRF9QT1JUX0RJU0FCTEUsIDAsICJQb3J0IERpc2FibGUiKTsKKwkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fRElTQUJMRSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fU1RPUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX3N0b3BwZWQpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2lvY2Rvd24pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChwcG9ydC0+YmZhLCBldmVudCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3NtX2xpbmt1cChzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0LCBlbnVtIGJmYV9wcG9ydF9zbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHBwb3J0LT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9QUE9SVF9TTV9FTkFCTEU6CisJCS8qKgorCQkgKiBBbHJlYWR5IGVuYWJsZWQuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0RJU0FCTEU6CisJCWlmIChiZmFfcHBvcnRfc2VuZF9kaXNhYmxlKHBwb3J0KSkKKwkJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9kaXNhYmxpbmcpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fZGlzYWJsaW5nX3F3YWl0KTsKKworCQliZmFfcHBvcnRfcmVzZXRfbGlua2luZm8ocHBvcnQpOworCQliZmFfcHBvcnRfY2FsbGJhY2socHBvcnQsIEJGQV9QUE9SVF9MSU5LRE9XTik7CisJCWJmYV9wbG9nX3N0cihwcG9ydC0+YmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwKKwkJCSAgICAgQkZBX1BMX0VJRF9QT1JUX0RJU0FCTEUsIDAsICJQb3J0IERpc2FibGUiKTsKKwkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fT0ZGTElORSk7CisJCWJmYV9wcG9ydF9hZW5fcG9zdChwcG9ydCwgQkZBX1BPUlRfQUVOX0RJU0FCTEUpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0xJTktET1dOOgorCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fbGlua2Rvd24pOworCQliZmFfcHBvcnRfcmVzZXRfbGlua2luZm8ocHBvcnQpOworCQliZmFfcHBvcnRfY2FsbGJhY2socHBvcnQsIEJGQV9QUE9SVF9MSU5LRE9XTik7CisJCWJmYV9wbG9nX3N0cihwcG9ydC0+YmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwKKwkJCSAgICAgQkZBX1BMX0VJRF9QT1JUX1NUX0NIQU5HRSwgMCwgIlBvcnQgTGlua2Rvd24iKTsKKwkJaWYgKEJGQV9QT1JUX0lTX0RJU0FCTEVEKHBwb3J0LT5iZmEpKSB7CisJCQliZmFfcHBvcnRfYWVuX3Bvc3QocHBvcnQsIEJGQV9QT1JUX0FFTl9PRkZMSU5FKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV9wcG9ydF9hZW5fcG9zdChwcG9ydCwgQkZBX1BPUlRfQUVOX0RJU0NPTk5FQ1QpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fU1RPUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX3N0b3BwZWQpOworCQliZmFfcHBvcnRfcmVzZXRfbGlua2luZm8ocHBvcnQpOworCQlpZiAoQkZBX1BPUlRfSVNfRElTQUJMRUQocHBvcnQtPmJmYSkpIHsKKwkJCWJmYV9wcG9ydF9hZW5fcG9zdChwcG9ydCwgQkZBX1BPUlRfQUVOX09GRkxJTkUpOworCQl9IGVsc2UgeworCQkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fRElTQ09OTkVDVCk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIEJGQV9QUE9SVF9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9pb2Nkb3duKTsKKwkJYmZhX3Bwb3J0X3Jlc2V0X2xpbmtpbmZvKHBwb3J0KTsKKwkJYmZhX3Bwb3J0X2NhbGxiYWNrKHBwb3J0LCBCRkFfUFBPUlRfTElOS0RPV04pOworCQlpZiAoQkZBX1BPUlRfSVNfRElTQUJMRUQocHBvcnQtPmJmYSkpIHsKKwkJCWJmYV9wcG9ydF9hZW5fcG9zdChwcG9ydCwgQkZBX1BPUlRfQUVOX09GRkxJTkUpOworCQl9IGVsc2UgeworCQkJYmZhX3Bwb3J0X2Flbl9wb3N0KHBwb3J0LCBCRkFfUE9SVF9BRU5fRElTQ09OTkVDVCk7CisJCX0KKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQocHBvcnQtPmJmYSwgZXZlbnQpOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9wcG9ydF9zbV9kaXNhYmxpbmdfcXdhaXQoc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCwKKwkJCSAgICAgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhwcG9ydC0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUFBPUlRfU01fUVJFU1VNRToKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2Rpc2FibGluZyk7CisJCWJmYV9wcG9ydF9zZW5kX2Rpc2FibGUocHBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX1NUT1A6CisJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9zdG9wcGVkKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmcHBvcnQtPnJlcXFfd2FpdCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRElTQUJMRToKKwkJLyoqCisJCSAqIEFscmVhZHkgYmVpbmcgZGlzYWJsZWQuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0xJTktVUDoKKwljYXNlIEJGQV9QUE9SVF9TTV9MSU5LRE9XTjoKKwkJLyoqCisJCSAqIFBvc3NpYmxlIHRvIGdldCBsaW5rIGV2ZW50cyB3aGVuIGRvaW5nIGJhY2stdG8tYmFjaworCQkgKiBlbmFibGUvZGlzYWJsZXMuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2lvY2ZhaWwpOworCQliZmFfcmVxcV93Y2FuY2VsKCZwcG9ydC0+cmVxcV93YWl0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQocHBvcnQtPmJmYSwgZXZlbnQpOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9wcG9ydF9zbV9kaXNhYmxpbmcoc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCwgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhwcG9ydC0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUFBPUlRfU01fRldSU1A6CisJCWJmYV9zbV9zZXRfc3RhdGUocHBvcnQsIGJmYV9wcG9ydF9zbV9kaXNhYmxlZCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRElTQUJMRToKKwkJLyoqCisJCSAqIEFscmVhZHkgYmVpbmcgZGlzYWJsZWQuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0VOQUJMRToKKwkJaWYgKGJmYV9wcG9ydF9zZW5kX2VuYWJsZShwcG9ydCkpCisJCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fZW5hYmxpbmcpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fZW5hYmxpbmdfcXdhaXQpOworCisJCWJmYV9wbG9nX3N0cihwcG9ydC0+YmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwKKwkJCSAgICAgQkZBX1BMX0VJRF9QT1JUX0VOQUJMRSwgMCwgIlBvcnQgRW5hYmxlIik7CisJCWJmYV9wcG9ydF9hZW5fcG9zdChwcG9ydCwgQkZBX1BPUlRfQUVOX0VOQUJMRSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fU1RPUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX3N0b3BwZWQpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0xJTktVUDoKKwljYXNlIEJGQV9QUE9SVF9TTV9MSU5LRE9XTjoKKwkJLyoqCisJCSAqIFBvc3NpYmxlIHRvIGdldCBsaW5rIGV2ZW50cyB3aGVuIGRvaW5nIGJhY2stdG8tYmFjaworCQkgKiBlbmFibGUvZGlzYWJsZXMuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2lvY2ZhaWwpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChwcG9ydC0+YmZhLCBldmVudCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3NtX2Rpc2FibGVkKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocHBvcnQtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1BQT1JUX1NNX1NUQVJUOgorCQkvKioKKwkJICogSWdub3JlIHN0YXJ0IGV2ZW50IGZvciBhIHBvcnQgdGhhdCBpcyBkaXNhYmxlZC4KKwkJICovCisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fU1RPUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX3N0b3BwZWQpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0VOQUJMRToKKwkJaWYgKGJmYV9wcG9ydF9zZW5kX2VuYWJsZShwcG9ydCkpCisJCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fZW5hYmxpbmcpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fZW5hYmxpbmdfcXdhaXQpOworCisJCWJmYV9wbG9nX3N0cihwcG9ydC0+YmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwKKwkJCSAgICAgQkZBX1BMX0VJRF9QT1JUX0VOQUJMRSwgMCwgIlBvcnQgRW5hYmxlIik7CisJCWJmYV9wcG9ydF9hZW5fcG9zdChwcG9ydCwgQkZBX1BPUlRfQUVOX0VOQUJMRSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfU01fRElTQUJMRToKKwkJLyoqCisJCSAqIEFscmVhZHkgZGlzYWJsZWQuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2lvY2ZhaWwpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChwcG9ydC0+YmZhLCBldmVudCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3NtX3N0b3BwZWQoc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCwgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhwcG9ydC0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUFBPUlRfU01fU1RBUlQ6CisJCWlmIChiZmFfcHBvcnRfc2VuZF9lbmFibGUocHBvcnQpKQorCQkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2VuYWJsaW5nKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2VuYWJsaW5nX3F3YWl0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQkvKioKKwkJICogSWdub3JlIGFsbCBvdGhlciBldmVudHMuCisJCSAqLworCQk7CisJfQorfQorCisvKioKKyAqIFBvcnQgaXMgZW5hYmxlZC4gSU9DIGlzIGRvd24vZmFpbGVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3NtX2lvY2Rvd24oc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCwgZW51bSBiZmFfcHBvcnRfc21fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhwcG9ydC0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUFBPUlRfU01fU1RBUlQ6CisJCWlmIChiZmFfcHBvcnRfc2VuZF9lbmFibGUocHBvcnQpKQorCQkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2VuYWJsaW5nKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2VuYWJsaW5nX3F3YWl0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQkvKioKKwkJICogSWdub3JlIGFsbCBldmVudHMuCisJCSAqLworCQk7CisJfQorfQorCisvKioKKyAqIFBvcnQgaXMgZGlzYWJsZWQuIElPQyBpcyBkb3duL2ZhaWxlZC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9wcG9ydF9zbV9pb2NmYWlsKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsIGVudW0gYmZhX3Bwb3J0X3NtX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocHBvcnQtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1BQT1JUX1NNX1NUQVJUOgorCQliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fZGlzYWJsZWQpOworCQlicmVhazsKKworCWNhc2UgQkZBX1BQT1JUX1NNX0VOQUJMRToKKwkJYmZhX3NtX3NldF9zdGF0ZShwcG9ydCwgYmZhX3Bwb3J0X3NtX2lvY2Rvd24pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCS8qKgorCQkgKiBJZ25vcmUgYWxsIGV2ZW50cy4KKwkJICovCisJCTsKKwl9Cit9CisKKworCisvKioKKyAqICBiZmFfcHBvcnRfcHJpdmF0ZQorICovCisKK3N0YXRpYyB2b2lkCitfX2JmYV9jYl9wb3J0X2V2ZW50KHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBjYmFyZzsKKworCWlmIChjb21wbGV0ZSkKKwkJcHBvcnQtPmV2ZW50X2NiZm4ocHBvcnQtPmV2ZW50X2NiYXJnLCBwcG9ydC0+aGNiX2V2ZW50KTsKK30KKworI2RlZmluZSBQUE9SVF9TVEFUU19ETUFfU1ogKEJGQV9ST1VORFVQKHNpemVvZih1bmlvbiBiZmFfcHBvcnRfc3RhdHNfdSksIFwKKwkJCQkJCQlCRkFfQ0FDSEVMSU5FX1NaKSkKKworc3RhdGljIHZvaWQKK2JmYV9wcG9ydF9tZW1pbmZvKHN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmNmZywgdTMyICpuZG1fbGVuLAorCQkgIHUzMiAqZG1fbGVuKQoreworCSpkbV9sZW4gKz0gUFBPUlRfU1RBVFNfRE1BX1NaOworfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3FyZXN1bWUodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0ID0gY2Jhcmc7CisKKwliZmFfc21fc2VuZF9ldmVudChwb3J0LCBCRkFfUFBPUlRfU01fUVJFU1VNRSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcHBvcnRfbWVtX2NsYWltKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQsIHN0cnVjdCBiZmFfbWVtaW5mb19zICptZW1pbmZvKQoreworCXU4ICAgICAgICAqZG1fa3ZhOworCXU2NCAgICAgICAgZG1fcGE7CisKKwlkbV9rdmEgPSBiZmFfbWVtaW5mb19kbWFfdmlydChtZW1pbmZvKTsKKwlkbV9wYSA9IGJmYV9tZW1pbmZvX2RtYV9waHlzKG1lbWluZm8pOworCisJcHBvcnQtPnN0YXRzX2t2YSA9IGRtX2t2YTsKKwlwcG9ydC0+c3RhdHNfcGEgPSBkbV9wYTsKKwlwcG9ydC0+c3RhdHMgPSAodW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKilkbV9rdmE7CisKKwlkbV9rdmEgKz0gUFBPUlRfU1RBVFNfRE1BX1NaOworCWRtX3BhICs9IFBQT1JUX1NUQVRTX0RNQV9TWjsKKworCWJmYV9tZW1pbmZvX2RtYV92aXJ0KG1lbWluZm8pID0gZG1fa3ZhOworCWJmYV9tZW1pbmZvX2RtYV9waHlzKG1lbWluZm8pID0gZG1fcGE7Cit9CisKKy8qKgorICogTWVtb3J5IGluaXRpYWxpemF0aW9uLgorICovCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X2F0dGFjaChzdHJ1Y3QgYmZhX3MgKmJmYSwgdm9pZCAqYmZhZCwgc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLAorCQkgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1lbWluZm8sIHN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldikKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisJc3RydWN0IGJmYV9wcG9ydF9jZmdfcyAqcG9ydF9jZmcgPSAmcHBvcnQtPmNmZzsKKworCWJmYV9vc19tZW1zZXQocHBvcnQsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3Bwb3J0X3MpKTsKKwlwcG9ydC0+YmZhID0gYmZhOworCisJYmZhX3Bwb3J0X21lbV9jbGFpbShwcG9ydCwgbWVtaW5mbyk7CisKKwliZmFfc21fc2V0X3N0YXRlKHBwb3J0LCBiZmFfcHBvcnRfc21fdW5pbml0KTsKKworCS8qKgorCSAqIGluaXRpYWxpemUgYW5kIHNldCBkZWZhdWx0IGNvbmZpZ3VyYXRpb24KKwkgKi8KKwlwb3J0X2NmZy0+dG9wb2xvZ3kgPSBCRkFfUFBPUlRfVE9QT0xPR1lfUDJQOworCXBvcnRfY2ZnLT5zcGVlZCA9IEJGQV9QUE9SVF9TUEVFRF9BVVRPOworCXBvcnRfY2ZnLT50cnVua2VkID0gQkZBX0ZBTFNFOworCXBvcnRfY2ZnLT5tYXhmcnNpemUgPSAwOworCisJcG9ydF9jZmctPnRybF9kZWZfc3BlZWQgPSBCRkFfUFBPUlRfU1BFRURfMUdCUFM7CisKKwliZmFfcmVxcV93aW5pdCgmcHBvcnQtPnJlcXFfd2FpdCwgYmZhX3Bwb3J0X3FyZXN1bWUsIHBwb3J0KTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9wcG9ydF9pbml0ZG9uZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwkvKioKKwkgKiBJbml0aWFsaXplIHBvcnQgYXR0cmlidXRlcyBmcm9tIElPQyBoYXJkd2FyZSBkYXRhLgorCSAqLworCWJmYV9wcG9ydF9zZXRfd3ducyhwcG9ydCk7CisJaWYgKHBwb3J0LT5jZmcubWF4ZnJzaXplID09IDApCisJCXBwb3J0LT5jZmcubWF4ZnJzaXplID0gYmZhX2lvY19tYXhmcnNpemUoJmJmYS0+aW9jKTsKKwlwcG9ydC0+Y2ZnLnJ4X2JiY3JlZGl0ID0gYmZhX2lvY19yeF9iYmNyZWRpdCgmYmZhLT5pb2MpOworCXBwb3J0LT5zcGVlZF9zdXAgPSBiZmFfaW9jX3NwZWVkX3N1cCgmYmZhLT5pb2MpOworCisJYmZhX2Fzc2VydChwcG9ydC0+Y2ZnLm1heGZyc2l6ZSk7CisJYmZhX2Fzc2VydChwcG9ydC0+Y2ZnLnJ4X2JiY3JlZGl0KTsKKwliZmFfYXNzZXJ0KHBwb3J0LT5zcGVlZF9zdXApOworfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X2RldGFjaChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworLyoqCisgKiBDYWxsZWQgd2hlbiBJT0MgaXMgcmVhZHkuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcHBvcnRfc3RhcnQoc3RydWN0IGJmYV9zICpiZmEpCit7CisJYmZhX3NtX3NlbmRfZXZlbnQoQkZBX1BPUlRfTU9EKGJmYSksIEJGQV9QUE9SVF9TTV9TVEFSVCk7Cit9CisKKy8qKgorICogQ2FsbGVkIGJlZm9yZSBJT0MgaXMgc3RvcHBlZC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9wcG9ydF9zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWJmYV9zbV9zZW5kX2V2ZW50KEJGQV9QT1JUX01PRChiZmEpLCBCRkFfUFBPUlRfU01fU1RPUCk7Cit9CisKKy8qKgorICogQ2FsbGVkIHdoZW4gSU9DIGZhaWx1cmUgaXMgZGV0ZWN0ZWQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcHBvcnRfaW9jZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwliZmFfc21fc2VuZF9ldmVudChCRkFfUE9SVF9NT0QoYmZhKSwgQkZBX1BQT1JUX1NNX0hXRkFJTCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcHBvcnRfdXBkYXRlX2xpbmtpbmZvKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQpCit7CisJc3RydWN0IGJmaV9wcG9ydF9ldmVudF9zICpwZXZlbnQgPSBwcG9ydC0+ZXZlbnRfYXJnLmkyaG1zZy5ldmVudDsKKworCXBwb3J0LT5zcGVlZCA9IHBldmVudC0+bGlua19zdGF0ZS5zcGVlZDsKKwlwcG9ydC0+dG9wb2xvZ3kgPSBwZXZlbnQtPmxpbmtfc3RhdGUudG9wb2xvZ3k7CisKKwlpZiAocHBvcnQtPnRvcG9sb2d5ID09IEJGQV9QUE9SVF9UT1BPTE9HWV9MT09QKQorCQlwcG9ydC0+bXlhbHBhID0gcGV2ZW50LT5saW5rX3N0YXRlLnRsLmxvb3BfaW5mby5teWFscGE7CisKKwkvKgorCSAqIFFvUyBEZXRhaWxzCisJICovCisJYmZhX29zX2Fzc2lnbihwcG9ydC0+cW9zX2F0dHIsIHBldmVudC0+bGlua19zdGF0ZS5xb3NfYXR0cik7CisJYmZhX29zX2Fzc2lnbihwcG9ydC0+cW9zX3ZjX2F0dHIsIHBldmVudC0+bGlua19zdGF0ZS5xb3NfdmNfYXR0cik7CisKKwliZmFfdHJjKHBwb3J0LT5iZmEsIHBwb3J0LT5zcGVlZCk7CisJYmZhX3RyYyhwcG9ydC0+YmZhLCBwcG9ydC0+dG9wb2xvZ3kpOworfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3Jlc2V0X2xpbmtpbmZvKHN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQpCit7CisJcHBvcnQtPnNwZWVkID0gQkZBX1BQT1JUX1NQRUVEX1VOS05PV047CisJcHBvcnQtPnRvcG9sb2d5ID0gQkZBX1BQT1JUX1RPUE9MT0dZX05PTkU7Cit9CisKKy8qKgorICogU2VuZCBwb3J0IGVuYWJsZSBtZXNzYWdlIHRvIGZpcm13YXJlLgorICovCitzdGF0aWMgICAgICAgICAgYmZhX2Jvb2xlYW5fdAorYmZhX3Bwb3J0X3NlbmRfZW5hYmxlKHN0cnVjdCBiZmFfcHBvcnRfcyAqcG9ydCkKK3sKKwlzdHJ1Y3QgYmZpX3Bwb3J0X2VuYWJsZV9yZXFfcyAqbTsKKworCS8qKgorCSAqIEluY3JlbWVudCBtZXNzYWdlIHRhZyBiZWZvcmUgcXVldWUgY2hlY2ssIHNvIHRoYXQgcmVzcG9uc2VzIHRvIG9sZAorCSAqIHJlcXVlc3RzIGFyZSBkaXNjYXJkZWQuCisJICovCisJcG9ydC0+bXNndGFnKys7CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JUKTsKKwlpZiAoIW0pIHsKKwkJYmZhX3JlcXFfd2FpdChwb3J0LT5iZmEsIEJGQV9SRVFRX1BPUlQsICZwb3J0LT5yZXFxX3dhaXQpOworCQlyZXR1cm4gQkZBX0ZBTFNFOworCX0KKworCWJmaV9oMmlfc2V0KG0tPm1oLCBCRklfTUNfRkNfUE9SVCwgQkZJX1BQT1JUX0gySV9FTkFCTEVfUkVRLAorCQkgICAgYmZhX2xwdWlkKHBvcnQtPmJmYSkpOworCW0tPm53d24gPSBwb3J0LT5ud3duOworCW0tPnB3d24gPSBwb3J0LT5wd3duOworCW0tPnBvcnRfY2ZnID0gcG9ydC0+Y2ZnOworCW0tPm1zZ3RhZyA9IHBvcnQtPm1zZ3RhZzsKKwltLT5wb3J0X2NmZy5tYXhmcnNpemUgPSBiZmFfb3NfaHRvbnMocG9ydC0+Y2ZnLm1heGZyc2l6ZSk7CisJYmZhX2RtYV9iZV9hZGRyX3NldChtLT5zdGF0c19kbWFfYWRkciwgcG9ydC0+c3RhdHNfcGEpOworCWJmYV90cmMocG9ydC0+YmZhLCBtLT5zdGF0c19kbWFfYWRkci5hMzIuYWRkcl9sbyk7CisJYmZhX3RyYyhwb3J0LT5iZmEsIG0tPnN0YXRzX2RtYV9hZGRyLmEzMi5hZGRyX2hpKTsKKworCS8qKgorCSAqIHF1ZXVlIEkvTyBtZXNzYWdlIHRvIGZpcm13YXJlCisJICovCisJYmZhX3JlcXFfcHJvZHVjZShwb3J0LT5iZmEsIEJGQV9SRVFRX1BPUlQpOworCXJldHVybiBCRkFfVFJVRTsKK30KKworLyoqCisgKiBTZW5kIHBvcnQgZGlzYWJsZSBtZXNzYWdlIHRvIGZpcm13YXJlLgorICovCitzdGF0aWMgICAgICAgICAgYmZhX2Jvb2xlYW5fdAorYmZhX3Bwb3J0X3NlbmRfZGlzYWJsZShzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQpCit7CisJYmZpX3Bwb3J0X2Rpc2FibGVfcmVxX3QgKm07CisKKwkvKioKKwkgKiBJbmNyZW1lbnQgbWVzc2FnZSB0YWcgYmVmb3JlIHF1ZXVlIGNoZWNrLCBzbyB0aGF0IHJlc3BvbnNlcyB0byBvbGQKKwkgKiByZXF1ZXN0cyBhcmUgZGlzY2FyZGVkLgorCSAqLworCXBvcnQtPm1zZ3RhZysrOworCisJLyoqCisJICogY2hlY2sgZm9yIHJvb20gaW4gcXVldWUgdG8gc2VuZCByZXF1ZXN0IG5vdworCSAqLworCW0gPSBiZmFfcmVxcV9uZXh0KHBvcnQtPmJmYSwgQkZBX1JFUVFfUE9SVCk7CisJaWYgKCFtKSB7CisJCWJmYV9yZXFxX3dhaXQocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JULCAmcG9ydC0+cmVxcV93YWl0KTsKKwkJcmV0dXJuIEJGQV9GQUxTRTsKKwl9CisKKwliZmlfaDJpX3NldChtLT5taCwgQkZJX01DX0ZDX1BPUlQsIEJGSV9QUE9SVF9IMklfRElTQUJMRV9SRVEsCisJCSAgICBiZmFfbHB1aWQocG9ydC0+YmZhKSk7CisJbS0+bXNndGFnID0gcG9ydC0+bXNndGFnOworCisJLyoqCisJICogcXVldWUgSS9PIG1lc3NhZ2UgdG8gZmlybXdhcmUKKwkgKi8KKwliZmFfcmVxcV9wcm9kdWNlKHBvcnQtPmJmYSwgQkZBX1JFUVFfUE9SVCk7CisKKwlyZXR1cm4gQkZBX1RSVUU7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcHBvcnRfc2V0X3d3bnMoc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0KQoreworCXBvcnQtPnB3d24gPSBiZmFfaW9jX2dldF9wd3duKCZwb3J0LT5iZmEtPmlvYyk7CisJcG9ydC0+bnd3biA9IGJmYV9pb2NfZ2V0X253d24oJnBvcnQtPmJmYS0+aW9jKTsKKworCWJmYV90cmMocG9ydC0+YmZhLCBwb3J0LT5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmJmYSwgcG9ydC0+bnd3bik7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcG9ydF9zZW5kX3R4Y3JlZGl0KHZvaWQgKnBvcnRfY2JhcmcpCit7CisKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSBwb3J0X2NiYXJnOworCXN0cnVjdCBiZmlfcHBvcnRfc2V0X3N2Y19wYXJhbXNfcmVxX3MgKm07CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JUKTsKKwlpZiAoIW0pIHsKKwkJYmZhX3RyYyhwb3J0LT5iZmEsIHBvcnQtPmNmZy50eF9iYmNyZWRpdCk7CisJCXJldHVybjsKKwl9CisKKwliZmlfaDJpX3NldChtLT5taCwgQkZJX01DX0ZDX1BPUlQsIEJGSV9QUE9SVF9IMklfU0VUX1NWQ19QQVJBTVNfUkVRLAorCQkgICAgYmZhX2xwdWlkKHBvcnQtPmJmYSkpOworCW0tPnR4X2JiY3JlZGl0ID0gYmZhX29zX2h0b25zKCh1MTYpIHBvcnQtPmNmZy50eF9iYmNyZWRpdCk7CisKKwkvKioKKwkgKiBxdWV1ZSBJL08gbWVzc2FnZSB0byBmaXJtd2FyZQorCSAqLworCWJmYV9yZXFxX3Byb2R1Y2UocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JUKTsKK30KKworCisKKy8qKgorICogIGJmYV9wcG9ydF9wdWJsaWMKKyAqLworCisvKioKKyAqIEZpcm13YXJlIG1lc3NhZ2UgaGFuZGxlci4KKyAqLwordm9pZAorYmZhX3Bwb3J0X2lzcihzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmaV9tc2dfcyAqbXNnKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKwl1bmlvbiBiZmlfcHBvcnRfaTJoX21zZ191IGkyaG1zZzsKKworCWkyaG1zZy5tc2cgPSBtc2c7CisJcHBvcnQtPmV2ZW50X2FyZy5pMmhtc2cgPSBpMmhtc2c7CisKKwlzd2l0Y2ggKG1zZy0+bWhkci5tc2dfaWQpIHsKKwljYXNlIEJGSV9QUE9SVF9JMkhfRU5BQkxFX1JTUDoKKwkJaWYgKHBwb3J0LT5tc2d0YWcgPT0gaTJobXNnLmVuYWJsZV9yc3AtPm1zZ3RhZykKKwkJCWJmYV9zbV9zZW5kX2V2ZW50KHBwb3J0LCBCRkFfUFBPUlRfU01fRldSU1ApOworCQlicmVhazsKKworCWNhc2UgQkZJX1BQT1JUX0kySF9ESVNBQkxFX1JTUDoKKwkJaWYgKHBwb3J0LT5tc2d0YWcgPT0gaTJobXNnLmVuYWJsZV9yc3AtPm1zZ3RhZykKKwkJCWJmYV9zbV9zZW5kX2V2ZW50KHBwb3J0LCBCRkFfUFBPUlRfU01fRldSU1ApOworCQlicmVhazsKKworCWNhc2UgQkZJX1BQT1JUX0kySF9FVkVOVDoKKwkJc3dpdGNoIChpMmhtc2cuZXZlbnQtPmxpbmtfc3RhdGUubGlua3N0YXRlKSB7CisJCWNhc2UgQkZBX1BQT1JUX0xJTktVUDoKKwkJCWJmYV9zbV9zZW5kX2V2ZW50KHBwb3J0LCBCRkFfUFBPUlRfU01fTElOS1VQKTsKKwkJCWJyZWFrOworCQljYXNlIEJGQV9QUE9SVF9MSU5LRE9XTjoKKwkJCWJmYV9zbV9zZW5kX2V2ZW50KHBwb3J0LCBCRkFfUFBPUlRfU01fTElOS0RPV04pOworCQkJYnJlYWs7CisJCWNhc2UgQkZBX1BQT1JUX1RSVU5LX0xJTktET1dOOgorCQkJLyoqIHRvZG86IGV2ZW50IG5vdGlmaWNhdGlvbiAqLworCQkJYnJlYWs7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIEJGSV9QUE9SVF9JMkhfR0VUX1NUQVRTX1JTUDoKKwljYXNlIEJGSV9QUE9SVF9JMkhfR0VUX1FPU19TVEFUU19SU1A6CisJCS8qCisJCSAqIGNoZWNrIGZvciB0aW1lciBwb3AgYmVmb3JlIHByb2Nlc3NpbmcgdGhlIHJzcAorCQkgKi8KKwkJaWYgKHBwb3J0LT5zdGF0c19idXN5ID09IEJGQV9GQUxTRQorCQkgICAgfHwgcHBvcnQtPnN0YXRzX3N0YXR1cyA9PSBCRkFfU1RBVFVTX0VUSU1FUikKKwkJCWJyZWFrOworCisJCWJmYV90aW1lcl9zdG9wKCZwcG9ydC0+dGltZXIpOworCQlwcG9ydC0+c3RhdHNfc3RhdHVzID0gaTJobXNnLmdldHN0YXRzX3JzcC0+c3RhdHVzOworCQliZmFfY2JfcXVldWUocHBvcnQtPmJmYSwgJnBwb3J0LT5oY2JfcWUsIF9fYmZhX2NiX3BvcnRfc3RhdHMsCisJCQkgICAgIHBwb3J0KTsKKwkJYnJlYWs7CisJY2FzZSBCRklfUFBPUlRfSTJIX0NMRUFSX1NUQVRTX1JTUDoKKwljYXNlIEJGSV9QUE9SVF9JMkhfQ0xFQVJfUU9TX1NUQVRTX1JTUDoKKwkJLyoKKwkJICogY2hlY2sgZm9yIHRpbWVyIHBvcCBiZWZvcmUgcHJvY2Vzc2luZyB0aGUgcnNwCisJCSAqLworCQlpZiAocHBvcnQtPnN0YXRzX2J1c3kgPT0gQkZBX0ZBTFNFCisJCSAgICB8fCBwcG9ydC0+c3RhdHNfc3RhdHVzID09IEJGQV9TVEFUVVNfRVRJTUVSKQorCQkJYnJlYWs7CisKKwkJYmZhX3RpbWVyX3N0b3AoJnBwb3J0LT50aW1lcik7CisJCXBwb3J0LT5zdGF0c19zdGF0dXMgPSBCRkFfU1RBVFVTX09LOworCQliZmFfY2JfcXVldWUocHBvcnQtPmJmYSwgJnBwb3J0LT5oY2JfcWUsCisJCQkgICAgIF9fYmZhX2NiX3BvcnRfc3RhdHNfY2xyLCBwcG9ydCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBiZmFfcHBvcnRfYXBpCisgKi8KKworLyoqCisgKiBSZWdpc3RlcmVkIGNhbGxiYWNrIGZvciBwb3J0IGV2ZW50cy4KKyAqLwordm9pZAorYmZhX3Bwb3J0X2V2ZW50X3JlZ2lzdGVyKHN0cnVjdCBiZmFfcyAqYmZhLAorCQkJIHZvaWQgKCpjYmZuKSAodm9pZCAqY2JhcmcsIGJmYV9wcG9ydF9ldmVudF90IGV2ZW50KSwKKwkJCSB2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwlwcG9ydC0+ZXZlbnRfY2JmbiA9IGNiZm47CisJcHBvcnQtPmV2ZW50X2NiYXJnID0gY2Jhcmc7Cit9CisKK2JmYV9zdGF0dXNfdAorYmZhX3Bwb3J0X2VuYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwlpZiAocHBvcnQtPmRpYWdfYnVzeSkKKwkJcmV0dXJuIChCRkFfU1RBVFVTX0RJQUdfQlVTWSk7CisJZWxzZSBpZiAoYmZhX3NtX2NtcF9zdGF0ZQorCQkgKEJGQV9QT1JUX01PRChiZmEpLCBiZmFfcHBvcnRfc21fZGlzYWJsaW5nX3F3YWl0KSkKKwkJcmV0dXJuIChCRkFfU1RBVFVTX0RFVkJVU1kpOworCisJYmZhX3NtX3NlbmRfZXZlbnQoQkZBX1BPUlRfTU9EKGJmYSksIEJGQV9QUE9SVF9TTV9FTkFCTEUpOworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9wcG9ydF9kaXNhYmxlKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWJmYV9zbV9zZW5kX2V2ZW50KEJGQV9QT1JUX01PRChiZmEpLCBCRkFfUFBPUlRfU01fRElTQUJMRSk7CisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogQ29uZmlndXJlIHBvcnQgc3BlZWQuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX3Bwb3J0X2NmZ19zcGVlZChzdHJ1Y3QgYmZhX3MgKmJmYSwgZW51bSBiZmFfcHBvcnRfc3BlZWQgc3BlZWQpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJYmZhX3RyYyhiZmEsIHNwZWVkKTsKKworCWlmICgoc3BlZWQgIT0gQkZBX1BQT1JUX1NQRUVEX0FVVE8pICYmIChzcGVlZCA+IHBwb3J0LT5zcGVlZF9zdXApKSB7CisJCWJmYV90cmMoYmZhLCBwcG9ydC0+c3BlZWRfc3VwKTsKKwkJcmV0dXJuIEJGQV9TVEFUVVNfVU5TVVBQX1NQRUVEOworCX0KKworCXBwb3J0LT5jZmcuc3BlZWQgPSBzcGVlZDsKKworCXJldHVybiAoQkZBX1NUQVRVU19PSyk7Cit9CisKKy8qKgorICogR2V0IGN1cnJlbnQgc3BlZWQuCisgKi8KK2VudW0gYmZhX3Bwb3J0X3NwZWVkCitiZmFfcHBvcnRfZ2V0X3NwZWVkKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJcmV0dXJuIHBvcnQtPnNwZWVkOworfQorCisvKioKKyAqIENvbmZpZ3VyZSBwb3J0IHRvcG9sb2d5LgorICovCitiZmFfc3RhdHVzX3QKK2JmYV9wcG9ydF9jZmdfdG9wb2xvZ3koc3RydWN0IGJmYV9zICpiZmEsIGVudW0gYmZhX3Bwb3J0X3RvcG9sb2d5IHRvcG9sb2d5KQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCWJmYV90cmMoYmZhLCB0b3BvbG9neSk7CisJYmZhX3RyYyhiZmEsIHBwb3J0LT5jZmcudG9wb2xvZ3kpOworCisJc3dpdGNoICh0b3BvbG9neSkgeworCWNhc2UgQkZBX1BQT1JUX1RPUE9MT0dZX1AyUDoKKwljYXNlIEJGQV9QUE9SVF9UT1BPTE9HWV9MT09QOgorCWNhc2UgQkZBX1BQT1JUX1RPUE9MT0dZX0FVVE86CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJcmV0dXJuIEJGQV9TVEFUVVNfRUlOVkFMOworCX0KKworCXBwb3J0LT5jZmcudG9wb2xvZ3kgPSB0b3BvbG9neTsKKwlyZXR1cm4gKEJGQV9TVEFUVVNfT0spOworfQorCisvKioKKyAqIEdldCBjdXJyZW50IHRvcG9sb2d5LgorICovCitlbnVtIGJmYV9wcG9ydF90b3BvbG9neQorYmZhX3Bwb3J0X2dldF90b3BvbG9neShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCXJldHVybiBwb3J0LT50b3BvbG9neTsKK30KKworYmZhX3N0YXR1c190CitiZmFfcHBvcnRfY2ZnX2hhcmRhbHBhKHN0cnVjdCBiZmFfcyAqYmZhLCB1OCBhbHBhKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCWJmYV90cmMoYmZhLCBhbHBhKTsKKwliZmFfdHJjKGJmYSwgcHBvcnQtPmNmZy5jZmdfaGFyZGFscGEpOworCWJmYV90cmMoYmZhLCBwcG9ydC0+Y2ZnLmhhcmRhbHBhKTsKKworCXBwb3J0LT5jZmcuY2ZnX2hhcmRhbHBhID0gQkZBX1RSVUU7CisJcHBvcnQtPmNmZy5oYXJkYWxwYSA9IGFscGE7CisKKwlyZXR1cm4gKEJGQV9TVEFUVVNfT0spOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9wcG9ydF9jbHJfaGFyZGFscGEoc3RydWN0IGJmYV9zICpiZmEpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJYmZhX3RyYyhiZmEsIHBwb3J0LT5jZmcuY2ZnX2hhcmRhbHBhKTsKKwliZmFfdHJjKGJmYSwgcHBvcnQtPmNmZy5oYXJkYWxwYSk7CisKKwlwcG9ydC0+Y2ZnLmNmZ19oYXJkYWxwYSA9IEJGQV9GQUxTRTsKKwlyZXR1cm4gKEJGQV9TVEFUVVNfT0spOworfQorCitiZmFfYm9vbGVhbl90CitiZmFfcHBvcnRfZ2V0X2hhcmRhbHBhKHN0cnVjdCBiZmFfcyAqYmZhLCB1OCAqYWxwYSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCSphbHBhID0gcG9ydC0+Y2ZnLmhhcmRhbHBhOworCXJldHVybiBwb3J0LT5jZmcuY2ZnX2hhcmRhbHBhOworfQorCit1OAorYmZhX3Bwb3J0X2dldF9teWFscGEoc3RydWN0IGJmYV9zICpiZmEpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwlyZXR1cm4gcG9ydC0+bXlhbHBhOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9wcG9ydF9jZmdfbWF4ZnJzaXplKHN0cnVjdCBiZmFfcyAqYmZhLCB1MTYgbWF4ZnJzaXplKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCWJmYV90cmMoYmZhLCBtYXhmcnNpemUpOworCWJmYV90cmMoYmZhLCBwcG9ydC0+Y2ZnLm1heGZyc2l6ZSk7CisKKwkvKgorCSAqIHdpdGggaW4gcmFuZ2UKKwkgKi8KKwlpZiAoKG1heGZyc2l6ZSA+IEZDX01BWF9QRFVTWikgfHwgKG1heGZyc2l6ZSA8IEZDX01JTl9QRFVTWikpCisJCXJldHVybiAoQkZBX1NUQVRVU19JTlZMRF9ERlNaKTsKKworCS8qCisJICogcG93ZXIgb2YgMiwgaWYgbm90IHRoZSBtYXggZnJhbWUgc2l6ZSBvZiAyMTEyCisJICovCisJaWYgKChtYXhmcnNpemUgIT0gRkNfTUFYX1BEVVNaKSAmJiAobWF4ZnJzaXplICYgKG1heGZyc2l6ZSAtIDEpKSkKKwkJcmV0dXJuIChCRkFfU1RBVFVTX0lOVkxEX0RGU1opOworCisJcHBvcnQtPmNmZy5tYXhmcnNpemUgPSBtYXhmcnNpemU7CisJcmV0dXJuIChCRkFfU1RBVFVTX09LKTsKK30KKwordTE2CitiZmFfcHBvcnRfZ2V0X21heGZyc2l6ZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCXJldHVybiBwb3J0LT5jZmcubWF4ZnJzaXplOworfQorCit1MzIKK2JmYV9wcG9ydF9teXBpZChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCXJldHVybiBwb3J0LT5teXBpZDsKK30KKwordTgKK2JmYV9wcG9ydF9nZXRfcnhfYmJjcmVkaXQoc3RydWN0IGJmYV9zICpiZmEpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwlyZXR1cm4gcG9ydC0+Y2ZnLnJ4X2JiY3JlZGl0OworfQorCit2b2lkCitiZmFfcHBvcnRfc2V0X3R4X2JiY3JlZGl0KHN0cnVjdCBiZmFfcyAqYmZhLCB1MTYgdHhfYmJjcmVkaXQpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwlwb3J0LT5jZmcudHhfYmJjcmVkaXQgPSAodTgpIHR4X2JiY3JlZGl0OworCWJmYV9wb3J0X3NlbmRfdHhjcmVkaXQocG9ydCk7Cit9CisKKy8qKgorICogR2V0IHBvcnQgYXR0cmlidXRlcy4KKyAqLworCit3d25fdAorYmZhX3Bwb3J0X2dldF93d24oc3RydWN0IGJmYV9zICpiZmEsIGJmYV9ib29sZWFuX3Qgbm9kZSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisJaWYgKG5vZGUpCisJCXJldHVybiBwcG9ydC0+bnd3bjsKKwllbHNlCisJCXJldHVybiBwcG9ydC0+cHd3bjsKK30KKwordm9pZAorYmZhX3Bwb3J0X2dldF9hdHRyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX3Bwb3J0X2F0dHJfcyAqYXR0cikKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwliZmFfb3NfbWVtc2V0KGF0dHIsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3Bwb3J0X2F0dHJfcykpOworCisJYXR0ci0+bnd3biA9IHBwb3J0LT5ud3duOworCWF0dHItPnB3d24gPSBwcG9ydC0+cHd3bjsKKworCWJmYV9vc19tZW1jcHkoJmF0dHItPnBwb3J0X2NmZywgJnBwb3J0LT5jZmcsCisJCSAgICAgIHNpemVvZihzdHJ1Y3QgYmZhX3Bwb3J0X2NmZ19zKSk7CisJLyoKKwkgKiBzcGVlZCBhdHRyaWJ1dGVzCisJICovCisJYXR0ci0+cHBvcnRfY2ZnLnNwZWVkID0gcHBvcnQtPmNmZy5zcGVlZDsKKwlhdHRyLT5zcGVlZF9zdXBwb3J0ZWQgPSBwcG9ydC0+c3BlZWRfc3VwOworCWF0dHItPnNwZWVkID0gcHBvcnQtPnNwZWVkOworCWF0dHItPmNvc19zdXBwb3J0ZWQgPSBGQ19DTEFTU18zOworCisJLyoKKwkgKiB0b3BvbG9neSBhdHRyaWJ1dGVzCisJICovCisJYXR0ci0+cHBvcnRfY2ZnLnRvcG9sb2d5ID0gcHBvcnQtPmNmZy50b3BvbG9neTsKKwlhdHRyLT50b3BvbG9neSA9IHBwb3J0LT50b3BvbG9neTsKKworCS8qCisJICogYmVhY29uIGF0dHJpYnV0ZXMKKwkgKi8KKwlhdHRyLT5iZWFjb24gPSBwcG9ydC0+YmVhY29uOworCWF0dHItPmxpbmtfZTJlX2JlYWNvbiA9IHBwb3J0LT5saW5rX2UyZV9iZWFjb247CisJYXR0ci0+cGxvZ19lbmFibGVkID0gYmZhX3Bsb2dfZ2V0X3NldHRpbmcocHBvcnQtPmJmYS0+cGxvZyk7CisKKwlhdHRyLT5wcG9ydF9jZmcucGF0aF90b3YgPSBiZmFfZmNwaW1fcGF0aF90b3ZfZ2V0KGJmYSk7CisJYXR0ci0+cHBvcnRfY2ZnLnFfZGVwdGggPSBiZmFfZmNwaW1fcWRlcHRoX2dldChiZmEpOworCWF0dHItPnBvcnRfc3RhdGUgPSBiZmFfc21fdG9fc3RhdGUoaGFsX3Bwb3J0X3NtX3RhYmxlLCBwcG9ydC0+c20pOworCWlmIChiZmFfaW9jX2lzX2Rpc2FibGVkKCZwcG9ydC0+YmZhLT5pb2MpKQorCQlhdHRyLT5wb3J0X3N0YXRlID0gQkZBX1BQT1JUX1NUX0lPQ0RJUzsKKwllbHNlIGlmIChiZmFfaW9jX2Z3X21pc21hdGNoKCZwcG9ydC0+YmZhLT5pb2MpKQorCQlhdHRyLT5wb3J0X3N0YXRlID0gQkZBX1BQT1JUX1NUX0ZXTUlTTUFUQ0g7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcG9ydF9zdGF0c19xdWVyeSh2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSAoc3RydWN0IGJmYV9wcG9ydF9zICopY2Jhcmc7CisJYmZpX3Bwb3J0X2dldF9zdGF0c19yZXFfdCAqbXNnOworCisJbXNnID0gYmZhX3JlcXFfbmV4dChwb3J0LT5iZmEsIEJGQV9SRVFRX1BPUlQpOworCisJaWYgKCFtc2cpIHsKKwkJcG9ydC0+c3RhdHNfcWZ1bGwgPSBCRkFfVFJVRTsKKwkJYmZhX3JlcXFfd2luaXQoJnBvcnQtPnN0YXRzX3JlcXFfd2FpdCwgYmZhX3BvcnRfc3RhdHNfcXVlcnksCisJCQkgICAgICAgcG9ydCk7CisJCWJmYV9yZXFxX3dhaXQocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JULCAmcG9ydC0+c3RhdHNfcmVxcV93YWl0KTsKKwkJcmV0dXJuOworCX0KKwlwb3J0LT5zdGF0c19xZnVsbCA9IEJGQV9GQUxTRTsKKworCWJmYV9vc19tZW1zZXQobXNnLCAwLCBzaXplb2YoYmZpX3Bwb3J0X2dldF9zdGF0c19yZXFfdCkpOworCWJmaV9oMmlfc2V0KG1zZy0+bWgsIEJGSV9NQ19GQ19QT1JULCBCRklfUFBPUlRfSDJJX0dFVF9TVEFUU19SRVEsCisJCSAgICBiZmFfbHB1aWQocG9ydC0+YmZhKSk7CisJYmZhX3JlcXFfcHJvZHVjZShwb3J0LT5iZmEsIEJGQV9SRVFRX1BPUlQpOworCisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZAorYmZhX3BvcnRfc3RhdHNfY2xlYXIodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0ID0gKHN0cnVjdCBiZmFfcHBvcnRfcyAqKWNiYXJnOworCWJmaV9wcG9ydF9jbGVhcl9zdGF0c19yZXFfdCAqbXNnOworCisJbXNnID0gYmZhX3JlcXFfbmV4dChwb3J0LT5iZmEsIEJGQV9SRVFRX1BPUlQpOworCisJaWYgKCFtc2cpIHsKKwkJcG9ydC0+c3RhdHNfcWZ1bGwgPSBCRkFfVFJVRTsKKwkJYmZhX3JlcXFfd2luaXQoJnBvcnQtPnN0YXRzX3JlcXFfd2FpdCwgYmZhX3BvcnRfc3RhdHNfY2xlYXIsCisJCQkgICAgICAgcG9ydCk7CisJCWJmYV9yZXFxX3dhaXQocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JULCAmcG9ydC0+c3RhdHNfcmVxcV93YWl0KTsKKwkJcmV0dXJuOworCX0KKwlwb3J0LT5zdGF0c19xZnVsbCA9IEJGQV9GQUxTRTsKKworCWJmYV9vc19tZW1zZXQobXNnLCAwLCBzaXplb2YoYmZpX3Bwb3J0X2NsZWFyX3N0YXRzX3JlcV90KSk7CisJYmZpX2gyaV9zZXQobXNnLT5taCwgQkZJX01DX0ZDX1BPUlQsIEJGSV9QUE9SVF9IMklfQ0xFQVJfU1RBVFNfUkVRLAorCQkgICAgYmZhX2xwdWlkKHBvcnQtPmJmYSkpOworCWJmYV9yZXFxX3Byb2R1Y2UocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JUKTsKKwlyZXR1cm47Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcG9ydF9xb3Nfc3RhdHNfY2xlYXIodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0ID0gKHN0cnVjdCBiZmFfcHBvcnRfcyAqKWNiYXJnOworCWJmaV9wcG9ydF9jbGVhcl9xb3Nfc3RhdHNfcmVxX3QgKm1zZzsKKworCW1zZyA9IGJmYV9yZXFxX25leHQocG9ydC0+YmZhLCBCRkFfUkVRUV9QT1JUKTsKKworCWlmICghbXNnKSB7CisJCXBvcnQtPnN0YXRzX3FmdWxsID0gQkZBX1RSVUU7CisJCWJmYV9yZXFxX3dpbml0KCZwb3J0LT5zdGF0c19yZXFxX3dhaXQsIGJmYV9wb3J0X3Fvc19zdGF0c19jbGVhciwKKwkJCSAgICAgICBwb3J0KTsKKwkJYmZhX3JlcXFfd2FpdChwb3J0LT5iZmEsIEJGQV9SRVFRX1BPUlQsICZwb3J0LT5zdGF0c19yZXFxX3dhaXQpOworCQlyZXR1cm47CisJfQorCXBvcnQtPnN0YXRzX3FmdWxsID0gQkZBX0ZBTFNFOworCisJYmZhX29zX21lbXNldChtc2csIDAsIHNpemVvZihiZmlfcHBvcnRfY2xlYXJfcW9zX3N0YXRzX3JlcV90KSk7CisJYmZpX2gyaV9zZXQobXNnLT5taCwgQkZJX01DX0ZDX1BPUlQsIEJGSV9QUE9SVF9IMklfQ0xFQVJfUU9TX1NUQVRTX1JFUSwKKwkJICAgIGJmYV9scHVpZChwb3J0LT5iZmEpKTsKKwliZmFfcmVxcV9wcm9kdWNlKHBvcnQtPmJmYSwgQkZBX1JFUVFfUE9SVCk7CisJcmV0dXJuOworfQorCitzdGF0aWMgdm9pZAorYmZhX3Bwb3J0X3N0YXRzX3N3YXAodW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKmQsIHVuaW9uIGJmYV9wcG9ydF9zdGF0c191ICpzKQoreworCXUzMiAgICAgICAqZGlwID0gKHUzMiAqKSBkOworCXUzMiAgICAgICAqc2lwID0gKHUzMiAqKSBzOworCWludCAgICAgICAgICAgICBpOworCisJLyoKKwkgKiBEbyA2NCBiaXQgZmllbGRzIHN3YXAgZmlyc3QKKwkgKi8KKwlmb3IgKGkgPSAwOworCSAgICAgaSA8CisJICAgICAoKHNpemVvZih1bmlvbiBiZmFfcHBvcnRfc3RhdHNfdSkgLQorCSAgICAgICBzaXplb2Yoc3RydWN0IGJmYV9xb3Nfc3RhdHNfcykpIC8gc2l6ZW9mKHUzMikpOyBpID0gaSArIDIpIHsKKyNpZmRlZiBfX0JJR0VORElBTgorCQlkaXBbaV0gPSBiZmFfb3NfbnRvaGwoc2lwW2ldKTsKKwkJZGlwW2kgKyAxXSA9IGJmYV9vc19udG9obChzaXBbaSArIDFdKTsKKyNlbHNlCisJCWRpcFtpXSA9IGJmYV9vc19udG9obChzaXBbaSArIDFdKTsKKwkJZGlwW2kgKyAxXSA9IGJmYV9vc19udG9obChzaXBbaV0pOworI2VuZGlmCisJfQorCisJLyoKKwkgKiBOb3cgc3dhcCB0aGUgMzIgYml0IGZpZWxkcworCSAqLworCWZvciAoOyBpIDwgKHNpemVvZih1bmlvbiBiZmFfcHBvcnRfc3RhdHNfdSkgLyBzaXplb2YodTMyKSk7ICsraSkKKwkJZGlwW2ldID0gYmZhX29zX250b2hsKHNpcFtpXSk7Cit9CisKK3N0YXRpYyB2b2lkCitfX2JmYV9jYl9wb3J0X3N0YXRzX2Nscih2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSBjYmFyZzsKKworCWlmIChjb21wbGV0ZSkgeworCQlwb3J0LT5zdGF0c19jYmZuKHBvcnQtPnN0YXRzX2NiYXJnLCBwb3J0LT5zdGF0c19zdGF0dXMpOworCX0gZWxzZSB7CisJCXBvcnQtPnN0YXRzX2J1c3kgPSBCRkFfRkFMU0U7CisJCXBvcnQtPnN0YXRzX3N0YXR1cyA9IEJGQV9TVEFUVVNfT0s7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3BvcnRfc3RhdHNfY2xyX3RpbWVvdXQodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwb3J0ID0gKHN0cnVjdCBiZmFfcHBvcnRfcyAqKWNiYXJnOworCisJYmZhX3RyYyhwb3J0LT5iZmEsIHBvcnQtPnN0YXRzX3FmdWxsKTsKKworCWlmIChwb3J0LT5zdGF0c19xZnVsbCkgeworCQliZmFfcmVxcV93Y2FuY2VsKCZwb3J0LT5zdGF0c19yZXFxX3dhaXQpOworCQlwb3J0LT5zdGF0c19xZnVsbCA9IEJGQV9GQUxTRTsKKwl9CisKKwlwb3J0LT5zdGF0c19zdGF0dXMgPSBCRkFfU1RBVFVTX0VUSU1FUjsKKwliZmFfY2JfcXVldWUocG9ydC0+YmZhLCAmcG9ydC0+aGNiX3FlLCBfX2JmYV9jYl9wb3J0X3N0YXRzX2NsciwgcG9ydCk7Cit9CisKK3N0YXRpYyB2b2lkCitfX2JmYV9jYl9wb3J0X3N0YXRzKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcG9ydCA9IGNiYXJnOworCisJaWYgKGNvbXBsZXRlKSB7CisJCWlmIChwb3J0LT5zdGF0c19zdGF0dXMgPT0gQkZBX1NUQVRVU19PSykKKwkJCWJmYV9wcG9ydF9zdGF0c19zd2FwKHBvcnQtPnN0YXRzX3JldCwgcG9ydC0+c3RhdHMpOworCQlwb3J0LT5zdGF0c19jYmZuKHBvcnQtPnN0YXRzX2NiYXJnLCBwb3J0LT5zdGF0c19zdGF0dXMpOworCX0gZWxzZSB7CisJCXBvcnQtPnN0YXRzX2J1c3kgPSBCRkFfRkFMU0U7CisJCXBvcnQtPnN0YXRzX3N0YXR1cyA9IEJGQV9TVEFUVVNfT0s7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3BvcnRfc3RhdHNfdGltZW91dCh2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSAoc3RydWN0IGJmYV9wcG9ydF9zICopY2Jhcmc7CisKKwliZmFfdHJjKHBvcnQtPmJmYSwgcG9ydC0+c3RhdHNfcWZ1bGwpOworCisJaWYgKHBvcnQtPnN0YXRzX3FmdWxsKSB7CisJCWJmYV9yZXFxX3djYW5jZWwoJnBvcnQtPnN0YXRzX3JlcXFfd2FpdCk7CisJCXBvcnQtPnN0YXRzX3FmdWxsID0gQkZBX0ZBTFNFOworCX0KKworCXBvcnQtPnN0YXRzX3N0YXR1cyA9IEJGQV9TVEFUVVNfRVRJTUVSOworCWJmYV9jYl9xdWV1ZShwb3J0LT5iZmEsICZwb3J0LT5oY2JfcWUsIF9fYmZhX2NiX3BvcnRfc3RhdHMsIHBvcnQpOworfQorCisjZGVmaW5lIEJGQV9QT1JUX1NUQVRTX1RPVgkxMDAwCisKKy8qKgorICogRmV0Y2ggcG9ydCBhdHRyaWJ1dGVzLgorICovCitiZmFfc3RhdHVzX3QKK2JmYV9wcG9ydF9nZXRfc3RhdHMoc3RydWN0IGJmYV9zICpiZmEsIHVuaW9uIGJmYV9wcG9ydF9zdGF0c191ICpzdGF0cywKKwkJICAgIGJmYV9jYl9wcG9ydF90IGNiZm4sIHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJaWYgKHBvcnQtPnN0YXRzX2J1c3kpIHsKKwkJYmZhX3RyYyhiZmEsIHBvcnQtPnN0YXRzX2J1c3kpOworCQlyZXR1cm4gKEJGQV9TVEFUVVNfREVWQlVTWSk7CisJfQorCisJcG9ydC0+c3RhdHNfYnVzeSA9IEJGQV9UUlVFOworCXBvcnQtPnN0YXRzX3JldCA9IHN0YXRzOworCXBvcnQtPnN0YXRzX2NiZm4gPSBjYmZuOworCXBvcnQtPnN0YXRzX2NiYXJnID0gY2Jhcmc7CisKKwliZmFfcG9ydF9zdGF0c19xdWVyeShwb3J0KTsKKworCWJmYV90aW1lcl9zdGFydChiZmEsICZwb3J0LT50aW1lciwgYmZhX3BvcnRfc3RhdHNfdGltZW91dCwgcG9ydCwKKwkJCUJGQV9QT1JUX1NUQVRTX1RPVik7CisJcmV0dXJuIChCRkFfU1RBVFVTX09LKTsKK30KKworYmZhX3N0YXR1c190CitiZmFfcHBvcnRfY2xlYXJfc3RhdHMoc3RydWN0IGJmYV9zICpiZmEsIGJmYV9jYl9wcG9ydF90IGNiZm4sIHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJaWYgKHBvcnQtPnN0YXRzX2J1c3kpIHsKKwkJYmZhX3RyYyhiZmEsIHBvcnQtPnN0YXRzX2J1c3kpOworCQlyZXR1cm4gKEJGQV9TVEFUVVNfREVWQlVTWSk7CisJfQorCisJcG9ydC0+c3RhdHNfYnVzeSA9IEJGQV9UUlVFOworCXBvcnQtPnN0YXRzX2NiZm4gPSBjYmZuOworCXBvcnQtPnN0YXRzX2NiYXJnID0gY2Jhcmc7CisKKwliZmFfcG9ydF9zdGF0c19jbGVhcihwb3J0KTsKKworCWJmYV90aW1lcl9zdGFydChiZmEsICZwb3J0LT50aW1lciwgYmZhX3BvcnRfc3RhdHNfY2xyX3RpbWVvdXQsIHBvcnQsCisJCQlCRkFfUE9SVF9TVEFUU19UT1YpOworCXJldHVybiAoQkZBX1NUQVRVU19PSyk7Cit9CisKK2JmYV9zdGF0dXNfdAorYmZhX3Bwb3J0X3RydW5rX2VuYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSwgdTggYml0bWFwKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCWJmYV90cmMoYmZhLCBiaXRtYXApOworCWJmYV90cmMoYmZhLCBwcG9ydC0+Y2ZnLnRydW5rZWQpOworCWJmYV90cmMoYmZhLCBwcG9ydC0+Y2ZnLnRydW5rX3BvcnRzKTsKKworCWlmICghYml0bWFwIHx8IChiaXRtYXAgJiAoYml0bWFwIC0gMSkpKQorCQlyZXR1cm4gQkZBX1NUQVRVU19FSU5WQUw7CisKKwlwcG9ydC0+Y2ZnLnRydW5rZWQgPSBCRkFfVFJVRTsKKwlwcG9ydC0+Y2ZnLnRydW5rX3BvcnRzID0gYml0bWFwOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKK3ZvaWQKK2JmYV9wcG9ydF9xb3NfZ2V0X2F0dHIoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfcW9zX2F0dHJfcyAqcW9zX2F0dHIpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJcW9zX2F0dHItPnN0YXRlID0gYmZhX29zX250b2hsKHBwb3J0LT5xb3NfYXR0ci5zdGF0ZSk7CisJcW9zX2F0dHItPnRvdGFsX2JiX2NyID0gYmZhX29zX250b2hsKHBwb3J0LT5xb3NfYXR0ci50b3RhbF9iYl9jcik7Cit9CisKK3ZvaWQKK2JmYV9wcG9ydF9xb3NfZ2V0X3ZjX2F0dHIoc3RydWN0IGJmYV9zICpiZmEsCisJCQkgIHN0cnVjdCBiZmFfcW9zX3ZjX2F0dHJfcyAqcW9zX3ZjX2F0dHIpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCXN0cnVjdCBiZmFfcW9zX3ZjX2F0dHJfcyAqYmZhX3ZjX2F0dHIgPSAmcHBvcnQtPnFvc192Y19hdHRyOworCXUzMiAgICAgICAgaSA9IDA7CisKKwlxb3NfdmNfYXR0ci0+dG90YWxfdmNfY291bnQgPSBiZmFfb3NfbnRvaHMoYmZhX3ZjX2F0dHItPnRvdGFsX3ZjX2NvdW50KTsKKwlxb3NfdmNfYXR0ci0+c2hhcmVkX2NyZWRpdCA9IGJmYV9vc19udG9ocyhiZmFfdmNfYXR0ci0+c2hhcmVkX2NyZWRpdCk7CisJcW9zX3ZjX2F0dHItPmVscF9vcG1vZGVfZmxhZ3MgPQorCQliZmFfb3NfbnRvaGwoYmZhX3ZjX2F0dHItPmVscF9vcG1vZGVfZmxhZ3MpOworCisJLyoKKwkgKiBJbmRpdmlkdWFsIFZDIGluZm8KKwkgKi8KKwl3aGlsZSAoaSA8IHFvc192Y19hdHRyLT50b3RhbF92Y19jb3VudCkgeworCQlxb3NfdmNfYXR0ci0+dmNfaW5mb1tpXS52Y19jcmVkaXQgPQorCQkJYmZhX3ZjX2F0dHItPnZjX2luZm9baV0udmNfY3JlZGl0OworCQlxb3NfdmNfYXR0ci0+dmNfaW5mb1tpXS5ib3Jyb3dfY3JlZGl0ID0KKwkJCWJmYV92Y19hdHRyLT52Y19pbmZvW2ldLmJvcnJvd19jcmVkaXQ7CisJCXFvc192Y19hdHRyLT52Y19pbmZvW2ldLnByaW9yaXR5ID0KKwkJCWJmYV92Y19hdHRyLT52Y19pbmZvW2ldLnByaW9yaXR5OworCQkrK2k7CisJfQorfQorCisvKioKKyAqIEZldGNoIFFvUyBTdGF0cy4KKyAqLworYmZhX3N0YXR1c190CitiZmFfcHBvcnRfZ2V0X3Fvc19zdGF0cyhzdHJ1Y3QgYmZhX3MgKmJmYSwgdW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKnN0YXRzLAorCQkJYmZhX2NiX3Bwb3J0X3QgY2Jmbiwgdm9pZCAqY2JhcmcpCit7CisJLyoKKwkgKiBRb1Mgc3RhdHMgaXMgZW1iZWRkZWQgaW4gcG9ydCBzdGF0cworCSAqLworCXJldHVybiAoYmZhX3Bwb3J0X2dldF9zdGF0cyhiZmEsIHN0YXRzLCBjYmZuLCBjYmFyZykpOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9wcG9ydF9jbGVhcl9xb3Nfc3RhdHMoc3RydWN0IGJmYV9zICpiZmEsIGJmYV9jYl9wcG9ydF90IGNiZm4sIHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJaWYgKHBvcnQtPnN0YXRzX2J1c3kpIHsKKwkJYmZhX3RyYyhiZmEsIHBvcnQtPnN0YXRzX2J1c3kpOworCQlyZXR1cm4gKEJGQV9TVEFUVVNfREVWQlVTWSk7CisJfQorCisJcG9ydC0+c3RhdHNfYnVzeSA9IEJGQV9UUlVFOworCXBvcnQtPnN0YXRzX2NiZm4gPSBjYmZuOworCXBvcnQtPnN0YXRzX2NiYXJnID0gY2Jhcmc7CisKKwliZmFfcG9ydF9xb3Nfc3RhdHNfY2xlYXIocG9ydCk7CisKKwliZmFfdGltZXJfc3RhcnQoYmZhLCAmcG9ydC0+dGltZXIsIGJmYV9wb3J0X3N0YXRzX2Nscl90aW1lb3V0LCBwb3J0LAorCQkJQkZBX1BPUlRfU1RBVFNfVE9WKTsKKwlyZXR1cm4gKEJGQV9TVEFUVVNfT0spOworfQorCisvKioKKyAqIEZldGNoIHBvcnQgYXR0cmlidXRlcy4KKyAqLworYmZhX3N0YXR1c190CitiZmFfcHBvcnRfdHJ1bmtfZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlyZXR1cm4gKEJGQV9TVEFUVVNfT0spOworfQorCitiZmFfYm9vbGVhbl90CitiZmFfcHBvcnRfdHJ1bmtfcXVlcnkoc3RydWN0IGJmYV9zICpiZmEsIHUzMiAqYml0bWFwKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJKmJpdG1hcCA9IHBvcnQtPmNmZy50cnVua19wb3J0czsKKwlyZXR1cm4gcG9ydC0+Y2ZnLnRydW5rZWQ7Cit9CisKK2JmYV9ib29sZWFuX3QKK2JmYV9wcG9ydF9pc19kaXNhYmxlZChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCXJldHVybiAoYmZhX3NtX3RvX3N0YXRlKGhhbF9wcG9ydF9zbV90YWJsZSwgcG9ydC0+c20pID09CisJCUJGQV9QUE9SVF9TVF9ESVNBQkxFRCk7CisKK30KKworYmZhX2Jvb2xlYW5fdAorYmZhX3Bwb3J0X2lzX3JhdGVsaW0oc3RydWN0IGJmYV9zICpiZmEpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCityZXR1cm4gKHBwb3J0LT5jZmcucmF0ZWxpbWl0ID8gQkZBX1RSVUUgOiBCRkFfRkFMU0UpOworCit9CisKK3ZvaWQKK2JmYV9wcG9ydF9jZmdfcW9zKHN0cnVjdCBiZmFfcyAqYmZhLCBiZmFfYm9vbGVhbl90IG9uX29mZikKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwliZmFfdHJjKGJmYSwgb25fb2ZmKTsKKwliZmFfdHJjKGJmYSwgcHBvcnQtPmNmZy5xb3NfZW5hYmxlZCk7CisKKwlwcG9ydC0+Y2ZnLnFvc19lbmFibGVkID0gb25fb2ZmOworfQorCit2b2lkCitiZmFfcHBvcnRfY2ZnX3JhdGVsaW0oc3RydWN0IGJmYV9zICpiZmEsIGJmYV9ib29sZWFuX3Qgb25fb2ZmKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCWJmYV90cmMoYmZhLCBvbl9vZmYpOworCWJmYV90cmMoYmZhLCBwcG9ydC0+Y2ZnLnJhdGVsaW1pdCk7CisKKwlwcG9ydC0+Y2ZnLnJhdGVsaW1pdCA9IG9uX29mZjsKKwlpZiAocHBvcnQtPmNmZy50cmxfZGVmX3NwZWVkID09IEJGQV9QUE9SVF9TUEVFRF9VTktOT1dOKQorCQlwcG9ydC0+Y2ZnLnRybF9kZWZfc3BlZWQgPSBCRkFfUFBPUlRfU1BFRURfMUdCUFM7Cit9CisKKy8qKgorICogQ29uZmlndXJlIGRlZmF1bHQgbWluaW11bSByYXRlbGltIHNwZWVkCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX3Bwb3J0X2NmZ19yYXRlbGltX3NwZWVkKHN0cnVjdCBiZmFfcyAqYmZhLCBlbnVtIGJmYV9wcG9ydF9zcGVlZCBzcGVlZCkKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwliZmFfdHJjKGJmYSwgc3BlZWQpOworCisJLyoKKwkgKiBBdXRvIGFuZCBzcGVlZHMgZ3JlYXRlciB0aGFuIHRoZSBzdXBwb3J0ZWQgc3BlZWQsIGFyZSBpbnZhbGlkCisJICovCisJaWYgKChzcGVlZCA9PSBCRkFfUFBPUlRfU1BFRURfQVVUTykgfHwgKHNwZWVkID4gcHBvcnQtPnNwZWVkX3N1cCkpIHsKKwkJYmZhX3RyYyhiZmEsIHBwb3J0LT5zcGVlZF9zdXApOworCQlyZXR1cm4gQkZBX1NUQVRVU19VTlNVUFBfU1BFRUQ7CisJfQorCisJcHBvcnQtPmNmZy50cmxfZGVmX3NwZWVkID0gc3BlZWQ7CisKKwlyZXR1cm4gKEJGQV9TVEFUVVNfT0spOworfQorCisvKioKKyAqIEdldCBkZWZhdWx0IG1pbmltdW0gcmF0ZWxpbSBzcGVlZAorICovCitlbnVtIGJmYV9wcG9ydF9zcGVlZAorYmZhX3Bwb3J0X2dldF9yYXRlbGltX3NwZWVkKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfcHBvcnRfcyAqcHBvcnQgPSBCRkFfUE9SVF9NT0QoYmZhKTsKKworCWJmYV90cmMoYmZhLCBwcG9ydC0+Y2ZnLnRybF9kZWZfc3BlZWQpOworCXJldHVybiAocHBvcnQtPmNmZy50cmxfZGVmX3NwZWVkKTsKKworfQorCit2b2lkCitiZmFfcHBvcnRfYnVzeShzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2Jvb2xlYW5fdCBzdGF0dXMpCit7CisJc3RydWN0IGJmYV9wcG9ydF9zICpwcG9ydCA9IEJGQV9QT1JUX01PRChiZmEpOworCisJYmZhX3RyYyhiZmEsIHN0YXR1cyk7CisJYmZhX3RyYyhiZmEsIHBwb3J0LT5kaWFnX2J1c3kpOworCisJcHBvcnQtPmRpYWdfYnVzeSA9IHN0YXR1czsKK30KKwordm9pZAorYmZhX3Bwb3J0X2JlYWNvbihzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2Jvb2xlYW5fdCBiZWFjb24sCisJCSBiZmFfYm9vbGVhbl90IGxpbmtfZTJlX2JlYWNvbikKK3sKKwlzdHJ1Y3QgYmZhX3Bwb3J0X3MgKnBwb3J0ID0gQkZBX1BPUlRfTU9EKGJmYSk7CisKKwliZmFfdHJjKGJmYSwgYmVhY29uKTsKKwliZmFfdHJjKGJmYSwgbGlua19lMmVfYmVhY29uKTsKKwliZmFfdHJjKGJmYSwgcHBvcnQtPmJlYWNvbik7CisJYmZhX3RyYyhiZmEsIHBwb3J0LT5saW5rX2UyZV9iZWFjb24pOworCisJcHBvcnQtPmJlYWNvbiA9IGJlYWNvbjsKKwlwcG9ydC0+bGlua19lMmVfYmVhY29uID0gbGlua19lMmVfYmVhY29uOworfQorCitiZmFfYm9vbGVhbl90CitiZmFfcHBvcnRfaXNfbGlua3VwKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXJldHVybiBiZmFfc21fY21wX3N0YXRlKEJGQV9QT1JUX01PRChiZmEpLCBiZmFfcHBvcnRfc21fbGlua3VwKTsKK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3MuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Zjcy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdjYjM5YTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3MuYwpAQCAtMCwwICsxLDE4MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFfZmNzLmMgQkZBIEZDUyBtYWluCisgKi8KKworI2luY2x1ZGUgPGZjcy9iZmFfZmNzLmg+CisjaW5jbHVkZSAiZmNzX3BvcnQuaCIKKyNpbmNsdWRlICJmY3NfdWYuaCIKKyNpbmNsdWRlICJmY3NfdnBvcnQuaCIKKyNpbmNsdWRlICJmY3NfcnBvcnQuaCIKKyNpbmNsdWRlICJmY3NfZmFicmljLmgiCisjaW5jbHVkZSAiZmNzX2ZjcGltLmgiCisjaW5jbHVkZSAiZmNzX2ZjcHRtLmgiCisjaW5jbHVkZSAiZmNidWlsZC5oIgorI2luY2x1ZGUgImZjcy5oIgorI2luY2x1ZGUgImJmYWRfZHJ2LmgiCisjaW5jbHVkZSA8ZmNiL2JmYV9mY2IuaD4KKworLyoqCisgKiBGQ1Mgc3ViLW1vZHVsZXMKKyAqLworc3RydWN0IGJmYV9mY3NfbW9kX3MgeworCXZvaWQgICAgICAgICAgICAoKm1vZGluaXQpIChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOworCXZvaWQgICAgICAgICAgICAoKm1vZGV4aXQpIChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOworfTsKKworI2RlZmluZSBCRkFfRkNTX01PRFVMRShfbW9kKSB7IF9tb2QgIyMgX21vZGluaXQsIF9tb2QgIyMgX21vZGV4aXQgfQorCitzdGF0aWMgc3RydWN0IGJmYV9mY3NfbW9kX3MgZmNzX21vZHVsZXNbXSA9IHsKKwlCRkFfRkNTX01PRFVMRShiZmFfZmNzX3Bwb3J0KSwKKwlCRkFfRkNTX01PRFVMRShiZmFfZmNzX3VmKSwKKwlCRkFfRkNTX01PRFVMRShiZmFfZmNzX2ZhYnJpYyksCisJQkZBX0ZDU19NT0RVTEUoYmZhX2Zjc192cG9ydCksCisJQkZBX0ZDU19NT0RVTEUoYmZhX2Zjc19ycG9ydCksCisJQkZBX0ZDU19NT0RVTEUoYmZhX2Zjc19mY3BpbSksCit9OworCisvKioKKyAqICBmY3NfYXBpIEJGQSBGQ1MgQVBJCisgKi8KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfZXhpdF9jb21wKHZvaWQgKmZjc19jYmFyZykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19zICpmY3MgPSBmY3NfY2Jhcmc7CisJc3RydWN0IGJmYWRfcyAqYmZhZCA9IGZjcy0+YmZhZDsKKworCWNvbXBsZXRlKCZiZmFkLT5jb21wKTsKK30KKworCisKKy8qKgorICogIGZjc19hcGkgQkZBIEZDUyBBUEkKKyAqLworCisvKioKKyAqIAkJRkNTIGluc3RhbmNlIGluaXRpYWxpemF0aW9uLgorICoKKyAqIAlwYXJhbVtpbl0JCWZjcwkJRkNTIGluc3RhbmNlCisgKiAJcGFyYW1baW5dCQliZmEJCUJGQSBpbnN0YW5jZQorICogCXBhcmFtW2luXQkJYmZhZAkJQkZBIGRyaXZlciBpbnN0YW5jZQorICoKKyAqIAlyZXR1cm4gTm9uZQorICovCit2b2lkCitiZmFfZmNzX2luaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzLCBzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYWRfcyAqYmZhZCwKKwkJCWJmYV9ib29sZWFuX3QgbWluX2NmZykKK3sKKwlpbnQgICAgICAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX2Zjc19tb2RfcyAgKm1vZDsKKworCWZjcy0+YmZhID0gYmZhOworCWZjcy0+YmZhZCA9IGJmYWQ7CisJZmNzLT5taW5fY2ZnID0gbWluX2NmZzsKKworCWJmYV9hdHRhY2hfZmNzKGJmYSk7CisJZmNidWlsZF9pbml0KCk7CisKKwlmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mKGZjc19tb2R1bGVzKSAvIHNpemVvZihmY3NfbW9kdWxlc1swXSk7IGkrKykgeworCQltb2QgPSAmZmNzX21vZHVsZXNbaV07CisJCW1vZC0+bW9kaW5pdChmY3MpOworCX0KK30KKworLyoqCisgKiBTdGFydCBGQ1Mgb3BlcmF0aW9ucy4KKyAqLwordm9pZAorYmZhX2Zjc19zdGFydChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7CisJYmZhX2Zjc19mYWJyaWNfbW9kc3RhcnQoZmNzKTsKK30KKworLyoqCisgKiAJCUZDUyBkcml2ZXIgZGV0YWlscyBpbml0aWFsaXphdGlvbi4KKyAqCisgKiAJcGFyYW1baW5dCQlmY3MJCUZDUyBpbnN0YW5jZQorICogCXBhcmFtW2luXQkJZHJpdmVyX2luZm8JRHJpdmVyIERldGFpbHMKKyAqCisgKiAJcmV0dXJuIE5vbmUKKyAqLwordm9pZAorYmZhX2Zjc19kcml2ZXJfaW5mb19pbml0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcywKKwkJCXN0cnVjdCBiZmFfZmNzX2RyaXZlcl9pbmZvX3MgKmRyaXZlcl9pbmZvKQoreworCisJZmNzLT5kcml2ZXJfaW5mbyA9ICpkcml2ZXJfaW5mbzsKKworCWJmYV9mY3NfZmFicmljX3BzeW1iX2luaXQoJmZjcy0+ZmFicmljKTsKK30KKworLyoqCisgKiAJCUZDUyBpbnN0YW5jZSBjbGVhbnVwIGFuZCBleGl0LgorICoKKyAqIAlwYXJhbVtpbl0JCWZjcwkJCUZDUyBpbnN0YW5jZQorICogCXJldHVybiBOb25lCisgKi8KK3ZvaWQKK2JmYV9mY3NfZXhpdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7CisJc3RydWN0IGJmYV9mY3NfbW9kX3MgICptb2Q7CisJaW50ICAgICAgICAgICAgIG5tb2RzLCBpOworCisJYmZhX3djX2luaXQoJmZjcy0+d2MsIGJmYV9mY3NfZXhpdF9jb21wLCBmY3MpOworCisJbm1vZHMgPSBzaXplb2YoZmNzX21vZHVsZXMpIC8gc2l6ZW9mKGZjc19tb2R1bGVzWzBdKTsKKworCWZvciAoaSA9IDA7IGkgPCBubW9kczsgaSsrKSB7CisJCWJmYV93Y191cCgmZmNzLT53Yyk7CisKKwkJbW9kID0gJmZjc19tb2R1bGVzW2ldOworCQltb2QtPm1vZGV4aXQoZmNzKTsKKwl9CisKKwliZmFfd2Nfd2FpdCgmZmNzLT53Yyk7Cit9CisKKwordm9pZAorYmZhX2Zjc190cmNfaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QpCit7CisJZmNzLT50cmNtb2QgPSB0cmNtb2Q7Cit9CisKKwordm9pZAorYmZhX2Zjc19sb2dfaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtb2QpCit7CisJZmNzLT5sb2dtID0gbG9nbW9kOworfQorCisKK3ZvaWQKK2JmYV9mY3NfYWVuX2luaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzLCBzdHJ1Y3QgYmZhX2Flbl9zICphZW4pCit7CisJZmNzLT5hZW4gPSBhZW47Cit9CisKK3ZvaWQKK2JmYV9mY3NfbW9kZXhpdF9jb21wKHN0cnVjdCBiZmFfZmNzX3MgKmZjcykKK3sKKwliZmFfd2NfZG93bigmZmNzLT53Yyk7Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNzX2xwb3J0LmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3NfbHBvcnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44OTc1ZWQwCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNzX2xwb3J0LmMKQEAgLTAsMCArMSw5NDAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2Zjc19wb3J0LmMgQkZBIEZDUyBwb3J0CisgKi8KKworI2luY2x1ZGUgPGZjcy9iZmFfZmNzLmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfbHBvcnQuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc19ycG9ydC5oPgorI2luY2x1ZGUgPGZjYi9iZmFfZmNiX3BvcnQuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSA8bG9nL2JmYV9sb2dfZmNzLmg+CisjaW5jbHVkZSAiZmNzLmgiCisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Zwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX2ZjeHAuaCIKKyNpbmNsdWRlICJmY3NfdHJjbW9kLmgiCisjaW5jbHVkZSAibHBvcnRfcHJpdi5oIgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuX2xwb3J0Lmg+CisKK0JGQV9UUkNfRklMRShGQ1MsIFBPUlQpOworCisvKioKKyAqIEZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KKworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9hZW5fcG9zdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQkJICAgICAgZW51bSBiZmFfbHBvcnRfYWVuX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfc2VuZF9sc19yanQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJc3RydWN0IGZjaHNfcyAqcnhfZmNocywgdTggcmVhc29uX2NvZGUsCisJCQl1OCByZWFzb25fY29kZV9leHBsKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfcGxvZ2koc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJc3RydWN0IGZjaHNfcyAqcnhfZmNocywKKwkJCXN0cnVjdCBmY19sb2dpX3MgKnBsb2dpKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfb25saW5lX2FjdGlvbnMoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfb2ZmbGluZV9hY3Rpb25zKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X3Vua25vd25faW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF91bmtub3duX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF91bmtub3duX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfZGVsZXRlZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9lY2hvKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXN0cnVjdCBmY2hzX3MgKnJ4X2ZjaHMsCisJCQlzdHJ1Y3QgZmNfZWNob19zICplY2hvLCB1MTYgbGVuKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfcm5pZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQlzdHJ1Y3QgZmNoc19zICpyeF9mY2hzLAorCQkJc3RydWN0IGZjX3JuaWRfY21kX3MgKnJuaWQsIHUxNiBsZW4pOworc3RhdGljIHZvaWQgICAgIGJmYV9mc19wb3J0X2dldF9nZW5fdG9wb19kYXRhKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXN0cnVjdCBmY19ybmlkX2dlbmVyYWxfdG9wb2xvZ3lfZGF0YV9zICpnZW5fdG9wb19kYXRhKTsKKworc3RhdGljIHN0cnVjdCB7CisJdm9pZCAgICAgICAgICAgICgqaW5pdCkgKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCk7CisJdm9pZCAgICAgICAgICAgICgqb25saW5lKSAoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKKwl2b2lkICAgICAgICAgICAgKCpvZmZsaW5lKSAoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK30gX19wb3J0X2FjdGlvbltdID0geworCXsKKwliZmFfZmNzX3BvcnRfdW5rbm93bl9pbml0LCBiZmFfZmNzX3BvcnRfdW5rbm93bl9vbmxpbmUsCisJCQliZmFfZmNzX3BvcnRfdW5rbm93bl9vZmZsaW5lfSwgeworCWJmYV9mY3NfcG9ydF9mYWJfaW5pdCwgYmZhX2Zjc19wb3J0X2ZhYl9vbmxpbmUsCisJCQliZmFfZmNzX3BvcnRfZmFiX29mZmxpbmV9LCB7CisJYmZhX2Zjc19wb3J0X2xvb3BfaW5pdCwgYmZhX2Zjc19wb3J0X2xvb3Bfb25saW5lLAorCQkJYmZhX2Zjc19wb3J0X2xvb3Bfb2ZmbGluZX0sIHsKK2JmYV9mY3NfcG9ydF9uMm5faW5pdCwgYmZhX2Zjc19wb3J0X24ybl9vbmxpbmUsCisJCQliZmFfZmNzX3BvcnRfbjJuX29mZmxpbmV9LH07CisKKy8qKgorICogIGZjc19wb3J0X3NtIEZDUyBsb2dpY2FsIHBvcnQgc3RhdGUgbWFjaGluZQorICovCisKK2VudW0gYmZhX2Zjc19wb3J0X2V2ZW50IHsKKwlCRkFfRkNTX1BPUlRfU01fQ1JFQVRFID0gMSwKKwlCRkFfRkNTX1BPUlRfU01fT05MSU5FID0gMiwKKwlCRkFfRkNTX1BPUlRfU01fT0ZGTElORSA9IDMsCisJQkZBX0ZDU19QT1JUX1NNX0RFTEVURSA9IDQsCisJQkZBX0ZDU19QT1JUX1NNX0RFTFJQT1JUID0gNSwKK307CisKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfc21fdW5pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkgICAgICAgZW51bSBiZmFfZmNzX3BvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9zbV9pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkgICAgIGVudW0gYmZhX2Zjc19wb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfc21fb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkgICAgICAgZW51bSBiZmFfZmNzX3BvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9zbV9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkJZW51bSBiZmFfZmNzX3BvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9zbV9kZWxldGluZyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQkJCSBlbnVtIGJmYV9mY3NfcG9ydF9ldmVudCBldmVudCk7CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc21fdW5pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCWVudW0gYmZhX2Zjc19wb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19QT1JUX1NNX0NSRUFURToKKwkJYmZhX3NtX3NldF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21faW5pdCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc21faW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIGVudW0gYmZhX2Zjc19wb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19QT1JUX1NNX09OTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21fb25saW5lKTsKKwkJYmZhX2Zjc19wb3J0X29ubGluZV9hY3Rpb25zKHBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19QT1JUX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21fdW5pbml0KTsKKwkJYmZhX2Zjc19wb3J0X2RlbGV0ZWQocG9ydCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc21fb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCWVudW0gYmZhX2Zjc19wb3J0X2V2ZW50IGV2ZW50KQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OworCXN0cnVjdCBsaXN0X2hlYWQgKnFlLCAqcWVuOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMocG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX1BPUlRfU01fT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21fb2ZmbGluZSk7CisJCWJmYV9mY3NfcG9ydF9vZmZsaW5lX2FjdGlvbnMocG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1BPUlRfU01fREVMRVRFOgorCisJCV9fcG9ydF9hY3Rpb25bcG9ydC0+ZmFicmljLT5mYWJfdHlwZV0ub2ZmbGluZShwb3J0KTsKKworCQlpZiAocG9ydC0+bnVtX3Jwb3J0cyA9PSAwKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHBvcnQsIGJmYV9mY3NfcG9ydF9zbV91bmluaXQpOworCQkJYmZhX2Zjc19wb3J0X2RlbGV0ZWQocG9ydCk7CisJCX0gZWxzZSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHBvcnQsIGJmYV9mY3NfcG9ydF9zbV9kZWxldGluZyk7CisJCQlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJnBvcnQtPnJwb3J0X3EpIHsKKwkJCQlycG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopcWU7CisJCQkJYmZhX2Zjc19ycG9ydF9kZWxldGUocnBvcnQpOworCQkJfQorCQl9CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1BPUlRfU01fREVMUlBPUlQ6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQllbnVtIGJmYV9mY3NfcG9ydF9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICpxZSwgKnFlbjsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19QT1JUX1NNX09OTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21fb25saW5lKTsKKwkJYmZhX2Zjc19wb3J0X29ubGluZV9hY3Rpb25zKHBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19QT1JUX1NNX0RFTEVURToKKwkJaWYgKHBvcnQtPm51bV9ycG9ydHMgPT0gMCkgeworCQkJYmZhX3NtX3NldF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21fdW5pbml0KTsKKwkJCWJmYV9mY3NfcG9ydF9kZWxldGVkKHBvcnQpOworCQl9IGVsc2UgeworCQkJYmZhX3NtX3NldF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21fZGVsZXRpbmcpOworCQkJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZwb3J0LT5ycG9ydF9xKSB7CisJCQkJcnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqKXFlOworCQkJCWJmYV9mY3NfcnBvcnRfZGVsZXRlKHJwb3J0KTsKKwkJCX0KKwkJfQorCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19QT1JUX1NNX0RFTFJQT1JUOgorCWNhc2UgQkZBX0ZDU19QT1JUX1NNX09GRkxJTkU6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc21fZGVsZXRpbmcoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJIGVudW0gYmZhX2Zjc19wb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19QT1JUX1NNX0RFTFJQT1JUOgorCQlpZiAocG9ydC0+bnVtX3Jwb3J0cyA9PSAwKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHBvcnQsIGJmYV9mY3NfcG9ydF9zbV91bmluaXQpOworCQkJYmZhX2Zjc19wb3J0X2RlbGV0ZWQocG9ydCk7CisJCX0KKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworCisKKy8qKgorICogIGZjc19wb3J0X3B2dAorICovCisKKy8qKgorICogU2VuZCBBRU4gbm90aWZpY2F0aW9uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfYWVuX3Bvc3Qoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkgICAgICBlbnVtIGJmYV9scG9ydF9hZW5fZXZlbnQgZXZlbnQpCit7CisJdW5pb24gYmZhX2Flbl9kYXRhX3UgYWVuX2RhdGE7CisJc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ21vZCA9IHBvcnQtPmZjcy0+bG9nbTsKKwllbnVtIGJmYV9wb3J0X3JvbGUgcm9sZSA9IHBvcnQtPnBvcnRfY2ZnLnJvbGVzOworCXd3bl90ICAgICAgICAgICBscHd3biA9IGJmYV9mY3NfcG9ydF9nZXRfcHd3bihwb3J0KTsKKwljaGFyICAgICAgICAgICAgbHB3d25fcHRyW0JGQV9TVFJJTkdfMzJdOworCWNoYXIgICAgICAgICAgICpyb2xlX3N0cltCRkFfUE9SVF9ST0xFX0ZDUF9NQVggLyAyICsgMV0gPQorCQl7ICJJbml0aWF0b3IiLCAiVGFyZ2V0IiwgIklQRkMiIH07CisKKwl3d24yc3RyKGxwd3duX3B0ciwgbHB3d24pOworCisJYmZhX2Fzc2VydChyb2xlIDw9IEJGQV9QT1JUX1JPTEVfRkNQX01BWCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfTFBPUlRfQUVOX09OTElORToKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fTFBPUlRfT05MSU5FLCBscHd3bl9wdHIsCisJCQlyb2xlX3N0cltyb2xlIC8gMl0pOworCQlicmVhazsKKwljYXNlIEJGQV9MUE9SVF9BRU5fT0ZGTElORToKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fTFBPUlRfT0ZGTElORSwgbHB3d25fcHRyLAorCQkJcm9sZV9zdHJbcm9sZSAvIDJdKTsKKwkJYnJlYWs7CisJY2FzZSBCRkFfTFBPUlRfQUVOX05FVzoKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fTFBPUlRfTkVXLCBscHd3bl9wdHIsCisJCQlyb2xlX3N0cltyb2xlIC8gMl0pOworCQlicmVhazsKKwljYXNlIEJGQV9MUE9SVF9BRU5fREVMRVRFOgorCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9MUE9SVF9ERUxFVEUsIGxwd3duX3B0ciwKKwkJCXJvbGVfc3RyW3JvbGUgLyAyXSk7CisJCWJyZWFrOworCWNhc2UgQkZBX0xQT1JUX0FFTl9ESVNDT05ORUNUOgorCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9MUE9SVF9ESVNDT05ORUNULCBscHd3bl9wdHIsCisJCQlyb2xlX3N0cltyb2xlIC8gMl0pOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisKKwlhZW5fZGF0YS5scG9ydC52Zl9pZCA9IHBvcnQtPmZhYnJpYy0+dmZfaWQ7CisJYWVuX2RhdGEubHBvcnQucm9sZXMgPSByb2xlOworCWFlbl9kYXRhLmxwb3J0LnBwd3duID0KKwkJYmZhX2Zjc19wb3J0X2dldF9wd3duKGJmYV9mY3NfZ2V0X2Jhc2VfcG9ydChwb3J0LT5mY3MpKTsKKwlhZW5fZGF0YS5scG9ydC5scHd3biA9IGxwd3duOworfQorCisvKgorICogU2VuZCBhIExTIHJlamVjdAorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X3NlbmRfbHNfcmp0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwgc3RydWN0IGZjaHNfcyAqcnhfZmNocywKKwkJCSB1OCByZWFzb25fY29kZSwgdTggcmVhc29uX2NvZGVfZXhwbCkKK3sKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJc3RydWN0IGJmYV9ycG9ydF9zICpiZmFfcnBvcnQgPSBOVUxMOworCWludCAgICAgICAgICAgICBsZW47CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcnhfZmNocy0+c19pZCk7CisKKwlmY3hwID0gYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKQorCQlyZXR1cm47CisKKwlsZW4gPSBmY19sc19yanRfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksIHJ4X2ZjaHMtPnNfaWQsCisJCQkgICAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIHJ4X2ZjaHMtPm94X2lkLAorCQkJICAgICAgcmVhc29uX2NvZGUsIHJlYXNvbl9jb2RlX2V4cGwpOworCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBiZmFfcnBvcnQsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywKKwkJICAgICAgQkZBX0ZBTFNFLCBGQ19DTEFTU18zLCBsZW4sICZmY2hzLCBOVUxMLCBOVUxMLAorCQkgICAgICBGQ19NQVhfUERVU1osIDApOworfQorCisvKioKKyAqIFByb2Nlc3MgaW5jb21pbmcgcGxvZ2kgZnJvbSBhIHJlbW90ZSBwb3J0LgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X3Bsb2dpKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwgc3RydWN0IGZjaHNfcyAqcnhfZmNocywKKwkJCXN0cnVjdCBmY19sb2dpX3MgKnBsb2dpKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHJ4X2ZjaHMtPmRfaWQpOworCWJmYV90cmMocG9ydC0+ZmNzLCByeF9mY2hzLT5zX2lkKTsKKworCS8qCisJICogSWYgbWluIGNmZyBtb2RlIGlzIGVuYWJsZWQsIGRyb3AgYW55IGluY29taW5nIFBMT0dJcworCSAqLworCWlmIChfX2Zjc19taW5fY2ZnKHBvcnQtPmZjcykpIHsKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIHJ4X2ZjaHMtPnNfaWQpOworCQlyZXR1cm47CisJfQorCisJaWYgKGZjX3Bsb2dpX3BhcnNlKHJ4X2ZjaHMpICE9IEZDX1BBUlNFX09LKSB7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByeF9mY2hzLT5zX2lkKTsKKwkJLyoKKwkJICogc2VuZCBhIExTIHJlamVjdAorCQkgKi8KKwkJYmZhX2Zjc19wb3J0X3NlbmRfbHNfcmp0KHBvcnQsIHJ4X2ZjaHMsCisJCQkJCSBGQ19MU19SSlRfUlNOX1BST1RPQ09MX0VSUk9SLAorCQkJCQkgRkNfTFNfUkpUX0VYUF9TUEFSTVNfRVJSX09QVElPTlMpOworCQlyZXR1cm47CisJfQorCisJLyoqCisqIERpcmVjdCBBdHRhY2ggUDJQIG1vZGUgOiB2ZXJpZnkgYWRkcmVzcyBhc3NpZ25lZCBieSB0aGUgci1wb3J0LgorCSAqLworCWlmICgoIWJmYV9mY3NfZmFicmljX2lzX3N3aXRjaGVkKHBvcnQtPmZhYnJpYykpCisJICAgICYmCisJICAgIChtZW1jbXAKKwkgICAgICgodm9pZCAqKSZiZmFfZmNzX3BvcnRfZ2V0X3B3d24ocG9ydCksICh2b2lkICopJnBsb2dpLT5wb3J0X25hbWUsCisJICAgICAgc2l6ZW9mKHd3bl90KSkgPCAwKSkgeworCQlpZiAoQkZBX0ZDU19QSURfSVNfV0tBKHJ4X2ZjaHMtPmRfaWQpKSB7CisJCQkvKgorCQkJICogQWRkcmVzcyBhc3NpZ25lZCB0byB1cyBjYW5ub3QgYmUgYSBXS0EKKwkJCSAqLworCQkJYmZhX2Zjc19wb3J0X3NlbmRfbHNfcmp0KHBvcnQsIHJ4X2ZjaHMsCisJCQkJCUZDX0xTX1JKVF9SU05fUFJPVE9DT0xfRVJST1IsCisJCQkJCUZDX0xTX1JKVF9FWFBfSU5WQUxJRF9OUE9SVF9JRCk7CisJCQlyZXR1cm47CisJCX0KKwkJcG9ydC0+cGlkID0gcnhfZmNocy0+ZF9pZDsKKwl9CisKKwkvKioKKwkgKiBGaXJzdCwgY2hlY2sgaWYgd2Uga25vdyB0aGUgZGV2aWNlIGJ5IHB3d24uCisJICovCisJcnBvcnQgPSBiZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0X2J5X3B3d24ocG9ydCwgcGxvZ2ktPnBvcnRfbmFtZSk7CisJaWYgKHJwb3J0KSB7CisJCS8qKgorCQkgKiBEaXJlY3QgQXR0YWNoIFAyUCBtb2RlOiBoYW5kbGUgYWRkcmVzcyBhc3NpZ25lZCBieSB0aGUgcnBvcnQuCisJCSAqLworCQlpZiAoKCFiZmFfZmNzX2ZhYnJpY19pc19zd2l0Y2hlZChwb3J0LT5mYWJyaWMpKQorCQkgICAgJiYKKwkJICAgIChtZW1jbXAKKwkJICAgICAoKHZvaWQgKikmYmZhX2Zjc19wb3J0X2dldF9wd3duKHBvcnQpLAorCQkgICAgICAodm9pZCAqKSZwbG9naS0+cG9ydF9uYW1lLCBzaXplb2Yod3duX3QpKSA8IDApKSB7CisJCQlwb3J0LT5waWQgPSByeF9mY2hzLT5kX2lkOworCQkJcnBvcnQtPnBpZCA9IHJ4X2ZjaHMtPnNfaWQ7CisJCX0KKwkJYmZhX2Zjc19ycG9ydF9wbG9naShycG9ydCwgcnhfZmNocywgcGxvZ2kpOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogTmV4dCwgbG9va3VwIHJwb3J0IGJ5IFBJRC4KKwkgKi8KKwlycG9ydCA9IGJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfYnlfcGlkKHBvcnQsIHJ4X2ZjaHMtPnNfaWQpOworCWlmICghcnBvcnQpIHsKKwkJLyoqCisJCSAqIEluYm91bmQgUExPR0kgZnJvbSBhIG5ldyBkZXZpY2UuCisJCSAqLworCQliZmFfZmNzX3Jwb3J0X3Bsb2dpX2NyZWF0ZShwb3J0LCByeF9mY2hzLCBwbG9naSk7CisJCXJldHVybjsKKwl9CisKKwkvKioKKwkgKiBScG9ydCBpcyBrbm93biBvbmx5IGJ5IFBJRC4KKwkgKi8KKwlpZiAocnBvcnQtPnB3d24pIHsKKwkJLyoqCisJCSAqIFRoaXMgaXMgYSBkaWZmZXJlbnQgZGV2aWNlIHdpdGggdGhlIHNhbWUgcGlkLiBPbGQgZGV2aWNlCisJCSAqIGRpc2FwcGVhcmVkLiBTZW5kIGltcGxpY2l0IExPR08gdG8gb2xkIGRldmljZS4KKwkJICovCisJCWJmYV9hc3NlcnQocnBvcnQtPnB3d24gIT0gcGxvZ2ktPnBvcnRfbmFtZSk7CisJCWJmYV9mY3NfcnBvcnRfbG9nb19pbXAocnBvcnQpOworCisJCS8qKgorCQkgKiBJbmJvdW5kIFBMT0dJIGZyb20gYSBuZXcgZGV2aWNlICh3aXRoIG9sZCBQSUQpLgorCQkgKi8KKwkJYmZhX2Zjc19ycG9ydF9wbG9naV9jcmVhdGUocG9ydCwgcnhfZmNocywgcGxvZ2kpOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogUExPR0kgY3Jvc3NpbmcgZWFjaCBvdGhlci4KKwkgKi8KKwliZmFfYXNzZXJ0KHJwb3J0LT5wd3duID09IFdXTl9OVUxMKTsKKwliZmFfZmNzX3Jwb3J0X3Bsb2dpKHJwb3J0LCByeF9mY2hzLCBwbG9naSk7Cit9CisKKy8qCisgKiBQcm9jZXNzIGluY29taW5nIEVDSE8uCisgKiBTaW5jZSBpdCBkb2VzIG5vdCByZXF1aXJlIGEgbG9naW4sIGl0IGlzIHByb2Nlc3NlZCBoZXJlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2VjaG8oc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCBzdHJ1Y3QgZmNoc19zICpyeF9mY2hzLAorCQkJc3RydWN0IGZjX2VjaG9fcyAqZWNobywgdTE2IHJ4X2xlbikKK3sKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJc3RydWN0IGJmYV9ycG9ydF9zICpiZmFfcnBvcnQgPSBOVUxMOworCWludCAgICAgICAgICAgICBsZW4sIHB5bGRfbGVuOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHJ4X2ZjaHMtPnNfaWQpOworCWJmYV90cmMocG9ydC0+ZmNzLCByeF9mY2hzLT5kX2lkKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgcnhfbGVuKTsKKworCWZjeHAgPSBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApCisJCXJldHVybjsKKworCWxlbiA9IGZjX2xzX2FjY19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgcnhfZmNocy0+c19pZCwKKwkJCSAgICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgcnhfZmNocy0+b3hfaWQpOworCisJLyoKKwkgKiBDb3B5IHRoZSBwYXlsb2FkIChpZiBhbnkpIGZyb20gdGhlIGVjaG8gZnJhbWUKKwkgKi8KKwlweWxkX2xlbiA9IHJ4X2xlbiAtIHNpemVvZihzdHJ1Y3QgZmNoc19zKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgcHlsZF9sZW4pOworCisJaWYgKHB5bGRfbGVuID4gbGVuKQorCQltZW1jcHkoKCh1OCAqKSBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApKSArCisJCSAgICAgICBzaXplb2Yoc3RydWN0IGZjX2VjaG9fcyksIChlY2hvICsgMSksCisJCSAgICAgICAocHlsZF9sZW4gLSBzaXplb2Yoc3RydWN0IGZjX2VjaG9fcykpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgYmZhX3Jwb3J0LCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsCisJCSAgICAgIEJGQV9GQUxTRSwgRkNfQ0xBU1NfMywgcHlsZF9sZW4sICZmY2hzLCBOVUxMLCBOVUxMLAorCQkgICAgICBGQ19NQVhfUERVU1osIDApOworfQorCisvKgorICogUHJvY2VzcyBpbmNvbWluZyBSTklELgorICogU2luY2UgaXQgZG9lcyBub3QgcmVxdWlyZSBhIGxvZ2luLCBpdCBpcyBwcm9jZXNzZWQgaGVyZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9ybmlkKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwgc3RydWN0IGZjaHNfcyAqcnhfZmNocywKKwkJCXN0cnVjdCBmY19ybmlkX2NtZF9zICpybmlkLCB1MTYgcnhfbGVuKQoreworCXN0cnVjdCBmY19ybmlkX2NvbW1vbl9pZF9kYXRhX3MgY29tbW9uX2lkX2RhdGE7CisJc3RydWN0IGZjX3JuaWRfZ2VuZXJhbF90b3BvbG9neV9kYXRhX3MgZ2VuX3RvcG9fZGF0YTsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJc3RydWN0IGJmYV9ycG9ydF9zICpiZmFfcnBvcnQgPSBOVUxMOworCXUxNiAgICAgICAgbGVuOworCXUzMiAgICAgICAgZGF0YV9mb3JtYXQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcnhfZmNocy0+c19pZCk7CisJYmZhX3RyYyhwb3J0LT5mY3MsIHJ4X2ZjaHMtPmRfaWQpOworCWJmYV90cmMocG9ydC0+ZmNzLCByeF9sZW4pOworCisJZmN4cCA9IGJmYV9mY3NfZmN4cF9hbGxvYyhwb3J0LT5mY3MpOworCWlmICghZmN4cCkKKwkJcmV0dXJuOworCisJLyoKKwkgKiBDaGVjayBOb2RlIEluZGVudGlmaWNhdGlvbiBEYXRhIEZvcm1hdAorCSAqIFdlIG9ubHkgc3VwcG9ydCBHZW5lcmFsIFRvcG9sb2d5IERpc2NvdmVyeSBGb3JtYXQuCisJICogRm9yIGFueSBvdGhlciByZXF1ZXN0ZWQgRGF0YSBGb3JtYXRzLCB3ZSByZXR1cm4gQ29tbW9uIE5vZGUgSWQgRGF0YQorCSAqIG9ubHksIGFzIHBlciBGQy1MUy4KKwkgKi8KKwliZmFfdHJjKHBvcnQtPmZjcywgcm5pZC0+bm9kZV9pZF9kYXRhX2Zvcm1hdCk7CisJaWYgKHJuaWQtPm5vZGVfaWRfZGF0YV9mb3JtYXQgPT0gUk5JRF9OT0RFSURfREFUQV9GT1JNQVRfRElTQ09WRVJZKSB7CisJCWRhdGFfZm9ybWF0ID0gUk5JRF9OT0RFSURfREFUQV9GT1JNQVRfRElTQ09WRVJZOworCQkvKgorCQkgKiBHZXQgR2VuZXJhbCB0b3BvbG9neSBkYXRhIGZvciB0aGlzIHBvcnQKKwkJICovCisJCWJmYV9mc19wb3J0X2dldF9nZW5fdG9wb19kYXRhKHBvcnQsICZnZW5fdG9wb19kYXRhKTsKKwl9IGVsc2UgeworCQlkYXRhX2Zvcm1hdCA9IFJOSURfTk9ERUlEX0RBVEFfRk9STUFUX0NPTU1PTjsKKwl9CisKKwkvKgorCSAqIENvcHkgdGhlIE5vZGUgSWQgSW5mbworCSAqLworCWNvbW1vbl9pZF9kYXRhLnBvcnRfbmFtZSA9IGJmYV9mY3NfcG9ydF9nZXRfcHd3bihwb3J0KTsKKwljb21tb25faWRfZGF0YS5ub2RlX25hbWUgPSBiZmFfZmNzX3BvcnRfZ2V0X253d24ocG9ydCk7CisKKwlsZW4gPSBmY19ybmlkX2FjY19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgcnhfZmNocy0+c19pZCwKKwkJCQliZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIHJ4X2ZjaHMtPm94X2lkLAorCQkJCWRhdGFfZm9ybWF0LCAmY29tbW9uX2lkX2RhdGEsICZnZW5fdG9wb19kYXRhKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgYmZhX3Jwb3J0LCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsCisJCSAgICAgIEJGQV9GQUxTRSwgRkNfQ0xBU1NfMywgbGVuLCAmZmNocywgTlVMTCwgTlVMTCwKKwkJICAgICAgRkNfTUFYX1BEVVNaLCAwKTsKKworCXJldHVybjsKK30KKworLyoKKyAqICBGaWxsIG91dCBHZW5lcmFsIFRvcG9scGd5IERpc2NvdmVyeSBEYXRhIGZvciBSTklEIEVMUy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mc19wb3J0X2dldF9nZW5fdG9wb19kYXRhKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXN0cnVjdCBmY19ybmlkX2dlbmVyYWxfdG9wb2xvZ3lfZGF0YV9zICpnZW5fdG9wb19kYXRhKQoreworCisJYmZhX29zX21lbXNldChnZW5fdG9wb19kYXRhLCAwLAorCQkgICAgICBzaXplb2Yoc3RydWN0IGZjX3JuaWRfZ2VuZXJhbF90b3BvbG9neV9kYXRhX3MpKTsKKworCWdlbl90b3BvX2RhdGEtPmFzc29fdHlwZSA9IGJmYV9vc19odG9ubChSTklEX0FTU09DSUFURURfVFlQRV9IT1NUKTsKKwlnZW5fdG9wb19kYXRhLT5waHlfcG9ydF9udW0gPSAwOwkvKiBAdG9kbyAqLworCWdlbl90b3BvX2RhdGEtPm51bV9hdHRhY2hlZF9ub2RlcyA9IGJmYV9vc19odG9ubCgxKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9vbmxpbmVfYWN0aW9ucyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPmZhYnJpYy0+b3Blcl90eXBlKTsKKworCV9fcG9ydF9hY3Rpb25bcG9ydC0+ZmFicmljLT5mYWJfdHlwZV0uaW5pdChwb3J0KTsKKwlfX3BvcnRfYWN0aW9uW3BvcnQtPmZhYnJpYy0+ZmFiX3R5cGVdLm9ubGluZShwb3J0KTsKKworCWJmYV9mY3NfcG9ydF9hZW5fcG9zdChwb3J0LCBCRkFfTFBPUlRfQUVOX09OTElORSk7CisJYmZhX2ZjYl9wb3J0X29ubGluZShwb3J0LT5mY3MtPmJmYWQsIHBvcnQtPnBvcnRfY2ZnLnJvbGVzLAorCQkJcG9ydC0+ZmFicmljLT52Zl9kcnYsIChwb3J0LT52cG9ydCA9PSBOVUxMKSA/CisJCQlOVUxMIDogcG9ydC0+dnBvcnQtPnZwb3J0X2Rydik7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfb2ZmbGluZV9hY3Rpb25zKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpxZSwgKnFlbjsKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5mYWJyaWMtPm9wZXJfdHlwZSk7CisKKwlfX3BvcnRfYWN0aW9uW3BvcnQtPmZhYnJpYy0+ZmFiX3R5cGVdLm9mZmxpbmUocG9ydCk7CisKKwlpZiAoYmZhX2Zjc19mYWJyaWNfaXNfb25saW5lKHBvcnQtPmZhYnJpYykgPT0gQkZBX1RSVUUpIHsKKwkJYmZhX2Zjc19wb3J0X2Flbl9wb3N0KHBvcnQsIEJGQV9MUE9SVF9BRU5fRElTQ09OTkVDVCk7CisJfSBlbHNlIHsKKwkJYmZhX2Zjc19wb3J0X2Flbl9wb3N0KHBvcnQsIEJGQV9MUE9SVF9BRU5fT0ZGTElORSk7CisJfQorCWJmYV9mY2JfcG9ydF9vZmZsaW5lKHBvcnQtPmZjcy0+YmZhZCwgcG9ydC0+cG9ydF9jZmcucm9sZXMsCisJCQlwb3J0LT5mYWJyaWMtPnZmX2RydiwKKwkJCShwb3J0LT52cG9ydCA9PSBOVUxMKSA/IE5VTEwgOiBwb3J0LT52cG9ydC0+dnBvcnRfZHJ2KTsKKworCWxpc3RfZm9yX2VhY2hfc2FmZShxZSwgcWVuLCAmcG9ydC0+cnBvcnRfcSkgeworCQlycG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopcWU7CisJCWJmYV9mY3NfcnBvcnRfb2ZmbGluZShycG9ydCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X3Vua25vd25faW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisJYmZhX2Fzc2VydCgwKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF91bmtub3duX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisJYmZhX2Fzc2VydCgwKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF91bmtub3duX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCWJmYV9hc3NlcnQoMCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfZGVsZXRlZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisJYmZhX2Zjc19wb3J0X2Flbl9wb3N0KHBvcnQsIEJGQV9MUE9SVF9BRU5fREVMRVRFKTsKKworCS8qCisJICogQmFzZSBwb3J0IHdpbGwgYmUgZGVsZXRlZCBieSB0aGUgT1MgZHJpdmVyCisJICovCisJaWYgKHBvcnQtPnZwb3J0KSB7CisJCWJmYV9mY2JfcG9ydF9kZWxldGUocG9ydC0+ZmNzLT5iZmFkLCBwb3J0LT5wb3J0X2NmZy5yb2xlcywKKwkJCXBvcnQtPmZhYnJpYy0+dmZfZHJ2LAorCQkJcG9ydC0+dnBvcnQgPyBwb3J0LT52cG9ydC0+dnBvcnRfZHJ2IDogTlVMTCk7CisJCWJmYV9mY3NfdnBvcnRfZGVsZXRlX2NvbXAocG9ydC0+dnBvcnQpOworCX0gZWxzZSB7CisJCWJmYV9mY3NfZmFicmljX3BvcnRfZGVsZXRlX2NvbXAocG9ydC0+ZmFicmljKTsKKwl9Cit9CisKKworCisvKioKKyAqICBmY3NfbHBvcnRfYXBpIEJGQSBGQ1MgcG9ydCBBUEkKKyAqLworLyoqCisgKiAgIE1vZHVsZSBpbml0aWFsaXphdGlvbgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfbW9kaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7CisKK30KKworLyoqCisgKiAgIE1vZHVsZSBjbGVhbnVwCisgKi8KK3ZvaWQKK2JmYV9mY3NfcG9ydF9tb2RleGl0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcykKK3sKKwliZmFfZmNzX21vZGV4aXRfY29tcChmY3MpOworfQorCisvKioKKyAqIAkJVW5zb2xpY2l0ZWQgZnJhbWUgcmVjZWl2ZSBoYW5kbGluZy4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X3VmX3JlY3Yoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpscG9ydCwgc3RydWN0IGZjaHNfcyAqZmNocywKKwkJCXUxNiBsZW4pCit7CisJdTMyICAgICAgICBwaWQgPSBmY2hzLT5zX2lkOworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gTlVMTDsKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgKmVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSAoZmNocyArIDEpOworCisJYmZhX3N0YXRzKGxwb3J0LCB1Zl9yZWN2cyk7CisKKwlpZiAoIWJmYV9mY3NfcG9ydF9pc19vbmxpbmUobHBvcnQpKSB7CisJCWJmYV9zdGF0cyhscG9ydCwgdWZfcmVjdl9kcm9wcyk7CisJCXJldHVybjsKKwl9CisKKwkvKioKKwkgKiBGaXJzdCwgaGFuZGxlIEVMU3MgdGhhdCBkb25vdCByZXF1aXJlIGEgbG9naW4uCisJICovCisJLyoKKwkgKiBIYW5kbGUgUExPR0kgZmlyc3QKKwkgKi8KKwlpZiAoKGZjaHMtPnR5cGUgPT0gRkNfVFlQRV9FTFMpICYmCisJCShlbHNfY21kLT5lbHNfY29kZSA9PSBGQ19FTFNfUExPR0kpKSB7CisJCWJmYV9mY3NfcG9ydF9wbG9naShscG9ydCwgZmNocywgKHN0cnVjdCBmY19sb2dpX3MgKikgZWxzX2NtZCk7CisJCXJldHVybjsKKwl9CisKKwkvKgorCSAqIEhhbmRsZSBFQ0hPIHNlcGFyYXRlbHkuCisJICovCisJaWYgKChmY2hzLT50eXBlID09IEZDX1RZUEVfRUxTKSAmJiAoZWxzX2NtZC0+ZWxzX2NvZGUgPT0gRkNfRUxTX0VDSE8pKSB7CisJCWJmYV9mY3NfcG9ydF9lY2hvKGxwb3J0LCBmY2hzLAorCQkJKHN0cnVjdCBmY19lY2hvX3MgKikgZWxzX2NtZCwgbGVuKTsKKwkJcmV0dXJuOworCX0KKworCS8qCisJICogSGFuZGxlIFJOSUQgc2VwYXJhdGVseS4KKwkgKi8KKwlpZiAoKGZjaHMtPnR5cGUgPT0gRkNfVFlQRV9FTFMpICYmIChlbHNfY21kLT5lbHNfY29kZSA9PSBGQ19FTFNfUk5JRCkpIHsKKwkJYmZhX2Zjc19wb3J0X3JuaWQobHBvcnQsIGZjaHMsCisJCQkoc3RydWN0IGZjX3JuaWRfY21kX3MgKikgZWxzX2NtZCwgbGVuKTsKKwkJcmV0dXJuOworCX0KKworCS8qKgorCSAqIGxvb2sgZm9yIGEgbWF0Y2hpbmcgcmVtb3RlIHBvcnQgSUQKKwkgKi8KKwlycG9ydCA9IGJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfYnlfcGlkKGxwb3J0LCBwaWQpOworCWlmIChycG9ydCkgeworCQliZmFfdHJjKHJwb3J0LT5mY3MsIGZjaHMtPnNfaWQpOworCQliZmFfdHJjKHJwb3J0LT5mY3MsIGZjaHMtPmRfaWQpOworCQliZmFfdHJjKHJwb3J0LT5mY3MsIGZjaHMtPnR5cGUpOworCisJCWJmYV9mY3NfcnBvcnRfdWZfcmVjdihycG9ydCwgZmNocywgbGVuKTsKKwkJcmV0dXJuOworCX0KKworCS8qKgorCSAqIE9ubHkgaGFuZGxlcyBFTFMgZnJhbWVzIGZvciBub3cuCisJICovCisJaWYgKGZjaHMtPnR5cGUgIT0gRkNfVFlQRV9FTFMpIHsKKwkJYmZhX3RyYyhscG9ydC0+ZmNzLCBmY2hzLT50eXBlKTsKKwkJYmZhX2Fzc2VydCgwKTsKKwkJcmV0dXJuOworCX0KKworCWJmYV90cmMobHBvcnQtPmZjcywgZWxzX2NtZC0+ZWxzX2NvZGUpOworCWlmIChlbHNfY21kLT5lbHNfY29kZSA9PSBGQ19FTFNfUlNDTikgeworCQliZmFfZmNzX3BvcnRfc2NuX3Byb2Nlc3NfcnNjbihscG9ydCwgZmNocywgbGVuKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChlbHNfY21kLT5lbHNfY29kZSA9PSBGQ19FTFNfTE9HTykgeworCQkvKioKKwkJICogQHRvZG8gSGFuZGxlIExPR08gZnJhbWVzIHJlY2VpdmVkLgorCQkgKi8KKwkJYmZhX3RyYyhscG9ydC0+ZmNzLCBlbHNfY21kLT5lbHNfY29kZSk7CisJCXJldHVybjsKKwl9CisKKwlpZiAoZWxzX2NtZC0+ZWxzX2NvZGUgPT0gRkNfRUxTX1BSTEkpIHsKKwkJLyoqCisJCSAqIEB0b2RvIEhhbmRsZSBQUkxJIGZyYW1lcyByZWNlaXZlZC4KKwkJICovCisJCWJmYV90cmMobHBvcnQtPmZjcywgZWxzX2NtZC0+ZWxzX2NvZGUpOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogVW5oYW5kbGVkIEVMUyBmcmFtZXMuIFNlbmQgYSBMU19SSlQuCisJICovCisJYmZhX2Zjc19wb3J0X3NlbmRfbHNfcmp0KGxwb3J0LCBmY2hzLCBGQ19MU19SSlRfUlNOX0NNRF9OT1RfU1VQUCwKKwkJCQkgRkNfTFNfUkpUX0VYUF9OT19BRERMX0lORk8pOworCit9CisKKy8qKgorICogICBQSUQgYmFzZWQgTG9va3VwIGZvciBhIFItUG9ydCBpbiB0aGUgUG9ydCBSLVBvcnQgUXVldWUKKyAqLworc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqCitiZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0X2J5X3BpZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHUzMiBwaWQpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQ7CisJc3RydWN0IGxpc3RfaGVhZCAqcWU7CisKKwlsaXN0X2Zvcl9lYWNoKHFlLCAmcG9ydC0+cnBvcnRfcSkgeworCQlycG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopcWU7CisJCWlmIChycG9ydC0+cGlkID09IHBpZCkKKwkJCXJldHVybiBycG9ydDsKKwl9CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcGlkKTsKKwlyZXR1cm4gTlVMTDsKK30KKworLyoqCisgKiAgIFBXV04gYmFzZWQgTG9va3VwIGZvciBhIFItUG9ydCBpbiB0aGUgUG9ydCBSLVBvcnQgUXVldWUKKyAqLworc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqCitiZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0X2J5X3B3d24oc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBwd3duKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OworCXN0cnVjdCBsaXN0X2hlYWQgKnFlOworCisJbGlzdF9mb3JfZWFjaChxZSwgJnBvcnQtPnJwb3J0X3EpIHsKKwkJcnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqKXFlOworCQlpZiAod3duX2lzX2VxdWFsKHJwb3J0LT5wd3duLCBwd3duKSkKKwkJCXJldHVybiBycG9ydDsKKwl9CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcHd3bik7CisJcmV0dXJuIChOVUxMKTsKK30KKworLyoqCisgKiAgIE5XV04gYmFzZWQgTG9va3VwIGZvciBhIFItUG9ydCBpbiB0aGUgUG9ydCBSLVBvcnQgUXVldWUKKyAqLworc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqCitiZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0X2J5X253d24oc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBud3duKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OworCXN0cnVjdCBsaXN0X2hlYWQgKnFlOworCisJbGlzdF9mb3JfZWFjaChxZSwgJnBvcnQtPnJwb3J0X3EpIHsKKwkJcnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqKXFlOworCQlpZiAod3duX2lzX2VxdWFsKHJwb3J0LT5ud3duLCBud3duKSkKKwkJCXJldHVybiBycG9ydDsKKwl9CisKKwliZmFfdHJjKHBvcnQtPmZjcywgbnd3bik7CisJcmV0dXJuIChOVUxMKTsKK30KKworLyoqCisgKiBDYWxsZWQgYnkgcnBvcnQgbW9kdWxlIHdoZW4gbmV3IHJwb3J0cyBhcmUgZGlzY292ZXJlZC4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2FkZF9ycG9ydChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCSAgICAgICBzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwlsaXN0X2FkZF90YWlsKCZycG9ydC0+cWUsICZwb3J0LT5ycG9ydF9xKTsKKwlwb3J0LT5udW1fcnBvcnRzKys7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IHJwb3J0IG1vZHVsZSB0byB3aGVuIHJwb3J0cyBhcmUgZGVsZXRlZC4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2RlbF9ycG9ydChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCSAgICAgICBzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwliZmFfYXNzZXJ0KGJmYV9xX2lzX29uX3EoJnBvcnQtPnJwb3J0X3EsIHJwb3J0KSk7CisJbGlzdF9kZWwoJnJwb3J0LT5xZSk7CisJcG9ydC0+bnVtX3Jwb3J0cy0tOworCisJYmZhX3NtX3NlbmRfZXZlbnQocG9ydCwgQkZBX0ZDU19QT1JUX1NNX0RFTFJQT1JUKTsKK30KKworLyoqCisgKiBDYWxsZWQgYnkgZmFicmljIGZvciBiYXNlIHBvcnQgd2hlbiBmYWJyaWMgbG9naW4gaXMgY29tcGxldGUuCisgKiBDYWxsZWQgYnkgdnBvcnQgZm9yIHZpcnR1YWwgcG9ydHMgd2hlbiBGRElTQyBpcyBjb21wbGV0ZS4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisJYmZhX3NtX3NlbmRfZXZlbnQocG9ydCwgQkZBX0ZDU19QT1JUX1NNX09OTElORSk7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IGZhYnJpYyBmb3IgYmFzZSBwb3J0IHdoZW4gZmFicmljIGdvZXMgb2ZmbGluZS4KKyAqIENhbGxlZCBieSB2cG9ydCBmb3IgdmlydHVhbCBwb3J0cyB3aGVuIHZpcnR1YWwgcG9ydCBiZWNvbWVzIG9mZmxpbmUuCisgKi8KK3ZvaWQKK2JmYV9mY3NfcG9ydF9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudChwb3J0LCBCRkFfRkNTX1BPUlRfU01fT0ZGTElORSk7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IGZhYnJpYyB0byBkZWxldGUgYmFzZSBscG9ydCBhbmQgYXNzb2NpYXRlZCByZXNvdXJjZXMuCisgKgorICogQ2FsbGVkIGJ5IHZwb3J0IHRvIGRlbGV0ZSBscG9ydCBhbmQgYXNzb2NpYXRlZCByZXNvdXJjZXMuIFNob3VsZCBjYWxsCisgKiBiZmFfZmNzX3Zwb3J0X2RlbGV0ZV9jb21wKCkgZm9yIHZwb3J0cyBvbiBjb21wbGV0aW9uLgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfZGVsZXRlKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudChwb3J0LCBCRkFfRkNTX1BPUlRfU01fREVMRVRFKTsKK30KKworLyoqCisgKiBDYWxsZWQgYnkgZmFicmljIGluIHByaXZhdGUgbG9vcCB0b3BvbG9neSB0byBwcm9jZXNzIExJUCBldmVudC4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2xpcChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7Cit9CisKKy8qKgorICogUmV0dXJuIFRSVUUgaWYgcG9ydCBpcyBvbmxpbmUsIGVsc2UgcmV0dXJuIEZBTFNFCisgKi8KK2JmYV9ib29sZWFuX3QKK2JmYV9mY3NfcG9ydF9pc19vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXJldHVybiAoYmZhX3NtX2NtcF9zdGF0ZShwb3J0LCBiZmFfZmNzX3BvcnRfc21fb25saW5lKSk7Cit9CisKKy8qKgorICogTG9naWNhbCBwb3J0IGluaXRpYWxpemF0aW9uIG9mIGJhc2Ugb3IgdmlydHVhbCBwb3J0LgorICogQ2FsbGVkIGJ5IGZhYnJpYyBmb3IgYmFzZSBwb3J0IG9yIGJ5IHZwb3J0IGZvciB2aXJ0dWFsIHBvcnRzLgorICovCit2b2lkCitiZmFfZmNzX2xwb3J0X2luaXQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpscG9ydCwgc3RydWN0IGJmYV9mY3NfcyAqZmNzLAorCQkgICB1MTYgdmZfaWQsIHN0cnVjdCBiZmFfcG9ydF9jZmdfcyAqcG9ydF9jZmcsCisJCSAgIHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0KQoreworCWxwb3J0LT5mY3MgPSBmY3M7CisJbHBvcnQtPmZhYnJpYyA9IGJmYV9mY3NfdmZfbG9va3VwKGZjcywgdmZfaWQpOworCWJmYV9vc19hc3NpZ24obHBvcnQtPnBvcnRfY2ZnLCAqcG9ydF9jZmcpOworCWxwb3J0LT52cG9ydCA9IHZwb3J0OworCWxwb3J0LT5scF90YWcgPSAodnBvcnQpID8gYmZhX2xwc19nZXRfdGFnKHZwb3J0LT5scHMpIDoKKwkJCSBiZmFfbHBzX2dldF90YWcobHBvcnQtPmZhYnJpYy0+bHBzKTsKKworCUlOSVRfTElTVF9IRUFEKCZscG9ydC0+cnBvcnRfcSk7CisJbHBvcnQtPm51bV9ycG9ydHMgPSAwOworCisJbHBvcnQtPmJmYWRfcG9ydCA9CisJCWJmYV9mY2JfcG9ydF9uZXcoZmNzLT5iZmFkLCBscG9ydCwgbHBvcnQtPnBvcnRfY2ZnLnJvbGVzLAorCQkJCWxwb3J0LT5mYWJyaWMtPnZmX2RydiwKKwkJCQl2cG9ydCA/IHZwb3J0LT52cG9ydF9kcnYgOiBOVUxMKTsKKwliZmFfZmNzX3BvcnRfYWVuX3Bvc3QobHBvcnQsIEJGQV9MUE9SVF9BRU5fTkVXKTsKKworCWJmYV9zbV9zZXRfc3RhdGUobHBvcnQsIGJmYV9mY3NfcG9ydF9zbV91bmluaXQpOworCWJmYV9zbV9zZW5kX2V2ZW50KGxwb3J0LCBCRkFfRkNTX1BPUlRfU01fQ1JFQVRFKTsKK30KKworCisKKy8qKgorICogIGZjc19scG9ydF9hcGkKKyAqLworCit2b2lkCitiZmFfZmNzX3BvcnRfZ2V0X2F0dHIoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkgICAgICBzdHJ1Y3QgYmZhX3BvcnRfYXR0cl9zICpwb3J0X2F0dHIpCit7CisJaWYgKGJmYV9zbV9jbXBfc3RhdGUocG9ydCwgYmZhX2Zjc19wb3J0X3NtX29ubGluZSkpCisJCXBvcnRfYXR0ci0+cGlkID0gcG9ydC0+cGlkOworCWVsc2UKKwkJcG9ydF9hdHRyLT5waWQgPSAwOworCisJcG9ydF9hdHRyLT5wb3J0X2NmZyA9IHBvcnQtPnBvcnRfY2ZnOworCisJaWYgKHBvcnQtPmZhYnJpYykgeworCQlwb3J0X2F0dHItPnBvcnRfdHlwZSA9IGJmYV9mY3NfZmFicmljX3BvcnRfdHlwZShwb3J0LT5mYWJyaWMpOworCQlwb3J0X2F0dHItPmxvb3BiYWNrID0gYmZhX2Zjc19mYWJyaWNfaXNfbG9vcGJhY2socG9ydC0+ZmFicmljKTsKKwkJcG9ydF9hdHRyLT5mYWJyaWNfbmFtZSA9IGJmYV9mY3NfcG9ydF9nZXRfZmFicmljX25hbWUocG9ydCk7CisJCW1lbWNweShwb3J0X2F0dHItPmZhYnJpY19pcF9hZGRyLAorCQkgICAgICAgYmZhX2Zjc19wb3J0X2dldF9mYWJyaWNfaXBhZGRyKHBvcnQpLAorCQkgICAgICAgQkZBX0ZDU19GQUJSSUNfSVBBRERSX1NaKTsKKworCQlpZiAocG9ydC0+dnBvcnQgIT0gTlVMTCkKKwkJCXBvcnRfYXR0ci0+cG9ydF90eXBlID0gQkZBX1BQT1JUX1RZUEVfVlBPUlQ7CisKKwl9IGVsc2UgeworCQlwb3J0X2F0dHItPnBvcnRfdHlwZSA9IEJGQV9QUE9SVF9UWVBFX1VOS05PV047CisJCXBvcnRfYXR0ci0+c3RhdGUgPSBCRkFfUE9SVF9VTklOSVQ7CisJfQorCit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmNzX3BvcnQuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Zjc19wb3J0LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWM0YjI0ZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Zjc19wb3J0LmMKQEAgLTAsMCArMSw2OCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFfZmNzX3Bwb3J0LmMgQkZBIEZDUyBQUE9SVCAoIHBoeXNpY2FsIHBvcnQpCisgKi8KKworI2luY2x1ZGUgPGZjcy9iZmFfZmNzLmg+CisjaW5jbHVkZSA8YmZhX3N2Yy5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX2ZhYnJpYy5oPgorI2luY2x1ZGUgImZjc190cmNtb2QuaCIKKyNpbmNsdWRlICJmY3MuaCIKKyNpbmNsdWRlICJmY3NfZmFicmljLmgiCisjaW5jbHVkZSAiZmNzX3BvcnQuaCIKKworQkZBX1RSQ19GSUxFKEZDUywgUFBPUlQpOworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wcG9ydF9ldmVudF9oYW5kbGVyKHZvaWQgKmNiYXJnLCBiZmFfcHBvcnRfZXZlbnRfdCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19zICAgICAgKmZjcyA9IGNiYXJnOworCisJYmZhX3RyYyhmY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9QUE9SVF9MSU5LVVA6CisJCWJmYV9mY3NfZmFicmljX2xpbmtfdXAoJmZjcy0+ZmFicmljKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9QUE9SVF9MSU5LRE9XTjoKKwkJYmZhX2Zjc19mYWJyaWNfbGlua19kb3duKCZmY3MtPmZhYnJpYyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUFBPUlRfVFJVTktfTElOS0RPV046CisJCWJmYV9hc3NlcnQoMCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3ZvaWQKK2JmYV9mY3NfcHBvcnRfbW9kaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7CisJYmZhX3Bwb3J0X2V2ZW50X3JlZ2lzdGVyKGZjcy0+YmZhLCBiZmFfZmNzX3Bwb3J0X2V2ZW50X2hhbmRsZXIsCisJCQkJICAgICBmY3MpOworfQorCit2b2lkCitiZmFfZmNzX3Bwb3J0X21vZGV4aXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKQoreworCWJmYV9mY3NfbW9kZXhpdF9jb21wKGZjcyk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3NfdWYuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Zjc191Zi5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFkMDFkYjYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9mY3NfdWYuYwpAQCAtMCwwICsxLDEwNSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFfZmNzX3VmLmMgQkZBIEZDUyBVRiAoIFVuc29saWNpdGVkIEZyYW1lcykKKyAqLworCisjaW5jbHVkZSA8ZmNzL2JmYV9mY3MuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfZmFicmljLmg+CisjaW5jbHVkZSAiZmNzLmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImZjc19mYWJyaWMuaCIKKyNpbmNsdWRlICJmY3NfdWYuaCIKKworQkZBX1RSQ19GSUxFKEZDUywgVUYpOworCisvKioKKyAqIAkJQkZBIGNhbGxiYWNrIGZvciB1bnNvbGljaXRlZCBmcmFtZSByZWNlaXZlIGhhbmRsZXIuCisgKgorICogQHBhcmFtW2luXQkJY2JhcmcJCWNhbGxiYWNrIGFyZyBmb3IgcmVjZWl2ZSBoYW5kbGVyCisgKiBAcGFyYW1baW5dCQl1ZgkJdW5zb2xpY2l0ZWQgZnJhbWUgZGVzY3JpcHRvcgorICoKKyAqIEByZXR1cm4gTm9uZQorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc191Zl9yZWN2KHZvaWQgKmNiYXJnLCBzdHJ1Y3QgYmZhX3VmX3MgKnVmKQoreworCXN0cnVjdCBiZmFfZmNzX3MgICAgICAqZmNzID0gKHN0cnVjdCBiZmFfZmNzX3MgKikgY2Jhcmc7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICpmY2hzID0gYmZhX3VmX2dldF9mcm1idWYodWYpOworCXUxNiAgICAgICAgbGVuID0gYmZhX3VmX2dldF9mcm1sZW4odWYpOworCXN0cnVjdCBmY192ZnRfcyAgICAgICAqdmZ0OworCXN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWM7CisKKwkvKioKKwkgKiBjaGVjayBmb3IgVkZUIGhlYWRlcgorCSAqLworCWlmIChmY2hzLT5yb3V0aW5nID09IEZDX1JUR19FWFRfSERSICYmCisJCWZjaHMtPmNhdF9pbmZvID09IEZDX0NBVF9WRlRfSERSKSB7CisJCWJmYV9zdGF0cyhmY3MsIHVmLnRhZ2dlZCk7CisJCXZmdCA9IGJmYV91Zl9nZXRfZnJtYnVmKHVmKTsKKwkJaWYgKGZjcy0+cG9ydF92ZmlkID09IHZmdC0+dmZfaWQpCisJCQlmYWJyaWMgPSAmZmNzLT5mYWJyaWM7CisJCWVsc2UKKwkJCWZhYnJpYyA9IGJmYV9mY3NfdmZfbG9va3VwKGZjcywgKHUxNikgdmZ0LT52Zl9pZCk7CisKKwkJLyoqCisJCSAqIGRyb3AgZnJhbWUgaWYgdmZpZCBpcyB1bmtub3duCisJCSAqLworCQlpZiAoIWZhYnJpYykgeworCQkJYmZhX2Fzc2VydCgwKTsKKwkJCWJmYV9zdGF0cyhmY3MsIHVmLnZmaWRfdW5rbm93bik7CisJCQliZmFfdWZfZnJlZSh1Zik7CisJCQlyZXR1cm47CisJCX0KKworCQkvKioKKwkJICogc2tpcCB2ZnQgaGVhZGVyCisJCSAqLworCQlmY2hzID0gKHN0cnVjdCBmY2hzX3MgKikgKHZmdCArIDEpOworCQlsZW4gLT0gc2l6ZW9mKHN0cnVjdCBmY192ZnRfcyk7CisKKwkJYmZhX3RyYyhmY3MsIHZmdC0+dmZfaWQpOworCX0gZWxzZSB7CisJCWJmYV9zdGF0cyhmY3MsIHVmLnVudGFnZ2VkKTsKKwkJZmFicmljID0gJmZjcy0+ZmFicmljOworCX0KKworCWJmYV90cmMoZmNzLCAoKHUzMiAqKSBmY2hzKVswXSk7CisJYmZhX3RyYyhmY3MsICgodTMyICopIGZjaHMpWzFdKTsKKwliZmFfdHJjKGZjcywgKCh1MzIgKikgZmNocylbMl0pOworCWJmYV90cmMoZmNzLCAoKHUzMiAqKSBmY2hzKVszXSk7CisJYmZhX3RyYyhmY3MsICgodTMyICopIGZjaHMpWzRdKTsKKwliZmFfdHJjKGZjcywgKCh1MzIgKikgZmNocylbNV0pOworCWJmYV90cmMoZmNzLCBsZW4pOworCisJYmZhX2Zjc19mYWJyaWNfdWZfcmVjdihmYWJyaWMsIGZjaHMsIGxlbik7CisJYmZhX3VmX2ZyZWUodWYpOworfQorCit2b2lkCitiZmFfZmNzX3VmX21vZGluaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKQoreworCWJmYV91Zl9yZWN2X3JlZ2lzdGVyKGZjcy0+YmZhLCBiZmFfZmNzX3VmX3JlY3YsIGZjcyk7Cit9CisKK3ZvaWQKK2JmYV9mY3NfdWZfbW9kZXhpdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7CisJYmZhX2Zjc19tb2RleGl0X2NvbXAoZmNzKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjeHAuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjeHAuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40NzU0YTBlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmN4cC5jCkBAIC0wLDAgKzEsNzgyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX3VmLmg+CisjaW5jbHVkZSA8Y3MvYmZhX2RlYnVnLmg+CisKK0JGQV9UUkNfRklMRShIQUwsIEZDWFApOworQkZBX01PRFVMRShmY3hwKTsKKworLyoqCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgdm9pZCAgICAgX19iZmFfZmN4cF9zZW5kX2NiZm4odm9pZCAqY2JhcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpOworc3RhdGljIHZvaWQgICAgIGhhbF9mY3hwX3J4X3Bsb2coc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCSBzdHJ1Y3QgYmZpX2ZjeHBfc2VuZF9yc3BfcyAqZmN4cF9yc3ApOworc3RhdGljIHZvaWQgICAgIGhhbF9mY3hwX3R4X3Bsb2coc3RydWN0IGJmYV9zICpiZmEsIHUzMiByZXFsZW4sCisJCQkJIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCBzdHJ1Y3QgZmNoc19zICpmY2hzKTsKK3N0YXRpYyB2b2lkCWJmYV9mY3hwX3FyZXN1bWUodm9pZCAqY2JhcmcpOworc3RhdGljIHZvaWQJYmZhX2ZjeHBfcXVldWUoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkgICAgICAgc3RydWN0IGJmaV9mY3hwX3NlbmRfcmVxX3MgKnNlbmRfcmVxKTsKKworLyoqCisgKiAgZmN4cF9wdnQgQkZBIEZDWFAgcHJpdmF0ZSBmdW5jdGlvbnMKKyAqLworCitzdGF0aWMgdm9pZAorY2xhaW1fZmN4cF9yZXFfcnNwX21lbShzdHJ1Y3QgYmZhX2ZjeHBfbW9kX3MgKm1vZCwgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1pKQoreworCXU4ICAgICAgICAqZG1fa3ZhID0gTlVMTDsKKwl1NjQgICAgICAgIGRtX3BhOworCXUzMiAgICAgICAgYnVmX3Bvb2xfc3o7CisKKwlkbV9rdmEgPSBiZmFfbWVtaW5mb19kbWFfdmlydChtaSk7CisJZG1fcGEgPSBiZmFfbWVtaW5mb19kbWFfcGh5cyhtaSk7CisKKwlidWZfcG9vbF9zeiA9IG1vZC0+cmVxX3BsZF9zeiAqIG1vZC0+bnVtX2ZjeHBzOworCisJLyoKKwkgKiBJbml0aWFsaXplIHRoZSBmY3hwIHJlcSBwYXlsb2FkIGxpc3QKKwkgKi8KKwltb2QtPnJlcV9wbGRfbGlzdF9rdmEgPSBkbV9rdmE7CisJbW9kLT5yZXFfcGxkX2xpc3RfcGEgPSBkbV9wYTsKKwlkbV9rdmEgKz0gYnVmX3Bvb2xfc3o7CisJZG1fcGEgKz0gYnVmX3Bvb2xfc3o7CisJYmZhX29zX21lbXNldChtb2QtPnJlcV9wbGRfbGlzdF9rdmEsIDAsIGJ1Zl9wb29sX3N6KTsKKworCS8qCisJICogSW5pdGlhbGl6ZSB0aGUgZmN4cCByc3AgcGF5bG9hZCBsaXN0CisJICovCisJYnVmX3Bvb2xfc3ogPSBtb2QtPnJzcF9wbGRfc3ogKiBtb2QtPm51bV9mY3hwczsKKwltb2QtPnJzcF9wbGRfbGlzdF9rdmEgPSBkbV9rdmE7CisJbW9kLT5yc3BfcGxkX2xpc3RfcGEgPSBkbV9wYTsKKwlkbV9rdmEgKz0gYnVmX3Bvb2xfc3o7CisJZG1fcGEgKz0gYnVmX3Bvb2xfc3o7CisJYmZhX29zX21lbXNldChtb2QtPnJzcF9wbGRfbGlzdF9rdmEsIDAsIGJ1Zl9wb29sX3N6KTsKKworCWJmYV9tZW1pbmZvX2RtYV92aXJ0KG1pKSA9IGRtX2t2YTsKKwliZmFfbWVtaW5mb19kbWFfcGh5cyhtaSkgPSBkbV9wYTsKK30KKworc3RhdGljIHZvaWQKK2NsYWltX2ZjeHBzX21lbShzdHJ1Y3QgYmZhX2ZjeHBfbW9kX3MgKm1vZCwgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1pKQoreworCXUxNiAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKworCWZjeHAgPSAoc3RydWN0IGJmYV9mY3hwX3MgKikgYmZhX21lbWluZm9fa3ZhKG1pKTsKKwliZmFfb3NfbWVtc2V0KGZjeHAsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX2ZjeHBfcykgKiBtb2QtPm51bV9mY3hwcyk7CisKKwlJTklUX0xJU1RfSEVBRCgmbW9kLT5mY3hwX2ZyZWVfcSk7CisJSU5JVF9MSVNUX0hFQUQoJm1vZC0+ZmN4cF9hY3RpdmVfcSk7CisKKwltb2QtPmZjeHBfbGlzdCA9IGZjeHA7CisKKwlmb3IgKGkgPSAwOyBpIDwgbW9kLT5udW1fZmN4cHM7IGkrKykgeworCQlmY3hwLT5mY3hwX21vZCA9IG1vZDsKKwkJZmN4cC0+ZmN4cF90YWcgPSBpOworCisJCWxpc3RfYWRkX3RhaWwoJmZjeHAtPnFlLCAmbW9kLT5mY3hwX2ZyZWVfcSk7CisJCWJmYV9yZXFxX3dpbml0KCZmY3hwLT5yZXFxX3dxZSwgYmZhX2ZjeHBfcXJlc3VtZSwgZmN4cCk7CisJCWZjeHAtPnJlcXFfd2FpdGluZyA9IEJGQV9GQUxTRTsKKworCQlmY3hwID0gZmN4cCArIDE7CisJfQorCisJYmZhX21lbWluZm9fa3ZhKG1pKSA9ICh2b2lkICopZmN4cDsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3hwX21lbWluZm8oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKm5kbV9sZW4sCisJCXUzMiAqZG1fbGVuKQoreworCXUxNiAgICAgICAgbnVtX2ZjeHBfcmVxcyA9IGNmZy0+ZndjZmcubnVtX2ZjeHBfcmVxczsKKworCWlmIChudW1fZmN4cF9yZXFzID09IDApCisJCXJldHVybjsKKworCS8qCisJICogQWNjb3VudCBmb3IgcmVxL3JzcCBwYXlsb2FkCisJICovCisJKmRtX2xlbiArPSBCRkFfRkNYUF9NQVhfSUJVRl9TWiAqIG51bV9mY3hwX3JlcXM7CisJaWYgKGNmZy0+ZHJ2Y2ZnLm1pbl9jZmcpCisJCSpkbV9sZW4gKz0gQkZBX0ZDWFBfTUFYX0lCVUZfU1ogKiBudW1fZmN4cF9yZXFzOworCWVsc2UKKwkJKmRtX2xlbiArPSBCRkFfRkNYUF9NQVhfTEJVRl9TWiAqIG51bV9mY3hwX3JlcXM7CisKKwkvKgorCSAqIEFjY291bnQgZm9yIGZjeHAgc3RydWN0cworCSAqLworCSpuZG1fbGVuICs9IHNpemVvZihzdHJ1Y3QgYmZhX2ZjeHBfcykgKiBudW1fZmN4cF9yZXFzOworfQorCitzdGF0aWMgdm9pZAorYmZhX2ZjeHBfYXR0YWNoKHN0cnVjdCBiZmFfcyAqYmZhLCB2b2lkICpiZmFkLCBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCSAgICBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbywgc3RydWN0IGJmYV9wY2lkZXZfcyAqcGNpZGV2KQoreworCXN0cnVjdCBiZmFfZmN4cF9tb2RfcyAqbW9kID0gQkZBX0ZDWFBfTU9EKGJmYSk7CisKKwliZmFfb3NfbWVtc2V0KG1vZCwgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfZmN4cF9tb2RfcykpOworCW1vZC0+YmZhID0gYmZhOworCW1vZC0+bnVtX2ZjeHBzID0gY2ZnLT5md2NmZy5udW1fZmN4cF9yZXFzOworCisJLyoqCisJICogSW5pdGlhbGl6ZSBGQ1hQIHJlcXVlc3QgYW5kIHJlc3BvbnNlIHBheWxvYWQgc2l6ZXMuCisJICovCisJbW9kLT5yZXFfcGxkX3N6ID0gbW9kLT5yc3BfcGxkX3N6ID0gQkZBX0ZDWFBfTUFYX0lCVUZfU1o7CisJaWYgKCFjZmctPmRydmNmZy5taW5fY2ZnKQorCQltb2QtPnJzcF9wbGRfc3ogPSBCRkFfRkNYUF9NQVhfTEJVRl9TWjsKKworCUlOSVRfTElTVF9IRUFEKCZtb2QtPndhaXRfcSk7CisKKwljbGFpbV9mY3hwX3JlcV9yc3BfbWVtKG1vZCwgbWVtaW5mbyk7CisJY2xhaW1fZmN4cHNfbWVtKG1vZCwgbWVtaW5mbyk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmN4cF9pbml0ZG9uZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3hwX2RldGFjaChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3hwX3N0YXJ0KHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX2ZjeHBfc3RvcChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3hwX2lvY2Rpc2FibGUoc3RydWN0IGJmYV9zICpiZmEpCit7CisJc3RydWN0IGJmYV9mY3hwX21vZF9zICptb2QgPSBCRkFfRkNYUF9NT0QoYmZhKTsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAqcWUsICpxZW47CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJm1vZC0+ZmN4cF9hY3RpdmVfcSkgeworCQlmY3hwID0gKHN0cnVjdCBiZmFfZmN4cF9zICopIHFlOworCQlpZiAoZmN4cC0+Y2FsbGVyID09IE5VTEwpIHsKKwkJCWZjeHAtPnNlbmRfY2JmbihmY3hwLT5jYWxsZXIsIGZjeHAsIGZjeHAtPnNlbmRfY2JhcmcsCisJCQkJCUJGQV9TVEFUVVNfSU9DX0ZBSUxVUkUsIDAsIDAsIE5VTEwpOworCQkJYmZhX2ZjeHBfZnJlZShmY3hwKTsKKwkJfSBlbHNlIHsKKwkJCWZjeHAtPnJzcF9zdGF0dXMgPSBCRkFfU1RBVFVTX0lPQ19GQUlMVVJFOworCQkJYmZhX2NiX3F1ZXVlKGJmYSwgJmZjeHAtPmhjYl9xZSwKKwkJCQkgICAgICBfX2JmYV9mY3hwX3NlbmRfY2JmbiwgZmN4cCk7CisJCX0KKwl9Cit9CisKK3N0YXRpYyBzdHJ1Y3QgYmZhX2ZjeHBfcyAqCitiZmFfZmN4cF9nZXQoc3RydWN0IGJmYV9mY3hwX21vZF9zICpmbSkKK3sKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKworCWJmYV9xX2RlcSgmZm0tPmZjeHBfZnJlZV9xLCAmZmN4cCk7CisKKwlpZiAoZmN4cCkKKwkJbGlzdF9hZGRfdGFpbCgmZmN4cC0+cWUsICZmbS0+ZmN4cF9hY3RpdmVfcSk7CisKKwlyZXR1cm4gKGZjeHApOworfQorCitzdGF0aWMgdm9pZAorYmZhX2ZjeHBfcHV0KHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwKQoreworCXN0cnVjdCBiZmFfZmN4cF9tb2RfcyAqbW9kID0gZmN4cC0+ZmN4cF9tb2Q7CisJc3RydWN0IGJmYV9mY3hwX3dxZV9zICp3cWU7CisKKwliZmFfcV9kZXEoJm1vZC0+d2FpdF9xLCAmd3FlKTsKKwlpZiAod3FlKSB7CisJCWJmYV90cmMobW9kLT5iZmEsIGZjeHAtPmZjeHBfdGFnKTsKKwkJd3FlLT5hbGxvY19jYmZuKHdxZS0+YWxsb2NfY2JhcmcsIGZjeHApOworCQlyZXR1cm47CisJfQorCisJYmZhX2Fzc2VydChiZmFfcV9pc19vbl9xKCZtb2QtPmZjeHBfYWN0aXZlX3EsIGZjeHApKTsKKwlsaXN0X2RlbCgmZmN4cC0+cWUpOworCWxpc3RfYWRkX3RhaWwoJmZjeHAtPnFlLCAmbW9kLT5mY3hwX2ZyZWVfcSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmN4cF9udWxsX2NvbXAodm9pZCAqYmZhZF9mY3hwLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwgdm9pZCAqY2JhcmcsCisJCSAgICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywgdTMyIHJzcF9sZW4sCisJCSAgICAgICB1MzIgcmVzaWRfbGVuLCBzdHJ1Y3QgZmNoc19zICpyc3BfZmNocykKK3sKKwkvKipkaXNjYXJkZWQgZmN4cCBjb21wbGV0aW9uICovCit9CisKK3N0YXRpYyB2b2lkCitfX2JmYV9mY3hwX3NlbmRfY2Jmbih2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSkKK3sKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCA9IGNiYXJnOworCisJaWYgKGNvbXBsZXRlKSB7CisJCWZjeHAtPnNlbmRfY2JmbihmY3hwLT5jYWxsZXIsIGZjeHAsIGZjeHAtPnNlbmRfY2JhcmcsCisJCQkJZmN4cC0+cnNwX3N0YXR1cywgZmN4cC0+cnNwX2xlbiwKKwkJCQlmY3hwLT5yZXNpZHVlX2xlbiwgJmZjeHAtPnJzcF9mY2hzKTsKKwl9IGVsc2UgeworCQliZmFfZmN4cF9mcmVlKGZjeHApOworCX0KK30KKworc3RhdGljIHZvaWQKK2hhbF9mY3hwX3NlbmRfY29tcChzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmaV9mY3hwX3NlbmRfcnNwX3MgKmZjeHBfcnNwKQoreworCXN0cnVjdCBiZmFfZmN4cF9tb2RfcwkqbW9kID0gQkZBX0ZDWFBfTU9EKGJmYSk7CisJc3RydWN0IGJmYV9mY3hwX3MgCSpmY3hwOworCXUxNgkJZmN4cF90YWcgPSBiZmFfb3NfbnRvaHMoZmN4cF9yc3AtPmZjeHBfdGFnKTsKKworCWJmYV90cmMoYmZhLCBmY3hwX3RhZyk7CisKKwlmY3hwX3JzcC0+cnNwX2xlbiA9IGJmYV9vc19udG9obChmY3hwX3JzcC0+cnNwX2xlbik7CisKKwkvKioKKwkgKiBAdG9kbyBmL3cgc2hvdWxkIG5vdCBzZXQgcmVzaWR1ZSB0byBub24tMCB3aGVuIGV2ZXJ5dGhpbmcKKwkgKiAgICAgICBpcyByZWNlaXZlZC4KKwkgKi8KKwlpZiAoZmN4cF9yc3AtPnJlcV9zdGF0dXMgPT0gQkZBX1NUQVRVU19PSykKKwkJZmN4cF9yc3AtPnJlc2lkdWVfbGVuID0gMDsKKwllbHNlCisJCWZjeHBfcnNwLT5yZXNpZHVlX2xlbiA9IGJmYV9vc19udG9obChmY3hwX3JzcC0+cmVzaWR1ZV9sZW4pOworCisJZmN4cCA9IEJGQV9GQ1hQX0ZST01fVEFHKG1vZCwgZmN4cF90YWcpOworCisJYmZhX2Fzc2VydChmY3hwLT5zZW5kX2NiZm4gIT0gTlVMTCk7CisKKwloYWxfZmN4cF9yeF9wbG9nKG1vZC0+YmZhLCBmY3hwLCBmY3hwX3JzcCk7CisKKwlpZiAoZmN4cC0+c2VuZF9jYmZuICE9IE5VTEwpIHsKKwkJaWYgKGZjeHAtPmNhbGxlciA9PSBOVUxMKSB7CisJCQliZmFfdHJjKG1vZC0+YmZhLCBmY3hwLT5mY3hwX3RhZyk7CisKKwkJCWZjeHAtPnNlbmRfY2JmbihmY3hwLT5jYWxsZXIsIGZjeHAsIGZjeHAtPnNlbmRfY2JhcmcsCisJCQkJCWZjeHBfcnNwLT5yZXFfc3RhdHVzLCBmY3hwX3JzcC0+cnNwX2xlbiwKKwkJCQkJZmN4cF9yc3AtPnJlc2lkdWVfbGVuLCAmZmN4cF9yc3AtPmZjaHMpOworCQkJLyoKKwkJCSAqIGZjeHAgYXV0b21hdGljYWxseSBmcmVlZCBvbiByZXR1cm4gZnJvbSB0aGUgY2FsbGJhY2sKKwkJCSAqLworCQkJYmZhX2ZjeHBfZnJlZShmY3hwKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV90cmMobW9kLT5iZmEsIGZjeHAtPmZjeHBfdGFnKTsKKwkJCWZjeHAtPnJzcF9zdGF0dXMgPSBmY3hwX3JzcC0+cmVxX3N0YXR1czsKKwkJCWZjeHAtPnJzcF9sZW4gPSBmY3hwX3JzcC0+cnNwX2xlbjsKKwkJCWZjeHAtPnJlc2lkdWVfbGVuID0gZmN4cF9yc3AtPnJlc2lkdWVfbGVuOworCQkJZmN4cC0+cnNwX2ZjaHMgPSBmY3hwX3JzcC0+ZmNoczsKKworCQkJYmZhX2NiX3F1ZXVlKGJmYSwgJmZjeHAtPmhjYl9xZSwKKwkJCQkgICAgICBfX2JmYV9mY3hwX3NlbmRfY2JmbiwgZmN4cCk7CisJCX0KKwl9IGVsc2UgeworCQliZmFfdHJjKGJmYSwgZmN4cF90YWcpOworCX0KK30KKworc3RhdGljIHZvaWQKK2hhbF9mY3hwX3NldF9sb2NhbF9zZ2VzKHN0cnVjdCBiZmlfc2dlX3MgKnNnZSwgdTMyIHJlcWxlbiwgdTY0IHJlcV9wYSkKK3sKKwl1bmlvbiBiZmlfYWRkcl91ICAgICAgc2dhX3plcm8gPSB7IHswfSB9OworCisJc2dlLT5zZ19sZW4gPSByZXFsZW47CisJc2dlLT5mbGFncyA9IEJGSV9TR0VfREFUQV9MQVNUOworCWJmYV9kbWFfYWRkcl9zZXQoc2dlWzBdLnNnYSwgcmVxX3BhKTsKKwliZmFfc2dlX3RvX2JlKHNnZSk7CisJc2dlKys7CisKKwlzZ2UtPnNnYSA9IHNnYV96ZXJvOworCXNnZS0+c2dfbGVuID0gcmVxbGVuOworCXNnZS0+ZmxhZ3MgPSBCRklfU0dFX1BHRExFTjsKKwliZmFfc2dlX3RvX2JlKHNnZSk7Cit9CisKK3N0YXRpYyB2b2lkCitoYWxfZmN4cF90eF9wbG9nKHN0cnVjdCBiZmFfcyAqYmZhLCB1MzIgcmVxbGVuLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJIHN0cnVjdCBmY2hzX3MgKmZjaHMpCit7CisJLyoKKwkgKiBUT0RPOiBUWCBveF9pZAorCSAqLworCWlmIChyZXFsZW4gPiAwKSB7CisJCWlmIChmY3hwLT51c2VfaXJlcWJ1ZikgeworCQkJdTMyICAgICAgICBwbGRfdzAgPQorCQkJCSooKHUzMiAqKSBCRkFfRkNYUF9SRVFfUExEKGZjeHApKTsKKworCQkJYmZhX3Bsb2dfZmNoZHJfYW5kX3BsKGJmYS0+cGxvZywgQkZBX1BMX01JRF9IQUxfRkNYUCwKKwkJCQlCRkFfUExfRUlEX1RYLAorCQkJCXJlcWxlbiArIHNpemVvZihzdHJ1Y3QgZmNoc19zKSwgZmNocywgcGxkX3cwKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV9wbG9nX2ZjaGRyKGJmYS0+cGxvZywgQkZBX1BMX01JRF9IQUxfRkNYUCwKKwkJCQlCRkFfUExfRUlEX1RYLCByZXFsZW4gKyBzaXplb2Yoc3RydWN0IGZjaHNfcyksCisJCQkJZmNocyk7CisJCX0KKwl9IGVsc2UgeworCQliZmFfcGxvZ19mY2hkcihiZmEtPnBsb2csIEJGQV9QTF9NSURfSEFMX0ZDWFAsIEJGQV9QTF9FSURfVFgsCisJCQkgICAgICAgcmVxbGVuICsgc2l6ZW9mKHN0cnVjdCBmY2hzX3MpLCBmY2hzKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitoYWxfZmN4cF9yeF9wbG9nKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJIHN0cnVjdCBiZmlfZmN4cF9zZW5kX3JzcF9zICpmY3hwX3JzcCkKK3sKKwlpZiAoZmN4cF9yc3AtPnJzcF9sZW4gPiAwKSB7CisJCWlmIChmY3hwLT51c2VfaXJzcGJ1ZikgeworCQkJdTMyICAgICAgICBwbGRfdzAgPQorCQkJCSooKHUzMiAqKSBCRkFfRkNYUF9SU1BfUExEKGZjeHApKTsKKworCQkJYmZhX3Bsb2dfZmNoZHJfYW5kX3BsKGJmYS0+cGxvZywgQkZBX1BMX01JRF9IQUxfRkNYUCwKKwkJCQkJICAgICAgQkZBX1BMX0VJRF9SWCwKKwkJCQkJICAgICAgKHUxNikgZmN4cF9yc3AtPnJzcF9sZW4sCisJCQkJCSAgICAgICZmY3hwX3JzcC0+ZmNocywgcGxkX3cwKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV9wbG9nX2ZjaGRyKGJmYS0+cGxvZywgQkZBX1BMX01JRF9IQUxfRkNYUCwKKwkJCQkgICAgICAgQkZBX1BMX0VJRF9SWCwKKwkJCQkgICAgICAgKHUxNikgZmN4cF9yc3AtPnJzcF9sZW4sCisJCQkJICAgICAgICZmY3hwX3JzcC0+ZmNocyk7CisJCX0KKwl9IGVsc2UgeworCQliZmFfcGxvZ19mY2hkcihiZmEtPnBsb2csIEJGQV9QTF9NSURfSEFMX0ZDWFAsIEJGQV9QTF9FSURfUlgsCisJCQkgICAgICAgKHUxNikgZmN4cF9yc3AtPnJzcF9sZW4sICZmY3hwX3JzcC0+ZmNocyk7CisJfQorfQorCisvKioKKyAqIEhhbmRsZXIgdG8gcmVzdW1lIHNlbmRpbmcgZmN4cCB3aGVuIHNwYWNlIGluIGF2YWlsYWJsZSBpbiBjcGUgcXVldWUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmN4cF9xcmVzdW1lKHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfZmN4cF9zCQkqZmN4cCA9IGNiYXJnOworCXN0cnVjdCBiZmFfcwkJCSpiZmEgPSBmY3hwLT5mY3hwX21vZC0+YmZhOworCXN0cnVjdCBiZmlfZmN4cF9zZW5kX3JlcV9zCSpzZW5kX3JlcTsKKworCWZjeHAtPnJlcXFfd2FpdGluZyA9IEJGQV9GQUxTRTsKKwlzZW5kX3JlcSA9IGJmYV9yZXFxX25leHQoYmZhLCBCRkFfUkVRUV9GQ1hQKTsKKwliZmFfZmN4cF9xdWV1ZShmY3hwLCBzZW5kX3JlcSk7Cit9CisKKy8qKgorICogUXVldWUgZmN4cCBzZW5kIHJlcXVlc3QgdG8gZm9pbXJ3YXJlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2ZjeHBfcXVldWUoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsIHN0cnVjdCBiZmlfZmN4cF9zZW5kX3JlcV9zICpzZW5kX3JlcSkKK3sKKwlzdHJ1Y3QgYmZhX3MgICAgICAJCSpiZmEgPSBmY3hwLT5mY3hwX21vZC0+YmZhOworCXN0cnVjdCBiZmFfZmN4cF9yZXFfaW5mb19zCSpyZXFpID0gJmZjeHAtPnJlcV9pbmZvOworCXN0cnVjdCBiZmFfZmN4cF9yc3BfaW5mb19zCSpyc3BpID0gJmZjeHAtPnJzcF9pbmZvOworCXN0cnVjdCBiZmFfcnBvcnRfcwkJKnJwb3J0ID0gcmVxaS0+YmZhX3Jwb3J0OworCisJYmZpX2gyaV9zZXQoc2VuZF9yZXEtPm1oLCBCRklfTUNfRkNYUCwgQkZJX0ZDWFBfSDJJX1NFTkRfUkVRLAorCQkJYmZhX2xwdWlkKGJmYSkpOworCisJc2VuZF9yZXEtPmZjeHBfdGFnID0gYmZhX29zX2h0b25zKGZjeHAtPmZjeHBfdGFnKTsKKwlpZiAocnBvcnQpIHsKKwkJc2VuZF9yZXEtPnJwb3J0X2Z3X2huZGwgPSBycG9ydC0+ZndfaGFuZGxlOworCQlzZW5kX3JlcS0+bWF4X2ZybXN6ID0gYmZhX29zX2h0b25zKHJwb3J0LT5ycG9ydF9pbmZvLm1heF9mcm1zeik7CisJCWlmIChzZW5kX3JlcS0+bWF4X2ZybXN6ID09IDApCisJCQlzZW5kX3JlcS0+bWF4X2ZybXN6ID0gYmZhX29zX2h0b25zKEZDX01BWF9QRFVTWik7CisJfSBlbHNlIHsKKwkJc2VuZF9yZXEtPnJwb3J0X2Z3X2huZGwgPSAwOworCQlzZW5kX3JlcS0+bWF4X2ZybXN6ID0gYmZhX29zX2h0b25zKEZDX01BWF9QRFVTWik7CisJfQorCisJc2VuZF9yZXEtPnZmX2lkID0gYmZhX29zX2h0b25zKHJlcWktPnZmX2lkKTsKKwlzZW5kX3JlcS0+bHBfdGFnID0gcmVxaS0+bHBfdGFnOworCXNlbmRfcmVxLT5jbGFzcyA9IHJlcWktPmNsYXNzOworCXNlbmRfcmVxLT5yc3BfdGltZW91dCA9IHJzcGktPnJzcF90aW1lb3V0OworCXNlbmRfcmVxLT5jdHMgPSByZXFpLT5jdHM7CisJc2VuZF9yZXEtPmZjaHMgPSByZXFpLT5mY2hzOworCisJc2VuZF9yZXEtPnJlcV9sZW4gPSBiZmFfb3NfaHRvbmwocmVxaS0+cmVxX3RvdF9sZW4pOworCXNlbmRfcmVxLT5yc3BfbWF4bGVuID0gYmZhX29zX2h0b25sKHJzcGktPnJzcF9tYXhsZW4pOworCisJLyoKKwkgKiBzZXR1cCByZXEgc2dsZXMKKwkgKi8KKwlpZiAoZmN4cC0+dXNlX2lyZXFidWYgPT0gMSkgeworCQloYWxfZmN4cF9zZXRfbG9jYWxfc2dlcyhzZW5kX3JlcS0+cmVxX3NnZSwgcmVxaS0+cmVxX3RvdF9sZW4sCisJCQkJCUJGQV9GQ1hQX1JFUV9QTERfUEEoZmN4cCkpOworCX0gZWxzZSB7CisJCWlmIChmY3hwLT5ucmVxX3NnbGVzID4gMCkgeworCQkJYmZhX2Fzc2VydChmY3hwLT5ucmVxX3NnbGVzID09IDEpOworCQkJaGFsX2ZjeHBfc2V0X2xvY2FsX3NnZXMoc2VuZF9yZXEtPnJlcV9zZ2UsCisJCQkJCQlyZXFpLT5yZXFfdG90X2xlbiwKKwkJCQkJCWZjeHAtPnJlcV9zZ2FfY2JmbihmY3hwLT5jYWxsZXIsCisJCQkJCQkJCSAgIDApKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV9hc3NlcnQocmVxaS0+cmVxX3RvdF9sZW4gPT0gMCk7CisJCQloYWxfZmN4cF9zZXRfbG9jYWxfc2dlcyhzZW5kX3JlcS0+cnNwX3NnZSwgMCwgMCk7CisJCX0KKwl9CisKKwkvKgorCSAqIHNldHVwIHJzcCBzZ2xlcworCSAqLworCWlmIChmY3hwLT51c2VfaXJzcGJ1ZiA9PSAxKSB7CisJCWJmYV9hc3NlcnQocnNwaS0+cnNwX21heGxlbiA8PSBCRkFfRkNYUF9NQVhfTEJVRl9TWik7CisKKwkJaGFsX2ZjeHBfc2V0X2xvY2FsX3NnZXMoc2VuZF9yZXEtPnJzcF9zZ2UsIHJzcGktPnJzcF9tYXhsZW4sCisJCQkJCUJGQV9GQ1hQX1JTUF9QTERfUEEoZmN4cCkpOworCisJfSBlbHNlIHsKKwkJaWYgKGZjeHAtPm5yc3Bfc2dsZXMgPiAwKSB7CisJCQliZmFfYXNzZXJ0KGZjeHAtPm5yc3Bfc2dsZXMgPT0gMSk7CisJCQloYWxfZmN4cF9zZXRfbG9jYWxfc2dlcyhzZW5kX3JlcS0+cnNwX3NnZSwKKwkJCQkJCXJzcGktPnJzcF9tYXhsZW4sCisJCQkJCQlmY3hwLT5yc3Bfc2dhX2NiZm4oZmN4cC0+Y2FsbGVyLAorCQkJCQkJCQkgICAwKSk7CisJCX0gZWxzZSB7CisJCQliZmFfYXNzZXJ0KHJzcGktPnJzcF9tYXhsZW4gPT0gMCk7CisJCQloYWxfZmN4cF9zZXRfbG9jYWxfc2dlcyhzZW5kX3JlcS0+cnNwX3NnZSwgMCwgMCk7CisJCX0KKwl9CisKKwloYWxfZmN4cF90eF9wbG9nKGJmYSwgcmVxaS0+cmVxX3RvdF9sZW4sIGZjeHAsICZyZXFpLT5mY2hzKTsKKworCWJmYV9yZXFxX3Byb2R1Y2UoYmZhLCBCRkFfUkVRUV9GQ1hQKTsKKworCWJmYV90cmMoYmZhLCBiZmFfcmVxcV9waShiZmEsIEJGQV9SRVFRX0ZDWFApKTsKKwliZmFfdHJjKGJmYSwgYmZhX3JlcXFfY2koYmZhLCBCRkFfUkVRUV9GQ1hQKSk7Cit9CisKKworLyoqCisgKiAgaGFsX2ZjeHBfYXBpIEJGQSBGQ1hQIEFQSQorICovCisKKy8qKgorICogQWxsb2NhdGUgYW4gRkNYUCBpbnN0YW5jZSB0byBzZW5kIGEgcmVzcG9uc2Ugb3IgdG8gc2VuZCBhIHJlcXVlc3QKKyAqIHRoYXQgaGFzIGEgcmVzcG9uc2UuIFJlcXVlc3QvcmVzcG9uc2UgYnVmZmVycyBhcmUgYWxsb2NhdGVkIGJ5IGNhbGxlci4KKyAqCisgKiBAcGFyYW1baW5dCWJmYQkJQkZBIGJmYSBpbnN0YW5jZQorICogQHBhcmFtW2luXQlucmVxX3NnbGVzCU51bWJlciBvZiBTRyBlbGVtZW50cyByZXF1aXJlZCBmb3IgcmVxdWVzdAorICogCQkJCWJ1ZmZlci4gMCwgaWYgZmN4cCBpbnRlcm5hbCBidWZmZXJzIGFyZQl1c2VkLgorICogCQkJCVVzZSBiZmFfZmN4cF9nZXRfcmVxYnVmKCkgdG8gZ2V0IHRoZQorICogCQkJCWludGVybmFsIHJlcSBidWZmZXIuCisgKiBAcGFyYW1baW5dCXJlcV9zZ2xlcwlTRyBlbGVtZW50cyBkZXNjcmliaW5nIHJlcXVlc3QgYnVmZmVyLiBXaWxsIGJlCisgKiAJCQkJY29waWVkIGluIGJ5IEJGQSBhbmQgaGVuY2UgY2FuIGJlIGZyZWVkIG9uCisgKiAJCQkJcmV0dXJuIGZyb20gdGhpcyBmdW5jdGlvbi4KKyAqIEBwYXJhbVtpbl0JZ2V0X3JlcV9zZ2EJZnVuY3Rpb24gcHRyIHRvIGJlIGNhbGxlZCB0byBnZXQgYSByZXF1ZXN0IFNHCisgKiAJCQkJQWRkcmVzcyAoZ2l2ZW4gdGhlIHNnZSBpbmRleCkuCisgKiBAcGFyYW1baW5dCWdldF9yZXFfc2dsZW4JZnVuY3Rpb24gcHRyIHRvIGJlIGNhbGxlZCB0byBnZXQgYSByZXF1ZXN0IFNHCisgKiAJCQkJbGVuIChnaXZlbiB0aGUgc2dlIGluZGV4KS4KKyAqIEBwYXJhbVtpbl0JZ2V0X3JzcF9zZ2EJZnVuY3Rpb24gcHRyIHRvIGJlIGNhbGxlZCB0byBnZXQgYSByZXNwb25zZSBTRworICogCQkJCUFkZHJlc3MgKGdpdmVuIHRoZSBzZ2UgaW5kZXgpLgorICogQHBhcmFtW2luXQlnZXRfcnNwX3NnbGVuCWZ1bmN0aW9uIHB0ciB0byBiZSBjYWxsZWQgdG8gZ2V0IGEgcmVzcG9uc2UgU0cKKyAqIAkJCQlsZW4gKGdpdmVuIHRoZSBzZ2UgaW5kZXgpLgorICoKKyAqIEByZXR1cm4gRkNYUCBpbnN0YW5jZS4gTlVMTCBvbiBmYWlsdXJlLgorICovCitzdHJ1Y3QgYmZhX2ZjeHBfcyAqCitiZmFfZmN4cF9hbGxvYyh2b2lkICpjYWxsZXIsIHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgbnJlcV9zZ2xlcywKKwkJCWludCBucnNwX3NnbGVzLCBiZmFfZmN4cF9nZXRfc2dhZGRyX3QgcmVxX3NnYV9jYmZuLAorCQkJYmZhX2ZjeHBfZ2V0X3NnbGVuX3QgcmVxX3NnbGVuX2NiZm4sCisJCQliZmFfZmN4cF9nZXRfc2dhZGRyX3QgcnNwX3NnYV9jYmZuLAorCQkJYmZhX2ZjeHBfZ2V0X3NnbGVuX3QgcnNwX3NnbGVuX2NiZm4pCit7CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAgPSBOVUxMOworCXUzMiAgICAgICAgbnJlcV9zZ3BnLCBucnNwX3NncGc7CisKKwliZmFfYXNzZXJ0KGJmYSAhPSBOVUxMKTsKKworCWZjeHAgPSBiZmFfZmN4cF9nZXQoQkZBX0ZDWFBfTU9EKGJmYSkpOworCWlmIChmY3hwID09IE5VTEwpCisJCXJldHVybiAoTlVMTCk7CisKKwliZmFfdHJjKGJmYSwgZmN4cC0+ZmN4cF90YWcpOworCisJZmN4cC0+Y2FsbGVyID0gY2FsbGVyOworCisJaWYgKG5yZXFfc2dsZXMgPT0gMCkgeworCQlmY3hwLT51c2VfaXJlcWJ1ZiA9IDE7CisJfSBlbHNlIHsKKwkJYmZhX2Fzc2VydChyZXFfc2dhX2NiZm4gIT0gTlVMTCk7CisJCWJmYV9hc3NlcnQocmVxX3NnbGVuX2NiZm4gIT0gTlVMTCk7CisKKwkJZmN4cC0+dXNlX2lyZXFidWYgPSAwOworCQlmY3hwLT5yZXFfc2dhX2NiZm4gPSByZXFfc2dhX2NiZm47CisJCWZjeHAtPnJlcV9zZ2xlbl9jYmZuID0gcmVxX3NnbGVuX2NiZm47CisKKwkJZmN4cC0+bnJlcV9zZ2xlcyA9IG5yZXFfc2dsZXM7CisKKwkJLyoKKwkJICogYWxsb2MgcmVxdWlyZWQgc2dwZ3MKKwkJICovCisJCWlmIChucmVxX3NnbGVzID4gQkZJX1NHRV9JTkxJTkUpIHsKKwkJCW5yZXFfc2dwZyA9IEJGQV9TR1BHX05QQUdFKG5yZXFfc2dsZXMpOworCisJCQlpZiAoYmZhX3NncGdfbWFsbG9jCisJCQkgICAgKGJmYSwgJmZjeHAtPnJlcV9zZ3BnX3EsIG5yZXFfc2dwZykKKwkJCSAgICAhPSBCRkFfU1RBVFVTX09LKSB7CisJCQkJLyogYmZhX3NncGdfd2FpdChiZmEsICZmY3hwLT5yZXFfc2dwZ193cWUsCisJCQkJbnJlcV9zZ3BnKTsgKi8KKwkJCQkvKgorCQkJCSAqIFRPRE8KKwkJCQkgKi8KKwkJCX0KKwkJfQorCX0KKworCWlmIChucnNwX3NnbGVzID09IDApIHsKKwkJZmN4cC0+dXNlX2lyc3BidWYgPSAxOworCX0gZWxzZSB7CisJCWJmYV9hc3NlcnQocnNwX3NnYV9jYmZuICE9IE5VTEwpOworCQliZmFfYXNzZXJ0KHJzcF9zZ2xlbl9jYmZuICE9IE5VTEwpOworCisJCWZjeHAtPnVzZV9pcnNwYnVmID0gMDsKKwkJZmN4cC0+cnNwX3NnYV9jYmZuID0gcnNwX3NnYV9jYmZuOworCQlmY3hwLT5yc3Bfc2dsZW5fY2JmbiA9IHJzcF9zZ2xlbl9jYmZuOworCisJCWZjeHAtPm5yc3Bfc2dsZXMgPSBucnNwX3NnbGVzOworCQkvKgorCQkgKiBhbGxvYyByZXF1aXJlZCBzZ3BncworCQkgKi8KKwkJaWYgKG5yc3Bfc2dsZXMgPiBCRklfU0dFX0lOTElORSkgeworCQkJbnJzcF9zZ3BnID0gQkZBX1NHUEdfTlBBR0UobnJlcV9zZ2xlcyk7CisKKwkJCWlmIChiZmFfc2dwZ19tYWxsb2MKKwkJCSAgICAoYmZhLCAmZmN4cC0+cnNwX3NncGdfcSwgbnJzcF9zZ3BnKQorCQkJICAgICE9IEJGQV9TVEFUVVNfT0spIHsKKwkJCQkvKiBiZmFfc2dwZ193YWl0KGJmYSwgJmZjeHAtPnJzcF9zZ3BnX3dxZSwKKwkJCQlucnNwX3NncGcpOyAqLworCQkJCS8qCisJCQkJICogVE9ETworCQkJCSAqLworCQkJfQorCQl9CisJfQorCisJcmV0dXJuIChmY3hwKTsKK30KKworLyoqCisgKiBHZXQgdGhlIGludGVybmFsIHJlcXVlc3QgYnVmZmVyIHBvaW50ZXIKKyAqCisgKiBAcGFyYW1baW5dCWZjeHAJQkZBIGZjeHAgcG9pbnRlcgorICoKKyAqIEByZXR1cm4gCQlwb2ludGVyIHRvIHRoZSBpbnRlcm5hbCByZXF1ZXN0IGJ1ZmZlcgorICovCit2b2lkICoKK2JmYV9mY3hwX2dldF9yZXFidWYoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApCit7CisJc3RydWN0IGJmYV9mY3hwX21vZF9zICptb2QgPSBmY3hwLT5mY3hwX21vZDsKKwl2b2lkCSpyZXFidWY7CisKKwliZmFfYXNzZXJ0KGZjeHAtPnVzZV9pcmVxYnVmID09IDEpOworCXJlcWJ1ZiA9ICgodTggKiltb2QtPnJlcV9wbGRfbGlzdF9rdmEpICsKKwkJCWZjeHAtPmZjeHBfdGFnICogbW9kLT5yZXFfcGxkX3N6OworCXJldHVybiByZXFidWY7Cit9CisKK3UzMgorYmZhX2ZjeHBfZ2V0X3JlcWJ1ZnN6KHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwKQoreworCXN0cnVjdCBiZmFfZmN4cF9tb2RfcyAqbW9kID0gZmN4cC0+ZmN4cF9tb2Q7CisKKwlyZXR1cm4gbW9kLT5yZXFfcGxkX3N6OworfQorCisvKioKKyAqIEdldCB0aGUgaW50ZXJuYWwgcmVzcG9uc2UgYnVmZmVyIHBvaW50ZXIKKyAqCisgKiBAcGFyYW1baW5dCWZjeHAJQkZBIGZjeHAgcG9pbnRlcgorICoKKyAqIEByZXR1cm4JCXBvaW50ZXIgdG8gdGhlIGludGVybmFsIHJlcXVlc3QgYnVmZmVyCisgKi8KK3ZvaWQgKgorYmZhX2ZjeHBfZ2V0X3JzcGJ1ZihzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCkKK3sKKwlzdHJ1Y3QgYmZhX2ZjeHBfbW9kX3MgKm1vZCA9IGZjeHAtPmZjeHBfbW9kOworCXZvaWQJKnJzcGJ1ZjsKKworCWJmYV9hc3NlcnQoZmN4cC0+dXNlX2lyc3BidWYgPT0gMSk7CisKKwlyc3BidWYgPSAoKHU4ICopbW9kLT5yc3BfcGxkX2xpc3Rfa3ZhKSArCisJCQlmY3hwLT5mY3hwX3RhZyAqIG1vZC0+cnNwX3BsZF9zejsKKwlyZXR1cm4gcnNwYnVmOworfQorCisvKioKKyAqIAkJRnJlZSB0aGUgQkZBIEZDWFAKKyAqCisgKiBAcGFyYW1baW5dCWZjeHAJCQlCRkEgZmN4cCBwb2ludGVyCisgKgorICogQHJldHVybiAJCXZvaWQKKyAqLwordm9pZAorYmZhX2ZjeHBfZnJlZShzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCkKK3sKKwlzdHJ1Y3QgYmZhX2ZjeHBfbW9kX3MgKm1vZCA9IGZjeHAtPmZjeHBfbW9kOworCisJYmZhX2Fzc2VydChmY3hwICE9IE5VTEwpOworCWJmYV90cmMobW9kLT5iZmEsIGZjeHAtPmZjeHBfdGFnKTsKKwliZmFfZmN4cF9wdXQoZmN4cCk7Cit9CisKKy8qKgorICogU2VuZCBhIEZDWFAgcmVxdWVzdAorICoKKyAqIEBwYXJhbVtpbl0JZmN4cAlCRkEgZmN4cCBwb2ludGVyCisgKiBAcGFyYW1baW5dCXJwb3J0CUJGQSBycG9ydCBwb2ludGVyLiBDb3VsZCBiZSBsZWZ0IE5VTEwgZm9yIFdLQSBycG9ydHMKKyAqIEBwYXJhbVtpbl0JdmZfaWQJdmlydHVhbCBGYWJyaWMgSUQKKyAqIEBwYXJhbVtpbl0JbHBfdGFnICBscG9ydCB0YWcKKyAqIEBwYXJhbVtpbl0JY3RzCXVzZSBDb250aW5vdXMgc2VxdWVuY2UKKyAqIEBwYXJhbVtpbl0JY29zCWZjIENsYXNzIG9mIFNlcnZpY2UKKyAqIEBwYXJhbVtpbl0JcmVxbGVuCXJlcXVlc3QgbGVuZ3RoLCBkb2VzIG5vdCBpbmNsdWRlIEZDSFMgbGVuZ3RoCisgKiBAcGFyYW1baW5dCWZjaHMJZmMgSGVhZGVyIFBvaW50ZXIuIFRoZSBoZWFkZXIgY29udGVudCB3aWxsIGJlIGNvcGllZAorICoJCQlpbiBieSBCRkEuCisgKgorICogQHBhcmFtW2luXQljYmZuCWNhbGwgYmFjayBmdW5jdGlvbiB0byBiZSBjYWxsZWQgb24gcmVjZWl2aW5nCisgKiAJCQkJCQkJCXRoZSByZXNwb25zZQorICogQHBhcmFtW2luXQljYmFyZwlhcmcgZm9yIGNiZm4KKyAqIEBwYXJhbVtpbl0JcnNwX3RpbWVvdXQKKyAqCQkJcmVzcG9uc2UgdGltZW91dAorICoKKyAqIEByZXR1cm4JCWJmYV9zdGF0dXNfdAorICovCit2b2lkCitiZmFfZmN4cF9zZW5kKHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCBzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0LAorCQl1MTYgdmZfaWQsIHU4IGxwX3RhZywgYmZhX2Jvb2xlYW5fdCBjdHMsIGVudW0gZmNfY29zIGNvcywKKwkJdTMyIHJlcWxlbiwgc3RydWN0IGZjaHNfcyAqZmNocywgYmZhX2NiX2ZjeHBfc2VuZF90IGNiZm4sCisJCXZvaWQgKmNiYXJnLCB1MzIgcnNwX21heGxlbiwgdTggcnNwX3RpbWVvdXQpCit7CisJc3RydWN0IGJmYV9zCQkJKmJmYSAgPSBmY3hwLT5mY3hwX21vZC0+YmZhOworCXN0cnVjdCBiZmFfZmN4cF9yZXFfaW5mb19zCSpyZXFpID0gJmZjeHAtPnJlcV9pbmZvOworCXN0cnVjdCBiZmFfZmN4cF9yc3BfaW5mb19zCSpyc3BpID0gJmZjeHAtPnJzcF9pbmZvOworCXN0cnVjdCBiZmlfZmN4cF9zZW5kX3JlcV9zCSpzZW5kX3JlcTsKKworCWJmYV90cmMoYmZhLCBmY3hwLT5mY3hwX3RhZyk7CisKKwkvKioKKwkgKiBzZXR1cCByZXF1ZXN0L3Jlc3BvbnNlIGluZm8KKwkgKi8KKwlyZXFpLT5iZmFfcnBvcnQgPSBycG9ydDsKKwlyZXFpLT52Zl9pZCA9IHZmX2lkOworCXJlcWktPmxwX3RhZyA9IGxwX3RhZzsKKwlyZXFpLT5jbGFzcyA9IGNvczsKKwlyc3BpLT5yc3BfdGltZW91dCA9IHJzcF90aW1lb3V0OworCXJlcWktPmN0cyA9IGN0czsKKwlyZXFpLT5mY2hzID0gKmZjaHM7CisJcmVxaS0+cmVxX3RvdF9sZW4gPSByZXFsZW47CisJcnNwaS0+cnNwX21heGxlbiA9IHJzcF9tYXhsZW47CisJZmN4cC0+c2VuZF9jYmZuID0gY2JmbiA/IGNiZm4gOiBiZmFfZmN4cF9udWxsX2NvbXA7CisJZmN4cC0+c2VuZF9jYmFyZyA9IGNiYXJnOworCisJLyoqCisJICogSWYgbm8gcm9vbSBpbiBDUEUgcXVldWUsIHdhaXQgZm9yCisJICovCisJc2VuZF9yZXEgPSBiZmFfcmVxcV9uZXh0KGJmYSwgQkZBX1JFUVFfRkNYUCk7CisJaWYgKCFzZW5kX3JlcSkgeworCQliZmFfdHJjKGJmYSwgZmN4cC0+ZmN4cF90YWcpOworCQlmY3hwLT5yZXFxX3dhaXRpbmcgPSBCRkFfVFJVRTsKKwkJYmZhX3JlcXFfd2FpdChiZmEsIEJGQV9SRVFRX0ZDWFAsICZmY3hwLT5yZXFxX3dxZSk7CisJCXJldHVybjsKKwl9CisKKwliZmFfZmN4cF9xdWV1ZShmY3hwLCBzZW5kX3JlcSk7Cit9CisKKy8qKgorICogQWJvcnQgYSBCRkEgRkNYUAorICoKKyAqIEBwYXJhbVtpbl0JZmN4cAlCRkEgZmN4cCBwb2ludGVyCisgKgorICogQHJldHVybiAJCXZvaWQKKyAqLworYmZhX3N0YXR1c190CitiZmFfZmN4cF9hYm9ydChzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCkKK3sKKwliZmFfYXNzZXJ0KDApOworCXJldHVybiAoQkZBX1NUQVRVU19PSyk7Cit9CisKK3ZvaWQKK2JmYV9mY3hwX2FsbG9jX3dhaXQoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfZmN4cF93cWVfcyAqd3FlLAorCQkJYmZhX2ZjeHBfYWxsb2NfY2Jmbl90IGFsbG9jX2NiZm4sIHZvaWQgKmFsbG9jX2NiYXJnKQoreworCXN0cnVjdCBiZmFfZmN4cF9tb2RfcyAqbW9kID0gQkZBX0ZDWFBfTU9EKGJmYSk7CisKKwliZmFfYXNzZXJ0KGxpc3RfZW1wdHkoJm1vZC0+ZmN4cF9mcmVlX3EpKTsKKworCXdxZS0+YWxsb2NfY2JmbiA9IGFsbG9jX2NiZm47CisJd3FlLT5hbGxvY19jYmFyZyA9IGFsbG9jX2NiYXJnOworCWxpc3RfYWRkX3RhaWwoJndxZS0+cWUsICZtb2QtPndhaXRfcSk7Cit9CisKK3ZvaWQKK2JmYV9mY3hwX3dhbGxvY19jYW5jZWwoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfZmN4cF93cWVfcyAqd3FlKQoreworCXN0cnVjdCBiZmFfZmN4cF9tb2RfcyAqbW9kID0gQkZBX0ZDWFBfTU9EKGJmYSk7CisKKwliZmFfYXNzZXJ0KGJmYV9xX2lzX29uX3EoJm1vZC0+d2FpdF9xLCB3cWUpKTsKKwlsaXN0X2RlbCgmd3FlLT5xZSk7Cit9CisKK3ZvaWQKK2JmYV9mY3hwX2Rpc2NhcmQoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApCit7CisJLyoqCisJICogSWYgd2FpdGluZyBmb3Igcm9vbSBpbiByZXF1ZXN0IHF1ZXVlLCBjYW5jZWwgcmVxcSB3YWl0CisJICogYW5kIGZyZWUgZmN4cC4KKwkgKi8KKwlpZiAoZmN4cC0+cmVxcV93YWl0aW5nKSB7CisJCWZjeHAtPnJlcXFfd2FpdGluZyA9IEJGQV9GQUxTRTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmZmN4cC0+cmVxcV93cWUpOworCQliZmFfZmN4cF9mcmVlKGZjeHApOworCQlyZXR1cm47CisJfQorCisJZmN4cC0+c2VuZF9jYmZuID0gYmZhX2ZjeHBfbnVsbF9jb21wOworfQorCisKKworLyoqCisgKiAgaGFsX2ZjeHBfcHVibGljIEJGQSBGQ1hQIHB1YmxpYyBmdW5jdGlvbnMKKyAqLworCit2b2lkCitiZmFfZmN4cF9pc3Ioc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm1zZykKK3sKKwlzd2l0Y2ggKG1zZy0+bWhkci5tc2dfaWQpIHsKKwljYXNlIEJGSV9GQ1hQX0kySF9TRU5EX1JTUDoKKwkJaGFsX2ZjeHBfc2VuZF9jb21wKGJmYSwgKHN0cnVjdCBiZmlfZmN4cF9zZW5kX3JzcF9zICopIG1zZyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3RyYyhiZmEsIG1zZy0+bWhkci5tc2dfaWQpOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKwordTMyCitiZmFfZmN4cF9nZXRfbWF4cnNwKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfZmN4cF9tb2RfcyAqbW9kID0gQkZBX0ZDWFBfTU9EKGJmYSk7CisKKwlyZXR1cm4gbW9kLT5yc3BfcGxkX3N6OworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjeHBfcHJpdi5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfZmN4cF9wcml2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGNkYTQ5MwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ZjeHBfcHJpdi5oCkBAIC0wLDAgKzEsMTM4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfRkNYUF9QUklWX0hfXworI2RlZmluZSBfX0JGQV9GQ1hQX1BSSVZfSF9fCisKKyNpbmNsdWRlIDxjcy9iZmFfc20uaD4KKyNpbmNsdWRlIDxwcm90b2NvbC9mYy5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX2ZjeHAuaD4KKworI2RlZmluZSBCRkFfRkNYUF9NSU4gICAgIAkoMSkKKyNkZWZpbmUgQkZBX0ZDWFBfTUFYX0lCVUZfU1oJKDIgKiAxMDI0ICsgMjU2KQorI2RlZmluZSBCRkFfRkNYUF9NQVhfTEJVRl9TWgkoNCAqIDEwMjQgKyAyNTYpCisKK3N0cnVjdCBiZmFfZmN4cF9tb2RfcyB7CisJc3RydWN0IGJmYV9zICAgICAgKmJmYTsJCS8qICBiYWNrcG9pbnRlciB0byBCRkEgKi8KKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9saXN0OwkvKiAgYXJyYXkgb2YgRkNYUHMgKi8KKwl1MTYgICAgICAgIG51bV9mY3hwczsJLyogIG1heCBudW0gRkNYUCByZXF1ZXN0cyAqLworCXN0cnVjdCBsaXN0X2hlYWQgZmN4cF9mcmVlX3E7CS8qICBmcmVlIEZDWFBzICovCisJc3RydWN0IGxpc3RfaGVhZCBmY3hwX2FjdGl2ZV9xOwkvKiAgYWN0aXZlIEZDWFBzICovCisJdm9pZAkqcmVxX3BsZF9saXN0X2t2YTsJLyogIGxpc3Qgb2YgRkNYUCByZXEgcGxkICovCisJdTY0IHJlcV9wbGRfbGlzdF9wYTsJLyogIGxpc3Qgb2YgRkNYUCByZXEgcGxkICovCisJdm9pZCAqcnNwX3BsZF9saXN0X2t2YTsJCS8qICBsaXN0IG9mIEZDWFAgcmVzcCBwbGQgKi8KKwl1NjQgcnNwX3BsZF9saXN0X3BhOwkvKiAgbGlzdCBvZiBGQ1hQIHJlc3AgcGxkICovCisJc3RydWN0IGxpc3RfaGVhZCAgd2FpdF9xOwkJLyogIHdhaXQgcXVldWUgZm9yIGZyZWUgZmN4cCAqLworCXUzMglyZXFfcGxkX3N6OworCXUzMglyc3BfcGxkX3N6OworfTsKKworI2RlZmluZSBCRkFfRkNYUF9NT0QoX19iZmEpCQkoJihfX2JmYSktPm1vZHVsZXMuZmN4cF9tb2QpCisjZGVmaW5lIEJGQV9GQ1hQX0ZST01fVEFHKF9fbW9kLCBfX3RhZykJKCYoX19tb2QpLT5mY3hwX2xpc3RbX190YWddKQorCit0eXBlZGVmIHZvaWQgICAgKCpmY3hwX3NlbmRfY2JfdCkgKHN0cnVjdCBiZmFfcyAqaW9jLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkgICB2b2lkICpjYl9hcmcsIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCSAgIHUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJCSAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKKworLyoqCisgKiBJbmZvcm1hdGlvbiBuZWVkZWQgZm9yIGEgRkNYUCByZXF1ZXN0CisgKi8KK3N0cnVjdCBiZmFfZmN4cF9yZXFfaW5mb19zIHsKKwlzdHJ1Y3QgYmZhX3Jwb3J0X3MgKmJmYV9ycG9ydDsJLyogIFBvaW50ZXIgdG8gdGhlIGJmYSBycG9ydCB0aGF0IHdhcworCQkJCQkgKnJldHVybmVkIGZyb20gYmZhX3Jwb3J0X2NyZWF0ZSgpLgorCQkJCQkgKlRoaXMgY291bGQgYmUgbGVmdCBOVUxMIGZvciBXS0Egb3IgZm9yCisJCQkJCSAqRkNYUCBpbnRlcmFjdGlvbnMgYmVmb3JlIHRoZSBycG9ydAorCQkJCQkgKm5leHVzIGlzIGVzdGFibGlzaGVkCisJCQkJCSAqLworCXN0cnVjdCBmY2hzX3MgICBmY2hzOwkvKiAgcmVxdWVzdCBGQyBoZWFkZXIgc3RydWN0dXJlICovCisJdTggY3RzOwkJLyogIGNvbnRpbm91cyBzZXF1ZW5jZSAqLworCXU4IGNsYXNzOwkJLyogIEZDIGNsYXNzIGZvciB0aGUgcmVxdWVzdC9yZXNwb25zZSAqLworCXUxNiBtYXhfZnJtc3o7CS8qICBtYXggc2VuZCBmcmFtZSBzaXplICovCisJdTE2IHZmX2lkOwkJLyogIHZzYW4gdGFnIGlmIGFwcGxpY2FibGUgKi8KKwl1OAlscF90YWc7CQkvKiAgbHBvcnQgdGFnICovCisJdTMyIHJlcV90b3RfbGVuOwkvKiAgcmVxdWVzdCBwYXlsb2FkIHRvdGFsIGxlbmd0aCAqLworfTsKKworc3RydWN0IGJmYV9mY3hwX3JzcF9pbmZvX3MgeworCXN0cnVjdCBmY2hzX3MgcnNwX2ZjaHM7CQkvKiAgUmVzcG9uc2UgZnJhbWUncyBGQyBoZWFkZXIgd2lsbAorCQkJCQkgKiBiZSAqc2VudCBiYWNrIGluIHRoaXMgZmllbGQgKi8KKwl1OCAgICAgICAgIHJzcF90aW1lb3V0OwkvKiAgdGltZW91dCBpbiBzZWNvbmRzLCAwLW5vIHJlc3BvbnNlCisJCQkJCSAqLworCXU4ICAgICAgICAgcnN2ZDJbM107CisJdTMyICAgICAgICByc3BfbWF4bGVuOwkvKiAgbWF4IHJlc3BvbnNlIGxlbmd0aCBleHBlY3RlZCAqLworfTsKKworc3RydWN0IGJmYV9mY3hwX3MgeworCXN0cnVjdCBsaXN0X2hlYWQgCXFlOwkJLyogIGZjeHAgcXVldWUgZWxlbWVudCAqLworCWJmYV9zbV90ICAgICAgICBzbTsgICAgICAgICAgICAgLyogIHN0YXRlIG1hY2hpbmUgKi8KKwl2b2lkICAgICAgICAgICAJKmNhbGxlcjsJLyogIGRyaXZlciBvciBmY3MgKi8KKwlzdHJ1Y3QgYmZhX2ZjeHBfbW9kX3MgKmZjeHBfbW9kOworCQkJCQkvKiAgYmFjayBwb2ludGVyIHRvIGZjeHAgbW9kICovCisJdTE2ICAgICAgICBmY3hwX3RhZzsJLyogIGludGVybmFsIHRhZyAqLworCXN0cnVjdCBiZmFfZmN4cF9yZXFfaW5mb19zIHJlcV9pbmZvOworCQkJCQkvKiAgcmVxdWVzdCBpbmZvICovCisJc3RydWN0IGJmYV9mY3hwX3JzcF9pbmZvX3MgcnNwX2luZm87CisJCQkJCS8qICByZXNwb25zZSBpbmZvICovCisJdTggCXVzZV9pcmVxYnVmOwkvKiAgdXNlIGludGVybmFsIHJlcSBidWYgKi8KKwl1OCAgICAgICAgIHVzZV9pcnNwYnVmOwkvKiAgdXNlIGludGVybmFsIHJzcCBidWYgKi8KKwl1MzIgICAgICAgIG5yZXFfc2dsZXM7CS8qICBudW0gcmVxdWVzdCBTR0xFcyAqLworCXUzMiAgICAgICAgbnJzcF9zZ2xlczsJLyogIG51bSByZXNwb25zZSBTR0xFcyAqLworCXN0cnVjdCBsaXN0X2hlYWQgcmVxX3NncGdfcTsJLyogIFNHIHBhZ2VzIGZvciByZXF1ZXN0IGJ1ZiAqLworCXN0cnVjdCBsaXN0X2hlYWQgcmVxX3NncGdfd3FlOwkvKiAgd2FpdCBxdWV1ZSBmb3IgcmVxIFNHIHBhZ2UgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIHJzcF9zZ3BnX3E7CS8qICBTRyBwYWdlcyBmb3IgcmVzcG9uc2UgYnVmICovCisJc3RydWN0IGxpc3RfaGVhZCByc3Bfc2dwZ193cWU7CS8qICB3YWl0IHF1ZXVlIGZvciByc3AgU0cgcGFnZSAqLworCisJYmZhX2ZjeHBfZ2V0X3NnYWRkcl90IHJlcV9zZ2FfY2JmbjsKKwkJCQkJLyogIFNHIGVsZW0gYWRkciB1c2VyIGZ1bmN0aW9uICovCisJYmZhX2ZjeHBfZ2V0X3NnbGVuX3QgcmVxX3NnbGVuX2NiZm47CisJCQkJCS8qICBTRyBlbGVtIGxlbiB1c2VyIGZ1bmN0aW9uICovCisJYmZhX2ZjeHBfZ2V0X3NnYWRkcl90IHJzcF9zZ2FfY2JmbjsKKwkJCQkJLyogIFNHIGVsZW0gYWRkciB1c2VyIGZ1bmN0aW9uICovCisJYmZhX2ZjeHBfZ2V0X3NnbGVuX3QgcnNwX3NnbGVuX2NiZm47CisJCQkJCS8qICBTRyBlbGVtIGxlbiB1c2VyIGZ1bmN0aW9uICovCisJYmZhX2NiX2ZjeHBfc2VuZF90IHNlbmRfY2JmbjsgICAvKiAgc2VuZCBjb21wbGV0aW9uIGNhbGxiYWNrICovCisJdm9pZAkJKnNlbmRfY2Jhcmc7CS8qICBjYWxsYmFjayBhcmcgKi8KKwlzdHJ1Y3QgYmZhX3NnZV9zICAgcmVxX3NnZVtCRkFfRkNYUF9NQVhfU0dFU107CisJCQkJCS8qICByZXEgU0cgZWxlbXMgKi8KKwlzdHJ1Y3QgYmZhX3NnZV9zICAgcnNwX3NnZVtCRkFfRkNYUF9NQVhfU0dFU107CisJCQkJCS8qICByc3AgU0cgZWxlbXMgKi8KKwl1OCAgICAgICAgIHJzcF9zdGF0dXM7CS8qICBjb21wOiByc3Agc3RhdHVzICovCisJdTMyICAgICAgICByc3BfbGVuOwkvKiAgY29tcDogYWN0dWFsIHJlc3BvbnNlIGxlbiAqLworCXUzMiAgICAgICAgcmVzaWR1ZV9sZW47CS8qICBjb21wOiByZXNpZHVhbCByc3AgbGVuZ3RoICovCisJc3RydWN0IGZjaHNfcyAgICAgICAgICByc3BfZmNoczsJLyogIGNvbXA6IHJlc3BvbnNlIGZjaHMgKi8KKwlzdHJ1Y3QgYmZhX2NiX3FlX3MgICAgaGNiX3FlOwkvKiAgY29tcDogY2FsbGJhY2sgcWVsZW0gKi8KKwlzdHJ1Y3QgYmZhX3JlcXFfd2FpdF9zCXJlcXFfd3FlOworCWJmYV9ib29sZWFuX3QJcmVxcV93YWl0aW5nOworfTsKKworI2RlZmluZSBCRkFfRkNYUF9SRVFfUExEKF9mY3hwKSAJKGJmYV9mY3hwX2dldF9yZXFidWYoX2ZjeHApKQorCisjZGVmaW5lIEJGQV9GQ1hQX1JTUF9GQ0hTKF9mY3hwKSAJKCYoKF9mY3hwKS0+cnNwX2luZm8uZmNocykpCisjZGVmaW5lIEJGQV9GQ1hQX1JTUF9QTEQoX2ZjeHApIAkoYmZhX2ZjeHBfZ2V0X3JzcGJ1ZihfZmN4cCkpCisKKyNkZWZpbmUgQkZBX0ZDWFBfUkVRX1BMRF9QQShfZmN4cCkJCQkJCVwKKwkoKF9mY3hwKS0+ZmN4cF9tb2QtPnJlcV9wbGRfbGlzdF9wYSArCQkJCVwKKwkJKChfZmN4cCktPmZjeHBfbW9kLT5yZXFfcGxkX3N6ICAqIChfZmN4cCktPmZjeHBfdGFnKSkKKworI2RlZmluZSBCRkFfRkNYUF9SU1BfUExEX1BBKF9mY3hwKSAJCQkJCVwKKwkoKF9mY3hwKS0+ZmN4cF9tb2QtPnJzcF9wbGRfbGlzdF9wYSArCQkJCVwKKwkJKChfZmN4cCktPmZjeHBfbW9kLT5yc3BfcGxkX3N6ICogKF9mY3hwKS0+ZmN4cF90YWcpKQorCit2b2lkCWJmYV9mY3hwX2lzcihzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmaV9tc2dfcyAqbXNnKTsKKyNlbmRpZiAvKiBfX0JGQV9GQ1hQX1BSSVZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9md2ltZ19wcml2LmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9md2ltZ19wcml2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWVjMTM1NQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2Z3aW1nX3ByaXYuaApAQCAtMCwwICsxLDMxIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfRldJTUdfUFJJVl9IX18KKyNkZWZpbmUgX19CRkFfRldJTUdfUFJJVl9IX18KKworI2RlZmluZQlCRklfRkxBU0hfQ0hVTktfU1oJCTI1NgkvKiAgRmxhc2ggY2h1bmsgc2l6ZSAqLworI2RlZmluZQlCRklfRkxBU0hfQ0hVTktfU1pfV09SRFMJKEJGSV9GTEFTSF9DSFVOS19TWi9zaXplb2YodTMyKSkKKworZXh0ZXJuIHUzMiAqYmZpX2ltYWdlX2N0X2dldF9jaHVuayh1MzIgb2ZmKTsKK2V4dGVybiB1MzIgYmZpX2ltYWdlX2N0X3NpemU7CitleHRlcm4gdTMyICpiZmlfaW1hZ2VfY2JfZ2V0X2NodW5rKHUzMiBvZmYpOworZXh0ZXJuIHUzMiBiZmlfaW1hZ2VfY2Jfc2l6ZTsKK2V4dGVybiB1MzIgKmJmaV9pbWFnZV9jYjsKK2V4dGVybiB1MzIgKmJmaV9pbWFnZV9jdDsKKworI2VuZGlmIC8qIF9fQkZBX0ZXSU1HX1BSSVZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9od19jYi5jIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaHdfY2IuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZGUxNDM4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaHdfY2IuYwpAQCAtMCwwICsxLDE0MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSA8YmZhX3ByaXYuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX2NicmVnLmg+CisKK3ZvaWQKK2JmYV9od2NiX3JlZ2luaXQoc3RydWN0IGJmYV9zICpiZmEpCit7CisJc3RydWN0IGJmYV9pb2NmY19yZWdzX3MJKmJmYV9yZWdzID0gJmJmYS0+aW9jZmMuYmZhX3JlZ3M7CisJYmZhX29zX2FkZHJfdAkJa3ZhID0gYmZhX2lvY19iYXIwKCZiZmEtPmlvYyk7CisJaW50ICAgICAgICAgICAgIAlpLCBxLCBmbiA9IGJmYV9pb2NfcGNpZm4oJmJmYS0+aW9jKTsKKworCWlmIChmbiA9PSAwKSB7CisJCWJmYV9yZWdzLT5pbnRyX3N0YXR1cyA9IChrdmEgKyBIT1NURk4wX0lOVF9TVEFUVVMpOworCQliZmFfcmVncy0+aW50cl9tYXNrICAgPSAoa3ZhICsgSE9TVEZOMF9JTlRfTVNLKTsKKwl9IGVsc2UgeworCQliZmFfcmVncy0+aW50cl9zdGF0dXMgPSAoa3ZhICsgSE9TVEZOMV9JTlRfU1RBVFVTKTsKKwkJYmZhX3JlZ3MtPmludHJfbWFzayAgID0gKGt2YSArIEhPU1RGTjFfSU5UX01TSyk7CisJfQorCisJZm9yIChpID0gMDsgaSA8IEJGSV9JT0NfTUFYX0NRUzsgaSsrKSB7CisJCS8qCisJCSAqIENQRSByZWdpc3RlcnMKKwkJICovCisJCXEgPSBDUEVfUV9OVU0oZm4sIGkpOworCQliZmFfcmVncy0+Y3BlX3FfcGlbaV0gPSAoa3ZhICsgQ1BFX1FfUEkocSkpOworCQliZmFfcmVncy0+Y3BlX3FfY2lbaV0gPSAoa3ZhICsgQ1BFX1FfQ0kocSkpOworCQliZmFfcmVncy0+Y3BlX3FfZGVwdGhbaV0gPSAoa3ZhICsgQ1BFX1FfREVQVEgocSkpOworCisJCS8qCisJCSAqIFJNRSByZWdpc3RlcnMKKwkJICovCisJCXEgPSBDUEVfUV9OVU0oZm4sIGkpOworCQliZmFfcmVncy0+cm1lX3FfcGlbaV0gPSAoa3ZhICsgUk1FX1FfUEkocSkpOworCQliZmFfcmVncy0+cm1lX3FfY2lbaV0gPSAoa3ZhICsgUk1FX1FfQ0kocSkpOworCQliZmFfcmVncy0+cm1lX3FfZGVwdGhbaV0gPSAoa3ZhICsgUk1FX1FfREVQVEgocSkpOworCX0KK30KKwordm9pZAorYmZhX2h3Y2JfcnNwcV9hY2soc3RydWN0IGJmYV9zICpiZmEsIGludCByc3BxKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX2h3Y2JfcnNwcV9hY2tfbXNpeChzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IHJzcHEpCit7CisJYmZhX3JlZ193cml0ZShiZmEtPmlvY2ZjLmJmYV9yZWdzLmludHJfc3RhdHVzLAorCQlfX0hGTl9JTlRfUk1FX1EwIDw8IFJNRV9RX05VTShiZmFfaW9jX3BjaWZuKCZiZmEtPmlvYyksIHJzcHEpKTsKK30KKwordm9pZAorYmZhX2h3Y2JfbXNpeF9nZXR2ZWNzKHN0cnVjdCBiZmFfcyAqYmZhLCB1MzIgKm1zaXhfdmVjc19ibWFwLAorCQkgdTMyICpudW1fdmVjcywgdTMyICptYXhfdmVjX2JpdCkKK3sKKyNkZWZpbmUgX19IRk5fTlVNSU5UUwkxMworCWlmIChiZmFfaW9jX3BjaWZuKCZiZmEtPmlvYykgPT0gMCkgeworCQkqbXNpeF92ZWNzX2JtYXAgPSAoX19IRk5fSU5UX0NQRV9RMCB8IF9fSEZOX0lOVF9DUEVfUTEgfAorCQkJCSAgIF9fSEZOX0lOVF9DUEVfUTIgfCBfX0hGTl9JTlRfQ1BFX1EzIHwKKwkJCQkgICBfX0hGTl9JTlRfUk1FX1EwIHwgX19IRk5fSU5UX1JNRV9RMSB8CisJCQkJICAgX19IRk5fSU5UX1JNRV9RMiB8IF9fSEZOX0lOVF9STUVfUTMgfAorCQkJCSAgIF9fSEZOX0lOVF9NQk9YX0xQVTApOworCQkqbWF4X3ZlY19iaXQgPSBfX0hGTl9JTlRfTUJPWF9MUFUwOworCX0gZWxzZSB7CisJCSptc2l4X3ZlY3NfYm1hcCA9IChfX0hGTl9JTlRfQ1BFX1E0IHwgX19IRk5fSU5UX0NQRV9RNSB8CisJCQkJICAgX19IRk5fSU5UX0NQRV9RNiB8IF9fSEZOX0lOVF9DUEVfUTcgfAorCQkJCSAgIF9fSEZOX0lOVF9STUVfUTQgfCBfX0hGTl9JTlRfUk1FX1E1IHwKKwkJCQkgICBfX0hGTl9JTlRfUk1FX1E2IHwgX19IRk5fSU5UX1JNRV9RNyB8CisJCQkJICAgX19IRk5fSU5UX01CT1hfTFBVMSk7CisJCSptYXhfdmVjX2JpdCA9IF9fSEZOX0lOVF9NQk9YX0xQVTE7CisJfQorCisJKm1zaXhfdmVjc19ibWFwIHw9IChfX0hGTl9JTlRfRVJSX0VNQyB8IF9fSEZOX0lOVF9FUlJfTFBVMCB8CisJCQkgICAgX19IRk5fSU5UX0VSUl9MUFUxIHwgX19IRk5fSU5UX0VSUl9QU1MpOworCSpudW1fdmVjcyA9IF9fSEZOX05VTUlOVFM7Cit9CisKKy8qKgorICogTm8gc3BlY2lhbCBzZXR1cCByZXF1aXJlZCBmb3IgY3Jvc3Nib3cgLS0gdmVjdG9yIGFzc2lnbm1lbnRzIGFyZSBpbXBsaWNpdC4KKyAqLwordm9pZAorYmZhX2h3Y2JfbXNpeF9pbml0KHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgbnZlY3MpCit7CisJaW50IGk7CisKKwliZmFfYXNzZXJ0KChudmVjcyA9PSAxKSB8fCAobnZlY3MgPT0gX19IRk5fTlVNSU5UUykpOworCisJYmZhLT5tc2l4Lm52ZWNzID0gbnZlY3M7CisJaWYgKG52ZWNzID09IDEpIHsKKwkJZm9yIChpID0gMDsgaSA8IEJGQV9NU0lYX0NCX01BWDsgaSsrKQorCQkJYmZhLT5tc2l4LmhhbmRsZXJbaV0gPSBiZmFfbXNpeF9hbGw7CisJCXJldHVybjsKKwl9CisKKwlmb3IgKGkgPSBCRkFfTVNJWF9DUEVfUTA7IGkgPD0gQkZBX01TSVhfQ1BFX1E3OyBpKyspCisJCWJmYS0+bXNpeC5oYW5kbGVyW2ldID0gYmZhX21zaXhfcmVxcTsKKworCWZvciAoaSA9IEJGQV9NU0lYX1JNRV9RMDsgaSA8PSBCRkFfTVNJWF9STUVfUTc7IGkrKykKKwkJYmZhLT5tc2l4LmhhbmRsZXJbaV0gPSBiZmFfbXNpeF9yc3BxOworCisJZm9yICg7IGkgPCBCRkFfTVNJWF9DQl9NQVg7IGkrKykKKwkJYmZhLT5tc2l4LmhhbmRsZXJbaV0gPSBiZmFfbXNpeF9scHVfZXJyOworfQorCisvKioKKyAqIENyb3NzYm93IC0tIGR1bW15LCBpbnRlcnJ1cHRzIGFyZSBtYXNrZWQKKyAqLwordm9pZAorYmZhX2h3Y2JfbXNpeF9pbnN0YWxsKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCit2b2lkCitiZmFfaHdjYl9tc2l4X3VuaW5zdGFsbChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworLyoqCisgKiBObyBzcGVjaWFsIGVuYWJsZS9kaXNhYmxlIC0tIHZlY3RvciBhc3NpZ25tZW50cyBhcmUgaW1wbGljaXQuCisgKi8KK3ZvaWQKK2JmYV9od2NiX2lzcl9tb2RlX3NldChzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2Jvb2xlYW5fdCBtc2l4KQoreworCWJmYS0+aW9jZmMuaHdpZi5od19yc3BxX2FjayA9IGJmYV9od2NiX3JzcHFfYWNrX21zaXg7Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfaHdfY3QuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2h3X2N0LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTFhZTU3NAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2h3X2N0LmMKQEAgLTAsMCArMSwxNjIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYV9wcml2Lmg+CisjaW5jbHVkZSA8YmZpL2JmaV9jdHJlZy5oPgorI2luY2x1ZGUgPGJmYV9pb2MuaD4KKworQkZBX1RSQ19GSUxFKEhBTCwgSU9DRkNfQ1QpOworCitzdGF0aWMgdTMyIF9fY3RfbXNpeF9lcnJfdmVjX3JlZ1tdID0geworCUhPU1RfTVNJWF9FUlJfSU5ERVhfRk4wLAorCUhPU1RfTVNJWF9FUlJfSU5ERVhfRk4xLAorCUhPU1RfTVNJWF9FUlJfSU5ERVhfRk4yLAorCUhPU1RfTVNJWF9FUlJfSU5ERVhfRk4zLAorfTsKKworc3RhdGljIHZvaWQKK2JmYV9od2N0X21zaXhfbHB1X2Vycl9zZXQoc3RydWN0IGJmYV9zICpiZmEsIGJmYV9ib29sZWFuX3QgbXNpeCwgaW50IHZlYykKK3sKKwlpbnQgZm4gPSBiZmFfaW9jX3BjaWZuKCZiZmEtPmlvYyk7CisJYmZhX29zX2FkZHJfdCBrdmEgPSBiZmFfaW9jX2JhcjAoJmJmYS0+aW9jKTsKKworCWlmIChtc2l4KQorCQliZmFfcmVnX3dyaXRlKGt2YSArIF9fY3RfbXNpeF9lcnJfdmVjX3JlZ1tmbl0sIHZlYyk7CisJZWxzZQorCQliZmFfcmVnX3dyaXRlKGt2YSArIF9fY3RfbXNpeF9lcnJfdmVjX3JlZ1tmbl0sIDApOworfQorCisvKioKKyAqIER1bW15IGludGVycnVwdCBoYW5kbGVyIGZvciBoYW5kbGluZyBzcHVyaW91cyBpbnRlcnJ1cHQgZHVyaW5nIGNoaXAtcmVpbml0LgorICovCitzdGF0aWMgdm9pZAorYmZhX2h3Y3RfbXNpeF9kdW1teShzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IHZlYykKK3sKK30KKwordm9pZAorYmZhX2h3Y3RfcmVnaW5pdChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX2lvY2ZjX3JlZ3NfcwkqYmZhX3JlZ3MgPSAmYmZhLT5pb2NmYy5iZmFfcmVnczsKKwliZmFfb3NfYWRkcl90CQlrdmEgPSBiZmFfaW9jX2JhcjAoJmJmYS0+aW9jKTsKKwlpbnQgICAgICAgICAgICAgCWksIHEsIGZuID0gYmZhX2lvY19wY2lmbigmYmZhLT5pb2MpOworCisJaWYgKGZuID09IDApIHsKKwkJYmZhX3JlZ3MtPmludHJfc3RhdHVzID0gKGt2YSArIEhPU1RGTjBfSU5UX1NUQVRVUyk7CisJCWJmYV9yZWdzLT5pbnRyX21hc2sgICA9IChrdmEgKyBIT1NURk4wX0lOVF9NU0spOworCX0gZWxzZSB7CisJCWJmYV9yZWdzLT5pbnRyX3N0YXR1cyA9IChrdmEgKyBIT1NURk4xX0lOVF9TVEFUVVMpOworCQliZmFfcmVncy0+aW50cl9tYXNrICAgPSAoa3ZhICsgSE9TVEZOMV9JTlRfTVNLKTsKKwl9CisKKwlmb3IgKGkgPSAwOyBpIDwgQkZJX0lPQ19NQVhfQ1FTOyBpKyspIHsKKwkJLyoKKwkJICogQ1BFIHJlZ2lzdGVycworCQkgKi8KKwkJcSA9IENQRV9RX05VTShmbiwgaSk7CisJCWJmYV9yZWdzLT5jcGVfcV9waVtpXSA9IChrdmEgKyBDUEVfUElfUFRSX1EocSA8PCA1KSk7CisJCWJmYV9yZWdzLT5jcGVfcV9jaVtpXSA9IChrdmEgKyBDUEVfQ0lfUFRSX1EocSA8PCA1KSk7CisJCWJmYV9yZWdzLT5jcGVfcV9kZXB0aFtpXSA9IChrdmEgKyBDUEVfREVQVEhfUShxIDw8IDUpKTsKKwkJYmZhX3JlZ3MtPmNwZV9xX2N0cmxbaV0gPSAoa3ZhICsgQ1BFX1FDVFJMX1EocSA8PCA1KSk7CisKKwkJLyoKKwkJICogUk1FIHJlZ2lzdGVycworCQkgKi8KKwkJcSA9IENQRV9RX05VTShmbiwgaSk7CisJCWJmYV9yZWdzLT5ybWVfcV9waVtpXSA9IChrdmEgKyBSTUVfUElfUFRSX1EocSA8PCA1KSk7CisJCWJmYV9yZWdzLT5ybWVfcV9jaVtpXSA9IChrdmEgKyBSTUVfQ0lfUFRSX1EocSA8PCA1KSk7CisJCWJmYV9yZWdzLT5ybWVfcV9kZXB0aFtpXSA9IChrdmEgKyBSTUVfREVQVEhfUShxIDw8IDUpKTsKKwkJYmZhX3JlZ3MtPnJtZV9xX2N0cmxbaV0gPSAoa3ZhICsgUk1FX1FDVFJMX1EocSA8PCA1KSk7CisJfQorfQorCit2b2lkCitiZmFfaHdjdF9yc3BxX2FjayhzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IHJzcHEpCit7CisJdTMyCXIzMjsKKworCXIzMiA9IGJmYV9yZWdfcmVhZChiZmEtPmlvY2ZjLmJmYV9yZWdzLnJtZV9xX2N0cmxbcnNwcV0pOworCWJmYV9yZWdfd3JpdGUoYmZhLT5pb2NmYy5iZmFfcmVncy5ybWVfcV9jdHJsW3JzcHFdLCByMzIpOworfQorCit2b2lkCitiZmFfaHdjdF9tc2l4X2dldHZlY3Moc3RydWN0IGJmYV9zICpiZmEsIHUzMiAqbXNpeF92ZWNzX2JtYXAsCisJCSB1MzIgKm51bV92ZWNzLCB1MzIgKm1heF92ZWNfYml0KQoreworCSptc2l4X3ZlY3NfYm1hcCA9ICgxIDw8IEJGQV9NU0lYX0NUX01BWCkgLSAxOworCSptYXhfdmVjX2JpdCA9ICgxIDw8IChCRkFfTVNJWF9DVF9NQVggLSAxKSk7CisJKm51bV92ZWNzID0gQkZBX01TSVhfQ1RfTUFYOworfQorCisvKioKKyAqIFNldHVwIE1TSS1YIHZlY3RvciBmb3IgY2F0YXB1bHQKKyAqLwordm9pZAorYmZhX2h3Y3RfbXNpeF9pbml0KHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgbnZlY3MpCit7CisJYmZhX2Fzc2VydCgobnZlY3MgPT0gMSkgfHwgKG52ZWNzID09IEJGQV9NU0lYX0NUX01BWCkpOworCWJmYV90cmMoYmZhLCBudmVjcyk7CisKKwliZmEtPm1zaXgubnZlY3MgPSBudmVjczsKKwliZmFfaHdjdF9tc2l4X3VuaW5zdGFsbChiZmEpOworfQorCit2b2lkCitiZmFfaHdjdF9tc2l4X2luc3RhbGwoc3RydWN0IGJmYV9zICpiZmEpCit7CisJaW50IGk7CisKKwlpZiAoYmZhLT5tc2l4Lm52ZWNzID09IDApCisJCXJldHVybjsKKworCWlmIChiZmEtPm1zaXgubnZlY3MgPT0gMSkgeworCQlmb3IgKGkgPSAwOyBpIDwgQkZBX01TSVhfQ1RfTUFYOyBpKyspCisJCQliZmEtPm1zaXguaGFuZGxlcltpXSA9IGJmYV9tc2l4X2FsbDsKKwkJcmV0dXJuOworCX0KKworCWZvciAoaSA9IEJGQV9NU0lYX0NQRV9RMDsgaSA8PSBCRkFfTVNJWF9DUEVfUTM7IGkrKykKKwkJYmZhLT5tc2l4LmhhbmRsZXJbaV0gPSBiZmFfbXNpeF9yZXFxOworCisJZm9yICg7IGkgPD0gQkZBX01TSVhfUk1FX1EzOyBpKyspCisJCWJmYS0+bXNpeC5oYW5kbGVyW2ldID0gYmZhX21zaXhfcnNwcTsKKworCWJmYV9hc3NlcnQoaSA9PSBCRkFfTVNJWF9MUFVfRVJSKTsKKwliZmEtPm1zaXguaGFuZGxlcltCRkFfTVNJWF9MUFVfRVJSXSA9IGJmYV9tc2l4X2xwdV9lcnI7Cit9CisKK3ZvaWQKK2JmYV9od2N0X21zaXhfdW5pbnN0YWxsKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWludCBpOworCisJZm9yIChpID0gMDsgaSA8IEJGQV9NU0lYX0NUX01BWDsgaSsrKQorCQliZmEtPm1zaXguaGFuZGxlcltpXSA9IGJmYV9od2N0X21zaXhfZHVtbXk7Cit9CisKKy8qKgorICogRW5hYmxlIE1TSS1YIHZlY3RvcnMKKyAqLwordm9pZAorYmZhX2h3Y3RfaXNyX21vZGVfc2V0KHN0cnVjdCBiZmFfcyAqYmZhLCBiZmFfYm9vbGVhbl90IG1zaXgpCit7CisJYmZhX3RyYyhiZmEsIDApOworCWJmYV9od2N0X21zaXhfbHB1X2Vycl9zZXQoYmZhLCBtc2l4LCBCRkFfTVNJWF9MUFVfRVJSKTsKKwliZmFfaW9jX2lzcl9tb2RlX3NldCgmYmZhLT5pb2MsIG1zaXgpOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ludHIuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ludHIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wY2ExMjU3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW50ci5jCkBAIC0wLDAgKzEsMjE4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaW5jbHVkZSA8YmZhLmg+CisjaW5jbHVkZSA8YmZpL2JmaV9jYnJlZy5oPgorI2luY2x1ZGUgPGJmYV9wb3J0X3ByaXYuaD4KKyNpbmNsdWRlIDxiZmFfaW50cl9wcml2Lmg+CisjaW5jbHVkZSA8Y3MvYmZhX2RlYnVnLmg+CisKK0JGQV9UUkNfRklMRShIQUwsIElOVFIpOworCitzdGF0aWMgdm9pZAorYmZhX21zaXhfZXJyaW50KHN0cnVjdCBiZmFfcyAqYmZhLCB1MzIgaW50cikKK3sKKwliZmFfaW9jX2Vycm9yX2lzcigmYmZhLT5pb2MpOworfQorCitzdGF0aWMgdm9pZAorYmZhX21zaXhfbHB1KHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWJmYV9pb2NfbWJveF9pc3IoJmJmYS0+aW9jKTsKK30KKwordm9pZAorYmZhX21zaXhfYWxsKHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgdmVjKQoreworCWJmYV9pbnR4KGJmYSk7Cit9CisKKy8qKgorICogIGhhbF9pbnRyX2FwaQorICovCitiZmFfYm9vbGVhbl90CitiZmFfaW50eChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwl1MzIgICAgICAgIGludHIsIHFpbnRyOworCWludCAgICAgICAgICAgICBxdWV1ZTsKKworCWludHIgPSBiZmFfcmVnX3JlYWQoYmZhLT5pb2NmYy5iZmFfcmVncy5pbnRyX3N0YXR1cyk7CisJaWYgKCFpbnRyKQorCQlyZXR1cm4gQkZBX0ZBTFNFOworCisJLyoqCisJICogUk1FIGNvbXBsZXRpb24gcXVldWUgaW50ZXJydXB0CisJICovCisJcWludHIgPSBpbnRyICYgX19IRk5fSU5UX1JNRV9NQVNLOworCWJmYV9yZWdfd3JpdGUoYmZhLT5pb2NmYy5iZmFfcmVncy5pbnRyX3N0YXR1cywgcWludHIpOworCisJZm9yIChxdWV1ZSA9IDA7IHF1ZXVlIDwgQkZJX0lPQ19NQVhfQ1FTX0FTSUM7IHF1ZXVlICsrKSB7CisJCWlmIChpbnRyICYgKF9fSEZOX0lOVF9STUVfUTAgPDwgcXVldWUpKQorCQkJYmZhX21zaXhfcnNwcShiZmEsIHF1ZXVlICYgKEJGSV9JT0NfTUFYX0NRUyAtIDEpKTsKKwl9CisJaW50ciAmPSB+cWludHI7CisJaWYgKCFpbnRyKQorCQlyZXR1cm4gQkZBX1RSVUU7CisKKwkvKioKKwkgKiBDUEUgY29tcGxldGlvbiBxdWV1ZSBpbnRlcnJ1cHQKKwkgKi8KKwlxaW50ciA9IGludHIgJiBfX0hGTl9JTlRfQ1BFX01BU0s7CisJYmZhX3JlZ193cml0ZShiZmEtPmlvY2ZjLmJmYV9yZWdzLmludHJfc3RhdHVzLCBxaW50cik7CisKKwlmb3IgKHF1ZXVlID0gMDsgcXVldWUgPCBCRklfSU9DX01BWF9DUVNfQVNJQzsgcXVldWUrKykgeworCQlpZiAoaW50ciAmIChfX0hGTl9JTlRfQ1BFX1EwIDw8IHF1ZXVlKSkKKwkJCWJmYV9tc2l4X3JlcXEoYmZhLCBxdWV1ZSAmIChCRklfSU9DX01BWF9DUVMgLSAxKSk7CisJfQorCWludHIgJj0gfnFpbnRyOworCWlmICghaW50cikKKwkJcmV0dXJuIEJGQV9UUlVFOworCisJYmZhX21zaXhfbHB1X2VycihiZmEsIGludHIpOworCisJcmV0dXJuIEJGQV9UUlVFOworfQorCit2b2lkCitiZmFfaXNyX2VuYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwl1MzIgICAgICAgIGludHJfdW5tYXNrOworCWludCAgICAgICAgICAgICBwY2lfZnVuYyA9IGJmYV9pb2NfcGNpZm4oJmJmYS0+aW9jKTsKKworCWJmYV90cmMoYmZhLCBwY2lfZnVuYyk7CisKKwliZmFfbXNpeF9pbnN0YWxsKGJmYSk7CisJaW50cl91bm1hc2sgPSAoX19IRk5fSU5UX0VSUl9FTUMgfCBfX0hGTl9JTlRfRVJSX0xQVTAgfAorCQkgICAgICAgX19IRk5fSU5UX0VSUl9MUFUxIHwgX19IRk5fSU5UX0VSUl9QU1MpOworCisJaWYgKHBjaV9mdW5jID09IDApCisJCWludHJfdW5tYXNrIHw9IChfX0hGTl9JTlRfQ1BFX1EwIHwgX19IRk5fSU5UX0NQRV9RMSB8CisJCQkJX19IRk5fSU5UX0NQRV9RMiB8IF9fSEZOX0lOVF9DUEVfUTMgfAorCQkJCV9fSEZOX0lOVF9STUVfUTAgfCBfX0hGTl9JTlRfUk1FX1ExIHwKKwkJCQlfX0hGTl9JTlRfUk1FX1EyIHwgX19IRk5fSU5UX1JNRV9RMyB8CisJCQkJX19IRk5fSU5UX01CT1hfTFBVMCk7CisJZWxzZQorCQlpbnRyX3VubWFzayB8PSAoX19IRk5fSU5UX0NQRV9RNCB8IF9fSEZOX0lOVF9DUEVfUTUgfAorCQkJCV9fSEZOX0lOVF9DUEVfUTYgfCBfX0hGTl9JTlRfQ1BFX1E3IHwKKwkJCQlfX0hGTl9JTlRfUk1FX1E0IHwgX19IRk5fSU5UX1JNRV9RNSB8CisJCQkJX19IRk5fSU5UX1JNRV9RNiB8IF9fSEZOX0lOVF9STUVfUTcgfAorCQkJCV9fSEZOX0lOVF9NQk9YX0xQVTEpOworCisJYmZhX3JlZ193cml0ZShiZmEtPmlvY2ZjLmJmYV9yZWdzLmludHJfc3RhdHVzLCBpbnRyX3VubWFzayk7CisJYmZhX3JlZ193cml0ZShiZmEtPmlvY2ZjLmJmYV9yZWdzLmludHJfbWFzaywgfmludHJfdW5tYXNrKTsKKwliZmFfaXNyX21vZGVfc2V0KGJmYSwgYmZhLT5tc2l4Lm52ZWNzICE9IDApOworfQorCit2b2lkCitiZmFfaXNyX2Rpc2FibGUoc3RydWN0IGJmYV9zICpiZmEpCit7CisJYmZhX2lzcl9tb2RlX3NldChiZmEsIEJGQV9GQUxTRSk7CisJYmZhX3JlZ193cml0ZShiZmEtPmlvY2ZjLmJmYV9yZWdzLmludHJfbWFzaywgLTFMKTsKKwliZmFfbXNpeF91bmluc3RhbGwoYmZhKTsKK30KKwordm9pZAorYmZhX21zaXhfcmVxcShzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IHFpZCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkIAkJKndhaXRxLCAqcWUsICpxZW47CisJc3RydWN0IGJmYV9yZXFxX3dhaXRfcwkqd3FlOworCisJcWlkICY9IChCRklfSU9DX01BWF9DUVMgLSAxKTsKKworCXdhaXRxID0gYmZhX3JlcXEoYmZhLCBxaWQpOworCWxpc3RfZm9yX2VhY2hfc2FmZShxZSwgcWVuLCB3YWl0cSkgeworCQkvKioKKwkJICogQ2FsbGJhY2sgb25seSBhcyBsb25nIGFzIHRoZXJlIGlzIHJvb20gaW4gcmVxdWVzdCBxdWV1ZQorCQkgKi8KKwkJaWYgKGJmYV9yZXFxX2Z1bGwoYmZhLCBxaWQpKQorCQkJYnJlYWs7CisKKwkJbGlzdF9kZWwocWUpOworCQl3cWUgPSAoc3RydWN0IGJmYV9yZXFxX3dhaXRfcyAqKSBxZTsKKwkJd3FlLT5xcmVzdW1lKHdxZS0+Y2JhcmcpOworCX0KK30KKwordm9pZAorYmZhX2lzcl91bmhhbmRsZWQoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm0pCit7CisJYmZhX3RyYyhiZmEsIG0tPm1oZHIubXNnX2NsYXNzKTsKKwliZmFfdHJjKGJmYSwgbS0+bWhkci5tc2dfaWQpOworCWJmYV90cmMoYmZhLCBtLT5taGRyLm10YWcuaTJodG9rKTsKKwliZmFfYXNzZXJ0KDApOworCWJmYV90cmNfc3RvcChiZmEtPnRyY21vZCk7Cit9CisKK3ZvaWQKK2JmYV9tc2l4X3JzcHEoc3RydWN0IGJmYV9zICpiZmEsIGludCByc3BfcWlkKQoreworCXN0cnVjdCBiZmlfbXNnX3MgICAgICAqbTsKKwl1MzIgICAgICAgIHBpLCBjaTsKKworCWJmYV90cmNfZnAoYmZhLCByc3BfcWlkKTsKKworCXJzcF9xaWQgJj0gKEJGSV9JT0NfTUFYX0NRUyAtIDEpOworCisJYmZhLT5pb2NmYy5od2lmLmh3X3JzcHFfYWNrKGJmYSwgcnNwX3FpZCk7CisKKwljaSA9IGJmYV9yc3BxX2NpKGJmYSwgcnNwX3FpZCk7CisJcGkgPSBiZmFfcnNwcV9waShiZmEsIHJzcF9xaWQpOworCisJYmZhX3RyY19mcChiZmEsIGNpKTsKKwliZmFfdHJjX2ZwKGJmYSwgcGkpOworCisJaWYgKGJmYS0+cm1lX3Byb2Nlc3MpIHsKKwkJd2hpbGUgKGNpICE9IHBpKSB7CisJCQltID0gYmZhX3JzcHFfZWxlbShiZmEsIHJzcF9xaWQsIGNpKTsKKwkJCWJmYV9hc3NlcnRfZnAobS0+bWhkci5tc2dfY2xhc3MgPCBCRklfTUNfTUFYKTsKKworCQkJYmZhX2lzcnNbbS0+bWhkci5tc2dfY2xhc3NdIChiZmEsIG0pOworCisJCQlDUV9JTkNSKGNpLCBiZmEtPmlvY2ZjLmNmZy5kcnZjZmcubnVtX3JzcHFfZWxlbXMpOworCQl9CisJfQorCisJLyoqCisJICogdXBkYXRlIENJCisJICovCisJYmZhX3JzcHFfY2koYmZhLCByc3BfcWlkKSA9IHBpOworCWJmYV9yZWdfd3JpdGUoYmZhLT5pb2NmYy5iZmFfcmVncy5ybWVfcV9jaVtyc3BfcWlkXSwgcGkpOworCWJmYV9vc19tbWlvd2IoKTsKK30KKwordm9pZAorYmZhX21zaXhfbHB1X2VycihzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IHZlYykKK3sKKwl1MzIgaW50cjsKKworCWludHIgPSBiZmFfcmVnX3JlYWQoYmZhLT5pb2NmYy5iZmFfcmVncy5pbnRyX3N0YXR1cyk7CisKKwlpZiAoaW50ciAmIChfX0hGTl9JTlRfTUJPWF9MUFUwIHwgX19IRk5fSU5UX01CT1hfTFBVMSkpCisJCWJmYV9tc2l4X2xwdShiZmEpOworCisJaWYgKGludHIgJiAoX19IRk5fSU5UX0VSUl9FTUMgfAorCQkgICAgX19IRk5fSU5UX0VSUl9MUFUwIHwgX19IRk5fSU5UX0VSUl9MUFUxIHwKKwkJICAgIF9fSEZOX0lOVF9FUlJfUFNTKSkKKwkJYmZhX21zaXhfZXJyaW50KGJmYSwgaW50cik7Cit9CisKK3ZvaWQKK2JmYV9pc3JfYmluZChlbnVtIGJmaV9tY2xhc3MgbWMsIGJmYV9pc3JfZnVuY190IGlzcl9mdW5jKQoreworCWJmYV9pc3JzW21jXSA9IGlzcl9mdW5jOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ludHJfcHJpdi5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW50cl9wcml2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGNlNmU2YgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2ludHJfcHJpdi5oCkBAIC0wLDAgKzEsMTE1IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfSU5UUl9QUklWX0hfXworI2RlZmluZSBfX0JGQV9JTlRSX1BSSVZfSF9fCisKKy8qKgorICogTWVzc2FnZSBoYW5kbGVyCisgKi8KK3R5cGVkZWYgdm9pZCAoKmJmYV9pc3JfZnVuY190KSAoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm0pOwordm9pZCBiZmFfaXNyX3VuaGFuZGxlZChzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmaV9tc2dfcyAqbSk7Cit2b2lkIGJmYV9pc3JfYmluZChlbnVtIGJmaV9tY2xhc3MgbWMsIGJmYV9pc3JfZnVuY190IGlzcl9mdW5jKTsKKworCisjZGVmaW5lIGJmYV9yZXFxX3BpKF9fYmZhLCBfX3JlcXEpCShfX2JmYSktPmlvY2ZjLnJlcV9jcV9waVtfX3JlcXFdCisjZGVmaW5lIGJmYV9yZXFxX2NpKF9fYmZhLCBfX3JlcXEpCQkJCQlcCisJKih1MzIgKikoKF9fYmZhKS0+aW9jZmMucmVxX2NxX3NoYWRvd19jaVtfX3JlcXFdLmt2YSkKKworI2RlZmluZSBiZmFfcmVxcV9mdWxsKF9fYmZhLCBfX3JlcXEpCQkJCVwKKwkoKChiZmFfcmVxcV9waShfX2JmYSwgX19yZXFxKSArIDEpICYJCQlcCisJICAoKF9fYmZhKS0+aW9jZmMuY2ZnLmRydmNmZy5udW1fcmVxcV9lbGVtcyAtIDEpKSA9PQlcCisJIGJmYV9yZXFxX2NpKF9fYmZhLCBfX3JlcXEpKQorCisjZGVmaW5lIGJmYV9yZXFxX25leHQoX19iZmEsIF9fcmVxcSkJCQkJXAorCShiZmFfcmVxcV9mdWxsKF9fYmZhLCBfX3JlcXEpID8gTlVMTCA6CQkJXAorCSAoKHZvaWQgKikoKHN0cnVjdCBiZmlfbXNnX3MgKikoKF9fYmZhKS0+aW9jZmMucmVxX2NxX2JhW19fcmVxcV0ua3ZhKSBcCisJCQkgICsgYmZhX3JlcXFfcGkoKF9fYmZhKSwgKF9fcmVxcSkpKSkpCisKKyNkZWZpbmUgYmZhX3JlcXFfcHJvZHVjZShfX2JmYSwgX19yZXFxKQlkbyB7CQkJCVwKKwkoX19iZmEpLT5pb2NmYy5yZXFfY3FfcGlbX19yZXFxXSsrOwkJCQlcCisJKF9fYmZhKS0+aW9jZmMucmVxX2NxX3BpW19fcmVxcV0gJj0JCQkJXAorCQkoKF9fYmZhKS0+aW9jZmMuY2ZnLmRydmNmZy5udW1fcmVxcV9lbGVtcyAtIDEpOyAgICAgIFwKKwliZmFfcmVnX3dyaXRlKChfX2JmYSktPmlvY2ZjLmJmYV9yZWdzLmNwZV9xX3BpW19fcmVxcV0sCQlcCisJCQkJKF9fYmZhKS0+aW9jZmMucmVxX2NxX3BpW19fcmVxcV0pOyAgICAgIFwKKwliZmFfb3NfbW1pb3diKCk7ICAgICAgXAorfSB3aGlsZSAoMCkKKworI2RlZmluZSBiZmFfcnNwcV9waShfX2JmYSwgX19yc3BxKQkJCQkJXAorCSoodTMyICopKChfX2JmYSktPmlvY2ZjLnJzcF9jcV9zaGFkb3dfcGlbX19yc3BxXS5rdmEpCisKKyNkZWZpbmUgYmZhX3JzcHFfY2koX19iZmEsIF9fcnNwcSkJKF9fYmZhKS0+aW9jZmMucnNwX2NxX2NpW19fcnNwcV0KKyNkZWZpbmUgYmZhX3JzcHFfZWxlbShfX2JmYSwgX19yc3BxLCBfX2NpKQkJCQlcCisJJigoc3RydWN0IGJmaV9tc2dfcyAqKSgoX19iZmEpLT5pb2NmYy5yc3BfY3FfYmFbX19yc3BxXS5rdmEpKVtfX2NpXQorCisjZGVmaW5lIENRX0lOQ1IoX19pbmRleCwgX19zaXplKQkJCQkJXAorCQkJKF9faW5kZXgpKys7IChfX2luZGV4KSAmPSAoKF9fc2l6ZSkgLSAxKQorCisvKioKKyAqIFF1ZXVlIGVsZW1lbnQgdG8gd2FpdCBmb3Igcm9vbSBpbiByZXF1ZXN0IHF1ZXVlLiBGSUZPIG9yZGVyIGlzCisgKiBtYWludGFpbmVkIHdoZW4gZnVsbGZpbGxpbmcgcmVxdWVzdHMuCisgKi8KK3N0cnVjdCBiZmFfcmVxcV93YWl0X3MgeworCXN0cnVjdCBsaXN0X2hlYWQgCXFlOworCXZvaWQJCSgqcXJlc3VtZSkgKHZvaWQgKmNiYXJnKTsKKwl2b2lkCQkqY2Jhcmc7Cit9OworCisvKioKKyAqIENpcmN1bGFyIHF1ZXVlIHVzYWdlIGFzc2lnbm1lbnRzCisgKi8KK2VudW0geworCUJGQV9SRVFRX0lPQwk9IDAsCS8qICBhbGwgbG93LXByaW9yaXR5IElPQyBtc2dzCSovCisJQkZBX1JFUVFfRkNYUAk9IDAsCS8qICBhbGwgRkNYUCBtZXNzYWdlcwkJKi8KKwlCRkFfUkVRUV9MUFMJPSAwLAkvKiAgYWxsIGxwb3J0IHNlcnZpY2UgbXNncwkqLworCUJGQV9SRVFRX1BPUlQJPSAwLAkvKiAgYWxsIHBvcnQgbWVzc2FnZXMJCSovCisJQkZBX1JFUVFfRkxBU0gJPSAwLAkvKiAgZm9yIGZsYXNoIG1vZHVsZQkJKi8KKwlCRkFfUkVRUV9ESUFHCT0gMCwJLyogIGZvciBkaWFnIG1vZHVsZQkJKi8KKwlCRkFfUkVRUV9SUE9SVAk9IDAsCS8qICBhbGwgcG9ydCBtZXNzYWdlcwkJKi8KKwlCRkFfUkVRUV9TQk9PVAk9IDAsCS8qICBhbGwgc2FuIGJvb3QgbWVzc2FnZXMJKi8KKwlCRkFfUkVRUV9RT1NfTE8JPSAxLAkvKiAgYWxsIGxvdyBwcmlvcml0eSBJTwkqLworCUJGQV9SRVFRX1FPU19NRAk9IDIsCS8qICBhbGwgbWVkaXVtIHByaW9yaXR5IElPCSovCisJQkZBX1JFUVFfUU9TX0hJCT0gMywJLyogIGFsbCBoaWdoIHByaW9yaXR5IElPCSovCit9OworCitzdGF0aWMgaW5saW5lIHZvaWQKK2JmYV9yZXFxX3dpbml0KHN0cnVjdCBiZmFfcmVxcV93YWl0X3MgKndxZSwgdm9pZCAoKnFyZXN1bWUpICh2b2lkICpjYmFyZyksCisJCQl2b2lkICpjYmFyZykKK3sKKwl3cWUtPnFyZXN1bWUgPSBxcmVzdW1lOworCXdxZS0+Y2JhcmcgPSBjYmFyZzsKK30KKworI2RlZmluZSBiZmFfcmVxcShfX2JmYSwgX19yZXFxKQkmKF9fYmZhKS0+cmVxcV93YWl0cVtfX3JlcXFdCisKKy8qKgorICogc3RhdGljIGlubGluZSB2b2lkCisgKiBiZmFfcmVxcV93YWl0KHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgcmVxcSwgc3RydWN0IGJmYV9yZXFxX3dhaXRfcyAqd3FlKQorICovCisjZGVmaW5lIGJmYV9yZXFxX3dhaXQoX19iZmEsIF9fcmVxcSwgX193cWUpIGRvIHsJCQlcCisJCQkJCQkJCQlcCisJCXN0cnVjdCBsaXN0X2hlYWQgKndhaXRxID0gYmZhX3JlcXEoX19iZmEsIF9fcmVxcSk7ICAgICAgXAorCQkJCQkJCQkJXAorCQliZmFfYXNzZXJ0KCgoX19yZXFxKSA8IEJGSV9JT0NfTUFYX0NRUykpOyAgICAgIFwKKwkJYmZhX2Fzc2VydCgoX193cWUpLT5xcmVzdW1lICYmIChfX3dxZSktPmNiYXJnKTsgICAgICBcCisJCQkJCQkJCQlcCisJCWxpc3RfYWRkX3RhaWwoJihfX3dxZSktPnFlLCB3YWl0cSk7ICAgICAgXAorfSB3aGlsZSAoMCkKKworI2RlZmluZSBiZmFfcmVxcV93Y2FuY2VsKF9fd3FlKQlsaXN0X2RlbCgmKF9fd3FlKS0+cWUpCisKKyNlbmRpZiAvKiBfX0JGQV9JTlRSX1BSSVZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9pb2MuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvYy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE0OTM0ODkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9pb2MuYwpAQCAtMCwwICsxLDIzODIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9pb2MuaD4KKyNpbmNsdWRlIDxiZmFfZndpbWdfcHJpdi5oPgorI2luY2x1ZGUgPGJmYV90cmNtb2RfcHJpdi5oPgorI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorI2luY2x1ZGUgPGJmaS9iZmlfaW9jLmg+CisjaW5jbHVkZSA8YmZpL2JmaV9jdHJlZy5oPgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuX2lvYy5oPgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuLmg+CisjaW5jbHVkZSA8bG9nL2JmYV9sb2dfaGFsLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wY2kuaD4KKworQkZBX1RSQ19GSUxFKEhBTCwgSU9DKTsKKworLyoqCisgKiBJT0MgbG9jYWwgZGVmaW5pdGlvbnMKKyAqLworI2RlZmluZSBCRkFfSU9DX1RPVgkJMjAwMAkvKiBtc2VjcyAqLworI2RlZmluZSBCRkFfSU9DX0hCX1RPVgkJMTAwMAkvKiBtc2VjcyAqLworI2RlZmluZSBCRkFfSU9DX0hCX0ZBSUxfTUFYCTQKKyNkZWZpbmUgQkZBX0lPQ19IV0lOSVRfTUFYCTIKKyNkZWZpbmUgQkZBX0lPQ19GV0lNR19NSU5TWiAgICAgKDE2ICogMTAyNCkKKyNkZWZpbmUgQkZBX0lPQ19UT1ZfUkVDT1ZFUgkoQkZBX0lPQ19IQl9GQUlMX01BWCAqIEJGQV9JT0NfSEJfVE9WIFwKKwkJCQkrIEJGQV9JT0NfVE9WKQorCisjZGVmaW5lIGJmYV9pb2NfdGltZXJfc3RhcnQoX19pb2MpCQkJCQlcCisJYmZhX3RpbWVyX2JlZ2luKChfX2lvYyktPnRpbWVyX21vZCwgJihfX2lvYyktPmlvY190aW1lciwJXAorCQkJYmZhX2lvY190aW1lb3V0LCAoX19pb2MpLCBCRkFfSU9DX1RPVikKKyNkZWZpbmUgYmZhX2lvY190aW1lcl9zdG9wKF9faW9jKSAgIGJmYV90aW1lcl9zdG9wKCYoX19pb2MpLT5pb2NfdGltZXIpCisKKyNkZWZpbmUgQkZBX0RCR19GV1RSQ19FTlRTCShCRklfSU9DX1RSQ19FTlRTKQorI2RlZmluZSBCRkFfREJHX0ZXVFJDX0xFTgkJCQkJXAorCShCRkFfREJHX0ZXVFJDX0VOVFMgKiBzaXplb2Yoc3RydWN0IGJmYV90cmNfcykgKwlcCisJIChzaXplb2Yoc3RydWN0IGJmYV90cmNfbW9kX3MpIC0JCQlcCisJICBCRkFfVFJDX01BWCAqIHNpemVvZihzdHJ1Y3QgYmZhX3RyY19zKSkpCisjZGVmaW5lIEJGQV9EQkdfRldUUkNfT0ZGKF9mbikJKEJGSV9JT0NfVFJDX09GRiArIEJGQV9EQkdfRldUUkNfTEVOICogKF9mbikpCisjZGVmaW5lIGJmYV9pb2Nfc3RhdHMoX2lvYywgX3N0YXRzKQkoX2lvYyktPnN0YXRzLl9zdGF0cyArKworCisjZGVmaW5lIEJGQV9GTEFTSF9DSFVOS19OTyhvZmYpICAgICAgICAgKG9mZiAvIEJGSV9GTEFTSF9DSFVOS19TWl9XT1JEUykKKyNkZWZpbmUgQkZBX0ZMQVNIX09GRlNFVF9JTl9DSFVOSyhvZmYpICAob2ZmICUgQkZJX0ZMQVNIX0NIVU5LX1NaX1dPUkRTKQorI2RlZmluZSBCRkFfRkxBU0hfQ0hVTktfQUREUihjaHVua25vKSAgIChjaHVua25vICogQkZJX0ZMQVNIX0NIVU5LX1NaX1dPUkRTKQorYmZhX2Jvb2xlYW5fdCAgIGJmYV9hdXRvX3JlY292ZXIgPSBCRkFfRkFMU0U7CisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgdm9pZCAgICAgYmZhX2lvY19hZW5fcG9zdChzdHJ1Y3QgYmZhX2lvY19zICpiZmEsCisJCQkJIGVudW0gYmZhX2lvY19hZW5fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2NfaHdfc2VtX2dldChzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2NfaHdfc2VtX3JlbGVhc2Uoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9jX2h3X3NlbV9nZXRfY2FuY2VsKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2lvY19od2luaXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBiZmFfYm9vbGVhbl90IGZvcmNlKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9jX3RpbWVvdXQodm9pZCAqaW9jKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9jX3NlbmRfZW5hYmxlKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2lvY19zZW5kX2Rpc2FibGUoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9jX3NlbmRfZ2V0YXR0cihzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2NfaGJfbW9uaXRvcihzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2NfaGJfc3RvcChzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2NfcmVzZXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBiZmFfYm9vbGVhbl90IGZvcmNlKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9jX21ib3hfcG9sbChzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2NfbWJveF9oYmZhaWwoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9jX3JlY292ZXIoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK3N0YXRpYyBiZmFfYm9vbGVhbl90IGJmYV9pb2NfZmlybXdhcmVfbG9jayhzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2NfZmlybXdhcmVfdW5sb2NrKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2lvY19kaXNhYmxlX2NvbXAoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9jX2xwdV9zdG9wKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CisKKy8qKgorICogIGJmYV9pb2Nfc20KKyAqLworCisvKioKKyAqIElPQyBzdGF0ZSBtYWNoaW5lIGV2ZW50cworICovCitlbnVtIGlvY19ldmVudCB7CisJSU9DX0VfRU5BQkxFID0gMSwJLyogIElPQyBlbmFibGUgcmVxdWVzdCAqLworCUlPQ19FX0RJU0FCTEUgPSAyLAkvKiAgSU9DIGRpc2FibGUgcmVxdWVzdCAqLworCUlPQ19FX1RJTUVPVVQgPSAzLAkvKiAgZi93IHJlc3BvbnNlIHRpbWVvdXQgKi8KKwlJT0NfRV9GV1JFQURZID0gNCwJLyogIGYvdyBpbml0aWFsaXphdGlvbiBkb25lICovCisJSU9DX0VfRldSU1BfR0VUQVRUUiA9IDUsCS8qICBJT0MgZ2V0IGF0dHJpYnV0ZSByZXNwb25zZSAqLworCUlPQ19FX0ZXUlNQX0VOQUJMRSA9IDYsCS8qICBlbmFibGUgZi93IHJlc3BvbnNlICovCisJSU9DX0VfRldSU1BfRElTQUJMRSA9IDcsCS8qICBkaXNhYmxlIGYvdyByZXNwb25zZSAqLworCUlPQ19FX0hCRkFJTCA9IDgsCS8qICBoZWFydGJlYXQgZmFpbHVyZSAqLworCUlPQ19FX0hXRVJST1IgPSA5LAkvKiAgaGFyZHdhcmUgZXJyb3IgaW50ZXJydXB0ICovCisJSU9DX0VfU0VNTE9DS0VEID0gMTAsCS8qICBoL3cgc2VtYXBob3JlIGlzIGxvY2tlZCAqLworCUlPQ19FX0RFVEFDSCA9IDExLAkvKiAgZHJpdmVyIGRldGFjaCBjbGVhbnVwICovCit9OworCitiZmFfZnNtX3N0YXRlX2RlY2woYmZhX2lvYywgcmVzZXQsIHN0cnVjdCBiZmFfaW9jX3MsIGVudW0gaW9jX2V2ZW50KTsKK2JmYV9mc21fc3RhdGVfZGVjbChiZmFfaW9jLCBmd2NoZWNrLCBzdHJ1Y3QgYmZhX2lvY19zLCBlbnVtIGlvY19ldmVudCk7CitiZmFfZnNtX3N0YXRlX2RlY2woYmZhX2lvYywgbWlzbWF0Y2gsIHN0cnVjdCBiZmFfaW9jX3MsIGVudW0gaW9jX2V2ZW50KTsKK2JmYV9mc21fc3RhdGVfZGVjbChiZmFfaW9jLCBzZW13YWl0LCBzdHJ1Y3QgYmZhX2lvY19zLCBlbnVtIGlvY19ldmVudCk7CitiZmFfZnNtX3N0YXRlX2RlY2woYmZhX2lvYywgaHdpbml0LCBzdHJ1Y3QgYmZhX2lvY19zLCBlbnVtIGlvY19ldmVudCk7CitiZmFfZnNtX3N0YXRlX2RlY2woYmZhX2lvYywgZW5hYmxpbmcsIHN0cnVjdCBiZmFfaW9jX3MsIGVudW0gaW9jX2V2ZW50KTsKK2JmYV9mc21fc3RhdGVfZGVjbChiZmFfaW9jLCBnZXRhdHRyLCBzdHJ1Y3QgYmZhX2lvY19zLCBlbnVtIGlvY19ldmVudCk7CitiZmFfZnNtX3N0YXRlX2RlY2woYmZhX2lvYywgb3AsIHN0cnVjdCBiZmFfaW9jX3MsIGVudW0gaW9jX2V2ZW50KTsKK2JmYV9mc21fc3RhdGVfZGVjbChiZmFfaW9jLCBpbml0ZmFpbCwgc3RydWN0IGJmYV9pb2NfcywgZW51bSBpb2NfZXZlbnQpOworYmZhX2ZzbV9zdGF0ZV9kZWNsKGJmYV9pb2MsIGhiZmFpbCwgc3RydWN0IGJmYV9pb2NfcywgZW51bSBpb2NfZXZlbnQpOworYmZhX2ZzbV9zdGF0ZV9kZWNsKGJmYV9pb2MsIGRpc2FibGluZywgc3RydWN0IGJmYV9pb2NfcywgZW51bSBpb2NfZXZlbnQpOworYmZhX2ZzbV9zdGF0ZV9kZWNsKGJmYV9pb2MsIGRpc2FibGVkLCBzdHJ1Y3QgYmZhX2lvY19zLCBlbnVtIGlvY19ldmVudCk7CisKK3N0YXRpYyBzdHJ1Y3QgYmZhX3NtX3RhYmxlX3MgaW9jX3NtX3RhYmxlW10gPSB7CisJe0JGQV9TTShiZmFfaW9jX3NtX3Jlc2V0KSwgQkZBX0lPQ19SRVNFVH0sCisJe0JGQV9TTShiZmFfaW9jX3NtX2Z3Y2hlY2spLCBCRkFfSU9DX0ZXTUlTTUFUQ0h9LAorCXtCRkFfU00oYmZhX2lvY19zbV9taXNtYXRjaCksIEJGQV9JT0NfRldNSVNNQVRDSH0sCisJe0JGQV9TTShiZmFfaW9jX3NtX3NlbXdhaXQpLCBCRkFfSU9DX1NFTVdBSVR9LAorCXtCRkFfU00oYmZhX2lvY19zbV9od2luaXQpLCBCRkFfSU9DX0hXSU5JVH0sCisJe0JGQV9TTShiZmFfaW9jX3NtX2VuYWJsaW5nKSwgQkZBX0lPQ19IV0lOSVR9LAorCXtCRkFfU00oYmZhX2lvY19zbV9nZXRhdHRyKSwgQkZBX0lPQ19HRVRBVFRSfSwKKwl7QkZBX1NNKGJmYV9pb2Nfc21fb3ApLCBCRkFfSU9DX09QRVJBVElPTkFMfSwKKwl7QkZBX1NNKGJmYV9pb2Nfc21faW5pdGZhaWwpLCBCRkFfSU9DX0lOSVRGQUlMfSwKKwl7QkZBX1NNKGJmYV9pb2Nfc21faGJmYWlsKSwgQkZBX0lPQ19IQkZBSUx9LAorCXtCRkFfU00oYmZhX2lvY19zbV9kaXNhYmxpbmcpLCBCRkFfSU9DX0RJU0FCTElOR30sCisJe0JGQV9TTShiZmFfaW9jX3NtX2Rpc2FibGVkKSwgQkZBX0lPQ19ESVNBQkxFRH0sCit9OworCisvKioKKyAqIFJlc2V0IGVudHJ5IGFjdGlvbnMgLS0gaW5pdGlhbGl6ZSBzdGF0ZSBtYWNoaW5lCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX3NtX3Jlc2V0X2VudHJ5KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlpb2MtPnJldHJ5X2NvdW50ID0gMDsKKwlpb2MtPmF1dG9fcmVjb3ZlciA9IGJmYV9hdXRvX3JlY292ZXI7Cit9CisKKy8qKgorICogQmVnaW5uaW5nIHN0YXRlLiBJT0MgaXMgaW4gcmVzZXQgc3RhdGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX3NtX3Jlc2V0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgZW51bSBpb2NfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIElPQ19FX0VOQUJMRToKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX2Z3Y2hlY2spOworCQlicmVhazsKKworCWNhc2UgSU9DX0VfRElTQUJMRToKKwkJYmZhX2lvY19kaXNhYmxlX2NvbXAoaW9jKTsKKwkJYnJlYWs7CisKKwljYXNlIElPQ19FX0RFVEFDSDoKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQoaW9jLCBldmVudCk7CisJfQorfQorCisvKioKKyAqIFNlbWFwaG9yZSBzaG91bGQgYmUgYWNxdWlyZWQgZm9yIHZlcnNpb24gY2hlY2suCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX3NtX2Z3Y2hlY2tfZW50cnkoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV9pb2NfaHdfc2VtX2dldChpb2MpOworfQorCisvKioKKyAqIEF3YWl0aW5nIGgvdyBzZW1hcGhvcmUgdG8gY29udGludWUgd2l0aCB2ZXJzaW9uIGNoZWNrLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9md2NoZWNrKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgZW51bSBpb2NfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIElPQ19FX1NFTUxPQ0tFRDoKKwkJaWYgKGJmYV9pb2NfZmlybXdhcmVfbG9jayhpb2MpKSB7CisJCQlpb2MtPnJldHJ5X2NvdW50ID0gMDsKKwkJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9od2luaXQpOworCQl9IGVsc2UgeworCQkJYmZhX2lvY19od19zZW1fcmVsZWFzZShpb2MpOworCQkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX21pc21hdGNoKTsKKwkJfQorCQlicmVhazsKKworCWNhc2UgSU9DX0VfRElTQUJMRToKKwkJYmZhX2lvY19kaXNhYmxlX2NvbXAoaW9jKTsKKwkJLyoKKwkJICogZmFsbCB0aHJvdWdoCisJCSAqLworCisJY2FzZSBJT0NfRV9ERVRBQ0g6CisJCWJmYV9pb2NfaHdfc2VtX2dldF9jYW5jZWwoaW9jKTsKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX3Jlc2V0KTsKKwkJYnJlYWs7CisKKwljYXNlIElPQ19FX0ZXUkVBRFk6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGlvYywgZXZlbnQpOworCX0KK30KKworLyoqCisgKiBOb3RpZnkgZW5hYmxlIGNvbXBsZXRpb24gY2FsbGJhY2sgYW5kIGdlbmVyYXRlIG1pc21hdGNoIEFFTi4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21fbWlzbWF0Y2hfZW50cnkoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCS8qKgorCSAqIFByb3ZpZGUgZW5hYmxlIGNvbXBsZXRpb24gY2FsbGJhY2sgYW5kIEFFTiBub3RpZmljYXRpb24gb25seSBvbmNlLgorCSAqLworCWlmIChpb2MtPnJldHJ5X2NvdW50ID09IDApIHsKKwkJaW9jLT5jYmZuLT5lbmFibGVfY2Jmbihpb2MtPmJmYSwgQkZBX1NUQVRVU19JT0NfRkFJTFVSRSk7CisJCWJmYV9pb2NfYWVuX3Bvc3QoaW9jLCBCRkFfSU9DX0FFTl9GV01JU01BVENIKTsKKwl9CisJaW9jLT5yZXRyeV9jb3VudCsrOworCWJmYV9pb2NfdGltZXJfc3RhcnQoaW9jKTsKK30KKworLyoqCisgKiBBd2FpdGluZyBmaXJtd2FyZSB2ZXJzaW9uIG1hdGNoLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9taXNtYXRjaChzdHJ1Y3QgYmZhX2lvY19zICppb2MsIGVudW0gaW9jX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaW9jLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBJT0NfRV9USU1FT1VUOgorCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZndjaGVjayk7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9ESVNBQkxFOgorCQliZmFfaW9jX2Rpc2FibGVfY29tcChpb2MpOworCQkvKgorCQkgKiBmYWxsIHRocm91Z2gKKwkJICovCisKKwljYXNlIElPQ19FX0RFVEFDSDoKKwkJYmZhX2lvY190aW1lcl9zdG9wKGlvYyk7CisJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9yZXNldCk7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9GV1JFQURZOgorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChpb2MsIGV2ZW50KTsKKwl9Cit9CisKKy8qKgorICogUmVxdWVzdCBmb3Igc2VtYXBob3JlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9zZW13YWl0X2VudHJ5KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwliZmFfaW9jX2h3X3NlbV9nZXQoaW9jKTsKK30KKworLyoqCisgKiBBd2FpdGluZyBzZW1hcGhvcmUgZm9yIGgvdyBpbml0aWFsemF0aW9uLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9zZW13YWl0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgZW51bSBpb2NfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIElPQ19FX1NFTUxPQ0tFRDoKKwkJaW9jLT5yZXRyeV9jb3VudCA9IDA7CisJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9od2luaXQpOworCQlicmVhazsKKworCWNhc2UgSU9DX0VfRElTQUJMRToKKwkJYmZhX2lvY19od19zZW1fZ2V0X2NhbmNlbChpb2MpOworCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZGlzYWJsZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChpb2MsIGV2ZW50KTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21faHdpbml0X2VudHJ5KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwliZmFfaW9jX3RpbWVyX3N0YXJ0KGlvYyk7CisJYmZhX2lvY19yZXNldChpb2MsIEJGQV9GQUxTRSk7Cit9CisKKy8qKgorICogSGFyZHdhcmUgaXMgYmVpbmcgaW5pdGlhbGl6ZWQuIEludGVycnVwdHMgYXJlIGVuYWJsZWQuCisgKiBIb2xkaW5nIGhhcmR3YXJlIHNlbWFwaG9yZSBsb2NrLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9od2luaXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBlbnVtIGlvY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGlvYywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgSU9DX0VfRldSRUFEWToKKwkJYmZhX2lvY190aW1lcl9zdG9wKGlvYyk7CisJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9lbmFibGluZyk7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9IV0VSUk9SOgorCQliZmFfaW9jX3RpbWVyX3N0b3AoaW9jKTsKKwkJLyoKKwkJICogZmFsbCB0aHJvdWdoCisJCSAqLworCisJY2FzZSBJT0NfRV9USU1FT1VUOgorCQlpb2MtPnJldHJ5X2NvdW50Kys7CisJCWlmIChpb2MtPnJldHJ5X2NvdW50IDwgQkZBX0lPQ19IV0lOSVRfTUFYKSB7CisJCQliZmFfaW9jX3RpbWVyX3N0YXJ0KGlvYyk7CisJCQliZmFfaW9jX3Jlc2V0KGlvYywgQkZBX1RSVUUpOworCQkJYnJlYWs7CisJCX0KKworCQliZmFfaW9jX2h3X3NlbV9yZWxlYXNlKGlvYyk7CisJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9pbml0ZmFpbCk7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9ESVNBQkxFOgorCQliZmFfaW9jX2h3X3NlbV9yZWxlYXNlKGlvYyk7CisJCWJmYV9pb2NfdGltZXJfc3RvcChpb2MpOworCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZGlzYWJsZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChpb2MsIGV2ZW50KTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21fZW5hYmxpbmdfZW50cnkoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV9pb2NfdGltZXJfc3RhcnQoaW9jKTsKKwliZmFfaW9jX3NlbmRfZW5hYmxlKGlvYyk7Cit9CisKKy8qKgorICogSG9zdCBJT0MgZnVuY3Rpb24gaXMgYmVpbmcgZW5hYmxlZCwgYXdhaXRpbmcgcmVzcG9uc2UgZnJvbSBmaXJtd2FyZS4KKyAqIFNlbWFwaG9yZSBpcyBhY3F1aXJlZC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21fZW5hYmxpbmcoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBlbnVtIGlvY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGlvYywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgSU9DX0VfRldSU1BfRU5BQkxFOgorCQliZmFfaW9jX3RpbWVyX3N0b3AoaW9jKTsKKwkJYmZhX2lvY19od19zZW1fcmVsZWFzZShpb2MpOworCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZ2V0YXR0cik7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9IV0VSUk9SOgorCQliZmFfaW9jX3RpbWVyX3N0b3AoaW9jKTsKKwkJLyoKKwkJICogZmFsbCB0aHJvdWdoCisJCSAqLworCisJY2FzZSBJT0NfRV9USU1FT1VUOgorCQlpb2MtPnJldHJ5X2NvdW50Kys7CisJCWlmIChpb2MtPnJldHJ5X2NvdW50IDwgQkZBX0lPQ19IV0lOSVRfTUFYKSB7CisJCQliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaW9jX2Z3c3RhdGUsCisJCQkJICAgICAgQkZJX0lPQ19VTklOSVQpOworCQkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX2h3aW5pdCk7CisJCQlicmVhazsKKwkJfQorCisJCWJmYV9pb2NfaHdfc2VtX3JlbGVhc2UoaW9jKTsKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX2luaXRmYWlsKTsKKwkJYnJlYWs7CisKKwljYXNlIElPQ19FX0RJU0FCTEU6CisJCWJmYV9pb2NfdGltZXJfc3RvcChpb2MpOworCQliZmFfaW9jX2h3X3NlbV9yZWxlYXNlKGlvYyk7CisJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9kaXNhYmxlZCk7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9GV1JFQURZOgorCQliZmFfaW9jX3NlbmRfZW5hYmxlKGlvYyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGlvYywgZXZlbnQpOworCX0KK30KKworCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9nZXRhdHRyX2VudHJ5KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwliZmFfaW9jX3RpbWVyX3N0YXJ0KGlvYyk7CisJYmZhX2lvY19zZW5kX2dldGF0dHIoaW9jKTsKK30KKworLyoqCisgKiBJT0MgY29uZmlndXJhdGlvbiBpbiBwcm9ncmVzcy4gVGltZXIgaXMgYWN0aXZlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9nZXRhdHRyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgZW51bSBpb2NfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIElPQ19FX0ZXUlNQX0dFVEFUVFI6CisJCWJmYV9pb2NfdGltZXJfc3RvcChpb2MpOworCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fb3ApOworCQlicmVhazsKKworCWNhc2UgSU9DX0VfSFdFUlJPUjoKKwkJYmZhX2lvY190aW1lcl9zdG9wKGlvYyk7CisJCS8qCisJCSAqIGZhbGwgdGhyb3VnaAorCQkgKi8KKworCWNhc2UgSU9DX0VfVElNRU9VVDoKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX2luaXRmYWlsKTsKKwkJYnJlYWs7CisKKwljYXNlIElPQ19FX0RJU0FCTEU6CisJCWJmYV9pb2NfdGltZXJfc3RvcChpb2MpOworCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZGlzYWJsZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChpb2MsIGV2ZW50KTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21fb3BfZW50cnkoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWlvYy0+Y2Jmbi0+ZW5hYmxlX2NiZm4oaW9jLT5iZmEsIEJGQV9TVEFUVVNfT0spOworCWJmYV9pb2NfaGJfbW9uaXRvcihpb2MpOworCWJmYV9pb2NfYWVuX3Bvc3QoaW9jLCBCRkFfSU9DX0FFTl9FTkFCTEUpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9vcChzdHJ1Y3QgYmZhX2lvY19zICppb2MsIGVudW0gaW9jX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaW9jLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBJT0NfRV9FTkFCTEU6CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9ESVNBQkxFOgorCQliZmFfaW9jX2hiX3N0b3AoaW9jKTsKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX2Rpc2FibGluZyk7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9IV0VSUk9SOgorCWNhc2UgSU9DX0VfRldSRUFEWToKKwkJLyoqCisJCSAqIEhhcmQgZXJyb3Igb3IgSU9DIHJlY292ZXJ5IGJ5IG90aGVyIGZ1bmN0aW9uLgorCQkgKiBUcmVhdCBpdCBzYW1lIGFzIGhlYXJ0YmVhdCBmYWlsdXJlLgorCQkgKi8KKwkJYmZhX2lvY19oYl9zdG9wKGlvYyk7CisJCS8qCisJCSAqICEhISBmYWxsIHRocm91Z2ggISEhCisJCSAqLworCisJY2FzZSBJT0NfRV9IQkZBSUw6CisJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9oYmZhaWwpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChpb2MsIGV2ZW50KTsKKwl9Cit9CisKKworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21fZGlzYWJsaW5nX2VudHJ5KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwliZmFfaW9jX2Flbl9wb3N0KGlvYywgQkZBX0lPQ19BRU5fRElTQUJMRSk7CisJYmZhX2lvY190aW1lcl9zdGFydChpb2MpOworCWJmYV9pb2Nfc2VuZF9kaXNhYmxlKGlvYyk7Cit9CisKKy8qKgorICogSU9DIGlzIGJlaW5nIGRpc2FibGVkCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX3NtX2Rpc2FibGluZyhzdHJ1Y3QgYmZhX2lvY19zICppb2MsIGVudW0gaW9jX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaW9jLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBJT0NfRV9IV0VSUk9SOgorCWNhc2UgSU9DX0VfRldSU1BfRElTQUJMRToKKwkJYmZhX2lvY190aW1lcl9zdG9wKGlvYyk7CisJCS8qCisJCSAqICEhISBmYWxsIHRocm91Z2ggISEhCisJCSAqLworCisJY2FzZSBJT0NfRV9USU1FT1VUOgorCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZGlzYWJsZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChpb2MsIGV2ZW50KTsKKwl9Cit9CisKKy8qKgorICogSU9DIGRpc2FibGUgY29tcGxldGlvbiBlbnRyeS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21fZGlzYWJsZWRfZW50cnkoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV9pb2NfZGlzYWJsZV9jb21wKGlvYyk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX3NtX2Rpc2FibGVkKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgZW51bSBpb2NfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIElPQ19FX0VOQUJMRToKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX3NlbXdhaXQpOworCQlicmVhazsKKworCWNhc2UgSU9DX0VfRElTQUJMRToKKwkJaW9jLT5jYmZuLT5kaXNhYmxlX2NiZm4oaW9jLT5iZmEpOworCQlicmVhazsKKworCWNhc2UgSU9DX0VfRldSRUFEWToKKwkJYnJlYWs7CisKKwljYXNlIElPQ19FX0RFVEFDSDoKKwkJYmZhX2lvY19maXJtd2FyZV91bmxvY2soaW9jKTsKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX3Jlc2V0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQoaW9jLCBldmVudCk7CisJfQorfQorCisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX3NtX2luaXRmYWlsX2VudHJ5KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlpb2MtPmNiZm4tPmVuYWJsZV9jYmZuKGlvYy0+YmZhLCBCRkFfU1RBVFVTX0lPQ19GQUlMVVJFKTsKKwliZmFfaW9jX3RpbWVyX3N0YXJ0KGlvYyk7Cit9CisKKy8qKgorICogSGFyZHdhcmUgaW5pdGlhbGl6YXRpb24gZmFpbGVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9pbml0ZmFpbChzdHJ1Y3QgYmZhX2lvY19zICppb2MsIGVudW0gaW9jX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaW9jLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBJT0NfRV9ESVNBQkxFOgorCQliZmFfaW9jX3RpbWVyX3N0b3AoaW9jKTsKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX2Rpc2FibGVkKTsKKwkJYnJlYWs7CisKKwljYXNlIElPQ19FX0RFVEFDSDoKKwkJYmZhX2lvY190aW1lcl9zdG9wKGlvYyk7CisJCWJmYV9pb2NfZmlybXdhcmVfdW5sb2NrKGlvYyk7CisJCWJmYV9mc21fc2V0X3N0YXRlKGlvYywgYmZhX2lvY19zbV9yZXNldCk7CisJCWJyZWFrOworCisJY2FzZSBJT0NfRV9USU1FT1VUOgorCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fc2Vtd2FpdCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGlvYywgZXZlbnQpOworCX0KK30KKworCitzdGF0aWMgdm9pZAorYmZhX2lvY19zbV9oYmZhaWxfZW50cnkoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXN0cnVjdCBsaXN0X2hlYWQgKnFlOworCXN0cnVjdCBiZmFfaW9jX2hiZmFpbF9ub3RpZnlfcyAqbm90aWZ5OworCisJLyoqCisJICogTWFyayBJT0MgYXMgZmFpbGVkIGluIGhhcmR3YXJlIGFuZCBzdG9wIGZpcm13YXJlLgorCSAqLworCWJmYV9pb2NfbHB1X3N0b3AoaW9jKTsKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaW9jX2Z3c3RhdGUsIEJGSV9JT0NfSEJGQUlMKTsKKworCWlmIChpb2MtPnBjaWRldi5kZXZpY2VfaWQgPT0gQkZBX1BDSV9ERVZJQ0VfSURfQ1QpIHsKKwkJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmxsX2hhbHQsIF9fRldfSU5JVF9IQUxUX1ApOworCQkvKgorCQkgKiBXYWl0IGZvciBoYWx0IHRvIHRha2UgZWZmZWN0CisJCSAqLworCQliZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5sbF9oYWx0KTsKKwl9CisKKwkvKioKKwkgKiBOb3RpZnkgZHJpdmVyIGFuZCBjb21tb24gbW9kdWxlcyByZWdpc3RlcmVkIGZvciBub3RpZmljYXRpb24uCisJICovCisJaW9jLT5jYmZuLT5oYmZhaWxfY2Jmbihpb2MtPmJmYSk7CisJbGlzdF9mb3JfZWFjaChxZSwgJmlvYy0+aGJfbm90aWZ5X3EpIHsKKwkJbm90aWZ5ID0gKHN0cnVjdCBiZmFfaW9jX2hiZmFpbF9ub3RpZnlfcyAqKXFlOworCQlub3RpZnktPmNiZm4obm90aWZ5LT5jYmFyZyk7CisJfQorCisJLyoqCisJICogRmx1c2ggYW55IHF1ZXVlZCB1cCBtYWlsYm94IHJlcXVlc3RzLgorCSAqLworCWJmYV9pb2NfbWJveF9oYmZhaWwoaW9jKTsKKwliZmFfaW9jX2Flbl9wb3N0KGlvYywgQkZBX0lPQ19BRU5fSEJGQUlMKTsKKworCS8qKgorCSAqIFRyaWdnZXIgYXV0by1yZWNvdmVyeSBhZnRlciBhIGRlbGF5LgorCSAqLworCWlmIChpb2MtPmF1dG9fcmVjb3ZlcikgeworCQliZmFfdGltZXJfYmVnaW4oaW9jLT50aW1lcl9tb2QsICZpb2MtPmlvY190aW1lciwKKwkJCQliZmFfaW9jX3RpbWVvdXQsIGlvYywgQkZBX0lPQ19UT1ZfUkVDT1ZFUik7CisJfQorfQorCisvKioKKyAqIElPQyBoZWFydGJlYXQgZmFpbHVyZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc21faGJmYWlsKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgZW51bSBpb2NfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKworCWNhc2UgSU9DX0VfRU5BQkxFOgorCQlpb2MtPmNiZm4tPmVuYWJsZV9jYmZuKGlvYy0+YmZhLCBCRkFfU1RBVFVTX0lPQ19GQUlMVVJFKTsKKwkJYnJlYWs7CisKKwljYXNlIElPQ19FX0RJU0FCTEU6CisJCWlmIChpb2MtPmF1dG9fcmVjb3ZlcikKKwkJCWJmYV9pb2NfdGltZXJfc3RvcChpb2MpOworCQliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZGlzYWJsZWQpOworCQlicmVhazsKKworCWNhc2UgSU9DX0VfVElNRU9VVDoKKwkJYmZhX2ZzbV9zZXRfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX3NlbXdhaXQpOworCQlicmVhazsKKworCWNhc2UgSU9DX0VfRldSRUFEWToKKwkJLyoqCisJCSAqIFJlY292ZXJ5IGlzIGFscmVhZHkgaW5pdGlhdGVkIGJ5IG90aGVyIGZ1bmN0aW9uLgorCQkgKi8KKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQoaW9jLCBldmVudCk7CisJfQorfQorCisKKworLyoqCisgKiAgYmZhX2lvY19wdnQgQkZBIElPQyBwcml2YXRlIGZ1bmN0aW9ucworICovCisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX2Rpc2FibGVfY29tcChzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJc3RydWN0IGxpc3RfaGVhZCAqcWU7CisJc3RydWN0IGJmYV9pb2NfaGJmYWlsX25vdGlmeV9zICpub3RpZnk7CisKKwlpb2MtPmNiZm4tPmRpc2FibGVfY2Jmbihpb2MtPmJmYSk7CisKKwkvKioKKwkgKiBOb3RpZnkgY29tbW9uIG1vZHVsZXMgcmVnaXN0ZXJlZCBmb3Igbm90aWZpY2F0aW9uLgorCSAqLworCWxpc3RfZm9yX2VhY2gocWUsICZpb2MtPmhiX25vdGlmeV9xKSB7CisJCW5vdGlmeSA9IChzdHJ1Y3QgYmZhX2lvY19oYmZhaWxfbm90aWZ5X3MgKilxZTsKKwkJbm90aWZ5LT5jYmZuKG5vdGlmeS0+Y2JhcmcpOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc2VtX3RpbWVvdXQodm9pZCAqaW9jX2FyZykKK3sKKwlzdHJ1Y3QgYmZhX2lvY19zICppb2MgPSAoc3RydWN0IGJmYV9pb2NfcyAqKWlvY19hcmc7CisKKwliZmFfaW9jX2h3X3NlbV9nZXQoaW9jKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NfdXNhZ2Vfc2VtX2dldChzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJdTMyICAgICAgICByMzI7CisJaW50ICAgICAgICAgICAgIGNudCA9IDA7CisjZGVmaW5lIEJGQV9TRU1fU1BJTkNOVAkxMDAwCisKKwlkbyB7CisJCXIzMiA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLmlvY191c2FnZV9zZW1fcmVnKTsKKwkJY250Kys7CisJCWlmIChjbnQgPiBCRkFfU0VNX1NQSU5DTlQpCisJCQlicmVhazsKKwl9IHdoaWxlIChyMzIgIT0gMCk7CisJYmZhX2Fzc2VydChjbnQgPCBCRkFfU0VNX1NQSU5DTlQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY191c2FnZV9zZW1fcmVsZWFzZShzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmlvY191c2FnZV9zZW1fcmVnLCAxKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NfaHdfc2VtX2dldChzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJdTMyICAgICAgICByMzI7CisKKwkvKioKKwkgKiBGaXJzdCByZWFkIHRvIHRoZSBzZW1hcGhvcmUgcmVnaXN0ZXIgd2lsbCByZXR1cm4gMCwgc3Vic2VxdWVudCByZWFkcworCSAqIHdpbGwgcmV0dXJuIDEuIFNlbWFwaG9yZSBpcyByZWxlYXNlZCBieSB3cml0aW5nIDAgdG8gdGhlIHJlZ2lzdGVyCisJICovCisJcjMyID0gYmZhX3JlZ19yZWFkKGlvYy0+aW9jX3JlZ3MuaW9jX3NlbV9yZWcpOworCWlmIChyMzIgPT0gMCkgeworCQliZmFfZnNtX3NlbmRfZXZlbnQoaW9jLCBJT0NfRV9TRU1MT0NLRUQpOworCQlyZXR1cm47CisJfQorCisJYmZhX3RpbWVyX2JlZ2luKGlvYy0+dGltZXJfbW9kLCAmaW9jLT5zZW1fdGltZXIsIGJmYV9pb2Nfc2VtX3RpbWVvdXQsCisJCQlpb2MsIEJGQV9JT0NfVE9WKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NfaHdfc2VtX3JlbGVhc2Uoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV9yZWdfd3JpdGUoaW9jLT5pb2NfcmVncy5pb2Nfc2VtX3JlZywgMSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX2h3X3NlbV9nZXRfY2FuY2VsKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwliZmFfdGltZXJfc3RvcCgmaW9jLT5zZW1fdGltZXIpOworfQorCisvKioKKyAqIEluaXRpYWxpemUgTFBVIGxvY2FsIG1lbW9yeSAoYWthIHNlY29uZGFyeSBtZW1vcnkgLyBTUkFNKQorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19sbWVtX2luaXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXUzMiAgICAgICAgcHNzX2N0bDsKKwlpbnQgICAgICAgICAgICAgaTsKKyNkZWZpbmUgUFNTX0xNRU1fSU5JVF9USU1FICAxMDAwMAorCisJcHNzX2N0bCA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLnBzc19jdGxfcmVnKTsKKwlwc3NfY3RsICY9IH5fX1BTU19MTUVNX1JFU0VUOworCXBzc19jdGwgfD0gX19QU1NfTE1FTV9JTklUX0VOOworCXBzc19jdGwgfD0gX19QU1NfSTJDX0NMS19ESVYoM1VMKTsgLyogaTJjIHdvcmthcm91bmQgMTIuNWtoeiBjbG9jayAqLworCWJmYV9yZWdfd3JpdGUoaW9jLT5pb2NfcmVncy5wc3NfY3RsX3JlZywgcHNzX2N0bCk7CisKKwkvKioKKwkgKiB3YWl0IGZvciBtZW1vcnkgaW5pdGlhbGl6YXRpb24gdG8gYmUgY29tcGxldGUKKwkgKi8KKwlpID0gMDsKKwlkbyB7CisJCXBzc19jdGwgPSBiZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5wc3NfY3RsX3JlZyk7CisJCWkrKzsKKwl9IHdoaWxlICghKHBzc19jdGwgJiBfX1BTU19MTUVNX0lOSVRfRE9ORSkgJiYgKGkgPCBQU1NfTE1FTV9JTklUX1RJTUUpKTsKKworCS8qKgorCSAqIElmIG1lbW9yeSBpbml0aWFsaXphdGlvbiBpcyBub3Qgc3VjY2Vzc2Z1bCwgSU9DIHRpbWVvdXQgd2lsbCBjYXRjaAorCSAqIHN1Y2ggZmFpbHVyZXMuCisJICovCisJYmZhX2Fzc2VydChwc3NfY3RsICYgX19QU1NfTE1FTV9JTklUX0RPTkUpOworCWJmYV90cmMoaW9jLCBwc3NfY3RsKTsKKworCXBzc19jdGwgJj0gfihfX1BTU19MTUVNX0lOSVRfRE9ORSB8IF9fUFNTX0xNRU1fSU5JVF9FTik7CisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLnBzc19jdGxfcmVnLCBwc3NfY3RsKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NfbHB1X3N0YXJ0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwl1MzIgICAgICAgIHBzc19jdGw7CisKKwkvKioKKwkgKiBUYWtlIHByb2Nlc3NvciBvdXQgb2YgcmVzZXQuCisJICovCisJcHNzX2N0bCA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLnBzc19jdGxfcmVnKTsKKwlwc3NfY3RsICY9IH5fX1BTU19MUFUwX1JFU0VUOworCisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLnBzc19jdGxfcmVnLCBwc3NfY3RsKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NfbHB1X3N0b3Aoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXUzMiAgICAgICAgcHNzX2N0bDsKKworCS8qKgorCSAqIFB1dCBwcm9jZXNzb3JzIGluIHJlc2V0LgorCSAqLworCXBzc19jdGwgPSBiZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5wc3NfY3RsX3JlZyk7CisJcHNzX2N0bCB8PSAoX19QU1NfTFBVMF9SRVNFVCB8IF9fUFNTX0xQVTFfUkVTRVQpOworCisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLnBzc19jdGxfcmVnLCBwc3NfY3RsKTsKK30KKworLyoqCisgKiBHZXQgZHJpdmVyIGFuZCBmaXJtd2FyZSB2ZXJzaW9ucy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2NfZnd2ZXJfZ2V0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgc3RydWN0IGJmaV9pb2NfaW1hZ2VfaGRyX3MgKmZ3aGRyKQoreworCXUzMiAgICAgICAgcGdudW0sIHBnb2ZmOworCXUzMiAgICAgICAgbG9mZiA9IDA7CisJaW50ICAgICAgICAgICAgIGk7CisJdTMyICAgICAgICpmd3NpZyA9ICh1MzIgKikgZndoZHI7CisKKwlwZ251bSA9IGJmYV9pb2Nfc21lbV9wZ251bShpb2MsIGxvZmYpOworCXBnb2ZmID0gYmZhX2lvY19zbWVtX3Bnb2ZmKGlvYywgbG9mZik7CisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmhvc3RfcGFnZV9udW1fZm4sIHBnbnVtKTsKKworCWZvciAoaSA9IDA7IGkgPCAoc2l6ZW9mKHN0cnVjdCBiZmlfaW9jX2ltYWdlX2hkcl9zKSAvIHNpemVvZih1MzIpKTsKKwkgICAgIGkrKykgeworCQlmd3NpZ1tpXSA9IGJmYV9tZW1fcmVhZChpb2MtPmlvY19yZWdzLnNtZW1fcGFnZV9zdGFydCwgbG9mZik7CisJCWxvZmYgKz0gc2l6ZW9mKHUzMik7CisJfQorfQorCitzdGF0aWMgdTMyICoKK2JmYV9pb2NfZndpbWdfZ2V0X2NodW5rKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgdTMyIG9mZikKK3sKKwlpZiAoaW9jLT5jdGRldikKKwkJcmV0dXJuIGJmaV9pbWFnZV9jdF9nZXRfY2h1bmsob2ZmKTsKKwlyZXR1cm4gYmZpX2ltYWdlX2NiX2dldF9jaHVuayhvZmYpOworfQorCitzdGF0aWMgICAgICAgICAgdTMyCitiZmFfaW9jX2Z3aW1nX2dldF9zaXplKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKK3JldHVybiAoaW9jLT5jdGRldikgPyBiZmlfaW1hZ2VfY3Rfc2l6ZSA6IGJmaV9pbWFnZV9jYl9zaXplOworfQorCisvKioKKyAqIFJldHVybnMgVFJVRSBpZiBzYW1lLgorICovCitzdGF0aWMgICAgICAgICAgYmZhX2Jvb2xlYW5fdAorYmZhX2lvY19md3Zlcl9jbXAoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBzdHJ1Y3QgYmZpX2lvY19pbWFnZV9oZHJfcyAqZndoZHIpCit7CisJc3RydWN0IGJmaV9pb2NfaW1hZ2VfaGRyX3MgKmRydl9md2hkcjsKKwlpbnQgICAgICAgICAgICAgaTsKKworCWRydl9md2hkciA9CisJCShzdHJ1Y3QgYmZpX2lvY19pbWFnZV9oZHJfcyAqKWJmYV9pb2NfZndpbWdfZ2V0X2NodW5rKGlvYywgMCk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQkZJX0lPQ19NRDVTVU1fU1o7IGkrKykgeworCQlpZiAoZndoZHItPm1kNXN1bVtpXSAhPSBkcnZfZndoZHItPm1kNXN1bVtpXSkgeworCQkJYmZhX3RyYyhpb2MsIGkpOworCQkJYmZhX3RyYyhpb2MsIGZ3aGRyLT5tZDVzdW1baV0pOworCQkJYmZhX3RyYyhpb2MsIGRydl9md2hkci0+bWQ1c3VtW2ldKTsKKwkJCXJldHVybiBCRkFfRkFMU0U7CisJCX0KKwl9CisKKwliZmFfdHJjKGlvYywgZndoZHItPm1kNXN1bVswXSk7CisJcmV0dXJuIEJGQV9UUlVFOworfQorCisvKioKKyAqIFJldHVybiB0cnVlIGlmIGN1cnJlbnQgcnVubmluZyB2ZXJzaW9uIGlzIHZhbGlkLiBGaXJtd2FyZSBzaWduYXR1cmUgYW5kCisgKiBleGVjdXRpb24gY29udGV4dCAoZHJpdmVyL2Jpb3MpIG11c3QgbWF0Y2guCisgKi8KK3N0YXRpYyAgICAgICAgICBiZmFfYm9vbGVhbl90CitiZmFfaW9jX2Z3dmVyX3ZhbGlkKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlzdHJ1Y3QgYmZpX2lvY19pbWFnZV9oZHJfcyBmd2hkciwgKmRydl9md2hkcjsKKworCS8qKgorCSAqIElmIGJpb3MvZWZpIGJvb3QgKGZsYXNoIGJhc2VkKSAtLSByZXR1cm4gdHJ1ZQorCSAqLworCWlmIChiZmFfaW9jX2Z3aW1nX2dldF9zaXplKGlvYykgPCBCRkFfSU9DX0ZXSU1HX01JTlNaKQorCQlyZXR1cm4gQkZBX1RSVUU7CisKKwliZmFfaW9jX2Z3dmVyX2dldChpb2MsICZmd2hkcik7CisJZHJ2X2Z3aGRyID0KKwkJKHN0cnVjdCBiZmlfaW9jX2ltYWdlX2hkcl9zICopYmZhX2lvY19md2ltZ19nZXRfY2h1bmsoaW9jLCAwKTsKKworCWlmIChmd2hkci5zaWduYXR1cmUgIT0gZHJ2X2Z3aGRyLT5zaWduYXR1cmUpIHsKKwkJYmZhX3RyYyhpb2MsIGZ3aGRyLnNpZ25hdHVyZSk7CisJCWJmYV90cmMoaW9jLCBkcnZfZndoZHItPnNpZ25hdHVyZSk7CisJCXJldHVybiBCRkFfRkFMU0U7CisJfQorCisJaWYgKGZ3aGRyLmV4ZWMgIT0gZHJ2X2Z3aGRyLT5leGVjKSB7CisJCWJmYV90cmMoaW9jLCBmd2hkci5leGVjKTsKKwkJYmZhX3RyYyhpb2MsIGRydl9md2hkci0+ZXhlYyk7CisJCXJldHVybiBCRkFfRkFMU0U7CisJfQorCisJcmV0dXJuIGJmYV9pb2NfZnd2ZXJfY21wKGlvYywgJmZ3aGRyKTsKK30KKworLyoqCisgKiBSZXR1cm4gdHJ1ZSBpZiBmaXJtd2FyZSBvZiBjdXJyZW50IGRyaXZlciBtYXRjaGVzIHRoZSBydW5uaW5nIGZpcm13YXJlLgorICovCitzdGF0aWMgICAgICAgICAgYmZhX2Jvb2xlYW5fdAorYmZhX2lvY19maXJtd2FyZV9sb2NrKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwllbnVtIGJmaV9pb2Nfc3RhdGUgaW9jX2Z3c3RhdGU7CisJdTMyICAgICAgICB1c2VjbnQ7CisJc3RydWN0IGJmaV9pb2NfaW1hZ2VfaGRyX3MgZndoZHI7CisKKwkvKioKKwkgKiBGaXJtd2FyZSBtYXRjaCBjaGVjayBpcyByZWxldmFudCBvbmx5IGZvciBDTkEuCisJICovCisJaWYgKCFpb2MtPmNuYSkKKwkJcmV0dXJuIEJGQV9UUlVFOworCisJLyoqCisJICogSWYgYmlvcyBib290IChmbGFzaCBiYXNlZCkgLS0gZG8gbm90IGluY3JlbWVudCB1c2FnZSBjb3VudAorCSAqLworCWlmIChiZmFfaW9jX2Z3aW1nX2dldF9zaXplKGlvYykgPCBCRkFfSU9DX0ZXSU1HX01JTlNaKQorCQlyZXR1cm4gQkZBX1RSVUU7CisKKwliZmFfaW9jX3VzYWdlX3NlbV9nZXQoaW9jKTsKKwl1c2VjbnQgPSBiZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5pb2NfdXNhZ2VfcmVnKTsKKworCS8qKgorCSAqIElmIHVzYWdlIGNvdW50IGlzIDAsIGFsd2F5cyByZXR1cm4gVFJVRS4KKwkgKi8KKwlpZiAodXNlY250ID09IDApIHsKKwkJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmlvY191c2FnZV9yZWcsIDEpOworCQliZmFfaW9jX3VzYWdlX3NlbV9yZWxlYXNlKGlvYyk7CisJCWJmYV90cmMoaW9jLCB1c2VjbnQpOworCQlyZXR1cm4gQkZBX1RSVUU7CisJfQorCisJaW9jX2Z3c3RhdGUgPSBiZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5pb2NfZndzdGF0ZSk7CisJYmZhX3RyYyhpb2MsIGlvY19md3N0YXRlKTsKKworCS8qKgorCSAqIFVzZSBjb3VudCBjYW5ub3QgYmUgbm9uLXplcm8gYW5kIGNoaXAgaW4gdW5pbml0aWFsaXplZCBzdGF0ZS4KKwkgKi8KKwliZmFfYXNzZXJ0KGlvY19md3N0YXRlICE9IEJGSV9JT0NfVU5JTklUKTsKKworCS8qKgorCSAqIENoZWNrIGlmIGFub3RoZXIgZHJpdmVyIHdpdGggYSBkaWZmZXJlbnQgZmlybXdhcmUgaXMgYWN0aXZlCisJICovCisJYmZhX2lvY19md3Zlcl9nZXQoaW9jLCAmZndoZHIpOworCWlmICghYmZhX2lvY19md3Zlcl9jbXAoaW9jLCAmZndoZHIpKSB7CisJCWJmYV9pb2NfdXNhZ2Vfc2VtX3JlbGVhc2UoaW9jKTsKKwkJYmZhX3RyYyhpb2MsIHVzZWNudCk7CisJCXJldHVybiBCRkFfRkFMU0U7CisJfQorCisJLyoqCisJICogU2FtZSBmaXJtd2FyZSB2ZXJzaW9uLiBJbmNyZW1lbnQgdGhlIHJlZmVyZW5jZSBjb3VudC4KKwkgKi8KKwl1c2VjbnQrKzsKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaW9jX3VzYWdlX3JlZywgdXNlY250KTsKKwliZmFfaW9jX3VzYWdlX3NlbV9yZWxlYXNlKGlvYyk7CisJYmZhX3RyYyhpb2MsIHVzZWNudCk7CisJcmV0dXJuIEJGQV9UUlVFOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY19maXJtd2FyZV91bmxvY2soc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXUzMiAgICAgICAgdXNlY250OworCisJLyoqCisJICogRmlybXdhcmUgbG9jayBpcyByZWxldmFudCBvbmx5IGZvciBDTkEuCisJICogSWYgYmlvcyBib290IChmbGFzaCBiYXNlZCkgLS0gZG8gbm90IGRlY3JlbWVudCB1c2FnZSBjb3VudAorCSAqLworCWlmICghaW9jLT5jbmEgfHwgKGJmYV9pb2NfZndpbWdfZ2V0X3NpemUoaW9jKSA8IEJGQV9JT0NfRldJTUdfTUlOU1opKQorCQlyZXR1cm47CisKKwkvKioKKwkgKiBkZWNyZW1lbnQgdXNhZ2UgY291bnQKKwkgKi8KKwliZmFfaW9jX3VzYWdlX3NlbV9nZXQoaW9jKTsKKwl1c2VjbnQgPSBiZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5pb2NfdXNhZ2VfcmVnKTsKKwliZmFfYXNzZXJ0KHVzZWNudCA+IDApOworCisJdXNlY250LS07CisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmlvY191c2FnZV9yZWcsIHVzZWNudCk7CisJYmZhX3RyYyhpb2MsIHVzZWNudCk7CisKKwliZmFfaW9jX3VzYWdlX3NlbV9yZWxlYXNlKGlvYyk7Cit9CisKKy8qKgorICogQ29uZGl0aW9uYWxseSBmbHVzaCBhbnkgcGVuZGluZyBtZXNzYWdlIGZyb20gZmlybXdhcmUgYXQgc3RhcnQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX21zZ2ZsdXNoKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwl1MzIgICAgICAgIHIzMjsKKworCXIzMiA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLmxwdV9tYm94X2NtZCk7CisJaWYgKHIzMikKKwkJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmxwdV9tYm94X2NtZCwgMSk7Cit9CisKKworc3RhdGljIHZvaWQKK2JmYV9pb2NfaHdpbml0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgYmZhX2Jvb2xlYW5fdCBmb3JjZSkKK3sKKwllbnVtIGJmaV9pb2Nfc3RhdGUgaW9jX2Z3c3RhdGU7CisJYmZhX2Jvb2xlYW5fdCAgIGZ3dmFsaWQ7CisKKwlpb2NfZndzdGF0ZSA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLmlvY19md3N0YXRlKTsKKworCWlmIChmb3JjZSkKKwkJaW9jX2Z3c3RhdGUgPSBCRklfSU9DX1VOSU5JVDsKKworCWJmYV90cmMoaW9jLCBpb2NfZndzdGF0ZSk7CisKKwkvKioKKwkgKiBjaGVjayBpZiBmaXJtd2FyZSBpcyB2YWxpZAorCSAqLworCWZ3dmFsaWQgPSAoaW9jX2Z3c3RhdGUgPT0gQkZJX0lPQ19VTklOSVQpID8KKwkJCUJGQV9GQUxTRSA6IGJmYV9pb2NfZnd2ZXJfdmFsaWQoaW9jKTsKKworCWlmICghZnd2YWxpZCkgeworCQliZmFfaW9jX2Jvb3QoaW9jLCBCRklfQk9PVF9UWVBFX05PUk1BTCwgaW9jLT5wY2lkZXYuZGV2aWNlX2lkKTsKKwkJcmV0dXJuOworCX0KKworCS8qKgorCSAqIElmIGhhcmR3YXJlIGluaXRpYWxpemF0aW9uIGlzIGluIHByb2dyZXNzIChpbml0aWFsaXplZCBieSBvdGhlciBJT0MpLAorCSAqIGp1c3Qgd2FpdCBmb3IgYW4gaW5pdGlhbGl6YXRpb24gY29tcGxldGlvbiBpbnRlcnJ1cHQuCisJICovCisJaWYgKGlvY19md3N0YXRlID09IEJGSV9JT0NfSU5JVElORykgeworCQliZmFfdHJjKGlvYywgaW9jX2Z3c3RhdGUpOworCQlpb2MtPmNiZm4tPnJlc2V0X2NiZm4oaW9jLT5iZmEpOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogSWYgSU9DIGZ1bmN0aW9uIGlzIGRpc2FibGVkIGFuZCBmaXJtd2FyZSB2ZXJzaW9uIGlzIHNhbWUsCisJICoganVzdCByZS1lbmFibGUgSU9DLgorCSAqLworCWlmIChpb2NfZndzdGF0ZSA9PSBCRklfSU9DX0RJU0FCTEVEIHx8IGlvY19md3N0YXRlID09IEJGSV9JT0NfT1ApIHsKKwkJYmZhX3RyYyhpb2MsIGlvY19md3N0YXRlKTsKKworCQkvKioKKwkJICogV2hlbiB1c2luZyBNU0ktWCBhbnkgcGVuZGluZyBmaXJtd2FyZSByZWFkeSBldmVudCBzaG91bGQKKwkJICogYmUgZmx1c2hlZC4gT3RoZXJ3aXNlIE1TSS1YIGludGVycnVwdHMgYXJlIG5vdCBkZWxpdmVyZWQuCisJCSAqLworCQliZmFfaW9jX21zZ2ZsdXNoKGlvYyk7CisJCWlvYy0+Y2Jmbi0+cmVzZXRfY2Jmbihpb2MtPmJmYSk7CisJCWJmYV9mc21fc2VuZF9ldmVudChpb2MsIElPQ19FX0ZXUkVBRFkpOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogSW5pdGlhbGl6ZSB0aGUgaC93IGZvciBhbnkgb3RoZXIgc3RhdGVzLgorCSAqLworCWJmYV9pb2NfYm9vdChpb2MsIEJGSV9CT09UX1RZUEVfTk9STUFMLCBpb2MtPnBjaWRldi5kZXZpY2VfaWQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY190aW1lb3V0KHZvaWQgKmlvY19hcmcpCit7CisJc3RydWN0IGJmYV9pb2NfcyAqaW9jID0gKHN0cnVjdCBiZmFfaW9jX3MgKilpb2NfYXJnOworCisJYmZhX3RyYyhpb2MsIDApOworCWJmYV9mc21fc2VuZF9ldmVudChpb2MsIElPQ19FX1RJTUVPVVQpOworfQorCit2b2lkCitiZmFfaW9jX21ib3hfc2VuZChzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHZvaWQgKmlvY19tc2csIGludCBsZW4pCit7CisJdTMyICAgICAgICptc2dwID0gKHUzMiAqKSBpb2NfbXNnOworCXUzMiAgICAgICAgaTsKKworCWJmYV90cmMoaW9jLCBtc2dwWzBdKTsKKwliZmFfdHJjKGlvYywgbGVuKTsKKworCWJmYV9hc3NlcnQobGVuIDw9IEJGSV9JT0NfTVNHTEVOX01BWCk7CisKKwkvKgorCSAqIGZpcnN0IHdyaXRlIG1zZyB0byBtYWlsYm94IHJlZ2lzdGVycworCSAqLworCWZvciAoaSA9IDA7IGkgPCBsZW4gLyBzaXplb2YodTMyKTsgaSsrKQorCQliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaGZuX21ib3ggKyBpICogc2l6ZW9mKHUzMiksCisJCQkgICAgICBiZmFfb3Nfd3RvbGUobXNncFtpXSkpOworCisJZm9yICg7IGkgPCBCRklfSU9DX01TR0xFTl9NQVggLyBzaXplb2YodTMyKTsgaSsrKQorCQliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaGZuX21ib3ggKyBpICogc2l6ZW9mKHUzMiksIDApOworCisJLyoKKwkgKiB3cml0ZSAxIHRvIG1haWxib3ggQ01EIHRvIHRyaWdnZXIgTFBVIGV2ZW50CisJICovCisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmhmbl9tYm94X2NtZCwgMSk7CisJKHZvaWQpYmZhX3JlZ19yZWFkKGlvYy0+aW9jX3JlZ3MuaGZuX21ib3hfY21kKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2Nfc2VuZF9lbmFibGUoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXN0cnVjdCBiZmlfaW9jX2N0cmxfcmVxX3MgZW5hYmxlX3JlcTsKKworCWJmaV9oMmlfc2V0KGVuYWJsZV9yZXEubWgsIEJGSV9NQ19JT0MsIEJGSV9JT0NfSDJJX0VOQUJMRV9SRVEsCisJCSAgICBiZmFfaW9jX3BvcnRpZChpb2MpKTsKKwllbmFibGVfcmVxLmlvY19jbGFzcyA9IGlvYy0+aW9jX21jOworCWJmYV9pb2NfbWJveF9zZW5kKGlvYywgJmVuYWJsZV9yZXEsIHNpemVvZihzdHJ1Y3QgYmZpX2lvY19jdHJsX3JlcV9zKSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX3NlbmRfZGlzYWJsZShzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJc3RydWN0IGJmaV9pb2NfY3RybF9yZXFfcyBkaXNhYmxlX3JlcTsKKworCWJmaV9oMmlfc2V0KGRpc2FibGVfcmVxLm1oLCBCRklfTUNfSU9DLCBCRklfSU9DX0gySV9ESVNBQkxFX1JFUSwKKwkJICAgIGJmYV9pb2NfcG9ydGlkKGlvYykpOworCWJmYV9pb2NfbWJveF9zZW5kKGlvYywgJmRpc2FibGVfcmVxLCBzaXplb2Yoc3RydWN0IGJmaV9pb2NfY3RybF9yZXFfcykpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY19zZW5kX2dldGF0dHIoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXN0cnVjdCBiZmlfaW9jX2dldGF0dHJfcmVxX3MgYXR0cl9yZXE7CisKKwliZmlfaDJpX3NldChhdHRyX3JlcS5taCwgQkZJX01DX0lPQywgQkZJX0lPQ19IMklfR0VUQVRUUl9SRVEsCisJCSAgICBiZmFfaW9jX3BvcnRpZChpb2MpKTsKKwliZmFfZG1hX2JlX2FkZHJfc2V0KGF0dHJfcmVxLmF0dHJfYWRkciwgaW9jLT5hdHRyX2RtYS5wYSk7CisJYmZhX2lvY19tYm94X3NlbmQoaW9jLCAmYXR0cl9yZXEsIHNpemVvZihhdHRyX3JlcSkpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY19oYl9jaGVjayh2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZhX2lvY19zICppb2MgPSBjYmFyZzsKKwl1MzIgICAgICAgIGhiX2NvdW50OworCisJaGJfY291bnQgPSBiZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5oZWFydGJlYXQpOworCWlmIChpb2MtPmhiX2NvdW50ID09IGhiX2NvdW50KSB7CisJCWlvYy0+aGJfZmFpbCsrOworCX0gZWxzZSB7CisJCWlvYy0+aGJfY291bnQgPSBoYl9jb3VudDsKKwkJaW9jLT5oYl9mYWlsID0gMDsKKwl9CisKKwlpZiAoaW9jLT5oYl9mYWlsID49IEJGQV9JT0NfSEJfRkFJTF9NQVgpIHsKKwkJYmZhX2xvZyhpb2MtPmxvZ20sIEJGQV9MT0dfSEFMX0hFQVJUQkVBVF9GQUlMVVJFLCBoYl9jb3VudCk7CisJCWlvYy0+aGJfZmFpbCA9IDA7CisJCWJmYV9pb2NfcmVjb3Zlcihpb2MpOworCQlyZXR1cm47CisJfQorCisJYmZhX2lvY19tYm94X3BvbGwoaW9jKTsKKwliZmFfdGltZXJfYmVnaW4oaW9jLT50aW1lcl9tb2QsICZpb2MtPmlvY190aW1lciwgYmZhX2lvY19oYl9jaGVjaywgaW9jLAorCQkJQkZBX0lPQ19IQl9UT1YpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY19oYl9tb25pdG9yKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlpb2MtPmhiX2ZhaWwgPSAwOworCWlvYy0+aGJfY291bnQgPSBiZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5oZWFydGJlYXQpOworCWJmYV90aW1lcl9iZWdpbihpb2MtPnRpbWVyX21vZCwgJmlvYy0+aW9jX3RpbWVyLCBiZmFfaW9jX2hiX2NoZWNrLCBpb2MsCisJCQlCRkFfSU9DX0hCX1RPVik7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX2hiX3N0b3Aoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV90aW1lcl9zdG9wKCZpb2MtPmlvY190aW1lcik7Cit9CisKKy8qKgorICogSG9zdCB0byBMUFUgbWFpbGJveCBtZXNzYWdlIGFkZHJlc3NlcworICovCitzdGF0aWMgc3RydWN0IHsKKwl1MzIgICAgICAgIGhmbl9tYm94LCBscHVfbWJveCwgaGZuX3BnbjsKK30gaW9jcmVnX2ZucmVnW10gPSB7CisJeworCUhPU1RGTjBfTFBVX01CT1gwXzAsIExQVV9IT1NURk4wX01CT1gwXzAsIEhPU1RfUEFHRV9OVU1fRk4wfSwgeworCUhPU1RGTjFfTFBVX01CT1gwXzgsIExQVV9IT1NURk4xX01CT1gwXzgsIEhPU1RfUEFHRV9OVU1fRk4xfSwgeworCUhPU1RGTjJfTFBVX01CT1gwXzAsIExQVV9IT1NURk4yX01CT1gwXzAsIEhPU1RfUEFHRV9OVU1fRk4yfSwgeworCUhPU1RGTjNfTFBVX01CT1gwXzgsIExQVV9IT1NURk4zX01CT1gwXzgsIEhPU1RfUEFHRV9OVU1fRk4zfQorfTsKKworLyoqCisgKiBIb3N0IDwtPiBMUFUgbWFpbGJveCBjb21tYW5kL3N0YXR1cyByZWdpc3RlcnMgLSBwb3J0IDAKKyAqLworc3RhdGljIHN0cnVjdCB7CisJdTMyICAgICAgICBoZm4sIGxwdTsKK30gaW9jcmVnX21iY21kX3AwW10gPSB7CisJeworCUhPU1RGTjBfTFBVMF9NQk9YMF9DTURfU1RBVCwgTFBVMF9IT1NURk4wX01CT1gwX0NNRF9TVEFUfSwgeworCUhPU1RGTjFfTFBVMF9NQk9YMF9DTURfU1RBVCwgTFBVMF9IT1NURk4xX01CT1gwX0NNRF9TVEFUfSwgeworCUhPU1RGTjJfTFBVMF9NQk9YMF9DTURfU1RBVCwgTFBVMF9IT1NURk4yX01CT1gwX0NNRF9TVEFUfSwgeworCUhPU1RGTjNfTFBVMF9NQk9YMF9DTURfU1RBVCwgTFBVMF9IT1NURk4zX01CT1gwX0NNRF9TVEFUfQorfTsKKworLyoqCisgKiBIb3N0IDwtPiBMUFUgbWFpbGJveCBjb21tYW5kL3N0YXR1cyByZWdpc3RlcnMgLSBwb3J0IDEKKyAqLworc3RhdGljIHN0cnVjdCB7CisJdTMyICAgICAgICBoZm4sIGxwdTsKK30gaW9jcmVnX21iY21kX3AxW10gPSB7CisJeworCUhPU1RGTjBfTFBVMV9NQk9YMF9DTURfU1RBVCwgTFBVMV9IT1NURk4wX01CT1gwX0NNRF9TVEFUfSwgeworCUhPU1RGTjFfTFBVMV9NQk9YMF9DTURfU1RBVCwgTFBVMV9IT1NURk4xX01CT1gwX0NNRF9TVEFUfSwgeworCUhPU1RGTjJfTFBVMV9NQk9YMF9DTURfU1RBVCwgTFBVMV9IT1NURk4yX01CT1gwX0NNRF9TVEFUfSwgeworCUhPU1RGTjNfTFBVMV9NQk9YMF9DTURfU1RBVCwgTFBVMV9IT1NURk4zX01CT1gwX0NNRF9TVEFUfQorfTsKKworLyoqCisgKiBTaGFyZWQgSVJRIGhhbmRsaW5nIGluIElOVFggbW9kZQorICovCitzdGF0aWMgc3RydWN0IHsKKwl1MzIgICAgICAgIGlzciwgbXNrOworfSBpb2NyZWdfc2hpcnFfbmV4dFtdID0geworCXsKKwlIT1NURk4xX0lOVF9TVEFUVVMsIEhPU1RGTjFfSU5UX01TS30sIHsKKwlIT1NURk4yX0lOVF9TVEFUVVMsIEhPU1RGTjJfSU5UX01TS30sIHsKKwlIT1NURk4zX0lOVF9TVEFUVVMsIEhPU1RGTjNfSU5UX01TS30sIHsKK0hPU1RGTjBfSU5UX1NUQVRVUywgSE9TVEZOMF9JTlRfTVNLfSx9OworCitzdGF0aWMgdm9pZAorYmZhX2lvY19yZWdfaW5pdChzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJYmZhX29zX2FkZHJfdCAgIHJiOworCWludCAgICAgICAgICAgICBwY2lmbiA9IGJmYV9pb2NfcGNpZm4oaW9jKTsKKworCXJiID0gYmZhX2lvY19iYXIwKGlvYyk7CisKKwlpb2MtPmlvY19yZWdzLmhmbl9tYm94ID0gcmIgKyBpb2NyZWdfZm5yZWdbcGNpZm5dLmhmbl9tYm94OworCWlvYy0+aW9jX3JlZ3MubHB1X21ib3ggPSByYiArIGlvY3JlZ19mbnJlZ1twY2lmbl0ubHB1X21ib3g7CisJaW9jLT5pb2NfcmVncy5ob3N0X3BhZ2VfbnVtX2ZuID0gcmIgKyBpb2NyZWdfZm5yZWdbcGNpZm5dLmhmbl9wZ247CisKKwlpZiAoaW9jLT5wb3J0X2lkID09IDApIHsKKwkJaW9jLT5pb2NfcmVncy5oZWFydGJlYXQgPSByYiArIEJGQV9JT0MwX0hCRUFUX1JFRzsKKwkJaW9jLT5pb2NfcmVncy5pb2NfZndzdGF0ZSA9IHJiICsgQkZBX0lPQzBfU1RBVEVfUkVHOworCQlpb2MtPmlvY19yZWdzLmhmbl9tYm94X2NtZCA9IHJiICsgaW9jcmVnX21iY21kX3AwW3BjaWZuXS5oZm47CisJCWlvYy0+aW9jX3JlZ3MubHB1X21ib3hfY21kID0gcmIgKyBpb2NyZWdfbWJjbWRfcDBbcGNpZm5dLmxwdTsKKwkJaW9jLT5pb2NfcmVncy5sbF9oYWx0ID0gcmIgKyBGV19JTklUX0hBTFRfUDA7CisJfSBlbHNlIHsKKwkJaW9jLT5pb2NfcmVncy5oZWFydGJlYXQgPSAocmIgKyBCRkFfSU9DMV9IQkVBVF9SRUcpOworCQlpb2MtPmlvY19yZWdzLmlvY19md3N0YXRlID0gKHJiICsgQkZBX0lPQzFfU1RBVEVfUkVHKTsKKwkJaW9jLT5pb2NfcmVncy5oZm5fbWJveF9jbWQgPSByYiArIGlvY3JlZ19tYmNtZF9wMVtwY2lmbl0uaGZuOworCQlpb2MtPmlvY19yZWdzLmxwdV9tYm94X2NtZCA9IHJiICsgaW9jcmVnX21iY21kX3AxW3BjaWZuXS5scHU7CisJCWlvYy0+aW9jX3JlZ3MubGxfaGFsdCA9IHJiICsgRldfSU5JVF9IQUxUX1AxOworCX0KKworCS8qKgorCSAqIFNoYXJlZCBJUlEgaGFuZGxpbmcgaW4gSU5UWCBtb2RlCisJICovCisJaW9jLT5pb2NfcmVncy5zaGlycV9pc3JfbmV4dCA9IHJiICsgaW9jcmVnX3NoaXJxX25leHRbcGNpZm5dLmlzcjsKKwlpb2MtPmlvY19yZWdzLnNoaXJxX21za19uZXh0ID0gcmIgKyBpb2NyZWdfc2hpcnFfbmV4dFtwY2lmbl0ubXNrOworCisJLyoKKwkgKiBQU1MgY29udHJvbCByZWdpc3RlcnMKKwkgKi8KKwlpb2MtPmlvY19yZWdzLnBzc19jdGxfcmVnID0gKHJiICsgUFNTX0NUTF9SRUcpOworCWlvYy0+aW9jX3JlZ3MuYXBwX3BsbF9mYXN0X2N0bF9yZWcgPSAocmIgKyBBUFBfUExMXzQyNV9DVExfUkVHKTsKKwlpb2MtPmlvY19yZWdzLmFwcF9wbGxfc2xvd19jdGxfcmVnID0gKHJiICsgQVBQX1BMTF8zMTJfQ1RMX1JFRyk7CisKKwkvKgorCSAqIElPQyBzZW1hcGhvcmUgcmVnaXN0ZXJzIGFuZCBzZXJpYWxpemF0aW9uCisJICovCisJaW9jLT5pb2NfcmVncy5pb2Nfc2VtX3JlZyA9IChyYiArIEhPU1RfU0VNMF9SRUcpOworCWlvYy0+aW9jX3JlZ3MuaW9jX3VzYWdlX3NlbV9yZWcgPSAocmIgKyBIT1NUX1NFTTFfUkVHKTsKKwlpb2MtPmlvY19yZWdzLmlvY191c2FnZV9yZWcgPSAocmIgKyBCRkFfRldfVVNFX0NPVU5UKTsKKworCS8qKgorCSAqIHNyYW0gbWVtb3J5IGFjY2VzcworCSAqLworCWlvYy0+aW9jX3JlZ3Muc21lbV9wYWdlX3N0YXJ0ID0gKHJiICsgUFNTX1NNRU1fUEFHRV9TVEFSVCk7CisJaW9jLT5pb2NfcmVncy5zbWVtX3BnMCA9IEJGSV9JT0NfU01FTV9QRzBfQ0I7CisJaWYgKGlvYy0+cGNpZGV2LmRldmljZV9pZCA9PSBCRkFfUENJX0RFVklDRV9JRF9DVCkKKwkJaW9jLT5pb2NfcmVncy5zbWVtX3BnMCA9IEJGSV9JT0NfU01FTV9QRzBfQ1Q7Cit9CisKKy8qKgorICogICAgICBJbml0aWF0ZSBhIGZ1bGwgZmlybXdhcmUgZG93bmxvYWQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX2Rvd25sb2FkX2Z3KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgdTMyIGJvb3RfdHlwZSwKKwkJICAgIHUzMiBib290X3BhcmFtKQoreworCXUzMiAgICAgICAqZndpbWc7CisJdTMyICAgICAgICBwZ251bSwgcGdvZmY7CisJdTMyICAgICAgICBsb2ZmID0gMDsKKwl1MzIgICAgICAgIGNodW5rbm8gPSAwOworCXUzMiAgICAgICAgaTsKKworCS8qKgorCSAqIEluaXRpYWxpemUgTE1FTSBmaXJzdCBiZWZvcmUgY29kZSBkb3dubG9hZAorCSAqLworCWJmYV9pb2NfbG1lbV9pbml0KGlvYyk7CisKKwkvKioKKwkgKiBGbGFzaCBiYXNlZCBmaXJtd2FyZSBib290CisJICovCisJYmZhX3RyYyhpb2MsIGJmYV9pb2NfZndpbWdfZ2V0X3NpemUoaW9jKSk7CisJaWYgKGJmYV9pb2NfZndpbWdfZ2V0X3NpemUoaW9jKSA8IEJGQV9JT0NfRldJTUdfTUlOU1opCisJCWJvb3RfdHlwZSA9IEJGSV9CT09UX1RZUEVfRkxBU0g7CisJZndpbWcgPSBiZmFfaW9jX2Z3aW1nX2dldF9jaHVuayhpb2MsIGNodW5rbm8pOworCWZ3aW1nW0JGSV9CT09UX1RZUEVfT0ZGIC8gc2l6ZW9mKHUzMildID0gYmZhX29zX3N3YXAzMihib290X3R5cGUpOworCWZ3aW1nW0JGSV9CT09UX1BBUkFNX09GRiAvIHNpemVvZih1MzIpXSA9CisJCWJmYV9vc19zd2FwMzIoYm9vdF9wYXJhbSk7CisKKwlwZ251bSA9IGJmYV9pb2Nfc21lbV9wZ251bShpb2MsIGxvZmYpOworCXBnb2ZmID0gYmZhX2lvY19zbWVtX3Bnb2ZmKGlvYywgbG9mZik7CisKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaG9zdF9wYWdlX251bV9mbiwgcGdudW0pOworCisJZm9yIChpID0gMDsgaSA8IGJmYV9pb2NfZndpbWdfZ2V0X3NpemUoaW9jKTsgaSsrKSB7CisKKwkJaWYgKEJGQV9GTEFTSF9DSFVOS19OTyhpKSAhPSBjaHVua25vKSB7CisJCQljaHVua25vID0gQkZBX0ZMQVNIX0NIVU5LX05PKGkpOworCQkJZndpbWcgPSBiZmFfaW9jX2Z3aW1nX2dldF9jaHVuayhpb2MsCisJCQkJCUJGQV9GTEFTSF9DSFVOS19BRERSKGNodW5rbm8pKTsKKwkJfQorCisJCS8qKgorCQkgKiB3cml0ZSBzbWVtCisJCSAqLworCQliZmFfbWVtX3dyaXRlKGlvYy0+aW9jX3JlZ3Muc21lbV9wYWdlX3N0YXJ0LCBsb2ZmLAorCQkJICAgICAgZndpbWdbQkZBX0ZMQVNIX09GRlNFVF9JTl9DSFVOSyhpKV0pOworCisJCWxvZmYgKz0gc2l6ZW9mKHUzMik7CisKKwkJLyoqCisJCSAqIGhhbmRsZSBwYWdlIG9mZnNldCB3cmFwIGFyb3VuZAorCQkgKi8KKwkJbG9mZiA9IFBTU19TTUVNX1BHT0ZGKGxvZmYpOworCQlpZiAobG9mZiA9PSAwKSB7CisJCQlwZ251bSsrOworCQkJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmhvc3RfcGFnZV9udW1fZm4sIHBnbnVtKTsKKwkJfQorCX0KKworCWJmYV9yZWdfd3JpdGUoaW9jLT5pb2NfcmVncy5ob3N0X3BhZ2VfbnVtX2ZuLAorCQkgICAgICBiZmFfaW9jX3NtZW1fcGdudW0oaW9jLCAwKSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX3Jlc2V0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgYmZhX2Jvb2xlYW5fdCBmb3JjZSkKK3sKKwliZmFfaW9jX2h3aW5pdChpb2MsIGZvcmNlKTsKK30KKworLyoqCisgKiBVcGRhdGUgQkZBIGNvbmZpZ3VyYXRpb24gZnJvbSBmaXJtd2FyZSBjb25maWd1cmF0aW9uLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19nZXRhdHRyX3JlcGx5KHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlzdHJ1Y3QgYmZpX2lvY19hdHRyX3MgKmF0dHIgPSBpb2MtPmF0dHI7CisKKwlhdHRyLT5hZGFwdGVyX3Byb3AgPSBiZmFfb3NfbnRvaGwoYXR0ci0+YWRhcHRlcl9wcm9wKTsKKwlhdHRyLT5tYXhmcnNpemUgPSBiZmFfb3NfbnRvaHMoYXR0ci0+bWF4ZnJzaXplKTsKKworCWJmYV9mc21fc2VuZF9ldmVudChpb2MsIElPQ19FX0ZXUlNQX0dFVEFUVFIpOworfQorCisvKioKKyAqIEF0dGFjaCB0aW1lIGluaXRpYWxpemF0aW9uIG9mIG1ib3ggbG9naWMuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX21ib3hfYXR0YWNoKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlzdHJ1Y3QgYmZhX2lvY19tYm94X21vZF9zICptb2QgPSAmaW9jLT5tYm94X21vZDsKKwlpbnQgICAgICAgICAgICAgbWM7CisKKwlJTklUX0xJU1RfSEVBRCgmbW9kLT5jbWRfcSk7CisJZm9yIChtYyA9IDA7IG1jIDwgQkZJX01DX01BWDsgbWMrKykgeworCQltb2QtPm1iaGRsclttY10uY2JmbiA9IE5VTEw7CisJCW1vZC0+bWJoZGxyW21jXS5jYmFyZyA9IGlvYy0+YmZhOworCX0KK30KKworLyoqCisgKiBNYm94IHBvbGwgdGltZXIgLS0gcmVzdGFydHMgYW55IHBlbmRpbmcgbWFpbGJveCByZXF1ZXN0cy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2NfbWJveF9wb2xsKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlzdHJ1Y3QgYmZhX2lvY19tYm94X21vZF9zICptb2QgPSAmaW9jLT5tYm94X21vZDsKKwlzdHJ1Y3QgYmZhX21ib3hfY21kX3MgKmNtZDsKKwl1MzIgICAgICAgIHN0YXQ7CisKKwkvKioKKwkgKiBJZiBubyBjb21tYW5kIHBlbmRpbmcsIGRvIG5vdGhpbmcKKwkgKi8KKwlpZiAobGlzdF9lbXB0eSgmbW9kLT5jbWRfcSkpCisJCXJldHVybjsKKworCS8qKgorCSAqIElmIHByZXZpb3VzIGNvbW1hbmQgaXMgbm90IHlldCBmZXRjaGVkIGJ5IGZpcm13YXJlLCBkbyBub3RoaW5nCisJICovCisJc3RhdCA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLmhmbl9tYm94X2NtZCk7CisJaWYgKHN0YXQpCisJCXJldHVybjsKKworCS8qKgorCSAqIEVucXVldWUgY29tbWFuZCB0byBmaXJtd2FyZS4KKwkgKi8KKwliZmFfcV9kZXEoJm1vZC0+Y21kX3EsICZjbWQpOworCWJmYV9pb2NfbWJveF9zZW5kKGlvYywgY21kLT5tc2csIHNpemVvZihjbWQtPm1zZykpOworfQorCisvKioKKyAqIENsZWFudXAgYW55IHBlbmRpbmcgcmVxdWVzdHMuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX21ib3hfaGJmYWlsKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlzdHJ1Y3QgYmZhX2lvY19tYm94X21vZF9zICptb2QgPSAmaW9jLT5tYm94X21vZDsKKwlzdHJ1Y3QgYmZhX21ib3hfY21kX3MgKmNtZDsKKworCXdoaWxlICghbGlzdF9lbXB0eSgmbW9kLT5jbWRfcSkpCisJCWJmYV9xX2RlcSgmbW9kLT5jbWRfcSwgJmNtZCk7Cit9CisKKy8qKgorICogSW5pdGlhbGl6ZSBJT0MgdG8gcG9ydCBtYXBwaW5nLgorICovCisKKyNkZWZpbmUgRk5DX1BFUlNfRk5fU0hJRlQoX19mbikJKChfX2ZuKSAqIDgpCitzdGF0aWMgdm9pZAorYmZhX2lvY19tYXBfcG9ydChzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJYmZhX29zX2FkZHJfdCAgIHJiID0gaW9jLT5wY2lkZXYucGNpX2Jhcl9rdmE7CisJdTMyICAgICAgICByMzI7CisKKwkvKioKKwkgKiBGb3IgY3Jvc3Nib3csIHBvcnQgaWQgaXMgc2FtZSBhcyBwY2kgZnVuY3Rpb24uCisJICovCisJaWYgKGlvYy0+cGNpZGV2LmRldmljZV9pZCAhPSBCRkFfUENJX0RFVklDRV9JRF9DVCkgeworCQlpb2MtPnBvcnRfaWQgPSBiZmFfaW9jX3BjaWZuKGlvYyk7CisJCXJldHVybjsKKwl9CisKKwkvKioKKwkgKiBGb3IgY2F0YXB1bHQsIGJhc2UgcG9ydCBpZCBvbiBwZXJzb25hbGl0eSByZWdpc3RlciBhbmQgSU9DIHR5cGUKKwkgKi8KKwlyMzIgPSBiZmFfcmVnX3JlYWQocmIgKyBGTkNfUEVSU19SRUcpOworCXIzMiA+Pj0gRk5DX1BFUlNfRk5fU0hJRlQoYmZhX2lvY19wY2lmbihpb2MpKTsKKwlpb2MtPnBvcnRfaWQgPSAocjMyICYgX19GMF9QT1JUX01BUF9NSykgPj4gX19GMF9QT1JUX01BUF9TSDsKKworCWJmYV90cmMoaW9jLCBiZmFfaW9jX3BjaWZuKGlvYykpOworCWJmYV90cmMoaW9jLCBpb2MtPnBvcnRfaWQpOworfQorCisKKworLyoqCisgKiAgYmZhX2lvY19wdWJsaWMKKyAqLworCisvKioKKyogU2V0IGludGVycnVwdCBtb2RlIGZvciBhIGZ1bmN0aW9uOiBJTlRYIG9yIE1TSVgKKyAqLwordm9pZAorYmZhX2lvY19pc3JfbW9kZV9zZXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBiZmFfYm9vbGVhbl90IG1zaXgpCit7CisJYmZhX29zX2FkZHJfdCAgIHJiID0gaW9jLT5wY2lkZXYucGNpX2Jhcl9rdmE7CisJdTMyICAgICAgICByMzIsIG1vZGU7CisKKwlyMzIgPSBiZmFfcmVnX3JlYWQocmIgKyBGTkNfUEVSU19SRUcpOworCWJmYV90cmMoaW9jLCByMzIpOworCisJbW9kZSA9IChyMzIgPj4gRk5DX1BFUlNfRk5fU0hJRlQoYmZhX2lvY19wY2lmbihpb2MpKSkgJgorCQlfX0YwX0lOVFhfU1RBVFVTOworCisJLyoqCisJICogSWYgYWxyZWFkeSBpbiBkZXNpcmVkIG1vZGUsIGRvIG5vdCBjaGFuZ2UgYW55dGhpbmcKKwkgKi8KKwlpZiAoIW1zaXggJiYgbW9kZSkKKwkJcmV0dXJuOworCisJaWYgKG1zaXgpCisJCW1vZGUgPSBfX0YwX0lOVFhfU1RBVFVTX01TSVg7CisJZWxzZQorCQltb2RlID0gX19GMF9JTlRYX1NUQVRVU19JTlRBOworCisJcjMyICY9IH4oX19GMF9JTlRYX1NUQVRVUyA8PCBGTkNfUEVSU19GTl9TSElGVChiZmFfaW9jX3BjaWZuKGlvYykpKTsKKwlyMzIgfD0gKG1vZGUgPDwgRk5DX1BFUlNfRk5fU0hJRlQoYmZhX2lvY19wY2lmbihpb2MpKSk7CisJYmZhX3RyYyhpb2MsIHIzMik7CisKKwliZmFfcmVnX3dyaXRlKHJiICsgRk5DX1BFUlNfUkVHLCByMzIpOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9pb2NfcGxsX2luaXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV9vc19hZGRyX3QgICByYiA9IGlvYy0+cGNpZGV2LnBjaV9iYXJfa3ZhOworCXUzMiAgICAgICAgcGxsX3NjbGssIHBsbF9mY2xrLCByMzI7CisKKwlpZiAoaW9jLT5wY2lkZXYuZGV2aWNlX2lkID09IEJGQV9QQ0lfREVWSUNFX0lEX0NUKSB7CisJCXBsbF9zY2xrID0KKwkJCV9fQVBQX1BMTF8zMTJfRU5BQkxFIHwgX19BUFBfUExMXzMxMl9MUkVTRVROIHwKKwkJCV9fQVBQX1BMTF8zMTJfUlNFTDIwMDUwMCB8IF9fQVBQX1BMTF8zMTJfUDBfMSgwVSkgfAorCQkJX19BUFBfUExMXzMxMl9KSVRMTVQwXzEoM1UpIHwKKwkJCV9fQVBQX1BMTF8zMTJfQ05UTE1UMF8xKDFVKTsKKwkJcGxsX2ZjbGsgPQorCQkJX19BUFBfUExMXzQyNV9FTkFCTEUgfCBfX0FQUF9QTExfNDI1X0xSRVNFVE4gfAorCQkJX19BUFBfUExMXzQyNV9SU0VMMjAwNTAwIHwgX19BUFBfUExMXzQyNV9QMF8xKDBVKSB8CisJCQlfX0FQUF9QTExfNDI1X0pJVExNVDBfMSgzVSkgfAorCQkJX19BUFBfUExMXzQyNV9DTlRMTVQwXzEoMVUpOworCisJCS8qKgorCQkgKiAJRm9yIGNhdGFwdWx0LCBjaG9vc2Ugb3BlcmF0aW9uYWwgbW9kZSBGQy9GQ29FCisJCSAqLworCQlpZiAoaW9jLT5mY21vZGUpIHsKKwkJCWJmYV9yZWdfd3JpdGUoKHJiICsgT1BfTU9ERSksIDApOworCQkJYmZhX3JlZ193cml0ZSgocmIgKyBFVEhfTUFDX1NFUl9SRUcpLAorCQkJCSAgICAgIF9fQVBQX0VNU19DTUxDS1NFTCB8IF9fQVBQX0VNU19SRUZDS0JVRkVOMgorCQkJCSAgICAgIHwgX19BUFBfRU1TX0NIQU5ORUxfU0VMKTsKKwkJfSBlbHNlIHsKKwkJCWlvYy0+cGxsaW5pdCA9IEJGQV9UUlVFOworCQkJYmZhX3JlZ193cml0ZSgocmIgKyBPUF9NT0RFKSwgX19HTE9CQUxfRkNPRV9NT0RFKTsKKwkJCWJmYV9yZWdfd3JpdGUoKHJiICsgRVRIX01BQ19TRVJfUkVHKSwKKwkJCQkgICAgICBfX0FQUF9FTVNfUkVGQ0tCVUZFTjEpOworCQl9CisJfSBlbHNlIHsKKwkJcGxsX3NjbGsgPQorCQkJX19BUFBfUExMXzMxMl9FTkFCTEUgfCBfX0FQUF9QTExfMzEyX0xSRVNFVE4gfAorCQkJX19BUFBfUExMXzMxMl9QMF8xKDNVKSB8IF9fQVBQX1BMTF8zMTJfSklUTE1UMF8xKDNVKSB8CisJCQlfX0FQUF9QTExfMzEyX0NOVExNVDBfMSgzVSk7CisJCXBsbF9mY2xrID0KKwkJCV9fQVBQX1BMTF80MjVfRU5BQkxFIHwgX19BUFBfUExMXzQyNV9MUkVTRVROIHwKKwkJCV9fQVBQX1BMTF80MjVfUlNFTDIwMDUwMCB8IF9fQVBQX1BMTF80MjVfUDBfMSgzVSkgfAorCQkJX19BUFBfUExMXzQyNV9KSVRMTVQwXzEoM1UpIHwKKwkJCV9fQVBQX1BMTF80MjVfQ05UTE1UMF8xKDNVKTsKKwl9CisKKwliZmFfcmVnX3dyaXRlKChyYiArIEJGQV9JT0MwX1NUQVRFX1JFRyksIEJGSV9JT0NfVU5JTklUKTsKKwliZmFfcmVnX3dyaXRlKChyYiArIEJGQV9JT0MxX1NUQVRFX1JFRyksIEJGSV9JT0NfVU5JTklUKTsKKworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMF9JTlRfTVNLKSwgMHhmZmZmZmZmZlUpOworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMV9JTlRfTVNLKSwgMHhmZmZmZmZmZlUpOworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMF9JTlRfU1RBVFVTKSwgMHhmZmZmZmZmZlUpOworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMV9JTlRfU1RBVFVTKSwgMHhmZmZmZmZmZlUpOworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMF9JTlRfTVNLKSwgMHhmZmZmZmZmZlUpOworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMV9JTlRfTVNLKSwgMHhmZmZmZmZmZlUpOworCisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmFwcF9wbGxfc2xvd19jdGxfcmVnLAorCQkgICAgICBfX0FQUF9QTExfMzEyX0xPR0lDX1NPRlRfUkVTRVQpOworCWJmYV9yZWdfd3JpdGUoaW9jLT5pb2NfcmVncy5hcHBfcGxsX3Nsb3dfY3RsX3JlZywKKwkJICAgICAgX19BUFBfUExMXzMxMl9CWVBBU1MgfCBfX0FQUF9QTExfMzEyX0xPR0lDX1NPRlRfUkVTRVQpOworCWJmYV9yZWdfd3JpdGUoaW9jLT5pb2NfcmVncy5hcHBfcGxsX2Zhc3RfY3RsX3JlZywKKwkJICAgICAgX19BUFBfUExMXzQyNV9MT0dJQ19TT0ZUX1JFU0VUKTsKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuYXBwX3BsbF9mYXN0X2N0bF9yZWcsCisJCSAgICAgIF9fQVBQX1BMTF80MjVfQllQQVNTIHwgX19BUFBfUExMXzQyNV9MT0dJQ19TT0ZUX1JFU0VUKTsKKwliZmFfb3NfdWRlbGF5KDIpOworCWJmYV9yZWdfd3JpdGUoaW9jLT5pb2NfcmVncy5hcHBfcGxsX3Nsb3dfY3RsX3JlZywKKwkJICAgICAgX19BUFBfUExMXzMxMl9MT0dJQ19TT0ZUX1JFU0VUKTsKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuYXBwX3BsbF9mYXN0X2N0bF9yZWcsCisJCSAgICAgIF9fQVBQX1BMTF80MjVfTE9HSUNfU09GVF9SRVNFVCk7CisKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuYXBwX3BsbF9zbG93X2N0bF9yZWcsCisJCSAgICAgIHBsbF9zY2xrIHwgX19BUFBfUExMXzMxMl9MT0dJQ19TT0ZUX1JFU0VUKTsKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuYXBwX3BsbF9mYXN0X2N0bF9yZWcsCisJCSAgICAgIHBsbF9mY2xrIHwgX19BUFBfUExMXzQyNV9MT0dJQ19TT0ZUX1JFU0VUKTsKKworCS8qKgorCSAqIFdhaXQgZm9yIFBMTHMgdG8gbG9jay4KKwkgKi8KKwliZmFfb3NfdWRlbGF5KDIwMDApOworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMF9JTlRfU1RBVFVTKSwgMHhmZmZmZmZmZlUpOworCWJmYV9yZWdfd3JpdGUoKHJiICsgSE9TVEZOMV9JTlRfU1RBVFVTKSwgMHhmZmZmZmZmZlUpOworCisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmFwcF9wbGxfc2xvd19jdGxfcmVnLCBwbGxfc2Nsayk7CisJYmZhX3JlZ193cml0ZShpb2MtPmlvY19yZWdzLmFwcF9wbGxfZmFzdF9jdGxfcmVnLCBwbGxfZmNsayk7CisKKwlpZiAoaW9jLT5wY2lkZXYuZGV2aWNlX2lkID09IEJGQV9QQ0lfREVWSUNFX0lEX0NUKSB7CisJCWJmYV9yZWdfd3JpdGUoKHJiICsgTUJJU1RfQ1RMX1JFRyksIF9fRURSQU1fQklTVFJfU1RBUlQpOworCQliZmFfb3NfdWRlbGF5KDEwMDApOworCQlyMzIgPSBiZmFfcmVnX3JlYWQoKHJiICsgTUJJU1RfU1RBVF9SRUcpKTsKKwkJYmZhX3RyYyhpb2MsIHIzMik7CisJfQorCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogSW50ZXJmYWNlIHVzZWQgYnkgZGlhZyBtb2R1bGUgdG8gZG8gZmlybXdhcmUgYm9vdCB3aXRoIG1lbW9yeSB0ZXN0CisgKiBhcyB0aGUgZW50cnkgdmVjdG9yLgorICovCit2b2lkCitiZmFfaW9jX2Jvb3Qoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB1MzIgYm9vdF90eXBlLCB1MzIgYm9vdF9wYXJhbSkKK3sKKwliZmFfb3NfYWRkcl90ICAgcmI7CisKKwliZmFfaW9jX3N0YXRzKGlvYywgaW9jX2Jvb3RzKTsKKworCWlmIChiZmFfaW9jX3BsbF9pbml0KGlvYykgIT0gQkZBX1NUQVRVU19PSykKKwkJcmV0dXJuOworCisJLyoqCisJICogSW5pdGlhbGl6ZSBJT0Mgc3RhdGUgb2YgYWxsIGZ1bmN0aW9ucyBvbiBhIGNoaXAgcmVzZXQuCisJICovCisJcmIgPSBpb2MtPnBjaWRldi5wY2lfYmFyX2t2YTsKKwlpZiAoYm9vdF9wYXJhbSA9PSBCRklfQk9PVF9UWVBFX01FTVRFU1QpIHsKKwkJYmZhX3JlZ193cml0ZSgocmIgKyBCRkFfSU9DMF9TVEFURV9SRUcpLCBCRklfSU9DX01FTVRFU1QpOworCQliZmFfcmVnX3dyaXRlKChyYiArIEJGQV9JT0MxX1NUQVRFX1JFRyksIEJGSV9JT0NfTUVNVEVTVCk7CisJfSBlbHNlIHsKKwkJYmZhX3JlZ193cml0ZSgocmIgKyBCRkFfSU9DMF9TVEFURV9SRUcpLCBCRklfSU9DX0lOSVRJTkcpOworCQliZmFfcmVnX3dyaXRlKChyYiArIEJGQV9JT0MxX1NUQVRFX1JFRyksIEJGSV9JT0NfSU5JVElORyk7CisJfQorCisJYmZhX2lvY19kb3dubG9hZF9mdyhpb2MsIGJvb3RfdHlwZSwgYm9vdF9wYXJhbSk7CisKKwkvKioKKwkgKiBFbmFibGUgaW50ZXJydXB0cyBqdXN0IGJlZm9yZSBzdGFydGluZyBMUFUKKwkgKi8KKwlpb2MtPmNiZm4tPnJlc2V0X2NiZm4oaW9jLT5iZmEpOworCWJmYV9pb2NfbHB1X3N0YXJ0KGlvYyk7Cit9CisKKy8qKgorICogRW5hYmxlL2Rpc2FibGUgSU9DIGZhaWx1cmUgYXV0byByZWNvdmVyeS4KKyAqLwordm9pZAorYmZhX2lvY19hdXRvX3JlY292ZXIoYmZhX2Jvb2xlYW5fdCBhdXRvX3JlY292ZXIpCit7CisJYmZhX2F1dG9fcmVjb3ZlciA9IEJGQV9GQUxTRTsKK30KKworCitiZmFfYm9vbGVhbl90CitiZmFfaW9jX2lzX29wZXJhdGlvbmFsKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlyZXR1cm4gYmZhX2ZzbV9jbXBfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX29wKTsKK30KKwordm9pZAorYmZhX2lvY19tc2dnZXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB2b2lkICptYm1zZykKK3sKKwl1MzIgICAgICAgKm1zZ3AgPSBtYm1zZzsKKwl1MzIgICAgICAgIHIzMjsKKwlpbnQgICAgICAgICAgICAgaTsKKworCS8qKgorCSAqIHJlYWQgdGhlIE1CT1ggbXNnCisJICovCisJZm9yIChpID0gMDsgaSA8IChzaXplb2YodW5pb24gYmZpX2lvY19pMmhfbXNnX3UpIC8gc2l6ZW9mKHUzMikpOworCSAgICAgaSsrKSB7CisJCXIzMiA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLmxwdV9tYm94ICsKKwkJCQkgICBpICogc2l6ZW9mKHUzMikpOworCQltc2dwW2ldID0gYmZhX29zX2h0b25sKHIzMik7CisJfQorCisJLyoqCisJICogdHVybiBvZmYgbWFpbGJveCBpbnRlcnJ1cHQgYnkgY2xlYXJpbmcgbWFpbGJveCBzdGF0dXMKKwkgKi8KKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MubHB1X21ib3hfY21kLCAxKTsKKwliZmFfcmVnX3JlYWQoaW9jLT5pb2NfcmVncy5scHVfbWJveF9jbWQpOworfQorCit2b2lkCitiZmFfaW9jX2lzcihzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHN0cnVjdCBiZmlfbWJtc2dfcyAqbSkKK3sKKwl1bmlvbiBiZmlfaW9jX2kyaF9tc2dfdSAqbXNnOworCisJbXNnID0gKHVuaW9uIGJmaV9pb2NfaTJoX21zZ191ICopbTsKKworCWJmYV9pb2Nfc3RhdHMoaW9jLCBpb2NfaXNycyk7CisKKwlzd2l0Y2ggKG1zZy0+bWgubXNnX2lkKSB7CisJY2FzZSBCRklfSU9DX0kySF9IQkVBVDoKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9JT0NfSTJIX1JFQURZX0VWRU5UOgorCQliZmFfZnNtX3NlbmRfZXZlbnQoaW9jLCBJT0NfRV9GV1JFQURZKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9JT0NfSTJIX0VOQUJMRV9SRVBMWToKKwkJYmZhX2ZzbV9zZW5kX2V2ZW50KGlvYywgSU9DX0VfRldSU1BfRU5BQkxFKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9JT0NfSTJIX0RJU0FCTEVfUkVQTFk6CisJCWJmYV9mc21fc2VuZF9ldmVudChpb2MsIElPQ19FX0ZXUlNQX0RJU0FCTEUpOworCQlicmVhazsKKworCWNhc2UgQkZJX0lPQ19JMkhfR0VUQVRUUl9SRVBMWToKKwkJYmZhX2lvY19nZXRhdHRyX3JlcGx5KGlvYyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3RyYyhpb2MsIG1zZy0+bWgubXNnX2lkKTsKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogSU9DIGF0dGFjaCB0aW1lIGluaXRpYWxpemF0aW9uIGFuZCBzZXR1cC4KKyAqCisgKiBAcGFyYW1baW5dCWlvYwltZW1vcnkgZm9yIElPQworICogQHBhcmFtW2luXQliZmEJZHJpdmVyIGluc3RhbmNlIHN0cnVjdHVyZQorICogQHBhcmFtW2luXQl0cmNtb2QJa2VybmVsIHRyYWNlIG1vZHVsZQorICogQHBhcmFtW2luXQlhZW4Ja2VybmVsIGFlbiBldmVudCBtb2R1bGUKKyAqIEBwYXJhbVtpbl0JbG9nbQlrZXJuZWwgbG9nZ2luZyBtb2R1bGUKKyAqLwordm9pZAorYmZhX2lvY19hdHRhY2goc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB2b2lkICpiZmEsIHN0cnVjdCBiZmFfaW9jX2NiZm5fcyAqY2JmbiwKKwkgICAgICAgc3RydWN0IGJmYV90aW1lcl9tb2RfcyAqdGltZXJfbW9kLCBzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbW9kLAorCSAgICAgICBzdHJ1Y3QgYmZhX2Flbl9zICphZW4sIHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtKQoreworCWlvYy0+YmZhID0gYmZhOworCWlvYy0+Y2JmbiA9IGNiZm47CisJaW9jLT50aW1lcl9tb2QgPSB0aW1lcl9tb2Q7CisJaW9jLT50cmNtb2QgPSB0cmNtb2Q7CisJaW9jLT5hZW4gPSBhZW47CisJaW9jLT5sb2dtID0gbG9nbTsKKwlpb2MtPmZjbW9kZSA9IEJGQV9GQUxTRTsKKwlpb2MtPnBsbGluaXQgPSBCRkFfRkFMU0U7CisJaW9jLT5kYmdfZndzYXZlX29uY2UgPSBCRkFfVFJVRTsKKworCWJmYV9pb2NfbWJveF9hdHRhY2goaW9jKTsKKwlJTklUX0xJU1RfSEVBRCgmaW9jLT5oYl9ub3RpZnlfcSk7CisKKwliZmFfZnNtX3NldF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fcmVzZXQpOworfQorCisvKioKKyAqIERyaXZlciBkZXRhY2ggdGltZSBJT0MgY2xlYW51cC4KKyAqLwordm9pZAorYmZhX2lvY19kZXRhY2goc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV9mc21fc2VuZF9ldmVudChpb2MsIElPQ19FX0RFVEFDSCk7Cit9CisKKy8qKgorICogU2V0dXAgSU9DIFBDSSBwcm9wZXJ0aWVzLgorICoKKyAqIEBwYXJhbVtpbl0JcGNpZGV2CVBDSSBkZXZpY2UgaW5mb3JtYXRpb24gZm9yIHRoaXMgSU9DCisgKi8KK3ZvaWQKK2JmYV9pb2NfcGNpX2luaXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBzdHJ1Y3QgYmZhX3BjaWRldl9zICpwY2lkZXYsCisJCSBlbnVtIGJmaV9tY2xhc3MgbWMpCit7CisJaW9jLT5pb2NfbWMgPSBtYzsKKwlpb2MtPnBjaWRldiA9ICpwY2lkZXY7CisJaW9jLT5jdGRldiA9IChpb2MtPnBjaWRldi5kZXZpY2VfaWQgPT0gQkZBX1BDSV9ERVZJQ0VfSURfQ1QpOworCWlvYy0+Y25hID0gaW9jLT5jdGRldiAmJiAhaW9jLT5mY21vZGU7CisKKwliZmFfaW9jX21hcF9wb3J0KGlvYyk7CisJYmZhX2lvY19yZWdfaW5pdChpb2MpOworfQorCisvKioKKyAqIEluaXRpYWxpemUgSU9DIGRtYSBtZW1vcnkKKyAqCisgKiBAcGFyYW1baW5dCWRtX2t2YQlrZXJuZWwgdmlydHVhbCBhZGRyZXNzIG9mIElPQyBkbWEgbWVtb3J5CisgKiBAcGFyYW1baW5dCWRtX3BhCXBoeXNpY2FsIGFkZHJlc3Mgb2YgSU9DIGRtYSBtZW1vcnkKKyAqLwordm9pZAorYmZhX2lvY19tZW1fY2xhaW0oc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB1OCAqZG1fa3ZhLCB1NjQgZG1fcGEpCit7CisJLyoqCisJICogZG1hIG1lbW9yeSBmb3IgZmlybXdhcmUgYXR0cmlidXRlCisJICovCisJaW9jLT5hdHRyX2RtYS5rdmEgPSBkbV9rdmE7CisJaW9jLT5hdHRyX2RtYS5wYSA9IGRtX3BhOworCWlvYy0+YXR0ciA9IChzdHJ1Y3QgYmZpX2lvY19hdHRyX3MgKilkbV9rdmE7Cit9CisKKy8qKgorICogUmV0dXJuIHNpemUgb2YgZG1hIG1lbW9yeSByZXF1aXJlZC4KKyAqLwordTMyCitiZmFfaW9jX21lbWluZm8odm9pZCkKK3sKKwlyZXR1cm4gQkZBX1JPVU5EVVAoc2l6ZW9mKHN0cnVjdCBiZmlfaW9jX2F0dHJfcyksIEJGQV9ETUFfQUxJR05fU1opOworfQorCit2b2lkCitiZmFfaW9jX2VuYWJsZShzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJYmZhX2lvY19zdGF0cyhpb2MsIGlvY19lbmFibGVzKTsKKwlpb2MtPmRiZ19md3NhdmVfb25jZSA9IEJGQV9UUlVFOworCisJYmZhX2ZzbV9zZW5kX2V2ZW50KGlvYywgSU9DX0VfRU5BQkxFKTsKK30KKwordm9pZAorYmZhX2lvY19kaXNhYmxlKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwliZmFfaW9jX3N0YXRzKGlvYywgaW9jX2Rpc2FibGVzKTsKKwliZmFfZnNtX3NlbmRfZXZlbnQoaW9jLCBJT0NfRV9ESVNBQkxFKTsKK30KKworLyoqCisgKiBSZXR1cm5zIG1lbW9yeSByZXF1aXJlZCBmb3Igc2F2aW5nIGZpcm13YXJlIHRyYWNlIGluIGNhc2Ugb2YgY3Jhc2guCisgKiBEcml2ZXIgbXVzdCBjYWxsIHRoaXMgaW50ZXJmYWNlIHRvIGFsbG9jYXRlIG1lbW9yeSByZXF1aXJlZCBmb3IKKyAqIGF1dG9tYXRpYyBzYXZpbmcgb2YgZmlybXdhcmUgdHJhY2UuIERyaXZlciBzaG91bGQgY2FsbAorICogYmZhX2lvY19kZWJ1Z19tZW1jbGFpbSgpIHJpZ2h0IGFmdGVyIGJmYV9pb2NfYXR0YWNoKCkgdG8gc2V0dXAgdGhpcworICogdHJhY2UgbWVtb3J5LgorICovCitpbnQKK2JmYV9pb2NfZGVidWdfdHJjc3ooYmZhX2Jvb2xlYW5fdCBhdXRvX3JlY292ZXIpCit7CityZXR1cm4gKGF1dG9fcmVjb3ZlcikgPyBCRkFfREJHX0ZXVFJDX0xFTiA6IDA7Cit9CisKKy8qKgorICogSW5pdGlhbGl6ZSBtZW1vcnkgZm9yIHNhdmluZyBmaXJtd2FyZSB0cmFjZS4gRHJpdmVyIG11c3QgaW5pdGlhbGl6ZQorICogdHJhY2UgbWVtb3J5IGJlZm9yZSBjYWxsIGJmYV9pb2NfZW5hYmxlKCkuCisgKi8KK3ZvaWQKK2JmYV9pb2NfZGVidWdfbWVtY2xhaW0oc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB2b2lkICpkYmdfZndzYXZlKQoreworCWJmYV9hc3NlcnQoaW9jLT5hdXRvX3JlY292ZXIpOworCWlvYy0+ZGJnX2Z3c2F2ZSA9IGRiZ19md3NhdmU7CisJaW9jLT5kYmdfZndzYXZlX2xlbiA9IGJmYV9pb2NfZGVidWdfdHJjc3ooaW9jLT5hdXRvX3JlY292ZXIpOworfQorCit1MzIKK2JmYV9pb2Nfc21lbV9wZ251bShzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHUzMiBmbWFkZHIpCit7CisJcmV0dXJuIFBTU19TTUVNX1BHTlVNKGlvYy0+aW9jX3JlZ3Muc21lbV9wZzAsIGZtYWRkcik7Cit9CisKK3UzMgorYmZhX2lvY19zbWVtX3Bnb2ZmKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgdTMyIGZtYWRkcikKK3sKKwlyZXR1cm4gUFNTX1NNRU1fUEdPRkYoZm1hZGRyKTsKK30KKworLyoqCisgKiBSZWdpc3RlciBtYWlsYm94IG1lc3NhZ2UgaGFuZGxlciBmdW5jdGlvbnMKKyAqCisgKiBAcGFyYW1baW5dCWlvYwkJSU9DIGluc3RhbmNlCisgKiBAcGFyYW1baW5dCW1jZnVuY3MJCW1lc3NhZ2UgY2xhc3MgaGFuZGxlciBmdW5jdGlvbnMKKyAqLwordm9pZAorYmZhX2lvY19tYm94X3JlZ2lzdGVyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgYmZhX2lvY19tYm94X21jZnVuY190ICptY2Z1bmNzKQoreworCXN0cnVjdCBiZmFfaW9jX21ib3hfbW9kX3MgKm1vZCA9ICZpb2MtPm1ib3hfbW9kOworCWludCAgICAgICAgICAgICBtYzsKKworCWZvciAobWMgPSAwOyBtYyA8IEJGSV9NQ19NQVg7IG1jKyspCisJCW1vZC0+bWJoZGxyW21jXS5jYmZuID0gbWNmdW5jc1ttY107Cit9CisKKy8qKgorICogUmVnaXN0ZXIgbWFpbGJveCBtZXNzYWdlIGhhbmRsZXIgZnVuY3Rpb24sIHRvIGJlIGNhbGxlZCBieSBjb21tb24gbW9kdWxlcworICovCit2b2lkCitiZmFfaW9jX21ib3hfcmVnaXNyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgZW51bSBiZmlfbWNsYXNzIG1jLAorCQkgICAgYmZhX2lvY19tYm94X21jZnVuY190IGNiZm4sIHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfaW9jX21ib3hfbW9kX3MgKm1vZCA9ICZpb2MtPm1ib3hfbW9kOworCisJbW9kLT5tYmhkbHJbbWNdLmNiZm4gPSBjYmZuOworCW1vZC0+bWJoZGxyW21jXS5jYmFyZyA9IGNiYXJnOworfQorCisvKioKKyAqIFF1ZXVlIGEgbWFpbGJveCBjb21tYW5kIHJlcXVlc3QgdG8gZmlybXdhcmUuIFdhaXRzIGlmIG1haWxib3ggaXMgYnVzeS4KKyAqIFJlc3BvbnNpYmlsaXR5IG9mIGNhbGxlciB0byBzZXJpYWxpemUKKyAqCisgKiBAcGFyYW1baW5dCWlvYwlJT0MgaW5zdGFuY2UKKyAqIEBwYXJhbVtpXQljbWQJTWFpbGJveCBjb21tYW5kCisgKi8KK3ZvaWQKK2JmYV9pb2NfbWJveF9xdWV1ZShzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHN0cnVjdCBiZmFfbWJveF9jbWRfcyAqY21kKQoreworCXN0cnVjdCBiZmFfaW9jX21ib3hfbW9kX3MgKm1vZCA9ICZpb2MtPm1ib3hfbW9kOworCXUzMiAgICAgICAgc3RhdDsKKworCS8qKgorCSAqIElmIGEgcHJldmlvdXMgY29tbWFuZCBpcyBwZW5kaW5nLCBxdWV1ZSBuZXcgY29tbWFuZAorCSAqLworCWlmICghbGlzdF9lbXB0eSgmbW9kLT5jbWRfcSkpIHsKKwkJbGlzdF9hZGRfdGFpbCgmY21kLT5xZSwgJm1vZC0+Y21kX3EpOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogSWYgbWFpbGJveCBpcyBidXN5LCBxdWV1ZSBjb21tYW5kIGZvciBwb2xsIHRpbWVyCisJICovCisJc3RhdCA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLmhmbl9tYm94X2NtZCk7CisJaWYgKHN0YXQpIHsKKwkJbGlzdF9hZGRfdGFpbCgmY21kLT5xZSwgJm1vZC0+Y21kX3EpOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogbWFpbGJveCBpcyBmcmVlIC0tIHF1ZXVlIGNvbW1hbmQgdG8gZmlybXdhcmUKKwkgKi8KKwliZmFfaW9jX21ib3hfc2VuZChpb2MsIGNtZC0+bXNnLCBzaXplb2YoY21kLT5tc2cpKTsKK30KKworLyoqCisgKiBIYW5kbGUgbWFpbGJveCBpbnRlcnJ1cHRzCisgKi8KK3ZvaWQKK2JmYV9pb2NfbWJveF9pc3Ioc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXN0cnVjdCBiZmFfaW9jX21ib3hfbW9kX3MgKm1vZCA9ICZpb2MtPm1ib3hfbW9kOworCXN0cnVjdCBiZmlfbWJtc2dfcyBtOworCWludCAgICAgICAgICAgICBtYzsKKworCWJmYV9pb2NfbXNnZ2V0KGlvYywgJm0pOworCisJLyoqCisJICogVHJlYXQgSU9DIG1lc3NhZ2UgY2xhc3MgYXMgc3BlY2lhbC4KKwkgKi8KKwltYyA9IG0ubWgubXNnX2NsYXNzOworCWlmIChtYyA9PSBCRklfTUNfSU9DKSB7CisJCWJmYV9pb2NfaXNyKGlvYywgJm0pOworCQlyZXR1cm47CisJfQorCisJaWYgKChtYyA+IEJGSV9NQ19NQVgpIHx8IChtb2QtPm1iaGRsclttY10uY2JmbiA9PSBOVUxMKSkKKwkJcmV0dXJuOworCisJbW9kLT5tYmhkbHJbbWNdLmNiZm4obW9kLT5tYmhkbHJbbWNdLmNiYXJnLCAmbSk7Cit9CisKK3ZvaWQKK2JmYV9pb2NfZXJyb3JfaXNyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwliZmFfZnNtX3NlbmRfZXZlbnQoaW9jLCBJT0NfRV9IV0VSUk9SKTsKK30KKworI2lmbmRlZiBCRkFfQklPU19CVUlMRAorCisvKioKKyAqIHJldHVybiB0cnVlIGlmIElPQyBpcyBkaXNhYmxlZAorICovCitiZmFfYm9vbGVhbl90CitiZmFfaW9jX2lzX2Rpc2FibGVkKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlyZXR1cm4gKGJmYV9mc21fY21wX3N0YXRlKGlvYywgYmZhX2lvY19zbV9kaXNhYmxpbmcpCisJCXx8IGJmYV9mc21fY21wX3N0YXRlKGlvYywgYmZhX2lvY19zbV9kaXNhYmxlZCkpOworfQorCisvKioKKyAqIHJldHVybiB0cnVlIGlmIElPQyBmaXJtd2FyZSBpcyBkaWZmZXJlbnQuCisgKi8KK2JmYV9ib29sZWFuX3QKK2JmYV9pb2NfZndfbWlzbWF0Y2goc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXJldHVybiAoYmZhX2ZzbV9jbXBfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX3Jlc2V0KQorCQl8fCBiZmFfZnNtX2NtcF9zdGF0ZShpb2MsIGJmYV9pb2Nfc21fZndjaGVjaykKKwkJfHwgYmZhX2ZzbV9jbXBfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX21pc21hdGNoKSk7Cit9CisKKyNkZWZpbmUgYmZhX2lvY19zdGF0ZV9kaXNhYmxlZChfX3NtKQkJXAorCSgoKF9fc20pID09IEJGSV9JT0NfVU5JTklUKSB8fAkJXAorCSAoKF9fc20pID09IEJGSV9JT0NfSU5JVElORykgfHwJCVwKKwkgKChfX3NtKSA9PSBCRklfSU9DX0hXSU5JVCkgfHwJCVwKKwkgKChfX3NtKSA9PSBCRklfSU9DX0RJU0FCTEVEKSB8fAlcCisJICgoX19zbSkgPT0gQkZJX0lPQ19IQkZBSUwpIHx8CQlcCisJICgoX19zbSkgPT0gQkZJX0lPQ19DRkdfRElTQUJMRUQpKQorCisvKioKKyAqIENoZWNrIGlmIGFkYXB0ZXIgaXMgZGlzYWJsZWQgLS0gYm90aCBJT0NzIHNob3VsZCBiZSBpbiBhIGRpc2FibGVkCisgKiBzdGF0ZS4KKyAqLworYmZhX2Jvb2xlYW5fdAorYmZhX2lvY19hZGFwdGVyX2lzX2Rpc2FibGVkKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwl1MzIgICAgICAgIGlvY19zdGF0ZTsKKwliZmFfb3NfYWRkcl90ICAgcmIgPSBpb2MtPnBjaWRldi5wY2lfYmFyX2t2YTsKKworCWlmICghYmZhX2ZzbV9jbXBfc3RhdGUoaW9jLCBiZmFfaW9jX3NtX2Rpc2FibGVkKSkKKwkJcmV0dXJuIEJGQV9GQUxTRTsKKworCWlvY19zdGF0ZSA9IGJmYV9yZWdfcmVhZChyYiArIEJGQV9JT0MwX1NUQVRFX1JFRyk7CisJaWYgKCFiZmFfaW9jX3N0YXRlX2Rpc2FibGVkKGlvY19zdGF0ZSkpCisJCXJldHVybiBCRkFfRkFMU0U7CisKKwlpb2Nfc3RhdGUgPSBiZmFfcmVnX3JlYWQocmIgKyBCRkFfSU9DMV9TVEFURV9SRUcpOworCWlmICghYmZhX2lvY19zdGF0ZV9kaXNhYmxlZChpb2Nfc3RhdGUpKQorCQlyZXR1cm4gQkZBX0ZBTFNFOworCisJcmV0dXJuIEJGQV9UUlVFOworfQorCisvKioKKyAqIEFkZCB0byBJT0MgaGVhcnRiZWF0IGZhaWx1cmUgbm90aWZpY2F0aW9uIHF1ZXVlLiBUbyBiZSB1c2VkIGJ5IGNvbW1vbgorICogbW9kdWxlcyBzdWNoIGFzCisgKi8KK3ZvaWQKK2JmYV9pb2NfaGJmYWlsX3JlZ2lzdGVyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywKKwkJCXN0cnVjdCBiZmFfaW9jX2hiZmFpbF9ub3RpZnlfcyAqbm90aWZ5KQoreworCWxpc3RfYWRkX3RhaWwoJm5vdGlmeS0+cWUsICZpb2MtPmhiX25vdGlmeV9xKTsKK30KKworI2RlZmluZSBCRkFfTUZHX05BTUUgIkJyb2NhZGUiCit2b2lkCitiZmFfaW9jX2dldF9hZGFwdGVyX2F0dHIoc3RydWN0IGJmYV9pb2NfcyAqaW9jLAorCQkJIHN0cnVjdCBiZmFfYWRhcHRlcl9hdHRyX3MgKmFkX2F0dHIpCit7CisJc3RydWN0IGJmaV9pb2NfYXR0cl9zICppb2NfYXR0cjsKKwljaGFyICAgICAgICAgICAgbW9kZWxbQkZBX0FEQVBURVJfTU9ERUxfTkFNRV9MRU5dOworCisJaW9jX2F0dHIgPSBpb2MtPmF0dHI7CisJYmZhX29zX21lbWNweSgodm9pZCAqKSZhZF9hdHRyLT5zZXJpYWxfbnVtLAorCQkgICAgICAodm9pZCAqKWlvY19hdHRyLT5icmNkX3NlcmlhbG51bSwKKwkJICAgICAgQkZBX0FEQVBURVJfU0VSSUFMX05VTV9MRU4pOworCisJYmZhX29zX21lbWNweSgmYWRfYXR0ci0+ZndfdmVyLCBpb2NfYXR0ci0+ZndfdmVyc2lvbiwgQkZBX1ZFUlNJT05fTEVOKTsKKwliZmFfb3NfbWVtY3B5KCZhZF9hdHRyLT5vcHRyb21fdmVyLCBpb2NfYXR0ci0+b3B0cm9tX3ZlcnNpb24sCisJCSAgICAgIEJGQV9WRVJTSU9OX0xFTik7CisJYmZhX29zX21lbWNweSgmYWRfYXR0ci0+bWFudWZhY3R1cmVyLCBCRkFfTUZHX05BTUUsCisJCSAgICAgIEJGQV9BREFQVEVSX01GR19OQU1FX0xFTik7CisJYmZhX29zX21lbWNweSgmYWRfYXR0ci0+dnBkLCAmaW9jX2F0dHItPnZwZCwKKwkJICAgICAgc2l6ZW9mKHN0cnVjdCBiZmFfbWZnX3ZwZF9zKSk7CisKKwlhZF9hdHRyLT5ucG9ydHMgPSBCRklfQURBUFRFUl9HRVRQKE5QT1JUUywgaW9jX2F0dHItPmFkYXB0ZXJfcHJvcCk7CisJYWRfYXR0ci0+bWF4X3NwZWVkID0gQkZJX0FEQVBURVJfR0VUUChTUEVFRCwgaW9jX2F0dHItPmFkYXB0ZXJfcHJvcCk7CisKKwkvKioKKwkgKiBtb2RlbCBuYW1lCisJICovCisJaWYgKEJGSV9BREFQVEVSX0dFVFAoU1BFRUQsIGlvY19hdHRyLT5hZGFwdGVyX3Byb3ApID09IDEwKSB7CisJCXN0cmNweShtb2RlbCwgIkJSLTEwPzAiKTsKKwkJbW9kZWxbNV0gPSAnMCcgKyBhZF9hdHRyLT5ucG9ydHM7CisJfSBlbHNlIHsKKwkJc3RyY3B5KG1vZGVsLCAiQnJvY2FkZS0/PzUiKTsKKwkJbW9kZWxbOF0gPQorCQkJJzAnICsgQkZJX0FEQVBURVJfR0VUUChTUEVFRCwgaW9jX2F0dHItPmFkYXB0ZXJfcHJvcCk7CisJCW1vZGVsWzldID0gJzAnICsgYWRfYXR0ci0+bnBvcnRzOworCX0KKworCWlmIChCRklfQURBUFRFUl9JU19TUEVDSUFMKGlvY19hdHRyLT5hZGFwdGVyX3Byb3ApKQorCQlhZF9hdHRyLT5wcm90b3R5cGUgPSAxOworCWVsc2UKKwkJYWRfYXR0ci0+cHJvdG90eXBlID0gMDsKKworCWJmYV9vc19tZW1jcHkoJmFkX2F0dHItPm1vZGVsLCBtb2RlbCwgQkZBX0FEQVBURVJfTU9ERUxfTkFNRV9MRU4pOworCWJmYV9vc19tZW1jcHkoJmFkX2F0dHItPm1vZGVsX2Rlc2NyLCAmYWRfYXR0ci0+bW9kZWwsCisJCSAgICAgIEJGQV9BREFQVEVSX01PREVMX05BTUVfTEVOKTsKKworCWFkX2F0dHItPnB3d24gPSBiZmFfaW9jX2dldF9wd3duKGlvYyk7CisJYWRfYXR0ci0+bWFjID0gYmZhX2lvY19nZXRfbWFjKGlvYyk7CisKKwlhZF9hdHRyLT5wY2llX2dlbiA9IGlvY19hdHRyLT5wY2llX2dlbjsKKwlhZF9hdHRyLT5wY2llX2xhbmVzID0gaW9jX2F0dHItPnBjaWVfbGFuZXM7CisJYWRfYXR0ci0+cGNpZV9sYW5lc19vcmlnID0gaW9jX2F0dHItPnBjaWVfbGFuZXNfb3JpZzsKKwlhZF9hdHRyLT5hc2ljX3JldiA9IGlvY19hdHRyLT5hc2ljX3JldjsKKwlhZF9hdHRyLT5od192ZXJbMF0gPSAnUic7CisJYWRfYXR0ci0+aHdfdmVyWzFdID0gJ2UnOworCWFkX2F0dHItPmh3X3ZlclsyXSA9ICd2JzsKKwlhZF9hdHRyLT5od192ZXJbM10gPSAnLSc7CisJYWRfYXR0ci0+aHdfdmVyWzRdID0gaW9jX2F0dHItPmFzaWNfcmV2OworCWFkX2F0dHItPmh3X3Zlcls1XSA9ICdcMCc7CisKKwlhZF9hdHRyLT5jbmFfY2FwYWJsZSA9IGlvYy0+Y25hOworfQorCit2b2lkCitiZmFfaW9jX2dldF9hdHRyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgc3RydWN0IGJmYV9pb2NfYXR0cl9zICppb2NfYXR0cikKK3sKKwliZmFfb3NfbWVtc2V0KCh2b2lkICopaW9jX2F0dHIsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX2lvY19hdHRyX3MpKTsKKworCWlvY19hdHRyLT5zdGF0ZSA9IGJmYV9zbV90b19zdGF0ZShpb2Nfc21fdGFibGUsIGlvYy0+ZnNtKTsKKwlpb2NfYXR0ci0+cG9ydF9pZCA9IGlvYy0+cG9ydF9pZDsKKworCWlmICghaW9jLT5jdGRldikKKwkJaW9jX2F0dHItPmlvY190eXBlID0gQkZBX0lPQ19UWVBFX0ZDOworCWVsc2UgaWYgKGlvYy0+aW9jX21jID09IEJGSV9NQ19JT0NGQykKKwkJaW9jX2F0dHItPmlvY190eXBlID0gQkZBX0lPQ19UWVBFX0ZDb0U7CisJZWxzZSBpZiAoaW9jLT5pb2NfbWMgPT0gQkZJX01DX0xMKQorCQlpb2NfYXR0ci0+aW9jX3R5cGUgPSBCRkFfSU9DX1RZUEVfTEw7CisKKwliZmFfaW9jX2dldF9hZGFwdGVyX2F0dHIoaW9jLCAmaW9jX2F0dHItPmFkYXB0ZXJfYXR0cik7CisKKwlpb2NfYXR0ci0+cGNpX2F0dHIuZGV2aWNlX2lkID0gaW9jLT5wY2lkZXYuZGV2aWNlX2lkOworCWlvY19hdHRyLT5wY2lfYXR0ci5wY2lmbiA9IGlvYy0+cGNpZGV2LnBjaV9mdW5jOworCWlvY19hdHRyLT5wY2lfYXR0ci5jaGlwX3JldlswXSA9ICdSJzsKKwlpb2NfYXR0ci0+cGNpX2F0dHIuY2hpcF9yZXZbMV0gPSAnZSc7CisJaW9jX2F0dHItPnBjaV9hdHRyLmNoaXBfcmV2WzJdID0gJ3YnOworCWlvY19hdHRyLT5wY2lfYXR0ci5jaGlwX3JldlszXSA9ICctJzsKKwlpb2NfYXR0ci0+cGNpX2F0dHIuY2hpcF9yZXZbNF0gPSBpb2NfYXR0ci0+YWRhcHRlcl9hdHRyLmFzaWNfcmV2OworCWlvY19hdHRyLT5wY2lfYXR0ci5jaGlwX3Jldls1XSA9ICdcMCc7Cit9CisKKy8qKgorICogIGhhbF93d25fcHVibGljCisgKi8KK3d3bl90CitiZmFfaW9jX2dldF9wd3duKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwl1bmlvbiB7CisJCXd3bl90ICAgICAgICAgICB3d247CisJCXU4ICAgICAgICAgYnl0ZVtzaXplb2Yod3duX3QpXTsKKwl9CisJdzsKKworCXcud3duID0gaW9jLT5hdHRyLT5tZmdfd3duOworCisJaWYgKGJmYV9pb2NfcG9ydGlkKGlvYykgPT0gMSkKKwkJdy5ieXRlWzddKys7CisKKwlyZXR1cm4gdy53d247Cit9CisKK3d3bl90CitiZmFfaW9jX2dldF9ud3duKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwl1bmlvbiB7CisJCXd3bl90ICAgICAgICAgICB3d247CisJCXU4ICAgICAgICAgYnl0ZVtzaXplb2Yod3duX3QpXTsKKwl9CisJdzsKKworCXcud3duID0gaW9jLT5hdHRyLT5tZmdfd3duOworCisJaWYgKGJmYV9pb2NfcG9ydGlkKGlvYykgPT0gMSkKKwkJdy5ieXRlWzddKys7CisKKwl3LmJ5dGVbMF0gPSAweDIwOworCisJcmV0dXJuIHcud3duOworfQorCit3d25fdAorYmZhX2lvY19nZXRfd3duX25hYTUoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB1MTYgaW5zdCkKK3sKKwl1bmlvbiB7CisJCXd3bl90ICAgICAgICAgICB3d247CisJCXU4ICAgICAgICAgYnl0ZVtzaXplb2Yod3duX3QpXTsKKwl9CisJdyAgICAgICAgICAgICAgLCB3NTsKKworCWJmYV90cmMoaW9jLCBpbnN0KTsKKworCXcud3duID0gaW9jLT5hdHRyLT5tZmdfd3duOworCXc1LmJ5dGVbMF0gPSAweDUwIHwgdy5ieXRlWzJdID4+IDQ7CisJdzUuYnl0ZVsxXSA9IHcuYnl0ZVsyXSA8PCA0IHwgdy5ieXRlWzNdID4+IDQ7CisJdzUuYnl0ZVsyXSA9IHcuYnl0ZVszXSA8PCA0IHwgdy5ieXRlWzRdID4+IDQ7CisJdzUuYnl0ZVszXSA9IHcuYnl0ZVs0XSA8PCA0IHwgdy5ieXRlWzVdID4+IDQ7CisJdzUuYnl0ZVs0XSA9IHcuYnl0ZVs1XSA8PCA0IHwgdy5ieXRlWzZdID4+IDQ7CisJdzUuYnl0ZVs1XSA9IHcuYnl0ZVs2XSA8PCA0IHwgdy5ieXRlWzddID4+IDQ7CisJdzUuYnl0ZVs2XSA9IHcuYnl0ZVs3XSA8PCA0IHwgKGluc3QgJiAweDBmMDApID4+IDg7CisJdzUuYnl0ZVs3XSA9IChpbnN0ICYgMHhmZik7CisKKwlyZXR1cm4gdzUud3duOworfQorCit1NjQKK2JmYV9pb2NfZ2V0X2FkaWQoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCXJldHVybiBpb2MtPmF0dHItPm1mZ193d247Cit9CisKK21hY190CitiZmFfaW9jX2dldF9tYWMoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCW1hY190ICAgICAgICAgICBtYWM7CisKKwltYWMgPSBpb2MtPmF0dHItPm1mZ19tYWM7CisJbWFjLm1hY1tNQUNfQUREUkxFTiAtIDFdICs9IGJmYV9pb2NfcGNpZm4oaW9jKTsKKworCXJldHVybiBtYWM7Cit9CisKK3ZvaWQKK2JmYV9pb2Nfc2V0X2ZjbW9kZShzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJaW9jLT5mY21vZGUgPSBCRkFfVFJVRTsKKwlpb2MtPnBvcnRfaWQgPSBiZmFfaW9jX3BjaWZuKGlvYyk7Cit9CisKK2JmYV9ib29sZWFuX3QKK2JmYV9pb2NfZ2V0X2ZjbW9kZShzdHJ1Y3QgYmZhX2lvY19zICppb2MpCit7CisJcmV0dXJuIGlvYy0+ZmNtb2RlIHx8IChpb2MtPnBjaWRldi5kZXZpY2VfaWQgIT0gQkZBX1BDSV9ERVZJQ0VfSURfQ1QpOworfQorCisvKioKKyAqIFJldHVybiB0cnVlIGlmIGludGVycnVwdCBzaG91bGQgYmUgY2xhaW1lZC4KKyAqLworYmZhX2Jvb2xlYW5fdAorYmZhX2lvY19pbnR4X2NsYWltKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwl1MzIgICAgICAgIGlzciwgbXNrOworCisJLyoqCisJICogQWx3YXlzIGNsYWltIGlmIG5vdCBjYXRhcHVsdC4KKwkgKi8KKwlpZiAoIWlvYy0+Y3RkZXYpCisJCXJldHVybiBCRkFfVFJVRTsKKworCS8qKgorCSAqIEZBTFNFIGlmIG5leHQgZGV2aWNlIGlzIGNsYWltaW5nIGludGVycnVwdC4KKwkgKiBUUlVFIGlmIG5leHQgZGV2aWNlIGlzIG5vdCBpbnRlcnJ1cHRpbmcgb3Igbm90IHByZXNlbnQuCisJICovCisJbXNrID0gYmZhX3JlZ19yZWFkKGlvYy0+aW9jX3JlZ3Muc2hpcnFfbXNrX25leHQpOworCWlzciA9IGJmYV9yZWdfcmVhZChpb2MtPmlvY19yZWdzLnNoaXJxX2lzcl9uZXh0KTsKKwlyZXR1cm4gIShpc3IgJiB+bXNrKTsKK30KKworLyoqCisgKiBTZW5kIEFFTiBub3RpZmljYXRpb24KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2NfYWVuX3Bvc3Qoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBlbnVtIGJmYV9pb2NfYWVuX2V2ZW50IGV2ZW50KQoreworCXVuaW9uIGJmYV9hZW5fZGF0YV91IGFlbl9kYXRhOworCXN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtb2QgPSBpb2MtPmxvZ207CisJczMyICAgICAgICAgaW5zdF9udW0gPSAwOworCXN0cnVjdCBiZmFfaW9jX2F0dHJfcyBpb2NfYXR0cjsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JT0NfQUVOX0hCR09PRDoKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fSU9DX0hCR09PRCwgaW5zdF9udW0pOworCQlicmVhazsKKwljYXNlIEJGQV9JT0NfQUVOX0hCRkFJTDoKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fSU9DX0hCRkFJTCwgaW5zdF9udW0pOworCQlicmVhazsKKwljYXNlIEJGQV9JT0NfQUVOX0VOQUJMRToKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fSU9DX0VOQUJMRSwgaW5zdF9udW0pOworCQlicmVhazsKKwljYXNlIEJGQV9JT0NfQUVOX0RJU0FCTEU6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX0lPQ19ESVNBQkxFLCBpbnN0X251bSk7CisJCWJyZWFrOworCWNhc2UgQkZBX0lPQ19BRU5fRldNSVNNQVRDSDoKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fSU9DX0ZXTUlTTUFUQ0gsIGluc3RfbnVtKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJbWVtc2V0KCZhZW5fZGF0YS5pb2MucHd3biwgMCwgc2l6ZW9mKGFlbl9kYXRhLmlvYy5wd3duKSk7CisJbWVtc2V0KCZhZW5fZGF0YS5pb2MubWFjLCAwLCBzaXplb2YoYWVuX2RhdGEuaW9jLm1hYykpOworCWJmYV9pb2NfZ2V0X2F0dHIoaW9jLCAmaW9jX2F0dHIpOworCXN3aXRjaCAoaW9jX2F0dHIuaW9jX3R5cGUpIHsKKwljYXNlIEJGQV9JT0NfVFlQRV9GQzoKKwkJYWVuX2RhdGEuaW9jLnB3d24gPSBiZmFfaW9jX2dldF9wd3duKGlvYyk7CisJCWJyZWFrOworCWNhc2UgQkZBX0lPQ19UWVBFX0ZDb0U6CisJCWFlbl9kYXRhLmlvYy5wd3duID0gYmZhX2lvY19nZXRfcHd3bihpb2MpOworCQlhZW5fZGF0YS5pb2MubWFjID0gYmZhX2lvY19nZXRfbWFjKGlvYyk7CisJCWJyZWFrOworCWNhc2UgQkZBX0lPQ19UWVBFX0xMOgorCQlhZW5fZGF0YS5pb2MubWFjID0gYmZhX2lvY19nZXRfbWFjKGlvYyk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoaW9jX2F0dHIuaW9jX3R5cGUgPT0gQkZBX0lPQ19UWVBFX0ZDKTsKKwkJYnJlYWs7CisJfQorCWFlbl9kYXRhLmlvYy5pb2NfdHlwZSA9IGlvY19hdHRyLmlvY190eXBlOworfQorCisvKioKKyAqIFJldHJpZXZlIHNhdmVkIGZpcm13YXJlIHRyYWNlIGZyb20gYSBwcmlvciBJT0MgZmFpbHVyZS4KKyAqLworYmZhX3N0YXR1c190CitiZmFfaW9jX2RlYnVnX2Z3c2F2ZShzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHZvaWQgKnRyY2RhdGEsIGludCAqdHJjbGVuKQoreworCWludCAgICAgICAgICAgICB0bGVuOworCisJaWYgKGlvYy0+ZGJnX2Z3c2F2ZV9sZW4gPT0gMCkKKwkJcmV0dXJuIEJGQV9TVEFUVVNfRU5PRlNBVkU7CisKKwl0bGVuID0gKnRyY2xlbjsKKwlpZiAodGxlbiA+IGlvYy0+ZGJnX2Z3c2F2ZV9sZW4pCisJCXRsZW4gPSBpb2MtPmRiZ19md3NhdmVfbGVuOworCisJYmZhX29zX21lbWNweSh0cmNkYXRhLCBpb2MtPmRiZ19md3NhdmUsIHRsZW4pOworCSp0cmNsZW4gPSB0bGVuOworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqIFJldHJpZXZlIHNhdmVkIGZpcm13YXJlIHRyYWNlIGZyb20gYSBwcmlvciBJT0MgZmFpbHVyZS4KKyAqLworYmZhX3N0YXR1c190CitiZmFfaW9jX2RlYnVnX2Z3dHJjKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgdm9pZCAqdHJjZGF0YSwgaW50ICp0cmNsZW4pCit7CisJdTMyICAgICAgICBwZ251bTsKKwl1MzIgICAgICAgIGxvZmYgPSBCRkFfREJHX0ZXVFJDX09GRihiZmFfaW9jX3BvcnRpZChpb2MpKTsKKwlpbnQgICAgICAgICAgICAgaSwgdGxlbjsKKwl1MzIgICAgICAgKnRidWYgPSB0cmNkYXRhLCByMzI7CisKKwliZmFfdHJjKGlvYywgKnRyY2xlbik7CisKKwlwZ251bSA9IGJmYV9pb2Nfc21lbV9wZ251bShpb2MsIGxvZmYpOworCWxvZmYgPSBiZmFfaW9jX3NtZW1fcGdvZmYoaW9jLCBsb2ZmKTsKKwliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaG9zdF9wYWdlX251bV9mbiwgcGdudW0pOworCisJdGxlbiA9ICp0cmNsZW47CisJaWYgKHRsZW4gPiBCRkFfREJHX0ZXVFJDX0xFTikKKwkJdGxlbiA9IEJGQV9EQkdfRldUUkNfTEVOOworCXRsZW4gLz0gc2l6ZW9mKHUzMik7CisKKwliZmFfdHJjKGlvYywgdGxlbik7CisKKwlmb3IgKGkgPSAwOyBpIDwgdGxlbjsgaSsrKSB7CisJCXIzMiA9IGJmYV9tZW1fcmVhZChpb2MtPmlvY19yZWdzLnNtZW1fcGFnZV9zdGFydCwgbG9mZik7CisJCXRidWZbaV0gPSBiZmFfb3NfbnRvaGwocjMyKTsKKwkJbG9mZiArPSBzaXplb2YodTMyKTsKKworCQkvKioKKwkJICogaGFuZGxlIHBhZ2Ugb2Zmc2V0IHdyYXAgYXJvdW5kCisJCSAqLworCQlsb2ZmID0gUFNTX1NNRU1fUEdPRkYobG9mZik7CisJCWlmIChsb2ZmID09IDApIHsKKwkJCXBnbnVtKys7CisJCQliZmFfcmVnX3dyaXRlKGlvYy0+aW9jX3JlZ3MuaG9zdF9wYWdlX251bV9mbiwgcGdudW0pOworCQl9CisJfQorCWJmYV9yZWdfd3JpdGUoaW9jLT5pb2NfcmVncy5ob3N0X3BhZ2VfbnVtX2ZuLAorCQkgICAgICBiZmFfaW9jX3NtZW1fcGdudW0oaW9jLCAwKSk7CisJYmZhX3RyYyhpb2MsIHBnbnVtKTsKKworCSp0cmNsZW4gPSB0bGVuICogc2l6ZW9mKHUzMik7CisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogU2F2ZSBmaXJtd2FyZSB0cmFjZSBpZiBjb25maWd1cmVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY19kZWJ1Z19zYXZlKHN0cnVjdCBiZmFfaW9jX3MgKmlvYykKK3sKKwlpbnQgICAgICAgICAgICAgdGxlbjsKKworCWlmIChpb2MtPmRiZ19md3NhdmVfbGVuKSB7CisJCXRsZW4gPSBpb2MtPmRiZ19md3NhdmVfbGVuOworCQliZmFfaW9jX2RlYnVnX2Z3dHJjKGlvYywgaW9jLT5kYmdfZndzYXZlLCAmdGxlbik7CisJfQorfQorCisvKioKKyAqIEZpcm13YXJlIGZhaWx1cmUgZGV0ZWN0ZWQuIFN0YXJ0IHJlY292ZXJ5IGFjdGlvbnMuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jX3JlY292ZXIoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWlmIChpb2MtPmRiZ19md3NhdmVfb25jZSkgeworCQlpb2MtPmRiZ19md3NhdmVfb25jZSA9IEJGQV9GQUxTRTsKKwkJYmZhX2lvY19kZWJ1Z19zYXZlKGlvYyk7CisJfQorCisJYmZhX2lvY19zdGF0cyhpb2MsIGlvY19oYmZhaWxzKTsKKwliZmFfZnNtX3NlbmRfZXZlbnQoaW9jLCBJT0NfRV9IQkZBSUwpOworfQorCisjZWxzZQorCitzdGF0aWMgdm9pZAorYmZhX2lvY19hZW5fcG9zdChzdHJ1Y3QgYmZhX2lvY19zICppb2MsIGVudW0gYmZhX2lvY19hZW5fZXZlbnQgZXZlbnQpCit7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaW9jX3JlY292ZXIoc3RydWN0IGJmYV9pb2NfcyAqaW9jKQoreworCWJmYV9hc3NlcnQoMCk7Cit9CisKKyNlbmRpZgorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvYy5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW9jLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNThlZmQ0YgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvYy5oCkBAIC0wLDAgKzEsMjU5IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfSU9DX0hfXworI2RlZmluZSBfX0JGQV9JT0NfSF9fCisKKyNpbmNsdWRlIDxjcy9iZmFfc20uaD4KKyNpbmNsdWRlIDxiZmkvYmZpLmg+CisjaW5jbHVkZSA8YmZpL2JmaV9pb2MuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX2Jvb3QuaD4KKyNpbmNsdWRlIDxiZmFfdGltZXIuaD4KKworLyoqCisgKiBQQ0kgZGV2aWNlIGluZm9ybWF0aW9uIHJlcXVpcmVkIGJ5IElPQworICovCitzdHJ1Y3QgYmZhX3BjaWRldl9zIHsKKwlpbnQgICAgICAgICAgICAgcGNpX3Nsb3Q7CisJdTggICAgICAgICBwY2lfZnVuYzsKKwl1MTYJZGV2aWNlX2lkOworCWJmYV9vc19hZGRyX3QgICBwY2lfYmFyX2t2YTsKK307CisKKy8qKgorICogU3RydWN0dXJlIHVzZWQgdG8gcmVtZW1iZXIgdGhlIERNQS1hYmxlIG1lbW9yeSBibG9jaydzIEtWQSBhbmQgUGh5c2ljYWwKKyAqIEFkZHJlc3MKKyAqLworc3RydWN0IGJmYV9kbWFfcyB7CisJdm9pZAkJKmt2YTsJLyohIEtlcm5lbCB2aXJ0dWFsIGFkZHJlc3MJKi8KKwl1NjQJcGE7CS8qISBQaHlzaWNhbCBhZGRyZXNzCQkqLworfTsKKworI2RlZmluZSBCRkFfRE1BX0FMSUdOX1NaCTI1NgorI2RlZmluZSBCRkFfUk9VTkRVUChfbCwgX3MpCSgoKF9sKSArICgoX3MpIC0gMSkpICYgfigoX3MpIC0gMSkpCisKKworCisjZGVmaW5lIGJmYV9kbWFfYWRkcl9zZXQoZG1hX2FkZHIsIHBhKQlcCisJCV9fYmZhX2RtYV9hZGRyX3NldCgmZG1hX2FkZHIsICh1NjQpcGEpCisKK3N0YXRpYyBpbmxpbmUgdm9pZAorX19iZmFfZG1hX2FkZHJfc2V0KHVuaW9uIGJmaV9hZGRyX3UgKmRtYV9hZGRyLCB1NjQgcGEpCit7CisJZG1hX2FkZHItPmEzMi5hZGRyX2xvID0gKHUzMikgcGE7CisJZG1hX2FkZHItPmEzMi5hZGRyX2hpID0gKHUzMikgKGJmYV9vc191MzIocGEpKTsKK30KKworCisjZGVmaW5lIGJmYV9kbWFfYmVfYWRkcl9zZXQoZG1hX2FkZHIsIHBhKQlcCisJCV9fYmZhX2RtYV9iZV9hZGRyX3NldCgmZG1hX2FkZHIsICh1NjQpcGEpCitzdGF0aWMgaW5saW5lIHZvaWQKK19fYmZhX2RtYV9iZV9hZGRyX3NldCh1bmlvbiBiZmlfYWRkcl91ICpkbWFfYWRkciwgdTY0IHBhKQoreworCWRtYV9hZGRyLT5hMzIuYWRkcl9sbyA9ICh1MzIpIGJmYV9vc19odG9ubChwYSk7CisJZG1hX2FkZHItPmEzMi5hZGRyX2hpID0gKHUzMikgYmZhX29zX2h0b25sKGJmYV9vc191MzIocGEpKTsKK30KKworc3RydWN0IGJmYV9pb2NfcmVnc19zIHsKKwliZmFfb3NfYWRkcl90ICAgaGZuX21ib3hfY21kOworCWJmYV9vc19hZGRyX3QgICBoZm5fbWJveDsKKwliZmFfb3NfYWRkcl90ICAgbHB1X21ib3hfY21kOworCWJmYV9vc19hZGRyX3QgICBscHVfbWJveDsKKwliZmFfb3NfYWRkcl90ICAgcHNzX2N0bF9yZWc7CisJYmZhX29zX2FkZHJfdCAgIGFwcF9wbGxfZmFzdF9jdGxfcmVnOworCWJmYV9vc19hZGRyX3QgICBhcHBfcGxsX3Nsb3dfY3RsX3JlZzsKKwliZmFfb3NfYWRkcl90ICAgaW9jX3NlbV9yZWc7CisJYmZhX29zX2FkZHJfdCAgIGlvY191c2FnZV9zZW1fcmVnOworCWJmYV9vc19hZGRyX3QgICBpb2NfdXNhZ2VfcmVnOworCWJmYV9vc19hZGRyX3QgICBob3N0X3BhZ2VfbnVtX2ZuOworCWJmYV9vc19hZGRyX3QgICBoZWFydGJlYXQ7CisJYmZhX29zX2FkZHJfdCAgIGlvY19md3N0YXRlOworCWJmYV9vc19hZGRyX3QgICBsbF9oYWx0OworCWJmYV9vc19hZGRyX3QgICBzaGlycV9pc3JfbmV4dDsKKwliZmFfb3NfYWRkcl90ICAgc2hpcnFfbXNrX25leHQ7CisJYmZhX29zX2FkZHJfdCAgIHNtZW1fcGFnZV9zdGFydDsKKwl1MzIJc21lbV9wZzA7Cit9OworCisjZGVmaW5lIGJmYV9yZWdfcmVhZChfcmFkZHIpCWJmYV9vc19yZWdfcmVhZChfcmFkZHIpCisjZGVmaW5lIGJmYV9yZWdfd3JpdGUoX3JhZGRyLCBfdmFsKQliZmFfb3NfcmVnX3dyaXRlKF9yYWRkciwgX3ZhbCkKKyNkZWZpbmUgYmZhX21lbV9yZWFkKF9yYWRkciwgX29mZikJYmZhX29zX21lbV9yZWFkKF9yYWRkciwgX29mZikKKyNkZWZpbmUgYmZhX21lbV93cml0ZShfcmFkZHIsIF9vZmYsIF92YWwpCVwKKwkJCQkJYmZhX29zX21lbV93cml0ZShfcmFkZHIsIF9vZmYsIF92YWwpCisvKioKKyAqIElPQyBNYWlsYm94IHN0cnVjdHVyZXMKKyAqLworc3RydWN0IGJmYV9tYm94X2NtZF9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkCQlxZTsKKwl1MzIJbXNnW0JGSV9JT0NfTVNHU1pdOworfTsKKworLyoqCisgKiBJT0MgbWFpbGJveCBtb2R1bGUKKyAqLwordHlwZWRlZiB2b2lkICgqYmZhX2lvY19tYm94X21jZnVuY190KSh2b2lkICpjYmFyZywgc3RydWN0IGJmaV9tYm1zZ19zICptKTsKK3N0cnVjdCBiZmFfaW9jX21ib3hfbW9kX3MgeworCXN0cnVjdCBsaXN0X2hlYWQJY21kX3E7CQkvKiAgcGVuZGluZyBtYm94IHF1ZXVlCSovCisJaW50CQlubWNsYXNzOwkvKiAgbnVtYmVyIG9mIGhhbmRsZXJzICovCisJc3RydWN0IHsKKwkJYmZhX2lvY19tYm94X21jZnVuY190CWNiZm47CS8qICBtZXNzYWdlIGhhbmRsZXJzCSovCisJCXZvaWQJCQkqY2Jhcmc7CisJfSBtYmhkbHJbQkZJX01DX01BWF07Cit9OworCisvKioKKyAqIElPQyBjYWxsYmFjayBmdW5jdGlvbiBpbnRlcmZhY2VzCisgKi8KK3R5cGVkZWYgdm9pZCAoKmJmYV9pb2NfZW5hYmxlX2NiZm5fdCkodm9pZCAqYmZhLCBlbnVtIGJmYV9zdGF0dXMgc3RhdHVzKTsKK3R5cGVkZWYgdm9pZCAoKmJmYV9pb2NfZGlzYWJsZV9jYmZuX3QpKHZvaWQgKmJmYSk7Cit0eXBlZGVmIHZvaWQgKCpiZmFfaW9jX2hiZmFpbF9jYmZuX3QpKHZvaWQgKmJmYSk7Cit0eXBlZGVmIHZvaWQgKCpiZmFfaW9jX3Jlc2V0X2NiZm5fdCkodm9pZCAqYmZhKTsKK3N0cnVjdCBiZmFfaW9jX2NiZm5fcyB7CisJYmZhX2lvY19lbmFibGVfY2Jmbl90CWVuYWJsZV9jYmZuOworCWJmYV9pb2NfZGlzYWJsZV9jYmZuX3QJZGlzYWJsZV9jYmZuOworCWJmYV9pb2NfaGJmYWlsX2NiZm5fdAloYmZhaWxfY2JmbjsKKwliZmFfaW9jX3Jlc2V0X2NiZm5fdAlyZXNldF9jYmZuOworfTsKKworLyoqCisgKiBIZWFydGJlYXQgZmFpbHVyZSBub3RpZmljYXRpb24gcXVldWUgZWxlbWVudC4KKyAqLworc3RydWN0IGJmYV9pb2NfaGJmYWlsX25vdGlmeV9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkCQlxZTsKKwliZmFfaW9jX2hiZmFpbF9jYmZuX3QJY2JmbjsKKwl2b2lkCQkJKmNiYXJnOworfTsKKworLyoqCisgKiBJbml0aWFsaXplIGEgaGVhcnRiZWF0IGZhaWx1cmUgbm90aWZpY2F0aW9uIHN0cnVjdHVyZQorICovCisjZGVmaW5lIGJmYV9pb2NfaGJmYWlsX2luaXQoX19ub3RpZnksIF9fY2JmbiwgX19jYmFyZykgZG8gewlcCisJKF9fbm90aWZ5KS0+Y2JmbiA9IChfX2NiZm4pOyAgICAgIFwKKwkoX19ub3RpZnkpLT5jYmFyZyA9IChfX2NiYXJnKTsgICAgICBcCit9IHdoaWxlICgwKQorCitzdHJ1Y3QgYmZhX2lvY19zIHsKKwliZmFfZnNtX3QJCWZzbTsKKwlzdHJ1Y3QgYmZhX3MJCSpiZmE7CisJc3RydWN0IGJmYV9wY2lkZXZfcwlwY2lkZXY7CisJc3RydWN0IGJmYV90aW1lcl9tb2RfcyAJKnRpbWVyX21vZDsKKwlzdHJ1Y3QgYmZhX3RpbWVyX3MgCWlvY190aW1lcjsKKwlzdHJ1Y3QgYmZhX3RpbWVyX3MgCXNlbV90aW1lcjsKKwl1MzIJCWhiX2NvdW50OworCXUzMgkJaGJfZmFpbDsKKwl1MzIJCXJldHJ5X2NvdW50OworCXN0cnVjdCBsaXN0X2hlYWQJCWhiX25vdGlmeV9xOworCXZvaWQJCQkqZGJnX2Z3c2F2ZTsKKwlpbnQJCQlkYmdfZndzYXZlX2xlbjsKKwliZmFfYm9vbGVhbl90CQlkYmdfZndzYXZlX29uY2U7CisJZW51bSBiZmlfbWNsYXNzCQlpb2NfbWM7CisJc3RydWN0IGJmYV9pb2NfcmVnc19zIAlpb2NfcmVnczsKKwlzdHJ1Y3QgYmZhX3RyY19tb2RfcwkqdHJjbW9kOworCXN0cnVjdCBiZmFfYWVuX3MJKmFlbjsKKwlzdHJ1Y3QgYmZhX2xvZ19tb2RfcwkqbG9nbTsKKwlzdHJ1Y3QgYmZhX2lvY19kcnZfc3RhdHNfcwlzdGF0czsKKwliZmFfYm9vbGVhbl90CQlhdXRvX3JlY292ZXI7CisJYmZhX2Jvb2xlYW5fdAkJZmNtb2RlOworCWJmYV9ib29sZWFuX3QJCWN0ZGV2OworCWJmYV9ib29sZWFuX3QJCWNuYTsKKwliZmFfYm9vbGVhbl90CQlwbGxpbml0OworCXU4CQkJcG9ydF9pZDsKKworCXN0cnVjdCBiZmFfZG1hX3MJYXR0cl9kbWE7CisJc3RydWN0IGJmaV9pb2NfYXR0cl9zCSphdHRyOworCXN0cnVjdCBiZmFfaW9jX2NiZm5fcwkqY2JmbjsKKwlzdHJ1Y3QgYmZhX2lvY19tYm94X21vZF9zIG1ib3hfbW9kOworfTsKKworI2RlZmluZSBiZmFfaW9jX3BjaWZuKF9faW9jKQkJKF9faW9jKS0+cGNpZGV2LnBjaV9mdW5jCisjZGVmaW5lIGJmYV9pb2NfZGV2aWQoX19pb2MpCQkoX19pb2MpLT5wY2lkZXYuZGV2aWNlX2lkCisjZGVmaW5lIGJmYV9pb2NfYmFyMChfX2lvYykJCShfX2lvYyktPnBjaWRldi5wY2lfYmFyX2t2YQorI2RlZmluZSBiZmFfaW9jX3BvcnRpZChfX2lvYykJCSgoX19pb2MpLT5wb3J0X2lkKQorI2RlZmluZSBiZmFfaW9jX2ZldGNoX3N0YXRzKF9faW9jLCBfX3N0YXRzKSBcCisJCSgoX19zdGF0cyktPmRydl9zdGF0cykgPSAoX19pb2MpLT5zdGF0cworI2RlZmluZSBiZmFfaW9jX2Nscl9zdGF0cyhfX2lvYykJXAorCQliZmFfb3NfbWVtc2V0KCYoX19pb2MpLT5zdGF0cywgMCwgc2l6ZW9mKChfX2lvYyktPnN0YXRzKSkKKyNkZWZpbmUgYmZhX2lvY19tYXhmcnNpemUoX19pb2MpCShfX2lvYyktPmF0dHItPm1heGZyc2l6ZQorI2RlZmluZSBiZmFfaW9jX3J4X2JiY3JlZGl0KF9faW9jKQkoX19pb2MpLT5hdHRyLT5yeF9iYmNyZWRpdAorI2RlZmluZSBiZmFfaW9jX3NwZWVkX3N1cChfX2lvYykJXAorCUJGSV9BREFQVEVSX0dFVFAoU1BFRUQsIChfX2lvYyktPmF0dHItPmFkYXB0ZXJfcHJvcCkKKworLyoqCisgKiBJT0MgbWFpbGJveCBpbnRlcmZhY2UKKyAqLwordm9pZCBiZmFfaW9jX21ib3hfcXVldWUoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBzdHJ1Y3QgYmZhX21ib3hfY21kX3MgKmNtZCk7Cit2b2lkIGJmYV9pb2NfbWJveF9yZWdpc3RlcihzdHJ1Y3QgYmZhX2lvY19zICppb2MsCisJCWJmYV9pb2NfbWJveF9tY2Z1bmNfdCAqbWNmdW5jcyk7Cit2b2lkIGJmYV9pb2NfbWJveF9pc3Ioc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK3ZvaWQgYmZhX2lvY19tYm94X3NlbmQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB2b2lkICppb2NfbXNnLCBpbnQgbGVuKTsKK3ZvaWQgYmZhX2lvY19tc2dnZXQoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB2b2lkICptYm1zZyk7Cit2b2lkIGJmYV9pb2NfbWJveF9yZWdpc3Ioc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBlbnVtIGJmaV9tY2xhc3MgbWMsCisJCWJmYV9pb2NfbWJveF9tY2Z1bmNfdCBjYmZuLCB2b2lkICpjYmFyZyk7CisKKy8qKgorICogSU9DIGludGVyZmFjZXMKKyAqLwordm9pZCBiZmFfaW9jX2F0dGFjaChzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHZvaWQgKmJmYSwKKwkJc3RydWN0IGJmYV9pb2NfY2Jmbl9zICpjYmZuLCBzdHJ1Y3QgYmZhX3RpbWVyX21vZF9zICp0aW1lcl9tb2QsCisJCXN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QsCisJCXN0cnVjdCBiZmFfYWVuX3MgKmFlbiwgc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ20pOwordm9pZCBiZmFfaW9jX2RldGFjaChzdHJ1Y3QgYmZhX2lvY19zICppb2MpOwordm9pZCBiZmFfaW9jX3BjaV9pbml0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgc3RydWN0IGJmYV9wY2lkZXZfcyAqcGNpZGV2LAorCQllbnVtIGJmaV9tY2xhc3MgbWMpOwordTMyIGJmYV9pb2NfbWVtaW5mbyh2b2lkKTsKK3ZvaWQgYmZhX2lvY19tZW1fY2xhaW0oc3RydWN0IGJmYV9pb2NfcyAqaW9jLCAgdTggKmRtX2t2YSwgdTY0IGRtX3BhKTsKK3ZvaWQgYmZhX2lvY19lbmFibGUoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK3ZvaWQgYmZhX2lvY19kaXNhYmxlKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CitiZmFfYm9vbGVhbl90IGJmYV9pb2NfaW50eF9jbGFpbShzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworCit2b2lkIGJmYV9pb2NfYm9vdChzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHUzMiBib290X3R5cGUsIHUzMiBib290X3BhcmFtKTsKK3ZvaWQgYmZhX2lvY19pc3Ioc3RydWN0IGJmYV9pb2NfcyAqaW9jLCBzdHJ1Y3QgYmZpX21ibXNnX3MgKm1zZyk7Cit2b2lkIGJmYV9pb2NfZXJyb3JfaXNyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7Cit2b2lkIGJmYV9pb2NfaXNyX21vZGVfc2V0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgYmZhX2Jvb2xlYW5fdCBpbnR4KTsKK2JmYV9zdGF0dXNfdCBiZmFfaW9jX3BsbF9pbml0KHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CitiZmFfYm9vbGVhbl90IGJmYV9pb2NfaXNfb3BlcmF0aW9uYWwoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKK2JmYV9ib29sZWFuX3QgYmZhX2lvY19pc19kaXNhYmxlZChzdHJ1Y3QgYmZhX2lvY19zICppb2MpOworYmZhX2Jvb2xlYW5fdCBiZmFfaW9jX2Z3X21pc21hdGNoKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CitiZmFfYm9vbGVhbl90IGJmYV9pb2NfYWRhcHRlcl9pc19kaXNhYmxlZChzdHJ1Y3QgYmZhX2lvY19zICppb2MpOwordm9pZCBiZmFfaW9jX2NmZ19jb21wbGV0ZShzdHJ1Y3QgYmZhX2lvY19zICppb2MpOwordm9pZCBiZmFfaW9jX2dldF9hdHRyKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgc3RydWN0IGJmYV9pb2NfYXR0cl9zICppb2NfYXR0cik7Cit2b2lkIGJmYV9pb2NfZ2V0X2FkYXB0ZXJfYXR0cihzdHJ1Y3QgYmZhX2lvY19zICppb2MsCisJCXN0cnVjdCBiZmFfYWRhcHRlcl9hdHRyX3MgKmFkX2F0dHIpOworaW50IGJmYV9pb2NfZGVidWdfdHJjc3ooYmZhX2Jvb2xlYW5fdCBhdXRvX3JlY292ZXIpOwordm9pZCBiZmFfaW9jX2RlYnVnX21lbWNsYWltKHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgdm9pZCAqZGJnX2Z3c2F2ZSk7CitiZmFfc3RhdHVzX3QgYmZhX2lvY19kZWJ1Z19md3NhdmUoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB2b2lkICp0cmNkYXRhLAorCQlpbnQgKnRyY2xlbik7CitiZmFfc3RhdHVzX3QgYmZhX2lvY19kZWJ1Z19md3RyYyhzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHZvaWQgKnRyY2RhdGEsCisJCQkJIGludCAqdHJjbGVuKTsKK3UzMiBiZmFfaW9jX3NtZW1fcGdudW0oc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB1MzIgZm1hZGRyKTsKK3UzMiBiZmFfaW9jX3NtZW1fcGdvZmYoc3RydWN0IGJmYV9pb2NfcyAqaW9jLCB1MzIgZm1hZGRyKTsKK3ZvaWQgYmZhX2lvY19zZXRfZmNtb2RlKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7CitiZmFfYm9vbGVhbl90IGJmYV9pb2NfZ2V0X2ZjbW9kZShzdHJ1Y3QgYmZhX2lvY19zICppb2MpOwordm9pZCBiZmFfaW9jX2hiZmFpbF9yZWdpc3RlcihzdHJ1Y3QgYmZhX2lvY19zICppb2MsCisJc3RydWN0IGJmYV9pb2NfaGJmYWlsX25vdGlmeV9zICpub3RpZnkpOworCisvKgorICogYmZhIG1mZyB3d24gQVBJIGZ1bmN0aW9ucworICovCit3d25fdCBiZmFfaW9jX2dldF9wd3duKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7Cit3d25fdCBiZmFfaW9jX2dldF9ud3duKHN0cnVjdCBiZmFfaW9jX3MgKmlvYyk7Cit3d25fdCBiZmFfaW9jX2dldF93d25fbmFhNShzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHUxNiBpbnN0KTsKK21hY190IGJmYV9pb2NfZ2V0X21hYyhzdHJ1Y3QgYmZhX2lvY19zICppb2MpOwordTY0IGJmYV9pb2NfZ2V0X2FkaWQoc3RydWN0IGJmYV9pb2NfcyAqaW9jKTsKKworI2VuZGlmIC8qIF9fQkZBX0lPQ19IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW9jZmMuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvY2ZjLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTIzNTBiMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvY2ZjLmMKQEAgLTAsMCArMSw4NzIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorI2luY2x1ZGUgPGJmYV9wcml2Lmg+CisjaW5jbHVkZSA8bG9nL2JmYV9sb2dfaGFsLmg+CisjaW5jbHVkZSA8YmZpL2JmaV9ib290Lmg+CisjaW5jbHVkZSA8YmZpL2JmaV9jYnJlZy5oPgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuX2lvYy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfaW9jZmMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3BjaS5oPgorI2luY2x1ZGUgImJmYV9jYWxsYmFja19wcml2LmgiCisjaW5jbHVkZSAiYmZhZF9kcnYuaCIKKworQkZBX1RSQ19GSUxFKEhBTCwgSU9DRkMpOworCisvKioKKyAqIElPQyBsb2NhbCBkZWZpbml0aW9ucworICovCisjZGVmaW5lIEJGQV9JT0NGQ19UT1YJCTUwMDAJLyogbXNlY3MgKi8KKworZW51bSB7CisJQkZBX0lPQ0ZDX0FDVF9OT05FCT0gMCwKKwlCRkFfSU9DRkNfQUNUX0lOSVQJPSAxLAorCUJGQV9JT0NGQ19BQ1RfU1RPUAk9IDIsCisJQkZBX0lPQ0ZDX0FDVF9ESVNBQkxFCT0gMywKK307CisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgdm9pZCBiZmFfaW9jZmNfZW5hYmxlX2NiZm4odm9pZCAqYmZhX2FyZywgZW51bSBiZmFfc3RhdHVzIHN0YXR1cyk7CitzdGF0aWMgdm9pZCBiZmFfaW9jZmNfZGlzYWJsZV9jYmZuKHZvaWQgKmJmYV9hcmcpOworc3RhdGljIHZvaWQgYmZhX2lvY2ZjX2hiZmFpbF9jYmZuKHZvaWQgKmJmYV9hcmcpOworc3RhdGljIHZvaWQgYmZhX2lvY2ZjX3Jlc2V0X2NiZm4odm9pZCAqYmZhX2FyZyk7CitzdGF0aWMgdm9pZCBiZmFfaW9jZmNfc3RhdHNfY2xlYXIodm9pZCAqYmZhX2FyZyk7CitzdGF0aWMgdm9pZCBiZmFfaW9jZmNfc3RhdHNfc3dhcChzdHJ1Y3QgYmZhX2Z3X3N0YXRzX3MgKmQsCisJCQlzdHJ1Y3QgYmZhX2Z3X3N0YXRzX3MgKnMpOworc3RhdGljIHZvaWQgYmZhX2lvY2ZjX3N0YXRzX2Nscl9jYih2b2lkICpiZmFfYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKK3N0YXRpYyB2b2lkIGJmYV9pb2NmY19zdGF0c19jbHJfdGltZW91dCh2b2lkICpiZmFfYXJnKTsKK3N0YXRpYyB2b2lkIGJmYV9pb2NmY19zdGF0c19jYih2b2lkICpiZmFfYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKK3N0YXRpYyB2b2lkIGJmYV9pb2NmY19zdGF0c190aW1lb3V0KHZvaWQgKmJmYV9hcmcpOworCitzdGF0aWMgc3RydWN0IGJmYV9pb2NfY2Jmbl9zIGJmYV9pb2NmY19jYmZuOworCisvKioKKyAqICBiZmFfaW9jX3B2dCBCRkEgSU9DIHByaXZhdGUgZnVuY3Rpb25zCisgKi8KKworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19jcXNfc3ooc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKmRtX2xlbikKK3sKKwlpbnQgICAgICAgICAgICAgaSwgcGVyX3JlcXFfc3osIHBlcl9yc3BxX3N6OworCisJcGVyX3JlcXFfc3ogPSBCRkFfUk9VTkRVUCgoY2ZnLT5kcnZjZmcubnVtX3JlcXFfZWxlbXMgKiBCRklfTE1TR19TWiksCisJCQkJCQkJQkZBX0RNQV9BTElHTl9TWik7CisJcGVyX3JzcHFfc3ogPSBCRkFfUk9VTkRVUCgoY2ZnLT5kcnZjZmcubnVtX3JzcHFfZWxlbXMgKiBCRklfTE1TR19TWiksCisJCQkJCQkJQkZBX0RNQV9BTElHTl9TWik7CisKKwkvKgorCSAqIENhbGN1bGF0ZSBDUSBzaXplCisJICovCisJZm9yIChpID0gMDsgaSA8IGNmZy0+ZndjZmcubnVtX2NxczsgaSsrKSB7CisJCSpkbV9sZW4gPSAqZG1fbGVuICsgcGVyX3JlcXFfc3o7CisJCSpkbV9sZW4gPSAqZG1fbGVuICsgcGVyX3JzcHFfc3o7CisJfQorCisJLyoKKwkgKiBDYWxjdWxhdGUgU2hhZG93IENJL1BJIHNpemUKKwkgKi8KKwlmb3IgKGkgPSAwOyBpIDwgY2ZnLT5md2NmZy5udW1fY3FzOyBpKyspCisJCSpkbV9sZW4gKz0gKDIgKiBCRkFfQ0FDSEVMSU5FX1NaKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19md19jZmdfc3ooc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKmRtX2xlbikKK3sKKwkqZG1fbGVuICs9CisJCUJGQV9ST1VORFVQKHNpemVvZihzdHJ1Y3QgYmZpX2lvY2ZjX2NmZ19zKSwgQkZBX0NBQ0hFTElORV9TWik7CisJKmRtX2xlbiArPQorCQlCRkFfUk9VTkRVUChzaXplb2Yoc3RydWN0IGJmaV9pb2NmY19jZmdyc3BfcyksCisJCQkgICAgQkZBX0NBQ0hFTElORV9TWik7CisJKmRtX2xlbiArPSBCRkFfUk9VTkRVUChzaXplb2Yoc3RydWN0IGJmYV9md19zdGF0c19zKSwgQkZBX0NBQ0hFTElORV9TWik7Cit9CisKKy8qKgorICogVXNlIHRoZSBNYWlsYm94IGludGVyZmFjZSB0byBzZW5kIEJGSV9JT0NGQ19IMklfQ0ZHX1JFUQorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX3NlbmRfY2ZnKHZvaWQgKmJmYV9hcmcpCit7CisJc3RydWN0IGJmYV9zICpiZmEgPSBiZmFfYXJnOworCXN0cnVjdCBiZmFfaW9jZmNfcyAqaW9jZmMgPSAmYmZhLT5pb2NmYzsKKwlzdHJ1Y3QgYmZpX2lvY2ZjX2NmZ19yZXFfcyBjZmdfcmVxOworCXN0cnVjdCBiZmlfaW9jZmNfY2ZnX3MgKmNmZ19pbmZvID0gaW9jZmMtPmNmZ2luZm87CisJc3RydWN0IGJmYV9pb2NmY19jZmdfcyAgKmNmZyA9ICZpb2NmYy0+Y2ZnOworCWludCAgICAgICAgICAgICBpOworCisJYmZhX2Fzc2VydChjZmctPmZ3Y2ZnLm51bV9jcXMgPD0gQkZJX0lPQ19NQVhfQ1FTKTsKKwliZmFfdHJjKGJmYSwgY2ZnLT5md2NmZy5udW1fY3FzKTsKKworCWlvY2ZjLT5jZmdkb25lID0gQkZBX0ZBTFNFOworCWJmYV9pb2NmY19yZXNldF9xdWV1ZXMoYmZhKTsKKworCS8qKgorCSAqIGluaXRpYWxpemUgSU9DIGNvbmZpZ3VyYXRpb24gaW5mbworCSAqLworCWNmZ19pbmZvLT5lbmRpYW5fc2lnID0gQkZJX0lPQ19FTkRJQU5fU0lHOworCWNmZ19pbmZvLT5udW1fY3FzID0gY2ZnLT5md2NmZy5udW1fY3FzOworCisJYmZhX2RtYV9iZV9hZGRyX3NldChjZmdfaW5mby0+Y2ZncnNwX2FkZHIsIGlvY2ZjLT5jZmdyc3BfZG1hLnBhKTsKKwliZmFfZG1hX2JlX2FkZHJfc2V0KGNmZ19pbmZvLT5zdGF0c19hZGRyLCBpb2NmYy0+c3RhdHNfcGEpOworCisJLyoqCisJICogZG1hIG1hcCBSRVEgYW5kIFJTUCBjaXJjdWxhciBxdWV1ZXMgYW5kIHNoYWRvdyBwb2ludGVycworCSAqLworCWZvciAoaSA9IDA7IGkgPCBjZmctPmZ3Y2ZnLm51bV9jcXM7IGkrKykgeworCQliZmFfZG1hX2JlX2FkZHJfc2V0KGNmZ19pbmZvLT5yZXFfY3FfYmFbaV0sCisJCQkJICAgICAgIGlvY2ZjLT5yZXFfY3FfYmFbaV0ucGEpOworCQliZmFfZG1hX2JlX2FkZHJfc2V0KGNmZ19pbmZvLT5yZXFfc2hhZG93X2NpW2ldLAorCQkJCSAgICAgICBpb2NmYy0+cmVxX2NxX3NoYWRvd19jaVtpXS5wYSk7CisJCWNmZ19pbmZvLT5yZXFfY3FfZWxlbXNbaV0gPQorCQkJYmZhX29zX2h0b25zKGNmZy0+ZHJ2Y2ZnLm51bV9yZXFxX2VsZW1zKTsKKworCQliZmFfZG1hX2JlX2FkZHJfc2V0KGNmZ19pbmZvLT5yc3BfY3FfYmFbaV0sCisJCQkJICAgICAgIGlvY2ZjLT5yc3BfY3FfYmFbaV0ucGEpOworCQliZmFfZG1hX2JlX2FkZHJfc2V0KGNmZ19pbmZvLT5yc3Bfc2hhZG93X3BpW2ldLAorCQkJCSAgICAgICBpb2NmYy0+cnNwX2NxX3NoYWRvd19waVtpXS5wYSk7CisJCWNmZ19pbmZvLT5yc3BfY3FfZWxlbXNbaV0gPQorCQkJYmZhX29zX2h0b25zKGNmZy0+ZHJ2Y2ZnLm51bV9yc3BxX2VsZW1zKTsKKwl9CisKKwkvKioKKwkgKiBkbWEgbWFwIElPQyBjb25maWd1cmF0aW9uIGl0c2VsZgorCSAqLworCWJmaV9oMmlfc2V0KGNmZ19yZXEubWgsIEJGSV9NQ19JT0NGQywgQkZJX0lPQ0ZDX0gySV9DRkdfUkVRLAorCQkJYmZhX2xwdWlkKGJmYSkpOworCWJmYV9kbWFfYmVfYWRkcl9zZXQoY2ZnX3JlcS5pb2NfY2ZnX2RtYV9hZGRyLCBpb2NmYy0+Y2ZnX2luZm8ucGEpOworCisJYmZhX2lvY19tYm94X3NlbmQoJmJmYS0+aW9jLCAmY2ZnX3JlcSwKKwkJCXNpemVvZihzdHJ1Y3QgYmZpX2lvY2ZjX2NmZ19yZXFfcykpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX2luaXRfbWVtKHN0cnVjdCBiZmFfcyAqYmZhLCB2b2lkICpiZmFkLCBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCSAgICBzdHJ1Y3QgYmZhX3BjaWRldl9zICpwY2lkZXYpCit7CisJc3RydWN0IGJmYV9pb2NmY19zCSppb2NmYyA9ICZiZmEtPmlvY2ZjOworCisJYmZhLT5iZmFkID0gYmZhZDsKKwlpb2NmYy0+YmZhID0gYmZhOworCWlvY2ZjLT5hY3Rpb24gPSBCRkFfSU9DRkNfQUNUX05PTkU7CisKKwliZmFfb3NfYXNzaWduKGlvY2ZjLT5jZmcsICpjZmcpOworCisJLyoqCisJICogSW5pdGlhbGl6ZSBjaGlwIHNwZWNpZmljIGhhbmRsZXJzLgorCSAqLworCWlmIChiZmFfaW9jX2RldmlkKCZiZmEtPmlvYykgPT0gQkZBX1BDSV9ERVZJQ0VfSURfQ1QpIHsKKwkJaW9jZmMtPmh3aWYuaHdfcmVnaW5pdCA9IGJmYV9od2N0X3JlZ2luaXQ7CisJCWlvY2ZjLT5od2lmLmh3X3JzcHFfYWNrID0gYmZhX2h3Y3RfcnNwcV9hY2s7CisJCWlvY2ZjLT5od2lmLmh3X21zaXhfaW5pdCA9IGJmYV9od2N0X21zaXhfaW5pdDsKKwkJaW9jZmMtPmh3aWYuaHdfbXNpeF9pbnN0YWxsID0gYmZhX2h3Y3RfbXNpeF9pbnN0YWxsOworCQlpb2NmYy0+aHdpZi5od19tc2l4X3VuaW5zdGFsbCA9IGJmYV9od2N0X21zaXhfdW5pbnN0YWxsOworCQlpb2NmYy0+aHdpZi5od19pc3JfbW9kZV9zZXQgPSBiZmFfaHdjdF9pc3JfbW9kZV9zZXQ7CisJCWlvY2ZjLT5od2lmLmh3X21zaXhfZ2V0dmVjcyA9IGJmYV9od2N0X21zaXhfZ2V0dmVjczsKKwl9IGVsc2UgeworCQlpb2NmYy0+aHdpZi5od19yZWdpbml0ID0gYmZhX2h3Y2JfcmVnaW5pdDsKKwkJaW9jZmMtPmh3aWYuaHdfcnNwcV9hY2sgPSBiZmFfaHdjYl9yc3BxX2FjazsKKwkJaW9jZmMtPmh3aWYuaHdfbXNpeF9pbml0ID0gYmZhX2h3Y2JfbXNpeF9pbml0OworCQlpb2NmYy0+aHdpZi5od19tc2l4X2luc3RhbGwgPSBiZmFfaHdjYl9tc2l4X2luc3RhbGw7CisJCWlvY2ZjLT5od2lmLmh3X21zaXhfdW5pbnN0YWxsID0gYmZhX2h3Y2JfbXNpeF91bmluc3RhbGw7CisJCWlvY2ZjLT5od2lmLmh3X2lzcl9tb2RlX3NldCA9IGJmYV9od2NiX2lzcl9tb2RlX3NldDsKKwkJaW9jZmMtPmh3aWYuaHdfbXNpeF9nZXR2ZWNzID0gYmZhX2h3Y2JfbXNpeF9nZXR2ZWNzOworCX0KKworCWlvY2ZjLT5od2lmLmh3X3JlZ2luaXQoYmZhKTsKKwliZmEtPm1zaXgubnZlY3MgPSAwOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX21lbV9jbGFpbShzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLAorCQkgICAgICBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbykKK3sKKwl1OCAgICAgICAgKmRtX2t2YTsKKwl1NjQgICAgICAgIGRtX3BhOworCWludCAgICAgICAgICAgICBpLCBwZXJfcmVxcV9zeiwgcGVyX3JzcHFfc3o7CisJc3RydWN0IGJmYV9pb2NmY19zICAqaW9jZmMgPSAmYmZhLT5pb2NmYzsKKwlpbnQJCWRiZ3N6OworCisJZG1fa3ZhID0gYmZhX21lbWluZm9fZG1hX3ZpcnQobWVtaW5mbyk7CisJZG1fcGEgPSBiZmFfbWVtaW5mb19kbWFfcGh5cyhtZW1pbmZvKTsKKworCS8qCisJICogRmlyc3QgYWxsb2NhdGUgZG1hIG1lbW9yeSBmb3IgSU9DLgorCSAqLworCWJmYV9pb2NfbWVtX2NsYWltKCZiZmEtPmlvYywgZG1fa3ZhLCBkbV9wYSk7CisJZG1fa3ZhICs9IGJmYV9pb2NfbWVtaW5mbygpOworCWRtX3BhICArPSBiZmFfaW9jX21lbWluZm8oKTsKKworCS8qCisJICogQ2xhaW0gRE1BLWFibGUgbWVtb3J5IGZvciB0aGUgcmVxdWVzdC9yZXNwb25zZSBxdWV1ZXMgYW5kIGZvciBzaGFkb3cKKwkgKiBjaS9waSByZWdpc3RlcnMKKwkgKi8KKwlwZXJfcmVxcV9zeiA9IEJGQV9ST1VORFVQKChjZmctPmRydmNmZy5udW1fcmVxcV9lbGVtcyAqIEJGSV9MTVNHX1NaKSwKKwkJCQkJCQlCRkFfRE1BX0FMSUdOX1NaKTsKKwlwZXJfcnNwcV9zeiA9IEJGQV9ST1VORFVQKChjZmctPmRydmNmZy5udW1fcnNwcV9lbGVtcyAqIEJGSV9MTVNHX1NaKSwKKwkJCQkJCQlCRkFfRE1BX0FMSUdOX1NaKTsKKworCWZvciAoaSA9IDA7IGkgPCBjZmctPmZ3Y2ZnLm51bV9jcXM7IGkrKykgeworCQlpb2NmYy0+cmVxX2NxX2JhW2ldLmt2YSA9IGRtX2t2YTsKKwkJaW9jZmMtPnJlcV9jcV9iYVtpXS5wYSA9IGRtX3BhOworCQliZmFfb3NfbWVtc2V0KGRtX2t2YSwgMCwgcGVyX3JlcXFfc3opOworCQlkbV9rdmEgKz0gcGVyX3JlcXFfc3o7CisJCWRtX3BhICs9IHBlcl9yZXFxX3N6OworCisJCWlvY2ZjLT5yc3BfY3FfYmFbaV0ua3ZhID0gZG1fa3ZhOworCQlpb2NmYy0+cnNwX2NxX2JhW2ldLnBhID0gZG1fcGE7CisJCWJmYV9vc19tZW1zZXQoZG1fa3ZhLCAwLCBwZXJfcnNwcV9zeik7CisJCWRtX2t2YSArPSBwZXJfcnNwcV9zejsKKwkJZG1fcGEgKz0gcGVyX3JzcHFfc3o7CisJfQorCisJZm9yIChpID0gMDsgaSA8IGNmZy0+ZndjZmcubnVtX2NxczsgaSsrKSB7CisJCWlvY2ZjLT5yZXFfY3Ffc2hhZG93X2NpW2ldLmt2YSA9IGRtX2t2YTsKKwkJaW9jZmMtPnJlcV9jcV9zaGFkb3dfY2lbaV0ucGEgPSBkbV9wYTsKKwkJZG1fa3ZhICs9IEJGQV9DQUNIRUxJTkVfU1o7CisJCWRtX3BhICs9IEJGQV9DQUNIRUxJTkVfU1o7CisKKwkJaW9jZmMtPnJzcF9jcV9zaGFkb3dfcGlbaV0ua3ZhID0gZG1fa3ZhOworCQlpb2NmYy0+cnNwX2NxX3NoYWRvd19waVtpXS5wYSA9IGRtX3BhOworCQlkbV9rdmEgKz0gQkZBX0NBQ0hFTElORV9TWjsKKwkJZG1fcGEgKz0gQkZBX0NBQ0hFTElORV9TWjsKKwl9CisKKwkvKgorCSAqIENsYWltIERNQS1hYmxlIG1lbW9yeSBmb3IgdGhlIGNvbmZpZyBpbmZvIHBhZ2UKKwkgKi8KKwliZmEtPmlvY2ZjLmNmZ19pbmZvLmt2YSA9IGRtX2t2YTsKKwliZmEtPmlvY2ZjLmNmZ19pbmZvLnBhID0gZG1fcGE7CisJYmZhLT5pb2NmYy5jZmdpbmZvID0gKHN0cnVjdCBiZmlfaW9jZmNfY2ZnX3MgKikgZG1fa3ZhOworCWRtX2t2YSArPSBCRkFfUk9VTkRVUChzaXplb2Yoc3RydWN0IGJmaV9pb2NmY19jZmdfcyksIEJGQV9DQUNIRUxJTkVfU1opOworCWRtX3BhICs9IEJGQV9ST1VORFVQKHNpemVvZihzdHJ1Y3QgYmZpX2lvY2ZjX2NmZ19zKSwgQkZBX0NBQ0hFTElORV9TWik7CisKKwkvKgorCSAqIENsYWltIERNQS1hYmxlIG1lbW9yeSBmb3IgdGhlIGNvbmZpZyByZXNwb25zZQorCSAqLworCWJmYS0+aW9jZmMuY2ZncnNwX2RtYS5rdmEgPSBkbV9rdmE7CisJYmZhLT5pb2NmYy5jZmdyc3BfZG1hLnBhID0gZG1fcGE7CisJYmZhLT5pb2NmYy5jZmdyc3AgPSAoc3RydWN0IGJmaV9pb2NmY19jZmdyc3BfcyAqKSBkbV9rdmE7CisKKwlkbV9rdmEgKz0KKwkJQkZBX1JPVU5EVVAoc2l6ZW9mKHN0cnVjdCBiZmlfaW9jZmNfY2ZncnNwX3MpLAorCQkJICAgIEJGQV9DQUNIRUxJTkVfU1opOworCWRtX3BhICs9IEJGQV9ST1VORFVQKHNpemVvZihzdHJ1Y3QgYmZpX2lvY2ZjX2NmZ3JzcF9zKSwKKwkJCSAgICAgQkZBX0NBQ0hFTElORV9TWik7CisKKwkvKgorCSAqIENsYWltIERNQS1hYmxlIG1lbW9yeSBmb3IgaW9jZmMgc3RhdHMKKwkgKi8KKwliZmEtPmlvY2ZjLnN0YXRzX2t2YSA9IGRtX2t2YTsKKwliZmEtPmlvY2ZjLnN0YXRzX3BhID0gZG1fcGE7CisJYmZhLT5pb2NmYy5md19zdGF0cyA9IChzdHJ1Y3QgYmZhX2Z3X3N0YXRzX3MgKikgZG1fa3ZhOworCWRtX2t2YSArPSBCRkFfUk9VTkRVUChzaXplb2Yoc3RydWN0IGJmYV9md19zdGF0c19zKSwgQkZBX0NBQ0hFTElORV9TWik7CisJZG1fcGEgKz0gQkZBX1JPVU5EVVAoc2l6ZW9mKHN0cnVjdCBiZmFfZndfc3RhdHNfcyksIEJGQV9DQUNIRUxJTkVfU1opOworCisJYmZhX21lbWluZm9fZG1hX3ZpcnQobWVtaW5mbykgPSBkbV9rdmE7CisJYmZhX21lbWluZm9fZG1hX3BoeXMobWVtaW5mbykgPSBkbV9wYTsKKworCWRiZ3N6ID0gYmZhX2lvY19kZWJ1Z190cmNzeihiZmFfYXV0b19yZWNvdmVyKTsKKwlpZiAoZGJnc3ogPiAwKSB7CisJCWJmYV9pb2NfZGVidWdfbWVtY2xhaW0oJmJmYS0+aW9jLCBiZmFfbWVtaW5mb19rdmEobWVtaW5mbykpOworCQliZmFfbWVtaW5mb19rdmEobWVtaW5mbykgKz0gZGJnc3o7CisJfQorfQorCisvKioKKyAqIEJGQSBzdWJtb2R1bGVzIGluaXRpYWxpemF0aW9uIGNvbXBsZXRpb24gbm90aWZpY2F0aW9uLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX2luaXRkb25lX3N1Ym1vZChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlpbnQgICAgICAgICAgICAgaTsKKworCWZvciAoaSA9IDA7IGhhbF9tb2RzW2ldOyBpKyspCisJCWhhbF9tb2RzW2ldLT5pbml0ZG9uZShiZmEpOworfQorCisvKioKKyAqIFN0YXJ0IEJGQSBzdWJtb2R1bGVzLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX3N0YXJ0X3N1Ym1vZChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlpbnQgICAgICAgICAgICAgaTsKKworCWJmYS0+cm1lX3Byb2Nlc3MgPSBCRkFfVFJVRTsKKworCWZvciAoaSA9IDA7IGhhbF9tb2RzW2ldOyBpKyspCisJCWhhbF9tb2RzW2ldLT5zdGFydChiZmEpOworfQorCisvKioKKyAqIERpc2FibGUgQkZBIHN1Ym1vZHVsZXMuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jZmNfZGlzYWJsZV9zdWJtb2Qoc3RydWN0IGJmYV9zICpiZmEpCit7CisJaW50ICAgICAgICAgICAgIGk7CisKKwlmb3IgKGkgPSAwOyBoYWxfbW9kc1tpXTsgaSsrKQorCQloYWxfbW9kc1tpXS0+aW9jZGlzYWJsZShiZmEpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX2luaXRfY2Iodm9pZCAqYmZhX2FyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSkKK3sKKwlzdHJ1Y3QgYmZhX3MJKmJmYSA9IGJmYV9hcmc7CisKKwlpZiAoY29tcGxldGUpIHsKKwkJaWYgKGJmYS0+aW9jZmMuY2ZnZG9uZSkKKwkJCWJmYV9jYl9pbml0KGJmYS0+YmZhZCwgQkZBX1NUQVRVU19PSyk7CisJCWVsc2UKKwkJCWJmYV9jYl9pbml0KGJmYS0+YmZhZCwgQkZBX1NUQVRVU19GQUlMRUQpOworCX0gZWxzZQorCQliZmEtPmlvY2ZjLmFjdGlvbiA9IEJGQV9JT0NGQ19BQ1RfTk9ORTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19zdG9wX2NiKHZvaWQgKmJmYV9hcmcsIGJmYV9ib29sZWFuX3QgY29tcGwpCit7CisJc3RydWN0IGJmYV9zICAqYmZhID0gYmZhX2FyZzsKKwlzdHJ1Y3QgYmZhZF9zICpiZmFkID0gYmZhLT5iZmFkOworCisJaWYgKGNvbXBsKQorCQljb21wbGV0ZSgmYmZhZC0+Y29tcCk7CisKKwllbHNlCisJCWJmYS0+aW9jZmMuYWN0aW9uID0gQkZBX0lPQ0ZDX0FDVF9OT05FOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX2Rpc2FibGVfY2Iodm9pZCAqYmZhX2FyZywgYmZhX2Jvb2xlYW5fdCBjb21wbCkKK3sKKwlzdHJ1Y3QgYmZhX3MgICpiZmEgPSBiZmFfYXJnOworCXN0cnVjdCBiZmFkX3MgKmJmYWQgPSBiZmEtPmJmYWQ7CisKKwlpZiAoY29tcGwpCisJCWNvbXBsZXRlKCZiZmFkLT5kaXNhYmxlX2NvbXApOworfQorCisvKioKKyAqIFVwZGF0ZSBCRkEgY29uZmlndXJhdGlvbiBmcm9tIGZpcm13YXJlIGNvbmZpZ3VyYXRpb24uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jZmNfY2ZncnNwKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfaW9jZmNfcwkJKmlvY2ZjCSA9ICZiZmEtPmlvY2ZjOworCXN0cnVjdCBiZmlfaW9jZmNfY2ZncnNwX3MJKmNmZ3JzcCAgPSBpb2NmYy0+Y2ZncnNwOworCXN0cnVjdCBiZmFfaW9jZmNfZndjZmdfcwkqZndjZmcgICA9ICZjZmdyc3AtPmZ3Y2ZnOworCXN0cnVjdCBiZmlfaW9jZmNfY2ZnX3MgCQkqY2ZnaW5mbyA9IGlvY2ZjLT5jZmdpbmZvOworCisJZndjZmctPm51bV9jcXMgICAgICAgID0gZndjZmctPm51bV9jcXM7CisJZndjZmctPm51bV9pb2ltX3JlcXMgID0gYmZhX29zX250b2hzKGZ3Y2ZnLT5udW1faW9pbV9yZXFzKTsKKwlmd2NmZy0+bnVtX3Rza2ltX3JlcXMgPSBiZmFfb3NfbnRvaHMoZndjZmctPm51bV90c2tpbV9yZXFzKTsKKwlmd2NmZy0+bnVtX2ZjeHBfcmVxcyAgPSBiZmFfb3NfbnRvaHMoZndjZmctPm51bV9mY3hwX3JlcXMpOworCWZ3Y2ZnLT5udW1fdWZfYnVmcyAgICA9IGJmYV9vc19udG9ocyhmd2NmZy0+bnVtX3VmX2J1ZnMpOworCWZ3Y2ZnLT5udW1fcnBvcnRzICAgICA9IGJmYV9vc19udG9ocyhmd2NmZy0+bnVtX3Jwb3J0cyk7CisKKwljZmdpbmZvLT5pbnRyX2F0dHIuY29hbGVzY2UgPSBjZmdyc3AtPmludHJfYXR0ci5jb2FsZXNjZTsKKwljZmdpbmZvLT5pbnRyX2F0dHIuZGVsYXkgICAgPSBiZmFfb3NfbnRvaHMoY2ZncnNwLT5pbnRyX2F0dHIuZGVsYXkpOworCWNmZ2luZm8tPmludHJfYXR0ci5sYXRlbmN5ICA9IGJmYV9vc19udG9ocyhjZmdyc3AtPmludHJfYXR0ci5sYXRlbmN5KTsKKworCWlvY2ZjLT5jZmdkb25lID0gQkZBX1RSVUU7CisKKwkvKioKKwkgKiBDb25maWd1cmF0aW9uIGlzIGNvbXBsZXRlIC0gaW5pdGlhbGl6ZS9zdGFydCBzdWJtb2R1bGVzCisJICovCisJaWYgKGlvY2ZjLT5hY3Rpb24gPT0gQkZBX0lPQ0ZDX0FDVF9JTklUKQorCQliZmFfY2JfcXVldWUoYmZhLCAmaW9jZmMtPmluaXRfaGNiX3FlLCBiZmFfaW9jZmNfaW5pdF9jYiwgYmZhKTsKKwllbHNlCisJCWJmYV9pb2NmY19zdGFydF9zdWJtb2QoYmZhKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19zdGF0c19jbGVhcih2b2lkICpiZmFfYXJnKQoreworCXN0cnVjdCBiZmFfcwkJKmJmYSA9IGJmYV9hcmc7CisJc3RydWN0IGJmYV9pb2NmY19zCSppb2NmYyA9ICZiZmEtPmlvY2ZjOworCXN0cnVjdCBiZmlfaW9jZmNfc3RhdHNfcmVxX3Mgc3RhdHNfcmVxOworCisJYmZhX3RpbWVyX3N0YXJ0KGJmYSwgJmlvY2ZjLT5zdGF0c190aW1lciwKKwkJCSAgICBiZmFfaW9jZmNfc3RhdHNfY2xyX3RpbWVvdXQsIGJmYSwKKwkJCSAgICBCRkFfSU9DRkNfVE9WKTsKKworCWJmaV9oMmlfc2V0KHN0YXRzX3JlcS5taCwgQkZJX01DX0lPQ0ZDLCBCRklfSU9DRkNfSDJJX0NMRUFSX1NUQVRTX1JFUSwKKwkJYmZhX2xwdWlkKGJmYSkpOworCWJmYV9pb2NfbWJveF9zZW5kKCZiZmEtPmlvYywgJnN0YXRzX3JlcSwKKwkJc2l6ZW9mKHN0cnVjdCBiZmlfaW9jZmNfc3RhdHNfcmVxX3MpKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19zdGF0c19zd2FwKHN0cnVjdCBiZmFfZndfc3RhdHNfcyAqZCwgc3RydWN0IGJmYV9md19zdGF0c19zICpzKQoreworCXUzMiAgICAgICAqZGlwID0gKHUzMiAqKSBkOworCXUzMiAgICAgICAqc2lwID0gKHUzMiAqKSBzOworCWludCAgICAgICAgICAgICBpOworCisJZm9yIChpID0gMDsgaSA8IChzaXplb2Yoc3RydWN0IGJmYV9md19zdGF0c19zKSAvIHNpemVvZih1MzIpKTsgaSsrKQorCQlkaXBbaV0gPSBiZmFfb3NfbnRvaGwoc2lwW2ldKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19zdGF0c19jbHJfY2Iodm9pZCAqYmZhX2FyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSkKK3sKKwlzdHJ1Y3QgYmZhX3MgKmJmYSA9IGJmYV9hcmc7CisJc3RydWN0IGJmYV9pb2NmY19zICppb2NmYyA9ICZiZmEtPmlvY2ZjOworCisJaWYgKGNvbXBsZXRlKSB7CisJCWJmYV9pb2NfY2xyX3N0YXRzKCZiZmEtPmlvYyk7CisJCWlvY2ZjLT5zdGF0c19jYmZuKGlvY2ZjLT5zdGF0c19jYmFyZywgaW9jZmMtPnN0YXRzX3N0YXR1cyk7CisJfSBlbHNlIHsKKwkJaW9jZmMtPnN0YXRzX2J1c3kgPSBCRkFfRkFMU0U7CisJCWlvY2ZjLT5zdGF0c19zdGF0dXMgPSBCRkFfU1RBVFVTX09LOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19zdGF0c19jbHJfdGltZW91dCh2b2lkICpiZmFfYXJnKQoreworCXN0cnVjdCBiZmFfcwkJKmJmYSA9IGJmYV9hcmc7CisJc3RydWN0IGJmYV9pb2NmY19zCSppb2NmYyA9ICZiZmEtPmlvY2ZjOworCisJYmZhX3RyYyhiZmEsIDApOworCisJaW9jZmMtPnN0YXRzX3N0YXR1cyA9IEJGQV9TVEFUVVNfRVRJTUVSOworCWJmYV9jYl9xdWV1ZShiZmEsICZpb2NmYy0+c3RhdHNfaGNiX3FlLCBiZmFfaW9jZmNfc3RhdHNfY2xyX2NiLCBiZmEpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX3N0YXRzX2NiKHZvaWQgKmJmYV9hcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpCit7CisJc3RydWN0IGJmYV9zCQkqYmZhID0gYmZhX2FyZzsKKwlzdHJ1Y3QgYmZhX2lvY2ZjX3MJKmlvY2ZjID0gJmJmYS0+aW9jZmM7CisKKwlpZiAoY29tcGxldGUpIHsKKwkJaWYgKGlvY2ZjLT5zdGF0c19zdGF0dXMgPT0gQkZBX1NUQVRVU19PSykgeworCQkJYmZhX29zX21lbXNldChpb2NmYy0+c3RhdHNfcmV0LCAwLAorCQkJCXNpemVvZigqaW9jZmMtPnN0YXRzX3JldCkpOworCQkJYmZhX2lvY2ZjX3N0YXRzX3N3YXAoJmlvY2ZjLT5zdGF0c19yZXQtPmZ3X3N0YXRzLAorCQkJCWlvY2ZjLT5md19zdGF0cyk7CisJCX0KKwkJaW9jZmMtPnN0YXRzX2NiZm4oaW9jZmMtPnN0YXRzX2NiYXJnLCBpb2NmYy0+c3RhdHNfc3RhdHVzKTsKKwl9IGVsc2UgeworCQlpb2NmYy0+c3RhdHNfYnVzeSA9IEJGQV9GQUxTRTsKKwkJaW9jZmMtPnN0YXRzX3N0YXR1cyA9IEJGQV9TVEFUVVNfT0s7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX3N0YXRzX3RpbWVvdXQodm9pZCAqYmZhX2FyZykKK3sKKwlzdHJ1Y3QgYmZhX3MJCSpiZmEgPSBiZmFfYXJnOworCXN0cnVjdCBiZmFfaW9jZmNfcwkqaW9jZmMgPSAmYmZhLT5pb2NmYzsKKworCWJmYV90cmMoYmZhLCAwKTsKKworCWlvY2ZjLT5zdGF0c19zdGF0dXMgPSBCRkFfU1RBVFVTX0VUSU1FUjsKKwliZmFfY2JfcXVldWUoYmZhLCAmaW9jZmMtPnN0YXRzX2hjYl9xZSwgYmZhX2lvY2ZjX3N0YXRzX2NiLCBiZmEpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvY2ZjX3N0YXRzX3F1ZXJ5KHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfaW9jZmNfcwkqaW9jZmMgPSAmYmZhLT5pb2NmYzsKKwlzdHJ1Y3QgYmZpX2lvY2ZjX3N0YXRzX3JlcV9zIHN0YXRzX3JlcTsKKworCWJmYV90aW1lcl9zdGFydChiZmEsICZpb2NmYy0+c3RhdHNfdGltZXIsCisJCQkgICAgYmZhX2lvY2ZjX3N0YXRzX3RpbWVvdXQsIGJmYSwgQkZBX0lPQ0ZDX1RPVik7CisKKwliZmlfaDJpX3NldChzdGF0c19yZXEubWgsIEJGSV9NQ19JT0NGQywgQkZJX0lPQ0ZDX0gySV9HRVRfU1RBVFNfUkVRLAorCQkJYmZhX2xwdWlkKGJmYSkpOworCWJmYV9pb2NfbWJveF9zZW5kKCZiZmEtPmlvYywgJnN0YXRzX3JlcSwKKwkJc2l6ZW9mKHN0cnVjdCBiZmlfaW9jZmNfc3RhdHNfcmVxX3MpKTsKK30KKwordm9pZAorYmZhX2lvY2ZjX3Jlc2V0X3F1ZXVlcyhzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlpbnQgICAgICAgICAgICAgcTsKKworCWZvciAocSA9IDA7IHEgPCBCRklfSU9DX01BWF9DUVM7IHErKykgeworCQliZmFfcmVxcV9jaShiZmEsIHEpID0gMDsKKwkJYmZhX3JlcXFfcGkoYmZhLCBxKSA9IDA7CisJCWJmYV9yc3BxX2NpKGJmYSwgcSkgPSAwOworCQliZmFfcnNwcV9waShiZmEsIHEpID0gMDsKKwl9Cit9CisKKy8qKgorICogSU9DIGVuYWJsZSByZXF1ZXN0IGlzIGNvbXBsZXRlCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jZmNfZW5hYmxlX2NiZm4odm9pZCAqYmZhX2FyZywgZW51bSBiZmFfc3RhdHVzIHN0YXR1cykKK3sKKwlzdHJ1Y3QgYmZhX3MJKmJmYSA9IGJmYV9hcmc7CisKKwlpZiAoc3RhdHVzICE9IEJGQV9TVEFUVVNfT0spIHsKKwkJYmZhX2lzcl9kaXNhYmxlKGJmYSk7CisJCWlmIChiZmEtPmlvY2ZjLmFjdGlvbiA9PSBCRkFfSU9DRkNfQUNUX0lOSVQpCisJCQliZmFfY2JfcXVldWUoYmZhLCAmYmZhLT5pb2NmYy5pbml0X2hjYl9xZSwKKwkJCQkgICAgIGJmYV9pb2NmY19pbml0X2NiLCBiZmEpOworCQlyZXR1cm47CisJfQorCisJYmZhX2lvY2ZjX2luaXRkb25lX3N1Ym1vZChiZmEpOworCWJmYV9pb2NmY19zZW5kX2NmZyhiZmEpOworfQorCisvKioKKyAqIElPQyBkaXNhYmxlIHJlcXVlc3QgaXMgY29tcGxldGUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2NmY19kaXNhYmxlX2NiZm4odm9pZCAqYmZhX2FyZykKK3sKKwlzdHJ1Y3QgYmZhX3MJKmJmYSA9IGJmYV9hcmc7CisKKwliZmFfaXNyX2Rpc2FibGUoYmZhKTsKKwliZmFfaW9jZmNfZGlzYWJsZV9zdWJtb2QoYmZhKTsKKworCWlmIChiZmEtPmlvY2ZjLmFjdGlvbiA9PSBCRkFfSU9DRkNfQUNUX1NUT1ApCisJCWJmYV9jYl9xdWV1ZShiZmEsICZiZmEtPmlvY2ZjLnN0b3BfaGNiX3FlLCBiZmFfaW9jZmNfc3RvcF9jYiwKKwkJCSAgICAgYmZhKTsKKwllbHNlIHsKKwkJYmZhX2Fzc2VydChiZmEtPmlvY2ZjLmFjdGlvbiA9PSBCRkFfSU9DRkNfQUNUX0RJU0FCTEUpOworCQliZmFfY2JfcXVldWUoYmZhLCAmYmZhLT5pb2NmYy5kaXNfaGNiX3FlLCBiZmFfaW9jZmNfZGlzYWJsZV9jYiwKKwkJCSAgICAgYmZhKTsKKwl9Cit9CisKKy8qKgorICogTm90aWZ5IHN1Yi1tb2R1bGVzIG9mIGhhcmR3YXJlIGZhaWx1cmUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jZmNfaGJmYWlsX2NiZm4odm9pZCAqYmZhX2FyZykKK3sKKwlzdHJ1Y3QgYmZhX3MJKmJmYSA9IGJmYV9hcmc7CisKKwliZmEtPnJtZV9wcm9jZXNzID0gQkZBX0ZBTFNFOworCisJYmZhX2lzcl9kaXNhYmxlKGJmYSk7CisJYmZhX2lvY2ZjX2Rpc2FibGVfc3VibW9kKGJmYSk7CisKKwlpZiAoYmZhLT5pb2NmYy5hY3Rpb24gPT0gQkZBX0lPQ0ZDX0FDVF9JTklUKQorCQliZmFfY2JfcXVldWUoYmZhLCAmYmZhLT5pb2NmYy5pbml0X2hjYl9xZSwgYmZhX2lvY2ZjX2luaXRfY2IsCisJCQkgICAgIGJmYSk7Cit9CisKKy8qKgorICogQWN0aW9ucyBvbiBjaGlwLXJlc2V0IGNvbXBsZXRpb24uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9jZmNfcmVzZXRfY2Jmbih2b2lkICpiZmFfYXJnKQoreworCXN0cnVjdCBiZmFfcwkqYmZhID0gYmZhX2FyZzsKKworCWJmYV9pb2NmY19yZXNldF9xdWV1ZXMoYmZhKTsKKwliZmFfaXNyX2VuYWJsZShiZmEpOworfQorCisKKworLyoqCisgKiAgYmZhX2lvY19wdWJsaWMKKyAqLworCisvKioKKyAqIFF1ZXJ5IElPQyBtZW1vcnkgcmVxdWlyZW1lbnQgaW5mb3JtYXRpb24uCisgKi8KK3ZvaWQKK2JmYV9pb2NmY19tZW1pbmZvKHN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmNmZywgdTMyICprbV9sZW4sCisJCXUzMiAqZG1fbGVuKQoreworCS8qIGRtYSBtZW1vcnkgZm9yIElPQyAqLworCSpkbV9sZW4gKz0gYmZhX2lvY19tZW1pbmZvKCk7CisKKwliZmFfaW9jZmNfZndfY2ZnX3N6KGNmZywgZG1fbGVuKTsKKwliZmFfaW9jZmNfY3FzX3N6KGNmZywgZG1fbGVuKTsKKwkqa21fbGVuICs9IGJmYV9pb2NfZGVidWdfdHJjc3ooYmZhX2F1dG9fcmVjb3Zlcik7Cit9CisKKy8qKgorICogUXVlcnkgSU9DIG1lbW9yeSByZXF1aXJlbWVudCBpbmZvcm1hdGlvbi4KKyAqLwordm9pZAorYmZhX2lvY2ZjX2F0dGFjaChzdHJ1Y3QgYmZhX3MgKmJmYSwgdm9pZCAqYmZhZCwgc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLAorCQkgICBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbywgc3RydWN0IGJmYV9wY2lkZXZfcyAqcGNpZGV2KQoreworCWludCAgICAgICAgICAgICBpOworCisJYmZhX2lvY2ZjX2NiZm4uZW5hYmxlX2NiZm4gPSBiZmFfaW9jZmNfZW5hYmxlX2NiZm47CisJYmZhX2lvY2ZjX2NiZm4uZGlzYWJsZV9jYmZuID0gYmZhX2lvY2ZjX2Rpc2FibGVfY2JmbjsKKwliZmFfaW9jZmNfY2Jmbi5oYmZhaWxfY2JmbiA9IGJmYV9pb2NmY19oYmZhaWxfY2JmbjsKKwliZmFfaW9jZmNfY2Jmbi5yZXNldF9jYmZuID0gYmZhX2lvY2ZjX3Jlc2V0X2NiZm47CisKKwliZmFfaW9jX2F0dGFjaCgmYmZhLT5pb2MsIGJmYSwgJmJmYV9pb2NmY19jYmZuLCAmYmZhLT50aW1lcl9tb2QsCisJCWJmYS0+dHJjbW9kLCBiZmEtPmFlbiwgYmZhLT5sb2dtKTsKKwliZmFfaW9jX3BjaV9pbml0KCZiZmEtPmlvYywgcGNpZGV2LCBCRklfTUNfSU9DRkMpOworCWJmYV9pb2NfbWJveF9yZWdpc3RlcigmYmZhLT5pb2MsIGJmYV9tYm94X2lzcnMpOworCisJLyoqCisJICogQ2hvb3NlIEZDIChzc2lkOiAweDFDKSB2L3MgRkNvRSAoc3NpZDogMHgxNCkgbW9kZS4KKwkgKi8KKwlpZiAoMCkKKwkJYmZhX2lvY19zZXRfZmNtb2RlKCZiZmEtPmlvYyk7CisKKwliZmFfaW9jZmNfaW5pdF9tZW0oYmZhLCBiZmFkLCBjZmcsIHBjaWRldik7CisJYmZhX2lvY2ZjX21lbV9jbGFpbShiZmEsIGNmZywgbWVtaW5mbyk7CisJYmZhX3RpbWVyX2luaXQoJmJmYS0+dGltZXJfbW9kKTsKKworCUlOSVRfTElTVF9IRUFEKCZiZmEtPmNvbXBfcSk7CisJZm9yIChpID0gMDsgaSA8IEJGSV9JT0NfTUFYX0NRUzsgaSsrKQorCQlJTklUX0xJU1RfSEVBRCgmYmZhLT5yZXFxX3dhaXRxW2ldKTsKK30KKworLyoqCisgKiBRdWVyeSBJT0MgbWVtb3J5IHJlcXVpcmVtZW50IGluZm9ybWF0aW9uLgorICovCit2b2lkCitiZmFfaW9jZmNfZGV0YWNoKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWJmYV9pb2NfZGV0YWNoKCZiZmEtPmlvYyk7Cit9CisKKy8qKgorICogUXVlcnkgSU9DIG1lbW9yeSByZXF1aXJlbWVudCBpbmZvcm1hdGlvbi4KKyAqLwordm9pZAorYmZhX2lvY2ZjX2luaXQoc3RydWN0IGJmYV9zICpiZmEpCit7CisJYmZhLT5pb2NmYy5hY3Rpb24gPSBCRkFfSU9DRkNfQUNUX0lOSVQ7CisJYmZhX2lvY19lbmFibGUoJmJmYS0+aW9jKTsKKwliZmFfbXNpeF9pbnN0YWxsKGJmYSk7Cit9CisKKy8qKgorICogSU9DIHN0YXJ0IGNhbGxlZCBmcm9tIGJmYV9zdGFydCgpLiBDYWxsZWQgdG8gc3RhcnQgSU9DIG9wZXJhdGlvbnMKKyAqIGF0IGRyaXZlciBpbnN0YW50aWF0aW9uIGZvciB0aGlzIGluc3RhbmNlLgorICovCit2b2lkCitiZmFfaW9jZmNfc3RhcnQoc3RydWN0IGJmYV9zICpiZmEpCit7CisJaWYgKGJmYS0+aW9jZmMuY2ZnZG9uZSkKKwkJYmZhX2lvY2ZjX3N0YXJ0X3N1Ym1vZChiZmEpOworfQorCisvKioKKyAqIElPQyBzdG9wIGNhbGxlZCBmcm9tIGJmYV9zdG9wKCkuIENhbGxlZCBvbmx5IHdoZW4gZHJpdmVyIGlzIHVubG9hZGVkCisgKiBmb3IgdGhpcyBpbnN0YW5jZS4KKyAqLwordm9pZAorYmZhX2lvY2ZjX3N0b3Aoc3RydWN0IGJmYV9zICpiZmEpCit7CisJYmZhLT5pb2NmYy5hY3Rpb24gPSBCRkFfSU9DRkNfQUNUX1NUT1A7CisKKwliZmEtPnJtZV9wcm9jZXNzID0gQkZBX0ZBTFNFOworCWJmYV9pb2NfZGlzYWJsZSgmYmZhLT5pb2MpOworfQorCit2b2lkCitiZmFfaW9jZmNfaXNyKHZvaWQgKmJmYWFyZywgc3RydWN0IGJmaV9tYm1zZ19zICptKQoreworCXN0cnVjdCBiZmFfcwkJKmJmYSA9IGJmYWFyZzsKKwlzdHJ1Y3QgYmZhX2lvY2ZjX3MJKmlvY2ZjID0gJmJmYS0+aW9jZmM7CisJdW5pb24gYmZpX2lvY2ZjX2kyaF9tc2dfdQkqbXNnOworCisJbXNnID0gKHVuaW9uIGJmaV9pb2NmY19pMmhfbXNnX3UgKikgbTsKKwliZmFfdHJjKGJmYSwgbXNnLT5taC5tc2dfaWQpOworCisJc3dpdGNoIChtc2ctPm1oLm1zZ19pZCkgeworCWNhc2UgQkZJX0lPQ0ZDX0kySF9DRkdfUkVQTFk6CisJCWlvY2ZjLT5jZmdfcmVwbHkgPSAmbXNnLT5jZmdfcmVwbHk7CisJCWJmYV9pb2NmY19jZmdyc3AoYmZhKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9JT0NGQ19JMkhfR0VUX1NUQVRTX1JTUDoKKwkJaWYgKGlvY2ZjLT5zdGF0c19idXN5ID09IEJGQV9GQUxTRQorCQkgICAgfHwgaW9jZmMtPnN0YXRzX3N0YXR1cyA9PSBCRkFfU1RBVFVTX0VUSU1FUikKKwkJCWJyZWFrOworCisJCWJmYV90aW1lcl9zdG9wKCZpb2NmYy0+c3RhdHNfdGltZXIpOworCQlpb2NmYy0+c3RhdHNfc3RhdHVzID0gQkZBX1NUQVRVU19PSzsKKwkJYmZhX2NiX3F1ZXVlKGJmYSwgJmlvY2ZjLT5zdGF0c19oY2JfcWUsIGJmYV9pb2NmY19zdGF0c19jYiwKKwkJCSAgICAgIGJmYSk7CisJCWJyZWFrOworCWNhc2UgQkZJX0lPQ0ZDX0kySF9DTEVBUl9TVEFUU19SU1A6CisJCS8qCisJCSAqIGNoZWNrIGZvciB0aW1lciBwb3AgYmVmb3JlIHByb2Nlc3NpbmcgdGhlIHJzcAorCQkgKi8KKwkJaWYgKGlvY2ZjLT5zdGF0c19idXN5ID09IEJGQV9GQUxTRQorCQkgICAgfHwgaW9jZmMtPnN0YXRzX3N0YXR1cyA9PSBCRkFfU1RBVFVTX0VUSU1FUikKKwkJCWJyZWFrOworCisJCWJmYV90aW1lcl9zdG9wKCZpb2NmYy0+c3RhdHNfdGltZXIpOworCQlpb2NmYy0+c3RhdHNfc3RhdHVzID0gQkZBX1NUQVRVU19PSzsKKwkJYmZhX2NiX3F1ZXVlKGJmYSwgJmlvY2ZjLT5zdGF0c19oY2JfcWUsCisJCQkgICAgICBiZmFfaW9jZmNfc3RhdHNfY2xyX2NiLCBiZmEpOworCQlicmVhazsKKwljYXNlIEJGSV9JT0NGQ19JMkhfVVBEQVRFUV9SU1A6CisJCWlvY2ZjLT51cGRhdGVxX2NiZm4oaW9jZmMtPnVwZGF0ZXFfY2JhcmcsIEJGQV9TVEFUVVNfT0spOworCQlicmVhazsKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworI2lmbmRlZiBCRkFfQklPU19CVUlMRAordm9pZAorYmZhX2FkYXB0ZXJfZ2V0X2F0dHIoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfYWRhcHRlcl9hdHRyX3MgKmFkX2F0dHIpCit7CisJYmZhX2lvY19nZXRfYWRhcHRlcl9hdHRyKCZiZmEtPmlvYywgYWRfYXR0cik7Cit9CisKK3U2NAorYmZhX2FkYXB0ZXJfZ2V0X2lkKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXJldHVybiBiZmFfaW9jX2dldF9hZGlkKCZiZmEtPmlvYyk7Cit9CisKK3ZvaWQKK2JmYV9pb2NmY19nZXRfYXR0cihzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9pb2NmY19hdHRyX3MgKmF0dHIpCit7CisJc3RydWN0IGJmYV9pb2NmY19zCSppb2NmYyA9ICZiZmEtPmlvY2ZjOworCisJYXR0ci0+aW50cl9hdHRyID0gaW9jZmMtPmNmZ2luZm8tPmludHJfYXR0cjsKKwlhdHRyLT5jb25maWcJPSBpb2NmYy0+Y2ZnOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9pb2NmY19pc3JhdHRyX3NldChzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9pb2NmY19pbnRyX2F0dHJfcyAqYXR0cikKK3sKKwlzdHJ1Y3QgYmZhX2lvY2ZjX3MJCSppb2NmYyA9ICZiZmEtPmlvY2ZjOworCXN0cnVjdCBiZmlfaW9jZmNfc2V0X2ludHJfcmVxX3MgKm07CisKKwlpb2NmYy0+Y2ZnaW5mby0+aW50cl9hdHRyID0gKmF0dHI7CisJaWYgKCFiZmFfaW9jZmNfaXNfb3BlcmF0aW9uYWwoYmZhKSkKKwkJcmV0dXJuIEJGQV9TVEFUVVNfT0s7CisKKwltID0gYmZhX3JlcXFfbmV4dChiZmEsIEJGQV9SRVFRX0lPQyk7CisJaWYgKCFtKQorCQlyZXR1cm4gQkZBX1NUQVRVU19ERVZCVVNZOworCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19JT0NGQywgQkZJX0lPQ0ZDX0gySV9TRVRfSU5UUl9SRVEsCisJCQliZmFfbHB1aWQoYmZhKSk7CisJbS0+Y29hbGVzY2UgPSBhdHRyLT5jb2FsZXNjZTsKKwltLT5kZWxheSAgICA9IGJmYV9vc19odG9ucyhhdHRyLT5kZWxheSk7CisJbS0+bGF0ZW5jeSAgPSBiZmFfb3NfaHRvbnMoYXR0ci0+bGF0ZW5jeSk7CisKKwliZmFfdHJjKGJmYSwgYXR0ci0+ZGVsYXkpOworCWJmYV90cmMoYmZhLCBhdHRyLT5sYXRlbmN5KTsKKworCWJmYV9yZXFxX3Byb2R1Y2UoYmZhLCBCRkFfUkVRUV9JT0MpOworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCit2b2lkCitiZmFfaW9jZmNfc2V0X3Nuc2Jhc2Uoc3RydWN0IGJmYV9zICpiZmEsIHU2NCBzbnNiYXNlX3BhKQoreworCXN0cnVjdCBiZmFfaW9jZmNfcyAgICAgICppb2NmYyA9ICZiZmEtPmlvY2ZjOworCisJaW9jZmMtPmNmZ2luZm8tPnNlbnNlX2J1Zl9sZW4gPSAoQkZJX0lPSU1fU05TTEVOIC0gMSk7CisJYmZhX2RtYV9iZV9hZGRyX3NldChpb2NmYy0+Y2ZnaW5mby0+aW9pbV9zbnNiYXNlLCBzbnNiYXNlX3BhKTsKK30KKworYmZhX3N0YXR1c190CitiZmFfaW9jZmNfZ2V0X3N0YXRzKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2lvY2ZjX3N0YXRzX3MgKnN0YXRzLAorCQkgICAgICBiZmFfY2JfaW9jX3QgY2Jmbiwgdm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9pb2NmY19zCSppb2NmYyA9ICZiZmEtPmlvY2ZjOworCisJaWYgKGlvY2ZjLT5zdGF0c19idXN5KSB7CisJCWJmYV90cmMoYmZhLCBpb2NmYy0+c3RhdHNfYnVzeSk7CisJCXJldHVybiAoQkZBX1NUQVRVU19ERVZCVVNZKTsKKwl9CisKKwlpb2NmYy0+c3RhdHNfYnVzeSA9IEJGQV9UUlVFOworCWlvY2ZjLT5zdGF0c19yZXQgPSBzdGF0czsKKwlpb2NmYy0+c3RhdHNfY2JmbiA9IGNiZm47CisJaW9jZmMtPnN0YXRzX2NiYXJnID0gY2Jhcmc7CisKKwliZmFfaW9jZmNfc3RhdHNfcXVlcnkoYmZhKTsKKworCXJldHVybiAoQkZBX1NUQVRVU19PSyk7Cit9CisKK2JmYV9zdGF0dXNfdAorYmZhX2lvY2ZjX2NsZWFyX3N0YXRzKHN0cnVjdCBiZmFfcyAqYmZhLCBiZmFfY2JfaW9jX3QgY2Jmbiwgdm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9pb2NmY19zCSppb2NmYyA9ICZiZmEtPmlvY2ZjOworCisJaWYgKGlvY2ZjLT5zdGF0c19idXN5KSB7CisJCWJmYV90cmMoYmZhLCBpb2NmYy0+c3RhdHNfYnVzeSk7CisJCXJldHVybiAoQkZBX1NUQVRVU19ERVZCVVNZKTsKKwl9CisKKwlpb2NmYy0+c3RhdHNfYnVzeSA9IEJGQV9UUlVFOworCWlvY2ZjLT5zdGF0c19jYmZuID0gY2JmbjsKKwlpb2NmYy0+c3RhdHNfY2JhcmcgPSBjYmFyZzsKKworCWJmYV9pb2NmY19zdGF0c19jbGVhcihiZmEpOworCXJldHVybiAoQkZBX1NUQVRVU19PSyk7Cit9CisKKy8qKgorICogRW5hYmxlIElPQyBhZnRlciBpdCBpcyBkaXNhYmxlZC4KKyAqLwordm9pZAorYmZhX2lvY2ZjX2VuYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwliZmFfcGxvZ19zdHIoYmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTCwgQkZBX1BMX0VJRF9NSVNDLCAwLAorCQkgICAgICJJT0MgRW5hYmxlIik7CisJYmZhX2lvY19lbmFibGUoJmJmYS0+aW9jKTsKK30KKwordm9pZAorYmZhX2lvY2ZjX2Rpc2FibGUoc3RydWN0IGJmYV9zICpiZmEpCit7CisJYmZhX3Bsb2dfc3RyKGJmYS0+cGxvZywgQkZBX1BMX01JRF9IQUwsIEJGQV9QTF9FSURfTUlTQywgMCwKKwkJICAgICAiSU9DIERpc2FibGUiKTsKKwliZmEtPmlvY2ZjLmFjdGlvbiA9IEJGQV9JT0NGQ19BQ1RfRElTQUJMRTsKKworCWJmYS0+cm1lX3Byb2Nlc3MgPSBCRkFfRkFMU0U7CisJYmZhX2lvY19kaXNhYmxlKCZiZmEtPmlvYyk7Cit9CisKKworYmZhX2Jvb2xlYW5fdAorYmZhX2lvY2ZjX2lzX29wZXJhdGlvbmFsKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXJldHVybiBiZmFfaW9jX2lzX29wZXJhdGlvbmFsKCZiZmEtPmlvYykgJiYgYmZhLT5pb2NmYy5jZmdkb25lOworfQorCisvKioKKyAqIFJldHVybiBib290IHRhcmdldCBwb3J0IHd3bnMgLS0gcmVhZCBmcm9tIGJvb3QgaW5mb3JtYXRpb24gaW4gZmxhc2guCisgKi8KK3ZvaWQKK2JmYV9pb2NmY19nZXRfYm9vdHd3bnMoc3RydWN0IGJmYV9zICpiZmEsIHU4ICpud3ducywgd3duX3QgKip3d25zKQoreworCXN0cnVjdCBiZmFfaW9jZmNfcwkJKmlvY2ZjCSA9ICZiZmEtPmlvY2ZjOworCXN0cnVjdCBiZmlfaW9jZmNfY2ZncnNwX3MJKmNmZ3JzcCAgPSBpb2NmYy0+Y2ZncnNwOworCisJKm53d25zID0gY2ZncnNwLT5ib290d3ducy5ud3duczsKKwkqd3ducyA9IGNmZ3JzcC0+Ym9vdHd3bnMud3duOworfQorCisjZW5kaWYKKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9pb2NmYy5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW9jZmMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43YWQxNzdlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW9jZmMuaApAQCAtMCwwICsxLDE2OCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0lPQ0ZDX0hfXworI2RlZmluZSBfX0JGQV9JT0NGQ19IX18KKworI2luY2x1ZGUgPGJmYV9pb2MuaD4KKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX2lvY2ZjLmg+CisjaW5jbHVkZSA8YmZhX2NhbGxiYWNrX3ByaXYuaD4KKworI2RlZmluZSBCRkFfUkVRUV9ORUxFTVNfTUlOCSg0KQorI2RlZmluZSBCRkFfUlNQUV9ORUxFTVNfTUlOCSg0KQorCitzdHJ1Y3QgYmZhX2lvY2ZjX3JlZ3NfcyB7CisJYmZhX29zX2FkZHJfdCAgIGludHJfc3RhdHVzOworCWJmYV9vc19hZGRyX3QgICBpbnRyX21hc2s7CisJYmZhX29zX2FkZHJfdCAgIGNwZV9xX3BpW0JGSV9JT0NfTUFYX0NRU107CisJYmZhX29zX2FkZHJfdCAgIGNwZV9xX2NpW0JGSV9JT0NfTUFYX0NRU107CisJYmZhX29zX2FkZHJfdCAgIGNwZV9xX2RlcHRoW0JGSV9JT0NfTUFYX0NRU107CisJYmZhX29zX2FkZHJfdCAgIGNwZV9xX2N0cmxbQkZJX0lPQ19NQVhfQ1FTXTsKKwliZmFfb3NfYWRkcl90ICAgcm1lX3FfY2lbQkZJX0lPQ19NQVhfQ1FTXTsKKwliZmFfb3NfYWRkcl90ICAgcm1lX3FfcGlbQkZJX0lPQ19NQVhfQ1FTXTsKKwliZmFfb3NfYWRkcl90ICAgcm1lX3FfZGVwdGhbQkZJX0lPQ19NQVhfQ1FTXTsKKwliZmFfb3NfYWRkcl90ICAgcm1lX3FfY3RybFtCRklfSU9DX01BWF9DUVNdOworfTsKKworLyoqCisgKiBNU0lYIHZlY3RvciBoYW5kbGVycworICovCisjZGVmaW5lIEJGQV9NU0lYX01BWF9WRUNUT1JTCTIyCit0eXBlZGVmIHZvaWQgKCpiZmFfbXNpeF9oYW5kbGVyX3QpKHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgdmVjKTsKK3N0cnVjdCBiZmFfbXNpeF9zIHsKKwlpbnQJbnZlY3M7CisJYmZhX21zaXhfaGFuZGxlcl90IGhhbmRsZXJbQkZBX01TSVhfTUFYX1ZFQ1RPUlNdOworfTsKKworLyoqCisgKiBDaGlwIHNwZWNpZmljIGludGVyZmFjZXMKKyAqLworc3RydWN0IGJmYV9od2lmX3MgeworCXZvaWQgKCpod19yZWdpbml0KShzdHJ1Y3QgYmZhX3MgKmJmYSk7CisJdm9pZCAoKmh3X3JzcHFfYWNrKShzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IHJzcHEpOworCXZvaWQgKCpod19tc2l4X2luaXQpKHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgbnZlY3MpOworCXZvaWQgKCpod19tc2l4X2luc3RhbGwpKHN0cnVjdCBiZmFfcyAqYmZhKTsKKwl2b2lkICgqaHdfbXNpeF91bmluc3RhbGwpKHN0cnVjdCBiZmFfcyAqYmZhKTsKKwl2b2lkICgqaHdfaXNyX21vZGVfc2V0KShzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2Jvb2xlYW5fdCBtc2l4KTsKKwl2b2lkICgqaHdfbXNpeF9nZXR2ZWNzKShzdHJ1Y3QgYmZhX3MgKmJmYSwgdTMyICp2ZWNtYXAsCisJCQl1MzIgKm52ZWNzLCB1MzIgKm1heHZlYyk7Cit9OwordHlwZWRlZiB2b2lkICgqYmZhX2NiX2lvY2ZjX3QpICh2b2lkICpjYmFyZywgZW51bSBiZmFfc3RhdHVzIHN0YXR1cyk7CisKK3N0cnVjdCBiZmFfaW9jZmNfcyB7CisJc3RydWN0IGJmYV9zIAkJKmJmYTsKKwlzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zIAljZmc7CisJaW50CQkJYWN0aW9uOworCisJdTMyICAgICAgICAJcmVxX2NxX3BpW0JGSV9JT0NfTUFYX0NRU107CisJdTMyICAgICAgICAJcnNwX2NxX2NpW0JGSV9JT0NfTUFYX0NRU107CisKKwlzdHJ1Y3QgYmZhX2NiX3FlX3MJaW5pdF9oY2JfcWU7CisJc3RydWN0IGJmYV9jYl9xZV9zCXN0b3BfaGNiX3FlOworCXN0cnVjdCBiZmFfY2JfcWVfcwlkaXNfaGNiX3FlOworCXN0cnVjdCBiZmFfY2JfcWVfcwlzdGF0c19oY2JfcWU7CisJYmZhX2Jvb2xlYW5fdAkJY2ZnZG9uZTsKKworCXN0cnVjdCBiZmFfZG1hX3MJY2ZnX2luZm87CisJc3RydWN0IGJmaV9pb2NmY19jZmdfcyAqY2ZnaW5mbzsKKwlzdHJ1Y3QgYmZhX2RtYV9zCWNmZ3JzcF9kbWE7CisJc3RydWN0IGJmaV9pb2NmY19jZmdyc3BfcyAqY2ZncnNwOworCXN0cnVjdCBiZmlfaW9jZmNfY2ZnX3JlcGx5X3MgKmNmZ19yZXBseTsKKworCXU4CQkJKnN0YXRzX2t2YTsKKwl1NjQJCXN0YXRzX3BhOworCXN0cnVjdCBiZmFfZndfc3RhdHNfcyAJKmZ3X3N0YXRzOworCXN0cnVjdCBiZmFfdGltZXJfcyAJc3RhdHNfdGltZXI7CS8qICB0aW1lciAqLworCXN0cnVjdCBiZmFfaW9jZmNfc3RhdHNfcyAqc3RhdHNfcmV0OwkvKiAgZHJpdmVyIHN0YXRzIGxvY2F0aW9uICovCisJYmZhX3N0YXR1c190CQlzdGF0c19zdGF0dXM7CS8qICBzdGF0cy9zdGF0c2NsciBzdGF0dXMgKi8KKwliZmFfYm9vbGVhbl90ICAgCXN0YXRzX2J1c3k7CS8qICBvdXRzdGFuZGluZyBzdGF0cyAqLworCWJmYV9jYl9pb2NfdAkJc3RhdHNfY2JmbjsJLyogIGRyaXZlciBjYWxsYmFjayBmdW5jdGlvbiAqLworCXZvaWQgICAgICAgICAgIAkJKnN0YXRzX2NiYXJnOwkvKiAgdXNlciBjYWxsYmFjayBhcmcgKi8KKworCXN0cnVjdCBiZmFfZG1hX3MgICAJcmVxX2NxX2JhW0JGSV9JT0NfTUFYX0NRU107CisJc3RydWN0IGJmYV9kbWFfcyAgIAlyZXFfY3Ffc2hhZG93X2NpW0JGSV9JT0NfTUFYX0NRU107CisJc3RydWN0IGJmYV9kbWFfcyAgIAlyc3BfY3FfYmFbQkZJX0lPQ19NQVhfQ1FTXTsKKwlzdHJ1Y3QgYmZhX2RtYV9zICAgCXJzcF9jcV9zaGFkb3dfcGlbQkZJX0lPQ19NQVhfQ1FTXTsKKwlzdHJ1Y3QgYmZhX2lvY2ZjX3JlZ3NfcwliZmFfcmVnczsJLyogIEJGQSBkZXZpY2UgcmVnaXN0ZXJzICovCisJc3RydWN0IGJmYV9od2lmX3MJaHdpZjsKKworCWJmYV9jYl9pb2NmY190CQl1cGRhdGVxX2NiZm47IC8qICBiaW9zIGNhbGxiYWNrIGZ1bmN0aW9uICovCisJdm9pZAkJCQkqdXBkYXRlcV9jYmFyZzsJLyogIGJpb3MgY2FsbGJhY2sgYXJnICovCit9OworCisjZGVmaW5lIGJmYV9scHVpZChfX2JmYSkJCWJmYV9pb2NfcG9ydGlkKCYoX19iZmEpLT5pb2MpCisjZGVmaW5lIGJmYV9tc2l4X2luaXQoX19iZmEsIF9fbnZlY3MpCVwKKwkoX19iZmEpLT5pb2NmYy5od2lmLmh3X21zaXhfaW5pdChfX2JmYSwgX19udmVjcykKKyNkZWZpbmUgYmZhX21zaXhfaW5zdGFsbChfX2JmYSkJXAorCShfX2JmYSktPmlvY2ZjLmh3aWYuaHdfbXNpeF9pbnN0YWxsKF9fYmZhKQorI2RlZmluZSBiZmFfbXNpeF91bmluc3RhbGwoX19iZmEpCVwKKwkoX19iZmEpLT5pb2NmYy5od2lmLmh3X21zaXhfdW5pbnN0YWxsKF9fYmZhKQorI2RlZmluZSBiZmFfaXNyX21vZGVfc2V0KF9fYmZhLCBfX21zaXgpCVwKKwkoX19iZmEpLT5pb2NmYy5od2lmLmh3X2lzcl9tb2RlX3NldChfX2JmYSwgX19tc2l4KQorI2RlZmluZSBiZmFfbXNpeF9nZXR2ZWNzKF9fYmZhLCBfX3ZlY21hcCwgX19udmVjcywgX19tYXh2ZWMpCVwKKwkoX19iZmEpLT5pb2NmYy5od2lmLmh3X21zaXhfZ2V0dmVjcyhfX2JmYSwgX192ZWNtYXAsIF9fbnZlY3MsIF9fbWF4dmVjKQorCisvKgorICogRkMgc3BlY2lmaWMgSU9DIGZ1bmN0aW9ucy4KKyAqLwordm9pZCBiZmFfaW9jZmNfbWVtaW5mbyhzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsIHUzMiAqa21fbGVuLAorCQl1MzIgKmRtX2xlbik7Cit2b2lkIGJmYV9pb2NmY19hdHRhY2goc3RydWN0IGJmYV9zICpiZmEsIHZvaWQgKmJmYWQsCisJCXN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmNmZywgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1lbWluZm8sCisJCXN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldik7Cit2b2lkIGJmYV9pb2NmY19kZXRhY2goc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfaW9jZmNfaW5pdChzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9pb2NmY19zdGFydChzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9pb2NmY19zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKTsKK3ZvaWQgYmZhX2lvY2ZjX2lzcih2b2lkICpiZmEsIHN0cnVjdCBiZmlfbWJtc2dfcyAqbXNnKTsKK3ZvaWQgYmZhX2lvY2ZjX3NldF9zbnNiYXNlKHN0cnVjdCBiZmFfcyAqYmZhLCB1NjQgc25zYmFzZV9wYSk7CitiZmFfYm9vbGVhbl90IGJmYV9pb2NmY19pc19vcGVyYXRpb25hbChzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9pb2NmY19yZXNldF9xdWV1ZXMoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfaW9jZmNfdXBkYXRlcShzdHJ1Y3QgYmZhX3MgKmJmYSwgdTMyIHJlcXFfYmEsIHUzMiByc3BxX2JhLAorCQkJdTMyIHJlcXFfc2NpLCB1MzIgcnNwcV9zcGksCisJCQliZmFfY2JfaW9jZmNfdCBjYmZuLCB2b2lkICpjYmFyZyk7CisKK3ZvaWQgYmZhX21zaXhfYWxsKHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgdmVjKTsKK3ZvaWQgYmZhX21zaXhfcmVxcShzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IHZlYyk7Cit2b2lkIGJmYV9tc2l4X3JzcHEoc3RydWN0IGJmYV9zICpiZmEsIGludCB2ZWMpOwordm9pZCBiZmFfbXNpeF9scHVfZXJyKHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgdmVjKTsKKwordm9pZCBiZmFfaHdjYl9yZWdpbml0KHN0cnVjdCBiZmFfcyAqYmZhKTsKK3ZvaWQgYmZhX2h3Y2JfcnNwcV9hY2soc3RydWN0IGJmYV9zICpiZmEsIGludCByc3BxKTsKK3ZvaWQgYmZhX2h3Y2JfbXNpeF9pbml0KHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgbnZlY3MpOwordm9pZCBiZmFfaHdjYl9tc2l4X2luc3RhbGwoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfaHdjYl9tc2l4X3VuaW5zdGFsbChzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9od2NiX2lzcl9tb2RlX3NldChzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2Jvb2xlYW5fdCBtc2l4KTsKK3ZvaWQgYmZhX2h3Y2JfbXNpeF9nZXR2ZWNzKHN0cnVjdCBiZmFfcyAqYmZhLCB1MzIgKnZlY21hcCwKKwkJCXUzMiAqbnZlY3MsIHUzMiAqbWF4dmVjKTsKK3ZvaWQgYmZhX2h3Y3RfcmVnaW5pdChzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9od2N0X3JzcHFfYWNrKHN0cnVjdCBiZmFfcyAqYmZhLCBpbnQgcnNwcSk7Cit2b2lkIGJmYV9od2N0X21zaXhfaW5pdChzdHJ1Y3QgYmZhX3MgKmJmYSwgaW50IG52ZWNzKTsKK3ZvaWQgYmZhX2h3Y3RfbXNpeF9pbnN0YWxsKHN0cnVjdCBiZmFfcyAqYmZhKTsKK3ZvaWQgYmZhX2h3Y3RfbXNpeF91bmluc3RhbGwoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfaHdjdF9pc3JfbW9kZV9zZXQoc3RydWN0IGJmYV9zICpiZmEsIGJmYV9ib29sZWFuX3QgbXNpeCk7Cit2b2lkIGJmYV9od2N0X21zaXhfZ2V0dmVjcyhzdHJ1Y3QgYmZhX3MgKmJmYSwgdTMyICp2ZWNtYXAsCisJCQl1MzIgKm52ZWNzLCB1MzIgKm1heHZlYyk7CisKK3ZvaWQgYmZhX2NvbV9tZW1pbmZvKGJmYV9ib29sZWFuX3QgbWluY2ZnLCB1MzIgKmRtX2xlbik7Cit2b2lkIGJmYV9jb21fYXR0YWNoKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWksCisJCWJmYV9ib29sZWFuX3QgbWluY2ZnKTsKK3ZvaWQgYmZhX2lvY2ZjX2dldF9ib290d3ducyhzdHJ1Y3QgYmZhX3MgKmJmYSwgdTggKm53d25zLCB3d25fdCAqKnd3bnMpOworCisjZW5kaWYgLyogX19CRkFfSU9DRkNfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvY2ZjX3EuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvY2ZjX3EuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MDBhMTdkCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW9jZmNfcS5jCkBAIC0wLDAgKzEsNDQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgImJmYV9pbnRyX3ByaXYuaCIKKworQkZBX1RSQ19GSUxFKEhBTCwgSU9DRkNfUSk7CisKK3ZvaWQKK2JmYV9pb2NmY191cGRhdGVxKHN0cnVjdCBiZmFfcyAqYmZhLCB1MzIgcmVxcV9iYSwgdTMyIHJzcHFfYmEsCisJCQkJdTMyIHJlcXFfc2NpLCB1MzIgcnNwcV9zcGksIGJmYV9jYl9pb2NmY190IGNiZm4sCisJCQkJdm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9pb2NmY19zICppb2NmYyA9ICZiZmEtPmlvY2ZjOworCXN0cnVjdCBiZmlfaW9jZmNfdXBkYXRlcV9yZXFfcyB1cGRhdGVxX3JlcTsKKworCWlvY2ZjLT51cGRhdGVxX2NiZm4gPSBjYmZuOworCWlvY2ZjLT51cGRhdGVxX2NiYXJnID0gY2Jhcmc7CisKKwliZmlfaDJpX3NldCh1cGRhdGVxX3JlcS5taCwgQkZJX01DX0lPQ0ZDLCBCRklfSU9DRkNfSDJJX1VQREFURVFfUkVRLAorCQkJYmZhX2xwdWlkKGJmYSkpOworCisJdXBkYXRlcV9yZXEucmVxcV9iYSA9IGJmYV9vc19odG9ubChyZXFxX2JhKTsKKwl1cGRhdGVxX3JlcS5yc3BxX2JhID0gYmZhX29zX2h0b25sKHJzcHFfYmEpOworCXVwZGF0ZXFfcmVxLnJlcXFfc2NpID0gYmZhX29zX2h0b25sKHJlcXFfc2NpKTsKKwl1cGRhdGVxX3JlcS5yc3BxX3NwaSA9IGJmYV9vc19odG9ubChyc3BxX3NwaSk7CisKKwliZmFfaW9jX21ib3hfc2VuZCgmYmZhLT5pb2MsICZ1cGRhdGVxX3JlcSwKKwkJCXNpemVvZihzdHJ1Y3QgYmZpX2lvY2ZjX3VwZGF0ZXFfcmVxX3MpKTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvaW0uYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX2lvaW0uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43YWUyNTUyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaW9pbS5jCkBAIC0wLDAgKzEsMTMxMSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSA8YmZhLmg+CisjaW5jbHVkZSA8Y3MvYmZhX2RlYnVnLmg+CisjaW5jbHVkZSA8YmZhX2NiX2lvaW1fbWFjcm9zLmg+CisKK0JGQV9UUkNfRklMRShIQUwsIElPSU0pOworCisvKgorICogZm9yd2FyZCBkZWNsYXJhdGlvbnMuCisgKi8KK3N0YXRpYyBiZmFfYm9vbGVhbl90CWJmYV9pb2ltX3NlbmRfaW9yZXEoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0pOworc3RhdGljIGJmYV9ib29sZWFuX3QJYmZhX2lvaW1fc2dlX3NldHVwKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKTsKK3N0YXRpYyB2b2lkCQliZmFfaW9pbV9zZ3BnX3NldHVwKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKTsKK3N0YXRpYyBiZmFfYm9vbGVhbl90CWJmYV9pb2ltX3NlbmRfYWJvcnQoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0pOworc3RhdGljIHZvaWQJCWJmYV9pb2ltX25vdGlmeV9jbGVhbnVwKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKTsKK3N0YXRpYyB2b2lkIF9fYmZhX2NiX2lvaW1fZ29vZF9jb21wKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKK3N0YXRpYyB2b2lkIF9fYmZhX2NiX2lvaW1fY29tcCh2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CitzdGF0aWMgdm9pZCBfX2JmYV9jYl9pb2ltX2Fib3J0KHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKK3N0YXRpYyB2b2lkIF9fYmZhX2NiX2lvaW1fZmFpbGVkKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKTsKK3N0YXRpYyB2b2lkIF9fYmZhX2NiX2lvaW1fcGF0aHRvdih2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CisKKy8qKgorICogIGJmYV9pb2ltX3NtCisgKi8KKworLyoqCisgKiBJTyBzdGF0ZSBtYWNoaW5lIGV2ZW50cworICovCitlbnVtIGJmYV9pb2ltX2V2ZW50IHsKKwlCRkFfSU9JTV9TTV9TVEFSVCA9IDEsCQkvKiAgaW8gc3RhcnQgcmVxdWVzdCBmcm9tIGhvc3QgKi8KKwlCRkFfSU9JTV9TTV9DT01QX0dPT0QgPSAyLAkvKiAgaW8gZ29vZCBjb21wLCByZXNvdXJjZSBmcmVlICovCisJQkZBX0lPSU1fU01fQ09NUCA9IDMsCQkvKiAgaW8gY29tcCwgcmVzb3VyY2UgaXMgZnJlZSAqLworCUJGQV9JT0lNX1NNX0NPTVBfVVRBRyA9IDQsCS8qICBpbyBjb21wLCByZXNvdXJjZSBpcyBmcmVlICovCisJQkZBX0lPSU1fU01fRE9ORSA9IDUsCQkvKiAgaW8gY29tcCwgcmVzb3VyY2Ugbm90IGZyZWUgKi8KKwlCRkFfSU9JTV9TTV9GUkVFID0gNiwJCS8qICBpbyByZXNvdXJjZSBpcyBmcmVlZCAqLworCUJGQV9JT0lNX1NNX0FCT1JUID0gNywJCS8qICBhYm9ydCByZXF1ZXN0IGZyb20gc2NzaSBzdGFjayAqLworCUJGQV9JT0lNX1NNX0FCT1JUX0NPTVAgPSA4LAkvKiAgYWJvcnQgZnJvbSBmL3cgKi8KKwlCRkFfSU9JTV9TTV9BQk9SVF9ET05FID0gOSwJLyogIGFib3J0IGNvbXBsZXRpb24gZnJvbSBmL3cgKi8KKwlCRkFfSU9JTV9TTV9RUkVTVU1FID0gMTAsCS8qICBDUSBzcGFjZSBhdmFpbGFibGUgdG8gcXVldWUgSU8gKi8KKwlCRkFfSU9JTV9TTV9TR0FMTE9DRUQgPSAxMSwJLyogIFNHIHBhZ2UgYWxsb2NhdGlvbiBzdWNjZXNzZnVsICovCisJQkZBX0lPSU1fU01fU1FSRVRSWSA9IDEyLAkvKiAgc2VxdWVuY2UgcmVjb3ZlcnkgcmV0cnkgKi8KKwlCRkFfSU9JTV9TTV9IQ0IJPSAxMywJCS8qICBiZmEgY2FsbGJhY2sgY29tcGxldGUgKi8KKwlCRkFfSU9JTV9TTV9DTEVBTlVQID0gMTQsCS8qICBJTyBjbGVhbnVwIGZyb20gaXRuaW0gKi8KKwlCRkFfSU9JTV9TTV9UTVNUQVJUID0gMTUsCS8qICBJTyBjbGVhbnVwIGZyb20gdHNraW0gKi8KKwlCRkFfSU9JTV9TTV9UTURPTkUgPSAxNiwJLyogIElPIGNsZWFudXAgZnJvbSB0c2tpbSAqLworCUJGQV9JT0lNX1NNX0hXRkFJTCA9IDE3LAkvKiAgSU9DIGgvdyBmYWlsdXJlIGV2ZW50ICovCisJQkZBX0lPSU1fU01fSU9UT1YgPSAxOCwJCS8qICBJVE4gb2ZmbGluZSBUT1YgICAgICAgKi8KK307CisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9uIG9mIElPIHN0YXRlIG1hY2hpbmUKKyAqLworc3RhdGljIHZvaWQgICAgIGJmYV9pb2ltX3NtX3VuaW5pdChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwKKwkJCQkgICAgICAgZW51bSBiZmFfaW9pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2lvaW1fc21fc2dhbGxvYyhzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwKKwkJCQkJZW51bSBiZmFfaW9pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2lvaW1fc21fYWN0aXZlKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltLAorCQkJCSAgICAgICBlbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9pbV9zbV9hYm9ydChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwKKwkJCQkgICAgICBlbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9pbV9zbV9jbGVhbnVwKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltLAorCQkJCQllbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9pbV9zbV9xZnVsbChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwKKwkJCQkgICAgICBlbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9pbV9zbV9hYm9ydF9xZnVsbChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwKKwkJCQkJICAgIGVudW0gYmZhX2lvaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2ltX3NtX2NsZWFudXBfcWZ1bGwoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sCisJCQkJCSAgICAgIGVudW0gYmZhX2lvaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pb2ltX3NtX2hjYihzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwKKwkJCQkgICAgZW51bSBiZmFfaW9pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2lvaW1fc21faGNiX2ZyZWUoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sCisJCQkJCSBlbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaW9pbV9zbV9yZXNmcmVlKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltLAorCQkJCQllbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KTsKKworLyoqCisgKiAJCUlPIGlzIG5vdCBzdGFydGVkICh1bmFsbG9jYXRlZCkuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9pbV9zbV91bmluaXQoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sIGVudW0gYmZhX2lvaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyY19mcChpb2ltLT5iZmEsIGlvaW0tPmlvdGFnKTsKKwliZmFfdHJjX2ZwKGlvaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lPSU1fU01fU1RBUlQ6CisJCWlmICghYmZhX2l0bmltX2lzX29ubGluZShpb2ltLT5pdG5pbSkpIHsKKwkJCWlmICghYmZhX2l0bmltX2hvbGRfaW8oaW9pbS0+aXRuaW0pKSB7CisJCQkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2IpOworCQkJCWxpc3RfZGVsKCZpb2ltLT5xZSk7CisJCQkJbGlzdF9hZGRfdGFpbCgmaW9pbS0+cWUsCisJCQkJCSZpb2ltLT5mY3BpbS0+aW9pbV9jb21wX3EpOworCQkJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsCisJCQkJCQlfX2JmYV9jYl9pb2ltX3BhdGh0b3YsIGlvaW0pOworCQkJfSBlbHNlIHsKKwkJCQlsaXN0X2RlbCgmaW9pbS0+cWUpOworCQkJCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLAorCQkJCQkmaW9pbS0+aXRuaW0tPnBlbmRpbmdfcSk7CisJCQl9CisJCQlicmVhazsKKwkJfQorCisJCWlmIChpb2ltLT5uc2dlcyA+IEJGSV9TR0VfSU5MSU5FKSB7CisJCQlpZiAoIWJmYV9pb2ltX3NnZV9zZXR1cChpb2ltKSkgeworCQkJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21fc2dhbGxvYyk7CisJCQkJcmV0dXJuOworCQkJfQorCQl9CisKKwkJaWYgKCFiZmFfaW9pbV9zZW5kX2lvcmVxKGlvaW0pKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX3FmdWxsKTsKKwkJCWJyZWFrOworCQl9CisKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9hY3RpdmUpOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fSU9UT1Y6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiKTsKKwkJYmZhX2NiX3F1ZXVlKGlvaW0tPmJmYSwgJmlvaW0tPmhjYl9xZSwKKwkJCQlfX2JmYV9jYl9pb2ltX3BhdGh0b3YsIGlvaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fQUJPUlQ6CisJCS8qKgorCQkgKiBJTyBpbiBwZW5kaW5nIHF1ZXVlIGNhbiBnZXQgYWJvcnQgcmVxdWVzdHMuIENvbXBsZXRlIGFib3J0CisJCSAqIHJlcXVlc3RzIGltbWVkaWF0ZWx5LgorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2IpOworCQliZmFfYXNzZXJ0KGJmYV9xX2lzX29uX3EoJmlvaW0tPml0bmltLT5wZW5kaW5nX3EsIGlvaW0pKTsKKwkJYmZhX2NiX3F1ZXVlKGlvaW0tPmJmYSwgJmlvaW0tPmhjYl9xZSwgX19iZmFfY2JfaW9pbV9hYm9ydCwKKwkJCQlpb2ltKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCUlPIGlzIHdhaXRpbmcgZm9yIFNHIHBhZ2VzLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvaW1fc21fc2dhbGxvYyhzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwgZW51bSBiZmFfaW9pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCWJmYV90cmMoaW9pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSU9JTV9TTV9TR0FMTE9DRUQ6CisJCWlmICghYmZhX2lvaW1fc2VuZF9pb3JlcShpb2ltKSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9xZnVsbCk7CisJCQlicmVhazsKKwkJfQorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2FjdGl2ZSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9DTEVBTlVQOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9zZ3BnX3djYW5jZWwoaW9pbS0+YmZhLCAmaW9pbS0+aW9zcC0+c2dwZ193cWUpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBfX2JmYV9jYl9pb2ltX2ZhaWxlZCwKKwkJCSAgICAgIGlvaW0pOworCQliZmFfaW9pbV9ub3RpZnlfY2xlYW51cChpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0FCT1JUOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9zZ3BnX3djYW5jZWwoaW9pbS0+YmZhLCAmaW9pbS0+aW9zcC0+c2dwZ193cWUpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBfX2JmYV9jYl9pb2ltX2Fib3J0LAorCQkJICAgICAgaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiKTsKKwkJYmZhX3NncGdfd2NhbmNlbChpb2ltLT5iZmEsICZpb2ltLT5pb3NwLT5zZ3BnX3dxZSk7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fZmFpbGVkLAorCQkJICAgICAgaW9pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlJTyBpcyBhY3RpdmUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9pbV9zbV9hY3RpdmUoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sIGVudW0gYmZhX2lvaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyY19mcChpb2ltLT5iZmEsIGlvaW0tPmlvdGFnKTsKKwliZmFfdHJjX2ZwKGlvaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lPSU1fU01fQ09NUF9HT09EOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsCisJCQkgICAgICBfX2JmYV9jYl9pb2ltX2dvb2RfY29tcCwgaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fY29tcCwKKwkJCSAgICAgIGlvaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fRE9ORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2JfZnJlZSk7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fY29tcCwKKwkJCSAgICAgIGlvaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fQUJPUlQ6CisJCWlvaW0tPmlvc3AtPmFib3J0X2V4cGxpY2l0ID0gQkZBX1RSVUU7CisJCWlvaW0tPmlvX2NiZm4gPSBfX2JmYV9jYl9pb2ltX2Fib3J0OworCisJCWlmIChiZmFfaW9pbV9zZW5kX2Fib3J0KGlvaW0pKQorCQkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9hYm9ydCk7CisJCWVsc2UgeworCQkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9hYm9ydF9xZnVsbCk7CisJCQliZmFfcmVxcV93YWl0KGlvaW0tPmJmYSwgaW9pbS0+aXRuaW0tPnJlcXEsCisJCQkJCSAgJmlvaW0tPmlvc3AtPnJlcXFfd2FpdCk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0NMRUFOVVA6CisJCWlvaW0tPmlvc3AtPmFib3J0X2V4cGxpY2l0ID0gQkZBX0ZBTFNFOworCQlpb2ltLT5pb19jYmZuID0gX19iZmFfY2JfaW9pbV9mYWlsZWQ7CisKKwkJaWYgKGJmYV9pb2ltX3NlbmRfYWJvcnQoaW9pbSkpCisJCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2NsZWFudXApOworCQllbHNlIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21fY2xlYW51cF9xZnVsbCk7CisJCQliZmFfcmVxcV93YWl0KGlvaW0tPmJmYSwgaW9pbS0+aXRuaW0tPnJlcXEsCisJCQkJCSAgJmlvaW0tPmlvc3AtPnJlcXFfd2FpdCk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2IpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBfX2JmYV9jYl9pb2ltX2ZhaWxlZCwKKwkJCSAgICAgIGlvaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJSU8gaXMgYmVpbmcgYWJvcnRlZCwgd2FpdGluZyBmb3IgY29tcGxldGlvbiBmcm9tIGZpcm13YXJlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvaW1fc21fYWJvcnQoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sIGVudW0gYmZhX2lvaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2ltLT5iZmEsIGlvaW0tPmlvdGFnKTsKKwliZmFfdHJjKGlvaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lPSU1fU01fQ09NUF9HT09EOgorCWNhc2UgQkZBX0lPSU1fU01fQ09NUDoKKwljYXNlIEJGQV9JT0lNX1NNX0RPTkU6CisJY2FzZSBCRkFfSU9JTV9TTV9GUkVFOgorCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fQUJPUlRfRE9ORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2JfZnJlZSk7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fYWJvcnQsCisJCQkgICAgICBpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0FCT1JUX0NPTVA6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiKTsKKwkJYmZhX2NiX3F1ZXVlKGlvaW0tPmJmYSwgJmlvaW0tPmhjYl9xZSwgX19iZmFfY2JfaW9pbV9hYm9ydCwKKwkJCSAgICAgIGlvaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fQ09NUF9VVEFHOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fYWJvcnQsCisJCQkgICAgICBpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0NMRUFOVVA6CisJCWJmYV9hc3NlcnQoaW9pbS0+aW9zcC0+YWJvcnRfZXhwbGljaXQgPT0gQkZBX1RSVUUpOworCQlpb2ltLT5pb3NwLT5hYm9ydF9leHBsaWNpdCA9IEJGQV9GQUxTRTsKKworCQlpZiAoYmZhX2lvaW1fc2VuZF9hYm9ydChpb2ltKSkKKwkJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21fY2xlYW51cCk7CisJCWVsc2UgeworCQkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9jbGVhbnVwX3FmdWxsKTsKKwkJCWJmYV9yZXFxX3dhaXQoaW9pbS0+YmZhLCBpb2ltLT5pdG5pbS0+cmVxcSwKKwkJCQkJICAmaW9pbS0+aW9zcC0+cmVxcV93YWl0KTsKKwkJfQorCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fZmFpbGVkLAorCQkJICAgICAgaW9pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogSU8gaXMgYmVpbmcgY2xlYW5lZCB1cCAoaW1wbGljaXQgYWJvcnQpLCB3YWl0aW5nIGZvciBjb21wbGV0aW9uIGZyb20KKyAqIGZpcm13YXJlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvaW1fc21fY2xlYW51cChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwgZW51bSBiZmFfaW9pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCWJmYV90cmMoaW9pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSU9JTV9TTV9DT01QX0dPT0Q6CisJY2FzZSBCRkFfSU9JTV9TTV9DT01QOgorCWNhc2UgQkZBX0lPSU1fU01fRE9ORToKKwljYXNlIEJGQV9JT0lNX1NNX0ZSRUU6CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9BQk9SVDoKKwkJLyoqCisJCSAqIElPIGlzIGFscmVhZHkgYmVpbmcgYWJvcnRlZCBpbXBsaWNpdGx5CisJCSAqLworCQlpb2ltLT5pb19jYmZuID0gX19iZmFfY2JfaW9pbV9hYm9ydDsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0FCT1JUX0RPTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiX2ZyZWUpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBpb2ltLT5pb19jYmZuLCBpb2ltKTsKKwkJYmZhX2lvaW1fbm90aWZ5X2NsZWFudXAoaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9BQk9SVF9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIGlvaW0tPmlvX2NiZm4sIGlvaW0pOworCQliZmFfaW9pbV9ub3RpZnlfY2xlYW51cChpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0NPTVBfVVRBRzoKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2IpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBpb2ltLT5pb19jYmZuLCBpb2ltKTsKKwkJYmZhX2lvaW1fbm90aWZ5X2NsZWFudXAoaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiKTsKKwkJYmZhX2NiX3F1ZXVlKGlvaW0tPmJmYSwgJmlvaW0tPmhjYl9xZSwgX19iZmFfY2JfaW9pbV9mYWlsZWQsCisJCQkgICAgICBpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0NMRUFOVVA6CisJCS8qKgorCQkgKiBJTyBjYW4gYmUgaW4gY2xlYW51cCBzdGF0ZSBhbHJlYWR5IGR1ZSB0byBUTSBjb21tYW5kLiAybmQgY2xlYW51cAorCQkgKiByZXF1ZXN0IGNvbWVzIGZyb20gSVROIG9mZmxpbmUgZXZlbnQuCisJCSAqLworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJSU8gaXMgd2FpdGluZyBmb3Igcm9vbSBpbiByZXF1ZXN0IENRCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9pbV9zbV9xZnVsbChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwgZW51bSBiZmFfaW9pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCWJmYV90cmMoaW9pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSU9JTV9TTV9RUkVTVU1FOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2FjdGl2ZSk7CisJCWJmYV9pb2ltX3NlbmRfaW9yZXEoaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9BQk9SVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2IpOworCQliZmFfcmVxcV93Y2FuY2VsKCZpb2ltLT5pb3NwLT5yZXFxX3dhaXQpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBfX2JmYV9jYl9pb2ltX2Fib3J0LAorCQkJICAgICAgaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9DTEVBTlVQOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9yZXFxX3djYW5jZWwoJmlvaW0tPmlvc3AtPnJlcXFfd2FpdCk7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fZmFpbGVkLAorCQkJICAgICAgaW9pbSk7CisJCWJmYV9pb2ltX25vdGlmeV9jbGVhbnVwKGlvaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9yZXFxX3djYW5jZWwoJmlvaW0tPmlvc3AtPnJlcXFfd2FpdCk7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fZmFpbGVkLAorCQkJICAgICAgaW9pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlBY3RpdmUgSU8gaXMgYmVpbmcgYWJvcnRlZCwgd2FpdGluZyBmb3Igcm9vbSBpbiByZXF1ZXN0IENRLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvaW1fc21fYWJvcnRfcWZ1bGwoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sIGVudW0gYmZhX2lvaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2ltLT5iZmEsIGlvaW0tPmlvdGFnKTsKKwliZmFfdHJjKGlvaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lPSU1fU01fUVJFU1VNRToKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9hYm9ydCk7CisJCWJmYV9pb2ltX3NlbmRfYWJvcnQoaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9DTEVBTlVQOgorCQliZmFfYXNzZXJ0KGlvaW0tPmlvc3AtPmFib3J0X2V4cGxpY2l0ID09IEJGQV9UUlVFKTsKKwkJaW9pbS0+aW9zcC0+YWJvcnRfZXhwbGljaXQgPSBCRkFfRkFMU0U7CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21fY2xlYW51cF9xZnVsbCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9DT01QX0dPT0Q6CisJY2FzZSBCRkFfSU9JTV9TTV9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJmYV9yZXFxX3djYW5jZWwoJmlvaW0tPmlvc3AtPnJlcXFfd2FpdCk7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIF9fYmZhX2NiX2lvaW1fYWJvcnQsCisJCQkgICAgICBpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0RPTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiX2ZyZWUpOworCQliZmFfcmVxcV93Y2FuY2VsKCZpb2ltLT5pb3NwLT5yZXFxX3dhaXQpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBfX2JmYV9jYl9pb2ltX2Fib3J0LAorCQkJICAgICAgaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmaW9pbS0+aW9zcC0+cmVxcV93YWl0KTsKKwkJYmZhX2NiX3F1ZXVlKGlvaW0tPmJmYSwgJmlvaW0tPmhjYl9xZSwgX19iZmFfY2JfaW9pbV9mYWlsZWQsCisJCQkgICAgICBpb2ltKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCUFjdGl2ZSBJTyBpcyBiZWluZyBjbGVhbmVkIHVwLCB3YWl0aW5nIGZvciByb29tIGluIHJlcXVlc3QgQ1EuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9pbV9zbV9jbGVhbnVwX3FmdWxsKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltLCBlbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaW9pbS0+YmZhLCBpb2ltLT5pb3RhZyk7CisJYmZhX3RyYyhpb2ltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JT0lNX1NNX1FSRVNVTUU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21fY2xlYW51cCk7CisJCWJmYV9pb2ltX3NlbmRfYWJvcnQoaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9BQk9SVDoKKwkJLyoqCisJCSAqIElPIGlzIGFscmFlZHkgYmVpbmcgY2xlYW5lZCB1cCBpbXBsaWNpdGx5CisJCSAqLworCQlpb2ltLT5pb19jYmZuID0gX19iZmFfY2JfaW9pbV9hYm9ydDsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0NPTVBfR09PRDoKKwljYXNlIEJGQV9JT0lNX1NNX0NPTVA6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21faGNiKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmaW9pbS0+aW9zcC0+cmVxcV93YWl0KTsKKwkJYmZhX2NiX3F1ZXVlKGlvaW0tPmJmYSwgJmlvaW0tPmhjYl9xZSwgaW9pbS0+aW9fY2JmbiwgaW9pbSk7CisJCWJmYV9pb2ltX25vdGlmeV9jbGVhbnVwKGlvaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fRE9ORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2JfZnJlZSk7CisJCWJmYV9yZXFxX3djYW5jZWwoJmlvaW0tPmlvc3AtPnJlcXFfd2FpdCk7CisJCWJmYV9jYl9xdWV1ZShpb2ltLT5iZmEsICZpb2ltLT5oY2JfcWUsIGlvaW0tPmlvX2NiZm4sIGlvaW0pOworCQliZmFfaW9pbV9ub3RpZnlfY2xlYW51cChpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2IpOworCQliZmFfcmVxcV93Y2FuY2VsKCZpb2ltLT5pb3NwLT5yZXFxX3dhaXQpOworCQliZmFfY2JfcXVldWUoaW9pbS0+YmZhLCAmaW9pbS0+aGNiX3FlLCBfX2JmYV9jYl9pb2ltX2ZhaWxlZCwKKwkJCSAgICAgIGlvaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIElPIGJmYSBjYWxsYmFjayBpcyBwZW5kaW5nLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvaW1fc21faGNiKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltLCBlbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmNfZnAoaW9pbS0+YmZhLCBpb2ltLT5pb3RhZyk7CisJYmZhX3RyY19mcChpb2ltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JT0lNX1NNX0hDQjoKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV91bmluaXQpOworCQliZmFfaW9pbV9mcmVlKGlvaW0pOworCQliZmFfY2JfaW9pbV9yZXNmcmVlKGlvaW0tPmJmYS0+YmZhZCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9DTEVBTlVQOgorCQliZmFfaW9pbV9ub3RpZnlfY2xlYW51cChpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0hXRkFJTDoKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBJTyBiZmEgY2FsbGJhY2sgaXMgcGVuZGluZy4gSU8gcmVzb3VyY2UgY2Fubm90IGJlIGZyZWVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2lvaW1fc21faGNiX2ZyZWUoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sIGVudW0gYmZhX2lvaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpb2ltLT5iZmEsIGlvaW0tPmlvdGFnKTsKKwliZmFfdHJjKGlvaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lPSU1fU01fSENCOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX3Jlc2ZyZWUpOworCQlsaXN0X2RlbCgmaW9pbS0+cWUpOworCQlsaXN0X2FkZF90YWlsKCZpb2ltLT5xZSwgJmlvaW0tPmZjcGltLT5pb2ltX3Jlc2ZyZWVfcSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9GUkVFOgorCQliZmFfc21fc2V0X3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2hjYik7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9DTEVBTlVQOgorCQliZmFfaW9pbV9ub3RpZnlfY2xlYW51cChpb2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JT0lNX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV9oY2IpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIElPIGlzIGNvbXBsZXRlZCwgd2FpdGluZyByZXNvdXJjZSBmcmVlIGZyb20gZmlybXdhcmUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaW9pbV9zbV9yZXNmcmVlKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltLCBlbnVtIGJmYV9pb2ltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaW9pbS0+YmZhLCBpb2ltLT5pb3RhZyk7CisJYmZhX3RyYyhpb2ltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JT0lNX1NNX0ZSRUU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaW9pbSwgYmZhX2lvaW1fc21fdW5pbml0KTsKKwkJYmZhX2lvaW1fZnJlZShpb2ltKTsKKwkJYmZhX2NiX2lvaW1fcmVzZnJlZShpb2ltLT5iZmEtPmJmYWQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0lPSU1fU01fQ0xFQU5VUDoKKwkJYmZhX2lvaW1fbm90aWZ5X2NsZWFudXAoaW9pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSU9JTV9TTV9IV0ZBSUw6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBiZmFfaW9pbV9wcml2YXRlCisgKi8KKworc3RhdGljIHZvaWQKK19fYmZhX2NiX2lvaW1fZ29vZF9jb21wKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfaW9pbV9zICppb2ltID0gY2Jhcmc7CisKKwlpZiAoIWNvbXBsZXRlKSB7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX0hDQik7CisJCXJldHVybjsKKwl9CisKKwliZmFfY2JfaW9pbV9nb29kX2NvbXAoaW9pbS0+YmZhLT5iZmFkLCBpb2ltLT5kaW8pOworfQorCitzdGF0aWMgdm9pZAorX19iZmFfY2JfaW9pbV9jb21wKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfaW9pbV9zCSppb2ltID0gY2Jhcmc7CisJc3RydWN0IGJmaV9pb2ltX3JzcF9zICptOworCXU4CQkqc25zaW5mbyA9IE5VTEw7CisJdTggICAgICAgICBzbnNfbGVuID0gMDsKKwlzMzIgICAgICAgICByZXNpZHVlID0gMDsKKworCWlmICghY29tcGxldGUpIHsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaW9pbSwgQkZBX0lPSU1fU01fSENCKTsKKwkJcmV0dXJuOworCX0KKworCW0gPSAoc3RydWN0IGJmaV9pb2ltX3JzcF9zICopICZpb2ltLT5pb3NwLT5jb21wX3JzcG1zZzsKKwlpZiAobS0+aW9fc3RhdHVzID09IEJGSV9JT0lNX1NUU19PSykgeworCQkvKioKKwkJICogc2V0dXAgc2Vuc2UgaW5mb3JtYXRpb24sIGlmIHByZXNlbnQKKwkJICovCisJCWlmIChtLT5zY3NpX3N0YXR1cyA9PSBTQ1NJX1NUQVRVU19DSEVDS19DT05ESVRJT04KKwkJCQkJJiYgbS0+c25zX2xlbikgeworCQkJc25zX2xlbiA9IG0tPnNuc19sZW47CisJCQlzbnNpbmZvID0gaW9pbS0+aW9zcC0+c25zaW5mbzsKKwkJfQorCisJCS8qKgorCQkgKiBzZXR1cCByZXNpZHVlIHZhbHVlIGNvcnJlY3RseSBmb3Igbm9ybWFsIGNvbXBsZXRpb25zCisJCSAqLworCQlpZiAobS0+cmVzaWRfZmxhZ3MgPT0gRkNQX1JFU0lEX1VOREVSKQorCQkJcmVzaWR1ZSA9IGJmYV9vc19udG9obChtLT5yZXNpZHVlKTsKKwkJaWYgKG0tPnJlc2lkX2ZsYWdzID09IEZDUF9SRVNJRF9PVkVSKSB7CisJCQlyZXNpZHVlID0gYmZhX29zX250b2hsKG0tPnJlc2lkdWUpOworCQkJcmVzaWR1ZSA9IC1yZXNpZHVlOworCQl9CisJfQorCisJYmZhX2NiX2lvaW1fZG9uZShpb2ltLT5iZmEtPmJmYWQsIGlvaW0tPmRpbywgbS0+aW9fc3RhdHVzLAorCQkJICBtLT5zY3NpX3N0YXR1cywgc25zX2xlbiwgc25zaW5mbywgcmVzaWR1ZSk7Cit9CisKK3N0YXRpYyB2b2lkCitfX2JmYV9jYl9pb2ltX2ZhaWxlZCh2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSkKK3sKKwlzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSA9IGNiYXJnOworCisJaWYgKCFjb21wbGV0ZSkgeworCQliZmFfc21fc2VuZF9ldmVudChpb2ltLCBCRkFfSU9JTV9TTV9IQ0IpOworCQlyZXR1cm47CisJfQorCisJYmZhX2NiX2lvaW1fZG9uZShpb2ltLT5iZmEtPmJmYWQsIGlvaW0tPmRpbywgQkZJX0lPSU1fU1RTX0FCT1JURUQsCisJCQkgIDAsIDAsIE5VTEwsIDApOworfQorCitzdGF0aWMgdm9pZAorX19iZmFfY2JfaW9pbV9wYXRodG92KHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfaW9pbV9zICppb2ltID0gY2Jhcmc7CisKKwlpZiAoIWNvbXBsZXRlKSB7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX0hDQik7CisJCXJldHVybjsKKwl9CisKKwliZmFfY2JfaW9pbV9kb25lKGlvaW0tPmJmYS0+YmZhZCwgaW9pbS0+ZGlvLCBCRklfSU9JTV9TVFNfUEFUSFRPViwKKwkJCSAgMCwgMCwgTlVMTCwgMCk7Cit9CisKK3N0YXRpYyB2b2lkCitfX2JmYV9jYl9pb2ltX2Fib3J0KHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfaW9pbV9zICppb2ltID0gY2Jhcmc7CisKKwlpZiAoIWNvbXBsZXRlKSB7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX0hDQik7CisJCXJldHVybjsKKwl9CisKKwliZmFfY2JfaW9pbV9hYm9ydChpb2ltLT5iZmEtPmJmYWQsIGlvaW0tPmRpbyk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaW9pbV9zZ3BnX2FsbG9jZWQodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0gPSBjYmFyZzsKKworCWlvaW0tPm5zZ3BncyA9IEJGQV9TR1BHX05QQUdFKGlvaW0tPm5zZ2VzKTsKKwlsaXN0X3NwbGljZV90YWlsX2luaXQoJmlvaW0tPmlvc3AtPnNncGdfd3FlLnNncGdfcSwgJmlvaW0tPnNncGdfcSk7CisJYmZhX2lvaW1fc2dwZ19zZXR1cChpb2ltKTsKKwliZmFfc21fc2VuZF9ldmVudChpb2ltLCBCRkFfSU9JTV9TTV9TR0FMTE9DRUQpOworfQorCisvKioKKyAqIFNlbmQgSS9PIHJlcXVlc3QgdG8gZmlybXdhcmUuCisgKi8KK3N0YXRpYyAgICAgICAgICBiZmFfYm9vbGVhbl90CitiZmFfaW9pbV9zZW5kX2lvcmVxKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKQoreworCXN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0gPSBpb2ltLT5pdG5pbTsKKwlzdHJ1Y3QgYmZpX2lvaW1fcmVxX3MgKm07CisJc3RhdGljIHN0cnVjdCBmY3BfY21uZF9zIGNtbmRfejAgPSB7IDAgfTsKKwlzdHJ1Y3QgYmZpX3NnZV9zICAgICAgKnNnZTsKKwl1MzIgICAgICAgIHBnZGxlbiA9IDA7CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQoaW9pbS0+YmZhLCBpdG5pbS0+cmVxcSk7CisJaWYgKCFtKSB7CisJCWJmYV9yZXFxX3dhaXQoaW9pbS0+YmZhLCBpb2ltLT5pdG5pbS0+cmVxcSwKKwkJCQkgICZpb2ltLT5pb3NwLT5yZXFxX3dhaXQpOworCQlyZXR1cm4gQkZBX0ZBTFNFOworCX0KKworCS8qKgorCSAqIGJ1aWxkIGkvbyByZXF1ZXN0IG1lc3NhZ2UgbmV4dAorCSAqLworCW0tPmlvX3RhZyA9IGJmYV9vc19odG9ucyhpb2ltLT5pb3RhZyk7CisJbS0+cnBvcnRfaGRsID0gaW9pbS0+aXRuaW0tPnJwb3J0LT5md19oYW5kbGU7CisJbS0+aW9fdGltZW91dCA9IGJmYV9jYl9pb2ltX2dldF90aW1lb3V0KGlvaW0tPmRpbyk7CisKKwkvKioKKwkgKiBidWlsZCBpbmxpbmUgSU8gU0cgZWxlbWVudCBoZXJlCisJICovCisJc2dlID0gJm0tPnNnZXNbMF07CisJaWYgKGlvaW0tPm5zZ2VzKSB7CisJCXNnZS0+c2dhID0gYmZhX2NiX2lvaW1fZ2V0X3NnYWRkcihpb2ltLT5kaW8sIDApOworCQlwZ2RsZW4gPSBiZmFfY2JfaW9pbV9nZXRfc2dsZW4oaW9pbS0+ZGlvLCAwKTsKKwkJc2dlLT5zZ19sZW4gPSBwZ2RsZW47CisJCXNnZS0+ZmxhZ3MgPSAoaW9pbS0+bnNnZXMgPiBCRklfU0dFX0lOTElORSkgPworCQkJCQlCRklfU0dFX0RBVEFfQ1BMIDogQkZJX1NHRV9EQVRBX0xBU1Q7CisJCWJmYV9zZ2VfdG9fYmUoc2dlKTsKKwkJc2dlKys7CisJfQorCisJaWYgKGlvaW0tPm5zZ2VzID4gQkZJX1NHRV9JTkxJTkUpIHsKKwkJc2dlLT5zZ2EgPSBpb2ltLT5zZ3BnLT5zZ3BnX3BhOworCX0gZWxzZSB7CisJCXNnZS0+c2dhLmEzMi5hZGRyX2xvID0gMDsKKwkJc2dlLT5zZ2EuYTMyLmFkZHJfaGkgPSAwOworCX0KKwlzZ2UtPnNnX2xlbiA9IHBnZGxlbjsKKwlzZ2UtPmZsYWdzID0gQkZJX1NHRV9QR0RMRU47CisJYmZhX3NnZV90b19iZShzZ2UpOworCisJLyoqCisJICogc2V0IHVwIEkvTyBjb21tYW5kIHBhcmFtZXRlcnMKKwkgKi8KKwliZmFfb3NfYXNzaWduKG0tPmNtbmQsIGNtbmRfejApOworCW0tPmNtbmQubHVuID0gYmZhX2NiX2lvaW1fZ2V0X2x1bihpb2ltLT5kaW8pOworCW0tPmNtbmQuaW9kaXIgPSBiZmFfY2JfaW9pbV9nZXRfaW9kaXIoaW9pbS0+ZGlvKTsKKwliZmFfb3NfYXNzaWduKG0tPmNtbmQuY2RiLAorCQkJKihzdHJ1Y3Qgc2NzaV9jZGJfcyAqKWJmYV9jYl9pb2ltX2dldF9jZGIoaW9pbS0+ZGlvKSk7CisJbS0+Y21uZC5mY3BfZGwgPSBiZmFfb3NfaHRvbmwoYmZhX2NiX2lvaW1fZ2V0X3NpemUoaW9pbS0+ZGlvKSk7CisKKwkvKioKKwkgKiBzZXQgdXAgSS9PIG1lc3NhZ2UgaGVhZGVyCisJICovCisJc3dpdGNoIChtLT5jbW5kLmlvZGlyKSB7CisJY2FzZSBGQ1BfSU9ESVJfUkVBRDoKKwkJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19JT0lNX1JFQUQsIDAsIGJmYV9scHVpZChpb2ltLT5iZmEpKTsKKwkJYmZhX3N0YXRzKGl0bmltLCBpbnB1dF9yZXFzKTsKKwkJYnJlYWs7CisJY2FzZSBGQ1BfSU9ESVJfV1JJVEU6CisJCWJmaV9oMmlfc2V0KG0tPm1oLCBCRklfTUNfSU9JTV9XUklURSwgMCwgYmZhX2xwdWlkKGlvaW0tPmJmYSkpOworCQliZmFfc3RhdHMoaXRuaW0sIG91dHB1dF9yZXFzKTsKKwkJYnJlYWs7CisJY2FzZSBGQ1BfSU9ESVJfUlc6CisJCWJmYV9zdGF0cyhpdG5pbSwgaW5wdXRfcmVxcyk7CisJCWJmYV9zdGF0cyhpdG5pbSwgb3V0cHV0X3JlcXMpOworCWRlZmF1bHQ6CisJCWJmaV9oMmlfc2V0KG0tPm1oLCBCRklfTUNfSU9JTV9JTywgMCwgYmZhX2xwdWlkKGlvaW0tPmJmYSkpOworCX0KKwlpZiAoaXRuaW0tPnNlcV9yZWMgfHwKKwkgICAgKGJmYV9jYl9pb2ltX2dldF9zaXplKGlvaW0tPmRpbykgJiAoc2l6ZW9mKHUzMikgLSAxKSkpCisJCWJmaV9oMmlfc2V0KG0tPm1oLCBCRklfTUNfSU9JTV9JTywgMCwgYmZhX2xwdWlkKGlvaW0tPmJmYSkpOworCisjaWZkZWYgSU9JTV9BRFZBTkNFRAorCW0tPmNtbmQuY3JuID0gYmZhX2NiX2lvaW1fZ2V0X2Nybihpb2ltLT5kaW8pOworCW0tPmNtbmQucHJpb3JpdHkgPSBiZmFfY2JfaW9pbV9nZXRfcHJpb3JpdHkoaW9pbS0+ZGlvKTsKKwltLT5jbW5kLnRhc2thdHRyID0gYmZhX2NiX2lvaW1fZ2V0X3Rhc2thdHRyKGlvaW0tPmRpbyk7CisKKwkvKioKKwkgKiBIYW5kbGUgbGFyZ2UgQ0RCICg+MTYgYnl0ZXMpLgorCSAqLworCW0tPmNtbmQuYWRkbF9jZGJfbGVuID0gKGJmYV9jYl9pb2ltX2dldF9jZGJsZW4oaW9pbS0+ZGlvKSAtCisJCQkJCUZDUF9DTU5EX0NEQl9MRU4pIC8gc2l6ZW9mKHUzMik7CisJaWYgKG0tPmNtbmQuYWRkbF9jZGJfbGVuKSB7CisJCWJmYV9vc19tZW1jcHkoJm0tPmNtbmQuY2RiICsgMSwgKHN0cnVjdCBzY3NpX2NkYl9zICopCisJCQkJYmZhX2NiX2lvaW1fZ2V0X2NkYihpb2ltLT5kaW8pICsgMSwKKwkJCQltLT5jbW5kLmFkZGxfY2RiX2xlbiAqIHNpemVvZih1MzIpKTsKKwkJZmNwX2NtbmRfZmNwZGwoJm0tPmNtbmQpID0KKwkJCQliZmFfb3NfaHRvbmwoYmZhX2NiX2lvaW1fZ2V0X3NpemUoaW9pbS0+ZGlvKSk7CisJfQorI2VuZGlmCisKKwkvKioKKwkgKiBxdWV1ZSBJL08gbWVzc2FnZSB0byBmaXJtd2FyZQorCSAqLworCWJmYV9yZXFxX3Byb2R1Y2UoaW9pbS0+YmZhLCBpdG5pbS0+cmVxcSk7CisJcmV0dXJuIEJGQV9UUlVFOworfQorCisvKioKKyAqIFNldHVwIGFueSBhZGRpdGlvbmFsIFNHIHBhZ2VzIG5lZWRlZC5JbmxpbmUgU0cgZWxlbWVudCBpcyBzZXR1cAorICogYXQgcXVldWluZyB0aW1lLgorICovCitzdGF0aWMgYmZhX2Jvb2xlYW5fdAorYmZhX2lvaW1fc2dlX3NldHVwKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKQoreworCXUxNiAgICAgICAgbnNncGdzOworCisJYmZhX2Fzc2VydChpb2ltLT5uc2dlcyA+IEJGSV9TR0VfSU5MSU5FKTsKKworCS8qKgorCSAqIGFsbG9jYXRlIFNHIHBhZ2VzIG5lZWRlZAorCSAqLworCW5zZ3BncyA9IEJGQV9TR1BHX05QQUdFKGlvaW0tPm5zZ2VzKTsKKwlpZiAoIW5zZ3BncykKKwkJcmV0dXJuIEJGQV9UUlVFOworCisJaWYgKGJmYV9zZ3BnX21hbGxvYyhpb2ltLT5iZmEsICZpb2ltLT5zZ3BnX3EsIG5zZ3BncykKKwkgICAgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfc2dwZ193YWl0KGlvaW0tPmJmYSwgJmlvaW0tPmlvc3AtPnNncGdfd3FlLCBuc2dwZ3MpOworCQlyZXR1cm4gQkZBX0ZBTFNFOworCX0KKworCWlvaW0tPm5zZ3BncyA9IG5zZ3BnczsKKwliZmFfaW9pbV9zZ3BnX3NldHVwKGlvaW0pOworCisJcmV0dXJuIEJGQV9UUlVFOworfQorCitzdGF0aWMgdm9pZAorYmZhX2lvaW1fc2dwZ19zZXR1cChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSkKK3sKKwlpbnQgICAgICAgICAgICAgc2dlaWQsIG5zZ2VzLCBpOworCXN0cnVjdCBiZmlfc2dlX3MgICAgICAqc2dlOworCXN0cnVjdCBiZmFfc2dwZ19zICpzZ3BnOworCXUzMiAgICAgICAgcGdjdW1zejsKKworCXNnZWlkID0gQkZJX1NHRV9JTkxJTkU7CisJaW9pbS0+c2dwZyA9IHNncGcgPSBiZmFfcV9maXJzdCgmaW9pbS0+c2dwZ19xKTsKKworCWRvIHsKKwkJc2dlID0gc2dwZy0+c2dwZy0+c2dlczsKKwkJbnNnZXMgPSBpb2ltLT5uc2dlcyAtIHNnZWlkOworCQlpZiAobnNnZXMgPiBCRklfU0dQR19EQVRBX1NHRVMpCisJCQluc2dlcyA9IEJGSV9TR1BHX0RBVEFfU0dFUzsKKworCQlwZ2N1bXN6ID0gMDsKKwkJZm9yIChpID0gMDsgaSA8IG5zZ2VzOyBpKyssIHNnZSsrLCBzZ2VpZCsrKSB7CisJCQlzZ2UtPnNnYSA9IGJmYV9jYl9pb2ltX2dldF9zZ2FkZHIoaW9pbS0+ZGlvLCBzZ2VpZCk7CisJCQlzZ2UtPnNnX2xlbiA9IGJmYV9jYl9pb2ltX2dldF9zZ2xlbihpb2ltLT5kaW8sIHNnZWlkKTsKKwkJCXBnY3Vtc3ogKz0gc2dlLT5zZ19sZW47CisKKwkJCS8qKgorCQkJICogc2V0IGZsYWdzCisJCQkgKi8KKwkJCWlmIChpIDwgKG5zZ2VzIC0gMSkpCisJCQkJc2dlLT5mbGFncyA9IEJGSV9TR0VfREFUQTsKKwkJCWVsc2UgaWYgKHNnZWlkIDwgKGlvaW0tPm5zZ2VzIC0gMSkpCisJCQkJc2dlLT5mbGFncyA9IEJGSV9TR0VfREFUQV9DUEw7CisJCQllbHNlCisJCQkJc2dlLT5mbGFncyA9IEJGSV9TR0VfREFUQV9MQVNUOworCQl9CisKKwkJc2dwZyA9IChzdHJ1Y3QgYmZhX3NncGdfcyAqKSBiZmFfcV9uZXh0KHNncGcpOworCisJCS8qKgorCQkgKiBzZXQgdGhlIGxpbmsgZWxlbWVudCBvZiBlYWNoIHBhZ2UKKwkJICovCisJCWlmIChzZ2VpZCA9PSBpb2ltLT5uc2dlcykgeworCQkJc2dlLT5mbGFncyA9IEJGSV9TR0VfUEdETEVOOworCQkJc2dlLT5zZ2EuYTMyLmFkZHJfbG8gPSAwOworCQkJc2dlLT5zZ2EuYTMyLmFkZHJfaGkgPSAwOworCQl9IGVsc2UgeworCQkJc2dlLT5mbGFncyA9IEJGSV9TR0VfTElOSzsKKwkJCXNnZS0+c2dhID0gc2dwZy0+c2dwZ19wYTsKKwkJfQorCQlzZ2UtPnNnX2xlbiA9IHBnY3Vtc3o7CisJfSB3aGlsZSAoc2dlaWQgPCBpb2ltLT5uc2dlcyk7Cit9CisKKy8qKgorICogU2VuZCBJL08gYWJvcnQgcmVxdWVzdCB0byBmaXJtd2FyZS4KKyAqLworc3RhdGljICAgICAgICAgIGJmYV9ib29sZWFuX3QKK2JmYV9pb2ltX3NlbmRfYWJvcnQoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0pCit7CisJc3RydWN0IGJmYV9pdG5pbV9zICAgICAgICAgICppdG5pbSA9IGlvaW0tPml0bmltOworCXN0cnVjdCBiZmlfaW9pbV9hYm9ydF9yZXFfcyAqbTsKKwllbnVtIGJmaV9pb2ltX2gyaSAgICAgICBtc2dvcDsKKworCS8qKgorCSAqIGNoZWNrIGZvciByb29tIGluIHF1ZXVlIHRvIHNlbmQgcmVxdWVzdCBub3cKKwkgKi8KKwltID0gYmZhX3JlcXFfbmV4dChpb2ltLT5iZmEsIGl0bmltLT5yZXFxKTsKKwlpZiAoIW0pCisJCXJldHVybiBCRkFfRkFMU0U7CisKKwkvKioKKwkgKiBidWlsZCBpL28gcmVxdWVzdCBtZXNzYWdlIG5leHQKKwkgKi8KKwlpZiAoaW9pbS0+aW9zcC0+YWJvcnRfZXhwbGljaXQpCisJCW1zZ29wID0gQkZJX0lPSU1fSDJJX0lPQUJPUlRfUkVROworCWVsc2UKKwkJbXNnb3AgPSBCRklfSU9JTV9IMklfSU9DTEVBTlVQX1JFUTsKKworCWJmaV9oMmlfc2V0KG0tPm1oLCBCRklfTUNfSU9JTSwgbXNnb3AsIGJmYV9scHVpZChpb2ltLT5iZmEpKTsKKwltLT5pb190YWcgICAgPSBiZmFfb3NfaHRvbnMoaW9pbS0+aW90YWcpOworCW0tPmFib3J0X3RhZyA9ICsraW9pbS0+YWJvcnRfdGFnOworCisJLyoqCisJICogcXVldWUgSS9PIG1lc3NhZ2UgdG8gZmlybXdhcmUKKwkgKi8KKwliZmFfcmVxcV9wcm9kdWNlKGlvaW0tPmJmYSwgaXRuaW0tPnJlcXEpOworCXJldHVybiBCRkFfVFJVRTsKK30KKworLyoqCisgKiBDYWxsIHRvIHJlc3VtZSBhbnkgSS9PIHJlcXVlc3RzIHdhaXRpbmcgZm9yIHJvb20gaW4gcmVxdWVzdCBxdWV1ZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pb2ltX3FyZXN1bWUodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0gPSBjYmFyZzsKKworCWJmYV9mY3BpbV9zdGF0cyhpb2ltLT5mY3BpbSwgcXJlc3VtZXMpOworCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX1FSRVNVTUUpOworfQorCisKK3N0YXRpYyB2b2lkCitiZmFfaW9pbV9ub3RpZnlfY2xlYW51cChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSkKK3sKKwkvKioKKwkgKiBNb3ZlIElPIGZyb20gaXRuaW0gcXVldWUgdG8gZmNwaW0gZ2xvYmFsIHF1ZXVlIHNpbmNlIGl0bmltIHdpbGwgYmUKKwkgKiBmcmVlZC4KKwkgKi8KKwlsaXN0X2RlbCgmaW9pbS0+cWUpOworCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLCAmaW9pbS0+ZmNwaW0tPmlvaW1fY29tcF9xKTsKKworCWlmICghaW9pbS0+aW9zcC0+dHNraW0pIHsKKwkJaWYgKGlvaW0tPmZjcGltLT5kZWxheV9jb21wICYmIGlvaW0tPml0bmltLT5pb3Rvdl9hY3RpdmUpIHsKKwkJCWJmYV9jYl9kZXF1ZXVlKCZpb2ltLT5oY2JfcWUpOworCQkJbGlzdF9kZWwoJmlvaW0tPnFlKTsKKwkJCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLCAmaW9pbS0+aXRuaW0tPmRlbGF5X2NvbXBfcSk7CisJCX0KKwkJYmZhX2l0bmltX2lvZG9uZShpb2ltLT5pdG5pbSk7CisJfSBlbHNlCisJCWJmYV90c2tpbV9pb2RvbmUoaW9pbS0+aW9zcC0+dHNraW0pOworfQorCisvKioKKyAqIAkJICBvciBhZnRlciB0aGUgbGluayBjb21lcyBiYWNrLgorICovCit2b2lkCitiZmFfaW9pbV9kZWxheWVkX2NvbXAoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sIGJmYV9ib29sZWFuX3QgaW90b3YpCit7CisJLyoqCisJICogSWYgcGF0aCB0b3YgdGltZXIgZXhwaXJlZCwgZmFpbGJhY2sgd2l0aCBQQVRIVE9WIHN0YXR1cyAtIHRoZXNlCisJICogSU8gcmVxdWVzdHMgYXJlIG5vdCBub3JtYWxseSByZXRyaWVkIGJ5IElPIHN0YWNrLgorCSAqCisJICogT3RoZXJ3aXNlIGRldmljZSBjYW1lYmFjayBvbmxpbmUgYW5kIGZhaWwgaXQgd2l0aCBub3JtYWwgZmFpbGVkCisJICogc3RhdHVzIHNvIHRoYXQgSU8gc3RhY2sgcmV0cmllcyB0aGVzZSBmYWlsZWQgSU8gcmVxdWVzdHMuCisJICovCisJaWYgKGlvdG92KQorCQlpb2ltLT5pb19jYmZuID0gX19iZmFfY2JfaW9pbV9wYXRodG92OworCWVsc2UKKwkJaW9pbS0+aW9fY2JmbiA9IF9fYmZhX2NiX2lvaW1fZmFpbGVkOworCisJYmZhX2NiX3F1ZXVlKGlvaW0tPmJmYSwgJmlvaW0tPmhjYl9xZSwgaW9pbS0+aW9fY2JmbiwgaW9pbSk7CisKKyAgICAvKioKKyAgICAgKiBNb3ZlIElPIHRvIGZjcGltIGdsb2JhbCBxdWV1ZSBzaW5jZSBpdG5pbSB3aWxsIGJlCisgICAgICogZnJlZWQuCisgICAgICovCisgICAgbGlzdF9kZWwoJmlvaW0tPnFlKTsKKyAgICBsaXN0X2FkZF90YWlsKCZpb2ltLT5xZSwgJmlvaW0tPmZjcGltLT5pb2ltX2NvbXBfcSk7Cit9CisKKworCisvKioKKyAqICBiZmFfaW9pbV9mcmllbmQKKyAqLworCisvKioKKyAqIE1lbW9yeSBhbGxvY2F0aW9uIGFuZCBpbml0aWFsaXphdGlvbi4KKyAqLwordm9pZAorYmZhX2lvaW1fYXR0YWNoKHN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltLCBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWluZm8pCit7CisJc3RydWN0IGJmYV9pb2ltX3MJCSppb2ltOworCXN0cnVjdCBiZmFfaW9pbV9zcF9zCSppb3NwOworCXUxNgkJaTsKKwl1OAkJCSpzbnNpbmZvOworCXUzMgkJc25zYnVmc3o7CisKKwkvKioKKwkgKiBjbGFpbSBtZW1vcnkgZmlyc3QKKwkgKi8KKwlpb2ltID0gKHN0cnVjdCBiZmFfaW9pbV9zICopIGJmYV9tZW1pbmZvX2t2YShtaW5mbyk7CisJZmNwaW0tPmlvaW1fYXJyID0gaW9pbTsKKwliZmFfbWVtaW5mb19rdmEobWluZm8pID0gKHU4ICopIChpb2ltICsgZmNwaW0tPm51bV9pb2ltX3JlcXMpOworCisJaW9zcCA9IChzdHJ1Y3QgYmZhX2lvaW1fc3BfcyAqKSBiZmFfbWVtaW5mb19rdmEobWluZm8pOworCWZjcGltLT5pb2ltX3NwX2FyciA9IGlvc3A7CisJYmZhX21lbWluZm9fa3ZhKG1pbmZvKSA9ICh1OCAqKSAoaW9zcCArIGZjcGltLT5udW1faW9pbV9yZXFzKTsKKworCS8qKgorCSAqIENsYWltIERNQSBtZW1vcnkgZm9yIHBlciBJTyBzZW5zZSBkYXRhLgorCSAqLworCXNuc2J1ZnN6ID0gZmNwaW0tPm51bV9pb2ltX3JlcXMgKiBCRklfSU9JTV9TTlNMRU47CisJZmNwaW0tPnNuc2Jhc2UucGEgID0gYmZhX21lbWluZm9fZG1hX3BoeXMobWluZm8pOworCWJmYV9tZW1pbmZvX2RtYV9waHlzKG1pbmZvKSArPSBzbnNidWZzejsKKworCWZjcGltLT5zbnNiYXNlLmt2YSA9IGJmYV9tZW1pbmZvX2RtYV92aXJ0KG1pbmZvKTsKKwliZmFfbWVtaW5mb19kbWFfdmlydChtaW5mbykgKz0gc25zYnVmc3o7CisJc25zaW5mbyA9IGZjcGltLT5zbnNiYXNlLmt2YTsKKwliZmFfaW9jZmNfc2V0X3Nuc2Jhc2UoZmNwaW0tPmJmYSwgZmNwaW0tPnNuc2Jhc2UucGEpOworCisJLyoqCisJICogSW5pdGlhbGl6ZSBpb2ltIGZyZWUgcXVldWVzCisJICovCisJSU5JVF9MSVNUX0hFQUQoJmZjcGltLT5pb2ltX2ZyZWVfcSk7CisJSU5JVF9MSVNUX0hFQUQoJmZjcGltLT5pb2ltX3Jlc2ZyZWVfcSk7CisJSU5JVF9MSVNUX0hFQUQoJmZjcGltLT5pb2ltX2NvbXBfcSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgZmNwaW0tPm51bV9pb2ltX3JlcXM7CisJICAgICBpKyssIGlvaW0rKywgaW9zcCsrLCBzbnNpbmZvICs9IEJGSV9JT0lNX1NOU0xFTikgeworCQkvKgorCQkgKiBpbml0aWFsaXplIElPSU0KKwkJICovCisJCWJmYV9vc19tZW1zZXQoaW9pbSwgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfaW9pbV9zKSk7CisJCWlvaW0tPmlvdGFnICAgPSBpOworCQlpb2ltLT5iZmEgICAgID0gZmNwaW0tPmJmYTsKKwkJaW9pbS0+ZmNwaW0gICA9IGZjcGltOworCQlpb2ltLT5pb3NwICAgID0gaW9zcDsKKwkJaW9zcC0+c25zaW5mbyA9IHNuc2luZm87CisJCUlOSVRfTElTVF9IRUFEKCZpb2ltLT5zZ3BnX3EpOworCQliZmFfcmVxcV93aW5pdCgmaW9pbS0+aW9zcC0+cmVxcV93YWl0LAorCQkJCSAgIGJmYV9pb2ltX3FyZXN1bWUsIGlvaW0pOworCQliZmFfc2dwZ193aW5pdCgmaW9pbS0+aW9zcC0+c2dwZ193cWUsCisJCQkJICAgYmZhX2lvaW1fc2dwZ19hbGxvY2VkLCBpb2ltKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShpb2ltLCBiZmFfaW9pbV9zbV91bmluaXQpOworCisJCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLCAmZmNwaW0tPmlvaW1fZnJlZV9xKTsKKwl9Cit9CisKKy8qKgorICogRHJpdmVyIGRldGFjaCB0aW1lIGNhbGwuCisgKi8KK3ZvaWQKK2JmYV9pb2ltX2RldGFjaChzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSkKK3sKK30KKwordm9pZAorYmZhX2lvaW1faXNyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZpX21zZ19zICptKQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCXN0cnVjdCBiZmlfaW9pbV9yc3BfcyAqcnNwID0gKHN0cnVjdCBiZmlfaW9pbV9yc3BfcyAqKSBtOworCXN0cnVjdCBiZmFfaW9pbV9zICppb2ltOworCXUxNiAgICAgICAgaW90YWc7CisJZW51bSBiZmFfaW9pbV9ldmVudCBldnQgPSBCRkFfSU9JTV9TTV9DT01QOworCisJaW90YWcgPSBiZmFfb3NfbnRvaHMocnNwLT5pb190YWcpOworCisJaW9pbSA9IEJGQV9JT0lNX0ZST01fVEFHKGZjcGltLCBpb3RhZyk7CisJYmZhX2Fzc2VydChpb2ltLT5pb3RhZyA9PSBpb3RhZyk7CisKKwliZmFfdHJjKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCWJmYV90cmMoaW9pbS0+YmZhLCByc3AtPmlvX3N0YXR1cyk7CisJYmZhX3RyYyhpb2ltLT5iZmEsIHJzcC0+cmV1c2VfaW9fdGFnKTsKKworCWlmIChiZmFfc21fY21wX3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX2FjdGl2ZSkpCisJCWJmYV9vc19hc3NpZ24oaW9pbS0+aW9zcC0+Y29tcF9yc3Btc2csICptKTsKKworCXN3aXRjaCAocnNwLT5pb19zdGF0dXMpIHsKKwljYXNlIEJGSV9JT0lNX1NUU19PSzoKKwkJYmZhX2ZjcGltX3N0YXRzKGZjcGltLCBpb2NvbXBfb2spOworCQlpZiAocnNwLT5yZXVzZV9pb190YWcgPT0gMCkKKwkJCWV2dCA9IEJGQV9JT0lNX1NNX0RPTkU7CisJCWVsc2UKKwkJCWV2dCA9IEJGQV9JT0lNX1NNX0NPTVA7CisJCWJyZWFrOworCisJY2FzZSBCRklfSU9JTV9TVFNfVElNRURPVVQ6CisJY2FzZSBCRklfSU9JTV9TVFNfQUJPUlRFRDoKKwkJcnNwLT5pb19zdGF0dXMgPSBCRklfSU9JTV9TVFNfQUJPUlRFRDsKKwkJYmZhX2ZjcGltX3N0YXRzKGZjcGltLCBpb2NvbXBfYWJvcnRlZCk7CisJCWlmIChyc3AtPnJldXNlX2lvX3RhZyA9PSAwKQorCQkJZXZ0ID0gQkZBX0lPSU1fU01fRE9ORTsKKwkJZWxzZQorCQkJZXZ0ID0gQkZBX0lPSU1fU01fQ09NUDsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9JT0lNX1NUU19QUk9UT19FUlI6CisJCWJmYV9mY3BpbV9zdGF0cyhmY3BpbSwgaW9jb21fcHJvdG9fZXJyKTsKKwkJYmZhX2Fzc2VydChyc3AtPnJldXNlX2lvX3RhZyk7CisJCWV2dCA9IEJGQV9JT0lNX1NNX0NPTVA7CisJCWJyZWFrOworCisJY2FzZSBCRklfSU9JTV9TVFNfU1FFUl9ORUVERUQ6CisJCWJmYV9mY3BpbV9zdGF0cyhmY3BpbSwgaW9jb21fc3Flcl9uZWVkZWQpOworCQliZmFfYXNzZXJ0KHJzcC0+cmV1c2VfaW9fdGFnID09IDApOworCQlldnQgPSBCRkFfSU9JTV9TTV9TUVJFVFJZOworCQlicmVhazsKKworCWNhc2UgQkZJX0lPSU1fU1RTX1JFU19GUkVFOgorCQliZmFfZmNwaW1fc3RhdHMoZmNwaW0sIGlvY29tX3Jlc19mcmVlKTsKKwkJZXZ0ID0gQkZBX0lPSU1fU01fRlJFRTsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9JT0lNX1NUU19IT1NUX0FCT1JURUQ6CisJCWJmYV9mY3BpbV9zdGF0cyhmY3BpbSwgaW9jb21faG9zdGFicnRzKTsKKwkJaWYgKHJzcC0+YWJvcnRfdGFnICE9IGlvaW0tPmFib3J0X3RhZykgeworCQkJYmZhX3RyYyhpb2ltLT5iZmEsIHJzcC0+YWJvcnRfdGFnKTsKKwkJCWJmYV90cmMoaW9pbS0+YmZhLCBpb2ltLT5hYm9ydF90YWcpOworCQkJcmV0dXJuOworCQl9CisKKwkJaWYgKHJzcC0+cmV1c2VfaW9fdGFnKQorCQkJZXZ0ID0gQkZBX0lPSU1fU01fQUJPUlRfQ09NUDsKKwkJZWxzZQorCQkJZXZ0ID0gQkZBX0lPSU1fU01fQUJPUlRfRE9ORTsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9JT0lNX1NUU19VVEFHOgorCQliZmFfZmNwaW1fc3RhdHMoZmNwaW0sIGlvY29tX3V0YWdzKTsKKwkJZXZ0ID0gQkZBX0lPSU1fU01fQ09NUF9VVEFHOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorCisJYmZhX3NtX3NlbmRfZXZlbnQoaW9pbSwgZXZ0KTsKK30KKwordm9pZAorYmZhX2lvaW1fZ29vZF9jb21wX2lzcihzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmaV9tc2dfcyAqbSkKK3sKKwlzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSA9IEJGQV9GQ1BJTV9NT0QoYmZhKTsKKwlzdHJ1Y3QgYmZpX2lvaW1fcnNwX3MgKnJzcCA9IChzdHJ1Y3QgYmZpX2lvaW1fcnNwX3MgKikgbTsKKwlzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbTsKKwl1MTYgICAgICAgIGlvdGFnOworCisJaW90YWcgPSBiZmFfb3NfbnRvaHMocnNwLT5pb190YWcpOworCisJaW9pbSA9IEJGQV9JT0lNX0ZST01fVEFHKGZjcGltLCBpb3RhZyk7CisJYmZhX2Fzc2VydChpb2ltLT5pb3RhZyA9PSBpb3RhZyk7CisKKwliZmFfdHJjX2ZwKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX0NPTVBfR09PRCk7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IGl0bmltIHRvIGNsZWFuIHVwIElPIHdoaWxlIGdvaW5nIG9mZmxpbmUuCisgKi8KK3ZvaWQKK2JmYV9pb2ltX2NsZWFudXAoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0pCit7CisJYmZhX3RyYyhpb2ltLT5iZmEsIGlvaW0tPmlvdGFnKTsKKwliZmFfZmNwaW1fc3RhdHMoaW9pbS0+ZmNwaW0sIGlvX2NsZWFudXBzKTsKKworCWlvaW0tPmlvc3AtPnRza2ltID0gTlVMTDsKKwliZmFfc21fc2VuZF9ldmVudChpb2ltLCBCRkFfSU9JTV9TTV9DTEVBTlVQKTsKK30KKwordm9pZAorYmZhX2lvaW1fY2xlYW51cF90bShzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSwgc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSkKK3sKKwliZmFfdHJjKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCWJmYV9mY3BpbV9zdGF0cyhpb2ltLT5mY3BpbSwgaW9fdG1hYm9ydHMpOworCisJaW9pbS0+aW9zcC0+dHNraW0gPSB0c2tpbTsKKwliZmFfc21fc2VuZF9ldmVudChpb2ltLCBCRkFfSU9JTV9TTV9DTEVBTlVQKTsKK30KKworLyoqCisgKiBJT0MgZmFpbHVyZSBoYW5kbGluZy4KKyAqLwordm9pZAorYmZhX2lvaW1faW9jZGlzYWJsZShzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSkKK3sKKwliZmFfc21fc2VuZF9ldmVudChpb2ltLCBCRkFfSU9JTV9TTV9IV0ZBSUwpOworfQorCisvKioKKyAqIElPIG9mZmxpbmUgVE9WIHBvcHBlZC4gRmFpbCB0aGUgcGVuZGluZyBJTy4KKyAqLwordm9pZAorYmZhX2lvaW1fdG92KHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKQoreworCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX0lPVE9WKTsKK30KKworCisKKy8qKgorICogIGJmYV9pb2ltX2FwaQorICovCisKKy8qKgorICogQWxsb2NhdGUgSU9JTSByZXNvdXJjZSBmb3IgaW5pdGlhdG9yIG1vZGUgSS9PIHJlcXVlc3QuCisgKi8KK3N0cnVjdCBiZmFfaW9pbV9zICoKK2JmYV9pb2ltX2FsbG9jKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhZF9pb2ltX3MgKmRpbywKKwkJc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwgdTE2IG5zZ2VzKQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCXN0cnVjdCBiZmFfaW9pbV9zICppb2ltOworCisJLyoqCisJICogYWxvY2F0ZSBJT0lNIHJlc291cmNlCisJICovCisJYmZhX3FfZGVxKCZmY3BpbS0+aW9pbV9mcmVlX3EsICZpb2ltKTsKKwlpZiAoIWlvaW0pIHsKKwkJYmZhX2ZjcGltX3N0YXRzKGZjcGltLCBub19pb3RhZ3MpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwlpb2ltLT5kaW8gPSBkaW87CisJaW9pbS0+aXRuaW0gPSBpdG5pbTsKKwlpb2ltLT5uc2dlcyA9IG5zZ2VzOworCWlvaW0tPm5zZ3BncyA9IDA7CisKKwliZmFfc3RhdHMoZmNwaW0sIHRvdGFsX2lvcyk7CisJYmZhX3N0YXRzKGl0bmltLCBpb3MpOworCWZjcGltLT5pb3NfYWN0aXZlKys7CisKKwlsaXN0X2FkZF90YWlsKCZpb2ltLT5xZSwgJml0bmltLT5pb19xKTsKKwliZmFfdHJjX2ZwKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCisJcmV0dXJuIGlvaW07Cit9CisKK3ZvaWQKK2JmYV9pb2ltX2ZyZWUoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0pCit7CisJc3RydWN0IGJmYV9mY3BpbV9tb2RfcyAqZmNwaW0gPSBpb2ltLT5mY3BpbTsKKworCWJmYV90cmNfZnAoaW9pbS0+YmZhLCBpb2ltLT5pb3RhZyk7CisJYmZhX2Fzc2VydF9mcChiZmFfc21fY21wX3N0YXRlKGlvaW0sIGJmYV9pb2ltX3NtX3VuaW5pdCkpOworCisJYmZhX2Fzc2VydF9mcChsaXN0X2VtcHR5KCZpb2ltLT5zZ3BnX3EpCisJCSAgIHx8IChpb2ltLT5uc2dlcyA+IEJGSV9TR0VfSU5MSU5FKSk7CisKKwlpZiAoaW9pbS0+bnNncGdzID4gMCkKKwkJYmZhX3NncGdfbWZyZWUoaW9pbS0+YmZhLCAmaW9pbS0+c2dwZ19xLCBpb2ltLT5uc2dwZ3MpOworCisJYmZhX3N0YXRzKGlvaW0tPml0bmltLCBpb19jb21wcyk7CisJZmNwaW0tPmlvc19hY3RpdmUtLTsKKworCWxpc3RfZGVsKCZpb2ltLT5xZSk7CisJbGlzdF9hZGRfdGFpbCgmaW9pbS0+cWUsICZmY3BpbS0+aW9pbV9mcmVlX3EpOworfQorCit2b2lkCitiZmFfaW9pbV9zdGFydChzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbSkKK3sKKwliZmFfdHJjX2ZwKGlvaW0tPmJmYSwgaW9pbS0+aW90YWcpOworCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX1NUQVJUKTsKK30KKworLyoqCisgKiBEcml2ZXIgSS9PIGFib3J0IHJlcXVlc3QuCisgKi8KK3ZvaWQKK2JmYV9pb2ltX2Fib3J0KHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKQoreworCWJmYV90cmMoaW9pbS0+YmZhLCBpb2ltLT5pb3RhZyk7CisJYmZhX2ZjcGltX3N0YXRzKGlvaW0tPmZjcGltLCBpb19hYm9ydHMpOworCWJmYV9zbV9zZW5kX2V2ZW50KGlvaW0sIEJGQV9JT0lNX1NNX0FCT1JUKTsKK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9pdG5pbS5jIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaXRuaW0uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40ZDVjNjFhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfaXRuaW0uYwpAQCAtMCwwICsxLDEwODggQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9mY3BpbS5oPgorI2luY2x1ZGUgImJmYV9mY3BpbV9wcml2LmgiCisKK0JGQV9UUkNfRklMRShIQUwsIElUTklNKTsKKworI2RlZmluZSBCRkFfSVROSU1fRlJPTV9UQUcoX2ZjcGltLCBfdGFnKQkJCQlcCisJKChfZmNwaW0pLT5pdG5pbV9hcnIgKyAoKF90YWcpICYgKChfZmNwaW0pLT5udW1faXRuaW1zIC0gMSkpKQorCisjZGVmaW5lIGJmYV9mY3BpbV9hZGRpdG4oX19pdG5pbSkJCQkJCVwKKwlsaXN0X2FkZF90YWlsKCYoX19pdG5pbSktPnFlLCAmKF9faXRuaW0pLT5mY3BpbS0+aXRuaW1fcSkKKyNkZWZpbmUgYmZhX2ZjcGltX2RlbGl0bihfX2l0bmltKQlkbyB7CQkJCVwKKwliZmFfYXNzZXJ0KGJmYV9xX2lzX29uX3EoJihfX2l0bmltKS0+ZmNwaW0tPml0bmltX3EsIF9faXRuaW0pKTsgICAgICBcCisJbGlzdF9kZWwoJihfX2l0bmltKS0+cWUpOyAgICAgIFwKKwliZmFfYXNzZXJ0KGxpc3RfZW1wdHkoJihfX2l0bmltKS0+aW9fcSkpOyAgICAgIFwKKwliZmFfYXNzZXJ0KGxpc3RfZW1wdHkoJihfX2l0bmltKS0+aW9fY2xlYW51cF9xKSk7ICAgICAgXAorCWJmYV9hc3NlcnQobGlzdF9lbXB0eSgmKF9faXRuaW0pLT5wZW5kaW5nX3EpKTsgICAgICBcCit9IHdoaWxlICgwKQorCisjZGVmaW5lIGJmYV9pdG5pbV9vbmxpbmVfY2IoX19pdG5pbSkgZG8gewkJCQlcCisJaWYgKChfX2l0bmltKS0+YmZhLT5mY3MpCQkJCQlcCisJCWJmYV9jYl9pdG5pbV9vbmxpbmUoKF9faXRuaW0pLT5kaXRuKTsgICAgICBcCisJZWxzZSB7CQkJCQkJCQlcCisJCWJmYV9jYl9xdWV1ZSgoX19pdG5pbSktPmJmYSwgJihfX2l0bmltKS0+aGNiX3FlLAlcCisJCV9fYmZhX2NiX2l0bmltX29ubGluZSwgKF9faXRuaW0pKTsgICAgICBcCisJfQkJCQkJCQkJXAorfSB3aGlsZSAoMCkKKworI2RlZmluZSBiZmFfaXRuaW1fb2ZmbGluZV9jYihfX2l0bmltKSBkbyB7CQkJCVwKKwlpZiAoKF9faXRuaW0pLT5iZmEtPmZjcykJCQkJCVwKKwkJYmZhX2NiX2l0bmltX29mZmxpbmUoKF9faXRuaW0pLT5kaXRuKTsgICAgICBcCisJZWxzZSB7CQkJCQkJCQlcCisJCWJmYV9jYl9xdWV1ZSgoX19pdG5pbSktPmJmYSwgJihfX2l0bmltKS0+aGNiX3FlLAlcCisJCV9fYmZhX2NiX2l0bmltX29mZmxpbmUsIChfX2l0bmltKSk7ICAgICAgXAorCX0JCQkJCQkJCVwKK30gd2hpbGUgKDApCisKKyNkZWZpbmUgYmZhX2l0bmltX3NsZXJfY2IoX19pdG5pbSkgZG8gewkJCQkJXAorCWlmICgoX19pdG5pbSktPmJmYS0+ZmNzKQkJCQkJXAorCQliZmFfY2JfaXRuaW1fc2xlcigoX19pdG5pbSktPmRpdG4pOyAgICAgIFwKKwllbHNlIHsJCQkJCQkJCVwKKwkJYmZhX2NiX3F1ZXVlKChfX2l0bmltKS0+YmZhLCAmKF9faXRuaW0pLT5oY2JfcWUsCVwKKwkJX19iZmFfY2JfaXRuaW1fc2xlciwgKF9faXRuaW0pKTsgICAgICBcCisJfQkJCQkJCQkJXAorfSB3aGlsZSAoMCkKKworLyoKKyAqIGZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1faW9jZGlzYWJsZV9jbGVhbnVwKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pOworc3RhdGljIGJmYV9ib29sZWFuX3QgYmZhX2l0bmltX3NlbmRfZndjcmVhdGUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSk7CitzdGF0aWMgYmZhX2Jvb2xlYW5fdCBiZmFfaXRuaW1fc2VuZF9md2RlbGV0ZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fY2xlYW5wX2NvbXAodm9pZCAqaXRuaW1fY2JhcmcpOworc3RhdGljIHZvaWQgICAgIGJmYV9pdG5pbV9jbGVhbnVwKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pOworc3RhdGljIHZvaWQgICAgIF9fYmZhX2NiX2l0bmltX29ubGluZSh2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CitzdGF0aWMgdm9pZCAgICAgX19iZmFfY2JfaXRuaW1fb2ZmbGluZSh2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CitzdGF0aWMgdm9pZCAgICAgX19iZmFfY2JfaXRuaW1fc2xlcih2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2l0bmltX2lvdG92X29ubGluZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1faW90b3ZfY2xlYW51cChzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1faW90b3Yodm9pZCAqaXRuaW1fYXJnKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1faW90b3Zfc3RhcnQoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2l0bmltX2lvdG92X3N0b3Aoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2l0bmltX2lvdG92X2RlbGV0ZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltKTsKKworLyoqCisgKiAgYmZhX2l0bmltX3NtIEJGQSBpdG5pbSBzdGF0ZSBtYWNoaW5lCisgKi8KKworCitlbnVtIGJmYV9pdG5pbV9ldmVudCB7CisJQkZBX0lUTklNX1NNX0NSRUFURSA9IDEsCS8qICBpdG5pbSBpcyBjcmVhdGVkICovCisJQkZBX0lUTklNX1NNX09OTElORSA9IDIsCS8qICBpdG5pbSBpcyBvbmxpbmUgKi8KKwlCRkFfSVROSU1fU01fT0ZGTElORSA9IDMsCS8qICBpdG5pbSBpcyBvZmZsaW5lICovCisJQkZBX0lUTklNX1NNX0ZXUlNQID0gNCwJCS8qICBmaXJtd2FyZSByZXNwb25zZSAqLworCUJGQV9JVE5JTV9TTV9ERUxFVEUgPSA1LAkvKiAgZGVsZXRpbmcgYW4gZXhpc3RpbmcgaXRuaW0gKi8KKwlCRkFfSVROSU1fU01fQ0xFQU5VUCA9IDYsCS8qICBJTyBjbGVhbnVwIGNvbXBsZXRpb24gKi8KKwlCRkFfSVROSU1fU01fU0xFUiA9IDcsCQkvKiAgc2Vjb25kIGxldmVsIGVycm9yIHJlY292ZXJ5ICovCisJQkZBX0lUTklNX1NNX0hXRkFJTCA9IDgsCS8qICBJT0MgaC93IGZhaWx1cmUgZXZlbnQgKi8KKwlCRkFfSVROSU1fU01fUVJFU1VNRSA9IDksCS8qICBxdWV1ZSBzcGFjZSBhdmFpbGFibGUgKi8KK307CisKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fc21fdW5pbml0KHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJCWVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fc21fY3JlYXRlZChzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCQkgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pdG5pbV9zbV9md2NyZWF0ZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCQkgIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkCWJmYV9pdG5pbV9zbV9kZWxldGVfcGVuZGluZyhzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCWVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fc21fb25saW5lKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJCWVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fc21fc2xlcihzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCSAgICAgIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fc21fY2xlYW51cF9vZmZsaW5lKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJCQkgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pdG5pbV9zbV9jbGVhbnVwX2RlbGV0ZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCQkJZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pdG5pbV9zbV9md2RlbGV0ZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCQkgIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCQkgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pdG5pbV9zbV9pb2NkaXNhYmxlKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJCSAgICBlbnVtIGJmYV9pdG5pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2l0bmltX3NtX2RlbGV0aW5nKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJCSAgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9pdG5pbV9zbV9md2NyZWF0ZV9xZnVsbChzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJCQkgIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfaXRuaW1fc21fZndkZWxldGVfcWZ1bGwoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwKKwkJCQkJICBlbnVtIGJmYV9pdG5pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2l0bmltX3NtX2RlbGV0aW5nX3FmdWxsKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJCSAgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpOworCisvKioKKyAqIAkJQmVnaW5uaW5nL3VuYWxsb2NhdGVkIHN0YXRlIC0gbm8gZXZlbnRzIGV4cGVjdGVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3NtX3VuaW5pdChzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLCBlbnVtIGJmYV9pdG5pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGl0bmltLT5iZmEsIGl0bmltLT5ycG9ydC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKGl0bmltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JVE5JTV9TTV9DUkVBVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9jcmVhdGVkKTsKKwkJaXRuaW0tPmlzX29ubGluZSA9IEJGQV9GQUxTRTsKKwkJYmZhX2ZjcGltX2FkZGl0bihpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlCZWdpbm5pbmcgc3RhdGUsIG9ubHkgb25saW5lIGV2ZW50IGV4cGVjdGVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3NtX2NyZWF0ZWQoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBpdG5pbS0+cnBvcnQtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSVROSU1fU01fT05MSU5FOgorCQlpZiAoYmZhX2l0bmltX3NlbmRfZndjcmVhdGUoaXRuaW0pKQorCQkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2Z3Y3JlYXRlKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2Z3Y3JlYXRlX3FmdWxsKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV91bmluaXQpOworCQliZmFfZmNwaW1fZGVsaXRuKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9pb2NkaXNhYmxlKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCVdhaXRpbmcgZm9yIGl0bmltIGNyZWF0ZSByZXNwb25zZSBmcm9tIGZpcm13YXJlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3NtX2Z3Y3JlYXRlKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaXRuaW0tPmJmYSwgaXRuaW0tPnJwb3J0LT5ycG9ydF90YWcpOworCWJmYV90cmMoaXRuaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lUTklNX1NNX0ZXUlNQOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fb25saW5lKTsKKwkJaXRuaW0tPmlzX29ubGluZSA9IEJGQV9UUlVFOworCQliZmFfaXRuaW1faW90b3Zfb25saW5lKGl0bmltKTsKKwkJYmZhX2l0bmltX29ubGluZV9jYihpdG5pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZGVsZXRlX3BlbmRpbmcpOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX09GRkxJTkU6CisJCWlmIChiZmFfaXRuaW1fc2VuZF9md2RlbGV0ZShpdG5pbSkpCisJCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZndkZWxldGUpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZndkZWxldGVfcWZ1bGwpOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2lvY2Rpc2FibGUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3NtX2Z3Y3JlYXRlX3FmdWxsKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQllbnVtIGJmYV9pdG5pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGl0bmltLT5iZmEsIGl0bmltLT5ycG9ydC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKGl0bmltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JVE5JTV9TTV9RUkVTVU1FOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZndjcmVhdGUpOworCQliZmFfaXRuaW1fc2VuZF9md2NyZWF0ZShpdG5pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fdW5pbml0KTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmaXRuaW0tPnJlcXFfd2FpdCk7CisJCWJmYV9mY3BpbV9kZWxpdG4oaXRuaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9vZmZsaW5lKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmaXRuaW0tPnJlcXFfd2FpdCk7CisJCWJmYV9pdG5pbV9vZmZsaW5lX2NiKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9pb2NkaXNhYmxlKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmaXRuaW0tPnJlcXFfd2FpdCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCVdhaXRpbmcgZm9yIGl0bmltIGNyZWF0ZSByZXNwb25zZSBmcm9tIGZpcm13YXJlLCBhIGRlbGV0ZSBpcyBwZW5kaW5nLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3NtX2RlbGV0ZV9wZW5kaW5nKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBpdG5pbS0+cnBvcnQtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSVROSU1fU01fRldSU1A6CisJCWlmIChiZmFfaXRuaW1fc2VuZF9md2RlbGV0ZShpdG5pbSkpCisJCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZGVsZXRpbmcpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZGVsZXRpbmdfcWZ1bGwpOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX3VuaW5pdCk7CisJCWJmYV9mY3BpbV9kZWxpdG4oaXRuaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJT25saW5lIHN0YXRlIC0gbm9ybWFsIHBhcmtpbmcgc3RhdGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1fc21fb25saW5lKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaXRuaW0tPmJmYSwgaXRuaW0tPnJwb3J0LT5ycG9ydF90YWcpOworCWJmYV90cmMoaXRuaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lUTklNX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9jbGVhbnVwX29mZmxpbmUpOworCQlpdG5pbS0+aXNfb25saW5lID0gQkZBX0ZBTFNFOworCQliZmFfaXRuaW1faW90b3Zfc3RhcnQoaXRuaW0pOworCQliZmFfaXRuaW1fY2xlYW51cChpdG5pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fY2xlYW51cF9kZWxldGUpOworCQlpdG5pbS0+aXNfb25saW5lID0gQkZBX0ZBTFNFOworCQliZmFfaXRuaW1fY2xlYW51cChpdG5pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fU0xFUjoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX3NsZXIpOworCQlpdG5pbS0+aXNfb25saW5lID0gQkZBX0ZBTFNFOworCQliZmFfaXRuaW1faW90b3Zfc3RhcnQoaXRuaW0pOworCQliZmFfaXRuaW1fc2xlcl9jYihpdG5pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21faW9jZGlzYWJsZSk7CisJCWl0bmltLT5pc19vbmxpbmUgPSBCRkFfRkFMU0U7CisJCWJmYV9pdG5pbV9pb3Rvdl9zdGFydChpdG5pbSk7CisJCWJmYV9pdG5pbV9pb2NkaXNhYmxlX2NsZWFudXAoaXRuaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJU2Vjb25kIGxldmVsIGVycm9yIHJlY292ZXJ5IG5lZWQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1fc21fc2xlcihzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLCBlbnVtIGJmYV9pdG5pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGl0bmltLT5iZmEsIGl0bmltLT5ycG9ydC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKGl0bmltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JVE5JTV9TTV9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fY2xlYW51cF9vZmZsaW5lKTsKKwkJYmZhX2l0bmltX2NsZWFudXAoaXRuaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2NsZWFudXBfZGVsZXRlKTsKKwkJYmZhX2l0bmltX2NsZWFudXAoaXRuaW0pOworCQliZmFfaXRuaW1faW90b3ZfZGVsZXRlKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9pb2NkaXNhYmxlKTsKKwkJYmZhX2l0bmltX2lvY2Rpc2FibGVfY2xlYW51cChpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlHb2luZyBvZmZsaW5lLiBXYWl0aW5nIGZvciBhY3RpdmUgSU8gY2xlYW51cC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pdG5pbV9zbV9jbGVhbnVwX29mZmxpbmUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwKKwkJCQkgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBpdG5pbS0+cnBvcnQtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSVROSU1fU01fQ0xFQU5VUDoKKwkJaWYgKGJmYV9pdG5pbV9zZW5kX2Z3ZGVsZXRlKGl0bmltKSkKKwkJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9md2RlbGV0ZSk7CisJCWVsc2UKKwkJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9md2RlbGV0ZV9xZnVsbCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fY2xlYW51cF9kZWxldGUpOworCQliZmFfaXRuaW1faW90b3ZfZGVsZXRlKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9pb2NkaXNhYmxlKTsKKwkJYmZhX2l0bmltX2lvY2Rpc2FibGVfY2xlYW51cChpdG5pbSk7CisJCWJmYV9pdG5pbV9vZmZsaW5lX2NiKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9TTEVSOgorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJRGVsZXRpbmcgaXRuaW0uIFdhaXRpbmcgZm9yIGFjdGl2ZSBJTyBjbGVhbnVwLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3NtX2NsZWFudXBfZGVsZXRlKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBpdG5pbS0+cnBvcnQtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSVROSU1fU01fQ0xFQU5VUDoKKwkJaWYgKGJmYV9pdG5pbV9zZW5kX2Z3ZGVsZXRlKGl0bmltKSkKKwkJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9kZWxldGluZyk7CisJCWVsc2UKKwkJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9kZWxldGluZ19xZnVsbCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21faW9jZGlzYWJsZSk7CisJCWJmYV9pdG5pbV9pb2NkaXNhYmxlX2NsZWFudXAoaXRuaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIFJwb3J0IG9mZmxpbmUuIEZpbXJ3YXJlIGl0bmltIGlzIGJlaW5nIGRlbGV0ZWQgLSBhd2FpdGluZyBmL3cgcmVzcG9uc2UuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1fc21fZndkZWxldGUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBpdG5pbS0+cnBvcnQtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSVROSU1fU01fRldSU1A6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9vZmZsaW5lKTsKKwkJYmZhX2l0bmltX29mZmxpbmVfY2IoaXRuaW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2RlbGV0aW5nKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9pb2NkaXNhYmxlKTsKKwkJYmZhX2l0bmltX29mZmxpbmVfY2IoaXRuaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3NtX2Z3ZGVsZXRlX3FmdWxsKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQllbnVtIGJmYV9pdG5pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGl0bmltLT5iZmEsIGl0bmltLT5ycG9ydC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKGl0bmltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9JVE5JTV9TTV9RUkVTVU1FOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZndkZWxldGUpOworCQliZmFfaXRuaW1fc2VuZF9md2RlbGV0ZShpdG5pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZGVsZXRpbmdfcWZ1bGwpOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2lvY2Rpc2FibGUpOworCQliZmFfcmVxcV93Y2FuY2VsKCZpdG5pbS0+cmVxcV93YWl0KTsKKwkJYmZhX2l0bmltX29mZmxpbmVfY2IoaXRuaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJT2ZmbGluZSBzdGF0ZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pdG5pbV9zbV9vZmZsaW5lKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaXRuaW0tPmJmYSwgaXRuaW0tPnJwb3J0LT5ycG9ydF90YWcpOworCWJmYV90cmMoaXRuaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lUTklNX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX3VuaW5pdCk7CisJCWJmYV9pdG5pbV9pb3Rvdl9kZWxldGUoaXRuaW0pOworCQliZmFfZmNwaW1fZGVsaXRuKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9PTkxJTkU6CisJCWlmIChiZmFfaXRuaW1fc2VuZF9md2NyZWF0ZShpdG5pbSkpCisJCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZndjcmVhdGUpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fZndjcmVhdGVfcWZ1bGwpOworCQlicmVhazsKKworCWNhc2UgQkZBX0lUTklNX1NNX0hXRkFJTDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2lvY2Rpc2FibGUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJSU9DIGgvdyBmYWlsZWQgc3RhdGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1fc21faW9jZGlzYWJsZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJICAgIGVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaXRuaW0tPmJmYSwgaXRuaW0tPnJwb3J0LT5ycG9ydF90YWcpOworCWJmYV90cmMoaXRuaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lUTklNX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX3VuaW5pdCk7CisJCWJmYV9pdG5pbV9pb3Rvdl9kZWxldGUoaXRuaW0pOworCQliZmFfZmNwaW1fZGVsaXRuKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9PRkZMSU5FOgorCQliZmFfaXRuaW1fb2ZmbGluZV9jYihpdG5pbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfSVROSU1fU01fT05MSU5FOgorCQlpZiAoYmZhX2l0bmltX3NlbmRfZndjcmVhdGUoaXRuaW0pKQorCQkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2Z3Y3JlYXRlKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2Z3Y3JlYXRlX3FmdWxsKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9IV0ZBSUw6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlJdG5pbSBpcyBkZWxldGVkLCB3YWl0aW5nIGZvciBmaXJtd2FyZSByZXNwb25zZSB0byBkZWxldGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1fc21fZGVsZXRpbmcoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwgZW51bSBiZmFfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBpdG5pbS0+cnBvcnQtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhpdG5pbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfSVROSU1fU01fRldSU1A6CisJY2FzZSBCRkFfSVROSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfaXRuaW1fc21fdW5pbml0KTsKKwkJYmZhX2ZjcGltX2RlbGl0bihpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1fc21fZGVsZXRpbmdfcWZ1bGwoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwKKwkJCWVudW0gYmZhX2l0bmltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaXRuaW0tPmJmYSwgaXRuaW0tPnJwb3J0LT5ycG9ydF90YWcpOworCWJmYV90cmMoaXRuaW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lUTklNX1NNX1FSRVNVTUU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9kZWxldGluZyk7CisJCWJmYV9pdG5pbV9zZW5kX2Z3ZGVsZXRlKGl0bmltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9JVE5JTV9TTV9IV0ZBSUw6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV91bmluaXQpOworCQliZmFfcmVxcV93Y2FuY2VsKCZpdG5pbS0+cmVxcV93YWl0KTsKKwkJYmZhX2ZjcGltX2RlbGl0bihpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBiZmFfaXRuaW1fcHJpdmF0ZQorICovCisKKy8qKgorICogCQlJbml0aWF0ZSBjbGVhbnVwIG9mIGFsbCBJT3Mgb24gYW4gSU9DIGZhaWx1cmUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1faW9jZGlzYWJsZV9jbGVhbnVwKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisJc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbTsKKwlzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAqcWUsICpxZW47CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJml0bmltLT50c2tfcSkgeworCQl0c2tpbSA9IChzdHJ1Y3QgYmZhX3Rza2ltX3MgKikgcWU7CisJCWJmYV90c2tpbV9pb2NkaXNhYmxlKHRza2ltKTsKKwl9CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJml0bmltLT5pb19xKSB7CisJCWlvaW0gPSAoc3RydWN0IGJmYV9pb2ltX3MgKikgcWU7CisJCWJmYV9pb2ltX2lvY2Rpc2FibGUoaW9pbSk7CisJfQorCisJLyoqCisJICogRm9yIElPIHJlcXVlc3QgaW4gcGVuZGluZyBxdWV1ZSwgd2UgcHJldGVuZCBhbiBlYXJseSB0aW1lb3V0LgorCSAqLworCWxpc3RfZm9yX2VhY2hfc2FmZShxZSwgcWVuLCAmaXRuaW0tPnBlbmRpbmdfcSkgeworCQlpb2ltID0gKHN0cnVjdCBiZmFfaW9pbV9zICopIHFlOworCQliZmFfaW9pbV90b3YoaW9pbSk7CisJfQorCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZpdG5pbS0+aW9fY2xlYW51cF9xKSB7CisJCWlvaW0gPSAoc3RydWN0IGJmYV9pb2ltX3MgKikgcWU7CisJCWJmYV9pb2ltX2lvY2Rpc2FibGUoaW9pbSk7CisJfQorfQorCisvKioKKyAqIAkJSU8gY2xlYW51cCBjb21wbGV0aW9uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1fY2xlYW5wX2NvbXAodm9pZCAqaXRuaW1fY2JhcmcpCit7CisJc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSA9IGl0bmltX2NiYXJnOworCisJYmZhX3N0YXRzKGl0bmltLCBjbGVhbnVwX2NvbXBzKTsKKwliZmFfc21fc2VuZF9ldmVudChpdG5pbSwgQkZBX0lUTklNX1NNX0NMRUFOVVApOworfQorCisvKioKKyAqIAkJSW5pdGlhdGUgY2xlYW51cCBvZiBhbGwgSU9zLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX2NsZWFudXAoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSkKK3sKKwlzdHJ1Y3QgYmZhX2lvaW1fcyAgKmlvaW07CisJc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAgKnFlLCAqcWVuOworCisJYmZhX3djX2luaXQoJml0bmltLT53YywgYmZhX2l0bmltX2NsZWFucF9jb21wLCBpdG5pbSk7CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJml0bmltLT5pb19xKSB7CisJCWlvaW0gPSAoc3RydWN0IGJmYV9pb2ltX3MgKikgcWU7CisKKwkJLyoqCisJCSAqIE1vdmUgSU8gdG8gYSBjbGVhbnVwIHF1ZXVlIGZyb20gYWN0aXZlIHF1ZXVlIHNvIHRoYXQgYSBsYXRlcgorCQkgKiBUTSB3aWxsIG5vdCBwaWNrdXAgdGhpcyBJTy4KKwkJICovCisJCWxpc3RfZGVsKCZpb2ltLT5xZSk7CisJCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLCAmaXRuaW0tPmlvX2NsZWFudXBfcSk7CisKKwkJYmZhX3djX3VwKCZpdG5pbS0+d2MpOworCQliZmFfaW9pbV9jbGVhbnVwKGlvaW0pOworCX0KKworCWxpc3RfZm9yX2VhY2hfc2FmZShxZSwgcWVuLCAmaXRuaW0tPnRza19xKSB7CisJCXRza2ltID0gKHN0cnVjdCBiZmFfdHNraW1fcyAqKSBxZTsKKwkJYmZhX3djX3VwKCZpdG5pbS0+d2MpOworCQliZmFfdHNraW1fY2xlYW51cCh0c2tpbSk7CisJfQorCisJYmZhX3djX3dhaXQoJml0bmltLT53Yyk7Cit9CisKK3N0YXRpYyB2b2lkCitfX2JmYV9jYl9pdG5pbV9vbmxpbmUodm9pZCAqY2JhcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpCit7CisJc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSA9IGNiYXJnOworCisJaWYgKGNvbXBsZXRlKQorCQliZmFfY2JfaXRuaW1fb25saW5lKGl0bmltLT5kaXRuKTsKK30KKworc3RhdGljIHZvaWQKK19fYmZhX2NiX2l0bmltX29mZmxpbmUodm9pZCAqY2JhcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpCit7CisJc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSA9IGNiYXJnOworCisJaWYgKGNvbXBsZXRlKQorCQliZmFfY2JfaXRuaW1fb2ZmbGluZShpdG5pbS0+ZGl0bik7Cit9CisKK3N0YXRpYyB2b2lkCitfX2JmYV9jYl9pdG5pbV9zbGVyKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0gPSBjYmFyZzsKKworCWlmIChjb21wbGV0ZSkKKwkJYmZhX2NiX2l0bmltX3NsZXIoaXRuaW0tPmRpdG4pOworfQorCisvKioKKyAqIENhbGwgdG8gcmVzdW1lIGFueSBJL08gcmVxdWVzdHMgd2FpdGluZyBmb3Igcm9vbSBpbiByZXF1ZXN0IHF1ZXVlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX3FyZXN1bWUodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSA9IGNiYXJnOworCisJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9JVE5JTV9TTV9RUkVTVU1FKTsKK30KKworCisKKworLyoqCisgKiAgYmZhX2l0bmltX3B1YmxpYworICovCisKK3ZvaWQKK2JmYV9pdG5pbV9pb2RvbmUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSkKK3sKKwliZmFfd2NfZG93bigmaXRuaW0tPndjKTsKK30KKwordm9pZAorYmZhX2l0bmltX3Rza2RvbmUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSkKK3sKKwliZmFfd2NfZG93bigmaXRuaW0tPndjKTsKK30KKwordm9pZAorYmZhX2l0bmltX21lbWluZm8oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKmttX2xlbiwKKwkJdTMyICpkbV9sZW4pCit7CisJLyoqCisJICogSVROIG1lbW9yeQorCSAqLworCSprbV9sZW4gKz0gY2ZnLT5md2NmZy5udW1fcnBvcnRzICogc2l6ZW9mKHN0cnVjdCBiZmFfaXRuaW1fcyk7Cit9CisKK3ZvaWQKK2JmYV9pdG5pbV9hdHRhY2goc3RydWN0IGJmYV9mY3BpbV9tb2RfcyAqZmNwaW0sIHN0cnVjdCBiZmFfbWVtaW5mb19zICptaW5mbykKK3sKKwlzdHJ1Y3QgYmZhX3MgICAgICAqYmZhID0gZmNwaW0tPmJmYTsKKwlzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltOworCWludCAgICAgICAgICAgICBpOworCisJSU5JVF9MSVNUX0hFQUQoJmZjcGltLT5pdG5pbV9xKTsKKworCWl0bmltID0gKHN0cnVjdCBiZmFfaXRuaW1fcyAqKSBiZmFfbWVtaW5mb19rdmEobWluZm8pOworCWZjcGltLT5pdG5pbV9hcnIgPSBpdG5pbTsKKworCWZvciAoaSA9IDA7IGkgPCBmY3BpbS0+bnVtX2l0bmltczsgaSsrLCBpdG5pbSsrKSB7CisJCWJmYV9vc19tZW1zZXQoaXRuaW0sIDAsIHNpemVvZihzdHJ1Y3QgYmZhX2l0bmltX3MpKTsKKwkJaXRuaW0tPmJmYSA9IGJmYTsKKwkJaXRuaW0tPmZjcGltID0gZmNwaW07CisJCWl0bmltLT5yZXFxID0gQkZBX1JFUVFfUU9TX0xPOworCQlpdG5pbS0+cnBvcnQgPSBCRkFfUlBPUlRfRlJPTV9UQUcoYmZhLCBpKTsKKwkJaXRuaW0tPmlvdG92X2FjdGl2ZSA9IEJGQV9GQUxTRTsKKwkJYmZhX3JlcXFfd2luaXQoJml0bmltLT5yZXFxX3dhaXQsIGJmYV9pdG5pbV9xcmVzdW1lLCBpdG5pbSk7CisKKwkJSU5JVF9MSVNUX0hFQUQoJml0bmltLT5pb19xKTsKKwkJSU5JVF9MSVNUX0hFQUQoJml0bmltLT5pb19jbGVhbnVwX3EpOworCQlJTklUX0xJU1RfSEVBRCgmaXRuaW0tPnBlbmRpbmdfcSk7CisJCUlOSVRfTElTVF9IRUFEKCZpdG5pbS0+dHNrX3EpOworCQlJTklUX0xJU1RfSEVBRCgmaXRuaW0tPmRlbGF5X2NvbXBfcSk7CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV91bmluaXQpOworCX0KKworCWJmYV9tZW1pbmZvX2t2YShtaW5mbykgPSAodTggKikgaXRuaW07Cit9CisKK3ZvaWQKK2JmYV9pdG5pbV9pb2NkaXNhYmxlKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisJYmZhX3N0YXRzKGl0bmltLCBpb2NfZGlzYWJsZWQpOworCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfSVROSU1fU01fSFdGQUlMKTsKK30KKworc3RhdGljIGJmYV9ib29sZWFuX3QKK2JmYV9pdG5pbV9zZW5kX2Z3Y3JlYXRlKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisJc3RydWN0IGJmaV9pdG5pbV9jcmVhdGVfcmVxX3MgKm07CisKKwlpdG5pbS0+bXNnX25vKys7CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQoaXRuaW0tPmJmYSwgaXRuaW0tPnJlcXEpOworCWlmICghbSkgeworCQliZmFfcmVxcV93YWl0KGl0bmltLT5iZmEsIGl0bmltLT5yZXFxLCAmaXRuaW0tPnJlcXFfd2FpdCk7CisJCXJldHVybiBCRkFfRkFMU0U7CisJfQorCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19JVE5JTSwgQkZJX0lUTklNX0gySV9DUkVBVEVfUkVRLAorCQkJYmZhX2xwdWlkKGl0bmltLT5iZmEpKTsKKwltLT5md19oYW5kbGUgPSBpdG5pbS0+cnBvcnQtPmZ3X2hhbmRsZTsKKwltLT5jbGFzcyA9IEZDX0NMQVNTXzM7CisJbS0+c2VxX3JlYyA9IGl0bmltLT5zZXFfcmVjOworCW0tPm1zZ19ubyA9IGl0bmltLT5tc2dfbm87CisKKwkvKioKKwkgKiBxdWV1ZSBJL08gbWVzc2FnZSB0byBmaXJtd2FyZQorCSAqLworCWJmYV9yZXFxX3Byb2R1Y2UoaXRuaW0tPmJmYSwgaXRuaW0tPnJlcXEpOworCXJldHVybiBCRkFfVFJVRTsKK30KKworc3RhdGljIGJmYV9ib29sZWFuX3QKK2JmYV9pdG5pbV9zZW5kX2Z3ZGVsZXRlKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisJc3RydWN0IGJmaV9pdG5pbV9kZWxldGVfcmVxX3MgKm07CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQoaXRuaW0tPmJmYSwgaXRuaW0tPnJlcXEpOworCWlmICghbSkgeworCQliZmFfcmVxcV93YWl0KGl0bmltLT5iZmEsIGl0bmltLT5yZXFxLCAmaXRuaW0tPnJlcXFfd2FpdCk7CisJCXJldHVybiBCRkFfRkFMU0U7CisJfQorCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19JVE5JTSwgQkZJX0lUTklNX0gySV9ERUxFVEVfUkVRLAorCQkJYmZhX2xwdWlkKGl0bmltLT5iZmEpKTsKKwltLT5md19oYW5kbGUgPSBpdG5pbS0+cnBvcnQtPmZ3X2hhbmRsZTsKKworCS8qKgorCSAqIHF1ZXVlIEkvTyBtZXNzYWdlIHRvIGZpcm13YXJlCisJICovCisJYmZhX3JlcXFfcHJvZHVjZShpdG5pbS0+YmZhLCBpdG5pbS0+cmVxcSk7CisJcmV0dXJuIEJGQV9UUlVFOworfQorCisvKioKKyAqIENsZWFudXAgYWxsIHBlbmRpbmcgZmFpbGVkIGluZmxpZ2h0IHJlcXVlc3RzLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX2RlbGF5ZWRfY29tcChzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLCBiZmFfYm9vbGVhbl90IGlvdG92KQoreworCXN0cnVjdCBiZmFfaW9pbV9zICppb2ltOworCXN0cnVjdCBsaXN0X2hlYWQgKnFlLCAqcWVuOworCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZpdG5pbS0+ZGVsYXlfY29tcF9xKSB7CisJCWlvaW0gPSAoc3RydWN0IGJmYV9pb2ltX3MgKilxZTsKKwkJYmZhX2lvaW1fZGVsYXllZF9jb21wKGlvaW0sIGlvdG92KTsKKwl9Cit9CisKKy8qKgorICogU3RhcnQgYWxsIHBlbmRpbmcgSU8gcmVxdWVzdHMuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1faW90b3Zfb25saW5lKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisJc3RydWN0IGJmYV9pb2ltX3MgKmlvaW07CisKKwliZmFfaXRuaW1faW90b3Zfc3RvcChpdG5pbSk7CisKKwkvKioKKwkgKiBBYm9ydCBhbGwgaW5mbGlnaHQgSU8gcmVxdWVzdHMgaW4gdGhlIHF1ZXVlCisJICovCisJYmZhX2l0bmltX2RlbGF5ZWRfY29tcChpdG5pbSwgQkZBX0ZBTFNFKTsKKworCS8qKgorCSAqIFN0YXJ0IGFsbCBwZW5kaW5nIElPIHJlcXVlc3RzLgorCSAqLworCXdoaWxlICghbGlzdF9lbXB0eSgmaXRuaW0tPnBlbmRpbmdfcSkpIHsKKwkJYmZhX3FfZGVxKCZpdG5pbS0+cGVuZGluZ19xLCAmaW9pbSk7CisJCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLCAmaXRuaW0tPmlvX3EpOworCQliZmFfaW9pbV9zdGFydChpb2ltKTsKKwl9Cit9CisKKy8qKgorICogRmFpbCBhbGwgcGVuZGluZyBJTyByZXF1ZXN0cworICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX2lvdG92X2NsZWFudXAoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSkKK3sKKwlzdHJ1Y3QgYmZhX2lvaW1fcyAqaW9pbTsKKworCS8qKgorCSAqIEZhaWwgYWxsIGluZmxpZ2h0IElPIHJlcXVlc3RzIGluIHRoZSBxdWV1ZQorCSAqLworCWJmYV9pdG5pbV9kZWxheWVkX2NvbXAoaXRuaW0sIEJGQV9UUlVFKTsKKworCS8qKgorCSAqIEZhaWwgYW55IHBlbmRpbmcgSU8gcmVxdWVzdHMuCisJICovCisJd2hpbGUgKCFsaXN0X2VtcHR5KCZpdG5pbS0+cGVuZGluZ19xKSkgeworCQliZmFfcV9kZXEoJml0bmltLT5wZW5kaW5nX3EsICZpb2ltKTsKKwkJbGlzdF9hZGRfdGFpbCgmaW9pbS0+cWUsICZpb2ltLT5mY3BpbS0+aW9pbV9jb21wX3EpOworCQliZmFfaW9pbV90b3YoaW9pbSk7CisJfQorfQorCisvKioKKyAqIElPIFRPViB0aW1lciBjYWxsYmFjay4gRmFpbCBhbnkgcGVuZGluZyBJTyByZXF1ZXN0cy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9pdG5pbV9pb3Rvdih2b2lkICppdG5pbV9hcmcpCit7CisJc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSA9IGl0bmltX2FyZzsKKworCWl0bmltLT5pb3Rvdl9hY3RpdmUgPSBCRkFfRkFMU0U7CisKKwliZmFfY2JfaXRuaW1fdG92X2JlZ2luKGl0bmltLT5kaXRuKTsKKwliZmFfaXRuaW1faW90b3ZfY2xlYW51cChpdG5pbSk7CisJYmZhX2NiX2l0bmltX3RvdihpdG5pbS0+ZGl0bik7Cit9CisKKy8qKgorICogU3RhcnQgSU8gVE9WIHRpbWVyIGZvciBmYWlsaW5nIGJhY2sgcGVuZGluZyBJTyByZXF1ZXN0cyBpbiBvZmZsaW5lIHN0YXRlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX2lvdG92X3N0YXJ0KHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisJaWYgKGl0bmltLT5mY3BpbS0+cGF0aF90b3YgPiAwKSB7CisKKwkJaXRuaW0tPmlvdG92X2FjdGl2ZSA9IEJGQV9UUlVFOworCQliZmFfYXNzZXJ0KGJmYV9pdG5pbV9ob2xkX2lvKGl0bmltKSk7CisJCWJmYV90aW1lcl9zdGFydChpdG5pbS0+YmZhLCAmaXRuaW0tPnRpbWVyLAorCQkJYmZhX2l0bmltX2lvdG92LCBpdG5pbSwgaXRuaW0tPmZjcGltLT5wYXRoX3Rvdik7CisJfQorfQorCisvKioKKyAqIFN0b3AgSU8gVE9WIHRpbWVyLgorICovCitzdGF0aWMgdm9pZAorYmZhX2l0bmltX2lvdG92X3N0b3Aoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSkKK3sKKwlpZiAoaXRuaW0tPmlvdG92X2FjdGl2ZSkgeworCQlpdG5pbS0+aW90b3ZfYWN0aXZlID0gQkZBX0ZBTFNFOworCQliZmFfdGltZXJfc3RvcCgmaXRuaW0tPnRpbWVyKTsKKwl9Cit9CisKKy8qKgorICogU3RvcCBJTyBUT1YgdGltZXIuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfaXRuaW1faW90b3ZfZGVsZXRlKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisgICAgYmZhX2Jvb2xlYW5fdCBwYXRodG92X2FjdGl2ZSA9IEJGQV9GQUxTRTsKKworICAgIGlmIChpdG5pbS0+aW90b3ZfYWN0aXZlKQorCQlwYXRodG92X2FjdGl2ZSA9IEJGQV9UUlVFOworCisJYmZhX2l0bmltX2lvdG92X3N0b3AoaXRuaW0pOworCWlmIChwYXRodG92X2FjdGl2ZSkKKwkJYmZhX2NiX2l0bmltX3Rvdl9iZWdpbihpdG5pbS0+ZGl0bik7CisJYmZhX2l0bmltX2lvdG92X2NsZWFudXAoaXRuaW0pOworCWlmIChwYXRodG92X2FjdGl2ZSkKKwkJYmZhX2NiX2l0bmltX3RvdihpdG5pbS0+ZGl0bik7Cit9CisKKworCisvKioKKyAqICBiZmFfaXRuaW1fcHVibGljCisgKi8KKworLyoqCisgKiAJCUl0bmltIGludGVycnVwdCBwcm9jZXNzaW5nLgorICovCit2b2lkCitiZmFfaXRuaW1faXNyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZpX21zZ19zICptKQoreworCXN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltID0gQkZBX0ZDUElNX01PRChiZmEpOworCXVuaW9uIGJmaV9pdG5pbV9pMmhfbXNnX3UgbXNnOworCXN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW07CisKKwliZmFfdHJjKGJmYSwgbS0+bWhkci5tc2dfaWQpOworCisJbXNnLm1zZyA9IG07CisKKwlzd2l0Y2ggKG0tPm1oZHIubXNnX2lkKSB7CisJY2FzZSBCRklfSVROSU1fSTJIX0NSRUFURV9SU1A6CisJCWl0bmltID0gQkZBX0lUTklNX0ZST01fVEFHKGZjcGltLAorCQkJCQkgICAgICAgbXNnLmNyZWF0ZV9yc3AtPmJmYV9oYW5kbGUpOworCQliZmFfYXNzZXJ0KG1zZy5jcmVhdGVfcnNwLT5zdGF0dXMgPT0gQkZBX1NUQVRVU19PSyk7CisJCWJmYV9zdGF0cyhpdG5pbSwgY3JlYXRlX2NvbXBzKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9JVE5JTV9TTV9GV1JTUCk7CisJCWJyZWFrOworCisJY2FzZSBCRklfSVROSU1fSTJIX0RFTEVURV9SU1A6CisJCWl0bmltID0gQkZBX0lUTklNX0ZST01fVEFHKGZjcGltLAorCQkJCQkgICAgICAgbXNnLmRlbGV0ZV9yc3AtPmJmYV9oYW5kbGUpOworCQliZmFfYXNzZXJ0KG1zZy5kZWxldGVfcnNwLT5zdGF0dXMgPT0gQkZBX1NUQVRVU19PSyk7CisJCWJmYV9zdGF0cyhpdG5pbSwgZGVsZXRlX2NvbXBzKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9JVE5JTV9TTV9GV1JTUCk7CisJCWJyZWFrOworCisJY2FzZSBCRklfSVROSU1fSTJIX1NMRVJfRVZFTlQ6CisJCWl0bmltID0gQkZBX0lUTklNX0ZST01fVEFHKGZjcGltLAorCQkJCQkgICAgICAgbXNnLnNsZXJfZXZlbnQtPmJmYV9oYW5kbGUpOworCQliZmFfc3RhdHMoaXRuaW0sIHNsZXJfZXZlbnRzKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9JVE5JTV9TTV9TTEVSKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfdHJjKGJmYSwgbS0+bWhkci5tc2dfaWQpOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworCisKKy8qKgorICogIGJmYV9pdG5pbV9hcGkKKyAqLworCitzdHJ1Y3QgYmZhX2l0bmltX3MgKgorYmZhX2l0bmltX2NyZWF0ZShzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydCwgdm9pZCAqZGl0bikKK3sKKwlzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSA9IEJGQV9GQ1BJTV9NT0QoYmZhKTsKKwlzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltOworCisJaXRuaW0gPSBCRkFfSVROSU1fRlJPTV9UQUcoZmNwaW0sIHJwb3J0LT5ycG9ydF90YWcpOworCWJmYV9hc3NlcnQoaXRuaW0tPnJwb3J0ID09IHJwb3J0KTsKKworCWl0bmltLT5kaXRuID0gZGl0bjsKKworCWJmYV9zdGF0cyhpdG5pbSwgY3JlYXRlcyk7CisJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9JVE5JTV9TTV9DUkVBVEUpOworCisJcmV0dXJuIChpdG5pbSk7Cit9CisKK3ZvaWQKK2JmYV9pdG5pbV9kZWxldGUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSkKK3sKKwliZmFfc3RhdHMoaXRuaW0sIGRlbGV0ZXMpOworCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfSVROSU1fU01fREVMRVRFKTsKK30KKwordm9pZAorYmZhX2l0bmltX29ubGluZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLCBiZmFfYm9vbGVhbl90IHNlcV9yZWMpCit7CisJaXRuaW0tPnNlcV9yZWMgPSBzZXFfcmVjOworCWJmYV9zdGF0cyhpdG5pbSwgb25saW5lcyk7CisJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9JVE5JTV9TTV9PTkxJTkUpOworfQorCit2b2lkCitiZmFfaXRuaW1fb2ZmbGluZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltKQoreworCWJmYV9zdGF0cyhpdG5pbSwgb2ZmbGluZXMpOworCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfSVROSU1fU01fT0ZGTElORSk7Cit9CisKKy8qKgorICogUmV0dXJuIHRydWUgaWYgaXRuaW0gaXMgY29uc2lkZXJlZCBvZmZsaW5lIGZvciBob2xkaW5nIG9mZiBJTyByZXF1ZXN0LgorICogSU8gaXMgbm90IGhlbGQgaWYgaXRuaW0gaXMgYmVpbmcgZGVsZXRlZC4KKyAqLworYmZhX2Jvb2xlYW5fdAorYmZhX2l0bmltX2hvbGRfaW8oc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSkKK3sKKwlyZXR1cm4gKAorCQlpdG5pbS0+ZmNwaW0tPnBhdGhfdG92ICYmIGl0bmltLT5pb3Rvdl9hY3RpdmUgJiYKKwkJKGJmYV9zbV9jbXBfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9md2NyZWF0ZSkgfHwKKwkJIGJmYV9zbV9jbXBfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9zbGVyKSB8fAorCQkgYmZhX3NtX2NtcF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2NsZWFudXBfb2ZmbGluZSkgfHwKKwkJIGJmYV9zbV9jbXBfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9md2RlbGV0ZSkgfHwKKwkJIGJmYV9zbV9jbXBfc3RhdGUoaXRuaW0sIGJmYV9pdG5pbV9zbV9vZmZsaW5lKSB8fAorCQkgYmZhX3NtX2NtcF9zdGF0ZShpdG5pbSwgYmZhX2l0bmltX3NtX2lvY2Rpc2FibGUpKQorKTsKK30KKwordm9pZAorYmZhX2l0bmltX2dldF9zdGF0cyhzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCXN0cnVjdCBiZmFfaXRuaW1faGFsX3N0YXRzX3MgKnN0YXRzKQoreworCSpzdGF0cyA9IGl0bmltLT5zdGF0czsKK30KKwordm9pZAorYmZhX2l0bmltX2NsZWFyX3N0YXRzKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pCit7CisJYmZhX29zX21lbXNldCgmaXRuaW0tPnN0YXRzLCAwLCBzaXplb2YoaXRuaW0tPnN0YXRzKSk7Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfbG9nLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9sb2cuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMjczNWU1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfbG9nLmMKQEAgLTAsMCArMSwzNDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2xvZy5jIEJGQSBsb2cgbGlicmFyeQorICovCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisjaW5jbHVkZSA8Y3MvYmZhX2xvZy5oPgorCisvKgorICogZ2xvYmFsIGxvZyBpbmZvIHN0cnVjdHVyZQorICovCitzdHJ1Y3QgYmZhX2xvZ19pbmZvX3MgeworCXUzMiAgICAgICAgc3RhcnRfaWR4OwkvKiAgc3RhcnQgaW5kZXggZm9yIGEgbW9kdWxlICovCisJdTMyICAgICAgICB0b3RhbF9jb3VudDsJLyogIHRvdGFsIGNvdW50IGZvciBhIG1vZHVsZSAqLworCWVudW0gYmZhX2xvZ19zZXZlcml0eSBsZXZlbDsJLyogIGdsb2JhbCBsb2cgbGV2ZWwgKi8KKwliZmFfbG9nX2NiX3QJY2JmbjsJCS8qICBjYWxsYmFjayBmdW5jdGlvbiAqLworfTsKKworc3RhdGljIHN0cnVjdCBiZmFfbG9nX2luZm9fcyBiZmFfbG9nX2luZm9bQkZBX0xPR19NT0RVTEVfSURfTUFYICsgMV07CitzdGF0aWMgdTMyIGJmYV9sb2dfbXNnX3RvdGFsX2NvdW50Oworc3RhdGljIGludCAgICAgIGJmYV9sb2dfaW5pdGlhbGl6ZWQ7CisKK3N0YXRpYyBjaGFyICAgICpiZmFfbG9nX3NldmVyaXR5W10gPQorCXsgIltub25lXSIsICJbY3JpdGljYWxdIiwgIltlcnJvcl0iLCAiW3dhcm5dIiwgIltpbmZvXSIsICIiIH07CisKKy8qKgorICogQkZBIGxvZyBsaWJyYXJ5IGluaXRpYWxpemF0aW9uCisgKgorICogVGhlIGxvZyBsaWJyYXJ5IGluaXRpYWxpemF0aW9uIGluY2x1ZGVzIHRoZSBmb2xsb3dpbmcsCisgKiAgICAtIHNldCBsb2cgaW5zdGFuY2UgbmFtZSBhbmQgY2FsbGJhY2sgZnVuY3Rpb24KKyAqICAgIC0gcmVhZCB0aGUgbWVzc2FnZSBhcnJheSBnZW5lcmF0ZWQgZnJvbSB4bWwgZmlsZXMKKyAqICAgIC0gY2FsY3VsYXRlIHN0YXJ0IGluZGV4IGZvciBlYWNoIG1vZHVsZQorICogICAgLSBjYWxjdWxhdGUgbWVzc2FnZSBjb3VudCBmb3IgZWFjaCBtb2R1bGUKKyAqICAgIC0gcGVyZm9ybSBlcnJvciBjaGVja2luZworICoKKyAqIEBwYXJhbVtpbl0gbG9nX21vZCAtIGxvZyBtb2R1bGUgaW5mbworICogQHBhcmFtW2luXSBpbnN0YW5jZV9uYW1lIC0gaW5zdGFuY2UgbmFtZQorICogQHBhcmFtW2luXSBjYmZuIC0gY2FsbGJhY2sgZnVuY3Rpb24KKyAqCisgKiBJdCByZXR1cm4gMCBvbiBzdWNjZXNzLCBvciAtMSBvbiBmYWlsdXJlCisgKi8KK2ludAorYmZhX2xvZ19pbml0KHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dfbW9kLCBjaGFyICppbnN0YW5jZV9uYW1lLAorCQkJYmZhX2xvZ19jYl90IGNiZm4pCit7CisJc3RydWN0IGJmYV9sb2dfbXNnZGVmX3MgKm1zZzsKKwl1MzIgICAgICAgIHByZV9tb2RfaWQgPSAwOworCXUzMiAgICAgICAgY3VyX21vZF9pZCA9IDA7CisJdTMyICAgICAgICBpLCBwcmVfaWR4LCBpZHgsIG1zZ19pZDsKKworCS8qCisJICogc2V0IGluc3RhbmNlIG5hbWUKKwkgKi8KKwlpZiAobG9nX21vZCkgeworCQlzdHJuY3B5KGxvZ19tb2QtPmluc3RhbmNlX2luZm8sIGluc3RhbmNlX25hbWUsCisJCQlzaXplb2YobG9nX21vZC0+aW5zdGFuY2VfaW5mbykpOworCQlsb2dfbW9kLT5jYmZuID0gY2JmbjsKKwkJZm9yIChpID0gMDsgaSA8PSBCRkFfTE9HX01PRFVMRV9JRF9NQVg7IGkrKykKKwkJCWxvZ19tb2QtPmxvZ19sZXZlbFtpXSA9IEJGQV9MT0dfV0FSTklORzsKKwl9CisKKwlpZiAoYmZhX2xvZ19pbml0aWFsaXplZCkKKwkJcmV0dXJuIDA7CisKKwlmb3IgKGkgPSAwOyBpIDw9IEJGQV9MT0dfTU9EVUxFX0lEX01BWDsgaSsrKSB7CisJCWJmYV9sb2dfaW5mb1tpXS5zdGFydF9pZHggPSAwOworCQliZmFfbG9nX2luZm9baV0udG90YWxfY291bnQgPSAwOworCQliZmFfbG9nX2luZm9baV0ubGV2ZWwgPSBCRkFfTE9HX1dBUk5JTkc7CisJCWJmYV9sb2dfaW5mb1tpXS5jYmZuID0gY2JmbjsKKwl9CisKKwlwcmVfaWR4ID0gMDsKKwlpZHggPSAwOworCW1zZyA9IGJmYV9sb2dfbXNnX2FycmF5OworCW1zZ19pZCA9IEJGQV9MT0dfR0VUX01TR19JRChtc2cpOworCXByZV9tb2RfaWQgPSBCRkFfTE9HX0dFVF9NT0RfSUQobXNnX2lkKTsKKwl3aGlsZSAobXNnX2lkICE9IDApIHsKKwkJY3VyX21vZF9pZCA9IEJGQV9MT0dfR0VUX01PRF9JRChtc2dfaWQpOworCisJCWlmIChjdXJfbW9kX2lkID4gQkZBX0xPR19NT0RVTEVfSURfTUFYKSB7CisJCQljYmZuKGxvZ19tb2QsIG1zZ19pZCwKKwkJCQkiJXMlcyBsb2c6IG1vZHVsZSBpZCAldSBvdXQgb2YgcmFuZ2VcbiIsCisJCQkJQkZBX0xPR19DQVRfTkFNRSwKKwkJCQliZmFfbG9nX3NldmVyaXR5W0JGQV9MT0dfRVJST1JdLAorCQkJCWN1cl9tb2RfaWQpOworCQkJcmV0dXJuIC0xOworCQl9CisKKwkJaWYgKHByZV9tb2RfaWQgPiBCRkFfTE9HX01PRFVMRV9JRF9NQVgpIHsKKwkJCWNiZm4obG9nX21vZCwgbXNnX2lkLAorCQkJCSIlcyVzIGxvZzogbW9kdWxlIGlkICV1IG91dCBvZiByYW5nZVxuIiwKKwkJCQlCRkFfTE9HX0NBVF9OQU1FLAorCQkJCWJmYV9sb2dfc2V2ZXJpdHlbQkZBX0xPR19FUlJPUl0sCisJCQkJcHJlX21vZF9pZCk7CisJCQlyZXR1cm4gLTE7CisJCX0KKworCQlpZiAoY3VyX21vZF9pZCAhPSBwcmVfbW9kX2lkKSB7CisJCQliZmFfbG9nX2luZm9bcHJlX21vZF9pZF0uc3RhcnRfaWR4ID0gcHJlX2lkeDsKKwkJCWJmYV9sb2dfaW5mb1twcmVfbW9kX2lkXS50b3RhbF9jb3VudCA9IGlkeCAtIHByZV9pZHg7CisJCQlwcmVfbW9kX2lkID0gY3VyX21vZF9pZDsKKwkJCXByZV9pZHggPSBpZHg7CisJCX0KKworCQlpZHgrKzsKKwkJbXNnKys7CisJCW1zZ19pZCA9IEJGQV9MT0dfR0VUX01TR19JRChtc2cpOworCX0KKworCWJmYV9sb2dfaW5mb1tjdXJfbW9kX2lkXS5zdGFydF9pZHggPSBwcmVfaWR4OworCWJmYV9sb2dfaW5mb1tjdXJfbW9kX2lkXS50b3RhbF9jb3VudCA9IGlkeCAtIHByZV9pZHg7CisJYmZhX2xvZ19tc2dfdG90YWxfY291bnQgPSBpZHg7CisKKwljYmZuKGxvZ19tb2QsIG1zZ19pZCwgIiVzJXMgbG9nOiBpbml0IE9LLCBtc2cgdG90YWwgY291bnQgJXVcbiIsCisJCUJGQV9MT0dfQ0FUX05BTUUsCisJCWJmYV9sb2dfc2V2ZXJpdHlbQkZBX0xPR19JTkZPXSwgYmZhX2xvZ19tc2dfdG90YWxfY291bnQpOworCisJYmZhX2xvZ19pbml0aWFsaXplZCA9IDE7CisKKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiBCRkEgbG9nIHNldCBsb2cgbGV2ZWwgZm9yIGEgbW9kdWxlCisgKgorICogQHBhcmFtW2luXSBsb2dfbW9kIC0gbG9nIG1vZHVsZSBpbmZvCisgKiBAcGFyYW1baW5dIG1vZF9pZCAtIG1vZHVsZSBpZAorICogQHBhcmFtW2luXSBsb2dfbGV2ZWwgLSBsb2cgc2V2ZXJpdHkgbGV2ZWwKKyAqCisgKiBJdCByZXR1cm4gQkZBX1NUQVRVU19PSyBvbiBzdWNjZXNzLCBvciA+IDAgb24gZmFpbHVyZQorICovCitiZmFfc3RhdHVzX3QKK2JmYV9sb2dfc2V0X2xldmVsKHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dfbW9kLCBpbnQgbW9kX2lkLAorCQkgIGVudW0gYmZhX2xvZ19zZXZlcml0eSBsb2dfbGV2ZWwpCit7CisJaWYgKG1vZF9pZCA8PSBCRkFfTE9HX1VOVVNFRF9JRCB8fCBtb2RfaWQgPiBCRkFfTE9HX01PRFVMRV9JRF9NQVgpCisJCXJldHVybiBCRkFfU1RBVFVTX0VJTlZBTDsKKworCWlmIChsb2dfbGV2ZWwgPD0gQkZBX0xPR19JTlZBTElEIHx8IGxvZ19sZXZlbCA+IEJGQV9MT0dfTEVWRUxfTUFYKQorCQlyZXR1cm4gQkZBX1NUQVRVU19FSU5WQUw7CisKKwlpZiAobG9nX21vZCkKKwkJbG9nX21vZC0+bG9nX2xldmVsW21vZF9pZF0gPSBsb2dfbGV2ZWw7CisJZWxzZQorCQliZmFfbG9nX2luZm9bbW9kX2lkXS5sZXZlbCA9IGxvZ19sZXZlbDsKKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqIEJGQSBsb2cgc2V0IGxvZyBsZXZlbCBmb3IgYWxsIG1vZHVsZXMKKyAqCisgKiBAcGFyYW1baW5dIGxvZ19tb2QgLSBsb2cgbW9kdWxlIGluZm8KKyAqIEBwYXJhbVtpbl0gbG9nX2xldmVsIC0gbG9nIHNldmVyaXR5IGxldmVsCisgKgorICogSXQgcmV0dXJuIEJGQV9TVEFUVVNfT0sgb24gc3VjY2Vzcywgb3IgPiAwIG9uIGZhaWx1cmUKKyAqLworYmZhX3N0YXR1c190CitiZmFfbG9nX3NldF9sZXZlbF9hbGwoc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ19tb2QsCisJCSAgZW51bSBiZmFfbG9nX3NldmVyaXR5IGxvZ19sZXZlbCkKK3sKKwlpbnQgbW9kX2lkID0gQkZBX0xPR19VTlVTRURfSUQgKyAxOworCisJaWYgKGxvZ19sZXZlbCA8PSBCRkFfTE9HX0lOVkFMSUQgfHwgbG9nX2xldmVsID4gQkZBX0xPR19MRVZFTF9NQVgpCisJCXJldHVybiBCRkFfU1RBVFVTX0VJTlZBTDsKKworCWlmIChsb2dfbW9kKSB7CisJCWZvciAoOyBtb2RfaWQgPD0gQkZBX0xPR19NT0RVTEVfSURfTUFYOyBtb2RfaWQrKykKKwkJCWxvZ19tb2QtPmxvZ19sZXZlbFttb2RfaWRdID0gbG9nX2xldmVsOworCX0gZWxzZSB7CisJCWZvciAoOyBtb2RfaWQgPD0gQkZBX0xPR19NT0RVTEVfSURfTUFYOyBtb2RfaWQrKykKKwkJCWJmYV9sb2dfaW5mb1ttb2RfaWRdLmxldmVsID0gbG9nX2xldmVsOworCX0KKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqIEJGQSBsb2cgc2V0IGxvZyBsZXZlbCBmb3IgYWxsIGFlbiBzdWItbW9kdWxlcworICoKKyAqIEBwYXJhbVtpbl0gbG9nX21vZCAtIGxvZyBtb2R1bGUgaW5mbworICogQHBhcmFtW2luXSBsb2dfbGV2ZWwgLSBsb2cgc2V2ZXJpdHkgbGV2ZWwKKyAqCisgKiBJdCByZXR1cm4gQkZBX1NUQVRVU19PSyBvbiBzdWNjZXNzLCBvciA+IDAgb24gZmFpbHVyZQorICovCitiZmFfc3RhdHVzX3QKK2JmYV9sb2dfc2V0X2xldmVsX2FlbihzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nX21vZCwKKwkJICBlbnVtIGJmYV9sb2dfc2V2ZXJpdHkgbG9nX2xldmVsKQoreworCWludCBtb2RfaWQgPSBCRkFfTE9HX0FFTl9NSU4gKyAxOworCisJaWYgKGxvZ19tb2QpIHsKKwkJZm9yICg7IG1vZF9pZCA8PSBCRkFfTE9HX0FFTl9NQVg7IG1vZF9pZCsrKQorCQkJbG9nX21vZC0+bG9nX2xldmVsW21vZF9pZF0gPSBsb2dfbGV2ZWw7CisJfSBlbHNlIHsKKwkJZm9yICg7IG1vZF9pZCA8PSBCRkFfTE9HX0FFTl9NQVg7IG1vZF9pZCsrKQorCQkJYmZhX2xvZ19pbmZvW21vZF9pZF0ubGV2ZWwgPSBsb2dfbGV2ZWw7CisJfQorCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogQkZBIGxvZyBnZXQgbG9nIGxldmVsIGZvciBhIG1vZHVsZQorICoKKyAqIEBwYXJhbVtpbl0gbG9nX21vZCAtIGxvZyBtb2R1bGUgaW5mbworICogQHBhcmFtW2luXSBtb2RfaWQgLSBtb2R1bGUgaWQKKyAqCisgKiBJdCByZXR1cm5zIGxvZyBsZXZlbCBvciAtMSBvbiBlcnJvcgorICovCitlbnVtIGJmYV9sb2dfc2V2ZXJpdHkKK2JmYV9sb2dfZ2V0X2xldmVsKHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dfbW9kLCBpbnQgbW9kX2lkKQoreworCWlmIChtb2RfaWQgPD0gQkZBX0xPR19VTlVTRURfSUQgfHwgbW9kX2lkID4gQkZBX0xPR19NT0RVTEVfSURfTUFYKQorCQlyZXR1cm4gQkZBX0xPR19JTlZBTElEOworCisJaWYgKGxvZ19tb2QpCisJCXJldHVybiAobG9nX21vZC0+bG9nX2xldmVsW21vZF9pZF0pOworCWVsc2UKKwkJcmV0dXJuIChiZmFfbG9nX2luZm9bbW9kX2lkXS5sZXZlbCk7Cit9CisKK2VudW0gYmZhX2xvZ19zZXZlcml0eQorYmZhX2xvZ19nZXRfbXNnX2xldmVsKHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dfbW9kLCB1MzIgbXNnX2lkKQoreworCXN0cnVjdCBiZmFfbG9nX21zZ2RlZl9zICptc2c7CisJdTMyICAgICAgICBtb2QgPSBCRkFfTE9HX0dFVF9NT0RfSUQobXNnX2lkKTsKKwl1MzIgICAgICAgIGlkeCA9IEJGQV9MT0dfR0VUX01TR19JRFgobXNnX2lkKSAtIDE7CisKKwlpZiAoIWJmYV9sb2dfaW5pdGlhbGl6ZWQpCisJCXJldHVybiBCRkFfTE9HX0lOVkFMSUQ7CisKKwlpZiAobW9kID4gQkZBX0xPR19NT0RVTEVfSURfTUFYKQorCQlyZXR1cm4gQkZBX0xPR19JTlZBTElEOworCisJaWYgKGlkeCA+PSBiZmFfbG9nX2luZm9bbW9kXS50b3RhbF9jb3VudCkgeworCQliZmFfbG9nX2luZm9bbW9kXS5jYmZuKGxvZ19tb2QsIG1zZ19pZCwKKwkJCSIlcyVzIGxvZzogaW5jb25zaXN0ZW50IGlkeCAldSB2cy4gdG90YWwgY291bnQgJXVcbiIsCisJCQlCRkFfTE9HX0NBVF9OQU1FLCBiZmFfbG9nX3NldmVyaXR5W0JGQV9MT0dfRVJST1JdLCBpZHgsCisJCQliZmFfbG9nX2luZm9bbW9kXS50b3RhbF9jb3VudCk7CisJCXJldHVybiBCRkFfTE9HX0lOVkFMSUQ7CisJfQorCisJbXNnID0gYmZhX2xvZ19tc2dfYXJyYXkgKyBiZmFfbG9nX2luZm9bbW9kXS5zdGFydF9pZHggKyBpZHg7CisJaWYgKG1zZ19pZCAhPSBCRkFfTE9HX0dFVF9NU0dfSUQobXNnKSkgeworCQliZmFfbG9nX2luZm9bbW9kXS5jYmZuKGxvZ19tb2QsIG1zZ19pZCwKKwkJCSIlcyVzIGxvZzogaW5jb25zaXN0ZW50IG1zZyBpZCAldSBhcnJheSBtc2cgaWQgJXVcbiIsCisJCQlCRkFfTE9HX0NBVF9OQU1FLCBiZmFfbG9nX3NldmVyaXR5W0JGQV9MT0dfRVJST1JdLAorCQkJbXNnX2lkLCBCRkFfTE9HX0dFVF9NU0dfSUQobXNnKSk7CisJCXJldHVybiBCRkFfTE9HX0lOVkFMSUQ7CisJfQorCisJcmV0dXJuIEJGQV9MT0dfR0VUX1NFVkVSSVRZKG1zZyk7Cit9CisKKy8qKgorICogQkZBIGxvZyBtZXNzYWdlIGhhbmRsaW5nCisgKgorICogQkZBIGxvZyBtZXNzYWdlIGhhbmRsaW5nIGZpbmRzIHRoZSBtZXNzYWdlIGJhc2VkIG9uIG1lc3NhZ2UgaWQgYW5kIHByaW50cworICogb3V0IHRoZSBtZXNzYWdlIGJhc2VkIG9uIGl0cyBmb3JtYXQgYW5kIGFyZ3VtZW50cy4gSXQgYWxzbyBkb2VzIHByZWZpeAorICogdGhlIHNldmVyaXR5IGV0Yy4KKyAqCisgKiBAcGFyYW1baW5dIGxvZ19tb2QgLSBsb2cgbW9kdWxlIGluZm8KKyAqIEBwYXJhbVtpbl0gbXNnX2lkIC0gbWVzc2FnZSBpZAorICogQHBhcmFtW2luXSAuLi4gLSBtZXNzYWdlIGFyZ3VtZW50cworICoKKyAqIEl0IHJldHVybiAwIG9uIHN1Y2Nlc3MsIG9yIC0xIG9uIGVycm9ycworICovCitpbnQKK2JmYV9sb2coc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ19tb2QsIHUzMiBtc2dfaWQsIC4uLikKK3sKKwl2YV9saXN0ICAgICAgICAgYXA7CisJY2hhciAgICAgICAgICAgIGJ1ZlsyNTZdOworCXN0cnVjdCBiZmFfbG9nX21zZ2RlZl9zICptc2c7CisJaW50ICAgICAgICAgICAgIGxvZ19sZXZlbDsKKwl1MzIgICAgICAgIG1vZCA9IEJGQV9MT0dfR0VUX01PRF9JRChtc2dfaWQpOworCXUzMiAgICAgICAgaWR4ID0gQkZBX0xPR19HRVRfTVNHX0lEWChtc2dfaWQpIC0gMTsKKworCWlmICghYmZhX2xvZ19pbml0aWFsaXplZCkKKwkJcmV0dXJuIC0xOworCisJaWYgKG1vZCA+IEJGQV9MT0dfTU9EVUxFX0lEX01BWCkKKwkJcmV0dXJuIC0xOworCisJaWYgKGlkeCA+PSBiZmFfbG9nX2luZm9bbW9kXS50b3RhbF9jb3VudCkgeworCQliZmFfbG9nX2luZm9bbW9kXS4KKwkJCWNiZm4KKwkJCShsb2dfbW9kLCBtc2dfaWQsCisJCQkiJXMlcyBsb2c6IGluY29uc2lzdGVudCBpZHggJXUgdnMuIHRvdGFsIGNvdW50ICV1XG4iLAorCQkJQkZBX0xPR19DQVRfTkFNRSwgYmZhX2xvZ19zZXZlcml0eVtCRkFfTE9HX0VSUk9SXSwgaWR4LAorCQkJYmZhX2xvZ19pbmZvW21vZF0udG90YWxfY291bnQpOworCQlyZXR1cm4gLTE7CisJfQorCisJbXNnID0gYmZhX2xvZ19tc2dfYXJyYXkgKyBiZmFfbG9nX2luZm9bbW9kXS5zdGFydF9pZHggKyBpZHg7CisJaWYgKG1zZ19pZCAhPSBCRkFfTE9HX0dFVF9NU0dfSUQobXNnKSkgeworCQliZmFfbG9nX2luZm9bbW9kXS4KKwkJCWNiZm4KKwkJCShsb2dfbW9kLCBtc2dfaWQsCisJCQkiJXMlcyBsb2c6IGluY29uc2lzdGVudCBtc2cgaWQgJXUgYXJyYXkgbXNnIGlkICV1XG4iLAorCQkJQkZBX0xPR19DQVRfTkFNRSwgYmZhX2xvZ19zZXZlcml0eVtCRkFfTE9HX0VSUk9SXSwKKwkJCW1zZ19pZCwgQkZBX0xPR19HRVRfTVNHX0lEKG1zZykpOworCQlyZXR1cm4gLTE7CisJfQorCisJbG9nX2xldmVsID0gbG9nX21vZCA/IGxvZ19tb2QtPmxvZ19sZXZlbFttb2RdIDogYmZhX2xvZ19pbmZvW21vZF0ubGV2ZWw7CisJaWYgKChCRkFfTE9HX0dFVF9TRVZFUklUWShtc2cpID4gbG9nX2xldmVsKSAmJgorCQkJKG1zZy0+YXR0cmlidXRlcyAhPSBCRkFfTE9HX0FUVFJfTk9ORSkpCisJCXJldHVybiAwOworCisJdmFfc3RhcnQoYXAsIG1zZ19pZCk7CisJYmZhX29zX3ZzcHJpbnRmKGJ1ZiwgQkZBX0xPR19HRVRfTVNHX0ZNVF9TVFJJTkcobXNnKSwgYXApOworCXZhX2VuZChhcCk7CisKKwlpZiAobG9nX21vZCkKKwkJbG9nX21vZC0+Y2Jmbihsb2dfbW9kLCBtc2dfaWQsICIlc1slc10lcyVzICVzOiAlc1xuIiwKKwkJCQlCRkFfTE9HX0NBVF9OQU1FLCBsb2dfbW9kLT5pbnN0YW5jZV9pbmZvLAorCQkJCWJmYV9sb2dfc2V2ZXJpdHlbQkZBX0xPR19HRVRfU0VWRVJJVFkobXNnKV0sCisJCQkJKG1zZy0+YXR0cmlidXRlcyAmIEJGQV9MT0dfQVRUUl9BVURJVCkKKwkJCQk/ICIgKGF1ZGl0KSAiIDogIiIsIG1zZy0+bXNnX3ZhbHVlLCBidWYpOworCWVsc2UKKwkJYmZhX2xvZ19pbmZvW21vZF0uY2Jmbihsb2dfbW9kLCBtc2dfaWQsICIlcyVzJXMgJXM6ICVzXG4iLAorCQkJCUJGQV9MT0dfQ0FUX05BTUUsCisJCQkJYmZhX2xvZ19zZXZlcml0eVtCRkFfTE9HX0dFVF9TRVZFUklUWShtc2cpXSwKKwkJCQkobXNnLT5hdHRyaWJ1dGVzICYgQkZBX0xPR19BVFRSX0FVRElUKSA/CisJCQkJIiAoYXVkaXQpICIgOiAiIiwgbXNnLT5tc2dfdmFsdWUsIGJ1Zik7CisKKwlyZXR1cm4gMDsKK30KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfbG9nX21vZHVsZS5jIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfbG9nX21vZHVsZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVjMTU0ZDMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9sb2dfbW9kdWxlLmMKQEAgLTAsMCArMSw0NTEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGNzL2JmYV9sb2cuaD4KKyNpbmNsdWRlIDxhZW4vYmZhX2Flbl9hZGFwdGVyLmg+CisjaW5jbHVkZSA8YWVuL2JmYV9hZW5fYXVkaXQuaD4KKyNpbmNsdWRlIDxhZW4vYmZhX2Flbl9ldGhwb3J0Lmg+CisjaW5jbHVkZSA8YWVuL2JmYV9hZW5faW9jLmg+CisjaW5jbHVkZSA8YWVuL2JmYV9hZW5faXRuaW0uaD4KKyNpbmNsdWRlIDxhZW4vYmZhX2Flbl9scG9ydC5oPgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuX3BvcnQuaD4KKyNpbmNsdWRlIDxhZW4vYmZhX2Flbl9ycG9ydC5oPgorI2luY2x1ZGUgPGxvZy9iZmFfbG9nX2Zjcy5oPgorI2luY2x1ZGUgPGxvZy9iZmFfbG9nX2hhbC5oPgorI2luY2x1ZGUgPGxvZy9iZmFfbG9nX2xpbnV4Lmg+CisjaW5jbHVkZSA8bG9nL2JmYV9sb2dfd2Rydi5oPgorCitzdHJ1Y3QgYmZhX2xvZ19tc2dkZWZfcyBiZmFfbG9nX21zZ19hcnJheVtdID0geworCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgQkZBX0FFTl9DQVRfQURBUFRFUiBNb2R1bGUgKi8KK3tCRkFfQUVOX0FEQVBURVJfQURELCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfSU5GTywKKyAiQkZBX0FFTl9BREFQVEVSX0FERCIsCisgIk5ldyBhZGFwdGVyIGZvdW5kOiBTTiA9ICVzLCBiYXNlIHBvcnQgV1dOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzEpIHwgMCksIDJ9LAorCit7QkZBX0FFTl9BREFQVEVSX1JFTU9WRSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfV0FSTklORywgIkJGQV9BRU5fQURBUFRFUl9SRU1PVkUiLAorICJBZGFwdGVyIHJlbW92ZWQ6IFNOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCisKKworCisvKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEJGQV9BRU5fQ0FUX0FVRElUIE1vZHVsZSAqLwore0JGQV9BRU5fQVVESVRfQVVUSF9FTkFCTEUsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX0lORk8sICJCRkFfQUVOX0FVRElUX0FVVEhfRU5BQkxFIiwKKyAiQXV0aGVudGljYXRpb24gZW5hYmxlZCBmb3IgYmFzZSBwb3J0OiBXV04gPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfQUVOX0FVRElUX0FVVEhfRElTQUJMRSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIkJGQV9BRU5fQVVESVRfQVVUSF9ESVNBQkxFIiwKKyAiQXV0aGVudGljYXRpb24gZGlzYWJsZWQgZm9yIGJhc2UgcG9ydDogV1dOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCisKKworCisvKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEJGQV9BRU5fQ0FUX0VUSFBPUlQgTW9kdWxlICovCit7QkZBX0FFTl9FVEhQT1JUX0xJTktVUCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fRVRIUE9SVF9MSU5LVVAiLAorICJCYXNlIHBvcnQgZXRoZXJuZXQgbGlua3VwOiBtYWMgPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfQUVOX0VUSFBPUlRfTElOS0RPV04sIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX0VUSFBPUlRfTElOS0RPV04iLAorICJCYXNlIHBvcnQgZXRoZXJuZXQgbGlua2Rvd246IG1hYyA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fRVRIUE9SVF9FTkFCTEUsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX0VUSFBPUlRfRU5BQkxFIiwKKyAiQmFzZSBwb3J0IGV0aGVybmV0IGludGVyZmFjZSBlbmFibGVkOiBtYWMgPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfQUVOX0VUSFBPUlRfRElTQUJMRSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fRVRIUE9SVF9ESVNBQkxFIiwKKyAiQmFzZSBwb3J0IGV0aGVybmV0IGludGVyZmFjZSBkaXNhYmxlZDogbWFjID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCisKKworCisvKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEJGQV9BRU5fQ0FUX0lPQyBNb2R1bGUgKi8KK3tCRkFfQUVOX0lPQ19IQkdPT0QsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX0lPQ19IQkdPT0QiLAorICJIZWFydCBCZWF0IG9mIElPQyAlZCBpcyBnb29kLiIsCisgKChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fSU9DX0hCRkFJTCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0NSSVRJQ0FMLAorICJCRkFfQUVOX0lPQ19IQkZBSUwiLAorICJIZWFydCBCZWF0IG9mIElPQyAlZCBoYXMgZmFpbGVkLiIsCisgKChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fSU9DX0VOQUJMRSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fSU9DX0VOQUJMRSIsCisgIklPQyAlZCBpcyBlbmFibGVkLiIsCisgKChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fSU9DX0RJU0FCTEUsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX0lPQ19ESVNBQkxFIiwKKyAiSU9DICVkIGlzIGRpc2FibGVkLiIsCisgKChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fSU9DX0ZXTUlTTUFUQ0gsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX0NSSVRJQ0FMLCAiQkZBX0FFTl9JT0NfRldNSVNNQVRDSCIsCisgIlJ1bm5pbmcgZmlybXdhcmUgdmVyc2lvbiBpcyBpbmNvbXBhdGlibGUgd2l0aCB0aGUgZHJpdmVyIHZlcnNpb24uIiwKKyAoMCksIDB9LAorCisKKworCisvKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEJGQV9BRU5fQ0FUX0lUTklNIE1vZHVsZSAqLwore0JGQV9BRU5fSVROSU1fT05MSU5FLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfSU5GTywKKyAiQkZBX0FFTl9JVE5JTV9PTkxJTkUiLAorICJUYXJnZXQgKFdXTiA9ICVzKSBpcyBvbmxpbmUgZm9yIGluaXRpYXRvciAoV1dOID0gJXMpLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fSVROSU1fT0ZGTElORSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fSVROSU1fT0ZGTElORSIsCisgIlRhcmdldCAoV1dOID0gJXMpIG9mZmxpbmVkIGJ5IGluaXRpYXRvciAoV1dOID0gJXMpLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fSVROSU1fRElTQ09OTkVDVCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfRVJST1IsICJCRkFfQUVOX0lUTklNX0RJU0NPTk5FQ1QiLAorICJUYXJnZXQgKFdXTiA9ICVzKSBjb25uZWN0aXZpdHkgbG9zdCBmb3IgaW5pdGlhdG9yIChXV04gPSAlcykuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzEpIHwgMCksIDJ9LAorCisKKworCisvKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEJGQV9BRU5fQ0FUX0xQT1JUIE1vZHVsZSAqLwore0JGQV9BRU5fTFBPUlRfTkVXLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfSU5GTywKKyAiQkZBX0FFTl9MUE9SVF9ORVciLAorICJOZXcgbG9naWNhbCBwb3J0IGNyZWF0ZWQ6IFdXTiA9ICVzLCBSb2xlID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzEpIHwgMCksIDJ9LAorCit7QkZBX0FFTl9MUE9SVF9ERUxFVEUsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX0xQT1JUX0RFTEVURSIsCisgIkxvZ2ljYWwgcG9ydCBkZWxldGVkOiBXV04gPSAlcywgUm9sZSA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fTFBPUlRfT05MSU5FLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfSU5GTywKKyAiQkZBX0FFTl9MUE9SVF9PTkxJTkUiLAorICJMb2dpY2FsIHBvcnQgb25saW5lOiBXV04gPSAlcywgUm9sZSA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fTFBPUlRfT0ZGTElORSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fTFBPUlRfT0ZGTElORSIsCisgIkxvZ2ljYWwgcG9ydCB0YWtlbiBvZmZsaW5lOiBXV04gPSAlcywgUm9sZSA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fTFBPUlRfRElTQ09OTkVDVCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfRVJST1IsICJCRkFfQUVOX0xQT1JUX0RJU0NPTk5FQ1QiLAorICJMb2dpY2FsIHBvcnQgbG9zdCBmYWJyaWMgY29ubmVjdGl2aXR5OiBXV04gPSAlcywgUm9sZSA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fTFBPUlRfTkVXX1BST1AsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX0xQT1JUX05FV19QUk9QIiwKKyAiTmV3IHZpcnR1YWwgcG9ydCBjcmVhdGVkIHVzaW5nIHByb3ByaWV0YXJ5IGludGVyZmFjZTogV1dOID0gJXMsIFJvbGUgPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMSkgfCAwKSwgMn0sCisKK3tCRkFfQUVOX0xQT1JUX0RFTEVURV9QUk9QLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiQkZBX0FFTl9MUE9SVF9ERUxFVEVfUFJPUCIsCisgIlZpcnR1YWwgcG9ydCBkZWxldGVkIHVzaW5nIHByb3ByaWV0YXJ5IGludGVyZmFjZTogV1dOID0gJXMsIFJvbGUgPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMSkgfCAwKSwgMn0sCisKK3tCRkFfQUVOX0xQT1JUX05FV19TVEFOREFSRCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIkJGQV9BRU5fTFBPUlRfTkVXX1NUQU5EQVJEIiwKKyAiTmV3IHZpcnR1YWwgcG9ydCBjcmVhdGVkIHVzaW5nIHN0YW5kYXJkIGludGVyZmFjZTogV1dOID0gJXMsIFJvbGUgPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMSkgfCAwKSwgMn0sCisKK3tCRkFfQUVOX0xQT1JUX0RFTEVURV9TVEFOREFSRCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIkJGQV9BRU5fTFBPUlRfREVMRVRFX1NUQU5EQVJEIiwKKyAiVmlydHVhbCBwb3J0IGRlbGV0ZWQgdXNpbmcgc3RhbmRhcmQgaW50ZXJmYWNlOiBXV04gPSAlcywgUm9sZSA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fTFBPUlRfTlBJVl9EVVBfV1dOLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19XQVJOSU5HLCAiQkZBX0FFTl9MUE9SVF9OUElWX0RVUF9XV04iLAorICJWaXJ0dWFsIHBvcnQgbG9naW4gZmFpbGVkLiBEdXBsaWNhdGUgV1dOID0gJXMgcmVwb3J0ZWQgYnkgZmFicmljLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fTFBPUlRfTlBJVl9GQUJSSUNfTUFYLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19XQVJOSU5HLCAiQkZBX0FFTl9MUE9SVF9OUElWX0ZBQlJJQ19NQVgiLAorICJWaXJ0dWFsIHBvcnQgKFdXTiA9ICVzKSBsb2dpbiBmYWlsZWQuIE1heCBOUElWIHBvcnRzIGFscmVhZHkgZXhpc3QgaW4iCisgIiBmYWJyaWMvZnBvcnQuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0FFTl9MUE9SVF9OUElWX1VOS05PV04sIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX1dBUk5JTkcsICJCRkFfQUVOX0xQT1JUX05QSVZfVU5LTk9XTiIsCisgIlZpcnR1YWwgcG9ydCAoV1dOID0gJXMpIGxvZ2luIGZhaWxlZC4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKKworCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgQkZBX0FFTl9DQVRfUE9SVCBNb2R1bGUgKi8KK3tCRkFfQUVOX1BPUlRfT05MSU5FLCBCRkFfTE9HX0FUVFJfTk9ORSwgQkZBX0xPR19JTkZPLCAiQkZBX0FFTl9QT1JUX09OTElORSIsCisgIkJhc2UgcG9ydCBvbmxpbmU6IFdXTiA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fUE9SVF9PRkZMSU5FLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfV0FSTklORywKKyAiQkZBX0FFTl9QT1JUX09GRkxJTkUiLAorICJCYXNlIHBvcnQgb2ZmbGluZTogV1dOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0FFTl9QT1JUX1JMSVIsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX1BPUlRfUkxJUiIsCisgIlJMSVIgZXZlbnQgbm90IHN1cHBvcnRlZC4iLAorICgwKSwgMH0sCisKK3tCRkFfQUVOX1BPUlRfU0ZQX0lOU0VSVCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fUE9SVF9TRlBfSU5TRVJUIiwKKyAiTmV3IFNGUCBmb3VuZDogV1dOL01BQyA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fUE9SVF9TRlBfUkVNT1ZFLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19XQVJOSU5HLCAiQkZBX0FFTl9QT1JUX1NGUF9SRU1PVkUiLAorICJTRlAgcmVtb3ZlZDogV1dOL01BQyA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9BRU5fUE9SVF9TRlBfUE9NLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfV0FSTklORywKKyAiQkZBX0FFTl9QT1JUX1NGUF9QT00iLAorICJTRlAgUE9NIGxldmVsIHRvICVzOiBXV04vTUFDID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzEpIHwgMCksIDJ9LAorCit7QkZBX0FFTl9QT1JUX0VOQUJMRSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fUE9SVF9FTkFCTEUiLAorICJCYXNlIHBvcnQgZW5hYmxlZDogV1dOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0FFTl9QT1JUX0RJU0FCTEUsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX1BPUlRfRElTQUJMRSIsCisgIkJhc2UgcG9ydCBkaXNhYmxlZDogV1dOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0FFTl9QT1JUX0FVVEhfT04sIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX1BPUlRfQVVUSF9PTiIsCisgIkF1dGhlbnRpY2F0aW9uIHN1Y2Nlc3NmdWwgZm9yIGJhc2UgcG9ydDogV1dOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0FFTl9QT1JUX0FVVEhfT0ZGLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfRVJST1IsCisgIkJGQV9BRU5fUE9SVF9BVVRIX09GRiIsCisgIkF1dGhlbnRpY2F0aW9uIHVuc3VjY2Vzc2Z1bCBmb3IgYmFzZSBwb3J0OiBXV04gPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfQUVOX1BPUlRfRElTQ09OTkVDVCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0VSUk9SLAorICJCRkFfQUVOX1BPUlRfRElTQ09OTkVDVCIsCisgIkJhc2UgcG9ydCAoV1dOID0gJXMpIGxvc3QgZmFicmljIGNvbm5lY3Rpdml0eS4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfQUVOX1BPUlRfUU9TX05FRywgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX1dBUk5JTkcsCisgIkJGQV9BRU5fUE9SVF9RT1NfTkVHIiwKKyAiUU9TIG5lZ290aWF0aW9uIGZhaWxlZCBmb3IgYmFzZSBwb3J0OiBXV04gPSAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfQUVOX1BPUlRfRkFCUklDX05BTUVfQ0hBTkdFLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19XQVJOSU5HLCAiQkZBX0FFTl9QT1JUX0ZBQlJJQ19OQU1FX0NIQU5HRSIsCisgIkJhc2UgcG9ydCBXV04gPSAlcywgRmFicmljIFdXTiA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fUE9SVF9TRlBfQUNDRVNTX0VSUk9SLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19XQVJOSU5HLCAiQkZBX0FFTl9QT1JUX1NGUF9BQ0NFU1NfRVJST1IiLAorICJTRlAgYWNjZXNzIGVycm9yOiBXV04vTUFDID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0FFTl9QT1JUX1NGUF9VTlNVUFBPUlQsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX1dBUk5JTkcsICJCRkFfQUVOX1BPUlRfU0ZQX1VOU1VQUE9SVCIsCisgIlVuc3VwcG9ydGVkIFNGUCBmb3VuZDogV1dOL01BQyA9ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKworCisKKworLyogbWVzc2FnZXMgZGVmaW5lIGZvciBCRkFfQUVOX0NBVF9SUE9SVCBNb2R1bGUgKi8KK3tCRkFfQUVOX1JQT1JUX09OTElORSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fUlBPUlRfT05MSU5FIiwKKyAiUmVtb3RlIHBvcnQgKFdXTiA9ICVzKSBvbmxpbmUgZm9yIGxvZ2ljYWwgcG9ydCAoV1dOID0gJXMpLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fUlBPUlRfT0ZGTElORSwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkJGQV9BRU5fUlBPUlRfT0ZGTElORSIsCisgIlJlbW90ZSBwb3J0IChXV04gPSAlcykgb2ZmbGluZWQgYnkgbG9naWNhbCBwb3J0IChXV04gPSAlcykuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzEpIHwgMCksIDJ9LAorCit7QkZBX0FFTl9SUE9SVF9ESVNDT05ORUNULCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19FUlJPUiwgIkJGQV9BRU5fUlBPUlRfRElTQ09OTkVDVCIsCisgIlJlbW90ZSBwb3J0IChXV04gPSAlcykgY29ubmVjdGl2aXR5IGxvc3QgZm9yIGxvZ2ljYWwgcG9ydCAoV1dOID0gJXMpLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8IDApLCAyfSwKKwore0JGQV9BRU5fUlBPUlRfUU9TX1BSSU8sIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJCRkFfQUVOX1JQT1JUX1FPU19QUklPIiwKKyAiUU9TIHByaW9yaXR5IGNoYW5nZWQgdG8gJXM6IFJQV1dOID0gJXMgYW5kIExQV1dOID0gJXMuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzEpIHwKKyAgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzIpIHwgMCksIDN9LAorCit7QkZBX0FFTl9SUE9SVF9RT1NfRkxPV0lELCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfSU5GTywKKyAiQkZBX0FFTl9SUE9SVF9RT1NfRkxPV0lEIiwKKyAiUU9TIGZsb3cgSUQgY2hhbmdlZCB0byAlZDogUlBXV04gPSAlcyBhbmQgTFBXV04gPSAlcy4iLAorICgoQkZBX0xPR19EIDw8IEJGQV9MT0dfQVJHMCkgfCAoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMSkgfAorICAoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMikgfCAwKSwgM30sCisKKworCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgRkNTIE1vZHVsZSAqLwore0JGQV9MT0dfRkNTX0ZBQlJJQ19OT1NXSVRDSCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIkZDU19GQUJSSUNfTk9TV0lUQ0giLAorICJObyBzd2l0Y2hlZCBmYWJyaWMgcHJlc2VuY2UgaXMgZGV0ZWN0ZWQuIiwKKyAoMCksIDB9LAorCit7QkZBX0xPR19GQ1NfRkFCUklDX0lTT0xBVEVELCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiRkNTX0ZBQlJJQ19JU09MQVRFRCIsCisgIlBvcnQgaXMgaXNvbGF0ZWQgZHVlIHRvIFZGX0lEIG1pc21hdGNoLiBQV1dOOiAlcywgUG9ydCBWRl9JRDogJTA0eCBhbmQiCisgIiBzd2l0Y2ggcG9ydCBWRl9JRDogJTA0eC4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAoQkZBX0xPR19YIDw8IEJGQV9MT0dfQVJHMSkgfAorICAoQkZBX0xPR19YIDw8IEJGQV9MT0dfQVJHMikgfCAwKSwgM30sCisKKworCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgSEFMIE1vZHVsZSAqLwore0JGQV9MT0dfSEFMX0FTU0VSVCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0VSUk9SLAorICJIQUxfQVNTRVJUIiwKKyAiQXNzZXJ0aW9uIGZhaWx1cmU6ICVzOiVkOiAlcyIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcxKSB8CisgIChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcyKSB8IDApLCAzfSwKKwore0JGQV9MT0dfSEFMX0hFQVJUQkVBVF9GQUlMVVJFLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19DUklUSUNBTCwgIkhBTF9IRUFSVEJFQVRfRkFJTFVSRSIsCisgIkZpcm13YXJlIGhlYXJ0YmVhdCBmYWlsdXJlIGF0ICVkIiwKKyAoKEJGQV9MT0dfRCA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0xPR19IQUxfRkNQSU1fUEFSTV9JTlZBTElELCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiSEFMX0ZDUElNX1BBUk1fSU5WQUxJRCIsCisgIkRyaXZlciBjb25maWd1cmF0aW9uICVzIHZhbHVlICVkIGlzIGludmFsaWQuIFZhbHVlIHNob3VsZCBiZSB3aXRoaW4iCisgIiAlZCBhbmQgJWQuIiwKKyAoKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfRCA8PCBCRkFfTE9HX0FSRzEpIHwKKyAgKEJGQV9MT0dfRCA8PCBCRkFfTE9HX0FSRzIpIHwgKEJGQV9MT0dfRCA8PCBCRkFfTE9HX0FSRzMpIHwgMCksIDR9LAorCit7QkZBX0xPR19IQUxfU01fQVNTRVJULCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfRVJST1IsCisgIkhBTF9TTV9BU1NFUlQiLAorICJTTSBBc3NlcnRpb24gZmFpbHVyZTogJXM6JWQ6IGV2ZW50ID0gJWQiLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAoQkZBX0xPR19EIDw8IEJGQV9MT0dfQVJHMSkgfAorICAoQkZBX0xPR19EIDw8IEJGQV9MT0dfQVJHMikgfCAwKSwgM30sCisKKworCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgTElOVVggTW9kdWxlICovCit7QkZBX0xPR19MSU5VWF9ERVZJQ0VfQ0xBSU1FRCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIkxJTlVYX0RFVklDRV9DTEFJTUVEIiwKKyAiYmZhIGRldmljZSBhdCAlcyBjbGFpbWVkLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9MT0dfTElOVVhfSEFTSF9JTklUX0ZBSUxFRCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIkxJTlVYX0hBU0hfSU5JVF9GQUlMRUQiLAorICJIYXNoIHRhYmxlIGluaXRpYWxpemF0aW9uIGZhaWx1cmUgZm9yIHRoZSBwb3J0ICVzLiIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9MT0dfTElOVVhfU1lTRlNfRkFJTEVELCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiTElOVVhfU1lTRlNfRkFJTEVEIiwKKyAic3lzZnMgZmlsZSBjcmVhdGlvbiBmYWlsdXJlIGZvciB0aGUgcG9ydCAlcy4iLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfTE9HX0xJTlVYX01FTV9BTExPQ19GQUlMRUQsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX0lORk8sICJMSU5VWF9NRU1fQUxMT0NfRkFJTEVEIiwKKyAiTWVtb3J5IGFsbG9jYXRpb24gZmFpbGVkOiAlcy4gICIsCisgKChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcwKSB8IDApLCAxfSwKKwore0JGQV9MT0dfTElOVVhfRFJJVkVSX1JFR0lTVFJBVElPTl9GQUlMRUQsCisgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLCBCRkFfTE9HX0lORk8sCisgIkxJTlVYX0RSSVZFUl9SRUdJU1RSQVRJT05fRkFJTEVEIiwKKyAiJXMuICAiLAorICgoQkZBX0xPR19TIDw8IEJGQV9MT0dfQVJHMCkgfCAwKSwgMX0sCisKK3tCRkFfTE9HX0xJTlVYX0lUTklNX0ZSRUUsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywgQkZBX0xPR19JTkZPLAorICJMSU5VWF9JVE5JTV9GUkVFIiwKKyAic2NzaSVkOiBGQ0lEOiAlcyBXV1BOOiAlcyIsCisgKChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcxKSB8CisgIChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcyKSB8IDApLCAzfSwKKwore0JGQV9MT0dfTElOVVhfSVROSU1fT05MSU5FLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiTElOVVhfSVROSU1fT05MSU5FIiwKKyAiVGFyZ2V0OiAlZDowOiVkIEZDSUQ6ICVzIFdXUE46ICVzIiwKKyAoKEJGQV9MT0dfRCA8PCBCRkFfTE9HX0FSRzApIHwgKEJGQV9MT0dfRCA8PCBCRkFfTE9HX0FSRzEpIHwKKyAgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzIpIHwgKEJGQV9MT0dfUyA8PCBCRkFfTE9HX0FSRzMpIHwgMCksIDR9LAorCit7QkZBX0xPR19MSU5VWF9JVE5JTV9PRkZMSU5FLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiTElOVVhfSVROSU1fT0ZGTElORSIsCisgIlRhcmdldDogJWQ6MDolZCBGQ0lEOiAlcyBXV1BOOiAlcyIsCisgKChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcxKSB8CisgIChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkcyKSB8IChCRkFfTE9HX1MgPDwgQkZBX0xPR19BUkczKSB8IDApLCA0fSwKKwore0JGQV9MT0dfTElOVVhfU0NTSV9IT1NUX0ZSRUUsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX0lORk8sICJMSU5VWF9TQ1NJX0hPU1RfRlJFRSIsCisgIkZyZWUgc2NzaSVkIiwKKyAoKEJGQV9MT0dfRCA8PCBCRkFfTE9HX0FSRzApIHwgMCksIDF9LAorCit7QkZBX0xPR19MSU5VWF9TQ1NJX0FCT1JULCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csIEJGQV9MT0dfSU5GTywKKyAiTElOVVhfU0NTSV9BQk9SVCIsCisgInNjc2klZDogYWJvcnQgY21uZCAlcCwgaW90YWcgJXgiLAorICgoQkZBX0xPR19EIDw8IEJGQV9MT0dfQVJHMCkgfCAoQkZBX0xPR19QIDw8IEJGQV9MT0dfQVJHMSkgfAorICAoQkZBX0xPR19YIDw8IEJGQV9MT0dfQVJHMikgfCAwKSwgM30sCisKK3tCRkFfTE9HX0xJTlVYX1NDU0lfQUJPUlRfQ09NUCwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIkxJTlVYX1NDU0lfQUJPUlRfQ09NUCIsCisgInNjc2klZDogY29tcGxldGUgYWJvcnQgMHglcCwgaW90YWcgMHgleCIsCisgKChCRkFfTE9HX0QgPDwgQkZBX0xPR19BUkcwKSB8IChCRkFfTE9HX1AgPDwgQkZBX0xPR19BUkcxKSB8CisgIChCRkFfTE9HX1ggPDwgQkZBX0xPR19BUkcyKSB8IDApLCAzfSwKKworCisKKworLyogbWVzc2FnZXMgZGVmaW5lIGZvciBXRFJWIE1vZHVsZSAqLwore0JGQV9MT0dfV0RSVl9JT0NfSU5JVF9FUlJPUiwgQkZBX0xPR19BVFRSX05PTkUgfCBCRkFfTE9HX0FUVFJfTE9HLAorIEJGQV9MT0dfSU5GTywgIldEUlZfSU9DX0lOSVRfRVJST1IiLAorICJJT0MgaW5pdGlhbGl6YXRpb24gaGFzIGZhaWxlZC4iLAorICgwKSwgMH0sCisKK3tCRkFfTE9HX1dEUlZfSU9DX0lOVEVSTkFMX0VSUk9SLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiV0RSVl9JT0NfSU5URVJOQUxfRVJST1IiLAorICJJT0MgaW50ZXJuYWwgZXJyb3IuICAiLAorICgwKSwgMH0sCisKK3tCRkFfTE9HX1dEUlZfSU9DX1NUQVJUX0VSUk9SLCBCRkFfTE9HX0FUVFJfTk9ORSB8IEJGQV9MT0dfQVRUUl9MT0csCisgQkZBX0xPR19JTkZPLCAiV0RSVl9JT0NfU1RBUlRfRVJST1IiLAorICJJT0MgY291bGQgbm90IGJlIHN0YXJ0ZWQuICAiLAorICgwKSwgMH0sCisKK3tCRkFfTE9HX1dEUlZfSU9DX1NUT1BfRVJST1IsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX0lORk8sICJXRFJWX0lPQ19TVE9QX0VSUk9SIiwKKyAiSU9DIGNvdWxkIG5vdCBiZSBzdG9wcGVkLiAgIiwKKyAoMCksIDB9LAorCit7QkZBX0xPR19XRFJWX0lOU1VGRklDSUVOVF9SRVNPVVJDRVMsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX0lORk8sICJXRFJWX0lOU1VGRklDSUVOVF9SRVNPVVJDRVMiLAorICJJbnN1ZmZpY2llbnQgbWVtb3J5LiAgIiwKKyAoMCksIDB9LAorCit7QkZBX0xPR19XRFJWX0JBU0VfQUREUkVTU19NQVBfRVJST1IsIEJGQV9MT0dfQVRUUl9OT05FIHwgQkZBX0xPR19BVFRSX0xPRywKKyBCRkFfTE9HX0lORk8sICJXRFJWX0JBU0VfQUREUkVTU19NQVBfRVJST1IiLAorICJVbmFibGUgdG8gbWFwIHRoZSBJT0Mgb250byB0aGUgc3lzdGVtIGFkZHJlc3Mgc3BhY2UuICAiLAorICgwKSwgMH0sCisKKworezAsIDAsIDAsICIiLCAiIiwgMCwgMH0sCit9OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfbHBzLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9scHMuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45ODQ0YjQ1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfbHBzLmMKQEAgLTAsMCArMSw3ODIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmaS9iZmlfbHBzLmg+CisjaW5jbHVkZSA8Y3MvYmZhX2RlYnVnLmg+CisKK0JGQV9UUkNfRklMRShIQUwsIExQUyk7CitCRkFfTU9EVUxFKGxwcyk7CisKKyNkZWZpbmUgQkZBX0xQU19NSU5fTFBPUlRTCSgxKQorI2RlZmluZSBCRkFfTFBTX01BWF9MUE9SVFMJKDI1NikKKworLyoqCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgdm9pZCBiZmFfbHBzX21lbWluZm8oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKm5kbV9sZW4sCisJCQkgICAgdTMyICpkbV9sZW4pOworc3RhdGljIHZvaWQgYmZhX2xwc19hdHRhY2goc3RydWN0IGJmYV9zICpiZmEsIHZvaWQgKmJmYWQsCisJCQkgICBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCQkgICBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbywKKwkJCSAgIHN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldik7CitzdGF0aWMgdm9pZCBiZmFfbHBzX2luaXRkb25lKHN0cnVjdCBiZmFfcyAqYmZhKTsKK3N0YXRpYyB2b2lkIGJmYV9scHNfZGV0YWNoKHN0cnVjdCBiZmFfcyAqYmZhKTsKK3N0YXRpYyB2b2lkIGJmYV9scHNfc3RhcnQoc3RydWN0IGJmYV9zICpiZmEpOworc3RhdGljIHZvaWQgYmZhX2xwc19zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKTsKK3N0YXRpYyB2b2lkIGJmYV9scHNfaW9jZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSk7CitzdGF0aWMgdm9pZCBiZmFfbHBzX2xvZ2luX3JzcChzdHJ1Y3QgYmZhX3MgKmJmYSwKKwkJCSAgICAgIHN0cnVjdCBiZmlfbHBzX2xvZ2luX3JzcF9zICpyc3ApOworc3RhdGljIHZvaWQgYmZhX2xwc19sb2dvdXRfcnNwKHN0cnVjdCBiZmFfcyAqYmZhLAorCQkJICAgICAgIHN0cnVjdCBiZmlfbHBzX2xvZ291dF9yc3BfcyAqcnNwKTsKK3N0YXRpYyB2b2lkIGJmYV9scHNfcmVxcV9yZXN1bWUodm9pZCAqbHBzX2FyZyk7CitzdGF0aWMgdm9pZCBiZmFfbHBzX2ZyZWUoc3RydWN0IGJmYV9scHNfcyAqbHBzKTsKK3N0YXRpYyB2b2lkIGJmYV9scHNfc2VuZF9sb2dpbihzdHJ1Y3QgYmZhX2xwc19zICpscHMpOworc3RhdGljIHZvaWQgYmZhX2xwc19zZW5kX2xvZ291dChzdHJ1Y3QgYmZhX2xwc19zICpscHMpOworc3RhdGljIHZvaWQgYmZhX2xwc19sb2dpbl9jb21wKHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7CitzdGF0aWMgdm9pZCBiZmFfbHBzX2xvZ291dF9jb21wKHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7CisKKworLyoqCisgKiAgbHBzX3B2dCBCRkEgTFBTIHByaXZhdGUgZnVuY3Rpb25zCisgKi8KKworZW51bSBiZmFfbHBzX2V2ZW50IHsKKwlCRkFfTFBTX1NNX0xPR0lOCT0gMSwJLyogbG9naW4gcmVxdWVzdCBmcm9tIHVzZXIJKi8KKwlCRkFfTFBTX1NNX0xPR09VVAk9IDIsCS8qIGxvZ291dCByZXF1ZXN0IGZyb20gdXNlcgkqLworCUJGQV9MUFNfU01fRldSU1AJPSAzLAkvKiBmL3cgcmVzcG9uc2UgdG8gbG9naW4vbG9nb3V0CSovCisJQkZBX0xQU19TTV9SRVNVTUUJPSA0LAkvKiBzcGFjZSBwcmVzZW50IGluIHJlcXEgcXVldWUJKi8KKwlCRkFfTFBTX1NNX0RFTEVURQk9IDUsCS8qIGxwcyBkZWxldGUgZnJvbSB1c2VyCQkqLworCUJGQV9MUFNfU01fT0ZGTElORQk9IDYsCS8qIExpbmsgaXMgb2ZmbGluZQkJKi8KK307CisKK3N0YXRpYyB2b2lkIGJmYV9scHNfc21faW5pdChzdHJ1Y3QgYmZhX2xwc19zICpscHMsIGVudW0gYmZhX2xwc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCBiZmFfbHBzX3NtX2xvZ2luKHN0cnVjdCBiZmFfbHBzX3MgKmxwcywgZW51bSBiZmFfbHBzX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkIGJmYV9scHNfc21fbG9naW53YWl0KHN0cnVjdCBiZmFfbHBzX3MgKmxwcywKKwkJCWVudW0gYmZhX2xwc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCBiZmFfbHBzX3NtX29ubGluZShzdHJ1Y3QgYmZhX2xwc19zICpscHMsIGVudW0gYmZhX2xwc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCBiZmFfbHBzX3NtX2xvZ291dChzdHJ1Y3QgYmZhX2xwc19zICpscHMsIGVudW0gYmZhX2xwc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCBiZmFfbHBzX3NtX2xvZ293YWl0KHN0cnVjdCBiZmFfbHBzX3MgKmxwcywKKwkJCWVudW0gYmZhX2xwc19ldmVudCBldmVudCk7CisKKy8qKgorICogSW5pdCBzdGF0ZSAtLSBubyBsb2dpbgorICovCitzdGF0aWMgdm9pZAorYmZhX2xwc19zbV9pbml0KHN0cnVjdCBiZmFfbHBzX3MgKmxwcywgZW51bSBiZmFfbHBzX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobHBzLT5iZmEsIGxwcy0+bHBfdGFnKTsKKwliZmFfdHJjKGxwcy0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfTFBTX1NNX0xPR0lOOgorCQlpZiAoYmZhX3JlcXFfZnVsbChscHMtPmJmYSwgbHBzLT5yZXFxKSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZShscHMsIGJmYV9scHNfc21fbG9naW53YWl0KTsKKwkJCWJmYV9yZXFxX3dhaXQobHBzLT5iZmEsIGxwcy0+cmVxcSwgJmxwcy0+d3FlKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2xvZ2luKTsKKwkJCWJmYV9scHNfc2VuZF9sb2dpbihscHMpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBCRkFfTFBTX1NNX0xPR09VVDoKKwkJYmZhX2xwc19sb2dvdXRfY29tcChscHMpOworCQlicmVhazsKKworCWNhc2UgQkZBX0xQU19TTV9ERUxFVEU6CisJCWJmYV9scHNfZnJlZShscHMpOworCQlicmVhazsKKworCWNhc2UgQkZBX0xQU19TTV9PRkZMSU5FOgorCQlicmVhazsKKworCWNhc2UgQkZBX0xQU19TTV9GV1JTUDoKKwkJLyogQ291bGQgaGFwcGVuIHdoZW4gZmFicmljIGRldGVjdHMgbG9vcGJhY2sgYW5kIGRpc2NhcmRzCisJCSAqIHRoZSBscHMgcmVxdWVzdC4gRncgd2lsbCBldmVudHVhbGx5IHNlbnQgb3V0IHRoZSB0aW1lb3V0CisJCSAqIEp1c3QgaWdub3JlCisJCSAqLworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIGxvZ2luIGlzIGluIHByb2dyZXNzIC0tIGF3YWl0aW5nIHJlc3BvbnNlIGZyb20gZmlybXdhcmUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfc21fbG9naW4oc3RydWN0IGJmYV9scHNfcyAqbHBzLCBlbnVtIGJmYV9scHNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhscHMtPmJmYSwgbHBzLT5scF90YWcpOworCWJmYV90cmMobHBzLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9MUFNfU01fRldSU1A6CisJCWlmIChscHMtPnN0YXR1cyA9PSBCRkFfU1RBVFVTX09LKQorCQkJYmZhX3NtX3NldF9zdGF0ZShscHMsIGJmYV9scHNfc21fb25saW5lKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShscHMsIGJmYV9scHNfc21faW5pdCk7CisJCWJmYV9scHNfbG9naW5fY29tcChscHMpOworCQlicmVhazsKKworCWNhc2UgQkZBX0xQU19TTV9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKGxwcywgYmZhX2xwc19zbV9pbml0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBsb2dpbiBwZW5kaW5nIC0gYXdhaXRpbmcgc3BhY2UgaW4gcmVxdWVzdCBxdWV1ZQorICovCitzdGF0aWMgdm9pZAorYmZhX2xwc19zbV9sb2dpbndhaXQoc3RydWN0IGJmYV9scHNfcyAqbHBzLCBlbnVtIGJmYV9scHNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhscHMtPmJmYSwgbHBzLT5scF90YWcpOworCWJmYV90cmMobHBzLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9MUFNfU01fUkVTVU1FOgorCQliZmFfc21fc2V0X3N0YXRlKGxwcywgYmZhX2xwc19zbV9sb2dpbik7CisJCWJyZWFrOworCisJY2FzZSBCRkFfTFBTX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2luaXQpOworCQliZmFfcmVxcV93Y2FuY2VsKCZscHMtPndxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogbG9naW4gY29tcGxldGUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfc21fb25saW5lKHN0cnVjdCBiZmFfbHBzX3MgKmxwcywgZW51bSBiZmFfbHBzX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobHBzLT5iZmEsIGxwcy0+bHBfdGFnKTsKKwliZmFfdHJjKGxwcy0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfTFBTX1NNX0xPR09VVDoKKwkJaWYgKGJmYV9yZXFxX2Z1bGwobHBzLT5iZmEsIGxwcy0+cmVxcSkpIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2xvZ293YWl0KTsKKwkJCWJmYV9yZXFxX3dhaXQobHBzLT5iZmEsIGxwcy0+cmVxcSwgJmxwcy0+d3FlKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2xvZ291dCk7CisJCQliZmFfbHBzX3NlbmRfbG9nb3V0KGxwcyk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIEJGQV9MUFNfU01fT0ZGTElORToKKwljYXNlIEJGQV9MUFNfU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGxwcywgYmZhX2xwc19zbV9pbml0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBsb2dvdXQgaW4gcHJvZ3Jlc3MgLSBhd2FpdGluZyBmaXJtd2FyZSByZXNwb25zZQorICovCitzdGF0aWMgdm9pZAorYmZhX2xwc19zbV9sb2dvdXQoc3RydWN0IGJmYV9scHNfcyAqbHBzLCBlbnVtIGJmYV9scHNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhscHMtPmJmYSwgbHBzLT5scF90YWcpOworCWJmYV90cmMobHBzLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9MUFNfU01fRldSU1A6CisJCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2luaXQpOworCQliZmFfbHBzX2xvZ291dF9jb21wKGxwcyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfTFBTX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2luaXQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIGxvZ291dCBwZW5kaW5nIC0tIGF3YWl0aW5nIHNwYWNlIGluIHJlcXVlc3QgcXVldWUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfc21fbG9nb3dhaXQoc3RydWN0IGJmYV9scHNfcyAqbHBzLCBlbnVtIGJmYV9scHNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhscHMtPmJmYSwgbHBzLT5scF90YWcpOworCWJmYV90cmMobHBzLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9MUFNfU01fUkVTVU1FOgorCQliZmFfc21fc2V0X3N0YXRlKGxwcywgYmZhX2xwc19zbV9sb2dvdXQpOworCQliZmFfbHBzX3NlbmRfbG9nb3V0KGxwcyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfTFBTX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2luaXQpOworCQliZmFfcmVxcV93Y2FuY2VsKCZscHMtPndxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBscHNfcHZ0IEJGQSBMUFMgcHJpdmF0ZSBmdW5jdGlvbnMKKyAqLworCisvKioKKyAqIHJldHVybiBtZW1vcnkgcmVxdWlyZW1lbnQKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfbWVtaW5mbyhzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsIHUzMiAqbmRtX2xlbiwgdTMyICpkbV9sZW4pCit7CisJaWYgKGNmZy0+ZHJ2Y2ZnLm1pbl9jZmcpCisJCSpuZG1fbGVuICs9IHNpemVvZihzdHJ1Y3QgYmZhX2xwc19zKSAqIEJGQV9MUFNfTUlOX0xQT1JUUzsKKwllbHNlCisJCSpuZG1fbGVuICs9IHNpemVvZihzdHJ1Y3QgYmZhX2xwc19zKSAqIEJGQV9MUFNfTUFYX0xQT1JUUzsKK30KKworLyoqCisgKiBiZmEgbW9kdWxlIGF0dGFjaCBhdCBpbml0aWFsaXphdGlvbiB0aW1lCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfbHBzX2F0dGFjaChzdHJ1Y3QgYmZhX3MgKmJmYSwgdm9pZCAqYmZhZCwgc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLAorCQlzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbywgc3RydWN0IGJmYV9wY2lkZXZfcyAqcGNpZGV2KQoreworCXN0cnVjdCBiZmFfbHBzX21vZF9zCSptb2QgPSBCRkFfTFBTX01PRChiZmEpOworCXN0cnVjdCBiZmFfbHBzX3MJKmxwczsKKwlpbnQJCQlpOworCisJYmZhX29zX21lbXNldChtb2QsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX2xwc19tb2RfcykpOworCW1vZC0+bnVtX2xwcyA9IEJGQV9MUFNfTUFYX0xQT1JUUzsKKwlpZiAoY2ZnLT5kcnZjZmcubWluX2NmZykKKwkJbW9kLT5udW1fbHBzID0gQkZBX0xQU19NSU5fTFBPUlRTOworCWVsc2UKKwkJbW9kLT5udW1fbHBzID0gQkZBX0xQU19NQVhfTFBPUlRTOworCW1vZC0+bHBzX2FyciA9IGxwcyA9IChzdHJ1Y3QgYmZhX2xwc19zICopIGJmYV9tZW1pbmZvX2t2YShtZW1pbmZvKTsKKworCWJmYV9tZW1pbmZvX2t2YShtZW1pbmZvKSArPSBtb2QtPm51bV9scHMgKiBzaXplb2Yoc3RydWN0IGJmYV9scHNfcyk7CisKKwlJTklUX0xJU1RfSEVBRCgmbW9kLT5scHNfZnJlZV9xKTsKKwlJTklUX0xJU1RfSEVBRCgmbW9kLT5scHNfYWN0aXZlX3EpOworCisJZm9yIChpID0gMDsgaSA8IG1vZC0+bnVtX2xwczsgaSsrLCBscHMrKykgeworCQlscHMtPmJmYQk9IGJmYTsKKwkJbHBzLT5scF90YWcJPSAodTgpIGk7CisJCWxwcy0+cmVxcQk9IEJGQV9SRVFRX0xQUzsKKwkJYmZhX3JlcXFfd2luaXQoJmxwcy0+d3FlLCBiZmFfbHBzX3JlcXFfcmVzdW1lLCBscHMpOworCQlsaXN0X2FkZF90YWlsKCZscHMtPnFlLCAmbW9kLT5scHNfZnJlZV9xKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfbHBzX2luaXRkb25lKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX2xwc19kZXRhY2goc3RydWN0IGJmYV9zICpiZmEpCit7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfbHBzX3N0YXJ0KHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX2xwc19zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCisvKioKKyAqIElPQyBpbiBkaXNhYmxlZCBzdGF0ZSAtLSBjb25zaWRlciBhbGwgbHBzIG9mZmxpbmUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfaW9jZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX2xwc19tb2RfcwkqbW9kID0gQkZBX0xQU19NT0QoYmZhKTsKKwlzdHJ1Y3QgYmZhX2xwc19zCSpscHM7CisJc3RydWN0IGxpc3RfaGVhZAkJKnFlLCAqcWVuOworCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZtb2QtPmxwc19hY3RpdmVfcSkgeworCQlscHMgPSAoc3RydWN0IGJmYV9scHNfcyAqKSBxZTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobHBzLCBCRkFfTFBTX1NNX09GRkxJTkUpOworCX0KK30KKworLyoqCisgKiBGaXJtd2FyZSBsb2dpbiByZXNwb25zZQorICovCitzdGF0aWMgdm9pZAorYmZhX2xwc19sb2dpbl9yc3Aoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbHBzX2xvZ2luX3JzcF9zICpyc3ApCit7CisJc3RydWN0IGJmYV9scHNfbW9kX3MJKm1vZCA9IEJGQV9MUFNfTU9EKGJmYSk7CisJc3RydWN0IGJmYV9scHNfcwkqbHBzOworCisJYmZhX2Fzc2VydChyc3AtPmxwX3RhZyA8IG1vZC0+bnVtX2xwcyk7CisJbHBzID0gQkZBX0xQU19GUk9NX1RBRyhtb2QsIHJzcC0+bHBfdGFnKTsKKworCWxwcy0+c3RhdHVzID0gcnNwLT5zdGF0dXM7CisJc3dpdGNoIChyc3AtPnN0YXR1cykgeworCWNhc2UgQkZBX1NUQVRVU19PSzoKKwkJbHBzLT5mcG9ydAk9IHJzcC0+Zl9wb3J0OworCQlscHMtPm5waXZfZW4JPSByc3AtPm5waXZfZW47CisJCWxwcy0+bHBfcGlkCT0gcnNwLT5scF9waWQ7CisJCWxwcy0+cHJfYmJjcmVkCT0gYmZhX29zX250b2hzKHJzcC0+YmJfY3JlZGl0KTsKKwkJbHBzLT5wcl9wd3duCT0gcnNwLT5wb3J0X25hbWU7CisJCWxwcy0+cHJfbnd3bgk9IHJzcC0+bm9kZV9uYW1lOworCQlscHMtPmF1dGhfcmVxCT0gcnNwLT5hdXRoX3JlcTsKKwkJbHBzLT5scF9tYWMJPSByc3AtPmxwX21hYzsKKwkJbHBzLT5icmNkX3N3aXRjaCA9IHJzcC0+YnJjZF9zd2l0Y2g7CisJCWxwcy0+ZmNmX21hYwk9IHJzcC0+ZmNmX21hYzsKKworCQlicmVhazsKKworCWNhc2UgQkZBX1NUQVRVU19GQUJSSUNfUkpUOgorCQlscHMtPmxzcmp0X3JzbiA9IHJzcC0+bHNyanRfcnNuOworCQlscHMtPmxzcmp0X2V4cGwgPSByc3AtPmxzcmp0X2V4cGw7CisKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9TVEFUVVNfRVBST1RPQ09MOgorCQlscHMtPmV4dF9zdGF0dXMgPSByc3AtPmV4dF9zdGF0dXM7CisKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQkvKiBOb3RoaW5nIHRvIGRvIHdpdGggb3RoZXIgc3RhdHVzICovCisJCWJyZWFrOworCX0KKworCWJmYV9zbV9zZW5kX2V2ZW50KGxwcywgQkZBX0xQU19TTV9GV1JTUCk7Cit9CisKKy8qKgorICogRmlybXdhcmUgbG9nb3V0IHJlc3BvbnNlCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfbHBzX2xvZ291dF9yc3Aoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbHBzX2xvZ291dF9yc3BfcyAqcnNwKQoreworCXN0cnVjdCBiZmFfbHBzX21vZF9zCSptb2QgPSBCRkFfTFBTX01PRChiZmEpOworCXN0cnVjdCBiZmFfbHBzX3MJKmxwczsKKworCWJmYV9hc3NlcnQocnNwLT5scF90YWcgPCBtb2QtPm51bV9scHMpOworCWxwcyA9IEJGQV9MUFNfRlJPTV9UQUcobW9kLCByc3AtPmxwX3RhZyk7CisKKwliZmFfc21fc2VuZF9ldmVudChscHMsIEJGQV9MUFNfU01fRldSU1ApOworfQorCisvKioKKyAqIFNwYWNlIGlzIGF2YWlsYWJsZSBpbiByZXF1ZXN0IHF1ZXVlLCByZXN1bWUgcXVldWVpbmcgcmVxdWVzdCB0byBmaXJtd2FyZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfcmVxcV9yZXN1bWUodm9pZCAqbHBzX2FyZykKK3sKKwlzdHJ1Y3QgYmZhX2xwc19zCSpscHMgPSBscHNfYXJnOworCisJYmZhX3NtX3NlbmRfZXZlbnQobHBzLCBCRkFfTFBTX1NNX1JFU1VNRSk7Cit9CisKKy8qKgorICogbHBzIGlzIGZyZWVkIC0tIHRyaWdnZXJlZCBieSB2cG9ydCBkZWxldGUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfZnJlZShzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJc3RydWN0IGJmYV9scHNfbW9kX3MJKm1vZCA9IEJGQV9MUFNfTU9EKGxwcy0+YmZhKTsKKworCWxpc3RfZGVsKCZscHMtPnFlKTsKKwlsaXN0X2FkZF90YWlsKCZscHMtPnFlLCAmbW9kLT5scHNfZnJlZV9xKTsKK30KKworLyoqCisgKiBzZW5kIGxvZ2luIHJlcXVlc3QgdG8gZmlybXdhcmUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfc2VuZF9sb2dpbihzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJc3RydWN0IGJmaV9scHNfbG9naW5fcmVxX3MJKm07CisKKwltID0gYmZhX3JlcXFfbmV4dChscHMtPmJmYSwgbHBzLT5yZXFxKTsKKwliZmFfYXNzZXJ0KG0pOworCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19MUFMsIEJGSV9MUFNfSDJJX0xPR0lOX1JFUSwKKwkJCWJmYV9scHVpZChscHMtPmJmYSkpOworCisJbS0+bHBfdGFnCT0gbHBzLT5scF90YWc7CisJbS0+YWxwYQkJPSBscHMtPmFscGE7CisJbS0+cGR1X3NpemUJPSBiZmFfb3NfaHRvbnMobHBzLT5wZHVzeik7CisJbS0+cHd3bgkJPSBscHMtPnB3d247CisJbS0+bnd3bgkJPSBscHMtPm53d247CisJbS0+ZmRpc2MJPSBscHMtPmZkaXNjOworCW0tPmF1dGhfZW4JPSBscHMtPmF1dGhfZW47CisKKwliZmFfcmVxcV9wcm9kdWNlKGxwcy0+YmZhLCBscHMtPnJlcXEpOworfQorCisvKioKKyAqIHNlbmQgbG9nb3V0IHJlcXVlc3QgdG8gZmlybXdhcmUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfc2VuZF9sb2dvdXQoc3RydWN0IGJmYV9scHNfcyAqbHBzKQoreworCXN0cnVjdCBiZmlfbHBzX2xvZ291dF9yZXFfcyAqbTsKKworCW0gPSBiZmFfcmVxcV9uZXh0KGxwcy0+YmZhLCBscHMtPnJlcXEpOworCWJmYV9hc3NlcnQobSk7CisKKwliZmlfaDJpX3NldChtLT5taCwgQkZJX01DX0xQUywgQkZJX0xQU19IMklfTE9HT1VUX1JFUSwKKwkJCWJmYV9scHVpZChscHMtPmJmYSkpOworCisJbS0+bHBfdGFnICAgID0gbHBzLT5scF90YWc7CisJbS0+cG9ydF9uYW1lID0gbHBzLT5wd3duOworCWJmYV9yZXFxX3Byb2R1Y2UobHBzLT5iZmEsIGxwcy0+cmVxcSk7Cit9CisKKy8qKgorICogSW5kaXJlY3QgbG9naW4gY29tcGxldGlvbiBoYW5kbGVyIGZvciBub24tZmNzCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfbHBzX2xvZ2luX2NvbXBfY2Iodm9pZCAqYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfbHBzX3MgKmxwcwk9IGFyZzsKKworCWlmICghY29tcGxldGUpCisJCXJldHVybjsKKworCWlmIChscHMtPmZkaXNjKQorCQliZmFfY2JfbHBzX2ZkaXNjX2NvbXAobHBzLT5iZmEtPmJmYWQsIGxwcy0+dWFyZywgbHBzLT5zdGF0dXMpOworCWVsc2UKKwkJYmZhX2NiX2xwc19mbG9naV9jb21wKGxwcy0+YmZhLT5iZmFkLCBscHMtPnVhcmcsIGxwcy0+c3RhdHVzKTsKK30KKworLyoqCisgKiBMb2dpbiBjb21wbGV0aW9uIGhhbmRsZXIgLS0gZGlyZWN0IGNhbGwgZm9yIGZjcywgcXVldWUgZm9yIG90aGVycworICovCitzdGF0aWMgdm9pZAorYmZhX2xwc19sb2dpbl9jb21wKHN0cnVjdCBiZmFfbHBzX3MgKmxwcykKK3sKKwlpZiAoIWxwcy0+YmZhLT5mY3MpIHsKKwkJYmZhX2NiX3F1ZXVlKGxwcy0+YmZhLCAmbHBzLT5oY2JfcWUsCisJCQkJYmZhX2xwc19sb2dpbl9jb21wX2NiLCBscHMpOworCQlyZXR1cm47CisJfQorCisJaWYgKGxwcy0+ZmRpc2MpCisJCWJmYV9jYl9scHNfZmRpc2NfY29tcChscHMtPmJmYS0+YmZhZCwgbHBzLT51YXJnLCBscHMtPnN0YXR1cyk7CisJZWxzZQorCQliZmFfY2JfbHBzX2Zsb2dpX2NvbXAobHBzLT5iZmEtPmJmYWQsIGxwcy0+dWFyZywgbHBzLT5zdGF0dXMpOworfQorCisvKioKKyAqIEluZGlyZWN0IGxvZ291dCBjb21wbGV0aW9uIGhhbmRsZXIgZm9yIG5vbi1mY3MKKyAqLworc3RhdGljIHZvaWQKK2JmYV9scHNfbG9nb3V0X2NvbXBfY2Iodm9pZCAqYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfbHBzX3MgKmxwcwk9IGFyZzsKKworCWlmICghY29tcGxldGUpCisJCXJldHVybjsKKworCWlmIChscHMtPmZkaXNjKQorCQliZmFfY2JfbHBzX2ZkaXNjbG9nb19jb21wKGxwcy0+YmZhLT5iZmFkLCBscHMtPnVhcmcpOworCWVsc2UKKwkJYmZhX2NiX2xwc19mbG9nb19jb21wKGxwcy0+YmZhLT5iZmFkLCBscHMtPnVhcmcpOworfQorCisvKioKKyAqIExvZ291dCBjb21wbGV0aW9uIGhhbmRsZXIgLS0gZGlyZWN0IGNhbGwgZm9yIGZjcywgcXVldWUgZm9yIG90aGVycworICovCitzdGF0aWMgdm9pZAorYmZhX2xwc19sb2dvdXRfY29tcChzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJaWYgKCFscHMtPmJmYS0+ZmNzKSB7CisJCWJmYV9jYl9xdWV1ZShscHMtPmJmYSwgJmxwcy0+aGNiX3FlLAorCQkJCWJmYV9scHNfbG9nb3V0X2NvbXBfY2IsIGxwcyk7CisJCXJldHVybjsKKwl9CisJaWYgKGxwcy0+ZmRpc2MpCisJCWJmYV9jYl9scHNfZmRpc2Nsb2dvX2NvbXAobHBzLT5iZmEtPmJmYWQsIGxwcy0+dWFyZyk7CisJZWxzZQorCQliZmFfY2JfbHBzX2Zsb2dvX2NvbXAobHBzLT5iZmEtPmJmYWQsIGxwcy0+dWFyZyk7Cit9CisKKworCisvKioKKyAqICBscHNfcHVibGljIEJGQSBMUFMgcHVibGljIGZ1bmN0aW9ucworICovCisKKy8qKgorICogQWxsb2NhdGUgYSBscG9ydCBzcnZpY2UgdGFnLgorICovCitzdHJ1Y3QgYmZhX2xwc19zICAqCitiZmFfbHBzX2FsbG9jKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfbHBzX21vZF9zCSptb2QgPSBCRkFfTFBTX01PRChiZmEpOworCXN0cnVjdCBiZmFfbHBzX3MJKmxwcyA9IE5VTEw7CisKKwliZmFfcV9kZXEoJm1vZC0+bHBzX2ZyZWVfcSwgJmxwcyk7CisKKwlpZiAobHBzID09IE5VTEwpCisJCXJldHVybiBOVUxMOworCisJbGlzdF9hZGRfdGFpbCgmbHBzLT5xZSwgJm1vZC0+bHBzX2FjdGl2ZV9xKTsKKworCWJmYV9zbV9zZXRfc3RhdGUobHBzLCBiZmFfbHBzX3NtX2luaXQpOworCXJldHVybiBscHM7Cit9CisKKy8qKgorICogRnJlZSBscG9ydCBzZXJ2aWNlIHRhZy4gVGhpcyBjYW4gYmUgY2FsbGVkIGFueXRpbWUgYWZ0ZXIgYW4gYWxsb2MuCisgKiBObyBuZWVkIHRvIHdhaXQgZm9yIGFueSBwZW5kaW5nIGxvZ2luL2xvZ291dCBjb21wbGV0aW9ucy4KKyAqLwordm9pZAorYmZhX2xwc19kZWxldGUoc3RydWN0IGJmYV9scHNfcyAqbHBzKQoreworCWJmYV9zbV9zZW5kX2V2ZW50KGxwcywgQkZBX0xQU19TTV9ERUxFVEUpOworfQorCisvKioKKyAqIEluaXRpYXRlIGEgbHBvcnQgbG9naW4uCisgKi8KK3ZvaWQKK2JmYV9scHNfZmxvZ2koc3RydWN0IGJmYV9scHNfcyAqbHBzLCB2b2lkICp1YXJnLCB1OCBhbHBhLCB1MTYgcGR1c3osCisJd3duX3QgcHd3biwgd3duX3Qgbnd3biwgYmZhX2Jvb2xlYW5fdCBhdXRoX2VuKQoreworCWxwcy0+dWFyZwk9IHVhcmc7CisJbHBzLT5hbHBhCT0gYWxwYTsKKwlscHMtPnBkdXN6CT0gcGR1c3o7CisJbHBzLT5wd3duCT0gcHd3bjsKKwlscHMtPm53d24JPSBud3duOworCWxwcy0+ZmRpc2MJPSBCRkFfRkFMU0U7CisJbHBzLT5hdXRoX2VuCT0gYXV0aF9lbjsKKwliZmFfc21fc2VuZF9ldmVudChscHMsIEJGQV9MUFNfU01fTE9HSU4pOworfQorCisvKioKKyAqIEluaXRpYXRlIGEgbHBvcnQgZmRpc2MgbG9naW4uCisgKi8KK3ZvaWQKK2JmYV9scHNfZmRpc2Moc3RydWN0IGJmYV9scHNfcyAqbHBzLCB2b2lkICp1YXJnLCB1MTYgcGR1c3osIHd3bl90IHB3d24sCisJd3duX3Qgbnd3bikKK3sKKwlscHMtPnVhcmcJPSB1YXJnOworCWxwcy0+YWxwYQk9IDA7CisJbHBzLT5wZHVzegk9IHBkdXN6OworCWxwcy0+cHd3bgk9IHB3d247CisJbHBzLT5ud3duCT0gbnd3bjsKKwlscHMtPmZkaXNjCT0gQkZBX1RSVUU7CisJbHBzLT5hdXRoX2VuCT0gQkZBX0ZBTFNFOworCWJmYV9zbV9zZW5kX2V2ZW50KGxwcywgQkZBX0xQU19TTV9MT0dJTik7Cit9CisKKy8qKgorICogSW5pdGlhdGUgYSBscG9ydCBsb2dvdXQgKGZsb2dpKS4KKyAqLwordm9pZAorYmZhX2xwc19mbG9nbyhzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJYmZhX3NtX3NlbmRfZXZlbnQobHBzLCBCRkFfTFBTX1NNX0xPR09VVCk7Cit9CisKKy8qKgorICogSW5pdGlhdGUgYSBscG9ydCBGRFNJQyBsb2dvdXQuCisgKi8KK3ZvaWQKK2JmYV9scHNfZmRpc2Nsb2dvKHN0cnVjdCBiZmFfbHBzX3MgKmxwcykKK3sKKwliZmFfc21fc2VuZF9ldmVudChscHMsIEJGQV9MUFNfU01fTE9HT1VUKTsKK30KKworLyoqCisgKiBEaXNjYXJkIGEgcGVuZGluZyBsb2dpbiByZXF1ZXN0IC0tIHNob3VsZCBiZSBjYWxsZWQgb25seSBmb3IKKyAqIGxpbmsgZG93biBoYW5kbGluZy4KKyAqLwordm9pZAorYmZhX2xwc19kaXNjYXJkKHN0cnVjdCBiZmFfbHBzX3MgKmxwcykKK3sKKwliZmFfc21fc2VuZF9ldmVudChscHMsIEJGQV9MUFNfU01fT0ZGTElORSk7Cit9CisKKy8qKgorICogUmV0dXJuIGxwb3J0IHNlcnZpY2VzIHRhZworICovCit1OAorYmZhX2xwc19nZXRfdGFnKHN0cnVjdCBiZmFfbHBzX3MgKmxwcykKK3sKKwlyZXR1cm4gbHBzLT5scF90YWc7Cit9CisKKy8qKgorICogUmV0dXJuIGxwb3J0IHNlcnZpY2VzIHRhZyBnaXZlbiB0aGUgcGlkCisgKi8KK3U4CitiZmFfbHBzX2dldF90YWdfZnJvbV9waWQoc3RydWN0IGJmYV9zICpiZmEsIHUzMiBwaWQpCit7CisJc3RydWN0IGJmYV9scHNfbW9kX3MJKm1vZCA9IEJGQV9MUFNfTU9EKGJmYSk7CisJc3RydWN0IGJmYV9scHNfcwkqbHBzOworCWludAkJCWk7CisKKwlmb3IgKGkgPSAwLCBscHMgPSBtb2QtPmxwc19hcnI7IGkgPCBtb2QtPm51bV9scHM7IGkrKywgbHBzKyspIHsKKwkJaWYgKGxwcy0+bHBfcGlkID09IHBpZCkKKwkJCXJldHVybiBscHMtPmxwX3RhZzsKKwl9CisKKwkvKiBSZXR1cm4gYmFzZSBwb3J0IHRhZyBhbnl3YXkgKi8KKwlyZXR1cm4gMDsKK30KKworLyoqCisgKiByZXR1cm4gaWYgZmFicmljIGxvZ2luIGluZGljYXRlcyBzdXBwb3J0IGZvciBOUElWCisgKi8KK2JmYV9ib29sZWFuX3QKK2JmYV9scHNfaXNfbnBpdl9lbihzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJcmV0dXJuIGxwcy0+bnBpdl9lbjsKK30KKworLyoqCisgKiBSZXR1cm4gVFJVRSBpZiBhdHRhY2hlZCB0byBGLVBvcnQsIGVsc2UgcmV0dXJuIEZBTFNFCisgKi8KK2JmYV9ib29sZWFuX3QKK2JmYV9scHNfaXNfZnBvcnQoc3RydWN0IGJmYV9scHNfcyAqbHBzKQoreworCXJldHVybiBscHMtPmZwb3J0OworfQorCisvKioKKyAqIFJldHVybiBUUlVFIGlmIGF0dGFjaGVkIHRvIGEgQnJvY2FkZSBGYWJyaWMKKyAqLworYmZhX2Jvb2xlYW5fdAorYmZhX2xwc19pc19icmNkX2ZhYnJpYyhzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJcmV0dXJuIGxwcy0+YnJjZF9zd2l0Y2g7Cit9CisvKioKKyAqIHJldHVybiBUUlVFIGlmIGF1dGhlbnRpY2F0aW9uIGlzIHJlcXVpcmVkCisgKi8KK2JmYV9ib29sZWFuX3QKK2JmYV9scHNfaXNfYXV0aHJlcShzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJcmV0dXJuIGxwcy0+YXV0aF9yZXE7Cit9CisKK2JmYV9lcHJvdG9fc3RhdHVzX3QKK2JmYV9scHNfZ2V0X2V4dHN0YXR1cyhzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJcmV0dXJuIGxwcy0+ZXh0X3N0YXR1czsKK30KKworLyoqCisgKiByZXR1cm4gcG9ydCBpZCBhc3NpZ25lZCB0byB0aGUgbHBvcnQKKyAqLwordTMyCitiZmFfbHBzX2dldF9waWQoc3RydWN0IGJmYV9scHNfcyAqbHBzKQoreworCXJldHVybiBscHMtPmxwX3BpZDsKK30KKworLyoqCisgKiBSZXR1cm4gYmJfY3JlZGl0IGFzc2lnbmVkIGluIEZMT0dJIHJlc3BvbnNlCisgKi8KK3UxNgorYmZhX2xwc19nZXRfcGVlcl9iYmNyZWRpdChzdHJ1Y3QgYmZhX2xwc19zICpscHMpCit7CisJcmV0dXJuIGxwcy0+cHJfYmJjcmVkOworfQorCisvKioKKyAqIFJldHVybiBwZWVyIHBvcnQgbmFtZQorICovCit3d25fdAorYmZhX2xwc19nZXRfcGVlcl9wd3duKHN0cnVjdCBiZmFfbHBzX3MgKmxwcykKK3sKKwlyZXR1cm4gbHBzLT5wcl9wd3duOworfQorCisvKioKKyAqIFJldHVybiBwZWVyIG5vZGUgbmFtZQorICovCit3d25fdAorYmZhX2xwc19nZXRfcGVlcl9ud3duKHN0cnVjdCBiZmFfbHBzX3MgKmxwcykKK3sKKwlyZXR1cm4gbHBzLT5wcl9ud3duOworfQorCisvKioKKyAqIHJldHVybiByZWFzb24gY29kZSBpZiBsb2dpbiByZXF1ZXN0IGlzIHJlamVjdGVkCisgKi8KK3U4CitiZmFfbHBzX2dldF9sc3JqdF9yc24oc3RydWN0IGJmYV9scHNfcyAqbHBzKQoreworCXJldHVybiBscHMtPmxzcmp0X3JzbjsKK30KKworLyoqCisgKiByZXR1cm4gZXhwbGFuYXRpb24gY29kZSBpZiBsb2dpbiByZXF1ZXN0IGlzIHJlamVjdGVkCisgKi8KK3U4CitiZmFfbHBzX2dldF9sc3JqdF9leHBsKHN0cnVjdCBiZmFfbHBzX3MgKmxwcykKK3sKKwlyZXR1cm4gbHBzLT5sc3JqdF9leHBsOworfQorCisKKy8qKgorICogTFBTIGZpcm13YXJlIG1lc3NhZ2UgY2xhc3MgaGFuZGxlci4KKyAqLwordm9pZAorYmZhX2xwc19pc3Ioc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm0pCit7CisJdW5pb24gYmZpX2xwc19pMmhfbXNnX3UJbXNnOworCisJYmZhX3RyYyhiZmEsIG0tPm1oZHIubXNnX2lkKTsKKwltc2cubXNnID0gbTsKKworCXN3aXRjaCAobS0+bWhkci5tc2dfaWQpIHsKKwljYXNlIEJGSV9MUFNfSDJJX0xPR0lOX1JTUDoKKwkJYmZhX2xwc19sb2dpbl9yc3AoYmZhLCBtc2cubG9naW5fcnNwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9MUFNfSDJJX0xPR09VVF9SU1A6CisJCWJmYV9scHNfbG9nb3V0X3JzcChiZmEsIG1zZy5sb2dvdXRfcnNwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfdHJjKGJmYSwgbS0+bWhkci5tc2dfaWQpOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9scHNfcHJpdi5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfbHBzX3ByaXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMTZjNmNlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfbHBzX3ByaXYuaApAQCAtMCwwICsxLDM4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfTFBTX1BSSVZfSF9fCisjZGVmaW5lIF9fQkZBX0xQU19QUklWX0hfXworCisjaW5jbHVkZSA8YmZhX3N2Yy5oPgorCitzdHJ1Y3QgYmZhX2xwc19tb2RfcyB7CisJc3RydWN0IGxpc3RfaGVhZAkJbHBzX2ZyZWVfcTsKKwlzdHJ1Y3QgbGlzdF9oZWFkCQlscHNfYWN0aXZlX3E7CisJc3RydWN0IGJmYV9scHNfcwkqbHBzX2FycjsKKwlpbnQJCQludW1fbHBzOworfTsKKworI2RlZmluZSBCRkFfTFBTX01PRChfX2JmYSkJCSgmKF9fYmZhKS0+bW9kdWxlcy5scHNfbW9kKQorI2RlZmluZSBCRkFfTFBTX0ZST01fVEFHKF9fbW9kLCBfX3RhZykJKCYoX19tb2QpLT5scHNfYXJyW19fdGFnXSkKKworLyoKKyAqIGV4dGVybmFsIGZ1bmN0aW9ucworICovCit2b2lkCWJmYV9scHNfaXNyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZpX21zZ19zICptc2cpOworCisjZW5kaWYgLyogX19CRkFfTFBTX1BSSVZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9tb2R1bGUuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX21vZHVsZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjMyZWRhOGUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9tb2R1bGUuYwpAQCAtMCwwICsxLDkwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaW5jbHVkZSA8YmZhLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wY2kuaD4KKyNpbmNsdWRlIDxjcy9iZmFfZGVidWcuaD4KKyNpbmNsdWRlIDxiZmFfaW9jZmMuaD4KKworLyoqCisgKiBCRkEgbW9kdWxlIGxpc3QgdGVybWluYXRlZCBieSBOVUxMCisgKi8KK3N0cnVjdCBiZmFfbW9kdWxlX3MgKmhhbF9tb2RzW10gPSB7CisJJmhhbF9tb2Rfc2dwZywKKwkmaGFsX21vZF9wcG9ydCwKKwkmaGFsX21vZF9mY3hwLAorCSZoYWxfbW9kX2xwcywKKwkmaGFsX21vZF91ZiwKKwkmaGFsX21vZF9ycG9ydCwKKwkmaGFsX21vZF9mY3BpbSwKKyNpZmRlZiBCRkFfQ0ZHX1BCSU5ECisJJmhhbF9tb2RfcGJpbmQsCisjZW5kaWYKKwlOVUxMCit9OworCisvKioKKyAqIE1lc3NhZ2UgaGFuZGxlcnMgZm9yIHZhcmlvdXMgbW9kdWxlcy4KKyAqLworYmZhX2lzcl9mdW5jX3QgIGJmYV9pc3JzW0JGSV9NQ19NQVhdID0geworCWJmYV9pc3JfdW5oYW5kbGVkLAkvKiBOT05FICovCisJYmZhX2lzcl91bmhhbmRsZWQsCS8qIEJGSV9NQ19JT0MgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogQkZJX01DX0RJQUcgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogQkZJX01DX0ZMQVNIICovCisJYmZhX2lzcl91bmhhbmRsZWQsCS8qIEJGSV9NQ19DRUUgKi8KKwliZmFfcHBvcnRfaXNyLAkJLyogQkZJX01DX1BPUlQgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogQkZJX01DX0lPQ0ZDICovCisJYmZhX2lzcl91bmhhbmRsZWQsCS8qIEJGSV9NQ19MTCAqLworCWJmYV91Zl9pc3IsCQkvKiBCRklfTUNfVUYgKi8KKwliZmFfZmN4cF9pc3IsCQkvKiBCRklfTUNfRkNYUCAqLworCWJmYV9scHNfaXNyLAkJLyogQkZJX01DX0xQUyAqLworCWJmYV9ycG9ydF9pc3IsCQkvKiBCRklfTUNfUlBPUlQgKi8KKwliZmFfaXRuaW1faXNyLAkJLyogQkZJX01DX0lUTklNICovCisJYmZhX2lzcl91bmhhbmRsZWQsCS8qIEJGSV9NQ19JT0lNX1JFQUQgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogQkZJX01DX0lPSU1fV1JJVEUgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogQkZJX01DX0lPSU1fSU8gKi8KKwliZmFfaW9pbV9pc3IsCQkvKiBCRklfTUNfSU9JTSAqLworCWJmYV9pb2ltX2dvb2RfY29tcF9pc3IsCS8qIEJGSV9NQ19JT0lNX0lPQ09NICovCisJYmZhX3Rza2ltX2lzciwJCS8qIEJGSV9NQ19UU0tJTSAqLworCWJmYV9pc3JfdW5oYW5kbGVkLAkvKiBCRklfTUNfU0JPT1QgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogQkZJX01DX0lQRkMgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogQkZJX01DX1BPUlQgKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogLS0tLS0tLS0tICovCisJYmZhX2lzcl91bmhhbmRsZWQsCS8qIC0tLS0tLS0tLSAqLworCWJmYV9pc3JfdW5oYW5kbGVkLAkvKiAtLS0tLS0tLS0gKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogLS0tLS0tLS0tICovCisJYmZhX2lzcl91bmhhbmRsZWQsCS8qIC0tLS0tLS0tLSAqLworCWJmYV9pc3JfdW5oYW5kbGVkLAkvKiAtLS0tLS0tLS0gKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogLS0tLS0tLS0tICovCisJYmZhX2lzcl91bmhhbmRsZWQsCS8qIC0tLS0tLS0tLSAqLworCWJmYV9pc3JfdW5oYW5kbGVkLAkvKiAtLS0tLS0tLS0gKi8KKwliZmFfaXNyX3VuaGFuZGxlZCwJLyogLS0tLS0tLS0tICovCit9OworCisvKioKKyAqIE1lc3NhZ2UgaGFuZGxlcnMgZm9yIG1haWxib3ggY29tbWFuZCBjbGFzc2VzCisgKi8KK2JmYV9pb2NfbWJveF9tY2Z1bmNfdCAgYmZhX21ib3hfaXNyc1tCRklfTUNfTUFYXSA9IHsKKwlOVUxMLAorCU5VTEwsCQkJLyogQkZJX01DX0lPQwkqLworCU5VTEwsCQkJLyogQkZJX01DX0RJQUcJKi8KKwlOVUxMLAkJLyogQkZJX01DX0ZMQVNIICovCisJTlVMTCwJCQkvKiBCRklfTUNfQ0VFCSovCisJTlVMTCwJCQkvKiBCRklfTUNfUE9SVAkqLworCWJmYV9pb2NmY19pc3IsCQkvKiBCRklfTUNfSU9DRkMgKi8KKwlOVUxMLAorfTsKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfbW9kdWxlc19wcml2LmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9tb2R1bGVzX3ByaXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45NmY3MDUzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfbW9kdWxlc19wcml2LmgKQEAgLTAsMCArMSw0MyBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX01PRFVMRVNfUFJJVl9IX18KKyNkZWZpbmUgX19CRkFfTU9EVUxFU19QUklWX0hfXworCisjaW5jbHVkZSAiYmZhX3VmX3ByaXYuaCIKKyNpbmNsdWRlICJiZmFfcG9ydF9wcml2LmgiCisjaW5jbHVkZSAiYmZhX3Jwb3J0X3ByaXYuaCIKKyNpbmNsdWRlICJiZmFfZmN4cF9wcml2LmgiCisjaW5jbHVkZSAiYmZhX2xwc19wcml2LmgiCisjaW5jbHVkZSAiYmZhX2ZjcGltX3ByaXYuaCIKKyNpbmNsdWRlIDxjZWUvYmZhX2NlZS5oPgorI2luY2x1ZGUgPHBvcnQvYmZhX3BvcnQuaD4KKworCitzdHJ1Y3QgYmZhX21vZHVsZXNfcyB7CisJc3RydWN0IGJmYV9wcG9ydF9zCXBwb3J0OwkvKiAgcGh5c2ljYWwgcG9ydCBtb2R1bGUJKi8KKwlzdHJ1Y3QgYmZhX2ZjeHBfbW9kX3MgZmN4cF9tb2Q7IC8qICBmY3hwIG1vZHVsZQkJKi8KKwlzdHJ1Y3QgYmZhX2xwc19tb2RfcyBscHNfbW9kOyAgIC8qICBmY3hwIG1vZHVsZQkJKi8KKwlzdHJ1Y3QgYmZhX3VmX21vZF9zIHVmX21vZDsJLyogIHVuc29saWNpdGVkIGZyYW1lIG1vZHVsZQkqLworCXN0cnVjdCBiZmFfcnBvcnRfbW9kX3MgcnBvcnRfbW9kOyAvKiAgcmVtb3RlIHBvcnQgbW9kdWxlCSovCisJc3RydWN0IGJmYV9mY3BpbV9tb2RfcyBmY3BpbV9tb2Q7IC8qICBGQ1AgaW5pdGlhdG9yIG1vZHVsZQkqLworCXN0cnVjdCBiZmFfc2dwZ19tb2RfcyBzZ3BnX21vZDsgLyogIFNHIHBhZ2UgbW9kdWxlCQkqLworCXN0cnVjdCBiZmFfY2VlX3MgY2VlOyAgIAkvKiAgQ0VFIE1vZHVsZSAgICAgICAgICAgICAgICAgKi8KKwlzdHJ1Y3QgYmZhX3BvcnRfcyBwb3J0OwkJLyogIFBoeXNpY2FsIHBvcnQgbW9kdWxlCSovCit9OworCisjZW5kaWYgLyogX19CRkFfTU9EVUxFU19QUklWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfb3NfaW5jLmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9vc19pbmMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMGE4OWY3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfb3NfaW5jLmgKQEAgLTAsMCArMSwyMjIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiBDb250YWlucyBkZWNsYXJhdGlvbnMgYWxsIE9TIFNwZWNpZmljIGZpbGVzIG5lZWRlZCBmb3IgQkZBIGxheWVyCisgKi8KKworI2lmbmRlZiBfX0JGQV9PU19JTkNfSF9fCisjZGVmaW5lIF9fQkZBX09TX0lOQ19IX18KKworI2lmbmRlZiBfX0tFUk5FTF9fCisjaW5jbHVkZSA8c3RkaW50Lmg+CisjZWxzZQorI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisKKyNpbmNsdWRlIDxsaW51eC92ZXJzaW9uLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisKKyNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgorI2RlZmluZSBTRVRfTU9EVUxFX1ZFUlNJT04oVkVSKQorCisjaW5jbHVkZSA8bGludXgvaWRyLmg+CisKKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9jZGV2Lmg+CisjaW5jbHVkZSA8bGludXgvZnMuaD4KKyNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgorI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KKworI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgorCisjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX2hvc3QuaD4KKworI2luY2x1ZGUgPHNjc2kvc2NzaV90Y3EuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfdHJhbnNwb3J0X2ZjLmg+CisjaW5jbHVkZSA8c2NzaS9zY3NpX3RyYW5zcG9ydC5oPgorCisjZGVmaW5lIEJGQV9FUlIJCQlLRVJOX0VSUgorI2RlZmluZSBCRkFfV0FSTklORwkJS0VSTl9XQVJOSU5HCisjZGVmaW5lIEJGQV9OT1RJQ0UJCUtFUk5fTk9USUNFCisjZGVmaW5lIEJGQV9JTkZPCQlLRVJOX0lORk8KKyNkZWZpbmUgQkZBX0RFQlVHCQlLRVJOX0RFQlVHCisKKyNkZWZpbmUgTE9HX0JGQURfSU5JVAkJMHgwMDAwMDAwMQorI2RlZmluZSBMT0dfRkNQX0lPCQkweDAwMDAwMDAyCisKKyNpZmRlZiBERUJVRworI2RlZmluZSBCRkFfTE9HX1RSQUNFKGJmYWQsIGxldmVsLCBtYXNrLCBmbXQsIGFyZy4uLikJCQlcCisJCUJGQV9MT0coYmZhZCwgbGV2ZWwsIG1hc2ssIGZtdCwgIyMgYXJnKQorI2RlZmluZSBCRkFfREVWX1RSQUNFKGJmYWQsIGxldmVsLCBmbXQsIGFyZy4uLikJCQkJXAorCQlCRkFfREVWX1BSSU5URihiZmFkLCBsZXZlbCwgZm10LCAjIyBhcmcpCisjZGVmaW5lIEJGQV9UUkFDRShsZXZlbCwgZm10LCBhcmcuLi4pCQkJCQlcCisJCUJGQV9QUklOVEYobGV2ZWwsIGZtdCwgIyMgYXJnKQorI2Vsc2UKKyNkZWZpbmUgQkZBX0xPR19UUkFDRShiZmFkLCBsZXZlbCwgbWFzaywgZm10LCBhcmcuLi4pCisjZGVmaW5lIEJGQV9ERVZfVFJBQ0UoYmZhZCwgbGV2ZWwsIGZtdCwgYXJnLi4uKQorI2RlZmluZSBCRkFfVFJBQ0UobGV2ZWwsIGZtdCwgYXJnLi4uKQorI2VuZGlmCisKKyNkZWZpbmUgQkZBX0FTU0VSVChwKSBkbyB7CQkJCQkJXAorCWlmICghKHApKSB7ICAgICAgXAorCQlwcmludGsoS0VSTl9FUlIgImFzc2VydCglcykgZmFpbGVkIGF0ICVzOiVkXG4iLAkJXAorCQkjcCwgX19GSUxFX18sIF9fTElORV9fKTsgICAgICBcCisJCUJVRygpOyAgICAgIFwKKwl9CQkJCQkJCQlcCit9IHdoaWxlICgwKQorCisKKyNkZWZpbmUgQkZBX0xPRyhiZmFkLCBsZXZlbCwgbWFzaywgZm10LCBhcmcuLi4pCQkJCVwKK2RvIHsgCQkJCQkJCQkJXAorCWlmICgoKG1hc2spICYgKCgoc3RydWN0IGJmYWRfcyAqKShiZmFkKSktPgkJCVwKKwkJY2ZnX2RhdGFbY2ZnX2xvZ19tYXNrXSkpIHx8IChsZXZlbFsxXSA8PSAnMycpKQkJXAorCQlkZXZfcHJpbnRrKGxldmVsLCAmKCgoc3RydWN0IGJmYWRfcyAqKQkJCVwKKwkJCShiZmFkKSktPnBjaWRldi0+ZGV2KSwgZm10LCAjI2FyZyk7ICAgICAgXAorfSB3aGlsZSAoMCkKKworI2lmbmRlZiBCRkFfREVWX1BSSU5URgorI2RlZmluZSBCRkFfREVWX1BSSU5URihiZmFkLCBsZXZlbCwgZm10LCBhcmcuLi4pCQkJXAorCQlkZXZfcHJpbnRrKGxldmVsLCAmKCgoc3RydWN0IGJmYWRfcyAqKQkJCVwKKwkJCShiZmFkKSktPnBjaWRldi0+ZGV2KSwgZm10LCAjI2FyZyk7CisjZW5kaWYKKworI2RlZmluZSBCRkFfUFJJTlRGKGxldmVsLCBmbXQsIGFyZy4uLikJCQkJCVwKKwkJcHJpbnRrKGxldmVsIGZtdCwgIyNhcmcpOworCitpbnQgYmZhX29zX01XQih2b2lkICopOworCisjZGVmaW5lIGJmYV9vc19tbWlvd2IoKQkJbW1pb3diKCkKKworI2RlZmluZSBiZmFfc3dhcF8zYihfeCkJCQkJXAorCSgoKChfeCkgJiAweGZmKSA8PCAxNikgfAkJXAorCSgoX3gpICYgMHgwMGZmMDApIHwJCQlcCisJKCgoX3gpICYgMHhmZjAwMDApID4+IDE2KSkKKworI2RlZmluZSBiZmFfc3dhcF84YihfeCkgCQkJCVwKKyAgICAgKCgoKF94KSAmIDB4ZmYwMDAwMDAwMDAwMDAwMHVsbCkgPj4gNTYpCQlcCisgICAgICB8ICgoKF94KSAmIDB4MDBmZjAwMDAwMDAwMDAwMHVsbCkgPj4gNDApCQlcCisgICAgICB8ICgoKF94KSAmIDB4MDAwMGZmMDAwMDAwMDAwMHVsbCkgPj4gMjQpCQlcCisgICAgICB8ICgoKF94KSAmIDB4MDAwMDAwZmYwMDAwMDAwMHVsbCkgPj4gOCkJCVwKKyAgICAgIHwgKCgoX3gpICYgMHgwMDAwMDAwMGZmMDAwMDAwdWxsKSA8PCA4KQkJXAorICAgICAgfCAoKChfeCkgJiAweDAwMDAwMDAwMDBmZjAwMDB1bGwpIDw8IDI0KQkJXAorICAgICAgfCAoKChfeCkgJiAweDAwMDAwMDAwMDAwMGZmMDB1bGwpIDw8IDQwKQkJXAorICAgICAgfCAoKChfeCkgJiAweDAwMDAwMDAwMDAwMDAwZmZ1bGwpIDw8IDU2KSkKKworI2RlZmluZSBiZmFfb3Nfc3dhcDMyKF94KSAJCQlcCisJKCgoKF94KSAmIDB4ZmYpIDw8IDI0KSAJCXwJXAorCSgoKF94KSAmIDB4MDAwMGZmMDApIDw8IDgpCXwJXAorCSgoKF94KSAmIDB4MDBmZjAwMDApID4+IDgpCXwJXAorCSgoKF94KSAmIDB4ZmYwMDAwMDApID4+IDI0KSkKKworCisjaWZuZGVmIF9fQklHRU5ESUFOCisjZGVmaW5lIGJmYV9vc19odG9ucyhfeCkgKCh1MTYpKCgoKF94KSAmIDB4ZmYwMCkgPj4gOCkgfCBcCisJCQkJICgoKF94KSAmIDB4MDBmZikgPDwgOCkpKQorCisjZGVmaW5lIGJmYV9vc19odG9ubChfeCkJYmZhX29zX3N3YXAzMihfeCkKKyNkZWZpbmUgYmZhX29zX2h0b25sbChfeCkJYmZhX3N3YXBfOGIoX3gpCisjZGVmaW5lIGJmYV9vc19odG9uM2IoX3gpCWJmYV9zd2FwXzNiKF94KQorCisjZGVmaW5lIGJmYV9vc193dG9sZShfeCkgICAoX3gpCisKKyNlbHNlCisKKyNkZWZpbmUgYmZhX29zX2h0b25zKF94KSAgIChfeCkKKyNkZWZpbmUgYmZhX29zX2h0b25sKF94KSAgIChfeCkKKyNkZWZpbmUgYmZhX29zX2h0b24zYihfeCkgIChfeCkKKyNkZWZpbmUgYmZhX29zX2h0b25sbChfeCkgIChfeCkKKyNkZWZpbmUgYmZhX29zX3d0b2xlKF94KSAgIGJmYV9vc19zd2FwMzIoX3gpCisKKyNlbmRpZgorCisjZGVmaW5lIGJmYV9vc19udG9ocyhfeCkgICBiZmFfb3NfaHRvbnMoX3gpCisjZGVmaW5lIGJmYV9vc19udG9obChfeCkgICBiZmFfb3NfaHRvbmwoX3gpCisjZGVmaW5lIGJmYV9vc19udG9obGwoX3gpICBiZmFfb3NfaHRvbmxsKF94KQorI2RlZmluZSBiZmFfb3NfbnRvaDNiKF94KSAgYmZhX29zX2h0b24zYihfeCkKKworI2RlZmluZSBiZmFfb3NfdTMyKF9fcGE2NCkgKChfX3BhNjQpID4+IDMyKQorCisjZGVmaW5lIGJmYV9vc19tZW1zZXQJbWVtc2V0CisjZGVmaW5lIGJmYV9vc19tZW1jcHkJbWVtY3B5CisjZGVmaW5lIGJmYV9vc191ZGVsYXkJdWRlbGF5CisjZGVmaW5lIGJmYV9vc192c3ByaW50ZiB2c3ByaW50ZgorCisjZGVmaW5lIGJmYV9vc19hc3NpZ24oX190LCBfX3MpIF9fdCA9IF9fcworCisjZGVmaW5lIGJmYV9vc19hZGRyX3QgY2hhciBfX2lvbWVtICoKKyNkZWZpbmUgYmZhX29zX3BhbmljKCkKKworI2RlZmluZSBiZmFfb3NfcmVnX3JlYWQoX3JhZGRyKSBiZmFfb3Nfd3RvbGUocmVhZGwoX3JhZGRyKSkKKyNkZWZpbmUgYmZhX29zX3JlZ193cml0ZShfcmFkZHIsIF92YWwpIHdyaXRlbChiZmFfb3Nfd3RvbGUoKF92YWwpKSwgKF9yYWRkcikpCisjZGVmaW5lIGJmYV9vc19tZW1fcmVhZChfcmFkZHIsIF9vZmYpICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisJYmZhX29zX250b2hsKHJlYWRsKCgoX3JhZGRyKSArIChfb2ZmKSkpKQorI2RlZmluZSBiZmFfb3NfbWVtX3dyaXRlKF9yYWRkciwgX29mZiwgX3ZhbCkgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorCXdyaXRlbChiZmFfb3NfaHRvbmwoKF92YWwpKSwgKChfcmFkZHIpICsgKF9vZmYpKSkKKworI2RlZmluZSBCRkFfVFJDX1RTKF90cmNtKQkJCQkJCVwKKwkJCSh7CQkJCQkJXAorCQkJCXN0cnVjdCB0aW1ldmFsIHR2OwkJCVwKKwkJCQkJCQkJCVwKKwkJCQlkb19nZXR0aW1lb2ZkYXkoJnR2KTsgICAgICBcCisJCQkJKHR2LnR2X3NlYyoxMDAwMDAwK3R2LnR2X3VzZWMpOyAgICAgIFwKKwkJCSB9KQorCitzdHJ1Y3QgYmZhX2xvZ19tb2RfczsKK3ZvaWQgYmZhX29zX3ByaW50ZihzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nX21vZCwgdTMyIG1zZ19pZCwKKwkJCWNvbnN0IGNoYXIgKmZtdCwgLi4uKTsKKyNlbmRpZgorCisjZGVmaW5lIGJvb2xlYW5fdCBpbnQKKworLyoqCisgKiBGb3IgY3VycmVudCB0aW1lIHN0YW1wLCBPUyBBUEkgd2lsbCBmaWxsLWluCisgKi8KK3N0cnVjdCBiZmFfdGltZXZhbF9zIHsKKwl1MzIJdHZfc2VjOwkJLyogIHNlY29uZHMgICAgICAgICovCisJdTMyCXR2X3VzZWM7CS8qICBtaWNyb3NlY29uZHMgICAqLworfTsKKwordm9pZCBiZmFfb3NfZ2V0dGltZW9mZGF5KHN0cnVjdCBiZmFfdGltZXZhbF9zICp0dik7CisKK3N0YXRpYyBpbmxpbmUgdm9pZAord3duMnN0cihjaGFyICp3d25fc3RyLCB1NjQgd3duKQoreworCXVuaW9uIHsKKwkJdTY0IHd3bjsKKwkJdTggYnl0ZVs4XTsKKwl9IHc7CisKKwl3Lnd3biA9IHd3bjsKKwlzcHJpbnRmKHd3bl9zdHIsICIlMDJ4OiUwMng6JTAyeDolMDJ4OiUwMng6JTAyeDolMDJ4OiUwMngiLCB3LmJ5dGVbMF0sCisJCXcuYnl0ZVsxXSwgdy5ieXRlWzJdLCB3LmJ5dGVbM10sIHcuYnl0ZVs0XSwgdy5ieXRlWzVdLAorCQl3LmJ5dGVbNl0sIHcuYnl0ZVs3XSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAorZmNpZDJzdHIoY2hhciAqZmNpZF9zdHIsIHUzMiBmY2lkKQoreworCXVuaW9uIHsKKwkJdTMyIGZjaWQ7CisJCXU4IGJ5dGVbNF07CisJfSBmOworCisJZi5mY2lkID0gZmNpZDsKKwlzcHJpbnRmKGZjaWRfc3RyLCAiJTAyeDolMDJ4OiUwMngiLCBmLmJ5dGVbMV0sIGYuYnl0ZVsyXSwgZi5ieXRlWzNdKTsKK30KKworI2VuZGlmIC8qIF9fQkZBX09TX0lOQ19IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3BvcnQuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3BvcnQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jYWIxOTAyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfcG9ydC5jCkBAIC0wLDAgKzEsNDYwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3BvcnQuaD4KKyNpbmNsdWRlIDxjcy9iZmFfdHJjLmg+CisjaW5jbHVkZSA8Y3MvYmZhX2xvZy5oPgorI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorI2luY2x1ZGUgPHBvcnQvYmZhX3BvcnQuaD4KKyNpbmNsdWRlIDxiZmkvYmZpLmg+CisjaW5jbHVkZSA8YmZpL2JmaV9wb3J0Lmg+CisjaW5jbHVkZSA8YmZhX2lvYy5oPgorI2luY2x1ZGUgPGNuYS9iZmFfY25hX3RyY21vZC5oPgorCitCRkFfVFJDX0ZJTEUoQ05BLCBQT1JUKTsKKworI2RlZmluZSBiZmFfaW9jX3BvcnRpZChfX2lvYykgKChfX2lvYyktPnBvcnRfaWQpCisjZGVmaW5lIGJmYV9scHVpZChfX2FyZykgYmZhX2lvY19wb3J0aWQoJihfX2FyZyktPmlvYykKKworc3RhdGljIHZvaWQKK2JmYV9wb3J0X3N0YXRzX3N3YXAoc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsIHVuaW9uIGJmYV9wcG9ydF9zdGF0c191ICpzdGF0cykKK3sKKwl1MzIgICAgICAgKmRpcCA9ICh1MzIgKikgc3RhdHM7CisJdTMyICAgICAgICB0MCwgdDE7CisJaW50ICAgICAgICAgICAgIGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgc2l6ZW9mKHVuaW9uIGJmYV9wcG9ydF9zdGF0c191KSAvIHNpemVvZih1MzIpOworCSAgICAgaSArPSAyKSB7CisJCXQwID0gZGlwW2ldOworCQl0MSA9IGRpcFtpICsgMV07CisjaWZkZWYgX19CSUdFTkRJQU4KKwkJZGlwW2ldID0gYmZhX29zX250b2hsKHQwKTsKKwkJZGlwW2kgKyAxXSA9IGJmYV9vc19udG9obCh0MSk7CisjZWxzZQorCQlkaXBbaV0gPSBiZmFfb3NfbnRvaGwodDEpOworCQlkaXBbaSArIDFdID0gYmZhX29zX250b2hsKHQwKTsKKyNlbmRpZgorCX0KKworICAgIC8qKiB0b2RvCisgICAgICogUW9TIHN0YXRzIHIgYWxzbyBzd2FwcGVkIGFzIDY0Yml0OyB0aGF0IHN0cnVjdHVyZSBhbHNvCisgICAgICogaGFzIHRvIHVzZSA2NCBiaXQgY291bnRlcnMKKyAgICAgKi8KK30KKworLyoqCisgKiBiZmFfcG9ydF9lbmFibGVfaXNyKCkKKyAqCisgKgorICogQHBhcmFtW2luXSBwb3J0IC0gUG9pbnRlciB0byB0aGUgcG9ydCBtb2R1bGUKKyAqICAgICAgICAgICAgc3RhdHVzIC0gUmV0dXJuIHN0YXR1cyBmcm9tIHRoZSBmL3cKKyAqCisgKiBAcmV0dXJuIHZvaWQKKyAqLworc3RhdGljIHZvaWQKK2JmYV9wb3J0X2VuYWJsZV9pc3Ioc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsIGJmYV9zdGF0dXNfdCBzdGF0dXMpCit7CisJYmZhX2Fzc2VydCgwKTsKK30KKworLyoqCisgKiBiZmFfcG9ydF9kaXNhYmxlX2lzcigpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gcG9ydCAtIFBvaW50ZXIgdG8gdGhlIHBvcnQgbW9kdWxlCisgKiAgICAgICAgICAgIHN0YXR1cyAtIFJldHVybiBzdGF0dXMgZnJvbSB0aGUgZi93CisgKgorICogQHJldHVybiB2b2lkCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcG9ydF9kaXNhYmxlX2lzcihzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCwgYmZhX3N0YXR1c190IHN0YXR1cykKK3sKKwliZmFfYXNzZXJ0KDApOworfQorCisvKioKKyAqIGJmYV9wb3J0X2dldF9zdGF0c19pc3IoKQorICoKKyAqCisgKiBAcGFyYW1baW5dIHBvcnQgLSBQb2ludGVyIHRvIHRoZSBQb3J0IG1vZHVsZQorICogICAgICAgICAgICBzdGF0dXMgLSBSZXR1cm4gc3RhdHVzIGZyb20gdGhlIGYvdworICoKKyAqIEByZXR1cm4gdm9pZAorICovCitzdGF0aWMgdm9pZAorYmZhX3BvcnRfZ2V0X3N0YXRzX2lzcihzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCwgYmZhX3N0YXR1c190IHN0YXR1cykKK3sKKwlwb3J0LT5zdGF0c19zdGF0dXMgPSBzdGF0dXM7CisJcG9ydC0+c3RhdHNfYnVzeSA9IEJGQV9GQUxTRTsKKworCWlmIChzdGF0dXMgPT0gQkZBX1NUQVRVU19PSykgeworCQltZW1jcHkocG9ydC0+c3RhdHMsIHBvcnQtPnN0YXRzX2RtYS5rdmEsCisJCSAgICAgICBzaXplb2YodW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UpKTsKKwkJYmZhX3BvcnRfc3RhdHNfc3dhcChwb3J0LCBwb3J0LT5zdGF0cyk7CisJfQorCisJaWYgKHBvcnQtPnN0YXRzX2NiZm4pIHsKKwkJcG9ydC0+c3RhdHNfY2Jmbihwb3J0LT5zdGF0c19jYmFyZywgc3RhdHVzKTsKKwkJcG9ydC0+c3RhdHNfY2JmbiA9IE5VTEw7CisJfQorfQorCisvKioKKyAqIGJmYV9wb3J0X2NsZWFyX3N0YXRzX2lzcigpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gcG9ydCAtIFBvaW50ZXIgdG8gdGhlIFBvcnQgbW9kdWxlCisgKiAgICAgICAgICAgIHN0YXR1cyAtIFJldHVybiBzdGF0dXMgZnJvbSB0aGUgZi93CisgKgorICogQHJldHVybiB2b2lkCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcG9ydF9jbGVhcl9zdGF0c19pc3Ioc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsIGJmYV9zdGF0dXNfdCBzdGF0dXMpCit7CisJcG9ydC0+c3RhdHNfc3RhdHVzID0gc3RhdHVzOworCXBvcnQtPnN0YXRzX2J1c3kgPSBCRkFfRkFMU0U7CisKKwlpZiAocG9ydC0+c3RhdHNfY2JmbikgeworCQlwb3J0LT5zdGF0c19jYmZuKHBvcnQtPnN0YXRzX2NiYXJnLCBzdGF0dXMpOworCQlwb3J0LT5zdGF0c19jYmZuID0gTlVMTDsKKwl9Cit9CisKKy8qKgorICogYmZhX3BvcnRfaXNyKCkKKyAqCisgKgorICogQHBhcmFtW2luXSBQb2ludGVyIHRvIHRoZSBQb3J0IG1vZHVsZSBkYXRhIHN0cnVjdHVyZS4KKyAqCisgKiBAcmV0dXJuIHZvaWQKKyAqLworc3RhdGljIHZvaWQKK2JmYV9wb3J0X2lzcih2b2lkICpjYmFyZywgc3RydWN0IGJmaV9tYm1zZ19zICptKQoreworCXN0cnVjdCBiZmFfcG9ydF9zICpwb3J0ID0gKHN0cnVjdCBiZmFfcG9ydF9zICopY2Jhcmc7CisJdW5pb24gYmZpX3BvcnRfaTJoX21zZ191ICppMmhtc2c7CisKKwlpMmhtc2cgPSAodW5pb24gYmZpX3BvcnRfaTJoX21zZ191ICopbTsKKwliZmFfdHJjKHBvcnQsIG0tPm1oLm1zZ19pZCk7CisKKwlzd2l0Y2ggKG0tPm1oLm1zZ19pZCkgeworCWNhc2UgQkZJX1BPUlRfSTJIX0VOQUJMRV9SU1A6CisJCWlmIChwb3J0LT5lbmRpc19wZW5kaW5nID09IEJGQV9GQUxTRSkKKwkJCWJyZWFrOworCQliZmFfcG9ydF9lbmFibGVfaXNyKHBvcnQsIGkyaG1zZy0+ZW5hYmxlX3JzcC5zdGF0dXMpOworCQlicmVhazsKKworCWNhc2UgQkZJX1BPUlRfSTJIX0RJU0FCTEVfUlNQOgorCQlpZiAocG9ydC0+ZW5kaXNfcGVuZGluZyA9PSBCRkFfRkFMU0UpCisJCQlicmVhazsKKwkJYmZhX3BvcnRfZGlzYWJsZV9pc3IocG9ydCwgaTJobXNnLT5kaXNhYmxlX3JzcC5zdGF0dXMpOworCQlicmVhazsKKworCWNhc2UgQkZJX1BPUlRfSTJIX0dFVF9TVEFUU19SU1A6CisJCS8qCisJCSAqIFN0YXRzIGJ1c3kgZmxhZyBpcyBzdGlsbCBzZXQ/IChtYXkgYmUgY21kIHRpbWVkIG91dCkKKwkJICovCisJCWlmIChwb3J0LT5zdGF0c19idXN5ID09IEJGQV9GQUxTRSkKKwkJCWJyZWFrOworCQliZmFfcG9ydF9nZXRfc3RhdHNfaXNyKHBvcnQsIGkyaG1zZy0+Z2V0c3RhdHNfcnNwLnN0YXR1cyk7CisJCWJyZWFrOworCisJY2FzZSBCRklfUE9SVF9JMkhfQ0xFQVJfU1RBVFNfUlNQOgorCQlpZiAocG9ydC0+c3RhdHNfYnVzeSA9PSBCRkFfRkFMU0UpCisJCQlicmVhazsKKwkJYmZhX3BvcnRfY2xlYXJfc3RhdHNfaXNyKHBvcnQsIGkyaG1zZy0+Y2xlYXJzdGF0c19yc3Auc3RhdHVzKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBiZmFfcG9ydF9tZW1pbmZvKCkKKyAqCisgKgorICogQHBhcmFtW2luXSB2b2lkCisgKgorICogQHJldHVybiBTaXplIG9mIERNQSByZWdpb24KKyAqLwordTMyCitiZmFfcG9ydF9tZW1pbmZvKHZvaWQpCit7CisJcmV0dXJuIEJGQV9ST1VORFVQKHNpemVvZih1bmlvbiBiZmFfcHBvcnRfc3RhdHNfdSksIEJGQV9ETUFfQUxJR05fU1opOworfQorCisvKioKKyAqIGJmYV9wb3J0X21lbV9jbGFpbSgpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gcG9ydCBQb3J0IG1vZHVsZSBwb2ludGVyCisgKiAJICAgICAgZG1hX2t2YSBLZXJuZWwgVmlydHVhbCBBZGRyZXNzIG9mIFBvcnQgRE1BIE1lbW9yeQorICogCSAgICAgIGRtYV9wYSAgUGh5c2ljYWwgQWRkcmVzcyBvZiBQb3J0IERNQSBNZW1vcnkKKyAqCisgKiBAcmV0dXJuIHZvaWQKKyAqLwordm9pZAorYmZhX3BvcnRfbWVtX2NsYWltKHN0cnVjdCBiZmFfcG9ydF9zICpwb3J0LCB1OCAqZG1hX2t2YSwgdTY0IGRtYV9wYSkKK3sKKwlwb3J0LT5zdGF0c19kbWEua3ZhID0gZG1hX2t2YTsKKwlwb3J0LT5zdGF0c19kbWEucGEgPSBkbWFfcGE7Cit9CisKKy8qKgorICogYmZhX3BvcnRfZW5hYmxlKCkKKyAqCisgKiAgIFNlbmQgdGhlIFBvcnQgZW5hYmxlIHJlcXVlc3QgdG8gdGhlIGYvdworICoKKyAqIEBwYXJhbVtpbl0gUG9pbnRlciB0byB0aGUgUG9ydCBtb2R1bGUgZGF0YSBzdHJ1Y3R1cmUuCisgKgorICogQHJldHVybiBTdGF0dXMKKyAqLworYmZhX3N0YXR1c190CitiZmFfcG9ydF9lbmFibGUoc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsIGJmYV9wb3J0X2VuZGlzX2NiZm5fdCBjYmZuLAorCQl2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZpX3BvcnRfZ2VuZXJpY19yZXFfcyAqbTsKKworCS8qKiB0b2RvIE5vdCBpbXBsZW1lbnRlZCAqLworCWJmYV9hc3NlcnQoMCk7CisKKwlpZiAoIWJmYV9pb2NfaXNfb3BlcmF0aW9uYWwocG9ydC0+aW9jKSkgeworCQliZmFfdHJjKHBvcnQsIEJGQV9TVEFUVVNfSU9DX0ZBSUxVUkUpOworCQlyZXR1cm4gQkZBX1NUQVRVU19JT0NfRkFJTFVSRTsKKwl9CisKKwlpZiAocG9ydC0+ZW5kaXNfcGVuZGluZykgeworCQliZmFfdHJjKHBvcnQsIEJGQV9TVEFUVVNfREVWQlVTWSk7CisJCXJldHVybiBCRkFfU1RBVFVTX0RFVkJVU1k7CisJfQorCisJbSA9IChzdHJ1Y3QgYmZpX3BvcnRfZ2VuZXJpY19yZXFfcyAqKXBvcnQtPmVuZGlzX21iLm1zZzsKKworCXBvcnQtPm1zZ3RhZysrOworCXBvcnQtPmVuZGlzX2NiZm4gPSBjYmZuOworCXBvcnQtPmVuZGlzX2NiYXJnID0gY2Jhcmc7CisJcG9ydC0+ZW5kaXNfcGVuZGluZyA9IEJGQV9UUlVFOworCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19QT1JULCBCRklfUE9SVF9IMklfRU5BQkxFX1JFUSwKKwkJICAgIGJmYV9pb2NfcG9ydGlkKHBvcnQtPmlvYykpOworCWJmYV9pb2NfbWJveF9xdWV1ZShwb3J0LT5pb2MsICZwb3J0LT5lbmRpc19tYik7CisKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiBiZmFfcG9ydF9kaXNhYmxlKCkKKyAqCisgKiAgIFNlbmQgdGhlIFBvcnQgZGlzYWJsZSByZXF1ZXN0IHRvIHRoZSBmL3cKKyAqCisgKiBAcGFyYW1baW5dIFBvaW50ZXIgdG8gdGhlIFBvcnQgbW9kdWxlIGRhdGEgc3RydWN0dXJlLgorICoKKyAqIEByZXR1cm4gU3RhdHVzCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX3BvcnRfZGlzYWJsZShzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCwgYmZhX3BvcnRfZW5kaXNfY2Jmbl90IGNiZm4sCisJCSB2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZpX3BvcnRfZ2VuZXJpY19yZXFfcyAqbTsKKworCS8qKiB0b2RvIE5vdCBpbXBsZW1lbnRlZCAqLworCWJmYV9hc3NlcnQoMCk7CisKKwlpZiAoIWJmYV9pb2NfaXNfb3BlcmF0aW9uYWwocG9ydC0+aW9jKSkgeworCQliZmFfdHJjKHBvcnQsIEJGQV9TVEFUVVNfSU9DX0ZBSUxVUkUpOworCQlyZXR1cm4gQkZBX1NUQVRVU19JT0NfRkFJTFVSRTsKKwl9CisKKwlpZiAocG9ydC0+ZW5kaXNfcGVuZGluZykgeworCQliZmFfdHJjKHBvcnQsIEJGQV9TVEFUVVNfREVWQlVTWSk7CisJCXJldHVybiBCRkFfU1RBVFVTX0RFVkJVU1k7CisJfQorCisJbSA9IChzdHJ1Y3QgYmZpX3BvcnRfZ2VuZXJpY19yZXFfcyAqKXBvcnQtPmVuZGlzX21iLm1zZzsKKworCXBvcnQtPm1zZ3RhZysrOworCXBvcnQtPmVuZGlzX2NiZm4gPSBjYmZuOworCXBvcnQtPmVuZGlzX2NiYXJnID0gY2Jhcmc7CisJcG9ydC0+ZW5kaXNfcGVuZGluZyA9IEJGQV9UUlVFOworCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19QT1JULCBCRklfUE9SVF9IMklfRElTQUJMRV9SRVEsCisJCSAgICBiZmFfaW9jX3BvcnRpZChwb3J0LT5pb2MpKTsKKwliZmFfaW9jX21ib3hfcXVldWUocG9ydC0+aW9jLCAmcG9ydC0+ZW5kaXNfbWIpOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogYmZhX3BvcnRfZ2V0X3N0YXRzKCkKKyAqCisgKiAgIFNlbmQgdGhlIHJlcXVlc3QgdG8gdGhlIGYvdyB0byBmZXRjaCBQb3J0IHN0YXRpc3RpY3MuCisgKgorICogQHBhcmFtW2luXSBQb2ludGVyIHRvIHRoZSBQb3J0IG1vZHVsZSBkYXRhIHN0cnVjdHVyZS4KKyAqCisgKiBAcmV0dXJuIFN0YXR1cworICovCitiZmFfc3RhdHVzX3QKK2JmYV9wb3J0X2dldF9zdGF0cyhzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCwgdW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKnN0YXRzLAorCQkgICBiZmFfcG9ydF9zdGF0c19jYmZuX3QgY2Jmbiwgdm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmaV9wb3J0X2dldF9zdGF0c19yZXFfcyAqbTsKKworCWlmICghYmZhX2lvY19pc19vcGVyYXRpb25hbChwb3J0LT5pb2MpKSB7CisJCWJmYV90cmMocG9ydCwgQkZBX1NUQVRVU19JT0NfRkFJTFVSRSk7CisJCXJldHVybiBCRkFfU1RBVFVTX0lPQ19GQUlMVVJFOworCX0KKworCWlmIChwb3J0LT5zdGF0c19idXN5KSB7CisJCWJmYV90cmMocG9ydCwgQkZBX1NUQVRVU19ERVZCVVNZKTsKKwkJcmV0dXJuIEJGQV9TVEFUVVNfREVWQlVTWTsKKwl9CisKKwltID0gKHN0cnVjdCBiZmlfcG9ydF9nZXRfc3RhdHNfcmVxX3MgKilwb3J0LT5zdGF0c19tYi5tc2c7CisKKwlwb3J0LT5zdGF0cyA9IHN0YXRzOworCXBvcnQtPnN0YXRzX2NiZm4gPSBjYmZuOworCXBvcnQtPnN0YXRzX2NiYXJnID0gY2Jhcmc7CisJcG9ydC0+c3RhdHNfYnVzeSA9IEJGQV9UUlVFOworCWJmYV9kbWFfYmVfYWRkcl9zZXQobS0+ZG1hX2FkZHIsIHBvcnQtPnN0YXRzX2RtYS5wYSk7CisKKwliZmlfaDJpX3NldChtLT5taCwgQkZJX01DX1BPUlQsIEJGSV9QT1JUX0gySV9HRVRfU1RBVFNfUkVRLAorCQkgICAgYmZhX2lvY19wb3J0aWQocG9ydC0+aW9jKSk7CisJYmZhX2lvY19tYm94X3F1ZXVlKHBvcnQtPmlvYywgJnBvcnQtPnN0YXRzX21iKTsKKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqIGJmYV9wb3J0X2NsZWFyX3N0YXRzKCkKKyAqCisgKgorICogQHBhcmFtW2luXSBQb2ludGVyIHRvIHRoZSBQb3J0IG1vZHVsZSBkYXRhIHN0cnVjdHVyZS4KKyAqCisgKiBAcmV0dXJuIFN0YXR1cworICovCitiZmFfc3RhdHVzX3QKK2JmYV9wb3J0X2NsZWFyX3N0YXRzKHN0cnVjdCBiZmFfcG9ydF9zICpwb3J0LCBiZmFfcG9ydF9zdGF0c19jYmZuX3QgY2JmbiwKKwkJICAgICB2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZpX3BvcnRfZ2VuZXJpY19yZXFfcyAqbTsKKworCWlmICghYmZhX2lvY19pc19vcGVyYXRpb25hbChwb3J0LT5pb2MpKSB7CisJCWJmYV90cmMocG9ydCwgQkZBX1NUQVRVU19JT0NfRkFJTFVSRSk7CisJCXJldHVybiBCRkFfU1RBVFVTX0lPQ19GQUlMVVJFOworCX0KKworCWlmIChwb3J0LT5zdGF0c19idXN5KSB7CisJCWJmYV90cmMocG9ydCwgQkZBX1NUQVRVU19ERVZCVVNZKTsKKwkJcmV0dXJuIEJGQV9TVEFUVVNfREVWQlVTWTsKKwl9CisKKwltID0gKHN0cnVjdCBiZmlfcG9ydF9nZW5lcmljX3JlcV9zICopcG9ydC0+c3RhdHNfbWIubXNnOworCisJcG9ydC0+c3RhdHNfY2JmbiA9IGNiZm47CisJcG9ydC0+c3RhdHNfY2JhcmcgPSBjYmFyZzsKKwlwb3J0LT5zdGF0c19idXN5ID0gQkZBX1RSVUU7CisKKwliZmlfaDJpX3NldChtLT5taCwgQkZJX01DX1BPUlQsIEJGSV9QT1JUX0gySV9DTEVBUl9TVEFUU19SRVEsCisJCSAgICBiZmFfaW9jX3BvcnRpZChwb3J0LT5pb2MpKTsKKwliZmFfaW9jX21ib3hfcXVldWUocG9ydC0+aW9jLCAmcG9ydC0+c3RhdHNfbWIpOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogYmZhX3BvcnRfaGJmYWlsKCkKKyAqCisgKgorICogQHBhcmFtW2luXSBQb2ludGVyIHRvIHRoZSBQb3J0IG1vZHVsZSBkYXRhIHN0cnVjdHVyZS4KKyAqCisgKiBAcmV0dXJuIHZvaWQKKyAqLwordm9pZAorYmZhX3BvcnRfaGJmYWlsKHZvaWQgKmFyZykKK3sKKwlzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCA9IChzdHJ1Y3QgYmZhX3BvcnRfcyAqKWFyZzsKKworCS8qCisJICogRmFpbCBhbnkgcGVuZGluZyBnZXRfc3RhdHMvY2xlYXJfc3RhdHMgcmVxdWVzdHMKKwkgKi8KKwlpZiAocG9ydC0+c3RhdHNfYnVzeSkgeworCQlpZiAocG9ydC0+c3RhdHNfY2JmbikKKwkJCXBvcnQtPnN0YXRzX2NiZm4ocG9ydC0+ZGV2LCBCRkFfU1RBVFVTX0ZBSUxFRCk7CisJCXBvcnQtPnN0YXRzX2NiZm4gPSBOVUxMOworCQlwb3J0LT5zdGF0c19idXN5ID0gQkZBX0ZBTFNFOworCX0KKworCS8qCisJICogQ2xlYXIgYW55IGVuYWJsZS9kaXNhYmxlIGlzIHBlbmRpbmcKKwkgKi8KKwlpZiAocG9ydC0+ZW5kaXNfcGVuZGluZykgeworCQlpZiAocG9ydC0+ZW5kaXNfY2JmbikKKwkJCXBvcnQtPmVuZGlzX2NiZm4ocG9ydC0+ZGV2LCBCRkFfU1RBVFVTX0ZBSUxFRCk7CisJCXBvcnQtPmVuZGlzX2NiZm4gPSBOVUxMOworCQlwb3J0LT5lbmRpc19wZW5kaW5nID0gQkZBX0ZBTFNFOworCX0KK30KKworLyoqCisgKiBiZmFfcG9ydF9hdHRhY2goKQorICoKKyAqCisgKiBAcGFyYW1baW5dIHBvcnQgLSBQb2ludGVyIHRvIHRoZSBQb3J0IG1vZHVsZSBkYXRhIHN0cnVjdHVyZQorICogICAgICAgICAgICBpb2MgIC0gUG9pbnRlciB0byB0aGUgaW9jIG1vZHVsZSBkYXRhIHN0cnVjdHVyZQorICogICAgICAgICAgICBkZXYgIC0gUG9pbnRlciB0byB0aGUgZGV2aWNlIGRyaXZlciBtb2R1bGUgZGF0YSBzdHJ1Y3R1cmUKKyAqICAgICAgICAgICAgICAgICAgIFRoZSBkZXZpY2UgZHJpdmVyIHNwZWNpZmljIG1ib3ggSVNSIGZ1bmN0aW9ucyBoYXZlCisgKiAgICAgICAgICAgICAgICAgICB0aGlzIHBvaW50ZXIgYXMgb25lIG9mIHRoZSBwYXJhbWV0ZXJzLgorICogICAgICAgICAgICB0cmNtb2QgLQorICogICAgICAgICAgICBsb2dtb2QgLQorICoKKyAqIEByZXR1cm4gdm9pZAorICovCit2b2lkCitiZmFfcG9ydF9hdHRhY2goc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsIHN0cnVjdCBiZmFfaW9jX3MgKmlvYywgdm9pZCAqZGV2LAorCQlzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbW9kLCBzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbW9kKQoreworCWJmYV9hc3NlcnQocG9ydCk7CisKKwlwb3J0LT5kZXYgPSBkZXY7CisJcG9ydC0+aW9jID0gaW9jOworCXBvcnQtPnRyY21vZCA9IHRyY21vZDsKKwlwb3J0LT5sb2dtb2QgPSBsb2dtb2Q7CisKKwlwb3J0LT5zdGF0c19idXN5ID0gcG9ydC0+ZW5kaXNfcGVuZGluZyA9IEJGQV9GQUxTRTsKKwlwb3J0LT5zdGF0c19jYmZuID0gcG9ydC0+ZW5kaXNfY2JmbiA9IE5VTEw7CisKKwliZmFfaW9jX21ib3hfcmVnaXNyKHBvcnQtPmlvYywgQkZJX01DX1BPUlQsIGJmYV9wb3J0X2lzciwgcG9ydCk7CisJYmZhX2lvY19oYmZhaWxfaW5pdCgmcG9ydC0+aGJmYWlsLCBiZmFfcG9ydF9oYmZhaWwsIHBvcnQpOworCWJmYV9pb2NfaGJmYWlsX3JlZ2lzdGVyKHBvcnQtPmlvYywgJnBvcnQtPmhiZmFpbCk7CisKKwliZmFfdHJjKHBvcnQsIDApOworfQorCisvKioKKyAqIGJmYV9wb3J0X2RldGFjaCgpCisgKgorICoKKyAqIEBwYXJhbVtpbl0gcG9ydCAtIFBvaW50ZXIgdG8gdGhlIFBvcnQgbW9kdWxlIGRhdGEgc3RydWN0dXJlCisgKgorICogQHJldHVybiB2b2lkCisgKi8KK3ZvaWQKK2JmYV9wb3J0X2RldGFjaChzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCkKK3sKKwliZmFfdHJjKHBvcnQsIDApOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfcG9ydF9wcml2LmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9wb3J0X3ByaXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40Yjk3ZTI3Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfcG9ydF9wcml2LmgKQEAgLTAsMCArMSw5MCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX1BPUlRfUFJJVl9IX18KKyNkZWZpbmUgX19CRkFfUE9SVF9QUklWX0hfXworCisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorI2luY2x1ZGUgPGJmaS9iZmlfcHBvcnQuaD4KKyNpbmNsdWRlICJiZmFfaW50cl9wcml2LmgiCisKKy8qKgorICogQkZBIHBoeXNpY2FsIHBvcnQgZGF0YSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGJmYV9wcG9ydF9zIHsKKwlzdHJ1Y3QgYmZhX3MgCQkqYmZhOwkvKiAgcGFyZW50IEJGQSBpbnN0YW5jZSAqLworCWJmYV9zbV90CQlzbTsJLyogIHBvcnQgc3RhdGUgbWFjaGluZSAqLworCXd3bl90CQkJbnd3bjsJLyogIG5vZGUgd3duIG9mIHBoeXNpY2FsIHBvcnQgKi8KKwl3d25fdAkJCXB3d247CS8qICBwb3J0IHd3biBvZiBwaHlzaWNhbCBvcHJ0ICovCisJZW51bSBiZmFfcHBvcnRfc3BlZWQgc3BlZWRfc3VwOworCQkJCQkvKiAgc3VwcG9ydGVkIHNwZWVkcyAqLworCWVudW0gYmZhX3Bwb3J0X3NwZWVkIHNwZWVkOwkvKiAgY3VycmVudCBzcGVlZCAqLworCWVudW0gYmZhX3Bwb3J0X3RvcG9sb2d5IHRvcG9sb2d5OwkvKiAgY3VycmVudCB0b3BvbG9neSAqLworCXU4CQkJbXlhbHBhOwkvKiAgbXkgQUxQQSBpbiBMT09QIHRvcG9sb2d5ICovCisJdTgJCQlyc3ZkWzNdOworCXN0cnVjdCBiZmFfcHBvcnRfY2ZnX3MJY2ZnOwkvKiAgY3VycmVudCBwb3J0IGNvbmZpZ3VyYXRpb24gKi8KKwlzdHJ1Y3QgYmZhX3Fvc19hdHRyX3MgIHFvc19hdHRyOyAgIC8qIFFvUyBBdHRyaWJ1dGVzICovCisJc3RydWN0IGJmYV9xb3NfdmNfYXR0cl9zIHFvc192Y19hdHRyOyAgLyogIFZDIGluZm8gZnJvbSBFTFAgKi8KKwlzdHJ1Y3QgYmZhX3JlcXFfd2FpdF9zCXJlcXFfd2FpdDsKKwkJCQkJLyogIHRvIHdhaXQgZm9yIHJvb20gaW4gcmVxcSAqLworCXN0cnVjdCBiZmFfcmVxcV93YWl0X3MJc3ZjcmVxX3dhaXQ7CisJCQkJCS8qICB0byB3YWl0IGZvciByb29tIGluIHJlcXEgKi8KKwlzdHJ1Y3QgYmZhX3JlcXFfd2FpdF9zCXN0YXRzX3JlcXFfd2FpdDsKKwkJCQkJLyogIHRvIHdhaXQgZm9yIHJvb20gaW4gcmVxcSAoc3RhdHMpICovCisJdm9pZAkJCSpldmVudF9jYmFyZzsKKwl2b2lkCQkJKCpldmVudF9jYmZuKSAodm9pZCAqY2JhcmcsCisJCQkJCQliZmFfcHBvcnRfZXZlbnRfdCBldmVudCk7CisJdW5pb24geworCQl1bmlvbiBiZmlfcHBvcnRfaTJoX21zZ191IGkyaG1zZzsKKwl9IGV2ZW50X2FyZzsKKwl2b2lkCQkJKmJmYWQ7CS8qICBCRkEgZHJpdmVyIGhhbmRsZSAqLworCXN0cnVjdCBiZmFfY2JfcWVfcwkJaGNiX3FlOwkvKiAgQkZBIGNhbGxiYWNrIHF1ZXVlIGVsZW0gKi8KKwllbnVtIGJmYV9wcG9ydF9saW5rc3RhdGUJaGNiX2V2ZW50OworCQkJCQkvKiAgbGluayBldmVudCBmb3IgY2FsbGJhY2sgKi8KKwl1MzIJCW1zZ3RhZzsJLyogIGZpbXJ3YXJlIG1zZyB0YWcgZm9yIHJlcGx5ICovCisJdTgJCQkqc3RhdHNfa3ZhOworCXU2NAkJc3RhdHNfcGE7CisJdW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKnN0YXRzOwkvKiAgcHBvcnQgc3RhdHMgKi8KKwl1MzIJCW15cGlkIDogMjQ7CisJdTMyCQlyc3ZkX2IgOiA4OworCXN0cnVjdCBiZmFfdGltZXJfcyAJdGltZXI7CS8qICB0aW1lciAqLworCXVuaW9uIGJmYV9wcG9ydF9zdGF0c191IAkqc3RhdHNfcmV0OworCQkJCQkvKiAgZHJpdmVyIHN0YXRzIGxvY2F0aW9uICovCisJYmZhX3N0YXR1c190CQlzdGF0c19zdGF0dXM7CisJCQkJCS8qICBzdGF0cy9zdGF0c2NsciBzdGF0dXMgKi8KKwliZmFfYm9vbGVhbl90ICAgCXN0YXRzX2J1c3k7CisJCQkJCS8qICBvdXRzdGFuZGluZyBzdGF0cy9zdGF0c2NsciAqLworCWJmYV9ib29sZWFuX3QgICAJc3RhdHNfcWZ1bGw7CisJYmZhX2Jvb2xlYW5fdCAgIAlkaWFnX2J1c3k7CisJCQkJCS8qICBkaWFnIGJ1c3kgc3RhdHVzICovCisJYmZhX2Jvb2xlYW5fdCAgIAliZWFjb247CisJCQkJCS8qICBwb3J0IGJlYWNvbiBzdGF0dXMgKi8KKwliZmFfYm9vbGVhbl90ICAgCWxpbmtfZTJlX2JlYWNvbjsKKwkJCQkJLyogIGxpbmsgYmVhY29uIHN0YXR1cyAqLworCWJmYV9jYl9wcG9ydF90CQlzdGF0c19jYmZuOworCQkJCQkvKiAgZHJpdmVyIGNhbGxiYWNrIGZ1bmN0aW9uICovCisJdm9pZAkJCSpzdGF0c19jYmFyZzsKKwkJCQkJLyogKiE8IHVzZXIgY2FsbGJhY2sgYXJnICovCit9OworCisjZGVmaW5lIEJGQV9QT1JUX01PRChfX2JmYSkJKCYoX19iZmEpLT5tb2R1bGVzLnBwb3J0KQorCisvKgorICogcHVibGljIGZ1bmN0aW9ucworICovCit2b2lkCWJmYV9wcG9ydF9pc3Ioc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm1zZyk7CisjZW5kaWYgLyogX19CRkFfUE9SVF9QUklWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfcHJpdi5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfcHJpdi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA3NDdhNmIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9wcml2LmgKQEAgLTAsMCArMSwxMTMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9QUklWX0hfXworI2RlZmluZSBfX0JGQV9QUklWX0hfXworCisjaW5jbHVkZSAiYmZhX2lvY2ZjLmgiCisjaW5jbHVkZSAiYmZhX2ludHJfcHJpdi5oIgorI2luY2x1ZGUgImJmYV90cmNtb2RfcHJpdi5oIgorI2luY2x1ZGUgImJmYV9tb2R1bGVzX3ByaXYuaCIKKyNpbmNsdWRlICJiZmFfZndpbWdfcHJpdi5oIgorI2luY2x1ZGUgPGNzL2JmYV9sb2cuaD4KKyNpbmNsdWRlIDxiZmFfdGltZXIuaD4KKworLyoqCisgKiBNYWNybyB0byBkZWZpbmUgYSBuZXcgQkZBIG1vZHVsZQorICovCisjZGVmaW5lIEJGQV9NT0RVTEUoX19tb2QpIAkJCQkJCVwKKwlzdGF0aWMgdm9pZCBiZmFfICMjIF9fbW9kICMjIF9tZW1pbmZvKAkJCQlcCisJCQlzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsIHUzMiAqbmRtX2xlbiwJXAorCQkJdTMyICpkbV9sZW4pOyAgICAgIFwKKwlzdGF0aWMgdm9pZCBiZmFfICMjIF9fbW9kICMjIF9hdHRhY2goc3RydWN0IGJmYV9zICpiZmEsCQlcCisJCQl2b2lkICpiZmFkLCBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsIAlcCisJCQlzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbywJCQlcCisJCQlzdHJ1Y3QgYmZhX3BjaWRldl9zICpwY2lkZXYpOyAgICAgIFwKKwlzdGF0aWMgdm9pZCBiZmFfICMjIF9fbW9kICMjIF9pbml0ZG9uZShzdHJ1Y3QgYmZhX3MgKmJmYSk7ICAgICAgXAorCXN0YXRpYyB2b2lkIGJmYV8gIyMgX19tb2QgIyMgX2RldGFjaChzdHJ1Y3QgYmZhX3MgKmJmYSk7ICAgICAgXAorCXN0YXRpYyB2b2lkIGJmYV8gIyMgX19tb2QgIyMgX3N0YXJ0KHN0cnVjdCBiZmFfcyAqYmZhKTsgICAgICBcCisJc3RhdGljIHZvaWQgYmZhXyAjIyBfX21vZCAjIyBfc3RvcChzdHJ1Y3QgYmZhX3MgKmJmYSk7ICAgICAgXAorCXN0YXRpYyB2b2lkIGJmYV8gIyMgX19tb2QgIyMgX2lvY2Rpc2FibGUoc3RydWN0IGJmYV9zICpiZmEpOyAgICAgIFwKKwkJCQkJCQkJCVwKKwlleHRlcm4gc3RydWN0IGJmYV9tb2R1bGVfcyBoYWxfbW9kXyAjIyBfX21vZDsJCQlcCisJc3RydWN0IGJmYV9tb2R1bGVfcyBoYWxfbW9kXyAjIyBfX21vZCA9IHsJCQlcCisJCWJmYV8gIyMgX19tb2QgIyMgX21lbWluZm8sCQkJCVwKKwkJYmZhXyAjIyBfX21vZCAjIyBfYXR0YWNoLAkJCQlcCisJCWJmYV8gIyMgX19tb2QgIyMgX2luaXRkb25lLAkJCQlcCisJCWJmYV8gIyMgX19tb2QgIyMgX2RldGFjaCwJCQkJXAorCQliZmFfICMjIF9fbW9kICMjIF9zdGFydCwJCQkJXAorCQliZmFfICMjIF9fbW9kICMjIF9zdG9wLAkJCQkJXAorCQliZmFfICMjIF9fbW9kICMjIF9pb2NkaXNhYmxlLAkJCQlcCisJfQorCisjZGVmaW5lIEJGQV9DQUNIRUxJTkVfU1oJKDI1NikKKworLyoqCisgKiBTdHJ1Y3R1cmUgdXNlZCB0byBpbnRlcmFjdCBiZXR3ZWVuIGRpZmZlcmVudCBCRkEgc3ViIG1vZHVsZXMKKyAqCisgKiBFYWNoIHN1YiBtb2R1bGUgbmVlZHMgdG8gaW1wbGVtZW50IG9ubHkgdGhlIGVudHJ5IHBvaW50cyByZWxldmFudCB0byBpdCAoYW5kCisgKiBjYW4gbGVhdmUgZW50cnkgcG9pbnRzIGFzIE5VTEwpCisgKi8KK3N0cnVjdCBiZmFfbW9kdWxlX3MgeworCXZvaWQgKCptZW1pbmZvKSAoc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKmttX2xlbiwKKwkJCXUzMiAqZG1fbGVuKTsKKwl2b2lkICgqYXR0YWNoKSAoc3RydWN0IGJmYV9zICpiZmEsIHZvaWQgKmJmYWQsCisJCQlzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCQlzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbywKKwkJCXN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldik7CisJdm9pZCAoKmluaXRkb25lKSAoc3RydWN0IGJmYV9zICpiZmEpOworCXZvaWQgKCpkZXRhY2gpIChzdHJ1Y3QgYmZhX3MgKmJmYSk7CisJdm9pZCAoKnN0YXJ0KSAoc3RydWN0IGJmYV9zICpiZmEpOworCXZvaWQgKCpzdG9wKSAoc3RydWN0IGJmYV9zICpiZmEpOworCXZvaWQgKCppb2NkaXNhYmxlKSAoc3RydWN0IGJmYV9zICpiZmEpOworfTsKKworZXh0ZXJuIHN0cnVjdCBiZmFfbW9kdWxlX3MgKmhhbF9tb2RzW107CisKK3N0cnVjdCBiZmFfcyB7CisJdm9pZAkJCSpiZmFkOwkJLyogIEJGQSBkcml2ZXIgaW5zdGFuY2UgICAgKi8KKwlzdHJ1Y3QgYmZhX2Flbl9zCSphZW47CQkvKiAgQUVOIG1vZHVsZQkJICAgICovCisJc3RydWN0IGJmYV9wbG9nX3MJKnBsb2c7CQkvKiAgcG9ydGxvZyBidWZmZXIJICAgICovCisJc3RydWN0IGJmYV9sb2dfbW9kX3MJKmxvZ207CQkvKiAgZHJpdmVyIGxvZ2dpbmcgbW9kdWxlbiAqLworCXN0cnVjdCBiZmFfdHJjX21vZF9zCSp0cmNtb2Q7CS8qICBkcml2ZXIgdHJhY2luZwkgICAgKi8KKwlzdHJ1Y3QgYmZhX2lvY19zCWlvYzsJCS8qICBJT0MgbW9kdWxlCQkgICAgKi8KKwlzdHJ1Y3QgYmZhX2lvY2ZjX3MJaW9jZmM7CQkvKiAgSU9DRkMgbW9kdWxlCSAgICAqLworCXN0cnVjdCBiZmFfdGltZXJfbW9kX3MJdGltZXJfbW9kOwkvKiAgdGltZXIgbW9kdWxlCSAgICAqLworCXN0cnVjdCBiZmFfbW9kdWxlc19zCW1vZHVsZXM7CS8qICBCRkEgbW9kdWxlcwkgICAgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkCWNvbXBfcTsJCS8qICBwZW5kaW5nIGNvbXBsZXRpb25zICAgICovCisJYmZhX2Jvb2xlYW5fdAkJcm1lX3Byb2Nlc3M7CS8qICBSTUUgcHJvY2Vzc2luZyBlbmFibGVkICovCisJc3RydWN0IGxpc3RfaGVhZAkJcmVxcV93YWl0cVtCRklfSU9DX01BWF9DUVNdOworCWJmYV9ib29sZWFuX3QJCWZjczsJCS8qICBGQ1MgaXMgYXR0YWNoZWQgdG8gQkZBICovCisJc3RydWN0IGJmYV9tc2l4X3MJbXNpeDsKK307CisKK2V4dGVybiBiZmFfaXNyX2Z1bmNfdCBiZmFfaXNyc1tCRklfTUNfTUFYXTsKK2V4dGVybiBiZmFfaW9jX21ib3hfbWNmdW5jX3QgIGJmYV9tYm94X2lzcnNbXTsKK2V4dGVybiBiZmFfYm9vbGVhbl90IGJmYV9hdXRvX3JlY292ZXI7CitleHRlcm4gc3RydWN0IGJmYV9tb2R1bGVfcyBoYWxfbW9kX2ZsYXNoOworZXh0ZXJuIHN0cnVjdCBiZmFfbW9kdWxlX3MgaGFsX21vZF9mY2RpYWc7CitleHRlcm4gc3RydWN0IGJmYV9tb2R1bGVfcyBoYWxfbW9kX3NncGc7CitleHRlcm4gc3RydWN0IGJmYV9tb2R1bGVfcyBoYWxfbW9kX3Bwb3J0OworZXh0ZXJuIHN0cnVjdCBiZmFfbW9kdWxlX3MgaGFsX21vZF9mY3hwOworZXh0ZXJuIHN0cnVjdCBiZmFfbW9kdWxlX3MgaGFsX21vZF9scHM7CitleHRlcm4gc3RydWN0IGJmYV9tb2R1bGVfcyBoYWxfbW9kX3VmOworZXh0ZXJuIHN0cnVjdCBiZmFfbW9kdWxlX3MgaGFsX21vZF9ycG9ydDsKK2V4dGVybiBzdHJ1Y3QgYmZhX21vZHVsZV9zIGhhbF9tb2RfZmNwaW07CitleHRlcm4gc3RydWN0IGJmYV9tb2R1bGVfcyBoYWxfbW9kX3BiaW5kOworCisjZW5kaWYgLyogX19CRkFfUFJJVl9IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfcnBvcnQuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3Jwb3J0LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTZkYTc3YQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3Jwb3J0LmMKQEAgLTAsMCArMSw5MTEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfZGVidWcuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX3Jwb3J0Lmg+CisjaW5jbHVkZSAiYmZhX2ludHJfcHJpdi5oIgorCitCRkFfVFJDX0ZJTEUoSEFMLCBSUE9SVCk7CitCRkFfTU9EVUxFKHJwb3J0KTsKKworI2RlZmluZSBiZmFfcnBvcnRfb2ZmbGluZV9jYihfX3JwKSBkbyB7CQkJCVwKKwlpZiAoKF9fcnApLT5iZmEtPmZjcykJCQkJCQlcCisJCWJmYV9jYl9ycG9ydF9vZmZsaW5lKChfX3JwKS0+cnBvcnRfZHJ2KTsgICAgICBcCisJZWxzZSB7CQkJCQkJCQlcCisJCWJmYV9jYl9xdWV1ZSgoX19ycCktPmJmYSwgJihfX3JwKS0+aGNiX3FlLAkJXAorCQkJCV9fYmZhX2NiX3Jwb3J0X29mZmxpbmUsIChfX3JwKSk7ICAgICAgXAorCX0JCQkJCQkJCVwKK30gd2hpbGUgKDApCisKKyNkZWZpbmUgYmZhX3Jwb3J0X29ubGluZV9jYihfX3JwKSBkbyB7CQkJCVwKKwlpZiAoKF9fcnApLT5iZmEtPmZjcykJCQkJCQlcCisJCWJmYV9jYl9ycG9ydF9vbmxpbmUoKF9fcnApLT5ycG9ydF9kcnYpOyAgICAgIFwKKwllbHNlIHsJCQkJCQkJCVwKKwkJYmZhX2NiX3F1ZXVlKChfX3JwKS0+YmZhLCAmKF9fcnApLT5oY2JfcWUsCQlcCisJCQkJICBfX2JmYV9jYl9ycG9ydF9vbmxpbmUsIChfX3JwKSk7ICAgICAgXAorCQl9CQkJCQkJCVwKK30gd2hpbGUgKDApCisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgc3RydWN0IGJmYV9ycG9ydF9zICpiZmFfcnBvcnRfYWxsb2Moc3RydWN0IGJmYV9ycG9ydF9tb2RfcyAqcnBfbW9kKTsKK3N0YXRpYyB2b2lkIGJmYV9ycG9ydF9mcmVlKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnBvcnQpOworc3RhdGljIGJmYV9ib29sZWFuX3QgYmZhX3Jwb3J0X3NlbmRfZndjcmVhdGUoc3RydWN0IGJmYV9ycG9ydF9zICpycCk7CitzdGF0aWMgYmZhX2Jvb2xlYW5fdCBiZmFfcnBvcnRfc2VuZF9md2RlbGV0ZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwKTsKK3N0YXRpYyBiZmFfYm9vbGVhbl90IGJmYV9ycG9ydF9zZW5kX2Z3c3BlZWQoc3RydWN0IGJmYV9ycG9ydF9zICpycCk7CitzdGF0aWMgdm9pZCBfX2JmYV9jYl9ycG9ydF9vbmxpbmUodm9pZCAqY2JhcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpOworc3RhdGljIHZvaWQgX19iZmFfY2JfcnBvcnRfb2ZmbGluZSh2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CisKKy8qKgorICogIGJmYV9ycG9ydF9zbSBCRkEgcnBvcnQgc3RhdGUgbWFjaGluZQorICovCisKKworZW51bSBiZmFfcnBvcnRfZXZlbnQgeworCUJGQV9SUE9SVF9TTV9DUkVBVEUJPSAxLAkvKiAgcnBvcnQgY3JlYXRlIGV2ZW50CQkqLworCUJGQV9SUE9SVF9TTV9ERUxFVEUJPSAyLAkvKiAgZGVsZXRpbmcgYW4gZXhpc3RpbmcgcnBvcnQgKi8KKwlCRkFfUlBPUlRfU01fT05MSU5FCT0gMywJLyogIHJwb3J0IGlzIG9ubGluZQkJKi8KKwlCRkFfUlBPUlRfU01fT0ZGTElORQk9IDQsCS8qICBycG9ydCBpcyBvZmZsaW5lCQkqLworCUJGQV9SUE9SVF9TTV9GV1JTUAk9IDUsCS8qICBmaXJtd2FyZSByZXNwb25zZQkJKi8KKwlCRkFfUlBPUlRfU01fSFdGQUlMCT0gNiwJLyogIElPQyBoL3cgZmFpbHVyZQkJKi8KKwlCRkFfUlBPUlRfU01fUU9TX1NDTgk9IDcsCS8qICBRb1MgU0NOIGZyb20gZmlybXdhcmUJKi8KKwlCRkFfUlBPUlRfU01fU0VUX1NQRUVECT0gOCwJLyogIFNldCBScG9ydCBTcGVlZCAJCSovCisJQkZBX1JQT1JUX1NNX1FSRVNVTUUJPSA5LAkvKiAgc3BhY2UgaW4gcmVxdWV1ZSBxdWV1ZQkqLworfTsKKworc3RhdGljIHZvaWQJYmZhX3Jwb3J0X3NtX3VuaW5pdChzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLAorCQkJCQllbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZAliZmFfcnBvcnRfc21fY3JlYXRlZChzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLAorCQkJCQkgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQJYmZhX3Jwb3J0X3NtX2Z3Y3JlYXRlKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnAsCisJCQkJCSAgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQJYmZhX3Jwb3J0X3NtX29ubGluZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLAorCQkJCQllbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZAliZmFfcnBvcnRfc21fZndkZWxldGUoc3RydWN0IGJmYV9ycG9ydF9zICpycCwKKwkJCQkJICBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZAliZmFfcnBvcnRfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLAorCQkJCQkgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQJYmZhX3Jwb3J0X3NtX2RlbGV0aW5nKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnAsCisJCQkJCSAgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQJYmZhX3Jwb3J0X3NtX29mZmxpbmVfcGVuZGluZyhzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLAorCQkJCQkgIGVudW0gYmZhX3Jwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkCWJmYV9ycG9ydF9zbV9kZWxldGVfcGVuZGluZyhzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLAorCQkJCQkgIGVudW0gYmZhX3Jwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkCWJmYV9ycG9ydF9zbV9pb2NkaXNhYmxlKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnAsCisJCQkJCSAgICBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZAliZmFfcnBvcnRfc21fZndjcmVhdGVfcWZ1bGwoc3RydWN0IGJmYV9ycG9ydF9zICpycCwKKwkJCQkJICBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZAliZmFfcnBvcnRfc21fZndkZWxldGVfcWZ1bGwoc3RydWN0IGJmYV9ycG9ydF9zICpycCwKKwkJCQkJICBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZAliZmFfcnBvcnRfc21fZGVsZXRpbmdfcWZ1bGwoc3RydWN0IGJmYV9ycG9ydF9zICpycCwKKwkJCQkJICBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCk7CisKKy8qKgorICogQmVnaW5uaW5nIHN0YXRlLCBvbmx5IG9ubGluZSBldmVudCBleHBlY3RlZC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9ycG9ydF9zbV91bmluaXQoc3RydWN0IGJmYV9ycG9ydF9zICpycCwgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycC0+YmZhLCBycC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKHJwLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9SUE9SVF9TTV9DUkVBVEU6CisJCWJmYV9zdGF0cyhycCwgc21fdW5fY3IpOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fY3JlYXRlZCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3N0YXRzKHJwLCBzbV91bl91bmV4cCk7CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Jwb3J0X3NtX2NyZWF0ZWQoc3RydWN0IGJmYV9ycG9ydF9zICpycCwgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycC0+YmZhLCBycC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKHJwLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9SUE9SVF9TTV9PTkxJTkU6CisJCWJmYV9zdGF0cyhycCwgc21fY3Jfb24pOworCQlpZiAoYmZhX3Jwb3J0X3NlbmRfZndjcmVhdGUocnApKQorCQkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2Z3Y3JlYXRlKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2Z3Y3JlYXRlX3FmdWxsKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9ERUxFVEU6CisJCWJmYV9zdGF0cyhycCwgc21fY3JfZGVsKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9ycG9ydF9mcmVlKHJwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9IV0ZBSUw6CisJCWJmYV9zdGF0cyhycCwgc21fY3JfaHdmKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2lvY2Rpc2FibGUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zdGF0cyhycCwgc21fY3JfdW5leHApOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBXYWl0aW5nIGZvciBycG9ydCBjcmVhdGUgcmVzcG9uc2UgZnJvbSBmaXJtd2FyZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9ycG9ydF9zbV9md2NyZWF0ZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLCBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwLT5iZmEsIHJwLT5ycG9ydF90YWcpOworCWJmYV90cmMocnAtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1JQT1JUX1NNX0ZXUlNQOgorCQliZmFfc3RhdHMocnAsIHNtX2Z3Y19yc3ApOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fb25saW5lKTsKKwkJYmZhX3Jwb3J0X29ubGluZV9jYihycCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUlBPUlRfU01fREVMRVRFOgorCQliZmFfc3RhdHMocnAsIHNtX2Z3Y19kZWwpOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fZGVsZXRlX3BlbmRpbmcpOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX09GRkxJTkU6CisJCWJmYV9zdGF0cyhycCwgc21fZndjX29mZik7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9vZmZsaW5lX3BlbmRpbmcpOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9md2NfaHdmKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2lvY2Rpc2FibGUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zdGF0cyhycCwgc21fZndjX3VuZXhwKTsKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogUmVxdWVzdCBxdWV1ZSBpcyBmdWxsLCBhd2FpdGluZyBxdWV1ZSByZXN1bWUgdG8gc2VuZCBjcmVhdGUgcmVxdWVzdC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9ycG9ydF9zbV9md2NyZWF0ZV9xZnVsbChzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLCBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwLT5iZmEsIHJwLT5ycG9ydF90YWcpOworCWJmYV90cmMocnAtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1JQT1JUX1NNX1FSRVNVTUU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9md2NyZWF0ZSk7CisJCWJmYV9ycG9ydF9zZW5kX2Z3Y3JlYXRlKHJwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9ERUxFVEU6CisJCWJmYV9zdGF0cyhycCwgc21fZndjX2RlbCk7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV91bmluaXQpOworCQliZmFfcmVxcV93Y2FuY2VsKCZycC0+cmVxcV93YWl0KTsKKwkJYmZhX3Jwb3J0X2ZyZWUocnApOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX09GRkxJTkU6CisJCWJmYV9zdGF0cyhycCwgc21fZndjX29mZik7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9vZmZsaW5lKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmcnAtPnJlcXFfd2FpdCk7CisJCWJmYV9ycG9ydF9vZmZsaW5lX2NiKHJwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9IV0ZBSUw6CisJCWJmYV9zdGF0cyhycCwgc21fZndjX2h3Zik7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9pb2NkaXNhYmxlKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmcnAtPnJlcXFfd2FpdCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9md2NfdW5leHApOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBPbmxpbmUgc3RhdGUgLSBub3JtYWwgcGFya2luZyBzdGF0ZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9ycG9ydF9zbV9vbmxpbmUoc3RydWN0IGJmYV9ycG9ydF9zICpycCwgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJc3RydWN0IGJmaV9ycG9ydF9xb3Nfc2NuX3MgKnFvc19zY247CisKKwliZmFfdHJjKHJwLT5iZmEsIHJwLT5ycG9ydF90YWcpOworCWJmYV90cmMocnAtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1JQT1JUX1NNX09GRkxJTkU6CisJCWJmYV9zdGF0cyhycCwgc21fb25fb2ZmKTsKKwkJaWYgKGJmYV9ycG9ydF9zZW5kX2Z3ZGVsZXRlKHJwKSkKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9md2RlbGV0ZSk7CisJCWVsc2UKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9md2RlbGV0ZV9xZnVsbCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUlBPUlRfU01fREVMRVRFOgorCQliZmFfc3RhdHMocnAsIHNtX29uX2RlbCk7CisJCWlmIChiZmFfcnBvcnRfc2VuZF9md2RlbGV0ZShycCkpCisJCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fZGVsZXRpbmcpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fZGVsZXRpbmdfcWZ1bGwpOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9vbl9od2YpOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21faW9jZGlzYWJsZSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUlBPUlRfU01fU0VUX1NQRUVEOgorCQliZmFfcnBvcnRfc2VuZF9md3NwZWVkKHJwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9RT1NfU0NOOgorCQlxb3Nfc2NuID0gKHN0cnVjdCBiZmlfcnBvcnRfcW9zX3Njbl9zICopIHJwLT5ldmVudF9hcmcuZndfbXNnOworCQlycC0+cW9zX2F0dHIgPSBxb3Nfc2NuLT5uZXdfcW9zX2F0dHI7CisJCWJmYV90cmMocnAtPmJmYSwgcW9zX3Njbi0+b2xkX3Fvc19hdHRyLnFvc19mbG93X2lkKTsKKwkJYmZhX3RyYyhycC0+YmZhLCBxb3Nfc2NuLT5uZXdfcW9zX2F0dHIucW9zX2Zsb3dfaWQpOworCQliZmFfdHJjKHJwLT5iZmEsIHFvc19zY24tPm9sZF9xb3NfYXR0ci5xb3NfcHJpb3JpdHkpOworCQliZmFfdHJjKHJwLT5iZmEsIHFvc19zY24tPm5ld19xb3NfYXR0ci5xb3NfcHJpb3JpdHkpOworCisJCXFvc19zY24tPm9sZF9xb3NfYXR0ci5xb3NfZmxvd19pZCAgPQorCQkJYmZhX29zX250b2hsKHFvc19zY24tPm9sZF9xb3NfYXR0ci5xb3NfZmxvd19pZCk7CisJCXFvc19zY24tPm5ld19xb3NfYXR0ci5xb3NfZmxvd19pZCAgPQorCQkJYmZhX29zX250b2hsKHFvc19zY24tPm5ld19xb3NfYXR0ci5xb3NfZmxvd19pZCk7CisJCXFvc19zY24tPm9sZF9xb3NfYXR0ci5xb3NfcHJpb3JpdHkgPQorCQkJYmZhX29zX250b2hsKHFvc19zY24tPm9sZF9xb3NfYXR0ci5xb3NfcHJpb3JpdHkpOworCQlxb3Nfc2NuLT5uZXdfcW9zX2F0dHIucW9zX3ByaW9yaXR5ID0KKwkJCWJmYV9vc19udG9obChxb3Nfc2NuLT5uZXdfcW9zX2F0dHIucW9zX3ByaW9yaXR5KTsKKworCQlpZiAocW9zX3Njbi0+b2xkX3Fvc19hdHRyLnFvc19mbG93X2lkICE9CisJCQlxb3Nfc2NuLT5uZXdfcW9zX2F0dHIucW9zX2Zsb3dfaWQpCisJCQliZmFfY2JfcnBvcnRfcW9zX3Njbl9mbG93aWQocnAtPnJwb3J0X2RydiwKKwkJCQkJCSAgICBxb3Nfc2NuLT5vbGRfcW9zX2F0dHIsCisJCQkJCQkgICAgcW9zX3Njbi0+bmV3X3Fvc19hdHRyKTsKKwkJaWYgKHFvc19zY24tPm9sZF9xb3NfYXR0ci5xb3NfcHJpb3JpdHkgIT0KKwkJCXFvc19zY24tPm5ld19xb3NfYXR0ci5xb3NfcHJpb3JpdHkpCisJCQliZmFfY2JfcnBvcnRfcW9zX3Njbl9wcmlvKHJwLT5ycG9ydF9kcnYsCisJCQkJCQkgIHFvc19zY24tPm9sZF9xb3NfYXR0ciwKKwkJCQkJCSAgcW9zX3Njbi0+bmV3X3Fvc19hdHRyKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc3RhdHMocnAsIHNtX29uX3VuZXhwKTsKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogRmlybXdhcmUgcnBvcnQgaXMgYmVpbmcgZGVsZXRlZCAtIGF3YWl0aW5nIGYvdyByZXNwb25zZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9ycG9ydF9zbV9md2RlbGV0ZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLCBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwLT5iZmEsIHJwLT5ycG9ydF90YWcpOworCWJmYV90cmMocnAtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1JQT1JUX1NNX0ZXUlNQOgorCQliZmFfc3RhdHMocnAsIHNtX2Z3ZF9yc3ApOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fb2ZmbGluZSk7CisJCWJmYV9ycG9ydF9vZmZsaW5lX2NiKHJwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9ERUxFVEU6CisJCWJmYV9zdGF0cyhycCwgc21fZndkX2RlbCk7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9kZWxldGluZyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUlBPUlRfU01fSFdGQUlMOgorCQliZmFfc3RhdHMocnAsIHNtX2Z3ZF9od2YpOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21faW9jZGlzYWJsZSk7CisJCWJmYV9ycG9ydF9vZmZsaW5lX2NiKHJwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc3RhdHMocnAsIHNtX2Z3ZF91bmV4cCk7CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Jwb3J0X3NtX2Z3ZGVsZXRlX3FmdWxsKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnAsIGVudW0gYmZhX3Jwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocnAtPmJmYSwgcnAtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhycC0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUlBPUlRfU01fUVJFU1VNRToKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2Z3ZGVsZXRlKTsKKwkJYmZhX3Jwb3J0X3NlbmRfZndkZWxldGUocnApOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX0RFTEVURToKKwkJYmZhX3N0YXRzKHJwLCBzbV9md2RfZGVsKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2RlbGV0aW5nX3FmdWxsKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9IV0ZBSUw6CisJCWJmYV9zdGF0cyhycCwgc21fZndkX2h3Zik7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9pb2NkaXNhYmxlKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmcnAtPnJlcXFfd2FpdCk7CisJCWJmYV9ycG9ydF9vZmZsaW5lX2NiKHJwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc3RhdHMocnAsIHNtX2Z3ZF91bmV4cCk7CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIE9mZmxpbmUgc3RhdGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLCBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwLT5iZmEsIHJwLT5ycG9ydF90YWcpOworCWJmYV90cmMocnAtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1JQT1JUX1NNX0RFTEVURToKKwkJYmZhX3N0YXRzKHJwLCBzbV9vZmZfZGVsKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9ycG9ydF9mcmVlKHJwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9PTkxJTkU6CisJCWJmYV9zdGF0cyhycCwgc21fb2ZmX29uKTsKKwkJaWYgKGJmYV9ycG9ydF9zZW5kX2Z3Y3JlYXRlKHJwKSkKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9md2NyZWF0ZSk7CisJCWVsc2UKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9md2NyZWF0ZV9xZnVsbCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUlBPUlRfU01fSFdGQUlMOgorCQliZmFfc3RhdHMocnAsIHNtX29mZl9od2YpOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21faW9jZGlzYWJsZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9vZmZfdW5leHApOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBScG9ydCBpcyBkZWxldGVkLCB3YWl0aW5nIGZvciBmaXJtd2FyZSByZXNwb25zZSB0byBkZWxldGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfc21fZGVsZXRpbmcoc3RydWN0IGJmYV9ycG9ydF9zICpycCwgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycC0+YmZhLCBycC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKHJwLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9SUE9SVF9TTV9GV1JTUDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9kZWxfZndyc3ApOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fdW5pbml0KTsKKwkJYmZhX3Jwb3J0X2ZyZWUocnApOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9kZWxfaHdmKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9ycG9ydF9mcmVlKHJwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9ycG9ydF9zbV9kZWxldGluZ19xZnVsbChzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwLCBlbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwLT5iZmEsIHJwLT5ycG9ydF90YWcpOworCWJmYV90cmMocnAtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1JQT1JUX1NNX1FSRVNVTUU6CisJCWJmYV9zdGF0cyhycCwgc21fZGVsX2Z3cnNwKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2RlbGV0aW5nKTsKKwkJYmZhX3Jwb3J0X3NlbmRfZndkZWxldGUocnApOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX0hXRkFJTDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9kZWxfaHdmKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9yZXFxX3djYW5jZWwoJnJwLT5yZXFxX3dhaXQpOworCQliZmFfcnBvcnRfZnJlZShycCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogV2FpdGluZyBmb3IgcnBvcnQgY3JlYXRlIHJlc3BvbnNlIGZyb20gZmlybXdhcmUuIEEgZGVsZXRlIGlzIHBlbmRpbmcuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfc21fZGVsZXRlX3BlbmRpbmcoc3RydWN0IGJmYV9ycG9ydF9zICpycCwKKwkJCQllbnVtIGJmYV9ycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwLT5iZmEsIHJwLT5ycG9ydF90YWcpOworCWJmYV90cmMocnAtPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1JQT1JUX1NNX0ZXUlNQOgorCQliZmFfc3RhdHMocnAsIHNtX2RlbHBfZndyc3ApOworCQlpZiAoYmZhX3Jwb3J0X3NlbmRfZndkZWxldGUocnApKQorCQkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2RlbGV0aW5nKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2RlbGV0aW5nX3FmdWxsKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9IV0ZBSUw6CisJCWJmYV9zdGF0cyhycCwgc21fZGVscF9od2YpOworCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fdW5pbml0KTsKKwkJYmZhX3Jwb3J0X2ZyZWUocnApOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zdGF0cyhycCwgc21fZGVscF91bmV4cCk7CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIFdhaXRpbmcgZm9yIHJwb3J0IGNyZWF0ZSByZXNwb25zZSBmcm9tIGZpcm13YXJlLiBScG9ydCBvZmZsaW5lIGlzIHBlbmRpbmcuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfc21fb2ZmbGluZV9wZW5kaW5nKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnAsCisJCQkJIGVudW0gYmZhX3Jwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocnAtPmJmYSwgcnAtPnJwb3J0X3RhZyk7CisJYmZhX3RyYyhycC0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUlBPUlRfU01fRldSU1A6CisJCWJmYV9zdGF0cyhycCwgc21fb2ZmcF9md3JzcCk7CisJCWlmIChiZmFfcnBvcnRfc2VuZF9md2RlbGV0ZShycCkpCisJCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fZndkZWxldGUpOworCQllbHNlCisJCQliZmFfc21fc2V0X3N0YXRlKHJwLCBiZmFfcnBvcnRfc21fZndkZWxldGVfcWZ1bGwpOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX0RFTEVURToKKwkJYmZhX3N0YXRzKHJwLCBzbV9vZmZwX2RlbCk7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV9kZWxldGVfcGVuZGluZyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUlBPUlRfU01fSFdGQUlMOgorCQliZmFfc3RhdHMocnAsIHNtX29mZnBfaHdmKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2lvY2Rpc2FibGUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zdGF0cyhycCwgc21fb2ZmcF91bmV4cCk7CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIElPQyBoL3cgZmFpbGVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX3Jwb3J0X3NtX2lvY2Rpc2FibGUoc3RydWN0IGJmYV9ycG9ydF9zICpycCwgZW51bSBiZmFfcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycC0+YmZhLCBycC0+cnBvcnRfdGFnKTsKKwliZmFfdHJjKHJwLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9SUE9SVF9TTV9PRkZMSU5FOgorCQliZmFfc3RhdHMocnAsIHNtX2lvY2Rfb2ZmKTsKKwkJYmZhX3Jwb3J0X29mZmxpbmVfY2IocnApOworCQlicmVhazsKKworCWNhc2UgQkZBX1JQT1JUX1NNX0RFTEVURToKKwkJYmZhX3N0YXRzKHJwLCBzbV9pb2NkX2RlbCk7CisJCWJmYV9zbV9zZXRfc3RhdGUocnAsIGJmYV9ycG9ydF9zbV91bmluaXQpOworCQliZmFfcnBvcnRfZnJlZShycCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfUlBPUlRfU01fT05MSU5FOgorCQliZmFfc3RhdHMocnAsIHNtX2lvY2Rfb24pOworCQlpZiAoYmZhX3Jwb3J0X3NlbmRfZndjcmVhdGUocnApKQorCQkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2Z3Y3JlYXRlKTsKKwkJZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX2Z3Y3JlYXRlX3FmdWxsKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9SUE9SVF9TTV9IV0ZBSUw6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3N0YXRzKHJwLCBzbV9pb2NkX3VuZXhwKTsKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBiZmFfcnBvcnRfcHJpdmF0ZSBCRkEgcnBvcnQgcHJpdmF0ZSBmdW5jdGlvbnMKKyAqLworCitzdGF0aWMgdm9pZAorX19iZmFfY2JfcnBvcnRfb25saW5lKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfcnBvcnRfcyAqcnAgPSBjYmFyZzsKKworCWlmIChjb21wbGV0ZSkKKwkJYmZhX2NiX3Jwb3J0X29ubGluZShycC0+cnBvcnRfZHJ2KTsKK30KKworc3RhdGljIHZvaWQKK19fYmZhX2NiX3Jwb3J0X29mZmxpbmUodm9pZCAqY2JhcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpCit7CisJc3RydWN0IGJmYV9ycG9ydF9zICpycCA9IGNiYXJnOworCisJaWYgKGNvbXBsZXRlKQorCQliZmFfY2JfcnBvcnRfb2ZmbGluZShycC0+cnBvcnRfZHJ2KTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9ycG9ydF9xcmVzdW1lKHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfcnBvcnRfcwkqcnAgPSBjYmFyZzsKKworCWJmYV9zbV9zZW5kX2V2ZW50KHJwLCBCRkFfUlBPUlRfU01fUVJFU1VNRSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfbWVtaW5mbyhzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsIHUzMiAqa21fbGVuLAorCQl1MzIgKmRtX2xlbikKK3sKKwlpZiAoY2ZnLT5md2NmZy5udW1fcnBvcnRzIDwgQkZBX1JQT1JUX01JTikKKwkJY2ZnLT5md2NmZy5udW1fcnBvcnRzID0gQkZBX1JQT1JUX01JTjsKKworCSprbV9sZW4gKz0gY2ZnLT5md2NmZy5udW1fcnBvcnRzICogc2l6ZW9mKHN0cnVjdCBiZmFfcnBvcnRfcyk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfYXR0YWNoKHN0cnVjdCBiZmFfcyAqYmZhLCB2b2lkICpiZmFkLCBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCSAgICAgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1lbWluZm8sIHN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldikKK3sKKwlzdHJ1Y3QgYmZhX3Jwb3J0X21vZF9zICptb2QgPSBCRkFfUlBPUlRfTU9EKGJmYSk7CisJc3RydWN0IGJmYV9ycG9ydF9zICpycDsKKwl1MTYgICAgICAgIGk7CisKKwlJTklUX0xJU1RfSEVBRCgmbW9kLT5ycF9mcmVlX3EpOworCUlOSVRfTElTVF9IRUFEKCZtb2QtPnJwX2FjdGl2ZV9xKTsKKworCXJwID0gKHN0cnVjdCBiZmFfcnBvcnRfcyAqKSBiZmFfbWVtaW5mb19rdmEobWVtaW5mbyk7CisJbW9kLT5ycHNfbGlzdCA9IHJwOworCW1vZC0+bnVtX3Jwb3J0cyA9IGNmZy0+ZndjZmcubnVtX3Jwb3J0czsKKworCWJmYV9hc3NlcnQobW9kLT5udW1fcnBvcnRzCisJCSAgICYmICEobW9kLT5udW1fcnBvcnRzICYgKG1vZC0+bnVtX3Jwb3J0cyAtIDEpKSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgbW9kLT5udW1fcnBvcnRzOyBpKyssIHJwKyspIHsKKwkJYmZhX29zX21lbXNldChycCwgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfcnBvcnRfcykpOworCQlycC0+YmZhID0gYmZhOworCQlycC0+cnBvcnRfdGFnID0gaTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX3VuaW5pdCk7CisKKwkJLyoqCisJCSAqICAtIGlzIHVudXNlZAorCQkgKi8KKwkJaWYgKGkpCisJCQlsaXN0X2FkZF90YWlsKCZycC0+cWUsICZtb2QtPnJwX2ZyZWVfcSk7CisKKwkJYmZhX3JlcXFfd2luaXQoJnJwLT5yZXFxX3dhaXQsIGJmYV9ycG9ydF9xcmVzdW1lLCBycCk7CisJfQorCisJLyoqCisJICogY29uc3VtZSBtZW1vcnkKKwkgKi8KKwliZmFfbWVtaW5mb19rdmEobWVtaW5mbykgPSAodTggKikgcnA7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfaW5pdGRvbmUoc3RydWN0IGJmYV9zICpiZmEpCit7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfZGV0YWNoKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX3Jwb3J0X3N0YXJ0KHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX3Jwb3J0X3N0b3Aoc3RydWN0IGJmYV9zICpiZmEpCit7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfcnBvcnRfaW9jZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKKwlzdHJ1Y3QgYmZhX3Jwb3J0X21vZF9zICptb2QgPSBCRkFfUlBPUlRfTU9EKGJmYSk7CisJc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAqcWUsICpxZW47CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJm1vZC0+cnBfYWN0aXZlX3EpIHsKKwkJcnBvcnQgPSAoc3RydWN0IGJmYV9ycG9ydF9zICopIHFlOworCQliZmFfc21fc2VuZF9ldmVudChycG9ydCwgQkZBX1JQT1JUX1NNX0hXRkFJTCk7CisJfQorfQorCitzdGF0aWMgc3RydWN0IGJmYV9ycG9ydF9zICoKK2JmYV9ycG9ydF9hbGxvYyhzdHJ1Y3QgYmZhX3Jwb3J0X21vZF9zICptb2QpCit7CisJc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydDsKKworCWJmYV9xX2RlcSgmbW9kLT5ycF9mcmVlX3EsICZycG9ydCk7CisJaWYgKHJwb3J0KQorCQlsaXN0X2FkZF90YWlsKCZycG9ydC0+cWUsICZtb2QtPnJwX2FjdGl2ZV9xKTsKKworCXJldHVybiAocnBvcnQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX3Jwb3J0X2ZyZWUoc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX3Jwb3J0X21vZF9zICptb2QgPSBCRkFfUlBPUlRfTU9EKHJwb3J0LT5iZmEpOworCisJYmZhX2Fzc2VydChiZmFfcV9pc19vbl9xKCZtb2QtPnJwX2FjdGl2ZV9xLCBycG9ydCkpOworCWxpc3RfZGVsKCZycG9ydC0+cWUpOworCWxpc3RfYWRkX3RhaWwoJnJwb3J0LT5xZSwgJm1vZC0+cnBfZnJlZV9xKTsKK30KKworc3RhdGljIGJmYV9ib29sZWFuX3QKK2JmYV9ycG9ydF9zZW5kX2Z3Y3JlYXRlKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnApCit7CisJc3RydWN0IGJmaV9ycG9ydF9jcmVhdGVfcmVxX3MgKm07CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQocnAtPmJmYSwgQkZBX1JFUVFfUlBPUlQpOworCWlmICghbSkgeworCQliZmFfcmVxcV93YWl0KHJwLT5iZmEsIEJGQV9SRVFRX1JQT1JULCAmcnAtPnJlcXFfd2FpdCk7CisJCXJldHVybiBCRkFfRkFMU0U7CisJfQorCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19SUE9SVCwgQkZJX1JQT1JUX0gySV9DUkVBVEVfUkVRLAorCQkJYmZhX2xwdWlkKHJwLT5iZmEpKTsKKwltLT5iZmFfaGFuZGxlID0gcnAtPnJwb3J0X3RhZzsKKwltLT5tYXhfZnJtc3ogPSBiZmFfb3NfaHRvbnMocnAtPnJwb3J0X2luZm8ubWF4X2ZybXN6KTsKKwltLT5waWQgPSBycC0+cnBvcnRfaW5mby5waWQ7CisJbS0+bHBfdGFnID0gcnAtPnJwb3J0X2luZm8ubHBfdGFnOworCW0tPmxvY2FsX3BpZCA9IHJwLT5ycG9ydF9pbmZvLmxvY2FsX3BpZDsKKwltLT5mY19jbGFzcyA9IHJwLT5ycG9ydF9pbmZvLmZjX2NsYXNzOworCW0tPnZmX2VuID0gcnAtPnJwb3J0X2luZm8udmZfZW47CisJbS0+dmZfaWQgPSBycC0+cnBvcnRfaW5mby52Zl9pZDsKKwltLT5jaXNjID0gcnAtPnJwb3J0X2luZm8uY2lzYzsKKworCS8qKgorCSAqIHF1ZXVlIEkvTyBtZXNzYWdlIHRvIGZpcm13YXJlCisJICovCisJYmZhX3JlcXFfcHJvZHVjZShycC0+YmZhLCBCRkFfUkVRUV9SUE9SVCk7CisJcmV0dXJuIEJGQV9UUlVFOworfQorCitzdGF0aWMgYmZhX2Jvb2xlYW5fdAorYmZhX3Jwb3J0X3NlbmRfZndkZWxldGUoc3RydWN0IGJmYV9ycG9ydF9zICpycCkKK3sKKwlzdHJ1Y3QgYmZpX3Jwb3J0X2RlbGV0ZV9yZXFfcyAqbTsKKworCS8qKgorCSAqIGNoZWNrIGZvciByb29tIGluIHF1ZXVlIHRvIHNlbmQgcmVxdWVzdCBub3cKKwkgKi8KKwltID0gYmZhX3JlcXFfbmV4dChycC0+YmZhLCBCRkFfUkVRUV9SUE9SVCk7CisJaWYgKCFtKSB7CisJCWJmYV9yZXFxX3dhaXQocnAtPmJmYSwgQkZBX1JFUVFfUlBPUlQsICZycC0+cmVxcV93YWl0KTsKKwkJcmV0dXJuIEJGQV9GQUxTRTsKKwl9CisKKwliZmlfaDJpX3NldChtLT5taCwgQkZJX01DX1JQT1JULCBCRklfUlBPUlRfSDJJX0RFTEVURV9SRVEsCisJCQliZmFfbHB1aWQocnAtPmJmYSkpOworCW0tPmZ3X2hhbmRsZSA9IHJwLT5md19oYW5kbGU7CisKKwkvKioKKwkgKiBxdWV1ZSBJL08gbWVzc2FnZSB0byBmaXJtd2FyZQorCSAqLworCWJmYV9yZXFxX3Byb2R1Y2UocnAtPmJmYSwgQkZBX1JFUVFfUlBPUlQpOworCXJldHVybiBCRkFfVFJVRTsKK30KKworc3RhdGljIGJmYV9ib29sZWFuX3QKK2JmYV9ycG9ydF9zZW5kX2Z3c3BlZWQoc3RydWN0IGJmYV9ycG9ydF9zICpycCkKK3sKKwlzdHJ1Y3QgYmZhX3Jwb3J0X3NwZWVkX3JlcV9zICptOworCisJLyoqCisJICogY2hlY2sgZm9yIHJvb20gaW4gcXVldWUgdG8gc2VuZCByZXF1ZXN0IG5vdworCSAqLworCW0gPSBiZmFfcmVxcV9uZXh0KHJwLT5iZmEsIEJGQV9SRVFRX1JQT1JUKTsKKwlpZiAoIW0pIHsKKwkJYmZhX3RyYyhycC0+YmZhLCBycC0+cnBvcnRfaW5mby5zcGVlZCk7CisJCXJldHVybiBCRkFfRkFMU0U7CisJfQorCisJYmZpX2gyaV9zZXQobS0+bWgsIEJGSV9NQ19SUE9SVCwgQkZJX1JQT1JUX0gySV9TRVRfU1BFRURfUkVRLAorCQkJYmZhX2xwdWlkKHJwLT5iZmEpKTsKKwltLT5md19oYW5kbGUgPSBycC0+ZndfaGFuZGxlOworCW0tPnNwZWVkID0gKHU4KXJwLT5ycG9ydF9pbmZvLnNwZWVkOworCisJLyoqCisJICogcXVldWUgSS9PIG1lc3NhZ2UgdG8gZmlybXdhcmUKKwkgKi8KKwliZmFfcmVxcV9wcm9kdWNlKHJwLT5iZmEsIEJGQV9SRVFRX1JQT1JUKTsKKwlyZXR1cm4gQkZBX1RSVUU7Cit9CisKKworCisvKioKKyAqICBiZmFfcnBvcnRfcHVibGljCisgKi8KKworLyoqCisgKiAJCVJwb3J0IGludGVycnVwdCBwcm9jZXNzaW5nLgorICovCit2b2lkCitiZmFfcnBvcnRfaXNyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZpX21zZ19zICptKQoreworCXVuaW9uIGJmaV9ycG9ydF9pMmhfbXNnX3UgbXNnOworCXN0cnVjdCBiZmFfcnBvcnRfcyAqcnA7CisKKwliZmFfdHJjKGJmYSwgbS0+bWhkci5tc2dfaWQpOworCisJbXNnLm1zZyA9IG07CisKKwlzd2l0Y2ggKG0tPm1oZHIubXNnX2lkKSB7CisJY2FzZSBCRklfUlBPUlRfSTJIX0NSRUFURV9SU1A6CisJCXJwID0gQkZBX1JQT1JUX0ZST01fVEFHKGJmYSwgbXNnLmNyZWF0ZV9yc3AtPmJmYV9oYW5kbGUpOworCQlycC0+ZndfaGFuZGxlID0gbXNnLmNyZWF0ZV9yc3AtPmZ3X2hhbmRsZTsKKwkJcnAtPnFvc19hdHRyID0gbXNnLmNyZWF0ZV9yc3AtPnFvc19hdHRyOworCQliZmFfYXNzZXJ0KG1zZy5jcmVhdGVfcnNwLT5zdGF0dXMgPT0gQkZBX1NUQVRVU19PSyk7CisJCWJmYV9zbV9zZW5kX2V2ZW50KHJwLCBCRkFfUlBPUlRfU01fRldSU1ApOworCQlicmVhazsKKworCWNhc2UgQkZJX1JQT1JUX0kySF9ERUxFVEVfUlNQOgorCQlycCA9IEJGQV9SUE9SVF9GUk9NX1RBRyhiZmEsIG1zZy5kZWxldGVfcnNwLT5iZmFfaGFuZGxlKTsKKwkJYmZhX2Fzc2VydChtc2cuZGVsZXRlX3JzcC0+c3RhdHVzID09IEJGQV9TVEFUVVNfT0spOworCQliZmFfc21fc2VuZF9ldmVudChycCwgQkZBX1JQT1JUX1NNX0ZXUlNQKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGSV9SUE9SVF9JMkhfUU9TX1NDTjoKKwkJcnAgPSBCRkFfUlBPUlRfRlJPTV9UQUcoYmZhLCBtc2cucW9zX3Njbl9ldnQtPmJmYV9oYW5kbGUpOworCQlycC0+ZXZlbnRfYXJnLmZ3X21zZyA9IG1zZy5xb3Nfc2NuX2V2dDsKKwkJYmZhX3NtX3NlbmRfZXZlbnQocnAsIEJGQV9SUE9SVF9TTV9RT1NfU0NOKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfdHJjKGJmYSwgbS0+bWhkci5tc2dfaWQpOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworCisKKy8qKgorICogIGJmYV9ycG9ydF9hcGkKKyAqLworCitzdHJ1Y3QgYmZhX3Jwb3J0X3MgKgorYmZhX3Jwb3J0X2NyZWF0ZShzdHJ1Y3QgYmZhX3MgKmJmYSwgdm9pZCAqcnBvcnRfZHJ2KQoreworCXN0cnVjdCBiZmFfcnBvcnRfcyAqcnA7CisKKwlycCA9IGJmYV9ycG9ydF9hbGxvYyhCRkFfUlBPUlRfTU9EKGJmYSkpOworCisJaWYgKHJwID09IE5VTEwpCisJCXJldHVybiAoTlVMTCk7CisKKwlycC0+YmZhID0gYmZhOworCXJwLT5ycG9ydF9kcnYgPSBycG9ydF9kcnY7CisJYmZhX3Jwb3J0X2NsZWFyX3N0YXRzKHJwKTsKKworCWJmYV9hc3NlcnQoYmZhX3NtX2NtcF9zdGF0ZShycCwgYmZhX3Jwb3J0X3NtX3VuaW5pdCkpOworCWJmYV9zbV9zZW5kX2V2ZW50KHJwLCBCRkFfUlBPUlRfU01fQ1JFQVRFKTsKKworCXJldHVybiAocnApOworfQorCit2b2lkCitiZmFfcnBvcnRfZGVsZXRlKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnBvcnQpCit7CisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIEJGQV9SUE9SVF9TTV9ERUxFVEUpOworfQorCit2b2lkCitiZmFfcnBvcnRfb25saW5lKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnBvcnQsIHN0cnVjdCBiZmFfcnBvcnRfaW5mb19zICpycG9ydF9pbmZvKQoreworCWJmYV9hc3NlcnQocnBvcnRfaW5mby0+bWF4X2ZybXN6ICE9IDApOworCisJLyoqCisJICogU29tZSBKQk9EcyBhcmUgc2VlbiB0byBiZSBub3Qgc2V0dGluZyBQRFUgc2l6ZSBjb3JyZWN0bHkgaW4gUExPR0kKKwkgKiByZXNwb25zZXMuIERlZmF1bHQgdG8gbWluaW11bSBzaXplLgorCSAqLworCWlmIChycG9ydF9pbmZvLT5tYXhfZnJtc3ogPT0gMCkgeworCQliZmFfdHJjKHJwb3J0LT5iZmEsIHJwb3J0LT5ycG9ydF90YWcpOworCQlycG9ydF9pbmZvLT5tYXhfZnJtc3ogPSBGQ19NSU5fUERVU1o7CisJfQorCisJYmZhX29zX2Fzc2lnbihycG9ydC0+cnBvcnRfaW5mbywgKnJwb3J0X2luZm8pOworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBCRkFfUlBPUlRfU01fT05MSU5FKTsKK30KKwordm9pZAorYmZhX3Jwb3J0X29mZmxpbmUoc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgQkZBX1JQT1JUX1NNX09GRkxJTkUpOworfQorCit2b2lkCitiZmFfcnBvcnRfc3BlZWQoc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydCwgZW51bSBiZmFfcHBvcnRfc3BlZWQgc3BlZWQpCit7CisJYmZhX2Fzc2VydChzcGVlZCAhPSAwKTsKKwliZmFfYXNzZXJ0KHNwZWVkICE9IEJGQV9QUE9SVF9TUEVFRF9BVVRPKTsKKworCXJwb3J0LT5ycG9ydF9pbmZvLnNwZWVkID0gc3BlZWQ7CisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIEJGQV9SUE9SVF9TTV9TRVRfU1BFRUQpOworfQorCit2b2lkCitiZmFfcnBvcnRfZ2V0X3N0YXRzKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnBvcnQsCisJc3RydWN0IGJmYV9ycG9ydF9oYWxfc3RhdHNfcyAqc3RhdHMpCit7CisJKnN0YXRzID0gcnBvcnQtPnN0YXRzOworfQorCit2b2lkCitiZmFfcnBvcnRfZ2V0X3Fvc19hdHRyKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnBvcnQsCisJCQkJCXN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyAqcW9zX2F0dHIpCit7CisJcW9zX2F0dHItPnFvc19wcmlvcml0eSAgPSBiZmFfb3NfbnRvaGwocnBvcnQtPnFvc19hdHRyLnFvc19wcmlvcml0eSk7CisJcW9zX2F0dHItPnFvc19mbG93X2lkICA9IGJmYV9vc19udG9obChycG9ydC0+cW9zX2F0dHIucW9zX2Zsb3dfaWQpOworCit9CisKK3ZvaWQKK2JmYV9ycG9ydF9jbGVhcl9zdGF0cyhzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0KQoreworCWJmYV9vc19tZW1zZXQoJnJwb3J0LT5zdGF0cywgMCwgc2l6ZW9mKHJwb3J0LT5zdGF0cykpOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3Jwb3J0X3ByaXYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3Jwb3J0X3ByaXYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NDkwY2UyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFfcnBvcnRfcHJpdi5oCkBAIC0wLDAgKzEsNDUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9SUE9SVF9QUklWX0hfXworI2RlZmluZSBfX0JGQV9SUE9SVF9QUklWX0hfXworCisjaW5jbHVkZSA8YmZhX3N2Yy5oPgorCisjZGVmaW5lIEJGQV9SUE9SVF9NSU4JNAorCitzdHJ1Y3QgYmZhX3Jwb3J0X21vZF9zIHsKKwlzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwc19saXN0OwkvKiAgbGlzdCBvZiBycG9ydHMJKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIAlycF9mcmVlX3E7CS8qICBmcmVlIGJmYV9ycG9ydHMJKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIAlycF9hY3RpdmVfcTsJLyogIGZyZWUgYmZhX3Jwb3J0cyAJKi8KKwl1MTYJbnVtX3Jwb3J0czsJLyogIG51bWJlciBvZiBycG9ydHMJKi8KK307CisKKyNkZWZpbmUgQkZBX1JQT1JUX01PRChfX2JmYSkJKCYoX19iZmEpLT5tb2R1bGVzLnJwb3J0X21vZCkKKworLyoqCisgKiBDb252ZXJ0IHJwb3J0IHRhZyB0byBSUE9SVAorICovCisjZGVmaW5lIEJGQV9SUE9SVF9GUk9NX1RBRyhfX2JmYSwgX3RhZykJCQkJXAorCShCRkFfUlBPUlRfTU9EKF9fYmZhKS0+cnBzX2xpc3QgKwkJCQlcCisJICgoX3RhZykgJiAoQkZBX1JQT1JUX01PRChfX2JmYSktPm51bV9ycG9ydHMgLSAxKSkpCisKKy8qCisgKiBleHRlcm5hbCBmdW5jdGlvbnMKKyAqLwordm9pZAliZmFfcnBvcnRfaXNyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZpX21zZ19zICptc2cpOworI2VuZGlmIC8qIF9fQkZBX1JQT1JUX1BSSVZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zZ3BnLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zZ3BnLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjc5ZDhmOQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3NncGcuYwpAQCAtMCwwICsxLDIzMSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSA8YmZhLmg+CisKK0JGQV9UUkNfRklMRShIQUwsIFNHUEcpOworQkZBX01PRFVMRShzZ3BnKTsKKworLyoqCisgKiAgYmZhX3NncGdfbW9kIEJGQSBTR1BHIE1vZGUgbW9kdWxlCisgKi8KKworLyoqCisgKiBDb21wdXRlIGFuZCByZXR1cm4gbWVtb3J5IG5lZWRlZCBieSBGQ1AoaW0pIG1vZHVsZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9zZ3BnX21lbWluZm8oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnLCB1MzIgKmttX2xlbiwKKwkJdTMyICpkbV9sZW4pCit7CisJaWYgKGNmZy0+ZHJ2Y2ZnLm51bV9zZ3BncyA8IEJGQV9TR1BHX01JTikKKwkJY2ZnLT5kcnZjZmcubnVtX3NncGdzID0gQkZBX1NHUEdfTUlOOworCisJKmttX2xlbiArPSAoY2ZnLT5kcnZjZmcubnVtX3NncGdzICsgMSkgKiBzaXplb2Yoc3RydWN0IGJmYV9zZ3BnX3MpOworCSpkbV9sZW4gKz0gKGNmZy0+ZHJ2Y2ZnLm51bV9zZ3BncyArIDEpICogc2l6ZW9mKHN0cnVjdCBiZmlfc2dwZ19zKTsKK30KKworCitzdGF0aWMgdm9pZAorYmZhX3NncGdfYXR0YWNoKHN0cnVjdCBiZmFfcyAqYmZhLCB2b2lkICpiZmFkLCBzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCSAgICBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWluZm8sIHN0cnVjdCBiZmFfcGNpZGV2X3MgKnBjaWRldikKK3sKKwlzdHJ1Y3QgYmZhX3NncGdfbW9kX3MJKm1vZCA9IEJGQV9TR1BHX01PRChiZmEpOworCWludAkJCQlpOworCXN0cnVjdCBiZmFfc2dwZ19zCQkqaHNncGc7CisJc3RydWN0IGJmaV9zZ3BnX3MgCSpzZ3BnOworCXU2NAkJYWxpZ25fbGVuOworCisJdW5pb24geworCQl1NjQgICAgICAgIHBhOworCQl1bmlvbiBiZmlfYWRkcl91ICAgICAgYWRkcjsKKwl9IHNncGdfcGE7CisKKwlJTklUX0xJU1RfSEVBRCgmbW9kLT5zZ3BnX3EpOworCUlOSVRfTElTVF9IRUFEKCZtb2QtPnNncGdfd2FpdF9xKTsKKworCWJmYV90cmMoYmZhLCBjZmctPmRydmNmZy5udW1fc2dwZ3MpOworCisJbW9kLT5udW1fc2dwZ3MgPSBjZmctPmRydmNmZy5udW1fc2dwZ3M7CisJbW9kLT5zZ3BnX2Fycl9wYSA9IGJmYV9tZW1pbmZvX2RtYV9waHlzKG1pbmZvKTsKKwlhbGlnbl9sZW4gPSAoQkZBX1NHUEdfUk9VTkRVUChtb2QtPnNncGdfYXJyX3BhKSAtIG1vZC0+c2dwZ19hcnJfcGEpOworCW1vZC0+c2dwZ19hcnJfcGEgKz0gYWxpZ25fbGVuOworCW1vZC0+aHNncGdfYXJyID0gKHN0cnVjdCBiZmFfc2dwZ19zICopIChiZmFfbWVtaW5mb19rdmEobWluZm8pICsKKwkJCQkJCWFsaWduX2xlbik7CisJbW9kLT5zZ3BnX2FyciA9IChzdHJ1Y3QgYmZpX3NncGdfcyAqKSAoYmZhX21lbWluZm9fZG1hX3ZpcnQobWluZm8pICsKKwkJCQkJCWFsaWduX2xlbik7CisKKwloc2dwZyA9IG1vZC0+aHNncGdfYXJyOworCXNncGcgPSBtb2QtPnNncGdfYXJyOworCXNncGdfcGEucGEgPSBtb2QtPnNncGdfYXJyX3BhOworCW1vZC0+ZnJlZV9zZ3BncyA9IG1vZC0+bnVtX3NncGdzOworCisJYmZhX2Fzc2VydCghKHNncGdfcGEucGEgJiAoc2l6ZW9mKHN0cnVjdCBiZmlfc2dwZ19zKSAtIDEpKSk7CisKKwlmb3IgKGkgPSAwOyBpIDwgbW9kLT5udW1fc2dwZ3M7IGkrKykgeworCQliZmFfb3NfbWVtc2V0KGhzZ3BnLCAwLCBzaXplb2YoKmhzZ3BnKSk7CisJCWJmYV9vc19tZW1zZXQoc2dwZywgMCwgc2l6ZW9mKCpzZ3BnKSk7CisKKwkJaHNncGctPnNncGcgPSBzZ3BnOworCQloc2dwZy0+c2dwZ19wYSA9IHNncGdfcGEuYWRkcjsKKwkJbGlzdF9hZGRfdGFpbCgmaHNncGctPnFlLCAmbW9kLT5zZ3BnX3EpOworCisJCWhzZ3BnKys7CisJCXNncGcrKzsKKwkJc2dwZ19wYS5wYSArPSBzaXplb2Yoc3RydWN0IGJmaV9zZ3BnX3MpOworCX0KKworCWJmYV9tZW1pbmZvX2t2YShtaW5mbykgPSAodTggKikgaHNncGc7CisJYmZhX21lbWluZm9fZG1hX3ZpcnQobWluZm8pID0gKHU4ICopIHNncGc7CisJYmZhX21lbWluZm9fZG1hX3BoeXMobWluZm8pID0gc2dwZ19wYS5wYTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9zZ3BnX2luaXRkb25lKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX3NncGdfZGV0YWNoKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX3NncGdfc3RhcnQoc3RydWN0IGJmYV9zICpiZmEpCit7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfc2dwZ19zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKQoreworfQorCitzdGF0aWMgdm9pZAorYmZhX3NncGdfaW9jZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworCisKKy8qKgorICogIGJmYV9zZ3BnX3B1YmxpYyBCRkEgU0dQRyBwdWJsaWMgZnVuY3Rpb25zCisgKi8KKworYmZhX3N0YXR1c190CitiZmFfc2dwZ19tYWxsb2Moc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBsaXN0X2hlYWQgKnNncGdfcSwgaW50IG5zZ3BncykKK3sKKwlzdHJ1Y3QgYmZhX3NncGdfbW9kX3MgKm1vZCA9IEJGQV9TR1BHX01PRChiZmEpOworCXN0cnVjdCBiZmFfc2dwZ19zICpoc2dwZzsKKwlpbnQgICAgICAgICAgICAgaTsKKworCWJmYV90cmNfZnAoYmZhLCBuc2dwZ3MpOworCisJaWYgKG1vZC0+ZnJlZV9zZ3BncyA8IG5zZ3BncykKKwkJcmV0dXJuIEJGQV9TVEFUVVNfRU5PTUVNOworCisJZm9yIChpID0gMDsgaSA8IG5zZ3BnczsgaSsrKSB7CisJCWJmYV9xX2RlcSgmbW9kLT5zZ3BnX3EsICZoc2dwZyk7CisJCWJmYV9hc3NlcnQoaHNncGcpOworCQlsaXN0X2FkZF90YWlsKCZoc2dwZy0+cWUsIHNncGdfcSk7CisJfQorCisJbW9kLT5mcmVlX3NncGdzIC09IG5zZ3BnczsKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKwordm9pZAorYmZhX3NncGdfbWZyZWUoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBsaXN0X2hlYWQgKnNncGdfcSwgaW50IG5zZ3BnKQoreworCXN0cnVjdCBiZmFfc2dwZ19tb2RfcyAqbW9kID0gQkZBX1NHUEdfTU9EKGJmYSk7CisJc3RydWN0IGJmYV9zZ3BnX3dxZV9zICp3cWU7CisKKwliZmFfdHJjX2ZwKGJmYSwgbnNncGcpOworCisJbW9kLT5mcmVlX3NncGdzICs9IG5zZ3BnOworCWJmYV9hc3NlcnQobW9kLT5mcmVlX3NncGdzIDw9IG1vZC0+bnVtX3NncGdzKTsKKworCWxpc3Rfc3BsaWNlX3RhaWxfaW5pdChzZ3BnX3EsICZtb2QtPnNncGdfcSk7CisKKwlpZiAobGlzdF9lbXB0eSgmbW9kLT5zZ3BnX3dhaXRfcSkpCisJCXJldHVybjsKKworCS8qKgorCSAqIHNhdGlzZnkgYXMgbWFueSB3YWl0aW5nIHJlcXVlc3RzIGFzIHBvc3NpYmxlCisJICovCisJZG8geworCQl3cWUgPSBiZmFfcV9maXJzdCgmbW9kLT5zZ3BnX3dhaXRfcSk7CisJCWlmIChtb2QtPmZyZWVfc2dwZ3MgPCB3cWUtPm5zZ3BnKQorCQkJbnNncGcgPSBtb2QtPmZyZWVfc2dwZ3M7CisJCWVsc2UKKwkJCW5zZ3BnID0gd3FlLT5uc2dwZzsKKwkJYmZhX3NncGdfbWFsbG9jKGJmYSwgJndxZS0+c2dwZ19xLCBuc2dwZyk7CisJCXdxZS0+bnNncGcgLT0gbnNncGc7CisJCWlmICh3cWUtPm5zZ3BnID09IDApIHsKKwkJCWxpc3RfZGVsKCZ3cWUtPnFlKTsKKwkJCXdxZS0+Y2Jmbih3cWUtPmNiYXJnKTsKKwkJfQorCX0gd2hpbGUgKG1vZC0+ZnJlZV9zZ3BncyAmJiAhbGlzdF9lbXB0eSgmbW9kLT5zZ3BnX3dhaXRfcSkpOworfQorCit2b2lkCitiZmFfc2dwZ193YWl0KHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX3NncGdfd3FlX3MgKndxZSwgaW50IG5zZ3BnKQoreworCXN0cnVjdCBiZmFfc2dwZ19tb2RfcyAqbW9kID0gQkZBX1NHUEdfTU9EKGJmYSk7CisKKwliZmFfYXNzZXJ0KG5zZ3BnID4gMCk7CisJYmZhX2Fzc2VydChuc2dwZyA+IG1vZC0+ZnJlZV9zZ3Bncyk7CisKKwl3cWUtPm5zZ3BnX3RvdGFsID0gd3FlLT5uc2dwZyA9IG5zZ3BnOworCisJLyoqCisJICogYWxsb2NhdGUgYW55IGxlZnQgdG8gdGhpcyBvbmUgZmlyc3QKKwkgKi8KKwlpZiAobW9kLT5mcmVlX3NncGdzKSB7CisJCS8qKgorCQkgKiBubyBvbmUgZWxzZSBpcyB3YWl0aW5nIGZvciBTR1BHCisJCSAqLworCQliZmFfYXNzZXJ0KGxpc3RfZW1wdHkoJm1vZC0+c2dwZ193YWl0X3EpKTsKKwkJbGlzdF9zcGxpY2VfdGFpbF9pbml0KCZtb2QtPnNncGdfcSwgJndxZS0+c2dwZ19xKTsKKwkJd3FlLT5uc2dwZyAtPSBtb2QtPmZyZWVfc2dwZ3M7CisJCW1vZC0+ZnJlZV9zZ3BncyA9IDA7CisJfQorCisJbGlzdF9hZGRfdGFpbCgmd3FlLT5xZSwgJm1vZC0+c2dwZ193YWl0X3EpOworfQorCit2b2lkCitiZmFfc2dwZ193Y2FuY2VsKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX3NncGdfd3FlX3MgKndxZSkKK3sKKwlzdHJ1Y3QgYmZhX3NncGdfbW9kX3MgKm1vZCA9IEJGQV9TR1BHX01PRChiZmEpOworCisJYmZhX2Fzc2VydChiZmFfcV9pc19vbl9xKCZtb2QtPnNncGdfd2FpdF9xLCB3cWUpKTsKKwlsaXN0X2RlbCgmd3FlLT5xZSk7CisKKwlpZiAod3FlLT5uc2dwZ190b3RhbCAhPSB3cWUtPm5zZ3BnKQorCQliZmFfc2dwZ19tZnJlZShiZmEsICZ3cWUtPnNncGdfcSwKKwkJCQkgICB3cWUtPm5zZ3BnX3RvdGFsIC0gd3FlLT5uc2dwZyk7Cit9CisKK3ZvaWQKK2JmYV9zZ3BnX3dpbml0KHN0cnVjdCBiZmFfc2dwZ193cWVfcyAqd3FlLCB2b2lkICgqY2JmbikgKHZvaWQgKmNiYXJnKSwKKwkJICAgdm9pZCAqY2JhcmcpCit7CisJSU5JVF9MSVNUX0hFQUQoJndxZS0+c2dwZ19xKTsKKwl3cWUtPmNiZm4gPSBjYmZuOworCXdxZS0+Y2JhcmcgPSBjYmFyZzsKK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zZ3BnX3ByaXYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3NncGdfcHJpdi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjljMmE4Y2IKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV9zZ3BnX3ByaXYuaApAQCAtMCwwICsxLDc5IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGhhbF9zZ3BnLmggQkZBIFNHIHBhZ2UgbW9kdWxlCisgKi8KKworI2lmbmRlZiBfX0JGQV9TR1BHX1BSSVZfSF9fCisjZGVmaW5lIF9fQkZBX1NHUEdfUFJJVl9IX18KKworI2luY2x1ZGUgPGNzL2JmYV9xLmg+CisKKyNkZWZpbmUgQkZBX1NHUEdfTUlOCSgxNikKKworLyoqCisgKiBBbGlnbm1lbnQgbWFjcm8gZm9yIFNHIHBhZ2UgYWxsb2NhdGlvbgorICovCisjZGVmaW5lIEJGQV9TR1BHX1JPVU5EVVAoX2wpICgoKF9sKSArIChzaXplb2Yoc3RydWN0IGJmaV9zZ3BnX3MpIC0gMSkpIFwKKwkJCSYgfihzaXplb2Yoc3RydWN0IGJmaV9zZ3BnX3MpIC0gMSkpCisKK3N0cnVjdCBiZmFfc2dwZ193cWVfcyB7CisJc3RydWN0IGxpc3RfaGVhZCBxZTsJLyogIHF1ZXVlIHNnIHBhZ2UgZWxlbWVudAkqLworCWludAluc2dwZzsJCS8qICBwYWdlcyB0byBiZSBhbGxvY2F0ZWQJKi8KKwlpbnQJbnNncGdfdG90YWw7CS8qICB0b3RhbCBwYWdlcyByZXF1aXJlZAkqLworCXZvaWQJKCpjYmZuKSAodm9pZCAqY2JhcmcpOworCQkJCS8qICBjYWxsYmFjayBmdW5jdGlvbgkJKi8KKwl2b2lkCSpjYmFyZzsJCS8qICBjYWxsYmFjayBhcmcJCSovCisJc3RydWN0IGxpc3RfaGVhZCBzZ3BnX3E7CS8qICBxdWV1ZSBvZiBhbGxvY2VkIHNncGdzCSovCit9OworCitzdHJ1Y3QgYmZhX3NncGdfcyB7CisJc3RydWN0IGxpc3RfaGVhZCAJcWU7CS8qICBxdWV1ZSBzZyBwYWdlIGVsZW1lbnQJKi8KKwlzdHJ1Y3QgYmZpX3NncGdfcyAqc2dwZzsgLyogIHZhIG9mIFNHIHBhZ2UJCSovCisJdW5pb24gYmZpX2FkZHJfdSBzZ3BnX3BhOy8qICBwYSBvZiBTRyBwYWdlCQkqLworfTsKKworLyoqCisgKiBHaXZlbiBudW1iZXIgb2YgU0cgZWxlbWVudHMsIEJGQV9TR1BHX05QQUdFKCkgcmV0dXJucyB0aGUgbnVtYmVyIG9mCisgKiBTRyBwYWdlcyByZXF1aXJlZC4KKyAqLworI2RlZmluZSBCRkFfU0dQR19OUEFHRShfbnNnZXMpICAoKChfbnNnZXMpIC8gQkZJX1NHUEdfREFUQV9TR0VTKSArIDEpCisKK3N0cnVjdCBiZmFfc2dwZ19tb2RfcyB7CisJc3RydWN0IGJmYV9zICpiZmE7CisJaW50CQludW1fc2dwZ3M7CS8qICBudW1iZXIgb2YgU0cgcGFnZXMJCSovCisJaW50CQlmcmVlX3NncGdzOwkvKiAgbnVtYmVyIG9mIGZyZWUgU0cgcGFnZXMJKi8KKwlzdHJ1Y3QgYmZhX3NncGdfcyAqaHNncGdfYXJyOwkvKiAgQkZBIFNHIHBhZ2UgYXJyYXkJKi8KKwlzdHJ1Y3QgYmZpX3NncGdfcyAqc2dwZ19hcnI7CS8qICBhY3R1YWwgU0cgcGFnZSBhcnJheQkqLworCXU2NAlzZ3BnX2Fycl9wYTsJLyogIFNHIHBhZ2UgYXJyYXkgRE1BIGFkZHIJKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIHNncGdfcTsJLyogIHF1ZXVlIG9mIGZyZWUgU0cgcGFnZXMJKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIHNncGdfd2FpdF9xOyAvKiAgd2FpdCBxdWV1ZSBmb3IgU0cgcGFnZXMJKi8KK307CisjZGVmaW5lIEJGQV9TR1BHX01PRChfX2JmYSkJKCYoX19iZmEpLT5tb2R1bGVzLnNncGdfbW9kKQorCitiZmFfc3RhdHVzX3QJYmZhX3NncGdfbWFsbG9jKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgbGlzdF9oZWFkICpzZ3BnX3EsCisJCQkJCQkJCWludCBuc2dwZ3MpOwordm9pZAkJYmZhX3NncGdfbWZyZWUoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBsaXN0X2hlYWQgKnNncGdfcSwKKwkJCQkJCQkJaW50IG5zZ3Bncyk7Cit2b2lkCQliZmFfc2dwZ193aW5pdChzdHJ1Y3QgYmZhX3NncGdfd3FlX3MgKndxZSwKKwkJCQkgICB2b2lkICgqY2JmbikgKHZvaWQgKmNiYXJnKSwgdm9pZCAqY2JhcmcpOwordm9pZAkJYmZhX3NncGdfd2FpdChzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9zZ3BnX3dxZV9zICp3cWUsCisJCQkJCQkJCWludCBuc2dwZ3MpOwordm9pZAkJYmZhX3NncGdfd2NhbmNlbChzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9zZ3BnX3dxZV9zICp3cWUpOworCisjZW5kaWYgLyogX19CRkFfU0dQR19QUklWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfc20uYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3NtLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTQyMGY0ZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3NtLmMKQEAgLTAsMCArMSwzOCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFzbS5jIEJGQSBTdGF0ZSBtYWNoaW5lIHV0aWxpdHkgZnVuY3Rpb25zCisgKi8KKworI2luY2x1ZGUgPGNzL2JmYV9zbS5oPgorCisvKioKKyAqICBjc19zbV9hcGkKKyAqLworCitpbnQKK2JmYV9zbV90b19zdGF0ZShzdHJ1Y3QgYmZhX3NtX3RhYmxlX3MgKnNtdCwgYmZhX3NtX3Qgc20pCit7CisJaW50ICAgICAgICAgICAgIGkgPSAwOworCisJd2hpbGUgKHNtdFtpXS5zbSAmJiBzbXRbaV0uc20gIT0gc20pCisJCWkrKzsKKwlyZXR1cm4gc210W2ldLnN0YXRlOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3RpbWVyLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV90aW1lci5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNiNzY0ODEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV90aW1lci5jCkBAIC0wLDAgKzEsOTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYV90aW1lci5oPgorI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorCit2b2lkCitiZmFfdGltZXJfaW5pdChzdHJ1Y3QgYmZhX3RpbWVyX21vZF9zICptb2QpCit7CisJSU5JVF9MSVNUX0hFQUQoJm1vZC0+dGltZXJfcSk7Cit9CisKK3ZvaWQKK2JmYV90aW1lcl9iZWF0KHN0cnVjdCBiZmFfdGltZXJfbW9kX3MgKm1vZCkKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAqcWggPSAmbW9kLT50aW1lcl9xOworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICpxZSwgKnFlX25leHQ7CisJc3RydWN0IGJmYV90aW1lcl9zICplbGVtOworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICB0aW1lZG91dF9xOworCisJSU5JVF9MSVNUX0hFQUQoJnRpbWVkb3V0X3EpOworCisJcWUgPSBiZmFfcV9uZXh0KHFoKTsKKworCXdoaWxlIChxZSAhPSBxaCkgeworCQlxZV9uZXh0ID0gYmZhX3FfbmV4dChxZSk7CisKKwkJZWxlbSA9IChzdHJ1Y3QgYmZhX3RpbWVyX3MgKikgcWU7CisJCWlmIChlbGVtLT50aW1lb3V0IDw9IEJGQV9USU1FUl9GUkVRKSB7CisJCQllbGVtLT50aW1lb3V0ID0gMDsKKwkJCWxpc3RfZGVsKCZlbGVtLT5xZSk7CisJCQlsaXN0X2FkZF90YWlsKCZlbGVtLT5xZSwgJnRpbWVkb3V0X3EpOworCQl9IGVsc2UgeworCQkJZWxlbS0+dGltZW91dCAtPSBCRkFfVElNRVJfRlJFUTsKKwkJfQorCisJCXFlID0gcWVfbmV4dDsJLyogZ28gdG8gbmV4dCBlbGVtICovCisJfQorCisJLyoKKwkgKiBQb3AgYWxsIHRoZSB0aW1lb3V0IGVudHJpZXMKKwkgKi8KKwl3aGlsZSAoIWxpc3RfZW1wdHkoJnRpbWVkb3V0X3EpKSB7CisJCWJmYV9xX2RlcSgmdGltZWRvdXRfcSwgJmVsZW0pOworCQllbGVtLT50aW1lcmNiKGVsZW0tPmFyZyk7CisJfQorfQorCisvKioKKyAqIFNob3VsZCBiZSBjYWxsZWQgd2l0aCBsb2NrIHByb3RlY3Rpb24KKyAqLwordm9pZAorYmZhX3RpbWVyX2JlZ2luKHN0cnVjdCBiZmFfdGltZXJfbW9kX3MgKm1vZCwgc3RydWN0IGJmYV90aW1lcl9zICp0aW1lciwKKwkJICAgIHZvaWQgKCp0aW1lcmNiKSAodm9pZCAqKSwgdm9pZCAqYXJnLCB1bnNpZ25lZCBpbnQgdGltZW91dCkKK3sKKworCWJmYV9hc3NlcnQodGltZXJjYiAhPSBOVUxMKTsKKwliZmFfYXNzZXJ0KCFiZmFfcV9pc19vbl9xKCZtb2QtPnRpbWVyX3EsIHRpbWVyKSk7CisKKwl0aW1lci0+dGltZW91dCA9IHRpbWVvdXQ7CisJdGltZXItPnRpbWVyY2IgPSB0aW1lcmNiOworCXRpbWVyLT5hcmcgPSBhcmc7CisKKwlsaXN0X2FkZF90YWlsKCZ0aW1lci0+cWUsICZtb2QtPnRpbWVyX3EpOworfQorCisvKioKKyAqIFNob3VsZCBiZSBjYWxsZWQgd2l0aCBsb2NrIHByb3RlY3Rpb24KKyAqLwordm9pZAorYmZhX3RpbWVyX3N0b3Aoc3RydWN0IGJmYV90aW1lcl9zICp0aW1lcikKK3sKKwliZmFfYXNzZXJ0KCFsaXN0X2VtcHR5KCZ0aW1lci0+cWUpKTsKKworCWxpc3RfZGVsKCZ0aW1lci0+cWUpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfdHJjbW9kX3ByaXYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3RyY21vZF9wcml2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjM1NjJkYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3RyY21vZF9wcml2LmgKQEAgLTAsMCArMSw2NiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBoYWxfdHJjbW9kLmggQkZBIHRyYWNlIG1vZHVsZXMKKyAqLworCisjaWZuZGVmIF9fQkZBX1RSQ01PRF9QUklWX0hfXworI2RlZmluZSBfX0JGQV9UUkNNT0RfUFJJVl9IX18KKworI2luY2x1ZGUgPGNzL2JmYV90cmMuaD4KKworLyoKKyAqICEhISBPbmx5IGFwcGVuZCB0byB0aGUgZW51bXMgZGVmaW5lZCBoZXJlIHRvIGF2b2lkIGFueSB2ZXJzaW9uaW5nCisgKiAhISEgbmVlZGVkIGJldHdlZW4gdHJhY2UgdXRpbGl0eSBhbmQgZHJpdmVyIHZlcnNpb24KKyAqLworZW51bSB7CisJQkZBX1RSQ19IQUxfSU9DCQk9IDEsCisJQkZBX1RSQ19IQUxfSU5UUgk9IDIsCisJQkZBX1RSQ19IQUxfRkNYUAk9IDMsCisJQkZBX1RSQ19IQUxfVUYJCT0gNCwKKwlCRkFfVFJDX0hBTF9ESUFHCT0gNSwKKwlCRkFfVFJDX0hBTF9SUE9SVAk9IDYsCisJQkZBX1RSQ19IQUxfRkNQSU0JPSA3LAorCUJGQV9UUkNfSEFMX0lPSU0JPSA4LAorCUJGQV9UUkNfSEFMX1RTS0lNCT0gOSwKKwlCRkFfVFJDX0hBTF9JVE5JTQk9IDEwLAorCUJGQV9UUkNfSEFMX1BQT1JUCT0gMTEsCisJQkZBX1RSQ19IQUxfU0dQRwk9IDEyLAorCUJGQV9UUkNfSEFMX0ZMQVNICT0gMTMsCisJQkZBX1RSQ19IQUxfREVCVUcJPSAxNCwKKwlCRkFfVFJDX0hBTF9XV04JCT0gMTUsCisJQkZBX1RSQ19IQUxfRkxBU0hfUkFXCT0gMTYsCisJQkZBX1RSQ19IQUxfU0JPT1QJPSAxNywKKwlCRkFfVFJDX0hBTF9TQk9PVF9JTwk9IDE4LAorCUJGQV9UUkNfSEFMX1NCT09UX0lOVFIJPSAxOSwKKwlCRkFfVFJDX0hBTF9TQlRFU1QJPSAyMCwKKwlCRkFfVFJDX0hBTF9JUEZDCT0gMjEsCisJQkZBX1RSQ19IQUxfSU9DRkMJPSAyMiwKKwlCRkFfVFJDX0hBTF9GQ1BUTQk9IDIzLAorCUJGQV9UUkNfSEFMX0lPVE0JPSAyNCwKKwlCRkFfVFJDX0hBTF9UU0tUTQk9IDI1LAorCUJGQV9UUkNfSEFMX1RJTgkJPSAyNiwKKwlCRkFfVFJDX0hBTF9MUFMJCT0gMjcsCisJQkZBX1RSQ19IQUxfRkNESUFHCT0gMjgsCisJQkZBX1RSQ19IQUxfUEJJTkQJPSAyOSwKKwlCRkFfVFJDX0hBTF9JT0NGQ19DVAk9IDMwLAorCUJGQV9UUkNfSEFMX0lPQ0ZDX0NCCT0gMzEsCisJQkZBX1RSQ19IQUxfSU9DRkNfUQk9IDMyLAorfTsKKworI2VuZGlmIC8qIF9fQkZBX1RSQ01PRF9QUklWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfdHNraW0uYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3Rza2ltLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDEwZDQwZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3Rza2ltLmMKQEAgLTAsMCArMSw2ODkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9jYl9pb2ltX21hY3Jvcy5oPgorCitCRkFfVFJDX0ZJTEUoSEFMLCBUU0tJTSk7CisKKy8qKgorICogdGFzayBtYW5hZ2VtZW50IGNvbXBsZXRpb24gaGFuZGxpbmcKKyAqLworI2RlZmluZSBiZmFfdHNraW1fcWNvbXAoX190c2tpbSwgX19jYmZuKSBkbyB7CQkJICAgICBcCisJYmZhX2NiX3F1ZXVlKChfX3Rza2ltKS0+YmZhLCAmKF9fdHNraW0pLT5oY2JfcWUsIF9fY2JmbiwgKF9fdHNraW0pKTsgXAorCWJmYV90c2tpbV9ub3RpZnlfY29tcChfX3Rza2ltKTsgICAgICBcCit9IHdoaWxlICgwKQorCisjZGVmaW5lIGJmYV90c2tpbV9ub3RpZnlfY29tcChfX3Rza2ltKSBkbyB7CQkJCSAgICAgXAorCWlmICgoX190c2tpbSktPm5vdGlmeSkJCQkJCSAgICAgCSAgICAgXAorCQliZmFfaXRuaW1fdHNrZG9uZSgoX190c2tpbSktPml0bmltKTsgICAgICBcCit9IHdoaWxlICgwKQorCisvKgorICogZm9yd2FyZCBkZWNsYXJhdGlvbnMKKyAqLworc3RhdGljIHZvaWQgICAgIF9fYmZhX2NiX3Rza2ltX2RvbmUodm9pZCAqY2JhcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpOworc3RhdGljIHZvaWQgICAgIF9fYmZhX2NiX3Rza2ltX2ZhaWxlZCh2b2lkICpjYmFyZywgYmZhX2Jvb2xlYW5fdCBjb21wbGV0ZSk7CitzdGF0aWMgYmZhX2Jvb2xlYW5fdCBiZmFfdHNraW1fbWF0Y2hfc2NvcGUoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwKKwkJCQkJICAgICAgIGx1bl90IGx1bik7CitzdGF0aWMgdm9pZCAgICAgYmZhX3Rza2ltX2dhdGhlcl9pb3Moc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3Rza2ltX2NsZWFucF9jb21wKHZvaWQgKnRza2ltX2NiYXJnKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfdHNraW1fY2xlYW51cF9pb3Moc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSk7CitzdGF0aWMgYmZhX2Jvb2xlYW5fdCBiZmFfdHNraW1fc2VuZChzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltKTsKK3N0YXRpYyBiZmFfYm9vbGVhbl90IGJmYV90c2tpbV9zZW5kX2Fib3J0KHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0pOworc3RhdGljIHZvaWQgICAgIGJmYV90c2tpbV9pb2NkaXNhYmxlX2lvcyhzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltKTsKKworLyoqCisgKiAgYmZhX3Rza2ltX3NtCisgKi8KKworZW51bSBiZmFfdHNraW1fZXZlbnQgeworCUJGQV9UU0tJTV9TTV9TVEFSVCAgICAgICAgPSAxLCAgLyogIFRNIGNvbW1hbmQgc3RhcnQgICAgICAgICAgICAqLworCUJGQV9UU0tJTV9TTV9ET05FICAgICAgICAgPSAyLCAgLyogIFRNIGNvbXBsZXRpb24gICAgICAgICAgICAgICAqLworCUJGQV9UU0tJTV9TTV9RUkVTVU1FICAgICAgPSAzLCAgLyogIHJlc3VtZSBhZnRlciBxZnVsbCAgICAgICAgICAqLworCUJGQV9UU0tJTV9TTV9IV0ZBSUwgICAgICAgPSA1LCAgLyogIElPQyBoL3cgZmFpbHVyZSBldmVudCAgICAgICAqLworCUJGQV9UU0tJTV9TTV9IQ0IgICAgICAgICAgPSA2LCAgLyogIEJGQSBjYWxsYmFjayBjb21wbGV0aW9uICAgICAqLworCUJGQV9UU0tJTV9TTV9JT1NfRE9ORSAgICAgPSA3LCAgLyogIElPIGFuZCBzdWIgVE0gY29tcGxldGlvbnMgICAqLworCUJGQV9UU0tJTV9TTV9DTEVBTlVQICAgICAgPSA4LCAgLyogIFRNIGNsZWFudXAgb24gSVROIG9mZmxpbmUgICAqLworCUJGQV9UU0tJTV9TTV9DTEVBTlVQX0RPTkUgPSA5LCAgLyogIFRNIGFib3J0IGNvbXBsZXRpb24gICAgICAgICAqLworfTsKKworc3RhdGljIHZvaWQgICAgIGJmYV90c2tpbV9zbV91bmluaXQoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwKKwkJCQkJZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV90c2tpbV9zbV9hY3RpdmUoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwKKwkJCQkJZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV90c2tpbV9zbV9jbGVhbnVwKHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0sCisJCQkJCSBlbnVtIGJmYV90c2tpbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3Rza2ltX3NtX2lvY2xlYW51cChzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltLAorCQkJCQkgZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV90c2tpbV9zbV9xZnVsbChzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltLAorCQkJCSAgICAgICBlbnVtIGJmYV90c2tpbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX3Rza2ltX3NtX2NsZWFudXBfcWZ1bGwoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwKKwkJCQkgICAgICAgZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV90c2tpbV9zbV9oY2Ioc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwKKwkJCQkgICAgIGVudW0gYmZhX3Rza2ltX2V2ZW50IGV2ZW50KTsKKworLyoqCisgKiAgICAgIFRhc2sgbWFuYWdlbWVudCBjb21tYW5kIGJlZ2lubmluZyBzdGF0ZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV90c2tpbV9zbV91bmluaXQoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwgZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyh0c2tpbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfVFNLSU1fU01fU1RBUlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUodHNraW0sIGJmYV90c2tpbV9zbV9hY3RpdmUpOworCQliZmFfdHNraW1fZ2F0aGVyX2lvcyh0c2tpbSk7CisKKwkJLyoqCisJCSAqIElmIGRldmljZSBpcyBvZmZsaW5lLCBkbyBub3Qgc2VuZCBUTSBvbiB3aXJlLiBKdXN0IGNsZWFudXAKKwkJICogYW55IHBlbmRpbmcgSU8gcmVxdWVzdHMgYW5kIGNvbXBsZXRlIFRNIHJlcXVlc3QuCisJCSAqLworCQlpZiAoIWJmYV9pdG5pbV9pc19vbmxpbmUodHNraW0tPml0bmltKSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2lvY2xlYW51cCk7CisJCQl0c2tpbS0+dHNrX3N0YXR1cyA9IEJGSV9UU0tJTV9TVFNfT0s7CisJCQliZmFfdHNraW1fY2xlYW51cF9pb3ModHNraW0pOworCQkJcmV0dXJuOworCQl9CisKKwkJaWYgKCFiZmFfdHNraW1fc2VuZCh0c2tpbSkpIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUodHNraW0sIGJmYV90c2tpbV9zbV9xZnVsbCk7CisJCQliZmFfcmVxcV93YWl0KHRza2ltLT5iZmEsIHRza2ltLT5pdG5pbS0+cmVxcSwKKwkJCQkJICAmdHNraW0tPnJlcXFfd2FpdCk7CisJCX0KKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBicmllZgorICoJVE0gY29tbWFuZCBpcyBhY3RpdmUsIGF3YWl0aW5nIGNvbXBsZXRpb24gZnJvbSBmaXJtd2FyZSB0bworICoJY2xlYW51cCBJTyByZXF1ZXN0cyBpbiBUTSBzY29wZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV90c2tpbV9zbV9hY3RpdmUoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwgZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyh0c2tpbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfVFNLSU1fU01fRE9ORToKKwkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2lvY2xlYW51cCk7CisJCWJmYV90c2tpbV9jbGVhbnVwX2lvcyh0c2tpbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfVFNLSU1fU01fQ0xFQU5VUDoKKwkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2NsZWFudXApOworCQlpZiAoIWJmYV90c2tpbV9zZW5kX2Fib3J0KHRza2ltKSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2NsZWFudXBfcWZ1bGwpOworCQkJYmZhX3JlcXFfd2FpdCh0c2tpbS0+YmZhLCB0c2tpbS0+aXRuaW0tPnJlcXEsCisJCQkJJnRza2ltLT5yZXFxX3dhaXQpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBCRkFfVFNLSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKHRza2ltLCBiZmFfdHNraW1fc21faGNiKTsKKwkJYmZhX3Rza2ltX2lvY2Rpc2FibGVfaW9zKHRza2ltKTsKKwkJYmZhX3Rza2ltX3Fjb21wKHRza2ltLCBfX2JmYV9jYl90c2tpbV9mYWlsZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqCUFuIGFjdGl2ZSBUTSBpcyBiZWluZyBjbGVhbmVkIHVwIHNpbmNlIElUTiBpcyBvZmZsaW5lLiBBd2FpdGluZyBjbGVhbnVwCisgKgljb21wbGV0aW9uIGV2ZW50IGZyb20gZmlybXdhcmUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfdHNraW1fc21fY2xlYW51cChzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltLCBlbnVtIGJmYV90c2tpbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHRza2ltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9UU0tJTV9TTV9ET05FOgorCQkvKioKKwkJICogSWdub3JlIGFuZCB3YWl0IGZvciBBQk9SVCBjb21wbGV0aW9uIGZyb20gZmlybXdhcmUuCisJCSAqLworCQlicmVhazsKKworCWNhc2UgQkZBX1RTS0lNX1NNX0NMRUFOVVBfRE9ORToKKwkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2lvY2xlYW51cCk7CisJCWJmYV90c2tpbV9jbGVhbnVwX2lvcyh0c2tpbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfVFNLSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKHRza2ltLCBiZmFfdHNraW1fc21faGNiKTsKKwkJYmZhX3Rza2ltX2lvY2Rpc2FibGVfaW9zKHRza2ltKTsKKwkJYmZhX3Rza2ltX3Fjb21wKHRza2ltLCBfX2JmYV9jYl90c2tpbV9mYWlsZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3Rza2ltX3NtX2lvY2xlYW51cChzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltLCBlbnVtIGJmYV90c2tpbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHRza2ltLT5iZmEsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9UU0tJTV9TTV9JT1NfRE9ORToKKwkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2hjYik7CisJCWJmYV90c2tpbV9xY29tcCh0c2tpbSwgX19iZmFfY2JfdHNraW1fZG9uZSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfVFNLSU1fU01fQ0xFQU5VUDoKKwkJLyoqCisJCSAqIElnbm9yZSwgVE0gY29tbWFuZCBjb21wbGV0ZWQgb24gd2lyZS4KKwkJICogTm90aWZ5IFRNIGNvbm1wbGV0aW9uIG9uIElPIGNsZWFudXAgY29tcGxldGlvbi4KKwkJICovCisJCWJyZWFrOworCisJY2FzZSBCRkFfVFNLSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKHRza2ltLCBiZmFfdHNraW1fc21faGNiKTsKKwkJYmZhX3Rza2ltX2lvY2Rpc2FibGVfaW9zKHRza2ltKTsKKwkJYmZhX3Rza2ltX3Fjb21wKHRza2ltLCBfX2JmYV9jYl90c2tpbV9mYWlsZWQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqICAgICAgVGFzayBtYW5hZ2VtZW50IGNvbW1hbmQgaXMgd2FpdGluZyBmb3Igcm9vbSBpbiByZXF1ZXN0IENRCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfdHNraW1fc21fcWZ1bGwoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwgZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyh0c2tpbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfVFNLSU1fU01fUVJFU1VNRToKKwkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2FjdGl2ZSk7CisJCWJmYV90c2tpbV9zZW5kKHRza2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9UU0tJTV9TTV9DTEVBTlVQOgorCQkvKioKKwkJICogTm8gbmVlZCB0byBzZW5kIFRNIG9uIHdpcmUgc2luY2UgSVROIGlzIG9mZmxpbmUuCisJCSAqLworCQliZmFfc21fc2V0X3N0YXRlKHRza2ltLCBiZmFfdHNraW1fc21faW9jbGVhbnVwKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmdHNraW0tPnJlcXFfd2FpdCk7CisJCWJmYV90c2tpbV9jbGVhbnVwX2lvcyh0c2tpbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfVFNLSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKHRza2ltLCBiZmFfdHNraW1fc21faGNiKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmdHNraW0tPnJlcXFfd2FpdCk7CisJCWJmYV90c2tpbV9pb2NkaXNhYmxlX2lvcyh0c2tpbSk7CisJCWJmYV90c2tpbV9xY29tcCh0c2tpbSwgX19iZmFfY2JfdHNraW1fZmFpbGVkKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAgICAgIFRhc2sgbWFuYWdlbWVudCBjb21tYW5kIGlzIGFjdGl2ZSwgYXdhaXRpbmcgZm9yIHJvb20gaW4gcmVxdWVzdCBDUQorICoJdG8gc2VuZCBjbGVhbiB1cCByZXF1ZXN0LgorICovCitzdGF0aWMgdm9pZAorYmZhX3Rza2ltX3NtX2NsZWFudXBfcWZ1bGwoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwKKwkJZW51bSBiZmFfdHNraW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyh0c2tpbS0+YmZhLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfVFNLSU1fU01fRE9ORToKKwkJYmZhX3JlcXFfd2NhbmNlbCgmdHNraW0tPnJlcXFfd2FpdCk7CisJCS8qKgorCQkgKgorCQkgKiBGYWxsIHRocm91Z2ggISEhCisJCSAqLworCisJY2FzZSBCRkFfVFNLSU1fU01fUVJFU1VNRToKKwkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX2NsZWFudXApOworCQliZmFfdHNraW1fc2VuZF9hYm9ydCh0c2tpbSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfVFNLSU1fU01fSFdGQUlMOgorCQliZmFfc21fc2V0X3N0YXRlKHRza2ltLCBiZmFfdHNraW1fc21faGNiKTsKKwkJYmZhX3JlcXFfd2NhbmNlbCgmdHNraW0tPnJlcXFfd2FpdCk7CisJCWJmYV90c2tpbV9pb2NkaXNhYmxlX2lvcyh0c2tpbSk7CisJCWJmYV90c2tpbV9xY29tcCh0c2tpbSwgX19iZmFfY2JfdHNraW1fZmFpbGVkKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAgICAgIEJGQSBjYWxsYmFjayBpcyBwZW5kaW5nCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfdHNraW1fc21faGNiKHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0sIGVudW0gYmZhX3Rza2ltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmModHNraW0tPmJmYSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX1RTS0lNX1NNX0hDQjoKKwkJYmZhX3NtX3NldF9zdGF0ZSh0c2tpbSwgYmZhX3Rza2ltX3NtX3VuaW5pdCk7CisJCWJmYV90c2tpbV9mcmVlKHRza2ltKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9UU0tJTV9TTV9DTEVBTlVQOgorCQliZmFfdHNraW1fbm90aWZ5X2NvbXAodHNraW0pOworCQlicmVhazsKKworCWNhc2UgQkZBX1RTS0lNX1NNX0hXRkFJTDoKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworCisKKy8qKgorICogIGJmYV90c2tpbV9wcml2YXRlCisgKi8KKworc3RhdGljIHZvaWQKK19fYmZhX2NiX3Rza2ltX2RvbmUodm9pZCAqY2JhcmcsIGJmYV9ib29sZWFuX3QgY29tcGxldGUpCit7CisJc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSA9IGNiYXJnOworCisJaWYgKCFjb21wbGV0ZSkgeworCQliZmFfc21fc2VuZF9ldmVudCh0c2tpbSwgQkZBX1RTS0lNX1NNX0hDQik7CisJCXJldHVybjsKKwl9CisKKwliZmFfc3RhdHModHNraW0tPml0bmltLCB0bV9zdWNjZXNzKTsKKwliZmFfY2JfdHNraW1fZG9uZSh0c2tpbS0+YmZhLT5iZmFkLCB0c2tpbS0+ZHRzaywgdHNraW0tPnRza19zdGF0dXMpOworfQorCitzdGF0aWMgdm9pZAorX19iZmFfY2JfdHNraW1fZmFpbGVkKHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0gPSBjYmFyZzsKKworCWlmICghY29tcGxldGUpIHsKKwkJYmZhX3NtX3NlbmRfZXZlbnQodHNraW0sIEJGQV9UU0tJTV9TTV9IQ0IpOworCQlyZXR1cm47CisJfQorCisJYmZhX3N0YXRzKHRza2ltLT5pdG5pbSwgdG1fZmFpbHVyZXMpOworCWJmYV9jYl90c2tpbV9kb25lKHRza2ltLT5iZmEtPmJmYWQsIHRza2ltLT5kdHNrLAorCQkJICAgQkZJX1RTS0lNX1NUU19GQUlMRUQpOworfQorCitzdGF0aWMgICAgICAgICAgYmZhX2Jvb2xlYW5fdAorYmZhX3Rza2ltX21hdGNoX3Njb3BlKHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0sIGx1bl90IGx1bikKK3sKKwlzd2l0Y2ggKHRza2ltLT50bV9jbW5kKSB7CisJY2FzZSBGQ1BfVE1fVEFSR0VUX1JFU0VUOgorCQlyZXR1cm4gQkZBX1RSVUU7CisKKwljYXNlIEZDUF9UTV9BQk9SVF9UQVNLX1NFVDoKKwljYXNlIEZDUF9UTV9DTEVBUl9UQVNLX1NFVDoKKwljYXNlIEZDUF9UTV9MVU5fUkVTRVQ6CisJY2FzZSBGQ1BfVE1fQ0xFQVJfQUNBOgorCQlyZXR1cm4gKHRza2ltLT5sdW4gPT0gbHVuKTsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorCisJcmV0dXJuIEJGQV9GQUxTRTsKK30KKworLyoqCisgKiAgICAgIEdhdGhlciBhZmZlY3RlZCBJTyByZXF1ZXN0cyBhbmQgdGFzayBtYW5hZ2VtZW50IGNvbW1hbmRzLgorICovCitzdGF0aWMgdm9pZAorYmZhX3Rza2ltX2dhdGhlcl9pb3Moc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSkKK3sKKwlzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltID0gdHNraW0tPml0bmltOworCXN0cnVjdCBiZmFfaW9pbV9zICppb2ltOworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICpxZSwgKnFlbjsKKworCUlOSVRfTElTVF9IRUFEKCZ0c2tpbS0+aW9fcSk7CisKKwkvKioKKwkgKiBHYXRoZXIgYW55IGFjdGl2ZSBJTyByZXF1ZXN0cyBmaXJzdC4KKwkgKi8KKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJml0bmltLT5pb19xKSB7CisJCWlvaW0gPSAoc3RydWN0IGJmYV9pb2ltX3MgKikgcWU7CisJCWlmIChiZmFfdHNraW1fbWF0Y2hfc2NvcGUKKwkJICAgICh0c2tpbSwgYmZhX2NiX2lvaW1fZ2V0X2x1bihpb2ltLT5kaW8pKSkgeworCQkJbGlzdF9kZWwoJmlvaW0tPnFlKTsKKwkJCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLCAmdHNraW0tPmlvX3EpOworCQl9CisJfQorCisJLyoqCisJICogRmFpbGJhY2sgYW55IHBlbmRpbmcgSU8gcmVxdWVzdHMgaW1tZWRpYXRlbHkuCisJICovCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZpdG5pbS0+cGVuZGluZ19xKSB7CisJCWlvaW0gPSAoc3RydWN0IGJmYV9pb2ltX3MgKikgcWU7CisJCWlmIChiZmFfdHNraW1fbWF0Y2hfc2NvcGUKKwkJICAgICh0c2tpbSwgYmZhX2NiX2lvaW1fZ2V0X2x1bihpb2ltLT5kaW8pKSkgeworCQkJbGlzdF9kZWwoJmlvaW0tPnFlKTsKKwkJCWxpc3RfYWRkX3RhaWwoJmlvaW0tPnFlLCAmaW9pbS0+ZmNwaW0tPmlvaW1fY29tcF9xKTsKKwkJCWJmYV9pb2ltX3Rvdihpb2ltKTsKKwkJfQorCX0KK30KKworLyoqCisgKiAJCUlPIGNsZWFudXAgY29tcGxldGlvbgorICovCitzdGF0aWMgdm9pZAorYmZhX3Rza2ltX2NsZWFucF9jb21wKHZvaWQgKnRza2ltX2NiYXJnKQoreworCXN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0gPSB0c2tpbV9jYmFyZzsKKworCWJmYV9zdGF0cyh0c2tpbS0+aXRuaW0sIHRtX2lvX2NvbXBzKTsKKwliZmFfc21fc2VuZF9ldmVudCh0c2tpbSwgQkZBX1RTS0lNX1NNX0lPU19ET05FKTsKK30KKworLyoqCisgKiAgICAgIEdhdGhlciBhZmZlY3RlZCBJTyByZXF1ZXN0cyBhbmQgdGFzayBtYW5hZ2VtZW50IGNvbW1hbmRzLgorICovCitzdGF0aWMgdm9pZAorYmZhX3Rza2ltX2NsZWFudXBfaW9zKHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0pCit7CisJc3RydWN0IGJmYV9pb2ltX3MgKmlvaW07CisJc3RydWN0IGxpc3RfaGVhZCAgICAgICAgKnFlLCAqcWVuOworCisJYmZhX3djX2luaXQoJnRza2ltLT53YywgYmZhX3Rza2ltX2NsZWFucF9jb21wLCB0c2tpbSk7CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlbiwgJnRza2ltLT5pb19xKSB7CisJCWlvaW0gPSAoc3RydWN0IGJmYV9pb2ltX3MgKikgcWU7CisJCWJmYV93Y191cCgmdHNraW0tPndjKTsKKwkJYmZhX2lvaW1fY2xlYW51cF90bShpb2ltLCB0c2tpbSk7CisJfQorCisJYmZhX3djX3dhaXQoJnRza2ltLT53Yyk7Cit9CisKKy8qKgorICogICAgICBTZW5kIHRhc2sgbWFuYWdlbWVudCByZXF1ZXN0IHRvIGZpcm13YXJlLgorICovCitzdGF0aWMgYmZhX2Jvb2xlYW5fdAorYmZhX3Rza2ltX3NlbmQoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSkKK3sKKwlzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltID0gdHNraW0tPml0bmltOworCXN0cnVjdCBiZmlfdHNraW1fcmVxX3MgKm07CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQodHNraW0tPmJmYSwgaXRuaW0tPnJlcXEpOworCWlmICghbSkKKwkJcmV0dXJuIEJGQV9GQUxTRTsKKworCS8qKgorCSAqIGJ1aWxkIGkvbyByZXF1ZXN0IG1lc3NhZ2UgbmV4dAorCSAqLworCWJmaV9oMmlfc2V0KG0tPm1oLCBCRklfTUNfVFNLSU0sIEJGSV9UU0tJTV9IMklfVE1fUkVRLAorCQkJYmZhX2xwdWlkKHRza2ltLT5iZmEpKTsKKworCW0tPnRza190YWcgPSBiZmFfb3NfaHRvbnModHNraW0tPnRza190YWcpOworCW0tPml0bl9maGRsID0gdHNraW0tPml0bmltLT5ycG9ydC0+ZndfaGFuZGxlOworCW0tPnRfc2VjcyA9IHRza2ltLT50c2VjczsKKwltLT5sdW4gPSB0c2tpbS0+bHVuOworCW0tPnRtX2ZsYWdzID0gdHNraW0tPnRtX2NtbmQ7CisKKwkvKioKKwkgKiBxdWV1ZSBJL08gbWVzc2FnZSB0byBmaXJtd2FyZQorCSAqLworCWJmYV9yZXFxX3Byb2R1Y2UodHNraW0tPmJmYSwgaXRuaW0tPnJlcXEpOworCXJldHVybiBCRkFfVFJVRTsKK30KKworLyoqCisgKiAgICAgIFNlbmQgYWJvcnQgcmVxdWVzdCB0byBjbGVhbnVwIGFuIGFjdGl2ZSBUTSB0byBmaXJtd2FyZS4KKyAqLworc3RhdGljIGJmYV9ib29sZWFuX3QKK2JmYV90c2tpbV9zZW5kX2Fib3J0KHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0pCit7CisJc3RydWN0IGJmYV9pdG5pbV9zICAgICAgICAgICAgICppdG5pbSA9IHRza2ltLT5pdG5pbTsKKwlzdHJ1Y3QgYmZpX3Rza2ltX2Fib3J0cmVxX3MgICAgKm07CisKKwkvKioKKwkgKiBjaGVjayBmb3Igcm9vbSBpbiBxdWV1ZSB0byBzZW5kIHJlcXVlc3Qgbm93CisJICovCisJbSA9IGJmYV9yZXFxX25leHQodHNraW0tPmJmYSwgaXRuaW0tPnJlcXEpOworCWlmICghbSkKKwkJcmV0dXJuIEJGQV9GQUxTRTsKKworCS8qKgorCSAqIGJ1aWxkIGkvbyByZXF1ZXN0IG1lc3NhZ2UgbmV4dAorCSAqLworCWJmaV9oMmlfc2V0KG0tPm1oLCBCRklfTUNfVFNLSU0sIEJGSV9UU0tJTV9IMklfQUJPUlRfUkVRLAorCQkJYmZhX2xwdWlkKHRza2ltLT5iZmEpKTsKKworCW0tPnRza190YWcgID0gYmZhX29zX2h0b25zKHRza2ltLT50c2tfdGFnKTsKKworCS8qKgorCSAqIHF1ZXVlIEkvTyBtZXNzYWdlIHRvIGZpcm13YXJlCisJICovCisJYmZhX3JlcXFfcHJvZHVjZSh0c2tpbS0+YmZhLCBpdG5pbS0+cmVxcSk7CisJcmV0dXJuIEJGQV9UUlVFOworfQorCisvKioKKyAqICAgICAgQ2FsbCB0byByZXN1bWUgdGFzayBtYW5hZ2VtZW50IGNtbmQgd2FpdGluZyBmb3Igcm9vbSBpbiByZXF1ZXN0IHF1ZXVlLgorICovCitzdGF0aWMgdm9pZAorYmZhX3Rza2ltX3FyZXN1bWUodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSA9IGNiYXJnOworCisJYmZhX2ZjcGltX3N0YXRzKHRza2ltLT5mY3BpbSwgcXJlc3VtZXMpOworCWJmYV9zdGF0cyh0c2tpbS0+aXRuaW0sIHRtX3FyZXN1bWVzKTsKKwliZmFfc21fc2VuZF9ldmVudCh0c2tpbSwgQkZBX1RTS0lNX1NNX1FSRVNVTUUpOworfQorCisvKioKKyAqIENsZWFudXAgSU9zIGFzc29jaWF0ZWQgd2l0aCBhIHRhc2sgbWFuZ2VtZW50IGNvbW1hbmQgb24gSU9DIGZhaWx1cmVzLgorICovCitzdGF0aWMgdm9pZAorYmZhX3Rza2ltX2lvY2Rpc2FibGVfaW9zKHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0pCit7CisJc3RydWN0IGJmYV9pb2ltX3MgKmlvaW07CisJc3RydWN0IGxpc3RfaGVhZCAgICAgICAgKnFlLCAqcWVuOworCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZ0c2tpbS0+aW9fcSkgeworCQlpb2ltID0gKHN0cnVjdCBiZmFfaW9pbV9zICopIHFlOworCQliZmFfaW9pbV9pb2NkaXNhYmxlKGlvaW0pOworCX0KK30KKworCisKKy8qKgorICogIGJmYV90c2tpbV9mcmllbmQKKyAqLworCisvKioKKyAqIE5vdGlmaWNhdGlvbiBvbiBjb21wbGV0aW9ucyBmcm9tIHJlbGF0ZWQgaW9pbS4KKyAqLwordm9pZAorYmZhX3Rza2ltX2lvZG9uZShzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltKQoreworCWJmYV93Y19kb3duKCZ0c2tpbS0+d2MpOworfQorCisvKioKKyAqIEhhbmRsZSBJT0MgaC93IGZhaWx1cmUgbm90aWZpY2F0aW9uIGZyb20gaXRuaW0uCisgKi8KK3ZvaWQKK2JmYV90c2tpbV9pb2NkaXNhYmxlKHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0pCit7CisJdHNraW0tPm5vdGlmeSA9IEJGQV9GQUxTRTsKKwliZmFfc3RhdHModHNraW0tPml0bmltLCB0bV9pb2Nkb3ducyk7CisJYmZhX3NtX3NlbmRfZXZlbnQodHNraW0sIEJGQV9UU0tJTV9TTV9IV0ZBSUwpOworfQorCisvKioKKyAqIENsZWFudXAgVE0gY29tbWFuZCBhbmQgYXNzb2NpYXRlZCBJT3MgYXMgcGFydCBvZiBJVE5JTSBvZmZsaW5lLgorICovCit2b2lkCitiZmFfdHNraW1fY2xlYW51cChzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltKQoreworCXRza2ltLT5ub3RpZnkgPSBCRkFfVFJVRTsKKwliZmFfc3RhdHModHNraW0tPml0bmltLCB0bV9jbGVhbnVwcyk7CisJYmZhX3NtX3NlbmRfZXZlbnQodHNraW0sIEJGQV9UU0tJTV9TTV9DTEVBTlVQKTsKK30KKworLyoqCisgKiAgICAgIE1lbW9yeSBhbGxvY2F0aW9uIGFuZCBpbml0aWFsaXphdGlvbi4KKyAqLwordm9pZAorYmZhX3Rza2ltX2F0dGFjaChzdHJ1Y3QgYmZhX2ZjcGltX21vZF9zICpmY3BpbSwgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1pbmZvKQoreworCXN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW07CisJdTE2ICAgICAgICBpOworCisJSU5JVF9MSVNUX0hFQUQoJmZjcGltLT50c2tpbV9mcmVlX3EpOworCisJdHNraW0gPSAoc3RydWN0IGJmYV90c2tpbV9zICopIGJmYV9tZW1pbmZvX2t2YShtaW5mbyk7CisJZmNwaW0tPnRza2ltX2FyciA9IHRza2ltOworCisJZm9yIChpID0gMDsgaSA8IGZjcGltLT5udW1fdHNraW1fcmVxczsgaSsrLCB0c2tpbSsrKSB7CisJCS8qCisJCSAqIGluaXRpYWxpemUgVFNLSU0KKwkJICovCisJCWJmYV9vc19tZW1zZXQodHNraW0sIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3Rza2ltX3MpKTsKKwkJdHNraW0tPnRza190YWcgPSBpOworCQl0c2tpbS0+YmZhICAgICA9IGZjcGltLT5iZmE7CisJCXRza2ltLT5mY3BpbSAgID0gZmNwaW07CisJCXRza2ltLT5ub3RpZnkgID0gQkZBX0ZBTFNFOworCQliZmFfcmVxcV93aW5pdCgmdHNraW0tPnJlcXFfd2FpdCwgYmZhX3Rza2ltX3FyZXN1bWUsCisJCQkJICAgdHNraW0pOworCQliZmFfc21fc2V0X3N0YXRlKHRza2ltLCBiZmFfdHNraW1fc21fdW5pbml0KTsKKworCQlsaXN0X2FkZF90YWlsKCZ0c2tpbS0+cWUsICZmY3BpbS0+dHNraW1fZnJlZV9xKTsKKwl9CisKKwliZmFfbWVtaW5mb19rdmEobWluZm8pID0gKHU4ICopIHRza2ltOworfQorCit2b2lkCitiZmFfdHNraW1fZGV0YWNoKHN0cnVjdCBiZmFfZmNwaW1fbW9kX3MgKmZjcGltKQoreworICAgIC8qKgorICAgICAqIEB0b2RvCisgICAgICovCit9CisKK3ZvaWQKK2JmYV90c2tpbV9pc3Ioc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm0pCit7CisJc3RydWN0IGJmYV9mY3BpbV9tb2RfcyAqZmNwaW0gPSBCRkFfRkNQSU1fTU9EKGJmYSk7CisJc3RydWN0IGJmaV90c2tpbV9yc3BfcyAqcnNwID0gKHN0cnVjdCBiZmlfdHNraW1fcnNwX3MgKikgbTsKKwlzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltOworCXUxNiAgICAgICAgdHNrX3RhZyA9IGJmYV9vc19udG9ocyhyc3AtPnRza190YWcpOworCisJdHNraW0gPSBCRkFfVFNLSU1fRlJPTV9UQUcoZmNwaW0sIHRza190YWcpOworCWJmYV9hc3NlcnQodHNraW0tPnRza190YWcgPT0gdHNrX3RhZyk7CisKKwl0c2tpbS0+dHNrX3N0YXR1cyA9IHJzcC0+dHNrX3N0YXR1czsKKworCS8qKgorCSAqIEZpcm13YXJlIHNlbmRzIEJGSV9UU0tJTV9TVFNfQUJPUlRFRCBzdGF0dXMgZm9yIGFib3J0CisJICogcmVxdWVzdHMuIEFsbCBvdGhlciBzdGF0dXNlcyBhcmUgZm9yIG5vcm1hbCBjb21wbGV0aW9ucy4KKwkgKi8KKwlpZiAocnNwLT50c2tfc3RhdHVzID09IEJGSV9UU0tJTV9TVFNfQUJPUlRFRCkgeworCQliZmFfc3RhdHModHNraW0tPml0bmltLCB0bV9jbGVhbnVwX2NvbXBzKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQodHNraW0sIEJGQV9UU0tJTV9TTV9DTEVBTlVQX0RPTkUpOworCX0gZWxzZSB7CisJCWJmYV9zdGF0cyh0c2tpbS0+aXRuaW0sIHRtX2Z3X3JzcHMpOworCQliZmFfc21fc2VuZF9ldmVudCh0c2tpbSwgQkZBX1RTS0lNX1NNX0RPTkUpOworCX0KK30KKworCisKKy8qKgorICogIGJmYV90c2tpbV9hcGkKKyAqLworCisKK3N0cnVjdCBiZmFfdHNraW1fcyAqCitiZmFfdHNraW1fYWxsb2Moc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFkX3Rza2ltX3MgKmR0c2spCit7CisJc3RydWN0IGJmYV9mY3BpbV9tb2RfcyAqZmNwaW0gPSBCRkFfRkNQSU1fTU9EKGJmYSk7CisJc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbTsKKworCWJmYV9xX2RlcSgmZmNwaW0tPnRza2ltX2ZyZWVfcSwgJnRza2ltKTsKKworCWlmICghdHNraW0pCisJCWJmYV9mY3BpbV9zdGF0cyhmY3BpbSwgbm9fdHNraW1zKTsKKwllbHNlCisJCXRza2ltLT5kdHNrID0gZHRzazsKKworCXJldHVybiB0c2tpbTsKK30KKwordm9pZAorYmZhX3Rza2ltX2ZyZWUoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSkKK3sKKwliZmFfYXNzZXJ0KGJmYV9xX2lzX29uX3FfZnVuYygmdHNraW0tPml0bmltLT50c2tfcSwgJnRza2ltLT5xZSkpOworCWxpc3RfZGVsKCZ0c2tpbS0+cWUpOworCWxpc3RfYWRkX3RhaWwoJnRza2ltLT5xZSwgJnRza2ltLT5mY3BpbS0+dHNraW1fZnJlZV9xKTsKK30KKworLyoqCisgKiAgICAgIFN0YXJ0IGEgdGFzayBtYW5hZ2VtZW50IGNvbW1hbmQuCisgKgorICogQHBhcmFtW2luXSAgICAgICB0c2tpbSAgICAgICBCRkEgdGFzayBtYW5hZ2VtZW50IGNvbW1hbmQgaW5zdGFuY2UKKyAqIEBwYXJhbVtpbl0gICAgICAgaXRuaW0gICAgICAgaS10IG5leHVzIGZvciB0aGUgdGFzayBtYW5hZ2VtZW50IGNvbW1hbmQKKyAqIEBwYXJhbVtpbl0gICAgICAgbHVuICAgICAgICAgbHVuLCBpZiBhcHBsaWNhYmxlCisgKiBAcGFyYW1baW5dICAgICAgIHRtX2NtbmQgICAgIFRhc2sgbWFuYWdlbWVudCBjb21tYW5kIGNvZGUuCisgKiBAcGFyYW1baW5dICAgICAgIHRfc2VjcyAgICAgIFRpbWVvdXQgaW4gc2Vjb25kcworICoKKyAqIEByZXR1cm4gTm9uZS4KKyAqLwordm9pZAorYmZhX3Rza2ltX3N0YXJ0KHN0cnVjdCBiZmFfdHNraW1fcyAqdHNraW0sIHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sIGx1bl90IGx1biwKKwkJICAgIGVudW0gZmNwX3RtX2NtbmQgdG1fY21uZCwgdTggdHNlY3MpCit7CisJdHNraW0tPml0bmltICAgPSBpdG5pbTsKKwl0c2tpbS0+bHVuICAgICA9IGx1bjsKKwl0c2tpbS0+dG1fY21uZCA9IHRtX2NtbmQ7CisJdHNraW0tPnRzZWNzICAgPSB0c2VjczsKKwl0c2tpbS0+bm90aWZ5ICA9IEJGQV9GQUxTRTsKKwliZmFfc3RhdHMoaXRuaW0sIHRtX2NtbmRzKTsKKworCWxpc3RfYWRkX3RhaWwoJnRza2ltLT5xZSwgJml0bmltLT50c2tfcSk7CisJYmZhX3NtX3NlbmRfZXZlbnQodHNraW0sIEJGQV9UU0tJTV9TTV9TVEFSVCk7Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFfdWYuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3VmLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmY1ZjlkZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3VmLmMKQEAgLTAsMCArMSwzNDUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX3VmLmMgQkZBIHVuc29saWNpdGVkIGZyYW1lIHJlY2VpdmUgaW1wbGVtZW50YXRpb24KKyAqLworCisjaW5jbHVkZSA8YmZhLmg+CisjaW5jbHVkZSA8YmZhX3N2Yy5oPgorI2luY2x1ZGUgPGJmaS9iZmlfdWYuaD4KKyNpbmNsdWRlIDxjcy9iZmFfZGVidWcuaD4KKworQkZBX1RSQ19GSUxFKEhBTCwgVUYpOworQkZBX01PRFVMRSh1Zik7CisKKy8qCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqIEludGVybmFsIGZ1bmN0aW9ucworICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKi8KK3N0YXRpYyB2b2lkCitfX2JmYV9jYl91Zl9yZWN2KHZvaWQgKmNiYXJnLCBiZmFfYm9vbGVhbl90IGNvbXBsZXRlKQoreworCXN0cnVjdCBiZmFfdWZfcyAgICp1ZiA9IGNiYXJnOworCXN0cnVjdCBiZmFfdWZfbW9kX3MgKnVmbSA9IEJGQV9VRl9NT0QodWYtPmJmYSk7CisKKwlpZiAoY29tcGxldGUpCisJCXVmbS0+dWZyZWN2KHVmbS0+Y2JhcmcsIHVmKTsKK30KKworc3RhdGljIHZvaWQKK2NsYWltX3VmX3BicyhzdHJ1Y3QgYmZhX3VmX21vZF9zICp1Zm0sIHN0cnVjdCBiZmFfbWVtaW5mb19zICptaSkKK3sKKwl1MzIgICAgICAgIHVmX3BiX3RvdF9zejsKKworCXVmbS0+dWZfcGJzX2t2YSA9IChzdHJ1Y3QgYmZhX3VmX2J1Zl9zICopIGJmYV9tZW1pbmZvX2RtYV92aXJ0KG1pKTsKKwl1Zm0tPnVmX3Bic19wYSA9IGJmYV9tZW1pbmZvX2RtYV9waHlzKG1pKTsKKwl1Zl9wYl90b3Rfc3ogPSBCRkFfUk9VTkRVUCgoc2l6ZW9mKHN0cnVjdCBiZmFfdWZfYnVmX3MpICogdWZtLT5udW1fdWZzKSwKKwkJCQkJCQlCRkFfRE1BX0FMSUdOX1NaKTsKKworCWJmYV9tZW1pbmZvX2RtYV92aXJ0KG1pKSArPSB1Zl9wYl90b3Rfc3o7CisJYmZhX21lbWluZm9fZG1hX3BoeXMobWkpICs9IHVmX3BiX3RvdF9zejsKKworCWJmYV9vc19tZW1zZXQoKHZvaWQgKil1Zm0tPnVmX3Bic19rdmEsIDAsIHVmX3BiX3RvdF9zeik7Cit9CisKK3N0YXRpYyB2b2lkCitjbGFpbV91Zl9wb3N0X21zZ3Moc3RydWN0IGJmYV91Zl9tb2RfcyAqdWZtLCBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWkpCit7CisJc3RydWN0IGJmaV91Zl9idWZfcG9zdF9zICp1Zl9icF9tc2c7CisJc3RydWN0IGJmaV9zZ2VfcyAgICAgICpzZ2U7CisJdW5pb24gYmZpX2FkZHJfdSAgICAgIHNnYV96ZXJvID0geyB7MH0gfTsKKwl1MTYgICAgICAgIGk7CisJdTE2ICAgICAgICBidWZfbGVuOworCisJdWZtLT51Zl9idWZfcG9zdHMgPSAoc3RydWN0IGJmaV91Zl9idWZfcG9zdF9zICopIGJmYV9tZW1pbmZvX2t2YShtaSk7CisJdWZfYnBfbXNnID0gdWZtLT51Zl9idWZfcG9zdHM7CisKKwlmb3IgKGkgPSAwLCB1Zl9icF9tc2cgPSB1Zm0tPnVmX2J1Zl9wb3N0czsgaSA8IHVmbS0+bnVtX3VmczsKKwkgICAgIGkrKywgdWZfYnBfbXNnKyspIHsKKwkJYmZhX29zX21lbXNldCh1Zl9icF9tc2csIDAsIHNpemVvZihzdHJ1Y3QgYmZpX3VmX2J1Zl9wb3N0X3MpKTsKKworCQl1Zl9icF9tc2ctPmJ1Zl90YWcgPSBpOworCQlidWZfbGVuID0gc2l6ZW9mKHN0cnVjdCBiZmFfdWZfYnVmX3MpOworCQl1Zl9icF9tc2ctPmJ1Zl9sZW4gPSBiZmFfb3NfaHRvbnMoYnVmX2xlbik7CisJCWJmaV9oMmlfc2V0KHVmX2JwX21zZy0+bWgsIEJGSV9NQ19VRiwgQkZJX1VGX0gySV9CVUZfUE9TVCwKKwkJCSAgICBiZmFfbHB1aWQodWZtLT5iZmEpKTsKKworCQlzZ2UgPSB1Zl9icF9tc2ctPnNnZTsKKwkJc2dlWzBdLnNnX2xlbiA9IGJ1Zl9sZW47CisJCXNnZVswXS5mbGFncyA9IEJGSV9TR0VfREFUQV9MQVNUOworCQliZmFfZG1hX2FkZHJfc2V0KHNnZVswXS5zZ2EsIHVmbV9wYnNfcGEodWZtLCBpKSk7CisJCWJmYV9zZ2VfdG9fYmUoc2dlKTsKKworCQlzZ2VbMV0uc2dfbGVuID0gYnVmX2xlbjsKKwkJc2dlWzFdLmZsYWdzID0gQkZJX1NHRV9QR0RMRU47CisJCXNnZVsxXS5zZ2EgPSBzZ2FfemVybzsKKwkJYmZhX3NnZV90b19iZSgmc2dlWzFdKTsKKwl9CisKKwkvKioKKwkgKiBhZHZhbmNlIHBvaW50ZXIgYmV5b25kIGNvbnN1bWVkIG1lbW9yeQorCSAqLworCWJmYV9tZW1pbmZvX2t2YShtaSkgPSAodTggKikgdWZfYnBfbXNnOworfQorCitzdGF0aWMgdm9pZAorY2xhaW1fdWZzKHN0cnVjdCBiZmFfdWZfbW9kX3MgKnVmbSwgc3RydWN0IGJmYV9tZW1pbmZvX3MgKm1pKQoreworCXUxNiAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX3VmX3MgICAqdWY7CisKKwkvKgorCSAqIENsYWltIGJsb2NrIG9mIG1lbW9yeSBmb3IgVUYgbGlzdAorCSAqLworCXVmbS0+dWZfbGlzdCA9IChzdHJ1Y3QgYmZhX3VmX3MgKikgYmZhX21lbWluZm9fa3ZhKG1pKTsKKworCS8qCisJICogSW5pdGlhbGl6ZSBVRnMgYW5kIHF1ZXVlIGl0IGluIFVGIGZyZWUgcXVldWUKKwkgKi8KKwlmb3IgKGkgPSAwLCB1ZiA9IHVmbS0+dWZfbGlzdDsgaSA8IHVmbS0+bnVtX3VmczsgaSsrLCB1ZisrKSB7CisJCWJmYV9vc19tZW1zZXQodWYsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3VmX3MpKTsKKwkJdWYtPmJmYSA9IHVmbS0+YmZhOworCQl1Zi0+dWZfdGFnID0gaTsKKwkJdWYtPnBiX2xlbiA9IHNpemVvZihzdHJ1Y3QgYmZhX3VmX2J1Zl9zKTsKKwkJdWYtPmJ1Zl9rdmEgPSAodm9pZCAqKSZ1Zm0tPnVmX3Bic19rdmFbaV07CisJCXVmLT5idWZfcGEgPSB1Zm1fcGJzX3BhKHVmbSwgaSk7CisJCWxpc3RfYWRkX3RhaWwoJnVmLT5xZSwgJnVmbS0+dWZfZnJlZV9xKTsKKwl9CisKKwkvKioKKwkgKiBhZHZhbmNlIG1lbW9yeSBwb2ludGVyCisJICovCisJYmZhX21lbWluZm9fa3ZhKG1pKSA9ICh1OCAqKSB1ZjsKK30KKworc3RhdGljIHZvaWQKK3VmX21lbV9jbGFpbShzdHJ1Y3QgYmZhX3VmX21vZF9zICp1Zm0sIHN0cnVjdCBiZmFfbWVtaW5mb19zICptaSkKK3sKKwljbGFpbV91Zl9wYnModWZtLCBtaSk7CisJY2xhaW1fdWZzKHVmbSwgbWkpOworCWNsYWltX3VmX3Bvc3RfbXNncyh1Zm0sIG1pKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV91Zl9tZW1pbmZvKHN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmNmZywgdTMyICpuZG1fbGVuLCB1MzIgKmRtX2xlbikKK3sKKwl1MzIgICAgICAgIG51bV91ZnMgPSBjZmctPmZ3Y2ZnLm51bV91Zl9idWZzOworCisJLyoKKwkgKiBkbWEtYWJsZSBtZW1vcnkgZm9yIFVGIHBvc3RlZCBidWZzCisJICovCisJKmRtX2xlbiArPSBCRkFfUk9VTkRVUCgoc2l6ZW9mKHN0cnVjdCBiZmFfdWZfYnVmX3MpICogbnVtX3VmcyksCisJCQkJCQkJQkZBX0RNQV9BTElHTl9TWik7CisKKwkvKgorCSAqIGtlcm5lbCBWaXJ0dWFsIG1lbW9yeSBmb3IgVUZzIGFuZCBVRiBidWYgcG9zdCBtc2cgY29waWVzCisJICovCisJKm5kbV9sZW4gKz0gc2l6ZW9mKHN0cnVjdCBiZmFfdWZfcykgKiBudW1fdWZzOworCSpuZG1fbGVuICs9IHNpemVvZihzdHJ1Y3QgYmZpX3VmX2J1Zl9wb3N0X3MpICogbnVtX3VmczsKK30KKworc3RhdGljIHZvaWQKK2JmYV91Zl9hdHRhY2goc3RydWN0IGJmYV9zICpiZmEsIHZvaWQgKmJmYWQsIHN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmNmZywKKwkJICBzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbywgc3RydWN0IGJmYV9wY2lkZXZfcyAqcGNpZGV2KQoreworCXN0cnVjdCBiZmFfdWZfbW9kX3MgKnVmbSA9IEJGQV9VRl9NT0QoYmZhKTsKKworCWJmYV9vc19tZW1zZXQodWZtLCAwLCBzaXplb2Yoc3RydWN0IGJmYV91Zl9tb2RfcykpOworCXVmbS0+YmZhID0gYmZhOworCXVmbS0+bnVtX3VmcyA9IGNmZy0+ZndjZmcubnVtX3VmX2J1ZnM7CisJSU5JVF9MSVNUX0hFQUQoJnVmbS0+dWZfZnJlZV9xKTsKKwlJTklUX0xJU1RfSEVBRCgmdWZtLT51Zl9wb3N0ZWRfcSk7CisKKwl1Zl9tZW1fY2xhaW0odWZtLCBtZW1pbmZvKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV91Zl9pbml0ZG9uZShzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworc3RhdGljIHZvaWQKK2JmYV91Zl9kZXRhY2goc3RydWN0IGJmYV9zICpiZmEpCit7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgYmZhX3VmX3MgKgorYmZhX3VmX2dldChzdHJ1Y3QgYmZhX3VmX21vZF9zICp1Zl9tb2QpCit7CisJc3RydWN0IGJmYV91Zl9zICAgKnVmOworCisJYmZhX3FfZGVxKCZ1Zl9tb2QtPnVmX2ZyZWVfcSwgJnVmKTsKKwlyZXR1cm4gKHVmKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV91Zl9wdXQoc3RydWN0IGJmYV91Zl9tb2RfcyAqdWZfbW9kLCBzdHJ1Y3QgYmZhX3VmX3MgKnVmKQoreworCWxpc3RfYWRkX3RhaWwoJnVmLT5xZSwgJnVmX21vZC0+dWZfZnJlZV9xKTsKK30KKworc3RhdGljIGJmYV9zdGF0dXNfdAorYmZhX3VmX3Bvc3Qoc3RydWN0IGJmYV91Zl9tb2RfcyAqdWZtLCBzdHJ1Y3QgYmZhX3VmX3MgKnVmKQoreworCXN0cnVjdCBiZmlfdWZfYnVmX3Bvc3RfcyAqdWZfcG9zdF9tc2c7CisKKwl1Zl9wb3N0X21zZyA9IGJmYV9yZXFxX25leHQodWZtLT5iZmEsIEJGQV9SRVFRX0ZDWFApOworCWlmICghdWZfcG9zdF9tc2cpCisJCXJldHVybiBCRkFfU1RBVFVTX0ZBSUxFRDsKKworCWJmYV9vc19tZW1jcHkodWZfcG9zdF9tc2csICZ1Zm0tPnVmX2J1Zl9wb3N0c1t1Zi0+dWZfdGFnXSwKKwkJICAgICAgc2l6ZW9mKHN0cnVjdCBiZmlfdWZfYnVmX3Bvc3RfcykpOworCWJmYV9yZXFxX3Byb2R1Y2UodWZtLT5iZmEsIEJGQV9SRVFRX0ZDWFApOworCisJYmZhX3RyYyh1Zm0tPmJmYSwgdWYtPnVmX3RhZyk7CisKKwlsaXN0X2FkZF90YWlsKCZ1Zi0+cWUsICZ1Zm0tPnVmX3Bvc3RlZF9xKTsKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworc3RhdGljIHZvaWQKK2JmYV91Zl9wb3N0X2FsbChzdHJ1Y3QgYmZhX3VmX21vZF9zICp1Zl9tb2QpCit7CisJc3RydWN0IGJmYV91Zl9zICAgKnVmOworCisJd2hpbGUgKCh1ZiA9IGJmYV91Zl9nZXQodWZfbW9kKSkgIT0gTlVMTCkgeworCQlpZiAoYmZhX3VmX3Bvc3QodWZfbW9kLCB1ZikgIT0gQkZBX1NUQVRVU19PSykKKwkJCWJyZWFrOworCX0KK30KKworc3RhdGljIHZvaWQKK3VmX3JlY3Yoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfdWZfZnJtX3JjdmRfcyAqbSkKK3sKKwlzdHJ1Y3QgYmZhX3VmX21vZF9zICp1Zm0gPSBCRkFfVUZfTU9EKGJmYSk7CisJdTE2ICAgICAgICB1Zl90YWcgPSBtLT5idWZfdGFnOworCXN0cnVjdCBiZmFfdWZfYnVmX3MgKnVmX2J1ZiA9ICZ1Zm0tPnVmX3Bic19rdmFbdWZfdGFnXTsKKwlzdHJ1Y3QgYmZhX3VmX3MgICAqdWYgPSAmdWZtLT51Zl9saXN0W3VmX3RhZ107CisJdTggICAgICAgICpidWYgPSAmdWZfYnVmLT5kWzBdOworCXN0cnVjdCBmY2hzX3MgICAgICAgICAqZmNoczsKKworCW0tPmZybV9sZW4gPSBiZmFfb3NfbnRvaHMobS0+ZnJtX2xlbik7CisJbS0+eGZyX2xlbiA9IGJmYV9vc19udG9ocyhtLT54ZnJfbGVuKTsKKworCWZjaHMgPSAoc3RydWN0IGZjaHNfcyAqKSB1Zl9idWY7CisKKwlsaXN0X2RlbCgmdWYtPnFlKTsJLyogZGVxdWV1ZSBmcm9tIHBvc3RlZCBxdWV1ZSAqLworCisJdWYtPmRhdGFfcHRyID0gYnVmOworCXVmLT5kYXRhX2xlbiA9IG0tPnhmcl9sZW47CisKKwliZmFfYXNzZXJ0KHVmLT5kYXRhX2xlbiA+PSBzaXplb2Yoc3RydWN0IGZjaHNfcykpOworCisJaWYgKHVmLT5kYXRhX2xlbiA9PSBzaXplb2Yoc3RydWN0IGZjaHNfcykpIHsKKwkJYmZhX3Bsb2dfZmNoZHIoYmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTF9VRiwgQkZBX1BMX0VJRF9SWCwKKwkJCSAgICAgICB1Zi0+ZGF0YV9sZW4sIChzdHJ1Y3QgZmNoc19zICopIGJ1Zik7CisJfSBlbHNlIHsKKwkJdTMyICAgICAgICBwbGRfdzAgPSAqKCh1MzIgKikgKGJ1ZiArIHNpemVvZihzdHJ1Y3QgZmNoc19zKSkpOworCQliZmFfcGxvZ19mY2hkcl9hbmRfcGwoYmZhLT5wbG9nLCBCRkFfUExfTUlEX0hBTF9VRiwKKwkJCQkgICAgICBCRkFfUExfRUlEX1JYLCB1Zi0+ZGF0YV9sZW4sCisJCQkJICAgICAgKHN0cnVjdCBmY2hzX3MgKikgYnVmLCBwbGRfdzApOworCX0KKworCWJmYV9jYl9xdWV1ZShiZmEsICZ1Zi0+aGNiX3FlLCBfX2JmYV9jYl91Zl9yZWN2LCB1Zik7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfdWZfc3RvcChzdHJ1Y3QgYmZhX3MgKmJmYSkKK3sKK30KKworc3RhdGljIHZvaWQKK2JmYV91Zl9pb2NkaXNhYmxlKHN0cnVjdCBiZmFfcyAqYmZhKQoreworCXN0cnVjdCBiZmFfdWZfbW9kX3MgKnVmbSA9IEJGQV9VRl9NT0QoYmZhKTsKKwlzdHJ1Y3QgYmZhX3VmX3MgICAqdWY7CisJc3RydWN0IGxpc3RfaGVhZCAgICAgICAgKnFlLCAqcWVuOworCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZ1Zm0tPnVmX3Bvc3RlZF9xKSB7CisJCXVmID0gKHN0cnVjdCBiZmFfdWZfcyAqKSBxZTsKKwkJbGlzdF9kZWwoJnVmLT5xZSk7CisJCWJmYV91Zl9wdXQodWZtLCB1Zik7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX3VmX3N0YXJ0KHN0cnVjdCBiZmFfcyAqYmZhKQoreworCWJmYV91Zl9wb3N0X2FsbChCRkFfVUZfTU9EKGJmYSkpOworfQorCisKKworLyoqCisgKiAgYmZhX3VmX2FwaQorICovCisKKy8qKgorICogCQlSZWdpc3RlciBoYW5kbGVyIGZvciBhbGwgdW5zb2xpY3RlZCByZWNpZXZlIGZyYW1lcy4KKyAqCisgKiBAcGFyYW1baW5dCWJmYQkJQkZBIGluc3RhbmNlCisgKiBAcGFyYW1baW5dCXVmcmVjdglyZWNlaXZlIGhhbmRsZXIgZnVuY3Rpb24KKyAqIEBwYXJhbVtpbl0JY2JhcmcJcmVjZWl2ZSBoYW5kbGVyIGFyZworICovCit2b2lkCitiZmFfdWZfcmVjdl9yZWdpc3RlcihzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2NiX3VmX3JlY3ZfdCB1ZnJlY3YsIHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfdWZfbW9kX3MgKnVmbSA9IEJGQV9VRl9NT0QoYmZhKTsKKworCXVmbS0+dWZyZWN2ID0gdWZyZWN2OworCXVmbS0+Y2JhcmcgPSBjYmFyZzsKK30KKworLyoqCisgKiAJCUZyZWUgYW4gdW5zb2xpY2l0ZWQgZnJhbWUgYmFjayB0byBCRkEuCisgKgorICogQHBhcmFtW2luXQkJdWYJCXVuc29saWNpdGVkIGZyYW1lIHRvIGJlIGZyZWVkCisgKgorICogQHJldHVybiBOb25lCisgKi8KK3ZvaWQKK2JmYV91Zl9mcmVlKHN0cnVjdCBiZmFfdWZfcyAqdWYpCit7CisJYmZhX3VmX3B1dChCRkFfVUZfTU9EKHVmLT5iZmEpLCB1Zik7CisJYmZhX3VmX3Bvc3RfYWxsKEJGQV9VRl9NT0QodWYtPmJmYSkpOworfQorCisKKworLyoqCisgKiAgdWZfcHViIEJGQSB1ZiBtb2R1bGUgcHVibGljIGZ1bmN0aW9ucworICovCisKK3ZvaWQKK2JmYV91Zl9pc3Ioc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm1zZykKK3sKKwliZmFfdHJjKGJmYSwgbXNnLT5taGRyLm1zZ19pZCk7CisKKwlzd2l0Y2ggKG1zZy0+bWhkci5tc2dfaWQpIHsKKwljYXNlIEJGSV9VRl9JMkhfRlJNX1JDVkQ6CisJCXVmX3JlY3YoYmZhLCAoc3RydWN0IGJmaV91Zl9mcm1fcmN2ZF9zICopIG1zZyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3RyYyhiZmEsIG1zZy0+bWhkci5tc2dfaWQpOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYV91Zl9wcml2LmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYV91Zl9wcml2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmNiNDkwZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhX3VmX3ByaXYuaApAQCAtMCwwICsxLDQ3IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX1VGX1BSSVZfSF9fCisjZGVmaW5lIF9fQkZBX1VGX1BSSVZfSF9fCisKKyNpbmNsdWRlIDxjcy9iZmFfc20uaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSA8YmZpL2JmaV91Zi5oPgorCisjZGVmaW5lIEJGQV9VRl9NSU4JKDQpCisKK3N0cnVjdCBiZmFfdWZfbW9kX3MgeworCXN0cnVjdCBiZmFfcyAqYmZhOwkJLyogIGJhY2sgcG9pbnRlciB0byBCRkEgKi8KKwlzdHJ1Y3QgYmZhX3VmX3MgKnVmX2xpc3Q7CS8qICBhcnJheSBvZiBVRnMgKi8KKwl1MTYJbnVtX3VmczsJLyogIG51bSB1bnNvbGljaXRlZCByeCBmcmFtZXMgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIAl1Zl9mcmVlX3E7CS8qICBmcmVlIFVGcyAqLworCXN0cnVjdCBsaXN0X2hlYWQgCXVmX3Bvc3RlZF9xOwkvKiAgVUZzIHBvc3RlZCB0byBJT0MgKi8KKwlzdHJ1Y3QgYmZhX3VmX2J1Zl9zICp1Zl9wYnNfa3ZhOwkvKiAgbGlzdCBVRiBidWZzIHJlcXVlc3QgcGxkICovCisJdTY0CXVmX3Bic19wYTsJLyogIHBoeSBhZGRyIGZvciBVRiBidWZzICovCisJc3RydWN0IGJmaV91Zl9idWZfcG9zdF9zICp1Zl9idWZfcG9zdHM7CisJCQkJCS8qICBwcmUtYnVpbHQgVUYgcG9zdCBtc2dzICovCisJYmZhX2NiX3VmX3JlY3ZfdCB1ZnJlY3Y7CS8qICB1ZiByZWN2IGhhbmRsZXIgZnVuY3Rpb24gKi8KKwl2b2lkCQkqY2Jhcmc7CQkvKiAgdWYgcmVjZWl2ZSBoYW5kbGVyIGFyZyAqLworfTsKKworI2RlZmluZSBCRkFfVUZfTU9EKF9fYmZhKQkoJihfX2JmYSktPm1vZHVsZXMudWZfbW9kKQorCisjZGVmaW5lIHVmbV9wYnNfcGEoX3VmbW9kLCBfdWZ0YWcpCVwKKwkoKF91Zm1vZCktPnVmX3Bic19wYSArIHNpemVvZihzdHJ1Y3QgYmZhX3VmX2J1Zl9zKSAqIChfdWZ0YWcpKQorCit2b2lkCWJmYV91Zl9pc3Ioc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmlfbXNnX3MgKm1zZyk7CisKKyNlbmRpZiAvKiBfX0JGQV9VRl9QUklWX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFkLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWQuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZjJiZTVhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkLmMKQEAgLTAsMCArMSwxMTgyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYWQuYyBMaW51eCBkcml2ZXIgUENJIGludGVyZmFjZSBtb2R1bGUuCisgKi8KKworI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgImJmYWRfZHJ2LmgiCisjaW5jbHVkZSAiYmZhZF9pbS5oIgorI2luY2x1ZGUgImJmYWRfdG0uaCIKKyNpbmNsdWRlICJiZmFkX2lwZmMuaCIKKyNpbmNsdWRlICJiZmFkX3RyY21vZC5oIgorI2luY2x1ZGUgPGZjYi9iZmFfZmNiX3ZmLmg+CisjaW5jbHVkZSA8ZmNiL2JmYV9mY2JfcnBvcnQuaD4KKyNpbmNsdWRlIDxmY2IvYmZhX2ZjYl9wb3J0Lmg+CisjaW5jbHVkZSA8ZmNiL2JmYV9mY2IuaD4KKworQkZBX1RSQ19GSUxFKExEUlYsIEJGQUQpOworc3RhdGljIERFRklORV9NVVRFWChiZmFkX211dGV4KTsKK0xJU1RfSEVBRChiZmFkX2xpc3QpOworc3RhdGljIGludCAgICAgIGJmYWRfaW5zdDsKK2ludCBiZmFkX3N1cHBvcnRlZF9mYzRzOworCitzdGF0aWMgY2hhciAgICAgKmhvc3RfbmFtZTsKK3N0YXRpYyBjaGFyICAgICAqb3NfbmFtZTsKK3N0YXRpYyBjaGFyICAgICAqb3NfcGF0Y2g7CitzdGF0aWMgaW50ICAgICAgbnVtX3Jwb3J0czsKK3N0YXRpYyBpbnQgICAgICBudW1faW9zOworc3RhdGljIGludCAgICAgIG51bV90bXM7CitzdGF0aWMgaW50ICAgICAgbnVtX2ZjeHBzOworc3RhdGljIGludCAgICAgIG51bV91ZmJ1ZnM7CitzdGF0aWMgaW50ICAgICAgcmVxcV9zaXplOworc3RhdGljIGludCAgICAgIHJzcHFfc2l6ZTsKK3N0YXRpYyBpbnQgICAgICBudW1fc2dwZ3M7CitzdGF0aWMgaW50ICAgICAgcnBvcnRfZGVsX3RpbWVvdXQgPSBCRkFfRkNTX1JQT1JUX0RFRl9ERUxfVElNRU9VVDsKK3N0YXRpYyBpbnQgICAgICBiZmFfaW9fbWF4X3NnZSA9IEJGQURfSU9fTUFYX1NHRTsKK3N0YXRpYyBpbnQgICAgICBsb2dfbGV2ZWwgPSBCRkFfTE9HX1dBUk5JTkc7CitzdGF0aWMgaW50ICAgICAgaW9jX2F1dG9fcmVjb3ZlciA9IEJGQV9UUlVFOworc3RhdGljIGludCAgICAgIGlwZmNfZW5hYmxlID0gQkZBX0ZBTFNFOworc3RhdGljIGludCAgICAgIGlwZmNfbXR1ID0gLTE7CitpbnQgCQliZmFfbHVuX3F1ZXVlX2RlcHRoID0gQkZBRF9MVU5fUVVFVUVfREVQVEg7CitpbnQgICAgICAJYmZhX2xpbmt1cF9kZWxheSA9IC0xOworCittb2R1bGVfcGFyYW0ob3NfbmFtZSwgY2hhcnAsIFNfSVJVR08gfCBTX0lXVVNSKTsKK21vZHVsZV9wYXJhbShvc19wYXRjaCwgY2hhcnAsIFNfSVJVR08gfCBTX0lXVVNSKTsKK21vZHVsZV9wYXJhbShob3N0X25hbWUsIGNoYXJwLCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0obnVtX3Jwb3J0cywgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0obnVtX2lvcywgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0obnVtX3RtcywgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0obnVtX2ZjeHBzLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK21vZHVsZV9wYXJhbShudW1fdWZidWZzLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK21vZHVsZV9wYXJhbShyZXFxX3NpemUsIGludCwgU19JUlVHTyB8IFNfSVdVU1IpOworbW9kdWxlX3BhcmFtKHJzcHFfc2l6ZSwgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0obnVtX3NncGdzLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK21vZHVsZV9wYXJhbShycG9ydF9kZWxfdGltZW91dCwgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0oYmZhX2x1bl9xdWV1ZV9kZXB0aCwgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0oYmZhX2lvX21heF9zZ2UsIGludCwgU19JUlVHTyB8IFNfSVdVU1IpOworbW9kdWxlX3BhcmFtKGxvZ19sZXZlbCwgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0oaW9jX2F1dG9fcmVjb3ZlciwgaW50LCBTX0lSVUdPIHwgU19JV1VTUik7Cittb2R1bGVfcGFyYW0oaXBmY19lbmFibGUsIGludCwgU19JUlVHTyB8IFNfSVdVU1IpOworbW9kdWxlX3BhcmFtKGlwZmNfbXR1LCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKK21vZHVsZV9wYXJhbShiZmFfbGlua3VwX2RlbGF5LCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKKworLyoKKyAqIFN0b3JlcyB0aGUgbW9kdWxlIHBhcm0gbnVtX3NncGdzIHZhbHVlOworICogdXNlZCB0byByZXNldCBmb3IgYmZhZCBuZXh0IGluc3RhbmNlLgorICovCitzdGF0aWMgaW50IG51bV9zZ3Bnc19wYXJtOworCitzdGF0aWMgYmZhX3N0YXR1c190CitiZmFkX2ZjNF9wcm9iZShzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworCWludCAgICAgICAgICAgICByYzsKKworCXJjID0gYmZhZF9pbV9wcm9iZShiZmFkKTsKKwlpZiAocmMgIT0gQkZBX1NUQVRVU19PSykKKwkJZ290byBleHQ7CisKKwliZmFkX3RtX3Byb2JlKGJmYWQpOworCisJaWYgKGlwZmNfZW5hYmxlKQorCQliZmFkX2lwZmNfcHJvYmUoYmZhZCk7CitleHQ6CisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgdm9pZAorYmZhZF9mYzRfcHJvYmVfdW5kbyhzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworCWJmYWRfaW1fcHJvYmVfdW5kbyhiZmFkKTsKKwliZmFkX3RtX3Byb2JlX3VuZG8oYmZhZCk7CisJaWYgKGlwZmNfZW5hYmxlKQorCQliZmFkX2lwZmNfcHJvYmVfdW5kbyhiZmFkKTsKK30KKworc3RhdGljIHZvaWQKK2JmYWRfZmM0X3Byb2JlX3Bvc3Qoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlpZiAoYmZhZC0+aW0pCisJCWJmYWRfaW1fcHJvYmVfcG9zdChiZmFkLT5pbSk7CisKKwliZmFkX3RtX3Byb2JlX3Bvc3QoYmZhZCk7CisJaWYgKGlwZmNfZW5hYmxlKQorCQliZmFkX2lwZmNfcHJvYmVfcG9zdChiZmFkKTsKK30KKworc3RhdGljIGJmYV9zdGF0dXNfdAorYmZhZF9mYzRfcG9ydF9uZXcoc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYWRfcG9ydF9zICpwb3J0LCBpbnQgcm9sZXMpCit7CisJaW50ICAgICAgICAgICAgIHJjID0gQkZBX1NUQVRVU19GQUlMRUQ7CisKKwlpZiAocm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9JTSkKKwkJcmMgPSBiZmFkX2ltX3BvcnRfbmV3KGJmYWQsIHBvcnQpOworCWlmIChyYyAhPSBCRkFfU1RBVFVTX09LKQorCQlnb3RvIGV4dDsKKworCWlmIChyb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX1RNKQorCQlyYyA9IGJmYWRfdG1fcG9ydF9uZXcoYmZhZCwgcG9ydCk7CisJaWYgKHJjICE9IEJGQV9TVEFUVVNfT0spCisJCWdvdG8gZXh0OworCisJaWYgKChyb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lQRkMpICYmIGlwZmNfZW5hYmxlKQorCQlyYyA9IGJmYWRfaXBmY19wb3J0X25ldyhiZmFkLCBwb3J0LCBwb3J0LT5wdmJfdHlwZSk7CitleHQ6CisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgdm9pZAorYmZhZF9mYzRfcG9ydF9kZWxldGUoc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYWRfcG9ydF9zICpwb3J0LCBpbnQgcm9sZXMpCit7CisJaWYgKHJvbGVzICYgQkZBX1BPUlRfUk9MRV9GQ1BfSU0pCisJCWJmYWRfaW1fcG9ydF9kZWxldGUoYmZhZCwgcG9ydCk7CisKKwlpZiAocm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9UTSkKKwkJYmZhZF90bV9wb3J0X2RlbGV0ZShiZmFkLCBwb3J0KTsKKworCWlmICgocm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9JUEZDKSAmJiBpcGZjX2VuYWJsZSkKKwkJYmZhZF9pcGZjX3BvcnRfZGVsZXRlKGJmYWQsIHBvcnQpOworfQorCisvKioKKyAqICBCRkEgY2FsbGJhY2tzCisgKi8KK3ZvaWQKK2JmYWRfaGNiX2NvbXAodm9pZCAqYXJnLCBiZmFfc3RhdHVzX3Qgc3RhdHVzKQoreworCXN0cnVjdCBiZmFkX2hhbF9jb21wICpmY29tcCA9IChzdHJ1Y3QgYmZhZF9oYWxfY29tcCAqKWFyZzsKKworCWZjb21wLT5zdGF0dXMgPSBzdGF0dXM7CisJY29tcGxldGUoJmZjb21wLT5jb21wKTsKK30KKworLyoqCisgKiBiZmFfaW5pdCBjYWxsYmFjaworICovCit2b2lkCitiZmFfY2JfaW5pdCh2b2lkICpkcnYsIGJmYV9zdGF0dXNfdCBpbml0X3N0YXR1cykKK3sKKwlzdHJ1Y3QgYmZhZF9zICAqYmZhZCA9IGRydjsKKworCWlmIChpbml0X3N0YXR1cyA9PSBCRkFfU1RBVFVTX09LKQorCQliZmFkLT5iZmFkX2ZsYWdzIHw9IEJGQURfSEFMX0lOSVRfRE9ORTsKKworCWNvbXBsZXRlKCZiZmFkLT5jb21wKTsKK30KKworCisKKy8qKgorICogIEJGQV9GQ1MgY2FsbGJhY2tzCisgKi8KK3N0YXRpYyBzdHJ1Y3QgYmZhZF9wb3J0X3MgKgorYmZhZF9nZXRfZHJ2X3BvcnQoc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYWRfdmZfcyAqdmZfZHJ2LAorCQkgIHN0cnVjdCBiZmFkX3Zwb3J0X3MgKnZwX2RydikKK3sKKwlyZXR1cm4gKCh2cF9kcnYpID8gKCYodnBfZHJ2KS0+ZHJ2X3BvcnQpCisJCTogKCh2Zl9kcnYpID8gKCYodmZfZHJ2KS0+YmFzZV9wb3J0KSA6ICgmKGJmYWQpLT5wcG9ydCkpKTsKK30KKworc3RydWN0IGJmYWRfcG9ydF9zICoKK2JmYV9mY2JfcG9ydF9uZXcoc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkgZW51bSBiZmFfcG9ydF9yb2xlIHJvbGVzLCBzdHJ1Y3QgYmZhZF92Zl9zICp2Zl9kcnYsCisJCSBzdHJ1Y3QgYmZhZF92cG9ydF9zICp2cF9kcnYpCit7CisJYmZhX3N0YXR1c190ICAgIHJjOworCXN0cnVjdCBiZmFkX3BvcnRfcyAqcG9ydF9kcnY7CisKKwlpZiAoIXZwX2RydiAmJiAhdmZfZHJ2KSB7CisJCXBvcnRfZHJ2ID0gJmJmYWQtPnBwb3J0OworCQlwb3J0X2Rydi0+cHZiX3R5cGUgPSBCRkFEX1BPUlRfUEhZU19CQVNFOworCX0gZWxzZSBpZiAoIXZwX2RydiAmJiB2Zl9kcnYpIHsKKwkJcG9ydF9kcnYgPSAmdmZfZHJ2LT5iYXNlX3BvcnQ7CisJCXBvcnRfZHJ2LT5wdmJfdHlwZSA9IEJGQURfUE9SVF9WRl9CQVNFOworCX0gZWxzZSBpZiAodnBfZHJ2ICYmICF2Zl9kcnYpIHsKKwkJcG9ydF9kcnYgPSAmdnBfZHJ2LT5kcnZfcG9ydDsKKwkJcG9ydF9kcnYtPnB2Yl90eXBlID0gQkZBRF9QT1JUX1BIWVNfVlBPUlQ7CisJfSBlbHNlIHsKKwkJcG9ydF9kcnYgPSAmdnBfZHJ2LT5kcnZfcG9ydDsKKwkJcG9ydF9kcnYtPnB2Yl90eXBlID0gQkZBRF9QT1JUX1ZGX1ZQT1JUOworCX0KKworCXBvcnRfZHJ2LT5mY3NfcG9ydCA9IHBvcnQ7CisJcG9ydF9kcnYtPnJvbGVzID0gcm9sZXM7CisJcmMgPSBiZmFkX2ZjNF9wb3J0X25ldyhiZmFkLCBwb3J0X2Rydiwgcm9sZXMpOworCWlmIChyYyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWJmYWRfZmM0X3BvcnRfZGVsZXRlKGJmYWQsIHBvcnRfZHJ2LCByb2xlcyk7CisJCXBvcnRfZHJ2ID0gTlVMTDsKKwl9CisKKwlyZXR1cm4gcG9ydF9kcnY7Cit9CisKK3ZvaWQKK2JmYV9mY2JfcG9ydF9kZWxldGUoc3RydWN0IGJmYWRfcyAqYmZhZCwgZW51bSBiZmFfcG9ydF9yb2xlIHJvbGVzLAorCQkgICAgc3RydWN0IGJmYWRfdmZfcyAqdmZfZHJ2LCBzdHJ1Y3QgYmZhZF92cG9ydF9zICp2cF9kcnYpCit7CisJc3RydWN0IGJmYWRfcG9ydF9zICpwb3J0X2RydjsKKworCS8qCisJICogdGhpcyB3aWxsIGJlIG9ubHkgY2FsbGVkIGZyb20gcm1tb2QgY29udGV4dAorCSAqLworCWlmICh2cF9kcnYgJiYgIXZwX2Rydi0+Y29tcF9kZWwpIHsKKwkJcG9ydF9kcnYgPSBiZmFkX2dldF9kcnZfcG9ydChiZmFkLCB2Zl9kcnYsIHZwX2Rydik7CisJCWJmYV90cmMoYmZhZCwgcm9sZXMpOworCQliZmFkX2ZjNF9wb3J0X2RlbGV0ZShiZmFkLCBwb3J0X2Rydiwgcm9sZXMpOworCX0KK30KKwordm9pZAorYmZhX2ZjYl9wb3J0X29ubGluZShzdHJ1Y3QgYmZhZF9zICpiZmFkLCBlbnVtIGJmYV9wb3J0X3JvbGUgcm9sZXMsCisJCSAgICBzdHJ1Y3QgYmZhZF92Zl9zICp2Zl9kcnYsIHN0cnVjdCBiZmFkX3Zwb3J0X3MgKnZwX2RydikKK3sKKwlzdHJ1Y3QgYmZhZF9wb3J0X3MgKnBvcnRfZHJ2ID0gYmZhZF9nZXRfZHJ2X3BvcnQoYmZhZCwgdmZfZHJ2LCB2cF9kcnYpOworCisJaWYgKHJvbGVzICYgQkZBX1BPUlRfUk9MRV9GQ1BfSU0pCisJCWJmYWRfaW1fcG9ydF9vbmxpbmUoYmZhZCwgcG9ydF9kcnYpOworCisJaWYgKHJvbGVzICYgQkZBX1BPUlRfUk9MRV9GQ1BfVE0pCisJCWJmYWRfdG1fcG9ydF9vbmxpbmUoYmZhZCwgcG9ydF9kcnYpOworCisJaWYgKChyb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lQRkMpICYmIGlwZmNfZW5hYmxlKQorCQliZmFkX2lwZmNfcG9ydF9vbmxpbmUoYmZhZCwgcG9ydF9kcnYpOworCisJYmZhZC0+YmZhZF9mbGFncyB8PSBCRkFEX1BPUlRfT05MSU5FOworfQorCit2b2lkCitiZmFfZmNiX3BvcnRfb2ZmbGluZShzdHJ1Y3QgYmZhZF9zICpiZmFkLCBlbnVtIGJmYV9wb3J0X3JvbGUgcm9sZXMsCisJCSAgICAgc3RydWN0IGJmYWRfdmZfcyAqdmZfZHJ2LCBzdHJ1Y3QgYmZhZF92cG9ydF9zICp2cF9kcnYpCit7CisJc3RydWN0IGJmYWRfcG9ydF9zICpwb3J0X2RydiA9IGJmYWRfZ2V0X2Rydl9wb3J0KGJmYWQsIHZmX2RydiwgdnBfZHJ2KTsKKworCWlmIChyb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lNKQorCQliZmFkX2ltX3BvcnRfb2ZmbGluZShiZmFkLCBwb3J0X2Rydik7CisKKwlpZiAocm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9UTSkKKwkJYmZhZF90bV9wb3J0X29mZmxpbmUoYmZhZCwgcG9ydF9kcnYpOworCisJaWYgKChyb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lQRkMpICYmIGlwZmNfZW5hYmxlKQorCQliZmFkX2lwZmNfcG9ydF9vZmZsaW5lKGJmYWQsIHBvcnRfZHJ2KTsKK30KKwordm9pZAorYmZhX2ZjYl92cG9ydF9kZWxldGUoc3RydWN0IGJmYWRfdnBvcnRfcyAqdnBvcnRfZHJ2KQoreworCWlmICh2cG9ydF9kcnYtPmNvbXBfZGVsKSB7CisJCWNvbXBsZXRlKHZwb3J0X2Rydi0+Y29tcF9kZWwpOworCQlyZXR1cm47CisJfQorCisJa2ZyZWUodnBvcnRfZHJ2KTsKK30KKworLyoqCisgKiBGQ1MgUlBPUlQgYWxsb2MgY2FsbGJhY2ssIGFmdGVyIHN1Y2Nlc3NmdWwgUExPR0kgYnkgRkNTCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2ZjYl9ycG9ydF9hbGxvYyhzdHJ1Y3QgYmZhZF9zICpiZmFkLCBzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICoqcnBvcnQsCisJCSAgICBzdHJ1Y3QgYmZhZF9ycG9ydF9zICoqcnBvcnRfZHJ2KQoreworCWJmYV9zdGF0dXNfdCAgICByYyA9IEJGQV9TVEFUVVNfT0s7CisKKwkqcnBvcnRfZHJ2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGJmYWRfcnBvcnRfcyksIEdGUF9BVE9NSUMpOworCWlmICgqcnBvcnRfZHJ2ID09IE5VTEwpIHsKKwkJcmMgPSBCRkFfU1RBVFVTX0VOT01FTTsKKwkJZ290byBleHQ7CisJfQorCisJKnJwb3J0ID0gJigqcnBvcnRfZHJ2KS0+ZmNzX3Jwb3J0OworCitleHQ6CisJcmV0dXJuIHJjOworfQorCisKKwordm9pZAorYmZhZF9oYWxfbWVtX3JlbGVhc2Uoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlpbnQgICAgICAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX21lbWluZm9fcyAqaGFsX21lbWluZm8gPSAmYmZhZC0+bWVtaW5mbzsKKwlzdHJ1Y3QgYmZhX21lbV9lbGVtX3MgKm1lbWluZm9fZWxlbTsKKworCWZvciAoaSA9IDA7IGkgPCBCRkFfTUVNX1RZUEVfTUFYOyBpKyspIHsKKwkJbWVtaW5mb19lbGVtID0gJmhhbF9tZW1pbmZvLT5tZW1pbmZvW2ldOworCQlpZiAobWVtaW5mb19lbGVtLT5rdmEgIT0gTlVMTCkgeworCQkJc3dpdGNoIChtZW1pbmZvX2VsZW0tPm1lbV90eXBlKSB7CisJCQljYXNlIEJGQV9NRU1fVFlQRV9LVkE6CisJCQkJdmZyZWUobWVtaW5mb19lbGVtLT5rdmEpOworCQkJCWJyZWFrOworCQkJY2FzZSBCRkFfTUVNX1RZUEVfRE1BOgorCQkJCWRtYV9mcmVlX2NvaGVyZW50KCZiZmFkLT5wY2lkZXYtPmRldiwKKwkJCQkJCW1lbWluZm9fZWxlbS0+bWVtX2xlbiwKKwkJCQkJCW1lbWluZm9fZWxlbS0+a3ZhLAorCQkJCQkJKGRtYV9hZGRyX3QpIG1lbWluZm9fZWxlbS0+ZG1hKTsKKwkJCQlicmVhazsKKwkJCWRlZmF1bHQ6CisJCQkJYmZhX2Fzc2VydCgwKTsKKwkJCQlicmVhazsKKwkJCX0KKwkJfQorCX0KKworCW1lbXNldChoYWxfbWVtaW5mbywgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfbWVtaW5mb19zKSk7Cit9CisKK3ZvaWQKK2JmYWRfdXBkYXRlX2hhbF9jZmcoc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqYmZhX2NmZykKK3sKKwlpZiAobnVtX3Jwb3J0cyA+IDApCisJCWJmYV9jZmctPmZ3Y2ZnLm51bV9ycG9ydHMgPSBudW1fcnBvcnRzOworCWlmIChudW1faW9zID4gMCkKKwkJYmZhX2NmZy0+ZndjZmcubnVtX2lvaW1fcmVxcyA9IG51bV9pb3M7CisJaWYgKG51bV90bXMgPiAwKQorCQliZmFfY2ZnLT5md2NmZy5udW1fdHNraW1fcmVxcyA9IG51bV90bXM7CisJaWYgKG51bV9mY3hwcyA+IDApCisJCWJmYV9jZmctPmZ3Y2ZnLm51bV9mY3hwX3JlcXMgPSBudW1fZmN4cHM7CisJaWYgKG51bV91ZmJ1ZnMgPiAwKQorCQliZmFfY2ZnLT5md2NmZy5udW1fdWZfYnVmcyA9IG51bV91ZmJ1ZnM7CisJaWYgKHJlcXFfc2l6ZSA+IDApCisJCWJmYV9jZmctPmRydmNmZy5udW1fcmVxcV9lbGVtcyA9IHJlcXFfc2l6ZTsKKwlpZiAocnNwcV9zaXplID4gMCkKKwkJYmZhX2NmZy0+ZHJ2Y2ZnLm51bV9yc3BxX2VsZW1zID0gcnNwcV9zaXplOworCWlmIChudW1fc2dwZ3MgPiAwKQorCQliZmFfY2ZnLT5kcnZjZmcubnVtX3NncGdzID0gbnVtX3NncGdzOworCisJLyoKKwkgKiBwb3B1bGF0ZSB0aGUgaGFsIHZhbHVlcyBiYWNrIHRvIHRoZSBkcml2ZXIgZm9yIHN5c2ZzIHVzZS4KKwkgKiBvdGhlcndpc2UsIHRoZSBkZWZhdWx0IHZhbHVlcyB3aWxsIGJlIHNob3duIGFzIDAgaW4gc3lzZnMKKwkgKi8KKwludW1fcnBvcnRzID0gYmZhX2NmZy0+ZndjZmcubnVtX3Jwb3J0czsKKwludW1faW9zICAgID0gYmZhX2NmZy0+ZndjZmcubnVtX2lvaW1fcmVxczsKKwludW1fdG1zCSAgID0gYmZhX2NmZy0+ZndjZmcubnVtX3Rza2ltX3JlcXM7CisJbnVtX2ZjeHBzICA9IGJmYV9jZmctPmZ3Y2ZnLm51bV9mY3hwX3JlcXM7CisJbnVtX3VmYnVmcyA9IGJmYV9jZmctPmZ3Y2ZnLm51bV91Zl9idWZzOworCXJlcXFfc2l6ZSAgPSBiZmFfY2ZnLT5kcnZjZmcubnVtX3JlcXFfZWxlbXM7CisJcnNwcV9zaXplICA9IGJmYV9jZmctPmRydmNmZy5udW1fcnNwcV9lbGVtczsKKwludW1fc2dwZ3MgID0gYmZhX2NmZy0+ZHJ2Y2ZnLm51bV9zZ3BnczsKK30KKworYmZhX3N0YXR1c190CitiZmFkX2hhbF9tZW1fYWxsb2Moc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlzdHJ1Y3QgYmZhX21lbWluZm9fcyAqaGFsX21lbWluZm8gPSAmYmZhZC0+bWVtaW5mbzsKKwlzdHJ1Y3QgYmZhX21lbV9lbGVtX3MgKm1lbWluZm9fZWxlbTsKKwliZmFfc3RhdHVzX3QgICAgcmMgPSBCRkFfU1RBVFVTX09LOworCWRtYV9hZGRyX3QgICAgICBwaHlzX2FkZHI7CisJaW50ICAgICAgICAgICAgIHJldHJ5X2NvdW50ID0gMDsKKwlpbnQgICAgICAgICAgICAgcmVzZXRfdmFsdWUgPSAxOworCWludCAgICAgICAgICAgICBtaW5fbnVtX3NncGdzID0gNTEyOworCXZvaWQgICAgICAgICAgICprdmE7CisJaW50ICAgICAgICAgICAgIGk7CisKKwliZmFfY2ZnX2dldF9kZWZhdWx0KCZiZmFkLT5pb2NfY2ZnKTsKKworcmV0cnk6CisJYmZhZF91cGRhdGVfaGFsX2NmZygmYmZhZC0+aW9jX2NmZyk7CisJYmZhZC0+Y2ZnX2RhdGEuaW9jX3F1ZXVlX2RlcHRoID0gYmZhZC0+aW9jX2NmZy5md2NmZy5udW1faW9pbV9yZXFzOworCWJmYV9jZmdfZ2V0X21lbWluZm8oJmJmYWQtPmlvY19jZmcsIGhhbF9tZW1pbmZvKTsKKworCWZvciAoaSA9IDA7IGkgPCBCRkFfTUVNX1RZUEVfTUFYOyBpKyspIHsKKwkJbWVtaW5mb19lbGVtID0gJmhhbF9tZW1pbmZvLT5tZW1pbmZvW2ldOworCQlzd2l0Y2ggKG1lbWluZm9fZWxlbS0+bWVtX3R5cGUpIHsKKwkJY2FzZSBCRkFfTUVNX1RZUEVfS1ZBOgorCQkJa3ZhID0gdm1hbGxvYyhtZW1pbmZvX2VsZW0tPm1lbV9sZW4pOworCQkJaWYgKGt2YSA9PSBOVUxMKSB7CisJCQkJYmZhZF9oYWxfbWVtX3JlbGVhc2UoYmZhZCk7CisJCQkJcmMgPSBCRkFfU1RBVFVTX0VOT01FTTsKKwkJCQlnb3RvIGV4dDsKKwkJCX0KKwkJCW1lbXNldChrdmEsIDAsIG1lbWluZm9fZWxlbS0+bWVtX2xlbik7CisJCQltZW1pbmZvX2VsZW0tPmt2YSA9IGt2YTsKKwkJCWJyZWFrOworCQljYXNlIEJGQV9NRU1fVFlQRV9ETUE6CisJCQlrdmEgPSBkbWFfYWxsb2NfY29oZXJlbnQoJmJmYWQtPnBjaWRldi0+ZGV2LAorCQkJCQltZW1pbmZvX2VsZW0tPm1lbV9sZW4sCisJCQkJCSZwaHlzX2FkZHIsIEdGUF9LRVJORUwpOworCQkJaWYgKGt2YSA9PSBOVUxMKSB7CisJCQkJYmZhZF9oYWxfbWVtX3JlbGVhc2UoYmZhZCk7CisJCQkJLyoKKwkJCQkgKiBJZiB3ZSBjYW5ub3QgYWxsb2NhdGUgd2l0aCBkZWZhdWx0CisJCQkJICogbnVtX3NncGFnZXMgdHJ5IHdpdGggaGFsZiB0aGUgdmFsdWUuCisJCQkJICovCisJCQkJaWYgKG51bV9zZ3BncyA+IG1pbl9udW1fc2dwZ3MpIHsKKwkJCQkJcHJpbnRrKEtFUk5fSU5GTyAiYmZhZFslZF06IG1lbW9yeSIKKwkJCQkJCSIgYWxsb2NhdGlvbiBmYWlsZWQgd2l0aCIKKwkJCQkJCSIgbnVtX3NncGdzOiAlZFxuIiwKKwkJCQkJCWJmYWQtPmluc3Rfbm8sIG51bV9zZ3Bncyk7CisJCQkJCW5leHRMb3dlckludCgmbnVtX3NncGdzKTsKKwkJCQkJcHJpbnRrKEtFUk5fSU5GTyAiYmZhZFslZF06IHRyeWluZyB0byIKKwkJCQkJCSIgYWxsb2NhdGUgbWVtb3J5IHdpdGgiCisJCQkJCQkiIG51bV9zZ3BnczogJWRcbiIsCisJCQkJCQliZmFkLT5pbnN0X25vLCBudW1fc2dwZ3MpOworCQkJCQlyZXRyeV9jb3VudCsrOworCQkJCQlnb3RvIHJldHJ5OworCQkJCX0gZWxzZSB7CisJCQkJCWlmIChudW1fc2dwZ3NfcGFybSA+IDApCisJCQkJCQludW1fc2dwZ3MgPSBudW1fc2dwZ3NfcGFybTsKKwkJCQkJZWxzZSB7CisJCQkJCQlyZXNldF92YWx1ZSA9CisJCQkJCQkJKDEgPDwgcmV0cnlfY291bnQpOworCQkJCQkJbnVtX3NncGdzICo9IHJlc2V0X3ZhbHVlOworCQkJCQl9CisJCQkJCXJjID0gQkZBX1NUQVRVU19FTk9NRU07CisJCQkJCWdvdG8gZXh0OworCQkJCX0KKwkJCX0KKworCQkJaWYgKG51bV9zZ3Bnc19wYXJtID4gMCkKKwkJCQludW1fc2dwZ3MgPSBudW1fc2dwZ3NfcGFybTsKKwkJCWVsc2UgeworCQkJCXJlc2V0X3ZhbHVlID0gKDEgPDwgcmV0cnlfY291bnQpOworCQkJCW51bV9zZ3BncyAqPSByZXNldF92YWx1ZTsKKwkJCX0KKworCQkJbWVtc2V0KGt2YSwgMCwgbWVtaW5mb19lbGVtLT5tZW1fbGVuKTsKKwkJCW1lbWluZm9fZWxlbS0+a3ZhID0ga3ZhOworCQkJbWVtaW5mb19lbGVtLT5kbWEgPSBwaHlzX2FkZHI7CisJCQlicmVhazsKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCisJCX0KKwl9CitleHQ6CisJcmV0dXJuIHJjOworfQorCisvKioKKyAqIENyZWF0ZSBhIHZwb3J0IHVuZGVyIGEgdmYuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhZF92cG9ydF9jcmVhdGUoc3RydWN0IGJmYWRfcyAqYmZhZCwgdTE2IHZmX2lkLAorCQkgIHN0cnVjdCBiZmFfcG9ydF9jZmdfcyAqcG9ydF9jZmcpCit7CisJc3RydWN0IGJmYWRfdnBvcnRfcyAqdnBvcnQ7CisJaW50ICAgICAgICAgICAgIHJjID0gQkZBX1NUQVRVU19PSzsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisJc3RydWN0IGNvbXBsZXRpb24gZmNvbXA7CisKKwl2cG9ydCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBiZmFkX3Zwb3J0X3MpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXZwb3J0KSB7CisJCXJjID0gQkZBX1NUQVRVU19FTk9NRU07CisJCWdvdG8gZXh0OworCX0KKworCXZwb3J0LT5kcnZfcG9ydC5iZmFkID0gYmZhZDsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJcmMgPSBiZmFfZmNzX3Zwb3J0X2NyZWF0ZSgmdnBvcnQtPmZjc192cG9ydCwgJmJmYWQtPmJmYV9mY3MsIHZmX2lkLAorCQkJCSAgcG9ydF9jZmcsIHZwb3J0KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCWlmIChyYyAhPSBCRkFfU1RBVFVTX09LKQorCQlnb3RvIGV4dF9mcmVlX3Zwb3J0OworCisJaWYgKHBvcnRfY2ZnLT5yb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lNKSB7CisJCXJjID0gYmZhZF9pbV9zY3NpX2hvc3RfYWxsb2MoYmZhZCwgdnBvcnQtPmRydl9wb3J0LmltX3BvcnQpOworCQlpZiAocmMgIT0gQkZBX1NUQVRVU19PSykKKwkJCWdvdG8gZXh0X2ZyZWVfZmNzX3Zwb3J0OworCX0KKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwliZmFfZmNzX3Zwb3J0X3N0YXJ0KCZ2cG9ydC0+ZmNzX3Zwb3J0KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCXJldHVybiBCRkFfU1RBVFVTX09LOworCitleHRfZnJlZV9mY3NfdnBvcnQ6CisJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCXZwb3J0LT5jb21wX2RlbCA9ICZmY29tcDsKKwlpbml0X2NvbXBsZXRpb24odnBvcnQtPmNvbXBfZGVsKTsKKwliZmFfZmNzX3Zwb3J0X2RlbGV0ZSgmdnBvcnQtPmZjc192cG9ydCk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJd2FpdF9mb3JfY29tcGxldGlvbih2cG9ydC0+Y29tcF9kZWwpOworZXh0X2ZyZWVfdnBvcnQ6CisJa2ZyZWUodnBvcnQpOworZXh0OgorCXJldHVybiByYzsKK30KKworLyoqCisgKiBDcmVhdGUgYSB2ZiBhbmQgaXRzIGJhc2UgdnBvcnQgaW1wbGljaXRlbHkuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhZF92Zl9jcmVhdGUoc3RydWN0IGJmYWRfcyAqYmZhZCwgdTE2IHZmX2lkLAorCSAgICAgICBzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgKnBvcnRfY2ZnKQoreworCXN0cnVjdCBiZmFkX3ZmX3MgKnZmOworCWludCAgICAgICAgICAgICByYyA9IEJGQV9TVEFUVVNfT0s7CisKKwl2ZiA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBiZmFkX3ZmX3MpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIXZmKSB7CisJCXJjID0gQkZBX1NUQVRVU19GQUlMRUQ7CisJCWdvdG8gZXh0OworCX0KKworCXJjID0gYmZhX2Zjc192Zl9jcmVhdGUoJnZmLT5mY3NfdmYsICZiZmFkLT5iZmFfZmNzLCB2Zl9pZCwgcG9ydF9jZmcsCisJCQkgICAgICAgdmYpOworCWlmIChyYyAhPSBCRkFfU1RBVFVTX09LKQorCQlrZnJlZSh2Zik7CitleHQ6CisJcmV0dXJuIHJjOworfQorCit2b2lkCitiZmFkX2JmYV90bW8odW5zaWduZWQgbG9uZyBkYXRhKQoreworCXN0cnVjdCBiZmFkX3MgICpiZmFkID0gKHN0cnVjdCBiZmFkX3MgKilkYXRhOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKwlzdHJ1Y3QgbGlzdF9oZWFkICBkb25lcTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCWJmYV90aW1lcl90aWNrKCZiZmFkLT5iZmEpOworCisJYmZhX2NvbXBfZGVxKCZiZmFkLT5iZmEsICZkb25lcSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisKKwlpZiAoIWxpc3RfZW1wdHkoJmRvbmVxKSkgeworCQliZmFfY29tcF9wcm9jZXNzKCZiZmFkLT5iZmEsICZkb25lcSk7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJYmZhX2NvbXBfZnJlZSgmYmZhZC0+YmZhLCAmZG9uZXEpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwl9CisKKwltb2RfdGltZXIoJmJmYWQtPmhhbF90bW8sIGppZmZpZXMgKyBtc2Vjc190b19qaWZmaWVzKEJGQV9USU1FUl9GUkVRKSk7Cit9CisKK3ZvaWQKK2JmYWRfaW5pdF90aW1lcihzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworCWluaXRfdGltZXIoJmJmYWQtPmhhbF90bW8pOworCWJmYWQtPmhhbF90bW8uZnVuY3Rpb24gPSBiZmFkX2JmYV90bW87CisJYmZhZC0+aGFsX3Rtby5kYXRhID0gKHVuc2lnbmVkIGxvbmcpYmZhZDsKKworCW1vZF90aW1lcigmYmZhZC0+aGFsX3RtbywgamlmZmllcyArIG1zZWNzX3RvX2ppZmZpZXMoQkZBX1RJTUVSX0ZSRVEpKTsKK30KKworaW50CitiZmFkX3BjaV9pbml0KHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworCXVuc2lnbmVkIGxvbmcgICBiYXIwX2xlbjsKKwlpbnQgICAgICAgICAgICAgcmMgPSAtRU5PREVWOworCisJaWYgKHBjaV9lbmFibGVfZGV2aWNlKHBkZXYpKSB7CisJCUJGQV9QUklOVEYoQkZBX0VSUiwgInBjaV9lbmFibGVfZGV2aWNlIGZhaWwgJXBcbiIsIHBkZXYpOworCQlnb3RvIG91dDsKKwl9CisKKwlpZiAocGNpX3JlcXVlc3RfcmVnaW9ucyhwZGV2LCBCRkFEX0RSSVZFUl9OQU1FKSkKKwkJZ290byBvdXRfZGlzYWJsZV9kZXZpY2U7CisKKwlwY2lfc2V0X21hc3RlcihwZGV2KTsKKworCisJaWYgKHBjaV9zZXRfZG1hX21hc2socGRldiwgRE1BX0JJVF9NQVNLKDY0KSkgIT0gMCkKKwkJaWYgKHBjaV9zZXRfZG1hX21hc2socGRldiwgRE1BX0JJVF9NQVNLKDMyKSkgIT0gMCkgeworCQkJQkZBX1BSSU5URihCRkFfRVJSLCAicGNpX3NldF9kbWFfbWFzayBmYWlsICVwXG4iLCBwZGV2KTsKKwkJCWdvdG8gb3V0X3JlbGVhc2VfcmVnaW9uOworCQl9CisKKwliZmFkLT5wY2lfYmFyMF9tYXAgPSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgMCk7CisJYmFyMF9sZW4gPSBwY2lfcmVzb3VyY2VfbGVuKHBkZXYsIDApOworCWJmYWQtPnBjaV9iYXIwX2t2YSA9IGlvcmVtYXAoYmZhZC0+cGNpX2JhcjBfbWFwLCBiYXIwX2xlbik7CisKKwlpZiAoYmZhZC0+cGNpX2JhcjBfa3ZhID09IE5VTEwpIHsKKwkJQkZBX1BSSU5URihCRkFfRVJSLCAiRmFpbCB0byBtYXAgYmFyMFxuIik7CisJCWdvdG8gb3V0X3JlbGVhc2VfcmVnaW9uOworCX0KKworCWJmYWQtPmhhbF9wY2lkZXYucGNpX3Nsb3QgPSBQQ0lfU0xPVChwZGV2LT5kZXZmbik7CisJYmZhZC0+aGFsX3BjaWRldi5wY2lfZnVuYyA9IFBDSV9GVU5DKHBkZXYtPmRldmZuKTsKKwliZmFkLT5oYWxfcGNpZGV2LnBjaV9iYXJfa3ZhID0gYmZhZC0+cGNpX2JhcjBfa3ZhOworCWJmYWQtPmhhbF9wY2lkZXYuZGV2aWNlX2lkID0gcGRldi0+ZGV2aWNlOworCWJmYWQtPnBjaV9uYW1lID0gcGNpX25hbWUocGRldik7CisKKwliZmFkLT5wY2lfYXR0ci52ZW5kb3JfaWQgPSBwZGV2LT52ZW5kb3I7CisJYmZhZC0+cGNpX2F0dHIuZGV2aWNlX2lkID0gcGRldi0+ZGV2aWNlOworCWJmYWQtPnBjaV9hdHRyLnNzaWQgPSBwZGV2LT5zdWJzeXN0ZW1fZGV2aWNlOworCWJmYWQtPnBjaV9hdHRyLnNzdmlkID0gcGRldi0+c3Vic3lzdGVtX3ZlbmRvcjsKKwliZmFkLT5wY2lfYXR0ci5wY2lmbiA9IFBDSV9GVU5DKHBkZXYtPmRldmZuKTsKKworCWJmYWQtPnBjaWRldiA9IHBkZXY7CisJcmV0dXJuIDA7CisKK291dF9yZWxlYXNlX3JlZ2lvbjoKKwlwY2lfcmVsZWFzZV9yZWdpb25zKHBkZXYpOworb3V0X2Rpc2FibGVfZGV2aWNlOgorCXBjaV9kaXNhYmxlX2RldmljZShwZGV2KTsKK291dDoKKwlyZXR1cm4gcmM7Cit9CisKK3ZvaWQKK2JmYWRfcGNpX3VuaW5pdChzdHJ1Y3QgcGNpX2RldiAqcGRldiwgc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKyNpZiBkZWZpbmVkKF9faWE2NF9fKQorCXBjaV9pb3VubWFwKHBkZXYsIGJmYWQtPnBjaV9iYXIwX2t2YSk7CisjZWxzZQorCWlvdW5tYXAoYmZhZC0+cGNpX2JhcjBfa3ZhKTsKKyNlbmRpZgorCXBjaV9yZWxlYXNlX3JlZ2lvbnMocGRldik7CisJcGNpX2Rpc2FibGVfZGV2aWNlKHBkZXYpOworCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKK30KKwordm9pZAorYmZhZF9mY3NfcG9ydF9jZmcoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgcG9ydF9jZmc7CisJc3RydWN0IGJmYV9wcG9ydF9hdHRyX3MgYXR0cjsKKwljaGFyICAgICAgICAgICAgc3ltbmFtZVtCRkFfU1lNTkFNRV9NQVhMRU5dOworCisJc3ByaW50ZihzeW1uYW1lLCAiJXMtJWQiLCBCRkFEX0RSSVZFUl9OQU1FLCBiZmFkLT5pbnN0X25vKTsKKwltZW1jcHkocG9ydF9jZmcuc3ltX25hbWUuc3ltbmFtZSwgc3ltbmFtZSwgc3RybGVuKHN5bW5hbWUpKTsKKwliZmFfcHBvcnRfZ2V0X2F0dHIoJmJmYWQtPmJmYSwgJmF0dHIpOworCXBvcnRfY2ZnLm53d24gPSBhdHRyLm53d247CisJcG9ydF9jZmcucHd3biA9IGF0dHIucHd3bjsKKworCWJmYV9mY3NfY2ZnX2Jhc2VfcG9ydCgmYmZhZC0+YmZhX2ZjcywgJnBvcnRfY2ZnKTsKK30KKworYmZhX3N0YXR1c190CitiZmFkX2Rydl9pbml0KHN0cnVjdCBiZmFkX3MgKmJmYWQpCit7CisJYmZhX3N0YXR1c190ICAgIHJjOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKwlzdHJ1Y3QgYmZhX2Zjc19kcml2ZXJfaW5mb19zIGRyaXZlcl9pbmZvOworCWludCAgICAgICAgICAgICBpOworCisJYmZhZC0+Y2ZnX2RhdGEucnBvcnRfZGVsX3RpbWVvdXQgPSBycG9ydF9kZWxfdGltZW91dDsKKwliZmFkLT5jZmdfZGF0YS5sdW5fcXVldWVfZGVwdGggPSBiZmFfbHVuX3F1ZXVlX2RlcHRoOworCWJmYWQtPmNmZ19kYXRhLmlvX21heF9zZ2UgPSBiZmFfaW9fbWF4X3NnZTsKKwliZmFkLT5jZmdfZGF0YS5iaW5kaW5nX21ldGhvZCA9IEZDUF9QV1dOX0JJTkRJTkc7CisKKwlyYyA9IGJmYWRfaGFsX21lbV9hbGxvYyhiZmFkKTsKKwlpZiAocmMgIT0gQkZBX1NUQVRVU19PSykgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJiZmFkJWQgYmZhZF9oYWxfbWVtX2FsbG9jIGZhaWx1cmVcbiIsCisJCSAgICAgICBiZmFkLT5pbnN0X25vKTsKKwkJcHJpbnRrKEtFUk5fV0FSTklORworCQkJIk5vdCBlbm91Z2ggbWVtb3J5IHRvIGF0dGFjaCBhbGwgQnJvY2FkZSBIQkEgcG9ydHMsIgorCQkJIiBTeXN0ZW0gbWF5IG5lZWQgbW9yZSBtZW1vcnkuXG4iKTsKKwkJZ290byBvdXRfaGFsX21lbV9hbGxvY19mYWlsdXJlOworCX0KKworCWJmYV9pbml0X2xvZygmYmZhZC0+YmZhLCBiZmFkLT5sb2dtb2QpOworCWJmYV9pbml0X3RyYygmYmZhZC0+YmZhLCBiZmFkLT50cmNtb2QpOworCWJmYV9pbml0X2FlbigmYmZhZC0+YmZhLCBiZmFkLT5hZW4pOworCUlOSVRfTElTVF9IRUFEKCZiZmFkLT5maWxlX3EpOworCUlOSVRfTElTVF9IRUFEKCZiZmFkLT5maWxlX2ZyZWVfcSk7CisJZm9yIChpID0gMDsgaSA8IEJGQURfQUVOX01BWF9BUFBTOyBpKyspIHsKKwkJYmZhX3FfcWVfaW5pdCgmYmZhZC0+ZmlsZV9idWZbaV0ucWUpOworCQlsaXN0X2FkZF90YWlsKCZiZmFkLT5maWxlX2J1ZltpXS5xZSwgJmJmYWQtPmZpbGVfZnJlZV9xKTsKKwl9CisJYmZhX2luaXRfcGxvZygmYmZhZC0+YmZhLCAmYmZhZC0+cGxvZ19idWYpOworCWJmYV9wbG9nX2luaXQoJmJmYWQtPnBsb2dfYnVmKTsKKwliZmFfcGxvZ19zdHIoJmJmYWQtPnBsb2dfYnVmLCBCRkFfUExfTUlEX0RSVlIsIEJGQV9QTF9FSURfRFJJVkVSX1NUQVJULAorCQkgICAgIDAsICJEcml2ZXIgQXR0YWNoIik7CisKKwliZmFfYXR0YWNoKCZiZmFkLT5iZmEsIGJmYWQsICZiZmFkLT5pb2NfY2ZnLCAmYmZhZC0+bWVtaW5mbywKKwkJICAgJmJmYWQtPmhhbF9wY2lkZXYpOworCisJaW5pdF9jb21wbGV0aW9uKCZiZmFkLT5jb21wKTsKKworCS8qCisJICogRW5hYmxlIEludGVycnVwdCBhbmQgd2FpdCBiZmFfaW5pdCBjb21wbGV0aW9uCisJICovCisJaWYgKGJmYWRfc2V0dXBfaW50cihiZmFkKSkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJiZmFkJWQ6IGJmYWRfc2V0dXBfaW50ciBmYWlsZWRcbiIsCisJCSAgICAgICBiZmFkLT5pbnN0X25vKTsKKwkJZ290byBvdXRfc2V0dXBfaW50cl9mYWlsdXJlOworCX0KKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwliZmFfaW5pdCgmYmZhZC0+YmZhKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCS8qCisJICogU2V0IHVwIGludGVycnVwdCBoYW5kbGVyIGZvciBlYWNoIHZlY3RvcnMKKwkgKi8KKwlpZiAoKGJmYWQtPmJmYWRfZmxhZ3MgJiBCRkFEX01TSVhfT04pCisJICAgICYmIGJmYWRfaW5zdGFsbF9tc2l4X2hhbmRsZXIoYmZhZCkpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiJXM6IGluc3RhbGxfbXNpeCBmYWlsZWQsIGJmYWQlZFxuIiwKKwkJICAgICAgIF9fRlVOQ1RJT05fXywgYmZhZC0+aW5zdF9ubyk7CisJfQorCisJYmZhZF9pbml0X3RpbWVyKGJmYWQpOworCisJd2FpdF9mb3JfY29tcGxldGlvbigmYmZhZC0+Y29tcCk7CisKKwltZW1zZXQoJmRyaXZlcl9pbmZvLCAwLCBzaXplb2YoZHJpdmVyX2luZm8pKTsKKwlzdHJuY3B5KGRyaXZlcl9pbmZvLnZlcnNpb24sIEJGQURfRFJJVkVSX1ZFUlNJT04sCisJCXNpemVvZihkcml2ZXJfaW5mby52ZXJzaW9uKSAtIDEpOworCWlmIChob3N0X25hbWUpCisJCXN0cm5jcHkoZHJpdmVyX2luZm8uaG9zdF9tYWNoaW5lX25hbWUsIGhvc3RfbmFtZSwKKwkJCXNpemVvZihkcml2ZXJfaW5mby5ob3N0X21hY2hpbmVfbmFtZSkgLSAxKTsKKwlpZiAob3NfbmFtZSkKKwkJc3RybmNweShkcml2ZXJfaW5mby5ob3N0X29zX25hbWUsIG9zX25hbWUsCisJCQlzaXplb2YoZHJpdmVyX2luZm8uaG9zdF9vc19uYW1lKSAtIDEpOworCWlmIChvc19wYXRjaCkKKwkJc3RybmNweShkcml2ZXJfaW5mby5ob3N0X29zX3BhdGNoLCBvc19wYXRjaCwKKwkJCXNpemVvZihkcml2ZXJfaW5mby5ob3N0X29zX3BhdGNoKSAtIDEpOworCisJc3RybmNweShkcml2ZXJfaW5mby5vc19kZXZpY2VfbmFtZSwgYmZhZC0+cGNpX25hbWUsCisJCXNpemVvZihkcml2ZXJfaW5mby5vc19kZXZpY2VfbmFtZSAtIDEpKTsKKworCS8qCisJICogRkNTIElOSVQKKwkgKi8KKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJYmZhX2Zjc19sb2dfaW5pdCgmYmZhZC0+YmZhX2ZjcywgYmZhZC0+bG9nbW9kKTsKKwliZmFfZmNzX3RyY19pbml0KCZiZmFkLT5iZmFfZmNzLCBiZmFkLT50cmNtb2QpOworCWJmYV9mY3NfYWVuX2luaXQoJmJmYWQtPmJmYV9mY3MsIGJmYWQtPmFlbik7CisJYmZhX2Zjc19pbml0KCZiZmFkLT5iZmFfZmNzLCAmYmZhZC0+YmZhLCBiZmFkLCBCRkFfRkFMU0UpOworCWJmYV9mY3NfZHJpdmVyX2luZm9faW5pdCgmYmZhZC0+YmZhX2ZjcywgJmRyaXZlcl9pbmZvKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCWJmYWQtPmJmYWRfZmxhZ3MgfD0gQkZBRF9EUlZfSU5JVF9ET05FOworCXJldHVybiBCRkFfU1RBVFVTX09LOworCitvdXRfc2V0dXBfaW50cl9mYWlsdXJlOgorCWJmYV9kZXRhY2goJmJmYWQtPmJmYSk7CisJYmZhZF9oYWxfbWVtX3JlbGVhc2UoYmZhZCk7CitvdXRfaGFsX21lbV9hbGxvY19mYWlsdXJlOgorCXJldHVybiBCRkFfU1RBVFVTX0ZBSUxFRDsKK30KKwordm9pZAorYmZhZF9kcnZfdW5pbml0KHN0cnVjdCBiZmFkX3MgKmJmYWQpCit7CisJZGVsX3RpbWVyX3N5bmMoJmJmYWQtPmhhbF90bW8pOworCWJmYV9pc3JfZGlzYWJsZSgmYmZhZC0+YmZhKTsKKwliZmFfZGV0YWNoKCZiZmFkLT5iZmEpOworCWJmYWRfcmVtb3ZlX2ludHIoYmZhZCk7CisJYmZhX2Fzc2VydChsaXN0X2VtcHR5KCZiZmFkLT5maWxlX3EpKTsKKwliZmFkX2hhbF9tZW1fcmVsZWFzZShiZmFkKTsKK30KKwordm9pZAorYmZhZF9kcnZfc3RhcnQoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJYmZhX3N0YXJ0KCZiZmFkLT5iZmEpOworCWJmYV9mY3Nfc3RhcnQoJmJmYWQtPmJmYV9mY3MpOworCWJmYWQtPmJmYWRfZmxhZ3MgfD0gQkZBRF9IQUxfU1RBUlRfRE9ORTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCWJmYWRfZmM0X3Byb2JlX3Bvc3QoYmZhZCk7Cit9CisKK3ZvaWQKK2JmYWRfZHJ2X3N0b3Aoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJaW5pdF9jb21wbGV0aW9uKCZiZmFkLT5jb21wKTsKKwliZmFkLT5wcG9ydC5mbGFncyB8PSBCRkFEX1BPUlRfREVMRVRFOworCWJmYV9mY3NfZXhpdCgmYmZhZC0+YmZhX2Zjcyk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJd2FpdF9mb3JfY29tcGxldGlvbigmYmZhZC0+Y29tcCk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJaW5pdF9jb21wbGV0aW9uKCZiZmFkLT5jb21wKTsKKwliZmFfc3RvcCgmYmZhZC0+YmZhKTsKKwliZmFkLT5iZmFkX2ZsYWdzICY9IH5CRkFEX0hBTF9TVEFSVF9ET05FOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCXdhaXRfZm9yX2NvbXBsZXRpb24oJmJmYWQtPmNvbXApOworfQorCitiZmFfc3RhdHVzX3QKK2JmYWRfY2ZnX3Bwb3J0KHN0cnVjdCBiZmFkX3MgKmJmYWQsIGVudW0gYmZhX3BvcnRfcm9sZSByb2xlKQoreworCWludCAgICAgICAgICAgICByYyA9IEJGQV9TVEFUVVNfT0s7CisKKwkvKgorCSAqIEFsbG9jYXRlIHNjc2lfaG9zdCBmb3IgdGhlIHBoeXNpY2FsIHBvcnQKKwkgKi8KKwlpZiAoKGJmYWRfc3VwcG9ydGVkX2ZjNHMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9JTSkKKwkgICAgJiYgKHJvbGUgJiBCRkFfUE9SVF9ST0xFX0ZDUF9JTSkpIHsKKwkJaWYgKGJmYWQtPnBwb3J0LmltX3BvcnQgPT0gTlVMTCkgeworCQkJcmMgPSBCRkFfU1RBVFVTX0ZBSUxFRDsKKwkJCWdvdG8gb3V0OworCQl9CisKKwkJcmMgPSBiZmFkX2ltX3Njc2lfaG9zdF9hbGxvYyhiZmFkLCBiZmFkLT5wcG9ydC5pbV9wb3J0KTsKKwkJaWYgKHJjICE9IEJGQV9TVEFUVVNfT0spCisJCQlnb3RvIG91dDsKKworCQliZmFkLT5wcG9ydC5yb2xlcyB8PSBCRkFfUE9SVF9ST0xFX0ZDUF9JTTsKKwl9CisKKwliZmFkLT5iZmFkX2ZsYWdzIHw9IEJGQURfQ0ZHX1BQT1JUX0RPTkU7CisKK291dDoKKwlyZXR1cm4gcmM7Cit9CisKK3ZvaWQKK2JmYWRfdW5jZmdfcHBvcnQoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlpZiAoKGJmYWQtPnBwb3J0LnJvbGVzICYgQkZBX1BPUlRfUk9MRV9GQ1BfSVBGQykgJiYgaXBmY19lbmFibGUpIHsKKwkJYmZhZF9pcGZjX3BvcnRfZGVsZXRlKGJmYWQsICZiZmFkLT5wcG9ydCk7CisJCWJmYWQtPnBwb3J0LnJvbGVzICY9IH5CRkFfUE9SVF9ST0xFX0ZDUF9JUEZDOworCX0KKworCWlmICgoYmZhZF9zdXBwb3J0ZWRfZmM0cyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lNKQorCSAgICAmJiAoYmZhZC0+cHBvcnQucm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9JTSkpIHsKKwkJYmZhZF9pbV9zY3NpX2hvc3RfZnJlZShiZmFkLCBiZmFkLT5wcG9ydC5pbV9wb3J0KTsKKwkJYmZhZF9pbV9wb3J0X2NsZWFuKGJmYWQtPnBwb3J0LmltX3BvcnQpOworCQlrZnJlZShiZmFkLT5wcG9ydC5pbV9wb3J0KTsKKwkJYmZhZC0+cHBvcnQucm9sZXMgJj0gfkJGQV9QT1JUX1JPTEVfRkNQX0lNOworCX0KKworCWJmYWQtPmJmYWRfZmxhZ3MgJj0gfkJGQURfQ0ZHX1BQT1JUX0RPTkU7Cit9CisKK3ZvaWQKK2JmYWRfZHJ2X2xvZ19sZXZlbF9zZXQoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlpZiAobG9nX2xldmVsID4gQkZBX0xPR19JTlZBTElEICYmIGxvZ19sZXZlbCA8PSBCRkFfTE9HX0xFVkVMX01BWCkKKwkJYmZhX2xvZ19zZXRfbGV2ZWxfYWxsKCZiZmFkLT5sb2dfZGF0YSwgbG9nX2xldmVsKTsKK30KKworIC8qCisgICogIFBDSV9lbnRyeSBQQ0kgZHJpdmVyIGVudHJpZXMgKiB7CisgICovCisKKy8qKgorICogUENJIHByb2JlIGVudHJ5LgorICovCitpbnQKK2JmYWRfcGNpX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqcGlkKQoreworCXN0cnVjdCBiZmFkX3MgICpiZmFkOworCWludCAgICAgICAgICAgICBlcnJvciA9IC1FTk9ERVYsIHJldHZhbDsKKwljaGFyICAgICAgICAgICAgYnVmWzE2XTsKKworCS8qCisJICogRm9yIHNpbmdsZSBwb3J0IGNhcmRzIC0gb25seSBjbGFpbSBmdW5jdGlvbiAwCisJICovCisJaWYgKChwZGV2LT5kZXZpY2UgPT0gQkZBX1BDSV9ERVZJQ0VfSURfRkNfOEcxUCkKKwkgICAgJiYgKFBDSV9GVU5DKHBkZXYtPmRldmZuKSAhPSAwKSkKKwkJcmV0dXJuIC1FTk9ERVY7CisKKwlCRkFfVFJBQ0UoQkZBX0lORk8sICJiZmFkX3BjaV9wcm9iZSBlbnRyeSIpOworCisJYmZhZCA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBiZmFkX3MpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWJmYWQpIHsKKwkJZXJyb3IgPSAtRU5PTUVNOworCQlnb3RvIG91dDsKKwl9CisKKwliZmFkLT50cmNtb2QgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgYmZhX3RyY19tb2RfcyksIEdGUF9LRVJORUwpOworCWlmICghYmZhZC0+dHJjbW9kKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgIkVycm9yIGFsbG9jIHRyYWNlIGJ1ZmZlciFcbiIpOworCQllcnJvciA9IC1FTk9NRU07CisJCWdvdG8gb3V0X2FsbG9jX3RyYWNlX2ZhaWx1cmU7CisJfQorCisJLyoKKwkgKiBMT0cvVFJBQ0UgSU5JVAorCSAqLworCWJmYV90cmNfaW5pdChiZmFkLT50cmNtb2QpOworCWJmYV90cmMoYmZhZCwgYmZhZF9pbnN0KTsKKworCWJmYWQtPmxvZ21vZCA9ICZiZmFkLT5sb2dfZGF0YTsKKwlzcHJpbnRmKGJ1ZiwgIiVkIiwgYmZhZF9pbnN0KTsKKwliZmFfbG9nX2luaXQoYmZhZC0+bG9nbW9kLCBidWYsIGJmYV9vc19wcmludGYpOworCisJYmZhZF9kcnZfbG9nX2xldmVsX3NldChiZmFkKTsKKworCWJmYWQtPmFlbiA9ICZiZmFkLT5hZW5fYnVmOworCisJaWYgKCEoYmZhZF9sb2FkX2Z3aW1nKHBkZXYpKSkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJiZmFkX2xvYWRfZndpbWcgZmFpbHVyZSFcbiIpOworCQlrZnJlZShiZmFkLT50cmNtb2QpOworCQlnb3RvIG91dF9hbGxvY190cmFjZV9mYWlsdXJlOworCX0KKworCXJldHZhbCA9IGJmYWRfcGNpX2luaXQocGRldiwgYmZhZCk7CisJaWYgKHJldHZhbCkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJiZmFkX3BjaV9pbml0IGZhaWx1cmUhXG4iKTsKKwkJZXJyb3IgPSByZXR2YWw7CisJCWdvdG8gb3V0X3BjaV9pbml0X2ZhaWx1cmU7CisJfQorCisJbXV0ZXhfbG9jaygmYmZhZF9tdXRleCk7CisJYmZhZC0+aW5zdF9ubyA9IGJmYWRfaW5zdCsrOworCWxpc3RfYWRkX3RhaWwoJmJmYWQtPmxpc3RfZW50cnksICZiZmFkX2xpc3QpOworCW11dGV4X3VubG9jaygmYmZhZF9tdXRleCk7CisKKwlzcGluX2xvY2tfaW5pdCgmYmZhZC0+YmZhZF9sb2NrKTsKKwlwY2lfc2V0X2RydmRhdGEocGRldiwgYmZhZCk7CisKKwliZmFkLT5yZWZfY291bnQgPSAwOworCWJmYWQtPnBwb3J0LmJmYWQgPSBiZmFkOworCisJcmV0dmFsID0gYmZhZF9kcnZfaW5pdChiZmFkKTsKKwlpZiAocmV0dmFsICE9IEJGQV9TVEFUVVNfT0spCisJCWdvdG8gb3V0X2Rydl9pbml0X2ZhaWx1cmU7CisJaWYgKCEoYmZhZC0+YmZhZF9mbGFncyAmIEJGQURfSEFMX0lOSVRfRE9ORSkpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiYmZhZCVkOiBoYWwgaW5pdCBmYWlsZWRcbiIsIGJmYWQtPmluc3Rfbm8pOworCQlnb3RvIG9rOworCX0KKworCS8qCisJICogUFBPUlQgRkNTIGNvbmZpZworCSAqLworCWJmYWRfZmNzX3BvcnRfY2ZnKGJmYWQpOworCisJcmV0dmFsID0gYmZhZF9jZmdfcHBvcnQoYmZhZCwgQkZBX1BPUlRfUk9MRV9GQ1BfSU0pOworCWlmIChyZXR2YWwgIT0gQkZBX1NUQVRVU19PSykKKwkJZ290byBvdXRfY2ZnX3Bwb3J0X2ZhaWx1cmU7CisKKwkvKgorCSAqIEJGQUQgbGV2ZWwgRkM0IChJTS9UTS9JUEZDKSBzcGVjaWZpYyByZXNvdXJjZSBhbGxvY2F0aW9uCisJICovCisJcmV0dmFsID0gYmZhZF9mYzRfcHJvYmUoYmZhZCk7CisJaWYgKHJldHZhbCAhPSBCRkFfU1RBVFVTX09LKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgImJmYWRfZmM0X3Byb2JlIGZhaWxlZFxuIik7CisJCWdvdG8gb3V0X2ZjNF9wcm9iZV9mYWlsdXJlOworCX0KKworCWJmYWRfZHJ2X3N0YXJ0KGJmYWQpOworCisJLyoKKwkgKiBJZiBiZmFfbGlua3VwX2RlbGF5IGlzIHNldCB0byAtMSBkZWZhdWx0OyB0cnkgdG8gcmV0cml2ZSB0aGUKKwkgKiB2YWx1ZSB1c2luZyB0aGUgYmZhZF9vc19nZXRfbGlua3VwX2RlbGF5KCk7IGVsc2UgdXNlIHRoZQorCSAqIHBhc3NlZCBpbiBtb2R1bGUgcGFyYW0gdmFsdWUgYXMgdGhlIGJmYV9saW5rdXBfZGVsYXkuCisJICovCisJaWYgKGJmYV9saW5rdXBfZGVsYXkgPCAwKSB7CisJCWJmYV9saW5rdXBfZGVsYXkgPSBiZmFkX29zX2dldF9saW5rdXBfZGVsYXkoYmZhZCk7CisJCWJmYWRfb3NfcnBvcnRfb25saW5lX3dhaXQoYmZhZCk7CisJCWJmYV9saW5rdXBfZGVsYXkgPSAtMTsKKwl9IGVsc2UgeworCQliZmFkX29zX3Jwb3J0X29ubGluZV93YWl0KGJmYWQpOworCX0KKworCWJmYV9sb2coYmZhZC0+bG9nbW9kLCBCRkFfTE9HX0xJTlVYX0RFVklDRV9DTEFJTUVELCBiZmFkLT5wY2lfbmFtZSk7CitvazoKKwlyZXR1cm4gMDsKKworb3V0X2ZjNF9wcm9iZV9mYWlsdXJlOgorCWJmYWRfZmM0X3Byb2JlX3VuZG8oYmZhZCk7CisJYmZhZF91bmNmZ19wcG9ydChiZmFkKTsKK291dF9jZmdfcHBvcnRfZmFpbHVyZToKKwliZmFkX2Rydl91bmluaXQoYmZhZCk7CitvdXRfZHJ2X2luaXRfZmFpbHVyZToKKwltdXRleF9sb2NrKCZiZmFkX211dGV4KTsKKwliZmFkX2luc3QtLTsKKwlsaXN0X2RlbCgmYmZhZC0+bGlzdF9lbnRyeSk7CisJbXV0ZXhfdW5sb2NrKCZiZmFkX211dGV4KTsKKwliZmFkX3BjaV91bmluaXQocGRldiwgYmZhZCk7CitvdXRfcGNpX2luaXRfZmFpbHVyZToKKwlrZnJlZShiZmFkLT50cmNtb2QpOworb3V0X2FsbG9jX3RyYWNlX2ZhaWx1cmU6CisJa2ZyZWUoYmZhZCk7CitvdXQ6CisJcmV0dXJuIGVycm9yOworfQorCisvKioKKyAqIFBDSSByZW1vdmUgZW50cnkuCisgKi8KK3ZvaWQKK2JmYWRfcGNpX3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAqcGRldikKK3sKKwlzdHJ1Y3QgYmZhZF9zICAqYmZhZCA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwliZmFfdHJjKGJmYWQsIGJmYWQtPmluc3Rfbm8pOworCisJaWYgKChiZmFkLT5iZmFkX2ZsYWdzICYgQkZBRF9EUlZfSU5JVF9ET05FKQorCSAgICAmJiAhKGJmYWQtPmJmYWRfZmxhZ3MgJiBCRkFEX0hBTF9JTklUX0RPTkUpKSB7CisKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCQlpbml0X2NvbXBsZXRpb24oJmJmYWQtPmNvbXApOworCQliZmFfc3RvcCgmYmZhZC0+YmZhKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJCXdhaXRfZm9yX2NvbXBsZXRpb24oJmJmYWQtPmNvbXApOworCisJCWJmYWRfcmVtb3ZlX2ludHIoYmZhZCk7CisJCWRlbF90aW1lcl9zeW5jKCZiZmFkLT5oYWxfdG1vKTsKKwkJZ290byBoYWxfZGV0YWNoOworCX0gZWxzZSBpZiAoIShiZmFkLT5iZmFkX2ZsYWdzICYgQkZBRF9EUlZfSU5JVF9ET05FKSkgeworCQlnb3RvIHJlbW92ZV9zeXNmczsKKwl9CisKKwlpZiAoYmZhZC0+YmZhZF9mbGFncyAmIEJGQURfSEFMX1NUQVJUX0RPTkUpCisJCWJmYWRfZHJ2X3N0b3AoYmZhZCk7CisKKwliZmFkX3JlbW92ZV9pbnRyKGJmYWQpOworCisJZGVsX3RpbWVyX3N5bmMoJmJmYWQtPmhhbF90bW8pOworCWJmYWRfZmM0X3Byb2JlX3VuZG8oYmZhZCk7CisKKwlpZiAoYmZhZC0+YmZhZF9mbGFncyAmIEJGQURfQ0ZHX1BQT1JUX0RPTkUpCisJCWJmYWRfdW5jZmdfcHBvcnQoYmZhZCk7CisKK2hhbF9kZXRhY2g6CisJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCWJmYV9kZXRhY2goJmJmYWQtPmJmYSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJYmZhZF9oYWxfbWVtX3JlbGVhc2UoYmZhZCk7CityZW1vdmVfc3lzZnM6CisKKwltdXRleF9sb2NrKCZiZmFkX211dGV4KTsKKwliZmFkX2luc3QtLTsKKwlsaXN0X2RlbCgmYmZhZC0+bGlzdF9lbnRyeSk7CisJbXV0ZXhfdW5sb2NrKCZiZmFkX211dGV4KTsKKwliZmFkX3BjaV91bmluaXQocGRldiwgYmZhZCk7CisKKwlrZnJlZShiZmFkLT50cmNtb2QpOworCWtmcmVlKGJmYWQpOworfQorCisKK3N0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCBiZmFkX2lkX3RhYmxlW10gPSB7CisJeworCSAudmVuZG9yID0gQkZBX1BDSV9WRU5ET1JfSURfQlJPQ0FERSwKKwkgLmRldmljZSA9IEJGQV9QQ0lfREVWSUNFX0lEX0ZDXzhHMlAsCisJIC5zdWJ2ZW5kb3IgPSBQQ0lfQU5ZX0lELAorCSAuc3ViZGV2aWNlID0gUENJX0FOWV9JRCwKKwkgfSwKKwl7CisJIC52ZW5kb3IgPSBCRkFfUENJX1ZFTkRPUl9JRF9CUk9DQURFLAorCSAuZGV2aWNlID0gQkZBX1BDSV9ERVZJQ0VfSURfRkNfOEcxUCwKKwkgLnN1YnZlbmRvciA9IFBDSV9BTllfSUQsCisJIC5zdWJkZXZpY2UgPSBQQ0lfQU5ZX0lELAorCSB9LAorCXsKKwkgLnZlbmRvciA9IEJGQV9QQ0lfVkVORE9SX0lEX0JST0NBREUsCisJIC5kZXZpY2UgPSBCRkFfUENJX0RFVklDRV9JRF9DVCwKKwkgLnN1YnZlbmRvciA9IFBDSV9BTllfSUQsCisJIC5zdWJkZXZpY2UgPSBQQ0lfQU5ZX0lELAorCSAuY2xhc3MgPSAoUENJX0NMQVNTX1NFUklBTF9GSUJFUiA8PCA4KSwKKwkgLmNsYXNzX21hc2sgPSB+MCwKKwkgfSwKKworCXswLCAwfSwKK307CisKK01PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBiZmFkX2lkX3RhYmxlKTsKKworc3RhdGljIHN0cnVjdCBwY2lfZHJpdmVyIGJmYWRfcGNpX2RyaXZlciA9IHsKKwkubmFtZSA9IEJGQURfRFJJVkVSX05BTUUsCisJLmlkX3RhYmxlID0gYmZhZF9pZF90YWJsZSwKKwkucHJvYmUgPSBiZmFkX3BjaV9wcm9iZSwKKwkucmVtb3ZlID0gX19kZXZleGl0X3AoYmZhZF9wY2lfcmVtb3ZlKSwKK307CisKKy8qKgorICogIExpbnV4IGRyaXZlciBtb2R1bGUgZnVuY3Rpb25zCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhZF9mYzRfbW9kdWxlX2luaXQodm9pZCkKK3sKKwlpbnQgICAgICAgICAgICAgcmM7CisKKwlyYyA9IGJmYWRfaW1fbW9kdWxlX2luaXQoKTsKKwlpZiAocmMgIT0gQkZBX1NUQVRVU19PSykKKwkJZ290byBleHQ7CisKKwliZmFkX3RtX21vZHVsZV9pbml0KCk7CisJaWYgKGlwZmNfZW5hYmxlKQorCQliZmFkX2lwZmNfbW9kdWxlX2luaXQoKTsKK2V4dDoKKwlyZXR1cm4gcmM7Cit9CisKK3ZvaWQKK2JmYWRfZmM0X21vZHVsZV9leGl0KHZvaWQpCit7CisJaWYgKGlwZmNfZW5hYmxlKQorCQliZmFkX2lwZmNfbW9kdWxlX2V4aXQoKTsKKwliZmFkX3RtX21vZHVsZV9leGl0KCk7CisJYmZhZF9pbV9tb2R1bGVfZXhpdCgpOworfQorCisvKioKKyAqIERyaXZlciBtb2R1bGUgaW5pdC4KKyAqLworc3RhdGljIGludCAgICAgIF9faW5pdAorYmZhZF9pbml0KHZvaWQpCit7CisJaW50ICAgICAgICAgICAgIGVycm9yID0gMDsKKworCXByaW50ayhLRVJOX0lORk8gIkJyb2NhZGUgQkZBIEZDL0ZDT0UgU0NTSSBkcml2ZXIgLSB2ZXJzaW9uOiAlc1xuIiwKKwkgICAgICAgQkZBRF9EUklWRVJfVkVSU0lPTik7CisKKwlpZiAobnVtX3NncGdzID4gMCkKKwkJbnVtX3NncGdzX3Bhcm0gPSBudW1fc2dwZ3M7CisKKwllcnJvciA9IGJmYWRfZmM0X21vZHVsZV9pbml0KCk7CisJaWYgKGVycm9yKSB7CisJCWVycm9yID0gLUVOT01FTTsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiYmZhZF9mYzRfbW9kdWxlX2luaXQgZmFpbHVyZVxuIik7CisJCWdvdG8gZXh0OworCX0KKworCWlmICghc3RyY21wKEZDUElfTkFNRSwgIiBmY3BpbSIpKQorCQliZmFkX3N1cHBvcnRlZF9mYzRzIHw9IEJGQV9QT1JUX1JPTEVfRkNQX0lNOworCWlmICghc3RyY21wKEZDUFRfTkFNRSwgIiBmY3B0bSIpKQorCQliZmFkX3N1cHBvcnRlZF9mYzRzIHw9IEJGQV9QT1JUX1JPTEVfRkNQX1RNOworCWlmICghc3RyY21wKElQRkNfTkFNRSwgIiBpcGZjIikpCisJCWJmYWRfc3VwcG9ydGVkX2ZjNHMgfD0gQkZBX1BPUlRfUk9MRV9GQ1BfSVBGQzsKKworCWJmYV9pb2NfYXV0b19yZWNvdmVyKGlvY19hdXRvX3JlY292ZXIpOworCWJmYV9mY3NfcnBvcnRfc2V0X2RlbF90aW1lb3V0KHJwb3J0X2RlbF90aW1lb3V0KTsKKwllcnJvciA9IHBjaV9yZWdpc3Rlcl9kcml2ZXIoJmJmYWRfcGNpX2RyaXZlcik7CisKKwlpZiAoZXJyb3IpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiYmZhZCBwY2lfcmVnaXN0ZXJfZHJpdmVyIGZhaWx1cmVcbiIpOworCQlnb3RvIGV4dDsKKwl9CisKKwlyZXR1cm4gMDsKKworZXh0OgorCWJmYWRfZmM0X21vZHVsZV9leGl0KCk7CisJcmV0dXJuIGVycm9yOworfQorCisvKioKKyAqIERyaXZlciBtb2R1bGUgZXhpdC4KKyAqLworc3RhdGljIHZvaWQgICAgIF9fZXhpdAorYmZhZF9leGl0KHZvaWQpCit7CisJcGNpX3VucmVnaXN0ZXJfZHJpdmVyKCZiZmFkX3BjaV9kcml2ZXIpOworCWJmYWRfZmM0X21vZHVsZV9leGl0KCk7CisJYmZhZF9mcmVlX2Z3aW1nKCk7Cit9CisKKyNkZWZpbmUgQkZBRF9QUk9UT19OQU1FIEZDUElfTkFNRSBGQ1BUX05BTUUgSVBGQ19OQU1FCisKK21vZHVsZV9pbml0KGJmYWRfaW5pdCk7Cittb2R1bGVfZXhpdChiZmFkX2V4aXQpOworTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOworTU9EVUxFX0RFU0NSSVBUSU9OKCJCcm9jYWRlIEZpYnJlIENoYW5uZWwgSEJBIERyaXZlciIgQkZBRF9QUk9UT19OQU1FKTsKK01PRFVMRV9BVVRIT1IoIkJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLiIpOworTU9EVUxFX1ZFUlNJT04oQkZBRF9EUklWRVJfVkVSU0lPTik7CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2F0dHIuYyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9hdHRyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTEyOWFlMwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9hdHRyLmMKQEAgLTAsMCArMSw2NDkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2F0dHIuYyBMaW51eCBkcml2ZXIgY29uZmlndXJhdGlvbiBpbnRlcmZhY2UgbW9kdWxlLgorICovCisKKyNpbmNsdWRlICJiZmFkX2Rydi5oIgorI2luY2x1ZGUgImJmYWRfaW0uaCIKKyNpbmNsdWRlICJiZmFkX3RyY21vZC5oIgorI2luY2x1ZGUgImJmYWRfYXR0ci5oIgorCisvKioKKyAqICBGQ190cmFuc3BvcnRfdGVtcGxhdGUgRkMgdHJhbnNwb3J0IHRlbXBsYXRlCisgKi8KKworLyoqCisgKiBGQyB0cmFuc3BvcnQgdGVtcGxhdGUgZW50cnksIGdldCBTQ1NJIHRhcmdldCBwb3J0IElELgorICovCit2b2lkCitiZmFkX2ltX2dldF9zdGFyZ2V0X3BvcnRfaWQoc3RydWN0IHNjc2lfdGFyZ2V0ICpzdGFyZ2V0KQoreworCXN0cnVjdCBTY3NpX0hvc3QgKnNob3N0OworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydDsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQ7CisJc3RydWN0IGJmYWRfaXRuaW1fcyAgICppdG5pbSA9IE5VTEw7CisJdTMyICAgICAgICBmY19pZCA9IC0xOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKworCXNob3N0ID0gYmZhZF9vc19zdGFyZ2V0X3RvX3Nob3N0KHN0YXJnZXQpOworCWltX3BvcnQgPSAoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwliZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisKKwlpdG5pbSA9IGJmYWRfb3NfZ2V0X2l0bmltKGltX3BvcnQsIHN0YXJnZXQtPmlkKTsKKwlpZiAoaXRuaW0pCisJCWZjX2lkID0gYmZhX2Zjc19pdG5pbV9nZXRfZmNpZCgmaXRuaW0tPmZjc19pdG5pbSk7CisKKwlmY19zdGFyZ2V0X3BvcnRfaWQoc3RhcmdldCkgPSBmY19pZDsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKK30KKworLyoqCisgKiBGQyB0cmFuc3BvcnQgdGVtcGxhdGUgZW50cnksIGdldCBTQ1NJIHRhcmdldCBud3duLgorICovCit2b2lkCitiZmFkX2ltX2dldF9zdGFyZ2V0X25vZGVfbmFtZShzdHJ1Y3Qgc2NzaV90YXJnZXQgKnN0YXJnZXQpCit7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3Q7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0OworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZDsKKwlzdHJ1Y3QgYmZhZF9pdG5pbV9zICAgKml0bmltID0gTlVMTDsKKwl1NjQgICAgICAgICAgICAgbm9kZV9uYW1lID0gMDsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwlzaG9zdCA9IGJmYWRfb3Nfc3RhcmdldF90b19zaG9zdChzdGFyZ2V0KTsKKwlpbV9wb3J0ID0gKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCisJaXRuaW0gPSBiZmFkX29zX2dldF9pdG5pbShpbV9wb3J0LCBzdGFyZ2V0LT5pZCk7CisJaWYgKGl0bmltKQorCQlub2RlX25hbWUgPSBiZmFfZmNzX2l0bmltX2dldF9ud3duKCZpdG5pbS0+ZmNzX2l0bmltKTsKKworCWZjX3N0YXJnZXRfbm9kZV9uYW1lKHN0YXJnZXQpID0gYmZhX29zX2h0b25sbChub2RlX25hbWUpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworfQorCisvKioKKyAqIEZDIHRyYW5zcG9ydCB0ZW1wbGF0ZSBlbnRyeSwgZ2V0IFNDU0kgdGFyZ2V0IHB3d24uCisgKi8KK3ZvaWQKK2JmYWRfaW1fZ2V0X3N0YXJnZXRfcG9ydF9uYW1lKHN0cnVjdCBzY3NpX3RhcmdldCAqc3RhcmdldCkKK3sKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdDsKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQ7CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkOworCXN0cnVjdCBiZmFkX2l0bmltX3MgICAqaXRuaW0gPSBOVUxMOworCXU2NCAgICAgICAgICAgICBwb3J0X25hbWUgPSAwOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKworCXNob3N0ID0gYmZhZF9vc19zdGFyZ2V0X3RvX3Nob3N0KHN0YXJnZXQpOworCWltX3BvcnQgPSAoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwliZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisKKwlpdG5pbSA9IGJmYWRfb3NfZ2V0X2l0bmltKGltX3BvcnQsIHN0YXJnZXQtPmlkKTsKKwlpZiAoaXRuaW0pCisJCXBvcnRfbmFtZSA9IGJmYV9mY3NfaXRuaW1fZ2V0X3B3d24oJml0bmltLT5mY3NfaXRuaW0pOworCisJZmNfc3RhcmdldF9wb3J0X25hbWUoc3RhcmdldCkgPSBiZmFfb3NfaHRvbmxsKHBvcnRfbmFtZSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7Cit9CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBnZXQgU0NTSSBob3N0IHBvcnQgSUQuCisgKi8KK3ZvaWQKK2JmYWRfaW1fZ2V0X2hvc3RfcG9ydF9pZChzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCkKK3sKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcG9ydF9zICAgICpwb3J0ID0gaW1fcG9ydC0+cG9ydDsKKworCWZjX2hvc3RfcG9ydF9pZChzaG9zdCkgPQorCQkJYmZhX29zX2h0b24zYihiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydC0+ZmNzX3BvcnQpKTsKK30KKworCisKKworCitzdHJ1Y3QgU2NzaV9Ib3N0ICoKK2JmYWRfb3Nfc3RhcmdldF90b19zaG9zdChzdHJ1Y3Qgc2NzaV90YXJnZXQgKnN0YXJnZXQpCit7CisJcmV0dXJuIGRldl90b19zaG9zdChzdGFyZ2V0LT5kZXYucGFyZW50KTsKK30KKworLyoqCisgKiBGQyB0cmFuc3BvcnQgdGVtcGxhdGUgZW50cnksIGdldCBTQ1NJIGhvc3QgcG9ydCB0eXBlLgorICovCitzdGF0aWMgdm9pZAorYmZhZF9pbV9nZXRfaG9zdF9wb3J0X3R5cGUoc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QpCit7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJc3RydWN0IGJmYV9wcG9ydF9hdHRyX3MgYXR0cjsKKworCWJmYV9wcG9ydF9nZXRfYXR0cigmYmZhZC0+YmZhLCAmYXR0cik7CisKKwlzd2l0Y2ggKGF0dHIucG9ydF90eXBlKSB7CisJY2FzZSBCRkFfUFBPUlRfVFlQRV9OUE9SVDoKKwkJZmNfaG9zdF9wb3J0X3R5cGUoc2hvc3QpID0gRkNfUE9SVFRZUEVfTlBPUlQ7CisJCWJyZWFrOworCWNhc2UgQkZBX1BQT1JUX1RZUEVfTkxQT1JUOgorCQlmY19ob3N0X3BvcnRfdHlwZShzaG9zdCkgPSBGQ19QT1JUVFlQRV9OTFBPUlQ7CisJCWJyZWFrOworCWNhc2UgQkZBX1BQT1JUX1RZUEVfUDJQOgorCQlmY19ob3N0X3BvcnRfdHlwZShzaG9zdCkgPSBGQ19QT1JUVFlQRV9QVFA7CisJCWJyZWFrOworCWNhc2UgQkZBX1BQT1JUX1RZUEVfTFBPUlQ6CisJCWZjX2hvc3RfcG9ydF90eXBlKHNob3N0KSA9IEZDX1BPUlRUWVBFX0xQT1JUOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlmY19ob3N0X3BvcnRfdHlwZShzaG9zdCkgPSBGQ19QT1JUVFlQRV9VTktOT1dOOworCQlicmVhazsKKwl9Cit9CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBnZXQgU0NTSSBob3N0IHBvcnQgc3RhdGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFkX2ltX2dldF9ob3N0X3BvcnRfc3RhdGUoc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QpCit7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJc3RydWN0IGJmYV9wcG9ydF9hdHRyX3MgYXR0cjsKKworCWJmYV9wcG9ydF9nZXRfYXR0cigmYmZhZC0+YmZhLCAmYXR0cik7CisKKwlzd2l0Y2ggKGF0dHIucG9ydF9zdGF0ZSkgeworCWNhc2UgQkZBX1BQT1JUX1NUX0xJTktET1dOOgorCQlmY19ob3N0X3BvcnRfc3RhdGUoc2hvc3QpID0gRkNfUE9SVFNUQVRFX0xJTktET1dOOworCQlicmVhazsKKwljYXNlIEJGQV9QUE9SVF9TVF9MSU5LVVA6CisJCWZjX2hvc3RfcG9ydF9zdGF0ZShzaG9zdCkgPSBGQ19QT1JUU1RBVEVfT05MSU5FOworCQlicmVhazsKKwljYXNlIEJGQV9QUE9SVF9TVF9VTklOSVQ6CisJY2FzZSBCRkFfUFBPUlRfU1RfRU5BQkxJTkdfUVdBSVQ6CisJY2FzZSBCRkFfUFBPUlRfU1RfRU5BQkxJTkc6CisJY2FzZSBCRkFfUFBPUlRfU1RfRElTQUJMSU5HX1FXQUlUOgorCWNhc2UgQkZBX1BQT1JUX1NUX0RJU0FCTElORzoKKwljYXNlIEJGQV9QUE9SVF9TVF9ESVNBQkxFRDoKKwljYXNlIEJGQV9QUE9SVF9TVF9TVE9QUEVEOgorCWNhc2UgQkZBX1BQT1JUX1NUX0lPQ0RPV046CisJZGVmYXVsdDoKKwkJZmNfaG9zdF9wb3J0X3N0YXRlKHNob3N0KSA9IEZDX1BPUlRTVEFURV9VTktOT1dOOworCQlicmVhazsKKwl9Cit9CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBnZXQgU0NTSSBob3N0IGFjdGl2ZSBmYzRzLgorICovCitzdGF0aWMgdm9pZAorYmZhZF9pbV9nZXRfaG9zdF9hY3RpdmVfZmM0cyhzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCkKK3sKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcG9ydF9zICAgICpwb3J0ID0gaW1fcG9ydC0+cG9ydDsKKworCW1lbXNldChmY19ob3N0X2FjdGl2ZV9mYzRzKHNob3N0KSwgMCwKKwkgICAgICAgc2l6ZW9mKGZjX2hvc3RfYWN0aXZlX2ZjNHMoc2hvc3QpKSk7CisKKwlpZiAocG9ydC0+c3VwcG9ydGVkX2ZjNHMgJgorCQkoQkZBX1BPUlRfUk9MRV9GQ1BfSU0gfCBCRkFfUE9SVF9ST0xFX0ZDUF9UTSkpCisJCWZjX2hvc3RfYWN0aXZlX2ZjNHMoc2hvc3QpWzJdID0gMTsKKworCWlmIChwb3J0LT5zdXBwb3J0ZWRfZmM0cyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lQRkMpCisJCWZjX2hvc3RfYWN0aXZlX2ZjNHMoc2hvc3QpWzNdID0gMHgyMDsKKworCWZjX2hvc3RfYWN0aXZlX2ZjNHMoc2hvc3QpWzddID0gMTsKK30KKworLyoqCisgKiBGQyB0cmFuc3BvcnQgdGVtcGxhdGUgZW50cnksIGdldCBTQ1NJIGhvc3QgbGluayBzcGVlZC4KKyAqLworc3RhdGljIHZvaWQKK2JmYWRfaW1fZ2V0X2hvc3Rfc3BlZWQoc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QpCit7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJc3RydWN0IGJmYV9wcG9ydF9hdHRyX3MgYXR0cjsKKworCWJmYV9wcG9ydF9nZXRfYXR0cigmYmZhZC0+YmZhLCAmYXR0cik7CisJc3dpdGNoIChhdHRyLnNwZWVkKSB7CisJY2FzZSBCRkFfUFBPUlRfU1BFRURfOEdCUFM6CisJCWZjX2hvc3Rfc3BlZWQoc2hvc3QpID0gRkNfUE9SVFNQRUVEXzhHQklUOworCQlicmVhazsKKwljYXNlIEJGQV9QUE9SVF9TUEVFRF80R0JQUzoKKwkJZmNfaG9zdF9zcGVlZChzaG9zdCkgPSBGQ19QT1JUU1BFRURfNEdCSVQ7CisJCWJyZWFrOworCWNhc2UgQkZBX1BQT1JUX1NQRUVEXzJHQlBTOgorCQlmY19ob3N0X3NwZWVkKHNob3N0KSA9IEZDX1BPUlRTUEVFRF8yR0JJVDsKKwkJYnJlYWs7CisJY2FzZSBCRkFfUFBPUlRfU1BFRURfMUdCUFM6CisJCWZjX2hvc3Rfc3BlZWQoc2hvc3QpID0gRkNfUE9SVFNQRUVEXzFHQklUOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlmY19ob3N0X3NwZWVkKHNob3N0KSA9IEZDX1BPUlRTUEVFRF9VTktOT1dOOworCQlicmVhazsKKwl9Cit9CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBnZXQgU0NTSSBob3N0IHBvcnQgdHlwZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYWRfaW1fZ2V0X2hvc3RfZmFicmljX25hbWUoc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QpCit7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX3BvcnRfcyAgICAqcG9ydCA9IGltX3BvcnQtPnBvcnQ7CisJd3duX3QgICAgICAgICAgIGZhYnJpY19ud3duID0gMDsKKworCWZhYnJpY19ud3duID0gYmZhX2Zjc19wb3J0X2dldF9mYWJyaWNfbmFtZShwb3J0LT5mY3NfcG9ydCk7CisKKwlmY19ob3N0X2ZhYnJpY19uYW1lKHNob3N0KSA9IGJmYV9vc19odG9ubGwoZmFicmljX253d24pOworCit9CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBnZXQgQkZBRCBzdGF0aXN0aWNzLgorICovCitzdGF0aWMgc3RydWN0IGZjX2hvc3Rfc3RhdGlzdGljcyAqCitiZmFkX2ltX2dldF9zdGF0cyhzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCkKK3sKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhZF9oYWxfY29tcCBmY29tcDsKKwlzdHJ1Y3QgZmNfaG9zdF9zdGF0aXN0aWNzICpoc3RhdHM7CisJYmZhX3N0YXR1c190ICAgIHJjOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKworCWhzdGF0cyA9ICZiZmFkLT5saW5rX3N0YXRzOworCWluaXRfY29tcGxldGlvbigmZmNvbXAuY29tcCk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCW1lbXNldChoc3RhdHMsIDAsIHNpemVvZihzdHJ1Y3QgZmNfaG9zdF9zdGF0aXN0aWNzKSk7CisJcmMgPSBiZmFfcHBvcnRfZ2V0X3N0YXRzKCZiZmFkLT5iZmEsCisJCQkJICAgICAodW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKikgaHN0YXRzLAorCQkJCSAgICAgYmZhZF9oY2JfY29tcCwgJmZjb21wKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwlpZiAocmMgIT0gQkZBX1NUQVRVU19PSykKKwkJcmV0dXJuIE5VTEw7CisKKwl3YWl0X2Zvcl9jb21wbGV0aW9uKCZmY29tcC5jb21wKTsKKworCXJldHVybiBoc3RhdHM7Cit9CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCByZXNldCBCRkFEIHN0YXRpc3RpY3MuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFkX2ltX3Jlc2V0X3N0YXRzKHN0cnVjdCBTY3NpX0hvc3QgKnNob3N0KQoreworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCA9CisJCQkoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQgPSBpbV9wb3J0LT5iZmFkOworCXN0cnVjdCBiZmFkX2hhbF9jb21wIGZjb21wOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKwliZmFfc3RhdHVzX3QgICAgcmM7CisKKwlpbml0X2NvbXBsZXRpb24oJmZjb21wLmNvbXApOworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwlyYyA9IGJmYV9wcG9ydF9jbGVhcl9zdGF0cygmYmZhZC0+YmZhLCBiZmFkX2hjYl9jb21wLCAmZmNvbXApOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCisJaWYgKHJjICE9IEJGQV9TVEFUVVNfT0spCisJCXJldHVybjsKKworCXdhaXRfZm9yX2NvbXBsZXRpb24oJmZjb21wLmNvbXApOworCisJcmV0dXJuOworfQorCisvKioKKyAqIEZDIHRyYW5zcG9ydCB0ZW1wbGF0ZSBlbnRyeSwgZ2V0IHJwb3J0IGxvc3MgdGltZW91dC4KKyAqLworc3RhdGljIHZvaWQKK2JmYWRfaW1fZ2V0X3Jwb3J0X2xvc3NfdG1vKHN0cnVjdCBmY19ycG9ydCAqcnBvcnQpCit7CisJc3RydWN0IGJmYWRfaXRuaW1fZGF0YV9zICppdG5pbV9kYXRhID0gcnBvcnQtPmRkX2RhdGE7CisJc3RydWN0IGJmYWRfaXRuaW1fcyAgICppdG5pbSA9IGl0bmltX2RhdGEtPml0bmltOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGl0bmltLT5pbS0+YmZhZDsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJcnBvcnQtPmRldl9sb3NzX3RtbyA9IGJmYV9mY3BpbV9wYXRoX3Rvdl9nZXQoJmJmYWQtPmJmYSk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7Cit9CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBzZXQgcnBvcnQgbG9zcyB0aW1lb3V0LgorICovCitzdGF0aWMgdm9pZAorYmZhZF9pbV9zZXRfcnBvcnRfbG9zc190bW8oc3RydWN0IGZjX3Jwb3J0ICpycG9ydCwgdTMyIHRpbWVvdXQpCit7CisJc3RydWN0IGJmYWRfaXRuaW1fZGF0YV9zICppdG5pbV9kYXRhID0gcnBvcnQtPmRkX2RhdGE7CisJc3RydWN0IGJmYWRfaXRuaW1fcyAgICppdG5pbSA9IGl0bmltX2RhdGEtPml0bmltOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGl0bmltLT5pbS0+YmZhZDsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwlpZiAodGltZW91dCA+IDApIHsKKwkJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCQliZmFfZmNwaW1fcGF0aF90b3Zfc2V0KCZiZmFkLT5iZmEsIHRpbWVvdXQpOworCQlycG9ydC0+ZGV2X2xvc3NfdG1vID0gYmZhX2ZjcGltX3BhdGhfdG92X2dldCgmYmZhZC0+YmZhKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJfQorCit9CisKK3N0cnVjdCBmY19mdW5jdGlvbl90ZW1wbGF0ZSBiZmFkX2ltX2ZjX2Z1bmN0aW9uX3RlbXBsYXRlID0geworCisJLyogVGFyZ2V0IGR5bmFtaWMgYXR0cmlidXRlcyAqLworCS5nZXRfc3RhcmdldF9wb3J0X2lkID0gYmZhZF9pbV9nZXRfc3RhcmdldF9wb3J0X2lkLAorCS5zaG93X3N0YXJnZXRfcG9ydF9pZCA9IDEsCisJLmdldF9zdGFyZ2V0X25vZGVfbmFtZSA9IGJmYWRfaW1fZ2V0X3N0YXJnZXRfbm9kZV9uYW1lLAorCS5zaG93X3N0YXJnZXRfbm9kZV9uYW1lID0gMSwKKwkuZ2V0X3N0YXJnZXRfcG9ydF9uYW1lID0gYmZhZF9pbV9nZXRfc3RhcmdldF9wb3J0X25hbWUsCisJLnNob3dfc3RhcmdldF9wb3J0X25hbWUgPSAxLAorCisJLyogSG9zdCBkeW5hbWljIGF0dHJpYnV0ZSAqLworCS5nZXRfaG9zdF9wb3J0X2lkID0gYmZhZF9pbV9nZXRfaG9zdF9wb3J0X2lkLAorCS5zaG93X2hvc3RfcG9ydF9pZCA9IDEsCisKKwkvKiBIb3N0IGZpeGVkIGF0dHJpYnV0ZXMgKi8KKwkuc2hvd19ob3N0X25vZGVfbmFtZSA9IDEsCisJLnNob3dfaG9zdF9wb3J0X25hbWUgPSAxLAorCS5zaG93X2hvc3Rfc3VwcG9ydGVkX2NsYXNzZXMgPSAxLAorCS5zaG93X2hvc3Rfc3VwcG9ydGVkX2ZjNHMgPSAxLAorCS5zaG93X2hvc3Rfc3VwcG9ydGVkX3NwZWVkcyA9IDEsCisJLnNob3dfaG9zdF9tYXhmcmFtZV9zaXplID0gMSwKKworCS8qIE1vcmUgaG9zdCBkeW5hbWljIGF0dHJpYnV0ZXMgKi8KKwkuc2hvd19ob3N0X3BvcnRfdHlwZSA9IDEsCisJLmdldF9ob3N0X3BvcnRfdHlwZSA9IGJmYWRfaW1fZ2V0X2hvc3RfcG9ydF90eXBlLAorCS5zaG93X2hvc3RfcG9ydF9zdGF0ZSA9IDEsCisJLmdldF9ob3N0X3BvcnRfc3RhdGUgPSBiZmFkX2ltX2dldF9ob3N0X3BvcnRfc3RhdGUsCisJLnNob3dfaG9zdF9hY3RpdmVfZmM0cyA9IDEsCisJLmdldF9ob3N0X2FjdGl2ZV9mYzRzID0gYmZhZF9pbV9nZXRfaG9zdF9hY3RpdmVfZmM0cywKKwkuc2hvd19ob3N0X3NwZWVkID0gMSwKKwkuZ2V0X2hvc3Rfc3BlZWQgPSBiZmFkX2ltX2dldF9ob3N0X3NwZWVkLAorCS5zaG93X2hvc3RfZmFicmljX25hbWUgPSAxLAorCS5nZXRfaG9zdF9mYWJyaWNfbmFtZSA9IGJmYWRfaW1fZ2V0X2hvc3RfZmFicmljX25hbWUsCisKKwkuc2hvd19ob3N0X3N5bWJvbGljX25hbWUgPSAxLAorCisJLyogU3RhdGlzdGljcyAqLworCS5nZXRfZmNfaG9zdF9zdGF0cyA9IGJmYWRfaW1fZ2V0X3N0YXRzLAorCS5yZXNldF9mY19ob3N0X3N0YXRzID0gYmZhZF9pbV9yZXNldF9zdGF0cywKKworCS8qIEFsbG9jYXRpb24gbGVuZ3RoIGZvciBob3N0IHNwZWNpZmljIGRhdGEgKi8KKwkuZGRfZmNycG9ydF9zaXplID0gc2l6ZW9mKHN0cnVjdCBiZmFkX2l0bmltX2RhdGFfcyAqKSwKKworCS8qIFJlbW90ZSBwb3J0IGZpeGVkIGF0dHJpYnV0ZXMgKi8KKwkuc2hvd19ycG9ydF9tYXhmcmFtZV9zaXplID0gMSwKKwkuc2hvd19ycG9ydF9zdXBwb3J0ZWRfY2xhc3NlcyA9IDEsCisJLnNob3dfcnBvcnRfZGV2X2xvc3NfdG1vID0gMSwKKwkuZ2V0X3Jwb3J0X2Rldl9sb3NzX3RtbyA9IGJmYWRfaW1fZ2V0X3Jwb3J0X2xvc3NfdG1vLAorCS5zZXRfcnBvcnRfZGV2X2xvc3NfdG1vID0gYmZhZF9pbV9zZXRfcnBvcnRfbG9zc190bW8sCit9OworCisvKioKKyAqICBTY3NpX0hvc3RfYXR0cnMgU0NTSSBob3N0IGF0dHJpYnV0ZXMKKyAqLworc3RhdGljIHNzaXplX3QKK2JmYWRfaW1fc2VyaWFsX251bV9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkgY2hhciAqYnVmKQoreworCXN0cnVjdCBTY3NpX0hvc3QgKnNob3N0ID0gY2xhc3NfdG9fc2hvc3QoZGV2KTsKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhX2lvY19hdHRyX3MgIGlvY19hdHRyOworCisJbWVtc2V0KCZpb2NfYXR0ciwgMCwgc2l6ZW9mKGlvY19hdHRyKSk7CisJYmZhX2dldF9hdHRyKCZiZmFkLT5iZmEsICZpb2NfYXR0cik7CisJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiJXNcbiIsCisJCQlpb2NfYXR0ci5hZGFwdGVyX2F0dHIuc2VyaWFsX251bSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitiZmFkX2ltX21vZGVsX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCWNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCA9IGNsYXNzX3RvX3Nob3N0KGRldik7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJc3RydWN0IGJmYV9pb2NfYXR0cl9zICBpb2NfYXR0cjsKKworCW1lbXNldCgmaW9jX2F0dHIsIDAsIHNpemVvZihpb2NfYXR0cikpOworCWJmYV9nZXRfYXR0cigmYmZhZC0+YmZhLCAmaW9jX2F0dHIpOworCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIiVzXG4iLCBpb2NfYXR0ci5hZGFwdGVyX2F0dHIubW9kZWwpOworfQorCitzdGF0aWMgc3NpemVfdAorYmZhZF9pbV9tb2RlbF9kZXNjX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQkgY2hhciAqYnVmKQoreworCXN0cnVjdCBTY3NpX0hvc3QgKnNob3N0ID0gY2xhc3NfdG9fc2hvc3QoZGV2KTsKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhX2lvY19hdHRyX3MgIGlvY19hdHRyOworCisJbWVtc2V0KCZpb2NfYXR0ciwgMCwgc2l6ZW9mKGlvY19hdHRyKSk7CisJYmZhX2dldF9hdHRyKCZiZmFkLT5iZmEsICZpb2NfYXR0cik7CisJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiJXNcbiIsCisJCQlpb2NfYXR0ci5hZGFwdGVyX2F0dHIubW9kZWxfZGVzY3IpOworfQorCitzdGF0aWMgc3NpemVfdAorYmZhZF9pbV9ub2RlX25hbWVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJCSBjaGFyICpidWYpCit7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QgPSBjbGFzc190b19zaG9zdChkZXYpOworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCA9CisJCQkoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwlzdHJ1Y3QgYmZhZF9wb3J0X3MgICAgKnBvcnQgPSBpbV9wb3J0LT5wb3J0OworCXU2NCAgICAgICAgbnd3bjsKKworCW53d24gPSBiZmFfZmNzX3BvcnRfZ2V0X253d24ocG9ydC0+ZmNzX3BvcnQpOworCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIjB4JWxseFxuIiwgYmZhX29zX2h0b25sbChud3duKSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitiZmFkX2ltX3N5bWJvbGljX25hbWVfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJCSBjaGFyICpidWYpCit7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QgPSBjbGFzc190b19zaG9zdChkZXYpOworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCA9CisJCQkoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQgPSBpbV9wb3J0LT5iZmFkOworCXN0cnVjdCBiZmFfaW9jX2F0dHJfcyAgaW9jX2F0dHI7CisKKwltZW1zZXQoJmlvY19hdHRyLCAwLCBzaXplb2YoaW9jX2F0dHIpKTsKKwliZmFfZ2V0X2F0dHIoJmJmYWQtPmJmYSwgJmlvY19hdHRyKTsKKworCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIkJyb2NhZGUgJXMgRlYlcyBEViVzXG4iLAorCQkJaW9jX2F0dHIuYWRhcHRlcl9hdHRyLm1vZGVsLAorCQkJaW9jX2F0dHIuYWRhcHRlcl9hdHRyLmZ3X3ZlciwgQkZBRF9EUklWRVJfVkVSU0lPTik7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitiZmFkX2ltX2h3X3ZlcnNpb25fc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJCWNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCA9IGNsYXNzX3RvX3Nob3N0KGRldik7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJc3RydWN0IGJmYV9pb2NfYXR0cl9zICBpb2NfYXR0cjsKKworCW1lbXNldCgmaW9jX2F0dHIsIDAsIHNpemVvZihpb2NfYXR0cikpOworCWJmYV9nZXRfYXR0cigmYmZhZC0+YmZhLCAmaW9jX2F0dHIpOworCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIiVzXG4iLCBpb2NfYXR0ci5hZGFwdGVyX2F0dHIuaHdfdmVyKTsKK30KKworc3RhdGljIHNzaXplX3QKK2JmYWRfaW1fZHJ2X3ZlcnNpb25fc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLAorCQkJCWNoYXIgKmJ1ZikKK3sKKwlyZXR1cm4gc25wcmludGYoYnVmLCBQQUdFX1NJWkUsICIlc1xuIiwgQkZBRF9EUklWRVJfVkVSU0lPTik7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitiZmFkX2ltX29wdGlvbnJvbV92ZXJzaW9uX3Nob3coc3RydWN0IGRldmljZSAqZGV2LAorCQkJIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCit7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QgPSBjbGFzc190b19zaG9zdChkZXYpOworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCA9CisJCQkoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQgPSBpbV9wb3J0LT5iZmFkOworCXN0cnVjdCBiZmFfaW9jX2F0dHJfcyAgaW9jX2F0dHI7CisKKwltZW1zZXQoJmlvY19hdHRyLCAwLCBzaXplb2YoaW9jX2F0dHIpKTsKKwliZmFfZ2V0X2F0dHIoJmJmYWQtPmJmYSwgJmlvY19hdHRyKTsKKwlyZXR1cm4gc25wcmludGYoYnVmLCBQQUdFX1NJWkUsICIlc1xuIiwKKwkJCWlvY19hdHRyLmFkYXB0ZXJfYXR0ci5vcHRyb21fdmVyKTsKK30KKworc3RhdGljIHNzaXplX3QKK2JmYWRfaW1fZndfdmVyc2lvbl9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsCisJCQkJIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCA9IGNsYXNzX3RvX3Nob3N0KGRldik7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJc3RydWN0IGJmYV9pb2NfYXR0cl9zICBpb2NfYXR0cjsKKworCW1lbXNldCgmaW9jX2F0dHIsIDAsIHNpemVvZihpb2NfYXR0cikpOworCWJmYV9nZXRfYXR0cigmYmZhZC0+YmZhLCAmaW9jX2F0dHIpOworCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIiVzXG4iLCBpb2NfYXR0ci5hZGFwdGVyX2F0dHIuZndfdmVyKTsKK30KKworc3RhdGljIHNzaXplX3QKK2JmYWRfaW1fbnVtX29mX3BvcnRzX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQljaGFyICpidWYpCit7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QgPSBjbGFzc190b19zaG9zdChkZXYpOworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCA9CisJCQkoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQgPSBpbV9wb3J0LT5iZmFkOworCXN0cnVjdCBiZmFfaW9jX2F0dHJfcyAgaW9jX2F0dHI7CisKKwltZW1zZXQoJmlvY19hdHRyLCAwLCBzaXplb2YoaW9jX2F0dHIpKTsKKwliZmFfZ2V0X2F0dHIoJmJmYWQtPmJmYSwgJmlvY19hdHRyKTsKKwlyZXR1cm4gc25wcmludGYoYnVmLCBQQUdFX1NJWkUsICIlZFxuIiwgaW9jX2F0dHIuYWRhcHRlcl9hdHRyLm5wb3J0cyk7Cit9CisKK3N0YXRpYyBzc2l6ZV90CitiZmFkX2ltX2Rydl9uYW1lX3Nob3coc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwKKwkJCQljaGFyICpidWYpCit7CisJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9TSVpFLCAiJXNcbiIsIEJGQURfRFJJVkVSX05BTUUpOworfQorCitzdGF0aWMgc3NpemVfdAorYmZhZF9pbV9udW1fb2ZfZGlzY292ZXJlZF9wb3J0c19zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCXN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCit7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QgPSBjbGFzc190b19zaG9zdChkZXYpOworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCA9CisJCQkoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIHNob3N0LT5ob3N0ZGF0YVswXTsKKwlzdHJ1Y3QgYmZhZF9wb3J0X3MgICAgKnBvcnQgPSBpbV9wb3J0LT5wb3J0OworCXN0cnVjdCBiZmFkX3MgICAgICAgICAqYmZhZCA9IGltX3BvcnQtPmJmYWQ7CisJaW50ICAgICAgICBucnBvcnRzID0gMjA0ODsKKwl3d25fdCAgICAgICAgICAqcnBvcnRzID0gTlVMTDsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwlycG9ydHMgPSBremFsbG9jKHNpemVvZih3d25fdCkgKiBucnBvcnRzICwgR0ZQX0FUT01JQyk7CisJaWYgKHJwb3J0cyA9PSBOVUxMKQorCQlyZXR1cm4gLUVOT01FTTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwliZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0cyhwb3J0LT5mY3NfcG9ydCwgcnBvcnRzLCAmbnJwb3J0cyk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJa2ZyZWUocnBvcnRzKTsKKworCXJldHVybiBzbnByaW50ZihidWYsIFBBR0VfU0laRSwgIiVkXG4iLCBucnBvcnRzKTsKK30KKworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKHNlcmlhbF9udW1iZXIsIFNfSVJVR08sCisJCQkJYmZhZF9pbV9zZXJpYWxfbnVtX3Nob3csIE5VTEwpOworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKG1vZGVsLCBTX0lSVUdPLCBiZmFkX2ltX21vZGVsX3Nob3csIE5VTEwpOworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKG1vZGVsX2Rlc2NyaXB0aW9uLCBTX0lSVUdPLAorCQkJCWJmYWRfaW1fbW9kZWxfZGVzY19zaG93LCBOVUxMKTsKK3N0YXRpYyAgICAgICAgICBERVZJQ0VfQVRUUihub2RlX25hbWUsIFNfSVJVR08sIGJmYWRfaW1fbm9kZV9uYW1lX3Nob3csIE5VTEwpOworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKHN5bWJvbGljX25hbWUsIFNfSVJVR08sCisJCQkJYmZhZF9pbV9zeW1ib2xpY19uYW1lX3Nob3csIE5VTEwpOworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKGhhcmR3YXJlX3ZlcnNpb24sIFNfSVJVR08sCisJCQkJYmZhZF9pbV9od192ZXJzaW9uX3Nob3csIE5VTEwpOworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKGRyaXZlcl92ZXJzaW9uLCBTX0lSVUdPLAorCQkJCWJmYWRfaW1fZHJ2X3ZlcnNpb25fc2hvdywgTlVMTCk7CitzdGF0aWMgICAgICAgICAgREVWSUNFX0FUVFIob3B0aW9uX3JvbV92ZXJzaW9uLCBTX0lSVUdPLAorCQkJCWJmYWRfaW1fb3B0aW9ucm9tX3ZlcnNpb25fc2hvdywgTlVMTCk7CitzdGF0aWMgICAgICAgICAgREVWSUNFX0FUVFIoZmlybXdhcmVfdmVyc2lvbiwgU19JUlVHTywKKwkJCQliZmFkX2ltX2Z3X3ZlcnNpb25fc2hvdywgTlVMTCk7CitzdGF0aWMgICAgICAgICAgREVWSUNFX0FUVFIobnVtYmVyX29mX3BvcnRzLCBTX0lSVUdPLAorCQkJCWJmYWRfaW1fbnVtX29mX3BvcnRzX3Nob3csIE5VTEwpOworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKGRyaXZlcl9uYW1lLCBTX0lSVUdPLCBiZmFkX2ltX2Rydl9uYW1lX3Nob3csIE5VTEwpOworc3RhdGljICAgICAgICAgIERFVklDRV9BVFRSKG51bWJlcl9vZl9kaXNjb3ZlcmVkX3BvcnRzLCBTX0lSVUdPLAorCQkJCWJmYWRfaW1fbnVtX29mX2Rpc2NvdmVyZWRfcG9ydHNfc2hvdywgTlVMTCk7CisKK3N0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpiZmFkX2ltX2hvc3RfYXR0cnNbXSA9IHsKKwkmZGV2X2F0dHJfc2VyaWFsX251bWJlciwKKwkmZGV2X2F0dHJfbW9kZWwsCisJJmRldl9hdHRyX21vZGVsX2Rlc2NyaXB0aW9uLAorCSZkZXZfYXR0cl9ub2RlX25hbWUsCisJJmRldl9hdHRyX3N5bWJvbGljX25hbWUsCisJJmRldl9hdHRyX2hhcmR3YXJlX3ZlcnNpb24sCisJJmRldl9hdHRyX2RyaXZlcl92ZXJzaW9uLAorCSZkZXZfYXR0cl9vcHRpb25fcm9tX3ZlcnNpb24sCisJJmRldl9hdHRyX2Zpcm13YXJlX3ZlcnNpb24sCisJJmRldl9hdHRyX251bWJlcl9vZl9wb3J0cywKKwkmZGV2X2F0dHJfZHJpdmVyX25hbWUsCisJJmRldl9hdHRyX251bWJlcl9vZl9kaXNjb3ZlcmVkX3BvcnRzLAorCU5VTEwsCit9OworCitzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYmZhZF9pbV92cG9ydF9hdHRyc1tdID0geworICAgICZkZXZfYXR0cl9zZXJpYWxfbnVtYmVyLAorICAgICZkZXZfYXR0cl9tb2RlbCwKKyAgICAmZGV2X2F0dHJfbW9kZWxfZGVzY3JpcHRpb24sCisgICAgJmRldl9hdHRyX25vZGVfbmFtZSwKKyAgICAmZGV2X2F0dHJfc3ltYm9saWNfbmFtZSwKKyAgICAmZGV2X2F0dHJfaGFyZHdhcmVfdmVyc2lvbiwKKyAgICAmZGV2X2F0dHJfZHJpdmVyX3ZlcnNpb24sCisgICAgJmRldl9hdHRyX29wdGlvbl9yb21fdmVyc2lvbiwKKyAgICAmZGV2X2F0dHJfZmlybXdhcmVfdmVyc2lvbiwKKyAgICAmZGV2X2F0dHJfbnVtYmVyX29mX3BvcnRzLAorICAgICZkZXZfYXR0cl9kcml2ZXJfbmFtZSwKKyAgICAmZGV2X2F0dHJfbnVtYmVyX29mX2Rpc2NvdmVyZWRfcG9ydHMsCisgICAgTlVMTCwKK307CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2F0dHIuaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9hdHRyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGQzMzEyZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9hdHRyLmgKQEAgLTAsMCArMSw2NSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBRF9BVFRSX0hfXworI2RlZmluZSBfX0JGQURfQVRUUl9IX18KKy8qKgorICogIGJmYWRfYXR0ci5oIFZNd2FyZSBkcml2ZXIgY29uZmlndXJhdGlvbiBpbnRlcmZhY2UgbW9kdWxlLgorICovCisKKy8qKgorICogIEZDX3RyYW5zcG9ydF90ZW1wbGF0ZSBGQyB0cmFuc3BvcnQgdGVtcGxhdGUKKyAqLworCitzdHJ1Y3QgU2NzaV9Ib3N0KgorYmZhZF9vc19kZXZfdG9fc2hvc3Qoc3RydWN0IHNjc2lfdGFyZ2V0ICpzdGFyZ2V0KTsKKworLyoqCisgKiBGQyB0cmFuc3BvcnQgdGVtcGxhdGUgZW50cnksIGdldCBTQ1NJIHRhcmdldCBwb3J0IElELgorICovCit2b2lkCitiZmFkX2ltX2dldF9zdGFyZ2V0X3BvcnRfaWQoc3RydWN0IHNjc2lfdGFyZ2V0ICpzdGFyZ2V0KTsKKworLyoqCisgKiBGQyB0cmFuc3BvcnQgdGVtcGxhdGUgZW50cnksIGdldCBTQ1NJIHRhcmdldCBud3duLgorICovCit2b2lkCitiZmFkX2ltX2dldF9zdGFyZ2V0X25vZGVfbmFtZShzdHJ1Y3Qgc2NzaV90YXJnZXQgKnN0YXJnZXQpOworCisvKioKKyAqIEZDIHRyYW5zcG9ydCB0ZW1wbGF0ZSBlbnRyeSwgZ2V0IFNDU0kgdGFyZ2V0IHB3d24uCisgKi8KK3ZvaWQKK2JmYWRfaW1fZ2V0X3N0YXJnZXRfcG9ydF9uYW1lKHN0cnVjdCBzY3NpX3RhcmdldCAqc3RhcmdldCk7CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBnZXQgU0NTSSBob3N0IHBvcnQgSUQuCisgKi8KK3ZvaWQKK2JmYWRfaW1fZ2V0X2hvc3RfcG9ydF9pZChzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCk7CisKKy8qKgorICogRkMgdHJhbnNwb3J0IHRlbXBsYXRlIGVudHJ5LCBpc3N1ZSBhIExJUC4KKyAqLworaW50CitiZmFkX2ltX2lzc3VlX2ZjX2hvc3RfbGlwKHN0cnVjdCBTY3NpX0hvc3QgKnNob3N0KTsKKworc3RydWN0IFNjc2lfSG9zdCoKK2JmYWRfb3Nfc3RhcmdldF90b19zaG9zdChzdHJ1Y3Qgc2NzaV90YXJnZXQgKnN0YXJnZXQpOworCisKKyNlbmRpZiAvKiAgX19CRkFEX0FUVFJfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfZHJ2LmggYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfZHJ2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTcyYzgxZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9kcnYuaApAQCAtMCwwICsxLDI5NSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqIENvbnRhaW5zIGJhc2UgZHJpdmVyIGRlZmluaXRpb25zLgorICovCisKKy8qKgorICogIGJmYV9kcnYuaCBMaW51eCBkcml2ZXIgZGF0YSBzdHJ1Y3R1cmVzLgorICovCisKKyNpZm5kZWYgX19CRkFEX0RSVl9IX18KKyNkZWZpbmUgX19CRkFEX0RSVl9IX18KKworI2luY2x1ZGUgImJmYV9vc19pbmMuaCIKKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjcy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcGNpLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wb3J0Lmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19ycG9ydC5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX3Jwb3J0Lmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc192cG9ydC5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX3Zwb3J0Lmg+CisKKyNpbmNsdWRlIDxjcy9iZmFfcGxvZy5oPgorI2luY2x1ZGUgImFlbi9iZmFfYWVuLmgiCisjaW5jbHVkZSA8bG9nL2JmYV9sb2dfbGludXguaD4KKworI2RlZmluZSBCRkFEX0RSSVZFUl9OQU1FICAgICAgICAiYmZhIgorI2lmZGVmIEJGQV9EUklWRVJfVkVSU0lPTgorI2RlZmluZSBCRkFEX0RSSVZFUl9WRVJTSU9OICAgIEJGQV9EUklWRVJfVkVSU0lPTgorI2Vsc2UKKyNkZWZpbmUgQkZBRF9EUklWRVJfVkVSU0lPTiAgICAiMi4wLjAuMCIKKyNlbmRpZgorCisKKyNkZWZpbmUgQkZBRF9JUlFfRkxBR1MgSVJRRl9TSEFSRUQKKworLyoKKyAqIEJGQUQgZmxhZ3MKKyAqLworI2RlZmluZSBCRkFEX01TSVhfT04JCQkJMHgwMDAwMDAwMQorI2RlZmluZSBCRkFEX0hBTF9JTklUX0RPTkUJCQkweDAwMDAwMDAyCisjZGVmaW5lIEJGQURfRFJWX0lOSVRfRE9ORQkJCTB4MDAwMDAwMDQKKyNkZWZpbmUgQkZBRF9DRkdfUFBPUlRfRE9ORQkJCTB4MDAwMDAwMDgKKyNkZWZpbmUgQkZBRF9IQUxfU1RBUlRfRE9ORQkJCTB4MDAwMDAwMTAKKyNkZWZpbmUgQkZBRF9QT1JUX09OTElORQkJCTB4MDAwMDAwMjAKKyNkZWZpbmUgQkZBRF9SUE9SVF9PTkxJTkUJCQkweDAwMDAwMDQwCisKKyNkZWZpbmUgQkZBRF9QT1JUX0RFTEVURQkJCTB4MDAwMDAwMDEKKworLyoKKyAqIEJGQUQgcmVsYXRlZCBkZWZpbml0aW9uCisgKi8KKyNkZWZpbmUgU0NTSV9TQ0FOX0RFTEFZCQlIWgorI2RlZmluZSBCRkFEX1NUT1BfVElNRU9VVAkzMAorI2RlZmluZSBCRkFEX1NVU1BFTkRfVElNRU9VVAlCRkFEX1NUT1BfVElNRU9VVAorCisvKgorICogQkZBRCBjb25maWd1cmF0aW9uIHBhcmFtZXRlciBkZWZhdWx0IHZhbHVlcworICovCisjZGVmaW5lIEJGQURfTFVOX1FVRVVFX0RFUFRIIAkJMzIKKyNkZWZpbmUgQkZBRF9JT19NQVhfU0dFIAkJU0dfQUxMCisKKyNkZWZpbmUgYmZhZF9pc3JfdCBpcnFfaGFuZGxlcl90CisKKyNkZWZpbmUgTUFYX01TSVhfRU5UUlkgMjIKKworc3RydWN0IGJmYWRfbXNpeF9zIHsKKwlzdHJ1Y3QgYmZhZF9zICpiZmFkOworCXN0cnVjdCBtc2l4X2VudHJ5IG1zaXg7Cit9OworCitlbnVtIGJmYWRfcG9ydF9wdmJfdHlwZSB7CisJQkZBRF9QT1JUX1BIWVNfQkFTRSA9IDAsCisJQkZBRF9QT1JUX1BIWVNfVlBPUlQgPSAxLAorCUJGQURfUE9SVF9WRl9CQVNFID0gMiwKKwlCRkFEX1BPUlRfVkZfVlBPUlQgPSAzLAorfTsKKworLyoKKyAqIFBPUlQgZGF0YSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGJmYWRfcG9ydF9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3RfZW50cnk7CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqZmNzX3BvcnQ7CisJdTMyICAgICAgICByb2xlczsKKwlzMzIgICAgICAgICBmbGFnczsKKwl1MzIgICAgICAgIHN1cHBvcnRlZF9mYzRzOworCXU4CQlpcGZjX2ZsYWdzOworCWVudW0gYmZhZF9wb3J0X3B2Yl90eXBlIHB2Yl90eXBlOworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydDsJLyogSU0gc3BlY2lmaWMgZGF0YSAqLworCXN0cnVjdCBiZmFkX3RtX3BvcnRfcyAqdG1fcG9ydDsJLyogVE0gc3BlY2lmaWMgZGF0YSAqLworCXN0cnVjdCBiZmFkX2lwZmNfcG9ydF9zICppcGZjX3BvcnQ7CS8qIElQRkMgc3BlY2lmaWMgZGF0YSAqLworfTsKKworLyoKKyAqIFZQT1JUIGRhdGEgc3RydWN0dXJlCisgKi8KK3N0cnVjdCBiZmFkX3Zwb3J0X3MgeworCXN0cnVjdCBiZmFkX3BvcnRfcyAgICAgZHJ2X3BvcnQ7CisJc3RydWN0IGJmYV9mY3NfdnBvcnRfcyBmY3NfdnBvcnQ7CisJc3RydWN0IGNvbXBsZXRpb24gKmNvbXBfZGVsOworfTsKKworLyoKKyAqIFZGIGRhdGEgc3RydWN0dXJlCisgKi8KK3N0cnVjdCBiZmFkX3ZmX3MgeworCWJmYV9mY3NfdmZfdCAgICBmY3NfdmY7CisJc3RydWN0IGJmYWRfcG9ydF9zICAgIGJhc2VfcG9ydDsJLyogYmFzZSBwb3J0IGZvciB2ZiAqLworCXN0cnVjdCBiZmFkX3MgICAqYmZhZDsKK307CisKK3N0cnVjdCBiZmFkX2NmZ19wYXJhbV9zIHsKKwl1MzIgICAgICAgIHJwb3J0X2RlbF90aW1lb3V0OworCXUzMiAgICAgICAgaW9jX3F1ZXVlX2RlcHRoOworCXUzMiAgICAgICAgbHVuX3F1ZXVlX2RlcHRoOworCXUzMiAgICAgICAgaW9fbWF4X3NnZTsKKwl1MzIgICAgICAgIGJpbmRpbmdfbWV0aG9kOworfTsKKworI2RlZmluZSBCRkFEX0FFTl9NQVhfQVBQUyA4CitzdHJ1Y3QgYmZhZF9hZW5fZmlsZV9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkICBxZTsKKwlzdHJ1Y3QgYmZhZF9zICpiZmFkOworCXMzMiByaTsKKwlzMzIgYXBwX2lkOworfTsKKworLyoKKyAqIEJGQUQgKFBDSSBmdW5jdGlvbikgZGF0YSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGJmYWRfcyB7CisJc3RydWN0IGxpc3RfaGVhZCBsaXN0X2VudHJ5OworCXN0cnVjdCBiZmFfcyAgICAgICBiZmE7CisJc3RydWN0IGJmYV9mY3NfcyAgICAgICBiZmFfZmNzOworCXN0cnVjdCBwY2lfZGV2ICpwY2lkZXY7CisJY29uc3QgY2hhciAqcGNpX25hbWU7CisJc3RydWN0IGJmYV9wY2lkZXZfcyBoYWxfcGNpZGV2OworCXN0cnVjdCBiZmFfaW9jX3BjaV9hdHRyX3MgcGNpX2F0dHI7CisJdW5zaWduZWQgbG9uZyAgIHBjaV9iYXIwX21hcDsKKwl2b2lkIF9faW9tZW0gICAqcGNpX2JhcjBfa3ZhOworCXN0cnVjdCBjb21wbGV0aW9uIGNvbXA7CisJc3RydWN0IGNvbXBsZXRpb24gc3VzcGVuZDsKKwlzdHJ1Y3QgY29tcGxldGlvbiBkaXNhYmxlX2NvbXA7CisJYmZhX2Jvb2xlYW5fdCAgIGRpc2FibGVfYWN0aXZlOworCXN0cnVjdCBiZmFkX3BvcnRfcyAgICAgcHBvcnQ7CS8qIHBoeXNpY2FsIHBvcnQgb2YgdGhlIEJGQUQgKi8KKwlzdHJ1Y3QgYmZhX21lbWluZm9fcyBtZW1pbmZvOworCXN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgICBpb2NfY2ZnOworCXUzMiAgICAgICAgaW5zdF9ubzsJLyogQkZBRCBpbnN0YW5jZSBudW1iZXIgKi8KKwl1MzIgICAgICAgIGJmYWRfZmxhZ3M7CisJc3BpbmxvY2tfdCAgICAgIGJmYWRfbG9jazsKKwlzdHJ1Y3QgYmZhZF9jZmdfcGFyYW1fcyBjZmdfZGF0YTsKKwlzdHJ1Y3QgYmZhZF9tc2l4X3MgbXNpeF90YWJbTUFYX01TSVhfRU5UUlldOworCWludCAgICAgICAgICAgICBudmVjOworCWNoYXIgICAgICAgICAgICBhZGFwdGVyX25hbWVbQkZBX0FEQVBURVJfU1lNX05BTUVfTEVOXTsKKwljaGFyICAgICAgICAgICAgcG9ydF9uYW1lW0JGQV9BREFQVEVSX1NZTV9OQU1FX0xFTl07CisJc3RydWN0IHRpbWVyX2xpc3QgaGFsX3RtbzsKKwl1bnNpZ25lZCBsb25nICAgaHNfc3RhcnQ7CisJc3RydWN0IGJmYWRfaW1fcyAqaW07CQkvKiBJTSBzcGVjaWZpYyBkYXRhICovCisJc3RydWN0IGJmYWRfdG1fcyAqdG07CQkvKiBUTSBzcGVjaWZpYyBkYXRhICovCisJc3RydWN0IGJmYWRfaXBmY19zICppcGZjOwkvKiBJUEZDIHNwZWNpZmljIGRhdGEgKi8KKwlzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAgIGxvZ19kYXRhOworCXN0cnVjdCBiZmFfdHJjX21vZF9zICAqdHJjbW9kOworCXN0cnVjdCBiZmFfbG9nX21vZF9zICAqbG9nbW9kOworCXN0cnVjdCBiZmFfYWVuX3MgICAgICAqYWVuOworCXN0cnVjdCBiZmFfYWVuX3MgICAgICAgYWVuX2J1ZjsKKwlzdHJ1Y3QgYmZhZF9hZW5fZmlsZV9zIGZpbGVfYnVmW0JGQURfQUVOX01BWF9BUFBTXTsKKwlzdHJ1Y3QgbGlzdF9oZWFkICAgICAgICAgZmlsZV9xOworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICBmaWxlX2ZyZWVfcTsKKwlzdHJ1Y3QgYmZhX3Bsb2dfcyAgICAgIHBsb2dfYnVmOworCWludCAgICAgICAgICAgICByZWZfY291bnQ7CisJYmZhX2Jvb2xlYW5fdAlpcGZjX2VuYWJsZWQ7CisJc3RydWN0IGZjX2hvc3Rfc3RhdGlzdGljcyBsaW5rX3N0YXRzOworCisJc3RydWN0IGtvYmplY3QgKmJmYV9rb2JqOworCXN0cnVjdCBrb2JqZWN0ICppb2Nfa29iajsKKwlzdHJ1Y3Qga29iamVjdCAqcHBvcnRfa29iajsKKwlzdHJ1Y3Qga29iamVjdCAqbHBvcnRfa29iajsKK307CisKKy8qCisgKiBSUE9SVCBkYXRhIHN0cnVjdHVyZQorICovCitzdHJ1Y3QgYmZhZF9ycG9ydF9zIHsKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zIGZjc19ycG9ydDsKK307CisKK3N0cnVjdCBiZmFkX2J1Zl9pbmZvIHsKKwl2b2lkICAgICAgICAgICAqdmlydDsKKwlkbWFfYWRkcl90ICAgICAgcGh5czsKKwl1MzIgICAgICAgIHNpemU7Cit9OworCitzdHJ1Y3QgYmZhZF9mY3hwIHsKKwlzdHJ1Y3QgYmZhZF9wb3J0X3MgICAgKnBvcnQ7CisJc3RydWN0IGJmYV9ycG9ydF9zICpiZmFfcnBvcnQ7CisJYmZhX3N0YXR1c190ICAgIHJlcV9zdGF0dXM7CisJdTE2ICAgICAgICB0YWc7CisJdTE2ICAgICAgICByc3BfbGVuOworCXUxNiAgICAgICAgcnNwX21heGxlbjsKKwl1OCAgICAgICAgIHVzZV9pcmVxYnVmOworCXU4ICAgICAgICAgdXNlX2lyc3BidWY7CisJdTMyICAgICAgICBudW1fcmVxX3NnbGVzOworCXUzMiAgICAgICAgbnVtX3JzcF9zZ2xlczsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJdm9pZCAgICAgICAgICAgKnJlcWJ1Zl9pbmZvOworCXZvaWQgICAgICAgICAgICpyc3BidWZfaW5mbzsKKwlzdHJ1Y3QgYmZhX3NnZV9zICAqcmVxX3NnZTsKKwlzdHJ1Y3QgYmZhX3NnZV9zICAqcnNwX3NnZTsKKwlmY3hwX3NlbmRfY2JfdCAgc2VuZF9jYmZuOworCXZvaWQgICAgICAgICAgICpzZW5kX2NiYXJnOworCXZvaWQgICAgICAgICAgICpiZmFfZmN4cDsKKwlzdHJ1Y3QgY29tcGxldGlvbiBjb21wOworfTsKKworc3RydWN0IGJmYWRfaGFsX2NvbXAgeworCWJmYV9zdGF0dXNfdCAgICBzdGF0dXM7CisJc3RydWN0IGNvbXBsZXRpb24gY29tcDsKK307CisKKy8qCisgKiBNYWNybyB0byBvYnRhaW4gdGhlIGltbWVkaWF0ZSBsb3dlciBwb3dlcgorICogb2YgdHdvIGZvciB0aGUgaW50ZWdlci4KKyAqLworI2RlZmluZSBuZXh0TG93ZXJJbnQoeCkgICAgICAgICAgICAgICAgICAgICAgICAgCVwKK2RvIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAlcCisJaW50IGo7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAlcCisJKCp4KS0tOyAgICAJCSAgICAgICAgICAgICAgICAJXAorCWZvciAoaiA9IDE7IGogPCAoc2l6ZW9mKGludCkgKiA4KTsgaiA8PD0gMSkgICAgIFwKKwkJKCp4KSA9ICgqeCkgfCAoKngpID4+IGo7ICAgICAgICAJXAorCSgqeCkrKzsgICAgICAgICAgICAgICAgICAJICAgICAgICAJXAorCSgqeCkgPSAoKngpID4+IDE7ICAgICAgICAgICAgICAgICAgICAgICAJXAorfSB3aGlsZSAoMCkKKworCitiZmFfc3RhdHVzX3QgICAgYmZhZF92cG9ydF9jcmVhdGUoc3RydWN0IGJmYWRfcyAqYmZhZCwgdTE2IHZmX2lkLAorCQkJCSAgc3RydWN0IGJmYV9wb3J0X2NmZ19zICpwb3J0X2NmZyk7CitiZmFfc3RhdHVzX3QgICAgYmZhZF92Zl9jcmVhdGUoc3RydWN0IGJmYWRfcyAqYmZhZCwgdTE2IHZmX2lkLAorCQkJICAgICAgIHN0cnVjdCBiZmFfcG9ydF9jZmdfcyAqcG9ydF9jZmcpOworYmZhX3N0YXR1c190ICAgIGJmYWRfY2ZnX3Bwb3J0KHN0cnVjdCBiZmFkX3MgKmJmYWQsIGVudW0gYmZhX3BvcnRfcm9sZSByb2xlKTsKK2JmYV9zdGF0dXNfdCAgICBiZmFkX2Rydl9pbml0KHN0cnVjdCBiZmFkX3MgKmJmYWQpOwordm9pZCAgICAgICAgICAgIGJmYWRfZHJ2X3N0YXJ0KHN0cnVjdCBiZmFkX3MgKmJmYWQpOwordm9pZCAgICAgICAgICAgIGJmYWRfdW5jZmdfcHBvcnQoc3RydWN0IGJmYWRfcyAqYmZhZCk7Cit2b2lkICAgICAgICAgICAgYmZhZF9kcnZfc3RvcChzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKK3ZvaWQgICAgICAgICAgICBiZmFkX3JlbW92ZV9pbnRyKHN0cnVjdCBiZmFkX3MgKmJmYWQpOwordm9pZCAgICAgICAgICAgIGJmYWRfaGFsX21lbV9yZWxlYXNlKHN0cnVjdCBiZmFkX3MgKmJmYWQpOwordm9pZCAgICAgICAgICAgIGJmYWRfaGNiX2NvbXAodm9pZCAqYXJnLCBiZmFfc3RhdHVzX3Qgc3RhdHVzKTsKKworaW50ICAgICAgICAgICAgIGJmYWRfc2V0dXBfaW50cihzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKK3ZvaWQgICAgICAgICAgICBiZmFkX3JlbW92ZV9pbnRyKHN0cnVjdCBiZmFkX3MgKmJmYWQpOworCit2b2lkCQliZmFkX3VwZGF0ZV9oYWxfY2ZnKHN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmJmYV9jZmcpOworYmZhX3N0YXR1c190CWJmYWRfaGFsX21lbV9hbGxvYyhzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKK3ZvaWQJCWJmYWRfYmZhX3Rtbyh1bnNpZ25lZCBsb25nIGRhdGEpOwordm9pZAkJYmZhZF9pbml0X3RpbWVyKHN0cnVjdCBiZmFkX3MgKmJmYWQpOworaW50CQliZmFkX3BjaV9pbml0KHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKK3ZvaWQJCWJmYWRfcGNpX3VuaW5pdChzdHJ1Y3QgcGNpX2RldiAqcGRldiwgc3RydWN0IGJmYWRfcyAqYmZhZCk7Cit2b2lkCQliZmFkX2Zjc19wb3J0X2NmZyhzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKK3ZvaWQJCWJmYWRfZHJ2X3VuaW5pdChzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKK3ZvaWQJCWJmYWRfZHJ2X2xvZ19sZXZlbF9zZXQoc3RydWN0IGJmYWRfcyAqYmZhZCk7CitiZmFfc3RhdHVzX3QJYmZhZF9mYzRfbW9kdWxlX2luaXQodm9pZCk7Cit2b2lkCQliZmFkX2ZjNF9tb2R1bGVfZXhpdCh2b2lkKTsKKwordm9pZCBiZmFkX3BjaV9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYpOworaW50IGJmYWRfcGNpX3Byb2JlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCBjb25zdCBzdHJ1Y3QgcGNpX2RldmljZV9pZCAqcGlkKTsKK3ZvaWQgYmZhZF9vc19ycG9ydF9vbmxpbmVfd2FpdChzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKK2ludCBiZmFkX29zX2dldF9saW5rdXBfZGVsYXkoc3RydWN0IGJmYWRfcyAqYmZhZCk7CitpbnQgYmZhZF9pbnN0YWxsX21zaXhfaGFuZGxlcihzdHJ1Y3QgYmZhZF9zICpiZmFkKTsKKworZXh0ZXJuIHN0cnVjdCBpZHIgYmZhZF9pbV9wb3J0X2luZGV4OworZXh0ZXJuIHN0cnVjdCBsaXN0X2hlYWQgYmZhZF9saXN0OworZXh0ZXJuIGludCBiZmFfbHVuX3F1ZXVlX2RlcHRoOworZXh0ZXJuIGludCBiZmFkX3N1cHBvcnRlZF9mYzRzOworZXh0ZXJuIGludCBiZmFfbGlua3VwX2RlbGF5OworCisjZW5kaWYgLyogX19CRkFEX0RSVl9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9md2ltZy5jIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2Z3aW1nLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjJmNjk0OQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9md2ltZy5jCkBAIC0wLDAgKzEsOTUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhZF9md2ltZy5jIExpbnV4IGRyaXZlciBQQ0kgaW50ZXJmYWNlIG1vZHVsZS4KKyAqLworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKyNpbmNsdWRlIDxiZmFkX2Rydi5oPgorI2luY2x1ZGUgPGJmYWRfaW1fY29tcGF0Lmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc192ZXJzaW9uLmg+CisjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgorI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9mcy5oPgorI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+CisjaW5jbHVkZSA8YXNtL2ZjbnRsLmg+CisjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvZmlybXdhcmUuaD4KKyNpbmNsdWRlIDxiZmFfZndpbWdfcHJpdi5oPgorI2luY2x1ZGUgPGJmYS5oPgorCit1MzIgYmZpX2ltYWdlX2N0X3NpemU7Cit1MzIgYmZpX2ltYWdlX2NiX3NpemU7Cit1MzIgKmJmaV9pbWFnZV9jdDsKK3UzMiAqYmZpX2ltYWdlX2NiOworCisKKyNkZWZpbmUJQkZBRF9GV19GSUxFX0NUCSJjdGZ3LmJpbiIKKyNkZWZpbmUJQkZBRF9GV19GSUxFX0NCCSJjYmZ3LmJpbiIKKwordTMyICoKK2JmYWRfcmVhZF9maXJtd2FyZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwgdTMyICoqYmZpX2ltYWdlLAorCQkJdTMyICpiZmlfaW1hZ2Vfc2l6ZSwgY2hhciAqZndfbmFtZSkKK3sKKwljb25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3OworCisJaWYgKHJlcXVlc3RfZmlybXdhcmUoJmZ3LCBmd19uYW1lLCAmcGRldi0+ZGV2KSkgeworCQlwcmludGsoS0VSTl9BTEVSVCAiQ2FuJ3QgbG9jYXRlIGZpcm13YXJlICVzXG4iLCBmd19uYW1lKTsKKwkJZ290byBlcnJvcjsKKwl9CisKKwkqYmZpX2ltYWdlID0gdm1hbGxvYyhmdy0+c2l6ZSk7CisJaWYgKE5VTEwgPT0gKmJmaV9pbWFnZSkgeworCQlwcmludGsoS0VSTl9BTEVSVCAiRmFpbCB0byBhbGxvY2F0ZSBidWZmZXIgZm9yIGZ3IGltYWdlICIKKwkJCSJzaXplPSV4IVxuIiwgKHUzMikgZnctPnNpemUpOworCQlnb3RvIGVycm9yOworCX0KKworCW1lbWNweSgqYmZpX2ltYWdlLCBmdy0+ZGF0YSwgZnctPnNpemUpOworCSpiZmlfaW1hZ2Vfc2l6ZSA9IGZ3LT5zaXplL3NpemVvZih1MzIpOworCisJcmV0dXJuKCpiZmlfaW1hZ2UpOworCitlcnJvcjoKKwlyZXR1cm4oTlVMTCk7Cit9CisKK3UzMiAqCitiZmFkX2dldF9maXJtd2FyZV9idWYoc3RydWN0IHBjaV9kZXYgKnBkZXYpCit7CisJaWYgKHBkZXYtPmRldmljZSA9PSBCRkFfUENJX0RFVklDRV9JRF9DVCkgeworCQlpZiAoYmZpX2ltYWdlX2N0X3NpemUgPT0gMCkKKwkJCWJmYWRfcmVhZF9maXJtd2FyZShwZGV2LCAmYmZpX2ltYWdlX2N0LAorCQkJCSZiZmlfaW1hZ2VfY3Rfc2l6ZSwgQkZBRF9GV19GSUxFX0NUKTsKKwkJcmV0dXJuKGJmaV9pbWFnZV9jdCk7CisJfSBlbHNlIHsKKwkJaWYgKGJmaV9pbWFnZV9jYl9zaXplID09IDApCisJCQliZmFkX3JlYWRfZmlybXdhcmUocGRldiwgJmJmaV9pbWFnZV9jYiwKKwkJCQkmYmZpX2ltYWdlX2NiX3NpemUsIEJGQURfRldfRklMRV9DQik7CisJCXJldHVybihiZmlfaW1hZ2VfY2IpOworCX0KK30KKwordTMyICoKK2JmaV9pbWFnZV9jdF9nZXRfY2h1bmsodTMyIG9mZikKK3sgcmV0dXJuICh1MzIgKikoYmZpX2ltYWdlX2N0ICsgb2ZmKTsgfQorCit1MzIgKgorYmZpX2ltYWdlX2NiX2dldF9jaHVuayh1MzIgb2ZmKQoreyByZXR1cm4gKHUzMiAqKShiZmlfaW1hZ2VfY2IgKyBvZmYpOyB9CisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9pbS5jIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2ltLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTU4Yzk5MgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9pbS5jCkBAIC0wLDAgKzEsMTIzMCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFkX2ltLmMgTGludXggZHJpdmVyIElNIG1vZHVsZS4KKyAqLworCisjaW5jbHVkZSAiYmZhZF9kcnYuaCIKKyNpbmNsdWRlICJiZmFkX2ltLmgiCisjaW5jbHVkZSAiYmZhZF90cmNtb2QuaCIKKyNpbmNsdWRlICJiZmFfY2JfaW9pbV9tYWNyb3MuaCIKKyNpbmNsdWRlIDxmY2IvYmZhX2ZjYl9mY3BpbS5oPgorCitCRkFfVFJDX0ZJTEUoTERSViwgSU0pOworCitERUZJTkVfSURSKGJmYWRfaW1fcG9ydF9pbmRleCk7CitzdHJ1Y3Qgc2NzaV90cmFuc3BvcnRfdGVtcGxhdGUgKmJmYWRfaW1fc2NzaV90cmFuc3BvcnRfdGVtcGxhdGU7CitzdGF0aWMgdm9pZCBiZmFkX2ltX2l0bmltX3dvcmtfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOworc3RhdGljIGludCBiZmFkX2ltX3F1ZXVlY29tbWFuZChzdHJ1Y3Qgc2NzaV9jbW5kICpjbW5kLAorCQl2b2lkICgqZG9uZSkoc3RydWN0IHNjc2lfY21uZCAqKSk7CitzdGF0aWMgaW50IGJmYWRfaW1fc2xhdmVfYWxsb2Moc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2KTsKKwordm9pZAorYmZhX2NiX2lvaW1fZG9uZSh2b2lkICpkcnYsIHN0cnVjdCBiZmFkX2lvaW1fcyAqZGlvLAorCQkJZW51bSBiZmlfaW9pbV9zdGF0dXMgaW9fc3RhdHVzLCB1OCBzY3NpX3N0YXR1cywKKwkJCWludCBzbnNfbGVuLCB1OCAqc25zX2luZm8sIHMzMiByZXNpZHVlKQoreworCXN0cnVjdCBzY3NpX2NtbmQgKmNtbmQgPSAoc3RydWN0IHNjc2lfY21uZCAqKWRpbzsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQgPSBkcnY7CisJc3RydWN0IGJmYWRfaXRuaW1fZGF0YV9zICppdG5pbV9kYXRhOworCXN0cnVjdCBiZmFkX2l0bmltX3MgKml0bmltOworCisJc3dpdGNoIChpb19zdGF0dXMpIHsKKwljYXNlIEJGSV9JT0lNX1NUU19PSzoKKwkJYmZhX3RyYyhiZmFkLCBzY3NpX3N0YXR1cyk7CisJCWNtbmQtPnJlc3VsdCA9IFNjc2lSZXN1bHQoRElEX09LLCBzY3NpX3N0YXR1cyk7CisJCXNjc2lfc2V0X3Jlc2lkKGNtbmQsIDApOworCisJCWlmIChzbnNfbGVuID4gMCkgeworCQkJYmZhX3RyYyhiZmFkLCBzbnNfbGVuKTsKKwkJCWlmIChzbnNfbGVuID4gU0NTSV9TRU5TRV9CVUZGRVJTSVpFKQorCQkJCXNuc19sZW4gPSBTQ1NJX1NFTlNFX0JVRkZFUlNJWkU7CisJCQltZW1jcHkoY21uZC0+c2Vuc2VfYnVmZmVyLCBzbnNfaW5mbywgc25zX2xlbik7CisJCX0KKwkJaWYgKHJlc2lkdWUgPiAwKQorCQkJc2NzaV9zZXRfcmVzaWQoY21uZCwgcmVzaWR1ZSk7CisJCWJyZWFrOworCisJY2FzZSBCRklfSU9JTV9TVFNfQUJPUlRFRDoKKwljYXNlIEJGSV9JT0lNX1NUU19USU1FRE9VVDoKKwljYXNlIEJGSV9JT0lNX1NUU19QQVRIVE9WOgorCWRlZmF1bHQ6CisJCWNtbmQtPnJlc3VsdCA9IFNjc2lSZXN1bHQoRElEX0VSUk9SLCAwKTsKKwl9CisKKwkvKiBVbm1hcCBETUEsIGlmIGhvc3QgaXMgTlVMTCwgaXQgbWVhbnMgYSBzY3NpIHBhc3N0aHJ1IGNtZCAqLworCWlmIChjbW5kLT5kZXZpY2UtPmhvc3QgIT0gTlVMTCkKKwkJc2NzaV9kbWFfdW5tYXAoY21uZCk7CisKKwljbW5kLT5ob3N0X3NjcmliYmxlID0gTlVMTDsKKwliZmFfdHJjKGJmYWQsIGNtbmQtPnJlc3VsdCk7CisKKwlpdG5pbV9kYXRhID0gY21uZC0+ZGV2aWNlLT5ob3N0ZGF0YTsKKwlpZiAoaXRuaW1fZGF0YSkgeworCQlpdG5pbSA9IGl0bmltX2RhdGEtPml0bmltOworCQlpZiAoIWNtbmQtPnJlc3VsdCAmJiBpdG5pbSAmJgorCQkJIChiZmFfbHVuX3F1ZXVlX2RlcHRoID4gY21uZC0+ZGV2aWNlLT5xdWV1ZV9kZXB0aCkpIHsKKwkJCS8qIFF1ZXVlIGRlcHRoIGFkanVzdG1lbnQgZm9yIGdvb2Qgc3RhdHVzIGNvbXBsZXRpb24gKi8KKwkJCWJmYWRfb3NfcmFtcF91cF9xZGVwdGgoaXRuaW0sIGNtbmQtPmRldmljZSk7CisJCX0gZWxzZSBpZiAoY21uZC0+cmVzdWx0ID09IFNBTV9TVEFUX1RBU0tfU0VUX0ZVTEwgJiYgaXRuaW0pIHsKKwkJCS8qIHFmdWxsIGhhbmRsaW5nICovCisJCQliZmFkX29zX2hhbmRsZV9xZnVsbChpdG5pbSwgY21uZC0+ZGV2aWNlKTsKKwkJfQorCX0KKworCWNtbmQtPnNjc2lfZG9uZShjbW5kKTsKK30KKwordm9pZAorYmZhX2NiX2lvaW1fZ29vZF9jb21wKHZvaWQgKmRydiwgc3RydWN0IGJmYWRfaW9pbV9zICpkaW8pCit7CisJc3RydWN0IHNjc2lfY21uZCAqY21uZCA9IChzdHJ1Y3Qgc2NzaV9jbW5kICopZGlvOworCXN0cnVjdCBiZmFkX2l0bmltX2RhdGFfcyAqaXRuaW1fZGF0YTsKKwlzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbTsKKworCWNtbmQtPnJlc3VsdCA9IFNjc2lSZXN1bHQoRElEX09LLCBTQ1NJX1NUQVRVU19HT09EKTsKKworCS8qIFVubWFwIERNQSwgaWYgaG9zdCBpcyBOVUxMLCBpdCBtZWFucyBhIHNjc2kgcGFzc3RocnUgY21kICovCisJaWYgKGNtbmQtPmRldmljZS0+aG9zdCAhPSBOVUxMKQorCQlzY3NpX2RtYV91bm1hcChjbW5kKTsKKworCWNtbmQtPmhvc3Rfc2NyaWJibGUgPSBOVUxMOworCisJLyogUXVldWUgZGVwdGggYWRqdXN0bWVudCAqLworCWlmIChiZmFfbHVuX3F1ZXVlX2RlcHRoID4gY21uZC0+ZGV2aWNlLT5xdWV1ZV9kZXB0aCkgeworCQlpdG5pbV9kYXRhID0gY21uZC0+ZGV2aWNlLT5ob3N0ZGF0YTsKKwkJaWYgKGl0bmltX2RhdGEpIHsKKwkJCWl0bmltID0gaXRuaW1fZGF0YS0+aXRuaW07CisJCQlpZiAoaXRuaW0pCisJCQkJYmZhZF9vc19yYW1wX3VwX3FkZXB0aChpdG5pbSwgY21uZC0+ZGV2aWNlKTsKKwkJfQorCX0KKworCWNtbmQtPnNjc2lfZG9uZShjbW5kKTsKK30KKwordm9pZAorYmZhX2NiX2lvaW1fYWJvcnQodm9pZCAqZHJ2LCBzdHJ1Y3QgYmZhZF9pb2ltX3MgKmRpbykKK3sKKwlzdHJ1Y3Qgc2NzaV9jbW5kICpjbW5kID0gKHN0cnVjdCBzY3NpX2NtbmQgKilkaW87CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gZHJ2OworCisJY21uZC0+cmVzdWx0ID0gU2NzaVJlc3VsdChESURfRVJST1IsIDApOworCisJLyogVW5tYXAgRE1BLCBpZiBob3N0IGlzIE5VTEwsIGl0IG1lYW5zIGEgc2NzaSBwYXNzdGhydSBjbWQgKi8KKwlpZiAoY21uZC0+ZGV2aWNlLT5ob3N0ICE9IE5VTEwpCisJCXNjc2lfZG1hX3VubWFwKGNtbmQpOworCisJYmZhX3RyYyhiZmFkLCBjbW5kLT5yZXN1bHQpOworCWNtbmQtPmhvc3Rfc2NyaWJibGUgPSBOVUxMOworfQorCit2b2lkCitiZmFfY2JfdHNraW1fZG9uZSh2b2lkICpiZmFkLCBzdHJ1Y3QgYmZhZF90c2tpbV9zICpkdHNrLAorCQkgICBlbnVtIGJmaV90c2tpbV9zdGF0dXMgdHNrX3N0YXR1cykKK3sKKwlzdHJ1Y3Qgc2NzaV9jbW5kICpjbW5kID0gKHN0cnVjdCBzY3NpX2NtbmQgKilkdHNrOworCXdhaXRfcXVldWVfaGVhZF90ICp3cTsKKworCWNtbmQtPlNDcC5TdGF0dXMgfD0gdHNrX3N0YXR1cyA8PCAxOworCXNldF9iaXQoSU9fRE9ORV9CSVQsICh1bnNpZ25lZCBsb25nICopJmNtbmQtPlNDcC5TdGF0dXMpOworCXdxID0gKHdhaXRfcXVldWVfaGVhZF90ICopIGNtbmQtPlNDcC5wdHI7CisJY21uZC0+U0NwLnB0ciA9IE5VTEw7CisKKwlpZiAod3EpCisJCXdha2VfdXAod3EpOworfQorCit2b2lkCitiZmFfY2JfaW9pbV9yZXNmcmVlKHZvaWQgKmRydikKK3sKK30KKworLyoqCisgKiAgU2NzaV9Ib3N0X3RlbXBsYXRlIFNDU0kgaG9zdCB0ZW1wbGF0ZQorICovCisvKioKKyAqIFNjc2lfSG9zdCB0ZW1wbGF0ZSBlbnRyeSwgcmV0dXJucyBCRkFEIFBDSSBpbmZvLgorICovCitzdGF0aWMgY29uc3QgY2hhciAqCitiZmFkX2ltX2luZm8oc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QpCit7CisJc3RhdGljIGNoYXIgICAgIGJmYV9idWZbMjU2XTsKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYV9pb2NfYXR0cl9zICBpb2NfYXR0cjsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQgPSBpbV9wb3J0LT5iZmFkOworCisJbWVtc2V0KCZpb2NfYXR0ciwgMCwgc2l6ZW9mKGlvY19hdHRyKSk7CisJYmZhX2dldF9hdHRyKCZiZmFkLT5iZmEsICZpb2NfYXR0cik7CisKKwltZW1zZXQoYmZhX2J1ZiwgMCwgc2l6ZW9mKGJmYV9idWYpKTsKKwlzbnByaW50ZihiZmFfYnVmLCBzaXplb2YoYmZhX2J1ZiksCisJCSAiQnJvY2FkZSBGQy9GQ09FIEFkYXB0ZXIsICIgIm1vZGVsOiAlcyBod3BhdGg6ICVzIGRyaXZlcjogJXMiLAorCQkgaW9jX2F0dHIuYWRhcHRlcl9hdHRyLm1vZGVsLCBiZmFkLT5wY2lfbmFtZSwKKwkJIEJGQURfRFJJVkVSX1ZFUlNJT04pOworCXJldHVybiBiZmFfYnVmOworfQorCisvKioKKyAqIFNjc2lfSG9zdCB0ZW1wbGF0ZSBlbnRyeSwgYWJvcnRzIHRoZSBzcGVjaWZpZWQgU0NTSSBjb21tYW5kLgorICoKKyAqIFJldHVybnM6IFNVQ0NFU1Mgb3IgRkFJTEVELgorICovCitzdGF0aWMgaW50CitiZmFkX2ltX2Fib3J0X2hhbmRsZXIoc3RydWN0IHNjc2lfY21uZCAqY21uZCkKK3sKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCA9IGNtbmQtPmRldmljZS0+aG9zdDsKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhX2lvaW1fcyAqaGFsX2lvOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKwl1MzIgICAgICAgIHRpbWVvdXQ7CisJaW50ICAgICAgICAgICAgIHJjID0gRkFJTEVEOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCWhhbF9pbyA9IChzdHJ1Y3QgYmZhX2lvaW1fcyAqKSBjbW5kLT5ob3N0X3NjcmliYmxlOworCWlmICghaGFsX2lvKSB7CisJCS8qIElPIGhhcyBiZWVuIGNvbXBsZXRlZCwgcmV0cnVuIHN1Y2Nlc3MgKi8KKwkJcmMgPSBTVUNDRVNTOworCQlnb3RvIG91dDsKKwl9CisJaWYgKGhhbF9pby0+ZGlvICE9IChzdHJ1Y3QgYmZhZF9pb2ltX3MgKikgY21uZCkgeworCQlyYyA9IEZBSUxFRDsKKwkJZ290byBvdXQ7CisJfQorCisJYmZhX3RyYyhiZmFkLCBoYWxfaW8tPmlvdGFnKTsKKwliZmFfbG9nKGJmYWQtPmxvZ21vZCwgQkZBX0xPR19MSU5VWF9TQ1NJX0FCT1JULAorCQlpbV9wb3J0LT5zaG9zdC0+aG9zdF9ubywgY21uZCwgaGFsX2lvLT5pb3RhZyk7CisJYmZhX2lvaW1fYWJvcnQoaGFsX2lvKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCS8qIE5lZWQgdG8gd2FpdCB1bnRpbCB0aGUgY29tbWFuZCBnZXQgYWJvcnRlZCAqLworCXRpbWVvdXQgPSAxMDsKKwl3aGlsZSAoKHN0cnVjdCBiZmFfaW9pbV9zICopIGNtbmQtPmhvc3Rfc2NyaWJibGUgPT0gaGFsX2lvKSB7CisJCXNldF9jdXJyZW50X3N0YXRlKFRBU0tfVU5JTlRFUlJVUFRJQkxFKTsKKwkJc2NoZWR1bGVfdGltZW91dCh0aW1lb3V0KTsKKwkJaWYgKHRpbWVvdXQgPCA0ICogSFopCisJCQl0aW1lb3V0ICo9IDI7CisJfQorCisJY21uZC0+c2NzaV9kb25lKGNtbmQpOworCWJmYV90cmMoYmZhZCwgaGFsX2lvLT5pb3RhZyk7CisJYmZhX2xvZyhiZmFkLT5sb2dtb2QsIEJGQV9MT0dfTElOVVhfU0NTSV9BQk9SVF9DT01QLAorCQlpbV9wb3J0LT5zaG9zdC0+aG9zdF9ubywgY21uZCwgaGFsX2lvLT5pb3RhZyk7CisJcmV0dXJuIFNVQ0NFU1M7CitvdXQ6CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJcmV0dXJuIHJjOworfQorCitzdGF0aWMgYmZhX3N0YXR1c190CitiZmFkX2ltX3RhcmdldF9yZXNldF9zZW5kKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBzY3NpX2NtbmQgKmNtbmQsCisJCSAgICAgc3RydWN0IGJmYWRfaXRuaW1fcyAqaXRuaW0pCit7CisJc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbTsKKwlzdHJ1Y3QgYmZhX2l0bmltX3MgKmJmYV9pdG5pbTsKKwliZmFfc3RhdHVzX3QgICAgcmMgPSBCRkFfU1RBVFVTX09LOworCisJYmZhX2l0bmltID0gYmZhX2Zjc19pdG5pbV9nZXRfaGFsaXRuKCZpdG5pbS0+ZmNzX2l0bmltKTsKKwl0c2tpbSA9IGJmYV90c2tpbV9hbGxvYygmYmZhZC0+YmZhLCAoc3RydWN0IGJmYWRfdHNraW1fcyAqKSBjbW5kKTsKKwlpZiAoIXRza2ltKSB7CisJCUJGQV9ERVZfUFJJTlRGKGJmYWQsIEJGQV9FUlIsCisJCQkgICAgICAgInRhcmdldCByZXNldCwgZmFpbCB0byBhbGxvY2F0ZSB0c2tpbVxuIik7CisJCXJjID0gQkZBX1NUQVRVU19GQUlMRUQ7CisJCWdvdG8gb3V0OworCX0KKworCS8qCisJICogU2V0IGhvc3Rfc2NyaWJibGUgdG8gTlVMTCB0byBhdm9pZCBhYm9ydGluZyBhIHRhc2sgY29tbWFuZCBpZgorCSAqIGhhcHBlbnMuCisJICovCisJY21uZC0+aG9zdF9zY3JpYmJsZSA9IE5VTEw7CisJY21uZC0+U0NwLlN0YXR1cyA9IDA7CisJYmZhX2l0bmltID0gYmZhX2Zjc19pdG5pbV9nZXRfaGFsaXRuKCZpdG5pbS0+ZmNzX2l0bmltKTsKKwliZmFfdHNraW1fc3RhcnQodHNraW0sIGJmYV9pdG5pbSwgKGx1bl90KTAsCisJCQkgICAgRkNQX1RNX1RBUkdFVF9SRVNFVCwgQkZBRF9UQVJHRVRfUkVTRVRfVE1PKTsKK291dDoKKwlyZXR1cm4gcmM7Cit9CisKKy8qKgorICogU2NzaV9Ib3N0IHRlbXBsYXRlIGVudHJ5LCByZXNldHMgYSBMVU4gYW5kIGFib3J0IGl0cyBhbGwgY29tbWFuZHMuCisgKgorICogUmV0dXJuczogU1VDQ0VTUyBvciBGQUlMRUQuCisgKgorICovCitzdGF0aWMgaW50CitiZmFkX2ltX3Jlc2V0X2x1bl9oYW5kbGVyKHN0cnVjdCBzY3NpX2NtbmQgKmNtbmQpCit7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QgPSBjbW5kLT5kZXZpY2UtPmhvc3Q7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJCShzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKikgc2hvc3QtPmhvc3RkYXRhWzBdOworCXN0cnVjdCBiZmFkX2l0bmltX2RhdGFfcyAqaXRuaW1fZGF0YSA9IGNtbmQtPmRldmljZS0+aG9zdGRhdGE7CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhX3Rza2ltX3MgKnRza2ltOworCXN0cnVjdCBiZmFkX2l0bmltX3MgICAqaXRuaW07CisJc3RydWN0IGJmYV9pdG5pbV9zICpiZmFfaXRuaW07CisJREVDTEFSRV9XQUlUX1FVRVVFX0hFQUQod3EpOworCWludCAgICAgICAgICAgICByYyA9IFNVQ0NFU1M7CisJdW5zaWduZWQgbG9uZyAgIGZsYWdzOworCWVudW0gYmZpX3Rza2ltX3N0YXR1cyB0YXNrX3N0YXR1czsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwlpdG5pbSA9IGl0bmltX2RhdGEtPml0bmltOworCWlmICghaXRuaW0pIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJCXJjID0gRkFJTEVEOworCQlnb3RvIG91dDsKKwl9CisKKwl0c2tpbSA9IGJmYV90c2tpbV9hbGxvYygmYmZhZC0+YmZhLCAoc3RydWN0IGJmYWRfdHNraW1fcyAqKSBjbW5kKTsKKwlpZiAoIXRza2ltKSB7CisJCUJGQV9ERVZfUFJJTlRGKGJmYWQsIEJGQV9FUlIsCisJCQkJIkxVTiByZXNldCwgZmFpbCB0byBhbGxvY2F0ZSB0c2tpbSIpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJcmMgPSBGQUlMRUQ7CisJCWdvdG8gb3V0OworCX0KKworCS8qKgorCSAqIFNldCBob3N0X3NjcmliYmxlIHRvIE5VTEwgdG8gYXZvaWQgYWJvcnRpbmcgYSB0YXNrIGNvbW1hbmQKKwkgKiBpZiBoYXBwZW5zLgorCSAqLworCWNtbmQtPmhvc3Rfc2NyaWJibGUgPSBOVUxMOworCWNtbmQtPlNDcC5wdHIgPSAoY2hhciAqKSZ3cTsKKwljbW5kLT5TQ3AuU3RhdHVzID0gMDsKKwliZmFfaXRuaW0gPSBiZmFfZmNzX2l0bmltX2dldF9oYWxpdG4oJml0bmltLT5mY3NfaXRuaW0pOworCWJmYV90c2tpbV9zdGFydCh0c2tpbSwgYmZhX2l0bmltLAorCQkJICAgIGJmYWRfaW50X3RvX2x1bihjbW5kLT5kZXZpY2UtPmx1biksCisJCQkgICAgRkNQX1RNX0xVTl9SRVNFVCwgQkZBRF9MVU5fUkVTRVRfVE1PKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCXdhaXRfZXZlbnQod3EsIHRlc3RfYml0KElPX0RPTkVfQklULAorCQkJKHVuc2lnbmVkIGxvbmcgKikmY21uZC0+U0NwLlN0YXR1cykpOworCisJdGFza19zdGF0dXMgPSBjbW5kLT5TQ3AuU3RhdHVzID4+IDE7CisJaWYgKHRhc2tfc3RhdHVzICE9IEJGSV9UU0tJTV9TVFNfT0spIHsKKwkJQkZBX0RFVl9QUklOVEYoYmZhZCwgQkZBX0VSUiwgIkxVTiByZXNldCBmYWlsdXJlLCBzdGF0dXM6ICVkXG4iLAorCQkJICAgICAgIHRhc2tfc3RhdHVzKTsKKwkJcmMgPSBGQUlMRUQ7CisJfQorCitvdXQ6CisJcmV0dXJuIHJjOworfQorCisvKioKKyAqIFNjc2lfSG9zdCB0ZW1wbGF0ZSBlbnRyeSwgcmVzZXRzIHRoZSBidXMgYW5kIGFib3J0IGFsbCBjb21tYW5kcy4KKyAqLworc3RhdGljIGludAorYmZhZF9pbV9yZXNldF9idXNfaGFuZGxlcihzdHJ1Y3Qgc2NzaV9jbW5kICpjbW5kKQoreworCXN0cnVjdCBTY3NpX0hvc3QgKnNob3N0ID0gY21uZC0+ZGV2aWNlLT5ob3N0OworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCA9CisJCQkJKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqKSBzaG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhZF9pdG5pbV9zICAgKml0bmltOworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKwl1MzIgICAgICAgIGksIHJjLCBlcnJfY250ID0gMDsKKwlERUNMQVJFX1dBSVRfUVVFVUVfSEVBRCh3cSk7CisJZW51bSBiZmlfdHNraW1fc3RhdHVzIHRhc2tfc3RhdHVzOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCWZvciAoaSA9IDA7IGkgPCBNQVhfRkNQX1RBUkdFVDsgaSsrKSB7CisJCWl0bmltID0gYmZhZF9vc19nZXRfaXRuaW0oaW1fcG9ydCwgaSk7CisJCWlmIChpdG5pbSkgeworCQkJY21uZC0+U0NwLnB0ciA9IChjaGFyICopJndxOworCQkJcmMgPSBiZmFkX2ltX3RhcmdldF9yZXNldF9zZW5kKGJmYWQsIGNtbmQsIGl0bmltKTsKKwkJCWlmIChyYyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCQkJZXJyX2NudCsrOworCQkJCWNvbnRpbnVlOworCQkJfQorCisJCQkvKiB3YWl0IHRhcmdldCByZXNldCB0byBjb21wbGV0ZSAqLworCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJCQl3YWl0X2V2ZW50KHdxLCB0ZXN0X2JpdChJT19ET05FX0JJVCwKKwkJCQkJKHVuc2lnbmVkIGxvbmcgKikmY21uZC0+U0NwLlN0YXR1cykpOworCQkJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCisJCQl0YXNrX3N0YXR1cyA9IGNtbmQtPlNDcC5TdGF0dXMgPj4gMTsKKwkJCWlmICh0YXNrX3N0YXR1cyAhPSBCRklfVFNLSU1fU1RTX09LKSB7CisJCQkJQkZBX0RFVl9QUklOVEYoYmZhZCwgQkZBX0VSUiwKKwkJCQkJInRhcmdldCByZXNldCBmYWlsdXJlLCIKKwkJCQkJIiBzdGF0dXM6ICVkXG4iLCB0YXNrX3N0YXR1cyk7CisJCQkJZXJyX2NudCsrOworCQkJfQorCQl9CisJfQorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCisJaWYgKGVycl9jbnQpCisJCXJldHVybiBGQUlMRUQ7CisKKwlyZXR1cm4gU1VDQ0VTUzsKK30KKworLyoqCisgKiBTY3NpX0hvc3QgdGVtcGxhdGUgZW50cnkgc2xhdmVfZGVzdHJveS4KKyAqLworc3RhdGljIHZvaWQKK2JmYWRfaW1fc2xhdmVfZGVzdHJveShzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYpCit7CisJc2Rldi0+aG9zdGRhdGEgPSBOVUxMOworCXJldHVybjsKK30KKworLyoqCisgKiAgQkZBIEZDUyBpdG5pbSBjYWxsYmFja3MKKyAqLworCisvKioKKyAqIEJGQSBGQ1MgaXRuaW0gYWxsb2MgY2FsbGJhY2ssIGFmdGVyIHN1Y2Nlc3NmdWwgUFJMSQorICogQ29udGV4dDogSW50ZXJydXB0CisgKi8KK3ZvaWQKK2JmYV9mY2JfaXRuaW1fYWxsb2Moc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqKml0bmltLAorCQkgICAgc3RydWN0IGJmYWRfaXRuaW1fcyAqKml0bmltX2RydikKK3sKKwkqaXRuaW1fZHJ2ID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGJmYWRfaXRuaW1fcyksIEdGUF9BVE9NSUMpOworCWlmICgqaXRuaW1fZHJ2ID09IE5VTEwpCisJCXJldHVybjsKKworCSgqaXRuaW1fZHJ2KS0+aW0gPSBiZmFkLT5pbTsKKwkqaXRuaW0gPSAmKCppdG5pbV9kcnYpLT5mY3NfaXRuaW07CisJKCppdG5pbV9kcnYpLT5zdGF0ZSA9IElUTklNX1NUQVRFX05PTkU7CisKKwkvKgorCSAqIEluaXRpYXplIHRoZSBpdG5pbV93b3JrCisJICovCisJSU5JVF9XT1JLKCYoKml0bmltX2RydiktPml0bmltX3dvcmssIGJmYWRfaW1faXRuaW1fd29ya19oYW5kbGVyKTsKKwliZmFkLT5iZmFkX2ZsYWdzIHw9IEJGQURfUlBPUlRfT05MSU5FOworfQorCisvKioKKyAqIEJGQSBGQ1MgaXRuaW0gZnJlZSBjYWxsYmFjay4KKyAqIENvbnRleHQ6IEludGVycnVwdC4gYmZhZF9sb2NrIGlzIGhlbGQKKyAqLwordm9pZAorYmZhX2ZjYl9pdG5pbV9mcmVlKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFkX2l0bmltX3MgKml0bmltX2RydikKK3sKKwlzdHJ1Y3QgYmZhZF9wb3J0X3MgICAgKnBvcnQ7CisJd3duX3Qgd3dwbjsKKwl1MzIgZmNpZDsKKwljaGFyIHd3cG5fc3RyWzMyXSwgZmNpZF9zdHJbMTZdOworCisJLyogb25saW5lIHRvIGZyZWUgc3RhdGUgdHJhbnN0aW9uIHNob3VsZCBub3QgaGFwcGVuICovCisJYmZhX2Fzc2VydChpdG5pbV9kcnYtPnN0YXRlICE9IElUTklNX1NUQVRFX09OTElORSk7CisKKwlpdG5pbV9kcnYtPnF1ZXVlX3dvcmsgPSAxOworCS8qIG9mZmxpbmUgcmVxdWVzdCBpcyBub3QgeWV0IGRvbmUsIHVzZSB0aGUgc2FtZSByZXF1ZXN0IHRvIGZyZWUgKi8KKwlpZiAoaXRuaW1fZHJ2LT5zdGF0ZSA9PSBJVE5JTV9TVEFURV9PRkZMSU5FX1BFTkRJTkcpCisJCWl0bmltX2Rydi0+cXVldWVfd29yayA9IDA7CisKKwlpdG5pbV9kcnYtPnN0YXRlID0gSVROSU1fU1RBVEVfRlJFRTsKKwlwb3J0ID0gYmZhX2Zjc19pdG5pbV9nZXRfZHJ2cG9ydCgmaXRuaW1fZHJ2LT5mY3NfaXRuaW0pOworCWl0bmltX2Rydi0+aW1fcG9ydCA9IHBvcnQtPmltX3BvcnQ7CisJd3dwbiA9IGJmYV9mY3NfaXRuaW1fZ2V0X3B3d24oJml0bmltX2Rydi0+ZmNzX2l0bmltKTsKKwlmY2lkID0gYmZhX2Zjc19pdG5pbV9nZXRfZmNpZCgmaXRuaW1fZHJ2LT5mY3NfaXRuaW0pOworCXd3bjJzdHIod3dwbl9zdHIsIHd3cG4pOworCWZjaWQyc3RyKGZjaWRfc3RyLCBmY2lkKTsKKwliZmFfbG9nKGJmYWQtPmxvZ21vZCwgQkZBX0xPR19MSU5VWF9JVE5JTV9GUkVFLAorCQlwb3J0LT5pbV9wb3J0LT5zaG9zdC0+aG9zdF9ubywKKwkJZmNpZF9zdHIsIHd3cG5fc3RyKTsKKwliZmFkX29zX2l0bmltX3Byb2Nlc3MoaXRuaW1fZHJ2KTsKK30KKworLyoqCisgKiBCRkEgRkNTIGl0bmltIG9ubGluZSBjYWxsYmFjay4KKyAqIENvbnRleHQ6IEludGVycnVwdC4gYmZhZF9sb2NrIGlzIGhlbGQKKyAqLwordm9pZAorYmZhX2ZjYl9pdG5pbV9vbmxpbmUoc3RydWN0IGJmYWRfaXRuaW1fcyAqaXRuaW1fZHJ2KQoreworCXN0cnVjdCBiZmFkX3BvcnRfcyAgICAqcG9ydDsKKworCWl0bmltX2Rydi0+YmZhX2l0bmltID0gYmZhX2Zjc19pdG5pbV9nZXRfaGFsaXRuKCZpdG5pbV9kcnYtPmZjc19pdG5pbSk7CisJcG9ydCA9IGJmYV9mY3NfaXRuaW1fZ2V0X2RydnBvcnQoJml0bmltX2Rydi0+ZmNzX2l0bmltKTsKKwlpdG5pbV9kcnYtPnN0YXRlID0gSVROSU1fU1RBVEVfT05MSU5FOworCWl0bmltX2Rydi0+cXVldWVfd29yayA9IDE7CisJaXRuaW1fZHJ2LT5pbV9wb3J0ID0gcG9ydC0+aW1fcG9ydDsKKwliZmFkX29zX2l0bmltX3Byb2Nlc3MoaXRuaW1fZHJ2KTsKK30KKworLyoqCisgKiBCRkEgRkNTIGl0bmltIG9mZmxpbmUgY2FsbGJhY2suCisgKiBDb250ZXh0OiBJbnRlcnJ1cHQuIGJmYWRfbG9jayBpcyBoZWxkCisgKi8KK3ZvaWQKK2JmYV9mY2JfaXRuaW1fb2ZmbGluZShzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbV9kcnYpCit7CisJc3RydWN0IGJmYWRfcG9ydF9zICAgICpwb3J0OworCXN0cnVjdCBiZmFkX3MgKmJmYWQ7CisKKwlwb3J0ID0gYmZhX2Zjc19pdG5pbV9nZXRfZHJ2cG9ydCgmaXRuaW1fZHJ2LT5mY3NfaXRuaW0pOworCWJmYWQgPSBwb3J0LT5iZmFkOworCWlmICgoYmZhZC0+cHBvcnQuZmxhZ3MgJiBCRkFEX1BPUlRfREVMRVRFKSB8fAorCQkgKHBvcnQtPmZsYWdzICYgQkZBRF9QT1JUX0RFTEVURSkpIHsKKwkJaXRuaW1fZHJ2LT5zdGF0ZSA9IElUTklNX1NUQVRFX09GRkxJTkU7CisJCXJldHVybjsKKwl9CisJaXRuaW1fZHJ2LT5pbV9wb3J0ID0gcG9ydC0+aW1fcG9ydDsKKwlpdG5pbV9kcnYtPnN0YXRlID0gSVROSU1fU1RBVEVfT0ZGTElORV9QRU5ESU5HOworCWl0bmltX2Rydi0+cXVldWVfd29yayA9IDE7CisJYmZhZF9vc19pdG5pbV9wcm9jZXNzKGl0bmltX2Rydik7Cit9CisKKy8qKgorICogQkZBIEZDUyBpdG5pbSB0aW1lb3V0IGNhbGxiYWNrLgorICogQ29udGV4dDogSW50ZXJydXB0LiBiZmFkX2xvY2sgaXMgaGVsZAorICovCit2b2lkIGJmYV9mY2JfaXRuaW1fdG92KHN0cnVjdCBiZmFkX2l0bmltX3MgKml0bmltKQoreworCWl0bmltLT5zdGF0ZSA9IElUTklNX1NUQVRFX1RJTUVPVVQ7Cit9CisKKy8qKgorICogUGF0aCBUT1YgcHJvY2Vzc2luZyBiZWdpbiBub3RpZmljYXRpb24gLS0gZHVtbXkgZm9yIGxpbnV4CisgKi8KK3ZvaWQKK2JmYV9mY2JfaXRuaW1fdG92X2JlZ2luKHN0cnVjdCBiZmFkX2l0bmltX3MgKml0bmltKQoreworfQorCisKKworLyoqCisgKiBBbGxvY2F0ZSBhIFNjc2lfSG9zdCBmb3IgYSBwb3J0LgorICovCitpbnQKK2JmYWRfaW1fc2NzaV9ob3N0X2FsbG9jKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCkKK3sKKwlpbnQgZXJyb3IgPSAxOworCisJaWYgKCFpZHJfcHJlX2dldCgmYmZhZF9pbV9wb3J0X2luZGV4LCBHRlBfS0VSTkVMKSkgeworCQlwcmludGsoS0VSTl9XQVJOSU5HICJpZHJfcHJlX2dldCBmYWlsdXJlXG4iKTsKKwkJZ290byBvdXQ7CisJfQorCisJZXJyb3IgPSBpZHJfZ2V0X25ldygmYmZhZF9pbV9wb3J0X2luZGV4LCBpbV9wb3J0LAorCQkJCQkgJmltX3BvcnQtPmlkcl9pZCk7CisJaWYgKGVycm9yKSB7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgImlkcl9nZXRfbmV3IGZhaWx1cmVcbiIpOworCQlnb3RvIG91dDsKKwl9CisKKwlpbV9wb3J0LT5zaG9zdCA9IGJmYWRfb3Nfc2NzaV9ob3N0X2FsbG9jKGltX3BvcnQsIGJmYWQpOworCWlmICghaW1fcG9ydC0+c2hvc3QpIHsKKwkJZXJyb3IgPSAxOworCQlnb3RvIG91dF9mcmVlX2lkcjsKKwl9CisKKwlpbV9wb3J0LT5zaG9zdC0+aG9zdGRhdGFbMF0gPSAodW5zaWduZWQgbG9uZylpbV9wb3J0OworCWltX3BvcnQtPnNob3N0LT51bmlxdWVfaWQgPSBpbV9wb3J0LT5pZHJfaWQ7CisJaW1fcG9ydC0+c2hvc3QtPnRoaXNfaWQgPSAtMTsKKwlpbV9wb3J0LT5zaG9zdC0+bWF4X2lkID0gTUFYX0ZDUF9UQVJHRVQ7CisJaW1fcG9ydC0+c2hvc3QtPm1heF9sdW4gPSBNQVhfRkNQX0xVTjsKKwlpbV9wb3J0LT5zaG9zdC0+bWF4X2NtZF9sZW4gPSAxNjsKKwlpbV9wb3J0LT5zaG9zdC0+Y2FuX3F1ZXVlID0gYmZhZC0+Y2ZnX2RhdGEuaW9jX3F1ZXVlX2RlcHRoOworCWltX3BvcnQtPnNob3N0LT50cmFuc3BvcnR0ID0gYmZhZF9pbV9zY3NpX3RyYW5zcG9ydF90ZW1wbGF0ZTsKKworCWVycm9yID0gYmZhZF9vc19zY3NpX2FkZF9ob3N0KGltX3BvcnQtPnNob3N0LCBpbV9wb3J0LCBiZmFkKTsKKwlpZiAoZXJyb3IpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiYmZhZF9vc19zY3NpX2FkZF9ob3N0IGZhaWx1cmUgJWRcbiIsCisJCQkJCQkJZXJyb3IpOworCQlnb3RvIG91dF9mY19yZWw7CisJfQorCisJLyogc2V0dXAgaG9zdCBmaXhlZCBhdHRyaWJ1dGUgaWYgdGhlIGxrIHN1cHBvcnRzICovCisJYmZhZF9vc19mY19ob3N0X2luaXQoaW1fcG9ydCk7CisKKwlyZXR1cm4gMDsKKworb3V0X2ZjX3JlbDoKKwlzY3NpX2hvc3RfcHV0KGltX3BvcnQtPnNob3N0KTsKK291dF9mcmVlX2lkcjoKKwlpZHJfcmVtb3ZlKCZiZmFkX2ltX3BvcnRfaW5kZXgsIGltX3BvcnQtPmlkcl9pZCk7CitvdXQ6CisJcmV0dXJuIGVycm9yOworfQorCit2b2lkCitiZmFkX2ltX3Njc2lfaG9zdF9mcmVlKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCisJYmZhX3RyYyhiZmFkLCBiZmFkLT5pbnN0X25vKTsKKwliZmFfbG9nKGJmYWQtPmxvZ21vZCwgQkZBX0xPR19MSU5VWF9TQ1NJX0hPU1RfRlJFRSwKKwkJCWltX3BvcnQtPnNob3N0LT5ob3N0X25vKTsKKworCWZjX3JlbW92ZV9ob3N0KGltX3BvcnQtPnNob3N0KTsKKworCXNjc2lfcmVtb3ZlX2hvc3QoaW1fcG9ydC0+c2hvc3QpOworCXNjc2lfaG9zdF9wdXQoaW1fcG9ydC0+c2hvc3QpOworCisJc3Bpbl9sb2NrX2lycXNhdmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCWlkcl9yZW1vdmUoJmJmYWRfaW1fcG9ydF9pbmRleCwgaW1fcG9ydC0+aWRyX2lkKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKK30KKworc3RhdGljIHZvaWQKK2JmYWRfaW1fcG9ydF9kZWxldGVfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCit7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0ID0KKwkJY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBiZmFkX2ltX3BvcnRfcywgcG9ydF9kZWxldGVfd29yayk7CisKKwliZmFkX2ltX3Njc2lfaG9zdF9mcmVlKGltX3BvcnQtPmJmYWQsIGltX3BvcnQpOworCWJmYWRfaW1fcG9ydF9jbGVhbihpbV9wb3J0KTsKKwlrZnJlZShpbV9wb3J0KTsKK30KKworYmZhX3N0YXR1c190CitiZmFkX2ltX3BvcnRfbmV3KHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFkX3BvcnRfcyAqcG9ydCkKK3sKKwlpbnQgICAgICAgICAgICAgcmMgPSBCRkFfU1RBVFVTX09LOworCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydDsKKworCWltX3BvcnQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MpLCBHRlBfQVRPTUlDKTsKKwlpZiAoaW1fcG9ydCA9PSBOVUxMKSB7CisJCXJjID0gQkZBX1NUQVRVU19FTk9NRU07CisJCWdvdG8gZXh0OworCX0KKwlwb3J0LT5pbV9wb3J0ID0gaW1fcG9ydDsKKwlpbV9wb3J0LT5wb3J0ID0gcG9ydDsKKwlpbV9wb3J0LT5iZmFkID0gYmZhZDsKKworCUlOSVRfV09SSygmaW1fcG9ydC0+cG9ydF9kZWxldGVfd29yaywgYmZhZF9pbV9wb3J0X2RlbGV0ZV9oYW5kbGVyKTsKKwlJTklUX0xJU1RfSEVBRCgmaW1fcG9ydC0+aXRuaW1fbWFwcGVkX2xpc3QpOworCUlOSVRfTElTVF9IRUFEKCZpbV9wb3J0LT5iaW5kaW5nX2xpc3QpOworCitleHQ6CisJcmV0dXJuIHJjOworfQorCit2b2lkCitiZmFkX2ltX3BvcnRfZGVsZXRlKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFkX3BvcnRfcyAqcG9ydCkKK3sKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPSBwb3J0LT5pbV9wb3J0OworCisJcXVldWVfd29yayhiZmFkLT5pbS0+ZHJ2X3dvcmtxLAorCQkJCSZpbV9wb3J0LT5wb3J0X2RlbGV0ZV93b3JrKTsKK30KKwordm9pZAorYmZhZF9pbV9wb3J0X2NsZWFuKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCkKK3sKKwlzdHJ1Y3QgYmZhZF9mY3BfYmluZGluZyAqYnAsICpicF9uZXc7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKKwlzdHJ1Y3QgYmZhZF9zICpiZmFkID0gIGltX3BvcnQtPmJmYWQ7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGJwLCBicF9uZXcsICZpbV9wb3J0LT5iaW5kaW5nX2xpc3QsCisJCQkJCWxpc3RfZW50cnkpIHsKKwkJbGlzdF9kZWwoJmJwLT5saXN0X2VudHJ5KTsKKwkJa2ZyZWUoYnApOworCX0KKworCS8qIHRoZSBpdG5pbV9tYXBwZWRfbGlzdCBtdXN0IGJlIGVtcHR5IGF0IHRoaXMgdGltZSAqLworCWJmYV9hc3NlcnQobGlzdF9lbXB0eSgmaW1fcG9ydC0+aXRuaW1fbWFwcGVkX2xpc3QpKTsKKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworfQorCit2b2lkCitiZmFkX2ltX3BvcnRfb25saW5lKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFkX3BvcnRfcyAqcG9ydCkKK3sKK30KKwordm9pZAorYmZhZF9pbV9wb3J0X29mZmxpbmUoc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYWRfcG9ydF9zICpwb3J0KQoreworfQorCitiZmFfc3RhdHVzX3QKK2JmYWRfaW1fcHJvYmUoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlzdHJ1Y3QgYmZhZF9pbV9zICAgICAgKmltOworCWJmYV9zdGF0dXNfdCAgICByYyA9IEJGQV9TVEFUVVNfT0s7CisKKwlpbSA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBiZmFkX2ltX3MpLCBHRlBfS0VSTkVMKTsKKwlpZiAoaW0gPT0gTlVMTCkgeworCQlyYyA9IEJGQV9TVEFUVVNfRU5PTUVNOworCQlnb3RvIGV4dDsKKwl9CisKKwliZmFkLT5pbSA9IGltOworCWltLT5iZmFkID0gYmZhZDsKKworCWlmIChiZmFkX29zX3RocmVhZF93b3JrcShiZmFkKSAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWtmcmVlKGltKTsKKwkJcmMgPSBCRkFfU1RBVFVTX0ZBSUxFRDsKKwl9CisKK2V4dDoKKwlyZXR1cm4gcmM7Cit9CisKK3ZvaWQKK2JmYWRfaW1fcHJvYmVfdW5kbyhzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworCWlmIChiZmFkLT5pbSkgeworCQliZmFkX29zX2Rlc3Ryb3lfd29ya3EoYmZhZC0+aW0pOworCQlrZnJlZShiZmFkLT5pbSk7CisJCWJmYWQtPmltID0gTlVMTDsKKwl9Cit9CisKKworCisKK2ludAorYmZhZF9vc19zY3NpX2FkZF9ob3N0KHN0cnVjdCBTY3NpX0hvc3QgKnNob3N0LCBzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQsCisJCQlzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworICAgIHN0cnVjdCBkZXZpY2UgKmRldjsKKworICAgIGlmIChpbV9wb3J0LT5wb3J0LT5wdmJfdHlwZSA9PSBCRkFEX1BPUlRfUEhZU19CQVNFKQorCQlkZXYgPSAmYmZhZC0+cGNpZGV2LT5kZXY7CisgICAgZWxzZQorCQlkZXYgPSAmYmZhZC0+cHBvcnQuaW1fcG9ydC0+c2hvc3QtPnNob3N0X2dlbmRldjsKKworICAgIHJldHVybiBzY3NpX2FkZF9ob3N0KHNob3N0LCBkZXYpOworfQorCitzdHJ1Y3QgU2NzaV9Ib3N0ICoKK2JmYWRfb3Nfc2NzaV9ob3N0X2FsbG9jKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCwgc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlzdHJ1Y3Qgc2NzaV9ob3N0X3RlbXBsYXRlICpzaHQ7CisKKwlpZiAoaW1fcG9ydC0+cG9ydC0+cHZiX3R5cGUgPT0gQkZBRF9QT1JUX1BIWVNfQkFTRSkKKwkJc2h0ID0gJmJmYWRfaW1fc2NzaV9ob3N0X3RlbXBsYXRlOworCWVsc2UKKwkJc2h0ID0gJmJmYWRfaW1fdnBvcnRfdGVtcGxhdGU7CisKKwlzaHQtPnNnX3RhYmxlc2l6ZSA9IGJmYWQtPmNmZ19kYXRhLmlvX21heF9zZ2U7CisKKwlyZXR1cm4gc2NzaV9ob3N0X2FsbG9jKHNodCwgc2l6ZW9mKHVuc2lnbmVkIGxvbmcpKTsKK30KKwordm9pZAorYmZhZF9vc19zY3NpX2hvc3RfZnJlZShzdHJ1Y3QgYmZhZF9zICpiZmFkLCBzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQpCit7CisJZmx1c2hfd29ya3F1ZXVlKGJmYWQtPmltLT5kcnZfd29ya3EpOworCWJmYWRfaW1fc2NzaV9ob3N0X2ZyZWUoaW1fcG9ydC0+YmZhZCwgaW1fcG9ydCk7CisJYmZhZF9pbV9wb3J0X2NsZWFuKGltX3BvcnQpOworCWtmcmVlKGltX3BvcnQpOworfQorCit2b2lkCitiZmFkX29zX2Rlc3Ryb3lfd29ya3Eoc3RydWN0IGJmYWRfaW1fcyAqaW0pCit7CisJaWYgKGltICYmIGltLT5kcnZfd29ya3EpIHsKKwkJZGVzdHJveV93b3JrcXVldWUoaW0tPmRydl93b3JrcSk7CisJCWltLT5kcnZfd29ya3EgPSBOVUxMOworCX0KK30KKworYmZhX3N0YXR1c190CitiZmFkX29zX3RocmVhZF93b3JrcShzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworCXN0cnVjdCBiZmFkX2ltX3MgICAgICAqaW0gPSBiZmFkLT5pbTsKKworCWJmYV90cmMoYmZhZCwgMCk7CisJc25wcmludGYoaW0tPmRydl93b3JrcV9uYW1lLCBCRkFEX0tPQkpfTkFNRV9MRU4sICJiZmFkX3dxXyVkIiwKKwkJIGJmYWQtPmluc3Rfbm8pOworCWltLT5kcnZfd29ya3EgPSBjcmVhdGVfc2luZ2xldGhyZWFkX3dvcmtxdWV1ZShpbS0+ZHJ2X3dvcmtxX25hbWUpOworCWlmICghaW0tPmRydl93b3JrcSkKKwkJcmV0dXJuIEJGQV9TVEFUVVNfRkFJTEVEOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogU2NzaV9Ib3N0IHRlbXBsYXRlIGVudHJ5LgorICoKKyAqIERlc2NyaXB0aW9uOgorICogT1MgZW50cnkgcG9pbnQgdG8gYWRqdXN0IHRoZSBxdWV1ZV9kZXB0aHMgb24gYSBwZXItZGV2aWNlIGJhc2lzLgorICogQ2FsbGVkIG9uY2UgcGVyIGRldmljZSBkdXJpbmcgdGhlIGJ1cyBzY2FuLgorICogUmV0dXJuIG5vbi16ZXJvIGlmIGZhaWxzLgorICovCitzdGF0aWMgaW50CitiZmFkX2ltX3NsYXZlX2NvbmZpZ3VyZShzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYpCit7CisJaWYgKHNkZXYtPnRhZ2dlZF9zdXBwb3J0ZWQpCisJCXNjc2lfYWN0aXZhdGVfdGNxKHNkZXYsIGJmYV9sdW5fcXVldWVfZGVwdGgpOworCWVsc2UKKwkJc2NzaV9kZWFjdGl2YXRlX3RjcShzZGV2LCBiZmFfbHVuX3F1ZXVlX2RlcHRoKTsKKworCXJldHVybiAwOworfQorCitzdHJ1Y3Qgc2NzaV9ob3N0X3RlbXBsYXRlIGJmYWRfaW1fc2NzaV9ob3N0X3RlbXBsYXRlID0geworCS5tb2R1bGUgPSBUSElTX01PRFVMRSwKKwkubmFtZSA9IEJGQURfRFJJVkVSX05BTUUsCisJLmluZm8gPSBiZmFkX2ltX2luZm8sCisJLnF1ZXVlY29tbWFuZCA9IGJmYWRfaW1fcXVldWVjb21tYW5kLAorCS5laF9hYm9ydF9oYW5kbGVyID0gYmZhZF9pbV9hYm9ydF9oYW5kbGVyLAorCS5laF9kZXZpY2VfcmVzZXRfaGFuZGxlciA9IGJmYWRfaW1fcmVzZXRfbHVuX2hhbmRsZXIsCisJLmVoX2J1c19yZXNldF9oYW5kbGVyID0gYmZhZF9pbV9yZXNldF9idXNfaGFuZGxlciwKKworCS5zbGF2ZV9hbGxvYyA9IGJmYWRfaW1fc2xhdmVfYWxsb2MsCisJLnNsYXZlX2NvbmZpZ3VyZSA9IGJmYWRfaW1fc2xhdmVfY29uZmlndXJlLAorCS5zbGF2ZV9kZXN0cm95ID0gYmZhZF9pbV9zbGF2ZV9kZXN0cm95LAorCisJLnRoaXNfaWQgPSAtMSwKKwkuc2dfdGFibGVzaXplID0gQkZBRF9JT19NQVhfU0dFLAorCS5jbWRfcGVyX2x1biA9IDMsCisJLnVzZV9jbHVzdGVyaW5nID0gRU5BQkxFX0NMVVNURVJJTkcsCisJLnNob3N0X2F0dHJzID0gYmZhZF9pbV9ob3N0X2F0dHJzLAorCS5tYXhfc2VjdG9ycyA9IDB4RkZGRiwKK307CisKK3N0cnVjdCBzY3NpX2hvc3RfdGVtcGxhdGUgYmZhZF9pbV92cG9ydF90ZW1wbGF0ZSA9IHsKKwkubW9kdWxlID0gVEhJU19NT0RVTEUsCisJLm5hbWUgPSBCRkFEX0RSSVZFUl9OQU1FLAorCS5pbmZvID0gYmZhZF9pbV9pbmZvLAorCS5xdWV1ZWNvbW1hbmQgPSBiZmFkX2ltX3F1ZXVlY29tbWFuZCwKKwkuZWhfYWJvcnRfaGFuZGxlciA9IGJmYWRfaW1fYWJvcnRfaGFuZGxlciwKKwkuZWhfZGV2aWNlX3Jlc2V0X2hhbmRsZXIgPSBiZmFkX2ltX3Jlc2V0X2x1bl9oYW5kbGVyLAorCS5laF9idXNfcmVzZXRfaGFuZGxlciA9IGJmYWRfaW1fcmVzZXRfYnVzX2hhbmRsZXIsCisKKwkuc2xhdmVfYWxsb2MgPSBiZmFkX2ltX3NsYXZlX2FsbG9jLAorCS5zbGF2ZV9jb25maWd1cmUgPSBiZmFkX2ltX3NsYXZlX2NvbmZpZ3VyZSwKKwkuc2xhdmVfZGVzdHJveSA9IGJmYWRfaW1fc2xhdmVfZGVzdHJveSwKKworCS50aGlzX2lkID0gLTEsCisJLnNnX3RhYmxlc2l6ZSA9IEJGQURfSU9fTUFYX1NHRSwKKwkuY21kX3Blcl9sdW4gPSAzLAorCS51c2VfY2x1c3RlcmluZyA9IEVOQUJMRV9DTFVTVEVSSU5HLAorCS5zaG9zdF9hdHRycyA9IGJmYWRfaW1fdnBvcnRfYXR0cnMsCisJLm1heF9zZWN0b3JzID0gMHhGRkZGLAorfTsKKwordm9pZAorYmZhZF9pbV9wcm9iZV9wb3N0KHN0cnVjdCBiZmFkX2ltX3MgKmltKQoreworCWZsdXNoX3dvcmtxdWV1ZShpbS0+ZHJ2X3dvcmtxKTsKK30KKworYmZhX3N0YXR1c190CitiZmFkX2ltX21vZHVsZV9pbml0KHZvaWQpCit7CisJYmZhZF9pbV9zY3NpX3RyYW5zcG9ydF90ZW1wbGF0ZSA9CisJCWZjX2F0dGFjaF90cmFuc3BvcnQoJmJmYWRfaW1fZmNfZnVuY3Rpb25fdGVtcGxhdGUpOworCWlmICghYmZhZF9pbV9zY3NpX3RyYW5zcG9ydF90ZW1wbGF0ZSkKKwkJcmV0dXJuIEJGQV9TVEFUVVNfRU5PTUVNOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKK3ZvaWQKK2JmYWRfaW1fbW9kdWxlX2V4aXQodm9pZCkKK3sKKwlpZiAoYmZhZF9pbV9zY3NpX3RyYW5zcG9ydF90ZW1wbGF0ZSkKKwkJZmNfcmVsZWFzZV90cmFuc3BvcnQoYmZhZF9pbV9zY3NpX3RyYW5zcG9ydF90ZW1wbGF0ZSk7Cit9CisKK3ZvaWQKK2JmYWRfb3NfaXRuaW1fcHJvY2VzcyhzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbV9kcnYpCit7CisJc3RydWN0IGJmYWRfaW1fcyAgICAgICppbSA9IGl0bmltX2Rydi0+aW07CisKKwlpZiAoaXRuaW1fZHJ2LT5xdWV1ZV93b3JrKQorCQlxdWV1ZV93b3JrKGltLT5kcnZfd29ya3EsICZpdG5pbV9kcnYtPml0bmltX3dvcmspOworfQorCit2b2lkCitiZmFkX29zX3JhbXBfdXBfcWRlcHRoKHN0cnVjdCBiZmFkX2l0bmltX3MgKml0bmltLCBzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYpCit7CisJc3RydWN0IHNjc2lfZGV2aWNlICp0bXBfc2RldjsKKworCWlmICgoKGppZmZpZXMgLSBpdG5pbS0+bGFzdF9yYW1wX3VwX3RpbWUpID4KKwkJQkZBX1FVRVVFX0ZVTExfUkFNUF9VUF9USU1FICogSFopICYmCisJCSgoamlmZmllcyAtIGl0bmltLT5sYXN0X3F1ZXVlX2Z1bGxfdGltZSkgPgorCQlCRkFfUVVFVUVfRlVMTF9SQU1QX1VQX1RJTUUgKiBIWikpIHsKKwkJc2hvc3RfZm9yX2VhY2hfZGV2aWNlKHRtcF9zZGV2LCBzZGV2LT5ob3N0KSB7CisJCQlpZiAoYmZhX2x1bl9xdWV1ZV9kZXB0aCA+IHRtcF9zZGV2LT5xdWV1ZV9kZXB0aCkgeworCQkJCWlmICh0bXBfc2Rldi0+aWQgIT0gc2Rldi0+aWQpCisJCQkJCWNvbnRpbnVlOworCQkJCWlmICh0bXBfc2Rldi0+b3JkZXJlZF90YWdzKQorCQkJCQlzY3NpX2FkanVzdF9xdWV1ZV9kZXB0aCh0bXBfc2RldiwKKwkJCQkJCU1TR19PUkRFUkVEX1RBRywKKwkJCQkJCXRtcF9zZGV2LT5xdWV1ZV9kZXB0aCArIDEpOworCQkJCWVsc2UKKwkJCQkJc2NzaV9hZGp1c3RfcXVldWVfZGVwdGgodG1wX3NkZXYsCisJCQkJCQlNU0dfU0lNUExFX1RBRywKKwkJCQkJCXRtcF9zZGV2LT5xdWV1ZV9kZXB0aCArIDEpOworCisJCQkJaXRuaW0tPmxhc3RfcmFtcF91cF90aW1lID0gamlmZmllczsKKwkJCX0KKwkJfQorCX0KK30KKwordm9pZAorYmZhZF9vc19oYW5kbGVfcWZ1bGwoc3RydWN0IGJmYWRfaXRuaW1fcyAqaXRuaW0sIHN0cnVjdCBzY3NpX2RldmljZSAqc2RldikKK3sKKwlzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnRtcF9zZGV2OworCisJaXRuaW0tPmxhc3RfcXVldWVfZnVsbF90aW1lID0gamlmZmllczsKKworCXNob3N0X2Zvcl9lYWNoX2RldmljZSh0bXBfc2Rldiwgc2Rldi0+aG9zdCkgeworCQlpZiAodG1wX3NkZXYtPmlkICE9IHNkZXYtPmlkKQorCQkJY29udGludWU7CisJCXNjc2lfdHJhY2tfcXVldWVfZnVsbCh0bXBfc2RldiwgdG1wX3NkZXYtPnF1ZXVlX2RlcHRoIC0gMSk7CisJfQorfQorCisKKworCitzdHJ1Y3QgYmZhZF9pdG5pbV9zICoKK2JmYWRfb3NfZ2V0X2l0bmltKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCwgaW50IGlkKQoreworCXN0cnVjdCBiZmFkX2l0bmltX3MgICAqaXRuaW0gPSBOVUxMOworCisJLyogU2VhcmNoIHRoZSBtYXBwZWQgbGlzdCBmb3IgdGhpcyB0YXJnZXQgSUQgKi8KKwlsaXN0X2Zvcl9lYWNoX2VudHJ5KGl0bmltLCAmaW1fcG9ydC0+aXRuaW1fbWFwcGVkX2xpc3QsIGxpc3RfZW50cnkpIHsKKwkJaWYgKGlkID09IGl0bmltLT5zY3NpX3RndF9pZCkKKwkJCXJldHVybiBpdG5pbTsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30KKworLyoqCisgKiBTY3NpX0hvc3QgdGVtcGxhdGUgZW50cnkgc2xhdmVfYWxsb2MKKyAqLworc3RhdGljIGludAorYmZhZF9pbV9zbGF2ZV9hbGxvYyhzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYpCit7CisJc3RydWN0IGZjX3Jwb3J0ICpycG9ydCA9IHN0YXJnZXRfdG9fcnBvcnQoc2NzaV90YXJnZXQoc2RldikpOworCisJaWYgKCFycG9ydCB8fCBmY19yZW1vdGVfcG9ydF9jaGtyZWFkeShycG9ydCkpCisJCXJldHVybiAtRU5YSU87CisKKwlzZGV2LT5ob3N0ZGF0YSA9IHJwb3J0LT5kZF9kYXRhOworCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQKK2JmYWRfb3NfZmNfaG9zdF9pbml0KHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCkKK3sKKwlzdHJ1Y3QgU2NzaV9Ib3N0ICpob3N0ID0gaW1fcG9ydC0+c2hvc3Q7CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhZF9wb3J0X3MgICAgKnBvcnQgPSBpbV9wb3J0LT5wb3J0OworCXVuaW9uIGF0dHIgeworCQlzdHJ1Y3QgYmZhX3Bwb3J0X2F0dHJfcyBwYXR0cjsKKwkJc3RydWN0IGJmYV9pb2NfYXR0cl9zICBpb2NfYXR0cjsKKwl9IGF0dHI7CisKKwlmY19ob3N0X25vZGVfbmFtZShob3N0KSA9CisJCWJmYV9vc19odG9ubGwoKGJmYV9mY3NfcG9ydF9nZXRfbnd3bihwb3J0LT5mY3NfcG9ydCkpKTsKKwlmY19ob3N0X3BvcnRfbmFtZShob3N0KSA9CisJCWJmYV9vc19odG9ubGwoKGJmYV9mY3NfcG9ydF9nZXRfcHd3bihwb3J0LT5mY3NfcG9ydCkpKTsKKworCWZjX2hvc3Rfc3VwcG9ydGVkX2NsYXNzZXMoaG9zdCkgPSBGQ19DT1NfQ0xBU1MzOworCisJbWVtc2V0KGZjX2hvc3Rfc3VwcG9ydGVkX2ZjNHMoaG9zdCksIDAsCisJICAgICAgIHNpemVvZihmY19ob3N0X3N1cHBvcnRlZF9mYzRzKGhvc3QpKSk7CisJaWYgKGJmYWRfc3VwcG9ydGVkX2ZjNHMgJiAoQkZBX1BPUlRfUk9MRV9GQ1BfSU0gfCBCRkFfUE9SVF9ST0xFX0ZDUF9UTSkpCisJCS8qIEZvciBGQ1AgdHlwZSAweDA4ICovCisJCWZjX2hvc3Rfc3VwcG9ydGVkX2ZjNHMoaG9zdClbMl0gPSAxOworCWlmIChiZmFkX3N1cHBvcnRlZF9mYzRzIHwgQkZBX1BPUlRfUk9MRV9GQ1BfSVBGQykKKwkJLyogRm9yIExMQy9TTkFQIHR5cGUgMHgwNSAqLworCQlmY19ob3N0X3N1cHBvcnRlZF9mYzRzKGhvc3QpWzNdID0gMHgyMDsKKwkvKiBGb3IgZmlicmUgY2hhbm5lbCBzZXJ2aWNlcyB0eXBlIDB4MjAgKi8KKwlmY19ob3N0X3N1cHBvcnRlZF9mYzRzKGhvc3QpWzddID0gMTsKKworCW1lbXNldCgmYXR0ci5pb2NfYXR0ciwgMCwgc2l6ZW9mKGF0dHIuaW9jX2F0dHIpKTsKKwliZmFfZ2V0X2F0dHIoJmJmYWQtPmJmYSwgJmF0dHIuaW9jX2F0dHIpOworCXNwcmludGYoZmNfaG9zdF9zeW1ib2xpY19uYW1lKGhvc3QpLCAiQnJvY2FkZSAlcyBGViVzIERWJXMiLAorCQlhdHRyLmlvY19hdHRyLmFkYXB0ZXJfYXR0ci5tb2RlbCwKKwkJYXR0ci5pb2NfYXR0ci5hZGFwdGVyX2F0dHIuZndfdmVyLCBCRkFEX0RSSVZFUl9WRVJTSU9OKTsKKworCWZjX2hvc3Rfc3VwcG9ydGVkX3NwZWVkcyhob3N0KSA9IDA7CisJZmNfaG9zdF9zdXBwb3J0ZWRfc3BlZWRzKGhvc3QpIHw9CisJCUZDX1BPUlRTUEVFRF84R0JJVCB8IEZDX1BPUlRTUEVFRF80R0JJVCB8IEZDX1BPUlRTUEVFRF8yR0JJVCB8CisJCUZDX1BPUlRTUEVFRF8xR0JJVDsKKworCW1lbXNldCgmYXR0ci5wYXR0ciwgMCwgc2l6ZW9mKGF0dHIucGF0dHIpKTsKKwliZmFfcHBvcnRfZ2V0X2F0dHIoJmJmYWQtPmJmYSwgJmF0dHIucGF0dHIpOworCWZjX2hvc3RfbWF4ZnJhbWVfc2l6ZShob3N0KSA9IGF0dHIucGF0dHIucHBvcnRfY2ZnLm1heGZyc2l6ZTsKK30KKworc3RhdGljIHZvaWQKK2JmYWRfaW1fZmNfcnBvcnRfYWRkKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCwgc3RydWN0IGJmYWRfaXRuaW1fcyAqaXRuaW0pCit7CisJc3RydWN0IGZjX3Jwb3J0X2lkZW50aWZpZXJzIHJwb3J0X2lkczsKKwlzdHJ1Y3QgZmNfcnBvcnQgKmZjX3Jwb3J0OworCXN0cnVjdCBiZmFkX2l0bmltX2RhdGFfcyAqaXRuaW1fZGF0YTsKKworCXJwb3J0X2lkcy5ub2RlX25hbWUgPQorCQliZmFfb3NfaHRvbmxsKGJmYV9mY3NfaXRuaW1fZ2V0X253d24oJml0bmltLT5mY3NfaXRuaW0pKTsKKwlycG9ydF9pZHMucG9ydF9uYW1lID0KKwkJYmZhX29zX2h0b25sbChiZmFfZmNzX2l0bmltX2dldF9wd3duKCZpdG5pbS0+ZmNzX2l0bmltKSk7CisJcnBvcnRfaWRzLnBvcnRfaWQgPQorCQliZmFfb3NfaHRvbjNiKGJmYV9mY3NfaXRuaW1fZ2V0X2ZjaWQoJml0bmltLT5mY3NfaXRuaW0pKTsKKwlycG9ydF9pZHMucm9sZXMgPSBGQ19SUE9SVF9ST0xFX1VOS05PV047CisKKwlpdG5pbS0+ZmNfcnBvcnQgPSBmY19ycG9ydCA9CisJCWZjX3JlbW90ZV9wb3J0X2FkZChpbV9wb3J0LT5zaG9zdCwgMCwgJnJwb3J0X2lkcyk7CisKKwlpZiAoIWZjX3Jwb3J0KQorCQlyZXR1cm47CisKKwlmY19ycG9ydC0+bWF4ZnJhbWVfc2l6ZSA9CisJCWJmYV9mY3NfaXRuaW1fZ2V0X21heGZyc2l6ZSgmaXRuaW0tPmZjc19pdG5pbSk7CisJZmNfcnBvcnQtPnN1cHBvcnRlZF9jbGFzc2VzID0gYmZhX2Zjc19pdG5pbV9nZXRfY29zKCZpdG5pbS0+ZmNzX2l0bmltKTsKKworCWl0bmltX2RhdGEgPSBmY19ycG9ydC0+ZGRfZGF0YTsKKwlpdG5pbV9kYXRhLT5pdG5pbSA9IGl0bmltOworCisJcnBvcnRfaWRzLnJvbGVzIHw9IEZDX1JQT1JUX1JPTEVfRkNQX1RBUkdFVDsKKworCWlmIChycG9ydF9pZHMucm9sZXMgIT0gRkNfUlBPUlRfUk9MRV9VTktOT1dOKQorCQlmY19yZW1vdGVfcG9ydF9yb2xlY2hnKGZjX3Jwb3J0LCBycG9ydF9pZHMucm9sZXMpOworCisJaWYgKChmY19ycG9ydC0+c2NzaV90YXJnZXRfaWQgIT0gLTEpCisJICAgICYmIChmY19ycG9ydC0+c2NzaV90YXJnZXRfaWQgPCBNQVhfRkNQX1RBUkdFVCkpCisJCWl0bmltLT5zY3NpX3RndF9pZCA9IGZjX3Jwb3J0LT5zY3NpX3RhcmdldF9pZDsKKworCXJldHVybjsKK30KKworLyoqCisgKiBXb3JrIHF1ZXVlIGhhbmRsZXIgdXNpbmcgRkMgdHJhbnNwb3J0IHNlcnZpY2UKKyogQ29udGV4dDoga2VybmVsCisgKi8KK3N0YXRpYyB2b2lkCitiZmFkX2ltX2l0bmltX3dvcmtfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCit7CisJc3RydWN0IGJmYWRfaXRuaW1fcyAgICppdG5pbSA9IGNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgYmZhZF9pdG5pbV9zLAorCQkJCQkJCWl0bmltX3dvcmspOworCXN0cnVjdCBiZmFkX2ltX3MgICAgICAqaW0gPSBpdG5pbS0+aW07CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW0tPmJmYWQ7CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0OworCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKKwlzdHJ1Y3QgZmNfcnBvcnQgKmZjX3Jwb3J0OworCXd3bl90IHd3cG47CisJdTMyIGZjaWQ7CisJY2hhciB3d3BuX3N0clszMl0sIGZjaWRfc3RyWzE2XTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwlpbV9wb3J0ID0gaXRuaW0tPmltX3BvcnQ7CisJYmZhX3RyYyhiZmFkLCBpdG5pbS0+c3RhdGUpOworCXN3aXRjaCAoaXRuaW0tPnN0YXRlKSB7CisJY2FzZSBJVE5JTV9TVEFURV9PTkxJTkU6CisJCWlmICghaXRuaW0tPmZjX3Jwb3J0KSB7CisJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJCWJmYWRfaW1fZmNfcnBvcnRfYWRkKGltX3BvcnQsIGl0bmltKTsKKwkJCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJCXd3cG4gPSBiZmFfZmNzX2l0bmltX2dldF9wd3duKCZpdG5pbS0+ZmNzX2l0bmltKTsKKwkJCWZjaWQgPSBiZmFfZmNzX2l0bmltX2dldF9mY2lkKCZpdG5pbS0+ZmNzX2l0bmltKTsKKwkJCXd3bjJzdHIod3dwbl9zdHIsIHd3cG4pOworCQkJZmNpZDJzdHIoZmNpZF9zdHIsIGZjaWQpOworCQkJbGlzdF9hZGRfdGFpbCgmaXRuaW0tPmxpc3RfZW50cnksCisJCQkJJmltX3BvcnQtPml0bmltX21hcHBlZF9saXN0KTsKKwkJCWJmYV9sb2coYmZhZC0+bG9nbW9kLCBCRkFfTE9HX0xJTlVYX0lUTklNX09OTElORSwKKwkJCQlpbV9wb3J0LT5zaG9zdC0+aG9zdF9ubywKKwkJCQlpdG5pbS0+c2NzaV90Z3RfaWQsCisJCQkJZmNpZF9zdHIsIHd3cG5fc3RyKTsKKwkJfSBlbHNlIHsKKwkJCXByaW50ayhLRVJOX1dBUk5JTkcKKwkJCQkiJXM6IGl0bmltICVsbHggaXMgYWxyZWFkeSBpbiBvbmxpbmUgc3RhdGVcbiIsCisJCQkJX19GVU5DVElPTl9fLAorCQkJCWJmYV9mY3NfaXRuaW1fZ2V0X3B3d24oJml0bmltLT5mY3NfaXRuaW0pKTsKKwkJfQorCisJCWJyZWFrOworCWNhc2UgSVROSU1fU1RBVEVfT0ZGTElORV9QRU5ESU5HOgorCQlpdG5pbS0+c3RhdGUgPSBJVE5JTV9TVEFURV9PRkZMSU5FOworCQlpZiAoaXRuaW0tPmZjX3Jwb3J0KSB7CisJCQlmY19ycG9ydCA9IGl0bmltLT5mY19ycG9ydDsKKwkJCSgoc3RydWN0IGJmYWRfaXRuaW1fZGF0YV9zICopCisJCQkJZmNfcnBvcnQtPmRkX2RhdGEpLT5pdG5pbSA9IE5VTEw7CisJCQlpdG5pbS0+ZmNfcnBvcnQgPSBOVUxMOworCQkJaWYgKCEoaW1fcG9ydC0+cG9ydC0+ZmxhZ3MgJiBCRkFEX1BPUlRfREVMRVRFKSkgeworCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCQkJCWZjX3Jwb3J0LT5kZXZfbG9zc190bW8gPQorCQkJCQliZmFfZmNwaW1fcGF0aF90b3ZfZ2V0KCZiZmFkLT5iZmEpICsgMTsKKwkJCQlmY19yZW1vdGVfcG9ydF9kZWxldGUoZmNfcnBvcnQpOworCQkJCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJCX0KKwkJCXd3cG4gPSBiZmFfZmNzX2l0bmltX2dldF9wd3duKCZpdG5pbS0+ZmNzX2l0bmltKTsKKwkJCWZjaWQgPSBiZmFfZmNzX2l0bmltX2dldF9mY2lkKCZpdG5pbS0+ZmNzX2l0bmltKTsKKwkJCXd3bjJzdHIod3dwbl9zdHIsIHd3cG4pOworCQkJZmNpZDJzdHIoZmNpZF9zdHIsIGZjaWQpOworCQkJbGlzdF9kZWwoJml0bmltLT5saXN0X2VudHJ5KTsKKwkJCWJmYV9sb2coYmZhZC0+bG9nbW9kLCBCRkFfTE9HX0xJTlVYX0lUTklNX09GRkxJTkUsCisJCQkJaW1fcG9ydC0+c2hvc3QtPmhvc3Rfbm8sCisJCQkJaXRuaW0tPnNjc2lfdGd0X2lkLAorCQkJCWZjaWRfc3RyLCB3d3BuX3N0cik7CisJCX0KKwkJYnJlYWs7CisJY2FzZSBJVE5JTV9TVEFURV9GUkVFOgorCQlpZiAoaXRuaW0tPmZjX3Jwb3J0KSB7CisJCQlmY19ycG9ydCA9IGl0bmltLT5mY19ycG9ydDsKKwkJCSgoc3RydWN0IGJmYWRfaXRuaW1fZGF0YV9zICopCisJCQkJZmNfcnBvcnQtPmRkX2RhdGEpLT5pdG5pbSA9IE5VTEw7CisJCQlpdG5pbS0+ZmNfcnBvcnQgPSBOVUxMOworCQkJaWYgKCEoaW1fcG9ydC0+cG9ydC0+ZmxhZ3MgJiBCRkFEX1BPUlRfREVMRVRFKSkgeworCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCQkJCWZjX3Jwb3J0LT5kZXZfbG9zc190bW8gPQorCQkJCQliZmFfZmNwaW1fcGF0aF90b3ZfZ2V0KCZiZmFkLT5iZmEpICsgMTsKKwkJCQlmY19yZW1vdGVfcG9ydF9kZWxldGUoZmNfcnBvcnQpOworCQkJCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJCX0KKwkJCWxpc3RfZGVsKCZpdG5pbS0+bGlzdF9lbnRyeSk7CisJCX0KKworCQlrZnJlZShpdG5pbSk7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJCWJyZWFrOworCX0KKworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworfQorCisvKioKKyAqIFNjc2lfSG9zdCB0ZW1wbGF0ZSBlbnRyeSwgcXVldWUgYSBTQ1NJIGNvbW1hbmQgdG8gdGhlIEJGQUQuCisgKi8KK3N0YXRpYyBpbnQKK2JmYWRfaW1fcXVldWVjb21tYW5kKHN0cnVjdCBzY3NpX2NtbmQgKmNtbmQsIHZvaWQgKCpkb25lKSAoc3RydWN0IHNjc2lfY21uZCAqKSkKK3sKKwlzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQgPQorCQkoc3RydWN0IGJmYWRfaW1fcG9ydF9zICopIGNtbmQtPmRldmljZS0+aG9zdC0+aG9zdGRhdGFbMF07CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gaW1fcG9ydC0+YmZhZDsKKwlzdHJ1Y3QgYmZhZF9pdG5pbV9kYXRhX3MgKml0bmltX2RhdGEgPSBjbW5kLT5kZXZpY2UtPmhvc3RkYXRhOworCXN0cnVjdCBiZmFkX2l0bmltX3MgICAqaXRuaW07CisJc3RydWN0IGJmYV9pb2ltX3MgKmhhbF9pbzsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisJaW50ICAgICAgICAgICAgIHJjOworCXMxNiAgICAgICAgc2dfY250ID0gMDsKKwlzdHJ1Y3QgZmNfcnBvcnQgKnJwb3J0ID0gc3RhcmdldF90b19ycG9ydChzY3NpX3RhcmdldChjbW5kLT5kZXZpY2UpKTsKKworCXJjID0gZmNfcmVtb3RlX3BvcnRfY2hrcmVhZHkocnBvcnQpOworCWlmIChyYykgeworCQljbW5kLT5yZXN1bHQgPSByYzsKKwkJZG9uZShjbW5kKTsKKwkJcmV0dXJuIDA7CisJfQorCisJc2dfY250ID0gc2NzaV9kbWFfbWFwKGNtbmQpOworCisJaWYgKHNnX2NudCA8IDApCisJCXJldHVybiBTQ1NJX01MUVVFVUVfSE9TVF9CVVNZOworCisJY21uZC0+c2NzaV9kb25lID0gZG9uZTsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwlpZiAoIShiZmFkLT5iZmFkX2ZsYWdzICYgQkZBRF9IQUxfU1RBUlRfRE9ORSkpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORworCQkJImJmYWQlZCwgcXVldWVjb21tYW5kICVwICV4IGZhaWxlZCwgQkZBIHN0b3BwZWRcbiIsCisJCSAgICAgICBiZmFkLT5pbnN0X25vLCBjbW5kLCBjbW5kLT5jbW5kWzBdKTsKKwkJY21uZC0+cmVzdWx0ID0gU2NzaVJlc3VsdChESURfTk9fQ09OTkVDVCwgMCk7CisJCWdvdG8gb3V0X2ZhaWxfY21kOworCX0KKworCWl0bmltID0gaXRuaW1fZGF0YS0+aXRuaW07CisJaWYgKCFpdG5pbSkgeworCQljbW5kLT5yZXN1bHQgPSBTY3NpUmVzdWx0KERJRF9JTU1fUkVUUlksIDApOworCQlnb3RvIG91dF9mYWlsX2NtZDsKKwl9CisKKwloYWxfaW8gPSBiZmFfaW9pbV9hbGxvYygmYmZhZC0+YmZhLCAoc3RydWN0IGJmYWRfaW9pbV9zICopIGNtbmQsCisJCQkJICAgIGl0bmltLT5iZmFfaXRuaW0sIHNnX2NudCk7CisJaWYgKCFoYWxfaW8pIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAiaGFsX2lvIGZhaWx1cmVcbiIpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJc2NzaV9kbWFfdW5tYXAoY21uZCk7CisJCXJldHVybiBTQ1NJX01MUVVFVUVfSE9TVF9CVVNZOworCX0KKworCWNtbmQtPmhvc3Rfc2NyaWJibGUgPSAoY2hhciAqKWhhbF9pbzsKKwliZmFfdHJjX2ZwKGJmYWQsIGhhbF9pby0+aW90YWcpOworCWJmYV9pb2ltX3N0YXJ0KGhhbF9pbyk7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisKKwlyZXR1cm4gMDsKKworb3V0X2ZhaWxfY21kOgorCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCXNjc2lfZG1hX3VubWFwKGNtbmQpOworCWlmIChkb25lKQorCQlkb25lKGNtbmQpOworCisJcmV0dXJuIDA7Cit9CisKK3ZvaWQKK2JmYWRfb3NfcnBvcnRfb25saW5lX3dhaXQoc3RydWN0IGJmYWRfcyAqYmZhZCkKK3sKKwlpbnQgaTsKKwlpbnQgcnBvcnRfZGVsYXkgPSAxMDsKKworCWZvciAoaSA9IDA7ICEoYmZhZC0+YmZhZF9mbGFncyAmIEJGQURfUE9SVF9PTkxJTkUpCisJCSAmJiBpIDwgYmZhX2xpbmt1cF9kZWxheTsgaSsrKQorCQlzY2hlZHVsZV90aW1lb3V0X3VuaW50ZXJydXB0aWJsZShIWik7CisKKwlpZiAoYmZhZC0+YmZhZF9mbGFncyAmIEJGQURfUE9SVF9PTkxJTkUpIHsKKwkJcnBvcnRfZGVsYXkgPSBycG9ydF9kZWxheSA8IGJmYV9saW5rdXBfZGVsYXkgPworCQkJCSBycG9ydF9kZWxheSA6IGJmYV9saW5rdXBfZGVsYXk7CisJCWZvciAoaSA9IDA7ICEoYmZhZC0+YmZhZF9mbGFncyAmIEJGQURfUlBPUlRfT05MSU5FKQorCQkJICYmIGkgPCBycG9ydF9kZWxheTsgaSsrKQorCQkJc2NoZWR1bGVfdGltZW91dF91bmludGVycnVwdGlibGUoSFopOworCisJCWlmIChycG9ydF9kZWxheSA+IDAgJiYgKGJmYWQtPmJmYWRfZmxhZ3MgJiBCRkFEX1JQT1JUX09OTElORSkpCisJCQlzY2hlZHVsZV90aW1lb3V0X3VuaW50ZXJydXB0aWJsZShycG9ydF9kZWxheSAqIEhaKTsKKwl9Cit9CisKK2ludAorYmZhZF9vc19nZXRfbGlua3VwX2RlbGF5KHN0cnVjdCBiZmFkX3MgKmJmYWQpCit7CisKKwl1OCAgICAgICAgIG53d25zID0gMDsKKwl3d25fdCAgICAgICAgICAgKnd3bnM7CisJaW50ICAgICAgICAgICAgIGxkZWxheTsKKworCS8qCisJICogUXVlcnlpbmcgZm9yIHRoZSBib290IHRhcmdldCBwb3J0IHd3bnMKKwkgKiAtLSByZWFkIGZyb20gYm9vdCBpbmZvcm1hdGlvbiBpbiBmbGFzaC4KKwkgKiBJZiBud3ducyA+IDAgPT4gYm9vdCBvdmVyIFNBTiBhbmQgc2V0IGJmYV9saW5rdXBfZGVsYXkgPSAzMAorCSAqIGVsc2UgPT4gbG9jYWwgYm9vdCBtYWNoaW5lIHNldCBiZmFfbGlua3VwX2RlbGF5ID0gMTAKKwkgKi8KKworCWJmYV9pb2NmY19nZXRfYm9vdHd3bnMoJmJmYWQtPmJmYSwgJm53d25zLCAmd3ducyk7CisKKwlpZiAobnd3bnMgPiAwKSB7CisJCS8qIElmIGJvb3Qgb3ZlciBTQU47IGxpbmt1cF9kZWxheSA9IDMwc2VjICovCisJCWxkZWxheSA9IDMwOworCX0gZWxzZSB7CisJCS8qIElmIGxvY2FsIGJvb3Q7IGxpbmt1cF9kZWxheSA9IDEwc2VjICovCisJCWxkZWxheSA9IDA7CisJfQorCisJcmV0dXJuIGxkZWxheTsKK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfaW0uaCBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF9pbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE4OWE1YjIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfaW0uaApAQCAtMCwwICsxLDE1MCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBRF9JTV9IX18KKyNkZWZpbmUgX19CRkFEX0lNX0hfXworCisjaW5jbHVkZSAiZmNzL2JmYV9mY3NfZmNwaW0uaCIKKyNpbmNsdWRlICJiZmFkX2ltX2NvbXBhdC5oIgorCisjZGVmaW5lIEZDUElfTkFNRSAiIGZjcGltIgorCit2b2lkIGJmYWRfZmxhZ3Nfc2V0KHN0cnVjdCBiZmFkX3MgKmJmYWQsIHUzMiBmbGFncyk7CitiZmFfc3RhdHVzX3QgYmZhZF9pbV9tb2R1bGVfaW5pdCh2b2lkKTsKK3ZvaWQgYmZhZF9pbV9tb2R1bGVfZXhpdCh2b2lkKTsKK2JmYV9zdGF0dXNfdCBiZmFkX2ltX3Byb2JlKHN0cnVjdCBiZmFkX3MgKmJmYWQpOwordm9pZCBiZmFkX2ltX3Byb2JlX3VuZG8oc3RydWN0IGJmYWRfcyAqYmZhZCk7Cit2b2lkIGJmYWRfaW1fcHJvYmVfcG9zdChzdHJ1Y3QgYmZhZF9pbV9zICppbSk7CitiZmFfc3RhdHVzX3QgYmZhZF9pbV9wb3J0X25ldyhzdHJ1Y3QgYmZhZF9zICpiZmFkLCBzdHJ1Y3QgYmZhZF9wb3J0X3MgKnBvcnQpOwordm9pZCBiZmFkX2ltX3BvcnRfZGVsZXRlKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFkX3BvcnRfcyAqcG9ydCk7Cit2b2lkIGJmYWRfaW1fcG9ydF9vbmxpbmUoc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYWRfcG9ydF9zICpwb3J0KTsKK3ZvaWQgYmZhZF9pbV9wb3J0X29mZmxpbmUoc3RydWN0IGJmYWRfcyAqYmZhZCwgc3RydWN0IGJmYWRfcG9ydF9zICpwb3J0KTsKK3ZvaWQgYmZhZF9pbV9wb3J0X2NsZWFuKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCk7CitpbnQgIGJmYWRfaW1fc2NzaV9ob3N0X2FsbG9jKHN0cnVjdCBiZmFkX3MgKmJmYWQsCisJCQkJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0KTsKK3ZvaWQgYmZhZF9pbV9zY3NpX2hvc3RfZnJlZShzdHJ1Y3QgYmZhZF9zICpiZmFkLAorCQkJCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCk7CisKKyNkZWZpbmUgTUFYX0ZDUF9UQVJHRVQgMTAyNAorI2RlZmluZSBNQVhfRkNQX0xVTiAxNjM4NAorI2RlZmluZSBCRkFEX1RBUkdFVF9SRVNFVF9UTU8gNjAKKyNkZWZpbmUgQkZBRF9MVU5fUkVTRVRfVE1PIDYwCisjZGVmaW5lIFNjc2lSZXN1bHQoaG9zdF9jb2RlLCBzY3NpX2NvZGUpICgoKGhvc3RfY29kZSkgPDwgMTYpIHwgc2NzaV9jb2RlKQorI2RlZmluZSBCRkFfUVVFVUVfRlVMTF9SQU1QX1VQX1RJTUUgMTIwCisjZGVmaW5lIEJGQURfS09CSl9OQU1FX0xFTiAyMAorCisvKgorICogaXRuaW0gZmxhZ3MKKyAqLworI2RlZmluZSBJVE5JTV9NQVBQRUQJCTB4MDAwMDAwMDEKKworI2RlZmluZSBTQ1NJX1RBU0tfTUdNVAkJMHgwMDAwMDAwMQorI2RlZmluZSBJT19ET05FX0JJVAkJCTAKKworc3RydWN0IGJmYWRfaXRuaW1fZGF0YV9zIHsKKwlzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbTsKK307CisKK3N0cnVjdCBiZmFkX2ltX3BvcnRfcyB7CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkOworCXN0cnVjdCBiZmFkX3BvcnRfcyAgICAqcG9ydDsKKwlzdHJ1Y3Qgd29ya19zdHJ1Y3QgcG9ydF9kZWxldGVfd29yazsKKwlpbnQgICAgICAgICAgICAgaWRyX2lkOworCXUxNiAgICAgICAgY3VyX3Njc2lfaWQ7CisJc3RydWN0IGxpc3RfaGVhZCBiaW5kaW5nX2xpc3Q7CisJc3RydWN0IFNjc2lfSG9zdCAqc2hvc3Q7CisJc3RydWN0IGxpc3RfaGVhZCBpdG5pbV9tYXBwZWRfbGlzdDsKK307CisKK2VudW0gYmZhZF9pdG5pbV9zdGF0ZSB7CisJSVROSU1fU1RBVEVfTk9ORSwKKwlJVE5JTV9TVEFURV9PTkxJTkUsCisJSVROSU1fU1RBVEVfT0ZGTElORV9QRU5ESU5HLAorCUlUTklNX1NUQVRFX09GRkxJTkUsCisJSVROSU1fU1RBVEVfVElNRU9VVCwKKwlJVE5JTV9TVEFURV9GUkVFLAorfTsKKworLyoKKyAqIFBlciBpdG5pbSBkYXRhIHN0cnVjdHVyZQorICovCitzdHJ1Y3QgYmZhZF9pdG5pbV9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3RfZW50cnk7CisJc3RydWN0IGJmYV9mY3NfaXRuaW1fcyBmY3NfaXRuaW07CisJc3RydWN0IHdvcmtfc3RydWN0IGl0bmltX3dvcms7CisJdTMyICAgICAgICBmbGFnczsKKwllbnVtIGJmYWRfaXRuaW1fc3RhdGUgc3RhdGU7CisJc3RydWN0IGJmYWRfaW1fcyAqaW07CisJc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0OworCXN0cnVjdCBiZmFkX3Jwb3J0X3MgKmRydl9ycG9ydDsKKwlzdHJ1Y3QgZmNfcnBvcnQgKmZjX3Jwb3J0OworCXN0cnVjdCBiZmFfaXRuaW1fcyAqYmZhX2l0bmltOworCXUxNiAgICAgICAgc2NzaV90Z3RfaWQ7CisJdTE2ICAgICAgICBxdWV1ZV93b3JrOworCXVuc2lnbmVkIGxvbmcJbGFzdF9yYW1wX3VwX3RpbWU7CisJdW5zaWduZWQgbG9uZwlsYXN0X3F1ZXVlX2Z1bGxfdGltZTsKK307CisKK2VudW0gYmZhZF9iaW5kaW5nX3R5cGUgeworCUZDUF9QV1dOX0JJTkRJTkcgPSAweDEsCisJRkNQX05XV05fQklORElORyA9IDB4MiwKKwlGQ1BfRkNJRF9CSU5ESU5HID0gMHgzLAorfTsKKworc3RydWN0IGJmYWRfZmNwX2JpbmRpbmcgeworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdF9lbnRyeTsKKwllbnVtIGJmYWRfYmluZGluZ190eXBlIGJpbmRpbmdfdHlwZTsKKwl1MTYgICAgICAgIHNjc2lfdGFyZ2V0X2lkOworCXUzMiAgICAgICAgZmNfaWQ7CisJd3duX3QgICAgICAgICAgIG53d247CisJd3duX3QgICAgICAgICAgIHB3d247Cit9OworCitzdHJ1Y3QgYmZhZF9pbV9zIHsKKwlzdHJ1Y3QgYmZhZF9zICAgICAgICAgKmJmYWQ7CisJc3RydWN0IHdvcmtxdWV1ZV9zdHJ1Y3QgKmRydl93b3JrcTsKKwljaGFyICAgZHJ2X3dvcmtxX25hbWVbQkZBRF9LT0JKX05BTUVfTEVOXTsKK307CisKK3N0cnVjdCBTY3NpX0hvc3QgKmJmYWRfb3Nfc2NzaV9ob3N0X2FsbG9jKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCwKKwkJCQlzdHJ1Y3QgYmZhZF9zICopOworYmZhX3N0YXR1c190IGJmYWRfb3NfdGhyZWFkX3dvcmtxKHN0cnVjdCBiZmFkX3MgKmJmYWQpOwordm9pZCBiZmFkX29zX2Rlc3Ryb3lfd29ya3Eoc3RydWN0IGJmYWRfaW1fcyAqaW0pOwordm9pZCBiZmFkX29zX2l0bmltX3Byb2Nlc3Moc3RydWN0IGJmYWRfaXRuaW1fcyAqaXRuaW1fZHJ2KTsKK3ZvaWQgYmZhZF9vc19mY19ob3N0X2luaXQoc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0KTsKK3ZvaWQgYmZhZF9vc19pbml0X3dvcmsoc3RydWN0IGJmYWRfaW1fcG9ydF9zICppbV9wb3J0KTsKK3ZvaWQgYmZhZF9vc19zY3NpX2hvc3RfZnJlZShzdHJ1Y3QgYmZhZF9zICpiZmFkLAorCQkJCSBzdHJ1Y3QgYmZhZF9pbV9wb3J0X3MgKmltX3BvcnQpOwordm9pZCBiZmFkX29zX3JhbXBfdXBfcWRlcHRoKHN0cnVjdCBiZmFkX2l0bmltX3MgKml0bmltLAorCQkJCSBzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYpOwordm9pZCBiZmFkX29zX2hhbmRsZV9xZnVsbChzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbSwgc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2KTsKK3N0cnVjdCBiZmFkX2l0bmltX3MgKmJmYWRfb3NfZ2V0X2l0bmltKHN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCwgaW50IGlkKTsKK2ludCBiZmFkX29zX3Njc2lfYWRkX2hvc3Qoc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QsCisJCXN0cnVjdCBiZmFkX2ltX3BvcnRfcyAqaW1fcG9ydCwgc3RydWN0IGJmYWRfcyAqYmZhZCk7CisKKy8qCisgKiBzY3NpX2hvc3RfdGVtcGxhdGUgZW50cmllcworICovCit2b2lkIGJmYWRfaW1faXRuaW1fdW5tYXAoc3RydWN0IGJmYWRfaW1fcG9ydF9zICAqaW1fcG9ydCwKKwkJCSBzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbSk7CisKK2V4dGVybiBzdHJ1Y3Qgc2NzaV9ob3N0X3RlbXBsYXRlIGJmYWRfaW1fc2NzaV9ob3N0X3RlbXBsYXRlOworZXh0ZXJuIHN0cnVjdCBzY3NpX2hvc3RfdGVtcGxhdGUgYmZhZF9pbV92cG9ydF90ZW1wbGF0ZTsKK2V4dGVybiBzdHJ1Y3QgZmNfZnVuY3Rpb25fdGVtcGxhdGUgYmZhZF9pbV9mY19mdW5jdGlvbl90ZW1wbGF0ZTsKK2V4dGVybiBzdHJ1Y3Qgc2NzaV90cmFuc3BvcnRfdGVtcGxhdGUgKmJmYWRfaW1fc2NzaV90cmFuc3BvcnRfdGVtcGxhdGU7CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2ltX2NvbXBhdC5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2ltX2NvbXBhdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjFkM2U3NGUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfaW1fY29tcGF0LmgKQEAgLTAsMCArMSw0NiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBRF9JTV9DT01QQVRfSF9fCisjZGVmaW5lIF9fQkZBRF9JTV9DT01QQVRfSF9fCisKK2V4dGVybiB1MzIgKmJmaV9pbWFnZV9idWY7CitleHRlcm4gdTMyIGJmaV9pbWFnZV9zaXplOworCitleHRlcm4gc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmJmYWRfaW1faG9zdF9hdHRyc1tdOworZXh0ZXJuIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICpiZmFkX2ltX3Zwb3J0X2F0dHJzW107CisKK3UzMiAqYmZhZF9nZXRfZmlybXdhcmVfYnVmKHN0cnVjdCBwY2lfZGV2ICpwZGV2KTsKK3UzMiAqYmZhZF9yZWFkX2Zpcm13YXJlKHN0cnVjdCBwY2lfZGV2ICpwZGV2LCB1MzIgKipiZmlfaW1hZ2UsCisJCQl1MzIgKmJmaV9pbWFnZV9zaXplLCBjaGFyICpmd19uYW1lKTsKKworc3RhdGljIGlubGluZSB1MzIgKgorYmZhZF9sb2FkX2Z3aW1nKHN0cnVjdCBwY2lfZGV2ICpwZGV2KQoreworCXJldHVybihiZmFkX2dldF9maXJtd2FyZV9idWYocGRldikpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK2JmYWRfZnJlZV9md2ltZyh2b2lkKQoreworCWlmIChiZmlfaW1hZ2VfY3Rfc2l6ZSAmJiBiZmlfaW1hZ2VfY3QpCisJCXZmcmVlKGJmaV9pbWFnZV9jdCk7CisJaWYgKGJmaV9pbWFnZV9jYl9zaXplICYmIGJmaV9pbWFnZV9jYikKKwkJdmZyZWUoYmZpX2ltYWdlX2NiKTsKK30KKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfaW50ci5jIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2ludHIuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mMTA0ZTAyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2ludHIuYwpAQCAtMCwwICsxLDIxNCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSAiYmZhZF9kcnYuaCIKKyNpbmNsdWRlICJiZmFkX3RyY21vZC5oIgorCitCRkFfVFJDX0ZJTEUoTERSViwgSU5UUik7CisKKy8qKgorICogIGJmYV9pc3IgQkZBIGRyaXZlciBpbnRlcnJ1cHQgZnVuY3Rpb25zCisgKi8KK2lycXJldHVybl90IGJmYWRfaW50eChpbnQgaXJxLCB2b2lkICpkZXZfaWQpOworc3RhdGljIGludCBtc2l4X2Rpc2FibGU7Cittb2R1bGVfcGFyYW0obXNpeF9kaXNhYmxlLCBpbnQsIFNfSVJVR08gfCBTX0lXVVNSKTsKKy8qKgorICogTGluZSBiYXNlZCBpbnRlcnJ1cHQgaGFuZGxlci4KKyAqLworaXJxcmV0dXJuX3QKK2JmYWRfaW50eChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCit7CisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkID0gZGV2X2lkOworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICBkb25lcTsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisJYmZhX2Jvb2xlYW5fdCByYzsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwlyYyA9IGJmYV9pbnR4KCZiZmFkLT5iZmEpOworCWlmICghcmMpIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJCXJldHVybiBJUlFfTk9ORTsKKwl9CisKKwliZmFfY29tcF9kZXEoJmJmYWQtPmJmYSwgJmRvbmVxKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKworCWlmICghbGlzdF9lbXB0eSgmZG9uZXEpKSB7CisJCWJmYV9jb21wX3Byb2Nlc3MoJmJmYWQtPmJmYSwgJmRvbmVxKTsKKworCQlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJCWJmYV9jb21wX2ZyZWUoJmJmYWQtPmJmYSwgJmRvbmVxKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisJCWJmYV90cmNfZnAoYmZhZCwgaXJxKTsKKwl9CisKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7CisKK30KKworc3RhdGljIGlycXJldHVybl90CitiZmFkX21zaXgoaW50IGlycSwgdm9pZCAqZGV2X2lkKQoreworCXN0cnVjdCBiZmFkX21zaXhfcyAqdmVjID0gZGV2X2lkOworCXN0cnVjdCBiZmFkX3MgKmJmYWQgPSB2ZWMtPmJmYWQ7CisJc3RydWN0IGxpc3RfaGVhZCBkb25lcTsKKwl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmYmZhZC0+YmZhZF9sb2NrLCBmbGFncyk7CisKKwliZmFfbXNpeCgmYmZhZC0+YmZhLCB2ZWMtPm1zaXguZW50cnkpOworCWJmYV9jb21wX2RlcSgmYmZhZC0+YmZhLCAmZG9uZXEpOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmJmYWQtPmJmYWRfbG9jaywgZmxhZ3MpOworCisJaWYgKCFsaXN0X2VtcHR5KCZkb25lcSkpIHsKKwkJYmZhX2NvbXBfcHJvY2VzcygmYmZhZC0+YmZhLCAmZG9uZXEpOworCisJCXNwaW5fbG9ja19pcnFzYXZlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwkJYmZhX2NvbXBfZnJlZSgmYmZhZC0+YmZhLCAmZG9uZXEpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZiZmFkLT5iZmFkX2xvY2ssIGZsYWdzKTsKKwl9CisKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKKy8qKgorICogSW5pdGlhbGl6ZSB0aGUgTVNJWCBlbnRyeSB0YWJsZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYWRfaW5pdF9tc2l4X2VudHJ5KHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBtc2l4X2VudHJ5ICptc2l4X2VudHJpZXMsCisJCQkgaW50IG1hc2ssIGludCBtYXhfYml0KQoreworCWludCAgICAgICAgICAgICBpOworCWludCAgICAgICAgICAgICBtYXRjaCA9IDB4MDAwMDAwMDE7CisKKwlmb3IgKGkgPSAwLCBiZmFkLT5udmVjID0gMDsgaSA8IE1BWF9NU0lYX0VOVFJZOyBpKyspIHsKKwkJaWYgKG1hc2sgJiBtYXRjaCkgeworCQkJYmZhZC0+bXNpeF90YWJbYmZhZC0+bnZlY10ubXNpeC5lbnRyeSA9IGk7CisJCQliZmFkLT5tc2l4X3RhYltiZmFkLT5udmVjXS5iZmFkID0gYmZhZDsKKwkJCW1zaXhfZW50cmllc1tiZmFkLT5udmVjXS5lbnRyeSA9IGk7CisJCQliZmFkLT5udmVjKys7CisJCX0KKworCQltYXRjaCA8PD0gMTsKKwl9CisKK30KKworaW50CitiZmFkX2luc3RhbGxfbXNpeF9oYW5kbGVyKHN0cnVjdCBiZmFkX3MgKmJmYWQpCit7CisJaW50ICAgICAgICAgICAgIGksIGVycm9yID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBiZmFkLT5udmVjOyBpKyspIHsKKwkJZXJyb3IgPSByZXF1ZXN0X2lycShiZmFkLT5tc2l4X3RhYltpXS5tc2l4LnZlY3RvciwKKwkJCQkgICAgKGlycV9oYW5kbGVyX3QpIGJmYWRfbXNpeCwgMCwKKwkJCQkgICAgQkZBRF9EUklWRVJfTkFNRSwgJmJmYWQtPm1zaXhfdGFiW2ldKTsKKwkJYmZhX3RyYyhiZmFkLCBpKTsKKwkJYmZhX3RyYyhiZmFkLCBiZmFkLT5tc2l4X3RhYltpXS5tc2l4LnZlY3Rvcik7CisJCWlmIChlcnJvcikgeworCQkJaW50ICAgICAgICAgICAgIGo7CisKKwkJCWZvciAoaiA9IDA7IGogPCBpOyBqKyspCisJCQkJZnJlZV9pcnEoYmZhZC0+bXNpeF90YWJbal0ubXNpeC52ZWN0b3IsCisJCQkJCQkmYmZhZC0+bXNpeF90YWJbal0pOworCisJCQlyZXR1cm4gMTsKKwkJfQorCX0KKworCXJldHVybiAwOworfQorCisvKioKKyAqIFNldHVwIE1TSVggYmFzZWQgaW50ZXJydXB0LgorICovCitpbnQKK2JmYWRfc2V0dXBfaW50cihzdHJ1Y3QgYmZhZF9zICpiZmFkKQoreworCWludCBlcnJvciA9IDA7CisJdTMyIG1hc2sgPSAwLCBpLCBudW1fYml0ID0gMCwgbWF4X2JpdCA9IDA7CisJc3RydWN0IG1zaXhfZW50cnkgbXNpeF9lbnRyaWVzW01BWF9NU0lYX0VOVFJZXTsKKworCS8qIENhbGwgQkZBIHRvIGdldCB0aGUgbXNpeCBtYXAgZm9yIHRoaXMgUENJIGZ1bmN0aW9uLiAgKi8KKwliZmFfbXNpeF9nZXR2ZWNzKCZiZmFkLT5iZmEsICZtYXNrLCAmbnVtX2JpdCwgJm1heF9iaXQpOworCisJLyogU2V0IHVwIHRoZSBtc2l4IGVudHJ5IHRhYmxlICovCisJYmZhZF9pbml0X21zaXhfZW50cnkoYmZhZCwgbXNpeF9lbnRyaWVzLCBtYXNrLCBtYXhfYml0KTsKKworCWlmICghbXNpeF9kaXNhYmxlKSB7CisJCWVycm9yID0gcGNpX2VuYWJsZV9tc2l4KGJmYWQtPnBjaWRldiwgbXNpeF9lbnRyaWVzLCBiZmFkLT5udmVjKTsKKwkJaWYgKGVycm9yKSB7CisJCQkvKgorCQkJICogT25seSBlcnJvciBudW1iZXIgb2YgdmVjdG9yIGlzIGF2YWlsYWJsZS4KKwkJCSAqIFdlIGRvbid0IGhhdmUgYSBtZWNoYW5pc20gdG8gbWFwIG11bHRpcGxlCisJCQkgKiBpbnRlcnJ1cHRzIGludG8gb25lIHZlY3Rvciwgc28gZXZlbiBpZiB3ZQorCQkJICogY2FuIHRyeSB0byByZXF1ZXN0IGxlc3MgdmVjdG9ycywgd2UgZG9uJ3QKKwkJCSAqIGtub3cgaG93IHRvIGFzc29jaWF0ZSBpbnRlcnJ1cHQgZXZlbnRzIHRvCisJCQkgKiAgdmVjdG9ycy4gTGludXggZG9lc24ndCBkdXBpY2F0ZSB2ZWN0b3JzCisJCQkgKiBpbiB0aGUgTVNJWCB0YWJsZSBmb3IgdGhpcyBjYXNlLgorCQkJICovCisKKwkJCXByaW50ayhLRVJOX1dBUk5JTkcgImJmYWQlZDogIgorCQkJCSJwY2lfZW5hYmxlX21zaXggZmFpbGVkICglZCksIgorCQkJCSIgdXNlIGxpbmUgYmFzZWQuXG4iLCBiZmFkLT5pbnN0X25vLCBlcnJvcik7CisKKwkJCWdvdG8gbGluZV9iYXNlZDsKKwkJfQorCisJCS8qIFNhdmUgdGhlIHZlY3RvcnMgKi8KKwkJZm9yIChpID0gMDsgaSA8IGJmYWQtPm52ZWM7IGkrKykgeworCQkJYmZhX3RyYyhiZmFkLCBtc2l4X2VudHJpZXNbaV0udmVjdG9yKTsKKwkJCWJmYWQtPm1zaXhfdGFiW2ldLm1zaXgudmVjdG9yID0gbXNpeF9lbnRyaWVzW2ldLnZlY3RvcjsKKwkJfQorCisJCWJmYV9tc2l4X2luaXQoJmJmYWQtPmJmYSwgYmZhZC0+bnZlYyk7CisKKwkJYmZhZC0+YmZhZF9mbGFncyB8PSBCRkFEX01TSVhfT047CisKKwkJcmV0dXJuIGVycm9yOworCX0KKworbGluZV9iYXNlZDoKKwllcnJvciA9IDA7CisJaWYgKHJlcXVlc3RfaXJxCisJICAgIChiZmFkLT5wY2lkZXYtPmlycSwgKGlycV9oYW5kbGVyX3QpIGJmYWRfaW50eCwgQkZBRF9JUlFfRkxBR1MsCisJICAgICBCRkFEX0RSSVZFUl9OQU1FLCBiZmFkKSAhPSAwKSB7CisJCS8qIEVuYWJsZSBpbnRlcnJ1cHQgaGFuZGxlciBmYWlsZWQgKi8KKwkJcmV0dXJuIDE7CisJfQorCisJcmV0dXJuIGVycm9yOworfQorCit2b2lkCitiZmFkX3JlbW92ZV9pbnRyKHN0cnVjdCBiZmFkX3MgKmJmYWQpCit7CisJaW50ICAgICAgICAgICAgIGk7CisKKwlpZiAoYmZhZC0+YmZhZF9mbGFncyAmIEJGQURfTVNJWF9PTikgeworCQlmb3IgKGkgPSAwOyBpIDwgYmZhZC0+bnZlYzsgaSsrKQorCQkJZnJlZV9pcnEoYmZhZC0+bXNpeF90YWJbaV0ubXNpeC52ZWN0b3IsCisJCQkJCSZiZmFkLT5tc2l4X3RhYltpXSk7CisKKwkJcGNpX2Rpc2FibGVfbXNpeChiZmFkLT5wY2lkZXYpOworCQliZmFkLT5iZmFkX2ZsYWdzICY9IH5CRkFEX01TSVhfT047CisJfSBlbHNlIHsKKwkJZnJlZV9pcnEoYmZhZC0+cGNpZGV2LT5pcnEsIGJmYWQpOworCX0KK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfaXBmYy5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2lwZmMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43MThiYzUyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX2lwZmMuaApAQCAtMCwwICsxLDQyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0RSVl9JUEZDX0hfXworI2RlZmluZSBfX0JGQV9EUlZfSVBGQ19IX18KKworCisjZGVmaW5lIElQRkNfTkFNRSAiIgorCisjZGVmaW5lIGJmYWRfaXBmY19tb2R1bGVfaW5pdCh4KSBkbyB7fSB3aGlsZSAoMCkKKyNkZWZpbmUgYmZhZF9pcGZjX21vZHVsZV9leGl0KHgpIGRvIHt9IHdoaWxlICgwKQorI2RlZmluZSBiZmFkX2lwZmNfcHJvYmUoeCkgZG8ge30gd2hpbGUgKDApCisjZGVmaW5lIGJmYWRfaXBmY19wcm9iZV91bmRvKHgpIGRvIHt9IHdoaWxlICgwKQorI2RlZmluZSBiZmFkX2lwZmNfcG9ydF9jb25maWcoeCwgeSkgQkZBX1NUQVRVU19PSworI2RlZmluZSBiZmFkX2lwZmNfcG9ydF91bmNvbmZpZyh4LCB5KSBkbyB7fSB3aGlsZSAoMCkKKworI2RlZmluZSBiZmFkX2lwZmNfcHJvYmVfcG9zdCh4KSBkbyB7fSB3aGlsZSAoMCkKKyNkZWZpbmUgYmZhZF9pcGZjX3BvcnRfbmV3KHgsIHksIHopIEJGQV9TVEFUVVNfT0sKKyNkZWZpbmUgYmZhZF9pcGZjX3BvcnRfZGVsZXRlKHgsIHkpIGRvIHt9IHdoaWxlICgwKQorI2RlZmluZSBiZmFkX2lwZmNfcG9ydF9vbmxpbmUoeCwgeSkgZG8ge30gd2hpbGUgKDApCisjZGVmaW5lIGJmYWRfaXBmY19wb3J0X29mZmxpbmUoeCwgeSkgZG8ge30gd2hpbGUgKDApCisKKyNkZWZpbmUgYmZhZF9pcF9nZXRfYXR0cih4KSBCRkFfU1RBVFVTX0ZBSUxFRAorI2RlZmluZSBiZmFkX2lwX3Jlc2V0X2Rydl9zdGF0cyh4KSBCRkFfU1RBVFVTX0ZBSUxFRAorI2RlZmluZSBiZmFkX2lwX2dldF9kcnZfc3RhdHMoeCwgeSkgQkZBX1NUQVRVU19GQUlMRUQKKyNkZWZpbmUgYmZhZF9pcF9lbmFibGVfaXBmYyh4LCB5LCB6KSBCRkFfU1RBVFVTX0ZBSUxFRAorCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFkX29zLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfb3MuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mYWY0N2I0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX29zLmMKQEAgLTAsMCArMSw1MCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFkX29zLmMgTGludXggZHJpdmVyIE9TIHNwZWNpZmljIGNhbGxzLgorICovCisKKyNpbmNsdWRlICJiZmFfb3NfaW5jLmgiCisjaW5jbHVkZSAiYmZhZF9kcnYuaCIKKwordm9pZAorYmZhX29zX2dldHRpbWVvZmRheShzdHJ1Y3QgYmZhX3RpbWV2YWxfcyAqdHYpCit7CisJc3RydWN0IHRpbWV2YWwgIHRtcF90djsKKworCWRvX2dldHRpbWVvZmRheSgmdG1wX3R2KTsKKwl0di0+dHZfc2VjID0gKHUzMikgdG1wX3R2LnR2X3NlYzsKKwl0di0+dHZfdXNlYyA9ICh1MzIpIHRtcF90di50dl91c2VjOworfQorCit2b2lkCitiZmFfb3NfcHJpbnRmKHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dfbW9kLCB1MzIgbXNnX2lkLAorCQkJY29uc3QgY2hhciAqZm10LCAuLi4pCit7CisJdmFfbGlzdCBhcDsKKwkjZGVmaW5lIEJGQV9TVFJJTkdfMjU2CTI1NgorCWNoYXIgdG1wW0JGQV9TVFJJTkdfMjU2XTsKKworCXZhX3N0YXJ0KGFwLCBmbXQpOworCXZzcHJpbnRmKHRtcCwgZm10LCBhcCk7CisJdmFfZW5kKGFwKTsKKworCXByaW50ayh0bXApOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF90bS5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX3RtLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDkwMWIxYgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvYmZhZF90bS5oCkBAIC0wLDAgKzEsNTkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoKKyAqIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIQkEgTGludXggVGFyZ2V0IE1vZGUgRHJpdmVyCisgKi8KKworLyoqCisgKiAgdG0vZHVtbXkvYmZhZF90bS5oIEJGQSBjYWxsYmFjayBkdW1teSBoZWFkZXIgZmlsZSBmb3IgQkZBIExpbnV4IHRhcmdldCBtb2RlIFBDSSBpbnRlcmZhY2UgbW9kdWxlLgorICovCisKKyNpZm5kZWYgX19CRkFEX1RNX0hfXworI2RlZmluZSBfX0JGQURfVE1fSF9fCisKKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3N0YXR1cy5oPgorCisjZGVmaW5lIEZDUFRfTkFNRSAJCSIiCisKKy8qCisgKiBDYWxsZWQgZnJvbSBiYXNlIExpbnV4IGRyaXZlciBvbiAoRGUpSW5pdCBldmVudHMKKyAqLworCisvKiBhdHRhY2ggdGd0IHRlbXBsYXRlIHdpdGggc2NzdCAqLworI2RlZmluZSBiZmFkX3RtX21vZHVsZV9pbml0KCkJZG8ge30gd2hpbGUgKDApCisKKy8qIGRldGFjaC9yZWxlYXNlIHRndCB0ZW1wbGF0ZSAqLworI2RlZmluZSBiZmFkX3RtX21vZHVsZV9leGl0KCkJZG8ge30gd2hpbGUgKDApCisKKyNkZWZpbmUgYmZhZF90bV9wcm9iZSh4KQlkbyB7fSB3aGlsZSAoMCkKKyNkZWZpbmUgYmZhZF90bV9wcm9iZV91bmRvKHgpCWRvIHt9IHdoaWxlICgwKQorI2RlZmluZSBiZmFkX3RtX3Byb2JlX3Bvc3QoeCkJZG8ge30gd2hpbGUgKDApCisKKy8qCisgKiBDYWxsZWQgYnkgYmFzZSBMaW51eCBkcml2ZXIgYnV0IHRyaWdnZXJlZCBieSBCRkEgRkNTIG9uIGNvbmZpZyBldmVudHMKKyAqLworI2RlZmluZSBiZmFkX3RtX3BvcnRfbmV3KHgsIHkpCQlCRkFfU1RBVFVTX09LCisjZGVmaW5lIGJmYWRfdG1fcG9ydF9kZWxldGUoeCwgeSkJZG8ge30gd2hpbGUgKDApCisKKy8qCisgKiBDYWxsZWQgYnkgYmFzZSBMaW51eCBkcml2ZXIgYnV0IHRyaWdnZXJlZCBieSBCRkEgRkNTIG9uIFBMT0dJL08gZXZlbnRzCisgKi8KKyNkZWZpbmUgYmZhZF90bV9wb3J0X29ubGluZSh4LCB5KQlkbyB7fSB3aGlsZSAoMCkKKyNkZWZpbmUgYmZhZF90bV9wb3J0X29mZmxpbmUoeCwgeSkJZG8ge30gd2hpbGUgKDApCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9iZmFkX3RyY21vZC5oIGIvZHJpdmVycy9zY3NpL2JmYS9iZmFkX3RyY21vZC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI4MjdiMmEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2JmYWRfdHJjbW9kLmgKQEAgLTAsMCArMSw1MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFkX3RyY21vZC5oIExpbnV4IGRyaXZlciB0cmFjZSBtb2R1bGVzCisgKi8KKworCisjaWZuZGVmIF9fQkZBRF9UUkNNT0RfSF9fCisjZGVmaW5lIF9fQkZBRF9UUkNNT0RfSF9fCisKKyNpbmNsdWRlIDxjcy9iZmFfdHJjLmg+CisKKy8qCisgKiAhISEgT25seSBhcHBlbmQgdG8gdGhlIGVudW1zIGRlZmluZWQgaGVyZSB0byBhdm9pZCBhbnkgdmVyc2lvbmluZworICogISEhIG5lZWRlZCBiZXR3ZWVuIHRyYWNlIHV0aWxpdHkgYW5kIGRyaXZlciB2ZXJzaW9uCisgKi8KK2VudW0geworCS8qIDIuNiBEcml2ZXIgKi8KKwlCRkFfVFJDX0xEUlZfQkZBRAkJPSAxLAorCUJGQV9UUkNfTERSVl9CRkFEXzJfNgkJPSAyLAorCUJGQV9UUkNfTERSVl9CRkFEXzJfNl85CQk9IDMsCisJQkZBX1RSQ19MRFJWX0JGQURfMl82XzEwCT0gNCwKKwlCRkFfVFJDX0xEUlZfSU5UUgkJPSA1LAorCUJGQV9UUkNfTERSVl9JT0NUTAkJPSA2LAorCUJGQV9UUkNfTERSVl9PUwkJCT0gNywKKwlCRkFfVFJDX0xEUlZfSU0JCQk9IDgsCisJQkZBX1RSQ19MRFJWX0lNXzJfNgkJPSA5LAorCUJGQV9UUkNfTERSVl9JTV8yXzZfOQkJPSAxMCwKKwlCRkFfVFJDX0xEUlZfSU1fMl82XzEwCQk9IDExLAorCUJGQV9UUkNfTERSVl9UTQkJCT0gMTIsCisJQkZBX1RSQ19MRFJWX0lQRkMJCT0gMTMsCisJQkZBX1RSQ19MRFJWX0lNXzJfNAkJPSAxNCwKKwlCRkFfVFJDX0xEUlZfSU1fVk1XCQk9IDE1LAorCUJGQV9UUkNfTERSVl9JTV9MVF8yXzZfMTAJPSAxNiwKK307CisKKyNlbmRpZiAvKiBfX0JGQURfVFJDTU9EX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9mYWIuYyBiL2RyaXZlcnMvc2NzaS9iZmEvZmFiLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2UzYTRkNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvZmFiLmMKQEAgLTAsMCArMSw2MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaW5jbHVkZSA8YmZhLmg+CisjaW5jbHVkZSA8YmZhX3N2Yy5oPgorI2luY2x1ZGUgImZjc19scG9ydC5oIgorI2luY2x1ZGUgImZjc19ycG9ydC5oIgorI2luY2x1ZGUgImxwb3J0X3ByaXYuaCIKKworLyoqCisgKiAgZmFiLmMgcG9ydCBmYWIgaW1wbGVtZW50YXRpb24uCisgKi8KKworLyoqCisgKiAgYmZhX2Zjc19wb3J0X2ZhYl9wdWJsaWMgcG9ydCBmYWIgcHVibGljIGZ1bmN0aW9ucworICovCisKKy8qKgorICogICBDYWxsZWQgYnkgcG9ydCB0byBpbml0aWFsaXplIGZhYnJpYyBzZXJ2aWNlcyBvZiB0aGUgYmFzZSBwb3J0LgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfZmFiX2luaXQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCWJmYV9mY3NfcG9ydF9uc19pbml0KHBvcnQpOworCWJmYV9mY3NfcG9ydF9zY25faW5pdChwb3J0KTsKKwliZmFfZmNzX3BvcnRfbXNfaW5pdChwb3J0KTsKK30KKworLyoqCisgKiAgIENhbGxlZCBieSBwb3J0IHRvIG5vdGlmeSB0cmFuc2l0aW9uIHRvIG9ubGluZSBzdGF0ZS4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2ZhYl9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCWJmYV9mY3NfcG9ydF9uc19vbmxpbmUocG9ydCk7CisJYmZhX2Zjc19wb3J0X3Njbl9vbmxpbmUocG9ydCk7Cit9CisKKy8qKgorICogICBDYWxsZWQgYnkgcG9ydCB0byBub3RpZnkgdHJhbnNpdGlvbiB0byBvZmZsaW5lIHN0YXRlLgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfZmFiX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCWJmYV9mY3NfcG9ydF9uc19vZmZsaW5lKHBvcnQpOworCWJmYV9mY3NfcG9ydF9zY25fb2ZmbGluZShwb3J0KTsKKwliZmFfZmNzX3BvcnRfbXNfb2ZmbGluZShwb3J0KTsKK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvZmFicmljLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2ZhYnJpYy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE4YjE0YzQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2ZhYnJpYy5jCkBAIC0wLDAgKzEsMTI3OCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBmYWJyaWMuYyBGYWJyaWMgbW9kdWxlIGltcGxlbWVudGF0aW9uLgorICovCisKKyNpbmNsdWRlICJmY3NfZmFicmljLmgiCisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Zwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImZjc19mY3hwLmgiCisjaW5jbHVkZSAiZmNzX2F1dGguaCIKKyNpbmNsdWRlICJmY3MuaCIKKyNpbmNsdWRlICJmY2J1aWxkLmgiCisjaW5jbHVkZSA8bG9nL2JmYV9sb2dfZmNzLmg+CisjaW5jbHVkZSA8YWVuL2JmYV9hZW5fcG9ydC5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKworQkZBX1RSQ19GSUxFKEZDUywgRkFCUklDKTsKKworI2RlZmluZSBCRkFfRkNTX0ZBQlJJQ19SRVRSWV9ERUxBWQkoMjAwMCkJLyogTWlsbGlzZWNvbmRzICovCisjZGVmaW5lIEJGQV9GQ1NfRkFCUklDX0NMRUFOVVBfREVMQVkJKDEwMDAwKQkvKiBNaWxsaXNlY29uZHMgKi8KKworI2RlZmluZSBiZmFfZmNzX2ZhYnJpY19zZXRfb3BlcnR5cGUoX19mYWJyaWMpIGRvIHsgICAgICAgICAgXAorICAgIGlmIChiZmFfcHBvcnRfZ2V0X3RvcG9sb2d5KChfX2ZhYnJpYyktPmZjcy0+YmZhKSAgICBcCisJCQkJPT0gQkZBX1BQT1JUX1RPUE9MT0dZX1AyUCkgICBcCisJICAgIChfX2ZhYnJpYyktPm9wZXJfdHlwZSA9IEJGQV9QUE9SVF9UWVBFX05QT1JUOyAgICAgICBcCisgICAgZWxzZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisJICAgIChfX2ZhYnJpYyktPm9wZXJfdHlwZSA9IEJGQV9QUE9SVF9UWVBFX05MUE9SVDsgICAgICBcCit9IHdoaWxlICgwKQorCisvKgorICogZm9yd2FyZCBkZWNsYXJhdGlvbnMKKyAqLworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX2luaXQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19mYWJyaWNfbG9naW4oc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19mYWJyaWNfbm90aWZ5X29ubGluZShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19ub3RpZnlfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19kZWxheSh2b2lkICpjYmFyZyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19mYWJyaWNfZGVsZXRlKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX2RlbGV0ZV9jb21wKHZvaWQgKmNiYXJnKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19wcm9jZXNzX3VmKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJCSAgc3RydWN0IGZjaHNfcyAqZmNocywgdTE2IGxlbik7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19mYWJyaWNfcHJvY2Vzc19mbG9naShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJCQkgICAgIHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUxNiBsZW4pOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NlbmRfZmxvZ2lfYWNjKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX2Zsb2dpYWNjX2NvbXAodm9pZCAqZmNzYXJnLAorCQkJCQkgICAgIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCQkgICAgIHZvaWQgKmNiYXJnLCBiZmFfc3RhdHVzX3Qgc3RhdHVzLAorCQkJCQkgICAgIHUzMiByc3BfbGVuLAorCQkJCQkgICAgIHUzMiByZXNpZF9sZW4sCisJCQkJCSAgICAgc3RydWN0IGZjaHNfcyAqcnNwZmNocyk7CisvKioKKyAqICBmY3NfZmFicmljX3NtIGZhYnJpYyBzdGF0ZSBtYWNoaW5lIGZ1bmN0aW9ucworICovCisKKy8qKgorICogRmFicmljIHN0YXRlIG1hY2hpbmUgZXZlbnRzCisgKi8KK2VudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgeworCUJGQV9GQ1NfRkFCUklDX1NNX0NSRUFURSA9IDEsCS8qICBmYWJyaWMgY3JlYXRlIGZyb20gZHJpdmVyICovCisJQkZBX0ZDU19GQUJSSUNfU01fREVMRVRFID0gMiwJLyogIGZhYnJpYyBkZWxldGUgZnJvbSBkcml2ZXIgKi8KKwlCRkFfRkNTX0ZBQlJJQ19TTV9MSU5LX0RPV04gPSAzLAkvKiAgbGluayBkb3duIGZyb20gcG9ydCAqLworCUJGQV9GQ1NfRkFCUklDX1NNX0xJTktfVVAgPSA0LAkvKiAgbGluayB1cCBmcm9tIHBvcnQgKi8KKwlCRkFfRkNTX0ZBQlJJQ19TTV9DT05UX09QID0gNSwJLyogIGNvbnRpbnVlIG9wIGZyb20gZmxvZ2kvYXV0aCAqLworCUJGQV9GQ1NfRkFCUklDX1NNX1JFVFJZX09QID0gNiwJLyogIGNvbnRpbnVlIG9wIGZyb20gZmxvZ2kvYXV0aCAqLworCUJGQV9GQ1NfRkFCUklDX1NNX05PX0ZBQlJJQyA9IDcsCS8qICBubyBmYWJyaWMgZnJvbSBmbG9naS9hdXRoCisJCQkJCQkgKi8KKwlCRkFfRkNTX0ZBQlJJQ19TTV9QRVJGX0VWRlAgPSA4LAkvKiAgcGVyZm9ybSBFVkZQIGZyb20KKwkJCQkJCSAqZmxvZ2kvYXV0aCAqLworCUJGQV9GQ1NfRkFCUklDX1NNX0lTT0xBVEUgPSA5LAkvKiAgaXNvbGF0ZSBmcm9tIEVWRlAgcHJvY2Vzc2luZyAqLworCUJGQV9GQ1NfRkFCUklDX1NNX05PX1RBR0dJTkcgPSAxMCwvKiAgbm8gVkZUIHRhZ2dpbmcgZnJvbSBFVkZQICovCisJQkZBX0ZDU19GQUJSSUNfU01fREVMQVlFRCA9IDExLAkvKiAgdGltZW91dCBkZWxheSBldmVudCAqLworCUJGQV9GQ1NfRkFCUklDX1NNX0FVVEhfRkFJTEVEID0gMTIsCS8qICBhdXRoZW50aWNhdGlvbiBmYWlsZWQgKi8KKwlCRkFfRkNTX0ZBQlJJQ19TTV9BVVRIX1NVQ0NFU1MgPSAxMywJLyogIGF1dGhlbnRpY2F0aW9uIHN1Y2Nlc3NmdWwKKwkJCQkJCSAqLworCUJGQV9GQ1NfRkFCUklDX1NNX0RFTENPTVAgPSAxNCwJLyogIGFsbCB2cG9ydHMgZGVsZXRlZCBldmVudCAqLworCUJGQV9GQ1NfRkFCUklDX1NNX0xPT1BCQUNLID0gMTUsCS8qICBSZWNlaXZlZCBvdXIgb3duIEZMT0dJICovCisJQkZBX0ZDU19GQUJSSUNfU01fU1RBUlQgPSAxNiwJLyogIGZhYnJpYyBkZWxldGUgZnJvbSBkcml2ZXIgKi8KK307CisKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19zbV91bmluaXQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCQkJIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NtX2NyZWF0ZWQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCQkJICBlbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19zbV9saW5rZG93bihzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJCQkgICBlbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19zbV9mbG9naShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJCQllbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19zbV9mbG9naV9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJCQkgICAgICBlbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19zbV9hdXRoKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJICAgICAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NtX2F1dGhfZmFpbGVkKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJCSAgICAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NtX2xvb3BiYWNrKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJCSAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NtX25vZmFicmljKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJCSAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NtX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJCQkgZW51bSBiZmFfZmNzX2ZhYnJpY19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19mYWJyaWNfc21fZXZmcChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJCSAgICAgICBlbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2ZhYnJpY19zbV9ldmZwX2RvbmUoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCQkJICAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NtX2lzb2xhdGVkKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJCSAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfZmFicmljX3NtX2RlbGV0aW5nKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJCSAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpOworLyoqCisgKiAgIEJlZ2lubmluZyBzdGF0ZSBiZWZvcmUgZmFicmljIGNyZWF0aW9uLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc21fdW5pbml0KHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkgZW51bSBiZmFfZmNzX2ZhYnJpY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMoZmFicmljLT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0NSRUFURToKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2NyZWF0ZWQpOworCQliZmFfZmNzX2ZhYnJpY19pbml0KGZhYnJpYyk7CisJCWJmYV9mY3NfbHBvcnRfaW5pdCgmZmFicmljLT5icG9ydCwgZmFicmljLT5mY3MsIEZDX1ZGX0lEX05VTEwsCisJCQkJICAgJmZhYnJpYy0+YnBvcnQucG9ydF9jZmcsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fTElOS19VUDoKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0xJTktfRE9XTjoKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQoZmFicmljLT5mY3MsIGV2ZW50KTsKKwl9Cit9CisKKy8qKgorICogICBCZWdpbm5pbmcgc3RhdGUgYmVmb3JlIGZhYnJpYyBjcmVhdGlvbi4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX3NtX2NyZWF0ZWQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCSAgZW51bSBiZmFfZmNzX2ZhYnJpY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMoZmFicmljLT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX1NUQVJUOgorCQlpZiAoYmZhX3Bwb3J0X2lzX2xpbmt1cChmYWJyaWMtPmZjcy0+YmZhKSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2Zsb2dpKTsKKwkJCWJmYV9mY3NfZmFicmljX2xvZ2luKGZhYnJpYyk7CisJCX0gZWxzZQorCQkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2xpbmtkb3duKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0xJTktfVVA6CisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9MSU5LX0RPV046CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV91bmluaXQpOworCQliZmFfZmNzX21vZGV4aXRfY29tcChmYWJyaWMtPmZjcyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGZhYnJpYy0+ZmNzLCBldmVudCk7CisJfQorfQorCisvKioKKyAqICAgTGluayBpcyBkb3duLCBhd2FpdGluZyBMSU5LIFVQIGV2ZW50IGZyb20gcG9ydC4gVGhpcyBpcyBhbHNvIHRoZQorICogICBmaXJzdCBzdGF0ZSBhdCBmYWJyaWMgY3JlYXRpb24uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX2ZhYnJpY19zbV9saW5rZG93bihzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJICAgZW51bSBiZmFfZmNzX2ZhYnJpY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMoZmFicmljLT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0xJTktfVVA6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9mbG9naSk7CisJCWJmYV9mY3NfZmFicmljX2xvZ2luKGZhYnJpYyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9SRVRSWV9PUDoKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2RlbGV0aW5nKTsKKwkJYmZhX2Zjc19mYWJyaWNfZGVsZXRlKGZhYnJpYyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGZhYnJpYy0+ZmNzLCBldmVudCk7CisJfQorfQorCisvKioKKyAqICAgRkxPR0kgaXMgaW4gcHJvZ3Jlc3MsIGF3YWl0aW5nIEZMT0dJIHJlcGx5LgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc21fZmxvZ2koc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCWVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5icG9ydC5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9DT05UX09QOgorCisJCWJmYV9wcG9ydF9zZXRfdHhfYmJjcmVkaXQoZmFicmljLT5mY3MtPmJmYSwgZmFicmljLT5iYl9jcmVkaXQpOworCQlmYWJyaWMtPmZhYl90eXBlID0gQkZBX0ZDU19GQUJSSUNfU1dJVENIRUQ7CisKKwkJaWYgKGZhYnJpYy0+YXV0aF9yZXFkICYmIGZhYnJpYy0+aXNfYXV0aCkgeworCQkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2F1dGgpOworCQkJYmZhX3RyYyhmYWJyaWMtPmZjcywgZXZlbnQpOworCQl9IGVsc2UgeworCQkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX29ubGluZSk7CisJCQliZmFfZmNzX2ZhYnJpY19ub3RpZnlfb25saW5lKGZhYnJpYyk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX1JFVFJZX09QOgorCQliZmFfc21fc2V0X3N0YXRlKGZhYnJpYywgYmZhX2Zjc19mYWJyaWNfc21fZmxvZ2lfcmV0cnkpOworCQliZmFfdGltZXJfc3RhcnQoZmFicmljLT5mY3MtPmJmYSwgJmZhYnJpYy0+ZGVsYXlfdGltZXIsCisJCQkJYmZhX2Zjc19mYWJyaWNfZGVsYXksIGZhYnJpYywKKwkJCQlCRkFfRkNTX0ZBQlJJQ19SRVRSWV9ERUxBWSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9MT09QQkFDSzoKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2xvb3BiYWNrKTsKKwkJYmZhX2xwc19kaXNjYXJkKGZhYnJpYy0+bHBzKTsKKwkJYmZhX2Zjc19mYWJyaWNfc2V0X29wZXJ0eXBlKGZhYnJpYyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9OT19GQUJSSUM6CisJCWZhYnJpYy0+ZmFiX3R5cGUgPSBCRkFfRkNTX0ZBQlJJQ19OMk47CisJCWJmYV9wcG9ydF9zZXRfdHhfYmJjcmVkaXQoZmFicmljLT5mY3MtPmJmYSwgZmFicmljLT5iYl9jcmVkaXQpOworCQliZmFfZmNzX2ZhYnJpY19ub3RpZnlfb25saW5lKGZhYnJpYyk7CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9ub2ZhYnJpYyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9MSU5LX0RPV046CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9saW5rZG93bik7CisJCWJmYV9scHNfZGlzY2FyZChmYWJyaWMtPmxwcyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9kZWxldGluZyk7CisJCWJmYV9scHNfZGlzY2FyZChmYWJyaWMtPmxwcyk7CisJCWJmYV9mY3NfZmFicmljX2RlbGV0ZShmYWJyaWMpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChmYWJyaWMtPmZjcywgZXZlbnQpOworCX0KK30KKworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc21fZmxvZ2lfcmV0cnkoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCSAgICAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5icG9ydC5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxBWUVEOgorCQliZmFfc21fc2V0X3N0YXRlKGZhYnJpYywgYmZhX2Zjc19mYWJyaWNfc21fZmxvZ2kpOworCQliZmFfZmNzX2ZhYnJpY19sb2dpbihmYWJyaWMpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fTElOS19ET1dOOgorCQliZmFfc21fc2V0X3N0YXRlKGZhYnJpYywgYmZhX2Zjc19mYWJyaWNfc21fbGlua2Rvd24pOworCQliZmFfdGltZXJfc3RvcCgmZmFicmljLT5kZWxheV90aW1lcik7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9kZWxldGluZyk7CisJCWJmYV90aW1lcl9zdG9wKCZmYWJyaWMtPmRlbGF5X3RpbWVyKTsKKwkJYmZhX2Zjc19mYWJyaWNfZGVsZXRlKGZhYnJpYyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGZhYnJpYy0+ZmNzLCBldmVudCk7CisJfQorfQorCisvKioKKyAqICAgQXV0aGVudGljYXRpb24gaXMgaW4gcHJvZ3Jlc3MsIGF3YWl0aW5nIGF1dGhlbnRpY2F0aW9uIHJlc3VsdHMuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX2ZhYnJpY19zbV9hdXRoKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCSAgICAgICBlbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoZmFicmljLT5mY3MsIGZhYnJpYy0+YnBvcnQucG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fQVVUSF9GQUlMRUQ6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9hdXRoX2ZhaWxlZCk7CisJCWJmYV9scHNfZGlzY2FyZChmYWJyaWMtPmxwcyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9BVVRIX1NVQ0NFU1M6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9vbmxpbmUpOworCQliZmFfZmNzX2ZhYnJpY19ub3RpZnlfb25saW5lKGZhYnJpYyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9QRVJGX0VWRlA6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9ldmZwKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0xJTktfRE9XTjoKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2xpbmtkb3duKTsKKwkJYmZhX2xwc19kaXNjYXJkKGZhYnJpYy0+bHBzKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2RlbGV0aW5nKTsKKwkJYmZhX2Zjc19mYWJyaWNfZGVsZXRlKGZhYnJpYyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGZhYnJpYy0+ZmNzLCBldmVudCk7CisJfQorfQorCisvKioKKyAqICAgQXV0aGVudGljYXRpb24gZmFpbGVkCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX2ZhYnJpY19zbV9hdXRoX2ZhaWxlZChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJICAgICAgZW51bSBiZmFfZmNzX2ZhYnJpY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMoZmFicmljLT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0xJTktfRE9XTjoKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2xpbmtkb3duKTsKKwkJYmZhX2Zjc19mYWJyaWNfbm90aWZ5X29mZmxpbmUoZmFicmljKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2RlbGV0aW5nKTsKKwkJYmZhX2Zjc19mYWJyaWNfZGVsZXRlKGZhYnJpYyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGZhYnJpYy0+ZmNzLCBldmVudCk7CisJfQorfQorCisvKioKKyAqICAgUG9ydCBpcyBpbiBsb29wYmFjayBtb2RlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc21fbG9vcGJhY2soc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCSAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5icG9ydC5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9MSU5LX0RPV046CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9saW5rZG93bik7CisJCWJmYV9mY3NfZmFicmljX25vdGlmeV9vZmZsaW5lKGZhYnJpYyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9kZWxldGluZyk7CisJCWJmYV9mY3NfZmFicmljX2RlbGV0ZShmYWJyaWMpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9zbV9mYXVsdChmYWJyaWMtPmZjcywgZXZlbnQpOworCX0KK30KKworLyoqCisgKiAgIFRoZXJlIGlzIG5vIGF0dGFjaGVkIGZhYnJpYyAtIHByaXZhdGUgbG9vcCBvciBOUG9ydC10by1OUG9ydCB0b3BvbG9neS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX3NtX25vZmFicmljKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkgICBlbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoZmFicmljLT5mY3MsIGZhYnJpYy0+YnBvcnQucG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fTElOS19ET1dOOgorCQliZmFfc21fc2V0X3N0YXRlKGZhYnJpYywgYmZhX2Zjc19mYWJyaWNfc21fbGlua2Rvd24pOworCQliZmFfbHBzX2Rpc2NhcmQoZmFicmljLT5scHMpOworCQliZmFfZmNzX2ZhYnJpY19ub3RpZnlfb2ZmbGluZShmYWJyaWMpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGZhYnJpYywgYmZhX2Zjc19mYWJyaWNfc21fZGVsZXRpbmcpOworCQliZmFfZmNzX2ZhYnJpY19kZWxldGUoZmFicmljKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX05PX0ZBQlJJQzoKKwkJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5iYl9jcmVkaXQpOworCQliZmFfcHBvcnRfc2V0X3R4X2JiY3JlZGl0KGZhYnJpYy0+ZmNzLT5iZmEsIGZhYnJpYy0+YmJfY3JlZGl0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQoZmFicmljLT5mY3MsIGV2ZW50KTsKKwl9Cit9CisKKy8qKgorICogICBGYWJyaWMgaXMgb25saW5lIC0gbm9ybWFsIG9wZXJhdGluZyBzdGF0ZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX3NtX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5icG9ydC5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9MSU5LX0RPV046CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9saW5rZG93bik7CisJCWJmYV9scHNfZGlzY2FyZChmYWJyaWMtPmxwcyk7CisJCWJmYV9mY3NfZmFicmljX25vdGlmeV9vZmZsaW5lKGZhYnJpYyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9kZWxldGluZyk7CisJCWJmYV9mY3NfZmFicmljX2RlbGV0ZShmYWJyaWMpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fQVVUSF9GQUlMRUQ6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9hdXRoX2ZhaWxlZCk7CisJCWJmYV9scHNfZGlzY2FyZChmYWJyaWMtPmxwcyk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9BVVRIX1NVQ0NFU1M6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGZhYnJpYy0+ZmNzLCBldmVudCk7CisJfQorfQorCisvKioKKyAqICAgRXhjaGFuZ2luZyB2aXJ0dWFsIGZhYnJpYyBwYXJhbWV0ZXJzLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc21fZXZmcChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkgICAgICAgZW51bSBiZmFfZmNzX2ZhYnJpY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMoZmFicmljLT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0NPTlRfT1A6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmFicmljLCBiZmFfZmNzX2ZhYnJpY19zbV9ldmZwX2RvbmUpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fSVNPTEFURToKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX2lzb2xhdGVkKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfc21fZmF1bHQoZmFicmljLT5mY3MsIGV2ZW50KTsKKwl9Cit9CisKKy8qKgorICogICBFVkZQIGV4Y2hhbmdlIGNvbXBsZXRlIGFuZCBWRlQgdGFnZ2luZyBpcyBlbmFibGVkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc21fZXZmcF9kb25lKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkgICAgZW51bSBiZmFfZmNzX2ZhYnJpY19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMoZmFicmljLT5mY3MsIGV2ZW50KTsKK30KKworLyoqCisgKiAgIFBvcnQgaXMgaXNvbGF0ZWQgYWZ0ZXIgRVZGUCBleGNoYW5nZSBkdWUgdG8gVkZfSUQgbWlzbWF0Y2ggKE4gYW5kIEYpLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc21faXNvbGF0ZWQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCSAgIGVudW0gYmZhX2Zjc19mYWJyaWNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5icG9ydC5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBldmVudCk7CisKKwliZmFfbG9nKGZhYnJpYy0+ZmNzLT5sb2dtLCBCRkFfTE9HX0ZDU19GQUJSSUNfSVNPTEFURUQsCisJCWZhYnJpYy0+YnBvcnQucG9ydF9jZmcucHd3biwgZmFicmljLT5mY3MtPnBvcnRfdmZpZCwKKwkJZmFicmljLT5ldmVudF9hcmcuc3dwX3ZmaWQpOworfQorCisvKioKKyAqICAgRmFicmljIGlzIGJlaW5nIGRlbGV0ZWQsIGF3YWl0aW5nIHZwb3J0IGRlbGV0ZSBjb21wbGV0aW9ucy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX3NtX2RlbGV0aW5nKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkgICBlbnVtIGJmYV9mY3NfZmFicmljX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoZmFicmljLT5mY3MsIGZhYnJpYy0+YnBvcnQucG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19GQUJSSUNfU01fREVMQ09NUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX3VuaW5pdCk7CisJCWJmYV9mY3NfbW9kZXhpdF9jb21wKGZhYnJpYy0+ZmNzKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfRkFCUklDX1NNX0xJTktfVVA6CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0ZBQlJJQ19TTV9MSU5LX0RPV046CisJCWJmYV9mY3NfZmFicmljX25vdGlmeV9vZmZsaW5lKGZhYnJpYyk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX2ZhdWx0KGZhYnJpYy0+ZmNzLCBldmVudCk7CisJfQorfQorCisKKworLyoqCisgKiAgZmNzX2ZhYnJpY19wcml2YXRlIGZhYnJpYyBwcml2YXRlIGZ1bmN0aW9ucworICovCisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX2ZhYnJpY19pbml0KHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpCit7CisJc3RydWN0IGJmYV9wb3J0X2NmZ19zICpwb3J0X2NmZyA9ICZmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnOworCisJcG9ydF9jZmctPnJvbGVzID0gQkZBX1BPUlRfUk9MRV9GQ1BfSU07CisJcG9ydF9jZmctPm53d24gPSBiZmFfaW9jX2dldF9ud3duKCZmYWJyaWMtPmZjcy0+YmZhLT5pb2MpOworCXBvcnRfY2ZnLT5wd3duID0gYmZhX2lvY19nZXRfcHd3bigmZmFicmljLT5mY3MtPmJmYS0+aW9jKTsKK30KKworLyoqCisgKiBQb3J0IFN5bWJvbGljIE5hbWUgQ3JlYXRpb24gZm9yIGJhc2UgcG9ydC4KKyAqLwordm9pZAorYmZhX2Zjc19mYWJyaWNfcHN5bWJfaW5pdChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKQoreworCXN0cnVjdCBiZmFfcG9ydF9jZmdfcyAqcG9ydF9jZmcgPSAmZmFicmljLT5icG9ydC5wb3J0X2NmZzsKKwlzdHJ1Y3QgYmZhX2FkYXB0ZXJfYXR0cl9zIGFkYXB0ZXJfYXR0cjsKKwlzdHJ1Y3QgYmZhX2Zjc19kcml2ZXJfaW5mb19zICpkcml2ZXJfaW5mbyA9ICZmYWJyaWMtPmZjcy0+ZHJpdmVyX2luZm87CisKKwliZmFfb3NfbWVtc2V0KCh2b2lkICopJmFkYXB0ZXJfYXR0ciwgMCwKKwkJICAgICAgc2l6ZW9mKHN0cnVjdCBiZmFfYWRhcHRlcl9hdHRyX3MpKTsKKwliZmFfaW9jX2dldF9hZGFwdGVyX2F0dHIoJmZhYnJpYy0+ZmNzLT5iZmEtPmlvYywgJmFkYXB0ZXJfYXR0cik7CisKKwkvKgorCSAqIE1vZGVsIG5hbWUvbnVtYmVyCisJICovCisJc3RybmNweSgoY2hhciAqKSZwb3J0X2NmZy0+c3ltX25hbWUsIGFkYXB0ZXJfYXR0ci5tb2RlbCwKKwkJQkZBX0ZDU19QT1JUX1NZTUJOQU1FX01PREVMX1NaKTsKKwlzdHJuY2F0KChjaGFyICopJnBvcnRfY2ZnLT5zeW1fbmFtZSwgQkZBX0ZDU19QT1JUX1NZTUJOQU1FX1NFUEFSQVRPUiwKKwkJc2l6ZW9mKEJGQV9GQ1NfUE9SVF9TWU1CTkFNRV9TRVBBUkFUT1IpKTsKKworCS8qCisJICogRHJpdmVyIFZlcnNpb24KKwkgKi8KKwlzdHJuY2F0KChjaGFyICopJnBvcnRfY2ZnLT5zeW1fbmFtZSwgKGNoYXIgKilkcml2ZXJfaW5mby0+dmVyc2lvbiwKKwkJQkZBX0ZDU19QT1JUX1NZTUJOQU1FX1ZFUlNJT05fU1opOworCXN0cm5jYXQoKGNoYXIgKikmcG9ydF9jZmctPnN5bV9uYW1lLCBCRkFfRkNTX1BPUlRfU1lNQk5BTUVfU0VQQVJBVE9SLAorCQlzaXplb2YoQkZBX0ZDU19QT1JUX1NZTUJOQU1FX1NFUEFSQVRPUikpOworCisJLyoKKwkgKiBIb3N0IG1hY2hpbmUgbmFtZQorCSAqLworCXN0cm5jYXQoKGNoYXIgKikmcG9ydF9jZmctPnN5bV9uYW1lLAorCQkoY2hhciAqKWRyaXZlcl9pbmZvLT5ob3N0X21hY2hpbmVfbmFtZSwKKwkJQkZBX0ZDU19QT1JUX1NZTUJOQU1FX01BQ0hJTkVOQU1FX1NaKTsKKwlzdHJuY2F0KChjaGFyICopJnBvcnRfY2ZnLT5zeW1fbmFtZSwgQkZBX0ZDU19QT1JUX1NZTUJOQU1FX1NFUEFSQVRPUiwKKwkJc2l6ZW9mKEJGQV9GQ1NfUE9SVF9TWU1CTkFNRV9TRVBBUkFUT1IpKTsKKworCS8qCisJICogSG9zdCBPUyBJbmZvIDoKKwkgKiBJZiBPUyBQYXRjaCBJbmZvIGlzIG5vdCB0aGVyZSwgZG8gbm90IHRydW5jYXRlIGFueSBieXRlcyBmcm9tIHRoZQorCSAqIE9TIG5hbWUgc3RyaW5nIGFuZCBpbnN0ZWFkIGNvcHkgdGhlIGVudGlyZSBPUyBpbmZvIHN0cmluZyAoNjQgYnl0ZXMpLgorCSAqLworCWlmIChkcml2ZXJfaW5mby0+aG9zdF9vc19wYXRjaFswXSA9PSAnXDAnKSB7CisJCXN0cm5jYXQoKGNoYXIgKikmcG9ydF9jZmctPnN5bV9uYW1lLAorCQkJKGNoYXIgKilkcml2ZXJfaW5mby0+aG9zdF9vc19uYW1lLCBCRkFfRkNTX09TX1NUUl9MRU4pOworCQlzdHJuY2F0KChjaGFyICopJnBvcnRfY2ZnLT5zeW1fbmFtZSwKKwkJCUJGQV9GQ1NfUE9SVF9TWU1CTkFNRV9TRVBBUkFUT1IsCisJCQlzaXplb2YoQkZBX0ZDU19QT1JUX1NZTUJOQU1FX1NFUEFSQVRPUikpOworCX0gZWxzZSB7CisJCXN0cm5jYXQoKGNoYXIgKikmcG9ydF9jZmctPnN5bV9uYW1lLAorCQkJKGNoYXIgKilkcml2ZXJfaW5mby0+aG9zdF9vc19uYW1lLAorCQkJQkZBX0ZDU19QT1JUX1NZTUJOQU1FX09TSU5GT19TWik7CisJCXN0cm5jYXQoKGNoYXIgKikmcG9ydF9jZmctPnN5bV9uYW1lLAorCQkJQkZBX0ZDU19QT1JUX1NZTUJOQU1FX1NFUEFSQVRPUiwKKwkJCXNpemVvZihCRkFfRkNTX1BPUlRfU1lNQk5BTUVfU0VQQVJBVE9SKSk7CisKKwkJLyoKKwkJICogQXBwZW5kIGhvc3QgT1MgUGF0Y2ggSW5mbworCQkgKi8KKwkJc3RybmNhdCgoY2hhciAqKSZwb3J0X2NmZy0+c3ltX25hbWUsCisJCQkoY2hhciAqKWRyaXZlcl9pbmZvLT5ob3N0X29zX3BhdGNoLAorCQkJQkZBX0ZDU19QT1JUX1NZTUJOQU1FX09TUEFUQ0hfU1opOworCX0KKworCS8qCisJICogbnVsbCB0ZXJtaW5hdGUKKwkgKi8KKwlwb3J0X2NmZy0+c3ltX25hbWUuc3ltbmFtZVtCRkFfU1lNTkFNRV9NQVhMRU4gLSAxXSA9IDA7Cit9CisKKy8qKgorICogYmZhIGxwcyBsb2dpbiBjb21wbGV0aW9uIGNhbGxiYWNrCisgKi8KK3ZvaWQKK2JmYV9jYl9scHNfZmxvZ2lfY29tcCh2b2lkICpiZmFkLCB2b2lkICp1YXJnLCBiZmFfc3RhdHVzX3Qgc3RhdHVzKQoreworCXN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMgPSB1YXJnOworCisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5icG9ydC5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBzdGF0dXMpOworCisJc3dpdGNoIChzdGF0dXMpIHsKKwljYXNlIEJGQV9TVEFUVVNfT0s6CisJCWZhYnJpYy0+c3RhdHMuZmxvZ2lfYWNjZXB0cysrOworCQlicmVhazsKKworCWNhc2UgQkZBX1NUQVRVU19JTlZBTElEX01BQzoKKwkJLyoKKwkJICogT25seSBmb3IgQ05BCisJCSAqLworCQlmYWJyaWMtPnN0YXRzLmZsb2dpX2FjY19lcnIrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9SRVRSWV9PUCk7CisKKwkJcmV0dXJuOworCisJY2FzZSBCRkFfU1RBVFVTX0VQUk9UT0NPTDoKKwkJc3dpdGNoIChiZmFfbHBzX2dldF9leHRzdGF0dXMoZmFicmljLT5scHMpKSB7CisJCWNhc2UgQkZBX0VQUk9UT19CQURfQUNDRVBUOgorCQkJZmFicmljLT5zdGF0cy5mbG9naV9hY2NfZXJyKys7CisJCQlicmVhazsKKworCQljYXNlIEJGQV9FUFJPVE9fVU5LTk9XTl9SU1A6CisJCQlmYWJyaWMtPnN0YXRzLmZsb2dpX3Vua25vd25fcnNwKys7CisJCQlicmVhazsKKworCQlkZWZhdWx0OgorCQkJYnJlYWs7CisJCX0KKwkJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9SRVRSWV9PUCk7CisKKwkJcmV0dXJuOworCisJY2FzZSBCRkFfU1RBVFVTX0ZBQlJJQ19SSlQ6CisJCWZhYnJpYy0+c3RhdHMuZmxvZ2lfcmVqZWN0cysrOworCQliZmFfc21fc2VuZF9ldmVudChmYWJyaWMsIEJGQV9GQ1NfRkFCUklDX1NNX1JFVFJZX09QKTsKKwkJcmV0dXJuOworCisJZGVmYXVsdDoKKwkJZmFicmljLT5zdGF0cy5mbG9naV9yc3BfZXJyKys7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGZhYnJpYywgQkZBX0ZDU19GQUJSSUNfU01fUkVUUllfT1ApOworCQlyZXR1cm47CisJfQorCisJZmFicmljLT5iYl9jcmVkaXQgPSBiZmFfbHBzX2dldF9wZWVyX2JiY3JlZGl0KGZhYnJpYy0+bHBzKTsKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJiX2NyZWRpdCk7CisKKwlpZiAoIWJmYV9scHNfaXNfYnJjZF9mYWJyaWMoZmFicmljLT5scHMpKQorCQlmYWJyaWMtPmZhYnJpY19uYW1lID0gYmZhX2xwc19nZXRfcGVlcl9ud3duKGZhYnJpYy0+bHBzKTsKKworCS8qCisJICogQ2hlY2sgcG9ydCB0eXBlLiBJdCBzaG91bGQgYmUgMSA9IEYtcG9ydC4KKwkgKi8KKwlpZiAoYmZhX2xwc19pc19mcG9ydChmYWJyaWMtPmxwcykpIHsKKwkJZmFicmljLT5icG9ydC5waWQgPSBiZmFfbHBzX2dldF9waWQoZmFicmljLT5scHMpOworCQlmYWJyaWMtPmlzX25waXYgPSBiZmFfbHBzX2lzX25waXZfZW4oZmFicmljLT5scHMpOworCQlmYWJyaWMtPmlzX2F1dGggPSBiZmFfbHBzX2lzX2F1dGhyZXEoZmFicmljLT5scHMpOworCQliZmFfc21fc2VuZF9ldmVudChmYWJyaWMsIEJGQV9GQ1NfRkFCUklDX1NNX0NPTlRfT1ApOworCX0gZWxzZSB7CisJCS8qCisJCSAqIE5wb3J0LTItTnBvcnQgZGlyZWN0IGF0dGFjaGVkCisJCSAqLworCQlmYWJyaWMtPmJwb3J0LnBvcnRfdG9wby5wbjJuLnJlbV9wb3J0X3d3biA9CisJCQliZmFfbHBzX2dldF9wZWVyX3B3d24oZmFicmljLT5scHMpOworCQliZmFfc21fc2VuZF9ldmVudChmYWJyaWMsIEJGQV9GQ1NfRkFCUklDX1NNX05PX0ZBQlJJQyk7CisJfQorCisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5icG9ydC5waWQpOworCWJmYV90cmMoZmFicmljLT5mY3MsIGZhYnJpYy0+aXNfbnBpdik7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5pc19hdXRoKTsKK30KKworLyoqCisgKiAJCUFsbG9jYXRlIGFuZCBzZW5kIEZMT0dJLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfbG9naW4oc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYykKK3sKKwlzdHJ1Y3QgYmZhX3MgICAqYmZhID0gZmFicmljLT5mY3MtPmJmYTsKKwlzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgKnBjZmcgPSAmZmFicmljLT5icG9ydC5wb3J0X2NmZzsKKwl1OCAgICAgICAgIGFscGEgPSAwOworCisJaWYgKGJmYV9wcG9ydF9nZXRfdG9wb2xvZ3koYmZhKSA9PSBCRkFfUFBPUlRfVE9QT0xPR1lfTE9PUCkKKwkJYWxwYSA9IGJmYV9wcG9ydF9nZXRfbXlhbHBhKGJmYSk7CisKKwliZmFfbHBzX2Zsb2dpKGZhYnJpYy0+bHBzLCBmYWJyaWMsIGFscGEsIGJmYV9wcG9ydF9nZXRfbWF4ZnJzaXplKGJmYSksCisJCSAgICAgIHBjZmctPnB3d24sIHBjZmctPm53d24sIGZhYnJpYy0+YXV0aF9yZXFkKTsKKworCWZhYnJpYy0+c3RhdHMuZmxvZ2lfc2VudCsrOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfbm90aWZ5X29ubGluZShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKQoreworCXN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0OworCXN0cnVjdCBsaXN0X2hlYWQgKnFlLCAqcWVuOworCisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT5mYWJyaWNfbmFtZSk7CisKKwliZmFfZmNzX2ZhYnJpY19zZXRfb3BlcnR5cGUoZmFicmljKTsKKwlmYWJyaWMtPnN0YXRzLmZhYnJpY19vbmxpbmVzKys7CisKKwkvKioKKwkgKiBub3RpZnkgb25saW5lIGV2ZW50IHRvIGJhc2UgYW5kIHRoZW4gdmlydHVhbCBwb3J0cworCSAqLworCWJmYV9mY3NfcG9ydF9vbmxpbmUoJmZhYnJpYy0+YnBvcnQpOworCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZmYWJyaWMtPnZwb3J0X3EpIHsKKwkJdnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqKXFlOworCQliZmFfZmNzX3Zwb3J0X29ubGluZSh2cG9ydCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfbm90aWZ5X29mZmxpbmUoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICpxZSwgKnFlbjsKKworCWJmYV90cmMoZmFicmljLT5mY3MsIGZhYnJpYy0+ZmFicmljX25hbWUpOworCWZhYnJpYy0+c3RhdHMuZmFicmljX29mZmxpbmVzKys7CisKKwkvKioKKwkgKiBub3RpZnkgb2ZmbGluZSBldmVudCBmaXJzdCB0byB2cG9ydHMgYW5kIHRoZW4gYmFzZSBwb3J0LgorCSAqLworCWxpc3RfZm9yX2VhY2hfc2FmZShxZSwgcWVuLCAmZmFicmljLT52cG9ydF9xKSB7CisJCXZwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKilxZTsKKwkJYmZhX2Zjc192cG9ydF9vZmZsaW5lKHZwb3J0KTsKKwl9CisKKwliZmFfZmNzX3BvcnRfb2ZmbGluZSgmZmFicmljLT5icG9ydCk7CisKKwlmYWJyaWMtPmZhYnJpY19uYW1lID0gMDsKKwlmYWJyaWMtPmZhYnJpY19pcF9hZGRyWzBdID0gMDsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX2RlbGF5KHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMgPSBjYmFyZzsKKworCWJmYV9zbV9zZW5kX2V2ZW50KGZhYnJpYywgQkZBX0ZDU19GQUJSSUNfU01fREVMQVlFRCk7Cit9CisKKy8qKgorICogRGVsZXRlIGFsbCB2cG9ydHMgYW5kIHdhaXQgZm9yIHZwb3J0IGRlbGV0ZSBjb21wbGV0aW9ucy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX2RlbGV0ZShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKQoreworCXN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0OworCXN0cnVjdCBsaXN0X2hlYWQgKnFlLCAqcWVuOworCisJbGlzdF9mb3JfZWFjaF9zYWZlKHFlLCBxZW4sICZmYWJyaWMtPnZwb3J0X3EpIHsKKwkJdnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqKXFlOworCQliZmFfZmNzX3Zwb3J0X2RlbGV0ZSh2cG9ydCk7CisJfQorCisJYmZhX2Zjc19wb3J0X2RlbGV0ZSgmZmFicmljLT5icG9ydCk7CisJYmZhX3djX3dhaXQoJmZhYnJpYy0+d2MpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfZGVsZXRlX2NvbXAodm9pZCAqY2JhcmcpCit7CisJc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyA9IGNiYXJnOworCisJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxDT01QKTsKK30KKworCisKKy8qKgorICogIGZjc19mYWJyaWNfcHVibGljIGZhYnJpYyBwdWJsaWMgZnVuY3Rpb25zCisgKi8KKworLyoqCisgKiAgIE1vZHVsZSBpbml0aWFsaXphdGlvbgorICovCit2b2lkCitiZmFfZmNzX2ZhYnJpY19tb2Rpbml0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljOworCisJZmFicmljID0gJmZjcy0+ZmFicmljOworCWJmYV9vc19tZW1zZXQoZmFicmljLCAwLCBzaXplb2Yoc3RydWN0IGJmYV9mY3NfZmFicmljX3MpKTsKKworCS8qKgorCSAqIEluaXRpYWxpemUgYmFzZSBmYWJyaWMuCisJICovCisJZmFicmljLT5mY3MgPSBmY3M7CisJSU5JVF9MSVNUX0hFQUQoJmZhYnJpYy0+dnBvcnRfcSk7CisJSU5JVF9MSVNUX0hFQUQoJmZhYnJpYy0+dmZfcSk7CisJZmFicmljLT5scHMgPSBiZmFfbHBzX2FsbG9jKGZjcy0+YmZhKTsKKwliZmFfYXNzZXJ0KGZhYnJpYy0+bHBzKTsKKworCS8qKgorCSAqIEluaXRpYWxpemUgZmFicmljIGRlbGV0ZSBjb21wbGV0aW9uIGhhbmRsZXIuIEZhYnJpYyBkZWxldGlvbiBpcyBjb21wbGV0ZQorCSAqIHdoZW4gdGhlIGxhc3QgdnBvcnQgZGVsZXRlIGlzIGNvbXBsZXRlLgorCSAqLworCWJmYV93Y19pbml0KCZmYWJyaWMtPndjLCBiZmFfZmNzX2ZhYnJpY19kZWxldGVfY29tcCwgZmFicmljKTsKKwliZmFfd2NfdXAoJmZhYnJpYy0+d2MpOwkvKiBGb3IgdGhlIGJhc2UgcG9ydCAqLworCisJYmZhX3NtX3NldF9zdGF0ZShmYWJyaWMsIGJmYV9mY3NfZmFicmljX3NtX3VuaW5pdCk7CisJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9DUkVBVEUpOworCWJmYV90cmMoZmNzLCAwKTsKK30KKworLyoqCisgKiAgIE1vZHVsZSBjbGVhbnVwCisgKi8KK3ZvaWQKK2JmYV9mY3NfZmFicmljX21vZGV4aXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKQoreworCXN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWM7CisKKwliZmFfdHJjKGZjcywgMCk7CisKKwkvKioKKwkgKiBDbGVhbnVwIGJhc2UgZmFicmljLgorCSAqLworCWZhYnJpYyA9ICZmY3MtPmZhYnJpYzsKKwliZmFfbHBzX2RlbGV0ZShmYWJyaWMtPmxwcyk7CisJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9ERUxFVEUpOworfQorCisvKioKKyAqIEZhYnJpYyBtb2R1bGUgc3RhcnQgLS0ga2ljayBzdGFydHMgRkNTIGFjdGlvbnMKKyAqLwordm9pZAorYmZhX2Zjc19mYWJyaWNfbW9kc3RhcnQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKQoreworCXN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWM7CisKKwliZmFfdHJjKGZjcywgMCk7CisJZmFicmljID0gJmZjcy0+ZmFicmljOworCWJmYV9zbV9zZW5kX2V2ZW50KGZhYnJpYywgQkZBX0ZDU19GQUJSSUNfU01fU1RBUlQpOworfQorCisvKioKKyAqICAgU3VzcGVuZCBmYWJyaWMgYWN0aXZpdHkgYXMgcGFydCBvZiBkcml2ZXIgc3VzcGVuZC4KKyAqLwordm9pZAorYmZhX2Zjc19mYWJyaWNfbW9kc3VzcChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7Cit9CisKK2JmYV9ib29sZWFuX3QKK2JmYV9mY3NfZmFicmljX2lzX2xvb3BiYWNrKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpCit7CisJcmV0dXJuIChiZmFfc21fY21wX3N0YXRlKGZhYnJpYywgYmZhX2Zjc19mYWJyaWNfc21fbG9vcGJhY2spKTsKK30KKworZW51bSBiZmFfcHBvcnRfdHlwZQorYmZhX2Zjc19mYWJyaWNfcG9ydF90eXBlKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpCit7CisJcmV0dXJuIGZhYnJpYy0+b3Blcl90eXBlOworfQorCisvKioKKyAqICAgTGluayB1cCBub3RpZmljYXRpb24gZnJvbSBCRkEgcGh5c2ljYWwgcG9ydCBtb2R1bGUuCisgKi8KK3ZvaWQKK2JmYV9mY3NfZmFicmljX2xpbmtfdXAoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYykKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV9zbV9zZW5kX2V2ZW50KGZhYnJpYywgQkZBX0ZDU19GQUJSSUNfU01fTElOS19VUCk7Cit9CisKKy8qKgorICogICBMaW5rIGRvd24gbm90aWZpY2F0aW9uIGZyb20gQkZBIHBoeXNpY2FsIHBvcnQgbW9kdWxlLgorICovCit2b2lkCitiZmFfZmNzX2ZhYnJpY19saW5rX2Rvd24oc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYykKK3sKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmYWJyaWMtPmJwb3J0LnBvcnRfY2ZnLnB3d24pOworCWJmYV9zbV9zZW5kX2V2ZW50KGZhYnJpYywgQkZBX0ZDU19GQUJSSUNfU01fTElOS19ET1dOKTsKK30KKworLyoqCisgKiAgIEEgY2hpbGQgdnBvcnQgaXMgYmVpbmcgY3JlYXRlZCBpbiB0aGUgZmFicmljLgorICoKKyAqICAgQ2FsbCBmcm9tIHZwb3J0IG1vZHVsZSBhdCB2cG9ydCBjcmVhdGlvbi4gQSBsaXN0IG9mIGJhc2UgcG9ydCBhbmQgdnBvcnRzCisgKiAgIGJlbG9uZ2luZyB0byBhIGZhYnJpYyBpcyBtYWludGFpbmVkIHRvIHByb3BhZ2F0ZSBsaW5rIGV2ZW50cy4KKyAqCisgKiAgIHBhcmFtW2luXSBmYWJyaWMgLSBGYWJyaWMgaW5zdGFuY2UuIFRoaXMgY2FuIGJlIGEgYmFzZSBmYWJyaWMgb3IgdmYuCisgKiAgIHBhcmFtW2luXSB2cG9ydCAgLSBWcG9ydCBiZWluZyBjcmVhdGVkLgorICoKKyAqICAgQHJldHVybiBOb25lIChhbHdheXMgc3VjY2VlZHMpCisgKi8KK3ZvaWQKK2JmYV9mY3NfZmFicmljX2FkZHZwb3J0KHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQlzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCkKK3sKKwkvKioKKwkgKiAtIGFkZCB2cG9ydCB0byBmYWJyaWMncyB2cG9ydF9xCisJICovCisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZmFicmljLT52Zl9pZCk7CisKKwlsaXN0X2FkZF90YWlsKCZ2cG9ydC0+cWUsICZmYWJyaWMtPnZwb3J0X3EpOworCWZhYnJpYy0+bnVtX3Zwb3J0cysrOworCWJmYV93Y191cCgmZmFicmljLT53Yyk7Cit9CisKKy8qKgorICogICBBIGNoaWxkIHZwb3J0IGlzIGJlaW5nIGRlbGV0ZWQgZnJvbSBmYWJyaWMuCisgKgorICogICBWcG9ydCBpcyBiZWluZyBkZWxldGVkLgorICovCit2b2lkCitiZmFfZmNzX2ZhYnJpY19kZWx2cG9ydChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpCit7CisJbGlzdF9kZWwoJnZwb3J0LT5xZSk7CisJZmFicmljLT5udW1fdnBvcnRzLS07CisJYmZhX3djX2Rvd24oJmZhYnJpYy0+d2MpOworfQorCisvKioKKyAqICAgQmFzZSBwb3J0IGlzIGRlbGV0ZWQuCisgKi8KK3ZvaWQKK2JmYV9mY3NfZmFicmljX3BvcnRfZGVsZXRlX2NvbXAoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYykKK3sKKwliZmFfd2NfZG93bigmZmFicmljLT53Yyk7Cit9CisKKy8qKgorICogICAgQ2hlY2sgaWYgZmFicmljIGlzIG9ubGluZS4KKyAqCisgKiAgIHBhcmFtW2luXSBmYWJyaWMgLSBGYWJyaWMgaW5zdGFuY2UuIFRoaXMgY2FuIGJlIGEgYmFzZSBmYWJyaWMgb3IgdmYuCisgKgorICogICBAcmV0dXJuICBUUlVFL0ZBTFNFCisgKi8KK2ludAorYmZhX2Zjc19mYWJyaWNfaXNfb25saW5lKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpCit7CisJcmV0dXJuIChiZmFfc21fY21wX3N0YXRlKGZhYnJpYywgYmZhX2Zjc19mYWJyaWNfc21fb25saW5lKSk7Cit9CisKKworYmZhX3N0YXR1c190CitiZmFfZmNzX2ZhYnJpY19hZGR2ZihzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqdmYsIHN0cnVjdCBiZmFfZmNzX3MgKmZjcywKKwkJICAgICBzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgKnBvcnRfY2ZnLAorCQkgICAgIHN0cnVjdCBiZmFkX3ZmX3MgKnZmX2RydikKK3sKKwliZmFfc21fc2V0X3N0YXRlKHZmLCBiZmFfZmNzX2ZhYnJpY19zbV91bmluaXQpOworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqIExvb2t1cCBmb3IgYSB2cG9ydCB3aXRoaW5nIGEgZmFicmljIGdpdmVuIGl0cyBwd3duCisgKi8KK3N0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKgorYmZhX2Zjc19mYWJyaWNfdnBvcnRfbG9va3VwKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsIHd3bl90IHB3d24pCit7CisJc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQ7CisJc3RydWN0IGxpc3RfaGVhZCAqcWU7CisKKwlsaXN0X2Zvcl9lYWNoKHFlLCAmZmFicmljLT52cG9ydF9xKSB7CisJCXZwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKilxZTsKKwkJaWYgKGJmYV9mY3NfcG9ydF9nZXRfcHd3bigmdnBvcnQtPmxwb3J0KSA9PSBwd3duKQorCQkJcmV0dXJuIHZwb3J0OworCX0KKworCXJldHVybiBOVUxMOworfQorCisvKioKKyAqICAgIEluIGEgZ2l2ZW4gZmFicmljLCByZXR1cm4gdGhlIG51bWJlciBvZiBscG9ydHMuCisgKgorICogICBwYXJhbVtpbl0gZmFicmljIC0gRmFicmljIGluc3RhbmNlLiBUaGlzIGNhbiBiZSBhIGJhc2UgZmFicmljIG9yIHZmLgorICoKKyogICAgQHJldHVybiA6IDEgb3IgbW9yZS4KKyAqLwordTE2CitiZmFfZmNzX2ZhYnJpY192cG9ydF9jb3VudChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKQoreworCXJldHVybiAoZmFicmljLT5udW1fdnBvcnRzKTsKK30KKworLyoqCisgKiAJCVVuc29saWNpdGVkIGZyYW1lIHJlY2VpdmUgaGFuZGxpbmcuCisgKi8KK3ZvaWQKK2JmYV9mY3NfZmFicmljX3VmX3JlY3Yoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywgc3RydWN0IGZjaHNfcyAqZmNocywKKwkJICAgICAgIHUxNiBsZW4pCit7CisJdTMyICAgICAgICBwaWQgPSBmY2hzLT5kX2lkOworCXN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0OworCXN0cnVjdCBsaXN0X2hlYWQgKnFlOworCXN0cnVjdCBmY19lbHNfY21kX3MgICAqZWxzX2NtZCA9IChzdHJ1Y3QgZmNfZWxzX2NtZF9zICopIChmY2hzICsgMSk7CisJc3RydWN0IGZjX2xvZ2lfcyAgICAgKmZsb2dpID0gKHN0cnVjdCBmY19sb2dpX3MgKikgZWxzX2NtZDsKKworCWJmYV90cmMoZmFicmljLT5mY3MsIGxlbik7CisJYmZhX3RyYyhmYWJyaWMtPmZjcywgcGlkKTsKKworCS8qKgorCSAqIExvb2sgZm9yIG91ciBvd24gRkxPR0kgZnJhbWVzIGJlaW5nIGxvb3BlZCBiYWNrLiBUaGlzIG1lYW5zIGFuCisJICogZXh0ZXJuYWwgbG9vcGJhY2sgY2FibGUgaXMgaW4gcGxhY2UuIE91ciBvd24gRkxPR0kgZnJhbWVzIGFyZQorCSAqIHNvbWV0aW1lcyBsb29wZWQgYmFjayB3aGVuIHN3aXRjaCBwb3J0IGdldHMgdGVtcG9yYXJpbHkgYnlwYXNzZWQuCisJICovCisJaWYgKChwaWQgPT0gYmZhX29zX250b2gzYihGQ19GQUJSSUNfUE9SVCkpCisJICAgICYmIChlbHNfY21kLT5lbHNfY29kZSA9PSBGQ19FTFNfRkxPR0kpCisJICAgICYmIChmbG9naS0+cG9ydF9uYW1lID09IGJmYV9mY3NfcG9ydF9nZXRfcHd3bigmZmFicmljLT5icG9ydCkpKSB7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGZhYnJpYywgQkZBX0ZDU19GQUJSSUNfU01fTE9PUEJBQ0spOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogRkxPR0kvRVZGUCBleGNoYW5nZXMgc2hvdWxkIGJlIGNvbnN1bWVkIGJ5IGJhc2UgZmFicmljLgorCSAqLworCWlmIChmY2hzLT5kX2lkID09IGJmYV9vc19odG9uM2IoRkNfRkFCUklDX1BPUlQpKSB7CisJCWJmYV90cmMoZmFicmljLT5mY3MsIHBpZCk7CisJCWJmYV9mY3NfZmFicmljX3Byb2Nlc3NfdWYoZmFicmljLCBmY2hzLCBsZW4pOworCQlyZXR1cm47CisJfQorCisJaWYgKGZhYnJpYy0+YnBvcnQucGlkID09IHBpZCkgeworCQkvKioKKwkJICogQWxsIGF1dGhlbnRpY2F0aW9uIGZyYW1lcyBzaG91bGQgYmUgcm91dGVkIHRvIGF1dGgKKwkJICovCisJCWJmYV90cmMoZmFicmljLT5mY3MsIGVsc19jbWQtPmVsc19jb2RlKTsKKwkJaWYgKGVsc19jbWQtPmVsc19jb2RlID09IEZDX0VMU19BVVRIKSB7CisJCQliZmFfdHJjKGZhYnJpYy0+ZmNzLCBlbHNfY21kLT5lbHNfY29kZSk7CisJCQlmYWJyaWMtPmF1dGgucmVzcG9uc2UgPSAodTggKikgZWxzX2NtZDsKKwkJCXJldHVybjsKKwkJfQorCisJCWJmYV90cmMoZmFicmljLT5mY3MsICoodTggKikgKCh1OCAqKSBmY2hzKSk7CisJCWJmYV9mY3NfcG9ydF91Zl9yZWN2KCZmYWJyaWMtPmJwb3J0LCBmY2hzLCBsZW4pOworCQlyZXR1cm47CisJfQorCisJLyoqCisJICogbG9vayBmb3IgYSBtYXRjaGluZyBsb2NhbCBwb3J0IElECisJICovCisJbGlzdF9mb3JfZWFjaChxZSwgJmZhYnJpYy0+dnBvcnRfcSkgeworCQl2cG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICopcWU7CisJCWlmICh2cG9ydC0+bHBvcnQucGlkID09IHBpZCkgeworCQkJYmZhX2Zjc19wb3J0X3VmX3JlY3YoJnZwb3J0LT5scG9ydCwgZmNocywgbGVuKTsKKwkJCXJldHVybjsKKwkJfQorCX0KKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBlbHNfY21kLT5lbHNfY29kZSk7CisJYmZhX2Zjc19wb3J0X3VmX3JlY3YoJmZhYnJpYy0+YnBvcnQsIGZjaHMsIGxlbik7Cit9CisKKy8qKgorICogCQlVbnNvbGljaXRlZCBmcmFtZXMgdG8gYmUgcHJvY2Vzc2VkIGJ5IGZhYnJpYy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX3Byb2Nlc3NfdWYoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywgc3RydWN0IGZjaHNfcyAqZmNocywKKwkJCSAgdTE2IGxlbikKK3sKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgKmVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSAoZmNocyArIDEpOworCisJYmZhX3RyYyhmYWJyaWMtPmZjcywgZWxzX2NtZC0+ZWxzX2NvZGUpOworCisJc3dpdGNoIChlbHNfY21kLT5lbHNfY29kZSkgeworCWNhc2UgRkNfRUxTX0ZMT0dJOgorCQliZmFfZmNzX2ZhYnJpY19wcm9jZXNzX2Zsb2dpKGZhYnJpYywgZmNocywgbGVuKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQkvKgorCQkgKiBuZWVkIHRvIGdlbmVyYXRlIGEgTFNfUkpUCisJCSAqLworCQlicmVhazsKKwl9Cit9CisKKy8qKgorICogCVByb2Nlc3MJaW5jb21pbmcgRkxPR0kKKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfZmFicmljX3Byb2Nlc3NfZmxvZ2koc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCXN0cnVjdCBmY2hzX3MgKmZjaHMsIHUxNiBsZW4pCit7CisJc3RydWN0IGZjX2xvZ2lfcyAgICAgKmZsb2dpID0gKHN0cnVjdCBmY19sb2dpX3MgKikgKGZjaHMgKyAxKTsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmJwb3J0ID0gJmZhYnJpYy0+YnBvcnQ7CisKKwliZmFfdHJjKGZhYnJpYy0+ZmNzLCBmY2hzLT5zX2lkKTsKKworCWZhYnJpYy0+c3RhdHMuZmxvZ2lfcmN2ZCsrOworCS8qCisJICogQ2hlY2sgcG9ydCB0eXBlLiBJdCBzaG91bGQgYmUgMCA9IG4tcG9ydC4KKwkgKi8KKwlpZiAoZmxvZ2ktPmNzcC5wb3J0X3R5cGUpIHsKKwkJLyoKKwkJICogQHRvZG86IG1heSBuZWVkIHRvIHNlbmQgYSBMU19SSlQKKwkJICovCisJCWJmYV90cmMoZmFicmljLT5mY3MsIGZsb2dpLT5wb3J0X25hbWUpOworCQlmYWJyaWMtPnN0YXRzLmZsb2dpX3JlamVjdGVkKys7CisJCXJldHVybjsKKwl9CisKKwlmYWJyaWMtPmJiX2NyZWRpdCA9IGJmYV9vc19udG9ocyhmbG9naS0+Y3NwLmJiY3JlZCk7CisJYnBvcnQtPnBvcnRfdG9wby5wbjJuLnJlbV9wb3J0X3d3biA9IGZsb2dpLT5wb3J0X25hbWU7CisJYnBvcnQtPnBvcnRfdG9wby5wbjJuLnJlcGx5X294aWQgPSBmY2hzLT5veF9pZDsKKworCS8qCisJICogU2VuZCBhIEZsb2dpIEFjYworCSAqLworCWJmYV9mY3NfZmFicmljX3NlbmRfZmxvZ2lfYWNjKGZhYnJpYyk7CisJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9OT19GQUJSSUMpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfc2VuZF9mbG9naV9hY2Moc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYykKK3sKKwlzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgKnBjZmcgPSAmZmFicmljLT5icG9ydC5wb3J0X2NmZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X24ybl9zICpuMm5fcG9ydCA9ICZmYWJyaWMtPmJwb3J0LnBvcnRfdG9wby5wbjJuOworCXN0cnVjdCBiZmFfcyAgICpiZmEgPSBmYWJyaWMtPmZjcy0+YmZhOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCXUxNiAgICAgICAgcmVxbGVuOworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKworCWZjeHAgPSBiZmFfZmNzX2ZjeHBfYWxsb2MoZmFicmljLT5mY3MpOworCS8qKgorCSAqIERvIG5vdCBleHBlY3QgdGhpcyBmYWlsdXJlIC0tIGV4cGVjdCByZW1vdGUgbm9kZSB0byByZXRyeQorCSAqLworCWlmICghZmN4cCkKKwkJcmV0dXJuOworCisJcmVxbGVuID0gZmNfZmxvZ2lfYWNjX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLAorCQkJCSAgICBiZmFfb3NfaHRvbjNiKEZDX0ZBQlJJQ19QT1JUKSwKKwkJCQkgICAgbjJuX3BvcnQtPnJlcGx5X294aWQsIHBjZmctPnB3d24sCisJCQkJICAgIHBjZmctPm53d24sIGJmYV9wcG9ydF9nZXRfbWF4ZnJzaXplKGJmYSksCisJCQkJICAgIGJmYV9wcG9ydF9nZXRfcnhfYmJjcmVkaXQoYmZhKSk7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIGZhYnJpYy0+dmZfaWQsIGJmYV9scHNfZ2V0X3RhZyhmYWJyaWMtPmxwcyksCisJCQlCRkFfRkFMU0UsIEZDX0NMQVNTXzMsIHJlcWxlbiwgJmZjaHMsCisJCQliZmFfZmNzX2ZhYnJpY19mbG9naWFjY19jb21wLCBmYWJyaWMsCisJCQlGQ19NQVhfUERVU1osIDApOyAvKiBUaW1lb3V0IDAgaW5kaWNhdGVzIG5vCisJCQkJCSAgICogcmVzcG9uc2UgZXhwZWN0ZWQKKwkJCQkJICAgKi8KK30KKworLyoqCisgKiAgIEZsb2dpIEFjYyBjb21wbGV0aW9uIGNhbGxiYWNrLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19mYWJyaWNfZmxvZ2lhY2NfY29tcCh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCB2b2lkICpjYmFyZywKKwkJCSAgICAgYmZhX3N0YXR1c190IHN0YXR1cywgdTMyIHJzcF9sZW4sCisJCQkgICAgIHUzMiByZXNpZF9sZW4sIHN0cnVjdCBmY2hzX3MgKnJzcGZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyA9IGNiYXJnOworCisJYmZhX3RyYyhmYWJyaWMtPmZjcywgc3RhdHVzKTsKK30KKworLyoKKyAqCisgKiBAcGFyYW1baW5dIGZhYnJpYyAtIGZhYnJpYworICogQHBhcmFtW2luXSByZXN1bHQgLSAxCisgKgorICogQHJldHVybiAtIG5vbmUKKyAqLwordm9pZAorYmZhX2Zjc19hdXRoX2ZpbmlzaGVkKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsIGVudW0gYXV0aF9zdGF0dXMgc3RhdHVzKQoreworCWJmYV90cmMoZmFicmljLT5mY3MsIHN0YXR1cyk7CisKKwlpZiAoc3RhdHVzID09IEZDX0FVVEhfU1RBVEVfU1VDQ0VTUykKKwkJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9BVVRIX1NVQ0NFU1MpOworCWVsc2UKKwkJYmZhX3NtX3NlbmRfZXZlbnQoZmFicmljLCBCRkFfRkNTX0ZBQlJJQ19TTV9BVVRIX0ZBSUxFRCk7Cit9CisKKy8qKgorICogU2VuZCBBRU4gbm90aWZpY2F0aW9uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX2ZhYnJpY19hZW5fcG9zdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQllbnVtIGJmYV9wb3J0X2Flbl9ldmVudCBldmVudCkKK3sKKwl1bmlvbiBiZmFfYWVuX2RhdGFfdSBhZW5fZGF0YTsKKwlzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbW9kID0gcG9ydC0+ZmNzLT5sb2dtOworCXd3bl90ICAgICAgICAgICBwd3duID0gYmZhX2Zjc19wb3J0X2dldF9wd3duKHBvcnQpOworCXd3bl90ICAgICAgICAgICBmd3duID0gYmZhX2Zjc19wb3J0X2dldF9mYWJyaWNfbmFtZShwb3J0KTsKKwljaGFyICAgICAgICAgICAgcHd3bl9wdHJbQkZBX1NUUklOR18zMl07CisJY2hhciAgICAgICAgICAgIGZ3d25fcHRyW0JGQV9TVFJJTkdfMzJdOworCisJd3duMnN0cihwd3duX3B0ciwgcHd3bik7CisJd3duMnN0cihmd3duX3B0ciwgZnd3bik7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfUE9SVF9BRU5fRkFCUklDX05BTUVfQ0hBTkdFOgorCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9QT1JUX0ZBQlJJQ19OQU1FX0NIQU5HRSwgcHd3bl9wdHIsCisJCQlmd3duX3B0cik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKworCWFlbl9kYXRhLnBvcnQucHd3biA9IHB3d247CisJYWVuX2RhdGEucG9ydC5md3duID0gZnd3bjsKK30KKworLyoKKyAqCisgKiBAcGFyYW1baW5dIGZhYnJpYyAtIGZhYnJpYworICogQHBhcmFtW2luXSB3d25fdCAtIG5ldyBmYWJyaWMgbmFtZQorICoKKyAqIEByZXR1cm4gLSBub25lCisgKi8KK3ZvaWQKK2JmYV9mY3NfZmFicmljX3NldF9mYWJyaWNfbmFtZShzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLAorCQkJICAgICAgIHd3bl90IGZhYnJpY19uYW1lKQoreworCWJmYV90cmMoZmFicmljLT5mY3MsIGZhYnJpY19uYW1lKTsKKworCWlmIChmYWJyaWMtPmZhYnJpY19uYW1lID09IDApIHsKKwkJLyoKKwkJICogV2l0aCBCUkNEIHN3aXRjaGVzLCB3ZSBkb24ndCBnZXQgRmFicmljIE5hbWUgaW4gRkxPR0kuCisJCSAqIERvbid0IGdlbmVyYXRlIGEgZmFicmljIG5hbWUgY2hhbmdlIGV2ZW50IGluIHRoaXMgY2FzZS4KKwkJICovCisJCWZhYnJpYy0+ZmFicmljX25hbWUgPSBmYWJyaWNfbmFtZTsKKwl9IGVsc2UgeworCQlmYWJyaWMtPmZhYnJpY19uYW1lID0gZmFicmljX25hbWU7CisJCS8qCisJCSAqIEdlbmVyYXRlIGEgRXZlbnQKKwkJICovCisJCWJmYV9mY3NfZmFicmljX2Flbl9wb3N0KCZmYWJyaWMtPmJwb3J0LAorCQkJCQlCRkFfUE9SVF9BRU5fRkFCUklDX05BTUVfQ0hBTkdFKTsKKwl9CisKK30KKworLyoqCisgKiBOb3QgdXNlZCBieSBGQ1MuCisgKi8KK3ZvaWQKK2JmYV9jYl9scHNfZmxvZ29fY29tcCh2b2lkICpiZmFkLCB2b2lkICp1YXJnKQoreworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvZmNidWlsZC5jIGIvZHJpdmVycy9zY3NpL2JmYS9mY2J1aWxkLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDE3NDcwNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvZmNidWlsZC5jCkBAIC0wLDAgKzEsMTQ0OSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworLyoKKyAqIGZjYnVpbGQuYyAtIEZDIGxpbmsgc2VydmljZSBmcmFtZSBidWlsZGluZyBhbmQgcGFyc2luZyByb3V0aW5lcworICovCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisjaW5jbHVkZSAiZmNidWlsZC5oIgorCisvKgorICogc3RhdGljIGJ1aWxkIGZ1bmN0aW9ucworICovCitzdGF0aWMgdm9pZCBmY19lbHNfcnNwX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCk7CitzdGF0aWMgdm9pZCBmY19ibHNfcnNwX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCk7CitzdGF0aWMgc3RydWN0IGZjaHNfcyAgIGZjX2Vsc19yZXFfdG1wbDsKK3N0YXRpYyBzdHJ1Y3QgZmNoc19zICAgZmNfZWxzX3JzcF90bXBsOworc3RhdGljIHN0cnVjdCBmY2hzX3MgICBmY19ibHNfcmVxX3RtcGw7CitzdGF0aWMgc3RydWN0IGZjaHNfcyAgIGZjX2Jsc19yc3BfdG1wbDsKK3N0YXRpYyBzdHJ1Y3QgZmNfYmFfYWNjX3MgYmFfYWNjX3RtcGw7CitzdGF0aWMgc3RydWN0IGZjX2xvZ2lfcyBwbG9naV90bXBsOworc3RhdGljIHN0cnVjdCBmY19wcmxpX3MgcHJsaV90bXBsOworc3RhdGljIHN0cnVjdCBmY19ycnFfcyBycnFfdG1wbDsKK3N0YXRpYyBzdHJ1Y3QgZmNoc19zICAgZmNwX2ZjaHNfdG1wbDsKKwordm9pZAorZmNidWlsZF9pbml0KHZvaWQpCit7CisJLyoKKwkgKiBmY19lbHNfcmVxX3RtcGwKKwkgKi8KKwlmY19lbHNfcmVxX3RtcGwucm91dGluZyA9IEZDX1JUR19FWFRfTElOSzsKKwlmY19lbHNfcmVxX3RtcGwuY2F0X2luZm8gPSBGQ19DQVRfTERfUkVRVUVTVDsKKwlmY19lbHNfcmVxX3RtcGwudHlwZSA9IEZDX1RZUEVfRUxTOworCWZjX2Vsc19yZXFfdG1wbC5mX2N0bCA9CisJCWJmYV9vc19odG9uM2IoRkNUTF9TRVFfSU5JIHwgRkNUTF9GU19FWENIIHwgRkNUTF9FTkRfU0VRIHwKKwkJCSAgICAgIEZDVExfU0lfWEZFUik7CisJZmNfZWxzX3JlcV90bXBsLnJ4X2lkID0gRkNfUlhJRF9BTlk7CisKKwkvKgorCSAqIGZjX2Vsc19yc3BfdG1wbAorCSAqLworCWZjX2Vsc19yc3BfdG1wbC5yb3V0aW5nID0gRkNfUlRHX0VYVF9MSU5LOworCWZjX2Vsc19yc3BfdG1wbC5jYXRfaW5mbyA9IEZDX0NBVF9MRF9SRVBMWTsKKwlmY19lbHNfcnNwX3RtcGwudHlwZSA9IEZDX1RZUEVfRUxTOworCWZjX2Vsc19yc3BfdG1wbC5mX2N0bCA9CisJCWJmYV9vc19odG9uM2IoRkNUTF9FQ19SRVNQIHwgRkNUTF9TRVFfSU5JIHwgRkNUTF9MU19FWENIIHwKKwkJCSAgICAgIEZDVExfRU5EX1NFUSB8IEZDVExfU0lfWEZFUik7CisJZmNfZWxzX3JzcF90bXBsLnJ4X2lkID0gRkNfUlhJRF9BTlk7CisKKwkvKgorCSAqIGZjX2Jsc19yZXFfdG1wbAorCSAqLworCWZjX2Jsc19yZXFfdG1wbC5yb3V0aW5nID0gRkNfUlRHX0JBU0lDX0xJTks7CisJZmNfYmxzX3JlcV90bXBsLnR5cGUgPSBGQ19UWVBFX0JMUzsKKwlmY19ibHNfcmVxX3RtcGwuZl9jdGwgPSBiZmFfb3NfaHRvbjNiKEZDVExfRU5EX1NFUSB8IEZDVExfU0lfWEZFUik7CisJZmNfYmxzX3JlcV90bXBsLnJ4X2lkID0gRkNfUlhJRF9BTlk7CisKKwkvKgorCSAqIGZjX2Jsc19yc3BfdG1wbAorCSAqLworCWZjX2Jsc19yc3BfdG1wbC5yb3V0aW5nID0gRkNfUlRHX0JBU0lDX0xJTks7CisJZmNfYmxzX3JzcF90bXBsLmNhdF9pbmZvID0gRkNfQ0FUX0JBX0FDQzsKKwlmY19ibHNfcnNwX3RtcGwudHlwZSA9IEZDX1RZUEVfQkxTOworCWZjX2Jsc19yc3BfdG1wbC5mX2N0bCA9CisJCWJmYV9vc19odG9uM2IoRkNUTF9FQ19SRVNQIHwgRkNUTF9TRVFfSU5JIHwgRkNUTF9MU19FWENIIHwKKwkJCSAgICAgIEZDVExfRU5EX1NFUSB8IEZDVExfU0lfWEZFUik7CisJZmNfYmxzX3JzcF90bXBsLnJ4X2lkID0gRkNfUlhJRF9BTlk7CisKKwkvKgorCSAqIGJhX2FjY190bXBsCisJICovCisJYmFfYWNjX3RtcGwuc2VxX2lkX3ZhbGlkID0gMDsKKwliYV9hY2NfdG1wbC5sb3dfc2VxX2NudCA9IDA7CisJYmFfYWNjX3RtcGwuaGlnaF9zZXFfY250ID0gMHhGRkZGOworCisJLyoKKwkgKiBwbG9naV90bXBsCisJICovCisJcGxvZ2lfdG1wbC5jc3AudmVyaGkgPSBGQ19QSF9WRVJfUEhfMzsKKwlwbG9naV90bXBsLmNzcC52ZXJsbyA9IEZDX1BIX1ZFUl80XzM7CisJcGxvZ2lfdG1wbC5jc3AuYmJjcmVkID0gYmZhX29zX2h0b25zKDB4MDAwNCk7CisJcGxvZ2lfdG1wbC5jc3AuY2lybyA9IDB4MTsKKwlwbG9naV90bXBsLmNzcC5jaXNjID0gMHgwOworCXBsb2dpX3RtcGwuY3NwLmFsdGJiY3JlZCA9IDB4MDsKKwlwbG9naV90bXBsLmNzcC5jb25zZXEgPSBiZmFfb3NfaHRvbnMoMHgwMEZGKTsKKwlwbG9naV90bXBsLmNzcC5yb19iaXRtYXAgPSBiZmFfb3NfaHRvbnMoMHgwMDAyKTsKKwlwbG9naV90bXBsLmNzcC5lX2RfdG92ID0gYmZhX29zX2h0b25sKDIwMDApOworCisJcGxvZ2lfdG1wbC5jbGFzczMuY2xhc3NfdmFsaWQgPSAxOworCXBsb2dpX3RtcGwuY2xhc3MzLnNlcXVlbnRpYWwgPSAxOworCXBsb2dpX3RtcGwuY2xhc3MzLmNvbnNlcSA9IDB4RkY7CisJcGxvZ2lfdG1wbC5jbGFzczMub3NweCA9IDE7CisKKwkvKgorCSAqIHBybGlfdG1wbAorCSAqLworCXBybGlfdG1wbC5jb21tYW5kID0gRkNfRUxTX1BSTEk7CisJcHJsaV90bXBsLnBnbGVuID0gMHgxMDsKKwlwcmxpX3RtcGwucGFnZWJ5dGVzID0gYmZhX29zX2h0b25zKDB4MDAxNCk7CisJcHJsaV90bXBsLnBhcmFtcGFnZS50eXBlID0gRkNfVFlQRV9GQ1A7CisJcHJsaV90bXBsLnBhcmFtcGFnZS5pbWFnZXBhaXIgPSAxOworCXBybGlfdG1wbC5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5yeHJkaXNhYiA9IDE7CisKKwkvKgorCSAqIHJycV90bXBsCisJICovCisJcnJxX3RtcGwuZWxzX2NtZC5lbHNfY29kZSA9IEZDX0VMU19SUlE7CisKKwkvKgorCSAqIGZjcF9mY2hzX3RtcGwKKwkgKi8KKwlmY3BfZmNoc190bXBsLnJvdXRpbmcgPSBGQ19SVEdfRkM0X0RFVl9EQVRBOworCWZjcF9mY2hzX3RtcGwuY2F0X2luZm8gPSBGQ19DQVRfVU5TT0xJQ0lUX0NNRDsKKwlmY3BfZmNoc190bXBsLnR5cGUgPSBGQ19UWVBFX0ZDUDsKKwlmY3BfZmNoc190bXBsLmZfY3RsID0KKwkJYmZhX29zX2h0b24zYihGQ1RMX0ZTX0VYQ0ggfCBGQ1RMX0VORF9TRVEgfCBGQ1RMX1NJX1hGRVIpOworCWZjcF9mY2hzX3RtcGwuc2VxX2lkID0gMTsKKwlmY3BfZmNoc190bXBsLnJ4X2lkID0gRkNfUlhJRF9BTlk7Cit9CisKK3N0YXRpYyB2b2lkCitmY19nc19mY2hkcl9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB1MzIgZF9pZCwgdTMyIHNfaWQsCisJCQl1MzIgb3hfaWQpCit7CisJYmZhX29zX21lbXNldChmY2hzLCAwLCBzaXplb2Yoc3RydWN0IGZjaHNfcykpOworCisJZmNocy0+cm91dGluZyA9IEZDX1JUR19GQzRfREVWX0RBVEE7CisJZmNocy0+Y2F0X2luZm8gPSBGQ19DQVRfVU5TT0xJQ0lUX0NUUkw7CisJZmNocy0+dHlwZSA9IEZDX1RZUEVfU0VSVklDRVM7CisJZmNocy0+Zl9jdGwgPQorCQliZmFfb3NfaHRvbjNiKEZDVExfU0VRX0lOSSB8IEZDVExfRlNfRVhDSCB8IEZDVExfRU5EX1NFUSB8CisJCQkgICAgICBGQ1RMX1NJX1hGRVIpOworCWZjaHMtPnJ4X2lkID0gRkNfUlhJRF9BTlk7CisJZmNocy0+ZF9pZCA9IChkX2lkKTsKKwlmY2hzLT5zX2lkID0gKHNfaWQpOworCWZjaHMtPm94X2lkID0gYmZhX29zX2h0b25zKG94X2lkKTsKKworCS8qKgorCSAqIEB0b2RvIG5vIG5lZWQgdG8gc2V0IG94X2lkIGZvciByZXF1ZXN0CisJICogICAgICAgbm8gbmVlZCB0byBzZXQgcnhfaWQgZm9yIHJlc3BvbnNlCisJICovCit9CisKK3ZvaWQKK2ZjX2Vsc19yZXFfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdTMyIGRfaWQsIHUzMiBzX2lkLAorCQkJdTE2IG94X2lkKQoreworCWJmYV9vc19tZW1jcHkoZmNocywgJmZjX2Vsc19yZXFfdG1wbCwgc2l6ZW9mKHN0cnVjdCBmY2hzX3MpKTsKKwlmY2hzLT5kX2lkID0gKGRfaWQpOworCWZjaHMtPnNfaWQgPSAoc19pZCk7CisJZmNocy0+b3hfaWQgPSBiZmFfb3NfaHRvbnMob3hfaWQpOworfQorCitzdGF0aWMgdm9pZAorZmNfZWxzX3JzcF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB1MzIgZF9pZCwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQpCit7CisJYmZhX29zX21lbWNweShmY2hzLCAmZmNfZWxzX3JzcF90bXBsLCBzaXplb2Yoc3RydWN0IGZjaHNfcykpOworCWZjaHMtPmRfaWQgPSBkX2lkOworCWZjaHMtPnNfaWQgPSBzX2lkOworCWZjaHMtPm94X2lkID0gb3hfaWQ7Cit9CisKK2VudW0gZmNfcGFyc2Vfc3RhdHVzCitmY19lbHNfcnNwX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmZjaHMsIGludCBsZW4pCit7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICplbHNfY21kID0gKHN0cnVjdCBmY19lbHNfY21kX3MgKikgKGZjaHMgKyAxKTsKKwlzdHJ1Y3QgZmNfbHNfcmp0X3MgICAgKmxzX3JqdCA9IChzdHJ1Y3QgZmNfbHNfcmp0X3MgKikgZWxzX2NtZDsKKworCWxlbiA9IGxlbjsKKworCXN3aXRjaCAoZWxzX2NtZC0+ZWxzX2NvZGUpIHsKKwljYXNlIEZDX0VMU19MU19SSlQ6CisJCWlmIChsc19yanQtPnJlYXNvbl9jb2RlID09IEZDX0xTX1JKVF9SU05fTE9HSUNBTF9CVVNZKQorCQkJcmV0dXJuIChGQ19QQVJTRV9CVVNZKTsKKwkJZWxzZQorCQkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKworCWNhc2UgRkNfRUxTX0FDQzoKKwkJcmV0dXJuIChGQ19QQVJTRV9PSyk7CisJfQorCXJldHVybiAoRkNfUEFSU0VfT0spOworfQorCitzdGF0aWMgdm9pZAorZmNfYmxzX3JzcF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB1MzIgZF9pZCwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQpCit7CisJYmZhX29zX21lbWNweShmY2hzLCAmZmNfYmxzX3JzcF90bXBsLCBzaXplb2Yoc3RydWN0IGZjaHNfcykpOworCWZjaHMtPmRfaWQgPSBkX2lkOworCWZjaHMtPnNfaWQgPSBzX2lkOworCWZjaHMtPm94X2lkID0gb3hfaWQ7Cit9CisKK3N0YXRpYyAgICAgICAgICB1MTYKK2ZjX3Bsb2dpX3hfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcGxkLCB1MzIgZF9pZCwgdTMyIHNfaWQsCisJCSB1MTYgb3hfaWQsIHd3bl90IHBvcnRfbmFtZSwgd3duX3Qgbm9kZV9uYW1lLAorCQkgdTE2IHBkdV9zaXplLCB1OCBlbHNfY29kZSkKK3sKKwlzdHJ1Y3QgZmNfbG9naV9zICAgICAqcGxvZ2kgPSAoc3RydWN0IGZjX2xvZ2lfcyAqKSAocGxkKTsKKworCWJmYV9vc19tZW1jcHkocGxvZ2ksICZwbG9naV90bXBsLCBzaXplb2Yoc3RydWN0IGZjX2xvZ2lfcykpOworCisJcGxvZ2ktPmVsc19jbWQuZWxzX2NvZGUgPSBlbHNfY29kZTsKKwlpZiAoZWxzX2NvZGUgPT0gRkNfRUxTX1BMT0dJKQorCQlmY19lbHNfcmVxX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKwllbHNlCisJCWZjX2Vsc19yc3BfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCisJcGxvZ2ktPmNzcC5yeHN6ID0gcGxvZ2ktPmNsYXNzMy5yeHN6ID0gYmZhX29zX2h0b25zKHBkdV9zaXplKTsKKworCWJmYV9vc19tZW1jcHkoJnBsb2dpLT5wb3J0X25hbWUsICZwb3J0X25hbWUsIHNpemVvZih3d25fdCkpOworCWJmYV9vc19tZW1jcHkoJnBsb2dpLT5ub2RlX25hbWUsICZub2RlX25hbWUsIHNpemVvZih3d25fdCkpOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjX2xvZ2lfcykpOworfQorCit1MTYKK2ZjX2Zsb2dpX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19sb2dpX3MgKmZsb2dpLCB1MzIgc19pZCwKKwkJdTE2IG94X2lkLCB3d25fdCBwb3J0X25hbWUsIHd3bl90IG5vZGVfbmFtZSwKKwkJdTE2IHBkdV9zaXplLCB1OCBzZXRfbnBpdiwgdTggc2V0X2F1dGgsCisJCXUxNiBsb2NhbF9iYl9jcmVkaXRzKQoreworCXUzMiAgICAgICAgZF9pZCA9IGJmYV9vc19odG9uM2IoRkNfRkFCUklDX1BPUlQpOworCXUzMiAJKnZ2bF9pbmZvOworCisJYmZhX29zX21lbWNweShmbG9naSwgJnBsb2dpX3RtcGwsIHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSk7CisKKwlmbG9naS0+ZWxzX2NtZC5lbHNfY29kZSA9IEZDX0VMU19GTE9HSTsKKwlmY19lbHNfcmVxX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKworCWZsb2dpLT5jc3AucnhzeiA9IGZsb2dpLT5jbGFzczMucnhzeiA9IGJmYV9vc19odG9ucyhwZHVfc2l6ZSk7CisJZmxvZ2ktPnBvcnRfbmFtZSA9IHBvcnRfbmFtZTsKKwlmbG9naS0+bm9kZV9uYW1lID0gbm9kZV9uYW1lOworCisJLyoKKwkgKiBTZXQgdGhlIE5QSVYgQ2FwYWJpbGl0eSBCaXQgKCB3b3JkIDEsIGJpdCAzMSkgb2YgQ29tbW9uCisJICogU2VydmljZSBQYXJhbWV0ZXJzLgorCSAqLworCWZsb2dpLT5jc3AuY2lybyA9IHNldF9ucGl2OworCisJLyogc2V0IEFVVEggY2FwYWJpbGl0eSAqLworCWZsb2dpLT5jc3Auc2VjdXJpdHkgPSBzZXRfYXV0aDsKKworCWZsb2dpLT5jc3AuYmJjcmVkID0gYmZhX29zX2h0b25zKGxvY2FsX2JiX2NyZWRpdHMpOworCisJLyogU2V0IGJyY2QgdG9rZW4gaW4gVlZMICovCisJdnZsX2luZm8gPSAodTMyICopJmZsb2dpLT52dmxbMF07CisKKwkvKiBzZXQgdGhlIGZsYWcgdG8gaW5kaWNhdGUgdGhlIHByZXNlbmNlIG9mIFZWTCAqLworCWZsb2dpLT5jc3AubnBpdl9zdXBwICAgID0gMTsgLyogQHRvZG8uIGZpZWxkIG5hbWUgaXMgbm90IGNvcnJlY3QgKi8KKwl2dmxfaW5mb1swXQk9IGJmYV9vc19odG9ubChGTE9HSV9WVkxfQlJDRCk7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSk7Cit9CisKK3UxNgorZmNfZmxvZ2lfYWNjX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19sb2dpX3MgKmZsb2dpLCB1MzIgc19pZCwKKwkJICAgdTE2IG94X2lkLCB3d25fdCBwb3J0X25hbWUsIHd3bl90IG5vZGVfbmFtZSwKKwkJICAgdTE2IHBkdV9zaXplLCB1MTYgbG9jYWxfYmJfY3JlZGl0cykKK3sKKwl1MzIgICAgICAgIGRfaWQgPSAwOworCisJYmZhX29zX21lbWNweShmbG9naSwgJnBsb2dpX3RtcGwsIHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSk7CisJZmNfZWxzX3JzcF9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisKKwlmbG9naS0+ZWxzX2NtZC5lbHNfY29kZSA9IEZDX0VMU19BQ0M7CisJZmxvZ2ktPmNzcC5yeHN6ID0gZmxvZ2ktPmNsYXNzMy5yeHN6ID0gYmZhX29zX2h0b25zKHBkdV9zaXplKTsKKwlmbG9naS0+cG9ydF9uYW1lID0gcG9ydF9uYW1lOworCWZsb2dpLT5ub2RlX25hbWUgPSBub2RlX25hbWU7CisKKwlmbG9naS0+Y3NwLmJiY3JlZCA9IGJmYV9vc19odG9ucyhsb2NhbF9iYl9jcmVkaXRzKTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19sb2dpX3MpKTsKK30KKwordTE2CitmY19mZGlzY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfbG9naV9zICpmbG9naSwgdTMyIHNfaWQsCisJCXUxNiBveF9pZCwgd3duX3QgcG9ydF9uYW1lLCB3d25fdCBub2RlX25hbWUsCisJCXUxNiBwZHVfc2l6ZSkKK3sKKwl1MzIgICAgICAgIGRfaWQgPSBiZmFfb3NfaHRvbjNiKEZDX0ZBQlJJQ19QT1JUKTsKKworCWJmYV9vc19tZW1jcHkoZmxvZ2ksICZwbG9naV90bXBsLCBzaXplb2Yoc3RydWN0IGZjX2xvZ2lfcykpOworCisJZmxvZ2ktPmVsc19jbWQuZWxzX2NvZGUgPSBGQ19FTFNfRkRJU0M7CisJZmNfZWxzX3JlcV9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisKKwlmbG9naS0+Y3NwLnJ4c3ogPSBmbG9naS0+Y2xhc3MzLnJ4c3ogPSBiZmFfb3NfaHRvbnMocGR1X3NpemUpOworCWZsb2dpLT5wb3J0X25hbWUgPSBwb3J0X25hbWU7CisJZmxvZ2ktPm5vZGVfbmFtZSA9IG5vZGVfbmFtZTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19sb2dpX3MpKTsKK30KKwordTE2CitmY19wbG9naV9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkgICAgICAgdTE2IG94X2lkLCB3d25fdCBwb3J0X25hbWUsIHd3bl90IG5vZGVfbmFtZSwKKwkgICAgICAgdTE2IHBkdV9zaXplKQoreworCXJldHVybiBmY19wbG9naV94X2J1aWxkKGZjaHMsIHBsZCwgZF9pZCwgc19pZCwgb3hfaWQsIHBvcnRfbmFtZSwKKwkJCQlub2RlX25hbWUsIHBkdV9zaXplLCBGQ19FTFNfUExPR0kpOworfQorCit1MTYKK2ZjX3Bsb2dpX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJICAgdTE2IG94X2lkLCB3d25fdCBwb3J0X25hbWUsIHd3bl90IG5vZGVfbmFtZSwKKwkJICAgdTE2IHBkdV9zaXplKQoreworCXJldHVybiBmY19wbG9naV94X2J1aWxkKGZjaHMsIHBsZCwgZF9pZCwgc19pZCwgb3hfaWQsIHBvcnRfbmFtZSwKKwkJCQlub2RlX25hbWUsIHBkdV9zaXplLCBGQ19FTFNfQUNDKTsKK30KKworZW51bSBmY19wYXJzZV9zdGF0dXMKK2ZjX3Bsb2dpX3JzcF9wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCBpbnQgbGVuLCB3d25fdCBwb3J0X25hbWUpCit7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICplbHNfY21kID0gKHN0cnVjdCBmY19lbHNfY21kX3MgKikgKGZjaHMgKyAxKTsKKwlzdHJ1Y3QgZmNfbG9naV9zICAgICAqcGxvZ2k7CisJc3RydWN0IGZjX2xzX3JqdF9zICAgICpsc19yanQ7CisKKwlzd2l0Y2ggKGVsc19jbWQtPmVsc19jb2RlKSB7CisJY2FzZSBGQ19FTFNfTFNfUkpUOgorCQlsc19yanQgPSAoc3RydWN0IGZjX2xzX3JqdF9zICopIChmY2hzICsgMSk7CisJCWlmIChsc19yanQtPnJlYXNvbl9jb2RlID09IEZDX0xTX1JKVF9SU05fTE9HSUNBTF9CVVNZKQorCQkJcmV0dXJuIChGQ19QQVJTRV9CVVNZKTsKKwkJZWxzZQorCQkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKwljYXNlIEZDX0VMU19BQ0M6CisJCXBsb2dpID0gKHN0cnVjdCBmY19sb2dpX3MgKikgKGZjaHMgKyAxKTsKKwkJaWYgKGxlbiA8IHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSkKKwkJCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7CisKKwkJaWYgKCF3d25faXNfZXF1YWwocGxvZ2ktPnBvcnRfbmFtZSwgcG9ydF9uYW1lKSkKKwkJCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7CisKKwkJaWYgKCFwbG9naS0+Y2xhc3MzLmNsYXNzX3ZhbGlkKQorCQkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKworCQlpZiAoYmZhX29zX250b2hzKHBsb2dpLT5jbGFzczMucnhzeikgPCAoRkNfTUlOX1BEVVNaKSkKKwkJCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7CisKKwkJcmV0dXJuIChGQ19QQVJTRV9PSyk7CisJZGVmYXVsdDoKKwkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKwl9Cit9CisKK2VudW0gZmNfcGFyc2Vfc3RhdHVzCitmY19wbG9naV9wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzKQoreworCXN0cnVjdCBmY19sb2dpX3MgICAgICpwbG9naSA9IChzdHJ1Y3QgZmNfbG9naV9zICopIChmY2hzICsgMSk7CisKKwlpZiAocGxvZ2ktPmNsYXNzMy5jbGFzc192YWxpZCAhPSAxKQorCQlyZXR1cm4gRkNfUEFSU0VfRkFJTFVSRTsKKworCWlmICgoYmZhX29zX250b2hzKHBsb2dpLT5jbGFzczMucnhzeikgPCBGQ19NSU5fUERVU1opCisJICAgIHx8IChiZmFfb3NfbnRvaHMocGxvZ2ktPmNsYXNzMy5yeHN6KSA+IEZDX01BWF9QRFVTWikKKwkgICAgfHwgKHBsb2dpLT5jbGFzczMucnhzeiA9PSAwKSkKKwkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKworCXJldHVybiBGQ19QQVJTRV9PSzsKK30KKwordTE2CitmY19wcmxpX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnBsZCwgdTMyIGRfaWQsIHUzMiBzX2lkLAorCSAgICAgIHUxNiBveF9pZCkKK3sKKwlzdHJ1Y3QgZmNfcHJsaV9zICAgICAgKnBybGkgPSAoc3RydWN0IGZjX3BybGlfcyAqKSAocGxkKTsKKworCWZjX2Vsc19yZXFfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCWJmYV9vc19tZW1jcHkocHJsaSwgJnBybGlfdG1wbCwgc2l6ZW9mKHN0cnVjdCBmY19wcmxpX3MpKTsKKworCXBybGktPmNvbW1hbmQgPSBGQ19FTFNfUFJMSTsKKwlwcmxpLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5pbml0aWF0b3IgICAgID0gMTsKKwlwcmxpLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5yZXRyeSAgICAgICAgID0gMTsKKwlwcmxpLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5yZWNfc3VwcG9ydCAgID0gMTsKKwlwcmxpLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy50YXNrX3JldHJ5X2lkID0gMDsKKwlwcmxpLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5jb25maXJtICAgICAgID0gMTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19wcmxpX3MpKTsKK30KKwordTE2CitmY19wcmxpX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJICB1MTYgb3hfaWQsIGVudW0gYmZhX3BvcnRfcm9sZSByb2xlKQoreworCXN0cnVjdCBmY19wcmxpX3MgICAgICAqcHJsaSA9IChzdHJ1Y3QgZmNfcHJsaV9zICopIChwbGQpOworCisJZmNfZWxzX3JzcF9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisJYmZhX29zX21lbWNweShwcmxpLCAmcHJsaV90bXBsLCBzaXplb2Yoc3RydWN0IGZjX3BybGlfcykpOworCisJcHJsaS0+Y29tbWFuZCA9IEZDX0VMU19BQ0M7CisKKwlpZiAoKHJvbGUgJiBCRkFfUE9SVF9ST0xFX0ZDUF9UTSkgPT0gQkZBX1BPUlRfUk9MRV9GQ1BfVE0pCisJCXBybGktPnBhcmFtcGFnZS5zZXJ2cGFyYW1zLnRhcmdldCA9IDE7CisJZWxzZQorCQlwcmxpLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5pbml0aWF0b3IgPSAxOworCisJcHJsaS0+cGFyYW1wYWdlLnJzcGNvZGUgPSBGQ19QUkxJX0FDQ19YUVREOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjX3BybGlfcykpOworfQorCitlbnVtIGZjX3BhcnNlX3N0YXR1cworZmNfcHJsaV9yc3BfcGFyc2Uoc3RydWN0IGZjX3BybGlfcyAqcHJsaSwgaW50IGxlbikKK3sKKwlpZiAobGVuIDwgc2l6ZW9mKHN0cnVjdCBmY19wcmxpX3MpKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJaWYgKHBybGktPmNvbW1hbmQgIT0gRkNfRUxTX0FDQykKKwkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKworCWlmICgocHJsaS0+cGFyYW1wYWdlLnJzcGNvZGUgIT0gRkNfUFJMSV9BQ0NfWFFURCkKKwkgICAgJiYgKHBybGktPnBhcmFtcGFnZS5yc3Bjb2RlICE9IEZDX1BSTElfQUNDX1BSRURFRl9JTUcpKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJaWYgKHBybGktPnBhcmFtcGFnZS5zZXJ2cGFyYW1zLnRhcmdldCAhPSAxKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJcmV0dXJuIChGQ19QQVJTRV9PSyk7Cit9CisKK2VudW0gZmNfcGFyc2Vfc3RhdHVzCitmY19wcmxpX3BhcnNlKHN0cnVjdCBmY19wcmxpX3MgKnBybGkpCit7CisJaWYgKHBybGktPnBhcmFtcGFnZS50eXBlICE9IEZDX1RZUEVfRkNQKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJaWYgKCFwcmxpLT5wYXJhbXBhZ2UuaW1hZ2VwYWlyKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJaWYgKCFwcmxpLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5pbml0aWF0b3IpCisJCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7CisKKwlyZXR1cm4gKEZDX1BBUlNFX09LKTsKK30KKwordTE2CitmY19sb2dvX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19sb2dvX3MgKmxvZ28sIHUzMiBkX2lkLAorCQkJdTMyIHNfaWQsIHUxNiBveF9pZCwgd3duX3QgcG9ydF9uYW1lKQoreworCWZjX2Vsc19yZXFfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCisJbWVtc2V0KGxvZ28sICdcMCcsIHNpemVvZihzdHJ1Y3QgZmNfbG9nb19zKSk7CisJbG9nby0+ZWxzX2NtZC5lbHNfY29kZSA9IEZDX0VMU19MT0dPOworCWxvZ28tPm5wb3J0X2lkID0gKHNfaWQpOworCWxvZ28tPm9yaWdfcG9ydF9uYW1lID0gcG9ydF9uYW1lOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjX2xvZ29fcykpOworfQorCitzdGF0aWMgICAgICAgICAgdTE2CitmY19hZGlzY194X2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19hZGlzY19zICphZGlzYywgdTMyIGRfaWQsCisJCSB1MzIgc19pZCwgdTE2IG94X2lkLCB3d25fdCBwb3J0X25hbWUsCisJCSB3d25fdCBub2RlX25hbWUsIHU4IGVsc19jb2RlKQoreworCW1lbXNldChhZGlzYywgJ1wwJywgc2l6ZW9mKHN0cnVjdCBmY19hZGlzY19zKSk7CisKKwlhZGlzYy0+ZWxzX2NtZC5lbHNfY29kZSA9IGVsc19jb2RlOworCisJaWYgKGVsc19jb2RlID09IEZDX0VMU19BRElTQykKKwkJZmNfZWxzX3JlcV9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisJZWxzZQorCQlmY19lbHNfcnNwX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKworCWFkaXNjLT5vcmlnX0hBID0gMDsKKwlhZGlzYy0+b3JpZ19wb3J0X25hbWUgPSBwb3J0X25hbWU7CisJYWRpc2MtPm9yaWdfbm9kZV9uYW1lID0gbm9kZV9uYW1lOworCWFkaXNjLT5ucG9ydF9pZCA9IChzX2lkKTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19hZGlzY19zKSk7Cit9CisKK3UxNgorZmNfYWRpc2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX2FkaXNjX3MgKmFkaXNjLCB1MzIgZF9pZCwKKwkJdTMyIHNfaWQsIHUxNiBveF9pZCwgd3duX3QgcG9ydF9uYW1lLAorCQl3d25fdCBub2RlX25hbWUpCit7CisJcmV0dXJuIGZjX2FkaXNjX3hfYnVpbGQoZmNocywgYWRpc2MsIGRfaWQsIHNfaWQsIG94X2lkLCBwb3J0X25hbWUsCisJCQkJbm9kZV9uYW1lLCBGQ19FTFNfQURJU0MpOworfQorCit1MTYKK2ZjX2FkaXNjX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfYWRpc2NfcyAqYWRpc2MsIHUzMiBkX2lkLAorCQkgICB1MzIgc19pZCwgdTE2IG94X2lkLCB3d25fdCBwb3J0X25hbWUsCisJCSAgIHd3bl90IG5vZGVfbmFtZSkKK3sKKwlyZXR1cm4gZmNfYWRpc2NfeF9idWlsZChmY2hzLCBhZGlzYywgZF9pZCwgc19pZCwgb3hfaWQsIHBvcnRfbmFtZSwKKwkJCQlub2RlX25hbWUsIEZDX0VMU19BQ0MpOworfQorCitlbnVtIGZjX3BhcnNlX3N0YXR1cworZmNfYWRpc2NfcnNwX3BhcnNlKHN0cnVjdCBmY19hZGlzY19zICphZGlzYywgaW50IGxlbiwgd3duX3QgcG9ydF9uYW1lLAorCQkJCSB3d25fdCBub2RlX25hbWUpCit7CisKKwlpZiAobGVuIDwgc2l6ZW9mKHN0cnVjdCBmY19hZGlzY19zKSkKKwkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKworCWlmIChhZGlzYy0+ZWxzX2NtZC5lbHNfY29kZSAhPSBGQ19FTFNfQUNDKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJaWYgKCF3d25faXNfZXF1YWwoYWRpc2MtPm9yaWdfcG9ydF9uYW1lLCBwb3J0X25hbWUpKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJcmV0dXJuIChGQ19QQVJTRV9PSyk7Cit9CisKK2VudW0gZmNfcGFyc2Vfc3RhdHVzCitmY19hZGlzY19wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBob3N0X2RhcCwKKwkJIHd3bl90IG5vZGVfbmFtZSwgd3duX3QgcG9ydF9uYW1lKQoreworCXN0cnVjdCBmY19hZGlzY19zICAgICAqYWRpc2MgPSAoc3RydWN0IGZjX2FkaXNjX3MgKikgcGxkOworCisJaWYgKGFkaXNjLT5lbHNfY21kLmVsc19jb2RlICE9IEZDX0VMU19BQ0MpCisJCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7CisKKwlpZiAoKGFkaXNjLT5ucG9ydF9pZCA9PSAoaG9zdF9kYXApKQorCSAgICAmJiB3d25faXNfZXF1YWwoYWRpc2MtPm9yaWdfcG9ydF9uYW1lLCBwb3J0X25hbWUpCisJICAgICYmIHd3bl9pc19lcXVhbChhZGlzYy0+b3JpZ19ub2RlX25hbWUsIG5vZGVfbmFtZSkpCisJCXJldHVybiAoRkNfUEFSU0VfT0spOworCisJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKK30KKworZW51bSBmY19wYXJzZV9zdGF0dXMKK2ZjX3BkaXNjX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHd3bl90IG5vZGVfbmFtZSwgd3duX3QgcG9ydF9uYW1lKQoreworCXN0cnVjdCBmY19sb2dpX3MgICAgICpwZGlzYyA9IChzdHJ1Y3QgZmNfbG9naV9zICopIChmY2hzICsgMSk7CisKKwlpZiAocGRpc2MtPmNsYXNzMy5jbGFzc192YWxpZCAhPSAxKQorCQlyZXR1cm4gRkNfUEFSU0VfRkFJTFVSRTsKKworCWlmICgoYmZhX29zX250b2hzKHBkaXNjLT5jbGFzczMucnhzeikgPAorCQkgKEZDX01JTl9QRFVTWiAtIHNpemVvZihzdHJ1Y3QgZmNoc19zKSkpCisJICAgIHx8IChwZGlzYy0+Y2xhc3MzLnJ4c3ogPT0gMCkpCisJCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7CisKKwlpZiAoIXd3bl9pc19lcXVhbChwZGlzYy0+cG9ydF9uYW1lLCBwb3J0X25hbWUpKQorCQlyZXR1cm4gKEZDX1BBUlNFX0ZBSUxVUkUpOworCisJaWYgKCF3d25faXNfZXF1YWwocGRpc2MtPm5vZGVfbmFtZSwgbm9kZV9uYW1lKSkKKwkJcmV0dXJuIChGQ19QQVJTRV9GQUlMVVJFKTsKKworCXJldHVybiBGQ19QQVJTRV9PSzsKK30KKwordTE2CitmY19hYnRzX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkKQoreworCWJmYV9vc19tZW1jcHkoZmNocywgJmZjX2Jsc19yZXFfdG1wbCwgc2l6ZW9mKHN0cnVjdCBmY2hzX3MpKTsKKwlmY2hzLT5jYXRfaW5mbyA9IEZDX0NBVF9BQlRTOworCWZjaHMtPmRfaWQgPSAoZF9pZCk7CisJZmNocy0+c19pZCA9IChzX2lkKTsKKwlmY2hzLT5veF9pZCA9IGJmYV9vc19odG9ucyhveF9pZCk7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNoc19zKSk7Cit9CisKK2VudW0gZmNfcGFyc2Vfc3RhdHVzCitmY19hYnRzX3JzcF9wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCBpbnQgbGVuKQoreworCWlmICgoZmNocy0+Y2F0X2luZm8gPT0gRkNfQ0FUX0JBX0FDQykKKwkgICAgfHwgKGZjaHMtPmNhdF9pbmZvID09IEZDX0NBVF9CQV9SSlQpKQorCQlyZXR1cm4gKEZDX1BBUlNFX09LKTsKKworCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7Cit9CisKK3UxNgorZmNfcnJxX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19ycnFfcyAqcnJxLCB1MzIgZF9pZCwKKwkJCSB1MzIgc19pZCwgdTE2IG94X2lkLCB1MTYgcnJxX294aWQpCit7CisJZmNfZWxzX3JlcV9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisKKwkvKgorCSAqIGJ1aWxkIHJycSBwYXlsb2FkCisJICovCisJYmZhX29zX21lbWNweShycnEsICZycnFfdG1wbCwgc2l6ZW9mKHN0cnVjdCBmY19ycnFfcykpOworCXJycS0+c19pZCA9IChzX2lkKTsKKwlycnEtPm94X2lkID0gYmZhX29zX2h0b25zKHJycV9veGlkKTsKKwlycnEtPnJ4X2lkID0gRkNfUlhJRF9BTlk7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfcnJxX3MpKTsKK30KKwordTE2CitmY19sb2dvX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJICB1MTYgb3hfaWQpCit7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICphY2MgPSBwbGQ7CisKKwlmY19lbHNfcnNwX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKworCW1lbXNldChhY2MsIDAsIHNpemVvZihzdHJ1Y3QgZmNfZWxzX2NtZF9zKSk7CisJYWNjLT5lbHNfY29kZSA9IEZDX0VMU19BQ0M7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfZWxzX2NtZF9zKSk7Cit9CisKK3UxNgorZmNfbHNfcmp0X2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19sc19yanRfcyAqbHNfcmp0LCB1MzIgZF9pZCwKKwkJdTMyIHNfaWQsIHUxNiBveF9pZCwgdTggcmVhc29uX2NvZGUsCisJCXU4IHJlYXNvbl9jb2RlX2V4cGwpCit7CisJZmNfZWxzX3JzcF9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisJbWVtc2V0KGxzX3JqdCwgMCwgc2l6ZW9mKHN0cnVjdCBmY19sc19yanRfcykpOworCisJbHNfcmp0LT5lbHNfY21kLmVsc19jb2RlID0gRkNfRUxTX0xTX1JKVDsKKwlsc19yanQtPnJlYXNvbl9jb2RlID0gcmVhc29uX2NvZGU7CisJbHNfcmp0LT5yZWFzb25fY29kZV9leHBsID0gcmVhc29uX2NvZGVfZXhwbDsKKwlsc19yanQtPnZlbmRvcl91bmlxdWUgPSAweDAwOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjX2xzX3JqdF9zKSk7Cit9CisKK3UxNgorZmNfYmFfYWNjX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19iYV9hY2NfcyAqYmFfYWNjLCB1MzIgZF9pZCwKKwkJdTMyIHNfaWQsIHUxNiBveF9pZCwgdTE2IHJ4X2lkKQoreworCWZjX2Jsc19yc3BfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCisJYmZhX29zX21lbWNweShiYV9hY2MsICZiYV9hY2NfdG1wbCwgc2l6ZW9mKHN0cnVjdCBmY19iYV9hY2NfcykpOworCisJZmNocy0+cnhfaWQgPSByeF9pZDsKKworCWJhX2FjYy0+b3hfaWQgPSBmY2hzLT5veF9pZDsKKwliYV9hY2MtPnJ4X2lkID0gZmNocy0+cnhfaWQ7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfYmFfYWNjX3MpKTsKK30KKwordTE2CitmY19sc19hY2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX2Vsc19jbWRfcyAqZWxzX2NtZCwKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkKQoreworCWZjX2Vsc19yc3BfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCW1lbXNldChlbHNfY21kLCAwLCBzaXplb2Yoc3RydWN0IGZjX2Vsc19jbWRfcykpOworCWVsc19jbWQtPmVsc19jb2RlID0gRkNfRUxTX0FDQzsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19lbHNfY21kX3MpKTsKK30KKworaW50CitmY19sb2dvdXRfcGFyYW1zX3BhZ2VzKHN0cnVjdCBmY2hzX3MgKmZjX2ZyYW1lLCB1OCBlbHNfY29kZSkKK3sKKwlpbnQgICAgICAgICAgICAgbnVtX3BhZ2VzID0gMDsKKwlzdHJ1Y3QgZmNfcHJsb19zICAgICAgKnBybG87CisJc3RydWN0IGZjX3RwcmxvX3MgICAgICp0cHJsbzsKKworCWlmIChlbHNfY29kZSA9PSBGQ19FTFNfUFJMTykgeworCQlwcmxvID0gKHN0cnVjdCBmY19wcmxvX3MgKikgKGZjX2ZyYW1lICsgMSk7CisJCW51bV9wYWdlcyA9IChiZmFfb3NfbnRvaHMocHJsby0+cGF5bG9hZF9sZW4pIC0gNCkgLyAxNjsKKwl9IGVsc2UgeworCQl0cHJsbyA9IChzdHJ1Y3QgZmNfdHBybG9fcyAqKSAoZmNfZnJhbWUgKyAxKTsKKwkJbnVtX3BhZ2VzID0gKGJmYV9vc19udG9ocyh0cHJsby0+cGF5bG9hZF9sZW4pIC0gNCkgLyAxNjsKKwl9CisJcmV0dXJuIG51bV9wYWdlczsKK30KKwordTE2CitmY190cHJsb19hY2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX3RwcmxvX2FjY19zICp0cHJsb19hY2MsCisJCQl1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCWludCBudW1fcGFnZXMpCit7CisJaW50ICAgICAgICAgICAgIHBhZ2U7CisKKwlmY19lbHNfcnNwX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKworCW1lbXNldCh0cHJsb19hY2MsIDAsIChudW1fcGFnZXMgKiAxNikgKyA0KTsKKwl0cHJsb19hY2MtPmNvbW1hbmQgPSBGQ19FTFNfQUNDOworCisJdHBybG9fYWNjLT5wYWdlX2xlbiA9IDB4MTA7CisJdHBybG9fYWNjLT5wYXlsb2FkX2xlbiA9IGJmYV9vc19odG9ucygobnVtX3BhZ2VzICogMTYpICsgNCk7CisKKwlmb3IgKHBhZ2UgPSAwOyBwYWdlIDwgbnVtX3BhZ2VzOyBwYWdlKyspIHsKKwkJdHBybG9fYWNjLT50cHJsb19hY2NfcGFyYW1zW3BhZ2VdLm9wYV92YWxpZCA9IDA7CisJCXRwcmxvX2FjYy0+dHBybG9fYWNjX3BhcmFtc1twYWdlXS5ycGFfdmFsaWQgPSAwOworCQl0cHJsb19hY2MtPnRwcmxvX2FjY19wYXJhbXNbcGFnZV0uZmM0dHlwZV9jc3AgPSBGQ19UWVBFX0ZDUDsKKwkJdHBybG9fYWNjLT50cHJsb19hY2NfcGFyYW1zW3BhZ2VdLm9yaWdfcHJvY2Vzc19hc3NjID0gMDsKKwkJdHBybG9fYWNjLT50cHJsb19hY2NfcGFyYW1zW3BhZ2VdLnJlc3BfcHJvY2Vzc19hc3NjID0gMDsKKwl9CisJcmV0dXJuIChiZmFfb3NfbnRvaHModHBybG9fYWNjLT5wYXlsb2FkX2xlbikpOworfQorCit1MTYKK2ZjX3BybG9fYWNjX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHN0cnVjdCBmY19wcmxvX2FjY19zICpwcmxvX2FjYywKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkLAorCQkJaW50IG51bV9wYWdlcykKK3sKKwlpbnQgICAgICAgICAgICAgcGFnZTsKKworCWZjX2Vsc19yc3BfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCisJbWVtc2V0KHBybG9fYWNjLCAwLCAobnVtX3BhZ2VzICogMTYpICsgNCk7CisJcHJsb19hY2MtPmNvbW1hbmQgPSBGQ19FTFNfQUNDOworCXBybG9fYWNjLT5wYWdlX2xlbiA9IDB4MTA7CisJcHJsb19hY2MtPnBheWxvYWRfbGVuID0gYmZhX29zX2h0b25zKChudW1fcGFnZXMgKiAxNikgKyA0KTsKKworCWZvciAocGFnZSA9IDA7IHBhZ2UgPCBudW1fcGFnZXM7IHBhZ2UrKykgeworCQlwcmxvX2FjYy0+cHJsb19hY2NfcGFyYW1zW3BhZ2VdLm9wYV92YWxpZCA9IDA7CisJCXBybG9fYWNjLT5wcmxvX2FjY19wYXJhbXNbcGFnZV0ucnBhX3ZhbGlkID0gMDsKKwkJcHJsb19hY2MtPnBybG9fYWNjX3BhcmFtc1twYWdlXS5mYzR0eXBlX2NzcCA9IEZDX1RZUEVfRkNQOworCQlwcmxvX2FjYy0+cHJsb19hY2NfcGFyYW1zW3BhZ2VdLm9yaWdfcHJvY2Vzc19hc3NjID0gMDsKKwkJcHJsb19hY2MtPnBybG9fYWNjX3BhcmFtc1twYWdlXS5yZXNwX3Byb2Nlc3NfYXNzYyA9IDA7CisJfQorCisJcmV0dXJuIChiZmFfb3NfbnRvaHMocHJsb19hY2MtPnBheWxvYWRfbGVuKSk7Cit9CisKK3UxNgorZmNfcm5pZF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcm5pZF9jbWRfcyAqcm5pZCwgdTMyIGRfaWQsCisJCQl1MzIgc19pZCwgdTE2IG94X2lkLCB1MzIgZGF0YV9mb3JtYXQpCit7CisJZmNfZWxzX3JlcV9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisKKwltZW1zZXQocm5pZCwgMCwgc2l6ZW9mKHN0cnVjdCBmY19ybmlkX2NtZF9zKSk7CisKKwlybmlkLT5lbHNfY21kLmVsc19jb2RlID0gRkNfRUxTX1JOSUQ7CisJcm5pZC0+bm9kZV9pZF9kYXRhX2Zvcm1hdCA9IGRhdGFfZm9ybWF0OworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjX3JuaWRfY21kX3MpKTsKK30KKwordTE2CitmY19ybmlkX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcm5pZF9hY2NfcyAqcm5pZF9hY2MsCisJCQl1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCXUzMiBkYXRhX2Zvcm1hdCwKKwkJCXN0cnVjdCBmY19ybmlkX2NvbW1vbl9pZF9kYXRhX3MgKmNvbW1vbl9pZF9kYXRhLAorCQkJc3RydWN0IGZjX3JuaWRfZ2VuZXJhbF90b3BvbG9neV9kYXRhX3MgKmdlbl90b3BvX2RhdGEpCit7CisJbWVtc2V0KHJuaWRfYWNjLCAwLCBzaXplb2Yoc3RydWN0IGZjX3JuaWRfYWNjX3MpKTsKKworCWZjX2Vsc19yc3BfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCisJcm5pZF9hY2MtPmVsc19jbWQuZWxzX2NvZGUgPSBGQ19FTFNfQUNDOworCXJuaWRfYWNjLT5ub2RlX2lkX2RhdGFfZm9ybWF0ID0gZGF0YV9mb3JtYXQ7CisJcm5pZF9hY2MtPmNvbW1vbl9pZF9kYXRhX2xlbmd0aCA9CisJCQlzaXplb2Yoc3RydWN0IGZjX3JuaWRfY29tbW9uX2lkX2RhdGFfcyk7CisJcm5pZF9hY2MtPmNvbW1vbl9pZF9kYXRhID0gKmNvbW1vbl9pZF9kYXRhOworCisJaWYgKGRhdGFfZm9ybWF0ID09IFJOSURfTk9ERUlEX0RBVEFfRk9STUFUX0RJU0NPVkVSWSkgeworCQlybmlkX2FjYy0+c3BlY2lmaWNfaWRfZGF0YV9sZW5ndGggPQorCQkJc2l6ZW9mKHN0cnVjdCBmY19ybmlkX2dlbmVyYWxfdG9wb2xvZ3lfZGF0YV9zKTsKKwkJYmZhX29zX2Fzc2lnbihybmlkX2FjYy0+Z2VuX3RvcG9sb2d5X2RhdGEsICpnZW5fdG9wb19kYXRhKTsKKwkJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjX3JuaWRfYWNjX3MpKTsKKwl9IGVsc2UgeworCQlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfcm5pZF9hY2NfcykgLQorCQkJc2l6ZW9mKHN0cnVjdCBmY19ybmlkX2dlbmVyYWxfdG9wb2xvZ3lfZGF0YV9zKSk7CisJfQorCit9CisKK3UxNgorZmNfcnBzY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcnBzY19jbWRfcyAqcnBzYywgdTMyIGRfaWQsCisJCQl1MzIgc19pZCwgdTE2IG94X2lkKQoreworCWZjX2Vsc19yZXFfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCisJbWVtc2V0KHJwc2MsIDAsIHNpemVvZihzdHJ1Y3QgZmNfcnBzY19jbWRfcykpOworCisJcnBzYy0+ZWxzX2NtZC5lbHNfY29kZSA9IEZDX0VMU19SUFNDOworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19ycHNjX2NtZF9zKSk7Cit9CisKK3UxNgorZmNfcnBzYzJfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX3Jwc2MyX2NtZF9zICpycHNjMiwKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTMyICpwaWRfbGlzdCwKKwkJCXUxNiBucGlkcykKK3sKKwl1MzIgZGN0bHJfaWQgPSBGQ19ET01BSU5fQ1RSTFIoYmZhX29zX2h0b24zYihkX2lkKSk7CisJaW50IGkgPSAwOworCisJZmNfZWxzX3JlcV9idWlsZChmY2hzLCBiZmFfb3NfaHRvbjNiKGRjdGxyX2lkKSwgc19pZCwgMCk7CisKKwltZW1zZXQocnBzYzIsIDAsIHNpemVvZihzdHJ1Y3QgZmNfcnBzYzJfY21kX3MpKTsKKworCXJwc2MyLT5lbHNfY21kLmVsc19jb2RlID0gRkNfRUxTX1JQU0M7CisJcnBzYzItPnRva2VuID0gYmZhX29zX2h0b25sKEZDX0JSQ0RfVE9LRU4pOworCXJwc2MyLT5udW1fcGlkcyAgPSBiZmFfb3NfaHRvbnMobnBpZHMpOworCWZvciAoaSA9IDA7IGkgPCBucGlkczsgaSsrKQorCQlycHNjMi0+cGlkX2xpc3RbaV0ucGlkID0gcGlkX2xpc3RbaV07CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfcnBzYzJfY21kX3MpICsgKChucGlkcyAtIDEpICoKKwkJCShzaXplb2YodTMyKSkpKTsKK30KKwordTE2CitmY19ycHNjX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcnBzY19hY2NfcyAqcnBzY19hY2MsCisJCQl1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCXN0cnVjdCBmY19ycHNjX3NwZWVkX2luZm9fcyAqb3Blcl9zcGVlZCkKK3sKKwltZW1zZXQocnBzY19hY2MsIDAsIHNpemVvZihzdHJ1Y3QgZmNfcnBzY19hY2NfcykpOworCisJZmNfZWxzX3JzcF9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisKKwlycHNjX2FjYy0+Y29tbWFuZCA9IEZDX0VMU19BQ0M7CisJcnBzY19hY2MtPm51bV9lbnRyaWVzID0gYmZhX29zX2h0b25zKDEpOworCisJcnBzY19hY2MtPnNwZWVkX2luZm9bMF0ucG9ydF9zcGVlZF9jYXAgPQorCQliZmFfb3NfaHRvbnMob3Blcl9zcGVlZC0+cG9ydF9zcGVlZF9jYXApOworCisJcnBzY19hY2MtPnNwZWVkX2luZm9bMF0ucG9ydF9vcF9zcGVlZCA9CisJCWJmYV9vc19odG9ucyhvcGVyX3NwZWVkLT5wb3J0X29wX3NwZWVkKTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19ycHNjX2FjY19zKSk7CisKK30KKworLyoKKyAqIFRCRCAtCisgKiAuIGdldCByaWQgb2YgdW5uZWNlc3NhcnkgbWVtc2V0cworICovCisKK3UxNgorZmNfbG9nb19yc3BfcGFyc2Uoc3RydWN0IGZjaHNfcyAqZmNocywgaW50IGxlbikKK3sKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgKmVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSAoZmNocyArIDEpOworCisJbGVuID0gbGVuOworCWlmIChlbHNfY21kLT5lbHNfY29kZSAhPSBGQ19FTFNfQUNDKQorCQlyZXR1cm4gRkNfUEFSU0VfRkFJTFVSRTsKKworCXJldHVybiBGQ19QQVJTRV9PSzsKK30KKwordTE2CitmY19wZGlzY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB1MzIgZF9pZCwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQsIHd3bl90IHBvcnRfbmFtZSwgd3duX3Qgbm9kZV9uYW1lLAorCQkJdTE2IHBkdV9zaXplKQoreworCXN0cnVjdCBmY19sb2dpX3MgICAgICpwZGlzYyA9IChzdHJ1Y3QgZmNfbG9naV9zICopIChmY2hzICsgMSk7CisKKwliZmFfb3NfbWVtY3B5KHBkaXNjLCAmcGxvZ2lfdG1wbCwgc2l6ZW9mKHN0cnVjdCBmY19sb2dpX3MpKTsKKworCXBkaXNjLT5lbHNfY21kLmVsc19jb2RlID0gRkNfRUxTX1BESVNDOworCWZjX2Vsc19yZXFfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCisJcGRpc2MtPmNzcC5yeHN6ID0gcGRpc2MtPmNsYXNzMy5yeHN6ID0gYmZhX29zX2h0b25zKHBkdV9zaXplKTsKKwlwZGlzYy0+cG9ydF9uYW1lID0gcG9ydF9uYW1lOworCXBkaXNjLT5ub2RlX25hbWUgPSBub2RlX25hbWU7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSk7Cit9CisKK3UxNgorZmNfcGRpc2NfcnNwX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmZjaHMsIGludCBsZW4sIHd3bl90IHBvcnRfbmFtZSkKK3sKKwlzdHJ1Y3QgZmNfbG9naV9zICAgICAqcGRpc2MgPSAoc3RydWN0IGZjX2xvZ2lfcyAqKSAoZmNocyArIDEpOworCisJaWYgKGxlbiA8IHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSkKKwkJcmV0dXJuIChGQ19QQVJTRV9MRU5fSU5WQUwpOworCisJaWYgKHBkaXNjLT5lbHNfY21kLmVsc19jb2RlICE9IEZDX0VMU19BQ0MpCisJCXJldHVybiAoRkNfUEFSU0VfQUNDX0lOVkFMKTsKKworCWlmICghd3duX2lzX2VxdWFsKHBkaXNjLT5wb3J0X25hbWUsIHBvcnRfbmFtZSkpCisJCXJldHVybiAoRkNfUEFSU0VfUFdXTl9OT1RfRVFVQUwpOworCisJaWYgKCFwZGlzYy0+Y2xhc3MzLmNsYXNzX3ZhbGlkKQorCQlyZXR1cm4gKEZDX1BBUlNFX05XV05fTk9UX0VRVUFMKTsKKworCWlmIChiZmFfb3NfbnRvaHMocGRpc2MtPmNsYXNzMy5yeHN6KSA8IChGQ19NSU5fUERVU1opKQorCQlyZXR1cm4gKEZDX1BBUlNFX1JYU1pfSU5WQUwpOworCisJcmV0dXJuIChGQ19QQVJTRV9PSyk7Cit9CisKK3UxNgorZmNfcHJsb19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkgICAgICBpbnQgbnVtX3BhZ2VzKQoreworCXN0cnVjdCBmY19wcmxvX3MgICAgICAqcHJsbyA9IChzdHJ1Y3QgZmNfcHJsb19zICopIChmY2hzICsgMSk7CisJaW50ICAgICAgICAgICAgIHBhZ2U7CisKKwlmY19lbHNfcmVxX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKwltZW1zZXQocHJsbywgMCwgKG51bV9wYWdlcyAqIDE2KSArIDQpOworCXBybG8tPmNvbW1hbmQgPSBGQ19FTFNfUFJMTzsKKwlwcmxvLT5wYWdlX2xlbiA9IDB4MTA7CisJcHJsby0+cGF5bG9hZF9sZW4gPSBiZmFfb3NfaHRvbnMoKG51bV9wYWdlcyAqIDE2KSArIDQpOworCisJZm9yIChwYWdlID0gMDsgcGFnZSA8IG51bV9wYWdlczsgcGFnZSsrKSB7CisJCXBybG8tPnBybG9fcGFyYW1zW3BhZ2VdLnR5cGUgPSBGQ19UWVBFX0ZDUDsKKwkJcHJsby0+cHJsb19wYXJhbXNbcGFnZV0ub3BhX3ZhbGlkID0gMDsKKwkJcHJsby0+cHJsb19wYXJhbXNbcGFnZV0ucnBhX3ZhbGlkID0gMDsKKwkJcHJsby0+cHJsb19wYXJhbXNbcGFnZV0ub3JpZ19wcm9jZXNzX2Fzc2MgPSAwOworCQlwcmxvLT5wcmxvX3BhcmFtc1twYWdlXS5yZXNwX3Byb2Nlc3NfYXNzYyA9IDA7CisJfQorCisJcmV0dXJuIChiZmFfb3NfbnRvaHMocHJsby0+cGF5bG9hZF9sZW4pKTsKK30KKwordTE2CitmY19wcmxvX3JzcF9wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCBpbnQgbGVuKQoreworCXN0cnVjdCBmY19wcmxvX2FjY19zICAqcHJsbyA9IChzdHJ1Y3QgZmNfcHJsb19hY2NfcyAqKSAoZmNocyArIDEpOworCWludCAgICAgICAgICAgICBudW1fcGFnZXMgPSAwOworCWludCAgICAgICAgICAgICBwYWdlID0gMDsKKworCWxlbiA9IGxlbjsKKworCWlmIChwcmxvLT5jb21tYW5kICE9IEZDX0VMU19BQ0MpCisJCXJldHVybiAoRkNfUEFSU0VfRkFJTFVSRSk7CisKKwludW1fcGFnZXMgPSAoKGJmYV9vc19udG9ocyhwcmxvLT5wYXlsb2FkX2xlbikpIC0gNCkgLyAxNjsKKworCWZvciAocGFnZSA9IDA7IHBhZ2UgPCBudW1fcGFnZXM7IHBhZ2UrKykgeworCQlpZiAocHJsby0+cHJsb19hY2NfcGFyYW1zW3BhZ2VdLnR5cGUgIT0gRkNfVFlQRV9GQ1ApCisJCQlyZXR1cm4gRkNfUEFSU0VfRkFJTFVSRTsKKworCQlpZiAocHJsby0+cHJsb19hY2NfcGFyYW1zW3BhZ2VdLm9wYV92YWxpZCAhPSAwKQorCQkJcmV0dXJuIEZDX1BBUlNFX0ZBSUxVUkU7CisKKwkJaWYgKHBybG8tPnBybG9fYWNjX3BhcmFtc1twYWdlXS5ycGFfdmFsaWQgIT0gMCkKKwkJCXJldHVybiBGQ19QQVJTRV9GQUlMVVJFOworCisJCWlmIChwcmxvLT5wcmxvX2FjY19wYXJhbXNbcGFnZV0ub3JpZ19wcm9jZXNzX2Fzc2MgIT0gMCkKKwkJCXJldHVybiBGQ19QQVJTRV9GQUlMVVJFOworCisJCWlmIChwcmxvLT5wcmxvX2FjY19wYXJhbXNbcGFnZV0ucmVzcF9wcm9jZXNzX2Fzc2MgIT0gMCkKKwkJCXJldHVybiBGQ19QQVJTRV9GQUlMVVJFOworCX0KKwlyZXR1cm4gKEZDX1BBUlNFX09LKTsKKworfQorCit1MTYKK2ZjX3RwcmxvX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCwgaW50IG51bV9wYWdlcywKKwkJCWVudW0gZmNfdHBybG9fdHlwZSB0cHJsb190eXBlLCB1MzIgdHByX2lkKQoreworCXN0cnVjdCBmY190cHJsb19zICAgICAqdHBybG8gPSAoc3RydWN0IGZjX3RwcmxvX3MgKikgKGZjaHMgKyAxKTsKKwlpbnQgICAgICAgICAgICAgcGFnZTsKKworCWZjX2Vsc19yZXFfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCW1lbXNldCh0cHJsbywgMCwgKG51bV9wYWdlcyAqIDE2KSArIDQpOworCXRwcmxvLT5jb21tYW5kID0gRkNfRUxTX1RQUkxPOworCXRwcmxvLT5wYWdlX2xlbiA9IDB4MTA7CisJdHBybG8tPnBheWxvYWRfbGVuID0gYmZhX29zX2h0b25zKChudW1fcGFnZXMgKiAxNikgKyA0KTsKKworCWZvciAocGFnZSA9IDA7IHBhZ2UgPCBudW1fcGFnZXM7IHBhZ2UrKykgeworCQl0cHJsby0+dHBybG9fcGFyYW1zW3BhZ2VdLnR5cGUgPSBGQ19UWVBFX0ZDUDsKKwkJdHBybG8tPnRwcmxvX3BhcmFtc1twYWdlXS5vcGFfdmFsaWQgPSAwOworCQl0cHJsby0+dHBybG9fcGFyYW1zW3BhZ2VdLnJwYV92YWxpZCA9IDA7CisJCXRwcmxvLT50cHJsb19wYXJhbXNbcGFnZV0ub3JpZ19wcm9jZXNzX2Fzc2MgPSAwOworCQl0cHJsby0+dHBybG9fcGFyYW1zW3BhZ2VdLnJlc3BfcHJvY2Vzc19hc3NjID0gMDsKKwkJaWYgKHRwcmxvX3R5cGUgPT0gRkNfR0xPQkFMX0xPR08pIHsKKwkJCXRwcmxvLT50cHJsb19wYXJhbXNbcGFnZV0uZ2xvYmFsX3Byb2Nlc3NfbG9nb3V0ID0gMTsKKwkJfSBlbHNlIGlmICh0cHJsb190eXBlID09IEZDX1RQUl9MT0dPKSB7CisJCQl0cHJsby0+dHBybG9fcGFyYW1zW3BhZ2VdLnRwb19ucG9ydF92YWxpZCA9IDE7CisJCQl0cHJsby0+dHBybG9fcGFyYW1zW3BhZ2VdLnRwb19ucG9ydF9pZCA9ICh0cHJfaWQpOworCQl9CisJfQorCisJcmV0dXJuIChiZmFfb3NfbnRvaHModHBybG8tPnBheWxvYWRfbGVuKSk7Cit9CisKK3UxNgorZmNfdHBybG9fcnNwX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmZjaHMsIGludCBsZW4pCit7CisJc3RydWN0IGZjX3RwcmxvX2FjY19zICp0cHJsbyA9IChzdHJ1Y3QgZmNfdHBybG9fYWNjX3MgKikgKGZjaHMgKyAxKTsKKwlpbnQgICAgICAgICAgICAgbnVtX3BhZ2VzID0gMDsKKwlpbnQgICAgICAgICAgICAgcGFnZSA9IDA7CisKKwlsZW4gPSBsZW47CisKKwlpZiAodHBybG8tPmNvbW1hbmQgIT0gRkNfRUxTX0FDQykKKwkJcmV0dXJuIChGQ19QQVJTRV9BQ0NfSU5WQUwpOworCisJbnVtX3BhZ2VzID0gKGJmYV9vc19udG9ocyh0cHJsby0+cGF5bG9hZF9sZW4pIC0gNCkgLyAxNjsKKworCWZvciAocGFnZSA9IDA7IHBhZ2UgPCBudW1fcGFnZXM7IHBhZ2UrKykgeworCQlpZiAodHBybG8tPnRwcmxvX2FjY19wYXJhbXNbcGFnZV0udHlwZSAhPSBGQ19UWVBFX0ZDUCkKKwkJCXJldHVybiAoRkNfUEFSU0VfTk9UX0ZDUCk7CisJCWlmICh0cHJsby0+dHBybG9fYWNjX3BhcmFtc1twYWdlXS5vcGFfdmFsaWQgIT0gMCkKKwkJCXJldHVybiAoRkNfUEFSU0VfT1BBRkxBR19JTlZBTCk7CisJCWlmICh0cHJsby0+dHBybG9fYWNjX3BhcmFtc1twYWdlXS5ycGFfdmFsaWQgIT0gMCkKKwkJCXJldHVybiAoRkNfUEFSU0VfUlBBRkxBR19JTlZBTCk7CisJCWlmICh0cHJsby0+dHBybG9fYWNjX3BhcmFtc1twYWdlXS5vcmlnX3Byb2Nlc3NfYXNzYyAhPSAwKQorCQkJcmV0dXJuIChGQ19QQVJTRV9PUEFfSU5WQUwpOworCQlpZiAodHBybG8tPnRwcmxvX2FjY19wYXJhbXNbcGFnZV0ucmVzcF9wcm9jZXNzX2Fzc2MgIT0gMCkKKwkJCXJldHVybiAoRkNfUEFSU0VfUlBBX0lOVkFMKTsKKwl9CisJcmV0dXJuIChGQ19QQVJTRV9PSyk7Cit9CisKK2VudW0gZmNfcGFyc2Vfc3RhdHVzCitmY19ycnFfcnNwX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmZjaHMsIGludCBsZW4pCit7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICplbHNfY21kID0gKHN0cnVjdCBmY19lbHNfY21kX3MgKikgKGZjaHMgKyAxKTsKKworCWxlbiA9IGxlbjsKKwlpZiAoZWxzX2NtZC0+ZWxzX2NvZGUgIT0gRkNfRUxTX0FDQykKKwkJcmV0dXJuIEZDX1BBUlNFX0ZBSUxVUkU7CisKKwlyZXR1cm4gRkNfUEFSU0VfT0s7Cit9CisKK3UxNgorZmNfYmFfcmp0X2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCwgdTMyIHJlYXNvbl9jb2RlLAorCQkJdTMyIHJlYXNvbl9leHBsKQoreworCXN0cnVjdCBmY19iYV9yanRfcyAgICAqYmFfcmp0ID0gKHN0cnVjdCBmY19iYV9yanRfcyAqKSAoZmNocyArIDEpOworCisJZmNfYmxzX3JzcF9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisKKwlmY2hzLT5jYXRfaW5mbyA9IEZDX0NBVF9CQV9SSlQ7CisJYmFfcmp0LT5yZWFzb25fY29kZSA9IHJlYXNvbl9jb2RlOworCWJhX3JqdC0+cmVhc29uX2V4cGwgPSByZWFzb25fZXhwbDsKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNfYmFfcmp0X3MpKTsKK30KKworc3RhdGljIHZvaWQKK2ZjX2dzX2N0aGRyX2J1aWxkKHN0cnVjdCBjdF9oZHJfcyAqY3RoZHIsIHUzMiBzX2lkLCB1MTYgY21kX2NvZGUpCit7CisJYmZhX29zX21lbXNldChjdGhkciwgMCwgc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworCWN0aGRyLT5yZXZfaWQgPSBDVF9HUzNfUkVWSVNJT047CisJY3RoZHItPmdzX3R5cGUgPSBDVF9HU1RZUEVfRElSU0VSVklDRTsKKwljdGhkci0+Z3Nfc3ViX3R5cGUgPSBDVF9HU1NVQlRZUEVfTkFNRVNFUlZFUjsKKwljdGhkci0+Y21kX3JzcF9jb2RlID0gYmZhX29zX2h0b25zKGNtZF9jb2RlKTsKK30KKworc3RhdGljIHZvaWQKK2ZjX2dzX2ZkbWlfY3RoZHJfYnVpbGQoc3RydWN0IGN0X2hkcl9zICpjdGhkciwgdTMyIHNfaWQsIHUxNiBjbWRfY29kZSkKK3sKKwliZmFfb3NfbWVtc2V0KGN0aGRyLCAwLCBzaXplb2Yoc3RydWN0IGN0X2hkcl9zKSk7CisJY3RoZHItPnJldl9pZCA9IENUX0dTM19SRVZJU0lPTjsKKwljdGhkci0+Z3NfdHlwZSA9IENUX0dTVFlQRV9NR01UU0VSVklDRTsKKwljdGhkci0+Z3Nfc3ViX3R5cGUgPSBDVF9HU1NVQlRZUEVfSEJBX01HTVRTRVJWRVI7CisJY3RoZHItPmNtZF9yc3BfY29kZSA9IGJmYV9vc19odG9ucyhjbWRfY29kZSk7Cit9CisKK3N0YXRpYyB2b2lkCitmY19nc19tc19jdGhkcl9idWlsZChzdHJ1Y3QgY3RfaGRyX3MgKmN0aGRyLCB1MzIgc19pZCwgdTE2IGNtZF9jb2RlLAorCQkJCQkgdTggc3ViX3R5cGUpCit7CisJYmZhX29zX21lbXNldChjdGhkciwgMCwgc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworCWN0aGRyLT5yZXZfaWQgPSBDVF9HUzNfUkVWSVNJT047CisJY3RoZHItPmdzX3R5cGUgPSBDVF9HU1RZUEVfTUdNVFNFUlZJQ0U7CisJY3RoZHItPmdzX3N1Yl90eXBlID0gc3ViX3R5cGU7CisJY3RoZHItPmNtZF9yc3BfY29kZSA9IGJmYV9vc19odG9ucyhjbWRfY29kZSk7Cit9CisKK3UxNgorZmNfZ2lkcG5fYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkgICAgICAgd3duX3QgcG9ydF9uYW1lKQoreworCisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgcHlsZDsKKwlzdHJ1Y3QgZmNnc19naWRwbl9yZXFfcyAqZ2lkcG4gPQorCQkJKHN0cnVjdCBmY2dzX2dpZHBuX3JlcV9zICopIChjdGhkciArIDEpOworCXUzMiAgICAgICAgZF9pZCA9IGJmYV9vc19odG9uM2IoRkNfTkFNRV9TRVJWRVIpOworCisJZmNfZ3NfZmNoZHJfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCWZjX2dzX2N0aGRyX2J1aWxkKGN0aGRyLCBzX2lkLCBHU19HSURfUE4pOworCisJYmZhX29zX21lbXNldChnaWRwbiwgMCwgc2l6ZW9mKHN0cnVjdCBmY2dzX2dpZHBuX3JlcV9zKSk7CisJZ2lkcG4tPnBvcnRfbmFtZSA9IHBvcnRfbmFtZTsKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNnc19naWRwbl9yZXFfcykgKyBzaXplb2Yoc3RydWN0IGN0X2hkcl9zKSk7Cit9CisKK3UxNgorZmNfZ3BuaWRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkgICAgICAgdTMyIHBvcnRfaWQpCit7CisKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkOworCWZjZ3NfZ3BuaWRfcmVxX3QgKmdwbmlkID0gKGZjZ3NfZ3BuaWRfcmVxX3QgKikgKGN0aGRyICsgMSk7CisJdTMyICAgICAgICBkX2lkID0gYmZhX29zX2h0b24zYihGQ19OQU1FX1NFUlZFUik7CisKKwlmY19nc19mY2hkcl9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisJZmNfZ3NfY3RoZHJfYnVpbGQoY3RoZHIsIHNfaWQsIEdTX0dQTl9JRCk7CisKKwliZmFfb3NfbWVtc2V0KGdwbmlkLCAwLCBzaXplb2YoZmNnc19ncG5pZF9yZXFfdCkpOworCWdwbmlkLT5kYXAgPSBwb3J0X2lkOworCXJldHVybiAoc2l6ZW9mKGZjZ3NfZ3BuaWRfcmVxX3QpICsgc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworfQorCit1MTYKK2ZjX2dubmlkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLCB1MTYgb3hfaWQsCisJICAgICAgIHUzMiBwb3J0X2lkKQoreworCisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgcHlsZDsKKwlmY2dzX2dubmlkX3JlcV90ICpnbm5pZCA9IChmY2dzX2dubmlkX3JlcV90ICopIChjdGhkciArIDEpOworCXUzMiAgICAgICAgZF9pZCA9IGJmYV9vc19odG9uM2IoRkNfTkFNRV9TRVJWRVIpOworCisJZmNfZ3NfZmNoZHJfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCWZjX2dzX2N0aGRyX2J1aWxkKGN0aGRyLCBzX2lkLCBHU19HTk5fSUQpOworCisJYmZhX29zX21lbXNldChnbm5pZCwgMCwgc2l6ZW9mKGZjZ3NfZ25uaWRfcmVxX3QpKTsKKwlnbm5pZC0+ZGFwID0gcG9ydF9pZDsKKwlyZXR1cm4gKHNpemVvZihmY2dzX2dubmlkX3JlcV90KSArIHNpemVvZihzdHJ1Y3QgY3RfaGRyX3MpKTsKK30KKwordTE2CitmY19jdF9yc3BfcGFyc2Uoc3RydWN0IGN0X2hkcl9zICpjdGhkcikKK3sKKwlpZiAoYmZhX29zX250b2hzKGN0aGRyLT5jbWRfcnNwX2NvZGUpICE9IENUX1JTUF9BQ0NFUFQpIHsKKwkJaWYgKGN0aGRyLT5yZWFzb25fY29kZSA9PSBDVF9SU05fTE9HSUNBTF9CVVNZKQorCQkJcmV0dXJuIEZDX1BBUlNFX0JVU1k7CisJCWVsc2UKKwkJCXJldHVybiBGQ19QQVJTRV9GQUlMVVJFOworCX0KKworCXJldHVybiBGQ19QQVJTRV9PSzsKK30KKwordTE2CitmY19zY3JfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX3Njcl9zICpzY3IsIHU4IHNldF9icl9yZWcsCisJCQl1MzIgc19pZCwgdTE2IG94X2lkKQoreworCXUzMiAgICAgICAgZF9pZCA9IGJmYV9vc19odG9uM2IoRkNfRkFCUklDX0NPTlRST0xMRVIpOworCisJZmNfZWxzX3JlcV9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisKKwliZmFfb3NfbWVtc2V0KHNjciwgMCwgc2l6ZW9mKHN0cnVjdCBmY19zY3JfcykpOworCXNjci0+Y29tbWFuZCA9IEZDX0VMU19TQ1I7CisJc2NyLT5yZWdfZnVuYyA9IEZDX1NDUl9SRUdfRlVOQ19GVUxMOworCWlmIChzZXRfYnJfcmVnKQorCQlzY3ItPnZ1X3JlZ19mdW5jID0gRkNfVlVfU0NSX1JFR19GVU5DX0ZBQlJJQ19OQU1FX0NIQU5HRTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY19zY3JfcykpOworfQorCit1MTYKK2ZjX3JzY25fYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX3JzY25fcGxfcyAqcnNjbiwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQpCit7CisJdTMyICAgICAgICBkX2lkID0gYmZhX29zX2h0b24zYihGQ19GQUJSSUNfQ09OVFJPTExFUik7CisJdTE2ICAgICAgICBwYXlsZGxlbjsKKworCWZjX2Vsc19yZXFfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgb3hfaWQpOworCXJzY24tPmNvbW1hbmQgPSBGQ19FTFNfUlNDTjsKKwlyc2NuLT5wYWdlbGVuID0gc2l6ZW9mKHJzY24tPmV2ZW50WzBdKTsKKworCXBheWxkbGVuID0gc2l6ZW9mKHUzMikgKyByc2NuLT5wYWdlbGVuOworCXJzY24tPnBheWxkbGVuID0gYmZhX29zX2h0b25zKHBheWxkbGVuKTsKKworCXJzY24tPmV2ZW50WzBdLmZvcm1hdCA9IEZDX1JTQ05fRk9STUFUX1BPUlRJRDsKKwlyc2NuLT5ldmVudFswXS5wb3J0aWQgPSBzX2lkOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjX3JzY25fcGxfcykpOworfQorCit1MTYKK2ZjX3JmdGlkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLCB1MTYgb3hfaWQsCisJICAgICAgIGVudW0gYmZhX3BvcnRfcm9sZSByb2xlcykKK3sKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkOworCXN0cnVjdCBmY2dzX3JmdGlkX3JlcV9zICpyZnRpZCA9CisJCQkoc3RydWN0IGZjZ3NfcmZ0aWRfcmVxX3MgKikgKGN0aGRyICsgMSk7CisJdTMyICAgICAgICB0eXBlX3ZhbHVlLCBkX2lkID0gYmZhX29zX2h0b24zYihGQ19OQU1FX1NFUlZFUik7CisJdTggICAgICAgICBpbmRleDsKKworCWZjX2dzX2ZjaGRyX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKwlmY19nc19jdGhkcl9idWlsZChjdGhkciwgc19pZCwgR1NfUkZUX0lEKTsKKworCWJmYV9vc19tZW1zZXQocmZ0aWQsIDAsIHNpemVvZihzdHJ1Y3QgZmNnc19yZnRpZF9yZXFfcykpOworCisJcmZ0aWQtPmRhcCA9IHNfaWQ7CisKKwkvKiBCeSBkZWZhdWx0LCBGQ1AgRkM0IFR5cGUgaXMgcmVnaXN0ZXJlZCAqLworCWluZGV4ID0gRkNfVFlQRV9GQ1AgPj4gNTsKKwl0eXBlX3ZhbHVlID0gMSA8PCAoRkNfVFlQRV9GQ1AgJSAzMik7CisJcmZ0aWQtPmZjNF90eXBlW2luZGV4XSA9IGJmYV9vc19odG9ubCh0eXBlX3ZhbHVlKTsKKworCWlmIChyb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lQRkMpIHsKKwkJaW5kZXggPSBGQ19UWVBFX0lQID4+IDU7CisJCXR5cGVfdmFsdWUgPSAxIDw8IChGQ19UWVBFX0lQICUgMzIpOworCQlyZnRpZC0+ZmM0X3R5cGVbaW5kZXhdIHw9IGJmYV9vc19odG9ubCh0eXBlX3ZhbHVlKTsKKwl9CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNnc19yZnRpZF9yZXFfcykgKyBzaXplb2Yoc3RydWN0IGN0X2hkcl9zKSk7Cit9CisKK3UxNgorZmNfcmZ0aWRfYnVpbGRfc29sKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLAorCQkJdTE2IG94X2lkLCB1OCAqZmM0X2JpdG1hcCwKKwkJCXUzMiBiaXRtYXBfc2l6ZSkKK3sKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkOworCXN0cnVjdCBmY2dzX3JmdGlkX3JlcV9zICpyZnRpZCA9CisJCQkoc3RydWN0IGZjZ3NfcmZ0aWRfcmVxX3MgKikgKGN0aGRyICsgMSk7CisJdTMyICAgICAgICBkX2lkID0gYmZhX29zX2h0b24zYihGQ19OQU1FX1NFUlZFUik7CisKKwlmY19nc19mY2hkcl9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisJZmNfZ3NfY3RoZHJfYnVpbGQoY3RoZHIsIHNfaWQsIEdTX1JGVF9JRCk7CisKKwliZmFfb3NfbWVtc2V0KHJmdGlkLCAwLCBzaXplb2Yoc3RydWN0IGZjZ3NfcmZ0aWRfcmVxX3MpKTsKKworCXJmdGlkLT5kYXAgPSBzX2lkOworCWJmYV9vc19tZW1jcHkoKHZvaWQgKilyZnRpZC0+ZmM0X3R5cGUsICh2b2lkICopZmM0X2JpdG1hcCwKKwkJCShiaXRtYXBfc2l6ZSA8IDMyID8gYml0bWFwX3NpemUgOiAzMikpOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjZ3NfcmZ0aWRfcmVxX3MpICsgc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworfQorCit1MTYKK2ZjX3JmZmlkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLCB1MTYgb3hfaWQsCisJICAgICAgIHU4IGZjNF90eXBlLCB1OCBmYzRfZnRycykKK3sKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgICAqY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIHB5bGQ7CisJc3RydWN0IGZjZ3NfcmZmaWRfcmVxX3MgKnJmZmlkID0KKwkJCShzdHJ1Y3QgZmNnc19yZmZpZF9yZXFfcyAqKSAoY3RoZHIgKyAxKTsKKwl1MzIgICAgICAgICBkX2lkID0gYmZhX29zX2h0b24zYihGQ19OQU1FX1NFUlZFUik7CisKKwlmY19nc19mY2hkcl9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCBveF9pZCk7CisJZmNfZ3NfY3RoZHJfYnVpbGQoY3RoZHIsIHNfaWQsIEdTX1JGRl9JRCk7CisKKwliZmFfb3NfbWVtc2V0KHJmZmlkLCAwLCBzaXplb2Yoc3RydWN0IGZjZ3NfcmZmaWRfcmVxX3MpKTsKKworCXJmZmlkLT5kYXAgCQkgCT0gc19pZDsKKwlyZmZpZC0+ZmM0ZnRyX2JpdHMgID0gZmM0X2Z0cnM7CisJcmZmaWQtPmZjNF90eXBlCQk9IGZjNF90eXBlOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjZ3NfcmZmaWRfcmVxX3MpICsgc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworfQorCit1MTYKK2ZjX3JzcG5pZF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpweWxkLCB1MzIgc19pZCwgdTE2IG94X2lkLAorCQl1OCAqbmFtZSkKK3sKKworCXN0cnVjdCBjdF9oZHJfcyAgICAgICAqY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIHB5bGQ7CisJc3RydWN0IGZjZ3NfcnNwbmlkX3JlcV9zICpyc3BuaWQgPQorCQkJKHN0cnVjdCBmY2dzX3JzcG5pZF9yZXFfcyAqKSAoY3RoZHIgKyAxKTsKKwl1MzIgICAgICAgIGRfaWQgPSBiZmFfb3NfaHRvbjNiKEZDX05BTUVfU0VSVkVSKTsKKworCWZjX2dzX2ZjaGRyX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIG94X2lkKTsKKwlmY19nc19jdGhkcl9idWlsZChjdGhkciwgc19pZCwgR1NfUlNQTl9JRCk7CisKKwliZmFfb3NfbWVtc2V0KHJzcG5pZCwgMCwgc2l6ZW9mKHN0cnVjdCBmY2dzX3JzcG5pZF9yZXFfcykpOworCisJcnNwbmlkLT5kYXAgPSBzX2lkOworCXJzcG5pZC0+c3BuX2xlbiA9ICh1OCkgc3RybGVuKChjaGFyICopbmFtZSk7CisJc3RybmNweSgoY2hhciAqKXJzcG5pZC0+c3BuLCAoY2hhciAqKW5hbWUsIHJzcG5pZC0+c3BuX2xlbik7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNnc19yc3BuaWRfcmVxX3MpICsgc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworfQorCit1MTYKK2ZjX2dpZF9mdF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpweWxkLCB1MzIgc19pZCwKKwkJCXU4IGZjNF90eXBlKQoreworCisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgcHlsZDsKKwlzdHJ1Y3QgZmNnc19naWRmdF9yZXFfcyAqZ2lkZnQgPQorCQkJKHN0cnVjdCBmY2dzX2dpZGZ0X3JlcV9zICopIChjdGhkciArIDEpOworCXUzMiAgICAgICAgZF9pZCA9IGJmYV9vc19odG9uM2IoRkNfTkFNRV9TRVJWRVIpOworCisJZmNfZ3NfZmNoZHJfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgMCk7CisKKwlmY19nc19jdGhkcl9idWlsZChjdGhkciwgc19pZCwgR1NfR0lEX0ZUKTsKKworCWJmYV9vc19tZW1zZXQoZ2lkZnQsIDAsIHNpemVvZihzdHJ1Y3QgZmNnc19naWRmdF9yZXFfcykpOworCWdpZGZ0LT5mYzRfdHlwZSA9IGZjNF90eXBlOworCWdpZGZ0LT5kb21haW5faWQgPSAwOworCWdpZGZ0LT5hcmVhX2lkID0gMDsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY2dzX2dpZGZ0X3JlcV9zKSArIHNpemVvZihzdHJ1Y3QgY3RfaGRyX3MpKTsKK30KKwordTE2CitmY19ycG5pZF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpweWxkLCB1MzIgc19pZCwgdTMyIHBvcnRfaWQsCisJICAgICAgIHd3bl90IHBvcnRfbmFtZSkKK3sKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkOworCXN0cnVjdCBmY2dzX3JwbmlkX3JlcV9zICpycG5pZCA9CisJCQkoc3RydWN0IGZjZ3NfcnBuaWRfcmVxX3MgKikgKGN0aGRyICsgMSk7CisJdTMyICAgICAgICBkX2lkID0gYmZhX29zX2h0b24zYihGQ19OQU1FX1NFUlZFUik7CisKKwlmY19nc19mY2hkcl9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCAwKTsKKwlmY19nc19jdGhkcl9idWlsZChjdGhkciwgc19pZCwgR1NfUlBOX0lEKTsKKworCWJmYV9vc19tZW1zZXQocnBuaWQsIDAsIHNpemVvZihzdHJ1Y3QgZmNnc19ycG5pZF9yZXFfcykpOworCXJwbmlkLT5wb3J0X2lkID0gcG9ydF9pZDsKKwlycG5pZC0+cG9ydF9uYW1lID0gcG9ydF9uYW1lOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGZjZ3NfcnBuaWRfcmVxX3MpICsgc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworfQorCit1MTYKK2ZjX3JubmlkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLCB1MzIgcG9ydF9pZCwKKwkgICAgICAgd3duX3Qgbm9kZV9uYW1lKQoreworCXN0cnVjdCBjdF9oZHJfcyAgICAgICAqY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIHB5bGQ7CisJc3RydWN0IGZjZ3Nfcm5uaWRfcmVxX3MgKnJubmlkID0KKwkJCShzdHJ1Y3QgZmNnc19ybm5pZF9yZXFfcyAqKSAoY3RoZHIgKyAxKTsKKwl1MzIgICAgICAgIGRfaWQgPSBiZmFfb3NfaHRvbjNiKEZDX05BTUVfU0VSVkVSKTsKKworCWZjX2dzX2ZjaGRyX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIDApOworCWZjX2dzX2N0aGRyX2J1aWxkKGN0aGRyLCBzX2lkLCBHU19STk5fSUQpOworCisJYmZhX29zX21lbXNldChybm5pZCwgMCwgc2l6ZW9mKHN0cnVjdCBmY2dzX3JubmlkX3JlcV9zKSk7CisJcm5uaWQtPnBvcnRfaWQgPSBwb3J0X2lkOworCXJubmlkLT5ub2RlX25hbWUgPSBub2RlX25hbWU7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNnc19ybm5pZF9yZXFfcykgKyBzaXplb2Yoc3RydWN0IGN0X2hkcl9zKSk7Cit9CisKK3UxNgorZmNfcmNzaWRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsIHUzMiBwb3J0X2lkLAorCSAgICAgICB1MzIgY29zKQoreworCXN0cnVjdCBjdF9oZHJfcyAgICAgICAqY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIHB5bGQ7CisJc3RydWN0IGZjZ3NfcmNzaWRfcmVxX3MgKnJjc2lkID0KKwkJCShzdHJ1Y3QgZmNnc19yY3NpZF9yZXFfcyAqKSAoY3RoZHIgKyAxKTsKKwl1MzIgICAgICAgIGRfaWQgPSBiZmFfb3NfaHRvbjNiKEZDX05BTUVfU0VSVkVSKTsKKworCWZjX2dzX2ZjaGRyX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIDApOworCWZjX2dzX2N0aGRyX2J1aWxkKGN0aGRyLCBzX2lkLCBHU19SQ1NfSUQpOworCisJYmZhX29zX21lbXNldChyY3NpZCwgMCwgc2l6ZW9mKHN0cnVjdCBmY2dzX3Jjc2lkX3JlcV9zKSk7CisJcmNzaWQtPnBvcnRfaWQgPSBwb3J0X2lkOworCXJjc2lkLT5jb3MgPSBjb3M7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgZmNnc19yY3NpZF9yZXFfcykgKyBzaXplb2Yoc3RydWN0IGN0X2hkcl9zKSk7Cit9CisKK3UxNgorZmNfcnB0aWRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsIHUzMiBwb3J0X2lkLAorCSAgICAgICB1OCBwb3J0X3R5cGUpCit7CisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgcHlsZDsKKwlzdHJ1Y3QgZmNnc19ycHRpZF9yZXFfcyAqcnB0aWQgPQorCQkJKHN0cnVjdCBmY2dzX3JwdGlkX3JlcV9zICopIChjdGhkciArIDEpOworCXUzMiAgICAgICAgZF9pZCA9IGJmYV9vc19odG9uM2IoRkNfTkFNRV9TRVJWRVIpOworCisJZmNfZ3NfZmNoZHJfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgMCk7CisJZmNfZ3NfY3RoZHJfYnVpbGQoY3RoZHIsIHNfaWQsIEdTX1JQVF9JRCk7CisKKwliZmFfb3NfbWVtc2V0KHJwdGlkLCAwLCBzaXplb2Yoc3RydWN0IGZjZ3NfcnB0aWRfcmVxX3MpKTsKKwlycHRpZC0+cG9ydF9pZCA9IHBvcnRfaWQ7CisJcnB0aWQtPnBvcnRfdHlwZSA9IHBvcnRfdHlwZTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBmY2dzX3JwdGlkX3JlcV9zKSArIHNpemVvZihzdHJ1Y3QgY3RfaGRyX3MpKTsKK30KKwordTE2CitmY19nYW54dF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpweWxkLCB1MzIgc19pZCwgdTMyIHBvcnRfaWQpCit7CisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgcHlsZDsKKwlzdHJ1Y3QgZmNnc19nYW54dF9yZXFfcyAqZ2FueHQgPQorCQkJKHN0cnVjdCBmY2dzX2dhbnh0X3JlcV9zICopIChjdGhkciArIDEpOworCXUzMiAgICAgICAgZF9pZCA9IGJmYV9vc19odG9uM2IoRkNfTkFNRV9TRVJWRVIpOworCisJZmNfZ3NfZmNoZHJfYnVpbGQoZmNocywgZF9pZCwgc19pZCwgMCk7CisJZmNfZ3NfY3RoZHJfYnVpbGQoY3RoZHIsIHNfaWQsIEdTX0dBX05YVCk7CisKKwliZmFfb3NfbWVtc2V0KGdhbnh0LCAwLCBzaXplb2Yoc3RydWN0IGZjZ3NfZ2FueHRfcmVxX3MpKTsKKwlnYW54dC0+cG9ydF9pZCA9IHBvcnRfaWQ7CisKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgY3RfaGRyX3MpICsgc2l6ZW9mKHN0cnVjdCBmY2dzX2dhbnh0X3JlcV9zKSk7Cit9CisKKy8qCisgKiBCdWlsZHMgZmMgaGRyIGFuZCBjdCBoZHIgZm9yIEZETUkgcmVxdWVzdHMuCisgKi8KK3UxNgorZmNfZmRtaV9yZXFoZHJfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsCisJCSAgICAgdTE2IGNtZF9jb2RlKQoreworCisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgcHlsZDsKKwl1MzIgICAgICAgIGRfaWQgPSBiZmFfb3NfaHRvbjNiKEZDX01HTVRfU0VSVkVSKTsKKworCWZjX2dzX2ZjaGRyX2J1aWxkKGZjaHMsIGRfaWQsIHNfaWQsIDApOworCWZjX2dzX2ZkbWlfY3RoZHJfYnVpbGQoY3RoZHIsIHNfaWQsIGNtZF9jb2RlKTsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykpOworfQorCisvKgorICogR2l2ZW4gYSBGQzQgVHlwZSwgdGhpcyBmdW5jdGlvbiByZXR1cm5zIGEgZmM0IHR5cGUgYml0bWFzaworICovCit2b2lkCitmY19nZXRfZmM0dHlwZV9iaXRtYXNrKHU4IGZjNF90eXBlLCB1OCAqYml0X21hc2spCit7CisJdTggICAgICAgICBpbmRleDsKKwl1MzIgICAgICAgKnB0ciA9ICh1MzIgKikgYml0X21hc2s7CisJdTMyICAgICAgICB0eXBlX3ZhbHVlOworCisJLyoKKwkgKiBAdG9kbyA6IENoZWNrIGZvciBiaXRtYXNrIHNpemUKKwkgKi8KKworCWluZGV4ID0gZmM0X3R5cGUgPj4gNTsKKwl0eXBlX3ZhbHVlID0gMSA8PCAoZmM0X3R5cGUgJSAzMik7CisJcHRyW2luZGV4XSA9IGJmYV9vc19odG9ubCh0eXBlX3ZhbHVlKTsKKworfQorCisvKgorICogR01BTCBSZXF1ZXN0CisgKi8KK3UxNgorZmNfZ21hbF9yZXFfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsIHd3bl90IHd3bikKK3sKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkOworCWZjZ3NfZ21hbF9yZXFfdCAqZ21hbCA9IChmY2dzX2dtYWxfcmVxX3QgKikgKGN0aGRyICsgMSk7CisJdTMyICAgICAgICBkX2lkID0gYmZhX29zX2h0b24zYihGQ19NR01UX1NFUlZFUik7CisKKwlmY19nc19mY2hkcl9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCAwKTsKKwlmY19nc19tc19jdGhkcl9idWlsZChjdGhkciwgc19pZCwgR1NfRkNfR01BTF9DTUQsCisJCQlDVF9HU1NVQlRZUEVfQ0ZHU0VSVkVSKTsKKworCWJmYV9vc19tZW1zZXQoZ21hbCwgMCwgc2l6ZW9mKGZjZ3NfZ21hbF9yZXFfdCkpOworCWdtYWwtPnd3biA9IHd3bjsKKworCXJldHVybiAoc2l6ZW9mKHN0cnVjdCBjdF9oZHJfcykgKyBzaXplb2YoZmNnc19nbWFsX3JlcV90KSk7Cit9CisKKy8qCisgKiBHRk4gKEdldCBGYWJyaWMgTmFtZSkgUmVxdWVzdAorICovCit1MTYKK2ZjX2dmbl9yZXFfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsIHd3bl90IHd3bikKK3sKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkOworCWZjZ3NfZ2ZuX3JlcV90ICpnZm4gPSAoZmNnc19nZm5fcmVxX3QgKikgKGN0aGRyICsgMSk7CisJdTMyICAgICAgICBkX2lkID0gYmZhX29zX2h0b24zYihGQ19NR01UX1NFUlZFUik7CisKKwlmY19nc19mY2hkcl9idWlsZChmY2hzLCBkX2lkLCBzX2lkLCAwKTsKKwlmY19nc19tc19jdGhkcl9idWlsZChjdGhkciwgc19pZCwgR1NfRkNfR0ZOX0NNRCwKKwkJCUNUX0dTU1VCVFlQRV9DRkdTRVJWRVIpOworCisJYmZhX29zX21lbXNldChnZm4sIDAsIHNpemVvZihmY2dzX2dmbl9yZXFfdCkpOworCWdmbi0+d3duID0gd3duOworCisJcmV0dXJuIChzaXplb2Yoc3RydWN0IGN0X2hkcl9zKSArIHNpemVvZihmY2dzX2dmbl9yZXFfdCkpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9mY2J1aWxkLmggYi9kcml2ZXJzL3Njc2kvYmZhL2ZjYnVpbGQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40ZDI0ODQyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9mY2J1aWxkLmgKQEAgLTAsMCArMSwyNzMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKy8qCisgKiBmY2J1aWxkLmggLSBGQyBsaW5rIHNlcnZpY2UgZnJhbWUgYnVpbGRpbmcgYW5kIHBhcnNpbmcgcm91dGluZXMKKyAqLworCisjaWZuZGVmIF9fRkNCVUlMRF9IX18KKyNkZWZpbmUgX19GQ0JVSUxEX0hfXworCisjaW5jbHVkZSA8YmZhX29zX2luYy5oPgorI2luY2x1ZGUgPHByb3RvY29sL2ZjLmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvZmNwLmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvY3QuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3BvcnQuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3Bwb3J0Lmg+CisKKy8qCisgKiBVdGlsaXR5IE1hY3Jvcy9mdW5jdGlvbnMKKyAqLworCisjZGVmaW5lIGZjaWZfc29mX3NldChfaWZoZHIsIF9zb2YpCShfaWZoZHIpLT5zb2YgPSBGQ18gIyMgX3NvZgorI2RlZmluZSBmY2lmX2VvZl9zZXQoX2lmaGRyLCBfZW9mKQkoX2lmaGRyKS0+ZW9mID0gRkNfICMjIF9lb2YKKworI2RlZmluZSB3d25faXNfZXF1YWwoX3d3bjEsIF93d24yKQkJXAorCShtZW1jbXAoJihfd3duMSksICYoX3d3bjIpLCBzaXplb2Yod3duX3QpKSA9PSAwKQorCisjZGVmaW5lIGZjX3JvdW5kdXAoX2wsIF9zKSAoKChfbCkgKyAoKF9zKSAtIDEpKSAmIH4oKF9zKSAtIDEpKQorCisvKgorICogR2l2ZW4gdGhlIGZjIHJlc3BvbnNlIGxlbmd0aCwgdGhpcyByb3V0aW5lIHdpbGwgcmV0dXJuCisgKiB0aGUgbGVuZ3RoIG9mIHRoZSBhY3R1YWwgcGF5bG9hZCBieXRlcyBmb2xsb3dpbmcgdGhlIENUIGhlYWRlci4KKyAqCisgKiBBc3N1bWVzIHRoZSBpbnB1dCByZXNwb25zZSBsZW5ndGggZG9lcyBub3QgaW5jbHVkZSB0aGUgY3JjLCBlb2YsIGV0Yy4KKyAqLworc3RhdGljIGlubGluZSAgIHUzMgorZmNfZ2V0X2N0cmVzcF9weWxkX2xlbih1MzIgcmVzcF9sZW4pCit7CisJcmV0dXJuIChyZXNwX2xlbiAtIHNpemVvZihzdHJ1Y3QgY3RfaGRyX3MpKTsKK30KKworLyoKKyAqIENvbnZlcnQgYmZhIHNwZWVkIHRvIHJwc2Mgc3BlZWQgdmFsdWUuCisgKi8KK3N0YXRpYyBpbmxpbmUgZW51bSBiZmFfcHBvcnRfc3BlZWQKK2ZjX3Jwc2Nfb3BlcnNwZWVkX3RvX2JmYV9zcGVlZChlbnVtIGZjX3Jwc2Nfb3Bfc3BlZWRfcyBzcGVlZCkKK3sKKwlzd2l0Y2ggKHNwZWVkKSB7CisKKwljYXNlIFJQU0NfT1BfU1BFRURfMUc6CisJCXJldHVybiBCRkFfUFBPUlRfU1BFRURfMUdCUFM7CisKKwljYXNlIFJQU0NfT1BfU1BFRURfMkc6CisJCXJldHVybiBCRkFfUFBPUlRfU1BFRURfMkdCUFM7CisKKwljYXNlIFJQU0NfT1BfU1BFRURfNEc6CisJCXJldHVybiBCRkFfUFBPUlRfU1BFRURfNEdCUFM7CisKKwljYXNlIFJQU0NfT1BfU1BFRURfOEc6CisJCXJldHVybiBCRkFfUFBPUlRfU1BFRURfOEdCUFM7CisKKwlkZWZhdWx0OgorCQlyZXR1cm4gQkZBX1BQT1JUX1NQRUVEX1VOS05PV047CisJfQorfQorCisvKgorICogQ29udmVydCBSUFNDIHNwZWVkIHRvIGJmYSBzcGVlZCB2YWx1ZS4KKyAqLworc3RhdGljIGlubGluZSAgIGVudW0gZmNfcnBzY19vcF9zcGVlZF9zCitmY19iZmFfc3BlZWRfdG9fcnBzY19vcGVyc3BlZWQoZW51bSBiZmFfcHBvcnRfc3BlZWQgb3Bfc3BlZWQpCit7CisJc3dpdGNoIChvcF9zcGVlZCkgeworCisJY2FzZSBCRkFfUFBPUlRfU1BFRURfMUdCUFM6CisJCXJldHVybiBSUFNDX09QX1NQRUVEXzFHOworCisJY2FzZSBCRkFfUFBPUlRfU1BFRURfMkdCUFM6CisJCXJldHVybiBSUFNDX09QX1NQRUVEXzJHOworCisJY2FzZSBCRkFfUFBPUlRfU1BFRURfNEdCUFM6CisJCXJldHVybiBSUFNDX09QX1NQRUVEXzRHOworCisJY2FzZSBCRkFfUFBPUlRfU1BFRURfOEdCUFM6CisJCXJldHVybiBSUFNDX09QX1NQRUVEXzhHOworCisJZGVmYXVsdDoKKwkJcmV0dXJuIFJQU0NfT1BfU1BFRURfTk9UX0VTVDsKKwl9Cit9CitlbnVtIGZjX3BhcnNlX3N0YXR1cyB7CisJRkNfUEFSU0VfT0sgPSAwLAorCUZDX1BBUlNFX0ZBSUxVUkUgPSAxLAorCUZDX1BBUlNFX0JVU1kgPSAyLAorCUZDX1BBUlNFX0xFTl9JTlZBTCwKKwlGQ19QQVJTRV9BQ0NfSU5WQUwsCisJRkNfUEFSU0VfUFdXTl9OT1RfRVFVQUwsCisJRkNfUEFSU0VfTldXTl9OT1RfRVFVQUwsCisJRkNfUEFSU0VfUlhTWl9JTlZBTCwKKwlGQ19QQVJTRV9OT1RfRkNQLAorCUZDX1BBUlNFX09QQUZMQUdfSU5WQUwsCisJRkNfUEFSU0VfUlBBRkxBR19JTlZBTCwKKwlGQ19QQVJTRV9PUEFfSU5WQUwsCisJRkNfUEFSU0VfUlBBX0lOVkFMLAorCit9OworCitzdHJ1Y3QgZmNfdGVtcGxhdGVzX3MgeworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNfZWxzX3JlcTsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjX2Jsc19yZXE7CisJc3RydWN0IGZjX2xvZ2lfcyAgICAgIHBsb2dpOworCXN0cnVjdCBmY19ycnFfcyAgICAgICAgcnJxOworfTsKKwordm9pZCBmY2J1aWxkX2luaXQodm9pZCk7CisKK3UxNiBmY19mbG9naV9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfbG9naV9zICpmbG9naSwKKwkJCXUzMiBzX2lkLCB1MTYgb3hfaWQsIHd3bl90IHBvcnRfbmFtZSwKKwkJCXd3bl90IG5vZGVfbmFtZSwgdTE2IHBkdV9zaXplLCB1OCBzZXRfbnBpdiwKKwkJCXU4IHNldF9hdXRoLCB1MTYgbG9jYWxfYmJfY3JlZGl0cyk7Cit1MTYgZmNfZmRpc2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqYnVmLCBzdHJ1Y3QgZmNfbG9naV9zICpmbG9naSwKKwkJCXUzMiBzX2lkLCB1MTYgb3hfaWQsIHd3bl90IHBvcnRfbmFtZSwKKwkJCXd3bl90IG5vZGVfbmFtZSwgdTE2IHBkdV9zaXplKTsKK3UxNiBmY19mbG9naV9hY2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX2xvZ2lfcyAqZmxvZ2ksCisJCQl1MzIgc19pZCwgdTE2IG94X2lkLCB3d25fdCBwb3J0X25hbWUsCisJCQl3d25fdCBub2RlX25hbWUsIHUxNiBwZHVfc2l6ZSwKKwkJCXUxNiBsb2NhbF9iYl9jcmVkaXRzKTsKK3UxNiBmY19wbG9naV9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBkX2lkLAorCQkJdTMyIHNfaWQsIHUxNiBveF9pZCwgd3duX3QgcG9ydF9uYW1lLAorCQkJd3duX3Qgbm9kZV9uYW1lLCB1MTYgcGR1X3NpemUpOworZW51bSBmY19wYXJzZV9zdGF0dXMgZmNfcGxvZ2lfcGFyc2Uoc3RydWN0IGZjaHNfcyAqZmNocyk7Cit1MTYgZmNfYWJ0c19idWlsZChzdHJ1Y3QgZmNoc19zICpidWYsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCk7CitlbnVtIGZjX3BhcnNlX3N0YXR1cyBmY19hYnRzX3JzcF9wYXJzZShzdHJ1Y3QgZmNoc19zICpidWYsIGludCBsZW4pOwordTE2IGZjX3JycV9idWlsZChzdHJ1Y3QgZmNoc19zICpidWYsIHN0cnVjdCBmY19ycnFfcyAqcnJxLCB1MzIgZF9pZCwKKwkJCXUzMiBzX2lkLCB1MTYgb3hfaWQsIHUxNiBycnFfb3hpZCk7CitlbnVtIGZjX3BhcnNlX3N0YXR1cyBmY19ycnFfcnNwX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmJ1ZiwgaW50IGxlbik7Cit1MTYgZmNfcnNwbmlkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnBsZCwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQsIHU4ICpuYW1lKTsKK3UxNiBmY19yZnRpZF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBzX2lkLAorCQkJdTE2IG94X2lkLCBlbnVtIGJmYV9wb3J0X3JvbGUgcm9sZSk7Cit1MTYgZmNfcmZ0aWRfYnVpbGRfc29sKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLAorCQkJdTE2IG94X2lkLCB1OCAqZmM0X2JpdG1hcCwKKwkJCXUzMiBiaXRtYXBfc2l6ZSk7Cit1MTYgZmNfcmZmaWRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQsIHU4IGZjNF90eXBlLCB1OCBmYzRfZnRycyk7Cit1MTYgZmNfZ2lkcG5fYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQsIHd3bl90IHBvcnRfbmFtZSk7Cit1MTYgZmNfZ3BuaWRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcGxkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCwgdTMyIHBvcnRfaWQpOwordTE2IGZjX3Njcl9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfc2NyX3MgKnNjciwKKwkJCXU4IHNldF9icl9yZWcsIHUzMiBzX2lkLCB1MTYgb3hfaWQpOwordTE2IGZjX3Bsb2dpX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsIHUzMiBkX2lkLAorCQkJdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCXd3bl90IHBvcnRfbmFtZSwgd3duX3Qgbm9kZV9uYW1lLCB1MTYgcGR1X3NpemUpOworCit1MTYgZmNfYWRpc2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX2FkaXNjX3MgKmFkaXNjLAorCQkJdTMyIGRfaWQsIHUzMiBzX2lkLCB1MTYgb3hfaWQsCisJCQl3d25fdCBwb3J0X25hbWUsIHd3bl90IG5vZGVfbmFtZSk7CitlbnVtIGZjX3BhcnNlX3N0YXR1cyBmY19hZGlzY19wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpwbGQsCisJCQl1MzIgaG9zdF9kYXAsCisJCQl3d25fdCBub2RlX25hbWUsIHd3bl90IHBvcnRfbmFtZSk7CitlbnVtIGZjX3BhcnNlX3N0YXR1cyBmY19hZGlzY19yc3BfcGFyc2Uoc3RydWN0IGZjX2FkaXNjX3MgKmFkaXNjLCBpbnQgbGVuLAorCQkJd3duX3QgcG9ydF9uYW1lLCB3d25fdCBub2RlX25hbWUpOwordTE2IGZjX2FkaXNjX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfYWRpc2NfcyAqYWRpc2MsCisJCQl1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCXd3bl90IHBvcnRfbmFtZSwgd3duX3Qgbm9kZV9uYW1lKTsKK3UxNiBmY19sc19yanRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX2xzX3JqdF9zICpsc19yanQsCisJCQl1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCXU4IHJlYXNvbl9jb2RlLCB1OCByZWFzb25fY29kZV9leHBsKTsKK3UxNiBmY19sc19hY2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX2Vsc19jbWRfcyAqZWxzX2NtZCwKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkKTsKK3UxNiBmY19wcmxpX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnBsZCwgdTMyIGRfaWQsCisJCQl1MzIgc19pZCwgdTE2IG94X2lkKTsKK2VudW0gZmNfcGFyc2Vfc3RhdHVzIGZjX3BybGlfcnNwX3BhcnNlKHN0cnVjdCBmY19wcmxpX3MgKnBybGksIGludCBsZW4pOworCit1MTYgZmNfcHJsaV9hY2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcGxkLCB1MzIgZF9pZCwKKwkJCXUzMiBzX2lkLCB1MTYgb3hfaWQsCisJCQllbnVtIGJmYV9wb3J0X3JvbGUgcm9sZSk7Cit1MTYgZmNfcm5pZF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcm5pZF9jbWRfcyAqcm5pZCwKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkLAorCQkJdTMyIGRhdGFfZm9ybWF0KTsKK3UxNiBmY19ybmlkX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcm5pZF9hY2NfcyAqcm5pZF9hY2MsCisJCQl1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCXUzMiBkYXRhX2Zvcm1hdCwKKwkJCXN0cnVjdCBmY19ybmlkX2NvbW1vbl9pZF9kYXRhX3MgKmNvbW1vbl9pZF9kYXRhLAorCQkJc3RydWN0IGZjX3JuaWRfZ2VuZXJhbF90b3BvbG9neV9kYXRhX3MgKgorCQkJZ2VuX3RvcG9fZGF0YSk7Cit1MTYgZmNfcnBzYzJfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX3Jwc2MyX2NtZF9zICpycHMyYywKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUzMiAqcGlkX2xpc3QsIHUxNiBucGlkcyk7Cit1MTYgZmNfcnBzY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcnBzY19jbWRfcyAqcnBzYywKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkKTsKK3UxNiBmY19ycHNjX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfcnBzY19hY2NfcyAqcnBzY19hY2MsCisJCQl1MzIgZF9pZCwgdTMyIHNfaWQsIHUxNiBveF9pZCwKKwkJCXN0cnVjdCBmY19ycHNjX3NwZWVkX2luZm9fcyAqb3Blcl9zcGVlZCk7Cit1MTYgZmNfZ2lkX2Z0X2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnBsZCwgdTMyIHNfaWQsCisJCQl1OCBmYzRfdHlwZSk7Cit1MTYgZmNfcnBuaWRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsCisJCQl1MzIgcG9ydF9pZCwgd3duX3QgcG9ydF9uYW1lKTsKK3UxNiBmY19ybm5pZF9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpweWxkLCB1MzIgc19pZCwKKwkJCXUzMiBwb3J0X2lkLCB3d25fdCBub2RlX25hbWUpOwordTE2IGZjX3Jjc2lkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLAorCQkJdTMyIHBvcnRfaWQsIHUzMiBjb3MpOwordTE2IGZjX3JwdGlkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLAorCQkJdTMyIHBvcnRfaWQsIHU4IHBvcnRfdHlwZSk7Cit1MTYgZmNfZ2FueHRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsCisJCQl1MzIgcG9ydF9pZCk7Cit1MTYgZmNfbG9nb19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfbG9nb19zICpsb2dvLAorCQkJdTMyIGRfaWQsIHUzMiBzX2lkLCB1MTYgb3hfaWQsCisJCQl3d25fdCBwb3J0X25hbWUpOwordTE2IGZjX2xvZ29fYWNjX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnBsZCwgdTMyIGRfaWQsCisJCQl1MzIgc19pZCwgdTE2IG94X2lkKTsKK3UxNiBmY19mZG1pX3JlcWhkcl9idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB2b2lkICpweWxkLCB1MzIgc19pZCwKKwkJCXUxNiBjbWRfY29kZSk7Cit1MTYgZmNfZ21hbF9yZXFfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsCisJCQl3d25fdCB3d24pOwordTE2IGZjX2dmbl9yZXFfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdm9pZCAqcHlsZCwgdTMyIHNfaWQsCisJCQl3d25fdCB3d24pOwordm9pZCBmY19nZXRfZmM0dHlwZV9iaXRtYXNrKHU4IGZjNF90eXBlLCB1OCAqYml0X21hc2spOwordm9pZCBmY19lbHNfcmVxX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCk7CitlbnVtIGZjX3BhcnNlX3N0YXR1cyBmY19lbHNfcnNwX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmZjaHMsIGludCBsZW4pOworZW51bSBmY19wYXJzZV9zdGF0dXMgZmNfcGxvZ2lfcnNwX3BhcnNlKHN0cnVjdCBmY2hzX3MgKmZjaHMsIGludCBsZW4sCisJCQkgd3duX3QgcG9ydF9uYW1lKTsKK2VudW0gZmNfcGFyc2Vfc3RhdHVzIGZjX3BybGlfcGFyc2Uoc3RydWN0IGZjX3BybGlfcyAqcHJsaSk7CitlbnVtIGZjX3BhcnNlX3N0YXR1cyBmY19wZGlzY19wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCB3d25fdCBub2RlX25hbWUsCisJCQl3d25fdCBwb3J0X25hbWUpOwordTE2IGZjX2JhX2FjY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCBzdHJ1Y3QgZmNfYmFfYWNjX3MgKmJhX2FjYywKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkLAorCQkJdTE2IHJ4X2lkKTsKK2ludCBmY19sb2dvdXRfcGFyYW1zX3BhZ2VzKHN0cnVjdCBmY2hzX3MgKmZjX2ZyYW1lLCB1OCBlbHNfY29kZSk7Cit1MTYgZmNfdHBybG9fYWNjX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsCisJCQlzdHJ1Y3QgZmNfdHBybG9fYWNjX3MgKnRwcmxvX2FjYywKKwkJCXUzMiBkX2lkLCB1MzIgc19pZCwgdTE2IG94X2lkLAorCQkJaW50IG51bV9wYWdlcyk7Cit1MTYgZmNfcHJsb19hY2NfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX3BybG9fYWNjX3MgKnBybG9fYWNjLAorCQkJdTMyIGRfaWQsIHUzMiBzX2lkLCB1MTYgb3hfaWQsCisJCQlpbnQgbnVtX3BhZ2VzKTsKK3UxNiBmY19sb2dvX3JzcF9wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCBpbnQgbGVuKTsKK3UxNiBmY19wZGlzY19idWlsZChzdHJ1Y3QgZmNoc19zICpmY2hzLCB1MzIgZF9pZCwgdTMyIHNfaWQsCisJCQl1MTYgb3hfaWQsIHd3bl90IHBvcnRfbmFtZSwgd3duX3Qgbm9kZV9uYW1lLAorCQkJdTE2IHBkdV9zaXplKTsKK3UxNiBmY19wZGlzY19yc3BfcGFyc2Uoc3RydWN0IGZjaHNfcyAqZmNocywgaW50IGxlbiwgd3duX3QgcG9ydF9uYW1lKTsKK3UxNiBmY19wcmxvX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUzMiBkX2lkLCB1MzIgc19pZCwKKwkJCXUxNiBveF9pZCwgaW50IG51bV9wYWdlcyk7Cit1MTYgZmNfcHJsb19yc3BfcGFyc2Uoc3RydWN0IGZjaHNfcyAqZmNocywgaW50IGxlbik7Cit1MTYgZmNfdHBybG9fYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdTMyIGRfaWQsIHUzMiBzX2lkLAorCQkJdTE2IG94X2lkLCBpbnQgbnVtX3BhZ2VzLAorCQkJZW51bSBmY190cHJsb190eXBlIHRwcmxvX3R5cGUsIHUzMiB0cHJfaWQpOwordTE2IGZjX3RwcmxvX3JzcF9wYXJzZShzdHJ1Y3QgZmNoc19zICpmY2hzLCBpbnQgbGVuKTsKK3UxNiBmY19iYV9yanRfYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgdTMyIGRfaWQsIHUzMiBzX2lkLAorCQkJdTE2IG94X2lkLCB1MzIgcmVhc29uX2NvZGUsCisJCQl1MzIgcmVhc29uX2V4cGwpOwordTE2IGZjX2dubmlkX2J1aWxkKHN0cnVjdCBmY2hzX3MgKmZjaHMsIHZvaWQgKnB5bGQsIHUzMiBzX2lkLAorCQkJdTE2IG94X2lkLCB1MzIgcG9ydF9pZCk7Cit1MTYgZmNfY3RfcnNwX3BhcnNlKHN0cnVjdCBjdF9oZHJfcyAqY3RoZHIpOwordTE2IGZjX3JzY25fYnVpbGQoc3RydWN0IGZjaHNfcyAqZmNocywgc3RydWN0IGZjX3JzY25fcGxfcyAqcnNjbiwKKwkJCXUzMiBzX2lkLCB1MTYgb3hfaWQpOworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2ZjcGltLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2ZjcGltLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGNlNWQ4OTMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2ZjcGltLmMKQEAgLTAsMCArMSw4NDQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgZmNwaW0uYyAtIEZDUCBpbml0aWF0b3IgbW9kZSBpLXQgbmV4dXMgc3RhdGUgbWFjaGluZQorICovCisKKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSAiZmNzX2ZjcGltLmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImZjc19mY3hwLmgiCisjaW5jbHVkZSAiZmNzLmgiCisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfZmNwaW0uaD4KKyNpbmNsdWRlIDxmY2IvYmZhX2ZjYl9mY3BpbS5oPgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuX2l0bmltLmg+CisKK0JGQV9UUkNfRklMRShGQ1MsIEZDUElNKTsKKworLyoKKyAqIGZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2l0bmltX3RpbWVvdXQodm9pZCAqYXJnKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2l0bmltX2ZyZWUoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfaXRuaW1fc2VuZF9wcmxpKHZvaWQgKml0bmltX2NiYXJnLAorCQkJCQlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2l0bmltX3BybGlfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkgICAgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkJCSAgICB2b2lkICpjYmFyZywKKwkJCQkJICAgIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkgICAgdTMyIHJzcF9sZW4sCisJCQkJCSAgICB1MzIgcmVzaWRfbGVuLAorCQkJCQkgICAgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfaXRuaW1fYWVuX3Bvc3Qoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0sCisJCQkJICAgICAgIGVudW0gYmZhX2l0bmltX2Flbl9ldmVudCBldmVudCk7CisKKy8qKgorICogIGZjc19pdG5pbV9zbSBGQ1MgaXRuaW0gc3RhdGUgbWFjaGluZSBldmVudHMKKyAqLworCitlbnVtIGJmYV9mY3NfaXRuaW1fZXZlbnQgeworCUJGQV9GQ1NfSVROSU1fU01fT05MSU5FID0gMSwJLyogIHJwb3J0IG9ubGluZSBldmVudCAqLworCUJGQV9GQ1NfSVROSU1fU01fT0ZGTElORSA9IDIsCS8qICBycG9ydCBvZmZsaW5lICovCisJQkZBX0ZDU19JVE5JTV9TTV9GUk1TRU5UID0gMywJLyogIHBybGkgZnJhbWUgaXMgc2VudCAqLworCUJGQV9GQ1NfSVROSU1fU01fUlNQX09LID0gNCwJLyogIGdvb2QgcmVzcG9uc2UgKi8KKwlCRkFfRkNTX0lUTklNX1NNX1JTUF9FUlJPUiA9IDUsCS8qICBlcnJvciByZXNwb25zZSAqLworCUJGQV9GQ1NfSVROSU1fU01fVElNRU9VVCA9IDYsCS8qICBkZWxheSB0aW1lb3V0ICovCisJQkZBX0ZDU19JVE5JTV9TTV9IQ0JfT0ZGTElORSA9IDcsCS8qICBCRkEgb25saW5lIGNhbGxiYWNrICovCisJQkZBX0ZDU19JVE5JTV9TTV9IQ0JfT05MSU5FID0gOCwJLyogIEJGQSBvZmZsaW5lIGNhbGxiYWNrICovCisJQkZBX0ZDU19JVE5JTV9TTV9JTklUSUFUT1IgPSA5LAkvKiAgcnBvcnQgaXMgaW5pdGlhdG9yICovCisJQkZBX0ZDU19JVE5JTV9TTV9ERUxFVEUgPSAxMCwJLyogIGRlbGV0ZSBldmVudCBmcm9tIHJwb3J0ICovCisJQkZBX0ZDU19JVE5JTV9TTV9QUkxPID0gMTEsCS8qICBkZWxldGUgZXZlbnQgZnJvbSBycG9ydCAqLworfTsKKworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfaXRuaW1fc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwKKwkJCQkJIGVudW0gYmZhX2Zjc19pdG5pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19pdG5pbV9zbV9wcmxpX3NlbmQoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0sCisJCQkJCSAgIGVudW0gYmZhX2Zjc19pdG5pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19pdG5pbV9zbV9wcmxpKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltLAorCQkJCSAgICAgIGVudW0gYmZhX2Zjc19pdG5pbV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19pdG5pbV9zbV9wcmxpX3JldHJ5KHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltLAorCQkJCQkgICAgZW51bSBiZmFfZmNzX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2l0bmltX3NtX2hjYl9vbmxpbmUoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0sCisJCQkJCSAgICBlbnVtIGJmYV9mY3NfaXRuaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfaXRuaW1fc21fb25saW5lKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltLAorCQkJCQllbnVtIGJmYV9mY3NfaXRuaW1fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfaXRuaW1fc21faGNiX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0sCisJCQkJCSAgICAgZW51bSBiZmFfZmNzX2l0bmltX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX2l0bmltX3NtX2luaXRpYXRvcihzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwKKwkJCQkJICAgZW51bSBiZmFfZmNzX2l0bmltX2V2ZW50IGV2ZW50KTsKKworc3RhdGljIHN0cnVjdCBiZmFfc21fdGFibGVfcyBpdG5pbV9zbV90YWJsZVtdID0geworCXtCRkFfU00oYmZhX2Zjc19pdG5pbV9zbV9vZmZsaW5lKSwgQkZBX0lUTklNX09GRkxJTkV9LAorCXtCRkFfU00oYmZhX2Zjc19pdG5pbV9zbV9wcmxpX3NlbmQpLCBCRkFfSVROSU1fUFJMSV9TRU5EfSwKKwl7QkZBX1NNKGJmYV9mY3NfaXRuaW1fc21fcHJsaSksIEJGQV9JVE5JTV9QUkxJX1NFTlR9LAorCXtCRkFfU00oYmZhX2Zjc19pdG5pbV9zbV9wcmxpX3JldHJ5KSwgQkZBX0lUTklNX1BSTElfUkVUUll9LAorCXtCRkFfU00oYmZhX2Zjc19pdG5pbV9zbV9oY2Jfb25saW5lKSwgQkZBX0lUTklNX0hDQl9PTkxJTkV9LAorCXtCRkFfU00oYmZhX2Zjc19pdG5pbV9zbV9vbmxpbmUpLCBCRkFfSVROSU1fT05MSU5FfSwKKwl7QkZBX1NNKGJmYV9mY3NfaXRuaW1fc21faGNiX29mZmxpbmUpLCBCRkFfSVROSU1fSENCX09GRkxJTkV9LAorCXtCRkFfU00oYmZhX2Zjc19pdG5pbV9zbV9pbml0aWF0b3IpLCBCRkFfSVROSU1fSU5JVElBVElPUn0sCit9OworCisvKioKKyAqICBmY3NfaXRuaW1fc20gRkNTIGl0bmltIHN0YXRlIG1hY2hpbmUKKyAqLworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19pdG5pbV9zbV9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltLAorCQkJIGVudW0gYmZhX2Zjc19pdG5pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGl0bmltLT5mY3MsIGl0bmltLT5ycG9ydC0+cHd3bik7CisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX09OTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9wcmxpX3NlbmQpOworCQliZmFfZmNzX2l0bmltX3NlbmRfcHJsaShpdG5pbSwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX09GRkxJTkU6CisJCWJmYV9mY3NfcnBvcnRfaXRuaW1fYWNrKGl0bmltLT5ycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX0lOSVRJQVRPUjoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9pbml0aWF0b3IpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9ERUxFVEU6CisJCWJmYV9mY3NfaXRuaW1fZnJlZShpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9CisKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfaXRuaW1fc21fcHJsaV9zZW5kKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltLAorCQkJICAgZW51bSBiZmFfZmNzX2l0bmltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaXRuaW0tPmZjcywgaXRuaW0tPnJwb3J0LT5wd3duKTsKKwliZmFfdHJjKGl0bmltLT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fRlJNU0VOVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9wcmxpKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fSU5JVElBVE9SOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX2luaXRpYXRvcik7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoaXRuaW0tPmZjcy0+YmZhLCAmaXRuaW0tPmZjeHBfd3FlKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChpdG5pbS0+ZmNzLT5iZmEsICZpdG5pbS0+ZmN4cF93cWUpOworCQliZmFfZmNzX3Jwb3J0X2l0bmltX2FjayhpdG5pbS0+cnBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9mY3NfaXRuaW1fc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoaXRuaW0tPmZjcy0+YmZhLCAmaXRuaW0tPmZjeHBfd3FlKTsKKwkJYmZhX2Zjc19pdG5pbV9mcmVlKGl0bmltKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfaXRuaW1fc21fcHJsaShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwKKwkJICAgICAgZW51bSBiZmFfZmNzX2l0bmltX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoaXRuaW0tPmZjcywgaXRuaW0tPnJwb3J0LT5wd3duKTsKKwliZmFfdHJjKGl0bmltLT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fUlNQX09LOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX2hjYl9vbmxpbmUpOworCQliZmFfaXRuaW1fb25saW5lKGl0bmltLT5iZmFfaXRuaW0sIGl0bmltLT5zZXFfcmVjKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fUlNQX0VSUk9SOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX3BybGlfcmV0cnkpOworCQliZmFfdGltZXJfc3RhcnQoaXRuaW0tPmZjcy0+YmZhLCAmaXRuaW0tPnRpbWVyLAorCQkJCWJmYV9mY3NfaXRuaW1fdGltZW91dCwgaXRuaW0sCisJCQkJQkZBX0ZDU19SRVRSWV9USU1FT1VUKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChpdG5pbS0+ZmN4cCk7CisJCWJmYV9mY3NfcnBvcnRfaXRuaW1fYWNrKGl0bmltLT5ycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX0lOSVRJQVRPUjoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9pbml0aWF0b3IpOworCQkvKgorCQkgKiBkb250IGRpc2NhcmQgZmN4cC4gYWNjZXB0IHdpbGwgcmVhY2ggc2FtZSBzdGF0ZQorCQkgKi8KKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF9kaXNjYXJkKGl0bmltLT5mY3hwKTsKKwkJYmZhX2Zjc19pdG5pbV9mcmVlKGl0bmltKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfaXRuaW1fc21fcHJsaV9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwKKwkJCSAgICBlbnVtIGJmYV9mY3NfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBpdG5pbS0+cnBvcnQtPnB3d24pOworCWJmYV90cmMoaXRuaW0tPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9USU1FT1VUOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX3BybGlfc2VuZCk7CisJCWJmYV9mY3NfaXRuaW1fc2VuZF9wcmxpKGl0bmltLCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJml0bmltLT50aW1lcik7CisJCWJmYV9mY3NfcnBvcnRfaXRuaW1fYWNrKGl0bmltLT5ycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX0lOSVRJQVRPUjoKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9pbml0aWF0b3IpOworCQliZmFfdGltZXJfc3RvcCgmaXRuaW0tPnRpbWVyKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX29mZmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmaXRuaW0tPnRpbWVyKTsKKwkJYmZhX2Zjc19pdG5pbV9mcmVlKGl0bmltKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfaXRuaW1fc21faGNiX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwKKwkJCSAgICBlbnVtIGJmYV9mY3NfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBpdG5pbS0+cnBvcnQtPnB3d24pOworCWJmYV90cmMoaXRuaW0tPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9IQ0JfT05MSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX29ubGluZSk7CisJCWJmYV9mY2JfaXRuaW1fb25saW5lKGl0bmltLT5pdG5pbV9kcnYpOworCQliZmFfZmNzX2l0bmltX2Flbl9wb3N0KGl0bmltLCBCRkFfSVROSU1fQUVOX09OTElORSk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9mY3NfaXRuaW1fc21fb2ZmbGluZSk7CisJCWJmYV9pdG5pbV9vZmZsaW5lKGl0bmltLT5iZmFfaXRuaW0pOworCQliZmFfZmNzX3Jwb3J0X2l0bmltX2FjayhpdG5pbS0+cnBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9mY3NfaXRuaW1fc21fb2ZmbGluZSk7CisJCWJmYV9mY3NfaXRuaW1fZnJlZShpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX2l0bmltX3NtX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwKKwkJCWVudW0gYmZhX2Zjc19pdG5pbV9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKGl0bmltLT5mY3MsIGl0bmltLT5ycG9ydC0+cHd3bik7CisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9mY3NfaXRuaW1fc21faGNiX29mZmxpbmUpOworCQliZmFfZmNiX2l0bmltX29mZmxpbmUoaXRuaW0tPml0bmltX2Rydik7CisJCWJmYV9pdG5pbV9vZmZsaW5lKGl0bmltLT5iZmFfaXRuaW0pOworCQlpZiAoYmZhX2Zjc19wb3J0X2lzX29ubGluZShpdG5pbS0+cnBvcnQtPnBvcnQpID09IEJGQV9UUlVFKSB7CisJCQliZmFfZmNzX2l0bmltX2Flbl9wb3N0KGl0bmltLCBCRkFfSVROSU1fQUVOX0RJU0NPTk5FQ1QpOworCQl9IGVsc2UgeworCQkJYmZhX2Zjc19pdG5pbV9hZW5fcG9zdChpdG5pbSwgQkZBX0lUTklNX0FFTl9PRkZMSU5FKTsKKwkJfQorCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9mY3NfaXRuaW1fc21fb2ZmbGluZSk7CisJCWJmYV9mY3NfaXRuaW1fZnJlZShpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX2l0bmltX3NtX2hjYl9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltLAorCQkJICAgICBlbnVtIGJmYV9mY3NfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBpdG5pbS0+cnBvcnQtPnB3d24pOworCWJmYV90cmMoaXRuaW0tPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9IQ0JfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9vZmZsaW5lKTsKKwkJYmZhX2Zjc19ycG9ydF9pdG5pbV9hY2soaXRuaW0tPnJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX29mZmxpbmUpOworCQliZmFfZmNzX2l0bmltX2ZyZWUoaXRuaW0pOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKgorICogVGhpcyBzdGF0ZSBpcyBzZXQgd2hlbiBhIGRpc2NvdmVyZWQgcnBvcnQgaXMgYWxzbyBpbiBpbnRpYXRvciBtb2RlLgorICogVGhpcyBJVE4gaXMgbWFya2VkIGFzIG5vX29wIGFuZCBpcyBub3QgYWN0aXZlIGFuZCB3aWxsIG5vdCBiZSB0cnVuZWQgaW50bworICogb25saW5lIHN0YXRlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19pdG5pbV9zbV9pbml0aWF0b3Ioc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0sCisJCQkgICBlbnVtIGJmYV9mY3NfaXRuaW1fZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBpdG5pbS0+cnBvcnQtPnB3d24pOworCWJmYV90cmMoaXRuaW0tPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKGl0bmltLCBiZmFfZmNzX2l0bmltX3NtX29mZmxpbmUpOworCQliZmFfZmNzX3Jwb3J0X2l0bmltX2FjayhpdG5pbS0+cnBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9SU1BfRVJST1I6CisJY2FzZSBCRkFfRkNTX0lUTklNX1NNX09OTElORToKKwljYXNlIEJGQV9GQ1NfSVROSU1fU01fSU5JVElBVE9SOgorCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19JVE5JTV9TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUoaXRuaW0sIGJmYV9mY3NfaXRuaW1fc21fb2ZmbGluZSk7CisJCWJmYV9mY3NfaXRuaW1fZnJlZShpdG5pbSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBpdG5pbV9wcml2YXRlIEZDUyBJVE5JTSBwcml2YXRlIGludGVyZmFjZXMKKyAqLworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19pdG5pbV9hZW5fcG9zdChzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwKKwkJICAgICAgIGVudW0gYmZhX2l0bmltX2Flbl9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IGl0bmltLT5ycG9ydDsKKwl1bmlvbiBiZmFfYWVuX2RhdGFfdSBhZW5fZGF0YTsKKwlzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbW9kID0gcnBvcnQtPmZjcy0+bG9nbTsKKwl3d25fdCAgICAgICAgICAgbHB3d24gPSBiZmFfZmNzX3BvcnRfZ2V0X3B3d24ocnBvcnQtPnBvcnQpOworCXd3bl90ICAgICAgICAgICBycHd3biA9IHJwb3J0LT5wd3duOworCWNoYXIgICAgICAgICAgICBscHd3bl9wdHJbQkZBX1NUUklOR18zMl07CisJY2hhciAgICAgICAgICAgIHJwd3duX3B0cltCRkFfU1RSSU5HXzMyXTsKKworCS8qCisJICogRG9uJ3QgcG9zdCBldmVudHMgZm9yIHdlbGwga25vd24gYWRkcmVzc2VzCisJICovCisJaWYgKEJGQV9GQ1NfUElEX0lTX1dLQShycG9ydC0+cGlkKSkKKwkJcmV0dXJuOworCisJd3duMnN0cihscHd3bl9wdHIsIGxwd3duKTsKKwl3d24yc3RyKHJwd3duX3B0ciwgcnB3d24pOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0lUTklNX0FFTl9PTkxJTkU6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX0lUTklNX09OTElORSwgcnB3d25fcHRyLCBscHd3bl9wdHIpOworCQlicmVhazsKKwljYXNlIEJGQV9JVE5JTV9BRU5fT0ZGTElORToKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fSVROSU1fT0ZGTElORSwgcnB3d25fcHRyLCBscHd3bl9wdHIpOworCQlicmVhazsKKwljYXNlIEJGQV9JVE5JTV9BRU5fRElTQ09OTkVDVDoKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fSVROSU1fRElTQ09OTkVDVCwgcnB3d25fcHRyLCBscHd3bl9wdHIpOworCQlicmVhazsKKwlkZWZhdWx0OgorCQlicmVhazsKKwl9CisKKwlhZW5fZGF0YS5pdG5pbS52Zl9pZCA9IHJwb3J0LT5wb3J0LT5mYWJyaWMtPnZmX2lkOworCWFlbl9kYXRhLml0bmltLnBwd3duID0KKwkJYmZhX2Zjc19wb3J0X2dldF9wd3duKGJmYV9mY3NfZ2V0X2Jhc2VfcG9ydChpdG5pbS0+ZmNzKSk7CisJYWVuX2RhdGEuaXRuaW0ubHB3d24gPSBscHd3bjsKKwlhZW5fZGF0YS5pdG5pbS5ycHd3biA9IHJwd3duOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19pdG5pbV9zZW5kX3BybGkodm9pZCAqaXRuaW1fY2JhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpCit7CisJc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0gPSBpdG5pbV9jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IGl0bmltLT5ycG9ydDsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBycG9ydC0+cG9ydDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJaW50ICAgICAgICAgICAgIGxlbjsKKworCWJmYV90cmMoaXRuaW0tPmZjcywgaXRuaW0tPnJwb3J0LT5wd3duKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJaXRuaW0tPnN0YXRzLmZjeHBfYWxsb2Nfd2FpdCsrOworCQliZmFfZmN4cF9hbGxvY193YWl0KHBvcnQtPmZjcy0+YmZhLCAmaXRuaW0tPmZjeHBfd3FlLAorCQkJCSAgICBiZmFfZmNzX2l0bmltX3NlbmRfcHJsaSwgaXRuaW0pOworCQlyZXR1cm47CisJfQorCWl0bmltLT5mY3hwID0gZmN4cDsKKworCWxlbiA9IGZjX3BybGlfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksIGl0bmltLT5ycG9ydC0+cGlkLAorCQkJICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgMCk7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIHJwb3J0LT5iZmFfcnBvcnQsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywKKwkJICAgICAgQkZBX0ZBTFNFLCBGQ19DTEFTU18zLCBsZW4sICZmY2hzLAorCQkgICAgICBiZmFfZmNzX2l0bmltX3BybGlfcmVzcG9uc2UsICh2b2lkICopaXRuaW0sIEZDX01BWF9QRFVTWiwKKwkJICAgICAgRkNfUkFfVE9WKTsKKworCWl0bmltLT5zdGF0cy5wcmxpX3NlbnQrKzsKKwliZmFfc21fc2VuZF9ldmVudChpdG5pbSwgQkZBX0ZDU19JVE5JTV9TTV9GUk1TRU5UKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfaXRuaW1fcHJsaV9yZXNwb25zZSh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCB2b2lkICpjYmFyZywKKwkJCSAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywgdTMyIHJzcF9sZW4sCisJCQkgICAgdTMyIHJlc2lkX2xlbiwgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0gPSAoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqKWNiYXJnOworCXN0cnVjdCBmY19lbHNfY21kX3MgICAqZWxzX2NtZDsKKwlzdHJ1Y3QgZmNfcHJsaV9zICAgICAgKnBybGlfcmVzcDsKKwlzdHJ1Y3QgZmNfbHNfcmp0X3MgICAgKmxzX3JqdDsKKwlzdHJ1Y3QgZmNfcHJsaV9wYXJhbXNfcyAqc3BhcmFtczsKKworCWJmYV90cmMoaXRuaW0tPmZjcywgcmVxX3N0YXR1cyk7CisKKwkvKgorCSAqIFNhbml0eSBDaGVja3MKKwkgKi8KKwlpZiAocmVxX3N0YXR1cyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWl0bmltLT5zdGF0cy5wcmxpX3JzcF9lcnIrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9GQ1NfSVROSU1fU01fUlNQX0VSUk9SKTsKKwkJcmV0dXJuOworCX0KKworCWVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSBCRkFfRkNYUF9SU1BfUExEKGZjeHApOworCisJaWYgKGVsc19jbWQtPmVsc19jb2RlID09IEZDX0VMU19BQ0MpIHsKKwkJcHJsaV9yZXNwID0gKHN0cnVjdCBmY19wcmxpX3MgKikgZWxzX2NtZDsKKworCQlpZiAoZmNfcHJsaV9yc3BfcGFyc2UocHJsaV9yZXNwLCByc3BfbGVuKSAhPSBGQ19QQVJTRV9PSykgeworCQkJYmZhX3RyYyhpdG5pbS0+ZmNzLCByc3BfbGVuKTsKKwkJCS8qCisJCQkgKiBDaGVjayBpZiB0aGlzICByLXBvcnQgaXMgYWxzbyBpbiBJbml0aWF0b3IgbW9kZS4KKwkJCSAqIElmIHNvLCB3ZSBuZWVkIHRvIHNldCB0aGlzIElUTiBhcyBhIG5vLW9wLgorCQkJICovCisJCQlpZiAocHJsaV9yZXNwLT5wYXJhbXBhZ2Uuc2VydnBhcmFtcy5pbml0aWF0b3IpIHsKKwkJCQliZmFfdHJjKGl0bmltLT5mY3MsIHBybGlfcmVzcC0+cGFyYW1wYWdlLnR5cGUpOworCQkJCWl0bmltLT5ycG9ydC0+c2NzaV9mdW5jdGlvbiA9CisJCQkJCUJGQV9SUE9SVF9JTklUSUFUT1I7CisJCQkJaXRuaW0tPnN0YXRzLnBybGlfcnNwX2FjYysrOworCQkJCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLAorCQkJCQkJICBCRkFfRkNTX0lUTklNX1NNX0lOSVRJQVRPUik7CisJCQkJcmV0dXJuOworCQkJfQorCisJCQlpdG5pbS0+c3RhdHMucHJsaV9yc3BfcGFyc2VfZXJyKys7CisJCQlyZXR1cm47CisJCX0KKwkJaXRuaW0tPnJwb3J0LT5zY3NpX2Z1bmN0aW9uID0gQkZBX1JQT1JUX1RBUkdFVDsKKworCQlzcGFyYW1zID0gJnBybGlfcmVzcC0+cGFyYW1wYWdlLnNlcnZwYXJhbXM7CisJCWl0bmltLT5zZXFfcmVjID0gc3BhcmFtcy0+cmV0cnk7CisJCWl0bmltLT5yZWNfc3VwcG9ydCA9IHNwYXJhbXMtPnJlY19zdXBwb3J0OworCQlpdG5pbS0+dGFza19yZXRyeV9pZCA9IHNwYXJhbXMtPnRhc2tfcmV0cnlfaWQ7CisJCWl0bmltLT5jb25mX2NvbXAgPSBzcGFyYW1zLT5jb25maXJtOworCisJCWl0bmltLT5zdGF0cy5wcmxpX3JzcF9hY2MrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9GQ1NfSVROSU1fU01fUlNQX09LKTsKKwl9IGVsc2UgeworCQlsc19yanQgPSAoc3RydWN0IGZjX2xzX3JqdF9zICopIEJGQV9GQ1hQX1JTUF9QTEQoZmN4cCk7CisKKwkJYmZhX3RyYyhpdG5pbS0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlKTsKKwkJYmZhX3RyYyhpdG5pbS0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlX2V4cGwpOworCisJCWl0bmltLT5zdGF0cy5wcmxpX3JzcF9yanQrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9GQ1NfSVROSU1fU01fUlNQX0VSUk9SKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX2l0bmltX3RpbWVvdXQodm9pZCAqYXJnKQoreworCXN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltID0gKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKilhcmc7CisKKwlpdG5pbS0+c3RhdHMudGltZW91dCsrOworCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfRkNTX0lUTklNX1NNX1RJTUVPVVQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19pdG5pbV9mcmVlKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworCWJmYV9pdG5pbV9kZWxldGUoaXRuaW0tPmJmYV9pdG5pbSk7CisJYmZhX2ZjYl9pdG5pbV9mcmVlKGl0bmltLT5mY3MtPmJmYWQsIGl0bmltLT5pdG5pbV9kcnYpOworfQorCisKKworLyoqCisgKiAgaXRuaW1fcHVibGljIEZDUyBJVE5JTSBwdWJsaWMgaW50ZXJmYWNlcworICovCisKKy8qKgorICogCUNhbGxlZCBieSBycG9ydCB3aGVuIGEgbmV3IHJwb3J0IGlzIGNyZWF0ZWQuCisgKgorICogQHBhcmFtW2luXSBycG9ydAktICByZW1vdGUgcG9ydC4KKyAqLworc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqCitiZmFfZmNzX2l0bmltX2NyZWF0ZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBycG9ydC0+cG9ydDsKKwlzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbTsKKwlzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbV9kcnY7CisJc3RydWN0IGJmYV9pdG5pbV9zICpiZmFfaXRuaW07CisKKwkvKgorCSAqIGNhbGwgYmZhZCB0byBhbGxvY2F0ZSB0aGUgaXRuaW0KKwkgKi8KKwliZmFfZmNiX2l0bmltX2FsbG9jKHBvcnQtPmZjcy0+YmZhZCwgJml0bmltLCAmaXRuaW1fZHJ2KTsKKwlpZiAoaXRuaW0gPT0gTlVMTCkgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwkvKgorCSAqIEluaXRpYWxpemUgaXRuaW0KKwkgKi8KKwlpdG5pbS0+cnBvcnQgPSBycG9ydDsKKwlpdG5pbS0+ZmNzID0gcnBvcnQtPmZjczsKKwlpdG5pbS0+aXRuaW1fZHJ2ID0gaXRuaW1fZHJ2OworCisJLyoKKwkgKiBjYWxsIEJGQSB0byBjcmVhdGUgdGhlIGl0bmltCisJICovCisJYmZhX2l0bmltID0gYmZhX2l0bmltX2NyZWF0ZShwb3J0LT5mY3MtPmJmYSwgcnBvcnQtPmJmYV9ycG9ydCwgaXRuaW0pOworCisJaWYgKGJmYV9pdG5pbSA9PSBOVUxMKSB7CisJCWJmYV90cmMocG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJCWJmYV9mY2JfaXRuaW1fZnJlZShwb3J0LT5mY3MtPmJmYWQsIGl0bmltX2Rydik7CisJCWJmYV9hc3NlcnQoMCk7CisJCXJldHVybiBOVUxMOworCX0KKworCWl0bmltLT5iZmFfaXRuaW0gPSBiZmFfaXRuaW07CisJaXRuaW0tPnNlcV9yZWMgPSBCRkFfRkFMU0U7CisJaXRuaW0tPnJlY19zdXBwb3J0ID0gQkZBX0ZBTFNFOworCWl0bmltLT5jb25mX2NvbXAgPSBCRkFfRkFMU0U7CisJaXRuaW0tPnRhc2tfcmV0cnlfaWQgPSBCRkFfRkFMU0U7CisKKwkvKgorCSAqIFNldCBTdGF0ZSBtYWNoaW5lCisJICovCisJYmZhX3NtX3NldF9zdGF0ZShpdG5pbSwgYmZhX2Zjc19pdG5pbV9zbV9vZmZsaW5lKTsKKworCXJldHVybiBpdG5pbTsKK30KKworLyoqCisgKiAJQ2FsbGVkIGJ5IHJwb3J0IHRvIGRlbGV0ZSAgdGhlIGluc3RhbmNlIG9mIEZDUElNLgorICoKKyAqIEBwYXJhbVtpbl0gcnBvcnQJLSAgcmVtb3RlIHBvcnQuCisgKi8KK3ZvaWQKK2JmYV9mY3NfaXRuaW1fZGVsZXRlKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworCWJmYV90cmMoaXRuaW0tPmZjcywgaXRuaW0tPnJwb3J0LT5waWQpOworCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfRkNTX0lUTklNX1NNX0RFTEVURSk7Cit9CisKKy8qKgorICogTm90aWZpY2F0aW9uIGZyb20gcnBvcnQgdGhhdCBQTE9HSSBpcyBjb21wbGV0ZSB0byBpbml0aWF0ZSBGQy00IHNlc3Npb24uCisgKi8KK3ZvaWQKK2JmYV9mY3NfaXRuaW1fcnBvcnRfb25saW5lKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworCWl0bmltLT5zdGF0cy5vbmxpbmVzKys7CisKKwlpZiAoIUJGQV9GQ1NfUElEX0lTX1dLQShpdG5pbS0+cnBvcnQtPnBpZCkpIHsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9GQ1NfSVROSU1fU01fT05MSU5FKTsKKwl9IGVsc2UgeworCQkvKgorCQkgKiBGb3Igd2VsbCBrbm93biBhZGRyZXNzZXMsIHdlIHNldCB0aGUgaXRuaW0gdG8gaW5pdGlhdG9yCisJCSAqIHN0YXRlCisJCSAqLworCQlpdG5pbS0+c3RhdHMuaW5pdGlhdG9yKys7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfRkNTX0lUTklNX1NNX0lOSVRJQVRPUik7CisJfQorfQorCisvKioKKyAqIENhbGxlZCBieSBycG9ydCB0byBoYW5kbGUgYSByZW1vdGUgZGV2aWNlIG9mZmxpbmUuCisgKi8KK3ZvaWQKK2JmYV9mY3NfaXRuaW1fcnBvcnRfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSkKK3sKKwlpdG5pbS0+c3RhdHMub2ZmbGluZXMrKzsKKwliZmFfc21fc2VuZF9ldmVudChpdG5pbSwgQkZBX0ZDU19JVE5JTV9TTV9PRkZMSU5FKTsKK30KKworLyoqCisgKiBDYWxsZWQgYnkgcnBvcnQgd2hlbiByZW1vdGUgcG9ydCBpcyBrbm93biB0byBiZSBhbiBpbml0aWF0b3IgZnJvbQorICogUFJMSSByZWNlaXZlZC4KKyAqLwordm9pZAorYmZhX2Zjc19pdG5pbV9pc19pbml0aWF0b3Ioc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pCit7CisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBpdG5pbS0+cnBvcnQtPnBpZCk7CisJaXRuaW0tPnN0YXRzLmluaXRpYXRvcisrOworCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfRkNTX0lUTklNX1NNX0lOSVRJQVRPUik7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IHJwb3J0IHRvIGNoZWNrIGlmIHRoZSBpdG5pbSBpcyBvbmxpbmUuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2Zjc19pdG5pbV9nZXRfb25saW5lX3N0YXRlKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworCWJmYV90cmMoaXRuaW0tPmZjcywgaXRuaW0tPnJwb3J0LT5waWQpOworCXN3aXRjaCAoYmZhX3NtX3RvX3N0YXRlKGl0bmltX3NtX3RhYmxlLCBpdG5pbS0+c20pKSB7CisJY2FzZSBCRkFfSVROSU1fT05MSU5FOgorCWNhc2UgQkZBX0lUTklNX0lOSVRJQVRJT1I6CisJCXJldHVybiBCRkFfU1RBVFVTX09LOworCisJZGVmYXVsdDoKKwkJcmV0dXJuIEJGQV9TVEFUVVNfTk9fRkNQSU1fTkVYVVM7CisKKwl9Cit9CisKKy8qKgorICogQkZBIGNvbXBsZXRpb24gY2FsbGJhY2sgZm9yIGJmYV9pdG5pbV9vbmxpbmUoKS4KKyAqLwordm9pZAorYmZhX2NiX2l0bmltX29ubGluZSh2b2lkICpjYmFyZykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSA9IChzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICopY2Jhcmc7CisKKwliZmFfdHJjKGl0bmltLT5mY3MsIGl0bmltLT5ycG9ydC0+cHd3bik7CisJYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9GQ1NfSVROSU1fU01fSENCX09OTElORSk7Cit9CisKKy8qKgorICogQkZBIGNvbXBsZXRpb24gY2FsbGJhY2sgZm9yIGJmYV9pdG5pbV9vZmZsaW5lKCkuCisgKi8KK3ZvaWQKK2JmYV9jYl9pdG5pbV9vZmZsaW5lKHZvaWQgKmNiX2FyZykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSA9IChzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICopY2JfYXJnOworCisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBpdG5pbS0+cnBvcnQtPnB3d24pOworCWJmYV9zbV9zZW5kX2V2ZW50KGl0bmltLCBCRkFfRkNTX0lUTklNX1NNX0hDQl9PRkZMSU5FKTsKK30KKworLyoqCisgKiBNYXJrIHRoZSBiZWdpbm5pbmcgb2YgUEFUSCBUT1YgaGFuZGxpbmcuIElPIGNvbXBsZXRpb24gY2FsbGJhY2tzCisgKiBhcmUgc3RpbGwgcGVuZGluZy4KKyAqLwordm9pZAorYmZhX2NiX2l0bmltX3Rvdl9iZWdpbih2b2lkICpjYl9hcmcpCit7CisJc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0gPSAoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqKWNiX2FyZzsKKworCWJmYV90cmMoaXRuaW0tPmZjcywgaXRuaW0tPnJwb3J0LT5wd3duKTsKKwliZmFfZmNiX2l0bmltX3Rvdl9iZWdpbihpdG5pbS0+aXRuaW1fZHJ2KTsKK30KKworLyoqCisgKiBNYXJrIHRoZSBlbmQgb2YgUEFUSCBUT1YgaGFuZGxpbmcuIEFsbCBwZW5kaW5nIElPcyBhcmUgYWxyZWFkeSBjbGVhbmVkIHVwLgorICovCit2b2lkCitiZmFfY2JfaXRuaW1fdG92KHZvaWQgKmNiX2FyZykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSA9IChzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICopY2JfYXJnOworCisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBpdG5pbS0+cnBvcnQtPnB3d24pOworCWJmYV9mY2JfaXRuaW1fdG92KGl0bmltLT5pdG5pbV9kcnYpOworfQorCisvKioKKyAqIAkJQkZBIG5vdGlmaWNhdGlvbiB0byBGQ1MvZHJpdmVyIGZvciBzZWNvbmQgbGV2ZWwgZXJyb3IgcmVjb3ZlcnkuCisgKgorICogQXRsZWFzdCBvbmUgSS9PIHJlcXVlc3QgaGFzIHRpbWVkb3V0IGFuZCB0YXJnZXQgaXMgdW5yZXNwb25zaXZlIHRvCisgKiByZXBlYXRlZCBhYm9ydCByZXF1ZXN0cy4gU2Vjb25kIGxldmVsIGVycm9yIHJlY292ZXJ5IHNob3VsZCBiZSBpbml0aWF0ZWQKKyAqIGJ5IHN0YXJ0aW5nIGltcGxpY2l0IGxvZ291dCBhbmQgcmVjb3ZlcnkgcHJvY2VkdXJlcy4KKyAqLwordm9pZAorYmZhX2NiX2l0bmltX3NsZXIodm9pZCAqY2JfYXJnKQoreworCXN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltID0gKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKiljYl9hcmc7CisKKwlpdG5pbS0+c3RhdHMuc2xlcisrOworCWJmYV90cmMoaXRuaW0tPmZjcywgaXRuaW0tPnJwb3J0LT5wd3duKTsKKwliZmFfZmNzX3Jwb3J0X2xvZ29faW1wKGl0bmltLT5ycG9ydCk7Cit9CisKK3N0cnVjdCBiZmFfZmNzX2l0bmltX3MgKgorYmZhX2Zjc19pdG5pbV9sb29rdXAoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBycHd3bikKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKwlycG9ydCA9IGJmYV9mY3NfcnBvcnRfbG9va3VwKHBvcnQsIHJwd3duKTsKKworCWlmICghcnBvcnQpCisJCXJldHVybiBOVUxMOworCisJYmZhX2Fzc2VydChycG9ydC0+aXRuaW0gIT0gTlVMTCk7CisJcmV0dXJuIChycG9ydC0+aXRuaW0pOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9mY3NfaXRuaW1fYXR0cl9nZXQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBycHd3biwKKwkJICAgICAgIHN0cnVjdCBiZmFfaXRuaW1fYXR0cl9zICphdHRyKQoreworCXN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltID0gTlVMTDsKKworCWl0bmltID0gYmZhX2Zjc19pdG5pbV9sb29rdXAocG9ydCwgcnB3d24pOworCisJaWYgKGl0bmltID09IE5VTEwpCisJCXJldHVybiBCRkFfU1RBVFVTX05PX0ZDUElNX05FWFVTOworCisJYXR0ci0+c3RhdGUgPSBiZmFfc21fdG9fc3RhdGUoaXRuaW1fc21fdGFibGUsIGl0bmltLT5zbSk7CisJYXR0ci0+cmV0cnkgPSBpdG5pbS0+c2VxX3JlYzsKKwlhdHRyLT5yZWNfc3VwcG9ydCA9IGl0bmltLT5yZWNfc3VwcG9ydDsKKwlhdHRyLT5jb25mX2NvbXAgPSBpdG5pbS0+Y29uZl9jb21wOworCWF0dHItPnRhc2tfcmV0cnlfaWQgPSBpdG5pbS0+dGFza19yZXRyeV9pZDsKKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCitiZmFfc3RhdHVzX3QKK2JmYV9mY3NfaXRuaW1fc3RhdHNfZ2V0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwgd3duX3QgcnB3d24sCisJCQlzdHJ1Y3QgYmZhX2l0bmltX3N0YXRzX3MgKnN0YXRzKQoreworCXN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltID0gTlVMTDsKKworCWJmYV9hc3NlcnQocG9ydCAhPSBOVUxMKTsKKworCWl0bmltID0gYmZhX2Zjc19pdG5pbV9sb29rdXAocG9ydCwgcnB3d24pOworCisJaWYgKGl0bmltID09IE5VTEwpCisJCXJldHVybiBCRkFfU1RBVFVTX05PX0ZDUElNX05FWFVTOworCisJYmZhX29zX21lbWNweShzdGF0cywgJml0bmltLT5zdGF0cywgc2l6ZW9mKHN0cnVjdCBiZmFfaXRuaW1fc3RhdHNfcykpOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKK2JmYV9zdGF0dXNfdAorYmZhX2Zjc19pdG5pbV9zdGF0c19jbGVhcihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90IHJwd3duKQoreworCXN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltID0gTlVMTDsKKworCWJmYV9hc3NlcnQocG9ydCAhPSBOVUxMKTsKKworCWl0bmltID0gYmZhX2Zjc19pdG5pbV9sb29rdXAocG9ydCwgcnB3d24pOworCisJaWYgKGl0bmltID09IE5VTEwpCisJCXJldHVybiBCRkFfU1RBVFVTX05PX0ZDUElNX05FWFVTOworCisJYmZhX29zX21lbXNldCgmaXRuaW0tPnN0YXRzLCAwLCBzaXplb2Yoc3RydWN0IGJmYV9pdG5pbV9zdGF0c19zKSk7CisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKK3ZvaWQKK2JmYV9mY3NfZmNwaW1fdWZfcmVjdihzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwgc3RydWN0IGZjaHNfcyAqZmNocywKKwkJICAgICAgdTE2IGxlbikKK3sKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgKmVsc19jbWQ7CisKKwliZmFfdHJjKGl0bmltLT5mY3MsIGZjaHMtPnR5cGUpOworCisJaWYgKGZjaHMtPnR5cGUgIT0gRkNfVFlQRV9FTFMpCisJCXJldHVybjsKKworCWVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSAoZmNocyArIDEpOworCisJYmZhX3RyYyhpdG5pbS0+ZmNzLCBlbHNfY21kLT5lbHNfY29kZSk7CisKKwlzd2l0Y2ggKGVsc19jbWQtPmVsc19jb2RlKSB7CisJY2FzZSBGQ19FTFNfUFJMTzoKKwkJLyogYmZhX3NtX3NlbmRfZXZlbnQoaXRuaW0sIEJGQV9GQ1NfSVROSU1fU01fUFJMTyk7ICovCisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3ZvaWQKK2JmYV9mY3NfaXRuaW1fcGF1c2Uoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pCit7Cit9CisKK3ZvaWQKK2JmYV9mY3NfaXRuaW1fcmVzdW1lKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworfQorCisvKioKKyAqICAgTW9kdWxlIGluaXRpYWxpemF0aW9uCisgKi8KK3ZvaWQKK2JmYV9mY3NfZmNwaW1fbW9kaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7Cit9CisKKy8qKgorICogICBNb2R1bGUgY2xlYW51cAorICovCit2b2lkCitiZmFfZmNzX2ZjcGltX21vZGV4aXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKQoreworCWJmYV9mY3NfbW9kZXhpdF9jb21wKGZjcyk7Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9mY3B0bS5jIGIvZHJpdmVycy9zY3NpL2JmYS9mY3B0bS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhjOGIwOGMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2ZjcHRtLmMKQEAgLTAsMCArMSw2OCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqIFRoaXMgZmlsZSBjb250YWlucyBkdW1teSBGQ1BUTSByb3V0aW5lcyB0byBhaWQgaW4gSW5pdGlhdG9yIE1vZGUgb25seQorICogY29tcGlsYXRpb24gb2YgT1MgZHJpdmVyLgorICoKKyAqLworCisjaW5jbHVkZSAiYmZhX29zX2luYy5oIgorI2luY2x1ZGUgImZjc19ycG9ydC5oIgorI2luY2x1ZGUgImZjc19mY3B0bS5oIgorI2luY2x1ZGUgImZjcy9iZmFfZmNzX3Jwb3J0LmgiCisKK3N0cnVjdCBiZmFfZmNzX3Rpbl9zICoKK2JmYV9mY3NfdGluX2NyZWF0ZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwlyZXR1cm4gTlVMTDsKK30KKwordm9pZAorYmZhX2Zjc190aW5fZGVsZXRlKHN0cnVjdCBiZmFfZmNzX3Rpbl9zICp0aW4pCit7Cit9CisKK3ZvaWQKK2JmYV9mY3NfdGluX3Jwb3J0X29mZmxpbmUoc3RydWN0IGJmYV9mY3NfdGluX3MgKnRpbikKK3sKK30KKwordm9pZAorYmZhX2Zjc190aW5fcnBvcnRfb25saW5lKHN0cnVjdCBiZmFfZmNzX3Rpbl9zICp0aW4pCit7Cit9CisKK3ZvaWQKK2JmYV9mY3NfdGluX3J4X3BybGkoc3RydWN0IGJmYV9mY3NfdGluX3MgKnRpbiwgc3RydWN0IGZjaHNfcyAqZmNocywgdTE2IGxlbikKK3sKK30KKwordm9pZAorYmZhX2Zjc19mY3B0bV91Zl9yZWN2KHN0cnVjdCBiZmFfZmNzX3Rpbl9zICp0aW4sIHN0cnVjdCBmY2hzX3MgKmZjaHMsIHUxNiBsZW4pCit7Cit9CisKK3ZvaWQKK2JmYV9mY3NfdGluX3BhdXNlKHN0cnVjdCBiZmFfZmNzX3Rpbl9zICp0aW4pCit7Cit9CisKK3ZvaWQKK2JmYV9mY3NfdGluX3Jlc3VtZShzdHJ1Y3QgYmZhX2Zjc190aW5fcyAqdGluKQoreworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9mY3MuaCBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGVlZTY4NQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzLmgKQEAgLTAsMCArMSwzMCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBmY3MuaCBGQ1MgbW9kdWxlIGZ1bmN0aW9ucworICovCisKKworI2lmbmRlZiBfX0ZDU19IX18KKyNkZWZpbmUgX19GQ1NfSF9fCisKKyNkZWZpbmUgX19mY3NfbWluX2NmZyhfX2ZjcykgICAgICAgKF9fZmNzKS0+bWluX2NmZworCit2b2lkIGJmYV9mY3NfbW9kZXhpdF9jb21wKHN0cnVjdCBiZmFfZmNzX3MgKmZjcyk7CisKKyNlbmRpZiAvKiBfX0ZDU19IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvZmNzX2F1dGguaCBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX2F1dGguaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NWQxNTVmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfYXV0aC5oCkBAIC0wLDAgKzEsMzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgZmNzX3VmLmggRkNTIHVuc29saWNpdGVkIGZyYW1lIHJlY2VpdmUKKyAqLworCisKKyNpZm5kZWYgX19GQ1NfQVVUSF9IX18KKyNkZWZpbmUgX19GQ1NfQVVUSF9IX18KKworI2luY2x1ZGUgPGZjcy9iZmFfZmNzLmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfdnBvcnQuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc19scG9ydC5oPgorCisvKgorICogZmNzIGZyaWVuZCBmdW5jdGlvbnM6IG9ubHkgYmV0d2VlbiBmY3MgbW9kdWxlcworICovCit2b2lkIGJmYV9mY3NfYXV0aF91Zl9yZWN2KHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsIGludCBsZW4pOwordm9pZCBiZmFfZmNzX2F1dGhfc3RhcnQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyk7Cit2b2lkIGJmYV9mY3NfYXV0aF9zdG9wKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpOworCisjZW5kaWYgLyogX19GQ1NfVUZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2Zjc19mYWJyaWMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX2ZhYnJpYy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVlZTk2MDgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2Zjc19mYWJyaWMuaApAQCAtMCwwICsxLDYxIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGZjc19scG9ydC5oIEZDUyBsb2dpY2FsIHBvcnQgaW50ZXJmYWNlcworICovCisKKyNpZm5kZWYgX19GQ1NfRkFCUklDX0hfXworI2RlZmluZSBfX0ZDU19GQUJSSUNfSF9fCisKKyNpbmNsdWRlIDxmY3MvYmZhX2Zjcy5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX3Zwb3J0Lmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfbHBvcnQuaD4KKworLyoKKyogZmNzIGZyaWVuZCBmdW5jdGlvbnM6IG9ubHkgYmV0d2VlbiBmY3MgbW9kdWxlcworICovCit2b2lkICAgICAgICAgICAgYmZhX2Zjc19mYWJyaWNfbW9kaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfZmFicmljX21vZGV4aXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX2ZhYnJpY19tb2RzdXNwKHN0cnVjdCBiZmFfZmNzX3MgKmZjcyk7Cit2b2lkICAgICAgICAgICAgYmZhX2Zjc19mYWJyaWNfbGlua191cChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX2ZhYnJpY19saW5rX2Rvd24oc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyk7Cit2b2lkICAgICAgICAgICAgYmZhX2Zjc19mYWJyaWNfYWRkdnBvcnQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCQkJc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfZmFicmljX2RlbHZwb3J0KHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMsCisJCQkJCXN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0KTsKK2ludCAgICAgICAgICAgICBiZmFfZmNzX2ZhYnJpY19pc19vbmxpbmUoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyk7CitzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICpiZmFfZmNzX2ZhYnJpY192cG9ydF9sb29rdXAoCisJCQlzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljLCB3d25fdCBwd3duKTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX2ZhYnJpY19tb2RzdGFydChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfZmFicmljX3VmX3JlY3Yoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCXN0cnVjdCBmY2hzX3MgKmZjaHMsIHUxNiBsZW4pOwordTE2ICAgICAgICBiZmFfZmNzX2ZhYnJpY192cG9ydF9jb3VudChzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKTsKK2JmYV9ib29sZWFuX3QgICBiZmFfZmNzX2ZhYnJpY19pc19sb29wYmFjayhzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljKTsKK2VudW0gYmZhX3Bwb3J0X3R5cGUgYmZhX2Zjc19mYWJyaWNfcG9ydF90eXBlKHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zICpmYWJyaWMpOwordm9pZCAgICAgCWJmYV9mY3NfZmFicmljX3BzeW1iX2luaXQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyk7Cit2b2lkIGJmYV9mY3NfZmFicmljX3BvcnRfZGVsZXRlX2NvbXAoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYyk7CisKK2JmYV9zdGF0dXNfdCBiZmFfZmNzX2ZhYnJpY19hZGR2ZihzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqdmYsCisJCQlzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHN0cnVjdCBiZmFfcG9ydF9jZmdfcyAqcG9ydF9jZmcsCisJCQlzdHJ1Y3QgYmZhZF92Zl9zICp2Zl9kcnYpOwordm9pZCBiZmFfZmNzX2F1dGhfZmluaXNoZWQoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCWVudW0gYXV0aF9zdGF0dXMgc3RhdHVzKTsKKwordm9pZCBiZmFfZmNzX2ZhYnJpY19zZXRfZmFicmljX25hbWUoc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYywKKwkJCXd3bl90IGZhYnJpY19uYW1lKTsKKyNlbmRpZiAvKiBfX0ZDU19GQUJSSUNfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2Zjc19mY3BpbS5oIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfZmNwaW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42MWU5ZTI2Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfZmNwaW0uaApAQCAtMCwwICsxLDQ0IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fRkNTX0ZDUElNX0hfXworI2RlZmluZSBfX0ZDU19GQ1BJTV9IX18KKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcG9ydC5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX2xwb3J0Lmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfcnBvcnQuaD4KKworLyoKKyAqIEZvbGxvd2luZyByb3V0aW5lcyBhcmUgZnJvbSBGQ1BJTSBhbmQgd2lsbCBiZSBjYWxsZWQgYnkgcnBvcnQuCisgKi8KK3N0cnVjdCBiZmFfZmNzX2l0bmltX3MgKmJmYV9mY3NfaXRuaW1fY3JlYXRlKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgYmZhX2Zjc19pdG5pbV9kZWxldGUoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pOwordm9pZCBiZmFfZmNzX2l0bmltX3Jwb3J0X29mZmxpbmUoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pOwordm9pZCBiZmFfZmNzX2l0bmltX3Jwb3J0X29ubGluZShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSk7CitiZmFfc3RhdHVzX3QgYmZhX2Zjc19pdG5pbV9nZXRfb25saW5lX3N0YXRlKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKTsKKwordm9pZCBiZmFfZmNzX2l0bmltX2lzX2luaXRpYXRvcihzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSk7Cit2b2lkIGJmYV9mY3NfaXRuaW1fcGF1c2Uoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pOwordm9pZCBiZmFfZmNzX2l0bmltX3Jlc3VtZShzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSk7CisKKy8qCisgKiBNb2R1ZGxlIGluaXQvY2xlYW51cCByb3V0aW5lcy4KKyAqLwordm9pZCBiZmFfZmNzX2ZjcGltX21vZGluaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKTsKK3ZvaWQgYmZhX2Zjc19mY3BpbV9tb2RleGl0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcyk7Cit2b2lkIGJmYV9mY3NfZmNwaW1fdWZfcmVjdihzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSwgc3RydWN0IGZjaHNfcyAqZmNocywKKwkJCXUxNiBsZW4pOworI2VuZGlmIC8qIF9fRkNTX0ZDUElNX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9mY3NfZmNwdG0uaCBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX2ZjcHRtLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmZmZjA4MgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX2ZjcHRtLmgKQEAgLTAsMCArMSw0NSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fRkNTX0ZDUFRNX0hfXworI2RlZmluZSBfX0ZDU19GQ1BUTV9IX18KKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcG9ydC5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX2xwb3J0Lmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfcnBvcnQuaD4KKworLyoKKyAqIEZvbGxvd2luZyByb3V0aW5lcyBhcmUgZnJvbSBGQ1BUTSBhbmQgd2lsbCBiZSBjYWxsZWQgYnkgcnBvcnQuCisgKi8KK3N0cnVjdCBiZmFfZmNzX3Rpbl9zICpiZmFfZmNzX3Rpbl9jcmVhdGUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpOwordm9pZCBiZmFfZmNzX3Rpbl9ycG9ydF9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3Rpbl9zICp0aW4pOwordm9pZCBiZmFfZmNzX3Rpbl9ycG9ydF9vbmxpbmUoc3RydWN0IGJmYV9mY3NfdGluX3MgKnRpbik7Cit2b2lkIGJmYV9mY3NfdGluX2RlbGV0ZShzdHJ1Y3QgYmZhX2Zjc190aW5fcyAqdGluKTsKK3ZvaWQgYmZhX2Zjc190aW5fcnhfcHJsaShzdHJ1Y3QgYmZhX2Zjc190aW5fcyAqdGluLCBzdHJ1Y3QgZmNoc19zICpmY2hzLAorCQkJdTE2IGxlbik7Cit2b2lkIGJmYV9mY3NfdGluX3BhdXNlKHN0cnVjdCBiZmFfZmNzX3Rpbl9zICp0aW4pOwordm9pZCBiZmFfZmNzX3Rpbl9yZXN1bWUoc3RydWN0IGJmYV9mY3NfdGluX3MgKnRpbik7CisKKy8qCisgKiBNb2R1ZGxlIGluaXQvY2xlYW51cCByb3V0aW5lcy4KKyAqLwordm9pZCBiZmFfZmNzX2ZjcHRtX21vZGluaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKTsKK3ZvaWQgYmZhX2Zjc19mY3B0bV9tb2RleGl0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcyk7Cit2b2lkIGJmYV9mY3NfZmNwdG1fdWZfcmVjdihzdHJ1Y3QgYmZhX2Zjc190aW5fcyAqdGluLCBzdHJ1Y3QgZmNoc19zICpmY2hzLAorCQkJdTE2IGxlbik7CisKKyNlbmRpZiAvKiBfX0ZDU19GQ1BUTV9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvZmNzX2ZjeHAuaCBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX2ZjeHAuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44Mjc3ZmU5Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfZmN4cC5oCkBAIC0wLDAgKzEsMjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgZmNzX2ZjeHAuaCBGQ1hQIGhlbHBlciBtYWNyb3MgZm9yIEZDUworICovCisKKworI2lmbmRlZiBfX0ZDU19GQ1hQX0hfXworI2RlZmluZSBfX0ZDU19GQ1hQX0hfXworCisjZGVmaW5lIGJmYV9mY3NfZmN4cF9hbGxvYyhfX2ZjcykJXAorCWJmYV9mY3hwX2FsbG9jKE5VTEwsIChfX2ZjcyktPmJmYSwgMCwgMCwgTlVMTCwgTlVMTCwgTlVMTCwgTlVMTCkKKworI2VuZGlmIC8qIF9fRkNTX0ZDWFBfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2Zjc19scG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfbHBvcnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hZTc0NGJhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfbHBvcnQuaApAQCAtMCwwICsxLDExNyBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBmY3NfbHBvcnQuaCBGQ1MgbG9naWNhbCBwb3J0IGludGVyZmFjZXMKKyAqLworCisjaWZuZGVmIF9fRkNTX0xQT1JUX0hfXworI2RlZmluZSBfX0ZDU19MUE9SVF9IX18KKworI2RlZmluZSBfX1ZQT1JUX0hfXworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcG9ydC5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc19scG9ydC5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX3Jwb3J0Lmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfdnBvcnQuaD4KKyNpbmNsdWRlIDxmY3NfZmFicmljLmg+CisjaW5jbHVkZSA8ZmNzX21zLmg+CisjaW5jbHVkZSA8Y3MvYmZhX3EuaD4KKyNpbmNsdWRlIDxmY2J1aWxkLmg+CisKKy8qCisgKiBQSUQgdXNlZCBpbiBQMlAvTjJOICggSW4gQmlnIEVuZGlhbikKKyAqLworI2RlZmluZSBOMk5fTE9DQUxfUElECSAgICAweDAxMDAwMAorI2RlZmluZSBOMk5fUkVNT1RFX1BJRAkJMHgwMjAwMDAKKworLyoKKyAqIE1pc2MgVGltZW91dHMKKyAqLworLyoKKyAqIFRvIGJlIHVzZWQgd2hlbiBzcGF3bmluZyBhIHRpbWVyIGJlZm9yZSByZXRyeWluZyBhIGZhaWxlZCBjb21tYW5kLiBNaWxsaQorICogU2Vjcy4KKyAqLworI2RlZmluZQlCRkFfRkNTX1JFVFJZX1RJTUVPVVQgMjAwMAorCisvKgorICogQ2hlY2sgZm9yIFBvcnQvVnBvcnQgTW9kZS9Sb2xlCisgKi8KKyNkZWZpbmUJQkZBX0ZDU19WUE9SVF9JU19JTklUSUFUT1JfTU9ERShwb3J0KSBcCisJCShwb3J0LT5wb3J0X2NmZy5yb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lNKQorCisjZGVmaW5lCUJGQV9GQ1NfVlBPUlRfSVNfVEFSR0VUX01PREUocG9ydCkgXAorCQkocG9ydC0+cG9ydF9jZmcucm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9UTSkKKworI2RlZmluZQlCRkFfRkNTX1ZQT1JUX0lTX0lQRkNfTU9ERShwb3J0KSBcCisJCShwb3J0LT5wb3J0X2NmZy5yb2xlcyAmIEJGQV9QT1JUX1JPTEVfRkNQX0lQRkMpCisKKy8qCisgKiBJcyB0aGlzIGEgV2VsbCBLbm93biBBZGRyZXNzCisgKi8KKyNkZWZpbmUgQkZBX0ZDU19QSURfSVNfV0tBKHBpZCkgICgoYmZhX29zX250b2gzYihwaWQpID4gMHhGRkYwMDApID8gIDEgOiAwKQorCisvKgorICogUG9pbnRlciB0byBlbGVtZW50cyB3aXRoaW4gUG9ydAorICovCisjZGVmaW5lIEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQocG9ydCkgIChwb3J0LT5mY3MtPmJmYSkKKyNkZWZpbmUgQkZBX0ZDU19HRVRfTlNfRlJPTV9QT1JUKHBvcnQpICAoJnBvcnQtPnBvcnRfdG9wby5wZmFiLm5zKQorI2RlZmluZSBCRkFfRkNTX0dFVF9TQ05fRlJPTV9QT1JUKHBvcnQpICAoJnBvcnQtPnBvcnRfdG9wby5wZmFiLnNjbikKKyNkZWZpbmUgQkZBX0ZDU19HRVRfTVNfRlJPTV9QT1JUKHBvcnQpICAoJnBvcnQtPnBvcnRfdG9wby5wZmFiLm1zKQorI2RlZmluZSBCRkFfRkNTX0dFVF9GRE1JX0ZST01fUE9SVChwb3J0KSAgKCZwb3J0LT5wb3J0X3RvcG8ucGZhYi5tcy5mZG1pKQorCisvKgorICogaGFuZGxlciBmb3IgdW5zb2xpY2llZCBmcmFtZXMKKyAqLwordm9pZCBiZmFfZmNzX3BvcnRfdWZfcmVjdihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmxwb3J0LCBzdHJ1Y3QgZmNoc19zICpmY2hzLAorCQkJdTE2IGxlbik7CisKKy8qCisgKiBGb2xsb3dpbmcgcm91dGluZXMgd2lsbCBiZSBjYWxsZWQgYnkgRmFicmljIHRvIGluZGljYXRlIHBvcnQKKyAqIG9ubGluZS9vZmZsaW5lIHRvIHZwb3J0LgorICovCit2b2lkIGJmYV9mY3NfbHBvcnRfaW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmxwb3J0LCBzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsCisJCQl1MTYgdmZfaWQsIHN0cnVjdCBiZmFfcG9ydF9jZmdfcyAqcG9ydF9jZmcsCisJCQlzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCk7Cit2b2lkIGJmYV9mY3NfcG9ydF9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3ZvaWQgYmZhX2Zjc19wb3J0X29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3ZvaWQgYmZhX2Zjc19wb3J0X2RlbGV0ZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOworYmZhX2Jvb2xlYW5fdCAgIGJmYV9mY3NfcG9ydF9pc19vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKKworLyoKKyAqIExvb2t1cCBycG9ydCBiYXNlZCBvbiBQSUQKKyAqLworc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqYmZhX2Zjc19wb3J0X2dldF9ycG9ydF9ieV9waWQoCisJCQlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHUzMiBwaWQpOworCisvKgorICogTG9va3VwIHJwb3J0IGJhc2VkIG9uIFBXV04KKyAqLworc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqYmZhX2Zjc19wb3J0X2dldF9ycG9ydF9ieV9wd3duKAorCQkJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBwd3duKTsKK3N0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKmJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfYnlfbnd3bigKKwkJCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwgd3duX3Qgbnd3bik7Cit2b2lkIGJmYV9mY3NfcG9ydF9hZGRfcnBvcnQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpOwordm9pZCBiZmFfZmNzX3BvcnRfZGVsX3Jwb3J0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKKwordm9pZCBiZmFfZmNzX3BvcnRfbW9kaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOwordm9pZCBiZmFfZmNzX3BvcnRfbW9kZXhpdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOwordm9pZCBiZmFfZmNzX3BvcnRfbGlwKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCk7CisKKyNlbmRpZiAvKiBfX0ZDU19MUE9SVF9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvZmNzX21zLmggYi9kcml2ZXJzL3Njc2kvYmZhL2Zjc19tcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI2YThjMTIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2Zjc19tcy5oCkBAIC0wLDAgKzEsMzUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgZmNzX21zLmggRkNTIG1zIGludGVyZmFjZXMKKyAqLworI2lmbmRlZiBfX0ZDU19NU19IX18KKyNkZWZpbmUgX19GQ1NfTVNfSF9fCisKKy8qIE1TIEZDUyByb3V0aW5lcyAqLwordm9pZCBiZmFfZmNzX3BvcnRfbXNfaW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOwordm9pZCBiZmFfZmNzX3BvcnRfbXNfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOwordm9pZCBiZmFfZmNzX3BvcnRfbXNfb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCk7Cit2b2lkIGJmYV9mY3NfcG9ydF9tc19mYWJyaWNfcnNjbihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOworCisvKiBGRE1JIEZDUyByb3V0aW5lcyAqLwordm9pZCBiZmFfZmNzX3BvcnRfZmRtaV9pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMpOwordm9pZCBiZmFfZmNzX3BvcnRfZmRtaV9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMpOwordm9pZCBiZmFfZmNzX3BvcnRfZmRtaV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcyk7CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9mY3NfcG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfcG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmFiYjY1MTkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2Zjc19wb3J0LmgKQEAgLTAsMCArMSwzMiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBmY3NfcHBvcnQuaCBGQ1MgcGh5c2ljYWwgcG9ydCBpbnRlcmZhY2VzCisgKi8KKworCisjaWZuZGVmIF9fRkNTX1BQT1JUX0hfXworI2RlZmluZSBfX0ZDU19QUE9SVF9IX18KKworLyoKKyAqIGZjcyBmcmllbmQgZnVuY3Rpb25zOiBvbmx5IGJldHdlZW4gZmNzIG1vZHVsZXMKKyAqLwordm9pZCBiZmFfZmNzX3Bwb3J0X21vZGluaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKTsKK3ZvaWQgYmZhX2Zjc19wcG9ydF9tb2RleGl0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcyk7CisKKyNlbmRpZiAvKiBfX0ZDU19QUE9SVF9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvZmNzX3Jwb3J0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2Zjc19ycG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY2MDFlOWQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2Zjc19ycG9ydC5oCkBAIC0wLDAgKzEsNjEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgZmNzX3Jwb3J0LmggRkNTIHJwb3J0IGludGVyZmFjZXMgYW5kIGRlZmluZXMKKyAqLworCisjaWZuZGVmIF9fRkNTX1JQT1JUX0hfXworI2RlZmluZSBfX0ZDU19SUE9SVF9IX18KKworI2luY2x1ZGUgPGZjcy9iZmFfZmNzX3Jwb3J0Lmg+CisKK3ZvaWQgYmZhX2Zjc19ycG9ydF9tb2Rpbml0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcyk7Cit2b2lkIGJmYV9mY3NfcnBvcnRfbW9kZXhpdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOworCit2b2lkIGJmYV9mY3NfcnBvcnRfdWZfcmVjdihzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwgc3RydWN0IGZjaHNfcyAqZmNocywKKwkJCXUxNiBsZW4pOwordm9pZCBiZmFfZmNzX3Jwb3J0X3NjbihzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCk7CisKK3N0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKmJmYV9mY3NfcnBvcnRfY3JlYXRlKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXUzMiBwaWQpOwordm9pZCBiZmFfZmNzX3Jwb3J0X2RlbGV0ZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCk7Cit2b2lkIGJmYV9mY3NfcnBvcnRfb25saW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgYmZhX2Zjc19ycG9ydF9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgYmZhX2Zjc19ycG9ydF9zdGFydChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHN0cnVjdCBmY2hzX3MgKnJ4X2ZjaHMsCisJCQlzdHJ1Y3QgZmNfbG9naV9zICpwbG9naV9yc3ApOwordm9pZCBiZmFfZmNzX3Jwb3J0X3Bsb2dpX2NyZWF0ZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQlzdHJ1Y3QgZmNoc19zICpyeF9mY2hzLAorCQkJc3RydWN0IGZjX2xvZ2lfcyAqcGxvZ2kpOwordm9pZCBiZmFfZmNzX3Jwb3J0X3Bsb2dpKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LCBzdHJ1Y3QgZmNoc19zICpmY2hzLAorCQkJc3RydWN0IGZjX2xvZ2lfcyAqcGxvZ2kpOwordm9pZCBiZmFfZmNzX3Jwb3J0X2xvZ29faW1wKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgYmZhX2Zjc19ycG9ydF9pdG5pbV9hY2soc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpOwordm9pZCBiZmFfZmNzX3Jwb3J0X2l0bnRtX2FjayhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCk7Cit2b2lkIGJmYV9mY3NfcnBvcnRfdGluX2FjayhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCk7Cit2b2lkIGJmYV9mY3NfcnBvcnRfZmNwdG1fb2ZmbGluZV9kb25lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK2ludCAgYmZhX2Zjc19ycG9ydF9nZXRfc3RhdGUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpOworc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqYmZhX2Zjc19ycG9ydF9jcmVhdGVfYnlfd3duKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXd3bl90IHd3bik7CisKKworLyogUnBvcnQgRmVhdHVyZXMgKi8KK3ZvaWQgIGJmYV9mY3NfcnBmX2luaXQoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpOwordm9pZCAgYmZhX2Zjc19ycGZfcnBvcnRfb25saW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgIGJmYV9mY3NfcnBmX3Jwb3J0X29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpOworCisjZW5kaWYgLyogX19GQ1NfUlBPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2Zjc190cmNtb2QuaCBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX3RyY21vZC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQxYjVhZTgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2Zjc190cmNtb2QuaApAQCAtMCwwICsxLDU2IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGZjc190cmNtb2QuaCBCRkEgRkNTIHRyYWNlIG1vZHVsZXMKKyAqLworCisjaWZuZGVmIF9fRkNTX1RSQ01PRF9IX18KKyNkZWZpbmUgX19GQ1NfVFJDTU9EX0hfXworCisjaW5jbHVkZSA8Y3MvYmZhX3RyYy5oPgorCisvKgorICogISEhIE9ubHkgYXBwZW5kIHRvIHRoZSBlbnVtcyBkZWZpbmVkIGhlcmUgdG8gYXZvaWQgYW55IHZlcnNpb25pbmcKKyAqICEhISBuZWVkZWQgYmV0d2VlbiB0cmFjZSB1dGlsaXR5IGFuZCBkcml2ZXIgdmVyc2lvbgorICovCitlbnVtIHsKKwlCRkFfVFJDX0ZDU19GQUJSSUMJCT0gMSwKKwlCRkFfVFJDX0ZDU19WRkFQSQkJPSAyLAorCUJGQV9UUkNfRkNTX1BPUlQJCT0gMywKKwlCRkFfVFJDX0ZDU19WUE9SVAkJPSA0LAorCUJGQV9UUkNfRkNTX1ZQX0FQSQkJPSA1LAorCUJGQV9UUkNfRkNTX1ZQUwkJCT0gNiwKKwlCRkFfVFJDX0ZDU19SUE9SVAkJPSA3LAorCUJGQV9UUkNfRkNTX0ZDUElNCQk9IDgsCisJQkZBX1RSQ19GQ1NfRkNQVE0JCT0gOSwKKwlCRkFfVFJDX0ZDU19OUwkJCT0gMTAsCisJQkZBX1RSQ19GQ1NfU0NOCQkJPSAxMSwKKwlCRkFfVFJDX0ZDU19MT09QCQk9IDEyLAorCUJGQV9UUkNfRkNTX1VGCQkJPSAxMywKKwlCRkFfVFJDX0ZDU19QUE9SVAkJPSAxNCwKKwlCRkFfVFJDX0ZDU19GQ1BJUAkJPSAxNSwKKwlCRkFfVFJDX0ZDU19QT1JUX0FQSQk9IDE2LAorCUJGQV9UUkNfRkNTX1JQT1JUX0FQSQk9IDE3LAorCUJGQV9UUkNfRkNTX0FVVEgJCT0gMTgsCisJQkZBX1RSQ19GQ1NfTjJOCQkJPSAxOSwKKwlCRkFfVFJDX0ZDU19NUwkJCT0gMjAsCisJQkZBX1RSQ19GQ1NfRkRNSQkJPSAyMSwKKwlCRkFfVFJDX0ZDU19SUE9SVF9GVFJTCT0gMjIsCit9OworCisjZW5kaWYgLyogX19GQ1NfVFJDTU9EX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9mY3NfdWYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX3VmLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTZmMWJkYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvZmNzX3VmLmgKQEAgLTAsMCArMSwzMiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBmY3NfdWYuaCBGQ1MgdW5zb2xpY2l0ZWQgZnJhbWUgcmVjZWl2ZQorICovCisKKworI2lmbmRlZiBfX0ZDU19VRl9IX18KKyNkZWZpbmUgX19GQ1NfVUZfSF9fCisKKy8qCisgKiBmY3MgZnJpZW5kIGZ1bmN0aW9uczogb25seSBiZXR3ZWVuIGZjcyBtb2R1bGVzCisgKi8KK3ZvaWQgYmZhX2Zjc191Zl9tb2Rpbml0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcyk7Cit2b2lkIGJmYV9mY3NfdWZfbW9kZXhpdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOworCisjZW5kaWYgLyogX19GQ1NfVUZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2Zjc192cG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfdnBvcnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45ZTgwYjZhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9mY3NfdnBvcnQuaApAQCAtMCwwICsxLDM5IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19GQ1NfVlBPUlRfSF9fCisjZGVmaW5lIF9fRkNTX1ZQT1JUX0hfXworCisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfbHBvcnQuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc192cG9ydC5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcGNpLmg+CisKKy8qCisgKiBNb2R1ZGxlIGluaXQvY2xlYW51cCByb3V0aW5lcy4KKyAqLworCit2b2lkIGJmYV9mY3NfdnBvcnRfbW9kaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOwordm9pZCBiZmFfZmNzX3Zwb3J0X21vZGV4aXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKTsKKwordm9pZCBiZmFfZmNzX3Zwb3J0X2NsZWFudXAoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpOwordm9pZCBiZmFfZmNzX3Zwb3J0X29ubGluZShzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCk7Cit2b2lkIGJmYV9mY3NfdnBvcnRfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCk7Cit2b2lkIGJmYV9mY3NfdnBvcnRfZGVsZXRlX2NvbXAoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpOwordTMyIGJmYV9mY3NfdnBvcnRfZ2V0X21heChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOworCisjZW5kaWYgLyogX19GQ1NfVlBPUlRfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvZmRtaS5jIGIvZHJpdmVycy9zY3NpL2JmYS9mZG1pLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjg0NWViMgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvZmRtaS5jCkBAIC0wLDAgKzEsMTIyMyBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBwb3J0X2FwaS5jIEJGQSBGQ1MgcG9ydAorICovCisKKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlICJmY3NfbHBvcnQuaCIKKyNpbmNsdWRlICJmY3NfcnBvcnQuaCIKKyNpbmNsdWRlICJscG9ydF9wcml2LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImZjc19mY3hwLmgiCisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfZmRtaS5oPgorCitCRkFfVFJDX0ZJTEUoRkNTLCBGRE1JKTsKKworI2RlZmluZSBCRkFfRkNTX0ZETUlfQ01EX01BWF9SRVRSSUVTIDIKKworLyoKKyAqIGZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfZmRtaV9zZW5kX3JoYmEodm9pZCAqZmRtaV9jYmFyZywKKwkJCQkJICAgIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9mZG1pX3NlbmRfcnBydCh2b2lkICpmZG1pX2NiYXJnLAorCQkJCQkgICAgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X2ZkbWlfc2VuZF9ycGEodm9pZCAqZmRtaV9jYmFyZywKKwkJCQkJICAgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X2ZkbWlfcmhiYV9yZXNwb25zZSh2b2lkICpmY3NhcmcsCisJCQkJCQlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJCXZvaWQgKmNiYXJnLAorCQkJCQkJYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJCQl1MzIgcnNwX2xlbiwKKwkJCQkJCXUzMiByZXNpZF9sZW4sCisJCQkJCQlzdHJ1Y3QgZmNoc19zICpyc3BfZmNocyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X2ZkbWlfcnBydF9yZXNwb25zZSh2b2lkICpmY3NhcmcsCisJCQkJCQlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJCXZvaWQgKmNiYXJnLAorCQkJCQkJYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJCQl1MzIgcnNwX2xlbiwKKwkJCQkJCXUzMiByZXNpZF9sZW4sCisJCQkJCQlzdHJ1Y3QgZmNoc19zICpyc3BfZmNocyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X2ZkbWlfcnBhX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCQkJICAgICAgIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCQkgICAgICAgdm9pZCAqY2JhcmcsCisJCQkJCSAgICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkJICAgICAgIHUzMiByc3BfbGVuLAorCQkJCQkgICAgICAgdTMyIHJlc2lkX2xlbiwKKwkJCQkJICAgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfZmRtaV90aW1lb3V0KHZvaWQgKmFyZyk7CitzdGF0aWMgdTE2IGJmYV9mY3NfcG9ydF9mZG1pX2J1aWxkX3JoYmFfcHlsZCgKKwkJCXN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLCB1OCAqcHlsZCk7CitzdGF0aWMgdTE2IGJmYV9mY3NfcG9ydF9mZG1pX2J1aWxkX3JwcnRfcHlsZCgKKwkJCXN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLCB1OCAqcHlsZCk7CitzdGF0aWMgdTE2IGJmYV9mY3NfcG9ydF9mZG1pX2J1aWxkX3JwYV9weWxkKAorCQkJc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksIHU4ICpweWxkKTsKK3N0YXRpYyB1MTYgYmZhX2Zjc19wb3J0X2ZkbWlfYnVpbGRfcG9ydGF0dHJfYmxvY2soCisJCQlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwgdTggKnB5bGQpOwordm9pZCBiZmFfZmNzX2ZkbWlfZ2V0X2hiYWF0dHIoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQlzdHJ1Y3QgYmZhX2Zjc19mZG1pX2hiYV9hdHRyX3MgKmhiYV9hdHRyKTsKK3ZvaWQgYmZhX2Zjc19mZG1pX2dldF9wb3J0YXR0cihzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCXN0cnVjdCBiZmFfZmNzX2ZkbWlfcG9ydF9hdHRyX3MgKnBvcnRfYXR0cik7CisvKioKKyAqICBmY3NfZmRtaV9zbSBGQ1MgRkRNSSBzdGF0ZSBtYWNoaW5lCisgKi8KKworLyoqCisgKiAgRkRNSSBTdGF0ZSBNYWNoaW5lIGV2ZW50cworICovCitlbnVtIHBvcnRfZmRtaV9ldmVudCB7CisJRkRNSVNNX0VWRU5UX1BPUlRfT05MSU5FID0gMSwKKwlGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FID0gMiwKKwlGRE1JU01fRVZFTlRfUlNQX09LID0gNCwKKwlGRE1JU01fRVZFTlRfUlNQX0VSUk9SID0gNSwKKwlGRE1JU01fRVZFTlRfVElNRU9VVCA9IDYsCisJRkRNSVNNX0VWRU5UX1JIQkFfU0VOVCA9IDcsCisJRkRNSVNNX0VWRU5UX1JQUlRfU0VOVCA9IDgsCisJRkRNSVNNX0VWRU5UX1JQQV9TRU5UID0gOSwKK307CisKK3N0YXRpYyB2b2lkIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQllbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9zZW5kaW5nX3JoYmEoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQllbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9yaGJhKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJZW51bSBwb3J0X2ZkbWlfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgYmZhX2Zjc19wb3J0X2ZkbWlfc21fcmhiYV9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCWVudW0gcG9ydF9mZG1pX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkIGJmYV9mY3NfcG9ydF9mZG1pX3NtX3NlbmRpbmdfcnBydChzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCWVudW0gcG9ydF9mZG1pX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkIGJmYV9mY3NfcG9ydF9mZG1pX3NtX3JwcnQoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQllbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9ycHJ0X3JldHJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJZW51bSBwb3J0X2ZkbWlfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgYmZhX2Zjc19wb3J0X2ZkbWlfc21fc2VuZGluZ19ycGEoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQllbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X2ZkbWlfc21fcnBhKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJZW51bSBwb3J0X2ZkbWlfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9mZG1pX3NtX3JwYV9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCWVudW0gcG9ydF9mZG1pX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfZmRtaV9zbV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQllbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCk7CisvKioKKyAqIAkJU3RhcnQgaW4gb2ZmbGluZSBzdGF0ZSAtIGF3YWl0aW5nIE1TIHRvIHNlbmQgc3RhcnQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfZmRtaV9zbV9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJICAgICBlbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJZmRtaS0+cmV0cnlfY250ID0gMDsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEZETUlTTV9FVkVOVF9QT1JUX09OTElORToKKwkJaWYgKHBvcnQtPnZwb3J0KSB7CisJCQkvKgorCQkJICogRm9yIFZwb3J0cywgcmVnaXN0ZXIgYSBuZXcgcG9ydC4KKwkJCSAqLworCQkJYmZhX3NtX3NldF9zdGF0ZShmZG1pLAorCQkJCQkgYmZhX2Zjc19wb3J0X2ZkbWlfc21fc2VuZGluZ19ycHJ0KTsKKwkJCWJmYV9mY3NfcG9ydF9mZG1pX3NlbmRfcnBydChmZG1pLCBOVUxMKTsKKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBGb3IgYSBiYXNlIHBvcnQsIHdlIHNob3VsZCBmaXJzdCByZWdpc3RlciB0aGUgSEJBCisJCQkgKiBhdHJpYnV0ZS4gVGhlIEhCQSBhdHRyaWJ1dGUgYWxzbyBjb250YWlucyB0aGUgYmFzZQorCQkJICogIHBvcnQgcmVnaXN0cmF0aW9uLgorCQkJICovCisJCQliZmFfc21fc2V0X3N0YXRlKGZkbWksCisJCQkJCSBiZmFfZmNzX3BvcnRfZmRtaV9zbV9zZW5kaW5nX3JoYmEpOworCQkJYmZhX2Zjc19wb3J0X2ZkbWlfc2VuZF9yaGJhKGZkbWksIE5VTEwpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfc21fc2VuZGluZ19yaGJhKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJCSAgZW51bSBwb3J0X2ZkbWlfZXZlbnQgZXZlbnQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gZmRtaS0+bXMtPnBvcnQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEZETUlTTV9FVkVOVF9SSEJBX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fcmhiYSk7CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF93YWxsb2NfY2FuY2VsKEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQocG9ydCksCisJCQkJICAgICAgICZmZG1pLT5mY3hwX3dxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfZmRtaV9zbV9yaGJhKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJICBlbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgRkRNSVNNX0VWRU5UX1JTUF9FUlJPUjoKKwkJLyoKKwkJICogaWYgbWF4IHJldHJpZXMgaGF2ZSBub3QgYmVlbiByZWFjaGVkLCBzdGFydCB0aW1lciBmb3IgYQorCQkgKiBkZWxheWVkIHJldHJ5CisJCSAqLworCQlpZiAoZmRtaS0+cmV0cnlfY250KysgPCBCRkFfRkNTX0ZETUlfQ01EX01BWF9SRVRSSUVTKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX3JoYmFfcmV0cnkpOworCQkJYmZhX3RpbWVyX3N0YXJ0KEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQocG9ydCksCisJCQkJCSZmZG1pLT50aW1lciwgYmZhX2Zjc19wb3J0X2ZkbWlfdGltZW91dCwKKwkJCQkJZmRtaSwgQkZBX0ZDU19SRVRSWV9USU1FT1VUKTsKKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBzZXQgc3RhdGUgdG8gb2ZmbGluZQorCQkJICovCisJCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29mZmxpbmUpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUlNQX09LOgorCQkvKgorCQkgKiBJbml0aWF0ZSBSZWdpc3RlciBQb3J0IEF0dHJpYnV0ZXMKKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fc2VuZGluZ19ycGEpOworCQlmZG1pLT5yZXRyeV9jbnQgPSAwOworCQliZmFfZmNzX3BvcnRfZmRtaV9zZW5kX3JwYShmZG1pLCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIEZETUlTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9mY3hwX2Rpc2NhcmQoZmRtaS0+ZmN4cCk7CisJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fb2ZmbGluZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfZmRtaV9zbV9yaGJhX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJCWVudW0gcG9ydF9mZG1pX2V2ZW50IGV2ZW50KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IGZkbWktPm1zLT5wb3J0OworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMocG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBGRE1JU01fRVZFTlRfVElNRU9VVDoKKwkJLyoKKwkJICogUmV0cnkgVGltZXIgRXhwaXJlZC4gUmUtc2VuZAorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShmZG1pLCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9zZW5kaW5nX3JoYmEpOworCQliZmFfZmNzX3BvcnRfZmRtaV9zZW5kX3JoYmEoZmRtaSwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29mZmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmZmRtaS0+dGltZXIpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKgorKiBSUFJUIDogUmVnaXN0ZXIgUG9ydAorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfc21fc2VuZGluZ19ycHJ0KHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJCSAgZW51bSBwb3J0X2ZkbWlfZXZlbnQgZXZlbnQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gZmRtaS0+bXMtPnBvcnQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEZETUlTTV9FVkVOVF9SUFJUX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fcnBydCk7CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF93YWxsb2NfY2FuY2VsKEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQocG9ydCksCisJCQkJICAgICAgICZmZG1pLT5mY3hwX3dxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfZmRtaV9zbV9ycHJ0KHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJICBlbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgRkRNSVNNX0VWRU5UX1JTUF9FUlJPUjoKKwkJLyoKKwkJICogaWYgbWF4IHJldHJpZXMgaGF2ZSBub3QgYmVlbiByZWFjaGVkLCBzdGFydCB0aW1lciBmb3IgYQorCQkgKiBkZWxheWVkIHJldHJ5CisJCSAqLworCQlpZiAoZmRtaS0+cmV0cnlfY250KysgPCBCRkFfRkNTX0ZETUlfQ01EX01BWF9SRVRSSUVTKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX3JwcnRfcmV0cnkpOworCQkJYmZhX3RpbWVyX3N0YXJ0KEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQocG9ydCksCisJCQkJCSZmZG1pLT50aW1lciwgYmZhX2Zjc19wb3J0X2ZkbWlfdGltZW91dCwKKwkJCQkJZmRtaSwgQkZBX0ZDU19SRVRSWV9USU1FT1VUKTsKKworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIHNldCBzdGF0ZSB0byBvZmZsaW5lCisJCQkgKi8KKwkJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fb2ZmbGluZSk7CisJCQlmZG1pLT5yZXRyeV9jbnQgPSAwOworCQl9CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUlNQX09LOgorCQlmZG1pLT5yZXRyeV9jbnQgPSAwOworCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29ubGluZSk7CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfZmN4cF9kaXNjYXJkKGZkbWktPmZjeHApOworCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29mZmxpbmUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfc21fcnBydF9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCQllbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgRkRNSVNNX0VWRU5UX1RJTUVPVVQ6CisJCS8qCisJCSAqIFJldHJ5IFRpbWVyIEV4cGlyZWQuIFJlLXNlbmQKKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fc2VuZGluZ19ycHJ0KTsKKwkJYmZhX2Zjc19wb3J0X2ZkbWlfc2VuZF9ycHJ0KGZkbWksIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgRkRNSVNNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShmZG1pLCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJmZkbWktPnRpbWVyKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoKKyAqIFJlZ2lzdGVyIFBvcnQgQXR0cmlidXRlcworICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfc21fc2VuZGluZ19ycGEoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQkJIGVudW0gcG9ydF9mZG1pX2V2ZW50IGV2ZW50KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IGZkbWktPm1zLT5wb3J0OworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMocG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBGRE1JU01fRVZFTlRfUlBBX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fcnBhKTsKKwkJYnJlYWs7CisKKwljYXNlIEZETUlTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChwb3J0KSwKKwkJCQkgICAgICAgJmZkbWktPmZjeHBfd3FlKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9mZG1pX3NtX3JwYShzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCSBlbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgRkRNSVNNX0VWRU5UX1JTUF9FUlJPUjoKKwkJLyoKKwkJICogaWYgbWF4IHJldHJpZXMgaGF2ZSBub3QgYmVlbiByZWFjaGVkLCBzdGFydCB0aW1lciBmb3IgYQorCQkgKiBkZWxheWVkIHJldHJ5CisJCSAqLworCQlpZiAoZmRtaS0+cmV0cnlfY250KysgPCBCRkFfRkNTX0ZETUlfQ01EX01BWF9SRVRSSUVTKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX3JwYV9yZXRyeSk7CisJCQliZmFfdGltZXJfc3RhcnQoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChwb3J0KSwKKwkJCQkJJmZkbWktPnRpbWVyLCBiZmFfZmNzX3BvcnRfZmRtaV90aW1lb3V0LAorCQkJCQlmZG1pLCBCRkFfRkNTX1JFVFJZX1RJTUVPVVQpOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIHNldCBzdGF0ZSB0byBvZmZsaW5lCisJCQkgKi8KKwkJCWJmYV9zbV9zZXRfc3RhdGUoZmRtaSwgYmZhX2Zjc19wb3J0X2ZkbWlfc21fb2ZmbGluZSk7CisJCQlmZG1pLT5yZXRyeV9jbnQgPSAwOworCQl9CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUlNQX09LOgorCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29ubGluZSk7CisJCWZkbWktPnJldHJ5X2NudCA9IDA7CisJCWJyZWFrOworCisJY2FzZSBGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfZmN4cF9kaXNjYXJkKGZkbWktPmZjeHApOworCQliZmFfc21fc2V0X3N0YXRlKGZkbWksIGJmYV9mY3NfcG9ydF9mZG1pX3NtX29mZmxpbmUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfc21fcnBhX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJICAgICAgIGVudW0gcG9ydF9mZG1pX2V2ZW50IGV2ZW50KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IGZkbWktPm1zLT5wb3J0OworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMocG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBGRE1JU01fRVZFTlRfVElNRU9VVDoKKwkJLyoKKwkJICogUmV0cnkgVGltZXIgRXhwaXJlZC4gUmUtc2VuZAorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShmZG1pLCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9zZW5kaW5nX3JwYSk7CisJCWJmYV9mY3NfcG9ydF9mZG1pX3NlbmRfcnBhKGZkbWksIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgRkRNSVNNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShmZG1pLCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJmZkbWktPnRpbWVyKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9mZG1pX3NtX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCSAgICBlbnVtIHBvcnRfZmRtaV9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgRkRNSVNNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShmZG1pLCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9vZmZsaW5lKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworCisvKioKKyogICBSSEJBIDogUmVnaXN0ZXIgSEJBIEF0dHJpYnV0ZXMuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfZmRtaV9zZW5kX3JoYmEodm9pZCAqZmRtaV9jYmFyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSA9IGZkbWlfY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gZmRtaS0+bXMtPnBvcnQ7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCWludCAgICAgICAgICAgICBsZW4sIGF0dHJfbGVuOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCXU4ICAgICAgICAqcHlsZDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJmZkbWktPmZjeHBfd3FlLAorCQkJCSAgICBiZmFfZmNzX3BvcnRfZmRtaV9zZW5kX3JoYmEsIGZkbWkpOworCQlyZXR1cm47CisJfQorCWZkbWktPmZjeHAgPSBmY3hwOworCisJcHlsZCA9IGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCk7CisJYmZhX29zX21lbXNldChweWxkLCAwLCBGQ19NQVhfUERVU1opOworCisJbGVuID0gZmNfZmRtaV9yZXFoZHJfYnVpbGQoJmZjaHMsIHB5bGQsIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwKKwkJCQkgICBGRE1JX1JIQkEpOworCisJYXR0cl9sZW4gPSBiZmFfZmNzX3BvcnRfZmRtaV9idWlsZF9yaGJhX3B5bGQoZmRtaSwKKwkJCSh1OCAqKSAoKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkICsgMSkpOworCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBOVUxMLCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsIEJGQV9GQUxTRSwKKwkJICAgICAgRkNfQ0xBU1NfMywgKGxlbiArIGF0dHJfbGVuKSwgJmZjaHMsCisJCSAgICAgIGJmYV9mY3NfcG9ydF9mZG1pX3JoYmFfcmVzcG9uc2UsICh2b2lkICopZmRtaSwKKwkJICAgICAgRkNfTUFYX1BEVVNaLCBGQ19SQV9UT1YpOworCisJYmZhX3NtX3NlbmRfZXZlbnQoZmRtaSwgRkRNSVNNX0VWRU5UX1JIQkFfU0VOVCk7Cit9CisKK3N0YXRpYyAgICAgICAgICB1MTYKK2JmYV9mY3NfcG9ydF9mZG1pX2J1aWxkX3JoYmFfcHlsZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCQkgIHU4ICpweWxkKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IGZkbWktPm1zLT5wb3J0OworCXN0cnVjdCBiZmFfZmNzX2ZkbWlfaGJhX2F0dHJfcyBoYmFfYXR0cjsJLyogQHRvZG8gKi8KKwlzdHJ1Y3QgYmZhX2Zjc19mZG1pX2hiYV9hdHRyX3MgKmZjc19oYmFfYXR0ciA9ICZoYmFfYXR0cjsgLyogQHRvZG8gKi8KKwlzdHJ1Y3QgZmRtaV9yaGJhX3MgICAgKnJoYmEgPSAoc3RydWN0IGZkbWlfcmhiYV9zICopIHB5bGQ7CisJc3RydWN0IGZkbWlfYXR0cl9zICAgICphdHRyOworCXU4ICAgICAgICAqY3Vycl9wdHI7CisJdTE2ICAgICAgICBsZW4sIGNvdW50OworCisJLyoKKwkgKiBnZXQgaGJhIGF0dHJpYnV0ZXMKKwkgKi8KKwliZmFfZmNzX2ZkbWlfZ2V0X2hiYWF0dHIoZmRtaSwgZmNzX2hiYV9hdHRyKTsKKworCXJoYmEtPmhiYV9pZCA9IGJmYV9mY3NfcG9ydF9nZXRfcHd3bihwb3J0KTsKKwlyaGJhLT5wb3J0X2xpc3QubnVtX3BvcnRzID0gYmZhX29zX2h0b25sKDEpOworCXJoYmEtPnBvcnRfbGlzdC5wb3J0X2VudHJ5ID0gYmZhX2Zjc19wb3J0X2dldF9wd3duKHBvcnQpOworCisJbGVuID0gc2l6ZW9mKHJoYmEtPmhiYV9pZCkgKyBzaXplb2YocmhiYS0+cG9ydF9saXN0KTsKKworCWNvdW50ID0gMDsKKwlsZW4gKz0gc2l6ZW9mKHJoYmEtPmhiYV9hdHRyX2Jsay5hdHRyX2NvdW50KTsKKworCS8qCisJICogZmlsbCBvdXQgdGhlIGludmlkaWR1YWwgZW50cmllcyBvZiB0aGUgSEJBIGF0dHJpYiBCbG9jaworCSAqLworCWN1cnJfcHRyID0gKHU4ICopICZyaGJhLT5oYmFfYXR0cl9ibGsuaGJhX2F0dHI7CisKKwkvKgorCSAqIE5vZGUgTmFtZQorCSAqLworCWF0dHIgPSAoc3RydWN0IGZkbWlfYXR0cl9zICopIGN1cnJfcHRyOworCWF0dHItPnR5cGUgPSBiZmFfb3NfaHRvbnMoRkRNSV9IQkFfQVRUUklCX05PREVOQU1FKTsKKwlhdHRyLT5sZW4gPSBzaXplb2Yod3duX3QpOworCW1lbWNweShhdHRyLT52YWx1ZSwgJmJmYV9mY3NfcG9ydF9nZXRfbnd3bihwb3J0KSwgYXR0ci0+bGVuKTsKKwljdXJyX3B0ciArPSBzaXplb2YoYXR0ci0+dHlwZSkgKyBzaXplb2YoYXR0ci0+bGVuKSArIGF0dHItPmxlbjsKKwlsZW4gKz0gYXR0ci0+bGVuOworCWNvdW50Kys7CisJYXR0ci0+bGVuID0KKwkJYmZhX29zX2h0b25zKGF0dHItPmxlbiArIHNpemVvZihhdHRyLT50eXBlKSArCisJCQkgICAgIHNpemVvZihhdHRyLT5sZW4pKTsKKworCS8qCisJICogTWFudWZhY3R1cmVyCisJICovCisJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfTUFOVUZBQ1RVUkVSKTsKKwlhdHRyLT5sZW4gPSAodTE2KSBzdHJsZW4oZmNzX2hiYV9hdHRyLT5tYW51ZmFjdHVyZXIpOworCW1lbWNweShhdHRyLT52YWx1ZSwgZmNzX2hiYV9hdHRyLT5tYW51ZmFjdHVyZXIsIGF0dHItPmxlbik7CisJLyogdmFyaWFibGUgZmllbGRzIG5lZWQgdG8gYmUgNCBieXRlIGFsaWduZWQgKi8KKwlhdHRyLT5sZW4gPSBmY19yb3VuZHVwKGF0dHItPmxlbiwgc2l6ZW9mKHUzMikpOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47CisJY291bnQrKzsKKwlhdHRyLT5sZW4gPQorCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJLyoKKwkgKiBTZXJpYWwgTnVtYmVyCisJICovCisJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfU0VSSUFMTlVNKTsKKwlhdHRyLT5sZW4gPSAodTE2KSBzdHJsZW4oZmNzX2hiYV9hdHRyLT5zZXJpYWxfbnVtKTsKKwltZW1jcHkoYXR0ci0+dmFsdWUsIGZjc19oYmFfYXR0ci0+c2VyaWFsX251bSwgYXR0ci0+bGVuKTsKKwkvKiB2YXJpYWJsZSBmaWVsZHMgbmVlZCB0byBiZSA0IGJ5dGUgYWxpZ25lZCAqLworCWF0dHItPmxlbiA9IGZjX3JvdW5kdXAoYXR0ci0+bGVuLCBzaXplb2YodTMyKSk7CisJY3Vycl9wdHIgKz0gc2l6ZW9mKGF0dHItPnR5cGUpICsgc2l6ZW9mKGF0dHItPmxlbikgKyBhdHRyLT5sZW47CisJbGVuICs9IGF0dHItPmxlbjsKKwljb3VudCsrOworCWF0dHItPmxlbiA9CisJCWJmYV9vc19odG9ucyhhdHRyLT5sZW4gKyBzaXplb2YoYXR0ci0+dHlwZSkgKworCQkJICAgICBzaXplb2YoYXR0ci0+bGVuKSk7CisKKwkvKgorCSAqIE1vZGVsCisJICovCisJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfTU9ERUwpOworCWF0dHItPmxlbiA9ICh1MTYpIHN0cmxlbihmY3NfaGJhX2F0dHItPm1vZGVsKTsKKwltZW1jcHkoYXR0ci0+dmFsdWUsIGZjc19oYmFfYXR0ci0+bW9kZWwsIGF0dHItPmxlbik7CisJLyogdmFyaWFibGUgZmllbGRzIG5lZWQgdG8gYmUgNCBieXRlIGFsaWduZWQgKi8KKwlhdHRyLT5sZW4gPSBmY19yb3VuZHVwKGF0dHItPmxlbiwgc2l6ZW9mKHUzMikpOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47CisJY291bnQrKzsKKwlhdHRyLT5sZW4gPQorCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJLyoKKwkgKiBNb2RlbCBEZXNjCisJICovCisJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfTU9ERUxfREVTQyk7CisJYXR0ci0+bGVuID0gKHUxNikgc3RybGVuKGZjc19oYmFfYXR0ci0+bW9kZWxfZGVzYyk7CisJbWVtY3B5KGF0dHItPnZhbHVlLCBmY3NfaGJhX2F0dHItPm1vZGVsX2Rlc2MsIGF0dHItPmxlbik7CisJLyogdmFyaWFibGUgZmllbGRzIG5lZWQgdG8gYmUgNCBieXRlIGFsaWduZWQgKi8KKwlhdHRyLT5sZW4gPSBmY19yb3VuZHVwKGF0dHItPmxlbiwgc2l6ZW9mKHUzMikpOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47CisJY291bnQrKzsKKwlhdHRyLT5sZW4gPQorCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJLyoKKwkgKiBIL1cgVmVyc2lvbgorCSAqLworCWlmIChmY3NfaGJhX2F0dHItPmh3X3ZlcnNpb25bMF0gIT0gJ1wwJykgeworCQlhdHRyID0gKHN0cnVjdCBmZG1pX2F0dHJfcyAqKSBjdXJyX3B0cjsKKwkJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfSFdfVkVSU0lPTik7CisJCWF0dHItPmxlbiA9ICh1MTYpIHN0cmxlbihmY3NfaGJhX2F0dHItPmh3X3ZlcnNpb24pOworCQltZW1jcHkoYXR0ci0+dmFsdWUsIGZjc19oYmFfYXR0ci0+aHdfdmVyc2lvbiwgYXR0ci0+bGVuKTsKKwkJLyogdmFyaWFibGUgZmllbGRzIG5lZWQgdG8gYmUgNCBieXRlIGFsaWduZWQgKi8KKwkJYXR0ci0+bGVuID0gZmNfcm91bmR1cChhdHRyLT5sZW4sIHNpemVvZih1MzIpKTsKKwkJY3Vycl9wdHIgKz0gc2l6ZW9mKGF0dHItPnR5cGUpICsgc2l6ZW9mKGF0dHItPmxlbikgKyBhdHRyLT5sZW47CisJCWxlbiArPSBhdHRyLT5sZW47CisJCWNvdW50Kys7CisJCWF0dHItPmxlbiA9CisJCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCQkgICAgIHNpemVvZihhdHRyLT5sZW4pKTsKKwl9CisKKwkvKgorCSAqIERyaXZlciBWZXJzaW9uCisJICovCisJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfRFJJVkVSX1ZFUlNJT04pOworCWF0dHItPmxlbiA9ICh1MTYpIHN0cmxlbihmY3NfaGJhX2F0dHItPmRyaXZlcl92ZXJzaW9uKTsKKwltZW1jcHkoYXR0ci0+dmFsdWUsIGZjc19oYmFfYXR0ci0+ZHJpdmVyX3ZlcnNpb24sIGF0dHItPmxlbik7CisJLyogdmFyaWFibGUgZmllbGRzIG5lZWQgdG8gYmUgNCBieXRlIGFsaWduZWQgKi8KKwlhdHRyLT5sZW4gPSBmY19yb3VuZHVwKGF0dHItPmxlbiwgc2l6ZW9mKHUzMikpOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47OworCWNvdW50Kys7CisJYXR0ci0+bGVuID0KKwkJYmZhX29zX2h0b25zKGF0dHItPmxlbiArIHNpemVvZihhdHRyLT50eXBlKSArCisJCQkgICAgIHNpemVvZihhdHRyLT5sZW4pKTsKKworCS8qCisJICogT3B0aW9uIFJvbSBWZXJzaW9uCisJICovCisJaWYgKGZjc19oYmFfYXR0ci0+b3B0aW9uX3JvbV92ZXJbMF0gIT0gJ1wwJykgeworCQlhdHRyID0gKHN0cnVjdCBmZG1pX2F0dHJfcyAqKSBjdXJyX3B0cjsKKwkJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfUk9NX1ZFUlNJT04pOworCQlhdHRyLT5sZW4gPSAodTE2KSBzdHJsZW4oZmNzX2hiYV9hdHRyLT5vcHRpb25fcm9tX3Zlcik7CisJCW1lbWNweShhdHRyLT52YWx1ZSwgZmNzX2hiYV9hdHRyLT5vcHRpb25fcm9tX3ZlciwgYXR0ci0+bGVuKTsKKwkJLyogdmFyaWFibGUgZmllbGRzIG5lZWQgdG8gYmUgNCBieXRlIGFsaWduZWQgKi8KKwkJYXR0ci0+bGVuID0gZmNfcm91bmR1cChhdHRyLT5sZW4sIHNpemVvZih1MzIpKTsKKwkJY3Vycl9wdHIgKz0gc2l6ZW9mKGF0dHItPnR5cGUpICsgc2l6ZW9mKGF0dHItPmxlbikgKyBhdHRyLT5sZW47CisJCWxlbiArPSBhdHRyLT5sZW47CisJCWNvdW50Kys7CisJCWF0dHItPmxlbiA9CisJCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCQkgICAgIHNpemVvZihhdHRyLT5sZW4pKTsKKwl9CisKKwkvKgorCSAqIGYvdyBWZXJzaW9uID0gZHJpdmVyIHZlcnNpb24KKwkgKi8KKwlhdHRyID0gKHN0cnVjdCBmZG1pX2F0dHJfcyAqKSBjdXJyX3B0cjsKKwlhdHRyLT50eXBlID0gYmZhX29zX2h0b25zKEZETUlfSEJBX0FUVFJJQl9GV19WRVJTSU9OKTsKKwlhdHRyLT5sZW4gPSAodTE2KSBzdHJsZW4oZmNzX2hiYV9hdHRyLT5kcml2ZXJfdmVyc2lvbik7CisJbWVtY3B5KGF0dHItPnZhbHVlLCBmY3NfaGJhX2F0dHItPmRyaXZlcl92ZXJzaW9uLCBhdHRyLT5sZW4pOworCS8qIHZhcmlhYmxlIGZpZWxkcyBuZWVkIHRvIGJlIDQgYnl0ZSBhbGlnbmVkICovCisJYXR0ci0+bGVuID0gZmNfcm91bmR1cChhdHRyLT5sZW4sIHNpemVvZih1MzIpKTsKKwljdXJyX3B0ciArPSBzaXplb2YoYXR0ci0+dHlwZSkgKyBzaXplb2YoYXR0ci0+bGVuKSArIGF0dHItPmxlbjsKKwlsZW4gKz0gYXR0ci0+bGVuOworCWNvdW50Kys7CisJYXR0ci0+bGVuID0KKwkJYmZhX29zX2h0b25zKGF0dHItPmxlbiArIHNpemVvZihhdHRyLT50eXBlKSArCisJCQkgICAgIHNpemVvZihhdHRyLT5sZW4pKTsKKworCS8qCisJICogT1MgTmFtZQorCSAqLworCWlmIChmY3NfaGJhX2F0dHItPm9zX25hbWVbMF0gIT0gJ1wwJykgeworCQlhdHRyID0gKHN0cnVjdCBmZG1pX2F0dHJfcyAqKSBjdXJyX3B0cjsKKwkJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfT1NfTkFNRSk7CisJCWF0dHItPmxlbiA9ICh1MTYpIHN0cmxlbihmY3NfaGJhX2F0dHItPm9zX25hbWUpOworCQltZW1jcHkoYXR0ci0+dmFsdWUsIGZjc19oYmFfYXR0ci0+b3NfbmFtZSwgYXR0ci0+bGVuKTsKKwkJLyogdmFyaWFibGUgZmllbGRzIG5lZWQgdG8gYmUgNCBieXRlIGFsaWduZWQgKi8KKwkJYXR0ci0+bGVuID0gZmNfcm91bmR1cChhdHRyLT5sZW4sIHNpemVvZih1MzIpKTsKKwkJY3Vycl9wdHIgKz0gc2l6ZW9mKGF0dHItPnR5cGUpICsgc2l6ZW9mKGF0dHItPmxlbikgKyBhdHRyLT5sZW47CisJCWxlbiArPSBhdHRyLT5sZW47CisJCWNvdW50Kys7CisJCWF0dHItPmxlbiA9CisJCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCQkgICAgIHNpemVvZihhdHRyLT5sZW4pKTsKKwl9CisKKwkvKgorCSAqIE1BWF9DVF9QQVlMT0FECisJICovCisJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJYXR0ci0+dHlwZSA9IGJmYV9vc19odG9ucyhGRE1JX0hCQV9BVFRSSUJfTUFYX0NUKTsKKwlhdHRyLT5sZW4gPSBzaXplb2YoZmNzX2hiYV9hdHRyLT5tYXhfY3RfcHlsZCk7CisJbWVtY3B5KGF0dHItPnZhbHVlLCAmZmNzX2hiYV9hdHRyLT5tYXhfY3RfcHlsZCwgYXR0ci0+bGVuKTsKKwlsZW4gKz0gYXR0ci0+bGVuOworCWNvdW50Kys7CisJYXR0ci0+bGVuID0KKwkJYmZhX29zX2h0b25zKGF0dHItPmxlbiArIHNpemVvZihhdHRyLT50eXBlKSArCisJCQkgICAgIHNpemVvZihhdHRyLT5sZW4pKTsKKworCS8qCisJICogVXBkYXRlIHNpemUgb2YgcGF5bG9hZAorCSAqLworCWxlbiArPSAoKHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pKSAqIGNvdW50KTsKKworCXJoYmEtPmhiYV9hdHRyX2Jsay5hdHRyX2NvdW50ID0gYmZhX29zX2h0b25sKGNvdW50KTsKKwlyZXR1cm4gbGVuOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfcmhiYV9yZXNwb25zZSh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCXZvaWQgKmNiYXJnLCBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQl1MzIgcnNwX2xlbiwgdTMyIHJlc2lkX2xlbiwKKwkJCQlzdHJ1Y3QgZmNoc19zICpyc3BfZmNocykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSA9IChzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqKWNiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IGZkbWktPm1zLT5wb3J0OworCXN0cnVjdCBjdF9oZHJfcyAgICAgICAqY3RoZHIgPSBOVUxMOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGZkbWksIEZETUlTTV9FVkVOVF9SU1BfRVJST1IpOworCQlyZXR1cm47CisJfQorCisJY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIEJGQV9GQ1hQX1JTUF9QTEQoZmN4cCk7CisJY3RoZHItPmNtZF9yc3BfY29kZSA9IGJmYV9vc19udG9ocyhjdGhkci0+Y21kX3JzcF9jb2RlKTsKKworCWlmIChjdGhkci0+Y21kX3JzcF9jb2RlID09IENUX1JTUF9BQ0NFUFQpIHsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoZmRtaSwgRkRNSVNNX0VWRU5UX1JTUF9PSyk7CisJCXJldHVybjsKKwl9CisKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPnJlYXNvbl9jb2RlKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPmV4cF9jb2RlKTsKKwliZmFfc21fc2VuZF9ldmVudChmZG1pLCBGRE1JU01fRVZFTlRfUlNQX0VSUk9SKTsKK30KKworLyoqCisqICAgUlBSVCA6IFJlZ2lzdGVyIFBvcnQKKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9mZG1pX3NlbmRfcnBydCh2b2lkICpmZG1pX2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pID0gZmRtaV9jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJdTE2ICAgICAgICBsZW4sIGF0dHJfbGVuOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCXU4ICAgICAgICAqcHlsZDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJmZkbWktPmZjeHBfd3FlLAorCQkJCSAgICBiZmFfZmNzX3BvcnRfZmRtaV9zZW5kX3JwcnQsIGZkbWkpOworCQlyZXR1cm47CisJfQorCWZkbWktPmZjeHAgPSBmY3hwOworCisJcHlsZCA9IGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCk7CisJYmZhX29zX21lbXNldChweWxkLCAwLCBGQ19NQVhfUERVU1opOworCisJbGVuID0gZmNfZmRtaV9yZXFoZHJfYnVpbGQoJmZjaHMsIHB5bGQsIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwKKwkJCQkgICBGRE1JX1JQUlQpOworCisJYXR0cl9sZW4gPSBiZmFfZmNzX3BvcnRfZmRtaV9idWlsZF9ycHJ0X3B5bGQoZmRtaSwKKwkJCSh1OCAqKSAoKHN0cnVjdCBjdF9oZHJfcyAqKSBweWxkICsgMSkpOworCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBOVUxMLCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsIEJGQV9GQUxTRSwKKwkJICAgICAgRkNfQ0xBU1NfMywgbGVuICsgYXR0cl9sZW4sICZmY2hzLAorCQkgICAgICBiZmFfZmNzX3BvcnRfZmRtaV9ycHJ0X3Jlc3BvbnNlLCAodm9pZCAqKWZkbWksCisJCSAgICAgIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKworCWJmYV9zbV9zZW5kX2V2ZW50KGZkbWksIEZETUlTTV9FVkVOVF9SUFJUX1NFTlQpOworfQorCisvKioKKyAqIFRoaXMgcm91dGluZSBidWlsZHMgUG9ydCBBdHRyaWJ1dGUgQmxvY2sgdGhhdCB1c2VkIGluIFJQQSwgUlBSVCBjb21tYW5kcy4KKyAqLworc3RhdGljICAgICAgICAgIHUxNgorYmZhX2Zjc19wb3J0X2ZkbWlfYnVpbGRfcG9ydGF0dHJfYmxvY2soc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQkJICAgICAgIHU4ICpweWxkKQoreworCXN0cnVjdCBiZmFfZmNzX2ZkbWlfcG9ydF9hdHRyX3MgZmNzX3BvcnRfYXR0cjsKKwlzdHJ1Y3QgZmRtaV9wb3J0X2F0dHJfcyAqcG9ydF9hdHRyaWIgPSAoc3RydWN0IGZkbWlfcG9ydF9hdHRyX3MgKikgcHlsZDsKKwlzdHJ1Y3QgZmRtaV9hdHRyX3MgICAgKmF0dHI7CisJdTggICAgICAgICpjdXJyX3B0cjsKKwl1MTYgICAgICAgIGxlbjsKKwl1OCAgICAgICAgIGNvdW50ID0gMDsKKworCS8qCisJICogZ2V0IHBvcnQgYXR0cmlidXRlcworCSAqLworCWJmYV9mY3NfZmRtaV9nZXRfcG9ydGF0dHIoZmRtaSwgJmZjc19wb3J0X2F0dHIpOworCisJbGVuID0gc2l6ZW9mKHBvcnRfYXR0cmliLT5hdHRyX2NvdW50KTsKKworCS8qCisJICogZmlsbCBvdXQgdGhlIGludmlkaWR1YWwgZW50cmllcworCSAqLworCWN1cnJfcHRyID0gKHU4ICopICZwb3J0X2F0dHJpYi0+cG9ydF9hdHRyOworCisJLyoKKwkgKiBGQzQgVHlwZXMKKwkgKi8KKwlhdHRyID0gKHN0cnVjdCBmZG1pX2F0dHJfcyAqKSBjdXJyX3B0cjsKKwlhdHRyLT50eXBlID0gYmZhX29zX2h0b25zKEZETUlfUE9SVF9BVFRSSUJfRkM0X1RZUEVTKTsKKwlhdHRyLT5sZW4gPSBzaXplb2YoZmNzX3BvcnRfYXR0ci5zdXBwX2ZjNF90eXBlcyk7CisJbWVtY3B5KGF0dHItPnZhbHVlLCBmY3NfcG9ydF9hdHRyLnN1cHBfZmM0X3R5cGVzLCBhdHRyLT5sZW4pOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47CisJKytjb3VudDsKKwlhdHRyLT5sZW4gPQorCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJLyoKKwkgKiBTdXBwb3J0ZWQgU3BlZWQKKwkgKi8KKwlhdHRyID0gKHN0cnVjdCBmZG1pX2F0dHJfcyAqKSBjdXJyX3B0cjsKKwlhdHRyLT50eXBlID0gYmZhX29zX2h0b25zKEZETUlfUE9SVF9BVFRSSUJfU1VQUF9TUEVFRCk7CisJYXR0ci0+bGVuID0gc2l6ZW9mKGZjc19wb3J0X2F0dHIuc3VwcF9zcGVlZCk7CisJbWVtY3B5KGF0dHItPnZhbHVlLCAmZmNzX3BvcnRfYXR0ci5zdXBwX3NwZWVkLCBhdHRyLT5sZW4pOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47CisJKytjb3VudDsKKwlhdHRyLT5sZW4gPQorCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJLyoKKwkgKiBjdXJyZW50IFBvcnQgU3BlZWQKKwkgKi8KKwlhdHRyID0gKHN0cnVjdCBmZG1pX2F0dHJfcyAqKSBjdXJyX3B0cjsKKwlhdHRyLT50eXBlID0gYmZhX29zX2h0b25zKEZETUlfUE9SVF9BVFRSSUJfUE9SVF9TUEVFRCk7CisJYXR0ci0+bGVuID0gc2l6ZW9mKGZjc19wb3J0X2F0dHIuY3Vycl9zcGVlZCk7CisJbWVtY3B5KGF0dHItPnZhbHVlLCAmZmNzX3BvcnRfYXR0ci5jdXJyX3NwZWVkLCBhdHRyLT5sZW4pOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47CisJKytjb3VudDsKKwlhdHRyLT5sZW4gPQorCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJLyoKKwkgKiBtYXggZnJhbWUgc2l6ZQorCSAqLworCWF0dHIgPSAoc3RydWN0IGZkbWlfYXR0cl9zICopIGN1cnJfcHRyOworCWF0dHItPnR5cGUgPSBiZmFfb3NfaHRvbnMoRkRNSV9QT1JUX0FUVFJJQl9GUkFNRV9TSVpFKTsKKwlhdHRyLT5sZW4gPSBzaXplb2YoZmNzX3BvcnRfYXR0ci5tYXhfZnJtX3NpemUpOworCW1lbWNweShhdHRyLT52YWx1ZSwgJmZjc19wb3J0X2F0dHIubWF4X2ZybV9zaXplLCBhdHRyLT5sZW4pOworCWN1cnJfcHRyICs9IHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pICsgYXR0ci0+bGVuOworCWxlbiArPSBhdHRyLT5sZW47CisJKytjb3VudDsKKwlhdHRyLT5sZW4gPQorCQliZmFfb3NfaHRvbnMoYXR0ci0+bGVuICsgc2l6ZW9mKGF0dHItPnR5cGUpICsKKwkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJLyoKKwkgKiBPUyBEZXZpY2UgTmFtZQorCSAqLworCWlmIChmY3NfcG9ydF9hdHRyLm9zX2RldmljZV9uYW1lWzBdICE9ICdcMCcpIHsKKwkJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJCWF0dHItPnR5cGUgPSBiZmFfb3NfaHRvbnMoRkRNSV9QT1JUX0FUVFJJQl9ERVZfTkFNRSk7CisJCWF0dHItPmxlbiA9ICh1MTYpIHN0cmxlbihmY3NfcG9ydF9hdHRyLm9zX2RldmljZV9uYW1lKTsKKwkJbWVtY3B5KGF0dHItPnZhbHVlLCBmY3NfcG9ydF9hdHRyLm9zX2RldmljZV9uYW1lLCBhdHRyLT5sZW4pOworCQkvKiB2YXJpYWJsZSBmaWVsZHMgbmVlZCB0byBiZSA0IGJ5dGUgYWxpZ25lZCAqLworCQlhdHRyLT5sZW4gPSBmY19yb3VuZHVwKGF0dHItPmxlbiwgc2l6ZW9mKHUzMikpOworCQljdXJyX3B0ciArPSBzaXplb2YoYXR0ci0+dHlwZSkgKyBzaXplb2YoYXR0ci0+bGVuKSArIGF0dHItPmxlbjsKKwkJbGVuICs9IGF0dHItPmxlbjsKKwkJKytjb3VudDsKKwkJYXR0ci0+bGVuID0KKwkJCWJmYV9vc19odG9ucyhhdHRyLT5sZW4gKyBzaXplb2YoYXR0ci0+dHlwZSkgKworCQkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJfQorCS8qCisJICogSG9zdCBOYW1lCisJICovCisJaWYgKGZjc19wb3J0X2F0dHIuaG9zdF9uYW1lWzBdICE9ICdcMCcpIHsKKwkJYXR0ciA9IChzdHJ1Y3QgZmRtaV9hdHRyX3MgKikgY3Vycl9wdHI7CisJCWF0dHItPnR5cGUgPSBiZmFfb3NfaHRvbnMoRkRNSV9QT1JUX0FUVFJJQl9IT1NUX05BTUUpOworCQlhdHRyLT5sZW4gPSAodTE2KSBzdHJsZW4oZmNzX3BvcnRfYXR0ci5ob3N0X25hbWUpOworCQltZW1jcHkoYXR0ci0+dmFsdWUsIGZjc19wb3J0X2F0dHIuaG9zdF9uYW1lLCBhdHRyLT5sZW4pOworCQkvKiB2YXJpYWJsZSBmaWVsZHMgbmVlZCB0byBiZSA0IGJ5dGUgYWxpZ25lZCAqLworCQlhdHRyLT5sZW4gPSBmY19yb3VuZHVwKGF0dHItPmxlbiwgc2l6ZW9mKHUzMikpOworCQljdXJyX3B0ciArPSBzaXplb2YoYXR0ci0+dHlwZSkgKyBzaXplb2YoYXR0ci0+bGVuKSArIGF0dHItPmxlbjsKKwkJbGVuICs9IGF0dHItPmxlbjsKKwkJKytjb3VudDsKKwkJYXR0ci0+bGVuID0KKwkJCWJmYV9vc19odG9ucyhhdHRyLT5sZW4gKyBzaXplb2YoYXR0ci0+dHlwZSkgKworCQkJCSAgICAgc2l6ZW9mKGF0dHItPmxlbikpOworCisJfQorCisJLyoKKwkgKiBVcGRhdGUgc2l6ZSBvZiBwYXlsb2FkCisJICovCisJcG9ydF9hdHRyaWItPmF0dHJfY291bnQgPSBiZmFfb3NfaHRvbmwoY291bnQpOworCWxlbiArPSAoKHNpemVvZihhdHRyLT50eXBlKSArIHNpemVvZihhdHRyLT5sZW4pKSAqIGNvdW50KTsKKwlyZXR1cm4gbGVuOworfQorCitzdGF0aWMgICAgICAgICAgdTE2CitiZmFfZmNzX3BvcnRfZmRtaV9idWlsZF9ycHJ0X3B5bGQoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWksCisJCQkJICB1OCAqcHlsZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKwlzdHJ1Y3QgZmRtaV9ycHJ0X3MgICAgKnJwcnQgPSAoc3RydWN0IGZkbWlfcnBydF9zICopIHB5bGQ7CisJdTE2ICAgICAgICBsZW47CisKKwlycHJ0LT5oYmFfaWQgPSBiZmFfZmNzX3BvcnRfZ2V0X3B3d24oYmZhX2Zjc19nZXRfYmFzZV9wb3J0KHBvcnQtPmZjcykpOworCXJwcnQtPnBvcnRfbmFtZSA9IGJmYV9mY3NfcG9ydF9nZXRfcHd3bihwb3J0KTsKKworCWxlbiA9IGJmYV9mY3NfcG9ydF9mZG1pX2J1aWxkX3BvcnRhdHRyX2Jsb2NrKGZkbWksCisJCQkodTggKikgJnJwcnQtPnBvcnRfYXR0cl9ibGspOworCisJbGVuICs9IHNpemVvZihycHJ0LT5oYmFfaWQpICsgc2l6ZW9mKHJwcnQtPnBvcnRfbmFtZSk7CisKKwlyZXR1cm4gbGVuOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfcnBydF9yZXNwb25zZSh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCXZvaWQgKmNiYXJnLCBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQl1MzIgcnNwX2xlbiwgdTMyIHJlc2lkX2xlbiwKKwkJCQlzdHJ1Y3QgZmNoc19zICpyc3BfZmNocykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSA9IChzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqKWNiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IGZkbWktPm1zLT5wb3J0OworCXN0cnVjdCBjdF9oZHJfcyAgICAgICAqY3RoZHIgPSBOVUxMOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCWJmYV9zbV9zZW5kX2V2ZW50KGZkbWksIEZETUlTTV9FVkVOVF9SU1BfRVJST1IpOworCQlyZXR1cm47CisJfQorCisJY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIEJGQV9GQ1hQX1JTUF9QTEQoZmN4cCk7CisJY3RoZHItPmNtZF9yc3BfY29kZSA9IGJmYV9vc19udG9ocyhjdGhkci0+Y21kX3JzcF9jb2RlKTsKKworCWlmIChjdGhkci0+Y21kX3JzcF9jb2RlID09IENUX1JTUF9BQ0NFUFQpIHsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoZmRtaSwgRkRNSVNNX0VWRU5UX1JTUF9PSyk7CisJCXJldHVybjsKKwl9CisKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPnJlYXNvbl9jb2RlKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPmV4cF9jb2RlKTsKKwliZmFfc21fc2VuZF9ldmVudChmZG1pLCBGRE1JU01fRVZFTlRfUlNQX0VSUk9SKTsKK30KKworLyoqCisqICAgUlBBIDogUmVnaXN0ZXIgUG9ydCBBdHRyaWJ1dGVzLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfc2VuZF9ycGEodm9pZCAqZmRtaV9jYmFyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSA9IGZkbWlfY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gZmRtaS0+bXMtPnBvcnQ7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCXUxNiAgICAgICAgbGVuLCBhdHRyX2xlbjsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwl1OCAgICAgICAgKnB5bGQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cG9ydF9jZmcucHd3bik7CisKKwlmY3hwID0gZmN4cF9hbGxvY2VkID8gZmN4cF9hbGxvY2VkIDogYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKSB7CisJCWJmYV9mY3hwX2FsbG9jX3dhaXQocG9ydC0+ZmNzLT5iZmEsICZmZG1pLT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19wb3J0X2ZkbWlfc2VuZF9ycGEsIGZkbWkpOworCQlyZXR1cm47CisJfQorCWZkbWktPmZjeHAgPSBmY3hwOworCisJcHlsZCA9IGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCk7CisJYmZhX29zX21lbXNldChweWxkLCAwLCBGQ19NQVhfUERVU1opOworCisJbGVuID0gZmNfZmRtaV9yZXFoZHJfYnVpbGQoJmZjaHMsIHB5bGQsIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwKKwkJCQkgICBGRE1JX1JQQSk7CisKKwlhdHRyX2xlbiA9IGJmYV9mY3NfcG9ydF9mZG1pX2J1aWxkX3JwYV9weWxkKGZkbWksCisJCQkodTggKikgKChzdHJ1Y3QgY3RfaGRyX3MgKikgcHlsZCArIDEpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiArIGF0dHJfbGVuLCAmZmNocywKKwkJICAgICAgYmZhX2Zjc19wb3J0X2ZkbWlfcnBhX3Jlc3BvbnNlLCAodm9pZCAqKWZkbWksCisJCSAgICAgIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKworCWJmYV9zbV9zZW5kX2V2ZW50KGZkbWksIEZETUlTTV9FVkVOVF9SUEFfU0VOVCk7Cit9CisKK3N0YXRpYyAgICAgICAgICB1MTYKK2JmYV9mY3NfcG9ydF9mZG1pX2J1aWxkX3JwYV9weWxkKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJCSB1OCAqcHlsZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBmZG1pLT5tcy0+cG9ydDsKKwlzdHJ1Y3QgZmRtaV9ycGFfcyAgICAgKnJwYSA9IChzdHJ1Y3QgZmRtaV9ycGFfcyAqKSBweWxkOworCXUxNiAgICAgICAgbGVuOworCisJcnBhLT5wb3J0X25hbWUgPSBiZmFfZmNzX3BvcnRfZ2V0X3B3d24ocG9ydCk7CisKKwlsZW4gPSBiZmFfZmNzX3BvcnRfZmRtaV9idWlsZF9wb3J0YXR0cl9ibG9jayhmZG1pLAorCQkJKHU4ICopICZycGEtPnBvcnRfYXR0cl9ibGspOworCisJbGVuICs9IHNpemVvZihycGEtPnBvcnRfbmFtZSk7CisKKwlyZXR1cm4gbGVuOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfcnBhX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkgICAgICAgdm9pZCAqY2JhcmcsIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJICAgICAgIHUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJICAgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICopY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gZmRtaS0+bXMtPnBvcnQ7CisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IE5VTEw7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cG9ydF9jZmcucHd3bik7CisKKwkvKgorCSAqIFNhbml0eSBDaGVja3MKKwkgKi8KKwlpZiAocmVxX3N0YXR1cyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByZXFfc3RhdHVzKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQoZmRtaSwgRkRNSVNNX0VWRU5UX1JTUF9FUlJPUik7CisJCXJldHVybjsKKwl9CisKKwljdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKwljdGhkci0+Y21kX3JzcF9jb2RlID0gYmZhX29zX250b2hzKGN0aGRyLT5jbWRfcnNwX2NvZGUpOworCisJaWYgKGN0aGRyLT5jbWRfcnNwX2NvZGUgPT0gQ1RfUlNQX0FDQ0VQVCkgeworCQliZmFfc21fc2VuZF9ldmVudChmZG1pLCBGRE1JU01fRVZFTlRfUlNQX09LKTsKKwkJcmV0dXJuOworCX0KKworCWJmYV90cmMocG9ydC0+ZmNzLCBjdGhkci0+cmVhc29uX2NvZGUpOworCWJmYV90cmMocG9ydC0+ZmNzLCBjdGhkci0+ZXhwX2NvZGUpOworCWJmYV9zbV9zZW5kX2V2ZW50KGZkbWksIEZETUlTTV9FVkVOVF9SU1BfRVJST1IpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfdGltZW91dCh2b2lkICphcmcpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWkgPSAoc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKilhcmc7CisKKwliZmFfc21fc2VuZF9ldmVudChmZG1pLCBGRE1JU01fRVZFTlRfVElNRU9VVCk7Cit9CisKK3ZvaWQKK2JmYV9mY3NfZmRtaV9nZXRfaGJhYXR0cihzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSwKKwkJCSBzdHJ1Y3QgYmZhX2Zjc19mZG1pX2hiYV9hdHRyX3MgKmhiYV9hdHRyKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IGZkbWktPm1zLT5wb3J0OworCXN0cnVjdCBiZmFfZmNzX2RyaXZlcl9pbmZvX3MgKmRyaXZlcl9pbmZvID0gJnBvcnQtPmZjcy0+ZHJpdmVyX2luZm87CisJc3RydWN0IGJmYV9hZGFwdGVyX2F0dHJfcyBhZGFwdGVyX2F0dHI7CisKKwliZmFfb3NfbWVtc2V0KGhiYV9hdHRyLCAwLCBzaXplb2Yoc3RydWN0IGJmYV9mY3NfZmRtaV9oYmFfYXR0cl9zKSk7CisJYmZhX29zX21lbXNldCgmYWRhcHRlcl9hdHRyLCAwLCBzaXplb2Yoc3RydWN0IGJmYV9hZGFwdGVyX2F0dHJfcykpOworCisJYmZhX2lvY19nZXRfYWRhcHRlcl9hdHRyKCZwb3J0LT5mY3MtPmJmYS0+aW9jLCAmYWRhcHRlcl9hdHRyKTsKKworCXN0cm5jcHkoaGJhX2F0dHItPm1hbnVmYWN0dXJlciwgYWRhcHRlcl9hdHRyLm1hbnVmYWN0dXJlciwKKwkJc2l6ZW9mKGFkYXB0ZXJfYXR0ci5tYW51ZmFjdHVyZXIpKTsKKworCXN0cm5jcHkoaGJhX2F0dHItPnNlcmlhbF9udW0sIGFkYXB0ZXJfYXR0ci5zZXJpYWxfbnVtLAorCQlzaXplb2YoYWRhcHRlcl9hdHRyLnNlcmlhbF9udW0pKTsKKworCXN0cm5jcHkoaGJhX2F0dHItPm1vZGVsLCBhZGFwdGVyX2F0dHIubW9kZWwsIHNpemVvZihoYmFfYXR0ci0+bW9kZWwpKTsKKworCXN0cm5jcHkoaGJhX2F0dHItPm1vZGVsX2Rlc2MsIGFkYXB0ZXJfYXR0ci5tb2RlbF9kZXNjciwKKwkJc2l6ZW9mKGhiYV9hdHRyLT5tb2RlbF9kZXNjKSk7CisKKwlzdHJuY3B5KGhiYV9hdHRyLT5od192ZXJzaW9uLCBhZGFwdGVyX2F0dHIuaHdfdmVyLAorCQlzaXplb2YoaGJhX2F0dHItPmh3X3ZlcnNpb24pKTsKKworCXN0cm5jcHkoaGJhX2F0dHItPmRyaXZlcl92ZXJzaW9uLCAoY2hhciAqKWRyaXZlcl9pbmZvLT52ZXJzaW9uLAorCQlzaXplb2YoaGJhX2F0dHItPmRyaXZlcl92ZXJzaW9uKSk7CisKKwlzdHJuY3B5KGhiYV9hdHRyLT5vcHRpb25fcm9tX3ZlciwgYWRhcHRlcl9hdHRyLm9wdHJvbV92ZXIsCisJCXNpemVvZihoYmFfYXR0ci0+b3B0aW9uX3JvbV92ZXIpKTsKKworCXN0cm5jcHkoaGJhX2F0dHItPmZ3X3ZlcnNpb24sIGFkYXB0ZXJfYXR0ci5md192ZXIsCisJCXNpemVvZihoYmFfYXR0ci0+ZndfdmVyc2lvbikpOworCisJc3RybmNweShoYmFfYXR0ci0+b3NfbmFtZSwgZHJpdmVyX2luZm8tPmhvc3Rfb3NfbmFtZSwKKwkJc2l6ZW9mKGhiYV9hdHRyLT5vc19uYW1lKSk7CisKKwkvKgorCSAqIElmIHRoZXJlIGlzIGEgcGF0Y2ggbGV2ZWwsIGFwcGVuZCBpdCB0byB0aGUgb3MgbmFtZSBhbG9uZyB3aXRoIGEKKwkgKiBzZXBhcmF0b3IKKwkgKi8KKwlpZiAoZHJpdmVyX2luZm8tPmhvc3Rfb3NfcGF0Y2hbMF0gIT0gJ1wwJykgeworCQlzdHJuY2F0KGhiYV9hdHRyLT5vc19uYW1lLCBCRkFfRkNTX1BPUlRfU1lNQk5BTUVfU0VQQVJBVE9SLAorCQkJc2l6ZW9mKEJGQV9GQ1NfUE9SVF9TWU1CTkFNRV9TRVBBUkFUT1IpKTsKKwkJc3RybmNhdChoYmFfYXR0ci0+b3NfbmFtZSwgZHJpdmVyX2luZm8tPmhvc3Rfb3NfcGF0Y2gsCisJCQlzaXplb2YoZHJpdmVyX2luZm8tPmhvc3Rfb3NfcGF0Y2gpKTsKKwl9CisKKwloYmFfYXR0ci0+bWF4X2N0X3B5bGQgPSBiZmFfb3NfaHRvbmwoRkNfTUFYX1BEVVNaKTsKKworfQorCit2b2lkCitiZmFfZmNzX2ZkbWlfZ2V0X3BvcnRhdHRyKHN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pLAorCQkJICBzdHJ1Y3QgYmZhX2Zjc19mZG1pX3BvcnRfYXR0cl9zICpwb3J0X2F0dHIpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gZmRtaS0+bXMtPnBvcnQ7CisJc3RydWN0IGJmYV9mY3NfZHJpdmVyX2luZm9fcyAqZHJpdmVyX2luZm8gPSAmcG9ydC0+ZmNzLT5kcml2ZXJfaW5mbzsKKwlzdHJ1Y3QgYmZhX3Bwb3J0X2F0dHJfcyBwcG9ydF9hdHRyOworCisJYmZhX29zX21lbXNldChwb3J0X2F0dHIsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX2Zjc19mZG1pX3BvcnRfYXR0cl9zKSk7CisKKwkvKgorCSAqIGdldCBwcG9ydCBhdHRyaWJ1dGVzIGZyb20gaGFsCisJICovCisJYmZhX3Bwb3J0X2dldF9hdHRyKHBvcnQtPmZjcy0+YmZhLCAmcHBvcnRfYXR0cik7CisKKwkvKgorCSAqIGdldCBGQzQgdHlwZSBCaXRtYXNrCisJICovCisJZmNfZ2V0X2ZjNHR5cGVfYml0bWFzayhGQ19UWVBFX0ZDUCwgcG9ydF9hdHRyLT5zdXBwX2ZjNF90eXBlcyk7CisKKwkvKgorCSAqIFN1cHBvcnRlZCBTcGVlZHMKKwkgKi8KKwlwb3J0X2F0dHItPnN1cHBfc3BlZWQgPSBiZmFfb3NfaHRvbmwoQkZBX0ZDU19GRE1JX1NVUE9SVEVEX1NQRUVEUyk7CisKKwkvKgorCSAqIEN1cnJlbnQgU3BlZWQKKwkgKi8KKwlwb3J0X2F0dHItPmN1cnJfc3BlZWQgPSBiZmFfb3NfaHRvbmwocHBvcnRfYXR0ci5zcGVlZCk7CisKKwkvKgorCSAqIE1heCBQRFUgU2l6ZS4KKwkgKi8KKwlwb3J0X2F0dHItPm1heF9mcm1fc2l6ZSA9IGJmYV9vc19odG9ubChGQ19NQVhfUERVU1opOworCisJLyoKKwkgKiBPUyBkZXZpY2UgTmFtZQorCSAqLworCXN0cm5jcHkocG9ydF9hdHRyLT5vc19kZXZpY2VfbmFtZSwgKGNoYXIgKilkcml2ZXJfaW5mby0+b3NfZGV2aWNlX25hbWUsCisJCXNpemVvZihwb3J0X2F0dHItPm9zX2RldmljZV9uYW1lKSk7CisKKwkvKgorCSAqIEhvc3QgbmFtZQorCSAqLworCXN0cm5jcHkocG9ydF9hdHRyLT5ob3N0X25hbWUsIChjaGFyICopZHJpdmVyX2luZm8tPmhvc3RfbWFjaGluZV9uYW1lLAorCQlzaXplb2YocG9ydF9hdHRyLT5ob3N0X25hbWUpKTsKKworfQorCisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9mZG1pX2luaXQoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyAqZmRtaSA9ICZtcy0+ZmRtaTsKKworCWZkbWktPm1zID0gbXM7CisJYmZhX3NtX3NldF9zdGF0ZShmZG1pLCBiZmFfZmNzX3BvcnRfZmRtaV9zbV9vZmZsaW5lKTsKK30KKwordm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfZmRtaV9zICpmZG1pID0gJm1zLT5mZG1pOworCisJZmRtaS0+bXMgPSBtczsKKwliZmFfc21fc2VuZF9ldmVudChmZG1pLCBGRE1JU01fRVZFTlRfUE9SVF9PRkZMSU5FKTsKK30KKwordm9pZAorYmZhX2Zjc19wb3J0X2ZkbWlfb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgKmZkbWkgPSAmbXMtPmZkbWk7CisKKwlmZG1pLT5tcyA9IG1zOworCWJmYV9zbV9zZW5kX2V2ZW50KGZkbWksIEZETUlTTV9FVkVOVF9QT1JUX09OTElORSk7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW4uaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9hZW4vYmZhX2Flbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRhOGNhYzAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW4uaApAQCAtMCwwICsxLDkyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0FFTl9IX18KKyNkZWZpbmUgX19CRkFfQUVOX0hfXworCisjaW5jbHVkZSAiZGVmcy9iZmFfZGVmc19hZW4uaCIKKworI2RlZmluZSBCRkFfQUVOX01BWF9FTlRSWSAgIDUxMgorCitleHRlcm4gczMyIGJmYV9hZW5fbWF4X2NmZ19lbnRyeTsKK3N0cnVjdCBiZmFfYWVuX3MgeworCXZvaWQJCSpiZmFkOworCXMzMgkJbWF4X2VudHJ5OworCXMzMgkJd3JpdGVfaW5kZXg7CisJczMyCQlyZWFkX2luZGV4OworCXUzMgliZmFkX251bTsKKwl1MzIJc2VxX251bTsKKwl2b2lkCQkoKmFlbl9jYl9ub3RpZnkpKHZvaWQgKmJmYWQpOworCXZvaWQJCSgqZ2V0dGltZW9mZGF5KShzdHJ1Y3QgYmZhX3RpbWV2YWxfcyAqdHYpOworCXN0cnVjdCBiZmFfdHJjX21vZF9zIAkqdHJjbW9kOworCXN0cnVjdCBiZmFfYWVuX2VudHJ5X3MJbGlzdFtCRkFfQUVOX01BWF9FTlRSWV07IC8qIE11c3QgYmUgdGhlIGxhc3QgKi8KK307CisKKworLyoqCisgKiBQdWJsaWMgQVBJcworICovCitzdGF0aWMgaW5saW5lIHZvaWQKK2JmYV9hZW5fc2V0X21heF9jZmdfZW50cnkoaW50IG1heF9lbnRyeSkKK3sKKwliZmFfYWVuX21heF9jZmdfZW50cnkgPSBtYXhfZW50cnk7Cit9CisKK3N0YXRpYyBpbmxpbmUgczMyCitiZmFfYWVuX2dldF9tYXhfY2ZnX2VudHJ5KHZvaWQpCit7CisJcmV0dXJuIGJmYV9hZW5fbWF4X2NmZ19lbnRyeTsKK30KKworc3RhdGljIGlubGluZSBzMzIKK2JmYV9hZW5fZ2V0X21lbWluZm8odm9pZCkKK3sKKwlyZXR1cm4gKHNpemVvZihzdHJ1Y3QgYmZhX2Flbl9lbnRyeV9zKSAqIGJmYV9hZW5fZ2V0X21heF9jZmdfZW50cnkoKSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgczMyCitiZmFfYWVuX2dldF93aShzdHJ1Y3QgYmZhX2Flbl9zICphZW4pCit7CisJcmV0dXJuIGFlbi0+d3JpdGVfaW5kZXg7Cit9CisKK3N0YXRpYyBpbmxpbmUgczMyCitiZmFfYWVuX2dldF9yaShzdHJ1Y3QgYmZhX2Flbl9zICphZW4pCit7CisJcmV0dXJuIGFlbi0+cmVhZF9pbmRleDsKK30KKworc3RhdGljIGlubGluZSBzMzIKK2JmYV9hZW5fZmV0Y2hfY291bnQoc3RydWN0IGJmYV9hZW5fcyAqYWVuLCBzMzIgcmVhZF9pbmRleCkKK3sKKwlyZXR1cm4gKChhZW4tPndyaXRlX2luZGV4ICsgYWVuLT5tYXhfZW50cnkpIC0gcmVhZF9pbmRleCkKKwkJJSBhZW4tPm1heF9lbnRyeTsKK30KKworczMyIGJmYV9hZW5faW5pdChzdHJ1Y3QgYmZhX2Flbl9zICphZW4sIHN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QsCisJCXZvaWQgKmJmYWQsIHUzMiBpbnN0X2lkLCB2b2lkICgqYWVuX2NiX25vdGlmeSkodm9pZCAqKSwKKwkJdm9pZCAoKmdldHRpbWVvZmRheSkoc3RydWN0IGJmYV90aW1ldmFsX3MgKikpOworCitzMzIgYmZhX2Flbl9wb3N0KHN0cnVjdCBiZmFfYWVuX3MgKmFlbiwgZW51bSBiZmFfYWVuX2NhdGVnb3J5IGFlbl9jYXRlZ29yeSwKKwkJICAgICBpbnQgYWVuX3R5cGUsIHVuaW9uIGJmYV9hZW5fZGF0YV91ICphZW5fZGF0YSk7CisKK3MzMiBiZmFfYWVuX2ZldGNoKHN0cnVjdCBiZmFfYWVuX3MgKmFlbiwgc3RydWN0IGJmYV9hZW5fZW50cnlfcyAqYWVuX2VudHJ5LAorCQkgICAgICBzMzIgZW50cnlfc3BhY2UsIHMzMiByaWksIHMzMiAqcmlfYXJyLAorCQkgICAgICBzMzIgcmlfYXJyX2NudCk7CisKK3MzMiBiZmFfYWVuX2dldF9pbnN0KHN0cnVjdCBiZmFfYWVuX3MgKmFlbik7CisKKyNlbmRpZiAvKiBfX0JGQV9BRU5fSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5fYWRhcHRlci5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2FkYXB0ZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yNjBkM2VhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2FkYXB0ZXIuaApAQCAtMCwwICsxLDMxIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgQkZBX0FFTl9DQVRfQURBUFRFUiBNb2R1bGUgKi8KKyNpZm5kZWYJX19iZmFfYWVuX2FkYXB0ZXJfaF9fCisjZGVmaW5lCV9fYmZhX2Flbl9hZGFwdGVyX2hfXworCisjaW5jbHVkZSAgPGNzL2JmYV9sb2cuaD4KKyNpbmNsdWRlICA8ZGVmcy9iZmFfZGVmc19hZW4uaD4KKworI2RlZmluZSBCRkFfQUVOX0FEQVBURVJfQUREIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9BREFQVEVSLCBCRkFfQURBUFRFUl9BRU5fQUREKQorI2RlZmluZSBCRkFfQUVOX0FEQVBURVJfUkVNT1ZFIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9BREFQVEVSLCBCRkFfQURBUFRFUl9BRU5fUkVNT1ZFKQorCisjZW5kaWYKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2F1ZGl0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5fYXVkaXQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMmNkN2FhCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2F1ZGl0LmgKQEAgLTAsMCArMSwzMSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEJGQV9BRU5fQ0FUX0FVRElUIE1vZHVsZSAqLworI2lmbmRlZglfX2JmYV9hZW5fYXVkaXRfaF9fCisjZGVmaW5lCV9fYmZhX2Flbl9hdWRpdF9oX18KKworI2luY2x1ZGUgIDxjcy9iZmFfbG9nLmg+CisjaW5jbHVkZSAgPGRlZnMvYmZhX2RlZnNfYWVuLmg+CisKKyNkZWZpbmUgQkZBX0FFTl9BVURJVF9BVVRIX0VOQUJMRSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfQVVESVQsIEJGQV9BVURJVF9BRU5fQVVUSF9FTkFCTEUpCisjZGVmaW5lIEJGQV9BRU5fQVVESVRfQVVUSF9ESVNBQkxFIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9BVURJVCwgQkZBX0FVRElUX0FFTl9BVVRIX0RJU0FCTEUpCisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5fZXRocG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2V0aHBvcnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MDdkMGI1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2V0aHBvcnQuaApAQCAtMCwwICsxLDM1IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgQkZBX0FFTl9DQVRfRVRIUE9SVCBNb2R1bGUgKi8KKyNpZm5kZWYJX19iZmFfYWVuX2V0aHBvcnRfaF9fCisjZGVmaW5lCV9fYmZhX2Flbl9ldGhwb3J0X2hfXworCisjaW5jbHVkZSAgPGNzL2JmYV9sb2cuaD4KKyNpbmNsdWRlICA8ZGVmcy9iZmFfZGVmc19hZW4uaD4KKworI2RlZmluZSBCRkFfQUVOX0VUSFBPUlRfTElOS1VQIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9FVEhQT1JULCBCRkFfRVRIUE9SVF9BRU5fTElOS1VQKQorI2RlZmluZSBCRkFfQUVOX0VUSFBPUlRfTElOS0RPV04gXAorCUJGQV9MT0dfQ1JFQVRFX0lEKEJGQV9BRU5fQ0FUX0VUSFBPUlQsIEJGQV9FVEhQT1JUX0FFTl9MSU5LRE9XTikKKyNkZWZpbmUgQkZBX0FFTl9FVEhQT1JUX0VOQUJMRSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfRVRIUE9SVCwgQkZBX0VUSFBPUlRfQUVOX0VOQUJMRSkKKyNkZWZpbmUgQkZBX0FFTl9FVEhQT1JUX0RJU0FCTEUgXAorCUJGQV9MT0dfQ1JFQVRFX0lEKEJGQV9BRU5fQ0FUX0VUSFBPUlQsIEJGQV9FVEhQT1JUX0FFTl9ESVNBQkxFKQorCisjZW5kaWYKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2lvYy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2lvYy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjcxMzc4YjQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5faW9jLmgKQEAgLTAsMCArMSwzNyBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEJGQV9BRU5fQ0FUX0lPQyBNb2R1bGUgKi8KKyNpZm5kZWYJX19iZmFfYWVuX2lvY19oX18KKyNkZWZpbmUJX19iZmFfYWVuX2lvY19oX18KKworI2luY2x1ZGUgIDxjcy9iZmFfbG9nLmg+CisjaW5jbHVkZSAgPGRlZnMvYmZhX2RlZnNfYWVuLmg+CisKKyNkZWZpbmUgQkZBX0FFTl9JT0NfSEJHT09EIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9JT0MsIEJGQV9JT0NfQUVOX0hCR09PRCkKKyNkZWZpbmUgQkZBX0FFTl9JT0NfSEJGQUlMIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9JT0MsIEJGQV9JT0NfQUVOX0hCRkFJTCkKKyNkZWZpbmUgQkZBX0FFTl9JT0NfRU5BQkxFIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9JT0MsIEJGQV9JT0NfQUVOX0VOQUJMRSkKKyNkZWZpbmUgQkZBX0FFTl9JT0NfRElTQUJMRSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfSU9DLCBCRkFfSU9DX0FFTl9ESVNBQkxFKQorI2RlZmluZSBCRkFfQUVOX0lPQ19GV01JU01BVENIIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9JT0MsIEJGQV9JT0NfQUVOX0ZXTUlTTUFUQ0gpCisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5faXRuaW0uaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9hZW4vYmZhX2Flbl9pdG5pbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE3ZDhkZGMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5faXRuaW0uaApAQCAtMCwwICsxLDMzIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgQkZBX0FFTl9DQVRfSVROSU0gTW9kdWxlICovCisjaWZuZGVmCV9fYmZhX2Flbl9pdG5pbV9oX18KKyNkZWZpbmUJX19iZmFfYWVuX2l0bmltX2hfXworCisjaW5jbHVkZSAgPGNzL2JmYV9sb2cuaD4KKyNpbmNsdWRlICA8ZGVmcy9iZmFfZGVmc19hZW4uaD4KKworI2RlZmluZSBCRkFfQUVOX0lUTklNX09OTElORSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfSVROSU0sIEJGQV9JVE5JTV9BRU5fT05MSU5FKQorI2RlZmluZSBCRkFfQUVOX0lUTklNX09GRkxJTkUgXAorCUJGQV9MT0dfQ1JFQVRFX0lEKEJGQV9BRU5fQ0FUX0lUTklNLCBCRkFfSVROSU1fQUVOX09GRkxJTkUpCisjZGVmaW5lIEJGQV9BRU5fSVROSU1fRElTQ09OTkVDVCBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfSVROSU0sIEJGQV9JVE5JTV9BRU5fRElTQ09OTkVDVCkKKworI2VuZGlmCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9hZW4vYmZhX2Flbl9scG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX2xwb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNWE4ZWJiNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9hZW4vYmZhX2Flbl9scG9ydC5oCkBAIC0wLDAgKzEsNTEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyogbWVzc2FnZXMgZGVmaW5lIGZvciBCRkFfQUVOX0NBVF9MUE9SVCBNb2R1bGUgKi8KKyNpZm5kZWYJX19iZmFfYWVuX2xwb3J0X2hfXworI2RlZmluZQlfX2JmYV9hZW5fbHBvcnRfaF9fCisKKyNpbmNsdWRlICA8Y3MvYmZhX2xvZy5oPgorI2luY2x1ZGUgIDxkZWZzL2JmYV9kZWZzX2Flbi5oPgorCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfTkVXIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9ORVcpCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfREVMRVRFIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9ERUxFVEUpCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfT05MSU5FIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9PTkxJTkUpCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfT0ZGTElORSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfTFBPUlQsIEJGQV9MUE9SVF9BRU5fT0ZGTElORSkKKyNkZWZpbmUgQkZBX0FFTl9MUE9SVF9ESVNDT05ORUNUIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9ESVNDT05ORUNUKQorI2RlZmluZSBCRkFfQUVOX0xQT1JUX05FV19QUk9QIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9ORVdfUFJPUCkKKyNkZWZpbmUgQkZBX0FFTl9MUE9SVF9ERUxFVEVfUFJPUCBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfTFBPUlQsIEJGQV9MUE9SVF9BRU5fREVMRVRFX1BST1ApCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfTkVXX1NUQU5EQVJEIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9ORVdfU1RBTkRBUkQpCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfREVMRVRFX1NUQU5EQVJEIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9ERUxFVEVfU1RBTkRBUkQpCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfTlBJVl9EVVBfV1dOIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9OUElWX0RVUF9XV04pCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfTlBJVl9GQUJSSUNfTUFYIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9OUElWX0ZBQlJJQ19NQVgpCisjZGVmaW5lIEJGQV9BRU5fTFBPUlRfTlBJVl9VTktOT1dOIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9MUE9SVCwgQkZBX0xQT1JUX0FFTl9OUElWX1VOS05PV04pCisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5fcG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX3BvcnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45YWRkOTA1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Flbi9iZmFfYWVuX3BvcnQuaApAQCAtMCwwICsxLDU3IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgQkZBX0FFTl9DQVRfUE9SVCBNb2R1bGUgKi8KKyNpZm5kZWYJX19iZmFfYWVuX3BvcnRfaF9fCisjZGVmaW5lCV9fYmZhX2Flbl9wb3J0X2hfXworCisjaW5jbHVkZSAgPGNzL2JmYV9sb2cuaD4KKyNpbmNsdWRlICA8ZGVmcy9iZmFfZGVmc19hZW4uaD4KKworI2RlZmluZSBCRkFfQUVOX1BPUlRfT05MSU5FIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9QT1JULCBCRkFfUE9SVF9BRU5fT05MSU5FKQorI2RlZmluZSBCRkFfQUVOX1BPUlRfT0ZGTElORSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX09GRkxJTkUpCisjZGVmaW5lIEJGQV9BRU5fUE9SVF9STElSIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9QT1JULCBCRkFfUE9SVF9BRU5fUkxJUikKKyNkZWZpbmUgQkZBX0FFTl9QT1JUX1NGUF9JTlNFUlQgXAorCUJGQV9MT0dfQ1JFQVRFX0lEKEJGQV9BRU5fQ0FUX1BPUlQsIEJGQV9QT1JUX0FFTl9TRlBfSU5TRVJUKQorI2RlZmluZSBCRkFfQUVOX1BPUlRfU0ZQX1JFTU9WRSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX1NGUF9SRU1PVkUpCisjZGVmaW5lIEJGQV9BRU5fUE9SVF9TRlBfUE9NIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9QT1JULCBCRkFfUE9SVF9BRU5fU0ZQX1BPTSkKKyNkZWZpbmUgQkZBX0FFTl9QT1JUX0VOQUJMRSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX0VOQUJMRSkKKyNkZWZpbmUgQkZBX0FFTl9QT1JUX0RJU0FCTEUgXAorCUJGQV9MT0dfQ1JFQVRFX0lEKEJGQV9BRU5fQ0FUX1BPUlQsIEJGQV9QT1JUX0FFTl9ESVNBQkxFKQorI2RlZmluZSBCRkFfQUVOX1BPUlRfQVVUSF9PTiBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX0FVVEhfT04pCisjZGVmaW5lIEJGQV9BRU5fUE9SVF9BVVRIX09GRiBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX0FVVEhfT0ZGKQorI2RlZmluZSBCRkFfQUVOX1BPUlRfRElTQ09OTkVDVCBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX0RJU0NPTk5FQ1QpCisjZGVmaW5lIEJGQV9BRU5fUE9SVF9RT1NfTkVHIFwKKwlCRkFfTE9HX0NSRUFURV9JRChCRkFfQUVOX0NBVF9QT1JULCBCRkFfUE9SVF9BRU5fUU9TX05FRykKKyNkZWZpbmUgQkZBX0FFTl9QT1JUX0ZBQlJJQ19OQU1FX0NIQU5HRSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX0ZBQlJJQ19OQU1FX0NIQU5HRSkKKyNkZWZpbmUgQkZBX0FFTl9QT1JUX1NGUF9BQ0NFU1NfRVJST1IgXAorCUJGQV9MT0dfQ1JFQVRFX0lEKEJGQV9BRU5fQ0FUX1BPUlQsIEJGQV9QT1JUX0FFTl9TRlBfQUNDRVNTX0VSUk9SKQorI2RlZmluZSBCRkFfQUVOX1BPUlRfU0ZQX1VOU1VQUE9SVCBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUE9SVCwgQkZBX1BPUlRfQUVOX1NGUF9VTlNVUFBPUlQpCisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5fcnBvcnQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9hZW4vYmZhX2Flbl9ycG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdlNGJlMWYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYWVuL2JmYV9hZW5fcnBvcnQuaApAQCAtMCwwICsxLDM3IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgQkZBX0FFTl9DQVRfUlBPUlQgTW9kdWxlICovCisjaWZuZGVmCV9fYmZhX2Flbl9ycG9ydF9oX18KKyNkZWZpbmUJX19iZmFfYWVuX3Jwb3J0X2hfXworCisjaW5jbHVkZSAgPGNzL2JmYV9sb2cuaD4KKyNpbmNsdWRlICA8ZGVmcy9iZmFfZGVmc19hZW4uaD4KKworI2RlZmluZSBCRkFfQUVOX1JQT1JUX09OTElORSBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUlBPUlQsIEJGQV9SUE9SVF9BRU5fT05MSU5FKQorI2RlZmluZSBCRkFfQUVOX1JQT1JUX09GRkxJTkUgXAorCUJGQV9MT0dfQ1JFQVRFX0lEKEJGQV9BRU5fQ0FUX1JQT1JULCBCRkFfUlBPUlRfQUVOX09GRkxJTkUpCisjZGVmaW5lIEJGQV9BRU5fUlBPUlRfRElTQ09OTkVDVCBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUlBPUlQsIEJGQV9SUE9SVF9BRU5fRElTQ09OTkVDVCkKKyNkZWZpbmUgQkZBX0FFTl9SUE9SVF9RT1NfUFJJTyBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUlBPUlQsIEJGQV9SUE9SVF9BRU5fUU9TX1BSSU8pCisjZGVmaW5lIEJGQV9BRU5fUlBPUlRfUU9TX0ZMT1dJRCBcCisJQkZBX0xPR19DUkVBVEVfSUQoQkZBX0FFTl9DQVRfUlBPUlQsIEJGQV9SUE9SVF9BRU5fUU9TX0ZMT1dJRCkKKworI2VuZGlmCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmEuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmEuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGMxNDEyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmYS5oCkBAIC0wLDAgKzEsMTc3IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0hfXworI2RlZmluZSBfX0JGQV9IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfZGVidWcuaD4KKyNpbmNsdWRlIDxjcy9iZmFfcS5oPgorI2luY2x1ZGUgPGNzL2JmYV90cmMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfbG9nLmg+CisjaW5jbHVkZSA8Y3MvYmZhX3Bsb2cuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3N0YXR1cy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfaW9jLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19pb2NmYy5oPgorI2luY2x1ZGUgPGFlbi9iZmFfYWVuLmg+CisjaW5jbHVkZSA8YmZpL2JmaS5oPgorCitzdHJ1Y3QgYmZhX3M7CisjaW5jbHVkZSA8YmZhX2ludHJfcHJpdi5oPgorCitzdHJ1Y3QgYmZhX3BjaWRldl9zOworCisvKioKKyAqIFBDSSBkZXZpY2VzIHN1cHBvcnRlZCBieSB0aGUgY3VycmVudCBCRkEKKyAqLworc3RydWN0IGJmYV9wY2lpZF9zIHsKKwl1MTYgICAgICAgIGRldmljZV9pZDsKKwl1MTYgICAgICAgIHZlbmRvcl9pZDsKK307CisKK2V4dGVybiBjaGFyICAgICBiZmFfdmVyc2lvbltdOworCisvKioKKyAqIEJGQSBQb3dlciBNZ210IENvbW1hbmRzCisgKi8KK2VudW0gYmZhX3BtX2NtZCB7CisJQkZBX1BNX0NUTF9EMCA9IDAsCisJQkZBX1BNX0NUTF9EMSA9IDEsCisJQkZBX1BNX0NUTF9EMiA9IDIsCisJQkZBX1BNX0NUTF9EMyA9IDMsCit9OworCisvKioKKyAqIEJGQSBtZW1vcnkgcmVzb3VyY2VzCisgKi8KK2VudW0gYmZhX21lbV90eXBlIHsKKwlCRkFfTUVNX1RZUEVfS1ZBID0gMSwJLyohIEtlcm5lbCBWaXJ0dWFsIE1lbW9yeSAqKG5vbi1kbWEtYWJsZSkgKi8KKwlCRkFfTUVNX1RZUEVfRE1BID0gMiwJLyohIERNQS1hYmxlIG1lbW9yeSAqLworCUJGQV9NRU1fVFlQRV9NQVggPSBCRkFfTUVNX1RZUEVfRE1BLAorfTsKKworc3RydWN0IGJmYV9tZW1fZWxlbV9zIHsKKwllbnVtIGJmYV9tZW1fdHlwZSBtZW1fdHlwZTsJLyogIHNlZSBlbnVtIGJmYV9tZW1fdHlwZSAJKi8KKwl1MzIgICAgICAgIG1lbV9sZW47CS8qICBUb3RhbCBMZW5ndGggaW4gQnl0ZXMJKi8KKwl1OCAgICAgICAJKmt2YTsJCS8qICBrZXJuZWwgdmlydHVhbCBhZGRyZXNzCSovCisJdTY0ICAgICAgICBkbWE7CQkvKiAgZG1hIGFkZHJlc3MgaWYgRE1BIG1lbW9yeQkqLworCXU4ICAgICAgIAkqa3ZhX2N1cnA7CS8qICBrdmEgYWxsb2NhdGlvbiBjdXJzb3IJKi8KKwl1NjQgICAgICAgIGRtYV9jdXJwOwkvKiAgZG1hIGFsbG9jYXRpb24gY3Vyc29yCSovCit9OworCitzdHJ1Y3QgYmZhX21lbWluZm9fcyB7CisJc3RydWN0IGJmYV9tZW1fZWxlbV9zIG1lbWluZm9bQkZBX01FTV9UWVBFX01BWF07Cit9OworI2RlZmluZSBiZmFfbWVtaW5mb19rdmEoX20pCVwKKwkoX20pLT5tZW1pbmZvW0JGQV9NRU1fVFlQRV9LVkEgLSAxXS5rdmFfY3VycAorI2RlZmluZSBiZmFfbWVtaW5mb19kbWFfdmlydChfbSkJXAorCShfbSktPm1lbWluZm9bQkZBX01FTV9UWVBFX0RNQSAtIDFdLmt2YV9jdXJwCisjZGVmaW5lIGJmYV9tZW1pbmZvX2RtYV9waHlzKF9tKQlcCisJKF9tKS0+bWVtaW5mb1tCRkFfTUVNX1RZUEVfRE1BIC0gMV0uZG1hX2N1cnAKKworLyoqCisgKiBHZW5lcmljIFNjYXR0ZXIgR2F0aGVyIEVsZW1lbnQgdXNlZCBieSBkcml2ZXIKKyAqLworc3RydWN0IGJmYV9zZ2VfcyB7CisJdTMyICAgICAgICBzZ19sZW47CisJdm9pZCAgICAgICAgICAgKnNnX2FkZHI7Cit9OworCisjZGVmaW5lIGJmYV9zZ2VfdG9fYmUoX19zZ2UpIGRvIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisJKCh1MzIgKikoX19zZ2UpKVswXSA9IGJmYV9vc19odG9ubCgoKHUzMiAqKShfX3NnZSkpWzBdKTsgICAgICBcCisJKCh1MzIgKikoX19zZ2UpKVsxXSA9IGJmYV9vc19odG9ubCgoKHUzMiAqKShfX3NnZSkpWzFdKTsgICAgICBcCisJKCh1MzIgKikoX19zZ2UpKVsyXSA9IGJmYV9vc19odG9ubCgoKHUzMiAqKShfX3NnZSkpWzJdKTsgICAgICBcCit9IHdoaWxlICgwKQorCisKKy8qCisgKiBiZmEgc3RhdHMgaW50ZXJmYWNlcworICovCisjZGVmaW5lIGJmYV9zdGF0cyhfbW9kLCBfc3RhdHMpCShfbW9kKS0+c3RhdHMuX3N0YXRzICsrCisKKyNkZWZpbmUgYmZhX2lvY19nZXRfc3RhdHMoX19iZmEsIF9faW9jX3N0YXRzKQlcCisJYmZhX2lvY19mZXRjaF9zdGF0cygmKF9fYmZhKS0+aW9jLCBfX2lvY19zdGF0cykKKyNkZWZpbmUgYmZhX2lvY19jbGVhcl9zdGF0cyhfX2JmYSkJXAorCWJmYV9pb2NfY2xyX3N0YXRzKCYoX19iZmEpLT5pb2MpCisKKy8qCisgKiBiZmEgQVBJIGZ1bmN0aW9ucworICovCit2b2lkIGJmYV9nZXRfcGNpaWRzKHN0cnVjdCBiZmFfcGNpaWRfcyAqKnBjaWlkcywgaW50ICpucGNpaWRzKTsKK3ZvaWQgYmZhX2NmZ19nZXRfZGVmYXVsdChzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcpOwordm9pZCBiZmFfY2ZnX2dldF9taW4oc3RydWN0IGJmYV9pb2NmY19jZmdfcyAqY2ZnKTsKK3ZvaWQgYmZhX2NmZ19nZXRfbWVtaW5mbyhzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zICpjZmcsCisJCQlzdHJ1Y3QgYmZhX21lbWluZm9fcyAqbWVtaW5mbyk7Cit2b2lkIGJmYV9hdHRhY2goc3RydWN0IGJmYV9zICpiZmEsIHZvaWQgKmJmYWQsIHN0cnVjdCBiZmFfaW9jZmNfY2ZnX3MgKmNmZywKKwkJCXN0cnVjdCBiZmFfbWVtaW5mb19zICptZW1pbmZvLAorCQkJc3RydWN0IGJmYV9wY2lkZXZfcyAqcGNpZGV2KTsKK3ZvaWQgYmZhX2luaXRfdHJjKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbW9kKTsKK3ZvaWQgYmZhX2luaXRfbG9nKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbW9kKTsKK3ZvaWQgYmZhX2luaXRfYWVuKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2Flbl9zICphZW4pOwordm9pZCBiZmFfaW5pdF9wbG9nKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX3Bsb2dfcyAqcGxvZyk7Cit2b2lkIGJmYV9kZXRhY2goc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfaW5pdChzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9zdGFydChzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9zdG9wKHN0cnVjdCBiZmFfcyAqYmZhKTsKK3ZvaWQgYmZhX2F0dGFjaF9mY3Moc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfY2JfaW5pdCh2b2lkICpiZmFkLCBiZmFfc3RhdHVzX3Qgc3RhdHVzKTsKK3ZvaWQgYmZhX2NiX3N0b3Aodm9pZCAqYmZhZCwgYmZhX3N0YXR1c190IHN0YXR1cyk7Cit2b2lkIGJmYV9jYl91cGRhdGVxKHZvaWQgKmJmYWQsIGJmYV9zdGF0dXNfdCBzdGF0dXMpOworCitiZmFfYm9vbGVhbl90IGJmYV9pbnR4KHN0cnVjdCBiZmFfcyAqYmZhKTsKK3ZvaWQgYmZhX2lzcl9lbmFibGUoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfaXNyX2Rpc2FibGUoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfbXNpeF9nZXR2ZWNzKHN0cnVjdCBiZmFfcyAqYmZhLCB1MzIgKm1zaXhfdmVjc19ibWFwLAorCQkJdTMyICpudW1fdmVjcywgdTMyICptYXhfdmVjX2JpdCk7CisjZGVmaW5lIGJmYV9tc2l4KF9fYmZhLCBfX3ZlYykgKF9fYmZhKS0+bXNpeC5oYW5kbGVyW19fdmVjXShfX2JmYSwgX192ZWMpCisKK3ZvaWQgYmZhX2NvbXBfZGVxKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgbGlzdF9oZWFkICpjb21wX3EpOwordm9pZCBiZmFfY29tcF9wcm9jZXNzKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgbGlzdF9oZWFkICpjb21wX3EpOwordm9pZCBiZmFfY29tcF9mcmVlKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgbGlzdF9oZWFkICpjb21wX3EpOworCit0eXBlZGVmIHZvaWQgKCpiZmFfY2JfaW9jX3QpICh2b2lkICpjYmFyZywgZW51bSBiZmFfc3RhdHVzIHN0YXR1cyk7Cit2b2lkIGJmYV9pb2NmY19nZXRfYXR0cihzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9pb2NmY19hdHRyX3MgKmF0dHIpOworYmZhX3N0YXR1c190IGJmYV9pb2NmY19nZXRfc3RhdHMoc3RydWN0IGJmYV9zICpiZmEsCisJCQlzdHJ1Y3QgYmZhX2lvY2ZjX3N0YXRzX3MgKnN0YXRzLAorCQkJYmZhX2NiX2lvY190IGNiZm4sIHZvaWQgKmNiYXJnKTsKK2JmYV9zdGF0dXNfdCBiZmFfaW9jZmNfY2xlYXJfc3RhdHMoc3RydWN0IGJmYV9zICpiZmEsCisJCQliZmFfY2JfaW9jX3QgY2Jmbiwgdm9pZCAqY2JhcmcpOwordm9pZCBiZmFfZ2V0X2F0dHIoc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFfaW9jX2F0dHJfcyAqaW9jX2F0dHIpOworCit2b2lkIGJmYV9hZGFwdGVyX2dldF9hdHRyKHN0cnVjdCBiZmFfcyAqYmZhLAorCQkJc3RydWN0IGJmYV9hZGFwdGVyX2F0dHJfcyAqYWRfYXR0cik7Cit1NjQgYmZhX2FkYXB0ZXJfZ2V0X2lkKHN0cnVjdCBiZmFfcyAqYmZhKTsKKworYmZhX3N0YXR1c190IGJmYV9pb2NmY19pc3JhdHRyX3NldChzdHJ1Y3QgYmZhX3MgKmJmYSwKKwkJCXN0cnVjdCBiZmFfaW9jZmNfaW50cl9hdHRyX3MgKmF0dHIpOworCit2b2lkIGJmYV9pb2NmY19lbmFibGUoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfaW9jZmNfZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9pb2NfYXV0b19yZWNvdmVyKGJmYV9ib29sZWFuX3QgYXV0b19yZWNvdmVyKTsKK3ZvaWQgYmZhX2NiX2lvY19kaXNhYmxlKHZvaWQgKmJmYWQpOwordm9pZCBiZmFfdGltZXJfdGljayhzdHJ1Y3QgYmZhX3MgKmJmYSk7CisjZGVmaW5lIGJmYV90aW1lcl9zdGFydChfYmZhLCBfdGltZXIsIF90aW1lcmNiLCBfYXJnLCBfdGltZW91dCkJXAorCWJmYV90aW1lcl9iZWdpbigmKF9iZmEpLT50aW1lcl9tb2QsIF90aW1lciwgX3RpbWVyY2IsIF9hcmcsIF90aW1lb3V0KQorCisvKgorICogQkZBIGRlYnVnIEFQSSBmdW5jdGlvbnMKKyAqLworYmZhX3N0YXR1c190IGJmYV9kZWJ1Z19md3RyYyhzdHJ1Y3QgYmZhX3MgKmJmYSwgdm9pZCAqdHJjZGF0YSwgaW50ICp0cmNsZW4pOworYmZhX3N0YXR1c190IGJmYV9kZWJ1Z19md3NhdmUoc3RydWN0IGJmYV9zICpiZmEsIHZvaWQgKnRyY2RhdGEsIGludCAqdHJjbGVuKTsKKworI2luY2x1ZGUgImJmYV9wcml2LmgiCisKKyNlbmRpZiAvKiBfX0JGQV9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmFfZmNwaW0uaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmFfZmNwaW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wNDc4OTc5Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmYV9mY3BpbS5oCkBAIC0wLDAgKzEsMTU5IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfRkNQSU1fSF9fCisjZGVmaW5lIF9fQkZBX0ZDUElNX0hfXworCisjaW5jbHVkZSA8YmZhLmg+CisjaW5jbHVkZSA8YmZhX3N2Yy5oPgorI2luY2x1ZGUgPGJmaS9iZmlfZmNwaW0uaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX2ZjcGltLmg+CisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdHJ1Y3QgYmZhX2l0bmltX3M7CitzdHJ1Y3QgYmZhX2lvaW1fczsKK3N0cnVjdCBiZmFfdHNraW1fczsKK3N0cnVjdCBiZmFkX2lvaW1fczsKK3N0cnVjdCBiZmFkX3Rza2ltX3M7CisKKy8qCisgKiBiZmEgZmNwaW0gbW9kdWxlIEFQSSBmdW5jdGlvbnMKKyAqLwordm9pZAkJYmZhX2ZjcGltX3BhdGhfdG92X3NldChzdHJ1Y3QgYmZhX3MgKmJmYSwgdTE2IHBhdGhfdG92KTsKK3UxNgliZmFfZmNwaW1fcGF0aF90b3ZfZ2V0KHN0cnVjdCBiZmFfcyAqYmZhKTsKK3ZvaWQJCWJmYV9mY3BpbV9xZGVwdGhfc2V0KHN0cnVjdCBiZmFfcyAqYmZhLCB1MTYgcV9kZXB0aCk7Cit1MTYJYmZhX2ZjcGltX3FkZXB0aF9nZXQoc3RydWN0IGJmYV9zICpiZmEpOworYmZhX3N0YXR1c190IGJmYV9mY3BpbV9nZXRfbW9kc3RhdHMoc3RydWN0IGJmYV9zICpiZmEsCisJCQlzdHJ1Y3QgYmZhX2ZjcGltX3N0YXRzX3MgKm1vZHN0YXRzKTsKK2JmYV9zdGF0dXNfdCBiZmFfZmNwaW1fY2xyX21vZHN0YXRzKHN0cnVjdCBiZmFfcyAqYmZhKTsKKworLyoKKyAqIGJmYSBpdG5pbSBBUEkgZnVuY3Rpb25zCisgKi8KK3N0cnVjdCBiZmFfaXRuaW1fcyAqYmZhX2l0bmltX2NyZWF0ZShzdHJ1Y3QgYmZhX3MgKmJmYSwKKwkJCQkJc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydCwgdm9pZCAqaXRuaW0pOwordm9pZAkJYmZhX2l0bmltX2RlbGV0ZShzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltKTsKK3ZvaWQJCWJmYV9pdG5pbV9vbmxpbmUoc3RydWN0IGJmYV9pdG5pbV9zICppdG5pbSwKKwkJCQkgYmZhX2Jvb2xlYW5fdCBzZXFfcmVjKTsKK3ZvaWQJCWJmYV9pdG5pbV9vZmZsaW5lKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pOwordm9pZAkJYmZhX2l0bmltX2dldF9zdGF0cyhzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLAorCQkJc3RydWN0IGJmYV9pdG5pbV9oYWxfc3RhdHNfcyAqc3RhdHMpOwordm9pZAkJYmZhX2l0bmltX2NsZWFyX3N0YXRzKHN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0pOworCisKKy8qKgorICogCQlCRkEgY29tcGxldGlvbiBjYWxsYmFjayBmb3IgYmZhX2l0bmltX29ubGluZSgpLgorICoKKyAqIEBwYXJhbVtpbl0JCWl0bmltCQlGQ1Mgb3IgZHJpdmVyIGl0bmltIGluc3RhbmNlCisgKgorICogcmV0dXJuIE5vbmUKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9jYl9pdG5pbV9vbmxpbmUodm9pZCAqaXRuaW0pOworCisvKioKKyAqIAkJQkZBIGNvbXBsZXRpb24gY2FsbGJhY2sgZm9yIGJmYV9pdG5pbV9vZmZsaW5lKCkuCisgKgorICogQHBhcmFtW2luXQkJaXRuaW0JCUZDUyBvciBkcml2ZXIgaXRuaW0gaW5zdGFuY2UKKyAqCisgKiByZXR1cm4gTm9uZQorICovCit2b2lkICAgICAgICAgICAgYmZhX2NiX2l0bmltX29mZmxpbmUodm9pZCAqaXRuaW0pOwordm9pZCAgICAgICAgICAgIGJmYV9jYl9pdG5pbV90b3ZfYmVnaW4odm9pZCAqaXRuaW0pOwordm9pZCAgICAgICAgICAgIGJmYV9jYl9pdG5pbV90b3Yodm9pZCAqaXRuaW0pOworCisvKioKKyAqIAkJQkZBIG5vdGlmaWNhdGlvbiB0byBGQ1MvZHJpdmVyIGZvciBzZWNvbmQgbGV2ZWwgZXJyb3IgcmVjb3ZlcnkuCisgKgorICogQXRsZWFzdCBvbmUgSS9PIHJlcXVlc3QgaGFzIHRpbWVkb3V0IGFuZCB0YXJnZXQgaXMgdW5yZXNwb25zaXZlIHRvCisgKiByZXBlYXRlZCBhYm9ydCByZXF1ZXN0cy4gU2Vjb25kIGxldmVsIGVycm9yIHJlY292ZXJ5IHNob3VsZCBiZSBpbml0aWF0ZWQKKyAqIGJ5IHN0YXJ0aW5nIGltcGxpY2l0IGxvZ291dCBhbmQgcmVjb3ZlcnkgcHJvY2VkdXJlcy4KKyAqCisgKiBAcGFyYW1baW5dCQlpdG5pbQkJRkNTIG9yIGRyaXZlciBpdG5pbSBpbnN0YW5jZQorICoKKyAqIHJldHVybiBOb25lCisgKi8KK3ZvaWQgICAgICAgICAgICBiZmFfY2JfaXRuaW1fc2xlcih2b2lkICppdG5pbSk7CisKKy8qCisgKiBiZmEgaW9pbSBBUEkgZnVuY3Rpb25zCisgKi8KK3N0cnVjdCBiZmFfaW9pbV9zCSpiZmFfaW9pbV9hbGxvYyhzdHJ1Y3QgYmZhX3MgKmJmYSwKKwkJCQkJc3RydWN0IGJmYWRfaW9pbV9zICpkaW8sCisJCQkJCXN0cnVjdCBiZmFfaXRuaW1fcyAqaXRuaW0sCisJCQkJCXUxNiBuc2dsZXMpOworCit2b2lkCQliZmFfaW9pbV9mcmVlKHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKTsKK3ZvaWQJCWJmYV9pb2ltX3N0YXJ0KHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKTsKK3ZvaWQJCWJmYV9pb2ltX2Fib3J0KHN0cnVjdCBiZmFfaW9pbV9zICppb2ltKTsKK3ZvaWQgCQliZmFfaW9pbV9kZWxheWVkX2NvbXAoc3RydWN0IGJmYV9pb2ltX3MgKmlvaW0sCisJCQkJICAgICAgYmZhX2Jvb2xlYW5fdCBpb3Rvdik7CisKKworLyoqCisgKiAJCUkvTyBjb21wbGV0aW9uIG5vdGlmaWNhdGlvbi4KKyAqCisgKiBAcGFyYW1baW5dCQlkaW8JCQlkcml2ZXIgSU8gc3RydWN0dXJlCisgKiBAcGFyYW1baW5dCQlpb19zdGF0dXMJCUlPIGNvbXBsZXRpb24gc3RhdHVzCisgKiBAcGFyYW1baW5dCQlzY3NpX3N0YXR1cwkJU0NTSSBzdGF0dXMgcmV0dXJuZWQgYnkgdGFyZ2V0CisgKiBAcGFyYW1baW5dCQlzbnNfbGVuCQkJU0NTSSBzZW5zZSBsZW5ndGgsIDAgaWYgbm9uZQorICogQHBhcmFtW2luXQkJc25zX2luZm8JCVNDU0kgc2Vuc2UgZGF0YSwgaWYgYW55CisgKiBAcGFyYW1baW5dCQlyZXNpZHVlCQkJUmVzaWR1YWwgbGVuZ3RoCisgKgorICogQHJldHVybiBOb25lCisgKi8KK3ZvaWQgICAgICAgICAgICBiZmFfY2JfaW9pbV9kb25lKHZvaWQgKmJmYWQsIHN0cnVjdCBiZmFkX2lvaW1fcyAqZGlvLAorCQkJCSAgZW51bSBiZmlfaW9pbV9zdGF0dXMgaW9fc3RhdHVzLAorCQkJCSAgdTggc2NzaV9zdGF0dXMsIGludCBzbnNfbGVuLAorCQkJCSAgdTggKnNuc19pbmZvLCBzMzIgcmVzaWR1ZSk7CisKKy8qKgorICogCQlJL08gZ29vZCBjb21wbGV0aW9uIG5vdGlmaWNhdGlvbi4KKyAqCisgKiBAcGFyYW1baW5dCQlkaW8JCQlkcml2ZXIgSU8gc3RydWN0dXJlCisgKgorICogQHJldHVybiBOb25lCisgKi8KK3ZvaWQgICAgICAgICAgICBiZmFfY2JfaW9pbV9nb29kX2NvbXAodm9pZCAqYmZhZCwgc3RydWN0IGJmYWRfaW9pbV9zICpkaW8pOworCisvKioKKyAqIAkJSS9PIGFib3J0IGNvbXBsZXRpb24gbm90aWZpY2F0aW9uCisgKgorICogQHBhcmFtW2luXQkJZGlvCQkJZHJpdmVyIElPIHRoYXQgd2FzIGFib3J0ZWQKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9jYl9pb2ltX2Fib3J0KHZvaWQgKmJmYWQsIHN0cnVjdCBiZmFkX2lvaW1fcyAqZGlvKTsKK3ZvaWQJCWJmYV9jYl9pb2ltX3Jlc2ZyZWUodm9pZCAqaGNiX2JmYWQpOworCit2b2lkIAkJCWJmYV9jYl9pb2ltX3Jlc2ZyZWUodm9pZCAqaGNiX2JmYWQpOworCisvKgorICogYmZhIHRza2ltIEFQSSBmdW5jdGlvbnMKKyAqLworc3RydWN0IGJmYV90c2tpbV9zCSpiZmFfdHNraW1fYWxsb2Moc3RydWN0IGJmYV9zICpiZmEsCisJCQkJCXN0cnVjdCBiZmFkX3Rza2ltX3MgKmR0c2spOwordm9pZAkJYmZhX3Rza2ltX2ZyZWUoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSk7Cit2b2lkCQliZmFfdHNraW1fc3RhcnQoc3RydWN0IGJmYV90c2tpbV9zICp0c2tpbSwKKwkJCQlzdHJ1Y3QgYmZhX2l0bmltX3MgKml0bmltLCBsdW5fdCBsdW4sCisJCQkJZW51bSBmY3BfdG1fY21uZCB0bSwgdTggdF9zZWNzKTsKK3ZvaWQJCWJmYV9jYl90c2tpbV9kb25lKHZvaWQgKmJmYWQsIHN0cnVjdCBiZmFkX3Rza2ltX3MgKmR0c2ssCisJCQkJICBlbnVtIGJmaV90c2tpbV9zdGF0dXMgdHNrX3N0YXR1cyk7CisKKyNlbmRpZiAvKiBfX0JGQV9GQ1BJTV9IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmYV9mY3B0bS5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmYV9mY3B0bS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVmNWZmZTAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZhX2ZjcHRtLmgKQEAgLTAsMCArMSw0NyBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0ZDUFRNX0hfXworI2RlZmluZSBfX0JGQV9GQ1BUTV9IX18KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxiZmkvYmZpX2ZjcHRtLmg+CisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdHJ1Y3QgYmZhX3Rpbl9zOworc3RydWN0IGJmYV9pb3RtX3M7CitzdHJ1Y3QgYmZhX3Rza3RtX3M7CisKKy8qCisgKiBiZmEgZmNwdG0gbW9kdWxlIEFQSSBmdW5jdGlvbnMKKyAqLwordm9pZCBiZmFfZmNwdG1fcGF0aF90b3Zfc2V0KHN0cnVjdCBiZmFfcyAqYmZhLCB1MTYgcGF0aF90b3YpOwordTE2IGJmYV9mY3B0bV9wYXRoX3Rvdl9nZXQoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfZmNwdG1fcWRlcHRoX3NldChzdHJ1Y3QgYmZhX3MgKmJmYSwgdTE2IHFfZGVwdGgpOwordTE2IGJmYV9mY3B0bV9xZGVwdGhfZ2V0KHN0cnVjdCBiZmFfcyAqYmZhKTsKKworLyoKKyAqIGJmYSB0aW4gQVBJIGZ1bmN0aW9ucworICovCit2b2lkIGJmYV90aW5fZ2V0X3N0YXRzKHN0cnVjdCBiZmFfdGluX3MgKnRpbiwgc3RydWN0IGJmYV90aW5fc3RhdHNfcyAqc3RhdHMpOwordm9pZCBiZmFfdGluX2NsZWFyX3N0YXRzKHN0cnVjdCBiZmFfdGluX3MgKnRpbik7CisKKyNlbmRpZiAvKiBfX0JGQV9GQ1BUTV9IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmYV9zdmMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmFfc3ZjLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGM4MGI3NAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmFfc3ZjLmgKQEAgLTAsMCArMSwzMjQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRkFfU1ZDX0hfXworI2RlZmluZSBfX0JGQV9TVkNfSF9fCisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdHJ1Y3QgYmZhX2ZjeHBfczsKKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfc3RhdHVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcnBvcnQuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3Fvcy5oPgorI2luY2x1ZGUgPGNzL2JmYV9zbS5oPgorI2luY2x1ZGUgPGJmYS5oPgorCisvKioKKyAqIAkJQkZBIHJwb3J0IGluZm9ybWF0aW9uLgorICovCitzdHJ1Y3QgYmZhX3Jwb3J0X2luZm9fcyB7CisJdTE2ICAgICAgICBtYXhfZnJtc3o7CS8qICBtYXggcmN2IHBkdSBzaXplICAgICAgICAgICAgICAgKi8KKwl1MzIgICAgICAgIHBpZCA6IDI0LAkvKiAgcmVtb3RlIHBvcnQgSUQgICAgICAgICAgICAgICAgICovCisJCQlscF90YWcgOiA4OworCXUzMiAgICAgICAgbG9jYWxfcGlkIDogMjQsCS8qICBsb2NhbCBwb3J0IElECQkgICAgKi8KKwkJCWNpc2MgOiA4OwkvKiAgQ0lSTyBzdXBwb3J0ZWQJCSAgICAqLworCXU4ICAgICAgICAgZmNfY2xhc3M7CS8qICBzdXBwb3J0ZWQgRkMgY2xhc3Nlcy4gZW51bSBmY19jb3MgKi8KKwl1OCAgICAgICAgIHZmX2VuOwkJLyogIHZpcnR1YWwgZmFicmljIGVuYWJsZSAgICAgICAgICAqLworCXUxNiAgICAgICAgdmZfaWQ7CQkvKiAgdmlydHVhbCBmYWJyaWMgSUQgICAgICAgICAgICAgICovCisJZW51bSBiZmFfcHBvcnRfc3BlZWQgc3BlZWQ7CS8qICBScG9ydCdzIGN1cnJlbnQgc3BlZWQJICAgICovCit9OworCisvKioKKyAqIEJGQSBycG9ydCBkYXRhIHN0cnVjdHVyZQorICovCitzdHJ1Y3QgYmZhX3Jwb3J0X3MgeworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgIHFlOwkgIC8qICBxdWV1ZSBlbGVtZW50ICovCisJYmZhX3NtX3QJICAgICAgc207IAkgIC8qICBzdGF0ZSBtYWNoaW5lICovCisJc3RydWN0IGJmYV9zICAgICAgICAgICpiZmE7CSAgLyogIGJhY2twb2ludGVyIHRvIEJGQSAqLworCXZvaWQgICAgICAgICAgICAgICAgICAqcnBvcnRfZHJ2OyAvKiAgZmNzL2RyaXZlciBycG9ydCBvYmplY3QgKi8KKwl1MTYgICAgICAgICAgICAgIGZ3X2hhbmRsZTsgLyogIGZpcm13YXJlIHJwb3J0IGhhbmRsZSAqLworCXUxNiAgICAgICAgICAgICAgcnBvcnRfdGFnOyAvKiAgQkZBIHJwb3J0IHRhZyAqLworCXN0cnVjdCBiZmFfcnBvcnRfaW5mb19zIHJwb3J0X2luZm87IC8qICBycG9ydCBpbmZvIGZyb20gKmZjcy9kcml2ZXIgKi8KKwlzdHJ1Y3QgYmZhX3JlcXFfd2FpdF9zIHJlcXFfd2FpdDsgLyogIHRvIHdhaXQgZm9yIHJvb20gaW4gcmVxcSAqLworCXN0cnVjdCBiZmFfY2JfcWVfcyAgICBoY2JfcWU7CSAvKiAgQkZBIGNhbGxiYWNrIHFlbGVtICovCisJc3RydWN0IGJmYV9ycG9ydF9oYWxfc3RhdHNfcyBzdGF0czsgLyogIEJGQSBycG9ydCBzdGF0aXN0aWNzICAqLworCXN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyAgcW9zX2F0dHI7CisJdW5pb24gYSB7CisJCWJmYV9zdGF0dXNfdCAgICBzdGF0dXM7CSAvKiAgZi93IHN0YXR1cyAqLworCQl2b2lkICAgICAgICAgICAgKmZ3X21zZzsgLyogIFFvUyBzY24gZXZlbnQgKi8KKwl9IGV2ZW50X2FyZzsKK307CisjZGVmaW5lIEJGQV9SUE9SVF9GQ19DT1MoX3Jwb3J0KQkoKF9ycG9ydCktPnJwb3J0X2luZm8uZmNfY2xhc3MpCisKKy8qKgorICogU2VuZCBjb21wbGV0aW9uIGNhbGxiYWNrLgorICovCit0eXBlZGVmIHZvaWQgKCpiZmFfY2JfZmN4cF9zZW5kX3QpICh2b2lkICpiZmFkX2ZjeHAsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJdm9pZCAqY2JhcmcsIGVudW0gYmZhX3N0YXR1cyByZXFfc3RhdHVzLAorCQkJdTMyIHJzcF9sZW4sIHUzMiByZXNpZF9sZW4sCisJCQlzdHJ1Y3QgZmNoc19zICpyc3BfZmNocyk7CisKKy8qKgorICogQkZBIGZjeHAgYWxsb2NhdGlvbiAoYXN5bmNocm9ub3VzKQorICovCit0eXBlZGVmIHZvaWQgKCpiZmFfZmN4cF9hbGxvY19jYmZuX3QpICh2b2lkICpjYmFyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApOworCitzdHJ1Y3QgYmZhX2ZjeHBfd3FlX3MgeworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICBxZTsKKwliZmFfZmN4cF9hbGxvY19jYmZuX3QgIGFsbG9jX2NiZm47CisJdm9pZCAgICAgICAgICAgKmFsbG9jX2NiYXJnOworfTsKKwordHlwZWRlZiB1NjQgKCpiZmFfZmN4cF9nZXRfc2dhZGRyX3QpICh2b2lkICpiZmFkX2ZjeHAsIGludCBzZ2VpZCk7Cit0eXBlZGVmIHUzMiAoKmJmYV9mY3hwX2dldF9zZ2xlbl90KSAodm9pZCAqYmZhZF9mY3hwLCBpbnQgc2dlaWQpOworCisjZGVmaW5lIEJGQV9VRl9CVUZTWgkoMiAqIDEwMjQgKyAyNTYpCisKKy8qKgorICogQHRvZG8gcHJpdmF0ZQorICovCitzdHJ1Y3QgYmZhX3VmX2J1Zl9zIHsKKwl1OCAgICAgICAgIGRbQkZBX1VGX0JVRlNaXTsKK307CisKKworc3RydWN0IGJmYV91Zl9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkCXFlOwkJLyogIHF1ZXVlIGVsZW1lbnQJICAqLworCXN0cnVjdCBiZmFfcwkqYmZhOwkJLyogIGJmYSBpbnN0YW5jZQkgICovCisJdTE2ICAgICAgICB1Zl90YWc7CQkvKiAgaWRlbnRpZnlpbmcgdGFnIGYvdyBtZXNzYWdlcyAqLworCXUxNiAgICAgICAgdmZfaWQ7CisJdTE2ICAgICAgICBzcmNfcnBvcnRfaGFuZGxlOworCXUxNiAgICAgICAgcnN2ZDsKKwl1OCAgICAgICAgCSpkYXRhX3B0cjsKKwl1MTYgICAgICAgIGRhdGFfbGVuOwkvKiAgYWN0dWFsIHJlY2VpdmUgbGVuZ3RoCSAgKi8KKwl1MTYgICAgICAgIHBiX2xlbjsJCS8qICBwb3N0ZWQgYnVmZmVyIGxlbmd0aAkgICovCisJdm9pZCAgICAgICAgICAgCSpidWZfa3ZhOwkvKiAgYnVmZmVyIHZpcnR1YWwgYWRkcmVzcwkgICovCisJdTY0ICAgICAgICBidWZfcGE7CQkvKiAgYnVmZmVyIHBoeXNpY2FsIGFkZHJlc3MJICAqLworCXN0cnVjdCBiZmFfY2JfcWVfcyAgICBoY2JfcWU7CS8qICBjb21wOiBCRkEgY29tcCBxZWxlbQkgICovCisJc3RydWN0IGJmYV9zZ2VfcyAgIAlzZ2VzW0JGSV9TR0VfSU5MSU5FX01BWF07Cit9OworCit0eXBlZGVmIHZvaWQgKCpiZmFfY2JfcHBvcnRfdCkgKHZvaWQgKmNiYXJnLCBlbnVtIGJmYV9zdGF0dXMgc3RhdHVzKTsKKworLyoqCisgKiBiZmEgbHBvcnQgbG9naW4vbG9nb3V0IHNlcnZpY2UgaW50ZXJmYWNlCisgKi8KK3N0cnVjdCBiZmFfbHBzX3MgeworCXN0cnVjdCBsaXN0X2hlYWQJcWU7CQkvKiAgcXVldWUgZWxlbWVudCAqLworCXN0cnVjdCBiZmFfcwkqYmZhOwkJLyogIHBhcmVudCBiZmEgaW5zdGFuY2UJKi8KKwliZmFfc21fdAlzbTsJCS8qICBmaW5pdGUgc3RhdGUgbWFjaGluZQkqLworCXU4CQlscF90YWc7CQkvKiAgbHBvcnQgdGFnCQkJKi8KKwl1OAkJcmVxcTsJCS8qICBscG9ydCByZXF1ZXN0IHF1ZXVlCSovCisJdTgJCWFscGE7CQkvKiAgQUxQQSBmb3IgbG9vcCB0b3BvbG9naWVzCSovCisJdTMyCWxwX3BpZDsJCS8qICBscG9ydCBwb3J0IElECQkqLworCWJmYV9ib29sZWFuX3QJZmRpc2M7CQkvKiAgc2VuZCBGRElTQyBpbnN0ZWFkIG9mIEZMT0dJKi8KKwliZmFfYm9vbGVhbl90CWF1dGhfZW47CS8qICBlbmFibGUgYXV0aGVudGljYXRpb24JKi8KKwliZmFfYm9vbGVhbl90CWF1dGhfcmVxOwkvKiAgYXV0aGVudGljYXRpb24gcmVxdWlyZWQJKi8KKwliZmFfYm9vbGVhbl90CW5waXZfZW47CS8qICBOUElWIGlzIGFsbG93ZWQgYnkgcGVlcgkqLworCWJmYV9ib29sZWFuX3QJZnBvcnQ7CQkvKiAgYXR0YWNoZWQgcGVlciBpcyBGX1BPUlQJKi8KKwliZmFfYm9vbGVhbl90CWJyY2Rfc3dpdGNoOy8qICBhdHRhY2hlZCBwZWVyIGlzIGJyY2Qgc3dpdGNoCSovCisJYmZhX3N0YXR1c190CXN0YXR1czsJCS8qICBsb2dpbiBzdGF0dXMJCSovCisJdTE2CXBkdXN6OwkJLyogIG1heCByZWNlaXZlIFBEVSBzaXplIAkqLworCXUxNglwcl9iYmNyZWQ7CS8qICBCQl9DUkVESVQgZnJvbSBwZWVyIAkqLworCXU4CQlsc3JqdF9yc247CS8qICBMU1JKVCByZWFzb24JCSovCisJdTgJCWxzcmp0X2V4cGw7CS8qICBMU1JKVCBleHBsYW5hdGlvbgkJKi8KKwl3d25fdAkJcHd3bjsJCS8qICBwb3J0IHd3biBvZiBscG9ydAkJKi8KKwl3d25fdAkJbnd3bjsJCS8qICBub2RlIHd3biBvZiBscG9ydAkJKi8KKwl3d25fdAkJcHJfcHd3bjsJLyogIHBvcnQgd3duIG9mIGxwb3J0IHBlZXIJKi8KKwl3d25fdAkJcHJfbnd3bjsJLyogIG5vZGUgd3duIG9mIGxwb3J0IHBlZXIJKi8KKwltYWNfdAkJbHBfbWFjOwkJLyogIGZwbWEvc3BtYSBNQUMgZm9yIGxwb3J0CSovCisJbWFjX3QJCWZjZl9tYWM7CS8qICBGQ0YgTUFDIG9mIGxwb3J0CQkqLworCXN0cnVjdCBiZmFfcmVxcV93YWl0X3MJd3FlOwkvKiAgcmVxdWVzdCB3YWl0IHF1ZXVlIGVsZW1lbnQJKi8KKwl2b2lkCQkqdWFyZzsJCS8qICB1c2VyIGNhbGxiYWNrIGFyZwkJKi8KKwlzdHJ1Y3QgYmZhX2NiX3FlX3MgaGNiX3FlOwkvKiAgY29tcDogY2FsbGJhY2sgcWVsZW0JKi8KKwlzdHJ1Y3QgYmZpX2xwc19sb2dpbl9yc3BfcyAqbG9naW5yc3A7CisJYmZhX2Vwcm90b19zdGF0dXNfdAlleHRfc3RhdHVzOworfTsKKworLyoKKyAqIGJmYSBwcG9ydCBBUEkgZnVuY3Rpb25zCisgKi8KK2JmYV9zdGF0dXNfdCBiZmFfcHBvcnRfZW5hYmxlKHN0cnVjdCBiZmFfcyAqYmZhKTsKK2JmYV9zdGF0dXNfdCBiZmFfcHBvcnRfZGlzYWJsZShzdHJ1Y3QgYmZhX3MgKmJmYSk7CitiZmFfc3RhdHVzX3QgYmZhX3Bwb3J0X2NmZ19zcGVlZChzdHJ1Y3QgYmZhX3MgKmJmYSwKKwkJCWVudW0gYmZhX3Bwb3J0X3NwZWVkIHNwZWVkKTsKK2VudW0gYmZhX3Bwb3J0X3NwZWVkIGJmYV9wcG9ydF9nZXRfc3BlZWQoc3RydWN0IGJmYV9zICpiZmEpOworYmZhX3N0YXR1c190IGJmYV9wcG9ydF9jZmdfdG9wb2xvZ3koc3RydWN0IGJmYV9zICpiZmEsCisJCQllbnVtIGJmYV9wcG9ydF90b3BvbG9neSB0b3BvKTsKK2VudW0gYmZhX3Bwb3J0X3RvcG9sb2d5IGJmYV9wcG9ydF9nZXRfdG9wb2xvZ3koc3RydWN0IGJmYV9zICpiZmEpOworYmZhX3N0YXR1c190IGJmYV9wcG9ydF9jZmdfaGFyZGFscGEoc3RydWN0IGJmYV9zICpiZmEsIHU4IGFscGEpOworYmZhX2Jvb2xlYW5fdCBiZmFfcHBvcnRfZ2V0X2hhcmRhbHBhKHN0cnVjdCBiZmFfcyAqYmZhLCB1OCAqYWxwYSk7Cit1OCBiZmFfcHBvcnRfZ2V0X215YWxwYShzdHJ1Y3QgYmZhX3MgKmJmYSk7CitiZmFfc3RhdHVzX3QgYmZhX3Bwb3J0X2Nscl9oYXJkYWxwYShzdHJ1Y3QgYmZhX3MgKmJmYSk7CitiZmFfc3RhdHVzX3QgYmZhX3Bwb3J0X2NmZ19tYXhmcnNpemUoc3RydWN0IGJmYV9zICpiZmEsIHUxNiBtYXhzaXplKTsKK3UxNiBiZmFfcHBvcnRfZ2V0X21heGZyc2l6ZShzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit1MzIgYmZhX3Bwb3J0X215cGlkKHN0cnVjdCBiZmFfcyAqYmZhKTsKK3U4IGJmYV9wcG9ydF9nZXRfcnhfYmJjcmVkaXQoc3RydWN0IGJmYV9zICpiZmEpOworYmZhX3N0YXR1c190IGJmYV9wcG9ydF90cnVua19lbmFibGUoc3RydWN0IGJmYV9zICpiZmEsIHU4IGJpdG1hcCk7CitiZmFfc3RhdHVzX3QgYmZhX3Bwb3J0X3RydW5rX2Rpc2FibGUoc3RydWN0IGJmYV9zICpiZmEpOworYmZhX2Jvb2xlYW5fdCBiZmFfcHBvcnRfdHJ1bmtfcXVlcnkoc3RydWN0IGJmYV9zICpiZmEsIHUzMiAqYml0bWFwKTsKK3ZvaWQgYmZhX3Bwb3J0X2dldF9hdHRyKHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX3Bwb3J0X2F0dHJfcyAqYXR0cik7Cit3d25fdCBiZmFfcHBvcnRfZ2V0X3d3bihzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2Jvb2xlYW5fdCBub2RlKTsKK2JmYV9zdGF0dXNfdCBiZmFfcHBvcnRfZ2V0X3N0YXRzKHN0cnVjdCBiZmFfcyAqYmZhLAorCQkJdW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKnN0YXRzLAorCQkJYmZhX2NiX3Bwb3J0X3QgY2Jmbiwgdm9pZCAqY2JhcmcpOworYmZhX3N0YXR1c190IGJmYV9wcG9ydF9jbGVhcl9zdGF0cyhzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2NiX3Bwb3J0X3QgY2JmbiwKKwkJCXZvaWQgKmNiYXJnKTsKK3ZvaWQgYmZhX3Bwb3J0X2V2ZW50X3JlZ2lzdGVyKHN0cnVjdCBiZmFfcyAqYmZhLAorCQkJdm9pZCAoKmV2ZW50X2NiZm4pICh2b2lkICpjYmFyZywKKwkJCWJmYV9wcG9ydF9ldmVudF90IGV2ZW50KSwgdm9pZCAqZXZlbnRfY2JhcmcpOworYmZhX2Jvb2xlYW5fdCBiZmFfcHBvcnRfaXNfZGlzYWJsZWQoc3RydWN0IGJmYV9zICpiZmEpOwordm9pZCBiZmFfcHBvcnRfY2ZnX3FvcyhzdHJ1Y3QgYmZhX3MgKmJmYSwgYmZhX2Jvb2xlYW5fdCBvbl9vZmYpOwordm9pZCBiZmFfcHBvcnRfY2ZnX3JhdGVsaW0oc3RydWN0IGJmYV9zICpiZmEsIGJmYV9ib29sZWFuX3Qgb25fb2ZmKTsKK2JmYV9zdGF0dXNfdCBiZmFfcHBvcnRfY2ZnX3JhdGVsaW1fc3BlZWQoc3RydWN0IGJmYV9zICpiZmEsCisJCQllbnVtIGJmYV9wcG9ydF9zcGVlZCBzcGVlZCk7CitlbnVtIGJmYV9wcG9ydF9zcGVlZCBiZmFfcHBvcnRfZ2V0X3JhdGVsaW1fc3BlZWQoc3RydWN0IGJmYV9zICpiZmEpOworCit2b2lkIGJmYV9wcG9ydF9zZXRfdHhfYmJjcmVkaXQoc3RydWN0IGJmYV9zICpiZmEsIHUxNiB0eF9iYmNyZWRpdCk7Cit2b2lkIGJmYV9wcG9ydF9idXN5KHN0cnVjdCBiZmFfcyAqYmZhLCBiZmFfYm9vbGVhbl90IHN0YXR1cyk7Cit2b2lkIGJmYV9wcG9ydF9iZWFjb24oc3RydWN0IGJmYV9zICpiZmEsIGJmYV9ib29sZWFuX3QgYmVhY29uLAorCQkJYmZhX2Jvb2xlYW5fdCBsaW5rX2UyZV9iZWFjb24pOwordm9pZCBiZmFfY2JfcHBvcnRfZXZlbnQodm9pZCAqY2JhcmcsIGJmYV9wcG9ydF9ldmVudF90IGV2ZW50KTsKK3ZvaWQgYmZhX3Bwb3J0X3Fvc19nZXRfYXR0cihzdHJ1Y3QgYmZhX3MgKmJmYSwgc3RydWN0IGJmYV9xb3NfYXR0cl9zICpxb3NfYXR0cik7Cit2b2lkIGJmYV9wcG9ydF9xb3NfZ2V0X3ZjX2F0dHIoc3RydWN0IGJmYV9zICpiZmEsCisJCQlzdHJ1Y3QgYmZhX3Fvc192Y19hdHRyX3MgKnFvc192Y19hdHRyKTsKK2JmYV9zdGF0dXNfdCBiZmFfcHBvcnRfZ2V0X3Fvc19zdGF0cyhzdHJ1Y3QgYmZhX3MgKmJmYSwKKwkJCXVuaW9uIGJmYV9wcG9ydF9zdGF0c191ICpzdGF0cywKKwkJCWJmYV9jYl9wcG9ydF90IGNiZm4sIHZvaWQgKmNiYXJnKTsKK2JmYV9zdGF0dXNfdCBiZmFfcHBvcnRfY2xlYXJfcW9zX3N0YXRzKHN0cnVjdCBiZmFfcyAqYmZhLCBiZmFfY2JfcHBvcnRfdCBjYmZuLAorCQkJdm9pZCAqY2JhcmcpOworYmZhX2Jvb2xlYW5fdCAgICAgYmZhX3Bwb3J0X2lzX3JhdGVsaW0oc3RydWN0IGJmYV9zICpiZmEpOworYmZhX2Jvb2xlYW5fdAliZmFfcHBvcnRfaXNfbGlua3VwKHN0cnVjdCBiZmFfcyAqYmZhKTsKKworLyoKKyAqIGJmYSBycG9ydCBBUEkgZnVuY3Rpb25zCisgKi8KK3N0cnVjdCBiZmFfcnBvcnRfcyAqYmZhX3Jwb3J0X2NyZWF0ZShzdHJ1Y3QgYmZhX3MgKmJmYSwgdm9pZCAqcnBvcnRfZHJ2KTsKK3ZvaWQgYmZhX3Jwb3J0X2RlbGV0ZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgYmZhX3Jwb3J0X29ubGluZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0LAorCQkJc3RydWN0IGJmYV9ycG9ydF9pbmZvX3MgKnJwb3J0X2luZm8pOwordm9pZCBiZmFfcnBvcnRfb2ZmbGluZShzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgYmZhX3Jwb3J0X3NwZWVkKHN0cnVjdCBiZmFfcnBvcnRfcyAqcnBvcnQsIGVudW0gYmZhX3Bwb3J0X3NwZWVkIHNwZWVkKTsKK3ZvaWQgYmZhX3Jwb3J0X2dldF9zdGF0cyhzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0LAorCQkJc3RydWN0IGJmYV9ycG9ydF9oYWxfc3RhdHNfcyAqc3RhdHMpOwordm9pZCBiZmFfcnBvcnRfY2xlYXJfc3RhdHMoc3RydWN0IGJmYV9ycG9ydF9zICpycG9ydCk7Cit2b2lkIGJmYV9jYl9ycG9ydF9vbmxpbmUodm9pZCAqcnBvcnQpOwordm9pZCBiZmFfY2JfcnBvcnRfb2ZmbGluZSh2b2lkICpycG9ydCk7Cit2b2lkIGJmYV9jYl9ycG9ydF9xb3Nfc2NuX2Zsb3dpZCh2b2lkICpycG9ydCwKKwkJCXN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyBvbGRfcW9zX2F0dHIsCisJCQlzdHJ1Y3QgYmZhX3Jwb3J0X3Fvc19hdHRyX3MgbmV3X3Fvc19hdHRyKTsKK3ZvaWQgYmZhX2NiX3Jwb3J0X3Fvc19zY25fcHJpbyh2b2lkICpycG9ydCwKKwkJCXN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyBvbGRfcW9zX2F0dHIsCisJCQlzdHJ1Y3QgYmZhX3Jwb3J0X3Fvc19hdHRyX3MgbmV3X3Fvc19hdHRyKTsKK3ZvaWQgYmZhX3Jwb3J0X2dldF9xb3NfYXR0cihzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0LAorCQkJc3RydWN0IGJmYV9ycG9ydF9xb3NfYXR0cl9zICpxb3NfYXR0cik7CisKKy8qCisgKiBiZmEgZmN4cCBBUEkgZnVuY3Rpb25zCisgKi8KK3N0cnVjdCBiZmFfZmN4cF9zICpiZmFfZmN4cF9hbGxvYyh2b2lkICpiZmFkX2ZjeHAsIHN0cnVjdCBiZmFfcyAqYmZhLAorCQkJaW50IG5yZXFfc2dsZXMsIGludCBucnNwX3NnbGVzLAorCQkJYmZhX2ZjeHBfZ2V0X3NnYWRkcl90IGdldF9yZXFfc2dhLAorCQkJYmZhX2ZjeHBfZ2V0X3NnbGVuX3QgZ2V0X3JlcV9zZ2xlbiwKKwkJCWJmYV9mY3hwX2dldF9zZ2FkZHJfdCBnZXRfcnNwX3NnYSwKKwkJCWJmYV9mY3hwX2dldF9zZ2xlbl90IGdldF9yc3Bfc2dsZW4pOwordm9pZCBiZmFfZmN4cF9hbGxvY193YWl0KHN0cnVjdCBiZmFfcyAqYmZhLCBzdHJ1Y3QgYmZhX2ZjeHBfd3FlX3MgKndxZSwKKwkJCWJmYV9mY3hwX2FsbG9jX2NiZm5fdCBhbGxvY19jYmZuLCB2b2lkICpjYmFyZyk7Cit2b2lkIGJmYV9mY3hwX3dhbGxvY19jYW5jZWwoc3RydWN0IGJmYV9zICpiZmEsCisJCQlzdHJ1Y3QgYmZhX2ZjeHBfd3FlX3MgKndxZSk7Cit2b2lkIGJmYV9mY3hwX2Rpc2NhcmQoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApOworCit2b2lkICpiZmFfZmN4cF9nZXRfcmVxYnVmKHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwKTsKK3ZvaWQgKmJmYV9mY3hwX2dldF9yc3BidWYoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApOworCit2b2lkIGJmYV9mY3hwX2ZyZWUoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApOworCit2b2lkIGJmYV9mY3hwX3NlbmQoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQlzdHJ1Y3QgYmZhX3Jwb3J0X3MgKnJwb3J0LCB1MTYgdmZfaWQsIHU4IGxwX3RhZywKKwkJCWJmYV9ib29sZWFuX3QgY3RzLCBlbnVtIGZjX2NvcyBjb3MsCisJCQl1MzIgcmVxbGVuLCBzdHJ1Y3QgZmNoc19zICpmY2hzLAorCQkJYmZhX2NiX2ZjeHBfc2VuZF90IGNiZm4sCisJCQl2b2lkICpjYmFyZywKKwkJCXUzMiByc3BfbWF4bGVuLCB1OCByc3BfdGltZW91dCk7CitiZmFfc3RhdHVzX3QgYmZhX2ZjeHBfYWJvcnQoc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApOwordTMyICAgICAgICBiZmFfZmN4cF9nZXRfcmVxYnVmc3ooc3RydWN0IGJmYV9mY3hwX3MgKmZjeHApOwordTMyCWJmYV9mY3hwX2dldF9tYXhyc3Aoc3RydWN0IGJmYV9zICpiZmEpOworCitzdGF0aWMgaW5saW5lIHZvaWQgKgorYmZhX3VmX2dldF9mcm1idWYoc3RydWN0IGJmYV91Zl9zICp1ZikKK3sKKwlyZXR1cm4gdWYtPmRhdGFfcHRyOworfQorCitzdGF0aWMgaW5saW5lICAgdTE2CitiZmFfdWZfZ2V0X2ZybWxlbihzdHJ1Y3QgYmZhX3VmX3MgKnVmKQoreworCXJldHVybiB1Zi0+ZGF0YV9sZW47Cit9CisKKy8qKgorICogICAgICBDYWxsYmFjayBwcm90b3R5cGUgZm9yIHVuc29saWNpdGVkIGZyYW1lIHJlY2VpdmUgaGFuZGxlci4KKyAqCisgKiBAcGFyYW1baW5dICAgICAgICAgICBjYmFyZyAgICAgICAgICAgY2FsbGJhY2sgYXJnIGZvciByZWNlaXZlIGhhbmRsZXIKKyAqIEBwYXJhbVtpbl0gICAgICAgICAgIHVmICAgICAgICAgICAgICB1bnNvbGljaXRlZCBmcmFtZSBkZXNjcmlwdG9yCisgKgorICogQHJldHVybiBOb25lCisgKi8KK3R5cGVkZWYgdm9pZCAoKmJmYV9jYl91Zl9yZWN2X3QpICh2b2lkICpjYmFyZywgc3RydWN0IGJmYV91Zl9zICp1Zik7CisKKy8qCisgKiBiZmEgdWYgQVBJIGZ1bmN0aW9ucworICovCit2b2lkIGJmYV91Zl9yZWN2X3JlZ2lzdGVyKHN0cnVjdCBiZmFfcyAqYmZhLCBiZmFfY2JfdWZfcmVjdl90IHVmcmVjdiwKKwkJCXZvaWQgKmNiYXJnKTsKK3ZvaWQgYmZhX3VmX2ZyZWUoc3RydWN0IGJmYV91Zl9zICp1Zik7CisKKy8qKgorICogYmZhIGxwb3J0IHNlcnZpY2UgYXBpCisgKi8KKworc3RydWN0IGJmYV9scHNfcyAqYmZhX2xwc19hbGxvYyhzdHJ1Y3QgYmZhX3MgKmJmYSk7Cit2b2lkIGJmYV9scHNfZGVsZXRlKHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7Cit2b2lkIGJmYV9scHNfZGlzY2FyZChzdHJ1Y3QgYmZhX2xwc19zICpscHMpOwordm9pZCBiZmFfbHBzX2Zsb2dpKHN0cnVjdCBiZmFfbHBzX3MgKmxwcywgdm9pZCAqdWFyZywgdTggYWxwYSwgdTE2IHBkdXN6LAorCQkgICB3d25fdCBwd3duLCB3d25fdCBud3duLCBiZmFfYm9vbGVhbl90IGF1dGhfZW4pOwordm9pZCBiZmFfbHBzX2ZkaXNjKHN0cnVjdCBiZmFfbHBzX3MgKmxwcywgdm9pZCAqdWFyZywgdTE2IHBkdXN6LCB3d25fdCBwd3duLAorCQkgICB3d25fdCBud3duKTsKK3ZvaWQgYmZhX2xwc19mbG9nbyhzdHJ1Y3QgYmZhX2xwc19zICpscHMpOwordm9pZCBiZmFfbHBzX2ZkaXNjbG9nbyhzdHJ1Y3QgYmZhX2xwc19zICpscHMpOwordTggYmZhX2xwc19nZXRfdGFnKHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7CitiZmFfYm9vbGVhbl90IGJmYV9scHNfaXNfbnBpdl9lbihzdHJ1Y3QgYmZhX2xwc19zICpscHMpOworYmZhX2Jvb2xlYW5fdCBiZmFfbHBzX2lzX2Zwb3J0KHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7CitiZmFfYm9vbGVhbl90IGJmYV9scHNfaXNfYnJjZF9mYWJyaWMoc3RydWN0IGJmYV9scHNfcyAqbHBzKTsKK2JmYV9ib29sZWFuX3QgYmZhX2xwc19pc19hdXRocmVxKHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7CitiZmFfZXByb3RvX3N0YXR1c190IGJmYV9scHNfZ2V0X2V4dHN0YXR1cyhzdHJ1Y3QgYmZhX2xwc19zICpscHMpOwordTMyIGJmYV9scHNfZ2V0X3BpZChzdHJ1Y3QgYmZhX2xwc19zICpscHMpOwordTggYmZhX2xwc19nZXRfdGFnX2Zyb21fcGlkKHN0cnVjdCBiZmFfcyAqYmZhLCB1MzIgcGlkKTsKK3UxNiBiZmFfbHBzX2dldF9wZWVyX2JiY3JlZGl0KHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7Cit3d25fdCBiZmFfbHBzX2dldF9wZWVyX3B3d24oc3RydWN0IGJmYV9scHNfcyAqbHBzKTsKK3d3bl90IGJmYV9scHNfZ2V0X3BlZXJfbnd3bihzdHJ1Y3QgYmZhX2xwc19zICpscHMpOwordTggYmZhX2xwc19nZXRfbHNyanRfcnNuKHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7Cit1OCBiZmFfbHBzX2dldF9sc3JqdF9leHBsKHN0cnVjdCBiZmFfbHBzX3MgKmxwcyk7Cit2b2lkIGJmYV9jYl9scHNfZmxvZ2lfY29tcCh2b2lkICpiZmFkLCB2b2lkICp1YXJnLCBiZmFfc3RhdHVzX3Qgc3RhdHVzKTsKK3ZvaWQgYmZhX2NiX2xwc19mbG9nb19jb21wKHZvaWQgKmJmYWQsIHZvaWQgKnVhcmcpOwordm9pZCBiZmFfY2JfbHBzX2ZkaXNjX2NvbXAodm9pZCAqYmZhZCwgdm9pZCAqdWFyZywgYmZhX3N0YXR1c190IHN0YXR1cyk7Cit2b2lkIGJmYV9jYl9scHNfZmRpc2Nsb2dvX2NvbXAodm9pZCAqYmZhZCwgdm9pZCAqdWFyZyk7CisKKyNlbmRpZiAvKiBfX0JGQV9TVkNfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmFfdGltZXIuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmFfdGltZXIuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNDA3MTAzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmYV90aW1lci5oCkBAIC0wLDAgKzEsNTMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRkFfVElNRVJfSF9fCisjZGVmaW5lIF9fQkZBX1RJTUVSX0hfXworCisjaW5jbHVkZSA8YmZhX29zX2luYy5oPgorI2luY2x1ZGUgPGNzL2JmYV9xLmg+CisKK3N0cnVjdCBiZmFfczsKKwordHlwZWRlZiB2b2lkICgqYmZhX3RpbWVyX2NiZm5fdCkodm9pZCAqKTsKKworLyoqCisgKiBCRkEgdGltZXIgZGF0YSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGJmYV90aW1lcl9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkCXFlOworCWJmYV90aW1lcl9jYmZuX3QgdGltZXJjYjsKKwl2b2lkICAgICAgICAgICAgKmFyZzsKKwlpbnQgICAgICAgICAgICAgdGltZW91dDsJLyoqPCBpbiBtaWxsaXNlY3MuICovCit9OworCisvKioKKyAqIFRpbWVyIG1vZHVsZSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGJmYV90aW1lcl9tb2RfcyB7CisJc3RydWN0IGxpc3RfaGVhZCB0aW1lcl9xOworfTsKKworI2RlZmluZSBCRkFfVElNRVJfRlJFUSA1MDAgLyoqPCBzcGVjaWZpZWQgaW4gbWlsbGlzZWNzICovCisKK3ZvaWQgYmZhX3RpbWVyX2JlYXQoc3RydWN0IGJmYV90aW1lcl9tb2RfcyAqbW9kKTsKK3ZvaWQgYmZhX3RpbWVyX2luaXQoc3RydWN0IGJmYV90aW1lcl9tb2RfcyAqbW9kKTsKK3ZvaWQgYmZhX3RpbWVyX2JlZ2luKHN0cnVjdCBiZmFfdGltZXJfbW9kX3MgKm1vZCwgc3RydWN0IGJmYV90aW1lcl9zICp0aW1lciwKKwkJCWJmYV90aW1lcl9jYmZuX3QgdGltZXJjYiwgdm9pZCAqYXJnLAorCQkJdW5zaWduZWQgaW50IHRpbWVvdXQpOwordm9pZCBiZmFfdGltZXJfc3RvcChzdHJ1Y3QgYmZhX3RpbWVyX3MgKnRpbWVyKTsKKworI2VuZGlmIC8qIF9fQkZBX1RJTUVSX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmkuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmNhZGZlMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpLmgKQEAgLTAsMCArMSwxNzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGSV9IX18KKyNkZWZpbmUgX19CRklfSF9fCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19zdGF0dXMuaD4KKworI3ByYWdtYSBwYWNrKDEpCisKKy8qKgorICogTXNnIGhlYWRlciBjb21tb24gdG8gYWxsIG1zZ3MKKyAqLworc3RydWN0IGJmaV9taGRyX3MgeworCXU4ICAgICAgICAgbXNnX2NsYXNzOwkvKiAgQHJlZiBiZmlfbWNsYXNzX3QJICAgICovCisJdTggICAgICAgICBtc2dfaWQ7CQkvKiAgbXNnIG9wY29kZSB3aXRoIGluIHRoZSBjbGFzcyAgICovCisJdW5pb24geworCQlzdHJ1Y3QgeworCQkJdTggICAgICAgICByc3ZkOworCQkJdTggICAgICAgICBscHVfaWQ7CS8qICBtc2cgZGVzdGluYXRpb24JICAgICovCisJCX0gaDJpOworCQl1MTYgICAgICAgIGkyaHRvazsJLyogIHRva2VuIGluIG1zZ3MgdG8gaG9zdAkgICAgKi8KKwl9IG10YWc7Cit9OworCisjZGVmaW5lIGJmaV9oMmlfc2V0KF9taCwgX21jLCBfb3AsIF9scHVpZCkgZG8gewkJXAorCShfbWgpLm1zZ19jbGFzcyAJCT0gKF9tYyk7ICAgICAgXAorCShfbWgpLm1zZ19pZAkJCT0gKF9vcCk7ICAgICAgXAorCShfbWgpLm10YWcuaDJpLmxwdV9pZAk9IChfbHB1aWQpOyAgICAgIFwKK30gd2hpbGUgKDApCisKKyNkZWZpbmUgYmZpX2kyaF9zZXQoX21oLCBfbWMsIF9vcCwgX2kyaHRvaykgZG8gewkJXAorCShfbWgpLm1zZ19jbGFzcyAJCT0gKF9tYyk7ICAgICAgXAorCShfbWgpLm1zZ19pZAkJCT0gKF9vcCk7ICAgICAgXAorCShfbWgpLm10YWcuaTJodG9rCQk9IChfaTJodG9rKTsgICAgICBcCit9IHdoaWxlICgwKQorCisvKgorICogTWVzc2FnZSBvcGNvZGVzOiAwLTEyNyB0byBmaXJtd2FyZSwgMTI4LTI1NSB0byBob3N0CisgKi8KKyNkZWZpbmUgQkZJX0kySF9PUENPREVfQkFTRQkxMjgKKyNkZWZpbmUgQkZBX0kySE0oX3gpIAkJCSgoX3gpICsgQkZJX0kySF9PUENPREVfQkFTRSkKKworLyoqCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICoKKyAqIFNjYXR0ZXIgR2F0aGVyIEVsZW1lbnQgYW5kIFBhZ2UgZGVmaW5pdGlvbgorICoKKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKi8KKworI2RlZmluZSBCRklfU0dFX0lOTElORQkxCisjZGVmaW5lIEJGSV9TR0VfSU5MSU5FX01BWAkoQkZJX1NHRV9JTkxJTkUgKyAxKQorCisvKioKKyAqIFNHIEZsYWdzCisgKi8KK2VudW0geworCUJGSV9TR0VfREFUQQk9IDAsCS8qICBkYXRhIGFkZHJlc3MsIG5vdCBsYXN0CSAgICAgKi8KKwlCRklfU0dFX0RBVEFfQ1BMCT0gMSwJLyogIGRhdGEgYWRkciwgbGFzdCBpbiBjdXJyZW50IHBhZ2UgKi8KKwlCRklfU0dFX0RBVEFfTEFTVAk9IDMsCS8qICBkYXRhIGFkZHJlc3MsIGxhc3QJCSAgICAgKi8KKwlCRklfU0dFX0xJTksJPSAyLAkvKiAgbGluayBhZGRyZXNzCQkgICAgICovCisJQkZJX1NHRV9QR0RMRU4JPSAyLAkvKiAgY3VtdWxhdGl2ZSBkYXRhIGxlbmd0aCBmb3IgcGFnZSAqLworfTsKKworLyoqCisgKiBETUEgYWRkcmVzc2VzCisgKi8KK3VuaW9uIGJmaV9hZGRyX3UgeworCXN0cnVjdCB7CisJCXUzMiAgICAgICAgYWRkcl9sbzsKKwkJdTMyICAgICAgICBhZGRyX2hpOworCX0gYTMyOworfTsKKworLyoqCisgKiBTY2F0dGVyIEdhdGhlciBFbGVtZW50CisgKi8KK3N0cnVjdCBiZmlfc2dlX3MgeworI2lmZGVmIF9fQklHRU5ESUFOCisJdTMyICAgICAgICBmbGFncwk6IDIsCisJCQlyc3ZkCTogMiwKKwkJCXNnX2xlbgk6IDI4OworI2Vsc2UKKwl1MzIgICAgICAgIHNnX2xlbgk6IDI4LAorCQkJcnN2ZAk6IDIsCisJCQlmbGFncwk6IDI7CisjZW5kaWYKKwl1bmlvbiBiZmlfYWRkcl91IHNnYTsKK307CisKKy8qKgorICogU2NhdHRlciBHYXRoZXIgUGFnZQorICovCisjZGVmaW5lIEJGSV9TR1BHX0RBVEFfU0dFUwkJNworI2RlZmluZSBCRklfU0dQR19TR0VTX01BWAkJKEJGSV9TR1BHX0RBVEFfU0dFUyArIDEpCisjZGVmaW5lIEJGSV9TR1BHX1JTVkRfV0RfTEVOCTgKK3N0cnVjdCBiZmlfc2dwZ19zIHsKKwlzdHJ1Y3QgYmZpX3NnZV9zIHNnZXNbQkZJX1NHUEdfU0dFU19NQVhdOworCXUzMglyc3ZkW0JGSV9TR1BHX1JTVkRfV0RfTEVOXTsKK307CisKKy8qCisgKiBMYXJnZSBNZXNzYWdlIHN0cnVjdHVyZSAtIDEyOCBCeXRlcyBzaXplIE1zZ3MKKyAqLworI2RlZmluZSBCRklfTE1TR19TWgkJMTI4CisjZGVmaW5lIEJGSV9MTVNHX1BMX1dTWglcCisJCQkoKEJGSV9MTVNHX1NaIC0gc2l6ZW9mKHN0cnVjdCBiZmlfbWhkcl9zKSkgLyA0KQorCitzdHJ1Y3QgYmZpX21zZ19zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyBtaGRyOworCXUzMglwbFtCRklfTE1TR19QTF9XU1pdOworfTsKKworLyoqCisgKiBNYWlsYm94IG1lc3NhZ2Ugc3RydWN0dXJlCisgKi8KKyNkZWZpbmUgQkZJX01CTVNHX1NaCQk3CitzdHJ1Y3QgYmZpX21ibXNnX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zCW1oOworCXUzMgkJcGxbQkZJX01CTVNHX1NaXTsKK307CisKKy8qKgorICogTWVzc2FnZSBDbGFzc2VzCisgKi8KK2VudW0gYmZpX21jbGFzcyB7CisJQkZJX01DX0lPQwkJPSAxLAkvKiAgSU8gQ29udHJvbGxlciAoSU9DKQkgICAgKi8KKwlCRklfTUNfRElBRwkJPSAyLAkvKiAgRGlhZ25vc3RpYyBNc2dzCQkgICAgKi8KKwlCRklfTUNfRkxBU0gJCT0gMywJLyogIEZsYXNoIG1lc3NhZ2UgY2xhc3MJICAgICovCisJQkZJX01DX0NFRQkJPSA0LAorCUJGSV9NQ19GQ19QT1JUCQk9IDUsCS8qICBGQyBwb3J0CQkgICAJICAgICovCisJQkZJX01DX0lPQ0ZDCQk9IDYsCS8qICBGQyAtIElPIENvbnRyb2xsZXIgKElPQykJICAgICovCisJQkZJX01DX0xMCQk9IDcsCS8qICBMaW5rIExheWVyCQkgCSAgICAqLworCUJGSV9NQ19VRgkJPSA4LAkvKiAgVW5zb2xpY2l0ZWQgZnJhbWUgcmVjZWl2ZQkgICAgKi8KKwlCRklfTUNfRkNYUAkJPSA5LAkvKiAgRkMgVHJhbnNwb3J0CQkgICAgKi8KKwlCRklfTUNfTFBTCQk9IDEwLAkvKiAgbHBvcnQgZmMgbG9naW4gc2VydmljZXMJICAgICovCisJQkZJX01DX1JQT1JUCQk9IDExLAkvKiAgUmVtb3RlIHBvcnQJCSAgICAqLworCUJGSV9NQ19JVE5JTQkJPSAxMiwJLyogIEktVCBuZXh1cyAoSW5pdGlhdG9yIG1vZGUpCSAgICAqLworCUJGSV9NQ19JT0lNX1JFQUQJPSAxMywJLyogIHJlYWQgSU8gKEluaXRpYXRvciBtb2RlKQkgICAgKi8KKwlCRklfTUNfSU9JTV9XUklURQk9IDE0LAkvKiAgd3JpdGUgSU8gKEluaXRpYXRvciBtb2RlKQkgICAgKi8KKwlCRklfTUNfSU9JTV9JTwkJPSAxNSwJLyogIElPIChJbml0aWF0b3IgbW9kZSkJICAgICovCisJQkZJX01DX0lPSU0JCT0gMTYsCS8qICBJTyAoSW5pdGlhdG9yIG1vZGUpCSAgICAqLworCUJGSV9NQ19JT0lNX0lPQ09NCT0gMTcsCS8qICBnb29kIElPIGNvbXBsZXRpb24JCSAgICAqLworCUJGSV9NQ19UU0tJTQkJPSAxOCwJLyogIEluaXRpYXRvciBUYXNrIG1hbmFnZW1lbnQJICAgICovCisJQkZJX01DX1NCT09UCQk9IDE5LAkvKiAgU0FOIGJvb3Qgc2VydmljZXMJCSAgICAqLworCUJGSV9NQ19JUEZDCQk9IDIwLAkvKiAgSVAgb3ZlciBGQyBNc2dzCQkgICAgKi8KKwlCRklfTUNfUE9SVAkJPSAyMSwJLyogIFBoeXNpY2FsIHBvcnQJCSAgICAqLworCUJGSV9NQ19NQVgJCT0gMzIKK307CisKKyNkZWZpbmUgQkZJX0lPQ19NQVhfQ1FTCQk0CisjZGVmaW5lIEJGSV9JT0NfTUFYX0NRU19BU0lDCTgKKyNkZWZpbmUgQkZJX0lPQ19NU0dMRU5fTUFYCTMyCS8qIDMyIGJ5dGVzICovCisKKyNwcmFnbWEgcGFjaygpCisKKyNlbmRpZiAvKiBfX0JGSV9IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfYm9vdC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfYm9vdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU5NTVhZmUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9ib290LmgKQEAgLTAsMCArMSwzNCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworLyoKKyAqIGJmaV9ib290LmgKKyAqLworCisjaWZuZGVmIF9fQkZJX0JPT1RfSF9fCisjZGVmaW5lIF9fQkZJX0JPT1RfSF9fCisKKyNkZWZpbmUgQkZJX0JPT1RfVFlQRV9PRkYJCTgKKyNkZWZpbmUgQkZJX0JPT1RfUEFSQU1fT0ZGCQkxMgorCisjZGVmaW5lIEJGSV9CT09UX1RZUEVfTk9STUFMIAkJMAkvKiBwYXJhbSBpcyBkZXZpY2UgaWQgKi8KKyNkZWZpbmUJQkZJX0JPT1RfVFlQRV9GTEFTSAkJMQorI2RlZmluZQlCRklfQk9PVF9UWVBFX01FTVRFU1QJCTIKKworI2RlZmluZSBCRklfQk9PVF9NRU1URVNUX1JFU19BRERSICAgMHg5MDAKKyNkZWZpbmUgQkZJX0JPT1RfTUVNVEVTVF9SRVNfU0lHICAgIDB4QTBBMUEyQTMKKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9jYnJlZy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfY2JyZWcuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iM2JiNTJiCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfY2JyZWcuaApAQCAtMCwwICsxLDMwNSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKgorICogYmZpX2NicmVnLmggY3Jvc3Nib3cgaG9zdCBibG9jayByZWdpc3RlciBkZWZpbml0aW9ucworICoKKyAqICEhISBEbyBub3QgZWRpdC4gQXV0byBnZW5lcmF0ZWQuICEhIQorICovCisKKyNpZm5kZWYgX19CRklfQ0JSRUdfSF9fCisjZGVmaW5lIF9fQkZJX0NCUkVHX0hfXworCisKKyNkZWZpbmUgSE9TVEZOMF9JTlRfU1RBVFVTICAgICAgICAgICAgICAgMHgwMDAxNDAwMAorI2RlZmluZSBfX0hPU1RGTjBfSU5UX1NUQVRVU19MVkxfTUsgICAgICAweDAwZjAwMDAwCisjZGVmaW5lIF9fSE9TVEZOMF9JTlRfU1RBVFVTX0xWTF9TSCAgICAgIDIwCisjZGVmaW5lIF9fSE9TVEZOMF9JTlRfU1RBVFVTX0xWTChfdikgICAgICgoX3YpIDw8IF9fSE9TVEZOMF9JTlRfU1RBVFVTX0xWTF9TSCkKKyNkZWZpbmUgX19IT1NURk4wX0lOVF9TVEFUVVNfUCAgICAgICAgICAgMHgwMDBmZmZmZgorI2RlZmluZSBIT1NURk4wX0lOVF9NU0sgICAgICAgICAgICAgICAgICAweDAwMDE0MDA0CisjZGVmaW5lIEhPU1RfUEFHRV9OVU1fRk4wICAgICAgICAgICAgICAgIDB4MDAwMTQwMDgKKyNkZWZpbmUgX19IT1NUX1BBR0VfTlVNX0ZOICAgICAgICAgICAgICAgMHgwMDAwMDFmZgorI2RlZmluZSBIT1NURk4xX0lOVF9TVEFUVVMgICAgICAgICAgICAgICAweDAwMDE0MTAwCisjZGVmaW5lIF9fSE9TVEZOMV9JTlRfU1RBVF9MVkxfTUsgICAgICAgIDB4MDBmMDAwMDAKKyNkZWZpbmUgX19IT1NURk4xX0lOVF9TVEFUX0xWTF9TSCAgICAgICAgMjAKKyNkZWZpbmUgX19IT1NURk4xX0lOVF9TVEFUX0xWTChfdikgICAgICAgKChfdikgPDwgX19IT1NURk4xX0lOVF9TVEFUX0xWTF9TSCkKKyNkZWZpbmUgX19IT1NURk4xX0lOVF9TVEFUX1AgICAgICAgICAgICAgMHgwMDBmZmZmZgorI2RlZmluZSBIT1NURk4xX0lOVF9NU0sgICAgICAgICAgICAgICAgICAweDAwMDE0MTA0CisjZGVmaW5lIEhPU1RfUEFHRV9OVU1fRk4xICAgICAgICAgICAgICAgIDB4MDAwMTQxMDgKKyNkZWZpbmUgQVBQX1BMTF80MDBfQ1RMX1JFRyAgICAgICAgICAgICAgMHgwMDAxNDIwNAorI2RlZmluZSBfX1BfNDAwX1BMTF9MT0NLICAgICAgICAgICAgICAgICAweDgwMDAwMDAwCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfU1JBTV9VU0VfMTAwTUhaICAgIDB4MDAxMDAwMDAKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9SRVNFVF9USU1FUl9NSyAgICAgMHgwMDBlMDAwMAorI2RlZmluZSBfX0FQUF9QTExfNDAwX1JFU0VUX1RJTUVSX1NIICAgICAxNworI2RlZmluZSBfX0FQUF9QTExfNDAwX1JFU0VUX1RJTUVSKF92KSAgICAoKF92KSA8PCBfX0FQUF9QTExfNDAwX1JFU0VUX1RJTUVSX1NIKQorI2RlZmluZSBfX0FQUF9QTExfNDAwX0xPR0lDX1NPRlRfUkVTRVQgICAweDAwMDEwMDAwCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfQ05UTE1UMF8xX01LICAgICAgIDB4MDAwMGMwMDAKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9DTlRMTVQwXzFfU0ggICAgICAgMTQKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9DTlRMTVQwXzEoX3YpICAgICAgKChfdikgPDwgX19BUFBfUExMXzQwMF9DTlRMTVQwXzFfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfSklUTE1UMF8xX01LICAgICAgIDB4MDAwMDMwMDAKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9KSVRMTVQwXzFfU0ggICAgICAgMTIKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9KSVRMTVQwXzEoX3YpICAgICAgKChfdikgPDwgX19BUFBfUExMXzQwMF9KSVRMTVQwXzFfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfSFJFRiAgICAgICAgICAgICAgIDB4MDAwMDA4MDAKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9IRElWICAgICAgICAgICAgICAgMHgwMDAwMDQwMAorI2RlZmluZSBfX0FQUF9QTExfNDAwX1AwXzFfTUsgICAgICAgICAgICAweDAwMDAwMzAwCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfUDBfMV9TSCAgICAgICAgICAgIDgKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9QMF8xKF92KSAgICAgICAgICAgKChfdikgPDwgX19BUFBfUExMXzQwMF9QMF8xX1NIKQorI2RlZmluZSBfX0FQUF9QTExfNDAwX1owXzJfTUsgICAgICAgICAgICAweDAwMDAwMGUwCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfWjBfMl9TSCAgICAgICAgICAgIDUKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9aMF8yKF92KSAgICAgICAgICAgKChfdikgPDwgX19BUFBfUExMXzQwMF9aMF8yX1NIKQorI2RlZmluZSBfX0FQUF9QTExfNDAwX1JTRUwyMDA1MDAgICAgICAgICAweDAwMDAwMDEwCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfRU5BUlNUICAgICAgICAgICAgIDB4MDAwMDAwMDgKKyNkZWZpbmUgX19BUFBfUExMXzQwMF9CWVBBU1MgICAgICAgICAgICAgMHgwMDAwMDAwNAorI2RlZmluZSBfX0FQUF9QTExfNDAwX0xSRVNFVE4gICAgICAgICAgICAweDAwMDAwMDAyCisjZGVmaW5lIF9fQVBQX1BMTF80MDBfRU5BQkxFICAgICAgICAgICAgIDB4MDAwMDAwMDEKKyNkZWZpbmUgQVBQX1BMTF8yMTJfQ1RMX1JFRyAgICAgICAgICAgICAgMHgwMDAxNDIwOAorI2RlZmluZSBfX1BfMjEyX1BMTF9MT0NLICAgICAgICAgICAgICAgICAweDgwMDAwMDAwCisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfUkVTRVRfVElNRVJfTUsgICAgIDB4MDAwZTAwMDAKKyNkZWZpbmUgX19BUFBfUExMXzIxMl9SRVNFVF9USU1FUl9TSCAgICAgMTcKKyNkZWZpbmUgX19BUFBfUExMXzIxMl9SRVNFVF9USU1FUihfdikgICAgKChfdikgPDwgX19BUFBfUExMXzIxMl9SRVNFVF9USU1FUl9TSCkKKyNkZWZpbmUgX19BUFBfUExMXzIxMl9MT0dJQ19TT0ZUX1JFU0VUICAgMHgwMDAxMDAwMAorI2RlZmluZSBfX0FQUF9QTExfMjEyX0NOVExNVDBfMV9NSyAgICAgICAweDAwMDBjMDAwCisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfQ05UTE1UMF8xX1NIICAgICAgIDE0CisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfQ05UTE1UMF8xKF92KSAgICAgICgoX3YpIDw8IF9fQVBQX1BMTF8yMTJfQ05UTE1UMF8xX1NIKQorI2RlZmluZSBfX0FQUF9QTExfMjEyX0pJVExNVDBfMV9NSyAgICAgICAweDAwMDAzMDAwCisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfSklUTE1UMF8xX1NIICAgICAgIDEyCisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfSklUTE1UMF8xKF92KSAgICAgICgoX3YpIDw8IF9fQVBQX1BMTF8yMTJfSklUTE1UMF8xX1NIKQorI2RlZmluZSBfX0FQUF9QTExfMjEyX0hSRUYgICAgICAgICAgICAgICAweDAwMDAwODAwCisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfSERJViAgICAgICAgICAgICAgIDB4MDAwMDA0MDAKKyNkZWZpbmUgX19BUFBfUExMXzIxMl9QMF8xX01LICAgICAgICAgICAgMHgwMDAwMDMwMAorI2RlZmluZSBfX0FQUF9QTExfMjEyX1AwXzFfU0ggICAgICAgICAgICA4CisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfUDBfMShfdikgICAgICAgICAgICgoX3YpIDw8IF9fQVBQX1BMTF8yMTJfUDBfMV9TSCkKKyNkZWZpbmUgX19BUFBfUExMXzIxMl9aMF8yX01LICAgICAgICAgICAgMHgwMDAwMDBlMAorI2RlZmluZSBfX0FQUF9QTExfMjEyX1owXzJfU0ggICAgICAgICAgICA1CisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfWjBfMihfdikgICAgICAgICAgICgoX3YpIDw8IF9fQVBQX1BMTF8yMTJfWjBfMl9TSCkKKyNkZWZpbmUgX19BUFBfUExMXzIxMl9SU0VMMjAwNTAwICAgICAgICAgMHgwMDAwMDAxMAorI2RlZmluZSBfX0FQUF9QTExfMjEyX0VOQVJTVCAgICAgICAgICAgICAweDAwMDAwMDA4CisjZGVmaW5lIF9fQVBQX1BMTF8yMTJfQllQQVNTICAgICAgICAgICAgIDB4MDAwMDAwMDQKKyNkZWZpbmUgX19BUFBfUExMXzIxMl9MUkVTRVROICAgICAgICAgICAgMHgwMDAwMDAwMgorI2RlZmluZSBfX0FQUF9QTExfMjEyX0VOQUJMRSAgICAgICAgICAgICAweDAwMDAwMDAxCisjZGVmaW5lIEhPU1RfU0VNMF9SRUcgICAgICAgICAgICAgICAgICAgIDB4MDAwMTQyMzAKKyNkZWZpbmUgX19IT1NUX1NFTUFQSE9SRSAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMQorI2RlZmluZSBIT1NUX1NFTTFfUkVHICAgICAgICAgICAgICAgICAgICAweDAwMDE0MjM0CisjZGVmaW5lIEhPU1RfU0VNMl9SRUcgICAgICAgICAgICAgICAgICAgIDB4MDAwMTQyMzgKKyNkZWZpbmUgSE9TVF9TRU0zX1JFRyAgICAgICAgICAgICAgICAgICAgMHgwMDAxNDIzYworI2RlZmluZSBIT1NUX1NFTTBfSU5GT19SRUcgICAgICAgICAgICAgICAweDAwMDE0MjQwCisjZGVmaW5lIEhPU1RfU0VNMV9JTkZPX1JFRyAgICAgICAgICAgICAgIDB4MDAwMTQyNDQKKyNkZWZpbmUgSE9TVF9TRU0yX0lORk9fUkVHICAgICAgICAgICAgICAgMHgwMDAxNDI0OAorI2RlZmluZSBIT1NUX1NFTTNfSU5GT19SRUcgICAgICAgICAgICAgICAweDAwMDE0MjRjCisjZGVmaW5lIEhPU1RGTjBfTFBVMF9DTURfU1RBVCAgICAgICAgICAgIDB4MDAwMTkwMDAKKyNkZWZpbmUgX19IT1NURk4wX0xQVTBfTUJPWF9JTkZPX01LICAgICAgMHhmZmZmZmZmZQorI2RlZmluZSBfX0hPU1RGTjBfTFBVMF9NQk9YX0lORk9fU0ggICAgICAxCisjZGVmaW5lIF9fSE9TVEZOMF9MUFUwX01CT1hfSU5GTyhfdikgICAgICgoX3YpIDw8IF9fSE9TVEZOMF9MUFUwX01CT1hfSU5GT19TSCkKKyNkZWZpbmUgX19IT1NURk4wX0xQVTBfTUJPWF9DTURfU1RBVFVTICAgMHgwMDAwMDAwMQorI2RlZmluZSBMUFUwX0hPU1RGTjBfQ01EX1NUQVQgICAgICAgICAgICAweDAwMDE5MDA4CisjZGVmaW5lIF9fTFBVMF9IT1NURk4wX01CT1hfSU5GT19NSyAgICAgIDB4ZmZmZmZmZmUKKyNkZWZpbmUgX19MUFUwX0hPU1RGTjBfTUJPWF9JTkZPX1NIICAgICAgMQorI2RlZmluZSBfX0xQVTBfSE9TVEZOMF9NQk9YX0lORk8oX3YpICAgICAoKF92KSA8PCBfX0xQVTBfSE9TVEZOMF9NQk9YX0lORk9fU0gpCisjZGVmaW5lIF9fTFBVMF9IT1NURk4wX01CT1hfQ01EX1NUQVRVUyAgIDB4MDAwMDAwMDEKKyNkZWZpbmUgSE9TVEZOMV9MUFUxX0NNRF9TVEFUICAgICAgICAgICAgMHgwMDAxOTAxNAorI2RlZmluZSBfX0hPU1RGTjFfTFBVMV9NQk9YX0lORk9fTUsgICAgICAweGZmZmZmZmZlCisjZGVmaW5lIF9fSE9TVEZOMV9MUFUxX01CT1hfSU5GT19TSCAgICAgIDEKKyNkZWZpbmUgX19IT1NURk4xX0xQVTFfTUJPWF9JTkZPKF92KSAgICAgKChfdikgPDwgX19IT1NURk4xX0xQVTFfTUJPWF9JTkZPX1NIKQorI2RlZmluZSBfX0hPU1RGTjFfTFBVMV9NQk9YX0NNRF9TVEFUVVMgICAweDAwMDAwMDAxCisjZGVmaW5lIExQVTFfSE9TVEZOMV9DTURfU1RBVCAgICAgICAgICAgIDB4MDAwMTkwMWMKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjFfTUJPWF9JTkZPX01LICAgICAgMHhmZmZmZmZmZQorI2RlZmluZSBfX0xQVTFfSE9TVEZOMV9NQk9YX0lORk9fU0ggICAgICAxCisjZGVmaW5lIF9fTFBVMV9IT1NURk4xX01CT1hfSU5GTyhfdikgICAgICgoX3YpIDw8IF9fTFBVMV9IT1NURk4xX01CT1hfSU5GT19TSCkKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjFfTUJPWF9DTURfU1RBVFVTICAgMHgwMDAwMDAwMQorI2RlZmluZSBDUEVfUTBfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMDE0CisjZGVmaW5lIENQRV9RMF9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwMWMKKyNkZWZpbmUgQ1BFX1EwX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDAyMAorI2RlZmluZSBDUEVfUTFfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMDM0CisjZGVmaW5lIENQRV9RMV9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwM2MKKyNkZWZpbmUgQ1BFX1ExX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDA0MAorI2RlZmluZSBDUEVfUTJfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMDU0CisjZGVmaW5lIENQRV9RMl9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwNWMKKyNkZWZpbmUgQ1BFX1EyX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDA2MAorI2RlZmluZSBDUEVfUTNfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMDc0CisjZGVmaW5lIENQRV9RM19QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwN2MKKyNkZWZpbmUgQ1BFX1EzX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDA4MAorI2RlZmluZSBDUEVfUTRfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMDk0CisjZGVmaW5lIENQRV9RNF9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwOWMKKyNkZWZpbmUgQ1BFX1E0X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDBhMAorI2RlZmluZSBDUEVfUTVfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMGI0CisjZGVmaW5lIENQRV9RNV9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwYmMKKyNkZWZpbmUgQ1BFX1E1X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDBjMAorI2RlZmluZSBDUEVfUTZfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMGQ0CisjZGVmaW5lIENQRV9RNl9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwZGMKKyNkZWZpbmUgQ1BFX1E2X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDBlMAorI2RlZmluZSBDUEVfUTdfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDEwMGY0CisjZGVmaW5lIENQRV9RN19QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTAwZmMKKyNkZWZpbmUgQ1BFX1E3X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMDEwMAorI2RlZmluZSBSTUVfUTBfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMDE0CisjZGVmaW5lIFJNRV9RMF9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwMWMKKyNkZWZpbmUgUk1FX1EwX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTAyMAorI2RlZmluZSBSTUVfUTFfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMDM0CisjZGVmaW5lIFJNRV9RMV9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwM2MKKyNkZWZpbmUgUk1FX1ExX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTA0MAorI2RlZmluZSBSTUVfUTJfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMDU0CisjZGVmaW5lIFJNRV9RMl9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwNWMKKyNkZWZpbmUgUk1FX1EyX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTA2MAorI2RlZmluZSBSTUVfUTNfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMDc0CisjZGVmaW5lIFJNRV9RM19QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwN2MKKyNkZWZpbmUgUk1FX1EzX0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTA4MAorI2RlZmluZSBSTUVfUTRfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMDk0CisjZGVmaW5lIFJNRV9RNF9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwOWMKKyNkZWZpbmUgUk1FX1E0X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTBhMAorI2RlZmluZSBSTUVfUTVfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMGI0CisjZGVmaW5lIFJNRV9RNV9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwYmMKKyNkZWZpbmUgUk1FX1E1X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTBjMAorI2RlZmluZSBSTUVfUTZfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMGQ0CisjZGVmaW5lIFJNRV9RNl9QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwZGMKKyNkZWZpbmUgUk1FX1E2X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTBlMAorI2RlZmluZSBSTUVfUTdfREVQVEggICAgICAgICAgICAgICAgICAgICAweDAwMDExMGY0CisjZGVmaW5lIFJNRV9RN19QSSAgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTEwZmMKKyNkZWZpbmUgUk1FX1E3X0NJICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxMTEwMAorI2RlZmluZSBQU1NfQ1RMX1JFRyAgICAgICAgICAgICAgICAgICAgICAweDAwMDE4ODAwCisjZGVmaW5lIF9fUFNTX0kyQ19DTEtfRElWX01LICAgICAgICAgICAgIDB4MDAwMzAwMDAKKyNkZWZpbmUgX19QU1NfSTJDX0NMS19ESVZfU0ggICAgICAgICAgICAgMTYKKyNkZWZpbmUgX19QU1NfSTJDX0NMS19ESVYoX3YpICAgICAgICAgICAgKChfdikgPDwgX19QU1NfSTJDX0NMS19ESVZfU0gpCisjZGVmaW5lIF9fUFNTX0xNRU1fSU5JVF9ET05FICAgICAgICAgICAgIDB4MDAwMDEwMDAKKyNkZWZpbmUgX19QU1NfTE1FTV9SRVNFVCAgICAgICAgICAgICAgICAgMHgwMDAwMDIwMAorI2RlZmluZSBfX1BTU19MTUVNX0lOSVRfRU4gICAgICAgICAgICAgICAweDAwMDAwMTAwCisjZGVmaW5lIF9fUFNTX0xQVTFfUkVTRVQgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgX19QU1NfTFBVMF9SRVNFVCAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMQorCisKKy8qCisgKiBUaGVzZSBkZWZpbml0aW9ucyBhcmUgZWl0aGVyIGluIGVycm9yL21pc3NpbmcgaW4gc3BlYy4gSXRzIGF1dG8tZ2VuZXJhdGVkCisgKiBmcm9tIGhhcmQgY29kZWQgdmFsdWVzIGluIHJlZ3BhcnNlLnBsLgorICovCisjZGVmaW5lIF9fRU1QSFBPU1RfQVRfNEdfTUtfRklYICAgICAgICAgIDB4MDAwMDAwMWMKKyNkZWZpbmUgX19FTVBIUE9TVF9BVF80R19TSF9GSVggICAgICAgICAgMHgwMDAwMDAwMgorI2RlZmluZSBfX0VNUEhQUkVfQVRfNEdfRklYICAgICAgICAgICAgICAweDAwMDAwMDAzCisjZGVmaW5lIF9fU0ZQX1RYUkFURV9FTl9GSVggICAgICAgICAgICAgIDB4MDAwMDAxMDAKKyNkZWZpbmUgX19TRlBfUlhSQVRFX0VOX0ZJWCAgICAgICAgICAgICAgMHgwMDAwMDA4MAorCisKKy8qCisgKiBUaGVzZSByZWdpc3RlciBkZWZpbml0aW9ucyBhcmUgYXV0by1nZW5lcmF0ZWQgZnJvbSBoYXJkIGNvZGVkIHZhbHVlcworICogaW4gcmVncGFyc2UucGwuCisgKi8KKyNkZWZpbmUgSE9TVEZOMF9MUFVfTUJPWDBfMCAgICAgICAgICAgICAgMHgwMDAxOTIwMAorI2RlZmluZSBIT1NURk4xX0xQVV9NQk9YMF84ICAgICAgICAgICAgICAweDAwMDE5MjYwCisjZGVmaW5lIExQVV9IT1NURk4wX01CT1gwXzAgICAgICAgICAgICAgIDB4MDAwMTkyODAKKyNkZWZpbmUgTFBVX0hPU1RGTjFfTUJPWDBfOCAgICAgICAgICAgICAgMHgwMDAxOTJlMAorCisKKy8qCisgKiBUaGVzZSByZWdpc3RlciBtYXBwaW5nIGRlZmluaXRpb25zIGFyZSBhdXRvLWdlbmVyYXRlZCBmcm9tIG1hcHBpbmcgdGFibGVzCisgKiBpbiByZWdwYXJzZS5wbC4KKyAqLworI2RlZmluZSBCRkFfSU9DMF9IQkVBVF9SRUcgICAgICAgICAgICAgICBIT1NUX1NFTTBfSU5GT19SRUcKKyNkZWZpbmUgQkZBX0lPQzBfU1RBVEVfUkVHICAgICAgICAgICAgICAgSE9TVF9TRU0xX0lORk9fUkVHCisjZGVmaW5lIEJGQV9JT0MxX0hCRUFUX1JFRyAgICAgICAgICAgICAgIEhPU1RfU0VNMl9JTkZPX1JFRworI2RlZmluZSBCRkFfSU9DMV9TVEFURV9SRUcgICAgICAgICAgICAgICBIT1NUX1NFTTNfSU5GT19SRUcKKyNkZWZpbmUgQkZBX0ZXX1VTRV9DT1VOVCAgICAgICAgICAgICAgICAgSE9TVF9TRU00X0lORk9fUkVHCisKKyNkZWZpbmUgQ1BFX1FfREVQVEgoX19uKSBcCisJKENQRV9RMF9ERVBUSCArIChfX24pICogKENQRV9RMV9ERVBUSCAtIENQRV9RMF9ERVBUSCkpCisjZGVmaW5lIENQRV9RX1BJKF9fbikgXAorCShDUEVfUTBfUEkgKyAoX19uKSAqIChDUEVfUTFfUEkgLSBDUEVfUTBfUEkpKQorI2RlZmluZSBDUEVfUV9DSShfX24pIFwKKwkoQ1BFX1EwX0NJICsgKF9fbikgKiAoQ1BFX1ExX0NJIC0gQ1BFX1EwX0NJKSkKKyNkZWZpbmUgUk1FX1FfREVQVEgoX19uKSBcCisJKFJNRV9RMF9ERVBUSCArIChfX24pICogKFJNRV9RMV9ERVBUSCAtIFJNRV9RMF9ERVBUSCkpCisjZGVmaW5lIFJNRV9RX1BJKF9fbikgXAorCShSTUVfUTBfUEkgKyAoX19uKSAqIChSTUVfUTFfUEkgLSBSTUVfUTBfUEkpKQorI2RlZmluZSBSTUVfUV9DSShfX24pIFwKKwkoUk1FX1EwX0NJICsgKF9fbikgKiAoUk1FX1ExX0NJIC0gUk1FX1EwX0NJKSkKKworI2RlZmluZSBDUEVfUV9OVU0oX19mbiwgX19xKSAgKCgoX19mbikgPDwgMikgKyAoX19xKSkKKyNkZWZpbmUgUk1FX1FfTlVNKF9fZm4sIF9fcSkgICgoKF9fZm4pIDw8IDIpICsgKF9fcSkpCisjZGVmaW5lIENQRV9RX01BU0soX19xKSAgKChfX3EpICYgMHgzKQorI2RlZmluZSBSTUVfUV9NQVNLKF9fcSkgICgoX19xKSAmIDB4MykKKworCisvKgorICogUENJIE1TSS1YIHZlY3RvciBkZWZpbmVzCisgKi8KK2VudW0geworICAgIEJGQV9NU0lYX0NQRV9RMCA9IDAsCisgICAgQkZBX01TSVhfQ1BFX1ExID0gMSwKKyAgICBCRkFfTVNJWF9DUEVfUTIgPSAyLAorICAgIEJGQV9NU0lYX0NQRV9RMyA9IDMsCisgICAgQkZBX01TSVhfQ1BFX1E0ID0gNCwKKyAgICBCRkFfTVNJWF9DUEVfUTUgPSA1LAorICAgIEJGQV9NU0lYX0NQRV9RNiA9IDYsCisgICAgQkZBX01TSVhfQ1BFX1E3ID0gNywKKyAgICBCRkFfTVNJWF9STUVfUTAgPSA4LAorICAgIEJGQV9NU0lYX1JNRV9RMSA9IDksCisgICAgQkZBX01TSVhfUk1FX1EyID0gMTAsCisgICAgQkZBX01TSVhfUk1FX1EzID0gMTEsCisgICAgQkZBX01TSVhfUk1FX1E0ID0gMTIsCisgICAgQkZBX01TSVhfUk1FX1E1ID0gMTMsCisgICAgQkZBX01TSVhfUk1FX1E2ID0gMTQsCisgICAgQkZBX01TSVhfUk1FX1E3ID0gMTUsCisgICAgQkZBX01TSVhfRVJSX0VNQyA9IDE2LAorICAgIEJGQV9NU0lYX0VSUl9MUFUwID0gMTcsCisgICAgQkZBX01TSVhfRVJSX0xQVTEgPSAxOCwKKyAgICBCRkFfTVNJWF9FUlJfUFNTID0gMTksCisgICAgQkZBX01TSVhfTUJPWF9MUFUwID0gMjAsCisgICAgQkZBX01TSVhfTUJPWF9MUFUxID0gMjEsCisgICAgQkZBX01TSVhfQ0JfTUFYID0gMjIsCit9OworCisvKgorICogQW5kIGNvcnJlc3BvbmRpbmcgaG9zdCBpbnRlcnJ1cHQgc3RhdHVzIGJpdCBmaWVsZCBkZWZpbmVzCisgKi8KKyNkZWZpbmUgX19IRk5fSU5UX0NQRV9RMCAgICAgICAgICAgICAgICAgICAweDAwMDAwMDAxVQorI2RlZmluZSBfX0hGTl9JTlRfQ1BFX1ExICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDJVCisjZGVmaW5lIF9fSEZOX0lOVF9DUEVfUTIgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwNFUKKyNkZWZpbmUgX19IRk5fSU5UX0NQRV9RMyAgICAgICAgICAgICAgICAgICAweDAwMDAwMDA4VQorI2RlZmluZSBfX0hGTl9JTlRfQ1BFX1E0ICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMTBVCisjZGVmaW5lIF9fSEZOX0lOVF9DUEVfUTUgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAyMFUKKyNkZWZpbmUgX19IRk5fSU5UX0NQRV9RNiAgICAgICAgICAgICAgICAgICAweDAwMDAwMDQwVQorI2RlZmluZSBfX0hGTl9JTlRfQ1BFX1E3ICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwODBVCisjZGVmaW5lIF9fSEZOX0lOVF9STUVfUTAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDEwMFUKKyNkZWZpbmUgX19IRk5fSU5UX1JNRV9RMSAgICAgICAgICAgICAgICAgICAweDAwMDAwMjAwVQorI2RlZmluZSBfX0hGTl9JTlRfUk1FX1EyICAgICAgICAgICAgICAgICAgIDB4MDAwMDA0MDBVCisjZGVmaW5lIF9fSEZOX0lOVF9STUVfUTMgICAgICAgICAgICAgICAgICAgMHgwMDAwMDgwMFUKKyNkZWZpbmUgX19IRk5fSU5UX1JNRV9RNCAgICAgICAgICAgICAgICAgICAweDAwMDAxMDAwVQorI2RlZmluZSBfX0hGTl9JTlRfUk1FX1E1ICAgICAgICAgICAgICAgICAgIDB4MDAwMDIwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9STUVfUTYgICAgICAgICAgICAgICAgICAgMHgwMDAwNDAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX1JNRV9RNyAgICAgICAgICAgICAgICAgICAweDAwMDA4MDAwVQorI2RlZmluZSBfX0hGTl9JTlRfRVJSX0VNQyAgICAgICAgICAgICAgICAgIDB4MDAwMTAwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9FUlJfTFBVMCAgICAgICAgICAgICAgICAgMHgwMDAyMDAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX0VSUl9MUFUxICAgICAgICAgICAgICAgICAweDAwMDQwMDAwVQorI2RlZmluZSBfX0hGTl9JTlRfRVJSX1BTUyAgICAgICAgICAgICAgICAgIDB4MDAwODAwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9NQk9YX0xQVTAgICAgICAgICAgICAgICAgMHgwMDEwMDAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX01CT1hfTFBVMSAgICAgICAgICAgICAgICAweDAwMjAwMDAwVQorI2RlZmluZSBfX0hGTl9JTlRfTUJPWDFfTFBVMCAgICAgICAgICAgICAgIDB4MDA0MDAwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9NQk9YMV9MUFUxICAgICAgICAgICAgICAgMHgwMDgwMDAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX0NQRV9NQVNLICAgICAgICAgICAgICAgICAweDAwMDAwMGZmVQorI2RlZmluZSBfX0hGTl9JTlRfUk1FX01BU0sgICAgICAgICAgICAgICAgIDB4MDAwMGZmMDBVCisKKworLyoKKyAqIGNyb3NzYm93IG1lbW9yeSBtYXAuCisgKi8KKyNkZWZpbmUgUFNTX1NNRU1fUEFHRV9TVEFSVAkweDgwMDAKKyNkZWZpbmUgUFNTX1NNRU1fUEdOVU0oX3BnMCwgX21hKQkoKF9wZzApICsgKChfbWEpID4+IDE1KSkKKyNkZWZpbmUgUFNTX1NNRU1fUEdPRkYoX21hKQkoKF9tYSkgJiAweDdmZmYpCisKKy8qCisgKiBFbmQgb2YgY3Jvc3Nib3cgbWVtb3J5IG1hcAorICovCisKKworI2VuZGlmIC8qIF9fQkZJX0NCUkVHX0hfXyAqLworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9jZWUuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2NlZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjA5NzA1OTY1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfY2VlLmgKQEAgLTAsMCArMSwxMTkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKy8qKgorICogIENvcHlyaWdodCAoYykgMjAwNi0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogIGJmaV9kY2J4LmggQkZJIEludGVyZmFjZSAoTWFpbGJveCBjb21tYW5kcyBhbmQgcmVsYXRlZCBzdHJ1Y3R1cmVzKQorICogYmV0d2VlbiBob3N0IGRyaXZlciBhbmQgRENCWC9MTERQIGZpcm13YXJlIG1vZHVsZS4KKyAqCisqKi8KKworI2lmbmRlZiBfX0JGSV9DRUVfSF9fCisjZGVmaW5lIF9fQkZJX0NFRV9IX18KKworI2luY2x1ZGUgPGJmaS9iZmkuaD4KKworI3ByYWdtYSBwYWNrKDEpCisKKworZW51bSBiZmlfY2VlX2gyaV9tc2dzX2UgeworCUJGSV9DRUVfSDJJX0dFVF9DRkdfUkVRID0gMSwKKwlCRklfQ0VFX0gySV9SRVNFVF9TVEFUUyA9IDIsCisJQkZJX0NFRV9IMklfR0VUX1NUQVRTX1JFUSA9IDMsCit9OworCisKK2VudW0gYmZpX2NlZV9pMmhfbXNnc19lIHsKKwlCRklfQ0VFX0kySF9HRVRfQ0ZHX1JTUCA9IEJGQV9JMkhNKDEpLAorCUJGSV9DRUVfSTJIX1JFU0VUX1NUQVRTX1JTUCA9IEJGQV9JMkhNKDIpLAorCUJGSV9DRUVfSTJIX0dFVF9TVEFUU19SU1AgPSBCRkFfSTJITSgzKSwKK307CisKKworLyogRGF0YSBzdHJ1Y3R1cmVzICovCisKKy8qCisgKiBCRklfQ0VFX0gySV9SRVNFVF9TVEFUUworICovCitzdHJ1Y3QgYmZpX2xsZHBfcmVzZXRfc3RhdHNfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOworfTsKKworLyoKKyAqIEJGSV9DRUVfSDJJX1JFU0VUX1NUQVRTCisgKi8KK3N0cnVjdCBiZmlfY2VlX3Jlc2V0X3N0YXRzX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsKK307CisKKy8qCisgKiBCRklfQ0VFX0gySV9HRVRfQ0ZHX1JFUQorICovCitzdHJ1Y3QgYmZpX2NlZV9nZXRfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsKKwl1bmlvbiBiZmlfYWRkcl91ICAgZG1hX2FkZHI7Cit9OworCisKKy8qCisgKiBCRklfQ0VFX0kySF9HRVRfQ0ZHX1JTUAorICovCitzdHJ1Y3QgYmZpX2NlZV9nZXRfcnNwX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsKKwl1OCAgICAgICAgICAgIGNtZF9zdGF0dXM7CisJdTggICAgICAgICAgICByc3ZkWzNdOworfTsKKworLyoKKyAqIEJGSV9DRUVfSDJJX0dFVF9TVEFUU19SRVEKKyAqLworc3RydWN0IGJmaV9jZWVfc3RhdHNfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsKKwl1bmlvbiBiZmlfYWRkcl91ICAgZG1hX2FkZHI7Cit9OworCisKKy8qCisgKiBCRklfQ0VFX0kySF9HRVRfU1RBVFNfUlNQCisgKi8KK3N0cnVjdCBiZmlfY2VlX3N0YXRzX3JzcF9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CisJdTggCQkgICBjbWRfc3RhdHVzOworCXU4IAkJICAgcnN2ZFszXTsKK307CisKKworCit1bmlvbiBiZmlfY2VlX2gyaV9tc2dfdSB7CisJc3RydWN0IGJmaV9taGRyX3MgICAgICAgICAgIG1oOworCXN0cnVjdCBiZmlfY2VlX2dldF9yZXFfcyAgIGdldF9yZXE7CisJc3RydWN0IGJmaV9jZWVfc3RhdHNfcmVxX3Mgc3RhdHNfcmVxOworfTsKKworCit1bmlvbiBiZmlfY2VlX2kyaF9tc2dfdSB7CisJc3RydWN0IGJmaV9taGRyX3MgICAgICAgICBtaDsKKwlzdHJ1Y3QgYmZpX2NlZV9nZXRfcnNwX3MgIGdldF9yc3A7CisJc3RydWN0IGJmaV9jZWVfc3RhdHNfcnNwX3Mgc3RhdHNfcnNwOworfTsKKworI3ByYWdtYSBwYWNrKCkKKworCisjZW5kaWYgLyogX19CRklfQ0VFX0hfXyAqLworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9jdHJlZy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfY3RyZWcuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kM2NhYTU4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfY3RyZWcuaApAQCAtMCwwICsxLDYxMSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKgorICogYmZpX2N0cmVnLmggY2F0YXB1bHQgaG9zdCBibG9jayByZWdpc3RlciBkZWZpbml0aW9ucworICoKKyAqICEhISBEbyBub3QgZWRpdC4gQXV0byBnZW5lcmF0ZWQuICEhIQorICovCisKKyNpZm5kZWYgX19CRklfQ1RSRUdfSF9fCisjZGVmaW5lIF9fQkZJX0NUUkVHX0hfXworCisKKyNkZWZpbmUgSE9TVEZOMF9MUFVfTUJPWDBfMCAgICAgICAgICAgICAgMHgwMDAxOTIwMAorI2RlZmluZSBIT1NURk4xX0xQVV9NQk9YMF84ICAgICAgICAgICAgICAweDAwMDE5MjYwCisjZGVmaW5lIExQVV9IT1NURk4wX01CT1gwXzAgICAgICAgICAgICAgIDB4MDAwMTkyODAKKyNkZWZpbmUgTFBVX0hPU1RGTjFfTUJPWDBfOCAgICAgICAgICAgICAgMHgwMDAxOTJlMAorI2RlZmluZSBIT1NURk4yX0xQVV9NQk9YMF8wICAgICAgICAgICAgICAweDAwMDE5NDAwCisjZGVmaW5lIEhPU1RGTjNfTFBVX01CT1gwXzggICAgICAgICAgICAgIDB4MDAwMTk0NjAKKyNkZWZpbmUgTFBVX0hPU1RGTjJfTUJPWDBfMCAgICAgICAgICAgICAgMHgwMDAxOTQ4MAorI2RlZmluZSBMUFVfSE9TVEZOM19NQk9YMF84ICAgICAgICAgICAgICAweDAwMDE5NGUwCisjZGVmaW5lIEhPU1RGTjBfSU5UX1NUQVRVUyAgICAgICAgICAgICAgIDB4MDAwMTQwMDAKKyNkZWZpbmUgX19IT1NURk4wX0hBTFRfT0NDVVJSRUQgICAgICAgICAgMHgwMTAwMDAwMAorI2RlZmluZSBfX0hPU1RGTjBfSU5UX1NUQVRVU19MVkxfTUsgICAgICAweDAwZjAwMDAwCisjZGVmaW5lIF9fSE9TVEZOMF9JTlRfU1RBVFVTX0xWTF9TSCAgICAgIDIwCisjZGVmaW5lIF9fSE9TVEZOMF9JTlRfU1RBVFVTX0xWTChfdikgICAgICgoX3YpIDw8IF9fSE9TVEZOMF9JTlRfU1RBVFVTX0xWTF9TSCkKKyNkZWZpbmUgX19IT1NURk4wX0lOVF9TVEFUVVNfUF9NSyAgICAgICAgMHgwMDBmMDAwMAorI2RlZmluZSBfX0hPU1RGTjBfSU5UX1NUQVRVU19QX1NIICAgICAgICAxNgorI2RlZmluZSBfX0hPU1RGTjBfSU5UX1NUQVRVU19QKF92KSAgICAgICAoKF92KSA8PCBfX0hPU1RGTjBfSU5UX1NUQVRVU19QX1NIKQorI2RlZmluZSBfX0hPU1RGTjBfSU5UX1NUQVRVU19GICAgICAgICAgICAweDAwMDBmZmZmCisjZGVmaW5lIEhPU1RGTjBfSU5UX01TSyAgICAgICAgICAgICAgICAgIDB4MDAwMTQwMDQKKyNkZWZpbmUgSE9TVF9QQUdFX05VTV9GTjAgICAgICAgICAgICAgICAgMHgwMDAxNDAwOAorI2RlZmluZSBfX0hPU1RfUEFHRV9OVU1fRk4gICAgICAgICAgICAgICAweDAwMDAwMWZmCisjZGVmaW5lIEhPU1RfTVNJWF9FUlJfSU5ERVhfRk4wICAgICAgICAgIDB4MDAwMTQwMGMKKyNkZWZpbmUgX19NU0lYX0VSUl9JTkRFWF9GTiAgICAgICAgICAgICAgMHgwMDAwMDFmZgorI2RlZmluZSBIT1NURk4xX0lOVF9TVEFUVVMgICAgICAgICAgICAgICAweDAwMDE0MTAwCisjZGVmaW5lIF9fSE9TVEZOMV9IQUxUX09DQ1VSUkVEICAgICAgICAgIDB4MDEwMDAwMDAKKyNkZWZpbmUgX19IT1NURk4xX0lOVF9TVEFUVVNfTFZMX01LICAgICAgMHgwMGYwMDAwMAorI2RlZmluZSBfX0hPU1RGTjFfSU5UX1NUQVRVU19MVkxfU0ggICAgICAyMAorI2RlZmluZSBfX0hPU1RGTjFfSU5UX1NUQVRVU19MVkwoX3YpICAgICAoKF92KSA8PCBfX0hPU1RGTjFfSU5UX1NUQVRVU19MVkxfU0gpCisjZGVmaW5lIF9fSE9TVEZOMV9JTlRfU1RBVFVTX1BfTUsgICAgICAgIDB4MDAwZjAwMDAKKyNkZWZpbmUgX19IT1NURk4xX0lOVF9TVEFUVVNfUF9TSCAgICAgICAgMTYKKyNkZWZpbmUgX19IT1NURk4xX0lOVF9TVEFUVVNfUChfdikgICAgICAgKChfdikgPDwgX19IT1NURk4xX0lOVF9TVEFUVVNfUF9TSCkKKyNkZWZpbmUgX19IT1NURk4xX0lOVF9TVEFUVVNfRiAgICAgICAgICAgMHgwMDAwZmZmZgorI2RlZmluZSBIT1NURk4xX0lOVF9NU0sgICAgICAgICAgICAgICAgICAweDAwMDE0MTA0CisjZGVmaW5lIEhPU1RfUEFHRV9OVU1fRk4xICAgICAgICAgICAgICAgIDB4MDAwMTQxMDgKKyNkZWZpbmUgSE9TVF9NU0lYX0VSUl9JTkRFWF9GTjEgICAgICAgICAgMHgwMDAxNDEwYworI2RlZmluZSBBUFBfUExMXzQyNV9DVExfUkVHICAgICAgICAgICAgICAweDAwMDE0MjA0CisjZGVmaW5lIF9fUF80MjVfUExMX0xPQ0sgICAgICAgICAgICAgICAgIDB4ODAwMDAwMDAKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9TUkFNX1VTRV8xMDBNSFogICAgMHgwMDEwMDAwMAorI2RlZmluZSBfX0FQUF9QTExfNDI1X1JFU0VUX1RJTUVSX01LICAgICAweDAwMGUwMDAwCisjZGVmaW5lIF9fQVBQX1BMTF80MjVfUkVTRVRfVElNRVJfU0ggICAgIDE3CisjZGVmaW5lIF9fQVBQX1BMTF80MjVfUkVTRVRfVElNRVIoX3YpICAgICgoX3YpIDw8IF9fQVBQX1BMTF80MjVfUkVTRVRfVElNRVJfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF80MjVfTE9HSUNfU09GVF9SRVNFVCAgIDB4MDAwMTAwMDAKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9DTlRMTVQwXzFfTUsgICAgICAgMHgwMDAwYzAwMAorI2RlZmluZSBfX0FQUF9QTExfNDI1X0NOVExNVDBfMV9TSCAgICAgICAxNAorI2RlZmluZSBfX0FQUF9QTExfNDI1X0NOVExNVDBfMShfdikgICAgICAoKF92KSA8PCBfX0FQUF9QTExfNDI1X0NOVExNVDBfMV9TSCkKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9KSVRMTVQwXzFfTUsgICAgICAgMHgwMDAwMzAwMAorI2RlZmluZSBfX0FQUF9QTExfNDI1X0pJVExNVDBfMV9TSCAgICAgICAxMgorI2RlZmluZSBfX0FQUF9QTExfNDI1X0pJVExNVDBfMShfdikgICAgICAoKF92KSA8PCBfX0FQUF9QTExfNDI1X0pJVExNVDBfMV9TSCkKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9IUkVGICAgICAgICAgICAgICAgMHgwMDAwMDgwMAorI2RlZmluZSBfX0FQUF9QTExfNDI1X0hESVYgICAgICAgICAgICAgICAweDAwMDAwNDAwCisjZGVmaW5lIF9fQVBQX1BMTF80MjVfUDBfMV9NSyAgICAgICAgICAgIDB4MDAwMDAzMDAKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9QMF8xX1NIICAgICAgICAgICAgOAorI2RlZmluZSBfX0FQUF9QTExfNDI1X1AwXzEoX3YpICAgICAgICAgICAoKF92KSA8PCBfX0FQUF9QTExfNDI1X1AwXzFfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF80MjVfWjBfMl9NSyAgICAgICAgICAgIDB4MDAwMDAwZTAKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9aMF8yX1NIICAgICAgICAgICAgNQorI2RlZmluZSBfX0FQUF9QTExfNDI1X1owXzIoX3YpICAgICAgICAgICAoKF92KSA8PCBfX0FQUF9QTExfNDI1X1owXzJfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF80MjVfUlNFTDIwMDUwMCAgICAgICAgIDB4MDAwMDAwMTAKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9FTkFSU1QgICAgICAgICAgICAgMHgwMDAwMDAwOAorI2RlZmluZSBfX0FQUF9QTExfNDI1X0JZUEFTUyAgICAgICAgICAgICAweDAwMDAwMDA0CisjZGVmaW5lIF9fQVBQX1BMTF80MjVfTFJFU0VUTiAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgX19BUFBfUExMXzQyNV9FTkFCTEUgICAgICAgICAgICAgMHgwMDAwMDAwMQorI2RlZmluZSBBUFBfUExMXzMxMl9DVExfUkVHICAgICAgICAgICAgICAweDAwMDE0MjA4CisjZGVmaW5lIF9fUF8zMTJfUExMX0xPQ0sgICAgICAgICAgICAgICAgIDB4ODAwMDAwMDAKKyNkZWZpbmUgX19FTkFCTEVfTUFDX0FIQl8xICAgICAgICAgICAgICAgMHgwMDgwMDAwMAorI2RlZmluZSBfX0VOQUJMRV9NQUNfQUhCXzAgICAgICAgICAgICAgICAweDAwNDAwMDAwCisjZGVmaW5lIF9fRU5BQkxFX01BQ18xICAgICAgICAgICAgICAgICAgIDB4MDAyMDAwMDAKKyNkZWZpbmUgX19FTkFCTEVfTUFDXzAgICAgICAgICAgICAgICAgICAgMHgwMDEwMDAwMAorI2RlZmluZSBfX0FQUF9QTExfMzEyX1JFU0VUX1RJTUVSX01LICAgICAweDAwMGUwMDAwCisjZGVmaW5lIF9fQVBQX1BMTF8zMTJfUkVTRVRfVElNRVJfU0ggICAgIDE3CisjZGVmaW5lIF9fQVBQX1BMTF8zMTJfUkVTRVRfVElNRVIoX3YpICAgICgoX3YpIDw8IF9fQVBQX1BMTF8zMTJfUkVTRVRfVElNRVJfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF8zMTJfTE9HSUNfU09GVF9SRVNFVCAgIDB4MDAwMTAwMDAKKyNkZWZpbmUgX19BUFBfUExMXzMxMl9DTlRMTVQwXzFfTUsgICAgICAgMHgwMDAwYzAwMAorI2RlZmluZSBfX0FQUF9QTExfMzEyX0NOVExNVDBfMV9TSCAgICAgICAxNAorI2RlZmluZSBfX0FQUF9QTExfMzEyX0NOVExNVDBfMShfdikgICAgICAoKF92KSA8PCBfX0FQUF9QTExfMzEyX0NOVExNVDBfMV9TSCkKKyNkZWZpbmUgX19BUFBfUExMXzMxMl9KSVRMTVQwXzFfTUsgICAgICAgMHgwMDAwMzAwMAorI2RlZmluZSBfX0FQUF9QTExfMzEyX0pJVExNVDBfMV9TSCAgICAgICAxMgorI2RlZmluZSBfX0FQUF9QTExfMzEyX0pJVExNVDBfMShfdikgICAgICAoKF92KSA8PCBfX0FQUF9QTExfMzEyX0pJVExNVDBfMV9TSCkKKyNkZWZpbmUgX19BUFBfUExMXzMxMl9IUkVGICAgICAgICAgICAgICAgMHgwMDAwMDgwMAorI2RlZmluZSBfX0FQUF9QTExfMzEyX0hESVYgICAgICAgICAgICAgICAweDAwMDAwNDAwCisjZGVmaW5lIF9fQVBQX1BMTF8zMTJfUDBfMV9NSyAgICAgICAgICAgIDB4MDAwMDAzMDAKKyNkZWZpbmUgX19BUFBfUExMXzMxMl9QMF8xX1NIICAgICAgICAgICAgOAorI2RlZmluZSBfX0FQUF9QTExfMzEyX1AwXzEoX3YpICAgICAgICAgICAoKF92KSA8PCBfX0FQUF9QTExfMzEyX1AwXzFfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF8zMTJfWjBfMl9NSyAgICAgICAgICAgIDB4MDAwMDAwZTAKKyNkZWZpbmUgX19BUFBfUExMXzMxMl9aMF8yX1NIICAgICAgICAgICAgNQorI2RlZmluZSBfX0FQUF9QTExfMzEyX1owXzIoX3YpICAgICAgICAgICAoKF92KSA8PCBfX0FQUF9QTExfMzEyX1owXzJfU0gpCisjZGVmaW5lIF9fQVBQX1BMTF8zMTJfUlNFTDIwMDUwMCAgICAgICAgIDB4MDAwMDAwMTAKKyNkZWZpbmUgX19BUFBfUExMXzMxMl9FTkFSU1QgICAgICAgICAgICAgMHgwMDAwMDAwOAorI2RlZmluZSBfX0FQUF9QTExfMzEyX0JZUEFTUyAgICAgICAgICAgICAweDAwMDAwMDA0CisjZGVmaW5lIF9fQVBQX1BMTF8zMTJfTFJFU0VUTiAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgX19BUFBfUExMXzMxMl9FTkFCTEUgICAgICAgICAgICAgMHgwMDAwMDAwMQorI2RlZmluZSBNQklTVF9DVExfUkVHICAgICAgICAgICAgICAgICAgICAweDAwMDE0MjIwCisjZGVmaW5lIF9fRURSQU1fQklTVFJfU1RBUlQgICAgICAgICAgICAgIDB4MDAwMDAwMDQKKyNkZWZpbmUgX19NQklTVF9SRVNFVCAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMgorI2RlZmluZSBfX01CSVNUX1NUQVJUICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDAxCisjZGVmaW5lIE1CSVNUX1NUQVRfUkVHICAgICAgICAgICAgICAgICAgIDB4MDAwMTQyMjQKKyNkZWZpbmUgX19FRFJBTV9CSVNUUl9TVEFUVVMgICAgICAgICAgICAgMHgwMDAwMDAwOAorI2RlZmluZSBfX0VEUkFNX0JJU1RSX0RPTkUgICAgICAgICAgICAgICAweDAwMDAwMDA0CisjZGVmaW5lIF9fTUVNX0JJVF9TVEFUVVMgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgX19NQklTVF9ET05FICAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMQorI2RlZmluZSBIT1NUX1NFTTBfUkVHICAgICAgICAgICAgICAgICAgICAweDAwMDE0MjMwCisjZGVmaW5lIF9fSE9TVF9TRU1BUEhPUkUgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDEKKyNkZWZpbmUgSE9TVF9TRU0xX1JFRyAgICAgICAgICAgICAgICAgICAgMHgwMDAxNDIzNAorI2RlZmluZSBIT1NUX1NFTTJfUkVHICAgICAgICAgICAgICAgICAgICAweDAwMDE0MjM4CisjZGVmaW5lIEhPU1RfU0VNM19SRUcgICAgICAgICAgICAgICAgICAgIDB4MDAwMTQyM2MKKyNkZWZpbmUgSE9TVF9TRU0wX0lORk9fUkVHICAgICAgICAgICAgICAgMHgwMDAxNDI0MAorI2RlZmluZSBIT1NUX1NFTTFfSU5GT19SRUcgICAgICAgICAgICAgICAweDAwMDE0MjQ0CisjZGVmaW5lIEhPU1RfU0VNMl9JTkZPX1JFRyAgICAgICAgICAgICAgIDB4MDAwMTQyNDgKKyNkZWZpbmUgSE9TVF9TRU0zX0lORk9fUkVHICAgICAgICAgICAgICAgMHgwMDAxNDI0YworI2RlZmluZSBFVEhfTUFDX1NFUl9SRUcgICAgICAgICAgICAgICAgICAweDAwMDE0Mjg4CisjZGVmaW5lIF9fQVBQX0VNU19DS0JVRkFNUElOICAgICAgICAgICAgIDB4MDAwMDAwMjAKKyNkZWZpbmUgX19BUFBfRU1TX1JFRkNMS1NFTCAgICAgICAgICAgICAgMHgwMDAwMDAxMAorI2RlZmluZSBfX0FQUF9FTVNfQ01MQ0tTRUwgICAgICAgICAgICAgICAweDAwMDAwMDA4CisjZGVmaW5lIF9fQVBQX0VNU19SRUZDS0JVRkVOMiAgICAgICAgICAgIDB4MDAwMDAwMDQKKyNkZWZpbmUgX19BUFBfRU1TX1JFRkNLQlVGRU4xICAgICAgICAgICAgMHgwMDAwMDAwMgorI2RlZmluZSBfX0FQUF9FTVNfQ0hBTk5FTF9TRUwgICAgICAgICAgICAweDAwMDAwMDAxCisjZGVmaW5lIEhPU1RGTjJfSU5UX1NUQVRVUyAgICAgICAgICAgICAgIDB4MDAwMTQzMDAKKyNkZWZpbmUgX19IT1NURk4yX0hBTFRfT0NDVVJSRUQgICAgICAgICAgMHgwMTAwMDAwMAorI2RlZmluZSBfX0hPU1RGTjJfSU5UX1NUQVRVU19MVkxfTUsgICAgICAweDAwZjAwMDAwCisjZGVmaW5lIF9fSE9TVEZOMl9JTlRfU1RBVFVTX0xWTF9TSCAgICAgIDIwCisjZGVmaW5lIF9fSE9TVEZOMl9JTlRfU1RBVFVTX0xWTChfdikgICAgICgoX3YpIDw8IF9fSE9TVEZOMl9JTlRfU1RBVFVTX0xWTF9TSCkKKyNkZWZpbmUgX19IT1NURk4yX0lOVF9TVEFUVVNfUF9NSyAgICAgICAgMHgwMDBmMDAwMAorI2RlZmluZSBfX0hPU1RGTjJfSU5UX1NUQVRVU19QX1NIICAgICAgICAxNgorI2RlZmluZSBfX0hPU1RGTjJfSU5UX1NUQVRVU19QKF92KSAgICAgICAoKF92KSA8PCBfX0hPU1RGTjJfSU5UX1NUQVRVU19QX1NIKQorI2RlZmluZSBfX0hPU1RGTjJfSU5UX1NUQVRVU19GICAgICAgICAgICAweDAwMDBmZmZmCisjZGVmaW5lIEhPU1RGTjJfSU5UX01TSyAgICAgICAgICAgICAgICAgIDB4MDAwMTQzMDQKKyNkZWZpbmUgSE9TVF9QQUdFX05VTV9GTjIgICAgICAgICAgICAgICAgMHgwMDAxNDMwOAorI2RlZmluZSBIT1NUX01TSVhfRVJSX0lOREVYX0ZOMiAgICAgICAgICAweDAwMDE0MzBjCisjZGVmaW5lIEhPU1RGTjNfSU5UX1NUQVRVUyAgICAgICAgICAgICAgIDB4MDAwMTQ0MDAKKyNkZWZpbmUgX19IQUxUX09DQ1VSUkVEICAgICAgICAgICAgICAgICAgMHgwMTAwMDAwMAorI2RlZmluZSBfX0hPU1RGTjNfSU5UX1NUQVRVU19MVkxfTUsgICAgICAweDAwZjAwMDAwCisjZGVmaW5lIF9fSE9TVEZOM19JTlRfU1RBVFVTX0xWTF9TSCAgICAgIDIwCisjZGVmaW5lIF9fSE9TVEZOM19JTlRfU1RBVFVTX0xWTChfdikgICAgICgoX3YpIDw8IF9fSE9TVEZOM19JTlRfU1RBVFVTX0xWTF9TSCkKKyNkZWZpbmUgX19IT1NURk4zX0lOVF9TVEFUVVNfUF9NSyAgICAgICAgMHgwMDBmMDAwMAorI2RlZmluZSBfX0hPU1RGTjNfSU5UX1NUQVRVU19QX1NIICAgICAgICAxNgorI2RlZmluZSBfX0hPU1RGTjNfSU5UX1NUQVRVU19QKF92KSAgICAgICAoKF92KSA8PCBfX0hPU1RGTjNfSU5UX1NUQVRVU19QX1NIKQorI2RlZmluZSBfX0hPU1RGTjNfSU5UX1NUQVRVU19GICAgICAgICAgICAweDAwMDBmZmZmCisjZGVmaW5lIEhPU1RGTjNfSU5UX01TSyAgICAgICAgICAgICAgICAgIDB4MDAwMTQ0MDQKKyNkZWZpbmUgSE9TVF9QQUdFX05VTV9GTjMgICAgICAgICAgICAgICAgMHgwMDAxNDQwOAorI2RlZmluZSBIT1NUX01TSVhfRVJSX0lOREVYX0ZOMyAgICAgICAgICAweDAwMDE0NDBjCisjZGVmaW5lIEZOQ19JRF9SRUcgICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMTQ2MDAKKyNkZWZpbmUgX19GVU5DVElPTl9OVU1CRVIgICAgICAgICAgICAgICAgMHgwMDAwMDAwNworI2RlZmluZSBGTkNfUEVSU19SRUcgICAgICAgICAgICAgICAgICAgICAweDAwMDE0NjA0CisjZGVmaW5lIF9fRjNfRlVOQ1RJT05fQUNUSVZFICAgICAgICAgICAgIDB4ODAwMDAwMDAKKyNkZWZpbmUgX19GM19GVU5DVElPTl9NT0RFICAgICAgICAgICAgICAgMHg0MDAwMDAwMAorI2RlZmluZSBfX0YzX1BPUlRfTUFQX01LICAgICAgICAgICAgICAgICAweDMwMDAwMDAwCisjZGVmaW5lIF9fRjNfUE9SVF9NQVBfU0ggICAgICAgICAgICAgICAgIDI4CisjZGVmaW5lIF9fRjNfUE9SVF9NQVAoX3YpICAgICAgICAgICAgICAgICgoX3YpIDw8IF9fRjNfUE9SVF9NQVBfU0gpCisjZGVmaW5lIF9fRjNfVk1fTU9ERSAgICAgICAgICAgICAgICAgICAgIDB4MDgwMDAwMDAKKyNkZWZpbmUgX19GM19JTlRYX1NUQVRVU19NSyAgICAgICAgICAgICAgMHgwNzAwMDAwMAorI2RlZmluZSBfX0YzX0lOVFhfU1RBVFVTX1NIICAgICAgICAgICAgICAyNAorI2RlZmluZSBfX0YzX0lOVFhfU1RBVFVTKF92KSAgICAgICAgICAgICAoKF92KSA8PCBfX0YzX0lOVFhfU1RBVFVTX1NIKQorI2RlZmluZSBfX0YyX0ZVTkNUSU9OX0FDVElWRSAgICAgICAgICAgICAweDAwODAwMDAwCisjZGVmaW5lIF9fRjJfRlVOQ1RJT05fTU9ERSAgICAgICAgICAgICAgIDB4MDA0MDAwMDAKKyNkZWZpbmUgX19GMl9QT1JUX01BUF9NSyAgICAgICAgICAgICAgICAgMHgwMDMwMDAwMAorI2RlZmluZSBfX0YyX1BPUlRfTUFQX1NIICAgICAgICAgICAgICAgICAyMAorI2RlZmluZSBfX0YyX1BPUlRfTUFQKF92KSAgICAgICAgICAgICAgICAoKF92KSA8PCBfX0YyX1BPUlRfTUFQX1NIKQorI2RlZmluZSBfX0YyX1ZNX01PREUgICAgICAgICAgICAgICAgICAgICAweDAwMDgwMDAwCisjZGVmaW5lIF9fRjJfSU5UWF9TVEFUVVNfTUsgICAgICAgICAgICAgIDB4MDAwNzAwMDAKKyNkZWZpbmUgX19GMl9JTlRYX1NUQVRVU19TSCAgICAgICAgICAgICAgMTYKKyNkZWZpbmUgX19GMl9JTlRYX1NUQVRVUyhfdikgICAgICAgICAgICAgKChfdikgPDwgX19GMl9JTlRYX1NUQVRVU19TSCkKKyNkZWZpbmUgX19GMV9GVU5DVElPTl9BQ1RJVkUgICAgICAgICAgICAgMHgwMDAwODAwMAorI2RlZmluZSBfX0YxX0ZVTkNUSU9OX01PREUgICAgICAgICAgICAgICAweDAwMDA0MDAwCisjZGVmaW5lIF9fRjFfUE9SVF9NQVBfTUsgICAgICAgICAgICAgICAgIDB4MDAwMDMwMDAKKyNkZWZpbmUgX19GMV9QT1JUX01BUF9TSCAgICAgICAgICAgICAgICAgMTIKKyNkZWZpbmUgX19GMV9QT1JUX01BUChfdikgICAgICAgICAgICAgICAgKChfdikgPDwgX19GMV9QT1JUX01BUF9TSCkKKyNkZWZpbmUgX19GMV9WTV9NT0RFICAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDgwMAorI2RlZmluZSBfX0YxX0lOVFhfU1RBVFVTX01LICAgICAgICAgICAgICAweDAwMDAwNzAwCisjZGVmaW5lIF9fRjFfSU5UWF9TVEFUVVNfU0ggICAgICAgICAgICAgIDgKKyNkZWZpbmUgX19GMV9JTlRYX1NUQVRVUyhfdikgICAgICAgICAgICAgKChfdikgPDwgX19GMV9JTlRYX1NUQVRVU19TSCkKKyNkZWZpbmUgX19GMF9GVU5DVElPTl9BQ1RJVkUgICAgICAgICAgICAgMHgwMDAwMDA4MAorI2RlZmluZSBfX0YwX0ZVTkNUSU9OX01PREUgICAgICAgICAgICAgICAweDAwMDAwMDQwCisjZGVmaW5lIF9fRjBfUE9SVF9NQVBfTUsgICAgICAgICAgICAgICAgIDB4MDAwMDAwMzAKKyNkZWZpbmUgX19GMF9QT1JUX01BUF9TSCAgICAgICAgICAgICAgICAgNAorI2RlZmluZSBfX0YwX1BPUlRfTUFQKF92KSAgICAgICAgICAgICAgICAoKF92KSA8PCBfX0YwX1BPUlRfTUFQX1NIKQorI2RlZmluZSBfX0YwX1ZNX01PREUgICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDA4CisjZGVmaW5lIF9fRjBfSU5UWF9TVEFUVVMgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDcKK2VudW0geworICAgIF9fRjBfSU5UWF9TVEFUVVNfTVNJWCAgICAgICAgICAgID0gMHgwLAorICAgIF9fRjBfSU5UWF9TVEFUVVNfSU5UQSAgICAgICAgICAgID0gMHgxLAorICAgIF9fRjBfSU5UWF9TVEFUVVNfSU5UQiAgICAgICAgICAgID0gMHgyLAorICAgIF9fRjBfSU5UWF9TVEFUVVNfSU5UQyAgICAgICAgICAgID0gMHgzLAorICAgIF9fRjBfSU5UWF9TVEFUVVNfSU5URCAgICAgICAgICAgID0gMHg0LAorfTsKKyNkZWZpbmUgT1BfTU9ERSAgICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxNDYwYworI2RlZmluZSBfX0FQUF9FVEhfQ0xLX0xPV1NQRUVEICAgICAgICAgICAweDAwMDAwMDA0CisjZGVmaW5lIF9fR0xPQkFMX0NPUkVDTEtfSEFMRlNQRUVEICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgX19HTE9CQUxfRkNPRV9NT0RFICAgICAgICAgICAgICAgMHgwMDAwMDAwMQorI2RlZmluZSBIT1NUX1NFTTRfUkVHICAgICAgICAgICAgICAgICAgICAweDAwMDE0NjEwCisjZGVmaW5lIEhPU1RfU0VNNV9SRUcgICAgICAgICAgICAgICAgICAgIDB4MDAwMTQ2MTQKKyNkZWZpbmUgSE9TVF9TRU02X1JFRyAgICAgICAgICAgICAgICAgICAgMHgwMDAxNDYxOAorI2RlZmluZSBIT1NUX1NFTTdfUkVHICAgICAgICAgICAgICAgICAgICAweDAwMDE0NjFjCisjZGVmaW5lIEhPU1RfU0VNNF9JTkZPX1JFRyAgICAgICAgICAgICAgIDB4MDAwMTQ2MjAKKyNkZWZpbmUgSE9TVF9TRU01X0lORk9fUkVHICAgICAgICAgICAgICAgMHgwMDAxNDYyNAorI2RlZmluZSBIT1NUX1NFTTZfSU5GT19SRUcgICAgICAgICAgICAgICAweDAwMDE0NjI4CisjZGVmaW5lIEhPU1RfU0VNN19JTkZPX1JFRyAgICAgICAgICAgICAgIDB4MDAwMTQ2MmMKKyNkZWZpbmUgSE9TVEZOMF9MUFUwX01CT1gwX0NNRF9TVEFUICAgICAgMHgwMDAxOTAwMAorI2RlZmluZSBfX0hPU1RGTjBfTFBVMF9NQk9YMF9JTkZPX01LICAgICAweGZmZmZmZmZlCisjZGVmaW5lIF9fSE9TVEZOMF9MUFUwX01CT1gwX0lORk9fU0ggICAgIDEKKyNkZWZpbmUgX19IT1NURk4wX0xQVTBfTUJPWDBfSU5GTyhfdikgICAgKChfdikgPDwgX19IT1NURk4wX0xQVTBfTUJPWDBfSU5GT19TSCkKKyNkZWZpbmUgX19IT1NURk4wX0xQVTBfTUJPWDBfQ01EX1NUQVRVUyAgMHgwMDAwMDAwMQorI2RlZmluZSBIT1NURk4wX0xQVTFfTUJPWDBfQ01EX1NUQVQgICAgICAweDAwMDE5MDA0CisjZGVmaW5lIF9fSE9TVEZOMF9MUFUxX01CT1gwX0lORk9fTUsgICAgIDB4ZmZmZmZmZmUKKyNkZWZpbmUgX19IT1NURk4wX0xQVTFfTUJPWDBfSU5GT19TSCAgICAgMQorI2RlZmluZSBfX0hPU1RGTjBfTFBVMV9NQk9YMF9JTkZPKF92KSAgICAoKF92KSA8PCBfX0hPU1RGTjBfTFBVMV9NQk9YMF9JTkZPX1NIKQorI2RlZmluZSBfX0hPU1RGTjBfTFBVMV9NQk9YMF9DTURfU1RBVFVTICAweDAwMDAwMDAxCisjZGVmaW5lIExQVTBfSE9TVEZOMF9NQk9YMF9DTURfU1RBVCAgICAgIDB4MDAwMTkwMDgKKyNkZWZpbmUgX19MUFUwX0hPU1RGTjBfTUJPWDBfSU5GT19NSyAgICAgMHhmZmZmZmZmZQorI2RlZmluZSBfX0xQVTBfSE9TVEZOMF9NQk9YMF9JTkZPX1NIICAgICAxCisjZGVmaW5lIF9fTFBVMF9IT1NURk4wX01CT1gwX0lORk8oX3YpICAgICgoX3YpIDw8IF9fTFBVMF9IT1NURk4wX01CT1gwX0lORk9fU0gpCisjZGVmaW5lIF9fTFBVMF9IT1NURk4wX01CT1gwX0NNRF9TVEFUVVMgIDB4MDAwMDAwMDEKKyNkZWZpbmUgTFBVMV9IT1NURk4wX01CT1gwX0NNRF9TVEFUICAgICAgMHgwMDAxOTAwYworI2RlZmluZSBfX0xQVTFfSE9TVEZOMF9NQk9YMF9JTkZPX01LICAgICAweGZmZmZmZmZlCisjZGVmaW5lIF9fTFBVMV9IT1NURk4wX01CT1gwX0lORk9fU0ggICAgIDEKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjBfTUJPWDBfSU5GTyhfdikgICAgKChfdikgPDwgX19MUFUxX0hPU1RGTjBfTUJPWDBfSU5GT19TSCkKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjBfTUJPWDBfQ01EX1NUQVRVUyAgMHgwMDAwMDAwMQorI2RlZmluZSBIT1NURk4xX0xQVTBfTUJPWDBfQ01EX1NUQVQgICAgICAweDAwMDE5MDEwCisjZGVmaW5lIF9fSE9TVEZOMV9MUFUwX01CT1gwX0lORk9fTUsgICAgIDB4ZmZmZmZmZmUKKyNkZWZpbmUgX19IT1NURk4xX0xQVTBfTUJPWDBfSU5GT19TSCAgICAgMQorI2RlZmluZSBfX0hPU1RGTjFfTFBVMF9NQk9YMF9JTkZPKF92KSAgICAoKF92KSA8PCBfX0hPU1RGTjFfTFBVMF9NQk9YMF9JTkZPX1NIKQorI2RlZmluZSBfX0hPU1RGTjFfTFBVMF9NQk9YMF9DTURfU1RBVFVTICAweDAwMDAwMDAxCisjZGVmaW5lIEhPU1RGTjFfTFBVMV9NQk9YMF9DTURfU1RBVCAgICAgIDB4MDAwMTkwMTQKKyNkZWZpbmUgX19IT1NURk4xX0xQVTFfTUJPWDBfSU5GT19NSyAgICAgMHhmZmZmZmZmZQorI2RlZmluZSBfX0hPU1RGTjFfTFBVMV9NQk9YMF9JTkZPX1NIICAgICAxCisjZGVmaW5lIF9fSE9TVEZOMV9MUFUxX01CT1gwX0lORk8oX3YpICAgICgoX3YpIDw8IF9fSE9TVEZOMV9MUFUxX01CT1gwX0lORk9fU0gpCisjZGVmaW5lIF9fSE9TVEZOMV9MUFUxX01CT1gwX0NNRF9TVEFUVVMgIDB4MDAwMDAwMDEKKyNkZWZpbmUgTFBVMF9IT1NURk4xX01CT1gwX0NNRF9TVEFUICAgICAgMHgwMDAxOTAxOAorI2RlZmluZSBfX0xQVTBfSE9TVEZOMV9NQk9YMF9JTkZPX01LICAgICAweGZmZmZmZmZlCisjZGVmaW5lIF9fTFBVMF9IT1NURk4xX01CT1gwX0lORk9fU0ggICAgIDEKKyNkZWZpbmUgX19MUFUwX0hPU1RGTjFfTUJPWDBfSU5GTyhfdikgICAgKChfdikgPDwgX19MUFUwX0hPU1RGTjFfTUJPWDBfSU5GT19TSCkKKyNkZWZpbmUgX19MUFUwX0hPU1RGTjFfTUJPWDBfQ01EX1NUQVRVUyAgMHgwMDAwMDAwMQorI2RlZmluZSBMUFUxX0hPU1RGTjFfTUJPWDBfQ01EX1NUQVQgICAgICAweDAwMDE5MDFjCisjZGVmaW5lIF9fTFBVMV9IT1NURk4xX01CT1gwX0lORk9fTUsgICAgIDB4ZmZmZmZmZmUKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjFfTUJPWDBfSU5GT19TSCAgICAgMQorI2RlZmluZSBfX0xQVTFfSE9TVEZOMV9NQk9YMF9JTkZPKF92KSAgICAoKF92KSA8PCBfX0xQVTFfSE9TVEZOMV9NQk9YMF9JTkZPX1NIKQorI2RlZmluZSBfX0xQVTFfSE9TVEZOMV9NQk9YMF9DTURfU1RBVFVTICAweDAwMDAwMDAxCisjZGVmaW5lIEhPU1RGTjJfTFBVMF9NQk9YMF9DTURfU1RBVCAgICAgIDB4MDAwMTkxNTAKKyNkZWZpbmUgX19IT1NURk4yX0xQVTBfTUJPWDBfSU5GT19NSyAgICAgMHhmZmZmZmZmZQorI2RlZmluZSBfX0hPU1RGTjJfTFBVMF9NQk9YMF9JTkZPX1NIICAgICAxCisjZGVmaW5lIF9fSE9TVEZOMl9MUFUwX01CT1gwX0lORk8oX3YpICAgICgoX3YpIDw8IF9fSE9TVEZOMl9MUFUwX01CT1gwX0lORk9fU0gpCisjZGVmaW5lIF9fSE9TVEZOMl9MUFUwX01CT1gwX0NNRF9TVEFUVVMgIDB4MDAwMDAwMDEKKyNkZWZpbmUgSE9TVEZOMl9MUFUxX01CT1gwX0NNRF9TVEFUICAgICAgMHgwMDAxOTE1NAorI2RlZmluZSBfX0hPU1RGTjJfTFBVMV9NQk9YMF9JTkZPX01LICAgICAweGZmZmZmZmZlCisjZGVmaW5lIF9fSE9TVEZOMl9MUFUxX01CT1gwX0lORk9fU0ggICAgIDEKKyNkZWZpbmUgX19IT1NURk4yX0xQVTFfTUJPWDBfSU5GTyhfdikgICAgKChfdikgPDwgX19IT1NURk4yX0xQVTFfTUJPWDBfSU5GT19TSCkKKyNkZWZpbmUgX19IT1NURk4yX0xQVTFfTUJPWDBCT1gwX0NNRF9TVEFUVVMgMHgwMDAwMDAwMQorI2RlZmluZSBMUFUwX0hPU1RGTjJfTUJPWDBfQ01EX1NUQVQgICAgICAweDAwMDE5MTU4CisjZGVmaW5lIF9fTFBVMF9IT1NURk4yX01CT1gwX0lORk9fTUsgICAgIDB4ZmZmZmZmZmUKKyNkZWZpbmUgX19MUFUwX0hPU1RGTjJfTUJPWDBfSU5GT19TSCAgICAgMQorI2RlZmluZSBfX0xQVTBfSE9TVEZOMl9NQk9YMF9JTkZPKF92KSAgICAoKF92KSA8PCBfX0xQVTBfSE9TVEZOMl9NQk9YMF9JTkZPX1NIKQorI2RlZmluZSBfX0xQVTBfSE9TVEZOMl9NQk9YMF9DTURfU1RBVFVTICAweDAwMDAwMDAxCisjZGVmaW5lIExQVTFfSE9TVEZOMl9NQk9YMF9DTURfU1RBVCAgICAgIDB4MDAwMTkxNWMKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjJfTUJPWDBfSU5GT19NSyAgICAgMHhmZmZmZmZmZQorI2RlZmluZSBfX0xQVTFfSE9TVEZOMl9NQk9YMF9JTkZPX1NIICAgICAxCisjZGVmaW5lIF9fTFBVMV9IT1NURk4yX01CT1gwX0lORk8oX3YpICAgICgoX3YpIDw8IF9fTFBVMV9IT1NURk4yX01CT1gwX0lORk9fU0gpCisjZGVmaW5lIF9fTFBVMV9IT1NURk4yX01CT1gwX0NNRF9TVEFUVVMgIDB4MDAwMDAwMDEKKyNkZWZpbmUgSE9TVEZOM19MUFUwX01CT1gwX0NNRF9TVEFUICAgICAgMHgwMDAxOTE2MAorI2RlZmluZSBfX0hPU1RGTjNfTFBVMF9NQk9YMF9JTkZPX01LICAgICAweGZmZmZmZmZlCisjZGVmaW5lIF9fSE9TVEZOM19MUFUwX01CT1gwX0lORk9fU0ggICAgIDEKKyNkZWZpbmUgX19IT1NURk4zX0xQVTBfTUJPWDBfSU5GTyhfdikgICAgKChfdikgPDwgX19IT1NURk4zX0xQVTBfTUJPWDBfSU5GT19TSCkKKyNkZWZpbmUgX19IT1NURk4zX0xQVTBfTUJPWDBfQ01EX1NUQVRVUyAgMHgwMDAwMDAwMQorI2RlZmluZSBIT1NURk4zX0xQVTFfTUJPWDBfQ01EX1NUQVQgICAgICAweDAwMDE5MTY0CisjZGVmaW5lIF9fSE9TVEZOM19MUFUxX01CT1gwX0lORk9fTUsgICAgIDB4ZmZmZmZmZmUKKyNkZWZpbmUgX19IT1NURk4zX0xQVTFfTUJPWDBfSU5GT19TSCAgICAgMQorI2RlZmluZSBfX0hPU1RGTjNfTFBVMV9NQk9YMF9JTkZPKF92KSAgICAoKF92KSA8PCBfX0hPU1RGTjNfTFBVMV9NQk9YMF9JTkZPX1NIKQorI2RlZmluZSBfX0hPU1RGTjNfTFBVMV9NQk9YMF9DTURfU1RBVFVTICAweDAwMDAwMDAxCisjZGVmaW5lIExQVTBfSE9TVEZOM19NQk9YMF9DTURfU1RBVCAgICAgIDB4MDAwMTkxNjgKKyNkZWZpbmUgX19MUFUwX0hPU1RGTjNfTUJPWDBfSU5GT19NSyAgICAgMHhmZmZmZmZmZQorI2RlZmluZSBfX0xQVTBfSE9TVEZOM19NQk9YMF9JTkZPX1NIICAgICAxCisjZGVmaW5lIF9fTFBVMF9IT1NURk4zX01CT1gwX0lORk8oX3YpICAgICgoX3YpIDw8IF9fTFBVMF9IT1NURk4zX01CT1gwX0lORk9fU0gpCisjZGVmaW5lIF9fTFBVMF9IT1NURk4zX01CT1gwX0NNRF9TVEFUVVMgIDB4MDAwMDAwMDEKKyNkZWZpbmUgTFBVMV9IT1NURk4zX01CT1gwX0NNRF9TVEFUICAgICAgMHgwMDAxOTE2YworI2RlZmluZSBfX0xQVTFfSE9TVEZOM19NQk9YMF9JTkZPX01LICAgICAweGZmZmZmZmZlCisjZGVmaW5lIF9fTFBVMV9IT1NURk4zX01CT1gwX0lORk9fU0ggICAgIDEKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjNfTUJPWDBfSU5GTyhfdikgICAgKChfdikgPDwgX19MUFUxX0hPU1RGTjNfTUJPWDBfSU5GT19TSCkKKyNkZWZpbmUgX19MUFUxX0hPU1RGTjNfTUJPWDBfQ01EX1NUQVRVUyAgMHgwMDAwMDAwMQorI2RlZmluZSBGV19JTklUX0hBTFRfUDAgICAgICAgICAgICAgICAgICAweDAwMDE5MWFjCisjZGVmaW5lIF9fRldfSU5JVF9IQUxUX1AgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDEKKyNkZWZpbmUgRldfSU5JVF9IQUxUX1AxICAgICAgICAgICAgICAgICAgMHgwMDAxOTFiYworI2RlZmluZSBDUEVfUElfUFRSX1EwICAgICAgICAgICAgICAgICAgICAweDAwMDM4MDAwCisjZGVmaW5lIF9fQ1BFX1BJX1VOVVNFRF9NSyAgICAgICAgICAgICAgIDB4ZmZmZjAwMDAKKyNkZWZpbmUgX19DUEVfUElfVU5VU0VEX1NIICAgICAgICAgICAgICAgMTYKKyNkZWZpbmUgX19DUEVfUElfVU5VU0VEKF92KSAgICAgICAgICAgICAgKChfdikgPDwgX19DUEVfUElfVU5VU0VEX1NIKQorI2RlZmluZSBfX0NQRV9QSV9QVFIgICAgICAgICAgICAgICAgICAgICAweDAwMDBmZmZmCisjZGVmaW5lIENQRV9QSV9QVFJfUTEgICAgICAgICAgICAgICAgICAgIDB4MDAwMzgwNDAKKyNkZWZpbmUgQ1BFX0NJX1BUUl9RMCAgICAgICAgICAgICAgICAgICAgMHgwMDAzODAwNAorI2RlZmluZSBfX0NQRV9DSV9VTlVTRURfTUsgICAgICAgICAgICAgICAweGZmZmYwMDAwCisjZGVmaW5lIF9fQ1BFX0NJX1VOVVNFRF9TSCAgICAgICAgICAgICAgIDE2CisjZGVmaW5lIF9fQ1BFX0NJX1VOVVNFRChfdikgICAgICAgICAgICAgICgoX3YpIDw8IF9fQ1BFX0NJX1VOVVNFRF9TSCkKKyNkZWZpbmUgX19DUEVfQ0lfUFRSICAgICAgICAgICAgICAgICAgICAgMHgwMDAwZmZmZgorI2RlZmluZSBDUEVfQ0lfUFRSX1ExICAgICAgICAgICAgICAgICAgICAweDAwMDM4MDQ0CisjZGVmaW5lIENQRV9ERVBUSF9RMCAgICAgICAgICAgICAgICAgICAgIDB4MDAwMzgwMDgKKyNkZWZpbmUgX19DUEVfREVQVEhfVU5VU0VEX01LICAgICAgICAgICAgMHhmODAwMDAwMAorI2RlZmluZSBfX0NQRV9ERVBUSF9VTlVTRURfU0ggICAgICAgICAgICAyNworI2RlZmluZSBfX0NQRV9ERVBUSF9VTlVTRUQoX3YpICAgICAgICAgICAoKF92KSA8PCBfX0NQRV9ERVBUSF9VTlVTRURfU0gpCisjZGVmaW5lIF9fQ1BFX01TSVhfVkVDX0lOREVYX01LICAgICAgICAgIDB4MDdmZjAwMDAKKyNkZWZpbmUgX19DUEVfTVNJWF9WRUNfSU5ERVhfU0ggICAgICAgICAgMTYKKyNkZWZpbmUgX19DUEVfTVNJWF9WRUNfSU5ERVgoX3YpICAgICAgICAgKChfdikgPDwgX19DUEVfTVNJWF9WRUNfSU5ERVhfU0gpCisjZGVmaW5lIF9fQ1BFX0RFUFRIICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMGZmZmYKKyNkZWZpbmUgQ1BFX0RFUFRIX1ExICAgICAgICAgICAgICAgICAgICAgMHgwMDAzODA0OAorI2RlZmluZSBDUEVfUUNUUkxfUTAgICAgICAgICAgICAgICAgICAgICAweDAwMDM4MDBjCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMzBfTUsgICAgICAgICAgIDB4ZmMwMDAwMDAKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQzMF9TSCAgICAgICAgICAgMjYKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQzMChfdikgICAgICAgICAgKChfdikgPDwgX19DUEVfQ1RSTF9VTlVTRUQzMF9TSCkKKyNkZWZpbmUgX19DUEVfRlVOQ19JTlRfQ1RSTF9NSyAgICAgICAgICAgMHgwMzAwMDAwMAorI2RlZmluZSBfX0NQRV9GVU5DX0lOVF9DVFJMX1NIICAgICAgICAgICAyNAorI2RlZmluZSBfX0NQRV9GVU5DX0lOVF9DVFJMKF92KSAgICAgICAgICAoKF92KSA8PCBfX0NQRV9GVU5DX0lOVF9DVFJMX1NIKQorZW51bSB7CisgICAgX19DUEVfRlVOQ19JTlRfQ1RSTF9ESVNBQkxFICAgICAgPSAweDAsCisgICAgX19DUEVfRlVOQ19JTlRfQ1RSTF9GMk5GICAgICAgICAgPSAweDEsCisgICAgX19DUEVfRlVOQ19JTlRfQ1RSTF8zUVVBUlQgICAgICAgPSAweDIsCisgICAgX19DUEVfRlVOQ19JTlRfQ1RSTF9IQUxGICAgICAgICAgPSAweDMsCit9OworI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDIwX01LICAgICAgICAgICAweDAwZjAwMDAwCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMjBfU0ggICAgICAgICAgIDIwCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMjAoX3YpICAgICAgICAgICgoX3YpIDw8IF9fQ1BFX0NUUkxfVU5VU0VEMjBfU0gpCisjZGVmaW5lIF9fQ1BFX1NDSV9USF9NSyAgICAgICAgICAgICAgICAgIDB4MDAwZjAwMDAKKyNkZWZpbmUgX19DUEVfU0NJX1RIX1NIICAgICAgICAgICAgICAgICAgMTYKKyNkZWZpbmUgX19DUEVfU0NJX1RIKF92KSAgICAgICAgICAgICAgICAgKChfdikgPDwgX19DUEVfU0NJX1RIX1NIKQorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDEwX01LICAgICAgICAgICAweDAwMDBjMDAwCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMTBfU0ggICAgICAgICAgIDE0CisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMTAoX3YpICAgICAgICAgICgoX3YpIDw8IF9fQ1BFX0NUUkxfVU5VU0VEMTBfU0gpCisjZGVmaW5lIF9fQ1BFX0FDS19QRU5ESU5HICAgICAgICAgICAgICAgIDB4MDAwMDIwMDAKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQ0MF9NSyAgICAgICAgICAgMHgwMDAwMWMwMAorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDQwX1NIICAgICAgICAgICAxMAorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDQwKF92KSAgICAgICAgICAoKF92KSA8PCBfX0NQRV9DVFJMX1VOVVNFRDQwX1NIKQorI2RlZmluZSBfX0NQRV9QQ0lFSURfTUsgICAgICAgICAgICAgICAgICAweDAwMDAwMzAwCisjZGVmaW5lIF9fQ1BFX1BDSUVJRF9TSCAgICAgICAgICAgICAgICAgIDgKKyNkZWZpbmUgX19DUEVfUENJRUlEKF92KSAgICAgICAgICAgICAgICAgKChfdikgPDwgX19DUEVfUENJRUlEX1NIKQorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDAwX01LICAgICAgICAgICAweDAwMDAwMGZlCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMDBfU0ggICAgICAgICAgIDEKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQwMChfdikgICAgICAgICAgKChfdikgPDwgX19DUEVfQ1RSTF9VTlVTRUQwMF9TSCkKKyNkZWZpbmUgX19DUEVfRVNJWkUgICAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMQorI2RlZmluZSBDUEVfUUNUUkxfUTEgICAgICAgICAgICAgICAgICAgICAweDAwMDM4MDRjCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMzFfTUsgICAgICAgICAgIDB4ZmMwMDAwMDAKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQzMV9TSCAgICAgICAgICAgMjYKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQzMShfdikgICAgICAgICAgKChfdikgPDwgX19DUEVfQ1RSTF9VTlVTRUQzMV9TSCkKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQyMV9NSyAgICAgICAgICAgMHgwMGYwMDAwMAorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDIxX1NIICAgICAgICAgICAyMAorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDIxKF92KSAgICAgICAgICAoKF92KSA8PCBfX0NQRV9DVFJMX1VOVVNFRDIxX1NIKQorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDExX01LICAgICAgICAgICAweDAwMDBjMDAwCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMTFfU0ggICAgICAgICAgIDE0CisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMTEoX3YpICAgICAgICAgICgoX3YpIDw8IF9fQ1BFX0NUUkxfVU5VU0VEMTFfU0gpCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VENDFfTUsgICAgICAgICAgIDB4MDAwMDFjMDAKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQ0MV9TSCAgICAgICAgICAgMTAKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQ0MShfdikgICAgICAgICAgKChfdikgPDwgX19DUEVfQ1RSTF9VTlVTRUQ0MV9TSCkKKyNkZWZpbmUgX19DUEVfQ1RSTF9VTlVTRUQwMV9NSyAgICAgICAgICAgMHgwMDAwMDBmZQorI2RlZmluZSBfX0NQRV9DVFJMX1VOVVNFRDAxX1NIICAgICAgICAgICAxCisjZGVmaW5lIF9fQ1BFX0NUUkxfVU5VU0VEMDEoX3YpICAgICAgICAgICgoX3YpIDw8IF9fQ1BFX0NUUkxfVU5VU0VEMDFfU0gpCisjZGVmaW5lIFJNRV9QSV9QVFJfUTAgICAgICAgICAgICAgICAgICAgIDB4MDAwMzgwMjAKKyNkZWZpbmUgX19MQVRFTkNZX1RJTUVfU1RBTVBfTUsgICAgICAgICAgMHhmZmZmMDAwMAorI2RlZmluZSBfX0xBVEVOQ1lfVElNRV9TVEFNUF9TSCAgICAgICAgICAxNgorI2RlZmluZSBfX0xBVEVOQ1lfVElNRV9TVEFNUChfdikgICAgICAgICAoKF92KSA8PCBfX0xBVEVOQ1lfVElNRV9TVEFNUF9TSCkKKyNkZWZpbmUgX19STUVfUElfUFRSICAgICAgICAgICAgICAgICAgICAgMHgwMDAwZmZmZgorI2RlZmluZSBSTUVfUElfUFRSX1ExICAgICAgICAgICAgICAgICAgICAweDAwMDM4MDYwCisjZGVmaW5lIFJNRV9DSV9QVFJfUTAgICAgICAgICAgICAgICAgICAgIDB4MDAwMzgwMjQKKyNkZWZpbmUgX19ERUxBWV9USU1FX1NUQU1QX01LICAgICAgICAgICAgMHhmZmZmMDAwMAorI2RlZmluZSBfX0RFTEFZX1RJTUVfU1RBTVBfU0ggICAgICAgICAgICAxNgorI2RlZmluZSBfX0RFTEFZX1RJTUVfU1RBTVAoX3YpICAgICAgICAgICAoKF92KSA8PCBfX0RFTEFZX1RJTUVfU1RBTVBfU0gpCisjZGVmaW5lIF9fUk1FX0NJX1BUUiAgICAgICAgICAgICAgICAgICAgIDB4MDAwMGZmZmYKKyNkZWZpbmUgUk1FX0NJX1BUUl9RMSAgICAgICAgICAgICAgICAgICAgMHgwMDAzODA2NAorI2RlZmluZSBSTUVfREVQVEhfUTAgICAgICAgICAgICAgICAgICAgICAweDAwMDM4MDI4CisjZGVmaW5lIF9fUk1FX0RFUFRIX1VOVVNFRF9NSyAgICAgICAgICAgIDB4ZjgwMDAwMDAKKyNkZWZpbmUgX19STUVfREVQVEhfVU5VU0VEX1NIICAgICAgICAgICAgMjcKKyNkZWZpbmUgX19STUVfREVQVEhfVU5VU0VEKF92KSAgICAgICAgICAgKChfdikgPDwgX19STUVfREVQVEhfVU5VU0VEX1NIKQorI2RlZmluZSBfX1JNRV9NU0lYX1ZFQ19JTkRFWF9NSyAgICAgICAgICAweDA3ZmYwMDAwCisjZGVmaW5lIF9fUk1FX01TSVhfVkVDX0lOREVYX1NIICAgICAgICAgIDE2CisjZGVmaW5lIF9fUk1FX01TSVhfVkVDX0lOREVYKF92KSAgICAgICAgICgoX3YpIDw8IF9fUk1FX01TSVhfVkVDX0lOREVYX1NIKQorI2RlZmluZSBfX1JNRV9ERVBUSCAgICAgICAgICAgICAgICAgICAgICAweDAwMDBmZmZmCisjZGVmaW5lIFJNRV9ERVBUSF9RMSAgICAgICAgICAgICAgICAgICAgIDB4MDAwMzgwNjgKKyNkZWZpbmUgUk1FX1FDVFJMX1EwICAgICAgICAgICAgICAgICAgICAgMHgwMDAzODAyYworI2RlZmluZSBfX1JNRV9JTlRfTEFURU5DWV9USU1FUl9NSyAgICAgICAweGZmMDAwMDAwCisjZGVmaW5lIF9fUk1FX0lOVF9MQVRFTkNZX1RJTUVSX1NIICAgICAgIDI0CisjZGVmaW5lIF9fUk1FX0lOVF9MQVRFTkNZX1RJTUVSKF92KSAgICAgICgoX3YpIDw8IF9fUk1FX0lOVF9MQVRFTkNZX1RJTUVSX1NIKQorI2RlZmluZSBfX1JNRV9JTlRfREVMQVlfVElNRVJfTUsgICAgICAgICAweDAwZmYwMDAwCisjZGVmaW5lIF9fUk1FX0lOVF9ERUxBWV9USU1FUl9TSCAgICAgICAgIDE2CisjZGVmaW5lIF9fUk1FX0lOVF9ERUxBWV9USU1FUihfdikgICAgICAgICgoX3YpIDw8IF9fUk1FX0lOVF9ERUxBWV9USU1FUl9TSCkKKyNkZWZpbmUgX19STUVfSU5UX0RFTEFZX0RJU0FCTEUgICAgICAgICAgMHgwMDAwODAwMAorI2RlZmluZSBfX1JNRV9ETFlfREVMQVlfRElTQUJMRSAgICAgICAgICAweDAwMDA0MDAwCisjZGVmaW5lIF9fUk1FX0FDS19QRU5ESU5HICAgICAgICAgICAgICAgIDB4MDAwMDIwMDAKKyNkZWZpbmUgX19STUVfRlVMTF9JTlRFUlJVUFRfRElTQUJMRSAgICAgMHgwMDAwMTAwMAorI2RlZmluZSBfX1JNRV9DVFJMX1VOVVNFRDEwX01LICAgICAgICAgICAweDAwMDAwYzAwCisjZGVmaW5lIF9fUk1FX0NUUkxfVU5VU0VEMTBfU0ggICAgICAgICAgIDEwCisjZGVmaW5lIF9fUk1FX0NUUkxfVU5VU0VEMTAoX3YpICAgICAgICAgICgoX3YpIDw8IF9fUk1FX0NUUkxfVU5VU0VEMTBfU0gpCisjZGVmaW5lIF9fUk1FX1BDSUVJRF9NSyAgICAgICAgICAgICAgICAgIDB4MDAwMDAzMDAKKyNkZWZpbmUgX19STUVfUENJRUlEX1NIICAgICAgICAgICAgICAgICAgOAorI2RlZmluZSBfX1JNRV9QQ0lFSUQoX3YpICAgICAgICAgICAgICAgICAoKF92KSA8PCBfX1JNRV9QQ0lFSURfU0gpCisjZGVmaW5lIF9fUk1FX0NUUkxfVU5VU0VEMDBfTUsgICAgICAgICAgIDB4MDAwMDAwZmUKKyNkZWZpbmUgX19STUVfQ1RSTF9VTlVTRUQwMF9TSCAgICAgICAgICAgMQorI2RlZmluZSBfX1JNRV9DVFJMX1VOVVNFRDAwKF92KSAgICAgICAgICAoKF92KSA8PCBfX1JNRV9DVFJMX1VOVVNFRDAwX1NIKQorI2RlZmluZSBfX1JNRV9FU0laRSAgICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDAxCisjZGVmaW5lIFJNRV9RQ1RSTF9RMSAgICAgICAgICAgICAgICAgICAgIDB4MDAwMzgwNmMKKyNkZWZpbmUgX19STUVfQ1RSTF9VTlVTRUQxMV9NSyAgICAgICAgICAgMHgwMDAwMGMwMAorI2RlZmluZSBfX1JNRV9DVFJMX1VOVVNFRDExX1NIICAgICAgICAgICAxMAorI2RlZmluZSBfX1JNRV9DVFJMX1VOVVNFRDExKF92KSAgICAgICAgICAoKF92KSA8PCBfX1JNRV9DVFJMX1VOVVNFRDExX1NIKQorI2RlZmluZSBfX1JNRV9DVFJMX1VOVVNFRDAxX01LICAgICAgICAgICAweDAwMDAwMGZlCisjZGVmaW5lIF9fUk1FX0NUUkxfVU5VU0VEMDFfU0ggICAgICAgICAgIDEKKyNkZWZpbmUgX19STUVfQ1RSTF9VTlVTRUQwMShfdikgICAgICAgICAgKChfdikgPDwgX19STUVfQ1RSTF9VTlVTRUQwMV9TSCkKKyNkZWZpbmUgUFNTX0NUTF9SRUcgICAgICAgICAgICAgICAgICAgICAgMHgwMDAxODgwMAorI2RlZmluZSBfX1BTU19JMkNfQ0xLX0RJVl9NSyAgICAgICAgICAgICAweDAwN2YwMDAwCisjZGVmaW5lIF9fUFNTX0kyQ19DTEtfRElWX1NIICAgICAgICAgICAgIDE2CisjZGVmaW5lIF9fUFNTX0kyQ19DTEtfRElWKF92KSAgICAgICAgICAgICgoX3YpIDw8IF9fUFNTX0kyQ19DTEtfRElWX1NIKQorI2RlZmluZSBfX1BTU19MTUVNX0lOSVRfRE9ORSAgICAgICAgICAgICAweDAwMDAxMDAwCisjZGVmaW5lIF9fUFNTX0xNRU1fUkVTRVQgICAgICAgICAgICAgICAgIDB4MDAwMDAyMDAKKyNkZWZpbmUgX19QU1NfTE1FTV9JTklUX0VOICAgICAgICAgICAgICAgMHgwMDAwMDEwMAorI2RlZmluZSBfX1BTU19MUFUxX1JFU0VUICAgICAgICAgICAgICAgICAweDAwMDAwMDAyCisjZGVmaW5lIF9fUFNTX0xQVTBfUkVTRVQgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDEKKyNkZWZpbmUgSFFNX1FTRVQwX1JYUV9EUkJMX1AwICAgICAgICAgICAgMHgwMDAzODAwMAorI2RlZmluZSBfX1JYUTBfQUREX1ZFQ1RPUlNfUCAgICAgICAgICAgICAweDgwMDAwMDAwCisjZGVmaW5lIF9fUlhRMF9TVE9QX1AgICAgICAgICAgICAgICAgICAgIDB4NDAwMDAwMDAKKyNkZWZpbmUgX19SWFEwX1BSRF9QVFJfUCAgICAgICAgICAgICAgICAgMHgwMDAwZmZmZgorI2RlZmluZSBIUU1fUVNFVDFfUlhRX0RSQkxfUDAgICAgICAgICAgICAweDAwMDM4MDgwCisjZGVmaW5lIF9fUlhRMV9BRERfVkVDVE9SU19QICAgICAgICAgICAgIDB4ODAwMDAwMDAKKyNkZWZpbmUgX19SWFExX1NUT1BfUCAgICAgICAgICAgICAgICAgICAgMHg0MDAwMDAwMAorI2RlZmluZSBfX1JYUTFfUFJEX1BUUl9QICAgICAgICAgICAgICAgICAweDAwMDBmZmZmCisjZGVmaW5lIEhRTV9RU0VUMF9SWFFfRFJCTF9QMSAgICAgICAgICAgIDB4MDAwM2MwMDAKKyNkZWZpbmUgSFFNX1FTRVQxX1JYUV9EUkJMX1AxICAgICAgICAgICAgMHgwMDAzYzA4MAorI2RlZmluZSBIUU1fUVNFVDBfVFhRX0RSQkxfUDAgICAgICAgICAgICAweDAwMDM4MDIwCisjZGVmaW5lIF9fVFhRMF9BRERfVkVDVE9SU19QICAgICAgICAgICAgIDB4ODAwMDAwMDAKKyNkZWZpbmUgX19UWFEwX1NUT1BfUCAgICAgICAgICAgICAgICAgICAgMHg0MDAwMDAwMAorI2RlZmluZSBfX1RYUTBfUFJEX1BUUl9QICAgICAgICAgICAgICAgICAweDAwMDBmZmZmCisjZGVmaW5lIEhRTV9RU0VUMV9UWFFfRFJCTF9QMCAgICAgICAgICAgIDB4MDAwMzgwYTAKKyNkZWZpbmUgX19UWFExX0FERF9WRUNUT1JTX1AgICAgICAgICAgICAgMHg4MDAwMDAwMAorI2RlZmluZSBfX1RYUTFfU1RPUF9QICAgICAgICAgICAgICAgICAgICAweDQwMDAwMDAwCisjZGVmaW5lIF9fVFhRMV9QUkRfUFRSX1AgICAgICAgICAgICAgICAgIDB4MDAwMGZmZmYKKyNkZWZpbmUgSFFNX1FTRVQwX1RYUV9EUkJMX1AxICAgICAgICAgICAgMHgwMDAzYzAyMAorI2RlZmluZSBIUU1fUVNFVDFfVFhRX0RSQkxfUDEgICAgICAgICAgICAweDAwMDNjMGEwCisjZGVmaW5lIEhRTV9RU0VUMF9JQl9EUkJMXzFfUDAgICAgICAgICAgIDB4MDAwMzgwNDAKKyNkZWZpbmUgX19JQjFfMF9BQ0tfUCAgICAgICAgICAgICAgICAgICAgMHg4MDAwMDAwMAorI2RlZmluZSBfX0lCMV8wX0RJU0FCTEVfUCAgICAgICAgICAgICAgICAweDQwMDAwMDAwCisjZGVmaW5lIF9fSUIxXzBfTlVNX09GX0FDS0VEX0VWRU5UU19QICAgIDB4MDAwMGZmZmYKKyNkZWZpbmUgSFFNX1FTRVQxX0lCX0RSQkxfMV9QMCAgICAgICAgICAgMHgwMDAzODBjMAorI2RlZmluZSBfX0lCMV8xX0FDS19QICAgICAgICAgICAgICAgICAgICAweDgwMDAwMDAwCisjZGVmaW5lIF9fSUIxXzFfRElTQUJMRV9QICAgICAgICAgICAgICAgIDB4NDAwMDAwMDAKKyNkZWZpbmUgX19JQjFfMV9OVU1fT0ZfQUNLRURfRVZFTlRTX1AgICAgMHgwMDAwZmZmZgorI2RlZmluZSBIUU1fUVNFVDBfSUJfRFJCTF8xX1AxICAgICAgICAgICAweDAwMDNjMDQwCisjZGVmaW5lIEhRTV9RU0VUMV9JQl9EUkJMXzFfUDEgICAgICAgICAgIDB4MDAwM2MwYzAKKyNkZWZpbmUgSFFNX1FTRVQwX0lCX0RSQkxfMl9QMCAgICAgICAgICAgMHgwMDAzODA2MAorI2RlZmluZSBfX0lCMl8wX0FDS19QICAgICAgICAgICAgICAgICAgICAweDgwMDAwMDAwCisjZGVmaW5lIF9fSUIyXzBfRElTQUJMRV9QICAgICAgICAgICAgICAgIDB4NDAwMDAwMDAKKyNkZWZpbmUgX19JQjJfMF9OVU1fT0ZfQUNLRURfRVZFTlRTX1AgICAgMHgwMDAwZmZmZgorI2RlZmluZSBIUU1fUVNFVDFfSUJfRFJCTF8yX1AwICAgICAgICAgICAweDAwMDM4MGUwCisjZGVmaW5lIF9fSUIyXzFfQUNLX1AgICAgICAgICAgICAgICAgICAgIDB4ODAwMDAwMDAKKyNkZWZpbmUgX19JQjJfMV9ESVNBQkxFX1AgICAgICAgICAgICAgICAgMHg0MDAwMDAwMAorI2RlZmluZSBfX0lCMl8xX05VTV9PRl9BQ0tFRF9FVkVOVFNfUCAgICAweDAwMDBmZmZmCisjZGVmaW5lIEhRTV9RU0VUMF9JQl9EUkJMXzJfUDEgICAgICAgICAgIDB4MDAwM2MwNjAKKyNkZWZpbmUgSFFNX1FTRVQxX0lCX0RSQkxfMl9QMSAgICAgICAgICAgMHgwMDAzYzBlMAorCisKKy8qCisgKiBUaGVzZSBkZWZpbml0aW9ucyBhcmUgZWl0aGVyIGluIGVycm9yL21pc3NpbmcgaW4gc3BlYy4gSXRzIGF1dG8tZ2VuZXJhdGVkCisgKiBmcm9tIGhhcmQgY29kZWQgdmFsdWVzIGluIHJlZ3BhcnNlLnBsLgorICovCisjZGVmaW5lIF9fRU1QSFBPU1RfQVRfNEdfTUtfRklYICAgICAgICAgIDB4MDAwMDAwMWMKKyNkZWZpbmUgX19FTVBIUE9TVF9BVF80R19TSF9GSVggICAgICAgICAgMHgwMDAwMDAwMgorI2RlZmluZSBfX0VNUEhQUkVfQVRfNEdfRklYICAgICAgICAgICAgICAweDAwMDAwMDAzCisjZGVmaW5lIF9fU0ZQX1RYUkFURV9FTl9GSVggICAgICAgICAgICAgIDB4MDAwMDAxMDAKKyNkZWZpbmUgX19TRlBfUlhSQVRFX0VOX0ZJWCAgICAgICAgICAgICAgMHgwMDAwMDA4MAorCisKKy8qCisgKiBUaGVzZSByZWdpc3RlciBkZWZpbml0aW9ucyBhcmUgYXV0by1nZW5lcmF0ZWQgZnJvbSBoYXJkIGNvZGVkIHZhbHVlcworICogaW4gcmVncGFyc2UucGwuCisgKi8KKworCisvKgorICogVGhlc2UgcmVnaXN0ZXIgbWFwcGluZyBkZWZpbml0aW9ucyBhcmUgYXV0by1nZW5lcmF0ZWQgZnJvbSBtYXBwaW5nIHRhYmxlcworICogaW4gcmVncGFyc2UucGwuCisgKi8KKyNkZWZpbmUgQkZBX0lPQzBfSEJFQVRfUkVHICAgICAgICAgICAgICAgSE9TVF9TRU0wX0lORk9fUkVHCisjZGVmaW5lIEJGQV9JT0MwX1NUQVRFX1JFRyAgICAgICAgICAgICAgIEhPU1RfU0VNMV9JTkZPX1JFRworI2RlZmluZSBCRkFfSU9DMV9IQkVBVF9SRUcgICAgICAgICAgICAgICBIT1NUX1NFTTJfSU5GT19SRUcKKyNkZWZpbmUgQkZBX0lPQzFfU1RBVEVfUkVHICAgICAgICAgICAgICAgSE9TVF9TRU0zX0lORk9fUkVHCisjZGVmaW5lIEJGQV9GV19VU0VfQ09VTlQgICAgICAgICAgICAgICAgIEhPU1RfU0VNNF9JTkZPX1JFRworCisjZGVmaW5lIENQRV9ERVBUSF9RKF9fbikgXAorCShDUEVfREVQVEhfUTAgKyAoX19uKSAqIChDUEVfREVQVEhfUTEgLSBDUEVfREVQVEhfUTApKQorI2RlZmluZSBDUEVfUUNUUkxfUShfX24pIFwKKwkoQ1BFX1FDVFJMX1EwICsgKF9fbikgKiAoQ1BFX1FDVFJMX1ExIC0gQ1BFX1FDVFJMX1EwKSkKKyNkZWZpbmUgQ1BFX1BJX1BUUl9RKF9fbikgXAorCShDUEVfUElfUFRSX1EwICsgKF9fbikgKiAoQ1BFX1BJX1BUUl9RMSAtIENQRV9QSV9QVFJfUTApKQorI2RlZmluZSBDUEVfQ0lfUFRSX1EoX19uKSBcCisJKENQRV9DSV9QVFJfUTAgKyAoX19uKSAqIChDUEVfQ0lfUFRSX1ExIC0gQ1BFX0NJX1BUUl9RMCkpCisjZGVmaW5lIFJNRV9ERVBUSF9RKF9fbikgXAorCShSTUVfREVQVEhfUTAgKyAoX19uKSAqIChSTUVfREVQVEhfUTEgLSBSTUVfREVQVEhfUTApKQorI2RlZmluZSBSTUVfUUNUUkxfUShfX24pIFwKKwkoUk1FX1FDVFJMX1EwICsgKF9fbikgKiAoUk1FX1FDVFJMX1ExIC0gUk1FX1FDVFJMX1EwKSkKKyNkZWZpbmUgUk1FX1BJX1BUUl9RKF9fbikgXAorCShSTUVfUElfUFRSX1EwICsgKF9fbikgKiAoUk1FX1BJX1BUUl9RMSAtIFJNRV9QSV9QVFJfUTApKQorI2RlZmluZSBSTUVfQ0lfUFRSX1EoX19uKSBcCisJKFJNRV9DSV9QVFJfUTAgKyAoX19uKSAqIChSTUVfQ0lfUFRSX1ExIC0gUk1FX0NJX1BUUl9RMCkpCisjZGVmaW5lIEhRTV9RU0VUX1JYUV9EUkJMX1AwKF9fbikgXAorCShIUU1fUVNFVDBfUlhRX0RSQkxfUDAgKyAoX19uKSAqIChIUU1fUVNFVDFfUlhRX0RSQkxfUDAgLSBcCisJSFFNX1FTRVQwX1JYUV9EUkJMX1AwKSkKKyNkZWZpbmUgSFFNX1FTRVRfVFhRX0RSQkxfUDAoX19uKSBcCisJKEhRTV9RU0VUMF9UWFFfRFJCTF9QMCArIChfX24pICogKEhRTV9RU0VUMV9UWFFfRFJCTF9QMCAtIFwKKwlIUU1fUVNFVDBfVFhRX0RSQkxfUDApKQorI2RlZmluZSBIUU1fUVNFVF9JQl9EUkJMXzFfUDAoX19uKSBcCisJKEhRTV9RU0VUMF9JQl9EUkJMXzFfUDAgKyAoX19uKSAqIChIUU1fUVNFVDFfSUJfRFJCTF8xX1AwIC0gXAorCUhRTV9RU0VUMF9JQl9EUkJMXzFfUDApKQorI2RlZmluZSBIUU1fUVNFVF9JQl9EUkJMXzJfUDAoX19uKSBcCisJKEhRTV9RU0VUMF9JQl9EUkJMXzJfUDAgKyAoX19uKSAqIChIUU1fUVNFVDFfSUJfRFJCTF8yX1AwIC0gXAorCUhRTV9RU0VUMF9JQl9EUkJMXzJfUDApKQorI2RlZmluZSBIUU1fUVNFVF9SWFFfRFJCTF9QMShfX24pIFwKKwkoSFFNX1FTRVQwX1JYUV9EUkJMX1AxICsgKF9fbikgKiAoSFFNX1FTRVQxX1JYUV9EUkJMX1AxIC0gXAorCUhRTV9RU0VUMF9SWFFfRFJCTF9QMSkpCisjZGVmaW5lIEhRTV9RU0VUX1RYUV9EUkJMX1AxKF9fbikgXAorCShIUU1fUVNFVDBfVFhRX0RSQkxfUDEgKyAoX19uKSAqIChIUU1fUVNFVDFfVFhRX0RSQkxfUDEgLSBcCisJSFFNX1FTRVQwX1RYUV9EUkJMX1AxKSkKKyNkZWZpbmUgSFFNX1FTRVRfSUJfRFJCTF8xX1AxKF9fbikgXAorCShIUU1fUVNFVDBfSUJfRFJCTF8xX1AxICsgKF9fbikgKiAoSFFNX1FTRVQxX0lCX0RSQkxfMV9QMSAtIFwKKwlIUU1fUVNFVDBfSUJfRFJCTF8xX1AxKSkKKyNkZWZpbmUgSFFNX1FTRVRfSUJfRFJCTF8yX1AxKF9fbikgXAorCShIUU1fUVNFVDBfSUJfRFJCTF8yX1AxICsgKF9fbikgKiAoSFFNX1FTRVQxX0lCX0RSQkxfMl9QMSAtIFwKKwlIUU1fUVNFVDBfSUJfRFJCTF8yX1AxKSkKKworI2RlZmluZSBDUEVfUV9OVU0oX19mbiwgX19xKSAgKCgoX19mbikgPDwgMikgKyAoX19xKSkKKyNkZWZpbmUgUk1FX1FfTlVNKF9fZm4sIF9fcSkgICgoKF9fZm4pIDw8IDIpICsgKF9fcSkpCisjZGVmaW5lIENQRV9RX01BU0soX19xKSAgKChfX3EpICYgMHgzKQorI2RlZmluZSBSTUVfUV9NQVNLKF9fcSkgICgoX19xKSAmIDB4MykKKworCisvKgorICogUENJIE1TSS1YIHZlY3RvciBkZWZpbmVzCisgKi8KK2VudW0geworICAgIEJGQV9NU0lYX0NQRV9RMCA9IDAsCisgICAgQkZBX01TSVhfQ1BFX1ExID0gMSwKKyAgICBCRkFfTVNJWF9DUEVfUTIgPSAyLAorICAgIEJGQV9NU0lYX0NQRV9RMyA9IDMsCisgICAgQkZBX01TSVhfUk1FX1EwID0gNCwKKyAgICBCRkFfTVNJWF9STUVfUTEgPSA1LAorICAgIEJGQV9NU0lYX1JNRV9RMiA9IDYsCisgICAgQkZBX01TSVhfUk1FX1EzID0gNywKKyAgICBCRkFfTVNJWF9MUFVfRVJSID0gOCwKKyAgICBCRkFfTVNJWF9DVF9NQVggPSA5LAorfTsKKworLyoKKyAqIEFuZCBjb3JyZXNwb25kaW5nIGhvc3QgaW50ZXJydXB0IHN0YXR1cyBiaXQgZmllbGQgZGVmaW5lcworICovCisjZGVmaW5lIF9fSEZOX0lOVF9DUEVfUTAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMVUKKyNkZWZpbmUgX19IRk5fSU5UX0NQRV9RMSAgICAgICAgICAgICAgICAgICAweDAwMDAwMDAyVQorI2RlZmluZSBfX0hGTl9JTlRfQ1BFX1EyICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDRVCisjZGVmaW5lIF9fSEZOX0lOVF9DUEVfUTMgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwOFUKKyNkZWZpbmUgX19IRk5fSU5UX0NQRV9RNCAgICAgICAgICAgICAgICAgICAweDAwMDAwMDEwVQorI2RlZmluZSBfX0hGTl9JTlRfQ1BFX1E1ICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMjBVCisjZGVmaW5lIF9fSEZOX0lOVF9DUEVfUTYgICAgICAgICAgICAgICAgICAgMHgwMDAwMDA0MFUKKyNkZWZpbmUgX19IRk5fSU5UX0NQRV9RNyAgICAgICAgICAgICAgICAgICAweDAwMDAwMDgwVQorI2RlZmluZSBfX0hGTl9JTlRfUk1FX1EwICAgICAgICAgICAgICAgICAgIDB4MDAwMDAxMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9STUVfUTEgICAgICAgICAgICAgICAgICAgMHgwMDAwMDIwMFUKKyNkZWZpbmUgX19IRk5fSU5UX1JNRV9RMiAgICAgICAgICAgICAgICAgICAweDAwMDAwNDAwVQorI2RlZmluZSBfX0hGTl9JTlRfUk1FX1EzICAgICAgICAgICAgICAgICAgIDB4MDAwMDA4MDBVCisjZGVmaW5lIF9fSEZOX0lOVF9STUVfUTQgICAgICAgICAgICAgICAgICAgMHgwMDAwMTAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX1JNRV9RNSAgICAgICAgICAgICAgICAgICAweDAwMDAyMDAwVQorI2RlZmluZSBfX0hGTl9JTlRfUk1FX1E2ICAgICAgICAgICAgICAgICAgIDB4MDAwMDQwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9STUVfUTcgICAgICAgICAgICAgICAgICAgMHgwMDAwODAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX0VSUl9FTUMgICAgICAgICAgICAgICAgICAweDAwMDEwMDAwVQorI2RlZmluZSBfX0hGTl9JTlRfRVJSX0xQVTAgICAgICAgICAgICAgICAgIDB4MDAwMjAwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9FUlJfTFBVMSAgICAgICAgICAgICAgICAgMHgwMDA0MDAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX0VSUl9QU1MgICAgICAgICAgICAgICAgICAweDAwMDgwMDAwVQorI2RlZmluZSBfX0hGTl9JTlRfTUJPWF9MUFUwICAgICAgICAgICAgICAgIDB4MDAxMDAwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9NQk9YX0xQVTEgICAgICAgICAgICAgICAgMHgwMDIwMDAwMFUKKyNkZWZpbmUgX19IRk5fSU5UX01CT1gxX0xQVTAgICAgICAgICAgICAgICAweDAwNDAwMDAwVQorI2RlZmluZSBfX0hGTl9JTlRfTUJPWDFfTFBVMSAgICAgICAgICAgICAgIDB4MDA4MDAwMDBVCisjZGVmaW5lIF9fSEZOX0lOVF9DUEVfTUFTSyAgICAgICAgICAgICAgICAgMHgwMDAwMDBmZlUKKyNkZWZpbmUgX19IRk5fSU5UX1JNRV9NQVNLICAgICAgICAgICAgICAgICAweDAwMDBmZjAwVQorCisKKy8qCisgKiBjYXRhcHVsdCBtZW1vcnkgbWFwLgorICovCisjZGVmaW5lIExMX1BHTl9IUU0wICAgICAgICAgICAgICAgICAgICAgIDB4MDA5NgorI2RlZmluZSBMTF9QR05fSFFNMSAgICAgICAgICAgICAgICAgICAgICAweDAwOTcKKyNkZWZpbmUgUFNTX1NNRU1fUEFHRV9TVEFSVAkweDgwMDAKKyNkZWZpbmUgUFNTX1NNRU1fUEdOVU0oX3BnMCwgX21hKQkoKF9wZzApICsgKChfbWEpID4+IDE1KSkKKyNkZWZpbmUgUFNTX1NNRU1fUEdPRkYoX21hKQkoKF9tYSkgJiAweDdmZmYpCisKKy8qCisgKiBFbmQgb2YgY2F0YXB1bHQgbWVtb3J5IG1hcAorICovCisKKworI2VuZGlmIC8qIF9fQkZJX0NUUkVHX0hfXyAqLworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9mYWJyaWMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2ZhYnJpYy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMwNjY5ZWQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9mYWJyaWMuaApAQCAtMCwwICsxLDkyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRklfRkFCUklDX0hfXworI2RlZmluZSBfX0JGSV9GQUJSSUNfSF9fCisKKyNpbmNsdWRlIDxiZmkvYmZpLmg+CisKKyNwcmFnbWEgcGFjaygxKQorCitlbnVtIGJmaV9mYWJyaWNfaDJpX21zZ3MgeworCUJGSV9GQUJSSUNfSDJJX0NSRUFURV9SRVEJPSAxLAorCUJGSV9GQUJSSUNfSDJJX0RFTEVURV9SRVEJPSAyLAorCUJGSV9GQUJSSUNfSDJJX1NFVEFVVEgJCT0gMywKK307CisKK2VudW0gYmZpX2ZhYnJpY19pMmhfbXNncyB7CisJQkZJX0ZBQlJJQ19JMkhfQ1JFQVRFX1JTUAk9IEJGQV9JMkhNKDEpLAorCUJGSV9GQUJSSUNfSTJIX0RFTEVURV9SU1AJPSBCRkFfSTJITSgyKSwKKwlCRklfRkFCUklDX0kySF9TRVRBVVRIX1JTUAk9IEJGQV9JMkhNKDMpLAorCUJGSV9GQUJSSUNfSTJIX09OTElORQkJPSBCRkFfSTJITSg0KSwKKwlCRklfRkFCUklDX0kySF9PRkZMSU5FCQk9IEJGQV9JMkhNKDUpLAorfTsKKworc3RydWN0IGJmaV9mYWJyaWNfY3JlYXRlX3JlcV9zIHsKKwliZmlfbWhkcl90CW1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkqLworCXU4ICAgICAgICAgdmZfZW47CQkvKiAgdmlydHVhbCBmYWJyaWMgZW5hYmxlCSovCisJdTggICAgICAgICByc3ZkOworCXUxNiAgICAgICAgdmZfaWQ7CQkvKiAgdmlydHVhbCBmYWJyaWMgSUQJCSovCisJd3duX3QJCXB3d247CQkvKiAgcG9ydCBuYW1lCQkJKi8KKwl3d25fdAkJbnd3bjsJCS8qICBub2RlIG5hbWUJCQkqLworfTsKKworc3RydWN0IGJmaV9mYWJyaWNfY3JlYXRlX3JzcF9zIHsKKwliZmlfbWhkcl90CW1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkqLworCXUxNiAgICAgICAgYmZhX2hhbmRsZTsJLyogIGhvc3QgZmFicmljIGhhbmRsZQkJKi8KKwl1OCAgICAgICAgIHN0YXR1czsJCS8qICBmYWJyaWMgY3JlYXRlIHN0YXR1cwkqLworCXU4ICAgICAgICAgcnN2ZDsKK307CisKK3N0cnVjdCBiZmlfZmFicmljX2RlbGV0ZV9yZXFfcyB7CisJYmZpX21oZHJfdAltaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1MTYgICAgICAgIGZ3X2hhbmRsZTsJLyogIGZpcm13YXJlIGZhYnJpYyBoYW5kbGUJKi8KKwl1MTYgICAgICAgIHJzdmQ7Cit9OworCitzdHJ1Y3QgYmZpX2ZhYnJpY19kZWxldGVfcnNwX3MgeworCWJmaV9taGRyX3QJbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSovCisJdTE2ICAgICAgICBiZmFfaGFuZGxlOwkvKiAgaG9zdCBmYWJyaWMgaGFuZGxlCQkqLworCXU4ICAgICAgICAgc3RhdHVzOwkJLyogIGZhYnJpYyBkZWxldGlvbiBzdGF0dXMJKi8KKwl1OCAgICAgICAgIHJzdmQ7Cit9OworCisjZGVmaW5lIEJGSV9GQUJSSUNfQVVUSFNFQ1JFVF9MRU4JNjQKK3N0cnVjdCBiZmlfZmFicmljX3NldGF1dGhfcmVxX3MgeworCWJmaV9taGRyX3QJbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSovCisJdTE2ICAgICAgICBmd19oYW5kbGU7CS8qICBmL3cgaGFuZGxlIG9mIGZhYnJpYwkqLworCXU4CQlhbGdvcml0aG07CisJdTgJCWdyb3VwOworCXU4CQlzZWNyZXRbQkZJX0ZBQlJJQ19BVVRIU0VDUkVUX0xFTl07Cit9OworCit1bmlvbiBiZmlfZmFicmljX2gyaV9tc2dfdSB7CisJYmZpX21zZ190CQkqbXNnOworCXN0cnVjdCBiZmlfZmFicmljX2NyZWF0ZV9yZXFfcwkqY3JlYXRlX3JlcTsKKwlzdHJ1Y3QgYmZpX2ZhYnJpY19kZWxldGVfcmVxX3MJKmRlbGV0ZV9yZXE7Cit9OworCit1bmlvbiBiZmlfZmFicmljX2kyaF9tc2dfdSB7CisJYmZpX21zZ190CQkqbXNnOworCXN0cnVjdCBiZmlfZmFicmljX2NyZWF0ZV9yc3BfcwkqY3JlYXRlX3JzcDsKKwlzdHJ1Y3QgYmZpX2ZhYnJpY19kZWxldGVfcnNwX3MJKmRlbGV0ZV9yc3A7Cit9OworCisjcHJhZ21hIHBhY2soKQorCisjZW5kaWYgLyogX19CRklfRkFCUklDX0hfXyAqLworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9mY3BpbS5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfZmNwaW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MmMwNTlmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfZmNwaW0uaApAQCAtMCwwICsxLDMwMSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZJX0ZDUElNX0hfXworI2RlZmluZSBfX0JGSV9GQ1BJTV9IX18KKworI2luY2x1ZGUgImJmaS5oIgorI2luY2x1ZGUgPHByb3RvY29sL2ZjcC5oPgorCisjcHJhZ21hIHBhY2soMSkKKworLyoKKyAqIEluaXRpYXRvciBtb2RlIEktVCBuZXh1cyBpbnRlcmZhY2UgZGVmaW5lcy4KKyAqLworCitlbnVtIGJmaV9pdG5pbV9oMmkgeworCUJGSV9JVE5JTV9IMklfQ1JFQVRFX1JFUSA9IDEsCS8qICBpLXQgbmV4dXMgY3JlYXRpb24gKi8KKwlCRklfSVROSU1fSDJJX0RFTEVURV9SRVEgPSAyLAkvKiAgaS10IG5leHVzIGRlbGV0aW9uICovCit9OworCitlbnVtIGJmaV9pdG5pbV9pMmggeworCUJGSV9JVE5JTV9JMkhfQ1JFQVRFX1JTUCA9IEJGQV9JMkhNKDEpLAorCUJGSV9JVE5JTV9JMkhfREVMRVRFX1JTUCA9IEJGQV9JMkhNKDIpLAorCUJGSV9JVE5JTV9JMkhfU0xFUl9FVkVOVCA9IEJGQV9JMkhNKDMpLAorfTsKKworc3RydWN0IGJmaV9pdG5pbV9jcmVhdGVfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJICovCisJdTE2ICAgICAgICBmd19oYW5kbGU7CS8qICBmL3cgaGFuZGxlIGZvciBpdG5pbQkgKi8KKwl1OCAgICAgICAgIGNsYXNzOwkJLyogIEZDIGNsYXNzIGZvciBJTwkJICovCisJdTggICAgICAgICBzZXFfcmVjOwkvKiAgc2VxdWVuY2UgcmVjb3Zlcnkgc3VwcG9ydAkgKi8KKwl1OCAgICAgICAgIG1zZ19ubzsJCS8qICBzZXEgaWQgb2YgdGhlIG1zZwkJICovCit9OworCitzdHJ1Y3QgYmZpX2l0bmltX2NyZWF0ZV9yc3BfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkgKi8KKwl1MTYgICAgICAgIGJmYV9oYW5kbGU7CS8qICBiZmEgaGFuZGxlIGZvciBpdG5pbQkgKi8KKwl1OCAgICAgICAgIHN0YXR1czsJCS8qICBmY3AgcmVxdWVzdCBzdGF0dXMJCSAqLworCXU4ICAgICAgICAgc2VxX2lkOwkJLyogIHNlcSBpZCBvZiB0aGUgbXNnCQkgKi8KK307CisKK3N0cnVjdCBiZmlfaXRuaW1fZGVsZXRlX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSAqLworCXUxNiAgICAgICAgZndfaGFuZGxlOwkvKiAgZi93IGl0bmltIGhhbmRsZQkJICovCisJdTggICAgICAgICBzZXFfaWQ7CQkvKiAgc2VxIGlkIG9mIHRoZSBtc2cJCSAqLworCXU4ICAgICAgICAgcnN2ZDsKK307CisKK3N0cnVjdCBiZmlfaXRuaW1fZGVsZXRlX3JzcF9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSAqLworCXUxNiAgICAgICAgYmZhX2hhbmRsZTsJLyogIGJmYSBoYW5kbGUgZm9yIGl0bmltCSAqLworCXU4ICAgICAgICAgc3RhdHVzOwkJLyogIGZjcCByZXF1ZXN0IHN0YXR1cwkJICovCisJdTggICAgICAgICBzZXFfaWQ7CQkvKiAgc2VxIGlkIG9mIHRoZSBtc2cJCSAqLworfTsKKworc3RydWN0IGJmaV9pdG5pbV9zbGVyX2V2ZW50X3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJICovCisJdTE2ICAgICAgICBiZmFfaGFuZGxlOwkvKiAgYmZhIGhhbmRsZSBmb3IgaXRuaW0JICovCisJdTE2ICAgICAgICByc3ZkOworfTsKKwordW5pb24gYmZpX2l0bmltX2gyaV9tc2dfdSB7CisJc3RydWN0IGJmaV9pdG5pbV9jcmVhdGVfcmVxX3MgKmNyZWF0ZV9yZXE7CisJc3RydWN0IGJmaV9pdG5pbV9kZWxldGVfcmVxX3MgKmRlbGV0ZV9yZXE7CisJc3RydWN0IGJmaV9tc2dfcyAgICAgICptc2c7Cit9OworCit1bmlvbiBiZmlfaXRuaW1faTJoX21zZ191IHsKKwlzdHJ1Y3QgYmZpX2l0bmltX2NyZWF0ZV9yc3BfcyAqY3JlYXRlX3JzcDsKKwlzdHJ1Y3QgYmZpX2l0bmltX2RlbGV0ZV9yc3BfcyAqZGVsZXRlX3JzcDsKKwlzdHJ1Y3QgYmZpX2l0bmltX3NsZXJfZXZlbnRfcyAqc2xlcl9ldmVudDsKKwlzdHJ1Y3QgYmZpX21zZ19zICAgICAgKm1zZzsKK307CisKKy8qCisgKiBJbml0aWF0b3IgbW9kZSBJTyBpbnRlcmZhY2UgZGVmaW5lcy4KKyAqLworCitlbnVtIGJmaV9pb2ltX2gyaSB7CisJQkZJX0lPSU1fSDJJX0lPQUJPUlRfUkVRID0gMSwJLyogIElPIGFib3J0IHJlcXVlc3QJICovCisJQkZJX0lPSU1fSDJJX0lPQ0xFQU5VUF9SRVEgPSAyLAkvKiAgSU8gY2xlYW51cCByZXF1ZXN0CSAqLworfTsKKworZW51bSBiZmlfaW9pbV9pMmggeworCUJGSV9JT0lNX0kySF9JT19SU1AgPSBCRkFfSTJITSgxKSwJLyogIG5vbi1mcCBJTyByZXNwb25zZQkgKi8KKwlCRklfSU9JTV9JMkhfSU9BQk9SVF9SU1AgPSBCRkFfSTJITSgyKSwvKiAgQUJPUlQgcnNwCSAqLworfTsKKworLyoqCisgKiBJTyBjb21tYW5kIERJRiBpbmZvCisgKi8KK3N0cnVjdCBiZmlfaW9pbV9kaWZfcyB7CisJdTMyCWRpZl9pbmZvWzRdOworfTsKKworLyoqCisgKiBGQ1AgSU8gbWVzc2FnZXMgb3ZlcnZpZXcKKyAqCisgKiBAbm90ZQorICogLSBNYXggQ0RCIGxlbmd0aCBzdXBwb3J0ZWQgaXMgNjQgYnl0ZXMuCisgKiAtIFNDU0kgTGlua2VkIGNvbW1hbmRzIGFuZCBTQ1NJIGJpLWRpcmVjdGlvbmFsIENvbW1hbmRzIG5vdAorICogCSBzdXBwb3J0ZWQuCisgKgorICovCitzdHJ1Y3QgYmZpX2lvaW1fcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBDb21tb24gbXNnIGhlYWRlcgkJICovCisJdTE2ICAgICAgICBpb190YWc7CQkvKiAgSS9PIHRhZwkJCSAqLworCXUxNiAgICAgICAgcnBvcnRfaGRsOwkvKiAgaXRuaW0vcnBvcnQgZmlybXdhcmUgaGFuZGxlICovCisJc3RydWN0IGZjcF9jbW5kX3MgY21uZDsJCS8qICBJTyByZXF1ZXN0IGluZm8JCSAqLworCisJLyoqCisJICogU0cgZWxlbWVudHMgYXJyYXkgd2l0aGluIHRoZSBJTyByZXF1ZXN0IG11c3QgYmUgZG91YmxlIHdvcmQKKwkgKiBhbGlnbmVkLiBUaGlzIGFsaWdtZW50IGlzIHJlcXVpcmVkIHRvIG9wdGltaXplIFNHTSBzZXR1cCBmb3IgdGhlIElPLgorCSAqLworCXN0cnVjdCBiZmlfc2dlX3MgICBzZ2VzW0JGSV9TR0VfSU5MSU5FX01BWF07CisJdTggICAgICAgICBpb190aW1lb3V0OworCXU4ICAgICAgICAgZGlmX2VuOworCXU4ICAgICAgICAgcnN2ZF9hWzJdOworCXN0cnVjdCBiZmlfaW9pbV9kaWZfcyAgZGlmOworfTsKKworLyoqCisgKiAJVGhpcyB0YWJsZSBzaG93cyB2YXJpb3VzIElPIHN0YXR1cyBjb2RlcyBmcm9tIGZpcm13YXJlIGFuZCB0aGVpcgorICoJbWVhbmluZy4gSG9zdCBkcml2ZXIgY2FuIHVzZSB0aGVzZSBzdGF0dXMgY29kZXMgdG8gZnVydGhlciBwcm9jZXNzCisgKglJTyBjb21wbGV0aW9ucy4KKyAqCisgKiAJQkZJX0lPSU1fU1RTX09LCQk6IElPIGNvbXBsZXRlZCB3aXRoIGVycm9yIGZyZWUgU0NTSSAmCisgKgkJCQkJICAgdHJhbnNwb3J0IHN0YXR1cy4KKyAqIAkJCQkJICAgLSBpby10YWcgY2FuIGJlIHJldXNlZC4KKyAqCisgKiAJQkZBX0lPSU1fU1RTX1NDU0lfRVJSCQk6IElPIGNvbXBsZXRlZCB3aXRoIHNjc2kgZXJyb3IuCisgKiAJCQkJCSAgLSBpby10YWcgY2FuIGJlIHJldXNlZC4KKyAqCisgKiAJQkZJX0lPSU1fU1RTX0hPU1RfQUJPUlRFRAk6IElPIHdhcyBhYm9ydGVkIHN1Y2Nlc3NmdWxseSBkdWUgdG8KKyAqCQkJCQkgICBob3N0IHJlcXVlc3QuCisgKiAJCQkJCSAgIC0gaW8tdGFnIGNhbm5vdCBiZSByZXVzZWQgeWV0LgorICoKKyAqIAlCRklfSU9JTV9TVFNfQUJPUlRFRAkJOiBJTyB3YXMgYWJvcnRlZCBzdWNjZXNzZnVsbHkKKyAqCQkJCQkgICBpbnRlcm5hbGx5IGJ5IGYvdy4KKyAqIAkJCQkJICAgLSBpby10YWcgY2Fubm90IGJlIHJldXNlZCB5ZXQuCisgKgorICogCUJGSV9JT0lNX1NUU19USU1FRE9VVAk6IElPIHRpbWVkb3V0IGFuZCBBQlRTL1JSUSBpcyBoYXBwZW5pbmcKKyAqCQkJCQkgICBpbiB0aGUgZmlybXdhcmUgYW5kCisgKiAJCQkJCSAgIC0gaW8tdGFnIGNhbm5vdCBiZSByZXVzZWQgeWV0LgorICoKKyAqIAlCRklfSU9JTV9TVFNfU1FFUl9ORUVERUQJOiBGaXJtd2FyZSBjb3VsZCBub3QgcmVjb3ZlciB0aGUgSU8KKyAqCQkJCQkgIHdpdGggc2VxdWVuY2UgbGV2ZWwgZXJyb3IKKyAqIAkJCQkJICBsb2dpYyBhbmQgaGVuY2UgaG9zdCBuZWVkcyB0byByZXRyeQorICoJCQkJCSAgdGhpcyBJTyB3aXRoIGEgZGlmZmVyZW50IElPIHRhZworICogCQkJCQkgIC0gaW8tdGFnIGNhbm5vdCBiZSB1c2VkIHlldC4KKyAqCisgKiAJQkZJX0lPSU1fU1RTX05FWFVTX0FCT1JUCTogU2Vjb25kIExldmVsIEVycm9yIFJlY292ZXJ5IGZyb20gaG9zdAorICoJCQkJCSAgaXMgcmVxdWlyZWQgYmVjYXVzZSAyIGNvbnNlY3V0aXZlIEFCVFMKKyAqCQkJCQkgIHRpbWVkb3V0IGFuZCBob3N0IG5lZWRzIGxvZ291dCBhbmQKKyAqCQkJCQkgIHJlLWxvZ2luIHdpdGggdGhlIHRhcmdldAorICogCQkJCQkgIC0gaW8tdGFnIGNhbm5vdCBiZSB1c2VkIHlldC4KKyAqCisgKiAJQkZJX0lPSU1fU1RTX1VOREVSUlVOCTogSU8gY29tcGxldGVkIHdpdGggU0NTSSBzdGF0dXMgZ29vZCwKKyAqCQkJCQkgIGJ1dCB0aGUgZGF0YSB0cmFuZmVycmVkIGlzIGxlc3MgdGhhbgorICoJCQkJCSAgdGhlIGZjcCBkYXRhIGxlbmd0aCBpbiB0aGUgY29tbWFuZC4KKyAqCQkJCQkgIGV4LiBTQ1NJIElOUVVJUlkgd2hlcmUgdHJhbnNmZXJyZWQKKyAqCQkJCQkgIGRhdGEgbGVuZ3RoIGFuZCByZXNpZHVlIGNvdW50IGluIEZDUAorICoJCQkJCSAgcmVzcG9uc2UgYWNjb3VudHMgZm9yIHRvdGFsIGZjcC1kbAorICogCQkJCQkgIC0gaW8tdGFnIGNhbiBiZSByZXVzZWQuCisgKgorICogCUJGSV9JT0lNX1NUU19PVkVSUlVOCTogSU8gY29tcGxldGVkIHdpdGggU0NTSSBzdGF0dXMgZ29vZCwKKyAqCQkJCQkgIGJ1dCB0aGUgZGF0YSB0cmFuc2VycmVkIGlzIG1vcmUgdGhhbgorICoJCQkJCSAgZmNwIGRhdGEgbGVuZ3RoIGluIHRoZSBjb21tYW5kLiBleC4KKyAqCQkJCQkgIFRBUEUgSU9zIHdoZXJlIGJsb2NrcyBjYW4gb2YgdW5lcXVhbAorICoJCQkJCSAgbGVuZ3Rocy4KKyAqIAkJCQkJICAtIGlvLXRhZyBjYW4gYmUgcmV1c2VkLgorICoKKyAqIAlCRklfSU9JTV9TVFNfUkVTX0ZSRUUJOiBGaXJtd2FyZSBoYXMgY29tcGxldGVkIHVzaW5nIGlvLXRhZworICoJCQkJCSAgZHVyaW5nIGFib3J0IHByb2Nlc3MKKyAqIAkJCQkJICAtIGlvLXRhZyBjYW4gYmUgcmV1c2VkLgorICoKKyAqIAlCRklfSU9JTV9TVFNfUFJPVE9fRVJSCTogRmlybXdhcmUgZGV0ZWN0ZWQgYSBwcm90b2NvbCBlcnJvci4KKyAqCQkJCQkgIGV4IHRhcmdldCBzZW50IG1vcmUgZGF0YSB0aGFuCisgKgkJCQkJICByZXF1ZXN0ZWQsIG9yIHRoZXJlIHdhcyBkYXRhIGZyYW1lCisgKgkJCQkJICBsb3NzIGFuZCBvdGhlciByZWFzb25zCisgKiAJCQkJCSAgLSBpby10YWcgY2Fubm90IGJlIHVzZWQgeWV0LgorICoKKyAqIAlCRklfSU9JTV9TVFNfRElGX0VSUgk6IEZpcndtYXJlIGRldGVjdGVkIERJRiBlcnJvci4gZXg6IERJRgorICogCQkJCQkgIENSQyBlcnIgb3IgUmVmIFRhZyBlcnIgb3IgQXBwIHRhZyBlcnIuCisgKiAJCQkJCSAgLSBpby10YWcgY2FuIGJlIHJldXNlZC4KKyAqCisgKiAJQkZBX0lPSU1fU1RTX1RTS19NR1RfQUJPUlQJOiBJTyB3YXMgYWJvcnRlZCBiZWNhdXNlIG9mIFRhc2sKKyAqCQkJCQkgIE1hbmFnZW1lbnQgY29tbWFuZCBmcm9tIHRoZSBob3N0CisgKiAJCQkJCSAgLSBpby10YWcgY2FuIGJlIHJldXNlZC4KKyAqCisgKiAJQkZJX0lPSU1fU1RTX1VUQUcJCTogRmlybXdhcmUgZG9lcyBub3Qga25vdyBhYm91dCB0aGlzCisgKgkJCQkJICBpb190YWcuCisgKiAJCQkJCSAgLSBpby10YWcgY2FuIGJlIHJldXNlZC4KKyAqLworZW51bSBiZmlfaW9pbV9zdGF0dXMgeworCUJGSV9JT0lNX1NUU19PSyA9IDAsCisJQkZJX0lPSU1fU1RTX0hPU1RfQUJPUlRFRCA9IDEsCisJQkZJX0lPSU1fU1RTX0FCT1JURUQgPSAyLAorCUJGSV9JT0lNX1NUU19USU1FRE9VVCA9IDMsCisJQkZJX0lPSU1fU1RTX1JFU19GUkVFID0gNCwKKwlCRklfSU9JTV9TVFNfU1FFUl9ORUVERUQgPSA1LAorCUJGSV9JT0lNX1NUU19QUk9UT19FUlIgPSA2LAorCUJGSV9JT0lNX1NUU19VVEFHID0gNywKKwlCRklfSU9JTV9TVFNfUEFUSFRPViA9IDgsCit9OworCisjZGVmaW5lIEJGSV9JT0lNX1NOU0xFTgkoMjU2KQorLyoqCisgKiBJL08gcmVzcG9uc2UgbWVzc2FnZQorICovCitzdHJ1Y3QgYmZpX2lvaW1fcnNwX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkgCSAqLworCXUxNiAgICAgICAgaW9fdGFnOwkJLyogIGNvbXBsZXRlZCBJTyB0YWcJCSAqLworCXUxNiAgICAgICAgYmZhX3Jwb3J0X2huZGw7CS8qICByZWxlYXRlZCBycG9ydCBoYW5kbGUJICovCisJdTggICAgICAgICBpb19zdGF0dXM7CS8qICBJTyBjb21wbGV0aW9uIHN0YXR1cwkgKi8KKwl1OCAgICAgICAgIHJldXNlX2lvX3RhZzsJLyogIElPIHRhZyBjYW4gYmUgcmV1c2VkICAgICAgICAqLworCXUxNglhYm9ydF90YWc7CS8qICBob3N0IGFib3J0IHJlcXVlc3QgdGFnICAgICAgKi8KKwl1OAkJc2NzaV9zdGF0dXM7CS8qICBzY3NpIHN0YXR1cyBmcm9tIHRhcmdldAkgKi8KKwl1OAkJc25zX2xlbjsJLyogIHNjc2kgc2Vuc2UgbGVuZ3RoCQkgKi8KKwl1OAkJcmVzaWRfZmxhZ3M7CS8qICBJTyByZXNpZHVlIGZsYWdzCQkgKi8KKwl1OAkJcnN2ZF9hOworCXUzMglyZXNpZHVlOwkvKiAgSU8gcmVzaWR1YWwgbGVuZ3RoIGluIGJ5dGVzICovCisJdTMyCXJzdmRfYlszXTsKK307CisKK3N0cnVjdCBiZmlfaW9pbV9hYm9ydF9yZXFfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOyAgICAgICAgICAvKiAgQ29tbW9uIG1zZyBoZWFkZXIgICovCisJdTE2ICAgICAgICBpb190YWc7ICAgICAgICAgLyogIEkvTyB0YWcgICAgICAgICAgICAqLworCXUxNiAgICAgICAgYWJvcnRfdGFnOyAgICAgIC8qICB1bmlxdWUgcmVxdWVzdCB0YWcgKi8KK307CisKKy8qCisgKiBJbml0aWF0b3IgbW9kZSB0YXNrIG1hbmFnZW1lbnQgY29tbWFuZCBpbnRlcmZhY2UgZGVmaW5lcy4KKyAqLworCitlbnVtIGJmaV90c2tpbV9oMmkgeworCUJGSV9UU0tJTV9IMklfVE1fUkVRICAgID0gMSwgLyogIHRhc2stbWdtdCBjb21tYW5kICAgICAgICAgKi8KKwlCRklfVFNLSU1fSDJJX0FCT1JUX1JFUSA9IDIsIC8qICB0YXNrLW1nbXQgY29tbWFuZCAgICAgICAgICovCit9OworCitlbnVtIGJmaV90c2tpbV9pMmggeworCUJGSV9UU0tJTV9JMkhfVE1fUlNQID0gQkZBX0kySE0oMSksCit9OworCitzdHJ1Y3QgYmZpX3Rza2ltX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7ICAgICAgICAgICAgIC8qICBDb21tb24gbXNnIGhlYWRlciAgICAgICAgICAqLworCXUxNiAgICAgICAgdHNrX3RhZzsgICAgICAgIC8qICB0YXNrIG1hbmFnZW1lbnQgdGFnICAgICAgICAqLworCXUxNiAgICAgICAgaXRuX2ZoZGw7ICAgICAgIC8qICBpdG4gZmlybXdhcmUgaGFuZGxlICAgICAgICAqLworCWx1bl90ICAgICAgICAgICBsdW47ICAgICAgICAgICAgLyogIExVIG51bWJlciAgICAgICAgICAgICAgICAgICovCisJdTggICAgICAgICB0bV9mbGFnczsgICAgICAgLyogIHNlZSBmY3BfdG1fY21uZF90ICAgICAgICAgICovCisJdTggICAgICAgICB0X3NlY3M7ICAgICAgICAgLyogIFRpbWVvdXQgdmFsdWUgaW4gc2Vjb25kcyAgICovCisJdTggICAgICAgICByc3ZkWzJdOworfTsKKworc3RydWN0IGJmaV90c2tpbV9hYm9ydHJlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7ICAgICAgICAgICAgIC8qICBDb21tb24gbXNnIGhlYWRlciAgICAgICAgICAqLworCXUxNiAgICAgICAgdHNrX3RhZzsgICAgICAgIC8qICB0YXNrIG1hbmFnZW1lbnQgdGFnICAgICAgICAqLworCXUxNiAgICAgICAgcnN2ZDsKK307CisKK2VudW0gYmZpX3Rza2ltX3N0YXR1cyB7CisJLyoKKwkgKiBGb2xsb3dpbmcgYXJlIEZDUC00IHNwZWMgZGVmaW5lZCBzdGF0dXMgY29kZXMsCisJICogKipETyBOT1QgQ0hBTkdFIFRIRU0gKioKKwkgKi8KKwlCRklfVFNLSU1fU1RTX09LICAgICAgID0gMCwKKwlCRklfVFNLSU1fU1RTX05PVF9TVVBQID0gNCwKKwlCRklfVFNLSU1fU1RTX0ZBSUxFRCAgID0gNSwKKworCS8qKgorCSAqIERlZmluZWQgYnkgQkZBCisJICovCisJQkZJX1RTS0lNX1NUU19USU1FT1VUICA9IDEwLCAgICAvKiAgVE0gcmVxdWVzdCB0aW1lZG91dCAgICAgKi8KKwlCRklfVFNLSU1fU1RTX0FCT1JURUQgID0gMTEsICAgIC8qICBBYm9ydGVkIG9uIGhvc3QgcmVxdWVzdCAqLworfTsKKworc3RydWN0IGJmaV90c2tpbV9yc3BfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIENvbW1vbiBtc2cgaGVhZGVyCQkgKi8KKwl1MTYgICAgICAgIHRza190YWc7CS8qICB0YXNrIG1nbXQgY21uZCB0YWcJCSAqLworCXU4ICAgICAgICAgdHNrX3N0YXR1czsJLyogIEByZWYgYmZpX3Rza2ltX3N0YXR1cyAqLworCXU4ICAgICAgICAgcnN2ZDsKK307CisKKyNwcmFnbWEgcGFjaygpCisKKyNlbmRpZiAvKiBfX0JGSV9GQ1BJTV9IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfZmN4cC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfZmN4cC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUwZTk5NWEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9mY3hwLmgKQEAgLTAsMCArMSw3MSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZJX0ZDWFBfSF9fCisjZGVmaW5lIF9fQkZJX0ZDWFBfSF9fCisKKyNpbmNsdWRlICJiZmkuaCIKKworI3ByYWdtYSBwYWNrKDEpCisKK2VudW0gYmZpX2ZjeHBfaDJpIHsKKwlCRklfRkNYUF9IMklfU0VORF9SRVEgPSAxLAorfTsKKworZW51bSBiZmlfZmN4cF9pMmggeworCUJGSV9GQ1hQX0kySF9TRU5EX1JTUCA9IEJGQV9JMkhNKDEpLAorfTsKKworI2RlZmluZSBCRkFfRkNYUF9NQVhfU0dFUwkyCisKKy8qKgorICogRkNYUCBzZW5kIHJlcXVlc3Qgc3RydWN0dXJlCisgKi8KK3N0cnVjdCBiZmlfZmN4cF9zZW5kX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgQ29tbW9uIG1zZyBoZWFkZXIJCSAgICAqLworCXUxNiAgICAgICAgZmN4cF90YWc7CS8qICBkcml2ZXIgcmVxdWVzdCB0YWcJCSAgICAqLworCXUxNiAgICAgICAgbWF4X2ZybXN6OwkvKiAgbWF4IHNlbmQgZnJhbWUgc2l6ZQkgICAgKi8KKwl1MTYgICAgICAgIHZmX2lkOwkJLyogIHZzYW4gdGFnIGlmIGFwcGxpY2FibGUJICAgICovCisJdTE2ICAgICAgICBycG9ydF9md19obmRsOwkvKiAgRlcgSGFuZGxlIGZvciB0aGUgcmVtb3RlIHBvcnQgICovCisJdTggICAgICAgICBjbGFzczsJCS8qICBGQyBjbGFzcyB1c2VkIGZvciByZXEvcnNwCSAgICAqLworCXU4ICAgICAgICAgcnNwX3RpbWVvdXQ7CS8qICB0aW1lb3V0IGluIHNlY3MsIDAtbm8gcmVzcG9uc2UgKi8KKwl1OCAgICAgICAgIGN0czsJCS8qICBjb250aW51ZSBzZXF1ZW5jZQkJICAgICovCisJdTggICAgICAgICBscF90YWc7CQkvKiAgbHBvcnQgdGFnCQkJICAgICovCisJc3RydWN0IGZjaHNfcyAgIGZjaHM7CQkvKiAgcmVxdWVzdCBGQyBoZWFkZXIgc3RydWN0dXJlICAgICovCisJdTMyICAgICAgICByZXFfbGVuOwkvKiAgcmVxdWVzdCBwYXlsb2FkIGxlbmd0aAkgICAgKi8KKwl1MzIgICAgICAgIHJzcF9tYXhsZW47CS8qICBtYXggcmVzcG9uc2UgbGVuZ3RoIGV4cGVjdGVkICAgKi8KKwlzdHJ1Y3QgYmZpX3NnZV9zICAgcmVxX3NnZVtCRkFfRkNYUF9NQVhfU0dFU107CS8qICByZXF1ZXN0IGJ1ZiAgICAqLworCXN0cnVjdCBiZmlfc2dlX3MgICByc3Bfc2dlW0JGQV9GQ1hQX01BWF9TR0VTXTsJLyogIHJlc3BvbnNlIGJ1ZiAgICovCit9OworCisvKioKKyAqIEZDWFAgc2VuZCByZXNwb25zZSBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGJmaV9mY3hwX3NlbmRfcnNwX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBDb21tb24gbXNnIGhlYWRlcgkJICAgICovCisJdTE2ICAgICAgICBmY3hwX3RhZzsJLyogIHNlbmQgcmVxdWVzdCB0YWcJCSAgICAqLworCXU4ICAgICAgICAgcmVxX3N0YXR1czsJLyogIHJlcXVlc3Qgc3RhdHVzCQkgICAgKi8KKwl1OCAgICAgICAgIHJzdmQ7CisJdTMyICAgICAgICByc3BfbGVuOwkvKiAgYWN0dWFsIHJlc3BvbnNlIGxlbmd0aAkgICAgKi8KKwl1MzIgICAgICAgIHJlc2lkdWVfbGVuOwkvKiAgcmVzaWR1YWwgcmVzcG9uc2UgbGVuZ3RoCSAgICAqLworCXN0cnVjdCBmY2hzX3MgICBmY2hzOwkJLyogIHJlc3BvbnNlIEZDIGhlYWRlciBzdHJ1Y3R1cmUgICAqLworfTsKKworI3ByYWdtYSBwYWNrKCkKKworI2VuZGlmIC8qIF9fQkZJX0ZDWFBfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2lvYy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfaW9jLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDI2ZTljMAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2lvYy5oCkBAIC0wLDAgKzEsMjAyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRklfSU9DX0hfXworI2RlZmluZSBfX0JGSV9JT0NfSF9fCisKKyNpbmNsdWRlICJiZmkuaCIKKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX2lvYy5oPgorCisjcHJhZ21hIHBhY2soMSkKKworZW51bSBiZmlfaW9jX2gyaV9tc2dzIHsKKwlCRklfSU9DX0gySV9FTkFCTEVfUkVRIAkJPSAxLAorCUJGSV9JT0NfSDJJX0RJU0FCTEVfUkVRIAk9IDIsCisJQkZJX0lPQ19IMklfR0VUQVRUUl9SRVEgCT0gMywKKwlCRklfSU9DX0gySV9EQkdfU1lOQwkgCT0gNCwKKwlCRklfSU9DX0gySV9EQkdfRFVNUAkgCT0gNSwKK307CisKK2VudW0gYmZpX2lvY19pMmhfbXNncyB7CisJQkZJX0lPQ19JMkhfRU5BQkxFX1JFUExZCT0gQkZBX0kySE0oMSksCisJQkZJX0lPQ19JMkhfRElTQUJMRV9SRVBMWSAJPSBCRkFfSTJITSgyKSwKKwlCRklfSU9DX0kySF9HRVRBVFRSX1JFUExZIAk9IEJGQV9JMkhNKDMpLAorCUJGSV9JT0NfSTJIX1JFQURZX0VWRU5UIAk9IEJGQV9JMkhNKDQpLAorCUJGSV9JT0NfSTJIX0hCRUFUCQk9IEJGQV9JMkhNKDUpLAorfTsKKworLyoqCisgKiBCRklfSU9DX0gySV9HRVRBVFRSX1JFUSBtZXNzYWdlCisgKi8KK3N0cnVjdCBiZmlfaW9jX2dldGF0dHJfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zCW1oOworCXVuaW9uIGJmaV9hZGRyX3UJYXR0cl9hZGRyOworfTsKKworc3RydWN0IGJmaV9pb2NfYXR0cl9zIHsKKwl3d25fdCAgICAgICAgICAgbWZnX3d3bjsKKwltYWNfdAkJbWZnX21hYzsKKwl1MTYJcnN2ZF9hOworCWNoYXIgICAgICAgICAgICBicmNkX3NlcmlhbG51bVtTVFJTWihCRkFfTUZHX1NFUklBTE5VTV9TSVpFKV07CisJdTggICAgICAgICBwY2llX2dlbjsKKwl1OCAgICAgICAgIHBjaWVfbGFuZXNfb3JpZzsKKwl1OCAgICAgICAgIHBjaWVfbGFuZXM7CisJdTggICAgICAgICByeF9iYmNyZWRpdDsJLyogIHJlY2VpdmUgYnVmZmVyIGNyZWRpdHMgKi8KKwl1MzIgICAgICAgIGFkYXB0ZXJfcHJvcDsJLyogIGFkYXB0ZXIgcHJvcGVydGllcyAgICAgKi8KKwl1MTYgICAgICAgIG1heGZyc2l6ZTsJLyogIG1heCByZWNlaXZlIGZyYW1lIHNpemUgKi8KKwljaGFyICAgICAgICAgCWFzaWNfcmV2OworCXU4ICAgICAgICAgcnN2ZF9iOworCWNoYXIgICAgICAgICAgICBmd192ZXJzaW9uW0JGQV9WRVJTSU9OX0xFTl07CisJY2hhciAgICAgICAgICAgIG9wdHJvbV92ZXJzaW9uW0JGQV9WRVJTSU9OX0xFTl07CisJc3RydWN0IGJmYV9tZmdfdnBkX3MJdnBkOworfTsKKworLyoqCisgKiBCRklfSU9DX0kySF9HRVRBVFRSX1JFUExZIG1lc3NhZ2UKKyAqLworc3RydWN0IGJmaV9pb2NfZ2V0YXR0cl9yZXBseV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgQ29tbW9uIG1zZyBoZWFkZXIgICAgICAgICAgKi8KKwl1OAkJc3RhdHVzOwkvKiAgY2ZnIHJlcGx5IHN0YXR1cyAgICAgICAgICAgKi8KKwl1OAkJcnN2ZFszXTsKK307CisKKy8qKgorICogRmlybXdhcmUgbWVtb3J5IHBhZ2Ugb2Zmc2V0cworICovCisjZGVmaW5lIEJGSV9JT0NfU01FTV9QRzBfQ0IJKDB4NDApCisjZGVmaW5lIEJGSV9JT0NfU01FTV9QRzBfQ1QJKDB4MTgwKQorCisvKioKKyAqIEZpcm13YXJlIHRyYWNlIG9mZnNldAorICovCisjZGVmaW5lIEJGSV9JT0NfVFJDX09GRgkJKDB4NGIwMCkKKyNkZWZpbmUgQkZJX0lPQ19UUkNfRU5UUwkyNTYKKworI2RlZmluZSBCRklfSU9DX0ZXX1NJR05BVFVSRQkoMHhiZmFkYmZhZCkKKyNkZWZpbmUgQkZJX0lPQ19NRDVTVU1fU1oJNAorc3RydWN0IGJmaV9pb2NfaW1hZ2VfaGRyX3MgeworCXUzMiAgICAgICAgc2lnbmF0dXJlOwkvKiAgY29uc3RhbnQgc2lnbmF0dXJlICovCisJdTMyICAgICAgICByc3ZkX2E7CisJdTMyICAgICAgICBleGVjOwkJLyogIGV4ZWMgdmVjdG9yICAgICAgICAqLworCXUzMiAgICAgICAgcGFyYW07CQkvKiAgcGFyYW1ldGVycyAgICAgICAgICovCisJdTMyICAgICAgICByc3ZkX2JbNF07CisJdTMyICAgICAgICBtZDVzdW1bQkZJX0lPQ19NRDVTVU1fU1pdOworfTsKKworLyoqCisgKiAgQkZJX0lPQ19JMkhfUkVBRFlfRVZFTlQgbWVzc2FnZQorICovCitzdHJ1Y3QgYmZpX2lvY19yZHlfZXZlbnRfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJCS8qICBjb21tb24gbXNnIGhlYWRlciAqLworCXU4ICAgICAgICAgaW5pdF9zdGF0dXM7CS8qICBpbml0IGV2ZW50IHN0YXR1cyAqLworCXU4ICAgICAgICAgcnN2ZFszXTsKK307CisKK3N0cnVjdCBiZmlfaW9jX2hiZWF0X3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1MzIJICAgaGJfY291bnQ7CS8qICBjdXJyZW50IGhlYXJ0IGJlYXQgY291bnQJKi8KK307CisKKy8qKgorICogSU9DIGhhcmR3YXJlL2Zpcm13YXJlIHN0YXRlCisgKi8KK2VudW0gYmZpX2lvY19zdGF0ZSB7CisJQkZJX0lPQ19VTklOSVQgCSA9IDAsCQkvKiAgbm90IGluaXRpYWxpemVkICAgICAgICAgICAgICAgICAqLworCUJGSV9JT0NfSU5JVElORyAJID0gMSwJLyogIGgvdyBpcyBiZWluZyBpbml0aWFsaXplZCAgICAgICAgKi8KKwlCRklfSU9DX0hXSU5JVCAJID0gMiwJCS8qICBoL3cgaXMgaW5pdGlhbGl6ZWQgICAgICAgICAgICAgICovCisJQkZJX0lPQ19DRkcgCSA9IDMsCQkvKiAgSU9DIGNvbmZpZ3VyYXRpb24gaW4gcHJvZ3Jlc3MgICAqLworCUJGSV9JT0NfT1AgCQkgPSA0LAkvKiAgSU9DIGlzIG9wZXJhdGlvbmFsICAgICAgICAgICAgICAqLworCUJGSV9JT0NfRElTQUJMSU5HIAkgPSA1LAkvKiAgSU9DIGlzIGJlaW5nIGRpc2FibGVkICAgICAgICAgICAqLworCUJGSV9JT0NfRElTQUJMRUQgCSA9IDYsCS8qICBJT0MgaXMgZGlzYWJsZWQgICAgICAgICAgICAgICAgICovCisJQkZJX0lPQ19DRkdfRElTQUJMRUQgPSA3LAkvKiAgSU9DIGlzIGJlaW5nIGRpc2FibGVkO3RyYW5zaWVudCAqLworCUJGSV9JT0NfSEJGQUlMICAgICAgID0gOCwJLyogIElPQyBoZWFydC1iZWF0IGZhaWx1cmUgICAgICAgICAgKi8KKwlCRklfSU9DX01FTVRFU1QgICAgICA9IDksCS8qICBJT0MgaXMgZG9pbmcgbWVtdGVzdCAgICAgICAgICAgICovCit9OworCisjZGVmaW5lIEJGSV9JT0NfRU5ESUFOX1NJRyAgMHgxMjM0NTY3OAorCitlbnVtIHsKKwlCRklfQURBUFRFUl9UWVBFX0ZDICAgPSAweDAxLAkJLyogIEZDIGFkYXB0ZXJzICAgICAgICAgICAqLworCUJGSV9BREFQVEVSX1RZUEVfTUsgICA9IDB4MGYwMDAwLAkvKiAgYWRhcHRlciB0eXBlIG1hc2sgICAgICovCisJQkZJX0FEQVBURVJfVFlQRV9TSCAgID0gMTYsCSAgICAgICAgLyogIGFkYXB0ZXIgdHlwZSBzaGlmdCAgICAqLworCUJGSV9BREFQVEVSX05QT1JUU19NSyA9IDB4ZmYwMCwJCS8qICBudW1iZXIgb2YgcG9ydHMgbWFzayAgKi8KKwlCRklfQURBUFRFUl9OUE9SVFNfU0ggPSA4LAkgICAgICAgIC8qICBudW1iZXIgb2YgcG9ydHMgc2hpZnQgKi8KKwlCRklfQURBUFRFUl9TUEVFRF9NSyAgPSAweGZmLAkJLyogIGFkYXB0ZXIgc3BlZWQgbWFzayAgICAqLworCUJGSV9BREFQVEVSX1NQRUVEX1NIICA9IDAsCSAgICAgICAgLyogIGFkYXB0ZXIgc3BlZWQgc2hpZnQgICAqLworCUJGSV9BREFQVEVSX1BST1RPICAgICA9IDB4MTAwMDAwLAkvKiAgcHJvdG90eXBlIGFkYXBhdGVycyAgICovCisJQkZJX0FEQVBURVJfVFRWICAgICAgID0gMHgyMDAwMDAsCS8qICBUVFYgZGVidWcgY2FwYWJsZSAgICAgKi8KKwlCRklfQURBUFRFUl9VTlNVUFAgICAgPSAweDQwMDAwMCwJLyogIHVua25vd24gYWRhcHRlciB0eXBlICAqLworfTsKKworI2RlZmluZSBCRklfQURBUFRFUl9HRVRQKF9fcHJvcCxfX2FkYXBfcHJvcCkgICAgICAgICAgCQlcCisgICAgKCgoX19hZGFwX3Byb3ApICYgQkZJX0FEQVBURVJfICMjIF9fcHJvcCAjIyBfTUspID4+ICAgICAgICAgXAorICAgICBCRklfQURBUFRFUl8gIyMgX19wcm9wICMjIF9TSCkKKyNkZWZpbmUgQkZJX0FEQVBURVJfU0VUUChfX3Byb3AsIF9fdmFsKSAgICAgICAgIAkJXAorICAgICgoX192YWwpIDw8IEJGSV9BREFQVEVSXyAjIyBfX3Byb3AgIyMgX1NIKQorI2RlZmluZSBCRklfQURBUFRFUl9JU19QUk9UTyhfX2FkYXBfdHlwZSkgICAJCQlcCisgICAgKChfX2FkYXBfdHlwZSkgJiBCRklfQURBUFRFUl9QUk9UTykKKyNkZWZpbmUgQkZJX0FEQVBURVJfSVNfVFRWKF9fYWRhcF90eXBlKSAgICAgCQkJXAorICAgICgoX19hZGFwX3R5cGUpICYgQkZJX0FEQVBURVJfVFRWKQorI2RlZmluZSBCRklfQURBUFRFUl9JU19VTlNVUFAoX19hZGFwX3R5cGUpICAJCQlcCisgICAgKChfX2FkYXBfdHlwZSkgJiBCRklfQURBUFRFUl9VTlNVUFApCisjZGVmaW5lIEJGSV9BREFQVEVSX0lTX1NQRUNJQUwoX19hZGFwX3R5cGUpICAgICAgICAgICAgICAgICAgICAgXAorICAgICgoX19hZGFwX3R5cGUpICYgKEJGSV9BREFQVEVSX1RUViB8IEJGSV9BREFQVEVSX1BST1RPIHwgICAgIFwKKwkJCUJGSV9BREFQVEVSX1VOU1VQUCkpCisKKy8qKgorICogQkZJX0lPQ19IMklfRU5BQkxFX1JFUSAmIEJGSV9JT0NfSDJJX0RJU0FCTEVfUkVRIG1lc3NhZ2VzCisgKi8KK3N0cnVjdCBiZmlfaW9jX2N0cmxfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zCW1oOworCXU4CQkJaW9jX2NsYXNzOworCXU4ICAgICAgICAgCXJzdmRbM107Cit9OworCisvKioKKyAqIEJGSV9JT0NfSTJIX0VOQUJMRV9SRVBMWSAmIEJGSV9JT0NfSTJIX0RJU0FCTEVfUkVQTFkgbWVzc2FnZXMKKyAqLworc3RydWN0IGJmaV9pb2NfY3RybF9yZXBseV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgQ29tbW9uIG1zZyBoZWFkZXIgICAgICovCisJdTggICAgICAgICBzdGF0dXM7CQkvKiAgZW5hYmxlL2Rpc2FibGUgc3RhdHVzICovCisJdTggICAgICAgICByc3ZkWzNdOworfTsKKworI2RlZmluZSBCRklfSU9DX01TR1NaICAgOAorLyoqCisgKiBIMkkgTWVzc2FnZXMKKyAqLwordW5pb24gYmZpX2lvY19oMmlfbXNnX3UgeworCXN0cnVjdCBiZmlfbWhkcl9zIAltaDsKKwlzdHJ1Y3QgYmZpX2lvY19jdHJsX3JlcV9zIGVuYWJsZV9yZXE7CisJc3RydWN0IGJmaV9pb2NfY3RybF9yZXFfcyBkaXNhYmxlX3JlcTsKKwlzdHJ1Y3QgYmZpX2lvY19nZXRhdHRyX3JlcV9zIGdldGF0dHJfcmVxOworCXUzMiAgICAgICAJCW1ib3htc2dbQkZJX0lPQ19NU0dTWl07Cit9OworCisvKioKKyAqIEkySCBNZXNzYWdlcworICovCit1bmlvbiBiZmlfaW9jX2kyaF9tc2dfdSB7CisJc3RydWN0IGJmaV9taGRyX3MgICAgICAJbWg7CisJc3RydWN0IGJmaV9pb2NfcmR5X2V2ZW50X3MgCXJkeV9ldmVudDsKKwl1MzIgICAgICAgCQltYm94bXNnW0JGSV9JT0NfTVNHU1pdOworfTsKKworI3ByYWdtYSBwYWNrKCkKKworI2VuZGlmIC8qIF9fQkZJX0lPQ19IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfaW9jZmMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2lvY2ZjLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzM3NjBkZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2lvY2ZjLmgKQEAgLTAsMCArMSwxNzcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGSV9JT0NGQ19IX18KKyNkZWZpbmUgX19CRklfSU9DRkNfSF9fCisKKyNpbmNsdWRlICJiZmkuaCIKKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX2lvYy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfaW9jZmMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX2Jvb3QuaD4KKworI3ByYWdtYSBwYWNrKDEpCisKK2VudW0gYmZpX2lvY2ZjX2gyaV9tc2dzIHsKKwlCRklfSU9DRkNfSDJJX0NGR19SRVEgCQk9IDEsCisJQkZJX0lPQ0ZDX0gySV9HRVRfU1RBVFNfUkVRIAk9IDIsCisJQkZJX0lPQ0ZDX0gySV9DTEVBUl9TVEFUU19SRVEJPSAzLAorCUJGSV9JT0NGQ19IMklfU0VUX0lOVFJfUkVRIAk9IDQsCisJQkZJX0lPQ0ZDX0gySV9VUERBVEVRX1JFUSA9IDUsCit9OworCitlbnVtIGJmaV9pb2NmY19pMmhfbXNncyB7CisJQkZJX0lPQ0ZDX0kySF9DRkdfUkVQTFkJCT0gQkZBX0kySE0oMSksCisJQkZJX0lPQ0ZDX0kySF9HRVRfU1RBVFNfUlNQIAk9IEJGQV9JMkhNKDIpLAorCUJGSV9JT0NGQ19JMkhfQ0xFQVJfU1RBVFNfUlNQCT0gQkZBX0kySE0oMyksCisJQkZJX0lPQ0ZDX0kySF9VUERBVEVRX1JTUCA9IEJGQV9JMkhNKDUpLAorfTsKKworc3RydWN0IGJmaV9pb2NmY19jZmdfcyB7CisJdTggICAgICAgICBudW1fY3FzOyAJLyogIE51bWJlciBvZiBDUXMgdG8gYmUgdXNlZCAgICAgKi8KKwl1OCAgICAgICAgIHNlbnNlX2J1Zl9sZW47CS8qICBTQ1NJIHNlbnNlIGxlbmd0aCAgICAgICAgICAgICovCisJdTggICAgICAgICB0cnVua19lbmFibGVkOwkvKiAgcG9ydCB0cnVua2luZyBlbmFibGVkICAgICAgICAqLworCXU4ICAgICAgICAgdHJ1bmtfcG9ydHM7CS8qICB0cnVuayBwb3J0cyBiaXQgbWFwICAgICAgICAgICovCisJdTMyICAgICAgICBlbmRpYW5fc2lnOwkvKiAgZW5kaWFuIHNpZ25hdHVyZSBvZiBob3N0ICAgICAqLworCisJLyoqCisJICogUmVxdWVzdCBhbmQgcmVzcG9uc2UgY2lyY3VsYXIgcXVldWUgYmFzZSBhZGRyZXNzZXMsIHNpemUgYW5kCisJICogc2hhZG93IGluZGV4IHBvaW50ZXJzLgorCSAqLworCXVuaW9uIGJmaV9hZGRyX3UgIHJlcV9jcV9iYVtCRklfSU9DX01BWF9DUVNdOworCXVuaW9uIGJmaV9hZGRyX3UgIHJlcV9zaGFkb3dfY2lbQkZJX0lPQ19NQVhfQ1FTXTsKKwl1MTYgICAgcmVxX2NxX2VsZW1zW0JGSV9JT0NfTUFYX0NRU107CisJdW5pb24gYmZpX2FkZHJfdSAgcnNwX2NxX2JhW0JGSV9JT0NfTUFYX0NRU107CisJdW5pb24gYmZpX2FkZHJfdSAgcnNwX3NoYWRvd19waVtCRklfSU9DX01BWF9DUVNdOworCXUxNiAgICByc3BfY3FfZWxlbXNbQkZJX0lPQ19NQVhfQ1FTXTsKKworCXVuaW9uIGJmaV9hZGRyX3UgIHN0YXRzX2FkZHI7CS8qICBETUEtYWJsZSBhZGRyZXNzIGZvciBzdGF0cwkgICovCisJdW5pb24gYmZpX2FkZHJfdSAgY2ZncnNwX2FkZHI7CS8qICBjb25maWcgcmVzcG9uc2UgZG1hIGFkZHJlc3MgICovCisJdW5pb24gYmZpX2FkZHJfdSAgaW9pbV9zbnNiYXNlOyAgLyogIElPIHNlbnNlIGJ1ZmZlciBiYXNlIGFkZHJlc3MgKi8KKwlzdHJ1Y3QgYmZhX2lvY2ZjX2ludHJfYXR0cl9zIGludHJfYXR0cjsgLyogIElPQyBpbnRlcnJ1cHQgYXR0cmlidXRlcyAqLworfTsKKworLyoqCisgKiBCb290IHRhcmdldCB3d24gaW5mb3JtYXRpb24gZm9yIHRoaXMgcG9ydC4gVGhpcyBjb250YWlucyBlaXRoZXIgdGhlIHN0b3JlZAorICogb3IgZGlzY292ZXJlZCBib290IHRhcmdldCBwb3J0IHd3bnMgZm9yIHRoZSBwb3J0LgorICovCitzdHJ1Y3QgYmZpX2lvY2ZjX2Jvb3R3d25zIHsKKwl3d25fdAkJd3duW0JGQV9CT09UX0JPT1RMVU5fTUFYXTsKKwl1OAkJbnd3bnM7CisJdTgJCXJzdmRbN107Cit9OworCitzdHJ1Y3QgYmZpX2lvY2ZjX2NmZ3JzcF9zIHsKKwlzdHJ1Y3QgYmZhX2lvY2ZjX2Z3Y2ZnX3MJZndjZmc7CisJc3RydWN0IGJmYV9pb2NmY19pbnRyX2F0dHJfcwlpbnRyX2F0dHI7CisJc3RydWN0IGJmaV9pb2NmY19ib290d3ducwlib290d3duczsKK307CisKKy8qKgorICogQkZJX0lPQ0ZDX0gySV9DRkdfUkVRIG1lc3NhZ2UKKyAqLworc3RydWN0IGJmaV9pb2NmY19jZmdfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICAgICAgbWg7CisJdW5pb24gYmZpX2FkZHJfdSAgICAgIGlvY19jZmdfZG1hX2FkZHI7Cit9OworCisvKioKKyAqIEJGSV9JT0NGQ19JMkhfQ0ZHX1JFUExZIG1lc3NhZ2UKKyAqLworc3RydWN0IGJmaV9pb2NmY19jZmdfcmVwbHlfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIENvbW1vbiBtc2cgaGVhZGVyICAgICAgICAgICovCisJdTggICAgICAgICBjZmdfc3VjY2VzczsJLyogIGNmZyByZXBseSBzdGF0dXMgICAgICAgICAgICovCisJdTggICAgICAgICBscHVfYm07CQkvKiAgTFBVcyBhc3NpZ25lZCBmb3IgdGhpcyBJT0MgKi8KKwl1OCAgICAgICAgIHJzdmRbMl07Cit9OworCisvKioKKyAqICBCRklfSU9DRkNfSDJJX0dFVF9TVEFUU19SRVEgJiBCRklfSU9DRkNfSDJJX0NMRUFSX1NUQVRTX1JFUSBtZXNzYWdlcworICovCitzdHJ1Y3QgYmZpX2lvY2ZjX3N0YXRzX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyBtaDsJCS8qICBtc2cgaGVhZGVyICAgICAgICAgICAgKi8KKwl1MzIgICAgICAgIG1zZ3RhZzsJCS8qICBtc2d0YWcgZm9yIHJlcGx5ICAgICAgKi8KK307CisKKy8qKgorICogQkZJX0lPQ0ZDX0kySF9HRVRfU1RBVFNfUlNQICYgQkZJX0lPQ0ZDX0kySF9DTEVBUl9TVEFUU19SU1AgbWVzc2FnZXMKKyAqLworc3RydWN0IGJmaV9pb2NmY19zdGF0c19yc3BfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIgICAgICovCisJdTggICAgICAgICBzdGF0dXM7CQkvKiAgcmVwbHkgc3RhdHVzICAgICAgICAgICovCisJdTggICAgICAgICByc3ZkWzNdOworCXUzMiAgICAgICAgbXNndGFnOwkJLyogIG1zZ3RhZyBmb3IgcmVwbHkgICAgICAqLworfTsKKworLyoqCisgKiBCRklfSU9DRkNfSDJJX1NFVF9JTlRSX1JFUSBtZXNzYWdlCisgKi8KK3N0cnVjdCBiZmlfaW9jZmNfc2V0X2ludHJfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zIG1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyICAgICAqLworCXU4CQljb2FsZXNjZTsJLyogIGVuYWJsZSBpbnRyIGNvYWxlc2NpbmcqLworCXU4ICAgICAgICAgcnN2ZFszXTsKKwl1MTYJZGVsYXk7CQkvKiAgZGVsYXkgdGltZXIgMC4uMTEyNXVzICAqLworCXUxNglsYXRlbmN5OwkvKiAgbGF0ZW5jeSB0aW1lciAwLi4yMjV1cyAqLworfTsKKworLyoqCisgKiBCRklfSU9DRkNfSDJJX1VQREFURVFfUkVRIG1lc3NhZ2UKKyAqLworc3RydWN0IGJmaV9pb2NmY191cGRhdGVxX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlciAgICAgKi8KKwl1MzIgcmVxcV9iYTsJCQkvKiAgcmVxcSBiYXNlIGFkZHIgICAgICAgICovCisJdTMyIHJzcHFfYmE7CQkJLyogIHJzcHEgYmFzZSBhZGRyICAgICAgICAqLworCXUzMiByZXFxX3NjaTsJCQkvKiAgcmVxcSBzaGFkb3cgY2kgICAgICAgICovCisJdTMyIHJzcHFfc3BpOwkJCS8qICByc3BxIHNoYWRvdyBwaSAgICAgICAgKi8KK307CisKKy8qKgorICogQkZJX0lPQ0ZDX0kySF9VUERBVEVRX1JTUCBtZXNzYWdlCisgKi8KK3N0cnVjdCBiZmlfaW9jZmNfdXBkYXRlcV9yc3BfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIgICAgICovCisJdTggICAgICAgICBzdGF0dXM7CQkvKiAgdXBkYXRlcSAgc3RhdHVzICAgICAgICovCisJdTggICAgICAgICByc3ZkWzNdOworfTsKKworLyoqCisgKiBIMkkgTWVzc2FnZXMKKyAqLwordW5pb24gYmZpX2lvY2ZjX2gyaV9tc2dfdSB7CisJc3RydWN0IGJmaV9taGRyX3MgCQltaDsKKwlzdHJ1Y3QgYmZpX2lvY2ZjX2NmZ19yZXFfcyAJY2ZnX3JlcTsKKwlzdHJ1Y3QgYmZpX2lvY2ZjX3N0YXRzX3JlcV9zIHN0YXRzX2dldDsKKwlzdHJ1Y3QgYmZpX2lvY2ZjX3N0YXRzX3JlcV9zIHN0YXRzX2NscjsKKwlzdHJ1Y3QgYmZpX2lvY2ZjX3VwZGF0ZXFfcmVxX3MgdXBkYXRlcV9yZXE7CisJdTMyICAgICAgIAkJCW1ib3htc2dbQkZJX0lPQ19NU0dTWl07Cit9OworCisvKioKKyAqIEkySCBNZXNzYWdlcworICovCit1bmlvbiBiZmlfaW9jZmNfaTJoX21zZ191IHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgICAgIAkJbWg7CisJc3RydWN0IGJmaV9pb2NmY19jZmdfcmVwbHlfcyAJCWNmZ19yZXBseTsKKwlzdHJ1Y3QgYmZpX2lvY2ZjX3N0YXRzX3JzcF9zIHN0YXRzX2dldF9yc3A7CisJc3RydWN0IGJmaV9pb2NmY19zdGF0c19yc3BfcyBzdGF0c19jbHJfcnNwOworCXN0cnVjdCBiZmlfaW9jZmNfdXBkYXRlcV9yc3BfcyB1cGRhdGVxX3JzcDsKKwl1MzIgICAgICAgCQkJbWJveG1zZ1tCRklfSU9DX01TR1NaXTsKK307CisKKyNwcmFnbWEgcGFjaygpCisKKyNlbmRpZiAvKiBfX0JGSV9JT0NGQ19IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfbHBvcnQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2xwb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjkwMTA2MQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2xwb3J0LmgKQEAgLTAsMCArMSw4OSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZJX0xQT1JUX0hfXworI2RlZmluZSBfX0JGSV9MUE9SVF9IX18KKworI2luY2x1ZGUgPGJmaS9iZmkuaD4KKworI3ByYWdtYSBwYWNrKDEpCisKK2VudW0gYmZpX2xwb3J0X2gyaV9tc2dzIHsKKwlCRklfTFBPUlRfSDJJX0NSRUFURV9SRVEgPSAxLAorCUJGSV9MUE9SVF9IMklfREVMRVRFX1JFUSA9IDIsCit9OworCitlbnVtIGJmaV9scG9ydF9pMmhfbXNncyB7CisJQkZJX0xQT1JUX0kySF9DUkVBVEVfUlNQID0gQkZBX0kySE0oMSksCisJQkZJX0xQT1JUX0kySF9ERUxFVEVfUlNQID0gQkZBX0kySE0oMiksCisJQkZJX0xQT1JUX0kySF9PTkxJTkUJICA9IEJGQV9JMkhNKDMpLAorCUJGSV9MUE9SVF9JMkhfT0ZGTElORQkgID0gQkZBX0kySE0oNCksCit9OworCisjZGVmaW5lIEJGSV9MUE9SVF9NQVhfU1lOTkFNRQk2NAorCitlbnVtIGJmaV9scG9ydF9yb2xlX2UgeworCUJGSV9MUE9SVF9ST0xFX0ZDUElNCT0gMSwKKwlCRklfTFBPUlRfUk9MRV9GQ1BUTQk9IDIsCisJQkZJX0xQT1JUX1JPTEVfSVBGQwk9IDQsCit9OworCitzdHJ1Y3QgYmZpX2xwb3J0X2NyZWF0ZV9yZXFfcyB7CisJYmZpX21oZHJfdAltaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1MTYJZmFicmljX2Z3aGRsOwkvKiAgcGFyZW50IGZhYnJpYyBpbnN0YW5jZQkqLworCXU4CQlyb2xlczsJCS8qICBscG9ydCBGQy00IHJvbGVzCQkqLworCXU4CQlyc3ZkOworCXd3bl90CQlwd3duOwkJLyogIHBvcnQgbmFtZQkJCSovCisJd3duX3QJCW53d247CQkvKiAgbm9kZSBuYW1lCQkJKi8KKwl1OAkJc3ltbmFtZVtCRklfTFBPUlRfTUFYX1NZTk5BTUVdOworfTsKKworc3RydWN0IGJmaV9scG9ydF9jcmVhdGVfcnNwX3MgeworCWJmaV9taGRyX3QJbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSovCisJdTggICAgICAgICBzdGF0dXM7CQkvKiAgbHBvcnQgY3JlYXRpb24gc3RhdHVzCSovCisJdTggICAgICAgICByc3ZkWzNdOworfTsKKworc3RydWN0IGJmaV9scG9ydF9kZWxldGVfcmVxX3MgeworCWJmaV9taGRyX3QJbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSovCisJdTE2ICAgICAgICBmd19oYW5kbGU7CS8qICBmaXJtd2FyZSBscG9ydCBoYW5kbGUJKi8KKwl1MTYgICAgICAgIHJzdmQ7Cit9OworCitzdHJ1Y3QgYmZpX2xwb3J0X2RlbGV0ZV9yc3BfcyB7CisJYmZpX21oZHJfdAltaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1MTYgICAgICAgIGJmYV9oYW5kbGU7CS8qICBob3N0IGxwb3J0IGhhbmRsZQkJKi8KKwl1OCAgICAgICAgIHN0YXR1czsJCS8qICBscG9ydCBkZWxldGlvbiBzdGF0dXMJKi8KKwl1OCAgICAgICAgIHJzdmQ7Cit9OworCit1bmlvbiBiZmlfbHBvcnRfaDJpX21zZ191IHsKKwliZmlfbXNnX3QJCSptc2c7CisJc3RydWN0IGJmaV9scG9ydF9jcmVhdGVfcmVxX3MJKmNyZWF0ZV9yZXE7CisJc3RydWN0IGJmaV9scG9ydF9kZWxldGVfcmVxX3MJKmRlbGV0ZV9yZXE7Cit9OworCit1bmlvbiBiZmlfbHBvcnRfaTJoX21zZ191IHsKKwliZmlfbXNnX3QJCSptc2c7CisJc3RydWN0IGJmaV9scG9ydF9jcmVhdGVfcnNwX3MJKmNyZWF0ZV9yc3A7CisJc3RydWN0IGJmaV9scG9ydF9kZWxldGVfcnNwX3MJKmRlbGV0ZV9yc3A7Cit9OworCisjcHJhZ21hIHBhY2soKQorCisjZW5kaWYgLyogX19CRklfTFBPUlRfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2xwcy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfbHBzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDE0YjBlMwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX2xwcy5oCkBAIC0wLDAgKzEsOTYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGSV9MUFNfSF9fCisjZGVmaW5lIF9fQkZJX0xQU19IX18KKworI2luY2x1ZGUgPGJmaS9iZmkuaD4KKworI3ByYWdtYSBwYWNrKDEpCisKK2VudW0gYmZpX2xwc19oMmlfbXNncyB7CisJQkZJX0xQU19IMklfTE9HSU5fUkVRCT0gMSwKKwlCRklfTFBTX0gySV9MT0dPVVRfUkVRCT0gMiwKK307CisKK2VudW0gYmZpX2xwc19pMmhfbXNncyB7CisJQkZJX0xQU19IMklfTE9HSU5fUlNQCT0gQkZBX0kySE0oMSksCisJQkZJX0xQU19IMklfTE9HT1VUX1JTUAk9IEJGQV9JMkhNKDIpLAorfTsKKworc3RydWN0IGJmaV9scHNfbG9naW5fcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1OAkJbHBfdGFnOworCXU4CQlhbHBhOworCXUxNglwZHVfc2l6ZTsKKwl3d25fdAkJcHd3bjsKKwl3d25fdAkJbnd3bjsKKwl1OAkJZmRpc2M7CisJdTgJCWF1dGhfZW47CisJdTgJCXJzdmRbMl07Cit9OworCitzdHJ1Y3QgYmZpX2xwc19sb2dpbl9yc3BfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkqLworCXU4CQlscF90YWc7CisJdTgJCXN0YXR1czsKKwl1OAkJbHNyanRfcnNuOworCXU4CQlsc3JqdF9leHBsOworCXd3bl90CQlwb3J0X25hbWU7CisJd3duX3QJCW5vZGVfbmFtZTsKKwl1MTYJYmJfY3JlZGl0OworCXU4CQlmX3BvcnQ7CisJdTgJCW5waXZfZW47CisJdTMyCWxwX3BpZCA6IDI0OworCXUzMglhdXRoX3JlcSA6IDg7CisJbWFjX3QJCWxwX21hYzsKKwltYWNfdAkJZmNmX21hYzsKKwl1OAkJZXh0X3N0YXR1czsKKwl1OCAgCWJyY2Rfc3dpdGNoOy8qICBhdHRhY2hlZCBwZWVyIGlzIGJyY2Qgc3dpdGNoCSovCit9OworCitzdHJ1Y3QgYmZpX2xwc19sb2dvdXRfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1OAkJbHBfdGFnOworCXU4CQlyc3ZkWzNdOworCXd3bl90CQlwb3J0X25hbWU7Cit9OworCitzdHJ1Y3QgYmZpX2xwc19sb2dvdXRfcnNwX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1OAkJbHBfdGFnOworCXU4CQlzdGF0dXM7CisJdTgJCXJzdmRbMl07Cit9OworCit1bmlvbiBiZmlfbHBzX2gyaV9tc2dfdSB7CisJc3RydWN0IGJmaV9taGRyX3MJCSptc2c7CisJc3RydWN0IGJmaV9scHNfbG9naW5fcmVxX3MJKmxvZ2luX3JlcTsKKwlzdHJ1Y3QgYmZpX2xwc19sb2dvdXRfcmVxX3MJKmxvZ291dF9yZXE7Cit9OworCit1bmlvbiBiZmlfbHBzX2kyaF9tc2dfdSB7CisJc3RydWN0IGJmaV9tc2dfcwkJKm1zZzsKKwlzdHJ1Y3QgYmZpX2xwc19sb2dpbl9yc3BfcwkqbG9naW5fcnNwOworCXN0cnVjdCBiZmlfbHBzX2xvZ291dF9yc3BfcwkqbG9nb3V0X3JzcDsKK307CisKKyNwcmFnbWEgcGFjaygpCisKKyNlbmRpZiAvKiBfX0JGSV9MUFNfSF9fICovCisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfcG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfcG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjNlYzNiZWEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9wb3J0LmgKQEAgLTAsMCArMSwxMTUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRklfUE9SVF9IX18KKyNkZWZpbmUgX19CRklfUE9SVF9IX18KKworI2luY2x1ZGUgPGJmaS9iZmkuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3Bwb3J0Lmg+CisKKyNwcmFnbWEgcGFjaygxKQorCitlbnVtIGJmaV9wb3J0X2gyaSB7CisJQkZJX1BPUlRfSDJJX0VOQUJMRV9SRVEJCT0gKDEpLAorCUJGSV9QT1JUX0gySV9ESVNBQkxFX1JFUQk9ICgyKSwKKwlCRklfUE9SVF9IMklfR0VUX1NUQVRTX1JFUQk9ICgzKSwKKwlCRklfUE9SVF9IMklfQ0xFQVJfU1RBVFNfUkVRCT0gKDQpLAorfTsKKworZW51bSBiZmlfcG9ydF9pMmggeworCUJGSV9QT1JUX0kySF9FTkFCTEVfUlNQCQk9IEJGQV9JMkhNKDEpLAorCUJGSV9QT1JUX0kySF9ESVNBQkxFX1JTUAk9IEJGQV9JMkhNKDIpLAorCUJGSV9QT1JUX0kySF9HRVRfU1RBVFNfUlNQCT0gQkZBX0kySE0oMyksCisJQkZJX1BPUlRfSTJIX0NMRUFSX1NUQVRTX1JTUAk9IEJGQV9JMkhNKDQpLAorfTsKKworLyoqCisgKiBHZW5lcmljIFJFUSB0eXBlCisgKi8KK3N0cnVjdCBiZmlfcG9ydF9nZW5lcmljX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgbXNnIGhlYWRlcgkJCSAgICAqLworCXUzMiAgICAgICAgbXNndGFnOwkJLyogIG1zZ3RhZyBmb3IgcmVwbHkJCSAgICAqLworCXUzMglyc3ZkOworfTsKKworLyoqCisgKiBHZW5lcmljIFJTUCB0eXBlCisgKi8KK3N0cnVjdCBiZmlfcG9ydF9nZW5lcmljX3JzcF9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSAgICAqLworCXU4ICAgICAgICAgc3RhdHVzOwkJLyogIHBvcnQgZW5hYmxlIHN0YXR1cwkJICAgICovCisJdTggICAgICAgICByc3ZkWzNdOworCXUzMiAgICAgICAgbXNndGFnOwkJLyogIG1zZ3RhZyBmb3IgcmVwbHkJCSAgICAqLworfTsKKworLyoqCisgKiBAdG9kbworICogQkZJX1BPUlRfSDJJX0VOQUJMRV9SRVEKKyAqLworCisvKioKKyAqIEB0b2RvCisgKiBCRklfUE9SVF9JMkhfRU5BQkxFX1JTUAorICovCisKKy8qKgorICogQkZJX1BPUlRfSDJJX0RJU0FCTEVfUkVRCisgKi8KKworLyoqCisgKiBCRklfUE9SVF9JMkhfRElTQUJMRV9SU1AKKyAqLworCisvKioKKyAqIEJGSV9QT1JUX0gySV9HRVRfU1RBVFNfUkVRCisgKi8KK3N0cnVjdCBiZmlfcG9ydF9nZXRfc3RhdHNfcmVxX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJICAgICovCisJdW5pb24gYmZpX2FkZHJfdSAgIGRtYV9hZGRyOworfTsKKworLyoqCisgKiBCRklfUE9SVF9JMkhfR0VUX1NUQVRTX1JTUAorICovCisKKy8qKgorICogQkZJX1BPUlRfSDJJX0NMRUFSX1NUQVRTX1JFUQorICovCisKKy8qKgorICogQkZJX1BPUlRfSTJIX0NMRUFSX1NUQVRTX1JTUAorICovCisKK3VuaW9uIGJmaV9wb3J0X2gyaV9tc2dfdSB7CisJc3RydWN0IGJmaV9taGRyX3MJCW1oOworCXN0cnVjdCBiZmlfcG9ydF9nZW5lcmljX3JlcV9zCWVuYWJsZV9yZXE7CisJc3RydWN0IGJmaV9wb3J0X2dlbmVyaWNfcmVxX3MJZGlzYWJsZV9yZXE7CisJc3RydWN0IGJmaV9wb3J0X2dldF9zdGF0c19yZXFfcwlnZXRzdGF0c19yZXE7CisJc3RydWN0IGJmaV9wb3J0X2dlbmVyaWNfcmVxX3MJY2xlYXJzdGF0c19yZXE7Cit9OworCit1bmlvbiBiZmlfcG9ydF9pMmhfbXNnX3UgeworCXN0cnVjdCBiZmlfbWhkcl9zICAgICAgICAgCW1oOworCXN0cnVjdCBiZmlfcG9ydF9nZW5lcmljX3JzcF9zCWVuYWJsZV9yc3A7CisJc3RydWN0IGJmaV9wb3J0X2dlbmVyaWNfcnNwX3MJZGlzYWJsZV9yc3A7CisJc3RydWN0IGJmaV9wb3J0X2dlbmVyaWNfcnNwX3MJZ2V0c3RhdHNfcnNwOworCXN0cnVjdCBiZmlfcG9ydF9nZW5lcmljX3JzcF9zCWNsZWFyc3RhdHNfcnNwOworfTsKKworI3ByYWdtYSBwYWNrKCkKKworI2VuZGlmIC8qIF9fQkZJX1BPUlRfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX3Bwb3J0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9wcG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM5NmQyNDYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9wcG9ydC5oCkBAIC0wLDAgKzEsMTg0IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZJX1BQT1JUX0hfXworI2RlZmluZSBfX0JGSV9QUE9SVF9IX18KKworI2luY2x1ZGUgPGJmaS9iZmkuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3Bwb3J0Lmg+CisKKyNwcmFnbWEgcGFjaygxKQorCitlbnVtIGJmaV9wcG9ydF9oMmkgeworCUJGSV9QUE9SVF9IMklfRU5BQkxFX1JFUQkJPSAoMSksCisJQkZJX1BQT1JUX0gySV9ESVNBQkxFX1JFUQkJPSAoMiksCisJQkZJX1BQT1JUX0gySV9HRVRfU1RBVFNfUkVRCQk9ICgzKSwKKwlCRklfUFBPUlRfSDJJX0NMRUFSX1NUQVRTX1JFUQk9ICg0KSwKKwlCRklfUFBPUlRfSDJJX1NFVF9TVkNfUEFSQU1TX1JFUQk9ICg1KSwKKwlCRklfUFBPUlRfSDJJX0VOQUJMRV9SWF9WRl9UQUdfUkVRCT0gKDYpLAorCUJGSV9QUE9SVF9IMklfRU5BQkxFX1RYX1ZGX1RBR19SRVEJPSAoNyksCisJQkZJX1BQT1JUX0gySV9HRVRfUU9TX1NUQVRTX1JFUQkJPSAoOCksCisJQkZJX1BQT1JUX0gySV9DTEVBUl9RT1NfU1RBVFNfUkVRCT0gKDkpLAorfTsKKworZW51bSBiZmlfcHBvcnRfaTJoIHsKKwlCRklfUFBPUlRfSTJIX0VOQUJMRV9SU1AJCT0gQkZBX0kySE0oMSksCisJQkZJX1BQT1JUX0kySF9ESVNBQkxFX1JTUAkJPSBCRkFfSTJITSgyKSwKKwlCRklfUFBPUlRfSTJIX0dFVF9TVEFUU19SU1AJCT0gQkZBX0kySE0oMyksCisJQkZJX1BQT1JUX0kySF9DTEVBUl9TVEFUU19SU1AJPSBCRkFfSTJITSg0KSwKKwlCRklfUFBPUlRfSTJIX1NFVF9TVkNfUEFSQU1TX1JTUAk9IEJGQV9JMkhNKDUpLAorCUJGSV9QUE9SVF9JMkhfRU5BQkxFX1JYX1ZGX1RBR19SU1AJPSBCRkFfSTJITSg2KSwKKwlCRklfUFBPUlRfSTJIX0VOQUJMRV9UWF9WRl9UQUdfUlNQCT0gQkZBX0kySE0oNyksCisJQkZJX1BQT1JUX0kySF9FVkVOVAkJCT0gQkZBX0kySE0oOCksCisJQkZJX1BQT1JUX0kySF9HRVRfUU9TX1NUQVRTX1JTUAkJPSBCRkFfSTJITSg5KSwKKwlCRklfUFBPUlRfSTJIX0NMRUFSX1FPU19TVEFUU19SU1AJPSBCRkFfSTJITSgxMCksCit9OworCisvKioKKyAqIEdlbmVyaWMgUkVRIHR5cGUKKyAqLworc3RydWN0IGJmaV9wcG9ydF9nZW5lcmljX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgbXNnIGhlYWRlcgkJCSAgICAqLworCXUzMiAgICAgICAgbXNndGFnOwkJLyogIG1zZ3RhZyBmb3IgcmVwbHkJCSAgICAqLworfTsKKworLyoqCisgKiBHZW5lcmljIFJTUCB0eXBlCisgKi8KK3N0cnVjdCBiZmlfcHBvcnRfZ2VuZXJpY19yc3BfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkgICAgKi8KKwl1OCAgICAgICAgIHN0YXR1czsJCS8qICBwb3J0IGVuYWJsZSBzdGF0dXMJCSAgICAqLworCXU4ICAgICAgICAgcnN2ZFszXTsKKwl1MzIgICAgICAgIG1zZ3RhZzsJCS8qICBtc2d0YWcgZm9yIHJlcGx5CQkgICAgKi8KK307CisKKy8qKgorICogQkZJX1BQT1JUX0gySV9FTkFCTEVfUkVRCisgKi8KK3N0cnVjdCBiZmlfcHBvcnRfZW5hYmxlX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgbXNnIGhlYWRlcgkJCSAgICAqLworCXUzMiAgICAgICAgcnN2ZDE7CisJd3duX3QgICAgICAgICAgIG53d247CQkvKiAgbm9kZSB3d24gb2YgcGh5c2ljYWwgcG9ydAkgICAgKi8KKwl3d25fdCAgICAgICAgICAgcHd3bjsJCS8qICBwb3J0IHd3biBvZiBwaHlzaWNhbCBwb3J0CSAgICAqLworCXN0cnVjdCBiZmFfcHBvcnRfY2ZnX3MgcG9ydF9jZmc7CS8qICBwb3J0IGNvbmZpZ3VyYXRpb24JICAgICovCisJdW5pb24gYmZpX2FkZHJfdSAgc3RhdHNfZG1hX2FkZHI7CS8qICBETUEgYWRkcmVzcyBmb3Igc3RhdHMgICovCisJdTMyICAgICAgICBtc2d0YWc7CQkvKiAgbXNndGFnIGZvciByZXBseQkJICAgICovCisJdTMyICAgICAgICByc3ZkMjsKK307CisKKy8qKgorICogQkZJX1BQT1JUX0kySF9FTkFCTEVfUlNQCisgKi8KKyNkZWZpbmUgYmZpX3Bwb3J0X2VuYWJsZV9yc3BfdCBzdHJ1Y3QgYmZpX3Bwb3J0X2dlbmVyaWNfcnNwX3MKKworLyoqCisgKiBCRklfUFBPUlRfSDJJX0RJU0FCTEVfUkVRCisgKi8KKyNkZWZpbmUgYmZpX3Bwb3J0X2Rpc2FibGVfcmVxX3Qgc3RydWN0IGJmaV9wcG9ydF9nZW5lcmljX3JlcV9zCisKKy8qKgorICogQkZJX1BQT1JUX0kySF9ESVNBQkxFX1JTUAorICovCisjZGVmaW5lIGJmaV9wcG9ydF9kaXNhYmxlX3JzcF90IHN0cnVjdCBiZmlfcHBvcnRfZ2VuZXJpY19yc3BfcworCisvKioKKyAqIEJGSV9QUE9SVF9IMklfR0VUX1NUQVRTX1JFUQorICovCisjZGVmaW5lIGJmaV9wcG9ydF9nZXRfc3RhdHNfcmVxX3Qgc3RydWN0IGJmaV9wcG9ydF9nZW5lcmljX3JlcV9zCisKKy8qKgorICogQkZJX1BQT1JUX0kySF9HRVRfU1RBVFNfUlNQCisgKi8KKyNkZWZpbmUgYmZpX3Bwb3J0X2dldF9zdGF0c19yc3BfdCBzdHJ1Y3QgYmZpX3Bwb3J0X2dlbmVyaWNfcnNwX3MKKworLyoqCisgKiBCRklfUFBPUlRfSDJJX0NMRUFSX1NUQVRTX1JFUQorICovCisjZGVmaW5lIGJmaV9wcG9ydF9jbGVhcl9zdGF0c19yZXFfdCBzdHJ1Y3QgYmZpX3Bwb3J0X2dlbmVyaWNfcmVxX3MKKworLyoqCisgKiBCRklfUFBPUlRfSTJIX0NMRUFSX1NUQVRTX1JTUAorICovCisjZGVmaW5lIGJmaV9wcG9ydF9jbGVhcl9zdGF0c19yc3BfdCBzdHJ1Y3QgYmZpX3Bwb3J0X2dlbmVyaWNfcnNwX3MKKworLyoqCisgKiBCRklfUFBPUlRfSDJJX0dFVF9RT1NfU1RBVFNfUkVRCisgKi8KKyNkZWZpbmUgYmZpX3Bwb3J0X2dldF9xb3Nfc3RhdHNfcmVxX3Qgc3RydWN0IGJmaV9wcG9ydF9nZW5lcmljX3JlcV9zCisKKy8qKgorICogQkZJX1BQT1JUX0gySV9HRVRfUU9TX1NUQVRTX1JTUAorICovCisjZGVmaW5lIGJmaV9wcG9ydF9nZXRfcW9zX3N0YXRzX3JzcF90IHN0cnVjdCBiZmlfcHBvcnRfZ2VuZXJpY19yc3BfcworCisvKioKKyAqIEJGSV9QUE9SVF9IMklfQ0xFQVJfUU9TX1NUQVRTX1JFUQorICovCisjZGVmaW5lIGJmaV9wcG9ydF9jbGVhcl9xb3Nfc3RhdHNfcmVxX3Qgc3RydWN0IGJmaV9wcG9ydF9nZW5lcmljX3JlcV9zCisKKy8qKgorICogQkZJX1BQT1JUX0gySV9DTEVBUl9RT1NfU1RBVFNfUlNQCisgKi8KKyNkZWZpbmUgYmZpX3Bwb3J0X2NsZWFyX3Fvc19zdGF0c19yc3BfdCBzdHJ1Y3QgYmZpX3Bwb3J0X2dlbmVyaWNfcnNwX3MKKworLyoqCisgKiBCRklfUFBPUlRfSDJJX1NFVF9TVkNfUEFSQU1TX1JFUQorICovCitzdHJ1Y3QgYmZpX3Bwb3J0X3NldF9zdmNfcGFyYW1zX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgbXNnIGhlYWRlciAqLworCXUxNiAgICAgICAgdHhfYmJjcmVkaXQ7CS8qICBUeCBjcmVkaXRzICovCisJdTE2ICAgICAgICByc3ZkOworfTsKKworLyoqCisgKiBCRklfUFBPUlRfSTJIX1NFVF9TVkNfUEFSQU1TX1JTUAorICovCisKKy8qKgorICogQkZJX1BQT1JUX0kySF9FVkVOVAorICovCitzdHJ1Y3QgYmZpX3Bwb3J0X2V2ZW50X3MgeworCXN0cnVjdCBiZmlfbWhkcl9zIAltaDsJLyogIGNvbW1vbiBtc2cgaGVhZGVyICovCisJc3RydWN0IGJmYV9wcG9ydF9saW5rX3MJbGlua19zdGF0ZTsKK307CisKK3VuaW9uIGJmaV9wcG9ydF9oMmlfbXNnX3UgeworCXN0cnVjdCBiZmlfbWhkcl9zCQkJKm1oZHI7CisJc3RydWN0IGJmaV9wcG9ydF9lbmFibGVfcmVxX3MJCSpwZW5hYmxlOworCXN0cnVjdCBiZmlfcHBvcnRfZ2VuZXJpY19yZXFfcwkJKnBkaXNhYmxlOworCXN0cnVjdCBiZmlfcHBvcnRfZ2VuZXJpY19yZXFfcwkJKnBnZXRzdGF0czsKKwlzdHJ1Y3QgYmZpX3Bwb3J0X2dlbmVyaWNfcmVxX3MJCSpwY2xlYXJzdGF0czsKKwlzdHJ1Y3QgYmZpX3Bwb3J0X3NldF9zdmNfcGFyYW1zX3JlcV9zCSpwc2V0c3ZjcGFyYW1zOworCXN0cnVjdCBiZmlfcHBvcnRfZ2V0X3Fvc19zdGF0c19yZXFfcwkqcGdldHFvc3N0YXRzOworCXN0cnVjdCBiZmlfcHBvcnRfZ2VuZXJpY19yZXFfcwkJKnBjbGVhcnFvc3N0YXRzOworfTsKKwordW5pb24gYmZpX3Bwb3J0X2kyaF9tc2dfdSB7CisJc3RydWN0IGJmaV9tc2dfcwkJCSptc2c7CisJc3RydWN0IGJmaV9wcG9ydF9nZW5lcmljX3JzcF9zCQkqZW5hYmxlX3JzcDsKKwlzdHJ1Y3QgYmZpX3Bwb3J0X2Rpc2FibGVfcnNwX3MJCSpkaXNhYmxlX3JzcDsKKwlzdHJ1Y3QgYmZpX3Bwb3J0X2dlbmVyaWNfcnNwX3MJCSpnZXRzdGF0c19yc3A7CisJc3RydWN0IGJmaV9wcG9ydF9jbGVhcl9zdGF0c19yc3BfcwkqY2xlYXJzdGF0c19yc3A7CisJc3RydWN0IGJmaV9wcG9ydF9zZXRfc3ZjX3BhcmFtc19yc3Bfcwkqc2V0c3ZjcGFyYXNtX3JzcDsKKwlzdHJ1Y3QgYmZpX3Bwb3J0X2dldF9xb3Nfc3RhdHNfcnNwX3MJKmdldHFvc3N0YXRzX3JzcDsKKwlzdHJ1Y3QgYmZpX3Bwb3J0X2NsZWFyX3Fvc19zdGF0c19yc3BfcwkqY2xlYXJxb3NzdGF0c19yc3A7CisJc3RydWN0IGJmaV9wcG9ydF9ldmVudF9zCQkqZXZlbnQ7Cit9OworCisjcHJhZ21hIHBhY2soKQorCisjZW5kaWYgLyogX19CRklfUFBPUlRfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9iZmkvYmZpX3Jwb3J0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9ycG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjM1MjBmNTUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV9ycG9ydC5oCkBAIC0wLDAgKzEsMTA0IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRklfUlBPUlRfSF9fCisjZGVmaW5lIF9fQkZJX1JQT1JUX0hfXworCisjaW5jbHVkZSA8YmZpL2JmaS5oPgorCisjcHJhZ21hIHBhY2soMSkKKworZW51bSBiZmlfcnBvcnRfaDJpX21zZ3MgeworCUJGSV9SUE9SVF9IMklfQ1JFQVRFX1JFUSA9IDEsCisJQkZJX1JQT1JUX0gySV9ERUxFVEVfUkVRID0gMiwKKwlCRklfUlBPUlRfSDJJX1NFVF9TUEVFRF9SRVEgID0gMywKK307CisKK2VudW0gYmZpX3Jwb3J0X2kyaF9tc2dzIHsKKwlCRklfUlBPUlRfSTJIX0NSRUFURV9SU1AgPSBCRkFfSTJITSgxKSwKKwlCRklfUlBPUlRfSTJIX0RFTEVURV9SU1AgPSBCRkFfSTJITSgyKSwKKwlCRklfUlBPUlRfSTJIX1FPU19TQ04gICAgPSBCRkFfSTJITSgzKSwKK307CisKK3N0cnVjdCBiZmlfcnBvcnRfY3JlYXRlX3JlcV9zIHsKKwlzdHJ1Y3QgYmZpX21oZHJfcyAgbWg7CQkvKiAgY29tbW9uIG1zZyBoZWFkZXIJCSovCisJdTE2ICAgICAgICBiZmFfaGFuZGxlOwkvKiAgaG9zdCBycG9ydCBoYW5kbGUJCSovCisJdTE2ICAgICAgICBtYXhfZnJtc3o7CS8qICBtYXggcmN2IHBkdSBzaXplCQkqLworCXUzMiAgICAgICAgcGlkICAgICAgIDogMjQsCS8qICByZW1vdGUgcG9ydCBJRAkJKi8KKwkJCWxwX3RhZyAgICA6IDg7CS8qICBsb2NhbCBwb3J0IHRhZwkJKi8KKwl1MzIgICAgICAgIGxvY2FsX3BpZCA6IDI0LAkvKiAgbG9jYWwgcG9ydCBJRAkJKi8KKwkJCWNpc2MgICAgICA6IDg7CisJdTggICAgICAgICBmY19jbGFzczsJLyogIHN1cHBvcnRlZCBGQyBjbGFzc2VzCSovCisJdTggICAgICAgICB2Zl9lbjsJCS8qICB2aXJ0dWFsIGZhYnJpYyBlbmFibGUJKi8KKwl1MTYgICAgICAgIHZmX2lkOwkJLyogIHZpcnR1YWwgZmFicmljIElECQkqLworfTsKKworc3RydWN0IGJmaV9ycG9ydF9jcmVhdGVfcnNwX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1OCAgICAgICAgIHN0YXR1czsJCS8qICBycG9ydCBjcmVhdGlvbiBzdGF0dXMJKi8KKwl1OCAgICAgICAgIHJzdmRbM107CisJdTE2ICAgICAgICBiZmFfaGFuZGxlOwkvKiAgaG9zdCBycG9ydCBoYW5kbGUJCSovCisJdTE2ICAgICAgICBmd19oYW5kbGU7CS8qICBmaXJtd2FyZSBycG9ydCBoYW5kbGUJKi8KKwlzdHJ1Y3QgYmZhX3Jwb3J0X3Fvc19hdHRyX3MgcW9zX2F0dHI7ICAvKiBRb1MgQXR0cmlidXRlcyAqLworfTsKKworc3RydWN0IGJmYV9ycG9ydF9zcGVlZF9yZXFfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkqLworCXUxNiAgICAgICAgZndfaGFuZGxlOwkvKiAgZmlybXdhcmUgcnBvcnQgaGFuZGxlCSovCisJdTgJCXNwZWVkOwkJLyohIHJwb3J0J3Mgc3BlZWQgdmlhIFJQU0MgICovCisJdTgJCXJzdmQ7Cit9OworCitzdHJ1Y3QgYmZpX3Jwb3J0X2RlbGV0ZV9yZXFfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkqLworCXUxNiAgICAgICAgZndfaGFuZGxlOwkvKiAgZmlybXdhcmUgcnBvcnQgaGFuZGxlCSovCisJdTE2ICAgICAgICByc3ZkOworfTsKKworc3RydWN0IGJmaV9ycG9ydF9kZWxldGVfcnNwX3MgeworCXN0cnVjdCBiZmlfbWhkcl9zICBtaDsJCS8qICBjb21tb24gbXNnIGhlYWRlcgkJKi8KKwl1MTYgICAgICAgIGJmYV9oYW5kbGU7CS8qICBob3N0IHJwb3J0IGhhbmRsZQkJKi8KKwl1OCAgICAgICAgIHN0YXR1czsJCS8qICBycG9ydCBkZWxldGlvbiBzdGF0dXMJKi8KKwl1OCAgICAgICAgIHJzdmQ7Cit9OworCitzdHJ1Y3QgYmZpX3Jwb3J0X3Fvc19zY25fcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIGNvbW1vbiBtc2cgaGVhZGVyCQkqLworCXUxNiAgICAgICAgYmZhX2hhbmRsZTsJLyogIGhvc3QgcnBvcnQgaGFuZGxlCQkqLworCXUxNiAgICAgICAgcnN2ZDsKKwlzdHJ1Y3QgYmZhX3Jwb3J0X3Fvc19hdHRyX3Mgb2xkX3Fvc19hdHRyOyAgLyogT2xkIFFvUyBBdHRyaWJ1dGVzICovCisJc3RydWN0IGJmYV9ycG9ydF9xb3NfYXR0cl9zIG5ld19xb3NfYXR0cjsgIC8qIE5ldyBRb1MgQXR0cmlidXRlcyAqLworfTsKKwordW5pb24gYmZpX3Jwb3J0X2gyaV9tc2dfdSB7CisJc3RydWN0IGJmaV9tc2dfcyAJCSptc2c7CisJc3RydWN0IGJmaV9ycG9ydF9jcmVhdGVfcmVxX3MJKmNyZWF0ZV9yZXE7CisJc3RydWN0IGJmaV9ycG9ydF9kZWxldGVfcmVxX3MJKmRlbGV0ZV9yZXE7CisJc3RydWN0IGJmaV9ycG9ydF9zcGVlZF9yZXFfcwkqc3BlZWRfcmVxOworfTsKKwordW5pb24gYmZpX3Jwb3J0X2kyaF9tc2dfdSB7CisJc3RydWN0IGJmaV9tc2dfcyAJCSptc2c7CisJc3RydWN0IGJmaV9ycG9ydF9jcmVhdGVfcnNwX3MJKmNyZWF0ZV9yc3A7CisJc3RydWN0IGJmaV9ycG9ydF9kZWxldGVfcnNwX3MJKmRlbGV0ZV9yc3A7CisJc3RydWN0IGJmaV9ycG9ydF9xb3Nfc2NuX3MJKnFvc19zY25fZXZ0OworfTsKKworI3ByYWdtYSBwYWNrKCkKKworI2VuZGlmIC8qIF9fQkZJX1JQT1JUX0hfXyAqLworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvYmZpL2JmaV91Zi5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfdWYuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mMzI4YTllCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2JmaS9iZmlfdWYuaApAQCAtMCwwICsxLDUyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRklfVUZfSF9fCisjZGVmaW5lIF9fQkZJX1VGX0hfXworCisjaW5jbHVkZSAiYmZpLmgiCisKKyNwcmFnbWEgcGFjaygxKQorCitlbnVtIGJmaV91Zl9oMmkgeworCUJGSV9VRl9IMklfQlVGX1BPU1QgPSAxLAorfTsKKworZW51bSBiZmlfdWZfaTJoIHsKKwlCRklfVUZfSTJIX0ZSTV9SQ1ZEID0gQkZBX0kySE0oMSksCit9OworCisjZGVmaW5lIEJGQV9VRl9NQVhfU0dFUwkyCisKK3N0cnVjdCBiZmlfdWZfYnVmX3Bvc3RfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIENvbW1vbiBtc2cgaGVhZGVyCQkqLworCXUxNiAgICAgICAgYnVmX3RhZzsJLyogIGJ1ZmZlciB0YWcJCQkqLworCXUxNiAgICAgICAgYnVmX2xlbjsJLyogIHRvdGFsIGJ1ZmZlciBsZW5ndGgJKi8KKwlzdHJ1Y3QgYmZpX3NnZV9zICAgc2dlW0JGQV9VRl9NQVhfU0dFU107IC8qICBidWZmZXIgRE1BIFNHRXMJKi8KK307CisKK3N0cnVjdCBiZmlfdWZfZnJtX3JjdmRfcyB7CisJc3RydWN0IGJmaV9taGRyX3MgIG1oOwkJLyogIENvbW1vbiBtc2cgaGVhZGVyCQkqLworCXUxNiAgICAgICAgYnVmX3RhZzsJLyogIGJ1ZmZlciB0YWcJCQkqLworCXUxNiAgICAgICAgcnN2ZDsKKwl1MTYgICAgICAgIGZybV9sZW47CS8qICByZWNlaXZlZCBmcmFtZSBsZW5ndGggCSovCisJdTE2ICAgICAgICB4ZnJfbGVuOwkvKiAgdHJhbmZlcnJlZCBsZW5ndGgJCSovCit9OworCisjcHJhZ21hIHBhY2soKQorCisjZW5kaWYgLyogX19CRklfVUZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL2JmYV9jbmFfdHJjbW9kLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL2JmYV9jbmFfdHJjbW9kLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDNiYTcwNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jbmEvYmZhX2NuYV90cmNtb2QuaApAQCAtMCwwICsxLDM2IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9jbmFfdHJjbW9kLmggQ05BIHRyYWNlIG1vZHVsZXMKKyAqLworCisjaWZuZGVmIF9fQkZBX0NOQV9UUkNNT0RfSF9fCisjZGVmaW5lIF9fQkZBX0NOQV9UUkNNT0RfSF9fCisKKyNpbmNsdWRlIDxjcy9iZmFfdHJjLmg+CisKKy8qCisgKiAhISEgT25seSBhcHBlbmQgdG8gdGhlIGVudW1zIGRlZmluZWQgaGVyZSB0byBhdm9pZCBhbnkgdmVyc2lvbmluZworICogISEhIG5lZWRlZCBiZXR3ZWVuIHRyYWNlIHV0aWxpdHkgYW5kIGRyaXZlciB2ZXJzaW9uCisgKi8KK2VudW0geworCUJGQV9UUkNfQ05BX0NFRQkJPSAxLAorCUJGQV9UUkNfQ05BX1BPUlQJPSAyLAorfTsKKworI2VuZGlmIC8qIF9fQkZBX0NOQV9UUkNNT0RfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL2NlZS9iZmFfY2VlLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL2NlZS9iZmFfY2VlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzdmMjk3ZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jbmEvY2VlL2JmYV9jZWUuaApAQCAtMCwwICsxLDc3IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfQ0VFX0hfXworI2RlZmluZSBfX0JGQV9DRUVfSF9fCisKKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX2NlZS5oPgorI2luY2x1ZGUgPGJmYV9pb2MuaD4KKyNpbmNsdWRlIDxjcy9iZmFfdHJjLmg+CisjaW5jbHVkZSA8Y3MvYmZhX2xvZy5oPgorCit0eXBlZGVmIHZvaWQgKCpiZmFfY2VlX2dldF9hdHRyX2NiZm5fdCkgKHZvaWQgKmRldiwgYmZhX3N0YXR1c190IHN0YXR1cyk7Cit0eXBlZGVmIHZvaWQgKCpiZmFfY2VlX2dldF9zdGF0c19jYmZuX3QpICh2b2lkICpkZXYsIGJmYV9zdGF0dXNfdCBzdGF0dXMpOwordHlwZWRlZiB2b2lkICgqYmZhX2NlZV9yZXNldF9zdGF0c19jYmZuX3QpICh2b2lkICpkZXYsIGJmYV9zdGF0dXNfdCBzdGF0dXMpOwordHlwZWRlZiB2b2lkICgqYmZhX2NlZV9oYmZhaWxfY2Jmbl90KSAodm9pZCAqZGV2LCBiZmFfc3RhdHVzX3Qgc3RhdHVzKTsKKworc3RydWN0IGJmYV9jZWVfY2Jmbl9zIHsKKwliZmFfY2VlX2dldF9hdHRyX2NiZm5fdCAgICBnZXRfYXR0cl9jYmZuOworCXZvaWQgKmdldF9hdHRyX2NiYXJnOworCWJmYV9jZWVfZ2V0X3N0YXRzX2NiZm5fdCAgIGdldF9zdGF0c19jYmZuOworCXZvaWQgKmdldF9zdGF0c19jYmFyZzsKKwliZmFfY2VlX3Jlc2V0X3N0YXRzX2NiZm5fdCByZXNldF9zdGF0c19jYmZuOworCXZvaWQgKnJlc2V0X3N0YXRzX2NiYXJnOworfTsKKworc3RydWN0IGJmYV9jZWVfcyB7CisJdm9pZCAqZGV2OworCWJmYV9ib29sZWFuX3QgZ2V0X2F0dHJfcGVuZGluZzsKKwliZmFfYm9vbGVhbl90IGdldF9zdGF0c19wZW5kaW5nOworCWJmYV9ib29sZWFuX3QgcmVzZXRfc3RhdHNfcGVuZGluZzsKKwliZmFfc3RhdHVzX3QgZ2V0X2F0dHJfc3RhdHVzOworCWJmYV9zdGF0dXNfdCBnZXRfc3RhdHNfc3RhdHVzOworCWJmYV9zdGF0dXNfdCByZXNldF9zdGF0c19zdGF0dXM7CisJc3RydWN0IGJmYV9jZWVfY2Jmbl9zIGNiZm47CisJc3RydWN0IGJmYV9pb2NfaGJmYWlsX25vdGlmeV9zIGhiZmFpbDsKKwlzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbW9kOworCXN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtb2Q7CisJc3RydWN0IGJmYV9jZWVfYXR0cl9zICphdHRyOworCXN0cnVjdCBiZmFfY2VlX3N0YXRzX3MgKnN0YXRzOworCXN0cnVjdCBiZmFfZG1hX3MgYXR0cl9kbWE7CisJc3RydWN0IGJmYV9kbWFfcyBzdGF0c19kbWE7CisJc3RydWN0IGJmYV9pb2NfcyAqaW9jOworCXN0cnVjdCBiZmFfbWJveF9jbWRfcyBnZXRfY2ZnX21iOworCXN0cnVjdCBiZmFfbWJveF9jbWRfcyBnZXRfc3RhdHNfbWI7CisJc3RydWN0IGJmYV9tYm94X2NtZF9zIHJlc2V0X3N0YXRzX21iOworfTsKKwordTMyIGJmYV9jZWVfbWVtaW5mbyh2b2lkKTsKK3ZvaWQgYmZhX2NlZV9tZW1fY2xhaW0oc3RydWN0IGJmYV9jZWVfcyAqY2VlLCB1OCAqZG1hX2t2YSwKKwkJCSB1NjQgZG1hX3BhKTsKK3ZvaWQgYmZhX2NlZV9hdHRhY2goc3RydWN0IGJmYV9jZWVfcyAqY2VlLCBzdHJ1Y3QgYmZhX2lvY19zICppb2MsIHZvaWQgKmRldiwKKwkJCXN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QsCisJCQlzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbW9kKTsKK3ZvaWQgYmZhX2NlZV9kZXRhY2goc3RydWN0IGJmYV9jZWVfcyAqY2VlKTsKK2JmYV9zdGF0dXNfdCBiZmFfY2VlX2dldF9hdHRyKHN0cnVjdCBiZmFfY2VlX3MgKmNlZSwKKwkJCSBzdHJ1Y3QgYmZhX2NlZV9hdHRyX3MgKmF0dHIsCisJCQliZmFfY2VlX2dldF9hdHRyX2NiZm5fdCBjYmZuLCB2b2lkICpjYmFyZyk7CitiZmFfc3RhdHVzX3QgYmZhX2NlZV9nZXRfc3RhdHMoc3RydWN0IGJmYV9jZWVfcyAqY2VlLAorCQkJc3RydWN0IGJmYV9jZWVfc3RhdHNfcyAqc3RhdHMsCisJCQliZmFfY2VlX2dldF9zdGF0c19jYmZuX3QgY2Jmbiwgdm9pZCAqY2JhcmcpOworYmZhX3N0YXR1c190IGJmYV9jZWVfcmVzZXRfc3RhdHMoc3RydWN0IGJmYV9jZWVfcyAqY2VlLAorCQkJYmZhX2NlZV9yZXNldF9zdGF0c19jYmZuX3QgY2Jmbiwgdm9pZCAqY2JhcmcpOworI2VuZGlmIC8qIF9fQkZBX0NFRV9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jbmEvcG9ydC9iZmFfcG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2NuYS9wb3J0L2JmYV9wb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2NiZjE3ZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jbmEvcG9ydC9iZmFfcG9ydC5oCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9QT1JUX0hfXworI2RlZmluZSBfX0JGQV9QT1JUX0hfXworCisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wb3J0Lmg+CisjaW5jbHVkZSA8YmZhX2lvYy5oPgorI2luY2x1ZGUgPGNzL2JmYV90cmMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfbG9nLmg+CisKK3R5cGVkZWYgdm9pZCAgICAoKmJmYV9wb3J0X3N0YXRzX2NiZm5fdCkgKHZvaWQgKmRldiwgYmZhX3N0YXR1c190IHN0YXR1cyk7Cit0eXBlZGVmIHZvaWQgICAgKCpiZmFfcG9ydF9lbmRpc19jYmZuX3QpICh2b2lkICpkZXYsIGJmYV9zdGF0dXNfdCBzdGF0dXMpOworCitzdHJ1Y3QgYmZhX3BvcnRfcyB7CisJdm9pZCAgICAgICAgICAgKmRldjsKKwlzdHJ1Y3QgYmZhX2lvY19zICppb2M7CisJc3RydWN0IGJmYV90cmNfbW9kX3MgKnRyY21vZDsKKwlzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbW9kOworCXUzMiAgICAgICAgbXNndGFnOworCWJmYV9ib29sZWFuX3QgICBzdGF0c19idXN5OworCXN0cnVjdCBiZmFfbWJveF9jbWRfcyBzdGF0c19tYjsKKwliZmFfcG9ydF9zdGF0c19jYmZuX3Qgc3RhdHNfY2JmbjsKKwl2b2lkICAgICAgICAgICAqc3RhdHNfY2Jhcmc7CisJYmZhX3N0YXR1c190ICAgIHN0YXRzX3N0YXR1czsKKwl1bmlvbiBiZmFfcHBvcnRfc3RhdHNfdSAqc3RhdHM7CisJc3RydWN0IGJmYV9kbWFfcyBzdGF0c19kbWE7CisJYmZhX2Jvb2xlYW5fdCAgIGVuZGlzX3BlbmRpbmc7CisJc3RydWN0IGJmYV9tYm94X2NtZF9zIGVuZGlzX21iOworCWJmYV9wb3J0X2VuZGlzX2NiZm5fdCBlbmRpc19jYmZuOworCXZvaWQgICAgICAgICAgICplbmRpc19jYmFyZzsKKwliZmFfc3RhdHVzX3QgICAgZW5kaXNfc3RhdHVzOworCXN0cnVjdCBiZmFfaW9jX2hiZmFpbF9ub3RpZnlfcyBoYmZhaWw7Cit9OworCit2b2lkICAgICAgICAgICAgYmZhX3BvcnRfYXR0YWNoKHN0cnVjdCBiZmFfcG9ydF9zICpwb3J0LCBzdHJ1Y3QgYmZhX2lvY19zICppb2MsCisJCQkJdm9pZCAqZGV2LCBzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbW9kLAorCQkJCXN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dtb2QpOwordm9pZCAgICAgICAgICAgIGJmYV9wb3J0X2RldGFjaChzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCk7Cit2b2lkICAgICAgICAgICAgYmZhX3BvcnRfaGJmYWlsKHZvaWQgKmFyZyk7CisKK2JmYV9zdGF0dXNfdCAgICBiZmFfcG9ydF9nZXRfc3RhdHMoc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsCisJCQkJICAgdW5pb24gYmZhX3Bwb3J0X3N0YXRzX3UgKnN0YXRzLAorCQkJCSAgIGJmYV9wb3J0X3N0YXRzX2NiZm5fdCBjYmZuLCB2b2lkICpjYmFyZyk7CitiZmFfc3RhdHVzX3QgICAgYmZhX3BvcnRfY2xlYXJfc3RhdHMoc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsCisJCQkJICAgICBiZmFfcG9ydF9zdGF0c19jYmZuX3QgY2Jmbiwgdm9pZCAqY2JhcmcpOworYmZhX3N0YXR1c190ICAgIGJmYV9wb3J0X2VuYWJsZShzdHJ1Y3QgYmZhX3BvcnRfcyAqcG9ydCwKKwkJCQliZmFfcG9ydF9lbmRpc19jYmZuX3QgY2Jmbiwgdm9pZCAqY2JhcmcpOworYmZhX3N0YXR1c190ICAgIGJmYV9wb3J0X2Rpc2FibGUoc3RydWN0IGJmYV9wb3J0X3MgKnBvcnQsCisJCQkJIGJmYV9wb3J0X2VuZGlzX2NiZm5fdCBjYmZuLCB2b2lkICpjYmFyZyk7Cit1MzIgICAgICAgIGJmYV9wb3J0X21lbWluZm8odm9pZCk7Cit2b2lkICAgICAgICAgICAgYmZhX3BvcnRfbWVtX2NsYWltKHN0cnVjdCBiZmFfcG9ydF9zICpwb3J0LCB1OCAqZG1hX2t2YSwKKwkJCQkgICB1NjQgZG1hX3BhKTsKKworI2VuZGlmIC8qIF9fQkZBX1BPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL3BzdGF0cy9ldGhwb3J0X2RlZnMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jbmEvcHN0YXRzL2V0aHBvcnRfZGVmcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjE1NjNlZTUKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL3BzdGF0cy9ldGhwb3J0X2RlZnMuaApAQCAtMCwwICsxLDM2IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0VUSFBPUlRfREVGU19IX18KKyNkZWZpbmUgX19FVEhQT1JUX0RFRlNfSF9fCisKK3N0cnVjdCBibmFkX2Rydl9zdGF0cyB7CisJdTY0IG5ldGlmX3F1ZXVlX3N0b3A7CisJdTY0IG5ldGlmX3F1ZXVlX3dha2V1cDsKKwl1NjQgdHNvNDsKKwl1NjQgdHNvNjsKKwl1NjQgdHNvX2VycjsKKwl1NjQgdGNwY3N1bV9vZmZsb2FkOworCXU2NCB1ZHBjc3VtX29mZmxvYWQ7CisJdTY0IGNzdW1faGVscDsKKwl1NjQgY3N1bV9oZWxwX2VycjsKKworCXU2NCBod19zdGF0c191cGRhdGVzOworCXU2NCBuZXRpZl9yeF9zY2hlZHVsZTsKKwl1NjQgbmV0aWZfcnhfY29tcGxldGU7CisJdTY0IG5ldGlmX3J4X2Ryb3BwZWQ7Cit9OworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL3BzdGF0cy9waHlwb3J0X2RlZnMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jbmEvcHN0YXRzL3BoeXBvcnRfZGVmcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmViNzU0ODAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY25hL3BzdGF0cy9waHlwb3J0X2RlZnMuaApAQCAtMCwwICsxLDIxOCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19QSFlQT1JUX0RFRlNfSF9fCisjZGVmaW5lIF9fUEhZUE9SVF9ERUZTX0hfXworCisjZGVmaW5lIEJOQV9UWEZfSURfTUFYICAJNjQKKyNkZWZpbmUgQk5BX1JYRl9JRF9NQVggIAk2NAorCisvKgorICogU3RhdGlzdGljcworICovCisKKy8qCisgKiBUeEYgRnJhbWUgU3RhdGlzdGljcworICovCitzdHJ1Y3QgYm5hX3N0YXRzX3R4ZiB7CisJdTY0ICAgICAgICB1Y2FzdF9vY3RldHM7CisJdTY0ICAgICAgICB1Y2FzdDsKKwl1NjQgICAgICAgIHVjYXN0X3ZsYW47CisKKwl1NjQgICAgICAgIG1jYXN0X29jdGV0czsKKwl1NjQgICAgICAgIG1jYXN0OworCXU2NCAgICAgICAgbWNhc3RfdmxhbjsKKworCXU2NCAgICAgICAgYmNhc3Rfb2N0ZXRzOworCXU2NCAgICAgICAgYmNhc3Q7CisJdTY0ICAgICAgICBiY2FzdF92bGFuOworCisJdTY0ICAgICAgICBlcnJvcnM7CisJdTY0ICAgICAgICBmaWx0ZXJfdmxhbjsJLyogZnJhbWVzIGZpbHRlcmVkIGR1ZSB0byBWTEFOICovCisJdTY0ICAgICAgICBmaWx0ZXJfbWFjX3NhOwkvKiBmcmFtZXMgZmlsdGVyZWQgZHVlIHRvIFNBIGNoZWNrICovCit9OworCisvKgorICogUnhGIEZyYW1lIFN0YXRpc3RpY3MKKyAqLworc3RydWN0IGJuYV9zdGF0c19yeGYgeworCXU2NCAgICAgICAgdWNhc3Rfb2N0ZXRzOworCXU2NCAgICAgICAgdWNhc3Q7CisJdTY0ICAgICAgICB1Y2FzdF92bGFuOworCisJdTY0ICAgICAgICBtY2FzdF9vY3RldHM7CisJdTY0ICAgICAgICBtY2FzdDsKKwl1NjQgICAgICAgIG1jYXN0X3ZsYW47CisKKwl1NjQgICAgICAgIGJjYXN0X29jdGV0czsKKwl1NjQgICAgICAgIGJjYXN0OworCXU2NCAgICAgICAgYmNhc3RfdmxhbjsKKwl1NjQgICAgICAgIGZyYW1lX2Ryb3BzOworfTsKKworLyoKKyAqIEZDIFR4IEZyYW1lIFN0YXRpc3RpY3MKKyAqLworc3RydWN0IGJuYV9zdGF0c19mY190eCB7CisJdTY0ICAgICAgICB0eGZfdWNhc3Rfb2N0ZXRzOworCXU2NCAgICAgICAgdHhmX3VjYXN0OworCXU2NCAgICAgICAgdHhmX3VjYXN0X3ZsYW47CisKKwl1NjQgICAgICAgIHR4Zl9tY2FzdF9vY3RldHM7CisJdTY0ICAgICAgICB0eGZfbWNhc3Q7CisJdTY0ICAgICAgICB0eGZfbWNhc3RfdmxhbjsKKworCXU2NCAgICAgICAgdHhmX2JjYXN0X29jdGV0czsKKwl1NjQgICAgICAgIHR4Zl9iY2FzdDsKKwl1NjQgICAgICAgIHR4Zl9iY2FzdF92bGFuOworCisJdTY0ICAgICAgICB0eGZfcGFyaXR5X2Vycm9yczsKKwl1NjQgICAgICAgIHR4Zl90aW1lb3V0OworCXU2NCAgICAgICAgdHhmX2ZpZF9wYXJpdHlfZXJyb3JzOworfTsKKworLyoKKyAqIEZDIFJ4IEZyYW1lIFN0YXRpc3RpY3MKKyAqLworc3RydWN0IGJuYV9zdGF0c19mY19yeCB7CisJdTY0ICAgICAgICByeGZfdWNhc3Rfb2N0ZXRzOworCXU2NCAgICAgICAgcnhmX3VjYXN0OworCXU2NCAgICAgICAgcnhmX3VjYXN0X3ZsYW47CisKKwl1NjQgICAgICAgIHJ4Zl9tY2FzdF9vY3RldHM7CisJdTY0ICAgICAgICByeGZfbWNhc3Q7CisJdTY0ICAgICAgICByeGZfbWNhc3RfdmxhbjsKKworCXU2NCAgICAgICAgcnhmX2JjYXN0X29jdGV0czsKKwl1NjQgICAgICAgIHJ4Zl9iY2FzdDsKKwl1NjQgICAgICAgIHJ4Zl9iY2FzdF92bGFuOworfTsKKworLyoKKyAqIFJBRCBGcmFtZSBTdGF0aXN0aWNzCisgKi8KK3N0cnVjdCBjbmFfc3RhdHNfcmFkIHsKKwl1NjQgICAgICAgIHJ4X2ZyYW1lczsKKwl1NjQgICAgICAgIHJ4X29jdGV0czsKKwl1NjQgICAgICAgIHJ4X3ZsYW5fZnJhbWVzOworCisJdTY0ICAgICAgICByeF91Y2FzdDsKKwl1NjQgICAgICAgIHJ4X3VjYXN0X29jdGV0czsKKwl1NjQgICAgICAgIHJ4X3VjYXN0X3ZsYW47CisKKwl1NjQgICAgICAgIHJ4X21jYXN0OworCXU2NCAgICAgICAgcnhfbWNhc3Rfb2N0ZXRzOworCXU2NCAgICAgICAgcnhfbWNhc3RfdmxhbjsKKworCXU2NCAgICAgICAgcnhfYmNhc3Q7CisJdTY0ICAgICAgICByeF9iY2FzdF9vY3RldHM7CisJdTY0ICAgICAgICByeF9iY2FzdF92bGFuOworCisJdTY0ICAgICAgICByeF9kcm9wczsKK307CisKKy8qCisgKiBCUEMgVHggUmVnaXN0ZXJzCisgKi8KK3N0cnVjdCBjbmFfc3RhdHNfYnBjX3R4IHsKKwl1NjQgICAgICAgIHR4X3BhdXNlWzhdOworCXU2NCAgICAgICAgdHhfemVyb19wYXVzZVs4XTsJLyogIFBhdXNlIGNhbmNlbGxhdGlvbiAqLworCXU2NCAgICAgICAgdHhfZmlyc3RfcGF1c2VbOF07CS8qICBQYXVzZSBpbml0aWF0aW9uIHJhdGhlcgorCQkJCQkJICp0aGFuIHJldGVudGlvbiAqLworfTsKKworLyoKKyAqIEJQQyBSeCBSZWdpc3RlcnMKKyAqLworc3RydWN0IGNuYV9zdGF0c19icGNfcnggeworCXU2NCAgICAgICAgcnhfcGF1c2VbOF07CisJdTY0ICAgICAgICByeF96ZXJvX3BhdXNlWzhdOwkvKiAgUGF1c2UgY2FuY2VsbGF0aW9uICovCisJdTY0ICAgICAgICByeF9maXJzdF9wYXVzZVs4XTsJLyogIFBhdXNlIGluaXRpYXRpb24gcmF0aGVyCisJCQkJCQkgKnRoYW4gcmV0ZW50aW9uICovCit9OworCisvKgorICogTUFDIFJ4IFN0YXRpc3RpY3MKKyAqLworc3RydWN0IGNuYV9zdGF0c19tYWNfcnggeworCXU2NCAgICAgICAgZnJhbWVfNjQ7CS8qIGJvdGggcnggYW5kIHR4IGNvdW50ZXIgKi8KKwl1NjQgICAgICAgIGZyYW1lXzY1XzEyNzsJLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NCAgICAgICAgZnJhbWVfMTI4XzI1NTsJLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NCAgICAgICAgZnJhbWVfMjU2XzUxMTsJLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NCAgICAgICAgZnJhbWVfNTEyXzEwMjM7CS8qIGJvdGggcnggYW5kIHR4IGNvdW50ZXIgKi8KKwl1NjQgICAgICAgIGZyYW1lXzEwMjRfMTUxODsJLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NCAgICAgICAgZnJhbWVfMTUxOF8xNTIyOwkvKiBib3RoIHJ4IGFuZCB0eCBjb3VudGVyICovCisJdTY0ICAgICAgICByeF9ieXRlczsKKwl1NjQgICAgICAgIHJ4X3BhY2tldHM7CisJdTY0ICAgICAgICByeF9mY3NfZXJyb3I7CisJdTY0ICAgICAgICByeF9tdWx0aWNhc3Q7CisJdTY0ICAgICAgICByeF9icm9hZGNhc3Q7CisJdTY0ICAgICAgICByeF9jb250cm9sX2ZyYW1lczsKKwl1NjQgICAgICAgIHJ4X3BhdXNlOworCXU2NCAgICAgICAgcnhfdW5rbm93bl9vcGNvZGU7CisJdTY0ICAgICAgICByeF9hbGlnbm1lbnRfZXJyb3I7CisJdTY0ICAgICAgICByeF9mcmFtZV9sZW5ndGhfZXJyb3I7CisJdTY0ICAgICAgICByeF9jb2RlX2Vycm9yOworCXU2NCAgICAgICAgcnhfY2Fycmllcl9zZW5zZV9lcnJvcjsKKwl1NjQgICAgICAgIHJ4X3VuZGVyc2l6ZTsKKwl1NjQgICAgICAgIHJ4X292ZXJzaXplOworCXU2NCAgICAgICAgcnhfZnJhZ21lbnRzOworCXU2NCAgICAgICAgcnhfamFiYmVyOworCXU2NCAgICAgICAgcnhfZHJvcDsKK307CisKKy8qCisgKiBNQUMgVHggU3RhdGlzdGljcworICovCitzdHJ1Y3QgY25hX3N0YXRzX21hY190eCB7CisJdTY0ICAgICAgICB0eF9ieXRlczsKKwl1NjQgICAgICAgIHR4X3BhY2tldHM7CisJdTY0ICAgICAgICB0eF9tdWx0aWNhc3Q7CisJdTY0ICAgICAgICB0eF9icm9hZGNhc3Q7CisJdTY0ICAgICAgICB0eF9wYXVzZTsKKwl1NjQgICAgICAgIHR4X2RlZmVycmFsOworCXU2NCAgICAgICAgdHhfZXhjZXNzaXZlX2RlZmVycmFsOworCXU2NCAgICAgICAgdHhfc2luZ2xlX2NvbGxpc2lvbjsKKwl1NjQgICAgICAgIHR4X211bGlwbGVfY29sbGlzaW9uOworCXU2NCAgICAgICAgdHhfbGF0ZV9jb2xsaXNpb247CisJdTY0ICAgICAgICB0eF9leGNlc3NpdmVfY29sbGlzaW9uOworCXU2NCAgICAgICAgdHhfdG90YWxfY29sbGlzaW9uOworCXU2NCAgICAgICAgdHhfcGF1c2VfaG9ub3JlZDsKKwl1NjQgICAgICAgIHR4X2Ryb3A7CisJdTY0ICAgICAgICB0eF9qYWJiZXI7CisJdTY0ICAgICAgICB0eF9mY3NfZXJyb3I7CisJdTY0ICAgICAgICB0eF9jb250cm9sX2ZyYW1lOworCXU2NCAgICAgICAgdHhfb3ZlcnNpemU7CisJdTY0ICAgICAgICB0eF91bmRlcnNpemU7CisJdTY0ICAgICAgICB0eF9mcmFnbWVudHM7Cit9OworCisvKgorICogQ29tcGxldGUgc3RhdGlzdGljcworICovCitzdHJ1Y3QgYm5hX3N0YXRzIHsKKwlzdHJ1Y3QgY25hX3N0YXRzX21hY19yeCBtYWNfcnhfc3RhdHM7CisJc3RydWN0IGNuYV9zdGF0c19icGNfcnggYnBjX3J4X3N0YXRzOworCXN0cnVjdCBjbmFfc3RhdHNfcmFkIHJhZF9zdGF0czsKKwlzdHJ1Y3QgYm5hX3N0YXRzX2ZjX3J4IGZjX3J4X3N0YXRzOworCXN0cnVjdCBjbmFfc3RhdHNfbWFjX3R4IG1hY190eF9zdGF0czsKKwlzdHJ1Y3QgY25hX3N0YXRzX2JwY190eCBicGNfdHhfc3RhdHM7CisJc3RydWN0IGJuYV9zdGF0c19mY190eCBmY190eF9zdGF0czsKKwlzdHJ1Y3QgYm5hX3N0YXRzX3J4ZiByeGZfc3RhdHNbQk5BX1RYRl9JRF9NQVhdOworCXN0cnVjdCBibmFfc3RhdHNfdHhmIHR4Zl9zdGF0c1tCTkFfUlhGX0lEX01BWF07Cit9OworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfY2hlY2tzdW0uaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfY2hlY2tzdW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hZjhjMWQ1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2NzL2JmYV9jaGVja3N1bS5oCkBAIC0wLDAgKzEsNjAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2NoZWNrc3VtLmggQkZBIGNoZWNrc3VtIHV0aWxpdGllcworICovCisKKyNpZm5kZWYgX19CRkFfQ0hFQ0tTVU1fSF9fCisjZGVmaW5lIF9fQkZBX0NIRUNLU1VNX0hfXworCitzdGF0aWMgaW5saW5lIHUzMgorYmZhX2NoZWNrc3VtX3UzMih1MzIgKmJ1ZiwgaW50IHN6KQoreworCWludAkJaSwgbSA9IHN6ID4+IDI7CisJdTMyCXN1bSA9IDA7CisKKwlmb3IgKGkgPSAwOyBpIDwgbTsgaSsrKQorCQlzdW0gXj0gYnVmW2ldOworCisJcmV0dXJuIChzdW0pOworfQorCitzdGF0aWMgaW5saW5lIHUxNgorYmZhX2NoZWNrc3VtX3UxNih1MTYgKmJ1ZiwgaW50IHN6KQoreworCWludCAgICAgICAgICAgICBpLCBtID0gc3ogPj4gMTsKKwl1MTYgICAgICAgIHN1bSA9IDA7CisKKwlmb3IgKGkgPSAwOyBpIDwgbTsgaSsrKQorCQlzdW0gXj0gYnVmW2ldOworCisJcmV0dXJuIChzdW0pOworfQorCitzdGF0aWMgaW5saW5lIHU4CitiZmFfY2hlY2tzdW1fdTgodTggKmJ1ZiwgaW50IHN6KQoreworCWludCAgICAgICAgICAgICBpOworCXU4ICAgICAgICAgc3VtID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBzejsgaSsrKQorCQlzdW0gXj0gYnVmW2ldOworCisJcmV0dXJuIChzdW0pOworfQorI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX2RlYnVnLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX2RlYnVnLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDQxYmU4NgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfZGVidWcuaApAQCAtMCwwICsxLDQ0IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9kZWJ1Zy5oIEJGQSBkZWJ1ZyBpbnRlcmZhY2VzCisgKi8KKworI2lmbmRlZiBfX0JGQV9ERUJVR19IX18KKyNkZWZpbmUgX19CRkFfREVCVUdfSF9fCisKKyNkZWZpbmUgYmZhX2Fzc2VydChfX2NvbmQpCWRvIHsJCQkJCVwKKwlpZiAoIShfX2NvbmQpKSAJCQkJCQkJXAorCQliZmFfcGFuaWMoX19MSU5FX18sIF9fRklMRV9fLCAjX19jb25kKTsgICAgICBcCit9IHdoaWxlICgwKQorCisjZGVmaW5lIGJmYV9zbV9mYXVsdChfX21vZCwgX19ldmVudCkJZG8gewkJCQlcCisJYmZhX3NtX3BhbmljKChfX21vZCktPmxvZ20sIF9fTElORV9fLCBfX0ZJTEVfXywgX19ldmVudCk7ICAgICAgXAorfSB3aGlsZSAoMCkKKworI2lmbmRlZiBCRkFfUEVSRl9CVUlMRAorI2RlZmluZSBiZmFfYXNzZXJ0X2ZwKF9fY29uZCkJYmZhX2Fzc2VydChfX2NvbmQpCisjZWxzZQorI2RlZmluZSBiZmFfYXNzZXJ0X2ZwKF9fY29uZCkKKyNlbmRpZgorCitzdHJ1Y3QgYmZhX2xvZ19tb2RfczsKK3ZvaWQgYmZhX3BhbmljKGludCBsaW5lLCBjaGFyICpmaWxlLCBjaGFyICpwYW5pY3N0cik7Cit2b2lkIGJmYV9zbV9wYW5pYyhzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nbSwgaW50IGxpbmUsIGNoYXIgKmZpbGUsIGludCBldmVudCk7CisKKyNlbmRpZiAvKiBfX0JGQV9ERUJVR19IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfbG9nLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX2xvZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc2MWNiZTIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX2xvZy5oCkBAIC0wLDAgKzEsMTg0IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9sb2cuaCBCRkEgbG9nIGxpYnJhcnkgZGF0YSBzdHJ1Y3R1cmUgYW5kIGZ1bmN0aW9uIGRlZmluaXRpb24KKyAqLworCisjaWZuZGVmIF9fQkZBX0xPR19IX18KKyNkZWZpbmUgX19CRkFfTE9HX0hfXworCisjaW5jbHVkZSA8YmZhX29zX2luYy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfc3RhdHVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19hZW4uaD4KKworLyoKKyAqIEJGQSBsb2cgbW9kdWxlIGRlZmluaXRpb24KKyAqCisgKiBUbyBjcmVhdGUgYSBuZXcgbW9kdWxlIGlkOgorICogQWRkIGEgI2RlZmluZSBhdCB0aGUgZW5kIG9mIHRoZSBsaXN0IGJlbG93LiBTZWxlY3QgYSB2YWx1ZSBmb3IgeW91cgorICogZGVmaW5pdGlvbiBzbyB0aGF0IGl0IGlzIG9uZSAoMSkgZ3JlYXRlciB0aGFuIHRoZSBwcmV2aW91cworICogZGVmaW5pdGlvbi4gTW9kaWZ5IHRoZSBkZWZpbml0aW9uIG9mIEJGQV9MT0dfTU9EVUxFX0lEX01BWCB0byBiZWNvbWUKKyAqIHlvdXIgbmV3IGRlZmluaXRpb24uCisgKiBTaG91bGQgaGF2ZSBubyBnYXBzIGluIGJldHdlZW4gdGhlIHZhbHVlcyBiZWNhdXNlIHRoaXMgaXMgdXNlZCBpbiBhcnJheXMuCisgKiBJTVBPUlRBTlQ6IEFFTl9JRHMgbXVzdCBiZSBhdCB0aGUgYmVnaW5pbmcsIG90aGVyd2lzZSB1cGRhdGUgYmZhX2RlZnNfYWVuLmgKKyAqLworCitlbnVtIGJmYV9sb2dfbW9kdWxlX2lkIHsKKwlCRkFfTE9HX1VOVVNFRF9JRAk9IDAsCisKKwkvKiBBRU4gZGVmcyBiZWdpbiAqLworCUJGQV9MT0dfQUVOX01JTgkJPSBCRkFfTE9HX1VOVVNFRF9JRCwKKworCUJGQV9MT0dfQUVOX0lEX0FEQVBURVIgCT0gQkZBX0xPR19BRU5fTUlOICsgQkZBX0FFTl9DQVRfQURBUFRFUiwvKiAxICovCisJQkZBX0xPR19BRU5fSURfUE9SVCAJPSBCRkFfTE9HX0FFTl9NSU4gKyBCRkFfQUVOX0NBVF9QT1JULAkvKiAyICovCisJQkZBX0xPR19BRU5fSURfTFBPUlQgCT0gQkZBX0xPR19BRU5fTUlOICsgQkZBX0FFTl9DQVRfTFBPUlQsCS8qIDMgKi8KKwlCRkFfTE9HX0FFTl9JRF9SUE9SVCAJPSBCRkFfTE9HX0FFTl9NSU4gKyBCRkFfQUVOX0NBVF9SUE9SVCwJLyogNCAqLworCUJGQV9MT0dfQUVOX0lEX0lUTklNIAk9IEJGQV9MT0dfQUVOX01JTiArIEJGQV9BRU5fQ0FUX0lUTklNLAkvKiA1ICovCisJQkZBX0xPR19BRU5fSURfVElOIAk9IEJGQV9MT0dfQUVOX01JTiArIEJGQV9BRU5fQ0FUX1RJTiwJLyogNiAqLworCUJGQV9MT0dfQUVOX0lEX0lQRkMgCT0gQkZBX0xPR19BRU5fTUlOICsgQkZBX0FFTl9DQVRfSVBGQywJLyogNyAqLworCUJGQV9MT0dfQUVOX0lEX0FVRElUIAk9IEJGQV9MT0dfQUVOX01JTiArIEJGQV9BRU5fQ0FUX0FVRElULAkvKiA4ICovCisJQkZBX0xPR19BRU5fSURfSU9DCT0gQkZBX0xPR19BRU5fTUlOICsgQkZBX0FFTl9DQVRfSU9DLAkvKiA5ICovCisJQkZBX0xPR19BRU5fSURfRVRIUE9SVAk9IEJGQV9MT0dfQUVOX01JTiArIEJGQV9BRU5fQ0FUX0VUSFBPUlQsLyogMTAgKi8KKworCUJGQV9MT0dfQUVOX01BWAkJPSBCRkFfTE9HX0FFTl9JRF9FVEhQT1JULAorCS8qIEFFTiBkZWZzIGVuZCAqLworCisJQkZBX0xPR19NT0RVTEVfSURfTUlOCT0gQkZBX0xPR19BRU5fTUFYLAorCisJQkZBX0xPR19GV19JRAkJPSBCRkFfTE9HX01PRFVMRV9JRF9NSU4gKyAxLAorCUJGQV9MT0dfSEFMX0lECQk9IEJGQV9MT0dfTU9EVUxFX0lEX01JTiArIDIsCisJQkZBX0xPR19GQ1NfSUQJCT0gQkZBX0xPR19NT0RVTEVfSURfTUlOICsgMywKKwlCRkFfTE9HX1dEUlZfSUQJCT0gQkZBX0xPR19NT0RVTEVfSURfTUlOICsgNCwKKwlCRkFfTE9HX0xJTlVYX0lECT0gQkZBX0xPR19NT0RVTEVfSURfTUlOICsgNSwKKwlCRkFfTE9HX1NPTEFSSVNfSUQJPSBCRkFfTE9HX01PRFVMRV9JRF9NSU4gKyA2LAorCisJQkZBX0xPR19NT0RVTEVfSURfTUFYIAk9IEJGQV9MT0dfU09MQVJJU19JRCwKKworCS8qIE5vdCBwYXJ0IG9mIGFueSBhcnJheXMgKi8KKwlCRkFfTE9HX01PRFVMRV9JRF9BTEwgCT0gQkZBX0xPR19NT0RVTEVfSURfTUFYICsgMSwKKwlCRkFfTE9HX0FFTl9BTEwgCT0gQkZBX0xPR19NT0RVTEVfSURfTUFYICsgMiwKKwlCRkFfTE9HX0RSVl9BTEwJCT0gQkZBX0xPR19NT0RVTEVfSURfTUFYICsgMywKK307CisKKy8qCisgKiBCRkEgbG9nIGNhdGFsb2cgbmFtZQorICovCisjZGVmaW5lIEJGQV9MT0dfQ0FUX05BTUUJIkJGQSIKKworLyoKKyAqIGJmYSBsb2cgc2V2ZXJpdHkgdmFsdWVzCisgKi8KK2VudW0gYmZhX2xvZ19zZXZlcml0eSB7CisJQkZBX0xPR19JTlZBTElEID0gMCwKKwlCRkFfTE9HX0NSSVRJQ0FMID0gMSwKKwlCRkFfTE9HX0VSUk9SID0gMiwKKwlCRkFfTE9HX1dBUk5JTkcgPSAzLAorCUJGQV9MT0dfSU5GTyA9IDQsCisJQkZBX0xPR19OT05FID0gNSwKKwlCRkFfTE9HX0xFVkVMX01BWCA9IEJGQV9MT0dfTk9ORQorfTsKKworI2RlZmluZSBCRkFfTE9HX01PRElEX09GRlNFVAkJMTYKKworCitzdHJ1Y3QgYmZhX2xvZ19tc2dkZWZfcyB7CisJdTMyCW1zZ19pZDsJCS8qICBtZXNzYWdlIGlkICovCisJaW50CQlhdHRyaWJ1dGVzOwkvKiAgYXR0cmlidXRlcyAqLworCWludAkJc2V2ZXJpdHk7CS8qICBzZXZlcml0eSBsZXZlbCAqLworCWNoYXIJCSptc2dfdmFsdWU7CisJCQkJCS8qICBtc2cgc3RyaW5nICovCisJY2hhcgkJKm1lc3NhZ2U7CisJCQkJCS8qICBtc2cgZm9ybWF0IHN0cmluZyAqLworCWludAkJYXJnX3R5cGU7CS8qICBhcmd1bWVudCB0eXBlICovCisJaW50CQlhcmdfbnVtOwkvKiAgbnVtYmVyIG9mIGFyZ3VtZW50ICovCit9OworCisvKgorICogc3VwcG9ydGVkIGFyZ3VtZW50IHR5cGUKKyAqLworZW51bSBiZmFfbG9nX2FyZ190eXBlIHsKKwlCRkFfTE9HX1MgPSAwLAkJLyogIHN0cmluZyAqLworCUJGQV9MT0dfRCwJCS8qICBkZWNpbWFsICovCisJQkZBX0xPR19JLAkJLyogIGludGVnZXIgKi8KKwlCRkFfTE9HX08sCQkvKiAgb2N0IG51bWJlciAqLworCUJGQV9MT0dfVSwJCS8qICB1bnNpZ25lZCBpbnRlZ2VyICovCisJQkZBX0xPR19YLAkJLyogIGhleCBudW1iZXIgKi8KKwlCRkFfTE9HX0YsCQkvKiAgZmxvYXRpbmcgKi8KKwlCRkFfTE9HX0MsCQkvKiAgY2hhcmFjdGVyICovCisJQkZBX0xPR19MLAkJLyogIGRvdWJsZSAqLworCUJGQV9MT0dfUAkJLyogIHBvaW50ZXIgKi8KK307CisKKyNkZWZpbmUgQkZBX0xPR19BUkdfVFlQRQkyCisjZGVmaW5lIEJGQV9MT0dfQVJHMAkJKDAgKiBCRkFfTE9HX0FSR19UWVBFKQorI2RlZmluZSBCRkFfTE9HX0FSRzEJCSgxICogQkZBX0xPR19BUkdfVFlQRSkKKyNkZWZpbmUgQkZBX0xPR19BUkcyCQkoMiAqIEJGQV9MT0dfQVJHX1RZUEUpCisjZGVmaW5lIEJGQV9MT0dfQVJHMwkJKDMgKiBCRkFfTE9HX0FSR19UWVBFKQorCisjZGVmaW5lIEJGQV9MT0dfR0VUX01PRF9JRChtc2dpZCkgKChtc2dpZCA+PiBCRkFfTE9HX01PRElEX09GRlNFVCkgJiAweGZmKQorI2RlZmluZSBCRkFfTE9HX0dFVF9NU0dfSURYKG1zZ2lkKSAobXNnaWQgJiAweGZmZmYpCisjZGVmaW5lIEJGQV9MT0dfR0VUX01TR19JRChtc2dkZWYpICgobXNnZGVmKS0+bXNnX2lkKQorI2RlZmluZSBCRkFfTE9HX0dFVF9NU0dfRk1UX1NUUklORyhtc2dkZWYpICgobXNnZGVmKS0+bWVzc2FnZSkKKyNkZWZpbmUgQkZBX0xPR19HRVRfU0VWRVJJVFkobXNnZGVmKSAoKG1zZ2RlZiktPnNldmVyaXR5KQorCisvKgorICogRXZlbnQgYXR0cmlidXRlcworICovCisjZGVmaW5lIEJGQV9MT0dfQVRUUl9OT05FCTAKKyNkZWZpbmUgQkZBX0xPR19BVFRSX0FVRElUCTEKKyNkZWZpbmUgQkZBX0xPR19BVFRSX0xPRwkyCisjZGVmaW5lIEJGQV9MT0dfQVRUUl9GRkRDCTQKKworI2RlZmluZSBCRkFfTE9HX0NSRUFURV9JRChtc3csIGxzdykgXAorCSgoKHUzMiltc3cgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgbHN3KQorCitzdHJ1Y3QgYmZhX2xvZ19tb2RfczsKKworLyoqCisgKiBjYWxsYmFjayBmdW5jdGlvbgorICovCit0eXBlZGVmIHZvaWQgKCpiZmFfbG9nX2NiX3QpKHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dfbW9kLCB1MzIgbXNnX2lkLAorCQkJY29uc3QgY2hhciAqZm9ybWF0LCAuLi4pOworCisKK3N0cnVjdCBiZmFfbG9nX21vZF9zIHsKKwljaGFyCQlpbnN0YW5jZV9pbmZvWzE2XTsJLyogIGluc3RhbmNlIGluZm8gKi8KKwlpbnQJCWxvZ19sZXZlbFtCRkFfTE9HX01PRFVMRV9JRF9NQVggKyAxXTsKKwkJCQkJCS8qICBsb2cgbGV2ZWwgZm9yIG1vZHVsZXMgKi8KKwliZmFfbG9nX2NiX3QJY2JmbjsgCQkJLyogIGNhbGxiYWNrIGZ1bmN0aW9uICovCit9OworCitleHRlcm4gaW50IGJmYV9sb2dfaW5pdChzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nX21vZCwKKwkJCWNoYXIgKmluc3RhbmNlX25hbWUsIGJmYV9sb2dfY2JfdCBjYmZuKTsKK2V4dGVybiBpbnQgYmZhX2xvZyhzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nX21vZCwgdTMyIG1zZ19pZCwgLi4uKTsKK2V4dGVybiBiZmFfc3RhdHVzX3QgYmZhX2xvZ19zZXRfbGV2ZWwoc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ19tb2QsCisJCQlpbnQgbW9kX2lkLCBlbnVtIGJmYV9sb2dfc2V2ZXJpdHkgbG9nX2xldmVsKTsKK2V4dGVybiBiZmFfc3RhdHVzX3QgYmZhX2xvZ19zZXRfbGV2ZWxfYWxsKHN0cnVjdCBiZmFfbG9nX21vZF9zICpsb2dfbW9kLAorCQkJZW51bSBiZmFfbG9nX3NldmVyaXR5IGxvZ19sZXZlbCk7CitleHRlcm4gYmZhX3N0YXR1c190IGJmYV9sb2dfc2V0X2xldmVsX2FlbihzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nX21vZCwKKwkJCWVudW0gYmZhX2xvZ19zZXZlcml0eSBsb2dfbGV2ZWwpOworZXh0ZXJuIGVudW0gYmZhX2xvZ19zZXZlcml0eSBiZmFfbG9nX2dldF9sZXZlbChzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nX21vZCwKKwkJCWludCBtb2RfaWQpOworZXh0ZXJuIGVudW0gYmZhX2xvZ19zZXZlcml0eSBiZmFfbG9nX2dldF9tc2dfbGV2ZWwoCisJCQlzdHJ1Y3QgYmZhX2xvZ19tb2RfcyAqbG9nX21vZCwgdTMyIG1zZ19pZCk7CisvKgorICogYXJyYXkgb2YgbWVzc2FnZXMgZ2VuZXJhdGVkIGZyb20geG1sIGZpbGVzCisgKi8KK2V4dGVybiBzdHJ1Y3QgYmZhX2xvZ19tc2dkZWZfcyBiZmFfbG9nX21zZ19hcnJheVtdOworCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfcGVyZi5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2NzL2JmYV9wZXJmLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDVhYTVmOQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfcGVyZi5oCkBAIC0wLDAgKzEsMzQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRkFEX1BFUkZfSF9fCisjZGVmaW5lIF9fQkZBRF9QRVJGX0hfXworCisjaWZkZWYgQkZBRF9QRVJGX0JVSUxECisKKyN1bmRlZiBiZmFfdHJjCisjdW5kZWYgYmZhX3RyYzMyCisjdW5kZWYgYmZhX2Fzc2VydAorI3VuZGVmIEJGQV9UUkNfRklMRQorCisjZGVmaW5lIGJmYV90cmMoX3RyY3AsIF9kYXRhKQorI2RlZmluZSBiZmFfdHJjMzIoX3RyY3AsIF9kYXRhKQorI2RlZmluZSBiZmFfYXNzZXJ0KF9fY29uZCkKKyNkZWZpbmUgQkZBX1RSQ19GSUxFKF9fbW9kLCBfX3N1Ym1vZCkKKworI2VuZGlmCisKKyNlbmRpZiAvKiBfX0JGQURfUEVSRl9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfcGxvZy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2NzL2JmYV9wbG9nLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjcwZjg2ZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfcGxvZy5oCkBAIC0wLDAgKzEsMTYyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX1BPUlRMT0dfSF9fCisjZGVmaW5lIF9fQkZBX1BPUlRMT0dfSF9fCisKKyNpbmNsdWRlICJwcm90b2NvbC9mYy5oIgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfdHlwZXMuaD4KKworI2RlZmluZSBCRkFfUExfTkxPR19FTlRTIDI1NgorI2RlZmluZSBCRkFfUExfTE9HX1JFQ19JTkNSKF94KSAoKF94KSsrLCAoX3gpICU9IEJGQV9QTF9OTE9HX0VOVFMpCisKKyNkZWZpbmUgQkZBX1BMX1NUUklOR19MT0dfU1ogICAzMiAgIC8qIG51bWJlciBvZiBjaGFycyBpbiBzdHJpbmcgbG9nICovCisjZGVmaW5lIEJGQV9QTF9JTlRfTE9HX1NaICAgICAgOCAgICAvKiBudW1iZXIgb2YgaW50ZWdlcnMgaW4gdGhlIGludGVnZXIgbG9nICovCisKK2VudW0gYmZhX3Bsb2dfbG9nX3R5cGUgeworCUJGQV9QTF9MT0dfVFlQRV9JTlZBTElEID0gMCwKKwlCRkFfUExfTE9HX1RZUEVfSU5UIAk9IDEsCisJQkZBX1BMX0xPR19UWVBFX1NUUklORyAJPSAyLAorfTsKKworLyoKKyAqIHRoZSAoZml4ZWQgc2l6ZSkgcmVjb3JkIGZvcm1hdCBmb3IgZWFjaCBlbnRyeSBpbiB0aGUgcG9ydGxvZworICovCitzdHJ1Y3QgYmZhX3Bsb2dfcmVjX3MgeworCXUzMiAgICAgICAgdHY7CS8qIEZpbGxlZCBieSB0aGUgcG9ydGxvZyBkcml2ZXIgd2hlbiB0aGUgKgorCQkJCSAqIGVudHJ5IGlzIGFkZGVkIHRvIHRoZSBjaXJjdWxhciBsb2cuICAgKi8KKwl1OCAgICAgICAgIHBvcnQ7CS8qIFNvdXJjZSBwb3J0IHRoYXQgbG9nZ2VkIHRoaXMgZW50cnkuIENNCisJCQkJICogZW50aXRpZXMgd2lsbCB1c2UgMHhGRiAqLworCXU4ICAgICAgICAgbWlkOwkvKiBJbnRlZ2VyIHZhbHVlIHRvIGJlIHVzZWQgYnkgYWxsIGVudGl0aWVzICoKKwkJCQkgKiB3aGlsZSBsb2dnaW5nLiBUaGUgbW9kdWxlIGlkIHRvIHN0cmluZyAgICoKKwkJCQkgKiBjb252ZXJzaW9uIHdpbGwgYmUgZG9uZSBieSBCRkFMLiBTZWUKKwkJCQkgKiBlbnVtIGJmYV9wbG9nX21pZCAqLworCXU4ICAgICAgICAgZWlkOwkvKiBpbmRpY2F0ZXMgUngsIFR4LCBJT0NUTCwgZXRjLiBTZWUKKwkJCQkgKiBlbnVtIGJmYV9wbG9nX2VpZCAqLworCXU4ICAgICAgICAgbG9nX3R5cGU7IC8qIGluZGljYXRlcyBzdHJpbmcgbG9nIG9yIGludGVnZXIgbG9nLgorCQkJCSAgICogc2VlIGJmYV9wbG9nX2xvZ190eXBlX3QgKi8KKwl1OCAgICAgICAgIGxvZ19udW1faW50czsKKwkvKgorCSAqIGludGVycHJldGVkIG9ubHkgaWYgbG9nX3R5cGUgaXMgSU5UX0xPRy4gaW5kaWNhdGVzIG51bWJlciBvZgorCSAqIGludGVnZXJzIGluIHRoZSBpbnRfbG9nW10gKDAtUExfSU5UX0xPR19TWikuCisJICovCisJdTggICAgICAgICByc3ZkOworCXUxNiAgICAgICAgbWlzYzsJLyogY2FuIGJlIHVzZWQgdG8gaW5kaWNhdGUgZmMgZnJhbWUgbGVuZ3RoLAorCQkJCSAqZXRjLi4gKi8KKwl1bmlvbiB7CisJCWNoYXIgICAgICAgICAgICBzdHJpbmdfbG9nW0JGQV9QTF9TVFJJTkdfTE9HX1NaXTsKKwkJdTMyICAgICAgICBpbnRfbG9nW0JGQV9QTF9JTlRfTE9HX1NaXTsKKwl9IGxvZ19lbnRyeTsKKworfTsKKworLyoKKyAqIHRoZSBmb2xsb3dpbmcgI2RlZmluZXMgd2lsbCBiZSB1c2VkIGJ5IHRoZSBsb2dnaW5nIGVudGl0aWVzIHRvIGluZGljYXRlCisgKiB0aGVpciBtb2R1bGUgaWQuIEJGQUwgd2lsbCBjb252ZXJ0IHRoZSBpbnRlZ2VyIHZhbHVlIHRvIHN0cmluZyBmb3JtYXQKKyAqCisqIHByb2Nlc3MgdG8gYmUgdXNlZCB3aGlsZSBjaGFuZ2luZyB0aGUgZm9sbG93aW5nICNkZWZpbmVzOgorICogIC0gQWx3YXlzIGFkZCBuZXcgZW50cmllcyBhdCB0aGUgZW5kCisgKiAgLSBkZWZpbmUgY29ycmVzcG9uZGluZyBzdHJpbmcgaW4gQkZBTAorICogIC0gRG8gbm90IHJlbW92ZSBhbnkgZW50cnkgb3IgcmVhcnJhbmdlIHRoZSBvcmRlci4KKyAqLworZW51bSBiZmFfcGxvZ19taWQgeworCUJGQV9QTF9NSURfSU5WQUxJRCAJPSAwLAorCUJGQV9QTF9NSURfREVCVUcgCT0gMSwKKwlCRkFfUExfTUlEX0RSVlIgCT0gMiwKKwlCRkFfUExfTUlEX0hBTCAJCT0gMywKKwlCRkFfUExfTUlEX0hBTF9GQ1hQIAk9IDQsCisJQkZBX1BMX01JRF9IQUxfVUYgCT0gNSwKKwlCRkFfUExfTUlEX0ZDUyAJCT0gNiwKKwlCRkFfUExfTUlEX01BWCAJCT0gNworfTsKKworI2RlZmluZSBCRkFfUExfTUlEX1NUUkxFTiAgICA4CitzdHJ1Y3QgYmZhX3Bsb2dfbWlkX3N0cmluZ3NfcyB7CisJY2hhciAgICAgICAgICAgIG1fc3RyW0JGQV9QTF9NSURfU1RSTEVOXTsKK307CisKKy8qCisgKiB0aGUgZm9sbG93aW5nICNkZWZpbmVzIHdpbGwgYmUgdXNlZCBieSB0aGUgbG9nZ2luZyBlbnRpdGllcyB0byBpbmRpY2F0ZQorICogdGhlaXIgZXZlbnQgdHlwZS4gQkZBTCB3aWxsIGNvbnZlcnQgdGhlIGludGVnZXIgdmFsdWUgdG8gc3RyaW5nIGZvcm1hdAorICoKKyogcHJvY2VzcyB0byBiZSB1c2VkIHdoaWxlIGNoYW5naW5nIHRoZSBmb2xsb3dpbmcgI2RlZmluZXM6CisgKiAgLSBBbHdheXMgYWRkIG5ldyBlbnRyaWVzIGF0IHRoZSBlbmQKKyAqICAtIGRlZmluZSBjb3JyZXNwb25kaW5nIHN0cmluZyBpbiBCRkFMCisgKiAgLSBEbyBub3QgcmVtb3ZlIGFueSBlbnRyeSBvciByZWFycmFuZ2UgdGhlIG9yZGVyLgorICovCitlbnVtIGJmYV9wbG9nX2VpZCB7CisJQkZBX1BMX0VJRF9JTlZBTElEIAkJPSAwLAorCUJGQV9QTF9FSURfSU9DX0RJU0FCTEUgCQk9IDEsCisJQkZBX1BMX0VJRF9JT0NfRU5BQkxFIAkJPSAyLAorCUJGQV9QTF9FSURfUE9SVF9ESVNBQkxFIAk9IDMsCisJQkZBX1BMX0VJRF9QT1JUX0VOQUJMRSAJCT0gNCwKKwlCRkFfUExfRUlEX1BPUlRfU1RfQ0hBTkdFIAk9IDUsCisJQkZBX1BMX0VJRF9UWCAJCQk9IDYsCisJQkZBX1BMX0VJRF9UWF9BQ0sxIAkJPSA3LAorCUJGQV9QTF9FSURfVFhfUkpUIAkJPSA4LAorCUJGQV9QTF9FSURfVFhfQlNZIAkJPSA5LAorCUJGQV9QTF9FSURfUlggCQkJPSAxMCwKKwlCRkFfUExfRUlEX1JYX0FDSzEgCQk9IDExLAorCUJGQV9QTF9FSURfUlhfUkpUIAkJPSAxMiwKKwlCRkFfUExfRUlEX1JYX0JTWSAJCT0gMTMsCisJQkZBX1BMX0VJRF9DVF9JTiAJCT0gMTQsCisJQkZBX1BMX0VJRF9DVF9PVVQgCQk9IDE1LAorCUJGQV9QTF9FSURfRFJJVkVSX1NUQVJUIAk9IDE2LAorCUJGQV9QTF9FSURfUlNDTiAJCT0gMTcsCisJQkZBX1BMX0VJRF9ERUJVRyAJCT0gMTgsCisJQkZBX1BMX0VJRF9NSVNDIAkJPSAxOSwKKwlCRkFfUExfRUlEX01BWCAJCQk9IDIwCit9OworCisjZGVmaW5lIEJGQV9QTF9FTkFNRV9TVFJMRU4gICAgCTgKK3N0cnVjdCBiZmFfcGxvZ19laWRfc3RyaW5nc19zIHsKKwljaGFyICAgICAgICAgICAgZV9zdHJbQkZBX1BMX0VOQU1FX1NUUkxFTl07Cit9OworCisjZGVmaW5lIEJGQV9QTF9TSUdfTEVOCTgKKyNkZWZpbmUgQkZBX1BMX1NJR19TVFIgICIxMnBsMTIzIgorCisvKgorICogcGVyIHBvcnQgY2lyY3VsYXIgbG9nIGJ1ZmZlcgorICovCitzdHJ1Y3QgYmZhX3Bsb2dfcyB7CisJY2hhciAgICAgICAgICAgIHBsb2dfc2lnW0JGQV9QTF9TSUdfTEVOXTsJLyogU3RhcnQgc2lnbmF0dXJlICovCisJdTggICAgICAgICBwbG9nX2VuYWJsZWQ7CisJdTggICAgICAgICByc3ZkWzddOworCXUzMiAgICAgICAgdGlja3M7CisJdTE2ICAgICAgICBoZWFkOworCXUxNiAgICAgICAgdGFpbDsKKwlzdHJ1Y3QgYmZhX3Bsb2dfcmVjX3MgIHBsb2dfcmVjc1tCRkFfUExfTkxPR19FTlRTXTsKK307CisKK3ZvaWQgYmZhX3Bsb2dfaW5pdChzdHJ1Y3QgYmZhX3Bsb2dfcyAqcGxvZyk7Cit2b2lkIGJmYV9wbG9nX3N0cihzdHJ1Y3QgYmZhX3Bsb2dfcyAqcGxvZywgZW51bSBiZmFfcGxvZ19taWQgbWlkLAorCQkJZW51bSBiZmFfcGxvZ19laWQgZXZlbnQsIHUxNiBtaXNjLCBjaGFyICpsb2dfc3RyKTsKK3ZvaWQgYmZhX3Bsb2dfaW50YXJyKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nLCBlbnVtIGJmYV9wbG9nX21pZCBtaWQsCisJCQllbnVtIGJmYV9wbG9nX2VpZCBldmVudCwgdTE2IG1pc2MsCisJCQl1MzIgKmludGFyciwgdTMyIG51bV9pbnRzKTsKK3ZvaWQgYmZhX3Bsb2dfZmNoZHIoc3RydWN0IGJmYV9wbG9nX3MgKnBsb2csIGVudW0gYmZhX3Bsb2dfbWlkIG1pZCwKKwkJCWVudW0gYmZhX3Bsb2dfZWlkIGV2ZW50LCB1MTYgbWlzYywKKwkJCXN0cnVjdCBmY2hzX3MgKmZjaGRyKTsKK3ZvaWQgYmZhX3Bsb2dfZmNoZHJfYW5kX3BsKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nLCBlbnVtIGJmYV9wbG9nX21pZCBtaWQsCisJCQllbnVtIGJmYV9wbG9nX2VpZCBldmVudCwgdTE2IG1pc2MsCisJCQlzdHJ1Y3QgZmNoc19zICpmY2hkciwgdTMyIHBsZF93MCk7Cit2b2lkIGJmYV9wbG9nX2NsZWFyKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nKTsKK3ZvaWQgYmZhX3Bsb2dfZW5hYmxlKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nKTsKK3ZvaWQgYmZhX3Bsb2dfZGlzYWJsZShzdHJ1Y3QgYmZhX3Bsb2dfcyAqcGxvZyk7CitiZmFfYm9vbGVhbl90CWJmYV9wbG9nX2dldF9zZXR0aW5nKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nKTsKKworI2VuZGlmIC8qIF9fQkZBX1BPUlRMT0dfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX3EuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfcS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmVhODk1ZmEKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX3EuaApAQCAtMCwwICsxLDgxIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9xLmggQ2lyY3VsYXIgcXVldWUgZGVmaW5pdGlvbnMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9RX0hfXworI2RlZmluZSBfX0JGQV9RX0hfXworCisjZGVmaW5lIGJmYV9xX2ZpcnN0KF9xKSAoKHZvaWQgKikoKChzdHJ1Y3QgbGlzdF9oZWFkICopIChfcSkpLT5uZXh0KSkKKyNkZWZpbmUgYmZhX3FfbmV4dChfcWUpCSgoKHN0cnVjdCBsaXN0X2hlYWQgKikgKF9xZSkpLT5uZXh0KQorI2RlZmluZSBiZmFfcV9wcmV2KF9xZSkgKCgoc3RydWN0IGxpc3RfaGVhZCAqKSAoX3FlKSktPnByZXYpCisKKy8qCisgKiBiZmFfcV9xZV9pbml0IC0gdG8gaW5pdGlhbGl6ZSBhIHF1ZXVlIGVsZW1lbnQKKyAqLworI2RlZmluZSBiZmFfcV9xZV9pbml0KF9xZSkgewkJCQkJCVwKKwliZmFfcV9uZXh0KF9xZSkgPSAoc3RydWN0IGxpc3RfaGVhZCAqKSBOVUxMOwkJCVwKKwliZmFfcV9wcmV2KF9xZSkgPSAoc3RydWN0IGxpc3RfaGVhZCAqKSBOVUxMOwkJCVwKK30KKworLyoKKyAqIGJmYV9xX2RlcSAtIGRlcXVldWUgYW4gZWxlbWVudCBmcm9tIGhlYWQgb2YgdGhlIHF1ZXVlCisgKi8KKyNkZWZpbmUgYmZhX3FfZGVxKF9xLCBfcWUpIHsJCQkJCQlcCisJaWYgKCFsaXN0X2VtcHR5KF9xKSkgewkJCQkJXAorCQkoKigoc3RydWN0IGxpc3RfaGVhZCAqKikgKF9xZSkpKSA9IGJmYV9xX25leHQoX3EpOwlcCisJCWJmYV9xX3ByZXYoYmZhX3FfbmV4dCgqKChzdHJ1Y3QgbGlzdF9oZWFkICoqKSBfcWUpKSkgPQlcCisJCQkJCQkoc3RydWN0IGxpc3RfaGVhZCAqKSAoX3EpOyBcCisJCWJmYV9xX25leHQoX3EpID0gYmZhX3FfbmV4dCgqKChzdHJ1Y3QgbGlzdF9oZWFkICoqKSBfcWUpKTsgXAorCQlCRkFfUV9EQkdfSU5JVCgqKChzdHJ1Y3QgbGlzdF9oZWFkICoqKSBfcWUpKTsJCVwKKwl9IGVsc2UgewkJCQkJCQlcCisJCSooKHN0cnVjdCBsaXN0X2hlYWQgKiopIChfcWUpKSA9IChzdHJ1Y3QgbGlzdF9oZWFkICopIE5VTEw7IFwKKwl9CQkJCQkJCQlcCit9CisKKy8qCisgKiBiZmFfcV9kZXFfdGFpbCAtIGRlcXVldWUgYW4gZWxlbWVudCBmcm9tIHRhaWwgb2YgdGhlIHF1ZXVlCisgKi8KKyNkZWZpbmUgYmZhX3FfZGVxX3RhaWwoX3EsIF9xZSkgewkJCQkJICAgIFwKKwlpZiAoIWxpc3RfZW1wdHkoX3EpKSB7CQkJCQkgICAgICAgICAgICBcCisJCSooKHN0cnVjdCBsaXN0X2hlYWQgKiopIChfcWUpKSA9IGJmYV9xX3ByZXYoX3EpOwkgICAgXAorCQliZmFfcV9uZXh0KGJmYV9xX3ByZXYoKigoc3RydWN0IGxpc3RfaGVhZCAqKikgX3FlKSkpID0gCSAgICBcCisJCQkJCQkoc3RydWN0IGxpc3RfaGVhZCAqKSAoX3EpOyAgXAorCQliZmFfcV9wcmV2KF9xKSA9IGJmYV9xX3ByZXYoKihzdHJ1Y3QgbGlzdF9oZWFkICoqKSBfcWUpOyAgICBcCisJCUJGQV9RX0RCR19JTklUKCooKHN0cnVjdCBsaXN0X2hlYWQgKiopIF9xZSkpOwkJICAgIFwKKwl9IGVsc2UgewkJCQkJCQkgICAgXAorCQkqKChzdHJ1Y3QgbGlzdF9oZWFkICoqKSAoX3FlKSkgPSAoc3RydWN0IGxpc3RfaGVhZCAqKSBOVUxMOyBcCisJfQkJCQkJCQkJICAgIFwKK30KKworLyoKKyAqICNpZmRlZiBCRkFfREVCVUcgKFVzaW5nIGJmYV9hc3NlcnQgdG8gY2hlY2sgZm9yIGRlYnVnX2J1aWxkIGlzIG5vdAorICogY29uc2lzdGVudCBhY3Jvc3MgbW9kdWxlcykKKyAqLworI2lmbmRlZiBCRkFfUEVSRl9CVUlMRAorI2RlZmluZSBCRkFfUV9EQkdfSU5JVChfcWUpCWJmYV9xX3FlX2luaXQoX3FlKQorI2Vsc2UKKyNkZWZpbmUgQkZBX1FfREJHX0lOSVQoX3FlKQorI2VuZGlmCisKKyNkZWZpbmUgYmZhX3FfaXNfb25fcShfcSwgX3FlKQkJXAorCWJmYV9xX2lzX29uX3FfZnVuYyhfcSwgKHN0cnVjdCBsaXN0X2hlYWQgKikoX3FlKSkKK2V4dGVybiBpbnQgYmZhX3FfaXNfb25fcV9mdW5jKHN0cnVjdCBsaXN0X2hlYWQgKnEsIHN0cnVjdCBsaXN0X2hlYWQgKnFlKTsKKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX3NtLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvY3MvYmZhX3NtLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTg3NzA2NgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfc20uaApAQCAtMCwwICsxLDY5IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYXNtLmggU3RhdGUgbWFjaGluZSBkZWZpbmVzCisgKi8KKworI2lmbmRlZiBfX0JGQV9TTV9IX18KKyNkZWZpbmUgX19CRkFfU01fSF9fCisKK3R5cGVkZWYgdm9pZCAoKmJmYV9zbV90KSh2b2lkICpzbSwgaW50IGV2ZW50KTsKKworI2RlZmluZSBiZmFfc21fc2V0X3N0YXRlKF9zbSwgX3N0YXRlKQkoX3NtKS0+c20gPSAoYmZhX3NtX3QpKF9zdGF0ZSkKKyNkZWZpbmUgYmZhX3NtX3NlbmRfZXZlbnQoX3NtLCBfZXZlbnQpCShfc20pLT5zbSgoX3NtKSwgKF9ldmVudCkpCisjZGVmaW5lIGJmYV9zbV9nZXRfc3RhdGUoX3NtKQkJKChfc20pLT5zbSkKKyNkZWZpbmUgYmZhX3NtX2NtcF9zdGF0ZShfc20sIF9zdGF0ZSkJKChfc20pLT5zbSA9PSAoYmZhX3NtX3QpKF9zdGF0ZSkpCisKKy8qKgorICogRm9yIGNvbnZlcnRpbmcgZnJvbSBzdGF0ZSBtYWNoaW5lIGZ1bmN0aW9uIHRvIHN0YXRlIGVuY29kaW5nLgorICovCitzdHJ1Y3QgYmZhX3NtX3RhYmxlX3MgeworCWJmYV9zbV90CXNtOwkvKiAgc3RhdGUgbWFjaGluZSBmdW5jdGlvbgkqLworCWludAkJc3RhdGU7CS8qICBzdGF0ZSBtYWNoaW5lIGVuY29kaW5nCSovCisJY2hhcgkJKm5hbWU7CS8qICBzdGF0ZSBuYW1lIGZvciBkaXNwbGF5CSovCit9OworI2RlZmluZSBCRkFfU00oX3NtKQkoKGJmYV9zbV90KShfc20pKQorCitpbnQgYmZhX3NtX3RvX3N0YXRlKHN0cnVjdCBiZmFfc21fdGFibGVfcyAqc210LCBiZmFfc21fdCBzbSk7CisKKy8qKgorICogU3RhdGUgbWFjaGluZSB3aXRoIGVudHJ5IGFjdGlvbnMuCisgKi8KK3R5cGVkZWYgdm9pZCAoKmJmYV9mc21fdCkodm9pZCAqZnNtLCBpbnQgZXZlbnQpOworCisvKioKKyAqIG9jIC0gb2JqZWN0IGNsYXNzIGVnLiBiZmFfaW9jCisgKiBzdCAtIHN0YXRlLCBlZy4gcmVzZXQKKyAqIG90eXBlIC0gb2JqZWN0IHR5cGUsIGVnLiBzdHJ1Y3QgYmZhX2lvY19zCisgKiBldHlwZSAtIG9iamVjdCB0eXBlLCBlZy4gZW51bSBpb2NfZXZlbnQKKyAqLworI2RlZmluZSBiZmFfZnNtX3N0YXRlX2RlY2wob2MsIHN0LCBvdHlwZSwgZXR5cGUpCQlcCisJc3RhdGljIHZvaWQgb2MgIyMgX3NtXyAjIyBzdChvdHlwZSAqIGZzbSwgZXR5cGUgZXZlbnQpOyAgICAgIFwKKwlzdGF0aWMgdm9pZCBvYyAjIyBfc21fICMjIHN0ICMjIF9lbnRyeShvdHlwZSAqIGZzbSkKKworI2RlZmluZSBiZmFfZnNtX3NldF9zdGF0ZShfZnNtLCBfc3RhdGUpIGRvIHsJXAorCShfZnNtKS0+ZnNtID0gKGJmYV9mc21fdCkoX3N0YXRlKTsgICAgICBcCisJX3N0YXRlICMjIF9lbnRyeShfZnNtKTsgICAgICBcCit9IHdoaWxlICgwKQorCisjZGVmaW5lIGJmYV9mc21fc2VuZF9ldmVudChfZnNtLCBfZXZlbnQpCVwKKwkoX2ZzbSktPmZzbSgoX2ZzbSksIChfZXZlbnQpKQorI2RlZmluZSBiZmFfZnNtX2NtcF9zdGF0ZShfZnNtLCBfc3RhdGUpCQlcCisJKChfZnNtKS0+ZnNtID09IChiZmFfZnNtX3QpKF9zdGF0ZSkpCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2NzL2JmYV90cmMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfdHJjLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2U3NDM5MgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfdHJjLmgKQEAgLTAsMCArMSwxNzYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRkFfVFJDX0hfXworI2RlZmluZSBfX0JGQV9UUkNfSF9fCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisKKyNpZm5kZWYgQkZBX1RSQ19NQVgKKyNkZWZpbmUgQkZBX1RSQ19NQVgJKDQgKiAxMDI0KQorI2VuZGlmCisKKyNpZm5kZWYgQkZBX1RSQ19UUworI2RlZmluZSBCRkFfVFJDX1RTKF90cmNtKQkoKF90cmNtKS0+dGlja3MgKyspCisjZW5kaWYKKworc3RydWN0IGJmYV90cmNfcyB7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1MTYJZmlsZW5vOworCXUxNglsaW5lOworI2Vsc2UKKwl1MTYJbGluZTsKKwl1MTYJZmlsZW5vOworI2VuZGlmCisJdTMyCXRpbWVzdGFtcDsKKwl1bmlvbiB7CisJCXN0cnVjdCB7CisJCQl1MzIJcnN2ZDsKKwkJCXUzMgl1MzI7CisJCX0gdTMyOworCQl1NjQJdTY0OworCX0gZGF0YTsKK307CisKKworc3RydWN0IGJmYV90cmNfbW9kX3MgeworCXUzMgloZWFkOworCXUzMgl0YWlsOworCXUzMgludHJjOworCXUzMglzdG9wcGVkOworCXUzMgl0aWNrczsKKwl1MzIJcnN2ZFszXTsKKwlzdHJ1Y3QgYmZhX3RyY19zIHRyY1tCRkFfVFJDX01BWF07Cit9OworCisKK2VudW0geworCUJGQV9UUkNfRlcgICA9IDEsCS8qICBmaXJtd2FyZSBtb2R1bGVzICovCisJQkZBX1RSQ19IQUwgID0gMiwJLyogIEJGQSBtb2R1bGVzICovCisJQkZBX1RSQ19GQ1MgID0gMywJLyogIEJGQSBGQ1MgbW9kdWxlcyAqLworCUJGQV9UUkNfTERSViA9IDQsCS8qICBMaW51eCBkcml2ZXIgbW9kdWxlcyAqLworCUJGQV9UUkNfU0RSViA9IDUsCS8qICBTb2xhcmlzIGRyaXZlciBtb2R1bGVzICovCisJQkZBX1RSQ19WRFJWID0gNiwJLyogIHZtd2FyZSBkcml2ZXIgbW9kdWxlcyAqLworCUJGQV9UUkNfV0RSViA9IDcsCS8qICB3aW5kb3dzIGRyaXZlciBtb2R1bGVzICovCisJQkZBX1RSQ19BRU4gID0gOCwJLyogIEFFTiBtb2R1bGUgKi8KKwlCRkFfVFJDX0JJT1MgPSA5LAkvKiAgYmlvcyBkcml2ZXIgbW9kdWxlcyAqLworCUJGQV9UUkNfRUZJICA9IDEwLAkvKiAgRUZJIGRyaXZlciBtb2R1bGVzICovCisJQk5BX1RSQ19XRFJWID0gMTEsCS8qICBCTkEgd2luZG93cyBkcml2ZXIgbW9kdWxlcyAqLworCUJOQV9UUkNfVkRSViA9IDEyLAkvKiAgQk5BIHZtd2FyZSBkcml2ZXIgbW9kdWxlcyAqLworCUJOQV9UUkNfU0RSViA9IDEzLAkvKiAgQk5BIFNvbGFyaXMgZHJpdmVyIG1vZHVsZXMgKi8KKwlCTkFfVFJDX0xEUlYgPSAxNCwJLyogIEJOQSBMaW51eCBkcml2ZXIgbW9kdWxlcyAqLworCUJOQV9UUkNfSEFMICA9IDE1LAkvKiAgQk5BIG1vZHVsZXMgKi8KKwlCRkFfVFJDX0NOQSAgPSAxNiwJLyogIENvbW1vbiBtb2R1bGVzICovCisJQk5BX1RSQ19JTURSViA9IDE3CS8qICBCTkEgd2luZG93cyBpbnRlcm1lZGlhdGUgZHJpdmVyIG1vZHVsZXMgKi8KK307CisjZGVmaW5lIEJGQV9UUkNfTU9EX1NICTEwCisjZGVmaW5lIEJGQV9UUkNfTU9EKF9fbW9kKQkoKEJGQV9UUkNfICMjIF9fbW9kKSA8PCBCRkFfVFJDX01PRF9TSCkKKworLyoqCisgKiBEZWZpbmUgYSBuZXcgdHJhY2luZyBmaWxlIChtb2R1bGUpLiBNb2R1bGUgc2hvdWxkIG1hdGNoIG9uZSBkZWZpbmVkIGFib3ZlLgorICovCisjZGVmaW5lIEJGQV9UUkNfRklMRShfX21vZCwgX19zdWJtb2QpCQkJCQlcCisJc3RhdGljIGludCBfX3RyY19maWxlbm8gPSAoKEJGQV9UUkNfICMjIF9fbW9kICMjIF8gIyMgX19zdWJtb2QpIHwgXAorCQkJCQkJIEJGQV9UUkNfTU9EKF9fbW9kKSkKKworCisjZGVmaW5lIGJmYV90cmMzMihfdHJjcCwgX2RhdGEpCVwKKwlfX2JmYV90cmMoKF90cmNwKS0+dHJjbW9kLCBfX3RyY19maWxlbm8sIF9fTElORV9fLCAodTMyKV9kYXRhKQorCisKKyNpZm5kZWYgQkZBX0JPT1RfQlVJTEQKKyNkZWZpbmUgYmZhX3RyYyhfdHJjcCwgX2RhdGEpCVwKKwlfX2JmYV90cmMoKF90cmNwKS0+dHJjbW9kLCBfX3RyY19maWxlbm8sIF9fTElORV9fLCAodTY0KV9kYXRhKQorI2Vsc2UKK3ZvaWQgYmZhX2Jvb3RfdHJjKHN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QsIHUxNiBmaWxlbm8sCisJCQl1MTYgbGluZSwgdTMyIGRhdGEpOworI2RlZmluZSBiZmFfdHJjKF90cmNwLCBfZGF0YSkJXAorCWJmYV9ib290X3RyYygoX3RyY3ApLT50cmNtb2QsIF9fdHJjX2ZpbGVubywgX19MSU5FX18sICh1MzIpX2RhdGEpCisjZW5kaWYKKworCitzdGF0aWMgaW5saW5lIHZvaWQKK2JmYV90cmNfaW5pdChzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbSkKK3sKKwl0cmNtLT5oZWFkID0gdHJjbS0+dGFpbCA9IHRyY20tPnN0b3BwZWQgPSAwOworCXRyY20tPm50cmMgPSBCRkFfVFJDX01BWDsKK30KKworCitzdGF0aWMgaW5saW5lIHZvaWQKK2JmYV90cmNfc3RvcChzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbSkKK3sKKwl0cmNtLT5zdG9wcGVkID0gMTsKK30KKworI2lmZGVmIEZXVFJDCitleHRlcm4gdm9pZCBkY19mbHVzaCh2b2lkICpkYXRhKTsKKyNlbHNlCisjZGVmaW5lIGRjX2ZsdXNoKGRhdGEpCisjZW5kaWYKKworCitzdGF0aWMgaW5saW5lIHZvaWQKK19fYmZhX3RyYyhzdHJ1Y3QgYmZhX3RyY19tb2RfcyAqdHJjbSwgaW50IGZpbGVubywgaW50IGxpbmUsIHU2NCBkYXRhKQoreworCWludAkJdGFpbCA9IHRyY20tPnRhaWw7CisJc3RydWN0IGJmYV90cmNfcyAJKnRyYyA9ICZ0cmNtLT50cmNbdGFpbF07CisKKwlpZiAodHJjbS0+c3RvcHBlZCkKKwkJcmV0dXJuOworCisJdHJjLT5maWxlbm8gPSAodTE2KSBmaWxlbm87CisJdHJjLT5saW5lID0gKHUxNikgbGluZTsKKwl0cmMtPmRhdGEudTY0ID0gZGF0YTsKKwl0cmMtPnRpbWVzdGFtcCA9IEJGQV9UUkNfVFModHJjbSk7CisJZGNfZmx1c2godHJjKTsKKworCXRyY20tPnRhaWwgPSAodHJjbS0+dGFpbCArIDEpICYgKEJGQV9UUkNfTUFYIC0gMSk7CisJaWYgKHRyY20tPnRhaWwgPT0gdHJjbS0+aGVhZCkKKwkJdHJjbS0+aGVhZCA9ICh0cmNtLT5oZWFkICsgMSkgJiAoQkZBX1RSQ19NQVggLSAxKTsKKwlkY19mbHVzaCh0cmNtKTsKK30KKworCitzdGF0aWMgaW5saW5lIHZvaWQKK19fYmZhX3RyYzMyKHN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtLCBpbnQgZmlsZW5vLCBpbnQgbGluZSwgdTMyIGRhdGEpCit7CisJaW50CQl0YWlsID0gdHJjbS0+dGFpbDsKKwlzdHJ1Y3QgYmZhX3RyY19zICp0cmMgPSAmdHJjbS0+dHJjW3RhaWxdOworCisJaWYgKHRyY20tPnN0b3BwZWQpCisJCXJldHVybjsKKworCXRyYy0+ZmlsZW5vID0gKHUxNikgZmlsZW5vOworCXRyYy0+bGluZSA9ICh1MTYpIGxpbmU7CisJdHJjLT5kYXRhLnUzMi51MzIgPSBkYXRhOworCXRyYy0+dGltZXN0YW1wID0gQkZBX1RSQ19UUyh0cmNtKTsKKwlkY19mbHVzaCh0cmMpOworCisJdHJjbS0+dGFpbCA9ICh0cmNtLT50YWlsICsgMSkgJiAoQkZBX1RSQ19NQVggLSAxKTsKKwlpZiAodHJjbS0+dGFpbCA9PSB0cmNtLT5oZWFkKQorCQl0cmNtLT5oZWFkID0gKHRyY20tPmhlYWQgKyAxKSAmIChCRkFfVFJDX01BWCAtIDEpOworCWRjX2ZsdXNoKHRyY20pOworfQorCisjaWZuZGVmIEJGQV9QRVJGX0JVSUxECisjZGVmaW5lIGJmYV90cmNfZnAoX3RyY3AsIF9kYXRhKQliZmFfdHJjKF90cmNwLCBfZGF0YSkKKyNlbHNlCisjZGVmaW5lIGJmYV90cmNfZnAoX3RyY3AsIF9kYXRhKQorI2VuZGlmCisKKyNlbmRpZiAvKiBfX0JGQV9UUkNfSF9fICovCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfd2MuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9jcy9iZmFfd2MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wNDYwYmQ0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2NzL2JmYV93Yy5oCkBAIC0wLDAgKzEsNjggQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX3djLmggR2VuZXJpYyB3YWl0IGNvdW50ZXIuCisgKi8KKworI2lmbmRlZiBfX0JGQV9XQ19IX18KKyNkZWZpbmUgX19CRkFfV0NfSF9fCisKK3R5cGVkZWYgdm9pZCAoKmJmYV93Y19yZXN1bWVfdCkgKHZvaWQgKmNiYXJnKTsKKworc3RydWN0IGJmYV93Y19zIHsKKwliZmFfd2NfcmVzdW1lX3Qgd2NfcmVzdW1lOworCXZvaWQJCSp3Y19jYmFyZzsKKwlpbnQJCXdjX2NvdW50OworfTsKKworc3RhdGljIGlubGluZSB2b2lkCitiZmFfd2NfdXAoc3RydWN0IGJmYV93Y19zICp3YykKK3sKKwl3Yy0+d2NfY291bnQrKzsKK30KKworc3RhdGljIGlubGluZSB2b2lkCitiZmFfd2NfZG93bihzdHJ1Y3QgYmZhX3djX3MgKndjKQoreworCXdjLT53Y19jb3VudC0tOworCWlmICh3Yy0+d2NfY291bnQgPT0gMCkKKwkJd2MtPndjX3Jlc3VtZSh3Yy0+d2NfY2JhcmcpOworfQorCisvKioKKyAqIEluaXRpYWxpemUgYSB3YWl0aW5nIGNvdW50ZXIuCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZAorYmZhX3djX2luaXQoc3RydWN0IGJmYV93Y19zICp3YywgYmZhX3djX3Jlc3VtZV90IHdjX3Jlc3VtZSwgdm9pZCAqd2NfY2JhcmcpCit7CisJd2MtPndjX3Jlc3VtZSA9IHdjX3Jlc3VtZTsKKwl3Yy0+d2NfY2JhcmcgPSB3Y19jYmFyZzsKKwl3Yy0+d2NfY291bnQgPSAwOworCWJmYV93Y191cCh3Yyk7Cit9CisKKy8qKgorICogV2FpdCBmb3IgY291bnRlciB0byByZWFjaCB6ZXJvCisgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZAorYmZhX3djX3dhaXQoc3RydWN0IGJmYV93Y19zICp3YykKK3sKKwliZmFfd2NfZG93bih3Yyk7Cit9CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYWRhcHRlci5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYWRhcHRlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhjMjA4ZmMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19hZGFwdGVyLmgKQEAgLTAsMCArMSw4MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworI2lmbmRlZiBfX0JGQV9ERUZTX0FEQVBURVJfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfQURBUFRFUl9IX18KKworI2luY2x1ZGUgPHByb3RvY29sL3R5cGVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc192ZXJzaW9uLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19tZmcuaD4KKworLyoqCisgKiBCRkEgYWRhcHRlciBsZXZlbCBhdHRyaWJ1dGVzLgorICovCitlbnVtIHsKKwlCRkFfQURBUFRFUl9TRVJJQUxfTlVNX0xFTiA9IFNUUlNaKEJGQV9NRkdfU0VSSUFMTlVNX1NJWkUpLAorCQkJCQkvKgorCQkJCQkgKiE8IGFkYXB0ZXIgc2VyaWFsIG51bSBsZW5ndGgKKwkJCQkJICovCisJQkZBX0FEQVBURVJfTU9ERUxfTkFNRV9MRU4gID0gMTYsICAvKiAgbW9kZWwgbmFtZSBsZW5ndGggKi8KKwlCRkFfQURBUFRFUl9NT0RFTF9ERVNDUl9MRU4gPSAxMjgsIC8qICBtb2RlbCBkZXNjcmlwdGlvbiBsZW5ndGggKi8KKwlCRkFfQURBUFRFUl9NRkdfTkFNRV9MRU4gICAgPSA4LCAgIC8qICBtYW51ZmFjdHVyZXIgbmFtZSBsZW5ndGggKi8KKwlCRkFfQURBUFRFUl9TWU1fTkFNRV9MRU4gICAgPSA2NCwgIC8qICBhZGFwdGVyIHN5bWJvbGljIG5hbWUgbGVuZ3RoICovCisJQkZBX0FEQVBURVJfT1NfVFlQRV9MRU4JICAgID0gNjQsICAvKiAgYWRhcHRlciBvcyB0eXBlIGxlbmd0aCAqLworfTsKKworc3RydWN0IGJmYV9hZGFwdGVyX2F0dHJfcyB7CisJY2hhciAgICAgICAgICAgIG1hbnVmYWN0dXJlcltCRkFfQURBUFRFUl9NRkdfTkFNRV9MRU5dOworCWNoYXIgICAgICAgICAgICBzZXJpYWxfbnVtW0JGQV9BREFQVEVSX1NFUklBTF9OVU1fTEVOXTsKKwl1MzIJcnN2ZDE7CisJY2hhciAgICAgICAgICAgIG1vZGVsW0JGQV9BREFQVEVSX01PREVMX05BTUVfTEVOXTsKKwljaGFyICAgICAgICAgICAgbW9kZWxfZGVzY3JbQkZBX0FEQVBURVJfTU9ERUxfREVTQ1JfTEVOXTsKKwl3d25fdCAgICAgICAgICAgcHd3bjsKKwljaGFyICAgICAgICAgICAgbm9kZV9zeW1uYW1lW0ZDX1NZTU5BTUVfTUFYXTsKKwljaGFyICAgICAgICAgICAgaHdfdmVyW0JGQV9WRVJTSU9OX0xFTl07CisJY2hhciAgICAgICAgICAgIGZ3X3ZlcltCRkFfVkVSU0lPTl9MRU5dOworCWNoYXIgICAgICAgICAgICBvcHRyb21fdmVyW0JGQV9WRVJTSU9OX0xFTl07CisJY2hhciAgICAgICAgICAgIG9zX3R5cGVbQkZBX0FEQVBURVJfT1NfVFlQRV9MRU5dOworCXN0cnVjdCBiZmFfbWZnX3ZwZF9zCXZwZDsKKwlzdHJ1Y3QgbWFjX3MJbWFjOworCisJdTgJCW5wb3J0czsKKwl1OAkJbWF4X3NwZWVkOworCXU4CQlwcm90b3R5cGU7CisJY2hhcgkgICAgICAgIGFzaWNfcmV2OworCisJdTggICAgICAgICBwY2llX2dlbjsKKwl1OCAgICAgICAgIHBjaWVfbGFuZXNfb3JpZzsKKwl1OCAgICAgICAgIHBjaWVfbGFuZXM7CisJdTgJICAgICAgICBjbmFfY2FwYWJsZTsKK307CisKKy8qKgorICogQkZBIGFkYXB0ZXIgbGV2ZWwgZXZlbnRzCisgKiBBcmd1bWVudHMgYmVsb3cgYXJlIGluIEJGQUwgY29udGV4dCBmcm9tIE1nbXQKKyAqIEJGQV9QT1JUX0FFTl9BREQ6ICAgICAgICBbaW5dOiBOb25lICAgICBbb3V0XTogc2VyaWFsX251bSwgcHd3biwgbnBvcnRzCisgKiBCRkFfUE9SVF9BRU5fUkVNT1ZFOiAgICAgW2luXTogcHd3biAgICAgW291dF06IHNlcmlhbF9udW0sIHB3d24sIG5wb3J0cworICovCitlbnVtIGJmYV9hZGFwdGVyX2Flbl9ldmVudCB7CisJQkZBX0FEQVBURVJfQUVOX0FERCAJPSAxLAkvKiAgTmV3IEFkYXB0ZXIgZm91bmQgZXZlbnQgKi8KKwlCRkFfQURBUFRFUl9BRU5fUkVNT1ZFIAk9IDIsCS8qICBBZGFwdGVyIHJlbW92ZWQgZXZlbnQgKi8KK307CisKK3N0cnVjdCBiZmFfYWRhcHRlcl9hZW5fZGF0YV9zIHsKKwljaGFyICAgICAgICAgICAgc2VyaWFsX251bVtCRkFfQURBUFRFUl9TRVJJQUxfTlVNX0xFTl07CisJdTMyICAgICAgICBucG9ydHM7CS8qICBOdW1iZXIgb2YgTlBvcnRzICovCisJd3duX3QgICAgICAgICAgIHB3d247CS8qICBXV04gb2Ygb25lIG9mIGl0cyBwaHlzaWNhbCBwb3J0ICovCit9OworCisjZW5kaWYgLyogX19CRkFfREVGU19BREFQVEVSX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYWVuLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19hZW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40YzgxYTYxCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYWVuLmgKQEAgLTAsMCArMSw3MyBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfQUVOX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX0FFTl9IX18KKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfdHlwZXMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX2lvYy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfYWRhcHRlci5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcG9ydC5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfbHBvcnQuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3Jwb3J0Lmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19pdG5pbS5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfdGluLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19pcGZjLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19hdWRpdC5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfZXRocG9ydC5oPgorCitlbnVtIGJmYV9hZW5fY2F0ZWdvcnkgeworCUJGQV9BRU5fQ0FUX0FEQVBURVIgCT0gMSwKKwlCRkFfQUVOX0NBVF9QT1JUIAk9IDIsCisJQkZBX0FFTl9DQVRfTFBPUlQgCT0gMywKKwlCRkFfQUVOX0NBVF9SUE9SVCAJPSA0LAorCUJGQV9BRU5fQ0FUX0lUTklNIAk9IDUsCisJQkZBX0FFTl9DQVRfVElOIAk9IDYsCisJQkZBX0FFTl9DQVRfSVBGQyAJPSA3LAorCUJGQV9BRU5fQ0FUX0FVRElUIAk9IDgsCisJQkZBX0FFTl9DQVRfSU9DIAk9IDksCisJQkZBX0FFTl9DQVRfRVRIUE9SVAk9IDEwLAorCUJGQV9BRU5fTUFYX0NBVCAJPSAxMAorfTsKKworI3ByYWdtYSBwYWNrKDEpCit1bmlvbiBiZmFfYWVuX2RhdGFfdSB7CisJc3RydWN0IGJmYV9hZGFwdGVyX2Flbl9kYXRhX3MgCWFkYXB0ZXI7CisJc3RydWN0IGJmYV9wb3J0X2Flbl9kYXRhX3MgCXBvcnQ7CisJc3RydWN0IGJmYV9scG9ydF9hZW5fZGF0YV9zIAlscG9ydDsKKwlzdHJ1Y3QgYmZhX3Jwb3J0X2Flbl9kYXRhX3MgCXJwb3J0OworCXN0cnVjdCBiZmFfaXRuaW1fYWVuX2RhdGFfcyAJaXRuaW07CisJc3RydWN0IGJmYV9hdWRpdF9hZW5fZGF0YV9zIAlhdWRpdDsKKwlzdHJ1Y3QgYmZhX2lvY19hZW5fZGF0YV9zIAlpb2M7CisJc3RydWN0IGJmYV9ldGhwb3J0X2Flbl9kYXRhX3MgCWV0aHBvcnQ7Cit9OworCitzdHJ1Y3QgYmZhX2Flbl9lbnRyeV9zIHsKKwllbnVtIGJmYV9hZW5fY2F0ZWdvcnkgCWFlbl9jYXRlZ29yeTsKKwlpbnQJCQlhZW5fdHlwZTsKKwl1bmlvbiBiZmFfYWVuX2RhdGFfdSAgCWFlbl9kYXRhOworCXN0cnVjdCBiZmFfdGltZXZhbF9zICAgCWFlbl90djsKKwlzMzIgICAgICAgICAJc2VxX251bTsKKwlzMzIgICAgICAgICAJYmZhZF9udW07CisJczMyICAgICAgICAgCXJzdmRbMV07Cit9OworCisjcHJhZ21hIHBhY2soKQorCisjZGVmaW5lIGJmYV9hZW5fZXZlbnRfdCBpbnQKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfQUVOX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYXVkaXQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2F1ZGl0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGUzYTk2MgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2F1ZGl0LmgKQEAgLTAsMCArMSwzOCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfQVVESVRfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfQVVESVRfSF9fCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisKKy8qKgorICogQkZBIGF1ZGl0IGV2ZW50cworICovCitlbnVtIGJmYV9hdWRpdF9hZW5fZXZlbnQgeworCUJGQV9BVURJVF9BRU5fQVVUSF9FTkFCTEUgCT0gMSwKKwlCRkFfQVVESVRfQUVOX0FVVEhfRElTQUJMRSAJPSAyLAorfTsKKworLyoqCisgKiBhdWRpdCBldmVudCBkYXRhCisgKi8KK3N0cnVjdCBiZmFfYXVkaXRfYWVuX2RhdGFfcyB7CisJd3duX3QgICAgICAgICAgIHB3d247Cit9OworCisjZW5kaWYgLyogX19CRkFfREVGU19BVURJVF9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2F1dGguaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2F1dGguaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kZDE5YzgzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYXV0aC5oCkBAIC0wLDAgKzEsMTEyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0RFRlNfQVVUSF9IX18KKyNkZWZpbmUgX19CRkFfREVGU19BVVRIX0hfXworCisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc190eXBlcy5oPgorCisjZGVmaW5lIFBVQkxJQ19LRVkJCQkxNTQwOQorI2RlZmluZSBQUklWQVRFX0tFWQkJCTE5MDA5CisjZGVmaW5lIEtFWV9MRU4JCQkJMzIzOTkKKyNkZWZpbmUgQkZBX0FVVEhfU0VDUkVUX1NUUklOR19MRU4JMjU2CisjZGVmaW5lIEJGQV9BVVRIX0ZBSUxfVElNRU9VVAkJMHhGRgorCisvKioKKyAqIEF1dGhlbnRpY2F0aW9uIHN0YXR1cworICovCitlbnVtIGJmYV9hdXRoX3N0YXR1cyB7CisJQkZBX0FVVEhfU1RBVFVTX05PTkUgCT0gMCwJLyogIG5vIGF1dGhlbnRpY2F0aW9uICovCisJQkZBX0FVVEhfVU5JTklUIAk9IDEsCS8qICBzdGF0ZSAtIHVuaW5pdCAqLworCUJGQV9BVVRIX05FR19TRU5EIAk9IDIsCS8qICBzdGF0ZSAtIG5lZ290aWF0ZSBzZW5kICovCisJQkZBX0FVVEhfQ0hBTF9XQUlUIAk9IDMsCS8qICBzdGF0ZSAtIGNoYWxsZW5nZSB3YWl0ICovCisJQkZBX0FVVEhfTkVHX1JFVFJZIAk9IDQsCS8qICBzdGF0ZSAtIG5lZ290aWF0ZSByZXRyeSAqLworCUJGQV9BVVRIX1JFUExZX1NFTkQgCT0gNSwJLyogIHN0YXRlIC0gcmVwbHkgc2VuZCAqLworCUJGQV9BVVRIX1NUQVRVU19XQUlUIAk9IDYsCS8qICBzdGF0ZSAtIHN0YXR1cyB3YWl0ICovCisJQkZBX0FVVEhfU1VDQ0VTUyAJPSA3LAkvKiAgc3RhdGUgLSBzdWNjZXNzICovCisJQkZBX0FVVEhfRkFJTEVEIAk9IDgsCS8qICBzdGF0ZSAtIGZhaWxlZCAqLworCUJGQV9BVVRIX1NUQVRVU19VTktOT1dOID0gOSwJLyogIGF1dGhlbnRpY2F0aW9uIHN0YXR1cyB1bmtub3duICovCit9OworCitzdHJ1Y3QgYXV0aF9wcm90b19zdGF0c19zIHsKKwl1MzIgICAgICAgIGF1dGhfcmp0czsKKwl1MzIgICAgICAgIGF1dGhfbmVnczsKKwl1MzIgICAgICAgIGF1dGhfZG9uZXM7CisKKwl1MzIgICAgICAgIGRoY2hhcF9jaGFsbGVuZ2VzOworCXUzMiAgICAgICAgZGhjaGFwX3JlcGxpZXM7CisJdTMyICAgICAgICBkaGNoYXBfc3VjY2Vzc2VzOworfTsKKworLyoqCisgKiBBdXRoZW50aWNhdGlvbiByZWxhdGVkIHN0YXRpc3RpY3MKKyAqLworc3RydWN0IGJmYV9hdXRoX3N0YXRzX3MgeworCXUzMiAgICAgICAgICAgYXV0aF9mYWlsdXJlczsJLyogIGF1dGhlbnRpY2F0aW9uIGZhaWx1cmVzICovCisJdTMyICAgICAgICAgICBhdXRoX3N1Y2Nlc3NlczsJLyogIGF1dGhlbnRpY2F0aW9uIHN1Y2Nlc3NlcyovCisJc3RydWN0IGF1dGhfcHJvdG9fc3RhdHNfcyBhdXRoX3J4X3N0YXRzOyAvKiAgUnggcHJvdG9jb2wgc3RhdHMgKi8KKwlzdHJ1Y3QgYXV0aF9wcm90b19zdGF0c19zIGF1dGhfdHhfc3RhdHM7IC8qICBUeCBwcm90b2NvbCBzdGF0cyAqLworfTsKKworLyoqCisgKiBBdXRoZW50aWNhdGlvbiBoYXNoIGZ1bmN0aW9uIGFsZ29yaXRobXMKKyAqLworZW51bSBiZmFfYXV0aF9hbGdvIHsKKwlCRkFfQVVUSF9BTEdPX01ENSAJPSAxLAkvKiAgTWVzc2FnZS1EaWdlc3QgYWxnb3JpdGhtIDUgKi8KKwlCRkFfQVVUSF9BTEdPX1NIQTEgCT0gMiwJLyogIFNlY3VyZSBIYXNoIEFsZ29yaXRobSAxICovCisJQkZBX0FVVEhfQUxHT19NUyAJPSAzLAkvKiAgTUQ1LCB0aGVuIFNIQS0xICovCisJQkZBX0FVVEhfQUxHT19TTSAJPSA0LAkvKiAgU0hBLTEsIHRoZW4gTUQ1ICovCit9OworCisvKioKKyAqIERIIEdyb3VwcworICoKKyAqIEN1cnJlbnQgdmFsdWUgY291bGQgYmUgY29tYmluYXRpb24gb2Ygb25lIG9yIG1vcmUgb2YgdGhlIGZvbGxvd2luZyB2YWx1ZXMKKyAqLworZW51bSBiZmFfYXV0aF9ncm91cCB7CisJQkZBX0FVVEhfR1JPVVBfREhOVUxMIAk9IDAsCS8qICBESCBOVUxMICh2YWx1ZSA9PSAwKSAqLworCUJGQV9BVVRIX0dST1VQX0RINzY4IAk9IDEsCS8qICBESCBncm91cCA3NjggKHZhbHVlID09IDEpICovCisJQkZBX0FVVEhfR1JPVVBfREgxMDI0IAk9IDIsCS8qICBESCBncm91cCAxMDI0ICh2YWx1ZSA9PSAyKSAqLworCUJGQV9BVVRIX0dST1VQX0RIMTI4MCAJPSA0LAkvKiAgREggZ3JvdXAgMTI4MCAodmFsdWUgPT0gMykgKi8KKwlCRkFfQVVUSF9HUk9VUF9ESDE1MzYgCT0gOCwJLyogIERIIGdyb3VwIDE1MzYgKHZhbHVlID09IDQpICovCisKKwlCRkFfQVVUSF9HUk9VUF9BTEwgCT0gMjU2CS8qICBVc2UgZGVmYXVsdCBESCBncm91cCBvcmRlcgorCQkJCQkgKiAgICAwLCAxLCAyLCAzLCA0ICovCit9OworCisvKioKKyAqIEF1dGhlbnRpY2F0aW9uIHNlY3JldCBzb3VyY2VzCisgKi8KK2VudW0gYmZhX2F1dGhfc2VjcmV0c291cmNlIHsKKwlCRkFfQVVUSF9TRUNTUkNfTE9DQUwgCT0gMSwJLyogIGxvY2FsbHkgY29uZmlndXJlZCAqLworCUJGQV9BVVRIX1NFQ1NSQ19SQURJVVMgCT0gMiwJLyogIHVzZSByYWRpdXMgc2VydmVyICovCisJQkZBX0FVVEhfU0VDU1JDX1RBQ0FDUyAJPSAzLAkvKiAgVEFDQUNTIHNlcnZlciAqLworfTsKKworLyoqCisgKiBBdXRoZW50aWNhdGlvbiBhdHRyaWJ1dGVzCisgKi8KK3N0cnVjdCBiZmFfYXV0aF9hdHRyX3MgeworCWVudW0gYmZhX2F1dGhfc3RhdHVzIAlzdGF0dXM7CisJZW51bSBiZmFfYXV0aF9hbGdvIAlhbGdvOworCWVudW0gYmZhX2F1dGhfZ3JvdXAgCWRoX2dycDsKKwl1MTYJCXJqdF9jb2RlOworCXUxNgkJcmp0X2NvZGVfZXhwOworCXU4CQkJc2VjcmV0X3NldDsKKwl1OAkJCXJlc3ZbN107Cit9OworCisjZW5kaWYgLyogX19CRkFfREVGU19BVVRIX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYm9vdC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfYm9vdC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjZmNGFhNTIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19ib290LmgKQEAgLTAsMCArMSw3MSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfQk9PVF9IX18KKyNkZWZpbmUgX19CRkFfREVGU19CT09UX0hfXworCisjaW5jbHVkZSA8cHJvdG9jb2wvdHlwZXMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3R5cGVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorCitlbnVtIHsKKwlCRkFfQk9PVF9CT09UTFVOX01BWCA9IDQsCS8qICBtYXhpbXVtIGJvb3QgbHVuIHBlciBJT0MgKi8KK307CisKKyNkZWZpbmUgQk9PVF9DRkdfUkVWMQkxCisKKy8qKgorICogICAgICBCb290IG9wdGlvbnMgc2V0dGluZy4gQm9vdCBvcHRpb25zIHNldHRpbmcgZGV0ZXJtaW5lcyBmcm9tIHdoZXJlCisgKiAgICAgIHRvIGdldCB0aGUgYm9vdCBsdW4gaW5mb3JtYXRpb24KKyAqLworZW51bSBiZmFfYm9vdF9ib290b3B0IHsKKyAgICBCRkFfQk9PVF9BVVRPX0RJU0NPVkVSID0gMCwgICAgLyogIEJvb3QgZnJvbSBibHVuIHByb3ZpZGVkIGJ5IGZhYnJpYyAqLworICAgIEJGQV9CT09UX1NUT1JFRF9CTFVOICAgPSAxLCAgICAvKiAgQm9vdCBmcm9tIGJsdW5zIHN0b3JlZCBpbiBmbGFzaCAgICovCisgICAgQkZBX0JPT1RfRklSU1RfTFVOICAgICA9IDIsICAgIC8qICBCb290IGZyb20gZmlyc3QgZGlzY292ZXJlZCBibHVuICAgKi8KK307CisKKy8qKgorICogQm9vdCBsdW4gaW5mb3JtYXRpb24uCisgKi8KK3N0cnVjdCBiZmFfYm9vdF9ib290bHVuX3MgeworCXd3bl90ICAgICAgICAgICBwd3duOwkvKiAgcG9ydCB3d24gb2YgdGFyZ2V0ICovCisJbHVuX3QgICAgICAgICAgIGx1bjsJLyogIDY0LWJpdCBsdW4gKi8KK307CisKKy8qKgorICogQk9PVCBib290IGNvbmZpZ3VyYXRvbgorICovCitzdHJ1Y3QgYmZhX2Jvb3RfY2ZnX3MgeworCXU4ICAgICAgICAgdmVyc2lvbjsKKwl1OCAgICAgICAgIHJzdmQxOworCXUxNiAgICAgICAgY2hrc3VtOworCisJdTggICAgICAgICBlbmFibGU7CQkvKiAgZW5hYmxlL2Rpc2FibGUgU0FOIGJvb3QgKi8KKwl1OCAgICAgICAgIHNwZWVkOwkJLyogIGJvb3Qgc3BlZWQgc2V0dGluZ3MgKi8KKwl1OCAgICAgICAgIHRvcG9sb2d5OwkvKiAgYm9vdCB0b3BvbG9neSBzZXR0aW5nICovCisJdTggICAgICAgICBib290b3B0OwkvKiAgYmZhX2Jvb3RfYm9vdG9wdF90ICovCisKKwl1MzIgICAgICAgIG5ibHVuczsJCS8qICBudW1iZXIgb2YgYm9vdCBsdW5zICovCisKKwl1MzIgICAgICAgIHJzdmQyOworCisJc3RydWN0IGJmYV9ib290X2Jvb3RsdW5fcyBibHVuW0JGQV9CT09UX0JPT1RMVU5fTUFYXTsKKwlzdHJ1Y3QgYmZhX2Jvb3RfYm9vdGx1bl9zIGJsdW5fZGlzY1tCRkFfQk9PVF9CT09UTFVOX01BWF07Cit9OworCisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX0JPT1RfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19jZWUuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2NlZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjUyMGEyMmYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19jZWUuaApAQCAtMCwwICsxLDE1OSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogIGJmYV9kZWZzX2NlZS5oIEludGVyZmFjZSBkZWNsYXJhdGlvbnMgYmV0d2VlbiBob3N0IGJhc2VkCisgKglCRkFMIGFuZCBEQ0JYL0xMRFAgbW9kdWxlIGluIEZpcm13YXJlCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworI2lmbmRlZiBfX0JGQV9ERUZTX0NFRV9IX18KKyNkZWZpbmUgX19CRkFfREVGU19DRUVfSF9fCisKKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3R5cGVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorI2luY2x1ZGUgPHByb3RvY29sL3R5cGVzLmg+CisKKyNwcmFnbWEgcGFjaygxKQorCisjZGVmaW5lIEJGQV9DRUVfTExEUF9NQVhfU1RSSU5HX0xFTiAoMTI4KQorCisKKy8qIEZJWE1FOiB0aGlzIGlzIGNvbWluZyBmcm9tIHRoZSBwcm90b2NvbCBzcGVjLiBDYW4gdGhlIGhvc3QgJiBhcHBzIHNoYXJlIHRoZQorICAgcHJvdG9jb2wgLmggZmlsZXMgPworICovCisjZGVmaW5lIEJGQV9DRUVfTExEUF9TWVNfQ0FQX09USEVSICAgICAgIDB4MDAwMQorI2RlZmluZSBCRkFfQ0VFX0xMRFBfU1lTX0NBUF9SRVBFQVRFUiAgICAweDAwMDIKKyNkZWZpbmUgQkZBX0NFRV9MTERQX1NZU19DQVBfTUFDX0JSSURHRSAgMHgwMDA0CisjZGVmaW5lIEJGQV9DRUVfTExEUF9TWVNfQ0FQX1dMQU5fQVAgICAgIDB4MDAwOAorI2RlZmluZSBCRkFfQ0VFX0xMRFBfU1lTX0NBUF9ST1VURVIgICAgICAweDAwMTAKKyNkZWZpbmUgQkZBX0NFRV9MTERQX1NZU19DQVBfVEVMRVBIT05FIAkgMHgwMDIwCisjZGVmaW5lIEJGQV9DRUVfTExEUF9TWVNfQ0FQX0RPQ1NJU19DRCAgIDB4MDA0MAorI2RlZmluZSBCRkFfQ0VFX0xMRFBfU1lTX0NBUF9TVEFUSU9OICAgICAweDAwODAKKyNkZWZpbmUgQkZBX0NFRV9MTERQX1NZU19DQVBfQ1ZMQU4JICAgICAweDAxMDAKKyNkZWZpbmUgQkZBX0NFRV9MTERQX1NZU19DQVBfU1ZMQU4gCSAgICAgMHgwMjAwCisjZGVmaW5lIEJGQV9DRUVfTExEUF9TWVNfQ0FQX1RQTVIJCSAweDA0MDAKKworCisvKiBMTERQIHN0cmluZyB0eXBlICovCitzdHJ1Y3QgYmZhX2NlZV9sbGRwX3N0cl9zIHsKKwl1OCBzdWJfdHlwZTsKKwl1OCBsZW47CisJdTggcnN2ZFsyXTsKKwl1OCB2YWx1ZVtCRkFfQ0VFX0xMRFBfTUFYX1NUUklOR19MRU5dOworfTsKKworCisvKiBMTERQIHBhcmFtdGVycyAqLworc3RydWN0IGJmYV9jZWVfbGxkcF9jZmdfcyB7CisJc3RydWN0IGJmYV9jZWVfbGxkcF9zdHJfcyBjaGFzc2lzX2lkOworCXN0cnVjdCBiZmFfY2VlX2xsZHBfc3RyX3MgcG9ydF9pZDsKKwlzdHJ1Y3QgYmZhX2NlZV9sbGRwX3N0cl9zIHBvcnRfZGVzYzsKKwlzdHJ1Y3QgYmZhX2NlZV9sbGRwX3N0cl9zIHN5c19uYW1lOworCXN0cnVjdCBiZmFfY2VlX2xsZHBfc3RyX3Mgc3lzX2Rlc2M7CisJc3RydWN0IGJmYV9jZWVfbGxkcF9zdHJfcyBtZ210X2FkZHI7CisJdTE2ICAgIHRpbWVfdG9faW50ZXJ2YWw7CisJdTE2ICAgIGVuYWJsZWRfc3lzdGVtX2NhcDsKK307CisKK2VudW0gYmZhX2NlZV9kY2J4X3ZlcnNpb25fZSB7CisJRENCWF9QUk9UT0NPTF9QUkVDRUUgPSAxLAorCURDQlhfUFJPVE9DT0xfQ0VFICAgID0gMiwKK307CisKK2VudW0gYmZhX2NlZV9sbHNfZSB7CisJQ0VFX0xMU19ET1dOX05PX1RMViA9IDAsIC8qIExMUyBpcyBkb3duIGJlY2F1c2UgdGhlIFRMViBub3Qgc2VudCBieQorCQkJCSAgKiB0aGUgcGVlciAqLworCUNFRV9MTFNfRE9XTiAgICAgICAgPSAxLCAvKiBMTFMgaXMgZG93biBhcyBhZHZlcnRpc2VkIGJ5IHRoZSBwZWVyICovCisJQ0VFX0xMU19VUCAgICAgICAgICA9IDIsCit9OworCisvKiBDRUUvRENCWCBwYXJhbWV0ZXJzICovCitzdHJ1Y3QgYmZhX2NlZV9kY2J4X2NmZ19zIHsKKwl1OCBwZ2lkWzhdOworCXU4IHBnX3BlcmNlbnRhZ2VbOF07CisJdTggcGZjX2VuYWJsZWQ7ICAgICAgICAgIC8qIGJpdG1hcCBvZiBwcmlvcnRpZXMgd2l0aCBQRkMgZW5hYmxlZCAqLworCXU4IGZjb2VfdXNlcl9wcmlvcml0eTsgICAvKiBiaXRtYXAgb2YgcHJpb3JpdGllcyB1c2VkIGZvciBGY29FCisJCQkJICAgICAgICogdHJhZmZpYyAqLworCXU4IGRjYnhfdmVyc2lvbjsJLyogb3BlcmF0aW5nIHZlcnNpb246Q0VFIG9yIHByZUNFRSAqLworCXU4IGxsc19mY29lOwkvKiBGQ29FIExvZ2ljYWwgTGluayBTdGF0dXMgKi8KKwl1OCBsbHNfbGFuOwkvKiBMQU4gTG9naWNhbCBMaW5rIFN0YXR1cyAqLworCXU4IHJzdmRbM107Cit9OworCisvKiBDRUUgc3RhdHVzICovCisvKiBNYWtpbmcgdGhpcyB0byB0cmktc3RhdGUgZm9yIHRoZSBiZW5lZml0IG9mIHBvcnQgbGlzdCBjb21tYW5kICovCitlbnVtIGJmYV9jZWVfc3RhdHVzX2UgeworICAgIENFRV9QSFlfRE9XTiA9IDAsCisgICAgQ0VFX1BIWV9VUCA9IDEsCisgICAgQ0VFX1VQID0gMiwKK307CisKKy8qIENFRSBRdWVyeSAqLworc3RydWN0IGJmYV9jZWVfYXR0cl9zIHsKKwl1OCAgICAgICAgICAgICAgICAgICBjZWVfc3RhdHVzOworCXU4ICAgICAgICAgICAgICAgICAgIGVycm9yX3JlYXNvbjsKKwlzdHJ1Y3QgYmZhX2NlZV9sbGRwX2NmZ19zIGxsZHBfcmVtb3RlOworCXN0cnVjdCBiZmFfY2VlX2RjYnhfY2ZnX3MgZGNieF9yZW1vdGU7CisJbWFjX3Qgc3JjX21hYzsKKwl1OCBsaW5rX3NwZWVkOworCXU4IGZpbGxlclszXTsKK307CisKKworCisKKy8qIExMRFAvRENCWC9DRUUgU3RhdGlzdGljcyAqLworCitzdHJ1Y3QgYmZhX2NlZV9sbGRwX3N0YXRzX3MgeworCXUzMiBmcmFtZXNfdHJhbnNtaXR0ZWQ7CisJdTMyIGZyYW1lc19hZ2VkX291dDsKKwl1MzIgZnJhbWVzX2Rpc2NhcmRlZDsKKwl1MzIgZnJhbWVzX2luX2Vycm9yOworCXUzMiBmcmFtZXNfcmN2ZDsKKwl1MzIgdGx2c19kaXNjYXJkZWQ7CisJdTMyIHRsdnNfdW5yZWNvZ25pemVkOworfTsKKworc3RydWN0IGJmYV9jZWVfZGNieF9zdGF0c19zIHsKKwl1MzIgc3VidGx2c191bnJlY29nbml6ZWQ7CisJdTMyIG5lZ290aWF0aW9uX2ZhaWxlZDsKKwl1MzIgcmVtb3RlX2NmZ19jaGFuZ2VkOworCXUzMiB0bHZzX3JlY2VpdmVkOworCXUzMiB0bHZzX2ludmFsaWQ7CisJdTMyIHNlcW5vOworCXUzMiBhY2tubzsKKwl1MzIgcmVjdmRfc2Vxbm87CisJdTMyIHJlY3ZkX2Fja25vOworfTsKKworc3RydWN0IGJmYV9jZWVfY2ZnX3N0YXRzX3MgeworCXUzMiBjZWVfc3RhdHVzX2Rvd247CisJdTMyIGNlZV9zdGF0dXNfdXA7CisJdTMyIGNlZV9od19jZmdfY2hhbmdlZDsKKwl1MzIgcmVjdmRfaW52YWxpZF9jZmc7Cit9OworCisKK3N0cnVjdCBiZmFfY2VlX3N0YXRzX3MgeworCXN0cnVjdCBiZmFfY2VlX2xsZHBfc3RhdHNfcyBsbGRwX3N0YXRzOworCXN0cnVjdCBiZmFfY2VlX2RjYnhfc3RhdHNfcyBkY2J4X3N0YXRzOworCXN0cnVjdCBiZmFfY2VlX2NmZ19zdGF0c19zICBjZmdfc3RhdHM7Cit9OworCisjcHJhZ21hIHBhY2soKQorCisKKyNlbmRpZgkvKiBfX0JGQV9ERUZTX0NFRV9IX18gKi8KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19kcml2ZXIuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2RyaXZlci5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU3MDQ5ODAKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19kcml2ZXIuaApAQCAtMCwwICsxLDQwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfREVGU19EUklWRVJfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfRFJJVkVSX0hfXworCisvKioKKyAqIERyaXZlciBzdGF0aXN0aWNzCisgKi8KKwl1MTYgICAgdG1faW9fYWJvcnQ7CisgICAgdTE2ICAgIHRtX2lvX2Fib3J0X2NvbXA7CisgICAgdTE2ICAgIHRtX2x1bl9yZXNldDsKKyAgICB1MTYgICAgdG1fbHVuX3Jlc2V0X2NvbXA7CisgICAgdTE2ICAgIHRtX3RhcmdldF9yZXNldDsKKyAgICB1MTYgICAgdG1fYnVzX3Jlc2V0OworICAgIHUxNiAgICBpb2NfcmVzdGFydDsgICAgICAgIC8qICBJT0MgcmVzdGFydCBjb3VudCAqLworICAgIHUxNiAgICBpb19wZW5kaW5nOyAgICAgICAgIC8qICBvdXRzdGFuZGluZyBpbyBjb3VudCBwZXItSU9DICovCisgICAgdTY0ICAgIGNvbnRyb2xfcmVxOworICAgIHU2NCAgICBpbnB1dF9yZXE7CisgICAgdTY0ICAgIG91dHB1dF9yZXE7CisgICAgdTY0ICAgIGlucHV0X3dvcmRzOworICAgIHU2NCAgICBvdXRwdXRfd29yZHM7Cit9IGJmYV9kcml2ZXJfc3RhdHNfdDsKKworCisjZW5kaWYgLyogX19CRkFfREVGU19EUklWRVJfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19ldGhwb3J0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19ldGhwb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzlmOWIzZQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2V0aHBvcnQuaApAQCAtMCwwICsxLDk4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfREVGU19FVEhQT1JUX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX0VUSFBPUlRfSF9fCisKKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3N0YXR1cy5oPgorI2luY2x1ZGUgPHByb3RvY29sL3R5cGVzLmg+CisjaW5jbHVkZSA8Y25hL3BzdGF0cy9waHlwb3J0X2RlZnMuaD4KKyNpbmNsdWRlIDxjbmEvcHN0YXRzL2V0aHBvcnRfZGVmcy5oPgorCitzdHJ1Y3QgYm5hX3R4X2luZm9fcyB7CisJdTMyICAgIG1pbmlwb3J0X3N0YXRlOworCXUzMiAgICBhZGFwdGVyX3N0YXRlOworCXU2NCAgICB0eF9jb3VudDsKKwl1NjQgICAgdHhfd2k7CisJdTY0ICAgIHR4X3NnOworCXU2NCAgICB0eF90Y3BfY2hrc3VtOworCXU2NCAgICB0eF91ZHBfY2hrc3VtOworCXU2NCAgICB0eF9pcF9jaGtzdW07CisJdTY0ICAgIHR4X2xzb3YxOworCXU2NCAgICB0eF9sc292MjsKKwl1NjQgICAgdHhfbWF4X3NnX2xlbiA7Cit9OworCitzdHJ1Y3QgYm5hX3J4X3F1ZXVlX2luZm9fcyB7CisJdTE2ICAgIHFfaWQgOworCXUxNiAgICBidWZfc2l6ZSA7CisJdTE2ICAgIGJ1Zl9jb3VudCA7CisJdTE2ICAgIHJzdmQgOworCXU2NCAgICByeF9jb3VudCA7CisJdTY0ICAgIHJ4X2Ryb3BwZWQgOworCXU2NCAgICByeF91bnN1cHBvcnRlZCA7CisJdTY0ICAgIHJ4X2ludGVybmFsX2VyciA7CisJdTY0ICAgIHJzc19jb3VudCA7CisJdTY0ICAgIHZsYW5fY291bnQgOworCXU2NCAgICByeF90Y3BfY2hrc3VtIDsKKwl1NjQgICAgcnhfdWRwX2Noa3N1bSA7CisJdTY0ICAgIHJ4X2lwX2Noa3N1bSA7CisJdTY0ICAgIHJ4X2hkcyA7Cit9OworCitzdHJ1Y3QgYm5hX3J4X3Ffc2V0X3MgeworCXUxNiAgICBxX3NldF90eXBlOworCXUzMiAgICBtaW5pcG9ydF9zdGF0ZTsKKwl1MzIgICAgYWRhcHRlcl9zdGF0ZTsKKwlzdHJ1Y3QgYm5hX3J4X3F1ZXVlX2luZm9fcyAgICByeF9xdWV1ZVsyXTsKK307CisKK3N0cnVjdCBibmFfcG9ydF9zdGF0c19zIHsKKwlzdHJ1Y3QgYm5hX3R4X2luZm9fcyAgIHR4X3N0YXRzOworCXUxNiAgICAgICAgcXNldF9jb3VudCA7CisJc3RydWN0IGJuYV9yeF9xX3NldF9zICByeF9xc2V0WzhdOworfTsKKworc3RydWN0IGJmYV9ldGhwb3J0X3N0YXRzX3MgeworCXN0cnVjdCBibmFfc3RhdHNfdHhmCXR4Zl9zdGF0c1sxXTsKKwlzdHJ1Y3QgYm5hX3N0YXRzX3J4ZglyeGZfc3RhdHNbMV07CisJc3RydWN0IGJuYWRfZHJ2X3N0YXRzIGRydl9zdGF0czsKK307CisKKy8qKgorICogRXRoZXJuZXQgcG9ydCBldmVudHMKKyAqIEFyZ3VtZW50cyBiZWxvdyBhcmUgaW4gQkZBTCBjb250ZXh0IGZyb20gTWdtdAorICogQkZBX1BPUlRfQUVOX0VUSF9MSU5LVVA6ICAgIFtpbl06IG1hYyBbb3V0XTogbWFjCisgKiBCRkFfUE9SVF9BRU5fRVRIX0xJTktET1dOOiAgW2luXTogbWFjIFtvdXRdOiBtYWMKKyAqIEJGQV9QT1JUX0FFTl9FVEhfRU5BQkxFOiAgW2luXTogbWFjIFtvdXRdOiBtYWMKKyAqIEJGQV9QT1JUX0FFTl9FVEhfRElTQUJMRTogIFtpbl06IG1hYyBbb3V0XTogbWFjCisgKgorICovCitlbnVtIGJmYV9ldGhwb3J0X2Flbl9ldmVudCB7CisJQkZBX0VUSFBPUlRfQUVOX0xJTktVUCA9IDEsIC8qICBCYXNlIFBvcnQgRXRoZXJuZXQgbGluayB1cCBldmVudCAqLworCUJGQV9FVEhQT1JUX0FFTl9MSU5LRE9XTiA9IDIsIC8qICBCYXNlIFBvcnQgRXRoZXJuZXQgbGluayBkb3duIGV2ZW50ICovCisJQkZBX0VUSFBPUlRfQUVOX0VOQUJMRSA9IDMsIC8qICBCYXNlIFBvcnQgRXRoZXJuZXQgbGluayBlbmFibGUgZXZlbnQgKi8KKwlCRkFfRVRIUE9SVF9BRU5fRElTQUJMRSA9IDQsIC8qICBCYXNlIFBvcnQgRXRoZXJuZXQgbGluayBkaXNhYmxlCisJCQkJICAgICAgKiBldmVudCAqLworfTsKKworc3RydWN0IGJmYV9ldGhwb3J0X2Flbl9kYXRhX3MgeworCW1hY190IG1hYzsJLyogIE1BQyBhZGRyZXNzIG9mIHRoZSBwaHlzaWNhbCBwb3J0ICovCit9OworCisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX0VUSFBPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19mY3BpbS5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfZmNwaW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMDhmNGY1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfZmNwaW0uaApAQCAtMCwwICsxLDQ1IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0RFRlNfRkNQSU1fSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfRkNQSU1fSF9fCisKK3N0cnVjdCBiZmFfZmNwaW1fc3RhdHNfcyB7CisJdTMyICAgICAgICB0b3RhbF9pb3M7CS8qICBUb3RhbCBJTyBjb3VudCAqLworCXUzMiAgICAgICAgcXJlc3VtZXM7CS8qICBJTyB3YWl0aW5nIGZvciBDUSBzcGFjZSAqLworCXUzMiAgICAgICAgbm9faW90YWdzOwkvKiAgTk8gSU8gY29udGV4dHMgKi8KKwl1MzIgICAgICAgIGlvX2Fib3J0czsJLyogIElPIGFib3J0IHJlcXVlc3RzICovCisJdTMyICAgICAgICBub190c2tpbXM7CS8qICBOTyB0YXNrIG1hbmFnZW1lbnQgY29udGV4dHMgKi8KKwl1MzIgICAgICAgIGlvY29tcF9vazsJLyogIElPIGNvbXBsZXRpb25zIHdpdGggT0sgc3RhdHVzICovCisJdTMyICAgICAgICBpb2NvbXBfdW5kZXJydW47CS8qICBJTyB1bmRlcnJ1biAoZ29vZCkgKi8KKwl1MzIgICAgICAgIGlvY29tcF9vdmVycnVuOwkvKiAgSU8gb3ZlcnJ1biAoZ29vZCkgKi8KKwl1MzIgICAgICAgIGlvY29tcF9hYm9ydGVkOwkvKiAgQWJvcnRlZCBJTyByZXF1ZXN0cyAqLworCXUzMiAgICAgICAgaW9jb21wX3RpbWVkb3V0OwkvKiAgSU8gdGltZW91dHMgKi8KKwl1MzIgICAgICAgIGlvY29tX25leHVzX2Fib3J0OwkvKiAgSU8gc2VsZWN0aW9uIHRpbWVvdXRzICovCisJdTMyICAgICAgICBpb2NvbV9wcm90b19lcnI7CS8qICBJTyBwcm90b2NvbCBlcnJvcnMgKi8KKwl1MzIgICAgICAgIGlvY29tX2RpZl9lcnI7CS8qICBJTyBTQkMtMyBwcm90ZWN0aW9uIGVycm9ycyAqLworCXUzMiAgICAgICAgaW9jb21fdG1fYWJvcnQ7CS8qICBJTyBhYm9ydGVkIGJ5IFRNIHJlcXVlc3RzICovCisJdTMyICAgICAgICBpb2NvbV9zcWVyX25lZWRlZDsJLyogIElPIHJldHJ5IGZvciBTUSBlcnJvcgorCQkJCQkJICpyZWNvdmVyeSAqLworCXUzMiAgICAgICAgaW9jb21fcmVzX2ZyZWU7CS8qICBEZWxheWVkIGZyZWVpbmcgb2YgSU8gcmVzb3VyY2VzICovCisJdTMyICAgICAgICBpb2NvbXBfc2NzaWVycjsJLyogIElPIHdpdGggbm9uLWdvb2QgU0NTSSBzdGF0dXMgKi8KKwl1MzIgICAgICAgIGlvY29tX2hvc3RhYnJ0czsJLyogIEhvc3QgSU8gYWJvcnQgcmVxdWVzdHMgKi8KKwl1MzIgICAgICAgIGlvY29tX3V0YWdzOwkvKiAgSU8gY29tcCB3aXRoIHVua25vd24gdGFncyAqLworCXUzMiAgICAgICAgaW9fY2xlYW51cHM7CS8qICBJTyBpbXBsaWNpdGx5IGFib3J0ZWQgKi8KKwl1MzIgICAgICAgIGlvX3RtYWJvcnRzOwkvKiAgSU8gYWJvcnRlZCBkdWUgdG8gVE0gY29tbWFuZHMgKi8KKwl1MzIgICAgICAgIHJzdmQ7Cit9OworI2VuZGlmIC8qX19CRkFfREVGU19GQ1BJTV9IX18qLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfaW1fY29tbW9uLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19pbV9jb21tb24uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45Y2NmNTNiCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfaW1fY29tbW9uLmgKQEAgLTAsMCArMSwzMiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfSU1fQ09NTU9OX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX0lNX0NPTU1PTl9IX18KKworI2RlZmluZQlCRkFfQURBUFRFUl9OQU1FX0xFTgkyNTYKKyNkZWZpbmUgQkZBX0FEQVBURVJfR1VJRF9MRU4gICAgMjU2CisjZGVmaW5lIFJFU0VSVkVEX1ZMQU5fTkFNRSAgICAgIEwiUE9SVCBWTEFOIgorI2RlZmluZSBQQVNTVEhSVV9WTEFOX05BTUUgICAgICBMIlBBU1NUSFJVIFZMQU4iCisKKwl1NjQJdHhfcGt0X2NudDsKKwl1NjQJcnhfcGt0X2NudDsKKwl1MzIJZHVyYXRpb247CisJdTgJCXN0YXR1czsKK30gYmZhX2ltX3N0YXRzX3QsICpwYmZhX2ltX3N0YXRzX3Q7CisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX0lNX0NPTU1PTl9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2ltX3RlYW0uaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2ltX3RlYW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hNDg2YTdlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfaW1fdGVhbS5oCkBAIC0wLDAgKzEsNzIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9ERUZTX0lNX1RFQU1fSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfSU1fVEVBTV9IX18KKworI2luY2x1ZGUgPHByb3RvY29sL3R5cGVzLmg+CisKKyNkZWZpbmUJQkZBX1RFQU1fTUFYX1BPUlRTCTgKKyNkZWZpbmUJQkZBX1RFQU1fTkFNRV9MRU4JMjU2CisjZGVmaW5lIEJGQV9NQVhfTlVNX1RFQU1TCTE2CisjZGVmaW5lIEJGQV9URUFNX0lOVkFMSURfREVMQVkgLTEKKworCUJGQV9MQUNQX1JBVEVfU0xPVyA9IDEsCisJQkZBX0xBQ1BfUkFURV9GQVNUCit9IGJmYV9pbV9sYWNwX3JhdGVfdDsKKworCUJGQV9URUFNX01PREVfRkFJTF9PVkVSID0gMSwKKwlCRkFfVEVBTV9NT0RFX0ZBSUxfQkFDSywKKwlCRkFfVEVBTV9NT0RFX0xBQ1AsCisJQkZBX1RFQU1fTU9ERV9OT05FCit9IGJmYV9pbV90ZWFtX21vZGVfdDsKKworCUJGQV9YTUlUX1BPTElDWV9MMiA9IDEsCisJQkZBX1hNSVRfUE9MSUNZX0wzX0w0Cit9IGJmYV9pbV94bWl0X3BvbGljeV90OworCisJYmZhX2ltX3RlYW1fbW9kZV90ICAgICB0ZWFtX21vZGU7CisJYmZhX2ltX2xhY3BfcmF0ZV90ICAgICBsYWNwX3JhdGU7CisJYmZhX2ltX3htaXRfcG9saWN5X3QgICB4bWl0X3BvbGljeTsKKwlpbnQgICAJICAgICAgICAgIGRlbGF5OworCXdjaGFyX3QgICAgCSAgcHJpbWFyeVtCRkFfQURBUFRFUl9OQU1FX0xFTl07CisJd2NoYXJfdCAgICAgICAgCSAgcHJlZmVycmVkX3ByaW1hcnlbQkZBX0FEQVBURVJfTkFNRV9MRU5dOworCW1hY190CSAgICAgICAgICBtYWM7CisJdTE2ICAgICAgIAkgIG51bV9wb3J0czsKKwl1MTYgICAgICAgICAgbnVtX3ZsYW5zOworCXUxNiB2bGFuX2xpc3RbQkZBX01BWF9WTEFOU19QRVJfUE9SVF07CisJd2NoYXJfdAkgdGVhbV9ndWlkX2xpc3RbQkZBX1RFQU1fTUFYX1BPUlRTXVtCRkFfQURBUFRFUl9HVUlEX0xFTl07CisJd2NoYXJfdAkgaW9jX25hbWVfbGlzdFtCRkFfVEVBTV9NQVhfUE9SVFNdW0JGQV9BREFQVEVSX05BTUVfTEVOXTsKK30gYmZhX2ltX3RlYW1fYXR0cl90OworCisJd2NoYXJfdAkJICAgICAgICAgICAgIHRlYW1fbmFtZVtCRkFfVEVBTV9OQU1FX0xFTl07CisJYmZhX2ltX3htaXRfcG9saWN5X3QJIHhtaXRfcG9saWN5OworCWludCAgICAgICAgICAgICAgICAgCSBkZWxheTsKKwl3Y2hhcl90ICAgICAgICAgICAgICAgIAkgcHJpbWFyeVtCRkFfQURBUFRFUl9OQU1FX0xFTl07CisJd2NoYXJfdCAgICAgICAgICAgICAgIAkgcHJlZmVycmVkX3ByaW1hcnlbQkZBX0FEQVBURVJfTkFNRV9MRU5dOworfSBiZmFfaW1fdGVhbV9lZGl0X3QsICpwYmZhX2ltX3RlYW1fZWRpdF90OworCisJd2NoYXJfdAkJCQkJdGVhbV9uYW1lW0JGQV9URUFNX05BTUVfTEVOXTsKKwliZmFfaW1fdGVhbV9tb2RlX3QgICAgICB0ZWFtX21vZGU7CisJbWFjX3QJICAgICAgICAgICAgICAgCW1hYzsKK30gYmZhX2ltX3RlYW1faW5mb190OworCisJYmZhX2ltX3RlYW1faW5mb190IAkJdGVhbV9pbmZvW0JGQV9NQVhfTlVNX1RFQU1TXTsKKwl1MTYgCQkJCW51bV90ZWFtczsKK30gYmZhX2ltX3RlYW1fbGlzdF90LCAqcGJmYV9pbV90ZWFtX2xpc3RfdDsKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfSU1fVEVBTV9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2lvYy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfaW9jLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjFkNTMyZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2lvYy5oCkBAIC0wLDAgKzEsMTUyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfREVGU19JT0NfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfSU9DX0hfXworCisjaW5jbHVkZSA8cHJvdG9jb2wvdHlwZXMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3R5cGVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc192ZXJzaW9uLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19hZGFwdGVyLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wbS5oPgorCitlbnVtIHsKKwlCRkFfSU9DX0RSSVZFUl9MRU4JPSAxNiwKKwlCRkFfSU9DX0NISVBfUkVWX0xFTiAJPSA4LAorfTsKKworLyoqCisgKiBEcml2ZXIgYW5kIGZpcm13YXJlIHZlcnNpb25zLgorICovCitzdHJ1Y3QgYmZhX2lvY19kcml2ZXJfYXR0cl9zIHsKKwljaGFyICAgICAgICAgICAgZHJpdmVyW0JGQV9JT0NfRFJJVkVSX0xFTl07CS8qICBkcml2ZXIgbmFtZSAqLworCWNoYXIgICAgICAgICAgICBkcml2ZXJfdmVyW0JGQV9WRVJTSU9OX0xFTl07CS8qICBkcml2ZXIgdmVyc2lvbiAqLworCWNoYXIgICAgICAgICAgICBmd192ZXJbQkZBX1ZFUlNJT05fTEVOXTsJLyogIGZpcm13YXJlIHZlcnNpb24qLworCWNoYXIgICAgICAgICAgICBiaW9zX3ZlcltCRkFfVkVSU0lPTl9MRU5dOwkvKiAgYmlvcyB2ZXJzaW9uICovCisJY2hhciAgICAgICAgICAgIGVmaV92ZXJbQkZBX1ZFUlNJT05fTEVOXTsJLyogIEVGSSB2ZXJzaW9uICovCisJY2hhciAgICAgICAgICAgIG9iX3ZlcltCRkFfVkVSU0lPTl9MRU5dOwkvKiAgb3BlbmJvb3QgdmVyc2lvbiovCit9OworCisvKioKKyAqIElPQyBQQ0kgZGV2aWNlIGF0dHJpYnV0ZXMKKyAqLworc3RydWN0IGJmYV9pb2NfcGNpX2F0dHJfcyB7CisJdTE2ICAgICAgICB2ZW5kb3JfaWQ7CS8qICBQQ0kgdmVuZG9yIElEICovCisJdTE2ICAgICAgICBkZXZpY2VfaWQ7CS8qICBQQ0kgZGV2aWNlIElEICovCisJdTE2ICAgICAgICBzc2lkOwkJLyogIHN1YnN5c3RlbSBJRCAqLworCXUxNiAgICAgICAgc3N2aWQ7CQkvKiAgc3Vic3lzdGVtIHZlbmRvciBJRCAqLworCXUzMiAgICAgICAgcGNpZm47CQkvKiAgUENJIGRldmljZSBmdW5jdGlvbiAqLworCXUzMiAgICAgICAgcnN2ZDsJCS8qIHBhZGRpbmcgKi8KKwl1OCAgICAgICAgIGNoaXBfcmV2W0JGQV9JT0NfQ0hJUF9SRVZfTEVOXTsJIC8qICBjaGlwIHJldmlzaW9uICovCit9OworCisvKioKKyAqIElPQyBzdGF0ZXMKKyAqLworZW51bSBiZmFfaW9jX3N0YXRlIHsKKwlCRkFfSU9DX1JFU0VUICAgICAgID0gMSwgIC8qICBJT0MgaXMgaW4gcmVzZXQgc3RhdGUgKi8KKwlCRkFfSU9DX1NFTVdBSVQgICAgID0gMiwgIC8qICBXYWl0aW5nIGZvciBJT0MgaGFyZHdhcmUgc2VtYXBob3JlICovCisJQkZBX0lPQ19IV0lOSVQgCSAgICA9IDMsICAvKiAgSU9DIGhhcmR3YXJlIGlzIGJlaW5nIGluaXRpYWxpemVkICovCisJQkZBX0lPQ19HRVRBVFRSICAgICA9IDQsICAvKiAgSU9DIGlzIGJlaW5nIGNvbmZpZ3VyZWQgKi8KKwlCRkFfSU9DX09QRVJBVElPTkFMID0gNSwgIC8qICBJT0MgaXMgb3BlcmF0aW9uYWwgKi8KKwlCRkFfSU9DX0lOSVRGQUlMICAgID0gNiwgIC8qICBJT0MgaGFyZHdhcmUgZmFpbHVyZSAqLworCUJGQV9JT0NfSEJGQUlMICAgICAgPSA3LCAgLyogIElPQyBoZWFydC1iZWF0IGZhaWx1cmUgKi8KKwlCRkFfSU9DX0RJU0FCTElORyAgID0gOCwgIC8qICBJT0MgaXMgYmVpbmcgZGlzYWJsZWQgKi8KKwlCRkFfSU9DX0RJU0FCTEVEICAgID0gOSwgIC8qICBJT0MgaXMgZGlzYWJsZWQgKi8KKwlCRkFfSU9DX0ZXTUlTTUFUQ0ggID0gMTAsIC8qICBJT0MgZmlybXdhcmUgZGlmZmVyZW50IGZyb20gZHJpdmVycyAqLworfTsKKworLyoqCisgKiBJT0MgZmlybXdhcmUgc3RhdHMKKyAqLworc3RydWN0IGJmYV9md19pb2Nfc3RhdHNfcyB7CisJdTMyICAgICAgICBoYl9jb3VudDsKKwl1MzIgICAgICAgIGNmZ19yZXFzOworCXUzMiAgICAgICAgZW5hYmxlX3JlcXM7CisJdTMyICAgICAgICBkaXNhYmxlX3JlcXM7CisJdTMyICAgICAgICBzdGF0c19yZXFzOworCXUzMiAgICAgICAgY2xyc3RhdHNfcmVxczsKKwl1MzIgICAgICAgIHVua25vd25fcmVxczsKKwl1MzIgICAgICAgIGljX3JlcXM7CQkvKiAgaW50ZXJydXB0IGNvYWxlc2NlIHJlcXMgKi8KK307CisKKy8qKgorICogSU9DIGRyaXZlciBzdGF0cworICovCitzdHJ1Y3QgYmZhX2lvY19kcnZfc3RhdHNfcyB7CisJdTMyCWlvY19pc3JzOworCXUzMglpb2NfZW5hYmxlczsKKwl1MzIJaW9jX2Rpc2FibGVzOworCXUzMglpb2NfaGJmYWlsczsKKwl1MzIJaW9jX2Jvb3RzOworCXUzMglzdGF0c190bW9zOworCXUzMiAgICAgICAgaGJfY291bnQ7CisJdTMyICAgICAgICBkaXNhYmxlX3JlcXM7CisJdTMyICAgICAgICBlbmFibGVfcmVxczsKKwl1MzIgICAgICAgIGRpc2FibGVfcmVwbGllczsKKwl1MzIgICAgICAgIGVuYWJsZV9yZXBsaWVzOworfTsKKworLyoqCisgKiBJT0Mgc3RhdGlzdGljcworICovCitzdHJ1Y3QgYmZhX2lvY19zdGF0c19zIHsKKwlzdHJ1Y3QgYmZhX2lvY19kcnZfc3RhdHNfcwlkcnZfc3RhdHM7IC8qICBkcml2ZXIgSU9DIHN0YXRzICovCisJc3RydWN0IGJmYV9md19pb2Nfc3RhdHNfcyAJZndfc3RhdHM7ICAvKiAgZmlybXdhcmUgSU9DIHN0YXRzICovCit9OworCisKK2VudW0gYmZhX2lvY190eXBlX2UgeworCUJGQV9JT0NfVFlQRV9GQwkgID0gMSwKKwlCRkFfSU9DX1RZUEVfRkNvRSA9IDIsCisJQkZBX0lPQ19UWVBFX0xMCSAgPSAzLAorfTsKKworLyoqCisgKiBJT0MgYXR0cmlidXRlcyByZXR1cm5lZCBpbiBxdWVyaWVzCisgKi8KK3N0cnVjdCBiZmFfaW9jX2F0dHJfcyB7CisJZW51bSBiZmFfaW9jX3R5cGVfZQkJaW9jX3R5cGU7CisJZW51bSBiZmFfaW9jX3N0YXRlIAkJc3RhdGU7CQkvKiAgSU9DIHN0YXRlICAgICAgKi8KKwlzdHJ1Y3QgYmZhX2FkYXB0ZXJfYXR0cl9zCWFkYXB0ZXJfYXR0cjsJLyogIEhCQSBhdHRyaWJ1dGVzICovCisJc3RydWN0IGJmYV9pb2NfZHJpdmVyX2F0dHJfcyAJZHJpdmVyX2F0dHI7CS8qICBkcml2ZXIgYXR0ciAgICAqLworCXN0cnVjdCBiZmFfaW9jX3BjaV9hdHRyX3MJcGNpX2F0dHI7CisJdTgJCQkJcG9ydF9pZDsJLyogIHBvcnQgbnVtYmVyICAgICovCit9OworCisvKioKKyAqIEJGQSBJT0MgbGV2ZWwgZXZlbnRzCisgKi8KK2VudW0gYmZhX2lvY19hZW5fZXZlbnQgeworCUJGQV9JT0NfQUVOX0hCR09PRAk9IDEsCS8qICBIZWFydCBCZWF0IHJlc3RvcmUgZXZlbnQJKi8KKwlCRkFfSU9DX0FFTl9IQkZBSUwJPSAyLAkvKiAgSGVhcnQgQmVhdCBmYWlsdXJlIGV2ZW50CSovCisJQkZBX0lPQ19BRU5fRU5BQkxFCT0gMywJLyogIElPQyBlbmFibGVkIGV2ZW50CQkqLworCUJGQV9JT0NfQUVOX0RJU0FCTEUJPSA0LAkvKiAgSU9DIGRpc2FibGVkIGV2ZW50CQkqLworCUJGQV9JT0NfQUVOX0ZXTUlTTUFUQ0gJPSA1LAkvKiAgSU9DIGZpcm13YXJlIG1pc21hdGNoCSovCit9OworCisvKioKKyAqIEJGQSBJT0MgbGV2ZWwgZXZlbnQgZGF0YSwgbm93IGp1c3QgYSBwbGFjZSBob2xkZXIKKyAqLworc3RydWN0IGJmYV9pb2NfYWVuX2RhdGFfcyB7CisJZW51bSBiZmFfaW9jX3R5cGVfZSBpb2NfdHlwZTsKKwl3d25fdAlwd3duOworCW1hY190CW1hYzsKK307CisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX0lPQ19IX18gKi8KKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfaW9jZmMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2lvY2ZjLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDc2YmNiZAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2lvY2ZjLmgKQEAgLTAsMCArMSwzMTAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9ERUZTX0lPQ0ZDX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX0lPQ0ZDX0hfXworCisjaW5jbHVkZSA8cHJvdG9jb2wvdHlwZXMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3R5cGVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc192ZXJzaW9uLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19hZGFwdGVyLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wbS5oPgorCisjZGVmaW5lIEJGQV9JT0NGQ19JTlRSX0RFTEFZCTExMjUKKyNkZWZpbmUgQkZBX0lPQ0ZDX0lOVFJfTEFURU5DWQkyMjUKKworLyoqCisgKiBJbnRlcnJ1cHQgY29hbGVzY2luZyBjb25maWd1cmF0aW9uLgorICovCitzdHJ1Y3QgYmZhX2lvY2ZjX2ludHJfYXR0cl9zIHsKKwliZmFfYm9vbGVhbl90CWNvYWxlc2NlOwkvKiAgZW5hYmxlL2Rpc2FibGUgY29hbGVzY2luZyAqLworCXUxNglsYXRlbmN5OwkvKiAgbGF0ZW5jeSBpbiBtaWNyb3NlY29uZHMgICAqLworCXUxNglkZWxheTsJCS8qICBkZWxheSBpbiBtaWNyb3NlY29uZHMgICAgICovCit9OworCisvKioKKyAqIElPQyBmaXJtd2FyZSBjb25maWd1cmF0b24KKyAqLworc3RydWN0IGJmYV9pb2NmY19md2NmZ19zIHsKKwl1MTYgICAgICAgIG51bV9mYWJyaWNzOwkvKiAgbnVtYmVyIG9mIGZhYnJpY3MJCSovCisJdTE2ICAgICAgICBudW1fbHBvcnRzOwkvKiAgbnVtYmVyIG9mIGxvY2FsIGxwb3J0cwkqLworCXUxNiAgICAgICAgbnVtX3Jwb3J0czsJLyogIG51bWJlciBvZiByZW1vdGUgcG9ydHMJKi8KKwl1MTYgICAgICAgIG51bV9pb2ltX3JlcXM7CS8qICBudW1iZXIgb2YgSU8gcmVxcwkJKi8KKwl1MTYgICAgICAgIG51bV90c2tpbV9yZXFzOwkvKiAgdGFzayBtYW5hZ2VtZW50IHJlcXVlc3RzCSovCisJdTE2ICAgICAgICBudW1faW90bV9yZXFzOwkvKiAgbnVtYmVyIG9mIFRNIElPIHJlcXMJKi8KKwl1MTYgICAgICAgIG51bV90c2t0bV9yZXFzOwkvKiAgVE0gdGFzayBtYW5hZ2VtZW50IHJlcXVlc3RzKi8KKwl1MTYgICAgICAgIG51bV9mY3hwX3JlcXM7CS8qICB1bmFzc2lzdGVkIEZDIGV4Y2hhbmdlcwkqLworCXUxNiAgICAgICAgbnVtX3VmX2J1ZnM7CS8qICB1bnNvbGljaXRlZCByZWN2IGJ1ZmZlcnMJKi8KKwl1OAkJbnVtX2NxczsKKwl1OAkJcnN2ZDsKK307CisKK3N0cnVjdCBiZmFfaW9jZmNfZHJ2Y2ZnX3MgeworCXUxNiAgICAgICAgbnVtX3JlcXFfZWxlbXM7CS8qICBudW1iZXIgb2YgcmVxIHF1ZXVlIGVsZW1lbnRzICovCisJdTE2ICAgICAgICBudW1fcnNwcV9lbGVtczsJLyogIG51bWJlciBvZiByc3AgcXVldWUgZWxlbWVudHMgKi8KKwl1MTYgICAgICAgIG51bV9zZ3BnczsJLyogIG51bWJlciBvZiB0b3RhbCBTRyBwYWdlcwkgICovCisJdTE2ICAgICAgICBudW1fc2Jvb3RfdGd0czsJLyogIG51bWJlciBvZiBTQU4gYm9vdCB0YXJnZXRzCSAgKi8KKwl1MTYgICAgICAgIG51bV9zYm9vdF9sdW5zOwkvKiAgbnVtYmVyIG9mIFNBTiBib290IGx1bnMJICAqLworCXUxNgkgICAgaW9jX3JlY292ZXI7CS8qICBJT0MgcmVjb3ZlcnkgbW9kZQkJICAqLworCXUxNgkgICAgbWluX2NmZzsJLyogIG1pbmltdW0gY29uZmlndXJhdGlvbgkgICovCisJdTE2ICAgICAgICBwYXRoX3RvdjsJLyogIGRldmljZSBwYXRoIHRpbWVvdXQJICAqLworCWJmYV9ib29sZWFuX3QgICBkZWxheV9jb21wOyAvKiAgZGVsYXkgY29tcGxldGlvbiBvZgorCQkJCQkJCWZhaWxlZCBpbmZsaWdodCBJT3MgKi8KKwl1MzIJCXJzdmQ7Cit9OworLyoqCisgKiBJT0MgY29uZmlndXJhdGlvbgorICovCitzdHJ1Y3QgYmZhX2lvY2ZjX2NmZ19zIHsKKwlzdHJ1Y3QgYmZhX2lvY2ZjX2Z3Y2ZnX3MJZndjZmc7CS8qICBmaXJtd2FyZSBzaWRlIGNvbmZpZyAqLworCXN0cnVjdCBiZmFfaW9jZmNfZHJ2Y2ZnX3MJZHJ2Y2ZnOwkvKiAgZHJpdmVyIHNpZGUgY29uZmlnCSAgKi8KK307CisKKy8qKgorICogSU9DIGZpcm13YXJlIElPIHN0YXRzCisgKi8KK3N0cnVjdCBiZmFfZndfaW9fc3RhdHNfcyB7CisJdTMyCWhvc3RfYWJvcnQ7CQkvKiAgSU8gYWJvcnRlZCBieSBob3N0IGRyaXZlciovCisJdTMyCWhvc3RfY2xlYW51cDsJCS8qICBJTyBjbGVhbiB1cCBieSBob3N0IGRyaXZlciAqLworCisJdTMyCWZ3X2lvX3RpbWVvdXQ7CQkvKiAgSU9zIHRpbWVkb3V0ICovCisJdTMyCWZ3X2ZybV9wYXJzZTsJCS8qICBmcmFtZSBwYXJzZWQgYnkgZi93ICovCisJdTMyCWZ3X2ZybV9kYXRhOwkJLyogIGZjcF9kYXRhIGZyYW1lIHBhcnNlZCBieSBmL3cgKi8KKwl1MzIJZndfZnJtX3JzcDsJCS8qICBmY3BfcnNwIGZyYW1lIHBhcnNlZCBieSBmL3cgKi8KKwl1MzIJZndfZnJtX3hmZXJfcmR5OwkvKiAgeGZlcl9yZHkgZnJhbWUgcGFyc2VkIGJ5IGYvdyAqLworCXUzMglmd19mcm1fYmxzX2FjYzsJCS8qICBCTFMgQUNDICBmcmFtZSBwYXJzZWQgYnkgZi93ICovCisJdTMyCWZ3X2ZybV90Z3RfYWJvcnQ7CS8qICB0YXJnZXQgQUJUUyBwYXJzZWQgYnkgZi93ICovCisJdTMyCWZ3X2ZybV91bmtub3duOwkJLyogIHVua25vd24gcGFyc2VkIGJ5IGYvdyAqLworCXUzMglmd19kYXRhX2RtYTsJCS8qICBmL3cgRE1BJ2VkIHRoZSBkYXRhIGZyYW1lICovCisJdTMyCWZ3X2ZybV9kcm9wOwkJLyogIGYvdyBkcm9wIHRoZSBmcmFtZSAqLworCisJdTMyCXJlY190aW1lb3V0OwkJLyogIEZXIHJlYyB0aW1lZCBvdXQgKi8KKwl1MzIJZXJyb3JfcmVjOwkJCS8qICBGVyBzZW5kaW5nIHJlYyBvbgorCQkJCQkJCSogYW4gZXJyb3IgY29uZGl0aW9uKi8KKwl1MzIJd2FpdF9mb3Jfc2k7CQkvKiAgRlcgd2FpdCBmb3IgU0kgKi8KKwl1MzIJcmVjX3JzcF9pbnZhbDsJCS8qICBSRUMgcnNwIGludmFsaWQgKi8KKwl1MzIJc2Vxcl9pb19hYm9ydDsJCS8qICB0YXJnZXQgZG9lcyBub3Qga25vdyBjbWQgc28gYWJvcnQgKi8KKwl1MzIJc2Vxcl9pb19yZXRyeTsJCS8qICBTRVFSIGZhaWxlZCBzbyByZXRyeSBJTyAqLworCisJdTMyCWl0bl9jaXNjX3VwZF9yc3A7CS8qICBJVE4gY2lzYyB1cGRhdGVkIG9uIGZjcF9yc3AgKi8KKwl1MzIJaXRuX2Npc2NfdXBkX2RhdGE7CS8qICBJVE4gY2lzYyB1cGRhdGVkIG9uIGZjcF9kYXRhICovCisJdTMyCWl0bl9jaXNjX3VwZF94ZmVyX3JkeTsJLyogIElUTiBjaXNjIHVwZGF0ZWQgb24gZmNwX2RhdGEgKi8KKworCXUzMglmY3BfZGF0YV9sb3N0OwkJLyogIGZjcCBkYXRhIGxvc3QgKi8KKworCXUzMglyb19zZXRfaW5feGZlcl9yZHk7CS8qICBUYXJnZXQgc2V0IFJPIGluIFhmZXJfcmR5IGZyYW1lICovCisJdTMyCXhmZXJfcmR5X29vb19lcnI7CS8qICBPdXQgb2Ygb3JkZXIgWGZlcl9yZHkgcmVjZWl2ZWQgKi8KKwl1MzIJeGZlcl9yZHlfdW5rbm93bl9lcnI7CS8qICB1bmtub3duIGVycm9yIGluIHhmZXJfcmR5IGZyYW1lICovCisKKwl1MzIJaW9fYWJvcnRfdGltZW91dDsJLyogIEFCVFMgdGltZWRvdXQgICovCisJdTMyCXNsZXJfaW5pdGlhdGVkOwkJLyogIFNMRVIgaW5pdGlhdGVkICovCisKKwl1MzIJdW5leHBfZmNwX3JzcDsJCS8qICBmY3AgcmVzcG9uc2UgaW4gd3Jvbmcgc3RhdGUgKi8KKworCXUzMglmY3BfcnNwX3VuZGVyX3J1bjsJLyogIGZjcCByc3AgSU8gdW5kZXJydW4gKi8KKwl1MzIgICAgICAgIGZjcF9yc3BfdW5kZXJfcnVuX3dyOyAgIC8qICBmY3AgcnNwIElPIHVuZGVycnVuIGZvciB3cml0ZSAqLworCXUzMglmY3BfcnNwX3VuZGVyX3J1bl9lcnI7CS8qICBmY3AgcnNwIElPIHVuZGVycnVuIGVycm9yICovCisJdTMyICAgICAgICBmY3BfcnNwX3Jlc2lkX2ludmFsOyAgICAvKiAgaW52YWxpZCByZXNpZHVlICovCisJdTMyCWZjcF9yc3Bfb3Zlcl9ydW47CS8qICBmY3AgcnNwIElPIG92ZXJydW4gKi8KKwl1MzIJZmNwX3JzcF9vdmVyX3J1bl9lcnI7CS8qICBmY3AgcnNwIElPIG92ZXJydW4gZXJyb3IgKi8KKwl1MzIJZmNwX3JzcF9wcm90b19lcnI7CS8qICBwcm90b2NvbCBlcnJvciBpbiBmY3AgcnNwICovCisJdTMyCWZjcF9yc3Bfc2Vuc2VfZXJyOwkvKiAgZXJyb3IgaW4gc2Vuc2UgaW5mbyBpbiBmY3AgcnNwICovCisJdTMyCWZjcF9jb25mX3JlcTsJCS8qICBGQ1AgY29uZiByZXF1ZXN0ZWQgKi8KKworCXUzMgl0Z3RfYWJvcnRlZF9pbzsJCS8qICB0YXJnZXQgaW5pdGlhdGVkIGFib3J0ICovCisKKwl1MzIJaW9oX2VkdG92X3RpbWVvdXRfZXZlbnQ7LyogIElPSCBlZHRvdiB0aW1lciBwb3BwZWQgKi8KKwl1MzIJaW9oX2ZjcF9yc3BfZXhjcF9ldmVudDsJLyogIElPSCBGQ1BfUlNQIGV4Y2VwdGlvbiAqLworCXUzMglpb2hfZmNwX2NvbmZfZXZlbnQ7CS8qICBJT0ggRkNQX0NPTkYgKi8KKwl1MzIJaW9oX211bHRfZnJtX3JzcF9ldmVudDsJLyogIElPSCBtdWx0aV9mcmFtZSBGQ1BfUlNQICovCisJdTMyCWlvaF9oaXRfY2xhc3MyX2V2ZW50OwkvKiAgSU9IIGhpdCBjbGFzczIgKi8KKwl1MzIJaW9oX21pc3Nfb3RoZXJfZXZlbnQ7CS8qICBJT0ggbWlzcyBvdGhlciAqLworCXUzMglpb2hfc2VxX2NudF9lcnJfZXZlbnQ7CS8qICBJT0ggc2VxIGNudCBlcnJvciAqLworCXUzMglpb2hfbGVuX2Vycl9ldmVudDsJCS8qICBJT0ggbGVuIGVycm9yIC0gZmNwX2RsICE9CisJCQkJCQkJKiBieXRlcyB4ZmVyZWQgKi8KKwl1MzIJaW9oX3NlcV9sZW5fZXJyX2V2ZW50OwkvKiAgSU9IIHNlcSBsZW4gZXJyb3IgKi8KKwl1MzIJaW9oX2RhdGFfb29yX2V2ZW50OwkvKiAgRGF0YSBvdXQgb2YgcmFuZ2UgKi8KKwl1MzIJaW9oX3JvX29vb19ldmVudDsJLyogIFJlbGF0aXZlIG9mZnNldCBvdXQgb2YgcmFuZ2UgKi8KKwl1MzIJaW9oX2NwdV9vd25lZF9ldmVudDsJLyogIElPSCBoaXQgLWlvc3Qgb3duZWQgYnkgZi93ICovCisJdTMyCWlvaF91bmV4cF9mcmFtZV9ldmVudDsJLyogIHVuZXhwZWN0ZWQgZnJhbWUgcmVjaWV2ZWQKKwkJCQkJCSAqICAgY291bnQgKi8KKwl1MzIJaW9oX2Vycl9pbnQ7CQkvKiAgSU9IIGVycm9yIGludCBkdXJpbmcgZGF0YS1waGFzZQorCQkJCQkJICogICBmb3Igc2NzaSB3cml0ZQorCQkJCQkJICovCit9OworCisvKioKKyAqIElPQyBwb3J0IGZpcm13YXJlIHN0YXRzCisgKi8KKworc3RydWN0IGJmYV9md19wb3J0X2ZwZ19zdGF0c19zIHsKKyAgICB1MzIgICAgaW50cl9ldnQ7CisgICAgdTMyICAgIGludHI7CisgICAgdTMyICAgIGludHJfZXhjZXNzOworICAgIHUzMiAgICBpbnRyX2NhdXNlMDsKKyAgICB1MzIgICAgaW50cl9vdGhlcjsKKyAgICB1MzIgICAgaW50cl9vdGhlcl9pZ247CisgICAgdTMyICAgIHNpZ19sb3N0OworICAgIHUzMiAgICBzaWdfcmVnYWluZWQ7CisgICAgdTMyICAgIHN5bmNfbG9zdDsKKyAgICB1MzIgICAgc3luY190bzsKKyAgICB1MzIgICAgc3luY19yZWdhaW5lZDsKKyAgICB1MzIgICAgZGl2Ml9vdmVyZmxvdzsKKyAgICB1MzIgICAgZGl2Ml91bmRlcmZsb3c7CisgICAgdTMyICAgIGVmaWZvX292ZXJmbG93OworICAgIHUzMiAgICBlZmlmb191bmRlcmZsb3c7CisgICAgdTMyICAgIGlkbGVfcng7CisgICAgdTMyICAgIGxycl9yeDsKKyAgICB1MzIgICAgbHJfcng7CisgICAgdTMyICAgIG9sc19yeDsKKyAgICB1MzIgICAgbm9zX3J4OworICAgIHUzMiAgICBsaXBfcng7CisgICAgdTMyICAgIGFyYmYwX3J4OworICAgIHUzMiAgICBtcmtfcng7CisgICAgdTMyICAgIGNvbnN0X21ya19yeDsKKyAgICB1MzIgICAgcHJpbV91bmtub3duOworICAgIHUzMiAgICByc3ZkOworfTsKKworCitzdHJ1Y3QgYmZhX2Z3X3BvcnRfbGtzbV9zdGF0c19zIHsKKyAgICB1MzIgICAgaHdzbV9zdWNjZXNzOyAgICAgICAvKiAgaHdzbSBzdGF0ZSBtYWNoaW5lIHN1Y2Nlc3MgICAgICAgICAgKi8KKyAgICB1MzIgICAgaHdzbV9mYWlsczsgICAgICAgICAvKiAgaHdzbSBmYWlscyAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgaHdzbV93ZHRvdjsgICAgICAgICAvKiAgaHdzbSB0aW1lZCBvdXQgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgc3dzbV9zdWNjZXNzOyAgICAgICAvKiAgc3dzbSBzdWNjZXNzICAgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgc3dzbV9mYWlsczsgICAgICAgICAvKiAgc3dzbSBmYWlscyAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgc3dzbV93ZHRvdjsgICAgICAgICAvKiAgc3dzbSB0aW1lZCBvdXQgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgYnVzeWJ1ZnM7ICAgICAgICAgICAvKiAgbGluayBpbml0IGZhaWxlZCBkdWUgdG8gYnVzeWJ1ZiAgICAgKi8KKyAgICB1MzIgICAgYnVmX3dhaXRzOyAgICAgICAgICAvKiAgYnVmd2FpdCBzdGF0ZSBlbnRyaWVzICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgbGlua19mYWlsczsgICAgICAgICAvKiAgbGluayBmYWlsdXJlcyAgICAgICAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgcHNwX2Vycm9yczsgICAgICAgICAvKiAgcHJpbWl0aXZlIHNlcXVlbmNlIHByb3RvY29sIGVycm9ycyAgKi8KKyAgICB1MzIgICAgbHJfdW5leHA7ICAgICAgICAgICAvKiAgTm8uIG9mIHRpbWVzIExSIHJ4LWVkIHVuZXhwZWN0ZWRseSAgKi8KKyAgICB1MzIgICAgbHJyX3VuZXhwOyAgICAgICAgICAvKiAgTm8uIG9mIHRpbWVzIExSUiByeC1lZCB1bmV4cGVjdGVkbHkgKi8KKyAgICB1MzIgICAgbHJfdHg7ICAgICAgICAgICAgICAvKiAgTm8uIG9mIHRpbWVzIExSIHR4IHN0YXJ0ZWQgICAgICAgICAgKi8KKyAgICB1MzIgICAgbHJyX3R4OyAgICAgICAgICAgICAvKiAgTm8uIG9mIHRpbWVzIExSUiB0eCBzdGFydGVkICAgICAgICAgKi8KKyAgICB1MzIgICAgb2xzX3R4OyAgICAgICAgICAgICAvKiAgTm8uIG9mIHRpbWVzIE9MUyB0eCBzdGFydGVkICAgICAgICAgKi8KKyAgICB1MzIgICAgbm9zX3R4OyAgICAgICAgICAgICAvKiAgTm8uIG9mIHRpbWVzIE5PUyB0eCBzdGFydGVkICAgICAgICAgKi8KK307CisKKworc3RydWN0IGJmYV9md19wb3J0X3Nuc21fc3RhdHNfcyB7CisgICAgdTMyICAgIGh3c21fc3VjY2VzczsgICAgICAgLyogIFN1Y2Nlc3NmdWwgaHdzbSB0ZXJtaW5hdGlvbnMgICAgICAgICovCisgICAgdTMyICAgIGh3c21fZmFpbHM7ICAgICAgICAgLyogIGh3c20gZmFpbCBjb3VudCAgICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGh3c21fd2R0b3Y7ICAgICAgICAgLyogIGh3c20gdGltZWQgb3V0ICAgICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIHN3c21fc3VjY2VzczsgICAgICAgLyogIHN3c20gc3VjY2VzcyAgICAgICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIHN3c21fd2R0b3Y7ICAgICAgICAgLyogIHN3c20gdGltZWQgb3V0ICAgICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGVycm9yX3Jlc2V0czsgICAgICAgLyogIGVycm9yIHJlc2V0cyBpbml0aWF0ZWQgYnkgdXBzbSAgICAgICovCisgICAgdTMyICAgIHN5bmNfbG9zdDsgICAgICAgICAgLyogIFN5bmMgbG9zcyBjb3VudCAgICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIHNpZ19sb3N0OyAgICAgICAgICAgLyogIFNpZ25hbCBsb3NzIGNvdW50ICAgICAgICAgICAgICAgICAgICovCit9OworCisKK3N0cnVjdCBiZmFfZndfcG9ydF9waHlzbV9zdGF0c19zIHsKKyAgICB1MzIgICAgbW9kdWxlX2luc2VydHM7ICAgICAvKiAgTW9kdWxlIGluc2VydCBjb3VudCAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgbW9kdWxlX3h0cmFjdHM7ICAgICAvKiAgTW9kdWxlIGV4dHJhY3RzIGNvdW50ICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgbW9kdWxlX2ludmFsaWRzOyAgICAvKiAgSW52YWxpZCBtb2R1bGUgaW5zZXJ0ZWQgY291bnQgICAgICAgKi8KKyAgICB1MzIgICAgbW9kdWxlX3JlYWRfaWduOyAgICAvKiAgTW9kdWxlIHZhbGlkYXRpb24gc3RhdHVzIGlnbm9yZWQgICAgKi8KKyAgICB1MzIgICAgbGFzZXJfZmF1bHRzOyAgICAgICAvKiAgTGFzZXIgZmF1bHQgY291bnQgICAgICAgICAgICAgICAgICAgKi8KKyAgICB1MzIgICAgcnN2ZDsKK307CisKKworc3RydWN0IGJmYV9md19maXBfc3RhdHNfcyB7CisgICAgdTMyICAgIGRpc2NfcmVxOyAgICAgICAgICAgLyogIERpc2NvdmVyeSBzb2xpY2l0IHJlcXVlc3RzICAgICAgICAgICovCisgICAgdTMyICAgIGRpc2NfcnNwOyAgICAgICAgICAgLyogIERpc2NvdmVyeSBzb2xpY2l0IHJlc3BvbnNlICAgICAgICAgICovCisgICAgdTMyICAgIGRpc2NfZXJyOyAgICAgICAgICAgLyogIERpc2NvdmVyeSBhZHZ0LiBwYXJzZSBlcnJvcnMgICAgICAgICovCisgICAgdTMyICAgIGRpc2NfdW5zb2w7ICAgICAgICAgLyogIERpc2NvdmVyeSB1bnNvbGljaXRlZCAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGRpc2NfdGltZW91dHM7ICAgICAgLyogIERpc2NvdmVyeSB0aW1lb3V0cyAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGxpbmtzdmNfdW5zdXBwOyAgICAgLyogIFVuc3VwcG9ydGVkIGxpbmsgc2VydmljZSByZXEgICAgICAgICovCisgICAgdTMyICAgIGxpbmtzdmNfZXJyOyAgICAgICAgLyogIFBhcnNlIGVycm9yIGluIGxpbmsgc2VydmljZSByZXEgICAgICovCisgICAgdTMyICAgIGxvZ29fcmVxOyAgICAgICAgICAgLyogIE51bWJlciBvZiBGSVAgbG9nb3MgcmVjZWl2ZWQgICAgICAgICovCisgICAgdTMyICAgIGNscnZsaW5rX3JlcTsgICAgICAgLyogIENsZWFyIHZpcnR1YWwgbGluayByZXEgICAgICAgICAgICAgICovCisgICAgdTMyICAgIG9wX3Vuc3VwcDsgICAgICAgICAgLyogIFVuc3VwcG9ydGVkIEZJUCBvcGVyYXRpb24gICAgICAgICAgICovCisgICAgdTMyICAgIHVudGFnZ2VkOyAgICAgICAgICAgLyogIFVudGFnZ2VkIGZyYW1lcyAoaWdub3JlZCkgICAgICAgICAgICovCisgICAgdTMyICAgIHJzdmQ7Cit9OworCisKK3N0cnVjdCBiZmFfZndfbHBzX3N0YXRzX3MgeworICAgIHUzMiAgICBtYWNfaW52YWxpZHM7ICAgICAgIC8qICBJbnZhbGlkIG1hYyBhc3NpZ25lZCAgICAgICAgICAgICAgICAqLworICAgIHUzMiAgICByc3ZkOworfTsKKworCitzdHJ1Y3QgYmZhX2Z3X2Zjb2Vfc3RhdHNfcyB7CisgICAgdTMyICAgIGNlZV9saW5rdXBzOyAgICAgICAgLyogIENFRSBsaW5rIHVwIGNvdW50ICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGNlZV9saW5rZG5zOyAgICAgICAgLyogIENFRSBsaW5rIGRvd24gY291bnQgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGZpcF9saW5rdXBzOyAgICAgICAgLyogIEZJUCBsaW5rIHVwIGNvdW50ICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGZpcF9saW5rZG5zOyAgICAgICAgLyogIEZJUCBsaW5rIHVwIGNvdW50ICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIGZpcF9mYWlsczsgICAgICAgICAgLyogIEZJUCBmYWlsIGNvdW50ICAgICAgICAgICAgICAgICAgICAgICovCisgICAgdTMyICAgIG1hY19pbnZhbGlkczsgICAgICAgLyogIEludmFsaWQgbWFjIGFzc2lnbmVkICAgICAgICAgICAgICAgICovCit9OworCisvKioKKyAqIElPQyBmaXJtd2FyZSBGQ29FIHBvcnQgc3RhdHMKKyAqLworc3RydWN0IGJmYV9md19mY29lX3BvcnRfc3RhdHNfcyB7CisgICAgc3RydWN0IGJmYV9md19mY29lX3N0YXRzX3MgIGZjb2Vfc3RhdHM7CisgICAgc3RydWN0IGJmYV9md19maXBfc3RhdHNfcyAgIGZpcF9zdGF0czsKK307CisKKy8qKgorICogSU9DIGZpcm13YXJlIEZDIHBvcnQgc3RhdHMKKyAqLworc3RydWN0IGJmYV9md19mY19wb3J0X3N0YXRzX3MgeworCXN0cnVjdCBiZmFfZndfcG9ydF9mcGdfc3RhdHNfcwkJZnBnX3N0YXRzOworCXN0cnVjdCBiZmFfZndfcG9ydF9waHlzbV9zdGF0c19zCXBoeXNtX3N0YXRzOworCXN0cnVjdCBiZmFfZndfcG9ydF9zbnNtX3N0YXRzX3MJCXNuc21fc3RhdHM7CisJc3RydWN0IGJmYV9md19wb3J0X2xrc21fc3RhdHNfcwkJbGtzbV9zdGF0czsKK307CisKKy8qKgorICogSU9DIGZpcm13YXJlIEZDIHBvcnQgc3RhdHMKKyAqLwordW5pb24gYmZhX2Z3X3BvcnRfc3RhdHNfcyB7CisJc3RydWN0IGJmYV9md19mY19wb3J0X3N0YXRzX3MJZmNfc3RhdHM7CisJc3RydWN0IGJmYV9md19mY29lX3BvcnRfc3RhdHNfcwlmY29lX3N0YXRzOworfTsKKworLyoqCisgKiBJT0MgZmlybXdhcmUgc3RhdHMKKyAqLworc3RydWN0IGJmYV9md19zdGF0c19zIHsKKwlzdHJ1Y3QgYmZhX2Z3X2lvY19zdGF0c19zCWlvY19zdGF0czsKKwlzdHJ1Y3QgYmZhX2Z3X2lvX3N0YXRzX3MJaW9fc3RhdHM7CisJdW5pb24gIGJmYV9md19wb3J0X3N0YXRzX3MJcG9ydF9zdGF0czsKK307CisKKy8qKgorICogSU9DIHN0YXRpc3RpY3MKKyAqLworc3RydWN0IGJmYV9pb2NmY19zdGF0c19zIHsKKwlzdHJ1Y3QgYmZhX2Z3X3N0YXRzX3MgCWZ3X3N0YXRzOwkvKiAgZmlybXdhcmUgSU9DIHN0YXRzICAgICAgKi8KK307CisKKy8qKgorICogSU9DIGF0dHJpYnV0ZXMgcmV0dXJuZWQgaW4gcXVlcmllcworICovCitzdHJ1Y3QgYmZhX2lvY2ZjX2F0dHJfcyB7CisJc3RydWN0IGJmYV9pb2NmY19jZmdfcwkJY29uZmlnOwkJLyogIElPQ0ZDIGNvbmZpZyAgICovCisJc3RydWN0IGJmYV9pb2NmY19pbnRyX2F0dHJfcwlpbnRyX2F0dHI7CS8qICBpbnRlcnJ1cHQgYXR0ciAqLworfTsKKworI2RlZmluZSBCRkFfSU9DRkNfUEFUSFRPVl9NQVgJNjAKKyNkZWZpbmUgQkZBX0lPQ0ZDX1FERVBUSF9NQVgJMjAwMAorCisjZW5kaWYgLyogX19CRkFfREVGU19JT0NfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19pcGZjLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19pcGZjLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uN2NiNjNlYQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2lwZmMuaApAQCAtMCwwICsxLDcwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0RFRlNfSVBGQ19IX18KKyNkZWZpbmUgX19CRkFfREVGU19JUEZDX0hfXworCisjaW5jbHVkZSA8YmZhX29zX2luYy5oPgorI2luY2x1ZGUgPHByb3RvY29sL3R5cGVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc190eXBlcy5oPgorCisvKioKKyAqIEZDUyBpcCByZW1vdGUgcG9ydCBzdGF0ZXMKKyAqLworZW51bSBiZmFfaXBycF9zdGF0ZSB7CisJQkZBX0lQUlBfVU5JTklUICA9IDAsCS8qICBQT1JUIGlzIG5vdCB5ZXQgaW5pdGlhbGl6ZWQgKi8KKwlCRkFfSVBSUF9PTkxJTkUgID0gMSwJLyogIHByb2Nlc3MgbG9naW4gaXMgY29tcGxldGUgKi8KKwlCRkFfSVBSUF9PRkZMSU5FID0gMiwJLyogIGlwcnAgaXMgb2ZmbGluZSAqLworfTsKKworLyoqCisgKiBGQ1MgcmVtb3RlIHBvcnQgc3RhdGlzdGljcworICovCitzdHJ1Y3QgYmZhX2lwcnBfc3RhdHNfcyB7CisJdTMyICAgICAgICBvZmZsaW5lczsKKwl1MzIgICAgICAgIG9ubGluZXM7CisJdTMyICAgICAgICByc2NuczsKKwl1MzIgICAgICAgIHBsb2dpczsKKwl1MzIgICAgICAgIGxvZ29zOworCXUzMiAgICAgICAgcGxvZ2lfdGltZW91dHM7CisJdTMyICAgICAgICBwbG9naV9yZWplY3RzOworfTsKKworLyoqCisgKiBGQ1MgaXBycCBhdHRyaWJ1dGUgcmV0dXJuZWQgaW4gcXVlcmllcworICovCitzdHJ1Y3QgYmZhX2lwcnBfYXR0cl9zIHsKKwllbnVtIGJmYV9pcHJwX3N0YXRlIHN0YXRlOworfTsKKworc3RydWN0IGJmYV9pcGZjX3N0YXRzX3MgeworCXUzMiBhcnBfc2VudDsKKwl1MzIgYXJwX3JlY3Y7CisJdTMyIGFycF9yZXBseV9zZW50OworCXUzMiBhcnBfcmVwbHlfcmVjdjsKKwl1MzIgZmFycF9zZW50OworCXUzMiBmYXJwX3JlY3Y7CisJdTMyIGZhcnBfcmVwbHlfc2VudDsKKwl1MzIgZmFycF9yZXBseV9yZWN2OworCXUzMiBmYXJwX3JlamVjdF9zZW50OworCXUzMiBmYXJwX3JlamVjdF9yZWN2OworfTsKKworc3RydWN0IGJmYV9pcGZjX2F0dHJfcyB7CisJYmZhX2Jvb2xlYW5fdCBlbmFibGVkOworfTsKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfSVBGQ19IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2l0bmltLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19pdG5pbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjJlYzc2OTkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19pdG5pbS5oCkBAIC0wLDAgKzEsMTI2IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0RFRlNfSVROSU1fSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfSVROSU1fSF9fCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvdHlwZXMuaD4KKworLyoqCisgKiBGQ1MgaXRuaW0gc3RhdGVzCisgKi8KK2VudW0gYmZhX2l0bmltX3N0YXRlIHsKKwlCRkFfSVROSU1fT0ZGTElORSAJPSAwLAkvKiAgb2ZmbGluZSAqLworCUJGQV9JVE5JTV9QUkxJX1NFTkQgCT0gMSwJLyogIHBybGkgc2VuZCAqLworCUJGQV9JVE5JTV9QUkxJX1NFTlQgCT0gMiwJLyogIHBybGkgc2VudCAqLworCUJGQV9JVE5JTV9QUkxJX1JFVFJZIAk9IDMsCS8qICBwcmxpIHJldHJ5ICovCisJQkZBX0lUTklNX0hDQl9PTkxJTkUgCT0gNCwJLyogIG9ubGluZSBjYWxsYmFjayAqLworCUJGQV9JVE5JTV9PTkxJTkUgCT0gNSwJLyogIG9ubGluZSAqLworCUJGQV9JVE5JTV9IQ0JfT0ZGTElORSAJPSA2LAkvKiAgb2ZmbGluZSBjYWxsYmFjayAqLworCUJGQV9JVE5JTV9JTklUSUFUSU9SIAk9IDcsCS8qICBpbml0aWF0b3IgKi8KK307CisKK3N0cnVjdCBiZmFfaXRuaW1faGFsX3N0YXRzX3MgeworCXUzMglvbmxpbmVzOwkvKiAgSVROIG5leHVzIG9ubGluZXMgKFBSTEkgZG9uZSkgKi8KKwl1MzIJb2ZmbGluZXM7CS8qICBJVE4gTmV4dXMgb2ZmbGluZXMgCSovCisJdTMyCWNyZWF0ZXM7CS8qICBJVE4gY3JlYXRlIHJlcXVlc3RzIAkqLworCXUzMglkZWxldGVzOwkvKiAgSVROIGRlbGV0ZSByZXF1ZXN0cyAJKi8KKwl1MzIJY3JlYXRlX2NvbXBzOwkvKiAgSVROIGNyZWF0ZSBjb21wbGV0aW9ucyAJKi8KKwl1MzIJZGVsZXRlX2NvbXBzOwkvKiAgSVROIGRlbGV0ZSBjb21wbGV0aW9ucyAJKi8KKwl1MzIJc2xlcl9ldmVudHM7CS8qICBTTEVSIChzZXF1ZW5jZSBsZXZlbCBlcnJvcgorCQkJCQkgKiByZWNvdmVyeSkgZXZlbnRzICovCisJdTMyCWlvY19kaXNhYmxlZDsJLyogIE51bSBJT0MgZGlzYWJsZXMJCSovCisJdTMyCWNsZWFudXBfY29tcHM7CS8qICBJVE4gY2xlYW51cCBjb21wbGV0aW9ucyAqLworCXUzMgl0bV9jbW5kczsJLyogIHRhc2sgbWFuYWdlbWVudChUTSkgY21uZHMgc2VudCAqLworCXUzMgl0bV9md19yc3BzOwkvKiAgVE0gY21kcyBmaXJtd2FyZSByZXNwb25zZXMgKi8KKwl1MzIJdG1fc3VjY2VzczsJLyogIFRNIHN1Y2Nlc3NlcyAqLworCXUzMgl0bV9mYWlsdXJlczsJLyogIFRNIGZhaWx1cmVzICovCisJdTMyCXRtX2lvX2NvbXBzOwkvKiAgVE0gSU8gY29tcGxldGlvbnMgKi8KKwl1MzIJdG1fcXJlc3VtZXM7CS8qICBUTSBxdWV1ZSByZXN1bWVzIChhZnRlciB3YWl0aW5nCisJCQkJCSAqIGZvciByZXNvdXJjZXMpCisJCQkJCSAqLworCXUzMgl0bV9pb2Nkb3duczsJLyogIFRNIGNtbmRzIGFmZmVjdGVkIGJ5IElPQyBkb3duICovCisJdTMyCXRtX2NsZWFudXBzOwkvKiAgVE0gY2xlYW51cHMgKi8KKwl1MzIJdG1fY2xlYW51cF9jb21wczsKKwkJCQkJLyogIFRNIGNsZWFudXAgY29tcGxldGlvbnMgKi8KKwl1MzIJaW9zOwkJLyogIElPIHJlcXVlc3RzICovCisJdTMyCWlvX2NvbXBzOwkvKiAgSU8gY29tcGxldGlvbnMgKi8KKwl1NjQJaW5wdXRfcmVxczsJLyogIElOUFVUIHJlcXVlc3RzICovCisJdTY0CW91dHB1dF9yZXFzOwkvKiAgT1VUUFVUIHJlcXVlc3RzICovCit9OworCisvKioKKyAqIEZDUyByZW1vdGUgcG9ydCBzdGF0aXN0aWNzCisgKi8KK3N0cnVjdCBiZmFfaXRuaW1fc3RhdHNfcyB7CisJdTMyICAgICAgICBvbmxpbmVzOwkvKiAgbnVtIHJwb3J0IG9ubGluZSAqLworCXUzMiAgICAgICAgb2ZmbGluZXM7CS8qICBudW0gcnBvcnQgb2ZmbGluZSAqLworCXUzMiAgICAgICAgcHJsaV9zZW50OwkvKiAgbnVtIHBybGkgc2VudCBvdXQgKi8KKwl1MzIgICAgICAgIGZjeHBfYWxsb2Nfd2FpdDsvKiAgbnVtIGZjeHAgYWxsb2Mgd2FpdHMgKi8KKwl1MzIgICAgICAgIHBybGlfcnNwX2VycjsJLyogIG51bSBwcmxpIHJzcCBlcnJvcnMgKi8KKwl1MzIgICAgICAgIHBybGlfcnNwX2FjYzsJLyogIG51bSBwcmxpIHJzcCBhY2NlcHRzICovCisJdTMyICAgICAgICBpbml0aWF0b3I7CS8qICBycG9ydCBpcyBhbiBpbml0aWF0b3IgKi8KKwl1MzIgICAgICAgIHBybGlfcnNwX3BhcnNlX2VycjsJLyogIHBybGkgcnNwIHBhcnNpbmcgZXJyb3JzICovCisJdTMyICAgICAgICBwcmxpX3JzcF9yanQ7CS8qICBudW0gcHJsaSByc3AgcmVqZWN0cyAqLworCXUzMiAgICAgICAgdGltZW91dDsJLyogIG51bSB0aW1lb3V0cyBkZXRlY3RlZCAqLworCXUzMiAgICAgICAgc2xlcjsJCS8qICBudW0gc2xlciBub3RpZmljYXRpb24gZnJvbSBCRkEgKi8KKwl1MzIJcnN2ZDsKKwlzdHJ1Y3QgYmZhX2l0bmltX2hhbF9zdGF0c19zCWhhbF9zdGF0czsKK307CisKKy8qKgorICogRkNTIGl0bmltIGF0dHJpYnV0ZXMgcmV0dXJuZWQgaW4gcXVlcmllcworICovCitzdHJ1Y3QgYmZhX2l0bmltX2F0dHJfcyB7CisJZW51bSBiZmFfaXRuaW1fc3RhdGUgc3RhdGU7IC8qICBGQ1MgaXRuaW0gc3RhdGUgICAgICAgICovCisJdTggcmV0cnk7CQkvKiAgZGF0YSByZXRyYW5zbWlzaW9uIHN1cHBvcnQgKi8KKwl1OAl0YXNrX3JldHJ5X2lkOyAgLyogIHRhc2sgcmV0cnkgaWRlbnQgc3VwcG9ydCAgICovCisJdTggcmVjX3N1cHBvcnQ7ICAgIC8qICBSRUMgc3VwcG9ydGVkICAgICAgICAgICAgICAqLworCXU4IGNvbmZfY29tcDsgICAgICAvKiAgY29uZmlybWVkIGNvbXBsZXRpb24gc3VwcCAgKi8KK307CisKKy8qKgorICogQkZBIElUTklNIGV2ZW50cy4KKyAqIEFyZ3VtZW50cyBiZWxvdyBhcmUgaW4gQkZBTCBjb250ZXh0IGZyb20gTWdtdAorICogQkZBX0lUTklNX0FFTl9ORVc6ICAgICAgIFtpbl06IE5vbmUgIFtvdXRdOiB2Zl9pZCwgbHB3d24KKyAqIEJGQV9JVE5JTV9BRU5fREVMRVRFOiAgICBbaW5dOiB2Zl9pZCwgbHB3d24sIHJwd3duICgwID0gYWxsIGZjcDQgdGFyZ2V0cyksCisgKgkJCQkgIFtvdXRdOiB2Zl9pZCwgcHB3d24sIGxwd3duLCBycHd3bgorICogQkZBX0lUTklNX0FFTl9PTkxJTkU6ICAgIFtpbl06IHZmX2lkLCBscHd3biwgcnB3d24gKDAgPSBhbGwgZmNwNCB0YXJnZXRzKSwKKyAqCQkJCSAgW291dF06IHZmX2lkLCBwcHd3biwgbHB3d24sIHJwd3duCisgKiBCRkFfSVROSU1fQUVOX09GRkxJTkU6ICAgW2luXTogdmZfaWQsIGxwd3duLCBycHd3biAoMCA9IGFsbCBmY3A0IHRhcmdldHMpLAorICoJCQkJICBbb3V0XTogdmZfaWQsIHBwd3duLCBscHd3biwgcnB3d24KKyAqIEJGQV9JVE5JTV9BRU5fRElTQ09OTkVDVDpbaW5dOiB2Zl9pZCwgbHB3d24sIHJwd3duICgwID0gYWxsIGZjcDQgdGFyZ2V0cyksCisgKgkJCQkgIFtvdXRdOiB2Zl9pZCwgcHB3d24sIGxwd3duLCBycHd3bgorICovCitlbnVtIGJmYV9pdG5pbV9hZW5fZXZlbnQgeworCUJGQV9JVE5JTV9BRU5fT05MSU5FIAk9IDEsCS8qICBUYXJnZXQgb25saW5lICovCisJQkZBX0lUTklNX0FFTl9PRkZMSU5FIAk9IDIsCS8qICBUYXJnZXQgb2ZmbGluZSAqLworCUJGQV9JVE5JTV9BRU5fRElTQ09OTkVDVCA9IDMsCS8qICBUYXJnZXQgZGlzY29ubmVjdGVkICovCit9OworCisvKioKKyAqIEJGQSBJVE5JTSBldmVudCBkYXRhIHN0cnVjdHVyZS4KKyAqLworc3RydWN0IGJmYV9pdG5pbV9hZW5fZGF0YV9zIHsKKwl1MTYgICAgICAgIHZmX2lkOwkvKiAgdmZfaWQgb2YgdGhlIElUIG5leHVzICovCisJdTE2ICAgICAgICByc3ZkWzNdOworCXd3bl90ICAgICAgICAgICBwcHd3bjsJLyogIFdXTiBvZiBpdHMgcGh5c2ljYWwgcG9ydCAqLworCXd3bl90ICAgICAgICAgICBscHd3bjsJLyogIFdXTiBvZiBsb2dpY2FsIHBvcnQgKi8KKwl3d25fdCAgICAgICAgICAgcnB3d247CS8qICBXV04gb2YgcmVtb3RlKHRhcmdldCkgcG9ydCAqLworfTsKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfSVROSU1fSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19sZWQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2xlZC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjYyMDM5MjcKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19sZWQuaApAQCAtMCwwICsxLDM1IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfREVGU19MRURfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfTEVEX0hfXworCisjZGVmaW5lCUJGQV9MRURfTUFYX05VTQkJMworCitlbnVtIGJmYV9sZWRfb3AgeworCUJGQV9MRURfT0ZGICAgPSAwLAorCUJGQV9MRURfT04gICAgPSAxLAorCUJGQV9MRURfRkxJQ0sgPSAyLAorCUJGQV9MRURfQkxJTksgPSAzLAorfTsKKworZW51bSBiZmFfbGVkX2NvbG9yIHsKKwlCRkFfTEVEX0dSRUVOID0gMCwKKwlCRkFfTEVEX0FNQkVSID0gMSwKK307CisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX0xFRF9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX2xwb3J0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19scG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjczNTlmODIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19scG9ydC5oCkBAIC0wLDAgKzEsNjggQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9ERUZTX0xQT1JUX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX0xQT1JUX0hfXworCisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc190eXBlcy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcG9ydC5oPgorCisvKioKKyAqIEJGQSBBRU4gbG9naWNhbCBwb3J0IGV2ZW50cy4KKyAqIEFyZ3VtZW50cyBiZWxvdyBhcmUgaW4gQkZBTCBjb250ZXh0IGZyb20gTWdtdAorICogQkZBX0xQT1JUX0FFTl9ORVc6ICAgICAgIFtpbl06IE5vbmUgICAgICAgICBbb3V0XTogdmZfaWQsIHBwd3duLCBscHd3biwgcm9sZXMKKyAqIEJGQV9MUE9SVF9BRU5fREVMRVRFOiAgICBbaW5dOiBscHd3biAgICAgICAgW291dF06IHZmX2lkLCBwcHd3bi4gbHB3d24sIHJvbGVzCisgKiBCRkFfTFBPUlRfQUVOX09OTElORTogICAgW2luXTogbHB3d24gICAgICAgIFtvdXRdOiB2Zl9pZCwgcHB3d24uIGxwd3duLCByb2xlcworICogQkZBX0xQT1JUX0FFTl9PRkZMSU5FOiAgIFtpbl06IGxwd3duICAgICAgICBbb3V0XTogdmZfaWQsIHBwd3duLiBscHd3biwgcm9sZXMKKyAqIEJGQV9MUE9SVF9BRU5fRElTQ09OTkVDVDpbaW5dOiBscHd3biAgICAgICAgW291dF06IHZmX2lkLCBwcHd3bi4gbHB3d24sIHJvbGVzCisgKiBCRkFfTFBPUlRfQUVOX05FV19QUk9QOiAgW2luXTogTm9uZSAgICAgICAgIFtvdXRdOiB2Zl9pZCwgcHB3d24uIGxwd3duLCByb2xlcworICogQkZBX0xQT1JUX0FFTl9ERUxFVEVfUFJPUDogICAgIFtpbl06IGxwd3duICBbb3V0XTogdmZfaWQsIHBwd3duLiBscHd3biwgcm9sZXMKKyAqIEJGQV9MUE9SVF9BRU5fTkVXX1NUQU5EQVJEOiAgICBbaW5dOiBOb25lICAgW291dF06IHZmX2lkLCBwcHd3bi4gbHB3d24sIHJvbGVzCisgKiBCRkFfTFBPUlRfQUVOX0RFTEVURV9TVEFOREFSRDogW2luXTogbHB3d24gIFtvdXRdOiB2Zl9pZCwgcHB3d24uIGxwd3duLCByb2xlcworICogQkZBX0xQT1JUX0FFTl9OUElWX0RVUF9XV046ICAgIFtpbl06IGxwd3duICBbb3V0XTogdmZfaWQsIHBwd3duLiBscHd3biwgcm9sZXMKKyAqIEJGQV9MUE9SVF9BRU5fTlBJVl9GQUJSSUNfTUFYOiBbaW5dOiBscHd3biAgW291dF06IHZmX2lkLCBwcHd3bi4gbHB3d24sIHJvbGVzCisgKiBCRkFfTFBPUlRfQUVOX05QSVZfVU5LTk9XTjogICAgW2luXTogbHB3d24gIFtvdXRdOiB2Zl9pZCwgcHB3d24uIGxwd3duLCByb2xlcworICovCitlbnVtIGJmYV9scG9ydF9hZW5fZXZlbnQgeworCUJGQV9MUE9SVF9BRU5fTkVXCT0gMSwJLyogIExQb3J0IGNyZWF0ZWQgZXZlbnQgKi8KKwlCRkFfTFBPUlRfQUVOX0RFTEVURQk9IDIsCS8qICBMUG9ydCBkZWxldGVkIGV2ZW50ICovCisJQkZBX0xQT1JUX0FFTl9PTkxJTkUJPSAzLAkvKiAgTFBvcnQgb25saW5lIGV2ZW50ICovCisJQkZBX0xQT1JUX0FFTl9PRkZMSU5FCT0gNCwJLyogIExQb3J0IG9mZmxpbmUgZXZlbnQgKi8KKwlCRkFfTFBPUlRfQUVOX0RJU0NPTk5FQ1QgPSA1LAkvKiAgTFBvcnQgZGlzY29ubmVjdCBldmVudCAqLworCUJGQV9MUE9SVF9BRU5fTkVXX1BST1AJPSA2LAkvKiAgVlBvcnQgY3JlYXRlZCBldmVudCAqLworCUJGQV9MUE9SVF9BRU5fREVMRVRFX1BST1AgPSA3LAkvKiAgVlBvcnQgZGVsZXRlZCBldmVudCAqLworCUJGQV9MUE9SVF9BRU5fTkVXX1NUQU5EQVJEID0gOCwJLyogIFZQb3J0IGNyZWF0ZWQgZXZlbnQgKi8KKwlCRkFfTFBPUlRfQUVOX0RFTEVURV9TVEFOREFSRCA9IDksICAvKiAgVlBvcnQgZGVsZXRlZCBldmVudCAqLworCUJGQV9MUE9SVF9BRU5fTlBJVl9EVVBfV1dOID0gMTAsICAgIC8qICBWUG9ydCBjb25maWd1cmVkIHdpdGgKKwkJCQkJICAgICAqICAgZHVwbGljYXRlIFdXTiBldmVudAorCQkJCQkJICovCisJQkZBX0xQT1JUX0FFTl9OUElWX0ZBQlJJQ19NQVggPSAxMSwgLyogIE1heCBOUElWIGluIGZhYnJpYy9mcG9ydCAqLworCUJGQV9MUE9SVF9BRU5fTlBJVl9VTktOT1dOID0gMTIsIC8qICBVbmtub3duIE5QSVYgRXJyb3IgY29kZSBldmVudCAqLworfTsKKworLyoqCisgKiBCRkEgQUVOIGV2ZW50IGRhdGEgc3RydWN0dXJlCisgKi8KK3N0cnVjdCBiZmFfbHBvcnRfYWVuX2RhdGFfcyB7CisJdTE2ICAgICAgICB2Zl9pZDsJLyogIHZmX2lkIG9mIHRoaXMgbG9naWNhbCBwb3J0ICovCisJdTE2ICAgICAgICByc3ZkOworCWVudW0gYmZhX3BvcnRfcm9sZSByb2xlczsJLyogIExvZ2ljYWwgcG9ydCBtb2RlLElNL1RNL0lQIGV0YyAqLworCXd3bl90ICAgICAgICAgICBwcHd3bjsJLyogIFdXTiBvZiBpdHMgcGh5c2ljYWwgcG9ydCAqLworCXd3bl90ICAgICAgICAgICBscHd3bjsJLyogIFdXTiBvZiB0aGlzIGxvZ2ljYWwgcG9ydCAqLworfTsKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfTFBPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19tZmcuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX21mZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEzZmQ0YWIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19tZmcuaApAQCAtMCwwICsxLDU4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisjaWZuZGVmIF9fQkZBX0RFRlNfTUZHX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX01GR19IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKworLyoqCisgKiBNYW51ZmFjdHVyaW5nIGJsb2NrIHZlcnNpb24KKyAqLworI2RlZmluZSBCRkFfTUZHX1ZFUlNJT04JCQkJMQorCisvKioKKyAqIE1hbnVmYWN0dXJpbmcgYmxvY2sgZm9ybWF0CisgKi8KKyNkZWZpbmUgQkZBX01GR19TRVJJQUxOVU1fU0laRQkJCTExCisjZGVmaW5lIEJGQV9NRkdfUEFSVE5VTV9TSVpFCQkJMTQKKyNkZWZpbmUgQkZBX01GR19TVVBQTElFUl9JRF9TSVpFCQkxMAorI2RlZmluZSBCRkFfTUZHX1NVUFBMSUVSX1BBUlROVU1fU0laRQkyMAorI2RlZmluZSBCRkFfTUZHX1NVUFBMSUVSX1NFUklBTE5VTV9TSVpFCTIwCisjZGVmaW5lIEJGQV9NRkdfU1VQUExJRVJfUkVWSVNJT05fU0laRQk0CisjZGVmaW5lIFNUUlNaKF9uKQkoKChfbikgKyA0KSAmIH4zKQorCisvKioKKyAqIFZQRCBkYXRhIGxlbmd0aAorICovCisjZGVmaW5lIEJGQV9NRkdfVlBEX0xFTiAgICAgMjU2CisKKy8qKgorICogQWxsIG51bWVyaWNhbCBmaWVsZHMgYXJlIGluIGJpZy1lbmRpYW4gZm9ybWF0LgorICovCitzdHJ1Y3QgYmZhX21mZ192cGRfcyB7CisgICAgdTggICAgIHZlcnNpb247ICAgIC8qICB2cGQgZGF0YSB2ZXJzaW9uICovCisgICAgdTggICAgIHZwZF9zaWdbM107IC8qICBjaGFyYWN0ZXJzICdWJywgJ1AnLCAnRCcgKi8KKyAgICB1OCAgICAgY2hrc3VtOyAgICAgLyogIHU4IGNoZWNrc3VtICovCisgICAgdTggICAgIHZlbmRvcjsgICAgIC8qICB2ZW5kb3IgKi8KKyAgICB1OCAgICAgbGVuOyAgICAgICAgLyogIHZwZCBkYXRhIGxlbmd0aCBleGNsdWRpbmcgaGVhZGVyICovCisgICAgdTggICAgIHJzdjsKKyAgICB1OCAgICAgZGF0YVtCRkFfTUZHX1ZQRF9MRU5dOyAgLyogIHZwZCBkYXRhICovCit9OworCisjcHJhZ21hIHBhY2soMSkKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfTUZHX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcGNpLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19wY2kuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jOWI4MzMyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcGNpLmgKQEAgLTAsMCArMSw0MSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfUENJX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX1BDSV9IX18KKworLyoqCisgKiBQQ0kgZGV2aWNlIGFuZCB2ZW5kb3IgSUQgaW5mb3JtYXRpb24KKyAqLworZW51bSB7CisJQkZBX1BDSV9WRU5ET1JfSURfQlJPQ0FERQk9IDB4MTY1NywKKwlCRkFfUENJX0RFVklDRV9JRF9GQ184RzJQCT0gMHgxMywKKwlCRkFfUENJX0RFVklDRV9JRF9GQ184RzFQCT0gMHgxNywKKwlCRkFfUENJX0RFVklDRV9JRF9DVAkJPSAweDE0LAorfTsKKworLyoqCisgKiBQQ0kgc3ViLXN5c3RlbSBkZXZpY2UgYW5kIHZlbmRvciBJRCBpbmZvcm1hdGlvbgorICovCitlbnVtIHsKKwlCRkFfUENJX0ZDT0VfU1NERVZJQ0VfSUQJPSAweDE0LAorfTsKKworI2RlZmluZSBCRkFfUENJX0FDQ0VTU19SQU5HRVMgMQkvKiBNYXhpbXVtIG51bWJlciBvZiBkZXZpY2UgYWRkcmVzcyByYW5nZXMKKwkJCQkgKiBtYXBwZWQgdGhyb3VnaCBkaWZmZXJlbnQgQkFSKHMpLiAqLworCisjZW5kaWYgLyogX19CRkFfREVGU19QQ0lfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19wbS5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcG0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lOGQ2ZDk1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcG0uaApAQCAtMCwwICsxLDMzIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfREVGU19QTV9IX18KKyNkZWZpbmUgX19CRkFfREVGU19QTV9IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKworLyoqCisgKiBCRkEgcG93ZXIgbWFuYWdlbWVudCBkZXZpY2Ugc3RhdGVzCisgKi8KK2VudW0gYmZhX3BtX2RzIHsKKwlCRkFfUE1fRFNfRDAgPSAwLAkvKiAgZnVsbCBwb3dlciBtb2RlICovCisJQkZBX1BNX0RTX0QxID0gMSwJLyogIHBvd2VyIHNhdmUgc3RhdGUgMSAqLworCUJGQV9QTV9EU19EMiA9IDIsCS8qICBwb3dlciBzYXZlIHN0YXRlIDIgKi8KKwlCRkFfUE1fRFNfRDMgPSAzLAkvKiAgcG93ZXIgb2ZmIHN0YXRlICovCit9OworCisjZW5kaWYgLyogX19CRkFfREVGU19QTV9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3BvbS5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcG9tLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZDlmYTI3OAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3BvbS5oCkBAIC0wLDAgKzEsNTYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRkFfREVGU19QT01fSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfUE9NX0hfXworCisjaW5jbHVkZSA8YmZhX29zX2luYy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfdHlwZXMuaD4KKworLyoqCisgKiBQT00gaGVhbHRoIHN0YXR1cyBsZXZlbHMgZm9yIGVhY2ggYXR0cmlidXRlcy4KKyAqLworZW51bSBiZmFfcG9tX2VudHJ5X2hlYWx0aCB7CisJQkZBX1BPTV9IRUFMVEhfTk9JTkZPICA9IDEsCS8qICBubyBpbmZvcm1hdGlvbiAqLworCUJGQV9QT01fSEVBTFRIX05PUk1BTCAgPSAyLAkvKiAgaGVhbHRoIGlzIG5vcm1hbCAqLworCUJGQV9QT01fSEVBTFRIX1dBUk5JTkcgPSAzLAkvKiAgd2FybmluZyBsZXZlbCAqLworCUJGQV9QT01fSEVBTFRIX0FMQVJNICAgPSA0LAkvKiAgYWxhcm1pbmcgbGV2ZWwgKi8KK307CisKKy8qKgorICogUmVhZGluZyBvZiB0ZW1wZXJhdHVyZS92b2x0YWdlL2N1cnJlbnQvcG93ZXIKKyAqLworc3RydWN0IGJmYV9wb21fZW50cnlfcyB7CisJZW51bSBiZmFfcG9tX2VudHJ5X2hlYWx0aCBoZWFsdGg7CS8qICBQT00gZW50cnkgaGVhbHRoICovCisJdTMyICAgICAgICBjdXJyX3ZhbHVlOwkvKiAgY3VycmVudCB2YWx1ZSAqLworCXUzMiAgICAgICAgdGhyX3dhcm5faGlnaDsJLyogIHRocmVzaG9sZCB3YXJuaW5nIGhpZ2ggKi8KKwl1MzIgICAgICAgIHRocl93YXJuX2xvdzsJLyogIHRocmVzaG9sZCB3YXJuaW5nIGxvdyAqLworCXUzMiAgICAgICAgdGhyX2FsYXJtX2xvdzsJLyogIHRocmVzaG9sZCBhbGFyYW0gbG93ICovCisJdTMyICAgICAgICB0aHJfYWxhcm1faGlnaDsJLyogIHRocmVzaG9sZCBhbGFybSBoaWdoICovCit9OworCisvKioKKyAqIFBPTSBhdHRyaWJ1dGVzCisgKi8KK3N0cnVjdCBiZmFfcG9tX2F0dHJfcyB7CisJc3RydWN0IGJmYV9wb21fZW50cnlfcyB0ZW1wZXJhdHVyZTsJLyogIGNlbnRpZ3JhZGUgKi8KKwlzdHJ1Y3QgYmZhX3BvbV9lbnRyeV9zIHZvbHRhZ2U7CS8qICB2b2x0cyAqLworCXN0cnVjdCBiZmFfcG9tX2VudHJ5X3MgY3VycjsJLyogIG1pbGxpIGFtcHMgKi8KKwlzdHJ1Y3QgYmZhX3BvbV9lbnRyeV9zIHR4cG93ZXI7CS8qICBtaWNybyB3YXR0cyAqLworCXN0cnVjdCBiZmFfcG9tX2VudHJ5X3Mgcnhwb3dlcjsJLyogIG1pY3JvIHdhdHRzICovCit9OworCisjZW5kaWYgLyogX19CRkFfREVGU19QT01fSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19wb3J0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19wb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGUwNjk2YwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3BvcnQuaApAQCAtMCwwICsxLDI0NSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfUE9SVF9IX18KKyNkZWZpbmUgX19CRkFfREVGU19QT1JUX0hfXworCisjaW5jbHVkZSA8YmZhX29zX2luYy5oPgorI2luY2x1ZGUgPHByb3RvY29sL3R5cGVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfaW9jLmg+CisKKyNkZWZpbmUgQkZBX0ZDU19GQUJSSUNfSVBBRERSX1NaICAxNgorCisvKioKKyAqIHN5bWJvbGljIG5hbWVzIGZvciBiYXNlIHBvcnQvdmlydHVhbCBwb3J0CisgKi8KKyNkZWZpbmUgQkZBX1NZTU5BTUVfTUFYTEVOCTEyOAkvKiB2bXdhcmUvd2luZG93cyB1c2VzIDEyOCBieXRlcyAqLworc3RydWN0IGJmYV9wb3J0X3N5bW5hbWVfcyB7CisJY2hhciAgICAgICAgICAgIHN5bW5hbWVbQkZBX1NZTU5BTUVfTUFYTEVOXTsKK307CisKKy8qKgorKiBSb2xlcyBvZiBGQ1MgcG9ydDoKKyAqICAgICAtIEZDUCBJTSBhbmQgRkNQIFRNIHJvbGVzIGNhbm5vdCBiZSBlbmFibGVkIHRvZ2V0aGVyIGZvciBhIEZDUyBwb3J0CisgKiAgICAgLSBDcmVhdGUgbXVsdGlwbGUgcG9ydHMgaWYgYm90aCBJTSBhbmQgVE0gZnVuY3Rpb25zIHJlcXVpcmVkLgorICogICAgIC0gQXRsZWFzdCBvbmUgcm9sZSBtdXN0IGJlIHNwZWNpZmllZC4KKyAqLworZW51bSBiZmFfcG9ydF9yb2xlIHsKKwlCRkFfUE9SVF9ST0xFX0ZDUF9JTSAJPSAweDAxLAkvKiAgRkNQIGluaXRpYXRvciByb2xlICovCisJQkZBX1BPUlRfUk9MRV9GQ1BfVE0gCT0gMHgwMiwJLyogIEZDUCB0YXJnZXQgcm9sZSAqLworCUJGQV9QT1JUX1JPTEVfRkNQX0lQRkMgCT0gMHgwNCwJLyogIElQIG92ZXIgRkMgcm9sZSAqLworCUJGQV9QT1JUX1JPTEVfRkNQX01BWCAJPSBCRkFfUE9SVF9ST0xFX0ZDUF9JUEZDIHwgQkZBX1BPUlRfUk9MRV9GQ1BfSU0KK307CisKKy8qKgorICogRkNTIHBvcnQgY29uZmlndXJhdGlvbi4KKyAqLworc3RydWN0IGJmYV9wb3J0X2NmZ19zIHsKKyAgICB3d25fdCAgICAgICAgICAgICAgIHB3d247ICAgICAgIC8qICBwb3J0IHd3biAqLworICAgIHd3bl90ICAgICAgICAgICAgICAgbnd3bjsgICAgICAgLyogIG5vZGUgd3duICovCisgICAgc3RydWN0IGJmYV9wb3J0X3N5bW5hbWVfcyAgc3ltX25hbWU7ICAgLyogIHZtIHBvcnQgc3ltYm9saWMgbmFtZSAqLworICAgIGVudW0gYmZhX3BvcnRfcm9sZSAgICAgcm9sZXM7ICAgICAgLyogIEZDUyBwb3J0IHJvbGVzICovCisJdTMyCQkJcnN2ZDsKKyAgICB1OCAgICAgICAgICAgICB0YWdbMTZdOwkvKiAgb3BhcXVlIHRhZyBmcm9tIGFwcGxpY2F0aW9uICovCit9OworCisvKioKKyAqIEZDUyBwb3J0IHN0YXRlcworICovCitlbnVtIGJmYV9wb3J0X3N0YXRlIHsKKwlCRkFfUE9SVF9VTklOSVQgID0gMCwJLyogIFBPUlQgaXMgbm90IHlldCBpbml0aWFsaXplZCAqLworCUJGQV9QT1JUX0ZESVNDICAgPSAxLAkvKiAgRkRJU0MgaXMgaW4gcHJvZ3Jlc3MgKi8KKwlCRkFfUE9SVF9PTkxJTkUgID0gMiwJLyogIGxvZ2luIHRvIGZhYnJpYyBpcyBjb21wbGV0ZSAqLworCUJGQV9QT1JUX09GRkxJTkUgPSAzLAkvKiAgTm8gbG9naW4gdG8gZmFicmljICovCit9OworCisvKioKKyAqIEZDUyBwb3J0IHR5cGUuIFJlcXVpcmVkIGZvciBWbVdhcmUuCisgKi8KK2VudW0gYmZhX3BvcnRfdHlwZSB7CisJQkZBX1BPUlRfVFlQRV9QSFlTSUNBTCA9IDAsCisJQkZBX1BPUlRfVFlQRV9WSVJUVUFMLAorfTsKKworLyoqCisgKiBGQ1MgcG9ydCBvZmZsaW5lIHJlYXNvbi4gUmVxdWlyZWQgZm9yIFZtV2FyZS4KKyAqLworZW51bSBiZmFfcG9ydF9vZmZsaW5lX3JlYXNvbiB7CisJQkZBX1BPUlRfT0ZGTElORV9VTktOT1dOID0gMCwKKwlCRkFfUE9SVF9PRkZMSU5FX0xJTktET1dOLAorCUJGQV9QT1JUX09GRkxJTkVfRkFCX1VOU1VQUE9SVEVELAkvKiAgTlBJViBub3Qgc3VwcG9ydGVkIGJ5IHRoZQorCQkJCQkJICogICAgZmFicmljICovCisJQkZBX1BPUlRfT0ZGTElORV9GQUJfTk9SRVNPVVJDRVMsCisJQkZBX1BPUlRfT0ZGTElORV9GQUJfTE9HT1VULAorfTsKKworLyoqCisgKiBGQ1MgbHBvcnQgaW5mby4gUmVxdWlyZWQgZm9yIFZtV2FyZS4KKyAqLworc3RydWN0IGJmYV9wb3J0X2luZm9fcyB7CisJdTggICAgICAgICBwb3J0X3R5cGU7CS8qIGJmYV9wb3J0X3R5cGVfdCA6IHBoeXNpY2FsIG9yCisJCQkJCSAqIHZpcnR1YWwgKi8KKwl1OCAgICAgICAgIHBvcnRfc3RhdGU7CS8qIG9uZSBvZiBiZmFfcG9ydF9zdGF0ZSB2YWx1ZXMgKi8KKwl1OCAgICAgICAgIG9mZmxpbmVfcmVhc29uOwkvKiBvbmUgb2YgYmZhX3BvcnRfb2ZmbGluZV9yZWFzb25fdAorCQkJCQkgKiB2YWx1ZXMgKi8KKwl3d25fdCAgICAgICAgICAgcG9ydF93d247CisJd3duX3QgICAgICAgICAgIG5vZGVfd3duOworCisJLyoKKwkgKiBmb2xsb3dpbmcgNCBmZWlsZHMgYXJlIHZhbGlkIGZvciBQaHlzaWNhbCBQb3J0cyBvbmx5CisJICovCisJdTMyICAgICAgICBtYXhfdnBvcnRzX3N1cHA7CS8qIE1heCBzdXBwb3J0ZWQgdnBvcnRzICovCisJdTMyICAgICAgICBudW1fdnBvcnRzX2ludXNlOwkvKiBOdW0gb2YgaW4gdXNlIHZwb3J0cyAqLworCXUzMiAgICAgICAgbWF4X3Jwb3J0c19zdXBwOwkvKiBNYXggc3VwcG9ydGVkIHJwb3J0cyAqLworCXUzMiAgICAgICAgbnVtX3Jwb3J0c19pbnVzZTsJLyogTnVtIG9mIGRvc2NvdmVyZWQgcnBvcnRzICovCisKK307CisKKy8qKgorICogRkNTIHBvcnQgc3RhdGlzdGljcworICovCitzdHJ1Y3QgYmZhX3BvcnRfc3RhdHNfcyB7CisJdTMyICAgICAgICBuc19wbG9naV9zZW50OworCXUzMiAgICAgICAgbnNfcGxvZ2lfcnNwX2VycjsKKwl1MzIgICAgICAgIG5zX3Bsb2dpX2FjY19lcnI7CisJdTMyICAgICAgICBuc19wbG9naV9hY2NlcHRzOworCXUzMiAgICAgICAgbnNfcmVqZWN0czsJLyogTlMgY29tbWFuZCByZWplY3RzICovCisJdTMyICAgICAgICBuc19wbG9naV91bmtub3duX3JzcDsKKwl1MzIgICAgICAgIG5zX3Bsb2dpX2FsbG9jX3dhaXQ7CisKKwl1MzIgICAgICAgIG5zX3JldHJpZXM7CS8qIE5TIGNvbW1hbmQgcmV0cmllcyAqLworCXUzMiAgICAgICAgbnNfdGltZW91dHM7CS8qIE5TIGNvbW1hbmQgdGltZW91dHMgKi8KKworCXUzMiAgICAgICAgbnNfcnNwbmlkX3NlbnQ7CisJdTMyICAgICAgICBuc19yc3BuaWRfYWNjZXB0czsKKwl1MzIgICAgICAgIG5zX3JzcG5pZF9yc3BfZXJyOworCXUzMiAgICAgICAgbnNfcnNwbmlkX3JlamVjdHM7CisJdTMyICAgICAgICBuc19yc3BuaWRfYWxsb2Nfd2FpdDsKKworCXUzMiAgICAgICAgbnNfcmZ0aWRfc2VudDsKKwl1MzIgICAgICAgIG5zX3JmdGlkX2FjY2VwdHM7CisJdTMyICAgICAgICBuc19yZnRpZF9yc3BfZXJyOworCXUzMiAgICAgICAgbnNfcmZ0aWRfcmVqZWN0czsKKwl1MzIgICAgICAgIG5zX3JmdGlkX2FsbG9jX3dhaXQ7CisKKwl1MzIJbnNfcmZmaWRfc2VudDsKKwl1MzIJbnNfcmZmaWRfYWNjZXB0czsKKwl1MzIJbnNfcmZmaWRfcnNwX2VycjsKKwl1MzIJbnNfcmZmaWRfcmVqZWN0czsKKwl1MzIJbnNfcmZmaWRfYWxsb2Nfd2FpdDsKKworCXUzMiAgICAgICAgbnNfZ2lkZnRfc2VudDsKKwl1MzIgICAgICAgIG5zX2dpZGZ0X2FjY2VwdHM7CisJdTMyICAgICAgICBuc19naWRmdF9yc3BfZXJyOworCXUzMiAgICAgICAgbnNfZ2lkZnRfcmVqZWN0czsKKwl1MzIgICAgICAgIG5zX2dpZGZ0X3Vua25vd25fcnNwOworCXUzMiAgICAgICAgbnNfZ2lkZnRfYWxsb2Nfd2FpdDsKKworCS8qCisJICogTWdtdCBTZXJ2ZXIgc3RhdHMKKwkgKi8KKwl1MzIgICAgICAgIG1zX3JldHJpZXM7CS8qIE1TIGNvbW1hbmQgcmV0cmllcyAqLworCXUzMiAgICAgICAgbXNfdGltZW91dHM7CS8qIE1TIGNvbW1hbmQgdGltZW91dHMgKi8KKwl1MzIgICAgICAgIG1zX3Bsb2dpX3NlbnQ7CisJdTMyICAgICAgICBtc19wbG9naV9yc3BfZXJyOworCXUzMiAgICAgICAgbXNfcGxvZ2lfYWNjX2VycjsKKwl1MzIgICAgICAgIG1zX3Bsb2dpX2FjY2VwdHM7CisJdTMyICAgICAgICBtc19yZWplY3RzOwkvKiBOUyBjb21tYW5kIHJlamVjdHMgKi8KKwl1MzIgICAgICAgIG1zX3Bsb2dpX3Vua25vd25fcnNwOworCXUzMiAgICAgICAgbXNfcGxvZ2lfYWxsb2Nfd2FpdDsKKworCXUzMiAgICAgICAgbnVtX3JzY247CS8qIE51bSBvZiBSU0NOIHJlY2VpdmVkICovCisJdTMyICAgICAgICBudW1fcG9ydGlkX3JzY247LyogTnVtIHBvcnRpZCBmb3JtYXQgUlNDTgorCQkJCQkJCQkqIHJlY2VpdmVkICovCisKKwl1MzIJdWZfcmVjdnM7IAkvKiB1bnNvbGljaXRlZCByZWN2IGZyYW1lcyAgICAgICovCisJdTMyCXVmX3JlY3ZfZHJvcHM7IAkvKiBkcm9wcGVkIHJlY2VpdmVkIGZyYW1lcwkqLworCisJdTMyCXJzdmQ7IAkJLyogcGFkZGluZyBmb3IgNjQgYml0IGFsaWdubWVudCAqLworfTsKKworLyoqCisgKiBCRkEgcG9ydCBhdHRyaWJ1dGUgcmV0dXJuZWQgaW4gcXVlcmllcworICovCitzdHJ1Y3QgYmZhX3BvcnRfYXR0cl9zIHsKKwllbnVtIGJmYV9wb3J0X3N0YXRlIHN0YXRlOwkJLyogIHBvcnQgc3RhdGUgKi8KKwl1MzIgICAgICAgICBwaWQ7CQkvKiAgcG9ydCBJRCAqLworCXN0cnVjdCBiZmFfcG9ydF9jZmdfcyAgIHBvcnRfY2ZnOwkvKiAgcG9ydCBjb25maWd1cmF0aW9uICovCisJZW51bSBiZmFfcHBvcnRfdHlwZSBwb3J0X3R5cGU7CS8qICBjdXJyZW50IHRvcG9sb2d5ICovCisJdTMyICAgICAgICAgbG9vcGJhY2s7CS8qICBjYWJsZSBpcyBleHRlcm5hbGx5IGxvb3BlZCBiYWNrICovCisJd3duX3QJCWZhYnJpY19uYW1lOyAvKiAgYXR0YWNoZWQgc3dpdGNoJ3Mgbnd3biAqLworCXU4CQlmYWJyaWNfaXBfYWRkcltCRkFfRkNTX0ZBQlJJQ19JUEFERFJfU1pdOyAvKiAgYXR0YWNoZWQKKwkJCQkJCQkqIGZhYnJpYydzIGlwIGFkZHIgKi8KK307CisKKy8qKgorICogQkZBIHBoeXNpY2FsIHBvcnQgTGV2ZWwgZXZlbnRzCisgKiBBcmd1bWVudHMgYmVsb3cgYXJlIGluIEJGQUwgY29udGV4dCBmcm9tIE1nbXQKKyAqIEJGQV9QT1JUX0FFTl9PTkxJTkU6ICAgICBbaW5dOiBwd3duCVtvdXRdOiBwd3duCisgKiBCRkFfUE9SVF9BRU5fT0ZGTElORTogICAgW2luXTogcHd3bglbb3V0XTogcHd3bgorICogQkZBX1BPUlRfQUVOX1JMSVI6ICAgICAgIFtpbl06IE5vbmUJW291dF06IHB3d24sIHJsaXJfZGF0YSwgcmxpcl9sZW4KKyAqIEJGQV9QT1JUX0FFTl9TRlBfSU5TRVJUOiBbaW5dOiBwd3duCVtvdXRdOiBwb3J0X2lkLCBwd3duCisgKiBCRkFfUE9SVF9BRU5fU0ZQX1JFTU9WRTogW2luXTogcHd3bglbb3V0XTogcG9ydF9pZCwgcHd3bgorICogQkZBX1BPUlRfQUVOX1NGUF9QT006ICAgIFtpbl06IHB3d24JW291dF06IGxldmVsLCBwb3J0X2lkLCBwd3duCisgKiBCRkFfUE9SVF9BRU5fRU5BQkxFOiAgICAgW2luXTogcHd3bglbb3V0XTogcHd3bgorICogQkZBX1BPUlRfQUVOX0RJU0FCTEU6ICAgIFtpbl06IHB3d24JW291dF06IHB3d24KKyAqIEJGQV9QT1JUX0FFTl9BVVRIX09OOiAgICBbaW5dOiBwd3duCVtvdXRdOiBwd3duCisgKiBCRkFfUE9SVF9BRU5fQVVUSF9PRkY6ICAgW2luXTogcHd3bglbb3V0XTogcHd3bgorICogQkZBX1BPUlRfQUVOX0RJU0NPTk5FQ1Q6IFtpbl06IHB3d24JW291dF06IHB3d24KKyAqIEJGQV9QT1JUX0FFTl9RT1NfTkVHOiAgICBbaW5dOiBwd3duCVtvdXRdOiBwd3duCisgKiBCRkFfUE9SVF9BRU5fRkFCUklDX05BTUVfQ0hBTkdFOiBbaW5dOiBwd3duLCBbb3V0XTogcHd3biwgZnd3bgorICoKKyAqLworZW51bSBiZmFfcG9ydF9hZW5fZXZlbnQgeworCUJGQV9QT1JUX0FFTl9PTkxJTkUgICAgID0gMSwJLyogIFBoeXNpY2FsIFBvcnQgb25saW5lIGV2ZW50ICovCisJQkZBX1BPUlRfQUVOX09GRkxJTkUgICAgPSAyLAkvKiAgUGh5c2ljYWwgUG9ydCBvZmZsaW5lIGV2ZW50ICovCisJQkZBX1BPUlRfQUVOX1JMSVIgICAgICAgPSAzLAkvKiAgUkxJUiBldmVudCwgbm90IHN1cHBvcnRlZCAqLworCUJGQV9QT1JUX0FFTl9TRlBfSU5TRVJUID0gNCwJLyogIFNGUCBpbnNlcnRlZCBldmVudCAqLworCUJGQV9QT1JUX0FFTl9TRlBfUkVNT1ZFID0gNSwJLyogIFNGUCByZW1vdmVkIGV2ZW50ICovCisJQkZBX1BPUlRfQUVOX1NGUF9QT00gICAgPSA2LAkvKiAgU0ZQIFBPTSBldmVudCAqLworCUJGQV9QT1JUX0FFTl9FTkFCTEUgICAgID0gNywJLyogIFBoeXNpY2FsIFBvcnQgZW5hYmxlIGV2ZW50ICovCisJQkZBX1BPUlRfQUVOX0RJU0FCTEUgICAgPSA4LAkvKiAgUGh5c2ljYWwgUG9ydCBkaXNhYmxlIGV2ZW50ICovCisJQkZBX1BPUlRfQUVOX0FVVEhfT04gICAgPSA5LAkvKiAgUGh5c2ljYWwgUG9ydCBhdXRoIHN1Y2Nlc3MgZXZlbnQgKi8KKwlCRkFfUE9SVF9BRU5fQVVUSF9PRkYgICA9IDEwLAkvKiAgUGh5c2ljYWwgUG9ydCBhdXRoIGZhaWwgZXZlbnQgKi8KKwlCRkFfUE9SVF9BRU5fRElTQ09OTkVDVCA9IDExLAkvKiAgUGh5c2ljYWwgUG9ydCBkaXNjb25uZWN0IGV2ZW50ICovCisJQkZBX1BPUlRfQUVOX1FPU19ORUcgICAgPSAxMiwgIAkvKiAgQmFzZSBQb3J0IFFPUyBuZWdvdGlhdGlvbiBldmVudCAqLworCUJGQV9QT1JUX0FFTl9GQUJSSUNfTkFNRV9DSEFOR0UgPSAxMywgLyogIEZhYnJpYyBOYW1lL1dXTiBjaGFuZ2UKKwkJCQkJICAgICAgICogZXZlbnQgKi8KKwlCRkFfUE9SVF9BRU5fU0ZQX0FDQ0VTU19FUlJPUiA9IDE0LCAvKiAgU0ZQIHJlYWQgZXJyb3IgZXZlbnQgKi8KKwlCRkFfUE9SVF9BRU5fU0ZQX1VOU1VQUE9SVCA9IDE1LCAvKiAgVW5zdXBwb3J0ZWQgU0ZQIGV2ZW50ICovCit9OworCitlbnVtIGJmYV9wb3J0X2Flbl9zZnBfcG9tIHsKKwlCRkFfUE9SVF9BRU5fU0ZQX1BPTV9HUkVFTiA9IDEsCS8qICBOb3JtYWwgKi8KKwlCRkFfUE9SVF9BRU5fU0ZQX1BPTV9BTUJFUiA9IDIsCS8qICBXYXJuaW5nICovCisJQkZBX1BPUlRfQUVOX1NGUF9QT01fUkVEICAgPSAzLAkvKiAgQ3JpdGljYWwgKi8KKwlCRkFfUE9SVF9BRU5fU0ZQX1BPTV9NQVggICA9IEJGQV9QT1JUX0FFTl9TRlBfUE9NX1JFRAorfTsKKworc3RydWN0IGJmYV9wb3J0X2Flbl9kYXRhX3MgeworCWVudW0gYmZhX2lvY190eXBlX2UgaW9jX3R5cGU7CisJd3duX3QgICAgICAgICAgIHB3d247CSAgICAgIC8qICBXV04gb2YgdGhlIHBoeXNpY2FsIHBvcnQgKi8KKwl3d25fdCAgICAgICAgICAgZnd3bjsJICAgICAgLyogIFdXTiBvZiB0aGUgZmFicmljIHBvcnQgKi8KKwltYWNfdCAgICAgICAgICAgbWFjOwkgICAgICAvKiAgTUFDIGFkZHJlcyBvZiB0aGUgZXRoZXJuZXQgcG9ydCwKKwkJCQkgICAgICAgKiBhcHBsaWNhYmxlIHRvIENOQSBwb3J0IG9ubHkgKi8KKwlpbnQgICAgICAgICAgICAgcGh5X3BvcnRfbnVtOyAvKiEgRm9yIFNGUCByZWxhdGVkIGV2ZW50cyAqLworCWVudW0gYmZhX3BvcnRfYWVuX3NmcF9wb20gbGV2ZWw7IC8qICBPbmx5IHRyYW5zaXRpb25zIHdpbGwKKwkJCQkJICAqIGJlIGluZm9ybWVkICovCit9OworCisjZW5kaWYgLyogX19CRkFfREVGU19QT1JUX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcHBvcnQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3Bwb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTAwMGJjNAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3Bwb3J0LmgKQEAgLTAsMCArMSwzODMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9ERUZTX1BQT1JUX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX1BQT1JUX0hfXworCisjaW5jbHVkZSA8YmZhX29zX2luYy5oPgorI2luY2x1ZGUgPHByb3RvY29sL2ZjLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc190eXBlcy5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcW9zLmg+CisjaW5jbHVkZSA8Y25hL3BzdGF0cy9waHlwb3J0X2RlZnMuaD4KKworLyogTW9kaWZ5IGNoYXIqIHBvcnRfc3R0W10gaW4gYmZhbF9wb3J0LmMgaWYgYSBuZXcgc3RhdGUgd2FzIGFkZGVkICovCitlbnVtIGJmYV9wcG9ydF9zdGF0ZXMgeworCUJGQV9QUE9SVF9TVF9VTklOSVQgCQk9IDEsCisJQkZBX1BQT1JUX1NUX0VOQUJMSU5HX1FXQUlUIAk9IDIsCisJQkZBX1BQT1JUX1NUX0VOQUJMSU5HIAkJPSAzLAorCUJGQV9QUE9SVF9TVF9MSU5LRE9XTiAJCT0gNCwKKwlCRkFfUFBPUlRfU1RfTElOS1VQIAkJPSA1LAorCUJGQV9QUE9SVF9TVF9ESVNBQkxJTkdfUVdBSVQgCT0gNiwKKwlCRkFfUFBPUlRfU1RfRElTQUJMSU5HCQk9IDcsCisJQkZBX1BQT1JUX1NUX0RJU0FCTEVEIAkJPSA4LAorCUJGQV9QUE9SVF9TVF9TVE9QUEVEIAkJPSA5LAorCUJGQV9QUE9SVF9TVF9JT0NET1dOIAkJPSAxMCwKKwlCRkFfUFBPUlRfU1RfSU9DRElTIAkJPSAxMSwKKwlCRkFfUFBPUlRfU1RfRldNSVNNQVRDSAkJPSAxMiwKKwlCRkFfUFBPUlRfU1RfTUFYX1NUQVRFLAorfTsKKworLyoqCisgKiAJUG9ydCBzcGVlZCBzZXR0aW5ncy4gRWFjaCBzcGVjaWZpYyBzcGVlZCBpcyBhIGJpdCBmaWVsZC4gVXNlIG11bHRpcGxlCisgKiAgICAgIGJpdHMgdG8gc3BlY2lmeSBzcGVlZHMgdG8gYmUgc2VsZWN0ZWQgZm9yIGF1dG8tbmVnb3RpYXRpb24uCisgKi8KK2VudW0gYmZhX3Bwb3J0X3NwZWVkIHsKKwlCRkFfUFBPUlRfU1BFRURfVU5LTk9XTiA9IDAsCisJQkZBX1BQT1JUX1NQRUVEXzFHQlBTIAk9IDEsCisJQkZBX1BQT1JUX1NQRUVEXzJHQlBTIAk9IDIsCisJQkZBX1BQT1JUX1NQRUVEXzRHQlBTIAk9IDQsCisJQkZBX1BQT1JUX1NQRUVEXzhHQlBTIAk9IDgsCisJQkZBX1BQT1JUX1NQRUVEXzEwR0JQUyAJPSAxMCwKKwlCRkFfUFBPUlRfU1BFRURfQVVUTyA9CisJCShCRkFfUFBPUlRfU1BFRURfMUdCUFMgfCBCRkFfUFBPUlRfU1BFRURfMkdCUFMgfAorCQkgQkZBX1BQT1JUX1NQRUVEXzRHQlBTIHwgQkZBX1BQT1JUX1NQRUVEXzhHQlBTKSwKK307CisKKy8qKgorICogCQlQb3J0IG9wZXJhdGlvbmFsIHR5cGUgKGluIHN5bmMgd2l0aCBTTklBIHBvcnQgdHlwZSkuCisgKi8KK2VudW0gYmZhX3Bwb3J0X3R5cGUgeworCUJGQV9QUE9SVF9UWVBFX1VOS05PV04gPSAxLAkvKiAgcG9ydCB0eXBlIGlzIHVua293biAqLworCUJGQV9QUE9SVF9UWVBFX1RSVU5LRUQgPSAyLAkvKiAgVHJ1bmtlZCBtb2RlICovCisJQkZBX1BQT1JUX1RZUEVfTlBPUlQgICA9IDUsCS8qICBQMlAgd2l0aCBzd2l0Y2hlZCBmYWJyaWMgKi8KKwlCRkFfUFBPUlRfVFlQRV9OTFBPUlQgID0gNiwJLyogIHB1YmxpYyBsb29wICovCisJQkZBX1BQT1JUX1RZUEVfTFBPUlQgICA9IDIwLAkvKiAgcHJpdmF0ZSBsb29wICovCisJQkZBX1BQT1JUX1RZUEVfUDJQICAgICA9IDIxLAkvKiAgUDJQIHdpdGggbm8gc3dpdGNoZWQgZmFicmljICovCisJQkZBX1BQT1JUX1RZUEVfVlBPUlQgICA9IDIyLAkvKiAgTlBJViAtIHZpcnR1YWwgcG9ydCAqLworfTsKKworLyoqCisgKiAJCVBvcnQgdG9wb2xvZ3kgc2V0dGluZy4gQSBwb3J0J3MgdG9wb2xvZ3kgYW5kIGZhYnJpYyBsb2dpbiBzdGF0dXMKKyAqIAkJZGV0ZXJtaW5lIGl0cyBvcGVyYXRpb25hbCB0eXBlLgorICovCitlbnVtIGJmYV9wcG9ydF90b3BvbG9neSB7CisJQkZBX1BQT1JUX1RPUE9MT0dZX05PTkUgPSAwLAkvKiAgTm8gdmFsaWQgdG9wb2xvZ3kgKi8KKwlCRkFfUFBPUlRfVE9QT0xPR1lfUDJQICA9IDEsCS8qICBQMlAgb25seSAqLworCUJGQV9QUE9SVF9UT1BPTE9HWV9MT09QID0gMiwJLyogIExPT1AgdG9wb2xvZ3kgKi8KKwlCRkFfUFBPUlRfVE9QT0xPR1lfQVVUTyA9IDMsCS8qICBhdXRvIHRvcG9sb2d5IHNlbGVjdGlvbiAqLworfTsKKworLyoqCisgKiAJCVBoeXNpY2FsIHBvcnQgbG9vcGJhY2sgdHlwZXMuCisgKi8KK2VudW0gYmZhX3Bwb3J0X29wbW9kZSB7CisJQkZBX1BQT1JUX09QTU9ERV9OT1JNQUwgICA9IDB4MDAsIC8qICBub3JtYWwgbm9uLWxvb3BiYWNrIG1vZGUgKi8KKwlCRkFfUFBPUlRfT1BNT0RFX0xCX0lOVCAgID0gMHgwMSwgLyogIGludGVybmFsIGxvb3AgYmFjayAqLworCUJGQV9QUE9SVF9PUE1PREVfTEJfU0xXICAgPSAweDAyLCAvKiAgc2VyaWFsIGxpbmsgd3JhcGJhY2sgKHNlcmRlcykgKi8KKwlCRkFfUFBPUlRfT1BNT0RFX0xCX0VYVCAgID0gMHgwNCwgLyogIGV4dGVybmFsIGxvb3AgYmFjayAoc2VyZGVzKSAqLworCUJGQV9QUE9SVF9PUE1PREVfTEJfQ0JMICAgPSAweDA4LCAvKiAgY2FibGVkIGxvb3AgYmFjayAqLworCUJGQV9QUE9SVF9PUE1PREVfTEJfTkxJTlQgPSAweDIwLCAvKiAgTkxfUG9ydCBpbnRlcm5hbCBsb29wYmFjayAqLworfTsKKworI2RlZmluZSBCRkFfUFBPUlRfT1BNT0RFX0xCX0hBUkQoX21vZGUpCQkJXAorCSgoX21vZGUgPT0gQkZBX1BQT1JUX09QTU9ERV9MQl9JTlQpIHx8CQlcCisgICAgIChfbW9kZSA9PSBCRkFfUFBPUlRfT1BNT0RFX0xCX1NMVykgfHwJCVwKKyAgICAgKF9tb2RlID09IEJGQV9QUE9SVF9PUE1PREVfTEJfRVhUKSkKKworLyoqCisJCVBvcnQgU3RhdGUgKGluIHN5bmMgd2l0aCBTTklBIHBvcnQgc3RhdGUpLgorICovCitlbnVtIGJmYV9wcG9ydF9zbmlhX3N0YXRlIHsKKwlCRkFfUFBPUlRfU1RBVEVfVU5LTk9XTiAgPSAxLAkvKiAgcG9ydCBpcyBub3QgaW5pdGlhbGl6ZWQgKi8KKwlCRkFfUFBPUlRfU1RBVEVfT05MSU5FICAgPSAyLAkvKiAgcG9ydCBpcyBPTkxJTkUgKi8KKwlCRkFfUFBPUlRfU1RBVEVfRElTQUJMRUQgPSAzLAkvKiAgcG9ydCBpcyBkaXNhYmxlZCBieSB1c2VyICovCisJQkZBX1BQT1JUX1NUQVRFX0JZUEFTU0VEID0gNCwJLyogIHBvcnQgaXMgYnlwYXNzZWQgKGluIExPT1ApICovCisJQkZBX1BQT1JUX1NUQVRFX0RJQUcgICAgID0gNSwJLyogIHBvcnQgZGlhZ25vc3RpY3MgaXMgYWN0aXZlICovCisJQkZBX1BQT1JUX1NUQVRFX0xJTktET1dOID0gNiwJLyogIGxpbmsgaXMgZG93biAqLworCUJGQV9QUE9SVF9TVEFURV9MT09QQkFDSyA9IDgsCS8qICBwb3J0IGlzIGxvb3BlZCBiYWNrICovCit9OworCisvKioKKyAqIAkJUG9ydCBsaW5rIHN0YXRlCisgKi8KK2VudW0gYmZhX3Bwb3J0X2xpbmtzdGF0ZSB7CisJQkZBX1BQT1JUX0xJTktVUCAJID0gMSwJLyogIFBoeXNpY2FsIHBvcnQvVHJ1bmsgbGluayB1cCAqLworCUJGQV9QUE9SVF9MSU5LRE9XTiAJID0gMiwJLyogIFBoeXNpY2FsIHBvcnQvVHJ1bmsgbGluayBkb3duICovCisJQkZBX1BQT1JUX1RSVU5LX0xJTktET1dOID0gMywJLyogIFRydW5rIGxpbmsgZG93biAobmV3IHRtYXN0ZXIpICovCit9OworCisvKioKKyAqIAkJUG9ydCBsaW5rIHN0YXRlIGV2ZW50CisgKi8KKyNkZWZpbmUgYmZhX3Bwb3J0X2V2ZW50X3QgZW51bSBiZmFfcHBvcnRfbGlua3N0YXRlCisKKy8qKgorICogCQlQb3J0IGxpbmsgc3RhdGUgcmVhc29uIGNvZGUKKyAqLworZW51bSBiZmFfcHBvcnRfbGlua3N0YXRlX3JzbiB7CisJQkZBX1BQT1JUX0xJTktTVEFURV9SU05fTk9ORQkJPSAwLAorCUJGQV9QUE9SVF9MSU5LU1RBVEVfUlNOX0RJU0FCTEVEIAk9IDEsCisJQkZBX1BQT1JUX0xJTktTVEFURV9SU05fUlhfTk9TIAkJPSAyLAorCUJGQV9QUE9SVF9MSU5LU1RBVEVfUlNOX1JYX09MUyAJCT0gMywKKwlCRkFfUFBPUlRfTElOS1NUQVRFX1JTTl9SWF9MSVAgCQk9IDQsCisJQkZBX1BQT1JUX0xJTktTVEFURV9SU05fUlhfTElQRjcgCT0gNSwKKwlCRkFfUFBPUlRfTElOS1NUQVRFX1JTTl9TRlBfUkVNT1ZFRCAJPSA2LAorCUJGQV9QUE9SVF9MSU5LU1RBVEVfUlNOX1BPUlRfRkFVTFQgCT0gNywKKwlCRkFfUFBPUlRfTElOS1NUQVRFX1JTTl9SWF9MT1MgCQk9IDgsCisJQkZBX1BQT1JUX0xJTktTVEFURV9SU05fTE9DQUxfRkFVTFQgCT0gOSwKKwlCRkFfUFBPUlRfTElOS1NUQVRFX1JTTl9SRU1PVEVfRkFVTFQgCT0gMTAsCisJQkZBX1BQT1JUX0xJTktTVEFURV9SU05fVElNRU9VVCAJPSAxMSwKKworCisKKwkvKiBDRUUgcmVsYXRlZCByZWFzb24gY29kZXMvZXJyb3JzICovCisJQ0VFX0xMRFBfSU5GT19BR0VEX09VVCAgICAgICA9IDIwLAorCUNFRV9MTERQX1NIVVRET1dOX1RMVl9SQ1ZEICAgPSAyMSwKKwlDRUVfUEVFUl9OT1RfQURWRVJUSVNFX0RDQlggID0gMjIsCisJQ0VFX1BFRVJfTk9UX0FEVkVSVElTRV9QRyAgICA9IDIzLAorCUNFRV9QRUVSX05PVF9BRFZFUlRJU0VfUEZDICAgPSAyNCwKKwlDRUVfUEVFUl9OT1RfQURWRVJUSVNFX0ZDT0UgID0gMjUsCisJQ0VFX1BHX05PVF9DT01QQVRJQkxFICAgICAgICA9IDI2LAorCUNFRV9QRkNfTk9UX0NPTVBBVElCTEUgICAgICAgPSAyNywKKwlDRUVfRkNPRV9OT1RfQ09NUEFUSUJMRSAgICAgID0gMjgsCisJQ0VFX0JBRF9QR19SQ1ZEICAgICAgICAgICAgICA9IDI5LAorCUNFRV9CQURfQldfUkNWRCAgICAgICAgICAgICAgPSAzMCwKKwlDRUVfQkFEX1BGQ19SQ1ZEICAgICAgICAgICAgID0gMzEsCisJQ0VFX0JBRF9GQ09FX1BSSV9SQ1ZEICAgICAgICA9IDMyLAorCUNFRV9GQ09FX1BSSV9QRkNfT0ZGICAgICAgICAgPSAzMywKKwlDRUVfRFVQX0NPTlRST0xfVExWX1JDVkQgICAgID0gMzQsCisJQ0VFX0RVUF9GRUFUX1RMVl9SQ1ZEICAgICAgICA9IDM1LAorCUNFRV9BUFBMWV9ORVdfQ0ZHICAgICAgICAgICAgPSAzNiwJLyogcmVhc29uLCBub3QgYW4gZXJyb3IgKi8KKwlDRUVfUFJPVE9DT0xfSU5JVCAgICAgICAgICAgID0gMzcsICAvKiByZWFzb24sIG5vdCBhbiBlcnJvciAqLworCUNFRV9QSFlfTElOS19ET1dOICAgICAgICAgICAgPSAzOCwKKwlDRUVfTExTX0ZDT0VfQUJTRU5UICAgICAgICAgID0gMzksCisJQ0VFX0xMU19GQ09FX0RPV04gICAgICAgICAgICA9IDQwCit9OworCisvKioKKyAqICAgICAgRGVmYXVsdCBUYXJnZXQgUmF0ZSBMaW1pdGluZyBTcGVlZC4KKyAqLworI2RlZmluZSBCRkFfUFBPUlRfREVGX1RSTF9TUEVFRCAgQkZBX1BQT1JUX1NQRUVEXzFHQlBTCisKKy8qKgorICogICAgICBQaHlzaWNhbCBwb3J0IGNvbmZpZ3VyYXRpb24KKyAqLworc3RydWN0IGJmYV9wcG9ydF9jZmdfcyB7CisJdTggICAgICAgICB0b3BvbG9neTsJLyogIGJmYV9wcG9ydF90b3BvbG9neQkJKi8KKwl1OCAgICAgICAgIHNwZWVkOwkJLyogIGVudW0gYmZhX3Bwb3J0X3NwZWVkCSovCisJdTggICAgICAgICB0cnVua2VkOwkvKiAgdHJ1bmtlZCBvciBub3QJCSovCisJdTggICAgICAgICBxb3NfZW5hYmxlZDsJLyogIHFvcyBlbmFibGVkIG9yIG5vdAkJKi8KKwl1OCAgICAgICAgIHRydW5rX3BvcnRzOwkvKiAgYml0bWFwIG9mIHRydW5rZWQgcG9ydHMJKi8KKwl1OCAgICAgICAgIGNmZ19oYXJkYWxwYTsJLyogIGlzIGhhcmQgYWxwYSBjb25maWd1cmVkCSovCisJdTE2ICAgICAgICBtYXhmcnNpemU7CS8qICBtYXhpbXVtIGZyYW1lIHNpemUJCSovCisJdTggICAgICAgICBoYXJkYWxwYTsJLyogIGNvbmZpZ3VyZWQgaGFyZCBhbHBhCSovCisJdTggICAgICAgICByeF9iYmNyZWRpdDsJLyogIHJlY2VpdmUgYnVmZmVyIGNyZWRpdHMJKi8KKwl1OCAgICAgICAgIHR4X2JiY3JlZGl0OwkvKiAgdHJhbnNtaXQgYnVmZmVyIGNyZWRpdHMJKi8KKwl1OCAgICAgICAgIHJhdGVsaW1pdDsJLyogIHJhdGVsaW1pdCBlbmFibGVkIG9yIG5vdAkqLworCXU4ICAgICAgICAgdHJsX2RlZl9zcGVlZDsJLyogIHJhdGVsaW1pdCBkZWZhdWx0IHNwZWVkCSovCisJdTgJCXJzdmRbM107CisJdTE2ICAgCXBhdGhfdG92OwkvKiAgZGV2aWNlIHBhdGggdGltZW91dAkqLworCXUxNiAgIAlxX2RlcHRoOwkvKiAgU0NTSSBRdWV1ZSBkZXB0aAkJKi8KK307CisKKy8qKgorICogCQlQb3J0IGF0dHJpYnV0ZSB2YWx1ZXMuCisgKi8KK3N0cnVjdCBiZmFfcHBvcnRfYXR0cl9zIHsKKwkvKgorCSAqIFN0YXRpYyBmaWVsZHMKKwkgKi8KKwl3d25fdCAgICAgICAgICAgbnd3bjsJCS8qICBub2RlIHd3biAqLworCXd3bl90ICAgICAgICAgICBwd3duOwkJLyogIHBvcnQgd3duICovCisJZW51bSBmY19jb3MgICAgIGNvc19zdXBwb3J0ZWQ7CS8qICBzdXBwb3J0ZWQgY2xhc3Mgb2Ygc2VydmljZXMgKi8KKwl1MzIgICAgICAgIHJzdmQ7CisJc3RydWN0IGZjX3N5bW5hbWVfcyAgICBwb3J0X3N5bW5hbWU7CS8qICBwb3J0IHN5bWJvbGljIG5hbWUgKi8KKwllbnVtIGJmYV9wcG9ydF9zcGVlZCBzcGVlZF9zdXBwb3J0ZWQ7IC8qICBzdXBwb3J0ZWQgc3BlZWRzICovCisJYmZhX2Jvb2xlYW5fdCAgIHBiaW5kX2VuYWJsZWQ7CS8qICBXaWxsIGJlIHNldCBpZiBQZXJzaXN0ZW50IGJpbmRpbmcKKwkJCQkJICogICBlbmFibGVkLiBSZWxldmFudCBvbmx5IGluIFdpbmRvd3MKKwkJCQkJICovCisKKwkvKgorCSAqIENvbmZpZ3VyZWQgdmFsdWVzCisJICovCisJc3RydWN0IGJmYV9wcG9ydF9jZmdfcyBwcG9ydF9jZmc7CS8qICBwcG9ydCBjZmcgKi8KKworCS8qCisJICogRHluYW1pYyBmaWVsZCAtIGluZm8gZnJvbSBCRkEKKwkgKi8KKwllbnVtIGJmYV9wcG9ydF9zdGF0ZXMgCXBvcnRfc3RhdGU7CS8qICBjdXJyZW50IHBvcnQgc3RhdGUgKi8KKwllbnVtIGJmYV9wcG9ydF9zcGVlZCAJc3BlZWQ7CQkvKiAgY3VycmVudCBzcGVlZCAqLworCWVudW0gYmZhX3Bwb3J0X3RvcG9sb2d5IAl0b3BvbG9neTsJLyogIGN1cnJlbnQgdG9wb2xvZ3kgKi8KKwliZmFfYm9vbGVhbl90CQliZWFjb247CQkvKiAgY3VycmVudCBiZWFjb24gc3RhdHVzICovCisJYmZhX2Jvb2xlYW5fdAkJbGlua19lMmVfYmVhY29uOy8qICBzZXQgaWYgbGluayBiZWFjb24gb24gKi8KKwliZmFfYm9vbGVhbl90CQlwbG9nX2VuYWJsZWQ7CS8qICBzZXQgaWYgcG9ydGxvZyBpcyBlbmFibGVkKi8KKworCS8qCisJICogRHluYW1pYyBmaWVsZCAtIGluZm8gZnJvbSBGQ1MKKwkgKi8KKwl1MzIgICAgICAgIAlwaWQ7CQkvKiAgcG9ydCBJRCAqLworCWVudW0gYmZhX3Bwb3J0X3R5cGUgCXBvcnRfdHlwZTsJLyogIGN1cnJlbnQgdG9wb2xvZ3kgKi8KKwl1MzIgICAgICAgIAlsb29wYmFjazsJLyogIGV4dGVybmFsIGxvb3BiYWNrICovCisJdTMyCQlyc3ZkMTsKKwl1MzIJCXJzdmQyOwkJLyogIHBhZGRpbmcgZm9yIDY0IGJpdCAqLworfTsKKworLyoqCisgKiAJCUZDIFBvcnQgc3RhdGlzdGljcy4KKyAqLworc3RydWN0IGJmYV9wcG9ydF9mY19zdGF0c19zIHsKKwl1NjQgICAgICAgIHNlY3NfcmVzZXQ7CS8qICBzZWNvbmRzIHNpbmNlIHN0YXRzIGlzIHJlc2V0ICovCisJdTY0ICAgICAgICB0eF9mcmFtZXM7CS8qICB0cmFuc21pdHRlZCBmcmFtZXMgKi8KKwl1NjQgICAgICAgIHR4X3dvcmRzOwkvKiAgdHJhbnNtaXR0ZWQgd29yZHMgKi8KKwl1NjQgICAgICAgIHJ4X2ZyYW1lczsJLyogIHJlY2VpdmVkIGZyYW1lcyAqLworCXU2NCAgICAgICAgcnhfd29yZHM7CS8qICByZWNlaXZlZCB3b3JkcyAqLworCXU2NCAgICAgICAgbGlwX2NvdW50OwkvKiAgTElQcyBzZWVuICovCisJdTY0ICAgICAgICBub3NfY291bnQ7CS8qICBOT1MgY291bnQgKi8KKwl1NjQgICAgICAgIGVycm9yX2ZyYW1lczsJLyogIGVycm9yZWQgZnJhbWVzIChzZW50PykgKi8KKwl1NjQgICAgICAgIGRyb3BwZWRfZnJhbWVzOwkvKiAgZHJvcHBlZCBmcmFtZXMgKi8KKwl1NjQgICAgICAgIGxpbmtfZmFpbHVyZXM7CS8qICBsaW5rIGZhaWx1cmUgY291bnQgKi8KKwl1NjQgICAgICAgIGxvc3Nfb2Zfc3luY3M7CS8qICBsb3NzIG9mIHN5bmMgY291bnQgKi8KKwl1NjQgICAgICAgIGxvc3Nfb2Zfc2lnbmFsczsvKiAgbG9zcyBvZiBzaWduYWwgY291bnQgKi8KKwl1NjQgICAgICAgIHByaW1zZXFfZXJyczsJLyogIHByaW1pdGl2ZSBzZXF1ZW5jZSBwcm90b2NvbCAqLworCXU2NCAgICAgICAgYmFkX29zX2NvdW50OwkvKiAgaW52YWxpZCBvcmRlcmVkIHNldCAqLworCXU2NCAgICAgICAgZXJyX2VuY19vdXQ7CS8qICBFbmNvZGluZyBlcnJvciBvdXRzaWRlIGZyYW1lICovCisJdTY0ICAgICAgICBpbnZhbGlkX2NyY3M7CS8qICBmcmFtZXMgcmVjZWl2ZWQgd2l0aCBpbnZhbGlkIENSQyovCisJdTY0CXVuZGVyc2l6ZWRfZnJtOyAvKiAgdW5kZXJzaXplZCBmcmFtZXMgKi8KKwl1NjQJb3ZlcnNpemVkX2ZybTsJLyogIG92ZXJzaXplZCBmcmFtZXMgKi8KKwl1NjQJYmFkX2VvZl9mcm07CS8qICBmcmFtZXMgd2l0aCBiYWQgRU9GICovCisJc3RydWN0IGJmYV9xb3Nfc3RhdHNfcwlxb3Nfc3RhdHM7CS8qICBRb1Mgc3RhdGlzdGljcyAqLworfTsKKworLyoqCisgKiAJCUV0aCBQb3J0IHN0YXRpc3RpY3MuCisgKi8KK3N0cnVjdCBiZmFfcHBvcnRfZXRoX3N0YXRzX3MgeworCXU2NAlzZWNzX3Jlc2V0OwkvKiAgc2Vjb25kcyBzaW5jZSBzdGF0cyBpcyByZXNldCAqLworCXU2NAlmcmFtZV82NDsgICAgICAvKiAgYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NAlmcmFtZV82NV8xMjc7ICAgICAgLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NAlmcmFtZV8xMjhfMjU1OyAgICAgLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NAlmcmFtZV8yNTZfNTExOyAgICAgLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NAlmcmFtZV81MTJfMTAyMzsgICAgLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NAlmcmFtZV8xMDI0XzE1MTg7ICAgLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCXU2NAlmcmFtZV8xNTE5XzE1MjI7ICAgLyogYm90aCByeCBhbmQgdHggY291bnRlciAqLworCisJdTY0CXR4X2J5dGVzOworCXU2NAl0eF9wYWNrZXRzOworCXU2NAl0eF9tY2FzdF9wYWNrZXRzOworCXU2NAl0eF9iY2FzdF9wYWNrZXRzOworCXU2NAl0eF9jb250cm9sX2ZyYW1lOworCXU2NAl0eF9kcm9wOworCXU2NAl0eF9qYWJiZXI7CisJdTY0CXR4X2Zjc19lcnJvcjsKKwl1NjQJdHhfZnJhZ21lbnRzOworCisJdTY0CXJ4X2J5dGVzOworCXU2NAlyeF9wYWNrZXRzOworCXU2NAlyeF9tY2FzdF9wYWNrZXRzOworCXU2NAlyeF9iY2FzdF9wYWNrZXRzOworCXU2NAlyeF9jb250cm9sX2ZyYW1lczsKKwl1NjQJcnhfdW5rbm93bl9vcGNvZGU7CisJdTY0CXJ4X2Ryb3A7CisJdTY0CXJ4X2phYmJlcjsKKwl1NjQJcnhfZmNzX2Vycm9yOworCXU2NAlyeF9hbGlnbm1lbnRfZXJyb3I7CisJdTY0CXJ4X2ZyYW1lX2xlbmd0aF9lcnJvcjsKKwl1NjQJcnhfY29kZV9lcnJvcjsKKwl1NjQJcnhfZnJhZ21lbnRzOworCisJdTY0CXJ4X3BhdXNlOyAvKiBCUEMgKi8KKwl1NjQJcnhfemVyb19wYXVzZTsgLyogIEJQQyBQYXVzZSBjYW5jZWxsYXRpb24gKi8KKwl1NjQJdHhfcGF1c2U7ICAgICAgLyogQlBDICovCisJdTY0CXR4X3plcm9fcGF1c2U7IC8qICBCUEMgUGF1c2UgY2FuY2VsbGF0aW9uICovCisJdTY0CXJ4X2Zjb2VfcGF1c2U7IC8qIEJQQyAqLworCXU2NAlyeF9mY29lX3plcm9fcGF1c2U7IC8qICBCUEMgUGF1c2UgY2FuY2VsbGF0aW9uICovCisJdTY0CXR4X2Zjb2VfcGF1c2U7ICAgICAgLyogQlBDICovCisJdTY0CXR4X2Zjb2VfemVyb19wYXVzZTsgLyogIEJQQyBQYXVzZSBjYW5jZWxsYXRpb24gKi8KK307CisKKy8qKgorICogCQlQb3J0IHN0YXRpc3RpY3MuCisgKi8KK3VuaW9uIGJmYV9wcG9ydF9zdGF0c191IHsKKwlzdHJ1Y3QgYmZhX3Bwb3J0X2ZjX3N0YXRzX3MJZmM7CisJc3RydWN0IGJmYV9wcG9ydF9ldGhfc3RhdHNfcyAJZXRoOworfTsKKworLyoqCisgKiAgICAgICAgICAgICAgUG9ydCBGQ1AgbWFwcGluZ3MuCisgKi8KK3N0cnVjdCBiZmFfcHBvcnRfZmNwbWFwX3MgeworCWNoYXIJCW9zZGV2bmFtZVsyNTZdOworCXUzMglidXM7CisJdTMyICAgICAgICB0YXJnZXQ7CisJdTMyICAgICAgICBvc2x1bjsKKwl1MzIgICAgICAgIGZjaWQ7CisJd3duX3QgICAgICAgICAgIG53d247CisJd3duX3QgICAgICAgICAgIHB3d247CisJdTY0ICAgICAgICBmY3BsdW47CisJY2hhcgkJbHVpZFsyNTZdOworfTsKKworLyoqCisgKiAgICAgICAgICAgICAgUG9ydCBSTklEIGluZm8uCisgKi8KK3N0cnVjdCBiZmFfcHBvcnRfcm5pZF9zIHsKKwl3d25fdCAgICAgICAgICAgICB3d247CisJdTMyICAgICAgICAgIHVuaXR0eXBlOworCXUzMiAgICAgICAgICBwb3J0aWQ7CisJdTMyICAgICAgICAgIGF0dGFjaGVkX25vZGVzX251bTsKKwl1MTYgICAgICAgICAgaXBfdmVyc2lvbjsKKwl1MTYgICAgICAgICAgdWRwX3BvcnQ7CisJdTggICAgICAgICAgIGlwYWRkclsxNl07CisJdTE2ICAgICAgICAgIHJzdmQ7CisJdTE2ICAgICAgICAgIHRvcG9sb2d5ZGlzY292ZXJ5ZmxhZ3M7Cit9OworCisvKioKKyAqIAkJTGluayBzdGF0ZSBpbmZvcm1hdGlvbgorICovCitzdHJ1Y3QgYmZhX3Bwb3J0X2xpbmtfcyB7CisJdTggICAgICAgICBsaW5rc3RhdGU7CS8qICBMaW5rIHN0YXRlIGJmYV9wcG9ydF9saW5rc3RhdGUgKi8KKwl1OCAgICAgICAgIGxpbmtzdGF0ZV9yc247CS8qICBiZmFfcHBvcnRfbGlua3N0YXRlX3Jzbl90ICovCisJdTggICAgICAgICB0b3BvbG9neTsJLyogIFAyUC9MT09QIGJmYV9wcG9ydF90b3BvbG9neSAqLworCXU4ICAgICAgICAgc3BlZWQ7CQkvKiAgTGluayBzcGVlZCAoMS8yLzQvOCBHKSAqLworCXUzMiAgICAgICAgbGlua3N0YXRlX29wdDsJLyogIExpbmtzdGF0ZSBvcHRpb25hbCBkYXRhIChkZWJ1ZykgKi8KKwl1OCAgICAgICAgIHRydW5rZWQ7CS8qICBUcnVua2VkIG9yIG5vdCAoMSBvciAwKSAqLworCXU4ICAgICAgICAgcmVzdmRbM107CisJc3RydWN0IGJmYV9xb3NfYXR0cl9zICBxb3NfYXR0cjsgICAvKiBRb1MgQXR0cmlidXRlcyAqLworCXN0cnVjdCBiZmFfcW9zX3ZjX2F0dHJfcyBxb3NfdmNfYXR0cjsgIC8qICBWQyBpbmZvIGZyb20gRUxQICovCisJdW5pb24geworCQlzdHJ1Y3QgeworCQkJdTggICAgICAgICB0bWFzdGVyOy8qICBUcnVuayBNYXN0ZXIgb3IKKwkJCQkJCSAqICAgIG5vdCAoMSBvciAwKSAqLworCQkJdTggICAgICAgICB0bGlua3M7CS8qICBUcnVuayBsaW5rcyBiaXRtYXAKKwkJCQkJCSAqICAgIChsaW5rdXApICovCisJCQl1OCAgICAgICAgIHJlc3YxOwkvKiAgUmVzZXJ2ZWQgKi8KKwkJfSB0cnVua19pbmZvOworCisJCXN0cnVjdCB7CisJCQl1OCAgICAgICAgIG15YWxwYTsJICAgLyogIGFscGEgY2xhaW1lZCAqLworCQkJdTggICAgICAgICBsb2dpbl9yZXE7IC8qICBMb2dpbiByZXF1aXJlZCBvcgorCQkJCQkJICAgICogICAgbm90ICgxIG9yIDApICovCisJCQl1OCAgICAgICAgIGFscGFibV92YWw7LyogIGFscGEgYml0bWFwIHZhbGlkCisJCQkJCQkgICAgKiAgICBvciBub3QgKDEgb3IgMCkgKi8KKwkJCXN0cnVjdCBmY19hbHBhYm1fcyAgICAgYWxwYWJtOwkgICAvKiAgYWxwYSBiaXRtYXAgKi8KKwkJfSBsb29wX2luZm87CisJfSB0bDsKK307CisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX1BQT1JUX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcW9zLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19xb3MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hYWRiYWNkCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcW9zLmgKQEAgLTAsMCArMSw5OSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfUU9TX0hfXworI2RlZmluZSBfX0JGQV9ERUZTX1FPU19IX18KKworLyoqCisgKiBRb1Mgc3RhdGVzCisgKi8KK2VudW0gYmZhX3Fvc19zdGF0ZSB7CisJQkZBX1FPU19PTkxJTkUgPSAxLAkJLyogIFFvUyBpcyBvbmxpbmUgKi8KKwlCRkFfUU9TX09GRkxJTkUgPSAyLAkJLyogIFFvUyBpcyBvZmZsaW5lICovCit9OworCisKKy8qKgorICogUW9TICBQcmlvcml0eSBsZXZlbHMuCisgKi8KK2VudW0gYmZhX3Fvc19wcmlvcml0eSB7CisJQkZBX1FPU19VTktOT1dOID0gMCwKKwlCRkFfUU9TX0hJR0ggID0gMSwJLyogIFFvUyBQcmlvcml0eSBMZXZlbCBIaWdoICovCisJQkZBX1FPU19NRUQgID0gIDIsCS8qICBRb1MgUHJpb3JpdHkgTGV2ZWwgTWVkaXVtICovCisJQkZBX1FPU19MT1cgID0gIDMsCS8qICBRb1MgUHJpb3JpdHkgTGV2ZWwgTG93ICovCit9OworCisKKy8qKgorICogUW9TICBiYW5kd2lkdGggYWxsb2NhdGlvbiBmb3IgZWFjaCBwcmlvcml0eSBsZXZlbAorICovCitlbnVtIGJmYV9xb3NfYndfYWxsb2MgeworCUJGQV9RT1NfQldfSElHSCAgPSA2MCwJLyogIGJhbmR3aWR0aCBhbGxvY2F0aW9uIGZvciBIaWdoICovCisJQkZBX1FPU19CV19NRUQgID0gIDMwLAkvKiAgYmFuZHdpZHRoIGFsbG9jYXRpb24gZm9yIE1lZGl1bSAqLworCUJGQV9RT1NfQldfTE9XICA9ICAxMCwJLyogIGJhbmR3aWR0aCBhbGxvY2F0aW9uIGZvciBMb3cgKi8KK307CisKKy8qKgorICogUW9TIGF0dHJpYnV0ZSByZXR1cm5lZCBpbiBRb1MgUXVlcnkKKyAqLworc3RydWN0IGJmYV9xb3NfYXR0cl9zIHsKKwllbnVtIGJmYV9xb3Nfc3RhdGUgc3RhdGU7CQkvKiAgUW9TIGN1cnJlbnQgc3RhdGUgKi8KKwl1MzIgIHRvdGFsX2JiX2NyOyAgCSAJLyogIFRvdGFsIEJCIENyZWRpdHMgKi8KK307CisKKy8qKgorICogVGhlc2UgZmllbGRzIHNob3VsZCBiZSBkaXNwbGF5ZWQgb25seSBmcm9tIHRoZSBDTEkuCisgKiBUaGVyZSB3aWxsIGJlIGEgc2VwYXJhdGUgQkZBTCBBUEkgKGdldF9xb3NfdmNfYXR0ciA/KQorICogdG8gcmV0cmlldmUgdGhpcy4KKyAqCisgKi8KKyNkZWZpbmUgIEJGQV9RT1NfTUFYX1ZDICAxNgorCitzdHJ1Y3QgYmZhX3Fvc192Y19pbmZvX3MgeworCXU4IHZjX2NyZWRpdDsKKwl1OCBib3Jyb3dfY3JlZGl0OworCXU4IHByaW9yaXR5OworCXU4IHJlc3ZkOworfTsKKworc3RydWN0IGJmYV9xb3NfdmNfYXR0cl9zIHsKKwl1MTYgIHRvdGFsX3ZjX2NvdW50OyAgICAgICAgICAgICAgICAgICAgLyogIFRvdGFsIFZDIENvdW50ICovCisJdTE2ICBzaGFyZWRfY3JlZGl0OworCXUzMiAgZWxwX29wbW9kZV9mbGFnczsKKwlzdHJ1Y3QgYmZhX3Fvc192Y19pbmZvX3MgdmNfaW5mb1tCRkFfUU9TX01BWF9WQ107ICAvKiAgIGFzIG1hbnkgYXMKKwkJCQkJCQkgICAgKiB0b3RhbF92Y19jb3VudCAqLworfTsKKworLyoqCisgKiBRb1Mgc3RhdGlzdGljcworICovCitzdHJ1Y3QgYmZhX3Fvc19zdGF0c19zIHsKKwl1MzIJZmxvZ2lfc2VudDsgCQkvKiAgUW9TIEZsb2dpIHNlbnQgKi8KKwl1MzIJZmxvZ2lfYWNjX3JlY3ZkOwkvKiAgUW9TIEZsb2dpIEFjYyByZWNlaXZlZCAqLworCXUzMglmbG9naV9yanRfcmVjdmQ7IC8qICBRb1MgRmxvZ2kgcmVqZWN0cyByZWNlaXZlZCAqLworCXUzMglmbG9naV9yZXRyaWVzOwkJLyogIFFvUyBGbG9naSByZXRyaWVzICovCisKKwl1MzIJZWxwX3JlY3ZkOyAJICAgCS8qICBRb1MgRUxQIHJlY2VpdmVkICovCisJdTMyCWVscF9hY2NlcHRlZDsgICAgICAgLyogIFFvUyBFTFAgQWNjZXB0ZWQgKi8KKwl1MzIJZWxwX3JlamVjdGVkOyAgICAgICAvKiAgUW9TIEVMUCByZWplY3RlZCAqLworCXUzMgllbHBfZHJvcHBlZDsgICAgICAgIC8qICBRb1MgRUxQIGRyb3BwZWQgICovCisKKwl1MzIJcW9zX3JzY25fcmVjdmQ7ICAgICAvKiAgUW9TIFJTQ04gcmVjZWl2ZWQgKi8KKwl1MzIJcnN2ZDsgCQkvKiBwYWRkaW5nIGZvciA2NCBiaXQgYWxpZ25tZW50ICovCit9OworCisjZW5kaWYgLyogX19CRkFfREVGU19RT1NfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19ycG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcnBvcnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMGFmNTlkCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfcnBvcnQuaApAQCAtMCwwICsxLDE5OSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfUlBPUlRfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfUlBPUlRfSF9fCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvdHlwZXMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3Bwb3J0Lmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wb3J0Lmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19xb3MuaD4KKworLyoqCisgKiBGQ1MgcmVtb3RlIHBvcnQgc3RhdGVzCisgKi8KK2VudW0gYmZhX3Jwb3J0X3N0YXRlIHsKKwlCRkFfUlBPUlRfVU5JTklUIAk9IDAsCS8qICBQT1JUIGlzIG5vdCB5ZXQgaW5pdGlhbGl6ZWQgKi8KKwlCRkFfUlBPUlRfT0ZGTElORSAJPSAxLAkvKiAgcnBvcnQgaXMgb2ZmbGluZSAqLworCUJGQV9SUE9SVF9QTE9HSSAJPSAyLAkvKiAgUExPR0kgdG8gcnBvcnQgaXMgaW4gcHJvZ3Jlc3MgKi8KKwlCRkFfUlBPUlRfT05MSU5FIAk9IDMsCS8qICBsb2dpbiB0byBycG9ydCBpcyBjb21wbGV0ZSAqLworCUJGQV9SUE9SVF9QTE9HSV9SRVRSWSAJPSA0LAkvKiAgcmV0cnlpbmcgbG9naW4gdG8gcnBvcnQgKi8KKwlCRkFfUlBPUlRfTlNRVUVSWSAJPSA1LAkvKiAgbmFtZXNlcnZlciBxdWVyeSAqLworCUJGQV9SUE9SVF9BRElTQyAJPSA2LAkvKiAgQURJU0MgYXV0aGVudGljYXRpb24gKi8KKwlCRkFfUlBPUlRfTE9HTyAJCT0gNywJLyogIGxvZ2dpbmcgb3V0IHdpdGggcnBvcnQgKi8KKwlCRkFfUlBPUlRfTE9HT1JDViAJPSA4LAkvKiAgaGFuZGxpbmcgTE9HTyBmcm9tIHJwb3J0ICovCisJQkZBX1JQT1JUX05TRElTQyAJPSA5LAkvKiAgcmUtZGlzY292ZXIgcnBvcnQgKi8KK307CisKKy8qKgorICogIFJwb3J0IFNjc2kgRnVuY3Rpb24gOiBJbml0aWF0b3IvVGFyZ2V0LgorICovCitlbnVtIGJmYV9ycG9ydF9mdW5jdGlvbiB7CisJQkZBX1JQT1JUX0lOSVRJQVRPUiAJPSAweDAxLAkvKiAgU0NTSSBJbml0aWF0b3IJKi8KKwlCRkFfUlBPUlRfVEFSR0VUIAk9IDB4MDIsCS8qICBTQ1NJIFRhcmdldAkqLworfTsKKworLyoqCisgKiBwb3J0L25vZGUgc3ltYm9saWMgbmFtZXMgZm9yIHJwb3J0CisgKi8KKyNkZWZpbmUgQkZBX1JQT1JUX1NZTU5BTUVfTUFYTEVOCTI1NQorc3RydWN0IGJmYV9ycG9ydF9zeW1uYW1lX3MgeworCWNoYXIgICAgICAgICAgICBzeW1uYW1lW0JGQV9SUE9SVF9TWU1OQU1FX01BWExFTl07Cit9OworCitzdHJ1Y3QgYmZhX3Jwb3J0X2hhbF9zdGF0c19zIHsKKwl1MzIgICAgICAgIHNtX3VuX2NyOwkgICAgLyogIHVuaW5pdDogY3JlYXRlIGV2ZW50cyAgICAgICovCisJdTMyICAgICAgICBzbV91bl91bmV4cDsJICAgIC8qICB1bmluaXQ6IGV4Y2VwdGlvbiBldmVudHMgICAqLworCXUzMiAgICAgICAgc21fY3Jfb247CSAgICAvKiAgY3JlYXRlZDogb25saW5lIGV2ZW50cyAgICAgKi8KKwl1MzIgICAgICAgIHNtX2NyX2RlbDsJICAgIC8qICBjcmVhdGVkOiBkZWxldGUgZXZlbnRzICAgICAqLworCXUzMiAgICAgICAgc21fY3JfaHdmOwkgICAgLyogIGNyZWF0ZWQ6IElPQyBkb3duICAgICAgICAgICovCisJdTMyICAgICAgICBzbV9jcl91bmV4cDsJICAgIC8qICBjcmVhdGVkOiBleGNlcHRpb24gZXZlbnRzICAqLworCXUzMiAgICAgICAgc21fZndjX3JzcDsJICAgIC8qICBmdyBjcmVhdGU6IGYvdyByZXNwb25zZXMgICAqLworCXUzMiAgICAgICAgc21fZndjX2RlbDsJICAgIC8qICBmdyBjcmVhdGU6IGRlbGV0ZSBldmVudHMgICAqLworCXUzMiAgICAgICAgc21fZndjX29mZjsJICAgIC8qICBmdyBjcmVhdGU6IG9mZmxpbmUgZXZlbnRzICAqLworCXUzMiAgICAgICAgc21fZndjX2h3ZjsJICAgIC8qICBmdyBjcmVhdGU6IElPQyBkb3duICAgICAgICAqLworCXUzMiAgICAgICAgc21fZndjX3VuZXhwOwkgICAgLyogIGZ3IGNyZWF0ZTogZXhjZXB0aW9uIGV2ZW50cyovCisJdTMyICAgICAgICBzbV9vbl9vZmY7CSAgICAvKiAgb25saW5lOiBvZmZsaW5lIGV2ZW50cyAgICAgKi8KKwl1MzIgICAgICAgIHNtX29uX2RlbDsJICAgIC8qICBvbmxpbmU6IGRlbGV0ZSBldmVudHMgICAgICAqLworCXUzMiAgICAgICAgc21fb25faHdmOwkgICAgLyogIG9ubGluZTogSU9DIGRvd24gZXZlbnRzICAgICovCisJdTMyICAgICAgICBzbV9vbl91bmV4cDsJICAgIC8qICBvbmxpbmU6IGV4Y2VwdGlvbiBldmVudHMgICAqLworCXUzMiAgICAgICAgc21fZndkX3JzcDsJICAgIC8qICBmdyBkZWxldGU6IGZ3IHJlc3BvbnNlcyAgICAqLworCXUzMiAgICAgICAgc21fZndkX2RlbDsJICAgIC8qICBmdyBkZWxldGU6IGRlbGV0ZSBldmVudHMgICAqLworCXUzMiAgICAgICAgc21fZndkX2h3ZjsJICAgIC8qICBmdyBkZWxldGU6IElPQyBkb3duIGV2ZW50cyAqLworCXUzMiAgICAgICAgc21fZndkX3VuZXhwOwkgICAgLyogIGZ3IGRlbGV0ZTogZXhjZXB0aW9uIGV2ZW50cyovCisJdTMyICAgICAgICBzbV9vZmZfZGVsOwkgICAgLyogIG9mZmxpbmU6IGRlbGV0ZSBldmVudHMgICAgICovCisJdTMyICAgICAgICBzbV9vZmZfb247CSAgICAvKiAgb2ZmbGluZTogb25saW5lIGV2ZW50cyAgICAgKi8KKwl1MzIgICAgICAgIHNtX29mZl9od2Y7CSAgICAvKiAgb2ZmbGluZTogSU9DIGRvd24gZXZlbnRzICAgKi8KKwl1MzIgICAgICAgIHNtX29mZl91bmV4cDsJICAgIC8qICBvZmZsaW5lOiBleGNlcHRpb24gZXZlbnRzICAqLworCXUzMiAgICAgICAgc21fZGVsX2Z3cnNwOwkgICAgLyogIGRlbGV0ZTogZncgcmVzcG9uc2VzICAgICAgICovCisJdTMyICAgICAgICBzbV9kZWxfaHdmOwkgICAgLyogIGRlbGV0ZTogSU9DIGRvd24gZXZlbnRzICAgICovCisJdTMyICAgICAgICBzbV9kZWxfdW5leHA7CSAgICAvKiAgZGVsZXRlOiBleGNlcHRpb24gZXZlbnRzICAgKi8KKwl1MzIgICAgICAgIHNtX2RlbHBfZndyc3A7CSAgICAvKiAgZGVsZXRlIHBlbmQ6IGZ3IHJlc3BvbnNlcyAgKi8KKwl1MzIgICAgICAgIHNtX2RlbHBfaHdmOwkgICAgLyogIGRlbGV0ZSBwZW5kOiBJT0MgZG93bnMgICAgICovCisJdTMyICAgICAgICBzbV9kZWxwX3VuZXhwOwkgICAgLyogIGRlbGV0ZSBwZW5kOiBleGNlcHRpb25zICAgICovCisJdTMyICAgICAgICBzbV9vZmZwX2Z3cnNwOwkgICAgLyogIG9mZi1wZW5kaW5nOiBmdyByZXNwb25zZXMgICovCisJdTMyICAgICAgICBzbV9vZmZwX2RlbDsJICAgIC8qICBvZmYtcGVuZGluZzogZGVsZXRlcyAgICAgICAqLworCXUzMiAgICAgICAgc21fb2ZmcF9od2Y7CSAgICAvKiAgb2ZmLXBlbmRpbmc6IElPQyBkb3ducyAgICAgKi8KKwl1MzIgICAgICAgIHNtX29mZnBfdW5leHA7CSAgICAvKiAgb2ZmLXBlbmRpbmc6IGV4Y2VwdGlvbnMgICAgKi8KKwl1MzIgICAgICAgIHNtX2lvY2Rfb2ZmOwkgICAgLyogIElPQyBkb3duOiBvZmZsaW5lIGV2ZW50cyAgICovCisJdTMyICAgICAgICBzbV9pb2NkX2RlbDsJICAgIC8qICBJT0MgZG93bjogZGVsZXRlIGV2ZW50cyAgICAqLworCXUzMiAgICAgICAgc21faW9jZF9vbjsJICAgIC8qICBJT0MgZG93bjogb25saW5lIGV2ZW50cyAgICAqLworCXUzMiAgICAgICAgc21faW9jZF91bmV4cDsJICAgIC8qICBJT0MgZG93bjogZXhjZXB0aW9ucyAgICAgICAqLworCXUzMiAgICAgICAgcnN2ZDsKK307CisKKy8qKgorICogRkNTIHJlbW90ZSBwb3J0IHN0YXRpc3RpY3MKKyAqLworc3RydWN0IGJmYV9ycG9ydF9zdGF0c19zIHsKKwl1MzIgICAgICAgIG9mZmxpbmVzOyAgICAgICAgICAgLyogIHJlbW90ZSBwb3J0IG9mZmxpbmUgY291bnQgICovCisJdTMyICAgICAgICBvbmxpbmVzOyAgICAgICAgICAgIC8qICByZW1vdGUgcG9ydCBvbmxpbmUgY291bnQgICAqLworCXUzMiAgICAgICAgcnNjbnM7ICAgICAgICAgICAgICAvKiAgUlNDTiBhZmZlY3RpbmcgcnBvcnQgICAgICAgKi8KKwl1MzIgICAgICAgIHBsb2dpczsJCSAgICAvKiAgcGxvZ2lzIHNlbnQgICAgICAgICAgICAgICAgKi8KKwl1MzIgICAgICAgIHBsb2dpX2FjY3M7CSAgICAvKiAgcGxvZ2kgYWNjZXB0cyAgICAgICAgICAgICAgKi8KKwl1MzIgICAgICAgIHBsb2dpX3RpbWVvdXRzOwkgICAgLyogIHBsb2dpIHRpbWVvdXRzICAgICAgICAgICAgICovCisJdTMyICAgICAgICBwbG9naV9yZWplY3RzOwkgICAgLyogIHJjdmQgcGxvZ2kgcmVqZWN0cyAgICAgICAgICovCisJdTMyICAgICAgICBwbG9naV9mYWlsZWQ7CSAgICAvKiAgbG9jYWwgZmFpbHVyZSAgICAgICAgICAgICAgKi8KKwl1MzIgICAgICAgIHBsb2dpX3JjdmQ7CSAgICAvKiAgcGxvZ2lzIHJjdmQgICAgICAgICAgICAgICAgKi8KKwl1MzIgICAgICAgIHBybGlfcmN2ZDsgICAgICAgICAgLyogIGluYm91bmQgUFJMSXMgICAgICAgICAgICAgICovCisJdTMyICAgICAgICBhZGlzY19yY3ZkOyAgICAgICAgIC8qICBBRElTQ3MgcmVjZWl2ZWQgICAgICAgICAgICAqLworCXUzMiAgICAgICAgYWRpc2NfcmVqZWN0czsgICAgICAvKiAgcmVjdmQgIEFESVNDIHJlamVjdHMgICAgICAgKi8KKwl1MzIgICAgICAgIGFkaXNjX3NlbnQ7ICAgICAgICAgLyogIEFESVNDIHJlcXVlc3RzIHNlbnQgICAgICAgICovCisJdTMyICAgICAgICBhZGlzY19hY2NzOyAgICAgICAgIC8qICBBRElTQyBhY2NlcHRlZCBieSBycG9ydCAgICAqLworCXUzMiAgICAgICAgYWRpc2NfZmFpbGVkOyAgICAgICAvKiAgQURJU0MgZmFpbGVkIChubyByZXNwb25zZSkgKi8KKwl1MzIgICAgICAgIGFkaXNjX3JlamVjdGVkOyAgICAgLyogIEFESVNDIHJlamVjdGVkIGJ5IHVzICAgICovCisJdTMyICAgICAgICBsb2dvczsgICAgICAgICAgICAgIC8qICBsb2dvcyBzZW50ICAgICAgICAgICAgICAgICAqLworCXUzMiAgICAgICAgbG9nb19hY2NzOyAgICAgICAgICAvKiAgTE9HTyBhY2NlcHRzIGZyb20gcnBvcnQgICAgKi8KKwl1MzIgICAgICAgIGxvZ29fZmFpbGVkOyAgICAgICAgLyogIExPR08gZmFpbHVyZXMgICAgICAgICAgICAgICovCisJdTMyICAgICAgICBsb2dvX3JlamVjdGVkOyAgICAgIC8qICBMT0dPIHJlamVjdHMgZnJvbSBycG9ydCAgICAqLworCXUzMiAgICAgICAgbG9nb19yY3ZkOyAgICAgICAgICAvKiAgTE9HTyBmcm9tIHJlbW90ZSBwb3J0ICAgICAgKi8KKworCXUzMiAgICAgICAgcnBzY19yY3ZkOyAgICAgICAgIC8qICBSUFNDIHJlY2VpdmVkICAgICAgICAgICAgKi8KKwl1MzIgICAgICAgIHJwc2NfcmVqZWN0czsgICAgICAvKiAgcmVjdmQgIFJQU0MgcmVqZWN0cyAgICAgICAqLworCXUzMiAgICAgICAgcnBzY19zZW50OyAgICAgICAgIC8qICBSUFNDIHJlcXVlc3RzIHNlbnQgICAgICAgICovCisJdTMyICAgICAgICBycHNjX2FjY3M7ICAgICAgICAgLyogIFJQU0MgYWNjZXB0ZWQgYnkgcnBvcnQgICAgKi8KKwl1MzIgICAgICAgIHJwc2NfZmFpbGVkOyAgICAgICAvKiAgUlBTQyBmYWlsZWQgKG5vIHJlc3BvbnNlKSAqLworCXUzMiAgICAgICAgcnBzY19yZWplY3RlZDsgICAgIC8qICBSUFNDIHJlamVjdGVkIGJ5IHVzICAgICovCisKKwl1MzIgICAgICAgIHJzdmQ7CisJc3RydWN0IGJmYV9ycG9ydF9oYWxfc3RhdHNfcwloYWxfc3RhdHM7ICAvKiAgQkZBIHJwb3J0IHN0YXRzICAgICovCit9OworCisvKioKKyAqICBScG9ydCdzIFFvUyBhdHRyaWJ1dGVzCisgKi8KK3N0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyB7CisJZW51bSBiZmFfcW9zX3ByaW9yaXR5IHFvc19wcmlvcml0eTsgIC8qICBycG9ydCdzIFFvUyBwcmlvcml0eSAgICovCisJdTMyCSAgICAgICBxb3NfZmxvd19pZDsJICAvKiAgUW9TIGZsb3cgSWQJICovCit9OworCisvKioKKyAqIEZDUyByZW1vdGUgcG9ydCBhdHRyaWJ1dGVzIHJldHVybmVkIGluIHF1ZXJpZXMKKyAqLworc3RydWN0IGJmYV9ycG9ydF9hdHRyX3MgeworCXd3bl90ICAgICAgICAgICAJbnd3bjsJLyogIG5vZGUgd3duICovCisJd3duX3QgICAgICAgICAgIAlwd3duOwkvKiAgcG9ydCB3d24gKi8KKwllbnVtIGZjX2NvcyBjb3Nfc3VwcG9ydGVkOwkvKiAgc3VwcG9ydGVkIGNsYXNzIG9mIHNlcnZpY2VzICovCisJdTMyICAgICAgICAJcGlkOwkvKiAgcG9ydCBJRCAqLworCXUzMiAgICAgICAgCWRmX3N6OwkvKiAgTWF4IHBheWxvYWQgc2l6ZSAqLworCWVudW0gYmZhX3Jwb3J0X3N0YXRlIAlzdGF0ZTsJLyogIFJwb3J0IFN0YXRlIG1hY2hpbmUgc3RhdGUgKi8KKwllbnVtIGZjX2NvcyAgICAgICAgCWZjX2NvczsJLyogIEZDIGNsYXNzZXMgb2Ygc2VydmljZXMgKi8KKwliZmFfYm9vbGVhbl90ICAgCWNpc2M7CS8qICBDSVNDIGNhcGFibGUgZGV2aWNlICovCisJc3RydWN0IGJmYV9ycG9ydF9zeW1uYW1lX3Mgc3ltbmFtZTsgLyogIFN5bWJvbGljIE5hbWUgKi8KKwllbnVtIGJmYV9ycG9ydF9mdW5jdGlvbglzY3NpX2Z1bmN0aW9uOyAvKiAgSW5pdGlhdG9yL1RhcmdldCAqLworCXN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyBxb3NfYXR0cjsgLyogIHFvcyBhdHRyaWJ1dGVzICAqLworCWVudW0gYmZhX3Bwb3J0X3NwZWVkIGN1cnJfc3BlZWQ7ICAgLyogIG9wZXJhdGluZyBzcGVlZCBnb3QgZnJvbQorCQkJCQkgICAgKiBSUFNDIEVMUy4gVU5LTk9XTiwgaWYgUlBTQworCQkJCQkgICAgKiBpcyBub3Qgc3VwcG9ydGVkICovCisJYmZhX2Jvb2xlYW5fdCAJdHJsX2VuZm9yY2VkOwkvKiAgVFJMIGVuZm9yY2VkID8gVFJVRS9GQUxTRSAqLworCWVudW0gYmZhX3Bwb3J0X3NwZWVkCWFzc2lnbmVkX3NwZWVkOwkvKiBTcGVlZCBhc3NpZ25lZCBieSB0aGUgdXNlci4KKwkJCQkJCSAqIHdpbGwgYmUgdXNlZCBpZiBSUFNDIGlzIG5vdAorCQkJCQkJICogc3VwcG9ydGVkIGJ5IHRoZSBycG9ydCAqLworfTsKKworI2RlZmluZSBiZmFfcnBvcnRfYWVuX3Fvc19kYXRhX3Qgc3RydWN0IGJmYV9ycG9ydF9xb3NfYXR0cl9zCisKKy8qKgorICogQkZBIHJlbW90ZSBwb3J0IGV2ZW50cworICogQXJndW1lbnRzIGJlbG93IGFyZSBpbiBCRkFMIGNvbnRleHQgZnJvbSBNZ210CisgKiBCRkFfUlBPUlRfQUVOX09OTElORTogICAgW2luXTogbHB3d24JW291dF06IHZmX2lkLCBscHd3biwgcnB3d24KKyAqIEJGQV9SUE9SVF9BRU5fT0ZGTElORTogICBbaW5dOiBscHd3biBbb3V0XTogdmZfaWQsIGxwd3duLCBycHd3bgorICogQkZBX1JQT1JUX0FFTl9ESVNDT05ORUNUOltpbl06IGxwd3duIFtvdXRdOiB2Zl9pZCwgbHB3d24sIHJwd3duCisgKiBCRkFfUlBPUlRfQUVOX1FPU19QUklPOiAgW2luXTogbHB3d24gW291dF06IHZmX2lkLCBscHd3biwgcnB3d24sIHByaW8KKyAqIEJGQV9SUE9SVF9BRU5fUU9TX0ZMT1dJRDpbaW5dOiBscHd3biBbb3V0XTogdmZfaWQsIGxwd3duLCBycHd3biwgZmxvd19pZAorICovCitlbnVtIGJmYV9ycG9ydF9hZW5fZXZlbnQgeworCUJGQV9SUE9SVF9BRU5fT05MSU5FICAgICAgPSAxLAkvKiAgUlBvcnQgb25saW5lIGV2ZW50ICovCisJQkZBX1JQT1JUX0FFTl9PRkZMSU5FICAgICA9IDIsCS8qICBSUG9ydCBvZmZsaW5lIGV2ZW50ICovCisJQkZBX1JQT1JUX0FFTl9ESVNDT05ORUNUICA9IDMsCS8qICBSUG9ydCBkaXNjb25uZWN0IGV2ZW50ICovCisJQkZBX1JQT1JUX0FFTl9RT1NfUFJJTyAgICA9IDQsCS8qICBRT1MgcHJpb3JpdHkgY2hhbmdlIGV2ZW50ICovCisJQkZBX1JQT1JUX0FFTl9RT1NfRkxPV0lEICA9IDUsCS8qICBRT1MgZmxvdyBJZCBjaGFuZ2UgZXZlbnQgKi8KK307CisKK3N0cnVjdCBiZmFfcnBvcnRfYWVuX2RhdGFfcyB7CisJdTE2ICAgICAgICB2Zl9pZDsJLyogIHZmX2lkIG9mIHRoaXMgbG9naWNhbCBwb3J0ICovCisJdTE2ICAgICAgICByc3ZkWzNdOworCXd3bl90ICAgICAgICAgICBwcHd3bjsJLyogIFdXTiBvZiBpdHMgcGh5c2ljYWwgcG9ydCAqLworCXd3bl90ICAgICAgICAgICBscHd3bjsJLyogIFdXTiBvZiB0aGlzIGxvZ2ljYWwgcG9ydCAqLworCXd3bl90ICAgICAgICAgICBycHd3bjsJLyogIFdXTiBvZiB0aGlzIHJlbW90ZSBwb3J0ICovCisJdW5pb24geworCQliZmFfcnBvcnRfYWVuX3Fvc19kYXRhX3QgcW9zOworCX0gcHJpdjsKK307CisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX1JQT1JUX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfc3RhdHVzLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc19zdGF0dXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jZGNlYWViCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfc3RhdHVzLmgKQEAgLTAsMCArMSwyNTUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRkFfREVGU19TVEFUVVNfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfU1RBVFVTX0hfXworCisvKioKKyAqIEFQSSBzdGF0dXMgcmV0dXJuIHZhbHVlcworICoKKyAqIE5PVEU6IFRoZSBlcnJvciBtc2dzIGFyZSBhdXRvIGdlbmVyYXRlZCBmcm9tIHRoZSBjb21tZW50cy4gT25seSBzaW5nZSBsaW5lCisgKiBjb21tZW50cyBhcmUgc3VwcG9ydGVkCisgKi8KK2VudW0gYmZhX3N0YXR1cyB7CisJQkZBX1NUQVRVU19PSyAJCT0gMCwJLyogIFN1Y2Nlc3MgKi8KKwlCRkFfU1RBVFVTX0ZBSUxFRCAJPSAxLAkvKiAgT3BlcmF0aW9uIGZhaWxlZCAqLworCUJGQV9TVEFUVVNfRUlOVkFMIAk9IDIsCS8qICBJbnZhbGlkIHBhcmFtcyBDaGVjayBpbnB1dAorCQkJCQkgKiBwYXJhbWV0ZXJzICovCisJQkZBX1NUQVRVU19FTk9NRU0gCT0gMywJLyogIE91dCBvZiByZXNvdXJjZXMgKi8KKwlCRkFfU1RBVFVTX0VOT1NZUyAJPSA0LAkvKiAgRnVuY3Rpb24gbm90IGltcGxlbWVudGVkICovCisJQkZBX1NUQVRVU19FVElNRVIgCT0gNSwJLyogIFRpbWVyIGV4cGlyZWQgLSBSZXRyeSwgaWYKKwkJCQkJICogcGVyc2lzdHMsIGNvbnRhY3Qgc3VwcG9ydCAqLworCUJGQV9TVEFUVVNfRVBST1RPQ09MIAk9IDYsCS8qICBQcm90b2NvbCBlcnJvciAqLworCUJGQV9TVEFUVVNfRU5PRkNQT1JUUyAJPSA3LAkvKiAgTm8gRkMgcG9ydHMgcmVzb3VyY2VzICovCisJQkZBX1NUQVRVU19OT0ZMQVNIIAk9IDgsCS8qICBGbGFzaCBub3QgcHJlc2VudCAqLworCUJGQV9TVEFUVVNfQkFERkxBU0ggCT0gOSwJLyogIEZsYXNoIGlzIGNvcnJ1cHRlZCBvciBiYWQgKi8KKwlCRkFfU1RBVFVTX1NGUF9VTlNVUFAgCT0gMTAsCS8qICBVbnN1cHBvcnRlZCBTRlAgLSBSZXBsYWNlIFNGUCAqLworCUJGQV9TVEFUVVNfVU5LTk9XTl9WRklEID0gMTEsCS8qICBWRl9JRCBub3QgZm91bmQgKi8KKwlCRkFfU1RBVFVTX0RBVEFDT1JSVVBURUQgPSAxMiwJLyogIERpYWcgcmV0dXJuZWQgZGF0YSBjb3JydXB0ZWQKKwkJCQkJICogY29udGFjdCBzdXBwb3J0ICovCisJQkZBX1NUQVRVU19ERVZCVVNZIAk9IDEzLAkvKiAgRGV2aWNlIGJ1c3kgLSBSZXRyeSBvcGVyYXRpb24gKi8KKwlCRkFfU1RBVFVTX0FCT1JURUQgCT0gMTQsCS8qICBPcGVyYXRpb24gYWJvcnRlZCAqLworCUJGQV9TVEFUVVNfTk9ERVYgCT0gMTUsCS8qICBEZXYgaXMgbm90IHByZXNlbnQgKi8KKwlCRkFfU1RBVFVTX0hETUFfRkFJTEVEIAk9IDE2LAkvKiAgSG9zdCBkbWEgZmFpbGVkIGNvbnRhY3Qgc3VwcG9ydCAqLworCUJGQV9TVEFUVVNfRkxBU0hfQkFEX0xFTiA9IDE3LAkvKiAgRmxhc2ggYmFkIGxlbmd0aCAqLworCUJGQV9TVEFUVVNfVU5LTk9XTl9MV1dOID0gMTgsCS8qICBMUE9SVCBQV1dOIG5vdCBmb3VuZCAqLworCUJGQV9TVEFUVVNfVU5LTk9XTl9SV1dOID0gMTksCS8qICBSUE9SVCBQV1dOIG5vdCBmb3VuZCAqLworCUJGQV9TVEFUVVNfRkNQVF9MU19SSlQgCT0gMjAsCS8qICBHb3QgTFNfUkpUIGZvciBGQyBQYXNzCisJCQkJCSAqIHRocm91Z2ggUmVxICovCisJQkZBX1NUQVRVU19WUE9SVF9FWElTVFMgPSAyMSwJLyogIFZQT1JUIGFscmVhZHkgZXhpc3RzICovCisJQkZBX1NUQVRVU19WUE9SVF9NQVggCT0gMjIsCS8qICBSZWFjaGVkIG1heCBWUE9SVCBzdXBwb3J0ZWQKKwkJCQkJICogbGltaXQgKi8KKwlCRkFfU1RBVFVTX1VOU1VQUF9TUEVFRCA9IDIzLAkvKiAgSW52YWxpZCBTcGVlZCBDaGVjayBzcGVlZAorCQkJCQkgKiBzZXR0aW5nICovCisJQkZBX1NUQVRVU19JTlZMRF9ERlNaIAk9IDI0LAkvKiAgSW52YWxpZCBNYXggZGF0YSBmaWVsZCBzaXplICovCisJQkZBX1NUQVRVU19DTkZHX0ZBSUxFRCAJPSAyNSwJLyogIFNldHRpbmcgY2FuIG5vdCBiZSBwZXJzaXN0ZWQgKi8KKwlCRkFfU1RBVFVTX0NNRF9OT1RTVVBQIAk9IDI2LAkvKiAgQ29tbWFuZC9BUEkgbm90IHN1cHBvcnRlZCAqLworCUJGQV9TVEFUVVNfTk9fQURBUFRFUiAJPSAyNywJLyogIE5vIEJyb2NhZGUgQWRhcHRlciBGb3VuZCAqLworCUJGQV9TVEFUVVNfTElOS0RPV04gCT0gMjgsCS8qICBMaW5rIGlzIGRvd24gLSBDaGVjayBvciByZXBsYWNlCisJCQkJCSAqIFNGUC9jYWJsZSAqLworCUJGQV9TVEFUVVNfRkFCUklDX1JKVCAJPSAyOSwJLyogIFJlamVjdCBmcm9tIGF0dGFjaGVkIGZhYnJpYyAqLworCUJGQV9TVEFUVVNfVU5LTk9XTl9WV1dOID0gMzAsCS8qICBWUE9SVCBQV1dOIG5vdCBmb3VuZCAqLworCUJGQV9TVEFUVVNfTlNMT0dJTl9GQUlMRUQgPSAzMSwJLyogIE5hbWVzZXJ2ZXIgbG9naW4gZmFpbGVkICovCisJQkZBX1NUQVRVU19OT19SUE9SVFMgCT0gMzIsCS8qICBObyByZW1vdGUgcG9ydHMgZm91bmQgKi8KKwlCRkFfU1RBVFVTX05TUVVFUllfRkFJTEVEID0gMzMsCS8qICBOYW1lc2VydmVyIHF1ZXJ5IGZhaWxlZCAqLworCUJGQV9TVEFUVVNfUE9SVF9PRkZMSU5FID0gMzQsCS8qICBQb3J0IGlzIG5vdCBvbmxpbmUgKi8KKwlCRkFfU1RBVFVTX1JQT1JUX09GRkxJTkUgPSAzNSwJLyogIFJQT1JUIGlzIG5vdCBvbmxpbmUgKi8KKwlCRkFfU1RBVFVTX1RHVE9QRU5fRkFJTEVEID0gMzYsCS8qICBSZW1vdGUgU0NTSSB0YXJnZXQgb3BlbiBmYWlsZWQgKi8KKwlCRkFfU1RBVFVTX0JBRF9MVU5TIAk9IDM3LAkvKiAgTm8gdmFsaWQgTFVOcyBmb3VuZCAqLworCUJGQV9TVEFUVVNfSU9fRkFJTFVSRSAJPSAzOCwJLyogIFNDU0kgdGFyZ2V0IElPIGZhaWx1cmUgKi8KKwlCRkFfU1RBVFVTX05PX0ZBQlJJQyAJPSAzOSwJLyogIE5vIHN3aXRjaGVkIGZhYnJpYyBwcmVzZW50ICovCisJQkZBX1NUQVRVU19FQkFERiAJPSA0MCwJLyogIEJhZCBmaWxlIGRlc2NyaXB0b3IgKi8KKwlCRkFfU1RBVFVTX0VJTlRSIAk9IDQxLAkvKiAgQSBzaWduYWwgd2FzIGNhdWdodCBkdXJpbmcgaW9jdGwgKi8KKwlCRkFfU1RBVFVTX0VJTyAJCT0gNDIsCS8qICBJL08gZXJyb3IgKi8KKwlCRkFfU1RBVFVTX0VOT1RUWSAJPSA0MywJLyogIEluYXBwcm9wcmlhdGUgSS9PIGNvbnRyb2wKKwkJCQkJICogb3BlcmF0aW9uICovCisJQkZBX1NUQVRVU19FTlhJTyAJPSA0NCwJLyogIE5vIHN1Y2ggZGV2aWNlIG9yIGFkZHJlc3MgKi8KKwlCRkFfU1RBVFVTX0VGT1BFTiAJPSA0NSwJLyogIEZhaWxlZCB0byBvcGVuIGZpbGUgKi8KKwlCRkFfU1RBVFVTX1ZQT1JUX1dXTl9CUCA9IDQ2LAkvKiAgV1dOIGlzIHNhbWUgYXMgYmFzZSBwb3J0J3MgV1dOICovCisJQkZBX1NUQVRVU19QT1JUX05PVF9ESVNBQkxFRCA9IDQ3LCAvKiAgUG9ydCBub3QgZGlzYWJsZWQgZGlzYWJsZSBwb3J0CisJCQkJCSAgICAqIGZpcnN0ICovCisJQkZBX1NUQVRVU19CQURGUk1IRFIgCT0gNDgsCS8qICBCYWQgZnJhbWUgaGVhZGVyICovCisJQkZBX1NUQVRVU19CQURGUk1TWiAJPSA0OSwJLyogIEJhZCBmcmFtZSBzaXplIGNoZWNrIGFuZCByZXBsYWNlCisJCQkJCSAqIFNGUC9jYWJsZSAqLworCUJGQV9TVEFUVVNfTUlTU0lOR0ZSTSAJPSA1MCwJLyogIE1pc3NpbmcgZnJhbWUgY2hlY2sgYW5kIHJlcGxhY2UKKwkJCQkJICogU0ZQL2NhYmxlICovCisJQkZBX1NUQVRVU19MSU5LVElNRU9VVCAJPSA1MSwJLyogIExpbmsgdGltZW91dCBjaGVjayBhbmQgcmVwbGFjZQorCQkJCQkgKiBTRlAvY2FibGUgKi8KKwlCRkFfU1RBVFVTX05PX0ZDUElNX05FWFVTID0gNTIsCS8qICBObyBGQ1AgTmV4dXMgZXhpc3RzIHdpdGggdGhlCisJCQkJCSAqIHJwb3J0ICovCisJQkZBX1NUQVRVU19DSEVDS1NVTV9GQUlMID0gNTMsCS8qICBjaGVja3N1bSBmYWlsdXJlICovCisJQkZBX1NUQVRVU19HWk1FX0ZBSUxFRCAJPSA1NCwJLyogIEdldCB6b25lIG1lbWJlciBxdWVyeSBmYWlsZWQgKi8KKwlCRkFfU1RBVFVTX1NDU0lTVEFSVF9SRVFEID0gNTUsCS8qICBTQ1NJIGRpc2sgcmVxdWlyZSBTVEFSVCBjb21tYW5kICovCisJQkZBX1NUQVRVU19JT0NfRkFJTFVSRSAJPSA1NiwJLyogIElPQyBmYWlsdXJlIC0gUmV0cnksIGlmIHBlcnNpc3RzCisJCQkJCSAqIGNvbnRhY3Qgc3VwcG9ydCAqLworCUJGQV9TVEFUVVNfSU5WQUxJRF9XV04gCT0gNTcsCS8qICBJbnZhbGlkIFdXTiAqLworCUJGQV9TVEFUVVNfTUlTTUFUQ0ggCT0gNTgsCS8qICBWZXJzaW9uIG1pc21hdGNoICovCisJQkZBX1NUQVRVU19JT0NfRU5BQkxFRCAJPSA1OSwJLyogIElPQyBpcyBhbHJlYWR5IGVuYWJsZWQgKi8KKwlCRkFfU1RBVFVTX0FEQVBURVJfRU5BQkxFRCA9IDYwLCAvKiAgQWRhcHRlciBpcyBub3QgZGlzYWJsZWQgZGlzYWJsZQorCQkJCQkgICogYWRhcHRlciBmaXJzdCAqLworCUJGQV9TVEFUVVNfSU9DX05PTl9PUCAJPSA2MSwJLyogIElPQyBpcyBub3Qgb3BlcmF0aW9uYWwuIEVuYWJsZSBJT0MKKwkJCQkJICogYW5kIGlmIGl0IHN0aWxsIGZhaWxzLAorCQkJCQkgKiBjb250YWN0IHN1cHBvcnQgKi8KKwlCRkFfU1RBVFVTX0FERFJfTUFQX0ZBSUxVUkUgPSA2MiwgLyogIFBDSSBiYXNlIGFkZHJlc3Mgbm90IG1hcHBlZAorCQkJCQkgICAqIGluIE9TICovCisJQkZBX1NUQVRVU19TQU1FX05BTUUgCT0gNjMsCS8qICBOYW1lIGV4aXN0cyEgdXNlIGEgZGlmZmVyZW50CisJCQkJCSAqIG5hbWUgKi8KKwlCRkFfU1RBVFVTX1BFTkRJTkcgICAgICA9IDY0LCAgIC8qICBBUEkgY29tcGxldGVzIGFzeW5jaHJvbm91c2x5ICovCisJQkZBX1NUQVRVU184R19TUEQJPSA2NSwJLyogIFNwZWVkIHNldHRpbmcgbm90IHZhbGlkIGZvcgorCQkJCQkgKiA4RyBIQkEgKi8KKwlCRkFfU1RBVFVTXzRHX1NQRAk9IDY2LAkvKiAgU3BlZWQgc2V0dGluZyBub3QgdmFsaWQgZm9yCisJCQkJCSAqIDRHIEhCQSAqLworCUJGQV9TVEFUVVNfQURfSVNfRU5BQkxFID0gNjcsCS8qICBBZGFwdGVyIGlzIGFscmVhZHkgZW5hYmxlZCAqLworCUJGQV9TVEFUVVNfRUlOVkFMX1RPViAJPSA2OCwJLyogIEludmFsaWQgcGF0aCBmYWlsb3ZlciBUT1YgKi8KKwlCRkFfU1RBVFVTX0VJTlZBTF9RREVQVEggPSA2OSwJLyogIEludmFsaWQgcXVldWUgZGVwdGggdmFsdWUgKi8KKwlCRkFfU1RBVFVTX1ZFUlNJT05fRkFJTCA9IDcwLAkvKiAgQXBwbGljYXRpb24vRHJpdmVyIHZlcnNpb24KKwkJCQkJICogbWlzbWF0Y2ggKi8KKwlCRkFfU1RBVFVTX0RJQUdfQlVTWSAgICA9IDcxLAkvKiAgZGlhZyBidXN5ICovCisJQkZBX1NUQVRVU19CRUFDT05fT04JPSA3MiwJLyogIFBvcnQgQmVhY29uIGFscmVhZHkgb24gKi8KKwlCRkFfU1RBVFVTX0JFQUNPTl9PRkYJPSA3MywJLyogIFBvcnQgQmVhY29uIGFscmVhZHkgb2ZmICovCisJQkZBX1NUQVRVU19MQkVBQ09OX09OICAgPSA3NCwJLyogIExpbmsgRW5kLXRvLUVuZCBCZWFjb24gYWxyZWFkeQorCQkJCQkgKiBvbiAqLworCUJGQV9TVEFUVVNfTEJFQUNPTl9PRkYJPSA3NSwJLyogIExpbmsgRW5kLXRvLUVuZCBCZWFjb24gYWxyZWFkeQorCQkJCQkgKiBvZmYgKi8KKwlCRkFfU1RBVFVTX1BPUlRfTk9UX0lOSVRFRCA9IDc2LCAvKiAgUG9ydCBub3QgaW5pdGlhbGl6ZWQgKi8KKwlCRkFfU1RBVFVTX1JQU0NfRU5BQkxFRCA9IDc3LCAvKiAgVGFyZ2V0IGhhcyBhIHZhbGlkIHNwZWVkICovCisJQkZBX1NUQVRVU19FTk9GU0FWRSA9IDc4LAkvKiAgTm8gc2F2ZWQgZmlybXdhcmUgdHJhY2UgKi8KKwlCRkFfU1RBVFVTX0JBRF9GSUxFID0gNzksCS8qICBOb3QgYSB2YWxpZCBCcm9jYWRlIEJvb3QgQ29kZQorCQkJCQkgKiBmaWxlICovCisJQkZBX1NUQVRVU19STElNX0VOID0gODAsCS8qICBUYXJnZXQgcmF0ZSBsaW1pdGluZyBpcyBhbHJlYWR5CisJCQkJCSAqIGVuYWJsZWQgKi8KKwlCRkFfU1RBVFVTX1JMSU1fRElTID0gODEsICAvKiAgVGFyZ2V0IHJhdGUgbGltaXRpbmcgaXMgYWxyZWFkeQorCQkJCSAgICAqIGRpc2FibGVkICovCisJQkZBX1NUQVRVU19JT0NfRElTQUJMRUQgPSA4MiwgICAvKiAgSU9DIGlzIGFscmVhZHkgZGlzYWJsZWQgKi8KKwlCRkFfU1RBVFVTX0FEQVBURVJfRElTQUJMRUQgPSA4MywgICAvKiAgQWRhcHRlciBpcyBhbHJlYWR5IGRpc2FibGVkICovCisJQkZBX1NUQVRVU19CSU9TX0RJU0FCTEVEID0gODQsICAgLyogIEJpb3MgaXMgYWxyZWFkeSBkaXNhYmxlZCAqLworCUJGQV9TVEFUVVNfQVVUSF9FTkFCTEVEID0gODUsICAgLyogIEF1dGhlbnRpY2F0aW9uIGlzIGFscmVhZHkKKwkJCQkJICogZW5hYmxlZCAqLworCUJGQV9TVEFUVVNfQVVUSF9ESVNBQkxFRCA9IDg2LCAgIC8qICBBdXRoZW50aWNhdGlvbiBpcyBhbHJlYWR5CisJCQkJCSAqIGRpc2FibGVkICovCisJQkZBX1NUQVRVU19FUlJPUl9UUkxfRU5BQkxFRCA9IDg3LCAgIC8qICBUYXJnZXQgcmF0ZSBsaW1pdGluZyBpcworCQkJCQkgICAgICAqIGVuYWJsZWQgKi8KKwlCRkFfU1RBVFVTX0VSUk9SX1FPU19FTkFCTEVEID0gODgsICAgLyogIFFvUyBpcyBlbmFibGVkICovCisJQkZBX1NUQVRVU19OT19TRlBfREVWID0gODksIC8qICBObyBTRlAgZGV2aWNlIGNoZWNrIG9yIHJlcGxhY2UgU0ZQICovCisJQkZBX1NUQVRVU19NRU1URVNUX0ZBSUxFRCA9IDkwLAkvKiAgTWVtb3J5IHRlc3QgZmFpbGVkIGNvbnRhY3QKKwkJCQkJICogc3VwcG9ydCAqLworCUJGQV9TVEFUVVNfSU5WQUxJRF9ERVZJRCA9IDkxLAkvKiAgSW52YWxpZCBkZXZpY2UgaWQgcHJvdmlkZWQgKi8KKwlCRkFfU1RBVFVTX1FPU19FTkFCTEVEID0gOTIsIC8qICBRT1MgaXMgYWxyZWFkeSBlbmFibGVkICovCisJQkZBX1NUQVRVU19RT1NfRElTQUJMRUQgPSA5MywgLyogIFFPUyBpcyBhbHJlYWR5IGRpc2FibGVkICovCisJQkZBX1NUQVRVU19JTkNPUlJFQ1RfRFJWX0NPTkZJRyA9IDk0LCAvKiAgQ2hlY2sgY29uZmlndXJhdGlvbgorCQkJCQkgICAgICAgKiBrZXkvdmFsdWUgcGFpciAqLworCUJGQV9TVEFUVVNfUkVHX0ZBSUwgPSA5NSwgLyogIENhbid0IHJlYWQgd2luZG93cyByZWdpc3RyeSAqLworCUJGQV9TVEFUVVNfSU1fSU5WX0NPREUgPSA5NiwgLyogIEludmFsaWQgSU9DVEwgY29kZSAqLworCUJGQV9TVEFUVVNfSU1fSU5WX1ZMQU4gPSA5NywgLyogIEludmFsaWQgVkxBTiBJRCAqLworCUJGQV9TVEFUVVNfSU1fSU5WX0FEQVBUX05BTUUgPSA5OCwgLyogIEludmFsaWQgYWRhcHRlciBuYW1lICovCisJQkZBX1NUQVRVU19JTV9MT1dfUkVTT1VSQ0VTID0gOTksIC8qICBNZW1vcnkgYWxsb2NhdGlvbiBmYWlsdXJlIGluCisJCQkJCSAgICogZHJpdmVyICovCisJQkZBX1NUQVRVU19JTV9WTEFOSURfSVNfUFZJRCA9IDEwMCwgLyogIEdpdmVuIFZMQU4gaWQgc2FtZSBhcyBQVklEICovCisJQkZBX1NUQVRVU19JTV9WTEFOSURfRVhJU1RTID0gMTAxLCAvKiAgR2l2ZW4gVkxBTiBpZCBhbHJlYWR5IGV4aXN0cyAqLworCUJGQV9TVEFUVVNfSU1fRldfVVBEQVRFX0ZBSUwgPSAxMDIsIC8qICBVcGRhdGluZyBmaXJtd2FyZSB3aXRoIG5ldworCQkJCQkgICAgICogVkxBTiBJRCBmYWlsZWQgKi8KKwlCRkFfU1RBVFVTX1BPUlRMT0dfRU5BQkxFRCA9IDEwMywgLyogIFBvcnQgTG9nIGlzIGFscmVhZHkgZW5hYmxlZCAqLworCUJGQV9TVEFUVVNfUE9SVExPR19ESVNBQkxFRCA9IDEwNCwgLyogIFBvcnQgTG9nIGlzIGFscmVhZHkgZGlzYWJsZWQgKi8KKwlCRkFfU1RBVFVTX0ZJTEVfTk9UX0ZPVU5EID0gMTA1LCAvKiAgU3BlY2lmaWVkIGZpbGUgY291bGQgbm90IGJlCisJCQkJCSAgKiBmb3VuZCAqLworCUJGQV9TVEFUVVNfUU9TX0ZDX09OTFkgPSAxMDYsIC8qICBRT1MgY2FuIGJlIGVuYWJsZWQgZm9yIEZDIG1vZGUKKwkJCQkgICAgICAgKiBvbmx5ICovCisJQkZBX1NUQVRVU19STElNX0ZDX09OTFkgPSAxMDcsIC8qICBSQVRFTElNIGNhbiBiZSBlbmFibGVkIGZvciBGQyBtb2RlCisJCQkJCSogb25seSAqLworCUJGQV9TVEFUVVNfQ1RfU1BEID0gMTA4LCAvKiAgSW52YWxpZCBzcGVlZCBzZWxlY3Rpb24gZm9yIENhdGFwdWx0LiAqLworCUJGQV9TVEFUVVNfTEVEVEVTVF9PUCA9IDEwOSwgLyogIExFRCB0ZXN0IGlzIG9wZXJhdGluZyAqLworCUJGQV9TVEFUVVNfQ0VFX05PVF9ETiA9IDExMCwgLyogIGV0aCBwb3J0IGlzIG5vdCBhdCBkb3duIHN0YXRlLCBwbGVhc2UKKwkJCQkgICAgICAqIGJyaW5nIGRvd24gZmlyc3QgKi8KKwlCRkFfU1RBVFVTXzEwR19TUEQgPSAxMTEsIC8qICBTcGVlZCBzZXR0aW5nIG5vdCB2YWxpZCBmb3IgMTBHIEhCQSAqLworCUJGQV9TVEFUVVNfSU1fSU5WX1RFQU1fTkFNRSA9IDExMiwgLyogIEludmFsaWQgdGVhbSBuYW1lICovCisJQkZBX1NUQVRVU19JTV9EVVBfVEVBTV9OQU1FID0gMTEzLCAvKiAgR2l2ZW4gdGVhbSBuYW1lIGFscmVhZHkKKwkJCQkJICAgICogZXhpc3RzICovCisJQkZBX1NUQVRVU19JTV9BREFQVF9BTFJFQURZX0lOX1RFQU0gPSAxMTQsIC8qICBHaXZlbiBhZGFwdGVyIGlzIHBhcnQKKwkJCQkJCSAgICAqIG9mIGFub3RoZXIgdGVhbSAqLworCUJGQV9TVEFUVVNfSU1fQURBUFRfSEFTX1ZMQU5TID0gMTE1LCAvKiAgQWRhcHRlciBoYXMgVkxBTnMgY29uZmlndXJlZC4KKwkJCQkJICAgICAgKiBEZWxldGUgYWxsIFZMQU5zIGJlZm9yZQorCQkJCQkgICAgICAqIGNyZWF0aW5nIHRlYW0gKi8KKwlCRkFfU1RBVFVTX0lNX1BWSURfTUlTTUFUQ0ggPSAxMTYsIC8qICBNaXNtYXRjaGluZyBQVklEcyBjb25maWd1cmVkCisJCQkJCSAgICAqIGZvciBhZGFwdGVycyAqLworCUJGQV9TVEFUVVNfSU1fTElOS19TUEVFRF9NSVNNQVRDSCA9IDExNywgLyogIE1pc21hdGNoaW5nIGxpbmsgc3BlZWRzCisJCQkJCQkgICogY29uZmlndXJlZCBmb3IgYWRhcHRlcnMgKi8KKwlCRkFfU1RBVFVTX0lNX01UVV9NSVNNQVRDSCA9IDExOCwgLyogIE1pc21hdGNoaW5nIE1UVXMgY29uZmlndXJlZCBmb3IKKwkJCQkJICAgKiBhZGFwdGVycyAqLworCUJGQV9TVEFUVVNfSU1fUlNTX01JU01BVENIID0gMTE5LCAvKiAgTWlzbWF0Y2hpbmcgUlNTIHBhcmFtZXRlcnMKKwkJCQkJICAgKiBjb25maWd1cmVkIGZvciBhZGFwdGVycyAqLworCUJGQV9TVEFUVVNfSU1fSERTX01JU01BVENIID0gMTIwLCAvKiAgTWlzbWF0Y2hpbmcgSERTIHBhcmFtZXRlcnMKKwkJCQkJICAgKiBjb25maWd1cmVkIGZvciBhZGFwdGVycyAqLworCUJGQV9TVEFUVVNfSU1fT0ZGTE9BRF9NSVNNQVRDSCA9IDEyMSwgLyogIE1pc21hdGNoaW5nIG9mZmxvYWQKKwkJCQkJICAgICAgICogcGFyYW1ldGVycyBjb25maWd1cmVkIGZvcgorCQkJCQkgICAgICAgKiBhZGFwdGVycyAqLworCUJGQV9TVEFUVVNfSU1fUE9SVF9QQVJBTVMgPSAxMjIsIC8qICBFcnJvciBzZXR0aW5nIHBvcnQgcGFyYW1ldGVycyAqLworCUJGQV9TVEFUVVNfSU1fUE9SVF9OT1RfSU5fVEVBTSA9IDEyMywgLyogIFBvcnQgaXMgbm90IHBhcnQgb2YgdGVhbSAqLworCUJGQV9TVEFUVVNfSU1fQ0FOTk9UX1JFTV9QUkkgPSAxMjQsIC8qICBQcmltYXJ5IGFkYXB0ZXIgY2Fubm90IGJlCisJCQkJCSAgICAgKiByZW1vdmVkLiBDaGFuZ2UgcHJpbWFyeSBiZWZvcmUKKwkJCQkJICAgICAqIHJlbW92aW5nICovCisJQkZBX1NUQVRVU19JTV9NQVhfUE9SVFNfUkVBQ0hFRCA9IDEyNSwgLyogIEV4Y2VlZGluZyBtYXhpbXVtIHBvcnRzCisJCQkJCQkqIHBlciB0ZWFtICovCisJQkZBX1NUQVRVU19JTV9MQVNUX1BPUlRfREVMRVRFID0gMTI2LCAvKiAgTGFzdCBwb3J0IGluIHRlYW0gYmVpbmcKKwkJCQkJICAgICAgICogZGVsZXRlZCAqLworCUJGQV9TVEFUVVNfSU1fTk9fRFJJVkVSID0gMTI3LCAvKiAgSU0gZHJpdmVyIGlzIG5vdCBpbnN0YWxsZWQgKi8KKwlCRkFfU1RBVFVTX0lNX01BWF9WTEFOU19SRUFDSEVEID0gMTI4LCAvKiAgRXhjZWVkaW5nIG1heGltdW0gVkxBTnMKKwkJCQkJCSogcGVyIHBvcnQgKi8KKwlCRkFfU1RBVFVTX1RPTUNBVF9TUERfTk9UX0FMTE9XRUQgPSAxMjksIC8qIEJpb3Mgc3BlZWQgY29uZmlnIG5vdAorCQkJCQkJICAqIGFsbG93ZWQgZm9yIENOQSAqLworCUJGQV9TVEFUVVNfTk9fTUlOUE9SVF9EUklWRVIgPSAxMzAsIC8qICBNaW5pcG9ydCBkcml2ZXIgaXMgbm90CisJCQkJCSAgICAgKiBsb2FkZWQgKi8KKwlCRkFfU1RBVFVTX0NBUkRfVFlQRV9NSVNNQVRDSCA9IDEzMSwgLyogIENhcmQgdHlwZSBtaXNtYXRjaCAqLworCUJGQV9TVEFUVVNfQkFEX0FTSUNCTEsgPSAxMzIsIC8qICBCYWQgQVNJQyBibG9jayAqLworCUJGQV9TVEFUVVNfTk9fRFJJVkVSID0gMTMzLCAvKiAgU3RvcmFnZS9FdGhlcm5ldCBkcml2ZXIgbm90IGxvYWRlZCAqLworCUJGQV9TVEFUVVNfSU5WQUxJRF9NQUMgPSAxMzQsIC8qICBJbnZhbGlkIG1hYyBhZGRyZXNzICovCisJQkZBX1NUQVRVU19JTV9OT19WTEFOID0gMTM1LCAvKiAgTm8gVkxBTnMgY29uZmlndXJlZCBvbiB0aGUgYWRhcHRlciAqLworCUJGQV9TVEFUVVNfSU1fRVRIX0xCX0ZBSUxFRCA9IDEzNiwgLyogIEV0aGVybmV0IGxvb3BiYWNrIHRlc3QgZmFpbGVkICovCisJQkZBX1NUQVRVU19JTV9QVklEX1JFTU9WRSA9IDEzNywgLyogIENhbm5vdCByZW1vdmUgcG9ydCB2bGFuIChQVklEKSAqLworCUJGQV9TVEFUVVNfSU1fUFZJRF9FRElUID0gMTM4LCAvKiAgQ2Fubm90IGVkaXQgcG9ydCB2bGFuIChQVklEKSAqLworCUJGQV9TVEFUVVNfQ05BX05PX0JPT1QgPSAxMzksIC8qICBCb290IHVwbG9hZCBub3QgYWxsb3dlZCBmb3IgQ05BICovCisJQkZBX1NUQVRVU19JTV9QVklEX05PTl9aRVJPID0gMTQwLCAvKiAgUG9ydCBWTEFOIElEIChQVklEKSBpcyBTZXQgdG8KKwkJCQkJICAgICogTm9uLVplcm8gVmFsdWUgKi8KKwlCRkFfU1RBVFVTX0lNX0lORVRDRkdfTE9DS19GQUlMRUQgPSAxNDEsIC8qICBBY3F1aXJpbmcgTmV0d29yaworCQkJCQkJICAqIFN1YnN5dGVtIExvY2sgRmFpbGVkLlBsZWFzZQorCQkJCQkJICAqIHRyeSBhZnRlciBzb21lIHRpbWUgKi8KKwlCRkFfU1RBVFVTX0lNX0dFVF9JTkVUQ0ZHX0ZBSUxFRCA9IDE0MiwgLyogIEFjcXVpcmluZyBOZXR3b3JrIFN1YnN5dGVtCisJCQkJCQkgKiBoYW5kbGUgRmFpbGVkLiBQbGVhc2UgdHJ5CisJCQkJCQkgKiBhZnRlciBzb21lIHRpbWUgKi8KKwlCRkFfU1RBVFVTX0lNX05PVF9CT1VORCA9IDE0MywgLyogIEJyb2NhZGUgMTBHIEV0aGVybmV0IFNlcnZpY2UgaXMgbm90CisJCQkJCSogRW5hYmxlZCBvbiB0aGlzIHBvcnQgKi8KKwlCRkFfU1RBVFVTX0lOU1VGRklDSUVOVF9QRVJNUyA9IDE0NCwgLyogIFVzZXIgZG9lc24ndCBoYXZlIHN1ZmZpY2llbnQKKwkJCQkJICAgICAgKiBwZXJtaXNzaW9ucyB0byBleGVjdXRlIHRoZSBCQ1UKKwkJCQkJICAgICAgKiBhcHBsaWNhdGlvbiAqLworCUJGQV9TVEFUVVNfSU1fSU5WX1ZMQU5fTkFNRSA9IDE0NSwgLyogIEludmFsaWQvUmVzZXJ2ZWQgVmxhbiBuYW1lCisJCQkJCSAgICAqIHN0cmluZy4gVGhlIG5hbWUgaXMgbm90IGFsbG93ZWQKKwkJCQkJICAgICogZm9yIHRoZSBub3JtYWwgVmxhbnMgKi8KKwlCRkFfU1RBVFVTX0NNRF9OT1RTVVBQX0NOQSA9IDE0NiwgLyogIENvbW1hbmQgbm90IHN1cHBvcnRlZCBmb3IgQ05BICovCisJQkZBX1NUQVRVU19JTV9QQVNTVEhSVV9FRElUID0gMTQ3LCAvKiAgQ2FuIG5vdCBlZGl0IHBhc3N0aHJ1IHZsYW4gaWQgKi8KKwlCRkFfU1RBVFVTX0lNX0JJTkRfRkFJTEVEID0gMTQ4LCAvKiEgPCBJTSBEcml2ZXIgYmluZCBvcGVyYXRpb24KKwkJCQkJICAqIGZhaWxlZCAqLworCUJGQV9TVEFUVVNfSU1fVU5CSU5EX0ZBSUxFRCA9IDE0OSwgLyogISA8IElNIERyaXZlciB1bmJpbmQgb3BlcmF0aW9uCisJCQkJCSAgICAqIGZhaWxlZCAqLworCUJGQV9TVEFUVVNfTUFYX1ZBTAkJLyogIFVua25vd24gZXJyb3IgY29kZSAqLworfTsKKyNkZWZpbmUgYmZhX3N0YXR1c190IGVudW0gYmZhX3N0YXR1cworCitlbnVtIGJmYV9lcHJvdG9fc3RhdHVzIHsKKwlCRkFfRVBST1RPX0JBRF9BQ0NFUFQgPSAwLAorCUJGQV9FUFJPVE9fVU5LTk9XTl9SU1AgPSAxCit9OworI2RlZmluZSBiZmFfZXByb3RvX3N0YXR1c190IGVudW0gYmZhX2Vwcm90b19zdGF0dXMKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfU1RBVFVTX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdGluLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc190aW4uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMDVhMmRiCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdGluLmgKQEAgLTAsMCArMSwxMTggQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9ERUZTX1RJTl9IX18KKyNkZWZpbmUgX19CRkFfREVGU19USU5fSF9fCisKKyNpbmNsdWRlIDxwcm90b2NvbC90eXBlcy5oPgorI2luY2x1ZGUgPHByb3RvY29sL2ZjLmg+CisKKy8qKgorICogRkNTIHRpbiBzdGF0ZXMKKyAqLworZW51bSBiZmFfdGluX3N0YXRlX2UgeworCUJGQV9USU5fU01fT0ZGTElORSA9IDAsCQkvKiAgdGluIGlzIG9mZmxpbmUgKi8KKwlCRkFfVElOX1NNX1dPU19MT0dJTiA9IDEsCS8qICBXYWl0aW5nIFBSTEkgQUNDL1JKVCBmcm9tIFVMUCAqLworCUJGQV9USU5fU01fV0ZXX09OTElORSA9IDIsCS8qICBXYWl0aW5nIEFDSyB0byBQUkxJIEFDQyBmcm9tIEZXICovCisJQkZBX1RJTl9TTV9PTkxJTkUgPSAzLAkJLyogIHRpbiBsb2dpbiBpcyBjb21wbGV0ZSAqLworCUJGQV9USU5fU01fV0lPX1JFTE9HSU4gPSA0LAkvKiAgdGluIHJlbG9naW4gaXMgaW4gcHJvZ3Jlc3MgKi8KKwlCRkFfVElOX1NNX1dJT19MT0dPVVQgPSA1LAkvKiAgUHJvY2Vzc2luZyBvZiBQUkxPIHJlcSBmcm9tCisJCQkJCSAqICAgSW5pdGlhdG9yIGlzIGluIHByb2dyZXNzCisJCQkJCSAqLworCUJGQV9USU5fU01fV09TX0xPR09VVCA9IDYsCS8qICBQcm9jZXNzaW5nIG9mIFBSTE8gcmVxIGZyb20KKwkJCQkJICogICBJbml0aWF0b3IgaXMgaW4gcHJvZ3Jlc3MKKwkJCQkJICovCisJQkZBX1RJTl9TTV9XSU9fQ0xFQU4gPSA3LAkvKiAgV2FpdGluZyBmb3IgSU8gY2xlYW51cCBiZWZvcmUgdGluCisJCQkJCSAqICAgaXMgb2ZmbGluZS4gVGhpcyBjYW4gYmUgdHJpZ2dlcmVkCisJCQkJCSAqICAgYnkgUlBPUlQgTE9HTyAocmN2ZC9zZW50KSBvciBieQorCQkJCQkgKiAgIFBSTE8gKHJjdmQvc2VudCkKKwkJCQkJICovCit9OworCitzdHJ1Y3QgYmZhX3BybGlfcmVxX3MgeworCXN0cnVjdCBmY2hzX3MgZmNoczsKKwlzdHJ1Y3QgZmNfcHJsaV9zIHBybGlfcGF5bG9hZDsKK307CisKK3N0cnVjdCBiZmFfcHJsb19yZXFfcyB7CisJc3RydWN0IGZjaHNfcyBmY2hzOworCXN0cnVjdCBmY19wcmxvX3MgcHJsb19wYXlsb2FkOworfTsKKwordm9pZCBiZmFfdGluX3NlbmRfbG9naW5fcnNwKHZvaWQgKmJmYV90aW4sIHUzMiBsb2dpbl9yc3AsCisJCQkJc3RydWN0IGZjX2xzX3JqdF9zIHJqdF9wYXlsb2FkKTsKK3ZvaWQgYmZhX3Rpbl9zZW5kX2xvZ291dF9yc3Aodm9pZCAqYmZhX3RpbiwgdTMyIGxvZ291dF9yc3AsCisJCQkJc3RydWN0IGZjX2xzX3JqdF9zIHJqdF9wYXlsb2FkKTsKKy8qKgorICogRkNTIHRhcmdldCBwb3J0IHN0YXRpc3RpY3MKKyAqLworc3RydWN0IGJmYV90aW5fc3RhdHNfcyB7CisJdTMyIG9ubGluZXM7CS8qICBJVE4gbmV4dXMgb25saW5lcyAoUFJMSSBkb25lKSAqLworCXUzMiBvZmZsaW5lczsJLyogIElUTiBOZXh1cyBvZmZsaW5lcyAJKi8KKwl1MzIgcHJsaV9yZXFfcGFyc2VfZXJyOwkvKiAgcHJsaSByZXEgcGFyc2luZyBlcnJvcnMgKi8KKwl1MzIgcHJsaV9yc3Bfcmp0OwkvKiAgbnVtIHBybGkgcnNwIHJlamVjdHMgc2VudCAqLworCXUzMiBwcmxpX3JzcF9hY2M7CS8qICBudW0gcHJsaSByc3AgYWNjZXB0cyBzZW50ICovCisJdTMyIGNsZWFudXBfY29tcHM7CS8qICBJVE4gY2xlYW51cCBjb21wbGV0aW9ucyAqLworfTsKKworLyoqCisgKiBGQ1MgdGluIGF0dHJpYnV0ZXMgcmV0dXJuZWQgaW4gcXVlcmllcworICovCitzdHJ1Y3QgYmZhX3Rpbl9hdHRyX3MgeworCWVudW0gYmZhX3Rpbl9zdGF0ZV9lIHN0YXRlOworCXU4CXNlcV9yZXRyeTsgICAgLyogIFNlcXVlbmNlIHJldHJ5IHN1cHBvcnRlZCAgICAgICovCisJdTgJcnN2ZFszXTsKK307CisKKy8qKgorICogQkZBIFRJTiBhc3luYyBldmVudCBkYXRhIHN0cnVjdHVyZSBmb3IgQkZBTAorICovCitlbnVtIGJmYV90aW5fYWVuX2V2ZW50IHsKKwlCRkFfVElOX0FFTl9PTkxJTkUgCT0gMSwJLyogIFRhcmdldCBvbmxpbmUgKi8KKwlCRkFfVElOX0FFTl9PRkZMSU5FIAk9IDIsCS8qICBUYXJnZXQgb2ZmbGluZSAqLworCUJGQV9USU5fQUVOX0RJU0NPTk5FQ1QJPSAzLAkvKiAgVGFyZ2V0IGRpc2Nvbm5lY3RlZCAqLworfTsKKworLyoqCisgKiBCRkEgVElOIGV2ZW50IGRhdGEgc3RydWN0dXJlLgorICovCitzdHJ1Y3QgYmZhX3Rpbl9hZW5fZGF0YV9zIHsKKwl1MTYgdmZfaWQ7CS8qICB2Zl9pZCBvZiB0aGUgSVQgbmV4dXMgKi8KKwl1MTYgcnN2ZFszXTsKKwl3d25fdCBscHd3bjsJLyogIFdXTiBvZiBsb2dpY2FsIHBvcnQgKi8KKwl3d25fdCBycHd3bjsJLyogIFdXTiBvZiByZW1vdGUodGFyZ2V0KSBwb3J0ICovCit9OworCisvKioKKyAqIEJlbG93IEFQSXMgYXJlIG5lZWRlZCBmcm9tIEJGQSBkcml2ZXIKKyAqIE1vdmUgdGhlc2UgdG8gQkZBIGRyaXZlciBwdWJsaWMgaGVhZGVyIGZpbGU/CisgKi8KKy8qICBUSU4gcmN2ZCBuZXcgUFJMSSAmIGdldHMgYmZhZF90aW5fdCBwdHIgZnJvbSBkcml2ZXIgdGhpcyBjYWxsYmFjayAqLwordm9pZCAqYmZhZF90aW5fcmN2ZF9sb2dpbl9yZXEodm9pZCAqYmZhZF90bV9wb3J0LCB2b2lkICpiZmFfdGluLAorCQkJCXd3bl90IHJwX3d3biwgdTMyIHJwX2ZjaWQsCisJCQkJc3RydWN0IGJmYV9wcmxpX3JlcV9zIHBybGlfcmVxKTsKKy8qICBUSU4gcmN2ZCBuZXcgUFJMTyAqLwordm9pZCBiZmFkX3Rpbl9yY3ZkX2xvZ291dF9yZXEodm9pZCAqYmZhZF90aW4sIHd3bl90IHJwX3d3biwgdTMyIHJwX2ZjaWQsCisJCQkJc3RydWN0IGJmYV9wcmxvX3JlcV9zIHBybG9fcmVxKTsKKy8qICBUSU4gaXMgb25saW5lIGFuZCByZWFkeSBmb3IgSU8gKi8KK3ZvaWQgYmZhZF90aW5fb25saW5lKHZvaWQgKmJmYWRfdGluKTsKKy8qICBUSU4gaXMgb2ZmbGluZSBhbmQgQkZBIGRyaXZlciBjYW4gc2h1dGRvd24gaXRzIHVwcGVyIHN0YWNrICovCit2b2lkIGJmYWRfdGluX29mZmxpbmUodm9pZCAqYmZhZF90aW4pOworLyogIFRJTiBkb2VzIG5vdCBuZWVkIHRoaXMgQkZBIGRyaXZlciB0aW4gdGFnIGFueW1vcmUsIHNvIGNhbiBiZSBmcmVlZCAqLwordm9pZCBiZmFkX3Rpbl9yZXNfZnJlZSh2b2lkICpiZmFkX3Rpbik7CisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX1RJTl9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3RzZW5zb3IuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3RzZW5zb3IuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMTg4MWQyCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdHNlbnNvci5oCkBAIC0wLDAgKzEsNDMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9ERUZTX1RTRU5TT1JfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfVFNFTlNPUl9IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3R5cGVzLmg+CisKKy8qKgorICogVGVtcGVyYXR1cmUgc2Vuc29yIHN0YXR1cyB2YWx1ZXMKKyAqLworZW51bSBiZmFfdHNlbnNvcl9zdGF0dXMgeworCUJGQV9UU0VOU09SX1NUQVRVU19VTktOT1dOICAgPSAxLCAgIC8qICB1bmtvd24gc3RhdHVzICovCisJQkZBX1RTRU5TT1JfU1RBVFVTX0ZBVUxUWSAgICA9IDIsICAgLyogIHNlbnNvciBpcyBmYXVsdHkgKi8KKwlCRkFfVFNFTlNPUl9TVEFUVVNfQkVMT1dfTUlOID0gMywgICAvKiAgdGVtcGVyYXR1cmUgYmVsb3cgbWluaW51bSAqLworCUJGQV9UU0VOU09SX1NUQVRVU19OT01JTkFMICAgPSA0LCAgIC8qICBub3JtYWwgdGVtcGVyYXR1cmUgKi8KKwlCRkFfVFNFTlNPUl9TVEFUVVNfQUJPVkVfTUFYID0gNSwgICAvKiAgdGVtcGVyYXR1cmUgYWJvdmUgbWF4aW11bSAqLworfTsKKworLyoqCisgKiBUZW1wZXJhdHVyZSBzZW5zb3IgYXR0cmlidXRlCisgKi8KK3N0cnVjdCBiZmFfdHNlbnNvcl9hdHRyX3MgeworCWVudW0gYmZhX3RzZW5zb3Jfc3RhdHVzIHN0YXR1czsJLyogIHRlbXBlcmF0dXJlIHNlbnNvciBzdGF0dXMgKi8KKwl1MzIgICAgICAgIAl2YWx1ZTsJLyogIGN1cnJlbnQgdGVtcGVyYXR1cmUgaW4gY2Vsc2l1cyAqLworfTsKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfVFNFTlNPUl9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3R5cGVzLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc190eXBlcy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQzNDgzMzIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc190eXBlcy5oCkBAIC0wLDAgKzEsMzAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpZm5kZWYgX19CRkFfREVGU19UWVBFU19IX18KKyNkZWZpbmUgX19CRkFfREVGU19UWVBFU19IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKworZW51bSBiZmFfYm9vbGVhbiB7CisJQkZBX0ZBTFNFID0gMCwKKwlCRkFfVFJVRSAgPSAxCit9OworI2RlZmluZSBiZmFfYm9vbGVhbl90IGVudW0gYmZhX2Jvb2xlYW4KKworI2RlZmluZSBCRkFfU1RSSU5HXzMyCTMyCisKKyNlbmRpZiAvKiBfX0JGQV9ERUZTX1RZUEVTX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdmVyc2lvbi5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdmVyc2lvbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY4OTAyYTIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc192ZXJzaW9uLmgKQEAgLTAsMCArMSwyMiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworI2lmbmRlZiBfX0JGQV9ERUZTX1ZFUlNJT05fSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfVkVSU0lPTl9IX18KKworI2RlZmluZSBCRkFfVkVSU0lPTl9MRU4JCTY0CisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdmYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3ZmLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzIzNWJlNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9kZWZzL2JmYV9kZWZzX3ZmLmgKQEAgLTAsMCArMSw3NCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0RFRlNfVkZfSF9fCisjZGVmaW5lIF9fQkZBX0RFRlNfVkZfSF9fCisKKyNpbmNsdWRlIDxiZmFfb3NfaW5jLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wb3J0Lmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvdHlwZXMuaD4KKworLyoqCisgKiBWRiBzdGF0ZXMKKyAqLworZW51bSBiZmFfdmZfc3RhdGUgeworCUJGQV9WRl9VTklOSVQgICAgPSAwLAkvKiAgZmFicmljIGlzIG5vdCB5ZXQgaW5pdGlhbGl6ZWQgKi8KKwlCRkFfVkZfTElOS19ET1dOID0gMSwJLyogIGxpbmsgaXMgZG93biAqLworCUJGQV9WRl9GTE9HSSAgICAgPSAyLAkvKiAgZmxvZ2kgaXMgaW4gcHJvZ3Jlc3MgKi8KKwlCRkFfVkZfQVVUSCAgICAgID0gMywJLyogIGF1dGhlbnRpY2F0aW9uIGluIHByb2dyZXNzICovCisJQkZBX1ZGX05PRkFCUklDICA9IDQsCS8qICBmYWJyaWMgaXMgbm90IHByZXNlbnQgKi8KKwlCRkFfVkZfT05MSU5FICAgID0gNSwJLyogIGxvZ2luIHRvIGZhYnJpYyBpcyBjb21wbGV0ZSAqLworCUJGQV9WRl9FVkZQICAgICAgPSA2LAkvKiAgRVZGUCBpcyBpbiBwcm9ncmVzcyAqLworCUJGQV9WRl9JU09MQVRFRCAgPSA3LAkvKiAgcG9ydCBpc29sYXRlZCBkdWUgdG8gdmZfaWQgbWlzbWF0Y2ggKi8KK307CisKKy8qKgorICogVkYgc3RhdGlzdGljcworICovCitzdHJ1Y3QgYmZhX3ZmX3N0YXRzX3MgeworCXUzMiAgICAgICAgZmxvZ2lfc2VudDsJLyogIE51bSBGTE9HSXMgc2VudCAJCSovCisJdTMyICAgICAgICBmbG9naV9yc3BfZXJyOwkvKiAgRkxPR0kgcmVzcG9uc2UgZXJyb3JzIAkqLworCXUzMiAgICAgICAgZmxvZ2lfYWNjX2VycjsJLyogIEZMT0dJIGFjY2VwdCBlcnJvcnMgCSovCisJdTMyICAgICAgICBmbG9naV9hY2NlcHRzOwkvKiAgRkxPR0kgYWNjZXB0cyByZWNlaXZlZCAJKi8KKwl1MzIgICAgICAgIGZsb2dpX3JlamVjdHM7CS8qICBGTE9HSSByZWplY3RzIHJlY2VpdmVkIAkqLworCXUzMiAgICAgICAgZmxvZ2lfdW5rbm93bl9yc3A7IC8qICBVbmtub3duIHJlc3BvbnNlcyBmb3IgRkxPR0kgKi8KKwl1MzIgICAgICAgIGZsb2dpX2FsbG9jX3dhaXQ7IC8qICBBbGxvY2F0aW9uIHdhaXRzIHByaW9yIHRvCisJCQkJCSAgICogc2VuZGluZyBGTE9HSQorCQkJCQkgICAqLworCXUzMiAgICAgICAgZmxvZ2lfcmN2ZDsJLyogIEZMT0dJcyByZWNlaXZlZCAqLworCXUzMiAgICAgICAgZmxvZ2lfcmVqZWN0ZWQ7CS8qICBJbmNvbWluZyBGTE9HSXMgcmVqZWN0ZWQgKi8KKwl1MzIgICAgICAgIGZhYnJpY19vbmxpbmVzOwkvKiAgSW50ZXJuYWwgZmFicmljIG9ubGluZQorCQkJCQkgKiBub3RpZmljYXRpb24gc2VudCB0byBvdGhlcgorCQkJCQkgKiBtb2R1bGVzCisJCQkJCSAqLworCXUzMiAgICAgICAgZmFicmljX29mZmxpbmVzOyAvKiAgSW50ZXJuYWwgZmFicmljIG9mZmxpbmUKKwkJCQkJICAqIG5vdGlmaWNhdGlvbiBzZW50IHRvIG90aGVyCisJCQkJCSAgKiBtb2R1bGVzCisJCQkJCSAgKi8KKwl1MzIgICAgICAgIHJlc3ZkOworfTsKKworLyoqCisgKiBWRiBhdHRyaWJ1dGVzIHJldHVybmVkIGluIHF1ZXJpZXMKKyAqLworc3RydWN0IGJmYV92Zl9hdHRyX3MgeworCWVudW0gYmZhX3ZmX3N0YXRlICBzdGF0ZTsJCS8qICBWRiBzdGF0ZSAqLworCXUzMiAgICAgICAgcnN2ZDsKKwl3d25fdCAgICAgICAgICAgZmFicmljX25hbWU7CS8qICBmYWJyaWMgbmFtZSAqLworfTsKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfVkZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZGVmcy9iZmFfZGVmc192cG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdnBvcnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45ZjAyMWY0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2RlZnMvYmZhX2RlZnNfdnBvcnQuaApAQCAtMCwwICsxLDkxIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfREVGU19WUE9SVF9IX18KKyNkZWZpbmUgX19CRkFfREVGU19WUE9SVF9IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3BvcnQuaD4KKyNpbmNsdWRlIDxwcm90b2NvbC90eXBlcy5oPgorCisvKioKKyAqIFZQT1JUIHN0YXRlcworICovCitlbnVtIGJmYV92cG9ydF9zdGF0ZSB7CisJQkZBX0ZDU19WUE9SVF9VTklOSVQgCQk9IDAsCisJQkZBX0ZDU19WUE9SVF9DUkVBVEVEIAkJPSAxLAorCUJGQV9GQ1NfVlBPUlRfT0ZGTElORSAJCT0gMSwKKwlCRkFfRkNTX1ZQT1JUX0ZESVNDX1NFTkQgCT0gMiwKKwlCRkFfRkNTX1ZQT1JUX0ZESVNDIAkJPSAzLAorCUJGQV9GQ1NfVlBPUlRfRkRJU0NfUkVUUlkgCT0gNCwKKwlCRkFfRkNTX1ZQT1JUX09OTElORSAJCT0gNSwKKwlCRkFfRkNTX1ZQT1JUX0RFTEVUSU5HIAkJPSA2LAorCUJGQV9GQ1NfVlBPUlRfQ0xFQU5VUCAJCT0gNiwKKwlCRkFfRkNTX1ZQT1JUX0xPR09fU0VORCAJPSA3LAorCUJGQV9GQ1NfVlBPUlRfTE9HTyAJCQk9IDgsCisJQkZBX0ZDU19WUE9SVF9FUlJPUgkJCT0gOSwKKwlCRkFfRkNTX1ZQT1JUX01BWF9TVEFURSwKK307CisKKy8qKgorICogdnBvcnQgc3RhdGlzdGljcworICovCitzdHJ1Y3QgYmZhX3Zwb3J0X3N0YXRzX3MgeworCXN0cnVjdCBiZmFfcG9ydF9zdGF0c19zIHBvcnRfc3RhdHM7CS8qICBiYXNlIGNsYXNzIChwb3J0KSBzdGF0cyAqLworCS8qCisJICogVE9ETyAtIHJlbW92ZQorCSAqLworCisJdTMyICAgICAgICBmZGlzY19zZW50OwkvKiAgbnVtIGZkaXNjIHNlbnQgKi8KKwl1MzIgICAgICAgIGZkaXNjX2FjY2VwdHM7CS8qICBmZGlzYyBhY2NlcHRzICovCisJdTMyICAgICAgICBmZGlzY19yZXRyaWVzOwkvKiAgZmRpc2MgcmV0cmllcyAqLworCXUzMiAgICAgICAgZmRpc2NfdGltZW91dHM7CS8qICBmZGlzYyB0aW1lb3V0cyAqLworCXUzMiAgICAgICAgZmRpc2NfcnNwX2VycjsJLyogIGZkaXNjIHJlc3BvbnNlIGVycm9yICovCisJdTMyICAgICAgICBmZGlzY19hY2NfYmFkOwkvKiAgYmFkIGZkaXNjIGFjY2VwdHMgKi8KKwl1MzIgICAgICAgIGZkaXNjX3JlamVjdHM7CS8qICBmZGlzYyByZWplY3RzICovCisJdTMyICAgICAgICBmZGlzY191bmtub3duX3JzcDsKKwkvKgorCSAqITwgZmRpc2MgcnNwIHVua25vd24gZXJyb3IKKwkgKi8KKwl1MzIgICAgICAgIGZkaXNjX2FsbG9jX3dhaXQ7LyogIGZkaXNjIHJlcSAoZmN4cClhbGxvYyB3YWl0ICovCisKKwl1MzIgICAgICAgIGxvZ29fYWxsb2Nfd2FpdDsvKiAgbG9nbyByZXEgKGZjeHApIGFsbG9jIHdhaXQgKi8KKwl1MzIgICAgICAgIGxvZ29fc2VudDsJLyogIGxvZ28gc2VudCAqLworCXUzMiAgICAgICAgbG9nb19hY2NlcHRzOwkvKiAgbG9nbyBhY2NlcHRzICovCisJdTMyICAgICAgICBsb2dvX3JlamVjdHM7CS8qICBsb2dvIHJlamVjdHMgKi8KKwl1MzIgICAgICAgIGxvZ29fcnNwX2VycjsJLyogIGxvZ28gcnNwIGVycm9ycyAqLworCXUzMiAgICAgICAgbG9nb191bmtub3duX3JzcDsKKwkJCS8qICBsb2dvIHJzcCB1bmtub3duIGVycm9ycyAqLworCisJdTMyICAgICAgICBmYWJfbm9fbnBpdjsJLyogIGZhYnJpYyBkb2VzIG5vdCBzdXBwb3J0IG5waXYgKi8KKworCXUzMiAgICAgICAgZmFiX29mZmxpbmU7CS8qICBvZmZsaW5lIGV2ZW50cyBmcm9tIGZhYiBTTSAqLworCXUzMiAgICAgICAgZmFiX29ubGluZTsJLyogIG9ubGluZSBldmVudHMgZnJvbSBmYWIgU00gKi8KKwl1MzIgICAgICAgIGZhYl9jbGVhbnVwOwkvKiAgY2xlYW51cCByZXF1ZXN0IGZyb20gZmFiIFNNICovCisJdTMyICAgICAgICByc3ZkOworfTsKKworLyoqCisgKiBCRkEgdnBvcnQgYXR0cmlidXRlIHJldHVybmVkIGluIHF1ZXJpZXMKKyAqLworc3RydWN0IGJmYV92cG9ydF9hdHRyX3MgeworCXN0cnVjdCBiZmFfcG9ydF9hdHRyX3MgICBwb3J0X2F0dHI7IC8qICBiYXNlIGNsYXNzIChwb3J0KSBhdHRyaWJ1dGVzICovCisJZW51bSBiZmFfdnBvcnRfc3RhdGUgdnBvcnRfc3RhdGU7IC8qICB2cG9ydCBzdGF0ZSAqLworCXUzMiAgICAgICAgICByc3ZkOworfTsKKworI2VuZGlmIC8qIF9fQkZBX0RFRlNfVlBPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2IuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY2IvYmZhX2ZjYi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjI5NjNiMGIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2IuaApAQCAtMCwwICsxLDMzIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9mY2IuaCBCRkEgRkNTIGNhbGxiYWNrIGludGVyZmFjZXMKKyAqLworCisjaWZuZGVmIF9fQkZBX0ZDQl9IX18KKyNkZWZpbmUgX19CRkFfRkNCX0hfXworCisvKioKKyAqICBmY2IgTWFpbiBmY3MgY2FsbGJhY2tzCisgKi8KKwordm9pZCBiZmFfZmNiX2V4aXQoc3RydWN0IGJmYWRfcyAqYmZhZCk7CisKKworCisjZW5kaWYgLyogX19CRkFfRkNCX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2ZjYi9iZmFfZmNiX2ZjcGltLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2JfZmNwaW0uaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hNmM3MGFlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2ZjYi9iZmFfZmNiX2ZjcGltLmgKQEAgLTAsMCArMSw3NiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyogOiBiZmFkX2ZjcGltLmggLSBCRkEgRkNTIGluaXRpYXRvciBtb2RlIHJlbW90ZSBwb3J0IGNhbGxiYWNrcworICovCisKKyNpZm5kZWYgX19CRkFEX0ZDQl9GQ1BJTV9IX18KKyNkZWZpbmUgX19CRkFEX0ZDQl9GQ1BJTV9IX18KKworc3RydWN0IGJmYWRfaXRuaW1fczsKKworLyoKKyAqIFJQSU0gY2FsbGJhY2tzCisgKi8KKworLyoqCisgKiAJTWVtb3J5IGFsbG9jYXRpb24gZm9yIHJlbW90ZSBwb3J0IGluc3RhbmNlLiBDYWxsZWQgYmVmb3JlIFBSTEkgaXMKKyAqIAlpbml0aWF0ZWQgdG8gdGhlIHJlbW90ZSB0YXJnZXQgcG9ydC4KKyAqCisgKiBAcGFyYW1baW5dIGJmYWQJCS0gZHJpdmVyIGluc3RhbmNlCisgKiBAcGFyYW1bb3V0XSBpdG5pbQkJLSBGQ1MgcmVtb3RlIHBvcnQgKElNKSBpbnN0YW5jZQorICogQHBhcmFtW291dF0gaXRuaW1fZHJ2CS0gZHJpdmVyIHJlbW90ZSBwb3J0IChJTSkgaW5zdGFuY2UKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLwordm9pZCBiZmFfZmNiX2l0bmltX2FsbG9jKHN0cnVjdCBiZmFkX3MgKmJmYWQsIHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKippdG5pbSwKKwkJCQkgICAgc3RydWN0IGJmYWRfaXRuaW1fcyAqKml0bmltX2Rydik7CisKKy8qKgorICogCQlGcmVlIHJlbW90ZSBwb3J0IChJTSkgaW5zdGFuY2UuCisgKgorICogQHBhcmFtW2luXSBiZmFkCS0gZHJpdmVyIGluc3RhbmNlCisgKiBAcGFyYW1baW5dIGl0bmltX2RydgktIGRyaXZlciByZW1vdGUgcG9ydCBpbnN0YW5jZQorICoKKyAqIEByZXR1cm4gTm9uZQorICovCit2b2lkICAgICAgICAgICAgYmZhX2ZjYl9pdG5pbV9mcmVlKHN0cnVjdCBiZmFkX3MgKmJmYWQsCisJCQkJICAgc3RydWN0IGJmYWRfaXRuaW1fcyAqaXRuaW1fZHJ2KTsKKworLyoqCisgKiAJTm90aWZpY2F0aW9uIG9mIHdoZW4gbG9naW4gd2l0aCBhIHJlbW90ZSB0YXJnZXQgZGV2aWNlIGlzIGNvbXBsZXRlLgorICoKKyAqIEBwYXJhbVtpbl0gaXRuaW1fZHJ2CS0gZHJpdmVyIHJlbW90ZSBwb3J0IGluc3RhbmNlCisgKgorICogQHJldHVybiBOb25lCisgKi8KK3ZvaWQgICAgICAgICAgICBiZmFfZmNiX2l0bmltX29ubGluZShzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbV9kcnYpOworCisvKioKKyAqIAlOb3RpZmljYXRpb24gd2hlbiBsb2dpbiB3aXRoIHRoZSByZW1vdGUgZGV2aWNlIGlzIHNldmVyZWQuCisgKgorICogQHBhcmFtW2luXSBpdG5pbV9kcnYJLSBkcml2ZXIgcmVtb3RlIHBvcnQgaW5zdGFuY2UKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9mY2JfaXRuaW1fb2ZmbGluZShzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbV9kcnYpOworCit2b2lkICAgICAgICAgICAgYmZhX2ZjYl9pdG5pbV90b3ZfYmVnaW4oc3RydWN0IGJmYWRfaXRuaW1fcyAqaXRuaW1fZHJ2KTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNiX2l0bmltX3RvdihzdHJ1Y3QgYmZhZF9pdG5pbV9zICppdG5pbV9kcnYpOworCisjZW5kaWYgLyogX19CRkFEX0ZDQl9GQ1BJTV9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY2IvYmZhX2ZjYl9wb3J0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2JfcG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjVmZDdmOTgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2JfcG9ydC5oCkBAIC0wLDAgKzEsMTEzIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9mY2JfcG9ydC5oIEJGQSBGQ1MgdmlydHVhbCBwb3J0IGRyaXZlciBpbnRlcmZhY2VzCisgKi8KKworI2lmbmRlZiBfX0JGQV9GQ0JfUE9SVF9IX18KKyNkZWZpbmUgX19CRkFfRkNCX1BPUlRfSF9fCisKKyNpbmNsdWRlIDxmY2IvYmZhX2ZjYl92cG9ydC5oPgorLyoqCisgKiAgZmNzX3BvcnRfZmNiIEZDUyBwb3J0IGRyaXZlciBpbnRlcmZhY2VzCisgKi8KKworLyoKKyAqIEZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KK3N0cnVjdCBiZmFkX3BvcnRfczsKKworLyoKKyAqIENhbGxiYWNrIGZ1bmN0aW9ucyBmcm9tIEJGQSBGQ1MgdG8gZHJpdmVyCisgKi8KKworLyoqCisgKiAJQ2FsbCBmcm9tIEZDUyB0byBkcml2ZXIgbW9kdWxlIHdoZW4gYSBwb3J0IGlzIGluc3RhbnRpYXRlZC4gVGhlIHBvcnQKKyAqIAljYW4gYmUgYSBiYXNlIHBvcnQgb3IgYSB2aXJ0dWFsIHBvcnQgd2l0aCBpbiB0aGUgYmFzZSBmYWJyaWMgb3IKKyAqIAlhIHZpcnR1YWwgZmFicmljLgorICoKKyAqICBPbiB0aGlzIGNhbGxiYWNrLCBkcml2ZXIgaXMgc3VwcG9zZWQgdG8gY3JlYXRlIHNjc2lfaG9zdCwgc2NzaV90Z3Qgb3IKKyAqICBuZXR3b3JrIGludGVyZmFjZXMgYmFzZXMgb24gcG9ydHMgcGVyc29uYWxpdHkvcm9sZXMuCisgKgorICogICAgICBiYXNlIHBvcnQgb2YgYmFzZSBmYWJyaWM6CXZmX2RydiA9PSBOVUxMICYmIHZwX2RydiA9PSBOVUxMCisgKiAgICAgIHZwb3J0IG9mIGJhc2UgZmFicmljOgkJdmZfZHJ2ID09IE5VTEwgJiYgdnBfZHJ2ICE9IE5VTEwKKyAqICAgICAgYmFzZSBwb3J0IG9mIFZGOgkJdmZfZHJ2ICE9IE5VTEwgJiYgdnBfZHJ2ID09IE5VTEwKKyAqICAgICAgdnBvcnQgb2YgVkY6CQkJdmZfZHJ2ICE9IE5VTEwgJiYgdnBfZHJ2ICE9IE5VTEwKKyAqCisgKiBAcGFyYW1baW5dIGJmYWQgICAtIGRyaXZlciBpbnN0YW5jZQorICogQHBhcmFtW2luXSBwb3J0ICAgLSBGQ1MgcG9ydCBpbnN0YW5jZQorICogQHBhcmFtW2luXSByb2xlcyAgLSBwb3J0IHJvbGVzOiBJTSwgVE0sIElQCisgKiBAcGFyYW1baW5dIHZmX2RydiAtIFZGIGRyaXZlciBpbnN0YW5jZSwgTlVMTCBpZiBiYXNlIGZhYnJpYyAobm8gVkYpCisgKiBAcGFyYW1baW5dIHZwX2RydiAtIHZwb3J0IGRyaXZlciBpbnN0YW5jZSwgTlVMTCBpZiBiYXNlIHBvcnQKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLworc3RydWN0IGJmYWRfcG9ydF9zICpiZmFfZmNiX3BvcnRfbmV3KHN0cnVjdCBiZmFkX3MgKmJmYWQsCisJCQlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQllbnVtIGJmYV9wb3J0X3JvbGUgcm9sZXMsIHN0cnVjdCBiZmFkX3ZmX3MgKnZmX2RydiwKKwkJCXN0cnVjdCBiZmFkX3Zwb3J0X3MgKnZwX2Rydik7CisKKy8qKgorICogCUNhbGwgZnJvbSBGQ1MgdG8gZHJpdmVyIG1vZHVsZSB3aGVuIGEgcG9ydCBpcyBkZWxldGVkLiBUaGUgcG9ydAorICogCWNhbiBiZSBhIGJhc2UgcG9ydCBvciBhIHZpcnR1YWwgcG9ydCB3aXRoIGluIHRoZSBiYXNlIGZhYnJpYyBvcgorICogCWEgdmlydHVhbCBmYWJyaWMuCisgKgorICogQHBhcmFtW2luXSBiZmFkICAgLSBkcml2ZXIgaW5zdGFuY2UKKyAqIEBwYXJhbVtpbl0gcm9sZXMgIC0gcG9ydCByb2xlczogSU0sIFRNLCBJUAorICogQHBhcmFtW2luXSB2Zl9kcnYgLSBWRiBkcml2ZXIgaW5zdGFuY2UsIE5VTEwgaWYgYmFzZSBmYWJyaWMgKG5vIFZGKQorICogQHBhcmFtW2luXSB2cF9kcnYgLSB2cG9ydCBkcml2ZXIgaW5zdGFuY2UsIE5VTEwgaWYgYmFzZSBwb3J0CisgKgorICogQHJldHVybiBOb25lCisgKi8KK3ZvaWQgYmZhX2ZjYl9wb3J0X2RlbGV0ZShzdHJ1Y3QgYmZhZF9zICpiZmFkLCBlbnVtIGJmYV9wb3J0X3JvbGUgcm9sZXMsCisJCQlzdHJ1Y3QgYmZhZF92Zl9zICp2Zl9kcnYsIHN0cnVjdCBiZmFkX3Zwb3J0X3MgKnZwX2Rydik7CisKKy8qKgorICogCU5vdGlmaWNhdGlvbiB3aGVuIHBvcnQgdHJhbnNpdGlvbnMgdG8gT05MSU5FIHN0YXRlLgorICoKKyAqIE9ubGluZSBub3RpZmljYXRpb24gaXMgYSBsb2dpY2FsIGxpbmsgdXAgZm9yIHRoZSBsb2NhbCBwb3J0LiBUaGlzCisgKiBub3RpZmljYXRpb24gaXMgc2VudCBhZnRlciBhIHN1Y2Nlc3NmdWxsIEZMT0dJLCBvciBhIHN1Y2Nlc3NmdWwKKyAqIGxpbmsgaW5pdGlhbGl6YXRpb24gaW4gcHJvdmlhdGUtbG9vcCBvciBOMk4gdG9wb2xvZ2llcy4KKyAqCisgKiBAcGFyYW1baW5dIGJmYWQgICAtIGRyaXZlciBpbnN0YW5jZQorICogQHBhcmFtW2luXSByb2xlcyAgLSBwb3J0IHJvbGVzOiBJTSwgVE0sIElQCisgKiBAcGFyYW1baW5dIHZmX2RydiAtIFZGIGRyaXZlciBpbnN0YW5jZSwgTlVMTCBpZiBiYXNlIGZhYnJpYyAobm8gVkYpCisgKiBAcGFyYW1baW5dIHZwX2RydiAtIHZwb3J0IGRyaXZlciBpbnN0YW5jZSwgTlVMTCBpZiBiYXNlIHBvcnQKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLwordm9pZCBiZmFfZmNiX3BvcnRfb25saW5lKHN0cnVjdCBiZmFkX3MgKmJmYWQsIGVudW0gYmZhX3BvcnRfcm9sZSByb2xlcywKKwkJCXN0cnVjdCBiZmFkX3ZmX3MgKnZmX2Rydiwgc3RydWN0IGJmYWRfdnBvcnRfcyAqdnBfZHJ2KTsKKworLyoqCisgKiAJTm90aWZpY2F0aW9uIHdoZW4gcG9ydCB0cmFuc2l0aW9ucyB0byBPRkZMSU5FIHN0YXRlLgorICoKKyAqIE9mZmxpbmUgbm90aWZpY2F0aW9uIGlzIGEgbG9naWNhbCBsaW5rIGRvd24gZm9yIHRoZSBsb2NhbCBwb3J0LgorICoKKyAqIEBwYXJhbVtpbl0gYmZhZCAgIC0gZHJpdmVyIGluc3RhbmNlCisgKiBAcGFyYW1baW5dIHJvbGVzICAtIHBvcnQgcm9sZXM6IElNLCBUTSwgSVAKKyAqIEBwYXJhbVtpbl0gdmZfZHJ2IC0gVkYgZHJpdmVyIGluc3RhbmNlLCBOVUxMIGlmIGJhc2UgZmFicmljIChubyBWRikKKyAqIEBwYXJhbVtpbl0gdnBfZHJ2IC0gdnBvcnQgZHJpdmVyIGluc3RhbmNlLCBOVUxMIGlmIGJhc2UgcG9ydAorICoKKyAqIEByZXR1cm4gTm9uZQorICovCit2b2lkIGJmYV9mY2JfcG9ydF9vZmZsaW5lKHN0cnVjdCBiZmFkX3MgKmJmYWQsIGVudW0gYmZhX3BvcnRfcm9sZSByb2xlcywKKwkJCXN0cnVjdCBiZmFkX3ZmX3MgKnZmX2Rydiwgc3RydWN0IGJmYWRfdnBvcnRfcyAqdnBfZHJ2KTsKKworCisjZW5kaWYgLyogX19CRkFfRkNCX1BPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2JfcnBvcnQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY2IvYmZhX2ZjYl9ycG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUwMjYxYmIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2JfcnBvcnQuaApAQCAtMCwwICsxLDgwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9mY2JfcnBvcnQuaCBCRkEgRkNTIHJwb3J0IGRyaXZlciBpbnRlcmZhY2VzCisgKi8KKworI2lmbmRlZiBfX0JGQV9GQ0JfUlBPUlRfSF9fCisjZGVmaW5lIF9fQkZBX0ZDQl9SUE9SVF9IX18KKworLyoqCisgKiAgZmNzX3Jwb3J0X2ZjYiBSZW1vdGUgcG9ydCBkcml2ZXIgaW50ZXJmYWNlcworICovCisKKworc3RydWN0IGJmYWRfcnBvcnRfczsKKworLyoKKyAqIENhbGxiYWNrIGZ1bmN0aW9ucyBmcm9tIEJGQSBGQ1MgdG8gZHJpdmVyCisgKi8KKworLyoqCisgKiAJQ29tcGxldGlvbiBjYWxsYmFjayBmb3IgYmZhX2Zjc19ycG9ydF9hZGQoKS4KKyAqCisgKiBAcGFyYW1baW5dIHJwb3J0X2RydiAtIGRyaXZlciBpbnN0YW5jZSBvZiBycG9ydAorICoKKyAqIEByZXR1cm4gTm9uZQorICovCit2b2lkIGJmYV9mY2JfcnBvcnRfYWRkKHN0cnVjdCBiZmFkX3Jwb3J0X3MgKnJwb3J0X2Rydik7CisKKy8qKgorICogCUNvbXBsZXRpb24gY2FsbGJhY2sgZm9yIGJmYV9mY3NfcnBvcnRfcmVtb3ZlKCkuCisgKgorICogQHBhcmFtW2luXSBycG9ydF9kcnYgLSBkcml2ZXIgaW5zdGFuY2Ugb2YgcnBvcnQKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLwordm9pZCBiZmFfZmNiX3Jwb3J0X3JlbW92ZShzdHJ1Y3QgYmZhZF9ycG9ydF9zICpycG9ydF9kcnYpOworCisvKioKKyAqIAkJQ2FsbCB0byBhbGxvY2F0ZSBhIHJwb3J0IGluc3RhbmNlLgorICoKKyAqIEBwYXJhbVtpbl0gYmZhZCAtIGRyaXZlciBpbnN0YW5jZQorICogQHBhcmFtW291dF0gcnBvcnQgLSBCRkEgRkNTIGluc3RhbmNlIG9mIHJwb3J0CisgKiBAcGFyYW1bb3V0XSBycG9ydF9kcnYgLSBkcml2ZXIgaW5zdGFuY2Ugb2YgcnBvcnQKKyAqCisgKiBAcmV0dmFsIEJGQV9TVEFUVVNfT0sgLSBzdWNjZXNzZnVsbHkgYWxsb2NhdGVkCisgKiBAcmV0dmFsIEJGQV9TVEFUVVNfRU5PTUVNIC0gY2Fubm90IGFsbG9jYXRlCisgKi8KK2JmYV9zdGF0dXNfdCBiZmFfZmNiX3Jwb3J0X2FsbG9jKHN0cnVjdCBiZmFkX3MgKmJmYWQsCisJCQlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICoqcnBvcnQsCisJCQlzdHJ1Y3QgYmZhZF9ycG9ydF9zICoqcnBvcnRfZHJ2KTsKKworLyoqCisgKiAJQ2FsbCB0byBmcmVlIHJwb3J0IG1lbW9yeSByZXNvdXJjZXMuCisgKgorICogQHBhcmFtW2luXSBiZmFkIC0gZHJpdmVyIGluc3RhbmNlCisgKiBAcGFyYW1baW5dIHJwb3J0X2RydiAtIGRyaXZlciBpbnN0YW5jZSBvZiBycG9ydAorICoKKyAqIEByZXR1cm4gTm9uZQorICovCit2b2lkIGJmYV9mY2JfcnBvcnRfZnJlZShzdHJ1Y3QgYmZhZF9zICpiZmFkLCBzdHJ1Y3QgYmZhZF9ycG9ydF9zICoqcnBvcnRfZHJ2KTsKKworCisKKyNlbmRpZiAvKiBfX0JGQV9GQ0JfUlBPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2JfdmYuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY2IvYmZhX2ZjYl92Zi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNmZDNmYWMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNiL2JmYV9mY2JfdmYuaApAQCAtMCwwICsxLDQ3IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9mY2JfdmYuaCBCRkEgRkNTIHZpcnR1YWwgZmFicmljIGRyaXZlciBpbnRlcmZhY2VzCisgKi8KKworI2lmbmRlZiBfX0JGQV9GQ0JfVkZfSF9fCisjZGVmaW5lIF9fQkZBX0ZDQl9WRl9IX18KKworLyoqCisgKiAgZmNzX3ZmX2ZjYiBWaXJ0dWFsIGZhYnJpYyBkcml2ZXIgaW50cmVmYWNlcworICovCisKKworc3RydWN0IGJmYWRfdmZfczsKKworLyoKKyAqIENhbGxiYWNrIGZ1bmN0aW9ucyBmcm9tIEJGQSBGQ1MgdG8gZHJpdmVyCisgKi8KKworLyoqCisgKiAJQ29tcGxldGlvbiBjYWxsYmFjayBmb3IgYmZhX2Zjc192Zl9zdG9wKCkuCisgKgorICogQHBhcmFtW2luXSB2Zl9kcnYgLSBkcml2ZXIgaW5zdGFuY2Ugb2YgdmYKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9mY2JfdmZfc3RvcChzdHJ1Y3QgYmZhZF92Zl9zICp2Zl9kcnYpOworCisKKworI2VuZGlmIC8qIF9fQkZBX0ZDQl9WRl9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY2IvYmZhX2ZjYl92cG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2ZjYi9iZmFfZmNiX3Zwb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTM5ZjQ3NAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY2IvYmZhX2ZjYl92cG9ydC5oCkBAIC0wLDAgKzEsNDcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2ZjYl92cG9ydC5oIEJGQSBGQ1MgdmlydHVhbCBwb3J0IGRyaXZlciBpbnRlcmZhY2VzCisgKi8KKworI2lmbmRlZiBfX0JGQV9GQ0JfVlBPUlRfSF9fCisjZGVmaW5lIF9fQkZBX0ZDQl9WUE9SVF9IX18KKworLyoqCisgKiAgZmNzX3Zwb3J0X2ZjYiBWaXJ0dWFsIHBvcnQgZHJpdmVyIGludGVyZmFjZXMKKyAqLworCisKK3N0cnVjdCBiZmFkX3Zwb3J0X3M7CisKKy8qCisgKiBDYWxsYmFjayBmdW5jdGlvbnMgZnJvbSBCRkEgRkNTIHRvIGRyaXZlcgorICovCisKKy8qKgorICogCUNvbXBsZXRpb24gY2FsbGJhY2sgZm9yIGJmYV9mY3NfdnBvcnRfZGVsZXRlKCkuCisgKgorICogQHBhcmFtW2luXSB2cG9ydF9kcnYgLSBkcml2ZXIgaW5zdGFuY2Ugb2YgdnBvcnQKKyAqCisgKiBAcmV0dXJuIE5vbmUKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9mY2JfdnBvcnRfZGVsZXRlKHN0cnVjdCBiZmFkX3Zwb3J0X3MgKnZwb3J0X2Rydik7CisKKworCisjZW5kaWYgLyogX19CRkFfRkNCX1ZQT1JUX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNzL2JmYV9mY3MuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42Mjc2NjljCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzLmgKQEAgLTAsMCArMSw3MyBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0ZDU19IX18KKyNkZWZpbmUgX19CRkFfRkNTX0hfXworCisjaW5jbHVkZSA8Y3MvYmZhX2RlYnVnLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19zdGF0dXMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3ZlcnNpb24uaD4KKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc19mYWJyaWMuaD4KKworI2RlZmluZSBCRkFfRkNTX09TX1NUUl9MRU4gIAkJNjQKKworc3RydWN0IGJmYV9mY3Nfc3RhdHNfcyB7CisJc3RydWN0IHsKKwkJdTMyICAgICAgICB1bnRhZ2dlZDsgLyogIHVudGFnZ2VkIHJlY2VpdmUgZnJhbWVzICovCisJCXUzMiAgICAgICAgdGFnZ2VkOwkvKiAgdGFnZ2VkIHJlY2VpdmUgZnJhbWVzICovCisJCXUzMiAgICAgICAgdmZpZF91bmtub3duOwkvKiAgVkYgaWQgaXMgdW5rbm93biAqLworCX0gdWY7Cit9OworCitzdHJ1Y3QgYmZhX2Zjc19kcml2ZXJfaW5mb19zIHsKKwl1OCAgdmVyc2lvbltCRkFfVkVSU0lPTl9MRU5dOwkJLyogIERyaXZlciBWZXJzaW9uICovCisJdTggIGhvc3RfbWFjaGluZV9uYW1lW0JGQV9GQ1NfT1NfU1RSX0xFTl07CisJdTggIGhvc3Rfb3NfbmFtZVtCRkFfRkNTX09TX1NUUl9MRU5dOyAvKiAgT1MgbmFtZSBhbmQgdmVyc2lvbiAqLworCXU4ICBob3N0X29zX3BhdGNoW0JGQV9GQ1NfT1NfU1RSX0xFTl07LyogIHBhdGNoIG9yIHNlcnZpY2UgcGFjayAqLworCXU4ICBvc19kZXZpY2VfbmFtZVtCRkFfRkNTX09TX1NUUl9MRU5dOyAvKiAgRHJpdmVyIERldmljZSBOYW1lICovCit9OworCitzdHJ1Y3QgYmZhX2Zjc19zIHsKKwlzdHJ1Y3QgYmZhX3MgICAgICAqYmZhOwkvKiAgY29ycmVzcG9uZGluZyBCRkEgYmZhIGluc3RhbmNlICovCisJc3RydWN0IGJmYWRfcyAgICAgICAgICpiZmFkOyAvKiAgY29ycmVzcG9uZGluZyBCREEgZHJpdmVyIGluc3RhbmNlICovCisJc3RydWN0IGJmYV9sb2dfbW9kX3MgICpsb2dtOwkvKiAgZHJpdmVyIGxvZ2dpbmcgbW9kdWxlIGluc3RhbmNlICovCisJc3RydWN0IGJmYV90cmNfbW9kX3MgICp0cmNtb2Q7CS8qICB0cmFjaW5nIG1vZHVsZSAqLworCXN0cnVjdCBiZmFfYWVuX3MgICAgICAqYWVuOwkvKiAgYWVuIGNvbXBvbmVudCAqLworCWJmYV9ib29sZWFuX3QgICB2Zl9lbmFibGVkOwkvKiAgVkYgbW9kZSBpcyBlbmFibGVkICovCisJYmZhX2Jvb2xlYW5fdCBtaW5fY2ZnOwkJLyogbWluIGNmZyBlbmFibGVkL2Rpc2FibGVkICovCisJdTE2ICAgICAgICBwb3J0X3ZmaWQ7CS8qICBwb3J0IGRlZmF1bHQgVkYgSUQgKi8KKwlzdHJ1Y3QgYmZhX2Zjc19kcml2ZXJfaW5mb19zIGRyaXZlcl9pbmZvOworCXN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zIGZhYnJpYzsgLyogIGJhc2UgZmFicmljIHN0YXRlIG1hY2hpbmUgKi8KKwlzdHJ1Y3QgYmZhX2Zjc19zdGF0c19zCXN0YXRzOwkvKiAgRkNTIHN0YXRpc3RpY3MgKi8KKwlzdHJ1Y3QgYmZhX3djX3MgICAgICAgCXdjOwkvKiAgd2FpdGluZyBjb3VudGVyICovCit9OworCisvKgorICogYmZhIGZjcyBBUEkgZnVuY3Rpb25zCisgKi8KK3ZvaWQgYmZhX2Zjc19pbml0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcywgc3RydWN0IGJmYV9zICpiZmEsIHN0cnVjdCBiZmFkX3MgKmJmYWQsCisJCQliZmFfYm9vbGVhbl90IG1pbl9jZmcpOwordm9pZCBiZmFfZmNzX2RyaXZlcl9pbmZvX2luaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzLAorCQkJc3RydWN0IGJmYV9mY3NfZHJpdmVyX2luZm9fcyAqZHJpdmVyX2luZm8pOwordm9pZCBiZmFfZmNzX2V4aXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKTsKK3ZvaWQgYmZhX2Zjc190cmNfaW5pdChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHN0cnVjdCBiZmFfdHJjX21vZF9zICp0cmNtb2QpOwordm9pZCBiZmFfZmNzX2xvZ19pbml0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcywgc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ21vZCk7Cit2b2lkIGJmYV9mY3NfYWVuX2luaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzLCBzdHJ1Y3QgYmZhX2Flbl9zICphZW4pOwordm9pZCAJICAJYmZhX2Zjc19zdGFydChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOworCisjZW5kaWYgLyogX19CRkFfRkNTX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzX2F1dGguaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19hdXRoLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjhjNGM5ZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19hdXRoLmgKQEAgLTAsMCArMSw4MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0ZDU19BVVRIX0hfXworI2RlZmluZSBfX0JGQV9GQ1NfQVVUSF9IX18KKworc3RydWN0IGJmYV9mY3NfczsKKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfc3RhdHVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19hdXRoLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc192Zi5oPgorI2luY2x1ZGUgPGNzL2JmYV9xLmg+CisjaW5jbHVkZSA8Y3MvYmZhX3NtLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX2xwb3J0Lmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvZmNfc3AuaD4KKworc3RydWN0IGJmYV9mY3NfZmFicmljX3M7CisKKworCitzdHJ1Y3QgYmZhX2Zjc19hdXRoX3MgeworCWJmYV9zbV90CXNtOwkvKiAgc3RhdGUgbWFjaGluZSAqLworCWJmYV9ib29sZWFuX3QgICBwb2xpY3k7CS8qICBhdXRoZW50aWNhdGlvbiBlbmFibGVkL2Rpc2FibGVkICovCisJZW51bSBiZmFfYXV0aF9zdGF0dXMgc3RhdHVzOwkvKiAgYXV0aGVudGljYXRpb24gc3RhdHVzICovCisJZW51bSBhdXRoX3JqdF9jb2RlcyAgcmp0X2NvZGU7CS8qICBhdXRoIHJlamVjdCBzdGF0dXMgKi8KKwllbnVtIGF1dGhfcmp0X2NvZGVfZXhwcyAgcmp0X2NvZGVfZXhwOwkvKiAgYXV0aCByZWplY3QgcmVhc29uICovCisJZW51bSBiZmFfYXV0aF9hbGdvIGFsZ287CS8qICBBdXRoZW50aWNhdGlvbiBhbGdvcml0aG0gKi8KKwlzdHJ1Y3QgYmZhX2F1dGhfc3RhdHNfcyBzdGF0czsJLyogIFN0YXRpc3RpY3MgKi8KKwllbnVtIGF1dGhfZGhfZ2lkICAgZ3JvdXA7CS8qICBESChkaWZmaWUtaGVsbG1hbikgR3JvdXAgKi8KKwllbnVtIGJmYV9hdXRoX3NlY3JldHNvdXJjZSBzb3VyY2U7CS8qICBTZWNyZXQgc291cmNlICovCisJY2hhciAgICAgICAgICAgIHNlY3JldFtCRkFfQVVUSF9TRUNSRVRfU1RSSU5HX0xFTl07CisJCQkJLyogIHNlY3JldCBzdHJpbmcgKi8KKwl1OCAgICAgICAgIHNlY3JldF9sZW47CisJCQkJLyogIHNlY3JldCBzdHJpbmcgbGVuZ3RoICovCisJdTggICAgICAgICBucmV0cmllczsKKwkJCQkvKiAgbnVtYmVyIG9mIHJldHJpZXMgKi8KKwlzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljOy8qICBwb2ludGVyIHRvIGZhYnJpYyAqLworCXU4ICAgICAgICAgc2VudGNvZGU7CS8qICBwb2ludGVyIHRvIHJlc3BvbnNlIGRhdGEgKi8KKwl1OCAgICAgICAgKnJlc3BvbnNlOwkvKiAgcG9pbnRlciB0byByZXNwb25zZSBkYXRhICovCisJc3RydWN0IGJmYV90aW1lcl9zIGRlbGF5X3RpbWVyOyAJLyogIGRlbGF5IHRpbWVyICovCisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CQkvKiAgcG9pbnRlciB0byBmY3hwICovCisJc3RydWN0IGJmYV9mY3hwX3dxZV9zIGZjeHBfd3FlOworfTsKKworLyoqCisgKiBiZmEgZmNzIGF1dGhlbnRpY2F0aW9uIHB1YmxpYyBmdW5jdGlvbnMKKyAqLworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfYXV0aF9nZXRfYXR0cihzdHJ1Y3QgYmZhX2Zjc19zICpwb3J0LAorCQkJCSAgICAgIHN0cnVjdCBiZmFfYXV0aF9hdHRyX3MgKmF0dHIpOworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfYXV0aF9zZXRfcG9saWN5KHN0cnVjdCBiZmFfZmNzX3MgKnBvcnQsCisJCQkJCWJmYV9ib29sZWFuX3QgcG9saWN5KTsKK2VudW0gYmZhX2F1dGhfc3RhdHVzIGJmYV9mY3NfYXV0aF9nZXRfc3RhdHVzKHN0cnVjdCBiZmFfZmNzX3MgKnBvcnQpOworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfYXV0aF9zZXRfYWxnbyhzdHJ1Y3QgYmZhX2Zjc19zICpwb3J0LAorCQkJCSAgICAgIGVudW0gYmZhX2F1dGhfYWxnbyBhbGdvKTsKK2JmYV9zdGF0dXNfdCAgICBiZmFfZmNzX2F1dGhfZ2V0X3N0YXRzKHN0cnVjdCBiZmFfZmNzX3MgKnBvcnQsCisJCQkJICAgICAgIHN0cnVjdCBiZmFfYXV0aF9zdGF0c19zICpzdGF0cyk7CitiZmFfc3RhdHVzX3QgICAgYmZhX2Zjc19hdXRoX3NldF9kaF9ncm91cChzdHJ1Y3QgYmZhX2Zjc19zICpwb3J0LCBpbnQgZ3JvdXApOworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfYXV0aF9zZXRfc2VjcmV0c3RyaW5nKHN0cnVjdCBiZmFfZmNzX3MgKnBvcnQsCisJCQkJCSAgICAgIGNoYXIgKnNlY3JldCk7CitiZmFfc3RhdHVzX3QgICAgYmZhX2Zjc19hdXRoX3NldF9zZWNyZXRzdHJpbmdfZW5jcnlwdChzdHJ1Y3QgYmZhX2Zjc19zICpwb3J0LAorCQkJCQkgICAgICB1MzIgc2VjcmV0W10sIHUzMiBsZW4pOworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfYXV0aF9zZXRfc2VjcmV0c291cmNlKHN0cnVjdCBiZmFfZmNzX3MgKnBvcnQsCisJCQkJCSAgICAgIGVudW0gYmZhX2F1dGhfc2VjcmV0c291cmNlIHNyYyk7CitiZmFfc3RhdHVzX3QgICAgYmZhX2Zjc19hdXRoX3Jlc2V0X3N0YXRzKHN0cnVjdCBiZmFfZmNzX3MgKnBvcnQpOworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfYXV0aF9yZWluaXQoc3RydWN0IGJmYV9mY3NfcyAqcG9ydCk7CisKKyNlbmRpZiAvKiBfX0JGQV9GQ1NfQVVUSF9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19mYWJyaWMuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19mYWJyaWMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40ZmZkMjI0Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzX2ZhYnJpYy5oCkBAIC0wLDAgKzEsMTEyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19CRkFfRkNTX0ZBQlJJQ19IX18KKyNkZWZpbmUgX19CRkFfRkNTX0ZBQlJJQ19IX18KKworc3RydWN0IGJmYV9mY3NfczsKKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfc3RhdHVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc192Zi5oPgorI2luY2x1ZGUgPGNzL2JmYV9xLmg+CisjaW5jbHVkZSA8Y3MvYmZhX3NtLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzX2xwb3J0Lmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvZmNfc3AuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc19hdXRoLmg+CisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9uCisgKi8KK3N0cnVjdCBiZmFkX3ZmX3M7CisKK2VudW0gYmZhX2Zjc19mYWJyaWNfdHlwZSB7CisJQkZBX0ZDU19GQUJSSUNfVU5LTk9XTiA9IDAsCisJQkZBX0ZDU19GQUJSSUNfU1dJVENIRUQgPSAxLAorCUJGQV9GQ1NfRkFCUklDX1BMT09QID0gMiwKKwlCRkFfRkNTX0ZBQlJJQ19OMk4gPSAzLAorfTsKKworCitzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyB7CisJc3RydWN0IGxpc3RfaGVhZCAgIHFlOwkJLyogIHF1ZXVlIGVsZW1lbnQgKi8KKwliZmFfc21fdAkgc207CQkvKiAgc3RhdGUgbWFjaGluZSAqLworCXN0cnVjdCBiZmFfZmNzX3MgKmZjczsJCS8qICBGQ1MgaW5zdGFuY2UgKi8KKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgIGJwb3J0OwkvKiAgYmFzZSBsb2dpY2FsIHBvcnQgKi8KKwllbnVtIGJmYV9mY3NfZmFicmljX3R5cGUgZmFiX3R5cGU7IC8qICBmYWJyaWMgdHlwZSAqLworCWVudW0gYmZhX3Bwb3J0X3R5cGUgb3Blcl90eXBlOwkvKiAgY3VycmVudCBsaW5rIHRvcG9sb2d5ICovCisJdTggICAgICAgICBpc192ZjsJCS8qICBpcyB2aXJ0dWFsIGZhYnJpYz8gKi8KKwl1OCAgICAgICAgIGlzX25waXY7CS8qICBpcyBOUElWIHN1cHBvcnRlZCA/ICovCisJdTggICAgICAgICBpc19hdXRoOwkvKiAgaXMgU2VjdXJpdHkvQXV0aCBzdXBwb3J0ZWQgPyAqLworCXUxNiAgICAgICAgYmJfY3JlZGl0OwkvKiAgQkIgY3JlZGl0IGZyb20gZmFicmljICovCisJdTE2ICAgICAgICB2Zl9pZDsJCS8qICB2aXJ0dWFsIGZhYnJpYyBJRCAqLworCXUxNiAgICAgICAgbnVtX3Zwb3J0czsJLyogIG51bSB2cG9ydHMgKi8KKwl1MTYgICAgICAgIHJzdmQ7CisJc3RydWN0IGxpc3RfaGVhZCAgICAgICAgIHZwb3J0X3E7CS8qICBxdWV1ZSBvZiB2aXJ0dWFsIHBvcnRzICovCisJc3RydWN0IGxpc3RfaGVhZCAgICAgICAgIHZmX3E7CS8qICBxdWV1ZSBvZiB2aXJ0dWFsIGZhYnJpY3MgKi8KKwlzdHJ1Y3QgYmZhZF92Zl9zICAgICAgKnZmX2RydjsJLyogIGRyaXZlciB2ZiBzdHJ1Y3R1cmUgKi8KKwlzdHJ1Y3QgYmZhX3RpbWVyX3MgbGlua190aW1lcjsJLyogIExpbmsgRmFpbHVyZSB0aW1lci4gVnBvcnQgKi8KKwl3d25fdCAgICAgICAgICAgZmFicmljX25hbWU7CS8qICBhdHRhY2hlZCBmYWJyaWMgbmFtZSAqLworCWJmYV9ib29sZWFuX3QgICBhdXRoX3JlcWQ7CS8qICBhdXRoZW50aWNhdGlvbiByZXF1aXJlZAkqLworCXN0cnVjdCBiZmFfdGltZXJfcyBkZWxheV90aW1lcjsJLyogIGRlbGF5IHRpbWVyCQkqLworCXVuaW9uIHsKKwkJdTE2ICAgICAgICBzd3BfdmZpZDsvKiAgc3dpdGNoIHBvcnQgVkYgaWQJCSovCisJfSBldmVudF9hcmc7CisJc3RydWN0IGJmYV9mY3NfYXV0aF9zICBhdXRoOwkvKiAgYXV0aGVudGljYXRpb24gY29uZmlnCSovCisJc3RydWN0IGJmYV93Y19zICAgICAgICB3YzsJLyogIHdhaXQgY291bnRlciBmb3IgZGVsZXRlCSovCisJc3RydWN0IGJmYV92Zl9zdGF0c19zICBzdGF0czsgCS8qICBmYWJyaWMvdmYgc3RhdHMJCSovCisJc3RydWN0IGJmYV9scHNfcwkqbHBzOwkvKiAgbHBvcnQgbG9naW4gc2VydmljZXMJKi8KKwl1OAlmYWJyaWNfaXBfYWRkcltCRkFfRkNTX0ZBQlJJQ19JUEFERFJfU1pdOyAgLyogIGF0dGFjaGVkCisJCQkJCQkJICAgICogZmFicmljJ3MgaXAgYWRkcgorCQkJCQkJCSAgICAqLworfTsKKworI2RlZmluZSBiZmFfZmNzX2ZhYnJpY19ucGl2X2NhcGFibGUoX19mKSAgICAoX19mKS0+aXNfbnBpdgorI2RlZmluZSBiZmFfZmNzX2ZhYnJpY19pc19zd2l0Y2hlZChfX2YpCQkJXAorCSgoX19mKS0+ZmFiX3R5cGUgPT0gQkZBX0ZDU19GQUJSSUNfU1dJVENIRUQpCisKKy8qKgorICogICBUaGUgZGVzaWduIGNhbGxzIGZvciBhIHNpbmdsZSBpbXBsZW1lbnRhdGlvbiBvZiBiYXNlIGZhYnJpYyBhbmQgdmYuCisgKi8KKyNkZWZpbmUgYmZhX2Zjc192Zl90IHN0cnVjdCBiZmFfZmNzX2ZhYnJpY19zCisKK3N0cnVjdCBiZmFfdmZfZXZlbnRfcyB7CisJdTMyICAgICAgICB1bmRlZmluZWQ7Cit9OworCisvKioKKyAqIGJmYSBmY3MgdmYgcHVibGljIGZ1bmN0aW9ucworICovCitiZmFfc3RhdHVzX3QgYmZhX2Zjc192Zl9tb2RlX2VuYWJsZShzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHUxNiB2Zl9pZCk7CitiZmFfc3RhdHVzX3QgYmZhX2Zjc192Zl9tb2RlX2Rpc2FibGUoc3RydWN0IGJmYV9mY3NfcyAqZmNzKTsKK2JmYV9zdGF0dXNfdCBiZmFfZmNzX3ZmX2NyZWF0ZShiZmFfZmNzX3ZmX3QgKnZmLCBzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsCisJCQkgICAgICAgdTE2IHZmX2lkLCBzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgKnBvcnRfY2ZnLAorCQkJICAgICAgIHN0cnVjdCBiZmFkX3ZmX3MgKnZmX2Rydik7CitiZmFfc3RhdHVzX3QgYmZhX2Zjc192Zl9kZWxldGUoYmZhX2Zjc192Zl90ICp2Zik7Cit2b2lkIGJmYV9mY3NfdmZfc3RhcnQoYmZhX2Zjc192Zl90ICp2Zik7CitiZmFfc3RhdHVzX3QgYmZhX2Zjc192Zl9zdG9wKGJmYV9mY3NfdmZfdCAqdmYpOwordm9pZCBiZmFfZmNzX3ZmX2xpc3Qoc3RydWN0IGJmYV9mY3NfcyAqZmNzLCB1MTYgKnZmX2lkcywgaW50ICpudmZzKTsKK3ZvaWQgYmZhX2Zjc192Zl9saXN0X2FsbChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHUxNiAqdmZfaWRzLCBpbnQgKm52ZnMpOwordm9pZCBiZmFfZmNzX3ZmX2dldF9hdHRyKGJmYV9mY3NfdmZfdCAqdmYsIHN0cnVjdCBiZmFfdmZfYXR0cl9zICp2Zl9hdHRyKTsKK3ZvaWQgYmZhX2Zjc192Zl9nZXRfc3RhdHMoYmZhX2Zjc192Zl90ICp2ZiwKKwkJCSAgc3RydWN0IGJmYV92Zl9zdGF0c19zICp2Zl9zdGF0cyk7Cit2b2lkIGJmYV9mY3NfdmZfY2xlYXJfc3RhdHMoYmZhX2Zjc192Zl90ICp2Zik7Cit2b2lkIGJmYV9mY3NfdmZfZ2V0X3BvcnRzKGJmYV9mY3NfdmZfdCAqdmYsIHd3bl90IHZwd3duW10sIGludCAqbnBvcnRzKTsKK2JmYV9mY3NfdmZfdCAqYmZhX2Zjc192Zl9sb29rdXAoc3RydWN0IGJmYV9mY3NfcyAqZmNzLCB1MTYgdmZfaWQpOworc3RydWN0IGJmYWRfdmZfcyAqYmZhX2Zjc192Zl9nZXRfZHJ2X3ZmKGJmYV9mY3NfdmZfdCAqdmYpOworCisjZW5kaWYgLyogX19CRkFfRkNTX0ZBQlJJQ19IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19mY3BpbS5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzX2ZjcGltLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTcxOWYyYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19mY3BpbS5oCkBAIC0wLDAgKzEsMTMxIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9mY3NfZmNwaW0uaCBCRkEgRkNTIEZDUCBJbml0aWF0b3IgTW9kZSBpbnRlcmZhY2VzL2RlZmluZXMuCisgKi8KKworI2lmbmRlZiBfX0JGQV9GQ1NfRkNQSU1fSF9fCisjZGVmaW5lIF9fQkZBX0ZDU19GQ1BJTV9IX18KKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfc3RhdHVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19pdG5pbS5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzLmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfcnBvcnQuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc19scG9ydC5oPgorI2luY2x1ZGUgPGJmYV9mY3BpbS5oPgorCisvKgorICogZm9yd2FyZCBkZWNsYXJhdGlvbnMKKyAqLworc3RydWN0IGJmYWRfaXRuaW1fczsKKworc3RydWN0IGJmYV9mY3NfaXRuaW1fcyB7CisJYmZhX3NtX3QJCXNtOwkJLyogIHN0YXRlIG1hY2hpbmUgKi8KKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zIAkqcnBvcnQ7CQkvKiAgcGFyZW50IHJlbW90ZSBycG9ydCAgKi8KKwlzdHJ1Y3QgYmZhZF9pdG5pbV9zICAgCSppdG5pbV9kcnY7CS8qICBkcml2ZXIgcGVlciBpbnN0YW5jZSAqLworCXN0cnVjdCBiZmFfZmNzX3MgICAgICAJKmZjczsJCS8qICBmY3MgaW5zdGFuY2UgICAgICAgICAqLworCXN0cnVjdCBiZmFfdGltZXJfcyAJdGltZXI7CQkvKiAgdGltZXIgZnVuY3Rpb25zICAgICAgKi8KKwlzdHJ1Y3QgYmZhX2l0bmltX3MgCSpiZmFfaXRuaW07CS8qICBCRkEgaXRuaW0gc3RydWN0ICAgICAqLworCWJmYV9ib29sZWFuX3QJIAlzZXFfcmVjOwkvKiAgc2VxIHJlY292ZXJ5IHN1cHBvcnQgKi8KKwliZmFfYm9vbGVhbl90CSAJcmVjX3N1cHBvcnQ7CS8qICBSRUMgc3VwcG9ydGVkICAgICAgICAqLworCWJmYV9ib29sZWFuX3QJIAljb25mX2NvbXA7CS8qICBGQ1BfQ09ORiAgICAgc3VwcG9ydCAqLworCWJmYV9ib29sZWFuX3QJIAl0YXNrX3JldHJ5X2lkOwkvKiAgdGFzayByZXRyeSBpZCBzdXBwICAgKi8KKwlzdHJ1Y3QgYmZhX2ZjeHBfd3FlX3MgCWZjeHBfd3FlOwkvKiAgd2FpdCBxZWxlbSBmb3IgZmN4cCAgKi8KKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsJCS8qICBGQ1hQIGluIHVzZSAgICAgICAgICAqLworCXN0cnVjdCBiZmFfaXRuaW1fc3RhdHNfcyAJc3RhdHM7CS8qICBpdG4gc3RhdGlzdGljcyAgICAgICAqLworfTsKKworCitzdGF0aWMgaW5saW5lIHN0cnVjdCBiZmFkX3BvcnRfcyAqCitiZmFfZmNzX2l0bmltX2dldF9kcnZwb3J0KHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworCXJldHVybiBpdG5pbS0+cnBvcnQtPnBvcnQtPmJmYWRfcG9ydDsKK30KKworCitzdGF0aWMgaW5saW5lIHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqCitiZmFfZmNzX2l0bmltX2dldF9wb3J0KHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworCXJldHVybiBpdG5pbS0+cnBvcnQtPnBvcnQ7Cit9CisKKworc3RhdGljIGlubGluZSB3d25fdAorYmZhX2Zjc19pdG5pbV9nZXRfbnd3bihzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSkKK3sKKwlyZXR1cm4gaXRuaW0tPnJwb3J0LT5ud3duOworfQorCisKK3N0YXRpYyBpbmxpbmUgd3duX3QKK2JmYV9mY3NfaXRuaW1fZ2V0X3B3d24oc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pCit7CisJcmV0dXJuIGl0bmltLT5ycG9ydC0+cHd3bjsKK30KKworCitzdGF0aWMgaW5saW5lIHUzMgorYmZhX2Zjc19pdG5pbV9nZXRfZmNpZChzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSkKK3sKKwlyZXR1cm4gaXRuaW0tPnJwb3J0LT5waWQ7Cit9CisKKworc3RhdGljIGlubGluZSAgIHUzMgorYmZhX2Zjc19pdG5pbV9nZXRfbWF4ZnJzaXplKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltKQoreworCXJldHVybiBpdG5pbS0+cnBvcnQtPm1heGZyc2l6ZTsKK30KKworCitzdGF0aWMgaW5saW5lICAgZW51bSBmY19jb3MKK2JmYV9mY3NfaXRuaW1fZ2V0X2NvcyhzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSkKK3sKKwlyZXR1cm4gaXRuaW0tPnJwb3J0LT5mY19jb3M7Cit9CisKKworc3RhdGljIGlubGluZSBzdHJ1Y3QgYmZhZF9pdG5pbV9zICoKK2JmYV9mY3NfaXRuaW1fZ2V0X2Rydml0bihzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbSkKK3sKKwlyZXR1cm4gaXRuaW0tPml0bmltX2RydjsKK30KKworCitzdGF0aWMgaW5saW5lIHN0cnVjdCBiZmFfaXRuaW1fcyAqCitiZmFfZmNzX2l0bmltX2dldF9oYWxpdG4oc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0pCit7CisJcmV0dXJuIGl0bmltLT5iZmFfaXRuaW07Cit9CisKKy8qKgorICogYmZhIGZjcyBGQ1AgSW5pdGlhdG9yIG1vZGUgQVBJIGZ1bmN0aW9ucworICovCit2b2lkIGJmYV9mY3NfaXRuaW1fZ2V0X2F0dHIoc3RydWN0IGJmYV9mY3NfaXRuaW1fcyAqaXRuaW0sCisJCQlzdHJ1Y3QgYmZhX2l0bmltX2F0dHJfcyAqYXR0cik7Cit2b2lkIGJmYV9mY3NfaXRuaW1fZ2V0X3N0YXRzKHN0cnVjdCBiZmFfZmNzX2l0bmltX3MgKml0bmltLAorCQkJc3RydWN0IGJmYV9pdG5pbV9zdGF0c19zICpzdGF0cyk7CitzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICpiZmFfZmNzX2l0bmltX2xvb2t1cChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQl3d25fdCBycHd3bik7CitiZmFfc3RhdHVzX3QgYmZhX2Zjc19pdG5pbV9hdHRyX2dldChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90IHJwd3duLAorCQkJc3RydWN0IGJmYV9pdG5pbV9hdHRyX3MgKmF0dHIpOworYmZhX3N0YXR1c190IGJmYV9mY3NfaXRuaW1fc3RhdHNfZ2V0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwgd3duX3QgcnB3d24sCisJCQlzdHJ1Y3QgYmZhX2l0bmltX3N0YXRzX3MgKnN0YXRzKTsKK2JmYV9zdGF0dXNfdCBiZmFfZmNzX2l0bmltX3N0YXRzX2NsZWFyKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXd3bl90IHJwd3duKTsKKyNlbmRpZiAvKiBfX0JGQV9GQ1NfRkNQSU1fSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNzL2JmYV9mY3NfZmRtaS5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzX2ZkbWkuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40NDQxZmZmCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzX2ZkbWkuaApAQCAtMCwwICsxLDYzIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIGJmYV9mY3NfZmRtaS5oIEJGQSBmY3MgZmRtaSBtb2R1bGUgcHVibGljIGludGVyZmFjZQorICovCisKKyNpZm5kZWYgX19CRkFfRkNTX0ZETUlfSF9fCisjZGVmaW5lIF9fQkZBX0ZDU19GRE1JX0hfXworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKyNpbmNsdWRlIDxwcm90b2NvbC9mZG1pLmg+CisKKyNkZWZpbmUJQkZBX0ZDU19GRE1JX1NVUE9SVEVEX1NQRUVEUyAgKEZETUlfVFJBTlNfU1BFRURfMUcgIHwgXAorCQkJCQlGRE1JX1RSQU5TX1NQRUVEXzJHIHwgXAorCQkJCQlGRE1JX1RSQU5TX1NQRUVEXzRHIHwgXAorCQkJCQlGRE1JX1RSQU5TX1NQRUVEXzhHKQorCisvKgorKiBIQkEgQXR0cmlidXRlIEJsb2NrIDogQkZBIGludGVybmFsIHJlcHJlc2VudGF0aW9uLiBOb3RlIDogU29tZSB2YXJpYWJsZQorKiBzaXplcyBoYXZlIGJlZW4gdHJpbW1lZCB0byBzdWl0IEJGQSBGb3IgRXggOiBNb2RlbCB3aWxsIGJlICJCcm9jYWRlIi4gQmFzZWQKKyAqIG9uIHRoaXMgdGhlIHNpemUgaGFzIGJlZW4gcmVkdWNlZCB0byAxNiBieXRlcyBmcm9tIHRoZSBzdGFuZGFyZCdzIDY0IGJ5dGVzLgorICovCitzdHJ1Y3QgYmZhX2Zjc19mZG1pX2hiYV9hdHRyX3MgeworCXd3bl90ICAgICAgICAgICBub2RlX25hbWU7CisJdTggICAgICAgICBtYW51ZmFjdHVyZXJbNjRdOworCXU4ICAgICAgICAgc2VyaWFsX251bVs2NF07CisJdTggICAgICAgICBtb2RlbFsxNl07CisJdTggICAgICAgICBtb2RlbF9kZXNjWzI1Nl07CisJdTggICAgICAgICBod192ZXJzaW9uWzhdOworCXU4ICAgICAgICAgZHJpdmVyX3ZlcnNpb25bOF07CisJdTggICAgICAgICBvcHRpb25fcm9tX3ZlcltCRkFfVkVSU0lPTl9MRU5dOworCXU4ICAgICAgICAgZndfdmVyc2lvbls4XTsKKwl1OCAgICAgICAgIG9zX25hbWVbMjU2XTsKKwl1MzIgICAgICAgIG1heF9jdF9weWxkOworfTsKKworLyoKKyAqIFBvcnQgQXR0cmlidXRlIEJsb2NrCisgKi8KK3N0cnVjdCBiZmFfZmNzX2ZkbWlfcG9ydF9hdHRyX3MgeworCXU4ICAgICAgICAgc3VwcF9mYzRfdHlwZXNbMzJdOwkvKiBzdXBwb3J0ZWQgRkM0IHR5cGVzICovCisJdTMyICAgICAgICBzdXBwX3NwZWVkOwkvKiBzdXBwb3J0ZWQgc3BlZWQgKi8KKwl1MzIgICAgICAgIGN1cnJfc3BlZWQ7CS8qIGN1cnJlbnQgU3BlZWQgKi8KKwl1MzIgICAgICAgIG1heF9mcm1fc2l6ZTsJLyogbWF4IGZyYW1lIHNpemUgKi8KKwl1OCAgICAgICAgIG9zX2RldmljZV9uYW1lWzI1Nl07CS8qIE9TIGRldmljZSBOYW1lICovCisJdTggICAgICAgICBob3N0X25hbWVbMjU2XTsJLyogaG9zdCBuYW1lICovCit9OworCisjZW5kaWYgLyogX19CRkFfRkNTX0ZETUlfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNzL2JmYV9mY3NfbHBvcnQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19scG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI4NWNiYTgKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNzL2JmYV9mY3NfbHBvcnQuaApAQCAtMCwwICsxLDIyNiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBiZmFfZmNzX3BvcnQuaCBCRkEgZmNzIHBvcnQgbW9kdWxlIHB1YmxpYyBpbnRlcmZhY2UKKyAqLworCisjaWZuZGVmIF9fQkZBX0ZDU19QT1JUX0hfXworI2RlZmluZSBfX0JGQV9GQ1NfUE9SVF9IX18KKworI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfc3RhdHVzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wb3J0Lmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19wcG9ydC5oPgorI2luY2x1ZGUgPGRlZnMvYmZhX2RlZnNfcnBvcnQuaD4KKyNpbmNsdWRlIDxjcy9iZmFfcS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfd2MuaD4KKworc3RydWN0IGJmYV9mY3NfczsKK3N0cnVjdCBiZmFfZmNzX2ZhYnJpY19zOworCisvKgorKiBAdG9kbyA6IG5lZWQgdG8gbW92ZSB0byBhIGdsb2JhbCBjb25maWcgZmlsZS4KKyAqIE1heGltdW0gVnBvcnRzIHN1cHBvcnRlZCBwZXIgcGh5c2ljYWwgcG9ydCBvciB2Zi4KKyAqLworI2RlZmluZSBCRkFfRkNTX01BWF9WUE9SVFNfU1VQUF9DQiAgMjU1CisjZGVmaW5lIEJGQV9GQ1NfTUFYX1ZQT1JUU19TVVBQX0NUICAxOTEKKworLyoKKyogQHRvZG8gOiBuZWVkIHRvIG1vdmUgdG8gYSBnbG9iYWwgY29uZmlnIGZpbGUuCisgKiBNYXhpbXVtIFJwb3J0cyBzdXBwb3J0ZWQgcGVyIHBvcnQgKHBoeXNpY2FsL2xvZ2ljYWwpLgorICovCisjZGVmaW5lIEJGQV9GQ1NfTUFYX1JQT1JUU19TVVBQICAyNTYJLyogQHRvZG8gOiB0ZW50YXRpdmUgdmFsdWUgKi8KKworCitzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgeworCWJmYV9zbV90ICAgICAgICBzbTsJCS8qICBzdGF0ZSBtYWNoaW5lICovCisJc3RydWN0IGJmYV90aW1lcl9zIHRpbWVyOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydDsJLyogIHBhcmVudCBwb3J0ICovCisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJc3RydWN0IGJmYV9mY3hwX3dxZV9zIGZjeHBfd3FlOworfTsKKworCitzdHJ1Y3QgYmZhX2Zjc19wb3J0X3Njbl9zIHsKKwliZmFfc21fdCAgICAgICAgc207CQkvKiAgc3RhdGUgbWFjaGluZSAqLworCXN0cnVjdCBiZmFfdGltZXJfcyB0aW1lcjsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQ7CS8qICBwYXJlbnQgcG9ydCAqLworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCXN0cnVjdCBiZmFfZmN4cF93cWVfcyBmY3hwX3dxZTsKK307CisKKworc3RydWN0IGJmYV9mY3NfcG9ydF9mZG1pX3MgeworCWJmYV9zbV90ICAgICAgICBzbTsJCS8qICBzdGF0ZSBtYWNoaW5lICovCisJc3RydWN0IGJmYV90aW1lcl9zIHRpbWVyOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXM7CS8qICBwYXJlbnQgbXMgKi8KKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwlzdHJ1Y3QgYmZhX2ZjeHBfd3FlX3MgZmN4cF93cWU7CisJdTggICAgICAgICByZXRyeV9jbnQ7CS8qICByZXRyeSBjb3VudCAqLworCXU4CSAJICAgcnN2ZFszXTsKK307CisKKworc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zIHsKKwliZmFfc21fdCAgICAgICAgc207CQkvKiAgc3RhdGUgbWFjaGluZSAqLworCXN0cnVjdCBiZmFfdGltZXJfcyB0aW1lcjsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQ7CS8qICBwYXJlbnQgcG9ydCAqLworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCXN0cnVjdCBiZmFfZmN4cF93cWVfcyBmY3hwX3dxZTsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZkbWlfcyBmZG1pOwkvKiAgRkRNSSBjb21wb25lbnQgb2YgTVMgKi8KKwl1OCAgICAgICAgIHJldHJ5X2NudDsJLyogIHJldHJ5IGNvdW50ICovCisJdTgJIAkgICByc3ZkWzNdOworfTsKKworCitzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZhYl9zIHsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgbnM7CS8qICBOUyBjb21wb25lbnQgb2YgcG9ydCAqLworCXN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3Mgc2NuOwkvKiAgc2NuIGNvbXBvbmVudCBvZiBwb3J0ICovCisJc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zIG1zOwkvKiAgTVMgY29tcG9uZW50IG9mIHBvcnQgKi8KK307CisKKworCisjZGVmaW5lIAlNQVhfQUxQQV9DT1VOVCAJCTEyNworCitzdHJ1Y3QgYmZhX2Zjc19wb3J0X2xvb3BfcyB7CisJdTggICAgICAgICBudW1fYWxwYTsJLyogIE51bSBvZiBBTFBBIGVudHJpZXMgaW4gdGhlIG1hcCAqLworCXU4ICAgICAgICAgYWxwYV9wb3NfbWFwW01BWF9BTFBBX0NPVU5UXTsJLyogIEFMUEEgUG9zaXRpb25hbAorCQkJCQkJCSAqTWFwICovCisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0OwkvKiAgcGFyZW50IHBvcnQgKi8KK307CisKKworCitzdHJ1Y3QgYmZhX2Zjc19wb3J0X24ybl9zIHsKKwl1MzIgICAgICAgIHJzdmQ7CisJdTE2ICAgICAgICByZXBseV9veGlkOwkvKiAgb3hfaWQgZnJvbSB0aGUgcmVxIGZsb2dpIHRvIGJlCisJCQkJCSAqdXNlZCBpbiBmbG9naSBhY2MgKi8KKwl3d25fdCAgICAgICAgICAgcmVtX3BvcnRfd3duOwkvKiAgQXR0YWNoZWQgcG9ydCdzIHd3biAqLworfTsKKworCit1bmlvbiBiZmFfZmNzX3BvcnRfdG9wb191IHsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X2ZhYl9zIHBmYWI7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9sb29wX3MgcGxvb3A7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9uMm5fcyBwbjJuOworfTsKKworCitzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgeworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICBxZTsJLyogIHVzZWQgYnkgcG9ydC92cG9ydCAqLworCWJmYV9zbV90ICAgICAgICAgICAgICAgc207CS8qICBzdGF0ZSBtYWNoaW5lICovCisJc3RydWN0IGJmYV9mY3NfZmFicmljX3MgKmZhYnJpYzsJLyogIHBhcmVudCBmYWJyaWMgKi8KKwlzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgIHBvcnRfY2ZnOwkvKiAgcG9ydCBjb25maWd1cmF0aW9uICovCisJc3RydWN0IGJmYV90aW1lcl9zIGxpbmtfdGltZXI7CS8qICB0aW1lciBmb3IgbGluayBvZmZsaW5lICovCisJdTMyICAgICAgICBwaWQgOiAyNDsJLyogIEZDIGFkZHJlc3MgKi8KKwl1OCAgICAgICAgIGxwX3RhZzsJCS8qICBscG9ydCB0YWcgKi8KKwl1MTYgICAgICAgIG51bV9ycG9ydHM7CS8qICBOdW0gb2Ygci1wb3J0cyAqLworCXN0cnVjdCBsaXN0X2hlYWQgcnBvcnRfcTsJLyogIHF1ZXVlIG9mIGRpc2NvdmVyZWQgci1wb3J0cyAqLworCXN0cnVjdCBiZmFfZmNzX3MgKmZjczsJLyogIEZDUyBpbnN0YW5jZSAqLworCXVuaW9uIGJmYV9mY3NfcG9ydF90b3BvX3UgcG9ydF90b3BvOwkvKiAgZmFicmljL2xvb3AvbjJuIGRldGFpbHMgKi8KKwlzdHJ1Y3QgYmZhZF9wb3J0X3MgKmJmYWRfcG9ydDsJLyogIGRyaXZlciBwZWVyIGluc3RhbmNlICovCisJc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQ7CS8qICBOVUxMIGZvciBiYXNlIHBvcnRzICovCisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJc3RydWN0IGJmYV9mY3hwX3dxZV9zIGZjeHBfd3FlOworCXN0cnVjdCBiZmFfcG9ydF9zdGF0c19zIHN0YXRzOworCXN0cnVjdCBiZmFfd2NfcyAgICAgICAgd2M7CS8qICB3YWl0aW5nIGNvdW50ZXIgZm9yIGV2ZW50cyAqLworfTsKKworI2RlZmluZSBiZmFfZmNzX2xwb3J0X3Qgc3RydWN0IGJmYV9mY3NfcG9ydF9zCisKKy8qKgorICogU3ltYm9saWMgTmFtZSByZWxhdGVkIGRlZmluZXMKKyAqICBUb3RhbCBieXRlcyAyNTUuCisgKiAgUGh5c2ljYWwgUG9ydCdzIHN5bWJvbGljIG5hbWUgMTI4IGJ5dGVzLgorICogIEZvciBWcG9ydHMsIFZwb3J0J3Mgc3ltYm9saWMgbmFtZSBpcyBhcHBlbmRlZCB0byB0aGUgUGh5c2ljYWwgcG9ydCdzCisgKiAgU3ltYm9saWMgTmFtZS4KKyAqCisgKiAgUGh5c2ljYWwgUG9ydCdzIHN5bWJvbGljIG5hbWUgRm9ybWF0IDogKFRvdGFsIDEyOCBieXRlcykKKyAqICBBZGFwdGVyIE1vZGVsIG51bWJlci9uYW1lIDogMTIgYnl0ZXMKKyAqICBEcml2ZXIgVmVyc2lvbiAgICAgOiAxMCBieXRlcworICogIEhvc3QgTWFjaGluZSBOYW1lICA6IDMwIGJ5dGVzCisgKiAJSG9zdCBPUyBJbmZvCSAgIDogNDggYnl0ZXMKKyAqIAlIb3N0IE9TIFBBVENIIEluZm8gOiAxNiBieXRlcworICogICggcmVtYWluaW5nIDEyIGJ5dGVzIHJlc2VydmVkIHRvIGJlIHVzZWQgZm9yIHNlcGFyYXRvcikKKyAqLworI2RlZmluZSBCRkFfRkNTX1BPUlRfU1lNQk5BTUVfU0VQQVJBVE9SIAkJIiB8ICIKKworI2RlZmluZSBCRkFfRkNTX1BPUlRfU1lNQk5BTUVfTU9ERUxfU1oJCQkxMgorI2RlZmluZSBCRkFfRkNTX1BPUlRfU1lNQk5BTUVfVkVSU0lPTl9TWiAJCTEwCisjZGVmaW5lIEJGQV9GQ1NfUE9SVF9TWU1CTkFNRV9NQUNISU5FTkFNRV9TWiAJMzAKKyNkZWZpbmUgQkZBX0ZDU19QT1JUX1NZTUJOQU1FX09TSU5GT19TWgkJCTQ4CisjZGVmaW5lIEJGQV9GQ1NfUE9SVF9TWU1CTkFNRV9PU1BBVENIX1NaCQkxNgorCisvKioKKyAqIEdldCBGQyBwb3J0IElEIGZvciBhIGxvZ2ljYWwgcG9ydC4KKyAqLworI2RlZmluZSBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQoX2xwb3J0KQkoKF9scG9ydCktPnBpZCkKKyNkZWZpbmUgYmZhX2Zjc19wb3J0X2dldF9wd3duKF9scG9ydCkJKChfbHBvcnQpLT5wb3J0X2NmZy5wd3duKQorI2RlZmluZSBiZmFfZmNzX3BvcnRfZ2V0X253d24oX2xwb3J0KQkoKF9scG9ydCktPnBvcnRfY2ZnLm53d24pCisjZGVmaW5lIGJmYV9mY3NfcG9ydF9nZXRfcHN5bV9uYW1lKF9scG9ydCkJKChfbHBvcnQpLT5wb3J0X2NmZy5zeW1fbmFtZSkKKyNkZWZpbmUgYmZhX2Zjc19wb3J0X2lzX2luaXRpYXRvcihfbHBvcnQpCVwKKwkJCSgoX2xwb3J0KS0+cG9ydF9jZmcucm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9JTSkKKyNkZWZpbmUgYmZhX2Zjc19wb3J0X2lzX3RhcmdldChfbHBvcnQpCVwKKwkJCSgoX2xwb3J0KS0+cG9ydF9jZmcucm9sZXMgJiBCRkFfUE9SVF9ST0xFX0ZDUF9UTSkKKyNkZWZpbmUgYmZhX2Zjc19wb3J0X2dldF9ucnBvcnRzKF9scG9ydCkJXAorCQkJKChfbHBvcnQpID8gKF9scG9ydCktPm51bV9ycG9ydHMgOiAwKQorCitzdGF0aWMgaW5saW5lIHN0cnVjdCBiZmFkX3BvcnRfcyAqCitiZmFfZmNzX3BvcnRfZ2V0X2RydnBvcnQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXJldHVybiBwb3J0LT5iZmFkX3BvcnQ7Cit9CisKKworI2RlZmluZSBiZmFfZmNzX3BvcnRfZ2V0X29wZXJ0eXBlKF9scG9ydCkJKF9scG9ydCktPmZhYnJpYy0+b3Blcl90eXBlCisKKworI2RlZmluZSBiZmFfZmNzX3BvcnRfZ2V0X2ZhYnJpY19uYW1lKF9scG9ydCkJKF9scG9ydCktPmZhYnJpYy0+ZmFicmljX25hbWUKKworCisjZGVmaW5lIGJmYV9mY3NfcG9ydF9nZXRfZmFicmljX2lwYWRkcihfbHBvcnQpCShfbHBvcnQpLT5mYWJyaWMtPmZhYnJpY19pcF9hZGRyCisKKy8qKgorICogYmZhIGZjcyBwb3J0IHB1YmxpYyBmdW5jdGlvbnMKKyAqLwordm9pZCBiZmFfZmNzX2NmZ19iYXNlX3BvcnQoc3RydWN0IGJmYV9mY3NfcyAqZmNzLAorCQkJc3RydWN0IGJmYV9wb3J0X2NmZ19zICpwb3J0X2NmZyk7CitzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmJmYV9mY3NfZ2V0X2Jhc2VfcG9ydChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpOwordm9pZCBiZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0cyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQl3d25fdCBycG9ydF93d25zW10sIGludCAqbnJwb3J0cyk7CisKK3d3bl90IGJmYV9mY3NfcG9ydF9nZXRfcnBvcnQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCB3d24sCisJCQlpbnQgaW5kZXgsIGludCBucnBvcnRzLCBiZmFfYm9vbGVhbl90IGJ3d24pOworCitzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmJmYV9mY3NfbG9va3VwX3BvcnQoc3RydWN0IGJmYV9mY3NfcyAqZmNzLAorCQkJdTE2IHZmX2lkLCB3d25fdCBscHd3bik7CisKK3ZvaWQgYmZhX2Zjc19wb3J0X2dldF9pbmZvKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCXN0cnVjdCBiZmFfcG9ydF9pbmZvX3MgKnBvcnRfaW5mbyk7Cit2b2lkIGJmYV9mY3NfcG9ydF9nZXRfYXR0cihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQlzdHJ1Y3QgYmZhX3BvcnRfYXR0cl9zICpwb3J0X2F0dHIpOwordm9pZCBiZmFfZmNzX3BvcnRfZ2V0X3N0YXRzKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqZmNzX3BvcnQsCisJCQlzdHJ1Y3QgYmZhX3BvcnRfc3RhdHNfcyAqcG9ydF9zdGF0cyk7Cit2b2lkIGJmYV9mY3NfcG9ydF9jbGVhcl9zdGF0cyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmZjc19wb3J0KTsKK2VudW0gYmZhX3Bwb3J0X3NwZWVkIGJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfbWF4X3NwZWVkKAorCQkJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3ZvaWQgYmZhX2Zjc19wb3J0X2VuYWJsZV9pcGZjX3JvbGVzKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqZmNzX3BvcnQpOwordm9pZCBiZmFfZmNzX3BvcnRfZGlzYWJsZV9pcGZjX3JvbGVzKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqZmNzX3BvcnQpOworCisjZW5kaWYgLyogX19CRkFfRkNTX1BPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNzL2JmYV9mY3NfcnBvcnQuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc19ycG9ydC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjcwMmI5NWIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvZmNzL2JmYV9mY3NfcnBvcnQuaApAQCAtMCwwICsxLDEwNCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fQkZBX0ZDU19SUE9SVF9IX18KKyNkZWZpbmUgX19CRkFfRkNTX1JQT1JUX0hfXworCisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19zdGF0dXMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfcS5oPgorI2luY2x1ZGUgPGZjcy9iZmFfZmNzLmg+CisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19ycG9ydC5oPgorCisjZGVmaW5lIEJGQV9GQ1NfUlBPUlRfREVGX0RFTF9USU1FT1VUIAk5MCAJLyogaW4gc2VjcyAqLworLyoKKyAqIGZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KK3N0cnVjdCBiZmFkX3Jwb3J0X3M7CisKK3N0cnVjdCBiZmFfZmNzX2l0bmltX3M7CitzdHJ1Y3QgYmZhX2Zjc190aW5fczsKK3N0cnVjdCBiZmFfZmNzX2lwcnBfczsKKworLyogUnBvcnQgRmVhdHVyZXMgKFJQRikgKi8KK3N0cnVjdCBiZmFfZmNzX3JwZl9zIHsKKwliZmFfc21fdCAgICAgICAgICAgICAgIHNtOwkvKiAgc3RhdGUgbWFjaGluZSAqLworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OwkvKiAgcGFyZW50IHJwb3J0ICovCisJc3RydWN0IGJmYV90aW1lcl9zIAl0aW1lcjsJLyogIGdlbmVyYWwgcHVycG9zZSB0aW1lciAqLworCXN0cnVjdCBiZmFfZmN4cF9zIAkqZmN4cDsJLyogIEZDWFAgbmVlZGVkIGZvciBkaXNjYXJkaW5nICovCisJc3RydWN0IGJmYV9mY3hwX3dxZV9zIAlmY3hwX3dxZTsJLyogIGZjeHAgd2FpdCBxdWV1ZSBlbGVtZW50ICovCisJaW50ICAgICAgICAgICAgIAlycHNjX3JldHJpZXM7CS8qICBtYXggUlBTQyByZXRyeSBhdHRlbXB0cyAqLworCWVudW0gYmZhX3Bwb3J0X3NwZWVkIAlycHNjX3NwZWVkOwkvKiBDdXJyZW50IFNwZWVkIGZyb20gUlBTQy4KKwkJCQkJCSAqIE8gaWYgUlBTQyBmYWlscyAqLworCWVudW0gYmZhX3Bwb3J0X3NwZWVkCWFzc2lnbmVkX3NwZWVkOwkvKiBTcGVlZCBhc3NpZ25lZCBieSB0aGUgdXNlci4KKwkJCQkJCSAqIHdpbGwgYmUgdXNlZCBpZiBSUFNDIGlzIG5vdAorCQkJCQkJICogc3VwcG9ydGVkIGJ5IHRoZSBycG9ydCAqLworfTsKKworc3RydWN0IGJmYV9mY3NfcnBvcnRfcyB7CisJc3RydWN0IGxpc3RfaGVhZCAgICAgICAgIHFlOwkvKiAgdXNlZCBieSBwb3J0L3Zwb3J0ICovCisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0OwkvKiAgcGFyZW50IEZDUyBwb3J0ICovCisJc3RydWN0IGJmYV9mY3NfcyAgICAgICpmY3M7CS8qICBmY3MgaW5zdGFuY2UgKi8KKwlzdHJ1Y3QgYmZhZF9ycG9ydF9zICAgKnJwX2RydjsJLyogIGRyaXZlciBwZWVyIGluc3RhbmNlICovCisJdTMyICAgICAgICBwaWQ7CS8qICBwb3J0IElEIG9mIHJwb3J0ICovCisJdTE2ICAgICAgICBtYXhmcnNpemU7CS8qICBtYXhpbXVtIGZyYW1lIHNpemUgKi8KKwl1MTYgICAgICAgIHJlcGx5X294aWQ7CS8qICBPWF9JRCBvZiBpbmJvdW5kIHJlcXVlc3RzICovCisJZW51bSBmY19jb3MgICAgICAgIGZjX2NvczsJLyogIEZDIGNsYXNzZXMgb2Ygc2VydmljZSBzdXBwICovCisJYmZhX2Jvb2xlYW5fdCAgIGNpc2M7CS8qICBDSVNDIGNhcGFibGUgZGV2aWNlICovCisJd3duX3QgICAgICAgICAgIHB3d247CS8qICBwb3J0IHd3biBvZiBycG9ydCAqLworCXd3bl90ICAgICAgICAgICBud3duOwkvKiAgbm9kZSB3d24gb2YgcnBvcnQgKi8KKwlzdHJ1Y3QgYmZhX3Jwb3J0X3N5bW5hbWVfcyBwc3ltX25hbWU7IC8qICBwb3J0IHN5bWJvbGljIG5hbWUgICovCisJYmZhX3NtX3QgICAgICAgIHNtOwkJLyogIHN0YXRlIG1hY2hpbmUgKi8KKwlzdHJ1Y3QgYmZhX3RpbWVyX3MgdGltZXI7CS8qICBnZW5lcmFsIHB1cnBvc2UgdGltZXIgKi8KKwlzdHJ1Y3QgYmZhX2Zjc19pdG5pbV9zICppdG5pbTsJLyogIElUTiBpbml0aWF0b3IgbW9kZSByb2xlICovCisJc3RydWN0IGJmYV9mY3NfdGluX3MgKnRpbjsJLyogIElUTiBpbml0aWF0b3IgbW9kZSByb2xlICovCisJc3RydWN0IGJmYV9mY3NfaXBycF9zICppcHJwOwkvKiAgSVAvRkMgcm9sZSAqLworCXN0cnVjdCBiZmFfcnBvcnRfcyAqYmZhX3Jwb3J0OwkvKiAgQkZBIFJwb3J0ICovCisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CS8qICBGQ1hQIG5lZWRlZCBmb3IgZGlzY2FyZGluZyAqLworCWludCAgICAgICAgICAgICBwbG9naV9yZXRyaWVzOwkvKiAgbWF4IHBsb2dpIHJldHJ5IGF0dGVtcHRzICovCisJaW50ICAgICAgICAgICAgIG5zX3JldHJpZXM7CS8qICBtYXggTlMgcXVlcnkgcmV0cnkgYXR0ZW1wdHMgKi8KKwlzdHJ1Y3QgYmZhX2ZjeHBfd3FlX3MgCWZjeHBfd3FlOyAvKiAgZmN4cCB3YWl0IHF1ZXVlIGVsZW1lbnQgKi8KKwlzdHJ1Y3QgYmZhX3Jwb3J0X3N0YXRzX3Mgc3RhdHM7CS8qICBycG9ydCBzdGF0cyAqLworCWVudW0gYmZhX3Jwb3J0X2Z1bmN0aW9uCXNjc2lfZnVuY3Rpb247ICAvKiAgSW5pdGlhdG9yL1RhcmdldCAqLworCXN0cnVjdCBiZmFfZmNzX3JwZl9zIHJwZjsgCS8qIFJwb3J0IGZlYXR1cmVzIG1vZHVsZSAqLworfTsKKworc3RhdGljIGlubGluZSBzdHJ1Y3QgYmZhX3Jwb3J0X3MgKgorYmZhX2Zjc19ycG9ydF9nZXRfaGFscnBvcnQoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpCit7CisJcmV0dXJuIHJwb3J0LT5iZmFfcnBvcnQ7Cit9CisKKy8qKgorICogYmZhIGZjcyBycG9ydCBBUEkgZnVuY3Rpb25zCisgKi8KK2JmYV9zdGF0dXNfdCBiZmFfZmNzX3Jwb3J0X2FkZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90ICpwd3duLAorCQkJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQlzdHJ1Y3QgYmZhZF9ycG9ydF9zICpycG9ydF9kcnYpOworYmZhX3N0YXR1c190IGJmYV9mY3NfcnBvcnRfcmVtb3ZlKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3ZvaWQgYmZhX2Zjc19ycG9ydF9nZXRfYXR0cihzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCXN0cnVjdCBiZmFfcnBvcnRfYXR0cl9zICphdHRyKTsKK3ZvaWQgYmZhX2Zjc19ycG9ydF9nZXRfc3RhdHMoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQlzdHJ1Y3QgYmZhX3Jwb3J0X3N0YXRzX3MgKnN0YXRzKTsKK3ZvaWQgYmZhX2Zjc19ycG9ydF9jbGVhcl9zdGF0cyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCk7CitzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpiZmFfZmNzX3Jwb3J0X2xvb2t1cChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQl3d25fdCBycHd3bik7CitzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpiZmFfZmNzX3Jwb3J0X2xvb2t1cF9ieV9ud3duKAorCQkJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBybnd3bik7Cit2b2lkIGJmYV9mY3NfcnBvcnRfc2V0X2RlbF90aW1lb3V0KHU4IHJwb3J0X3Rtbyk7Cit2b2lkIGJmYV9mY3NfcnBvcnRfc2V0X3NwZWVkKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJZW51bSBiZmFfcHBvcnRfc3BlZWQgc3BlZWQpOworI2VuZGlmIC8qIF9fQkZBX0ZDU19SUE9SVF9IX18gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc192cG9ydC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2Zjcy9iZmFfZmNzX3Zwb3J0LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uY2QzM2YyYwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9mY3MvYmZhX2Zjc192cG9ydC5oCkBAIC0wLDAgKzEsNjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2Zjc192cG9ydC5oIEJGQSBmY3MgdnBvcnQgbW9kdWxlIHB1YmxpYyBpbnRlcmZhY2UKKyAqLworCisjaWZuZGVmIF9fQkZBX0ZDU19WUE9SVF9IX18KKyNkZWZpbmUgX19CRkFfRkNTX1ZQT1JUX0hfXworCisjaW5jbHVkZSA8ZGVmcy9iZmFfZGVmc19zdGF0dXMuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3BvcnQuaD4KKyNpbmNsdWRlIDxkZWZzL2JmYV9kZWZzX3Zwb3J0Lmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3MuaD4KKyNpbmNsdWRlIDxmY2IvYmZhX2ZjYl92cG9ydC5oPgorCitzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zIHsKKwlzdHJ1Y3QgbGlzdF9oZWFkCQlxZTsJCS8qICBxdWV1ZSBlbGVtCSAqLworCWJmYV9zbV90CQlzbTsJCS8qICBzdGF0ZSBtYWNoaW5lCSovCisJYmZhX2Zjc19scG9ydF90CQlscG9ydDsJCS8qICBsb2dpY2FsIHBvcnQJKi8KKwlzdHJ1Y3QgYmZhX3RpbWVyX3MJdGltZXI7CQkvKiAgZ2VuZXJhbCBwdXJwb3NlIHRpbWVyICovCisJc3RydWN0IGJmYWRfdnBvcnRfcwkqdnBvcnRfZHJ2OwkvKiAgRHJpdmVyIHByaXZhdGUJKi8KKwlzdHJ1Y3QgYmZhX3Zwb3J0X3N0YXRzX3MgdnBvcnRfc3RhdHM7CS8qICB2cG9ydCBzdGF0aXN0aWNzCSovCisJc3RydWN0IGJmYV9scHNfcwkqbHBzOwkJLyogIExwb3J0IGxvZ2luIHNlcnZpY2UgKi8KKwlpbnQJCQlmZGlzY19yZXRyaWVzOworfTsKKworI2RlZmluZSBiZmFfZmNzX3Zwb3J0X2dldF9wb3J0KHZwb3J0KSBcCisJCQkoKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAgKikoJnZwb3J0LT5wb3J0KSkKKworLyoqCisgKiBiZmEgZmNzIHZwb3J0IHB1YmxpYyBmdW5jdGlvbnMKKyAqLworYmZhX3N0YXR1c190IGJmYV9mY3NfdnBvcnRfY3JlYXRlKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0LAorCQkJc3RydWN0IGJmYV9mY3NfcyAqZmNzLCB1MTYgdmZfaWQsCisJCQlzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgKnBvcnRfY2ZnLAorCQkJc3RydWN0IGJmYWRfdnBvcnRfcyAqdnBvcnRfZHJ2KTsKK2JmYV9zdGF0dXNfdCBiZmFfZmNzX3Zwb3J0X2RlbGV0ZShzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCk7CitiZmFfc3RhdHVzX3QgYmZhX2Zjc192cG9ydF9zdGFydChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCk7CitiZmFfc3RhdHVzX3QgYmZhX2Zjc192cG9ydF9zdG9wKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0KTsKK3ZvaWQgYmZhX2Zjc192cG9ydF9nZXRfYXR0cihzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCXN0cnVjdCBiZmFfdnBvcnRfYXR0cl9zICp2cG9ydF9hdHRyKTsKK3ZvaWQgYmZhX2Zjc192cG9ydF9nZXRfc3RhdHMoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQlzdHJ1Y3QgYmZhX3Zwb3J0X3N0YXRzX3MgKnZwb3J0X3N0YXRzKTsKK3ZvaWQgYmZhX2Zjc192cG9ydF9jbHJfc3RhdHMoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpOworc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqYmZhX2Zjc192cG9ydF9sb29rdXAoc3RydWN0IGJmYV9mY3NfcyAqZmNzLAorCQkJdTE2IHZmX2lkLCB3d25fdCB2cHd3bik7CisKKyNlbmRpZiAvKiBfX0JGQV9GQ1NfVlBPUlRfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvbG9nL2JmYV9sb2dfZmNzLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvbG9nL2JmYV9sb2dfZmNzLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjZmNWRmOAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9sb2cvYmZhX2xvZ19mY3MuaApAQCAtMCwwICsxLDI4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qCisgKiBtZXNzYWdlcyBkZWZpbmUgZm9yIEZDUyBNb2R1bGUKKyAqLworI2lmbmRlZglfX0JGQV9MT0dfRkNTX0hfXworI2RlZmluZQlfX0JGQV9MT0dfRkNTX0hfXworI2luY2x1ZGUgIDxjcy9iZmFfbG9nLmg+CisjZGVmaW5lIEJGQV9MT0dfRkNTX0ZBQlJJQ19OT1NXSVRDSCAJXAorCSgoKHUzMikgQkZBX0xPR19GQ1NfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgMSkKKyNkZWZpbmUgQkZBX0xPR19GQ1NfRkFCUklDX0lTT0xBVEVEIAlcCisJKCgodTMyKSBCRkFfTE9HX0ZDU19JRCA8PCBCRkFfTE9HX01PRElEX09GRlNFVCkgfCAyKQorI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvbG9nL2JmYV9sb2dfaGFsLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvbG9nL2JmYV9sb2dfaGFsLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMDQxMmFlYQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9sb2cvYmZhX2xvZ19oYWwuaApAQCAtMCwwICsxLDMwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qIG1lc3NhZ2VzIGRlZmluZSBmb3IgSEFMIE1vZHVsZSAqLworI2lmbmRlZglfX0JGQV9MT0dfSEFMX0hfXworI2RlZmluZQlfX0JGQV9MT0dfSEFMX0hfXworI2luY2x1ZGUgIDxjcy9iZmFfbG9nLmg+CisjZGVmaW5lIEJGQV9MT0dfSEFMX0FTU0VSVCBcCisJKCgodTMyKSBCRkFfTE9HX0hBTF9JRCA8PCBCRkFfTE9HX01PRElEX09GRlNFVCkgfCAxKQorI2RlZmluZSBCRkFfTE9HX0hBTF9IRUFSVEJFQVRfRkFJTFVSRSBcCisJKCgodTMyKSBCRkFfTE9HX0hBTF9JRCA8PCBCRkFfTE9HX01PRElEX09GRlNFVCkgfCAyKQorI2RlZmluZSBCRkFfTE9HX0hBTF9GQ1BJTV9QQVJNX0lOVkFMSUQgXAorCSgoKHUzMikgQkZBX0xPR19IQUxfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgMykKKyNkZWZpbmUgQkZBX0xPR19IQUxfU01fQVNTRVJUIFwKKwkoKCh1MzIpIEJGQV9MT0dfSEFMX0lEIDw8IEJGQV9MT0dfTU9ESURfT0ZGU0VUKSB8IDQpCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9sb2cvYmZhX2xvZ19saW51eC5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL2xvZy9iZmFfbG9nX2xpbnV4LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzE3YzA1NAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9sb2cvYmZhX2xvZ19saW51eC5oCkBAIC0wLDAgKzEsNDQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyogbWVzc2FnZXMgZGVmaW5lIGZvciBMSU5VWCBNb2R1bGUgKi8KKyNpZm5kZWYJX19CRkFfTE9HX0xJTlVYX0hfXworI2RlZmluZQlfX0JGQV9MT0dfTElOVVhfSF9fCisjaW5jbHVkZSAgPGNzL2JmYV9sb2cuaD4KKyNkZWZpbmUgQkZBX0xPR19MSU5VWF9ERVZJQ0VfQ0xBSU1FRCBcCisJCSgoKHUzMikgQkZBX0xPR19MSU5VWF9JRCA8PCBCRkFfTE9HX01PRElEX09GRlNFVCkgfCAxKQorI2RlZmluZSBCRkFfTE9HX0xJTlVYX0hBU0hfSU5JVF9GQUlMRUQgXAorCQkoKCh1MzIpIEJGQV9MT0dfTElOVVhfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgMikKKyNkZWZpbmUgQkZBX0xPR19MSU5VWF9TWVNGU19GQUlMRUQgXAorCQkoKCh1MzIpIEJGQV9MT0dfTElOVVhfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgMykKKyNkZWZpbmUgQkZBX0xPR19MSU5VWF9NRU1fQUxMT0NfRkFJTEVEIFwKKwkJKCgodTMyKSBCRkFfTE9HX0xJTlVYX0lEIDw8IEJGQV9MT0dfTU9ESURfT0ZGU0VUKSB8IDQpCisjZGVmaW5lIEJGQV9MT0dfTElOVVhfRFJJVkVSX1JFR0lTVFJBVElPTl9GQUlMRUQgXAorCQkoKCh1MzIpIEJGQV9MT0dfTElOVVhfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgNSkKKyNkZWZpbmUgQkZBX0xPR19MSU5VWF9JVE5JTV9GUkVFIFwKKwkJKCgodTMyKSBCRkFfTE9HX0xJTlVYX0lEIDw8IEJGQV9MT0dfTU9ESURfT0ZGU0VUKSB8IDYpCisjZGVmaW5lIEJGQV9MT0dfTElOVVhfSVROSU1fT05MSU5FIFwKKwkJKCgodTMyKSBCRkFfTE9HX0xJTlVYX0lEIDw8IEJGQV9MT0dfTU9ESURfT0ZGU0VUKSB8IDcpCisjZGVmaW5lIEJGQV9MT0dfTElOVVhfSVROSU1fT0ZGTElORSBcCisJCSgoKHUzMikgQkZBX0xPR19MSU5VWF9JRCA8PCBCRkFfTE9HX01PRElEX09GRlNFVCkgfCA4KQorI2RlZmluZSBCRkFfTE9HX0xJTlVYX1NDU0lfSE9TVF9GUkVFIFwKKwkJKCgodTMyKSBCRkFfTE9HX0xJTlVYX0lEIDw8IEJGQV9MT0dfTU9ESURfT0ZGU0VUKSB8IDkpCisjZGVmaW5lIEJGQV9MT0dfTElOVVhfU0NTSV9BQk9SVCBcCisJCSgoKHUzMikgQkZBX0xPR19MSU5VWF9JRCA8PCBCRkFfTE9HX01PRElEX09GRlNFVCkgfCAxMCkKKyNkZWZpbmUgQkZBX0xPR19MSU5VWF9TQ1NJX0FCT1JUX0NPTVAgXAorCQkoKCh1MzIpIEJGQV9MT0dfTElOVVhfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgMTEpCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9sb2cvYmZhX2xvZ193ZHJ2LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvbG9nL2JmYV9sb2dfd2Rydi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgwOWE5NWYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvbG9nL2JmYV9sb2dfd2Rydi5oCkBAIC0wLDAgKzEsMzYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoKKyAqIG1lc3NhZ2VzIGRlZmluZSBmb3IgV0RSViBNb2R1bGUKKyAqLworI2lmbmRlZglfX0JGQV9MT0dfV0RSVl9IX18KKyNkZWZpbmUJX19CRkFfTE9HX1dEUlZfSF9fCisjaW5jbHVkZSAgPGNzL2JmYV9sb2cuaD4KKyNkZWZpbmUgQkZBX0xPR19XRFJWX0lPQ19JTklUX0VSUk9SIAlcCisJKCgodTMyKSBCRkFfTE9HX1dEUlZfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgMSkKKyNkZWZpbmUgQkZBX0xPR19XRFJWX0lPQ19JTlRFUk5BTF9FUlJPUiBcCisJKCgodTMyKSBCRkFfTE9HX1dEUlZfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgMikKKyNkZWZpbmUgQkZBX0xPR19XRFJWX0lPQ19TVEFSVF9FUlJPUiAJXAorCSgoKHUzMikgQkZBX0xPR19XRFJWX0lEIDw8IEJGQV9MT0dfTU9ESURfT0ZGU0VUKSB8IDMpCisjZGVmaW5lIEJGQV9MT0dfV0RSVl9JT0NfU1RPUF9FUlJPUiAJXAorCSgoKHUzMikgQkZBX0xPR19XRFJWX0lEIDw8IEJGQV9MT0dfTU9ESURfT0ZGU0VUKSB8IDQpCisjZGVmaW5lIEJGQV9MT0dfV0RSVl9JTlNVRkZJQ0lFTlRfUkVTT1VSQ0VTIFwKKwkoKCh1MzIpIEJGQV9MT0dfV0RSVl9JRCA8PCBCRkFfTE9HX01PRElEX09GRlNFVCkgfCA1KQorI2RlZmluZSBCRkFfTE9HX1dEUlZfQkFTRV9BRERSRVNTX01BUF9FUlJPUiBcCisJKCgodTMyKSBCRkFfTE9HX1dEUlZfSUQgPDwgQkZBX0xPR19NT0RJRF9PRkZTRVQpIHwgNikKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL2N0LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvcHJvdG9jb2wvY3QuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jNTlkNjYzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL2N0LmgKQEAgLTAsMCArMSw0OTIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0NUX0hfXworI2RlZmluZSBfX0NUX0hfXworCisjaW5jbHVkZSA8cHJvdG9jb2wvdHlwZXMuaD4KKworI3ByYWdtYSBwYWNrKDEpCisKK3N0cnVjdCBjdF9oZHJfc3sKKwl1MzIJcmV2X2lkOjg7CS8qIFJldmlzaW9uIG9mIHRoZSBDVCAqLworCXUzMglpbl9pZDoyNDsJLyogSW5pdGlhdG9yIElkICovCisJdTMyCWdzX3R5cGU6ODsJLyogR2VuZXJpYyBzZXJ2aWNlIFR5cGUgKi8KKwl1MzIJZ3Nfc3ViX3R5cGU6ODsJLyogR2VuZXJpYyBzZXJ2aWNlIHN1YiB0eXBlICovCisJdTMyCW9wdGlvbnM6ODsJLyogb3B0aW9ucyAqLworCXUzMglyc3ZyZDo4OwkvKiByZXNlcnZlZCAqLworCXUzMgljbWRfcnNwX2NvZGU6MTY7LyogY3QgY29tbWFuZC9yZXNwb25zZSBjb2RlICovCisJdTMyCW1heF9yZXNfc2l6ZToxNjsvKiBtYXhpbXVtL3Jlc2lkdWFsIHNpemUgKi8KKwl1MzIJZnJhZ19pZDo4OwkvKiBmcmFnbWVudCBJRCAqLworCXUzMglyZWFzb25fY29kZTo4OwkvKiByZWFzb24gY29kZSAqLworCXUzMglleHBfY29kZTo4OwkvKiBleHBsYW5hdGlvbiBjb2RlICovCisJdTMyCXZlbmRvcl91bnE6ODsJLyogdmVuZG9yIHVuaXF1ZSAqLworfTsKKworLyoKKyAqIGRlZmluZXMgZm9yIHRoZSBSZXZpc2lvbgorICovCitlbnVtIHsKKwlDVF9HUzNfUkVWSVNJT04gPSAweDAxLAorfTsKKworLyoKKyAqIGRlZmluZXMgZm9yIGdzX3R5cGUKKyAqLworZW51bSB7CisJQ1RfR1NUWVBFX0tFWVNFUlZJQ0UJPSAweEY3LAorCUNUX0dTVFlQRV9BTElBU1NFUlZJQ0UJPSAweEY4LAorCUNUX0dTVFlQRV9NR01UU0VSVklDRQk9IDB4RkEsCisJQ1RfR1NUWVBFX1RJTUVTRVJWSUNFCT0gMHhGQiwKKwlDVF9HU1RZUEVfRElSU0VSVklDRQk9IDB4RkMsCit9OworCisvKgorICogZGVmaW5lcyBmb3IgZ3Nfc3ViX3R5cGUgZm9yIGdzIHR5cGUgZGlyZWN0b3J5IHNlcnZpY2UKKyAqLworZW51bSB7CisJQ1RfR1NTVUJUWVBFX05BTUVTRVJWRVIgPSAweDAyLAorfTsKKworLyoKKyAqIGRlZmluZXMgZm9yIGdzX3N1Yl90eXBlIGZvciBncyB0eXBlIG1hbmFnZW1lbnQgc2VydmljZQorICovCitlbnVtIHsKKwlDVF9HU1NVQlRZUEVfQ0ZHU0VSVkVSCT0gMHgwMSwKKwlDVF9HU1NVQlRZUEVfVU5aT05FRF9OUyA9IDB4MDIsCisJQ1RfR1NTVUJUWVBFX1pPTkVTRVJWRVIgPSAweDAzLAorCUNUX0dTU1VCVFlQRV9MT0NLU0VSVkVSID0gMHgwNCwKKwlDVF9HU1NVQlRZUEVfSEJBX01HTVRTRVJWRVIgPSAweDEwLAkvKiBmb3IgRkRNSSAqLworfTsKKworLyoKKyAqIGRlZmluZXMgZm9yIENUIHJlc3BvbnNlIGNvZGUgZmllbGQKKyAqLworZW51bSB7CisJQ1RfUlNQX1JFSkVDVCA9IDB4ODAwMSwKKwlDVF9SU1BfQUNDRVBUID0gMHg4MDAyLAorfTsKKworLyoKKyAqIGRlZmludGlvbnMgZm9yIENUIHJlYXNvbiBjb2RlCisgKi8KK2VudW0geworCUNUX1JTTl9JTlZfQ01ECQk9IDB4MDEsCisJQ1RfUlNOX0lOVl9WRVIJCT0gMHgwMiwKKwlDVF9SU05fTE9HSUNfRVJSCT0gMHgwMywKKwlDVF9SU05fSU5WX1NJWkUJCT0gMHgwNCwKKwlDVF9SU05fTE9HSUNBTF9CVVNZCT0gMHgwNSwKKwlDVF9SU05fUFJPVE9fRVJSCT0gMHgwNywKKwlDVF9SU05fVU5BQkxFX1RPX1BFUkYJPSAweDA5LAorCUNUX1JTTl9OT1RfU1VQUAkJCT0gMHgwQiwKKwlDVF9SU05fU0VSVkVSX05PVF9BVkJMICA9IDB4MEQsCisJQ1RfUlNOX1NFU1NJT05fQ09VTERfTk9UX0JFX0VTVEJEID0gMHgwRSwKKwlDVF9SU05fVkVORE9SX1NQRUNJRklDICA9IDB4RkYsCisKK307CisKKy8qCisgKiBkZWZpbml0aW9ucyBmb3IgZXhwbGFuYXRpb25zIGNvZGUgZm9yIE5hbWUgc2VydmVyCisgKi8KK2VudW0geworCUNUX05TX0VYUF9OT0FERElUSU9OQUwJPSAweDAwLAorCUNUX05TX0VYUF9JRF9OT1RfUkVHCT0gMHgwMSwKKwlDVF9OU19FWFBfUE5fTk9UX1JFRwk9IDB4MDIsCisJQ1RfTlNfRVhQX05OX05PVF9SRUcJPSAweDAzLAorCUNUX05TX0VYUF9DU19OT1RfUkVHCT0gMHgwNCwKKwlDVF9OU19FWFBfSVBOX05PVF9SRUcJPSAweDA1LAorCUNUX05TX0VYUF9JUEFfTk9UX1JFRwk9IDB4MDYsCisJQ1RfTlNfRVhQX0ZUX05PVF9SRUcJPSAweDA3LAorCUNUX05TX0VYUF9TUE5fTk9UX1JFRwk9IDB4MDgsCisJQ1RfTlNfRVhQX1NOTl9OT1RfUkVHCT0gMHgwOSwKKwlDVF9OU19FWFBfUFRfTk9UX1JFRwk9IDB4MEEsCisJQ1RfTlNfRVhQX0lQUF9OT1RfUkVHCT0gMHgwQiwKKwlDVF9OU19FWFBfRlBOX05PVF9SRUcJPSAweDBDLAorCUNUX05TX0VYUF9IQV9OT1RfUkVHCT0gMHgwRCwKKwlDVF9OU19FWFBfRkRfTk9UX1JFRwk9IDB4MEUsCisJQ1RfTlNfRVhQX0ZGX05PVF9SRUcJPSAweDBGLAorCUNUX05TX0VYUF9BQ0NFU1NERU5JRUQJPSAweDEwLAorCUNUX05TX0VYUF9VTkFDQ0VQVEFCTEVfSUQgPSAweDExLAorCUNUX05TX0VYUF9EQVRBQkFTRUVNUFRZCQkJPSAweDEyLAorCUNUX05TX0VYUF9OT1RfUkVHX0lOX1NDT1BFIAkJPSAweDEzLAorCUNUX05TX0VYUF9ET01fSURfTk9UX1BSRVNFTlQgCT0gMHgxNCwKKwlDVF9OU19FWFBfUE9SVF9OVU1fTk9UX1BSRVNFTlQgID0gMHgxNSwKKwlDVF9OU19FWFBfTk9fREVWSUNFX0FUVEFDSEVEIAk9IDB4MTYKK307CisKKy8qCisgKiBkZWZpbnRpb25zIGZvciB0aGUgZXhwbGFuYXRpb24gY29kZSBmb3IgYWxsIHNlcnZlcnMKKyAqLworZW51bSB7CisJQ1RfRVhQX0FVVEhfRVhDRVBUSU9OCQkJPSAweEYxLAorCUNUX0VYUF9EQl9GVUxMCQkJCQk9IDB4RjIsCisJQ1RfRVhQX0RCX0VNUFRZCQkJCQk9IDB4RjMsCisJQ1RfRVhQX1BST0NFU1NJTkdfUkVRCQkJPSAweEY0LAorCUNUX0VYUF9VTkFCTEVfVE9fVkVSSUZZX0NPTk4JPSAweEY1LAorCUNUX0VYUF9ERVZJQ0VTX05PVF9JTl9DTU5fWk9ORSAgPSAweEY2Cit9OworCisvKgorICogQ29tbWFuZCBjb2RlcyBmb3IgTmFtZSBzZXJ2ZXIKKyAqLworZW51bSB7CisJR1NfR0lEX1BOCT0gMHgwMTIxLAkvKiBHZXQgSWQgb24gcG9ydCBuYW1lICovCisJR1NfR1BOX0lECT0gMHgwMTEyLAkvKiBHZXQgcG9ydCBuYW1lIG9uIElEICovCisJR1NfR05OX0lECT0gMHgwMTEzLAkvKiBHZXQgbm9kZSBuYW1lIG9uIElEICovCisJR1NfR0lEX0ZUCT0gMHgwMTcxLAkvKiBHZXQgSWQgb24gRkM0IHR5cGUgKi8KKwlHU19HU1BOX0lECT0gMHgwMTE4LAkvKiBHZXQgc3ltYm9saWMgUE4gb24gSUQgKi8KKwlHU19SRlRfSUQJPSAweDAyMTcsCS8qIFJlZ2lzdGVyIGZjNHR5cGUgb24gSUQgKi8KKwlHU19SU1BOX0lECT0gMHgwMjE4LAkvKiBSZWdpc3RlciBzeW1ib2xpYyBQTiBvbiBJRCAqLworCUdTX1JQTl9JRAk9IDB4MDIxMiwJLyogUmVnaXN0ZXIgcG9ydCBuYW1lICovCisJR1NfUk5OX0lECT0gMHgwMjEzLAkvKiBSZWdpc3RlciBub2RlIG5hbWUgKi8KKwlHU19SQ1NfSUQJPSAweDAyMTQsCS8qIFJlZ2lzdGVyIGNsYXNzIG9mIHNlcnZpY2UgKi8KKwlHU19SUFRfSUQJPSAweDAyMUEsCS8qIFJlZ2lzdGVyIHBvcnQgdHlwZSAqLworCUdTX0dBX05YVAk9IDB4MDEwMCwJLyogR2V0IGFsbCBuZXh0ICovCisJR1NfUkZGX0lECT0gMHgwMjFGLAkvKiBSZWdpc3RlciBGQzQgRmVhdHVyZQkJKi8KK307CisKK3N0cnVjdCBmY2dzX2lkX3JlcV9zeworCXUzMglyc3ZkOjg7CisJdTMyCWRhcDoyNDsJLyogcG9ydCBpZGVudGlmaWVyICovCit9OworI2RlZmluZSBmY2dzX2dwbmlkX3JlcV90IHN0cnVjdCBmY2dzX2lkX3JlcV9zCisjZGVmaW5lIGZjZ3NfZ25uaWRfcmVxX3Qgc3RydWN0IGZjZ3NfaWRfcmVxX3MKKyNkZWZpbmUgZmNnc19nc3BuaWRfcmVxX3Qgc3RydWN0IGZjZ3NfaWRfcmVxX3MKKworc3RydWN0IGZjZ3NfZ2lkcG5fcmVxX3N7CisJd3duX3QJcG9ydF9uYW1lOwkvKiBwb3J0IHd3biAqLworfTsKKworc3RydWN0IGZjZ3NfZ2lkcG5fcmVzcF9zeworCXUzMglyc3ZkOjg7CisJdTMyCWRhcDoyNDsJLyogcG9ydCBpZGVudGlmaWVyICovCit9OworCisvKioKKyAqIFJGVF9JRAorICovCitzdHJ1Y3QgZmNnc19yZnRpZF9yZXFfcyB7CisJdTMyCXJzdmQ6ODsKKwl1MzIJZGFwOjI0OwkJLyogcG9ydCBpZGVudGlmaWVyICovCisJdTMyCWZjNF90eXBlWzhdOwkvKiBmYzQgdHlwZXMgKi8KK307CisKKy8qKgorICogUkZGX0lEIDogUmVnaXN0ZXIgRkM0IGZlYXR1cmVzLgorICovCisKKyNkZWZpbmUgRkNfR1NfRkNQX0ZDNF9GRUFUVVJFX0lOSVRJQVRPUiAgMHgwMgorI2RlZmluZSBGQ19HU19GQ1BfRkM0X0ZFQVRVUkVfVEFSR0VUCSAweDAxCisKK3N0cnVjdCBmY2dzX3JmZmlkX3JlcV9zeworICAgIHUzMiAgICByc3ZkICAgICAgICAgIDo4OworICAgIHUzMiAgICBkYXAgICAgICAgIAkgIDoyNDsJCS8qIHBvcnQgaWRlbnRpZmllcgkqLworICAgIHUzMiAgICByc3ZkMSAgICAgICAgIDoxNjsKKyAgICB1MzIgICAgZmM0ZnRyX2JpdHMgICA6ODsJCS8qIGZjNCBmZWF0dXJlIGJpdHMJKi8KKyAgICB1MzIgICAgZmM0X3R5cGUgICAgICA6ODsJCS8qIGNvcnJlc3BvbmRpbmcgRkM0IFR5cGUgKi8KK307CisKKy8qKgorICogR0lEX0ZUIFJlcXVlc3QKKyAqLworc3RydWN0IGZjZ3NfZ2lkZnRfcmVxX3N7CisJdTgJcmVzZXJ2ZWQ7CisJdTgJZG9tYWluX2lkOwkvKiBkb21haW4sIDAgLSBhbGwgZmFicmljICovCisJdTgJYXJlYV9pZDsJLyogYXJlYSwgMCAtIHdob2xlIGRvbWFpbiAqLworCXU4CWZjNF90eXBlOwkvKiBGQ19UWVBFX0ZDUCBmb3IgU0NTSSBkZXZpY2VzICovCit9OwkJCQkvKiBHSURfRlQgUmVxdWVzdCAqLworCisvKioKKyAqIEdJRF9GVCBSZXNwb25zZQorICovCitzdHJ1Y3QgZmNnc19naWRmdF9yZXNwX3MgeworCXU4CQlsYXN0OjE7CS8qIGxhc3QgcG9ydCBpZGVudGlmaWVyIGZsYWcgKi8KKwl1OAkJcmVzZXJ2ZWQ6NzsKKwl1MzIJcGlkOjI0OwkvKiBwb3J0IGlkZW50aWZpZXIgKi8KK307CQkJCS8qIEdJRF9GVCBSZXNwb25zZSAqLworCisvKioKKyAqIFJTUE5fSUQKKyAqLworc3RydWN0IGZjZ3NfcnNwbmlkX3JlcV9zeworCXUzMglyc3ZkOjg7CisJdTMyCWRhcDoyNDsJCS8qIHBvcnQgaWRlbnRpZmllciAqLworCXU4CQlzcG5fbGVuOwkvKiBzeW1ib2xpYyBwb3J0IG5hbWUgbGVuZ3RoICovCisJdTgJCXNwblsyNTZdOwkvKiBzeW1ib2xpYyBwb3J0IG5hbWUgKi8KK307CisKKy8qKgorICogUlBOX0lECisgKi8KK3N0cnVjdCBmY2dzX3JwbmlkX3JlcV9zeworCXUzMglyc3ZkOjg7CisJdTMyCXBvcnRfaWQ6MjQ7CisJd3duX3QJCXBvcnRfbmFtZTsKK307CisKKy8qKgorICogUk5OX0lECisgKi8KK3N0cnVjdCBmY2dzX3JubmlkX3JlcV9zeworCXUzMglyc3ZkOjg7CisJdTMyCXBvcnRfaWQ6MjQ7CisJd3duX3QJCW5vZGVfbmFtZTsKK307CisKKy8qKgorICogUkNTX0lECisgKi8KK3N0cnVjdCBmY2dzX3Jjc2lkX3JlcV9zeworCXUzMglyc3ZkOjg7CisJdTMyCXBvcnRfaWQ6MjQ7CisJdTMyCWNvczsKK307CisKKy8qKgorICogUlBUX0lECisgKi8KK3N0cnVjdCBmY2dzX3JwdGlkX3JlcV9zeworCXUzMglyc3ZkOjg7CisJdTMyCXBvcnRfaWQ6MjQ7CisJdTMyCXBvcnRfdHlwZTo4OworCXUzMglyc3ZkMToyNDsKK307CisKKy8qKgorICogR0FfTlhUIFJlcXVlc3QKKyAqLworc3RydWN0IGZjZ3NfZ2FueHRfcmVxX3N7CisJdTMyCXJzdmQ6ODsKKwl1MzIJcG9ydF9pZDoyNDsKK307CisKKy8qKgorICogR0FfTlhUIFJlc3BvbnNlCisgKi8KK3N0cnVjdCBmY2dzX2dhbnh0X3JzcF9zeworCXUzMglwb3J0X3R5cGU6ODsJLyogUG9ydCBUeXBlICovCisJdTMyCXBvcnRfaWQ6MjQ7CS8qIFBvcnQgSWRlbnRpZmllciAqLworCXd3bl90CQlwb3J0X25hbWU7CS8qIFBvcnQgTmFtZSAqLworCXU4CQlzcG5fbGVuOwkvKiBMZW5ndGggb2YgU3ltYm9saWMgUG9ydCBOYW1lICovCisJY2hhcgkJc3BuWzI1NV07CS8qIFN5bWJvbGljIFBvcnQgTmFtZSAqLworCXd3bl90CQlub2RlX25hbWU7CS8qIE5vZGUgTmFtZSAqLworCXU4CQlzbm5fbGVuOwkvKiBMZW5ndGggb2YgU3ltYm9saWMgTm9kZSBOYW1lICovCisJY2hhcgkJc25uWzI1NV07CS8qIFN5bWJvbGljIE5vZGUgTmFtZSAqLworCXU4CQlpcGFbOF07CQkvKiBJbml0aWFsIFByb2Nlc3MgQXNzb2NpYXRvciAqLworCXU4CQlpcFsxNl07CQkvKiBJUCBBZGRyZXNzICovCisJdTMyCWNvczsJCS8qIENsYXNzIG9mIFNlcnZpY2UgKi8KKwl1MzIJZmM0dHlwZXNbOF07CS8qIEZDLTQgVFlQRXMgKi8KKwl3d25fdAkJZmFicmljX3BvcnRfbmFtZTsKKwkJCQkJLyogRmFicmljIFBvcnQgTmFtZSAqLworCXUzMglyc3ZkOjg7CQkvKiBSZXNlcnZlZCAqLworCXUzMgloYXJkX2FkZHI6MjQ7CS8qIEhhcmQgQWRkcmVzcyAqLworfTsKKworLyoKKyAqIEZhYnJpYyBDb25maWcgU2VydmVyCisgKi8KKworLyoKKyAqIENvbW1hbmQgY29kZXMgZm9yIEZhYnJpYyBDb25maWd1cmF0aW9uIFNlcnZlcgorICovCitlbnVtIHsKKwlHU19GQ19HRk5fQ01ECT0gMHgwMTE0LAkvKiBHUyBGQyBHZXQgRmFicmljIE5hbWUgICovCisJR1NfRkNfR01BTF9DTUQJPSAweDAxMTYsCS8qIEdTIEZDIEdNQUwgICovCisJR1NfRkNfVFJBQ0VfQ01ECT0gMHgwNDAwLAkvKiBHUyBGQyBUcmFjZSBSb3V0ZSAqLworCUdTX0ZDX1BJTkdfQ01ECT0gMHgwNDAxLAkvKiBHUyBGQyBQaW5nICovCit9OworCisvKgorICogU291cmNlIG9yIERlc3RpbmF0aW9uIFBvcnQgVGFncy4KKyAqLworZW51bSB7CisJR1NfRlRSQUNFX1RBR19OUE9SVF9JRAkJPSAxLAorCUdTX0ZUUkFDRV9UQUdfTlBPUlRfTkFNRQk9IDIsCit9OworCisvKgorKiBQb3J0IFZhbHVlIDogQ291bGQgYmUgYSBQb3J0IGlkIG9yIHd3bgorICovCit1bmlvbiBmY2dzX3BvcnRfdmFsX3V7CisJdTMyCW5wb3J0X2lkOworCXd3bl90CQlucG9ydF93d247Cit9OworCisjZGVmaW5lIEdTX0ZUUkFDRV9NQVhfSE9QX0NPVU5UCTIwCisjZGVmaW5lIEdTX0ZUUkFDRV9SRVZJU0lPTgkxCisKKy8qCisgKiBGdHJhY2UgUmVsYXRlZCBTdHJ1Y3R1cmVzLgorICovCisKKy8qCisgKiBTVFIgKFN3aXRjaCBUcmFjZSkgUmVqZWN0IFJlYXNvbiBDb2Rlcy4gRnJvbSBGQy1TVy4KKyAqLworZW51bSB7CisJR1NfRlRSQUNFX1NUUl9DTURfQ09NUExFVEVEX1NVQ0MJPSAwLAorCUdTX0ZUUkFDRV9TVFJfQ01EX05PVF9TVVBQX0lOX05FWFRfU1dJVENILAorCUdTX0ZUUkFDRV9TVFJfTk9fUkVTUF9GUk9NX05FWFRfU1dJVENILAorCUdTX0ZUUkFDRV9TVFJfTUFYX0hPUF9DTlRfUkVBQ0hFRCwKKwlHU19GVFJBQ0VfU1RSX1NSQ19QT1JUX05PVF9GT1VORCwKKwlHU19GVFJBQ0VfU1RSX0RTVF9QT1JUX05PVF9GT1VORCwKKwlHU19GVFJBQ0VfU1RSX0RFVklDRVNfTk9UX0lOX0NPTU1PTl9aT05FLAorCUdTX0ZUUkFDRV9TVFJfTk9fUk9VVEVfQldfUE9SVFMsCisJR1NfRlRSQUNFX1NUUl9OT19BRERMX0VYUExOLAorCUdTX0ZUUkFDRV9TVFJfRkFCUklDX0JVU1ksCisJR1NfRlRSQUNFX1NUUl9GQUJSSUNfQlVJTERfSU5fUFJPR1JFU1MsCisJR1NfRlRSQUNFX1NUUl9WRU5ET1JfU1BFQ0lGSUNfRVJSX1NUQVJUID0gMHhmMCwKKwlHU19GVFJBQ0VfU1RSX1ZFTkRPUl9TUEVDSUZJQ19FUlJfRU5EID0gMHhmZiwKK307CisKKy8qCisgKiBGdHJhY2UgUmVxdWVzdAorICovCitzdHJ1Y3QgZmNnc19mdHJhY2VfcmVxX3N7CisJdTMyCXJldmlzaW9uOworCXUxNglzcmNfcG9ydF90YWc7CS8qIFNvdXJjZSBQb3J0IHRhZyAqLworCXUxNglzcmNfcG9ydF9sZW47CS8qIFNvdXJjZSBQb3J0IGxlbiAqLworCXVuaW9uIGZjZ3NfcG9ydF92YWxfdSBzcmNfcG9ydF92YWw7CS8qIFNvdXJjZSBQb3J0IHZhbHVlICovCisJdTE2CWRzdF9wb3J0X3RhZzsJLyogRGVzdGluYXRpb24gUG9ydCB0YWcgKi8KKwl1MTYJZHN0X3BvcnRfbGVuOwkvKiBEZXN0aW5hdGlvbiBQb3J0IGxlbiAqLworCXVuaW9uIGZjZ3NfcG9ydF92YWxfdSBkc3RfcG9ydF92YWw7CS8qIERlc3RpbmF0aW9uIFBvcnQgdmFsdWUgKi8KKwl1MzIJdG9rZW47CisJdTgJCXZlbmRvcl9pZFs4XTsJLyogVDEwIFZlbmRvciBJZGVudGlmaWVyICovCisJdTgJCXZlbmRvcl9pbmZvWzhdOwkvKiBWZW5kb3Igc3BlY2lmaWMgSW5mbyAqLworCXUzMgltYXhfaG9wX2NudDsJLyogTWF4IEhvcCBDb3VudCAqLworfTsKKworLyoKKyAqIFBhdGggaW5mbyBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGZjZ3NfZnRyYWNlX3BhdGhfaW5mb19zeworCXd3bl90CQlzd2l0Y2hfbmFtZTsJCS8qIFN3aXRjaCBXV04gKi8KKwl1MzIJZG9tYWluX2lkOworCXd3bl90CQlpbmdyZXNzX3BvcnRfbmFtZTsJLyogSW5ncmVzcyBwb3J0cyB3d24gKi8KKwl1MzIJaW5ncmVzc19waHlzX3BvcnRfbnVtOwkvKiBJbmdyZXNzIHBvcnRzIHBoeXNpY2FsIHBvcnQKKwkJCQkJCSAqIG51bWJlcgorCQkJCQkJICovCisJd3duX3QJCWVncmVzc19wb3J0X25hbWU7CS8qIEluZ3Jlc3MgcG9ydHMgd3duICovCisJdTMyCWVncmVzc19waHlzX3BvcnRfbnVtOwkvKiBJbmdyZXNzIHBvcnRzIHBoeXNpY2FsIHBvcnQKKwkJCQkJCSAqIG51bWJlcgorCQkJCQkJICovCit9OworCisvKgorICogRnRyYWNlIEFjYyBSZXNwb25zZQorICovCitzdHJ1Y3QgZmNnc19mdHJhY2VfcmVzcF9zeworCXUzMglyZXZpc2lvbjsKKwl1MzIJdG9rZW47CisJdTgJCXZlbmRvcl9pZFs4XTsJCS8qIFQxMCBWZW5kb3IgSWRlbnRpZmllciAqLworCXU4CQl2ZW5kb3JfaW5mb1s4XTsJCS8qIFZlbmRvciBzcGVjaWZpYyBJbmZvICovCisJdTMyCXN0cl9yZWpfcmVhc29uX2NvZGU7CS8qIFNUUiBSZWplY3QgUmVhc29uIENvZGUgKi8KKwl1MzIJbnVtX3BhdGhfaW5mb19lbnRyaWVzOwkvKiBOby4gb2YgcGF0aCBpbmZvIGVudHJpZXMgKi8KKwkvKgorCSAqIHBhdGggaW5mbyBlbnRyeS9lbnRyaWVzLgorCSAqLworCXN0cnVjdCBmY2dzX2Z0cmFjZV9wYXRoX2luZm9fcyBwYXRoX2luZm9bMV07CisKK307CisKKy8qCisqIEZhYnJpYyBDb25maWcgU2VydmVyIDogRkNQaW5nCisgKi8KKworLyoKKyAqIEZDIFBpbmcgUmVxdWVzdAorICovCitzdHJ1Y3QgZmNnc19mY3BpbmdfcmVxX3N7CisJdTMyCXJldmlzaW9uOworCXUxNglwb3J0X3RhZzsKKwl1MTYJcG9ydF9sZW47CS8qIFBvcnQgbGVuICovCisJdW5pb24gZmNnc19wb3J0X3ZhbF91IHBvcnRfdmFsOwkvKiBQb3J0IHZhbHVlICovCisJdTMyCXRva2VuOworfTsKKworLyoKKyAqIEZDIFBpbmcgUmVzcG9uc2UKKyAqLworc3RydWN0IGZjZ3NfZmNwaW5nX3Jlc3Bfc3sKKwl1MzIJdG9rZW47Cit9OworCisvKgorICogQ29tbWFuZCBjb2RlcyBmb3Igem9uZSBzZXJ2ZXIgcXVlcnkuCisgKi8KK2VudW0geworCVpTX0daTUUgPSAweDAxMjQsCS8qIEdldCB6b25lIG1lbWJlciBleHRlbmRlZCAqLworfTsKKworLyoKKyAqIFpTIEdaTUUgcmVxdWVzdAorICovCisjZGVmaW5lIFpTX0daTUVfWk5BTUVMRU4JMzIKK3N0cnVjdCB6c19nem1lX3JlcV9zeworCXU4CXpuYW1lbGVuOworCXU4CXJzdmRbM107CisJdTgJem5hbWVbWlNfR1pNRV9aTkFNRUxFTl07Cit9OworCitlbnVtIHpzX21icl90eXBleworCVpTX01CUl9UWVBFX1BXV04JPSAxLAorCVpTX01CUl9UWVBFX0RPTVBPUlQJPSAyLAorCVpTX01CUl9UWVBFX1BPUlRJRAk9IDMsCisJWlNfTUJSX1RZUEVfTldXTgk9IDQsCit9OworCitzdHJ1Y3QgenNfbWJyX3d3bl9zeworCXU4CW1icl90eXBlOworCXU4CXJzdmRbM107CisJd3duX3QJd3duOworfTsKKworc3RydWN0IHpzX3F1ZXJ5X3Jlc3Bfc3sKKwl1MzIJbm1icnM7CS8qICBudW1iZXIgb2Ygem9uZSBtZW1iZXJzICovCisJc3RydWN0IHpzX21icl93d25fcwltYnJbMV07Cit9OworCisvKgorICogR01BTCBDb21tYW5kICggR2V0ICggaW50ZXJjb25uZWN0IEVsZW1lbnQpIE1hbmFnZW1lbnQgQWRkcmVzcyBMaXN0KQorICogVG8gcmV0cmlldmUgdGhlIElQIEFkZHJlc3Mgb2YgYSBTd2l0Y2guCisgKi8KKworI2RlZmluZSBDVF9HTUFMX1JFU1BfUFJFRklYX1RFTE5FVAkgInRlbG5ldDovLyIKKyNkZWZpbmUgQ1RfR01BTF9SRVNQX1BSRUZJWF9IVFRQCSAiaHR0cDovLyIKKworLyogIEdNQUwvR0ZOIHJlcXVlc3QgKi8KK3N0cnVjdCBmY2dzX3JlcV9zIHsKKwl3d25fdCAgICB3d247IAkvKiBQV1dOL05XV04gKi8KK307CisKKyNkZWZpbmUgZmNnc19nbWFsX3JlcV90IHN0cnVjdCBmY2dzX3JlcV9zCisjZGVmaW5lIGZjZ3NfZ2ZuX3JlcV90IHN0cnVjdCBmY2dzX3JlcV9zCisKKy8qIEFjY2VwdCBSZXNwb25zZSB0byBHTUFMICovCitzdHJ1Y3QgZmNnc19nbWFsX3Jlc3BfcyB7CisJdTMyIAkJbXNfbGVuOyAgIC8qIE51bSBvZiBlbnRyaWVzICovCisJdTggICAgIAltc19tYVsyNTZdOworfTsKKworc3RydWN0IGZjX2dtYWxfZW50cnlfcyB7CisJdTggIGxlbjsKKwl1OCAgcHJlZml4WzddOyAvKiBsaWtlICJodHRwOi8vIiAqLworCXU4ICBpcF9hZGRyWzI0OF07Cit9OworCisjcHJhZ21hIHBhY2soKQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9mYy5oIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL2ZjLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2UzOWJhNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9mYy5oCkBAIC0wLDAgKzEsMTEwNSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fRkNfSF9fCisjZGVmaW5lIF9fRkNfSF9fCisKKyNpbmNsdWRlIDxwcm90b2NvbC90eXBlcy5oPgorCisjcHJhZ21hIHBhY2soMSkKKworLyoKKyAqIEZpYnJlIENoYW5uZWwgSGVhZGVyIFN0cnVjdHVyZSAoRkNIUykgZGVmaW5pdGlvbgorICovCitzdHJ1Y3QgZmNoc19zIHsKKyNpZmRlZiBfX0JJR0VORElBTgorCXUzMiAgICAgICAgcm91dGluZzo0OwkvKiByb3V0aW5nIGJpdHMgKi8KKwl1MzIgICAgICAgIGNhdF9pbmZvOjQ7CS8qIGNhdGVnb3J5IGluZm8gKi8KKyNlbHNlCisJdTMyICAgICAgICBjYXRfaW5mbzo0OwkvKiBjYXRlZ29yeSBpbmZvICovCisJdTMyICAgICAgICByb3V0aW5nOjQ7CS8qIHJvdXRpbmcgYml0cyAqLworI2VuZGlmCisJdTMyICAgICAgICBkX2lkOjI0OwkvKiBkZXN0aW5hdGlvbiBpZGVudGlmaWVyICovCisKKwl1MzIgICAgICAgIGNzX2N0bDo4OwkvKiBjbGFzcyBzcGVjaWZpYyBjb250cm9sICovCisJdTMyICAgICAgICBzX2lkOjI0OwkvKiBzb3VyY2UgaWRlbnRpZmllciAqLworCisJdTMyICAgICAgICB0eXBlOjg7CQkvKiBkYXRhIHN0cnVjdHVyZSB0eXBlICovCisJdTMyICAgICAgICBmX2N0bDoyNDsJLyogaW5pdGlhbCBmcmFtZSBjb250cm9sICovCisKKwl1OCAgICAgICAgIHNlcV9pZDsJCS8qIHNlcXVlbmNlIGlkZW50aWZpZXIgKi8KKwl1OCAgICAgICAgIGRmX2N0bDsJCS8qIGRhdGEgZmllbGQgY29udHJvbCAqLworCXUxNiAgICAgICAgc2VxX2NudDsJLyogc2VxdWVuY2UgY291bnQgKi8KKworCXUxNiAgICAgICAgb3hfaWQ7CQkvKiBvcmlnaW5hdG9yIGV4Y2hhbmdlIElEICovCisJdTE2ICAgICAgICByeF9pZDsJCS8qIHJlc3BvbmRlciBleGNoYW5nZSBJRCAqLworCisJdTMyICAgICAgICBybzsJCS8qIHJlbGF0aXZlIG9mZnNldCAqLworfTsKKy8qCisgKiBGaWJyZSBDaGFubmVsIEJCX0UgSGVhZGVyIFN0cnVjdHVyZQorICovCitzdHJ1Y3QgZmNiYmVoc19zIHsKKwl1MTYJdmVyX3JzdmQ7CisJdTMyCXJzdmRbMl07CisJdTMyCXJzdmRfX3NvZjsKK307CisKKyNkZWZpbmUgRkNfU0VRX0lEX01BWAkJMjU2CisKKy8qCisgKiByb3V0aW5nIGJpdCBkZWZpbml0aW9ucworICovCitlbnVtIHsKKwlGQ19SVEdfRkM0X0RFVl9EQVRBCT0gMHgwLAkvKiBGQy00IERldmljZSBEYXRhICovCisJRkNfUlRHX0VYVF9MSU5LCQk9IDB4MiwJLyogRXh0ZW5kZWQgTGluayBEYXRhICovCisJRkNfUlRHX0ZDNF9MSU5LX0RBVEEJPSAweDMsCS8qIEZDLTQgTGluayBEYXRhICovCisJRkNfUlRHX1ZJREVPX0RBVEEJPSAweDQsCS8qIFZpZGVvIERhdGEgKi8KKwlGQ19SVEdfRVhUX0hEUgkJPSAweDUsCS8qIFZGVCwgSUZSIG9yIEVuY2Fwc3VsZWQgKi8KKwlGQ19SVEdfQkFTSUNfTElOSwk9IDB4OCwJLyogQmFzaWMgTGluayBkYXRhICovCisJRkNfUlRHX0xJTktfQ1RSTAk9IDB4QywJLyogTGluayBDb250cm9sICovCit9OworCisvKgorICogaW5mb3JtYXRpb24gY2F0ZWdvcnkgZm9yIGV4dGVuZGVkIGxpbmsgZGF0YSBhbmQgRkMtNCBMaW5rIERhdGEKKyAqLworZW51bSB7CisJRkNfQ0FUX0xEX1JFUVVFU1QJPSAweDIsCS8qIFJlcXVlc3QgKi8KKwlGQ19DQVRfTERfUkVQTFkJCT0gMHgzLAkvKiBSZXBseSAqLworCUZDX0NBVF9MRF9ESUFHCQk9IDB4RiwJLyogZm9yIERJQUcgdXNlIG9ubHkgKi8KK307CisKKy8qCisgKiBpbmZvcm1hdGlvbiBjYXRlZ29yeSBmb3IgZXh0ZW5kZWQgaGVhZGVycyAoVkZULCBJRlIgb3IgZW5jYXBzdWxhdGlvbikKKyAqLworZW51bSB7CisJRkNfQ0FUX1ZGVF9IRFIgPSAweDAsCS8qIFZpcnR1YWwgZmFicmljIHRhZ2dpbmcgaGVhZGVyICovCisJRkNfQ0FUX0lGUl9IRFIgPSAweDEsCS8qIEludGVyLUZhYnJpYyByb3V0aW5nIGhlYWRlciAqLworCUZDX0NBVF9FTkNfSERSID0gMHgyLAkvKiBFbmNhcHN1bGF0aW9uIGhlYWRlciAqLworfTsKKworLyoKKyAqIGluZm9ybWF0aW9uIGNhdGVnb3J5IGZvciBGQy00IGRldmljZSBkYXRhCisgKi8KK2VudW0geworCUZDX0NBVF9VTkNBVEVHX0lORk8JPSAweDAsCS8qIFVuY2F0ZWdvcml6ZWQgaW5mb3JtYXRpb24gKi8KKwlGQ19DQVRfU09MSUNJVF9EQVRBCT0gMHgxLAkvKiBTb2xpY2l0ZWQgRGF0YSAqLworCUZDX0NBVF9VTlNPTElDSVRfQ1RSTAk9IDB4MiwJLyogVW5zb2xpY2l0ZWQgQ29udHJvbCAqLworCUZDX0NBVF9TT0xJQ0lUX0NUUkwJPSAweDMsCS8qIFNvbGljaXRlZCBDb250cm9sICovCisJRkNfQ0FUX1VOU09MSUNJVF9EQVRBCT0gMHg0LAkvKiBVbnNvbGljaXRlZCBEYXRhICovCisJRkNfQ0FUX0RBVEFfREVTQwk9IDB4NSwJLyogRGF0YSBEZXNjcmlwdG9yICovCisJRkNfQ0FUX1VOU09MSUNJVF9DTUQJPSAweDYsCS8qIFVuc29saWNpdGVkIENvbW1hbmQgKi8KKwlGQ19DQVRfQ01EX1NUQVRVUwk9IDB4NywJLyogQ29tbWFuZCBTdGF0dXMgKi8KK307CisKKy8qCisgKiBpbmZvcm1hdGlvbiBjYXRlZ29yeSBmb3IgTGluayBDb250cm9sCisgKi8KK2VudW0geworCUZDX0NBVF9BQ0tfMQkJPSAweDAwLAorCUZDX0NBVF9BQ0tfMF9OCQk9IDB4MDEsCisJRkNfQ0FUX1BfUkpUCQk9IDB4MDIsCisJRkNfQ0FUX0ZfUkpUCQk9IDB4MDMsCisJRkNfQ0FUX1BfQlNZCQk9IDB4MDQsCisJRkNfQ0FUX0ZfQlNZX0RBVEEJPSAweDA1LAorCUZDX0NBVF9GX0JTWV9MSU5LX0NUTAk9IDB4MDYsCisJRkNfQ0FUX0ZfTENSCQk9IDB4MDcsCisJRkNfQ0FUX05UWQkJPSAweDA4LAorCUZDX0NBVF9FTkQJCT0gMHgwOSwKK307CisKKy8qCisgKiBUeXBlIEZpZWxkIERlZmluaXRpb25zLiBGQy1QSCBTZWN0aW9uIDE4LjUgcGcuIDE2NQorICovCitlbnVtIHsKKwlGQ19UWVBFX0JMUwkJPSAweDAsCS8qIEJhc2ljIExpbmsgU2VydmljZSAqLworCUZDX1RZUEVfRUxTCQk9IDB4MSwJLyogRXh0ZW5kZWQgTGluayBTZXJ2aWNlICovCisJRkNfVFlQRV9JUAkJPSAweDUsCS8qIElQICovCisJRkNfVFlQRV9GQ1AJCT0gMHg4LAkvKiBTQ1NJLUZDUCAqLworCUZDX1RZUEVfR1BQCQk9IDB4OSwJLyogU0NTSV9HUFAgKi8KKwlGQ19UWVBFX1NFUlZJQ0VTCT0gMHgyMCwJLyogRmlicmUgQ2hhbm5lbCBTZXJ2aWNlcyAqLworCUZDX1RZUEVfRkNfRlNTCQk9IDB4MjIsCS8qIEZhYnJpYyBTd2l0Y2ggU2VydmljZXMgKi8KKwlGQ19UWVBFX0ZDX0FMCQk9IDB4MjMsCS8qIEZDLUFMICovCisJRkNfVFlQRV9GQ19TTk1QCQk9IDB4MjQsCS8qIEZDLVNOTVAgKi8KKwlGQ19UWVBFX01BWAkJPSAyNTYsCS8qIDI1NiBGQy00IHR5cGVzICovCit9OworCitzdHJ1Y3QgZmNfZmM0dHlwZXNfc3sKKwl1OCAgICAgICAgIGJpdHNbRkNfVFlQRV9NQVggLyA4XTsKK307CisKKy8qCisgKiBGcmFtZSBDb250cm9sIERlZmluaXRpb25zLiBGQy1QSCBUYWJsZS00NS4gcGcuIDE2OAorICovCitlbnVtIHsKKwlGQ1RMX0VDX09SSUcgPSAweDAwMDAwMCwJLyogZXhjaGFuZ2Ugb3JpZ2luYXRvciAqLworCUZDVExfRUNfUkVTUCA9IDB4ODAwMDAwLAkvKiBleGNoYW5nZSByZXNwb25kZXIgKi8KKwlGQ1RMX1NFUV9JTkkgPSAweDAwMDAwMCwJLyogc2VxdWVuY2UgaW5pdGlhdG9yICovCisJRkNUTF9TRVFfUkVDID0gMHg0MDAwMDAsCS8qIHNlcXVlbmNlIHJlY2lwaWVudCAqLworCUZDVExfRlNfRVhDSCA9IDB4MjAwMDAwLAkvKiBmaXJzdCBzZXF1ZW5jZSBvZiB4Y2hnICovCisJRkNUTF9MU19FWENIID0gMHgxMDAwMDAsCS8qIGxhc3Qgc2VxdWVuY2Ugb2YgeGNoZyAqLworCUZDVExfRU5EX1NFUSA9IDB4MDgwMDAwLAkvKiBsYXN0IGZyYW1lIG9mIHNlcXVlbmNlICovCisJRkNUTF9TSV9YRkVSID0gMHgwMTAwMDAsCS8qIHNlcSBpbml0aWF0aXZlIHRyYW5zZmVyICovCisJRkNUTF9ST19QUkVTRU5UID0gMHgwMDAwMDgsCS8qIHJlbGF0aXZlIG9mZnNldCBwcmVzZW50ICovCisJRkNUTF9GSUxMQllURV9NQVNLID0gMHgwMDAwMDMJLyogLCBmaWxsIGJ5dGUgbWFzayAqLworfTsKKworLyoKKyAqIEZhYnJpYyBXZWxsIEtub3duIEFkZHJlc3NlcworICovCitlbnVtIHsKKwlGQ19NSU5fV0VMTF9LTk9XTl9BRERSCQk9IDB4RkZGRkYwLAorCUZDX0RPTUFJTl9DT05UUk9MTEVSX01BU0sgCT0gMHhGRkZDMDAsCisJRkNfQUxJQVNfU0VSVkVSCQkJPSAweEZGRkZGOCwKKwlGQ19NR01UX1NFUlZFUgkJCT0gMHhGRkZGRkEsCisJRkNfVElNRV9TRVJWRVIJCQk9IDB4RkZGRkZCLAorCUZDX05BTUVfU0VSVkVSCQkJPSAweEZGRkZGQywKKwlGQ19GQUJSSUNfQ09OVFJPTExFUgkJPSAweEZGRkZGRCwKKwlGQ19GQUJSSUNfUE9SVAkJCT0gMHhGRkZGRkUsCisJRkNfQlJPQURDQVNUX1NFUlZFUgkJPSAweEZGRkZGRgorfTsKKworLyoKKyAqIGRvbWFpbi9hcmVhL3BvcnQgZGVmaW5lcworICovCisjZGVmaW5lIEZDX0RPTUFJTl9NQVNLICAweEZGMDAwMAorI2RlZmluZSBGQ19ET01BSU5fU0hJRlQgMTYKKyNkZWZpbmUgRkNfQVJFQV9NQVNLICAgIDB4MDBGRjAwCisjZGVmaW5lIEZDX0FSRUFfU0hJRlQgICA4CisjZGVmaW5lIEZDX1BPUlRfTUFTSyAgICAweDAwMDBGRgorI2RlZmluZSBGQ19QT1JUX1NISUZUICAgMAorCisjZGVmaW5lIEZDX0dFVF9ET01BSU4ocCkJKCgocCkgJiBGQ19ET01BSU5fTUFTSykgPj4gRkNfRE9NQUlOX1NISUZUKQorI2RlZmluZSBGQ19HRVRfQVJFQShwKQkJKCgocCkgJiBGQ19BUkVBX01BU0spID4+IEZDX0FSRUFfU0hJRlQpCisjZGVmaW5lIEZDX0dFVF9QT1JUKHApCQkoKChwKSAmIEZDX1BPUlRfTUFTSykgPj4gRkNfUE9SVF9TSElGVCkKKworI2RlZmluZSBGQ19ET01BSU5fQ1RSTFIocCkJKEZDX0RPTUFJTl9DT05UUk9MTEVSX01BU0sgfCAoRkNfR0VUX0RPTUFJTihwKSkpCisKK2VudW0geworCUZDX1JYSURfQU5ZID0gMHhGRkZGVSwKK307CisKKy8qCisgKiBnZW5lcmljIEVMUyBjb21tYW5kCisgKi8KK3N0cnVjdCBmY19lbHNfY21kX3N7CisJdTMyICAgICAgICBlbHNfY29kZTo4OwkvKiBFTFMgQ29tbWFuZCBDb2RlICovCisJdTMyICAgICAgICByZXNlcnZlZDoyNDsKK307CisKKy8qCisgKiBFTFMgQ29tbWFuZCBDb2Rlcy4gRkMtUEggVGFibGUtNzUuIHBnLiAyMjMKKyAqLworZW51bSB7CisJRkNfRUxTX0xTX1JKVCA9IDB4MSwJLyogTGluayBTZXJ2aWNlIFJlamVjdC4gKi8KKwlGQ19FTFNfQUNDID0gMHgwMiwJLyogQWNjZXB0ICovCisJRkNfRUxTX1BMT0dJID0gMHgwMywJLyogTl9Qb3J0IExvZ2luLiAqLworCUZDX0VMU19GTE9HSSA9IDB4MDQsCS8qIEZfUG9ydCBMb2dpbi4gKi8KKwlGQ19FTFNfTE9HTyA9IDB4MDUsCS8qIExvZ291dC4gKi8KKwlGQ19FTFNfQUJUWCA9IDB4MDYsCS8qIEFib3J0IEV4Y2hhbmdlICovCisJRkNfRUxTX1JFUyA9IDB4MDgsCS8qIFJlYWQgRXhjaGFuZ2Ugc3RhdHVzICovCisJRkNfRUxTX1JTUyA9IDB4MDksCS8qIFJlYWQgc2VxdWVuY2Ugc3RhdHVzIGJsb2NrICovCisJRkNfRUxTX1JTSSA9IDB4MEEsCS8qIFJlcXVlc3QgU2VxdWVuY2UgSW5pdGlhdGl2ZSAqLworCUZDX0VMU19FU1RDID0gMHgwQywJLyogRXN0aW1hdGUgQ3JlZGl0LiAqLworCUZDX0VMU19SVFYgPSAweDBFLAkvKiBSZWFkIFRpbWVvdXQgVmFsdWUuICovCisJRkNfRUxTX1JMUyA9IDB4MEYsCS8qIFJlYWQgTGluayBTdGF0dXMuICovCisJRkNfRUxTX0VDSE8gPSAweDEwLAkvKiBFY2hvICovCisJRkNfRUxTX1RFU1QgPSAweDExLAkvKiBUZXN0ICovCisJRkNfRUxTX1JSUSA9IDB4MTIsCS8qIFJlaW5zdGF0ZSBSZWNvdmVyeSBRdWFsaWZpZXIuICovCisJRkNfRUxTX1JFQyA9IDB4MTMsCS8qIEFkZCB0aGlzIGZvciBUQVBFIHN1cHBvcnQgaW4gRkNSICovCisJRkNfRUxTX1BSTEkgPSAweDIwLAkvKiBQcm9jZXNzIExvZ2luICovCisJRkNfRUxTX1BSTE8gPSAweDIxLAkvKiBQcm9jZXNzIExvZ291dC4gKi8KKwlGQ19FTFNfU0NOID0gMHgyMiwJLyogU3RhdGUgQ2hhbmdlIE5vdGlmaWNhdGlvbi4gKi8KKwlGQ19FTFNfVFBSTE8gPSAweDI0LAkvKiBUaGlyZCBQYXJ0eSBQcm9jZXNzIExvZ291dC4gKi8KKwlGQ19FTFNfUERJU0MgPSAweDUwLAkvKiBEaXNjb3ZlciBOX1BvcnQgUGFyYW1ldGVycy4gKi8KKwlGQ19FTFNfRkRJU0MgPSAweDUxLAkvKiBEaXNjb3ZlciBGX1BvcnQgUGFyYW1ldGVycy4gKi8KKwlGQ19FTFNfQURJU0MgPSAweDUyLAkvKiBEaXNjb3ZlciBBZGRyZXNzLiAqLworCUZDX0VMU19GQU4gPSAweDYwLAkvKiBGYWJyaWMgQWRkcmVzcyBOb3RpZmljYXRpb24gKi8KKwlGQ19FTFNfUlNDTiA9IDB4NjEsCS8qIFJlZyBTdGF0ZSBDaGFuZ2UgTm90aWZpY2F0aW9uICovCisJRkNfRUxTX1NDUiA9IDB4NjIsCS8qIFN0YXRlIENoYW5nZSBSZWdpc3RyYXRpb24uICovCisJRkNfRUxTX1JUSU4gPSAweDc3LAkvKiBNYW5nZW1lbnQgc2VydmVyIHJlcXVlc3QgKi8KKwlGQ19FTFNfUk5JRCA9IDB4NzgsCS8qIE1hbmdlbWVudCBzZXJ2ZXIgcmVxdWVzdCAqLworCUZDX0VMU19STElSID0gMHg3OSwJLyogUmVnaXN0ZXJlZCBMaW5rIEluY2lkZW50IFJlY29yZCAqLworCisJRkNfRUxTX1JQU0MgPSAweDdELAkvKiBSZXBvcnQgUG9ydCBTcGVlZCBDYXBhYmlsaXRpZXMgKi8KKwlGQ19FTFNfUVNBID0gMHg3RSwJLyogUXVlcnkgU2VjdXJpdHkgQXR0cmlidXRlcy4gUmVmIEZDLVNQICovCisJRkNfRUxTX0UyRV9MQkVBQ09OID0gMHg4MSwKKwkJCQkvKiBFbmQtdG8tRW5kIExpbmsgQmVhY29uICovCisJRkNfRUxTX0FVVEggPSAweDkwLAkvKiBBdXRoZW50aWNhdGlvbi4gUmVmIEZDLVNQICovCisJRkNfRUxTX1JGQ04gPSAweDk3LAkvKiBSZXF1ZXN0IEZhYnJpYyBDaGFuZ2UgTm90aWZpY2F0aW9uLiBSZWYKKwkJCQkgKkZDLVNQICovCisKK307CisKKy8qCisgKiAgVmVyc2lvbiBudW1iZXJzIGZvciBGQy1QSCBzdGFuZGFyZHMsCisgKiAgdXNlZCBpbiBsb2dpbiB0byBpbmRpY2F0ZSB3aGF0IHBvcnQKKyAqICBzdXBwb3J0cy4gU2VlIEZDLVBILVggdGFibGUgMTU4LgorICovCitlbnVtIHsKKwlGQ19QSF9WRVJfNF8zID0gMHgwOSwKKwlGQ19QSF9WRVJfUEhfMyA9IDB4MjAsCit9OworCisvKgorICogUERVIHNpemUgZGVmaW5lcworICovCitlbnVtIHsKKwlGQ19NSU5fUERVU1ogPSA1MTIsCisJRkNfTUFYX1BEVVNaID0gMjExMiwKK307CisKKy8qCisgKiBOX1BvcnQgUExPR0kgQ29tbW9uIFNlcnZpY2UgUGFyYW1ldGVycy4KKyAqIEZDLVBILXguIEZpZ3VyZS03Ni4gcGcuIDMwOC4KKyAqLworc3RydWN0IGZjX3Bsb2dpX2NzcF9zeworCXU4ICAgICAgICAgdmVyaGk7CS8qIEZDLVBIIGhpZ2ggdmVyc2lvbiAqLworCXU4ICAgICAgICAgdmVybG87CS8qIEZDLVBIIGxvdyB2ZXJzaW9uICovCisJdTE2ICAgICAgICBiYmNyZWQ7CS8qIEJCX0NyZWRpdCAqLworCisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIGNpcm86MSwJCS8qIGNvbnRpbnVvdXNseSBpbmNyZWFzaW5nIFJPICovCisJCQlycm86MSwJCS8qIHJhbmRvbSByZWxhdGl2ZSBvZmZzZXQgKi8KKwkJCW5waXZfc3VwcDoxLAkvKiBOUElWIHN1cHBvcnRlZCAqLworCQkJcG9ydF90eXBlOjEsCS8qIE5fUG9ydC9GX3BvcnQgKi8KKwkJCWFsdGJiY3JlZDoxLAkvKiBhbHRlcm5hdGUgQkJfQ3JlZGl0ICovCisJCQlyZXNvbHV0aW9uOjEsCS8qIG1zL25zIEVEX1RPViByZXNvbHV0aW9uICovCisJCQl2dmxfaW5mbzoxLAkvKiBWVkwgSW5mbyBpbmNsdWRlZCAqLworCQkJcmVzZXJ2ZWQxOjE7CisKKwl1OCAgICAgICAgIGhnX3N1cHA6MSwKKwkJCXF1ZXJ5X2RiYzoxLAorCQkJc2VjdXJpdHk6MSwKKwkJCXN5bmNfY2FwOjEsCisJCQlyX3RfdG92OjEsCisJCQlkaF9kdXBfc3VwcDoxLAorCQkJY2lzYzoxLAkJLyogY29udGludW91c2x5IGluY3JlYXNpbmcgc2VxIGNvdW50ICovCisJCQlwYXlsb2FkOjE7CisjZWxzZQorCXU4ICAgICAgICAgcmVzZXJ2ZWQyOjIsCisJCQlyZXNvbHV0aW9uOjEsCS8qIG1zL25zIEVEX1RPViByZXNvbHV0aW9uICovCisJCQlhbHRiYmNyZWQ6MSwJLyogYWx0ZXJuYXRlIEJCX0NyZWRpdCAqLworCQkJcG9ydF90eXBlOjEsCS8qIE5fUG9ydC9GX3BvcnQgKi8KKwkJCW5waXZfc3VwcDoxLAkvKiBOUElWIHN1cHBvcnRlZCAqLworCQkJcnJvOjEsCQkvKiByYW5kb20gcmVsYXRpdmUgb2Zmc2V0ICovCisJCQljaXJvOjE7CQkvKiBjb250aW51b3VzbHkgaW5jcmVhc2luZyBSTyAqLworCisJdTggICAgICAgICBwYXlsb2FkOjEsCisJCQljaXNjOjEsCQkvKiBjb250aW51b3VzbHkgaW5jcmVhc2luZyBzZXEgY291bnQgKi8KKwkJCWRoX2R1cF9zdXBwOjEsCisJCQlyX3RfdG92OjEsCisJCQlzeW5jX2NhcDoxLAorCQkJc2VjdXJpdHk6MSwKKwkJCXF1ZXJ5X2RiYzoxLAorCQkJaGdfc3VwcDoxOworI2VuZGlmCisKKwl1MTYgICAgICAgIHJ4c3o7CQkvKiByZWNpZXZlIGRhdGFfZmllbGQgc2l6ZSAqLworCisJdTE2ICAgICAgICBjb25zZXE7CisJdTE2ICAgICAgICByb19iaXRtYXA7CisKKwl1MzIgICAgICAgIGVfZF90b3Y7Cit9OworCisvKgorICogTl9Qb3J0IFBMT0dJIENsYXNzIFNwZWNpZmljIFBhcmFtZXRlcnMuCisgKiBGQy1QSC14LiBGaWd1cmUgNzguIHBnLiAzMTguCisgKi8KK3N0cnVjdCBmY19wbG9naV9jbHBfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXUzMiAgICAgICAgY2xhc3NfdmFsaWQ6MTsKKwl1MzIgICAgICAgIGludGVybWl4OjE7CS8qIGNsYXNzIGludGVybWl4IHN1cHBvcnRlZCBpZiBzZXQgPTEuCisJCQkJCSAqIHZhbGlkIG9ubHkgZm9yIGNsYXNzMS4gUmVzZXJ2ZWQgZm9yCisJCQkJCSAqIGNsYXNzMiAmIGNsYXNzMworCQkJCQkgKi8KKwl1MzIgICAgICAgIHJlc2VydmVkMToyOworCXUzMiAgICAgICAgc2VxdWVudGlhbDoxOworCXUzMiAgICAgICAgcmVzZXJ2ZWQyOjM7CisjZWxzZQorCXUzMiAgICAgICAgcmVzZXJ2ZWQyOjM7CisJdTMyICAgICAgICBzZXF1ZW50aWFsOjE7CisJdTMyICAgICAgICByZXNlcnZlZDE6MjsKKwl1MzIgICAgICAgIGludGVybWl4OjE7CS8qIGNsYXNzIGludGVybWl4IHN1cHBvcnRlZCBpZiBzZXQgPTEuCisJCQkJCSAqIHZhbGlkIG9ubHkgZm9yIGNsYXNzMS4gUmVzZXJ2ZWQgZm9yCisJCQkJCSAqIGNsYXNzMiAmIGNsYXNzMworCQkJCQkgKi8KKwl1MzIgICAgICAgIGNsYXNzX3ZhbGlkOjE7CisjZW5kaWYKKworCXUzMiAgICAgICAgcmVzZXJ2ZWQzOjI0OworCisJdTMyICAgICAgICByZXNlcnZlZDQ6MTY7CisJdTMyICAgICAgICByeHN6OjE2OwkvKiBSZWNlaXZlIGRhdGFfZmllbGQgc2l6ZSAqLworCisJdTMyICAgICAgICByZXNlcnZlZDU6ODsKKwl1MzIgICAgICAgIGNvbnNlcTo4OworCXUzMiAgICAgICAgZTJlX2NyZWRpdDoxNjsJLyogZW5kIHRvIGVuZCBjcmVkaXQgKi8KKworCXUzMiAgICAgICAgcmVzZXJ2ZWQ3Ojg7CisJdTMyICAgICAgICBvc3B4Ojg7CisJdTMyICAgICAgICByZXNlcnZlZDg6MTY7Cit9OworCisjZGVmaW5lIEZMT0dJX1ZWTF9CUkNEICAgIDB4NDI1MjQzNDQgLyogQVNDSUkgdmFsdWUgZm9yIGVhY2ggY2hhcmFjdGVyIGluCisJCQkJICAgICAgKiBzdHJpbmcgIkJSQ0QiICovCisKKy8qCisgKiBQTE9HSSBlbHMgY29tbWFuZCBhbmQgcmVwbHkgcGF5bG9hZAorICovCitzdHJ1Y3QgZmNfbG9naV9zeworCXN0cnVjdCBmY19lbHNfY21kX3MgZWxzX2NtZDsJLyogRUxTIGNvbW1hbmQgY29kZSAqLworCXN0cnVjdCBmY19wbG9naV9jc3BfcyAgY3NwOwkJLyogY29tbW9uIHNlcnZpY2UgcGFyYW1zICovCisJd3duX3QgICAgICAgICAgIHBvcnRfbmFtZTsKKwl3d25fdCAgICAgICAgICAgbm9kZV9uYW1lOworCXN0cnVjdCBmY19wbG9naV9jbHBfcyAgY2xhc3MxOwkJLyogY2xhc3MgMSBzZXJ2aWNlIHBhcmFtZXRlcnMgKi8KKwlzdHJ1Y3QgZmNfcGxvZ2lfY2xwX3MgIGNsYXNzMjsJCS8qIGNsYXNzIDIgc2VydmljZSBwYXJhbWV0ZXJzICovCisJc3RydWN0IGZjX3Bsb2dpX2NscF9zICBjbGFzczM7CQkvKiBjbGFzcyAzIHNlcnZpY2UgcGFyYW1ldGVycyAqLworCXN0cnVjdCBmY19wbG9naV9jbHBfcyAgY2xhc3M0OwkJLyogY2xhc3MgNCBzZXJ2aWNlIHBhcmFtZXRlcnMgKi8KKwl1OCAgICAgICAgIHZ2bFsxNl07CS8qIHZlbmRvciB2ZXJzaW9uIGxldmVsICovCit9OworCisvKgorICogTE9HTyBlbHMgY29tbWFuZCBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY19sb2dvX3N7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICBlbHNfY21kOwkvKiBFTFMgY29tbWFuZCBjb2RlICovCisJdTMyICAgICAgICByZXMxOjg7CisJdTMyICAgICAgICBucG9ydF9pZDoyNDsJLyogTl9Qb3J0IGlkZW50aWZpZXIgb2Ygc291cmNlICovCisJd3duX3QgICAgICAgICAgIG9yaWdfcG9ydF9uYW1lOwkvKiBQb3J0IG5hbWUgb2YgdGhlIExPR08gb3JpZ2luYXRvciAqLworfTsKKworLyoKKyAqIEFESVNDIGVscyBjb21tYW5kIHBheWxvYWQKKyAqLworc3RydWN0IGZjX2FkaXNjX3MgeworCXN0cnVjdCBmY19lbHNfY21kX3MgICAgZWxzX2NtZDsJLyogRUxTIGNvbW1hbmQgY29kZSAqLworCXUzMiAgICAgICAgcmVzMTo4OworCXUzMiAgICAgICAgb3JpZ19IQToyNDsJLyogb3JpZ2luYXRvciBoYXJkIGFkZHJlc3MgKi8KKwl3d25fdCAgICAgICAgICAgb3JpZ19wb3J0X25hbWU7CS8qIG9yaWdpbmF0b3IgcG9ydCBuYW1lICovCisJd3duX3QgICAgICAgICAgIG9yaWdfbm9kZV9uYW1lOwkvKiBvcmlnaW5hdG9yIG5vZGUgbmFtZSAqLworCXUzMiAgICAgICAgcmVzMjo4OworCXUzMiAgICAgICAgbnBvcnRfaWQ6MjQ7CS8qIG9yaWdpbmF0b3IgTlBvcnRJRCAqLworfTsKKworLyoKKyAqIEV4Y2hhbmdlIHN0YXR1cyBibG9jaworICovCitzdHJ1Y3QgZmNfZXhjaF9zdGF0dXNfYmxrX3N7CisJdTMyICAgICAgICBveGlkOjE2OworCXUzMiAgICAgICAgcnhpZDoxNjsKKwl1MzIgICAgICAgIHJlczE6ODsKKwl1MzIgICAgICAgIG9yaWdfbnA6MjQ7CS8qIG9yaWdpbmF0b3IgTlBvcnRJRCAqLworCXUzMiAgICAgICAgcmVzMjo4OworCXUzMiAgICAgICAgcmVzcF9ucDoyNDsJLyogcmVzcG9uZGVyIE5Qb3J0SUQgKi8KKwl1MzIgICAgICAgIGVzX2JpdHM7CisJdTMyICAgICAgICByZXMzOworCS8qCisJICogdW4gbW9kaWZpZWQgc2VjdGlvbiBvZiB0aGUgZmllbGRzCisJICovCit9OworCisvKgorICogUkVTIGVscyBjb21tYW5kIHBheWxvYWQKKyAqLworc3RydWN0IGZjX3Jlc19zIHsKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgIGVsc19jbWQ7CS8qIEVMUyBjb21tYW5kIGNvZGUgKi8KKwl1MzIgICAgICAgIHJlczE6ODsKKwl1MzIgICAgICAgIG5wb3J0X2lkOjI0OwkvKiBOX1BvcnQgaWRlbnRpZmllciBvZiBzb3VyY2UgKi8KKwl1MzIgICAgICAgIG94aWQ6MTY7CisJdTMyICAgICAgICByeGlkOjE2OworCXU4ICAgICAgICAgYXNzb2NfaGRyWzMyXTsKK307CisKKy8qCisgKiBSRVMgZWxzIGFjY2VwdCBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY19yZXNfYWNjX3N7CisJc3RydWN0IGZjX2Vsc19jbWRfcyBlbHNfY21kOwkvKiBFTFMgY29tbWFuZCBjb2RlICovCisJc3RydWN0IGZjX2V4Y2hfc3RhdHVzX2Jsa19zIGZjX2V4Y2hfYmxrOyAvKiBFeGNoYW5nZSBzdGF0dXMgYmxvY2sgKi8KK307CisKKy8qCisgKiBSRUMgZWxzIGNvbW1hbmQgcGF5bG9hZAorICovCitzdHJ1Y3QgZmNfcmVjX3MgeworCXN0cnVjdCBmY19lbHNfY21kX3MgICAgZWxzX2NtZDsJLyogRUxTIGNvbW1hbmQgY29kZSAqLworCXUzMiAgICAgICAgcmVzMTo4OworCXUzMiAgICAgICAgbnBvcnRfaWQ6MjQ7CS8qIE5fUG9ydCBpZGVudGlmaWVyIG9mIHNvdXJjZSAqLworCXUzMiAgICAgICAgb3hpZDoxNjsKKwl1MzIgICAgICAgIHJ4aWQ6MTY7Cit9OworCisjZGVmaW5lIEZDX1JFQ19FU0JfT1dOX1JTUAkweDgwMDAwMDAwCS8qIHJlc3BvbmRlciBvd25zICovCisjZGVmaW5lIEZDX1JFQ19FU0JfU0kJCTB4NDAwMDAwMDAJLyogU0kgaXMgb3duZWQgCSovCisjZGVmaW5lIEZDX1JFQ19FU0JfQ09NUAkJMHgyMDAwMDAwMAkvKiBleGNoYW5nZSBpcyBjb21wbGV0ZQkqLworI2RlZmluZSBGQ19SRUNfRVNCX0VORENPTkRfQUJOCTB4MTAwMDAwMDAJLyogYWJub3JtYWwgZW5kaW5nIAkqLworI2RlZmluZSBGQ19SRUNfRVNCX1JRQUNUCTB4MDQwMDAwMDAJLyogcmVjb3ZlcnkgcXVhbCBhY3RpdmUJKi8KKyNkZWZpbmUgRkNfUkVDX0VTQl9FUlJQX01TSwkweDAzMDAwMDAwCisjZGVmaW5lIEZDX1JFQ19FU0JfT1hJRF9JTlYJMHgwMDgwMDAwMAkvKiBpbnZhbGlkIE9YSUQJCSovCisjZGVmaW5lIEZDX1JFQ19FU0JfUlhJRF9JTlYJMHgwMDQwMDAwMAkvKiBpbnZhbGlkIFJYSUQJCSovCisjZGVmaW5lIEZDX1JFQ19FU0JfUFJJT19JTlVTRQkweDAwMjAwMDAwCisKKy8qCisgKiBSRUMgZWxzIGFjY2VwdCBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY19yZWNfYWNjX3MgeworCXN0cnVjdCBmY19lbHNfY21kX3MgICAgZWxzX2NtZDsJLyogRUxTIGNvbW1hbmQgY29kZSAqLworCXUzMiAgICAgICAgb3hpZDoxNjsKKwl1MzIgICAgICAgIHJ4aWQ6MTY7CisJdTMyICAgICAgICByZXMxOjg7CisJdTMyICAgICAgICBvcmlnX2lkOjI0OwkvKiBOX1BvcnQgaWQgb2YgZXhjaGFuZ2Ugb3JpZ2luYXRvciAqLworCXUzMiAgICAgICAgcmVzMjo4OworCXUzMiAgICAgICAgcmVzcF9pZDoyNDsJLyogTl9Qb3J0IGlkIG9mIGV4Y2hhbmdlIHJlc3BvbmRlciAqLworCXUzMiAgICAgICAgY291bnQ7CQkvKiBkYXRhIHRyYW5zZmVyIGNvdW50ICovCisJdTMyICAgICAgICBlX3N0YXQ7CQkvKiBleGNoYW5nZSBzdGF0dXMgKi8KK307CisKKy8qCisgKiBSU0kgZWxzIHBheWxvYWQKKyAqLworc3RydWN0IGZjX3JzaV9zIHsKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgIGVsc19jbWQ7CisJdTMyICAgICAgICByZXMxOjg7CisJdTMyICAgICAgICBvcmlnX3NpZDoyNDsKKwl1MzIgICAgICAgIG94aWQ6MTY7CisJdTMyICAgICAgICByeGlkOjE2OworfTsKKworLyoKKyAqIHN0cnVjdHVyZSBmb3IgUFJMSSBwYXJhbWF0ZXIgcGFnZXMsIGJvdGggcmVxdWVzdCAmIHJlc3BvbnNlCisgKiBzZWUgRkMtUEgtWCB0YWJsZSAxMTMgJiAxMTUgZm9yIGV4cGxhbmF0aW9uIGFsc28gRkNQIHRhYmxlIDgKKyAqLworc3RydWN0IGZjX3BybGlfcGFyYW1zX3N7CisJdTMyICAgICAgICByZXNlcnZlZDogMTY7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1MzIgICAgICAgIHJlc2VydmVkMTogNTsKKwl1MzIgICAgICAgIHJlY19zdXBwb3J0IDogMTsKKwl1MzIgICAgICAgIHRhc2tfcmV0cnlfaWQgOiAxOworCXUzMiAgICAgICAgcmV0cnkgOiAxOworCisJdTMyICAgICAgICBjb25maXJtIDogMTsKKwl1MzIgICAgICAgIGRvdmVybGF5OjE7CisJdTMyICAgICAgICBpbml0aWF0b3I6MTsKKwl1MzIgICAgICAgIHRhcmdldDoxOworCXUzMiAgICAgICAgY2RtaXg6MTsKKwl1MzIgICAgICAgIGRybWl4OjE7CisJdTMyICAgICAgICByeHJkaXNhYjoxOworCXUzMiAgICAgICAgd3hyZGlzYWI6MTsKKyNlbHNlCisJdTMyICAgICAgICByZXRyeSA6IDE7CisJdTMyICAgICAgICB0YXNrX3JldHJ5X2lkIDogMTsKKwl1MzIgICAgICAgIHJlY19zdXBwb3J0IDogMTsKKwl1MzIgICAgICAgIHJlc2VydmVkMTogNTsKKworCXUzMiAgICAgICAgd3hyZGlzYWI6MTsKKwl1MzIgICAgICAgIHJ4cmRpc2FiOjE7CisJdTMyICAgICAgICBkcm1peDoxOworCXUzMiAgICAgICAgY2RtaXg6MTsKKwl1MzIgICAgICAgIHRhcmdldDoxOworCXUzMiAgICAgICAgaW5pdGlhdG9yOjE7CisJdTMyICAgICAgICBkb3ZlcmxheToxOworCXUzMiAgICAgICAgY29uZmlybSA6IDE7CisjZW5kaWYKK307CisKKy8qCisgKiB2YWxpZCB2YWx1ZXMgZm9yIHJzcGNvZGUgaW4gUFJMSSBBQ0MgcGF5bG9hZAorICovCitlbnVtIHsKKwlGQ19QUkxJX0FDQ19YUVREID0gMHgxLAkJLyogcmVxdWVzdCBleGVjdXRlZCAqLworCUZDX1BSTElfQUNDX1BSRURFRl9JTUcgPSAweDUsCS8qIHByZWRlZmluZWQgaW1hZ2UgLSBubyBwcmxpIG5lZWRlZCAqLworfTsKKworc3RydWN0IGZjX3BybGlfcGFyYW1zX3BhZ2Vfc3sKKwl1MzIgICAgICAgIHR5cGU6ODsKKwl1MzIgICAgICAgIGNvZGV4dDo4OworI2lmZGVmIF9fQklHRU5ESUFOCisJdTMyICAgICAgICBvcmlncHJvY2FzdjoxOworCXUzMiAgICAgICAgcnNwcGF2OjE7CisJdTMyICAgICAgICBpbWFnZXBhaXI6MTsKKwl1MzIgICAgICAgIHJlc2VydmVkMToxOworCXUzMiAgICAgICAgcnNwY29kZTo0OworI2Vsc2UKKwl1MzIgICAgICAgIHJzcGNvZGU6NDsKKwl1MzIgICAgICAgIHJlc2VydmVkMToxOworCXUzMiAgICAgICAgaW1hZ2VwYWlyOjE7CisJdTMyICAgICAgICByc3BwYXY6MTsKKwl1MzIgICAgICAgIG9yaWdwcm9jYXN2OjE7CisjZW5kaWYKKwl1MzIgICAgICAgIHJlc2VydmVkMjo4OworCisJdTMyICAgICAgICBvcmlncHJvY2FzOworCXUzMiAgICAgICAgcnNwcHJvY2FzOworCXN0cnVjdCBmY19wcmxpX3BhcmFtc19zICBzZXJ2cGFyYW1zOworfTsKKworLyoKKyAqIFBSTEkgcmVxdWVzdCBhbmQgYWNjZXB0IHBheWxvYWQsIEZDLVBILVggdGFibGVzIDExMiAmIDExNAorICovCitzdHJ1Y3QgZmNfcHJsaV9zeworCXUzMiAgICAgICAgY29tbWFuZDo4OworCXUzMiAgICAgICAgcGdsZW46ODsKKwl1MzIgICAgICAgIHBhZ2VieXRlczoxNjsKKwlzdHJ1Y3QgZmNfcHJsaV9wYXJhbXNfcGFnZV9zIHBhcmFtcGFnZTsKK307CisKKy8qCisgKiBQUkxPIGxvZ291dCBwYXJhbXMgcGFnZQorICovCitzdHJ1Y3QgZmNfcHJsb19wYXJhbXNfcGFnZV9zeworCXUzMiAgICAgICAgdHlwZTo4OworCXUzMiAgICAgICAgdHlwZV9leHQ6ODsKKyNpZmRlZiBfX0JJR0VORElBTgorCXUzMiAgICAgICAgb3BhX3ZhbGlkOjE7CS8qIG9yaWdpbmF0b3IgcHJvY2VzcyBhc3NvY2lhdG9yCisJCQkJCSAqIHZhbGlkCisJCQkJCSAqLworCXUzMiAgICAgICAgcnBhX3ZhbGlkOjE7CS8qIHJlc3BvbmRlciBwcm9jZXNzIGFzc29jaWF0b3IgdmFsaWQgKi8KKwl1MzIgICAgICAgIHJlczE6MTQ7CisjZWxzZQorCXUzMiAgICAgICAgcmVzMToxNDsKKwl1MzIgICAgICAgIHJwYV92YWxpZDoxOwkvKiByZXNwb25kZXIgcHJvY2VzcyBhc3NvY2lhdG9yIHZhbGlkICovCisJdTMyICAgICAgICBvcGFfdmFsaWQ6MTsJLyogb3JpZ2luYXRvciBwcm9jZXNzIGFzc29jaWF0b3IKKwkJCQkJICogdmFsaWQKKwkJCQkJICovCisjZW5kaWYKKwl1MzIgICAgICAgIG9yaWdfcHJvY2Vzc19hc3NjOworCXUzMiAgICAgICAgcmVzcF9wcm9jZXNzX2Fzc2M7CisKKwl1MzIgICAgICAgIHJlczI7Cit9OworCisvKgorICogUFJMTyBlbHMgY29tbWFuZCBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY19wcmxvX3N7CisJdTMyICAgICAgICAJY29tbWFuZDo4OworCXUzMiAgICAgICAgCXBhZ2VfbGVuOjg7CisJdTMyICAgICAgICAJcGF5bG9hZF9sZW46MTY7CisJc3RydWN0IGZjX3BybG9fcGFyYW1zX3BhZ2VfcyAJcHJsb19wYXJhbXNbMV07Cit9OworCisvKgorICogUFJMTyBMb2dvdXQgcmVzcG9uc2UgcGFyYW1ldGVyIHBhZ2UKKyAqLworc3RydWN0IGZjX3BybG9fYWNjX3BhcmFtc19wYWdlX3N7CisJdTMyICAgICAgICB0eXBlOjg7CisJdTMyICAgICAgICB0eXBlX2V4dDo4OworCisjaWZkZWYgX19CSUdFTkRJQU4KKwl1MzIgICAgICAgIG9wYV92YWxpZDoxOwkvKiBvcmlnaW5hdG9yIHByb2Nlc3MgYXNzb2NpYXRvcgorCQkJCQkgKiB2YWxpZAorCQkJCQkgKi8KKwl1MzIgICAgICAgIHJwYV92YWxpZDoxOwkvKiByZXNwb25kZXIgcHJvY2VzcyBhc3NvY2lhdG9yIHZhbGlkICovCisJdTMyICAgICAgICByZXMxOjE0OworI2Vsc2UKKwl1MzIgICAgICAgIHJlczE6MTQ7CisJdTMyICAgICAgICBycGFfdmFsaWQ6MTsJLyogcmVzcG9uZGVyIHByb2Nlc3MgYXNzb2NpYXRvciB2YWxpZCAqLworCXUzMiAgICAgICAgb3BhX3ZhbGlkOjE7CS8qIG9yaWdpbmF0b3IgcHJvY2VzcyBhc3NvY2lhdG9yCisJCQkJCSAqIHZhbGlkCisJCQkJCSAqLworI2VuZGlmCisJdTMyICAgICAgICBvcmlnX3Byb2Nlc3NfYXNzYzsKKwl1MzIgICAgICAgIHJlc3BfcHJvY2Vzc19hc3NjOworCisJdTMyICAgICAgICBmYzR0eXBlX2NzcDsKK307CisKKy8qCisgKiBQUkxPIGVscyBjb21tYW5kIEFDQyBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY19wcmxvX2FjY19zeworCXUzMiAgICAgICAgY29tbWFuZDo4OworCXUzMiAgICAgICAgcGFnZV9sZW46ODsKKwl1MzIgICAgICAgIHBheWxvYWRfbGVuOjE2OworCXN0cnVjdCBmY19wcmxvX2FjY19wYXJhbXNfcGFnZV9zIHBybG9fYWNjX3BhcmFtc1sxXTsKK307CisKKy8qCisgKiBTQ1IgZWxzIGNvbW1hbmQgcGF5bG9hZAorICovCitlbnVtIHsKKwlGQ19TQ1JfUkVHX0ZVTkNfRkFCUklDX0RFVEVDVEVEID0gMHgwMSwKKwlGQ19TQ1JfUkVHX0ZVTkNfTl9QT1JUX0RFVEVDVEVEID0gMHgwMiwKKwlGQ19TQ1JfUkVHX0ZVTkNfRlVMTCA9IDB4MDMsCisJRkNfU0NSX1JFR19GVU5DX0NMRUFSX1JFRyA9IDB4RkYsCit9OworCisvKiBTQ1IgVlUgcmVnaXN0cmF0aW9ucyAqLworZW51bSB7CisJRkNfVlVfU0NSX1JFR19GVU5DX0ZBQlJJQ19OQU1FX0NIQU5HRSA9IDB4MDEKK307CisKK3N0cnVjdCBmY19zY3Jfc3sKKwl1MzIgY29tbWFuZDo4OworCXUzMiByZXM6MjQ7CisJdTMyIHZ1X3JlZ19mdW5jOjg7IC8qIFZlbmRvciBVbmlxdWUgUmVnaXN0cmF0aW9ucyAqLworCXUzMiByZXMxOjE2OworCXUzMiByZWdfZnVuYzo4OworfTsKKworLyoKKyAqIEluZm9ybWF0aW9uIGNhdGVnb3J5IGZvciBCYXNpYyBsaW5rIGRhdGEKKyAqLworZW51bSB7CisJRkNfQ0FUX05PUAk9IDB4MCwKKwlGQ19DQVRfQUJUUwk9IDB4MSwKKwlGQ19DQVRfUk1DCT0gMHgyLAorCUZDX0NBVF9CQV9BQ0MJPSAweDQsCisJRkNfQ0FUX0JBX1JKVAk9IDB4NSwKKwlGQ19DQVRfUFJNVAk9IDB4NiwKK307CisKKy8qCisgKiBMU19SSlQgZWxzIHJlcGx5IHBheWxvYWQKKyAqLworc3RydWN0IGZjX2xzX3JqdF9zIHsKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgIGVsc19jbWQ7CQkvKiBFTFMgY29tbWFuZCBjb2RlICovCisJdTMyICAgICAgICByZXMxOjg7CisJdTMyICAgICAgICByZWFzb25fY29kZTo4OwkJLyogUmVhc29uIGNvZGUgZm9yIHJlamVjdCAqLworCXUzMiAgICAgICAgcmVhc29uX2NvZGVfZXhwbDo4OwkvKiBSZWFzb24gY29kZSBleHBsYW5hdGlvbiAqLworCXUzMiAgICAgICAgdmVuZG9yX3VuaXF1ZTo4OwkvKiBWZW5kb3Igc3BlY2lmaWMgKi8KK307CisKKy8qCisgKiBMU19SSlQgcmVhc29uIGNvZGVzCisgKi8KK2VudW0geworCUZDX0xTX1JKVF9SU05fSU5WX0NNRF9DT0RFCT0gMHgwMSwKKwlGQ19MU19SSlRfUlNOX0xPR0lDQUxfRVJST1IJPSAweDAzLAorCUZDX0xTX1JKVF9SU05fTE9HSUNBTF9CVVNZCT0gMHgwNSwKKwlGQ19MU19SSlRfUlNOX1BST1RPQ09MX0VSUk9SCT0gMHgwNywKKwlGQ19MU19SSlRfUlNOX1VOQUJMRV9UT19QRVJGX0NNRCA9IDB4MDksCisJRkNfTFNfUkpUX1JTTl9DTURfTk9UX1NVUFAJPSAweDBCLAorfTsKKworLyoKKyAqIExTX1JKVCByZWFzb24gY29kZSBleHBsYW5hdGlvbgorICovCitlbnVtIHsKKwlGQ19MU19SSlRfRVhQX05PX0FERExfSU5GTwkJPSAweDAwLAorCUZDX0xTX1JKVF9FWFBfU1BBUk1TX0VSUl9PUFRJT05TCT0gMHgwMSwKKwlGQ19MU19SSlRfRVhQX1NQQVJNU19FUlJfSU5JX0NUTAk9IDB4MDMsCisJRkNfTFNfUkpUX0VYUF9TUEFSTVNfRVJSX1JFQ19DVEwJPSAweDA1LAorCUZDX0xTX1JKVF9FWFBfU1BBUk1TX0VSUl9SWFNaCQk9IDB4MDcsCisJRkNfTFNfUkpUX0VYUF9TUEFSTVNfRVJSX0NPTlNFUQkJPSAweDA5LAorCUZDX0xTX1JKVF9FWFBfU1BBUk1TX0VSUl9DUkVESVQJCT0gMHgwQiwKKwlGQ19MU19SSlRfRVhQX0lOVl9QT1JUX05BTUUJCT0gMHgwRCwKKwlGQ19MU19SSlRfRVhQX0lOVl9OT0RFX0ZBQlJJQ19OQU1FCT0gMHgwRSwKKwlGQ19MU19SSlRfRVhQX0lOVl9DU1AJCQk9IDB4MEYsCisJRkNfTFNfUkpUX0VYUF9JTlZfQVNTT0NfSERSCQk9IDB4MTEsCisJRkNfTFNfUkpUX0VYUF9BU1NPQ19IRFJfUkVRRAkJPSAweDEzLAorCUZDX0xTX1JKVF9FWFBfSU5WX09SSUdfU19JRAkJPSAweDE1LAorCUZDX0xTX1JKVF9FWFBfSU5WX09YSURfUlhJRF9DT01CCT0gMHgxNywKKwlGQ19MU19SSlRfRVhQX0NNRF9BTFJFQURZX0lOX1BST0cJPSAweDE5LAorCUZDX0xTX1JKVF9FWFBfTE9HSU5fUkVRVUlSRUQJCT0gMHgxRSwKKwlGQ19MU19SSlRfRVhQX0lOVkFMSURfTlBPUlRfSUQJCT0gMHgxRiwKKwlGQ19MU19SSlRfRVhQX0lOU1VGRl9SRVMJCT0gMHgyOSwKKwlGQ19MU19SSlRfRVhQX0NNRF9OT1RfU1VQUAkJPSAweDJDLAorCUZDX0xTX1JKVF9FWFBfSU5WX1BBWUxPQURfTEVOCQk9IDB4MkQsCit9OworCisvKgorICogUlJRIGVscyBjb21tYW5kIHBheWxvYWQKKyAqLworc3RydWN0IGZjX3JycV9zeworCXN0cnVjdCBmY19lbHNfY21kX3MgICAgZWxzX2NtZDsJLyogRUxTIGNvbW1hbmQgY29kZSAqLworCXUzMiAgICAgICAgcmVzMTo4OworCXUzMiAgICAgICAgc19pZDoyNDsJLyogZXhjaGFuZ2Ugb3JpZ2luYXRvciBTX0lEICovCisKKwl1MzIgICAgICAgIG94X2lkOjE2OwkvKiBvcmlnaW5hdG9yIGV4Y2hhbmdlIElEICovCisJdTMyICAgICAgICByeF9pZDoxNjsJLyogcmVzcG9uZGVyIGV4Y2hhbmdlIElEICovCisKKwl1MzIgICAgICAgIHJlczJbOF07CS8qIG9wdGlvbmFsIGFzc29jaWF0aW9uIGhlYWRlciAqLworfTsKKworLyoKKyAqIEFCVFMgQkFfQUNDIHJlcGx5IHBheWxvYWQKKyAqLworc3RydWN0IGZjX2JhX2FjY19zeworCXUzMiAgICAgICAgc2VxX2lkX3ZhbGlkOjg7CS8qIHNldCB0byAweDAwIGZvciBBYm9ydCBFeGNoYW5nZSAqLworCXUzMiAgICAgICAgc2VxX2lkOjg7CS8qIGludmFsaWQgZm9yIEFib3J0IEV4Y2hhbmdlICovCisJdTMyICAgICAgICByZXMyOjE2OworCXUzMiAgICAgICAgb3hfaWQ6MTY7CS8qIE9YX0lEIGZyb20gQUJUUyBmcmFtZSAqLworCXUzMiAgICAgICAgcnhfaWQ6MTY7CS8qIFJYX0lEIGZyb20gQUJUUyBmcmFtZSAqLworCXUzMiAgICAgICAgbG93X3NlcV9jbnQ6MTY7CS8qIHNldCB0byAweDAwMDAgZm9yIEFib3J0IEV4Y2hhbmdlICovCisJdTMyICAgICAgICBoaWdoX3NlcV9jbnQ6MTY7Lyogc2V0IHRvIDB4RkZGRiBmb3IgQWJvcnQgRXhjaGFuZ2UgKi8KK307CisKKy8qCisgKiBBQlRTIEJBX1JKVCByZWplY3QgcGF5bG9hZAorICovCitzdHJ1Y3QgZmNfYmFfcmp0X3N7CisJdTMyICAgICAgICByZXMxOjg7CQkvKiBSZXNlcnZlZCAqLworCXUzMiAgICAgICAgcmVhc29uX2NvZGU6ODsJLyogcmVhc29uIGNvZGUgZm9yIHJlamVjdCAqLworCXUzMiAgICAgICAgcmVhc29uX2V4cGw6ODsJLyogcmVhc29uIGNvZGUgZXhwbGFuYXRpb24gKi8KKwl1MzIgICAgICAgIHZlbmRvcl91bmlxdWU6ODsvKiB2ZW5kb3IgdW5pcXVlIHJlYXNvbiBjb2RlLHNldCB0byAwICovCit9OworCisvKgorICogVFBSTE8gbG9nb3V0IHBhcmFtZXRlciBwYWdlCisgKi8KK3N0cnVjdCBmY190cHJsb19wYXJhbXNfcGFnZV9zeworCXUzMiAgICAgICAgdHlwZTo4OworCXUzMiAgICAgICAgdHlwZV9leHQ6ODsKKworI2lmZGVmIF9fQklHRU5ESUFOCisJdTMyICAgICAgICBvcGFfdmFsaWQ6MTsKKwl1MzIgICAgICAgIHJwYV92YWxpZDoxOworCXUzMiAgICAgICAgdHBvX25wb3J0X3ZhbGlkOjE7CisJdTMyICAgICAgICBnbG9iYWxfcHJvY2Vzc19sb2dvdXQ6MTsKKwl1MzIgICAgICAgIHJlczE6MTI7CisjZWxzZQorCXUzMiAgICAgICAgcmVzMToxMjsKKwl1MzIgICAgICAgIGdsb2JhbF9wcm9jZXNzX2xvZ291dDoxOworCXUzMiAgICAgICAgdHBvX25wb3J0X3ZhbGlkOjE7CisJdTMyICAgICAgICBycGFfdmFsaWQ6MTsKKwl1MzIgICAgICAgIG9wYV92YWxpZDoxOworI2VuZGlmCisKKwl1MzIgICAgICAgIG9yaWdfcHJvY2Vzc19hc3NjOworCXUzMiAgICAgICAgcmVzcF9wcm9jZXNzX2Fzc2M7CisKKwl1MzIgICAgICAgIHJlczI6ODsKKwl1MzIgICAgICAgIHRwb19ucG9ydF9pZDsKK307CisKKy8qCisgKiBUUFJMTyBFTFMgY29tbWFuZCBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY190cHJsb19zeworCXUzMiAgICAgICAgY29tbWFuZDo4OworCXUzMiAgICAgICAgcGFnZV9sZW46ODsKKwl1MzIgICAgICAgIHBheWxvYWRfbGVuOjE2OworCisJc3RydWN0IGZjX3RwcmxvX3BhcmFtc19wYWdlX3MgdHBybG9fcGFyYW1zWzFdOworfTsKKworZW51bSBmY190cHJsb190eXBleworCUZDX0dMT0JBTF9MT0dPID0gMSwKKwlGQ19UUFJfTE9HTworfTsKKworLyoKKyAqIFRQUkxPIGVscyBjb21tYW5kIEFDQyBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY190cHJsb19hY2Nfc3sKKwl1MzIJY29tbWFuZDo4OworCXUzMglwYWdlX2xlbjo4OworCXUzMglwYXlsb2FkX2xlbjoxNjsKKwlzdHJ1Y3QgZmNfcHJsb19hY2NfcGFyYW1zX3BhZ2VfcyB0cHJsb19hY2NfcGFyYW1zWzFdOworfTsKKworLyoKKyAqIFJTQ04gZWxzIGNvbW1hbmQgcmVxIHBheWxvYWQKKyAqLworI2RlZmluZSBGQ19SU0NOX1BHTEVOCTB4NAorCitlbnVtIGZjX3JzY25fZm9ybWF0eworCUZDX1JTQ05fRk9STUFUX1BPUlRJRAk9IDB4MCwKKwlGQ19SU0NOX0ZPUk1BVF9BUkVBCT0gMHgxLAorCUZDX1JTQ05fRk9STUFUX0RPTUFJTgk9IDB4MiwKKwlGQ19SU0NOX0ZPUk1BVF9GQUJSSUMJPSAweDMsCit9OworCitzdHJ1Y3QgZmNfcnNjbl9ldmVudF9zeworCXUzMiAgICAgICAgZm9ybWF0OjI7CisJdTMyICAgICAgICBxdWFsaWZpZXI6NDsKKwl1MzIgICAgICAgIHJlc3ZkOjI7CisJdTMyICAgICAgICBwb3J0aWQ6MjQ7Cit9OworCitzdHJ1Y3QgZmNfcnNjbl9wbF9zeworCXU4ICAgICAgICAgY29tbWFuZDsKKwl1OCAgICAgICAgIHBhZ2VsZW47CisJdTE2ICAgICAgICBwYXlsZGxlbjsKKwlzdHJ1Y3QgZmNfcnNjbl9ldmVudF9zIGV2ZW50WzFdOworfTsKKworLyoKKyAqIEVDSE8gZWxzIGNvbW1hbmQgcmVxIHBheWxvYWQKKyAqLworc3RydWN0IGZjX2VjaG9fcyB7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICBlbHNfY21kOworfTsKKworLyoKKyAqIFJOSUQgZWxzIGNvbW1hbmQKKyAqLworCisjZGVmaW5lIFJOSURfTk9ERUlEX0RBVEFfRk9STUFUX0NPTU1PTiAgICAJCSAweDAwCisjZGVmaW5lIFJOSURfTk9ERUlEX0RBVEFfRk9STUFUX0ZDUDMgICAgICAgIAkJIDB4MDgKKyNkZWZpbmUgUk5JRF9OT0RFSURfREFUQV9GT1JNQVRfRElTQ09WRVJZICAgICAJCTB4REYKKworI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9VTktOT1dOICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDAxCisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX09USEVSICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfSFVCICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMworI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9TV0lUQ0ggICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDA0CisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX0dBVEVXQVkgICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDUKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfU1RPUkFHRV9ERVZJQ0UgICAgICAgICAgICAgMHgwMDAwMDAwOQorI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9IT1NUICAgICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDBBCisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX1NUT1JBR0VfU1VCU1lTVEVNICAgICAgICAgIDB4MDAwMDAwMEIKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfU1RPUkFHRV9BQ0NFU1NfREVWSUNFICAgICAgMHgwMDAwMDAwRQorI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9OQVNfU0VSVkVSICAgICAgICAgICAgICAgICAweDAwMDAwMDExCisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX0JSSURHRSAgICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfVklSVFVBTElaQVRJT05fREVWSUNFICAgICAgMHgwMDAwMDAwMworI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9NVUxUSV9GVU5DVElPTl9ERVZJQ0UgICAgICAweDAwMDAwMEZGCisKKy8qCisgKiBSTklEIGVscyBjb21tYW5kIHBheWxvYWQKKyAqLworc3RydWN0IGZjX3JuaWRfY21kX3N7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICBlbHNfY21kOworCXUzMiAgICAgICAgbm9kZV9pZF9kYXRhX2Zvcm1hdDo4OworCXUzMiAgICAgICAgcmVzZXJ2ZWQ6MjQ7Cit9OworCisvKgorICogUk5JRCBlbHMgcmVzcG9uc2UgcGF5bG9hZAorICovCisKK3N0cnVjdCBmY19ybmlkX2NvbW1vbl9pZF9kYXRhX3N7CisJd3duX3QgICAgICAgICAgIHBvcnRfbmFtZTsKKwl3d25fdCAgICAgICAgICAgbm9kZV9uYW1lOworfTsKKworc3RydWN0IGZjX3JuaWRfZ2VuZXJhbF90b3BvbG9neV9kYXRhX3N7CisJdTMyICAgICAgICB2ZW5kb3JfdW5pcXVlWzRdOworCXUzMiAgICAgICAgYXNzb190eXBlOworCXUzMiAgICAgICAgcGh5X3BvcnRfbnVtOworCXUzMiAgICAgICAgbnVtX2F0dGFjaGVkX25vZGVzOworCXUzMiAgICAgICAgbm9kZV9tZ210Ojg7CisJdTMyICAgICAgICBpcF92ZXJzaW9uOjg7CisJdTMyICAgICAgICB1ZHBfdGNwX3BvcnRfbnVtOjE2OworCXUzMiAgICAgICAgaXBfYWRkcmVzc1s0XTsKKwl1MzIgICAgICAgIHJlc2VydmVkOjE2OworCXUzMiAgICAgICAgdmVuZG9yX3NwZWNpZmljOjE2OworfTsKKworc3RydWN0IGZjX3JuaWRfYWNjX3N7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICBlbHNfY21kOworCXUzMiAgICAgICAgbm9kZV9pZF9kYXRhX2Zvcm1hdDo4OworCXUzMiAgICAgICAgY29tbW9uX2lkX2RhdGFfbGVuZ3RoOjg7CisJdTMyICAgICAgICByZXNlcnZlZDo4OworCXUzMiAgICAgICAgc3BlY2lmaWNfaWRfZGF0YV9sZW5ndGg6ODsKKwlzdHJ1Y3QgZmNfcm5pZF9jb21tb25faWRfZGF0YV9zIGNvbW1vbl9pZF9kYXRhOworCXN0cnVjdCBmY19ybmlkX2dlbmVyYWxfdG9wb2xvZ3lfZGF0YV9zIGdlbl90b3BvbG9neV9kYXRhOworfTsKKworI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9VTktOT1dOICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDAxCisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX09USEVSICAgICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfSFVCICAgICAgICAgICAgICAgICAgICAgICAgMHgwMDAwMDAwMworI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9TV0lUQ0ggICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDA0CisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX0dBVEVXQVkgICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDUKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfU1RPUkFHRV9ERVZJQ0UgICAgICAgICAgICAgMHgwMDAwMDAwOQorI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9IT1NUICAgICAgICAgICAgICAgICAgICAgICAweDAwMDAwMDBBCisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX1NUT1JBR0VfU1VCU1lTVEVNICAgICAgICAgIDB4MDAwMDAwMEIKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfU1RPUkFHRV9BQ0NFU1NfREVWSUNFICAgICAgMHgwMDAwMDAwRQorI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9OQVNfU0VSVkVSICAgICAgICAgICAgICAgICAweDAwMDAwMDExCisjZGVmaW5lIFJOSURfQVNTT0NJQVRFRF9UWVBFX0JSSURHRSAgICAgICAgICAgICAgICAgICAgIDB4MDAwMDAwMDIKKyNkZWZpbmUgUk5JRF9BU1NPQ0lBVEVEX1RZUEVfVklSVFVBTElaQVRJT05fREVWSUNFICAgICAgMHgwMDAwMDAwMworI2RlZmluZSBSTklEX0FTU09DSUFURURfVFlQRV9NVUxUSV9GVU5DVElPTl9ERVZJQ0UgICAgICAweDAwMDAwMEZGCisKK2VudW0gZmNfcnBzY19zcGVlZF9jYXB7CisJUlBTQ19TUEVFRF9DQVBfMUcgPSAweDgwMDAsCisJUlBTQ19TUEVFRF9DQVBfMkcgPSAweDQwMDAsCisJUlBTQ19TUEVFRF9DQVBfNEcgPSAweDIwMDAsCisJUlBTQ19TUEVFRF9DQVBfMTBHID0gMHgxMDAwLAorCVJQU0NfU1BFRURfQ0FQXzhHID0gMHgwODAwLAorCVJQU0NfU1BFRURfQ0FQXzE2RyA9IDB4MDQwMCwKKworCVJQU0NfU1BFRURfQ0FQX1VOS05PV04gPSAweDAwMDEsCit9OworCitlbnVtIGZjX3Jwc2Nfb3Bfc3BlZWRfc3sKKwlSUFNDX09QX1NQRUVEXzFHID0gMHg4MDAwLAorCVJQU0NfT1BfU1BFRURfMkcgPSAweDQwMDAsCisJUlBTQ19PUF9TUEVFRF80RyA9IDB4MjAwMCwKKwlSUFNDX09QX1NQRUVEXzEwRyA9IDB4MTAwMCwKKwlSUFNDX09QX1NQRUVEXzhHID0gMHgwODAwLAorCVJQU0NfT1BfU1BFRURfMTZHID0gMHgwNDAwLAorCisJUlBTQ19PUF9TUEVFRF9OT1RfRVNUID0gMHgwMDAxLAkvKiEgc3BlZWQgbm90IGVzdGFibGlzaGVkICovCit9OworCitzdHJ1Y3QgZmNfcnBzY19zcGVlZF9pbmZvX3N7CisJdTE2ICAgICAgICBwb3J0X3NwZWVkX2NhcDsJLyohIHNlZSBmY19ycHNjX3NwZWVkX2NhcF90ICovCisJdTE2ICAgICAgICBwb3J0X29wX3NwZWVkOwkvKiEgc2VlIGZjX3Jwc2Nfb3Bfc3BlZWRfdCAqLworfTsKKworZW51bSBsaW5rX2UyZV9iZWFjb25fc3ViY21keworCUxJTktfRTJFX0JFQUNPTl9PTiA9IDEsCisJTElOS19FMkVfQkVBQ09OX09GRiA9IDIKK307CisKK2VudW0gYmVhY29uX3R5cGV7CisJQkVBQ09OX1RZUEVfTk9STUFMCT0gMSwJLyohIE5vcm1hbCBCZWFjb25pbmcuIEdyZWVuICovCisJQkVBQ09OX1RZUEVfV0FSTgk9IDIsCS8qISBXYXJuaW5nIEJlYWNvbmluZy4gWWVsbG93L0FtYmVyICovCisJQkVBQ09OX1RZUEVfQ1JJVElDQUwJPSAzCS8qISBDcml0aWNhbCBCZWFjb25pbmcuIFJlZCAqLworfTsKKworc3RydWN0IGxpbmtfZTJlX2JlYWNvbl9wYXJhbV9zIHsKKwl1OCAgICAgICAgIGJlYWNvbl90eXBlOwkvKiBCZWFjb24gVHlwZS4gU2VlIGJlYWNvbl90eXBlX3QgKi8KKwl1OCAgICAgICAgIGJlYWNvbl9mcmVxdWVuY3k7CisJCQkJCS8qIEJlYWNvbiBmcmVxdWVuY3kuIE51bWJlciBvZiBibGlua3MKKwkJCQkJICogcGVyIDEwIHNlY29uZHMKKwkJCQkJICovCisJdTE2ICAgICAgICBiZWFjb25fZHVyYXRpb247LyogQmVhY29uIGR1cmF0aW9uIChpbiBTZWNvbmRzKS4gVGhlCisJCQkJCSAqIGNvbW1hbmQgb3BlcmF0aW9uIHNob3VsZCBiZQorCQkJCQkgKiB0ZXJtaW5hdGVkIGF0IHRoZSBlbmQgb2YgdGhpcworCQkJCQkgKiB0aW1lb3V0IHZhbHVlLgorCQkJCQkgKgorCQkJCQkgKiBJZ25vcmVkIGlmIGRpYWdfc3ViX2NtZCBpcworCQkJCQkgKiBMSU5LX0UyRV9CRUFDT05fT0ZGLgorCQkJCQkgKgorCQkJCQkgKiBJZiAwLCBiZWFjb25pbmcgd2lsbCBjb250aW51ZSB0aWxsIGEKKwkJCQkJICogQkVBQ09OIE9GRiByZXF1ZXN0IGlzIHJlY2VpdmVkCisJCQkJCSAqLworfTsKKworLyoKKyAqIExpbmsgRTJFIGJlYWNvbiByZXF1ZXN0L2dvb2QgcmVzcG9uc2UgZm9ybWF0LiBGb3IgTFNfUkpUcyB1c2UgZmNfbHNfcmp0X3QKKyAqLworc3RydWN0IGxpbmtfZTJlX2JlYWNvbl9yZXFfc3sKKwl1MzIgICAgICAgIGxzX2NvZGU7CS8qISBGQ19FTFNfRTJFX0xCRUFDT04gaW4gcmVxdWVzdHMgKgorCQkJCQkgKm9yIEZDX0VMU19BQ0MgaW4gZ29vZCByZXBsaWVzICovCisJdTMyICAgICAgICBsc19zdWJfY21kOwkvKiEgU2VlIGxpbmtfZTJlX2JlYWNvbl9zdWJjbWRfdCAqLworCXN0cnVjdCBsaW5rX2UyZV9iZWFjb25fcGFyYW1fcyBiZWFjb25fcGFybTsKK307CisKKy8qKgorICogSWYgUlBTQyByZXF1ZXN0IGlzIHNlbnQgdG8gdGhlIERvbWFpbiBDb250cm9sbGVyLCB0aGUgcmVxdWVzdCBpcyBmb3IKKyAqIGFsbCB0aGUgcG9ydHMgd2l0aGluIHRoYXQgZG9tYWluIChUT0RPIC0gSSBkb24ndCB0aGluayBGT1MgaW1wbGVtZW50cworICogdGhpcy4uLikuCisgKi8KK3N0cnVjdCBmY19ycHNjX2NtZF9zeworCXN0cnVjdCBmY19lbHNfY21kX3MgICAgZWxzX2NtZDsKK307CisKKy8qCisgKiBSUFNDIEFjYworICovCitzdHJ1Y3QgZmNfcnBzY19hY2Nfc3sKKwl1MzIgICAgICAgIGNvbW1hbmQ6ODsKKwl1MzIgICAgICAgIHJzdmQ6ODsKKwl1MzIgICAgICAgIG51bV9lbnRyaWVzOjE2OworCisJc3RydWN0IGZjX3Jwc2Nfc3BlZWRfaW5mb19zIHNwZWVkX2luZm9bMV07Cit9OworCisvKioKKyAqIElmIFJQU0MyIHJlcXVlc3QgaXMgc2VudCB0byB0aGUgRG9tYWluIENvbnRyb2xsZXIsCisgKi8KKyNkZWZpbmUgRkNfQlJDRF9UT0tFTiAgICAweDQyNTI0MzQ0CisKK3N0cnVjdCBmY19ycHNjMl9jbWRfc3sKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgIGVsc19jbWQ7CisJdTMyICAgICAgIAl0b2tlbjsKKwl1MTYgICAgIAlyZXN2ZDsKKwl1MTYgICAgIAludW1fcGlkczsgICAgICAgLyogTnVtYmVyIG9mIHBpZHMgaW4gdGhlIHJlcXVlc3QgKi8KKwlzdHJ1Y3QgIHsKKwkJdTMyCXJzdmQxOjg7CisJCXUzMglwaWQ6MjQ7CS8qIHBvcnQgaWRlbnRpZmllciAqLworCX0gcGlkX2xpc3RbMV07Cit9OworCitlbnVtIGZjX3Jwc2MyX3BvcnRfdHlwZXsKKwlSUFNDMl9QT1JUX1RZUEVfVU5LTk9XTiA9IDAsCisJUlBTQzJfUE9SVF9UWVBFX05QT1JUICAgPSAxLAorCVJQU0MyX1BPUlRfVFlQRV9OTFBPUlQgID0gMiwKKwlSUFNDMl9QT1JUX1RZUEVfTlBJVl9QT1JUICA9IDB4NWYsCisJUlBTQzJfUE9SVF9UWVBFX05QT1JUX1RSVU5LICA9IDB4NmYsCit9OworCisvKgorICogUlBTQzIgcG9ydEluZm8gZW50cnkgc3RydWN0dXJlCisgKi8KK3N0cnVjdCBmY19ycHNjMl9wb3J0X2luZm9fc3sKKyAgICB1MzIgICAgcGlkOyAgICAgICAgLyogUElEICovCisgICAgdTE2ICAgIHJlc3ZkMTsKKyAgICB1MTYgICAgaW5kZXg7ICAgICAgLyogcG9ydCBudW1iZXIgLyBpbmRleCAqLworICAgIHU4ICAgICByZXN2ZDI7CisgICAgdTggICAgCXR5cGU7ICAgICAgICAvKiBwb3J0IHR5cGUgTi9OTC8uLi4gKi8KKyAgICB1MTYgICAgc3BlZWQ7ICAgICAgLyogcG9ydCBPcGVyYXRpbmcgU3BlZWQgKi8KK307CisKKy8qCisgKiBSUFNDMiBBY2NlcHQgcGF5bG9hZAorICovCitzdHJ1Y3QgZmNfcnBzYzJfYWNjX3N7CisJdTggICAgICAgIGVsc19jbWQ7CisJdTggICAgICAgIHJlc3ZkOworCXUxNiAgICAgICBudW1fcGlkczsgIC8qIE51bWJlciBvZiBwaWRzIGluIHRoZSByZXF1ZXN0ICovCisJc3RydWN0IGZjX3Jwc2MyX3BvcnRfaW5mb19zICBwb3J0X2luZm9bMV07ICAgIC8qIHBvcnQgaW5mb3JtYXRpb24gKi8KK307CisKKy8qKgorICogYml0IGZpZWxkcyBzbyB0aGF0IG11bHRpcGxlIGNsYXNzZXMgY2FuIGJlIHNwZWNpZmllZAorICovCitlbnVtIGZjX2Nvc3sKKwlGQ19DTEFTU18yCT0gMHgwNCwKKwlGQ19DTEFTU18zCT0gMHgwOCwKKwlGQ19DTEFTU18yXzMJPSAweDBDLAorfTsKKworLyoKKyAqIHN5bWJvbGljIG5hbWUKKyAqLworc3RydWN0IGZjX3N5bW5hbWVfc3sKKwl1OCAgICAgICAgIHN5bW5hbWVbRkNfU1lNTkFNRV9NQVhdOworfTsKKworc3RydWN0IGZjX2FscGFibV9zeworCXU4ICAgICAgICAgYWxwYV9ibVtGQ19BTFBBX01BWCAvIDhdOworfTsKKworLyoKKyAqIHByb3RvY29sIGRlZmF1bHQgdGltZW91dCB2YWx1ZXMKKyAqLworI2RlZmluZSBGQ19FRF9UT1YJCTIKKyNkZWZpbmUgRkNfUkVDX1RPVgkJKEZDX0VEX1RPViArIDEpCisjZGVmaW5lIEZDX1JBX1RPVgkJMTAKKyNkZWZpbmUgRkNfRUxTX1RPVgkJKDIgKiBGQ19SQV9UT1YpCisKKy8qCisgKiB2aXJ0dWFsIGZhYnJpYyByZWxhdGVkIGRlZmluZXMKKyAqLworI2RlZmluZSBGQ19WRl9JRF9OVUxMICAgIDAJLyogIG11c3Qgbm90IGJlIHVzZWQgYXMgVkZfSUQgKi8KKyNkZWZpbmUgRkNfVkZfSURfTUlOICAgICAxCisjZGVmaW5lIEZDX1ZGX0lEX01BWCAgICAgMHhFRkYKKyNkZWZpbmUgRkNfVkZfSURfQ1RMICAgICAweEZFRgkvKiAgY29udHJvbCBWRl9JRCAqLworCisvKioKKyAqIFZpcnR1YWwgRmFicmljIFRhZ2dpbmcgaGVhZGVyIGZvcm1hdAorICogQGNhdXRpb24gVGhpcyBpcyBkZWZpbmVkIG9ubHkgaW4gQklHIEVORElBTiBmb3JtYXQuCisgKi8KK3N0cnVjdCBmY192ZnRfc3sKKwl1MzIgICAgICAgIHJfY3RsOjg7CisJdTMyICAgICAgICB2ZXI6MjsKKwl1MzIgICAgICAgIHR5cGU6NDsKKwl1MzIgICAgICAgIHJlc19hOjI7CisJdTMyICAgICAgICBwcmlvcml0eTozOworCXUzMiAgICAgICAgdmZfaWQ6MTI7CisJdTMyICAgICAgICByZXNfYjoxOworCXUzMiAgICAgICAgaG9wY3Q6ODsKKwl1MzIgICAgICAgIHJlc19jOjI0OworfTsKKworI3ByYWdtYSBwYWNrKCkKKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvcHJvdG9jb2wvZmNfc3AuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9mY19zcC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU1YmIwYjMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvcHJvdG9jb2wvZmNfc3AuaApAQCAtMCwwICsxLDIyNCBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fRkNfU1BfSF9fCisjZGVmaW5lIF9fRkNfU1BfSF9fCisKKyNpbmNsdWRlIDxwcm90b2NvbC90eXBlcy5oPgorCisjcHJhZ21hIHBhY2soMSkKKworZW51bSBhdXRoX2Vsc19mbGFnc3sKKwlGQ19BVVRIX0VMU19NT1JFX0ZSQUdTX0ZMQUcgCT0gMHg4MCwJLyohIGJpdC03LiBNb3JlIEZyYWdtZW50cworCQkJCQkJICogRm9sbG93CisJCQkJCQkgKi8KKwlGQ19BVVRIX0VMU19DT05DQVRfRkxBRyAJPSAweDQwLAkvKiEgYml0LTYuIENvbmNhdGVuYXRpb24gRmxhZyAqLworCUZDX0FVVEhfRUxTX1NFUV9OVU1fRkxBRyAJPSAweDAxIAkvKiEgYml0LTAuIFNlcXVlbmNlIE51bWJlciAqLworfTsKKworZW51bSBhdXRoX21zZ19jb2Rlc3sKKwlGQ19BVVRIX01DX0FVVEhfUkpUCQk9IDB4MEEsCS8qISBBdXRoIFJlamVjdCAqLworCUZDX0FVVEhfTUNfQVVUSF9ORUcgCQk9IDB4MEIsIC8qISBBdXRoIE5lZ290aWF0ZSAqLworCUZDX0FVVEhfTUNfQVVUSF9ET05FIAkJPSAweDBDLCAvKiEgQXV0aCBEb25lICovCisKKwlGQ19BVVRIX01DX0RIQ0hBUF9DSEFMIAkJPSAweDEwLCAvKiEgREhDSEFQIENoYWxsZW5nZSAqLworCUZDX0FVVEhfTUNfREhDSEFQX1JFUExZIAk9IDB4MTEsIC8qISBESENIQVAgUmVwbHkgKi8KKwlGQ19BVVRIX01DX0RIQ0hBUF9TVUNDIAkJPSAweDEyLCAvKiEgREhDSEFQIFN1Y2Nlc3MgKi8KKworCUZDX0FVVEhfTUNfRkNBUF9SRVEgCQk9IDB4MTMsIC8qISBGQ0FQIFJlcXVlc3QgKi8KKwlGQ19BVVRIX01DX0ZDQVBfQUNLIAkJPSAweDE0LCAvKiEgRkNBUCBBY2tub3dsZWRnZSAqLworCUZDX0FVVEhfTUNfRkNBUF9DT05GIAkJPSAweDE1LCAvKiEgRkNBUCBDb25maXJtICovCisKKwlGQ19BVVRIX01DX0ZDUEFQX0lOSVQgCQk9IDB4MTYsIC8qISBGQ1BBUCBJbml0ICovCisJRkNfQVVUSF9NQ19GQ1BBUF9BQ0MgCQk9IDB4MTcsIC8qISBGQ1BBUCBBY2NlcHQgKi8KKwlGQ19BVVRIX01DX0ZDUEFQX0NPTVAgCQk9IDB4MTgsIC8qISBGQ1BBUCBDb21wbGV0ZSAqLworCisJRkNfQVVUSF9NQ19JS0VfU0FfSU5JVCAJCT0gMHgyMiwgLyohIElLRSBTQSBJTklUICovCisJRkNfQVVUSF9NQ19JS0VfU0FfQVVUSCAJCT0gMHgyMywgLyohIElLRSBTQSBBdXRoICovCisJRkNfQVVUSF9NQ19JS0VfQ1JFQVRFX0NISUxEX1NBCT0gMHgyNCwgLyohIElLRSBDcmVhdGUgQ2hpbGQgU0EgKi8KKwlGQ19BVVRIX01DX0lLRV9JTkZPIAkJPSAweDI1LCAvKiEgSUtFIGluZm9ybWF0aW9uYWwgKi8KK307CisKK2VudW0gYXV0aF9wcm90b192ZXJzaW9ueworCUZDX0FVVEhfUFJPVE9fVkVSXzEgCT0gMSwJLyohIFByb3RvY29sIFZlcnNpb24gMSAqLworfTsKKworZW51bSB7CisJRkNfQVVUSF9FTFNfQ09NTUFORF9DT0RFID0gMHg5MCwvKiEgQXV0aGVudGljYXRpb24gRUxTIENvbW1hbmQgY29kZSAgKi8KKwlGQ19BVVRIX1BST1RPX1BBUkFNX0xFTl9TWiA9IDQsCS8qISBTaXplIG9mIFByb3RvIFBhcmFtZXRlciBMZW4gRmllbGQgKi8KKwlGQ19BVVRIX1BST1RPX1BBUkFNX1ZBTF9TWiA9IDQsCS8qISBTaXplIG9mIFByb3RvIFBhcmFtZXRlciBWYWwgRmllbGQgKi8KKwlGQ19NQVhfQVVUSF9TRUNSRVRfTEVOICAgICA9IDI1NiwKKwkJCQkJLyohIE1heGltdW0gc2VjcmV0IHN0cmluZyBsZW5ndGggKi8KKwlGQ19BVVRIX05VTV9VU0FCTEVfUFJPVE9fTEVOX1NaID0gNCwKKwkJCQkJLyohIFNpemUgb2YgdXNhYmxlIHByb3RvY29scyBmaWVsZCAqLworCUZDX0FVVEhfUkVTUF9WQUxVRV9MRU5fU1oJPSA0LAorCQkJCQkvKiEgU2l6ZSBvZiByZXNwb25zZSB2YWx1ZSBsZW5ndGggKi8KKwlGQ19NQVhfQ0hBUF9LRVlfTEVOCT0gMjU2LAkvKiEgTWF4aW11bSBtZDUgZGlnZXN0IGxlbmd0aCAqLworCUZDX01BWF9BVVRIX1JFVFJJRVMgICAgID0gMywJLyohIE1heGltdW0gbnVtYmVyIG9mIHJldHJpZXMgKi8KKwlGQ19NRDVfRElHRVNUX0xFTiAgICAgICA9IDE2LAkvKiEgTUQ1IGRpZ2VzdCBsZW5ndGggKi8KKwlGQ19TSEExX0RJR0VTVF9MRU4gICAgICA9IDIwLAkvKiEgU0hBMSBkaWdlc3QgbGVuZ3RoICovCisJRkNfTUFYX0RIR19TVVBQT1JURUQgICAgPSAxLAkvKiEgTWF4aW11bSBESCBHcm91cHMgc3VwcG9ydGVkICovCisJRkNfTUFYX0FMR19TVVBQT1JURUQgICAgPSAxLAkvKiEgTWF4aW11bSBhbGdvcml0aG1zIHN1cHBvcnRlZCAqLworCUZDX01BWF9QUk9UT19TVVBQT1JURUQgID0gMSwJLyohIE1heGltdW0gcHJvdG9jb2xzIHN1cHBvcnRlZCAqLworCUZDX1NUQVJUX1RYTl9JRCAgICAgICAgID0gMiwJLyohIFN0YXJ0aW5nIHRyYW5zYWN0aW9uIElEICovCit9OworCitlbnVtIGF1dGhfcHJvdG9faWR7CisJRkNfQVVUSF9QUk9UT19ESENIQVAJCT0gMHgwMDAwMDAwMSwKKwlGQ19BVVRIX1BST1RPX0ZDQVAgCQk9IDB4MDAwMDAwMDIsCisJRkNfQVVUSF9QUk9UT19GQ1BBUCAJCT0gMHgwMDAwMDAwMywKKwlGQ19BVVRIX1BST1RPX0lLRXYyIAkJPSAweDAwMDAwMDA0LAorCUZDX0FVVEhfUFJPVE9fSUtFdjJfQVVUSCAJPSAweDAwMDAwMDA1LAorfTsKKworc3RydWN0IGF1dGhfbmFtZV9zeworCXUxNgluYW1lX3RhZzsJLyohIE5hbWUgVGFnID0gMSBmb3IgQXV0aGVudGljYXRpb24gKi8KKwl1MTYJbmFtZV9sZW47CS8qISBOYW1lIExlbmd0aCA9IDggZm9yIEF1dGhlbnRpY2F0aW9uCisJCQkJCSAqLworCXd3bl90CQluYW1lOyAgCQkvKiEgTmFtZS4gVE9ETyAtIGlzIHRoaXMgUFdXTiAqLworfTsKKworCitlbnVtIGF1dGhfaGFzaF9mdW5jeworCUZDX0FVVEhfSEFTSF9GVU5DX01ENSAJCT0gMHgwMDAwMDAwNSwKKwlGQ19BVVRIX0hBU0hfRlVOQ19TSEFfMSAJPSAweDAwMDAwMDA2LAorfTsKKworZW51bSBhdXRoX2RoX2dpZHsKKwlGQ19BVVRIX0RIX0dJRF8wX0RIR19OVUxMCT0gMHgwMDAwMDAwMCwKKwlGQ19BVVRIX0RIX0dJRF8xX0RIR18xMDI0CT0gMHgwMDAwMDAwMSwKKwlGQ19BVVRIX0RIX0dJRF8yX0RIR18xMjgwCT0gMHgwMDAwMDAwMiwKKwlGQ19BVVRIX0RIX0dJRF8zX0RIR18xNTM2CT0gMHgwMDAwMDAwMywKKwlGQ19BVVRIX0RIX0dJRF80X0RIR18yMDQ4CT0gMHgwMDAwMDAwNCwKKwlGQ19BVVRIX0RIX0dJRF82X0RIR18zMDcyCT0gMHgwMDAwMDAwNiwKKwlGQ19BVVRIX0RIX0dJRF83X0RIR180MDk2CT0gMHgwMDAwMDAwNywKKwlGQ19BVVRIX0RIX0dJRF84X0RIR182MTQ0CT0gMHgwMDAwMDAwOCwKKwlGQ19BVVRIX0RIX0dJRF85X0RIR184MTkyCT0gMHgwMDAwMDAwOSwKK307CisKK3N0cnVjdCBhdXRoX2Vsc19tc2dfcyB7CisJdTgJCWF1dGhfZWxzX2NvZGU7CS8qICBBdXRoZW50aWNhdGlvbiBFTFMgQ29kZSAoMHg5MCkgKi8KKwl1OCAJYXV0aF9lbHNfZmxhZzsgCS8qICBBdXRoZW50aWNhdGlvbiBFTFMgRmxhZ3MgKi8KKwl1OCAJYXV0aF9tc2dfY29kZTsgCS8qICBBdXRoZW50aWNhdGlvbiBNZXNzYWdlIENvZGUgKi8KKwl1OCAJcHJvdG9fdmVyc2lvbjsgCS8qICBQcm90b2NvbCBWZXJzaW9uICovCisJdTMyCW1zZ19sZW47IAkvKiAgTWVzc2FnZSBMZW5ndGggKi8KKwl1MzIJdHJhbnNfaWQ7IAkvKiAgVHJhbnNhY3Rpb24gSWRlbnRpZmllciAoVF9JRCkgKi8KKworCS8qIE1zZyBwYXlsb2FkIGZvbGxvd3MuLi4gKi8KK307CisKKworZW51bSBhdXRoX25lZ19wYXJhbV90YWdzIHsKKwlGQ19BVVRIX05FR19ESENIQVBfSEFTSExJU1QgCT0gMHgwMDAxLAorCUZDX0FVVEhfTkVHX0RIQ0hBUF9ESEdfSURfTElTVCAJPSAweDAwMDIsCit9OworCisKK3N0cnVjdCBkaGNoYXBfcGFyYW1fZm9ybWF0X3MgeworCXUxNgl0YWc7CQkvKiEgUGFyYW1ldGVyIFRhZy4gU2VlCisJCQkJCSAqIGF1dGhfbmVnX3BhcmFtX3RhZ3NfdAorCQkJCQkgKi8KKwl1MTYJd29yZF9jbnQ7CisKKwkvKiBmb2xsb3dlZCBieSB2YXJpYWJsZSBsZW5ndGggcGFyYW1ldGVyIHZhbHVlLi4uICovCit9OworCitzdHJ1Y3QgYXV0aF9wcm90b19wYXJhbXNfcyB7CisJdTMyCXByb3RvX3BhcmFtX2xlbjsKKwl1MzIJcHJvdG9faWQ7CisKKwkvKgorCSAqIEZvbGxvd2VkIGJ5IHZhcmlhYmxlIGxlbmd0aCBQcm90b2NvbCBzcGVjaWZpYyBwYXJhbWV0ZXJzLiBESC1DSEFQCisJICogdXNlcyBkaGNoYXBfcGFyYW1fZm9ybWF0X3QKKwkgKi8KK307CisKK3N0cnVjdCBhdXRoX25lZ19tc2dfcyB7CisJc3RydWN0IGF1dGhfbmFtZV9zCWF1dGhfaW5pX25hbWU7CisJdTMyCQl1c2FibGVfYXV0aF9wcm90b3M7CisJc3RydWN0IGF1dGhfcHJvdG9fcGFyYW1zX3MgcHJvdG9fcGFyYW1zWzFdOyAvKiEgKDEuLnVzYWJsZV9hdXRoX3Byb3RvKQorCQkJCQkJICAgICAqIHByb3RvY29sIHBhcmFtcworCQkJCQkJICAgICAqLworfTsKKworc3RydWN0IGF1dGhfZGhfdmFsX3MgeworCXUzMiBkaF92YWxfbGVuOworCXUzMiBkaF92YWxbMV07Cit9OworCitzdHJ1Y3QgYXV0aF9kaGNoYXBfY2hhbF9tc2dfcyB7CisJc3RydWN0IGF1dGhfZWxzX21zZ19zCWhkcjsKKwlzdHJ1Y3QgYXV0aF9uYW1lX3MgYXV0aF9yZXNwb25kZXJfbmFtZTsJLyogVE9ETyBWUksgLSBpcyBhdXRoX25hbWVfdAorCQkJCQkJICogdHlwZSBPSz8KKwkJCQkJCSAqLworCXUzMiAJaGFzaF9pZDsKKwl1MzIgCWRoX2dycF9pZDsKKwl1MzIgCWNoYWxfdmFsX2xlbjsKKwljaGFyCQljaGFsX3ZhbFsxXTsKKworCS8qIC4uLmZvbGxvd2VkIGJ5IHZhcmlhYmxlIENoYWxsZW5nZSBsZW5ndGgvdmFsdWUgYW5kIERIIGxlbmd0aC92YWx1ZSAqLworfTsKKworCitlbnVtIGF1dGhfcmp0X2NvZGVzIHsKKwlGQ19BVVRIX1JKVF9DT0RFX0FVVEhfRkFJTFVSRSAJPSAweDAxLAorCUZDX0FVVEhfUkpUX0NPREVfTE9HSUNBTF9FUlIJPSAweDAyLAorfTsKKworZW51bSBhdXRoX3JqdF9jb2RlX2V4cHMgeworCUZDX0FVVEhfQ0VYUF9BVVRIX01FQ0hfTk9UX1VTQUJMRQk9IDB4MDEsCisJRkNfQVVUSF9DRVhQX0RIX0dST1VQX05PVF9VU0FCTEUgCT0gMHgwMiwKKwlGQ19BVVRIX0NFWFBfSEFTSF9GVU5DX05PVF9VU0FCTEUgCT0gMHgwMywKKwlGQ19BVVRIX0NFWFBfQVVUSF9YQUNUX1NUQVJURUQJCT0gMHgwNCwKKwlGQ19BVVRIX0NFWFBfQVVUSF9GQUlMRUQgCQk9IDB4MDUsCisJRkNfQVVUSF9DRVhQX0lOQ09SUkVDVF9QTEQgCQk9IDB4MDYsCisJRkNfQVVUSF9DRVhQX0lOQ09SUkVDVF9QUk9UT19NU0cgCT0gMHgwNywKKwlGQ19BVVRIX0NFWFBfUkVTVEFSVF9BVVRIX1BST1RPIAk9IDB4MDgsCisJRkNfQVVUSF9DRVhQX0FVVEhfQ09OQ0FUX05PVF9TVVBQIAk9IDB4MDksCisJRkNfQVVUSF9DRVhQX1BST1RPX1ZFUl9OT1RfU1VQUCAJPSAweDBBLAorfTsKKworZW51bSBhdXRoX3N0YXR1cyB7CisJRkNfQVVUSF9TVEFURV9JTlBST0dSRVNTID0gMCwgCS8qISBhdXRoZW50aWNhdGlvbiBpbiBwcm9ncmVzcyAJKi8KKwlGQ19BVVRIX1NUQVRFX0ZBSUxFRAk9IDEsIAkvKiEgYXV0aGVudGljYXRpb24gZmFpbGVkICovCisJRkNfQVVUSF9TVEFURV9TVUNDRVNTCT0gMiAJLyohIGF1dGhlbnRpY2F0aW9uIHN1Y2Nlc3NmdWwJKi8KK307CisKK3N0cnVjdCBhdXRoX3JqdF9tc2dfcyB7CisJc3RydWN0IGF1dGhfZWxzX21zZ19zCWhkcjsKKwl1OAkJcmVhc29uX2NvZGU7CisJdTgJCXJlYXNvbl9jb2RlX2V4cDsKKwl1OAkJcnN2ZFsyXTsKK307CisKKworc3RydWN0IGF1dGhfZGhjaGFwX25lZ19tc2dfcyB7CisJc3RydWN0IGF1dGhfZWxzX21zZ19zIGhkcjsKKwlzdHJ1Y3QgYXV0aF9uZWdfbXNnX3MgbmVnbzsKK307CisKK3N0cnVjdCBhdXRoX2RoY2hhcF9yZXBseV9tc2dfcyB7CisJc3RydWN0IGF1dGhfZWxzX21zZ19zCWhkcjsKKworCS8qCisJICogZm9sbG93ZWQgYnkgcmVzcG9uc2UgdmFsdWUgbGVuZ3RoICYgVmFsdWUgKyBESCBWYWx1ZSBMZW5ndGggJiBWYWx1ZQorCSAqLworfTsKKworI3ByYWdtYSBwYWNrKCkKKworI2VuZGlmIC8qIF9fRkNfU1BfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvcHJvdG9jb2wvZmNwLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvcHJvdG9jb2wvZmNwLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWFkZTY4YQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9mY3AuaApAQCAtMCwwICsxLDE4NiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisjaWZuZGVmIF9fRkNQUFJPVE9fSF9fCisjZGVmaW5lIF9fRkNQUFJPVE9fSF9fCisKKyNpbmNsdWRlIDxwcm90b2NvbC9zY3NpLmg+CisKKyNwcmFnbWEgcGFjaygxKQorCitlbnVtIHsKKwlGQ1BfUkpUCQk9IDB4MDEwMDAwMDAsCS8qIFNSUiByZWplY3QgKi8KKwlGQ1BfU1JSX0FDQ0VQVAk9IDB4MDIwMDAwMDAsCS8qIFNSUiBhY2NlcHQgKi8KKwlGQ1BfU1JSCQk9IDB4MTQwMDAwMDAsCS8qIFNlcXVlbmNlIFJldHJhbnNtaXNzaW9uIFJlcXVlc3QgKi8KK307CisKKy8qCisgKiBTUlIgRkMtNCBMUyBwYXlsb2FkCisgKi8KK3N0cnVjdCBmY19zcnJfc3sKKwl1MzIJbHNfY21kOworCXUzMiAgICAgICAgb3hfaWQ6MTY7CS8qIG94LWlkICovCisJdTMyICAgICAgICByeF9pZDoxNjsJLyogcngtaWQgKi8KKwl1MzIgICAgICAgIHJvOwkJLyogcmVsYXRpdmUgb2Zmc2V0ICovCisJdTMyICAgICAgICByX2N0bDo4OwkJLyogUl9DVEwgZm9yIEkuVS4gKi8KKwl1MzIgICAgICAgIHJlczoyNDsKK307CisKKworLyoKKyAqIEZDUF9DTU5EIGRlZmluaXRpb25zCisgKi8KKyNkZWZpbmUgRkNQX0NNTkRfQ0RCX0xFTiAgICAxNgorI2RlZmluZSBGQ1BfQ01ORF9MVU5fTEVOICAgIDgKKworc3RydWN0IGZjcF9jbW5kX3N7CisJbHVuX3QgICAgICAgICAgIGx1bjsJCS8qIDY0LWJpdCBMVSBudW1iZXIgKi8KKwl1OCAgICAgICAgIGNybjsJCS8qIGNvbW1hbmQgcmVmZXJlbmNlIG51bWJlciAqLworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICByZXN2ZDoxLAorCQkJcHJpb3JpdHk6NCwJLyogRkNQLTM6IFNBTS0zIHByaW9yaXR5ICovCisJCQl0YXNrYXR0cjozOwkvKiBzY3NpIHRhc2sgYXR0cmlidXRlICovCisjZWxzZQorCXU4ICAgICAgICAgdGFza2F0dHI6MywJLyogc2NzaSB0YXNrIGF0dHJpYnV0ZSAqLworCQkJcHJpb3JpdHk6NCwJLyogRkNQLTM6IFNBTS0zIHByaW9yaXR5ICovCisJCQlyZXN2ZDoxOworI2VuZGlmCisJdTggICAgICAgICB0bV9mbGFnczsJLyogdGFzayBtYW5hZ2VtZW50IGZsYWdzICovCisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIGFkZGxfY2RiX2xlbjo2LAkvKiBhZGRpdGlvbmFsIENEQiBsZW5ndGggd29yZHMgKi8KKwkJCWlvZGlyOjI7CS8qIHJlYWQvd3JpdGUgRkNQX0RBVEEgSVVzICovCisjZWxzZQorCXU4ICAgICAgICAgaW9kaXI6MiwJLyogcmVhZC93cml0ZSBGQ1BfREFUQSBJVXMgKi8KKwkJCWFkZGxfY2RiX2xlbjo2OwkvKiBhZGRpdGlvbmFsIENEQiBsZW5ndGggKi8KKyNlbmRpZgorCXN0cnVjdCBzY3NpX2NkYl9zICAgICAgY2RiOworCisJLyoKKwkgKiAhISEgYWRkaXRpb25hbCBjZGIgYnl0ZXMgZm9sbG93cyBoZXJlISEhCisJICovCisJdTMyICAgICAgICBmY3BfZGw7CS8qIGJ5dGVzIHRvIGJlIHRyYW5zZmVycmVkICovCit9OworCisjZGVmaW5lIGZjcF9jbW5kX2NkYl9sZW4oX2NtbmQpICgoX2NtbmQpLT5hZGRsX2NkYl9sZW4gKiA0ICsgRkNQX0NNTkRfQ0RCX0xFTikKKyNkZWZpbmUgZmNwX2NtbmRfZmNwZGwoX2NtbmQpCSgoJihfY21uZCktPmZjcF9kbClbKF9jbW5kKS0+YWRkbF9jZGJfbGVuXSkKKworLyoKKyAqIGZjcF9jbW5kX3QuaW9kaXIgZmllbGQgdmFsdWVzCisgKi8KK2VudW0gZmNwX2lvZGlyeworCUZDUF9JT0RJUl9OT05FCT0gMCwKKwlGQ1BfSU9ESVJfV1JJVEUgPSAxLAorCUZDUF9JT0RJUl9SRUFECT0gMiwKKwlGQ1BfSU9ESVJfUlcJPSAzLAorfTsKKworLyoKKyAqIFRhc2sgYXR0cmlidXRlIGZpZWxkCisgKi8KK2VudW0geworCUZDUF9UQVNLX0FUVFJfU0lNUExFCT0gMCwKKwlGQ1BfVEFTS19BVFRSX0hPUQk9IDEsCisJRkNQX1RBU0tfQVRUUl9PUkRFUkVECT0gMiwKKwlGQ1BfVEFTS19BVFRSX0FDQQk9IDQsCisJRkNQX1RBU0tfQVRUUl9VTlRBR0dFRAk9IDUsCS8qIG9ic29sZXRlIGluIEZDUC0zICovCit9OworCisvKgorICogVGFzayBtYW5hZ2VtZW50IGZsYWdzIGZpZWxkIC0gb25seSBvbmUgYml0IHNoYWxsIGJlIHNldAorICovCisjaWZuZGVmIEJJVAorI2RlZmluZSBCSVQoX3gpCSgxIDw8IChfeCkpCisjZW5kaWYKK2VudW0gZmNwX3RtX2NtbmR7CisJRkNQX1RNX0FCT1JUX1RBU0tfU0VUCT0gQklUKDEpLAorCUZDUF9UTV9DTEVBUl9UQVNLX1NFVAk9IEJJVCgyKSwKKwlGQ1BfVE1fTFVOX1JFU0VUCT0gQklUKDQpLAorCUZDUF9UTV9UQVJHRVRfUkVTRVQJPSBCSVQoNSksCS8qIG9ic29sZXRlIGluIEZDUC0zICovCisJRkNQX1RNX0NMRUFSX0FDQQk9IEJJVCg2KSwKK307CisKKy8qCisgKiBGQ1BfWEZFUl9SRFkgSVUgZGVmaW5lcworICovCitzdHJ1Y3QgZmNwX3hmZXJfcmR5X3N7CisJdTMyICAgICAgICBkYXRhX3JvOworCXUzMiAgICAgICAgYnVyc3RfbGVuOworCXUzMiAgICAgICAgcmVzZXJ2ZWQ7Cit9OworCisvKgorICogRkNQX1JTUCByZXNpZHVlIGZsYWdzCisgKi8KK2VudW0gZmNwX3Jlc2lkdWV7CisJRkNQX05PX1JFU0lEVUUgPSAwLAkvKiBubyByZXNpZHVlICovCisJRkNQX1JFU0lEX09WRVIgPSAxLAkvKiBtb3JlIGRhdGEgbGVmdCB0aGF0IHdhcyBub3Qgc2VudCAqLworCUZDUF9SRVNJRF9VTkRFUiA9IDIsCS8qIGxlc3MgZGF0YSB0aGFuIHJlcXVlc3RlZCAqLworfTsKKworZW51bSB7CisJRkNQX1JTUElORk9fR09PRCA9IDAsCisJRkNQX1JTUElORk9fREFUQUxFTl9NSVNNQVRDSCA9IDEsCisJRkNQX1JTUElORk9fQ01ORF9JTlZBTElEID0gMiwKKwlGQ1BfUlNQSU5GT19ST0xFTl9NSVNNQVRDSCA9IDMsCisJRkNQX1JTUElORk9fVE1fTk9UX1NVUFAgPSA0LAorCUZDUF9SU1BJTkZPX1RNX0ZBSUxFRCA9IDUsCit9OworCitzdHJ1Y3QgZmNwX3JzcGluZm9fc3sKKwl1MzIgICAgICAgIHJlczA6MjQ7CisJdTMyICAgICAgICByc3BfY29kZTo4OwkvKiByZXNwb25zZSBjb2RlIChhcyBhYm92ZSkgKi8KKwl1MzIgICAgICAgIHJlczE7Cit9OworCitzdHJ1Y3QgZmNwX3Jlc3Bfc3sKKwl1MzIgICAgICAgIHJlc2VydmVkWzJdOwkvKiAyIHdvcmRzIHJlc2VydmVkICovCisJdTE2ICAgICAgICByZXNlcnZlZDI7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHJlc2VydmVkMzozOworCXU4ICAgICAgICAgZmNwX2NvbmZfcmVxOjE7CS8qIEZDUF9DT05GIGlzIHJlcXVlc3RlZCAqLworCXU4ICAgICAgICAgcmVzaWRfZmxhZ3M6MjsJLyogdW5kZXJmbG93L292ZXJmbG93ICovCisJdTggICAgICAgICBzbnNfbGVuX3ZhbGlkOjE7Lyogc2Vuc2UgbGVuIGlzIHZhbGlkICovCisJdTggICAgICAgICByc3BfbGVuX3ZhbGlkOjE7LyogcmVzcG9uc2UgbGVuIGlzIHZhbGlkICovCisjZWxzZQorCXU4ICAgICAgICAgcnNwX2xlbl92YWxpZDoxOy8qIHJlc3BvbnNlIGxlbiBpcyB2YWxpZCAqLworCXU4ICAgICAgICAgc25zX2xlbl92YWxpZDoxOy8qIHNlbnNlIGxlbiBpcyB2YWxpZCAqLworCXU4ICAgICAgICAgcmVzaWRfZmxhZ3M6MjsJLyogdW5kZXJmbG93L292ZXJmbG93ICovCisJdTggICAgICAgICBmY3BfY29uZl9yZXE6MTsJLyogRkNQX0NPTkYgaXMgcmVxdWVzdGVkICovCisJdTggICAgICAgICByZXNlcnZlZDM6MzsKKyNlbmRpZgorCXU4ICAgICAgICAgc2NzaV9zdGF0dXM7CS8qIG9uZSBieXRlIFNDU0kgc3RhdHVzICovCisJdTMyICAgICAgICByZXNpZHVlOwkvKiByZXNpZHVhbCBkYXRhIGJ5dGVzICovCisJdTMyICAgICAgICBzbnNfbGVuOwkvKiBsZW5ndGggb2Qgc2Vuc2UgaW5mbyAqLworCXUzMiAgICAgICAgcnNwX2xlbjsJLyogbGVuZ3RoIG9mIHJlc3BvbnNlIGluZm8gKi8KK307CisKKyNkZWZpbmUgZmNwX3Nuc2xlbihfX2ZjcHJzcCkJKChfX2ZjcHJzcCktPnNuc19sZW5fdmFsaWQgPyAJCVwKKwkJCQkJKF9fZmNwcnNwKS0+c25zX2xlbiA6IDApCisjZGVmaW5lIGZjcF9yc3BsZW4oX19mY3Byc3ApCSgoX19mY3Byc3ApLT5yc3BfbGVuX3ZhbGlkID8gCQlcCisJCQkJCShfX2ZjcHJzcCktPnJzcF9sZW4gOiAwKQorI2RlZmluZSBmY3BfcnNwaW5mbyhfX2ZjcHJzcCkJKChzdHJ1Y3QgZmNwX3JzcGluZm9fcyAqKSgoX19mY3Byc3ApICsgMSkpCisjZGVmaW5lIGZjcF9zbnNpbmZvKF9fZmNwcnNwKQkoKCh1OCAqKWZjcF9yc3BpbmZvKF9fZmNwcnNwKSkgKyAJXAorCQkJCQkJZmNwX3JzcGxlbihfX2ZjcHJzcCkpCisKK3N0cnVjdCBmY3BfY21uZF9mcl9zeworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlzdHJ1Y3QgZmNwX2NtbmRfcyAgICAgIGZjcDsKK307CisKKyNwcmFnbWEgcGFjaygpCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL2ZkbWkuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9mZG1pLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmMwNWMyNgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9mZG1pLmgKQEAgLTAsMCArMSwxNjMgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX0ZETUlfSF9fCisjZGVmaW5lIF9fRkRNSV9IX18KKworI2luY2x1ZGUgPHByb3RvY29sL3R5cGVzLmg+CisjaW5jbHVkZSA8cHJvdG9jb2wvZmMuaD4KKyNpbmNsdWRlIDxwcm90b2NvbC9jdC5oPgorCisjcHJhZ21hIHBhY2soMSkKKworLyoKKyAqIEZETUkgQ29tbWFuZCBDb2RlcworICovCisjZGVmaW5lCUZETUlfR1JITAkJMHgwMTAwCisjZGVmaW5lCUZETUlfR0hBVAkJMHgwMTAxCisjZGVmaW5lCUZETUlfR1JQTAkJMHgwMTAyCisjZGVmaW5lCUZETUlfR1BBVAkJMHgwMTEwCisjZGVmaW5lCUZETUlfUkhCQQkJMHgwMjAwCisjZGVmaW5lCUZETUlfUkhBVAkJMHgwMjAxCisjZGVmaW5lCUZETUlfUlBSVAkJMHgwMjEwCisjZGVmaW5lCUZETUlfUlBBCQkweDAyMTEKKyNkZWZpbmUJRkRNSV9ESEJBCQkweDAzMDAKKyNkZWZpbmUJRkRNSV9EUFJUCQkweDAzMTAKKworLyoKKyAqIEZETUkgcmVhc29uIGNvZGVzCisgKi8KKyNkZWZpbmUJRkRNSV9OT19BRERJVElPTkFMX0VYUAkJMHgwMAorI2RlZmluZQlGRE1JX0hCQV9BTFJFQURZX1JFRwkJMHgxMAorI2RlZmluZQlGRE1JX0hCQV9BVFRSSUJfTk9UX1JFRwkJMHgxMQorI2RlZmluZQlGRE1JX0hCQV9BVFRSSUJfTVVMVElQTEUJMHgxMgorI2RlZmluZQlGRE1JX0hCQV9BVFRSSUJfTEVOR1RIX0lOVkFMSUQJMHgxMworI2RlZmluZQlGRE1JX0hCQV9BVFRSSUJfTk9UX1BSRVNFTlQJMHgxNAorI2RlZmluZQlGRE1JX1BPUlRfT1JJR19OT1RfSU5fTElTVAkweDE1CisjZGVmaW5lCUZETUlfUE9SVF9IQkFfTk9UX0lOX0xJU1QJMHgxNgorI2RlZmluZQlGRE1JX1BPUlRfQVRUUklCX05PVF9SRUcJMHgyMAorI2RlZmluZQlGRE1JX1BPUlRfTk9UX1JFRwkJMHgyMQorI2RlZmluZQlGRE1JX1BPUlRfQVRUUklCX01VTFRJUExFCTB4MjIKKyNkZWZpbmUJRkRNSV9QT1JUX0FUVFJJQl9MRU5HVEhfSU5WQUxJRAkweDIzCisjZGVmaW5lCUZETUlfUE9SVF9BTFJFQURZX1JFR0lTVEVSRUVECTB4MjQKKworLyoKKyAqIEZETUkgVHJhbnNtaXNzaW9uIFNwZWVkIE1hc2sgdmFsdWVzCisgKi8KKyNkZWZpbmUJRkRNSV9UUkFOU19TUEVFRF8xRwkJMHgwMDAwMDAwMQorI2RlZmluZQlGRE1JX1RSQU5TX1NQRUVEXzJHCQkweDAwMDAwMDAyCisjZGVmaW5lCUZETUlfVFJBTlNfU1BFRURfMTBHCQkweDAwMDAwMDA0CisjZGVmaW5lCUZETUlfVFJBTlNfU1BFRURfNEcJCTB4MDAwMDAwMDgKKyNkZWZpbmUJRkRNSV9UUkFOU19TUEVFRF84RwkJMHgwMDAwMDAxMAorI2RlZmluZQlGRE1JX1RSQU5TX1NQRUVEXzE2RwkJMHgwMDAwMDAyMAorI2RlZmluZQlGRE1JX1RSQU5TX1NQRUVEX1VOS05PV04JMHgwMDAwODAwMAorCisvKgorICogRkRNSSBIQkEgYXR0cmlidXRlIHR5cGVzCisgKi8KK2VudW0gZmRtaV9oYmFfYXR0cmlidXRlX3R5cGUgeworCUZETUlfSEJBX0FUVFJJQl9OT0RFTkFNRSA9IDEsCS8qIDB4MDAwMSAqLworCUZETUlfSEJBX0FUVFJJQl9NQU5VRkFDVFVSRVIsCS8qIDB4MDAwMiAqLworCUZETUlfSEJBX0FUVFJJQl9TRVJJQUxOVU0sCS8qIDB4MDAwMyAqLworCUZETUlfSEJBX0FUVFJJQl9NT0RFTCwJCS8qIDB4MDAwNCAqLworCUZETUlfSEJBX0FUVFJJQl9NT0RFTF9ERVNDLAkvKiAweDAwMDUgKi8KKwlGRE1JX0hCQV9BVFRSSUJfSFdfVkVSU0lPTiwJLyogMHgwMDA2ICovCisJRkRNSV9IQkFfQVRUUklCX0RSSVZFUl9WRVJTSU9OLAkvKiAweDAwMDcgKi8KKwlGRE1JX0hCQV9BVFRSSUJfUk9NX1ZFUlNJT04sCS8qIDB4MDAwOCAqLworCUZETUlfSEJBX0FUVFJJQl9GV19WRVJTSU9OLAkvKiAweDAwMDkgKi8KKwlGRE1JX0hCQV9BVFRSSUJfT1NfTkFNRSwJLyogMHgwMDBBICovCisJRkRNSV9IQkFfQVRUUklCX01BWF9DVCwJCS8qIDB4MDAwQiAqLworCisJRkRNSV9IQkFfQVRUUklCX01BWF9UWVBFCit9OworCisvKgorICogRkRNSSBQb3J0IGF0dHJpYnV0ZSB0eXBlcworICovCitlbnVtIGZkbWlfcG9ydF9hdHRyaWJ1dGVfdHlwZSB7CisJRkRNSV9QT1JUX0FUVFJJQl9GQzRfVFlQRVMgPSAxLAkvKiAweDAwMDEgKi8KKwlGRE1JX1BPUlRfQVRUUklCX1NVUFBfU1BFRUQsCS8qIDB4MDAwMiAqLworCUZETUlfUE9SVF9BVFRSSUJfUE9SVF9TUEVFRCwJLyogMHgwMDAzICovCisJRkRNSV9QT1JUX0FUVFJJQl9GUkFNRV9TSVpFLAkvKiAweDAwMDQgKi8KKwlGRE1JX1BPUlRfQVRUUklCX0RFVl9OQU1FLAkvKiAweDAwMDUgKi8KKwlGRE1JX1BPUlRfQVRUUklCX0hPU1RfTkFNRSwJLyogMHgwMDA2ICovCisKKwlGRE1JX1BPUlRfQVRUUl9NQVhfVFlQRQorfTsKKworLyoKKyAqIEZETUkgYXR0cmlidXRlCisgKi8KK3N0cnVjdCBmZG1pX2F0dHJfcyB7CisJdTE2ICAgICAgICB0eXBlOworCXUxNiAgICAgICAgbGVuOworCXU4ICAgICAgICAgdmFsdWVbMV07Cit9OworCisvKgorICogSEJBIEF0dHJpYnV0ZSBCbG9jaworICovCitzdHJ1Y3QgZmRtaV9oYmFfYXR0cl9zIHsKKwl1MzIgICAgICAgIGF0dHJfY291bnQ7CS8qICMgb2YgYXR0cmlidXRlcyAqLworCXN0cnVjdCBmZG1pX2F0dHJfcyAgICAgaGJhX2F0dHI7CS8qIG4gYXR0cmlidXRlcyAqLworfTsKKworLyoKKyAqIFJlZ2lzdGVyZWQgUG9ydCBMaXN0CisgKi8KK3N0cnVjdCBmZG1pX3BvcnRfbGlzdF9zIHsKKwl1MzIgICAgICAgIG51bV9wb3J0czsJLyogbnVtYmVyIE9mIFBvcnQgRW50cmllcyAqLworCXd3bl90ICAgICAgICAgICBwb3J0X2VudHJ5OwkvKiBvbmUgb3IgbW9yZSAqLworfTsKKworLyoKKyAqIFBvcnQgQXR0cmlidXRlIEJsb2NrCisgKi8KK3N0cnVjdCBmZG1pX3BvcnRfYXR0cl9zIHsKKwl1MzIgICAgICAgIGF0dHJfY291bnQ7CS8qICMgb2YgYXR0cmlidXRlcyAqLworCXN0cnVjdCBmZG1pX2F0dHJfcyAgICAgcG9ydF9hdHRyOwkvKiBuIGF0dHJpYnV0ZXMgKi8KK307CisKKy8qCisgKiBGRE1JIFJlZ2lzdGVyIEhCQSBBdHRyaWJ1dGVzCisgKi8KK3N0cnVjdCBmZG1pX3JoYmFfcyB7CisJd3duX3QgICAgICAgICAgIGhiYV9pZDsJCS8qIEhCQSBJZGVudGlmaWVyICovCisJc3RydWN0IGZkbWlfcG9ydF9saXN0X3MgcG9ydF9saXN0OwkvKiBSZWdpc3RlcmVkIFBvcnQgTGlzdCAqLworCXN0cnVjdCBmZG1pX2hiYV9hdHRyX3MgaGJhX2F0dHJfYmxrOwkvKiBIQkEgYXR0cmlidXRlIGJsb2NrICovCit9OworCisvKgorICogRkRNSSBSZWdpc3RlciBQb3J0CisgKi8KK3N0cnVjdCBmZG1pX3JwcnRfcyB7CisJd3duX3QgICAgICAgICAgIGhiYV9pZDsJCS8qIEhCQSBJZGVudGlmaWVyICovCisJd3duX3QgICAgICAgICAgIHBvcnRfbmFtZTsJLyogUG9ydCB3d24gKi8KKwlzdHJ1Y3QgZmRtaV9wb3J0X2F0dHJfcyBwb3J0X2F0dHJfYmxrOwkvKiBQb3J0IEF0dHIgQmxvY2sgKi8KK307CisKKy8qCisgKiBGRE1JIFJlZ2lzdGVyIFBvcnQgQXR0cmlidXRlcworICovCitzdHJ1Y3QgZmRtaV9ycGFfcyB7CisJd3duX3QgICAgICAgICAgIHBvcnRfbmFtZTsJLyogcG9ydCB3d24gKi8KKwlzdHJ1Y3QgZmRtaV9wb3J0X2F0dHJfcyBwb3J0X2F0dHJfYmxrOwkvKiBQb3J0IEF0dHIgQmxvY2sgKi8KK307CisKKyNwcmFnbWEgcGFjaygpCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL3BjaWZ3LmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvcHJvdG9jb2wvcGNpZncuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ODMwZGMzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL3BjaWZ3LmgKQEAgLTAsMCArMSw3NSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBwY2lmdy5oIFBDSSBGVyByZWxhdGVkIGhlYWRlcnMKKyAqLworCisjaWZuZGVmIF9fUENJRldfSF9fCisjZGVmaW5lIF9fUENJRldfSF9fCisKKyNwcmFnbWEgcGFjaygxKQorCitzdHJ1Y3QgcG5wX2hkcl9zeworICB1MzIJc2lnbmF0dXJlOwkvKiAiJFBuUCIgKi8KKyAgdTgJcmV2OwkJLyogU3RydWN0IHJldmlzaW9uICovCisgIHU4IAlsZW47CQkvKiBIZWFkZXIgc3RydWN0dXJlIGxlbiBpbiBtdWx0aXBsZXMKKwkJCQkgKiBvZiAxNiBieXRlcyAqLworICB1MTYgIG9mZjsJCS8qIE9mZnNldCB0byBuZXh0IGhlYWRlciAwMCBpZiBub25lICovCisgIHU4CXJzdmQ7CQkvKiBSZXNlcnZlZCBieXRlICovCisgIHU4CWNrc3VtOwkJLyogOC1iaXQgY2hlY2tzdW0gZm9yIHRoaXMgaGVhZGVyICovCisgIHUzMglwbnBfZGV2X2lkOwkvKiBQblAgRGV2aWNlIElkICovCisgIHUxNiAgbWZzdHI7CQkvKiBQb2ludGVyIHRvIG1hbnVmYWN0dXJlciBzdHJpbmcgKi8KKyAgdTE2CXByc3RyOwkJLyogUG9pbnRlciB0byBwcm9kdWN0IHN0cmluZyAqLworICB1OAlkZXZ0eXBlWzNdOwkvKiBEZXZpY2UgVHlwZSBDb2RlICovCisgIHU4CWRldmluZDsJCS8qIERldmljZSBJbmRpY2F0b3IgKi8KKyAgdTE2CWJjdmVudHI7CS8qIEJvb3RzdHJhcCBlbnRyeSB2ZWN0b3IgKi8KKyAgdTE2CXJzdmQyOwkJLyogUmVzZXJ2ZWQgKi8KKyAgdTE2ICBzcml2OwkJLyogU3RhdGljIHJlc291cmNlIGluZm9ybWF0aW9uIHZlY3RvciAqLworfTsKKworc3RydWN0IHBjaV8zXzBfZHNfc3sKKyB1MzIJc2lnOyAgIAkJLyogU2lnbmF0dXJlICJQQ0lSIiAqLworIHUxNgl2ZW5kaWQ7CQkvKiBWZW5kb3IgSUQgKi8KKyB1MTYJZGV2aWQ7CQkvKiBEZXZpY2UgSUQgKi8KKyB1MTYJZGV2bGlzdG9mZjsJLyogRGV2aWNlIExpc3QgT2Zmc2V0ICovCisgdTE2CWxlbjsJCS8qIFBDSSBEYXRhIFN0cnVjdHVyZSBMZW5ndGggKi8KKyB1OAlyZXY7CQkvKiBQQ0kgRGF0YSBTdHJ1Y3R1cmUgUmV2aXNpb24gKi8KKyB1OAljbGNvZGVbM107CS8qIENsYXNzIENvZGUgKi8KKyB1MTYJaW1nbGVuOwkJLyogQ29kZSBpbWFnZSBsZW5ndGggaW4gbXVsdGlwbGVzIG9mCisJCQkJICogNTEyIGJ5dGVzICovCisgdTE2CWNvZGVyZXY7CS8qIFJldmlzaW9uIGxldmVsIG9mIGNvZGUvZGF0YSAqLworIHU4CWNvZGV0eXBlOwkvKiBDb2RlIHR5cGUgMHgwMCAtIEJJT1MgKi8KKyB1OAlpbmRyOwkJLyogTGFzdCBpbWFnZSBpbmRpY2F0b3IgKi8KKyB1MTYJbXJ0aW1nbGVuOwkvKiBNYXggUnVuIFRpbWUgSW1hZ2UgTGVuZ3RoICovCisgdTE2CWN1b2ZmOwkJLyogQ29uZmlnIFV0aWxpdHkgQ29kZSBIZWFkZXIgT2Zmc2V0ICovCisgdTE2CWRtdGZjbHA7CS8qIERNVEYgQ0xQIGVudHJ5IHBvaW50IG9mZnNldCAqLworfTsKKworc3RydWN0IHBjaV9vcHRyb21faGRyX3N7CisgdTE2CXNpZzsJCS8qIFNpZ25hdHVyZSAweDU1QUEgKi8KKyB1OAlsZW47CQkvKiBPcHRpb24gUk9NIGxlbmd0aCBpbiB1bml0cyBvZiA1MTIgYnl0ZXMgKi8KKyB1OAlpbml2ZWNbM107CS8qIEluaXRpYWxpemF0aW9uIHZlY3RvciAqLworIHU4CXJzdmRbMTZdOwkvKiBSZXNlcnZlZCBmaWVsZCAqLworIHUxNgl2ZXJwdHI7CQkvKiBQb2ludGVyIHRvIHZlcnNpb24gc3RyaW5nIC0gcHJpdmF0ZSAqLworIHUxNglwY2lkczsJCS8qIFBvaW50ZXIgdG8gUENJIGRhdGEgc3RydWN0dXJlICovCisgdTE2CXBucGhkcjsJCS8qIFBvaW50ZXIgdG8gUG5QIGV4cGFuc2lvbiBoZWFkZXIgKi8KK307CisKKyNwcmFnbWEgcGFjaygpCisKKyNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL3Njc2kuaCBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9zY3NpLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjIyMGU2YgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvaW5jbHVkZS9wcm90b2NvbC9zY3NpLmgKQEAgLTAsMCArMSwxNjQ4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKyNpZm5kZWYgX19TQ1NJX0hfXworI2RlZmluZSBfX1NDU0lfSF9fCisKKyNpbmNsdWRlIDxwcm90b2NvbC90eXBlcy5oPgorCisjcHJhZ21hIHBhY2soMSkKKworLyoKKyAqIGdlbmVyaWMgU0NTSSBjZGIgZGVmaW5pdGlvbgorICovCisjZGVmaW5lIFNDU0lfTUFYX0NEQkxFTiAgICAgMTYKK3N0cnVjdCBzY3NpX2NkYl9zeworCXU4ICAgICAgICAgc2NzaV9jZGJbU0NTSV9NQVhfQ0RCTEVOXTsKK307CisKKy8qCisgKiBzY3NpIGx1biBzZXJpYWwgbnVtYmVyIGRlZmluaXRpb24KKyAqLworI2RlZmluZSBTQ1NJX0xVTl9TTl9MRU4gICAgIDMyCitzdHJ1Y3Qgc2NzaV9sdW5fc25fc3sKKwl1OCAgICAgICAgIGx1bl9zbltTQ1NJX0xVTl9TTl9MRU5dOworfTsKKworLyoKKyAqIFNDU0kgRGlyZWN0IEFjY2VzcyBDb21tYW5kcworICovCitlbnVtIHsKKwlTQ1NJX09QX1RFU1RfVU5JVF9SRUFEWQkJPSAweDAwLAorCVNDU0lfT1BfUkVRVUVTVF9TRU5TRQkJPSAweDAzLAorCVNDU0lfT1BfRk9STUFUX1VOSVQJCT0gMHgwNCwKKwlTQ1NJX09QX1JFQUQ2CQkJPSAweDA4LAorCVNDU0lfT1BfV1JJVEU2CQkJPSAweDBBLAorCVNDU0lfT1BfV1JJVEVfRklMRU1BUktTCQk9IDB4MTAsCisJU0NTSV9PUF9JTlFVSVJZCQkJPSAweDEyLAorCVNDU0lfT1BfTU9ERV9TRUxFQ1Q2CQk9IDB4MTUsCisJU0NTSV9PUF9SRVNFUlZFNgkJPSAweDE2LAorCVNDU0lfT1BfUkVMRUFTRTYJCT0gMHgxNywKKwlTQ1NJX09QX01PREVfU0VOU0U2CQk9IDB4MUEsCisJU0NTSV9PUF9TVEFSVF9TVE9QX1VOSVQJCT0gMHgxQiwKKwlTQ1NJX09QX1NFTkRfRElBR05PU1RJQwkJPSAweDFELAorCVNDU0lfT1BfUkVBRF9DQVBBQ0lUWQkJPSAweDI1LAorCVNDU0lfT1BfUkVBRDEwCQkJPSAweDI4LAorCVNDU0lfT1BfV1JJVEUxMAkJCT0gMHgyQSwKKwlTQ1NJX09QX1ZFUklGWTEwCQk9IDB4MkYsCisJU0NTSV9PUF9SRUFEX0RFRkVDVF9EQVRBCT0gMHgzNywKKwlTQ1NJX09QX0xPR19TRUxFQ1QJCT0gMHg0QywKKwlTQ1NJX09QX0xPR19TRU5TRQkJPSAweDRELAorCVNDU0lfT1BfTU9ERV9TRUxFQ1QxMAkJPSAweDU1LAorCVNDU0lfT1BfUkVTRVJWRTEwCQk9IDB4NTYsCisJU0NTSV9PUF9SRUxFQVNFMTAJCT0gMHg1NywKKwlTQ1NJX09QX01PREVfU0VOU0UxMAkJPSAweDVBLAorCVNDU0lfT1BfUEVSX1JFU0VSVkVfSU4JCT0gMHg1RSwKKwlTQ1NJX09QX1BFUl9SRVNFUlZFX09VUgkJPSAweDVFLAorCVNDU0lfT1BfUkVBRDE2CQkJPSAweDg4LAorCVNDU0lfT1BfV1JJVEUxNgkJCT0gMHg4QSwKKwlTQ1NJX09QX1ZFUklGWTE2CQk9IDB4OEYsCisJU0NTSV9PUF9SRUFEX0NBUEFDSVRZMTYJCT0gMHg5RSwKKwlTQ1NJX09QX1JFUE9SVF9MVU5TCQk9IDB4QTAsCisJU0NTSV9PUF9SRUFEMTIJCQk9IDB4QTgsCisJU0NTSV9PUF9XUklURTEyCQkJPSAweEFBLAorCVNDU0lfT1BfVU5ERUYJCQk9IDB4RkYsCit9OworCisvKgorICogU0NTSSBTVEFSVF9TVE9QX1VOSVQgY29tbWFuZAorICovCitzdHJ1Y3Qgc2NzaV9zdGFydF9zdG9wX3VuaXRfc3sKKwl1OCAgICAgICAgIG9wY29kZTsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgbHVuOjM7CisJdTggICAgICAgICByZXNlcnZlZDE6NDsKKwl1OCAgICAgICAgIGltbWVkOjE7CisjZWxzZQorCXU4ICAgICAgICAgaW1tZWQ6MTsKKwl1OCAgICAgICAgIHJlc2VydmVkMTo0OworCXU4ICAgICAgICAgbHVuOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmVkMjsKKwl1OCAgICAgICAgIHJlc2VydmVkMzsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcG93ZXJfY29uZGl0aW9uczo0OworCXU4ICAgICAgICAgcmVzZXJ2ZWQ0OjI7CisJdTggICAgICAgICBsb0VqOjE7CisJdTggICAgICAgICBzdGFydDoxOworI2Vsc2UKKwl1OCAgICAgICAgIHN0YXJ0OjE7CisJdTggICAgICAgICBsb0VqOjE7CisJdTggICAgICAgICByZXNlcnZlZDQ6MjsKKwl1OCAgICAgICAgIHBvd2VyX2NvbmRpdGlvbnM6NDsKKyNlbmRpZgorCXU4ICAgICAgICAgY29udHJvbDsKK307CisKKy8qCisgKiBTQ1NJIFNFTkRfRElBR05PU1RJQyBjb21tYW5kCisgKi8KK3N0cnVjdCBzY3NpX3NlbmRfZGlhZ25vc3RpY19zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBzZWxmX3Rlc3RfY29kZTozOworCXU4ICAgICAgICAgcGY6MTsKKwl1OCAgICAgICAgIHJlc2VydmVkMToxOworCXU4ICAgICAgICAgc2VsZl90ZXN0OjE7CisJdTggICAgICAgICBkZXZfb2ZmbDoxOworCXU4ICAgICAgICAgdW5pdF9vZmZsOjE7CisjZWxzZQorCXU4ICAgICAgICAgdW5pdF9vZmZsOjE7CisJdTggICAgICAgICBkZXZfb2ZmbDoxOworCXU4ICAgICAgICAgc2VsZl90ZXN0OjE7CisJdTggICAgICAgICByZXNlcnZlZDE6MTsKKwl1OCAgICAgICAgIHBmOjE7CisJdTggICAgICAgICBzZWxmX3Rlc3RfY29kZTozOworI2VuZGlmCisJdTggICAgICAgICByZXNlcnZlZDI7CisKKwl1OCAgICAgICAgIHBhcmFtX2xpc3RfbGVuZ3RoWzJdOwkvKiBNU0IgZmlyc3QgKi8KKwl1OCAgICAgICAgIGNvbnRyb2w7CisKK307CisKKy8qCisgKiBTQ1NJIFJFQUQxMC9XUklURTEwIGNvbW1hbmRzCisgKi8KK3N0cnVjdCBzY3NpX3J3MTBfc3sKKwl1OCAgICAgICAgIG9wY29kZTsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgbHVuOjM7CisJdTggICAgICAgICBkcG86MTsJLyogRGlzYWJsZSBQYWdlIE91dCAqLworCXU4ICAgICAgICAgZnVhOjE7CS8qIEZvcmNlIFVuaXQgQWNjZXNzICovCisJdTggICAgICAgICByZXNlcnZlZDE6MjsKKwl1OCAgICAgICAgIHJlbF9hZHI6MTsJLyogcmVsYXRpdmUgYWRkcmVzcyAqLworI2Vsc2UKKwl1OCAgICAgICAgIHJlbF9hZHI6MTsKKwl1OCAgICAgICAgIHJlc2VydmVkMToyOworCXU4ICAgICAgICAgZnVhOjE7CisJdTggICAgICAgICBkcG86MTsKKwl1OCAgICAgICAgIGx1bjozOworI2VuZGlmCisJdTggICAgICAgICBsYmEwOwkvKiBsb2dpY2FsIGJsb2NrIGFkZHJlc3MgLSBNU0IgKi8KKwl1OCAgICAgICAgIGxiYTE7CisJdTggICAgICAgICBsYmEyOworCXU4ICAgICAgICAgbGJhMzsJLyogTFNCICovCisJdTggICAgICAgICByZXNlcnZlZDM7CisJdTggICAgICAgICB4ZmVyX2xlbmd0aDA7CS8qIHRyYW5zZmVyIGxlbmd0aCBpbiBibG9ja3MgLSBNU0IgKi8KKwl1OCAgICAgICAgIHhmZXJfbGVuZ3RoMTsJLyogTFNCICovCisJdTggICAgICAgICBjb250cm9sOworfTsKKworI2RlZmluZSBTQ1NJX0NEQjEwX0dFVF9MQkEoY2RiKSAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAoKChjZGIpLT5sYmEwIDw8IDI0KSB8ICgoY2RiKS0+bGJhMSA8PCAxNikgfCAgICBcCisgICAgICgoY2RiKS0+bGJhMiA8PCA4KSB8IChjZGIpLT5sYmEzKQorCisjZGVmaW5lIFNDU0lfQ0RCMTBfU0VUX0xCQShjZGIsIGxiYSkgeyAgICAgIFwKKyAgICAoY2RiKS0+bGJhMCA9IGxiYSA+PiAyNDsgICAgICAgICAgICBcCisgICAgKGNkYiktPmxiYTEgPSAobGJhID4+IDE2KSAmIDB4RkY7ICAgXAorICAgIChjZGIpLT5sYmEyID0gKGxiYSA+PiA4KSAmIDB4RkY7ICAgIFwKKyAgICAoY2RiKS0+bGJhMyA9IGxiYSAmIDB4RkY7ICAgICAgICAgICBcCit9CisKKyNkZWZpbmUgU0NTSV9DREIxMF9HRVRfVEwoY2RiKSAgXAorICAgICgoY2RiKS0+eGZlcl9sZW5ndGgwIDw8IDggfCAoY2RiKS0+eGZlcl9sZW5ndGgxKQorI2RlZmluZSBTQ1NJX0NEQjEwX1NFVF9UTChjZGIsIHRsKSB7ICAgICAgXAorICAgIChjZGIpLT54ZmVyX2xlbmd0aDAgPSB0bCA+PiA4OyAgICAgICBcCisgICAgKGNkYiktPnhmZXJfbGVuZ3RoMSA9IHRsICYgMHhGRjsgICAgIFwKK30KKworLyoKKyAqIFNDU0kgUkVBRDYvV1JJVEU2IGNvbW1hbmRzCisgKi8KK3N0cnVjdCBzY3NpX3J3Nl9zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBsdW46MzsKKwl1OCAgICAgICAgIGxiYTA6NTsJCS8qIE1TYiAqLworI2Vsc2UKKwl1OCAgICAgICAgIGxiYTA6NTsJCS8qIE1TYiAqLworCXU4ICAgICAgICAgbHVuOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIGxiYTE7CisJdTggICAgICAgICBsYmEyOwkJLyogTFNCICovCisJdTggICAgICAgICB4ZmVyX2xlbmd0aDsKKwl1OCAgICAgICAgIGNvbnRyb2w7Cit9OworCisjZGVmaW5lIFNDU0lfVEFQRV9DREI2X0dFVF9UTChjZGIpICAgICAgICAgICAgICBcCisgICAgKCgoY2RiKS0+dGwwIDw8IDE2KSB8ICgoY2RiKS0+dGwxIDw8IDgpIHwgKGNkYiktPnRsMikKKworI2RlZmluZSBTQ1NJX1RBUEVfQ0RCNl9TRVRfVEwoY2RiLCB0bCkgeyAgICAgIFwKKyAgICAoY2RiKS0+dGwwID0gdGwgPj4gMTY7ICAgICAgICAgICAgXAorICAgIChjZGIpLT50bDEgPSAodGwgPj4gOCkgJiAweEZGOyAgICBcCisgICAgKGNkYiktPnRsMiA9IHRsICYgMHhGRjsgICAgICAgICAgIFwKK30KKworLyoKKyAqIFNDU0kgc2VxdWVudGlhbCAoVEFQRSkgd3J0aWUgY29tbWFuZAorICovCitzdHJ1Y3Qgc2NzaV90YXBlX3dyX3N7CisJdTggICAgICAgICBvcGNvZGU7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHJzdmQ6NzsKKwl1OCAgICAgICAgIGZpeGVkOjE7CS8qIE1TYiAqLworI2Vsc2UKKwl1OCAgICAgICAgIGZpeGVkOjE7CS8qIE1TYiAqLworCXU4ICAgICAgICAgcnN2ZDo3OworI2VuZGlmCisJdTggICAgICAgICB0bDA7CQkvKiBNc2IgKi8KKwl1OCAgICAgICAgIHRsMTsKKwl1OCAgICAgICAgIHRsMjsJCS8qIExzYiAqLworCisJdTggICAgICAgICBjb250cm9sOworfTsKKworI2RlZmluZSBTQ1NJX0NEQjZfR0VUX0xCQShjZGIpICAgICAgICAgICAgICBcCisgICAgKCgoY2RiKS0+bGJhMCA8PCAxNikgfCAoKGNkYiktPmxiYTEgPDwgOCkgfCAoY2RiKS0+bGJhMikKKworI2RlZmluZSBTQ1NJX0NEQjZfU0VUX0xCQShjZGIsIGxiYSkgeyAgICAgIFwKKyAgICAoY2RiKS0+bGJhMCA9IGxiYSA+PiAxNjsgICAgICAgICAgICBcCisgICAgKGNkYiktPmxiYTEgPSAobGJhID4+IDgpICYgMHhGRjsgICAgXAorICAgIChjZGIpLT5sYmEyID0gbGJhICYgMHhGRjsgICAgICAgICAgIFwKK30KKworI2RlZmluZSBTQ1NJX0NEQjZfR0VUX1RMKGNkYikgKChjZGIpLT54ZmVyX2xlbmd0aCkKKyNkZWZpbmUgU0NTSV9DREI2X1NFVF9UTChjZGIsIHRsKSB7ICAgICAgXAorICAgIChjZGIpLT54ZmVyX2xlbmd0aCA9IHRsOyAgICAgICAgIFwKK30KKworLyoKKyAqIFNDU0kgc2Vuc2UgZGF0YSBmb3JtYXQKKyAqLworc3RydWN0IHNjc2lfc2Vuc2Vfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgdmFsaWQ6MTsKKwl1OCAgICAgICAgIHJzcF9jb2RlOjc7CisjZWxzZQorCXU4ICAgICAgICAgcnNwX2NvZGU6NzsKKwl1OCAgICAgICAgIHZhbGlkOjE7CisjZW5kaWYKKwl1OCAgICAgICAgIHNlZ19udW07CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIGZpbGVfbWFyazoxOworCXU4ICAgICAgICAgZW9tOjE7CQkvKiBlbmQgb2YgbWVkaWEgKi8KKwl1OCAgICAgICAgIGlsaToxOwkJLyogaW5jb3JyZWN0IGxlbmd0aCBpbmRpY2F0b3IgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkOjE7CisJdTggICAgICAgICBzZW5zZV9rZXk6NDsKKyNlbHNlCisJdTggICAgICAgICBzZW5zZV9rZXk6NDsKKwl1OCAgICAgICAgIHJlc2VydmVkOjE7CisJdTggICAgICAgICBpbGk6MTsJCS8qIGluY29ycmVjdCBsZW5ndGggaW5kaWNhdG9yICovCisJdTggICAgICAgICBlb206MTsJCS8qIGVuZCBvZiBtZWRpYSAqLworCXU4ICAgICAgICAgZmlsZV9tYXJrOjE7CisjZW5kaWYKKwl1OCAgICAgICAgIGluZm9ybWF0aW9uWzRdOwkvKiBkZXZpY2UtdHlwZSBvciBjb21tYW5kIHNwZWNpZmljIGluZm8KKwkJCQkJICovCisJdTggICAgICAgICBhZGRfc2Vuc2VfbGVuZ3RoOworCQkJCQkvKiBhZGRpdGlvbmFsIHNlbnNlIGxlbmd0aCAqLworCXU4ICAgICAgICAgY29tbWFuZF9pbmZvWzRdOy8qIGNvbW1hbmQgc3BlY2lmaWMgaW5mb3JtYXRpb24KKwkJCQkJCSAqLworCXU4ICAgICAgICAgYXNjOwkJLyogYWRkaXRpb25hbCBzZW5zZSBjb2RlICovCisJdTggICAgICAgICBhc2NxOwkJLyogYWRkaXRpb25hbCBzZW5zZSBjb2RlIHF1YWxpZmllciAqLworCXU4ICAgICAgICAgZnJ1X2NvZGU7CS8qIGZpZWxkIHJlcGxhY2VhYmxlIHVuaXQgY29kZSAqLworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBza3N2OjE7CQkvKiBzZW5zZSBrZXkgc3BlY2lmaWMgdmFsaWQgKi8KKwl1OCAgICAgICAgIGNfZDoxOwkJLyogY29tbWFuZC9kYXRhIGJpdCAqLworCXU4ICAgICAgICAgcmVzMToyOworCXU4ICAgICAgICAgYnB2OjE7CQkvKiBiaXQgcG9pbnRlciB2YWxpZCAqLworCXU4ICAgICAgICAgYnBvaW50ZXI6MzsJLyogYml0IHBvaW50ZXIgKi8KKyNlbHNlCisJdTggICAgICAgICBicG9pbnRlcjozOwkvKiBiaXQgcG9pbnRlciAqLworCXU4ICAgICAgICAgYnB2OjE7CQkvKiBiaXQgcG9pbnRlciB2YWxpZCAqLworCXU4ICAgICAgICAgcmVzMToyOworCXU4ICAgICAgICAgY19kOjE7CQkvKiBjb21tYW5kL2RhdGEgYml0ICovCisJdTggICAgICAgICBza3N2OjE7CQkvKiBzZW5zZSBrZXkgc3BlY2lmaWMgdmFsaWQgKi8KKyNlbmRpZgorCXU4ICAgICAgICAgZnBvaW50ZXJbMl07CS8qIGZpZWxkIHBvaW50ZXIgKi8KK307CisKKyNkZWZpbmUgU0NTSV9TRU5TRV9DVVJfRVJSICAgICAgICAgIDB4NzAKKyNkZWZpbmUgU0NTSV9TRU5TRV9ERUZfRVJSICAgICAgICAgIDB4NzEKKworLyoKKyAqIFNDU0kgc2Vuc2Uga2V5IHZhbHVlcworICovCisjZGVmaW5lIFNDU0lfU0tfTk9fU0VOU0UgICAgICAgIDB4MAorI2RlZmluZSBTQ1NJX1NLX1JFQ19FUlIgICAgICAgICAweDEJLyogcmVjb3ZlcmVkIGVycm9yICovCisjZGVmaW5lIFNDU0lfU0tfTk9UX1JFQURZICAgICAgIDB4MgorI2RlZmluZSBTQ1NJX1NLX01FRF9FUlIgICAgICAgICAweDMJLyogbWVkaXVtIGVycm9yICovCisjZGVmaW5lIFNDU0lfU0tfSFdfRVJSICAgICAgICAgIDB4NAkvKiBoYXJkd2FyZSBlcnJvciAqLworI2RlZmluZSBTQ1NJX1NLX0lMTEVHQUxfUkVRICAgICAweDUKKyNkZWZpbmUgU0NTSV9TS19VTklUX0FUVCAgICAgICAgMHg2CS8qIHVuaXQgYXR0ZW50aW9uICovCisjZGVmaW5lIFNDU0lfU0tfREFUQV9QUk9URUNUICAgIDB4NworI2RlZmluZSBTQ1NJX1NLX0JMQU5LX0NIRUNLICAgICAweDgKKyNkZWZpbmUgU0NTSV9TS19WRU5ET1JfU1BFQyAgICAgMHg5CisjZGVmaW5lIFNDU0lfU0tfQ09QWV9BQk9SVEVEICAgIDB4QQorI2RlZmluZSBTQ1NJX1NLX0FCT1JURURfQ01ORCAgICAweEIKKyNkZWZpbmUgU0NTSV9TS19WT0xfT1ZFUkZMT1cgICAgMHhECisjZGVmaW5lIFNDU0lfU0tfTUlTQ09NUEFSRSAgICAgIDB4RQorCisvKgorICogU0NTSSBhZGRpdGlvbmFsIHNlbnNlIGNvZGVzCisgKi8KKyNkZWZpbmUgU0NTSV9BU0NfTk9fQUREX1NFTlNFICAgICAgICAgICAweDAwCisjZGVmaW5lIFNDU0lfQVNDX0xVTl9OT1RfUkVBRFkgICAgICAgICAgMHgwNAorI2RlZmluZSBTQ1NJX0FTQ19MVU5fQ09NTVVOSUNBVElPTiAgICAgIDB4MDgKKyNkZWZpbmUgU0NTSV9BU0NfV1JJVEVfRVJST1IgICAgICAgICAgICAweDBDCisjZGVmaW5lIFNDU0lfQVNDX0lOVkFMSURfQ01ORF9DT0RFICAgICAgMHgyMAorI2RlZmluZSBTQ1NJX0FTQ19CQURfTEJBICAgICAgICAgICAgICAgIDB4MjEKKyNkZWZpbmUgU0NTSV9BU0NfSU5WQUxJRF9GSUVMRF9JTl9DREIgICAweDI0CisjZGVmaW5lIFNDU0lfQVNDX0xVTl9OT1RfU1VQUE9SVEVEICAgICAgMHgyNQorI2RlZmluZSBTQ1NJX0FTQ19MVU5fV1JJVEVfUFJPVEVDVCAgICAgIDB4MjcKKyNkZWZpbmUgU0NTSV9BU0NfUE9XRVJPTl9CRFIgICAgICAgICAgICAweDI5CS8qIHBvd2VyIG9uIHJlc2V0LCBidXMgcmVzZXQsCisJCQkJCQkgKiBidXMgZGV2aWNlIHJlc2V0CisJCQkJCQkgKi8KKyNkZWZpbmUgU0NTSV9BU0NfUEFSQU1TX0NIQU5HRUQgICAgICAgICAweDJBCisjZGVmaW5lIFNDU0lfQVNDX0NNTkRfQ0xFQVJFRF9CWV9BX0kgICAgMHgyRgorI2RlZmluZSBTQ1NJX0FTQ19TQVZJTkdfUEFSQU1fTk9UU1VQUCAgIDB4MzkKKyNkZWZpbmUgU0NTSV9BU0NfVE9DQyAgICAgICAgICAgICAgICAgICAweDNGCS8qIHRhcmdldCBvcGVyYXRpbmcgY29uZHRpb25zCisJCQkJCQkgKiBjaGFuZ2VkCisJCQkJCQkgKi8KKyNkZWZpbmUgU0NTSV9BU0NfUEFSSVRZX0VSUk9SICAgICAgICAgICAweDQ3CisjZGVmaW5lIFNDU0lfQVNDX0NNTkRfUEhBU0VfRVJST1IgICAgICAgMHg0QQorI2RlZmluZSBTQ1NJX0FTQ19EQVRBX1BIQVNFX0VSUk9SICAgICAgIDB4NEIKKyNkZWZpbmUgU0NTSV9BU0NfVkVORE9SX1NQRUMgICAgICAgICAgICAweDdGCisKKy8qCisgKiBTQ1NJIGFkZGl0aW9uYWwgc2Vuc2UgY29kZSBxdWFsaWZpZXJzCisgKi8KKyNkZWZpbmUgU0NTSV9BU0NRX0NBVVNFX05PVF9SRVBPUlQgICAgICAweDAwCisjZGVmaW5lIFNDU0lfQVNDUV9CRUNPTUlOR19SRUFEWSAgICAgICAgMHgwMQorI2RlZmluZSBTQ1NJX0FTQ1FfSU5JVF9DTURfUkVRICAgICAgICAgIDB4MDIKKyNkZWZpbmUgU0NTSV9BU0NRX0ZPUk1BVF9JTl9QUk9HUkVTUyAgICAweDA0CisjZGVmaW5lIFNDU0lfQVNDUV9PUEVSQVRJT05fSU5fUFJPR1JFU1MgMHgwNworI2RlZmluZSBTQ1NJX0FTQ1FfU0VMRl9URVNUX0lOX1BST0dSRVNTIDB4MDkKKyNkZWZpbmUgU0NTSV9BU0NRX1dSX1VORVhQX1VOU09MX0RBVEEgICAweDBDCisjZGVmaW5lIFNDU0lfQVNDUV9XUl9OT1RFTkdfVU5TT0xfREFUQSAgMHgwRAorCisjZGVmaW5lIFNDU0lfQVNDUV9MQkFfT1VUX09GX1JBTkdFICAgICAgMHgwMAorI2RlZmluZSBTQ1NJX0FTQ1FfSU5WQUxJRF9FTEVNRU5UX0FERFIgIDB4MDEKKworI2RlZmluZSBTQ1NJX0FTQ1FfTFVOX1dSSVRFX1BST1RFQ1RFRCAgICAgICAweDAwCisjZGVmaW5lIFNDU0lfQVNDUV9MVU5fSFdfV1JJVEVfUFJPVEVDVEVEICAgIDB4MDEKKyNkZWZpbmUgU0NTSV9BU0NRX0xVTl9TV19XUklURV9QUk9URUNURUQgICAgMHgwMgorCisjZGVmaW5lIFNDU0lfQVNDUV9QT1IgICAweDAxCS8qIHBvd2VyIG9uIHJlc2V0ICovCisjZGVmaW5lIFNDU0lfQVNDUV9TQlIgICAweDAyCS8qIHNjc2kgYnVzIHJlc2V0ICovCisjZGVmaW5lIFNDU0lfQVNDUV9CRFIgICAweDAzCS8qIGJ1cyBkZXZpY2UgcmVzZXQgKi8KKyNkZWZpbmUgU0NTSV9BU0NRX0RJUiAgIDB4MDQJLyogZGV2aWNlIGludGVybmFsIHJlc2V0ICovCisKKyNkZWZpbmUgU0NTSV9BU0NRX01PREVfUEFSQU1TX0NIQU5HRUQgICAgICAgMHgwMQorI2RlZmluZSBTQ1NJX0FTQ1FfTE9HX1BBUkFNU19DSEFOR0VEICAgICAgICAweDAyCisjZGVmaW5lIFNDU0lfQVNDUV9SRVNFUlZBVElPTlNfUFJFRU1QVEVEICAgIDB4MDMKKyNkZWZpbmUgU0NTSV9BU0NRX1JFU0VSVkFUSU9OU19SRUxFQVNFRCAgICAgMHgwNAorI2RlZmluZSBTQ1NJX0FTQ1FfUkVHSVNUUkFUSU9OU19QUkVFTVBURUQgICAweDA1CisKKyNkZWZpbmUgU0NTSV9BU0NRX01JQ1JPQ09ERV9DSEFOR0VEIDB4MDEKKyNkZWZpbmUgU0NTSV9BU0NRX0NIQU5HRURfT1BFUl9DT05EIDB4MDIKKyNkZWZpbmUgU0NTSV9BU0NRX0lOUV9DSEFOR0VEICAgICAgIDB4MDMJLyogaW5xdWlyeSBkYXRhIGNoYW5nZWQgKi8KKyNkZWZpbmUgU0NTSV9BU0NRX0RJX0NIQU5HRUQgICAgICAgIDB4MDUJLyogZGV2aWNlIGlkIGNoYW5nZWQgKi8KKyNkZWZpbmUgU0NTSV9BU0NRX1JMX0RBVEFfQ0hBTkdFRCAgIDB4MEUJLyogcmVwb3J0IGx1bnMgZGF0YSBjaGFuZ2VkICovCisKKyNkZWZpbmUgU0NTSV9BU0NRX0RQX0NSQ19FUlIgICAgICAgICAgICAweDAxCS8qIGRhdGEgcGhhc2UgY3JjIGVycm9yICovCisjZGVmaW5lIFNDU0lfQVNDUV9EUF9TQ1NJX1BBUklUWV9FUlIgICAgMHgwMgkvKiBkYXRhIHBoYXNlIHNjc2kgcGFyaXR5IGVycm9yCisJCQkJCQkgKi8KKyNkZWZpbmUgU0NTSV9BU0NRX0lVX0NSQ19FUlIgICAgICAgICAgICAweDAzCS8qIGluZm9ybWF0aW9uIHVuaXQgY3JjIGVycm9yICovCisjZGVmaW5lIFNDU0lfQVNDUV9QUk9UT19TRVJWX0NSQ19FUlIgICAgMHgwNQorCisjZGVmaW5lIFNDU0lfQVNDUV9MVU5fVElNRV9PVVQgICAgICAgICAgMHgwMQorCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqIFNDU0kgSU5RVUlSWQorICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KKworc3RydWN0IHNjc2lfaW5xdWlyeV9zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBsdW46MzsKKwl1OCAgICAgICAgIHJlc2VydmVkMTozOworCXU4ICAgICAgICAgY21kX2R0OjE7CisJdTggICAgICAgICBldnBkOjE7CisjZWxzZQorCXU4ICAgICAgICAgZXZwZDoxOworCXU4ICAgICAgICAgY21kX2R0OjE7CisJdTggICAgICAgICByZXNlcnZlZDE6MzsKKwl1OCAgICAgICAgIGx1bjozOworI2VuZGlmCisJdTggICAgICAgICBwYWdlX2NvZGU7CisJdTggICAgICAgICByZXNlcnZlZDI7CisJdTggICAgICAgICBhbGxvY19sZW5ndGg7CisJdTggICAgICAgICBjb250cm9sOworfTsKKworc3RydWN0IHNjc2lfaW5xdWlyeV92ZW5kb3Jfc3sKKwl1OCAgICAgICAgIHZlbmRvcl9pZFs4XTsKK307CisKK3N0cnVjdCBzY3NpX2lucXVpcnlfcHJvZGlkX3N7CisJdTggICAgICAgICBwcm9kdWN0X2lkWzE2XTsKK307CisKK3N0cnVjdCBzY3NpX2lucXVpcnlfcHJvZHJldl9zeworCXU4ICAgICAgICAgcHJvZHVjdF9yZXZbNF07Cit9OworCitzdHJ1Y3Qgc2NzaV9pbnF1aXJ5X2RhdGFfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcGVyaXBoZXJhbF9xdWFsOjM7CS8qIHBlcmlwaGVyYWwgcXVhbGlmaWVyICovCisJdTggICAgICAgICBkZXZpY2VfdHlwZTo1OwkJLyogcGVyaXBoZXJhbCBkZXZpY2UgdHlwZSAqLworCisJdTggICAgICAgICBybWI6MTsJCQkvKiByZW1vdmFibGUgbWVkaXVtIGJpdCAqLworCXU4ICAgICAgICAgZGV2aWNlX3R5cGVfbW9kOjc7CS8qIGRldmljZSB0eXBlIG1vZGlmaWVyICovCisKKwl1OCAgICAgICAgIHZlcnNpb247CisKKwl1OCAgICAgICAgIGFlbmM6MTsJCS8qIGFzeW5jIGV2ZW50IG5vdGlmaWNhdGlvbiBjYXBhYmlsaXR5CisJCQkJCSAqLworCXU4ICAgICAgICAgdHJtX2lvcDoxOwkvKiB0ZXJtaW5hdGUgSS9PIHByb2Nlc3MgKi8KKwl1OCAgICAgICAgIG5vcm1fYWNhOjE7CS8qIG5vcm1hbCBBQ0Egc3VwcG9ydGVkICovCisJdTggICAgICAgICBoaV9zdXBwb3J0OjE7CS8qIFNDU0ktMzogc3VwcG9ydHMgUkVQT1JUIExVTlMgKi8KKwl1OCAgICAgICAgIHJzcF9kYXRhX2Zvcm1hdDo0OworCisJdTggICAgICAgICBhZGRpdGlvbmFsX2xlbjsKKwl1OCAgICAgICAgIHNjY3M6MTsKKwl1OCAgICAgICAgIHJlc2VydmVkMTo3OworCisJdTggICAgICAgICByZXNlcnZlZDI6MTsKKwl1OCAgICAgICAgIGVuY19zZXJ2OjE7CS8qIGVuY2xvc3VyZSBzZXJ2aWNlIGNvbXBvbmVudCAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQzOjE7CisJdTggICAgICAgICBtdWx0aV9wb3J0OjE7CS8qIG11bHRpLXBvcnQgZGV2aWNlICovCisJdTggICAgICAgICBtX2NobmdyOjE7CS8qIGRldmljZSBpbiBtZWRpdW0gdHJhbnNwb3J0IGVsZW1lbnQgKi8KKwl1OCAgICAgICAgIGFja19yZXFfcToxOwkvKiBTSVAgc3BlY2lmaWMgYml0ICovCisJdTggICAgICAgICBhZGRyMzI6MTsJLyogU0lQIHNwZWNpZmljIGJpdCAqLworCXU4ICAgICAgICAgYWRkcjE2OjE7CS8qIFNJUCBzcGVjaWZpYyBiaXQgKi8KKworCXU4ICAgICAgICAgcmVsX2FkcjoxOwkvKiByZWxhdGl2ZSBhZGRyZXNzICovCisJdTggICAgICAgICB3X2J1czMyOjE7CisJdTggICAgICAgICB3X2J1czE2OjE7CisJdTggICAgICAgICBzeW5jaHJvbm91czoxOworCXU4ICAgICAgICAgbGlua2VkX2NvbW1hbmRzOjE7CisJdTggICAgICAgICB0cmFuc19kaXM6MTsKKwl1OCAgICAgICAgIGNtZF9xdWV1ZToxOwkvKiBjb21tYW5kIHF1ZXVlaW5nIHN1cHBvcnRlZCAqLworCXU4ICAgICAgICAgc29mdF9yZXNldDoxOwkvKiBzb2Z0IHJlc2V0IGFsdGVybmF0aXZlIChWUykgKi8KKyNlbHNlCisJdTggICAgICAgICBkZXZpY2VfdHlwZTo1OwkvKiBwZXJpcGhlcmFsIGRldmljZSB0eXBlICovCisJdTggICAgICAgICBwZXJpcGhlcmFsX3F1YWw6MzsKKwkJCQkJLyogcGVyaXBoZXJhbCBxdWFsaWZpZXIgKi8KKworCXU4ICAgICAgICAgZGV2aWNlX3R5cGVfbW9kOjc7CisJCQkJCS8qIGRldmljZSB0eXBlIG1vZGlmaWVyICovCisJdTggICAgICAgICBybWI6MTsJCS8qIHJlbW92YWJsZSBtZWRpdW0gYml0ICovCisKKwl1OCAgICAgICAgIHZlcnNpb247CisKKwl1OCAgICAgICAgIHJzcF9kYXRhX2Zvcm1hdDo0OworCXU4ICAgICAgICAgaGlfc3VwcG9ydDoxOwkvKiBTQ1NJLTM6IHN1cHBvcnRzIFJFUE9SVCBMVU5TICovCisJdTggICAgICAgICBub3JtX2FjYToxOwkvKiBub3JtYWwgQUNBIHN1cHBvcnRlZCAqLworCXU4ICAgICAgICAgdGVybWluYXRlX2lvcDoxOy8qIHRlcm1pbmF0ZSBJL08gcHJvY2VzcyAqLworCXU4ICAgICAgICAgYWVuYzoxOwkJLyogYXN5bmMgZXZlbnQgbm90aWZpY2F0aW9uIGNhcGFiaWxpdHkKKwkJCQkJICovCisKKwl1OCAgICAgICAgIGFkZGl0aW9uYWxfbGVuOworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjc7CisJdTggICAgICAgICBzY2NzOjE7CisKKwl1OCAgICAgICAgIGFkZHIxNjoxOwkvKiBTSVAgc3BlY2lmaWMgYml0ICovCisJdTggICAgICAgICBhZGRyMzI6MTsJLyogU0lQIHNwZWNpZmljIGJpdCAqLworCXU4ICAgICAgICAgYWNrX3JlcV9xOjE7CS8qIFNJUCBzcGVjaWZpYyBiaXQgKi8KKwl1OCAgICAgICAgIG1fY2huZ3I6MTsJLyogZGV2aWNlIGluIG1lZGl1bSB0cmFuc3BvcnQgZWxlbWVudCAqLworCXU4ICAgICAgICAgbXVsdGlfcG9ydDoxOwkvKiBtdWx0aS1wb3J0IGRldmljZSAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQzOjE7CS8qIFRCRCAtIFZlbmRvciBTcGVjaWZpYyAqLworCXU4ICAgICAgICAgZW5jX3NlcnY6MTsJLyogZW5jbG9zdXJlIHNlcnZpY2UgY29tcG9uZW50ICovCisJdTggICAgICAgICByZXNlcnZlZDI6MTsKKworCXU4ICAgICAgICAgc29mdF9zZXNldDoxOwkvKiBzb2Z0IHJlc2V0IGFsdGVybmF0aXZlIChWUykgKi8KKwl1OCAgICAgICAgIGNtZF9xdWV1ZToxOwkvKiBjb21tYW5kIHF1ZXVlaW5nIHN1cHBvcnRlZCAqLworCXU4ICAgICAgICAgdHJhbnNfZGlzOjE7CisJdTggICAgICAgICBsaW5rZWRfY29tbWFuZHM6MTsKKwl1OCAgICAgICAgIHN5bmNocm9ub3VzOjE7CisJdTggICAgICAgICB3X2J1czE2OjE7CisJdTggICAgICAgICB3X2J1czMyOjE7CisJdTggICAgICAgICByZWxfYWRyOjE7CS8qIHJlbGF0aXZlIGFkZHJlc3MgKi8KKyNlbmRpZgorCXN0cnVjdCBzY3NpX2lucXVpcnlfdmVuZG9yX3MgdmVuZG9yX2lkOworCXN0cnVjdCBzY3NpX2lucXVpcnlfcHJvZGlkX3MgcHJvZHVjdF9pZDsKKwlzdHJ1Y3Qgc2NzaV9pbnF1aXJ5X3Byb2RyZXZfcyBwcm9kdWN0X3JldjsKKwl1OCAgICAgICAgIHZlbmRvcl9zcGVjaWZpY1syMF07CisJdTggICAgICAgICByZXNlcnZlZDRbNDBdOworfTsKKworLyoKKyAqIGlucXVpcnkucGVyaXBoZXJhbF9xdWFsIGZpZWxkIHZhbHVlcworICovCisjZGVmaW5lIFNDU0lfREVWUVVBTF9ERUZBVUxUICAgICAgICAwCisjZGVmaW5lIFNDU0lfREVWUVVBTF9OT1RfQ09OTkVDVEVEICAxCisjZGVmaW5lIFNDU0lfREVWUVVBTF9OT1RfU1VQUE9SVEVEICAzCisKKy8qCisgKiBpbnF1aXJ5LmRldmljZV90eXBlIGZpZWxkIHZhbHVlcworICovCisjZGVmaW5lIFNDU0lfREVWSUNFX0RJUkVDVF9BQ0NFU1MgICAgICAgMHgwMAorI2RlZmluZSBTQ1NJX0RFVklDRV9TRVFfQUNDRVNTICAgICAgICAgIDB4MDEKKyNkZWZpbmUgU0NTSV9ERVZJQ0VfQVJSQVlfQ09OVFJPTExFUiAgICAweDBDCisjZGVmaW5lIFNDU0lfREVWSUNFX1VOS05PV04gICAgICAgICAgICAgMHgxRgorCisvKgorICogaW5xdWlyeS52ZXJzaW9uCisgKi8KKyNkZWZpbmUgU0NTSV9WRVJTSU9OX0FOU0lfWDMxMzEgICAgIDIJLyogQU5TSSBYMy4xMzEgU0NTSS0yICovCisjZGVmaW5lIFNDU0lfVkVSU0lPTl9TUEMgICAgICAgICAgICAzCS8qIFNQQyAoU0NTSS0zKSwgQU5TSSBYMy4zMDE6MTk5NyAqLworI2RlZmluZSBTQ1NJX1ZFUlNJT05fU1BDXzIgICAgICAgICAgNAkvKiBTUEMtMiAqLworCisvKgorICogcmVzcG9uc2UgZGF0YSBmb3JtYXQKKyAqLworI2RlZmluZSBTQ1NJX1JTUF9EQVRBX0ZPUk1BVCAgICAgICAgMgkvKiBTQ1NJLTIgJiBTUEMgKi8KKworLyoKKyAqIFNDU0kgaW5xdWlyeSBwYWdlIGNvZGVzCisgKi8KKyNkZWZpbmUgU0NTSV9JTlFfUEFHRV9WUERfUEFHRVMgICAgIDB4MDAJLyogc3VwcG9ydGVkIHZwZCBwYWdlcyAqLworI2RlZmluZSBTQ1NJX0lOUV9QQUdFX1VTTl9QQUdFICAgICAgMHg4MAkvKiB1bml0IHNlcmlhbCBudW1iZXIgcGFnZSAqLworI2RlZmluZSBTQ1NJX0lOUV9QQUdFX0RFVl9JREVOVCAgICAgMHg4MwkvKiBkZXZpY2UgaW5kZW50aWZpY2F0aW9uIHBhZ2UKKwkJCQkJCSAqLworI2RlZmluZSBTQ1NJX0lOUV9QQUdFU19NQVggICAgICAgICAgMworCisvKgorICogc3VwcG9ydGVkIHZpdGFsIHByb2R1Y3QgZGF0YSBwYWdlcworICovCitzdHJ1Y3Qgc2NzaV9pbnFfcGFnZV92cGRfcGFnZXNfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcGVyaXBoZXJhbF9xdWFsOjM7CisJdTggICAgICAgICBkZXZpY2VfdHlwZTo1OworI2Vsc2UKKwl1OCAgICAgICAgIGRldmljZV90eXBlOjU7CisJdTggICAgICAgICBwZXJpcGhlcmFsX3F1YWw6MzsKKyNlbmRpZgorCXU4ICAgICAgICAgcGFnZV9jb2RlOworCXU4ICAgICAgICAgcmVzZXJ2ZWQ7CisJdTggICAgICAgICBwYWdlX2xlbmd0aDsKKwl1OCAgICAgICAgIHBhZ2VzW1NDU0lfSU5RX1BBR0VTX01BWF07Cit9OworCisvKgorICogVW5pdCBzZXJpYWwgbnVtYmVyIHBhZ2UKKyAqLworI2RlZmluZSBTQ1NJX0lOUV9VU05fTEVOIDMyCisKK3N0cnVjdCBzY3NpX2lucV91c25fc3sKKwljaGFyICAgICAgICAgICAgdXNuW1NDU0lfSU5RX1VTTl9MRU5dOworfTsKKworc3RydWN0IHNjc2lfaW5xX3BhZ2VfdXNuX3N7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHBlcmlwaGVyYWxfcXVhbDozOworCXU4ICAgICAgICAgZGV2aWNlX3R5cGU6NTsKKyNlbHNlCisJdTggICAgICAgICBkZXZpY2VfdHlwZTo1OworCXU4ICAgICAgICAgcGVyaXBoZXJhbF9xdWFsOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIHBhZ2VfY29kZTsKKwl1OCAgICAgICAgIHJlc2VydmVkMTsKKwl1OCAgICAgICAgIHBhZ2VfbGVuZ3RoOworCXN0cnVjdCBzY3NpX2lucV91c25fcyAgdXNuOworfTsKKworZW51bSB7CisJU0NTSV9JTlFfRElQX0NPREVfQklOQVJZID0gMSwJLyogaWRlbnRpZmllciBoYXMgYmluYXJ5IHZhbHVlICovCisJU0NTSV9JTlFfRElQX0NPREVfQVNDSUkgPSAyLAkvKiBpZGVudGlmaWVyIGhhcyBhc2NpaSB2YWx1ZSAqLworfTsKKworZW51bSB7CisJU0NTSV9JTlFfRElQX0FTU09DX0xVTiA9IDAsCS8qIGlkIGlzIGFzc29jaWF0ZWQgd2l0aCBkZXZpY2UgKi8KKwlTQ1NJX0lOUV9ESVBfQVNTT0NfUE9SVCA9IDEsCS8qIGlkIGlzIGFzc29jaWF0ZWQgd2l0aCBwb3J0IHRoYXQKKwkJCQkJICogcmVjZWl2ZWQgdGhlIHJlcXVlc3QKKwkJCQkJICovCit9OworCitlbnVtIHsKKwlTQ1NJX0lOUV9JRF9UWVBFX1ZFTkRPUiA9IDEsCisJU0NTSV9JTlFfSURfVFlQRV9JRUVFID0gMiwKKwlTQ1NJX0lOUV9JRF9UWVBFX0ZDX0ZTID0gMywKKwlTQ1NJX0lOUV9JRF9UWVBFX09USEVSID0gNCwKK307CisKK3N0cnVjdCBzY3NpX2lucV9kaXBfZGVzY19zeworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICByZXMwOjQ7CisJdTggICAgICAgICBjb2RlX3NldDo0OworCXU4ICAgICAgICAgcmVzMToyOworCXU4ICAgICAgICAgYXNzb2NpYXRpb246MjsKKwl1OCAgICAgICAgIGlkX3R5cGU6NDsKKyNlbHNlCisJdTggICAgICAgICBjb2RlX3NldDo0OworCXU4ICAgICAgICAgcmVzMDo0OworCXU4ICAgICAgICAgaWRfdHlwZTo0OworCXU4ICAgICAgICAgYXNzb2NpYXRpb246MjsKKwl1OCAgICAgICAgIHJlczE6MjsKKyNlbmRpZgorCXU4ICAgICAgICAgcmVzMjsKKwl1OCAgICAgICAgIGlkX2xlbjsKKwlzdHJ1Y3Qgc2NzaV9sdW5fc25fcyAgIGlkOworfTsKKworLyoKKyAqIERldmljZSBpbmRlbnRpZmljYXRpb24gcGFnZQorICovCitzdHJ1Y3Qgc2NzaV9pbnFfcGFnZV9kZXZfaWRlbnRfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcGVyaXBoZXJhbF9xdWFsOjM7CisJdTggICAgICAgICBkZXZpY2VfdHlwZTo1OworI2Vsc2UKKwl1OCAgICAgICAgIGRldmljZV90eXBlOjU7CisJdTggICAgICAgICBwZXJpcGhlcmFsX3F1YWw6MzsKKyNlbmRpZgorCXU4ICAgICAgICAgcGFnZV9jb2RlOworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOworCXU4ICAgICAgICAgcGFnZV9sZW5ndGg7CisJc3RydWN0IHNjc2lfaW5xX2RpcF9kZXNjX3MgZGVzYzsKK307CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICogUkVBRCBDQVBBQ0lUWQorICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKi8KKworc3RydWN0IHNjc2lfcmVhZF9jYXBhY2l0eV9zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBsdW46MzsKKwl1OCAgICAgICAgIHJlc2VydmVkMTo0OworCXU4ICAgICAgICAgcmVsX2FkcjoxOworI2Vsc2UKKwl1OCAgICAgICAgIHJlbF9hZHI6MTsKKwl1OCAgICAgICAgIHJlc2VydmVkMTo0OworCXU4ICAgICAgICAgbHVuOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIGxiYTA7CS8qIE1TQiAqLworCXU4ICAgICAgICAgbGJhMTsKKwl1OCAgICAgICAgIGxiYTI7CisJdTggICAgICAgICBsYmEzOwkvKiBMU0IgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkMjsKKwl1OCAgICAgICAgIHJlc2VydmVkMzsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcmVzZXJ2ZWQ0Ojc7CisJdTggICAgICAgICBwbWk6MTsJLyogcGFydGlhbCBtZWRpdW0gaW5kaWNhdG9yICovCisjZWxzZQorCXU4ICAgICAgICAgcG1pOjE7CS8qIHBhcnRpYWwgbWVkaXVtIGluZGljYXRvciAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQ0Ojc7CisjZW5kaWYKKwl1OCAgICAgICAgIGNvbnRyb2w7Cit9OworCitzdHJ1Y3Qgc2NzaV9yZWFkX2NhcGFjaXR5X2RhdGFfc3sKKwl1MzIgICAgICAgIG1heF9sYmE7CS8qIG1heGltdW0gTEJBIGF2YWlsYWJsZSAqLworCXUzMiAgICAgICAgYmxvY2tfbGVuZ3RoOwkvKiBpbiBieXRlcyAqLworfTsKKworc3RydWN0IHNjc2lfcmVhZF9jYXBhY2l0eTE2X2RhdGFfc3sKKwl1NjQgICAgICAgIGxiYTsJLyogbWF4aW11bSBMQkEgYXZhaWxhYmxlICovCisJdTMyICAgICAgICBibG9ja19sZW5ndGg7CS8qIGluIGJ5dGVzICovCisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHJlc2VydmVkMTo0LAorCQkJcF90eXBlOjMsCisJCQlwcm90X2VuOjE7CisJdTgJCXJlc2VydmVkMjo0LAorCQkJbGJfcGJlOjQ7CS8qIGxvZ2ljYWwgYmxvY2tzIHBlciBwaHlzaWNhbCBibG9jaworCQkJCQkgKiBleHBvbmVudCAqLworCXUxNglyZXNlcnZlZDM6MiwKKwkJCWxiYV9hbGlnbjoxNDsJLyogbG93ZXN0IGFsaWduZWQgbG9naWNhbCBibG9jaworCQkJCQkgKiBhZGRyZXNzICovCisjZWxzZQorCXUxNglsYmFfYWxpZ246MTQsCS8qIGxvd2VzdCBhbGlnbmVkIGxvZ2ljYWwgYmxvY2sKKwkJCQkJICogYWRkcmVzcyAqLworCQkJcmVzZXJ2ZWQzOjI7CisJdTgJCWxiX3BiZTo0LAkvKiBsb2dpY2FsIGJsb2NrcyBwZXIgcGh5c2ljYWwgYmxvY2sKKwkJCQkJICogZXhwb25lbnQgKi8KKwkJCXJlc2VydmVkMjo0OworCXU4CQlwcm90X2VuOjEsCisJCQlwX3R5cGU6MywKKwkJCXJlc2VydmVkMTo0OworI2VuZGlmCisJdTY0CXJlc2VydmVkNDsKKwl1NjQJcmVzZXJ2ZWQ1OworfTsKKworLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKiBSRVBPUlQgTFVOUyBjb21tYW5kCisgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqLworCitzdHJ1Y3Qgc2NzaV9yZXBvcnRfbHVuc19zeworCXU4ICAgICAgICAgb3Bjb2RlOwkJLyogQTBoIC0gUkVQT1JUIExVTlMgb3BDb2RlICovCisJdTggICAgICAgICByZXNlcnZlZDFbNV07CisJdTggICAgICAgICBhbGxvY19sZW5ndGhbNF07LyogYWxsb2NhdGlvbiBsZW5ndGggTVNCIGZpcnN0ICovCisJdTggICAgICAgICByZXNlcnZlZDI7CisJdTggICAgICAgICBjb250cm9sOworfTsKKworI2RlZmluZSBTQ1NJX1JFUE9SVF9MVU5fQUxMT0NfTEVOR1RIKHJsKSAgICAgICAgICAgICAgICAJCVwKKyAgICAoKHJsLT5hbGxvY19sZW5ndGhbMF0gPDwgMjQpIHwgKHJsLT5hbGxvY19sZW5ndGhbMV0gPDwgMTYpIHwgCVwKKyAgICAgKHJsLT5hbGxvY19sZW5ndGhbMl0gPDwgOCkgfCAocmwtPmFsbG9jX2xlbmd0aFszXSkpCisKKyNkZWZpbmUgU0NTSV9SRVBPUlRfTFVOU19TRVRfQUxMT0NMRU4ocmwsIGFsbG9jX2xlbikgeyAgICAgIFwKKyAgICAocmwpLT5hbGxvY19sZW5ndGhbMF0gPSAoYWxsb2NfbGVuKSA+PiAyNDsgICAgICAJCQlcCisgICAgKHJsKS0+YWxsb2NfbGVuZ3RoWzFdID0gKChhbGxvY19sZW4pID4+IDE2KSAmIDB4RkY7IAkJXAorICAgIChybCktPmFsbG9jX2xlbmd0aFsyXSA9ICgoYWxsb2NfbGVuKSA+PiA4KSAmIDB4RkY7ICAJCVwKKyAgICAocmwpLT5hbGxvY19sZW5ndGhbM10gPSAoYWxsb2NfbGVuKSAmIDB4RkY7ICAgICAJCQlcCit9CisKK3N0cnVjdCBzY3NpX3JlcG9ydF9sdW5zX2RhdGFfc3sKKwl1MzIgICAgICAgIGx1bl9saXN0X2xlbmd0aDsJLyogbGVuZ3RoIG9mIExVTiBsaXN0IGxlbmd0aCAqLworCXUzMiAgICAgICAgcmVzZXJ2ZWQ7CisJbHVuX3QgICAgICAgICAgIGx1blsxXTsJCQkvKiBmaXJzdCBMVU4gaW4gbHVuIGxpc3QgKi8KK307CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqIFNDU0kgbW9kZSAgcGFyYW1ldGVycworICogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqLworZW51bSB7CisJU0NTSV9EQV9NRURJVU1fREVGID0gMCwJLyogZGlyZWN0IGFjY2VzcyBkZWZhdWx0IG1lZGl1bSB0eXBlICovCisJU0NTSV9EQV9NRURJVU1fU1MgPSAxLAkvKiBkaXJlY3QgYWNjZXNzIHNpbmdsZSBzaWRlZCAqLworCVNDU0lfREFfTUVESVVNX0RTID0gMiwJLyogZGlyZWN0IGFjY2VzcyBkb3VibGUgc2lkZWQgKi8KK307CisKKy8qCisgKiBTQ1NJIE1vZGUgU2VsZWN0KDYpIGNkYgorICovCitzdHJ1Y3Qgc2NzaV9tb2RlX3NlbGVjdDZfc3sKKwl1OCAgICAgICAgIG9wY29kZTsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjM7CisJdTggICAgICAgICBwZjoxOwkJLyogcGFnZSBmb3JtYXQgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkMjozOworCXU4ICAgICAgICAgc3A6MTsJCS8qIHNhdmUgcGFnZXMgaWYgc2V0IHRvIDEgKi8KKyNlbHNlCisJdTggICAgICAgICBzcDoxOwkvKiBzYXZlIHBhZ2VzIGlmIHNldCB0byAxICovCisJdTggICAgICAgICByZXNlcnZlZDI6MzsKKwl1OCAgICAgICAgIHBmOjE7CS8qIHBhZ2UgZm9ybWF0ICovCisJdTggICAgICAgICByZXNlcnZlZDE6MzsKKyNlbmRpZgorCXU4ICAgICAgICAgcmVzZXJ2ZWQzWzJdOworCXU4ICAgICAgICAgYWxsb2NfbGVuOworCXU4ICAgICAgICAgY29udHJvbDsKK307CisKKy8qCisgKiBTQ1NJIE1vZGUgU2VsZWN0KDEwKSBjZGIKKyAqLworc3RydWN0IHNjc2lfbW9kZV9zZWxlY3QxMF9zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICByZXNlcnZlZDE6MzsKKwl1OCAgICAgICAgIHBmOjE7CS8qIHBhZ2UgZm9ybWF0ICovCisJdTggICAgICAgICByZXNlcnZlZDI6MzsKKwl1OCAgICAgICAgIHNwOjE7CS8qIHNhdmUgcGFnZXMgaWYgc2V0IHRvIDEgKi8KKyNlbHNlCisJdTggICAgICAgICBzcDoxOwkvKiBzYXZlIHBhZ2VzIGlmIHNldCB0byAxICovCisJdTggICAgICAgICByZXNlcnZlZDI6MzsKKwl1OCAgICAgICAgIHBmOjE7CS8qIHBhZ2UgZm9ybWF0ICovCisJdTggICAgICAgICByZXNlcnZlZDE6MzsKKyNlbmRpZgorCXU4ICAgICAgICAgcmVzZXJ2ZWQzWzVdOworCXU4ICAgICAgICAgYWxsb2NfbGVuX21zYjsKKwl1OCAgICAgICAgIGFsbG9jX2xlbl9sc2I7CisJdTggICAgICAgICBjb250cm9sOworfTsKKworLyoKKyAqIFNDU0kgTW9kZSBTZW5zZSg2KSBjZGIKKyAqLworc3RydWN0IHNjc2lfbW9kZV9zZW5zZTZfc3sKKwl1OCAgICAgICAgIG9wY29kZTsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjQ7CisJdTggICAgICAgICBkYmQ6MTsJLyogZGlzYWJsZSBibG9jayBkaXNjcmlwdG9ycyBpZiBzZXQgdG8gMSAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQyOjM7CisKKwl1OCAgICAgICAgIHBjOjI7CS8qIHBhZ2UgY29udHJvbCAqLworCXU4ICAgICAgICAgcGFnZV9jb2RlOjY7CisjZWxzZQorCXU4ICAgICAgICAgcmVzZXJ2ZWQyOjM7CisJdTggICAgICAgICBkYmQ6MTsJLyogZGlzYWJsZSBibG9jayBkZXNjcmlwdG9ycyBpZiBzZXQgdG8gMSAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjQ7CisKKwl1OCAgICAgICAgIHBhZ2VfY29kZTo2OworCXU4ICAgICAgICAgcGM6MjsJLyogcGFnZSBjb250cm9sICovCisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmVkMzsKKwl1OCAgICAgICAgIGFsbG9jX2xlbjsKKwl1OCAgICAgICAgIGNvbnRyb2w7Cit9OworCisvKgorICogU0NTSSBNb2RlIFNlbnNlKDEwKSBjZGIKKyAqLworc3RydWN0IHNjc2lfbW9kZV9zZW5zZTEwX3N7CisJdTggICAgICAgICBvcGNvZGU7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHJlc2VydmVkMTozOworCXU4ICAgICAgICAgTExCQUE6MTsJLyogbG9uZyBMQkEgYWNjZXB0ZWQgaWYgc2V0IHRvIDEgKi8KKwl1OCAgICAgICAgIGRiZDoxOwkJLyogZGlzYWJsZSBibG9jayBkZXNjcmlwdG9ycyBpZiBzZXQKKwkJCQkJICogdG8gMQorCQkJCQkgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkMjozOworCisJdTggICAgICAgICBwYzoyOwkJLyogcGFnZSBjb250cm9sICovCisJdTggICAgICAgICBwYWdlX2NvZGU6NjsKKyNlbHNlCisJdTggICAgICAgICByZXNlcnZlZDI6MzsKKwl1OCAgICAgICAgIGRiZDoxOwkJLyogZGlzYWJsZSBibG9jayBkZXNjcmlwdG9ycyBpZiBzZXQgdG8KKwkJCQkJICogMQorCQkJCQkgKi8KKwl1OCAgICAgICAgIExMQkFBOjE7CS8qIGxvbmcgTEJBIGFjY2VwdGVkIGlmIHNldCB0byAxICovCisJdTggICAgICAgICByZXNlcnZlZDE6MzsKKworCXU4ICAgICAgICAgcGFnZV9jb2RlOjY7CisJdTggICAgICAgICBwYzoyOwkJLyogcGFnZSBjb250cm9sICovCisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmVkM1s0XTsKKwl1OCAgICAgICAgIGFsbG9jX2xlbl9tc2I7CisJdTggICAgICAgICBhbGxvY19sZW5fbHNiOworCXU4ICAgICAgICAgY29udHJvbDsKK307CisKKyNkZWZpbmUgU0NTSV9DREIxMF9HRVRfQUwoY2RiKSAgCQkJCQlcCisgICAgKChjZGIpLT5hbGxvY19sZW5fbXNiIDw8IDggfCAoY2RiKS0+YWxsb2NfbGVuX2xzYikKKworI2RlZmluZSBTQ1NJX0NEQjEwX1NFVF9BTChjZGIsIGFsKSB7ICAgICAgXAorICAgIChjZGIpLT5hbGxvY19sZW5fbXNiID0gYWwgPj4gODsgICAgICAgCQkJCVwKKyAgICAoY2RiKS0+YWxsb2NfbGVuX2xzYiA9IGFsICYgMHhGRjsgICAgIAkJCQlcCit9CisKKyNkZWZpbmUgU0NTSV9DREI2X0dFVF9BTChjZGIpICgoY2RiKS0+YWxsb2NfbGVuKQorCisjZGVmaW5lIFNDU0lfQ0RCNl9TRVRfQUwoY2RiLCBhbCkgeyAgICAgIFwKKyAgICAoY2RiKS0+YWxsb2NfbGVuID0gYWw7ICAgICAgICAgCQkJCQlcCit9CisKKy8qCisgKiBwYWdlIGNvbnRyb2wgZmllbGQgdmFsdWVzCisgKi8KKyNkZWZpbmUgU0NTSV9QQ19DVVJSRU5UX1ZBTFVFUyAgICAgICAweDAKKyNkZWZpbmUgU0NTSV9QQ19DSEFOR0VBQkxFX1ZBTFVFUyAgICAweDEKKyNkZWZpbmUgU0NTSV9QQ19ERUZBVUxUX1ZBTFVFUyAgICAgICAweDIKKyNkZWZpbmUgU0NTSV9QQ19TQVZFRF9WQUxVRVMgICAgICAgICAweDMKKworLyoKKyAqIFNDU0kgbW9kZSBwYWdlIGNvZGVzCisgKi8KKyNkZWZpbmUgU0NTSV9NUF9WRU5ET1JfU1BFQyAgICAgMHgwMAorI2RlZmluZSBTQ1NJX01QX0RJU0NfUkVDTiAgICAgICAweDAyCS8qIGRpc2Nvbm5lY3QtcmVjb25uZWN0IHBhZ2UgKi8KKyNkZWZpbmUgU0NTSV9NUF9GT1JNQVRfREVWSUNFICAgMHgwMworI2RlZmluZSBTQ1NJX01QX1JERyAgICAgICAgICAgICAweDA0CS8qIHJpZ2lkIGRpc2sgZ2VvbWV0cnkgcGFnZSAqLworI2RlZmluZSBTQ1NJX01QX0ZEUCAgICAgICAgICAgICAweDA1CS8qIGZsZXhpYmxlIGRpc2sgcGFnZSAqLworI2RlZmluZSBTQ1NJX01QX0NBQ0hJTkcgICAgICAgICAweDA4CS8qIGNhY2hpbmcgcGFnZSAqLworI2RlZmluZSBTQ1NJX01QX0NPTlRST0wgICAgICAgICAweDBBCS8qIGNvbnRyb2wgbW9kZSBwYWdlICovCisjZGVmaW5lIFNDU0lfTVBfTUVEX1RZUEVTX1NVUCAgIDB4MEIJLyogbWVkaXVtIHR5cGVzIHN1cHBvcnRlZCBwYWdlICovCisjZGVmaW5lIFNDU0lfTVBfSU5GT19FWENQX0NOVEwgIDB4MUMJLyogaW5mb3JtYXRpb25hbCBleGNlcHRpb24gY29udHJvbCAqLworI2RlZmluZSBTQ1NJX01QX0FMTCAgICAgICAgICAgICAweDNGCS8qIHJldHVybiBhbGwgcGFnZXMgLSBtb2RlIHNlbnNlIG9ubHkgKi8KKworLyoKKyAqIG1vZGUgcGFyYW1ldGVyIGhlYWRlcgorICovCitzdHJ1Y3Qgc2NzaV9tb2RlX3BhcmFtX2hlYWRlcjZfc3sKKwl1OCAgICAgICAgIG1vZGVfZGF0YWxlbjsKKwl1OCAgICAgICAgIG1lZGl1bV90eXBlOworCisJLyoKKwkgKiBkZXZpY2Ugc3BlY2lmaWMgcGFyYW1ldGVycyBleHBhbmRlZCBmb3IgZGlyZWN0IGFjY2VzcyBkZXZpY2VzCisJICovCisjaWZkZWYgX19CSUdFTkRJQU4KKwl1MzIgICAgICAgIHdwOjE7CQkvKiB3cml0ZSBwcm90ZWN0ZWQgKi8KKwl1MzIgICAgICAgIHJlc2VydmVkMToyOworCXUzMiAgICAgICAgZHBvZnVhOjE7CS8qIGRpc2FibGUgcGFnZSBvdXQgKyBmb3JjZSB1bml0IGFjY2VzcworCQkJCQkgKi8KKwl1MzIgICAgICAgIHJlc2VydmVkMjo0OworI2Vsc2UKKwl1MzIgICAgICAgIHJlc2VydmVkMjo0OworCXUzMiAgICAgICAgZHBvZnVhOjE7CS8qIGRpc2FibGUgcGFnZSBvdXQgKyBmb3JjZSB1bml0IGFjY2VzcworCQkJCQkgKi8KKwl1MzIgICAgICAgIHJlc2VydmVkMToyOworCXUzMiAgICAgICAgd3A6MTsJCS8qIHdyaXRlIHByb3RlY3RlZCAqLworI2VuZGlmCisKKwl1OCAgICAgICAgIGJsb2NrX2Rlc2NsZW47Cit9OworCitzdHJ1Y3Qgc2NzaV9tb2RlX3BhcmFtX2hlYWRlcjEwX3N7CisJdTMyICAgICAgICBtb2RlX2RhdGFsZW46MTY7CisJdTMyICAgICAgICBtZWRpdW1fdHlwZTo4OworCisJLyoKKwkgKiBkZXZpY2Ugc3BlY2lmaWMgcGFyYW1ldGVycyBleHBhbmRlZCBmb3IgZGlyZWN0IGFjY2VzcyBkZXZpY2VzCisJICovCisjaWZkZWYgX19CSUdFTkRJQU4KKwl1MzIgICAgICAgIHdwOjE7CQkvKiB3cml0ZSBwcm90ZWN0ZWQgKi8KKwl1MzIgICAgICAgIHJlc2VydmVkMToyOworCXUzMiAgICAgICAgZHBvZnVhOjE7CS8qIGRpc2FibGUgcGFnZSBvdXQgKyBmb3JjZSB1bml0IGFjY2VzcworCQkJCQkgKi8KKwl1MzIgICAgICAgIHJlc2VydmVkMjo0OworI2Vsc2UKKwl1MzIgICAgICAgIHJlc2VydmVkMjo0OworCXUzMiAgICAgICAgZHBvZnVhOjE7CS8qIGRpc2FibGUgcGFnZSBvdXQgKyBmb3JjZSB1bml0IGFjY2VzcworCQkJCQkgKi8KKwl1MzIgICAgICAgIHJlc2VydmVkMToyOworCXUzMiAgICAgICAgd3A6MTsJCS8qIHdyaXRlIHByb3RlY3RlZCAqLworI2VuZGlmCisKKyNpZmRlZiBfX0JJR0VORElBTgorCXUzMiAgICAgICAgcmVzZXJ2ZWQzOjc7CisJdTMyICAgICAgICBsb25nbGJhOjE7CisjZWxzZQorCXUzMiAgICAgICAgbG9uZ2xiYToxOworCXUzMiAgICAgICAgcmVzZXJ2ZWQzOjc7CisjZW5kaWYKKwl1MzIgICAgICAgIHJlc2VydmVkNDo4OworCXUzMiAgICAgICAgYmxvY2tfZGVzY2xlbjoxNjsKK307CisKKy8qCisgKiBtb2RlIHBhcmFtZXRlciBibG9jayBkZXNjcmlwdG9yCisgKi8KK3N0cnVjdCBzY3NpX21vZGVfcGFyYW1fZGVzY19zeworCXUzMiAgICAgICAgbmJsa3M7CisJdTMyICAgICAgICBkZW5zaXR5X2NvZGU6ODsKKwl1MzIgICAgICAgIGJsb2NrX2xlbmd0aDoyNDsKK307CisKKy8qCisgKiBEaXNjb25uZWN0LXJlY29ubmVjdCBtb2RlIHBhZ2UgZm9ybWF0CisgKi8KK3N0cnVjdCBzY3NpX21wX2Rpc2NfcmVjbl9zeworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBwczoxOworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjE7CisJdTggICAgICAgICBwYWdlX2NvZGU6NjsKKyNlbHNlCisJdTggICAgICAgICBwYWdlX2NvZGU6NjsKKwl1OCAgICAgICAgIHJlc2VydmVkMToxOworCXU4ICAgICAgICAgcHM6MTsKKyNlbmRpZgorCXU4ICAgICAgICAgcGFnZV9sZW47CisJdTggICAgICAgICBidWZfZnVsbF9yYXRpbzsKKwl1OCAgICAgICAgIGJ1Zl9lbXB0eV9yYXRpbzsKKworCXU4ICAgICAgICAgYmlsX21zYjsJLyogYnVzIGluYWN0aXZpdHkgbGltaXQgLU1TQiAqLworCXU4ICAgICAgICAgYmlsX2xzYjsJLyogYnVzIGluYWN0aXZpdHkgbGltaXQgLUxTQiAqLworCisJdTggICAgICAgICBkdGxfbXNiOwkvKiBkaXNjb25uZWN0IHRpbWUgbGltaXQgLSBNU0IgKi8KKwl1OCAgICAgICAgIGR0bF9sc2I7CS8qIGRpc2Nvbm5lY3QgdGltZSBsaW1pdCAtIExTQiAqLworCisJdTggICAgICAgICBjdGxfbXNiOwkvKiBjb25uZWN0IHRpbWUgbGltaXQgLSBNU0IgKi8KKwl1OCAgICAgICAgIGN0bF9sc2I7CS8qIGNvbm5lY3QgdGltZSBsaW1pdCAtIExTQiAqLworCisJdTggICAgICAgICBtYXhfYnVyc3RfbGVuX21zYjsKKwl1OCAgICAgICAgIG1heF9idXJzdF9sZW5fbHNiOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBlbWRwOjE7CS8qIGVuYWJsZSBtb2RpZnkgZGF0YSBwb2ludGVycyAqLworCXU4ICAgICAgICAgZmE6MzsJLyogZmFpciBhcmJpdHJhdGlvbiAqLworCXU4ICAgICAgICAgZGltbToxOwkvKiBkaXNjb25uZWN0IGltbWVkaWF0ZSAqLworCXU4ICAgICAgICAgZHRkYzozOwkvKiBkYXRhIHRyYW5zZmVyIGRpc2Nvbm5lY3QgY29udHJvbCAqLworI2Vsc2UKKwl1OCAgICAgICAgIGR0ZGM6MzsJLyogZGF0YSB0cmFuc2ZlciBkaXNjb25uZWN0IGNvbnRyb2wgKi8KKwl1OCAgICAgICAgIGRpbW06MTsJLyogZGlzY29ubmVjdCBpbW1lZGlhdGUgKi8KKwl1OCAgICAgICAgIGZhOjM7CS8qIGZhaXIgYXJiaXRyYXRpb24gKi8KKwl1OCAgICAgICAgIGVtZHA6MTsJLyogZW5hYmxlIG1vZGlmeSBkYXRhIHBvaW50ZXJzICovCisjZW5kaWYKKworCXU4ICAgICAgICAgcmVzZXJ2ZWQzOworCisJdTggICAgICAgICBmaXJzdF9idXJzdF9sZW5fbXNiOworCXU4ICAgICAgICAgZmlyc3RfYnVyc3RfbGVuX2xzYjsKK307CisKKy8qCisgKiBTQ1NJIGZvcm1hdCBkZXZpY2UgbW9kZSBwYWdlCisgKi8KK3N0cnVjdCBzY3NpX21wX2Zvcm1hdF9kZXZpY2Vfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXUzMiAgICAgICAgcHM6MTsKKwl1MzIgICAgICAgIHJlc2VydmVkMToxOworCXUzMiAgICAgICAgcGFnZV9jb2RlOjY7CisjZWxzZQorCXUzMiAgICAgICAgcGFnZV9jb2RlOjY7CisJdTMyICAgICAgICByZXNlcnZlZDE6MTsKKwl1MzIgICAgICAgIHBzOjE7CisjZW5kaWYKKwl1MzIgICAgICAgIHBhZ2VfbGVuOjg7CisJdTMyICAgICAgICB0cmFja3NfcGVyX3pvbmU6MTY7CisKKwl1MzIgICAgICAgIGFfc2VjX3Blcl96b25lOjE2OworCXUzMiAgICAgICAgYV90cmFja3NfcGVyX3pvbmU6MTY7CisKKwl1MzIgICAgICAgIGFfdHJhY2tzX3Blcl9sdW46MTY7CS8qIGFsdGVybmF0ZSB0cmFja3MvbHVuLU1TQiAqLworCXUzMiAgICAgICAgc2VjX3Blcl90cmFjazoxNjsJLyogc2VjdG9ycy90cmFjay1NU0IgKi8KKworCXUzMiAgICAgICAgYnl0ZXNfcGVyX3NlY3RvcjoxNjsKKwl1MzIgICAgICAgIGludGVybGVhdmU6MTY7CisKKwl1MzIgICAgICAgIHRzZjoxNjsJCQkvKiB0cmFjayBza2V3IGZhY3Rvci1NU0IgKi8KKwl1MzIgICAgICAgIGNzZjoxNjsJCQkvKiBjeWxpbmRlciBza2V3IGZhY3Rvci1NU0IgKi8KKworI2lmZGVmIF9fQklHRU5ESUFOCisJdTMyICAgICAgICBzc2VjOjE7CS8qIHNvZnQgc2VjdG9yIGZvcm1hdHRpbmcgKi8KKwl1MzIgICAgICAgIGhzZWM6MTsJLyogaGFyZCBzZWN0b3IgZm9ybWF0dGluZyAqLworCXUzMiAgICAgICAgcm1iOjE7CS8qIHJlbW92YWJsZSBtZWRpYSAqLworCXUzMiAgICAgICAgc3VyZjoxOwkvKiBzdXJmYWNlICovCisJdTMyICAgICAgICByZXNlcnZlZDI6NDsKKyNlbHNlCisJdTMyICAgICAgICByZXNlcnZlZDI6NDsKKwl1MzIgICAgICAgIHN1cmY6MTsJLyogc3VyZmFjZSAqLworCXUzMiAgICAgICAgcm1iOjE7CS8qIHJlbW92YWJsZSBtZWRpYSAqLworCXUzMiAgICAgICAgaHNlYzoxOwkvKiBoYXJkIHNlY3RvciBmb3JtYXR0aW5nICovCisJdTMyICAgICAgICBzc2VjOjE7CS8qIHNvZnQgc2VjdG9yIGZvcm1hdHRpbmcgKi8KKyNlbmRpZgorCXUzMiAgICAgICAgcmVzZXJ2ZWQzOjI0OworfTsKKworLyoKKyAqIFNDU0kgcmlnaWQgZGlzayBkZXZpY2UgZ2VvbWV0cnkgcGFnZQorICovCitzdHJ1Y3Qgc2NzaV9tcF9yaWdpZF9kZXZpY2VfZ2VvbWV0cnlfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXUzMiAgICAgICAgcHM6MTsKKwl1MzIgICAgICAgIHJlc2VydmVkMToxOworCXUzMiAgICAgICAgcGFnZV9jb2RlOjY7CisjZWxzZQorCXUzMiAgICAgICAgcGFnZV9jb2RlOjY7CisJdTMyICAgICAgICByZXNlcnZlZDE6MTsKKwl1MzIgICAgICAgIHBzOjE7CisjZW5kaWYKKwl1MzIgICAgICAgIHBhZ2VfbGVuOjg7CisJdTMyICAgICAgICBudW1fY3lsaW5kZXJzMDo4OworCXUzMiAgICAgICAgbnVtX2N5bGluZGVyczE6ODsKKworCXUzMiAgICAgICAgbnVtX2N5bGluZGVyczI6ODsKKwl1MzIgICAgICAgIG51bV9oZWFkczo4OworCXUzMiAgICAgICAgc2N3cDA6ODsKKwl1MzIgICAgICAgIHNjd3AxOjg7CisKKwl1MzIgICAgICAgIHNjd3AyOjg7CisJdTMyICAgICAgICBzY3J3YzA6ODsKKwl1MzIgICAgICAgIHNjcndjMTo4OworCXUzMiAgICAgICAgc2Nyd2MyOjg7CisKKwl1MzIgICAgICAgIGRzcjoxNjsKKwl1MzIgICAgICAgIGxzY3lsMDo4OworCXUzMiAgICAgICAgbHNjeWwxOjg7CisKKwl1MzIgICAgICAgIGxzY3lsMjo4OworI2lmZGVmIF9fQklHRU5ESUFOCisJdTMyICAgICAgICByZXNlcnZlZDI6NjsKKwl1MzIgICAgICAgIHJwbDoyOwkvKiByb3RhdGlvbmFsIHBvc2l0aW9uIGxvY2tpbmcgKi8KKyNlbHNlCisJdTMyICAgICAgICBycGw6MjsJLyogcm90YXRpb25hbCBwb3NpdGlvbiBsb2NraW5nICovCisJdTMyICAgICAgICByZXNlcnZlZDI6NjsKKyNlbmRpZgorCXUzMiAgICAgICAgcm90X29mZjo4OworCXUzMiAgICAgICAgcmVzZXJ2ZWQzOjg7CisKKwl1MzIgICAgICAgIG1lZF9yb3RfcmF0ZToxNjsKKwl1MzIgICAgICAgIHJlc2VydmVkNDoxNjsKK307CisKKy8qCisgKiBTQ1NJIGNhY2hpbmcgbW9kZSBwYWdlCisgKi8KK3N0cnVjdCBzY3NpX21wX2NhY2hpbmdfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcHM6MTsKKwl1OCAgICAgICAgIHJlczE6MTsKKwl1OCAgICAgICAgIHBhZ2VfY29kZTo2OworI2Vsc2UKKwl1OCAgICAgICAgIHBhZ2VfY29kZTo2OworCXU4ICAgICAgICAgcmVzMToxOworCXU4ICAgICAgICAgcHM6MTsKKyNlbmRpZgorCXU4ICAgICAgICAgcGFnZV9sZW47CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIGljOjE7CS8qIGluaXRpYXRvciBjb250cm9sICovCisJdTggICAgICAgICBhYnBmOjE7CS8qIGFib3J0IHByZS1mZXRjaCAqLworCXU4ICAgICAgICAgY2FwOjE7CS8qIGNhY2hpbmcgYW5hbHlzaXMgcGVybWl0dGVkICovCisJdTggICAgICAgICBkaXNjOjE7CS8qIGRpc2NvbnRpbnVpdHkgKi8KKwl1OCAgICAgICAgIHNpemU6MTsJLyogc2l6ZSBlbmFibGUgKi8KKwl1OCAgICAgICAgIHdjZToxOwkvKiB3cml0ZSBjYWNoZSBlbmFibGUgKi8KKwl1OCAgICAgICAgIG1mOjE7CS8qIG11bHRpcGxpY2F0aW9uIGZhY3RvciAqLworCXU4ICAgICAgICAgcmNkOjE7CS8qIHJlYWQgY2FjaGUgZGlzYWJsZSAqLworCisJdTggICAgICAgICBkcnJwOjQ7CS8qIGRlbWFuZCByZWFkIHJldGVudGlvbiBwcmlvcml0eSAqLworCXU4ICAgICAgICAgd3JwOjQ7CS8qIHdyaXRlIHJldGVudGlvbiBwcmlvcml0eSAqLworI2Vsc2UKKwl1OCAgICAgICAgIHJjZDoxOwkvKiByZWFkIGNhY2hlIGRpc2FibGUgKi8KKwl1OCAgICAgICAgIG1mOjE7CS8qIG11bHRpcGxpY2F0aW9uIGZhY3RvciAqLworCXU4ICAgICAgICAgd2NlOjE7CS8qIHdyaXRlIGNhY2hlIGVuYWJsZSAqLworCXU4ICAgICAgICAgc2l6ZToxOwkvKiBzaXplIGVuYWJsZSAqLworCXU4ICAgICAgICAgZGlzYzoxOwkvKiBkaXNjb250aW51aXR5ICovCisJdTggICAgICAgICBjYXA6MTsJLyogY2FjaGluZyBhbmFseXNpcyBwZXJtaXR0ZWQgKi8KKwl1OCAgICAgICAgIGFicGY6MTsJLyogYWJvcnQgcHJlLWZldGNoICovCisJdTggICAgICAgICBpYzoxOwkvKiBpbml0aWF0b3IgY29udHJvbCAqLworCisJdTggICAgICAgICB3cnA6NDsJLyogd3JpdGUgcmV0ZW50aW9uIHByaW9yaXR5ICovCisJdTggICAgICAgICBkcnJwOjQ7CS8qIGRlbWFuZCByZWFkIHJldGVudGlvbiBwcmlvcml0eSAqLworI2VuZGlmCisJdTggICAgICAgICBkcHRsWzJdOy8qIGRpc2FibGUgcHJlLWZldGNoIHRyYW5zZmVyIGxlbmd0aCAqLworCXU4ICAgICAgICAgbWluX3ByZWZldGNoWzJdOworCXU4ICAgICAgICAgbWF4X3ByZWZldGNoWzJdOworCXU4ICAgICAgICAgbWF4X3ByZWZldGNoX2xpbWl0WzJdOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBmc3c6MTsJLyogZm9yY2Ugc2VxdWVudGlhbCB3cml0ZSAqLworCXU4ICAgICAgICAgbGJjc3M6MTsvKiBsb2dpY2FsIGJsb2NrIGNhY2hlIHNlZ21lbnQgc2l6ZSAqLworCXU4ICAgICAgICAgZHJhOjE7CS8qIGRpc2FibGUgcmVhZCBhaGVhZCAqLworCXU4ICAgICAgICAgdnM6MjsJLyogdmVuZG9yIHNwZWNpZmljICovCisJdTggICAgICAgICByZXMyOjM7CisjZWxzZQorCXU4ICAgICAgICAgcmVzMjozOworCXU4ICAgICAgICAgdnM6MjsJLyogdmVuZG9yIHNwZWNpZmljICovCisJdTggICAgICAgICBkcmE6MTsJLyogZGlzYWJsZSByZWFkIGFoZWFkICovCisJdTggICAgICAgICBsYmNzczoxOy8qIGxvZ2ljYWwgYmxvY2sgY2FjaGUgc2VnbWVudCBzaXplICovCisJdTggICAgICAgICBmc3c6MTsJLyogZm9yY2Ugc2VxdWVudGlhbCB3cml0ZSAqLworI2VuZGlmCisJdTggICAgICAgICBudW1fY2FjaGVfc2VnczsKKworCXU4ICAgICAgICAgY2FjaGVfc2VnX3NpemVbMl07CisJdTggICAgICAgICByZXMzOworCXU4ICAgICAgICAgbm9uX2NhY2hlX3NlZ19zaXplWzNdOworfTsKKworLyoKKyAqIFNDU0kgY29udHJvbCBtb2RlIHBhZ2UKKyAqLworc3RydWN0IHNjc2lfbXBfY29udHJvbF9wYWdlX3N7CisjaWZkZWYgX19CSUdFTkRJQU4KK3U4ICAgICAgICAgcHM6MTsKK3U4ICAgICAgICAgcmVzZXJ2ZWQxOjE7Cit1OCAgICAgICAgIHBhZ2VfY29kZTo2OworI2Vsc2UKK3U4ICAgICAgICAgcGFnZV9jb2RlOjY7Cit1OCAgICAgICAgIHJlc2VydmVkMToxOwordTggICAgICAgICBwczoxOworI2VuZGlmCisJdTggICAgICAgICBwYWdlX2xlbjsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgdHN0OjM7CQkvKiB0YXNrIHNldCB0eXBlICovCisJdTggICAgICAgICByZXNlcnZlZDM6MzsKKwl1OCAgICAgICAgIGdsdHNkOjE7CS8qIGdsb2JhbCBsb2dnaW5nIHRhcmdldCBzYXZlIGRpc2FibGUgKi8KKwl1OCAgICAgICAgIHJsZWM6MTsJCS8qIHJlcG9ydCBsb2cgZXhjZXB0aW9uIGNvbmRpdGlvbiAqLworCisJdTggICAgICAgICBxYWxnb19tb2Q6NDsJLyogcXVldWUgYWxvZ29yaXRobSBtb2RpZmllciAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQ0OjE7CisJdTggICAgICAgICBxZXJyOjI7CQkvKiBxdWV1ZSBlcnJvciBtYW5hZ2VtZW50ICovCisJdTggICAgICAgICBkcXVlOjE7CQkvKiBkaXNhYmxlIHF1ZXVpbmcgKi8KKworCXU4ICAgICAgICAgcmVzZXJ2ZWQ1OjE7CisJdTggICAgICAgICByYWM6MTsJCS8qIHJlcG9ydCBhIGNoZWNrICovCisJdTggICAgICAgICByZXNlcnZlZDY6MjsKKwl1OCAgICAgICAgIHN3cDoxOwkJLyogc29mdHdhcmUgd3JpdGUgcHJvdGVjdCAqLworCXU4ICAgICAgICAgcmFlcnA6MTsJLyogcmVhZHkgQUVSIHBlcm1pc3Npb24gKi8KKwl1OCAgICAgICAgIHVhYWVycDoxOwkvKiB1bml0IGF0dGVuc3Rpb24gQUVSIHBlcm1pc3Npb24gKi8KKwl1OCAgICAgICAgIGVhZXJwOjE7CS8qIGVycm9yIEFFUiBwZXJtaXNzaW9uICovCisKKwl1OCAgICAgICAgIHJlc2VydmVkNzo1OworCXU4ICAgICAgICAgYXV0b2xvYWRfbW9kOjM7CisjZWxzZQorCXU4ICAgICAgICAgcmxlYzoxOwkJLyogcmVwb3J0IGxvZyBleGNlcHRpb24gY29uZGl0aW9uICovCisJdTggICAgICAgICBnbHRzZDoxOwkvKiBnbG9iYWwgbG9nZ2luZyB0YXJnZXQgc2F2ZSBkaXNhYmxlICovCisJdTggICAgICAgICByZXNlcnZlZDM6MzsKKwl1OCAgICAgICAgIHRzdDozOwkJLyogdGFzayBzZXQgdHlwZSAqLworCisJdTggICAgICAgICBkcXVlOjE7CQkvKiBkaXNhYmxlIHF1ZXVpbmcgKi8KKwl1OCAgICAgICAgIHFlcnI6MjsJCS8qIHF1ZXVlIGVycm9yIG1hbmFnZW1lbnQgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkNDoxOworCXU4ICAgICAgICAgcWFsZ29fbW9kOjQ7CS8qIHF1ZXVlIGFsb2dvcml0aG0gbW9kaWZpZXIgKi8KKworCXU4ICAgICAgICAgZWFlcnA6MTsJLyogZXJyb3IgQUVSIHBlcm1pc3Npb24gKi8KKwl1OCAgICAgICAgIHVhYWVycDoxOwkvKiB1bml0IGF0dGVuc3Rpb24gQUVSIHBlcm1pc3Npb24gKi8KKwl1OCAgICAgICAgIHJhZXJwOjE7CS8qIHJlYWR5IEFFUiBwZXJtaXNzaW9uICovCisJdTggICAgICAgICBzd3A6MTsJCS8qIHNvZnR3YXJlIHdyaXRlIHByb3RlY3QgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkNjoyOworCXU4ICAgICAgICAgcmFjOjE7CQkvKiByZXBvcnQgYSBjaGVjayAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQ1OjE7CisKKwl1OCAgICAgICAgIGF1dG9sb2FkX21vZDozOworCXU4ICAgICAgICAgcmVzZXJ2ZWQ3OjU7CisjZW5kaWYKKwl1OCAgICAgICAgIHJhaHBfbXNiOwkvKiByZWFkeSBBRVIgaG9sZG9mZiBwZXJpb2QgLSBNU0IgKi8KKwl1OCAgICAgICAgIHJhaHBfbHNiOwkvKiByZWFkeSBBRVIgaG9sZG9mZiBwZXJpb2QgLSBMU0IgKi8KKworCXU4ICAgICAgICAgYnVzeV90aW1lb3V0X3BlcmlvZF9tc2I7CisJdTggICAgICAgICBidXN5X3RpbWVvdXRfcGVyaW9kX2xzYjsKKworCXU4ICAgICAgICAgZXh0X3NlbGZ0ZXN0X2NvbXBsX3RpbWVfbXNiOworCXU4ICAgICAgICAgZXh0X3NlbGZ0ZXN0X2NvbXBsX3RpbWVfbHNiOworfTsKKworLyoKKyAqIFNDU0kgbWVkaXVtIHR5cGVzIHN1cHBvcnRlZCBtb2RlIHBhZ2UKKyAqLworc3RydWN0IHNjc2lfbXBfbWVkaXVtX3R5cGVzX3N1cF9zeworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBwczoxOworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjE7CisJdTggICAgICAgICBwYWdlX2NvZGU6NjsKKyNlbHNlCisJdTggICAgICAgICBwYWdlX2NvZGU6NjsKKwl1OCAgICAgICAgIHJlc2VydmVkMToxOworCXU4ICAgICAgICAgcHM6MTsKKyNlbmRpZgorCXU4ICAgICAgICAgcGFnZV9sZW47CisKKwl1OCAgICAgICAgIHJlc2VydmVkM1syXTsKKwl1OCAgICAgICAgIG1lZF90eXBlMV9zdXA7CS8qIG1lZGl1bSB0eXBlIG9uZSBzdXBwb3J0ZWQgKi8KKwl1OCAgICAgICAgIG1lZF90eXBlMl9zdXA7CS8qIG1lZGl1bSB0eXBlIHR3byBzdXBwb3J0ZWQgKi8KKwl1OCAgICAgICAgIG1lZF90eXBlM19zdXA7CS8qIG1lZGl1bSB0eXBlIHRocmVlIHN1cHBvcnRlZCAqLworCXU4ICAgICAgICAgbWVkX3R5cGU0X3N1cDsJLyogbWVkaXVtIHR5cGUgZm91ciBzdXBwb3J0ZWQgKi8KK307CisKKy8qCisgKiBTQ1NJIGluZm9ybWF0aW9uYWwgZXhjZXB0aW9uIGNvbnRyb2wgbW9kZSBwYWdlCisgKi8KK3N0cnVjdCBzY3NpX21wX2luZm9fZXhjcHRfY250bF9zeworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBwczoxOworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjE7CisJdTggICAgICAgICBwYWdlX2NvZGU6NjsKKyNlbHNlCisJdTggICAgICAgICBwYWdlX2NvZGU6NjsKKwl1OCAgICAgICAgIHJlc2VydmVkMToxOworCXU4ICAgICAgICAgcHM6MTsKKyNlbmRpZgorCXU4ICAgICAgICAgcGFnZV9sZW47CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHBlcmY6MTsJCS8qIHBlcmZvcm1hbmNlICovCisJdTggICAgICAgICByZXNlcnZlZDM6MTsKKwl1OCAgICAgICAgIGViZjoxOwkJLyogZW5hYmxlIGJhY2tncm91bmQgZnVjbnRpb24gKi8KKwl1OCAgICAgICAgIGV3YXNjOjE7CS8qIGVuYWJsZSB3YXJuaW5nICovCisJdTggICAgICAgICBkZXhjcHQ6MTsJLyogZGlzYWJsZSBleGNlcHRpb24gY29udHJvbCAqLworCXU4ICAgICAgICAgdGVzdDoxOwkJLyogZW5hYmxlIHRlc3QgZGV2aWNlIGZhaWx1cmUKKwkJCQkJICogbm90aWZpY2F0aW9uCisJCQkJCSAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQ0OjE7CisJdTggICAgICAgICBsb2dfZXJyb3I6MTsKKworCXU4ICAgICAgICAgcmVzZXJ2ZWQ1OjQ7CisJdTggICAgICAgICBtcmllOjQ7CQkvKiBtZXRob2Qgb2YgcmVwb3J0aW5nIGluZm8KKwkJCQkJICogZXhjZXB0aW9ucworCQkJCQkgKi8KKyNlbHNlCisJdTggICAgICAgICBsb2dfZXJyb3I6MTsKKwl1OCAgICAgICAgIHJlc2VydmVkNDoxOworCXU4ICAgICAgICAgdGVzdDoxOwkJLyogZW5hYmxlIHRlc3QgZGV2aWNlIGZhaWx1cmUKKwkJCQkJICogbm90aWZpY2F0aW9uCisJCQkJCSAqLworCXU4ICAgICAgICAgZGV4Y3B0OjE7CS8qIGRpc2FibGUgZXhjZXB0aW9uIGNvbnRyb2wgKi8KKwl1OCAgICAgICAgIGV3YXNjOjE7CS8qIGVuYWJsZSB3YXJuaW5nICovCisJdTggICAgICAgICBlYmY6MTsJCS8qIGVuYWJsZSBiYWNrZ3JvdW5kIGZ1Y250aW9uICovCisJdTggICAgICAgICByZXNlcnZlZDM6MTsKKwl1OCAgICAgICAgIHBlcmY6MTsJCS8qIHBlcmZvcm1hbmNlICovCisKKwl1OCAgICAgICAgIG1yaWU6NDsJCS8qIG1ldGhvZCBvZiByZXBvcnRpbmcgaW5mbworCQkJCQkgKiBleGNlcHRpb25zCisJCQkJCSAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQ1OjQ7CisjZW5kaWYKKwl1OCAgICAgICAgIGludGVydmFsX3RpbWVyX21zYjsKKwl1OCAgICAgICAgIGludGVydmFsX3RpbWVyX2xzYjsKKworCXU4ICAgICAgICAgcmVwb3J0X2NvdW50X21zYjsKKwl1OCAgICAgICAgIHJlcG9ydF9jb3VudF9sc2I7Cit9OworCisvKgorICogTWV0aG9kcyBvZiByZXBvcnRpbmcgaW5mb3JtYXRpb25hbCBleGNlcHRpb25zCisgKi8KKyNkZWZpbmUgU0NTSV9NUF9JRUNfTk9fUkVQT1JUICAgICAgIDB4MAkvKiBubyByZXBvcnRpbmcgb2YgZXhjZXB0aW9ucyAqLworI2RlZmluZSBTQ1NJX01QX0lFQ19BRVIgICAgICAgICAgICAgMHgxCS8qIGFzeW5jIGV2ZW50IHJlcG9ydGluZyAqLworI2RlZmluZSBTQ1NJX01QX0lFQ19VTklUX0FUVE4gICAgICAgMHgyCS8qIGdlbmVyYXRlIHVuaXQgYXR0ZW5zdGlvbiAqLworI2RlZmluZSBTQ1NJX01PX0lFQ19DT05EX1JFQ19FUlIgICAgMHgzCS8qIGNvbmRpdGlvbmFsbHkgZ2VuZXJhdGUgcmVjb3ZlcmVkCisJCQkJCSAqIGVycm9yCisJCQkJCSAqLworI2RlZmluZSBTQ1NJX01QX0lFQ19VTkNPTkRfUkVDX0VSUiAgMHg0CS8qIHVuY29uZGl0aW9uYWxseSBnZW5lcmF0ZSByZWNvdmVyZWQKKwkJCQkJICogZXJyb3IKKwkJCQkJICovCisjZGVmaW5lIFNDU0lfTVBfSUVDX05PX1NFTlNFICAgICAgICAweDUJLyogZ2VuZXJhdGUgbm8gc2Vuc2UgKi8KKyNkZWZpbmUgU0NTSV9NUF9JRUNfT05fUkVRVUVTVCAgICAgIDB4NgkvKiBvbmx5IHJlcG9ydCBleGNlcHRpb25zIG9uIHJlcXVlc3QgKi8KKworLyoKKyAqIFNDU0kgZmxleGlibGUgZGlzayBwYWdlCisgKi8KK3N0cnVjdCBzY3NpX21wX2ZsZXhpYmxlX2Rpc2tfc3sKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcHM6MTsKKwl1OCAgICAgICAgIHJlc2VydmVkMToxOworCXU4ICAgICAgICAgcGFnZV9jb2RlOjY7CisjZWxzZQorCXU4ICAgICAgICAgcGFnZV9jb2RlOjY7CisJdTggICAgICAgICByZXNlcnZlZDE6MTsKKwl1OCAgICAgICAgIHBzOjE7CisjZW5kaWYKKwl1OCAgICAgICAgIHBhZ2VfbGVuOworCisJdTggICAgICAgICB0cmFuc2Zlcl9yYXRlX21zYjsKKwl1OCAgICAgICAgIHRyYW5zZmVyX3JhdGVfbHNiOworCisJdTggICAgICAgICBudW1faGVhZHM7CisJdTggICAgICAgICBudW1fc2VjdG9yczsKKworCXU4ICAgICAgICAgYnl0ZXNfcGVyX3NlY3Rvcl9tc2I7CisJdTggICAgICAgICBieXRlc19wZXJfc2VjdG9yX2xzYjsKKworCXU4ICAgICAgICAgbnVtX2N5bGluZGVyc19tc2I7CisJdTggICAgICAgICBudW1fY3lsaW5kZXJzX2xzYjsKKworCXU4ICAgICAgICAgc2Nfd3BjX21zYjsJLyogc3RhcnRpbmcgY3lsaW5kZXItd3JpdGUKKwkJCQkJICogcHJlY29tcGVuc2F0aW9uIG1zYgorCQkJCQkgKi8KKwl1OCAgICAgICAgIHNjX3dwY19sc2I7CS8qIHN0YXJ0aW5nIGN5bGluZGVyLXdyaXRlCisJCQkJCSAqIHByZWNvbXBlbnNhdGlvbiBsc2IKKwkJCQkJICovCisJdTggICAgICAgICBzY19yd2NfbXNiOwkvKiBzdGFydGluZyBjeWxpbmRlci1yZWR1Y2VkIHdyaXRlCisJCQkJCSAqIGN1cnJlbnQgbXNiCisJCQkJCSAqLworCXU4ICAgICAgICAgc2NfcndjX2xzYjsJLyogc3RhcnRpbmcgY3lsaW5kZXItcmVkdWNlZCB3cml0ZQorCQkJCQkgKiBjdXJyZW50IGxzYgorCQkJCQkgKi8KKworCXU4ICAgICAgICAgZGV2X3N0ZXBfcmF0ZV9tc2I7CisJdTggICAgICAgICBkZXZfc3RlcF9yYXRlX2xzYjsKKworCXU4ICAgICAgICAgZGV2X3N0ZXBfcHVsc2Vfd2lkdGg7CisKKwl1OCAgICAgICAgIGhlYWRfc2RfbXNiOwkvKiBoZWFkIHNldHRsZSBkZWxheSBtc2IgKi8KKwl1OCAgICAgICAgIGhlYWRfc2RfbHNiOwkvKiBoZWFkIHNldHRsZSBkZWxheSBsc2IgKi8KKworCXU4ICAgICAgICAgbW90b3Jfb25fZGVsYXk7CisJdTggICAgICAgICBtb3Rvcl9vZmZfZGVsYXk7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHRyZHk6MTsJCS8qIHRydWUgcmVhZHkgYml0ICovCisJdTggICAgICAgICBzc246MTsJCS8qIHN0YXJ0IHNlY3RvciBudW1iZXIgYml0ICovCisJdTggICAgICAgICBtbzoxOwkJLyogbW90b3Igb24gYml0ICovCisJdTggICAgICAgICByZXNlcnZlZDM6NTsKKworCXU4ICAgICAgICAgcmVzZXJ2ZWQ0OjQ7CisJdTggICAgICAgICBzcGM6NDsJCS8qIHN0ZXAgcHVsc2UgcGVyIGN5bGluZGVyICovCisjZWxzZQorCXU4ICAgICAgICAgcmVzZXJ2ZWQzOjU7CisJdTggICAgICAgICBtbzoxOwkJLyogbW90b3Igb24gYml0ICovCisJdTggICAgICAgICBzc246MTsJCS8qIHN0YXJ0IHNlY3RvciBudW1iZXIgYml0ICovCisJdTggICAgICAgICB0cmR5OjE7CQkvKiB0cnVlIHJlYWR5IGJpdCAqLworCisJdTggICAgICAgICBzcGM6NDsJCS8qIHN0ZXAgcHVsc2UgcGVyIGN5bGluZGVyICovCisJdTggICAgICAgICByZXNlcnZlZDQ6NDsKKyNlbmRpZgorCXU4ICAgICAgICAgd3JpdGVfY29tcDsKKwl1OCAgICAgICAgIGhlYWRfbG9hZF9kZWxheTsKKwl1OCAgICAgICAgIGhlYWRfdW5sb2FkX2RlbGF5OworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICBwaW4zNDo0OwkvKiBwaW4zNCB1c2FnZSAqLworCXU4ICAgICAgICAgcGluMjo0OwkJLyogcGluMiB1c2FnZSAqLworCisJdTggICAgICAgICBwaW40OjQ7CQkvKiBwaW40IHVzYWdlICovCisJdTggICAgICAgICBwaW4xOjQ7CQkvKiBwaW4xIHVzYWdlICovCisjZWxzZQorCXU4ICAgICAgICAgcGluMjo0OwkJLyogcGluMiB1c2FnZSAqLworCXU4ICAgICAgICAgcGluMzQ6NDsJLyogcGluMzQgdXNhZ2UgKi8KKworCXU4ICAgICAgICAgcGluMTo0OwkJLyogcGluMSB1c2FnZSAqLworCXU4ICAgICAgICAgcGluNDo0OwkJLyogcGluNCB1c2FnZSAqLworI2VuZGlmCisJdTggICAgICAgICBtZWRfcm90X3JhdGVfbXNiOworCXU4ICAgICAgICAgbWVkX3JvdF9yYXRlX2xzYjsKKworCXU4ICAgICAgICAgcmVzZXJ2ZWQ1WzJdOworfTsKKworc3RydWN0IHNjc2lfbW9kZV9wYWdlX2Zvcm1hdF9kYXRhNl9zeworCXN0cnVjdCBzY3NpX21vZGVfcGFyYW1faGVhZGVyNl9zIG1waDsJLyogbW9kZSBwYWdlIGhlYWRlciAqLworCXN0cnVjdCBzY3NpX21vZGVfcGFyYW1fZGVzY19zIGRlc2M7CS8qIGJsb2NrIGRlc2NyaXB0b3IgKi8KKwlzdHJ1Y3Qgc2NzaV9tcF9mb3JtYXRfZGV2aWNlX3MgZm9ybWF0OwkvKiBmb3JtYXQgZGV2aWNlIGRhdGEgKi8KK307CisKK3N0cnVjdCBzY3NpX21vZGVfcGFnZV9mb3JtYXRfZGF0YTEwX3N7CisJc3RydWN0IHNjc2lfbW9kZV9wYXJhbV9oZWFkZXIxMF9zIG1waDsJLyogbW9kZSBwYWdlIGhlYWRlciAqLworCXN0cnVjdCBzY3NpX21vZGVfcGFyYW1fZGVzY19zIGRlc2M7CS8qIGJsb2NrIGRlc2NyaXB0b3IgKi8KKwlzdHJ1Y3Qgc2NzaV9tcF9mb3JtYXRfZGV2aWNlX3MgZm9ybWF0OwkvKiBmb3JtYXQgZGV2aWNlIGRhdGEgKi8KK307CisKK3N0cnVjdCBzY3NpX21vZGVfcGFnZV9yZGdfZGF0YTZfc3sKKwlzdHJ1Y3Qgc2NzaV9tb2RlX3BhcmFtX2hlYWRlcjZfcyBtcGg7CS8qIG1vZGUgcGFnZSBoZWFkZXIgKi8KKwlzdHJ1Y3Qgc2NzaV9tb2RlX3BhcmFtX2Rlc2NfcyBkZXNjOwkvKiBibG9jayBkZXNjcmlwdG9yICovCisJc3RydWN0IHNjc2lfbXBfcmlnaWRfZGV2aWNlX2dlb21ldHJ5X3MgcmRnOworCQkJCQkvKiByaWdpZCBnZW9tZXRyeSBkYXRhICovCit9OworCitzdHJ1Y3Qgc2NzaV9tb2RlX3BhZ2VfcmRnX2RhdGExMF9zeworCXN0cnVjdCBzY3NpX21vZGVfcGFyYW1faGVhZGVyMTBfcyBtcGg7CS8qIG1vZGUgcGFnZSBoZWFkZXIgKi8KKwlzdHJ1Y3Qgc2NzaV9tb2RlX3BhcmFtX2Rlc2NfcyBkZXNjOwkvKiBibG9jayBkZXNjcmlwdG9yICovCisJc3RydWN0IHNjc2lfbXBfcmlnaWRfZGV2aWNlX2dlb21ldHJ5X3MgcmRnOworCQkJCQkvKiByaWdpZCBnZW9tZXRyeSBkYXRhICovCit9OworCitzdHJ1Y3Qgc2NzaV9tb2RlX3BhZ2VfY2FjaGU2X3N7CisJc3RydWN0IHNjc2lfbW9kZV9wYXJhbV9oZWFkZXI2X3MgbXBoOwkvKiBtb2RlIHBhZ2UgaGVhZGVyICovCisJc3RydWN0IHNjc2lfbW9kZV9wYXJhbV9kZXNjX3MgZGVzYzsJLyogYmxvY2sgZGVzY3JpcHRvciAqLworCXN0cnVjdCBzY3NpX21wX2NhY2hpbmdfcyBjYWNoZTsJLyogY2FjaGUgcGFnZSBkYXRhICovCit9OworCitzdHJ1Y3Qgc2NzaV9tb2RlX3BhZ2VfY2FjaGUxMF9zeworCXN0cnVjdCBzY3NpX21vZGVfcGFyYW1faGVhZGVyMTBfcyBtcGg7CS8qIG1vZGUgcGFnZSBoZWFkZXIgKi8KKwlzdHJ1Y3Qgc2NzaV9tb2RlX3BhcmFtX2Rlc2NfcyBkZXNjOwkvKiBibG9jayBkZXNjcmlwdG9yICovCisJc3RydWN0IHNjc2lfbXBfY2FjaGluZ19zIGNhY2hlOwkvKiBjYWNoZSBwYWdlIGRhdGEgKi8KK307CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisgKiBGb3JtYXQgVW5pdCBjb21tYW5kCisgKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKyAqLworCisvKgorICogRm9ybWF0IFVuaXQgQ0RCCisgKi8KK3N0cnVjdCBzY3NpX2Zvcm1hdF91bml0X3N7CisJdTggICAgICAgICBvcGNvZGU7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIHJlczE6MzsKKwl1OCAgICAgICAgIGZtdGRhdGE6MTsJLyogaWYgc2V0LCBkYXRhIG91dCBwaGFzZSBoYXMgZm9ybWF0CisJCQkJCSAqIGRhdGEKKwkJCQkJICovCisJdTggICAgICAgICBjbXBsc3Q6MTsJLyogaWYgc2V0LCBkZWZlY3QgbGlzdCBpcyBjb21wbGV0ZSAqLworCXU4ICAgICAgICAgZGVmX2xpc3Q6MzsJLyogZm9ybWF0IG9mIGRlZmVjdCBkZXNjcmlwdG9yIGlzCisJCQkJCSAqIGZtdGRhdGEgPTEKKwkJCQkJICovCisjZWxzZQorCXU4ICAgICAgICAgZGVmX2xpc3Q6MzsJLyogZm9ybWF0IG9mIGRlZmVjdCBkZXNjcmlwdG9yIGlzCisJCQkJCSAqIGZtdGRhdGEgPSAxCisJCQkJCSAqLworCXU4ICAgICAgICAgY21wbHN0OjE7CS8qIGlmIHNldCwgZGVmZWN0IGxpc3QgaXMgY29tcGxldGUgKi8KKwl1OCAgICAgICAgIGZtdGRhdGE6MTsJLyogaWYgc2V0LCBkYXRhIG91dCBwaGFzZSBoYXMgZm9ybWF0CisJCQkJCSAqIGRhdGEKKwkJCQkJICovCisJdTggICAgICAgICByZXMxOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIGludGVybGVhdmVfbXNiOworCXU4ICAgICAgICAgaW50ZXJsZWF2ZV9sc2I7CisJdTggICAgICAgICB2ZW5kb3Jfc3BlYzsKKwl1OCAgICAgICAgIGNvbnRyb2w7Cit9OworCisvKgorICogaAorICovCitzdHJ1Y3Qgc2NzaV9yZXNlcnZlNl9zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICByZXNlcnZlZDozOworCXU4ICAgICAgICAgb2Jzb2xldGU6NDsKKwl1OCAgICAgICAgIGV4dGVudDoxOworI2Vsc2UKKwl1OCAgICAgICAgIGV4dGVudDoxOworCXU4ICAgICAgICAgb2Jzb2xldGU6NDsKKwl1OCAgICAgICAgIHJlc2VydmVkOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmF0aW9uX2lkOworCXUxNiAgICAgICAgcGFyYW1fbGlzdF9sZW47CisJdTggICAgICAgICBjb250cm9sOworfTsKKworLyoKKyAqIGgKKyAqLworc3RydWN0IHNjc2lfcmVsZWFzZTZfc3sKKwl1OCAgICAgICAgIG9wY29kZTsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjM7CisJdTggICAgICAgICBvYnNvbGV0ZTo0OworCXU4ICAgICAgICAgZXh0ZW50OjE7CisjZWxzZQorCXU4ICAgICAgICAgZXh0ZW50OjE7CisJdTggICAgICAgICBvYnNvbGV0ZTo0OworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmF0aW9uX2lkOworCXUxNiAgICAgICAgcmVzZXJ2ZWQyOworCXU4ICAgICAgICAgY29udHJvbDsKK307CisKKy8qCisgKiBoCisgKi8KK3N0cnVjdCBzY3NpX3Jlc2VydmUxMF9zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICByZXNlcnZlZDE6MzsKKwl1OCAgICAgICAgIHRoaXJkX3BhcnR5OjE7CisJdTggICAgICAgICByZXNlcnZlZDI6MjsKKwl1OCAgICAgICAgIGxvbmdfaWQ6MTsKKwl1OCAgICAgICAgIGV4dGVudDoxOworI2Vsc2UKKwl1OCAgICAgICAgIGV4dGVudDoxOworCXU4ICAgICAgICAgbG9uZ19pZDoxOworCXU4ICAgICAgICAgcmVzZXJ2ZWQyOjI7CisJdTggICAgICAgICB0aGlyZF9wYXJ0eToxOworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmF0aW9uX2lkOworCXU4ICAgICAgICAgdGhpcmRfcHR5X2Rldl9pZDsKKwl1OCAgICAgICAgIHJlc2VydmVkMzsKKwl1OCAgICAgICAgIHJlc2VydmVkNDsKKwl1OCAgICAgICAgIHJlc2VydmVkNTsKKwl1MTYgICAgICAgIHBhcmFtX2xpc3RfbGVuOworCXU4ICAgICAgICAgY29udHJvbDsKK307CisKK3N0cnVjdCBzY3NpX3JlbGVhc2UxMF9zeworCXU4ICAgICAgICAgb3Bjb2RlOworI2lmZGVmIF9fQklHRU5ESUFOCisJdTggICAgICAgICByZXNlcnZlZDE6MzsKKwl1OCAgICAgICAgIHRoaXJkX3BhcnR5OjE7CisJdTggICAgICAgICByZXNlcnZlZDI6MjsKKwl1OCAgICAgICAgIGxvbmdfaWQ6MTsKKwl1OCAgICAgICAgIGV4dGVudDoxOworI2Vsc2UKKwl1OCAgICAgICAgIGV4dGVudDoxOworCXU4ICAgICAgICAgbG9uZ19pZDoxOworCXU4ICAgICAgICAgcmVzZXJ2ZWQyOjI7CisJdTggICAgICAgICB0aGlyZF9wYXJ0eToxOworCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmF0aW9uX2lkOworCXU4ICAgICAgICAgdGhpcmRfcHR5X2Rldl9pZDsKKwl1OCAgICAgICAgIHJlc2VydmVkMzsKKwl1OCAgICAgICAgIHJlc2VydmVkNDsKKwl1OCAgICAgICAgIHJlc2VydmVkNTsKKwl1MTYgICAgICAgIHBhcmFtX2xpc3RfbGVuOworCXU4ICAgICAgICAgY29udHJvbDsKK307CisKK3N0cnVjdCBzY3NpX3ZlcmlmeTEwX3N7CisJdTggICAgICAgICBvcGNvZGU7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIGx1bjozOworCXU4ICAgICAgICAgZHBvOjE7CisJdTggICAgICAgICByZXNlcnZlZDoyOworCXU4ICAgICAgICAgYnl0Y2hrOjE7CisJdTggICAgICAgICByZWxhZGRyOjE7CisjZWxzZQorCXU4ICAgICAgICAgcmVsYWRkcjoxOworCXU4ICAgICAgICAgYnl0Y2hrOjE7CisJdTggICAgICAgICByZXNlcnZlZDoyOworCXU4ICAgICAgICAgZHBvOjE7CisJdTggICAgICAgICBsdW46MzsKKyNlbmRpZgorCXU4ICAgICAgICAgbGJhMDsKKwl1OCAgICAgICAgIGxiYTE7CisJdTggICAgICAgICBsYmEyOworCXU4ICAgICAgICAgbGJhMzsKKwl1OCAgICAgICAgIHJlc2VydmVkMTsKKwl1OCAgICAgICAgIHZlcmlmaWNhdGlvbl9sZW4wOworCXU4ICAgICAgICAgdmVyaWZpY2F0aW9uX2xlbjE7CisJdTggICAgICAgICBjb250cm9sX2J5dGU7Cit9OworCitzdHJ1Y3Qgc2NzaV9yZXF1ZXN0X3NlbnNlX3N7CisJdTggICAgICAgICBvcGNvZGU7CisjaWZkZWYgX19CSUdFTkRJQU4KKwl1OCAgICAgICAgIGx1bjozOworCXU4ICAgICAgICAgcmVzZXJ2ZWQ6NTsKKyNlbHNlCisJdTggICAgICAgICByZXNlcnZlZDo1OworCXU4ICAgICAgICAgbHVuOjM7CisjZW5kaWYKKwl1OCAgICAgICAgIHJlc2VydmVkMDsKKwl1OCAgICAgICAgIHJlc2VydmVkMTsKKwl1OCAgICAgICAgIGFsbG9jX2xlbjsKKwl1OCAgICAgICAgIGNvbnRyb2xfYnl0ZTsKK307CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICogU0NTSSBzdGF0dXMgYnl0ZSB2YWx1ZXMKKyAqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorICovCisjZGVmaW5lIFNDU0lfU1RBVFVTX0dPT0QgICAgICAgICAgICAgICAgICAgMHgwMAorI2RlZmluZSBTQ1NJX1NUQVRVU19DSEVDS19DT05ESVRJT04gICAgICAgIDB4MDIKKyNkZWZpbmUgU0NTSV9TVEFUVVNfQ09ORElUSU9OX01FVCAgICAgICAgICAweDA0CisjZGVmaW5lIFNDU0lfU1RBVFVTX0JVU1kgICAgICAgICAgICAgICAgICAgMHgwOAorI2RlZmluZSBTQ1NJX1NUQVRVU19JTlRFUk1FRElBVEUgICAgICAgICAgIDB4MTAKKyNkZWZpbmUgU0NTSV9TVEFUVVNfSUNNICAgICAgICAgICAgICAgICAgICAweDE0CS8qIGludGVybWVkaWF0ZSBjb25kaXRpb24gbWV0ICovCisjZGVmaW5lIFNDU0lfU1RBVFVTX1JFU0VSVkFUSU9OX0NPTkZMSUNUICAgMHgxOAorI2RlZmluZSBTQ1NJX1NUQVRVU19DT01NQU5EX1RFUk1JTkFURUQgICAgIDB4MjIKKyNkZWZpbmUgU0NTSV9TVEFUVVNfUVVFVUVfRlVMTCAgICAgICAgICAgICAweDI4CisjZGVmaW5lIFNDU0lfU1RBVFVTX0FDQV9BQ1RJVkUgICAgICAgICAgICAgMHgzMAorCisjZGVmaW5lIFNDU0lfTUFYX0FMTE9DX0xFTgkJMHhGRgkvKiBtYXhpbXVtIGFsbG9jYXJpb24gbGVuZ3RoCisJCQkJCQkgKiBpbiBDREJzCisJCQkJCQkgKi8KKworI2RlZmluZSBTQ1NJX09QX1dSSVRFX1ZFUklGWTEwICAgICAgMHgyRQorI2RlZmluZSBTQ1NJX09QX1dSSVRFX1ZFUklGWTEyICAgICAgMHhBRQorI2RlZmluZSBTQ1NJX09QX1VOREVGICAgICAgICAgICAgICAgMHhGRgorCisvKgorICogU0NTSSBXUklURS1WRVJJRlkoMTApIGNvbW1hbmQKKyAqLworc3RydWN0IHNjc2lfd3JpdGVfdmVyaWZ5MTBfc3sKKwl1OCAgICAgICAgIG9wY29kZTsKKyNpZmRlZiBfX0JJR0VORElBTgorCXU4ICAgICAgICAgcmVzZXJ2ZWQxOjM7CisJdTggICAgICAgICBkcG86MTsJCS8qIERpc2FibGUgUGFnZSBPdXQgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkMjoxOworCXU4ICAgICAgICAgZWJwOjE7CQkvKiBlcnNlIGJ5LXBhc3MgKi8KKwl1OCAgICAgICAgIGJ5dGNoazoxOwkvKiBieXRlIGNoZWNrICovCisJdTggICAgICAgICByZWxfYWRyOjE7CS8qIHJlbGF0aXZlIGFkZHJlc3MgKi8KKyNlbHNlCisJdTggICAgICAgICByZWxfYWRyOjE7CS8qIHJlbGF0aXZlIGFkZHJlc3MgKi8KKwl1OCAgICAgICAgIGJ5dGNoazoxOwkvKiBieXRlIGNoZWNrICovCisJdTggICAgICAgICBlYnA6MTsJCS8qIGVyc2UgYnktcGFzcyAqLworCXU4ICAgICAgICAgcmVzZXJ2ZWQyOjE7CisJdTggICAgICAgICBkcG86MTsJCS8qIERpc2FibGUgUGFnZSBPdXQgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkMTozOworI2VuZGlmCisJdTggICAgICAgICBsYmEwOwkJLyogbG9naWNhbCBibG9jayBhZGRyZXNzIC0gTVNCICovCisJdTggICAgICAgICBsYmExOworCXU4ICAgICAgICAgbGJhMjsKKwl1OCAgICAgICAgIGxiYTM7CQkvKiBMU0IgKi8KKwl1OCAgICAgICAgIHJlc2VydmVkMzsKKwl1OCAgICAgICAgIHhmZXJfbGVuZ3RoMDsJLyogdHJhbnNmZXIgbGVuZ3RoIGluIGJsb2NrcyAtIE1TQiAqLworCXU4ICAgICAgICAgeGZlcl9sZW5ndGgxOwkvKiBMU0IgKi8KKwl1OCAgICAgICAgIGNvbnRyb2w7Cit9OworCisjcHJhZ21hIHBhY2soKQorCisjZW5kaWYgLyogX19TQ1NJX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL3R5cGVzLmggYi9kcml2ZXJzL3Njc2kvYmZhL2luY2x1ZGUvcHJvdG9jb2wvdHlwZXMuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yODc1YTZjCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9pbmNsdWRlL3Byb3RvY29sL3R5cGVzLmgKQEAgLTAsMCArMSw0MiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICB0eXBlcy5oIFByb3RvY29sIGRlZmluZWQgYmFzZSB0eXBlcworICovCisKKyNpZm5kZWYgX19UWVBFU19IX18KKyNkZWZpbmUgX19UWVBFU19IX18KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKworI2RlZmluZSB3d25fdCB1NjQKKyNkZWZpbmUgbHVuX3QgdTY0CisKKyNkZWZpbmUgV1dOX05VTEwJKDApCisjZGVmaW5lIEZDX1NZTU5BTUVfTUFYCTI1NgkvKiAgbWF4IG5hbWUgc2VydmVyIHN5bWJvbGljIG5hbWUgc2l6ZSAqLworI2RlZmluZSBGQ19BTFBBX01BWAkxMjgKKworI3ByYWdtYSBwYWNrKDEpCisKKyNkZWZpbmUgTUFDX0FERFJMRU4JKDYpCitzdHJ1Y3QgbWFjX3MgeyB1OCBtYWNbTUFDX0FERFJMRU5dOyB9OworI2RlZmluZSBtYWNfdCBzdHJ1Y3QgbWFjX3MKKworI3ByYWdtYSBwYWNrKCkKKworI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL2xvb3AuYyBiL2RyaXZlcnMvc2NzaS9iZmEvbG9vcC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmE0MThkZWQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2xvb3AuYwpAQCAtMCwwICsxLDQyMiBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBwb3J0X2xvb3AuYyB2cG9ydCBwcml2YXRlIGxvb3AgaW1wbGVtZW50YXRpb24uCisgKi8KKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImxwb3J0X3ByaXYuaCIKKworQkZBX1RSQ19GSUxFKEZDUywgTE9PUCk7CisKKy8qKgorICogICBBTFBBIHRvIExJWEEgYml0bWFwIG1hcHBpbmcKKyAqCisgKiAgIEFMUEEgMHgwMCAoV29yZCAwLCBCaXQgMzApIGlzIGludmFsaWQgZm9yIE5fUG9ydHMuIEFsc28gV29yZCAwIEJpdCAzMQorICogaXMgZm9yIExfYml0IChsb2dpbiByZXF1aXJlZCkgYW5kIGlzIGZpbGxlZCBhcyBBTFBBIDB4MDAgaGVyZS4KKyAqLworc3RhdGljIGNvbnN0IHU4ICAgcG9ydF9sb29wX2FscGFfbWFwW10gPSB7CisJMHhFRiwgMHhFOCwgMHhFNCwgMHhFMiwgMHhFMSwgMHhFMCwgMHhEQywgMHhEQSwJLyogV29yZCAzIEJpdHMgMC4uNyAqLworCTB4RDksIDB4RDYsIDB4RDUsIDB4RDQsIDB4RDMsIDB4RDIsIDB4RDEsIDB4Q0UsCS8qIFdvcmQgMyBCaXRzIDguLjE1ICovCisJMHhDRCwgMHhDQywgMHhDQiwgMHhDQSwgMHhDOSwgMHhDNywgMHhDNiwgMHhDNSwJLyogV29yZCAzIEJpdHMgMTYuLjIzICovCisJMHhDMywgMHhCQywgMHhCQSwgMHhCOSwgMHhCNiwgMHhCNSwgMHhCNCwgMHhCMywJLyogV29yZCAzIEJpdHMgMjQuLjMxICovCisKKwkweEIyLCAweEIxLCAweEFFLCAweEFELCAweEFDLCAweEFCLCAweEFBLCAweEE5LAkvKiBXb3JkIDIgQml0cyAwLi43ICovCisJMHhBNywgMHhBNiwgMHhBNSwgMHhBMywgMHg5RiwgMHg5RSwgMHg5RCwgMHg5QiwJLyogV29yZCAyIEJpdHMgOC4uMTUgKi8KKwkweDk4LCAweDk3LCAweDkwLCAweDhGLCAweDg4LCAweDg0LCAweDgyLCAweDgxLAkvKiBXb3JkIDIgQml0cyAxNi4uMjMgKi8KKwkweDgwLCAweDdDLCAweDdBLCAweDc5LCAweDc2LCAweDc1LCAweDc0LCAweDczLAkvKiBXb3JkIDIgQml0cyAyNC4uMzEgKi8KKworCTB4NzIsIDB4NzEsIDB4NkUsIDB4NkQsIDB4NkMsIDB4NkIsIDB4NkEsIDB4NjksCS8qIFdvcmQgMSBCaXRzIDAuLjcgKi8KKwkweDY3LCAweDY2LCAweDY1LCAweDYzLCAweDVDLCAweDVBLCAweDU5LCAweDU2LAkvKiBXb3JkIDEgQml0cyA4Li4xNSAqLworCTB4NTUsIDB4NTQsIDB4NTMsIDB4NTIsIDB4NTEsIDB4NEUsIDB4NEQsIDB4NEMsCS8qIFdvcmQgMSBCaXRzIDE2Li4yMyAqLworCTB4NEIsIDB4NEEsIDB4NDksIDB4NDcsIDB4NDYsIDB4NDUsIDB4NDMsIDB4M0MsCS8qIFdvcmQgMSBCaXRzIDI0Li4zMSAqLworCisJMHgzQSwgMHgzOSwgMHgzNiwgMHgzNSwgMHgzNCwgMHgzMywgMHgzMiwgMHgzMSwJLyogV29yZCAwIEJpdHMgMC4uNyAqLworCTB4MkUsIDB4MkQsIDB4MkMsIDB4MkIsIDB4MkEsIDB4MjksIDB4MjcsIDB4MjYsCS8qIFdvcmQgMCBCaXRzIDguLjE1ICovCisJMHgyNSwgMHgyMywgMHgxRiwgMHgxRSwgMHgxRCwgMHgxQiwgMHgxOCwgMHgxNywJLyogV29yZCAwIEJpdHMgMTYuLjIzICovCisJMHgxMCwgMHgwRiwgMHgwOCwgMHgwNCwgMHgwMiwgMHgwMSwgMHgwMCwgMHgwMCwJLyogV29yZCAwIEJpdHMgMjQuLjMxICovCit9OworCisvKgorICogTG9jYWwgRnVuY3Rpb25zCisgKi8KK2JmYV9zdGF0dXNfdCAgICBiZmFfZmNzX3BvcnRfbG9vcF9zZW5kX3Bsb2dpKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkJICAgICB1OCBhbHBhKTsKKwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9sb29wX3Bsb2dpX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCQkJCSBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJCSB2b2lkICpjYmFyZywKKwkJCQkJCSBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkJCSB1MzIgcnNwX2xlbiwKKwkJCQkJCSB1MzIgcmVzaWRfbGVuLAorCQkJCQkJIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKKworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfcG9ydF9sb29wX3NlbmRfYWRpc2Moc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJCQkgICAgIHU4IGFscGEpOworCit2b2lkICAgICAgICAgICAgYmZhX2Zjc19wb3J0X2xvb3BfYWRpc2NfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkJIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCQkJIHZvaWQgKmNiYXJnLAorCQkJCQkJIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkJIHUzMiByc3BfbGVuLAorCQkJCQkJIHUzMiByZXNpZF9sZW4sCisJCQkJCQkgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworCitiZmFfc3RhdHVzX3QgICAgYmZhX2Zjc19wb3J0X2xvb3Bfc2VuZF9wbG9naV9hY2Moc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJCQkJIHU4IGFscGEpOworCit2b2lkICAgICAgICAgICAgYmZhX2Zjc19wb3J0X2xvb3BfcGxvZ2lfYWNjX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCQkJCSAgICAgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkJCQkgICAgIHZvaWQgKmNiYXJnLAorCQkJCQkJICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkJCSAgICAgdTMyIHJzcF9sZW4sCisJCQkJCQkgICAgIHUzMiByZXNpZF9sZW4sCisJCQkJCQkgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKKworYmZhX3N0YXR1c190ICAgIGJmYV9mY3NfcG9ydF9sb29wX3NlbmRfYWRpc2NfYWNjKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkJCSB1OCBhbHBhKTsKKwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9sb29wX2FkaXNjX2FjY19yZXNwb25zZSh2b2lkICpmY3NhcmcsCisJCQkJCQkgICAgIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCQkJICAgICB2b2lkICpjYmFyZywKKwkJCQkJCSAgICAgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJCQkgICAgIHUzMiByc3BfbGVuLAorCQkJCQkJICAgICB1MzIgcmVzaWRfbGVuLAorCQkJCQkJICAgICBzdHJ1Y3QgZmNoc19zICpyc3BfZmNocyk7CisvKioKKyAqICAgQ2FsbGVkIGJ5IHBvcnQgdG8gaW5pdGlhbGl6YXIgaW4gcHJvdmF0ZSBMT09QIHRvcG9sb2d5LgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfbG9vcF9pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKK30KKworLyoqCisgKiAgIENhbGxlZCBieSBwb3J0IHRvIG5vdGlmeSB0cmFuc2l0aW9uIHRvIG9ubGluZSBzdGF0ZS4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2xvb3Bfb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKworCXU4ICAgICAgICAgbnVtX2FscGEgPSBwb3J0LT5wb3J0X3RvcG8ucGxvb3AubnVtX2FscGE7CisJdTggICAgICAgICphbHBhX3Bvc19tYXAgPSBwb3J0LT5wb3J0X3RvcG8ucGxvb3AuYWxwYV9wb3NfbWFwOworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJfcG9ydDsKKwlpbnQgICAgICAgICAgICAgaWkgPSAwOworCisJLyoKKwkgKiBJZiB0aGUgcG9ydCByb2xlIGlzIEluaXRpYXRvciBNb2RlLCBjcmVhdGUgUnBvcnRzLgorCSAqLworCWlmIChwb3J0LT5wb3J0X2NmZy5yb2xlcyA9PSBCRkFfUE9SVF9ST0xFX0ZDUF9JTSkgeworCQkvKgorCQkgKiBDaGVjayBpZiB0aGUgQUxQQSBwb3NpdGlvbmFsIGJpdG1hcCBpcyBhdmFpbGFibGUuCisJCSAqIGlmIG5vdCwgd2Ugc2VuZCBQTE9HSSB0byBhbGwgcG9zc2libGUgQUxQQXMuCisJCSAqLworCQlpZiAobnVtX2FscGEgPiAwKSB7CisJCQlmb3IgKGlpID0gMDsgaWkgPCBudW1fYWxwYTsgaWkrKykgeworCQkJCS8qCisJCQkJICogaWdub3JlIEFMUEEgb2YgYmZhIHBvcnQKKwkJCQkgKi8KKwkJCQlpZiAoYWxwYV9wb3NfbWFwW2lpXSAhPSBwb3J0LT5waWQpIHsKKwkJCQkJcl9wb3J0ID0gYmZhX2Zjc19ycG9ydF9jcmVhdGUocG9ydCwKKwkJCQkJCWFscGFfcG9zX21hcFtpaV0pOworCQkJCX0KKwkJCX0KKwkJfSBlbHNlIHsKKwkJCWZvciAoaWkgPSAwOyBpaSA8IE1BWF9BTFBBX0NPVU5UOyBpaSsrKSB7CisJCQkJLyoKKwkJCQkgKiBpZ25vcmUgQUxQQSBvZiBiZmEgcG9ydAorCQkJCSAqLworCQkJCWlmICgocG9ydF9sb29wX2FscGFfbWFwW2lpXSA+IDApCisJCQkJICAgICYmIChwb3J0X2xvb3BfYWxwYV9tYXBbaWldICE9IHBvcnQtPnBpZCkpCisJCQkJCWJmYV9mY3NfcG9ydF9sb29wX3NlbmRfcGxvZ2kocG9ydCwKKwkJCQkJCXBvcnRfbG9vcF9hbHBhX21hcFtpaV0pOworCQkJCS8qKlRCRCAqLworCQkJfQorCQl9CisJfSBlbHNlIHsKKwkJLyoKKwkJICogVEJEIFRhcmdldCBNb2RlID8/CisJCSAqLworCX0KKworfQorCisvKioKKyAqICAgQ2FsbGVkIGJ5IHBvcnQgdG8gbm90aWZ5IHRyYW5zaXRpb24gdG8gb2ZmbGluZSBzdGF0ZS4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2xvb3Bfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisKK30KKworLyoqCisgKiAgIENhbGxlZCBieSBwb3J0IHRvIG5vdGlmeSBhIExJUCBvbiB0aGUgbG9vcC4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2xvb3BfbGlwKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKK30KKworLyoqCisgKiBMb2NhbCBGdW5jdGlvbnMuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2Zjc19wb3J0X2xvb3Bfc2VuZF9wbG9naShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHU4IGFscGEpCit7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwID0gTlVMTDsKKwlpbnQgICAgICAgICAgICAgbGVuOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIGFscGEpOworCisJZmN4cCA9IGJmYV9mY3hwX2FsbG9jKE5VTEwsIHBvcnQtPmZjcy0+YmZhLCAwLCAwLCBOVUxMLCBOVUxMLCBOVUxMLAorCQkJCSAgTlVMTCk7CisJYmZhX2Fzc2VydChmY3hwKTsKKworCWxlbiA9IGZjX3Bsb2dpX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLCBhbHBhLAorCQkJICAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIDAsCisJCQkgICAgIHBvcnQtPnBvcnRfY2ZnLnB3d24sIHBvcnQtPnBvcnRfY2ZnLm53d24sCisJCQkJIGJmYV9wcG9ydF9nZXRfbWF4ZnJzaXplKHBvcnQtPmZjcy0+YmZhKSk7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywgQkZBX0ZBTFNFLAorCQkJICBGQ19DTEFTU18zLCBsZW4sICZmY2hzLAorCQkJICBiZmFfZmNzX3BvcnRfbG9vcF9wbG9naV9yZXNwb25zZSwgKHZvaWQgKilwb3J0LAorCQkJICBGQ19NQVhfUERVU1osIEZDX1JBX1RPVik7CisKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiAgIENhbGxlZCBieSBmY3hwIHRvIG5vdGlmeSB0aGUgUGxvZ2kgcmVzcG9uc2UKKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2xvb3BfcGxvZ2lfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkgdm9pZCAqY2JhcmcsIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCSB1MzIgcnNwX2xlbiwgdTMyIHJlc2lkX2xlbiwKKwkJCQkgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqKSBjYmFyZzsKKwlzdHJ1Y3QgZmNfbG9naV9zICAgICAqcGxvZ2lfcmVzcDsKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgKmVsc19jbWQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisKKwkvKgorCSAqIFNhbml0eSBDaGVja3MKKwkgKi8KKwlpZiAocmVxX3N0YXR1cyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByZXFfc3RhdHVzKTsKKwkJLyoKKwkJICogQHRvZG8KKwkJICogVGhpcyBjb3VsZCBtZWFuIHRoYXQgdGhlIGRldmljZSB3aXRoIHRoaXMgQVBMQSBkb2VzIG5vdAorCQkgKiBleGlzdCBvbiB0aGUgbG9vcC4KKwkJICovCisKKwkJcmV0dXJuOworCX0KKworCWVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSBCRkFfRkNYUF9SU1BfUExEKGZjeHApOworCXBsb2dpX3Jlc3AgPSAoc3RydWN0IGZjX2xvZ2lfcyAqKSBlbHNfY21kOworCisJaWYgKGVsc19jbWQtPmVsc19jb2RlID09IEZDX0VMU19BQ0MpIHsKKwkJYmZhX2Zjc19ycG9ydF9zdGFydChwb3J0LCByc3BfZmNocywgcGxvZ2lfcmVzcCk7CisJfSBlbHNlIHsKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIHBsb2dpX3Jlc3AtPmVsc19jbWQuZWxzX2NvZGUpOworCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworYmZhX3N0YXR1c190CitiZmFfZmNzX3BvcnRfbG9vcF9zZW5kX3Bsb2dpX2FjYyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHU4IGFscGEpCit7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCWludCAgICAgICAgICAgICBsZW47CisKKwliZmFfdHJjKHBvcnQtPmZjcywgYWxwYSk7CisKKwlmY3hwID0gYmZhX2ZjeHBfYWxsb2MoTlVMTCwgcG9ydC0+ZmNzLT5iZmEsIDAsIDAsIE5VTEwsIE5VTEwsIE5VTEwsCisJCQkJICBOVUxMKTsKKwliZmFfYXNzZXJ0KGZjeHApOworCisJbGVuID0gZmNfcGxvZ2lfYWNjX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLCBhbHBhLAorCQkJCSBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIDAsCisJCQkJIHBvcnQtPnBvcnRfY2ZnLnB3d24sIHBvcnQtPnBvcnRfY2ZnLm53d24sCisJCQkJIGJmYV9wcG9ydF9nZXRfbWF4ZnJzaXplKHBvcnQtPmZjcy0+YmZhKSk7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywgQkZBX0ZBTFNFLAorCQkJCSBGQ19DTEFTU18zLCBsZW4sICZmY2hzLAorCQkJCSBiZmFfZmNzX3BvcnRfbG9vcF9wbG9naV9hY2NfcmVzcG9uc2UsCisJCQkJICh2b2lkICopcG9ydCwgRkNfTUFYX1BEVVNaLCAwKTsgLyogTm8gcmVzcG9uc2UKKwkJCQkJCQkJICAqIGV4cGVjdGVkCisJCQkJCQkJCSAgKi8KKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKgorICogIFBsb2dpIEFjYyBSZXNwb25zZQorICogV2UgZG9ub3QgZG8gYW55IHByb2Nlc3NpbmcgaGVyZS4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2xvb3BfcGxvZ2lfYWNjX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkJICAgICB2b2lkICpjYmFyZywgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJICAgICB1MzIgcnNwX2xlbiwgdTMyIHJlc2lkX2xlbiwKKwkJCQkgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKQoreworCisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqKSBjYmFyZzsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5waWQpOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCXJldHVybjsKKwl9Cit9CisKK2JmYV9zdGF0dXNfdAorYmZhX2Zjc19wb3J0X2xvb3Bfc2VuZF9hZGlzYyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHU4IGFscGEpCit7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCWludCAgICAgICAgICAgICBsZW47CisKKwliZmFfdHJjKHBvcnQtPmZjcywgYWxwYSk7CisKKwlmY3hwID0gYmZhX2ZjeHBfYWxsb2MoTlVMTCwgcG9ydC0+ZmNzLT5iZmEsIDAsIDAsIE5VTEwsIE5VTEwsIE5VTEwsCisJCQkJICBOVUxMKTsKKwliZmFfYXNzZXJ0KGZjeHApOworCisJbGVuID0gZmNfYWRpc2NfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksIGFscGEsCisJCQkgICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgMCwKKwkJCSAgICAgcG9ydC0+cG9ydF9jZmcucHd3biwgcG9ydC0+cG9ydF9jZmcubnd3bik7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywgQkZBX0ZBTFNFLAorCQkJICBGQ19DTEFTU18zLCBsZW4sICZmY2hzLAorCQkJICBiZmFfZmNzX3BvcnRfbG9vcF9hZGlzY19yZXNwb25zZSwgKHZvaWQgKilwb3J0LAorCQkJICBGQ19NQVhfUERVU1osIEZDX1JBX1RPVik7CisKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiAgIENhbGxlZCBieSBmY3hwIHRvIG5vdGlmeSB0aGUgQURJU0MgcmVzcG9uc2UKKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X2xvb3BfYWRpc2NfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkgdm9pZCAqY2JhcmcsIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCSB1MzIgcnNwX2xlbiwgdTMyIHJlc2lkX2xlbiwKKwkJCQkgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqKSBjYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKwlzdHJ1Y3QgZmNfYWRpc2NfcyAgICAgKmFkaXNjX3Jlc3A7CisJc3RydWN0IGZjX2Vsc19jbWRfcyAgICplbHNfY21kOworCXUzMiAgICAgICAgcGlkID0gcnNwX2ZjaHMtPnNfaWQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisKKwkvKgorCSAqIFNhbml0eSBDaGVja3MKKwkgKi8KKwlpZiAocmVxX3N0YXR1cyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCS8qCisJCSAqIFRCRCA6IHdlIG1heSBuZWVkIHRvIHJldHJ5IGNlcnRhaW4gcmVxdWVzdHMKKwkJICovCisJCWJmYV9mY3hwX2ZyZWUoZmN4cCk7CisJCXJldHVybjsKKwl9CisKKwllbHNfY21kID0gKHN0cnVjdCBmY19lbHNfY21kX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKwlhZGlzY19yZXNwID0gKHN0cnVjdCBmY19hZGlzY19zICopIGVsc19jbWQ7CisKKwlpZiAoZWxzX2NtZC0+ZWxzX2NvZGUgPT0gRkNfRUxTX0FDQykgeworCX0gZWxzZSB7CisJCWJmYV90cmMocG9ydC0+ZmNzLCBhZGlzY19yZXNwLT5lbHNfY21kLmVsc19jb2RlKTsKKworCQkvKgorCQkgKiBUQkQ6IHdlIG1heSBuZWVkIHRvIGNoZWNrIGZvciByZWplY3QgY29kZXMgYW5kIHJldHJ5CisJCSAqLworCQlycG9ydCA9IGJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfYnlfcGlkKHBvcnQsIHBpZCk7CisJCWlmIChycG9ydCkgeworCQkJbGlzdF9kZWwoJnJwb3J0LT5xZSk7CisJCQliZmFfZmNzX3Jwb3J0X2RlbGV0ZShycG9ydCk7CisJCX0KKworCX0KKwlyZXR1cm47Cit9CisKK2JmYV9zdGF0dXNfdAorYmZhX2Zjc19wb3J0X2xvb3Bfc2VuZF9hZGlzY19hY2Moc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB1OCBhbHBhKQoreworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwlpbnQgICAgICAgICAgICAgbGVuOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIGFscGEpOworCisJZmN4cCA9IGJmYV9mY3hwX2FsbG9jKE5VTEwsIHBvcnQtPmZjcy0+YmZhLCAwLCAwLCBOVUxMLCBOVUxMLCBOVUxMLAorCQkJCSAgTlVMTCk7CisJYmZhX2Fzc2VydChmY3hwKTsKKworCWxlbiA9IGZjX2FkaXNjX2FjY19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgYWxwYSwKKwkJCQkgYmZhX2Zjc19wb3J0X2dldF9mY2lkKHBvcnQpLCAwLAorCQkJCSBwb3J0LT5wb3J0X2NmZy5wd3duLCBwb3J0LT5wb3J0X2NmZy5ud3duKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCQkJRkNfQ0xBU1NfMywgbGVuLCAmZmNocywKKwkJCQliZmFfZmNzX3BvcnRfbG9vcF9hZGlzY19hY2NfcmVzcG9uc2UsCisJCQkJKHZvaWQgKilwb3J0LCBGQ19NQVhfUERVU1osIDApOyAvKiBubyByZXBvbnNlCisJCQkJCQkJCSAqIGV4cGVjdGVkCisJCQkJCQkJCSAqLworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qCisgKiAgQWRpc2MgQWNjIFJlc3BvbnNlCisgKiBXZSBkb25vdCBkbyBhbnkgcHJvY2Vzc2luZyBoZXJlLgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfbG9vcF9hZGlzY19hY2NfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkgICAgIHZvaWQgKmNiYXJnLCBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkgICAgIHUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJCSAgICAgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcG9ydF9zICopIGNiYXJnOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBpZCk7CisKKwkvKgorCSAqIFNhbml0eSBDaGVja3MKKwkgKi8KKwlpZiAocmVxX3N0YXR1cyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByZXFfc3RhdHVzKTsKKwkJcmV0dXJuOworCX0KK30KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvbHBvcnRfYXBpLmMgYi9kcml2ZXJzL3Njc2kvYmZhL2xwb3J0X2FwaS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhmNTFhODMKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL2xwb3J0X2FwaS5jCkBAIC0wLDAgKzEsMjkxIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIHBvcnRfYXBpLmMgQkZBIEZDUyBwb3J0CisgKi8KKworI2luY2x1ZGUgPGZjcy9iZmFfZmNzLmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfbHBvcnQuaD4KKyNpbmNsdWRlIDxmY3MvYmZhX2Zjc19ycG9ydC5oPgorI2luY2x1ZGUgImZjc19ycG9ydC5oIgorI2luY2x1ZGUgImZjc19mYWJyaWMuaCIKKyNpbmNsdWRlICJmY3NfdHJjbW9kLmgiCisjaW5jbHVkZSAiZmNzX3Zwb3J0LmgiCisKK0JGQV9UUkNfRklMRShGQ1MsIFBPUlRfQVBJKTsKKworCisKKy8qKgorICogIGZjc19wb3J0X2FwaSBCRkEgRkNTIHBvcnQgQVBJCisgKi8KKwordm9pZAorYmZhX2Zjc19jZmdfYmFzZV9wb3J0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcywgc3RydWN0IGJmYV9wb3J0X2NmZ19zICpwb3J0X2NmZykKK3sKK30KKworc3RydWN0IGJmYV9mY3NfcG9ydF9zICoKK2JmYV9mY3NfZ2V0X2Jhc2VfcG9ydChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7CisJcmV0dXJuICgmZmNzLT5mYWJyaWMuYnBvcnQpOworfQorCit3d25fdAorYmZhX2Zjc19wb3J0X2dldF9ycG9ydChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90IHd3biwgaW50IGluZGV4LAorCQkgICAgICAgaW50IG5ycG9ydHMsIGJmYV9ib29sZWFuX3QgYnd3bikKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpxaCwgKnFlOworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gTlVMTDsKKwlpbnQgICAgICAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX2Zjc19zICpmY3M7CisKKwlpZiAocG9ydCA9PSBOVUxMIHx8IG5ycG9ydHMgPT0gMCkKKwkJcmV0dXJuICh3d25fdCkgMDsKKworCWZjcyA9IHBvcnQtPmZjczsKKwliZmFfdHJjKGZjcywgKHUzMikgbnJwb3J0cyk7CisKKwlpID0gMDsKKwlxaCA9ICZwb3J0LT5ycG9ydF9xOworCXFlID0gYmZhX3FfZmlyc3QocWgpOworCisJd2hpbGUgKChxZSAhPSBxaCkgJiYgKGkgPCBucnBvcnRzKSkgeworCQlycG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopcWU7CisJCWlmIChiZmFfb3NfbnRvaDNiKHJwb3J0LT5waWQpID4gMHhGRkYwMDApIHsKKwkJCXFlID0gYmZhX3FfbmV4dChxZSk7CisJCQliZmFfdHJjKGZjcywgKHUzMikgcnBvcnQtPnB3d24pOworCQkJYmZhX3RyYyhmY3MsIHJwb3J0LT5waWQpOworCQkJYmZhX3RyYyhmY3MsIGkpOworCQkJY29udGludWU7CisJCX0KKworCQlpZiAoYnd3bikgeworCQkJaWYgKCFtZW1jbXAoJnd3biwgJnJwb3J0LT5wd3duLCA4KSkKKwkJCQlicmVhazsKKwkJfSBlbHNlIHsKKwkJCWlmIChpID09IGluZGV4KQorCQkJCWJyZWFrOworCQl9CisKKwkJaSsrOworCQlxZSA9IGJmYV9xX25leHQocWUpOworCX0KKworCWJmYV90cmMoZmNzLCBpKTsKKwlpZiAocnBvcnQpIHsKKwkJcmV0dXJuIHJwb3J0LT5wd3duOworCX0gZWxzZSB7CisJCXJldHVybiAod3duX3QpIDA7CisJfQorfQorCit2b2lkCitiZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0cyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90IHJwb3J0X3d3bnNbXSwKKwkJCWludCAqbnJwb3J0cykKK3sKKwlzdHJ1Y3QgbGlzdF9oZWFkICpxaCwgKnFlOworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gTlVMTDsKKwlpbnQgICAgICAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX2Zjc19zICpmY3M7CisKKwlpZiAocG9ydCA9PSBOVUxMIHx8IHJwb3J0X3d3bnMgPT0gTlVMTCB8fCAqbnJwb3J0cyA9PSAwKQorCQlyZXR1cm47CisKKwlmY3MgPSBwb3J0LT5mY3M7CisJYmZhX3RyYyhmY3MsICh1MzIpICpucnBvcnRzKTsKKworCWkgPSAwOworCXFoID0gJnBvcnQtPnJwb3J0X3E7CisJcWUgPSBiZmFfcV9maXJzdChxaCk7CisKKwl3aGlsZSAoKHFlICE9IHFoKSAmJiAoaSA8ICpucnBvcnRzKSkgeworCQlycG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopcWU7CisJCWlmIChiZmFfb3NfbnRvaDNiKHJwb3J0LT5waWQpID4gMHhGRkYwMDApIHsKKwkJCXFlID0gYmZhX3FfbmV4dChxZSk7CisJCQliZmFfdHJjKGZjcywgKHUzMikgcnBvcnQtPnB3d24pOworCQkJYmZhX3RyYyhmY3MsIHJwb3J0LT5waWQpOworCQkJYmZhX3RyYyhmY3MsIGkpOworCQkJY29udGludWU7CisJCX0KKworCQlycG9ydF93d25zW2ldID0gcnBvcnQtPnB3d247CisKKwkJaSsrOworCQlxZSA9IGJmYV9xX25leHQocWUpOworCX0KKworCWJmYV90cmMoZmNzLCBpKTsKKwkqbnJwb3J0cyA9IGk7CisJcmV0dXJuOworfQorCisvKgorICogSXRlcmF0ZSdzIHRocm91Z2ggYWxsIHRoZSBycG9ydCdzIGluIHRoZSBnaXZlbiBwb3J0IHRvCisgKiBkZXRlcm1pbmUgdGhlIG1heGltdW0gb3BlcmF0aW5nIHNwZWVkLgorICovCitlbnVtIGJmYV9wcG9ydF9zcGVlZAorYmZhX2Zjc19wb3J0X2dldF9ycG9ydF9tYXhfc3BlZWQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBsaXN0X2hlYWQgKnFoLCAqcWU7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSBOVUxMOworCXN0cnVjdCBiZmFfZmNzX3MgKmZjczsKKwllbnVtIGJmYV9wcG9ydF9zcGVlZCBtYXhfc3BlZWQgPSAwOworCXN0cnVjdCBiZmFfcHBvcnRfYXR0cl9zIHBwb3J0X2F0dHI7CisJZW51bSBiZmFfcHBvcnRfc3BlZWQgcHBvcnRfc3BlZWQ7CisKKwlpZiAocG9ydCA9PSBOVUxMKQorCQlyZXR1cm4gMDsKKworCWZjcyA9IHBvcnQtPmZjczsKKworCS8qCisJICogR2V0IFBoeXNpY2FsIHBvcnQncyBjdXJyZW50IHNwZWVkCisJICovCisJYmZhX3Bwb3J0X2dldF9hdHRyKHBvcnQtPmZjcy0+YmZhLCAmcHBvcnRfYXR0cik7CisJcHBvcnRfc3BlZWQgPSBwcG9ydF9hdHRyLnNwZWVkOworCWJmYV90cmMoZmNzLCBwcG9ydF9zcGVlZCk7CisKKwlxaCA9ICZwb3J0LT5ycG9ydF9xOworCXFlID0gYmZhX3FfZmlyc3QocWgpOworCisJd2hpbGUgKHFlICE9IHFoKSB7CisJCXJwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKilxZTsKKwkJaWYgKChiZmFfb3NfbnRvaDNiKHJwb3J0LT5waWQpID4gMHhGRkYwMDApCisJCSAgICB8fCAoYmZhX2Zjc19ycG9ydF9nZXRfc3RhdGUocnBvcnQpID09IEJGQV9SUE9SVF9PRkZMSU5FKSkgeworCQkJcWUgPSBiZmFfcV9uZXh0KHFlKTsKKwkJCWNvbnRpbnVlOworCQl9CisKKwkJaWYgKChycG9ydC0+cnBmLnJwc2Nfc3BlZWQgPT0gQkZBX1BQT1JUX1NQRUVEXzhHQlBTKQorCQkgICAgfHwgKHJwb3J0LT5ycGYucnBzY19zcGVlZCA+IHBwb3J0X3NwZWVkKSkgeworCQkJbWF4X3NwZWVkID0gcnBvcnQtPnJwZi5ycHNjX3NwZWVkOworCQkJYnJlYWs7CisJCX0gZWxzZSBpZiAocnBvcnQtPnJwZi5ycHNjX3NwZWVkID4gbWF4X3NwZWVkKSB7CisJCQltYXhfc3BlZWQgPSBycG9ydC0+cnBmLnJwc2Nfc3BlZWQ7CisJCX0KKworCQlxZSA9IGJmYV9xX25leHQocWUpOworCX0KKworCWJmYV90cmMoZmNzLCBtYXhfc3BlZWQpOworCXJldHVybiBtYXhfc3BlZWQ7Cit9CisKK3N0cnVjdCBiZmFfZmNzX3BvcnRfcyAqCitiZmFfZmNzX2xvb2t1cF9wb3J0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcywgdTE2IHZmX2lkLCB3d25fdCBscHd3bikKK3sKKwlzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydDsKKwliZmFfZmNzX3ZmX3QgICAqdmY7CisKKwliZmFfYXNzZXJ0KGZjcyAhPSBOVUxMKTsKKworCXZmID0gYmZhX2Zjc192Zl9sb29rdXAoZmNzLCB2Zl9pZCk7CisJaWYgKHZmID09IE5VTEwpIHsKKwkJYmZhX3RyYyhmY3MsIHZmX2lkKTsKKwkJcmV0dXJuIChOVUxMKTsKKwl9CisKKwlpZiAoIWxwd3duIHx8ICh2Zi0+YnBvcnQucG9ydF9jZmcucHd3biA9PSBscHd3bikpCisJCXJldHVybiAoJnZmLT5icG9ydCk7CisKKwl2cG9ydCA9IGJmYV9mY3NfZmFicmljX3Zwb3J0X2xvb2t1cCh2ZiwgbHB3d24pOworCWlmICh2cG9ydCkKKwkJcmV0dXJuICgmdnBvcnQtPmxwb3J0KTsKKworCXJldHVybiAoTlVMTCk7Cit9CisKKy8qCisgKiAgQVBJIGNvcnJlc3BvbmRpbmcgdG8gVm1XYXJlJ3MgTlBJVl9WUE9SVF9HRVRJTkZPLgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfZ2V0X2luZm8oc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkgICAgICBzdHJ1Y3QgYmZhX3BvcnRfaW5mb19zICpwb3J0X2luZm8pCit7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+ZmFicmljLT5mYWJyaWNfbmFtZSk7CisKKwlpZiAocG9ydC0+dnBvcnQgPT0gTlVMTCkgeworCQkvKgorCQkgKiBUaGlzIGlzIGEgUGh5c2ljYWwgcG9ydAorCQkgKi8KKwkJcG9ydF9pbmZvLT5wb3J0X3R5cGUgPSBCRkFfUE9SVF9UWVBFX1BIWVNJQ0FMOworCisJCS8qCisJCSAqIEB0b2RvIDogbmVlZCB0byBmaXggdGhlIHN0YXRlICYgcmVhc29uCisJCSAqLworCQlwb3J0X2luZm8tPnBvcnRfc3RhdGUgPSAwOworCQlwb3J0X2luZm8tPm9mZmxpbmVfcmVhc29uID0gMDsKKworCQlwb3J0X2luZm8tPnBvcnRfd3duID0gYmZhX2Zjc19wb3J0X2dldF9wd3duKHBvcnQpOworCQlwb3J0X2luZm8tPm5vZGVfd3duID0gYmZhX2Zjc19wb3J0X2dldF9ud3duKHBvcnQpOworCisJCXBvcnRfaW5mby0+bWF4X3Zwb3J0c19zdXBwID0gYmZhX2Zjc192cG9ydF9nZXRfbWF4KHBvcnQtPmZjcyk7CisJCXBvcnRfaW5mby0+bnVtX3Zwb3J0c19pbnVzZSA9CisJCQliZmFfZmNzX2ZhYnJpY192cG9ydF9jb3VudChwb3J0LT5mYWJyaWMpOworCQlwb3J0X2luZm8tPm1heF9ycG9ydHNfc3VwcCA9IEJGQV9GQ1NfTUFYX1JQT1JUU19TVVBQOworCQlwb3J0X2luZm8tPm51bV9ycG9ydHNfaW51c2UgPSBwb3J0LT5udW1fcnBvcnRzOworCX0gZWxzZSB7CisJCS8qCisJCSAqIFRoaXMgaXMgYSB2aXJ0dWFsIHBvcnQKKwkJICovCisJCXBvcnRfaW5mby0+cG9ydF90eXBlID0gQkZBX1BPUlRfVFlQRV9WSVJUVUFMOworCisJCS8qCisJCSAqIEB0b2RvIDogbmVlZCB0byBmaXggdGhlIHN0YXRlICYgcmVhc29uCisJCSAqLworCQlwb3J0X2luZm8tPnBvcnRfc3RhdGUgPSAwOworCQlwb3J0X2luZm8tPm9mZmxpbmVfcmVhc29uID0gMDsKKworCQlwb3J0X2luZm8tPnBvcnRfd3duID0gYmZhX2Zjc19wb3J0X2dldF9wd3duKHBvcnQpOworCQlwb3J0X2luZm8tPm5vZGVfd3duID0gYmZhX2Zjc19wb3J0X2dldF9ud3duKHBvcnQpOworCX0KK30KKwordm9pZAorYmZhX2Zjc19wb3J0X2dldF9zdGF0cyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmZjc19wb3J0LAorCQkgICAgICAgc3RydWN0IGJmYV9wb3J0X3N0YXRzX3MgKnBvcnRfc3RhdHMpCit7CisJYmZhX29zX21lbWNweShwb3J0X3N0YXRzLCAmZmNzX3BvcnQtPnN0YXRzLAorCQkgICAgICBzaXplb2Yoc3RydWN0IGJmYV9wb3J0X3N0YXRzX3MpKTsKKwlyZXR1cm47Cit9CisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9jbGVhcl9zdGF0cyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKmZjc19wb3J0KQoreworCWJmYV9vc19tZW1zZXQoJmZjc19wb3J0LT5zdGF0cywgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfcG9ydF9zdGF0c19zKSk7CisJcmV0dXJuOworfQorCit2b2lkCitiZmFfZmNzX3BvcnRfZW5hYmxlX2lwZmNfcm9sZXMoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpmY3NfcG9ydCkKK3sKKwlmY3NfcG9ydC0+cG9ydF9jZmcucm9sZXMgfD0gQkZBX1BPUlRfUk9MRV9GQ1BfSVBGQzsKKwlyZXR1cm47Cit9CisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9kaXNhYmxlX2lwZmNfcm9sZXMoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpmY3NfcG9ydCkKK3sKKwlmY3NfcG9ydC0+cG9ydF9jZmcucm9sZXMgJj0gfkJGQV9QT1JUX1JPTEVfRkNQX0lQRkM7CisJcmV0dXJuOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvbHBvcnRfcHJpdi5oIGIvZHJpdmVycy9zY3NpL2JmYS9scG9ydF9wcml2LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGJhZTM3MAotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvbHBvcnRfcHJpdi5oCkBAIC0wLDAgKzEsODIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2lmbmRlZiBfX1ZQX1BSSVZfSF9fCisjZGVmaW5lIF9fVlBfUFJJVl9IX18KKworI2luY2x1ZGUgPGZjcy9iZmFfZmNzX2xwb3J0Lmg+CisjaW5jbHVkZSA8ZmNzL2JmYV9mY3NfdnBvcnQuaD4KKworLyoKKyAqIEZ1bmN0aW9ucyBleHBvcnRlZCBieSB2cHMKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfdnBvcnRfaW5pdChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCk7CisKKy8qCisgKiBGdW5jdGlvbnMgZXhwb3J0ZWQgYnkgdnBzCisgKi8KK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3Zwc19vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3Zwc19vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCk7Cit2b2lkICAgICAgICAgICAgYmZhX2Zjc192cHNfbGlwKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCk7CisKKy8qCisgKiBGdW5jdGlvbnMgZXhwb3J0ZWQgYnkgcG9ydF9mYWIKKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9mYWJfaW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnZwb3J0KTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3BvcnRfZmFiX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnZwb3J0KTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3BvcnRfZmFiX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICp2cG9ydCk7Cit2b2lkICAgICAgICAgICAgYmZhX2Zjc19wb3J0X2ZhYl9yeF9mcmFtZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQkJCSAgdTggKnJ4X2ZyYW1lLCB1MzIgbGVuKTsKKworLyoKKyAqIEZ1bmN0aW9ucyBleHBvcnRlZCBieSBWUC1OUy4KKyAqLwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9uc19pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqdnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9uc19vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqdnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9uc19vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICp2cG9ydCk7Cit2b2lkICAgICAgICAgICAgYmZhX2Zjc19wb3J0X25zX3F1ZXJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCk7CisKKy8qCisgKiBGdW5jdGlvbnMgZXhwb3J0ZWQgYnkgVlAtU0NOCisgKi8KK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3BvcnRfc2NuX2luaXQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICp2cG9ydCk7Cit2b2lkICAgICAgICAgICAgYmZhX2Zjc19wb3J0X3Njbl9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqdnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9zY25fb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqdnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9zY25fcHJvY2Vzc19yc2NuKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkJICAgICAgc3RydWN0IGZjaHNfcyAqcnhfZnJhbWUsIHUzMiBsZW4pOworCisvKgorICogRnVuY3Rpb25zIGV4cG9ydGVkIGJ5IFZQLU4yTgorICovCisKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3BvcnRfbjJuX2luaXQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3BvcnRfbjJuX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9uMm5fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9uMm5fcnhfZnJhbWUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJCQkgIHU4ICpyeF9mcmFtZSwgdTMyIGxlbik7CisKKy8qCisgKiBGdW5jdGlvbnMgZXhwb3J0ZWQgYnkgVlAtTE9PUAorICovCit2b2lkICAgICAgICAgICAgYmZhX2Zjc19wb3J0X2xvb3BfaW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9sb29wX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOwordm9pZCAgICAgICAgICAgIGJmYV9mY3NfcG9ydF9sb29wX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3BvcnRfbG9vcF9saXAoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KTsKK3ZvaWQgICAgICAgICAgICBiZmFfZmNzX3BvcnRfbG9vcF9yeF9mcmFtZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsCisJCQkJCSAgIHU4ICpyeF9mcmFtZSwgdTMyIGxlbik7CisKKyNlbmRpZiAvKiBfX1ZQX1BSSVZfSF9fICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL21zLmMgYi9kcml2ZXJzL3Njc2kvYmZhL21zLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzk2YjNjYQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvbXMuYwpAQCAtMCwwICsxLDc1OSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisKKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImZjc19mY3hwLmgiCisjaW5jbHVkZSAibHBvcnRfcHJpdi5oIgorCitCRkFfVFJDX0ZJTEUoRkNTLCBNUyk7CisKKyNkZWZpbmUgQkZBX0ZDU19NU19DTURfTUFYX1JFVFJJRVMgIDIKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X21zX3NlbmRfcGxvZ2kodm9pZCAqbXNfY2JhcmcsCisJCQkJCSAgIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc190aW1lb3V0KHZvaWQgKmFyZyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X21zX3Bsb2dpX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCQkJICAgICAgIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCQkgICAgICAgdm9pZCAqY2JhcmcsCisJCQkJCSAgICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkJICAgICAgIHUzMiByc3BfbGVuLAorCQkJCQkgICAgICAgdTMyIHJlc2lkX2xlbiwKKwkJCQkJICAgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKKworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc19zZW5kX2dtYWwodm9pZCAqbXNfY2JhcmcsCisJCQkJCSAgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X21zX2dtYWxfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkgICAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJICAgICAgdm9pZCAqY2JhcmcsCisJCQkJCSAgICAgIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkgICAgICB1MzIgcnNwX2xlbiwKKwkJCQkJICAgICAgdTMyIHJlc2lkX2xlbiwKKwkJCQkJICAgICAgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc19zZW5kX2dmbih2b2lkICptc19jYmFyZywKKwkJCQkJIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc19nZm5fcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkgICAgIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCQkgICAgIHZvaWQgKmNiYXJnLAorCQkJCQkgICAgIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkgICAgIHUzMiByc3BfbGVuLAorCQkJCQkgICAgIHUzMiByZXNpZF9sZW4sCisJCQkJCSAgICAgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworLyoqCisgKiAgZmNzX21zX3NtIEZDUyBNUyBzdGF0ZSBtYWNoaW5lCisgKi8KKworLyoqCisgKiAgTVMgU3RhdGUgTWFjaGluZSBldmVudHMKKyAqLworZW51bSBwb3J0X21zX2V2ZW50IHsKKwlNU1NNX0VWRU5UX1BPUlRfT05MSU5FID0gMSwKKwlNU1NNX0VWRU5UX1BPUlRfT0ZGTElORSA9IDIsCisJTVNTTV9FVkVOVF9SU1BfT0sgPSAzLAorCU1TU01fRVZFTlRfUlNQX0VSUk9SID0gNCwKKwlNU1NNX0VWRU5UX1RJTUVPVVQgPSA1LAorCU1TU01fRVZFTlRfRkNYUF9TRU5UID0gNiwKKwlNU1NNX0VWRU5UX1BPUlRfRkFCUklDX1JTQ04gPSA3Cit9OworCitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X21zX3NtX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCQkJICAgZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbXNfc21fcGxvZ2lfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zLAorCQkJCQkJIGVudW0gcG9ydF9tc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X21zX3NtX3Bsb2dpKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMsCisJCQkJCSBlbnVtIHBvcnRfbXNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc19zbV9wbG9naV9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zLAorCQkJCQkgICAgICAgZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbXNfc21fZ21hbF9zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMsCisJCQkJCQllbnVtIHBvcnRfbXNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc19zbV9nbWFsKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMsCisJCQkJCWVudW0gcG9ydF9tc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X21zX3NtX2dtYWxfcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCQkJICAgICAgZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbXNfc21fZ2ZuX3NlbmRpbmcoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCQkJICAgICAgIGVudW0gcG9ydF9tc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X21zX3NtX2dmbihzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zLAorCQkJCSAgICAgICBlbnVtIHBvcnRfbXNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc19zbV9nZm5fcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCQkJICAgICBlbnVtIHBvcnRfbXNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9tc19zbV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCQkJICBlbnVtIHBvcnRfbXNfZXZlbnQgZXZlbnQpOworLyoqCisgKiAJCVN0YXJ0IGluIG9mZmxpbmUgc3RhdGUgLSBhd2FpdGluZyBOUyB0byBzZW5kIHN0YXJ0LgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3NtX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCSAgIGVudW0gcG9ydF9tc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIG1zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE1TU01fRVZFTlRfUE9SVF9PTkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9wbG9naV9zZW5kaW5nKTsKKwkJYmZhX2Zjc19wb3J0X21zX3NlbmRfcGxvZ2kobXMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTVNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbXNfc21fcGxvZ2lfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zLAorCQkJCSBlbnVtIHBvcnRfbXNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhtcy0+cG9ydC0+ZmNzLCBtcy0+cG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhtcy0+cG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBNU1NNX0VWRU5UX0ZDWFBfU0VOVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX3Bsb2dpKTsKKwkJYnJlYWs7CisKKwljYXNlIE1TU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChtcy0+cG9ydCksCisJCQkJICAgICAgICZtcy0+ZmN4cF93cWUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3NtX3Bsb2dpKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMsIGVudW0gcG9ydF9tc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIG1zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE1TU01fRVZFTlRfUlNQX0VSUk9SOgorCQkvKgorCQkgKiBTdGFydCB0aW1lciBmb3IgYSBkZWxheWVkIHJldHJ5CisJCSAqLworCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fcGxvZ2lfcmV0cnkpOworCQliZmFfdGltZXJfc3RhcnQoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChtcy0+cG9ydCksICZtcy0+dGltZXIsCisJCQkJYmZhX2Zjc19wb3J0X21zX3RpbWVvdXQsIG1zLAorCQkJCUJGQV9GQ1NfUkVUUllfVElNRU9VVCk7CisJCWJyZWFrOworCisJY2FzZSBNU1NNX0VWRU5UX1JTUF9PSzoKKwkJLyoKKwkJICogc2luY2UgcGxvZ2kgaXMgZG9uZSwgbm93IGludm9rZSBNUyByZWxhdGVkIHN1Yi1tb2R1bGVzCisJCSAqLworCQliZmFfZmNzX3BvcnRfZmRtaV9vbmxpbmUobXMpOworCisJCS8qKgorCQkgKiBpZiB0aGlzIGlzIGEgVnBvcnQsIGdvIHRvIG9ubGluZSBzdGF0ZS4KKwkJICovCisJCWlmIChtcy0+cG9ydC0+dnBvcnQpIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9vbmxpbmUpOworCQkJYnJlYWs7CisJCX0KKworCQkvKgorCQkgKiBGb3IgYSBiYXNlIHBvcnQgd2UgbmVlZCB0byBnZXQgdGhlCisJCSAqIHN3aXRjaCdzIElQIGFkZHJlc3MuCisJCSAqLworCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fZ21hbF9zZW5kaW5nKTsKKwkJYmZhX2Zjc19wb3J0X21zX3NlbmRfZ21hbChtcywgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBNU1NNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF9kaXNjYXJkKG1zLT5mY3hwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9tc19zbV9wbG9naV9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zLAorCQkJICAgICAgIGVudW0gcG9ydF9tc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIG1zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE1TU01fRVZFTlRfVElNRU9VVDoKKwkJLyoKKwkJICogUmV0cnkgVGltZXIgRXhwaXJlZC4gUmUtc2VuZAorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX3Bsb2dpX3NlbmRpbmcpOworCQliZmFfZmNzX3BvcnRfbXNfc2VuZF9wbG9naShtcywgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBNU1NNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX29mZmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmbXMtPnRpbWVyKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9tc19zbV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCSAgZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgbXMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTVNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9vZmZsaW5lKTsKKwkJLyoKKwkJICogbm93IGludm9rZSBNUyByZWxhdGVkIHN1Yi1tb2R1bGVzCisJCSAqLworCQliZmFfZmNzX3BvcnRfZmRtaV9vZmZsaW5lKG1zKTsKKwkJYnJlYWs7CisKKwljYXNlIE1TU01fRVZFTlRfUE9SVF9GQUJSSUNfUlNDTjoKKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX2dmbl9zZW5kaW5nKTsKKwkJbXMtPnJldHJ5X2NudCA9IDA7CisJCWJmYV9mY3NfcG9ydF9tc19zZW5kX2dmbihtcywgTlVMTCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbXNfc21fZ21hbF9zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMsCisJCQkJZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgbXMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTVNTTV9FVkVOVF9GQ1hQX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9nbWFsKTsKKwkJYnJlYWs7CisKKwljYXNlIE1TU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChtcy0+cG9ydCksCisJCQkJICAgICAgICZtcy0+ZmN4cF93cWUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3NtX2dtYWwoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywgZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgbXMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTVNTTV9FVkVOVF9SU1BfRVJST1I6CisJCS8qCisJCSAqIFN0YXJ0IHRpbWVyIGZvciBhIGRlbGF5ZWQgcmV0cnkKKwkJICovCisJCWlmIChtcy0+cmV0cnlfY250KysgPCBCRkFfRkNTX01TX0NNRF9NQVhfUkVUUklFUykgeworCQkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX2dtYWxfcmV0cnkpOworCQkJYmZhX3RpbWVyX3N0YXJ0KEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQobXMtPnBvcnQpLAorCQkJCQkmbXMtPnRpbWVyLCBiZmFfZmNzX3BvcnRfbXNfdGltZW91dCwgbXMsCisJCQkJCUJGQV9GQ1NfUkVUUllfVElNRU9VVCk7CisJCX0gZWxzZSB7CisJCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fZ2ZuX3NlbmRpbmcpOworCQkJYmZhX2Zjc19wb3J0X21zX3NlbmRfZ2ZuKG1zLCBOVUxMKTsKKwkJCW1zLT5yZXRyeV9jbnQgPSAwOworCQl9CisJCWJyZWFrOworCisJY2FzZSBNU1NNX0VWRU5UX1JTUF9PSzoKKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX2dmbl9zZW5kaW5nKTsKKwkJYmZhX2Zjc19wb3J0X21zX3NlbmRfZ2ZuKG1zLCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIE1TU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX2Rpc2NhcmQobXMtPmZjeHApOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3NtX2dtYWxfcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCSAgICAgIGVudW0gcG9ydF9tc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIG1zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE1TU01fRVZFTlRfVElNRU9VVDoKKwkJLyoKKwkJICogUmV0cnkgVGltZXIgRXhwaXJlZC4gUmUtc2VuZAorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX2dtYWxfc2VuZGluZyk7CisJCWJmYV9mY3NfcG9ydF9tc19zZW5kX2dtYWwobXMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTVNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJm1zLT50aW1lcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogIG1zX3B2dCBNUyBsb2NhbCBmdW5jdGlvbnMKKyAqLworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3NlbmRfZ21hbCh2b2lkICptc19jYmFyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zID0gbXNfY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gbXMtPnBvcnQ7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCWludCAgICAgICAgICAgICBsZW47CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cGlkKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJm1zLT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19wb3J0X21zX3NlbmRfZ21hbCwgbXMpOworCQlyZXR1cm47CisJfQorCW1zLT5mY3hwID0gZmN4cDsKKworCWxlbiA9IGZjX2dtYWxfcmVxX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLAorCQkJCWJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwKKwkJCQliZmFfbHBzX2dldF9wZWVyX253d24ocG9ydC0+ZmFicmljLT5scHMpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIGJmYV9mY3NfcG9ydF9tc19nbWFsX3Jlc3BvbnNlLAorCQkgICAgICAodm9pZCAqKW1zLCBGQ19NQVhfUERVU1osIEZDX1JBX1RPVik7CisKKwliZmFfc21fc2VuZF9ldmVudChtcywgTVNTTV9FVkVOVF9GQ1hQX1NFTlQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX2dtYWxfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCSAgICAgIHZvaWQgKmNiYXJnLCBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCSAgICAgIHUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJICAgICAgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcyA9IChzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKiljYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBtcy0+cG9ydDsKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gTlVMTDsKKwlzdHJ1Y3QgZmNnc19nbWFsX3Jlc3BfcyAqZ21hbF9yZXNwOworCXN0cnVjdCBmY19nbWFsX2VudHJ5X3MgKmdtYWxfZW50cnk7CisJdTMyICAgICAgICBudW1fZW50cmllczsKKwl1OCAgICAgICAgKnJzcF9zdHI7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG1zLCBNU1NNX0VWRU5UX1JTUF9FUlJPUik7CisJCXJldHVybjsKKwl9CisKKwljdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKwljdGhkci0+Y21kX3JzcF9jb2RlID0gYmZhX29zX250b2hzKGN0aGRyLT5jbWRfcnNwX2NvZGUpOworCisJaWYgKGN0aGRyLT5jbWRfcnNwX2NvZGUgPT0gQ1RfUlNQX0FDQ0VQVCkgeworCQlnbWFsX3Jlc3AgPSAoc3RydWN0IGZjZ3NfZ21hbF9yZXNwX3MgKikoY3RoZHIgKyAxKTsKKwkJbnVtX2VudHJpZXMgPSBiZmFfb3NfbnRvaGwoZ21hbF9yZXNwLT5tc19sZW4pOworCQlpZiAobnVtX2VudHJpZXMgPT0gMCkgeworCQkJYmZhX3NtX3NlbmRfZXZlbnQobXMsIE1TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwkJCXJldHVybjsKKwkJfQorCQkvKgorCQkgKiBUaGUgcmVzcG9uc2UgY291bGQgY29udGFpbiBtdWx0aXBsZSBFbnRyaWVzLgorCQkgKiBFbnRyaWVzIGZvciBTTk1QIGludGVyZmFjZSwgZXRjLgorCQkgKiBXZSBsb29rIGZvciB0aGUgZW50cnkgd2l0aCBhIHRlbG5ldCBwcmVmaXguCisJCSAqIEZpcnN0ICJodHRwOi8vIiBlbnRyeSByZWZlcnMgdG8gSVAgYWRkcgorCQkgKi8KKworCQlnbWFsX2VudHJ5ID0gKHN0cnVjdCBmY19nbWFsX2VudHJ5X3MgKilnbWFsX3Jlc3AtPm1zX21hOworCQl3aGlsZSAobnVtX2VudHJpZXMgPiAwKSB7CisJCQlpZiAoc3RybmNtcAorCQkJICAgIChnbWFsX2VudHJ5LT5wcmVmaXgsIENUX0dNQUxfUkVTUF9QUkVGSVhfSFRUUCwKKwkJCSAgICAgc2l6ZW9mKGdtYWxfZW50cnktPnByZWZpeCkpID09IDApIHsKKworCQkJCS8qCisJCQkJICogaWYgdGhlIElQIGFkZHJlc3MgaXMgdGVybWluYXRpbmcgd2l0aCBhICcvJywKKwkJCQkgKiByZW1vdmUgaXQuICpCeXRlIDAgY29uc2lzdHMgb2YgdGhlIGxlbmd0aAorCQkJCSAqIG9mIHRoZSBzdHJpbmcuCisJCQkJICovCisJCQkJcnNwX3N0ciA9ICYoZ21hbF9lbnRyeS0+cHJlZml4WzBdKTsKKwkJCQlpZiAocnNwX3N0cltnbWFsX2VudHJ5LT5sZW4gLSAxXSA9PSAnLycpCisJCQkJCXJzcF9zdHJbZ21hbF9lbnRyeS0+bGVuIC0gMV0gPSAwOworCQkJCS8qCisJCQkJICogY29weSBJUCBBZGRyZXNzIHRvIGZhYnJpYworCQkJCSAqLworCQkJCXN0cm5jcHkoYmZhX2Zjc19wb3J0X2dldF9mYWJyaWNfaXBhZGRyKHBvcnQpLAorCQkJCQlnbWFsX2VudHJ5LT5pcF9hZGRyLAorCQkJCQlCRkFfRkNTX0ZBQlJJQ19JUEFERFJfU1opOworCQkJCWJyZWFrOworCQkJfSBlbHNlIHsKKwkJCQktLW51bV9lbnRyaWVzOworCQkJCSsrZ21hbF9lbnRyeTsKKwkJCX0KKwkJfQorCisJCWJmYV9zbV9zZW5kX2V2ZW50KG1zLCBNU1NNX0VWRU5UX1JTUF9PSyk7CisJCXJldHVybjsKKwl9CisKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPnJlYXNvbl9jb2RlKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPmV4cF9jb2RlKTsKKwliZmFfc21fc2VuZF9ldmVudChtcywgTVNTTV9FVkVOVF9SU1BfRVJST1IpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3NtX2dmbl9zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMsCisJCQkgICAgICAgZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgbXMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTVNTTV9FVkVOVF9GQ1hQX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9nZm4pOworCQlicmVhazsKKworCWNhc2UgTVNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChCRkFfRkNTX0dFVF9IQUxfRlJPTV9QT1JUKG1zLT5wb3J0KSwKKwkJCQkgICAgICAgJm1zLT5mY3hwX3dxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbXNfc21fZ2ZuKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMsIGVudW0gcG9ydF9tc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIG1zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG1zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE1TU01fRVZFTlRfUlNQX0VSUk9SOgorCQkvKgorCQkgKiBTdGFydCB0aW1lciBmb3IgYSBkZWxheWVkIHJldHJ5CisJCSAqLworCQlpZiAobXMtPnJldHJ5X2NudCsrIDwgQkZBX0ZDU19NU19DTURfTUFYX1JFVFJJRVMpIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9nZm5fcmV0cnkpOworCQkJYmZhX3RpbWVyX3N0YXJ0KEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQobXMtPnBvcnQpLAorCQkJCQkmbXMtPnRpbWVyLCBiZmFfZmNzX3BvcnRfbXNfdGltZW91dCwgbXMsCisJCQkJCUJGQV9GQ1NfUkVUUllfVElNRU9VVCk7CisJCX0gZWxzZSB7CisJCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fb25saW5lKTsKKwkJCW1zLT5yZXRyeV9jbnQgPSAwOworCQl9CisJCWJyZWFrOworCisJY2FzZSBNU1NNX0VWRU5UX1JTUF9PSzoKKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX29ubGluZSk7CisJCWJyZWFrOworCisJY2FzZSBNU1NNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShtcywgYmZhX2Zjc19wb3J0X21zX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF9kaXNjYXJkKG1zLT5mY3hwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9tc19zbV9nZm5fcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcywKKwkJCSAgICAgZW51bSBwb3J0X21zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgbXMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobXMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTVNTTV9FVkVOVF9USU1FT1VUOgorCQkvKgorCQkgKiBSZXRyeSBUaW1lciBFeHBpcmVkLiBSZS1zZW5kCisJCSAqLworCQliZmFfc21fc2V0X3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fZ2ZuX3NlbmRpbmcpOworCQliZmFfZmNzX3BvcnRfbXNfc2VuZF9nZm4obXMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTVNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJm1zLT50aW1lcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogIG1zX3B2dCBNUyBsb2NhbCBmdW5jdGlvbnMKKyAqLworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3NlbmRfZ2ZuKHZvaWQgKm1zX2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMgPSBtc19jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBtcy0+cG9ydDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJaW50ICAgICAgICAgICAgIGxlbjsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5waWQpOworCisJZmN4cCA9IGZjeHBfYWxsb2NlZCA/IGZjeHBfYWxsb2NlZCA6IGJmYV9mY3NfZmN4cF9hbGxvYyhwb3J0LT5mY3MpOworCWlmICghZmN4cCkgeworCQliZmFfZmN4cF9hbGxvY193YWl0KHBvcnQtPmZjcy0+YmZhLCAmbXMtPmZjeHBfd3FlLAorCQkJCSAgICBiZmFfZmNzX3BvcnRfbXNfc2VuZF9nZm4sIG1zKTsKKwkJcmV0dXJuOworCX0KKwltcy0+ZmN4cCA9IGZjeHA7CisKKwlsZW4gPSBmY19nZm5fcmVxX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLAorCQkJICAgICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwKKwkJCSAgICAgICBiZmFfbHBzX2dldF9wZWVyX253d24ocG9ydC0+ZmFicmljLT5scHMpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIGJmYV9mY3NfcG9ydF9tc19nZm5fcmVzcG9uc2UsCisJCSAgICAgICh2b2lkICopbXMsIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKworCWJmYV9zbV9zZW5kX2V2ZW50KG1zLCBNU1NNX0VWRU5UX0ZDWFBfU0VOVCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbXNfZ2ZuX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsIHZvaWQgKmNiYXJnLAorCQkJICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywgdTMyIHJzcF9sZW4sCisJCQkgICAgICAgdTMyIHJlc2lkX2xlbiwgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICptcyA9IChzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKiljYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBtcy0+cG9ydDsKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gTlVMTDsKKwl3d25fdCAgICAgICAgICAqZ2ZuX3Jlc3A7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG1zLCBNU1NNX0VWRU5UX1JTUF9FUlJPUik7CisJCXJldHVybjsKKwl9CisKKwljdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKwljdGhkci0+Y21kX3JzcF9jb2RlID0gYmZhX29zX250b2hzKGN0aGRyLT5jbWRfcnNwX2NvZGUpOworCisJaWYgKGN0aGRyLT5jbWRfcnNwX2NvZGUgPT0gQ1RfUlNQX0FDQ0VQVCkgeworCQlnZm5fcmVzcCA9ICh3d25fdCAqKSAoY3RoZHIgKyAxKTsKKwkJLyoKKwkJICogY2hlY2sgaWYgaXQgaGFzIGFjdHVhbGx5IGNoYW5nZWQKKwkJICovCisJCWlmICgobWVtY21wCisJCSAgICAgKCh2b2lkICopJmJmYV9mY3NfcG9ydF9nZXRfZmFicmljX25hbWUocG9ydCksIGdmbl9yZXNwLAorCQkgICAgICBzaXplb2Yod3duX3QpKSAhPSAwKSkKKwkJCWJmYV9mY3NfZmFicmljX3NldF9mYWJyaWNfbmFtZShwb3J0LT5mYWJyaWMsICpnZm5fcmVzcCk7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG1zLCBNU1NNX0VWRU5UX1JTUF9PSyk7CisJCXJldHVybjsKKwl9CisKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPnJlYXNvbl9jb2RlKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPmV4cF9jb2RlKTsKKwliZmFfc21fc2VuZF9ldmVudChtcywgTVNTTV9FVkVOVF9SU1BfRVJST1IpOworfQorCisvKioKKyAqICBtc19wdnQgTVMgbG9jYWwgZnVuY3Rpb25zCisgKi8KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9tc19zZW5kX3Bsb2dpKHZvaWQgKm1zX2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMgPSBtc19jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBtcy0+cG9ydDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJaW50ICAgICAgICAgICAgIGxlbjsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5waWQpOworCisJZmN4cCA9IGZjeHBfYWxsb2NlZCA/IGZjeHBfYWxsb2NlZCA6IGJmYV9mY3NfZmN4cF9hbGxvYyhwb3J0LT5mY3MpOworCWlmICghZmN4cCkgeworCQlwb3J0LT5zdGF0cy5tc19wbG9naV9hbGxvY193YWl0Kys7CisJCWJmYV9mY3hwX2FsbG9jX3dhaXQocG9ydC0+ZmNzLT5iZmEsICZtcy0+ZmN4cF93cWUsCisJCQkJICAgIGJmYV9mY3NfcG9ydF9tc19zZW5kX3Bsb2dpLCBtcyk7CisJCXJldHVybjsKKwl9CisJbXMtPmZjeHAgPSBmY3hwOworCisJbGVuID0gZmNfcGxvZ2lfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksCisJCQkgICAgIGJmYV9vc19odG9uM2IoRkNfTUdNVF9TRVJWRVIpLAorCQkJICAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIDAsCisJCQkgICAgIHBvcnQtPnBvcnRfY2ZnLnB3d24sIHBvcnQtPnBvcnRfY2ZnLm53d24sCisJCQkgICAgIGJmYV9wcG9ydF9nZXRfbWF4ZnJzaXplKHBvcnQtPmZjcy0+YmZhKSk7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywgQkZBX0ZBTFNFLAorCQkgICAgICBGQ19DTEFTU18zLCBsZW4sICZmY2hzLCBiZmFfZmNzX3BvcnRfbXNfcGxvZ2lfcmVzcG9uc2UsCisJCSAgICAgICh2b2lkICopbXMsIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKworCXBvcnQtPnN0YXRzLm1zX3Bsb2dpX3NlbnQrKzsKKwliZmFfc21fc2VuZF9ldmVudChtcywgTVNTTV9FVkVOVF9GQ1hQX1NFTlQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X21zX3Bsb2dpX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkgICAgICAgdm9pZCAqY2JhcmcsIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJICAgICAgIHUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJICAgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMgPSAoc3RydWN0IGJmYV9mY3NfcG9ydF9tc19zICopY2Jhcmc7CisKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBtcy0+cG9ydDsKKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgKmVsc19jbWQ7CisJc3RydWN0IGZjX2xzX3JqdF9zICAgICpsc19yanQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQlwb3J0LT5zdGF0cy5tc19wbG9naV9yc3BfZXJyKys7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByZXFfc3RhdHVzKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobXMsIE1TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwkJcmV0dXJuOworCX0KKworCWVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSBCRkFfRkNYUF9SU1BfUExEKGZjeHApOworCisJc3dpdGNoIChlbHNfY21kLT5lbHNfY29kZSkgeworCisJY2FzZSBGQ19FTFNfQUNDOgorCQlpZiAocnNwX2xlbiA8IHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSkgeworCQkJYmZhX3RyYyhwb3J0LT5mY3MsIHJzcF9sZW4pOworCQkJcG9ydC0+c3RhdHMubXNfcGxvZ2lfYWNjX2VycisrOworCQkJYmZhX3NtX3NlbmRfZXZlbnQobXMsIE1TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwkJCWJyZWFrOworCQl9CisJCXBvcnQtPnN0YXRzLm1zX3Bsb2dpX2FjY2VwdHMrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobXMsIE1TU01fRVZFTlRfUlNQX09LKTsKKwkJYnJlYWs7CisKKwljYXNlIEZDX0VMU19MU19SSlQ6CisJCWxzX3JqdCA9IChzdHJ1Y3QgZmNfbHNfcmp0X3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKworCQliZmFfdHJjKHBvcnQtPmZjcywgbHNfcmp0LT5yZWFzb25fY29kZSk7CisJCWJmYV90cmMocG9ydC0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlX2V4cGwpOworCisJCXBvcnQtPnN0YXRzLm1zX3JlamVjdHMrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobXMsIE1TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlwb3J0LT5zdGF0cy5tc19wbG9naV91bmtub3duX3JzcCsrOworCQliZmFfdHJjKHBvcnQtPmZjcywgZWxzX2NtZC0+ZWxzX2NvZGUpOworCQliZmFfc21fc2VuZF9ldmVudChtcywgTVNTTV9FVkVOVF9SU1BfRVJST1IpOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9tc190aW1lb3V0KHZvaWQgKmFyZykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqKWFyZzsKKworCW1zLT5wb3J0LT5zdGF0cy5tc190aW1lb3V0cysrOworCWJmYV9zbV9zZW5kX2V2ZW50KG1zLCBNU1NNX0VWRU5UX1RJTUVPVVQpOworfQorCisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9tc19pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zID0gQkZBX0ZDU19HRVRfTVNfRlJPTV9QT1JUKHBvcnQpOworCisJbXMtPnBvcnQgPSBwb3J0OworCWJmYV9zbV9zZXRfc3RhdGUobXMsIGJmYV9mY3NfcG9ydF9tc19zbV9vZmZsaW5lKTsKKworCS8qCisJICogSW52b2tlIGluaXQgcm91dGluZXMgb2Ygc3ViIG1vZHVsZXMuCisJICovCisJYmZhX2Zjc19wb3J0X2ZkbWlfaW5pdChtcyk7Cit9CisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9tc19vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X21zX3MgKm1zID0gQkZBX0ZDU19HRVRfTVNfRlJPTV9QT1JUKHBvcnQpOworCisJbXMtPnBvcnQgPSBwb3J0OworCWJmYV9zbV9zZW5kX2V2ZW50KG1zLCBNU1NNX0VWRU5UX1BPUlRfT0ZGTElORSk7Cit9CisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9tc19vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMgPSBCRkFfRkNTX0dFVF9NU19GUk9NX1BPUlQocG9ydCk7CisKKwltcy0+cG9ydCA9IHBvcnQ7CisJYmZhX3NtX3NlbmRfZXZlbnQobXMsIE1TU01fRVZFTlRfUE9SVF9PTkxJTkUpOworfQorCit2b2lkCitiZmFfZmNzX3BvcnRfbXNfZmFicmljX3JzY24oc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbXNfcyAqbXMgPSBCRkFfRkNTX0dFVF9NU19GUk9NX1BPUlQocG9ydCk7CisKKwkvKgorCSAqIEB0b2RvLiAgSGFuZGxlIHRoaXMgb25seSB3aGVuIGluIE9ubGluZSBzdGF0ZQorCSAqLworCWlmIChiZmFfc21fY21wX3N0YXRlKG1zLCBiZmFfZmNzX3BvcnRfbXNfc21fb25saW5lKSkKKwkJYmZhX3NtX3NlbmRfZXZlbnQobXMsIE1TU01fRVZFTlRfUE9SVF9GQUJSSUNfUlNDTik7Cit9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL24ybi5jIGIvZHJpdmVycy9zY3NpL2JmYS9uMm4uYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43MzU0NTY4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9uMm4uYwpAQCAtMCwwICsxLDEwNSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBuMm4uYyBuMm4gaW1wbGVtZW50YXRpb24uCisgKi8KKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImxwb3J0X3ByaXYuaCIKKworQkZBX1RSQ19GSUxFKEZDUywgTjJOKTsKKworLyoqCisgKiAgIENhbGxlZCBieSBmY3MvcG9ydCB0byBpbml0aWFsaXplIE4yTiB0b3BvbG9neS4KKyAqLwordm9pZAorYmZhX2Zjc19wb3J0X24ybl9pbml0KHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKK30KKworLyoqCisgKiAgIENhbGxlZCBieSBmY3MvcG9ydCB0byBub3RpZnkgdHJhbnNpdGlvbiB0byBvbmxpbmUgc3RhdGUuCisgKi8KK3ZvaWQKK2JmYV9mY3NfcG9ydF9uMm5fb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X24ybl9zICpuMm5fcG9ydCA9ICZwb3J0LT5wb3J0X3RvcG8ucG4ybjsKKwlzdHJ1Y3QgYmZhX3BvcnRfY2ZnX3MgKnBjZmcgPSAmcG9ydC0+cG9ydF9jZmc7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcGNmZy0+cHd3bik7CisKKwkvKgorCSAqIElmIG91ciBQV1dOIGlzID4gdGhhbiB0aGF0IG9mIHRoZSByLXBvcnQsIHdlIGhhdmUgdG8gaW5pdGlhdGUgUExPR0kKKwkgKiBhbmQgYXNzaWduIGFuIEFkZHJlc3MuIGlmIG5vdCwgd2UgbmVlZCB0byB3YWl0IGZvciBpdHMgUExPR0kuCisJICoKKwkgKiBJZiBvdXIgUFdXTiBpcyA8IHRoYW4gdGhhdCBvZiB0aGUgcmVtb3RlIHBvcnQsIGl0IHdpbGwgc2VuZCBhIFBMT0dJCisJICogd2l0aCB0aGUgUElEcyBhc3NpZ25lZC4gVGhlIHJwb3J0IHN0YXRlIG1hY2hpbmUgdGFrZSBjYXJlIG9mIHRoaXMKKwkgKiBpbmNvbWluZyBQTE9HSS4KKwkgKi8KKwlpZiAobWVtY21wCisJICAgICgodm9pZCAqKSZwY2ZnLT5wd3duLCAodm9pZCAqKSZuMm5fcG9ydC0+cmVtX3BvcnRfd3duLAorCSAgICAgc2l6ZW9mKHd3bl90KSkgPiAwKSB7CisJCXBvcnQtPnBpZCA9IE4yTl9MT0NBTF9QSUQ7CisJCS8qKgorCQkgKiBGaXJzdCwgY2hlY2sgaWYgd2Uga25vdyB0aGUgZGV2aWNlIGJ5IHB3d24uCisJCSAqLworCQlycG9ydCA9IGJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfYnlfcHd3bihwb3J0LAorCQkJCQkJICAgICAgIG4ybl9wb3J0LT5yZW1fcG9ydF93d24pOworCQlpZiAocnBvcnQpIHsKKwkJCWJmYV90cmMocG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwkJCWJmYV90cmMocG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJCQlycG9ydC0+cGlkID0gTjJOX1JFTU9URV9QSUQ7CisJCQliZmFfZmNzX3Jwb3J0X29ubGluZShycG9ydCk7CisJCQlyZXR1cm47CisJCX0KKworCQkvKgorCQkgKiBJbiBuMm4gdGhlcmUgY2FuIGJlIG9ubHkgb25lIHJwb3J0LiBEZWxldGUgdGhlIG9sZCBvbmUgd2hvc2UKKwkJICogcGlkIHNob3VsZCBiZSB6ZXJvLCBiZWNhdXNlIGl0IGlzIG9mZmxpbmUuCisJCSAqLworCQlpZiAocG9ydC0+bnVtX3Jwb3J0cyA+IDApIHsKKwkJCXJwb3J0ID0gYmZhX2Zjc19wb3J0X2dldF9ycG9ydF9ieV9waWQocG9ydCwgMCk7CisJCQliZmFfYXNzZXJ0KHJwb3J0ICE9IE5VTEwpOworCQkJaWYgKHJwb3J0KSB7CisJCQkJYmZhX3RyYyhwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwkJCQliZmFfZmNzX3Jwb3J0X2RlbGV0ZShycG9ydCk7CisJCQl9CisJCX0KKwkJYmZhX2Zjc19ycG9ydF9jcmVhdGUocG9ydCwgTjJOX1JFTU9URV9QSUQpOworCX0KK30KKworLyoqCisgKiAgIENhbGxlZCBieSBmY3MvcG9ydCB0byBub3RpZnkgdHJhbnNpdGlvbiB0byBvZmZsaW5lIHN0YXRlLgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfbjJuX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbjJuX3MgKm4ybl9wb3J0ID0gJnBvcnQtPnBvcnRfdG9wby5wbjJuOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBpZCk7CisJcG9ydC0+cGlkID0gMDsKKwluMm5fcG9ydC0+cmVtX3BvcnRfd3duID0gMDsKKwluMm5fcG9ydC0+cmVwbHlfb3hpZCA9IDA7Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9ucy5jIGIvZHJpdmVycy9zY3NpL2JmYS9ucy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU5ZmVhOTkKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL25zLmMKQEAgLTAsMCArMSwxMjQzIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogQHBhZ2UgbnNfc21faW5mbyBWUE9SVCBOUyBTdGF0ZSBNYWNoaW5lCisgKgorICogQHNlY3Rpb24gbnNfc21faW50ZXJhY3Rpb25zIFZQT1JUIE5TIFN0YXRlIE1hY2hpbmUgSW50ZXJhY3Rpb25zCisgKgorICogQHNlY3Rpb24gbnNfc20gVlBPUlQgTlMgU3RhdGUgTWFjaGluZQorICogCWltZyBuc19zbS5qcGcKKyAqLworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlIDxiZmFfaW9jZmMuaD4KKyNpbmNsdWRlICJmY3NfbHBvcnQuaCIKKyNpbmNsdWRlICJmY3NfcnBvcnQuaCIKKyNpbmNsdWRlICJmY3NfdHJjbW9kLmgiCisjaW5jbHVkZSAiZmNzX2ZjeHAuaCIKKyNpbmNsdWRlICJmY3MuaCIKKyNpbmNsdWRlICJscG9ydF9wcml2LmgiCisKK0JGQV9UUkNfRklMRShGQ1MsIE5TKTsKKworLyoKKyAqIGZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc2VuZF9wbG9naSh2b2lkICpuc19jYmFyZywKKwkJCQkJICAgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X25zX3NlbmRfcnNwbl9pZCh2b2lkICpuc19jYmFyZywKKwkJCQkJICAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc2VuZF9yZnRfaWQodm9pZCAqbnNfY2JhcmcsCisJCQkJCSAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc2VuZF9yZmZfaWQodm9pZCAqbnNfY2JhcmcsCisJCQkJCSAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc2VuZF9naWRfZnQodm9pZCAqbnNfY2JhcmcsCisJCQkJCSAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfdGltZW91dCh2b2lkICphcmcpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19wbG9naV9yZXNwb25zZSh2b2lkICpmY3NhcmcsCisJCQkJCSAgICAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJICAgICAgIHZvaWQgKmNiYXJnLAorCQkJCQkgICAgICAgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJCSAgICAgICB1MzIgcnNwX2xlbiwKKwkJCQkJICAgICAgIHUzMiByZXNpZF9sZW4sCisJCQkJCSAgICAgICBzdHJ1Y3QgZmNoc19zICpyc3BfZmNocyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X25zX3JzcG5faWRfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkJIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCQkJIHZvaWQgKmNiYXJnLAorCQkJCQkJIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkJIHUzMiByc3BfbGVuLAorCQkJCQkJIHUzMiByZXNpZF9sZW4sCisJCQkJCQkgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19yZnRfaWRfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkJCQl2b2lkICpjYmFyZywKKwkJCQkJCWJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkJdTMyIHJzcF9sZW4sCisJCQkJCQl1MzIgcmVzaWRfbGVuLAorCQkJCQkJc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19yZmZfaWRfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkJCQl2b2lkICpjYmFyZywKKwkJCQkJCWJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkJdTMyIHJzcF9sZW4sCisJCQkJCQl1MzIgcmVzaWRfbGVuLAorCQkJCQkJc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19naWRfZnRfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkJCQl2b2lkICpjYmFyZywKKwkJCQkJCWJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkJdTMyIHJzcF9sZW4sCisJCQkJCQl1MzIgcmVzaWRfbGVuLAorCQkJCQkJc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19wcm9jZXNzX2dpZGZ0X3BpZHMoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJCQkJICAgdTMyICpwaWRfYnVmLAorCQkJCQkJICAgdTMyIG5fcGlkcyk7CisKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfYm9vdF90YXJnZXRfZGlzYyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpOworLyoqCisgKiAgZmNzX25zX3NtIEZDUyBuYW1lc2VydmVyIGludGVyZmFjZSBzdGF0ZSBtYWNoaW5lCisgKi8KKworLyoqCisgKiBWUG9ydCBOUyBTdGF0ZSBNYWNoaW5lIGV2ZW50cworICovCitlbnVtIHZwb3J0X25zX2V2ZW50IHsKKwlOU1NNX0VWRU5UX1BPUlRfT05MSU5FID0gMSwKKwlOU1NNX0VWRU5UX1BPUlRfT0ZGTElORSA9IDIsCisJTlNTTV9FVkVOVF9QTE9HSV9TRU5UID0gMywKKwlOU1NNX0VWRU5UX1JTUF9PSyA9IDQsCisJTlNTTV9FVkVOVF9SU1BfRVJST1IgPSA1LAorCU5TU01fRVZFTlRfVElNRU9VVCA9IDYsCisJTlNTTV9FVkVOVF9OU19RVUVSWSA9IDcsCisJTlNTTV9FVkVOVF9SU1BOSURfU0VOVCA9IDgsCisJTlNTTV9FVkVOVF9SRlRJRF9TRU5UID0gOSwKKwlOU1NNX0VWRU5UX1JGRklEX1NFTlQgPSAxMCwKKwlOU1NNX0VWRU5UX0dJREZUX1NFTlQgPSAxMSwKK307CisKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCQkgICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fcGxvZ2lfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCQkJIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19zbV9wbG9naShzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCQkgZW51bSB2cG9ydF9uc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X25zX3NtX3Bsb2dpX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJCSAgICAgICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yc3BuX2lkKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJCQkgICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fcnNwbl9pZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCQkgICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fcnNwbl9pZF9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCQkJIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19zbV9zZW5kaW5nX3JmdF9pZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCQkJICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fcmZ0X2lkX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJCQllbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fcmZ0X2lkKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJCSAgZW51bSB2cG9ydF9uc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X25zX3NtX3NlbmRpbmdfcmZmX2lkKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJCQkgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19zbV9yZmZfaWRfcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkJCWVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19zbV9yZmZfaWQoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkJICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19naWRfZnQoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkJCSAgZW51bSB2cG9ydF9uc19ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X25zX3NtX2dpZF9mdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCQkgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19zbV9naWRfZnRfcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkJCWVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9uc19zbV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkJICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KTsKKy8qKgorICogCQlTdGFydCBpbiBvZmZsaW5lIHN0YXRlIC0gYXdhaXRpbmcgbGlua3VwCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJICAgZW51bSB2cG9ydF9uc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIG5zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE5TU01fRVZFTlRfUE9SVF9PTkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9wbG9naV9zZW5kaW5nKTsKKwkJYmZhX2Zjc19wb3J0X25zX3NlbmRfcGxvZ2kobnMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fcGxvZ2lfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJCSBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgbnMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTlNTTV9FVkVOVF9QTE9HSV9TRU5UOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fcGxvZ2kpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChCRkFfRkNTX0dFVF9IQUxfRlJPTV9QT1JUKG5zLT5wb3J0KSwKKwkJCQkgICAgICAgJm5zLT5mY3hwX3dxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fcGxvZ2koc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCSBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgbnMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTlNTTV9FVkVOVF9SU1BfRVJST1I6CisJCS8qCisJCSAqIFN0YXJ0IHRpbWVyIGZvciBhIGRlbGF5ZWQgcmV0cnkKKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9wbG9naV9yZXRyeSk7CisJCW5zLT5wb3J0LT5zdGF0cy5uc19yZXRyaWVzKys7CisJCWJmYV90aW1lcl9zdGFydChCRkFfRkNTX0dFVF9IQUxfRlJPTV9QT1JUKG5zLT5wb3J0KSwgJm5zLT50aW1lciwKKwkJCQliZmFfZmNzX3BvcnRfbnNfdGltZW91dCwgbnMsCisJCQkJQkZBX0ZDU19SRVRSWV9USU1FT1VUKTsKKwkJYnJlYWs7CisKKwljYXNlIE5TU01fRVZFTlRfUlNQX09LOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yc3BuX2lkKTsKKwkJYmZhX2Zjc19wb3J0X25zX3NlbmRfcnNwbl9pZChucywgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBOU1NNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF9kaXNjYXJkKG5zLT5mY3hwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9uc19zbV9wbG9naV9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJICAgICAgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBucy0+cG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBOU1NNX0VWRU5UX1RJTUVPVVQ6CisJCS8qCisJCSAqIFJldHJ5IFRpbWVyIEV4cGlyZWQuIFJlLXNlbmQKKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9wbG9naV9zZW5kaW5nKTsKKwkJYmZhX2Zjc19wb3J0X25zX3NlbmRfcGxvZ2kobnMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJm5zLT50aW1lcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yc3BuX2lkKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJICAgZW51bSB2cG9ydF9uc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIG5zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE5TU01fRVZFTlRfUlNQTklEX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9yc3BuX2lkKTsKKwkJYnJlYWs7CisKKwljYXNlIE5TU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChucy0+cG9ydCksCisJCQkJICAgICAgICZucy0+ZmN4cF93cWUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3NtX3JzcG5faWQoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCSAgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBucy0+cG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBOU1NNX0VWRU5UX1JTUF9FUlJPUjoKKwkJLyoKKwkJICogU3RhcnQgdGltZXIgZm9yIGEgZGVsYXllZCByZXRyeQorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX3JzcG5faWRfcmV0cnkpOworCQlucy0+cG9ydC0+c3RhdHMubnNfcmV0cmllcysrOworCQliZmFfdGltZXJfc3RhcnQoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChucy0+cG9ydCksICZucy0+dGltZXIsCisJCQkJYmZhX2Zjc19wb3J0X25zX3RpbWVvdXQsIG5zLAorCQkJCUJGQV9GQ1NfUkVUUllfVElNRU9VVCk7CisJCWJyZWFrOworCisJY2FzZSBOU1NNX0VWRU5UX1JTUF9PSzoKKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX3NlbmRpbmdfcmZ0X2lkKTsKKwkJYmZhX2Zjc19wb3J0X25zX3NlbmRfcmZ0X2lkKG5zLCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIE5TU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfZmN4cF9kaXNjYXJkKG5zLT5mY3hwKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX29mZmxpbmUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3NtX3JzcG5faWRfcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkgZW51bSB2cG9ydF9uc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIG5zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE5TU01fRVZFTlRfVElNRU9VVDoKKwkJLyoKKwkJICogUmV0cnkgVGltZXIgRXhwaXJlZC4gUmUtc2VuZAorCQkgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX3NlbmRpbmdfcnNwbl9pZCk7CisJCWJmYV9mY3NfcG9ydF9uc19zZW5kX3JzcG5faWQobnMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJm5zLT50aW1lcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yZnRfaWQoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBucy0+cG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBOU1NNX0VWRU5UX1JGVElEX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9yZnRfaWQpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChCRkFfRkNTX0dFVF9IQUxfRlJPTV9QT1JUKG5zLT5wb3J0KSwKKwkJCQkgICAgICAgJm5zLT5mY3hwX3dxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fcmZ0X2lkKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBucy0+cG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBOU1NNX0VWRU5UX1JTUF9PSzoKKwkJLyoKKwkJICogTm93IG1vdmUgdG8gcmVnaXN0ZXIgRkM0IEZlYXR1cmVzCisJCSAqLworCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yZmZfaWQpOworCQliZmFfZmNzX3BvcnRfbnNfc2VuZF9yZmZfaWQobnMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9SU1BfRVJST1I6CisJCS8qCisJCSAqIFN0YXJ0IHRpbWVyIGZvciBhIGRlbGF5ZWQgcmV0cnkKKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9yZnRfaWRfcmV0cnkpOworCQlucy0+cG9ydC0+c3RhdHMubnNfcmV0cmllcysrOworCQliZmFfdGltZXJfc3RhcnQoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChucy0+cG9ydCksICZucy0+dGltZXIsCisJCQkJYmZhX2Zjc19wb3J0X25zX3RpbWVvdXQsIG5zLAorCQkJCUJGQV9GQ1NfUkVUUllfVElNRU9VVCk7CisJCWJyZWFrOworCisJY2FzZSBOU1NNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF9kaXNjYXJkKG5zLT5mY3hwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9uc19zbV9yZnRfaWRfcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQllbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgbnMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTlNTTV9FVkVOVF9USU1FT1VUOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yZnRfaWQpOworCQliZmFfZmNzX3BvcnRfbnNfc2VuZF9yZnRfaWQobnMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJm5zLT50aW1lcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yZmZfaWQoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQkgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBucy0+cG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBOU1NNX0VWRU5UX1JGRklEX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9yZmZfaWQpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChCRkFfRkNTX0dFVF9IQUxfRlJPTV9QT1JUKG5zLT5wb3J0KSwKKwkJCQkgICAgICAgJm5zLT5mY3hwX3dxZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fcmZmX2lkKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkgIGVudW0gdnBvcnRfbnNfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBucy0+cG9ydC0+cG9ydF9jZmcucHd3bik7CisJYmZhX3RyYyhucy0+cG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBOU1NNX0VWRU5UX1JTUF9PSzoKKworCQkvKgorCQkgKiBJZiBtaW4gY2ZnIG1vZGUgaXMgZW5hYmxlZCwgd2UgZG9ub3QgaW5pdGlhdGUgcnBvcnQKKwkJICogZGlzY292ZXJ5IHdpdGggdGhlIGZhYnJpYy4gSW5zdGVhZCwgd2Ugd2lsbCByZXRyaWV2ZSB0aGUKKwkJICogYm9vdCB0YXJnZXRzIGZyb20gSEFML0ZXLgorCQkgKi8KKwkJaWYgKF9fZmNzX21pbl9jZmcobnMtPnBvcnQtPmZjcykpIHsKKwkJCWJmYV9mY3NfcG9ydF9uc19ib290X3RhcmdldF9kaXNjKG5zLT5wb3J0KTsKKwkJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vbmxpbmUpOworCQkJcmV0dXJuOworCQl9CisKKwkJLyoKKwkJICogSWYgdGhlIHBvcnQgcm9sZSBpcyBJbml0aWF0b3IgTW9kZSBpc3N1ZSBOUyBxdWVyeS4KKwkJICogSWYgaXQgaXMgVGFyZ2V0IE1vZGUsIHNraXAgdGhpcyBhbmQgZ28gdG8gb25saW5lLgorCQkgKi8KKwkJaWYgKEJGQV9GQ1NfVlBPUlRfSVNfSU5JVElBVE9SX01PREUobnMtPnBvcnQpKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19naWRfZnQpOworCQkJYmZhX2Zjc19wb3J0X25zX3NlbmRfZ2lkX2Z0KG5zLCBOVUxMKTsKKwkJfSBlbHNlIGlmIChCRkFfRkNTX1ZQT1JUX0lTX1RBUkdFVF9NT0RFKG5zLT5wb3J0KSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX29ubGluZSk7CisJCX0KKwkJLyoKKwkJICoga2ljayBvZmYgbWdtdCBzcnZyIHN0YXRlIG1hY2hpbmUKKwkJICovCisJCWJmYV9mY3NfcG9ydF9tc19vbmxpbmUobnMtPnBvcnQpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9SU1BfRVJST1I6CisJCS8qCisJCSAqIFN0YXJ0IHRpbWVyIGZvciBhIGRlbGF5ZWQgcmV0cnkKKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9yZmZfaWRfcmV0cnkpOworCQlucy0+cG9ydC0+c3RhdHMubnNfcmV0cmllcysrOworCQliZmFfdGltZXJfc3RhcnQoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChucy0+cG9ydCksICZucy0+dGltZXIsCisJCQkJYmZhX2Zjc19wb3J0X25zX3RpbWVvdXQsIG5zLAorCQkJCUJGQV9GQ1NfUkVUUllfVElNRU9VVCk7CisJCWJyZWFrOworCisJY2FzZSBOU1NNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX29mZmxpbmUpOworCQliZmFfZmN4cF9kaXNjYXJkKG5zLT5mY3hwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9uc19zbV9yZmZfaWRfcmV0cnkoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucywKKwkJCQllbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgbnMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTlNTTV9FVkVOVF9USU1FT1VUOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fc2VuZGluZ19yZmZfaWQpOworCQliZmFfZmNzX3BvcnRfbnNfc2VuZF9yZmZfaWQobnMsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJm5zLT50aW1lcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3NtX3NlbmRpbmdfZ2lkX2Z0KHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgbnMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTlNTTV9FVkVOVF9HSURGVF9TRU5UOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fZ2lkX2Z0KTsKKwkJYnJlYWs7CisKKwljYXNlIE5TU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoQkZBX0ZDU19HRVRfSEFMX0ZST01fUE9SVChucy0+cG9ydCksCisJCQkJICAgICAgICZucy0+ZmN4cF93cWUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3NtX2dpZF9mdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgbnMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTlNTTV9FVkVOVF9SU1BfT0s6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vbmxpbmUpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9SU1BfRVJST1I6CisJCS8qCisJCSAqIFRCRDogZm9yIGNlcnRhaW4gcmVqZWN0IGNvZGVzLCB3ZSBkb24ndCBuZWVkIHRvIHJldHJ5CisJCSAqLworCQkvKgorCQkgKiBTdGFydCB0aW1lciBmb3IgYSBkZWxheWVkIHJldHJ5CisJCSAqLworCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fZ2lkX2Z0X3JldHJ5KTsKKwkJbnMtPnBvcnQtPnN0YXRzLm5zX3JldHJpZXMrKzsKKwkJYmZhX3RpbWVyX3N0YXJ0KEJGQV9GQ1NfR0VUX0hBTF9GUk9NX1BPUlQobnMtPnBvcnQpLCAmbnMtPnRpbWVyLAorCQkJCWJmYV9mY3NfcG9ydF9uc190aW1lb3V0LCBucywKKwkJCQlCRkFfRkNTX1JFVFJZX1RJTUVPVVQpOworCQlicmVhazsKKworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChucy0+ZmN4cCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc21fZ2lkX2Z0X3JldHJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMsCisJCQkJZW51bSB2cG9ydF9uc19ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIG5zLT5wb3J0LT5wb3J0X2NmZy5wd3duKTsKKwliZmFfdHJjKG5zLT5wb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIE5TU01fRVZFTlRfVElNRU9VVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX3NlbmRpbmdfZ2lkX2Z0KTsKKwkJYmZhX2Zjc19wb3J0X25zX3NlbmRfZ2lkX2Z0KG5zLCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIE5TU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fb2ZmbGluZSk7CisJCWJmYV90aW1lcl9zdG9wKCZucy0+dGltZXIpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3NtX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zLAorCQkJICBlbnVtIHZwb3J0X25zX2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgbnMtPnBvcnQtPnBvcnRfY2ZnLnB3d24pOworCWJmYV90cmMobnMtPnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgTlNTTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUobnMsIGJmYV9mY3NfcG9ydF9uc19zbV9vZmZsaW5lKTsKKwkJYnJlYWs7CisKKwljYXNlIE5TU01fRVZFTlRfTlNfUVVFUlk6CisJCS8qCisJCSAqIElmIHRoZSBwb3J0IHJvbGUgaXMgSW5pdGlhdG9yIE1vZGUgaXNzdWUgTlMgcXVlcnkuCisJCSAqIElmIGl0IGlzIFRhcmdldCBNb2RlLCBza2lwIHRoaXMgYW5kIGdvIHRvIG9ubGluZS4KKwkJICovCisJCWlmIChCRkFfRkNTX1ZQT1JUX0lTX0lOSVRJQVRPUl9NT0RFKG5zLT5wb3J0KSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZShucywgYmZhX2Zjc19wb3J0X25zX3NtX3NlbmRpbmdfZ2lkX2Z0KTsKKwkJCWJmYV9mY3NfcG9ydF9uc19zZW5kX2dpZF9mdChucywgTlVMTCk7CisJCX07CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBuc19wdnQgTmFtZXNlcnZlciBsb2NhbCBmdW5jdGlvbnMKKyAqLworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3NlbmRfcGxvZ2kodm9pZCAqbnNfY2JhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucyA9IG5zX2NiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IG5zLT5wb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlpbnQgICAgICAgICAgICAgbGVuOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBpZCk7CisKKwlmY3hwID0gZmN4cF9hbGxvY2VkID8gZmN4cF9hbGxvY2VkIDogYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKSB7CisJCXBvcnQtPnN0YXRzLm5zX3Bsb2dpX2FsbG9jX3dhaXQrKzsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJm5zLT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19wb3J0X25zX3NlbmRfcGxvZ2ksIG5zKTsKKwkJcmV0dXJuOworCX0KKwlucy0+ZmN4cCA9IGZjeHA7CisKKwlsZW4gPSBmY19wbG9naV9idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwKKwkJCSAgICAgYmZhX29zX2h0b24zYihGQ19OQU1FX1NFUlZFUiksCisJCQkgICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgMCwKKwkJCSAgICAgcG9ydC0+cG9ydF9jZmcucHd3biwgcG9ydC0+cG9ydF9jZmcubnd3biwKKwkJCSAgICAgYmZhX3Bwb3J0X2dldF9tYXhmcnNpemUocG9ydC0+ZmNzLT5iZmEpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIGJmYV9mY3NfcG9ydF9uc19wbG9naV9yZXNwb25zZSwKKwkJICAgICAgKHZvaWQgKilucywgRkNfTUFYX1BEVVNaLCBGQ19SQV9UT1YpOworCXBvcnQtPnN0YXRzLm5zX3Bsb2dpX3NlbnQrKzsKKworCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1BMT0dJX1NFTlQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3Bsb2dpX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkgICAgICAgdm9pZCAqY2JhcmcsIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJICAgICAgIHUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJICAgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMgPSAoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICopY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gbnMtPnBvcnQ7CisJLyogc3RydWN0IGZjX2xvZ2lfcyAqcGxvZ2lfcmVzcDsgKi8KKwlzdHJ1Y3QgZmNfZWxzX2NtZF9zICAgKmVsc19jbWQ7CisJc3RydWN0IGZjX2xzX3JqdF9zICAgICpsc19yanQ7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCXBvcnQtPnN0YXRzLm5zX3Bsb2dpX3JzcF9lcnIrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwkJcmV0dXJuOworCX0KKworCWVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSBCRkFfRkNYUF9SU1BfUExEKGZjeHApOworCisJc3dpdGNoIChlbHNfY21kLT5lbHNfY29kZSkgeworCisJY2FzZSBGQ19FTFNfQUNDOgorCQlpZiAocnNwX2xlbiA8IHNpemVvZihzdHJ1Y3QgZmNfbG9naV9zKSkgeworCQkJYmZhX3RyYyhwb3J0LT5mY3MsIHJzcF9sZW4pOworCQkJcG9ydC0+c3RhdHMubnNfcGxvZ2lfYWNjX2VycisrOworCQkJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwkJCWJyZWFrOworCQl9CisJCXBvcnQtPnN0YXRzLm5zX3Bsb2dpX2FjY2VwdHMrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX09LKTsKKwkJYnJlYWs7CisKKwljYXNlIEZDX0VMU19MU19SSlQ6CisJCWxzX3JqdCA9IChzdHJ1Y3QgZmNfbHNfcmp0X3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKworCQliZmFfdHJjKHBvcnQtPmZjcywgbHNfcmp0LT5yZWFzb25fY29kZSk7CisJCWJmYV90cmMocG9ydC0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlX2V4cGwpOworCisJCXBvcnQtPnN0YXRzLm5zX3JlamVjdHMrKzsKKworCQliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SU1BfRVJST1IpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCXBvcnQtPnN0YXRzLm5zX3Bsb2dpX3Vua25vd25fcnNwKys7CisJCWJmYV90cmMocG9ydC0+ZmNzLCBlbHNfY21kLT5lbHNfY29kZSk7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1JTUF9FUlJPUik7CisJfQorfQorCisvKioKKyAqIFJlZ2lzdGVyIHRoZSBzeW1ib2xpYyBwb3J0IG5hbWUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc2VuZF9yc3BuX2lkKHZvaWQgKm5zX2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMgPSBuc19jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBucy0+cG9ydDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJaW50ICAgICAgICAgICAgIGxlbjsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwl1OCAgICAgICAgIHN5bWJsWzI1Nl07CisJdTggICAgICAgICpwc3ltYmwgPSAmc3ltYmxbMF07CisKKwliZmFfb3NfbWVtc2V0KHN5bWJsLCAwLCBzaXplb2Yoc3ltYmwpKTsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJcG9ydC0+c3RhdHMubnNfcnNwbmlkX2FsbG9jX3dhaXQrKzsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJm5zLT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19wb3J0X25zX3NlbmRfcnNwbl9pZCwgbnMpOworCQlyZXR1cm47CisJfQorCW5zLT5mY3hwID0gZmN4cDsKKworCS8qCisJICogZm9yIFYtUG9ydCwgZm9ybSBhIFBvcnQgU3ltYm9saWMgTmFtZQorCSAqLworCWlmIChwb3J0LT52cG9ydCkgeworCQkvKipGb3IgVnBvcnRzLAorCQkgKiAgd2UgYXBwZW5kIHRoZSB2cG9ydCdzIHBvcnQgc3ltYm9saWMgbmFtZSB0byB0aGF0IG9mIHRoZSBiYXNlIHBvcnQuCisJCSAqLworCisJCXN0cm5jcHkoKGNoYXIgKilwc3ltYmwsCisJCQkoY2hhciAqKQorCQkJJihiZmFfZmNzX3BvcnRfZ2V0X3BzeW1fbmFtZQorCQkJICAoYmZhX2Zjc19nZXRfYmFzZV9wb3J0KHBvcnQtPmZjcykpKSwKKwkJCXN0cmxlbigoY2hhciAqKQorCQkJICAgICAgICZiZmFfZmNzX3BvcnRfZ2V0X3BzeW1fbmFtZShiZmFfZmNzX2dldF9iYXNlX3BvcnQKKwkJCQkJCQkgICAocG9ydC0+ZmNzKSkpKTsKKworCQkvKgorCQkgKiBFbnN1cmUgd2UgaGF2ZSBhIG51bGwgdGVybWluYXRpbmcgc3RyaW5nLgorCQkgKi8KKwkJKChjaGFyICopCisJCSBwc3ltYmwpW3N0cmxlbigoY2hhciAqKQorCQkJCSZiZmFfZmNzX3BvcnRfZ2V0X3BzeW1fbmFtZQorCQkJCShiZmFfZmNzX2dldF9iYXNlX3BvcnQocG9ydC0+ZmNzKSkpXSA9IDA7CisKKwkJc3RybmNhdCgoY2hhciAqKXBzeW1ibCwKKwkJCShjaGFyICopJihiZmFfZmNzX3BvcnRfZ2V0X3BzeW1fbmFtZShwb3J0KSksCisJCQlzdHJsZW4oKGNoYXIgKikmYmZhX2Zjc19wb3J0X2dldF9wc3ltX25hbWUocG9ydCkpKTsKKwl9IGVsc2UgeworCQlwc3ltYmwgPSAodTggKikgJihiZmFfZmNzX3BvcnRfZ2V0X3BzeW1fbmFtZShwb3J0KSk7CisJfQorCisJbGVuID0gZmNfcnNwbmlkX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLAorCQkJICAgICAgYmZhX2Zjc19wb3J0X2dldF9mY2lkKHBvcnQpLCAwLCBwc3ltYmwpOworCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBOVUxMLCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsIEJGQV9GQUxTRSwKKwkJICAgICAgRkNfQ0xBU1NfMywgbGVuLCAmZmNocywgYmZhX2Zjc19wb3J0X25zX3JzcG5faWRfcmVzcG9uc2UsCisJCSAgICAgICh2b2lkICopbnMsIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKworCXBvcnQtPnN0YXRzLm5zX3JzcG5pZF9zZW50Kys7CisKKwliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SU1BOSURfU0VOVCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfcnNwbl9pZF9yZXNwb25zZSh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLAorCQkJCSB2b2lkICpjYmFyZywgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJIHUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJCSBzdHJ1Y3QgZmNoc19zICpyc3BfZmNocykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqKWNiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IG5zLT5wb3J0OworCXN0cnVjdCBjdF9oZHJfcyAgICAgICAqY3RoZHIgPSBOVUxMOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJLyoKKwkgKiBTYW5pdHkgQ2hlY2tzCisJICovCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCXBvcnQtPnN0YXRzLm5zX3JzcG5pZF9yc3BfZXJyKys7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1JTUF9FUlJPUik7CisJCXJldHVybjsKKwl9CisKKwljdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKwljdGhkci0+Y21kX3JzcF9jb2RlID0gYmZhX29zX250b2hzKGN0aGRyLT5jbWRfcnNwX2NvZGUpOworCisJaWYgKGN0aGRyLT5jbWRfcnNwX2NvZGUgPT0gQ1RfUlNQX0FDQ0VQVCkgeworCQlwb3J0LT5zdGF0cy5uc19yc3BuaWRfYWNjZXB0cysrOworCQliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SU1BfT0spOworCQlyZXR1cm47CisJfQorCisJcG9ydC0+c3RhdHMubnNfcnNwbmlkX3JlamVjdHMrKzsKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPnJlYXNvbl9jb2RlKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPmV4cF9jb2RlKTsKKwliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SU1BfRVJST1IpOworfQorCisvKioKKyAqIFJlZ2lzdGVyIEZDNC1UeXBlcworICogVEJELCBOZWVkIHRvIHJldHJpZXZlIHRoaXMgZnJvbSB0aGUgT1MgZHJpdmVyLCBpbiBjYXNlIElQRkMgaXMgZW5hYmxlZCA/CisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc2VuZF9yZnRfaWQodm9pZCAqbnNfY2JhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucyA9IG5zX2NiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IG5zLT5wb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlpbnQgICAgICAgICAgICAgbGVuOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBvcnRfY2ZnLnB3d24pOworCisJZmN4cCA9IGZjeHBfYWxsb2NlZCA/IGZjeHBfYWxsb2NlZCA6IGJmYV9mY3NfZmN4cF9hbGxvYyhwb3J0LT5mY3MpOworCWlmICghZmN4cCkgeworCQlwb3J0LT5zdGF0cy5uc19yZnRpZF9hbGxvY193YWl0Kys7CisJCWJmYV9mY3hwX2FsbG9jX3dhaXQocG9ydC0+ZmNzLT5iZmEsICZucy0+ZmN4cF93cWUsCisJCQkJICAgIGJmYV9mY3NfcG9ydF9uc19zZW5kX3JmdF9pZCwgbnMpOworCQlyZXR1cm47CisJfQorCW5zLT5mY3hwID0gZmN4cDsKKworCWxlbiA9IGZjX3JmdGlkX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLAorCQkJICAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIDAsCisJCQkgICAgIHBvcnQtPnBvcnRfY2ZnLnJvbGVzKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIGJmYV9mY3NfcG9ydF9uc19yZnRfaWRfcmVzcG9uc2UsCisJCSAgICAgICh2b2lkICopbnMsIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKworCXBvcnQtPnN0YXRzLm5zX3JmdGlkX3NlbnQrKzsKKwliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SRlRJRF9TRU5UKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9uc19yZnRfaWRfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQl2b2lkICpjYmFyZywgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJdTMyIHJzcF9sZW4sIHUzMiByZXNpZF9sZW4sCisJCQkJc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucyA9IChzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKiljYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBucy0+cG9ydDsKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gTlVMTDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKworCS8qCisJICogU2FuaXR5IENoZWNrcworCSAqLworCWlmIChyZXFfc3RhdHVzICE9IEJGQV9TVEFUVVNfT0spIHsKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIHJlcV9zdGF0dXMpOworCQlwb3J0LT5zdGF0cy5uc19yZnRpZF9yc3BfZXJyKys7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1JTUF9FUlJPUik7CisJCXJldHVybjsKKwl9CisKKwljdGhkciA9IChzdHJ1Y3QgY3RfaGRyX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKwljdGhkci0+Y21kX3JzcF9jb2RlID0gYmZhX29zX250b2hzKGN0aGRyLT5jbWRfcnNwX2NvZGUpOworCisJaWYgKGN0aGRyLT5jbWRfcnNwX2NvZGUgPT0gQ1RfUlNQX0FDQ0VQVCkgeworCQlwb3J0LT5zdGF0cy5uc19yZnRpZF9hY2NlcHRzKys7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1JTUF9PSyk7CisJCXJldHVybjsKKwl9CisKKwlwb3J0LT5zdGF0cy5uc19yZnRpZF9yZWplY3RzKys7CisJYmZhX3RyYyhwb3J0LT5mY3MsIGN0aGRyLT5yZWFzb25fY29kZSk7CisJYmZhX3RyYyhwb3J0LT5mY3MsIGN0aGRyLT5leHBfY29kZSk7CisJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX0VSUk9SKTsKK30KKworLyoqCisqIFJlZ2lzdGVyIEZDNC1GZWF0dXJlcyA6IFNob3VsZCBiZSBkb25lIGFmdGVyIFJGVF9JRAorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X25zX3NlbmRfcmZmX2lkKHZvaWQgKm5zX2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMgPSBuc19jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBucy0+cG9ydDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJaW50ICAgICAgICAgICAgIGxlbjsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwl1OCAgICAgICAgIGZjNF9mdHJzID0gMDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJcG9ydC0+c3RhdHMubnNfcmZmaWRfYWxsb2Nfd2FpdCsrOworCQliZmFfZmN4cF9hbGxvY193YWl0KHBvcnQtPmZjcy0+YmZhLCAmbnMtPmZjeHBfd3FlLAorCQkJCSAgICBiZmFfZmNzX3BvcnRfbnNfc2VuZF9yZmZfaWQsIG5zKTsKKwkJcmV0dXJuOworCX0KKwlucy0+ZmN4cCA9IGZjeHA7CisKKwlpZiAoQkZBX0ZDU19WUE9SVF9JU19JTklUSUFUT1JfTU9ERShucy0+cG9ydCkpIHsKKwkJZmM0X2Z0cnMgPSBGQ19HU19GQ1BfRkM0X0ZFQVRVUkVfSU5JVElBVE9SOworCX0gZWxzZSBpZiAoQkZBX0ZDU19WUE9SVF9JU19UQVJHRVRfTU9ERShucy0+cG9ydCkpIHsKKwkJZmM0X2Z0cnMgPSBGQ19HU19GQ1BfRkM0X0ZFQVRVUkVfVEFSR0VUOworCX0KKworCWxlbiA9IGZjX3JmZmlkX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLAorCQkJICAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIDAsIEZDX1RZUEVfRkNQLAorCQkJICAgICBmYzRfZnRycyk7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywgQkZBX0ZBTFNFLAorCQkgICAgICBGQ19DTEFTU18zLCBsZW4sICZmY2hzLCBiZmFfZmNzX3BvcnRfbnNfcmZmX2lkX3Jlc3BvbnNlLAorCQkgICAgICAodm9pZCAqKW5zLCBGQ19NQVhfUERVU1osIEZDX1JBX1RPVik7CisKKwlwb3J0LT5zdGF0cy5uc19yZmZpZF9zZW50Kys7CisJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUkZGSURfU0VOVCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfcmZmX2lkX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkJdm9pZCAqY2JhcmcsIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCXUzMiByc3BfbGVuLCB1MzIgcmVzaWRfbGVuLAorCQkJCXN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMgPSAoc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICopY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gbnMtPnBvcnQ7CisJc3RydWN0IGN0X2hkcl9zICAgICAgICpjdGhkciA9IE5VTEw7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cG9ydF9jZmcucHd3bik7CisKKwkvKgorCSAqIFNhbml0eSBDaGVja3MKKwkgKi8KKwlpZiAocmVxX3N0YXR1cyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByZXFfc3RhdHVzKTsKKwkJcG9ydC0+c3RhdHMubnNfcmZmaWRfcnNwX2VycisrOworCQliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SU1BfRVJST1IpOworCQlyZXR1cm47CisJfQorCisJY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIEJGQV9GQ1hQX1JTUF9QTEQoZmN4cCk7CisJY3RoZHItPmNtZF9yc3BfY29kZSA9IGJmYV9vc19udG9ocyhjdGhkci0+Y21kX3JzcF9jb2RlKTsKKworCWlmIChjdGhkci0+Y21kX3JzcF9jb2RlID09IENUX1JTUF9BQ0NFUFQpIHsKKwkJcG9ydC0+c3RhdHMubnNfcmZmaWRfYWNjZXB0cysrOworCQliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SU1BfT0spOworCQlyZXR1cm47CisJfQorCisJcG9ydC0+c3RhdHMubnNfcmZmaWRfcmVqZWN0cysrOworCWJmYV90cmMocG9ydC0+ZmNzLCBjdGhkci0+cmVhc29uX2NvZGUpOworCWJmYV90cmMocG9ydC0+ZmNzLCBjdGhkci0+ZXhwX2NvZGUpOworCisJaWYgKGN0aGRyLT5yZWFzb25fY29kZSA9PSBDVF9SU05fTk9UX1NVUFApIHsKKwkJLyoKKwkJICogaWYgdGhpcyBjb21tYW5kIGlzIG5vdCBzdXBwb3J0ZWQsIHdlIGRvbid0IHJldHJ5CisJCSAqLworCQliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9SU1BfT0spOworCX0gZWxzZSB7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1JTUF9FUlJPUik7CisJfQorfQorCisvKioKKyAqIFF1ZXJ5IEZhYnJpYyBmb3IgRkM0LVR5cGVzIERldmljZXMuCisgKgorKiAgVEJEIDogTmVlZCB0byB1c2UgYSBsb2NhbCAoRkNTIHByaXZhdGUpIHJlc3BvbnNlIGJ1ZmZlciwgc2luY2UgdGhlIHJlc3BvbnNlCisgKiBjYW4gYmUgbGFyZ2VyIHRoYW4gMksuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfc2VuZF9naWRfZnQodm9pZCAqbnNfY2JhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucyA9IG5zX2NiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IG5zLT5wb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlpbnQgICAgICAgICAgICAgbGVuOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPnBpZCk7CisKKwlmY3hwID0gZmN4cF9hbGxvY2VkID8gZmN4cF9hbGxvY2VkIDogYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKSB7CisJCXBvcnQtPnN0YXRzLm5zX2dpZGZ0X2FsbG9jX3dhaXQrKzsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJm5zLT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19wb3J0X25zX3NlbmRfZ2lkX2Z0LCBucyk7CisJCXJldHVybjsKKwl9CisJbnMtPmZjeHAgPSBmY3hwOworCisJLyoKKwkgKiBUaGlzIHF1ZXJ5IGlzIG9ubHkgaW5pdGlhdGVkIGZvciBGQ1AgaW5pdGlhdG9yIG1vZGUuCisJICovCisJbGVuID0gZmNfZ2lkX2Z0X2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLCBucy0+cG9ydC0+cGlkLAorCQkJICAgICAgRkNfVFlQRV9GQ1ApOworCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBOVUxMLCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsIEJGQV9GQUxTRSwKKwkJICAgICAgRkNfQ0xBU1NfMywgbGVuLCAmZmNocywgYmZhX2Zjc19wb3J0X25zX2dpZF9mdF9yZXNwb25zZSwKKwkJICAgICAgKHZvaWQgKilucywgYmZhX2ZjeHBfZ2V0X21heHJzcChwb3J0LT5mY3MtPmJmYSksCisJCSAgICAgIEZDX1JBX1RPVik7CisKKwlwb3J0LT5zdGF0cy5uc19naWRmdF9zZW50Kys7CisKKwliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9HSURGVF9TRU5UKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9uc19naWRfZnRfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQl2b2lkICpjYmFyZywgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkJdTMyIHJzcF9sZW4sIHUzMiByZXNpZF9sZW4sCisJCQkJc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucyA9IChzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKiljYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBucy0+cG9ydDsKKwlzdHJ1Y3QgY3RfaGRyX3MgICAgICAgKmN0aGRyID0gTlVMTDsKKwl1MzIgICAgICAgIG5fcGlkczsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKworCS8qCisJICogU2FuaXR5IENoZWNrcworCSAqLworCWlmIChyZXFfc3RhdHVzICE9IEJGQV9TVEFUVVNfT0spIHsKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIHJlcV9zdGF0dXMpOworCQlwb3J0LT5zdGF0cy5uc19naWRmdF9yc3BfZXJyKys7CisJCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1JTUF9FUlJPUik7CisJCXJldHVybjsKKwl9CisKKwlpZiAocmVzaWRfbGVuICE9IDApIHsKKwkJLyoKKwkJICogVEJEIDogd2Ugd2lsbCBuZWVkIHRvIGFsbG9jYXRlIGEgbGFyZ2VyIGJ1ZmZlciAmIHJldHJ5IHRoZQorCQkgKiBjb21tYW5kCisJCSAqLworCQliZmFfdHJjKHBvcnQtPmZjcywgcnNwX2xlbik7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByZXNpZF9sZW4pOworCQlyZXR1cm47CisJfQorCisJY3RoZHIgPSAoc3RydWN0IGN0X2hkcl9zICopIEJGQV9GQ1hQX1JTUF9QTEQoZmN4cCk7CisJY3RoZHItPmNtZF9yc3BfY29kZSA9IGJmYV9vc19udG9ocyhjdGhkci0+Y21kX3JzcF9jb2RlKTsKKworCXN3aXRjaCAoY3RoZHItPmNtZF9yc3BfY29kZSkgeworCisJY2FzZSBDVF9SU1BfQUNDRVBUOgorCisJCXBvcnQtPnN0YXRzLm5zX2dpZGZ0X2FjY2VwdHMrKzsKKwkJbl9waWRzID0gKGZjX2dldF9jdHJlc3BfcHlsZF9sZW4ocnNwX2xlbikgLyBzaXplb2YodTMyKSk7CisJCWJmYV90cmMocG9ydC0+ZmNzLCBuX3BpZHMpOworCQliZmFfZmNzX3BvcnRfbnNfcHJvY2Vzc19naWRmdF9waWRzKHBvcnQsCisJCQkJCQkgICAodTMyICopIChjdGhkciArIDEpLAorCQkJCQkJICAgbl9waWRzKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX09LKTsKKwkJYnJlYWs7CisKKwljYXNlIENUX1JTUF9SRUpFQ1Q6CisKKwkJLyoKKwkJICogQ2hlY2sgdGhlIHJlYXNvbiBjb2RlICAmIGV4cGxhbmF0aW9uLgorCQkgKiBUaGVyZSBtYXkgbm90IGhhdmUgYmVlbiBhbnkgRkM0IGRldmljZXMgaW4gdGhlIGZhYnJpYworCQkgKi8KKwkJcG9ydC0+c3RhdHMubnNfZ2lkZnRfcmVqZWN0cysrOworCQliZmFfdHJjKHBvcnQtPmZjcywgY3RoZHItPnJlYXNvbl9jb2RlKTsKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIGN0aGRyLT5leHBfY29kZSk7CisKKwkJaWYgKChjdGhkci0+cmVhc29uX2NvZGUgPT0gQ1RfUlNOX1VOQUJMRV9UT19QRVJGKQorCQkgICAgJiYgKGN0aGRyLT5leHBfY29kZSA9PSBDVF9OU19FWFBfRlRfTk9UX1JFRykpIHsKKworCQkJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX09LKTsKKwkJfSBlbHNlIHsKKwkJCS8qCisJCQkgKiBmb3IgYWxsIG90aGVyIGVycm9ycywgcmV0cnkKKwkJCSAqLworCQkJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwkJfQorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCXBvcnQtPnN0YXRzLm5zX2dpZGZ0X3Vua25vd25fcnNwKys7CisJCWJmYV90cmMocG9ydC0+ZmNzLCBjdGhkci0+Y21kX3JzcF9jb2RlKTsKKwkJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUlNQX0VSUk9SKTsKKwl9Cit9CisKKy8qKgorICogICAgIFRoaXMgcm91dGluZSB3aWxsIGJlIGNhbGxlZCBieSBiZmFfdGltZXIgb24gdGltZXIgdGltZW91dHMuCisgKgorICogCXBhcmFtW2luXSAJcG9ydCAJLSBwb2ludGVyIHRvIGJmYV9mY3NfcG9ydF90LgorICoKKyAqIAlyZXR1cm4KKyAqIAkJdm9pZAorICoKKyogCVNwZWNpYWwgQ29uc2lkZXJhdGlvbnM6CisgKgorICogCW5vdGUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9uc190aW1lb3V0KHZvaWQgKmFyZykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqKWFyZzsKKworCW5zLT5wb3J0LT5zdGF0cy5uc190aW1lb3V0cysrOworCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1RJTUVPVVQpOworfQorCisvKgorICogUHJvY2VzcyB0aGUgUElEIGxpc3QgaW4gR0lEX0ZUIHJlc3BvbnNlCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfcHJvY2Vzc19naWRmdF9waWRzKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkgICB1MzIgKnBpZF9idWYsIHUzMiBuX3BpZHMpCit7CisJc3RydWN0IGZjZ3NfZ2lkZnRfcmVzcF9zICpnaWRmdF9lbnRyeTsKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKwl1MzIgICAgICAgIGlpOworCisJZm9yIChpaSA9IDA7IGlpIDwgbl9waWRzOyBpaSsrKSB7CisJCWdpZGZ0X2VudHJ5ID0gKHN0cnVjdCBmY2dzX2dpZGZ0X3Jlc3BfcyAqKSAmcGlkX2J1ZltpaV07CisKKwkJaWYgKGdpZGZ0X2VudHJ5LT5waWQgPT0gcG9ydC0+cGlkKQorCQkJY29udGludWU7CisKKwkJLyoKKwkJICogQ2hlY2sgaWYgdGhpcyBycG9ydCBhbHJlYWR5IGV4aXN0cworCQkgKi8KKwkJcnBvcnQgPSBiZmFfZmNzX3BvcnRfZ2V0X3Jwb3J0X2J5X3BpZChwb3J0LCBnaWRmdF9lbnRyeS0+cGlkKTsKKwkJaWYgKHJwb3J0ID09IE5VTEwpIHsKKwkJCS8qCisJCQkgKiB0aGlzIGlzIGEgbmV3IGRldmljZS4gY3JlYXRlIHJwb3J0CisJCQkgKi8KKwkJCXJwb3J0ID0gYmZhX2Zjc19ycG9ydF9jcmVhdGUocG9ydCwgZ2lkZnRfZW50cnktPnBpZCk7CisJCX0gZWxzZSB7CisJCQkvKgorCQkJICogdGhpcyBycG9ydCBhbHJlYWR5IGV4aXN0cworCQkJICovCisJCQliZmFfZmNzX3Jwb3J0X3NjbihycG9ydCk7CisJCX0KKworCQliZmFfdHJjKHBvcnQtPmZjcywgZ2lkZnRfZW50cnktPnBpZCk7CisKKwkJLyoKKwkJICogaWYgdGhlIGxhc3QgZW50cnkgYml0IGlzIHNldCwgYmFpbCBvdXQuCisJCSAqLworCQlpZiAoZ2lkZnRfZW50cnktPmxhc3QpCisJCQlyZXR1cm47CisJfQorfQorCisvKioKKyAqICBmY3NfbnNfcHVibGljIEZDUyBuYW1lc2VydmVyIHB1YmxpYyBpbnRlcmZhY2VzCisgKi8KKworLyoKKyAqIEZ1bmN0aW9ucyBjYWxsZWQgYnkgcG9ydC9mYWIuCisgKiBUaGVzZSB3aWxsIHNlbmQgcmVsZXZhbnQgRXZlbnRzIHRvIHRoZSBucyBzdGF0ZSBtYWNoaW5lLgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfbnNfaW5pdChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9uc19zICpucyA9IEJGQV9GQ1NfR0VUX05TX0ZST01fUE9SVChwb3J0KTsKKworCW5zLT5wb3J0ID0gcG9ydDsKKwliZmFfc21fc2V0X3N0YXRlKG5zLCBiZmFfZmNzX3BvcnRfbnNfc21fb2ZmbGluZSk7Cit9CisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9uc19vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X25zX3MgKm5zID0gQkZBX0ZDU19HRVRfTlNfRlJPTV9QT1JUKHBvcnQpOworCisJbnMtPnBvcnQgPSBwb3J0OworCWJmYV9zbV9zZW5kX2V2ZW50KG5zLCBOU1NNX0VWRU5UX1BPUlRfT0ZGTElORSk7Cit9CisKK3ZvaWQKK2JmYV9mY3NfcG9ydF9uc19vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMgPSBCRkFfRkNTX0dFVF9OU19GUk9NX1BPUlQocG9ydCk7CisKKwlucy0+cG9ydCA9IHBvcnQ7CisJYmZhX3NtX3NlbmRfZXZlbnQobnMsIE5TU01fRVZFTlRfUE9SVF9PTkxJTkUpOworfQorCit2b2lkCitiZmFfZmNzX3BvcnRfbnNfcXVlcnkoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfbnNfcyAqbnMgPSBCRkFfRkNTX0dFVF9OU19GUk9NX1BPUlQocG9ydCk7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cGlkKTsKKwliZmFfc21fc2VuZF9ldmVudChucywgTlNTTV9FVkVOVF9OU19RVUVSWSk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfbnNfYm9vdF90YXJnZXRfZGlzYyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQpCit7CisKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKwl1OCAgICAgICAgIG53d25zOworCXd3bl90ICAgICAgICAgICp3d25zOworCWludCAgICAgICAgICAgICBpaTsKKworCWJmYV9pb2NmY19nZXRfYm9vdHd3bnMocG9ydC0+ZmNzLT5iZmEsICZud3ducywgJnd3bnMpOworCisJZm9yIChpaSA9IDA7IGlpIDwgbnd3bnM7ICsraWkpIHsKKwkJcnBvcnQgPSBiZmFfZmNzX3Jwb3J0X2NyZWF0ZV9ieV93d24ocG9ydCwgd3duc1tpaV0pOworCQliZmFfYXNzZXJ0KHJwb3J0KTsKKwl9Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9wbG9nLmMgYi9kcml2ZXJzL3Njc2kvYmZhL3Bsb2cuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44NmFmODE4Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS9wbG9nLmMKQEAgLTAsMCArMSwxODQgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYV9vc19pbmMuaD4KKyNpbmNsdWRlIDxjcy9iZmFfcGxvZy5oPgorI2luY2x1ZGUgPGNzL2JmYV9kZWJ1Zy5oPgorCitzdGF0aWMgaW50CitwbGtkX3ZhbGlkYXRlX2xvZ3JlYyhzdHJ1Y3QgYmZhX3Bsb2dfcmVjX3MgKnBsX3JlYykKK3sKKwlpZiAoKHBsX3JlYy0+bG9nX3R5cGUgIT0gQkZBX1BMX0xPR19UWVBFX0lOVCkKKwkgICAgJiYgKHBsX3JlYy0+bG9nX3R5cGUgIT0gQkZBX1BMX0xPR19UWVBFX1NUUklORykpCisJCXJldHVybiAxOworCisJaWYgKChwbF9yZWMtPmxvZ190eXBlICE9IEJGQV9QTF9MT0dfVFlQRV9JTlQpCisJICAgICYmIChwbF9yZWMtPmxvZ19udW1faW50cyA+IEJGQV9QTF9JTlRfTE9HX1NaKSkKKwkJcmV0dXJuIDE7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQKK2JmYV9wbG9nX2FkZChzdHJ1Y3QgYmZhX3Bsb2dfcyAqcGxvZywgc3RydWN0IGJmYV9wbG9nX3JlY19zICpwbF9yZWMpCit7CisJdTE2ICAgICAgICB0YWlsOworCXN0cnVjdCBiZmFfcGxvZ19yZWNfcyAqcGxfcmVjcDsKKworCWlmIChwbG9nLT5wbG9nX2VuYWJsZWQgPT0gMCkKKwkJcmV0dXJuOworCisJaWYgKHBsa2RfdmFsaWRhdGVfbG9ncmVjKHBsX3JlYykpIHsKKwkJYmZhX2Fzc2VydCgwKTsKKwkJcmV0dXJuOworCX0KKworCXRhaWwgPSBwbG9nLT50YWlsOworCisJcGxfcmVjcCA9ICYocGxvZy0+cGxvZ19yZWNzW3RhaWxdKTsKKworCWJmYV9vc19tZW1jcHkocGxfcmVjcCwgcGxfcmVjLCBzaXplb2Yoc3RydWN0IGJmYV9wbG9nX3JlY19zKSk7CisKKwlwbF9yZWNwLT50diA9IEJGQV9UUkNfVFMocGxvZyk7CisJQkZBX1BMX0xPR19SRUNfSU5DUihwbG9nLT50YWlsKTsKKworCWlmIChwbG9nLT5oZWFkID09IHBsb2ctPnRhaWwpCisJCUJGQV9QTF9MT0dfUkVDX0lOQ1IocGxvZy0+aGVhZCk7Cit9CisKK3ZvaWQKK2JmYV9wbG9nX2luaXQoc3RydWN0IGJmYV9wbG9nX3MgKnBsb2cpCit7CisJYmZhX29zX21lbXNldCgoY2hhciAqKXBsb2csIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3Bsb2dfcykpOworCisJYmZhX29zX21lbWNweShwbG9nLT5wbG9nX3NpZywgQkZBX1BMX1NJR19TVFIsIEJGQV9QTF9TSUdfTEVOKTsKKwlwbG9nLT5oZWFkID0gcGxvZy0+dGFpbCA9IDA7CisJcGxvZy0+cGxvZ19lbmFibGVkID0gMTsKK30KKwordm9pZAorYmZhX3Bsb2dfc3RyKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nLCBlbnVtIGJmYV9wbG9nX21pZCBtaWQsCisJCWVudW0gYmZhX3Bsb2dfZWlkIGV2ZW50LAorCQl1MTYgbWlzYywgY2hhciAqbG9nX3N0cikKK3sKKwlzdHJ1Y3QgYmZhX3Bsb2dfcmVjX3MgIGxwOworCisJaWYgKHBsb2ctPnBsb2dfZW5hYmxlZCkgeworCQliZmFfb3NfbWVtc2V0KCZscCwgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfcGxvZ19yZWNfcykpOworCQlscC5taWQgPSBtaWQ7CisJCWxwLmVpZCA9IGV2ZW50OworCQlscC5sb2dfdHlwZSA9IEJGQV9QTF9MT0dfVFlQRV9TVFJJTkc7CisJCWxwLm1pc2MgPSBtaXNjOworCQlzdHJuY3B5KGxwLmxvZ19lbnRyeS5zdHJpbmdfbG9nLCBsb2dfc3RyLAorCQkJQkZBX1BMX1NUUklOR19MT0dfU1ogLSAxKTsKKwkJbHAubG9nX2VudHJ5LnN0cmluZ19sb2dbQkZBX1BMX1NUUklOR19MT0dfU1ogLSAxXSA9ICdcMCc7CisJCWJmYV9wbG9nX2FkZChwbG9nLCAmbHApOworCX0KK30KKwordm9pZAorYmZhX3Bsb2dfaW50YXJyKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nLCBlbnVtIGJmYV9wbG9nX21pZCBtaWQsCisJCWVudW0gYmZhX3Bsb2dfZWlkIGV2ZW50LAorCQl1MTYgbWlzYywgdTMyICppbnRhcnIsIHUzMiBudW1faW50cykKK3sKKwlzdHJ1Y3QgYmZhX3Bsb2dfcmVjX3MgIGxwOworCXUzMiAgICAgICAgaTsKKworCWlmIChudW1faW50cyA+IEJGQV9QTF9JTlRfTE9HX1NaKQorCQludW1faW50cyA9IEJGQV9QTF9JTlRfTE9HX1NaOworCisJaWYgKHBsb2ctPnBsb2dfZW5hYmxlZCkgeworCQliZmFfb3NfbWVtc2V0KCZscCwgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfcGxvZ19yZWNfcykpOworCQlscC5taWQgPSBtaWQ7CisJCWxwLmVpZCA9IGV2ZW50OworCQlscC5sb2dfdHlwZSA9IEJGQV9QTF9MT0dfVFlQRV9JTlQ7CisJCWxwLm1pc2MgPSBtaXNjOworCisJCWZvciAoaSA9IDA7IGkgPCBudW1faW50czsgaSsrKQorCQkJYmZhX29zX2Fzc2lnbihscC5sb2dfZW50cnkuaW50X2xvZ1tpXSwKKwkJCQkJaW50YXJyW2ldKTsKKworCQlscC5sb2dfbnVtX2ludHMgPSAodTgpIG51bV9pbnRzOworCisJCWJmYV9wbG9nX2FkZChwbG9nLCAmbHApOworCX0KK30KKwordm9pZAorYmZhX3Bsb2dfZmNoZHIoc3RydWN0IGJmYV9wbG9nX3MgKnBsb2csIGVudW0gYmZhX3Bsb2dfbWlkIG1pZCwKKwkJCWVudW0gYmZhX3Bsb2dfZWlkIGV2ZW50LAorCQkJdTE2IG1pc2MsIHN0cnVjdCBmY2hzX3MgKmZjaGRyKQoreworCXN0cnVjdCBiZmFfcGxvZ19yZWNfcyAgbHA7CisJdTMyICAgICAgICp0bXBfaW50ID0gKHUzMiAqKSBmY2hkcjsKKwl1MzIgICAgICAgIGludHNbQkZBX1BMX0lOVF9MT0dfU1pdOworCisJaWYgKHBsb2ctPnBsb2dfZW5hYmxlZCkgeworCQliZmFfb3NfbWVtc2V0KCZscCwgMCwgc2l6ZW9mKHN0cnVjdCBiZmFfcGxvZ19yZWNfcykpOworCisJCWludHNbMF0gPSB0bXBfaW50WzBdOworCQlpbnRzWzFdID0gdG1wX2ludFsxXTsKKwkJaW50c1syXSA9IHRtcF9pbnRbNF07CisKKwkJYmZhX3Bsb2dfaW50YXJyKHBsb2csIG1pZCwgZXZlbnQsIG1pc2MsIGludHMsIDMpOworCX0KK30KKwordm9pZAorYmZhX3Bsb2dfZmNoZHJfYW5kX3BsKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nLCBlbnVtIGJmYV9wbG9nX21pZCBtaWQsCisJCSAgICAgIGVudW0gYmZhX3Bsb2dfZWlkIGV2ZW50LCB1MTYgbWlzYywgc3RydWN0IGZjaHNfcyAqZmNoZHIsCisJCSAgICAgIHUzMiBwbGRfdzApCit7CisJc3RydWN0IGJmYV9wbG9nX3JlY19zICBscDsKKwl1MzIgICAgICAgKnRtcF9pbnQgPSAodTMyICopIGZjaGRyOworCXUzMiAgICAgICAgaW50c1tCRkFfUExfSU5UX0xPR19TWl07CisKKwlpZiAocGxvZy0+cGxvZ19lbmFibGVkKSB7CisJCWJmYV9vc19tZW1zZXQoJmxwLCAwLCBzaXplb2Yoc3RydWN0IGJmYV9wbG9nX3JlY19zKSk7CisKKwkJaW50c1swXSA9IHRtcF9pbnRbMF07CisJCWludHNbMV0gPSB0bXBfaW50WzFdOworCQlpbnRzWzJdID0gdG1wX2ludFs0XTsKKwkJaW50c1szXSA9IHBsZF93MDsKKworCQliZmFfcGxvZ19pbnRhcnIocGxvZywgbWlkLCBldmVudCwgbWlzYywgaW50cywgNCk7CisJfQorfQorCit2b2lkCitiZmFfcGxvZ19jbGVhcihzdHJ1Y3QgYmZhX3Bsb2dfcyAqcGxvZykKK3sKKwlwbG9nLT5oZWFkID0gcGxvZy0+dGFpbCA9IDA7Cit9CisKK3ZvaWQKK2JmYV9wbG9nX2VuYWJsZShzdHJ1Y3QgYmZhX3Bsb2dfcyAqcGxvZykKK3sKKwlwbG9nLT5wbG9nX2VuYWJsZWQgPSAxOworfQorCit2b2lkCitiZmFfcGxvZ19kaXNhYmxlKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nKQoreworCXBsb2ctPnBsb2dfZW5hYmxlZCA9IDA7Cit9CisKK2JmYV9ib29sZWFuX3QKK2JmYV9wbG9nX2dldF9zZXR0aW5nKHN0cnVjdCBiZmFfcGxvZ19zICpwbG9nKQoreworCXJldHVybigoYmZhX2Jvb2xlYW5fdClwbG9nLT5wbG9nX2VuYWJsZWQpOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9ycG9ydC5jIGIvZHJpdmVycy9zY3NpL2JmYS9ycG9ydC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjljZjU4YmIKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL3Jwb3J0LmMKQEAgLTAsMCArMSwyNjE4IEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIHJwb3J0LmMgUmVtb3RlIHBvcnQgaW1wbGVtZW50YXRpb24uCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlICJmY2J1aWxkLmgiCisjaW5jbHVkZSAiZmNzX3Zwb3J0LmgiCisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX2ZjcGltLmgiCisjaW5jbHVkZSAiZmNzX2ZjcHRtLmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImZjc19mY3hwLmgiCisjaW5jbHVkZSAiZmNzLmgiCisjaW5jbHVkZSA8ZmNiL2JmYV9mY2JfcnBvcnQuaD4KKyNpbmNsdWRlIDxhZW4vYmZhX2Flbl9ycG9ydC5oPgorCitCRkFfVFJDX0ZJTEUoRkNTLCBSUE9SVCk7CisKKyNkZWZpbmUgQkZBX0ZDU19SUE9SVF9NQVhfUkVUUklFUwkJKDUpCisKKy8qIEluIG1pbGxpc2VjcyAqLworc3RhdGljIHUzMiBiZmFfZmNzX3Jwb3J0X2RlbF90aW1lb3V0ID0KKwkJCUJGQV9GQ1NfUlBPUlRfREVGX0RFTF9USU1FT1VUICogMTAwMDsKKworLyoKKyAqIGZvcndhcmQgZGVjbGFyYXRpb25zCisgKi8KK3N0YXRpYyBzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpiZmFfZmNzX3Jwb3J0X2FsbG9jKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCQkJCSAgIHd3bl90IHB3d24sIHUzMiBycGlkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X2ZyZWUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfaGFsX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9vbmxpbmVfYWN0aW9uKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3VwZGF0ZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkgICAgIHN0cnVjdCBmY19sb2dpX3MgKnBsb2dpKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X2ZjNF9wYXVzZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9mYzRfcmVzdW1lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3RpbWVvdXQodm9pZCAqYXJnKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NlbmRfcGxvZ2kodm9pZCAqcnBvcnRfY2JhcmcsCisJCQkJCSBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NlbmRfcGxvZ2lhY2Modm9pZCAqcnBvcnRfY2JhcmcsCisJCQkJCSAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3Bsb2dpX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCQkJICAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJICAgICB2b2lkICpjYmFyZywKKwkJCQkJICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkJICAgICB1MzIgcnNwX2xlbiwKKwkJCQkJICAgICB1MzIgcmVzaWRfbGVuLAorCQkJCQkgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NlbmRfYWRpc2Modm9pZCAqcnBvcnRfY2JhcmcsCisJCQkJCSBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X2FkaXNjX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCQkJICAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJICAgICB2b2lkICpjYmFyZywKKwkJCQkJICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkJICAgICB1MzIgcnNwX2xlbiwKKwkJCQkJICAgICB1MzIgcmVzaWRfbGVuLAorCQkJCQkgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4odm9pZCAqcnBvcnRfY2JhcmcsCisJCQkJCSBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X2dpZHBuX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCQkJICAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJICAgICB2b2lkICpjYmFyZywKKwkJCQkJICAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywKKwkJCQkJICAgICB1MzIgcnNwX2xlbiwKKwkJCQkJICAgICB1MzIgcmVzaWRfbGVuLAorCQkJCQkgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NlbmRfbG9nbyh2b2lkICpycG9ydF9jYmFyZywKKwkJCQkJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zZW5kX2xvZ29fYWNjKHZvaWQgKnJwb3J0X2NiYXJnKTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3Byb2Nlc3NfcHJsaShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCXN0cnVjdCBmY2hzX3MgKnJ4X2ZjaHMsIHUxNiBsZW4pOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc2VuZF9sc19yanQoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQlzdHJ1Y3QgZmNoc19zICpyeF9mY2hzLCB1OCByZWFzb25fY29kZSwKKwkJCXU4IHJlYXNvbl9jb2RlX2V4cGwpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfcHJvY2Vzc19hZGlzYyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCXN0cnVjdCBmY2hzX3MgKnJ4X2ZjaHMsIHUxNiBsZW4pOworLyoqCisgKiAgZmNzX3Jwb3J0X3NtIEZDUyBycG9ydCBzdGF0ZSBtYWNoaW5lIGV2ZW50cworICovCisKK2VudW0gcnBvcnRfZXZlbnQgeworCVJQU01fRVZFTlRfUExPR0lfU0VORCA9IDEsCS8qICBuZXcgcnBvcnQ7IHN0YXJ0IHdpdGggUExPR0kgKi8KKwlSUFNNX0VWRU5UX1BMT0dJX1JDVkQgPSAyLAkvKiAgSW5ib3VuZCBQTE9HSSBmcm9tIHJlbW90ZSBwb3J0ICovCisJUlBTTV9FVkVOVF9QTE9HSV9DT01QID0gMywJLyogIFBMT0dJIGNvbXBsZXRlZCB0byBycG9ydCAqLworCVJQU01fRVZFTlRfTE9HT19SQ1ZEID0gNCwJLyogIExPR08gZnJvbSByZW1vdGUgZGV2aWNlICovCisJUlBTTV9FVkVOVF9MT0dPX0lNUCA9IDUsCS8qICBpbXBsaWNpdCBsb2dvIGZvciBTTEVSICovCisJUlBTTV9FVkVOVF9GQ1hQX1NFTlQgPSA2LAkvKiAgRnJhbWUgZnJvbSBoYXMgYmVlbiBzZW50ICovCisJUlBTTV9FVkVOVF9ERUxFVEUgPSA3LAkvKiAgUlBPUlQgZGVsZXRlIHJlcXVlc3QgKi8KKwlSUFNNX0VWRU5UX1NDTiA9IDgsCS8qICBzdGF0ZSBjaGFuZ2Ugbm90aWZpY2F0aW9uICovCisJUlBTTV9FVkVOVF9BQ0NFUFRFRCA9IDksLyogIEdvb2QgcmVzcG9uc2UgZnJvbSByZW1vdGUgZGV2aWNlICovCisJUlBTTV9FVkVOVF9GQUlMRUQgPSAxMCwJLyogIFJlcXVlc3QgdG8gcnBvcnQgZmFpbGVkLiAgKi8KKwlSUFNNX0VWRU5UX1RJTUVPVVQgPSAxMSwJLyogIFJwb3J0IFNNIHRpbWVvdXQgZXZlbnQgKi8KKwlSUFNNX0VWRU5UX0hDQl9PTkxJTkUgPSAxMiwJLyogIEJGQSBycG9ydCBvbmxpbmUgY2FsbGJhY2sgKi8KKwlSUFNNX0VWRU5UX0hDQl9PRkZMSU5FID0gMTMsCS8qICBCRkEgcnBvcnQgb2ZmbGluZSBjYWxsYmFjayAqLworCVJQU01fRVZFTlRfRkM0X09GRkxJTkUgPSAxNCwJLyogIEZDLTQgb2ZmbGluZSBjb21wbGV0ZSAqLworCVJQU01fRVZFTlRfQUREUkVTU19DSEFOR0UgPSAxNSwJLyogIFJwb3J0J3MgUElEIGhhcyBjaGFuZ2VkICovCisJUlBTTV9FVkVOVF9BRERSRVNTX0RJU0MgPSAxNgkvKiAgTmVlZCB0byBEaXNjb3ZlciBycG9ydCdzIFBJRCAqLworfTsKKworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fdW5pbml0KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQllbnVtIHJwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpX3NlbmRpbmcoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCSAgICAgICBlbnVtIHJwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpYWNjX3NlbmRpbmcoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCQkgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fcGxvZ2lfcmV0cnkoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCSAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zbV9wbG9naShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkgICAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zbV9oYWxfb25saW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQkgICAgZW51bSBycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zbV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCWVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fbnNxdWVyeV9zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQkJIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fbnNxdWVyeShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkJIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fYWRpc2Nfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkJICAgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fYWRpc2Moc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJICAgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fZmM0X2xvZ29yY3Yoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCSAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zbV9mYzRfbG9nb3NlbmQoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCSAgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fZmM0X29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCSAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zbV9oY2Jfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkJICAgICBlbnVtIHJwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NtX2hjYl9sb2dvcmN2KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQkgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21faGNiX2xvZ29zZW5kKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQkgICAgICBlbnVtIHJwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NtX2xvZ29fc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkJICAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zbV9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQkgZW51bSBycG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkJCWVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fbnNkaXNjX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQkgICAgICBlbnVtIHJwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Jwb3J0X3NtX25zZGlzY19zZW50KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCQkgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBvcnRfc21fbnNkaXNjX3NlbnQoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkJCSAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCk7CisKK3N0YXRpYyBzdHJ1Y3QgYmZhX3NtX3RhYmxlX3MgcnBvcnRfc21fdGFibGVbXSA9IHsKKwl7QkZBX1NNKGJmYV9mY3NfcnBvcnRfc21fdW5pbml0KSwgQkZBX1JQT1JUX1VOSU5JVH0sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpX3NlbmRpbmcpLCBCRkFfUlBPUlRfUExPR0l9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9wbG9naWFjY19zZW5kaW5nKSwgQkZBX1JQT1JUX09OTElORX0sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpX3JldHJ5KSwgQkZBX1JQT1JUX1BMT0dJX1JFVFJZfSwKKwl7QkZBX1NNKGJmYV9mY3NfcnBvcnRfc21fcGxvZ2kpLCBCRkFfUlBPUlRfUExPR0l9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9oYWxfb25saW5lKSwgQkZBX1JQT1JUX09OTElORX0sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX29ubGluZSksIEJGQV9SUE9SVF9PTkxJTkV9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9uc3F1ZXJ5X3NlbmRpbmcpLCBCRkFfUlBPUlRfTlNRVUVSWX0sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX25zcXVlcnkpLCBCRkFfUlBPUlRfTlNRVUVSWX0sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX2FkaXNjX3NlbmRpbmcpLCBCRkFfUlBPUlRfQURJU0N9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9hZGlzYyksIEJGQV9SUE9SVF9BRElTQ30sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9sb2dvcmN2KSwgQkZBX1JQT1JUX0xPR09SQ1Z9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9mYzRfbG9nb3NlbmQpLCBCRkFfUlBPUlRfTE9HT30sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9vZmZsaW5lKSwgQkZBX1JQT1JUX09GRkxJTkV9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9oY2Jfb2ZmbGluZSksIEJGQV9SUE9SVF9PRkZMSU5FfSwKKwl7QkZBX1NNKGJmYV9mY3NfcnBvcnRfc21faGNiX2xvZ29yY3YpLCBCRkFfUlBPUlRfTE9HT1JDVn0sCisJe0JGQV9TTShiZmFfZmNzX3Jwb3J0X3NtX2hjYl9sb2dvc2VuZCksIEJGQV9SUE9SVF9MT0dPfSwKKwl7QkZBX1NNKGJmYV9mY3NfcnBvcnRfc21fbG9nb19zZW5kaW5nKSwgQkZBX1JQT1JUX0xPR099LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9vZmZsaW5lKSwgQkZBX1JQT1JUX09GRkxJTkV9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyksIEJGQV9SUE9SVF9OU0RJU0N9LAorCXtCRkFfU00oYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2NfcmV0cnkpLCBCRkFfUlBPUlRfTlNESVNDfSwKKwl7QkZBX1NNKGJmYV9mY3NfcnBvcnRfc21fbnNkaXNjX3NlbnQpLCBCRkFfUlBPUlRfTlNESVNDfSwKK307CisKKy8qKgorICogCQlCZWdpbm5pbmcgc3RhdGUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX3VuaW5pdChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9TRU5EOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpX3NlbmRpbmcpOworCQlycG9ydC0+cGxvZ2lfcmV0cmllcyA9IDA7CisJCWJmYV9mY3NfcnBvcnRfc2VuZF9wbG9naShycG9ydCwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX1JDVkQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fcGxvZ2lhY2Nfc2VuZGluZyk7CisJCWJmYV9mY3NfcnBvcnRfc2VuZF9wbG9naWFjYyhycG9ydCwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX0NPTVA6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21faGFsX29ubGluZSk7CisJCWJmYV9mY3NfcnBvcnRfaGFsX29ubGluZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0RJU0M6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fbnNkaXNjX3NlbmRpbmcpOworCQlycG9ydC0+bnNfcmV0cmllcyA9IDA7CisJCWJmYV9mY3NfcnBvcnRfc2VuZF9naWRwbihycG9ydCwgTlVMTCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlQTE9HSSBpcyBiZWluZyBzZW50LgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zbV9wbG9naV9zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJICAgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFJQU01fRVZFTlRfRkNYUF9TRU5UOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPmZjeHBfd3FlKTsKKwkJYmZhX2Zjc19ycG9ydF9mcmVlKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfUkNWRDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9wbG9naWFjY19zZW5kaW5nKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfcGxvZ2lhY2MocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRToKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX25zZGlzY19zZW5kaW5nKTsKKwkJcnBvcnQtPm5zX3JldHJpZXMgPSAwOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9MT0dPX0lNUDoKKwkJcnBvcnQtPnBpZCA9IDA7CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPmZjeHBfd3FlKTsKKwkJYmZhX3RpbWVyX3N0YXJ0KHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT50aW1lciwKKwkJCQliZmFfZmNzX3Jwb3J0X3RpbWVvdXQsIHJwb3J0LAorCQkJCWJmYV9mY3NfcnBvcnRfZGVsX3RpbWVvdXQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9TQ046CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlQTE9HSSBpcyBiZWluZyBzZW50LgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zbV9wbG9naWFjY19zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJCSAgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9GQ1hQX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21faGFsX29ubGluZSk7CisJCWJmYV9mY3NfcnBvcnRfaGFsX29ubGluZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV91bmluaXQpOworCQliZmFfZmN4cF93YWxsb2NfY2FuY2VsKHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT5mY3hwX3dxZSk7CisJCWJmYV9mY3NfcnBvcnRfZnJlZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1NDTjoKKwkJLyoqCisJCSAqIElnbm9yZSwgU0NOIGlzIHBvc3NpYmx5IG9ubGluZSBub3RpZmljYXRpb24uCisJCSAqLworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRToKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX25zZGlzY19zZW5kaW5nKTsKKwkJcnBvcnQtPm5zX3JldHJpZXMgPSAwOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9MT0dPX0lNUDoKKwkJcnBvcnQtPnBpZCA9IDA7CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPmZjeHBfd3FlKTsKKwkJYmZhX3RpbWVyX3N0YXJ0KHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT50aW1lciwKKwkJCQliZmFfZmNzX3Jwb3J0X3RpbWVvdXQsIHJwb3J0LAorCQkJCWJmYV9mY3NfcnBvcnRfZGVsX3RpbWVvdXQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9IQ0JfT0ZGTElORToKKwkJLyoqCisJCSAqIElnbm9yZSBCRkEgY2FsbGJhY2ssIG9uIGEgUExPR0kgcmVjZWl2ZSB3ZSBjYWxsIGJmYSBvZmZsaW5lLgorCQkgKi8KKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCVBMT0dJIGlzIHNlbnQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9TQ046CisJCWJmYV90aW1lcl9zdG9wKCZycG9ydC0+dGltZXIpOworCQkvKgorCQkgKiAhISBmYWxsIHRocm91Z2ggISEKKwkJICovCisKKwljYXNlIFJQU01fRVZFTlRfVElNRU9VVDoKKwkJcnBvcnQtPnBsb2dpX3JldHJpZXMrKzsKKwkJaWYgKHJwb3J0LT5wbG9naV9yZXRyaWVzIDwgQkZBX0ZDU19SUE9SVF9NQVhfUkVUUklFUykgeworCQkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9wbG9naV9zZW5kaW5nKTsKKwkJCWJmYV9mY3NfcnBvcnRfc2VuZF9wbG9naShycG9ydCwgTlVMTCk7CisJCX0gZWxzZSB7CisJCQlycG9ydC0+cGlkID0gMDsKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fb2ZmbGluZSk7CisJCQliZmFfdGltZXJfc3RhcnQocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPnRpbWVyLAorCQkJCQliZmFfZmNzX3Jwb3J0X3RpbWVvdXQsIHJwb3J0LAorCQkJCQliZmFfZmNzX3Jwb3J0X2RlbF90aW1lb3V0KTsKKwkJfQorCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fdW5pbml0KTsKKwkJYmZhX3RpbWVyX3N0b3AoJnJwb3J0LT50aW1lcik7CisJCWJmYV9mY3NfcnBvcnRfZnJlZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fUkNWRDoKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfUkNWRDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9wbG9naWFjY19zZW5kaW5nKTsKKwkJYmZhX3RpbWVyX3N0b3AoJnJwb3J0LT50aW1lcik7CisJCWJmYV9mY3NfcnBvcnRfc2VuZF9wbG9naWFjYyhycG9ydCwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCQliZmFfdGltZXJfc3RvcCgmcnBvcnQtPnRpbWVyKTsKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyk7CisJCXJwb3J0LT5uc19yZXRyaWVzID0gMDsKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX2dpZHBuKHJwb3J0LCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19JTVA6CisJCXJwb3J0LT5waWQgPSAwOworCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX29mZmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmcnBvcnQtPnRpbWVyKTsKKwkJYmZhX3RpbWVyX3N0YXJ0KHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT50aW1lciwKKwkJCQliZmFfZmNzX3Jwb3J0X3RpbWVvdXQsIHJwb3J0LAorCQkJCWJmYV9mY3NfcnBvcnRfZGVsX3RpbWVvdXQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hhbF9vbmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmcnBvcnQtPnRpbWVyKTsKKwkJYmZhX2Zjc19ycG9ydF9oYWxfb25saW5lKHJwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCVBMT0dJIGlzIHNlbnQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LCBlbnVtIHJwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBSUFNNX0VWRU5UX0FDQ0VQVEVEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hhbF9vbmxpbmUpOworCQlycG9ydC0+cGxvZ2lfcmV0cmllcyA9IDA7CisJCWJmYV9mY3NfcnBvcnRfaGFsX29ubGluZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fUkNWRDoKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX2xvZ29fYWNjKHJwb3J0KTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCS8qCisJCSAqICEhIGZhbGwgdGhyb3VnaCAhIQorCQkgKi8KKwljYXNlIFJQU01fRVZFTlRfRkFJTEVEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpX3JldHJ5KTsKKwkJYmZhX3RpbWVyX3N0YXJ0KHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT50aW1lciwKKwkJCQliZmFfZmNzX3Jwb3J0X3RpbWVvdXQsIHJwb3J0LAorCQkJCUJGQV9GQ1NfUkVUUllfVElNRU9VVCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fSU1QOgorCQlycG9ydC0+cGlkID0gMDsKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCWJmYV90aW1lcl9zdGFydChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+dGltZXIsCisJCQkJYmZhX2Zjc19ycG9ydF90aW1lb3V0LCBycG9ydCwKKwkJCQliZmFfZmNzX3Jwb3J0X2RlbF90aW1lb3V0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfQUREUkVTU19DSEFOR0U6CisJCWJmYV9mY3hwX2Rpc2NhcmQocnBvcnQtPmZjeHApOworCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX25zZGlzY19zZW5kaW5nKTsKKwkJcnBvcnQtPm5zX3JldHJpZXMgPSAwOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9SQ1ZEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpYWNjX3NlbmRpbmcpOworCQliZmFfZmN4cF9kaXNjYXJkKHJwb3J0LT5mY3hwKTsKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX3Bsb2dpYWNjKHJwb3J0LCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfU0NOOgorCQkvKioKKwkJICogSWdub3JlIFNDTiAtIHdhaXQgZm9yIFBMT0dJIHJlc3BvbnNlLgorCQkgKi8KKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9mY3hwX2Rpc2NhcmQocnBvcnQtPmZjeHApOworCQliZmFfZmNzX3Jwb3J0X2ZyZWUocnBvcnQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hhbF9vbmxpbmUpOworCQliZmFfZmN4cF9kaXNjYXJkKHJwb3J0LT5mY3hwKTsKKwkJYmZhX2Zjc19ycG9ydF9oYWxfb25saW5lKHJwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCVBMT0dJIGlzIGNvbXBsZXRlLiBBd2FpdGluZyBCRkEgcnBvcnQgb25saW5lIGNhbGxiYWNrLiBGQy00cworICogCQlhcmUgb2ZmbGluZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc21faGFsX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCWVudW0gcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFJQU01fRVZFTlRfSENCX09OTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9vbmxpbmUpOworCQliZmFfZmNzX3Jwb3J0X29ubGluZV9hY3Rpb24ocnBvcnQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9MT0dPX1JDVkQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21faGNiX2xvZ29yY3YpOworCQliZmFfcnBvcnRfb2ZmbGluZShycG9ydC0+YmZhX3Jwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19JTVA6CisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hjYl9vZmZsaW5lKTsKKwkJYmZhX3Jwb3J0X29mZmxpbmUocnBvcnQtPmJmYV9ycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX1JDVkQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fcGxvZ2lhY2Nfc2VuZGluZyk7CisJCWJmYV9ycG9ydF9vZmZsaW5lKHJwb3J0LT5iZmFfcnBvcnQpOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfcGxvZ2lhY2MocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21faGNiX2xvZ29zZW5kKTsKKwkJYmZhX3Jwb3J0X29mZmxpbmUocnBvcnQtPmJmYV9ycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1NDTjoKKwkJLyoqCisJCSAqIEB0b2RvCisJCSAqIElnbm9yZSBTQ04gLSBQTE9HSSBqdXN0IGNvbXBsZXRlZCwgRkMtNCBsb2dpbiBzaG91bGQgZGV0ZWN0CisJCSAqIGRldmljZSBmYWlsdXJlcy4KKwkJICovCisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlScG9ydCBpcyBPTkxJTkUuIEZDLTRzIGFjdGl2ZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc21fb25saW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LCBlbnVtIHJwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBSUFNNX0VWRU5UX1NDTjoKKwkJLyoqCisJCSAqIFBhdXNlIEZDLTQgYWN0aXZpdHkgdGlsbCBycG9ydCBpcyBhdXRoZW50aWNhdGVkLgorCQkgKiBJbiBzd2l0Y2hlZCBmYWJyaWNzLCBjaGVjayBwcmVzZW5jZSBvZiBkZXZpY2UgaW4gbmFtZXNlcnZlcgorCQkgKiBmaXJzdC4KKwkJICovCisJCWJmYV9mY3NfcnBvcnRfZmM0X3BhdXNlKHJwb3J0KTsKKworCQlpZiAoYmZhX2Zjc19mYWJyaWNfaXNfc3dpdGNoZWQocnBvcnQtPnBvcnQtPmZhYnJpYykpIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsCisJCQkJCSBiZmFfZmNzX3Jwb3J0X3NtX25zcXVlcnlfc2VuZGluZyk7CisJCQlycG9ydC0+bnNfcmV0cmllcyA9IDA7CisJCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQl9IGVsc2UgeworCQkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9hZGlzY19zZW5kaW5nKTsKKwkJCWJmYV9mY3NfcnBvcnRfc2VuZF9hZGlzYyhycG9ydCwgTlVMTCk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfUkNWRDoKKwljYXNlIFJQU01fRVZFTlRfTE9HT19JTVA6CisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9vZmZsaW5lKTsKKwkJYmZhX2Zjc19ycG9ydF9vZmZsaW5lX2FjdGlvbihycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9mYzRfbG9nb3NlbmQpOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9sb2dvcmN2KTsKKwkJYmZhX2Zjc19ycG9ydF9vZmZsaW5lX2FjdGlvbihycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX0NPTVA6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCQlBbiBTQ04gZXZlbnQgaXMgcmVjZWl2ZWQgaW4gT05MSU5FIHN0YXRlLiBOUyBxdWVyeSBpcyBiZWluZyBzZW50CisgKiAJCXByaW9yIHRvIEFESVNDIGF1dGhlbnRpY2F0aW9uIHdpdGggcnBvcnQuIEZDLTRzIGFyZSBwYXVzZWQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX25zcXVlcnlfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQkgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9GQ1hQX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fbnNxdWVyeSk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9mYzRfbG9nb3NlbmQpOworCQliZmFfZmN4cF93YWxsb2NfY2FuY2VsKHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT5mY3hwX3dxZSk7CisJCWJmYV9mY3NfcnBvcnRfb2ZmbGluZV9hY3Rpb24ocnBvcnQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9TQ046CisJCS8qKgorCQkgKiBpZ25vcmUgU0NOLCB3YWl0IGZvciByZXNwb25zZSB0byBxdWVyeSBpdHNlbGYKKwkJICovCisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fUkNWRDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9mYzRfbG9nb3Jjdik7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPmZjeHBfd3FlKTsKKwkJYmZhX2Zjc19ycG9ydF9vZmZsaW5lX2FjdGlvbihycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fSU1QOgorCQlycG9ydC0+cGlkID0gMDsKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfdGltZXJfc3RhcnQocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPnRpbWVyLAorCQkJCWJmYV9mY3NfcnBvcnRfdGltZW91dCwgcnBvcnQsCisJCQkJYmZhX2Zjc19ycG9ydF9kZWxfdGltZW91dCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX1JDVkQ6CisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJQW4gU0NOIGV2ZW50IGlzIHJlY2VpdmVkIGluIE9OTElORSBzdGF0ZS4gTlMgcXVlcnkgaXMgc2VudCB0byBycG9ydC4KKyAqIAlGQy00cyBhcmUgcGF1c2VkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zbV9uc3F1ZXJ5KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LCBlbnVtIHJwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBSUFNNX0VWRU5UX0FDQ0VQVEVEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2FkaXNjX3NlbmRpbmcpOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfYWRpc2MocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9GQUlMRUQ6CisJCXJwb3J0LT5uc19yZXRyaWVzKys7CisJCWlmIChycG9ydC0+bnNfcmV0cmllcyA8IEJGQV9GQ1NfUlBPUlRfTUFYX1JFVFJJRVMpIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsCisJCQkJCSBiZmFfZmNzX3Jwb3J0X3NtX25zcXVlcnlfc2VuZGluZyk7CisJCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQl9IGVsc2UgeworCQkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9mYzRfb2ZmbGluZSk7CisJCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJfQorCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fZmM0X2xvZ29zZW5kKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCWJmYV9mY3NfcnBvcnRfb2ZmbGluZV9hY3Rpb24ocnBvcnQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9TQ046CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fUkNWRDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9mYzRfbG9nb3Jjdik7CisJCWJmYV9mY3hwX2Rpc2NhcmQocnBvcnQtPmZjeHApOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfQ09NUDoKKwljYXNlIFJQU01fRVZFTlRfQUREUkVTU19DSEFOR0U6CisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX1JDVkQ6CisJY2FzZSBSUFNNX0VWRU5UX0xPR09fSU1QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCWJmYV9mY3NfcnBvcnRfb2ZmbGluZV9hY3Rpb24ocnBvcnQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAlBbiBTQ04gZXZlbnQgaXMgcmVjZWl2ZWQgaW4gT05MSU5FIHN0YXRlLiBBRElTQyBpcyBiZWluZyBzZW50IGZvcgorICogCWF1dGhlbnRpY2F0aW5nIHdpdGggcnBvcnQuIEZDLTRzIGFyZSBwYXVzZWQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX2FkaXNjX3NlbmRpbmcoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQkgICAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9GQ1hQX1NFTlQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fYWRpc2MpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fZmM0X2xvZ29zZW5kKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19JTVA6CisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9sb2dvcmN2KTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfU0NOOgorCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9SQ1ZEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCUFuIFNDTiBldmVudCBpcyByZWNlaXZlZCBpbiBPTkxJTkUgc3RhdGUuIEFESVNDIGlzIHRvIHJwb3J0LgorICogCQlGQy00cyBhcmUgcGF1c2VkLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zbV9hZGlzYyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9BQ0NFUFRFRDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9vbmxpbmUpOworCQliZmFfZmNzX3Jwb3J0X2ZjNF9yZXN1bWUocnBvcnQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9SQ1ZEOgorCQkvKioKKwkJICogVG9vIGNvbXBsZXggdG8gY2xlYW51cCBGQy00ICYgcnBvcnQgYW5kIHRoZW4gYWNjIHRvIFBMT0dJLgorCQkgKiBBdCBsZWFzdCBnbyBvZmZsaW5lIHdoZW4gYSBQTE9HSSBpcyByZWNlaXZlZC4KKwkJICovCisJCWJmYV9mY3hwX2Rpc2NhcmQocnBvcnQtPmZjeHApOworCQkvKgorCQkgKiAhISEgZmFsbCB0aHJvdWdoICEhIQorCQkgKi8KKworCWNhc2UgUlBTTV9FVkVOVF9GQUlMRUQ6CisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9vZmZsaW5lKTsKKwkJYmZhX2Zjc19ycG9ydF9vZmZsaW5lX2FjdGlvbihycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9mYzRfbG9nb3NlbmQpOworCQliZmFfZmN4cF9kaXNjYXJkKHJwb3J0LT5mY3hwKTsKKwkJYmZhX2Zjc19ycG9ydF9vZmZsaW5lX2FjdGlvbihycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1NDTjoKKwkJLyoqCisJCSAqIGFscmVhZHkgcHJvY2Vzc2luZyBSU0NOCisJCSAqLworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9MT0dPX0lNUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9mYzRfb2ZmbGluZSk7CisJCWJmYV9mY3hwX2Rpc2NhcmQocnBvcnQtPmZjeHApOworCQliZmFfZmNzX3Jwb3J0X29mZmxpbmVfYWN0aW9uKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9sb2dvcmN2KTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCWJmYV9mY3NfcnBvcnRfb2ZmbGluZV9hY3Rpb24ocnBvcnQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJUnBvcnQgaGFzIHNlbnQgTE9HTy4gQXdhaXRpbmcgRkMtNCBvZmZsaW5lIGNvbXBsZXRpb24gY2FsbGJhY2suCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9sb2dvcmN2KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9GQzRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9oY2JfbG9nb3Jjdik7CisJCWJmYV9ycG9ydF9vZmZsaW5lKHJwb3J0LT5iZmFfcnBvcnQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fZmM0X2xvZ29zZW5kKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRToKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCUxPR08gbmVlZHMgdG8gYmUgc2VudCB0byBycG9ydC4gQXdhaXRpbmcgRkMtNCBvZmZsaW5lIGNvbXBsZXRpb24KKyAqIAkJY2FsbGJhY2suCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX2ZjNF9sb2dvc2VuZChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCSAgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFJQU01fRVZFTlRfRkM0X09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21faGNiX2xvZ29zZW5kKTsKKwkJYmZhX3Jwb3J0X29mZmxpbmUocnBvcnQtPmJmYV9ycG9ydCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogCVJwb3J0IGlzIGdvaW5nIG9mZmxpbmUuIEF3YWl0aW5nIEZDLTQgb2ZmbGluZSBjb21wbGV0aW9uIGNhbGxiYWNrLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zbV9mYzRfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCWVudW0gcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFJQU01fRVZFTlRfRkM0X09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21faGNiX29mZmxpbmUpOworCQliZmFfcnBvcnRfb2ZmbGluZShycG9ydC0+YmZhX3Jwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfU0NOOgorCWNhc2UgUlBTTV9FVkVOVF9MT0dPX0lNUDoKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRToKKwkJLyoqCisJCSAqIHJwb3J0IGlzIGFscmVhZHkgZ29pbmcgb2ZmbGluZS4KKwkJICogU0NOIC0gaWdub3JlIGFuZCB3YWl0IHRpbGwgdHJhbnNpdGlvbmluZyB0byBvZmZsaW5lIHN0YXRlCisJCSAqLworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fZmM0X2xvZ29zZW5kKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCVJwb3J0IGlzIG9mZmxpbmUuIEZDLTRzIGFyZSBvZmZsaW5lLiBBd2FpdGluZyBCRkEgcnBvcnQgb2ZmbGluZQorICogCQljYWxsYmFjay4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc21faGNiX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQllbnVtIHJwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBSUFNNX0VWRU5UX0hDQl9PRkZMSU5FOgorCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRToKKwkJaWYgKGJmYV9mY3NfcG9ydF9pc19vbmxpbmUocnBvcnQtPnBvcnQpKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LAorCQkJCQkgYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyk7CisJCQlycG9ydC0+bnNfcmV0cmllcyA9IDA7CisJCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQl9IGVsc2UgeworCQkJcnBvcnQtPnBpZCA9IDA7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX29mZmxpbmUpOworCQkJYmZhX3RpbWVyX3N0YXJ0KHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT50aW1lciwKKwkJCQkJYmZhX2Zjc19ycG9ydF90aW1lb3V0LCBycG9ydCwKKwkJCQkJYmZhX2Zjc19ycG9ydF9kZWxfdGltZW91dCk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9mY3NfcnBvcnRfZnJlZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1NDTjoKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQkvKioKKwkJICogSWdub3JlLCBhbHJlYWR5IG9mZmxpbmUuCisJCSAqLworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJUnBvcnQgaXMgb2ZmbGluZS4gRkMtNHMgYXJlIG9mZmxpbmUuIEF3YWl0aW5nIEJGQSBycG9ydCBvZmZsaW5lCisgKiAJCWNhbGxiYWNrIHRvIHNlbmQgTE9HTyBhY2NlcHQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX2hjYl9sb2dvcmN2KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9IQ0JfT0ZGTElORToKKwljYXNlIFJQU01fRVZFTlRfQUREUkVTU19DSEFOR0U6CisJCWlmIChycG9ydC0+cGlkKQorCQkJYmZhX2Zjc19ycG9ydF9zZW5kX2xvZ29fYWNjKHJwb3J0KTsKKwkJLyoKKwkJICogSWYgdGhlIGxwb3J0IGlzIG9ubGluZSBhbmQgaWYgdGhlIHJwb3J0IGlzIG5vdCBhIHdlbGwga25vd24KKwkJICogYWRkcmVzcyBwb3J0LCB3ZSB0cnkgdG8gcmUtZGlzY292ZXIgdGhlIHItcG9ydC4KKwkJICovCisJCWlmIChiZmFfZmNzX3BvcnRfaXNfb25saW5lKHJwb3J0LT5wb3J0KQorCQkgICAgJiYgKCFCRkFfRkNTX1BJRF9JU19XS0EocnBvcnQtPnBpZCkpKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LAorCQkJCQkgYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyk7CisJCQlycG9ydC0+bnNfcmV0cmllcyA9IDA7CisJCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIGlmIGl0IGlzIG5vdCBhIHdlbGwga25vd24gYWRkcmVzcywgcmVzZXQgdGhlIHBpZCB0bworCQkJICoKKwkJCSAqLworCQkJaWYgKCFCRkFfRkNTX1BJRF9JU19XS0EocnBvcnQtPnBpZCkpCisJCQkJcnBvcnQtPnBpZCA9IDA7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX29mZmxpbmUpOworCQkJYmZhX3RpbWVyX3N0YXJ0KHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT50aW1lciwKKwkJCQkJYmZhX2Zjc19ycG9ydF90aW1lb3V0LCBycG9ydCwKKwkJCQkJYmZhX2Zjc19ycG9ydF9kZWxfdGltZW91dCk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hjYl9sb2dvc2VuZCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fSU1QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hjYl9vZmZsaW5lKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQkvKioKKwkJICogSWdub3JlIC0gYWxyZWFkeSBwcm9jZXNzaW5nIGEgTE9HTy4KKwkJICovCisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogUnBvcnQgaXMgYmVpbmcgZGVsZXRlZC4gRkMtNHMgYXJlIG9mZmxpbmUuIEF3YWl0aW5nIEJGQSBycG9ydCBvZmZsaW5lCisgKiBjYWxsYmFjayB0byBzZW5kIExPR08uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX2hjYl9sb2dvc2VuZChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCSAgICAgIGVudW0gcnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFJQU01fRVZFTlRfSENCX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fbG9nb19zZW5kaW5nKTsKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX2xvZ28ocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9MT0dPX1JDVkQ6CisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIAkJUnBvcnQgaXMgYmVpbmcgZGVsZXRlZC4gRkMtNHMgYXJlIG9mZmxpbmUuIExPR08gaXMgYmVpbmcgc2VudC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc21fbG9nb19zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJICAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9GQ1hQX1NFTlQ6CisJCS8qCisJCSAqIE9uY2UgTE9HTyBpcyBzZW50LCB3ZSBkb25vdCB3YWl0IGZvciB0aGUgcmVzcG9uc2UKKwkJICovCisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fdW5pbml0KTsKKwkJYmZhX2Zjc19ycG9ydF9mcmVlKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfU0NOOgorCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRToKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPmZjeHBfd3FlKTsKKwkJYmZhX2Zjc19ycG9ydF9mcmVlKHJwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCVJwb3J0IGlzIG9mZmxpbmUuIEZDLTRzIGFyZSBvZmZsaW5lLiBCRkEgcnBvcnQgaXMgb2ZmbGluZS4KKyAqIAkJVGltZXIgYWN0aXZlIHRvIGRlbGV0ZSBzdGFsZSBycG9ydC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9USU1FT1VUOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3VuaW5pdCk7CisJCWJmYV9mY3NfcnBvcnRfZnJlZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1NDTjoKKwljYXNlIFJQU01fRVZFTlRfQUREUkVTU19DSEFOR0U6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fbnNkaXNjX3NlbmRpbmcpOworCQliZmFfdGltZXJfc3RvcCgmcnBvcnQtPnRpbWVyKTsKKwkJcnBvcnQtPm5zX3JldHJpZXMgPSAwOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fdW5pbml0KTsKKwkJYmZhX3RpbWVyX3N0b3AoJnJwb3J0LT50aW1lcik7CisJCWJmYV9mY3NfcnBvcnRfZnJlZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX1JDVkQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fcGxvZ2lhY2Nfc2VuZGluZyk7CisJCWJmYV90aW1lcl9zdG9wKCZycG9ydC0+dGltZXIpOworCQliZmFfZmNzX3Jwb3J0X3NlbmRfcGxvZ2lhY2MocnBvcnQsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9MT0dPX1JDVkQ6CisJY2FzZSBSUFNNX0VWRU5UX0xPR09fSU1QOgorCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hhbF9vbmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmcnBvcnQtPnRpbWVyKTsKKwkJYmZhX2Zjc19ycG9ydF9oYWxfb25saW5lKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfU0VORDoKKwkJYmZhX3RpbWVyX3N0b3AoJnJwb3J0LT50aW1lcik7CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fcGxvZ2lfc2VuZGluZyk7CisJCXJwb3J0LT5wbG9naV9yZXRyaWVzID0gMDsKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX3Bsb2dpKHJwb3J0LCBOVUxMKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJUnBvcnQgYWRkcmVzcyBoYXMgY2hhbmdlZC4gTmFtZXNlcnZlciBkaXNjb3ZlcnkgcmVxdWVzdCBpcyBiZWluZyBzZW50LgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCQllbnVtIHJwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBSUFNNX0VWRU5UX0ZDWFBfU0VOVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VudCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV91bmluaXQpOworCQliZmFfZmN4cF93YWxsb2NfY2FuY2VsKHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT5mY3hwX3dxZSk7CisJCWJmYV9mY3NfcnBvcnRfZnJlZShycG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX1JDVkQ6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fcGxvZ2lhY2Nfc2VuZGluZyk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPmZjeHBfd3FlKTsKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX3Bsb2dpYWNjKHJwb3J0LCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfU0NOOgorCWNhc2UgUlBTTV9FVkVOVF9MT0dPX1JDVkQ6CisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX1NFTkQ6CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFOgorCQlycG9ydC0+bnNfcmV0cmllcyA9IDA7CS8qIHJlc2V0IHRoZSByZXRyeSBjb3VudCAqLworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9MT0dPX0lNUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUpOworCQliZmFfdGltZXJfc3RhcnQocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPnRpbWVyLAorCQkJCWJmYV9mY3NfcnBvcnRfdGltZW91dCwgcnBvcnQsCisJCQkJYmZhX2Zjc19ycG9ydF9kZWxfdGltZW91dCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX1BMT0dJX0NPTVA6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21faGFsX29ubGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwocnBvcnQtPmZjcy0+YmZhLCAmcnBvcnQtPmZjeHBfd3FlKTsKKwkJYmZhX2Zjc19ycG9ydF9oYWxfb25saW5lKHJwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiAJCU5hbWVzZXJ2ZXIgZGlzY292ZXJ5IGZhaWxlZC4gV2FpdGluZyBmb3IgdGltZW91dCB0byByZXRyeS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc21fbnNkaXNjX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJICAgICAgZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9USU1FT1VUOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX25zZGlzY19zZW5kaW5nKTsKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX2dpZHBuKHJwb3J0LCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfU0NOOgorCWNhc2UgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyk7CisJCWJmYV90aW1lcl9zdG9wKCZycG9ydC0+dGltZXIpOworCQlycG9ydC0+bnNfcmV0cmllcyA9IDA7CisJCWJmYV9mY3NfcnBvcnRfc2VuZF9naWRwbihycG9ydCwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV91bmluaXQpOworCQliZmFfdGltZXJfc3RvcCgmcnBvcnQtPnRpbWVyKTsKKwkJYmZhX2Zjc19ycG9ydF9mcmVlKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfUkNWRDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9wbG9naWFjY19zZW5kaW5nKTsKKwkJYmZhX3RpbWVyX3N0b3AoJnJwb3J0LT50aW1lcik7CisJCWJmYV9mY3NfcnBvcnRfc2VuZF9wbG9naWFjYyhycG9ydCwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fSU1QOgorCQlycG9ydC0+cGlkID0gMDsKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJnJwb3J0LT50aW1lcik7CisJCWJmYV90aW1lcl9zdGFydChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+dGltZXIsCisJCQkJYmZhX2Zjc19ycG9ydF90aW1lb3V0LCBycG9ydCwKKwkJCQliZmFfZmNzX3Jwb3J0X2RlbF90aW1lb3V0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQliZmFfZmNzX3Jwb3J0X3NlbmRfbG9nb19hY2MocnBvcnQpOworCQlicmVhazsKKworCWNhc2UgUlBTTV9FVkVOVF9QTE9HSV9DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX2hhbF9vbmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmcnBvcnQtPnRpbWVyKTsKKwkJYmZhX2Zjc19ycG9ydF9oYWxfb25saW5lKHJwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBScG9ydCBhZGRyZXNzIGhhcyBjaGFuZ2VkLiBOYW1lc2VydmVyIGRpc2NvdmVyeSByZXF1ZXN0IGlzIHNlbnQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NtX25zZGlzY19zZW50KHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJZW51bSBycG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBTTV9FVkVOVF9BQ0NFUFRFRDoKKwljYXNlIFJQU01fRVZFTlRfQUREUkVTU19DSEFOR0U6CisJCWlmIChycG9ydC0+cGlkKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX3Bsb2dpX3NlbmRpbmcpOworCQkJYmZhX2Zjc19ycG9ydF9zZW5kX3Bsb2dpKHJwb3J0LCBOVUxMKTsKKwkJfSBlbHNlIHsKKwkJCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsCisJCQkJCSBiZmFfZmNzX3Jwb3J0X3NtX25zZGlzY19zZW5kaW5nKTsKKwkJCXJwb3J0LT5uc19yZXRyaWVzID0gMDsKKwkJCWJmYV9mY3NfcnBvcnRfc2VuZF9naWRwbihycG9ydCwgTlVMTCk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfRkFJTEVEOgorCQlycG9ydC0+bnNfcmV0cmllcysrOworCQlpZiAocnBvcnQtPm5zX3JldHJpZXMgPCBCRkFfRkNTX1JQT1JUX01BWF9SRVRSSUVTKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LAorCQkJCQkgYmZhX2Zjc19ycG9ydF9zbV9uc2Rpc2Nfc2VuZGluZyk7CisJCQliZmFfZmNzX3Jwb3J0X3NlbmRfZ2lkcG4ocnBvcnQsIE5VTEwpOworCQl9IGVsc2UgeworCQkJcnBvcnQtPnBpZCA9IDA7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwb3J0LCBiZmFfZmNzX3Jwb3J0X3NtX29mZmxpbmUpOworCQkJYmZhX3RpbWVyX3N0YXJ0KHJwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT50aW1lciwKKwkJCQkJYmZhX2Zjc19ycG9ydF90aW1lb3V0LCBycG9ydCwKKwkJCQkJYmZhX2Zjc19ycG9ydF9kZWxfdGltZW91dCk7CisJCX07CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV91bmluaXQpOworCQliZmFfZmN4cF9kaXNjYXJkKHJwb3J0LT5mY3hwKTsKKwkJYmZhX2Zjc19ycG9ydF9mcmVlKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfUkNWRDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9wbG9naWFjY19zZW5kaW5nKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCWJmYV9mY3NfcnBvcnRfc2VuZF9wbG9naWFjYyhycG9ydCwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBSUFNNX0VWRU5UX0xPR09fSU1QOgorCQlycG9ydC0+cGlkID0gMDsKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCWJmYV90aW1lcl9zdGFydChycG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+dGltZXIsCisJCQkJYmZhX2Zjc19ycG9ydF90aW1lb3V0LCBycG9ydCwKKwkJCQliZmFfZmNzX3Jwb3J0X2RlbF90aW1lb3V0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfU0NOOgorCQkvKioKKwkJICogaWdub3JlLCB3YWl0IGZvciBOUyBxdWVyeSByZXNwb25zZQorCQkgKi8KKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfTE9HT19SQ1ZEOgorCQkvKioKKwkJICogTm90IGxvZ2dlZC1pbiB5ZXQuIEFjY2VwdCBMT0dPLgorCQkgKi8KKwkJYmZhX2Zjc19ycG9ydF9zZW5kX2xvZ29fYWNjKHJwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIFJQU01fRVZFTlRfUExPR0lfQ09NUDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycG9ydCwgYmZhX2Zjc19ycG9ydF9zbV9oYWxfb25saW5lKTsKKwkJYmZhX2ZjeHBfZGlzY2FyZChycG9ydC0+ZmN4cCk7CisJCWJmYV9mY3NfcnBvcnRfaGFsX29ubGluZShycG9ydCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBmY3NfcnBvcnRfcHJpdmF0ZSBGQ1MgUlBPUlQgcHJvdmF0ZSBmdW5jdGlvbnMKKyAqLworCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zZW5kX3Bsb2dpKHZvaWQgKnJwb3J0X2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gcnBvcnRfY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gcnBvcnQtPnBvcnQ7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCWludCAgICAgICAgICAgICBsZW47CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19ycG9ydF9zZW5kX3Bsb2dpLCBycG9ydCk7CisJCXJldHVybjsKKwl9CisJcnBvcnQtPmZjeHAgPSBmY3hwOworCisJbGVuID0gZmNfcGxvZ2lfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksIHJwb3J0LT5waWQsCisJCQkgICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgMCwKKwkJCSAgICAgcG9ydC0+cG9ydF9jZmcucHd3biwgcG9ydC0+cG9ydF9jZmcubnd3biwKKwkJCSAgICAgYmZhX3Bwb3J0X2dldF9tYXhmcnNpemUocG9ydC0+ZmNzLT5iZmEpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIGJmYV9mY3NfcnBvcnRfcGxvZ2lfcmVzcG9uc2UsCisJCSAgICAgICh2b2lkICopcnBvcnQsIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKworCXJwb3J0LT5zdGF0cy5wbG9naXMrKzsKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9GQ1hQX1NFTlQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9wbG9naV9yZXNwb25zZSh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCB2b2lkICpjYmFyZywKKwkJCSAgICAgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsIHUzMiByc3BfbGVuLAorCQkJICAgICB1MzIgcmVzaWRfbGVuLCBzdHJ1Y3QgZmNoc19zICpyc3BfZmNocykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopY2Jhcmc7CisJc3RydWN0IGZjX2xvZ2lfcwkqcGxvZ2lfcnNwOworCXN0cnVjdCBmY19sc19yanRfcwkqbHNfcmp0OworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnR3aW47CisJc3RydWN0IGxpc3RfaGVhZCAqcWU7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKworCS8qCisJICogU2FuaXR5IENoZWNrcworCSAqLworCWlmIChyZXFfc3RhdHVzICE9IEJGQV9TVEFUVVNfT0spIHsKKwkJYmZhX3RyYyhycG9ydC0+ZmNzLCByZXFfc3RhdHVzKTsKKwkJcnBvcnQtPnN0YXRzLnBsb2dpX2ZhaWxlZCsrOworCQliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9GQUlMRUQpOworCQlyZXR1cm47CisJfQorCisJcGxvZ2lfcnNwID0gKHN0cnVjdCBmY19sb2dpX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKworCS8qKgorCSAqIENoZWNrIGZvciBmYWlsdXJlIGZpcnN0LgorCSAqLworCWlmIChwbG9naV9yc3AtPmVsc19jbWQuZWxzX2NvZGUgIT0gRkNfRUxTX0FDQykgeworCQlsc19yanQgPSAoc3RydWN0IGZjX2xzX3JqdF9zICopIEJGQV9GQ1hQX1JTUF9QTEQoZmN4cCk7CisKKwkJYmZhX3RyYyhycG9ydC0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlKTsKKwkJYmZhX3RyYyhycG9ydC0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlX2V4cGwpOworCisJCXJwb3J0LT5zdGF0cy5wbG9naV9yZWplY3RzKys7CisJCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX0ZBSUxFRCk7CisJCXJldHVybjsKKwl9CisKKwkvKioKKwkgKiBQTE9HSSBpcyBjb21wbGV0ZS4gTWFrZSBzdXJlIHRoaXMgZGV2aWNlIGlzIG5vdCBvbmUgb2YgdGhlIGtub3duCisJICogZGV2aWNlIHdpdGggYSBuZXcgRkMgcG9ydCBhZGRyZXNzLgorCSAqLworCWxpc3RfZm9yX2VhY2gocWUsICZycG9ydC0+cG9ydC0+cnBvcnRfcSkgeworCQl0d2luID0gKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKilxZTsKKwkJaWYgKHR3aW4gPT0gcnBvcnQpCisJCQljb250aW51ZTsKKwkJaWYgKCFycG9ydC0+cHd3biAmJiAocGxvZ2lfcnNwLT5wb3J0X25hbWUgPT0gdHdpbi0+cHd3bikpIHsKKwkJCWJmYV90cmMocnBvcnQtPmZjcywgdHdpbi0+cGlkKTsKKwkJCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisKKwkJCS8qCisJCQkgKiBVcGRhdGUgcGxvZ2kgc3RhdHMgaW4gdHdpbgorCQkJICovCisJCQl0d2luLT5zdGF0cy5wbG9naXMgKz0gcnBvcnQtPnN0YXRzLnBsb2dpczsKKwkJCXR3aW4tPnN0YXRzLnBsb2dpX3JlamVjdHMgKz0gcnBvcnQtPnN0YXRzLnBsb2dpX3JlamVjdHM7CisJCQl0d2luLT5zdGF0cy5wbG9naV90aW1lb3V0cyArPQorCQkJCXJwb3J0LT5zdGF0cy5wbG9naV90aW1lb3V0czsKKwkJCXR3aW4tPnN0YXRzLnBsb2dpX2ZhaWxlZCArPSBycG9ydC0+c3RhdHMucGxvZ2lfZmFpbGVkOworCQkJdHdpbi0+c3RhdHMucGxvZ2lfcmN2ZCArPSBycG9ydC0+c3RhdHMucGxvZ2lfcmN2ZDsKKwkJCXR3aW4tPnN0YXRzLnBsb2dpX2FjY3MrKzsKKworCQkJYmZhX2Zjc19ycG9ydF9kZWxldGUocnBvcnQpOworCisJCQliZmFfZmNzX3Jwb3J0X3VwZGF0ZSh0d2luLCBwbG9naV9yc3ApOworCQkJdHdpbi0+cGlkID0gcnNwX2ZjaHMtPnNfaWQ7CisJCQliZmFfc21fc2VuZF9ldmVudCh0d2luLCBSUFNNX0VWRU5UX1BMT0dJX0NPTVApOworCQkJcmV0dXJuOworCQl9CisJfQorCisJLyoqCisJICogTm9ybWFsIGxvZ2luIHBhdGggLS0gbm8gZXZpbCB0d2lucy4KKwkgKi8KKwlycG9ydC0+c3RhdHMucGxvZ2lfYWNjcysrOworCWJmYV9mY3NfcnBvcnRfdXBkYXRlKHJwb3J0LCBwbG9naV9yc3ApOworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX0FDQ0VQVEVEKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc2VuZF9wbG9naWFjYyh2b2lkICpycG9ydF9jYmFyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IHJwb3J0X2NiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IHJwb3J0LT5wb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlpbnQgICAgICAgICAgICAgbGVuOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cmVwbHlfb3hpZCk7CisKKwlmY3hwID0gZmN4cF9hbGxvY2VkID8gZmN4cF9hbGxvY2VkIDogYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKSB7CisJCWJmYV9mY3hwX2FsbG9jX3dhaXQocG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUsCisJCQkJICAgIGJmYV9mY3NfcnBvcnRfc2VuZF9wbG9naWFjYywgcnBvcnQpOworCQlyZXR1cm47CisJfQorCXJwb3J0LT5mY3hwID0gZmN4cDsKKworCWxlbiA9IGZjX3Bsb2dpX2FjY19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgcnBvcnQtPnBpZCwKKwkJCQkgYmZhX2Zjc19wb3J0X2dldF9mY2lkKHBvcnQpLCBycG9ydC0+cmVwbHlfb3hpZCwKKwkJCQkgcG9ydC0+cG9ydF9jZmcucHd3biwgcG9ydC0+cG9ydF9jZmcubnd3biwKKwkJCQkgYmZhX3Bwb3J0X2dldF9tYXhmcnNpemUocG9ydC0+ZmNzLT5iZmEpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIE5VTEwsIE5VTEwsIEZDX01BWF9QRFVTWiwgMCk7CisKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9GQ1hQX1NFTlQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9zZW5kX2FkaXNjKHZvaWQgKnJwb3J0X2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gcnBvcnRfY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gcnBvcnQtPnBvcnQ7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCWludCAgICAgICAgICAgICBsZW47CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19ycG9ydF9zZW5kX2FkaXNjLCBycG9ydCk7CisJCXJldHVybjsKKwl9CisJcnBvcnQtPmZjeHAgPSBmY3hwOworCisJbGVuID0gZmNfYWRpc2NfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksIHJwb3J0LT5waWQsCisJCQkgICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgMCwKKwkJCSAgICAgcG9ydC0+cG9ydF9jZmcucHd3biwgcG9ydC0+cG9ydF9jZmcubnd3bik7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywgQkZBX0ZBTFNFLAorCQkgICAgICBGQ19DTEFTU18zLCBsZW4sICZmY2hzLCBiZmFfZmNzX3Jwb3J0X2FkaXNjX3Jlc3BvbnNlLAorCQkgICAgICBycG9ydCwgRkNfTUFYX1BEVVNaLCBGQ19SQV9UT1YpOworCisJcnBvcnQtPnN0YXRzLmFkaXNjX3NlbnQrKzsKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9GQ1hQX1NFTlQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9hZGlzY19yZXNwb25zZSh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCB2b2lkICpjYmFyZywKKwkJCSAgICAgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsIHUzMiByc3BfbGVuLAorCQkJICAgICB1MzIgcmVzaWRfbGVuLCBzdHJ1Y3QgZmNoc19zICpyc3BfZmNocykKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopY2Jhcmc7CisJdm9pZCAgICAgICAgICAgKnBsZCA9IGJmYV9mY3hwX2dldF9yc3BidWYoZmN4cCk7CisJc3RydWN0IGZjX2xzX3JqdF9zICAgICpsc19yanQ7CisKKwlpZiAocmVxX3N0YXR1cyAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWJmYV90cmMocnBvcnQtPmZjcywgcmVxX3N0YXR1cyk7CisJCXJwb3J0LT5zdGF0cy5hZGlzY19mYWlsZWQrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfRkFJTEVEKTsKKwkJcmV0dXJuOworCX0KKworCWlmIChmY19hZGlzY19yc3BfcGFyc2UoKHN0cnVjdCBmY19hZGlzY19zICopcGxkLCByc3BfbGVuLCBycG9ydC0+cHd3biwKKwkJcnBvcnQtPm53d24pICA9PSBGQ19QQVJTRV9PSykgeworCQlycG9ydC0+c3RhdHMuYWRpc2NfYWNjcysrOworCQliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9BQ0NFUFRFRCk7CisJCXJldHVybjsKKwl9CisKKwlycG9ydC0+c3RhdHMuYWRpc2NfcmVqZWN0cysrOworCWxzX3JqdCA9IHBsZDsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGxzX3JqdC0+ZWxzX2NtZC5lbHNfY29kZSk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGxzX3JqdC0+cmVhc29uX2NvZGVfZXhwbCk7CisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfRkFJTEVEKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc2VuZF9naWRwbih2b2lkICpycG9ydF9jYmFyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IHJwb3J0X2NiYXJnOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IHJwb3J0LT5wb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwlpbnQgICAgICAgICAgICAgbGVuOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKworCWZjeHAgPSBmY3hwX2FsbG9jZWQgPyBmY3hwX2FsbG9jZWQgOiBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApIHsKKwkJYmZhX2ZjeHBfYWxsb2Nfd2FpdChwb3J0LT5mY3MtPmJmYSwgJnJwb3J0LT5mY3hwX3dxZSwKKwkJCQkgICAgYmZhX2Zjc19ycG9ydF9zZW5kX2dpZHBuLCBycG9ydCk7CisJCXJldHVybjsKKwl9CisJcnBvcnQtPmZjeHAgPSBmY3hwOworCisJbGVuID0gZmNfZ2lkcG5fYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksCisJCQkgICAgIGJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgMCwgcnBvcnQtPnB3d24pOworCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBOVUxMLCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsIEJGQV9GQUxTRSwKKwkJICAgICAgRkNfQ0xBU1NfMywgbGVuLCAmZmNocywgYmZhX2Zjc19ycG9ydF9naWRwbl9yZXNwb25zZSwKKwkJICAgICAgKHZvaWQgKilycG9ydCwgRkNfTUFYX1BEVVNaLCBGQ19SQV9UT1YpOworCisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfRkNYUF9TRU5UKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfZ2lkcG5fcmVzcG9uc2Uodm9pZCAqZmNzYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwgdm9pZCAqY2JhcmcsCisJCQkgICAgIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLCB1MzIgcnNwX2xlbiwKKwkJCSAgICAgdTMyIHJlc2lkX2xlbiwgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqKWNiYXJnOworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnR3aW47CisJc3RydWN0IGxpc3RfaGVhZCAqcWU7CisJc3RydWN0IGN0X2hkcl9zICAgICAgIAkqY3RoZHI7CisJc3RydWN0IGZjZ3NfZ2lkcG5fcmVzcF9zCSpnaWRwbl9yc3A7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5wd3duKTsKKworCWN0aGRyID0gKHN0cnVjdCBjdF9oZHJfcyAqKSBCRkFfRkNYUF9SU1BfUExEKGZjeHApOworCWN0aGRyLT5jbWRfcnNwX2NvZGUgPSBiZmFfb3NfbnRvaHMoY3RoZHItPmNtZF9yc3BfY29kZSk7CisKKwlpZiAoY3RoZHItPmNtZF9yc3BfY29kZSA9PSBDVF9SU1BfQUNDRVBUKSB7CisJCS8qCisJCSAqIENoZWNrIGlmIHRoZSBwaWQgaXMgdGhlIHNhbWUgYXMgYmVmb3JlLgorCQkgKi8KKwkJZ2lkcG5fcnNwID0gKHN0cnVjdCBmY2dzX2dpZHBuX3Jlc3BfcyAqKSAoY3RoZHIgKyAxKTsKKworCQlpZiAoZ2lkcG5fcnNwLT5kYXAgPT0gcnBvcnQtPnBpZCkgeworCQkJLyoKKwkJCSAqIERldmljZSBpcyBvbmxpbmUKKwkJCSAqLworCQkJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfQUNDRVBURUQpOworCQl9IGVsc2UgeworCQkJLyoKKwkJCSAqIERldmljZSdzIFBJRCBoYXMgY2hhbmdlZC4gV2UgbmVlZCB0byBjbGVhbnVwIGFuZAorCQkJICogcmUtbG9naW4uIElmIHRoZXJlIGlzIGFub3RoZXIgZGV2aWNlIHdpdGggdGhlIHRoZQorCQkJICogbmV3bHkgZGlzY292ZXJlZCBwaWQsIHNlbmQgYW4gc2NuIG5vdGljZSBzbyB0aGF0IGl0cworCQkJICogbmV3IHBpZCBjYW4gYmUgZGlzY292ZXJlZC4KKwkJCSAqLworCQkJbGlzdF9mb3JfZWFjaChxZSwgJnJwb3J0LT5wb3J0LT5ycG9ydF9xKSB7CisJCQkJdHdpbiA9IChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICopcWU7CisJCQkJaWYgKHR3aW4gPT0gcnBvcnQpCisJCQkJCWNvbnRpbnVlOworCQkJCWlmIChnaWRwbl9yc3AtPmRhcCA9PSB0d2luLT5waWQpIHsKKwkJCQkJYmZhX3RyYyhycG9ydC0+ZmNzLCB0d2luLT5waWQpOworCQkJCQliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCisJCQkJCXR3aW4tPnBpZCA9IDA7CisJCQkJCWJmYV9zbV9zZW5kX2V2ZW50KHR3aW4sCisJCQkJCQlSUFNNX0VWRU5UX0FERFJFU1NfQ0hBTkdFKTsKKwkJCQl9CisJCQl9CisJCQlycG9ydC0+cGlkID0gZ2lkcG5fcnNwLT5kYXA7CisJCQliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9BRERSRVNTX0NIQU5HRSk7CisJCX0KKwkJcmV0dXJuOworCX0KKworCS8qCisJICogUmVqZWN0IFJlc3BvbnNlCisJICovCisJc3dpdGNoIChjdGhkci0+cmVhc29uX2NvZGUpIHsKKwljYXNlIENUX1JTTl9MT0dJQ0FMX0JVU1k6CisJCS8qCisJCSAqIE5lZWQgdG8gcmV0cnkKKwkJICovCisJCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX1RJTUVPVVQpOworCQlicmVhazsKKworCWNhc2UgQ1RfUlNOX1VOQUJMRV9UT19QRVJGOgorCQkvKgorCQkgKiBkZXZpY2UgZG9lc24ndCBleGlzdCA6IFN0YXJ0IHRpbWVyIHRvIGNsZWFudXAgdGhpcyBsYXRlci4KKwkJICovCisJCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX0ZBSUxFRCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfRkFJTEVEKTsKKwkJYnJlYWs7CisJfQorfQorCisvKioKKyAqICAgIENhbGxlZCB0byBzZW5kIGEgbG9nb3V0IHRvIHRoZSBycG9ydC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc2VuZF9sb2dvKHZvaWQgKnJwb3J0X2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gcnBvcnRfY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwl1MTYgICAgICAgIGxlbjsKKworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisKKwlwb3J0ID0gcnBvcnQtPnBvcnQ7CisKKwlmY3hwID0gZmN4cF9hbGxvY2VkID8gZmN4cF9hbGxvY2VkIDogYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKSB7CisJCWJmYV9mY3hwX2FsbG9jX3dhaXQocG9ydC0+ZmNzLT5iZmEsICZycG9ydC0+ZmN4cF93cWUsCisJCQkJICAgIGJmYV9mY3NfcnBvcnRfc2VuZF9sb2dvLCBycG9ydCk7CisJCXJldHVybjsKKwl9CisJcnBvcnQtPmZjeHAgPSBmY3hwOworCisJbGVuID0gZmNfbG9nb19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgcnBvcnQtPnBpZCwKKwkJCSAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIDAsCisJCQkgICAgYmZhX2Zjc19wb3J0X2dldF9wd3duKHBvcnQpKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIE5VTEwsIHJwb3J0LCBGQ19NQVhfUERVU1osCisJCSAgICAgIEZDX0VEX1RPVik7CisKKwlycG9ydC0+c3RhdHMubG9nb3MrKzsKKwliZmFfZmN4cF9kaXNjYXJkKHJwb3J0LT5mY3hwKTsKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9GQ1hQX1NFTlQpOworfQorCisvKioKKyAqICAgIFNlbmQgQUNDIGZvciBhIExPR08gcmVjZWl2ZWQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3NlbmRfbG9nb19hY2Modm9pZCAqcnBvcnRfY2JhcmcpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSBycG9ydF9jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQ7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCXUxNiAgICAgICAgbGVuOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKworCXBvcnQgPSBycG9ydC0+cG9ydDsKKworCWZjeHAgPSBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApCisJCXJldHVybjsKKworCXJwb3J0LT5zdGF0cy5sb2dvX3JjdmQrKzsKKwlsZW4gPSBmY19sb2dvX2FjY19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgcnBvcnQtPnBpZCwKKwkJCQliZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIHJwb3J0LT5yZXBseV9veGlkKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIE5VTEwsIE5VTEwsIEZDX01BWF9QRFVTWiwgMCk7Cit9CisKKy8qKgorICogICAgIFRoaXMgcm91dGluZSB3aWxsIGJlIGNhbGxlZCBieSBiZmFfdGltZXIgb24gdGltZXIgdGltZW91dHMuCisgKgorICogCXBhcmFtW2luXSAJcnBvcnQgCQkJLSBwb2ludGVyIHRvIGJmYV9mY3NfcG9ydF9uc190LgorICogCXBhcmFtW291dF0JcnBvcnRfc3RhdHVzIAktIHBvaW50ZXIgdG8gcmV0dXJuIHZwb3J0IHN0YXR1cyBpbgorICoKKyAqIAlyZXR1cm4KKyAqIAkJdm9pZAorICoKKyogIAlTcGVjaWFsIENvbnNpZGVyYXRpb25zOgorICoKKyAqIAlub3RlCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3RpbWVvdXQodm9pZCAqYXJnKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKilhcmc7CisKKwlycG9ydC0+c3RhdHMucGxvZ2lfdGltZW91dHMrKzsKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9USU1FT1VUKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfcHJvY2Vzc19wcmxpKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJc3RydWN0IGZjaHNfcyAqcnhfZmNocywgdTE2IGxlbikKK3sKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gcnBvcnQtPnBvcnQ7CisJc3RydWN0IGZjX3BybGlfcyAgICAgICpwcmxpOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHJ4X2ZjaHMtPnNfaWQpOworCWJmYV90cmMocG9ydC0+ZmNzLCByeF9mY2hzLT5kX2lkKTsKKworCXJwb3J0LT5zdGF0cy5wcmxpX3JjdmQrKzsKKworCWlmIChCRkFfRkNTX1ZQT1JUX0lTX1RBUkdFVF9NT0RFKHBvcnQpKSB7CisJCS8qCisJCSAqIFRhcmdldCBNb2RlIDogTGV0IHRoZSBmY3B0bSBoYW5kbGUgaXQKKwkJICovCisJCWJmYV9mY3NfdGluX3J4X3BybGkocnBvcnQtPnRpbiwgcnhfZmNocywgbGVuKTsKKwkJcmV0dXJuOworCX0KKworCS8qCisJICogV2UgYXJlIGVpdGhlciBpbiBJbml0aWF0b3Igb3IgaXBmYyBNb2RlCisJICovCisJcHJsaSA9IChzdHJ1Y3QgZmNfcHJsaV9zICopIChyeF9mY2hzICsgMSk7CisKKwlpZiAocHJsaS0+cGFyYW1wYWdlLnNlcnZwYXJhbXMuaW5pdGlhdG9yKSB7CisJCWJmYV90cmMocnBvcnQtPmZjcywgcHJsaS0+cGFyYW1wYWdlLnR5cGUpOworCQlycG9ydC0+c2NzaV9mdW5jdGlvbiA9IEJGQV9SUE9SVF9JTklUSUFUT1I7CisJCWJmYV9mY3NfaXRuaW1faXNfaW5pdGlhdG9yKHJwb3J0LT5pdG5pbSk7CisJfSBlbHNlIHsKKwkJLyoKKwkJICogQHRvZG86IFBSTEkgZnJvbSBhIHRhcmdldCA/CisJCSAqLworCQliZmFfdHJjKHBvcnQtPmZjcywgcnhfZmNocy0+c19pZCk7CisJCXJwb3J0LT5zY3NpX2Z1bmN0aW9uID0gQkZBX1JQT1JUX1RBUkdFVDsKKwl9CisKKwlmY3hwID0gYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKQorCQlyZXR1cm47CisKKwlsZW4gPSBmY19wcmxpX2FjY19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgcnhfZmNocy0+c19pZCwKKwkJCQliZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIHJ4X2ZjaHMtPm94X2lkLAorCQkJCXBvcnQtPnBvcnRfY2ZnLnJvbGVzKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCSAgICAgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIE5VTEwsIE5VTEwsIEZDX01BWF9QRFVTWiwgMCk7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3Byb2Nlc3NfcnBzYyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCXN0cnVjdCBmY2hzX3MgKnJ4X2ZjaHMsIHUxNiBsZW4pCit7CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IHJwb3J0LT5wb3J0OworCXN0cnVjdCBmY19ycHNjX3NwZWVkX2luZm9fcyBzcGVlZHM7CisJc3RydWN0IGJmYV9wcG9ydF9hdHRyX3MgcHBvcnRfYXR0cjsKKworCWJmYV90cmMocG9ydC0+ZmNzLCByeF9mY2hzLT5zX2lkKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgcnhfZmNocy0+ZF9pZCk7CisKKwlycG9ydC0+c3RhdHMucnBzY19yY3ZkKys7CisJc3BlZWRzLnBvcnRfc3BlZWRfY2FwID0KKwkJUlBTQ19TUEVFRF9DQVBfMUcgfCBSUFNDX1NQRUVEX0NBUF8yRyB8IFJQU0NfU1BFRURfQ0FQXzRHIHwKKwkJUlBTQ19TUEVFRF9DQVBfOEc7CisKKwkvKgorCSAqIGdldCBjdXJlbnQgc3BlZWQgZnJvbSBwcG9ydCBhdHRyaWJ1dGVzIGZyb20gQkZBCisJICovCisJYmZhX3Bwb3J0X2dldF9hdHRyKHBvcnQtPmZjcy0+YmZhLCAmcHBvcnRfYXR0cik7CisKKwlzcGVlZHMucG9ydF9vcF9zcGVlZCA9IGZjX2JmYV9zcGVlZF90b19ycHNjX29wZXJzcGVlZChwcG9ydF9hdHRyLnNwZWVkKTsKKworCWZjeHAgPSBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwlpZiAoIWZjeHApCisJCXJldHVybjsKKworCWxlbiA9IGZjX3Jwc2NfYWNjX2J1aWxkKCZmY2hzLCBiZmFfZmN4cF9nZXRfcmVxYnVmKGZjeHApLCByeF9mY2hzLT5zX2lkLAorCQkJCWJmYV9mY3NfcG9ydF9nZXRfZmNpZChwb3J0KSwgcnhfZmNocy0+b3hfaWQsCisJCQkJJnNwZWVkcyk7CisKKwliZmFfZmN4cF9zZW5kKGZjeHAsIE5VTEwsIHBvcnQtPmZhYnJpYy0+dmZfaWQsIHBvcnQtPmxwX3RhZywgQkZBX0ZBTFNFLAorCQkgICAgICBGQ19DTEFTU18zLCBsZW4sICZmY2hzLCBOVUxMLCBOVUxMLCBGQ19NQVhfUERVU1osIDApOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9wcm9jZXNzX2FkaXNjKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJc3RydWN0IGZjaHNfcyAqcnhfZmNocywgdTE2IGxlbikKK3sKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gcnBvcnQtPnBvcnQ7CisJc3RydWN0IGZjX2FkaXNjX3MgICAgICAqYWRpc2M7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcnhfZmNocy0+c19pZCk7CisJYmZhX3RyYyhwb3J0LT5mY3MsIHJ4X2ZjaHMtPmRfaWQpOworCisJcnBvcnQtPnN0YXRzLmFkaXNjX3JjdmQrKzsKKworCWlmIChCRkFfRkNTX1ZQT1JUX0lTX1RBUkdFVF9NT0RFKHBvcnQpKSB7CisJCS8qCisJCSAqIEB0b2RvIDogVGFyZ2V0IE1vZGUgaGFuZGxpbmcKKwkJICovCisJCWJmYV90cmMocG9ydC0+ZmNzLCByeF9mY2hzLT5kX2lkKTsKKwkJYmZhX2Fzc2VydCgwKTsKKwkJcmV0dXJuOworCX0KKworCWFkaXNjID0gKHN0cnVjdCBmY19hZGlzY19zICopIChyeF9mY2hzICsgMSk7CisKKwkvKgorCSAqIEFjY2VwdCBpZiB0aGUgaXRuaW0gZm9yIHRoaXMgcnBvcnQgaXMgb25saW5lLiBFbHNlIHJlamVjdCB0aGUgQURJU0MKKwkgKi8KKwlpZiAoYmZhX2Zjc19pdG5pbV9nZXRfb25saW5lX3N0YXRlKHJwb3J0LT5pdG5pbSkgPT0gQkZBX1NUQVRVU19PSykgeworCisJCWZjeHAgPSBiZmFfZmNzX2ZjeHBfYWxsb2MocG9ydC0+ZmNzKTsKKwkJaWYgKCFmY3hwKQorCQkJcmV0dXJuOworCisJCWxlbiA9IGZjX2FkaXNjX2FjY19idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwKKwkJCQkJIHJ4X2ZjaHMtPnNfaWQsCisJCQkJCSBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksCisJCQkJCSByeF9mY2hzLT5veF9pZCwgcG9ydC0+cG9ydF9jZmcucHd3biwKKwkJCQkJIHBvcnQtPnBvcnRfY2ZnLm53d24pOworCisJCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLAorCQkJICAgICAgQkZBX0ZBTFNFLCBGQ19DTEFTU18zLCBsZW4sICZmY2hzLCBOVUxMLCBOVUxMLAorCQkJICAgICAgRkNfTUFYX1BEVVNaLCAwKTsKKwl9IGVsc2UgeworCQlycG9ydC0+c3RhdHMuYWRpc2NfcmVqZWN0ZWQrKzsKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX2xzX3JqdChycG9ydCwgcnhfZmNocywKKwkJCQkJICBGQ19MU19SSlRfUlNOX1VOQUJMRV9UT19QRVJGX0NNRCwKKwkJCQkJICBGQ19MU19SSlRfRVhQX0xPR0lOX1JFUVVJUkVEKTsKKwl9CisKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfaGFsX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBycG9ydC0+cG9ydDsKKwlzdHJ1Y3QgYmZhX3Jwb3J0X2luZm9fcyBycG9ydF9pbmZvOworCisJcnBvcnRfaW5mby5waWQgPSBycG9ydC0+cGlkOworCXJwb3J0X2luZm8ubG9jYWxfcGlkID0gcG9ydC0+cGlkOworCXJwb3J0X2luZm8ubHBfdGFnID0gcG9ydC0+bHBfdGFnOworCXJwb3J0X2luZm8udmZfaWQgPSBwb3J0LT5mYWJyaWMtPnZmX2lkOworCXJwb3J0X2luZm8udmZfZW4gPSBwb3J0LT5mYWJyaWMtPmlzX3ZmOworCXJwb3J0X2luZm8uZmNfY2xhc3MgPSBycG9ydC0+ZmNfY29zOworCXJwb3J0X2luZm8uY2lzYyA9IHJwb3J0LT5jaXNjOworCXJwb3J0X2luZm8ubWF4X2ZybXN6ID0gcnBvcnQtPm1heGZyc2l6ZTsKKwliZmFfcnBvcnRfb25saW5lKHJwb3J0LT5iZmFfcnBvcnQsICZycG9ydF9pbmZvKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfZmM0X3BhdXNlKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KQoreworCWlmIChiZmFfZmNzX3BvcnRfaXNfaW5pdGlhdG9yKHJwb3J0LT5wb3J0KSkKKwkJYmZhX2Zjc19pdG5pbV9wYXVzZShycG9ydC0+aXRuaW0pOworCisJaWYgKGJmYV9mY3NfcG9ydF9pc190YXJnZXQocnBvcnQtPnBvcnQpKQorCQliZmFfZmNzX3Rpbl9wYXVzZShycG9ydC0+dGluKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfZmM0X3Jlc3VtZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwlpZiAoYmZhX2Zjc19wb3J0X2lzX2luaXRpYXRvcihycG9ydC0+cG9ydCkpCisJCWJmYV9mY3NfaXRuaW1fcmVzdW1lKHJwb3J0LT5pdG5pbSk7CisKKwlpZiAoYmZhX2Zjc19wb3J0X2lzX3RhcmdldChycG9ydC0+cG9ydCkpCisJCWJmYV9mY3NfdGluX3Jlc3VtZShycG9ydC0+dGluKTsKK30KKworc3RhdGljIHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKgorYmZhX2Zjc19ycG9ydF9hbGxvYyhzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90IHB3d24sIHUzMiBycGlkKQoreworCXN0cnVjdCBiZmFfZmNzX3MgKmZjcyA9IHBvcnQtPmZjczsKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKwlzdHJ1Y3QgYmZhZF9ycG9ydF9zICpycG9ydF9kcnY7CisKKwkvKioKKwkgKiBhbGxvY2F0ZSBycG9ydAorCSAqLworCWlmIChiZmFfZmNiX3Jwb3J0X2FsbG9jKGZjcy0+YmZhZCwgJnJwb3J0LCAmcnBvcnRfZHJ2KQorCSAgICAhPSBCRkFfU1RBVFVTX09LKSB7CisJCWJmYV90cmMoZmNzLCBycGlkKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJLyoKKwkgKiBJbml0aWFsaXplIHItcG9ydAorCSAqLworCXJwb3J0LT5wb3J0ID0gcG9ydDsKKwlycG9ydC0+ZmNzID0gZmNzOworCXJwb3J0LT5ycF9kcnYgPSBycG9ydF9kcnY7CisJcnBvcnQtPnBpZCA9IHJwaWQ7CisJcnBvcnQtPnB3d24gPSBwd3duOworCisJLyoqCisJICogYWxsb2NhdGUgQkZBIHJwb3J0CisJICovCisJcnBvcnQtPmJmYV9ycG9ydCA9IGJmYV9ycG9ydF9jcmVhdGUocG9ydC0+ZmNzLT5iZmEsIHJwb3J0KTsKKwlpZiAoIXJwb3J0LT5iZmFfcnBvcnQpIHsKKwkJYmZhX3RyYyhmY3MsIHJwaWQpOworCQlrZnJlZShycG9ydF9kcnYpOworCQlyZXR1cm4gTlVMTDsKKwl9CisKKwkvKioKKwkgKiBhbGxvY2F0ZSBGQy00cworCSAqLworCWJmYV9hc3NlcnQoYmZhX2Zjc19wb3J0X2lzX2luaXRpYXRvcihwb3J0KSBeCisJCSAgIGJmYV9mY3NfcG9ydF9pc190YXJnZXQocG9ydCkpOworCisJaWYgKGJmYV9mY3NfcG9ydF9pc19pbml0aWF0b3IocG9ydCkpIHsKKwkJcnBvcnQtPml0bmltID0gYmZhX2Zjc19pdG5pbV9jcmVhdGUocnBvcnQpOworCQlpZiAoIXJwb3J0LT5pdG5pbSkgeworCQkJYmZhX3RyYyhmY3MsIHJwaWQpOworCQkJYmZhX3Jwb3J0X2RlbGV0ZShycG9ydC0+YmZhX3Jwb3J0KTsKKwkJCWtmcmVlKHJwb3J0X2Rydik7CisJCQlyZXR1cm4gTlVMTDsKKwkJfQorCX0KKworCWlmIChiZmFfZmNzX3BvcnRfaXNfdGFyZ2V0KHBvcnQpKSB7CisJCXJwb3J0LT50aW4gPSBiZmFfZmNzX3Rpbl9jcmVhdGUocnBvcnQpOworCQlpZiAoIXJwb3J0LT50aW4pIHsKKwkJCWJmYV90cmMoZmNzLCBycGlkKTsKKwkJCWJmYV9ycG9ydF9kZWxldGUocnBvcnQtPmJmYV9ycG9ydCk7CisJCQlrZnJlZShycG9ydF9kcnYpOworCQkJcmV0dXJuIE5VTEw7CisJCX0KKwl9CisKKwliZmFfZmNzX3BvcnRfYWRkX3Jwb3J0KHBvcnQsIHJwb3J0KTsKKworCWJmYV9zbV9zZXRfc3RhdGUocnBvcnQsIGJmYV9mY3NfcnBvcnRfc21fdW5pbml0KTsKKworCS8qCisJICogSW5pdGlhbGl6ZSB0aGUgUnBvcnQgRmVhdHVyZXMoUlBGKSBTdWIgTW9kdWxlCisJICovCisJaWYgKCFCRkFfRkNTX1BJRF9JU19XS0EocnBvcnQtPnBpZCkpCisJCWJmYV9mY3NfcnBmX2luaXQocnBvcnQpOworCisJcmV0dXJuIHJwb3J0OworfQorCisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X2ZyZWUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gcnBvcnQtPnBvcnQ7CisKKwkvKioKKwkgKiAtIGRlbGV0ZSBGQy00cworCSAqIC0gZGVsZXRlIEJGQSBycG9ydAorCSAqIC0gcmVtb3ZlIGZyb20gcXVldWUgb2YgcnBvcnRzCisJICovCisJaWYgKGJmYV9mY3NfcG9ydF9pc19pbml0aWF0b3IocG9ydCkpCisJCWJmYV9mY3NfaXRuaW1fZGVsZXRlKHJwb3J0LT5pdG5pbSk7CisKKwlpZiAoYmZhX2Zjc19wb3J0X2lzX3RhcmdldChwb3J0KSkKKwkJYmZhX2Zjc190aW5fZGVsZXRlKHJwb3J0LT50aW4pOworCisJYmZhX3Jwb3J0X2RlbGV0ZShycG9ydC0+YmZhX3Jwb3J0KTsKKwliZmFfZmNzX3BvcnRfZGVsX3Jwb3J0KHBvcnQsIHJwb3J0KTsKKwlrZnJlZShycG9ydC0+cnBfZHJ2KTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfYWVuX3Bvc3Qoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCSAgICAgICBlbnVtIGJmYV9ycG9ydF9hZW5fZXZlbnQgZXZlbnQsCisJCSAgICAgICBzdHJ1Y3QgYmZhX3Jwb3J0X2Flbl9kYXRhX3MgKmRhdGEpCit7CisJdW5pb24gYmZhX2Flbl9kYXRhX3UgYWVuX2RhdGE7CisJc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ21vZCA9IHJwb3J0LT5mY3MtPmxvZ207CisJd3duX3QgICAgICAgICAgIGxwd3duID0gYmZhX2Zjc19wb3J0X2dldF9wd3duKHJwb3J0LT5wb3J0KTsKKwl3d25fdCAgICAgICAgICAgcnB3d24gPSBycG9ydC0+cHd3bjsKKwljaGFyICAgICAgICAgICAgbHB3d25fcHRyW0JGQV9TVFJJTkdfMzJdOworCWNoYXIgICAgICAgICAgICBycHd3bl9wdHJbQkZBX1NUUklOR18zMl07CisJY2hhciAgICAgICAgICAgKnByaW9fc3RyW10gPSB7ICJ1bmtub3duIiwgImhpZ2giLCAibWVkaXVtIiwgImxvdyIgfTsKKworCXd3bjJzdHIobHB3d25fcHRyLCBscHd3bik7CisJd3duMnN0cihycHd3bl9wdHIsIHJwd3duKTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9SUE9SVF9BRU5fT05MSU5FOgorCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9SUE9SVF9PTkxJTkUsIHJwd3duX3B0ciwgbHB3d25fcHRyKTsKKwkJYnJlYWs7CisJY2FzZSBCRkFfUlBPUlRfQUVOX09GRkxJTkU6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX1JQT1JUX09GRkxJTkUsIHJwd3duX3B0ciwgbHB3d25fcHRyKTsKKwkJYnJlYWs7CisJY2FzZSBCRkFfUlBPUlRfQUVOX0RJU0NPTk5FQ1Q6CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX1JQT1JUX0RJU0NPTk5FQ1QsIHJwd3duX3B0ciwgbHB3d25fcHRyKTsKKwkJYnJlYWs7CisJY2FzZSBCRkFfUlBPUlRfQUVOX1FPU19QUklPOgorCQlhZW5fZGF0YS5ycG9ydC5wcml2LnFvcyA9IGRhdGEtPnByaXYucW9zOworCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9SUE9SVF9RT1NfUFJJTywKKwkJCXByaW9fc3RyW2Flbl9kYXRhLnJwb3J0LnByaXYucW9zLnFvc19wcmlvcml0eV0sCisJCQlycHd3bl9wdHIsIGxwd3duX3B0cik7CisJCWJyZWFrOworCWNhc2UgQkZBX1JQT1JUX0FFTl9RT1NfRkxPV0lEOgorCQlhZW5fZGF0YS5ycG9ydC5wcml2LnFvcyA9IGRhdGEtPnByaXYucW9zOworCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9SUE9SVF9RT1NfRkxPV0lELAorCQkJYWVuX2RhdGEucnBvcnQucHJpdi5xb3MucW9zX2Zsb3dfaWQsIHJwd3duX3B0ciwKKwkJCWxwd3duX3B0cik7CisJCWJyZWFrOworCWRlZmF1bHQ6CisJCWJyZWFrOworCX0KKworCWFlbl9kYXRhLnJwb3J0LnZmX2lkID0gcnBvcnQtPnBvcnQtPmZhYnJpYy0+dmZfaWQ7CisJYWVuX2RhdGEucnBvcnQucHB3d24gPQorCQliZmFfZmNzX3BvcnRfZ2V0X3B3d24oYmZhX2Zjc19nZXRfYmFzZV9wb3J0KHJwb3J0LT5mY3MpKTsKKwlhZW5fZGF0YS5ycG9ydC5scHd3biA9IGxwd3duOworCWFlbl9kYXRhLnJwb3J0LnJwd3duID0gcnB3d247Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X29ubGluZV9hY3Rpb24oc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gcnBvcnQtPnBvcnQ7CisKKwlycG9ydC0+c3RhdHMub25saW5lcysrOworCisJaWYgKGJmYV9mY3NfcG9ydF9pc19pbml0aWF0b3IocG9ydCkpIHsKKwkJYmZhX2Zjc19pdG5pbV9ycG9ydF9vbmxpbmUocnBvcnQtPml0bmltKTsKKwkJaWYgKCFCRkFfRkNTX1BJRF9JU19XS0EocnBvcnQtPnBpZCkpCisJCQliZmFfZmNzX3JwZl9ycG9ydF9vbmxpbmUocnBvcnQpOworCX07CisKKwlpZiAoYmZhX2Zjc19wb3J0X2lzX3RhcmdldChwb3J0KSkKKwkJYmZhX2Zjc190aW5fcnBvcnRfb25saW5lKHJwb3J0LT50aW4pOworCisJLyoKKwkgKiBEb24ndCBwb3N0IGV2ZW50cyBmb3Igd2VsbCBrbm93biBhZGRyZXNzZXMKKwkgKi8KKwlpZiAoIUJGQV9GQ1NfUElEX0lTX1dLQShycG9ydC0+cGlkKSkKKwkJYmZhX2Zjc19ycG9ydF9hZW5fcG9zdChycG9ydCwgQkZBX1JQT1JUX0FFTl9PTkxJTkUsIE5VTEwpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycG9ydF9vZmZsaW5lX2FjdGlvbihzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBycG9ydC0+cG9ydDsKKworCXJwb3J0LT5zdGF0cy5vZmZsaW5lcysrOworCisJLyoKKwkgKiBEb24ndCBwb3N0IGV2ZW50cyBmb3Igd2VsbCBrbm93biBhZGRyZXNzZXMKKwkgKi8KKwlpZiAoIUJGQV9GQ1NfUElEX0lTX1dLQShycG9ydC0+cGlkKSkgeworCQlpZiAoYmZhX2Zjc19wb3J0X2lzX29ubGluZShycG9ydC0+cG9ydCkgPT0gQkZBX1RSVUUpIHsKKwkJCWJmYV9mY3NfcnBvcnRfYWVuX3Bvc3QocnBvcnQsIEJGQV9SUE9SVF9BRU5fRElTQ09OTkVDVCwKKwkJCQkJICAgICAgIE5VTEwpOworCQl9IGVsc2UgeworCQkJYmZhX2Zjc19ycG9ydF9hZW5fcG9zdChycG9ydCwgQkZBX1JQT1JUX0FFTl9PRkZMSU5FLAorCQkJCQkgICAgICAgTlVMTCk7CisJCX0KKwl9CisKKwlpZiAoYmZhX2Zjc19wb3J0X2lzX2luaXRpYXRvcihwb3J0KSkgeworCQliZmFfZmNzX2l0bmltX3Jwb3J0X29mZmxpbmUocnBvcnQtPml0bmltKTsKKwkJaWYgKCFCRkFfRkNTX1BJRF9JU19XS0EocnBvcnQtPnBpZCkpCisJCQliZmFfZmNzX3JwZl9ycG9ydF9vZmZsaW5lKHJwb3J0KTsKKwl9CisKKwlpZiAoYmZhX2Zjc19wb3J0X2lzX3RhcmdldChwb3J0KSkKKwkJYmZhX2Zjc190aW5fcnBvcnRfb2ZmbGluZShycG9ydC0+dGluKTsKK30KKworLyoqCisgKiBVcGRhdGUgcnBvcnQgcGFyYW1ldGVycyBmcm9tIFBMT0dJIG9yIFBMT0dJIGFjY2VwdC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfdXBkYXRlKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LCBzdHJ1Y3QgZmNfbG9naV9zICpwbG9naSkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBycG9ydC0+cG9ydDsKKworCS8qKgorCSAqIC0gcG9ydCBuYW1lCisJICogLSBub2RlIG5hbWUKKwkgKi8KKwlycG9ydC0+cHd3biA9IHBsb2dpLT5wb3J0X25hbWU7CisJcnBvcnQtPm53d24gPSBwbG9naS0+bm9kZV9uYW1lOworCisJLyoqCisJICogLSBjbGFzcyBvZiBzZXJ2aWNlCisJICovCisJcnBvcnQtPmZjX2NvcyA9IDA7CisJaWYgKHBsb2dpLT5jbGFzczMuY2xhc3NfdmFsaWQpCisJCXJwb3J0LT5mY19jb3MgPSBGQ19DTEFTU18zOworCisJaWYgKHBsb2dpLT5jbGFzczIuY2xhc3NfdmFsaWQpCisJCXJwb3J0LT5mY19jb3MgfD0gRkNfQ0xBU1NfMjsKKworCS8qKgorCSAqIC0gQ0lTQworCSAqIC0gTUFYIHJlY2VpdmUgZnJhbWUgc2l6ZQorCSAqLworCXJwb3J0LT5jaXNjID0gcGxvZ2ktPmNzcC5jaXNjOworCXJwb3J0LT5tYXhmcnNpemUgPSBiZmFfb3NfbnRvaHMocGxvZ2ktPmNsYXNzMy5yeHN6KTsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBiZmFfb3NfbnRvaHMocGxvZ2ktPmNzcC5iYmNyZWQpKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+ZmFicmljLT5iYl9jcmVkaXQpOworCS8qKgorCSAqIERpcmVjdCBBdHRhY2ggUDJQIG1vZGUgOgorCSAqIFRoaXMgaXMgdG8gaGFuZGxlIGEgYnVnICgyMzM0NzYpIGluIElCTSB0YXJnZXRzIGluIERpcmVjdCBBdHRhY2gKKwkgKiBNb2RlLiBCYXNpY2FsbHksIGluIEZMT0dJIEFjY2VwdCB0aGUgdGFyZ2V0IHdvdWxkIGhhdmUgZXJyb25lb3VzbHkKKwkgKiBzZXQgdGhlIEJCIENyZWRpdCB0byB0aGUgdmFsdWUgdXNlZCBpbiB0aGUgRkxPR0kgc2VudCBieSB0aGUgSEJBLgorCSAqIEl0IHVzZXMgdGhlIGNvcnJlY3QgdmFsdWUgKGl0cyBvd24gQkIgY3JlZGl0KSBpbiBQTE9HSS4KKwkgKi8KKwlpZiAoKCFiZmFfZmNzX2ZhYnJpY19pc19zd2l0Y2hlZChwb3J0LT5mYWJyaWMpKQorCSAgICAmJiAoYmZhX29zX250b2hzKHBsb2dpLT5jc3AuYmJjcmVkKSA8IHBvcnQtPmZhYnJpYy0+YmJfY3JlZGl0KSkgeworCisJCWJmYV90cmMocG9ydC0+ZmNzLCBiZmFfb3NfbnRvaHMocGxvZ2ktPmNzcC5iYmNyZWQpKTsKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIHBvcnQtPmZhYnJpYy0+YmJfY3JlZGl0KTsKKworCQlwb3J0LT5mYWJyaWMtPmJiX2NyZWRpdCA9IGJmYV9vc19udG9ocyhwbG9naS0+Y3NwLmJiY3JlZCk7CisJCWJmYV9wcG9ydF9zZXRfdHhfYmJjcmVkaXQocG9ydC0+ZmNzLT5iZmEsCisJCQkJCSAgcG9ydC0+ZmFicmljLT5iYl9jcmVkaXQpOworCX0KKworfQorCisvKioKKyAqICAgQ2FsbGVkIHRvIGhhbmRsZSBMT0dPIHJlY2VpdmVkIGZyb20gYW4gZXhpc3RpbmcgcmVtb3RlIHBvcnQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Jwb3J0X3Byb2Nlc3NfbG9nbyhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwgc3RydWN0IGZjaHNfcyAqZmNocykKK3sKKwlycG9ydC0+cmVwbHlfb3hpZCA9IGZjaHMtPm94X2lkOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnJlcGx5X294aWQpOworCisJcnBvcnQtPnN0YXRzLmxvZ29fcmN2ZCsrOworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX0xPR09fUkNWRCk7Cit9CisKKworCisvKioKKyAqICBmY3NfcnBvcnRfcHVibGljIEZDUyBycG9ydCBwdWJsaWMgaW50ZXJmYWNlcworICovCisKKy8qKgorICogCUNhbGxlZCBieSBicG9ydC92cG9ydCB0byBjcmVhdGUgYSByZW1vdGUgcG9ydCBpbnN0YW5jZSBmb3IgYSBkaXNjb3ZlcmVkCisgKiAJcmVtb3RlIGRldmljZS4KKyAqCisgKiBAcGFyYW1baW5dIHBvcnQJLSBiYXNlIHBvcnQgb3IgdnBvcnQKKyAqIEBwYXJhbVtpbl0gcnBpZAktIHJlbW90ZSBwb3J0IElECisgKgorICogQHJldHVybiBOb25lCisgKi8KK3N0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKgorYmZhX2Zjc19ycG9ydF9jcmVhdGUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB1MzIgcnBpZCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBycGlkKTsKKwlycG9ydCA9IGJmYV9mY3NfcnBvcnRfYWxsb2MocG9ydCwgV1dOX05VTEwsIHJwaWQpOworCWlmICghcnBvcnQpCisJCXJldHVybiBOVUxMOworCisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfUExPR0lfU0VORCk7CisJcmV0dXJuIHJwb3J0OworfQorCisvKioKKyAqIENhbGxlZCB0byBjcmVhdGUgYSBycG9ydCBmb3Igd2hpY2ggb25seSB0aGUgd3duIGlzIGtub3duLgorICoKKyAqIEBwYXJhbVtpbl0gcG9ydAktIGJhc2UgcG9ydAorICogQHBhcmFtW2luXSBycHd3bgktIHJlbW90ZSBwb3J0IHd3bgorICoKKyAqIEByZXR1cm4gTm9uZQorICovCitzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICoKK2JmYV9mY3NfcnBvcnRfY3JlYXRlX2J5X3d3bihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90IHJwd3duKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHJwd3duKTsKKwlycG9ydCA9IGJmYV9mY3NfcnBvcnRfYWxsb2MocG9ydCwgcnB3d24sIDApOworCWlmICghcnBvcnQpCisJCXJldHVybiBOVUxMOworCisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfQUREUkVTU19ESVNDKTsKKwlyZXR1cm4gcnBvcnQ7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IGJwb3J0IGluIHByaXZhdGUgbG9vcCB0b3BvbG9neSB0byBpbmRpY2F0ZSB0aGF0IGEKKyAqIHJwb3J0IGhhcyBiZWVuIGRpc2NvdmVyZWQgYW5kIHBsb2dpIGhhcyBiZWVuIGNvbXBsZXRlZC4KKyAqCisgKiBAcGFyYW1baW5dIHBvcnQJLSBiYXNlIHBvcnQgb3IgdnBvcnQKKyAqIEBwYXJhbVtpbl0gcnBpZAktIHJlbW90ZSBwb3J0IElECisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfc3RhcnQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCBzdHJ1Y3QgZmNoc19zICpmY2hzLAorCQkJc3RydWN0IGZjX2xvZ2lfcyAqcGxvZ2kpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQ7CisKKwlycG9ydCA9IGJmYV9mY3NfcnBvcnRfYWxsb2MocG9ydCwgV1dOX05VTEwsIGZjaHMtPnNfaWQpOworCWlmICghcnBvcnQpCisJCXJldHVybjsKKworCWJmYV9mY3NfcnBvcnRfdXBkYXRlKHJwb3J0LCBwbG9naSk7CisKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9QTE9HSV9DT01QKTsKK30KKworLyoqCisgKiAgIENhbGxlZCBieSBicG9ydC92cG9ydCB0byBoYW5kbGUgUExPR0kgcmVjZWl2ZWQgZnJvbSBhIG5ldyByZW1vdGUgcG9ydC4KKyAqICAgSWYgYW4gZXhpc3RpbmcgcnBvcnQgZG9lcyBhIHBsb2dpLCBpdCB3aWxsIGJlIGhhbmRsZWQgc2VwYXJhdGVseS4KKyAqLwordm9pZAorYmZhX2Zjc19ycG9ydF9wbG9naV9jcmVhdGUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCBzdHJ1Y3QgZmNoc19zICpmY2hzLAorCQkJICAgc3RydWN0IGZjX2xvZ2lfcyAqcGxvZ2kpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQ7CisKKwlycG9ydCA9IGJmYV9mY3NfcnBvcnRfYWxsb2MocG9ydCwgcGxvZ2ktPnBvcnRfbmFtZSwgZmNocy0+c19pZCk7CisJaWYgKCFycG9ydCkKKwkJcmV0dXJuOworCisJYmZhX2Zjc19ycG9ydF91cGRhdGUocnBvcnQsIHBsb2dpKTsKKworCXJwb3J0LT5yZXBseV9veGlkID0gZmNocy0+b3hfaWQ7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cmVwbHlfb3hpZCk7CisKKwlycG9ydC0+c3RhdHMucGxvZ2lfcmN2ZCsrOworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX1BMT0dJX1JDVkQpOworfQorCitzdGF0aWMgaW50Cit3d25fY29tcGFyZSh3d25fdCB3d24xLCB3d25fdCB3d24yKQoreworCXU4ICAgICAgICAqYjEgPSAodTggKikgJnd3bjE7CisJdTggICAgICAgICpiMiA9ICh1OCAqKSAmd3duMjsKKwlpbnQgICAgICAgICAgICAgaTsKKworCWZvciAoaSA9IDA7IGkgPCBzaXplb2Yod3duX3QpOyBpKyspIHsKKwkJaWYgKGIxW2ldIDwgYjJbaV0pCisJCQlyZXR1cm4gLTE7CisJCWlmIChiMVtpXSA+IGIyW2ldKQorCQkJcmV0dXJuIDE7CisJfQorCXJldHVybiAwOworfQorCisvKioKKyAqICAgQ2FsbGVkIGJ5IGJwb3J0L3Zwb3J0IHRvIGhhbmRsZSBQTE9HSSByZWNlaXZlZCBmcm9tIGFuIGV4aXN0aW5nCisgKiAJIHJlbW90ZSBwb3J0LgorICovCit2b2lkCitiZmFfZmNzX3Jwb3J0X3Bsb2dpKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LCBzdHJ1Y3QgZmNoc19zICpyeF9mY2hzLAorCQkgICAgc3RydWN0IGZjX2xvZ2lfcyAqcGxvZ2kpCit7CisJLyoqCisJICogQHRvZG8gSGFuZGxlIFAyUCBhbmQgaW5pdGlhdG9yLWluaXRpYXRvci4KKwkgKi8KKworCWJmYV9mY3NfcnBvcnRfdXBkYXRlKHJwb3J0LCBwbG9naSk7CisKKwlycG9ydC0+cmVwbHlfb3hpZCA9IHJ4X2ZjaHMtPm94X2lkOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnJlcGx5X294aWQpOworCisJLyoqCisJICogSW4gU3dpdGNoZWQgZmFicmljIHRvcG9sb2d5LAorCSAqIFBMT0dJIHRvIGVhY2ggb3RoZXIuIElmIG91ciBwd3duIGlzIHNtYWxsZXIsIGlnbm9yZSBpdCwKKwkgKiBpZiBpdCBpcyBub3QgYSB3ZWxsIGtub3duIGFkZHJlc3MuCisJICogSWYgdGhlIGxpbmsgdG9wb2xvZ3kgaXMgTjJOLAorCSAqIHRoaXMgUGxvZ2kgc2hvdWxkIGJlIGFjY2VwdGVkLgorCSAqLworCWlmICgod3duX2NvbXBhcmUocnBvcnQtPnBvcnQtPnBvcnRfY2ZnLnB3d24sIHJwb3J0LT5wd3duKSA9PSAtMSkKKwkgICAgJiYgKGJmYV9mY3NfZmFicmljX2lzX3N3aXRjaGVkKHJwb3J0LT5wb3J0LT5mYWJyaWMpKQorCSAgICAmJiAoIUJGQV9GQ1NfUElEX0lTX1dLQShycG9ydC0+cGlkKSkpIHsKKwkJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwkJcmV0dXJuOworCX0KKworCXJwb3J0LT5zdGF0cy5wbG9naV9yY3ZkKys7CisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfUExPR0lfUkNWRCk7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IGJwb3J0L3Zwb3J0IHRvIGRlbGV0ZSBhIHJlbW90ZSBwb3J0IGluc3RhbmNlLgorICoKKyogUnBvcnQgZGVsZXRlIGlzIGNhbGxlZCB1bmRlciB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnM6CisgKiAJCS0gdnBvcnQgaXMgZGVsZXRlZAorICogCQktIHZmIGlzIGRlbGV0ZWQKKyAqIAkJLSBleHBsaWNpdCByZXF1ZXN0IGZyb20gT1MgdG8gZGVsZXRlIHJwb3J0ICh2bXdhcmUpCisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfZGVsZXRlKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KQoreworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX0RFTEVURSk7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IGJwb3J0L3Zwb3J0IHRvICB3aGVuIGEgdGFyZ2V0IGdvZXMgb2ZmbGluZS4KKyAqCisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9MT0dPX0lNUCk7Cit9CisKKy8qKgorICogQ2FsbGVkIGJ5IGJwb3J0IGluIG4ybiB3aGVuIGEgdGFyZ2V0IChhdHRhY2hlZCBwb3J0KSBiZWNvbWVzIG9ubGluZS4KKyAqCisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfb25saW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KQoreworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX1BMT0dJX1NFTkQpOworfQorCisvKioKKyAqICAgQ2FsbGVkIGJ5IGJwb3J0L3Zwb3J0IHRvIG5vdGlmeSBTQ04gZm9yIHRoZSByZW1vdGUgcG9ydAorICovCit2b2lkCitiZmFfZmNzX3Jwb3J0X3NjbihzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKworCXJwb3J0LT5zdGF0cy5yc2NucysrOworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX1NDTik7Cit9CisKKy8qKgorICogICBDYWxsZWQgYnkgIGZjcGltIHRvIG5vdGlmeSB0aGF0IHRoZSBJVE4gY2xlYW51cCBpcyBkb25lLgorICovCit2b2lkCitiZmFfZmNzX3Jwb3J0X2l0bmltX2FjayhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9GQzRfT0ZGTElORSk7Cit9CisKKy8qKgorICogICBDYWxsZWQgYnkgZmNwdG0gdG8gbm90aWZ5IHRoYXQgdGhlIElUTiBjbGVhbnVwIGlzIGRvbmUuCisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfdGluX2FjayhzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudChycG9ydCwgUlBTTV9FVkVOVF9GQzRfT0ZGTElORSk7Cit9CisKKy8qKgorICogICAgIFRoaXMgcm91dGluZSBCRkEgY2FsbGJhY2sgZm9yIGJmYV9ycG9ydF9vbmxpbmUoKSBjYWxsLgorICoKKyAqIAlwYXJhbVtpbl0gCWNiX2FyZwktICBycG9ydCBzdHJ1Y3QuCisgKgorICogCXJldHVybgorICogCQl2b2lkCisgKgorKiAJU3BlY2lhbCBDb25zaWRlcmF0aW9uczoKKyAqCisgKiAJbm90ZQorICovCit2b2lkCitiZmFfY2JfcnBvcnRfb25saW5lKHZvaWQgKmNiYXJnKQoreworCisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqKWNiYXJnOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfSENCX09OTElORSk7Cit9CisKKy8qKgorICogICAgIFRoaXMgcm91dGluZSBCRkEgY2FsbGJhY2sgZm9yIGJmYV9ycG9ydF9vZmZsaW5lKCkgY2FsbC4KKyAqCisgKiAJcGFyYW1baW5dIAlycG9ydCAJLQorICoKKyAqIAlyZXR1cm4KKyAqIAkJdm9pZAorICoKKyAqIAlTcGVjaWFsIENvbnNpZGVyYXRpb25zOgorICoKKyAqIAlub3RlCisgKi8KK3ZvaWQKK2JmYV9jYl9ycG9ydF9vZmZsaW5lKHZvaWQgKmNiYXJnKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKiljYmFyZzsKKworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV9zbV9zZW5kX2V2ZW50KHJwb3J0LCBSUFNNX0VWRU5UX0hDQl9PRkZMSU5FKTsKK30KKworLyoqCisgKiBUaGlzIHJvdXRpbmUgaXMgYSBzdGF0aWMgQkZBIGNhbGxiYWNrIHdoZW4gdGhlcmUgaXMgYSBRb1MgZmxvd19pZAorICogY2hhbmdlIG5vdGlmaWNhdGlvbgorICoKKyAqIEBwYXJhbVtpbl0gCXJwb3J0IAktCisgKgorICogQHJldHVybiAgCXZvaWQKKyAqCisgKiBTcGVjaWFsIENvbnNpZGVyYXRpb25zOgorICoKKyAqIEBub3RlCisgKi8KK3ZvaWQKK2JmYV9jYl9ycG9ydF9xb3Nfc2NuX2Zsb3dpZCh2b2lkICpjYmFyZywKKwkJCSAgICBzdHJ1Y3QgYmZhX3Jwb3J0X3Fvc19hdHRyX3Mgb2xkX3Fvc19hdHRyLAorCQkJICAgIHN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyBuZXdfcW9zX2F0dHIpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqKWNiYXJnOworCXN0cnVjdCBiZmFfcnBvcnRfYWVuX2RhdGFfcyBhZW5fZGF0YTsKKworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWFlbl9kYXRhLnByaXYucW9zID0gbmV3X3Fvc19hdHRyOworCWJmYV9mY3NfcnBvcnRfYWVuX3Bvc3QocnBvcnQsIEJGQV9SUE9SVF9BRU5fUU9TX0ZMT1dJRCwgJmFlbl9kYXRhKTsKK30KKworLyoqCisgKiBUaGlzIHJvdXRpbmUgaXMgYSBzdGF0aWMgQkZBIGNhbGxiYWNrIHdoZW4gdGhlcmUgaXMgYSBRb1MgcHJpb3JpdHkKKyAqIGNoYW5nZSBub3RpZmljYXRpb24KKyAqCisgKiBAcGFyYW1baW5dIAlycG9ydCAJLQorICoKKyAqIEByZXR1cm4gCXZvaWQKKyAqCisgKiBTcGVjaWFsIENvbnNpZGVyYXRpb25zOgorICoKKyAqIEBub3RlCisgKi8KK3ZvaWQKK2JmYV9jYl9ycG9ydF9xb3Nfc2NuX3ByaW8odm9pZCAqY2JhcmcsIHN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyBvbGRfcW9zX2F0dHIsCisJCQkgIHN0cnVjdCBiZmFfcnBvcnRfcW9zX2F0dHJfcyBuZXdfcW9zX2F0dHIpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqKWNiYXJnOworCXN0cnVjdCBiZmFfcnBvcnRfYWVuX2RhdGFfcyBhZW5fZGF0YTsKKworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWFlbl9kYXRhLnByaXYucW9zID0gbmV3X3Fvc19hdHRyOworCWJmYV9mY3NfcnBvcnRfYWVuX3Bvc3QocnBvcnQsIEJGQV9SUE9SVF9BRU5fUU9TX1BSSU8sICZhZW5fZGF0YSk7Cit9CisKKy8qKgorICogCQlDYWxsZWQgdG8gcHJvY2VzcyBhbnkgdW5zb2xpY3RlZCBmcmFtZXMgZnJvbSB0aGlzIHJlbW90ZSBwb3J0CisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfbG9nb19pbXAoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpCit7CisJYmZhX3NtX3NlbmRfZXZlbnQocnBvcnQsIFJQU01fRVZFTlRfTE9HT19JTVApOworfQorCisvKioKKyAqIAkJQ2FsbGVkIHRvIHByb2Nlc3MgYW55IHVuc29saWN0ZWQgZnJhbWVzIGZyb20gdGhpcyByZW1vdGUgcG9ydAorICovCit2b2lkCitiZmFfZmNzX3Jwb3J0X3VmX3JlY3Yoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsIHN0cnVjdCBmY2hzX3MgKmZjaHMsCisJCQl1MTYgbGVuKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IHJwb3J0LT5wb3J0OworCXN0cnVjdCBmY19lbHNfY21kX3MgICAqZWxzX2NtZDsKKworCWJmYV90cmMocnBvcnQtPmZjcywgZmNocy0+c19pZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBmY2hzLT5kX2lkKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGZjaHMtPnR5cGUpOworCisJaWYgKGZjaHMtPnR5cGUgIT0gRkNfVFlQRV9FTFMpCisJCXJldHVybjsKKworCWVsc19jbWQgPSAoc3RydWN0IGZjX2Vsc19jbWRfcyAqKSAoZmNocyArIDEpOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBlbHNfY21kLT5lbHNfY29kZSk7CisKKwlzd2l0Y2ggKGVsc19jbWQtPmVsc19jb2RlKSB7CisJY2FzZSBGQ19FTFNfTE9HTzoKKwkJYmZhX2Zjc19ycG9ydF9wcm9jZXNzX2xvZ28ocnBvcnQsIGZjaHMpOworCQlicmVhazsKKworCWNhc2UgRkNfRUxTX0FESVNDOgorCQliZmFfZmNzX3Jwb3J0X3Byb2Nlc3NfYWRpc2MocnBvcnQsIGZjaHMsIGxlbik7CisJCWJyZWFrOworCisJY2FzZSBGQ19FTFNfUFJMTzoKKwkJaWYgKGJmYV9mY3NfcG9ydF9pc19pbml0aWF0b3IocG9ydCkpCisJCQliZmFfZmNzX2ZjcGltX3VmX3JlY3YocnBvcnQtPml0bmltLCBmY2hzLCBsZW4pOworCisJCWlmIChiZmFfZmNzX3BvcnRfaXNfdGFyZ2V0KHBvcnQpKQorCQkJYmZhX2Zjc19mY3B0bV91Zl9yZWN2KHJwb3J0LT50aW4sIGZjaHMsIGxlbik7CisJCWJyZWFrOworCisJY2FzZSBGQ19FTFNfUFJMSToKKwkJYmZhX2Zjc19ycG9ydF9wcm9jZXNzX3BybGkocnBvcnQsIGZjaHMsIGxlbik7CisJCWJyZWFrOworCisJY2FzZSBGQ19FTFNfUlBTQzoKKwkJYmZhX2Zjc19ycG9ydF9wcm9jZXNzX3Jwc2MocnBvcnQsIGZjaHMsIGxlbik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Zjc19ycG9ydF9zZW5kX2xzX3JqdChycG9ydCwgZmNocywKKwkJCQkJICBGQ19MU19SSlRfUlNOX0NNRF9OT1RfU1VQUCwKKwkJCQkJICBGQ19MU19SSlRfRVhQX05PX0FERExfSU5GTyk7CisJCWJyZWFrOworCX0KK30KKworLyoKKyAqIFNlbmQgYSBMUyByZWplY3QKKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBvcnRfc2VuZF9sc19yanQoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsIHN0cnVjdCBmY2hzX3MgKnJ4X2ZjaHMsCisJCQkgIHU4IHJlYXNvbl9jb2RlLCB1OCByZWFzb25fY29kZV9leHBsKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IHJwb3J0LT5wb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cDsKKwlpbnQgICAgICAgICAgICAgbGVuOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCByeF9mY2hzLT5zX2lkKTsKKworCWZjeHAgPSBiZmFfZmNzX2ZjeHBfYWxsb2MocnBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKQorCQlyZXR1cm47CisKKwlsZW4gPSBmY19sc19yanRfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksIHJ4X2ZjaHMtPnNfaWQsCisJCQkgICAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIHJ4X2ZjaHMtPm94X2lkLAorCQkJICAgICAgcmVhc29uX2NvZGUsIHJlYXNvbl9jb2RlX2V4cGwpOworCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBOVUxMLCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsIEJGQV9GQUxTRSwKKwkJICAgICAgRkNfQ0xBU1NfMywgbGVuLCAmZmNocywgTlVMTCwgTlVMTCwgRkNfTUFYX1BEVVNaLCAwKTsKK30KKworLyoqCisgKiAgIE1vZHVsZSBpbml0aWFsaXphdGlvbgorICovCit2b2lkCitiZmFfZmNzX3Jwb3J0X21vZGluaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKQoreworfQorCisvKioKKyAqICAgTW9kdWxlIGNsZWFudXAKKyAqLwordm9pZAorYmZhX2Zjc19ycG9ydF9tb2RleGl0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcykKK3sKKwliZmFfZmNzX21vZGV4aXRfY29tcChmY3MpOworfQorCisvKioKKyAqIFJldHVybiBzdGF0ZSBvZiBycG9ydC4KKyAqLworaW50CitiZmFfZmNzX3Jwb3J0X2dldF9zdGF0ZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCkKK3sKKwlyZXR1cm4gYmZhX3NtX3RvX3N0YXRlKHJwb3J0X3NtX3RhYmxlLCBycG9ydC0+c20pOworfQorCisvKioKKyAqIAkJIENhbGxlZCBieSB0aGUgRHJpdmVyIHRvIHNldCBycG9ydCBkZWxldGUvYWdlb3V0IHRpbWVvdXQKKyAqCisgKiAJcGFyYW1baW5dCQlycG9ydCB0aW1lb3V0IHZhbHVlIGluIHNlY29uZHMuCisgKgorICogCXJldHVybiBOb25lCisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfc2V0X2RlbF90aW1lb3V0KHU4IHJwb3J0X3RtbykKK3sKKwkvKgorCSAqIGNvbnZlcnQgdG8gTWlsbGlzZWNzCisJICovCisJaWYgKHJwb3J0X3RtbyA+IDApCisJCWJmYV9mY3NfcnBvcnRfZGVsX3RpbWVvdXQgPSBycG9ydF90bW8gKiAxMDAwOworfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9ycG9ydF9hcGkuYyBiL2RyaXZlcnMvc2NzaS9iZmEvcnBvcnRfYXBpLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2RhZTE3NwotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvcnBvcnRfYXBpLmMKQEAgLTAsMCArMSwxODAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSAiZmNzX3Zwb3J0LmgiCisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorCitCRkFfVFJDX0ZJTEUoRkNTLCBSUE9SVF9BUEkpOworCisvKioKKyAqICBycG9ydF9hcGkuYyBSZW1vdGUgcG9ydCBpbXBsZW1lbnRhdGlvbi4KKyAqLworCisvKioKKyAqICBmY3NfcnBvcnRfYXBpIEZDUyBycG9ydCBBUEkuCisgKi8KKworLyoqCisgKiAJRGlyZWN0IEFQSSB0byBhZGQgYSB0YXJnZXQgYnkgcG9ydCB3d24uIFRoaXMgaW50ZXJmYWNlIGlzIHVzZWQsIGZvcgorICoJZXhhbXBsZSwgYnkgYmlvcyB3aGVuIHRhcmdldCBwd3duIGlzIGtub3duIGZyb20gYm9vdCBsdW4gY29uZmlndXJhdGlvbi4KKyAqLworYmZhX3N0YXR1c190CitiZmFfZmNzX3Jwb3J0X2FkZChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHd3bl90ICpwd3duLAorCQkJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQlzdHJ1Y3QgYmZhZF9ycG9ydF9zICpycG9ydF9kcnYpCit7CisJYmZhX3RyYyhwb3J0LT5mY3MsICpwd3duKTsKKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqCURpcmVjdCBBUEkgdG8gcmVtb3ZlIGEgdGFyZ2V0IGFuZCBpdHMgYXNzb2NpYXRlZCByZXNvdXJjZXMuIFRoaXMKKyAqCWludGVyZmFjZSBpcyB1c2VkLCBmb3IgZXhhbXBsZSwgYnkgdm13YXJlIGRyaXZlciB0byByZW1vdmUgdGFyZ2V0CisgKglwb3J0cyBmcm9tIHRoZSB0YXJnZXQgbGlzdCBmb3IgYSBWTS4KKyAqLworYmZhX3N0YXR1c190CitiZmFfZmNzX3Jwb3J0X3JlbW92ZShzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydF9pbikKK3sKKworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OworCisJYmZhX3RyYyhycG9ydF9pbi0+ZmNzLCBycG9ydF9pbi0+cHd3bik7CisKKwlycG9ydCA9IGJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfYnlfcHd3bihycG9ydF9pbi0+cG9ydCwgcnBvcnRfaW4tPnB3d24pOworCWlmIChycG9ydCA9PSBOVUxMKSB7CisJCS8qCisJCSAqIFRCRCBFcnJvciBoYW5kbGluZworCQkgKi8KKwkJYmZhX3RyYyhycG9ydF9pbi0+ZmNzLCBycG9ydF9pbi0+cGlkKTsKKwkJcmV0dXJuIEJGQV9TVEFUVVNfVU5LTk9XTl9SV1dOOworCX0KKworCS8qCisJICogVEJEIGlmIHRoaXMgcmVtb3RlIHBvcnQgaXMgb25saW5lLCBzZW5kIGEgbG9nbworCSAqLworCXJldHVybiBCRkFfU1RBVFVTX09LOworCit9CisKKy8qKgorICoJUmVtb3RlIGRldmljZSBzdGF0dXMgZm9yIGRpc3BsYXkvZGVidWcuCisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfZ2V0X2F0dHIoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQsCisJCQlzdHJ1Y3QgYmZhX3Jwb3J0X2F0dHJfcyAqcnBvcnRfYXR0cikKK3sKKwlzdHJ1Y3QgYmZhX3Jwb3J0X3Fvc19hdHRyX3MgcW9zX2F0dHI7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gcnBvcnQtPnBvcnQ7CisKKwliZmFfb3NfbWVtc2V0KHJwb3J0X2F0dHIsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3Jwb3J0X2F0dHJfcykpOworCisJcnBvcnRfYXR0ci0+cGlkID0gcnBvcnQtPnBpZDsKKwlycG9ydF9hdHRyLT5wd3duID0gcnBvcnQtPnB3d247CisJcnBvcnRfYXR0ci0+bnd3biA9IHJwb3J0LT5ud3duOworCXJwb3J0X2F0dHItPmNvc19zdXBwb3J0ZWQgPSBycG9ydC0+ZmNfY29zOworCXJwb3J0X2F0dHItPmRmX3N6ID0gcnBvcnQtPm1heGZyc2l6ZTsKKwlycG9ydF9hdHRyLT5zdGF0ZSA9IGJmYV9mY3NfcnBvcnRfZ2V0X3N0YXRlKHJwb3J0KTsKKwlycG9ydF9hdHRyLT5mY19jb3MgPSBycG9ydC0+ZmNfY29zOworCXJwb3J0X2F0dHItPmNpc2MgPSBycG9ydC0+Y2lzYzsKKwlycG9ydF9hdHRyLT5zY3NpX2Z1bmN0aW9uID0gcnBvcnQtPnNjc2lfZnVuY3Rpb247CisJcnBvcnRfYXR0ci0+Y3Vycl9zcGVlZCAgPSBycG9ydC0+cnBmLnJwc2Nfc3BlZWQ7CisJcnBvcnRfYXR0ci0+YXNzaWduZWRfc3BlZWQgID0gcnBvcnQtPnJwZi5hc3NpZ25lZF9zcGVlZDsKKworCWJmYV9ycG9ydF9nZXRfcW9zX2F0dHIocnBvcnQtPmJmYV9ycG9ydCwgJnFvc19hdHRyKTsKKwlycG9ydF9hdHRyLT5xb3NfYXR0ciA9IHFvc19hdHRyOworCisJcnBvcnRfYXR0ci0+dHJsX2VuZm9yY2VkID0gQkZBX0ZBTFNFOworCWlmIChiZmFfcHBvcnRfaXNfcmF0ZWxpbShwb3J0LT5mY3MtPmJmYSkpIHsKKwkJaWYgKChycG9ydC0+cnBmLnJwc2Nfc3BlZWQgPT0gQkZBX1BQT1JUX1NQRUVEX1VOS05PV04pIHx8CisJCQkocnBvcnQtPnJwZi5ycHNjX3NwZWVkIDwKKwkJCWJmYV9mY3NfcG9ydF9nZXRfcnBvcnRfbWF4X3NwZWVkKHBvcnQpKSkKKwkJCXJwb3J0X2F0dHItPnRybF9lbmZvcmNlZCA9IEJGQV9UUlVFOworCX0KKworCS8qCisJICogVE9ETworCSAqIHJwb3J0LT5zeW1uYW1lCisJICovCit9CisKKy8qKgorICogCVBlciByZW1vdGUgZGV2aWNlIHN0YXRpc3RpY3MuCisgKi8KK3ZvaWQKK2JmYV9mY3NfcnBvcnRfZ2V0X3N0YXRzKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0LAorCQkJc3RydWN0IGJmYV9ycG9ydF9zdGF0c19zICpzdGF0cykKK3sKKwkqc3RhdHMgPSBycG9ydC0+c3RhdHM7Cit9CisKK3ZvaWQKK2JmYV9mY3NfcnBvcnRfY2xlYXJfc3RhdHMoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpCit7CisJYmZhX29zX21lbXNldCgoY2hhciAqKSZycG9ydC0+c3RhdHMsIDAsCisJCQlzaXplb2Yoc3RydWN0IGJmYV9ycG9ydF9zdGF0c19zKSk7Cit9CisKK3N0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKgorYmZhX2Zjc19ycG9ydF9sb29rdXAoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBycHd3bikKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKworCXJwb3J0ID0gYmZhX2Zjc19wb3J0X2dldF9ycG9ydF9ieV9wd3duKHBvcnQsIHJwd3duKTsKKwlpZiAocnBvcnQgPT0gTlVMTCkgeworCQkvKgorCQkgKiBUQkQgRXJyb3IgaGFuZGxpbmcKKwkJICovCisJfQorCisJcmV0dXJuIHJwb3J0OworfQorCitzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICoKK2JmYV9mY3NfcnBvcnRfbG9va3VwX2J5X253d24oc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LCB3d25fdCBybnd3bikKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydDsKKworCXJwb3J0ID0gYmZhX2Zjc19wb3J0X2dldF9ycG9ydF9ieV9ud3duKHBvcnQsIHJud3duKTsKKwlpZiAocnBvcnQgPT0gTlVMTCkgeworCQkvKgorCQkgKiBUQkQgRXJyb3IgaGFuZGxpbmcKKwkJICovCisJfQorCisJcmV0dXJuIHJwb3J0OworfQorCisvKgorICogVGhpcyBBUEkgaXMgdG8gc2V0IHRoZSBScG9ydCdzIHNwZWVkLiBTaG91bGQgYmUgdXNlZCB3aGVuIFJQU0MgaXMgbm90CisgKiBzdXBwb3J0ZWQgYnkgdGhlIHJwb3J0LgorICovCit2b2lkCitiZmFfZmNzX3Jwb3J0X3NldF9zcGVlZChzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCwKKwkJCWVudW0gYmZhX3Bwb3J0X3NwZWVkIHNwZWVkKQoreworCXJwb3J0LT5ycGYuYXNzaWduZWRfc3BlZWQgID0gc3BlZWQ7CisKKwkvKiBTZXQgdGhpcyBzcGVlZCBpbiBmL3cgb25seSBpZiB0aGUgUlBTQyBzcGVlZCBpcyBub3QgYXZhaWxhYmxlICovCisJaWYgKHJwb3J0LT5ycGYucnBzY19zcGVlZCA9PSBCRkFfUFBPUlRfU1BFRURfVU5LTk9XTikKKwkJYmZhX3Jwb3J0X3NwZWVkKHJwb3J0LT5iZmFfcnBvcnQsIHNwZWVkKTsKK30KKworCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvYmZhL3Jwb3J0X2Z0cnMuYyBiL2RyaXZlcnMvc2NzaS9iZmEvcnBvcnRfZnRycy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhhMWY1OWQKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL3Jwb3J0X2Z0cnMuYwpAQCAtMCwwICsxLDM3NSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAwNS0yMDA5IEJyb2NhZGUgQ29tbXVuaWNhdGlvbnMgU3lzdGVtcywgSW5jLgorICogQWxsIHJpZ2h0cyByZXNlcnZlZAorICogd3d3LmJyb2NhZGUuY29tCisgKgorICogTGludXggZHJpdmVyIGZvciBCcm9jYWRlIEZpYnJlIENoYW5uZWwgSG9zdCBCdXMgQWRhcHRlci4KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAorICogdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAoR1BMKSBWZXJzaW9uIDIgYXMKKyAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAorICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKKyAqIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KKyAqLworCisvKioKKyAqICBycG9ydF9mdHJzLmMgUmVtb3RlIHBvcnQgZmVhdHVyZXMgKFJQRikgaW1wbGVtZW50YXRpb24uCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlICJmY2J1aWxkLmgiCisjaW5jbHVkZSAiZmNzX3Jwb3J0LmgiCisjaW5jbHVkZSAiZmNzX2xwb3J0LmgiCisjaW5jbHVkZSAiZmNzX3RyY21vZC5oIgorI2luY2x1ZGUgImZjc19mY3hwLmgiCisjaW5jbHVkZSAiZmNzLmgiCisKK0JGQV9UUkNfRklMRShGQ1MsIFJQT1JUX0ZUUlMpOworCisjZGVmaW5lIEJGQV9GQ1NfUlBGX1JFVFJJRVMJKDMpCisjZGVmaW5lIEJGQV9GQ1NfUlBGX1JFVFJZX1RJTUVPVVQgICgxMDAwKSAvKiAxIHNlYyAoSW4gbWlsbGlzZWNzKSAqLworCitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycGZfc2VuZF9ycHNjMih2b2lkICpycG9ydF9jYmFyZywKKwkJCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcnBmX3Jwc2MyX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywKKwkJCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCB2b2lkICpjYmFyZywKKwkJCWJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLCB1MzIgcnNwX2xlbiwKKwkJCXUzMiByZXNpZF9sZW4sCisJCQlzdHJ1Y3QgZmNoc19zICpyc3BfZmNocyk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycGZfdGltZW91dCh2b2lkICphcmcpOworCisvKioKKyAqICBmY3NfcnBvcnRfZnRyc19zbSBGQ1MgcnBvcnQgc3RhdGUgbWFjaGluZSBldmVudHMKKyAqLworCitlbnVtIHJwZl9ldmVudCB7CisJUlBGU01fRVZFTlRfUlBPUlRfT0ZGTElORSAgPSAxLCAgICAgLyogIFJwb3J0IG9mZmxpbmUgICAgICAgICAgICAqLworCVJQRlNNX0VWRU5UX1JQT1JUX09OTElORSAgID0gMiwgICAgIC8qICBScG9ydCBvbmxpbmUgICAgICAgICAgICAqLworCVJQRlNNX0VWRU5UX0ZDWFBfU0VOVCAgICAgID0gMywgICAgLyogIEZyYW1lIGZyb20gaGFzIGJlZW4gc2VudCAqLworCVJQRlNNX0VWRU5UX1RJTUVPVVQgIAkgICA9IDQsICAgIC8qICBScG9ydCBTTSB0aW1lb3V0IGV2ZW50ICAgKi8KKwlSUEZTTV9FVkVOVF9SUFNDX0NPTVAgICAgICA9IDUsCisJUlBGU01fRVZFTlRfUlBTQ19GQUlMICAgICAgPSA2LAorCVJQRlNNX0VWRU5UX1JQU0NfRVJST1IgICAgID0gNywKK307CisKK3N0YXRpYyB2b2lkCWJmYV9mY3NfcnBmX3NtX3VuaW5pdChzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqcnBmLAorCQkJCQllbnVtIHJwZl9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycGZfc21fcnBzY19zZW5kaW5nKHN0cnVjdCBiZmFfZmNzX3JwZl9zICpycGYsCisJCQkJCSAgICAgICBlbnVtIHJwZl9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycGZfc21fcnBzYyhzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqcnBmLAorCQkJCQkgICAgICAgZW51bSBycGZfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgCWJmYV9mY3NfcnBmX3NtX3Jwc2NfcmV0cnkoc3RydWN0IGJmYV9mY3NfcnBmX3MgKnJwZiwKKwkJCQkJCQllbnVtIHJwZl9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19ycGZfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqcnBmLAorCQkJCQkJCWVudW0gcnBmX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3JwZl9zbV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcnBmX3MgKnJwZiwKKwkJCQkJCQllbnVtIHJwZl9ldmVudCBldmVudCk7CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3JwZl9zbV91bmluaXQoc3RydWN0IGJmYV9mY3NfcnBmX3MgKnJwZiwgZW51bSBycGZfZXZlbnQgZXZlbnQpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSBycGYtPnJwb3J0OworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFJQRlNNX0VWRU5UX1JQT1JUX09OTElORSA6CisJCWlmICghQkZBX0ZDU19QSURfSVNfV0tBKHJwb3J0LT5waWQpKSB7CisJCQliZmFfc21fc2V0X3N0YXRlKHJwZiwgYmZhX2Zjc19ycGZfc21fcnBzY19zZW5kaW5nKTsKKwkJCXJwZi0+cnBzY19yZXRyaWVzID0gMDsKKwkJCWJmYV9mY3NfcnBmX3NlbmRfcnBzYzIocnBmLCBOVUxMKTsKKwkJCWJyZWFrOworCQl9OworCisJY2FzZSBSUEZTTV9FVkVOVF9SUE9SVF9PRkZMSU5FIDoKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcnBmX3NtX3Jwc2Nfc2VuZGluZyhzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqcnBmLCBlbnVtIHJwZl9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IHJwZi0+cnBvcnQ7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFJQRlNNX0VWRU5UX0ZDWFBfU0VOVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycGYsIGJmYV9mY3NfcnBmX3NtX3Jwc2MpOworCQlicmVhazsKKworCWNhc2UgUlBGU01fRVZFTlRfUlBPUlRfT0ZGTElORSA6CisJCWJmYV9zbV9zZXRfc3RhdGUocnBmLCBiZmFfZmNzX3JwZl9zbV9vZmZsaW5lKTsKKwkJYmZhX2ZjeHBfd2FsbG9jX2NhbmNlbChycG9ydC0+ZmNzLT5iZmEsICZycGYtPmZjeHBfd3FlKTsKKwkJcnBmLT5ycHNjX3JldHJpZXMgPSAwOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycGZfc21fcnBzYyhzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqcnBmLCBlbnVtIHJwZl9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IHJwZi0+cnBvcnQ7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBGU01fRVZFTlRfUlBTQ19DT01QOgorCQliZmFfc21fc2V0X3N0YXRlKHJwZiwgYmZhX2Zjc19ycGZfc21fb25saW5lKTsKKwkJLyogVXBkYXRlIHNwZWVkIGluZm8gaW4gZi93IHZpYSBCRkEgKi8KKwkJaWYgKHJwZi0+cnBzY19zcGVlZCAhPSBCRkFfUFBPUlRfU1BFRURfVU5LTk9XTikgeworCQkJYmZhX3Jwb3J0X3NwZWVkKHJwb3J0LT5iZmFfcnBvcnQsIHJwZi0+cnBzY19zcGVlZCk7CisJCX0gZWxzZSBpZiAocnBmLT5hc3NpZ25lZF9zcGVlZCAhPSBCRkFfUFBPUlRfU1BFRURfVU5LTk9XTikgeworCQkJYmZhX3Jwb3J0X3NwZWVkKHJwb3J0LT5iZmFfcnBvcnQsIHJwZi0+YXNzaWduZWRfc3BlZWQpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBSUEZTTV9FVkVOVF9SUFNDX0ZBSUw6CisJCS8qIFJQU0Mgbm90IHN1cHBvcnRlZCBieSBycG9ydCAqLworCQliZmFfc21fc2V0X3N0YXRlKHJwZiwgYmZhX2Zjc19ycGZfc21fb25saW5lKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQRlNNX0VWRU5UX1JQU0NfRVJST1I6CisJCS8qIG5lZWQgdG8gcmV0cnkuLi5kZWxheWVkIGEgYml0LiAqLworCQlpZiAocnBmLT5ycHNjX3JldHJpZXMrKyA8IEJGQV9GQ1NfUlBGX1JFVFJJRVMpIHsKKwkJCWJmYV90aW1lcl9zdGFydChycG9ydC0+ZmNzLT5iZmEsICZycGYtPnRpbWVyLAorCQkJCSAgICBiZmFfZmNzX3JwZl90aW1lb3V0LCBycGYsCisJCQkJICAgIEJGQV9GQ1NfUlBGX1JFVFJZX1RJTUVPVVQpOworCQkJYmZhX3NtX3NldF9zdGF0ZShycGYsIGJmYV9mY3NfcnBmX3NtX3Jwc2NfcmV0cnkpOworCQl9IGVsc2UgeworCQkJYmZhX3NtX3NldF9zdGF0ZShycGYsIGJmYV9mY3NfcnBmX3NtX29ubGluZSk7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIFJQRlNNX0VWRU5UX1JQT1JUX09GRkxJTkUgOgorCQliZmFfc21fc2V0X3N0YXRlKHJwZiwgYmZhX2Zjc19ycGZfc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX2Rpc2NhcmQocnBmLT5mY3hwKTsKKwkJcnBmLT5ycHNjX3JldHJpZXMgPSAwOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycGZfc21fcnBzY19yZXRyeShzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqcnBmLCBlbnVtIHJwZl9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IHJwZi0+cnBvcnQ7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJwb3J0LT5waWQpOworCWJmYV90cmMocnBvcnQtPmZjcywgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgUlBGU01fRVZFTlRfVElNRU9VVCA6CisJCS8qIHJlLXNlbmQgdGhlIFJQU0MgKi8KKwkJYmZhX3NtX3NldF9zdGF0ZShycGYsIGJmYV9mY3NfcnBmX3NtX3Jwc2Nfc2VuZGluZyk7CisJCWJmYV9mY3NfcnBmX3NlbmRfcnBzYzIocnBmLCBOVUxMKTsKKwkJYnJlYWs7CisKKwljYXNlIFJQRlNNX0VWRU5UX1JQT1JUX09GRkxJTkUgOgorCQliZmFfdGltZXJfc3RvcCgmcnBmLT50aW1lcik7CisJCWJmYV9zbV9zZXRfc3RhdGUocnBmLCBiZmFfZmNzX3JwZl9zbV9vZmZsaW5lKTsKKwkJcnBmLT5ycHNjX3JldHJpZXMgPSAwOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycGZfc21fb25saW5lKHN0cnVjdCBiZmFfZmNzX3JwZl9zICpycGYsIGVudW0gcnBmX2V2ZW50IGV2ZW50KQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gcnBmLT5ycG9ydDsKKworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBSUEZTTV9FVkVOVF9SUE9SVF9PRkZMSU5FIDoKKwkJYmZhX3NtX3NldF9zdGF0ZShycGYsIGJmYV9mY3NfcnBmX3NtX29mZmxpbmUpOworCQlycGYtPnJwc2NfcmV0cmllcyA9IDA7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3JwZl9zbV9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3JwZl9zICpycGYsIGVudW0gcnBmX2V2ZW50IGV2ZW50KQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0ID0gcnBmLT5ycG9ydDsKKworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnB3d24pOworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBSUEZTTV9FVkVOVF9SUE9SVF9PTkxJTkUgOgorCQliZmFfc21fc2V0X3N0YXRlKHJwZiwgYmZhX2Zjc19ycGZfc21fcnBzY19zZW5kaW5nKTsKKwkJYmZhX2Zjc19ycGZfc2VuZF9ycHNjMihycGYsIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgUlBGU01fRVZFTlRfUlBPUlRfT0ZGTElORSA6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisvKioKKyAqIENhbGxlZCB3aGVuIFJwb3J0IGlzIGNyZWF0ZWQuCisgKi8KK3ZvaWQgIGJmYV9mY3NfcnBmX2luaXQoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpCit7CisJc3RydWN0IGJmYV9mY3NfcnBmX3MgKnJwZiA9ICZycG9ydC0+cnBmOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwlycGYtPnJwb3J0ID0gcnBvcnQ7CisKKwliZmFfc21fc2V0X3N0YXRlKHJwZiwgYmZhX2Zjc19ycGZfc21fdW5pbml0KTsKK30KKworLyoqCisgKiBDYWxsZWQgd2hlbiBScG9ydCBiZWNvbWVzIG9ubGluZQorICovCit2b2lkICBiZmFfZmNzX3JwZl9ycG9ydF9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQpCit7CisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKworCWlmIChfX2Zjc19taW5fY2ZnKHJwb3J0LT5wb3J0LT5mY3MpKQorCQlyZXR1cm47CisKKwlpZiAoYmZhX2Zjc19mYWJyaWNfaXNfc3dpdGNoZWQocnBvcnQtPnBvcnQtPmZhYnJpYykpCisJCWJmYV9zbV9zZW5kX2V2ZW50KCZycG9ydC0+cnBmLCBSUEZTTV9FVkVOVF9SUE9SVF9PTkxJTkUpOworfQorCisvKioKKyAqIENhbGxlZCB3aGVuIFJwb3J0IGJlY29tZXMgb2ZmbGluZQorICovCit2b2lkICBiZmFfZmNzX3JwZl9ycG9ydF9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0KQoreworCWJmYV90cmMocnBvcnQtPmZjcywgcnBvcnQtPnBpZCk7CisKKwlpZiAoX19mY3NfbWluX2NmZyhycG9ydC0+cG9ydC0+ZmNzKSkKKwkJcmV0dXJuOworCisJYmZhX3NtX3NlbmRfZXZlbnQoJnJwb3J0LT5ycGYsIFJQRlNNX0VWRU5UX1JQT1JUX09GRkxJTkUpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycGZfdGltZW91dCh2b2lkICphcmcpCit7CisJc3RydWN0IGJmYV9mY3NfcnBmX3MgKnJwZiA9IChzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqKSBhcmc7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSBycGYtPnJwb3J0OworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cGlkKTsKKwliZmFfc21fc2VuZF9ldmVudChycGYsIFJQRlNNX0VWRU5UX1RJTUVPVVQpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19ycGZfc2VuZF9ycHNjMih2b2lkICpycGZfY2JhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwX2FsbG9jZWQpCit7CisJc3RydWN0IGJmYV9mY3NfcnBmX3MgKnJwZiAJPSAoc3RydWN0IGJmYV9mY3NfcnBmX3MgKilycGZfY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQgPSBycGYtPnJwb3J0OworCXN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCA9IHJwb3J0LT5wb3J0OworCXN0cnVjdCBmY2hzX3MgICAgICAgICAgZmNoczsKKwlpbnQgICAgICAgICAgICAgbGVuOworCXN0cnVjdCBiZmFfZmN4cF9zICpmY3hwOworCisJYmZhX3RyYyhycG9ydC0+ZmNzLCBycG9ydC0+cHd3bik7CisKKwlmY3hwID0gZmN4cF9hbGxvY2VkID8gZmN4cF9hbGxvY2VkIDogYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKSB7CisJCWJmYV9mY3hwX2FsbG9jX3dhaXQocG9ydC0+ZmNzLT5iZmEsICZycGYtPmZjeHBfd3FlLAorCQkJCQliZmFfZmNzX3JwZl9zZW5kX3Jwc2MyLCBycGYpOworCQlyZXR1cm47CisJfQorCXJwZi0+ZmN4cCA9IGZjeHA7CisKKwlsZW4gPSBmY19ycHNjMl9idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgcnBvcnQtPnBpZCwKKwkJCSAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksICZycG9ydC0+cGlkLCAxKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgTlVMTCwgcG9ydC0+ZmFicmljLT52Zl9pZCwgcG9ydC0+bHBfdGFnLCBCRkFfRkFMU0UsCisJCQkgIEZDX0NMQVNTXzMsIGxlbiwgJmZjaHMsIGJmYV9mY3NfcnBmX3Jwc2MyX3Jlc3BvbnNlLAorCQkJICBycGYsIEZDX01BWF9QRFVTWiwgRkNfUkFfVE9WKTsKKwlycG9ydC0+c3RhdHMucnBzY19zZW50Kys7CisJYmZhX3NtX3NlbmRfZXZlbnQocnBmLCBSUEZTTV9FVkVOVF9GQ1hQX1NFTlQpOworCit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3JwZl9ycHNjMl9yZXNwb25zZSh2b2lkICpmY3NhcmcsIHN0cnVjdCBiZmFfZmN4cF9zICpmY3hwLCB2b2lkICpjYmFyZywKKwkJCSAgICBiZmFfc3RhdHVzX3QgcmVxX3N0YXR1cywgdTMyIHJzcF9sZW4sCisJCQkgICAgdTMyIHJlc2lkX2xlbiwgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpCit7CisJc3RydWN0IGJmYV9mY3NfcnBmX3MgKnJwZiA9IChzdHJ1Y3QgYmZhX2Zjc19ycGZfcyAqKSBjYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19ycG9ydF9zICpycG9ydCA9IHJwZi0+cnBvcnQ7CisJc3RydWN0IGZjX2xzX3JqdF9zICAgICpsc19yanQ7CisJc3RydWN0IGZjX3Jwc2MyX2FjY19zICAqcnBzYzJfYWNjOworCXUxNiAgICAgICAgbnVtX2VudHM7CisKKwliZmFfdHJjKHJwb3J0LT5mY3MsIHJlcV9zdGF0dXMpOworCisJaWYgKHJlcV9zdGF0dXMgIT0gQkZBX1NUQVRVU19PSykgeworCQliZmFfdHJjKHJwb3J0LT5mY3MsIHJlcV9zdGF0dXMpOworCQlpZiAocmVxX3N0YXR1cyA9PSBCRkFfU1RBVFVTX0VUSU1FUikKKwkJCXJwb3J0LT5zdGF0cy5ycHNjX2ZhaWxlZCsrOworCQliZmFfc21fc2VuZF9ldmVudChycGYsIFJQRlNNX0VWRU5UX1JQU0NfRVJST1IpOworCQlyZXR1cm47CisJfQorCisJcnBzYzJfYWNjID0gKHN0cnVjdCBmY19ycHNjMl9hY2NfcyAqKSBCRkFfRkNYUF9SU1BfUExEKGZjeHApOworCWlmIChycHNjMl9hY2MtPmVsc19jbWQgPT0gRkNfRUxTX0FDQykgeworCQlycG9ydC0+c3RhdHMucnBzY19hY2NzKys7CisJCW51bV9lbnRzID0gYmZhX29zX250b2hzKHJwc2MyX2FjYy0+bnVtX3BpZHMpOworCQliZmFfdHJjKHJwb3J0LT5mY3MsIG51bV9lbnRzKTsKKwkJaWYgKG51bV9lbnRzID4gMCkgeworCQkJYmZhX2Fzc2VydChycHNjMl9hY2MtPnBvcnRfaW5mb1swXS5waWQgIT0gcnBvcnQtPnBpZCk7CisJCQliZmFfdHJjKHJwb3J0LT5mY3MsCisJCQkJYmZhX29zX250b2hzKHJwc2MyX2FjYy0+cG9ydF9pbmZvWzBdLnBpZCkpOworCQkJYmZhX3RyYyhycG9ydC0+ZmNzLAorCQkJCWJmYV9vc19udG9ocyhycHNjMl9hY2MtPnBvcnRfaW5mb1swXS5zcGVlZCkpOworCQkJYmZhX3RyYyhycG9ydC0+ZmNzLAorCQkJCWJmYV9vc19udG9ocyhycHNjMl9hY2MtPnBvcnRfaW5mb1swXS5pbmRleCkpOworCQkJYmZhX3RyYyhycG9ydC0+ZmNzLAorCQkJCXJwc2MyX2FjYy0+cG9ydF9pbmZvWzBdLnR5cGUpOworCisJCQlpZiAocnBzYzJfYWNjLT5wb3J0X2luZm9bMF0uc3BlZWQgPT0gMCkgeworCQkJCWJmYV9zbV9zZW5kX2V2ZW50KHJwZiwgUlBGU01fRVZFTlRfUlBTQ19FUlJPUik7CisJCQkJcmV0dXJuOworCQkJfQorCisJCQlycGYtPnJwc2Nfc3BlZWQgPSBmY19ycHNjX29wZXJzcGVlZF90b19iZmFfc3BlZWQoCisJCQkJYmZhX29zX250b2hzKHJwc2MyX2FjYy0+cG9ydF9pbmZvWzBdLnNwZWVkKSk7CisKKwkJCWJmYV9zbV9zZW5kX2V2ZW50KHJwZiwgUlBGU01fRVZFTlRfUlBTQ19DT01QKTsKKwkJfQorCX0gZWxzZSB7CisJCWxzX3JqdCA9IChzdHJ1Y3QgZmNfbHNfcmp0X3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKwkJYmZhX3RyYyhycG9ydC0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlKTsKKwkJYmZhX3RyYyhycG9ydC0+ZmNzLCBsc19yanQtPnJlYXNvbl9jb2RlX2V4cGwpOworCQlycG9ydC0+c3RhdHMucnBzY19yZWplY3RzKys7CisJCWlmIChsc19yanQtPnJlYXNvbl9jb2RlID09IEZDX0xTX1JKVF9SU05fQ01EX05PVF9TVVBQKSB7CisJCQliZmFfc21fc2VuZF9ldmVudChycGYsIFJQRlNNX0VWRU5UX1JQU0NfRkFJTCk7CisJCX0gZWxzZSB7CisJCQliZmFfc21fc2VuZF9ldmVudChycGYsIFJQRlNNX0VWRU5UX1JQU0NfRVJST1IpOworCQl9CisJfQorfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS9zY24uYyBiL2RyaXZlcnMvc2NzaS9iZmEvc2NuLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYmQ0NzcxZgotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvc2NzaS9iZmEvc2NuLmMKQEAgLTAsMCArMSw0ODIgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworI2luY2x1ZGUgPGJmYS5oPgorI2luY2x1ZGUgPGJmYV9zdmMuaD4KKyNpbmNsdWRlICJmY3NfbHBvcnQuaCIKKyNpbmNsdWRlICJmY3NfcnBvcnQuaCIKKyNpbmNsdWRlICJmY3NfbXMuaCIKKyNpbmNsdWRlICJmY3NfdHJjbW9kLmgiCisjaW5jbHVkZSAiZmNzX2ZjeHAuaCIKKyNpbmNsdWRlICJmY3MuaCIKKyNpbmNsdWRlICJscG9ydF9wcml2LmgiCisKK0JGQV9UUkNfRklMRShGQ1MsIFNDTik7CisKKyNkZWZpbmUgRkNfUU9TX1JTQ05fRVZFTlQJCTB4MGMKKyNkZWZpbmUgRkNfRkFCUklDX05BTUVfUlNDTl9FVkVOVAkweDBkCisKKy8qCisgKiBmb3J3YXJkIGRlY2xhcmF0aW9ucworICovCitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X3Njbl9zZW5kX3Njcih2b2lkICpzY25fY2JhcmcsCisJCQkJCSAgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHBfYWxsb2NlZCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X3Njbl9zY3JfcmVzcG9uc2Uodm9pZCAqZmNzYXJnLAorCQkJCQkgICAgICBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cCwKKwkJCQkJICAgICAgdm9pZCAqY2JhcmcsCisJCQkJCSAgICAgIGJmYV9zdGF0dXNfdCByZXFfc3RhdHVzLAorCQkJCQkgICAgICB1MzIgcnNwX2xlbiwKKwkJCQkJICAgICAgdTMyIHJlc2lkX2xlbiwKKwkJCQkJICAgICAgc3RydWN0IGZjaHNfcyAqcnNwX2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9zY25fc2VuZF9sc19hY2Moc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJCQkgICAgIHN0cnVjdCBmY2hzX3MgKnJ4X2ZjaHMpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9zY25fdGltZW91dCh2b2lkICphcmcpOworCisvKioKKyAqICBmY3Nfc2NtX3NtIEZDUyBTQ04gc3RhdGUgbWFjaGluZQorICovCisKKy8qKgorICogVlBvcnQgU0NOIFN0YXRlIE1hY2hpbmUgZXZlbnRzCisgKi8KK2VudW0gcG9ydF9zY25fZXZlbnQgeworCVNDTlNNX0VWRU5UX1BPUlRfT05MSU5FID0gMSwKKwlTQ05TTV9FVkVOVF9QT1JUX09GRkxJTkUgPSAyLAorCVNDTlNNX0VWRU5UX1JTUF9PSyA9IDMsCisJU0NOU01fRVZFTlRfUlNQX0VSUk9SID0gNCwKKwlTQ05TTV9FVkVOVF9USU1FT1VUID0gNSwKKwlTQ05TTV9FVkVOVF9TQ1JfU0VOVCA9IDYsCit9OworCitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X3Njbl9zbV9vZmZsaW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiwKKwkJCQkJICAgIGVudW0gcG9ydF9zY25fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9zY25fc21fc2VuZGluZ19zY3Ioc3RydWN0IGJmYV9mY3NfcG9ydF9zY25fcyAqc2NuLAorCQkJCQkJZW51bSBwb3J0X3Njbl9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc19wb3J0X3Njbl9zbV9zY3Ioc3RydWN0IGJmYV9mY3NfcG9ydF9zY25fcyAqc2NuLAorCQkJCQllbnVtIHBvcnRfc2NuX2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3BvcnRfc2NuX3NtX3Njcl9yZXRyeShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3Njbl9zICpzY24sCisJCQkJCSAgICAgIGVudW0gcG9ydF9zY25fZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfcG9ydF9zY25fc21fb25saW5lKHN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiwKKwkJCQkJICAgZW51bSBwb3J0X3Njbl9ldmVudCBldmVudCk7CisKKy8qKgorICogCQlTdGFydGluZyBzdGF0ZSAtIGF3YWl0aW5nIGxpbmsgdXAuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc2NuX3NtX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zY25fcyAqc2NuLAorCQkJICAgIGVudW0gcG9ydF9zY25fZXZlbnQgZXZlbnQpCit7CisJc3dpdGNoIChldmVudCkgeworCWNhc2UgU0NOU01fRVZFTlRfUE9SVF9PTkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoc2NuLCBiZmFfZmNzX3BvcnRfc2NuX3NtX3NlbmRpbmdfc2NyKTsKKwkJYmZhX2Zjc19wb3J0X3Njbl9zZW5kX3NjcihzY24sIE5VTEwpOworCQlicmVhazsKKworCWNhc2UgU0NOU01fRVZFTlRfUE9SVF9PRkZMSU5FOgorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X3Njbl9zbV9zZW5kaW5nX3NjcihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3Njbl9zICpzY24sCisJCQkJZW51bSBwb3J0X3Njbl9ldmVudCBldmVudCkKK3sKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBTQ05TTV9FVkVOVF9TQ1JfU0VOVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShzY24sIGJmYV9mY3NfcG9ydF9zY25fc21fc2NyKTsKKwkJYnJlYWs7CisKKwljYXNlIFNDTlNNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShzY24sIGJmYV9mY3NfcG9ydF9zY25fc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX3dhbGxvY19jYW5jZWwoc2NuLT5wb3J0LT5mY3MtPmJmYSwgJnNjbi0+ZmN4cF93cWUpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X3Njbl9zbV9zY3Ioc3RydWN0IGJmYV9mY3NfcG9ydF9zY25fcyAqc2NuLAorCQkJZW51bSBwb3J0X3Njbl9ldmVudCBldmVudCkKK3sKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBzY24tPnBvcnQ7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBTQ05TTV9FVkVOVF9SU1BfT0s6CisJCWJmYV9zbV9zZXRfc3RhdGUoc2NuLCBiZmFfZmNzX3BvcnRfc2NuX3NtX29ubGluZSk7CisJCWJyZWFrOworCisJY2FzZSBTQ05TTV9FVkVOVF9SU1BfRVJST1I6CisJCWJmYV9zbV9zZXRfc3RhdGUoc2NuLCBiZmFfZmNzX3BvcnRfc2NuX3NtX3Njcl9yZXRyeSk7CisJCWJmYV90aW1lcl9zdGFydChwb3J0LT5mY3MtPmJmYSwgJnNjbi0+dGltZXIsCisJCQkJYmZhX2Zjc19wb3J0X3Njbl90aW1lb3V0LCBzY24sCisJCQkJQkZBX0ZDU19SRVRSWV9USU1FT1VUKTsKKwkJYnJlYWs7CisKKwljYXNlIFNDTlNNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShzY24sIGJmYV9mY3NfcG9ydF9zY25fc21fb2ZmbGluZSk7CisJCWJmYV9mY3hwX2Rpc2NhcmQoc2NuLT5mY3hwKTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9zY25fc21fc2NyX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiwKKwkJCSAgICAgIGVudW0gcG9ydF9zY25fZXZlbnQgZXZlbnQpCit7CisJc3dpdGNoIChldmVudCkgeworCWNhc2UgU0NOU01fRVZFTlRfVElNRU9VVDoKKwkJYmZhX3NtX3NldF9zdGF0ZShzY24sIGJmYV9mY3NfcG9ydF9zY25fc21fc2VuZGluZ19zY3IpOworCQliZmFfZmNzX3BvcnRfc2NuX3NlbmRfc2NyKHNjbiwgTlVMTCk7CisJCWJyZWFrOworCisJY2FzZSBTQ05TTV9FVkVOVF9QT1JUX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUoc2NuLCBiZmFfZmNzX3BvcnRfc2NuX3NtX29mZmxpbmUpOworCQliZmFfdGltZXJfc3RvcCgmc2NuLT50aW1lcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc2NuX3NtX29ubGluZShzdHJ1Y3QgYmZhX2Zjc19wb3J0X3Njbl9zICpzY24sCisJCQkgICBlbnVtIHBvcnRfc2NuX2V2ZW50IGV2ZW50KQoreworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIFNDTlNNX0VWRU5UX1BPUlRfT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZShzY24sIGJmYV9mY3NfcG9ydF9zY25fc21fb2ZmbGluZSk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBmY3Nfc2NuX3ByaXZhdGUgRkNTIFNDTiBwcml2YXRlIGZ1bmN0aW9ucworICovCisKKy8qKgorICogVGhpcyByb3V0aW5lIHdpbGwgYmUgY2FsbGVkIHRvIHNlbmQgYSBTQ1IgY29tbWFuZC4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9zY25fc2VuZF9zY3Iodm9pZCAqc2NuX2NiYXJnLCBzdHJ1Y3QgYmZhX2ZjeHBfcyAqZmN4cF9hbGxvY2VkKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiA9IHNjbl9jYmFyZzsKKwlzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQgPSBzY24tPnBvcnQ7CisJc3RydWN0IGZjaHNfcyAgICAgICAgICBmY2hzOworCWludCAgICAgICAgICAgICBsZW47CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cGlkKTsKKwliZmFfdHJjKHBvcnQtPmZjcywgcG9ydC0+cG9ydF9jZmcucHd3bik7CisKKwlmY3hwID0gZmN4cF9hbGxvY2VkID8gZmN4cF9hbGxvY2VkIDogYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKSB7CisJCWJmYV9mY3hwX2FsbG9jX3dhaXQocG9ydC0+ZmNzLT5iZmEsICZzY24tPmZjeHBfd3FlLAorCQkJCSAgICBiZmFfZmNzX3BvcnRfc2NuX3NlbmRfc2NyLCBzY24pOworCQlyZXR1cm47CisJfQorCXNjbi0+ZmN4cCA9IGZjeHA7CisKKwkvKgorCSAqIEhhbmRsZSBWVSByZWdpc3RyYXRpb25zIGZvciBCYXNlIHBvcnQgb25seQorCSAqLworCWlmICgoIXBvcnQtPnZwb3J0KSAmJiBiZmFfaW9jX2dldF9mY21vZGUoJnBvcnQtPmZjcy0+YmZhLT5pb2MpKSB7CisJCWxlbiA9IGZjX3Njcl9idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwKKwkJCQkgICBiZmFfbHBzX2lzX2JyY2RfZmFicmljKHBvcnQtPmZhYnJpYy0+bHBzKSwKKwkJCQkgICBwb3J0LT5waWQsIDApOworCX0gZWxzZSB7CisJCWxlbiA9IGZjX3Njcl9idWlsZCgmZmNocywgYmZhX2ZjeHBfZ2V0X3JlcWJ1ZihmY3hwKSwgQkZBX0ZBTFNFLAorCQkJCSAgIHBvcnQtPnBpZCwgMCk7CisJfQorCisJYmZhX2ZjeHBfc2VuZChmY3hwLCBOVUxMLCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsIEJGQV9GQUxTRSwKKwkJICAgICAgRkNfQ0xBU1NfMywgbGVuLCAmZmNocywgYmZhX2Zjc19wb3J0X3Njbl9zY3JfcmVzcG9uc2UsCisJCSAgICAgICh2b2lkICopc2NuLCBGQ19NQVhfUERVU1osIEZDX1JBX1RPVik7CisKKwliZmFfc21fc2VuZF9ldmVudChzY24sIFNDTlNNX0VWRU5UX1NDUl9TRU5UKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9zY25fc2NyX3Jlc3BvbnNlKHZvaWQgKmZjc2FyZywgc3RydWN0IGJmYV9mY3hwX3MgKmZjeHAsCisJCQkgICAgICB2b2lkICpjYmFyZywgYmZhX3N0YXR1c190IHJlcV9zdGF0dXMsCisJCQkgICAgICB1MzIgcnNwX2xlbiwgdTMyIHJlc2lkX2xlbiwKKwkJCSAgICAgIHN0cnVjdCBmY2hzX3MgKnJzcF9mY2hzKQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiA9IChzdHJ1Y3QgYmZhX2Zjc19wb3J0X3Njbl9zICopY2Jhcmc7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0ID0gc2NuLT5wb3J0OworCXN0cnVjdCBmY19lbHNfY21kX3MgICAqZWxzX2NtZDsKKwlzdHJ1Y3QgZmNfbHNfcmp0X3MgICAgKmxzX3JqdDsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBwb3J0LT5wb3J0X2NmZy5wd3duKTsKKworCS8qCisJICogU2FuaXR5IENoZWNrcworCSAqLworCWlmIChyZXFfc3RhdHVzICE9IEJGQV9TVEFUVVNfT0spIHsKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIHJlcV9zdGF0dXMpOworCQliZmFfc21fc2VuZF9ldmVudChzY24sIFNDTlNNX0VWRU5UX1JTUF9FUlJPUik7CisJCXJldHVybjsKKwl9CisKKwllbHNfY21kID0gKHN0cnVjdCBmY19lbHNfY21kX3MgKikgQkZBX0ZDWFBfUlNQX1BMRChmY3hwKTsKKworCXN3aXRjaCAoZWxzX2NtZC0+ZWxzX2NvZGUpIHsKKworCWNhc2UgRkNfRUxTX0FDQzoKKwkJYmZhX3NtX3NlbmRfZXZlbnQoc2NuLCBTQ05TTV9FVkVOVF9SU1BfT0spOworCQlicmVhazsKKworCWNhc2UgRkNfRUxTX0xTX1JKVDoKKworCQlsc19yanQgPSAoc3RydWN0IGZjX2xzX3JqdF9zICopIEJGQV9GQ1hQX1JTUF9QTEQoZmN4cCk7CisKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIGxzX3JqdC0+cmVhc29uX2NvZGUpOworCQliZmFfdHJjKHBvcnQtPmZjcywgbHNfcmp0LT5yZWFzb25fY29kZV9leHBsKTsKKworCQliZmFfc21fc2VuZF9ldmVudChzY24sIFNDTlNNX0VWRU5UX1JTUF9FUlJPUik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX3NtX3NlbmRfZXZlbnQoc2NuLCBTQ05TTV9FVkVOVF9SU1BfRVJST1IpOworCX0KK30KKworLyoKKyAqIFNlbmQgYSBMUyBBY2NlcHQKKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9zY25fc2VuZF9sc19hY2Moc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0LAorCQkJc3RydWN0IGZjaHNfcyAqcnhfZmNocykKK3sKKwlzdHJ1Y3QgZmNoc19zICAgICAgICAgIGZjaHM7CisJc3RydWN0IGJmYV9mY3hwX3MgKmZjeHA7CisJc3RydWN0IGJmYV9ycG9ydF9zICpiZmFfcnBvcnQgPSBOVUxMOworCWludCAgICAgICAgICAgICBsZW47CisKKwliZmFfdHJjKHBvcnQtPmZjcywgcnhfZmNocy0+c19pZCk7CisKKwlmY3hwID0gYmZhX2Zjc19mY3hwX2FsbG9jKHBvcnQtPmZjcyk7CisJaWYgKCFmY3hwKQorCQlyZXR1cm47CisKKwlsZW4gPSBmY19sc19hY2NfYnVpbGQoJmZjaHMsIGJmYV9mY3hwX2dldF9yZXFidWYoZmN4cCksIHJ4X2ZjaHMtPnNfaWQsCisJCQkgICAgICBiZmFfZmNzX3BvcnRfZ2V0X2ZjaWQocG9ydCksIHJ4X2ZjaHMtPm94X2lkKTsKKworCWJmYV9mY3hwX3NlbmQoZmN4cCwgYmZhX3Jwb3J0LCBwb3J0LT5mYWJyaWMtPnZmX2lkLCBwb3J0LT5scF90YWcsCisJCSAgICAgIEJGQV9GQUxTRSwgRkNfQ0xBU1NfMywgbGVuLCAmZmNocywgTlVMTCwgTlVMTCwKKwkJICAgICAgRkNfTUFYX1BEVVNaLCAwKTsKK30KKworLyoqCisgKiAgICAgVGhpcyByb3V0aW5lIHdpbGwgYmUgY2FsbGVkIGJ5IGJmYV90aW1lciBvbiB0aW1lciB0aW1lb3V0cy4KKyAqCisgKiAJcGFyYW1baW5dIAl2cG9ydCAJCQktIHBvaW50ZXIgdG8gYmZhX2Zjc19wb3J0X3QuCisgKiAJcGFyYW1bb3V0XQl2cG9ydF9zdGF0dXMgCS0gcG9pbnRlciB0byByZXR1cm4gdnBvcnQgc3RhdHVzIGluCisgKgorICogCXJldHVybgorICogCQl2b2lkCisgKgorKiAgCVNwZWNpYWwgQ29uc2lkZXJhdGlvbnM6CisgKgorICogCW5vdGUKKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfcG9ydF9zY25fdGltZW91dCh2b2lkICphcmcpCit7CisJc3RydWN0IGJmYV9mY3NfcG9ydF9zY25fcyAqc2NuID0gKHN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKilhcmc7CisKKwliZmFfc21fc2VuZF9ldmVudChzY24sIFNDTlNNX0VWRU5UX1RJTUVPVVQpOworfQorCisKKworLyoqCisgKiAgZmNzX3Njbl9wdWJsaWMgRkNTIHN0YXRlIGNoYW5nZSBub3RpZmljYXRpb24gcHVibGljIGludGVyZmFjZXMKKyAqLworCisvKgorICogRnVuY3Rpb25zIGNhbGxlZCBieSBwb3J0L2ZhYgorICovCit2b2lkCitiZmFfZmNzX3BvcnRfc2NuX2luaXQoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiA9IEJGQV9GQ1NfR0VUX1NDTl9GUk9NX1BPUlQocG9ydCk7CisKKwlzY24tPnBvcnQgPSBwb3J0OworCWJmYV9zbV9zZXRfc3RhdGUoc2NuLCBiZmFfZmNzX3BvcnRfc2NuX3NtX29mZmxpbmUpOworfQorCit2b2lkCitiZmFfZmNzX3BvcnRfc2NuX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiA9IEJGQV9GQ1NfR0VUX1NDTl9GUk9NX1BPUlQocG9ydCk7CisKKwlzY24tPnBvcnQgPSBwb3J0OworCWJmYV9zbV9zZW5kX2V2ZW50KHNjbiwgU0NOU01fRVZFTlRfUE9SVF9PRkZMSU5FKTsKK30KKwordm9pZAorYmZhX2Zjc19wb3J0X3Njbl9vbmxpbmUoc3RydWN0IGJmYV9mY3NfcG9ydF9zICpwb3J0KQoreworCXN0cnVjdCBiZmFfZmNzX3BvcnRfc2NuX3MgKnNjbiA9IEJGQV9GQ1NfR0VUX1NDTl9GUk9NX1BPUlQocG9ydCk7CisKKwlzY24tPnBvcnQgPSBwb3J0OworCWJmYV9zbV9zZW5kX2V2ZW50KHNjbiwgU0NOU01fRVZFTlRfUE9SVF9PTkxJTkUpOworfQorCitzdGF0aWMgdm9pZAorYmZhX2Zjc19wb3J0X3Njbl9wb3J0aWRfcnNjbihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHUzMiBycGlkKQoreworCXN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKnJwb3J0OworCisJYmZhX3RyYyhwb3J0LT5mY3MsIHJwaWQpOworCisJLyoqCisJICogSWYgdGhpcyBpcyBhbiB1bmtub3duIGRldmljZSwgdGhlbiBpdCBqdXN0IGNhbWUgb25saW5lLgorCSAqIE90aGVyd2lzZSBsZXQgcnBvcnQgaGFuZGxlIHRoZSBSU0NOIGV2ZW50LgorCSAqLworCXJwb3J0ID0gYmZhX2Zjc19wb3J0X2dldF9ycG9ydF9ieV9waWQocG9ydCwgcnBpZCk7CisJaWYgKHJwb3J0ID09IE5VTEwpIHsKKwkJLyoKKwkJICogSWYgbWluIGNmZyBtb2RlIGlzIGVuYWJsZWQsIHdlIGRvbm90IG5lZWQgdG8KKwkJICogZGlzY292ZXIgYW55IG5ldyBycG9ydHMuCisJCSAqLworCQlpZiAoIV9fZmNzX21pbl9jZmcocG9ydC0+ZmNzKSkKKwkJCXJwb3J0ID0gYmZhX2Zjc19ycG9ydF9jcmVhdGUocG9ydCwgcnBpZCk7CisJfSBlbHNlIHsKKwkJYmZhX2Zjc19ycG9ydF9zY24ocnBvcnQpOworCX0KK30KKworLyoqCisgKiByc2NuIGZvcm1hdCBiYXNlZCBQSUQgY29tcGFyaXNvbgorICovCisjZGVmaW5lIF9fZmNfcGlkX21hdGNoKF9fYzAsIF9fYzEsIF9fZm10KQkJXAorCSgoKF9fZm10KSA9PSBGQ19SU0NOX0ZPUk1BVF9GQUJSSUMpIHx8CQlcCisJICgoKF9fZm10KSA9PSBGQ19SU0NOX0ZPUk1BVF9ET01BSU4pICYmCQlcCisJICAoKF9fYzApWzBdID09IChfX2MxKVswXSkpIHx8CQkJXAorCSAoKChfX2ZtdCkgPT0gRkNfUlNDTl9GT1JNQVRfQVJFQSkgJiYJCVwKKwkgICgoX19jMClbMF0gPT0gKF9fYzEpWzBdKSAmJgkJCVwKKwkgICgoX19jMClbMV0gPT0gKF9fYzEpWzFdKSkpCisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3BvcnRfc2NuX211bHRpcG9ydF9yc2NuKHN0cnVjdCBiZmFfZmNzX3BvcnRfcyAqcG9ydCwKKwkJCWVudW0gZmNfcnNjbl9mb3JtYXQgZm9ybWF0LCB1MzIgcnNjbl9waWQpCit7CisJc3RydWN0IGJmYV9mY3NfcnBvcnRfcyAqcnBvcnQ7CisJc3RydWN0IGxpc3RfaGVhZCAqcWUsICpxZV9uZXh0OworCXU4ICAgICAgICAqYzAsICpjMTsKKworCWJmYV90cmMocG9ydC0+ZmNzLCBmb3JtYXQpOworCWJmYV90cmMocG9ydC0+ZmNzLCByc2NuX3BpZCk7CisKKwljMCA9ICh1OCAqKSAmcnNjbl9waWQ7CisKKwlsaXN0X2Zvcl9lYWNoX3NhZmUocWUsIHFlX25leHQsICZwb3J0LT5ycG9ydF9xKSB7CisJCXJwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3Jwb3J0X3MgKilxZTsKKwkJYzEgPSAodTggKikgJnJwb3J0LT5waWQ7CisJCWlmIChfX2ZjX3BpZF9tYXRjaChjMCwgYzEsIGZvcm1hdCkpCisJCQliZmFfZmNzX3Jwb3J0X3NjbihycG9ydCk7CisJfQorfQorCit2b2lkCitiZmFfZmNzX3BvcnRfc2NuX3Byb2Nlc3NfcnNjbihzdHJ1Y3QgYmZhX2Zjc19wb3J0X3MgKnBvcnQsIHN0cnVjdCBmY2hzX3MgKmZjaHMsCisJCQkgICAgICB1MzIgbGVuKQoreworCXN0cnVjdCBmY19yc2NuX3BsX3MgICAqcnNjbiA9IChzdHJ1Y3QgZmNfcnNjbl9wbF9zICopIChmY2hzICsgMSk7CisJaW50ICAgICAgICAgICAgIG51bV9lbnRyaWVzOworCXUzMiAgICAgICAgcnNjbl9waWQ7CisJYmZhX2Jvb2xlYW5fdCAgIG5zcXVlcnkgPSBCRkFfRkFMU0U7CisJaW50ICAgICAgICAgICAgIGkgPSAwOworCisJbnVtX2VudHJpZXMgPQorCQkoYmZhX29zX250b2hzKHJzY24tPnBheWxkbGVuKSAtCisJCSBzaXplb2YodTMyKSkgLyBzaXplb2YocnNjbi0+ZXZlbnRbMF0pOworCisJYmZhX3RyYyhwb3J0LT5mY3MsIG51bV9lbnRyaWVzKTsKKworCXBvcnQtPnN0YXRzLm51bV9yc2NuKys7CisKKwliZmFfZmNzX3BvcnRfc2NuX3NlbmRfbHNfYWNjKHBvcnQsIGZjaHMpOworCisJZm9yIChpID0gMDsgaSA8IG51bV9lbnRyaWVzOyBpKyspIHsKKwkJcnNjbl9waWQgPSByc2NuLT5ldmVudFtpXS5wb3J0aWQ7CisKKwkJYmZhX3RyYyhwb3J0LT5mY3MsIHJzY24tPmV2ZW50W2ldLmZvcm1hdCk7CisJCWJmYV90cmMocG9ydC0+ZmNzLCByc2NuX3BpZCk7CisKKwkJc3dpdGNoIChyc2NuLT5ldmVudFtpXS5mb3JtYXQpIHsKKwkJY2FzZSBGQ19SU0NOX0ZPUk1BVF9QT1JUSUQ6CisJCQlpZiAocnNjbi0+ZXZlbnRbaV0ucXVhbGlmaWVyID09IEZDX1FPU19SU0NOX0VWRU5UKSB7CisJCQkJLyoKKwkJCQkgKiBJZ25vcmUgdGhpcyBldmVudC4gZi93IHdvdWxkIGhhdmUgcHJvY2Vzc2VkCisJCQkJICogaXQKKwkJCQkgKi8KKwkJCQliZmFfdHJjKHBvcnQtPmZjcywgcnNjbl9waWQpOworCQkJfSBlbHNlIHsKKwkJCQlwb3J0LT5zdGF0cy5udW1fcG9ydGlkX3JzY24rKzsKKwkJCQliZmFfZmNzX3BvcnRfc2NuX3BvcnRpZF9yc2NuKHBvcnQsIHJzY25fcGlkKTsKKwkJCX0KKwkJCWJyZWFrOworCisJCWNhc2UgRkNfUlNDTl9GT1JNQVRfRkFCUklDOgorCQkJaWYgKHJzY24tPmV2ZW50W2ldLnF1YWxpZmllciA9PQorCQkJICAgIEZDX0ZBQlJJQ19OQU1FX1JTQ05fRVZFTlQpIHsKKwkJCQliZmFfZmNzX3BvcnRfbXNfZmFicmljX3JzY24ocG9ydCk7CisJCQkJYnJlYWs7CisJCQl9CisJCQkvKgorCQkJICogISEhISEhISEhIEZhbGwgVGhyb3VnaCAhISEhISEhISEhISEhCisJCQkgKi8KKworCQljYXNlIEZDX1JTQ05fRk9STUFUX0FSRUE6CisJCWNhc2UgRkNfUlNDTl9GT1JNQVRfRE9NQUlOOgorCQkJbnNxdWVyeSA9IEJGQV9UUlVFOworCQkJYmZhX2Zjc19wb3J0X3Njbl9tdWx0aXBvcnRfcnNjbihwb3J0LAorCQkJCQkJCXJzY24tPmV2ZW50W2ldLmZvcm1hdCwKKwkJCQkJCQlyc2NuX3BpZCk7CisJCQlicmVhazsKKworCQlkZWZhdWx0OgorCQkJYmZhX2Fzc2VydCgwKTsKKwkJCW5zcXVlcnkgPSBCRkFfVFJVRTsKKwkJfQorCX0KKworCS8qKgorCSAqIElmIGFueSBvZiBhcmVhLCBkb21haW4gb3IgZmFicmljIFJTQ04gaXMgcmVjZWl2ZWQsIGRvIGEgZnJlc2ggZGlzY292ZXJ5CisJICogdG8gZmluZCBuZXcgZGV2aWNlcy4KKwkgKi8KKwlpZiAobnNxdWVyeSkKKwkJYmZhX2Zjc19wb3J0X25zX3F1ZXJ5KHBvcnQpOworfQorCisKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9iZmEvdmZhcGkuYyBiL2RyaXZlcnMvc2NzaS9iZmEvdmZhcGkuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMWQ4MWZlCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL2JmYS92ZmFwaS5jCkBAIC0wLDAgKzEsMjkyIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDA1LTIwMDkgQnJvY2FkZSBDb21tdW5pY2F0aW9ucyBTeXN0ZW1zLCBJbmMuCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkCisgKiB3d3cuYnJvY2FkZS5jb20KKyAqCisgKiBMaW51eCBkcml2ZXIgZm9yIEJyb2NhZGUgRmlicmUgQ2hhbm5lbCBIb3N0IEJ1cyBBZGFwdGVyLgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0CisgKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIChHUEwpIFZlcnNpb24gMiBhcworICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24KKyAqCisgKiBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0CisgKiBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQorICogR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICovCisKKy8qKgorICogIHZmYXBpLmMgRmFicmljIG1vZHVsZSBpbXBsZW1lbnRhdGlvbi4KKyAqLworCisjaW5jbHVkZSAiZmNzX2ZhYnJpYy5oIgorI2luY2x1ZGUgImZjc190cmNtb2QuaCIKKworQkZBX1RSQ19GSUxFKEZDUywgVkZBUEkpOworCisvKioKKyAqICBmY3NfdmZfYXBpIHZpcnR1YWwgZmFicmljcyBBUEkKKyAqLworCisvKioKKyAqIAkJRW5hYmxlIFZGIG1vZGUuCisgKgorICogQHBhcmFtW2luXQkJZmNzCQlmY3MgbW9kdWxlIGluc3RhbmNlCisgKiBAcGFyYW1baW5dCQl2Zl9pZAkJZGVmYXVsdCB2Zl9pZCBvZiBwb3J0LCBGQ19WRl9JRF9OVUxMCisgKiAJCQkJCXRvIHVzZSBzdGFuZGFyZCBkZWZhdWx0IHZmX2lkIG9mIDEuCisgKgorICogQHJldHZhbAlCRkFfU1RBVFVTX09LCQl2ZiBtb2RlIGlzIGVuYWJsZWQKKyAqIEByZXR2YWwJQkZBX1NUQVRVU19CVVNZCQlQb3J0IGlzIGFjdGl2ZS4gUG9ydCBtdXN0IGJlIGRpc2FibGVkCisgKgkJCQkJYmVmb3JlIFZGIG1vZGUgY2FuIGJlIGVuYWJsZWQuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2Zjc192Zl9tb2RlX2VuYWJsZShzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHUxNiB2Zl9pZCkKK3sKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiAJCURpc2FibGUgVkYgbW9kZS4KKyAqCisgKiBAcGFyYW1baW5dCQlmY3MJCWZjcyBtb2R1bGUgaW5zdGFuY2UKKyAqCisgKiBAcmV0dmFsCUJGQV9TVEFUVVNfT0sJCXZmIG1vZGUgaXMgZGlzYWJsZWQKKyAqIEByZXR2YWwJQkZBX1NUQVRVU19CVVNZCQlWRnMgYXJlIHByZXNlbnQgYW5kIGJlaW5nIHVzZWQuIEFsbAorICogCQkJCQlWRnMgbXVzdCBiZSBkZWxldGVkIGJlZm9yZSBkaXNhYmxpbmcKKyAqCQkJCQlWRiBtb2RlLgorICovCitiZmFfc3RhdHVzX3QKK2JmYV9mY3NfdmZfbW9kZV9kaXNhYmxlKHN0cnVjdCBiZmFfZmNzX3MgKmZjcykKK3sKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiAJCUNyZWF0ZSBhIG5ldyBWRiBpbnN0YW5jZS4KKyAqCisgKiAgQSBuZXcgVkYgaXMgY3JlYXRlZCB1c2luZyB0aGUgZ2l2ZW4gVkYgY29uZmlndXJhdGlvbi4gQSBWRiBpcyBpZGVudGlmaWVkCisgKiAgYnkgVkYgaWQuIE5vIGR1cGxpY2F0ZSBWRiBjcmVhdGlvbiBpcyBhbGxvd2VkIHdpdGggdGhlIHNhbWUgVkYgaWQuIE9uY2UKKyAqICBhIFZGIGlzIGNyZWF0ZWQsIFZGIGlzIGF1dG9tYXRpY2FsbHkgc3RhcnRlZCBhZnRlciBsaW5rIGluaXRpYWxpemF0aW9uCisgKiAgYW5kIEVWRlAgZXhjaGFuZ2UgaXMgY29tcGxldGVkLgorICoKKyAqIAlwYXJhbVtpbl0gdmYJCS0gCUZDUyB2ZiBkYXRhIHN0cnVjdHVyZS4gTWVtb3J5IGlzCisgKgkJCQkJYWxsb2NhdGVkIGJ5IGNhbGxlciAoZHJpdmVyKQorICogCXBhcmFtW2luXSBmY3MgCQktIAlGQ1MgbW9kdWxlCisgKiAJcGFyYW1baW5dIHZmX2NmZwktIAlWRiBjb25maWd1cmF0aW9uCisgKiAJcGFyYW1baW5dIHZmX2RydiAJLSAJT3BhcXVlIGhhbmRsZSBiYWNrIHRvIHRoZSBkcml2ZXIncworICoJCQkJCXZpcnR1YWwgdmYgc3RydWN0dXJlCisgKgorICogCXJldHZhbCBCRkFfU1RBVFVTX09LIFZGIGNyZWF0aW9uIGlzIHN1Y2Nlc3NmdWwKKyAqIAlyZXR2YWwgQkZBX1NUQVRVU19GQUlMRUQgVkYgY3JlYXRpb24gZmFpbGVkCisgKiAJcmV0dmFsIEJGQV9TVEFUVVNfRUVYSVNUIEEgVkYgZXhpc3RzIHdpdGggdGhlIGdpdmVuIHZmX2lkCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2Zjc192Zl9jcmVhdGUoYmZhX2Zjc192Zl90ICp2Ziwgc3RydWN0IGJmYV9mY3NfcyAqZmNzLCB1MTYgdmZfaWQsCisJCSAgc3RydWN0IGJmYV9wb3J0X2NmZ19zICpwb3J0X2NmZywgc3RydWN0IGJmYWRfdmZfcyAqdmZfZHJ2KQoreworCWJmYV90cmMoZmNzLCB2Zl9pZCk7CisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogIAlVc2UgdGhpcyBmdW5jdGlvbiB0byBkZWxldGUgYSBCRkEgVkYgb2JqZWN0LiBWRiBvYmplY3Qgc2hvdWxkCisgKiAJCWJlIHN0b3BwZWQgYmVmb3JlIHRoaXMgZnVuY3Rpb24gY2FsbC4KKyAqCisgKiAJcGFyYW1baW5dIHZmIC0gcG9pbnRlciB0byBiZmFfdmZfdC4KKyAqCisgKiAJcmV0dmFsIEJGQV9TVEFUVVNfT0sJT24gdmYgZGVsZXRpb24gc3VjY2VzcworICogCXJldHZhbCBCRkFfU1RBVFVTX0JVU1kgVkYgaXMgbm90IGluIGEgc3RvcHBlZCBzdGF0ZQorICogCXJldHZhbCBCRkFfU1RBVFVTX0lOUFJPR1JFU1MgVkYgZGVsZXRpb24gaW4gaW4gcHJvZ3Jlc3MKKyAqLworYmZhX3N0YXR1c190CitiZmFfZmNzX3ZmX2RlbGV0ZShiZmFfZmNzX3ZmX3QgKnZmKQoreworCWJmYV90cmModmYtPmZjcywgdmYtPnZmX2lkKTsKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiAgCVN0YXJ0IHBhcnRpY2lwYXRpb24gaW4gVkYuIFRoaXMgdHJpZ2dlcnMgbG9naW4gdG8gdGhlIHZpcnR1YWwgZmFicmljLgorICoKKyAqIAlwYXJhbVtpbl0gdmYgLSBwb2ludGVyIHRvIGJmYV92Zl90LgorICoKKyAqIAlyZXR1cm4gTm9uZQorICovCit2b2lkCitiZmFfZmNzX3ZmX3N0YXJ0KGJmYV9mY3NfdmZfdCAqdmYpCit7CisJYmZhX3RyYyh2Zi0+ZmNzLCB2Zi0+dmZfaWQpOworfQorCisvKioKKyAqICAJTG9nb3V0IHdpdGggdGhlIHZpcnR1YWwgZmFicmljLgorICoKKyAqIAlwYXJhbVtpbl0gdmYgLSBwb2ludGVyIHRvIGJmYV92Zl90LgorICoKKyAqIAlyZXR2YWwgQkZBX1NUQVRVU19PSyAJT24gc3VjY2Vzcy4KKyAqIAlyZXR2YWwgQkZBX1NUQVRVU19JTlBST0dSRVNTIFZGIGlzIGJlaW5nIHN0b3BwZWQuCisgKi8KK2JmYV9zdGF0dXNfdAorYmZhX2Zjc192Zl9zdG9wKGJmYV9mY3NfdmZfdCAqdmYpCit7CisJYmZhX3RyYyh2Zi0+ZmNzLCB2Zi0+dmZfaWQpOworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqICAJUmV0dXJucyBhdHRyaWJ1dGVzIG9mIHRoZSBnaXZlbiBWRi4KKyAqCisgKiAJcGFyYW1baW5dIAl2ZgkJCXBvaW50ZXIgdG8gYmZhX3ZmX3QuCisgKiAJcGFyYW1bb3V0XSB2Zl9hdHRyIAl2ZiBhdHRyaWJ1dGVzIHJldHVybmVkCisgKgorICogCXJldHVybiBOb25lCisgKi8KK3ZvaWQKK2JmYV9mY3NfdmZfZ2V0X2F0dHIoYmZhX2Zjc192Zl90ICp2Ziwgc3RydWN0IGJmYV92Zl9hdHRyX3MgKnZmX2F0dHIpCit7CisJYmZhX3RyYyh2Zi0+ZmNzLCB2Zi0+dmZfaWQpOworfQorCisvKioKKyAqIAkJUmV0dXJuIHN0YXRpc3RpY3MgYXNzb2NpYXRlZCB3aXRoIHRoZSBnaXZlbiB2Zi4KKyAqCisgKiAJcGFyYW1baW5dIAl2ZgkJCXBvaW50ZXIgdG8gYmZhX3ZmX3QuCisgKiAJcGFyYW1bb3V0XSB2Zl9zdGF0cyAJdmYgc3RhdGlzdGljcyByZXR1cm5lZAorICoKKyAqICBAcmV0dXJuIE5vbmUKKyAqLwordm9pZAorYmZhX2Zjc192Zl9nZXRfc3RhdHMoYmZhX2Zjc192Zl90ICp2Ziwgc3RydWN0IGJmYV92Zl9zdGF0c19zICp2Zl9zdGF0cykKK3sKKwliZmFfb3NfbWVtY3B5KHZmX3N0YXRzLCAmdmYtPnN0YXRzLCBzaXplb2Yoc3RydWN0IGJmYV92Zl9zdGF0c19zKSk7CisJcmV0dXJuOworfQorCit2b2lkCisvKioKKyAqIAkJY2xlYXIgc3RhdGlzdGljcyBhc3NvY2lhdGVkIHdpdGggdGhlIGdpdmVuIHZmLgorICoKKyAqIAlwYXJhbVtpbl0gCXZmCQkJcG9pbnRlciB0byBiZmFfdmZfdC4KKyAqCisgKiAgQHJldHVybiBOb25lCisgKi8KK2JmYV9mY3NfdmZfY2xlYXJfc3RhdHMoYmZhX2Zjc192Zl90ICp2ZikKK3sKKwliZmFfb3NfbWVtc2V0KCZ2Zi0+c3RhdHMsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3ZmX3N0YXRzX3MpKTsKKwlyZXR1cm47Cit9CisKKy8qKgorICogIAlSZXR1cm5zIEZDUyB2ZiBzdHJ1Y3R1cmUgZm9yIGEgZ2l2ZW4gdmZfaWQuCisgKgorICogCXBhcmFtW2luXSAJdmZfaWQJCS0gVkZfSUQKKyAqCisgKiAJcmV0dXJuCisgKiAJCUlmIGxvb2t1cCBzdWNjZWVkcywgcmV0dW5zIGZjcyB2ZiBvYmplY3QsIG90aGVyd2lzZSByZXR1cm5zIE5VTEwKKyAqLworYmZhX2Zjc192Zl90ICAgKgorYmZhX2Zjc192Zl9sb29rdXAoc3RydWN0IGJmYV9mY3NfcyAqZmNzLCB1MTYgdmZfaWQpCit7CisJYmZhX3RyYyhmY3MsIHZmX2lkKTsKKwlpZiAodmZfaWQgPT0gRkNfVkZfSURfTlVMTCkKKwkJcmV0dXJuICgmZmNzLT5mYWJyaWMpOworCisJLyoqCisJICogQHRvZG8gdmYgc3VwcG9ydAorCSAqLworCisJcmV0dXJuIE5VTEw7Cit9CisKKy8qKgorICogIAlSZXR1cm5zIGRyaXZlciBWRiBzdHJ1Y3R1cmUgZm9yIGEgZ2l2ZW4gRkNTIHZmLgorICoKKyAqIAlwYXJhbVtpbl0gCXZmCQktIHBvaW50ZXIgdG8gYmZhX3ZmX3QKKyAqCisgKiAJcmV0dXJuIERyaXZlciBWRiBzdHJ1Y3R1cmUKKyAqLworc3RydWN0IGJmYWRfdmZfcyAgICAgICoKK2JmYV9mY3NfdmZfZ2V0X2Rydl92ZihiZmFfZmNzX3ZmX3QgKnZmKQoreworCWJmYV9hc3NlcnQodmYpOworCWJmYV90cmModmYtPmZjcywgdmYtPnZmX2lkKTsKKwlyZXR1cm4gdmYtPnZmX2RydjsKK30KKworLyoqCisgKiAgCVJldHVybiB0aGUgbGlzdCBvZiBWRnMgY29uZmlndXJlZC4KKyAqCisgKiAJcGFyYW1baW5dCWZjcwlmY3MgbW9kdWxlIGluc3RhbmNlCisgKiAJcGFyYW1bb3V0XSAJdmZfaWRzCXJldHVybmVkIGxpc3Qgb2YgdmZfaWRzCisgKiAJcGFyYW1baW4sb3V0XSAJbnZmcwlpbjpzaXplIG9mIHZmX2lkcyBhcnJheSwKKyAqIAkJCQlvdXQ6dG90YWwgZWxlbWVudHMgcHJlc2VudCwKKyAqIAkJCQlhY3R1YWwgZWxlbWVudHMgcmV0dXJuZWQgaXMgbGltaXRlZCBieSB0aGUgc2l6ZQorICoKKyAqIAlyZXR1cm4gRHJpdmVyIFZGIHN0cnVjdHVyZQorICovCit2b2lkCitiZmFfZmNzX3ZmX2xpc3Qoc3RydWN0IGJmYV9mY3NfcyAqZmNzLCB1MTYgKnZmX2lkcywgaW50ICpudmZzKQoreworCWJmYV90cmMoZmNzLCAqbnZmcyk7Cit9CisKKy8qKgorICogIAlSZXR1cm4gdGhlIGxpc3Qgb2YgYWxsIFZGcyB2aXNpYmxlIGZyb20gZmFicmljLgorICoKKyAqIAlwYXJhbVtpbl0JZmNzCWZjcyBtb2R1bGUgaW5zdGFuY2UKKyAqIAlwYXJhbVtvdXRdIAl2Zl9pZHMJcmV0dXJuZWQgbGlzdCBvZiB2Zl9pZHMKKyAqIAlwYXJhbVtpbixvdXRdIAludmZzCWluOnNpemUgb2YgdmZfaWRzIGFycmF5LAorICoJCQkJb3V0OnRvdGFsIGVsZW1lbnRzIHByZXNlbnQsCisgKiAJCQkJYWN0dWFsIGVsZW1lbnRzIHJldHVybmVkIGlzIGxpbWl0ZWQgYnkgdGhlIHNpemUKKyAqCisgKiAJcmV0dXJuIERyaXZlciBWRiBzdHJ1Y3R1cmUKKyAqLwordm9pZAorYmZhX2Zjc192Zl9saXN0X2FsbChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MsIHUxNiAqdmZfaWRzLCBpbnQgKm52ZnMpCit7CisJYmZhX3RyYyhmY3MsICpudmZzKTsKK30KKworLyoqCisgKiAJCVJldHVybiB0aGUgbGlzdCBvZiBsb2NhbCBsb2dpY2FsIHBvcnRzIHByZXNlbnQgaW4gdGhlIGdpdmVuIFZGLgorICoKKyAqIAlwYXJhbVtpbl0JdmYJdmYgZm9yIHdoaWNoIGxvZ2ljYWwgcG9ydHMgYXJlIHJldHVybmVkCisgKiAJcGFyYW1bb3V0XSAJbHB3d24JcmV0dXJuZWQgbG9naWNhbCBwb3J0IHd3biBsaXN0CisgKiAJcGFyYW1baW4sb3V0XSAJbmxwb3J0cwlpbjpzaXplIG9mIGxwd3duIGxpc3Q7CisgKgkJCQlvdXQ6dG90YWwgZWxlbWVudHMgcHJlc2VudCwKKyAqIAkJCQlhY3R1YWwgZWxlbWVudHMgcmV0dXJuZWQgaXMgbGltaXRlZCBieSB0aGUgc2l6ZQorICoKKyAqLwordm9pZAorYmZhX2Zjc192Zl9nZXRfcG9ydHMoYmZhX2Zjc192Zl90ICp2Ziwgd3duX3QgbHB3d25bXSwgaW50ICpubHBvcnRzKQoreworCXN0cnVjdCBsaXN0X2hlYWQgICAgICAgICpxZTsKKwlzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydDsKKwlpbnQgICAgICAgICAgICAgaTsKKwlzdHJ1Y3QgYmZhX2Zjc19zICAgICAgKmZjczsKKworCWlmICh2ZiA9PSBOVUxMIHx8IGxwd3duID09IE5VTEwgfHwgKm5scG9ydHMgPT0gMCkKKwkJcmV0dXJuOworCisJZmNzID0gdmYtPmZjczsKKworCWJmYV90cmMoZmNzLCB2Zi0+dmZfaWQpOworCWJmYV90cmMoZmNzLCAodTMyKSAqbmxwb3J0cyk7CisKKwlpID0gMDsKKwlscHd3bltpKytdID0gdmYtPmJwb3J0LnBvcnRfY2ZnLnB3d247CisKKwlsaXN0X2Zvcl9lYWNoKHFlLCAmdmYtPnZwb3J0X3EpIHsKKwkJaWYgKGkgPj0gKm5scG9ydHMpCisJCQlicmVhazsKKworCQl2cG9ydCA9IChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICopIHFlOworCQlscHd3bltpKytdID0gdnBvcnQtPmxwb3J0LnBvcnRfY2ZnLnB3d247CisJfQorCisJYmZhX3RyYyhmY3MsIGkpOworCSpubHBvcnRzID0gaTsKKwlyZXR1cm47Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JmYS92cG9ydC5jIGIvZHJpdmVycy9zY3NpL2JmYS92cG9ydC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMxMGFmMDYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3Njc2kvYmZhL3Zwb3J0LmMKQEAgLTAsMCArMSw4OTEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKGMpIDIwMDUtMjAwOSBCcm9jYWRlIENvbW11bmljYXRpb25zIFN5c3RlbXMsIEluYy4KKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQKKyAqIHd3dy5icm9jYWRlLmNvbQorICoKKyAqIExpbnV4IGRyaXZlciBmb3IgQnJvY2FkZSBGaWJyZSBDaGFubmVsIEhvc3QgQnVzIEFkYXB0ZXIuCisgKgorICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkgaXQKKyAqIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgKEdQTCkgVmVyc2lvbiAyIGFzCisgKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbgorICoKKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKKyAqIFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCisgKiBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisgKi8KKworLyoqCisgKiAgYmZhX2Zjc192cG9ydC5jIEZDUyB2aXJ0dWFsIHBvcnQgc3RhdGUgbWFjaGluZQorICovCisKKyNpbmNsdWRlIDxiZmEuaD4KKyNpbmNsdWRlIDxiZmFfc3ZjLmg+CisjaW5jbHVkZSA8ZmNidWlsZC5oPgorI2luY2x1ZGUgImZjc19mYWJyaWMuaCIKKyNpbmNsdWRlICJmY3NfbHBvcnQuaCIKKyNpbmNsdWRlICJmY3NfdnBvcnQuaCIKKyNpbmNsdWRlICJmY3NfdHJjbW9kLmgiCisjaW5jbHVkZSAiZmNzLmgiCisjaW5jbHVkZSA8YWVuL2JmYV9hZW5fbHBvcnQuaD4KKworQkZBX1RSQ19GSUxFKEZDUywgVlBPUlQpOworCisjZGVmaW5lIF9fdnBvcnRfZmNzKF9fdnApICAgICAgIChfX3ZwKS0+bHBvcnQuZmNzCisjZGVmaW5lIF9fdnBvcnRfcHd3bihfX3ZwKSAgICAgIChfX3ZwKS0+bHBvcnQucG9ydF9jZmcucHd3bgorI2RlZmluZSBfX3Zwb3J0X253d24oX192cCkgICAgICAoX192cCktPmxwb3J0LnBvcnRfY2ZnLm53d24KKyNkZWZpbmUgX192cG9ydF9iZmEoX192cCkgICAgICAgKF9fdnApLT5scG9ydC5mY3MtPmJmYQorI2RlZmluZSBfX3Zwb3J0X2ZjaWQoX192cCkgICAgICAoX192cCktPmxwb3J0LnBpZAorI2RlZmluZSBfX3Zwb3J0X2ZhYnJpYyhfX3ZwKSAgICAoX192cCktPmxwb3J0LmZhYnJpYworI2RlZmluZSBfX3Zwb3J0X3ZmaWQoX192cCkgICAgICAoX192cCktPmxwb3J0LmZhYnJpYy0+dmZfaWQKKworI2RlZmluZSBCRkFfRkNTX1ZQT1JUX01BWF9SRVRSSUVTICA1CisvKgorICogRm9yd2FyZCBkZWNsYXJhdGlvbnMKKyAqLworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfdnBvcnRfZG9fZmRpc2Moc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfdnBvcnRfdGltZW91dCh2b2lkICp2cG9ydF9hcmcpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfdnBvcnRfZG9fbG9nbyhzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc192cG9ydF9mcmVlKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0KTsKKworLyoqCisgKiAgZmNzX3Zwb3J0X3NtIEZDUyB2aXJ0dWFsIHBvcnQgc3RhdGUgbWFjaGluZQorICovCisKKy8qKgorICogVlBvcnQgU3RhdGUgTWFjaGluZSBldmVudHMKKyAqLworZW51bSBiZmFfZmNzX3Zwb3J0X2V2ZW50IHsKKwlCRkFfRkNTX1ZQT1JUX1NNX0NSRUFURSA9IDEsCS8qICB2cG9ydCBjcmVhdGUgZXZlbnQgKi8KKwlCRkFfRkNTX1ZQT1JUX1NNX0RFTEVURSA9IDIsCS8qICB2cG9ydCBkZWxldGUgZXZlbnQgKi8KKwlCRkFfRkNTX1ZQT1JUX1NNX1NUQVJUID0gMywJLyogIHZwb3J0IHN0YXJ0IHJlcXVlc3QgKi8KKwlCRkFfRkNTX1ZQT1JUX1NNX1NUT1AgPSA0LAkvKiAgc3RvcDogdW5zdXBwb3J0ZWQgKi8KKwlCRkFfRkNTX1ZQT1JUX1NNX09OTElORSA9IDUsCS8qICBmYWJyaWMgb25saW5lICovCisJQkZBX0ZDU19WUE9SVF9TTV9PRkZMSU5FID0gNiwJLyogIGZhYnJpYyBvZmZsaW5lIGV2ZW50ICovCisJQkZBX0ZDU19WUE9SVF9TTV9GUk1TRU5UID0gNywJLyogIGZkaXNjL2xvZ28gc2VudCBldmVudHMgKi8KKwlCRkFfRkNTX1ZQT1JUX1NNX1JTUF9PSyA9IDgsCS8qICBnb29kIHJlc3BvbnNlICovCisJQkZBX0ZDU19WUE9SVF9TTV9SU1BfRVJST1IgPSA5LAkvKiAgZXJyb3IvYmFkIHJlc3BvbnNlICovCisJQkZBX0ZDU19WUE9SVF9TTV9USU1FT1VUID0gMTAsCS8qICBkZWxheSB0aW1lciBldmVudCAqLworCUJGQV9GQ1NfVlBPUlRfU01fREVMQ09NUCA9IDExLAkvKiAgbHBvcnQgZGVsZXRlIGNvbXBsZXRpb24gKi8KKwlCRkFfRkNTX1ZQT1JUX1NNX1JTUF9EVVBfV1dOID0gMTIsCS8qICBEdXAgd25uIGVycm9yICovCisJQkZBX0ZDU19WUE9SVF9TTV9SU1BfRkFJTEVEID0gMTMsCS8qICBub24tcmV0cnlhYmxlIGZhaWx1cmUgKi8KK307CisKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Zwb3J0X3NtX3VuaW5pdChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCQkJZW51bSBiZmFfZmNzX3Zwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Zwb3J0X3NtX2NyZWF0ZWQoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQkJCSBlbnVtIGJmYV9mY3NfdnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfdnBvcnRfc21fb2ZmbGluZShzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCQkJIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc192cG9ydF9zbV9mZGlzYyhzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCQkgICAgICAgZW51bSBiZmFfZmNzX3Zwb3J0X2V2ZW50IGV2ZW50KTsKK3N0YXRpYyB2b2lkICAgICBiZmFfZmNzX3Zwb3J0X3NtX2ZkaXNjX3JldHJ5KHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0LAorCQkJCQkgICAgIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc192cG9ydF9zbV9vbmxpbmUoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQkJCWVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc192cG9ydF9zbV9kZWxldGluZyhzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCQkJICBlbnVtIGJmYV9mY3NfdnBvcnRfZXZlbnQgZXZlbnQpOworc3RhdGljIHZvaWQgICAgIGJmYV9mY3NfdnBvcnRfc21fY2xlYW51cChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCQkJIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc192cG9ydF9zbV9sb2dvKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0LAorCQkJCSAgICAgIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCk7CitzdGF0aWMgdm9pZCAgICAgYmZhX2Zjc192cG9ydF9zbV9lcnJvcihzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCQkgICAgICAgZW51bSBiZmFfZmNzX3Zwb3J0X2V2ZW50IGV2ZW50KTsKKworc3RhdGljIHN0cnVjdCBiZmFfc21fdGFibGVfcyB2cG9ydF9zbV90YWJsZVtdID0geworCXtCRkFfU00oYmZhX2Zjc192cG9ydF9zbV91bmluaXQpLCBCRkFfRkNTX1ZQT1JUX1VOSU5JVH0sCisJe0JGQV9TTShiZmFfZmNzX3Zwb3J0X3NtX2NyZWF0ZWQpLCBCRkFfRkNTX1ZQT1JUX0NSRUFURUR9LAorCXtCRkFfU00oYmZhX2Zjc192cG9ydF9zbV9vZmZsaW5lKSwgQkZBX0ZDU19WUE9SVF9PRkZMSU5FfSwKKwl7QkZBX1NNKGJmYV9mY3NfdnBvcnRfc21fZmRpc2MpLCBCRkFfRkNTX1ZQT1JUX0ZESVNDfSwKKwl7QkZBX1NNKGJmYV9mY3NfdnBvcnRfc21fZmRpc2NfcmV0cnkpLCBCRkFfRkNTX1ZQT1JUX0ZESVNDX1JFVFJZfSwKKwl7QkZBX1NNKGJmYV9mY3NfdnBvcnRfc21fb25saW5lKSwgQkZBX0ZDU19WUE9SVF9PTkxJTkV9LAorCXtCRkFfU00oYmZhX2Zjc192cG9ydF9zbV9kZWxldGluZyksIEJGQV9GQ1NfVlBPUlRfREVMRVRJTkd9LAorCXtCRkFfU00oYmZhX2Zjc192cG9ydF9zbV9jbGVhbnVwKSwgQkZBX0ZDU19WUE9SVF9DTEVBTlVQfSwKKwl7QkZBX1NNKGJmYV9mY3NfdnBvcnRfc21fbG9nbyksIEJGQV9GQ1NfVlBPUlRfTE9HT30sCisJe0JGQV9TTShiZmFfZmNzX3Zwb3J0X3NtX2Vycm9yKSwgQkZBX0ZDU19WUE9SVF9FUlJPUn0KK307CisKKy8qKgorICogQmVnaW5uaW5nIHN0YXRlLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc192cG9ydF9zbV91bmluaXQoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQllbnVtIGJmYV9mY3NfdnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIF9fdnBvcnRfcHd3bih2cG9ydCkpOworCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX0NSRUFURToKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV9jcmVhdGVkKTsKKwkJYmZhX2Zjc19mYWJyaWNfYWRkdnBvcnQoX192cG9ydF9mYWJyaWModnBvcnQpLCB2cG9ydCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogQ3JlYXRlZCBzdGF0ZSAtIGEgc3RhcnQgZXZlbnQgaXMgcmVxdWlyZWQgdG8gc3RhcnQgdXAgdGhlIHN0YXRlIG1hY2hpbmUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Zwb3J0X3NtX2NyZWF0ZWQoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQkgZW51bSBiZmFfZmNzX3Zwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBfX3Zwb3J0X3B3d24odnBvcnQpKTsKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9TVEFSVDoKKwkJaWYgKGJmYV9mY3NfZmFicmljX2lzX29ubGluZShfX3Zwb3J0X2ZhYnJpYyh2cG9ydCkpCisJCSAgICAmJiBiZmFfZmNzX2ZhYnJpY19ucGl2X2NhcGFibGUoX192cG9ydF9mYWJyaWModnBvcnQpKSkgeworCQkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV9mZGlzYyk7CisJCQliZmFfZmNzX3Zwb3J0X2RvX2ZkaXNjKHZwb3J0KTsKKwkJfSBlbHNlIHsKKwkJCS8qKgorCQkJICogRmFicmljIGlzIG9mZmxpbmUgb3Igbm90IE5QSVYgY2FwYWJsZSwgc3RheSBpbgorCQkJICogb2ZmbGluZSBzdGF0ZS4KKwkJCSAqLworCQkJdnBvcnQtPnZwb3J0X3N0YXRzLmZhYl9ub19ucGl2Kys7CisJCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX29mZmxpbmUpOworCQl9CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV9jbGVhbnVwKTsKKwkJYmZhX2Zjc19wb3J0X2RlbGV0ZSgmdnBvcnQtPmxwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fT05MSU5FOgorCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9PRkZMSU5FOgorCQkvKioKKwkJICogSWdub3JlIE9OTElORS9PRkZMSU5FIGV2ZW50cyBmcm9tIGZhYnJpYyB0aWxsIHZwb3J0IGlzIHN0YXJ0ZWQuCisJCSAqLworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIE9mZmxpbmUgc3RhdGUgLSBhd2FpdGluZyBPTkxJTkUgZXZlbnQgZnJvbSBmYWJyaWMgU00uCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Zwb3J0X3NtX29mZmxpbmUoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQkgZW51bSBiZmFfZmNzX3Zwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBfX3Zwb3J0X3B3d24odnBvcnQpKTsKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUodnBvcnQsIGJmYV9mY3NfdnBvcnRfc21fY2xlYW51cCk7CisJCWJmYV9mY3NfcG9ydF9kZWxldGUoJnZwb3J0LT5scG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX09OTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV9mZGlzYyk7CisJCXZwb3J0LT5mZGlzY19yZXRyaWVzID0gMDsKKwkJYmZhX2Zjc192cG9ydF9kb19mZGlzYyh2cG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX09GRkxJTkU6CisJCS8qCisJCSAqIFRoaXMgY2FuIGhhcHBlbiBpZiB0aGUgdnBvcnQgY291bGRuJ3QgYmUgaW5pdGlhbHppZWQgZHVlCisJCSAqIHRoZSBmYWN0IHRoYXQgdGhlIG5waXYgd2FzIG5vdCBlbmFibGVkIG9uIHRoZSBzd2l0Y2guIEluCisJCSAqIHRoYXQgY2FzZSB3ZSB3aWxsIHB1dCB0aGUgdnBvcnQgaW4gb2ZmbGluZSBzdGF0ZS4gSG93ZXZlciwKKwkJICogdGhlIGxpbmsgY2FuIGdvIGRvd24gYW5kIGNhdXNlIHRoZSB0aGlzIGV2ZW50IHRvIGJlIHNlbnQgd2hlbgorCQkgKiB3ZSBhcmUgYWxyZWFkeSBvZmZsaW5lLiBJZ25vcmUgaXQuCisJCSAqLworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIEZESVNDIGlzIHNlbnQgYW5kIGF3YWl0aW5nIHJlcGx5IGZyb20gZmFicmljLgorICovCitzdGF0aWMgdm9pZAorYmZhX2Zjc192cG9ydF9zbV9mZGlzYyhzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJICAgICAgIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgX192cG9ydF9wd3duKHZwb3J0KSk7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX2xvZ28pOworCQliZmFfbHBzX2Rpc2NhcmQodnBvcnQtPmxwcyk7CisJCWJmYV9mY3NfdnBvcnRfZG9fbG9nbyh2cG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX09GRkxJTkU6CisJCWJmYV9zbV9zZXRfc3RhdGUodnBvcnQsIGJmYV9mY3NfdnBvcnRfc21fb2ZmbGluZSk7CisJCWJmYV9scHNfZGlzY2FyZCh2cG9ydC0+bHBzKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fUlNQX09LOgorCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX29ubGluZSk7CisJCWJmYV9mY3NfcG9ydF9vbmxpbmUoJnZwb3J0LT5scG9ydCk7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX1JTUF9FUlJPUjoKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV9mZGlzY19yZXRyeSk7CisJCWJmYV90aW1lcl9zdGFydChfX3Zwb3J0X2JmYSh2cG9ydCksICZ2cG9ydC0+dGltZXIsCisJCQkJYmZhX2Zjc192cG9ydF90aW1lb3V0LCB2cG9ydCwKKwkJCQlCRkFfRkNTX1JFVFJZX1RJTUVPVVQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9SU1BfRkFJTEVEOgorCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX29mZmxpbmUpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9SU1BfRFVQX1dXTjoKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV9lcnJvcik7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKy8qKgorICogRkRJU0MgYXR0ZW1wdCBmYWlsZWQgLSBhIHRpbWVyIGlzIGFjdGl2ZSB0byByZXRyeSBGRElTQy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfdnBvcnRfc21fZmRpc2NfcmV0cnkoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQkgICAgIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgX192cG9ydF9wd3duKHZwb3J0KSk7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fREVMRVRFOgorCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX2NsZWFudXApOworCQliZmFfdGltZXJfc3RvcCgmdnBvcnQtPnRpbWVyKTsKKwkJYmZhX2Zjc19wb3J0X2RlbGV0ZSgmdnBvcnQtPmxwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fT0ZGTElORToKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV9vZmZsaW5lKTsKKwkJYmZhX3RpbWVyX3N0b3AoJnZwb3J0LT50aW1lcik7CisJCWJyZWFrOworCisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX1RJTUVPVVQ6CisJCWJmYV9zbV9zZXRfc3RhdGUodnBvcnQsIGJmYV9mY3NfdnBvcnRfc21fZmRpc2MpOworCQl2cG9ydC0+dnBvcnRfc3RhdHMuZmRpc2NfcmV0cmllcysrOworCQl2cG9ydC0+ZmRpc2NfcmV0cmllcysrOworCQliZmFfZmNzX3Zwb3J0X2RvX2ZkaXNjKHZwb3J0KTsKKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQliZmFfYXNzZXJ0KDApOworCX0KK30KKworLyoqCisgKiBWcG9ydCBpcyBvbmxpbmUgKEZESVNDIGlzIGNvbXBsZXRlKS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfdnBvcnRfc21fb25saW5lKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0LAorCQkJZW51bSBiZmFfZmNzX3Zwb3J0X2V2ZW50IGV2ZW50KQoreworCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBfX3Zwb3J0X3B3d24odnBvcnQpKTsKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgZXZlbnQpOworCisJc3dpdGNoIChldmVudCkgeworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9ERUxFVEU6CisJCWJmYV9zbV9zZXRfc3RhdGUodnBvcnQsIGJmYV9mY3NfdnBvcnRfc21fZGVsZXRpbmcpOworCQliZmFfZmNzX3BvcnRfZGVsZXRlKCZ2cG9ydC0+bHBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX29mZmxpbmUpOworCQliZmFfbHBzX2Rpc2NhcmQodnBvcnQtPmxwcyk7CisJCWJmYV9mY3NfcG9ydF9vZmZsaW5lKCZ2cG9ydC0+bHBvcnQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIFZwb3J0IGlzIGJlaW5nIGRlbGV0ZWQgLSBhd2FpdGluZyBscG9ydCBkZWxldGUgY29tcGxldGlvbiB0byBzZW5kCisgKiBMT0dPIHRvIGZhYnJpYy4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfdnBvcnRfc21fZGVsZXRpbmcoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQkgIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgX192cG9ydF9wd3duKHZwb3J0KSk7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fREVMRVRFOgorCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9ERUxDT01QOgorCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX2xvZ28pOworCQliZmFfZmNzX3Zwb3J0X2RvX2xvZ28odnBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9PRkZMSU5FOgorCQliZmFfc21fc2V0X3N0YXRlKHZwb3J0LCBiZmFfZmNzX3Zwb3J0X3NtX2NsZWFudXApOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIEVycm9yIFN0YXRlLgorICogVGhpcyBzdGF0ZSB3aWxsIGJlIHNldCB3aGVuIHRoZSBWcG9ydCBDcmVhdGlvbiBmYWlscyBkdWUgdG8gZXJyb3JzIGxpa2UKKyAqIER1cCBXV04uIEluIHRoaXMgc3RhdGUgb25seSBvcGVyYXRpb24gYWxsb3dlZCBpcyBhIFZwb3J0IERlbGV0ZS4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfdnBvcnRfc21fZXJyb3Ioc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCSAgICAgICBlbnVtIGJmYV9mY3NfdnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIF9fdnBvcnRfcHd3bih2cG9ydCkpOworCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX0RFTEVURToKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV91bmluaXQpOworCQliZmFfZmNzX3Zwb3J0X2ZyZWUodnBvcnQpOworCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBldmVudCk7CisJfQorfQorCisvKioKKyAqIExwb3J0IGNsZWFudXAgaXMgaW4gcHJvZ3Jlc3Mgc2luY2UgdnBvcnQgaXMgYmVpbmcgZGVsZXRlZC4gRmFicmljIGlzCisgKiBvZmZsaW5lLCBzbyBubyBMT0dPIGlzIG5lZWRlZCB0byBjb21wbGV0ZSB2cG9ydCBkZWxldGlvbi4KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfdnBvcnRfc21fY2xlYW51cChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwKKwkJCSBlbnVtIGJmYV9mY3NfdnBvcnRfZXZlbnQgZXZlbnQpCit7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIF9fdnBvcnRfcHd3bih2cG9ydCkpOworCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBldmVudCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX0RFTENPTVA6CisJCWJmYV9zbV9zZXRfc3RhdGUodnBvcnQsIGJmYV9mY3NfdnBvcnRfc21fdW5pbml0KTsKKwkJYmZhX2Zjc192cG9ydF9mcmVlKHZwb3J0KTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fREVMRVRFOgorCQlicmVhazsKKworCWRlZmF1bHQ6CisJCWJmYV9hc3NlcnQoMCk7CisJfQorfQorCisvKioKKyAqIExPR08gaXMgc2VudCB0byBmYWJyaWMuIFZwb3J0IGRlbGV0ZSBpcyBpbiBwcm9ncmVzcy4gTHBvcnQgZGVsZXRlIGNsZWFudXAKKyAqIGlzIGRvbmUuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Zwb3J0X3NtX2xvZ28oc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCSAgICAgIGVudW0gYmZhX2Zjc192cG9ydF9ldmVudCBldmVudCkKK3sKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgX192cG9ydF9wd3duKHZwb3J0KSk7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIGV2ZW50KTsKKworCXN3aXRjaCAoZXZlbnQpIHsKKwljYXNlIEJGQV9GQ1NfVlBPUlRfU01fT0ZGTElORToKKwkJYmZhX2xwc19kaXNjYXJkKHZwb3J0LT5scHMpOworCQkvKgorCQkgKiAhISEgZmFsbCB0aHJvdWdoICEhIQorCQkgKi8KKworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9SU1BfT0s6CisJY2FzZSBCRkFfRkNTX1ZQT1JUX1NNX1JTUF9FUlJPUjoKKwkJYmZhX3NtX3NldF9zdGF0ZSh2cG9ydCwgYmZhX2Zjc192cG9ydF9zbV91bmluaXQpOworCQliZmFfZmNzX3Zwb3J0X2ZyZWUodnBvcnQpOworCQlicmVhazsKKworCWNhc2UgQkZBX0ZDU19WUE9SVF9TTV9ERUxFVEU6CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJYmZhX2Fzc2VydCgwKTsKKwl9Cit9CisKKworCisvKioKKyAqICBmY3NfdnBvcnRfcHJpdmF0ZSBGQ1MgdmlydHVhbCBwb3J0IHByaXZhdGUgZnVuY3Rpb25zCisgKi8KKworLyoqCisgKiBTZW5kIEFFTiBub3RpZmljYXRpb24KKyAqLworc3RhdGljIHZvaWQKK2JmYV9mY3NfdnBvcnRfYWVuX3Bvc3QoYmZhX2Zjc19scG9ydF90ICpwb3J0LCBlbnVtIGJmYV9scG9ydF9hZW5fZXZlbnQgZXZlbnQpCit7CisJdW5pb24gYmZhX2Flbl9kYXRhX3UgYWVuX2RhdGE7CisJc3RydWN0IGJmYV9sb2dfbW9kX3MgKmxvZ21vZCA9IHBvcnQtPmZjcy0+bG9nbTsKKwllbnVtIGJmYV9wb3J0X3JvbGUgcm9sZSA9IHBvcnQtPnBvcnRfY2ZnLnJvbGVzOworCXd3bl90ICAgICAgICAgICBscHd3biA9IGJmYV9mY3NfcG9ydF9nZXRfcHd3bihwb3J0KTsKKwljaGFyICAgICAgICAgICAgbHB3d25fcHRyW0JGQV9TVFJJTkdfMzJdOworCWNoYXIgICAgICAgICAgICpyb2xlX3N0cltCRkFfUE9SVF9ST0xFX0ZDUF9NQVggLyAyICsgMV0gPQorCQl7ICJJbml0aWF0b3IiLCAiVGFyZ2V0IiwgIklQRkMiIH07CisKKwl3d24yc3RyKGxwd3duX3B0ciwgbHB3d24pOworCisJYmZhX2Fzc2VydChyb2xlIDw9IEJGQV9QT1JUX1JPTEVfRkNQX01BWCk7CisKKwlzd2l0Y2ggKGV2ZW50KSB7CisJY2FzZSBCRkFfTFBPUlRfQUVOX05QSVZfRFVQX1dXTjoKKwkJYmZhX2xvZyhsb2dtb2QsIEJGQV9BRU5fTFBPUlRfTlBJVl9EVVBfV1dOLCBscHd3bl9wdHIsCisJCQlyb2xlX3N0cltyb2xlIC8gMl0pOworCQlicmVhazsKKwljYXNlIEJGQV9MUE9SVF9BRU5fTlBJVl9GQUJSSUNfTUFYOgorCQliZmFfbG9nKGxvZ21vZCwgQkZBX0FFTl9MUE9SVF9OUElWX0ZBQlJJQ19NQVgsIGxwd3duX3B0ciwKKwkJCXJvbGVfc3RyW3JvbGUgLyAyXSk7CisJCWJyZWFrOworCWNhc2UgQkZBX0xQT1JUX0FFTl9OUElWX1VOS05PV046CisJCWJmYV9sb2cobG9nbW9kLCBCRkFfQUVOX0xQT1JUX05QSVZfVU5LTk9XTiwgbHB3d25fcHRyLAorCQkJcm9sZV9zdHJbcm9sZSAvIDJdKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJlYWs7CisJfQorCisJYWVuX2RhdGEubHBvcnQudmZfaWQgPSBwb3J0LT5mYWJyaWMtPnZmX2lkOworCWFlbl9kYXRhLmxwb3J0LnJvbGVzID0gcm9sZTsKKwlhZW5fZGF0YS5scG9ydC5wcHd3biA9CisJCWJmYV9mY3NfcG9ydF9nZXRfcHd3bihiZmFfZmNzX2dldF9iYXNlX3BvcnQocG9ydC0+ZmNzKSk7CisJYWVuX2RhdGEubHBvcnQubHB3d24gPSBscHd3bjsKK30KKworLyoqCisgKiBUaGlzIHJvdXRpbmUgd2lsbCBiZSBjYWxsZWQgdG8gc2VuZCBhIEZESVNDIGNvbW1hbmQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Zwb3J0X2RvX2ZkaXNjKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0KQoreworCWJmYV9scHNfZmRpc2ModnBvcnQtPmxwcywgdnBvcnQsCisJCSAgICAgIGJmYV9wcG9ydF9nZXRfbWF4ZnJzaXplKF9fdnBvcnRfYmZhKHZwb3J0KSksCisJCSAgICAgIF9fdnBvcnRfcHd3bih2cG9ydCksIF9fdnBvcnRfbnd3bih2cG9ydCkpOworCXZwb3J0LT52cG9ydF9zdGF0cy5mZGlzY19zZW50Kys7Cit9CisKK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Zwb3J0X2ZkaXNjX3JlamVjdGVkKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0KQoreworCXU4ICAgICAgICAgbHNyanRfcnNuID0gYmZhX2xwc19nZXRfbHNyanRfcnNuKHZwb3J0LT5scHMpOworCXU4ICAgICAgICAgbHNyanRfZXhwbCA9IGJmYV9scHNfZ2V0X2xzcmp0X2V4cGwodnBvcnQtPmxwcyk7CisKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgbHNyanRfcnNuKTsKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgbHNyanRfZXhwbCk7CisKKwkvKgorCSAqIEZvciBjZXJ0YWluIHJlYXNvbiBjb2Rlcywgd2UgZG9uJ3Qgd2FudCB0byByZXRyeS4KKwkgKi8KKwlzd2l0Y2ggKGJmYV9scHNfZ2V0X2xzcmp0X2V4cGwodnBvcnQtPmxwcykpIHsKKwljYXNlIEZDX0xTX1JKVF9FWFBfSU5WX1BPUlRfTkFNRToJLyogYnkgYnJvY2FkZSAqLworCWNhc2UgRkNfTFNfUkpUX0VYUF9JTlZBTElEX05QT1JUX0lEOgkvKiBieSBDaXNjbyAqLworCQlpZiAodnBvcnQtPmZkaXNjX3JldHJpZXMgPCBCRkFfRkNTX1ZQT1JUX01BWF9SRVRSSUVTKQorCQkJYmZhX3NtX3NlbmRfZXZlbnQodnBvcnQsIEJGQV9GQ1NfVlBPUlRfU01fUlNQX0VSUk9SKTsKKwkJZWxzZSB7CisJCQliZmFfZmNzX3Zwb3J0X2Flbl9wb3N0KCZ2cG9ydC0+bHBvcnQsCisJCQkJCSAgICAgICBCRkFfTFBPUlRfQUVOX05QSVZfRFVQX1dXTik7CisJCQliZmFfc21fc2VuZF9ldmVudCh2cG9ydCwgQkZBX0ZDU19WUE9SVF9TTV9SU1BfRFVQX1dXTik7CisJCX0KKwkJYnJlYWs7CisKKwljYXNlIEZDX0xTX1JKVF9FWFBfSU5TVUZGX1JFUzoKKwkJLyoKKwkJICogVGhpcyBtZWFucyBtYXggbG9naW5zIHBlciBwb3J0L3N3aXRjaCBzZXR0aW5nIG9uIHRoZQorCQkgKiBzd2l0Y2ggd2FzIGV4Y2VlZGVkLgorCQkgKi8KKwkJaWYgKHZwb3J0LT5mZGlzY19yZXRyaWVzIDwgQkZBX0ZDU19WUE9SVF9NQVhfUkVUUklFUykKKwkJCWJmYV9zbV9zZW5kX2V2ZW50KHZwb3J0LCBCRkFfRkNTX1ZQT1JUX1NNX1JTUF9FUlJPUik7CisJCWVsc2UgeworCQkJYmZhX2Zjc192cG9ydF9hZW5fcG9zdCgmdnBvcnQtPmxwb3J0LAorCQkJCQkgICAgICAgQkZBX0xQT1JUX0FFTl9OUElWX0ZBQlJJQ19NQVgpOworCQkJYmZhX3NtX3NlbmRfZXZlbnQodnBvcnQsIEJGQV9GQ1NfVlBPUlRfU01fUlNQX0ZBSUxFRCk7CisJCX0KKwkJYnJlYWs7CisKKwlkZWZhdWx0OgorCQlpZiAodnBvcnQtPmZkaXNjX3JldHJpZXMgPT0gMCkJLyogUHJpbnQgb25seSBvbmNlICovCisJCQliZmFfZmNzX3Zwb3J0X2Flbl9wb3N0KCZ2cG9ydC0+bHBvcnQsCisJCQkJCSAgICAgICBCRkFfTFBPUlRfQUVOX05QSVZfVU5LTk9XTik7CisJCWJmYV9zbV9zZW5kX2V2ZW50KHZwb3J0LCBCRkFfRkNTX1ZQT1JUX1NNX1JTUF9FUlJPUik7CisJfQorfQorCisvKioKKyAqIAlDYWxsZWQgdG8gc2VuZCBhIGxvZ291dCB0byB0aGUgZmFicmljLiBVc2VkIHdoZW4gYSBWLVBvcnQgaXMKKyAqIAlkZWxldGVkL3N0b3BwZWQuCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Zwb3J0X2RvX2xvZ28oc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpCit7CisJYmZhX3RyYyhfX3Zwb3J0X2Zjcyh2cG9ydCksIF9fdnBvcnRfcHd3bih2cG9ydCkpOworCisJdnBvcnQtPnZwb3J0X3N0YXRzLmxvZ29fc2VudCsrOworCWJmYV9scHNfZmRpc2Nsb2dvKHZwb3J0LT5scHMpOworfQorCisvKioKKyAqICAgICBUaGlzIHJvdXRpbmUgd2lsbCBiZSBjYWxsZWQgYnkgYmZhX3RpbWVyIG9uIHRpbWVyIHRpbWVvdXRzLgorICoKKyAqIAlwYXJhbVtpbl0gCXZwb3J0IAkJLSBwb2ludGVyIHRvIGJmYV9mY3NfdnBvcnRfdC4KKyAqIAlwYXJhbVtvdXRdCXZwb3J0X3N0YXR1cyAJLSBwb2ludGVyIHRvIHJldHVybiB2cG9ydCBzdGF0dXMgaW4KKyAqCisgKiAJcmV0dXJuCisgKiAJCXZvaWQKKyAqCisqIAlTcGVjaWFsIENvbnNpZGVyYXRpb25zOgorICoKKyAqIAlub3RlCisgKi8KK3N0YXRpYyB2b2lkCitiZmFfZmNzX3Zwb3J0X3RpbWVvdXQodm9pZCAqdnBvcnRfYXJnKQoreworCXN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0ID0gKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKil2cG9ydF9hcmc7CisKKwl2cG9ydC0+dnBvcnRfc3RhdHMuZmRpc2NfdGltZW91dHMrKzsKKwliZmFfc21fc2VuZF9ldmVudCh2cG9ydCwgQkZBX0ZDU19WUE9SVF9TTV9USU1FT1VUKTsKK30KKworc3RhdGljIHZvaWQKK2JmYV9mY3NfdnBvcnRfZnJlZShzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCkKK3sKKwliZmFfZmNzX2ZhYnJpY19kZWx2cG9ydChfX3Zwb3J0X2ZhYnJpYyh2cG9ydCksIHZwb3J0KTsKKwliZmFfZmNiX3Zwb3J0X2RlbGV0ZSh2cG9ydC0+dnBvcnRfZHJ2KTsKKwliZmFfbHBzX2RlbGV0ZSh2cG9ydC0+bHBzKTsKK30KKworCisKKy8qKgorICogIGZjc192cG9ydF9wdWJsaWMgRkNTIHZpcnR1YWwgcG9ydCBwdWJsaWMgaW50ZXJmYWNlcworICovCisKKy8qKgorICogT25saW5lIG5vdGlmaWNhdGlvbiBmcm9tIGZhYnJpYyBTTS4KKyAqLwordm9pZAorYmZhX2Zjc192cG9ydF9vbmxpbmUoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpCit7CisJdnBvcnQtPnZwb3J0X3N0YXRzLmZhYl9vbmxpbmUrKzsKKwliZmFfc21fc2VuZF9ldmVudCh2cG9ydCwgQkZBX0ZDU19WUE9SVF9TTV9PTkxJTkUpOworfQorCisvKioKKyAqIE9mZmxpbmUgbm90aWZpY2F0aW9uIGZyb20gZmFicmljIFNNLgorICovCit2b2lkCitiZmFfZmNzX3Zwb3J0X29mZmxpbmUoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQpCit7CisJdnBvcnQtPnZwb3J0X3N0YXRzLmZhYl9vZmZsaW5lKys7CisJYmZhX3NtX3NlbmRfZXZlbnQodnBvcnQsIEJGQV9GQ1NfVlBPUlRfU01fT0ZGTElORSk7Cit9CisKKy8qKgorICogQ2xlYW51cCBub3RpZmljYXRpb24gZnJvbSBmYWJyaWMgU00gb24gbGluayB0aW1lciBleHBpcnkuCisgKi8KK3ZvaWQKK2JmYV9mY3NfdnBvcnRfY2xlYW51cChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCkKK3sKKwl2cG9ydC0+dnBvcnRfc3RhdHMuZmFiX2NsZWFudXArKzsKK30KKworLyoqCisgKiBEZWxldGUgY29tcGxldGlvbiBjYWxsYmFjayBmcm9tIGFzc29jaWF0ZWQgbHBvcnQKKyAqLwordm9pZAorYmZhX2Zjc192cG9ydF9kZWxldGVfY29tcChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudCh2cG9ydCwgQkZBX0ZDU19WUE9SVF9TTV9ERUxDT01QKTsKK30KKworLyoqCisgKiAgIE1vZHVsZSBpbml0aWFsaXphdGlvbgorICovCit2b2lkCitiZmFfZmNzX3Zwb3J0X21vZGluaXQoc3RydWN0IGJmYV9mY3NfcyAqZmNzKQoreworfQorCisvKioKKyAqICAgTW9kdWxlIGNsZWFudXAKKyAqLwordm9pZAorYmZhX2Zjc192cG9ydF9tb2RleGl0KHN0cnVjdCBiZmFfZmNzX3MgKmZjcykKK3sKKwliZmFfZmNzX21vZGV4aXRfY29tcChmY3MpOworfQorCit1MzIKK2JmYV9mY3NfdnBvcnRfZ2V0X21heChzdHJ1Y3QgYmZhX2Zjc19zICpmY3MpCit7CisJc3RydWN0IGJmYV9pb2NfYXR0cl9zIGlvY19hdHRyOworCisJYmZhX2dldF9hdHRyKGZjcy0+YmZhLCAmaW9jX2F0dHIpOworCisJaWYgKGlvY19hdHRyLnBjaV9hdHRyLmRldmljZV9pZCA9PSBCRkFfUENJX0RFVklDRV9JRF9DVCkKKwkJcmV0dXJuIChCRkFfRkNTX01BWF9WUE9SVFNfU1VQUF9DVCk7CisJZWxzZQorCQlyZXR1cm4gKEJGQV9GQ1NfTUFYX1ZQT1JUU19TVVBQX0NCKTsKK30KKworCisKKy8qKgorICogIGZjc192cG9ydF9hcGkgVmlydHVhbCBwb3J0IEFQSQorICovCisKKy8qKgorICogIAlVc2UgdGhpcyBmdW5jdGlvbiB0byBpbnN0YW50aWF0ZSBhIG5ldyBGQ1MgdnBvcnQgb2JqZWN0LiBUaGlzCisgKiAJZnVuY3Rpb24gd2lsbCBub3QgdHJpZ2dlciBhbnkgSFcgaW5pdGlhbGl6YXRpb24gcHJvY2VzcyAod2hpY2ggd2lsbCBiZQorICogCWRvbmUgaW4gdnBvcnRfc3RhcnQoKSBjYWxsKQorICoKKyAqIAlwYXJhbVtpbl0gdnBvcnQJLSAJcG9pbnRlciB0byBiZmFfZmNzX3Zwb3J0X3QuIFRoaXMgc3BhY2UKKyAqIAkJCQkJbmVlZHMgdG8gYmUgYWxsb2NhdGVkIGJ5IHRoZSBkcml2ZXIuCisgKiAJcGFyYW1baW5dIGZjcyAJCS0gCUZDUyBpbnN0YW5jZQorICogCXBhcmFtW2luXSB2cG9ydF9jZmcJLSAJdnBvcnQgY29uZmlndXJhdGlvbgorICogCXBhcmFtW2luXSB2Zl9pZCAgICAJLSAJVkZfSUQgaWYgdnBvcnQgaXMgY3JlYXRlZCB3aXRoaW4gYSBWRi4KKyAqICAgICAgICAgICAgICAgICAgICAgICAgICAJCUZDX1ZGX0lEX05VTEwgdG8gc3BlY2lmeSBiYXNlIGZhYnJpYy4KKyAqIAlwYXJhbVtpbl0gdnBvcnRfZHJ2IAktIAlPcGFxdWUgaGFuZGxlIGJhY2sgdG8gdGhlIGRyaXZlcidzIHZwb3J0CisgKiAJCQkJCXN0cnVjdHVyZQorICoKKyAqIAlyZXR2YWwgQkZBX1NUQVRVU19PSyAtIG9uIHN1Y2Nlc3MuCisgKiAJcmV0dmFsIEJGQV9TVEFUVVNfRkFJTEVEIC0gb24gZmFpbHVyZS4KKyAqLworYmZhX3N0YXR1c190CitiZmFfZmNzX3Zwb3J0X2NyZWF0ZShzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCwgc3RydWN0IGJmYV9mY3NfcyAqZmNzLAorCQkgICAgIHUxNiB2Zl9pZCwgc3RydWN0IGJmYV9wb3J0X2NmZ19zICp2cG9ydF9jZmcsCisJCSAgICAgc3RydWN0IGJmYWRfdnBvcnRfcyAqdnBvcnRfZHJ2KQoreworCWlmICh2cG9ydF9jZmctPnB3d24gPT0gMCkKKwkJcmV0dXJuIChCRkFfU1RBVFVTX0lOVkFMSURfV1dOKTsKKworCWlmIChiZmFfZmNzX3BvcnRfZ2V0X3B3d24oJmZjcy0+ZmFicmljLmJwb3J0KSA9PSB2cG9ydF9jZmctPnB3d24pCisJCXJldHVybiBCRkFfU1RBVFVTX1ZQT1JUX1dXTl9CUDsKKworCWlmIChiZmFfZmNzX3Zwb3J0X2xvb2t1cChmY3MsIHZmX2lkLCB2cG9ydF9jZmctPnB3d24pICE9IE5VTEwpCisJCXJldHVybiBCRkFfU1RBVFVTX1ZQT1JUX0VYSVNUUzsKKworCWlmIChiZmFfZmNzX2ZhYnJpY192cG9ydF9jb3VudCgmZmNzLT5mYWJyaWMpID09CisJICAgIGJmYV9mY3NfdnBvcnRfZ2V0X21heChmY3MpKQorCQlyZXR1cm4gQkZBX1NUQVRVU19WUE9SVF9NQVg7CisKKwl2cG9ydC0+bHBzID0gYmZhX2xwc19hbGxvYyhmY3MtPmJmYSk7CisJaWYgKCF2cG9ydC0+bHBzKQorCQlyZXR1cm4gQkZBX1NUQVRVU19WUE9SVF9NQVg7CisKKwl2cG9ydC0+dnBvcnRfZHJ2ID0gdnBvcnRfZHJ2OworCWJmYV9zbV9zZXRfc3RhdGUodnBvcnQsIGJmYV9mY3NfdnBvcnRfc21fdW5pbml0KTsKKworCWJmYV9mY3NfbHBvcnRfaW5pdCgmdnBvcnQtPmxwb3J0LCBmY3MsIHZmX2lkLCB2cG9ydF9jZmcsIHZwb3J0KTsKKworCWJmYV9zbV9zZW5kX2V2ZW50KHZwb3J0LCBCRkFfRkNTX1ZQT1JUX1NNX0NSRUFURSk7CisKKwlyZXR1cm4gQkZBX1NUQVRVU19PSzsKK30KKworLyoqCisgKiAgCVVzZSB0aGlzIGZ1bmN0aW9uIGluaXRpYWxpemUgdGhlIHZwb3J0LgorICoKKyAqICBAcGFyYW1baW5dIHZwb3J0IC0gcG9pbnRlciB0byBiZmFfZmNzX3Zwb3J0X3QuCisgKgorICogIEByZXR1cm5zIE5vbmUKKyAqLworYmZhX3N0YXR1c190CitiZmFfZmNzX3Zwb3J0X3N0YXJ0KHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0KQoreworCWJmYV9zbV9zZW5kX2V2ZW50KHZwb3J0LCBCRkFfRkNTX1ZQT1JUX1NNX1NUQVJUKTsKKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqICAJVXNlIHRoaXMgZnVuY3Rpb24gcXVpZXNlIHRoZSB2cG9ydCBvYmplY3QuIFRoaXMgZnVuY3Rpb24gd2lsbCByZXR1cm4KKyAqIAlpbW1lZGlhdGVseSwgd2hlbiB0aGUgdnBvcnQgaXMgYWN0dWFsbHkgc3RvcHBlZCwgdGhlCisgKiAJYmZhX2Rydl92cG9ydF9zdG9wX2NiKCkgd2lsbCBiZSBjYWxsZWQuCisgKgorICogCXBhcmFtW2luXSB2cG9ydCAtIHBvaW50ZXIgdG8gYmZhX2Zjc192cG9ydF90LgorICoKKyAqIAlyZXR1cm4gTm9uZQorICovCitiZmFfc3RhdHVzX3QKK2JmYV9mY3NfdnBvcnRfc3RvcChzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudCh2cG9ydCwgQkZBX0ZDU19WUE9SVF9TTV9TVE9QKTsKKworCXJldHVybiBCRkFfU1RBVFVTX09LOworfQorCisvKioKKyAqICAJVXNlIHRoaXMgZnVuY3Rpb24gdG8gZGVsZXRlIGEgdnBvcnQgb2JqZWN0LiBGYWJyaWMgb2JqZWN0IHNob3VsZAorICogCQliZSBzdG9wcGVkIGJlZm9yZSB0aGlzIGZ1bmN0aW9uIGNhbGwuCisgKgorICogCXBhcmFtW2luXSB2cG9ydCAtIHBvaW50ZXIgdG8gYmZhX2Zjc192cG9ydF90LgorICoKKyAqIAlyZXR1cm4gICAgIE5vbmUKKyAqLworYmZhX3N0YXR1c190CitiZmFfZmNzX3Zwb3J0X2RlbGV0ZShzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCkKK3sKKwliZmFfc21fc2VuZF9ldmVudCh2cG9ydCwgQkZBX0ZDU19WUE9SVF9TTV9ERUxFVEUpOworCisJcmV0dXJuIEJGQV9TVEFUVVNfT0s7Cit9CisKKy8qKgorICogIAlVc2UgdGhpcyBmdW5jdGlvbiB0byBnZXQgdnBvcnQncyBjdXJyZW50IHN0YXR1cyBpbmZvLgorICoKKyAqIAlwYXJhbVtpbl0gCXZwb3J0IAkJcG9pbnRlciB0byBiZmFfZmNzX3Zwb3J0X3QuCisgKiAJcGFyYW1bb3V0XQlhdHRyIAkJcG9pbnRlciB0byByZXR1cm4gdnBvcnQgYXR0cmlidXRlcworICoKKyAqIAlyZXR1cm4gTm9uZQorICovCit2b2lkCitiZmFfZmNzX3Zwb3J0X2dldF9hdHRyKHN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0LAorCQkgICAgICAgc3RydWN0IGJmYV92cG9ydF9hdHRyX3MgKmF0dHIpCit7CisJaWYgKHZwb3J0ID09IE5VTEwgfHwgYXR0ciA9PSBOVUxMKQorCQlyZXR1cm47CisKKwliZmFfb3NfbWVtc2V0KGF0dHIsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3Zwb3J0X2F0dHJfcykpOworCisJYmZhX2Zjc19wb3J0X2dldF9hdHRyKCZ2cG9ydC0+bHBvcnQsICZhdHRyLT5wb3J0X2F0dHIpOworCWF0dHItPnZwb3J0X3N0YXRlID0gYmZhX3NtX3RvX3N0YXRlKHZwb3J0X3NtX3RhYmxlLCB2cG9ydC0+c20pOworfQorCisvKioKKyAqICAJVXNlIHRoaXMgZnVuY3Rpb24gdG8gZ2V0IHZwb3J0J3Mgc3RhdGlzdGljcy4KKyAqCisgKiAJcGFyYW1baW5dIAl2cG9ydCAJCXBvaW50ZXIgdG8gYmZhX2Zjc192cG9ydF90LgorICogCXBhcmFtW291dF0Jc3RhdHMJCXBvaW50ZXIgdG8gcmV0dXJuIHZwb3J0IHN0YXRpc3RpY3MgaW4KKyAqCisgKiAJcmV0dXJuIE5vbmUKKyAqLwordm9pZAorYmZhX2Zjc192cG9ydF9nZXRfc3RhdHMoc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQsCisJCQlzdHJ1Y3QgYmZhX3Zwb3J0X3N0YXRzX3MgKnN0YXRzKQoreworCSpzdGF0cyA9IHZwb3J0LT52cG9ydF9zdGF0czsKK30KKworLyoqCisgKiAgCVVzZSB0aGlzIGZ1bmN0aW9uIHRvIGNsZWFyIHZwb3J0J3Mgc3RhdGlzdGljcy4KKyAqCisgKiAJcGFyYW1baW5dIAl2cG9ydCAJCXBvaW50ZXIgdG8gYmZhX2Zjc192cG9ydF90LgorICoKKyAqIAlyZXR1cm4gTm9uZQorICovCit2b2lkCitiZmFfZmNzX3Zwb3J0X2Nscl9zdGF0cyhzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydCkKK3sKKwliZmFfb3NfbWVtc2V0KCZ2cG9ydC0+dnBvcnRfc3RhdHMsIDAsIHNpemVvZihzdHJ1Y3QgYmZhX3Zwb3J0X3N0YXRzX3MpKTsKK30KKworLyoqCisgKiAgICAgIExvb2t1cCBhIHZpcnR1YWwgcG9ydC4gRXhjbHVkZXMgYmFzZSBwb3J0IGZyb20gbG9va3VwLgorICovCitzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICoKK2JmYV9mY3NfdnBvcnRfbG9va3VwKHN0cnVjdCBiZmFfZmNzX3MgKmZjcywgdTE2IHZmX2lkLCB3d25fdCB2cHd3bikKK3sKKwlzdHJ1Y3QgYmZhX2Zjc192cG9ydF9zICp2cG9ydDsKKwlzdHJ1Y3QgYmZhX2Zjc19mYWJyaWNfcyAqZmFicmljOworCisJYmZhX3RyYyhmY3MsIHZmX2lkKTsKKwliZmFfdHJjKGZjcywgdnB3d24pOworCisJZmFicmljID0gYmZhX2Zjc192Zl9sb29rdXAoZmNzLCB2Zl9pZCk7CisJaWYgKCFmYWJyaWMpIHsKKwkJYmZhX3RyYyhmY3MsIHZmX2lkKTsKKwkJcmV0dXJuIE5VTEw7CisJfQorCisJdnBvcnQgPSBiZmFfZmNzX2ZhYnJpY192cG9ydF9sb29rdXAoZmFicmljLCB2cHd3bik7CisJcmV0dXJuIHZwb3J0OworfQorCisvKioKKyAqIEZESVNDIFJlc3BvbnNlCisgKi8KK3ZvaWQKK2JmYV9jYl9scHNfZmRpc2NfY29tcCh2b2lkICpiZmFkLCB2b2lkICp1YXJnLCBiZmFfc3RhdHVzX3Qgc3RhdHVzKQoreworCXN0cnVjdCBiZmFfZmNzX3Zwb3J0X3MgKnZwb3J0ID0gdWFyZzsKKworCWJmYV90cmMoX192cG9ydF9mY3ModnBvcnQpLCBfX3Zwb3J0X3B3d24odnBvcnQpKTsKKwliZmFfdHJjKF9fdnBvcnRfZmNzKHZwb3J0KSwgc3RhdHVzKTsKKworCXN3aXRjaCAoc3RhdHVzKSB7CisJY2FzZSBCRkFfU1RBVFVTX09LOgorCQkvKgorCQkgKiBJbml0aWFsaWF6ZSB0aGUgVi1Qb3J0IGZpZWxkcworCQkgKi8KKwkJX192cG9ydF9mY2lkKHZwb3J0KSA9IGJmYV9scHNfZ2V0X3BpZCh2cG9ydC0+bHBzKTsKKwkJdnBvcnQtPnZwb3J0X3N0YXRzLmZkaXNjX2FjY2VwdHMrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQodnBvcnQsIEJGQV9GQ1NfVlBPUlRfU01fUlNQX09LKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9TVEFUVVNfSU5WQUxJRF9NQUM6CisJCS8qCisJCSAqIE9ubHkgZm9yIENOQQorCQkgKi8KKwkJdnBvcnQtPnZwb3J0X3N0YXRzLmZkaXNjX2FjY19iYWQrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQodnBvcnQsIEJGQV9GQ1NfVlBPUlRfU01fUlNQX0VSUk9SKTsKKworCQlicmVhazsKKworCWNhc2UgQkZBX1NUQVRVU19FUFJPVE9DT0w6CisJCXN3aXRjaCAoYmZhX2xwc19nZXRfZXh0c3RhdHVzKHZwb3J0LT5scHMpKSB7CisJCWNhc2UgQkZBX0VQUk9UT19CQURfQUNDRVBUOgorCQkJdnBvcnQtPnZwb3J0X3N0YXRzLmZkaXNjX2FjY19iYWQrKzsKKwkJCWJyZWFrOworCisJCWNhc2UgQkZBX0VQUk9UT19VTktOT1dOX1JTUDoKKwkJCXZwb3J0LT52cG9ydF9zdGF0cy5mZGlzY191bmtub3duX3JzcCsrOworCQkJYnJlYWs7CisKKwkJZGVmYXVsdDoKKwkJCWJyZWFrOworCQl9CisKKwkJYmZhX3NtX3NlbmRfZXZlbnQodnBvcnQsIEJGQV9GQ1NfVlBPUlRfU01fUlNQX0VSUk9SKTsKKwkJYnJlYWs7CisKKwljYXNlIEJGQV9TVEFUVVNfRkFCUklDX1JKVDoKKwkJdnBvcnQtPnZwb3J0X3N0YXRzLmZkaXNjX3JlamVjdHMrKzsKKwkJYmZhX2Zjc192cG9ydF9mZGlzY19yZWplY3RlZCh2cG9ydCk7CisJCWJyZWFrOworCisJZGVmYXVsdDoKKwkJdnBvcnQtPnZwb3J0X3N0YXRzLmZkaXNjX3JzcF9lcnIrKzsKKwkJYmZhX3NtX3NlbmRfZXZlbnQodnBvcnQsIEJGQV9GQ1NfVlBPUlRfU01fUlNQX0VSUk9SKTsKKwl9Cit9CisKKy8qKgorICogTE9HTyByZXNwb25zZQorICovCit2b2lkCitiZmFfY2JfbHBzX2ZkaXNjbG9nb19jb21wKHZvaWQgKmJmYWQsIHZvaWQgKnVhcmcpCit7CisJc3RydWN0IGJmYV9mY3NfdnBvcnRfcyAqdnBvcnQgPSB1YXJnOworCWJmYV9zbV9zZW5kX2V2ZW50KHZwb3J0LCBCRkFfRkNTX1ZQT1JUX1NNX1JTUF9PSyk7Cit9CisKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JueDJpL2JueDJpLmggYi9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmkuaAppbmRleCBkNzU3NmYyLi41ZWRkZTFhIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmkuaAorKysgYi9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmkuaApAQCAtMTAwLDYgKzEwMCw4IEBACiAjZGVmaW5lIENUWF9PRkZTRVQgCQkJMHgxMDAwMAogI2RlZmluZSBNQVhfQ0lEX0NOVAkJCTB4NDAwMAogCisjZGVmaW5lIEJOWDJJXzU3MFhfUEFHRV9TSVpFX0RFRkFVTFQJNDA5NgorCiAvKiA1NzA5IGNvbnRleHQgcmVnaXN0ZXJzICovCiAjZGVmaW5lIEJOWDJfTVFfQ09ORklHMgkJCTB4MDAwMDNkMDAKICNkZWZpbmUgQk5YMl9NUV9DT05GSUcyX0NPTlRfU1oJCSgweDdMPDw0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JueDJpL2JueDJpX2h3aS5jIGIvZHJpdmVycy9zY3NpL2JueDJpL2JueDJpX2h3aS5jCmluZGV4IDQxZTFiMGUuLjVjOGQ3NjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9ibngyaS9ibngyaV9od2kuYworKysgYi9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmlfaHdpLmMKQEAgLTIzODYsNyArMjM4Niw3IEBACiAJCWN0eF9zeiA9IChjb25maWcyICYgQk5YMl9NUV9DT05GSUcyX0NPTlRfU1opID4+IDM7CiAJCWlmIChjdHhfc3opCiAJCQlyZWdfb2ZmID0gQ1RYX09GRlNFVCArIE1BWF9DSURfQ05UICogTUJfS0VSTkVMX0NUWF9TSVpFCi0JCQkJICArIFBBR0VfU0laRSAqCisJCQkJICArIEJOWDJJXzU3MFhfUEFHRV9TSVpFX0RFRkFVTFQgKgogCQkJCSAgKCgoY2lkX251bSAtIGZpcnN0X2w0bDUpIC8gY3R4X3N6KSArIDI1Nik7CiAJCWVsc2UKIAkJCXJlZ19vZmYgPSBDVFhfT0ZGU0VUICsgKE1CX0tFUk5FTF9DVFhfU0laRSAqIGNpZF9udW0pOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2JueDJpL2JueDJpX2lzY3NpLmMgYi9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmlfaXNjc2kuYwppbmRleCA5YTdiYTcxLi5jYWZiODg4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmlfaXNjc2kuYworKysgYi9kcml2ZXJzL3Njc2kvYm54MmkvYm54MmlfaXNjc2kuYwpAQCAtMTI0Myw3ICsxMjQzLDcgQEAKIAkJY21kc19tYXggPSBCTlgySV9TUV9XUUVTX01JTjsKIAogCWNsc19zZXNzaW9uID0gaXNjc2lfc2Vzc2lvbl9zZXR1cCgmYm54MmlfaXNjc2lfdHJhbnNwb3J0LCBzaG9zdCwKLQkJCQkJICBjbWRzX21heCwgc2l6ZW9mKHN0cnVjdCBibngyaV9jbWQpLAorCQkJCQkgIGNtZHNfbWF4LCAwLCBzaXplb2Yoc3RydWN0IGJueDJpX2NtZCksCiAJCQkJCSAgaW5pdGlhbF9jbWRzbiwgSVNDU0lfTUFYX1RBUkdFVCk7CiAJaWYgKCFjbHNfc2Vzc2lvbikKIAkJcmV0dXJuIE5VTEw7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvY3hnYjNpL2N4Z2IzaV9pc2NzaS5jIGIvZHJpdmVycy9zY3NpL2N4Z2IzaS9jeGdiM2lfaXNjc2kuYwppbmRleCBjMzk5ZjQ4Li4yNjMxYmRkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvY3hnYjNpL2N4Z2IzaV9pc2NzaS5jCisrKyBiL2RyaXZlcnMvc2NzaS9jeGdiM2kvY3hnYjNpX2lzY3NpLmMKQEAgLTQyMiw3ICs0MjIsNyBAQAogCUJVR19PTihoYmEgIT0gaXNjc2lfaG9zdF9wcml2KHNob3N0KSk7CiAKIAljbHNfc2Vzc2lvbiA9IGlzY3NpX3Nlc3Npb25fc2V0dXAoJmN4Z2IzaV9pc2NzaV90cmFuc3BvcnQsIHNob3N0LAotCQkJCQkgIGNtZHNfbWF4LAorCQkJCQkgIGNtZHNfbWF4LCAwLAogCQkJCQkgIHNpemVvZihzdHJ1Y3QgaXNjc2lfdGNwX3Rhc2spICsKIAkJCQkJICBzaXplb2Yoc3RydWN0IGN4Z2IzaV90YXNrX2RhdGEpLAogCQkJCQkgIGluaXRpYWxfY21kc24sIElTQ1NJX01BWF9UQVJHRVQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2RldmljZV9oYW5kbGVyL3Njc2lfZGhfcmRhYy5jIGIvZHJpdmVycy9zY3NpL2RldmljZV9oYW5kbGVyL3Njc2lfZGhfcmRhYy5jCmluZGV4IDExYzg5MzEuLjI2ODE4OWQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9kZXZpY2VfaGFuZGxlci9zY3NpX2RoX3JkYWMuYworKysgYi9kcml2ZXJzL3Njc2kvZGV2aWNlX2hhbmRsZXIvc2NzaV9kaF9yZGFjLmMKQEAgLTUwMCw4ICs1MDAsNiBAQAogCWlmICghcmV0KQogCQlnb3RvIGRvbmU7CiAKLQllcnIgPSBTQ1NJX0RIX09LOwotCiAJc3dpdGNoIChzZW5zZV9oZHIuc2Vuc2Vfa2V5KSB7CiAJY2FzZSBOT19TRU5TRToKIAljYXNlIEFCT1JURURfQ09NTUFORDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9ocHRpb3AuYyBiL2RyaXZlcnMvc2NzaS9ocHRpb3AuYwppbmRleCBjNTk2YWI1Li5hMGU3ZTcxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvaHB0aW9wLmMKKysrIGIvZHJpdmVycy9zY3NpL2hwdGlvcC5jCkBAIC0xLDYgKzEsNiBAQAogLyoKICAqIEhpZ2hQb2ludCBSUjN4eHgvNHh4eCBjb250cm9sbGVyIGRyaXZlciBmb3IgTGludXgKLSAqIENvcHlyaWdodCAoQykgMjAwNi0yMDA3IEhpZ2hQb2ludCBUZWNobm9sb2dpZXMsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKyAqIENvcHlyaWdodCAoQykgMjAwNi0yMDA5IEhpZ2hQb2ludCBUZWNobm9sb2dpZXMsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC4KICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKQEAgLTQxLDcgKzQxLDcgQEAKIAogc3RhdGljIGNoYXIgZHJpdmVyX25hbWVbXSA9ICJocHRpb3AiOwogc3RhdGljIGNvbnN0IGNoYXIgZHJpdmVyX25hbWVfbG9uZ1tdID0gIlJvY2tldFJBSUQgM3h4eC80eHh4IENvbnRyb2xsZXIgZHJpdmVyIjsKLXN0YXRpYyBjb25zdCBjaGFyIGRyaXZlcl92ZXJbXSA9ICJ2MS4zICgwNzEyMDMpIjsKK3N0YXRpYyBjb25zdCBjaGFyIGRyaXZlcl92ZXJbXSA9ICJ2MS42ICgwOTA5MTApIjsKIAogc3RhdGljIGludCBpb3Bfc2VuZF9zeW5jX21zZyhzdHJ1Y3QgaHB0aW9wX2hiYSAqaGJhLCB1MzIgbXNnLCB1MzIgbWlsbGlzZWMpOwogc3RhdGljIHZvaWQgaHB0aW9wX2ZpbmlzaF9zY3NpX3JlcShzdHJ1Y3QgaHB0aW9wX2hiYSAqaGJhLCB1MzIgdGFnLApAQCAtMTE1LDkgKzExNSwxMyBAQAogc3RhdGljIGludCBpb3BfaW50cl9pdGwoc3RydWN0IGhwdGlvcF9oYmEgKmhiYSkKIHsKIAlzdHJ1Y3QgaHB0X2lvcG11X2l0bCBfX2lvbWVtICppb3AgPSBoYmEtPnUuaXRsLmlvcDsKKwl2b2lkIF9faW9tZW0gKnBseCA9IGhiYS0+dS5pdGwucGx4OwogCXUzMiBzdGF0dXM7CiAJaW50IHJldCA9IDA7CiAKKwlpZiAocGx4ICYmIHJlYWRsKHBseCArIDB4MTFDNUMpICYgMHhmKQorCQl3cml0ZWwoMSwgcGx4ICsgMHgxMUM2MCk7CisKIAlzdGF0dXMgPSByZWFkbCgmaW9wLT5vdXRib3VuZF9pbnRzdGF0dXMpOwogCiAJaWYgKHN0YXR1cyAmIElPUE1VX09VVEJPVU5EX0lOVF9NU0cwKSB7CkBAIC00NjAsMTUgKzQ2NCwyNSBAQAogCiBzdGF0aWMgaW50IGhwdGlvcF9tYXBfcGNpX2Jhcl9pdGwoc3RydWN0IGhwdGlvcF9oYmEgKmhiYSkKIHsKKwlzdHJ1Y3QgcGNpX2RldiAqcGNpZGV2ID0gaGJhLT5wY2lkZXY7CiAJaGJhLT51Lml0bC5pb3AgPSBocHRpb3BfbWFwX3BjaV9iYXIoaGJhLCAwKTsKLQlpZiAoaGJhLT51Lml0bC5pb3ApCi0JCXJldHVybiAwOwotCWVsc2UKKwlpZiAoaGJhLT51Lml0bC5pb3AgPT0gTlVMTCkKIAkJcmV0dXJuIC0xOworCWlmICgocGNpZGV2LT5kZXZpY2UgJiAweGZmMDApID09IDB4NDQwMCkgeworCQloYmEtPnUuaXRsLnBseCA9IGhiYS0+dS5pdGwuaW9wOworCQloYmEtPnUuaXRsLmlvcCA9IGhwdGlvcF9tYXBfcGNpX2JhcihoYmEsIDIpOworCQlpZiAoaGJhLT51Lml0bC5pb3AgPT0gTlVMTCkgeworCQkJaW91bm1hcChoYmEtPnUuaXRsLnBseCk7CisJCQlyZXR1cm4gLTE7CisJCX0KKwl9CisJcmV0dXJuIDA7CiB9CiAKIHN0YXRpYyB2b2lkIGhwdGlvcF91bm1hcF9wY2lfYmFyX2l0bChzdHJ1Y3QgaHB0aW9wX2hiYSAqaGJhKQogeworCWlmIChoYmEtPnUuaXRsLnBseCkKKwkJaW91bm1hcChoYmEtPnUuaXRsLnBseCk7CiAJaW91bm1hcChoYmEtPnUuaXRsLmlvcCk7CiB9CiAKQEAgLTEyMzksMjIgKzEyNTMsMjMgQEAKIHN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCBocHRpb3BfaWRfdGFibGVbXSA9IHsKIAl7IFBDSV9WREVWSUNFKFRUSSwgMHgzMjIwKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAogCXsgUENJX1ZERVZJQ0UoVFRJLCAweDMzMjApLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCi0JeyBQQ0lfVkRFVklDRShUVEksIDB4MzUyMCksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKLQl7IFBDSV9WREVWSUNFKFRUSSwgMHg0MzIwKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAorCXsgUENJX1ZERVZJQ0UoVFRJLCAweDM0MTApLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCiAJeyBQQ0lfVkRFVklDRShUVEksIDB4MzUxMCksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKIAl7IFBDSV9WREVWSUNFKFRUSSwgMHgzNTExKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAorCXsgUENJX1ZERVZJQ0UoVFRJLCAweDM1MjApLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCiAJeyBQQ0lfVkRFVklDRShUVEksIDB4MzUyMSksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKIAl7IFBDSV9WREVWSUNFKFRUSSwgMHgzNTIyKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAotCXsgUENJX1ZERVZJQ0UoVFRJLCAweDM0MTApLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCi0JeyBQQ0lfVkRFVklDRShUVEksIDB4MzU0MCksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKIAl7IFBDSV9WREVWSUNFKFRUSSwgMHgzNTMwKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAorCXsgUENJX1ZERVZJQ0UoVFRJLCAweDM1NDApLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCiAJeyBQQ0lfVkRFVklDRShUVEksIDB4MzU2MCksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKLQl7IFBDSV9WREVWSUNFKFRUSSwgMHg0MzIyKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAotCXsgUENJX1ZERVZJQ0UoVFRJLCAweDQzMjEpLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCiAJeyBQQ0lfVkRFVklDRShUVEksIDB4NDIxMCksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKIAl7IFBDSV9WREVWSUNFKFRUSSwgMHg0MjExKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAogCXsgUENJX1ZERVZJQ0UoVFRJLCAweDQzMTApLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCiAJeyBQQ0lfVkRFVklDRShUVEksIDB4NDMxMSksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKKwl7IFBDSV9WREVWSUNFKFRUSSwgMHg0MzIwKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAorCXsgUENJX1ZERVZJQ0UoVFRJLCAweDQzMjEpLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9pdGxfb3BzIH0sCisJeyBQQ0lfVkRFVklDRShUVEksIDB4NDMyMiksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX2l0bF9vcHMgfSwKKwl7IFBDSV9WREVWSUNFKFRUSSwgMHg0NDAwKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfaXRsX29wcyB9LAogCXsgUENJX1ZERVZJQ0UoVFRJLCAweDMxMjApLCAoa2VybmVsX3Vsb25nX3QpJmhwdGlvcF9tdl9vcHMgfSwKIAl7IFBDSV9WREVWSUNFKFRUSSwgMHgzMTIyKSwgKGtlcm5lbF91bG9uZ190KSZocHRpb3BfbXZfb3BzIH0sCiAJeyBQQ0lfVkRFVklDRShUVEksIDB4MzAyMCksIChrZXJuZWxfdWxvbmdfdCkmaHB0aW9wX212X29wcyB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2hwdGlvcC5oIGIvZHJpdmVycy9zY3NpL2hwdGlvcC5oCmluZGV4IGEwMjg5ZjIuLjBiODcxYzAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9ocHRpb3AuaAorKysgYi9kcml2ZXJzL3Njc2kvaHB0aW9wLmgKQEAgLTEsNiArMSw2IEBACiAvKgogICogSGlnaFBvaW50IFJSM3h4eC80eHh4IGNvbnRyb2xsZXIgZHJpdmVyIGZvciBMaW51eAotICogQ29weXJpZ2h0IChDKSAyMDA2LTIwMDcgSGlnaFBvaW50IFRlY2hub2xvZ2llcywgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA2LTIwMDkgSGlnaFBvaW50IFRlY2hub2xvZ2llcywgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLgogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAgKiBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQpAQCAtMjI4LDYgKzIyOCw3IEBACiAJdW5pb24gewogCQlzdHJ1Y3QgewogCQkJc3RydWN0IGhwdF9pb3BtdV9pdGwgX19pb21lbSAqaW9wOworCQkJdm9pZCBfX2lvbWVtICpwbHg7CiAJCX0gaXRsOwogCQlzdHJ1Y3QgewogCQkJc3RydWN0IGhwdF9pb3Btdl9yZWdzICpyZWdzOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL2lzY3NpX3RjcC5jIGIvZHJpdmVycy9zY3NpL2lzY3NpX3RjcC5jCmluZGV4IDJiMWI4MzQuLmVkYzQ5Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9pc2NzaV90Y3AuYworKysgYi9kcml2ZXJzL3Njc2kvaXNjc2lfdGNwLmMKQEAgLTgxMSw3ICs4MTEsNyBAQAogCQlnb3RvIGZyZWVfaG9zdDsKIAogCWNsc19zZXNzaW9uID0gaXNjc2lfc2Vzc2lvbl9zZXR1cCgmaXNjc2lfc3dfdGNwX3RyYW5zcG9ydCwgc2hvc3QsCi0JCQkJCSAgY21kc19tYXgsCisJCQkJCSAgY21kc19tYXgsIDAsCiAJCQkJCSAgc2l6ZW9mKHN0cnVjdCBpc2NzaV90Y3BfdGFzaykgKwogCQkJCQkgIHNpemVvZihzdHJ1Y3QgaXNjc2lfc3dfdGNwX2hkcmJ1ZiksCiAJCQkJCSAgaW5pdGlhbF9jbWRzbiwgMCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbGliaXNjc2kuYyBiL2RyaXZlcnMvc2NzaS9saWJpc2NzaS5jCmluZGV4IDhkYzczYzQuLmYxYTQyNDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9saWJpc2NzaS5jCisrKyBiL2RyaXZlcnMvc2NzaS9saWJpc2NzaS5jCkBAIC0yNDM2LDcgKzI0MzYsNyBAQAogICovCiBzdHJ1Y3QgaXNjc2lfY2xzX3Nlc3Npb24gKgogaXNjc2lfc2Vzc2lvbl9zZXR1cChzdHJ1Y3QgaXNjc2lfdHJhbnNwb3J0ICppc2NzaXQsIHN0cnVjdCBTY3NpX0hvc3QgKnNob3N0LAotCQkgICAgdWludDE2X3QgY21kc19tYXgsIGludCBjbWRfdGFza19zaXplLAorCQkgICAgdWludDE2X3QgY21kc19tYXgsIGludCBkZF9zaXplLCBpbnQgY21kX3Rhc2tfc2l6ZSwKIAkJICAgIHVpbnQzMl90IGluaXRpYWxfY21kc24sIHVuc2lnbmVkIGludCBpZCkKIHsKIAlzdHJ1Y3QgaXNjc2lfaG9zdCAqaWhvc3QgPSBzaG9zdF9wcml2KHNob3N0KTsKQEAgLTI0ODYsNyArMjQ4Niw4IEBACiAJc2NzaV9jbWRzID0gdG90YWxfY21kcyAtIElTQ1NJX01HTVRfQ01EU19NQVg7CiAKIAljbHNfc2Vzc2lvbiA9IGlzY3NpX2FsbG9jX3Nlc3Npb24oc2hvc3QsIGlzY3NpdCwKLQkJCQkJICBzaXplb2Yoc3RydWN0IGlzY3NpX3Nlc3Npb24pKTsKKwkJCQkJICBzaXplb2Yoc3RydWN0IGlzY3NpX3Nlc3Npb24pICsKKwkJCQkJICBkZF9zaXplKTsKIAlpZiAoIWNsc19zZXNzaW9uKQogCQlnb3RvIGRlY19zZXNzaW9uX2NvdW50OwogCXNlc3Npb24gPSBjbHNfc2Vzc2lvbi0+ZGRfZGF0YTsKQEAgLTI1MDMsNiArMjUwNCw3IEBACiAJc2Vzc2lvbi0+bWF4X2NtZHNuID0gaW5pdGlhbF9jbWRzbiArIDE7CiAJc2Vzc2lvbi0+bWF4X3IydCA9IDE7CiAJc2Vzc2lvbi0+dHQgPSBpc2NzaXQ7CisJc2Vzc2lvbi0+ZGRfZGF0YSA9IGNsc19zZXNzaW9uLT5kZF9kYXRhICsgc2l6ZW9mKCpzZXNzaW9uKTsKIAltdXRleF9pbml0KCZzZXNzaW9uLT5laF9tdXRleCk7CiAJc3Bpbl9sb2NrX2luaXQoJnNlc3Npb24tPmxvY2spOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbHBmYy9scGZjX3Njc2kuYyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5jCmluZGV4IDYxZDA4OTcuLmM4OGY1OWYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5jCisrKyBiL2RyaXZlcnMvc2NzaS9scGZjL2xwZmNfc2NzaS5jCkBAIC01Niw4ICs1Niw2IEBACiAJIlNDU0lfUFJPVF9XUklURV9JTlNFUlQiLAogCSJTQ1NJX1BST1RfUkVBRF9QQVNTIiwKIAkiU0NTSV9QUk9UX1dSSVRFX1BBU1MiLAotCSJTQ1NJX1BST1RfUkVBRF9DT05WRVJUIiwKLQkiU0NTSV9QUk9UX1dSSVRFX0NPTlZFUlQiCiB9Owogc3RhdGljIHZvaWQKIGxwZmNfcmVsZWFzZV9zY3NpX2J1Zl9zNChzdHJ1Y3QgbHBmY19oYmEgKnBoYmEsIHN0cnVjdCBscGZjX3Njc2lfYnVmICpwc2IpOwpAQCAtMTEzMSwxMyArMTEyOSwxMSBAQAogCQkJcmV0X3Byb2YgPSBMUEZDX1BST0ZfQTE7CiAJCQlicmVhazsKIAotCQljYXNlIFNDU0lfUFJPVF9SRUFEX0NPTlZFUlQ6Ci0JCWNhc2UgU0NTSV9QUk9UX1dSSVRFX0NPTlZFUlQ6CisJCWNhc2UgU0NTSV9QUk9UX1JFQURfUEFTUzoKKwkJY2FzZSBTQ1NJX1BST1RfV1JJVEVfUEFTUzoKIAkJCXJldF9wcm9mID0gTFBGQ19QUk9GX0FTVDE7CiAJCQlicmVhazsKIAotCQljYXNlIFNDU0lfUFJPVF9SRUFEX1BBU1M6Ci0JCWNhc2UgU0NTSV9QUk9UX1dSSVRFX1BBU1M6CiAJCWNhc2UgU0NTSV9QUk9UX05PUk1BTDoKIAkJZGVmYXVsdDoKIAkJCXByaW50ayhLRVJOX0VSUiAiQmFkIG9wL2d1YXJkOiVkLyVkIGNvbWJpbmF0aW9uXG4iLApAQCAtMTE1Nyw4ICsxMTUzLDYgQEAKIAkJCXJldF9wcm9mID0gTFBGQ19QUk9GX0MxOwogCQkJYnJlYWs7CiAKLQkJY2FzZSBTQ1NJX1BST1RfUkVBRF9DT05WRVJUOgotCQljYXNlIFNDU0lfUFJPVF9XUklURV9DT05WRVJUOgogCQljYXNlIFNDU0lfUFJPVF9SRUFEX0lOU0VSVDoKIAkJY2FzZSBTQ1NJX1BST1RfV1JJVEVfU1RSSVA6CiAJCWNhc2UgU0NTSV9QUk9UX05PUk1BTDoKQEAgLTEyMDksOCArMTIwMyw3IEBACiAJc3RhdGljIGludCBjbnQ7CiAKIAlpZiAocHJvdGNudCAmJiAob3AgPT0gU0NTSV9QUk9UX1dSSVRFX1NUUklQIHx8Ci0JCQkJb3AgPT0gU0NTSV9QUk9UX1dSSVRFX1BBU1MgfHwKLQkJCQlvcCA9PSBTQ1NJX1BST1RfV1JJVEVfQ09OVkVSVCkpIHsKKwkJCQlvcCA9PSBTQ1NJX1BST1RfV1JJVEVfUEFTUykpIHsKIAogCQljbnQrKzsKIAkJc3B0ID0gcGFnZV9hZGRyZXNzKHNnX3BhZ2Uoc2NzaV9wcm90X3NnbGlzdChzYykpKSArCkBAIC0xNTAxLDggKzE0OTQsNiBAQAogCWNhc2UgU0NTSV9QUk9UX1dSSVRFX1NUUklQOgogCWNhc2UgU0NTSV9QUk9UX1JFQURfUEFTUzoKIAljYXNlIFNDU0lfUFJPVF9XUklURV9QQVNTOgotCWNhc2UgU0NTSV9QUk9UX1dSSVRFX0NPTlZFUlQ6Ci0JY2FzZSBTQ1NJX1BST1RfUkVBRF9DT05WRVJUOgogCQlyZXQgPSBMUEZDX1BHX1RZUEVfRElGX0JVRjsKIAkJYnJlYWs7CiAJZGVmYXVsdDoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL0tjb25maWcgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9LY29uZmlnCmluZGV4IDRhODY4NTUuLjcwYzRjMjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL0tjb25maWcKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvS2NvbmZpZwpAQCAtMiw3ICsyLDcgQEAKICMgS2VybmVsIGNvbmZpZ3VyYXRpb24gZmlsZSBmb3IgdGhlIE1QVDJTQVMKICMKICMgVGhpcyBjb2RlIGlzIGJhc2VkIG9uIGRyaXZlcnMvc2NzaS9tcHQyc2FzL0tjb25maWcKLSMgQ29weXJpZ2h0IChDKSAyMDA3LTIwMDggIExTSSBDb3Jwb3JhdGlvbgorIyBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOSAgTFNJIENvcnBvcmF0aW9uCiAjICAobWFpbHRvOkRMLU1QVEZ1c2lvbkxpbnV4QGxzaS5jb20pCiAKICMgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTIuaCBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyLmgKaW5kZXggN2JiMmVjZS4uZjlmNmMwOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTIuaAorKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcGkvbXBpMi5oCkBAIC04LDcgKzgsNyBAQAogICogICAgICAgICAgICAgICAgICBzY2F0dGVyL2dhdGhlciBmb3JtYXRzLgogICogIENyZWF0aW9uIERhdGU6ICBKdW5lIDIxLCAyMDA2CiAgKgotICogIG1waTIuaCBWZXJzaW9uOiAgMDIuMDAuMTEKKyAqICBtcGkyLmggVmVyc2lvbjogIDAyLjAwLjEyCiAgKgogICogIFZlcnNpb24gSGlzdG9yeQogICogIC0tLS0tLS0tLS0tLS0tLQpAQCAtNDUsNiArNDUsMTMgQEAKICAqICAxMC0wMi0wOCAgMDIuMDAuMTAgIEJ1bXBlZCBNUEkyX0hFQURFUl9WRVJTSU9OX1VOSVQuCiAgKiAgICAgICAgICAgICAgICAgICAgICBNb3ZlZCBMVU4gZmllbGQgZGVmaW5lcyBmcm9tIG1waTJfaW5pdC5oLgogICogIDAxLTE5LTA5ICAwMi4wMC4xMSAgQnVtcGVkIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVC4KKyAqICAwNS0wNi0wOSAgMDIuMDAuMTIgIEJ1bXBlZCBNUEkyX0hFQURFUl9WRVJTSU9OX1VOSVQuCisgKiAgICAgICAgICAgICAgICAgICAgICBJbiBhbGwgcmVxdWVzdCBhbmQgcmVwbHkgZGVzY3JpcHRvcnMsIHJlcGxhY2VkIFZGX0lECisgKiAgICAgICAgICAgICAgICAgICAgICBmaWVsZCB3aXRoIE1TSXhJbmRleCBmaWVsZC4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgRGV2SGFuZGxlIGZpZWxkIGZyb20KKyAqICAgICAgICAgICAgICAgICAgICAgIE1QSTJfU0NTSV9JT19TVUNDRVNTX1JFUExZX0RFU0NSSVBUT1IgYW5kIG1hZGUgdGhvc2UKKyAqICAgICAgICAgICAgICAgICAgICAgIGJ5dGVzIHJlc2VydmVkLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgUkFJRCBBY2NlbGVyYXRvciBmdW5jdGlvbmFsaXR5LgogICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKi8KIApAQCAtNzAsNyArNzcsNyBAQAogI2RlZmluZSBNUEkyX1ZFUlNJT05fMDJfMDAgICAgICAgICAgICAgICAgICAoMHgwMjAwKQogCiAvKiB2ZXJzaW9uaW5nIGZvciB0aGlzIE1QSSBoZWFkZXIgc2V0ICovCi0jZGVmaW5lIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVCAgICAgICAgICAgICgweDBCKQorI2RlZmluZSBNUEkyX0hFQURFUl9WRVJTSU9OX1VOSVQgICAgICAgICAgICAoMHgwQykKICNkZWZpbmUgTVBJMl9IRUFERVJfVkVSU0lPTl9ERVYgICAgICAgICAgICAgKDB4MDApCiAjZGVmaW5lIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVF9NQVNLICAgICAgICgweEZGMDApCiAjZGVmaW5lIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVF9TSElGVCAgICAgICg4KQpAQCAtMjU3LDcgKzI2NCw3IEBACiB0eXBlZGVmIHN0cnVjdCBfTVBJMl9ERUZBVUxUX1JFUVVFU1RfREVTQ1JJUFRPUgogewogICAgIFU4ICAgICAgICAgICAgICBSZXF1ZXN0RmxhZ3M7ICAgICAgICAgICAgICAgLyogMHgwMCAqLwotICAgIFU4ICAgICAgICAgICAgICBWRl9JRDsgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLworICAgIFU4ICAgICAgICAgICAgICBNU0l4SW5kZXg7ICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLwogICAgIFUxNiAgICAgICAgICAgICBTTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMiAqLwogICAgIFUxNiAgICAgICAgICAgICBMTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwNCAqLwogICAgIFUxNiAgICAgICAgICAgICBEZXNjcmlwdG9yVHlwZURlcGVuZGVudDsgICAgLyogMHgwNiAqLwpAQCAtMjcxLDYgKzI3OCw3IEBACiAjZGVmaW5lIE1QSTJfUkVRX0RFU0NSSVBUX0ZMQUdTX1NDU0lfVEFSR0VUICAgICAgICAgICAgICgweDAyKQogI2RlZmluZSBNUEkyX1JFUV9ERVNDUklQVF9GTEFHU19ISUdIX1BSSU9SSVRZICAgICAgICAgICAoMHgwNikKICNkZWZpbmUgTVBJMl9SRVFfREVTQ1JJUFRfRkxBR1NfREVGQVVMVF9UWVBFICAgICAgICAgICAgKDB4MDgpCisjZGVmaW5lIE1QSTJfUkVRX0RFU0NSSVBUX0ZMQUdTX1JBSURfQUNDRUxFUkFUT1IgICAgICAgICgweDBBKQogCiAjZGVmaW5lIE1QSTJfUkVRX0RFU0NSSVBUX0ZMQUdTX0lPQ19GSUZPX01BUktFUiAoMHgwMSkKIApAQCAtMjc5LDcgKzI4Nyw3IEBACiB0eXBlZGVmIHN0cnVjdCBfTVBJMl9ISUdIX1BSSU9SSVRZX1JFUVVFU1RfREVTQ1JJUFRPUgogewogICAgIFU4ICAgICAgICAgICAgICBSZXF1ZXN0RmxhZ3M7ICAgICAgICAgICAgICAgLyogMHgwMCAqLwotICAgIFU4ICAgICAgICAgICAgICBWRl9JRDsgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLworICAgIFU4ICAgICAgICAgICAgICBNU0l4SW5kZXg7ICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLwogICAgIFUxNiAgICAgICAgICAgICBTTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMiAqLwogICAgIFUxNiAgICAgICAgICAgICBMTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwNCAqLwogICAgIFUxNiAgICAgICAgICAgICBSZXNlcnZlZDE7ICAgICAgICAgICAgICAgICAgLyogMHgwNiAqLwpAQCAtMjkzLDcgKzMwMSw3IEBACiB0eXBlZGVmIHN0cnVjdCBfTVBJMl9TQ1NJX0lPX1JFUVVFU1RfREVTQ1JJUFRPUgogewogICAgIFU4ICAgICAgICAgICAgICBSZXF1ZXN0RmxhZ3M7ICAgICAgICAgICAgICAgLyogMHgwMCAqLwotICAgIFU4ICAgICAgICAgICAgICBWRl9JRDsgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLworICAgIFU4ICAgICAgICAgICAgICBNU0l4SW5kZXg7ICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLwogICAgIFUxNiAgICAgICAgICAgICBTTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMiAqLwogICAgIFUxNiAgICAgICAgICAgICBMTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwNCAqLwogICAgIFUxNiAgICAgICAgICAgICBEZXZIYW5kbGU7ICAgICAgICAgICAgICAgICAgLyogMHgwNiAqLwpAQCAtMzA2LDcgKzMxNCw3IEBACiB0eXBlZGVmIHN0cnVjdCBfTVBJMl9TQ1NJX1RBUkdFVF9SRVFVRVNUX0RFU0NSSVBUT1IKIHsKICAgICBVOCAgICAgICAgICAgICAgUmVxdWVzdEZsYWdzOyAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KLSAgICBVOCAgICAgICAgICAgICAgVkZfSUQ7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KKyAgICBVOCAgICAgICAgICAgICAgTVNJeEluZGV4OyAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KICAgICBVMTYgICAgICAgICAgICAgU01JRDsgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KICAgICBVMTYgICAgICAgICAgICAgTE1JRDsgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDQgKi8KICAgICBVMTYgICAgICAgICAgICAgSW9JbmRleDsgICAgICAgICAgICAgICAgICAgIC8qIDB4MDYgKi8KQEAgLTMxNSwxNCArMzIzLDI5IEBACiAgIE1waTJTQ1NJVGFyZ2V0UmVxdWVzdERlc2NyaXB0b3JfdCwKICAgTVBJMl9QT0lOVEVSIHBNcGkyU0NTSVRhcmdldFJlcXVlc3REZXNjcmlwdG9yX3Q7CiAKKworLyogUkFJRCBBY2NlbGVyYXRvciBSZXF1ZXN0IERlc2NyaXB0b3IgKi8KK3R5cGVkZWYgc3RydWN0IF9NUEkyX1JBSURfQUNDRUxfUkVRVUVTVF9ERVNDUklQVE9SIHsKKyAgICBVOCAgICAgICAgICAgICAgUmVxdWVzdEZsYWdzOyAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KKyAgICBVOCAgICAgICAgICAgICAgTVNJeEluZGV4OyAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KKyAgICBVMTYgICAgICAgICAgICAgU01JRDsgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KKyAgICBVMTYgICAgICAgICAgICAgTE1JRDsgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDQgKi8KKyAgICBVMTYgICAgICAgICAgICAgUmVzZXJ2ZWQ7ICAgICAgICAgICAgICAgICAgIC8qIDB4MDYgKi8KK30gTVBJMl9SQUlEX0FDQ0VMX1JFUVVFU1RfREVTQ1JJUFRPUiwKKyAgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1JBSURfQUNDRUxfUkVRVUVTVF9ERVNDUklQVE9SLAorICBNcGkyUkFJREFjY2VsZXJhdG9yUmVxdWVzdERlc2NyaXB0b3JfdCwKKyAgTVBJMl9QT0lOVEVSIHBNcGkyUkFJREFjY2VsZXJhdG9yUmVxdWVzdERlc2NyaXB0b3JfdDsKKworCiAvKiB1bmlvbiBvZiBSZXF1ZXN0IERlc2NyaXB0b3JzICovCiB0eXBlZGVmIHVuaW9uIF9NUEkyX1JFUVVFU1RfREVTQ1JJUFRPUl9VTklPTgogewotICAgIE1QSTJfREVGQVVMVF9SRVFVRVNUX0RFU0NSSVBUT1IgICAgICAgICBEZWZhdWx0OwotICAgIE1QSTJfSElHSF9QUklPUklUWV9SRVFVRVNUX0RFU0NSSVBUT1IgICBIaWdoUHJpb3JpdHk7Ci0gICAgTVBJMl9TQ1NJX0lPX1JFUVVFU1RfREVTQ1JJUFRPUiAgICAgICAgIFNDU0lJTzsKLSAgICBNUEkyX1NDU0lfVEFSR0VUX1JFUVVFU1RfREVTQ1JJUFRPUiAgICAgU0NTSVRhcmdldDsKLSAgICBVNjQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV29yZHM7CisgICAgTVBJMl9ERUZBVUxUX1JFUVVFU1RfREVTQ1JJUFRPUiAgICAgICAgICAgICBEZWZhdWx0OworICAgIE1QSTJfSElHSF9QUklPUklUWV9SRVFVRVNUX0RFU0NSSVBUT1IgICAgICAgSGlnaFByaW9yaXR5OworICAgIE1QSTJfU0NTSV9JT19SRVFVRVNUX0RFU0NSSVBUT1IgICAgICAgICAgICAgU0NTSUlPOworICAgIE1QSTJfU0NTSV9UQVJHRVRfUkVRVUVTVF9ERVNDUklQVE9SICAgICAgICAgU0NTSVRhcmdldDsKKyAgICBNUEkyX1JBSURfQUNDRUxfUkVRVUVTVF9ERVNDUklQVE9SICAgICAgICAgIFJBSURBY2NlbGVyYXRvcjsKKyAgICBVNjQgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdvcmRzOwogfSBNUEkyX1JFUVVFU1RfREVTQ1JJUFRPUl9VTklPTiwgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1JFUVVFU1RfREVTQ1JJUFRPUl9VTklPTiwKICAgTXBpMlJlcXVlc3REZXNjcmlwdG9yVW5pb25fdCwgTVBJMl9QT0lOVEVSIHBNcGkyUmVxdWVzdERlc2NyaXB0b3JVbmlvbl90OwogCkBAIC0zMzMsMTkgKzM1NiwyMCBAQAogdHlwZWRlZiBzdHJ1Y3QgX01QSTJfREVGQVVMVF9SRVBMWV9ERVNDUklQVE9SCiB7CiAgICAgVTggICAgICAgICAgICAgIFJlcGx5RmxhZ3M7ICAgICAgICAgICAgICAgICAvKiAweDAwICovCi0gICAgVTggICAgICAgICAgICAgIFZGX0lEOyAgICAgICAgICAgICAgICAgICAgICAvKiAweDAxICovCisgICAgVTggICAgICAgICAgICAgIE1TSXhJbmRleDsgICAgICAgICAgICAgICAgICAvKiAweDAxICovCiAgICAgVTE2ICAgICAgICAgICAgIERlc2NyaXB0b3JUeXBlRGVwZW5kZW50MTsgICAvKiAweDAyICovCiAgICAgVTMyICAgICAgICAgICAgIERlc2NyaXB0b3JUeXBlRGVwZW5kZW50MjsgICAvKiAweDA0ICovCiB9IE1QSTJfREVGQVVMVF9SRVBMWV9ERVNDUklQVE9SLCBNUEkyX1BPSU5URVIgUFRSX01QSTJfREVGQVVMVF9SRVBMWV9ERVNDUklQVE9SLAogICBNcGkyRGVmYXVsdFJlcGx5RGVzY3JpcHRvcl90LCBNUEkyX1BPSU5URVIgcE1waTJEZWZhdWx0UmVwbHlEZXNjcmlwdG9yX3Q7CiAKIC8qIGRlZmluZXMgZm9yIHRoZSBSZXBseUZsYWdzIGZpZWxkICovCi0jZGVmaW5lIE1QSTJfUlBZX0RFU0NSSVBUX0ZMQUdTX1RZUEVfTUFTSyAgICAgICAgICAgICAgICgweDBGKQotI2RlZmluZSBNUEkyX1JQWV9ERVNDUklQVF9GTEFHU19TQ1NJX0lPX1NVQ0NFU1MgICAgICAgICAoMHgwMCkKLSNkZWZpbmUgTVBJMl9SUFlfREVTQ1JJUFRfRkxBR1NfQUREUkVTU19SRVBMWSAgICAgICAgICAgKDB4MDEpCi0jZGVmaW5lIE1QSTJfUlBZX0RFU0NSSVBUX0ZMQUdTX1RBUkdFVEFTU0lTVF9TVUNDRVNTICAgICgweDAyKQotI2RlZmluZSBNUEkyX1JQWV9ERVNDUklQVF9GTEFHU19UQVJHRVRfQ09NTUFORF9CVUZGRVIgICAoMHgwMykKLSNkZWZpbmUgTVBJMl9SUFlfREVTQ1JJUFRfRkxBR1NfVU5VU0VEICAgICAgICAgICAgICAgICAgKDB4MEYpCisjZGVmaW5lIE1QSTJfUlBZX0RFU0NSSVBUX0ZMQUdTX1RZUEVfTUFTSyAgICAgICAgICAgICAgICAgICAoMHgwRikKKyNkZWZpbmUgTVBJMl9SUFlfREVTQ1JJUFRfRkxBR1NfU0NTSV9JT19TVUNDRVNTICAgICAgICAgICAgICgweDAwKQorI2RlZmluZSBNUEkyX1JQWV9ERVNDUklQVF9GTEFHU19BRERSRVNTX1JFUExZICAgICAgICAgICAgICAgKDB4MDEpCisjZGVmaW5lIE1QSTJfUlBZX0RFU0NSSVBUX0ZMQUdTX1RBUkdFVEFTU0lTVF9TVUNDRVNTICAgICAgICAoMHgwMikKKyNkZWZpbmUgTVBJMl9SUFlfREVTQ1JJUFRfRkxBR1NfVEFSR0VUX0NPTU1BTkRfQlVGRkVSICAgICAgICgweDAzKQorI2RlZmluZSBNUEkyX1JQWV9ERVNDUklQVF9GTEFHU19SQUlEX0FDQ0VMRVJBVE9SX1NVQ0NFU1MgICAgKDB4MDUpCisjZGVmaW5lIE1QSTJfUlBZX0RFU0NSSVBUX0ZMQUdTX1VOVVNFRCAgICAgICAgICAgICAgICAgICAgICAoMHgwRikKIAogLyogdmFsdWVzIGZvciBtYXJraW5nIGEgcmVwbHkgZGVzY3JpcHRvciBhcyB1bnVzZWQgKi8KICNkZWZpbmUgTVBJMl9SUFlfREVTQ1JJUFRfVU5VU0VEX1dPUkQwX01BUksgICAgICAgICAgICAgKDB4RkZGRkZGRkYpCkBAIC0zNTUsNyArMzc5LDcgQEAKIHR5cGVkZWYgc3RydWN0IF9NUEkyX0FERFJFU1NfUkVQTFlfREVTQ1JJUFRPUgogewogICAgIFU4ICAgICAgICAgICAgICBSZXBseUZsYWdzOyAgICAgICAgICAgICAgICAgLyogMHgwMCAqLwotICAgIFU4ICAgICAgICAgICAgICBWRl9JRDsgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLworICAgIFU4ICAgICAgICAgICAgICBNU0l4SW5kZXg7ICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLwogICAgIFUxNiAgICAgICAgICAgICBTTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMiAqLwogICAgIFUzMiAgICAgICAgICAgICBSZXBseUZyYW1lQWRkcmVzczsgICAgICAgICAgLyogMHgwNCAqLwogfSBNUEkyX0FERFJFU1NfUkVQTFlfREVTQ1JJUFRPUiwgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX0FERFJFU1NfUkVQTFlfREVTQ1JJUFRPUiwKQEAgLTM2OCwxMCArMzkyLDEwIEBACiB0eXBlZGVmIHN0cnVjdCBfTVBJMl9TQ1NJX0lPX1NVQ0NFU1NfUkVQTFlfREVTQ1JJUFRPUgogewogICAgIFU4ICAgICAgICAgICAgICBSZXBseUZsYWdzOyAgICAgICAgICAgICAgICAgLyogMHgwMCAqLwotICAgIFU4ICAgICAgICAgICAgICBWRl9JRDsgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLworICAgIFU4ICAgICAgICAgICAgICBNU0l4SW5kZXg7ICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLwogICAgIFUxNiAgICAgICAgICAgICBTTUlEOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMiAqLwogICAgIFUxNiAgICAgICAgICAgICBUYXNrVGFnOyAgICAgICAgICAgICAgICAgICAgLyogMHgwNCAqLwotICAgIFUxNiAgICAgICAgICAgICBEZXZIYW5kbGU7ICAgICAgICAgICAgICAgICAgLyogMHgwNiAqLworICAgIFUxNiAgICAgICAgICAgICBSZXNlcnZlZDE7ICAgICAgICAgICAgICAgICAgLyogMHgwNiAqLwogfSBNUEkyX1NDU0lfSU9fU1VDQ0VTU19SRVBMWV9ERVNDUklQVE9SLAogICBNUEkyX1BPSU5URVIgUFRSX01QSTJfU0NTSV9JT19TVUNDRVNTX1JFUExZX0RFU0NSSVBUT1IsCiAgIE1waTJTQ1NJSU9TdWNjZXNzUmVwbHlEZXNjcmlwdG9yX3QsCkBAIC0zODIsNyArNDA2LDcgQEAKIHR5cGVkZWYgc3RydWN0IF9NUEkyX1RBUkdFVEFTU0lTVF9TVUNDRVNTX1JFUExZX0RFU0NSSVBUT1IKIHsKICAgICBVOCAgICAgICAgICAgICAgUmVwbHlGbGFnczsgICAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KLSAgICBVOCAgICAgICAgICAgICAgVkZfSUQ7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KKyAgICBVOCAgICAgICAgICAgICAgTVNJeEluZGV4OyAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KICAgICBVMTYgICAgICAgICAgICAgU01JRDsgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KICAgICBVOCAgICAgICAgICAgICAgU2VxdWVuY2VOdW1iZXI7ICAgICAgICAgICAgIC8qIDB4MDQgKi8KICAgICBVOCAgICAgICAgICAgICAgUmVzZXJ2ZWQxOyAgICAgICAgICAgICAgICAgIC8qIDB4MDUgKi8KQEAgLTM5Nyw3ICs0MjEsNyBAQAogdHlwZWRlZiBzdHJ1Y3QgX01QSTJfVEFSR0VUX0NPTU1BTkRfQlVGRkVSX1JFUExZX0RFU0NSSVBUT1IKIHsKICAgICBVOCAgICAgICAgICAgICAgUmVwbHlGbGFnczsgICAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KLSAgICBVOCAgICAgICAgICAgICAgVkZfSUQ7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KKyAgICBVOCAgICAgICAgICAgICAgTVNJeEluZGV4OyAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KICAgICBVOCAgICAgICAgICAgICAgVlBfSUQ7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KICAgICBVOCAgICAgICAgICAgICAgRmxhZ3M7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDMgKi8KICAgICBVMTYgICAgICAgICAgICAgSW5pdGlhdG9yRGV2SGFuZGxlOyAgICAgICAgIC8qIDB4MDQgKi8KQEAgLTQxMSwxNSArNDM1LDI4IEBACiAjZGVmaW5lIE1QSTJfUlBZX0RFU0NSSVBUX1RDQl9GTEFHU19QSFlOVU1fTUFTSyAgICAgKDB4M0YpCiAKIAorLyogUkFJRCBBY2NlbGVyYXRvciBTdWNjZXNzIFJlcGx5IERlc2NyaXB0b3IgKi8KK3R5cGVkZWYgc3RydWN0IF9NUEkyX1JBSURfQUNDRUxFUkFUT1JfU1VDQ0VTU19SRVBMWV9ERVNDUklQVE9SIHsKKyAgICBVOCAgICAgICAgICAgICAgUmVwbHlGbGFnczsgICAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KKyAgICBVOCAgICAgICAgICAgICAgTVNJeEluZGV4OyAgICAgICAgICAgICAgICAgIC8qIDB4MDEgKi8KKyAgICBVMTYgICAgICAgICAgICAgU01JRDsgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KKyAgICBVMzIgICAgICAgICAgICAgUmVzZXJ2ZWQ7ICAgICAgICAgICAgICAgICAgIC8qIDB4MDQgKi8KK30gTVBJMl9SQUlEX0FDQ0VMRVJBVE9SX1NVQ0NFU1NfUkVQTFlfREVTQ1JJUFRPUiwKKyAgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1JBSURfQUNDRUxFUkFUT1JfU1VDQ0VTU19SRVBMWV9ERVNDUklQVE9SLAorICBNcGkyUkFJREFjY2VsZXJhdG9yU3VjY2Vzc1JlcGx5RGVzY3JpcHRvcl90LAorICBNUEkyX1BPSU5URVIgcE1waTJSQUlEQWNjZWxlcmF0b3JTdWNjZXNzUmVwbHlEZXNjcmlwdG9yX3Q7CisKKwogLyogdW5pb24gb2YgUmVwbHkgRGVzY3JpcHRvcnMgKi8KIHR5cGVkZWYgdW5pb24gX01QSTJfUkVQTFlfREVTQ1JJUFRPUlNfVU5JT04KIHsKLSAgICBNUEkyX0RFRkFVTFRfUkVQTFlfREVTQ1JJUFRPUiAgICAgICAgICAgICAgIERlZmF1bHQ7Ci0gICAgTVBJMl9BRERSRVNTX1JFUExZX0RFU0NSSVBUT1IgICAgICAgICAgICAgICBBZGRyZXNzUmVwbHk7Ci0gICAgTVBJMl9TQ1NJX0lPX1NVQ0NFU1NfUkVQTFlfREVTQ1JJUFRPUiAgICAgICBTQ1NJSU9TdWNjZXNzOwotICAgIE1QSTJfVEFSR0VUQVNTSVNUX1NVQ0NFU1NfUkVQTFlfREVTQ1JJUFRPUiAgVGFyZ2V0QXNzaXN0U3VjY2VzczsKLSAgICBNUEkyX1RBUkdFVF9DT01NQU5EX0JVRkZFUl9SRVBMWV9ERVNDUklQVE9SIFRhcmdldENvbW1hbmRCdWZmZXI7Ci0gICAgVTY0ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXb3JkczsKKyAgICBNUEkyX0RFRkFVTFRfUkVQTFlfREVTQ1JJUFRPUiAgICAgICAgICAgICAgICAgICBEZWZhdWx0OworICAgIE1QSTJfQUREUkVTU19SRVBMWV9ERVNDUklQVE9SICAgICAgICAgICAgICAgICAgIEFkZHJlc3NSZXBseTsKKyAgICBNUEkyX1NDU0lfSU9fU1VDQ0VTU19SRVBMWV9ERVNDUklQVE9SICAgICAgICAgICBTQ1NJSU9TdWNjZXNzOworICAgIE1QSTJfVEFSR0VUQVNTSVNUX1NVQ0NFU1NfUkVQTFlfREVTQ1JJUFRPUiAgICAgIFRhcmdldEFzc2lzdFN1Y2Nlc3M7CisgICAgTVBJMl9UQVJHRVRfQ09NTUFORF9CVUZGRVJfUkVQTFlfREVTQ1JJUFRPUiAgICAgVGFyZ2V0Q29tbWFuZEJ1ZmZlcjsKKyAgICBNUEkyX1JBSURfQUNDRUxFUkFUT1JfU1VDQ0VTU19SRVBMWV9ERVNDUklQVE9SICBSQUlEQWNjZWxlcmF0b3JTdWNjZXNzOworICAgIFU2NCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFdvcmRzOwogfSBNUEkyX1JFUExZX0RFU0NSSVBUT1JTX1VOSU9OLCBNUEkyX1BPSU5URVIgUFRSX01QSTJfUkVQTFlfREVTQ1JJUFRPUlNfVU5JT04sCiAgIE1waTJSZXBseURlc2NyaXB0b3JzVW5pb25fdCwgTVBJMl9QT0lOVEVSIHBNcGkyUmVwbHlEZXNjcmlwdG9yc1VuaW9uX3Q7CiAKQEAgLTQ1OCw2ICs0OTUsNyBAQAogI2RlZmluZSBNUEkyX0ZVTkNUSU9OX0RJQUdfUkVMRUFTRSAgICAgICAgICAgICAgICAgICgweDFFKSAvKiBEaWFnbm9zdGljIFJlbGVhc2UgKi8KICNkZWZpbmUgTVBJMl9GVU5DVElPTl9UQVJHRVRfQ01EX0JVRl9CQVNFX1BPU1QgICAgICAoMHgyNCkgLyogVGFyZ2V0IENvbW1hbmQgQnVmZmVyIFBvc3QgQmFzZSAqLwogI2RlZmluZSBNUEkyX0ZVTkNUSU9OX1RBUkdFVF9DTURfQlVGX0xJU1RfUE9TVCAgICAgICgweDI1KSAvKiBUYXJnZXQgQ29tbWFuZCBCdWZmZXIgUG9zdCBMaXN0ICovCisjZGVmaW5lIE1QSTJfRlVOQ1RJT05fUkFJRF9BQ0NFTEVSQVRPUiAgICAgICAgICAgICAgKDB4MkMpIC8qIFJBSUQgQWNjZWxlcmF0b3IqLwogCiAKIApAQCAtNTU1LDEyICs1OTMsMTcgQEAKIAogI2RlZmluZSBNUEkyX0lPQ1NUQVRVU19ESUFHTk9TVElDX1JFTEVBU0VEICAgICAgICAgICgweDAwQTApCiAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisqICBSQUlEIEFjY2VsZXJhdG9yIHZhbHVlcworKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2RlZmluZSBNUEkyX0lPQ1NUQVRVU19SQUlEX0FDQ0VMX0VSUk9SICAgICAgICAgICAgICgweDAwQjApCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICBJT0NTdGF0dXMgZmxhZyB0byBpbmRpY2F0ZSB0aGF0IGxvZyBpbmZvIGlzIGF2YWlsYWJsZQogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIAotI2RlZmluZSBNUEkyX0lPQ1NUQVRVU19GTEFHX0xPR19JTkZPX0FWQUlMQUJMRSAgKDB4ODAwMCkKKyNkZWZpbmUgTVBJMl9JT0NTVEFUVVNfRkxBR19MT0dfSU5GT19BVkFJTEFCTEUgICAgICAoMHg4MDAwKQogCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgSU9DTG9nSW5mbyBUeXBlcwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfY25mZy5oIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfY25mZy5oCmluZGV4IDJmMjdjZjYuLmFiNDdjNDYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX2NuZmcuaAorKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcGkvbXBpMl9jbmZnLmgKQEAgLTYsNyArNiw3IEBACiAgKiAgICAgICAgICBUaXRsZTogIE1QSSBDb25maWd1cmF0aW9uIG1lc3NhZ2VzIGFuZCBwYWdlcwogICogIENyZWF0aW9uIERhdGU6ICBOb3ZlbWJlciAxMCwgMjAwNgogICoKLSAqICAgIG1waTJfY25mZy5oIFZlcnNpb246ICAwMi4wMC4xMAorICogICAgbXBpMl9jbmZnLmggVmVyc2lvbjogIDAyLjAwLjExCiAgKgogICogIFZlcnNpb24gSGlzdG9yeQogICogIC0tLS0tLS0tLS0tLS0tLQpAQCAtOTUsNiArOTUsMTEgQEAKICAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIE1QSTJfU0FTX0RFVklDRTBfQVNUQVRVU19ERVZJQ0VfQkxPQ0tFRCBkZWZpbmUuCiAgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBQb3J0R3JvdXBzLCBEbWFHcm91cCwgYW5kIENvbnRyb2xHcm91cCBmaWVsZHMgdG8KICAqICAgICAgICAgICAgICAgICAgICAgIFNBUyBEZXZpY2UgUGFnZSAwLgorICogIDA1LTA2LTA5ICAwMi4wMC4xMSAgQWRkZWQgc3RydWN0dXJlcyBhbmQgZGVmaW5lcyBmb3IgSU8gVW5pdCBQYWdlIDUgYW5kIElPCisgKiAgICAgICAgICAgICAgICAgICAgICBVbml0IFBhZ2UgNi4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIGV4cGFuZGVyIHJlZHVjZWQgZnVuY3Rpb25hbGl0eSBkYXRhIHRvIFNBUworICogICAgICAgICAgICAgICAgICAgICAgRXhwYW5kZXIgUGFnZSAwLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgU0FTIFBIWSBQYWdlIDIgYW5kIFNBUyBQSFkgUGFnZSAzLgogICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKi8KIApAQCAtNzIzLDYgKzcyOCw2NSBAQAogI2RlZmluZSBNUEkyX0lPVU5JVFBBR0UzX0dQSU9fU0VUVElOR19PTiAgICAgICAgICAgICAgICAoMHgwMDAxKQogCiAKKy8qIElPIFVuaXQgUGFnZSA1ICovCisKKy8qCisgKiBVcHBlciBsYXllciBjb2RlIChkcml2ZXJzLCB1dGlsaXRpZXMsIGV0Yy4pIHNob3VsZCBsZWF2ZSB0aGlzIGRlZmluZSBzZXQgdG8KKyAqIG9uZSBhbmQgY2hlY2sgSGVhZGVyLlBhZ2VMZW5ndGggb3IgTnVtRG1hRW5naW5lcyBhdCBydW50aW1lLgorICovCisjaWZuZGVmIE1QSTJfSU9VTklUUEFHRTVfRE1BRU5HSU5FX0VOVFJJRVMKKyNkZWZpbmUgTVBJMl9JT1VOSVRQQUdFNV9ETUFFTkdJTkVfRU5UUklFUyAgICAgICgxKQorI2VuZGlmCisKK3R5cGVkZWYgc3RydWN0IF9NUEkyX0NPTkZJR19QQUdFX0lPX1VOSVRfNSB7CisgICAgTVBJMl9DT05GSUdfUEFHRV9IRUFERVIgSGVhZGVyOwkJCQkvKiAweDAwICovCisgICAgVTY0ICAgICAgICAgICAgICAgICAgICAgUmFpZEFjY2VsZXJhdG9yQnVmZmVyQmFzZUFkZHJlc3M7ICAvKiAweDA0ICovCisgICAgVTY0ICAgICAgICAgICAgICAgICAgICAgUmFpZEFjY2VsZXJhdG9yQnVmZmVyU2l6ZTsgICAgICAgICAvKiAweDBDICovCisgICAgVTY0ICAgICAgICAgICAgICAgICAgICAgUmFpZEFjY2VsZXJhdG9yQ29udHJvbEJhc2VBZGRyZXNzOyAvKiAweDE0ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUkFDb250cm9sU2l6ZTsgICAgICAgICAgICAgICAgICAgICAvKiAweDFDICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgTnVtRG1hRW5naW5lczsgICAgICAgICAgICAgICAgICAgICAvKiAweDFEICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUkFNaW5Db250cm9sU2l6ZTsgICAgICAgICAgICAgICAgICAvKiAweDFFICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUkFNYXhDb250cm9sU2l6ZTsgICAgICAgICAgICAgICAgICAvKiAweDFGICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQxOyAgICAgICAgICAgICAgICAgICAgICAgICAvKiAweDIwICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQyOyAgICAgICAgICAgICAgICAgICAgICAgICAvKiAweDI0ICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQzOyAgICAgICAgICAgICAgICAgICAgICAgICAvKiAweDI4ICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgRG1hRW5naW5lQ2FwYWJpbGl0aWVzCisJCQkJW01QSTJfSU9VTklUUEFHRTVfRE1BRU5HSU5FX0VOVFJJRVNdOyAvKiAweDJDICovCit9IE1QSTJfQ09ORklHX1BBR0VfSU9fVU5JVF81LCBNUEkyX1BPSU5URVIgUFRSX01QSTJfQ09ORklHX1BBR0VfSU9fVU5JVF81LAorICBNcGkySU9Vbml0UGFnZTVfdCwgTVBJMl9QT0lOVEVSIHBNcGkySU9Vbml0UGFnZTVfdDsKKworI2RlZmluZSBNUEkyX0lPVU5JVFBBR0U1X1BBR0VWRVJTSU9OICAgICAgICAgICAgICAgICAgICAoMHgwMCkKKworLyogZGVmaW5lcyBmb3IgSU8gVW5pdCBQYWdlIDUgRG1hRW5naW5lQ2FwYWJpbGl0aWVzIGZpZWxkICovCisjZGVmaW5lIE1QSTJfSU9VTklUUEFHRTVfRE1BX0NBUF9NQVNLX01BWF9SRVFVRVNUUyAgICAgICgweEZGMDApCisjZGVmaW5lIE1QSTJfSU9VTklUUEFHRTVfRE1BX0NBUF9TSElGVF9NQVhfUkVRVUVTVFMgICAgICgxNikKKworI2RlZmluZSBNUEkyX0lPVU5JVFBBR0U1X0RNQV9DQVBfRUVEUCAgICAgICAgICAgICAgICAgICAoMHgwMDA4KQorI2RlZmluZSBNUEkyX0lPVU5JVFBBR0U1X0RNQV9DQVBfUEFSSVRZX0dFTkVSQVRJT04gICAgICAoMHgwMDA0KQorI2RlZmluZSBNUEkyX0lPVU5JVFBBR0U1X0RNQV9DQVBfSEFTSElORyAgICAgICAgICAgICAgICAoMHgwMDAyKQorI2RlZmluZSBNUEkyX0lPVU5JVFBBR0U1X0RNQV9DQVBfRU5DUllQVElPTiAgICAgICAgICAgICAoMHgwMDAxKQorCisKKy8qIElPIFVuaXQgUGFnZSA2ICovCisKK3R5cGVkZWYgc3RydWN0IF9NUEkyX0NPTkZJR19QQUdFX0lPX1VOSVRfNiB7CisgICAgTVBJMl9DT05GSUdfUEFHRV9IRUFERVIgSGVhZGVyOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICBGbGFnczsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwNCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFJBSG9zdENvbnRyb2xTaXplOyAgICAgICAgICAgICAgICAgICAgICAvKiAweDA2ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQwOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDcgKi8KKyAgICBVNjQgICAgICAgICAgICAgICAgICAgICBSYWlkQWNjZWxlcmF0b3JIb3N0Q29udHJvbEJhc2VBZGRyZXNzOyAgLyogMHgwOCAqLworICAgIFUzMiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiAweDEwICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQyOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MTQgKi8KKyAgICBVMzIgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDM7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogMHgxOCAqLworfSBNUEkyX0NPTkZJR19QQUdFX0lPX1VOSVRfNiwgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX0NPTkZJR19QQUdFX0lPX1VOSVRfNiwKKyAgTXBpMklPVW5pdFBhZ2U2X3QsIE1QSTJfUE9JTlRFUiBwTXBpMklPVW5pdFBhZ2U2X3Q7CisKKyNkZWZpbmUgTVBJMl9JT1VOSVRQQUdFNl9QQUdFVkVSU0lPTiAgICAgICAgICAgICAgICAgICAgKDB4MDApCisKKy8qIGRlZmluZXMgZm9yIElPIFVuaXQgUGFnZSA2IEZsYWdzIGZpZWxkICovCisjZGVmaW5lIE1QSTJfSU9VTklUUEFHRTZfRkxBR1NfRU5BQkxFX1JBSURfQUNDRUxFUkFUT1IgICgweDAwMDEpCisKKwogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICBJT0MgQ29uZmlnIFBhZ2VzCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpAQCAtMTcwOSwxMCArMTc3MywxNCBAQAogICAgIFU2NCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFjdGl2ZVpvbmVNYW5hZ2VyU0FTQWRkcmVzczsvKiAweDJDICovCiAgICAgVTE2ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgWm9uZUxvY2tJbmFjdGl2aXR5TGltaXQ7ICAgIC8qIDB4MzQgKi8KICAgICBVMTYgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDE7ICAgICAgICAgICAgICAgICAgLyogMHgzNiAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFRpbWVUb1JlZHVjZWRGdW5jOyAgICAgICAgICAvKiAweDM4ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSW5pdGlhbFRpbWVUb1JlZHVjZWRGdW5jOyAgIC8qIDB4MzkgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBNYXhSZWR1Y2VkRnVuY1RpbWU7ICAgICAgICAgLyogMHgzQSAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMjsgICAgICAgICAgICAgICAgICAvKiAweDNCICovCiB9IE1QSTJfQ09ORklHX1BBR0VfRVhQQU5ERVJfMCwgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX0NPTkZJR19QQUdFX0VYUEFOREVSXzAsCiAgIE1waTJFeHBhbmRlclBhZ2UwX3QsIE1QSTJfUE9JTlRFUiBwTXBpMkV4cGFuZGVyUGFnZTBfdDsKIAotI2RlZmluZSBNUEkyX1NBU0VYUEFOREVSMF9QQUdFVkVSU0lPTiAgICAgICAoMHgwNSkKKyNkZWZpbmUgTVBJMl9TQVNFWFBBTkRFUjBfUEFHRVZFUlNJT04gICAgICAgKDB4MDYpCiAKIC8qIHZhbHVlcyBmb3IgU0FTIEV4cGFuZGVyIFBhZ2UgMCBEaXNjb3ZlcnlTdGF0dXMgZmllbGQgKi8KICNkZWZpbmUgTVBJMl9TQVNfRVhQQU5ERVIwX0RTX01BWF9FTkNMT1NVUkVTX0VYQ0VFRCAgICAgICAgICgweDgwMDAwMDAwKQpAQCAtMTczNyw2ICsxODA1LDcgQEAKICNkZWZpbmUgTVBJMl9TQVNfRVhQQU5ERVIwX0RTX0xPT1BfREVURUNURUQgICAgICAgICAgICAgICAgICgweDAwMDAwMDAxKQogCiAvKiB2YWx1ZXMgZm9yIFNBUyBFeHBhbmRlciBQYWdlIDAgRmxhZ3MgZmllbGQgKi8KKyNkZWZpbmUgTVBJMl9TQVNfRVhQQU5ERVIwX0ZMQUdTX1JFRFVDRURfRlVOQ1RJT05BTElUWSAgICAgICgweDIwMDApCiAjZGVmaW5lIE1QSTJfU0FTX0VYUEFOREVSMF9GTEFHU19aT05FX0xPQ0tFRCAgICAgICAgICAgICAgICAoMHgxMDAwKQogI2RlZmluZSBNUEkyX1NBU19FWFBBTkRFUjBfRkxBR1NfU1VQUE9SVEVEX1BIWVNJQ0FMX1BSRVMgICAgKDB4MDgwMCkKICNkZWZpbmUgTVBJMl9TQVNfRVhQQU5ERVIwX0ZMQUdTX0FTU0VSVEVEX1BIWVNJQ0FMX1BSRVMgICAgICgweDA0MDApCkBAIC0xOTQ0LDYgKzIwMTMsMTMzIEBACiAjZGVmaW5lIE1QSTJfU0FTUEhZMV9QQUdFVkVSU0lPTiAgICAgICAgICAgICgweDAxKQogCiAKKy8qIFNBUyBQSFkgUGFnZSAyICovCisKK3R5cGVkZWYgc3RydWN0IF9NUEkyX1NBU1BIWTJfUEhZX0VWRU5UIHsKKyAgICBVOCAgICAgICAgICBQaHlFdmVudENvZGU7ICAgICAgIC8qIDB4MDAgKi8KKyAgICBVOCAgICAgICAgICBSZXNlcnZlZDE7ICAgICAgICAgIC8qIDB4MDEgKi8KKyAgICBVMTYgICAgICAgICBSZXNlcnZlZDI7ICAgICAgICAgIC8qIDB4MDIgKi8KKyAgICBVMzIgICAgICAgICBQaHlFdmVudEluZm87ICAgICAgIC8qIDB4MDQgKi8KK30gTVBJMl9TQVNQSFkyX1BIWV9FVkVOVCwgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1NBU1BIWTJfUEhZX0VWRU5ULAorICBNcGkyU2FzUGh5MlBoeUV2ZW50X3QsIE1QSTJfUE9JTlRFUiBwTXBpMlNhc1BoeTJQaHlFdmVudF90OworCisvKiB1c2UgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfIGZvciB0aGUgUGh5RXZlbnRDb2RlIGZpZWxkICovCisKKworLyoKKyAqIEhvc3QgY29kZSAoZHJpdmVycywgQklPUywgdXRpbGl0aWVzLCBldGMuKSBzaG91bGQgbGVhdmUgdGhpcyBkZWZpbmUgc2V0IHRvCisgKiBvbmUgYW5kIGNoZWNrIEhlYWRlci5FeHRQYWdlTGVuZ3RoIG9yIE51bVBoeUV2ZW50cyBhdCBydW50aW1lLgorICovCisjaWZuZGVmIE1QSTJfU0FTUEhZMl9QSFlfRVZFTlRfTUFYCisjZGVmaW5lIE1QSTJfU0FTUEhZMl9QSFlfRVZFTlRfTUFYICAgICAgKDEpCisjZW5kaWYKKwordHlwZWRlZiBzdHJ1Y3QgX01QSTJfQ09ORklHX1BBR0VfU0FTX1BIWV8yIHsKKyAgICBNUEkyX0NPTkZJR19FWFRFTkRFRF9QQUdFX0hFQURFUiAgICBIZWFkZXI7ICAgICAgICAgICAgICAgICAgICAgLyogMHgwMCAqLworICAgIFUzMiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMTsgICAgICAgICAgICAgICAgICAvKiAweDA4ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTnVtUGh5RXZlbnRzOyAgICAgICAgICAgICAgIC8qIDB4MEMgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDI7ICAgICAgICAgICAgICAgICAgLyogMHgwRCAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMzsgICAgICAgICAgICAgICAgICAvKiAweDBFICovCisgICAgTVBJMl9TQVNQSFkyX1BIWV9FVkVOVCAgICAgICAgICAgICAgUGh5RXZlbnRbTVBJMl9TQVNQSFkyX1BIWV9FVkVOVF9NQVhdOworCQkJCQkJCQkvKiAweDEwICovCit9IE1QSTJfQ09ORklHX1BBR0VfU0FTX1BIWV8yLCBNUEkyX1BPSU5URVIgUFRSX01QSTJfQ09ORklHX1BBR0VfU0FTX1BIWV8yLAorICBNcGkyU2FzUGh5UGFnZTJfdCwgTVBJMl9QT0lOVEVSIHBNcGkyU2FzUGh5UGFnZTJfdDsKKworI2RlZmluZSBNUEkyX1NBU1BIWTJfUEFHRVZFUlNJT04gICAgICAgICAgICAoMHgwMCkKKworCisvKiBTQVMgUEhZIFBhZ2UgMyAqLworCit0eXBlZGVmIHN0cnVjdCBfTVBJMl9TQVNQSFkzX1BIWV9FVkVOVF9DT05GSUcgeworICAgIFU4ICAgICAgICAgIFBoeUV2ZW50Q29kZTsgICAgICAgLyogMHgwMCAqLworICAgIFU4ICAgICAgICAgIFJlc2VydmVkMTsgICAgICAgICAgLyogMHgwMSAqLworICAgIFUxNiAgICAgICAgIFJlc2VydmVkMjsgICAgICAgICAgLyogMHgwMiAqLworICAgIFU4ICAgICAgICAgIENvdW50ZXJUeXBlOyAgICAgICAgLyogMHgwNCAqLworICAgIFU4ICAgICAgICAgIFRocmVzaG9sZFdpbmRvdzsgICAgLyogMHgwNSAqLworICAgIFU4ICAgICAgICAgIFRpbWVVbml0czsgICAgICAgICAgLyogMHgwNiAqLworICAgIFU4ICAgICAgICAgIFJlc2VydmVkMzsgICAgICAgICAgLyogMHgwNyAqLworICAgIFUzMiAgICAgICAgIEV2ZW50VGhyZXNob2xkOyAgICAgLyogMHgwOCAqLworICAgIFUxNiAgICAgICAgIFRocmVzaG9sZEZsYWdzOyAgICAgLyogMHgwQyAqLworICAgIFUxNiAgICAgICAgIFJlc2VydmVkNDsgICAgICAgICAgLyogMHgwRSAqLworfSBNUEkyX1NBU1BIWTNfUEhZX0VWRU5UX0NPTkZJRywgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1NBU1BIWTNfUEhZX0VWRU5UX0NPTkZJRywKKyAgTXBpMlNhc1BoeTNQaHlFdmVudENvbmZpZ190LCBNUEkyX1BPSU5URVIgcE1waTJTYXNQaHkzUGh5RXZlbnRDb25maWdfdDsKKworLyogdmFsdWVzIGZvciBQaHlFdmVudENvZGUgZmllbGQgKi8KKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfTk9fRVZFTlQgICAgICAgICAgICAgICAgICAgICgweDAwKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9JTlZBTElEX0RXT1JEICAgICAgICAgICAgICAgKDB4MDEpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1JVTk5JTkdfRElTUEFSSVRZX0VSUk9SICAgICAoMHgwMikKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfTE9TU19EV09SRF9TWU5DICAgICAgICAgICAgICgweDAzKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9QSFlfUkVTRVRfUFJPQkxFTSAgICAgICAgICAgKDB4MDQpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX0VMQVNUSUNJVFlfQlVGX09WRVJGTE9XICAgICAoMHgwNSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUlhfRVJST1IgICAgICAgICAgICAgICAgICAgICgweDA2KQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9SWF9BRERSX0ZSQU1FX0VSUk9SICAgICAgICAgKDB4MjApCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1RYX0FDX09QRU5fUkVKRUNUICAgICAgICAgICAoMHgyMSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUlhfQUNfT1BFTl9SRUpFQ1QgICAgICAgICAgICgweDIyKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9UWF9SQ19PUEVOX1JFSkVDVCAgICAgICAgICAgKDB4MjMpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1JYX1JDX09QRU5fUkVKRUNUICAgICAgICAgICAoMHgyNCkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUlhfQUlQX1BBUlRJQUxfV0FJVElOR19PTiAgICgweDI1KQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9SWF9BSVBfQ09OTkVDVF9XQUlUSU5HX09OICAgKDB4MjYpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1RYX0JSRUFLICAgICAgICAgICAgICAgICAgICAoMHgyNykKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUlhfQlJFQUsgICAgICAgICAgICAgICAgICAgICgweDI4KQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9CUkVBS19USU1FT1VUICAgICAgICAgICAgICAgKDB4MjkpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX0NPTk5FQ1RJT04gICAgICAgICAgICAgICAgICAoMHgyQSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUEVBS1RYX1BBVEhXQVlfQkxPQ0tFRCAgICAgICgweDJCKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9QRUFLVFhfQVJCX1dBSVRfVElNRSAgICAgICAgKDB4MkMpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1BFQUtfQVJCX1dBSVRfVElNRSAgICAgICAgICAoMHgyRCkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUEVBS19DT05ORUNUX1RJTUUgICAgICAgICAgICgweDJFKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9UWF9TU1BfRlJBTUVTICAgICAgICAgICAgICAgKDB4NDApCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1JYX1NTUF9GUkFNRVMgICAgICAgICAgICAgICAoMHg0MSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfVFhfU1NQX0VSUk9SX0ZSQU1FUyAgICAgICAgICgweDQyKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9SWF9TU1BfRVJST1JfRlJBTUVTICAgICAgICAgKDB4NDMpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1RYX0NSRURJVF9CTE9DS0VEICAgICAgICAgICAoMHg0NCkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUlhfQ1JFRElUX0JMT0NLRUQgICAgICAgICAgICgweDQ1KQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9UWF9TQVRBX0ZSQU1FUyAgICAgICAgICAgICAgKDB4NTApCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1JYX1NBVEFfRlJBTUVTICAgICAgICAgICAgICAoMHg1MSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfU0FUQV9PVkVSRkxPVyAgICAgICAgICAgICAgICgweDUyKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9UWF9TTVBfRlJBTUVTICAgICAgICAgICAgICAgKDB4NjApCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX1JYX1NNUF9GUkFNRVMgICAgICAgICAgICAgICAoMHg2MSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUlhfU01QX0VSUk9SX0ZSQU1FUyAgICAgICAgICgweDYzKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfRVZFTlRfQ09ERV9IT1RQTFVHX1RJTUVPVVQgICAgICAgICAgICAgKDB4RDApCisjZGVmaW5lIE1QSTJfU0FTUEhZM19FVkVOVF9DT0RFX01JU0FMSUdORURfTVVYX1BSSU1JVElWRSAgICAoMHhEMSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfUlhfQUlQICAgICAgICAgICAgICAgICAgICAgICgweEQyKQorCisvKiB2YWx1ZXMgZm9yIHRoZSBDb3VudGVyVHlwZSBmaWVsZCAqLworI2RlZmluZSBNUEkyX1NBU1BIWTNfQ09VTlRFUl9UWVBFX1dSQVBQSU5HICAgICAgICAgICAgICAgICAgKDB4MDApCisjZGVmaW5lIE1QSTJfU0FTUEhZM19DT1VOVEVSX1RZUEVfU0FUVVJBVElORyAgICAgICAgICAgICAgICAoMHgwMSkKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX0NPVU5URVJfVFlQRV9QRUFLX1ZBTFVFICAgICAgICAgICAgICAgICgweDAyKQorCisvKiB2YWx1ZXMgZm9yIHRoZSBUaW1lVW5pdHMgZmllbGQgKi8KKyNkZWZpbmUgTVBJMl9TQVNQSFkzX1RJTUVfVU5JVFNfMTBfTUlDUk9TRUNPTkRTICAgICAgICAgICAgICgweDAwKQorI2RlZmluZSBNUEkyX1NBU1BIWTNfVElNRV9VTklUU18xMDBfTUlDUk9TRUNPTkRTICAgICAgICAgICAgKDB4MDEpCisjZGVmaW5lIE1QSTJfU0FTUEhZM19USU1FX1VOSVRTXzFfTUlMTElTRUNPTkQgICAgICAgICAgICAgICAoMHgwMikKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX1RJTUVfVU5JVFNfMTBfTUlMTElTRUNPTkRTICAgICAgICAgICAgICgweDAzKQorCisvKiB2YWx1ZXMgZm9yIHRoZSBUaHJlc2hvbGRGbGFncyBmaWVsZCAqLworI2RlZmluZSBNUEkyX1NBU1BIWTNfVEZMQUdTX1BIWV9SRVNFVCAgICAgICAgICAgICAgICAgICAgICAgKDB4MDAwMikKKyNkZWZpbmUgTVBJMl9TQVNQSFkzX1RGTEFHU19FVkVOVF9OT1RJRlkgICAgICAgICAgICAgICAgICAgICgweDAwMDEpCisKKy8qCisgKiBIb3N0IGNvZGUgKGRyaXZlcnMsIEJJT1MsIHV0aWxpdGllcywgZXRjLikgc2hvdWxkIGxlYXZlIHRoaXMgZGVmaW5lIHNldCB0bworICogb25lIGFuZCBjaGVjayBIZWFkZXIuRXh0UGFnZUxlbmd0aCBvciBOdW1QaHlFdmVudHMgYXQgcnVudGltZS4KKyAqLworI2lmbmRlZiBNUEkyX1NBU1BIWTNfUEhZX0VWRU5UX01BWAorI2RlZmluZSBNUEkyX1NBU1BIWTNfUEhZX0VWRU5UX01BWCAgICAgICgxKQorI2VuZGlmCisKK3R5cGVkZWYgc3RydWN0IF9NUEkyX0NPTkZJR19QQUdFX1NBU19QSFlfMyB7CisgICAgTVBJMl9DT05GSUdfRVhURU5ERURfUEFHRV9IRUFERVIgICAgSGVhZGVyOyAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KKyAgICBVMzIgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDE7ICAgICAgICAgICAgICAgICAgLyogMHgwOCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE51bVBoeUV2ZW50czsgICAgICAgICAgICAgICAvKiAweDBDICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQyOyAgICAgICAgICAgICAgICAgIC8qIDB4MEQgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDM7ICAgICAgICAgICAgICAgICAgLyogMHgwRSAqLworICAgIE1QSTJfU0FTUEhZM19QSFlfRVZFTlRfQ09ORklHICAgICAgIFBoeUV2ZW50Q29uZmlnCisJCQkJCVtNUEkyX1NBU1BIWTNfUEhZX0VWRU5UX01BWF07IC8qIDB4MTAgKi8KK30gTVBJMl9DT05GSUdfUEFHRV9TQVNfUEhZXzMsIE1QSTJfUE9JTlRFUiBQVFJfTVBJMl9DT05GSUdfUEFHRV9TQVNfUEhZXzMsCisgIE1waTJTYXNQaHlQYWdlM190LCBNUEkyX1BPSU5URVIgcE1waTJTYXNQaHlQYWdlM190OworCisjZGVmaW5lIE1QSTJfU0FTUEhZM19QQUdFVkVSU0lPTiAgICAgICAgICAgICgweDAwKQorCisKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgU0FTIFBvcnQgQ29uZmlnIFBhZ2VzCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfaGlzdG9yeS50eHQgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcGkvbXBpMl9oaXN0b3J5LnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NWZjYWEzCi0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfaGlzdG9yeS50eHQKQEAgLTAsMCArMSwzMzQgQEAKKyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKyBGdXNpb24tTVBUIE1QSSAyLjAgSGVhZGVyIEZpbGUgQ2hhbmdlIEhpc3RvcnkKKyA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KKworIENvcHlyaWdodCAoYykgMjAwMC0yMDA5IExTSSBDb3Jwb3JhdGlvbi4KKworIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorIEhlYWRlciBTZXQgUmVsZWFzZSBWZXJzaW9uOiAgICAwMi4wMC4xMgorIEhlYWRlciBTZXQgUmVsZWFzZSBEYXRlOiAgICAgICAwNS0wNi0wOQorIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCisgRmlsZW5hbWUgICAgICAgICAgICAgICBDdXJyZW50IHZlcnNpb24gICAgIFByaW9yIHZlcnNpb24KKyAtLS0tLS0tLS0tICAgICAgICAgICAgIC0tLS0tLS0tLS0tLS0tLSAgICAgLS0tLS0tLS0tLS0tLQorIG1waTIuaCAgICAgICAgICAgICAgICAgMDIuMDAuMTIgICAgICAgICAgICAwMi4wMC4xMQorIG1waTJfY25mZy5oICAgICAgICAgICAgMDIuMDAuMTEgICAgICAgICAgICAwMi4wMC4xMAorIG1waTJfaW5pdC5oICAgICAgICAgICAgMDIuMDAuMDcgICAgICAgICAgICAwMi4wMC4wNgorIG1waTJfaW9jLmggICAgICAgICAgICAgMDIuMDAuMTEgICAgICAgICAgICAwMi4wMC4xMAorIG1waTJfcmFpZC5oICAgICAgICAgICAgMDIuMDAuMDMgICAgICAgICAgICAwMi4wMC4wMworIG1waTJfc2FzLmggICAgICAgICAgICAgMDIuMDAuMDIgICAgICAgICAgICAwMi4wMC4wMgorIG1waTJfdGFyZy5oICAgICAgICAgICAgMDIuMDAuMDMgICAgICAgICAgICAwMi4wMC4wMworIG1waTJfdG9vbC5oICAgICAgICAgICAgMDIuMDAuMDMgICAgICAgICAgICAwMi4wMC4wMgorIG1waTJfdHlwZS5oICAgICAgICAgICAgMDIuMDAuMDAgICAgICAgICAgICAwMi4wMC4wMAorIG1waTJfcmEuaCAgICAgICAgICAgICAgMDIuMDAuMDAKKyBtcGkyX2hpc3RvcnkudHh0ICAgICAgIDAyLjAwLjExICAgICAgICAgICAgMDIuMDAuMTIKKworCisgKiAgRGF0ZSAgICAgIFZlcnNpb24gICBEZXNjcmlwdGlvbgorICogIC0tLS0tLS0tICAtLS0tLS0tLSAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK21waTIuaAorICogIDA0LTMwLTA3ICAwMi4wMC4wMCAgQ29ycmVzcG9uZHMgdG8gRnVzaW9uLU1QVCBNUEkgU3BlY2lmaWNhdGlvbiBSZXYgQS4KKyAqICAwNi0wNC0wNyAgMDIuMDAuMDEgIEJ1bXBlZCBNUEkyX0hFQURFUl9WRVJTSU9OX1VOSVQuCisgKiAgMDYtMjYtMDcgIDAyLjAwLjAyICBCdW1wZWQgTVBJMl9IRUFERVJfVkVSU0lPTl9VTklULgorICogIDA4LTMxLTA3ICAwMi4wMC4wMyAgQnVtcGVkIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVC4KKyAqICAgICAgICAgICAgICAgICAgICAgIE1vdmVkIFJlcGx5UG9zdEhvc3RJbmRleCByZWdpc3RlciB0byBvZmZzZXQgMHg2QyBvZiB0aGUKKyAqICAgICAgICAgICAgICAgICAgICAgIE1QSTJfU1lTVEVNX0lOVEVSRkFDRV9SRUdTIGFuZCBtb2RpZmllZCB0aGUgZGVmaW5lIGZvcgorICogICAgICAgICAgICAgICAgICAgICAgTVBJMl9SRVBMWV9QT1NUX0hPU1RfSU5ERVhfT0ZGU0VULgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgdW5pb24gb2YgcmVxdWVzdCBkZXNjcmlwdG9ycy4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIHVuaW9uIG9mIHJlcGx5IGRlc2NyaXB0b3JzLgorICogIDEwLTMxLTA3ICAwMi4wMC4wNCAgQnVtcGVkIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVC4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIGRlZmluZSBmb3IgTVBJMl9WRVJTSU9OXzAyXzAwLgorICogICAgICAgICAgICAgICAgICAgICAgRml4ZWQgdGhlIHNpemUgb2YgdGhlIEZ1bmN0aW9uRGVwZW5kZW50NSBmaWVsZCBpbiB0aGUKKyAqICAgICAgICAgICAgICAgICAgICAgIE1QSTJfREVGQVVMVF9SRVBMWSBzdHJ1Y3R1cmUuCisgKiAgMTItMTgtMDcgIDAyLjAwLjA1ICBCdW1wZWQgTVBJMl9IRUFERVJfVkVSU0lPTl9VTklULgorICogICAgICAgICAgICAgICAgICAgICAgUmVtb3ZlZCB0aGUgTVBJLWRlZmluZWQgRmF1bHQgQ29kZXMgYW5kIGV4dGVuZGVkIHRoZQorICogICAgICAgICAgICAgICAgICAgICAgcHJvZHVjdCBzcGVjaWZpYyBjb2RlcyB1cCB0byAweEVGRkYuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBhIHNpeHRoIGtleSB2YWx1ZSBmb3IgdGhlIFdyaXRlU2VxdWVuY2UgcmVnaXN0ZXIKKyAqICAgICAgICAgICAgICAgICAgICAgIGFuZCBjaGFuZ2VkIHRoZSBmbHVzaCB2YWx1ZSB0byAweDAuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBtZXNzYWdlIGZ1bmN0aW9uIGNvZGVzIGZvciBEaWFnbm9zdGljIEJ1ZmZlciBQb3N0CisgKiAgICAgICAgICAgICAgICAgICAgICBhbmQgRGlhZ25zb3RpYyBSZWxlYXNlLgorICogICAgICAgICAgICAgICAgICAgICAgTmV3IElPQ1N0YXR1cyBkZWZpbmU6IE1QSTJfSU9DU1RBVFVTX0RJQUdOT1NUSUNfUkVMRUFTRUQKKyAqICAgICAgICAgICAgICAgICAgICAgIE1vdmVkIE1QSTJfVkVSU0lPTl9VTklPTiBmcm9tIG1waTJfaW9jLmguCisgKiAgMDItMjktMDggIDAyLjAwLjA2ICBCdW1wZWQgTVBJMl9IRUFERVJfVkVSU0lPTl9VTklULgorICogIDAzLTAzLTA4ICAwMi4wMC4wNyAgQnVtcGVkIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVC4KKyAqICAwNS0yMS0wOCAgMDIuMDAuMDggIEJ1bXBlZCBNUEkyX0hFQURFUl9WRVJTSU9OX1VOSVQuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCAjZGVmaW5lcyBmb3IgbWFya2luZyBhIHJlcGx5IGRlc2NyaXB0b3IgYXMgdW51c2VkLgorICogIDA2LTI3LTA4ICAwMi4wMC4wOSAgQnVtcGVkIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVC4KKyAqICAxMC0wMi0wOCAgMDIuMDAuMTAgIEJ1bXBlZCBNUEkyX0hFQURFUl9WRVJTSU9OX1VOSVQuCisgKiAgICAgICAgICAgICAgICAgICAgICBNb3ZlZCBMVU4gZmllbGQgZGVmaW5lcyBmcm9tIG1waTJfaW5pdC5oLgorICogIDAxLTE5LTA5ICAwMi4wMC4xMSAgQnVtcGVkIE1QSTJfSEVBREVSX1ZFUlNJT05fVU5JVC4KKyAqICAwNS0wNi0wOSAgMDIuMDAuMTIgIEJ1bXBlZCBNUEkyX0hFQURFUl9WRVJTSU9OX1VOSVQuCisgKiAgICAgICAgICAgICAgICAgICAgICBJbiBhbGwgcmVxdWVzdCBhbmQgcmVwbHkgZGVzY3JpcHRvcnMsIHJlcGxhY2VkIFZGX0lECisgKiAgICAgICAgICAgICAgICAgICAgICBmaWVsZCB3aXRoIE1TSXhJbmRleCBmaWVsZC4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgRGV2SGFuZGxlIGZpZWxkIGZyb20KKyAqICAgICAgICAgICAgICAgICAgICAgIE1QSTJfU0NTSV9JT19TVUNDRVNTX1JFUExZX0RFU0NSSVBUT1IgYW5kIG1hZGUgdGhvc2UKKyAqICAgICAgICAgICAgICAgICAgICAgIGJ5dGVzIHJlc2VydmVkLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgUkFJRCBBY2NlbGVyYXRvciBmdW5jdGlvbmFsaXR5LgorICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK21waTJfY25mZy5oCisgKiAgMDQtMzAtMDcgIDAyLjAwLjAwICBDb3JyZXNwb25kcyB0byBGdXNpb24tTVBUIE1QSSBTcGVjaWZpY2F0aW9uIFJldiBBLgorICogIDA2LTA0LTA3ICAwMi4wMC4wMSAgQWRkZWQgZGVmaW5lcyBmb3IgU0FTIElPIFVuaXQgUGFnZSAyIFBoeUZsYWdzLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTWFudWZhY3R1cmluZyBQYWdlIDExLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTVBJMl9TQVNfRVhQQU5ERVIwX0ZMQUdTX0NPTk5FQ1RPUl9FTkRfREVWSUNFCisgKiAgICAgICAgICAgICAgICAgICAgICBkZWZpbmUuCisgKiAgMDYtMjYtMDcgIDAyLjAwLjAyICBBZGRpbmcgZ2VuZXJpYyBzdHJ1Y3R1cmUgZm9yIHByb2R1Y3Qtc3BlY2lmaWMKKyAqICAgICAgICAgICAgICAgICAgICAgIE1hbnVmYWN0dXJpbmcgcGFnZXM6IE1QSTJfQ09ORklHX1BBR0VfTUFOVUZBQ1RVUklOR19QUy4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJld29yayBvZiBCSU9TIFBhZ2UgMiBjb25maWd1cmF0aW9uIHBhZ2UuCisgKiAgICAgICAgICAgICAgICAgICAgICBGaXhlZCBNUEkyX0JJT1NQQUdFMl9CT09UX0RFVklDRSB0byBiZSBhIHVuaW9uIG9mIHRoZQorICogICAgICAgICAgICAgICAgICAgICAgZm9ybXMuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBjb25maWd1cmF0aW9uIHBhZ2VzIElPQyBQYWdlIDggYW5kIERyaXZlcgorICogICAgICAgICAgICAgICAgICAgICAgUGVyc2lzdGVudCBNYXBwaW5nIFBhZ2UgMC4KKyAqICAwOC0zMS0wNyAgMDIuMDAuMDMgIE1vZGlmaWVkIGNvbmZpZ3VyYXRpb24gcGFnZXMgZGVhbGluZyB3aXRoIEludGVncmF0ZWQKKyAqICAgICAgICAgICAgICAgICAgICAgIFJBSUQgKE1hbnVmYWN0dXJpbmcgUGFnZSA0LCBSQUlEIFZvbHVtZSBQYWdlcyAwIGFuZCAxLAorICogICAgICAgICAgICAgICAgICAgICAgUkFJRCBQaHlzaWNhbCBEaXNrIFBhZ2VzIDAgYW5kIDEsIFJBSUQgQ29uZmlndXJhdGlvbgorICogICAgICAgICAgICAgICAgICAgICAgUGFnZSAwKS4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIG5ldyB2YWx1ZSBmb3IgQWNjZXNzU3RhdHVzIGZpZWxkIG9mIFNBUyBEZXZpY2UKKyAqICAgICAgICAgICAgICAgICAgICAgIFBhZ2UgMCAoX1NBVEFfTkVFRFNfSU5JVElBTElaQVRJT04pLgorICogIDEwLTMxLTA3ICAwMi4wMC4wNCAgQWRkZWQgbWlzc2luZyBTRVBEZXZIYW5kbGUgZmllbGQgdG8KKyAqICAgICAgICAgICAgICAgICAgICAgIE1QSTJfQ09ORklHX1BBR0VfU0FTX0VOQ0xPU1VSRV8wLgorICogIDEyLTE4LTA3ICAwMi4wMC4wNSAgTW9kaWZpZWQgSU8gVW5pdCBQYWdlIDAgdG8gdXNlIDMyLWJpdCB2ZXJzaW9uIGZpZWxkcyBmb3IKKyAqICAgICAgICAgICAgICAgICAgICAgIE5WREFUQS4KKyAqICAgICAgICAgICAgICAgICAgICAgIE1vZGlmaWVkIElPQyBQYWdlIDcgdG8gdXNlIG1hc2tzIGFuZCBhZGRlZCBmaWVsZCBmb3IKKyAqICAgICAgICAgICAgICAgICAgICAgIFNBU0Jyb2FkY2FzdFByaW1pdGl2ZU1hc2tzLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTVBJMl9DT05GSUdfUEFHRV9CSU9TXzQuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBNUEkyX0NPTkZJR19QQUdFX0xPR18wLgorICogIDAyLTI5LTA4ICAwMi4wMC4wNiAgTW9kaWZpZWQgdmFyaW91cyBuYW1lcyB0byBtYWtlIHRoZW0gMzItY2hhcmFjdGVyIHVuaXF1ZS4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIFNBUyBEZXZpY2UgSURzLgorICogICAgICAgICAgICAgICAgICAgICAgVXBkYXRlZCBJbnRlZ3JhdGVkIFJBSUQgY29uZmlndXJhdGlvbiBwYWdlcyBpbmNsdWRpbmcKKyAqICAgICAgICAgICAgICAgICAgICAgIE1hbnVmYWN0dXJpbmcgUGFnZSA0LCBJT0MgUGFnZSA2LCBhbmQgUkFJRCBDb25maWd1cmF0aW9uCisgKiAgICAgICAgICAgICAgICAgICAgICBQYWdlIDAuCisgKiAgMDUtMjEtMDggIDAyLjAwLjA3ICBBZGRlZCBkZWZpbmUgTVBJMl9NQU5QQUdFNF9NSVhfU1NEX1NBU19TQVRBLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgZGVmaW5lIE1QSTJfTUFOUEFHRTRfUEhZU0RJU0tfMTI4TUJfQ09FUkNJT04uCisgKiAgICAgICAgICAgICAgICAgICAgICBGaXhlZCBkZWZpbmUgTVBJMl9JT0NQQUdFOF9GTEFHU19FTkNMT1NVUkVfU0xPVF9NQVBQSU5HLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgbWlzc2luZyBNYXhOdW1Sb3V0ZWRTYXNBZGRyZXNzZXMgZmllbGQgdG8KKyAqICAgICAgICAgICAgICAgICAgICAgIE1QSTJfQ09ORklHX1BBR0VfRVhQQU5ERVJfMC4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIFNBUyBQb3J0IFBhZ2UgMC4KKyAqICAgICAgICAgICAgICAgICAgICAgIE1vZGlmaWVkIHN0cnVjdHVyZSBsYXlvdXQgZm9yCisgKiAgICAgICAgICAgICAgICAgICAgICBNUEkyX0NPTkZJR19QQUdFX0RSSVZFUl9NQVBQSU5HXzAuCisgKiAgMDYtMjctMDggIDAyLjAwLjA4ICBDaGFuZ2VkIE1QSTJfQ09ORklHX1BBR0VfUkRfUERJU0tfMSB0byB1c2UKKyAqICAgICAgICAgICAgICAgICAgICAgIE1QSTJfUkFJRF9QSFlTX0RJU0sxX1BBVEhfTUFYIHRvIHNpemUgdGhlIGFycmF5LgorICogIDEwLTAyLTA4ICAwMi4wMC4wOSAgQ2hhbmdlZCBNUEkyX1JBSURfUEdBRF9DT05GSUdOVU1fTUFTSyBmcm9tIDB4MDAwMEZGRkYKKyAqICAgICAgICAgICAgICAgICAgICAgIHRvIDB4MDAwMDAwRkYuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCB0d28gbmV3IHZhbHVlcyBmb3IgdGhlIFBoeXNpY2FsIERpc2sgQ29lcmNpb24gU2l6ZQorICogICAgICAgICAgICAgICAgICAgICAgYml0cyBpbiB0aGUgRmxhZ3MgZmllbGQgb2YgTWFudWZhY3R1cmluZyBQYWdlIDQuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBwcm9kdWN0LXNwZWNpZmljIE1hbnVmYWN0dXJpbmcgcGFnZXMgMTYgdG8gMzEuCisgKiAgICAgICAgICAgICAgICAgICAgICBNb2RpZmllZCBGbGFncyBiaXRzIGZvciBjb250cm9sbGluZyB3cml0ZSBjYWNoZSBvbiBTQVRBCisgKiAgICAgICAgICAgICAgICAgICAgICBkcml2ZXMgaW4gSU8gVW5pdCBQYWdlIDEuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBuZXcgYml0IHRvIEFkZGl0aW9uYWxDb250cm9sRmxhZ3Mgb2YgU0FTIElPIFVuaXQKKyAqICAgICAgICAgICAgICAgICAgICAgIFBhZ2UgMSB0byBjb250cm9sIEludmFsaWQgVG9wb2xvZ3kgQ29ycmVjdGlvbi4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIFN1cHBvcnRlZFBoeXNEaXNrcyBmaWVsZCB0byBSQUlEIFZvbHVtZSBQYWdlIDEgYW5kCisgKiAgICAgICAgICAgICAgICAgICAgICBhZGRlZCByZWxhdGVkIGRlZmluZXMuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBhZGRpdGlvbmFsIGRlZmluZXMgZm9yIFJBSUQgVm9sdW1lIFBhZ2UgMAorICogICAgICAgICAgICAgICAgICAgICAgVm9sdW1lU3RhdHVzRmxhZ3MgZmllbGQuCisgKiAgICAgICAgICAgICAgICAgICAgICBNb2RpZmllZCBtZWFuaW5nIG9mIFJBSUQgVm9sdW1lIFBhZ2UgMCBWb2x1bWVTZXR0aW5ncworICogICAgICAgICAgICAgICAgICAgICAgZGVmaW5lIGZvciBhdXRvLWNvbmZpZ3VyZSBvZiBob3Qtc3dhcCBkcml2ZXMuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBQaHlzRGlza0F0dHJpYnV0ZXMgZmllbGQgKGFuZCByZWxhdGVkIGRlZmluZXMpIHRvCisgKiAgICAgICAgICAgICAgICAgICAgICBSQUlEIFBoeXNpY2FsIERpc2sgUGFnZSAwLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTVBJMl9TQVNfUEhZSU5GT19QSFlfVkFDQU5UIGRlZmluZS4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIHRocmVlIG5ldyBEaXNjb3ZlcnlTdGF0dXMgYml0cyBmb3IgU0FTIElPIFVuaXQKKyAqICAgICAgICAgICAgICAgICAgICAgIFBhZ2UgMCBhbmQgU0FTIEV4cGFuZGVyIFBhZ2UgMC4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgbXVsdGlwbGV4aW5nIGluZm9ybWF0aW9uIGZyb20gU0FTIElPIFVuaXQgcGFnZXMuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBCb290RGV2aWNlV2FpdFRpbWUgZmllbGQgdG8gU0FTIElPIFVuaXQgUGFnZSA0LgorICogICAgICAgICAgICAgICAgICAgICAgUmVtb3ZlZCBab25lIEFkZHJlc3MgUmVzb2x2ZWQgYml0IGZyb20gUGh5SW5mbyBhbmQgZnJvbQorICogICAgICAgICAgICAgICAgICAgICAgRXhwYW5kZXIgUGFnZSAwIEZsYWdzIGZpZWxkLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgdHdvIG5ldyBBY2Nlc3NTdGF0dXMgdmFsdWVzIHRvIFNBUyBEZXZpY2UgUGFnZSAwCisgKiAgICAgICAgICAgICAgICAgICAgICBmb3IgaW5kaWNhdGluZyByb3V0aW5nIHByb2JsZW1zLiBBZGRlZCAzIHJlc2VydmVkIHdvcmRzCisgKiAgICAgICAgICAgICAgICAgICAgICB0byB0aGlzIHBhZ2UuCisgKiAgMDEtMTktMDkgIDAyLjAwLjEwICBGaXhlZCBkZWZpbmVzIGZvciBHUElPVmFsIGZpZWxkIG9mIElPIFVuaXQgUGFnZSAzLgorICogICAgICAgICAgICAgICAgICAgICAgSW5zZXJ0ZWQgbWlzc2luZyByZXNlcnZlZCBmaWVsZCBpbnRvIHN0cnVjdHVyZSBmb3IgSU9DCisgKiAgICAgICAgICAgICAgICAgICAgICBQYWdlIDYuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBtb3JlIHBlbmRpbmcgdGFzayBiaXRzIHRvIFJBSUQgVm9sdW1lIFBhZ2UgMAorICogICAgICAgICAgICAgICAgICAgICAgVm9sdW1lU3RhdHVzRmxhZ3MgZGVmaW5lcy4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIE1QSTJfUEhZU0RJU0swX1NUQVRVU19GTEFHX05PVF9DRVJUSUZJRUQgZGVmaW5lLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgYSBuZXcgRGlzY292ZXJ5U3RhdHVzIGJpdCBmb3IgU0FTIElPIFVuaXQgUGFnZSAwCisgKiAgICAgICAgICAgICAgICAgICAgICBhbmQgU0FTIEV4cGFuZGVyIFBhZ2UgMCB0byBmbGFnIGEgZG93bnN0cmVhbSBpbml0aWF0b3IKKyAqICAgICAgICAgICAgICAgICAgICAgIHdoZW4gaW4gc2ltcGxpZmllZCByb3V0aW5nIG1vZGUuCisgKiAgICAgICAgICAgICAgICAgICAgICBSZW1vdmVkIFNBVEEgSW5pdCBGYWlsdXJlIGRlZmluZXMgZm9yIERpc2NvdmVyeVN0YXR1cworICogICAgICAgICAgICAgICAgICAgICAgZmllbGRzIG9mIFNBUyBJTyBVbml0IFBhZ2UgMCBhbmQgU0FTIEV4cGFuZGVyIFBhZ2UgMC4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIE1QSTJfU0FTX0RFVklDRTBfQVNUQVRVU19ERVZJQ0VfQkxPQ0tFRCBkZWZpbmUuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBQb3J0R3JvdXBzLCBEbWFHcm91cCwgYW5kIENvbnRyb2xHcm91cCBmaWVsZHMgdG8KKyAqICAgICAgICAgICAgICAgICAgICAgIFNBUyBEZXZpY2UgUGFnZSAwLgorICogIDA1LTA2LTA5ICAwMi4wMC4xMSAgQWRkZWQgc3RydWN0dXJlcyBhbmQgZGVmaW5lcyBmb3IgSU8gVW5pdCBQYWdlIDUgYW5kIElPCisgKiAgICAgICAgICAgICAgICAgICAgICBVbml0IFBhZ2UgNi4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIGV4cGFuZGVyIHJlZHVjZWQgZnVuY3Rpb25hbGl0eSBkYXRhIHRvIFNBUworICogICAgICAgICAgICAgICAgICAgICAgRXhwYW5kZXIgUGFnZSAwLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgU0FTIFBIWSBQYWdlIDIgYW5kIFNBUyBQSFkgUGFnZSAzLgorICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK21waTJfaW5pdC5oCisgKiAgMDQtMzAtMDcgIDAyLjAwLjAwICBDb3JyZXNwb25kcyB0byBGdXNpb24tTVBUIE1QSSBTcGVjaWZpY2F0aW9uIFJldiBBLgorICogIDEwLTMxLTA3ICAwMi4wMC4wMSAgRml4ZWQgbmFtZSBmb3IgcE1waTJTQ1NJVGFza01hbmFnZW1lbnRSZXF1ZXN0X3QuCisgKiAgMTItMTgtMDcgIDAyLjAwLjAyICBNb2RpZmllZCBUYXNrIE1hbmFnZW1lbnQgVGFyZ2V0IFJlc2V0IE1ldGhvZCBkZWZpbmVzLgorICogIDAyLTI5LTA4ICAwMi4wMC4wMyAgQWRkZWQgUXVlcnkgVGFzayBTZXQgYW5kIFF1ZXJ5IFVuaXQgQXR0ZW50aW9uLgorICogIDAzLTAzLTA4ICAwMi4wMC4wNCAgRml4ZWQgbmFtZSBvZiBzdHJ1Y3QgX01QSTJfU0NTSV9UQVNLX01BTkFHRV9SRVBMWS4KKyAqICAwNS0yMS0wOCAgMDIuMDAuMDUgIEZpeGVkIHR5cG8gaW4gbmFtZSBvZiBNcGkyU2VwUmVxdWVzdF90LgorICogIDEwLTAyLTA4ICAwMi4wMC4wNiAgUmVtb3ZlZCBVbnRhZ2dlZCBhbmQgTm8gRGlzY29ubmVjdCB2YWx1ZXMgZnJvbSBTQ1NJIElPCisgKiAgICAgICAgICAgICAgICAgICAgICBDb250cm9sIGZpZWxkIFRhc2sgQXR0cmlidXRlIGZsYWdzLgorICogICAgICAgICAgICAgICAgICAgICAgTW92ZWQgTFVOIGZpZWxkIGRlZmluZXMgdG8gbXBpMi5oIGJlY2FzdWUgdGhleSBhcmUKKyAqICAgICAgICAgICAgICAgICAgICAgIGNvbW1vbiB0byBtYW55IHN0cnVjdHVyZXMuCisgKiAgMDUtMDYtMDkgIDAyLjAwLjA3ICBDaGFuZ2VkIHRhc2sgbWFuYWdlbWVudCB0eXBlIG9mIFF1ZXJ5IFVuaXQgQXR0ZW50aW9uIHRvCisgKiAgICAgICAgICAgICAgICAgICAgICBRdWVyeSBBc3luY2hyb25vdXMgRXZlbnQuCisgKiAgICAgICAgICAgICAgICAgICAgICBEZWZpbmVkIHR3byBuZXcgYml0cyBpbiB0aGUgU2xvdFN0YXR1cyBmaWVsZCBvZiB0aGUgU0NTSQorICogICAgICAgICAgICAgICAgICAgICAgRW5jbG9zdXJlIFByb2Nlc3NvciBSZXF1ZXN0IGFuZCBSZXBseS4KKyAqICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCittcGkyX2lvYy5oCisgKiAgMDQtMzAtMDcgIDAyLjAwLjAwICBDb3JyZXNwb25kcyB0byBGdXNpb24tTVBUIE1QSSBTcGVjaWZpY2F0aW9uIFJldiBBLgorICogIDA2LTA0LTA3ICAwMi4wMC4wMSAgSW4gSU9DRmFjdHMgUmVwbHkgc3RydWN0dXJlLCByZW5hbWVkIE1heERldmljZXMgdG8KKyAqICAgICAgICAgICAgICAgICAgICAgIE1heFRhcmdldHMuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBUb3RhbEltYWdlU2l6ZSBmaWVsZCB0byBGV0Rvd25sb2FkIFJlcXVlc3QuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCByZXNlcnZlZCB3b3JkcyB0byBGV1VwbG9hZCBSZXF1ZXN0LgorICogIDA2LTI2LTA3ICAwMi4wMC4wMiAgQWRkZWQgSVIgQ29uZmlndXJhdGlvbiBDaGFuZ2UgTGlzdCBFdmVudC4KKyAqICAwOC0zMS0wNyAgMDIuMDAuMDMgIFJlbW92ZWQgU3lzdGVtUmVwbHlRdWV1ZURlcHRoIGZpZWxkIGZyb20gdGhlIElPQ0luaXQKKyAqICAgICAgICAgICAgICAgICAgICAgIHJlcXVlc3QgYW5kIHJlcGxhY2VkIGl0IHdpdGgKKyAqICAgICAgICAgICAgICAgICAgICAgIFJlcGx5RGVzY3JpcHRvclBvc3RRdWV1ZURlcHRoIGFuZCBSZXBseUZyZWVRdWV1ZURlcHRoLgorICogICAgICAgICAgICAgICAgICAgICAgUmVwbGFjZWQgdGhlIE1pblJlcGx5UXVldWVEZXB0aCBmaWVsZCBvZiB0aGUgSU9DRmFjdHMKKyAqICAgICAgICAgICAgICAgICAgICAgIHJlcGx5IHdpdGggTWF4UmVwbHlEZXNjcmlwdG9yUG9zdFF1ZXVlRGVwdGguCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBNUEkyX1JEUFFfREVQVEhfTUlOIGRlZmluZSB0byBzcGVjaWZ5IHRoZSBtaW5pbXVtCisgKiAgICAgICAgICAgICAgICAgICAgICBkZXB0aCBmb3IgdGhlIFJlcGx5IERlc2NyaXB0b3IgUG9zdCBRdWV1ZS4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIFNBU0FkZHJlc3MgZmllbGQgdG8gSW5pdGlhdG9yIERldmljZSBUYWJsZQorICogICAgICAgICAgICAgICAgICAgICAgT3ZlcmZsb3cgRXZlbnQgZGF0YS4KKyAqICAxMC0zMS0wNyAgMDIuMDAuMDQgIEFkZGVkIFJlYXNvbkNvZGUgTVBJMl9FVkVOVF9TQVNfSU5JVF9SQ19OT1RfUkVTUE9ORElORworICogICAgICAgICAgICAgICAgICAgICAgZm9yIFNBUyBJbml0aWF0b3IgRGV2aWNlIFN0YXR1cyBDaGFuZ2UgRXZlbnQgZGF0YS4KKyAqICAgICAgICAgICAgICAgICAgICAgIE1vZGlmaWVkIFJlYXNvbiBDb2RlIGRlZmluZXMgZm9yIFNBUyBUb3BvbG9neSBDaGFuZ2UKKyAqICAgICAgICAgICAgICAgICAgICAgIExpc3QgRXZlbnQgZGF0YSwgaW5jbHVkaW5nIGFkZGluZyBhIGJpdCBmb3IgUEhZIFZhY2FudAorICogICAgICAgICAgICAgICAgICAgICAgc3RhdHVzLCBhbmQgYWRkaW5nIGEgbWFzayBmb3IgdGhlIFJlYXNvbiBDb2RlLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgZGVmaW5lIGZvcgorICogICAgICAgICAgICAgICAgICAgICAgTVBJMl9FVkVOVF9TQVNfVE9QT19FU19ERUxBWV9OT1RfUkVTUE9ORElORy4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIGRlZmluZSBmb3IgTVBJMl9FWFRfSU1BR0VfVFlQRV9NRUdBUkFJRC4KKyAqICAxMi0xOC0wNyAgMDIuMDAuMDUgIEFkZGVkIEJvb3QgU3RhdHVzIGRlZmluZXMgZm9yIHRoZSBJT0NFeGNlcHRpb25zIGZpZWxkIG9mCisgKiAgICAgICAgICAgICAgICAgICAgICB0aGUgSU9DRmFjdHMgUmVwbHkuCisgKiAgICAgICAgICAgICAgICAgICAgICBSZW1vdmVkIE1QSTJfSU9DRkFDVFNfQ0FQQUJJTElUWV9FWFRFTkRFRF9CVUZGRVIgZGVmaW5lLgorICogICAgICAgICAgICAgICAgICAgICAgTW92ZWQgTVBJMl9WRVJTSU9OX1VOSU9OIHRvIG1waTIuaC4KKyAqICAgICAgICAgICAgICAgICAgICAgIENoYW5nZWQgTVBJMl9FVkVOVF9OT1RJRklDQVRJT05fUkVRVUVTVCB0byB1c2UgbWFza3MKKyAqICAgICAgICAgICAgICAgICAgICAgIGluc3RlYWQgb2YgZW5hYmxlcywgYW5kIGFkZGVkIFNBU0Jyb2FkY2FzdFByaW1pdGl2ZU1hc2tzCisgKiAgICAgICAgICAgICAgICAgICAgICBmaWVsZC4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIExvZyBFbnRyeSBBZGRlZCBFdmVudCBhbmQgcmVsYXRlZCBzdHJ1Y3R1cmUuCisgKiAgMDItMjktMDggIDAyLjAwLjA2ICBBZGRlZCBkZWZpbmUgTVBJMl9JT0NGQUNUU19DQVBBQklMSVRZX0lOVEVHUkFURURfUkFJRC4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgZGVmaW5lIE1QSTJfSU9DRkFDVFNfUFJPVE9DT0xfU01QX1RBUkdFVC4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIE1heFZvbHVtZXMgYW5kIE1heFBlcnNpc3RlbnRFbnRyaWVzIGZpZWxkcyB0bworICogICAgICAgICAgICAgICAgICAgICAgSU9DRmFjdHMgcmVwbHkuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBQcm90b2NhbEZsYWdzIGFuZCBJT0NDYXBhYmlsaXRpZXMgZmllbGRzIHRvCisgKiAgICAgICAgICAgICAgICAgICAgICBNUEkyX0ZXX0lNQUdFX0hFQURFUi4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgTVBJMl9QT1JURU5BQkxFX0ZMQUdTX0VOQUJMRV9TSU5HTEVfUE9SVC4KKyAqICAwMy0wMy0wOCAgMDIuMDAuMDcgIEZpeGVkIE1QSTJfRldfSU1BR0VfSEVBREVSIGJ5IGNoYW5naW5nIFJlc2VydmVkMjYgdG8KKyAqICAgICAgICAgICAgICAgICAgICAgIGEgVTE2IChmcm9tIGEgVTMyKS4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgZXh0cmEgJ3MnIGZyb20gRXZlbnRNYXNrcyBuYW1lLgorICogIDA2LTI3LTA4ICAwMi4wMC4wOCAgRml4ZWQgYW4gb2Zmc2V0IGluIGEgY29tbWVudC4KKyAqICAxMC0wMi0wOCAgMDIuMDAuMDkgIFJlbW92ZWQgU3lzdGVtUmVwbHlGcmFtZVNpemUgZnJvbSBNUEkyX0lPQ19JTklUX1JFUVVFU1QuCisgKiAgICAgICAgICAgICAgICAgICAgICBSZW1vdmVkIEN1clJlcGx5RnJhbWVTaXplIGZyb20gTVBJMl9JT0NfRkFDVFNfUkVQTFkgYW5kCisgKiAgICAgICAgICAgICAgICAgICAgICByZW5hbWVkIE1pblJlcGx5RnJhbWVTaXplIHRvIFJlcGx5RnJhbWVTaXplLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTVBJMl9JT0NGQUNUU19FWENFUFRfSVJfRk9SRUlHTl9DT05GSUdfTUFYLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgdHdvIG5ldyBSQUlET3BlcmF0aW9uIHZhbHVlcyBmb3IgSW50ZWdyYXRlZCBSQUlECisgKiAgICAgICAgICAgICAgICAgICAgICBPcGVyYXRpb25zIFN0YXR1cyBFdmVudCBkYXRhLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgZm91ciBuZXcgSVIgQ29uZmlndXJhdGlvbiBDaGFuZ2UgTGlzdCBFdmVudCBkYXRhCisgKiAgICAgICAgICAgICAgICAgICAgICBSZWFzb25Db2RlIHZhbHVlcy4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIHR3byBuZXcgUmVhc29uQ29kZSBkZWZpbmVzIGZvciBTQVMgRGV2aWNlIFN0YXR1cworICogICAgICAgICAgICAgICAgICAgICAgQ2hhbmdlIEV2ZW50IGRhdGEuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCB0aHJlZSBuZXcgRGlzY292ZXJ5U3RhdHVzIGJpdHMgZm9yIHRoZSBTQVMKKyAqICAgICAgICAgICAgICAgICAgICAgIERpc2NvdmVyeSBldmVudCBkYXRhLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTXVsdGlwbGV4aW5nIFN0YXR1cyBDaGFuZ2UgYml0IHRvIHRoZSBQaHlTdGF0dXMKKyAqICAgICAgICAgICAgICAgICAgICAgIGZpZWxkIG9mIHRoZSBTQVMgVG9wb2xvZ3kgQ2hhbmdlIExpc3QgZXZlbnQgZGF0YS4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgZGVmaW5lIGZvciBNUEkyX0lOSVRfSU1BR0VfQk9PVEZMQUdTX1hNRU1DT1BZLgorICogICAgICAgICAgICAgICAgICAgICAgQm9vdEZsYWdzIGFyZSBub3cgcHJvZHVjdC1zcGVjaWZpYy4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIGRlZmluZXMgZm9yIHRoZSBpbmRpdmR1YWwgc2lnbmF0dXJlIGJ5dGVzCisgKiAgICAgICAgICAgICAgICAgICAgICBmb3IgTVBJMl9JTklUX0lNQUdFX0ZPT1RFUi4KKyAqICAwMS0xOS0wOSAgMDIuMDAuMTAgIEFkZGVkIE1QSTJfSU9DRkFDVFNfQ0FQQUJJTElUWV9FVkVOVF9SRVBMQVkgZGVmaW5lLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTVBJMl9FVkVOVF9TQVNfRElTQ19EU19ET1dOU1RSRUFNX0lOSVRJQVRPUgorICogICAgICAgICAgICAgICAgICAgICAgZGVmaW5lLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfU0FUQV9JTklUX0ZBSUxVUkUKKyAqICAgICAgICAgICAgICAgICAgICAgIGRlZmluZS4KKyAqICAgICAgICAgICAgICAgICAgICAgIFJlbW92ZWQgTVBJMl9FVkVOVF9TQVNfRElTQ19EU19TQVRBX0lOSVRfRkFJTFVSRSBkZWZpbmUuCisgKiAgMDUtMDYtMDkgIDAyLjAwLjExICBBZGRlZCBNUEkyX0lPQ0ZBQ1RTX0NBUEFCSUxJVFlfUkFJRF9BQ0NFTEVSQVRPUiBkZWZpbmUuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBNUEkyX0lPQ0ZBQ1RTX0NBUEFCSUxJVFlfTVNJX1hfSU5ERVggZGVmaW5lLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgdHdvIG5ldyByZWFzb24gY29kZXMgZm9yIFNBUyBEZXZpY2UgU3RhdHVzIENoYW5nZQorICogICAgICAgICAgICAgICAgICAgICAgRXZlbnQuCisgKiAgICAgICAgICAgICAgICAgICAgICBBZGRlZCBuZXcgZXZlbnQ6IFNBUyBQSFkgQ291bnRlci4KKyAqICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCittcGkyX3JhaWQuaAorICogIDA0LTMwLTA3ICAwMi4wMC4wMCAgQ29ycmVzcG9uZHMgdG8gRnVzaW9uLU1QVCBNUEkgU3BlY2lmaWNhdGlvbiBSZXYgQS4KKyAqICAwOC0zMS0wNyAgMDIuMDAuMDEgIE1vZGlmaWNhdGlvbnMgdG8gUkFJRCBBY3Rpb24gcmVxdWVzdCBhbmQgcmVwbHksCisgKiAgICAgICAgICAgICAgICAgICAgICBpbmNsdWRpbmcgdGhlIEFjdGlvbnMgYW5kIEFjdGlvbkRhdGEuCisgKiAgMDItMjktMDggIDAyLjAwLjAyICBBZGRlZCBNUEkyX1JBSURfQUNUSU9OX0FEQVRBX0RJU0FCTF9GVUxMX1JFQlVJTEQuCisgKiAgMDUtMjEtMDggIDAyLjAwLjAzICBBZGRlZCBNUEkyX1JBSURfVk9MX0NSRUFUSU9OX05VTV9QSFlTRElTS1Mgc28gdGhhdAorICogICAgICAgICAgICAgICAgICAgICAgdGhlIFBoeXNEaXNrIGFycmF5IGluIE1QSTJfUkFJRF9WT0xVTUVfQ1JFQVRJT05fU1RSVUNUCisgKiAgICAgICAgICAgICAgICAgICAgICBjYW4gYmUgc2l6ZWQgYnkgdGhlIGJ1aWxkIGVudmlyb25tZW50LgorICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK21waTJfc2FzLmgKKyAqICAwNC0zMC0wNyAgMDIuMDAuMDAgIENvcnJlc3BvbmRzIHRvIEZ1c2lvbi1NUFQgTVBJIFNwZWNpZmljYXRpb24gUmV2IEEuCisgKiAgMDYtMjYtMDcgIDAyLjAwLjAxICBBZGRlZCBDbGVhciBBbGwgUGVyc2lzdGVudCBPcGVyYXRpb24gdG8gU0FTIElPIFVuaXQKKyAqICAgICAgICAgICAgICAgICAgICAgIENvbnRyb2wgUmVxdWVzdC4KKyAqICAxMC0wMi0wOCAgMDIuMDAuMDIgIEFkZGVkIFNldCBJT0MgUGFyYW1ldGVyIE9wZXJhdGlvbiB0byBTQVMgSU8gVW5pdCBDb250cm9sCisgKiAgICAgICAgICAgICAgICAgICAgICBSZXF1ZXN0LgorICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKK21waTJfdGFyZy5oCisgKiAgMDQtMzAtMDcgIDAyLjAwLjAwICBDb3JyZXNwb25kcyB0byBGdXNpb24tTVBUIE1QSSBTcGVjaWZpY2F0aW9uIFJldiBBLgorICogIDA4LTMxLTA3ICAwMi4wMC4wMSAgQWRkZWQgQ29tbWFuZCBCdWZmZXIgRGF0YSBMb2NhdGlvbiBBZGRyZXNzIFNwYWNlIGJpdHMgdG8KKyAqICAgICAgICAgICAgICAgICAgICAgIEJ1ZmZlclBvc3RGbGFncyBmaWVsZCBvZiBDb21tYW5kQnVmZmVyUG9zdEJhc2UgUmVxdWVzdC4KKyAqICAwMi0yOS0wOCAgMDIuMDAuMDIgIE1vZGlmaWVkIHZhcmlvdXMgbmFtZXMgdG8gbWFrZSB0aGVtIDMyLWNoYXJhY3RlciB1bmlxdWUuCisgKiAgMTAtMDItMDggIDAyLjAwLjAzICBSZW1vdmVkIE5leHRDbWRCdWZmZXJPZmZzZXQgZnJvbQorICogICAgICAgICAgICAgICAgICAgICAgTVBJMl9UQVJHRVRfQ01EX0JVRl9QT1NUX0JBU0VfUkVRVUVTVC4KKyAqICAgICAgICAgICAgICAgICAgICAgIFRhcmdldCBTdGF0dXMgU2VuZCBSZXF1ZXN0IG9ubHkgdGFrZXMgYSBzaW5nbGUgU0dFIGZvcgorICogICAgICAgICAgICAgICAgICAgICAgcmVzcG9uc2UgZGF0YS4KKyAqICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQorCittcGkyX3Rvb2wuaAorICogIDA0LTMwLTA3ICAwMi4wMC4wMCAgQ29ycmVzcG9uZHMgdG8gRnVzaW9uLU1QVCBNUEkgU3BlY2lmaWNhdGlvbiBSZXYgQS4KKyAqICAxMi0xOC0wNyAgMDIuMDAuMDEgIEFkZGVkIERpYWdub3N0aWMgQnVmZmVyIFBvc3QgYW5kIERpYWdub3N0aWMgUmVsZWFzZQorICogICAgICAgICAgICAgICAgICAgICAgc3RydWN0dXJlcyBhbmQgZGVmaW5lcy4KKyAqICAwMi0yOS0wOCAgMDIuMDAuMDIgIE1vZGlmaWVkIHZhcmlvdXMgbmFtZXMgdG8gbWFrZSB0aGVtIDMyLWNoYXJhY3RlciB1bmlxdWUuCisgKiAgMDUtMDYtMDkgIDAyLjAwLjAzICBBZGRlZCBJU1RXSSBSZWFkIFdyaXRlIFRvb2wgYW5kIERpYWdub3N0aWMgQ0xJIFRvb2wuCisgKiAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworbXBpMl90eXBlLmgKKyAqICAwNC0zMC0wNyAgMDIuMDAuMDAgIENvcnJlc3BvbmRzIHRvIEZ1c2lvbi1NUFQgTVBJIFNwZWNpZmljYXRpb24gUmV2IEEuCisgKiAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworbXBpMl9yYS5oCisgKiAgMDUtMDYtMDkgIDAyLjAwLjAwICBJbml0aWFsIHZlcnNpb24uCisgKiAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworbXBpMl9oaXN0b3J5LnR4dCAgICAgICAgIFBhcnRzIGxpc3QgaGlzdG9yeQorCitGaWxlbmFtZSAgICAgMDIuMDAuMTIKKy0tLS0tLS0tLS0gICAtLS0tLS0tLQorbXBpMi5oICAgICAgIDAyLjAwLjEyCittcGkyX2NuZmcuaCAgMDIuMDAuMTEKK21waTJfaW5pdC5oICAwMi4wMC4wNworbXBpMl9pb2MuaCAgIDAyLjAwLjExCittcGkyX3JhaWQuaCAgMDIuMDAuMDMKK21waTJfc2FzLmggICAwMi4wMC4wMgorbXBpMl90YXJnLmggIDAyLjAwLjAzCittcGkyX3Rvb2wuaCAgMDIuMDAuMDMKK21waTJfdHlwZS5oICAwMi4wMC4wMAorbXBpMl9yYS5oICAgIDAyLjAwLjAwCisKK0ZpbGVuYW1lICAgICAwMi4wMC4xMSAgMDIuMDAuMTAgIDAyLjAwLjA5ICAwMi4wMC4wOCAgMDIuMDAuMDcgIDAyLjAwLjA2CistLS0tLS0tLS0tICAgLS0tLS0tLS0gIC0tLS0tLS0tICAtLS0tLS0tLSAgLS0tLS0tLS0gIC0tLS0tLS0tICAtLS0tLS0tLQorbXBpMi5oICAgICAgIDAyLjAwLjExICAwMi4wMC4xMCAgMDIuMDAuMDkgIDAyLjAwLjA4ICAwMi4wMC4wNyAgMDIuMDAuMDYKK21waTJfY25mZy5oICAwMi4wMC4xMCAgMDIuMDAuMDkgIDAyLjAwLjA4ICAwMi4wMC4wNyAgMDIuMDAuMDYgIDAyLjAwLjA2CittcGkyX2luaXQuaCAgMDIuMDAuMDYgIDAyLjAwLjA2ICAwMi4wMC4wNSAgMDIuMDAuMDUgIDAyLjAwLjA0ICAwMi4wMC4wMworbXBpMl9pb2MuaCAgIDAyLjAwLjEwICAwMi4wMC4wOSAgMDIuMDAuMDggIDAyLjAwLjA3ICAwMi4wMC4wNyAgMDIuMDAuMDYKK21waTJfcmFpZC5oICAwMi4wMC4wMyAgMDIuMDAuMDMgIDAyLjAwLjAzICAwMi4wMC4wMyAgMDIuMDAuMDIgIDAyLjAwLjAyCittcGkyX3Nhcy5oICAgMDIuMDAuMDIgIDAyLjAwLjAyICAwMi4wMC4wMSAgMDIuMDAuMDEgIDAyLjAwLjAxICAwMi4wMC4wMQorbXBpMl90YXJnLmggIDAyLjAwLjAzICAwMi4wMC4wMyAgMDIuMDAuMDIgIDAyLjAwLjAyICAwMi4wMC4wMiAgMDIuMDAuMDIKK21waTJfdG9vbC5oICAwMi4wMC4wMiAgMDIuMDAuMDIgIDAyLjAwLjAyICAwMi4wMC4wMiAgMDIuMDAuMDIgIDAyLjAwLjAyCittcGkyX3R5cGUuaCAgMDIuMDAuMDAgIDAyLjAwLjAwICAwMi4wMC4wMCAgMDIuMDAuMDAgIDAyLjAwLjAwICAwMi4wMC4wMAorCitGaWxlbmFtZSAgICAgMDIuMDAuMDUgIDAyLjAwLjA0ICAwMi4wMC4wMyAgMDIuMDAuMDIgIDAyLjAwLjAxICAwMi4wMC4wMAorLS0tLS0tLS0tLSAgIC0tLS0tLS0tICAtLS0tLS0tLSAgLS0tLS0tLS0gIC0tLS0tLS0tICAtLS0tLS0tLSAgLS0tLS0tLS0KK21waTIuaCAgICAgICAwMi4wMC4wNSAgMDIuMDAuMDQgIDAyLjAwLjAzICAwMi4wMC4wMiAgMDIuMDAuMDEgIDAyLjAwLjAwCittcGkyX2NuZmcuaCAgMDIuMDAuMDUgIDAyLjAwLjA0ICAwMi4wMC4wMyAgMDIuMDAuMDIgIDAyLjAwLjAxICAwMi4wMC4wMAorbXBpMl9pbml0LmggIDAyLjAwLjAyICAwMi4wMC4wMSAgMDIuMDAuMDAgIDAyLjAwLjAwICAwMi4wMC4wMCAgMDIuMDAuMDAKK21waTJfaW9jLmggICAwMi4wMC4wNSAgMDIuMDAuMDQgIDAyLjAwLjAzICAwMi4wMC4wMiAgMDIuMDAuMDEgIDAyLjAwLjAwCittcGkyX3JhaWQuaCAgMDIuMDAuMDEgIDAyLjAwLjAxICAwMi4wMC4wMSAgMDIuMDAuMDAgIDAyLjAwLjAwICAwMi4wMC4wMAorbXBpMl9zYXMuaCAgIDAyLjAwLjAxICAwMi4wMC4wMSAgMDIuMDAuMDEgIDAyLjAwLjAxICAwMi4wMC4wMCAgMDIuMDAuMDAKK21waTJfdGFyZy5oICAwMi4wMC4wMSAgMDIuMDAuMDEgIDAyLjAwLjAxICAwMi4wMC4wMCAgMDIuMDAuMDAgIDAyLjAwLjAwCittcGkyX3Rvb2wuaCAgMDIuMDAuMDEgIDAyLjAwLjAwICAwMi4wMC4wMCAgMDIuMDAuMDAgIDAyLjAwLjAwICAwMi4wMC4wMAorbXBpMl90eXBlLmggIDAyLjAwLjAwICAwMi4wMC4wMCAgMDIuMDAuMDAgIDAyLjAwLjAwICAwMi4wMC4wMCAgMDIuMDAuMDAKKwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfaW5pdC5oIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfaW5pdC5oCmluZGV4IGYxMTE1ZjAuLjU2M2U1NmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX2luaXQuaAorKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcGkvbXBpMl9pbml0LmgKQEAgLTEsMTIgKzEsMTIgQEAKIC8qCi0gKiAgQ29weXJpZ2h0IChjKSAyMDAwLTIwMDggTFNJIENvcnBvcmF0aW9uLgorICogIENvcHlyaWdodCAoYykgMjAwMC0yMDA5IExTSSBDb3Jwb3JhdGlvbi4KICAqCiAgKgogICogICAgICAgICAgIE5hbWU6ICBtcGkyX2luaXQuaAogICogICAgICAgICAgVGl0bGU6ICBNUEkgU0NTSSBpbml0aWF0b3IgbW9kZSBtZXNzYWdlcyBhbmQgc3RydWN0dXJlcwogICogIENyZWF0aW9uIERhdGU6ICBKdW5lIDIzLCAyMDA2CiAgKgotICogICAgbXBpMl9pbml0LmggVmVyc2lvbjogIDAyLjAwLjA2CisgKiAgICBtcGkyX2luaXQuaCBWZXJzaW9uOiAgMDIuMDAuMDcKICAqCiAgKiAgVmVyc2lvbiBIaXN0b3J5CiAgKiAgLS0tLS0tLS0tLS0tLS0tCkBAIC0yMyw2ICsyMywxMCBAQAogICogICAgICAgICAgICAgICAgICAgICAgQ29udHJvbCBmaWVsZCBUYXNrIEF0dHJpYnV0ZSBmbGFncy4KICAqICAgICAgICAgICAgICAgICAgICAgIE1vdmVkIExVTiBmaWVsZCBkZWZpbmVzIHRvIG1waTIuaCBiZWNhc3VlIHRoZXkgYXJlCiAgKiAgICAgICAgICAgICAgICAgICAgICBjb21tb24gdG8gbWFueSBzdHJ1Y3R1cmVzLgorICogIDA1LTA2LTA5ICAwMi4wMC4wNyAgQ2hhbmdlZCB0YXNrIG1hbmFnZW1lbnQgdHlwZSBvZiBRdWVyeSBVbml0IEF0dGVudGlvbiB0bworICogICAgICAgICAgICAgICAgICAgICAgUXVlcnkgQXN5bmNocm9ub3VzIEV2ZW50LgorICogICAgICAgICAgICAgICAgICAgICAgRGVmaW5lZCB0d28gbmV3IGJpdHMgaW4gdGhlIFNsb3RTdGF0dXMgZmllbGQgb2YgdGhlIFNDU0kKKyAqICAgICAgICAgICAgICAgICAgICAgIEVuY2xvc3VyZSBQcm9jZXNzb3IgUmVxdWVzdCBhbmQgUmVwbHkuCiAgKiAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqLwogCkBAIC0yODksNyArMjkzLDExIEBACiAjZGVmaW5lIE1QSTJfU0NTSVRBU0tNR01UX1RBU0tUWVBFX1FVRVJZX1RBU0sgICAgICAgICAgICgweDA3KQogI2RlZmluZSBNUEkyX1NDU0lUQVNLTUdNVF9UQVNLVFlQRV9DTFJfQUNBICAgICAgICAgICAgICAoMHgwOCkKICNkZWZpbmUgTVBJMl9TQ1NJVEFTS01HTVRfVEFTS1RZUEVfUVJZX1RBU0tfU0VUICAgICAgICAgKDB4MDkpCi0jZGVmaW5lIE1QSTJfU0NTSVRBU0tNR01UX1RBU0tUWVBFX1FSWV9VTklUX0FUVEVOVElPTiAgICgweDBBKQorI2RlZmluZSBNUEkyX1NDU0lUQVNLTUdNVF9UQVNLVFlQRV9RUllfQVNZTkNfRVZFTlQgICAgICAoMHgwQSkKKworLyogb2Jzb2xldGUgVGFza1R5cGUgbmFtZSAqLworI2RlZmluZSBNUEkyX1NDU0lUQVNLTUdNVF9UQVNLVFlQRV9RUllfVU5JVF9BVFRFTlRJT04JXAorCShNUEkyX1NDU0lUQVNLTUdNVF9UQVNLVFlQRV9RUllfQVNZTkNfRVZFTlQpCiAKIC8qIE1zZ0ZsYWdzIGJpdHMgKi8KIApAQCAtMzc1LDYgKzM4Myw4IEBACiAjZGVmaW5lIE1QSTJfU0VQX1JFUV9TTE9UU1RBVFVTX0hPVF9TUEFSRSAgICAgICAgICAgICAgICgweDAwMDAwMTAwKQogI2RlZmluZSBNUEkyX1NFUF9SRVFfU0xPVFNUQVRVU19VTkNPTkZJR1VSRUQgICAgICAgICAgICAoMHgwMDAwMDA4MCkKICNkZWZpbmUgTVBJMl9TRVBfUkVRX1NMT1RTVEFUVVNfUFJFRElDVEVEX0ZBVUxUICAgICAgICAgKDB4MDAwMDAwNDApCisjZGVmaW5lIE1QSTJfU0VQX1JFUV9TTE9UU1RBVFVTX0lOX0NSSVRJQ0FMX0FSUkFZICAgICAgICgweDAwMDAwMDEwKQorI2RlZmluZSBNUEkyX1NFUF9SRVFfU0xPVFNUQVRVU19JTl9GQUlMRURfQVJSQVkgICAgICAgICAoMHgwMDAwMDAwOCkKICNkZWZpbmUgTVBJMl9TRVBfUkVRX1NMT1RTVEFUVVNfREVWX1JFQlVJTERJTkcgICAgICAgICAgKDB4MDAwMDAwMDQpCiAjZGVmaW5lIE1QSTJfU0VQX1JFUV9TTE9UU1RBVFVTX0RFVl9GQVVMVFkgICAgICAgICAgICAgICgweDAwMDAwMDAyKQogI2RlZmluZSBNUEkyX1NFUF9SRVFfU0xPVFNUQVRVU19OT19FUlJPUiAgICAgICAgICAgICAgICAoMHgwMDAwMDAwMSkKQEAgLTQxMCw2ICs0MjAsOCBAQAogI2RlZmluZSBNUEkyX1NFUF9SRVBMWV9TTE9UU1RBVFVTX0hPVF9TUEFSRSAgICAgICAgICAgICAoMHgwMDAwMDEwMCkKICNkZWZpbmUgTVBJMl9TRVBfUkVQTFlfU0xPVFNUQVRVU19VTkNPTkZJR1VSRUQgICAgICAgICAgKDB4MDAwMDAwODApCiAjZGVmaW5lIE1QSTJfU0VQX1JFUExZX1NMT1RTVEFUVVNfUFJFRElDVEVEX0ZBVUxUICAgICAgICgweDAwMDAwMDQwKQorI2RlZmluZSBNUEkyX1NFUF9SRVBMWV9TTE9UU1RBVFVTX0lOX0NSSVRJQ0FMX0FSUkFZICAgICAoMHgwMDAwMDAxMCkKKyNkZWZpbmUgTVBJMl9TRVBfUkVQTFlfU0xPVFNUQVRVU19JTl9GQUlMRURfQVJSQVkgICAgICAgKDB4MDAwMDAwMDgpCiAjZGVmaW5lIE1QSTJfU0VQX1JFUExZX1NMT1RTVEFUVVNfREVWX1JFQlVJTERJTkcgICAgICAgICgweDAwMDAwMDA0KQogI2RlZmluZSBNUEkyX1NFUF9SRVBMWV9TTE9UU1RBVFVTX0RFVl9GQVVMVFkgICAgICAgICAgICAoMHgwMDAwMDAwMikKICNkZWZpbmUgTVBJMl9TRVBfUkVQTFlfU0xPVFNUQVRVU19OT19FUlJPUiAgICAgICAgICAgICAgKDB4MDAwMDAwMDEpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcGkvbXBpMl9pb2MuaCBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX2lvYy5oCmluZGV4IDhjNWQ4MTguLmMyOTQxMjggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX2lvYy5oCisrKyBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX2lvYy5oCkBAIC02LDcgKzYsNyBAQAogICogICAgICAgICAgVGl0bGU6ICBNUEkgSU9DLCBQb3J0LCBFdmVudCwgRlcgRG93bmxvYWQsIGFuZCBGVyBVcGxvYWQgbWVzc2FnZXMKICAqICBDcmVhdGlvbiBEYXRlOiAgT2N0b2JlciAxMSwgMjAwNgogICoKLSAqICBtcGkyX2lvYy5oIFZlcnNpb246ICAwMi4wMC4xMAorICogIG1waTJfaW9jLmggVmVyc2lvbjogIDAyLjAwLjExCiAgKgogICogIFZlcnNpb24gSGlzdG9yeQogICogIC0tLS0tLS0tLS0tLS0tLQpAQCAtNzksNiArNzksMTEgQEAKICAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX1NBVEFfSU5JVF9GQUlMVVJFCiAgKiAgICAgICAgICAgICAgICAgICAgICBkZWZpbmUuCiAgKiAgICAgICAgICAgICAgICAgICAgICBSZW1vdmVkIE1QSTJfRVZFTlRfU0FTX0RJU0NfRFNfU0FUQV9JTklUX0ZBSUxVUkUgZGVmaW5lLgorICogIDA1LTA2LTA5ICAwMi4wMC4xMSAgQWRkZWQgTVBJMl9JT0NGQUNUU19DQVBBQklMSVRZX1JBSURfQUNDRUxFUkFUT1IgZGVmaW5lLgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgTVBJMl9JT0NGQUNUU19DQVBBQklMSVRZX01TSV9YX0lOREVYIGRlZmluZS4KKyAqICAgICAgICAgICAgICAgICAgICAgIEFkZGVkIHR3byBuZXcgcmVhc29uIGNvZGVzIGZvciBTQVMgRGV2aWNlIFN0YXR1cyBDaGFuZ2UKKyAqICAgICAgICAgICAgICAgICAgICAgIEV2ZW50LgorICogICAgICAgICAgICAgICAgICAgICAgQWRkZWQgbmV3IGV2ZW50OiBTQVMgUEhZIENvdW50ZXIuCiAgKiAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KICAqLwogCkBAIC0yNjEsNiArMjY2LDggQEAKIC8qIFByb2R1Y3RJRCBmaWVsZCB1c2VzIE1QSTJfRldfSEVBREVSX1BJRF8gKi8KIAogLyogSU9DQ2FwYWJpbGl0aWVzICovCisjZGVmaW5lIE1QSTJfSU9DRkFDVFNfQ0FQQUJJTElUWV9NU0lfWF9JTkRFWCAgICAgICAgICAgICgweDAwMDA4MDAwKQorI2RlZmluZSBNUEkyX0lPQ0ZBQ1RTX0NBUEFCSUxJVFlfUkFJRF9BQ0NFTEVSQVRPUiAgICAgICAoMHgwMDAwNDAwMCkKICNkZWZpbmUgTVBJMl9JT0NGQUNUU19DQVBBQklMSVRZX0VWRU5UX1JFUExBWSAgICAgICAgICAgKDB4MDAwMDIwMDApCiAjZGVmaW5lIE1QSTJfSU9DRkFDVFNfQ0FQQUJJTElUWV9JTlRFR1JBVEVEX1JBSUQgICAgICAgICgweDAwMDAxMDAwKQogI2RlZmluZSBNUEkyX0lPQ0ZBQ1RTX0NBUEFCSUxJVFlfVExSICAgICAgICAgICAgICAgICAgICAoMHgwMDAwMDgwMCkKQEAgLTQ0MCw2ICs0NDcsNyBAQAogI2RlZmluZSBNUEkyX0VWRU5UX0lSX1BIWVNJQ0FMX0RJU0sgICAgICAgICAgICAgICAgICgweDAwMUYpCiAjZGVmaW5lIE1QSTJfRVZFTlRfSVJfQ09ORklHVVJBVElPTl9DSEFOR0VfTElTVCAgICAgKDB4MDAyMCkKICNkZWZpbmUgTVBJMl9FVkVOVF9MT0dfRU5UUllfQURERUQgICAgICAgICAgICAgICAgICAoMHgwMDIxKQorI2RlZmluZSBNUEkyX0VWRU5UX1NBU19QSFlfQ09VTlRFUiAgICAgICAgICAgICAgICAgICgweDAwMjIpCiAKIAogLyogTG9nIEVudHJ5IEFkZGVkIEV2ZW50IGRhdGEgKi8KQEAgLTUwMiwxNyArNTEwLDE5IEBACiAgIE1QSTJfUE9JTlRFUiBwTXBpMkV2ZW50RGF0YVNhc0RldmljZVN0YXR1c0NoYW5nZV90OwogCiAvKiBTQVMgRGV2aWNlIFN0YXR1cyBDaGFuZ2UgRXZlbnQgZGF0YSBSZWFzb25Db2RlIHZhbHVlcyAqLwotI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19TTUFSVF9EQVRBICAgICAgICAgICAgICAgKDB4MDUpCi0jZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX1VOU1VQUE9SVEVEICAgICAgICAgICAgICAoMHgwNykKLSNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfSU5URVJOQUxfREVWSUNFX1JFU0VUICAgICgweDA4KQotI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19UQVNLX0FCT1JUX0lOVEVSTkFMICAgICAgKDB4MDkpCi0jZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX0FCT1JUX1RBU0tfU0VUX0lOVEVSTkFMICAoMHgwQSkKLSNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfQ0xFQVJfVEFTS19TRVRfSU5URVJOQUwgICgweDBCKQotI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19RVUVSWV9UQVNLX0lOVEVSTkFMICAgICAgKDB4MEMpCi0jZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX0FTWU5DX05PVElGSUNBVElPTiAgICAgICAoMHgwRCkKLSNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfQ01QX0lOVEVSTkFMX0RFVl9SRVNFVCAgICgweDBFKQotI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19DTVBfVEFTS19BQk9SVF9JTlRFUk5BTCAgKDB4MEYpCi0jZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX1NBVEFfSU5JVF9GQUlMVVJFICAgICAgICAoMHgxMCkKKyNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfU01BUlRfREFUQSAgICAgICAgICAgICAgICAgICAgICAgICAgICgweDA1KQorI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19VTlNVUFBPUlRFRCAgICAgICAgICAgICAgICAgICAgICAgICAgKDB4MDcpCisjZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX0lOVEVSTkFMX0RFVklDRV9SRVNFVCAgICAgICAgICAgICAgICAoMHgwOCkKKyNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfVEFTS19BQk9SVF9JTlRFUk5BTCAgICAgICAgICAgICAgICAgICgweDA5KQorI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19BQk9SVF9UQVNLX1NFVF9JTlRFUk5BTCAgICAgICAgICAgICAgKDB4MEEpCisjZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX0NMRUFSX1RBU0tfU0VUX0lOVEVSTkFMICAgICAgICAgICAgICAoMHgwQikKKyNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfUVVFUllfVEFTS19JTlRFUk5BTCAgICAgICAgICAgICAgICAgICgweDBDKQorI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19BU1lOQ19OT1RJRklDQVRJT04gICAgICAgICAgICAgICAgICAgKDB4MEQpCisjZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX0NNUF9JTlRFUk5BTF9ERVZfUkVTRVQgICAgICAgICAgICAgICAoMHgwRSkKKyNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfQ01QX1RBU0tfQUJPUlRfSU5URVJOQUwgICAgICAgICAgICAgICgweDBGKQorI2RlZmluZSBNUEkyX0VWRU5UX1NBU19ERVZfU1RBVF9SQ19TQVRBX0lOSVRfRkFJTFVSRSAgICAgICAgICAgICAgICAgICAgKDB4MTApCisjZGVmaW5lIE1QSTJfRVZFTlRfU0FTX0RFVl9TVEFUX1JDX0VYUEFOREVSX1JFRFVDRURfRlVOQ1RJT05BTElUWSAgICAgICAoMHgxMSkKKyNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfREVWX1NUQVRfUkNfQ01QX0VYUEFOREVSX1JFRFVDRURfRlVOQ1RJT05BTElUWSAgICgweDEyKQogCiAKIC8qIEludGVncmF0ZWQgUkFJRCBPcGVyYXRpb24gU3RhdHVzIEV2ZW50IGRhdGEgKi8KQEAgLTgyMiw2ICs4MzIsMzcgQEAKICNkZWZpbmUgTVBJMl9FVkVOVF9TQVNfRU5DTF9SQ19OT1RfUkVTUE9ORElORyAgICAgICAoMHgwMikKIAogCisvKiBTQVMgUEhZIENvdW50ZXIgRXZlbnQgZGF0YSAqLworCit0eXBlZGVmIHN0cnVjdCBfTVBJMl9FVkVOVF9EQVRBX1NBU19QSFlfQ09VTlRFUiB7CisgICAgVTY0ICAgICAgICAgVGltZVN0YW1wOyAgICAgICAgICAvKiAweDAwICovCisgICAgVTMyICAgICAgICAgUmVzZXJ2ZWQxOyAgICAgICAgICAvKiAweDA4ICovCisgICAgVTggICAgICAgICAgUGh5RXZlbnRDb2RlOyAgICAgICAvKiAweDBDICovCisgICAgVTggICAgICAgICAgUGh5TnVtOyAgICAgICAgICAgICAvKiAweDBEICovCisgICAgVTE2ICAgICAgICAgUmVzZXJ2ZWQyOyAgICAgICAgICAvKiAweDBFICovCisgICAgVTMyICAgICAgICAgUGh5RXZlbnRJbmZvOyAgICAgICAvKiAweDEwICovCisgICAgVTggICAgICAgICAgQ291bnRlclR5cGU7ICAgICAgICAvKiAweDE0ICovCisgICAgVTggICAgICAgICAgVGhyZXNob2xkV2luZG93OyAgICAvKiAweDE1ICovCisgICAgVTggICAgICAgICAgVGltZVVuaXRzOyAgICAgICAgICAvKiAweDE2ICovCisgICAgVTggICAgICAgICAgUmVzZXJ2ZWQzOyAgICAgICAgICAvKiAweDE3ICovCisgICAgVTMyICAgICAgICAgRXZlbnRUaHJlc2hvbGQ7ICAgICAvKiAweDE4ICovCisgICAgVTE2ICAgICAgICAgVGhyZXNob2xkRmxhZ3M7ICAgICAvKiAweDFDICovCisgICAgVTE2ICAgICAgICAgUmVzZXJ2ZWQ0OyAgICAgICAgICAvKiAweDFFICovCit9IE1QSTJfRVZFTlRfREFUQV9TQVNfUEhZX0NPVU5URVIsCisgIE1QSTJfUE9JTlRFUiBQVFJfTVBJMl9FVkVOVF9EQVRBX1NBU19QSFlfQ09VTlRFUiwKKyAgTXBpMkV2ZW50RGF0YVNhc1BoeUNvdW50ZXJfdCwgTVBJMl9QT0lOVEVSIHBNcGkyRXZlbnREYXRhU2FzUGh5Q291bnRlcl90OworCisvKiB1c2UgTVBJMl9TQVNQSFkzX0VWRU5UX0NPREVfIHZhbHVlcyBmcm9tIG1waTJfY25mZy5oIGZvciB0aGUKKyAqIFBoeUV2ZW50Q29kZSBmaWVsZAorICogdXNlIE1QSTJfU0FTUEhZM19DT1VOVEVSX1RZUEVfIHZhbHVlcyBmcm9tIG1waTJfY25mZy5oIGZvciB0aGUKKyAqIENvdW50ZXJUeXBlIGZpZWxkCisgKiB1c2UgTVBJMl9TQVNQSFkzX1RJTUVfVU5JVFNfIHZhbHVlcyBmcm9tIG1waTJfY25mZy5oIGZvciB0aGUKKyAqIFRpbWVVbml0cyBmaWVsZAorICogdXNlIE1QSTJfU0FTUEhZM19URkxBR1NfIHZhbHVlcyBmcm9tIG1waTJfY25mZy5oIGZvciB0aGUKKyAqIFRocmVzaG9sZEZsYWdzIGZpZWxkCisgKiAqLworCisKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICBFdmVudEFjayBtZXNzYWdlCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfdG9vbC5oIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXBpL21waTJfdG9vbC5oCmluZGV4IDJmZjRlOTMuLjAwN2U5NTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21waS9tcGkyX3Rvb2wuaAorKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcGkvbXBpMl90b29sLmgKQEAgLTEsMTIgKzEsMTIgQEAKIC8qCi0gKiAgQ29weXJpZ2h0IChjKSAyMDAwLTIwMDggTFNJIENvcnBvcmF0aW9uLgorICogIENvcHlyaWdodCAoYykgMjAwMC0yMDA5IExTSSBDb3Jwb3JhdGlvbi4KICAqCiAgKgogICogICAgICAgICAgIE5hbWU6ICBtcGkyX3Rvb2wuaAogICogICAgICAgICAgVGl0bGU6ICBNUEkgZGlhZ25vc3RpYyB0b29sIHN0cnVjdHVyZXMgYW5kIGRlZmluaXRpb25zCiAgKiAgQ3JlYXRpb24gRGF0ZTogIE1hcmNoIDI2LCAyMDA3CiAgKgotICogICAgbXBpMl90b29sLmggVmVyc2lvbjogIDAyLjAwLjAyCisgKiAgICBtcGkyX3Rvb2wuaCBWZXJzaW9uOiAgMDIuMDAuMDMKICAqCiAgKiAgVmVyc2lvbiBIaXN0b3J5CiAgKiAgLS0tLS0tLS0tLS0tLS0tCkBAIC0xNyw2ICsxNyw3IEBACiAgKiAgMTItMTgtMDcgIDAyLjAwLjAxICBBZGRlZCBEaWFnbm9zdGljIEJ1ZmZlciBQb3N0IGFuZCBEaWFnbm9zdGljIFJlbGVhc2UKICAqICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdHVyZXMgYW5kIGRlZmluZXMuCiAgKiAgMDItMjktMDggIDAyLjAwLjAyICBNb2RpZmllZCB2YXJpb3VzIG5hbWVzIHRvIG1ha2UgdGhlbSAzMi1jaGFyYWN0ZXIgdW5pcXVlLgorICogIDA1LTA2LTA5ICAwMi4wMC4wMyAgQWRkZWQgSVNUV0kgUmVhZCBXcml0ZSBUb29sIGFuZCBEaWFnbm9zdGljIENMSSBUb29sLgogICogIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKi8KIApAQCAtMzIsNyArMzMsMTAgQEAKIC8qIGRlZmluZXMgZm9yIHRoZSBUb29scyAqLwogI2RlZmluZSBNUEkyX1RPT0xCT1hfQ0xFQU5fVE9PTCAgICAgICAgICAgICAgICAgICAgICgweDAwKQogI2RlZmluZSBNUEkyX1RPT0xCT1hfTUVNT1JZX01PVkVfVE9PTCAgICAgICAgICAgICAgICgweDAxKQorI2RlZmluZSBNUEkyX1RPT0xCT1hfSVNUV0lfUkVBRF9XUklURV9UT09MICAgICAgICAgICgweDAzKQogI2RlZmluZSBNUEkyX1RPT0xCT1hfQkVBQ09OX1RPT0wgICAgICAgICAgICAgICAgICAgICgweDA1KQorI2RlZmluZSBNUEkyX1RPT0xCT1hfRElBR05PU1RJQ19DTElfVE9PTCAgICAgICAgICAgICgweDA2KQorCiAKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICBUb29sYm94IHJlcGx5CkBAIC0xMTIsNiArMTE2LDc3IEBACiAKIAogLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyogIFRvb2xib3ggSVNUV0kgUmVhZCBXcml0ZSBUb29sCisqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisvKiBUb29sYm94IElTVFdJIFJlYWQgV3JpdGUgVG9vbCByZXF1ZXN0IG1lc3NhZ2UgKi8KK3R5cGVkZWYgc3RydWN0IF9NUEkyX1RPT0xCT1hfSVNUV0lfUkVBRF9XUklURV9SRVFVRVNUIHsKKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBUb29sOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMTsgICAgICAgICAgICAgICAgICAvKiAweDAxICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgQ2hhaW5PZmZzZXQ7ICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBGdW5jdGlvbjsgICAgICAgICAgICAgICAgICAgLyogMHgwMyAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMjsgICAgICAgICAgICAgICAgICAvKiAweDA0ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQzOyAgICAgICAgICAgICAgICAgIC8qIDB4MDYgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBNc2dGbGFnczsgICAgICAgICAgICAgICAgICAgLyogMHgwNyAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFZQX0lEOyAgICAgICAgICAgICAgICAgICAgICAvKiAweDA4ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgVkZfSUQ7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDkgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDQ7ICAgICAgICAgICAgICAgICAgLyogMHgwQSAqLworICAgIFUzMiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkNTsgICAgICAgICAgICAgICAgICAvKiAweDBDICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQ2OyAgICAgICAgICAgICAgICAgIC8qIDB4MTAgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBEZXZJbmRleDsgICAgICAgICAgICAgICAgICAgLyogMHgxNCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIEFjdGlvbjsgICAgICAgICAgICAgICAgICAgICAvKiAweDE1ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgU0dMRmxhZ3M7ICAgICAgICAgICAgICAgICAgIC8qIDB4MTYgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDc7ICAgICAgICAgICAgICAgICAgLyogMHgxNyAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgIFR4RGF0YUxlbmd0aDsgICAgICAgICAgICAgICAvKiAweDE4ICovCisgICAgVTE2ICAgICAgICAgICAgICAgICAgICAgUnhEYXRhTGVuZ3RoOyAgICAgICAgICAgICAgIC8qIDB4MUEgKi8KKyAgICBVMzIgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDg7ICAgICAgICAgICAgICAgICAgLyogMHgxQyAqLworICAgIFUzMiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkOTsgICAgICAgICAgICAgICAgICAvKiAweDIwICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQxMDsgICAgICAgICAgICAgICAgIC8qIDB4MjQgKi8KKyAgICBVMzIgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDExOyAgICAgICAgICAgICAgICAgLyogMHgyOCAqLworICAgIFUzMiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMTI7ICAgICAgICAgICAgICAgICAvKiAweDJDICovCisgICAgTVBJMl9TR0VfU0lNUExFX1VOSU9OICAgU0dMOyAgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MzAgKi8KK30gTVBJMl9UT09MQk9YX0lTVFdJX1JFQURfV1JJVEVfUkVRVUVTVCwKKyAgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1RPT0xCT1hfSVNUV0lfUkVBRF9XUklURV9SRVFVRVNULAorICBNcGkyVG9vbGJveElzdHdpUmVhZFdyaXRlUmVxdWVzdF90LAorICBNUEkyX1BPSU5URVIgcE1waTJUb29sYm94SXN0d2lSZWFkV3JpdGVSZXF1ZXN0X3Q7CisKKy8qIHZhbHVlcyBmb3IgdGhlIEFjdGlvbiBmaWVsZCAqLworI2RlZmluZSBNUEkyX1RPT0xfSVNUV0lfQUNUSU9OX1JFQURfREFUQSAgICAgICAgICAgICgweDAxKQorI2RlZmluZSBNUEkyX1RPT0xfSVNUV0lfQUNUSU9OX1dSSVRFX0RBVEEgICAgICAgICAgICgweDAyKQorI2RlZmluZSBNUEkyX1RPT0xfSVNUV0lfQUNUSU9OX1NFUVVFTkNFICAgICAgICAgICAgICgweDAzKQorI2RlZmluZSBNUEkyX1RPT0xfSVNUV0lfQUNUSU9OX1JFU0VSVkVfQlVTICAgICAgICAgICgweDEwKQorI2RlZmluZSBNUEkyX1RPT0xfSVNUV0lfQUNUSU9OX1JFTEVBU0VfQlVTICAgICAgICAgICgweDExKQorI2RlZmluZSBNUEkyX1RPT0xfSVNUV0lfQUNUSU9OX1JFU0VUICAgICAgICAgICAgICAgICgweDEyKQorCisvKiB2YWx1ZXMgZm9yIFNHTEZsYWdzIGZpZWxkIGFyZSBpbiB0aGUgU0dMIHNlY3Rpb24gb2YgbXBpMi5oICovCisKKworLyogVG9vbGJveCBJU1RXSSBSZWFkIFdyaXRlIFRvb2wgcmVwbHkgbWVzc2FnZSAqLwordHlwZWRlZiBzdHJ1Y3QgX01QSTJfVE9PTEJPWF9JU1RXSV9SRVBMWSB7CisgICAgVTggICAgICAgICAgICAgICAgICAgICAgVG9vbDsgICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDAgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDE7ICAgICAgICAgICAgICAgICAgLyogMHgwMSAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIE1zZ0xlbmd0aDsgICAgICAgICAgICAgICAgICAvKiAweDAyICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgRnVuY3Rpb247ICAgICAgICAgICAgICAgICAgIC8qIDB4MDMgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDI7ICAgICAgICAgICAgICAgICAgLyogMHgwNCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMzsgICAgICAgICAgICAgICAgICAvKiAweDA2ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgTXNnRmxhZ3M7ICAgICAgICAgICAgICAgICAgIC8qIDB4MDcgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBWUF9JRDsgICAgICAgICAgICAgICAgICAgICAgLyogMHgwOCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFZGX0lEOyAgICAgICAgICAgICAgICAgICAgICAvKiAweDA5ICovCisgICAgVTE2ICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQ0OyAgICAgICAgICAgICAgICAgIC8qIDB4MEEgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDU7ICAgICAgICAgICAgICAgICAgLyogMHgwQyAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgIElPQ1N0YXR1czsgICAgICAgICAgICAgICAgICAvKiAweDBFICovCisgICAgVTMyICAgICAgICAgICAgICAgICAgICAgSU9DTG9nSW5mbzsgICAgICAgICAgICAgICAgIC8qIDB4MTAgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBEZXZJbmRleDsgICAgICAgICAgICAgICAgICAgLyogMHgxNCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIEFjdGlvbjsgICAgICAgICAgICAgICAgICAgICAvKiAweDE1ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgSXN0d2lTdGF0dXM7ICAgICAgICAgICAgICAgIC8qIDB4MTYgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDY7ICAgICAgICAgICAgICAgICAgLyogMHgxNyAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgIFR4RGF0YUNvdW50OyAgICAgICAgICAgICAgICAvKiAweDE4ICovCisgICAgVTE2ICAgICAgICAgICAgICAgICAgICAgUnhEYXRhQ291bnQ7ICAgICAgICAgICAgICAgIC8qIDB4MUEgKi8KK30gTVBJMl9UT09MQk9YX0lTVFdJX1JFUExZLCBNUEkyX1BPSU5URVIgUFRSX01QSTJfVE9PTEJPWF9JU1RXSV9SRVBMWSwKKyAgTXBpMlRvb2xib3hJc3R3aVJlcGx5X3QsIE1QSTJfUE9JTlRFUiBwTXBpMlRvb2xib3hJc3R3aVJlcGx5X3Q7CisKKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogIFRvb2xib3ggQmVhY29uIFRvb2wgcmVxdWVzdAogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KIApAQCAtMTM5LDYgKzIxNCw2MSBAQAogI2RlZmluZSBNUEkyX1RPT0xCT1hfRkxBR1NfQkVBQ09OTU9ERV9PTiAgICAgICAgKDB4MDEpCiAKIAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyogIFRvb2xib3ggRGlhZ25vc3RpYyBDTEkgVG9vbAorKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKworI2RlZmluZSBNUEkyX1RPT0xCT1hfRElBR19DTElfQ01EX0xFTkdUSCAgICAoMHg1QykKKworLyogVG9vbGJveCBEaWFnbm9zdGljIENMSSBUb29sIHJlcXVlc3QgbWVzc2FnZSAqLwordHlwZWRlZiBzdHJ1Y3QgX01QSTJfVE9PTEJPWF9ESUFHTk9TVElDX0NMSV9SRVFVRVNUIHsKKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBUb29sOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMTsgICAgICAgICAgICAgICAgICAvKiAweDAxICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgQ2hhaW5PZmZzZXQ7ICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBGdW5jdGlvbjsgICAgICAgICAgICAgICAgICAgLyogMHgwMyAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMjsgICAgICAgICAgICAgICAgICAvKiAweDA0ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQzOyAgICAgICAgICAgICAgICAgIC8qIDB4MDYgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBNc2dGbGFnczsgICAgICAgICAgICAgICAgICAgLyogMHgwNyAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFZQX0lEOyAgICAgICAgICAgICAgICAgICAgICAvKiAweDA4ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgVkZfSUQ7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDkgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDQ7ICAgICAgICAgICAgICAgICAgLyogMHgwQSAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFNHTEZsYWdzOyAgICAgICAgICAgICAgICAgICAvKiAweDBDICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQ1OyAgICAgICAgICAgICAgICAgIC8qIDB4MEQgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDY7ICAgICAgICAgICAgICAgICAgLyogMHgwRSAqLworICAgIFUzMiAgICAgICAgICAgICAgICAgICAgIERhdGFMZW5ndGg7ICAgICAgICAgICAgICAgICAvKiAweDEwICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgRGlhZ25vc3RpY0NsaUNvbW1hbmQKKwkJW01QSTJfVE9PTEJPWF9ESUFHX0NMSV9DTURfTEVOR1RIXTsgICAgIC8qIDB4MTQgKi8KKyAgICBNUEkyX1NHRV9TSU1QTEVfVU5JT04gICBTR0w7ICAgICAgICAgICAgICAgICAgICAgICAgLyogMHg3MCAqLworfSBNUEkyX1RPT0xCT1hfRElBR05PU1RJQ19DTElfUkVRVUVTVCwKKyAgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1RPT0xCT1hfRElBR05PU1RJQ19DTElfUkVRVUVTVCwKKyAgTXBpMlRvb2xib3hEaWFnbm9zdGljQ2xpUmVxdWVzdF90LAorICBNUEkyX1BPSU5URVIgcE1waTJUb29sYm94RGlhZ25vc3RpY0NsaVJlcXVlc3RfdDsKKworLyogdmFsdWVzIGZvciBTR0xGbGFncyBmaWVsZCBhcmUgaW4gdGhlIFNHTCBzZWN0aW9uIG9mIG1waTIuaCAqLworCisKKy8qIFRvb2xib3ggRGlhZ25vc3RpYyBDTEkgVG9vbCByZXBseSBtZXNzYWdlICovCit0eXBlZGVmIHN0cnVjdCBfTVBJMl9UT09MQk9YX0RJQUdOT1NUSUNfQ0xJX1JFUExZIHsKKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBUb29sOyAgICAgICAgICAgICAgICAgICAgICAgLyogMHgwMCAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMTsgICAgICAgICAgICAgICAgICAvKiAweDAxICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgTXNnTGVuZ3RoOyAgICAgICAgICAgICAgICAgIC8qIDB4MDIgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBGdW5jdGlvbjsgICAgICAgICAgICAgICAgICAgLyogMHgwMyAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkMjsgICAgICAgICAgICAgICAgICAvKiAweDA0ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgUmVzZXJ2ZWQzOyAgICAgICAgICAgICAgICAgIC8qIDB4MDYgKi8KKyAgICBVOCAgICAgICAgICAgICAgICAgICAgICBNc2dGbGFnczsgICAgICAgICAgICAgICAgICAgLyogMHgwNyAqLworICAgIFU4ICAgICAgICAgICAgICAgICAgICAgIFZQX0lEOyAgICAgICAgICAgICAgICAgICAgICAvKiAweDA4ICovCisgICAgVTggICAgICAgICAgICAgICAgICAgICAgVkZfSUQ7ICAgICAgICAgICAgICAgICAgICAgIC8qIDB4MDkgKi8KKyAgICBVMTYgICAgICAgICAgICAgICAgICAgICBSZXNlcnZlZDQ7ICAgICAgICAgICAgICAgICAgLyogMHgwQSAqLworICAgIFUxNiAgICAgICAgICAgICAgICAgICAgIFJlc2VydmVkNTsgICAgICAgICAgICAgICAgICAvKiAweDBDICovCisgICAgVTE2ICAgICAgICAgICAgICAgICAgICAgSU9DU3RhdHVzOyAgICAgICAgICAgICAgICAgIC8qIDB4MEUgKi8KKyAgICBVMzIgICAgICAgICAgICAgICAgICAgICBJT0NMb2dJbmZvOyAgICAgICAgICAgICAgICAgLyogMHgxMCAqLworICAgIFUzMiAgICAgICAgICAgICAgICAgICAgIFJldHVybmVkRGF0YUxlbmd0aDsgICAgICAgICAvKiAweDE0ICovCit9IE1QSTJfVE9PTEJPWF9ESUFHTk9TVElDX0NMSV9SRVBMWSwKKyAgTVBJMl9QT0lOVEVSIFBUUl9NUEkyX1RPT0xCT1hfRElBR19DTElfUkVQTFksCisgIE1waTJUb29sYm94RGlhZ25vc3RpY0NsaVJlcGx5X3QsCisgIE1QSTJfUE9JTlRFUiBwTXBpMlRvb2xib3hEaWFnbm9zdGljQ2xpUmVwbHlfdDsKKworCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKICogICAgICAgRGlhZ25vc3RpYyBCdWZmZXIgTWVzc2FnZXMKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfYmFzZS5jIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19iYXNlLmMKaW5kZXggZDk1ZDJmMi4uNjcwMjQxZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19iYXNlLmMKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19iYXNlLmMKQEAgLTMsNyArMyw3IEBACiAgKiBmb3IgYWNjZXNzIHRvIE1QVCAoTWVzc2FnZSBQYXNzaW5nIFRlY2hub2xvZ3kpIGZpcm13YXJlLgogICoKICAqIFRoaXMgY29kZSBpcyBiYXNlZCBvbiBkcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyX2Jhc2UuYwotICogQ29weXJpZ2h0IChDKSAyMDA3LTIwMDggIExTSSBDb3Jwb3JhdGlvbgorICogQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIExTSSBDb3Jwb3JhdGlvbgogICogIChtYWlsdG86REwtTVBURnVzaW9uTGludXhAbHNpLmNvbSkKICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC02Myw3ICs2Myw3IEBACiBzdGF0aWMgTVBUX0NBTExCQUNLCW1wdF9jYWxsYmFja3NbTVBUX01BWF9DQUxMQkFDS1NdOwogCiAjZGVmaW5lIEZBVUxUX1BPTExJTkdfSU5URVJWQUwgMTAwMCAvKiBpbiBtaWxsaXNlY29uZHMgKi8KLSNkZWZpbmUgTVBUMlNBU19NQVhfUkVRVUVTVF9RVUVVRSA1MDAgLyogbWF4aW11bSBjb250cm9sbGVyIHF1ZXVlIGRlcHRoICovCisjZGVmaW5lIE1QVDJTQVNfTUFYX1JFUVVFU1RfUVVFVUUgNjAwIC8qIG1heGltdW0gY29udHJvbGxlciBxdWV1ZSBkZXB0aCAqLwogCiBzdGF0aWMgaW50IG1heF9xdWV1ZV9kZXB0aCA9IC0xOwogbW9kdWxlX3BhcmFtKG1heF9xdWV1ZV9kZXB0aCwgaW50LCAwKTsKQEAgLTU0MywxMyArNTQzLDEzIEBACiAgKiBfYmFzZV9kaXNwbGF5X3JlcGx5X2luZm8gLQogICogQGlvYzogcG9pbnRlciB0byBzY3NpIGNvbW1hbmQgb2JqZWN0CiAgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAotICogQFZGX0lEOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCisgKiBAbXNpeF9pbmRleDogTVNJWCB0YWJsZSBpbmRleCBzdXBwbGllZCBieSB0aGUgT1MKICAqIEByZXBseTogcmVwbHkgbWVzc2FnZSBmcmFtZShsb3dlciAzMmJpdCBhZGRyKQogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiBzdGF0aWMgdm9pZAotX2Jhc2VfZGlzcGxheV9yZXBseV9pbmZvKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IFZGX0lELAorX2Jhc2VfZGlzcGxheV9yZXBseV9pbmZvKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IG1zaXhfaW5kZXgsCiAgICAgdTMyIHJlcGx5KQogewogCU1QSTJEZWZhdWx0UmVwbHlfdCAqbXBpX3JlcGx5OwpAQCAtNTcyLDIyICs1NzIsMjQgQEAKICAqIG1wdDJzYXNfYmFzZV9kb25lIC0gYmFzZSBpbnRlcm5hbCBjb21tYW5kIGNvbXBsZXRpb24gcm91dGluZQogICogQGlvYzogcG9pbnRlciB0byBzY3NpIGNvbW1hbmQgb2JqZWN0CiAgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAotICogQFZGX0lEOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCisgKiBAbXNpeF9pbmRleDogTVNJWCB0YWJsZSBpbmRleCBzdXBwbGllZCBieSB0aGUgT1MKICAqIEByZXBseTogcmVwbHkgbWVzc2FnZSBmcmFtZShsb3dlciAzMmJpdCBhZGRyKQogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXZvaWQKLW1wdDJzYXNfYmFzZV9kb25lKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IFZGX0lELCB1MzIgcmVwbHkpCit1OAorbXB0MnNhc19iYXNlX2RvbmUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggbXNpeF9pbmRleCwKKyAgICB1MzIgcmVwbHkpCiB7CiAJTVBJMkRlZmF1bHRSZXBseV90ICptcGlfcmVwbHk7CiAKIAltcGlfcmVwbHkgPSBtcHQyc2FzX2Jhc2VfZ2V0X3JlcGx5X3ZpcnRfYWRkcihpb2MsIHJlcGx5KTsKIAlpZiAobXBpX3JlcGx5ICYmIG1waV9yZXBseS0+RnVuY3Rpb24gPT0gTVBJMl9GVU5DVElPTl9FVkVOVF9BQ0spCi0JCXJldHVybjsKKwkJcmV0dXJuIDE7CiAKIAlpZiAoaW9jLT5iYXNlX2NtZHMuc3RhdHVzID09IE1QVDJfQ01EX05PVF9VU0VEKQotCQlyZXR1cm47CisJCXJldHVybiAxOwogCiAJaW9jLT5iYXNlX2NtZHMuc3RhdHVzIHw9IE1QVDJfQ01EX0NPTVBMRVRFOwogCWlmIChtcGlfcmVwbHkpIHsKQEAgLTU5NiwxOCArNTk4LDIwIEBACiAJfQogCWlvYy0+YmFzZV9jbWRzLnN0YXR1cyAmPSB+TVBUMl9DTURfUEVORElORzsKIAljb21wbGV0ZSgmaW9jLT5iYXNlX2NtZHMuZG9uZSk7CisJcmV0dXJuIDE7CiB9CiAKIC8qKgogICogX2Jhc2VfYXN5bmNfZXZlbnQgLSBtYWluIGNhbGxiYWNrIGhhbmRsZXIgZm9yIGZpcm13YXJlIGFzeW4gZXZlbnRzCiAgKiBAaW9jOiBwb2ludGVyIHRvIHNjc2kgY29tbWFuZCBvYmplY3QKLSAqIEBWRl9JRDogdmlydHVhbCBmdW5jdGlvbiBpZAorICogQG1zaXhfaW5kZXg6IE1TSVggdGFibGUgaW5kZXggc3VwcGxpZWQgYnkgdGhlIE9TCiAgKiBAcmVwbHk6IHJlcGx5IG1lc3NhZ2UgZnJhbWUobG93ZXIgMzJiaXQgYWRkcikKICAqCi0gKiBSZXR1cm4gbm90aGluZy4KKyAqIFJldHVybiAxIG1lYW5pbmcgbWYgc2hvdWxkIGJlIGZyZWVkIGZyb20gX2Jhc2VfaW50ZXJydXB0CisgKiAgICAgICAgMCBtZWFucyB0aGUgbWYgaXMgZnJlZWQgZnJvbSB0aGlzIGZ1bmN0aW9uLgogICovCi1zdGF0aWMgdm9pZAotX2Jhc2VfYXN5bmNfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwgdTMyIHJlcGx5KQorc3RhdGljIHU4CitfYmFzZV9hc3luY19ldmVudChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IG1zaXhfaW5kZXgsIHUzMiByZXBseSkKIHsKIAlNcGkyRXZlbnROb3RpZmljYXRpb25SZXBseV90ICptcGlfcmVwbHk7CiAJTXBpMkV2ZW50QWNrUmVxdWVzdF90ICphY2tfcmVxdWVzdDsKQEAgLTYxNSw5ICs2MTksOSBAQAogCiAJbXBpX3JlcGx5ID0gbXB0MnNhc19iYXNlX2dldF9yZXBseV92aXJ0X2FkZHIoaW9jLCByZXBseSk7CiAJaWYgKCFtcGlfcmVwbHkpCi0JCXJldHVybjsKKwkJcmV0dXJuIDE7CiAJaWYgKG1waV9yZXBseS0+RnVuY3Rpb24gIT0gTVBJMl9GVU5DVElPTl9FVkVOVF9OT1RJRklDQVRJT04pCi0JCXJldHVybjsKKwkJcmV0dXJuIDE7CiAjaWZkZWYgQ09ORklHX1NDU0lfTVBUMlNBU19MT0dHSU5HCiAJX2Jhc2VfZGlzcGxheV9ldmVudF9kYXRhKGlvYywgbXBpX3JlcGx5KTsKICNlbmRpZgpAQCAtNjM1LDE2ICs2MzksNDcgQEAKIAlhY2tfcmVxdWVzdC0+RnVuY3Rpb24gPSBNUEkyX0ZVTkNUSU9OX0VWRU5UX0FDSzsKIAlhY2tfcmVxdWVzdC0+RXZlbnQgPSBtcGlfcmVwbHktPkV2ZW50OwogCWFja19yZXF1ZXN0LT5FdmVudENvbnRleHQgPSBtcGlfcmVwbHktPkV2ZW50Q29udGV4dDsKLQlhY2tfcmVxdWVzdC0+VkZfSUQgPSBWRl9JRDsKLQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIFZGX0lEKTsKKwlhY2tfcmVxdWVzdC0+VkZfSUQgPSAwOyAgLyogVE9ETyAqLworCWFja19yZXF1ZXN0LT5WUF9JRCA9IDA7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkKTsKIAogIG91dDoKIAogCS8qIHNjc2loIGNhbGxiYWNrIGhhbmRsZXIgKi8KLQltcHQyc2FzX3Njc2loX2V2ZW50X2NhbGxiYWNrKGlvYywgVkZfSUQsIHJlcGx5KTsKKwltcHQyc2FzX3Njc2loX2V2ZW50X2NhbGxiYWNrKGlvYywgbXNpeF9pbmRleCwgcmVwbHkpOwogCiAJLyogY3RsIGNhbGxiYWNrIGhhbmRsZXIgKi8KLQltcHQyc2FzX2N0bF9ldmVudF9jYWxsYmFjayhpb2MsIFZGX0lELCByZXBseSk7CisJbXB0MnNhc19jdGxfZXZlbnRfY2FsbGJhY2soaW9jLCBtc2l4X2luZGV4LCByZXBseSk7CisKKwlyZXR1cm4gMTsKK30KKworLyoqCisgKiBfYmFzZV9nZXRfY2JfaWR4IC0gb2J0YWluIHRoZSBjYWxsYmFjayBpbmRleAorICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CisgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAorICoKKyAqIFJldHVybiBjYWxsYmFjayBpbmRleC4KKyAqLworc3RhdGljIHU4CitfYmFzZV9nZXRfY2JfaWR4KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQpCit7CisJaW50IGk7CisJdTggY2JfaWR4ID0gMHhGRjsKKworCWlmIChzbWlkID49IGlvYy0+aGlfcHJpb3JpdHlfc21pZCkgeworCQlpZiAoc21pZCA8IGlvYy0+aW50ZXJuYWxfc21pZCkgeworCQkJaSA9IHNtaWQgLSBpb2MtPmhpX3ByaW9yaXR5X3NtaWQ7CisJCQljYl9pZHggPSBpb2MtPmhwcl9sb29rdXBbaV0uY2JfaWR4OworCQl9IGVsc2UgeworCQkJaSA9IHNtaWQgLSBpb2MtPmludGVybmFsX3NtaWQ7CisJCQljYl9pZHggPSBpb2MtPmludGVybmFsX2xvb2t1cFtpXS5jYl9pZHg7CisJCX0KKwl9IGVsc2UgeworCQlpID0gc21pZCAtIDE7CisJCWNiX2lkeCA9IGlvYy0+c2NzaV9sb29rdXBbaV0uY2JfaWR4OworCX0KKwlyZXR1cm4gY2JfaWR4OwogfQogCiAvKioKQEAgLTY4MCw3ICs3MTUsNiBAQAogewogCXUzMiBoaW1fcmVnaXN0ZXI7CiAKLQl3cml0ZWwoMCwgJmlvYy0+Y2hpcC0+SG9zdEludGVycnVwdFN0YXR1cyk7CiAJaGltX3JlZ2lzdGVyID0gcmVhZGwoJmlvYy0+Y2hpcC0+SG9zdEludGVycnVwdE1hc2spOwogCWhpbV9yZWdpc3RlciAmPSB+TVBJMl9ISU1fUklNOwogCXdyaXRlbChoaW1fcmVnaXN0ZXIsICZpb2MtPmNoaXAtPkhvc3RJbnRlcnJ1cHRNYXNrKTsKQEAgLTcxMiw5ICs3NDYsMTAgQEAKIAl1MTYgc21pZDsKIAl1OCBjYl9pZHg7CiAJdTMyIHJlcGx5OwotCXU4IFZGX0lEOworCXU4IG1zaXhfaW5kZXg7CiAJc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jID0gYnVzX2lkOwogCU1waTJSZXBseURlc2NyaXB0b3JzVW5pb25fdCAqcnBmOworCXU4IHJjOwogCiAJaWYgKGlvYy0+bWFza19pbnRlcnJ1cHRzKQogCQlyZXR1cm4gSVJRX05PTkU7CkBAIC03MzMsNyArNzY4LDcgQEAKIAkJcmVwbHkgPSAwOwogCQljYl9pZHggPSAweEZGOwogCQlzbWlkID0gbGUxNl90b19jcHUocnBmLT5EZWZhdWx0LkRlc2NyaXB0b3JUeXBlRGVwZW5kZW50MSk7Ci0JCVZGX0lEID0gcnBmLT5EZWZhdWx0LlZGX0lEOworCQltc2l4X2luZGV4ID0gcnBmLT5EZWZhdWx0Lk1TSXhJbmRleDsKIAkJaWYgKHJlcXVlc3RfZGVzcmlwdF90eXBlID09CiAJCSAgICBNUEkyX1JQWV9ERVNDUklQVF9GTEFHU19BRERSRVNTX1JFUExZKSB7CiAJCQlyZXBseSA9IGxlMzJfdG9fY3B1CkBAIC03NDUsMTYgKzc4MCwxOCBAQAogCQkgICAgTVBJMl9SUFlfREVTQ1JJUFRfRkxBR1NfVEFSR0VUQVNTSVNUX1NVQ0NFU1MpCiAJCQlnb3RvIG5leHQ7CiAJCWlmIChzbWlkKQotCQkJY2JfaWR4ID0gaW9jLT5zY3NpX2xvb2t1cFtzbWlkIC0gMV0uY2JfaWR4OworCQkJY2JfaWR4ID0gX2Jhc2VfZ2V0X2NiX2lkeChpb2MsIHNtaWQpOwogCQlpZiAoc21pZCAmJiBjYl9pZHggIT0gMHhGRikgewotCQkJbXB0X2NhbGxiYWNrc1tjYl9pZHhdKGlvYywgc21pZCwgVkZfSUQsIHJlcGx5KTsKKwkJCXJjID0gbXB0X2NhbGxiYWNrc1tjYl9pZHhdKGlvYywgc21pZCwgbXNpeF9pbmRleCwKKwkJCSAgICByZXBseSk7CiAJCQlpZiAocmVwbHkpCi0JCQkJX2Jhc2VfZGlzcGxheV9yZXBseV9pbmZvKGlvYywgc21pZCwgVkZfSUQsCisJCQkJX2Jhc2VfZGlzcGxheV9yZXBseV9pbmZvKGlvYywgc21pZCwgbXNpeF9pbmRleCwKIAkJCQkgICAgcmVwbHkpOwotCQkJbXB0MnNhc19iYXNlX2ZyZWVfc21pZChpb2MsIHNtaWQpOworCQkJaWYgKHJjKQorCQkJCW1wdDJzYXNfYmFzZV9mcmVlX3NtaWQoaW9jLCBzbWlkKTsKIAkJfQogCQlpZiAoIXNtaWQpCi0JCQlfYmFzZV9hc3luY19ldmVudChpb2MsIFZGX0lELCByZXBseSk7CisJCQlfYmFzZV9hc3luY19ldmVudChpb2MsIG1zaXhfaW5kZXgsIHJlcGx5KTsKIAogCQkvKiByZXBseSBmcmVlIHF1ZXVlIGhhbmRsaW5nICovCiAJCWlmIChyZXBseSkgewpAQCAtMTE5MSwxOSArMTIyOCw2IEBACiB9CiAKIC8qKgotICogbXB0MnNhc19iYXNlX2dldF9tc2dfZnJhbWVfZG1hIC0gb2J0YWluIHJlcXVlc3QgbWYgcG9pbnRlciBwaHlzIGFkZHIKLSAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAotICogQHNtaWQ6IHN5c3RlbSByZXF1ZXN0IG1lc3NhZ2UgaW5kZXgoc21pZCB6ZXJvIGlzIGludmFsaWQpCi0gKgotICogUmV0dXJucyBwaHlzIHBvaW50ZXIgdG8gbWVzc2FnZSBmcmFtZS4KLSAqLwotZG1hX2FkZHJfdAotbXB0MnNhc19iYXNlX2dldF9tc2dfZnJhbWVfZG1hKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQpCi17Ci0JcmV0dXJuIGlvYy0+cmVxdWVzdF9kbWEgKyAoc21pZCAqIGlvYy0+cmVxdWVzdF9zeik7Ci19Ci0KLS8qKgogICogbXB0MnNhc19iYXNlX2dldF9tc2dfZnJhbWUgLSBvYnRhaW4gcmVxdWVzdCBtZiBwb2ludGVyCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4KHNtaWQgemVybyBpcyBpbnZhbGlkKQpAQCAtMTI1OCw3ICsxMjgyLDcgQEAKIH0KIAogLyoqCi0gKiBtcHQyc2FzX2Jhc2VfZ2V0X3NtaWQgLSBvYnRhaW4gYSBmcmVlIHNtaWQKKyAqIG1wdDJzYXNfYmFzZV9nZXRfc21pZCAtIG9idGFpbiBhIGZyZWUgc21pZCBmcm9tIGludGVybmFsIHF1ZXVlCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBjYl9pZHg6IGNhbGxiYWNrIGluZGV4CiAgKgpAQCAtMTI3Miw2ICsxMjk2LDM5IEBACiAJdTE2IHNtaWQ7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7CisJaWYgKGxpc3RfZW1wdHkoJmlvYy0+aW50ZXJuYWxfZnJlZV9saXN0KSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKKwkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiJXM6IHNtaWQgbm90IGF2YWlsYWJsZVxuIiwKKwkJICAgIGlvYy0+bmFtZSwgX19mdW5jX18pOworCQlyZXR1cm4gMDsKKwl9CisKKwlyZXF1ZXN0ID0gbGlzdF9lbnRyeShpb2MtPmludGVybmFsX2ZyZWVfbGlzdC5uZXh0LAorCSAgICBzdHJ1Y3QgcmVxdWVzdF90cmFja2VyLCB0cmFja2VyX2xpc3QpOworCXJlcXVlc3QtPmNiX2lkeCA9IGNiX2lkeDsKKwlzbWlkID0gcmVxdWVzdC0+c21pZDsKKwlsaXN0X2RlbCgmcmVxdWVzdC0+dHJhY2tlcl9saXN0KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKKwlyZXR1cm4gc21pZDsKK30KKworLyoqCisgKiBtcHQyc2FzX2Jhc2VfZ2V0X3NtaWRfc2NzaWlvIC0gb2J0YWluIGEgZnJlZSBzbWlkIGZyb20gc2NzaWlvIHF1ZXVlCisgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKKyAqIEBjYl9pZHg6IGNhbGxiYWNrIGluZGV4CisgKiBAc2NtZDogcG9pbnRlciB0byBzY3NpIGNvbW1hbmQgb2JqZWN0CisgKgorICogUmV0dXJucyBzbWlkICh6ZXJvIGlzIGludmFsaWQpCisgKi8KK3UxNgorbXB0MnNhc19iYXNlX2dldF9zbWlkX3Njc2lpbyhzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IGNiX2lkeCwKKyAgICBzdHJ1Y3Qgc2NzaV9jbW5kICpzY21kKQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IHJlcXVlc3RfdHJhY2tlciAqcmVxdWVzdDsKKwl1MTYgc21pZDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKIAlpZiAobGlzdF9lbXB0eSgmaW9jLT5mcmVlX2xpc3QpKSB7CiAJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOwogCQlwcmludGsoTVBUMlNBU19FUlJfRk1UICIlczogc21pZCBub3QgYXZhaWxhYmxlXG4iLApAQCAtMTI4MSw2ICsxMzM4LDM2IEBACiAKIAlyZXF1ZXN0ID0gbGlzdF9lbnRyeShpb2MtPmZyZWVfbGlzdC5uZXh0LAogCSAgICBzdHJ1Y3QgcmVxdWVzdF90cmFja2VyLCB0cmFja2VyX2xpc3QpOworCXJlcXVlc3QtPnNjbWQgPSBzY21kOworCXJlcXVlc3QtPmNiX2lkeCA9IGNiX2lkeDsKKwlzbWlkID0gcmVxdWVzdC0+c21pZDsKKwlsaXN0X2RlbCgmcmVxdWVzdC0+dHJhY2tlcl9saXN0KTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKKwlyZXR1cm4gc21pZDsKK30KKworLyoqCisgKiBtcHQyc2FzX2Jhc2VfZ2V0X3NtaWRfaHByIC0gb2J0YWluIGEgZnJlZSBzbWlkIGZyb20gaGktcHJpb3JpdHkgcXVldWUKKyAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAorICogQGNiX2lkeDogY2FsbGJhY2sgaW5kZXgKKyAqCisgKiBSZXR1cm5zIHNtaWQgKHplcm8gaXMgaW52YWxpZCkKKyAqLwordTE2CittcHQyc2FzX2Jhc2VfZ2V0X3NtaWRfaHByKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTggY2JfaWR4KQoreworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IHJlcXVlc3RfdHJhY2tlciAqcmVxdWVzdDsKKwl1MTYgc21pZDsKKworCXNwaW5fbG9ja19pcnFzYXZlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKKwlpZiAobGlzdF9lbXB0eSgmaW9jLT5ocHJfZnJlZV9saXN0KSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKKwkJcmV0dXJuIDA7CisJfQorCisJcmVxdWVzdCA9IGxpc3RfZW50cnkoaW9jLT5ocHJfZnJlZV9saXN0Lm5leHQsCisJICAgIHN0cnVjdCByZXF1ZXN0X3RyYWNrZXIsIHRyYWNrZXJfbGlzdCk7CiAJcmVxdWVzdC0+Y2JfaWR4ID0gY2JfaWR4OwogCXNtaWQgPSByZXF1ZXN0LT5zbWlkOwogCWxpc3RfZGVsKCZyZXF1ZXN0LT50cmFja2VyX2xpc3QpOwpAQCAtMTMwMCwxMCArMTM4NywzMiBAQAogbXB0MnNhc19iYXNlX2ZyZWVfc21pZChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkKQogewogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJaW50IGk7CiAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7Ci0JaW9jLT5zY3NpX2xvb2t1cFtzbWlkIC0gMV0uY2JfaWR4ID0gMHhGRjsKLQlsaXN0X2FkZF90YWlsKCZpb2MtPnNjc2lfbG9va3VwW3NtaWQgLSAxXS50cmFja2VyX2xpc3QsCisJaWYgKHNtaWQgPj0gaW9jLT5oaV9wcmlvcml0eV9zbWlkKSB7CisJCWlmIChzbWlkIDwgaW9jLT5pbnRlcm5hbF9zbWlkKSB7CisJCQkvKiBoaS1wcmlvcml0eSAqLworCQkJaSA9IHNtaWQgLSBpb2MtPmhpX3ByaW9yaXR5X3NtaWQ7CisJCQlpb2MtPmhwcl9sb29rdXBbaV0uY2JfaWR4ID0gMHhGRjsKKwkJCWxpc3RfYWRkX3RhaWwoJmlvYy0+aHByX2xvb2t1cFtpXS50cmFja2VyX2xpc3QsCisJCQkgICAgJmlvYy0+aHByX2ZyZWVfbGlzdCk7CisJCX0gZWxzZSB7CisJCQkvKiBpbnRlcm5hbCBxdWV1ZSAqLworCQkJaSA9IHNtaWQgLSBpb2MtPmludGVybmFsX3NtaWQ7CisJCQlpb2MtPmludGVybmFsX2xvb2t1cFtpXS5jYl9pZHggPSAweEZGOworCQkJbGlzdF9hZGRfdGFpbCgmaW9jLT5pbnRlcm5hbF9sb29rdXBbaV0udHJhY2tlcl9saXN0LAorCQkJICAgICZpb2MtPmludGVybmFsX2ZyZWVfbGlzdCk7CisJCX0KKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7CisJCXJldHVybjsKKwl9CisKKwkvKiBzY3NpaW8gcXVldWUgKi8KKwlpID0gc21pZCAtIDE7CisJaW9jLT5zY3NpX2xvb2t1cFtpXS5jYl9pZHggPSAweEZGOworCWlvYy0+c2NzaV9sb29rdXBbaV0uc2NtZCA9IE5VTEw7CisJbGlzdF9hZGRfdGFpbCgmaW9jLT5zY3NpX2xvb2t1cFtpXS50cmFja2VyX2xpc3QsCiAJICAgICZpb2MtPmZyZWVfbGlzdCk7CiAJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7CiAKQEAgLTEzNTIsMjEgKzE0NjEsMTkgQEAKICAqIG1wdDJzYXNfYmFzZV9wdXRfc21pZF9zY3NpX2lvIC0gc2VuZCBTQ1NJX0lPIHJlcXVlc3QgdG8gZmlybXdhcmUKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAogICogQHNtaWQ6IHN5c3RlbSByZXF1ZXN0IG1lc3NhZ2UgaW5kZXgKLSAqIEB2Zl9pZDogdmlydHVhbCBmdW5jdGlvbiBpZAogICogQGhhbmRsZTogZGV2aWNlIGhhbmRsZQogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiB2b2lkCi1tcHQyc2FzX2Jhc2VfcHV0X3NtaWRfc2NzaV9pbyhzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCB2Zl9pZCwKLSAgICB1MTYgaGFuZGxlKQorbXB0MnNhc19iYXNlX3B1dF9zbWlkX3Njc2lfaW8oc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTE2IGhhbmRsZSkKIHsKIAlNcGkyUmVxdWVzdERlc2NyaXB0b3JVbmlvbl90IGRlc2NyaXB0b3I7CiAJdTY0ICpyZXF1ZXN0ID0gKHU2NCAqKSZkZXNjcmlwdG9yOwogCiAKIAlkZXNjcmlwdG9yLlNDU0lJTy5SZXF1ZXN0RmxhZ3MgPSBNUEkyX1JFUV9ERVNDUklQVF9GTEFHU19TQ1NJX0lPOwotCWRlc2NyaXB0b3IuU0NTSUlPLlZGX0lEID0gdmZfaWQ7CisJZGVzY3JpcHRvci5TQ1NJSU8uTVNJeEluZGV4ID0gMDsgLyogVE9ETyAqLwogCWRlc2NyaXB0b3IuU0NTSUlPLlNNSUQgPSBjcHVfdG9fbGUxNihzbWlkKTsKIAlkZXNjcmlwdG9yLlNDU0lJTy5EZXZIYW5kbGUgPSBjcHVfdG9fbGUxNihoYW5kbGUpOwogCWRlc2NyaXB0b3IuU0NTSUlPLkxNSUQgPSAwOwpAQCAtMTM3OSwyMCArMTQ4NiwxOCBAQAogICogbXB0MnNhc19iYXNlX3B1dF9zbWlkX2hpX3ByaW9yaXR5IC0gc2VuZCBUYXNrIE1hbmFnbWVudCByZXF1ZXN0IHRvIGZpcm13YXJlCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4Ci0gKiBAdmZfaWQ6IHZpcnR1YWwgZnVuY3Rpb24gaWQKICAqCiAgKiBSZXR1cm4gbm90aGluZy4KICAqLwogdm9pZAotbXB0MnNhc19iYXNlX3B1dF9zbWlkX2hpX3ByaW9yaXR5KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsCi0gICAgdTggdmZfaWQpCittcHQyc2FzX2Jhc2VfcHV0X3NtaWRfaGlfcHJpb3JpdHkoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCkKIHsKIAlNcGkyUmVxdWVzdERlc2NyaXB0b3JVbmlvbl90IGRlc2NyaXB0b3I7CiAJdTY0ICpyZXF1ZXN0ID0gKHU2NCAqKSZkZXNjcmlwdG9yOwogCiAJZGVzY3JpcHRvci5IaWdoUHJpb3JpdHkuUmVxdWVzdEZsYWdzID0KIAkgICAgTVBJMl9SRVFfREVTQ1JJUFRfRkxBR1NfSElHSF9QUklPUklUWTsKLQlkZXNjcmlwdG9yLkhpZ2hQcmlvcml0eS5WRl9JRCA9IHZmX2lkOworCWRlc2NyaXB0b3IuSGlnaFByaW9yaXR5Lk1TSXhJbmRleCA9IDA7IC8qIFRPRE8gKi8KIAlkZXNjcmlwdG9yLkhpZ2hQcmlvcml0eS5TTUlEID0gY3B1X3RvX2xlMTYoc21pZCk7CiAJZGVzY3JpcHRvci5IaWdoUHJpb3JpdHkuTE1JRCA9IDA7CiAJZGVzY3JpcHRvci5IaWdoUHJpb3JpdHkuUmVzZXJ2ZWQxID0gMDsKQEAgLTE0MDQsMTggKzE1MDksMTcgQEAKICAqIG1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0IC0gRGVmYXVsdCwgcHJpbWFyaWx5IHVzZWQgZm9yIGNvbmZpZyBwYWdlcwogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CiAgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAotICogQHZmX2lkOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCiAgKgogICogUmV0dXJuIG5vdGhpbmcuCiAgKi8KIHZvaWQKLW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IHZmX2lkKQorbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCkKIHsKIAlNcGkyUmVxdWVzdERlc2NyaXB0b3JVbmlvbl90IGRlc2NyaXB0b3I7CiAJdTY0ICpyZXF1ZXN0ID0gKHU2NCAqKSZkZXNjcmlwdG9yOwogCiAJZGVzY3JpcHRvci5EZWZhdWx0LlJlcXVlc3RGbGFncyA9IE1QSTJfUkVRX0RFU0NSSVBUX0ZMQUdTX0RFRkFVTFRfVFlQRTsKLQlkZXNjcmlwdG9yLkRlZmF1bHQuVkZfSUQgPSB2Zl9pZDsKKwlkZXNjcmlwdG9yLkRlZmF1bHQuTVNJeEluZGV4ID0gMDsgLyogVE9ETyAqLwogCWRlc2NyaXB0b3IuRGVmYXVsdC5TTUlEID0gY3B1X3RvX2xlMTYoc21pZCk7CiAJZGVzY3JpcHRvci5EZWZhdWx0LkxNSUQgPSAwOwogCWRlc2NyaXB0b3IuRGVmYXVsdC5EZXNjcmlwdG9yVHlwZURlcGVuZGVudCA9IDA7CkBAIC0xNDI3LDIxICsxNTMxLDIwIEBACiAgKiBtcHQyc2FzX2Jhc2VfcHV0X3NtaWRfdGFyZ2V0X2Fzc2lzdCAtIHNlbmQgVGFyZ2V0IEFzc2lzdC9TdGF0dXMgdG8gZmlybXdhcmUKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAogICogQHNtaWQ6IHN5c3RlbSByZXF1ZXN0IG1lc3NhZ2UgaW5kZXgKLSAqIEB2Zl9pZDogdmlydHVhbCBmdW5jdGlvbiBpZAogICogQGlvX2luZGV4OiB2YWx1ZSB1c2VkIHRvIHRyYWNrIHRoZSBJTwogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiB2b2lkCiBtcHQyc2FzX2Jhc2VfcHV0X3NtaWRfdGFyZ2V0X2Fzc2lzdChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLAotICAgIHU4IHZmX2lkLCB1MTYgaW9faW5kZXgpCisgICAgdTE2IGlvX2luZGV4KQogewogCU1waTJSZXF1ZXN0RGVzY3JpcHRvclVuaW9uX3QgZGVzY3JpcHRvcjsKIAl1NjQgKnJlcXVlc3QgPSAodTY0ICopJmRlc2NyaXB0b3I7CiAKIAlkZXNjcmlwdG9yLlNDU0lUYXJnZXQuUmVxdWVzdEZsYWdzID0KIAkgICAgTVBJMl9SRVFfREVTQ1JJUFRfRkxBR1NfU0NTSV9UQVJHRVQ7Ci0JZGVzY3JpcHRvci5TQ1NJVGFyZ2V0LlZGX0lEID0gdmZfaWQ7CisJZGVzY3JpcHRvci5TQ1NJVGFyZ2V0Lk1TSXhJbmRleCA9IDA7IC8qIFRPRE8gKi8KIAlkZXNjcmlwdG9yLlNDU0lUYXJnZXQuU01JRCA9IGNwdV90b19sZTE2KHNtaWQpOwogCWRlc2NyaXB0b3IuU0NTSVRhcmdldC5MTUlEID0gMDsKIAlkZXNjcmlwdG9yLlNDU0lUYXJnZXQuSW9JbmRleCA9IGNwdV90b19sZTE2KGlvX2luZGV4KTsKQEAgLTE3MTcsNiArMTgyMCw4IEBACiAJfQogCiAJa2ZyZWUoaW9jLT5zY3NpX2xvb2t1cCk7CisJa2ZyZWUoaW9jLT5ocHJfbG9va3VwKTsKKwlrZnJlZShpb2MtPmludGVybmFsX2xvb2t1cCk7CiB9CiAKIApAQCAtMTczNiw3ICsxODQxLDYgQEAKIAl1MTYgbnVtX29mX3JlcGx5X2ZyYW1lczsKIAl1MTYgY2hhaW5zX25lZWRlZF9wZXJfaW87CiAJdTMyIHN6LCB0b3RhbF9zejsKLQl1MTYgaTsKIAl1MzIgcmV0cnlfc3o7CiAJdTE2IG1heF9yZXF1ZXN0X2NyZWRpdDsKIApAQCAtMTc2NCw3ICsxODY4LDEwIEBACiAJCSAgICBNUFQyU0FTX01BWF9SRVFVRVNUX1FVRVVFKSA/IE1QVDJTQVNfTUFYX1JFUVVFU1RfUVVFVUUgOgogCQkgICAgZmFjdHMtPlJlcXVlc3RDcmVkaXQ7CiAJfQotCWlvYy0+cmVxdWVzdF9kZXB0aCA9IG1heF9yZXF1ZXN0X2NyZWRpdDsKKworCWlvYy0+aGJhX3F1ZXVlX2RlcHRoID0gbWF4X3JlcXVlc3RfY3JlZGl0OworCWlvYy0+aGlfcHJpb3JpdHlfZGVwdGggPSBmYWN0cy0+SGlnaFByaW9yaXR5Q3JlZGl0OworCWlvYy0+aW50ZXJuYWxfZGVwdGggPSBpb2MtPmhpX3ByaW9yaXR5X2RlcHRoICsgNTsKIAogCS8qIHJlcXVlc3QgZnJhbWUgc2l6ZSAqLwogCWlvYy0+cmVxdWVzdF9zeiA9IGZhY3RzLT5JT0NSZXF1ZXN0RnJhbWVTaXplICogNDsKQEAgLTE4MDIsNyArMTkwOSw3IEBACiAJaW9jLT5jaGFpbnNfbmVlZGVkX3Blcl9pbyA9IGNoYWluc19uZWVkZWRfcGVyX2lvOwogCiAJLyogcmVwbHkgZnJlZSBxdWV1ZSBzaXppbmcgLSB0YWtpbmcgaW50byBhY2NvdW50IGZvciBldmVudHMgKi8KLQludW1fb2ZfcmVwbHlfZnJhbWVzID0gaW9jLT5yZXF1ZXN0X2RlcHRoICsgMzI7CisJbnVtX29mX3JlcGx5X2ZyYW1lcyA9IGlvYy0+aGJhX3F1ZXVlX2RlcHRoICsgMzI7CiAKIAkvKiBudW1iZXIgb2YgcmVwbGllcyBmcmFtZXMgY2FuJ3QgYmUgYSBtdWx0aXBsZSBvZiAxNiAqLwogCS8qIGRlY3JlYXNlIG51bWJlciBvZiByZXBseSBmcmFtZXMgYnkgMSAqLwpAQCAtMTgyMyw3ICsxOTMwLDcgQEAKIAkgKiBmcmFtZXMKIAkgKi8KIAotCXF1ZXVlX3NpemUgPSBpb2MtPnJlcXVlc3RfZGVwdGggKyBudW1fb2ZfcmVwbHlfZnJhbWVzICsgMTsKKwlxdWV1ZV9zaXplID0gaW9jLT5oYmFfcXVldWVfZGVwdGggKyBudW1fb2ZfcmVwbHlfZnJhbWVzICsgMTsKIAkvKiByb3VuZCB1cCB0byAxNiBieXRlIGJvdW5kYXJ5ICovCiAJaWYgKHF1ZXVlX3NpemUgJSAxNikKIAkJcXVldWVfc2l6ZSArPSAxNiAtIChxdWV1ZV9zaXplICUgMTYpOwpAQCAtMTgzNyw2MCArMTk0NCw4NSBAQAogCQlpZiAocXVldWVfZGlmZiAlIDE2KQogCQkJcXVldWVfZGlmZiArPSAxNiAtIChxdWV1ZV9kaWZmICUgMTYpOwogCi0JCS8qIGFkanVzdCByZXF1ZXN0X2RlcHRoLCByZXBseV9mcmVlX3F1ZXVlX2RlcHRoLAorCQkvKiBhZGp1c3QgaGJhX3F1ZXVlX2RlcHRoLCByZXBseV9mcmVlX3F1ZXVlX2RlcHRoLAogCQkgKiBhbmQgcXVldWVfc2l6ZQogCQkgKi8KLQkJaW9jLT5yZXF1ZXN0X2RlcHRoIC09IHF1ZXVlX2RpZmY7CisJCWlvYy0+aGJhX3F1ZXVlX2RlcHRoIC09IHF1ZXVlX2RpZmY7CiAJCWlvYy0+cmVwbHlfZnJlZV9xdWV1ZV9kZXB0aCAtPSBxdWV1ZV9kaWZmOwogCQlxdWV1ZV9zaXplIC09IHF1ZXVlX2RpZmY7CiAJfQogCWlvYy0+cmVwbHlfcG9zdF9xdWV1ZV9kZXB0aCA9IHF1ZXVlX3NpemU7CiAKLQkvKiBtYXggc2NzaSBob3N0IHF1ZXVlIGRlcHRoICovCi0JaW9jLT5zaG9zdC0+Y2FuX3F1ZXVlID0gaW9jLT5yZXF1ZXN0X2RlcHRoIC0gSU5URVJOQUxfQ01EU19DT1VOVDsKLQlkaW5pdHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJzY3NpIGhvc3QgcXVldWU6IGRlcHRoIgotCSAgICAiKCVkKVxuIiwgaW9jLT5uYW1lLCBpb2MtPnNob3N0LT5jYW5fcXVldWUpKTsKLQogCWRpbml0cHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfSU5GT19GTVQgInNjYXR0ZXIgZ2F0aGVyOiAiCiAJICAgICJzZ2VfaW5fbWFpbl9tc2coJWQpLCBzZ2VfcGVyX2NoYWluKCVkKSwgc2dlX3Blcl9pbyglZCksICIKIAkgICAgImNoYWluc19wZXJfaW8oJWQpXG4iLCBpb2MtPm5hbWUsIGlvYy0+bWF4X3NnZXNfaW5fbWFpbl9tZXNzYWdlLAogCSAgICBpb2MtPm1heF9zZ2VzX2luX2NoYWluX21lc3NhZ2UsIGlvYy0+c2hvc3QtPnNnX3RhYmxlc2l6ZSwKIAkgICAgaW9jLT5jaGFpbnNfbmVlZGVkX3Blcl9pbykpOwogCisJaW9jLT5zY3NpaW9fZGVwdGggPSBpb2MtPmhiYV9xdWV1ZV9kZXB0aCAtCisJICAgIGlvYy0+aGlfcHJpb3JpdHlfZGVwdGggLSBpb2MtPmludGVybmFsX2RlcHRoOworCisJLyogc2V0IHRoZSBzY3NpIGhvc3QgY2FuX3F1ZXVlIGRlcHRoCisJICogd2l0aCBzb21lIGludGVybmFsIGNvbW1hbmRzIHRoYXQgY291bGQgYmUgb3V0c3RhbmRpbmcKKwkgKi8KKwlpb2MtPnNob3N0LT5jYW5fcXVldWUgPSBpb2MtPnNjc2lpb19kZXB0aCAtICgyKTsKKwlkaW5pdHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJzY3NpIGhvc3Q6ICIKKwkgICAgImNhbl9xdWV1ZSBkZXB0aCAoJWQpXG4iLCBpb2MtPm5hbWUsIGlvYy0+c2hvc3QtPmNhbl9xdWV1ZSkpOworCiAJLyogY29udGlndW91cyBwb29sIGZvciByZXF1ZXN0IGFuZCBjaGFpbnMsIDE2IGJ5dGUgYWxpZ24sIG9uZSBleHRyYSAiCiAJICogImZyYW1lIGZvciBzbWlkPTAKIAkgKi8KLQlpb2MtPmNoYWluX2RlcHRoID0gaW9jLT5jaGFpbnNfbmVlZGVkX3Blcl9pbyAqIGlvYy0+cmVxdWVzdF9kZXB0aDsKLQlzeiA9ICgoaW9jLT5yZXF1ZXN0X2RlcHRoICsgMSArIGlvYy0+Y2hhaW5fZGVwdGgpICogaW9jLT5yZXF1ZXN0X3N6KTsKKwlpb2MtPmNoYWluX2RlcHRoID0gaW9jLT5jaGFpbnNfbmVlZGVkX3Blcl9pbyAqIGlvYy0+c2NzaWlvX2RlcHRoOworCXN6ID0gKChpb2MtPnNjc2lpb19kZXB0aCArIDEgKyBpb2MtPmNoYWluX2RlcHRoKSAqIGlvYy0+cmVxdWVzdF9zeik7CisKKwkvKiBoaS1wcmlvcml0eSBxdWV1ZSAqLworCXN6ICs9IChpb2MtPmhpX3ByaW9yaXR5X2RlcHRoICogaW9jLT5yZXF1ZXN0X3N6KTsKKworCS8qIGludGVybmFsIHF1ZXVlICovCisJc3ogKz0gKGlvYy0+aW50ZXJuYWxfZGVwdGggKiBpb2MtPnJlcXVlc3Rfc3opOwogCiAJaW9jLT5yZXF1ZXN0X2RtYV9zeiA9IHN6OwogCWlvYy0+cmVxdWVzdCA9IHBjaV9hbGxvY19jb25zaXN0ZW50KGlvYy0+cGRldiwgc3osICZpb2MtPnJlcXVlc3RfZG1hKTsKIAlpZiAoIWlvYy0+cmVxdWVzdCkgewogCQlwcmludGsoTVBUMlNBU19FUlJfRk1UICJyZXF1ZXN0IHBvb2w6IHBjaV9hbGxvY19jb25zaXN0ZW50ICIKLQkJICAgICJmYWlsZWQ6IHJlcV9kZXB0aCglZCksIGNoYWluc19wZXJfaW8oJWQpLCBmcmFtZV9zeiglZCksICIKLQkJICAgICJ0b3RhbCglZCBrQilcbiIsIGlvYy0+bmFtZSwgaW9jLT5yZXF1ZXN0X2RlcHRoLAorCQkgICAgImZhaWxlZDogaGJhX2RlcHRoKCVkKSwgY2hhaW5zX3Blcl9pbyglZCksIGZyYW1lX3N6KCVkKSwgIgorCQkgICAgInRvdGFsKCVkIGtCKVxuIiwgaW9jLT5uYW1lLCBpb2MtPmhiYV9xdWV1ZV9kZXB0aCwKIAkJICAgIGlvYy0+Y2hhaW5zX25lZWRlZF9wZXJfaW8sIGlvYy0+cmVxdWVzdF9zeiwgc3ovMTAyNCk7Ci0JCWlmIChpb2MtPnJlcXVlc3RfZGVwdGggPCBNUFQyU0FTX1NBU19RVUVVRV9ERVBUSCkKKwkJaWYgKGlvYy0+c2NzaWlvX2RlcHRoIDwgTVBUMlNBU19TQVNfUVVFVUVfREVQVEgpCiAJCQlnb3RvIG91dDsKIAkJcmV0cnlfc3ogKz0gNjQ7Ci0JCWlvYy0+cmVxdWVzdF9kZXB0aCA9IG1heF9yZXF1ZXN0X2NyZWRpdCAtIHJldHJ5X3N6OworCQlpb2MtPmhiYV9xdWV1ZV9kZXB0aCA9IG1heF9yZXF1ZXN0X2NyZWRpdCAtIHJldHJ5X3N6OwogCQlnb3RvIHJldHJ5X2FsbG9jYXRpb247CiAJfQogCiAJaWYgKHJldHJ5X3N6KQogCQlwcmludGsoTVBUMlNBU19FUlJfRk1UICJyZXF1ZXN0IHBvb2w6IHBjaV9hbGxvY19jb25zaXN0ZW50ICIKLQkJICAgICJzdWNjZWVkOiByZXFfZGVwdGgoJWQpLCBjaGFpbnNfcGVyX2lvKCVkKSwgZnJhbWVfc3ooJWQpLCAiCi0JCSAgICAidG90YWwoJWQga2IpXG4iLCBpb2MtPm5hbWUsIGlvYy0+cmVxdWVzdF9kZXB0aCwKKwkJICAgICJzdWNjZWVkOiBoYmFfZGVwdGgoJWQpLCBjaGFpbnNfcGVyX2lvKCVkKSwgZnJhbWVfc3ooJWQpLCAiCisJCSAgICAidG90YWwoJWQga2IpXG4iLCBpb2MtPm5hbWUsIGlvYy0+aGJhX3F1ZXVlX2RlcHRoLAogCQkgICAgaW9jLT5jaGFpbnNfbmVlZGVkX3Blcl9pbywgaW9jLT5yZXF1ZXN0X3N6LCBzei8xMDI0KTsKIAotCWlvYy0+Y2hhaW4gPSBpb2MtPnJlcXVlc3QgKyAoKGlvYy0+cmVxdWVzdF9kZXB0aCArIDEpICoKKworCS8qIGhpLXByaW9yaXR5IHF1ZXVlICovCisJaW9jLT5oaV9wcmlvcml0eSA9IGlvYy0+cmVxdWVzdCArICgoaW9jLT5zY3NpaW9fZGVwdGggKyAxKSAqCiAJICAgIGlvYy0+cmVxdWVzdF9zeik7Ci0JaW9jLT5jaGFpbl9kbWEgPSBpb2MtPnJlcXVlc3RfZG1hICsgKChpb2MtPnJlcXVlc3RfZGVwdGggKyAxKSAqCisJaW9jLT5oaV9wcmlvcml0eV9kbWEgPSBpb2MtPnJlcXVlc3RfZG1hICsgKChpb2MtPnNjc2lpb19kZXB0aCArIDEpICoKIAkgICAgaW9jLT5yZXF1ZXN0X3N6KTsKKworCS8qIGludGVybmFsIHF1ZXVlICovCisJaW9jLT5pbnRlcm5hbCA9IGlvYy0+aGlfcHJpb3JpdHkgKyAoaW9jLT5oaV9wcmlvcml0eV9kZXB0aCAqCisJICAgIGlvYy0+cmVxdWVzdF9zeik7CisJaW9jLT5pbnRlcm5hbF9kbWEgPSBpb2MtPmhpX3ByaW9yaXR5X2RtYSArIChpb2MtPmhpX3ByaW9yaXR5X2RlcHRoICoKKwkgICAgaW9jLT5yZXF1ZXN0X3N6KTsKKworCWlvYy0+Y2hhaW4gPSBpb2MtPmludGVybmFsICsgKGlvYy0+aW50ZXJuYWxfZGVwdGggKgorCSAgICBpb2MtPnJlcXVlc3Rfc3opOworCWlvYy0+Y2hhaW5fZG1hID0gaW9jLT5pbnRlcm5hbF9kbWEgKyAoaW9jLT5pbnRlcm5hbF9kZXB0aCAqCisJICAgIGlvYy0+cmVxdWVzdF9zeik7CisKIAlkaW5pdHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJyZXF1ZXN0IHBvb2woMHglcCk6ICIKIAkgICAgImRlcHRoKCVkKSwgZnJhbWVfc2l6ZSglZCksIHBvb2xfc2l6ZSglZCBrQilcbiIsIGlvYy0+bmFtZSwKLQkgICAgaW9jLT5yZXF1ZXN0LCBpb2MtPnJlcXVlc3RfZGVwdGgsIGlvYy0+cmVxdWVzdF9zeiwKLQkgICAgKChpb2MtPnJlcXVlc3RfZGVwdGggKyAxKSAqIGlvYy0+cmVxdWVzdF9zeikvMTAyNCkpOworCSAgICBpb2MtPnJlcXVlc3QsIGlvYy0+aGJhX3F1ZXVlX2RlcHRoLCBpb2MtPnJlcXVlc3Rfc3osCisJICAgIChpb2MtPmhiYV9xdWV1ZV9kZXB0aCAqIGlvYy0+cmVxdWVzdF9zeikvMTAyNCkpOwogCWRpbml0cHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfSU5GT19GTVQgImNoYWluIHBvb2woMHglcCk6IGRlcHRoIgogCSAgICAiKCVkKSwgZnJhbWVfc2l6ZSglZCksIHBvb2xfc2l6ZSglZCBrQilcbiIsIGlvYy0+bmFtZSwgaW9jLT5jaGFpbiwKIAkgICAgaW9jLT5jaGFpbl9kZXB0aCwgaW9jLT5yZXF1ZXN0X3N6LCAoKGlvYy0+Y2hhaW5fZGVwdGggKgpAQCAtMTg5OSw3ICsyMDMxLDcgQEAKIAkgICAgaW9jLT5uYW1lLCAodW5zaWduZWQgbG9uZyBsb25nKSBpb2MtPnJlcXVlc3RfZG1hKSk7CiAJdG90YWxfc3ogKz0gc3o7CiAKLQlpb2MtPnNjc2lfbG9va3VwID0ga2NhbGxvYyhpb2MtPnJlcXVlc3RfZGVwdGgsCisJaW9jLT5zY3NpX2xvb2t1cCA9IGtjYWxsb2MoaW9jLT5zY3NpaW9fZGVwdGgsCiAJICAgIHNpemVvZihzdHJ1Y3QgcmVxdWVzdF90cmFja2VyKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKCFpb2MtPnNjc2lfbG9va3VwKSB7CiAJCXByaW50ayhNUFQyU0FTX0VSUl9GTVQgInNjc2lfbG9va3VwOiBrY2FsbG9jIGZhaWxlZFxuIiwKQEAgLTE5MDcsMTIgKzIwMzksMzggQEAKIAkJZ290byBvdXQ7CiAJfQogCi0JIC8qIGluaXRpYWxpemUgc29tZSBiaXRzICovCi0JZm9yIChpID0gMDsgaSA8IGlvYy0+cmVxdWVzdF9kZXB0aDsgaSsrKQotCQlpb2MtPnNjc2lfbG9va3VwW2ldLnNtaWQgPSBpICsgMTsKKwlkaW5pdHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJzY3NpaW8oMHglcCk6ICIKKwkgICAgImRlcHRoKCVkKVxuIiwgaW9jLT5uYW1lLCBpb2MtPnJlcXVlc3QsCisJICAgIGlvYy0+c2NzaWlvX2RlcHRoKSk7CisKKwkvKiBpbml0aWFsaXplIGhpLXByaW9yaXR5IHF1ZXVlIHNtaWQncyAqLworCWlvYy0+aHByX2xvb2t1cCA9IGtjYWxsb2MoaW9jLT5oaV9wcmlvcml0eV9kZXB0aCwKKwkgICAgc2l6ZW9mKHN0cnVjdCByZXF1ZXN0X3RyYWNrZXIpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWlvYy0+aHByX2xvb2t1cCkgeworCQlwcmludGsoTVBUMlNBU19FUlJfRk1UICJocHJfbG9va3VwOiBrY2FsbG9jIGZhaWxlZFxuIiwKKwkJICAgIGlvYy0+bmFtZSk7CisJCWdvdG8gb3V0OworCX0KKwlpb2MtPmhpX3ByaW9yaXR5X3NtaWQgPSBpb2MtPnNjc2lpb19kZXB0aCArIDE7CisJZGluaXRwcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19JTkZPX0ZNVCAiaGlfcHJpb3JpdHkoMHglcCk6ICIKKwkgICAgImRlcHRoKCVkKSwgc3RhcnQgc21pZCglZClcbiIsIGlvYy0+bmFtZSwgaW9jLT5oaV9wcmlvcml0eSwKKwkgICAgaW9jLT5oaV9wcmlvcml0eV9kZXB0aCwgaW9jLT5oaV9wcmlvcml0eV9zbWlkKSk7CisKKwkvKiBpbml0aWFsaXplIGludGVybmFsIHF1ZXVlIHNtaWQncyAqLworCWlvYy0+aW50ZXJuYWxfbG9va3VwID0ga2NhbGxvYyhpb2MtPmludGVybmFsX2RlcHRoLAorCSAgICBzaXplb2Yoc3RydWN0IHJlcXVlc3RfdHJhY2tlciksIEdGUF9LRVJORUwpOworCWlmICghaW9jLT5pbnRlcm5hbF9sb29rdXApIHsKKwkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiaW50ZXJuYWxfbG9va3VwOiBrY2FsbG9jIGZhaWxlZFxuIiwKKwkJICAgIGlvYy0+bmFtZSk7CisJCWdvdG8gb3V0OworCX0KKwlpb2MtPmludGVybmFsX3NtaWQgPSBpb2MtPmhpX3ByaW9yaXR5X3NtaWQgKyBpb2MtPmhpX3ByaW9yaXR5X2RlcHRoOworCWRpbml0cHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfSU5GT19GTVQgImludGVybmFsKDB4JXApOiAiCisJICAgICJkZXB0aCglZCksIHN0YXJ0IHNtaWQoJWQpXG4iLCBpb2MtPm5hbWUsIGlvYy0+aW50ZXJuYWwsCisJICAgICBpb2MtPmludGVybmFsX2RlcHRoLCBpb2MtPmludGVybmFsX3NtaWQpKTsKIAogCS8qIHNlbnNlIGJ1ZmZlcnMsIDQgYnl0ZSBhbGlnbiAqLwotCXN6ID0gaW9jLT5yZXF1ZXN0X2RlcHRoICogU0NTSV9TRU5TRV9CVUZGRVJTSVpFOworCXN6ID0gaW9jLT5zY3NpaW9fZGVwdGggKiBTQ1NJX1NFTlNFX0JVRkZFUlNJWkU7CiAJaW9jLT5zZW5zZV9kbWFfcG9vbCA9IHBjaV9wb29sX2NyZWF0ZSgic2Vuc2UgcG9vbCIsIGlvYy0+cGRldiwgc3osIDQsCiAJICAgIDApOwogCWlmICghaW9jLT5zZW5zZV9kbWFfcG9vbCkgewpAQCAtMTkyOSw3ICsyMDg3LDcgQEAKIAl9CiAJZGluaXRwcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19JTkZPX0ZNVAogCSAgICAic2Vuc2UgcG9vbCgweCVwKTogZGVwdGgoJWQpLCBlbGVtZW50X3NpemUoJWQpLCBwb29sX3NpemUiCi0JICAgICIoJWQga0IpXG4iLCBpb2MtPm5hbWUsIGlvYy0+c2Vuc2UsIGlvYy0+cmVxdWVzdF9kZXB0aCwKKwkgICAgIiglZCBrQilcbiIsIGlvYy0+bmFtZSwgaW9jLT5zZW5zZSwgaW9jLT5zY3NpaW9fZGVwdGgsCiAJICAgIFNDU0lfU0VOU0VfQlVGRkVSU0laRSwgc3ovMTAyNCkpOwogCWRpbml0cHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfSU5GT19GTVQgInNlbnNlX2RtYSgweCVsbHgpXG4iLAogCSAgICBpb2MtPm5hbWUsICh1bnNpZ25lZCBsb25nIGxvbmcpaW9jLT5zZW5zZV9kbWEpKTsKQEAgLTIzMDQsNyArMjQ2Miw3IEBACiAJICAgICgocmVxdWVzdF9ieXRlcy80KTw8TVBJMl9ET09SQkVMTF9BRERfRFdPUkRTX1NISUZUKSksCiAJICAgICZpb2MtPmNoaXAtPkRvb3JiZWxsKTsKIAotCWlmICgoX2Jhc2Vfd2FpdF9mb3JfZG9vcmJlbGxfaW50KGlvYywgNSwgc2xlZXBfZmxhZykpKSB7CisJaWYgKChfYmFzZV93YWl0X2Zvcl9kb29yYmVsbF9pbnQoaW9jLCA1LCBOT19TTEVFUCkpKSB7CiAJCXByaW50ayhNUFQyU0FTX0VSUl9GTVQgImRvb3JiZWxsIGhhbmRzaGFrZSAiCiAJCSAgICJpbnQgZmFpbGVkIChsaW5lPSVkKVxuIiwgaW9jLT5uYW1lLCBfX0xJTkVfXyk7CiAJCXJldHVybiAtRUZBVUxUOwpAQCAtMjQ1NCw3ICsyNjEyLDggQEAKIAlpZiAobXBpX3JlcXVlc3QtPk9wZXJhdGlvbiA9PSBNUEkyX1NBU19PUF9QSFlfSEFSRF9SRVNFVCB8fAogCSAgICBtcGlfcmVxdWVzdC0+T3BlcmF0aW9uID09IE1QSTJfU0FTX09QX1BIWV9MSU5LX1JFU0VUKQogCQlpb2MtPmlvY19saW5rX3Jlc2V0X2luX3Byb2dyZXNzID0gMTsKLQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIG1waV9yZXF1ZXN0LT5WRl9JRCk7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkKTsKKwlpbml0X2NvbXBsZXRpb24oJmlvYy0+YmFzZV9jbWRzLmRvbmUpOwogCXRpbWVsZWZ0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZpb2MtPmJhc2VfY21kcy5kb25lLAogCSAgICBtc2Vjc190b19qaWZmaWVzKDEwMDAwKSk7CiAJaWYgKChtcGlfcmVxdWVzdC0+T3BlcmF0aW9uID09IE1QSTJfU0FTX09QX1BIWV9IQVJEX1JFU0VUIHx8CkBAIC0yNTU1LDcgKzI3MTQsOCBAQAogCXJlcXVlc3QgPSBtcHQyc2FzX2Jhc2VfZ2V0X21zZ19mcmFtZShpb2MsIHNtaWQpOwogCWlvYy0+YmFzZV9jbWRzLnNtaWQgPSBzbWlkOwogCW1lbWNweShyZXF1ZXN0LCBtcGlfcmVxdWVzdCwgc2l6ZW9mKE1waTJTZXBSZXBseV90KSk7Ci0JbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkLCBtcGlfcmVxdWVzdC0+VkZfSUQpOworCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCk7CisJaW5pdF9jb21wbGV0aW9uKCZpb2MtPmJhc2VfY21kcy5kb25lKTsKIAl0aW1lbGVmdCA9IHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmaW9jLT5iYXNlX2NtZHMuZG9uZSwKIAkgICAgbXNlY3NfdG9famlmZmllcygxMDAwMCkpOwogCWlmICghKGlvYy0+YmFzZV9jbWRzLnN0YXR1cyAmIE1QVDJfQ01EX0NPTVBMRVRFKSkgewpAQCAtMjcwMSwxMyArMjg2MSwxMiBAQAogLyoqCiAgKiBfYmFzZV9zZW5kX2lvY19pbml0IC0gc2VuZCBpb2NfaW5pdCB0byBmaXJtd2FyZQogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0Ci0gKiBAVkZfSUQ6IHZpcnR1YWwgZnVuY3Rpb24gaWQKICAqIEBzbGVlcF9mbGFnOiBDQU5fU0xFRVAgb3IgTk9fU0xFRVAKICAqCiAgKiBSZXR1cm5zIDAgZm9yIHN1Y2Nlc3MsIG5vbi16ZXJvIGZvciBmYWlsdXJlLgogICovCiBzdGF0aWMgaW50Ci1fYmFzZV9zZW5kX2lvY19pbml0KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTggVkZfSUQsIGludCBzbGVlcF9mbGFnKQorX2Jhc2Vfc2VuZF9pb2NfaW5pdChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIGludCBzbGVlcF9mbGFnKQogewogCU1waTJJT0NJbml0UmVxdWVzdF90IG1waV9yZXF1ZXN0OwogCU1waTJJT0NJbml0UmVwbHlfdCBtcGlfcmVwbHk7CkBAIC0yNzE5LDcgKzI4NzgsOCBAQAogCW1lbXNldCgmbXBpX3JlcXVlc3QsIDAsIHNpemVvZihNcGkySU9DSW5pdFJlcXVlc3RfdCkpOwogCW1waV9yZXF1ZXN0LkZ1bmN0aW9uID0gTVBJMl9GVU5DVElPTl9JT0NfSU5JVDsKIAltcGlfcmVxdWVzdC5XaG9Jbml0ID0gTVBJMl9XSE9JTklUX0hPU1RfRFJJVkVSOwotCW1waV9yZXF1ZXN0LlZGX0lEID0gVkZfSUQ7CisJbXBpX3JlcXVlc3QuVkZfSUQgPSAwOyAvKiBUT0RPICovCisJbXBpX3JlcXVlc3QuVlBfSUQgPSAwOwogCW1waV9yZXF1ZXN0Lk1zZ1ZlcnNpb24gPSBjcHVfdG9fbGUxNihNUEkyX1ZFUlNJT04pOwogCW1waV9yZXF1ZXN0LkhlYWRlclZlcnNpb24gPSBjcHVfdG9fbGUxNihNUEkyX0hFQURFUl9WRVJTSU9OKTsKIApAQCAtMjc5NSwxMyArMjk1NSwxMiBAQAogLyoqCiAgKiBfYmFzZV9zZW5kX3BvcnRfZW5hYmxlIC0gc2VuZCBwb3J0X2VuYWJsZShkaXNjb3Zlcnkgc3R1ZmYpIHRvIGZpcm13YXJlCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBWRl9JRDogdmlydHVhbCBmdW5jdGlvbiBpZAogICogQHNsZWVwX2ZsYWc6IENBTl9TTEVFUCBvciBOT19TTEVFUAogICoKICAqIFJldHVybnMgMCBmb3Igc3VjY2Vzcywgbm9uLXplcm8gZm9yIGZhaWx1cmUuCiAgKi8KIHN0YXRpYyBpbnQKLV9iYXNlX3NlbmRfcG9ydF9lbmFibGUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwgaW50IHNsZWVwX2ZsYWcpCitfYmFzZV9zZW5kX3BvcnRfZW5hYmxlKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgaW50IHNsZWVwX2ZsYWcpCiB7CiAJTXBpMlBvcnRFbmFibGVSZXF1ZXN0X3QgKm1waV9yZXF1ZXN0OwogCXUzMiBpb2Nfc3RhdGU7CkBAIC0yODI5LDkgKzI5ODgsMTEgQEAKIAlpb2MtPmJhc2VfY21kcy5zbWlkID0gc21pZDsKIAltZW1zZXQobXBpX3JlcXVlc3QsIDAsIHNpemVvZihNcGkyUG9ydEVuYWJsZVJlcXVlc3RfdCkpOwogCW1waV9yZXF1ZXN0LT5GdW5jdGlvbiA9IE1QSTJfRlVOQ1RJT05fUE9SVF9FTkFCTEU7Ci0JbXBpX3JlcXVlc3QtPlZGX0lEID0gVkZfSUQ7CisJbXBpX3JlcXVlc3QtPlZGX0lEID0gMDsgLyogVE9ETyAqLworCW1waV9yZXF1ZXN0LT5WUF9JRCA9IDA7CiAKLQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIFZGX0lEKTsKKwltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQpOworCWluaXRfY29tcGxldGlvbigmaW9jLT5iYXNlX2NtZHMuZG9uZSk7CiAJdGltZWxlZnQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmlvYy0+YmFzZV9jbWRzLmRvbmUsCiAJICAgIDMwMCpIWik7CiAJaWYgKCEoaW9jLT5iYXNlX2NtZHMuc3RhdHVzICYgTVBUMl9DTURfQ09NUExFVEUpKSB7CkBAIC0yODkyLDEzICszMDUzLDEyIEBACiAvKioKICAqIF9iYXNlX2V2ZW50X25vdGlmaWNhdGlvbiAtIHNlbmQgZXZlbnQgbm90aWZpY2F0aW9uCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBWRl9JRDogdmlydHVhbCBmdW5jdGlvbiBpZAogICogQHNsZWVwX2ZsYWc6IENBTl9TTEVFUCBvciBOT19TTEVFUAogICoKICAqIFJldHVybnMgMCBmb3Igc3VjY2Vzcywgbm9uLXplcm8gZm9yIGZhaWx1cmUuCiAgKi8KIHN0YXRpYyBpbnQKLV9iYXNlX2V2ZW50X25vdGlmaWNhdGlvbihzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IFZGX0lELCBpbnQgc2xlZXBfZmxhZykKK19iYXNlX2V2ZW50X25vdGlmaWNhdGlvbihzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIGludCBzbGVlcF9mbGFnKQogewogCU1waTJFdmVudE5vdGlmaWNhdGlvblJlcXVlc3RfdCAqbXBpX3JlcXVlc3Q7CiAJdW5zaWduZWQgbG9uZyB0aW1lbGVmdDsKQEAgLTI5MjYsMTEgKzMwODYsMTMgQEAKIAlpb2MtPmJhc2VfY21kcy5zbWlkID0gc21pZDsKIAltZW1zZXQobXBpX3JlcXVlc3QsIDAsIHNpemVvZihNcGkyRXZlbnROb3RpZmljYXRpb25SZXF1ZXN0X3QpKTsKIAltcGlfcmVxdWVzdC0+RnVuY3Rpb24gPSBNUEkyX0ZVTkNUSU9OX0VWRU5UX05PVElGSUNBVElPTjsKLQltcGlfcmVxdWVzdC0+VkZfSUQgPSBWRl9JRDsKKwltcGlfcmVxdWVzdC0+VkZfSUQgPSAwOyAvKiBUT0RPICovCisJbXBpX3JlcXVlc3QtPlZQX0lEID0gMDsKIAlmb3IgKGkgPSAwOyBpIDwgTVBJMl9FVkVOVF9OT1RJRllfRVZFTlRNQVNLX1dPUkRTOyBpKyspCiAJCW1waV9yZXF1ZXN0LT5FdmVudE1hc2tzW2ldID0KIAkJICAgIGxlMzJfdG9fY3B1KGlvYy0+ZXZlbnRfbWFza3NbaV0pOwotCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCwgVkZfSUQpOworCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCk7CisJaW5pdF9jb21wbGV0aW9uKCZpb2MtPmJhc2VfY21kcy5kb25lKTsKIAl0aW1lbGVmdCA9IHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmaW9jLT5iYXNlX2NtZHMuZG9uZSwgMzAqSFopOwogCWlmICghKGlvYy0+YmFzZV9jbWRzLnN0YXR1cyAmIE1QVDJfQ01EX0NPTVBMRVRFKSkgewogCQlwcmludGsoTVBUMlNBU19FUlJfRk1UICIlczogdGltZW91dFxuIiwKQEAgLTI5ODEsNyArMzE0Myw3IEBACiAJCXJldHVybjsKIAogCW11dGV4X2xvY2soJmlvYy0+YmFzZV9jbWRzLm11dGV4KTsKLQlfYmFzZV9ldmVudF9ub3RpZmljYXRpb24oaW9jLCAwLCBDQU5fU0xFRVApOworCV9iYXNlX2V2ZW50X25vdGlmaWNhdGlvbihpb2MsIENBTl9TTEVFUCk7CiAJbXV0ZXhfdW5sb2NrKCZpb2MtPmJhc2VfY21kcy5tdXRleCk7CiB9CiAKQEAgLTMwMDYsNyArMzE2OCw2IEBACiAKIAlkcnNwcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19ERUJVR19GTVQgImNsZWFyIGludGVycnVwdHNcbiIsCiAJICAgIGlvYy0+bmFtZSkpOwotCXdyaXRlbCgwLCAmaW9jLT5jaGlwLT5Ib3N0SW50ZXJydXB0U3RhdHVzKTsKIAogCWNvdW50ID0gMDsKIAlkbyB7CkBAIC0zMTYwLDMwICszMzIxLDYwIEBACiAvKioKICAqIF9iYXNlX21ha2VfaW9jX29wZXJhdGlvbmFsIC0gcHV0IGNvbnRyb2xsZXIgaW4gT1BFUkFUSU9OQUwgc3RhdGUKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAotICogQFZGX0lEOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCiAgKiBAc2xlZXBfZmxhZzogQ0FOX1NMRUVQIG9yIE5PX1NMRUVQCiAgKgogICogUmV0dXJucyAwIGZvciBzdWNjZXNzLCBub24temVybyBmb3IgZmFpbHVyZS4KICAqLwogc3RhdGljIGludAotX2Jhc2VfbWFrZV9pb2Nfb3BlcmF0aW9uYWwoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwKLSAgICBpbnQgc2xlZXBfZmxhZykKK19iYXNlX21ha2VfaW9jX29wZXJhdGlvbmFsKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgaW50IHNsZWVwX2ZsYWcpCiB7CiAJaW50IHIsIGk7CiAJdW5zaWduZWQgbG9uZwlmbGFnczsKIAl1MzIgcmVwbHlfYWRkcmVzczsKKwl1MTYgc21pZDsKKwlzdHJ1Y3QgX3RyX2xpc3QgKmRlbGF5ZWRfdHIsICpkZWxheWVkX3RyX25leHQ7CiAKIAlkaW5pdHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0RFQlVHX0ZNVCAiJXNcbiIsIGlvYy0+bmFtZSwKIAkgICAgX19mdW5jX18pKTsKIAorCS8qIGNsZWFuIHRoZSBkZWxheWVkIHRhcmdldCByZXNldCBsaXN0ICovCisJbGlzdF9mb3JfZWFjaF9lbnRyeV9zYWZlKGRlbGF5ZWRfdHIsIGRlbGF5ZWRfdHJfbmV4dCwKKwkgICAgJmlvYy0+ZGVsYXllZF90cl9saXN0LCBsaXN0KSB7CisJCWxpc3RfZGVsKCZkZWxheWVkX3RyLT5saXN0KTsKKwkJa2ZyZWUoZGVsYXllZF90cik7CisJfQorCiAJLyogaW5pdGlhbGl6ZSB0aGUgc2NzaSBsb29rdXAgZnJlZSBsaXN0ICovCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOwogCUlOSVRfTElTVF9IRUFEKCZpb2MtPmZyZWVfbGlzdCk7Ci0JZm9yIChpID0gMDsgaSA8IGlvYy0+cmVxdWVzdF9kZXB0aDsgaSsrKSB7CisJc21pZCA9IDE7CisJZm9yIChpID0gMDsgaSA8IGlvYy0+c2NzaWlvX2RlcHRoOyBpKyssIHNtaWQrKykgewogCQlpb2MtPnNjc2lfbG9va3VwW2ldLmNiX2lkeCA9IDB4RkY7CisJCWlvYy0+c2NzaV9sb29rdXBbaV0uc21pZCA9IHNtaWQ7CisJCWlvYy0+c2NzaV9sb29rdXBbaV0uc2NtZCA9IE5VTEw7CiAJCWxpc3RfYWRkX3RhaWwoJmlvYy0+c2NzaV9sb29rdXBbaV0udHJhY2tlcl9saXN0LAogCQkgICAgJmlvYy0+ZnJlZV9saXN0KTsKIAl9CisKKwkvKiBoaS1wcmlvcml0eSBxdWV1ZSAqLworCUlOSVRfTElTVF9IRUFEKCZpb2MtPmhwcl9mcmVlX2xpc3QpOworCXNtaWQgPSBpb2MtPmhpX3ByaW9yaXR5X3NtaWQ7CisJZm9yIChpID0gMDsgaSA8IGlvYy0+aGlfcHJpb3JpdHlfZGVwdGg7IGkrKywgc21pZCsrKSB7CisJCWlvYy0+aHByX2xvb2t1cFtpXS5jYl9pZHggPSAweEZGOworCQlpb2MtPmhwcl9sb29rdXBbaV0uc21pZCA9IHNtaWQ7CisJCWxpc3RfYWRkX3RhaWwoJmlvYy0+aHByX2xvb2t1cFtpXS50cmFja2VyX2xpc3QsCisJCSAgICAmaW9jLT5ocHJfZnJlZV9saXN0KTsKKwl9CisKKwkvKiBpbnRlcm5hbCBxdWV1ZSAqLworCUlOSVRfTElTVF9IRUFEKCZpb2MtPmludGVybmFsX2ZyZWVfbGlzdCk7CisJc21pZCA9IGlvYy0+aW50ZXJuYWxfc21pZDsKKwlmb3IgKGkgPSAwOyBpIDwgaW9jLT5pbnRlcm5hbF9kZXB0aDsgaSsrLCBzbWlkKyspIHsKKwkJaW9jLT5pbnRlcm5hbF9sb29rdXBbaV0uY2JfaWR4ID0gMHhGRjsKKwkJaW9jLT5pbnRlcm5hbF9sb29rdXBbaV0uc21pZCA9IHNtaWQ7CisJCWxpc3RfYWRkX3RhaWwoJmlvYy0+aW50ZXJuYWxfbG9va3VwW2ldLnRyYWNrZXJfbGlzdCwKKwkJICAgICZpb2MtPmludGVybmFsX2ZyZWVfbGlzdCk7CisJfQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOwogCiAJLyogaW5pdGlhbGl6ZSBSZXBseSBGcmVlIFF1ZXVlICovCkBAIC0zMTk2LDcgKzMzODcsNyBAQAogCWZvciAoaSA9IDA7IGkgPCBpb2MtPnJlcGx5X3Bvc3RfcXVldWVfZGVwdGg7IGkrKykKIAkJaW9jLT5yZXBseV9wb3N0X2ZyZWVbaV0uV29yZHMgPSBVTExPTkdfTUFYOwogCi0JciA9IF9iYXNlX3NlbmRfaW9jX2luaXQoaW9jLCBWRl9JRCwgc2xlZXBfZmxhZyk7CisJciA9IF9iYXNlX3NlbmRfaW9jX2luaXQoaW9jLCBzbGVlcF9mbGFnKTsKIAlpZiAocikKIAkJcmV0dXJuIHI7CiAKQEAgLTMyMDcsMTQgKzMzOTgsMTQgQEAKIAl3cml0ZWwoMCwgJmlvYy0+Y2hpcC0+UmVwbHlQb3N0SG9zdEluZGV4KTsKIAogCV9iYXNlX3VubWFza19pbnRlcnJ1cHRzKGlvYyk7Ci0JciA9IF9iYXNlX2V2ZW50X25vdGlmaWNhdGlvbihpb2MsIFZGX0lELCBzbGVlcF9mbGFnKTsKKwlyID0gX2Jhc2VfZXZlbnRfbm90aWZpY2F0aW9uKGlvYywgc2xlZXBfZmxhZyk7CiAJaWYgKHIpCiAJCXJldHVybiByOwogCiAJaWYgKHNsZWVwX2ZsYWcgPT0gQ0FOX1NMRUVQKQogCQlfYmFzZV9zdGF0aWNfY29uZmlnX3BhZ2VzKGlvYyk7CiAKLQlyID0gX2Jhc2Vfc2VuZF9wb3J0X2VuYWJsZShpb2MsIFZGX0lELCBzbGVlcF9mbGFnKTsKKwlyID0gX2Jhc2Vfc2VuZF9wb3J0X2VuYWJsZShpb2MsIHNsZWVwX2ZsYWcpOwogCWlmIChyKQogCQlyZXR1cm4gcjsKIApAQCAtMzI3OCw2ICszNDY5LDE3IEBACiAJaWYgKHIpCiAJCWdvdG8gb3V0X2ZyZWVfcmVzb3VyY2VzOwogCisJaW9jLT5wZmFjdHMgPSBrY2FsbG9jKGlvYy0+ZmFjdHMuTnVtYmVyT2ZQb3J0cywKKwkgICAgc2l6ZW9mKE1waTJQb3J0RmFjdHNSZXBseV90KSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFpb2MtPnBmYWN0cykKKwkJZ290byBvdXRfZnJlZV9yZXNvdXJjZXM7CisKKwlmb3IgKGkgPSAwIDsgaSA8IGlvYy0+ZmFjdHMuTnVtYmVyT2ZQb3J0czsgaSsrKSB7CisJCXIgPSBfYmFzZV9nZXRfcG9ydF9mYWN0cyhpb2MsIGksIENBTl9TTEVFUCk7CisJCWlmIChyKQorCQkJZ290byBvdXRfZnJlZV9yZXNvdXJjZXM7CisJfQorCiAJciA9IF9iYXNlX2FsbG9jYXRlX21lbW9yeV9wb29scyhpb2MsIENBTl9TTEVFUCk7CiAJaWYgKHIpCiAJCWdvdG8gb3V0X2ZyZWVfcmVzb3VyY2VzOwpAQCAtMzI4Niw3ICszNDg4LDYgQEAKIAogCS8qIGJhc2UgaW50ZXJuYWwgY29tbWFuZCBiaXRzICovCiAJbXV0ZXhfaW5pdCgmaW9jLT5iYXNlX2NtZHMubXV0ZXgpOwotCWluaXRfY29tcGxldGlvbigmaW9jLT5iYXNlX2NtZHMuZG9uZSk7CiAJaW9jLT5iYXNlX2NtZHMucmVwbHkgPSBremFsbG9jKGlvYy0+cmVwbHlfc3osIEdGUF9LRVJORUwpOwogCWlvYy0+YmFzZV9jbWRzLnN0YXR1cyA9IE1QVDJfQ01EX05PVF9VU0VEOwogCkBAIC0zMjk0LDcgKzM0OTUsNiBAQAogCWlvYy0+dHJhbnNwb3J0X2NtZHMucmVwbHkgPSBremFsbG9jKGlvYy0+cmVwbHlfc3osIEdGUF9LRVJORUwpOwogCWlvYy0+dHJhbnNwb3J0X2NtZHMuc3RhdHVzID0gTVBUMl9DTURfTk9UX1VTRUQ7CiAJbXV0ZXhfaW5pdCgmaW9jLT50cmFuc3BvcnRfY21kcy5tdXRleCk7Ci0JaW5pdF9jb21wbGV0aW9uKCZpb2MtPnRyYW5zcG9ydF9jbWRzLmRvbmUpOwogCiAJLyogdGFzayBtYW5hZ2VtZW50IGludGVybmFsIGNvbW1hbmQgYml0cyAqLwogCWlvYy0+dG1fY21kcy5yZXBseSA9IGt6YWxsb2MoaW9jLT5yZXBseV9zeiwgR0ZQX0tFUk5FTCk7CkBAIC0zMzEwLDcgKzM1MTAsNiBAQAogCWlvYy0+Y3RsX2NtZHMucmVwbHkgPSBremFsbG9jKGlvYy0+cmVwbHlfc3osIEdGUF9LRVJORUwpOwogCWlvYy0+Y3RsX2NtZHMuc3RhdHVzID0gTVBUMl9DTURfTk9UX1VTRUQ7CiAJbXV0ZXhfaW5pdCgmaW9jLT5jdGxfY21kcy5tdXRleCk7Ci0JaW5pdF9jb21wbGV0aW9uKCZpb2MtPmN0bF9jbWRzLmRvbmUpOwogCiAJZm9yIChpID0gMDsgaSA8IE1QSTJfRVZFTlRfTk9USUZZX0VWRU5UTUFTS19XT1JEUzsgaSsrKQogCQlpb2MtPmV2ZW50X21hc2tzW2ldID0gLTE7CkBAIC0zMzI3LDE4ICszNTI2LDcgQEAKIAlfYmFzZV91bm1hc2tfZXZlbnRzKGlvYywgTVBJMl9FVkVOVF9JUl9PUEVSQVRJT05fU1RBVFVTKTsKIAlfYmFzZV91bm1hc2tfZXZlbnRzKGlvYywgTVBJMl9FVkVOVF9UQVNLX1NFVF9GVUxMKTsKIAlfYmFzZV91bm1hc2tfZXZlbnRzKGlvYywgTVBJMl9FVkVOVF9MT0dfRU5UUllfQURERUQpOwotCi0JaW9jLT5wZmFjdHMgPSBrY2FsbG9jKGlvYy0+ZmFjdHMuTnVtYmVyT2ZQb3J0cywKLQkgICAgc2l6ZW9mKE1waTJQb3J0RmFjdHNSZXBseV90KSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFpb2MtPnBmYWN0cykKLQkJZ290byBvdXRfZnJlZV9yZXNvdXJjZXM7Ci0KLQlmb3IgKGkgPSAwIDsgaSA8IGlvYy0+ZmFjdHMuTnVtYmVyT2ZQb3J0czsgaSsrKSB7Ci0JCXIgPSBfYmFzZV9nZXRfcG9ydF9mYWN0cyhpb2MsIGksIENBTl9TTEVFUCk7Ci0JCWlmIChyKQotCQkJZ290byBvdXRfZnJlZV9yZXNvdXJjZXM7Ci0JfQotCXIgPSBfYmFzZV9tYWtlX2lvY19vcGVyYXRpb25hbChpb2MsIDAsIENBTl9TTEVFUCk7CisJciA9IF9iYXNlX21ha2VfaW9jX29wZXJhdGlvbmFsKGlvYywgQ0FOX1NMRUVQKTsKIAlpZiAocikKIAkJZ290byBvdXRfZnJlZV9yZXNvdXJjZXM7CiAKQEAgLTM0NjYsNyArMzY1NCw3IEBACiAKIAkvKiBwZW5kaW5nIGNvbW1hbmQgY291bnQgKi8KIAlzcGluX2xvY2tfaXJxc2F2ZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7Ci0JZm9yIChpID0gMDsgaSA8IGlvYy0+cmVxdWVzdF9kZXB0aDsgaSsrKQorCWZvciAoaSA9IDA7IGkgPCBpb2MtPnNjc2lpb19kZXB0aDsgaSsrKQogCQlpZiAoaW9jLT5zY3NpX2xvb2t1cFtpXS5jYl9pZHggIT0gMHhGRikKIAkJCWlvYy0+cGVuZGluZ19pb19jb3VudCsrOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOwpAQCAtMzQ5MCw3ICszNjc4LDcgQEAKIG1wdDJzYXNfYmFzZV9oYXJkX3Jlc2V0X2hhbmRsZXIoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCBpbnQgc2xlZXBfZmxhZywKICAgICBlbnVtIHJlc2V0X3R5cGUgdHlwZSkKIHsKLQlpbnQgciwgaTsKKwlpbnQgcjsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZHRtcHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfREVCVUdfRk1UICIlczogZW50ZXJcbiIsIGlvYy0+bmFtZSwKQEAgLTM1MTMsOSArMzcwMSw3IEBACiAJaWYgKHIpCiAJCWdvdG8gb3V0OwogCV9iYXNlX3Jlc2V0X2hhbmRsZXIoaW9jLCBNUFQyX0lPQ19BRlRFUl9SRVNFVCk7Ci0JZm9yIChpID0gMCA7IGkgPCBpb2MtPmZhY3RzLk51bWJlck9mUG9ydHM7IGkrKykKLQkJciA9IF9iYXNlX21ha2VfaW9jX29wZXJhdGlvbmFsKGlvYywgaW9jLT5wZmFjdHNbaV0uVkZfSUQsCi0JCSAgICBzbGVlcF9mbGFnKTsKKwlyID0gX2Jhc2VfbWFrZV9pb2Nfb3BlcmF0aW9uYWwoaW9jLCBzbGVlcF9mbGFnKTsKIAlpZiAoIXIpCiAJCV9iYXNlX3Jlc2V0X2hhbmRsZXIoaW9jLCBNUFQyX0lPQ19ET05FX1JFU0VUKTsKICBvdXQ6CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2Jhc2UuaCBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfYmFzZS5oCmluZGV4IDJmYWFiMWUuLjBjZjZiYzIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfYmFzZS5oCisrKyBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfYmFzZS5oCkBAIC0zLDcgKzMsNyBAQAogICogZm9yIGFjY2VzcyB0byBNUFQgKE1lc3NhZ2UgUGFzc2luZyBUZWNobm9sb2d5KSBmaXJtd2FyZS4KICAqCiAgKiBUaGlzIGNvZGUgaXMgYmFzZWQgb24gZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0Ml9iYXNlLmgKLSAqIENvcHlyaWdodCAoQykgMjAwNy0yMDA4ICBMU0kgQ29ycG9yYXRpb24KKyAqIENvcHlyaWdodCAoQykgMjAwNy0yMDA5ICBMU0kgQ29ycG9yYXRpb24KICAqICAobWFpbHRvOkRMLU1QVEZ1c2lvbkxpbnV4QGxzaS5jb20pCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtNjksMTAgKzY5LDEwIEBACiAjZGVmaW5lIE1QVDJTQVNfRFJJVkVSX05BTUUJCSJtcHQyc2FzIgogI2RlZmluZSBNUFQyU0FTX0FVVEhPUgkiTFNJIENvcnBvcmF0aW9uIDxETC1NUFRGdXNpb25MaW51eEBsc2kuY29tPiIKICNkZWZpbmUgTVBUMlNBU19ERVNDUklQVElPTgkiTFNJIE1QVCBGdXNpb24gU0FTIDIuMCBEZXZpY2UgRHJpdmVyIgotI2RlZmluZSBNUFQyU0FTX0RSSVZFUl9WRVJTSU9OCQkiMDEuMTAwLjA2LjAwIgotI2RlZmluZSBNUFQyU0FTX01BSk9SX1ZFUlNJT04JCTAxCisjZGVmaW5lIE1QVDJTQVNfRFJJVkVSX1ZFUlNJT04JCSIwMi4xMDAuMDMuMDAiCisjZGVmaW5lIE1QVDJTQVNfTUFKT1JfVkVSU0lPTgkJMDIKICNkZWZpbmUgTVBUMlNBU19NSU5PUl9WRVJTSU9OCQkxMDAKLSNkZWZpbmUgTVBUMlNBU19CVUlMRF9WRVJTSU9OCQkwNgorI2RlZmluZSBNUFQyU0FTX0JVSUxEX1ZFUlNJT04JCTAzCiAjZGVmaW5lIE1QVDJTQVNfUkVMRUFTRV9WRVJTSU9OCQkwMAogCiAvKgpAQCAtMjY0LDYgKzI2NCwxMyBAQAogICogU0FTIFRvcG9sb2d5IFN0cnVjdHVyZXMKICAqLwogCisjZGVmaW5lIE1QVFNBU19TVEFURV9UUl9TRU5ECQkweDAwMDEKKyNkZWZpbmUgTVBUU0FTX1NUQVRFX1RSX0NPTVBMRVRFCTB4MDAwMgorI2RlZmluZSBNUFRTQVNfU1RBVEVfQ05UUkxfU0VORAkJMHgwMDA0CisjZGVmaW5lIE1QVFNBU19TVEFURV9DTlRSTF9DT01QTEVURQkweDAwMDgKKworI2RlZmluZSBNUFQyU0FTX1JFUV9TQVNfQ05UUkwJCTB4MDAxMAorCiAvKioKICAqIHN0cnVjdCBfc2FzX2RldmljZSAtIGF0dGFjaGVkIGRldmljZSBpbmZvcm1hdGlvbgogICogQGxpc3Q6IHNhcyBkZXZpY2UgbGlzdApAQCAtMzAwLDYgKzMwNyw3IEBACiAJdTE2CXNsb3Q7CiAJdTgJaGlkZGVuX3JhaWRfY29tcG9uZW50OwogCXU4CXJlc3BvbmRpbmc7CisJdTE2CXN0YXRlOwogfTsKIAogLyoqCkBAIC00MzYsNiArNDQ0LDE3IEBACiAJc3RydWN0IGxpc3RfaGVhZCB0cmFja2VyX2xpc3Q7CiB9OwogCisvKioKKyAqIHN0cnVjdCBfdHJfbGlzdCAtIHRhcmdldCByZXNldCBsaXN0CisgKiBAaGFuZGxlOiBkZXZpY2UgaGFuZGxlCisgKiBAc3RhdGU6IHN0YXRlIG1hY2hpbmUKKyAqLworc3RydWN0IF90cl9saXN0IHsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3Q7CisJdTE2CWhhbmRsZTsKKwl1MTYJc3RhdGU7Cit9OworCiB0eXBlZGVmIHZvaWQgKCpNUFRfQUREX1NHRSkodm9pZCAqcGFkZHIsIHUzMiBmbGFnc19sZW5ndGgsIGRtYV9hZGRyX3QgZG1hX2FkZHIpOwogCiAvKioKQEAgLTUxMCw4ICs1MjksOSBAQAogICogQGNvbmZpZ19wYWdlX3N6OiBjb25maWcgcGFnZSBzaXplCiAgKiBAY29uZmlnX3BhZ2U6IHJlc2VydmUgbWVtb3J5IGZvciBjb25maWcgcGFnZSBwYXlsb2FkCiAgKiBAY29uZmlnX3BhZ2VfZG1hOgorICogQGhiYV9xdWV1ZV9kZXB0aDogaGJhIHJlcXVlc3QgcXVldWUgZGVwdGgKICAqIEBzZ2Vfc2l6ZTogc2cgZWxlbWVudCBzaXplIGZvciBlaXRoZXIgMzIvNjQgYml0Ci0gKiBAcmVxdWVzdF9kZXB0aDogaGJhIHJlcXVlc3QgcXVldWUgZGVwdGgKKyAqIEBzY3NpaW9fZGVwdGg6IFNDU0lfSU8gcXVldWUgZGVwdGgKICAqIEByZXF1ZXN0X3N6OiBwZXIgcmVxdWVzdCBmcmFtZSBzaXplCiAgKiBAcmVxdWVzdDogcG9vbCBvZiByZXF1ZXN0IGZyYW1lcwogICogQHJlcXVlc3RfZG1hOgpAQCAtNTI4LDYgKzU0OCwxOCBAQAogICogQGNoYWluc19uZWVkZWRfcGVyX2lvOiBtYXggY2hhaW5zIHBlciBpbwogICogQGNoYWluX29mZnNldF92YWx1ZV9mb3JfbWFpbl9tZXNzYWdlOiBsb2NhdGlvbiAxc3Qgc2cgaW4gbWFpbgogICogQGNoYWluX2RlcHRoOiB0b3RhbCBjaGFpbnMgYWxsb2NhdGVkCisgKiBAaGlfcHJpb3JpdHlfc21pZDoKKyAqIEBoaV9wcmlvcml0eToKKyAqIEBoaV9wcmlvcml0eV9kbWE6CisgKiBAaGlfcHJpb3JpdHlfZGVwdGg6CisgKiBAaHByX2xvb2t1cDoKKyAqIEBocHJfZnJlZV9saXN0OgorICogQGludGVybmFsX3NtaWQ6CisgKiBAaW50ZXJuYWw6CisgKiBAaW50ZXJuYWxfZG1hOgorICogQGludGVybmFsX2RlcHRoOgorICogQGludGVybmFsX2xvb2t1cDoKKyAqIEBpbnRlcm5hbF9mcmVlX2xpc3Q6CiAgKiBAc2Vuc2U6IHBvb2wgb2Ygc2Vuc2UKICAqIEBzZW5zZV9kbWE6CiAgKiBAc2Vuc2VfZG1hX3Bvb2w6CkBAIC01OTcsNiArNjI5LDggQEAKIAl1OAkJY3RsX2NiX2lkeDsKIAl1OAkJYmFzZV9jYl9pZHg7CiAJdTgJCWNvbmZpZ19jYl9pZHg7CisJdTgJCXRtX3RyX2NiX2lkeDsKKwl1OAkJdG1fc2FzX2NvbnRyb2xfY2JfaWR4OwogCXN0cnVjdCBfaW50ZXJuYWxfY21kIGJhc2VfY21kczsKIAlzdHJ1Y3QgX2ludGVybmFsX2NtZCB0cmFuc3BvcnRfY21kczsKIAlzdHJ1Y3QgX2ludGVybmFsX2NtZCB0bV9jbWRzOwpAQCAtNjQzLDkgKzY3NywxMCBAQAogCXZvaWQgCQkqY29uZmlnX3BhZ2U7CiAJZG1hX2FkZHJfdAljb25maWdfcGFnZV9kbWE7CiAKLQkvKiByZXF1ZXN0ICovCisJLyogc2NzaWlvIHJlcXVlc3QgKi8KKwl1MTYJCWhiYV9xdWV1ZV9kZXB0aDsKIAl1MTYJCXNnZV9zaXplOwotCXUxNiAJCXJlcXVlc3RfZGVwdGg7CisJdTE2IAkJc2NzaWlvX2RlcHRoOwogCXUxNgkJcmVxdWVzdF9zejsKIAl1OAkJKnJlcXVlc3Q7CiAJZG1hX2FkZHJfdAlyZXF1ZXN0X2RtYTsKQEAgLTY2NSw2ICs3MDAsMjIgQEAKIAl1MTYJCWNoYWluX29mZnNldF92YWx1ZV9mb3JfbWFpbl9tZXNzYWdlOwogCXUxNgkJY2hhaW5fZGVwdGg7CiAKKwkvKiBoaS1wcmlvcml0eSBxdWV1ZSAqLworCXUxNgkJaGlfcHJpb3JpdHlfc21pZDsKKwl1OAkJKmhpX3ByaW9yaXR5OworCWRtYV9hZGRyX3QJaGlfcHJpb3JpdHlfZG1hOworCXUxNgkJaGlfcHJpb3JpdHlfZGVwdGg7CisJc3RydWN0IHJlcXVlc3RfdHJhY2tlciAqaHByX2xvb2t1cDsKKwlzdHJ1Y3QgbGlzdF9oZWFkIGhwcl9mcmVlX2xpc3Q7CisKKwkvKiBpbnRlcm5hbCBxdWV1ZSAqLworCXUxNgkJaW50ZXJuYWxfc21pZDsKKwl1OAkJKmludGVybmFsOworCWRtYV9hZGRyX3QJaW50ZXJuYWxfZG1hOworCXUxNgkJaW50ZXJuYWxfZGVwdGg7CisJc3RydWN0IHJlcXVlc3RfdHJhY2tlciAqaW50ZXJuYWxfbG9va3VwOworCXN0cnVjdCBsaXN0X2hlYWQgaW50ZXJuYWxfZnJlZV9saXN0OworCiAJLyogc2Vuc2UgKi8KIAl1OAkJKnNlbnNlOwogCWRtYV9hZGRyX3QJc2Vuc2VfZG1hOwpAQCAtNjkwLDYgKzc0MSw4IEBACiAJc3RydWN0IGRtYV9wb29sICpyZXBseV9wb3N0X2ZyZWVfZG1hX3Bvb2w7CiAJdTMyCQlyZXBseV9wb3N0X2hvc3RfaW5kZXg7CiAKKwlzdHJ1Y3QgbGlzdF9oZWFkIGRlbGF5ZWRfdHJfbGlzdDsKKwogCS8qIGRpYWcgYnVmZmVyIHN1cHBvcnQgKi8KIAl1OAkJKmRpYWdfYnVmZmVyW01QSTJfRElBR19CVUZfVFlQRV9DT1VOVF07CiAJdTMyCQlkaWFnX2J1ZmZlcl9zeltNUEkyX0RJQUdfQlVGX1RZUEVfQ09VTlRdOwpAQCAtNzAxLDcgKzc1NCw3IEBACiAJdTMyCQlkaWFnbm9zdGljX2ZsYWdzW01QSTJfRElBR19CVUZfVFlQRV9DT1VOVF07CiB9OwogCi10eXBlZGVmIHZvaWQgKCpNUFRfQ0FMTEJBQ0spKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IFZGX0lELAordHlwZWRlZiB1OCAoKk1QVF9DQUxMQkFDSykoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggbXNpeF9pbmRleCwKICAgICB1MzIgcmVwbHkpOwogCiAKQEAgLTcyMCwyMiArNzczLDI4IEBACiB2b2lkICptcHQyc2FzX2Jhc2VfZ2V0X21zZ19mcmFtZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkKTsKIHZvaWQgKm1wdDJzYXNfYmFzZV9nZXRfc2Vuc2VfYnVmZmVyKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQpOwogdm9pZCBtcHQyc2FzX2Jhc2VfYnVpbGRfemVyb19sZW5fc2dlKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdm9pZCAqcGFkZHIpOwotZG1hX2FkZHJfdCBtcHQyc2FzX2Jhc2VfZ2V0X21zZ19mcmFtZV9kbWEoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCk7Ci1kbWFfYWRkcl90IG1wdDJzYXNfYmFzZV9nZXRfc2Vuc2VfYnVmZmVyX2RtYShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkKTsKK2RtYV9hZGRyX3QgbXB0MnNhc19iYXNlX2dldF9zZW5zZV9idWZmZXJfZG1hKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywKKyAgICB1MTYgc21pZCk7CisKKy8qIGhpLXByaW9yaXR5IHF1ZXVlICovCit1MTYgbXB0MnNhc19iYXNlX2dldF9zbWlkX2hwcihzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IGNiX2lkeCk7Cit1MTYgbXB0MnNhc19iYXNlX2dldF9zbWlkX3Njc2lpbyhzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IGNiX2lkeCwKKyAgICBzdHJ1Y3Qgc2NzaV9jbW5kICpzY21kKTsKIAogdTE2IG1wdDJzYXNfYmFzZV9nZXRfc21pZChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IGNiX2lkeCk7CiB2b2lkIG1wdDJzYXNfYmFzZV9mcmVlX3NtaWQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCk7Ci12b2lkIG1wdDJzYXNfYmFzZV9wdXRfc21pZF9zY3NpX2lvKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IHZmX2lkLAordm9pZCBtcHQyc2FzX2Jhc2VfcHV0X3NtaWRfc2NzaV9pbyhzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLAogICAgIHUxNiBoYW5kbGUpOwotdm9pZCBtcHQyc2FzX2Jhc2VfcHV0X3NtaWRfaGlfcHJpb3JpdHkoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggdmZfaWQpOwordm9pZCBtcHQyc2FzX2Jhc2VfcHV0X3NtaWRfaGlfcHJpb3JpdHkoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCk7CiB2b2lkIG1wdDJzYXNfYmFzZV9wdXRfc21pZF90YXJnZXRfYXNzaXN0KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsCi0gICAgdTggdmZfaWQsIHUxNiBpb19pbmRleCk7Ci12b2lkIG1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IHZmX2lkKTsKKyAgICB1MTYgaW9faW5kZXgpOwordm9pZCBtcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkKTsKIHZvaWQgbXB0MnNhc19iYXNlX2luaXRpYWxpemVfY2FsbGJhY2tfaGFuZGxlcih2b2lkKTsKIHU4IG1wdDJzYXNfYmFzZV9yZWdpc3Rlcl9jYWxsYmFja19oYW5kbGVyKE1QVF9DQUxMQkFDSyBjYl9mdW5jKTsKIHZvaWQgbXB0MnNhc19iYXNlX3JlbGVhc2VfY2FsbGJhY2tfaGFuZGxlcih1OCBjYl9pZHgpOwogCi12b2lkIG1wdDJzYXNfYmFzZV9kb25lKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IFZGX0lELCB1MzIgcmVwbHkpOwordTggbXB0MnNhc19iYXNlX2RvbmUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggbXNpeF9pbmRleCwKKyAgICB1MzIgcmVwbHkpOwogdm9pZCAqbXB0MnNhc19iYXNlX2dldF9yZXBseV92aXJ0X2FkZHIoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MzIgcGh5c19hZGRyKTsKIAogdTMyIG1wdDJzYXNfYmFzZV9nZXRfaW9jc3RhdGUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCBpbnQgY29va2VkKTsKQEAgLTc0OSw2ICs4MDgsOCBAQAogdm9pZCBtcHQyc2FzX2Jhc2VfdmFsaWRhdGVfZXZlbnRfdHlwZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUzMiAqZXZlbnRfdHlwZSk7CiAKIC8qIHNjc2loIHNoYXJlZCBBUEkgKi8KK3U4IG1wdDJzYXNfc2NzaWhfZXZlbnRfY2FsbGJhY2soc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBtc2l4X2luZGV4LAorICAgIHUzMiByZXBseSk7CiB2b2lkIG1wdDJzYXNfc2NzaWhfaXNzdWVfdG0oc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgaGFuZGxlLCB1aW50IGx1biwKICAgICB1OCB0eXBlLCB1MTYgc21pZF90YXNrLCB1bG9uZyB0aW1lb3V0KTsKIHZvaWQgbXB0MnNhc19zY3NpaF9zZXRfdG1fZmxhZyhzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBoYW5kbGUpOwpAQCAtNzYwLDExICs4MjEsMTEgQEAKIHN0cnVjdCBfc2FzX2RldmljZSAqbXB0MnNhc19zY3NpaF9zYXNfZGV2aWNlX2ZpbmRfYnlfc2FzX2FkZHJlc3MoCiAgICAgc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1NjQgc2FzX2FkZHJlc3MpOwogCi12b2lkIG1wdDJzYXNfc2NzaWhfZXZlbnRfY2FsbGJhY2soc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwgdTMyIHJlcGx5KTsKIHZvaWQgbXB0MnNhc19zY3NpaF9yZXNldF9oYW5kbGVyKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgaW50IHJlc2V0X3BoYXNlKTsKIAogLyogY29uZmlnIHNoYXJlZCBBUEkgKi8KLXZvaWQgbXB0MnNhc19jb25maWdfZG9uZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBWRl9JRCwgdTMyIHJlcGx5KTsKK3U4IG1wdDJzYXNfY29uZmlnX2RvbmUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggbXNpeF9pbmRleCwKKyAgICB1MzIgcmVwbHkpOwogaW50IG1wdDJzYXNfY29uZmlnX2dldF9udW1iZXJfaGJhX3BoeXMoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCAqbnVtX3BoeXMpOwogaW50IG1wdDJzYXNfY29uZmlnX2dldF9tYW51ZmFjdHVyaW5nX3BnMChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsCiAgICAgTXBpMkNvbmZpZ1JlcGx5X3QgKm1waV9yZXBseSwgTXBpMk1hbnVmYWN0dXJpbmdQYWdlMF90ICpjb25maWdfcGFnZSk7CkBAIC04MTcsMTQgKzg3OCwxNyBAQAogZXh0ZXJuIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICptcHQyc2FzX2Rldl9hdHRyc1tdOwogdm9pZCBtcHQyc2FzX2N0bF9pbml0KHZvaWQpOwogdm9pZCBtcHQyc2FzX2N0bF9leGl0KHZvaWQpOwotdm9pZCBtcHQyc2FzX2N0bF9kb25lKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IFZGX0lELCB1MzIgcmVwbHkpOwordTggbXB0MnNhc19jdGxfZG9uZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBtc2l4X2luZGV4LAorICAgIHUzMiByZXBseSk7CiB2b2lkIG1wdDJzYXNfY3RsX3Jlc2V0X2hhbmRsZXIoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCBpbnQgcmVzZXRfcGhhc2UpOwotdm9pZCBtcHQyc2FzX2N0bF9ldmVudF9jYWxsYmFjayhzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IFZGX0lELCB1MzIgcmVwbHkpOwordTggbXB0MnNhc19jdGxfZXZlbnRfY2FsbGJhY2soc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBtc2l4X2luZGV4LAorICAgIHUzMiByZXBseSk7CiB2b2lkIG1wdDJzYXNfY3RsX2FkZF90b19ldmVudF9sb2coc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLAogICAgIE1waTJFdmVudE5vdGlmaWNhdGlvblJlcGx5X3QgKm1waV9yZXBseSk7CiAKIC8qIHRyYW5zcG9ydCBzaGFyZWQgQVBJICovCi12b2lkIG1wdDJzYXNfdHJhbnNwb3J0X2RvbmUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggVkZfSUQsIHUzMiByZXBseSk7Cit1OCBtcHQyc2FzX3RyYW5zcG9ydF9kb25lKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IG1zaXhfaW5kZXgsCisgICAgdTMyIHJlcGx5KTsKIHN0cnVjdCBfc2FzX3BvcnQgKm1wdDJzYXNfdHJhbnNwb3J0X3BvcnRfYWRkKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywKICAgICB1MTYgaGFuZGxlLCB1MTYgcGFyZW50X2hhbmRsZSk7CiB2b2lkIG1wdDJzYXNfdHJhbnNwb3J0X3BvcnRfcmVtb3ZlKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTY0IHNhc19hZGRyZXNzLApAQCAtODM4LDYgKzkwMiw4IEBACiBleHRlcm4gc3RydWN0IHNhc19mdW5jdGlvbl90ZW1wbGF0ZSBtcHQyc2FzX3RyYW5zcG9ydF9mdW5jdGlvbnM7CiBleHRlcm4gc3RydWN0IHNjc2lfdHJhbnNwb3J0X3RlbXBsYXRlICptcHQyc2FzX3RyYW5zcG9ydF90ZW1wbGF0ZTsKIGV4dGVybiBpbnQgc2NzaV9pbnRlcm5hbF9kZXZpY2VfYmxvY2soc3RydWN0IHNjc2lfZGV2aWNlICpzZGV2KTsKK2V4dGVybiB1OCBtcHQyc2FzX3N0bV96ZXJvX3NtaWRfaGFuZGxlcihzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsCisgICAgdTggbXNpeF9pbmRleCwgdTMyIHJlcGx5KTsKIGV4dGVybiBpbnQgc2NzaV9pbnRlcm5hbF9kZXZpY2VfdW5ibG9jayhzdHJ1Y3Qgc2NzaV9kZXZpY2UgKnNkZXYpOwogCiAjZW5kaWYgLyogTVBUMlNBU19CQVNFX0hfSU5DTFVERUQgKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfY29uZmlnLmMgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2NvbmZpZy5jCmluZGV4IGFiOGM1NjAuLjU5NGEzODkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfY29uZmlnLmMKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19jb25maWcuYwpAQCAtMiw3ICsyLDcgQEAKICAqIFRoaXMgbW9kdWxlIHByb3ZpZGVzIGNvbW1vbiBBUEkgZm9yIGFjY2Vzc2luZyBmaXJtd2FyZSBjb25maWd1cmF0aW9uIHBhZ2VzCiAgKgogICogVGhpcyBjb2RlIGlzIGJhc2VkIG9uIGRyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJfYmFzZS5jCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOCAgTFNJIENvcnBvcmF0aW9uCisgKiBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOSAgTFNJIENvcnBvcmF0aW9uCiAgKiAgKG1haWx0bzpETC1NUFRGdXNpb25MaW51eEBsc2kuY29tKQogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTIyNywyMyArMjI3LDI1IEBACiAgKiBtcHQyc2FzX2NvbmZpZ19kb25lIC0gY29uZmlnIHBhZ2UgY29tcGxldGlvbiByb3V0aW5lCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4Ci0gKiBAVkZfSUQ6IHZpcnR1YWwgZnVuY3Rpb24gaWQKKyAqIEBtc2l4X2luZGV4OiBNU0lYIHRhYmxlIGluZGV4IHN1cHBsaWVkIGJ5IHRoZSBPUwogICogQHJlcGx5OiByZXBseSBtZXNzYWdlIGZyYW1lKGxvd2VyIDMyYml0IGFkZHIpCiAgKiBDb250ZXh0OiBub25lLgogICoKICAqIFRoZSBjYWxsYmFjayBoYW5kbGVyIHdoZW4gdXNpbmcgX2NvbmZpZ19yZXF1ZXN0LgogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXZvaWQKLW1wdDJzYXNfY29uZmlnX2RvbmUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggVkZfSUQsIHUzMiByZXBseSkKK3U4CittcHQyc2FzX2NvbmZpZ19kb25lKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IG1zaXhfaW5kZXgsCisgICAgdTMyIHJlcGx5KQogewogCU1QSTJEZWZhdWx0UmVwbHlfdCAqbXBpX3JlcGx5OwogCiAJaWYgKGlvYy0+Y29uZmlnX2NtZHMuc3RhdHVzID09IE1QVDJfQ01EX05PVF9VU0VEKQotCQlyZXR1cm47CisJCXJldHVybiAxOwogCWlmIChpb2MtPmNvbmZpZ19jbWRzLnNtaWQgIT0gc21pZCkKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKIAlpb2MtPmNvbmZpZ19jbWRzLnN0YXR1cyB8PSBNUFQyX0NNRF9DT01QTEVURTsKIAltcGlfcmVwbHkgPSAgbXB0MnNhc19iYXNlX2dldF9yZXBseV92aXJ0X2FkZHIoaW9jLCByZXBseSk7CiAJaWYgKG1waV9yZXBseSkgewpAQCAtMjU3LDYgKzI1OSw3IEBACiAjZW5kaWYKIAlpb2MtPmNvbmZpZ19jbWRzLnNtaWQgPSBVU0hPUlRfTUFYOwogCWNvbXBsZXRlKCZpb2MtPmNvbmZpZ19jbWRzLmRvbmUpOworCXJldHVybiAxOwogfQogCiAvKioKQEAgLTMwMyw2ICszMDYsOSBAQAogCXJldHJ5X2NvdW50ID0gMDsKIAltZW1zZXQoJm1lbSwgMCwgc2l6ZW9mKHN0cnVjdCBjb25maWdfcmVxdWVzdCkpOwogCisJbXBpX3JlcXVlc3QtPlZGX0lEID0gMDsgLyogVE9ETyAqLworCW1waV9yZXF1ZXN0LT5WUF9JRCA9IDA7CisKIAlpZiAoY29uZmlnX3BhZ2UpIHsKIAkJbXBpX3JlcXVlc3QtPkhlYWRlci5QYWdlVmVyc2lvbiA9IG1waV9yZXBseS0+SGVhZGVyLlBhZ2VWZXJzaW9uOwogCQltcGlfcmVxdWVzdC0+SGVhZGVyLlBhZ2VOdW1iZXIgPSBtcGlfcmVwbHktPkhlYWRlci5QYWdlTnVtYmVyOwpAQCAtMzgwLDcgKzM4Niw3IEBACiAJX2NvbmZpZ19kaXNwbGF5X3NvbWVfZGVidWcoaW9jLCBzbWlkLCAiY29uZmlnX3JlcXVlc3QiLCBOVUxMKTsKICNlbmRpZgogCWluaXRfY29tcGxldGlvbigmaW9jLT5jb25maWdfY21kcy5kb25lKTsKLQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIGNvbmZpZ19yZXF1ZXN0LT5WRl9JRCk7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkKTsKIAl0aW1lbGVmdCA9IHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmaW9jLT5jb25maWdfY21kcy5kb25lLAogCSAgICB0aW1lb3V0KkhaKTsKIAlpZiAoIShpb2MtPmNvbmZpZ19jbWRzLnN0YXR1cyAmIE1QVDJfQ01EX0NPTVBMRVRFKSkgewpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19jdGwuYyBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfY3RsLmMKaW5kZXggYzJhNTEwMS4uNTdkNzI0NiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19jdGwuYworKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2N0bC5jCkBAIC0zLDcgKzMsNyBAQAogICogY29udHJvbGxlcnMKICAqCiAgKiBUaGlzIGNvZGUgaXMgYmFzZWQgb24gZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0Ml9jdGwuYwotICogQ29weXJpZ2h0IChDKSAyMDA3LTIwMDggIExTSSBDb3Jwb3JhdGlvbgorICogQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIExTSSBDb3Jwb3JhdGlvbgogICogIChtYWlsdG86REwtTVBURnVzaW9uTGludXhAbHNpLmNvbSkKICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0yMTksMjMgKzIxOSwyNSBAQAogICogbXB0MnNhc19jdGxfZG9uZSAtIGN0bCBtb2R1bGUgY29tcGxldGlvbiByb3V0aW5lCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4Ci0gKiBAVkZfSUQ6IHZpcnR1YWwgZnVuY3Rpb24gaWQKKyAqIEBtc2l4X2luZGV4OiBNU0lYIHRhYmxlIGluZGV4IHN1cHBsaWVkIGJ5IHRoZSBPUwogICogQHJlcGx5OiByZXBseSBtZXNzYWdlIGZyYW1lKGxvd2VyIDMyYml0IGFkZHIpCiAgKiBDb250ZXh0OiBub25lLgogICoKICAqIFRoZSBjYWxsYmFjayBoYW5kbGVyIHdoZW4gdXNpbmcgaW9jLT5jdGxfY2JfaWR4LgogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXZvaWQKLW1wdDJzYXNfY3RsX2RvbmUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggVkZfSUQsIHUzMiByZXBseSkKK3U4CittcHQyc2FzX2N0bF9kb25lKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTE2IHNtaWQsIHU4IG1zaXhfaW5kZXgsCisJdTMyIHJlcGx5KQogewogCU1QSTJEZWZhdWx0UmVwbHlfdCAqbXBpX3JlcGx5OwogCiAJaWYgKGlvYy0+Y3RsX2NtZHMuc3RhdHVzID09IE1QVDJfQ01EX05PVF9VU0VEKQotCQlyZXR1cm47CisJCXJldHVybiAxOwogCWlmIChpb2MtPmN0bF9jbWRzLnNtaWQgIT0gc21pZCkKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKIAlpb2MtPmN0bF9jbWRzLnN0YXR1cyB8PSBNUFQyX0NNRF9DT01QTEVURTsKIAltcGlfcmVwbHkgPSBtcHQyc2FzX2Jhc2VfZ2V0X3JlcGx5X3ZpcnRfYWRkcihpb2MsIHJlcGx5KTsKIAlpZiAobXBpX3JlcGx5KSB7CkBAIC0yNDcsNiArMjQ5LDcgQEAKICNlbmRpZgogCWlvYy0+Y3RsX2NtZHMuc3RhdHVzICY9IH5NUFQyX0NNRF9QRU5ESU5HOwogCWNvbXBsZXRlKCZpb2MtPmN0bF9jbWRzLmRvbmUpOworCXJldHVybiAxOwogfQogCiAvKioKQEAgLTMyOCwyMiArMzMxLDI1IEBACiAvKioKICAqIG1wdDJzYXNfY3RsX2V2ZW50X2NhbGxiYWNrIC0gZmlybXdhcmUgZXZlbnQgaGFuZGxlciAoY2FsbGVkIGF0IElTUiB0aW1lKQogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0Ci0gKiBAVkZfSUQ6IHZpcnR1YWwgZnVuY3Rpb24gaWQKKyAqIEBtc2l4X2luZGV4OiBNU0lYIHRhYmxlIGluZGV4IHN1cHBsaWVkIGJ5IHRoZSBPUwogICogQHJlcGx5OiByZXBseSBtZXNzYWdlIGZyYW1lKGxvd2VyIDMyYml0IGFkZHIpCiAgKiBDb250ZXh0OiBpbnRlcnJ1cHQuCiAgKgogICogVGhpcyBmdW5jdGlvbiBtZXJlbHkgYWRkcyBhIG5ldyB3b3JrIHRhc2sgaW50byBpb2MtPmZpcm13YXJlX2V2ZW50X3RocmVhZC4KICAqIFRoZSB0YXNrcyBhcmUgd29ya2VkIGZyb20gX2Zpcm13YXJlX2V2ZW50X3dvcmsgaW4gdXNlciBjb250ZXh0LgogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXZvaWQKLW1wdDJzYXNfY3RsX2V2ZW50X2NhbGxiYWNrKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTggVkZfSUQsIHUzMiByZXBseSkKK3U4CittcHQyc2FzX2N0bF9ldmVudF9jYWxsYmFjayhzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IG1zaXhfaW5kZXgsCisJdTMyIHJlcGx5KQogewogCU1waTJFdmVudE5vdGlmaWNhdGlvblJlcGx5X3QgKm1waV9yZXBseTsKIAogCW1waV9yZXBseSA9IG1wdDJzYXNfYmFzZV9nZXRfcmVwbHlfdmlydF9hZGRyKGlvYywgcmVwbHkpOwogCW1wdDJzYXNfY3RsX2FkZF90b19ldmVudF9sb2coaW9jLCBtcGlfcmVwbHkpOworCXJldHVybiAxOwogfQogCiAvKioKQEAgLTUwNyw3ICs1MTMsNyBAQAogCiAJaGFuZGxlID0gbGUxNl90b19jcHUodG1fcmVxdWVzdC0+RGV2SGFuZGxlKTsKIAlzcGluX2xvY2tfaXJxc2F2ZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7Ci0JZm9yIChpID0gaW9jLT5yZXF1ZXN0X2RlcHRoOyBpICYmICFmb3VuZDsgaS0tKSB7CisJZm9yIChpID0gaW9jLT5zY3NpaW9fZGVwdGg7IGkgJiYgIWZvdW5kOyBpLS0pIHsKIAkJc2NtZCA9IGlvYy0+c2NzaV9sb29rdXBbaSAtIDFdLnNjbWQ7CiAJCWlmIChzY21kID09IE5VTEwgfHwgc2NtZC0+ZGV2aWNlID09IE5VTEwgfHwKIAkJICAgIHNjbWQtPmRldmljZS0+aG9zdGRhdGEgPT0gTlVMTCkKQEAgLTYxNCw3ICs2MjAsNyBAQAogCQlwcmludGsoTVBUMlNBU19JTkZPX0ZNVCAiJXM6IGlvYyBpcyBvcGVyYXRpb25hbFxuIiwKIAkJICAgIGlvYy0+bmFtZSwgX19mdW5jX18pOwogCi0Jc21pZCA9IG1wdDJzYXNfYmFzZV9nZXRfc21pZChpb2MsIGlvYy0+Y3RsX2NiX2lkeCk7CisJc21pZCA9IG1wdDJzYXNfYmFzZV9nZXRfc21pZF9zY3NpaW8oaW9jLCBpb2MtPmN0bF9jYl9pZHgsIE5VTEwpOwogCWlmICghc21pZCkgewogCQlwcmludGsoTVBUMlNBU19FUlJfRk1UICIlczogZmFpbGVkIG9idGFpbmluZyBhIHNtaWRcbiIsCiAJCSAgICBpb2MtPm5hbWUsIF9fZnVuY19fKTsKQEAgLTczNyw3ICs3NDMsNyBAQAogCQkgICAgKHUzMiltcHQyc2FzX2Jhc2VfZ2V0X3NlbnNlX2J1ZmZlcl9kbWEoaW9jLCBzbWlkKTsKIAkJcHJpdl9zZW5zZSA9IG1wdDJzYXNfYmFzZV9nZXRfc2Vuc2VfYnVmZmVyKGlvYywgc21pZCk7CiAJCW1lbXNldChwcml2X3NlbnNlLCAwLCBTQ1NJX1NFTlNFX0JVRkZFUlNJWkUpOwotCQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfc2NzaV9pbyhpb2MsIHNtaWQsIDAsCisJCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9zY3NpX2lvKGlvYywgc21pZCwKIAkJICAgIGxlMTZfdG9fY3B1KG1waV9yZXF1ZXN0LT5GdW5jdGlvbkRlcGVuZGVudDEpKTsKIAkJYnJlYWs7CiAJfQpAQCAtNzU5LDggKzc2NSw3IEBACiAJCW11dGV4X2xvY2soJmlvYy0+dG1fY21kcy5tdXRleCk7CiAJCW1wdDJzYXNfc2NzaWhfc2V0X3RtX2ZsYWcoaW9jLCBsZTE2X3RvX2NwdSgKIAkJICAgIHRtX3JlcXVlc3QtPkRldkhhbmRsZSkpOwotCQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfaGlfcHJpb3JpdHkoaW9jLCBzbWlkLAotCQkgICAgbXBpX3JlcXVlc3QtPlZGX0lEKTsKKwkJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2hpX3ByaW9yaXR5KGlvYywgc21pZCk7CiAJCWJyZWFrOwogCX0KIAljYXNlIE1QSTJfRlVOQ1RJT05fU01QX1BBU1NUSFJPVUdIOgpAQCAtNzgxLDcgKzc4Niw3IEBACiAJCQlpb2MtPmlvY19saW5rX3Jlc2V0X2luX3Byb2dyZXNzID0gMTsKIAkJCWlvYy0+aWdub3JlX2xvZ2luZm9zID0gMTsKIAkJfQotCQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIG1waV9yZXF1ZXN0LT5WRl9JRCk7CisJCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCk7CiAJCWJyZWFrOwogCX0KIAljYXNlIE1QSTJfRlVOQ1RJT05fU0FTX0lPX1VOSVRfQ09OVFJPTDoKQEAgLTc5NSwxMSArODAwLDExIEBACiAJCQlpb2MtPmlvY19saW5rX3Jlc2V0X2luX3Byb2dyZXNzID0gMTsKIAkJCWlvYy0+aWdub3JlX2xvZ2luZm9zID0gMTsKIAkJfQotCQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIG1waV9yZXF1ZXN0LT5WRl9JRCk7CisJCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCk7CiAJCWJyZWFrOwogCX0KIAlkZWZhdWx0OgotCQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIG1waV9yZXF1ZXN0LT5WRl9JRCk7CisJCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCk7CiAJCWJyZWFrOwogCX0KIApAQCAtODA3LDYgKzgxMiw3IEBACiAJCXRpbWVvdXQgPSBNUFQyX0lPQ1RMX0RFRkFVTFRfVElNRU9VVDsKIAllbHNlCiAJCXRpbWVvdXQgPSBrYXJnLnRpbWVvdXQ7CisJaW5pdF9jb21wbGV0aW9uKCZpb2MtPmN0bF9jbWRzLmRvbmUpOwogCXRpbWVsZWZ0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZpb2MtPmN0bF9jbWRzLmRvbmUsCiAJICAgIHRpbWVvdXQqSFopOwogCWlmIChtcGlfcmVxdWVzdC0+RnVuY3Rpb24gPT0gTVBJMl9GVU5DVElPTl9TQ1NJX1RBU0tfTUdNVCkgewpAQCAtMTM3MSw2ICsxMzc3LDggQEAKIAltcGlfcmVxdWVzdC0+RmxhZ3MgPSBjcHVfdG9fbGUzMihrYXJnLmRpYWdub3N0aWNfZmxhZ3MpOwogCW1waV9yZXF1ZXN0LT5CdWZmZXJBZGRyZXNzID0gY3B1X3RvX2xlNjQocmVxdWVzdF9kYXRhX2RtYSk7CiAJbXBpX3JlcXVlc3QtPkJ1ZmZlckxlbmd0aCA9IGNwdV90b19sZTMyKHJlcXVlc3RfZGF0YV9zeik7CisJbXBpX3JlcXVlc3QtPlZGX0lEID0gMDsgLyogVE9ETyAqLworCW1waV9yZXF1ZXN0LT5WUF9JRCA9IDA7CiAKIAlkY3RscHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfREVCVUdfRk1UICIlczogZGlhZ19idWZmZXIoMHglcCksICIKIAkgICAgImRtYSgweCVsbHgpLCBzeiglZClcbiIsIGlvYy0+bmFtZSwgX19mdW5jX18sIHJlcXVlc3RfZGF0YSwKQEAgLTEzODAsNyArMTM4OCw4IEBACiAJCW1waV9yZXF1ZXN0LT5Qcm9kdWN0U3BlY2lmaWNbaV0gPQogCQkJY3B1X3RvX2xlMzIoaW9jLT5wcm9kdWN0X3NwZWNpZmljW2J1ZmZlcl90eXBlXVtpXSk7CiAKLQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIG1waV9yZXF1ZXN0LT5WRl9JRCk7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkKTsKKwlpbml0X2NvbXBsZXRpb24oJmlvYy0+Y3RsX2NtZHMuZG9uZSk7CiAJdGltZWxlZnQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmlvYy0+Y3RsX2NtZHMuZG9uZSwKIAkgICAgTVBUMl9JT0NUTF9ERUZBVUxUX1RJTUVPVVQqSFopOwogCkBAIC0xNjQzLDggKzE2NTIsMTEgQEAKIAogCW1waV9yZXF1ZXN0LT5GdW5jdGlvbiA9IE1QSTJfRlVOQ1RJT05fRElBR19SRUxFQVNFOwogCW1waV9yZXF1ZXN0LT5CdWZmZXJUeXBlID0gYnVmZmVyX3R5cGU7CisJbXBpX3JlcXVlc3QtPlZGX0lEID0gMDsgLyogVE9ETyAqLworCW1waV9yZXF1ZXN0LT5WUF9JRCA9IDA7CiAKLQltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWQsIG1waV9yZXF1ZXN0LT5WRl9JRCk7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkKTsKKwlpbml0X2NvbXBsZXRpb24oJmlvYy0+Y3RsX2NtZHMuZG9uZSk7CiAJdGltZWxlZnQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmlvYy0+Y3RsX2NtZHMuZG9uZSwKIAkgICAgTVBUMl9JT0NUTF9ERUZBVUxUX1RJTUVPVVQqSFopOwogCkBAIC0xOTAyLDggKzE5MTQsMTEgQEAKIAlmb3IgKGkgPSAwOyBpIDwgTVBUMl9QUk9EVUNUX1NQRUNJRklDX0RXT1JEUzsgaSsrKQogCQltcGlfcmVxdWVzdC0+UHJvZHVjdFNwZWNpZmljW2ldID0KIAkJCWNwdV90b19sZTMyKGlvYy0+cHJvZHVjdF9zcGVjaWZpY1tidWZmZXJfdHlwZV1baV0pOworCW1waV9yZXF1ZXN0LT5WRl9JRCA9IDA7IC8qIFRPRE8gKi8KKwltcGlfcmVxdWVzdC0+VlBfSUQgPSAwOwogCi0JbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkLCBtcGlfcmVxdWVzdC0+VkZfSUQpOworCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCk7CisJaW5pdF9jb21wbGV0aW9uKCZpb2MtPmN0bF9jbWRzLmRvbmUpOwogCXRpbWVsZWZ0ID0gd2FpdF9mb3JfY29tcGxldGlvbl90aW1lb3V0KCZpb2MtPmN0bF9jbWRzLmRvbmUsCiAJICAgIE1QVDJfSU9DVExfREVGQVVMVF9USU1FT1VUKkhaKTsKIApAQCAtMjA2OSw2ICsyMDg0LDcgQEAKIF9jdGxfaW9jdGwoc3RydWN0IGZpbGUgKmZpbGUsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQogewogCWxvbmcgcmV0OworCiAJbG9ja19rZXJuZWwoKTsKIAlyZXQgPSBfY3RsX2lvY3RsX21haW4oZmlsZSwgY21kLCAodm9pZCBfX3VzZXIgKilhcmcpOwogCXVubG9ja19rZXJuZWwoKTsKQEAgLTIxNDMsNiArMjE1OSw3IEBACiBfY3RsX2lvY3RsX2NvbXBhdChzdHJ1Y3QgZmlsZSAqZmlsZSwgdW5zaWduZWQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKIHsKIAlsb25nIHJldDsKKwogCWxvY2tfa2VybmVsKCk7CiAJaWYgKGNtZCA9PSBNUFQyQ09NTUFORDMyKQogCQlyZXQgPSBfY3RsX2NvbXBhdF9tcHRfY29tbWFuZChmaWxlLCBjbWQsIGFyZyk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2N0bC5oIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19jdGwuaAppbmRleCA0ZGExMTQzLi4yMTFmMjk2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2N0bC5oCisrKyBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfY3RsLmgKQEAgLTMsNyArMyw3IEBACiAgKiBjb250cm9sbGVycwogICoKICAqIFRoaXMgY29kZSBpcyBiYXNlZCBvbiBkcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyX2N0bC5oCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOCAgTFNJIENvcnBvcmF0aW9uCisgKiBDb3B5cmlnaHQgKEMpIDIwMDctMjAwOSAgTFNJIENvcnBvcmF0aW9uCiAgKiAgKG1haWx0bzpETC1NUFRGdXNpb25MaW51eEBsc2kuY29tKQogICoKICAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfZGVidWcuaCBiL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfZGVidWcuaAppbmRleCBhZDMyNTA5Li41MzA4YTI1IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX2RlYnVnLmgKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19kZWJ1Zy5oCkBAIC0yLDcgKzIsNyBAQAogICogTG9nZ2luZyBTdXBwb3J0IGZvciBNUFQgKE1lc3NhZ2UgUGFzc2luZyBUZWNobm9sb2d5KSBiYXNlZCBjb250cm9sbGVycwogICoKICAqIFRoaXMgY29kZSBpcyBiYXNlZCBvbiBkcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyX2RlYnVnLmMKLSAqIENvcHlyaWdodCAoQykgMjAwNy0yMDA4ICBMU0kgQ29ycG9yYXRpb24KKyAqIENvcHlyaWdodCAoQykgMjAwNy0yMDA5ICBMU0kgQ29ycG9yYXRpb24KICAqICAobWFpbHRvOkRMLU1QVEZ1c2lvbkxpbnV4QGxzaS5jb20pCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19zY3NpaC5jIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc19zY3NpaC5jCmluZGV4IDc3NGIzNDUuLjg2YWIzMmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfc2NzaWguYworKysgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX3Njc2loLmMKQEAgLTIsNyArMiw3IEBACiAgKiBTY3NpIEhvc3QgTGF5ZXIgZm9yIE1QVCAoTWVzc2FnZSBQYXNzaW5nIFRlY2hub2xvZ3kpIGJhc2VkIGNvbnRyb2xsZXJzCiAgKgogICogVGhpcyBjb2RlIGlzIGJhc2VkIG9uIGRyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJfc2NzaWguYwotICogQ29weXJpZ2h0IChDKSAyMDA3LTIwMDggIExTSSBDb3Jwb3JhdGlvbgorICogQ29weXJpZ2h0IChDKSAyMDA3LTIwMDkgIExTSSBDb3Jwb3JhdGlvbgogICogIChtYWlsdG86REwtTVBURnVzaW9uTGludXhAbHNpLmNvbSkKICAqCiAgKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC03OSw2ICs3OSw5IEBACiBzdGF0aWMgdTggY29uZmlnX2NiX2lkeCA9IC0xOwogc3RhdGljIGludCBtcHRfaWRzOwogCitzdGF0aWMgdTggdG1fdHJfY2JfaWR4ID0gLTEgOworc3RhdGljIHU4IHRtX3Nhc19jb250cm9sX2NiX2lkeCA9IC0xOworCiAvKiBjb21tYW5kIGxpbmUgb3B0aW9ucyAqLwogc3RhdGljIHUzMiBsb2dnaW5nX2xldmVsOwogTU9EVUxFX1BBUk1fREVTQyhsb2dnaW5nX2xldmVsLCAiIGJpdHMgZm9yIGVuYWJsaW5nIGFkZGl0aW9uYWwgbG9nZ2luZyBpbmZvICIKQEAgLTEwOSw2ICsxMTIsNyBAQAogICogQHdvcms6IHdvcmsgb2JqZWN0IChpb2MtPmZhdWx0X3Jlc2V0X3dvcmtfcSkKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAogICogQFZGX0lEOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCisgKiBAVlBfSUQ6IHZpcnR1YWwgcG9ydCBpZAogICogQGhvc3RfcmVzZXRfaGFuZGxpbmc6IGhhbmRsaW5nIGV2ZW50cyBkdXJpbmcgaG9zdCByZXNldAogICogQGlnbm9yZTogZmxhZyBtZWFuaW5nIHRoaXMgZXZlbnQgaGFzIGJlZW4gbWFya2VkIHRvIGlnbm9yZQogICogQGV2ZW50OiBmaXJtd2FyZSBldmVudCBNUEkyX0VWRU5UX1hYWCBkZWZpbmVkIGluIG1wdDJfaW9jLmgKQEAgLTEyMSw2ICsxMjUsNyBAQAogCXN0cnVjdCB3b3JrX3N0cnVjdAl3b3JrOwogCXN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYzsKIAl1OAkJCVZGX0lEOworCXU4CQkJVlBfSUQ7CiAJdTgJCQlob3N0X3Jlc2V0X2hhbmRsaW5nOwogCXU4CQkJaWdub3JlOwogCXUxNgkJCWV2ZW50OwpAQCAtMTM4LDggKzE0MywxMCBAQAogICogQGx1bjogbHVuIG51bWJlcgogICogQGNkYl9sZW5ndGg6IGNkYiBsZW5ndGgKICAqIEBjZGI6IGNkYiBjb250ZW50cwotICogQHZhbGlkX3JlcGx5OiBmbGFnIHNldCBmb3IgcmVwbHkgbWVzc2FnZQogICogQHRpbWVvdXQ6IHRpbWVvdXQgZm9yIHRoaXMgY29tbWFuZAorICogQFZGX0lEOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCisgKiBAVlBfSUQ6IHZpcnR1YWwgcG9ydCBpZAorICogQHZhbGlkX3JlcGx5OiBmbGFnIHNldCBmb3IgcmVwbHkgbWVzc2FnZQogICogQHNlbnNlX2xlbmd0aDogc2Vuc2UgbGVuZ3RoCiAgKiBAaW9jX3N0YXR1czogaW9jIHN0YXR1cwogICogQHNjc2lfc3RhdGU6IHNjc2kgc3RhdGUKQEAgLTE2MSw2ICsxNjgsOCBAQAogCXU4CWNkYl9sZW5ndGg7CiAJdTgJY2RiWzMyXTsKIAl1OAl0aW1lb3V0OworCXU4CVZGX0lEOworCXU4CVZQX0lEOwogCXU4CXZhbGlkX3JlcGx5OwogICAvKiB0aGUgZm9sbG93aW5nIGJpdHMgYXJlIG9ubHkgdmFsaWQgd2hlbiAndmFsaWRfcmVwbHkgPSAxJyAqLwogCXUzMglzZW5zZV9sZW5ndGg7CkBAIC03NTYsNjYgKzc2NSwxNiBAQAogfQogCiAvKioKLSAqIF9zY3NpaF9zY3NpX2xvb2t1cF9nZXQgLSByZXR1cm5zIHNjbWQgZW50cnkKKyAqIG1wdHNjc2loX2dldF9zY3NpX2xvb2t1cCAtIHJldHVybnMgc2NtZCBlbnRyeQogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CiAgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAotICogQ29udGV4dDogVGhpcyBmdW5jdGlvbiB3aWxsIGFjcXVpcmUgaW9jLT5zY3NpX2xvb2t1cF9sb2NrLgogICoKICAqIFJldHVybnMgdGhlIHNtaWQgc3RvcmVkIHNjbWQgcG9pbnRlci4KICAqLwogc3RhdGljIHN0cnVjdCBzY3NpX2NtbmQgKgogX3Njc2loX3Njc2lfbG9va3VwX2dldChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkKQogewotCXVuc2lnbmVkIGxvbmcJZmxhZ3M7Ci0Jc3RydWN0IHNjc2lfY21uZCAqc2NtZDsKLQotCXNwaW5fbG9ja19pcnFzYXZlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKLQlzY21kID0gaW9jLT5zY3NpX2xvb2t1cFtzbWlkIC0gMV0uc2NtZDsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKLQlyZXR1cm4gc2NtZDsKLX0KLQotLyoqCi0gKiBtcHRzY3NpaF9nZXRjbGVhcl9zY3NpX2xvb2t1cCAtIHJldHVybnMgc2NtZCBlbnRyeQotICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0Ci0gKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAotICogQ29udGV4dDogVGhpcyBmdW5jdGlvbiB3aWxsIGFjcXVpcmUgaW9jLT5zY3NpX2xvb2t1cF9sb2NrLgotICoKLSAqIFJldHVybnMgdGhlIHNtaWQgc3RvcmVkIHNjbWQgcG9pbnRlciwgYXMgd2VsbCBhcyBjbGVhcmluZyB0aGUgc2NtZCBwb2ludGVyLgotICovCi1zdGF0aWMgc3RydWN0IHNjc2lfY21uZCAqCi1fc2NzaWhfc2NzaV9sb29rdXBfZ2V0Y2xlYXIoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCkKLXsKLQl1bnNpZ25lZCBsb25nCWZsYWdzOwotCXN0cnVjdCBzY3NpX2NtbmQgKnNjbWQ7Ci0KLQlzcGluX2xvY2tfaXJxc2F2ZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7Ci0Jc2NtZCA9IGlvYy0+c2NzaV9sb29rdXBbc21pZCAtIDFdLnNjbWQ7Ci0JaW9jLT5zY3NpX2xvb2t1cFtzbWlkIC0gMV0uc2NtZCA9IE5VTEw7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaW9jLT5zY3NpX2xvb2t1cF9sb2NrLCBmbGFncyk7Ci0JcmV0dXJuIHNjbWQ7Ci19Ci0KLS8qKgotICogX3Njc2loX3Njc2lfbG9va3VwX3NldCAtIHVwZGF0ZXMgc2NtZCBlbnRyeSBpbiBsb29rdXAKLSAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAotICogQHNtaWQ6IHN5c3RlbSByZXF1ZXN0IG1lc3NhZ2UgaW5kZXgKLSAqIEBzY21kOiBwb2ludGVyIHRvIHNjc2kgY29tbWFuZCBvYmplY3QKLSAqIENvbnRleHQ6IFRoaXMgZnVuY3Rpb24gd2lsbCBhY3F1aXJlIGlvYy0+c2NzaV9sb29rdXBfbG9jay4KLSAqCi0gKiBUaGlzIHdpbGwgc2F2ZSBzY21kIHBvaW50ZXIgaW4gdGhlIHNjc2lfbG9va3VwIGFycmF5LgotICoKLSAqIFJldHVybiBub3RoaW5nLgotICovCi1zdGF0aWMgdm9pZAotX3Njc2loX3Njc2lfbG9va3VwX3NldChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLAotICAgIHN0cnVjdCBzY3NpX2NtbmQgKnNjbWQpCi17Ci0JdW5zaWduZWQgbG9uZwlmbGFnczsKLQotCXNwaW5fbG9ja19pcnFzYXZlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKLQlpb2MtPnNjc2lfbG9va3VwW3NtaWQgLSAxXS5zY21kID0gc2NtZDsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKKwlyZXR1cm4gaW9jLT5zY3NpX2xvb2t1cFtzbWlkIC0gMV0uc2NtZDsKIH0KIAogLyoqCkBAIC04MzgsOSArNzk3LDkgQEAKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKIAlzbWlkID0gMDsKLQlmb3IgKGkgPSAwOyBpIDwgaW9jLT5yZXF1ZXN0X2RlcHRoOyBpKyspIHsKKwlmb3IgKGkgPSAwOyBpIDwgaW9jLT5zY3NpaW9fZGVwdGg7IGkrKykgewogCQlpZiAoaW9jLT5zY3NpX2xvb2t1cFtpXS5zY21kID09IHNjbWQpIHsKLQkJCXNtaWQgPSBpICsgMTsKKwkJCXNtaWQgPSBpb2MtPnNjc2lfbG9va3VwW2ldLnNtaWQ7CiAJCQlnb3RvIG91dDsKIAkJfQogCX0KQEAgLTg2OSw3ICs4MjgsNyBAQAogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2NzaV9sb29rdXBfbG9jaywgZmxhZ3MpOwogCWZvdW5kID0gMDsKLQlmb3IgKGkgPSAwIDsgaSA8IGlvYy0+cmVxdWVzdF9kZXB0aDsgaSsrKSB7CisJZm9yIChpID0gMCA7IGkgPCBpb2MtPnNjc2lpb19kZXB0aDsgaSsrKSB7CiAJCWlmIChpb2MtPnNjc2lfbG9va3VwW2ldLnNjbWQgJiYKIAkJICAgIChpb2MtPnNjc2lfbG9va3VwW2ldLnNjbWQtPmRldmljZS0+aWQgPT0gaWQgJiYKIAkJICAgIGlvYy0+c2NzaV9sb29rdXBbaV0uc2NtZC0+ZGV2aWNlLT5jaGFubmVsID09IGNoYW5uZWwpKSB7CkBAIC05MDMsNyArODYyLDcgQEAKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZpb2MtPnNjc2lfbG9va3VwX2xvY2ssIGZsYWdzKTsKIAlmb3VuZCA9IDA7Ci0JZm9yIChpID0gMCA7IGkgPCBpb2MtPnJlcXVlc3RfZGVwdGg7IGkrKykgeworCWZvciAoaSA9IDAgOyBpIDwgaW9jLT5zY3NpaW9fZGVwdGg7IGkrKykgewogCQlpZiAoaW9jLT5zY3NpX2xvb2t1cFtpXS5zY21kICYmCiAJCSAgICAoaW9jLT5zY3NpX2xvb2t1cFtpXS5zY21kLT5kZXZpY2UtPmlkID09IGlkICYmCiAJCSAgICBpb2MtPnNjc2lfbG9va3VwW2ldLnNjbWQtPmRldmljZS0+Y2hhbm5lbCA9PSBjaGFubmVsICYmCkBAIC0xMTEzLDcgKzEwNzIsNyBAQAogfQogCiAvKioKLSAqIF9zY3NpaF9jaGFuZ2VfcXVldWVfZGVwdGggLSBjaGFuZ2luZyBkZXZpY2UgcXVldWUgdGFnIHR5cGUKKyAqIF9zY3NpaF9jaGFuZ2VfcXVldWVfdHlwZSAtIGNoYW5naW5nIGRldmljZSBxdWV1ZSB0YWcgdHlwZQogICogQHNkZXY6IHNjc2kgZGV2aWNlIHN0cnVjdAogICogQHRhZ190eXBlOiByZXF1ZXN0ZWQgdGFnIHR5cGUKICAqCkBAIC0xNjc5LDIzICsxNjM4LDI0IEBACiAgKiBfc2NzaWhfdG1fZG9uZSAtIHRtIGNvbXBsZXRpb24gcm91dGluZQogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CiAgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAotICogQFZGX0lEOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCisgKiBAbXNpeF9pbmRleDogTVNJWCB0YWJsZSBpbmRleCBzdXBwbGllZCBieSB0aGUgT1MKICAqIEByZXBseTogcmVwbHkgbWVzc2FnZSBmcmFtZShsb3dlciAzMmJpdCBhZGRyKQogICogQ29udGV4dDogbm9uZS4KICAqCiAgKiBUaGUgY2FsbGJhY2sgaGFuZGxlciB3aGVuIHVzaW5nIHNjc2loX2lzc3VlX3RtLgogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXN0YXRpYyB2b2lkCi1fc2NzaWhfdG1fZG9uZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBWRl9JRCwgdTMyIHJlcGx5KQorc3RhdGljIHU4Citfc2NzaWhfdG1fZG9uZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBtc2l4X2luZGV4LCB1MzIgcmVwbHkpCiB7CiAJTVBJMkRlZmF1bHRSZXBseV90ICptcGlfcmVwbHk7CiAKIAlpZiAoaW9jLT50bV9jbWRzLnN0YXR1cyA9PSBNUFQyX0NNRF9OT1RfVVNFRCkKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKIAlpZiAoaW9jLT50bV9jbWRzLnNtaWQgIT0gc21pZCkKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKIAlpb2MtPnRtX2NtZHMuc3RhdHVzIHw9IE1QVDJfQ01EX0NPTVBMRVRFOwogCW1waV9yZXBseSA9ICBtcHQyc2FzX2Jhc2VfZ2V0X3JlcGx5X3ZpcnRfYWRkcihpb2MsIHJlcGx5KTsKIAlpZiAobXBpX3JlcGx5KSB7CkBAIC0xNzA0LDYgKzE2NjQsNyBAQAogCX0KIAlpb2MtPnRtX2NtZHMuc3RhdHVzICY9IH5NUFQyX0NNRF9QRU5ESU5HOwogCWNvbXBsZXRlKCZpb2MtPnRtX2NtZHMuZG9uZSk7CisJcmV0dXJuIDE7CiB9CiAKIC8qKgpAQCAtMTc5MCw3ICsxNzUxLDYgQEAKIAl1MTYgc21pZCA9IDA7CiAJdTMyIGlvY19zdGF0ZTsKIAl1bnNpZ25lZCBsb25nIHRpbWVsZWZ0OwotCXU4IFZGX0lEID0gMDsKIAogCWlmIChpb2MtPnRtX2NtZHMuc3RhdHVzICE9IE1QVDJfQ01EX05PVF9VU0VEKSB7CiAJCXByaW50ayhNUFQyU0FTX0lORk9fRk1UICIlczogdG1fY21kIGJ1c3khISFcbiIsCkBAIC0xODE3LDcgKzE3NzcsNyBAQAogCQlnb3RvIGlzc3VlX2hvc3RfcmVzZXQ7CiAJfQogCi0Jc21pZCA9IG1wdDJzYXNfYmFzZV9nZXRfc21pZChpb2MsIGlvYy0+dG1fY2JfaWR4KTsKKwlzbWlkID0gbXB0MnNhc19iYXNlX2dldF9zbWlkX2hwcihpb2MsIGlvYy0+dG1fY2JfaWR4KTsKIAlpZiAoIXNtaWQpIHsKIAkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiJXM6IGZhaWxlZCBvYnRhaW5pbmcgYSBzbWlkXG4iLAogCQkgICAgaW9jLT5uYW1lLCBfX2Z1bmNfXyk7CkBAIC0xODI1LDcgKzE3ODUsOCBAQAogCX0KIAogCWR0bXByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0lORk9fRk1UICJzZW5kaW5nIHRtOiBoYW5kbGUoMHglMDR4KSwiCi0JICAgICIgdGFza190eXBlKDB4JTAyeCksIHNtaWQoJWQpXG4iLCBpb2MtPm5hbWUsIGhhbmRsZSwgdHlwZSwgc21pZCkpOworCSAgICAiIHRhc2tfdHlwZSgweCUwMngpLCBzbWlkKCVkKVxuIiwgaW9jLT5uYW1lLCBoYW5kbGUsIHR5cGUsCisJICAgIHNtaWRfdGFzaykpOwogCWlvYy0+dG1fY21kcy5zdGF0dXMgPSBNUFQyX0NNRF9QRU5ESU5HOwogCW1waV9yZXF1ZXN0ID0gbXB0MnNhc19iYXNlX2dldF9tc2dfZnJhbWUoaW9jLCBzbWlkKTsKIAlpb2MtPnRtX2NtZHMuc21pZCA9IHNtaWQ7CkBAIC0xODM0LDEwICsxNzk1LDEyIEBACiAJbXBpX3JlcXVlc3QtPkRldkhhbmRsZSA9IGNwdV90b19sZTE2KGhhbmRsZSk7CiAJbXBpX3JlcXVlc3QtPlRhc2tUeXBlID0gdHlwZTsKIAltcGlfcmVxdWVzdC0+VGFza01JRCA9IGNwdV90b19sZTE2KHNtaWRfdGFzayk7CisJbXBpX3JlcXVlc3QtPlZQX0lEID0gMDsgIC8qIFRPRE8gKi8KKwltcGlfcmVxdWVzdC0+VkZfSUQgPSAwOwogCWludF90b19zY3NpbHVuKGx1biwgKHN0cnVjdCBzY3NpX2x1biAqKW1waV9yZXF1ZXN0LT5MVU4pOwogCW1wdDJzYXNfc2NzaWhfc2V0X3RtX2ZsYWcoaW9jLCBoYW5kbGUpOwogCWluaXRfY29tcGxldGlvbigmaW9jLT50bV9jbWRzLmRvbmUpOwotCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9oaV9wcmlvcml0eShpb2MsIHNtaWQsIFZGX0lEKTsKKwltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfaGlfcHJpb3JpdHkoaW9jLCBzbWlkKTsKIAl0aW1lbGVmdCA9IHdhaXRfZm9yX2NvbXBsZXRpb25fdGltZW91dCgmaW9jLT50bV9jbWRzLmRvbmUsIHRpbWVvdXQqSFopOwogCW1wdDJzYXNfc2NzaWhfY2xlYXJfdG1fZmxhZyhpb2MsIGhhbmRsZSk7CiAJaWYgKCEoaW9jLT50bV9jbWRzLnN0YXR1cyAmIE1QVDJfQ01EX0NPTVBMRVRFKSkgewpAQCAtMjA3NSw3ICsyMDM4LDcgQEAKIH0KIAogLyoqCi0gKiBfc2NzaWhfYWJvcnQgLSBlaCB0aHJlYWRzIG1haW4gaG9zdCByZXNldCByb3V0aW5lCisgKiBfc2NzaWhfaG9zdF9yZXNldCAtIGVoIHRocmVhZHMgbWFpbiBob3N0IHJlc2V0IHJvdXRpbmUKICAqIEBzZGV2OiBzY3NpIGRldmljZSBzdHJ1Y3QKICAqCiAgKiBSZXR1cm5zIFNVQ0NFU1MgaWYgY29tbWFuZCBhYm9ydGVkIGVsc2UgRkFJTEVECkBAIC0yMzU0LDYgKzIzMTcsMjMxIEBACiB9CiAKIC8qKgorICogX3Njc2loX3RtX3RyX3NlbmQgLSBzZW5kIHRhc2sgbWFuYWdlbWVudCByZXF1ZXN0CisgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKKyAqIEBoYW5kbGU6IGRldmljZSBoYW5kbGUKKyAqIENvbnRleHQ6IGludGVycnVwdCB0aW1lLgorICoKKyAqIFRoaXMgY29kZSBpcyB0byBpbml0aWF0ZSB0aGUgZGV2aWNlIHJlbW92YWwgaGFuZHNoYWtlIHByb3RvY2FsCisgKiB3aXRoIGNvbnRyb2xsZXIgZmlybXdhcmUuICBUaGlzIGZ1bmN0aW9uIHdpbGwgaXNzdWUgdGFyZ2V0IHJlc2V0CisgKiB1c2luZyBoaWdoIHByaW9yaXR5IHJlcXVlc3QgcXVldWUuICBJdCB3aWxsIHNlbmQgYSBzYXMgaW91bml0CisgKiBjb250cm9sbCByZXF1ZXN0IChNUEkyX1NBU19PUF9SRU1PVkVfREVWSUNFKSBmcm9tIHRoaXMgY29tcGxldGlvbi4KKyAqCisgKiBUaGlzIGlzIGRlc2lnbmVkIHRvIHNlbmQgbXVsaXBsZSB0YXNrIG1hbmFnZW1lbnQgcmVxdWVzdCBhdCB0aGUgc2FtZQorICogdGltZSB0byB0aGUgZmlmby4gSWYgdGhlIGZpZm8gaXMgZnVsbCwgd2Ugd2lsbCBhcHBlbmQgdGhlIHJlcXVlc3QsCisgKiBhbmQgcHJvY2VzcyBpdCBpbiBhIGZ1dHVyZSBjb21wbGV0aW9uLgorICovCitzdGF0aWMgdm9pZAorX3Njc2loX3RtX3RyX3NlbmQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgaGFuZGxlKQoreworCU1waTJTQ1NJVGFza01hbmFnZW1lbnRSZXF1ZXN0X3QgKm1waV9yZXF1ZXN0OworCXN0cnVjdCBNUFQyU0FTX1RBUkdFVCAqc2FzX3RhcmdldF9wcml2X2RhdGE7CisJdTE2IHNtaWQ7CisJc3RydWN0IF9zYXNfZGV2aWNlICpzYXNfZGV2aWNlOworCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJc3RydWN0IF90cl9saXN0ICpkZWxheWVkX3RyOworCisJaWYgKGlvYy0+c2hvc3RfcmVjb3ZlcnkpIHsKKwkJcHJpbnRrKE1QVDJTQVNfSU5GT19GTVQgIiVzOiBob3N0IHJlc2V0IGluIHByb2dyZXNzIVxuIiwKKwkJICAgIF9fZnVuY19fLCBpb2MtPm5hbWUpOworCQlyZXR1cm47CisJfQorCisJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2FzX2RldmljZV9sb2NrLCBmbGFncyk7CisJc2FzX2RldmljZSA9IF9zY3NpaF9zYXNfZGV2aWNlX2ZpbmRfYnlfaGFuZGxlKGlvYywgaGFuZGxlKTsKKwlpZiAoIXNhc19kZXZpY2UpIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaW9jLT5zYXNfZGV2aWNlX2xvY2ssIGZsYWdzKTsKKwkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiJXM6IGZhaWxlZCBmaW5kaW5nIHNhc19kZXZpY2VcbiIsCisJCSAgICBpb2MtPm5hbWUsIF9fZnVuY19fKTsKKwkJcmV0dXJuOworCX0KKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNhc19kZXZpY2VfbG9jaywgZmxhZ3MpOworCisJLyogc2tpcCBpcyBoaWRkZW4gcmFpZCBjb21wb25lbnQgKi8KKwlpZiAoc2FzX2RldmljZS0+aGlkZGVuX3JhaWRfY29tcG9uZW50KQorCQlyZXR1cm47CisKKwlzbWlkID0gbXB0MnNhc19iYXNlX2dldF9zbWlkX2hwcihpb2MsIGlvYy0+dG1fdHJfY2JfaWR4KTsKKwlpZiAoIXNtaWQpIHsKKwkJZGVsYXllZF90ciA9IGt6YWxsb2Moc2l6ZW9mKCpkZWxheWVkX3RyKSwgR0ZQX0FUT01JQyk7CisJCWlmICghZGVsYXllZF90cikKKwkJCXJldHVybjsKKwkJSU5JVF9MSVNUX0hFQUQoJmRlbGF5ZWRfdHItPmxpc3QpOworCQlkZWxheWVkX3RyLT5oYW5kbGUgPSBoYW5kbGU7CisJCWRlbGF5ZWRfdHItPnN0YXRlID0gTVBUMlNBU19SRVFfU0FTX0NOVFJMOworCQlsaXN0X2FkZF90YWlsKCZkZWxheWVkX3RyLT5saXN0LAorCQkgICAgJmlvYy0+ZGVsYXllZF90cl9saXN0KTsKKwkJaWYgKHNhc19kZXZpY2UtPnN0YXJnZXQpCisJCQlkZXd0cHJpbnRrKGlvYywgc3RhcmdldF9wcmludGsoS0VSTl9JTkZPLAorCQkJICAgIHNhc19kZXZpY2UtPnN0YXJnZXQsICJERUxBWUVEOnRyOmhhbmRsZSgweCUwNHgpLCAiCisJCQkgICAgIihvcGVuKVxuIiwgc2FzX2RldmljZS0+aGFuZGxlKSk7CisJCXJldHVybjsKKwl9CisKKwlpZiAoc2FzX2RldmljZS0+c3RhcmdldCAmJiBzYXNfZGV2aWNlLT5zdGFyZ2V0LT5ob3N0ZGF0YSkgeworCQlzYXNfdGFyZ2V0X3ByaXZfZGF0YSA9IHNhc19kZXZpY2UtPnN0YXJnZXQtPmhvc3RkYXRhOworCQlzYXNfdGFyZ2V0X3ByaXZfZGF0YS0+dG1fYnVzeSA9IDE7CisJCWRld3RwcmludGsoaW9jLCBzdGFyZ2V0X3ByaW50ayhLRVJOX0lORk8sIHNhc19kZXZpY2UtPnN0YXJnZXQsCisJCSAgICAidHI6aGFuZGxlKDB4JTA0eCksIChvcGVuKVxuIiwgc2FzX2RldmljZS0+aGFuZGxlKSk7CisJfQorCisJbXBpX3JlcXVlc3QgPSBtcHQyc2FzX2Jhc2VfZ2V0X21zZ19mcmFtZShpb2MsIHNtaWQpOworCW1lbXNldChtcGlfcmVxdWVzdCwgMCwgc2l6ZW9mKE1waTJTQ1NJVGFza01hbmFnZW1lbnRSZXF1ZXN0X3QpKTsKKwltcGlfcmVxdWVzdC0+RnVuY3Rpb24gPSBNUEkyX0ZVTkNUSU9OX1NDU0lfVEFTS19NR01UOworCW1waV9yZXF1ZXN0LT5EZXZIYW5kbGUgPSBjcHVfdG9fbGUxNihoYW5kbGUpOworCW1waV9yZXF1ZXN0LT5UYXNrVHlwZSA9IE1QSTJfU0NTSVRBU0tNR01UX1RBU0tUWVBFX1RBUkdFVF9SRVNFVDsKKwlzYXNfZGV2aWNlLT5zdGF0ZSB8PSBNUFRTQVNfU1RBVEVfVFJfU0VORDsKKwlzYXNfZGV2aWNlLT5zdGF0ZSB8PSBNUFQyU0FTX1JFUV9TQVNfQ05UUkw7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2hpX3ByaW9yaXR5KGlvYywgc21pZCk7Cit9CisKKworCisvKioKKyAqIF9zY3NpaF9zYXNfY29udHJvbF9jb21wbGV0ZSAtIGNvbXBsZXRpb24gcm91dGluZQorICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CisgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAorICogQG1zaXhfaW5kZXg6IE1TSVggdGFibGUgaW5kZXggc3VwcGxpZWQgYnkgdGhlIE9TCisgKiBAcmVwbHk6IHJlcGx5IG1lc3NhZ2UgZnJhbWUobG93ZXIgMzJiaXQgYWRkcikKKyAqIENvbnRleHQ6IGludGVycnVwdCB0aW1lLgorICoKKyAqIFRoaXMgaXMgdGhlIHNhcyBpb3VuaXQgY29udHJvbGwgY29tcGxldGlvbiByb3V0aW5lLgorICogVGhpcyBjb2RlIGlzIHBhcnQgb2YgdGhlIGNvZGUgdG8gaW5pdGlhdGUgdGhlIGRldmljZSByZW1vdmFsCisgKiBoYW5kc2hha2UgcHJvdG9jYWwgd2l0aCBjb250cm9sbGVyIGZpcm13YXJlLgorICoKKyAqIFJldHVybiAxIG1lYW5pbmcgbWYgc2hvdWxkIGJlIGZyZWVkIGZyb20gX2Jhc2VfaW50ZXJydXB0CisgKiAgICAgICAgMCBtZWFucyB0aGUgbWYgaXMgZnJlZWQgZnJvbSB0aGlzIGZ1bmN0aW9uLgorICovCitzdGF0aWMgdTgKK19zY3NpaF9zYXNfY29udHJvbF9jb21wbGV0ZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLAorICAgIHU4IG1zaXhfaW5kZXgsIHUzMiByZXBseSkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXUxNiBoYW5kbGU7CisJc3RydWN0IF9zYXNfZGV2aWNlICpzYXNfZGV2aWNlOworCU1waTJTYXNJb1VuaXRDb250cm9sUmVwbHlfdCAqbXBpX3JlcGx5ID0KKwkgICAgbXB0MnNhc19iYXNlX2dldF9yZXBseV92aXJ0X2FkZHIoaW9jLCByZXBseSk7CisKKwloYW5kbGUgPSBsZTE2X3RvX2NwdShtcGlfcmVwbHktPkRldkhhbmRsZSk7CisKKwlzcGluX2xvY2tfaXJxc2F2ZSgmaW9jLT5zYXNfZGV2aWNlX2xvY2ssIGZsYWdzKTsKKwlzYXNfZGV2aWNlID0gX3Njc2loX3Nhc19kZXZpY2VfZmluZF9ieV9oYW5kbGUoaW9jLCBoYW5kbGUpOworCWlmICghc2FzX2RldmljZSkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNhc19kZXZpY2VfbG9jaywgZmxhZ3MpOworCQlwcmludGsoTVBUMlNBU19FUlJfRk1UICIlczogZmFpbGVkIGZpbmRpbmcgc2FzX2RldmljZVxuIiwKKwkJICAgIGlvYy0+bmFtZSwgX19mdW5jX18pOworCQlyZXR1cm4gMTsKKwl9CisJc2FzX2RldmljZS0+c3RhdGUgfD0gTVBUU0FTX1NUQVRFX0NOVFJMX0NPTVBMRVRFOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmlvYy0+c2FzX2RldmljZV9sb2NrLCBmbGFncyk7CisKKwlpZiAoc2FzX2RldmljZS0+c3RhcmdldCkKKwkJZGV3dHByaW50ayhpb2MsIHN0YXJnZXRfcHJpbnRrKEtFUk5fSU5GTywgc2FzX2RldmljZS0+c3RhcmdldCwKKwkJICAgICJzY19jb21wbGV0ZTpoYW5kbGUoMHglMDR4KSwgIgorCQkgICAgImlvY19zdGF0dXMoMHglMDR4KSwgbG9naW5mbygweCUwOHgpXG4iLAorCQkgICAgaGFuZGxlLCBsZTE2X3RvX2NwdShtcGlfcmVwbHktPklPQ1N0YXR1cyksCisJCSAgICBsZTMyX3RvX2NwdShtcGlfcmVwbHktPklPQ0xvZ0luZm8pKSk7CisJcmV0dXJuIDE7Cit9CisKKy8qKgorICogX3Njc2loX3RtX3RyX2NvbXBsZXRlIC0KKyAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAorICogQHNtaWQ6IHN5c3RlbSByZXF1ZXN0IG1lc3NhZ2UgaW5kZXgKKyAqIEBtc2l4X2luZGV4OiBNU0lYIHRhYmxlIGluZGV4IHN1cHBsaWVkIGJ5IHRoZSBPUworICogQHJlcGx5OiByZXBseSBtZXNzYWdlIGZyYW1lKGxvd2VyIDMyYml0IGFkZHIpCisgKiBDb250ZXh0OiBpbnRlcnJ1cHQgdGltZS4KKyAqCisgKiBUaGlzIGlzIHRoZSB0YXJnZXQgcmVzZXQgY29tcGxldGlvbiByb3V0aW5lLgorICogVGhpcyBjb2RlIGlzIHBhcnQgb2YgdGhlIGNvZGUgdG8gaW5pdGlhdGUgdGhlIGRldmljZSByZW1vdmFsCisgKiBoYW5kc2hha2UgcHJvdG9jYWwgd2l0aCBjb250cm9sbGVyIGZpcm13YXJlLgorICogSXQgd2lsbCBzZW5kIGEgc2FzIGlvdW5pdCBjb250cm9sbCByZXF1ZXN0IChNUEkyX1NBU19PUF9SRU1PVkVfREVWSUNFKQorICoKKyAqIFJldHVybiAxIG1lYW5pbmcgbWYgc2hvdWxkIGJlIGZyZWVkIGZyb20gX2Jhc2VfaW50ZXJydXB0CisgKiAgICAgICAgMCBtZWFucyB0aGUgbWYgaXMgZnJlZWQgZnJvbSB0aGlzIGZ1bmN0aW9uLgorICovCitzdGF0aWMgdTgKK19zY3NpaF90bV90cl9jb21wbGV0ZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBtc2l4X2luZGV4LAorICAgIHUzMiByZXBseSkKK3sKKwl1bnNpZ25lZCBsb25nIGZsYWdzOworCXUxNiBoYW5kbGU7CisJc3RydWN0IF9zYXNfZGV2aWNlICpzYXNfZGV2aWNlOworCU1waTJTQ1NJVGFza01hbmFnZW1lbnRSZXBseV90ICptcGlfcmVwbHkgPQorCSAgICBtcHQyc2FzX2Jhc2VfZ2V0X3JlcGx5X3ZpcnRfYWRkcihpb2MsIHJlcGx5KTsKKwlNcGkyU2FzSW9Vbml0Q29udHJvbFJlcXVlc3RfdCAqbXBpX3JlcXVlc3Q7CisJdTE2IHNtaWRfc2FzX2N0cmw7CisJc3RydWN0IE1QVDJTQVNfVEFSR0VUICpzYXNfdGFyZ2V0X3ByaXZfZGF0YTsKKwlzdHJ1Y3QgX3RyX2xpc3QgKmRlbGF5ZWRfdHI7CisJdTggcmM7CisKKwloYW5kbGUgPSBsZTE2X3RvX2NwdShtcGlfcmVwbHktPkRldkhhbmRsZSk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2FzX2RldmljZV9sb2NrLCBmbGFncyk7CisJc2FzX2RldmljZSA9IF9zY3NpaF9zYXNfZGV2aWNlX2ZpbmRfYnlfaGFuZGxlKGlvYywgaGFuZGxlKTsKKwlpZiAoIXNhc19kZXZpY2UpIHsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaW9jLT5zYXNfZGV2aWNlX2xvY2ssIGZsYWdzKTsKKwkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiJXM6IGZhaWxlZCBmaW5kaW5nIHNhc19kZXZpY2VcbiIsCisJCSAgICBpb2MtPm5hbWUsIF9fZnVuY19fKTsKKwkJcmV0dXJuIDE7CisJfQorCXNhc19kZXZpY2UtPnN0YXRlIHw9IE1QVFNBU19TVEFURV9UUl9DT01QTEVURTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNhc19kZXZpY2VfbG9jaywgZmxhZ3MpOworCisJaWYgKHNhc19kZXZpY2UtPnN0YXJnZXQpCisJCWRld3RwcmludGsoaW9jLCBzdGFyZ2V0X3ByaW50ayhLRVJOX0lORk8sIHNhc19kZXZpY2UtPnN0YXJnZXQsCisJCSAgICAidHJfY29tcGxldGU6aGFuZGxlKDB4JTA0eCksICglcykgaW9jX3N0YXR1cygweCUwNHgpLCAiCisJCSAgICAibG9naW5mbygweCUwOHgpLCBjb21wbGV0ZWQoJWQpXG4iLAorCQkgICAgc2FzX2RldmljZS0+aGFuZGxlLCAoc2FzX2RldmljZS0+c3RhdGUgJgorCQkgICAgTVBUMlNBU19SRVFfU0FTX0NOVFJMKSA/ICJvcGVuIiA6ICJhY3RpdmUiLAorCQkgICAgbGUxNl90b19jcHUobXBpX3JlcGx5LT5JT0NTdGF0dXMpLAorCQkgICAgbGUzMl90b19jcHUobXBpX3JlcGx5LT5JT0NMb2dJbmZvKSwKKwkJICAgIGxlMzJfdG9fY3B1KG1waV9yZXBseS0+VGVybWluYXRpb25Db3VudCkpKTsKKworCWlmIChzYXNfZGV2aWNlLT5zdGFyZ2V0ICYmIHNhc19kZXZpY2UtPnN0YXJnZXQtPmhvc3RkYXRhKSB7CisJCXNhc190YXJnZXRfcHJpdl9kYXRhID0gc2FzX2RldmljZS0+c3RhcmdldC0+aG9zdGRhdGE7CisJCXNhc190YXJnZXRfcHJpdl9kYXRhLT50bV9idXN5ID0gMDsKKwl9CisKKwlpZiAoIWxpc3RfZW1wdHkoJmlvYy0+ZGVsYXllZF90cl9saXN0KSkgeworCQlkZWxheWVkX3RyID0gbGlzdF9lbnRyeShpb2MtPmRlbGF5ZWRfdHJfbGlzdC5uZXh0LAorCQkgICAgc3RydWN0IF90cl9saXN0LCBsaXN0KTsKKwkJbXB0MnNhc19iYXNlX2ZyZWVfc21pZChpb2MsIHNtaWQpOworCQlpZiAoZGVsYXllZF90ci0+c3RhdGUgJiBNUFQyU0FTX1JFUV9TQVNfQ05UUkwpCisJCQlfc2NzaWhfdG1fdHJfc2VuZChpb2MsIGRlbGF5ZWRfdHItPmhhbmRsZSk7CisJCWxpc3RfZGVsKCZkZWxheWVkX3RyLT5saXN0KTsKKwkJa2ZyZWUoZGVsYXllZF90cik7CisJCXJjID0gMDsgLyogdGVsbHMgYmFzZV9pbnRlcnJ1cHQgbm90IHRvIGZyZWUgbWYgKi8KKwl9IGVsc2UKKwkJcmMgPSAxOworCisKKwlpZiAoIShzYXNfZGV2aWNlLT5zdGF0ZSAmIE1QVDJTQVNfUkVRX1NBU19DTlRSTCkpCisJCXJldHVybiByYzsKKworCWlmIChpb2MtPnNob3N0X3JlY292ZXJ5KSB7CisJCXByaW50ayhNUFQyU0FTX0lORk9fRk1UICIlczogaG9zdCByZXNldCBpbiBwcm9ncmVzcyFcbiIsCisJCSAgICBfX2Z1bmNfXywgaW9jLT5uYW1lKTsKKwkJcmV0dXJuIHJjOworCX0KKworCXNtaWRfc2FzX2N0cmwgPSBtcHQyc2FzX2Jhc2VfZ2V0X3NtaWQoaW9jLCBpb2MtPnRtX3Nhc19jb250cm9sX2NiX2lkeCk7CisJaWYgKCFzbWlkX3Nhc19jdHJsKSB7CisJCXByaW50ayhNUFQyU0FTX0VSUl9GTVQgIiVzOiBmYWlsZWQgb2J0YWluaW5nIGEgc21pZFxuIiwKKwkJICAgIGlvYy0+bmFtZSwgX19mdW5jX18pOworCQlyZXR1cm4gcmM7CisJfQorCisJbXBpX3JlcXVlc3QgPSBtcHQyc2FzX2Jhc2VfZ2V0X21zZ19mcmFtZShpb2MsIHNtaWRfc2FzX2N0cmwpOworCW1lbXNldChtcGlfcmVxdWVzdCwgMCwgc2l6ZW9mKE1waTJTYXNJb1VuaXRDb250cm9sUmVxdWVzdF90KSk7CisJbXBpX3JlcXVlc3QtPkZ1bmN0aW9uID0gTVBJMl9GVU5DVElPTl9TQVNfSU9fVU5JVF9DT05UUk9MOworCW1waV9yZXF1ZXN0LT5PcGVyYXRpb24gPSBNUEkyX1NBU19PUF9SRU1PVkVfREVWSUNFOworCW1waV9yZXF1ZXN0LT5EZXZIYW5kbGUgPSBtcGlfcmVwbHktPkRldkhhbmRsZTsKKwlzYXNfZGV2aWNlLT5zdGF0ZSB8PSBNUFRTQVNfU1RBVEVfQ05UUkxfU0VORDsKKwltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfZGVmYXVsdChpb2MsIHNtaWRfc2FzX2N0cmwpOworCXJldHVybiByYzsKK30KKworLyoqCiAgKiBfc2NzaWhfY2hlY2tfdG9wb19kZWxldGVfZXZlbnRzIC0gc2FuaXR5IGNoZWNrIG9uIHRvcG8gZXZlbnRzCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBldmVudF9kYXRhOiB0aGUgZXZlbnQgZGF0YSBwYXlsb2FkCkBAIC0yMzc1LDYgKzI1NjMsMjEgQEAKIAl1MTYgZXhwYW5kZXJfaGFuZGxlOwogCXN0cnVjdCBfc2FzX25vZGUgKnNhc19leHBhbmRlcjsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOworCWludCBpLCByZWFzb25fY29kZTsKKwl1MTYgaGFuZGxlOworCisJZm9yIChpID0gMCA7IGkgPCBldmVudF9kYXRhLT5OdW1FbnRyaWVzOyBpKyspIHsKKwkJaWYgKGV2ZW50X2RhdGEtPlBIWVtpXS5QaHlTdGF0dXMgJgorCQkgICAgTVBJMl9FVkVOVF9TQVNfVE9QT19QSFlTVEFUVVNfVkFDQU5UKQorCQkJY29udGludWU7CisJCWhhbmRsZSA9IGxlMTZfdG9fY3B1KGV2ZW50X2RhdGEtPlBIWVtpXS5BdHRhY2hlZERldkhhbmRsZSk7CisJCWlmICghaGFuZGxlKQorCQkJY29udGludWU7CisJCXJlYXNvbl9jb2RlID0gZXZlbnRfZGF0YS0+UEhZW2ldLlBoeVN0YXR1cyAmCisJCSAgICBNUEkyX0VWRU5UX1NBU19UT1BPX1JDX01BU0s7CisJCWlmIChyZWFzb25fY29kZSA9PSBNUEkyX0VWRU5UX1NBU19UT1BPX1JDX1RBUkdfTk9UX1JFU1BPTkRJTkcpCisJCQlfc2NzaWhfdG1fdHJfc2VuZChpb2MsIGhhbmRsZSk7CisJfQogCiAJZXhwYW5kZXJfaGFuZGxlID0gbGUxNl90b19jcHUoZXZlbnRfZGF0YS0+RXhwYW5kZXJEZXZIYW5kbGUpOwogCWlmIChleHBhbmRlcl9oYW5kbGUgPCBpb2MtPnNhc19oYmEubnVtX3BoeXMpIHsKQEAgLTI0MzMsOCArMjYzNiw4IEBACiAJdTE2IHNtaWQ7CiAJdTE2IGNvdW50ID0gMDsKIAotCWZvciAoc21pZCA9IDE7IHNtaWQgPD0gaW9jLT5yZXF1ZXN0X2RlcHRoOyBzbWlkKyspIHsKLQkJc2NtZCA9IF9zY3NpaF9zY3NpX2xvb2t1cF9nZXRjbGVhcihpb2MsIHNtaWQpOworCWZvciAoc21pZCA9IDE7IHNtaWQgPD0gaW9jLT5zY3NpaW9fZGVwdGg7IHNtaWQrKykgeworCQlzY21kID0gX3Njc2loX3Njc2lfbG9va3VwX2dldChpb2MsIHNtaWQpOwogCQlpZiAoIXNjbWQpCiAJCQljb250aW51ZTsKIAkJY291bnQrKzsKQEAgLTI2MTYsNyArMjgxOSw3IEBACiAJaWYgKChzYXNfZGV2aWNlX3ByaXZfZGF0YS0+ZmxhZ3MgJiBNUFRfREVWSUNFX1RMUl9PTikpCiAJCW1waV9jb250cm9sIHw9IE1QSTJfU0NTSUlPX0NPTlRST0xfVExSX09OOwogCi0Jc21pZCA9IG1wdDJzYXNfYmFzZV9nZXRfc21pZChpb2MsIGlvYy0+c2NzaV9pb19jYl9pZHgpOworCXNtaWQgPSBtcHQyc2FzX2Jhc2VfZ2V0X3NtaWRfc2NzaWlvKGlvYywgaW9jLT5zY3NpX2lvX2NiX2lkeCwgc2NtZCk7CiAJaWYgKCFzbWlkKSB7CiAJCXByaW50ayhNUFQyU0FTX0VSUl9GTVQgIiVzOiBmYWlsZWQgb2J0YWluaW5nIGEgc21pZFxuIiwKIAkJICAgIGlvYy0+bmFtZSwgX19mdW5jX18pOwpAQCAtMjY0Myw3ICsyODQ2LDggQEAKIAltcGlfcmVxdWVzdC0+U0dMT2Zmc2V0MCA9IG9mZnNldG9mKE1waTJTQ1NJSU9SZXF1ZXN0X3QsIFNHTCkgLyA0OwogCW1waV9yZXF1ZXN0LT5TR0xGbGFncyA9IGNwdV90b19sZTE2KE1QSTJfU0NTSUlPX1NHTEZMQUdTX1RZUEVfTVBJICsKIAkgICAgTVBJMl9TQ1NJSU9fU0dMRkxBR1NfU1lTVEVNX0FERFIpOwotCisJbXBpX3JlcXVlc3QtPlZGX0lEID0gMDsgLyogVE9ETyAqLworCW1waV9yZXF1ZXN0LT5WUF9JRCA9IDA7CiAJaW50X3RvX3Njc2lsdW4oc2FzX2RldmljZV9wcml2X2RhdGEtPmx1biwgKHN0cnVjdCBzY3NpX2x1biAqKQogCSAgICBtcGlfcmVxdWVzdC0+TFVOKTsKIAltZW1jcHkobXBpX3JlcXVlc3QtPkNEQi5DREIzMiwgc2NtZC0+Y21uZCwgc2NtZC0+Y21kX2xlbik7CkBAIC0yNjU3LDggKzI4NjEsNyBAQAogCQl9CiAJfQogCi0JX3Njc2loX3Njc2lfbG9va3VwX3NldChpb2MsIHNtaWQsIHNjbWQpOwotCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9zY3NpX2lvKGlvYywgc21pZCwgMCwKKwltcHQyc2FzX2Jhc2VfcHV0X3NtaWRfc2NzaV9pbyhpb2MsIHNtaWQsCiAJICAgIHNhc19kZXZpY2VfcHJpdl9kYXRhLT5zYXNfdGFyZ2V0LT5oYW5kbGUpOwogCXJldHVybiAwOwogCkBAIC0yOTU0LDE1ICszMTU3LDE2IEBACiAgKiBfc2NzaWhfaW9fZG9uZSAtIHNjc2kgcmVxdWVzdCBjYWxsYmFjawogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0CiAgKiBAc21pZDogc3lzdGVtIHJlcXVlc3QgbWVzc2FnZSBpbmRleAotICogQFZGX0lEOiB2aXJ0dWFsIGZ1bmN0aW9uIGlkCisgKiBAbXNpeF9pbmRleDogTVNJWCB0YWJsZSBpbmRleCBzdXBwbGllZCBieSB0aGUgT1MKICAqIEByZXBseTogcmVwbHkgbWVzc2FnZSBmcmFtZShsb3dlciAzMmJpdCBhZGRyKQogICoKLSAqIENhbGxiYWNrIGhhbmRsZXIgd2hlbiB1c2luZyBzY3NpaF9xY21kLgorICogQ2FsbGJhY2sgaGFuZGxlciB3aGVuIHVzaW5nIF9zY3NpaF9xY21kLgogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXN0YXRpYyB2b2lkCi1fc2NzaWhfaW9fZG9uZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBWRl9JRCwgdTMyIHJlcGx5KQorc3RhdGljIHU4Citfc2NzaWhfaW9fZG9uZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBtc2l4X2luZGV4LCB1MzIgcmVwbHkpCiB7CiAJTXBpMlNDU0lJT1JlcXVlc3RfdCAqbXBpX3JlcXVlc3Q7CiAJTXBpMlNDU0lJT1JlcGx5X3QgKm1waV9yZXBseTsKQEAgLTI5NzYsOSArMzE4MCw5IEBACiAJdTMyIHJlc3BvbnNlX2NvZGU7CiAKIAltcGlfcmVwbHkgPSBtcHQyc2FzX2Jhc2VfZ2V0X3JlcGx5X3ZpcnRfYWRkcihpb2MsIHJlcGx5KTsKLQlzY21kID0gX3Njc2loX3Njc2lfbG9va3VwX2dldGNsZWFyKGlvYywgc21pZCk7CisJc2NtZCA9IF9zY3NpaF9zY3NpX2xvb2t1cF9nZXQoaW9jLCBzbWlkKTsKIAlpZiAoc2NtZCA9PSBOVUxMKQotCQlyZXR1cm47CisJCXJldHVybiAxOwogCiAJbXBpX3JlcXVlc3QgPSBtcHQyc2FzX2Jhc2VfZ2V0X21zZ19mcmFtZShpb2MsIHNtaWQpOwogCkBAIC0zMTM0LDYgKzMzMzgsNyBAQAogIG91dDoKIAlzY3NpX2RtYV91bm1hcChzY21kKTsKIAlzY21kLT5zY3NpX2RvbmUoc2NtZCk7CisJcmV0dXJuIDE7CiB9CiAKIC8qKgpAQCAtMzM5OCw5ICszNjAzLDggQEAKIAkJfQogCX0KIAotCXNhc19hZGRyZXNzID0gbGU2NF90b19jcHUoZXhwYW5kZXJfcGcwLlNBU0FkZHJlc3MpOwotCiAJc3Bpbl9sb2NrX2lycXNhdmUoJmlvYy0+c2FzX25vZGVfbG9jaywgZmxhZ3MpOworCXNhc19hZGRyZXNzID0gbGU2NF90b19jcHUoZXhwYW5kZXJfcGcwLlNBU0FkZHJlc3MpOwogCXNhc19leHBhbmRlciA9IG1wdDJzYXNfc2NzaWhfZXhwYW5kZXJfZmluZF9ieV9zYXNfYWRkcmVzcyhpb2MsCiAJICAgIHNhc19hZGRyZXNzKTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpb2MtPnNhc19ub2RlX2xvY2ssIGZsYWdzKTsKQEAgLTM2NjYsNiArMzg3MCwxMiBAQAogCWlmIChpb2MtPnJlbW92ZV9ob3N0KQogCQlnb3RvIG91dDsKIAorCWlmICgoc2FzX2RldmljZS0+c3RhdGUgJiBNUFRTQVNfU1RBVEVfVFJfQ09NUExFVEUpKSB7CisJCWRld3RwcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19JTkZPX0ZNVCAiXHRza2lwICIKKwkJICAgInRhcmdldF9yZXNldCBoYW5kbGUoMHglMDR4KVxuIiwgaW9jLT5uYW1lLCBoYW5kbGUpKTsKKwkJZ290byBza2lwX3RyOworCX0KKwogCS8qIFRhcmdldCBSZXNldCB0byBmbHVzaCBvdXQgYWxsIHRoZSBvdXRzdGFuZGluZyBJTyAqLwogCWRldmljZV9oYW5kbGUgPSAoc2FzX2RldmljZS0+aGlkZGVuX3JhaWRfY29tcG9uZW50KSA/CiAJICAgIHNhc19kZXZpY2UtPnZvbHVtZV9oYW5kbGUgOiBoYW5kbGU7CkBAIC0zNjgyLDYgKzM4OTIsMTMgQEAKIAkJaWYgKGlvYy0+c2hvc3RfcmVjb3ZlcnkpCiAJCQlnb3RvIG91dDsKIAl9Cisgc2tpcF90cjoKKworCWlmICgoc2FzX2RldmljZS0+c3RhdGUgJiBNUFRTQVNfU1RBVEVfQ05UUkxfQ09NUExFVEUpKSB7CisJCWRld3RwcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19JTkZPX0ZNVCAiXHRza2lwICIKKwkJICAgInNhc19jbnRybCBoYW5kbGUoMHglMDR4KVxuIiwgaW9jLT5uYW1lLCBoYW5kbGUpKTsKKwkJZ290byBvdXQ7CisJfQogCiAJLyogU0FTX0lPX1VOSVRfQ05UUiAtIHNlbmQgUkVNT1ZFX0RFVklDRSAqLwogCWRld3RwcmludGsoaW9jLCBwcmludGsoTVBUMlNBU19JTkZPX0ZNVCAic2FzX2lvdW5pdDogaGFuZGxlIgpAQCAtMzY5MCw3ICszOTA3LDggQEAKIAltcGlfcmVxdWVzdC5GdW5jdGlvbiA9IE1QSTJfRlVOQ1RJT05fU0FTX0lPX1VOSVRfQ09OVFJPTDsKIAltcGlfcmVxdWVzdC5PcGVyYXRpb24gPSBNUEkyX1NBU19PUF9SRU1PVkVfREVWSUNFOwogCW1waV9yZXF1ZXN0LkRldkhhbmRsZSA9IGhhbmRsZTsKLQltcGlfcmVxdWVzdC5WRl9JRCA9IDA7CisJbXBpX3JlcXVlc3QuVkZfSUQgPSAwOyAvKiBUT0RPICovCisJbXBpX3JlcXVlc3QuVlBfSUQgPSAwOwogCWlmICgobXB0MnNhc19iYXNlX3Nhc19pb3VuaXRfY29udHJvbChpb2MsICZtcGlfcmVwbHksCiAJICAgICZtcGlfcmVxdWVzdCkpICE9IDApIHsKIAkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiZmFpbHVyZSBhdCAlczolZC8lcygpIVxuIiwKQEAgLTM4MDAsMTUgKzQwMTgsMTIgQEAKIC8qKgogICogX3Njc2loX3Nhc190b3BvbG9neV9jaGFuZ2VfZXZlbnQgLSBoYW5kbGUgdG9wb2xvZ3kgY2hhbmdlcwogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0Ci0gKiBAVkZfSUQ6Ci0gKiBAZXZlbnRfZGF0YTogZXZlbnQgZGF0YSBwYXlsb2FkCi0gKiBmd19ldmVudDoKKyAqIEBmd19ldmVudDogVGhlIGZ3X2V2ZW50X3dvcmsgb2JqZWN0CiAgKiBDb250ZXh0OiB1c2VyLgogICoKICAqLwogc3RhdGljIHZvaWQKLV9zY3NpaF9zYXNfdG9wb2xvZ3lfY2hhbmdlX2V2ZW50KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTggVkZfSUQsCi0gICAgTXBpMkV2ZW50RGF0YVNhc1RvcG9sb2d5Q2hhbmdlTGlzdF90ICpldmVudF9kYXRhLAorX3Njc2loX3Nhc190b3BvbG9neV9jaGFuZ2VfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLAogICAgIHN0cnVjdCBmd19ldmVudF93b3JrICpmd19ldmVudCkKIHsKIAlpbnQgaTsKQEAgLTM4MTgsNiArNDAzMyw3IEBACiAJc3RydWN0IF9zYXNfbm9kZSAqc2FzX2V4cGFuZGVyOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdTggbGlua19yYXRlXzsKKwlNcGkyRXZlbnREYXRhU2FzVG9wb2xvZ3lDaGFuZ2VMaXN0X3QgKmV2ZW50X2RhdGEgPSBmd19ldmVudC0+ZXZlbnRfZGF0YTsKIAogI2lmZGVmIENPTkZJR19TQ1NJX01QVDJTQVNfTE9HR0lORwogCWlmIChpb2MtPmxvZ2dpbmdfbGV2ZWwgJiBNUFRfREVCVUdfRVZFTlRfV09SS19UQVNLKQpAQCAtMzg1MSwxNSArNDA2NywxNiBAQAogCQl9CiAJCWlmIChpb2MtPnNob3N0X3JlY292ZXJ5KQogCQkJcmV0dXJuOwotCQlpZiAoZXZlbnRfZGF0YS0+UEhZW2ldLlBoeVN0YXR1cyAmCi0JCSAgICBNUEkyX0VWRU5UX1NBU19UT1BPX1BIWVNUQVRVU19WQUNBTlQpCisJCXBoeV9udW1iZXIgPSBldmVudF9kYXRhLT5TdGFydFBoeU51bSArIGk7CisJCXJlYXNvbl9jb2RlID0gZXZlbnRfZGF0YS0+UEhZW2ldLlBoeVN0YXR1cyAmCisJCSAgICBNUEkyX0VWRU5UX1NBU19UT1BPX1JDX01BU0s7CisJCWlmICgoZXZlbnRfZGF0YS0+UEhZW2ldLlBoeVN0YXR1cyAmCisJCSAgICBNUEkyX0VWRU5UX1NBU19UT1BPX1BIWVNUQVRVU19WQUNBTlQpICYmIChyZWFzb25fY29kZSAhPQorCQkgICAgTVBJMl9FVkVOVF9TQVNfVE9QT19SQ19UQVJHX05PVF9SRVNQT05ESU5HKSkKIAkJCWNvbnRpbnVlOwogCQloYW5kbGUgPSBsZTE2X3RvX2NwdShldmVudF9kYXRhLT5QSFlbaV0uQXR0YWNoZWREZXZIYW5kbGUpOwogCQlpZiAoIWhhbmRsZSkKIAkJCWNvbnRpbnVlOwotCQlwaHlfbnVtYmVyID0gZXZlbnRfZGF0YS0+U3RhcnRQaHlOdW0gKyBpOwotCQlyZWFzb25fY29kZSA9IGV2ZW50X2RhdGEtPlBIWVtpXS5QaHlTdGF0dXMgJgotCQkgICAgTVBJMl9FVkVOVF9TQVNfVE9QT19SQ19NQVNLOwogCQlsaW5rX3JhdGVfID0gZXZlbnRfZGF0YS0+UEhZW2ldLkxpbmtSYXRlID4+IDQ7CiAJCXN3aXRjaCAocmVhc29uX2NvZGUpIHsKIAkJY2FzZSBNUEkyX0VWRU5UX1NBU19UT1BPX1JDX1BIWV9DSEFOR0VEOgpAQCAtMzk3MSwxOSArNDE4OCwxOSBAQAogLyoqCiAgKiBfc2NzaWhfc2FzX2RldmljZV9zdGF0dXNfY2hhbmdlX2V2ZW50IC0gaGFuZGxlIGRldmljZSBzdGF0dXMgY2hhbmdlCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBWRl9JRDoKLSAqIEBldmVudF9kYXRhOiBldmVudCBkYXRhIHBheWxvYWQKKyAqIEBmd19ldmVudDogVGhlIGZ3X2V2ZW50X3dvcmsgb2JqZWN0CiAgKiBDb250ZXh0OiB1c2VyLgogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiBzdGF0aWMgdm9pZAotX3Njc2loX3Nhc19kZXZpY2Vfc3RhdHVzX2NoYW5nZV9ldmVudChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IFZGX0lELAotICAgIE1waTJFdmVudERhdGFTYXNEZXZpY2VTdGF0dXNDaGFuZ2VfdCAqZXZlbnRfZGF0YSkKK19zY3NpaF9zYXNfZGV2aWNlX3N0YXR1c19jaGFuZ2VfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLAorICAgIHN0cnVjdCBmd19ldmVudF93b3JrICpmd19ldmVudCkKIHsKICNpZmRlZiBDT05GSUdfU0NTSV9NUFQyU0FTX0xPR0dJTkcKIAlpZiAoaW9jLT5sb2dnaW5nX2xldmVsICYgTVBUX0RFQlVHX0VWRU5UX1dPUktfVEFTSykKLQkJX3Njc2loX3Nhc19kZXZpY2Vfc3RhdHVzX2NoYW5nZV9ldmVudF9kZWJ1Zyhpb2MsIGV2ZW50X2RhdGEpOworCQlfc2NzaWhfc2FzX2RldmljZV9zdGF0dXNfY2hhbmdlX2V2ZW50X2RlYnVnKGlvYywKKwkJICAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CiAjZW5kaWYKIH0KIApAQCAtNDAyNiwzNCArNDI0MywzMyBAQAogLyoqCiAgKiBfc2NzaWhfc2FzX2VuY2xvc3VyZV9kZXZfc3RhdHVzX2NoYW5nZV9ldmVudCAtIGhhbmRsZSBlbmNsb3N1cmUgZXZlbnRzCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBWRl9JRDoKLSAqIEBldmVudF9kYXRhOiBldmVudCBkYXRhIHBheWxvYWQKKyAqIEBmd19ldmVudDogVGhlIGZ3X2V2ZW50X3dvcmsgb2JqZWN0CiAgKiBDb250ZXh0OiB1c2VyLgogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiBzdGF0aWMgdm9pZAogX3Njc2loX3Nhc19lbmNsb3N1cmVfZGV2X3N0YXR1c19jaGFuZ2VfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLAotICAgIHU4IFZGX0lELCBNcGkyRXZlbnREYXRhU2FzRW5jbERldlN0YXR1c0NoYW5nZV90ICpldmVudF9kYXRhKQorICAgIHN0cnVjdCBmd19ldmVudF93b3JrICpmd19ldmVudCkKIHsKICNpZmRlZiBDT05GSUdfU0NTSV9NUFQyU0FTX0xPR0dJTkcKIAlpZiAoaW9jLT5sb2dnaW5nX2xldmVsICYgTVBUX0RFQlVHX0VWRU5UX1dPUktfVEFTSykKIAkJX3Njc2loX3Nhc19lbmNsb3N1cmVfZGV2X3N0YXR1c19jaGFuZ2VfZXZlbnRfZGVidWcoaW9jLAotCQkgICAgIGV2ZW50X2RhdGEpOworCQkgICAgIGZ3X2V2ZW50LT5ldmVudF9kYXRhKTsKICNlbmRpZgogfQogCiAvKioKICAqIF9zY3NpaF9zYXNfYnJvYWRjYXN0X3ByaW1hdGl2ZV9ldmVudCAtIGhhbmRsZSBicm9hZGNhc3QgZXZlbnRzCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBldmVudF9kYXRhOiBldmVudCBkYXRhIHBheWxvYWQKKyAqIEBmd19ldmVudDogVGhlIGZ3X2V2ZW50X3dvcmsgb2JqZWN0CiAgKiBDb250ZXh0OiB1c2VyLgogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiBzdGF0aWMgdm9pZAotX3Njc2loX3Nhc19icm9hZGNhc3RfcHJpbWF0aXZlX2V2ZW50KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTggVkZfSUQsCi0gICAgTXBpMkV2ZW50RGF0YVNhc0Jyb2FkY2FzdFByaW1pdGl2ZV90ICpldmVudF9kYXRhKQorX3Njc2loX3Nhc19icm9hZGNhc3RfcHJpbWF0aXZlX2V2ZW50KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywKKyAgICBzdHJ1Y3QgZndfZXZlbnRfd29yayAqZndfZXZlbnQpCiB7CiAJc3RydWN0IHNjc2lfY21uZCAqc2NtZDsKIAl1MTYgc21pZCwgaGFuZGxlOwpAQCAtNDA2MiwxMSArNDI3OCwxMiBAQAogCXUzMiB0ZXJtaW5hdGlvbl9jb3VudDsKIAl1MzIgcXVlcnlfY291bnQ7CiAJTXBpMlNDU0lUYXNrTWFuYWdlbWVudFJlcGx5X3QgKm1waV9yZXBseTsKLQorI2lmZGVmIENPTkZJR19TQ1NJX01QVDJTQVNfTE9HR0lORworCU1waTJFdmVudERhdGFTYXNCcm9hZGNhc3RQcmltaXRpdmVfdCAqZXZlbnRfZGF0YSA9IGZ3X2V2ZW50LT5ldmVudF9kYXRhOworI2VuZGlmCiAJZGV3dHByaW50ayhpb2MsIHByaW50ayhNUFQyU0FTX0RFQlVHX0ZNVCAiYnJvYWRjYXN0IHByaW1hdGl2ZTogIgogCSAgICAicGh5IG51bWJlciglZCksIHdpZHRoKCVkKVxuIiwgaW9jLT5uYW1lLCBldmVudF9kYXRhLT5QaHlOdW0sCiAJICAgIGV2ZW50X2RhdGEtPlBvcnRXaWR0aCkpOwotCiAJZHRtcHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfREVCVUdfRk1UICIlczogZW50ZXJcbiIsIGlvYy0+bmFtZSwKIAkgICAgX19mdW5jX18pKTsKIApAQCAtNDA3NCw3ICs0MjkxLDcgQEAKIAl0ZXJtaW5hdGlvbl9jb3VudCA9IDA7CiAJcXVlcnlfY291bnQgPSAwOwogCW1waV9yZXBseSA9IGlvYy0+dG1fY21kcy5yZXBseTsKLQlmb3IgKHNtaWQgPSAxOyBzbWlkIDw9IGlvYy0+cmVxdWVzdF9kZXB0aDsgc21pZCsrKSB7CisJZm9yIChzbWlkID0gMTsgc21pZCA8PSBpb2MtPnNjc2lpb19kZXB0aDsgc21pZCsrKSB7CiAJCXNjbWQgPSBfc2NzaWhfc2NzaV9sb29rdXBfZ2V0KGlvYywgc21pZCk7CiAJCWlmICghc2NtZCkKIAkJCWNvbnRpbnVlOwpAQCAtNDEyMSwyMyArNDMzOCwyNSBAQAogLyoqCiAgKiBfc2NzaWhfc2FzX2Rpc2NvdmVyeV9ldmVudCAtIGhhbmRsZSBkaXNjb3ZlcnkgZXZlbnRzCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBldmVudF9kYXRhOiBldmVudCBkYXRhIHBheWxvYWQKKyAqIEBmd19ldmVudDogVGhlIGZ3X2V2ZW50X3dvcmsgb2JqZWN0CiAgKiBDb250ZXh0OiB1c2VyLgogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiBzdGF0aWMgdm9pZAotX3Njc2loX3Nhc19kaXNjb3ZlcnlfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwKLSAgICBNcGkyRXZlbnREYXRhU2FzRGlzY292ZXJ5X3QgKmV2ZW50X2RhdGEpCitfc2NzaWhfc2FzX2Rpc2NvdmVyeV9ldmVudChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsCisgICAgc3RydWN0IGZ3X2V2ZW50X3dvcmsgKmZ3X2V2ZW50KQogeworCU1waTJFdmVudERhdGFTYXNEaXNjb3ZlcnlfdCAqZXZlbnRfZGF0YSA9IGZ3X2V2ZW50LT5ldmVudF9kYXRhOworCiAjaWZkZWYgQ09ORklHX1NDU0lfTVBUMlNBU19MT0dHSU5HCiAJaWYgKGlvYy0+bG9nZ2luZ19sZXZlbCAmIE1QVF9ERUJVR19FVkVOVF9XT1JLX1RBU0spIHsKIAkJcHJpbnRrKE1QVDJTQVNfREVCVUdfRk1UICJkaXNjb3ZlcnkgZXZlbnQ6ICglcykiLCBpb2MtPm5hbWUsCiAJCSAgICAoZXZlbnRfZGF0YS0+UmVhc29uQ29kZSA9PSBNUEkyX0VWRU5UX1NBU19ESVNDX1JDX1NUQVJURUQpID8KIAkJICAgICJzdGFydCIgOiAic3RvcCIpOwogCWlmIChldmVudF9kYXRhLT5EaXNjb3ZlcnlTdGF0dXMpCi0JCXByaW50ayhNUFQyU0FTX0RFQlVHX0ZNVCAiLCBkaXNjb3Zlcnlfc3RhdHVzKDB4JTA4eCkiLAotCQkgICAgaW9jLT5uYW1lLCBsZTMyX3RvX2NwdShldmVudF9kYXRhLT5EaXNjb3ZlcnlTdGF0dXMpKTsKKwkJcHJpbnRrKCJkaXNjb3Zlcnlfc3RhdHVzKDB4JTA4eCkiLAorCQkgICAgbGUzMl90b19jcHUoZXZlbnRfZGF0YS0+RGlzY292ZXJ5U3RhdHVzKSk7CiAJcHJpbnRrKCJcbiIpOwogCX0KICNlbmRpZgpAQCAtNDQ4OCwxOSArNDcwNywxOSBAQAogLyoqCiAgKiBfc2NzaWhfc2FzX2lyX2NvbmZpZ19jaGFuZ2VfZXZlbnQgLSBoYW5kbGUgaXIgY29uZmlndXJhdGlvbiBjaGFuZ2UgZXZlbnRzCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBWRl9JRDoKLSAqIEBldmVudF9kYXRhOiBldmVudCBkYXRhIHBheWxvYWQKKyAqIEBmd19ldmVudDogVGhlIGZ3X2V2ZW50X3dvcmsgb2JqZWN0CiAgKiBDb250ZXh0OiB1c2VyLgogICoKICAqIFJldHVybiBub3RoaW5nLgogICovCiBzdGF0aWMgdm9pZAotX3Njc2loX3Nhc19pcl9jb25maWdfY2hhbmdlX2V2ZW50KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgdTggVkZfSUQsCi0gICAgTXBpMkV2ZW50RGF0YUlyQ29uZmlnQ2hhbmdlTGlzdF90ICpldmVudF9kYXRhKQorX3Njc2loX3Nhc19pcl9jb25maWdfY2hhbmdlX2V2ZW50KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywKKyAgICBzdHJ1Y3QgZndfZXZlbnRfd29yayAqZndfZXZlbnQpCiB7CiAJTXBpMkV2ZW50SXJDb25maWdFbGVtZW50X3QgKmVsZW1lbnQ7CiAJaW50IGk7CiAJdTggZm9yZWlnbl9jb25maWc7CisJTXBpMkV2ZW50RGF0YUlyQ29uZmlnQ2hhbmdlTGlzdF90ICpldmVudF9kYXRhID0gZndfZXZlbnQtPmV2ZW50X2RhdGE7CiAKICNpZmRlZiBDT05GSUdfU0NTSV9NUFQyU0FTX0xPR0dJTkcKIAlpZiAoaW9jLT5sb2dnaW5nX2xldmVsICYgTVBUX0RFQlVHX0VWRU5UX1dPUktfVEFTSykKQEAgLTQ1NDMsMTQgKzQ3NjIsMTQgQEAKIC8qKgogICogX3Njc2loX3Nhc19pcl92b2x1bWVfZXZlbnQgLSBJUiB2b2x1bWUgZXZlbnQKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAotICogQGV2ZW50X2RhdGE6IGV2ZW50IGRhdGEgcGF5bG9hZAorICogQGZ3X2V2ZW50OiBUaGUgZndfZXZlbnRfd29yayBvYmplY3QKICAqIENvbnRleHQ6IHVzZXIuCiAgKgogICogUmV0dXJuIG5vdGhpbmcuCiAgKi8KIHN0YXRpYyB2b2lkCi1fc2NzaWhfc2FzX2lyX3ZvbHVtZV9ldmVudChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHU4IFZGX0lELAotICAgIE1waTJFdmVudERhdGFJclZvbHVtZV90ICpldmVudF9kYXRhKQorX3Njc2loX3Nhc19pcl92b2x1bWVfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLAorICAgIHN0cnVjdCBmd19ldmVudF93b3JrICpmd19ldmVudCkKIHsKIAl1NjQgd3dpZDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwpAQCAtNDU1OSw2ICs0Nzc4LDcgQEAKIAl1MzIgc3RhdGU7CiAJaW50IHJjOwogCXN0cnVjdCBNUFQyU0FTX1RBUkdFVCAqc2FzX3RhcmdldF9wcml2X2RhdGE7CisJTXBpMkV2ZW50RGF0YUlyVm9sdW1lX3QgKmV2ZW50X2RhdGEgPSBmd19ldmVudC0+ZXZlbnRfZGF0YTsKIAogCWlmIChldmVudF9kYXRhLT5SZWFzb25Db2RlICE9IE1QSTJfRVZFTlRfSVJfVk9MVU1FX1JDX1NUQVRFX0NIQU5HRUQpCiAJCXJldHVybjsKQEAgLTQ2MjgsMTQgKzQ4NDgsMTQgQEAKIC8qKgogICogX3Njc2loX3Nhc19pcl9waHlzaWNhbF9kaXNrX2V2ZW50IC0gUEQgZXZlbnQKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAotICogQGV2ZW50X2RhdGE6IGV2ZW50IGRhdGEgcGF5bG9hZAorICogQGZ3X2V2ZW50OiBUaGUgZndfZXZlbnRfd29yayBvYmplY3QKICAqIENvbnRleHQ6IHVzZXIuCiAgKgogICogUmV0dXJuIG5vdGhpbmcuCiAgKi8KIHN0YXRpYyB2b2lkCi1fc2NzaWhfc2FzX2lyX3BoeXNpY2FsX2Rpc2tfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwKLSAgIE1waTJFdmVudERhdGFJclBoeXNpY2FsRGlza190ICpldmVudF9kYXRhKQorX3Njc2loX3Nhc19pcl9waHlzaWNhbF9kaXNrX2V2ZW50KHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywKKyAgICBzdHJ1Y3QgZndfZXZlbnRfd29yayAqZndfZXZlbnQpCiB7CiAJdTE2IGhhbmRsZTsKIAl1MzIgc3RhdGU7CkBAIC00NjQ0LDYgKzQ4NjQsNyBAQAogCU1waTJDb25maWdSZXBseV90IG1waV9yZXBseTsKIAlNcGkyU2FzRGV2aWNlUGFnZTBfdCBzYXNfZGV2aWNlX3BnMDsKIAl1MzIgaW9jX3N0YXR1czsKKwlNcGkyRXZlbnREYXRhSXJQaHlzaWNhbERpc2tfdCAqZXZlbnRfZGF0YSA9IGZ3X2V2ZW50LT5ldmVudF9kYXRhOwogCiAJaWYgKGV2ZW50X2RhdGEtPlJlYXNvbkNvZGUgIT0gTVBJMl9FVkVOVF9JUl9QSFlTRElTS19SQ19TVEFURV9DSEFOR0VEKQogCQlyZXR1cm47CkBAIC00NzQzLDMzICs0OTY0LDMzIEBACiAvKioKICAqIF9zY3NpaF9zYXNfaXJfb3BlcmF0aW9uX3N0YXR1c19ldmVudCAtIGhhbmRsZSBSQUlEIG9wZXJhdGlvbiBldmVudHMKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAotICogQFZGX0lEOgotICogQGV2ZW50X2RhdGE6IGV2ZW50IGRhdGEgcGF5bG9hZAorICogQGZ3X2V2ZW50OiBUaGUgZndfZXZlbnRfd29yayBvYmplY3QKICAqIENvbnRleHQ6IHVzZXIuCiAgKgogICogUmV0dXJuIG5vdGhpbmcuCiAgKi8KIHN0YXRpYyB2b2lkCi1fc2NzaWhfc2FzX2lyX29wZXJhdGlvbl9zdGF0dXNfZXZlbnQoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwKLSAgICBNcGkyRXZlbnREYXRhSXJPcGVyYXRpb25TdGF0dXNfdCAqZXZlbnRfZGF0YSkKK19zY3NpaF9zYXNfaXJfb3BlcmF0aW9uX3N0YXR1c19ldmVudChzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsCisgICAgc3RydWN0IGZ3X2V2ZW50X3dvcmsgKmZ3X2V2ZW50KQogewogI2lmZGVmIENPTkZJR19TQ1NJX01QVDJTQVNfTE9HR0lORwogCWlmIChpb2MtPmxvZ2dpbmdfbGV2ZWwgJiBNUFRfREVCVUdfRVZFTlRfV09SS19UQVNLKQotCQlfc2NzaWhfc2FzX2lyX29wZXJhdGlvbl9zdGF0dXNfZXZlbnRfZGVidWcoaW9jLCBldmVudF9kYXRhKTsKKwkJX3Njc2loX3Nhc19pcl9vcGVyYXRpb25fc3RhdHVzX2V2ZW50X2RlYnVnKGlvYywKKwkJICAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CiAjZW5kaWYKIH0KIAogLyoqCiAgKiBfc2NzaWhfdGFza19zZXRfZnVsbCAtIGhhbmRsZSB0YXNrIHNldCBmdWxsCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKLSAqIEBldmVudF9kYXRhOiBldmVudCBkYXRhIHBheWxvYWQKKyAqIEBmd19ldmVudDogVGhlIGZ3X2V2ZW50X3dvcmsgb2JqZWN0CiAgKiBDb250ZXh0OiB1c2VyLgogICoKICAqIFRocm90dGxlIGJhY2sgcWRlcHRoLgogICovCiBzdGF0aWMgdm9pZAotX3Njc2loX3Rhc2tfc2V0X2Z1bGwoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwKLSAgICBNcGkyRXZlbnREYXRhVGFza1NldEZ1bGxfdCAqZXZlbnRfZGF0YSkKK19zY3NpaF90YXNrX3NldF9mdWxsKHN0cnVjdCBNUFQyU0FTX0FEQVBURVIgKmlvYywgc3RydWN0IGZ3X2V2ZW50X3dvcmsKKwkqZndfZXZlbnQpCiB7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAlzdHJ1Y3QgX3Nhc19kZXZpY2UgKnNhc19kZXZpY2U7CkBAIC00NzgwLDYgKzUwMDEsNyBAQAogCXUxNiBoYW5kbGU7CiAJaW50IGlkLCBjaGFubmVsOwogCXU2NCBzYXNfYWRkcmVzczsKKwlNcGkyRXZlbnREYXRhVGFza1NldEZ1bGxfdCAqZXZlbnRfZGF0YSA9IGZ3X2V2ZW50LT5ldmVudF9kYXRhOwogCiAJY3VycmVudF9kZXB0aCA9IGxlMTZfdG9fY3B1KGV2ZW50X2RhdGEtPkN1cnJlbnREZXB0aCk7CiAJaGFuZGxlID0gbGUxNl90b19jcHUoZXZlbnRfZGF0YS0+RGV2SGFuZGxlKTsKQEAgLTQ4NjgsNiArNTA5MCwxMCBAQAogCQlpZiAoc2FzX2RldmljZS0+c2FzX2FkZHJlc3MgPT0gc2FzX2FkZHJlc3MgJiYKIAkJICAgIHNhc19kZXZpY2UtPnNsb3QgPT0gc2xvdCAmJiBzYXNfZGV2aWNlLT5zdGFyZ2V0KSB7CiAJCQlzYXNfZGV2aWNlLT5yZXNwb25kaW5nID0gMTsKKwkJCXNhc19kZXZpY2UtPnN0YXRlID0gMDsKKwkJCXN0YXJnZXQgPSBzYXNfZGV2aWNlLT5zdGFyZ2V0OworCQkJc2FzX3RhcmdldF9wcml2X2RhdGEgPSBzdGFyZ2V0LT5ob3N0ZGF0YTsKKwkJCXNhc190YXJnZXRfcHJpdl9kYXRhLT50bV9idXN5ID0gMDsKIAkJCXN0YXJnZXRfcHJpbnRrKEtFUk5fSU5GTywgc2FzX2RldmljZS0+c3RhcmdldCwKIAkJCSAgICAiaGFuZGxlKDB4JTA0eCksIHNhc19hZGRyKDB4JTAxNmxseCksIGVuY2xvc3VyZSAiCiAJCQkgICAgImxvZ2ljYWwgaWQoMHglMDE2bGx4KSwgc2xvdCglZClcbiIsIGhhbmRsZSwKQEAgLTQ4ODAsOCArNTEwNiw2IEBACiAJCQlwcmludGsoS0VSTl9JTkZPICJcdGhhbmRsZSBjaGFuZ2VkIGZyb20oMHglMDR4KSEhIVxuIiwKIAkJCSAgICBzYXNfZGV2aWNlLT5oYW5kbGUpOwogCQkJc2FzX2RldmljZS0+aGFuZGxlID0gaGFuZGxlOwotCQkJc3RhcmdldCA9IHNhc19kZXZpY2UtPnN0YXJnZXQ7Ci0JCQlzYXNfdGFyZ2V0X3ByaXZfZGF0YSA9IHN0YXJnZXQtPmhvc3RkYXRhOwogCQkJc2FzX3RhcmdldF9wcml2X2RhdGEtPmhhbmRsZSA9IGhhbmRsZTsKIAkJCWdvdG8gb3V0OwogCQl9CkBAIC01MjI3LDQ0ICs1NDUxLDM4IEBACiAKIAlzd2l0Y2ggKGZ3X2V2ZW50LT5ldmVudCkgewogCWNhc2UgTVBJMl9FVkVOVF9TQVNfVE9QT0xPR1lfQ0hBTkdFX0xJU1Q6Ci0JCV9zY3NpaF9zYXNfdG9wb2xvZ3lfY2hhbmdlX2V2ZW50KGlvYywgZndfZXZlbnQtPlZGX0lELAotCQkgICAgZndfZXZlbnQtPmV2ZW50X2RhdGEsIGZ3X2V2ZW50KTsKKwkJX3Njc2loX3Nhc190b3BvbG9neV9jaGFuZ2VfZXZlbnQoaW9jLCBmd19ldmVudCk7CiAJCWJyZWFrOwogCWNhc2UgTVBJMl9FVkVOVF9TQVNfREVWSUNFX1NUQVRVU19DSEFOR0U6Ci0JCV9zY3NpaF9zYXNfZGV2aWNlX3N0YXR1c19jaGFuZ2VfZXZlbnQoaW9jLCBmd19ldmVudC0+VkZfSUQsCi0JCSAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CisJCV9zY3NpaF9zYXNfZGV2aWNlX3N0YXR1c19jaGFuZ2VfZXZlbnQoaW9jLAorCQkgICAgZndfZXZlbnQpOwogCQlicmVhazsKIAljYXNlIE1QSTJfRVZFTlRfU0FTX0RJU0NPVkVSWToKLQkJX3Njc2loX3Nhc19kaXNjb3ZlcnlfZXZlbnQoaW9jLCBmd19ldmVudC0+VkZfSUQsCi0JCSAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CisJCV9zY3NpaF9zYXNfZGlzY292ZXJ5X2V2ZW50KGlvYywKKwkJICAgIGZ3X2V2ZW50KTsKIAkJYnJlYWs7CiAJY2FzZSBNUEkyX0VWRU5UX1NBU19CUk9BRENBU1RfUFJJTUlUSVZFOgotCQlfc2NzaWhfc2FzX2Jyb2FkY2FzdF9wcmltYXRpdmVfZXZlbnQoaW9jLCBmd19ldmVudC0+VkZfSUQsCi0JCSAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CisJCV9zY3NpaF9zYXNfYnJvYWRjYXN0X3ByaW1hdGl2ZV9ldmVudChpb2MsCisJCSAgICBmd19ldmVudCk7CiAJCWJyZWFrOwogCWNhc2UgTVBJMl9FVkVOVF9TQVNfRU5DTF9ERVZJQ0VfU1RBVFVTX0NIQU5HRToKIAkJX3Njc2loX3Nhc19lbmNsb3N1cmVfZGV2X3N0YXR1c19jaGFuZ2VfZXZlbnQoaW9jLAotCQkgICAgZndfZXZlbnQtPlZGX0lELCBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CisJCSAgICBmd19ldmVudCk7CiAJCWJyZWFrOwogCWNhc2UgTVBJMl9FVkVOVF9JUl9DT05GSUdVUkFUSU9OX0NIQU5HRV9MSVNUOgotCQlfc2NzaWhfc2FzX2lyX2NvbmZpZ19jaGFuZ2VfZXZlbnQoaW9jLCBmd19ldmVudC0+VkZfSUQsCi0JCSAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CisJCV9zY3NpaF9zYXNfaXJfY29uZmlnX2NoYW5nZV9ldmVudChpb2MsIGZ3X2V2ZW50KTsKIAkJYnJlYWs7CiAJY2FzZSBNUEkyX0VWRU5UX0lSX1ZPTFVNRToKLQkJX3Njc2loX3Nhc19pcl92b2x1bWVfZXZlbnQoaW9jLCBmd19ldmVudC0+VkZfSUQsCi0JCSAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CisJCV9zY3NpaF9zYXNfaXJfdm9sdW1lX2V2ZW50KGlvYywgZndfZXZlbnQpOwogCQlicmVhazsKIAljYXNlIE1QSTJfRVZFTlRfSVJfUEhZU0lDQUxfRElTSzoKLQkJX3Njc2loX3Nhc19pcl9waHlzaWNhbF9kaXNrX2V2ZW50KGlvYywgZndfZXZlbnQtPlZGX0lELAotCQkgICAgZndfZXZlbnQtPmV2ZW50X2RhdGEpOworCQlfc2NzaWhfc2FzX2lyX3BoeXNpY2FsX2Rpc2tfZXZlbnQoaW9jLCBmd19ldmVudCk7CiAJCWJyZWFrOwogCWNhc2UgTVBJMl9FVkVOVF9JUl9PUEVSQVRJT05fU1RBVFVTOgotCQlfc2NzaWhfc2FzX2lyX29wZXJhdGlvbl9zdGF0dXNfZXZlbnQoaW9jLCBmd19ldmVudC0+VkZfSUQsCi0JCSAgICBmd19ldmVudC0+ZXZlbnRfZGF0YSk7CisJCV9zY3NpaF9zYXNfaXJfb3BlcmF0aW9uX3N0YXR1c19ldmVudChpb2MsIGZ3X2V2ZW50KTsKIAkJYnJlYWs7CiAJY2FzZSBNUEkyX0VWRU5UX1RBU0tfU0VUX0ZVTEw6Ci0JCV9zY3NpaF90YXNrX3NldF9mdWxsKGlvYywgZndfZXZlbnQtPlZGX0lELAotCQkgICAgZndfZXZlbnQtPmV2ZW50X2RhdGEpOworCQlfc2NzaWhfdGFza19zZXRfZnVsbChpb2MsIGZ3X2V2ZW50KTsKIAkJYnJlYWs7CiAJfQogCV9zY3NpaF9md19ldmVudF9mcmVlKGlvYywgZndfZXZlbnQpOwpAQCAtNTI3MywxNyArNTQ5MSwxOSBAQAogLyoqCiAgKiBtcHQyc2FzX3Njc2loX2V2ZW50X2NhbGxiYWNrIC0gZmlybXdhcmUgZXZlbnQgaGFuZGxlciAoY2FsbGVkIGF0IElTUiB0aW1lKQogICogQGlvYzogcGVyIGFkYXB0ZXIgb2JqZWN0Ci0gKiBAVkZfSUQ6IHZpcnR1YWwgZnVuY3Rpb24gaWQKKyAqIEBtc2l4X2luZGV4OiBNU0lYIHRhYmxlIGluZGV4IHN1cHBsaWVkIGJ5IHRoZSBPUwogICogQHJlcGx5OiByZXBseSBtZXNzYWdlIGZyYW1lKGxvd2VyIDMyYml0IGFkZHIpCiAgKiBDb250ZXh0OiBpbnRlcnJ1cHQuCiAgKgogICogVGhpcyBmdW5jdGlvbiBtZXJlbHkgYWRkcyBhIG5ldyB3b3JrIHRhc2sgaW50byBpb2MtPmZpcm13YXJlX2V2ZW50X3RocmVhZC4KICAqIFRoZSB0YXNrcyBhcmUgd29ya2VkIGZyb20gX2Zpcm13YXJlX2V2ZW50X3dvcmsgaW4gdXNlciBjb250ZXh0LgogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXZvaWQKLW1wdDJzYXNfc2NzaWhfZXZlbnRfY2FsbGJhY2soc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBWRl9JRCwgdTMyIHJlcGx5KQordTgKK21wdDJzYXNfc2NzaWhfZXZlbnRfY2FsbGJhY2soc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1OCBtc2l4X2luZGV4LAorCXUzMiByZXBseSkKIHsKIAlzdHJ1Y3QgZndfZXZlbnRfd29yayAqZndfZXZlbnQ7CiAJTXBpMkV2ZW50Tm90aWZpY2F0aW9uUmVwbHlfdCAqbXBpX3JlcGx5OwpAQCAtNTI5NCwxMSArNTUxNCwxMSBAQAogCXNwaW5fbG9ja19pcnFzYXZlKCZpb2MtPmZ3X2V2ZW50X2xvY2ssIGZsYWdzKTsKIAlpZiAoaW9jLT5md19ldmVudHNfb2ZmIHx8IGlvYy0+cmVtb3ZlX2hvc3QpIHsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaW9jLT5md19ldmVudF9sb2NrLCBmbGFncyk7Ci0JCXJldHVybjsKKwkJcmV0dXJuIDE7CiAJfQogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmlvYy0+ZndfZXZlbnRfbG9jaywgZmxhZ3MpOwogCi0JbXBpX3JlcGx5ID0gIG1wdDJzYXNfYmFzZV9nZXRfcmVwbHlfdmlydF9hZGRyKGlvYywgcmVwbHkpOworCW1waV9yZXBseSA9IG1wdDJzYXNfYmFzZV9nZXRfcmVwbHlfdmlydF9hZGRyKGlvYywgcmVwbHkpOwogCWV2ZW50ID0gbGUxNl90b19jcHUobXBpX3JlcGx5LT5FdmVudCk7CiAKIAlzd2l0Y2ggKGV2ZW50KSB7CkBAIC01MzEyLDcgKzU1MzIsNyBAQAogCQlpZiAoYmFlbl9kYXRhLT5QcmltaXRpdmUgIT0KIAkJICAgIE1QSTJfRVZFTlRfUFJJTUlUSVZFX0FTWU5DSFJPTk9VU19FVkVOVCB8fAogCQkgICAgaW9jLT5icm9hZGNhc3RfYWVuX2J1c3kpCi0JCQlyZXR1cm47CisJCQlyZXR1cm4gMTsKIAkJaW9jLT5icm9hZGNhc3RfYWVuX2J1c3kgPSAxOwogCQlicmVhazsKIAl9CkBAIC01MzM0LDE0ICs1NTU0LDE0IEBACiAJCWJyZWFrOwogCiAJZGVmYXVsdDogLyogaWdub3JlIHRoZSByZXN0ICovCi0JCXJldHVybjsKKwkJcmV0dXJuIDE7CiAJfQogCiAJZndfZXZlbnQgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZndfZXZlbnRfd29yayksIEdGUF9BVE9NSUMpOwogCWlmICghZndfZXZlbnQpIHsKIAkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiZmFpbHVyZSBhdCAlczolZC8lcygpIVxuIiwKIAkJICAgIGlvYy0+bmFtZSwgX19GSUxFX18sIF9fTElORV9fLCBfX2Z1bmNfXyk7Ci0JCXJldHVybjsKKwkJcmV0dXJuIDE7CiAJfQogCWZ3X2V2ZW50LT5ldmVudF9kYXRhID0KIAkgICAga3phbGxvYyhtcGlfcmVwbHktPkV2ZW50RGF0YUxlbmd0aCo0LCBHRlBfQVRPTUlDKTsKQEAgLTUzNDksMTUgKzU1NjksMTcgQEAKIAkJcHJpbnRrKE1QVDJTQVNfRVJSX0ZNVCAiZmFpbHVyZSBhdCAlczolZC8lcygpIVxuIiwKIAkJICAgIGlvYy0+bmFtZSwgX19GSUxFX18sIF9fTElORV9fLCBfX2Z1bmNfXyk7CiAJCWtmcmVlKGZ3X2V2ZW50KTsKLQkJcmV0dXJuOworCQlyZXR1cm4gMTsKIAl9CiAKIAltZW1jcHkoZndfZXZlbnQtPmV2ZW50X2RhdGEsIG1waV9yZXBseS0+RXZlbnREYXRhLAogCSAgICBtcGlfcmVwbHktPkV2ZW50RGF0YUxlbmd0aCo0KTsKIAlmd19ldmVudC0+aW9jID0gaW9jOwotCWZ3X2V2ZW50LT5WRl9JRCA9IFZGX0lEOworCWZ3X2V2ZW50LT5WRl9JRCA9IG1waV9yZXBseS0+VkZfSUQ7CisJZndfZXZlbnQtPlZQX0lEID0gbXBpX3JlcGx5LT5WUF9JRDsKIAlmd19ldmVudC0+ZXZlbnQgPSBldmVudDsKIAlfc2NzaWhfZndfZXZlbnRfYWRkKGlvYywgZndfZXZlbnQpOworCXJldHVybiAxOwogfQogCiAvKiBzaG9zdCB0ZW1wbGF0ZSAqLwpAQCAtNTYxNyw3ICs1ODM5LDcgQEAKIH0KIAogLyoqCi0gKiBfc2NzaWhfcHJvYmVfc2FzIC0gcmVwb3J0aW5nIHJhaWQgdm9sdW1lcyB0byBzYXMgdHJhbnNwb3J0CisgKiBfc2NzaWhfcHJvYmVfc2FzIC0gcmVwb3J0aW5nIHNhcyBkZXZpY2VzIHRvIHNhcyB0cmFuc3BvcnQKICAqIEBpb2M6IHBlciBhZGFwdGVyIG9iamVjdAogICoKICAqIENhbGxlZCBkdXJpbmcgaW5pdGlhbCBsb2FkaW5nIG9mIHRoZSBkcml2ZXIuCkBAIC01NzE0LDYgKzU5MzYsOCBAQAogCWlvYy0+YmFzZV9jYl9pZHggPSBiYXNlX2NiX2lkeDsKIAlpb2MtPnRyYW5zcG9ydF9jYl9pZHggPSB0cmFuc3BvcnRfY2JfaWR4OwogCWlvYy0+Y29uZmlnX2NiX2lkeCA9IGNvbmZpZ19jYl9pZHg7CisJaW9jLT50bV90cl9jYl9pZHggPSB0bV90cl9jYl9pZHg7CisJaW9jLT50bV9zYXNfY29udHJvbF9jYl9pZHggPSB0bV9zYXNfY29udHJvbF9jYl9pZHg7CiAJaW9jLT5sb2dnaW5nX2xldmVsID0gbG9nZ2luZ19sZXZlbDsKIAkvKiBtaXNjIHNlbWFwaG9yZXMgYW5kIHNwaW4gbG9ja3MgKi8KIAlzcGluX2xvY2tfaW5pdCgmaW9jLT5pb2NfcmVzZXRfaW5fcHJvZ3Jlc3NfbG9jayk7CkBAIC01NzI5LDYgKzU5NTMsNyBAQAogCUlOSVRfTElTVF9IRUFEKCZpb2MtPmZ3X2V2ZW50X2xpc3QpOwogCUlOSVRfTElTVF9IRUFEKCZpb2MtPnJhaWRfZGV2aWNlX2xpc3QpOwogCUlOSVRfTElTVF9IRUFEKCZpb2MtPnNhc19oYmEuc2FzX3BvcnRfbGlzdCk7CisJSU5JVF9MSVNUX0hFQUQoJmlvYy0+ZGVsYXllZF90cl9saXN0KTsKIAogCS8qIGluaXQgc2hvc3QgcGFyYW1ldGVycyAqLwogCXNob3N0LT5tYXhfY21kX2xlbiA9IDE2OwpAQCAtNTc0NSw2ICs1OTcwLDcgQEAKIAogCXNjc2lfaG9zdF9zZXRfcHJvdChzaG9zdCwgU0hPU1RfRElGX1RZUEUxX1BST1RFQ1RJT04KIAkgICAgfCBTSE9TVF9ESUZfVFlQRTNfUFJPVEVDVElPTik7CisJc2NzaV9ob3N0X3NldF9ndWFyZChzaG9zdCwgU0hPU1RfRElYX0dVQVJEX0NSQyk7CiAKIAkvKiBldmVudCB0aHJlYWQgKi8KIAlzbnByaW50Zihpb2MtPmZpcm13YXJlX2V2ZW50X25hbWUsIHNpemVvZihpb2MtPmZpcm13YXJlX2V2ZW50X25hbWUpLApAQCAtNTg5NCw2ICs2MTIwLDExIEBACiAJLyogY3RsIG1vZHVsZSBjYWxsYmFjayBoYW5kbGVyICovCiAJY3RsX2NiX2lkeCA9IG1wdDJzYXNfYmFzZV9yZWdpc3Rlcl9jYWxsYmFja19oYW5kbGVyKG1wdDJzYXNfY3RsX2RvbmUpOwogCisJdG1fdHJfY2JfaWR4ID0gbXB0MnNhc19iYXNlX3JlZ2lzdGVyX2NhbGxiYWNrX2hhbmRsZXIoCisJICAgIF9zY3NpaF90bV90cl9jb21wbGV0ZSk7CisJdG1fc2FzX2NvbnRyb2xfY2JfaWR4ID0gbXB0MnNhc19iYXNlX3JlZ2lzdGVyX2NhbGxiYWNrX2hhbmRsZXIoCisJICAgIF9zY3NpaF9zYXNfY29udHJvbF9jb21wbGV0ZSk7CisKIAltcHQyc2FzX2N0bF9pbml0KCk7CiAKIAllcnJvciA9IHBjaV9yZWdpc3Rlcl9kcml2ZXIoJnNjc2loX2RyaXZlcik7CkBAIC01OTI0LDYgKzYxNTUsOSBAQAogCW1wdDJzYXNfYmFzZV9yZWxlYXNlX2NhbGxiYWNrX2hhbmRsZXIoY29uZmlnX2NiX2lkeCk7CiAJbXB0MnNhc19iYXNlX3JlbGVhc2VfY2FsbGJhY2tfaGFuZGxlcihjdGxfY2JfaWR4KTsKIAorCW1wdDJzYXNfYmFzZV9yZWxlYXNlX2NhbGxiYWNrX2hhbmRsZXIodG1fdHJfY2JfaWR4KTsKKwltcHQyc2FzX2Jhc2VfcmVsZWFzZV9jYWxsYmFja19oYW5kbGVyKHRtX3Nhc19jb250cm9sX2NiX2lkeCk7CisKIAltcHQyc2FzX2N0bF9leGl0KCk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfdHJhbnNwb3J0LmMgYi9kcml2ZXJzL3Njc2kvbXB0MnNhcy9tcHQyc2FzX3RyYW5zcG9ydC5jCmluZGV4IDc0MjMyNGEuLmViOTgxODggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJzYXNfdHJhbnNwb3J0LmMKKysrIGIvZHJpdmVycy9zY3NpL21wdDJzYXMvbXB0MnNhc190cmFuc3BvcnQuYwpAQCAtMiw3ICsyLDcgQEAKICAqIFNBUyBUcmFuc3BvcnQgTGF5ZXIgZm9yIE1QVCAoTWVzc2FnZSBQYXNzaW5nIFRlY2hub2xvZ3kpIGJhc2VkIGNvbnRyb2xsZXJzCiAgKgogICogVGhpcyBjb2RlIGlzIGJhc2VkIG9uIGRyaXZlcnMvc2NzaS9tcHQyc2FzL21wdDJfdHJhbnNwb3J0LmMKLSAqIENvcHlyaWdodCAoQykgMjAwNy0yMDA4ICBMU0kgQ29ycG9yYXRpb24KKyAqIENvcHlyaWdodCAoQykgMjAwNy0yMDA5ICBMU0kgQ29ycG9yYXRpb24KICAqICAobWFpbHRvOkRMLU1QVEZ1c2lvbkxpbnV4QGxzaS5jb20pCiAgKgogICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vcgpAQCAtMjEyLDI1ICsyMTIsMjYgQEAKICAqIG1wdDJzYXNfdHJhbnNwb3J0X2RvbmUgLSAgaW50ZXJuYWwgdHJhbnNwb3J0IGxheWVyIGNhbGxiYWNrIGhhbmRsZXIuCiAgKiBAaW9jOiBwZXIgYWRhcHRlciBvYmplY3QKICAqIEBzbWlkOiBzeXN0ZW0gcmVxdWVzdCBtZXNzYWdlIGluZGV4Ci0gKiBAVkZfSUQ6IHZpcnR1YWwgZnVuY3Rpb24gaWQKKyAqIEBtc2l4X2luZGV4OiBNU0lYIHRhYmxlIGluZGV4IHN1cHBsaWVkIGJ5IHRoZSBPUwogICogQHJlcGx5OiByZXBseSBtZXNzYWdlIGZyYW1lKGxvd2VyIDMyYml0IGFkZHIpCiAgKgogICogQ2FsbGJhY2sgaGFuZGxlciB3aGVuIHNlbmRpbmcgaW50ZXJuYWwgZ2VuZXJhdGVkIHRyYW5zcG9ydCBjbWRzLgogICogVGhlIGNhbGxiYWNrIGluZGV4IHBhc3NlZCBpcyBgaW9jLT50cmFuc3BvcnRfY2JfaWR4YAogICoKLSAqIFJldHVybiBub3RoaW5nLgorICogUmV0dXJuIDEgbWVhbmluZyBtZiBzaG91bGQgYmUgZnJlZWQgZnJvbSBfYmFzZV9pbnRlcnJ1cHQKKyAqICAgICAgICAwIG1lYW5zIHRoZSBtZiBpcyBmcmVlZCBmcm9tIHRoaXMgZnVuY3Rpb24uCiAgKi8KLXZvaWQKLW1wdDJzYXNfdHJhbnNwb3J0X2RvbmUoc3RydWN0IE1QVDJTQVNfQURBUFRFUiAqaW9jLCB1MTYgc21pZCwgdTggVkZfSUQsCit1OAorbXB0MnNhc190cmFuc3BvcnRfZG9uZShzdHJ1Y3QgTVBUMlNBU19BREFQVEVSICppb2MsIHUxNiBzbWlkLCB1OCBtc2l4X2luZGV4LAogICAgIHUzMiByZXBseSkKIHsKIAlNUEkyRGVmYXVsdFJlcGx5X3QgKm1waV9yZXBseTsKIAogCW1waV9yZXBseSA9ICBtcHQyc2FzX2Jhc2VfZ2V0X3JlcGx5X3ZpcnRfYWRkcihpb2MsIHJlcGx5KTsKIAlpZiAoaW9jLT50cmFuc3BvcnRfY21kcy5zdGF0dXMgPT0gTVBUMl9DTURfTk9UX1VTRUQpCi0JCXJldHVybjsKKwkJcmV0dXJuIDE7CiAJaWYgKGlvYy0+dHJhbnNwb3J0X2NtZHMuc21pZCAhPSBzbWlkKQotCQlyZXR1cm47CisJCXJldHVybiAxOwogCWlvYy0+dHJhbnNwb3J0X2NtZHMuc3RhdHVzIHw9IE1QVDJfQ01EX0NPTVBMRVRFOwogCWlmIChtcGlfcmVwbHkpIHsKIAkJbWVtY3B5KGlvYy0+dHJhbnNwb3J0X2NtZHMucmVwbHksIG1waV9yZXBseSwKQEAgLTIzOSw2ICsyNDAsNyBAQAogCX0KIAlpb2MtPnRyYW5zcG9ydF9jbWRzLnN0YXR1cyAmPSB+TVBUMl9DTURfUEVORElORzsKIAljb21wbGV0ZSgmaW9jLT50cmFuc3BvcnRfY21kcy5kb25lKTsKKwlyZXR1cm4gMTsKIH0KIAogLyogcmVwb3J0IG1hbnVmYWN0dXJlIHJlcXVlc3Qgc3RydWN0dXJlICovCkBAIC0zNjksNiArMzcxLDggQEAKIAltZW1zZXQobXBpX3JlcXVlc3QsIDAsIHNpemVvZihNcGkyU21wUGFzc3Rocm91Z2hSZXF1ZXN0X3QpKTsKIAltcGlfcmVxdWVzdC0+RnVuY3Rpb24gPSBNUEkyX0ZVTkNUSU9OX1NNUF9QQVNTVEhST1VHSDsKIAltcGlfcmVxdWVzdC0+UGh5c2ljYWxQb3J0ID0gMHhGRjsKKwltcGlfcmVxdWVzdC0+VkZfSUQgPSAwOyAvKiBUT0RPICovCisJbXBpX3JlcXVlc3QtPlZQX0lEID0gMDsKIAlzYXNfYWRkcmVzc19sZSA9ICh1NjQgKikmbXBpX3JlcXVlc3QtPlNBU0FkZHJlc3M7CiAJKnNhc19hZGRyZXNzX2xlID0gY3B1X3RvX2xlNjQoc2FzX2FkZHJlc3MpOwogCW1waV9yZXF1ZXN0LT5SZXF1ZXN0RGF0YUxlbmd0aCA9IHNpemVvZihzdHJ1Y3QgcmVwX21hbnVfcmVxdWVzdCk7CkBAIC0zOTYsNyArNDAwLDggQEAKIAlkdHJhbnNwb3J0cHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfREVCVUdfRk1UICJyZXBvcnRfbWFudWZhY3R1cmUgLSAiCiAJICAgICJzZW5kIHRvIHNhc19hZGRyKDB4JTAxNmxseClcbiIsIGlvYy0+bmFtZSwKIAkgICAgKHVuc2lnbmVkIGxvbmcgbG9uZylzYXNfYWRkcmVzcykpOwotCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCwgMCAvKiBWRl9JRCAqLyk7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkKTsKKwlpbml0X2NvbXBsZXRpb24oJmlvYy0+dHJhbnNwb3J0X2NtZHMuZG9uZSk7CiAJdGltZWxlZnQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmlvYy0+dHJhbnNwb3J0X2NtZHMuZG9uZSwKIAkgICAgMTAqSFopOwogCkBAIC0xMTA2LDYgKzExMTEsOCBAQAogCW1lbXNldChtcGlfcmVxdWVzdCwgMCwgc2l6ZW9mKE1waTJTbXBQYXNzdGhyb3VnaFJlcXVlc3RfdCkpOwogCW1waV9yZXF1ZXN0LT5GdW5jdGlvbiA9IE1QSTJfRlVOQ1RJT05fU01QX1BBU1NUSFJPVUdIOwogCW1waV9yZXF1ZXN0LT5QaHlzaWNhbFBvcnQgPSAweEZGOworCW1waV9yZXF1ZXN0LT5WRl9JRCA9IDA7IC8qIFRPRE8gKi8KKwltcGlfcmVxdWVzdC0+VlBfSUQgPSAwOwogCSooKHU2NCAqKSZtcGlfcmVxdWVzdC0+U0FTQWRkcmVzcykgPSAocnBoeSkgPwogCSAgICBjcHVfdG9fbGU2NChycGh5LT5pZGVudGlmeS5zYXNfYWRkcmVzcykgOgogCSAgICBjcHVfdG9fbGU2NChpb2MtPnNhc19oYmEuc2FzX2FkZHJlc3MpOwpAQCAtMTE0Nyw3ICsxMTU0LDggQEAKIAlkdHJhbnNwb3J0cHJpbnRrKGlvYywgcHJpbnRrKE1QVDJTQVNfREVCVUdfRk1UICIlcyAtICIKIAkgICAgInNlbmRpbmcgc21wIHJlcXVlc3RcbiIsIGlvYy0+bmFtZSwgX19mdW5jX18pKTsKIAotCW1wdDJzYXNfYmFzZV9wdXRfc21pZF9kZWZhdWx0KGlvYywgc21pZCwgMCAvKiBWRl9JRCAqLyk7CisJbXB0MnNhc19iYXNlX3B1dF9zbWlkX2RlZmF1bHQoaW9jLCBzbWlkKTsKKwlpbml0X2NvbXBsZXRpb24oJmlvYy0+dHJhbnNwb3J0X2NtZHMuZG9uZSk7CiAJdGltZWxlZnQgPSB3YWl0X2Zvcl9jb21wbGV0aW9uX3RpbWVvdXQoJmlvYy0+dHJhbnNwb3J0X2NtZHMuZG9uZSwKIAkgICAgMTAqSFopOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvbXZzYXMvbXZfZGVmcy5oIGIvZHJpdmVycy9zY3NpL212c2FzL212X2RlZnMuaAppbmRleCBmOGNiOWRlLi4xODQ5ZGExIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvbXZzYXMvbXZfZGVmcy5oCisrKyBiL2RyaXZlcnMvc2NzaS9tdnNhcy9tdl9kZWZzLmgKQEAgLTI1LDYgKzI1LDggQEAKICNpZm5kZWYgX01WX0RFRlNfSF8KICNkZWZpbmUgX01WX0RFRlNfSF8KIAorI2RlZmluZSBQQ0lfREVWSUNFX0lEX0FSRUNBXzEzMDAJMHgxMzAwCisjZGVmaW5lIFBDSV9ERVZJQ0VfSURfQVJFQ0FfMTMyMAkweDEzMjAKIAogZW51bSBjaGlwX2ZsYXZvcnMgewogCWNoaXBfNjMyMCwKQEAgLTMyLDYgKzM0LDggQEAKIAljaGlwXzY0ODUsCiAJY2hpcF85NDgwLAogCWNoaXBfOTE4MCwKKwljaGlwXzEzMDAsCisJY2hpcF8xMzIwCiB9OwogCiAvKiBkcml2ZXIgY29tcGlsZS10aW1lIGNvbmZpZ3VyYXRpb24gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9tdnNhcy9tdl9pbml0LmMgYi9kcml2ZXJzL3Njc2kvbXZzYXMvbXZfaW5pdC5jCmluZGV4IDg2NDZhMTkuLmM3OTBkNDUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9tdnNhcy9tdl9pbml0LmMKKysrIGIvZHJpdmVycy9zY3NpL212c2FzL212X2luaXQuYwpAQCAtMzIsNiArMzIsOCBAQAogCVtjaGlwXzY0ODVdID0JeyAxLCA4LCAweDgwMCwgMzMsIDMyLCAxMCwgJm12c182NHh4X2Rpc3BhdGNoLCB9LAogCVtjaGlwXzkxODBdID0JeyAyLCA0LCAweDgwMCwgMTcsIDY0LCAgOSwgJm12c185NHh4X2Rpc3BhdGNoLCB9LAogCVtjaGlwXzk0ODBdID0JeyAyLCA0LCAweDgwMCwgMTcsIDY0LCAgOSwgJm12c185NHh4X2Rpc3BhdGNoLCB9LAorCVtjaGlwXzEzMDBdID0JeyAxLCA0LCAweDQwMCwgMTcsIDE2LCAgOSwgJm12c182NHh4X2Rpc3BhdGNoLCB9LAorCVtjaGlwXzEzMjBdID0JeyAyLCA0LCAweDgwMCwgMTcsIDY0LCAgOSwgJm12c185NHh4X2Rpc3BhdGNoLCB9LAogfTsKIAogI2RlZmluZSBTT0NfU0FTX05VTSAyCkBAIC02NTMsNiArNjU1LDggQEAKIAl7IFBDSV9WREVWSUNFKE1BUlZFTEwsIDB4NjQ4NSksIGNoaXBfNjQ4NSB9LAogCXsgUENJX1ZERVZJQ0UoTUFSVkVMTCwgMHg5NDgwKSwgY2hpcF85NDgwIH0sCiAJeyBQQ0lfVkRFVklDRShNQVJWRUxMLCAweDkxODApLCBjaGlwXzkxODAgfSwKKwl7IFBDSV9WREVWSUNFKEFSRUNBLCBQQ0lfREVWSUNFX0lEX0FSRUNBXzEzMDApLCBjaGlwXzEzMDAgfSwKKwl7IFBDSV9WREVWSUNFKEFSRUNBLCBQQ0lfREVWSUNFX0lEX0FSRUNBXzEzMjApLCBjaGlwXzEzMjAgfSwKIAogCXsgfQkvKiB0ZXJtaW5hdGUgbGlzdCAqLwogfTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9wbWNyYWlkLmMgYi9kcml2ZXJzL3Njc2kvcG1jcmFpZC5jCmluZGV4IDQzMDJmMDYuLmY3YzcwZTIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9wbWNyYWlkLmMKKysrIGIvZHJpdmVycy9zY3NpL3BtY3JhaWQuYwpAQCAtNDYsNiArNDYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CiAjaW5jbHVkZSA8c2NzaS9zY3NpLmg+CiAjaW5jbHVkZSA8c2NzaS9zY3NpX2hvc3QuaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfZGV2aWNlLmg+CiAjaW5jbHVkZSA8c2NzaS9zY3NpX3RjcS5oPgogI2luY2x1ZGUgPHNjc2kvc2NzaV9laC5oPgogI2luY2x1ZGUgPHNjc2kvc2NzaV9jbW5kLmg+CkBAIC02ODQsNyArNjg1LDcgQEAKIAlzdHJ1Y3QgcG1jcmFpZF9pbnN0YW5jZSAqcGluc3RhbmNlID0gY21kLT5kcnZfaW5zdDsKIAl1bnNpZ25lZCBsb25nIGxvY2tfZmxhZ3M7CiAKLQlkZXZfZXJyKCZwaW5zdGFuY2UtPnBkZXYtPmRldiwKKwlkZXZfaW5mbygmcGluc3RhbmNlLT5wZGV2LT5kZXYsCiAJCSJBZGFwdGVyIGJlaW5nIHJlc2V0IGR1ZSB0byBjb21tYW5kIHRpbWVvdXQuXG4iKTsKIAogCS8qIENvbW1hbmQgdGltZW91dHMgcmVzdWx0IGluIGhhcmQgcmVzZXQgc2VxdWVuY2UuIFRoZSBjb21tYW5kIHRoYXQgZ290CkBAIC04MTUsOCArODE2LDkgQEAKIAogCWlmIChQTUNSQUlEX0lPQVNDX1NFTlNFX0tFWShpb2FzYykgPiAwKSB7CiAJCXNjc2lfY21kLT5yZXN1bHQgfD0gKERJRF9FUlJPUiA8PCAxNik7Ci0JCXBtY3JhaWRfZXJyKCJjb21tYW5kIENEQlswXSA9ICV4IGZhaWxlZCB3aXRoIElPQVNDOiAweCUwOFhcbiIsCi0JCQkgICAgIGNtZC0+aW9hX2NiLT5pb2FyY2IuY2RiWzBdLCBpb2FzYyk7CisJCXNjbWRfcHJpbnRrKEtFUk5fSU5GTywgc2NzaV9jbWQsCisJCQkgICAgImNvbW1hbmQgQ0RCWzBdID0gJXggZmFpbGVkIHdpdGggSU9BU0M6IDB4JTA4WFxuIiwKKwkJCSAgICBjbWQtPmlvYV9jYi0+aW9hcmNiLmNkYlswXSwgaW9hc2MpOwogCX0KIAogCS8qIGlmIHdlIGhhZCBhbGxvY2F0ZWQgc2Vuc2UgYnVmZmVycyBmb3IgcmVxdWVzdCBzZW5zZSwgY29weSB0aGUgc2Vuc2UKQEAgLTE1NDEsMTMgKzE1NDMsMTMgQEAKIAogCWlmIChwaW5zdGFuY2UtPmxkbi5oY2FtLT5ub3RpZmljYXRpb25fbG9zdCA9PQogCSAgICBIT1NUUkNCX05PVElGSUNBVElPTlNfTE9TVCkKLQkJZGV2X2VycigmcGluc3RhbmNlLT5wZGV2LT5kZXYsICJFcnJvciBub3RpZmljYXRpb25zIGxvc3RcbiIpOworCQlkZXZfaW5mbygmcGluc3RhbmNlLT5wZGV2LT5kZXYsICJFcnJvciBub3RpZmljYXRpb25zIGxvc3RcbiIpOwogCiAJaW9hc2MgPSBsZTMyX3RvX2NwdShoY2FtX2xkbi0+ZXJyb3JfbG9nLmZkX2lvYXNjKTsKIAogCWlmIChpb2FzYyA9PSBQTUNSQUlEX0lPQVNDX1VBX0JVU19XQVNfUkVTRVQgfHwKIAkJaW9hc2MgPT0gUE1DUkFJRF9JT0FTQ19VQV9CVVNfV0FTX1JFU0VUX0JZX09USEVSKSB7Ci0JCWRldl9lcnIoJnBpbnN0YW5jZS0+cGRldi0+ZGV2LAorCQlkZXZfaW5mbygmcGluc3RhbmNlLT5wZGV2LT5kZXYsCiAJCQkiVW5pdEF0dGVudGlvbiBkdWUgdG8gSU9BIEJ1cyBSZXNldFxuIik7CiAJCXNjc2lfcmVwb3J0X2J1c19yZXNldCgKIAkJCXBpbnN0YW5jZS0+aG9zdCwKQEAgLTE1ODQsNyArMTU4Niw3IEBACiAJICAgIGF0b21pY19yZWFkKCZwaW5zdGFuY2UtPmNjbi5pZ25vcmUpID09IDEpIHsKIAkJcmV0dXJuOwogCX0gZWxzZSBpZiAoaW9hc2MpIHsKLQkJZGV2X2VycigmcGluc3RhbmNlLT5wZGV2LT5kZXYsCisJCWRldl9pbmZvKCZwaW5zdGFuY2UtPnBkZXYtPmRldiwKIAkJCSJIb3N0IFJDQiAoQ0NOKSBmYWlsZWQgd2l0aCBJT0FTQzogMHglMDhYXG4iLCBpb2FzYyk7CiAJCXNwaW5fbG9ja19pcnFzYXZlKHBpbnN0YW5jZS0+aG9zdC0+aG9zdF9sb2NrLCBsb2NrX2ZsYWdzKTsKIAkJcG1jcmFpZF9zZW5kX2hjYW0ocGluc3RhbmNlLCBQTUNSQUlEX0hDQU1fQ09ERV9DT05GSUdfQ0hBTkdFKTsKQEAgLTE2MzQsNyArMTYzNiw3IEBACiAJCQlyZXR1cm47CiAJCX0KIAl9IGVsc2UgewotCQlkZXZfZXJyKCZwaW5zdGFuY2UtPnBkZXYtPmRldiwKKwkJZGV2X2luZm8oJnBpbnN0YW5jZS0+cGRldi0+ZGV2LAogCQkJIkhvc3QgUkNCKExETikgZmFpbGVkIHdpdGggSU9BU0M6IDB4JTA4WFxuIiwgaW9hc2MpOwogCX0KIAkvKiBzZW5kIG5ldGxpbmsgbWVzc2FnZSBmb3IgSENBTSBub3RpZmljYXRpb24gaWYgZW5hYmxlZCAqLwpAQCAtMTgyMiw3ICsxODI0LDYgQEAKIAkJCXNjc2lfZG1hX3VubWFwKHNjc2lfY21kKTsKIAkJCXBtY3JhaWRfcmV0dXJuX2NtZChjbWQpOwogCi0KIAkJCXBtY3JhaWRfaW5mbygiZmFpbGluZyglZCkgQ0RCWzBdID0gJXggcmVzdWx0OiAleFxuIiwKIAkJCQkgICAgIGxlMzJfdG9fY3B1KHJlc3ApID4+IDIsCiAJCQkJICAgICBjbWQtPmlvYV9jYi0+aW9hcmNiLmNkYlswXSwKQEAgLTI1MTQsNyArMjUxNSw4IEBACiAJcmVzID0gc2NzaV9jbWQtPmRldmljZS0+aG9zdGRhdGE7CiAKIAlpZiAoIXJlcykgewotCQlwbWNyYWlkX2VycigicmVzZXRfZGV2aWNlOiBOVUxMIHJlc291cmNlIHBvaW50ZXJcbiIpOworCQlzZGV2X3ByaW50ayhLRVJOX0VSUiwgc2NzaV9jbWQtPmRldmljZSwKKwkJCSAgICAicmVzZXRfZGV2aWNlOiBOVUxMIHJlc291cmNlIHBvaW50ZXJcbiIpOwogCQlyZXR1cm4gRkFJTEVEOwogCX0KIApAQCAtMjc1Miw4ICsyNzU0LDggQEAKIAlwaW5zdGFuY2UgPQogCQkoc3RydWN0IHBtY3JhaWRfaW5zdGFuY2UgKilzY3NpX2NtZC0+ZGV2aWNlLT5ob3N0LT5ob3N0ZGF0YTsKIAotCWRldl9lcnIoJnBpbnN0YW5jZS0+cGRldi0+ZGV2LAotCQkiSS9PIGNvbW1hbmQgdGltZWQgb3V0LCBhYm9ydGluZyBpdC5cbiIpOworCXNjbWRfcHJpbnRrKEtFUk5fSU5GTywgc2NzaV9jbWQsCisJCSAgICAiSS9PIGNvbW1hbmQgdGltZWQgb3V0LCBhYm9ydGluZyBpdC5cbiIpOwogCiAJcmVzID0gc2NzaV9jbWQtPmRldmljZS0+aG9zdGRhdGE7CiAKQEAgLTI4MjQsNyArMjgyNiw4IEBACiAgKi8KIHN0YXRpYyBpbnQgcG1jcmFpZF9laF9kZXZpY2VfcmVzZXRfaGFuZGxlcihzdHJ1Y3Qgc2NzaV9jbW5kICpzY21kKQogewotCXBtY3JhaWRfZXJyKCJEb2luZyBkZXZpY2UgcmVzZXQgZHVlIHRvIGFuIEkvTyBjb21tYW5kIHRpbWVvdXQuXG4iKTsKKwlzY21kX3ByaW50ayhLRVJOX0lORk8sIHNjbWQsCisJCSAgICAicmVzZXR0aW5nIGRldmljZSBkdWUgdG8gYW4gSS9PIGNvbW1hbmQgdGltZW91dC5cbiIpOwogCXJldHVybiBwbWNyYWlkX3Jlc2V0X2RldmljZShzY21kLAogCQkJCSAgICBQTUNSQUlEX0lOVEVSTkFMX1RJTUVPVVQsCiAJCQkJICAgIFJFU0VUX0RFVklDRV9MVU4pOwpAQCAtMjgzMiw3ICsyODM1LDggQEAKIAogc3RhdGljIGludCBwbWNyYWlkX2VoX2J1c19yZXNldF9oYW5kbGVyKHN0cnVjdCBzY3NpX2NtbmQgKnNjbWQpCiB7Ci0JcG1jcmFpZF9lcnIoIkRvaW5nIGJ1cyByZXNldCBkdWUgdG8gYW4gSS9PIGNvbW1hbmQgdGltZW91dC5cbiIpOworCXNjbWRfcHJpbnRrKEtFUk5fSU5GTywgc2NtZCwKKwkJICAgICJEb2luZyBidXMgcmVzZXQgZHVlIHRvIGFuIEkvTyBjb21tYW5kIHRpbWVvdXQuXG4iKTsKIAlyZXR1cm4gcG1jcmFpZF9yZXNldF9kZXZpY2Uoc2NtZCwKIAkJCQkgICAgUE1DUkFJRF9SRVNFVF9CVVNfVElNRU9VVCwKIAkJCQkgICAgUkVTRVRfREVWSUNFX0JVUyk7CkBAIC0yODQwLDcgKzI4NDQsOCBAQAogCiBzdGF0aWMgaW50IHBtY3JhaWRfZWhfdGFyZ2V0X3Jlc2V0X2hhbmRsZXIoc3RydWN0IHNjc2lfY21uZCAqc2NtZCkKIHsKLQlwbWNyYWlkX2VycigiRG9pbmcgdGFyZ2V0IHJlc2V0IGR1ZSB0byBhbiBJL08gY29tbWFuZCB0aW1lb3V0LlxuIik7CisJc2NtZF9wcmludGsoS0VSTl9JTkZPLCBzY21kLAorCQkgICAgIkRvaW5nIHRhcmdldCByZXNldCBkdWUgdG8gYW4gSS9PIGNvbW1hbmQgdGltZW91dC5cbiIpOwogCXJldHVybiBwbWNyYWlkX3Jlc2V0X2RldmljZShzY21kLAogCQkJCSAgICBQTUNSQUlEX0lOVEVSTkFMX1RJTUVPVVQsCiAJCQkJICAgIFJFU0VUX0RFVklDRV9UQVJHRVQpOwpAQCAtMjk4OCwxMSArMjk5MywxMSBAQAogCW5zZWcgPSBzY3NpX2RtYV9tYXAoc2NzaV9jbWQpOwogCiAJaWYgKG5zZWcgPCAwKSB7Ci0JCWRldl9lcnIoJnBpbnN0YW5jZS0+cGRldi0+ZGV2LCAic2NzaV9tYXBfZG1hIGZhaWxlZCFcbiIpOworCQlzY21kX3ByaW50ayhLRVJOX0VSUiwgc2NzaV9jbWQsICJzY3NpX21hcF9kbWEgZmFpbGVkIVxuIik7CiAJCXJldHVybiAtMTsKIAl9IGVsc2UgaWYgKG5zZWcgPiBQTUNSQUlEX01BWF9JT0FETFMpIHsKIAkJc2NzaV9kbWFfdW5tYXAoc2NzaV9jbWQpOwotCQlkZXZfZXJyKCZwaW5zdGFuY2UtPnBkZXYtPmRldiwKKwkJc2NtZF9wcmludGsoS0VSTl9FUlIsIHNjc2lfY21kLAogCQkJInNnIGNvdW50IGlzICglZCkgbW9yZSB0aGFuIGFsbG93ZWQhXG4iLCBuc2VnKTsKIAkJcmV0dXJuIC0xOwogCX0KQEAgLTUwNDAsNyArNTA0NSw3IEBACiAJcmMgPSBwY2lfZW5hYmxlX2RldmljZShwZGV2KTsKIAogCWlmIChyYykgewotCQlwbWNyYWlkX2VycigicG1jcmFpZDogRW5hYmxlIGRldmljZSBmYWlsZWRcbiIpOworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJyZXN1bWU6IEVuYWJsZSBkZXZpY2UgZmFpbGVkXG4iKTsKIAkJcmV0dXJuIHJjOwogCX0KIApAQCAtNTA1NCw3ICs1MDU5LDcgQEAKIAkJcmMgPSBwY2lfc2V0X2NvbnNpc3RlbnRfZG1hX21hc2socGRldiwgRE1BX0JJVF9NQVNLKDMyKSk7CiAKIAlpZiAocmMgIT0gMCkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJGYWlsZWQgdG8gc2V0IFBDSSBETUEgbWFza1xuIik7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgInJlc3VtZTogRmFpbGVkIHRvIHNldCBQQ0kgRE1BIG1hc2tcbiIpOwogCQlnb3RvIGRpc2FibGVfZGV2aWNlOwogCX0KIApAQCAtNTA2Myw3ICs1MDY4LDggQEAKIAlyYyA9IHBtY3JhaWRfcmVnaXN0ZXJfaW50ZXJydXB0X2hhbmRsZXIocGluc3RhbmNlKTsKIAogCWlmIChyYykgewotCQlwbWNyYWlkX2VycigicmVzdW1lOiBjb3VsZG4ndCByZWdpc3RlciBpbnRlcnJ1cHQgaGFuZGxlcnNcbiIpOworCQlkZXZfZXJyKCZwZGV2LT5kZXYsCisJCQkicmVzdW1lOiBjb3VsZG4ndCByZWdpc3RlciBpbnRlcnJ1cHQgaGFuZGxlcnNcbiIpOwogCQlyYyA9IC1FTk9ERVY7CiAJCWdvdG8gcmVsZWFzZV9ob3N0OwogCX0KQEAgLTUwODAsNyArNTA4Niw3IEBACiAJICogc3RhdGUuCiAJICovCiAJaWYgKHBtY3JhaWRfcmVzZXRfYnJpbmd1cChwaW5zdGFuY2UpKSB7Ci0JCXBtY3JhaWRfZXJyKCJjb3VsZG4ndCBpbml0aWFsaXplIElPQSBcbiIpOworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjb3VsZG4ndCBpbml0aWFsaXplIElPQSBcbiIpOwogCQlyYyA9IC1FTk9ERVY7CiAJCWdvdG8gcmVsZWFzZV90YXNrbGV0czsKIAl9CkBAIC01MTg3LDcgKzUxOTMsNyBAQAogCUxJU1RfSEVBRChvbGRfcmVzKTsKIAogCWlmIChwaW5zdGFuY2UtPmNmZ190YWJsZS0+ZmxhZ3MgJiBNSUNST0NPREVfVVBEQVRFX1JFUVVJUkVEKQotCQlkZXZfZXJyKCZwaW5zdGFuY2UtPnBkZXYtPmRldiwgIlJlcXVpcmUgbWljcm9jb2RlIGRvd25sb2FkXG4iKTsKKwkJcG1jcmFpZF9lcnIoIklPQSByZXF1aXJlcyBtaWNyb2NvZGUgZG93bmxvYWRcbiIpOwogCiAJLyogcmVzb3VyY2UgbGlzdCBpcyBwcm90ZWN0ZWQgYnkgcGluc3RhbmNlLT5yZXNvdXJjZV9sb2NrLgogCSAqIGluaXRfcmVzX3RhYmxlIGNhbiBiZSBjYWxsZWQgZnJvbSBwcm9iZSAodXNlci10aHJlYWQpIG9yIHJ1bnRpbWUKQEAgLTUyMjQsOCArNTIzMCw3IEBACiAJCWlmICghZm91bmQpIHsKIAogCQkJaWYgKGxpc3RfZW1wdHkoJnBpbnN0YW5jZS0+ZnJlZV9yZXNfcSkpIHsKLQkJCQlkZXZfZXJyKCZwaW5zdGFuY2UtPnBkZXYtPmRldiwKLQkJCQkJIlRvbyBtYW55IGRldmljZXMgYXR0YWNoZWRcbiIpOworCQkJCXBtY3JhaWRfZXJyKCJUb28gbWFueSBkZXZpY2VzIGF0dGFjaGVkXG4iKTsKIAkJCQlicmVhazsKIAkJCX0KIApAQCAtNTQ0Miw3ICs1NDQ3LDcgQEAKIAlyYyA9IHBtY3JhaWRfcmVnaXN0ZXJfaW50ZXJydXB0X2hhbmRsZXIocGluc3RhbmNlKTsKIAogCWlmIChyYykgewotCQlwbWNyYWlkX2VycigiY291bGRuJ3QgcmVnaXN0ZXIgaW50ZXJydXB0IGhhbmRsZXJcbiIpOworCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjb3VsZG4ndCByZWdpc3RlciBpbnRlcnJ1cHQgaGFuZGxlclxuIik7CiAJCWdvdG8gb3V0X3Njc2lfaG9zdF9wdXQ7CiAJfQogCkBAIC01NDY2LDcgKzU0NzEsNyBAQAogCSAqLwogCXBtY3JhaWRfaW5mbygic3RhcnRpbmcgSU9BIGluaXRpYWxpemF0aW9uIHNlcXVlbmNlXG4iKTsKIAlpZiAocG1jcmFpZF9yZXNldF9icmluZ3VwKHBpbnN0YW5jZSkpIHsKLQkJcG1jcmFpZF9lcnIoImNvdWxkbid0IGluaXRpYWxpemUgSU9BIFxuIik7CisJCWRldl9lcnIoJnBkZXYtPmRldiwgImNvdWxkbid0IGluaXRpYWxpemUgSU9BIFxuIik7CiAJCXJjID0gMTsKIAkJZ290byBvdXRfcmVsZWFzZV9idWZzOwogCX0KQEAgLTU1MzQsNyArNTUzOSw2IEBACiAJLnNodXRkb3duID0gcG1jcmFpZF9zaHV0ZG93bgogfTsKIAotCiAvKioKICAqIHBtY3JhaWRfaW5pdCAtIG1vZHVsZSBsb2FkIGVudHJ5IHBvaW50CiAgKi8KQEAgLTU1NjYsNyArNTU3MCw2IEBACiAJCWdvdG8gb3V0X3VucmVnX2NocmRldjsKIAl9CiAKLQogCWVycm9yID0gcG1jcmFpZF9uZXRsaW5rX2luaXQoKTsKIAogCWlmIChlcnJvcikKQEAgLTU1ODQsNiArNTU4Nyw3IEBACiAKIG91dF91bnJlZ19jaHJkZXY6CiAJdW5yZWdpc3Rlcl9jaHJkZXZfcmVnaW9uKE1LREVWKHBtY3JhaWRfbWFqb3IsIDApLCBQTUNSQUlEX01BWF9BREFQVEVSUyk7CisKIG91dF9pbml0OgogCXJldHVybiBlcnJvcjsKIH0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9taWQuYyBiL2RyaXZlcnMvc2NzaS9xbGEyeHh4L3FsYV9taWQuYwppbmRleCA0MmI3OTlhLi5lMDdiMzYxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvcWxhMnh4eC9xbGFfbWlkLmMKKysrIGIvZHJpdmVycy9zY3NpL3FsYTJ4eHgvcWxhX21pZC5jCkBAIC01NjgsNyArNTY4LDcgQEAKIAlpZiAocmVxID09IE5VTEwpIHsKIAkJcWxhX3ByaW50ayhLRVJOX1dBUk5JTkcsIGhhLCAiY291bGQgbm90IGFsbG9jYXRlIG1lbW9yeSIKIAkJCSJmb3IgcmVxdWVzdCBxdWVcbiIpOwotCQlnb3RvIHF1ZV9mYWlsZWQ7CisJCWdvdG8gZmFpbGVkOwogCX0KIAogCXJlcS0+bGVuZ3RoID0gUkVRVUVTVF9FTlRSWV9DTlRfMjRYWDsKQEAgLTYzMiw2ICs2MzIsNyBAQAogCiBxdWVfZmFpbGVkOgogCXFsYTI1eHhfZnJlZV9yZXFfcXVlKGJhc2VfdmhhLCByZXEpOworZmFpbGVkOgogCXJldHVybiAwOwogfQogCkBAIC02NTksNyArNjYwLDcgQEAKIAlpZiAocnNwID09IE5VTEwpIHsKIAkJcWxhX3ByaW50ayhLRVJOX1dBUk5JTkcsIGhhLCAiY291bGQgbm90IGFsbG9jYXRlIG1lbW9yeSBmb3IiCiAJCQkJIiByZXNwb25zZSBxdWVcbiIpOwotCQlnb3RvIHF1ZV9mYWlsZWQ7CisJCWdvdG8gZmFpbGVkOwogCX0KIAogCXJzcC0+bGVuZ3RoID0gUkVTUE9OU0VfRU5UUllfQ05UX01ROwpAQCAtNzI4LDYgKzcyOSw3IEBACiAKIHF1ZV9mYWlsZWQ6CiAJcWxhMjV4eF9mcmVlX3JzcF9xdWUoYmFzZV92aGEsIHJzcCk7CitmYWlsZWQ6CiAJcmV0dXJuIDA7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9zY3NpLmMgYi9kcml2ZXJzL3Njc2kvc2NzaS5jCmluZGV4IGI2ZTAzMDcuLmRkMDk4Y2EgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zY3NpLmMKKysrIGIvZHJpdmVycy9zY3NpL3Njc2kuYwpAQCAtMjQxLDEwICsyNDEsNyBAQAogICovCiBzdHJ1Y3Qgc2NzaV9jbW5kICpfX3Njc2lfZ2V0X2NvbW1hbmQoc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QsIGdmcF90IGdmcF9tYXNrKQogewotCXN0cnVjdCBzY3NpX2NtbmQgKmNtZDsKLQl1bnNpZ25lZCBjaGFyICpidWY7Ci0KLQljbWQgPSBzY3NpX2hvc3RfYWxsb2NfY29tbWFuZChzaG9zdCwgZ2ZwX21hc2spOworCXN0cnVjdCBzY3NpX2NtbmQgKmNtZCA9IHNjc2lfaG9zdF9hbGxvY19jb21tYW5kKHNob3N0LCBnZnBfbWFzayk7CiAKIAlpZiAodW5saWtlbHkoIWNtZCkpIHsKIAkJdW5zaWduZWQgbG9uZyBmbGFnczsKQEAgLTI1OCw5ICsyNTUsMTUgQEAKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc2hvc3QtPmZyZWVfbGlzdF9sb2NrLCBmbGFncyk7CiAKIAkJaWYgKGNtZCkgeworCQkJdm9pZCAqYnVmLCAqcHJvdDsKKwogCQkJYnVmID0gY21kLT5zZW5zZV9idWZmZXI7CisJCQlwcm90ID0gY21kLT5wcm90X3NkYjsKKwogCQkJbWVtc2V0KGNtZCwgMCwgc2l6ZW9mKCpjbWQpKTsKKwogCQkJY21kLT5zZW5zZV9idWZmZXIgPSBidWY7CisJCQljbWQtPnByb3Rfc2RiID0gcHJvdDsKIAkJfQogCX0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3Njc2lfZGVidWcuYyBiL2RyaXZlcnMvc2NzaS9zY3NpX2RlYnVnLmMKaW5kZXggZmI5YWYyMC4uYzQxMDNiZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3Njc2lfZGVidWcuYworKysgYi9kcml2ZXJzL3Njc2kvc2NzaV9kZWJ1Zy5jCkBAIC01MCw2ICs1MCw3IEBACiAjaW5jbHVkZSA8c2NzaS9zY3NpX2hvc3QuaD4KICNpbmNsdWRlIDxzY3NpL3Njc2ljYW0uaD4KICNpbmNsdWRlIDxzY3NpL3Njc2lfZWguaD4KKyNpbmNsdWRlIDxzY3NpL3Njc2lfZGJnLmg+CiAKICNpbmNsdWRlICJzZC5oIgogI2luY2x1ZGUgInNjc2lfbG9nZ2luZy5oIgpAQCAtNjQsNiArNjUsNyBAQAogI2RlZmluZSBQQVJBTUVURVJfTElTVF9MRU5HVEhfRVJSIDB4MWEKICNkZWZpbmUgSU5WQUxJRF9PUENPREUgMHgyMAogI2RlZmluZSBBRERSX09VVF9PRl9SQU5HRSAweDIxCisjZGVmaW5lIElOVkFMSURfQ09NTUFORF9PUENPREUgMHgyMAogI2RlZmluZSBJTlZBTElEX0ZJRUxEX0lOX0NEQiAweDI0CiAjZGVmaW5lIElOVkFMSURfRklFTERfSU5fUEFSQU1fTElTVCAweDI2CiAjZGVmaW5lIFBPV0VST05fUkVTRVQgMHgyOQpAQCAtMTgwLDcgKzE4Miw3IEBACiAjZGVmaW5lIFNERUJVR19TRU5TRV9MRU4gMzIKIAogI2RlZmluZSBTQ1NJX0RFQlVHX0NBTlFVRVVFICAyNTUKLSNkZWZpbmUgU0NTSV9ERUJVR19NQVhfQ01EX0xFTiAxNgorI2RlZmluZSBTQ1NJX0RFQlVHX01BWF9DTURfTEVOIDMyCiAKIHN0cnVjdCBzZGVidWdfZGV2X2luZm8gewogCXN0cnVjdCBsaXN0X2hlYWQgZGV2X2xpc3Q7CkBAIC0yOTYsOSArMjk4LDI1IEBACiB9CiAKIHN0YXRpYyB2b2lkIGdldF9kYXRhX3RyYW5zZmVyX2luZm8odW5zaWduZWQgY2hhciAqY21kLAotCQkJCSAgIHVuc2lnbmVkIGxvbmcgbG9uZyAqbGJhLCB1bnNpZ25lZCBpbnQgKm51bSkKKwkJCQkgICB1bnNpZ25lZCBsb25nIGxvbmcgKmxiYSwgdW5zaWduZWQgaW50ICpudW0sCisJCQkJICAgdTMyICplaV9sYmEpCiB7CisJKmVpX2xiYSA9IDA7CisKIAlzd2l0Y2ggKCpjbWQpIHsKKwljYXNlIFZBUklBQkxFX0xFTkdUSF9DTUQ6CisJCSpsYmEgPSAodTY0KWNtZFsxOV0gfCAodTY0KWNtZFsxOF0gPDwgOCB8CisJCQkodTY0KWNtZFsxN10gPDwgMTYgfCAodTY0KWNtZFsxNl0gPDwgMjQgfAorCQkJKHU2NCljbWRbMTVdIDw8IDMyIHwgKHU2NCljbWRbMTRdIDw8IDQwIHwKKwkJCSh1NjQpY21kWzEzXSA8PCA0OCB8ICh1NjQpY21kWzEyXSA8PCA1NjsKKworCQkqZWlfbGJhID0gKHUzMiljbWRbMjNdIHwgKHUzMiljbWRbMjJdIDw8IDggfAorCQkJKHUzMiljbWRbMjFdIDw8IDE2IHwgKHUzMiljbWRbMjBdIDw8IDI0OworCisJCSpudW0gPSAodTMyKWNtZFszMV0gfCAodTMyKWNtZFszMF0gPDwgOCB8ICh1MzIpY21kWzI5XSA8PCAxNiB8CisJCQkodTMyKWNtZFsyOF0gPDwgMjQ7CisJCWJyZWFrOworCiAJY2FzZSBXUklURV8xNjoKIAljYXNlIFJFQURfMTY6CiAJCSpsYmEgPSAodTY0KWNtZFs5XSB8ICh1NjQpY21kWzhdIDw8IDggfApAQCAtMTU4OSw3ICsxNjA3LDcgQEAKIH0KIAogc3RhdGljIGludCBwcm90X3ZlcmlmeV9yZWFkKHN0cnVjdCBzY3NpX2NtbmQgKlNDcG50LCBzZWN0b3JfdCBzdGFydF9zZWMsCi0JCQkgICAgdW5zaWduZWQgaW50IHNlY3RvcnMpCisJCQkgICAgdW5zaWduZWQgaW50IHNlY3RvcnMsIHUzMiBlaV9sYmEpCiB7CiAJdW5zaWduZWQgaW50IGksIHJlc2lkOwogCXN0cnVjdCBzY2F0dGVybGlzdCAqcHNnbDsKQEAgLTE2MzYsMTMgKzE2NTQsMjMgQEAKIAkJCXJldHVybiAweDAxOwogCQl9CiAKLQkJaWYgKHNjc2lfZGVidWdfZGlmICE9IFNEX0RJRl9UWVBFM19QUk9URUNUSU9OICYmCisJCWlmIChzY3NpX2RlYnVnX2RpZiA9PSBTRF9ESUZfVFlQRTFfUFJPVEVDVElPTiAmJgogCQkgICAgYmUzMl90b19jcHUoc2R0W2ldLnJlZl90YWcpICE9IChzZWN0b3IgJiAweGZmZmZmZmZmKSkgewogCQkJcHJpbnRrKEtFUk5fRVJSICIlczogUkVGIGNoZWNrIGZhaWxlZCBvbiBzZWN0b3IgJWx1XG4iLAogCQkJICAgICAgIF9fZnVuY19fLCAodW5zaWduZWQgbG9uZylzZWN0b3IpOwogCQkJZGlmX2Vycm9ycysrOwogCQkJcmV0dXJuIDB4MDM7CiAJCX0KKworCQlpZiAoc2NzaV9kZWJ1Z19kaWYgPT0gU0RfRElGX1RZUEUyX1BST1RFQ1RJT04gJiYKKwkJICAgIGJlMzJfdG9fY3B1KHNkdFtpXS5yZWZfdGFnKSAhPSBlaV9sYmEpIHsKKwkJCXByaW50ayhLRVJOX0VSUiAiJXM6IFJFRiBjaGVjayBmYWlsZWQgb24gc2VjdG9yICVsdVxuIiwKKwkJCSAgICAgICBfX2Z1bmNfXywgKHVuc2lnbmVkIGxvbmcpc2VjdG9yKTsKKwkJCWRpZl9lcnJvcnMrKzsKKwkJCXJldHVybiAweDAzOworCQl9CisKKwkJZWlfbGJhKys7CiAJfQogCiAJcmVzaWQgPSBzZWN0b3JzICogODsgLyogQnl0ZXMgb2YgcHJvdGVjdGlvbiBkYXRhIHRvIGNvcHkgaW50byBzZ2wgKi8KQEAgLTE2NzAsNyArMTY5OCw4IEBACiB9CiAKIHN0YXRpYyBpbnQgcmVzcF9yZWFkKHN0cnVjdCBzY3NpX2NtbmQgKlNDcG50LCB1bnNpZ25lZCBsb25nIGxvbmcgbGJhLAotCQkgICAgIHVuc2lnbmVkIGludCBudW0sIHN0cnVjdCBzZGVidWdfZGV2X2luZm8gKmRldmlwKQorCQkgICAgIHVuc2lnbmVkIGludCBudW0sIHN0cnVjdCBzZGVidWdfZGV2X2luZm8gKmRldmlwLAorCQkgICAgIHUzMiBlaV9sYmEpCiB7CiAJdW5zaWduZWQgbG9uZyBpZmxhZ3M7CiAJaW50IHJldDsKQEAgLTE2OTksNyArMTcyOCw3IEBACiAKIAkvKiBESVggKyBUMTAgRElGICovCiAJaWYgKHNjc2lfZGVidWdfZGl4ICYmIHNjc2lfcHJvdF9zZ19jb3VudChTQ3BudCkpIHsKLQkJaW50IHByb3RfcmV0ID0gcHJvdF92ZXJpZnlfcmVhZChTQ3BudCwgbGJhLCBudW0pOworCQlpbnQgcHJvdF9yZXQgPSBwcm90X3ZlcmlmeV9yZWFkKFNDcG50LCBsYmEsIG51bSwgZWlfbGJhKTsKIAogCQlpZiAocHJvdF9yZXQpIHsKIAkJCW1rX3NlbnNlX2J1ZmZlcihkZXZpcCwgQUJPUlRFRF9DT01NQU5ELCAweDEwLCBwcm90X3JldCk7CkBAIC0xNzM1LDcgKzE3NjQsNyBAQAogfQogCiBzdGF0aWMgaW50IHByb3RfdmVyaWZ5X3dyaXRlKHN0cnVjdCBzY3NpX2NtbmQgKlNDcG50LCBzZWN0b3JfdCBzdGFydF9zZWMsCi0JCQkgICAgIHVuc2lnbmVkIGludCBzZWN0b3JzKQorCQkJICAgICB1bnNpZ25lZCBpbnQgc2VjdG9ycywgdTMyIGVpX2xiYSkKIHsKIAlpbnQgaSwgaiwgcmV0OwogCXN0cnVjdCBzZF9kaWZfdHVwbGUgKnNkdDsKQEAgLTE3NDksMTEgKzE3NzgsNiBAQAogCiAJc2VjdG9yID0gZG9fZGl2KHRtcF9zZWMsIHNkZWJ1Z19zdG9yZV9zZWN0b3JzKTsKIAotCWlmICgoKFNDcG50LT5jbW5kWzFdID4+IDUpICYgNykgIT0gMSkgewotCQlwcmludGsoS0VSTl9XQVJOSU5HICJzY3NpX2RlYnVnOiBXUlBST1RFQ1QgIT0gMVxuIik7Ci0JCXJldHVybiAwOwotCX0KLQogCUJVR19PTihzY3NpX3NnX2NvdW50KFNDcG50KSA9PSAwKTsKIAlCVUdfT04oc2NzaV9wcm90X3NnX2NvdW50KFNDcG50KSA9PSAwKTsKIApAQCAtMTgwOCw3ICsxODMyLDcgQEAKIAkJCQlnb3RvIG91dDsKIAkJCX0KIAotCQkJaWYgKHNjc2lfZGVidWdfZGlmICE9IFNEX0RJRl9UWVBFM19QUk9URUNUSU9OICYmCisJCQlpZiAoc2NzaV9kZWJ1Z19kaWYgPT0gU0RfRElGX1RZUEUxX1BST1RFQ1RJT04gJiYKIAkJCSAgICBiZTMyX3RvX2NwdShzZHQtPnJlZl90YWcpCiAJCQkgICAgIT0gKHN0YXJ0X3NlYyAmIDB4ZmZmZmZmZmYpKSB7CiAJCQkJcHJpbnRrKEtFUk5fRVJSCkBAIC0xODE5LDYgKzE4NDMsMTYgQEAKIAkJCQlnb3RvIG91dDsKIAkJCX0KIAorCQkJaWYgKHNjc2lfZGVidWdfZGlmID09IFNEX0RJRl9UWVBFMl9QUk9URUNUSU9OICYmCisJCQkgICAgYmUzMl90b19jcHUoc2R0LT5yZWZfdGFnKSAhPSBlaV9sYmEpIHsKKwkJCQlwcmludGsoS0VSTl9FUlIKKwkJCQkgICAgICAgIiVzOiBSRUYgY2hlY2sgZmFpbGVkIG9uIHNlY3RvciAlbHVcbiIsCisJCQkJICAgICAgIF9fZnVuY19fLCAodW5zaWduZWQgbG9uZylzZWN0b3IpOworCQkJCXJldCA9IDB4MDM7CisJCQkJZHVtcF9zZWN0b3IoZGFkZHIsIHNjc2lfZGVidWdfc2VjdG9yX3NpemUpOworCQkJCWdvdG8gb3V0OworCQkJfQorCiAJCQkvKiBXb3VsZCBiZSBncmVhdCB0byBjb3B5IHRoaXMgaW4gYmlnZ2VyCiAJCQkgKiBjaHVua3MuICBIb3dldmVyLCBmb3IgdGhlIHNha2Ugb2YKIAkJCSAqIGNvcnJlY3RuZXNzIHdlIG5lZWQgdG8gdmVyaWZ5IGVhY2ggc2VjdG9yCkBAIC0xODMyLDYgKzE4NjYsNyBAQAogCQkJCXNlY3RvciA9IDA7CS8qIEZvcmNlIHdyYXAgKi8KIAogCQkJc3RhcnRfc2VjKys7CisJCQllaV9sYmErKzsKIAkJCWRhZGRyICs9IHNjc2lfZGVidWdfc2VjdG9yX3NpemU7CiAJCQlwcGFnZV9vZmZzZXQgKz0gc2l6ZW9mKHN0cnVjdCBzZF9kaWZfdHVwbGUpOwogCQl9CkBAIC0xODUzLDcgKzE4ODgsOCBAQAogfQogCiBzdGF0aWMgaW50IHJlc3Bfd3JpdGUoc3RydWN0IHNjc2lfY21uZCAqU0NwbnQsIHVuc2lnbmVkIGxvbmcgbG9uZyBsYmEsCi0JCSAgICAgIHVuc2lnbmVkIGludCBudW0sIHN0cnVjdCBzZGVidWdfZGV2X2luZm8gKmRldmlwKQorCQkgICAgICB1bnNpZ25lZCBpbnQgbnVtLCBzdHJ1Y3Qgc2RlYnVnX2Rldl9pbmZvICpkZXZpcCwKKwkJICAgICAgdTMyIGVpX2xiYSkKIHsKIAl1bnNpZ25lZCBsb25nIGlmbGFnczsKIAlpbnQgcmV0OwpAQCAtMTg2NCw3ICsxOTAwLDcgQEAKIAogCS8qIERJWCArIFQxMCBESUYgKi8KIAlpZiAoc2NzaV9kZWJ1Z19kaXggJiYgc2NzaV9wcm90X3NnX2NvdW50KFNDcG50KSkgewotCQlpbnQgcHJvdF9yZXQgPSBwcm90X3ZlcmlmeV93cml0ZShTQ3BudCwgbGJhLCBudW0pOworCQlpbnQgcHJvdF9yZXQgPSBwcm90X3ZlcmlmeV93cml0ZShTQ3BudCwgbGJhLCBudW0sIGVpX2xiYSk7CiAKIAkJaWYgKHByb3RfcmV0KSB7CiAJCQlta19zZW5zZV9idWZmZXIoZGV2aXAsIElMTEVHQUxfUkVRVUVTVCwgMHgxMCwgcHJvdF9yZXQpOwpAQCAtMjg3MiwxMSArMjkwOCwxMiBAQAogCiAJY2FzZSBTRF9ESUZfVFlQRTBfUFJPVEVDVElPTjoKIAljYXNlIFNEX0RJRl9UWVBFMV9QUk9URUNUSU9OOgorCWNhc2UgU0RfRElGX1RZUEUyX1BST1RFQ1RJT046CiAJY2FzZSBTRF9ESUZfVFlQRTNfUFJPVEVDVElPTjoKIAkJYnJlYWs7CiAKIAlkZWZhdWx0OgotCQlwcmludGsoS0VSTl9FUlIgInNjc2lfZGVidWdfaW5pdDogZGlmIG11c3QgYmUgMCwgMSBvciAzXG4iKTsKKwkJcHJpbnRrKEtFUk5fRVJSICJzY3NpX2RlYnVnX2luaXQ6IGRpZiBtdXN0IGJlIDAsIDEsIDIgb3IgM1xuIik7CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIApAQCAtMzEyMSw2ICszMTU4LDcgQEAKIAlpbnQgbGVuLCBrOwogCXVuc2lnbmVkIGludCBudW07CiAJdW5zaWduZWQgbG9uZyBsb25nIGxiYTsKKwl1MzIgZWlfbGJhOwogCWludCBlcnJzdHMgPSAwOwogCWludCB0YXJnZXQgPSBTQ3BudC0+ZGV2aWNlLT5pZDsKIAlzdHJ1Y3Qgc2RlYnVnX2Rldl9pbmZvICpkZXZpcCA9IE5VTEw7CkBAIC0zMjU0LDE0ICszMjkyLDMwIEBACiAJY2FzZSBSRUFEXzE2OgogCWNhc2UgUkVBRF8xMjoKIAljYXNlIFJFQURfMTA6CisJCS8qIFJFQUR7MTAsMTIsMTZ9IGFuZCBESUYgVHlwZSAyIGFyZSBuYXR1cmFsIGVuZW1pZXMgKi8KKwkJaWYgKHNjc2lfZGVidWdfZGlmID09IFNEX0RJRl9UWVBFMl9QUk9URUNUSU9OICYmCisJCSAgICBjbWRbMV0gJiAweGUwKSB7CisJCQlta19zZW5zZV9idWZmZXIoZGV2aXAsIElMTEVHQUxfUkVRVUVTVCwKKwkJCQkJSU5WQUxJRF9DT01NQU5EX09QQ09ERSwgMCk7CisJCQllcnJzdHMgPSBjaGVja19jb25kaXRpb25fcmVzdWx0OworCQkJYnJlYWs7CisJCX0KKworCQlpZiAoKHNjc2lfZGVidWdfZGlmID09IFNEX0RJRl9UWVBFMV9QUk9URUNUSU9OIHx8CisJCSAgICAgc2NzaV9kZWJ1Z19kaWYgPT0gU0RfRElGX1RZUEUzX1BST1RFQ1RJT04pICYmCisJCSAgICAoY21kWzFdICYgMHhlMCkgPT0gMCkKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5wcm90ZWN0ZWQgUkQvV1IgdG8gRElGIGRldmljZVxuIik7CisKKwkJLyogZmFsbCB0aHJvdWdoICovCiAJY2FzZSBSRUFEXzY6CityZWFkOgogCQllcnJzdHMgPSBjaGVja19yZWFkaW5lc3MoU0NwbnQsIDAsIGRldmlwKTsKIAkJaWYgKGVycnN0cykKIAkJCWJyZWFrOwogCQlpZiAoc2NzaV9kZWJ1Z19mYWtlX3J3KQogCQkJYnJlYWs7Ci0JCWdldF9kYXRhX3RyYW5zZmVyX2luZm8oY21kLCAmbGJhLCAmbnVtKTsKLQkJZXJyc3RzID0gcmVzcF9yZWFkKFNDcG50LCBsYmEsIG51bSwgZGV2aXApOworCQlnZXRfZGF0YV90cmFuc2Zlcl9pbmZvKGNtZCwgJmxiYSwgJm51bSwgJmVpX2xiYSk7CisJCWVycnN0cyA9IHJlc3BfcmVhZChTQ3BudCwgbGJhLCBudW0sIGRldmlwLCBlaV9sYmEpOwogCQlpZiAoaW5qX3JlY292ZXJlZCAmJiAoMCA9PSBlcnJzdHMpKSB7CiAJCQlta19zZW5zZV9idWZmZXIoZGV2aXAsIFJFQ09WRVJFRF9FUlJPUiwKIAkJCQkJVEhSRVNIT0xEX0VYQ0VFREVELCAwKTsKQEAgLTMyODgsMTQgKzMzNDIsMzAgQEAKIAljYXNlIFdSSVRFXzE2OgogCWNhc2UgV1JJVEVfMTI6CiAJY2FzZSBXUklURV8xMDoKKwkJLyogV1JJVEV7MTAsMTIsMTZ9IGFuZCBESUYgVHlwZSAyIGFyZSBuYXR1cmFsIGVuZW1pZXMgKi8KKwkJaWYgKHNjc2lfZGVidWdfZGlmID09IFNEX0RJRl9UWVBFMl9QUk9URUNUSU9OICYmCisJCSAgICBjbWRbMV0gJiAweGUwKSB7CisJCQlta19zZW5zZV9idWZmZXIoZGV2aXAsIElMTEVHQUxfUkVRVUVTVCwKKwkJCQkJSU5WQUxJRF9DT01NQU5EX09QQ09ERSwgMCk7CisJCQllcnJzdHMgPSBjaGVja19jb25kaXRpb25fcmVzdWx0OworCQkJYnJlYWs7CisJCX0KKworCQlpZiAoKHNjc2lfZGVidWdfZGlmID09IFNEX0RJRl9UWVBFMV9QUk9URUNUSU9OIHx8CisJCSAgICAgc2NzaV9kZWJ1Z19kaWYgPT0gU0RfRElGX1RZUEUzX1BST1RFQ1RJT04pICYmCisJCSAgICAoY21kWzFdICYgMHhlMCkgPT0gMCkKKwkJCXByaW50ayhLRVJOX0VSUiAiVW5wcm90ZWN0ZWQgUkQvV1IgdG8gRElGIGRldmljZVxuIik7CisKKwkJLyogZmFsbCB0aHJvdWdoICovCiAJY2FzZSBXUklURV82Ogord3JpdGU6CiAJCWVycnN0cyA9IGNoZWNrX3JlYWRpbmVzcyhTQ3BudCwgMCwgZGV2aXApOwogCQlpZiAoZXJyc3RzKQogCQkJYnJlYWs7CiAJCWlmIChzY3NpX2RlYnVnX2Zha2VfcncpCiAJCQlicmVhazsKLQkJZ2V0X2RhdGFfdHJhbnNmZXJfaW5mbyhjbWQsICZsYmEsICZudW0pOwotCQllcnJzdHMgPSByZXNwX3dyaXRlKFNDcG50LCBsYmEsIG51bSwgZGV2aXApOworCQlnZXRfZGF0YV90cmFuc2Zlcl9pbmZvKGNtZCwgJmxiYSwgJm51bSwgJmVpX2xiYSk7CisJCWVycnN0cyA9IHJlc3Bfd3JpdGUoU0NwbnQsIGxiYSwgbnVtLCBkZXZpcCwgZWlfbGJhKTsKIAkJaWYgKGlual9yZWNvdmVyZWQgJiYgKDAgPT0gZXJyc3RzKSkgewogCQkJbWtfc2Vuc2VfYnVmZmVyKGRldmlwLCBSRUNPVkVSRURfRVJST1IsCiAJCQkJCVRIUkVTSE9MRF9FWENFRURFRCwgMCk7CkBAIC0zMzQxLDE1ICszNDExLDM4IEBACiAJCQlicmVhazsKIAkJaWYgKHNjc2lfZGVidWdfZmFrZV9ydykKIAkJCWJyZWFrOwotCQlnZXRfZGF0YV90cmFuc2Zlcl9pbmZvKGNtZCwgJmxiYSwgJm51bSk7Ci0JCWVycnN0cyA9IHJlc3BfcmVhZChTQ3BudCwgbGJhLCBudW0sIGRldmlwKTsKKwkJZ2V0X2RhdGFfdHJhbnNmZXJfaW5mbyhjbWQsICZsYmEsICZudW0sICZlaV9sYmEpOworCQllcnJzdHMgPSByZXNwX3JlYWQoU0NwbnQsIGxiYSwgbnVtLCBkZXZpcCwgZWlfbGJhKTsKIAkJaWYgKGVycnN0cykKIAkJCWJyZWFrOwotCQllcnJzdHMgPSByZXNwX3dyaXRlKFNDcG50LCBsYmEsIG51bSwgZGV2aXApOworCQllcnJzdHMgPSByZXNwX3dyaXRlKFNDcG50LCBsYmEsIG51bSwgZGV2aXAsIGVpX2xiYSk7CiAJCWlmIChlcnJzdHMpCiAJCQlicmVhazsKIAkJZXJyc3RzID0gcmVzcF94ZHdyaXRlcmVhZChTQ3BudCwgbGJhLCBudW0sIGRldmlwKTsKIAkJYnJlYWs7CisJY2FzZSBWQVJJQUJMRV9MRU5HVEhfQ01EOgorCQlpZiAoc2NzaV9kZWJ1Z19kaWYgPT0gU0RfRElGX1RZUEUyX1BST1RFQ1RJT04pIHsKKworCQkJaWYgKChjbWRbMTBdICYgMHhlMCkgPT0gMCkKKwkJCQlwcmludGsoS0VSTl9FUlIKKwkJCQkgICAgICAgIlVucHJvdGVjdGVkIFJEL1dSIHRvIERJRiBkZXZpY2VcbiIpOworCisJCQlpZiAoY21kWzldID09IFJFQURfMzIpIHsKKwkJCQlCVUdfT04oU0NwbnQtPmNtZF9sZW4gPCAzMik7CisJCQkJZ290byByZWFkOworCQkJfQorCisJCQlpZiAoY21kWzldID09IFdSSVRFXzMyKSB7CisJCQkJQlVHX09OKFNDcG50LT5jbWRfbGVuIDwgMzIpOworCQkJCWdvdG8gd3JpdGU7CisJCQl9CisJCX0KKworCQlta19zZW5zZV9idWZmZXIoZGV2aXAsIElMTEVHQUxfUkVRVUVTVCwKKwkJCQlJTlZBTElEX0ZJRUxEX0lOX0NEQiwgMCk7CisJCWVycnN0cyA9IGNoZWNrX2NvbmRpdGlvbl9yZXN1bHQ7CisJCWJyZWFrOworCiAJZGVmYXVsdDoKIAkJaWYgKFNDU0lfREVCVUdfT1BUX05PSVNFICYgc2NzaV9kZWJ1Z19vcHRzKQogCQkJcHJpbnRrKEtFUk5fSU5GTyAic2NzaV9kZWJ1ZzogT3Bjb2RlOiAweCV4IG5vdCAiCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc2NzaV9lcnJvci5jIGIvZHJpdmVycy9zY3NpL3Njc2lfZXJyb3IuYwppbmRleCA4NzcyMDRkLi4xYjAwNjBiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2NzaV9lcnJvci5jCisrKyBiL2RyaXZlcnMvc2NzaS9zY3NpX2Vycm9yLmMKQEAgLTcyNSw2ICs3MjUsOSBAQAogCQljYXNlIE5FRURTX1JFVFJZOgogCQljYXNlIEZBSUxFRDoKIAkJCWJyZWFrOworCQljYXNlIEFERF9UT19NTFFVRVVFOgorCQkJcnRuID0gTkVFRFNfUkVUUlk7CisJCQlicmVhazsKIAkJZGVmYXVsdDoKIAkJCXJ0biA9IEZBSUxFRDsKIAkJCWJyZWFrOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3Njc2lfdHJhbnNwb3J0X2ZjLmMgYi9kcml2ZXJzL3Njc2kvc2NzaV90cmFuc3BvcnRfZmMuYwppbmRleCBiOTg4ODVkLi5hNjdmZWQxIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2NzaV90cmFuc3BvcnRfZmMuYworKysgYi9kcml2ZXJzL3Njc2kvc2NzaV90cmFuc3BvcnRfZmMuYwpAQCAtMzU4Niw2ICszNTg2LDcgQEAKIAogLyoqCiAgKiBmY19ic2dfaG9zdF9kaXNwYXRjaCAtIHByb2Nlc3MgZmMgaG9zdCBic2cgcmVxdWVzdHMgYW5kIGRpc3BhdGNoIHRvIExMREQKKyAqIEBxOgkJZmMgaG9zdCByZXF1ZXN0IHF1ZXVlCiAgKiBAc2hvc3Q6CXNjc2kgaG9zdCBycG9ydCBhdHRhY2hlZCB0bwogICogQGpvYjoJYnNnIGpvYiB0byBiZSBwcm9jZXNzZWQKICAqLwpAQCAtMzY5Myw2ICszNjk0LDcgQEAKIAogLyoqCiAgKiBmY19ic2dfcnBvcnRfZGlzcGF0Y2ggLSBwcm9jZXNzIHJwb3J0IGJzZyByZXF1ZXN0cyBhbmQgZGlzcGF0Y2ggdG8gTExERAorICogQHE6CQlycG9ydCByZXF1ZXN0IHF1ZXVlCiAgKiBAc2hvc3Q6CXNjc2kgaG9zdCBycG9ydCBhdHRhY2hlZCB0bwogICogQHJwb3J0OglycG9ydCByZXF1ZXN0IGRlc3RpbmVkIHRvCiAgKiBAam9iOglic2cgam9iIHRvIGJlIHByb2Nlc3NlZApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3NkLmMgYi9kcml2ZXJzL3Njc2kvc2QuYwppbmRleCA4ZGQ5NmRjLi45MDkzYzcyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2QuYworKysgYi9kcml2ZXJzL3Njc2kvc2QuYwpAQCAtMTE2LDYgKzExNiw5IEBACiAgKiBvYmplY3QgYWZ0ZXIgbGFzdCBwdXQpICovCiBzdGF0aWMgREVGSU5FX01VVEVYKHNkX3JlZl9tdXRleCk7CiAKK3N0cnVjdCBrbWVtX2NhY2hlICpzZF9jZGJfY2FjaGU7CittZW1wb29sX3QgKnNkX2NkYl9wb29sOworCiBzdGF0aWMgY29uc3QgY2hhciAqc2RfY2FjaGVfdHlwZXNbXSA9IHsKIAkid3JpdGUgdGhyb3VnaCIsICJub25lIiwgIndyaXRlIGJhY2siLAogCSJ3cml0ZSBiYWNrLCBubyByZWFkIChkYWZ0KSIKQEAgLTM3MCw2ICszNzMsMzEgQEAKIAltdXRleF91bmxvY2soJnNkX3JlZl9tdXRleCk7CiB9CiAKK3N0YXRpYyB2b2lkIHNkX3Byb3Rfb3Aoc3RydWN0IHNjc2lfY21uZCAqc2NtZCwgdW5zaWduZWQgaW50IGRpZikKK3sKKwl1bnNpZ25lZCBpbnQgcHJvdF9vcCA9IFNDU0lfUFJPVF9OT1JNQUw7CisJdW5zaWduZWQgaW50IGRpeCA9IHNjc2lfcHJvdF9zZ19jb3VudChzY21kKTsKKworCWlmIChzY21kLT5zY19kYXRhX2RpcmVjdGlvbiA9PSBETUFfRlJPTV9ERVZJQ0UpIHsKKwkJaWYgKGRpZiAmJiBkaXgpCisJCQlwcm90X29wID0gU0NTSV9QUk9UX1JFQURfUEFTUzsKKwkJZWxzZSBpZiAoZGlmICYmICFkaXgpCisJCQlwcm90X29wID0gU0NTSV9QUk9UX1JFQURfU1RSSVA7CisJCWVsc2UgaWYgKCFkaWYgJiYgZGl4KQorCQkJcHJvdF9vcCA9IFNDU0lfUFJPVF9SRUFEX0lOU0VSVDsKKwl9IGVsc2UgeworCQlpZiAoZGlmICYmIGRpeCkKKwkJCXByb3Rfb3AgPSBTQ1NJX1BST1RfV1JJVEVfUEFTUzsKKwkJZWxzZSBpZiAoZGlmICYmICFkaXgpCisJCQlwcm90X29wID0gU0NTSV9QUk9UX1dSSVRFX0lOU0VSVDsKKwkJZWxzZSBpZiAoIWRpZiAmJiBkaXgpCisJCQlwcm90X29wID0gU0NTSV9QUk9UX1dSSVRFX1NUUklQOworCX0KKworCXNjc2lfc2V0X3Byb3Rfb3Aoc2NtZCwgcHJvdF9vcCk7CisJc2NzaV9zZXRfcHJvdF90eXBlKHNjbWQsIGRpZik7Cit9CisKIC8qKgogICoJc2RfaW5pdF9jb21tYW5kIC0gYnVpbGQgYSBzY3NpIChyZWFkIG9yIHdyaXRlKSBjb21tYW5kIGZyb20KICAqCWluZm9ybWF0aW9uIGluIHRoZSByZXF1ZXN0IHN0cnVjdHVyZS4KQEAgLTM4OCw2ICs0MTYsNyBAQAogCXNlY3Rvcl90IHRocmVzaG9sZDsKIAl1bnNpZ25lZCBpbnQgdGhpc19jb3VudCA9IGJsa19ycV9zZWN0b3JzKHJxKTsKIAlpbnQgcmV0LCBob3N0X2RpZjsKKwl1bnNpZ25lZCBjaGFyIHByb3RlY3Q7CiAKIAlpZiAocnEtPmNtZF90eXBlID09IFJFUV9UWVBFX0JMT0NLX1BDKSB7CiAJCXJldCA9IHNjc2lfc2V0dXBfYmxrX3BjX2NtbmQoc2RwLCBycSk7CkBAIC01MjAsMTMgKzU0OSw0OSBAQAogCS8qIFNldCBSRFBST1RFQ1QvV1JQUk9URUNUIGlmIGRpc2sgaXMgZm9ybWF0dGVkIHdpdGggRElGICovCiAJaG9zdF9kaWYgPSBzY3NpX2hvc3RfZGlmX2NhcGFibGUoc2RwLT5ob3N0LCBzZGtwLT5wcm90ZWN0aW9uX3R5cGUpOwogCWlmIChob3N0X2RpZikKLQkJU0NwbnQtPmNtbmRbMV0gPSAxIDw8IDU7CisJCXByb3RlY3QgPSAxIDw8IDU7CiAJZWxzZQotCQlTQ3BudC0+Y21uZFsxXSA9IDA7CisJCXByb3RlY3QgPSAwOwogCi0JaWYgKGJsb2NrID4gMHhmZmZmZmZmZikgeworCWlmIChob3N0X2RpZiA9PSBTRF9ESUZfVFlQRTJfUFJPVEVDVElPTikgeworCQlTQ3BudC0+Y21uZCA9IG1lbXBvb2xfYWxsb2Moc2RfY2RiX3Bvb2wsIEdGUF9BVE9NSUMpOworCisJCWlmICh1bmxpa2VseShTQ3BudC0+Y21uZCA9PSBOVUxMKSkgeworCQkJcmV0ID0gQkxLUFJFUF9ERUZFUjsKKwkJCWdvdG8gb3V0OworCQl9CisKKwkJU0NwbnQtPmNtZF9sZW4gPSBTRF9FWFRfQ0RCX1NJWkU7CisJCW1lbXNldChTQ3BudC0+Y21uZCwgMCwgU0NwbnQtPmNtZF9sZW4pOworCQlTQ3BudC0+Y21uZFswXSA9IFZBUklBQkxFX0xFTkdUSF9DTUQ7CisJCVNDcG50LT5jbW5kWzddID0gMHgxODsKKwkJU0NwbnQtPmNtbmRbOV0gPSAocnFfZGF0YV9kaXIocnEpID09IFJFQUQpID8gUkVBRF8zMiA6IFdSSVRFXzMyOworCQlTQ3BudC0+Y21uZFsxMF0gPSBwcm90ZWN0IHwgKGJsa19mdWFfcnEocnEpID8gMHg4IDogMCk7CisKKwkJLyogTEJBICovCisJCVNDcG50LT5jbW5kWzEyXSA9IHNpemVvZihibG9jaykgPiA0ID8gKHVuc2lnbmVkIGNoYXIpIChibG9jayA+PiA1NikgJiAweGZmIDogMDsKKwkJU0NwbnQtPmNtbmRbMTNdID0gc2l6ZW9mKGJsb2NrKSA+IDQgPyAodW5zaWduZWQgY2hhcikgKGJsb2NrID4+IDQ4KSAmIDB4ZmYgOiAwOworCQlTQ3BudC0+Y21uZFsxNF0gPSBzaXplb2YoYmxvY2spID4gNCA/ICh1bnNpZ25lZCBjaGFyKSAoYmxvY2sgPj4gNDApICYgMHhmZiA6IDA7CisJCVNDcG50LT5jbW5kWzE1XSA9IHNpemVvZihibG9jaykgPiA0ID8gKHVuc2lnbmVkIGNoYXIpIChibG9jayA+PiAzMikgJiAweGZmIDogMDsKKwkJU0NwbnQtPmNtbmRbMTZdID0gKHVuc2lnbmVkIGNoYXIpIChibG9jayA+PiAyNCkgJiAweGZmOworCQlTQ3BudC0+Y21uZFsxN10gPSAodW5zaWduZWQgY2hhcikgKGJsb2NrID4+IDE2KSAmIDB4ZmY7CisJCVNDcG50LT5jbW5kWzE4XSA9ICh1bnNpZ25lZCBjaGFyKSAoYmxvY2sgPj4gOCkgJiAweGZmOworCQlTQ3BudC0+Y21uZFsxOV0gPSAodW5zaWduZWQgY2hhcikgYmxvY2sgJiAweGZmOworCisJCS8qIEV4cGVjdGVkIEluZGlyZWN0IExCQSAqLworCQlTQ3BudC0+Y21uZFsyMF0gPSAodW5zaWduZWQgY2hhcikgKGJsb2NrID4+IDI0KSAmIDB4ZmY7CisJCVNDcG50LT5jbW5kWzIxXSA9ICh1bnNpZ25lZCBjaGFyKSAoYmxvY2sgPj4gMTYpICYgMHhmZjsKKwkJU0NwbnQtPmNtbmRbMjJdID0gKHVuc2lnbmVkIGNoYXIpIChibG9jayA+PiA4KSAmIDB4ZmY7CisJCVNDcG50LT5jbW5kWzIzXSA9ICh1bnNpZ25lZCBjaGFyKSBibG9jayAmIDB4ZmY7CisKKwkJLyogVHJhbnNmZXIgbGVuZ3RoICovCisJCVNDcG50LT5jbW5kWzI4XSA9ICh1bnNpZ25lZCBjaGFyKSAodGhpc19jb3VudCA+PiAyNCkgJiAweGZmOworCQlTQ3BudC0+Y21uZFsyOV0gPSAodW5zaWduZWQgY2hhcikgKHRoaXNfY291bnQgPj4gMTYpICYgMHhmZjsKKwkJU0NwbnQtPmNtbmRbMzBdID0gKHVuc2lnbmVkIGNoYXIpICh0aGlzX2NvdW50ID4+IDgpICYgMHhmZjsKKwkJU0NwbnQtPmNtbmRbMzFdID0gKHVuc2lnbmVkIGNoYXIpIHRoaXNfY291bnQgJiAweGZmOworCX0gZWxzZSBpZiAoYmxvY2sgPiAweGZmZmZmZmZmKSB7CiAJCVNDcG50LT5jbW5kWzBdICs9IFJFQURfMTYgLSBSRUFEXzY7Ci0JCVNDcG50LT5jbW5kWzFdIHw9IGJsa19mdWFfcnEocnEpID8gMHg4IDogMDsKKwkJU0NwbnQtPmNtbmRbMV0gPSBwcm90ZWN0IHwgKGJsa19mdWFfcnEocnEpID8gMHg4IDogMCk7CiAJCVNDcG50LT5jbW5kWzJdID0gc2l6ZW9mKGJsb2NrKSA+IDQgPyAodW5zaWduZWQgY2hhcikgKGJsb2NrID4+IDU2KSAmIDB4ZmYgOiAwOwogCQlTQ3BudC0+Y21uZFszXSA9IHNpemVvZihibG9jaykgPiA0ID8gKHVuc2lnbmVkIGNoYXIpIChibG9jayA+PiA0OCkgJiAweGZmIDogMDsKIAkJU0NwbnQtPmNtbmRbNF0gPSBzaXplb2YoYmxvY2spID4gNCA/ICh1bnNpZ25lZCBjaGFyKSAoYmxvY2sgPj4gNDApICYgMHhmZiA6IDA7CkBAIC01NDcsNyArNjEyLDcgQEAKIAkJCXRoaXNfY291bnQgPSAweGZmZmY7CiAKIAkJU0NwbnQtPmNtbmRbMF0gKz0gUkVBRF8xMCAtIFJFQURfNjsKLQkJU0NwbnQtPmNtbmRbMV0gfD0gYmxrX2Z1YV9ycShycSkgPyAweDggOiAwOworCQlTQ3BudC0+Y21uZFsxXSA9IHByb3RlY3QgfCAoYmxrX2Z1YV9ycShycSkgPyAweDggOiAwKTsKIAkJU0NwbnQtPmNtbmRbMl0gPSAodW5zaWduZWQgY2hhcikgKGJsb2NrID4+IDI0KSAmIDB4ZmY7CiAJCVNDcG50LT5jbW5kWzNdID0gKHVuc2lnbmVkIGNoYXIpIChibG9jayA+PiAxNikgJiAweGZmOwogCQlTQ3BudC0+Y21uZFs0XSA9ICh1bnNpZ25lZCBjaGFyKSAoYmxvY2sgPj4gOCkgJiAweGZmOwpAQCAtNTc4LDggKzY0Myw3IEBACiAKIAkvKiBJZiBESUYgb3IgRElYIGlzIGVuYWJsZWQsIHRlbGwgSEJBIGhvdyB0byBoYW5kbGUgcmVxdWVzdCAqLwogCWlmIChob3N0X2RpZiB8fCBzY3NpX3Byb3Rfc2dfY291bnQoU0NwbnQpKQotCQlzZF9kaWZfb3AoU0NwbnQsIGhvc3RfZGlmLCBzY3NpX3Byb3Rfc2dfY291bnQoU0NwbnQpLAotCQkJICBzZGtwLT5wcm90ZWN0aW9uX3R5cGUpOworCQlzZF9wcm90X29wKFNDcG50LCBob3N0X2RpZik7CiAKIAkvKgogCSAqIFdlIHNob3VsZG4ndCBkaXNjb25uZWN0IGluIHRoZSBtaWRkbGUgb2YgYSBzZWN0b3IsIHNvIHdpdGggYSBkdW1iCkBAIC0xMDIzLDYgKzEwODcsNyBAQAogCWludCByZXN1bHQgPSBTQ3BudC0+cmVzdWx0OwogCXVuc2lnbmVkIGludCBnb29kX2J5dGVzID0gcmVzdWx0ID8gMCA6IHNjc2lfYnVmZmxlbihTQ3BudCk7CiAJc3RydWN0IHNjc2lfc2Vuc2VfaGRyIHNzaGRyOworCXN0cnVjdCBzY3NpX2Rpc2sgKnNka3AgPSBzY3NpX2Rpc2soU0NwbnQtPnJlcXVlc3QtPnJxX2Rpc2spOwogCWludCBzZW5zZV92YWxpZCA9IDA7CiAJaW50IHNlbnNlX2RlZmVycmVkID0gMDsKIApAQCAtMTA4NCw2ICsxMTQ5LDEwIEBACiAJaWYgKHJxX2RhdGFfZGlyKFNDcG50LT5yZXF1ZXN0KSA9PSBSRUFEICYmIHNjc2lfcHJvdF9zZ19jb3VudChTQ3BudCkpCiAJCXNkX2RpZl9jb21wbGV0ZShTQ3BudCwgZ29vZF9ieXRlcyk7CiAKKwlpZiAoc2NzaV9ob3N0X2RpZl9jYXBhYmxlKHNka3AtPmRldmljZS0+aG9zdCwgc2RrcC0+cHJvdGVjdGlvbl90eXBlKQorCSAgICA9PSBTRF9ESUZfVFlQRTJfUFJPVEVDVElPTiAmJiBTQ3BudC0+Y21uZCAhPSBTQ3BudC0+cmVxdWVzdC0+Y21kKQorCQltZW1wb29sX2ZyZWUoU0NwbnQtPmNtbmQsIHNkX2NkYl9wb29sKTsKKwogCXJldHVybiBnb29kX2J5dGVzOwogfQogCkBAIC0xMjM4LDM0ICsxMzA3LDI4IEBACiAJdTggdHlwZTsKIAogCWlmIChzY3NpX2RldmljZV9wcm90ZWN0aW9uKHNkcCkgPT0gMCB8fCAoYnVmZmVyWzEyXSAmIDEpID09IDApCi0JCXR5cGUgPSAwOwotCWVsc2UKLQkJdHlwZSA9ICgoYnVmZmVyWzEyXSA+PiAxKSAmIDcpICsgMTsgLyogUF9UWVBFIDAgPSBUeXBlIDEgKi8KKwkJcmV0dXJuOworCisJdHlwZSA9ICgoYnVmZmVyWzEyXSA+PiAxKSAmIDcpICsgMTsgLyogUF9UWVBFIDAgPSBUeXBlIDEgKi8KKworCWlmICh0eXBlID09IHNka3AtPnByb3RlY3Rpb25fdHlwZSB8fCAhc2RrcC0+Zmlyc3Rfc2NhbikKKwkJcmV0dXJuOwogCiAJc2RrcC0+cHJvdGVjdGlvbl90eXBlID0gdHlwZTsKIAotCXN3aXRjaCAodHlwZSkgewotCWNhc2UgU0RfRElGX1RZUEUwX1BST1RFQ1RJT046Ci0JY2FzZSBTRF9ESUZfVFlQRTFfUFJPVEVDVElPTjoKLQljYXNlIFNEX0RJRl9UWVBFM19QUk9URUNUSU9OOgotCQlicmVhazsKLQotCWNhc2UgU0RfRElGX1RZUEUyX1BST1RFQ1RJT046Ci0JCXNkX3ByaW50ayhLRVJOX0VSUiwgc2RrcCwgImZvcm1hdHRlZCB3aXRoIERJRiBUeXBlIDIgIglcCi0JCQkgICJwcm90ZWN0aW9uIHdoaWNoIGlzIGN1cnJlbnRseSB1bnN1cHBvcnRlZC4gIglcCi0JCQkgICJEaXNhYmxpbmcgZGlzayFcbiIpOwotCQlnb3RvIGRpc2FibGU7Ci0KLQlkZWZhdWx0OgotCQlzZF9wcmludGsoS0VSTl9FUlIsIHNka3AsICJmb3JtYXR0ZWQgd2l0aCB1bmtub3duICIJXAotCQkJICAicHJvdGVjdGlvbiB0eXBlICVkLiBEaXNhYmxpbmcgZGlzayFcbiIsIHR5cGUpOwotCQlnb3RvIGRpc2FibGU7CisJaWYgKHR5cGUgPiBTRF9ESUZfVFlQRTNfUFJPVEVDVElPTikgeworCQlzZF9wcmludGsoS0VSTl9FUlIsIHNka3AsICJmb3JtYXR0ZWQgd2l0aCB1bnN1cHBvcnRlZCAiCVwKKwkJCSAgInByb3RlY3Rpb24gdHlwZSAldS4gRGlzYWJsaW5nIGRpc2shXG4iLCB0eXBlKTsKKwkJc2RrcC0+Y2FwYWNpdHkgPSAwOworCQlyZXR1cm47CiAJfQogCi0JcmV0dXJuOwotCi1kaXNhYmxlOgotCXNka3AtPmNhcGFjaXR5ID0gMDsKKwlpZiAoc2NzaV9ob3N0X2RpZl9jYXBhYmxlKHNkcC0+aG9zdCwgdHlwZSkpCisJCXNkX3ByaW50ayhLRVJOX05PVElDRSwgc2RrcCwKKwkJCSAgIkVuYWJsaW5nIERJRiBUeXBlICV1IHByb3RlY3Rpb25cbiIsIHR5cGUpOworCWVsc2UKKwkJc2RfcHJpbnRrKEtFUk5fTk9USUNFLCBzZGtwLAorCQkJICAiRGlzYWJsaW5nIERJRiBUeXBlICV1IHByb3RlY3Rpb25cbiIsIHR5cGUpOwogfQogCiBzdGF0aWMgdm9pZCByZWFkX2NhcGFjaXR5X2Vycm9yKHN0cnVjdCBzY3NpX2Rpc2sgKnNka3AsIHN0cnVjdCBzY3NpX2RldmljZSAqc2RwLApAQCAtMjMwMCw4ICsyMzYzLDI0IEBACiAJaWYgKGVycikKIAkJZ290byBlcnJfb3V0X2NsYXNzOwogCisJc2RfY2RiX2NhY2hlID0ga21lbV9jYWNoZV9jcmVhdGUoInNkX2V4dF9jZGIiLCBTRF9FWFRfQ0RCX1NJWkUsCisJCQkJCSAwLCAwLCBOVUxMKTsKKwlpZiAoIXNkX2NkYl9jYWNoZSkgeworCQlwcmludGsoS0VSTl9FUlIgInNkOiBjYW4ndCBpbml0IGV4dGVuZGVkIGNkYiBjYWNoZVxuIik7CisJCWdvdG8gZXJyX291dF9jbGFzczsKKwl9CisKKwlzZF9jZGJfcG9vbCA9IG1lbXBvb2xfY3JlYXRlX3NsYWJfcG9vbChTRF9NRU1QT09MX1NJWkUsIHNkX2NkYl9jYWNoZSk7CisJaWYgKCFzZF9jZGJfcG9vbCkgeworCQlwcmludGsoS0VSTl9FUlIgInNkOiBjYW4ndCBpbml0IGV4dGVuZGVkIGNkYiBwb29sXG4iKTsKKwkJZ290byBlcnJfb3V0X2NhY2hlOworCX0KKwogCXJldHVybiAwOwogCitlcnJfb3V0X2NhY2hlOgorCWttZW1fY2FjaGVfZGVzdHJveShzZF9jZGJfY2FjaGUpOworCiBlcnJfb3V0X2NsYXNzOgogCWNsYXNzX3VucmVnaXN0ZXIoJnNkX2Rpc2tfY2xhc3MpOwogZXJyX291dDoKQEAgLTIzMjEsNiArMjQwMCw5IEBACiAKIAlTQ1NJX0xPR19ITFFVRVVFKDMsIHByaW50aygiZXhpdF9zZDogZXhpdGluZyBzZCBkcml2ZXJcbiIpKTsKIAorCW1lbXBvb2xfZGVzdHJveShzZF9jZGJfcG9vbCk7CisJa21lbV9jYWNoZV9kZXN0cm95KHNkX2NkYl9jYWNoZSk7CisKIAlzY3NpX3VucmVnaXN0ZXJfZHJpdmVyKCZzZF90ZW1wbGF0ZS5nZW5kcnYpOwogCWNsYXNzX3VucmVnaXN0ZXIoJnNkX2Rpc2tfY2xhc3MpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc2QuaCBiL2RyaXZlcnMvc2NzaS9zZC5oCmluZGV4IDg0NzRiNWJhLi5lMzc0ODA0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3Njc2kvc2QuaAorKysgYi9kcml2ZXJzL3Njc2kvc2QuaApAQCAtMzcsNiArMzcsMTEgQEAKICAqLwogI2RlZmluZSBTRF9MQVNUX0JVR0dZX1NFQ1RPUlMJOAogCitlbnVtIHsKKwlTRF9FWFRfQ0RCX1NJWkUgPSAzMiwJLyogRXh0ZW5kZWQgQ0RCIHNpemUgKi8KKwlTRF9NRU1QT09MX1NJWkUgPSAyLAkvKiBDREIgcG9vbCBzaXplICovCit9OworCiBzdHJ1Y3Qgc2NzaV9kaXNrIHsKIAlzdHJ1Y3Qgc2NzaV9kcml2ZXIgKmRyaXZlcjsJLyogYWx3YXlzICZzZF90ZW1wbGF0ZSAqLwogCXN0cnVjdCBzY3NpX2RldmljZSAqZGV2aWNlOwpAQCAtMTAxLDE2ICsxMDYsMTIgQEAKIAogI2lmZGVmIENPTkZJR19CTEtfREVWX0lOVEVHUklUWQogCi1leHRlcm4gdm9pZCBzZF9kaWZfb3Aoc3RydWN0IHNjc2lfY21uZCAqLCB1bnNpZ25lZCBpbnQsIHVuc2lnbmVkIGludCwgdW5zaWduZWQgaW50KTsKIGV4dGVybiB2b2lkIHNkX2RpZl9jb25maWdfaG9zdChzdHJ1Y3Qgc2NzaV9kaXNrICopOwogZXh0ZXJuIGludCBzZF9kaWZfcHJlcGFyZShzdHJ1Y3QgcmVxdWVzdCAqcnEsIHNlY3Rvcl90LCB1bnNpZ25lZCBpbnQpOwogZXh0ZXJuIHZvaWQgc2RfZGlmX2NvbXBsZXRlKHN0cnVjdCBzY3NpX2NtbmQgKiwgdW5zaWduZWQgaW50KTsKIAogI2Vsc2UgLyogQ09ORklHX0JMS19ERVZfSU5URUdSSVRZICovCiAKLXN0YXRpYyBpbmxpbmUgdm9pZCBzZF9kaWZfb3Aoc3RydWN0IHNjc2lfY21uZCAqY21kLCB1bnNpZ25lZCBpbnQgYSwgdW5zaWduZWQgaW50IGIsIHVuc2lnbmVkIGludCBjKQotewotfQogc3RhdGljIGlubGluZSB2b2lkIHNkX2RpZl9jb25maWdfaG9zdChzdHJ1Y3Qgc2NzaV9kaXNrICpkaXNrKQogewogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zY3NpL3NkX2RpZi5jIGIvZHJpdmVycy9zY3NpL3NkX2RpZi5jCmluZGV4IDgyZjE0YTkuLjg4ZGE5NzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zZF9kaWYuYworKysgYi9kcml2ZXJzL3Njc2kvc2RfZGlmLmMKQEAgLTMyMCwxNSArMzIwLDYgQEAKIAkJZGlmID0gMDsgZGl4ID0gMTsKIAl9CiAKLQlpZiAodHlwZSkgewotCQlpZiAoZGlmKQotCQkJc2RfcHJpbnRrKEtFUk5fTk9USUNFLCBzZGtwLAotCQkJCSAgIkVuYWJsaW5nIERJRiBUeXBlICVkIHByb3RlY3Rpb25cbiIsIHR5cGUpOwotCQllbHNlCi0JCQlzZF9wcmludGsoS0VSTl9OT1RJQ0UsIHNka3AsCi0JCQkJICAiRGlzYWJsaW5nIERJRiBUeXBlICVkIHByb3RlY3Rpb25cbiIsIHR5cGUpOwotCX0KLQogCWlmICghZGl4KQogCQlyZXR1cm47CiAKQEAgLTM2MCw2MiArMzUxLDYgQEAKIH0KIAogLyoKLSAqIERJRiBETUEgb3BlcmF0aW9uIG1hZ2ljIGRlY29kZXIgcmluZy4KLSAqLwotdm9pZCBzZF9kaWZfb3Aoc3RydWN0IHNjc2lfY21uZCAqc2NtZCwgdW5zaWduZWQgaW50IGRpZiwgdW5zaWduZWQgaW50IGRpeCwgdW5zaWduZWQgaW50IHR5cGUpCi17Ci0JaW50IGNzdW1fY29udmVydCwgcHJvdF9vcDsKLQotCXByb3Rfb3AgPSAwOwotCi0JLyogQ29udmVydCBjaGVja3N1bT8gKi8KLQlpZiAoc2NzaV9ob3N0X2dldF9ndWFyZChzY21kLT5kZXZpY2UtPmhvc3QpICE9IFNIT1NUX0RJWF9HVUFSRF9DUkMpCi0JCWNzdW1fY29udmVydCA9IDE7Ci0JZWxzZQotCQljc3VtX2NvbnZlcnQgPSAwOwotCi0JQlVHX09OKGRpZiAmJiAoc2NtZC0+Y21uZFswXSA9PSBSRUFEXzYgfHwgc2NtZC0+Y21uZFswXSA9PSBXUklURV82KSk7Ci0KLQlzd2l0Y2ggKHNjbWQtPmNtbmRbMF0pIHsKLQljYXNlIFJFQURfNjoKLQljYXNlIFJFQURfMTA6Ci0JY2FzZSBSRUFEXzEyOgotCWNhc2UgUkVBRF8xNjoKLQkJaWYgKGRpZiAmJiBkaXgpCi0JCQlpZiAoY3N1bV9jb252ZXJ0KQotCQkJCXByb3Rfb3AgPSBTQ1NJX1BST1RfUkVBRF9DT05WRVJUOwotCQkJZWxzZQotCQkJCXByb3Rfb3AgPSBTQ1NJX1BST1RfUkVBRF9QQVNTOwotCQllbHNlIGlmIChkaWYgJiYgIWRpeCkKLQkJCXByb3Rfb3AgPSBTQ1NJX1BST1RfUkVBRF9TVFJJUDsKLQkJZWxzZSBpZiAoIWRpZiAmJiBkaXgpCi0JCQlwcm90X29wID0gU0NTSV9QUk9UX1JFQURfSU5TRVJUOwotCi0JCWJyZWFrOwotCi0JY2FzZSBXUklURV82OgotCWNhc2UgV1JJVEVfMTA6Ci0JY2FzZSBXUklURV8xMjoKLQljYXNlIFdSSVRFXzE2OgotCQlpZiAoZGlmICYmIGRpeCkKLQkJCWlmIChjc3VtX2NvbnZlcnQpCi0JCQkJcHJvdF9vcCA9IFNDU0lfUFJPVF9XUklURV9DT05WRVJUOwotCQkJZWxzZQotCQkJCXByb3Rfb3AgPSBTQ1NJX1BST1RfV1JJVEVfUEFTUzsKLQkJZWxzZSBpZiAoZGlmICYmICFkaXgpCi0JCQlwcm90X29wID0gU0NTSV9QUk9UX1dSSVRFX0lOU0VSVDsKLQkJZWxzZSBpZiAoIWRpZiAmJiBkaXgpCi0JCQlwcm90X29wID0gU0NTSV9QUk9UX1dSSVRFX1NUUklQOwotCi0JCWJyZWFrOwotCX0KLQotCXNjc2lfc2V0X3Byb3Rfb3Aoc2NtZCwgcHJvdF9vcCk7Ci0JaWYgKGRpZikKLQkJc2NzaV9zZXRfcHJvdF90eXBlKHNjbWQsIHR5cGUpOwotfQotCi0vKgogICogVGhlIHZpcnR1YWwgc3RhcnQgc2VjdG9yIGlzIHRoZSBvbmUgdGhhdCB3YXMgb3JpZ2luYWxseSBzdWJtaXR0ZWQKICAqIGJ5IHRoZSBibG9jayBsYXllci4JRHVlIHRvIHBhcnRpdGlvbmluZywgTUQvRE0gY2xvbmluZywgZXRjLiB0aGUKICAqIGFjdHVhbCBwaHlzaWNhbCBzdGFydCBzZWN0b3IgaXMgbGlrZWx5IHRvIGJlIGRpZmZlcmVudC4gIFJlbWFwCmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc2cuYyBiL2RyaXZlcnMvc2NzaS9zZy5jCmluZGV4IDc0N2E1ZTUuLjA0MGY3NTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zZy5jCisrKyBiL2RyaXZlcnMvc2NzaS9zZy5jCkBAIC0xNzA4LDExICsxNzA4LDYgQEAKIAlTZ19zY2F0dGVyX2hvbGQgKnJlcV9zY2hwID0gJnNycC0+ZGF0YTsKIAogCVNDU0lfTE9HX1RJTUVPVVQoNCwgcHJpbnRrKCJzZ19maW5pc2hfcmVtX3JlcTogcmVzX3VzZWQ9JWRcbiIsIChpbnQpIHNycC0+cmVzX3VzZWQpKTsKLQlpZiAoc3JwLT5yZXNfdXNlZCkKLQkJc2dfdW5saW5rX3Jlc2VydmUoc2ZwLCBzcnApOwotCWVsc2UKLQkJc2dfcmVtb3ZlX3NjYXQocmVxX3NjaHApOwotCiAJaWYgKHNycC0+cnEpIHsKIAkJaWYgKHNycC0+YmlvKQogCQkJcmV0ID0gYmxrX3JxX3VubWFwX3VzZXIoc3JwLT5iaW8pOwpAQCAtMTcyMCw2ICsxNzE1LDExIEBACiAJCWJsa19wdXRfcmVxdWVzdChzcnAtPnJxKTsKIAl9CiAKKwlpZiAoc3JwLT5yZXNfdXNlZCkKKwkJc2dfdW5saW5rX3Jlc2VydmUoc2ZwLCBzcnApOworCWVsc2UKKwkJc2dfcmVtb3ZlX3NjYXQocmVxX3NjaHApOworCiAJc2dfcmVtb3ZlX3JlcXVlc3Qoc2ZwLCBzcnApOwogCiAJcmV0dXJuIHJldDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2NzaS9zci5jIGIvZHJpdmVycy9zY3NpL3NyLmMKaW5kZXggZWI2MWY3YS4uZDZmMzQwZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zY3NpL3NyLmMKKysrIGIvZHJpdmVycy9zY3NpL3NyLmMKQEAgLTY4NCwxNCArNjg0LDIwIEBACiAJCWNkLT5jYXBhY2l0eSA9IDB4MWZmZmZmOwogCQlzZWN0b3Jfc2l6ZSA9IDIwNDg7CS8qIEEgZ3Vlc3MsIGp1c3QgaW4gY2FzZSAqLwogCX0gZWxzZSB7Ci0jaWYgMAotCQlpZiAoY2Ryb21fZ2V0X2xhc3Rfd3JpdHRlbigmY2QtPmNkaSwKLQkJCQkJICAgJmNkLT5jYXBhY2l0eSkpCi0jZW5kaWYKLQkJCWNkLT5jYXBhY2l0eSA9IDEgKyAoKGJ1ZmZlclswXSA8PCAyNCkgfAotCQkJCQkJICAgIChidWZmZXJbMV0gPDwgMTYpIHwKLQkJCQkJCSAgICAoYnVmZmVyWzJdIDw8IDgpIHwKLQkJCQkJCSAgICBidWZmZXJbM10pOworCQlsb25nIGxhc3Rfd3JpdHRlbjsKKworCQljZC0+Y2FwYWNpdHkgPSAxICsgKChidWZmZXJbMF0gPDwgMjQpIHwgKGJ1ZmZlclsxXSA8PCAxNikgfAorCQkJCSAgICAoYnVmZmVyWzJdIDw8IDgpIHwgYnVmZmVyWzNdKTsKKwkJLyoKKwkJICogUkVBRF9DQVBBQ0lUWSBkb2Vzbid0IHJldHVybiB0aGUgY29ycmVjdCBzaXplIG9uCisJCSAqIGNlcnRhaW4gVURGIG1lZGlhLiAgSWYgbGFzdF93cml0dGVuIGlzIGxhcmdlciwgdXNlCisJCSAqIGl0IGluc3RlYWQuCisJCSAqCisJCSAqIGh0dHA6Ly9idWd6aWxsYS5rZXJuZWwub3JnL3Nob3dfYnVnLmNnaT9pZD05NjY4CisJCSAqLworCQlpZiAoIWNkcm9tX2dldF9sYXN0X3dyaXR0ZW4oJmNkLT5jZGksICZsYXN0X3dyaXR0ZW4pKQorCQkJY2QtPmNhcGFjaXR5ID0gbWF4X3QobG9uZywgY2QtPmNhcGFjaXR5LCBsYXN0X3dyaXR0ZW4pOworCiAJCXNlY3Rvcl9zaXplID0gKGJ1ZmZlcls0XSA8PCAyNCkgfAogCQkgICAgKGJ1ZmZlcls1XSA8PCAxNikgfCAoYnVmZmVyWzZdIDw8IDgpIHwgYnVmZmVyWzddOwogCQlzd2l0Y2ggKHNlY3Rvcl9zaXplKSB7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3Njc2kvc3QuYyBiL2RyaXZlcnMvc2NzaS9zdC5jCmluZGV4IGIzM2QwNDIuLjEyZDU4YTcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2NzaS9zdC5jCisrKyBiL2RyaXZlcnMvc2NzaS9zdC5jCkBAIC0yODU5LDExICsyODU5LDggQEAKIAkJCWlvY3RsX3Jlc3VsdCA9IHN0X2ludF9pb2N0bChTVHAsIE1UQlNGLCAxKTsKIAogCQlpZiAoY21kX2luID09IE1UU0VUQkxLIHx8IGNtZF9pbiA9PSBTRVRfREVOU19BTkRfQkxLKSB7Ci0JCQlpbnQgb2xkX2Jsb2NrX3NpemUgPSBTVHAtPmJsb2NrX3NpemU7CiAJCQlTVHAtPmJsb2NrX3NpemUgPSBhcmcgJiBNVF9TVF9CTEtTSVpFX01BU0s7CiAJCQlpZiAoU1RwLT5ibG9ja19zaXplICE9IDApIHsKLQkJCQlpZiAob2xkX2Jsb2NrX3NpemUgPT0gMCkKLQkJCQkJbm9ybWFsaXplX2J1ZmZlcihTVHAtPmJ1ZmZlcik7CiAJCQkJKFNUcC0+YnVmZmVyKS0+YnVmZmVyX2Jsb2NrcyA9CiAJCQkJICAgIChTVHAtPmJ1ZmZlciktPmJ1ZmZlcl9zaXplIC8gU1RwLT5ibG9ja19zaXplOwogCQkJfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvODI1MF9wY2kuYyBiL2RyaXZlcnMvc2VyaWFsLzgyNTBfcGNpLmMKaW5kZXggZTcxMDhlNy4uNDJlODU1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zZXJpYWwvODI1MF9wY2kuYworKysgYi9kcml2ZXJzL3NlcmlhbC84MjUwX3BjaS5jCkBAIC0xNTYxLDExICsxNTYxLDE2IEBACiAJcGJuX2V4YXJfWFIxN0MxNTIsCiAJcGJuX2V4YXJfWFIxN0MxNTQsCiAJcGJuX2V4YXJfWFIxN0MxNTgsCisJcGJuX2V4YXJfaWJtX3NhdHVybiwKIAlwYm5fcGFzZW1pXzE2ODJNLAogCXBibl9uaTg0MzBfMiwKIAlwYm5fbmk4NDMwXzQsCiAJcGJuX25pODQzMF84LAogCXBibl9uaTg0MzBfMTYsCisJcGJuX0FERElEQVRBX1BDSWVfMV8zOTA2MjUwLAorCXBibl9BRERJREFUQV9QQ0llXzJfMzkwNjI1MCwKKwlwYm5fQURESURBVEFfUENJZV80XzM5MDYyNTAsCisJcGJuX0FERElEQVRBX1BDSWVfOF8zOTA2MjUwLAogfTsKIAogLyoKQEAgLTIxNDYsNiArMjE1MSwxMyBAQAogCQkuYmFzZV9iYXVkCT0gOTIxNjAwLAogCQkudWFydF9vZmZzZXQJPSAweDIwMCwKIAl9LAorCVtwYm5fZXhhcl9pYm1fc2F0dXJuXSA9IHsKKwkJLmZsYWdzCQk9IEZMX0JBU0UwLAorCQkubnVtX3BvcnRzCT0gMSwKKwkJLmJhc2VfYmF1ZAk9IDkyMTYwMCwKKwkJLnVhcnRfb2Zmc2V0CT0gMHgyMDAsCisJfSwKKwogCS8qCiAJICogUEEgU2VtaSBQV1JmaWNpZW50IFBBNlQtMTY4Mk0gb24tY2hpcCBVQVJUCiAJICovCkBAIC0yMTg1LDYgKzIxOTcsMzcgQEAKIAkJLnVhcnRfb2Zmc2V0CT0gMHgxMCwKIAkJLmZpcnN0X29mZnNldAk9IDB4ODAwLAogCX0sCisJLyoKKwkgKiBBRERJLURBVEEgR21iSCBQQ0ktRXhwcmVzcyBjb21tdW5pY2F0aW9uIGNhcmRzIDxpbmZvQGFkZGktZGF0YS5jb20+CisJICovCisJW3Bibl9BRERJREFUQV9QQ0llXzFfMzkwNjI1MF0gPSB7CisJCS5mbGFncwkJPSBGTF9CQVNFMCwKKwkJLm51bV9wb3J0cwk9IDEsCisJCS5iYXNlX2JhdWQJPSAzOTA2MjUwLAorCQkudWFydF9vZmZzZXQJPSAweDIwMCwKKwkJLmZpcnN0X29mZnNldAk9IDB4MTAwMCwKKwl9LAorCVtwYm5fQURESURBVEFfUENJZV8yXzM5MDYyNTBdID0geworCQkuZmxhZ3MJCT0gRkxfQkFTRTAsCisJCS5udW1fcG9ydHMJPSAyLAorCQkuYmFzZV9iYXVkCT0gMzkwNjI1MCwKKwkJLnVhcnRfb2Zmc2V0CT0gMHgyMDAsCisJCS5maXJzdF9vZmZzZXQJPSAweDEwMDAsCisJfSwKKwlbcGJuX0FERElEQVRBX1BDSWVfNF8zOTA2MjUwXSA9IHsKKwkJLmZsYWdzCQk9IEZMX0JBU0UwLAorCQkubnVtX3BvcnRzCT0gNCwKKwkJLmJhc2VfYmF1ZAk9IDM5MDYyNTAsCisJCS51YXJ0X29mZnNldAk9IDB4MjAwLAorCQkuZmlyc3Rfb2Zmc2V0CT0gMHgxMDAwLAorCX0sCisJW3Bibl9BRERJREFUQV9QQ0llXzhfMzkwNjI1MF0gPSB7CisJCS5mbGFncwkJPSBGTF9CQVNFMCwKKwkJLm51bV9wb3J0cwk9IDgsCisJCS5iYXNlX2JhdWQJPSAzOTA2MjUwLAorCQkudWFydF9vZmZzZXQJPSAweDIwMCwKKwkJLmZpcnN0X29mZnNldAk9IDB4MTAwMCwKKwl9LAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkIHNvZnRtb2RlbV9ibGFja2xpc3RbXSA9IHsKQEAgLTI2NDksNiArMjY5Miw5IEBACiAJCVBDSV9TVUJWRU5ET1JfSURfQ09OTkVDVF9URUNILAogCQlQQ0lfU1VCREVWSUNFX0lEX0NPTk5FQ1RfVEVDSF9QQ0lfVUFSVF84XzQ4NSwgMCwgMCwKIAkJcGJuX2IwXzhfMTg0MzIwMF8yMDAgfSwKKwl7CVBDSV9WRU5ET1JfSURfRVhBUiwgUENJX0RFVklDRV9JRF9FWEFSX1hSMTdDMTUyLAorCQlQQ0lfVkVORE9SX0lEX0lCTSwgUENJX1NVQkRFVklDRV9JRF9JQk1fU0FUVVJOX1NFUklBTF9PTkVfUE9SVCwKKwkJMCwgMCwgcGJuX2V4YXJfaWJtX3NhdHVybiB9LAogCiAJewlQQ0lfVkVORE9SX0lEX1NFQUxFVkVMLCBQQ0lfREVWSUNFX0lEX1NFQUxFVkVMX1U1MzAsCiAJCVBDSV9BTllfSUQsIFBDSV9BTllfSUQsIDAsIDAsCkBAIC0zNTU2LDYgKzM2MDIsMzggQEAKIAkJMCwKIAkJcGJuX2IwXzhfMTE1MjAwIH0sCiAKKwl7CVBDSV9WRU5ET1JfSURfQURESURBVEEsCisJCVBDSV9ERVZJQ0VfSURfQURESURBVEFfQVBDSWU3NTAwLAorCQlQQ0lfQU5ZX0lELAorCQlQQ0lfQU5ZX0lELAorCQkwLAorCQkwLAorCQlwYm5fQURESURBVEFfUENJZV80XzM5MDYyNTAgfSwKKworCXsJUENJX1ZFTkRPUl9JRF9BRERJREFUQSwKKwkJUENJX0RFVklDRV9JRF9BRERJREFUQV9BUENJZTc0MjAsCisJCVBDSV9BTllfSUQsCisJCVBDSV9BTllfSUQsCisJCTAsCisJCTAsCisJCXBibl9BRERJREFUQV9QQ0llXzJfMzkwNjI1MCB9LAorCisJewlQQ0lfVkVORE9SX0lEX0FERElEQVRBLAorCQlQQ0lfREVWSUNFX0lEX0FERElEQVRBX0FQQ0llNzMwMCwKKwkJUENJX0FOWV9JRCwKKwkJUENJX0FOWV9JRCwKKwkJMCwKKwkJMCwKKwkJcGJuX0FERElEQVRBX1BDSWVfMV8zOTA2MjUwIH0sCisKKwl7CVBDSV9WRU5ET1JfSURfQURESURBVEEsCisJCVBDSV9ERVZJQ0VfSURfQURESURBVEFfQVBDSWU3ODAwLAorCQlQQ0lfQU5ZX0lELAorCQlQQ0lfQU5ZX0lELAorCQkwLAorCQkwLAorCQlwYm5fQURESURBVEFfUENJZV84XzM5MDYyNTAgfSwKKwogCXsJUENJX1ZFTkRPUl9JRF9ORVRNT1MsIFBDSV9ERVZJQ0VfSURfTkVUTU9TXzk4MzUsCiAJCVBDSV9WRU5ET1JfSURfSUJNLCAweDAyOTksCiAJCTAsIDAsIHBibl9iMF9idF8yXzExNTIwMCB9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zZXJpYWwvYXRtZWxfc2VyaWFsLmMgYi9kcml2ZXJzL3NlcmlhbC9hdG1lbF9zZXJpYWwuYwppbmRleCAzNTUxYzVjLi45ZDk0OGJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3NlcmlhbC9hdG1lbF9zZXJpYWwuYworKysgYi9kcml2ZXJzL3NlcmlhbC9hdG1lbF9zZXJpYWwuYwpAQCAtMTUzMSw3ICsxNTMxLDcgQEAKIAl2b2lkICpkYXRhOwogCWludCByZXQ7CiAKLQlCVUlMRF9CVUdfT04oIWlzX3Bvd2VyX29mXzIoQVRNRUxfU0VSSUFMX1JJTkdTSVpFKSk7CisJQlVJTERfQlVHX09OKEFUTUVMX1NFUklBTF9SSU5HU0laRSAmIChBVE1FTF9TRVJJQUxfUklOR1NJWkUgLSAxKSk7CiAKIAlwb3J0ID0gJmF0bWVsX3BvcnRzW3BkZXYtPmlkXTsKIAlwb3J0LT5iYWNrdXBfaW1yID0gMDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc2VyaWFsL3NlcmlhbF9jb3JlLmMgYi9kcml2ZXJzL3NlcmlhbC9zZXJpYWxfY29yZS5jCmluZGV4IDE2ODliZGEuLmRjYzcyNDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc2VyaWFsL3NlcmlhbF9jb3JlLmMKKysrIGIvZHJpdmVycy9zZXJpYWwvc2VyaWFsX2NvcmUuYwpAQCAtMTI3MCw2ICsxMjcwLDkgQEAKIAogCUJVR19PTigha2VybmVsX2xvY2tlZCgpKTsKIAorCWlmICghc3RhdGUpCisJCXJldHVybjsKKwogCXVwb3J0ID0gc3RhdGUtPnVhcnRfcG9ydDsKIAlwb3J0ID0gJnN0YXRlLT5wb3J0OwogCkBAIC0xMzE2LDkgKzEzMTksOSBAQAogCSAqLwogCWlmIChwb3J0LT5mbGFncyAmIEFTWU5DX0lOSVRJQUxJWkVEKSB7CiAJCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JCXNwaW5fbG9ja19pcnFzYXZlKCZwb3J0LT5sb2NrLCBmbGFncyk7CisJCXNwaW5fbG9ja19pcnFzYXZlKCZ1cG9ydC0+bG9jaywgZmxhZ3MpOwogCQl1cG9ydC0+b3BzLT5zdG9wX3J4KHVwb3J0KTsKLQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9ydC0+bG9jaywgZmxhZ3MpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ1cG9ydC0+bG9jaywgZmxhZ3MpOwogCQkvKgogCQkgKiBCZWZvcmUgd2UgZHJvcCBEVFIsIG1ha2Ugc3VyZSB0aGUgVUFSVCB0cmFuc21pdHRlcgogCQkgKiBoYXMgY29tcGxldGVseSBkcmFpbmVkOyB0aGlzIGlzIGVzcGVjaWFsbHkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL2FtYmEtcGwwMjIuYyBiL2RyaXZlcnMvc3BpL2FtYmEtcGwwMjIuYwppbmRleCA5NThhM2ZmLi5mZjViYmI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3NwaS9hbWJhLXBsMDIyLmMKKysrIGIvZHJpdmVycy9zcGkvYW1iYS1wbDAyMi5jCkBAIC0xODI2LDcgKzE4MjYsNyBAQAogCQkgKiBTVCBNaWNybyBkZXJpdmF0aXZlLCB0aGlzIGhhcyAzMmJpdCB3aWRlCiAJCSAqIGFuZCAzMiBsb2NhdGlvbnMgZGVlcCBUWC9SWCBGSUZPCiAJCSAqLwotCQkuaWQJPSAweDAwMTA4MDIyLAorCQkuaWQJPSAweDAxMDgwMDIyLAogCQkubWFzawk9IDB4ZmZmZmZmZmYsCiAJCS5kYXRhCT0gJnZlbmRvcl9zdCwKIAl9LApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL0tjb25maWcgYi9kcml2ZXJzL3N0YWdpbmcvS2NvbmZpZwppbmRleCA5YTRkZDU5Li43ZGYzYmE0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvS2NvbmZpZworKysgYi9kcml2ZXJzL3N0YWdpbmcvS2NvbmZpZwpAQCAtNTksOCArNTksNiBAQAogCiBzb3VyY2UgImRyaXZlcnMvc3RhZ2luZy9wb2NoL0tjb25maWciCiAKLXNvdXJjZSAiZHJpdmVycy9zdGFnaW5nL2FnbngvS2NvbmZpZyIKLQogc291cmNlICJkcml2ZXJzL3N0YWdpbmcvb3R1cy9LY29uZmlnIgogCiBzb3VyY2UgImRyaXZlcnMvc3RhZ2luZy9ydDI4NjAvS2NvbmZpZyIKQEAgLTEyOSw3ICsxMjcsNSBAQAogCiBzb3VyY2UgImRyaXZlcnMvc3RhZ2luZy9paW8vS2NvbmZpZyIKIAotc291cmNlICJkcml2ZXJzL3N0YWdpbmcvY293bG9vcC9LY29uZmlnIgotCiBlbmRpZiAjICFTVEFHSU5HX0VYQ0xVREVfQlVJTEQKIGVuZGlmICMgU1RBR0lORwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL01ha2VmaWxlIGIvZHJpdmVycy9zdGFnaW5nL01ha2VmaWxlCmluZGV4IDEwNGYyZjguLjc0NzU3MTEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9NYWtlZmlsZQorKysgYi9kcml2ZXJzL3N0YWdpbmcvTWFrZWZpbGUKQEAgLTEyLDcgKzEyLDYgQEAKIG9iai0kKENPTkZJR19QUklTTTJfVVNCKQkrPSB3bGFuLW5nLwogb2JqLSQoQ09ORklHX0VDSE8pCQkrPSBlY2hvLwogb2JqLSQoQ09ORklHX1BPQ0gpCQkrPSBwb2NoLwotb2JqLSQoQ09ORklHX0FHTlgpCQkrPSBhZ254Lwogb2JqLSQoQ09ORklHX09UVVMpCQkrPSBvdHVzLwogb2JqLSQoQ09ORklHX1JUMjg2MCkJCSs9IHJ0Mjg2MC8KIG9iai0kKENPTkZJR19SVDI4NzApCQkrPSBydDI4NzAvCkBAIC00Niw0ICs0NSwzIEBACiBvYmotJChDT05GSUdfUkFSX1JFR0lTVEVSKQkrPSByYXIvCiBvYmotJChDT05GSUdfRFhfU0VQKQkJKz0gc2VwLwogb2JqLSQoQ09ORklHX0lJTykJCSs9IGlpby8KLW9iai0kKENPTkZJR19DT1dMT09QKQkJKz0gY293bG9vcC8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L0tjb25maWcgYi9kcml2ZXJzL3N0YWdpbmcvYWdueC9LY29uZmlnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3ZjQzNTQ5Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L0tjb25maWcKKysrIC9kZXYvbnVsbApAQCAtMSw1ICswLDAgQEAKLWNvbmZpZyBBR05YCi0JdHJpc3RhdGUgIldpcmVsZXNzIEFpcmdvIEFHTlggc3VwcG9ydCIKLQlkZXBlbmRzIG9uIFdMQU5fODAyMTEgJiYgTUFDODAyMTEKLQktLS1oZWxwLS0tCi0JICBUaGlzIGlzIGFuIGV4cGVyaW1lbnRhbCBkcml2ZXIgZm9yIEFpcmdvIEFHTlgwMCB3aXJlbGVzcyBjaGlwLgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2FnbngvTWFrZWZpbGUgYi9kcml2ZXJzL3N0YWdpbmcvYWdueC9NYWtlZmlsZQpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMTIxNjU2NC4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYWdueC9NYWtlZmlsZQorKysgL2Rldi9udWxsCkBAIC0xLDggKzAsMCBAQAotb2JqLSQoQ09ORklHX0FHTlgpCSs9IGFnbngubwotCi1hZ254LW9ianMgOj0JcmYubwlcCi0JCXBjaS5vCVwKLQkJeG1pdC5vCVwKLQkJdGFibGUubwlcCi0JCXN0YS5vCVwKLQkJcGh5Lm8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L1RPRE8gYi9kcml2ZXJzL3N0YWdpbmcvYWdueC9UT0RPCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4OWJlYzc0Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L1RPRE8KKysrIC9kZXYvbnVsbApAQCAtMSwyMiArMCwwIEBACi0yMDA4IDcvMTgKLQotVGhlIFJYIGhhcyBjYW4ndCByZWNlaXZlIE9GRE0gcGFja2V0IGNvcnJlY3RseSwKLUd1ZXNzIGl0IG5lZWQgYmUgZG8gUlggY2FsaWJyYXRlLgotCi0KLWJlZm9yZSAyMDA4IDMvMQotCi0xOiBUaGUgUlggZ2V0IHRvbyBtdWNoICJDUkMgZmFpbGVkIiBwYWtldHMsIGl0IG1ha2UgdGhlIGNhcmQgd29yayB2ZXJ5IHVuc3RhYmxlLAotMjogQWZ0ZXIgcnVubmluZyBhIHdoaWxlLCB0aGUgY2FyZCB3aWxsIGdldCBpbmZpbml0eSAiUlggRnJhbWUiIGFuZCAiRXJyb3IiCi1pbnRlcnJ1cHQsIG5vdCBrbm93IHRoZSByb290IHJlYXNvbiBzbyBmYXIsIHRyeSB0byBmaXggaXQKLTM6IFVzaW5nIHR3byB0eCBxdWV1ZSB0eGQgYW5kIHR4bSBidXQgbm90IG9ubHkgdHhtLgotNDogU2V0IHRoZSBoZHIgY29ycmVjdGx5LgotNTogVHJ5IHRvIGRvIHJlY2FsaWJyYXRlIGNvcnJldnRseQotNjogVG8gc3VwcG9ydCBHIG1vZGUgaW4gZnV0dXJlCi03OiBGaXggdGhlIG1hYyBhZGRyZXNzIGNhbid0IGJlIHJlYWRlZCBhbmQgc2V0IGNvcnJlY3RseSBpbiBCRSBtYWNoaW5lLgotODogRml4IGluY2x1ZGUgYW5kIGV4Y2x1ZGUgRkNTIGluIHByb21pc291cyBtb2RlIGFuZCBtYW5hZ2UgbW9kZQotOTogVXNpbmcgc3RhX25vdGlmeSB0byBub3RpY2Ugc3RhIGNoYW5nZQotMTA6IFR1cm4gb24gZnJhbWUgcmVjZXB0aW9uIGF0IHRoZSBlbmQgb2Ygc3RhcnQKLTExOiBHdWVzcyB0aGUgY2FyZCBzdXBwb3J0IEhXX01VTFRJQ0FTVF9GSUxURVIKLTEyOiBUaGUgdHggcHJvY2VzcyBzaG91bGQgYmUgaW1wbG1lbnQgYXRvbWljPwotMTM6IFVzaW5nIG1hYzgwMjExIGZ1bmN0aW9uIHRvIGNvbnRyb2wgdGhlIFRYJlJYIExFRC4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L2FnbnguaCBiL2RyaXZlcnMvc3RhZ2luZy9hZ254L2FnbnguaApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMzk2M2QyNS4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYWdueC9hZ254LmgKKysrIC9kZXYvbnVsbApAQCAtMSwxNTYgKzAsMCBAQAotI2lmbmRlZiBBR05YX0hfCi0jZGVmaW5lIEFHTlhfSF8KLQotI2luY2x1ZGUgPGxpbnV4L2lvLmg+Ci0KLSNpbmNsdWRlICJ4bWl0LmgiCi0KLSNkZWZpbmUgUEZYCQkJCUtCVUlMRF9NT0ROQU1FICI6ICIKLQotc3RhdGljIGlubGluZSB1MzIgYWdueF9yZWFkMzIodm9pZCBfX2lvbWVtICptZW1fcmVnaW9uLCB1MzIgb2Zmc2V0KQotewotCXJldHVybiBpb3JlYWQzMihtZW1fcmVnaW9uICsgb2Zmc2V0KTsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIGFnbnhfd3JpdGUzMih2b2lkIF9faW9tZW0gKm1lbV9yZWdpb24sIHUzMiBvZmZzZXQsIHUzMiB2YWwpCi17Ci0JaW93cml0ZTMyKHZhbCwgbWVtX3JlZ2lvbiArIG9mZnNldCk7Ci19Ci0KLS8qIHN0YXRpYyBjb25zdCBzdHJ1Y3QgaWVlZTgwMjExX3JhdGUgYWdueF9yYXRlc184MDIxMWJbXSA9IHsgKi8KLS8qIAl7IC5yYXRlID0gMTAsICovCi0vKiAJICAudmFsID0gMHhhLCAqLwotLyogCSAgLmZsYWdzID0gSUVFRTgwMjExX1JBVEVfQ0NLIH0sICovCi0vKiAJeyAucmF0ZSA9IDIwLCAqLwotLyogCSAgLnZhbCA9IDB4MTQsICovCi0vKiAJICAuaHdfdmFsdWUgPSAtMHgxNCwgKi8KLS8qIAkgIC5mbGFncyA9IElFRUU4MDIxMV9SQVRFX0NDS18yIH0sICovCi0vKiAJeyAucmF0ZSA9IDU1LCAqLwotLyogCSAgLnZhbCA9IDB4MzcsICovCi0vKiAJICAudmFsMiA9IC0weDM3LCAqLwotLyogCSAgLmZsYWdzID0gSUVFRTgwMjExX1JBVEVfQ0NLXzIgfSwgKi8KLS8qIAl7IC5yYXRlID0gMTEwLCAqLwotLyogCSAgLnZhbCA9IDB4NmUsICovCi0vKiAJICAudmFsMiA9IC0weDZlLCAqLwotLyogCSAgLmZsYWdzID0gSUVFRTgwMjExX1JBVEVfQ0NLXzIgfSAqLwotLyogfTsgKi8KLQotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9yYXRlIGFnbnhfcmF0ZXNfODAyMTFnW10gPSB7Ci0vKiAJeyAuYml0cmF0ZSA9IDEwLCAuaHdfdmFsdWUgPSAxLCAuZmxhZ3MgPSBJRUVFODAyMTFfUkFURV9TSE9SVF9QUkVBTUJMRSB9LCAqLwotLyogCXsgLmJpdHJhdGUgPSAyMCwgLmh3X3ZhbHVlID0gMiwgLmZsYWdzID0gSUVFRTgwMjExX1JBVEVfU0hPUlRfUFJFQU1CTEUgfSwgKi8KLS8qIAl7IC5iaXRyYXRlID0gNTUsIC5od192YWx1ZSA9IDMsIC5mbGFncyA9IElFRUU4MDIxMV9SQVRFX1NIT1JUX1BSRUFNQkxFIH0sICovCi0vKiAJeyAuYml0cmF0ZSA9IDExMCwgLmh3X3ZhbHVlID0gNCwgLmZsYWdzID0gSUVFRTgwMjExX1JBVEVfU0hPUlRfUFJFQU1CTEUgfSwgKi8KLQl7IC5iaXRyYXRlID0gMTAsIC5od192YWx1ZSA9IDEsIH0sCi0JeyAuYml0cmF0ZSA9IDIwLCAuaHdfdmFsdWUgPSAyLCB9LAotCXsgLmJpdHJhdGUgPSA1NSwgLmh3X3ZhbHVlID0gMywgfSwKLQl7IC5iaXRyYXRlID0gMTEwLCAuaHdfdmFsdWUgPSA0LH0sCi0KLQl7IC5iaXRyYXRlID0gNjAsIC5od192YWx1ZSA9IDB4QiwgfSwKLQl7IC5iaXRyYXRlID0gOTAsIC5od192YWx1ZSA9IDB4RiwgfSwKLQl7IC5iaXRyYXRlID0gMTIwLCAuaHdfdmFsdWUgPSAweEEgfSwKLQl7IC5iaXRyYXRlID0gMTgwLCAuaHdfdmFsdWUgPSAweEUsIH0sCi0vKgl7IC5iaXRyYXRlID0gMjQwLCAuaHdfdmFsdWUgPSAweGQsIH0sICovCi0JeyAuYml0cmF0ZSA9IDM2MCwgLmh3X3ZhbHVlID0gMHhELCB9LAotCXsgLmJpdHJhdGUgPSA0ODAsIC5od192YWx1ZSA9IDB4OCwgfSwKLQl7IC5iaXRyYXRlID0gNTQwLCAuaHdfdmFsdWUgPSAweEMsIH0sCi19OwotCi1zdGF0aWMgY29uc3Qgc3RydWN0IGllZWU4MDIxMV9jaGFubmVsIGFnbnhfY2hhbm5lbHNbXSA9IHsKLQl7IC5jZW50ZXJfZnJlcSA9IDI0MTIsIC5od192YWx1ZSA9IDEsIH0sCi0JeyAuY2VudGVyX2ZyZXEgPSAyNDE3LCAuaHdfdmFsdWUgPSAyLCB9LAotCXsgLmNlbnRlcl9mcmVxID0gMjQyMiwgLmh3X3ZhbHVlID0gMywgfSwKLQl7IC5jZW50ZXJfZnJlcSA9IDI0MjcsIC5od192YWx1ZSA9IDQsIH0sCi0JeyAuY2VudGVyX2ZyZXEgPSAyNDMyLCAuaHdfdmFsdWUgPSA1LCB9LAotCXsgLmNlbnRlcl9mcmVxID0gMjQzNywgLmh3X3ZhbHVlID0gNiwgfSwKLQl7IC5jZW50ZXJfZnJlcSA9IDI0NDIsIC5od192YWx1ZSA9IDcsIH0sCi0JeyAuY2VudGVyX2ZyZXEgPSAyNDQ3LCAuaHdfdmFsdWUgPSA4LCB9LAotCXsgLmNlbnRlcl9mcmVxID0gMjQ1MiwgLmh3X3ZhbHVlID0gOSwgfSwKLQl7IC5jZW50ZXJfZnJlcSA9IDI0NTcsIC5od192YWx1ZSA9IDEwLCB9LAotCXsgLmNlbnRlcl9mcmVxID0gMjQ2MiwgLmh3X3ZhbHVlID0gMTEsIH0sCi0JeyAuY2VudGVyX2ZyZXEgPSAyNDY3LCAuaHdfdmFsdWUgPSAxMiwgfSwKLQl7IC5jZW50ZXJfZnJlcSA9IDI0NzIsIC5od192YWx1ZSA9IDEzLCB9LAotCXsgLmNlbnRlcl9mcmVxID0gMjQ4NCwgLmh3X3ZhbHVlID0gMTQsIH0sCi19OwotCi0jZGVmaW5lIE5VTV9EUklWRV9NT0RFUwkyCi0vKiBBZ254IG9wZXJhdGUgbW9kZSAqLwotZW51bSB7Ci0JQUdOWF9NT0RFXzgwMjExQSwKLQlBR05YX01PREVfODAyMTFBX09PQiwKLQlBR05YX01PREVfODAyMTFBX01JTU8sCi0JQUdOWF9NT0RFXzgwMjExQl9TSE9SVCwKLQlBR05YX01PREVfODAyMTFCX0xPTkcsCi0JQUdOWF9NT0RFXzgwMjExRywKLQlBR05YX01PREVfODAyMTFHX09PQiwKLQlBR05YX01PREVfODAyMTFHX01JTU8sCi19OwotCi1lbnVtIHsKLQlBR05YX1VOSU5JVCwKLQlBR05YX1NUQVJULAotCUFHTlhfU1RPUCwKLX07Ci0KLXN0cnVjdCBhZ254X3ByaXYgewotCXN0cnVjdCBwY2lfZGV2ICpwZGV2OwotCXN0cnVjdCBpZWVlODAyMTFfaHcgKmh3OwotCi0Jc3BpbmxvY2tfdCBsb2NrOwotCXN0cnVjdCBtdXRleCBtdXRleDsKLQl1bnNpZ25lZCBpbnQgaW5pdF9zdGF0dXM7Ci0KLQl2b2lkIF9faW9tZW0gKmN0bDsJLyogcG9pbnRlciB0byBiYXNlIHJhbSBhZGRyZXNzICovCi0Jdm9pZCBfX2lvbWVtICpkYXRhOwkvKiBwb2ludGVyIHRvIG1lbSByZWdpb24gIzIgKi8KLQotCXN0cnVjdCBhZ254X3Jpbmcgcng7Ci0Jc3RydWN0IGFnbnhfcmluZyB0eG07Ci0Jc3RydWN0IGFnbnhfcmluZyB0eGQ7Ci0KLQkvKiBOZWVkIHZvbGF0aWxlPyAqLwotCXUzMiBpcnFfc3RhdHVzOwotCi0Jc3RydWN0IGRlbGF5ZWRfd29yayBwZXJpb2RpY193b3JrOyAvKiBQZXJpb2RpYyB0YXNrcyBsaWtlIHJlY2FsaWJyYXRlICovCi0Jc3RydWN0IGllZWU4MDIxMV9sb3dfbGV2ZWxfc3RhdHMgc3RhdHM7Ci0KLQkvKiB1bnNpZ25lZCBpbnQgcGh5bW9kZTsgKi8KLQlpbnQgbW9kZTsKLQlpbnQgY2hhbm5lbDsKLQl1OCBic3NpZFtFVEhfQUxFTl07Ci0KLQl1OCBtYWNfYWRkcltFVEhfQUxFTl07Ci0JdTggcmV2aWQ7Ci0KLQlzdHJ1Y3QgaWVlZTgwMjExX3N1cHBvcnRlZF9iYW5kIGJhbmQ7Ci19OwotCi0KLSNkZWZpbmUgQUdOWF9DSEFJTlNfTUFYCTYKLSNkZWZpbmUgQUdOWF9QRVJJT0RJQ19ERUxBWSA2MDAwMCAvKiB1bml0OiBtcyAqLwotI2RlZmluZSBMT0NBTF9TVEFJRAkwCS8qIHRoZSBzdGF0aW9uIGVudHJ5IGZvciB0aGUgY2FyZCBpdHNlbGYgKi8KLSNkZWZpbmUgQlNTSURfU1RBSUQJMQkvKiB0aGUgc3RhdGlvbiBlbnRyeSBmb3IgdGhlIGJzc3NpZCBBUCAqLwotI2RlZmluZQlzcGlfZGVsYXkoKQl1ZGVsYXkoNDApCi0jZGVmaW5lIGVlcHJvbV9kZWxheSgpCXVkZWxheSg0MCkKLSNkZWZpbmUJcm91dGluZ190YWJsZV9kZWxheSgpCXVkZWxheSg1MCkKLQotLyogUERVIHBvb2wgTUVNIHJlZ2lvbiAjMiAqLwotI2RlZmluZSBBR05YX1BEVVBPT0wJCTB4NDAwMDAJLyogUERVIHBvb2wgKi8KLSNkZWZpbmUgQUdOWF9QRFVQT09MX1NJWkUJMHg4MDAwCS8qIFBEVSBwb29sIHNpemUqLwotI2RlZmluZSBBR05YX1BEVV9UWF9XUQkJMHg0MTAwMAkvKiBQRFUgbGlzdCBUWCB3b3JrcXVldWUgKi8KLSNkZWZpbmUgQUdOWF9QRFVfRlJFRQkJMHg0MTgwMAkvKiBGcmVlIFBvb2wgKi8KLSNkZWZpbmUgUERVX1NJWkUJCTB4ODAJLyogRnJlZSBQb29sIG5vZGUgc2l6ZSAqLwotI2RlZmluZSBQRFVfRlJFRV9DTlQJCTB4ZDAgLyogRnJlZSBwb29sIG5vZGUgY291bnQgKi8KLQotCi0vKiBSRiBzdHVmZnMgKi8KLWV4dGVybiB2b2lkIHJmX2NoaXBzX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci1leHRlcm4gdm9pZCBzcGlfcmNfd3JpdGUodm9pZCBfX2lvbWVtICptZW1fcmVnaW9uLCB1MzIgY2hpcF9pZHMsIHUzMiBzdyk7Ci1leHRlcm4gdm9pZCBjYWxpYnJhdGVfb3NjaWxsYXRvcihzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLWV4dGVybiB2b2lkIGRvX2NhbGlicmF0aW9uKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpOwotZXh0ZXJuIHZvaWQgYW50ZW5uYV9jYWxpYnJhdGUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci1leHRlcm4gdm9pZCBfX2FudGVubmFfY2FsaWJyYXRlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpOwotZXh0ZXJuIHZvaWQgcHJpbnRfb2Zmc2V0cyhzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLWV4dGVybiBpbnQgYWdueF9zZXRfY2hhbm5lbChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgY2hhbm5lbCk7Ci0KLQotI2VuZGlmIC8qIEFHTlhfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L2RlYnVnLmggYi9kcml2ZXJzL3N0YWdpbmcvYWdueC9kZWJ1Zy5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA3OTQ3ZjMyLi4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L2RlYnVnLmgKKysrIC9kZXYvbnVsbApAQCAtMSw0MTYgKzAsMCBAQAotI2lmbmRlZiBBR05YX0RFQlVHX0hfCi0jZGVmaW5lIEFHTlhfREVCVUdfSF8KLQotI2luY2x1ZGUgImFnbnguaCIKLSNpbmNsdWRlICJwaHkuaCIKLSNpbmNsdWRlICJzdGEuaCIKLSNpbmNsdWRlICJ4bWl0LmgiCi0KLSNkZWZpbmUgQUdOWF9UUkFDRSAgICAgICAgICAgICAgcHJpbnRrKEtFUk5fRVJSIFBGWCAiZnVuY3Rpb246JXMgbGluZTolZFxuIiwgX19mdW5jX18sIF9fTElORV9fKQotCi0jZGVmaW5lIFBSSU5US19MRTE2KHByZWZpeCwgdmFyKQlwcmludGsoS0VSTl9ERUJVRyBQRlggI3ByZWZpeCAiOiAiICN2YXIgIiAweCUuNHhcbiIsIGxlMTZfdG9fY3B1KHZhcikpCi0jZGVmaW5lIFBSSU5US19MRTMyKHByZWZpeCwgdmFyKQlwcmludGsoS0VSTl9ERUJVRyBQRlggI3ByZWZpeCAiOiAiICN2YXIgIiAweCUuOHhcbiIsIGxlMzJfdG9fY3B1KHZhcikpCi0jZGVmaW5lIFBSSU5US19VOChwcmVmaXgsIHZhcikgCQlwcmludGsoS0VSTl9ERUJVRyBQRlggI3ByZWZpeCAiOiAiICN2YXIgIiAweCUuMnhcbiIsIHZhcikKLSNkZWZpbmUgUFJJTlRLX0JFMTYocHJlZml4LCB2YXIpCXByaW50ayhLRVJOX0RFQlVHIFBGWCAjcHJlZml4ICI6ICIgI3ZhciAiIDB4JS40eFxuIiwgYmUxNl90b19jcHUodmFyKSkKLSNkZWZpbmUgUFJJTlRLX0JFMzIocHJlZml4LCB2YXIpCXByaW50ayhLRVJOX0RFQlVHIFBGWCAjcHJlZml4ICI6ICIgI3ZhciAiIDB4JS44eFxuIiwgYmUzMl90b19jcHUodmFyKSkKLSNkZWZpbmUgUFJJTlRLX0JJVFMocHJlZml4LCBmaWVsZCkgICAgCXByaW50ayhLRVJOX0RFQlVHIFBGWCAjcHJlZml4ICI6ICIgI2ZpZWxkICI6IDB4JXhcbiIsIChyZWcgJiBmaWVsZCkgPj4gZmllbGQjI19TSElGVCkKLQotc3RhdGljIGlubGluZSB2b2lkIGFnbnhfYnVnKGNoYXIgKnJlYXNvbikKLXsKLQlwcmludGsoS0VSTl9FUlIgUEZYICIlc1xuIiwgcmVhc29uKTsKLQlCVUcoKTsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIGFnbnhfcHJpbnRfZGVzYyhzdHJ1Y3QgYWdueF9kZXNjICpkZXNjKQotewotCXUzMiByZWcgPSBiZTMyX3RvX2NwdShkZXNjLT5mcmFnKTsKLQotCVBSSU5US19CSVRTKERFU0MsIFBBQ0tFVF9MRU4pOwotCi0JaWYgKHJlZyAmIEZJUlNUX0ZSQUcpIHsKLQkJUFJJTlRLX0JJVFMoREVTQywgRklSU1RfUEFDS0VUX01BU0spOwotCQlQUklOVEtfQklUUyhERVNDLCBGSVJTVF9SRVNFUlYyKTsKLQkJUFJJTlRLX0JJVFMoREVTQywgRklSU1RfVEtJUF9FUlJPUik7Ci0JCVBSSU5US19CSVRTKERFU0MsIEZJUlNUX1RLSVBfUEFDS0VUKTsKLQkJUFJJTlRLX0JJVFMoREVTQywgRklSU1RfUkVTRVJWMSk7Ci0JCVBSSU5US19CSVRTKERFU0MsIEZJUlNUX0ZSQUdfTEVOKTsKLQl9IGVsc2UgewotCQlQUklOVEtfQklUUyhERVNDLCBTVUJfUkVTRVJWMik7Ci0JCVBSSU5US19CSVRTKERFU0MsIFNVQl9US0lQX0VSUk9SKTsKLQkJUFJJTlRLX0JJVFMoREVTQywgU1VCX1RLSVBfUEFDS0VUKTsKLQkJUFJJTlRLX0JJVFMoREVTQywgU1VCX1JFU0VSVjEpOwotCQlQUklOVEtfQklUUyhERVNDLCBTVUJfRlJBR19MRU4pOwotCX0KLQotCVBSSU5US19CSVRTKERFU0MsIEZJUlNUX0ZSQUcpOwotCVBSSU5US19CSVRTKERFU0MsIExBU1RfRlJBRyk7Ci0JUFJJTlRLX0JJVFMoREVTQywgT1dORVIpOwotfQotCi0KLXN0YXRpYyBpbmxpbmUgdm9pZCBkdW1wX2llZWU4MDIxMWJfcGh5X2hkcihfX2JlMzIgXzExYjAsIF9fYmUzMiBfMTFiMSkKLXsKLQotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgYWdueF9wcmludF9oZHIoc3RydWN0IGFnbnhfaGRyICpoZHIpCi17Ci0JdTMyIHJlZzsKLQlpbnQgaTsKLQotCXJlZyA9IGJlMzJfdG9fY3B1KGhkci0+cmVnMCk7Ci0JUFJJTlRLX0JJVFMoSERSLCBSVFMpOwotCVBSSU5US19CSVRTKEhEUiwgTVVMVElDQVNUKTsKLQlQUklOVEtfQklUUyhIRFIsIEFDSyk7Ci0JUFJJTlRLX0JJVFMoSERSLCBUTSk7Ci0JUFJJTlRLX0JJVFMoSERSLCBSRUxBWSk7Ci0JUFJJTlRLX0JJVFMoSERSLCBSRVZJU0VEX0ZDUyk7Ci0JUFJJTlRLX0JJVFMoSERSLCBORVhUX0JVRkZFUl9BRERSKTsKLQotCXJlZyA9IGJlMzJfdG9fY3B1KGhkci0+cmVnMSk7Ci0JUFJJTlRLX0JJVFMoSERSLCBNQUNfSERSX0xFTik7Ci0JUFJJTlRLX0JJVFMoSERSLCBEVVJBVElPTl9PVkVSSURFKTsKLQlQUklOVEtfQklUUyhIRFIsIFBIWV9IRFJfT1ZFUklERSk7Ci0JUFJJTlRLX0JJVFMoSERSLCBDUkNfRkFJTCk7Ci0JUFJJTlRLX0JJVFMoSERSLCBTRVFVRU5DRV9OVU1CRVIpOwotCVBSSU5US19CSVRTKEhEUiwgQlVGRl9IRUFEX0FERFIpOwotCi0JcmVnID0gYmUzMl90b19jcHUoaGRyLT5yZWcyKTsKLQlQUklOVEtfQklUUyhIRFIsIFBEVV9DT1VOVCk7Ci0JUFJJTlRLX0JJVFMoSERSLCBXRVBfS0VZKTsKLQlQUklOVEtfQklUUyhIRFIsIFVTRVNfV0VQX0tFWSk7Ci0JUFJJTlRLX0JJVFMoSERSLCBLRUVQX0FMSVZFKTsKLQlQUklOVEtfQklUUyhIRFIsIEJVRkZfVEFJTF9BRERSKTsKLQotCXJlZyA9IGJlMzJfdG9fY3B1KGhkci0+cmVnMyk7Ci0JUFJJTlRLX0JJVFMoSERSLCBDVFNfMTFHKTsKLQlQUklOVEtfQklUUyhIRFIsIFJUU18xMUcpOwotCVBSSU5US19CSVRTKEhEUiwgRlJBR19TSVpFKTsKLQlQUklOVEtfQklUUyhIRFIsIFBBWUxPQURfTEVOKTsKLQlQUklOVEtfQklUUyhIRFIsIEZSQUdfTlVNKTsKLQotCXJlZyA9IGJlMzJfdG9fY3B1KGhkci0+cmVnNCk7Ci0JUFJJTlRLX0JJVFMoSERSLCBSRUxBWV9TVEFJRCk7Ci0JUFJJTlRLX0JJVFMoSERSLCBTVEFUSU9OX0lEKTsKLQlQUklOVEtfQklUUyhIRFIsIFdPUktRVUVVRV9JRCk7Ci0KLQlyZWcgPSBiZTMyX3RvX2NwdShoZHItPnJlZzUpOwotCS8qIHByaW50ZiB0aGUgcm91dGUgZmxhZyAqLwotCVBSSU5US19CSVRTKEhEUiwgUk9VVEVfSE9TVCk7Ci0JUFJJTlRLX0JJVFMoSERSLCBST1VURV9DQVJEX0NQVSk7Ci0JUFJJTlRLX0JJVFMoSERSLCBST1VURV9FTkNSWVBUSU9OKTsKLQlQUklOVEtfQklUUyhIRFIsIFJPVVRFX1RYKTsKLQlQUklOVEtfQklUUyhIRFIsIFJPVVRFX1JYMSk7Ci0JUFJJTlRLX0JJVFMoSERSLCBST1VURV9SWDIpOwotCVBSSU5US19CSVRTKEhEUiwgUk9VVEVfQ09NUFJFU1NJT04pOwotCi0JUFJJTlRLX0JFMzIoSERSLCBoZHItPl8xMWcwKTsKLQlQUklOVEtfQkUzMihIRFIsIGhkci0+XzExZzEpOwotCVBSSU5US19CRTMyKEhEUiwgaGRyLT5fMTFiMCk7Ci0JUFJJTlRLX0JFMzIoSERSLCBoZHItPl8xMWIxKTsKLQotCWR1bXBfaWVlZTgwMjExYl9waHlfaGRyKGhkci0+XzExYjAsIGhkci0+XzExYjEpOwotCi0JLyogRml4bWUgKi8KLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShoZHItPm1hY19oZHIpOyBpKyspIHsKLQkJaWYgKGkgPT0gMCkKLQkJCXByaW50ayhLRVJOX0RFQlVHIFBGWCAiSUVFRTgwMjExIEhEUjogIik7Ci0JCXByaW50aygiJS4yeCAiLCBoZHItPm1hY19oZHJbaV0pOwotCQlpZiAoaSArIDEgPT0gQVJSQVlfU0laRShoZHItPm1hY19oZHIpKQotCQkJcHJpbnRrKCJcbiIpOwotCX0KLQotCVBSSU5US19CRTE2KEhEUiwgaGRyLT5ydHNfZHVyYXRpb24pOwotCVBSSU5US19CRTE2KEhEUiwgaGRyLT5sYXN0X2R1cmF0aW9uKTsKLQlQUklOVEtfQkUxNihIRFIsIGhkci0+c2VjX2xhc3RfZHVyYXRpb24pOwotCVBSSU5US19CRTE2KEhEUiwgaGRyLT5vdGhlcl9kdXJhdGlvbik7Ci0JUFJJTlRLX0JFMTYoSERSLCBoZHItPnR4X290aGVyX2R1cmF0aW9uKTsKLQlQUklOVEtfQkUxNihIRFIsIGhkci0+bGFzdF8xMWdfbGVuKTsKLQlQUklOVEtfQkUxNihIRFIsIGhkci0+b3RoZXJfMTFnX2xlbik7Ci0JUFJJTlRLX0JFMTYoSERSLCBoZHItPmxhc3RfMTFiX2xlbik7Ci0JUFJJTlRLX0JFMTYoSERSLCBoZHItPm90aGVyXzExYl9sZW4pOwotCi0JLyogRklYTUUgKi8KLQlyZWcgPSBiZTE2X3RvX2NwdShoZHItPnJlZzYpOwotCVBSSU5US19CSVRTKEhEUiwgTUJGKTsKLQlQUklOVEtfQklUUyhIRFIsIFJTVkQ0KTsKLQotCVBSSU5US19CRTE2KEhEUiwgaGRyLT5yeF9mcmFnX3N0YXQpOwotCi0JUFJJTlRLX0JFMzIoSERSLCBoZHItPnRpbWVfc3RhbXApOwotCVBSSU5US19CRTMyKEhEUiwgaGRyLT5waHlfc3RhdHNfaGkpOwotCVBSSU5US19CRTMyKEhEUiwgaGRyLT5waHlfc3RhdHNfbG8pOwotCVBSSU5US19CRTMyKEhEUiwgaGRyLT5taWNfa2V5MCk7Ci0JUFJJTlRLX0JFMzIoSERSLCBoZHItPm1pY19rZXkxKTsKLX0gLyogYWdueF9wcmludF9oZHIgKi8KLQotCi1zdGF0aWMgaW5saW5lIHZvaWQgYWdueF9wcmludF9yeF9oZHIoc3RydWN0IGFnbnhfaGRyICpoZHIpCi17Ci0JYWdueF9wcmludF9oZHIoaGRyKTsKLQotCVBSSU5US19CRTE2KEhEUiwgaGRyLT5yeC5yeF9wYWNrZXRfZHVyYXRpb24pOwotCVBSSU5US19CRTE2KEhEUiwgaGRyLT5yeC5yZXBsYXlfY250KTsKLQotCVBSSU5US19VOChIRFIsIGhkci0+cnhfY2hhbm5lbCk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBhZ254X3ByaW50X3R4X2hkcihzdHJ1Y3QgYWdueF9oZHIgKmhkcikKLXsKLQlhZ254X3ByaW50X2hkcihoZHIpOwotCi0JUFJJTlRLX1U4KEhEUiwgaGRyLT50eC5sb25nX3JldHJ5X2xpbWl0KTsKLQlQUklOVEtfVTgoSERSLCBoZHItPnR4LnNob3J0X3JldHJ5X2xpbWl0KTsKLQlQUklOVEtfVTgoSERSLCBoZHItPnR4LmxvbmdfcmV0cnlfY250KTsKLQlQUklOVEtfVTgoSERSLCBoZHItPnR4LnNob3J0X3JldHJ5X2NudCk7Ci0KLQlQUklOVEtfVTgoSERSLCBoZHItPnJ4X2NoYW5uZWwpOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQKLWFnbnhfcHJpbnRfc3RhX3Bvd2VyKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHVuc2lnbmVkIGludCBzdGFfaWR4KQotewotCXN0cnVjdCBhZ254X3N0YV9wb3dlciBwb3dlcjsKLQl1MzIgcmVnOwotCi0JZ2V0X3N0YV9wb3dlcihwcml2LCAmcG93ZXIsIHN0YV9pZHgpOwotCi0JcmVnID0gbGUzMl90b19jcHUocG93ZXIucmVnKTsKLQlQUklOVEtfQklUUyhTVEFfUE9XRVIsIFNJR05BTCk7Ci0JUFJJTlRLX0JJVFMoU1RBX1BPV0VSLCBSQVRFKTsKLQlQUklOVEtfQklUUyhTVEFfUE9XRVIsIFRJRlMpOwotCVBSSU5US19CSVRTKFNUQV9QT1dFUiwgRURDRik7Ci0JUFJJTlRLX0JJVFMoU1RBX1BPV0VSLCBDSEFOTkVMX0JPTkQpOwotCVBSSU5US19CSVRTKFNUQV9QT1dFUiwgUEhZX01PREUpOwotCVBSSU5US19CSVRTKFNUQV9QT1dFUiwgUE9XRVJfTEVWRUwpOwotCVBSSU5US19CSVRTKFNUQV9QT1dFUiwgTlVNX1RSQU5TTUlUVEVSUyk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZAotYWdueF9wcmludF9zdGFfdHhfd3Eoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdW5zaWduZWQgaW50IHN0YV9pZHgsIHVuc2lnbmVkIGludCB3cV9pZHgpCi17Ci0Jc3RydWN0IGFnbnhfc3RhX3R4X3dxIHR4X3dxOwotCXUzMiByZWc7Ci0KLQlnZXRfc3RhX3R4X3dxKHByaXYsICZ0eF93cSwgc3RhX2lkeCwgd3FfaWR4KTsKLQotCXJlZyA9IGxlMzJfdG9fY3B1KHR4X3dxLnJlZzApOwotCVBSSU5US19CSVRTKFNUQV9UWF9XUSwgVEFJTF9QT0lOVEVSKTsKLQlQUklOVEtfQklUUyhTVEFfVFhfV1EsIEhFQURfUE9JTlRFUl9MT1cpOwotCi0JcmVnID0gbGUzMl90b19jcHUodHhfd3EucmVnMyk7Ci0JUFJJTlRLX0JJVFMoU1RBX1RYX1dRLCBIRUFEX1BPSU5URVJfSElHSCk7Ci0JUFJJTlRLX0JJVFMoU1RBX1RYX1dRLCBBQ0tfUE9JTlRFUl9MT1cpOwotCi0JcmVnID0gbGUzMl90b19jcHUodHhfd3EucmVnMSk7Ci0JUFJJTlRLX0JJVFMoU1RBX1RYX1dRLCBBQ0tfUE9JTlRFUl9ISUdIKTsKLQlQUklOVEtfQklUUyhTVEFfVFhfV1EsIEhFQURfVElNT1VUX1RBSUxfUEFDS19DTlQpOwotCVBSSU5US19CSVRTKFNUQV9UWF9XUSwgQUNLX1RJTU9VVF9UQUlMX1BBQ0tfQ05UKTsKLQotCXJlZyA9IGxlMzJfdG9fY3B1KHR4X3dxLnJlZzIpOwotCVBSSU5US19CSVRTKFNUQV9UWF9XUSwgSEVBRF9USU1PVVRfV0lOX0xJTV9CWVRFX0NOVCk7Ci0JUFJJTlRLX0JJVFMoU1RBX1RYX1dRLCBIRUFEX1RJTU9VVF9XSU5fTElNX0ZSQUdfQ05UKTsKLQlQUklOVEtfQklUUyhTVEFfVFhfV1EsIFdPUktfUVVFVUVfQUNLX1RZUEUpOwotCVBSSU5US19CSVRTKFNUQV9UWF9XUSwgV09SS19RVUVVRV9WQUxJRCk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBhZ254X3ByaW50X3N0YV90cmFmZmljKHN0cnVjdCBhZ254X3N0YV90cmFmZmljICp0cmFmZmljKQotewotCXUzMiByZWc7Ci0KLQlyZWcgPSBsZTMyX3RvX2NwdSh0cmFmZmljLT5yZWcwKTsKLQlQUklOVEtfQklUUyhTVEFfVFJBRkZJQywgQUNLX1RJTU9VVF9DTlQpOwotCVBSSU5US19CSVRTKFNUQV9UUkFGRklDLCBUUkFGRklDX0FDS19UWVBFKTsKLQlQUklOVEtfQklUUyhTVEFfVFJBRkZJQywgTkVXX1BBQ0tFVCk7Ci0JUFJJTlRLX0JJVFMoU1RBX1RSQUZGSUMsIFRSQUZGSUNfVkFMSUQpOwotCVBSSU5US19CSVRTKFNUQV9UUkFGRklDLCBSWF9IRFJfREVTQ19QT0lOVEVSKTsKLQotCXJlZyA9IGxlMzJfdG9fY3B1KHRyYWZmaWMtPnJlZzEpOwotCVBSSU5US19CSVRTKFNUQV9UUkFGRklDLCBSWF9QQUNLRVRfVElNRVNUQU1QKTsKLQlQUklOVEtfQklUUyhTVEFfVFJBRkZJQywgVFJBRkZJQ19SRVNFUlZFRCk7Ci0JUFJJTlRLX0JJVFMoU1RBX1RSQUZGSUMsIFNWKTsKLQlQUklOVEtfQklUUyhTVEFfVFJBRkZJQywgUlhfU0VRVUVOQ0VfTlVNKTsKLQotCVBSSU5US19MRTMyKFNUQV9UUkFGRklDLCB0cmFmZmljLT50eF9yZXBsYXlfY250X2xvdyk7Ci0KLQlQUklOVEtfTEUxNihTVEFfVFJBRkZJQywgdHJhZmZpYy0+dHhfcmVwbGF5X2NudF9oaWdoKTsKLQlQUklOVEtfTEUxNihTVEFfVFJBRkZJQywgdHJhZmZpYy0+cnhfcmVwbGF5X2NudF9oaWdoKTsKLQotCVBSSU5US19MRTMyKFNUQV9UUkFGRklDLCB0cmFmZmljLT5yeF9yZXBsYXlfY250X2xvdyk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBhZ254X3ByaW50X3N0YShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgc3RhX2lkeCkKLXsKLQlzdHJ1Y3QgYWdueF9zdGEgc3RhdGlvbjsKLQlzdHJ1Y3QgYWdueF9zdGEgKnN0YSA9ICZzdGF0aW9uOwotCXUzMiByZWc7Ci0JdW5zaWduZWQgaW50IGk7Ci0KLQlnZXRfc3RhKHByaXYsIHN0YSwgc3RhX2lkeCk7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKQotCQlQUklOVEtfTEUzMihTVEEsIHN0YS0+dHhfc2Vzc2lvbl9rZXlzW2ldKTsKLQlmb3IgKGkgPSAwOyBpIDwgNDsgaSsrKQotCQlQUklOVEtfTEUzMihTVEEsIHN0YS0+cnhfc2Vzc2lvbl9rZXlzW2ldKTsKLQotCXJlZyA9IGxlMzJfdG9fY3B1KHN0YS0+cmVnKTsKLQlQUklOVEtfQklUUyhTVEEsIElEXzEpOwotCVBSSU5US19CSVRTKFNUQSwgSURfMCk7Ci0JUFJJTlRLX0JJVFMoU1RBLCBFTkFCTEVfQ09OQ0FURU5BVElPTik7Ci0JUFJJTlRLX0JJVFMoU1RBLCBFTkFCTEVfREVDT01QUkVTU0lPTik7Ci0JUFJJTlRLX0JJVFMoU1RBLCBTVEFfUkVTRVJWRUQpOwotCVBSSU5US19CSVRTKFNUQSwgRUFQKTsKLQlQUklOVEtfQklUUyhTVEEsIEVEX05VTEwpOwotCVBSSU5US19CSVRTKFNUQSwgRU5DUllQVElPTl9QT0xJQ1kpOwotCVBSSU5US19CSVRTKFNUQSwgREVGSU5FRF9LRVlfSUQpOwotCVBSSU5US19CSVRTKFNUQSwgRklYRURfS0VZKTsKLQlQUklOVEtfQklUUyhTVEEsIEtFWV9WQUxJRCk7Ci0JUFJJTlRLX0JJVFMoU1RBLCBTVEFUSU9OX1ZBTElEKTsKLQotCVBSSU5US19MRTMyKFNUQSwgc3RhLT50eF9hZXNfYmxrc191bmljYXN0KTsKLQlQUklOVEtfTEUzMihTVEEsIHN0YS0+cnhfYWVzX2Jsa3NfdW5pY2FzdCk7Ci0KLQlQUklOVEtfTEUxNihTVEEsIHN0YS0+YWVzX2Zvcm1hdF9lcnJfdW5pY2FzdF9jbnQpOwotCVBSSU5US19MRTE2KFNUQSwgc3RhLT5hZXNfcmVwbGF5X3VuaWNhc3QpOwotCi0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPmFlc19kZWNyeXB0X2Vycl91bmljYXN0KTsKLQlQUklOVEtfTEUxNihTVEEsIHN0YS0+YWVzX2RlY3J5cHRfZXJyX2RlZmF1bHQpOwotCi0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnNpbmdsZV9yZXRyeV9wYWNrZXRzKTsKLQlQUklOVEtfTEUxNihTVEEsIHN0YS0+ZmFpbGVkX3R4X3BhY2tldHMpOwotCi0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPm11dGlfcmV0cnlfcGFja2V0cyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPmFja190aW1lb3V0cyk7Ci0KLQlQUklOVEtfTEUxNihTVEEsIHN0YS0+ZnJhZ190eF9jbnQpOwotCVBSSU5US19MRTE2KFNUQSwgc3RhLT5ydHNfYnJxX3NlbnQpOwotCi0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnR4X3BhY2tldHMpOwotCVBSSU5US19MRTE2KFNUQSwgc3RhLT5jdHNfYmFja190aW1lb3V0KTsKLQotCVBSSU5US19MRTMyKFNUQSwgc3RhLT5waHlfc3RhdHNfaGlnaCk7Ci0JUFJJTlRLX0xFMzIoU1RBLCBzdGEtPnBoeV9zdGF0c19sb3cpOwotCi0JLyogZm9yIChpID0gMDsgaSA8IDg7IGkrKykgKi8KLQlhZ254X3ByaW50X3N0YV90cmFmZmljKHN0YS0+dHJhZmZpYyArIDApOwotCi0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3MwX2ZyYWdfc3VjY2Vzcyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3MxX2ZyYWdfc3VjY2Vzcyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3MyX2ZyYWdfc3VjY2Vzcyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3MzX2ZyYWdfc3VjY2Vzcyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3M0X2ZyYWdfc3VjY2Vzcyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3M1X2ZyYWdfc3VjY2Vzcyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3M2X2ZyYWdfc3VjY2Vzcyk7Ci0JUFJJTlRLX0xFMTYoU1RBLCBzdGEtPnRyYWZmaWNfY2xhc3M3X2ZyYWdfc3VjY2Vzcyk7Ci0KLQlQUklOVEtfTEUxNihTVEEsIHN0YS0+bnVtX2ZyYWdfbm9uX3ByaW1lX3JhdGVzKTsKLQlQUklOVEtfTEUxNihTVEEsIHN0YS0+YWNrX3RpbWVvdXRfbm9uX3ByaW1lX3JhdGVzKTsKLX0KLQotCi1zdGF0aWMgaW5saW5lIHZvaWQgZHVtcF9pZWVlODAyMTFfaGRyKHN0cnVjdCBpZWVlODAyMTFfaGRyICpoZHIsIGNoYXIgKnRhZykKLXsKLQl1MTYgZmN0bDsKLQlpbnQgaGRybGVuOwotCi0JZmN0bCA9IGxlMTZfdG9fY3B1KGhkci0+ZnJhbWVfY29udHJvbCk7Ci0Jc3dpdGNoIChmY3RsICYgSUVFRTgwMjExX0ZDVExfRlRZUEUpIHsKLQljYXNlIElFRUU4MDIxMV9GVFlQRV9EQVRBOgotCQlwcmludGsoUEZYICIlcyBEQVRBICIsIHRhZyk7Ci0JCWJyZWFrOwotCWNhc2UgSUVFRTgwMjExX0ZUWVBFX0NUTDoKLQkJcHJpbnRrKFBGWCAiJXMgQ1RMICIsIHRhZyk7Ci0JCWJyZWFrOwotCWNhc2UgSUVFRTgwMjExX0ZUWVBFX01HTVQ6Ci0JCXByaW50ayhQRlggIiVzIE1HTVQgIiwgdGFnKTsKLQkJc3dpdGNoIChmY3RsICYgSUVFRTgwMjExX0ZDVExfU1RZUEUpIHsKLQkJY2FzZSBJRUVFODAyMTFfU1RZUEVfQVNTT0NfUkVROgotCQkJcHJpbnRrKCJTdWJUeXBlOiBBU1NPQ19SRVEgIik7Ci0JCQlicmVhazsKLQkJY2FzZSBJRUVFODAyMTFfU1RZUEVfQVNTT0NfUkVTUDoKLQkJCXByaW50aygiU3ViVHlwZTogQVNTT0NfUkVTUCAiKTsKLQkJCWJyZWFrOwotCQljYXNlIElFRUU4MDIxMV9TVFlQRV9SRUFTU09DX1JFUToKLQkJCXByaW50aygiU3ViVHlwZTogUkVBU1NPQ19SRVEgIik7Ci0JCQlicmVhazsKLQkJY2FzZSBJRUVFODAyMTFfU1RZUEVfUkVBU1NPQ19SRVNQOgotCQkJcHJpbnRrKCJTdWJUeXBlOiBSRUFTU09DX1JFU1AgIik7Ci0JCQlicmVhazsKLQkJY2FzZSBJRUVFODAyMTFfU1RZUEVfUFJPQkVfUkVROgotCQkJcHJpbnRrKCJTdWJUeXBlOiBQUk9CRV9SRVEgIik7Ci0JCQlicmVhazsKLQkJY2FzZSBJRUVFODAyMTFfU1RZUEVfUFJPQkVfUkVTUDoKLQkJCXByaW50aygiU3ViVHlwZTogUFJPQkVfUkVTUCAiKTsKLQkJCWJyZWFrOwotCQljYXNlIElFRUU4MDIxMV9TVFlQRV9CRUFDT046Ci0JCQlwcmludGsoIlN1YlR5cGU6IEJFQUNPTiAiKTsKLQkJCWJyZWFrOwotCQljYXNlIElFRUU4MDIxMV9TVFlQRV9BVElNOgotCQkJcHJpbnRrKCJTdWJUeXBlOiBBVElNICIpOwotCQkJYnJlYWs7Ci0JCWNhc2UgSUVFRTgwMjExX1NUWVBFX0RJU0FTU09DOgotCQkJcHJpbnRrKCJTdWJUeXBlOiBESVNBU1NPQyAiKTsKLQkJCWJyZWFrOwotCQljYXNlIElFRUU4MDIxMV9TVFlQRV9BVVRIOgotCQkJcHJpbnRrKCJTdWJUeXBlOiBBVVRIICIpOwotCQkJYnJlYWs7Ci0JCWNhc2UgSUVFRTgwMjExX1NUWVBFX0RFQVVUSDoKLQkJCXByaW50aygiU3ViVHlwZTogREVBVVRIICIpOwotCQkJYnJlYWs7Ci0JCWNhc2UgSUVFRTgwMjExX1NUWVBFX0FDVElPTjoKLQkJCXByaW50aygiU3ViVHlwZTogQUNUSU9OICIpOwotCQkJYnJlYWs7Ci0JCWRlZmF1bHQ6Ci0JCQlwcmludGsoIlN1YlR5cGU6IFVua25vd1xuIik7Ci0JCX0KLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJcHJpbnRrKFBGWCAiJXMgUGFja2V0IHR5cGU6IFVua25vd1xuIiwgdGFnKTsKLQl9Ci0KLQloZHJsZW4gPSBpZWVlODAyMTFfaGRybGVuKGZjdGwpOwotCi0JaWYgKGhkcmxlbiA+PSA0KQotCQlwcmludGsoIkZDPTB4JTA0eCBEVVI9MHglMDR4IiwKLQkJICAgICAgIGZjdGwsIGxlMTZfdG9fY3B1KGhkci0+ZHVyYXRpb25faWQpKTsKLQlpZiAoaGRybGVuID49IDEwKQotCQlwcmludGsoIiBBMT0lcE0iLCBoZHItPmFkZHIxKTsKLQlpZiAoaGRybGVuID49IDE2KQotCQlwcmludGsoIiBBMj0lcE0iLCBoZHItPmFkZHIyKTsKLQlpZiAoaGRybGVuID49IDI0KQotCQlwcmludGsoIiBBMz0lcE0iLCBoZHItPmFkZHIzKTsKLQlpZiAoaGRybGVuID49IDMwKQotCQlwcmludGsoIiBBND0lcE0iLCBoZHItPmFkZHI0KTsKLQlwcmludGsoIlxuIik7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBkdW1wX3R4bV9yZWdpc3RlcnMoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQlpbnQgaTsKLQlmb3IgKGkgPSAwOyBpIDw9IDB4MWU4OyBpICs9IDQpCi0JCXByaW50ayhLRVJOX0RFQlVHIFBGWCAiVFhNOiAleC0tLT4gMHglLjh4XG4iLCBpLCBpb3JlYWQzMihjdGwgKyBpKSk7Ci19Ci1zdGF0aWMgaW5saW5lIHZvaWQgZHVtcF9yeG1fcmVnaXN0ZXJzKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JaW50IGk7Ci0JZm9yIChpID0gMDsgaSA8PSAweDEwODsgaSArPSA0KQotCQlwcmludGsoS0VSTl9ERUJVRyBQRlggIlJYTTogJXgtLS0+IDB4JS44eFxuIiwgaSwgaW9yZWFkMzIoY3RsICsgMHgyMDAwICsgaSkpOwotfQotc3RhdGljIGlubGluZSB2b2lkIGR1bXBfYm1fcmVnaXN0ZXJzKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JaW50IGk7Ci0JZm9yIChpID0gMDsgaSA8PSAweDkwOyBpICs9IDQpCi0JCXByaW50ayhLRVJOX0RFQlVHIFBGWCAiQk06ICV4LS0tPiAweCUuOHhcbiIsIGksIGlvcmVhZDMyKGN0bCArIDB4MmMwMCArIGkpKTsKLX0KLXN0YXRpYyBpbmxpbmUgdm9pZCBkdW1wX2Npcl9yZWdpc3RlcnMoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQlpbnQgaTsKLQlmb3IgKGkgPSAwOyBpIDw9IDB4Yjg7IGkgKz0gNCkKLQkJcHJpbnRrKEtFUk5fREVCVUcgUEZYICJDSVI6ICV4LS0tPiAweCUuOHhcbiIsIGksIGlvcmVhZDMyKGN0bCArIDB4MzAwMCArIGkpKTsKLX0KLQotI2VuZGlmIC8qIEFHTlhfREVCVUdfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3BjaS5jIGIvZHJpdmVycy9zdGFnaW5nL2FnbngvcGNpLmMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMyYjU0ODkuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2FnbngvcGNpLmMKKysrIC9kZXYvbnVsbApAQCAtMSw2MzUgKzAsMCBAQAotLyoqCi0gKiBBaXJnbyBNSU1PIHdpcmVsZXNzIGRyaXZlcgotICoKLSAqIENvcHlyaWdodCAoYykgMjAwNyBMaSBZYW5CbyA8ZHJlYW1mbHkyODFAZ21haWwuY29tPgotCi0gKiBUaGFua3MgZm9yIEplZmYgV2lsbGlhbXMgPGFuZ2VsYmFuZUBnbWFpbC5jb20+IGRvIHJldmVyc2UgZW5naW5lZXIKLSAqIHdvcmtzIGFuZCBwdWJsaXNoZWQgdGhlIFNQRUNTIGF0IGh0dHA6Ly9haXJnby53ZHdjb25zdWx0aW5nLm5ldC9teW1vaW4KLQotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqLwotCi0jaW5jbHVkZSA8bGludXgvaW5pdC5oPgotI2luY2x1ZGUgPGxpbnV4L2V0aGVyZGV2aWNlLmg+Ci0jaW5jbHVkZSA8bGludXgvcGNpLmg+Ci0jaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KLQotI2luY2x1ZGUgImFnbnguaCIKLSNpbmNsdWRlICJkZWJ1Zy5oIgotI2luY2x1ZGUgInhtaXQuaCIKLSNpbmNsdWRlICJwaHkuaCIKLQotTU9EVUxFX0FVVEhPUigiTGkgWWFuQm8gPGRyZWFtZmx5MjgxQGdtYWlsLmNvbT4iKTsKLU1PRFVMRV9ERVNDUklQVElPTigiQWlyZ28gTUlNTyBQQ0kgd2lyZWxlc3MgZHJpdmVyIik7Ci1NT0RVTEVfTElDRU5TRSgiR1BMIik7Ci0KLXN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCBhZ254X3BjaV9pZF90YmxbXSBfX2RldmluaXRkYXRhID0gewotCXsgUENJX0RFVklDRSgweDE3Y2IsIDB4MDAwMSkgfSwJLyogQmVrbGluIEY1ZDgwMTAsIE5ldGdlYXIgV0dNNTExIGV0YyAqLwotCXsgUENJX0RFVklDRSgweDE3Y2IsIDB4MDAwMikgfSwJLyogTmV0Z2VhciBXcG50NTExICovCi0JeyAwIH0KLX07Ci0KLU1PRFVMRV9ERVZJQ0VfVEFCTEUocGNpLCBhZ254X3BjaV9pZF90YmwpOwotCi0KLXN0YXRpYyBpbmxpbmUgdm9pZCBhZ254X2ludGVycnVwdF9hY2soc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdTMyICpyZWFzb24pCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQotCWlmICgqcmVhc29uICYgQUdOWF9TVEFUX1JYKSB7Ci0JCS8qIE1hcmsgY29tcGxldGUgUlggKi8KLQkJcmVnID0gaW9yZWFkMzIoY3RsICsgQUdOWF9DSVJfUlhDVEwpOwotCQlyZWcgfD0gMHg0OwotCQlpb3dyaXRlMzIocmVnLCBjdGwgKyBBR05YX0NJUl9SWENUTCk7Ci0JCS8qIGRpc2FibGUgUnggaW50ZXJydXB0ICovCi0JfQotCWlmICgqcmVhc29uICYgQUdOWF9TVEFUX1RYKSB7Ci0JCXJlZyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfQ0lSX1RYRENUTCk7Ci0JCWlmIChyZWcgJiAweDQpIHsKLQkJCWlvd3JpdGUzMihyZWcsIGN0bCArIEFHTlhfQ0lSX1RYRENUTCk7Ci0JCQkqcmVhc29uIHw9IEFHTlhfU1RBVF9UWEQ7Ci0JCX0KLQkJcmVnID0gaW9yZWFkMzIoY3RsICsgQUdOWF9DSVJfVFhNQ1RMKTsKLQkJaWYgKHJlZyAmIDB4NCkgewotCQkJaW93cml0ZTMyKHJlZywgY3RsICsgQUdOWF9DSVJfVFhNQ1RMKTsKLQkJCSpyZWFzb24gfD0gQUdOWF9TVEFUX1RYTTsKLQkJfQotCX0KLSNpZiAwCi0JaWYgKCpyZWFzb24gJiBBR05YX1NUQVRfWCkgewotCQlyZWcgPSBpb3JlYWQzMihjdGwgKyBBR05YX0lOVF9TVEFUKTsKLQkJaW93cml0ZTMyKHJlZywgY3RsICsgQUdOWF9JTlRfU1RBVCk7Ci0JCS8qIEZJWE1FIHJlaW5pdCBpbnRlcnJ1cHQgbWFzayAqLwotCQlyZWcgPSAweGMzOTBiZjkgJiB+SVJRX1RYX0JFQUNPTjsKLQkJcmVnICY9IH5JUlFfVFhfRElTQUJMRTsKLQkJaW93cml0ZTMyKHJlZywgY3RsICsgQUdOWF9JTlRfTUFTSyk7Ci0JCWlvd3JpdGUzMigweDgwMCwgY3RsICsgQUdOWF9DSVJfQkxLQ1RMKTsKLQl9Ci0jZW5kaWYKLX0gLyogYWdueF9pbnRlcnJ1cHRfYWNrICovCi0KLXN0YXRpYyBpcnFyZXR1cm5fdCBhZ254X2ludGVycnVwdF9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmRldl9pZCkKLXsKLQlzdHJ1Y3QgaWVlZTgwMjExX2h3ICpkZXYgPSBkZXZfaWQ7Ci0Jc3RydWN0IGFnbnhfcHJpdiAqcHJpdiA9IGRldi0+cHJpdjsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQlpcnFyZXR1cm5fdCByZXQgPSBJUlFfTk9ORTsKLQl1MzIgaXJxX3JlYXNvbjsKLQotCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7Ci0KLS8qCXByaW50ayhLRVJOX0VSUiBQRlggIkdldCBhIGludGVycnVwdCAlc1xuIiwgX19mdW5jX18pOyAqLwotCi0JaWYgKHByaXYtPmluaXRfc3RhdHVzICE9IEFHTlhfU1RBUlQpCi0JCWdvdG8gb3V0OwotCi0JLyogRmlYTUUgIEhlcmUgaGFzIG5vIGxvY2ssIElzIHRoaXMgd2lsbCBsZWFkIHRvIHJhY2U/ICovCi0JaXJxX3JlYXNvbiA9IGlvcmVhZDMyKGN0bCArIEFHTlhfQ0lSX0JMS0NUTCk7Ci0JaWYgKCEoaXJxX3JlYXNvbiAmIDB4NykpCi0JCWdvdG8gb3V0OwotCi0JcmV0ID0gSVJRX0hBTkRMRUQ7Ci0JcHJpdi0+aXJxX3N0YXR1cyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfSU5UX1NUQVQpOwotCi0vKglwcmludGsoUEZYICJJbnRlcnJ1cHQgcmVhc29uIGlzIDB4JXhcbiIsIGlycV9yZWFzb24pOyAqLwotCS8qIE1ha2Ugc3VyZSB0aGUgdHhtIGFuZCB0eGQgZmxhZ3MgZG9uJ3QgY29uZmxpY3Qgd2l0aCBvdGhlciB1bmtub3duCi0JICAgaW50ZXJydXB0IGZsYWcsIG1heWJlIGlzIG5vdCBuZWNlc3NhcnkgKi8KLQlpcnFfcmVhc29uICY9IDB4RjsKLQotCWRpc2FibGVfcnhfaW50ZXJydXB0KHByaXYpOwotCS8qIFRPRE8gTWFrZSBzdXJlIHRoZSBjYXJkIGZpbmlzaGVkIGluaXRpYWxpemVkICovCi0JYWdueF9pbnRlcnJ1cHRfYWNrKHByaXYsICZpcnFfcmVhc29uKTsKLQotCWlmIChpcnFfcmVhc29uICYgQUdOWF9TVEFUX1JYKQotCQloYW5kbGVfcnhfaXJxKHByaXYpOwotCWlmIChpcnFfcmVhc29uICYgQUdOWF9TVEFUX1RYRCkKLQkJaGFuZGxlX3R4ZF9pcnEocHJpdik7Ci0JaWYgKGlycV9yZWFzb24gJiBBR05YX1NUQVRfVFhNKQotCQloYW5kbGVfdHhtX2lycShwcml2KTsKLQlpZiAoaXJxX3JlYXNvbiAmIEFHTlhfU1RBVF9YKQotCQloYW5kbGVfb3RoZXJfaXJxKHByaXYpOwotCi0JZW5hYmxlX3J4X2ludGVycnVwdChwcml2KTsKLW91dDoKLQlzcGluX3VubG9jaygmcHJpdi0+bG9jayk7Ci0JcmV0dXJuIHJldDsKLX0gLyogYWdueF9pbnRlcnJ1cHRfaGFuZGxlciAqLwotCi0KLS8qIEZJWE1FICovCi1zdGF0aWMgaW50IGFnbnhfdHgoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2LCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQotewotCUFHTlhfVFJBQ0U7Ci0JcmV0dXJuIF9hZ254X3R4KGRldi0+cHJpdiwgc2tiKTsKLX0gLyogYWdueF90eCAqLwotCi0KLXN0YXRpYyBpbnQgYWdueF9nZXRfbWFjX2FkZHJlc3Moc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1MzIgcmVnOwotCUFHTlhfVFJBQ0U7Ci0KLQkvKiBBdHRlbnRpb24hIGRpcmVjdGx5IHJlYWQgdGhlIE1BQyBvciBvdGhlciBkYXRlIGZyb20gRUVQUk9NIHdpbGwKLQkgbGVhZCB0byBjYXJkYnVzKFdHTTUxMSkgbG9jayB1cCB3aGVuIHdyaXRlIHRvIFBNIFBMTCByZWdpc3RlciAqLwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgMHgzNTQ0KTsKLQl1ZGVsYXkoNDApOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgMHgzNTRjKTsKLQl1ZGVsYXkoNTApOwotCS8qIEdldCB0aGUgbWFjIGFkZHJlc3MgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIDB4MzU0NCk7Ci0JdWRlbGF5KDQwKTsKLQotCS8qIEhBQ0sgKi8KLQlyZWcgPSBjcHVfdG9fbGUzMihyZWcpOwotCXByaXYtPm1hY19hZGRyWzBdID0gKCh1OCAqKSZyZWcpWzJdOwotCXByaXYtPm1hY19hZGRyWzFdID0gKCh1OCAqKSZyZWcpWzNdOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgMHgzNTQ4KTsKLQl1ZGVsYXkoNTApOwotCSooKHUzMiAqKShwcml2LT5tYWNfYWRkciArIDIpKSA9IGNwdV90b19sZTMyKHJlZyk7Ci0KLQlpZiAoIWlzX3ZhbGlkX2V0aGVyX2FkZHIocHJpdi0+bWFjX2FkZHIpKSB7Ci0JCXByaW50ayhLRVJOX1dBUk5JTkcgUEZYICJyZWFkIG1hYyAlcE1cbiIsIHByaXYtPm1hY19hZGRyKTsKLQkJcHJpbnRrKEtFUk5fV0FSTklORyBQRlggIkludmFsaWQgaHdhZGRyISBVc2luZyByYW5kb20gaHdhZGRyXG4iKTsKLQkJcmFuZG9tX2V0aGVyX2FkZHIocHJpdi0+bWFjX2FkZHIpOwotCX0KLQotCXJldHVybiAwOwotfSAvKiBhZ254X2dldF9tYWNfYWRkcmVzcyAqLwotCi1zdGF0aWMgaW50IGFnbnhfYWxsb2NfcmluZ3Moc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl1bnNpZ25lZCBpbnQgbGVuOwotCUFHTlhfVFJBQ0U7Ci0KLQkvKiBBbGxvY2F0ZSBSWC9UWE0vVFhEIHJpbmdzIGluZm8gKi8KLQlwcml2LT5yeC5zaXplID0gQUdOWF9SWF9SSU5HX1NJWkU7Ci0JcHJpdi0+dHhtLnNpemUgPSBBR05YX1RYTV9SSU5HX1NJWkU7Ci0JcHJpdi0+dHhkLnNpemUgPSBBR05YX1RYRF9SSU5HX1NJWkU7Ci0KLQlsZW4gPSBwcml2LT5yeC5zaXplICsgcHJpdi0+dHhtLnNpemUgKyBwcml2LT50eGQuc2l6ZTsKLQotLyoJcHJpdi0+cnguaW5mbyA9IGt6YWxsb2Moc2l6ZW9mKHN0cnVjdCBhZ254X2luZm8pICogbGVuLCBHRlBfS0VSTkVMKTsgKi8KLQlwcml2LT5yeC5pbmZvID0ga3phbGxvYyhzaXplb2Yoc3RydWN0IGFnbnhfaW5mbykgKiBsZW4sIEdGUF9BVE9NSUMpOwotCWlmICghcHJpdi0+cnguaW5mbykKLQkJcmV0dXJuIC1FTk9NRU07Ci0JcHJpdi0+dHhtLmluZm8gPSBwcml2LT5yeC5pbmZvICsgcHJpdi0+cnguc2l6ZTsKLQlwcml2LT50eGQuaW5mbyA9IHByaXYtPnR4bS5pbmZvICsgcHJpdi0+dHhtLnNpemU7Ci0KLQkvKiBBbGxvY2F0ZSBSWC9UWE0vVFhEIGRlc2NyaXB0b3JzICovCi0JcHJpdi0+cnguZGVzYyA9IHBjaV9hbGxvY19jb25zaXN0ZW50KHByaXYtPnBkZXYsIHNpemVvZihzdHJ1Y3QgYWdueF9kZXNjKSAqIGxlbiwKLQkJCQkJICAgICAmcHJpdi0+cnguZG1hKTsKLQlpZiAoIXByaXYtPnJ4LmRlc2MpIHsKLQkJa2ZyZWUocHJpdi0+cnguaW5mbyk7Ci0JCXJldHVybiAtRU5PTUVNOwotCX0KLQotCXByaXYtPnR4bS5kZXNjID0gcHJpdi0+cnguZGVzYyArIHByaXYtPnJ4LnNpemU7Ci0JcHJpdi0+dHhtLmRtYSA9IHByaXYtPnJ4LmRtYSArIHNpemVvZihzdHJ1Y3QgYWdueF9kZXNjKSAqIHByaXYtPnJ4LnNpemU7Ci0JcHJpdi0+dHhkLmRlc2MgPSBwcml2LT50eG0uZGVzYyArIHByaXYtPnR4bS5zaXplOwotCXByaXYtPnR4ZC5kbWEgPSBwcml2LT50eG0uZG1hICsgc2l6ZW9mKHN0cnVjdCBhZ254X2Rlc2MpICogcHJpdi0+dHhtLnNpemU7Ci0KLQlyZXR1cm4gMDsKLX0gLyogYWdueF9hbGxvY19yaW5ncyAqLwotCi1zdGF0aWMgdm9pZCByaW5nc19mcmVlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0JdW5zaWduZWQgaW50IGxlbiA9IHByaXYtPnJ4LnNpemUgKyBwcml2LT50eG0uc2l6ZSArIHByaXYtPnR4ZC5zaXplOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JQUdOWF9UUkFDRTsKLQotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7Ci0Ja2ZyZWUocHJpdi0+cnguaW5mbyk7Ci0JcGNpX2ZyZWVfY29uc2lzdGVudChwcml2LT5wZGV2LCBzaXplb2Yoc3RydWN0IGFnbnhfZGVzYykgKiBsZW4sCi0JCQkgICAgcHJpdi0+cnguZGVzYywgcHJpdi0+cnguZG1hKTsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7Ci19Ci0KLSNpZiAwCi1zdGF0aWMgdm9pZCBhZ254X3BlcmlvZGljX3dvcmtfaGFuZGxlcihzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspCi17Ci0Jc3RydWN0IGFnbnhfcHJpdiAqcHJpdiA9IGNvbnRhaW5lcl9vZih3b3JrLCBzdHJ1Y3QgYWdueF9wcml2LCBwZXJpb2RpY193b3JrLndvcmspOwotLyoJdW5zaWduZWQgbG9uZyBmbGFnczsgKi8KLQl1bnNpZ25lZCBsb25nIGRlbGF5OwotCi0JLyogZml4bWU6IHVzaW5nIG11dGV4Pz8gKi8KLS8qCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7ICovCi0KLQkvKiBUT0RPIFJlY2FsaWJyYXRlKi8KLS8qCWNhbGlicmF0ZV9vc2NpbGxhdG9yKHByaXYpOyAqLwotLyoJYW50ZW5uYV9jYWxpYnJhdGUocHJpdik7ICovCi0vKglhZ254X3NlbmRfcGFja2V0KHByaXYsIDk5Nyk7ICovCi0JLyogRklYTUUgKi8KLS8qIAlpZiAoZGVidWcgPT0gMykgKi8KLS8qICAgICAgICAgICAgICAgICBkZWxheSA9IG1zZWNzX3RvX2ppZmZpZXMoQUdOWF9QRVJJT0RJQ19ERUxBWSk7ICovCi0vKiAJZWxzZSAqLwotCWRlbGF5ID0gbXNlY3NfdG9famlmZmllcyhBR05YX1BFUklPRElDX0RFTEFZKTsKLS8qCWRlbGF5ID0gcm91bmRfamlmZmllcyhIWiAqIDE1KTsgKi8KLQotCXF1ZXVlX2RlbGF5ZWRfd29yayhwcml2LT5ody0+d29ya3F1ZXVlLCAmcHJpdi0+cGVyaW9kaWNfd29yaywgZGVsYXkpOwotCi0vKglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7ICovCi19Ci0jZW5kaWYKLQotc3RhdGljIGludCBhZ254X3N0YXJ0KHN0cnVjdCBpZWVlODAyMTFfaHcgKmRldikKLXsKLQlzdHJ1Y3QgYWdueF9wcml2ICpwcml2ID0gZGV2LT5wcml2OwotCS8qIHVuc2lnbmVkIGxvbmcgZGVsYXk7ICovCi0JaW50IGVyciA9IDA7Ci0JQUdOWF9UUkFDRTsKLQotCWVyciA9IGFnbnhfYWxsb2NfcmluZ3MocHJpdik7Ci0JaWYgKGVycikgewotCQlwcmludGsoS0VSTl9FUlIgUEZYICJDYW4ndCBhbGxvYyBSWC9UWE0vVFhEIHJpbmdzXG4iKTsKLQkJZ290byBvdXQ7Ci0JfQotCWVyciA9IHJlcXVlc3RfaXJxKHByaXYtPnBkZXYtPmlycSwgJmFnbnhfaW50ZXJydXB0X2hhbmRsZXIsCi0JCQkgIElSUUZfU0hBUkVELCAiYWdueF9wY2kiLCBkZXYpOwotCWlmIChlcnIpIHsKLQkJcHJpbnRrKEtFUk5fRVJSIFBGWCAiRmFpbGVkIHRvIHJlZ2lzdGVyIElSUSBoYW5kbGVyXG4iKTsKLQkJcmluZ3NfZnJlZShwcml2KTsKLQkJZ290byBvdXQ7Ci0JfQotCi0vKgltZGVsYXkoNTAwKTsgKi8KLQotCW1pZ2h0X3NsZWVwKCk7Ci0JYWdueF9od19pbml0KHByaXYpOwotCi0vKgltZGVsYXkoNTAwKTsgKi8KLQltaWdodF9zbGVlcCgpOwotCi0JcHJpdi0+aW5pdF9zdGF0dXMgPSBBR05YX1NUQVJUOwotLyogICAgICAgICBJTklUX0RFTEFZRURfV09SSygmcHJpdi0+cGVyaW9kaWNfd29yaywgYWdueF9wZXJpb2RpY193b3JrX2hhbmRsZXIpOyAqLwotLyogCWRlbGF5ID0gbXNlY3NfdG9famlmZmllcyhBR05YX1BFUklPRElDX0RFTEFZKTsgKi8KLS8qICAgICAgICAgcXVldWVfZGVsYXllZF93b3JrKHByaXYtPmh3LT53b3JrcXVldWUsICZwcml2LT5wZXJpb2RpY193b3JrLCBkZWxheSk7ICovCi1vdXQ6Ci0JcmV0dXJuIGVycjsKLX0gLyogYWdueF9zdGFydCAqLwotCi1zdGF0aWMgdm9pZCBhZ254X3N0b3Aoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2KQotewotCXN0cnVjdCBhZ254X3ByaXYgKnByaXYgPSBkZXYtPnByaXY7Ci0JQUdOWF9UUkFDRTsKLQotCXByaXYtPmluaXRfc3RhdHVzID0gQUdOWF9TVE9QOwotCS8qIG1ha2Ugc3VyZSBoYXJkd2FyZSB3aWxsIG5vdCBnZW5lcmF0ZSBpcnEgKi8KLQlhZ254X2h3X3Jlc2V0KHByaXYpOwotCWZyZWVfaXJxKHByaXYtPnBkZXYtPmlycSwgZGV2KTsKLS8qCWZsdXNoX3dvcmtxdWV1ZShwcml2LT5ody0+d29ya3F1ZXVlKTsgKi8KLS8qCWNhbmNlbF9kZWxheWVkX3dvcmtfc3luYygmcHJpdi0+cGVyaW9kaWNfd29yayk7ICovCi0JdW5maWxsX3JpbmdzKHByaXYpOwotCXJpbmdzX2ZyZWUocHJpdik7Ci19Ci0KLXN0YXRpYyBpbnQgYWdueF9jb25maWcoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2LCB1MzIgY2hhbmdlZCkKLXsKLQlzdHJ1Y3QgYWdueF9wcml2ICpwcml2ID0gZGV2LT5wcml2OwotCXN0cnVjdCBpZWVlODAyMTFfY29uZiAqY29uZiA9ICZkZXYtPmNvbmY7Ci0JaW50IGNoYW5uZWwgPSBpZWVlODAyMTFfZnJlcXVlbmN5X3RvX2NoYW5uZWwoY29uZi0+Y2hhbm5lbC0+Y2VudGVyX2ZyZXEpOwotCUFHTlhfVFJBQ0U7Ci0KLQlzcGluX2xvY2soJnByaXYtPmxvY2spOwotCS8qIEZJWE1FIG5lZWQgcHJpdiBsb2NrPyAqLwotCWlmIChjaGFubmVsICE9IHByaXYtPmNoYW5uZWwpIHsKLQkJcHJpdi0+Y2hhbm5lbCA9IGNoYW5uZWw7Ci0JCWFnbnhfc2V0X2NoYW5uZWwocHJpdiwgcHJpdi0+Y2hhbm5lbCk7Ci0JfQotCi0Jc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOwotCXJldHVybiAwOwotfQotCi1zdGF0aWMgdm9pZCBhZ254X2Jzc19pbmZvX2NoYW5nZWQoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2LAotCQkJCSAgc3RydWN0IGllZWU4MDIxMV92aWYgKnZpZiwKLQkJCQkgIHN0cnVjdCBpZWVlODAyMTFfYnNzX2NvbmYgKmNvbmYsCi0JCQkJICB1MzIgY2hhbmdlZCkKLXsKLQlzdHJ1Y3QgYWdueF9wcml2ICpwcml2ID0gZGV2LT5wcml2OwotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCUFHTlhfVFJBQ0U7Ci0KLQlpZiAoIShjaGFuZ2VkICYgQlNTX0NIQU5HRURfQlNTSUQpKQotCQlyZXR1cm47Ci0KLQlzcGluX2xvY2soJnByaXYtPmxvY2spOwotCi0JaWYgKG1lbWNtcChjb25mLT5ic3NpZCwgcHJpdi0+YnNzaWQsIEVUSF9BTEVOKSkgewotCQlhZ254X3NldF9ic3NpZChwcml2LCBjb25mLT5ic3NpZCk7Ci0JCW1lbWNweShwcml2LT5ic3NpZCwgY29uZi0+YnNzaWQsIEVUSF9BTEVOKTsKLQkJaGFzaF93cml0ZShwcml2LCBjb25mLT5ic3NpZCwgQlNTSURfU1RBSUQpOwotCQlzdGFfaW5pdChwcml2LCBCU1NJRF9TVEFJRCk7Ci0JCS8qIEZJWE1FIG5lZWRlZD8gKi8KLQkJc3RhX3Bvd2VyX2luaXQocHJpdiwgQlNTSURfU1RBSUQpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX01UU00sIDB4ZmYgJiB+MHgxKTsKLQl9Ci0Jc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOwotfSAvKiBhZ254X2Jzc19pbmZvX2NoYW5nZWQgKi8KLQotCi1zdGF0aWMgdm9pZCBhZ254X2NvbmZpZ3VyZV9maWx0ZXIoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2LAotCQkJCSAgdW5zaWduZWQgaW50IGNoYW5nZWRfZmxhZ3MsCi0JCQkJICB1bnNpZ25lZCBpbnQgKnRvdGFsX2ZsYWdzLAotCQkJCSAgaW50IG1jX2NvdW50LCBzdHJ1Y3QgZGV2X21jX2xpc3QgKm1jbGlzdCkKLXsKLQl1bnNpZ25lZCBpbnQgbmV3X2ZsYWdzID0gMDsKLQotCSp0b3RhbF9mbGFncyA9IG5ld19mbGFnczsKLQkvKiBUT0RPICovCi19Ci0KLXN0YXRpYyBpbnQgYWdueF9hZGRfaW50ZXJmYWNlKHN0cnVjdCBpZWVlODAyMTFfaHcgKmRldiwKLQkJCSAgICAgIHN0cnVjdCBpZWVlODAyMTFfaWZfaW5pdF9jb25mICpjb25mKQotewotCXN0cnVjdCBhZ254X3ByaXYgKnByaXYgPSBkZXYtPnByaXY7Ci0JQUdOWF9UUkFDRTsKLQotCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7Ci0JLyogRklYTUUgKi8KLQlpZiAocHJpdi0+bW9kZSAhPSBOTDgwMjExX0lGVFlQRV9NT05JVE9SKQotCQlyZXR1cm4gLUVPUE5PVFNVUFA7Ci0KLQlzd2l0Y2ggKGNvbmYtPnR5cGUpIHsKLQljYXNlIE5MODAyMTFfSUZUWVBFX1NUQVRJT046Ci0JCXByaXYtPm1vZGUgPSBjb25mLT50eXBlOwotCQlicmVhazsKLQlkZWZhdWx0OgotCQlyZXR1cm4gLUVPUE5PVFNVUFA7Ci0JfQotCi0Jc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyB2b2lkIGFnbnhfcmVtb3ZlX2ludGVyZmFjZShzdHJ1Y3QgaWVlZTgwMjExX2h3ICpkZXYsCi0JCQkJICBzdHJ1Y3QgaWVlZTgwMjExX2lmX2luaXRfY29uZiAqY29uZikKLXsKLQlzdHJ1Y3QgYWdueF9wcml2ICpwcml2ID0gZGV2LT5wcml2OwotCUFHTlhfVFJBQ0U7Ci0KLQkvKiBUT0RPICovCi0JcHJpdi0+bW9kZSA9IE5MODAyMTFfSUZUWVBFX01PTklUT1I7Ci19Ci0KLXN0YXRpYyBpbnQgYWdueF9nZXRfc3RhdHMoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2LAotCQkJICBzdHJ1Y3QgaWVlZTgwMjExX2xvd19sZXZlbF9zdGF0cyAqc3RhdHMpCi17Ci0Jc3RydWN0IGFnbnhfcHJpdiAqcHJpdiA9IGRldi0+cHJpdjsKLQlBR05YX1RSQUNFOwotCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7Ci0JLyogVE9ETyAhISAqLwotCW1lbWNweShzdGF0cywgJnByaXYtPnN0YXRzLCBzaXplb2YoKnN0YXRzKSk7Ci0Jc3Bpbl91bmxvY2soJnByaXYtPmxvY2spOwotCi0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyB1NjQgYWdueF9nZXRfdHNmdChzdHJ1Y3QgaWVlZTgwMjExX2h3ICpkZXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSAoKHN0cnVjdCBhZ254X3ByaXYgKilkZXYtPnByaXYpLT5jdGw7Ci0JdTMyIHRzZnRsOwotCXU2NCB0c2Z0OwotCUFHTlhfVFJBQ0U7Ci0KLQkvKiBGSVhNRSAqLwotCXRzZnRsID0gaW9yZWFkMzIoY3RsICsgQUdOWF9UWE1fVElNRVNUQU1QTE8pOwotCXRzZnQgPSBpb3JlYWQzMihjdGwgKyBBR05YX1RYTV9USU1FU1RBTVBISSk7Ci0JdHNmdCA8PD0gMzI7Ci0JdHNmdCB8PSB0c2Z0bDsKLQotCXJldHVybiB0c2Z0OwotfQotCi1zdGF0aWMgaW50IGFnbnhfZ2V0X3R4X3N0YXRzKHN0cnVjdCBpZWVlODAyMTFfaHcgKmRldiwKLQkJCSAgICAgc3RydWN0IGllZWU4MDIxMV90eF9xdWV1ZV9zdGF0cyAqc3RhdHMpCi17Ci0Jc3RydWN0IGFnbnhfcHJpdiAqcHJpdiA9IGRldi0+cHJpdjsKLQlBR05YX1RSQUNFOwotCi0JLyogRklYTUUgbm93IHdlIGp1c3QgdXNpbmcgdHhkIHF1ZXVlLCBidXQgc2hvdWxkIHVzaW5nIHR4bSBxdWV1ZSB0b28gKi8KLQlzdGF0c1swXS5sZW4gPSAocHJpdi0+dHhkLmlkeCAtIHByaXYtPnR4ZC5pZHhfc2VudCkgLyAyOwotCXN0YXRzWzBdLmxpbWl0ID0gcHJpdi0+dHhkLnNpemUgLSAyOwotCXN0YXRzWzBdLmNvdW50ID0gcHJpdi0+dHhkLmlkeCAvIDI7Ci0KLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIHN0cnVjdCBpZWVlODAyMTFfb3BzIGFnbnhfb3BzID0gewotCS50eAkJCT0gYWdueF90eCwKLQkuc3RhcnQJCQk9IGFnbnhfc3RhcnQsCi0JLnN0b3AJCQk9IGFnbnhfc3RvcCwKLQkuYWRkX2ludGVyZmFjZQkJPSBhZ254X2FkZF9pbnRlcmZhY2UsCi0JLnJlbW92ZV9pbnRlcmZhY2UJPSBhZ254X3JlbW92ZV9pbnRlcmZhY2UsCi0JLmNvbmZpZwkJCT0gYWdueF9jb25maWcsCi0JLmJzc19pbmZvX2NoYW5nZWQJPSBhZ254X2Jzc19pbmZvX2NoYW5nZWQsCi0JLmNvbmZpZ3VyZV9maWx0ZXIJPSBhZ254X2NvbmZpZ3VyZV9maWx0ZXIsCi0JLmdldF9zdGF0cwkJPSBhZ254X2dldF9zdGF0cywKLQkuZ2V0X3R4X3N0YXRzCQk9IGFnbnhfZ2V0X3R4X3N0YXRzLAotCS5nZXRfdHNmCQk9IGFnbnhfZ2V0X3RzZnQKLX07Ci0KLXN0YXRpYyB2b2lkIF9fZGV2ZXhpdCBhZ254X3BjaV9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCi17Ci0Jc3RydWN0IGllZWU4MDIxMV9odyAqZGV2ID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwotCXN0cnVjdCBhZ254X3ByaXYgKnByaXY7Ci0JQUdOWF9UUkFDRTsKLQotCWlmICghZGV2KQotCQlyZXR1cm47Ci0JcHJpdiA9IGRldi0+cHJpdjsKLQlpZWVlODAyMTFfdW5yZWdpc3Rlcl9odyhkZXYpOwotCXBjaV9pb3VubWFwKHBkZXYsIHByaXYtPmN0bCk7Ci0JcGNpX2lvdW5tYXAocGRldiwgcHJpdi0+ZGF0YSk7Ci0JcGNpX3JlbGVhc2VfcmVnaW9ucyhwZGV2KTsKLQlwY2lfZGlzYWJsZV9kZXZpY2UocGRldik7Ci0KLQlpZWVlODAyMTFfZnJlZV9odyhkZXYpOwotfQotCi1zdGF0aWMgaW50IF9fZGV2aW5pdCBhZ254X3BjaV9wcm9iZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwKLQkJCQkgICAgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQotewotCXN0cnVjdCBpZWVlODAyMTFfaHcgKmRldjsKLQlzdHJ1Y3QgYWdueF9wcml2ICpwcml2OwotCWludCBlcnI7Ci0KLQllcnIgPSBwY2lfZW5hYmxlX2RldmljZShwZGV2KTsKLQlpZiAoZXJyKSB7Ci0JCWRldl9lcnIoJnBkZXYtPmRldiwgImNhbid0IGVuYWJsZSBwY2kgZGV2aWNlXG4iKTsKLQkJcmV0dXJuIGVycjsKLQl9Ci0KLQllcnIgPSBwY2lfcmVxdWVzdF9yZWdpb25zKHBkZXYsICJhZ254LXBjaSIpOwotCWlmIChlcnIpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiY2FuJ3QgcmVzZXJ2ZSBQQ0kgcmVzb3VyY2VzXG4iKTsKLQkJcmV0dXJuIGVycjsKLQl9Ci0KLQlpZiAocGNpX3NldF9kbWFfbWFzayhwZGV2LCBETUFfQklUX01BU0soMzIpKSB8fAotCSAgICBwY2lfc2V0X2NvbnNpc3RlbnRfZG1hX21hc2socGRldiwgRE1BX0JJVF9NQVNLKDMyKSkpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAibm8gc3VpdGFibGUgRE1BIGF2YWlsYWJsZVxuIik7Ci0JCWVyciA9IC1FSU87Ci0JCWdvdG8gZXJyX2ZyZWVfcmVnOwotCX0KLQotCXBjaV9zZXRfbWFzdGVyKHBkZXYpOwotCi0JZGV2ID0gaWVlZTgwMjExX2FsbG9jX2h3KHNpemVvZigqcHJpdiksICZhZ254X29wcyk7Ci0JaWYgKCFkZXYpIHsKLQkJZGV2X2VycigmcGRldi0+ZGV2LCAiaWVlZTgwMjExIGFsbG9jIGZhaWxlZFxuIik7Ci0JCWVyciA9IC1FTk9NRU07Ci0JCWdvdG8gZXJyX2ZyZWVfcmVnOwotCX0KLQlwcml2ID0gZGV2LT5wcml2OwotCW1lbXNldChwcml2LCAwLCBzaXplb2YoKnByaXYpKTsKLQlwcml2LT5tb2RlID0gTkw4MDIxMV9JRlRZUEVfTU9OSVRPUjsKLQlwcml2LT5wZGV2ID0gcGRldjsKLQlwcml2LT5odyA9IGRldjsKLQlzcGluX2xvY2tfaW5pdCgmcHJpdi0+bG9jayk7Ci0JcHJpdi0+aW5pdF9zdGF0dXMgPSBBR05YX1VOSU5JVDsKLQotCXByaXYtPmN0bCA9IHBjaV9pb21hcChwZGV2LCAwLCAwKTsKLS8qCWRldl9kYmcoJnBkZXYtPmRldiwgIk1FTTEgbWFwcGVkIGFkZHJlc3MgaXMgMHglcFxuIiwgcHJpdi0+Y3RsKTsgKi8KLQlpZiAoIXByaXYtPmN0bCkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBtYXAgZGV2aWNlIG1lbW9yeVxuIik7Ci0JCWVyciA9IC1FTk9NRU07Ci0JCWdvdG8gZXJyX2ZyZWVfZGV2OwotCX0KLQlwcml2LT5kYXRhID0gcGNpX2lvbWFwKHBkZXYsIDEsIDApOwotCWlmICghcHJpdi0+ZGF0YSkgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCBtYXAgZGV2aWNlIG1lbW9yeVxuIik7Ci0JCWVyciA9IC1FTk9NRU07Ci0JCWdvdG8gZXJyX2lvdW5tYXAyOwotCX0KLQotCXBjaV9yZWFkX2NvbmZpZ19ieXRlKHBkZXYsIFBDSV9SRVZJU0lPTl9JRCwgJnByaXYtPnJldmlkKTsKLQotCXByaXYtPmJhbmQuY2hhbm5lbHMgICA9IChzdHJ1Y3QgaWVlZTgwMjExX2NoYW5uZWwgKilhZ254X2NoYW5uZWxzOwotCXByaXYtPmJhbmQubl9jaGFubmVscyA9IEFSUkFZX1NJWkUoYWdueF9jaGFubmVscyk7Ci0JcHJpdi0+YmFuZC5iaXRyYXRlcyAgID0gKHN0cnVjdCBpZWVlODAyMTFfcmF0ZSAqKWFnbnhfcmF0ZXNfODAyMTFnOwotCXByaXYtPmJhbmQubl9iaXRyYXRlcyA9IEFSUkFZX1NJWkUoYWdueF9yYXRlc184MDIxMWcpOwotCi0JLyogSW5pdCBpZWVlODAyLjExIGRldiAgKi8KLQlTRVRfSUVFRTgwMjExX0RFVihkZXYsICZwZGV2LT5kZXYpOwotCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBkZXYpOwotCWRldi0+ZXh0cmFfdHhfaGVhZHJvb20gPSBzaXplb2Yoc3RydWN0IGFnbnhfaGRyKTsKLQotCS8qIEZJWE1FIEl0IG9ubHkgaW5jbHVkZSBGQ1MgaW4gcHJvbWlvdXMgbW9kZSBidXQgbm90IG1hbmFnZSBtb2RlICovCi0vKiAgICAgIGRldi0+ZmxhZ3MgPSAgSUVFRTgwMjExX0hXX1JYX0lOQ0xVREVTX0ZDUzsgKi8KLQlkZXYtPmNoYW5uZWxfY2hhbmdlX3RpbWUgPSA1MDAwOwotCWRldi0+bWF4X3NpZ25hbCA9IDEwMDsKLQkvKiBGSVhNRSAqLwotCWRldi0+cXVldWVzID0gMTsKLQotCWFnbnhfZ2V0X21hY19hZGRyZXNzKHByaXYpOwotCi0JU0VUX0lFRUU4MDIxMV9QRVJNX0FERFIoZGV2LCBwcml2LT5tYWNfYWRkcik7Ci0KLS8qIAkvXCogRklYTUUgKlwvICovCi0vKiAJZm9yIChpID0gMTsgaSA8IE5VTV9EUklWRV9NT0RFUzsgaSsrKSB7ICovCi0vKiAJCWVyciA9IGllZWU4MDIxMV9yZWdpc3Rlcl9od21vZGUoZGV2LCAmcHJpdi0+bW9kZXNbaV0pOyAqLwotLyogCQlpZiAoZXJyKSB7ICovCi0vKiAJCQlwcmludGsoS0VSTl9FUlIgUEZYICJDYW4ndCByZWdpc3RlciBod21vZGVcbiIpOyAqLwotLyogCQkJZ290byAgZXJyX2lvdW5tYXA7ICovCi0vKiAJCX0gKi8KLS8qIAl9ICovCi0KLQlwcml2LT5jaGFubmVsID0gMTsKLQlkZXYtPndpcGh5LT5iYW5kc1tJRUVFODAyMTFfQkFORF8yR0haXSA9ICZwcml2LT5iYW5kOwotCi0JZXJyID0gaWVlZTgwMjExX3JlZ2lzdGVyX2h3KGRldik7Ci0JaWYgKGVycikgewotCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJjYW4ndCByZWdpc3RlciBoYXJkd2FyZVxuIik7Ci0JCWdvdG8gZXJyX2lvdW5tYXA7Ci0JfQotCi0JYWdueF9od19yZXNldChwcml2KTsKLQotCWRldl9pbmZvKCZwZGV2LT5kZXYsICIlczogaHdhZGRyICVwTSwgUmV2IDB4JTAyeFxuIiwKLQkJd2lwaHlfbmFtZShkZXYtPndpcGh5KSwKLQkJZGV2LT53aXBoeS0+cGVybV9hZGRyLCBwcml2LT5yZXZpZCk7Ci0JcmV0dXJuIDA7Ci0KLSBlcnJfaW91bm1hcDoKLQlwY2lfaW91bm1hcChwZGV2LCBwcml2LT5kYXRhKTsKLQotIGVycl9pb3VubWFwMjoKLQlwY2lfaW91bm1hcChwZGV2LCBwcml2LT5jdGwpOwotCi0gZXJyX2ZyZWVfZGV2OgotCXBjaV9zZXRfZHJ2ZGF0YShwZGV2LCBOVUxMKTsKLQlpZWVlODAyMTFfZnJlZV9odyhkZXYpOwotCi0gZXJyX2ZyZWVfcmVnOgotCXBjaV9yZWxlYXNlX3JlZ2lvbnMocGRldik7Ci0KLQlwY2lfZGlzYWJsZV9kZXZpY2UocGRldik7Ci0JcmV0dXJuIGVycjsKLX0gLyogYWdueF9wY2lfcHJvYmUqLwotCi0jaWZkZWYgQ09ORklHX1BNCi0KLXN0YXRpYyBpbnQgYWdueF9wY2lfc3VzcGVuZChzdHJ1Y3QgcGNpX2RldiAqcGRldiwgcG1fbWVzc2FnZV90IHN0YXRlKQotewotCXN0cnVjdCBpZWVlODAyMTFfaHcgKmRldiA9IHBjaV9nZXRfZHJ2ZGF0YShwZGV2KTsKLQlBR05YX1RSQUNFOwotCi0JaWVlZTgwMjExX3N0b3BfcXVldWVzKGRldik7Ci0JYWdueF9zdG9wKGRldik7Ci0KLQlwY2lfc2F2ZV9zdGF0ZShwZGV2KTsKLQlwY2lfc2V0X3Bvd2VyX3N0YXRlKHBkZXYsIHBjaV9jaG9vc2Vfc3RhdGUocGRldiwgc3RhdGUpKTsKLQlyZXR1cm4gMDsKLX0KLQotc3RhdGljIGludCBhZ254X3BjaV9yZXN1bWUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCi17Ci0Jc3RydWN0IGllZWU4MDIxMV9odyAqZGV2ID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwotCUFHTlhfVFJBQ0U7Ci0KLQlwY2lfc2V0X3Bvd2VyX3N0YXRlKHBkZXYsIFBDSV9EMCk7Ci0JcGNpX3Jlc3RvcmVfc3RhdGUocGRldik7Ci0KLQlhZ254X3N0YXJ0KGRldik7Ci0JaWVlZTgwMjExX3dha2VfcXVldWVzKGRldik7Ci0KLQlyZXR1cm4gMDsKLX0KLQotI2Vsc2UKLQotI2RlZmluZSBhZ254X3BjaV9zdXNwZW5kIE5VTEwKLSNkZWZpbmUgYWdueF9wY2lfcmVzdW1lIE5VTEwKLQotI2VuZGlmIC8qIENPTkZJR19QTSAqLwotCi0KLXN0YXRpYyBzdHJ1Y3QgcGNpX2RyaXZlciBhZ254X3BjaV9kcml2ZXIgPSB7Ci0JLm5hbWUJCT0gImFnbngtcGNpIiwKLQkuaWRfdGFibGUJPSBhZ254X3BjaV9pZF90YmwsCi0JLnByb2JlCQk9IGFnbnhfcGNpX3Byb2JlLAotCS5yZW1vdmUJCT0gX19kZXZleGl0X3AoYWdueF9wY2lfcmVtb3ZlKSwKLQkuc3VzcGVuZAk9IGFnbnhfcGNpX3N1c3BlbmQsCi0JLnJlc3VtZQkJPSBhZ254X3BjaV9yZXN1bWUsCi19OwotCi1zdGF0aWMgaW50IF9faW5pdCBhZ254X3BjaV9pbml0KHZvaWQpCi17Ci0JQUdOWF9UUkFDRTsKLQlyZXR1cm4gcGNpX3JlZ2lzdGVyX2RyaXZlcigmYWdueF9wY2lfZHJpdmVyKTsKLX0KLQotc3RhdGljIHZvaWQgX19leGl0IGFnbnhfcGNpX2V4aXQodm9pZCkKLXsKLQlBR05YX1RSQUNFOwotCXBjaV91bnJlZ2lzdGVyX2RyaXZlcigmYWdueF9wY2lfZHJpdmVyKTsKLX0KLQotCi1tb2R1bGVfaW5pdChhZ254X3BjaV9pbml0KTsKLW1vZHVsZV9leGl0KGFnbnhfcGNpX2V4aXQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2FnbngvcGh5LmMgYi9kcml2ZXJzL3N0YWdpbmcvYWdueC9waHkuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZWMxY2E4Ni4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYWdueC9waHkuYworKysgL2Rldi9udWxsCkBAIC0xLDk2MCArMCwwIEBACi0vKioKLSAqIEFpcmdvIE1JTU8gd2lyZWxlc3MgZHJpdmVyCi0gKgotICogQ29weXJpZ2h0IChjKSAyMDA3IExpIFlhbkJvIDxkcmVhbWZseTI4MUBnbWFpbC5jb20+Ci0KLSAqIFRoYW5rcyBmb3IgSmVmZiBXaWxsaWFtcyA8YW5nZWxiYW5lQGdtYWlsLmNvbT4gZG8gcmV2ZXJzZSBlbmdpbmVlcgotICogd29ya3MgYW5kIHB1Ymxpc2hlZCB0aGUgU1BFQ1MgYXQgaHR0cDovL2FpcmdvLndkd2NvbnN1bHRpbmcubmV0L215bW9pbgotCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgotICovCi0KLSNpbmNsdWRlIDxsaW51eC9pbml0Lmg+Ci0jaW5jbHVkZSA8bGludXgvZXRoZXJkZXZpY2UuaD4KLSNpbmNsdWRlIDxsaW51eC9wY2kuaD4KLSNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgotI2luY2x1ZGUgImFnbnguaCIKLSNpbmNsdWRlICJkZWJ1Zy5oIgotI2luY2x1ZGUgInBoeS5oIgotI2luY2x1ZGUgInRhYmxlLmgiCi0jaW5jbHVkZSAic3RhLmgiCi0jaW5jbHVkZSAieG1pdC5oIgotCi11OCByZWFkX2Zyb21fZWVwcm9tKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHUxNiBhZGRyZXNzKQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXN0cnVjdCBhZ254X2VlcHJvbSBjbWQ7Ci0JdTMyIHJlZzsKLQotCW1lbXNldCgmY21kLCAwLCBzaXplb2YoY21kKSk7Ci0JY21kLmNtZCA9IEVFUFJPTV9DTURfUkVBRCA8PCBBR05YX0VFUFJPTV9DT01NQU5EX1NISUZUOwotCWNtZC5hZGRyZXNzID0gYWRkcmVzczsKLQkvKiBWZXJpZnkgdGhhdCB0aGUgU3RhdHVzIGJpdCBpcyBjbGVhciAqLwotCS8qIFJlYWQgQ29tbWFuZCBhbmQgQWRkcmVzcyBhcmUgd3JpdHRlbiB0byB0aGUgU2VyaWFsIEludGVyZmFjZSAqLwotCWlvd3JpdGUzMigqKF9fbGUzMiAqKSZjbWQsIGN0bCArIEFHTlhfQ0lSX1NFUklBTElURik7Ci0JLyogV2FpdCBmb3IgdGhlIFN0YXR1cyBiaXQgdG8gY2xlYXIgYWdhaW4gKi8KLQllZXByb21fZGVsYXkoKTsKLQkvKiBSZWFkIGZyb20gRGF0YSAqLwotCXJlZyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfQ0lSX1NFUklBTElURik7Ci0KLQljbWQgPSAqKHN0cnVjdCBhZ254X2VlcHJvbSAqKSZyZWc7Ci0KLQlyZXR1cm4gY21kLmRhdGE7Ci19Ci0KLXN0YXRpYyBpbnQgY2FyZF9mdWxsX3Jlc2V0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQlBR05YX1RSQUNFOwotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0NJUl9CTEtDVEwpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX0JMS0NUTCwgMHg4MCk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0NJUl9CTEtDVEwpOwotCXJldHVybiAwOwotfQotCi1pbmxpbmUgdm9pZCBlbmFibGVfcG93ZXJfc2F2aW5nKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9QTV9QTUNUTCk7Ci0JcmVnICY9IH4weDg7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9QTUNUTCwgcmVnKTsKLX0KLQotaW5saW5lIHZvaWQgZGlzYWJsZV9wb3dlcl9zYXZpbmcoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1MzIgcmVnOwotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1BNX1BNQ1RMKTsKLQlyZWcgfD0gMHg4OwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fUE1DVEwsIHJlZyk7Ci19Ci0KLQotdm9pZCBkaXNhYmxlX3JlY2VpdmVyKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JQUdOWF9UUkFDRTsKLQotCS8qIEZJWE1FIERpc2FibGUgdGhlIHJlY2VpdmVyICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRElTQ09WTU9ELCAweDApOwotCS8qIFNldCBnYWluIGNvbnRyb2wgcmVzZXQgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SU1RHQ1RMLCAweDEpOwotCS8qIFJlc2V0IGdhaW4gY29udHJvbCByZXNldCAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1JTVEdDVEwsIDB4MCk7Ci19Ci0KLQotLyogRml4bWUgdGhpcyBzaG91bGUgYmUgZGlzYWJsZSBSWCwgYWJvdmUgaXMgZW5hYmxlIFJYICovCi12b2lkIGVuYWJsZV9yZWNlaXZlcihzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCUFHTlhfVFJBQ0U7Ci0KLQkvKiBTZXQgYWRhcHRpdmUgZ2FpbiBjb250cm9sIGRpc2NvdmVyeSBtb2RlICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRElTQ09WTU9ELCAweDMpOwotCS8qIFNldCBnYWluIGNvbnRyb2wgcmVzZXQgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SU1RHQ1RMLCAweDEpOwotCS8qIENsZWFyIGdhaW4gY29udHJvbCByZXNldCAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1JTVEdDVEwsIDB4MCk7Ci19Ci0KLXN0YXRpYyB2b2lkIG1hY19hZGRyZXNzX3NldChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXU4ICptYWNfYWRkciA9IHByaXYtPm1hY19hZGRyOwotCXUzMiByZWc7Ci0KLQkvKiBGSVhNRSAqLwotCXJlZyA9IChtYWNfYWRkclswXSA8PCAyNCkgfCAobWFjX2FkZHJbMV0gPDwgMTYpIHwgbWFjX2FkZHJbMl0gPDwgOCB8IG1hY19hZGRyWzNdOwotCWlvd3JpdGUzMihyZWcsIGN0bCArIEFHTlhfUlhNX01BQ0hJKTsKLQlyZWcgPSAobWFjX2FkZHJbNF0gPDwgOCkgfCBtYWNfYWRkcls1XTsKLQlpb3dyaXRlMzIocmVnLCBjdGwgKyBBR05YX1JYTV9NQUNMTyk7Ci19Ci0KLXN0YXRpYyB2b2lkIHJlY2VpdmVyX2Jzc2lkX3NldChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBjb25zdCB1OCAqYnNzaWQpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQotCWRpc2FibGVfcmVjZWl2ZXIocHJpdik7Ci0JLyogRklYTUUgKi8KLQlyZWcgPSBic3NpZFswXSA8PCAyNCB8IChic3NpZFsxXSA8PCAxNikgfCAoYnNzaWRbMl0gPDwgOCkgfCBic3NpZFszXTsKLQlpb3dyaXRlMzIocmVnLCBjdGwgKyBBR05YX1JYTV9CU1NJREhJKTsKLQlyZWcgPSAoYnNzaWRbNF0gPDwgOCkgfCBic3NpZFs1XTsKLQlpb3dyaXRlMzIocmVnLCBjdGwgKyBBR05YX1JYTV9CU1NJRExPKTsKLQotCS8qIEVuYWJsZSB0aGUgcmVjZWl2ZXIgKi8KLQllbmFibGVfcmVjZWl2ZXIocHJpdik7Ci0KLQkvKiBDbGVhciB0aGUgVFNGICovCi0vKiAJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fVFNGTE8sIDB4MCk7ICovCi0vKiAJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fVFNGSEksIDB4MCk7ICovCi0JLyogQ2xlYXIgdGhlIFRCVFQgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9UQlRUTE8sIDB4MCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fVEJUVEhJLCAweDApOwotCWRpc2FibGVfcmVjZWl2ZXIocHJpdik7Ci19IC8qIHJlY2VpdmVyX2Jzc2lkX3NldCAqLwotCi1zdGF0aWMgdm9pZCBiYW5kX21hbmFnZW1lbnRfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXZvaWQgX19pb21lbSAqZGF0YSA9IHByaXYtPmRhdGE7Ci0JdTMyIHJlZzsKLQlpbnQgaTsKLQlBR05YX1RSQUNFOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9UWFdBRERSLCBBR05YX1BEVV9UWF9XUSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfQUREUldJTiwgMHgwKTsKLQltZW1zZXRfaW8oZGF0YSArIEFHTlhfUERVUE9PTCwgMHgwLCBBR05YX1BEVVBPT0xfU0laRSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9CTUNUTCwgMHgyMDApOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9DSVBEVVdDTlQsIDB4NDApOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQk1fU1BQRFVXQ05ULCAweDIpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQk1fUkZQUERVV0NOVCwgMHgwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX1JIUFBEVVdDTlQsIDB4MjIpOwotCi0JLyogRklYTUUgSW5pdGlhbGl6ZSB0aGUgRnJlZSBQb29sIExpbmtlZCBMaXN0ICovCi0JLyogICAgMS4gV3JpdGUgdGhlIEFkZHJlc3Mgb2YgdGhlIE5leHQgTm9kZSAoKDB4NDE4MDAgKyBub2RlKnNpemUpL3NpemUpCi0JICAgICAgdG8gdGhlIGZpcnN0IHdvcmQgb2YgZWFjaCBub2RlLiAgKi8KLQlmb3IgKGkgPSAwOyBpIDwgUERVX0ZSRUVfQ05UOyBpKyspIHsKLQkJaW93cml0ZTMyKChBR05YX1BEVV9GUkVFICsgKGkrMSkqUERVX1NJWkUpL1BEVV9TSVpFLAotCQkJICBkYXRhICsgQUdOWF9QRFVfRlJFRSArIChQRFVfU0laRSAqIGkpKTsKLQkJLyogVGhlIGxhc3Qgbm9kZSBzaG91bGQgYmUgc2V0IHRvIDB4MCAqLwotCQlpZiAoKGkgKyAxKSA9PSBQRFVfRlJFRV9DTlQpCi0JCQltZW1zZXRfaW8oZGF0YSArIEFHTlhfUERVX0ZSRUUgKyAoUERVX1NJWkUgKiBpKSwKLQkJCQkgIDB4MCwgUERVX1NJWkUpOwotCX0KLQotCS8qIEhlYWQgaXMgRmlyc3QgUG9vbCBhZGRyZXNzICgweDQxODAwKSAvIHNpemUgKDB4ODApICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9GUExIUCwgQUdOWF9QRFVfRlJFRS9QRFVfU0laRSk7Ci0JLyogVGFpbCBpcyBMYXN0IFBvb2wgQWRkcmVzcyAoMHg0N2Y4MCkgLyBzaXplICgweDgwKSAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQk1fRlBMVFAsIDB4NDdmODAvUERVX1NJWkUpOwotCS8qIENvdW50IGlzIE51bWJlciBvZiBOb2RlcyBpbiB0aGUgUG9vbCAoMHhkMCkgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX0ZQQ05ULCBQRFVfRlJFRV9DTlQpOwotCi0JLyogU3RhcnQgYWxsIHdvcmtxdWV1ZSAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQk1fQ0lXUUNUTCwgMHg4MDAwMCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9DUFVMV0NUTCwgMHg4MDAwMCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9DUFVIV0NUTCwgMHg4MDAwMCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9DUFVUWFdDVEwsIDB4ODAwMDApOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQk1fQ1BVUlhXQ1RMLCAweDgwMDAwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX1NQUlhXQ1RMLCAweDgwMDAwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX1NQVFhXQ1RMLCAweDgwMDAwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX1JGUFdDVEwsIDB4ODAwMDApOwotCi0JLyogRW5hYmxlIHRoZSBCYW5kIE1hbmFnZW1lbnQgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfQk1fQk1DVEwpOwotCXJlZyB8PSAweDE7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9CTV9CTUNUTCwgcmVnKTsKLX0gLyogYmFuZF9tYW5hZ21lbnRfaW5pdCAqLwotCi0KLXN0YXRpYyB2b2lkIHN5c3RlbV9pdGZfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXUzMiByZWc7Ci0JQUdOWF9UUkFDRTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfU1lTSVRGX0dQSU9VVCwgMHgwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1BNX1RFU1RQSFksIDB4MTFlMTQzYSk7Ci0KLQlpZiAocHJpdi0+cmV2aWQgPT0gMCkgewotCQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1lTSVRGX1NZU01PREUpOwotCQlyZWcgfD0gMHgxMTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfU1lTTU9ERSwgcmVnKTsKLQl9Ci0JLyogPz8/IFdoYXQgaXMgdGhhdCBtZWFucz8gaXQgc2hvdWxkIGRpZmZlcmVuY2UgZm9yIGRpZmZlcmljZSB0eXBlCi0JIG9mIGNhcmRzICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfU0VSSUFMSVRGLCAweGZmZjgxMDA2KTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfU1lTSVRGX0dQSU9JTiwgMHgxZjAwMDApOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfU1lTSVRGX0dQSU9VVCwgMHg1KTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1lTSVRGX0dQSU9JTik7Ci19Ci0KLXN0YXRpYyB2b2lkIGVuY3J5cHRpb25faW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCUFHTlhfVFJBQ0U7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0VOQ1JZX1dFUEtFWTAsIDB4MCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9FTkNSWV9XRVBLRVkxLCAweDApOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfRU5DUllfV0VQS0VZMiwgMHgwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0VOQ1JZX1dFUEtFWTMsIDB4MCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9FTkNSWV9DQ01SRUNUTCwgMHg4KTsKLX0KLQotc3RhdGljIHZvaWQgdHhfbWFuYWdlbWVudF9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0Jdm9pZCBfX2lvbWVtICpkYXRhID0gcHJpdi0+ZGF0YTsKLQl1MzIgcmVnOwotCUFHTlhfVFJBQ0U7Ci0KLQkvKiBGaWxsIG91dCB0aGUgQ29tcHV0YXRpb25hbEVuZ2luZUxvb2t1cFRhYmxlCi0JICogc3RhcnRpbmcgYXQgbWVtb3J5ICMyIG9mZnNldCAweDgwMAotCSAqLwotCXR4X2VuZ2luZV9sb29rdXBfdGJsX2luaXQocHJpdik7Ci0JbWVtc2V0X2lvKGRhdGEgKyAweDEwMDAsIDAsIDB4ZmUwKTsKLQkvKiBFbmFibGUgVHJhbnNtaXNzaW9uIE1hbmFnZW1lbnQgRnVuY3Rpb25zICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fRVRNRiwgMHgzZmYpOwotCS8qIFdyaXRlIDB4M2YgdG8gVHJhbnNtaXNzaW9uIFRlbXBsYXRlICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fVFhURU1QLCAweDNmKTsKLQotCWlmIChwcml2LT5yZXZpZCA+PSAyKQotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9TSUZTUElGUywgMHgxZTE0MGEwYik7Ci0JZWxzZQotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9TSUZTUElGUywgMHgxZTE5MGEwYik7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfVFhNX1RJRlNFSUZTKTsKLQlyZWcgJj0gMHhmZjAwOwotCXJlZyB8PSAweGI7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fVElGU0VJRlMsIHJlZyk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1RYTV9USUZTRUlGUyk7Ci0JcmVnICY9IDB4ZmZmZjAwZmY7Ci0JcmVnIHw9IDB4YTAwOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX1RJRlNFSUZTLCByZWcpOwotCS8qIEVuYWJsZSBUSUZTICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1RMLCAweDQwMDAwKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fVElGU0VJRlMpOwotCXJlZyAmPSAweGZmMDBmZmZmOwotCXJlZyB8PSAweDUxMDAwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9USUZTRUlGUywgcmVnKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfVFhNX1BST0JERUxBWSk7Ci0JcmVnICY9IDB4ZmYwMGZmZmY7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fUFJPQkRFTEFZLCByZWcpOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fVElGU0VJRlMpOwotCXJlZyAmPSAweDAwZmZmZmZmOwotCXJlZyB8PSAweDFjMDAwMDAwOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX1RJRlNFSUZTLCByZWcpOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fUFJPQkRFTEFZKTsKLQlyZWcgJj0gMHgwMGZmZmZmZjsKLQlyZWcgfD0gMHgwMTAwMDAwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9QUk9CREVMQVksIHJlZyk7Ci0KLQkvKiAjIFNldCBESUYgMC0xLDItMyw0LTUsNi03IHRvIGRlZmF1bHRzICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fRElGMDEsIDB4MzIxZDMyMWQpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX0RJRjIzLCAweDMyMWQzMjFkKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9ESUY0NSwgMHgzMjFkMzIxZCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fRElGNjcsIDB4MzIxZDMyMWQpOwotCi0JLyogTWF4IEFjayB0aW1lb3V0IGxpbWl0ICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fTUFYQUNLVElNLCAweDFlMTkpOwotCS8qIE1heCBSWCBEYXRhIFRpbWVvdXQgY291bnQsICovCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1RYTV9NQVhSWFRJTUUpOwotCXJlZyAmPSAweGZmZmYwMDAwOwotCXJlZyB8PSAweGZmOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX01BWFJYVElNRSwgcmVnKTsKLQotCS8qIENGIHBvbGwgUlggVGltZW91dCBjb3VudCAqLwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fQ0ZQT0xMUlhUSU0pOwotCXJlZyAmPSAweGZmZmY7Ci0JcmVnIHw9IDB4ZmYwMDAwOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX0NGUE9MTFJYVElNLCByZWcpOwotCi0JLyogTWF4IFRpbWVvdXQgRXhjZWVkZWQgY291bnQsICovCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1RYTV9NQVhUSU1PVVQpOwotCXJlZyAmPSAweGZmMDBmZmZmOwotCXJlZyB8PSAweDE5MDAwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9NQVhUSU1PVVQsIHJlZyk7Ci0KLQkvKiBDRiBhY2sgdGltZW91dCBsaW1pdCBmb3IgMTFiICovCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1RYTV9DRkFDS1QxMUIpOwotCXJlZyAmPSAweGZmMDA7Ci0JcmVnIHw9IDB4MWU7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ0ZBQ0tUMTFCLCByZWcpOwotCi0JLyogTWF4IENGIFBvbGwgVGltZW91dCBDb3VudCAqLwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fQ0ZQT0xMUlhUSU0pOwotCXJlZyAmPSAweGZmZmYwMDAwOwotCXJlZyB8PSAweDE5OwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX0NGUE9MTFJYVElNLCByZWcpOwotCS8qIENGIFBvbGwgUlggVGltZW91dCBDb3VudCAqLwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fQ0ZQT0xMUlhUSU0pOwotCXJlZyAmPSAweGZmZmYwMDAwOwotCXJlZyB8PSAweDFlOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX0NGUE9MTFJYVElNLCByZWcpOwotCi0JLyogIyB3cml0ZSBkZWZhdWx0IHRvICovCi0JLyogICAgMS4gU2NoZWR1bGUgRW1wdHkgQ291bnQgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9TQ0hFTVBDTlQsIDB4NSk7Ci0JLyogICAgMi4gQ0ZQIFBlcmlvZCBDb3VudCAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX0NGUEVSQ05ULCAweDEpOwotCS8qICAgIDMuIENGUCBNRFYgICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ0ZQTURWLCAweDEwMDAwKTsKLQotCS8qIFByb2JlIERlbGF5ICovCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1RYTV9QUk9CREVMQVkpOwotCXJlZyAmPSAweGZmZmYwMDAwOwotCXJlZyB8PSAweDQwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9QUk9CREVMQVksIHJlZyk7Ci0KLQkvKiBNYXggQ0NBIGNvdW50IFNsb3QgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfVFhNX01BWENDQUNOVFNMT1QpOwotCXJlZyAmPSAweGZmZmYwMGZmOwotCXJlZyB8PSAweDkwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9NQVhDQ0FDTlRTTE9ULCByZWcpOwotCi0JLyogU2xvdCBsaW1pdC8xIG1zZWMgTGltaXQgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfVFhNX1NMT1RMSU1JVCk7Ci0JcmVnICY9IDB4ZmYwMGZmZmY7Ci0JcmVnIHw9IDB4MTQwMDc3OwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX1NMT1RMSU1JVCwgcmVnKTsKLQotCS8qICMgU2V0IENXICMoMC03KSB0byBkZWZhdWx0ICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1cwLCAweGZmMDAwNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1cxLCAweGZmMDAwNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1cyLCAweGZmMDAwNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1czLCAweGZmMDAwNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1c0LCAweGZmMDAwNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1c1LCAweGZmMDAwNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1c2LCAweGZmMDAwNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1c3LCAweGZmMDAwNyk7Ci0KLQkvKiAjIFNldCBTaG9ydC9Mb25nIGxpbWl0ICMoMC03KSB0byBkZWZhdWx0ICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU0wLCAgMHhhMDAwYSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU0xLCAgMHhhMDAwYSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU0yLCAgMHhhMDAwYSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU0zLCAgMHhhMDAwYSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU00LCAgMHhhMDAwYSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU01LCAgMHhhMDAwYSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU02LCAgMHhhMDAwYSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fU0xCRUFMSU03LCAgMHhhMDAwYSk7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfVFhNX0NUTCk7Ci0JcmVnIHw9IDB4MTQwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9DVEwsIHJlZyk7Ci0JLyogV2FpdCBmb3IgYml0IDAgaW4gQ29udHJvbCBSZWcgdG8gY2xlYXIgICovCi0JdWRlbGF5KDgwKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfVFhNX0NUTCk7Ci0JLyogT3IgMHgxODAwMCB0byBDb250cm9sIHJlZyAqLwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fQ1RMKTsKLQlyZWcgfD0gMHgxODAwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9DVEwsIHJlZyk7Ci0JLyogV2FpdCBmb3IgYml0IDAgaW4gQ29udHJvbCBSZWcgdG8gY2xlYXIgKi8KLQl1ZGVsYXkoODApOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fQ1RMKTsKLQotCS8qIFNldCBMaXN0ZW4gSW50ZXJ2YWwgQ291bnQgdG8gZGVmYXVsdCAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX0xJU0lOVEVSQ05ULCAweDEpOwotCS8qIFNldCBEVElNIHBlcmlvZCBjb3VudCB0byBkZWZhdWx0ICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fRFRJTVBFUklDTlQsIDB4MjAwMCk7Ci19IC8qIHR4X21hbmFnZW1lbnRfaW5pdCAqLwotCi1zdGF0aWMgdm9pZCByeF9tYW5hZ2VtZW50X2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQlBR05YX1RSQUNFOwotCi0JLyogSW5pdGlhbGl6ZSB0aGUgUm91dGluZyBUYWJsZSAqLwotCXJvdXRpbmdfdGFibGVfaW5pdChwcml2KTsKLQotCWlmIChwcml2LT5yZXZpZCA+PSAzKSB7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MjA3NCwgMHgxZjE3MTcxMCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MjA3OCwgMHgxMDEwMGQwZCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MjA3YywgMHgxMTExMTAxMCk7Ci0JfSBlbHNlIHsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9SWE1fREVMQVkxMSwgMHgwKTsKLQl9Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9SWE1fUkVRUkFURSwgMHg4MTk1ZTAwKTsKLX0KLQotCi1zdGF0aWMgdm9pZCBhZ254X3RpbWVyX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQlBR05YX1RSQUNFOwotCi0vKiAJL1wqIFdyaXRlIDB4MjQ5ZjAwICh0aWNrIGR1cmF0aW9uPykgdG8gVGltZXIgMSAqXC8gKi8KLS8qIAlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RJTUNUTF9USU1FUjEsIDB4MjQ5ZjAwKTsgKi8KLS8qIAkvXCogV3JpdGUgMHhlMiB0byBUaW1lciAxIENvbnRyb2wgKlwvICovCi0vKiAJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9USU1DVExfVElNMUNUTCwgMHhlMik7ICovCi0KLQkvKiBXcml0ZSAweDI0OWYwMCAodGljayBkdXJhdGlvbj8pIHRvIFRpbWVyIDEgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RJTUNUTF9USU1FUjEsIDB4MCk7Ci0JLyogV3JpdGUgMHhlMiB0byBUaW1lciAxIENvbnRyb2wgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RJTUNUTF9USU0xQ1RMLCAweDApOwotCi0JaW93cml0ZTMyKDB4RkZGRkZGRkYsIHByaXYtPmN0bCArIEFHTlhfVFhNX0JFQUNPTl9DVEwpOwotfQotCi1zdGF0aWMgdm9pZCBwb3dlcl9tYW5hZ2VfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXUzMiByZWc7Ci0JQUdOWF9UUkFDRTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fTUFDTVNXLCAweDFmKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1BNX1JGQ1RMLCAweDFmKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9QTV9QTUNUTCk7Ci0JcmVnICY9IDB4ZjAwZjsKLQlyZWcgfD0gMHhhMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1BNX1BNQ1RMLCByZWcpOwotCi0JaWYgKHByaXYtPnJldmlkID49IDMpIHsKLQkJcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1BNX1NPRlRSU1QpOwotCQlyZWcgfD0gMHgxODsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9TT0ZUUlNULCByZWcpOwotCX0KLX0gLyogcG93ZXJfbWFuYWdlX2luaXQgKi8KLQotCi1zdGF0aWMgdm9pZCBnYWluX2N0bGNudF9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQlBR05YX1RSQUNFOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVFJBQ05UNSwgMHgxMTkpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RSQUNOVDYsIDB4MTE4KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9UUkFDTlQ3LCAweDExNyk7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfUE1fUE1DVEwpOwotCXJlZyB8PSAweDg7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9QTUNUTCwgcmVnKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9QTV9QTUNUTCk7Ci0JcmVnICY9IH4weDg7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9QTUNUTCwgcmVnKTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX0FERFJXSU4sIDB4MCk7Ci0KLQkvKiBGSVhNRSBXcml0ZSB0aGUgaW5pdGlhbCBTdGF0aW9uIERlc2NyaXB0b3IgZm9yIHRoZSBjYXJkICovCi0Jc3RhX2luaXQocHJpdiwgTE9DQUxfU1RBSUQpOwotCXN0YV9pbml0KHByaXYsIEJTU0lEX1NUQUlEKTsKLQotCS8qIEVuYWJsZSBzdGFpb24gMCBhbmQgMSBjYW4gZG8gVFggKi8KLQkvKiBJdCBzZWVtZWQgaWYgd2Ugc2V0IG90aGVyIGJpdCB0byAxIHRoZSBiaXQgMCB3aWxsCi0JICAgYmUgYXV0byBjaGFuZ2UgdG8gMCAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQk1fVFhUT1BFRVIsIDB4MiB8IDB4MSk7Ci0vKglhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX1RYVE9QRUVSLCAweDEpOyAqLwotfSAvKiBnYWluX2N0bGNudF9pbml0ICovCi0KLQotc3RhdGljIHZvaWQgcGh5X2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl2b2lkIF9faW9tZW0gKmRhdGEgPSBwcml2LT5kYXRhOwotCXUzMiByZWc7Ci0JQUdOWF9UUkFDRTsKLQotCS8qIExvYWQgSW5pdGlhbEdhaW5UYWJsZSAqLwotCWdhaW5fdGFibGVfaW5pdChwcml2KTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX0FERFJXSU4sIDB4MjAwMDAwMCk7Ci0KLQkvKiBDbGVhciB0aGUgZm9sbG93aW5nIG9mZnNldHMgaW4gTWVtb3J5IFJhbmdlICMyOiAqLwotCW1lbXNldF9pbyhkYXRhICsgMHg1MDQwLCAwLCAweGEgKiA0KTsKLQltZW1zZXRfaW8oZGF0YSArIDB4NTA4MCwgMCwgMHhhICogNCk7Ci0JbWVtc2V0X2lvKGRhdGEgKyAweDUwYzAsIDAsIDB4YSAqIDQpOwotCW1lbXNldF9pbyhkYXRhICsgMHg1NDAwLCAwLCAweDgwICogNCk7Ci0JbWVtc2V0X2lvKGRhdGEgKyAweDYwMDAsIDAsIDB4MjgwICogNCk7Ci0JbWVtc2V0X2lvKGRhdGEgKyAweDcwMDAsIDAsIDB4MjgwICogNCk7Ci0JbWVtc2V0X2lvKGRhdGEgKyAweDgwMDAsIDAsIDB4MjgwICogNCk7Ci0KLQkvKiBJbml0aWFsaXplIHRoZSBGb2xsb3dpbmcgUmVnaXN0ZXJzIEFjY29yZGluZyB0byBQQ0kgUmV2aXNpb24gSUQgKi8KLQlpZiAocHJpdi0+cmV2aWQgPT0gMCkgewotCQkvKiBmaXhtZSB0aGUgcGFydCBoYXNuJ3QgYmVlbiB1cGRhdGUgYnV0IGJlbG93IGhhcyBiZWVuIHVwZGF0ZQotCQkgICBiYXNlZCBvbiBXR001MTEgKi8KLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfTEVOLCAweGYpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9USU1FUjEsIDB4MWQpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9USU1FUjIsIDB4Myk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQUNJX0FJQ0NIQTBPVkUsIDB4MTEpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9BSUNDSEExT1ZFLCAweDApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USEQwQSwgMHg2NCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBBTCwgMHg0Yik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBCLCAweDRiKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRFVOU0FULCAweDE0KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRFNBVCwgMHgyNCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RGSVJDQUwsIDB4OCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RHQ1RMMTFBLCAweDFhKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfREdDVEwxMUIsIDB4Myk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0dBSU5JTklULCAweGQpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USE5PU0lHLCAweDEpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9DT0FSU1RFUCwgMHg3KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfU0lGU1QxMUEsIDB4MjgpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9TSUZTVDExQiwgMHgyOCk7Ci0JCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9HQ1JfQ1dERVRFQyk7Ci0JCXJlZyB8PSAweDE7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0NXREVURUMsIHJlZyk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSXzBYMzgsIDB4MWUpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9CT0FDVCwgMHgyNik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RJU0NPVk1PRCwgMHgzKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkxJU1RBTlQsIDB4Myk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX05BQ1RJQU5ULCAweDMpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9OTUVBU0FOVCwgMHgzKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkNBUFRBTlQsIDB4Myk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIQ0FQMTFBLCAweDApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USENBUDExQiwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhDQVBSWDExQSwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhDQVBSWDExQiwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhMRVZEUk8sIDB4MTApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9NQVhSWFRJTUUxMUEsIDB4MSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX01BWFJYVElNRTExQiwgMHgxKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQ09SUlRJTUUsIDB4MTkwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfU0lHSFRILCAweDc4KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfU0lHTFRILCAweDFjKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQ09SUkRST1AsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIQ0QsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX01BWFBPV0RJRkYsIDB4MSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RFU1RCVVMsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0FOVENGRywgMHgxZik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RISlVNUCwgMHgxNCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIUE9XRVIsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIUE9XQ0xJUCwgMHgzMCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBCVEZFU1QsIDB4MzIpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USFJYMTFCUE9XTUlOLCAweDE5KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfMFgxNGMsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSXzBYMTUwLCAweDApOwotCQlhZ254X3dyaXRlMzIoY3RsLCAweDk0MDAsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OTQwYywgMHg2ZmYpOwotCQlhZ254X3dyaXRlMzIoY3RsLCAweDk0MjgsIDB4YTApOwotCQlhZ254X3dyaXRlMzIoY3RsLCAweDk0MzQsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OWMwNCwgMHgxNSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OWMwYywgMHg3Zik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OWMzNCwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgMHhjMDAwLCAweDM4ZCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MTQwMTgsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MTYwMDAsIDB4MSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MTEwMDQsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4ZWM1NCwgMHhhKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgMHhlYzFjLCAweDUpOwotCX0gZWxzZSBpZiAocHJpdi0+cmV2aWQgPiAwKSB7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQUNJX0xFTiwgMHhmKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfVElNRVIxLCAweDIxKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfVElNRVIyLCAweDI3KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfQUlDQ0hBME9WRSwgMHgxMSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQUNJX0FJQ0NIQTFPVkUsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RVTlNBVCwgMHgxNCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RTQVQsIDB4MjQpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9ERklSQ0FMLCAweDgpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9ER0NUTDExQSwgMHgxYSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RHQ1RMMTFCLCAweDMpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9HQUlOSU5JVCwgMHhkKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhOT1NJRywgMHgxKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQ09BUlNURVAsIDB4Nyk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1NJRlNUMTFBLCAweDI4KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfU0lGU1QxMUIsIDB4MjgpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9DV0RFVEVDLCAweDApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl8wWDM4LCAweDFlKTsKLS8qCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9CT0FDVCwgMHgyNik7Ki8KLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRElTQ09WTU9ELCAweDMpOwotCi0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIQ0FQMTFBLCAweDMyKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhDQVAxMUIsIDB4MzIpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USENBUFJYMTFBLCAweDMyKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhDQVBSWDExQiwgMHgzMik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RITEVWRFJPLCAweDEwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTUFYUlhUSU1FMTFBLCAweDFhZCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX01BWFJYVElNRTExQiwgMHhhMTApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9DT1JSVElNRSwgMHgxOTApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9DT1JSRFJPUCwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhDRCwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhDUywgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTUFYUE9XRElGRiwgMHg0KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEVTVEJVUywgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhKVU1QLCAweDFlKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhQT1dFUiwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhQT1dDTElQLCAweDJhKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhEMEJURkVTVCwgMHgzYyk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIUlgxMUJQT1dNSU4sIDB4MTkpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl8wWDE0YywgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfMFgxNTAsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1JYT1ZFUklERSwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfV0FUQ0hET0csIDB4MzcpOwotCQlhZ254X3dyaXRlMzIoY3RsLCAweDk0MDAsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OTQwYywgMHg2ZmYpOwotCQlhZ254X3dyaXRlMzIoY3RsLCAweDk0MjgsIDB4YTApOwotCQlhZ254X3dyaXRlMzIoY3RsLCAweDk0MzQsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OWMwNCwgMHgxNSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OWMwYywgMHg3Zik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4OWMzNCwgMHgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgMHhjMDAwLCAweDM4ZCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MTQwMTQsIDB4MTAwMCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MTQwMTgsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MTYwMDAsIDB4MSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4MTEwMDQsIDB4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4ZWM1NCwgMHhhKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgMHhlYzFjLCAweDUwKTsKLQl9IGVsc2UgaWYgKHByaXYtPnJldmlkID4gMSkgewotCQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIDB4ZWMxOCk7Ci0JCXJlZyB8PSAweDg7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4ZWMxOCwgcmVnKTsKLQl9Ci0KLQkvKiBXcml0ZSB0aGUgVFggRmlyIENvZWZmaWNpZW50IFRhYmxlICovCi0JdHhfZmlyX3RhYmxlX2luaXQocHJpdik7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfUE1fUE1DVEwpOwotCXJlZyAmPSB+MHg4OwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fUE1DVEwsIHJlZyk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1BNX1BMTENUTCk7Ci0JcmVnIHw9IDB4MTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1BNX1BMTENUTCwgcmVnKTsKLQotLyogCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgMHgxYTAzMCk7ICovCi0vKiAJcmVnICY9IH4weDQ7ICovCi0vKiAJYWdueF93cml0ZTMyKGN0bCwgMHgxYTAzMCwgcmVnKTsgKi8KLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RSQUNOVDQsIDB4MTEzKTsKLX0gLyogcGh5X2luaXQgKi8KLQotc3RhdGljIHZvaWQgY2hpcF9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQlBR05YX1RSQUNFOwotCi0JYmFuZF9tYW5hZ2VtZW50X2luaXQocHJpdik7Ci0KLQlyZl9jaGlwc19pbml0KHByaXYpOwotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1BNX1BNQ1RMKTsKLQlyZWcgfD0gMHg4OwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fUE1DVEwsIHJlZyk7Ci0KLQkvKiBJbml0aWFsaXplIHRoZSBQSFkgKi8KLQlwaHlfaW5pdChwcml2KTsKLQotCWVuY3J5cHRpb25faW5pdChwcml2KTsKLQotCXR4X21hbmFnZW1lbnRfaW5pdChwcml2KTsKLQotCXJ4X21hbmFnZW1lbnRfaW5pdChwcml2KTsKLQotCXBvd2VyX21hbmFnZV9pbml0KHByaXYpOwotCi0JLyogSW5pdGlhbGl6ZSB0aGUgVGltZXJzICovCi0JYWdueF90aW1lcl9pbml0KHByaXYpOwotCi0JLyogV3JpdGUgMHhjMzkwYmY5IHRvIEludGVycnVwdCBNYXNrIChEaXNhYmxlIFRYKSAqLwotCXJlZyA9IDB4YzM5MGJmOSAmIH5JUlFfVFhfQkVBQ09OOwotCXJlZyAmPSB+SVJRX1RYX0RJU0FCTEU7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9JTlRfTUFTSywgcmVnKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9DSVJfQkxLQ1RMKTsKLQlyZWcgfD0gMHg4MDA7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfQkxLQ1RMLCByZWcpOwotCi0JLyogc2V0IGl0IHdoZW4gbmVlZCBnZXQgbXVsdGljYXN0IGVuYWJsZT8gKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX01UU00sIDB4ZmYpOwotfSAvKiBjaGlwX2luaXQgKi8KLQotCi1zdGF0aWMgaW5saW5lIHZvaWQgc2V0X3Byb21pc19hbmRfbWFuYWdlZChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfU1lTSVRGX1NZU01PREUsIDB4MTAgfCAweDIpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfU1lTSVRGX1NZU01PREUsIDB4MTAgfCAweDIpOwotfQotc3RhdGljIGlubGluZSB2b2lkIHNldF9sZWFybl9tb2RlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfU1lTTU9ERSwgMHg4KTsKLX0KLXN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfc2Nhbl9tb2RlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfU1lTTU9ERSwgMHgyMCk7Ci19Ci1zdGF0aWMgaW5saW5lIHZvaWQgc2V0X3Byb21pc2N1b3VzX21vZGUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQkvKiBhZ254X3dyaXRlMzIoY3RsLCBBR05YX1NZU0lURl9TWVNNT0RFLCAweDIxMCk7Ki8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1NZU0lURl9TWVNNT0RFLCAweDEwKTsKLX0KLXN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfbWFuYWdlZF9tb2RlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfU1lTTU9ERSwgMHgyKTsKLX0KLXN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfYWRob2NfbW9kZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfU1lTSVRGX1NZU01PREUsIDB4MCk7Ci19Ci0KLSNpZiAwCi1zdGF0aWMgdm9pZCB1bmtub3dfcmVnaXN0ZXJfd3JpdGUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVU5LTk9XTl9CQVNFICsgMHgwLCAweDNlKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4NCwgMHhiMik7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDgsIDB4MTQwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4YywgMHgxQzApOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVU5LTk9XTl9CQVNFICsgMHgxMCwgMHgxRkYpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVU5LTk9XTl9CQVNFICsgMHgxNCwgMHgxREQpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVU5LTk9XTl9CQVNFICsgMHgxOCwgMHgxNUYpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVU5LTk9XTl9CQVNFICsgMHgxYywgMHhBMSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDIwLCAweDNFNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDI0LCAweDM2Qik7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDI4LCAweDM0OCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDJjLCAweDM3RCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDMwLCAweDNERSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDM0LCAweDM2KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4MzgsIDB4NjQpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVU5LTk9XTl9CQVNFICsgMHgzYywgMHg1Nyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDQwLCAweDIzKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4NDQsIDB4M0VEKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4NDgsIDB4M0M5KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4NGMsIDB4M0NBKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4NTAsIDB4M0U3KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4NTQsIDB4OCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9VTktOT1dOX0JBU0UgKyAweDU4LCAweDFGKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1VOS05PV05fQkFTRSArIDB4NWMsIDB4MWEpOwotfQotI2VuZGlmCi0KLXN0YXRpYyB2b2lkIGNhcmRfaW50ZXJmYWNlX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1OCBic3NpZFtFVEhfQUxFTl0gPSB7MHhmZiwgMHhmZiwgMHhmZiwgMHhmZiwgMHhmZiwgMHhmZn07Ci0JdTMyIHJlZzsKLQl1bnNpZ25lZCBpbnQgaTsKLQlBR05YX1RSQUNFOwotCi0JbWlnaHRfc2xlZXAoKTsKLQkvKiBDbGVhciBSWCBDb250cm9sIGFuZCBFbmFibGUgUlggcXVldWVzICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfUlhDVEwsIDB4OCk7Ci0KLQltaWdodF9zbGVlcCgpOwotCS8qIERvIGEgZnVsbCByZXNldCBvZiB0aGUgY2FyZCAqLwotCWNhcmRfZnVsbF9yZXNldChwcml2KTsKLQltaWdodF9zbGVlcCgpOwotCi0JLyogQ2hlY2sgYW5kIHNldCBDYXJkIEVuZGlhbm5lc3MgKi8KLQlyZWcgPSBpb3JlYWQzMihwcml2LT5jdGwgKyBBR05YX0NJUl9FTkRJQU4pOwotCS8qIFRPRE8gSWYgbm90IDB4QjNCMkIxQjAgc2V0IHRvIDB4QjNCMkIxQjAgKi8KLQlwcmludGsoS0VSTl9JTkZPIFBGWCAiQ0lSX0VORElBTiBpcyAleFxuIiwgcmVnKTsKLQotCi0JLyogQ29uZmlnIHRoZSBlZXByb20gKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9TRVJJQUxJVEYsIDB4NzAwMDA4Nik7Ci0JdWRlbGF5KDEwKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfQ0lSX1NFUklBTElURik7Ci0KLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fU09GVFJTVCwgMHg4MDAwMDAzMyk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCAweGVjNTApOwotCXJlZyB8PSAweGY7Ci0JYWdueF93cml0ZTMyKGN0bCwgMHhlYzUwLCByZWcpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fU09GVFJTVCwgMHgwKTsKLQotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1NZU0lURl9HUElPSU4pOwotCXVkZWxheSgxMCk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0NJUl9TRVJJQUxJVEYpOwotCi0JLyogRHVtcCB0aGUgZWVwcm9tICovCi0JZG8gewotCQljaGFyIGVlcHJvbVsweDEwMDAwMC8weDEwMF07Ci0KLQkJZm9yIChpID0gMDsgaSA8IDB4MTAwMDAwOyBpICs9IDB4MTAwKSB7Ci0JCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9TRVJJQUxJVEYsIDB4MzAwMDAwMCArIGkpOwotCQkJdWRlbGF5KDEzKTsKLQkJCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9DSVJfU0VSSUFMSVRGKTsKLQkJCXVkZWxheSg3MCk7Ci0JCQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfQ0lSX1NFUklBTElURik7Ci0JCQllZXByb21baS8weDEwMF0gPSByZWcgJiAweEZGOwotCQkJdWRlbGF5KDEwKTsKLQkJfQotCQlwcmludF9oZXhfZHVtcF9ieXRlcyhQRlggIkVFUFJPTTogIiwgRFVNUF9QUkVGSVhfTk9ORSwgZWVwcm9tLAotCQkJCSAgICAgQVJSQVlfU0laRShlZXByb20pKTsKLQl9IHdoaWxlICgwKTsKLQotCXNwaV9yY193cml0ZShjdGwsIFJGX0NISVAwLCAweDI2KTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX1JMU1cpOwotCi0JLyogSW5pdGlhbGl6ZSB0aGUgc3lzdGVtIGludGVyZmFjZSAqLwotCXN5c3RlbV9pdGZfaW5pdChwcml2KTsKLQotCW1pZ2h0X3NsZWVwKCk7Ci0JLyogQ2hpcCBJbml0aWFsaXphdGlvbiAoUG9sYXJpcykgKi8KLQljaGlwX2luaXQocHJpdik7Ci0JbWlnaHRfc2xlZXAoKTsKLQotCS8qIENhbGlicmF0ZSB0aGUgYW50ZW5uYWUgKi8KLQlhbnRlbm5hX2NhbGlicmF0ZShwcml2KTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgMHhlYzUwKTsKLQlyZWcgJj0gfjB4NDA7Ci0JYWdueF93cml0ZTMyKGN0bCwgMHhlYzUwLCByZWcpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fU09GVFJTVCwgMHgwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1BNX1BMTENUTCwgMHgxKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9CTV9CTUNUTCk7Ci0JcmVnIHw9IDB4ODAwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0JNX0JNQ1RMLCByZWcpOwotCWVuYWJsZV9yZWNlaXZlcihwcml2KTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1lTSVRGX1NZU01PREUpOwotCXJlZyB8PSAweDIwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1NZU0lURl9TWVNNT0RFLCByZWcpOwotCWVuYWJsZV9yZWNlaXZlcihwcml2KTsKLQotCW1pZ2h0X3NsZWVwKCk7Ci0JLyogSW5pdGlhbGl6ZSBHYWluIENvbnRyb2wgQ291bnRzICovCi0JZ2Fpbl9jdGxjbnRfaW5pdChwcml2KTsKLQotCS8qIFdyaXRlIEluaXRpYWwgU3RhdGlvbiBQb3dlciBUZW1wbGF0ZSBmb3IgdGhpcyBzdGF0aW9uKCMwKSAqLwotCXN0YV9wb3dlcl9pbml0KHByaXYsIExPQ0FMX1NUQUlEKTsKLQotCW1pZ2h0X3NsZWVwKCk7Ci0JLyogSW5pdGlhbGl6ZSB0aGUgcngsdGQsdG0gcmluZ3MsIGZvciBlYWNoIG5vZGUgaW4gdGhlIHJpbmcgKi8KLQlmaWxsX3JpbmdzKHByaXYpOwotCi0JbWlnaHRfc2xlZXAoKTsKLQotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9TT0ZUUlNULCAweDgwMDAwMDMzKTsKLQlhZ254X3dyaXRlMzIoY3RsLCAweGVjNTAsIDB4Yyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9TT0ZUUlNULCAweDApOwotCi0JLyogRklYTUUgSW5pdGlhbGl6ZSB0aGUgdHJhbnNtaXQgY29udHJvbCByZWdpc3RlciAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfVFhNX0NUTCwgMHgxOTRjMSk7Ci0KLQllbmFibGVfcmVjZWl2ZXIocHJpdik7Ci0KLQltaWdodF9zbGVlcCgpOwotCS8qIEZJWE1FIFNldCB0aGUgUmVjZWl2ZSBDb250cm9sIE1hYyBBZGRyZXNzIHRvIGNhcmQgYWRkcmVzcyAqLwotCW1hY19hZGRyZXNzX3NldChwcml2KTsKLQllbmFibGVfcmVjZWl2ZXIocHJpdik7Ci0JbWlnaHRfc2xlZXAoKTsKLQotCS8qIFNldCB0aGUgcmVjaWV2ZSByZXF1ZXN0IHJhdGUgKi8KLQkvKiBGSVhNRSBFbmFibGUgdGhlIHJlcXVlc3QgKi8KLQkvKiBDaGVjayBwYWNrZXQgbGVuZ3RoICovCi0JLyogU2V0IG1heGltdW0gcGFja2V0IGxlbmd0aCAqLwotLyoJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9SWE1fUkVRUkFURSwgMHg4ODE5NWUwMCk7ICovCi0vKgllbmFibGVfcmVjZWl2ZXIocHJpdik7ICovCi0KLQkvKiBTZXQgdGhlIFJlY2VpdmVyIEJTU0lEICovCi0JcmVjZWl2ZXJfYnNzaWRfc2V0KHByaXYsIGJzc2lkKTsKLQotCS8qIEZJWE1FIFNldCB0byBtYW5hZ2VkIG1vZGUgKi8KLQlzZXRfbWFuYWdlZF9tb2RlKHByaXYpOwotLyoJc2V0X3Byb21pc2N1b3VzX21vZGUocHJpdik7ICovCi0vKglzZXRfc2Nhbl9tb2RlKHByaXYpOyAqLwotLyoJc2V0X2xlYXJuX21vZGUocHJpdik7ICovCi0vKglzZXRfcHJvbWlzX2FuZF9tYW5hZ2VkKHByaXYpOyAqLwotLyoJc2V0X2FkaG9jX21vZGUocHJpdik7ICovCi0KLQkvKiBTZXQgdGhlIHJlY2lldmUgcmVxdWVzdCByYXRlICovCi0JLyogQ2hlY2sgcGFja2V0IGxlbmd0aCAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUlhNX1JFUVJBVEUsIDB4MDgwMDAwMDApOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9SWE1fUkVRUkFURSk7Ci0JLyogU2V0IG1heGltdW0gcGFja2V0IGxlbmd0aCAqLwotCXJlZyB8PSAweDAwMTk1ZTAwOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUlhNX1JFUVJBVEUsIHJlZyk7Ci0KLQkvKiBDb25maWd1cmUgdGhlIFJYIGFuZCBUWCBpbnRlcnJ1cHQgKi8KLQlyZWcgPSBFTkFCTEVfUlhfSU5URVJSVVBUIHwgUlhfQ0FDSEVfTElORSB8IEZSQUdfTEVOXzIwNDggfCBGUkFHX0JFOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX1JYQ0ZHLCByZWcpOwotCS8qIEZJWE1FICovCi0JcmVnID0gRU5BQkxFX1RYX0lOVEVSUlVQVCB8IFRYX0NBQ0hFX0xJTkUgfCBGUkFHX0xFTl8yMDQ4IHwgRlJBR19CRTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9UWENGRywgcmVnKTsKLQotCS8qIEVuYWJsZSBSWCBUWCBJbnRlcnJ1cHRzICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfUlhDVEwsIDB4ODApOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX1RYTUNUTCwgMHg4MCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfVFhEQ1RMLCAweDgwKTsKLQotCS8qIEZJWE1FIFNldCB0aGUgbWFzdGVyIGNvbnRyb2wgaW50ZXJydXB0IGluIGJsb2NrIGNvbnRyb2wgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9CTEtDVEwsIDB4ODAwKTsKLQotCS8qIEVuYWJsZSBSWCBhbmQgVFggcXVldWVzICovCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0NJUl9SWENUTCk7Ci0JcmVnIHw9IDB4ODsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9SWENUTCwgcmVnKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfQ0lSX1RYTUNUTCk7Ci0JcmVnIHw9IDB4ODsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9UWE1DVEwsIHJlZyk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0NJUl9UWERDVEwpOwotCXJlZyB8PSAweDg7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfVFhEQ1RMLCByZWcpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfR1BJT1VULCAweDUpOwotCS8qIEZJWE1FICovCi0JLyogIHVua25vd19yZWdpc3Rlcl93cml0ZShwcml2KTsgKi8KLQkvKiBVcGRhdGUgbG9jYWwgY2FyZCBoYXNoIGVudHJ5ICovCi0JaGFzaF93cml0ZShwcml2LCBwcml2LT5tYWNfYWRkciwgTE9DQUxfU1RBSUQpOwotCi0JbWlnaHRfc2xlZXAoKTsKLQotCS8qIEZJWE1FICovCi0JYWdueF9zZXRfY2hhbm5lbChwcml2LCAxKTsKLQltaWdodF9zbGVlcCgpOwotfSAvKiBhZ254X2NhcmRfaW50ZXJmYWNlX2luaXQgKi8KLQotCi12b2lkIGFnbnhfaHdfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCUFHTlhfVFJBQ0U7Ci0JbWlnaHRfc2xlZXAoKTsKLQljYXJkX2ludGVyZmFjZV9pbml0KHByaXYpOwotfQotCi1pbnQgYWdueF9od19yZXNldChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXJldHVybiBjYXJkX2Z1bGxfcmVzZXQocHJpdik7Ci19Ci0KLWludCBhZ254X3NldF9zc2lkKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pCi17Ci0JQUdOWF9UUkFDRTsKLQlyZXR1cm4gMDsKLX0KLQotdm9pZCBhZ254X3NldF9ic3NpZChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBjb25zdCB1OCAqYnNzaWQpCi17Ci0JcmVjZWl2ZXJfYnNzaWRfc2V0KHByaXYsIGJzc2lkKTsKLX0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3BoeS5oIGIvZHJpdmVycy9zdGFnaW5nL2FnbngvcGh5LmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGE5NTVmMDUuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2FnbngvcGh5LmgKKysrIC9kZXYvbnVsbApAQCAtMSw0MDkgKzAsMCBAQAotI2lmbmRlZiBBR05YX1BIWV9IXwotI2RlZmluZSBBR05YX1BIWV9IXwotCi0jaW5jbHVkZSAiYWdueC5oIgotCi0vKiBUcmFuc21pc3Npb24gTWFuYWdtZW50IFJlZ2lzdGVycyAqLwotI2RlZmluZSBBR05YX1RYTV9CQVNFCQkweDAwMDAKLSNkZWZpbmUgQUdOWF9UWE1fQ1RMCQkweDAwMDAJLyogY29udHJvbCByZWdpc3RlciAqLwotI2RlZmluZSBBR05YX1RYTV9FVE1GCQkweDAwMDQgLyogZW5hYmxlIHRyYW5zbWlzc2lvbiBtYW5hZ2VtZW50IGZ1bmN0aW9ucyAqLwotI2RlZmluZSBBR05YX1RYTV9UWFRFTVAJCTB4MDAwOCAvKiB0cmFuc21pc3Npb24gdGVtcGxhdGUgKi8KLSNkZWZpbmUgQUdOWF9UWE1fUkVUUllTVEFJRAkweDAwMGMgLyogUmV0cnkgU3RhdGlvbiBJRCAqLwotI2RlZmluZSBBR05YX1RYTV9USU1FU1RBTVBMTwkJMHgwMDEwCS8qIFRpbWVzdGFtcCBMbyAqLwotI2RlZmluZSBBR05YX1RYTV9USU1FU1RBTVBISQkJMHgwMDE0CS8qIFRpbWVzdGFtcCBIaSAqLwotI2RlZmluZSBBR05YX1RYTV9UWERFTEFZCTB4MDAxOCAgLyogdHggZGVsYXkgKi8KLSNkZWZpbmUgQUdOWF9UWE1fVEJUVExPCQkweDAwMjAJLyogdGJ0dCBMbyAqLwotI2RlZmluZSBBR05YX1RYTV9UQlRUSEkJCTB4MDAyNAkvKiB0YnR0IEhpICovCi0jZGVmaW5lIEFHTlhfVFhNX0JFQUlOVEVSCTB4MDAyOCAvKiBCZWFjb24gSW50ZXJ2YWwgKi8KLSNkZWZpbmUgQUdOWF9UWE1fTkFWCQkweDAwMzAgLyogTkFWICovCi0jZGVmaW5lIEFHTlhfVFhNX0NGUE1EVgkJMHgwMDM0IC8qIENGUCBNRFYgKi8KLSNkZWZpbmUgQUdOWF9UWE1fQ0ZQRVJDTlQJMHgwMDM4IC8qIENGUCBwZXJpb2QgY291bnQgKi8KLSNkZWZpbmUgQUdOWF9UWE1fUFJPQkRFTEFZCTB4MDAzYyAvKiBwcm9iZSBkZWxheSAqLwotI2RlZmluZSBBR05YX1RYTV9MSVNJTlRFUkNOVAkweDAwNDAgLyogbGlzdGVuIGludGVydmFsIGNvdW50ICovCi0jZGVmaW5lIEFHTlhfVFhNX0RUSU1QRVJJQ05UCTB4MDA0YyAvKiBEVElNIHBlcmlvZCBjb3VudCAqLwotCi0jZGVmaW5lIEFHTlhfVFhNX0JFQUNPTl9DVEwJMHgwMDVjIC8qIGJlYWNvbiBjb250cm9sICovCi0KLSNkZWZpbmUgQUdOWF9UWE1fU0NIRU1QQ05UCTB4MDA3YyAvKiBzY2hlZHVsZSBlbXB0eSBjb3VudCAqLwotI2RlZmluZSBBR05YX1RYTV9NQVhUSU1PVVQJMHgwMDg0IC8qIG1heCB0aW1lb3V0IGV4Y2VlZCBjb3VudCAqLwotI2RlZmluZSBBR05YX1RYTV9NQVhDRlBUSU0JMHgwMDg4IC8qIG1heCBDRiBwb2xsIHRpbWVvdXQgY291bnQgKi8KLSNkZWZpbmUgQUdOWF9UWE1fTUFYUlhUSU1FCTB4MDA4YyAvKiBtYXggUlggdGltZW91dCBjb3VudCAqLwotI2RlZmluZSBBR05YX1RYTV9NQVhBQ0tUSU0JMHgwMDkwCS8qIG1heCBBQ0sgdGltZW91dCBjb3VudCAqLwotI2RlZmluZSBBR05YX1RYTV9ESUYwMQkJMHgwMGEwIC8qIERJRiAwLTEgKi8KLSNkZWZpbmUgQUdOWF9UWE1fRElGMjMJCTB4MDBhNCAvKiBESUYgMi0zICovCi0jZGVmaW5lIEFHTlhfVFhNX0RJRjQ1CQkweDAwYTggLyogRElGIDQtNSAqLwotI2RlZmluZSBBR05YX1RYTV9ESUY2NwkJMHgwMGFjIC8qIERJRiA2LTcgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0lGU1BJRlMJMHgwMGIwIC8qIFNJRlMvUElGUyAqLwotI2RlZmluZSBBR05YX1RYTV9USUZTRUlGUwkweDAwYjQgLyogVElGUy9FSUZTICovCi0jZGVmaW5lIEFHTlhfVFhNX01BWENDQUNOVFNMT1QJMHgwMGI4IC8qIG1heCBDQ0EgY291bnQgc2xvdCAqLwotI2RlZmluZSBBR05YX1RYTV9TTE9UTElNSVQJMHgwMGJjIC8qIHNsb3QgbGltaXQvMSBtc2VjIGxpbWl0ICovCi0jZGVmaW5lIEFHTlhfVFhNX0NGUE9MTFJYVElNCTB4MDBmMCAvKiBDRiBwb2xsIFJYIHRpbWVvdXQgY291bnQgKi8KLSNkZWZpbmUgQUdOWF9UWE1fQ0ZBQ0tUMTFCCTB4MDBmNCAvKiBDRiBhY2sgdGltZW91dCBsaW1pdCBmb3IgMTFiICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXMAkJMHgwMTAwIC8qIENXIDAgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU0wCTB4MDEwOCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCAwICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXMQkJMHgwMTIwIC8qIENXIDEgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU0xCTB4MDEyOCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCAxICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXMgkJMHgwMTQwIC8qIENXIDIgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU0yCTB4MDE0OCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCAyICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXMwkJMHgwMTYwIC8qIENXIDMgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU0zCTB4MDE2OCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCAzICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXNAkJMHgwMTgwIC8qIENXIDQgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU00CTB4MDE4OCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCA0ICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXNQkJMHgwMWEwIC8qIENXIDUgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU01CTB4MDFhOCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCA1ICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXNgkJMHgwMWMwIC8qIENXIDYgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU02CTB4MDFjOCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCA2ICovCi0jZGVmaW5lIEFHTlhfVFhNX0NXNwkJMHgwMWUwIC8qIENXIDcgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU0xCRUFMSU03CTB4MDFlOCAvKiBzaG9ydC9sb25nIGJlYWNvbiBsaW1pdCA3ICovCi0jZGVmaW5lIEFHTlhfVFhNX0JFQUNPTlRFTVAgICAgIDB4MTAwMAkvKiBiZWFjb24gdGVtcGxhdGUgKi8KLSNkZWZpbmUgQUdOWF9UWE1fU1RBUE9XVEVNUAkweDFhMDAgLyogIFN0YXRpb24gUG93ZXIgVGVtcGxhdGUgKi8KLQotLyogUmVjZWl2ZSBNYW5hZ2VtZW50IENvbnRyb2wgUmVnaXN0ZXJzICovCi0jZGVmaW5lIEFHTlhfUlhNX0JBU0UJCTB4MjAwMAotI2RlZmluZSBBR05YX1JYTV9SRVFSQVRFCTB4MjAwMAkvKiByZXF1ZXN0ZWQgcmF0ZSAqLwotI2RlZmluZSBBR05YX1JYTV9NQUNISQkJMHgyMDA0CS8qIGZpcnN0IDQgYnl0ZXMgb2YgbWFjIGFkZHJlc3MgKi8KLSNkZWZpbmUgQUdOWF9SWE1fTUFDTE8JCTB4MjAwOAkvKiBsYXN0IDIgYnl0ZXMgb2YgbWFjIGFkZHJlc3MgKi8KLSNkZWZpbmUgQUdOWF9SWE1fQlNTSURISQkweDIwMGMJLyogYnNzaWQgaGkgKi8KLSNkZWZpbmUgQUdOWF9SWE1fQlNTSURMTwkweDIwMTAJLyogYnNzaWQgbG8gKi8KLSNkZWZpbmUgQUdOWF9SWE1fSEFTSF9DTURfRkxBRwkweDIwMTQJLyogRmxhZ3MgZm9yIHRoZSBSWCBIYXNoIENvbW1hbmQgRGVmYXVsdDowICovCi0jZGVmaW5lIEFHTlhfUlhNX0hBU0hfQ01EX0hJR0gJMHgyMDE4CS8qIFRoZSBIaWdoIGhhbGYgb2YgdGhlIEhhc2ggQ29tbWFuZCAqLwotI2RlZmluZSBBR05YX1JYTV9IQVNIX0NNRF9MT1cJMHgyMDFjCS8qIFRoZSBMb3cgaGFsZiBvZiB0aGUgSGFzaCBDb21tYW5kICovCi0jZGVmaW5lIEFHTlhfUlhNX1JPVVRBQgkJMHgyMDIwCS8qIHJvdXRpbmcgdGFibGUgKi8KLSNkZWZpbmUJCVJPVVRBQl9TVUJUWVBFX1NISUZUCTI0Ci0jZGVmaW5lCQlST1VUQUJfVFlQRV9TSElGVAkyOAotI2RlZmluZQkJUk9VVEFCX1NUQVRVU19TSElGVAkzMAotI2RlZmluZQkJUk9VVEFCX1JXX1NISUZUCQkzMQotI2RlZmluZQkJUk9VVEFCX1JPVVRFX0RST1AJMHhmMDAwMDAgLyogRHJvcCAqLwotI2RlZmluZQkJUk9VVEFCX1JPVVRFX0NQVQkweDQwMDAwMCAvKiBDUFUgKi8KLSNkZWZpbmUJCVJPVVRBQl9ST1VURV9FTkNSWQkweDUwMDgwMCAvKiBFbmNyeXB0aW9uICovCi0jZGVmaW5lCQlST1VUQUJfUk9VVEVfUkZQCTB4ODAwMDAwIC8qIFJGUCAqLwotCi0jZGVmaW5lCQlST1VUQUJfVFlQRV9NQU5BRwkweDAgLyogTWFuYWdlbWVudCAqLwotI2RlZmluZQkJUk9VVEFCX1RZUEVfQ1RMCQkweDEgLyogQ29udHJvbCAqLwotI2RlZmluZQkJUk9VVEFCX1RZUEVfREFUQQkweDIgLyogRGF0YSAqLwotCi0jZGVmaW5lCQlST1VUQUJfU1VCVFlQRV9EQVRBCQkweDAKLSNkZWZpbmUJCVJPVVRBQl9TVUJUWVBFX0RBVEFBQ0sJCTB4MQotI2RlZmluZQkJUk9VVEFCX1NVQlRZUEVfREFUQVBPTEwJCTB4MgotI2RlZmluZQkJUk9VVEFCX1NVQlRZUEVfREFUQVBPTExBQ0sJMHgzCi0jZGVmaW5lCQlST1VUQUJfU1VCVFlQRV9OVUxMCQkweDQgLyogTlVMTCAqLwotI2RlZmluZQkJUk9VVEFCX1NVQlRZUEVfTlVMTEFDSwkJMHg1Ci0jZGVmaW5lCQlST1VUQUJfU1VCVFlQRV9OVUxMUE9MTAkJMHg2Ci0jZGVmaW5lCQlST1VUQUJfU1VCVFlQRV9OVUxMUE9MTEFDSwkweDcKLSNkZWZpbmUJCVJPVVRBQl9TVUJUWVBFX1FPU0RBVEEJCTB4OCAvKiBRT1MgREFUQSAqLwotI2RlZmluZQkJUk9VVEFCX1NVQlRZUEVfUU9TREFUQUFDSwkweDkKLSNkZWZpbmUJCVJPVVRBQl9TVUJUWVBFX1FPU0RBVEFQT0xMCTB4YQotI2RlZmluZQkJUk9VVEFCX1NVQlRZUEVfUU9TREFUQUFDS1BPTEwJMHhiCi0jZGVmaW5lCQlST1VUQUJfU1VCVFlQRV9RT1NOVUxMCQkweGMKLSNkZWZpbmUJCVJPVVRBQl9TVUJUWVBFX1FPU05VTExBQ0sJMHhkCi0jZGVmaW5lCQlST1VUQUJfU1VCVFlQRV9RT1NOVUxMUE9MTAkweGUKLSNkZWZpbmUJCVJPVVRBQl9TVUJUWVBFX1FPU05VTExQT0xMQUNLCTB4ZgotI2RlZmluZSBBR05YX1JYTV9ERUxBWTExCSAgIDB4MjAyNAkvKiBkZWxheSAxMShBQikgKi8KLSNkZWZpbmUgQUdOWF9SWE1fU09GX0NOVAkgICAweDIwMjgJLyogU09GIENvdW50ICovCi0jZGVmaW5lIEFHTlhfUlhNX0ZSQUdfQ05UCSAgIDB4MjAyYwkvKiBGcmFnbWVudCBDb3VudCovCi0jZGVmaW5lIEFHTlhfUlhNX0ZDU19DTlQJICAgMHgyMDMwCS8qIEZDUyBDb3VudCAqLwotI2RlZmluZSBBR05YX1JYTV9CU1NJRF9NSVNTX0NOVAkgICAweDIwMzQJLyogQlNTSUQgTWlzcyBDb3VudCAqLwotI2RlZmluZSBBR05YX1JYTV9QRFVfRVJSX0NOVAkgICAweDIwMzgJLyogUERVIEVycm9yIENvdW50ICovCi0jZGVmaW5lIEFHTlhfUlhNX0RFU1RfTUlTU19DTlQJICAgMHgyMDNDCS8qIERlc3RpbmF0aW9uIE1pc3MgQ291bnQgKi8KLSNkZWZpbmUgQUdOWF9SWE1fRFJPUF9DTlQJICAgMHgyMDQwCS8qIERyb3AgQ291bnQgKi8KLSNkZWZpbmUgQUdOWF9SWE1fQUJPUlRfQ05UCSAgIDB4MjA0NAkvKiBBYm9ydCBDb3VudCAqLwotI2RlZmluZSBBR05YX1JYTV9SRUxBWV9DTlQJICAgMHgyMDQ4CS8qIFJlbGF5IENvdW50ICovCi0jZGVmaW5lIEFHTlhfUlhNX0hBU0hfTUlTU19DTlQJICAgMHgyMDRjCS8qIEhhc2ggTWlzcyBDb3VudCAqLwotI2RlZmluZSBBR05YX1JYTV9TQV9ISQkJICAgMHgyMDUwCS8qIEFkZHJlc3Mgb2YgcmVjZWl2ZWQgcGFja2V0IEhpICovCi0jZGVmaW5lIEFHTlhfUlhNX1NBX0xPCQkgICAweDIwNTQJLyogQWRkcmVzcyBvZiByZWNlaXZlZCBwYWNrZXQgTG8gKi8KLSNkZWZpbmUgQUdOWF9SWE1fSEFTSF9EVU1QX0xTVAkgICAweDIxMDAJLyogQ29udGFpbnMgSGFzaCBEYXRhICovCi0jZGVmaW5lIEFHTlhfUlhNX0hBU0hfRFVNUF9NU1QJICAgMHgyMTA0CS8qIENvbnRhaW5zIEhhc2ggRGF0YSAqLwotI2RlZmluZSBBR05YX1JYTV9IQVNIX0RVTVBfREFUQSAgICAweDIxMDgJLyogVGhlIFN0YXRpb24gSUQgdG8gZHVtcCAqLwotCi0KLS8qIEVuY3J5cHRpb24gTWFuYWdtZW50ICovCi0jZGVmaW5lIEFHTlhfRU5DUllfQkFTRQkJMHgyNDAwCi0jZGVmaW5lIEFHTlhfRU5DUllfV0VQS0VZMAkweDI0NDAgLyogd2VwIGtleSAjMCAqLwotI2RlZmluZSBBR05YX0VOQ1JZX1dFUEtFWTEJMHgyNDQ0IC8qIHdlcCBrZXkgIzEgKi8KLSNkZWZpbmUgQUdOWF9FTkNSWV9XRVBLRVkyCTB4MjQ0OCAvKiB3ZXAga2V5ICMyICovCi0jZGVmaW5lIEFHTlhfRU5DUllfV0VQS0VZMwkweDI0NGMgLyogd2VwIGtleSAjMyAqLwotI2RlZmluZSBBR05YX0VOQ1JZX0NDTVJFQ1RMCTB4MjQ2MCAvKiBjY20gcmVwbGF5IGNvbnRyb2wgKi8KLQotCi0vKiBCYW5kIE1hbmFnZW1lbnQgUmVnaXN0ZXJzICovCi0jZGVmaW5lIEFHTlhfQk1fQkFTRQkJMHgyYzAwCi0jZGVmaW5lIEFHTlhfQk1fQk1DVEwJCTB4MmMwMCAgLyogYmFuZCBtYW5hZ2VtZW50IGNvbnRyb2wgKi8KLSNkZWZpbmUgQUdOWF9CTV9UWFdBRERSCQkweDJjMTggIC8qIHR4IHdvcmtxdWV1ZSBhZGRyZXNzIHN0YXJ0ICovCi0jZGVmaW5lIEFHTlhfQk1fVFhUT1BFRVIJMHgyYzI0CS8qIHRyYW5zbWl0IHRvIHBlZXJzICovCi0jZGVmaW5lIEFHTlhfQk1fRlBMSFAJCTB4MmMyYyAgLyogZnJlZSBwb29sIGxpc3QgaGVhZCBwb2ludGVyICovCi0jZGVmaW5lIEFHTlhfQk1fRlBMVFAJCTB4MmMzMCAgLyogZnJlZSBwb29sIGxpc3QgdGFpbCBwb2ludGVyICovCi0jZGVmaW5lIEFHTlhfQk1fRlBDTlQJCTB4MmMzNCAgLyogZnJlZSBwb29sIGNvdW50ICovCi0jZGVmaW5lIEFHTlhfQk1fQ0lQRFVXQ05UCTB4MmMzOCAgLyogY2FyZCBpbnRlcmZhY2UgcGR1IHdvcmtxdWV1ZSBjb3VudCAqLwotI2RlZmluZSBBR05YX0JNX1NQUERVV0NOVAkweDJjM2MgIC8qIHNwIHBkdSB3b3JrcXVldWUgY291bnQgKi8KLSNkZWZpbmUgQUdOWF9CTV9SRlBQRFVXQ05UCTB4MmM0MCAgLyogcmZwIHBkdSB3b3JrcXVldWUgY291bnQgKi8KLSNkZWZpbmUgQUdOWF9CTV9SSFBQRFVXQ05UCTB4MmM0NCAgLyogcmhwIHBkdSB3b3JrcXVldWUgY291bnQgKi8KLSNkZWZpbmUgQUdOWF9CTV9DSVdRQ1RMCQkweDJjNDggLyogQ2FyZCBJbnRlcmZhY2UgV29ya1F1ZXVlIENvbnRyb2wgKi8KLSNkZWZpbmUgQUdOWF9CTV9DUFVUWFdDVEwJMHgyYzUwICAvKiBjcHUgdHggd29ya3F1ZXVlIGNvbnRyb2wgKi8KLSNkZWZpbmUgQUdOWF9CTV9DUFVSWFdDVEwJMHgyYzU4ICAvKiBjcHUgcnggd29ya3F1ZXVlIGNvbnRyb2wgKi8KLSNkZWZpbmUgQUdOWF9CTV9DUFVMV0NUTAkweDJjNjAgLyogY3B1IGxvdyB3b3JrcXVldWUgY29udHJvbCAqLwotI2RlZmluZSBBR05YX0JNX0NQVUhXQ1RMCTB4MmM2OCAvKiBjcHUgaGlnaCB3b3JrcXVldWUgY29udHJvbCAqLwotI2RlZmluZSBBR05YX0JNX1NQVFhXQ1RMCTB4MmM3MCAvKiBzcCB0eCB3b3JrcXVldWUgY29udHJvbCAqLwotI2RlZmluZSBBR05YX0JNX1NQUlhXQ1RMCTB4MmM3OCAvKiBzcCByeCB3b3JrcXVldWUgY29udHJvbCAqLwotI2RlZmluZSBBR05YX0JNX1JGUFdDVEwJCTB4MmM4MCAvKiBSRlAgd29ya3F1ZXVlIGNvbnRyb2wgKi8KLSNkZWZpbmUgQUdOWF9CTV9NVFNNCQkweDJjOTAgLyogTXVsdGljYXN0IFRyYW5zbWl0IFN0YXRpb24gTWFzayAqLwotCi0vKiBDYXJkIEludGVyZmFjZSBSZWdpc3RlcnMgKDMyYml0cykgKi8KLSNkZWZpbmUgQUdOWF9DSVJfQkFTRQkJMHgzMDAwCi0jZGVmaW5lIEFHTlhfQ0lSX0JMS0NUTAkJMHgzMDAwCS8qIGJsb2NrIGNvbnRyb2wqLwotI2RlZmluZQkJQUdOWF9TVEFUX1RYCTB4MQotI2RlZmluZQkJQUdOWF9TVEFUX1JYCTB4MgotI2RlZmluZQkJQUdOWF9TVEFUX1gJMHg0Ci0vKiBCZWxvdyB0d28gaW50ZXJydXB0IGZsYWdzIHdpbGwgYmUgc2V0IGJ5IG91ciBidXQgbm90IENQVSBvciB0aGUgY2FyZCAqLwotI2RlZmluZQkJQUdOWF9TVEFUX1RYRAkweDEwCi0jZGVmaW5lCQlBR05YX1NUQVRfVFhNCTB4MjAKLQotI2RlZmluZSBBR05YX0NJUl9BRERSV0lOCTB4MzAwNAkvKiBBZGRyZXNzYWJsZSBXaW5kb3dzKi8KLSNkZWZpbmUgQUdOWF9DSVJfRU5ESUFOCQkweDMwMDggIC8qIGNhcmQgZW5kaWFubmVzcyAqLwotI2RlZmluZSBBR05YX0NJUl9TRVJJQUxJVEYJMHgzMDIwCS8qIHNlcmlhbCBpbnRlcmZhY2UgKi8KLSNkZWZpbmUgQUdOWF9DSVJfUlhDRkcJCTB4MzA0MAkvKiByZWNlaXZlIGNvbmZpZyAqLwotI2RlZmluZQkJRU5BQkxFX1JYX0lOVEVSUlVQVCAweDIwCi0jZGVmaW5lCQlSWF9DQUNIRV9MSU5FCSAgICAweDgKLS8qIHRoZSBSWCBmcmFnbWVudCBsZW5ndGggKi8KLSNkZWZpbmUJCUZSQUdfTEVOXzI1NgkweDAgLyogMjU2QiAqLwotI2RlZmluZQkJRlJBR19MRU5fNTEyCTB4MQotI2RlZmluZQkJRlJBR19MRU5fMTAyNAkweDIKLSNkZWZpbmUJCUZSQUdfTEVOXzIwNDgJMHgzCi0jZGVmaW5lCQlGUkFHX0JFCQkweDEwCi0jZGVmaW5lIEFHTlhfQ0lSX1JYQ1RMCQkweDMwNTAJLyogcmVjZWl2ZSBjb250cm9sICovCi0vKiBtZW1vcnkgYWRkcmVzcywgY2hpcHNpZGUgKi8KLSNkZWZpbmUgQUdOWF9DSVJfUlhDTVNUQVJUCTB4MzA1NAkvKiByZWNlaXZlIGNsaWVudCBtZW1vcnkgc3RhcnQgKi8KLSNkZWZpbmUgQUdOWF9DSVJfUlhDTUVORAkweDMwNTgJLyogcmVjZWl2ZSBjbGllbnQgbWVtb3J5IGVuZCAqLwotLyogbWVtb3J5IGFkZHJlc3MsIHBjaSAqLwotI2RlZmluZSBBR05YX0NJUl9SWEhPU1RBRERSCTB4MzA2MAkvKiByZWNlaXZlIGhvc3RzaWRlIGFkZHJlc3MgKi8KLS8qIG1lbW9yeSBhZGRyZXNzLCBjaGlwc2lkZSAqLwotI2RlZmluZSBBR05YX0NJUl9SWENMSUFERFIJMHgzMDY0CS8qIHJlY2VpdmUgY2xpZW50c2lkZSBhZGRyZXNzICovCi0jZGVmaW5lIEFHTlhfQ0lSX1JYRE1BQ1RMCTB4MzA2OAkvKiByZWNlaXZlIGRtYSBjb250cm9sICovCi0jZGVmaW5lIEFHTlhfQ0lSX1RYQ0ZHCQkweDMwODAJLyogdHJhbnNtaXQgY29uZmlnICovCi0jZGVmaW5lIEFHTlhfQ0lSX1RYTUNUTAkJMHgzMDkwIC8qIFRyYW5zbWl0IE1hbmFnZW1lbnQgQ29udHJvbCAqLwotI2RlZmluZQkJRU5BQkxFX1RYX0lOVEVSUlVQVCAweDIwCi0jZGVmaW5lCQlUWF9DQUNIRV9MSU5FCSAgICAweDgKLSNkZWZpbmUgQUdOWF9DSVJfVFhNU1RBUlQJMHgzMDk0IC8qIFRyYW5zbWl0IE1hbmFnZW1lbnQgU3RhcnQgKi8KLSNkZWZpbmUgQUdOWF9DSVJfVFhNRU5ECQkweDMwOTggLyogVHJhbnNtaXQgTWFuYWdlbWVudCBFbmQgKi8KLSNkZWZpbmUgQUdOWF9DSVJfVFhEQ1RMCQkweDMwYTAJLyogdHJhbnNtaXQgZGF0YSBjb250cm9sICovCi0vKiBtZW1lb3J5IGFkZHJlc3MsIGNoaXBzZXQgKi8KLSNkZWZpbmUgQUdOWF9DSVJfVFhEU1RBUlQJMHgzMGE0CS8qIHRyYW5zbWl0IGRhdGEgc3RhcnQgKi8KLSNkZWZpbmUgQUdOWF9DSVJfVFhERU5ECQkweDMwYTgJLyogdHJhbnNtaXQgZGF0YSBlbmQgKi8KLSNkZWZpbmUgQUdOWF9DSVJfVFhNSEFERFIJMHgzMGIwIC8qIFRyYW5zbWl0IE1hbmFnZW1lbnQgSG9zdHNpZGUgQWRkcmVzcyAqLwotI2RlZmluZSBBR05YX0NJUl9UWE1DQUREUgkweDMwYjQgLyogVHJhbnNtaXQgTWFuYWdlbWVudCBDbGllbnRzaWRlIEFkZHJlc3MgKi8KLSNkZWZpbmUgQUdOWF9DSVJfVFhETUFDVEwJMHgzMGI4CS8qIHRyYW5zbWl0IGRtYSBjb250cm9sICovCi0KLQotLyogUG93ZXIgTWFuYWdtZW50IFVuaXQgKi8KLSNkZWZpbmUgQUdOWF9QTV9CQVNFCQkweDNjMDAKLSNkZWZpbmUgQUdOWF9QTV9QTUNUTAkJMHgzYzAwCS8qIFBNIENvbnRyb2wqLwotI2RlZmluZSBBR05YX1BNX01BQ01TVwkJMHgzYzA4IC8qIE1BQyBNYW51YWwgU2xvdyBXb3JrIEVuYWJsZSAqLwotI2RlZmluZSBBR05YX1BNX1JGQ1RMCQkweDNjMGMgLyogUkYgQ29udHJvbCAqLwotI2RlZmluZSBBR05YX1BNX1BIWU1XCQkweDNjMTQJLyogUGh5IE1hbm5hbCBXb3JrICovCi0jZGVmaW5lIEFHTlhfUE1fU09GVFJTVAkJMHgzYzE4CS8qIFBNVSBTb2Z0IFJlc2V0ICovCi0jZGVmaW5lIEFHTlhfUE1fUExMQ1RMCQkweDNjMWMJLyogUE1VIFBMTCBjb250cm9sKi8KLSNkZWZpbmUgQUdOWF9QTV9URVNUUEhZCQkweDNjMjQgLyogUE1VIFRlc3QgUGh5ICovCi0KLQotLyogSW50ZXJydXB0IENvbnRyb2wgaW50ZXJmYWNlICovCi0jZGVmaW5lIEFHTlhfSU5UX0JBU0UJCTB4NDAwMAotI2RlZmluZSBBR05YX0lOVF9TVEFUCQkweDQwMDAJLyogaW50ZXJydXB0IHN0YXR1cyAqLwotI2RlZmluZSBBR05YX0lOVF9NQVNLCQkweDQwMGMJLyogaW50ZXJydXB0IG1hc2sgKi8KLS8qIEZJWE1FICovCi0jZGVmaW5lCQlJUlFfVFhfQkVBQ09OCTB4MQkvKiBUWCBCZWFjb24gKi8KLSNkZWZpbmUJCUlSUV9UWF9SRVRSWQkweDgJLyogVFggUmV0cnkgSW50ZXJydXB0ICovCi0jZGVmaW5lCQlJUlFfVFhfQUNUSVZJVFkJMHgxMAkvKiBUWCBBY3Rpdml0eSAqLwotI2RlZmluZQkJSVJRX1JYX0FDVElWSVRZCTB4MjAJLyogUlggQWN0aXZpdHkgKi8KLS8qIEZJWE1FIEkgZ3Vlc3MgdGhhdCBpbnN0ZWFkIFJYIGEgbm9uZSBleGlzdCBzdGFpb24ncyBwYWNrZXQgb3IKLSAgIHRoZSBzdGF0aW9uIGhhc24ndCBiZWVuIGluaXQgKi8KLSNkZWZpbmUJCUlSUV9SWF9YCTB4NDAKLSNkZWZpbmUJCUlSUV9SWF9ZCTB4ODAJLyogUlggPyAqLwotI2RlZmluZQkJSVJRX1JYX0hBU0hISVQJMHgxMDAJLyogUlggSGFzaCBIaXQgKi8KLSNkZWZpbmUJCUlSUV9SWF9GUkFNRQkweDIwMAkvKiBSWCBGcmFtZSAqLwotI2RlZmluZQkJSVJRX0VSUl9JTlQJMHg0MDAJLyogRXJyb3IgSW50ZXJydXB0ICovCi0jZGVmaW5lCQlJUlFfVFhfUVVFX0ZVTEwJMHg4MDAJLyogVFggV29ya3F1ZXVlIEZ1bGwgKi8KLSNkZWZpbmUJCUlSUV9CQU5ETUFOX0VSUgkweDEwMDAwCS8qIEJhbmR3aWR0aCBNYW5hZ2VtZW50IEVycm9yICovCi0jZGVmaW5lCQlJUlFfVFhfRElTQUJMRQkweDIwMDAwCS8qIFRYIERpc2FibGUgKi8KLSNkZWZpbmUJCUlSUV9SWF9JVkFTRVNLRVkgMHg4MDAwMCAvKiBSWCBJbnZhbGlkIFNlc3Npb24gS2V5ICovCi0jZGVmaW5lCQlJUlFfUlhfS0VZSURNSVMJMHgxMDAwMDAgLyogUlgga2V5IElEIE1pc21hdGNoICovCi0jZGVmaW5lCQlJUlFfUkVQX1RISElUCTB4MjAwMDAwIC8qIFJlcGxheSBUaHJlc2hvbGQgSGl0ICovCi0jZGVmaW5lCQlJUlFfVElNRVIxCTB4NDAwMDAwMCAvKiBUaW1lcjEgKi8KLSNkZWZpbmUJCUlSUV9USU1FUl9DTlQJMHgxMDAwMDAwMCAvKiBUaW1lciBDb3VudCAqLwotI2RlZmluZQkJSVJRX1BIWV9GQVNUSU5UIDB4MjAwMDAwMDAgLyogUGh5IEZhc3QgSW50ZXJydXB0ICovCi0jZGVmaW5lCQlJUlFfUEhZX1NMT1dJTlQJMHg0MDAwMDAwMCAvKiBQaHkgU2xvdyBJbnRlcnJ1cHQgKi8KLSNkZWZpbmUJCUlSUV9PVEhFUgkweDgwMDAwMDAwIC8qIFVua25vdyBpbnRlcnJ1cHQgKi8KLSNkZWZpbmUJCUFHTlhfSVJRX0FMTCAgIAkweGZmZmZmZmZmCi0KLS8qIFN5c3RlbSBJbnRlcmZhY2UgKi8KLSNkZWZpbmUgQUdOWF9TWVNJVEZfQkFTRQkweDQ0MDAKLSNkZWZpbmUgQUdOWF9TWVNJVEZfU1lTTU9ERQkweDQ0MDAJLyogc3lzdGVtIG1vZGUgKi8KLSNkZWZpbmUgQUdOWF9TWVNJVEZfR1BJT0lOCTB4NDQxMCAvKiBHUElPIEluICovCi0vKiBQSU4gbGluZXMgZm9yIGxlZHM/ICovCi0jZGVmaW5lIEFHTlhfU1lTSVRGX0dQSU9VVAkweDQ0MTQJLyogR1BJTyBPdXQgKi8KLQotLyogVGltZXIgQ29udHJvbCAqLwotI2RlZmluZSBBR05YX1RJTUNUTF9USU1FUjEJMHg0ODAwIC8qIFRpbWVyIDEgKi8KLSNkZWZpbmUgQUdOWF9USU1DVExfVElNMUNUTAkweDQ4MDggLyogVGltZXIgMSBDb250cm9sICovCi0KLQotLyogQW50ZW5uYSBDYWxpYnJhdGlvbiBJbnRlcmZhY2UgKi8KLSNkZWZpbmUgQUdOWF9BQ0lfQkFTRQkJMHg1MDAwCi0jZGVmaW5lIEFHTlhfQUNJX01PREUJCTB4NTAwMCAvKiBNb2RlICovCi0jZGVmaW5lIEFHTlhfQUNJX01FQVNVUkUJMHg1MDA0IC8qIE1lYXN1cmUgKi8KLSNkZWZpbmUgQUdOWF9BQ0lfU0VMQ0hBSU4JMHg1MDA4IC8qIFNlbGVjdCBDaGFpbiAqLwotI2RlZmluZSBBR05YX0FDSV9MRU4JCTB4NTAwYyAvKiBMZW5ndGggKi8KLSNkZWZpbmUgQUdOWF9BQ0lfVElNRVIxCQkweDUwMTggLyogVGltZXIgMSAqLwotI2RlZmluZSBBR05YX0FDSV9USU1FUjIJCTB4NTAxYyAvKiBUaW1lciAyICovCi0jZGVmaW5lIEFHTlhfQUNJX09GRlNFVAkJMHg1MDIwIC8qIE9mZnNldCAqLwotI2RlZmluZSBBR05YX0FDSV9TVEFUVVMJCTB4NTAzMCAvKiBTdGF0dXMgKi8KLSNkZWZpbmUJCUNBTElfSURMRQkweDAKLSNkZWZpbmUJCUNBTElfRE9ORQkweDEKLSNkZWZpbmUJCUNBTElfQlVTWQkweDIKLSNkZWZpbmUJCUNBTElfRVJSCTB4MwotI2RlZmluZSBBR05YX0FDSV9BSUNDSEEwT1ZFCTB4NTAzNCAvKiBBSUMgQ2hhbm5lbCAwIE92ZXJyaWRlICovCi0jZGVmaW5lIEFHTlhfQUNJX0FJQ0NIQTFPVkUJMHg1MDM4IC8qIEFJQyBDaGFubmVsIDEgT3ZlcnJpZGUgKi8KLQotLyogR2FpbiBDb250cm9sIFJlZ2lzdGVycyAqLwotI2RlZmluZSBBR05YX0dDUl9CQVNFCQkweDkwMDAKLS8qIHRocmVzaG9sZCBvZiBwcmltYXJ5IGFudGVubmEgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfVEhEMEEJCTB4OTAwMAkvKiB0aHJlc2hvbGQ/IEQwIEEgKi8KLS8qIGxvdyB0aHJlc2hvbGQgb2YgcHJpbWFyeSBhbnRlbm5hICovCi0jZGVmaW5lIEFHTlhfR0NSX1RIRDBBTAkJMHg5MDA0CS8qIHRocmVzaG9sZD8gRDAgQSBsb3cgKi8KLS8qIHRocmVzaG9sZCBvZiBzZWNvbmRhcnkgYW50ZW5uYSAqLwotI2RlZmluZSBBR05YX0dDUl9USEQwQgkJMHg5MDA4CS8qIHRocmVzaG9sZD8gRDBfQiAqLwotI2RlZmluZSBBR05YX0dDUl9EVU5TQVQJCTB4OTAwYyAvKiBkIHVuc2F0dXJhdGVkICovCi0jZGVmaW5lIEFHTlhfR0NSX0RTQVQJCTB4OTAxMCAvKiBkIHNhdHVyYXRlZCAqLwotI2RlZmluZSBBR05YX0dDUl9ERklSQ0FMCTB4OTAxNCAvKiBEIEZpci9DYWwgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfREdDVEwxMUEJMHg5MDE4IC8qIGQgZ2FpbiBjb250cm9sIDExYSAqLwotI2RlZmluZSBBR05YX0dDUl9ER0NUTDExQgkweDkwMWMgLyogZCBnYWluIGNvbnRyb2wgMTFiICovCi0vKiBzdHJlbmd0aCBvZiBnYWluICovCi0jZGVmaW5lIEFHTlhfR0NSX0dBSU5JTklUCTB4OTAyMAkvKiBnYWluIGluaXRpYWxpemF0aW9uICovCi0jZGVmaW5lIEFHTlhfR0NSX1RITk9TSUcJMHg5MDI0IC8qIHRocmVob2xkIG5vIHNpZ25hbCAqLwotI2RlZmluZSBBR05YX0dDUl9DT0FSU1RFUAkweDkwMjggLyogY29hcnNlIHN0ZXBwaW5nICovCi0jZGVmaW5lIEFHTlhfR0NSX1NJRlNUMTFBCTB4OTAyYyAvKiBzaWZ4IHRpbWUgMTFhICovCi0jZGVmaW5lIEFHTlhfR0NSX1NJRlNUMTFCCTB4OTAzMCAvKiBzaWZ4IHRpbWUgMTFiICovCi0jZGVmaW5lIEFHTlhfR0NSX0NXREVURUMJMHg5MDM0IC8qIGN3IGRldGVjdGlvbiAqLwotI2RlZmluZSBBR05YX0dDUl8wWDM4CQkweDkwMzggLyogPz8/PyAqLwotI2RlZmluZSBBR05YX0dDUl9CT0FDVAkJMHg5MDNjCS8qIEJPIEFjdGl2ZSAqLwotI2RlZmluZSBBR05YX0dDUl9CT0lOQUNUCTB4OTA0MAkvKiBCTyBJbmFjdGl2ZSAqLwotI2RlZmluZSBBR05YX0dDUl9CT0RZTkEJCTB4OTA0NAkvKiBCTyBkeW5hbWljICovCi0vKiA4MDIuMTEgbW9kZShhLGIsZykgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfRElTQ09WTU9ECTB4OTA0OAkvKiBkaXNjb3ZlcnkgbW9kZSAqLwotI2RlZmluZSBBR05YX0dDUl9OTElTVEFOVAkweDkwNGMJLyogbnVtYmVyIG9mIGxpc3RlbmluZyBhbnRlbm5hICovCi0jZGVmaW5lIEFHTlhfR0NSX05BQ1RJQU5UCTB4OTA1MAkvKiBudW1iZXIgb2YgYWN0aXZlIGFudGVubmEgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfTk1FQVNBTlQJMHg5MDU0CS8qIG51bWJlciBvZiBtZWFzdXJpbmcgYW50ZW5uYSAqLwotI2RlZmluZSBBR05YX0dDUl9OQ0FQVEFOVAkweDkwNTgJLyogbnVtYmVyIG9mIGNhcHR1cmUgYW50ZW5uYSAqLwotI2RlZmluZSBBR05YX0dDUl9USENBUDExQQkweDkwNWMgLyogdGhyZXNob2xkIGNhcHR1cmUgMTFhICovCi0jZGVmaW5lIEFHTlhfR0NSX1RIQ0FQMTFCCTB4OTA2MCAvKiB0aHJlc2hvbGQgY2FwdHVyZSAxMWIgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfVEhDQVBSWDExQQkweDkwNjQgLyogdGhyZXNob2xkIGNhcHR1cmUgcnggMTFhICovCi0jZGVmaW5lIEFHTlhfR0NSX1RIQ0FQUlgxMUIJMHg5MDY4IC8qIHRocmVzaG9sZCBjYXB0dXJlIHJ4IDExYiAqLwotI2RlZmluZSBBR05YX0dDUl9USExFVkRSTwkweDkwNmMgLyogdGhyZXNob2xkIGxldmVsIGRyb3AgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfR0FJTlNFVDAJMHg5MDcwIC8qIEdhaW5zZXQgMCAqLwotI2RlZmluZSBBR05YX0dDUl9HQUlOU0VUMQkweDkwNzQgLyogR2FpbnNldCAxICovCi0jZGVmaW5lIEFHTlhfR0NSX0dBSU5TRVQyCTB4OTA3OCAvKiBHYWluc2V0IDIgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfTUFYUlhUSU1FMTFBCTB4OTA3YyAvKiBtYXhpbXVtIHJ4IHRpbWUgMTFhICovCi0jZGVmaW5lIEFHTlhfR0NSX01BWFJYVElNRTExQgkweDkwODAgLyogbWF4aW11bSByeCB0aW1lIDExYiAqLwotI2RlZmluZSBBR05YX0dDUl9DT1JSVElNRQkweDkwODQgLyogY29ycmVjdGlvbiB0aW1lICovCi0vKiByZXNldCB0aGUgc3Vic3lzdGVtLCAwID0gZGlzYWJsZSwgMSA9IGVuYWJsZSAqLwotI2RlZmluZSBBR05YX0dDUl9SU1RHQ1RMCTB4OTA4OAkvKiByZXNldCBnYWluIGNvbnRyb2wgKi8KLS8qIGNoYW5uZWwgcmVjZWl2aW5nICovCi0jZGVmaW5lIEFHTlhfR0NSX1JYQ0hBTkVMCTB4OTA4YwkvKiByZWNlaXZlIGNoYW5uZWwgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfTk9JU0UwCQkweDkwOTAgLyogTm9pc2UgMCAqLwotI2RlZmluZSBBR05YX0dDUl9OT0lTRTEJCTB4OTA5NCAvKiBOb2lzZSAxICovCi0jZGVmaW5lIEFHTlhfR0NSX05PSVNFMgkJMHg5MDk4IC8qIE5vaXNlIDIgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfU0lHSFRICQkweDkwOWMJLyogU2lnbmFsIEhpZ2ggVGhyZXNob2xkICovCi0jZGVmaW5lIEFHTlhfR0NSX1NJR0xUSAkJMHg5MGEwCS8qIFNpZ25hbCBMb3cgVGhyZXNob2xkICovCi0jZGVmaW5lIEFHTlhfR0NSX0NPUlJEUk9QCTB4OTBhNCAvKiBjb3JyZWN0aW9uIGRyb3AgKi8KLS8qIHRocmVzaG9sZCBvZiB0ZXJ0aWF5IGFudGVubmEgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfVEhDRAkJMHg5MGE4CS8qIHRocmVzaG9sZD8gQ0QgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfVEhDUwkJMHg5MGFjCS8qIHRocmVzaG9sZD8gQ1MgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfTUFYUE9XRElGRgkweDkwYjggLyogbWF4aW11bSBwb3dlciBkaWZmZXJlbmNlICovCi0jZGVmaW5lIEFHTlhfR0NSX1RSQUNOVDQJMHg5MGVjIC8qIFRyYW5zaXRpb24gQ291bnQgNCAqLwotI2RlZmluZSBBR05YX0dDUl9UUkFDTlQ1ICAgICAgCTB4OTBmMAkvKiB0cmFuc2l0aW9uIGNvdW50IDUgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfVFJBQ05UNiAgICAgICAJMHg5MGY0CS8qIHRyYW5zaXRpb24gY291bnQgNiAqLwotI2RlZmluZSBBR05YX0dDUl9UUkFDTlQ3ICAgICAgIAkweDkwZjgJLyogdHJhbnNpdGlvbiBjb3V0biA3ICovCi0jZGVmaW5lIEFHTlhfR0NSX1RFU1RCVVMJMHg5MTFjIC8qIHRlc3QgYnVzICovCi0jZGVmaW5lIEFHTlhfR0NSX0NIQUlOTlVNCTB4OTEyMCAvKiBOdW1iZXIgb2YgQ2hhaW5zICovCi0jZGVmaW5lIEFHTlhfR0NSX0FOVENGRwkJMHg5MTI0CS8qIEFudGVubmEgQ29uZmlnICovCi0jZGVmaW5lIEFHTlhfR0NSX1RISlVNUAkJMHg5MTJjIC8qIHRocmVob2xkIGp1bXAgKi8KLSNkZWZpbmUgQUdOWF9HQ1JfVEhQT1dFUgkweDkxMzAgLyogdGhyZXNob2xkIHBvd2VyICovCi0jZGVmaW5lIEFHTlhfR0NSX1RIUE9XQ0xJUAkweDkxMzQgLyogdGhyZXNob2xkIHBvd2VyIGNsaXAqLwotI2RlZmluZSBBR05YX0dDUl9GT1JDRUNUTENMSwkweDkxMzggLyogRm9yY2UgR2FpbiBDb250cm9sIENsb2NrICovCi0jZGVmaW5lIEFHTlhfR0NSX0dBSU5TRVRXUklURQkweDkxM2MgLyogR2FpbnNldCBXcml0ZSAqLwotI2RlZmluZSBBR05YX0dDUl9USEQwQlRGRVNUCTB4OTE0MAkvKiB0aHJlc2hvbGQgZDAgYiB0ZiBlc3RpbWF0ZSAqLwotI2RlZmluZSBBR05YX0dDUl9USFJYMTFCUE9XTUlOCTB4OTE0NAkvKiB0aHJlc2hvbGQgcnggMTFiIHBvd2VyIG1pbmltdW0gKi8KLSNkZWZpbmUgQUdOWF9HQ1JfMFgxNGMJCTB4OTE0YyAvKiA/PyAqLwotI2RlZmluZSBBR05YX0dDUl8wWDE1MAkJMHg5MTUwIC8qID8/ICovCi0jZGVmaW5lIEFHTlhfR0NSX1JYT1ZFUklERQkweDkxOTQJLyogcmVjaWV2ZSBvdmVycmlkZSAqLwotI2RlZmluZSBBR05YX0dDUl9XQVRDSERPRwkweDkxYjAJLyogd2F0Y2hkb2cgdGltZW91dCAqLwotCi0KLS8qIFNwaSBJbnRlcmZhY2UgKi8KLSNkZWZpbmUgQUdOWF9TUElfQkFTRQkJMHhkYzAwCi0jZGVmaW5lIEFHTlhfU1BJX0NGRwkJMHhkYzAwIC8qIHNwaSBjb25maWd1cmF0aW9uICovCi0vKiBPbmx5IGFjY2VwdCAxNiBiaXRzICovCi0jZGVmaW5lIEFHTlhfU1BJX1dNU1cJCTB4ZGMwNAkvKiB3cml0ZSBtb3N0IHNpZ25pZmljYW50IHdvcmQgKi8KLS8qIE9ubHkgYWNjZXB0IDE2IGJpdHMgKi8KLSNkZWZpbmUgQUdOWF9TUElfV0xTVwkJMHhkYzA4CS8qIHdyaXRlIGxlYXN0IHNpZ25pZmljYW50IHdvcmQgKi8KLSNkZWZpbmUgQUdOWF9TUElfQ1RMCQkweGRjMGMJLyogc3BpIGNvbnRyb2wgKi8KLSNkZWZpbmUgQUdOWF9TUElfUk1TVwkJMHhkYzEwIC8qIHJlYWQgbW9zdCBzaWduaWZpY2FudCB3b3JkICovCi0jZGVmaW5lIEFHTlhfU1BJX1JMU1cJCTB4ZGMxNCAvKiByZWFkIGxlYXN0IHNpZ25pZmljYW50IHdvcmQgKi8KLS8qIFNQSSBDb250cm9sIE1hc2sgKi8KLSNkZWZpbmUJCVNQSV9SRUFEX0NUTAkJMHg0MDAwIC8qIHJlYWQgY29udHJvbCAqLwotI2RlZmluZQkJU1BJX0JVU1lfQ1RMCQkweDgwMDAgLyogYnVzeSBjb250cm9sICovCi0vKiBSRiBhbmQgc3ludGggY2hpcHMgaW4gc3BpICovCi0jZGVmaW5lCQlSRl9DSElQMAkweDQwMAotI2RlZmluZQkJUkZfQ0hJUDEJMHg4MDAKLSNkZWZpbmUJCVJGX0NISVAyCTB4MTAwMAotI2RlZmluZQkJU1lOVEhfQ0hJUAkweDIwMDAKLQotLyogVW5rbm93biByZWdpc3RlciAqLwotI2RlZmluZSBBR05YX1VOS05PV05fQkFTRQkweDc4MDAKLQotLyogRklYTUUgTW9uaXRvckdhaW4gKi8KLSNkZWZpbmUgQUdOWF9NT05HQ1JfQkFTRQkweDEyMDAwCi0KLS8qIEdhaW4gVGFibGUgKi8KLSNkZWZpbmUgQUdOWF9HQUlOX1RBQkxFCQkweDEyNDAwCi0KLS8qIFRoZSBpbml0aWFsIEZJUiBjb2VmZmljaWVudCB0YWJsZSAqLwotI2RlZmluZSBBR05YX0ZJUl9CQVNFCQkweDE5ODA0Ci0KLSNkZWZpbmUgQUdOWF9FTkdJTkVfTE9PS1VQX1RCTAkweDgwMAotCi0vKiBlZXByb20gY29tbWFuZHMgKi8KLSNkZWZpbmUgRUVQUk9NX0NNRF9OVUxMCQkweDAgLyogTlVMTCAqLwotI2RlZmluZSBFRVBST01fQ01EX1dSSVRFCTB4MiAvKiB3cml0ZSAqLwotI2RlZmluZSBFRVBST01fQ01EX1JFQUQJCTB4MyAvKiByZWFkICovCi0jZGVmaW5lIEVFUFJPTV9DTURfU1RBVFVTUkVBRAkweDUgLyogc3RhdHVzIHJlZ2lzdGVyIHJlYWQgKi8KLSNkZWZpbmUgRUVQUk9NX0NNRF9XUklURUVOQUJMRQkweDYgLyogd3JpdGUgZW5hYmxlICovCi0jZGVmaW5lIEVFUFJPTV9DTURfQ09ORklHVVJFCTB4NyAvKiBjb25maWd1cmUgKi8KLQotI2RlZmluZSBFRVBST01fREFUQUZPUkNPRklHVVJFCTB4NiAvKiA/Pz8gKi8KLQotLyogZWVwcm9tIGFkZHJlc3MgKi8KLSNkZWZpbmUgRUVQUk9NX0FERFJfU1VCVklECTB4MCAvKiBTdWIgVmVuZG9yIElEICovCi0jZGVmaW5lIEVFUFJPTV9BRERSX1NVQlNJRAkweDIgLyogU3ViIFN5c3RlbSBJRCAqLwotI2RlZmluZSBFRVBST01fQUREUl9NQUNBRERSCTB4MTQ2IC8qIE1BQyBBZGRyZXNzICovCi0jZGVmaW5lIEVFUFJPTV9BRERSX0xPVFlQRQkweDE0ZiAvKiBMTyB0eXBlICovCi0KLXN0cnVjdCBhZ254X2VlcHJvbSB7Ci0JdTggZGF0YTsJLyogZGF0ZSAqLwotCXUxNiBhZGRyZXNzOwkvKiBhZGRyZXNzIGluIEVFUFJPTSAqLwotCXU4IGNtZDsJCS8qIGNvbW1hbmQsIHVua25vd24sIHN0YXR1cyAqLwotfSAgX19hdHRyaWJ1dGVfXygoX19wYWNrZWRfXykpOwotCi0jZGVmaW5lIEFHTlhfRUVQUk9NX0NPTU1BTkRfU0hJRlQJNQotI2RlZmluZSBBR05YX0VFUFJPTV9DT01NQU5EX1NUQVQJMHgwMQotCi12b2lkIGRpc2FibGVfcmVjZWl2ZXIoc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci12b2lkIGVuYWJsZV9yZWNlaXZlcihzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLXU4IHJlYWRfZnJvbV9lZXByb20oc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdTE2IGFkZHJlc3MpOwotdm9pZCBhZ254X2h3X2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci1pbnQgYWdueF9od19yZXNldChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLWludCBhZ254X3NldF9zc2lkKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHU4ICpzc2lkLCBzaXplX3Qgc3NpZF9sZW4pOwotdm9pZCBhZ254X3NldF9ic3NpZChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBjb25zdCB1OCAqYnNzaWQpOwotdm9pZCBlbmFibGVfcG93ZXJfc2F2aW5nKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpOwotdm9pZCBkaXNhYmxlX3Bvd2VyX3NhdmluZyhzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLXZvaWQgY2FsaWJyYXRlX2FudGVubmFfcGVyaW9kKHVuc2lnbmVkIGxvbmcgZGF0YSk7Ci0KLSNlbmRpZiAvKiBBR05YX1BIWV9IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2FnbngvcmYuYyBiL2RyaXZlcnMvc3RhZ2luZy9hZ254L3JmLmMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDQyZTQ1N2EuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2FnbngvcmYuYworKysgL2Rldi9udWxsCkBAIC0xLDg5MyArMCwwIEBACi0vKioKLSAqIEFpcmdvIE1JTU8gd2lyZWxlc3MgZHJpdmVyCi0gKgotICogQ29weXJpZ2h0IChjKSAyMDA3IExpIFlhbkJvIDxkcmVhbWZseTI4MUBnbWFpbC5jb20+Ci0KLSAqIFRoYW5rcyBmb3IgSmVmZiBXaWxsaWFtcyA8YW5nZWxiYW5lQGdtYWlsLmNvbT4gZG8gcmV2ZXJzZSBlbmdpbmVlcgotICogd29ya3MgYW5kIHB1Ymxpc2hlZCB0aGUgU1BFQ1MgYXQgaHR0cDovL2FpcmdvLndkd2NvbnN1bHRpbmcubmV0L215bW9pbgotCi0gKiBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQotICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKLSAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOwotICovCi0KLSNpbmNsdWRlIDxsaW51eC9wY2kuaD4KLSNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgotI2luY2x1ZGUgImFnbnguaCIKLSNpbmNsdWRlICJkZWJ1Zy5oIgotI2luY2x1ZGUgInBoeS5oIgotI2luY2x1ZGUgInRhYmxlLmgiCi0KLS8qIEZJWE1FISAqLwotc3RhdGljIGlubGluZSB2b2lkIHNwaV93cml0ZSh2b2lkIF9faW9tZW0gKnJlZ2lvbiwgdTMyIGNoaXBfaWRzLCB1MzIgc3csCi0JCSAgICAgIHUxNiBzaXplLCB1MzIgY29udHJvbCkKLXsKLQl1MzIgcmVnOwotCXUzMiBsc3cgPSBzdyAmIDB4ZmZmZjsJCS8qIGxvd2VyIDE2IGJpdHMgb2Ygc3cqLwotCXUzMiBtc3cgPSBzdyA+PiAxNjsJCS8qIGhpZ2ggMTYgYml0cyBvZiBzdyAqLwotCi0JLyogRklYTUUgV3JpdGUgTW9zdCBTaWduaWZpY2FudCBXb3JkIG9mIHRoZSAzMmJpdCBkYXRhIHRvIE1TVyAqLwotCS8qIEZJWE1FIEFuZCBMZWFzdCBTaWduaWZpY2FudCBXb3JkIHRvIExTVyAqLwotCWlvd3JpdGUzMigobHN3KSwgcmVnaW9uICsgQUdOWF9TUElfV0xTVyk7Ci0JaW93cml0ZTMyKChtc3cpLCByZWdpb24gKyBBR05YX1NQSV9XTVNXKTsKLQlyZWcgPSBjaGlwX2lkcyB8IHNpemUgfCBjb250cm9sOwotCS8qIFdyaXRlIGNoaXAgaWQocyksIHdyaXRlIHNpemUgYW5kIGJ1c3kgY29udHJvbCB0byBDb250cm9sIFJlZ2lzdGVyICovCi0JaW93cml0ZTMyKChyZWcpLCByZWdpb24gKyBBR05YX1NQSV9DVEwpOwotCS8qIFdhaXQgZm9yIEJ1c3kgY29udHJvbCB0byBjbGVhciAqLwotCXNwaV9kZWxheSgpOwotfQotCi0vKgotICogV3JpdGUgdG8gU1BJIFN5bnRoIHJlZ2lzdGVyCi0gKi8KLXN0YXRpYyBpbmxpbmUgdm9pZCBzcGlfc3lfd3JpdGUodm9pZCBfX2lvbWVtICpyZWdpb24sIHUzMiBjaGlwX2lkcywgdTMyIHN3KQotewotCS8qIEZJWE1FIHRoZSBzaXplIDB4MTUgaXMgYSBtYWdpYyB2YWx1ZSovCi0Jc3BpX3dyaXRlKHJlZ2lvbiwgY2hpcF9pZHMsIHN3LCAweDE1LCBTUElfQlVTWV9DVEwpOwotfQotCi0vKgotICogV3JpdGUgdG8gU1BJIFJGIHJlZ2lzdGVyCi0gKi8KLXN0YXRpYyBpbmxpbmUgdm9pZCBzcGlfcmZfd3JpdGUodm9pZCBfX2lvbWVtICpyZWdpb24sIHUzMiBjaGlwX2lkcywgdTMyIHN3KQotewotCS8qIEZJWE1FIHRoZSBzaXplIDB4ZCBpcyBhIG1hZ2ljIHZhbHVlKi8KLQlzcGlfd3JpdGUocmVnaW9uLCBjaGlwX2lkcywgc3csIDB4ZCwgU1BJX0JVU1lfQ1RMKTsKLX0gLyogc3BpX3JmX3dyaXRlICovCi0KLS8qCi0gKiBXcml0ZSB0byBTUEkgd2l0aCBSZWFkIENvbnRyb2wgYml0IHNldAotICovCi1pbmxpbmUgdm9pZCBzcGlfcmNfd3JpdGUodm9pZCBfX2lvbWVtICpyZWdpb24sIHUzMiBjaGlwX2lkcywgdTMyIHN3KQotewotCS8qIEZJWE1FIHRoZSBzaXplIDB4ZTUgaXMgYSBtYWdpYyB2YWx1ZSAqLwotCXNwaV93cml0ZShyZWdpb24sIGNoaXBfaWRzLCBzdywgMHhlNSwgU1BJX0JVU1lfQ1RMfFNQSV9SRUFEX0NUTCk7Ci19Ci0KLS8qIEdldCB0aGUgYWN0aXZlIGNoYWlucydzIGNvdW50ICovCi1zdGF0aWMgaW50IGdldF9hY3RpdmVfY2hhaW5zKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JaW50IG51bSA9IDA7Ci0JdTMyIHJlZzsKLQlBR05YX1RSQUNFOwotCi0Jc3BpX3JjX3dyaXRlKGN0bCwgUkZfQ0hJUDAsIDB4MjEpOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9TUElfUkxTVyk7Ci0JaWYgKHJlZyA9PSAxKQotCQludW0rKzsKLQotCXNwaV9yY193cml0ZShjdGwsIFJGX0NISVAxLCAweDIxKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX1JMU1cpOwotCWlmIChyZWcgPT0gMSkKLQkJbnVtKys7Ci0KLQlzcGlfcmNfd3JpdGUoY3RsLCBSRl9DSElQMiwgMHgyMSk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1NQSV9STFNXKTsKLQlpZiAocmVnID09IDEpCi0JCW51bSsrOwotCi0Jc3BpX3JjX3dyaXRlKGN0bCwgUkZfQ0hJUDAsIDB4MjYpOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9TUElfUkxTVyk7Ci0JaWYgKDB4MzMgIT0gcmVnKQotCQlwcmludGsoS0VSTl9XQVJOSU5HIFBGWCAiVW5tYXRjaGVkIHJmIGNoaXBzIHJlc3VsdFxuIik7Ci0KLQlyZXR1cm4gbnVtOwotfSAvKiBnZXRfYWN0aXZlX2NoYWlucyAqLwotCi12b2lkIHJmX2NoaXBzX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1MzIgcmVnOwotCWludCBudW07Ci0JQUdOWF9UUkFDRTsKLQotCWlmIChwcml2LT5yZXZpZCA9PSAxKSB7Ci0JCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9TWVNJVEZfR1BJT1VUKTsKLQkJcmVnIHw9IDB4ODsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfR1BJT1VULCByZWcpOwotCX0KLQotCS8qIFNldCBTUEkgY2xvY2sgc3BlZWQgdG8gMjAwTlMgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX0NGRyk7Ci0JcmVnICY9IH4weEY7Ci0JcmVnIHw9IDB4MzsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1NQSV9DRkcsIHJlZyk7Ci0KLQkvKiBTZXQgU1BJIGNsb2NrIHNwZWVkIHRvIDUwTlMgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX0NGRyk7Ci0JcmVnICY9IH4weEY7Ci0JcmVnIHw9IDB4MTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1NQSV9DRkcsIHJlZyk7Ci0KLQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMXxSRl9DSElQMiwgMHgxMTAxKTsKLQotCW51bSA9IGdldF9hY3RpdmVfY2hhaW5zKHByaXYpOwotCXByaW50ayhLRVJOX0lORk8gUEZYICJBY3RpdmUgY2hhaW5zIGFyZSAlZFxuIiwgbnVtKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9TUElfQ0ZHKTsKLQlyZWcgJj0gfjB4RjsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1NQSV9DRkcsIHJlZyk7Ci0KLQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMXxSRl9DSElQMiwgMHgxOTA4KTsKLX0gLyogcmZfY2hpcHNfaW5pdCAqLwotCi0KLXN0YXRpYyB1MzIgY2hhbm5lbF90YmxbMTVdWzldID0gewotCXswLCAgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMH0sCi0JezEsICAweDAwLCAweDAwLCAweDYyNCwgMHgwMCwgMHgxYTQsIDB4MjgsIDB4MDAsIDB4MWV9LAotCXsyLCAgMHgwMCwgMHgwMCwgMHg2MTUsIDB4MDAsIDB4MWFlLCAweDI4LCAweDAwLCAweDFlfSwKLQl7MywgIDB4MDAsIDB4MDAsIDB4NjFhLCAweDAwLCAweDFhZSwgMHgyOCwgMHgwMCwgMHgxZX0sCi0JezQsICAweDAwLCAweDAwLCAweDYxZiwgMHgwMCwgMHgxYWUsIDB4MjgsIDB4MDAsIDB4MWV9LAotCXs1LCAgMHgwMCwgMHgwMCwgMHg2MjQsIDB4MDAsIDB4MWFlLCAweDI4LCAweDAwLCAweDFlfSwKLQl7NiwgIDB4MDAsIDB4MDAsIDB4NjFmLCAweDAwLCAweDFiMywgMHgyOCwgMHgwMCwgMHgxZX0sCi0JezcsICAweDAwLCAweDAwLCAweDYyNCwgMHgwMCwgMHgxYjMsIDB4MjgsIDB4MDAsIDB4MWV9LAotCXs4LCAgMHgwMCwgMHgwMCwgMHg2MjksIDB4MDAsIDB4MWIzLCAweDI4LCAweDAwLCAweDFlfSwKLQl7OSwgIDB4MDAsIDB4MDAsIDB4NjI0LCAweDAwLCAweDFiOCwgMHgyOCwgMHgwMCwgMHgxZX0sCi0JezEwLCAweDAwLCAweDAwLCAweDYyOSwgMHgwMCwgMHgxYjgsIDB4MjgsIDB4MDAsIDB4MWV9LAotCXsxMSwgMHgwMCwgMHgwMCwgMHg2MmUsIDB4MDAsIDB4MWI4LCAweDI4LCAweDAwLCAweDFlfSwKLQl7MTIsIDB4MDAsIDB4MDAsIDB4NjMzLCAweDAwLCAweDFiOCwgMHgyOCwgMHgwMCwgMHgxZX0sCi0JezEzLCAweDAwLCAweDAwLCAweDYyOCwgMHgwMCwgMHgxYjgsIDB4MjgsIDB4MDAsIDB4MWV9LAotCXsxNCwgMHgwMCwgMHgwMCwgMHg2NDQsIDB4MDAsIDB4MWI4LCAweDI4LCAweDAwLCAweDFlfSwKLX07Ci0KLQotc3RhdGljIGlubGluZSB2b2lkCi1jaGFubmVsX3RibF93cml0ZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgY2hhbm5lbCwgdW5zaWduZWQgaW50IHJlZ19udW0pCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQotCXJlZyA9IGNoYW5uZWxfdGJsW2NoYW5uZWxdW3JlZ19udW1dOwotCXJlZyA8PD0gNDsKLQlyZWcgfD0gcmVnX251bTsKLQlzcGlfc3lfd3JpdGUoY3RsLCBTWU5USF9DSElQLCByZWcpOwotfQotCi1zdGF0aWMgdm9pZCBzeW50aF9mcmVxX3NldChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgY2hhbm5lbCkKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1MzIgcmVnOwotCUFHTlhfVFJBQ0U7Ci0KLQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgMHgxMjAxKTsKLQotCS8qIFNldCB0aGUgQ2xvY2sgYml0cyB0byA1ME5TICovCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1NQSV9DRkcpOwotCXJlZyAmPSB+MHhGOwotCXJlZyB8PSAweDE7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TUElfQ0ZHLCByZWcpOwotCi0JLyogV3JpdGUgMHgwMGMwIHRvIExTVyBhbmQgMHgzIHRvIE1TVyBvZiBTeW50aCBDaGlwICovCi0Jc3BpX3N5X3dyaXRlKGN0bCwgU1lOVEhfQ0hJUCwgMHgzMDBjMCk7Ci0KLQlzcGlfc3lfd3JpdGUoY3RsLCBTWU5USF9DSElQLCAweDMyKTsKLQotCS8qICMgV3JpdGUgdG8gUmVnaXN0ZXIgMSBvbiB0aGUgU3ludGggQ2hpcCAqLwotCWNoYW5uZWxfdGJsX3dyaXRlKHByaXYsIGNoYW5uZWwsIDEpOwotCS8qICMgV3JpdGUgdG8gUmVnaXN0ZXIgMyBvbiB0aGUgU3ludGggQ2hpcCAqLwotCWNoYW5uZWxfdGJsX3dyaXRlKHByaXYsIGNoYW5uZWwsIDMpOwotCS8qICMgV3JpdGUgdG8gUmVnaXN0ZXIgNiBvbiB0aGUgU3ludGggQ2hpcCAqLwotCWNoYW5uZWxfdGJsX3dyaXRlKHByaXYsIGNoYW5uZWwsIDYpOwotCS8qICMgV3JpdGUgdG8gUmVnaXN0ZXIgNSBvbiB0aGUgU3ludGggQ2hpcCAqLwotCWNoYW5uZWxfdGJsX3dyaXRlKHByaXYsIGNoYW5uZWwsIDUpOwotCS8qICMgV3JpdGUgdG8gcmVnaXN0ZXIgOCBvbiB0aGUgU3ludGggQ2hpcCAqLwotCWNoYW5uZWxfdGJsX3dyaXRlKHByaXYsIGNoYW5uZWwsIDgpOwotCi0JLyogRklYTUUgQ2xlYXIgdGhlIGNsb2NrIGJpdHMgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX0NGRyk7Ci0JcmVnICY9IH4weGY7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TUElfQ0ZHLCByZWcpOwotfSAvKiBzeW50aF9jaGlwX2luaXQgKi8KLQotCi1zdGF0aWMgdm9pZCBhbnRlbm5hX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgaW50IG51bV9hbnRlbm5hKQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCi0Jc3dpdGNoIChudW1fYW50ZW5uYSkgewotCWNhc2UgMToKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkxJU1RBTlQsIDEpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9OTUVBU0FOVCwgMSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX05BQ1RJQU5ULCAxKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkNBUFRBTlQsIDEpOwotCi0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0FOVENGRywgNyk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0JPQUNULCAzNCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0JPSU5BQ1QsIDM0KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQk9EWU5BLCAzMCk7Ci0KLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhEMEEsIDEyNSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBBTCwgMTAwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhEMEIsIDkwKTsKLQotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USEQwQlRGRVNULCA4MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1NJR0hUSCwgMTAwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfU0lHTFRILCAxNik7Ci0JCWJyZWFrOwotCWNhc2UgMjoKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkxJU1RBTlQsIDIpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9OTUVBU0FOVCwgMik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX05BQ1RJQU5ULCAyKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkNBUFRBTlQsIDIpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9BTlRDRkcsIDE1KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQk9BQ1QsIDM2KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQk9JTkFDVCwgMzYpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9CT0RZTkEsIDMyKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhEMEEsIDEyMCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBBTCwgMTAwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhEMEIsIDgwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfVEhEMEJURkVTVCwgNzApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9TSUdIVEgsIDEwMCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1NJR0xUSCwgMzIpOwotCQlicmVhazsKLQljYXNlIDM6Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX05MSVNUQU5ULCAzKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTk1FQVNBTlQsIDMpOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9OQUNUSUFOVCwgMyk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX05DQVBUQU5ULCAzKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQU5UQ0ZHLCAzMSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0JPQUNULCAzNik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0JPSU5BQ1QsIDM2KTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQk9EWU5BLCAzMik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBBLCAxMDApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USEQwQUwsIDEwMCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBCLCA3MCk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBCVEZFU1QsIDcwKTsKLQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfU0lHSFRILCAxMDApOwotCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9TSUdMVEgsIDQ4KTsKLS8qCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9TSUdMVEgsIDE2KTsgKi8KLQkJYnJlYWs7Ci0JZGVmYXVsdDoKLQkJcHJpbnRrKEtFUk5fV0FSTklORyBQRlggIlVua25vdyBhbnRlbm5hIG51bWJlclxuIik7Ci0JfQotfSAvKiBhbnRlbm5hX2luaXQgKi8KLQotc3RhdGljIHZvaWQgY2hhaW5fdXBkYXRlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHUzMiBjaGFpbikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1MzIgcmVnOwotCUFHTlhfVFJBQ0U7Ci0KLQlzcGlfcmNfd3JpdGUoY3RsLCBSRl9DSElQMCwgMHgyMCk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1NQSV9STFNXKTsKLQotCWlmIChyZWcgPT0gMHg0KQotCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgcmVnfDB4MTAwMCk7Ci0JZWxzZSBpZiAocmVnICE9IDB4MCkKLQkJc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDF8UkZfQ0hJUDIsIHJlZ3wweDEwMDApOwotCWVsc2UgewotCQlpZiAoY2hhaW4gPT0gMyB8fCBjaGFpbiA9PSA2KSB7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMXxSRl9DSElQMiwgcmVnfDB4MTAwMCk7Ci0JCQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SWE9WRVJJREUsIDB4MCk7Ci0JCX0gZWxzZSBpZiAoY2hhaW4gPT0gMiB8fCBjaGFpbiA9PSA0KSB7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgcmVnfDB4MTAwMCk7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMiwgMHgxMDA1KTsKLQkJCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1JYT1ZFUklERSwgMHg4MjQpOwotCQl9IGVsc2UgaWYgKGNoYWluID09IDEpIHsKLQkJCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwLCByZWd8MHgxMDAwKTsKLQkJCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAxfFJGX0NISVAyLCAweDEwMDQpOwotCQkJYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfUlhPVkVSSURFLCAweGMzNik7Ci0JCX0KLQl9Ci0KLQlzcGlfcmNfd3JpdGUoY3RsLCBSRl9DSElQMCwgMHgyMik7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1NQSV9STFNXKTsKLQotCXN3aXRjaCAocmVnKSB7Ci0JY2FzZSAwOgotCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMXxSRl9DSElQMiwgMHgxMDA1KTsKLQkJYnJlYWs7Ci0JY2FzZSAxOgotCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgMHgxMjAxKTsKLQkJYnJlYWs7Ci0JY2FzZSAyOgotCQlpZiAoY2hhaW4gPT0gNiB8fCBjaGFpbiA9PSA0KSB7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgMHgxMjAyKTsKLQkJCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAyLCAweDEwMDUpOwotCQl9IGVsc2UgaWYgKGNoYWluIDwgMykgewotCQkJc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDAsIDB4MTIwMik7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMXxSRl9DSElQMiwgMHgxMDA1KTsKLQkJfQotCQlicmVhazsKLQlkZWZhdWx0OgotCQlpZiAoY2hhaW4gPT0gMykgewotCQkJc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDEsIDB4MTIwMyk7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMiwgMHgxMjAxKTsKLQkJfSBlbHNlIGlmIChjaGFpbiA9PSAyKSB7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMCwgMHgxMjAzKTsKLQkJCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAyLCAweDEyMDApOwotCQkJc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDEsIDB4MTIwMSk7Ci0JCX0gZWxzZSBpZiAoY2hhaW4gPT0gMSkgewotCQkJc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDAsIDB4MTIwMyk7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMXxSRl9DSElQMiwgMHgxMjAwKTsKLQkJfSBlbHNlIGlmIChjaGFpbiA9PSA0KSB7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgMHgxMjAzKTsKLQkJCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAyLCAweDEyMDEpOwotCQl9IGVsc2UgewotCQkJc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDAsIDB4MTIwMyk7Ci0JCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMXxSRl9DSElQMiwgMHgxMjAxKTsKLQkJfQotCX0KLX0gLyogY2hhaW5fdXBkYXRlICovCi0KLXN0YXRpYyB2b2lkIGFudGVubmFfY29uZmlnKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQlBR05YX1RSQUNFOwotCi0JLyogV3JpdGUgMHgwIHRvIHRoZSBUWCBNYW5hZ2VtZW50IENvbnRyb2wgUmVnaXN0ZXIgRW5hYmxlIGJpdCAqLwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9UWE1fQ1RMKTsKLQlyZWcgJj0gfjB4MTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1RYTV9DVEwsIHJlZyk7Ci0KLQkvKiBGSVhNRSAqLwotCS8qIFNldCBpbml0aWFsIHZhbHVlIGJhc2VkIG9uIG51bWJlciBvZiBBbnRlbm5hZSAqLwotCWFudGVubmFfaW5pdChwcml2LCAzKTsKLQotCS8qIEZJWE1FIFVwZGF0ZSBQb3dlciBUZW1wbGF0ZXMgZm9yIGN1cnJlbnQgdmFsaWQgU3RhdGlvbnMgKi8KLQkvKiBzdGFfcG93ZXJfaW5pdChwcml2LCAwKTsqLwotCi0JLyogRklYTUUgdGhlIG51bWJlciBvZiBjaGFpbnMgc2hvdWxkIGdldCBmcm9tIGVlcHJvbSovCi0JY2hhaW5fdXBkYXRlKHByaXYsIEFHTlhfQ0hBSU5TX01BWCk7Ci19IC8qIGFudGVubmFfY29uZmlnICovCi0KLXZvaWQgY2FsaWJyYXRlX29zY2lsbGF0b3Ioc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1MzIgcmVnOwotCUFHTlhfVFJBQ0U7Ci0KLQlzcGlfcmNfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgMHgxMjAxKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVQxKTsKLQlyZWcgfD0gMHgxMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9HQUlOU0VUMSwgcmVnKTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVRXUklURSwgMSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfUlNUR0NUTCwgMSk7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9MRU4sIDB4M2ZmKTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQUNJX1RJTUVSMSwgMHgyNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfVElNRVIyLCAweDI3KTsKLQkvKiAoUmVzaWR1YWwgREMgQ2FsaWJyYXRpb24pIHRvIENhbGlicmF0aW9uIE1vZGUgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9NT0RFLCAweDIpOwotCi0Jc3BpX3JjX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDEsIDB4MTAwNCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfTEVOLCAweDNmZik7Ci0JLyogKFRYIExPIENhbGlicmF0aW9uKSB0byBDYWxpYnJhdGlvbiBNb2RlICovCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfTU9ERSwgMHg0KTsKLQotCWRvIHsKLQkJdTMyICByZWcxLCByZWcyLCByZWczOwotCQkvKiBFbmFibGUgUG93ZXIgU2F2aW5nIENvbnRyb2wgKi8KLQkJZW5hYmxlX3Bvd2VyX3NhdmluZyhwcml2KTsKLQkJLyogU2F2ZSB0aGUgZm9sbG93aW5nIHJlZ2lzdGVycyB0byByZXN0b3JlICovCi0JCXJlZzEgPSBpb3JlYWQzMihjdGwgKyAweDExMDAwKTsKLQkJcmVnMiA9IGlvcmVhZDMyKGN0bCArIDB4ZWM1MCk7Ci0JCXJlZzMgPSBpb3JlYWQzMihjdGwgKyAweGVjNTQpOwotCQl3bWIoKTsKLQotCQlhZ254X3dyaXRlMzIoY3RsLCAweDExMDAwLCAweGNmZGYpOwotCQlhZ254X3dyaXRlMzIoY3RsLCAweGVjNTAsIDB4NzApOwotCQkvKiBSZXN0b3JlIHRoZSByZWdpc3RlcnMgKi8KLQkJYWdueF93cml0ZTMyKGN0bCwgMHgxMTAwMCwgcmVnMSk7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4ZWM1MCwgcmVnMik7Ci0JCWFnbnhfd3JpdGUzMihjdGwsIDB4ZWM1NCwgcmVnMyk7Ci0JCS8qIERpc2FibGUgUG93ZXIgU2F2aW5nIENvbnRyb2wgKi8KLQkJZGlzYWJsZV9wb3dlcl9zYXZpbmcocHJpdik7Ci0JfSB3aGlsZSAoMCk7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SU1RHQ1RMLCAwKTsKLX0gLyogY2FsaWJyYXRlX29zY2lsbGF0b3IgKi8KLQotCi1zdGF0aWMgdm9pZCByYWRpb19jaGFubmVsX3NldChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgY2hhbm5lbCkKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1bnNpZ25lZCBpbnQgZnJlcSA9IHByaXYtPmJhbmQuY2hhbm5lbHNbY2hhbm5lbCAtIDFdLmNlbnRlcl9mcmVxOwotCXUzMiByZWc7Ci0JQUdOWF9UUkFDRTsKLQotCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxLCAweDEyMDEpOwotCS8qIFNldCBTUEkgQ2xvY2sgdG8gNTAgTnMgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX0NGRyk7Ci0JcmVnICY9IH4weEY7Ci0JcmVnIHw9IDB4MTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX1NQSV9DRkcsIHJlZyk7Ci0KLQkvKiBDbGVhciB0aGUgRGlzYWJsZSBUeCBpbnRlcnJ1cHQgYml0IGluIEludGVycnVwdCBNYXNrICovCi0vKiAJcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0lOVF9NQVNLKTsgKi8KLS8qIAlyZWcgJj0gfklSUV9UWF9ESVNBQkxFOyAqLwotLyogCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfSU5UX01BU0ssIHJlZyk7ICovCi0KLQkvKiBCYW5kIFNlbGVjdGlvbiAqLwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9TWVNJVEZfR1BJT1VUKTsKLQlyZWcgfD0gMHg4OwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfU1lTSVRGX0dQSU9VVCwgcmVnKTsKLQotCS8qIEZJWE1FIFNldCB0aGUgU2lMYWJzIENoaXAgRnJlcXVlbmN5ICovCi0Jc3ludGhfZnJlcV9zZXQocHJpdiwgY2hhbm5lbCk7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfUE1fU09GVFJTVCk7Ci0JcmVnIHw9IDB4ODAxMDAwMzA7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9TT0ZUUlNULCByZWcpOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9QTV9QTExDVEwpOwotCXJlZyB8PSAweDIwMDA5OwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUE1fUExMQ1RMLCByZWcpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfR1BJT1VULCAweDUpOwotCi0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDF8UkZfQ0hJUDIsIDB4MTEwMCk7Ci0KLQkvKiBMb2FkIHRoZSBNb25pdG9yR2FpbiBUYWJsZSAqLwotCW1vbml0b3JfZ2Fpbl90YWJsZV9pbml0KHByaXYpOwotCi0JLyogTG9hZCB0aGUgVFggRmlyIHRhYmxlICovCi0JdHhfZmlyX3RhYmxlX2luaXQocHJpdik7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfUE1fUE1DVEwpOwotCXJlZyB8PSAweDg7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9QTUNUTCwgcmVnKTsKLQotCXNwaV9yY193cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxLCAweDIyKTsKLQl1ZGVsYXkoODApOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9TUElfUkxTVyk7Ci0KLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1JYT1ZFUklERSwgMHhmZik7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRElTQ09WTU9ELCAweDMpOwotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCAweGVjNTApOwotCXJlZyB8PSAweDRmOwotCWFnbnhfd3JpdGUzMihjdGwsIDB4ZWM1MCwgcmVnKTsKLQotCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxLCAweDEyMDEpOwotCWFnbnhfd3JpdGUzMihjdGwsIDB4MTEwMDgsIDB4MSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgMHgxMTAwYywgMHgwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCAweDExMDA4LCAweDApOwotCWFnbnhfd3JpdGUzMihjdGwsIDB4ZWM1MCwgMHhjKTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RJU0NPVk1PRCwgMHgzKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SWE9WRVJJREUsIDB4MCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgMHgxMTAxMCwgMHg2ZSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgMHgxMTAxNCwgMHg2Yyk7Ci0KLQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMSwgMHgxMjAxKTsKLQotCS8qIENhbGlicmF0ZSB0aGUgQW50ZW5uYSAqLwotCS8qIGFudGVubmFfY2FsaWJyYXRlKHByaXYpOyAqLwotCS8qIENhbGlicmF0ZSB0aGUgVHhMb2NhbE9zY2lsbGF0b3IgKi8KLQljYWxpYnJhdGVfb3NjaWxsYXRvcihwcml2KTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9QTV9QTUNUTCk7Ci0JcmVnICY9IH4weDg7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9QTUNUTCwgcmVnKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9HQUlOSU5JVCwgMHhhKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USENELCAweDApOwotCi0JYWdueF93cml0ZTMyKGN0bCwgMHgxMTAxOCwgMHhiKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9ESVNDT1ZNT0QsIDB4MCk7Ci0KLQkvKiBXcml0ZSBGcmVxdWVuY3kgdG8gR2FpbiBDb250cm9sIENoYW5uZWwgKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SWENIQU5FTCwgZnJlcSk7Ci0JLyogV3JpdGUgMHgxNDAwMDAvRnJlcSB0byAweDljMDggKi8KLQlyZWcgPSAweDE0MDAwMC9mcmVxOwotCWFnbnhfd3JpdGUzMihjdGwsIDB4OWMwOCwgcmVnKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9QTV9TT0ZUUlNUKTsKLQlyZWcgJj0gfjB4ODAxMDAwMzA7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9TT0ZUUlNULCByZWcpOwotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1BNX1BMTENUTCk7Ci0JcmVnICY9IH4weDIwMDA5OwotCXJlZyB8PSAweDE7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9QTExDVEwsIHJlZyk7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9NT0RFLCAweDApOwotCi0vKiBGSVhNRSBBY2NvcmRpbmcgdG8gTnVtYmVyIG9mIENoYWluczogKi8KLQotLyogCQkJICAgMS4gMTogKi8KLS8qICAgICAgICAgIDEuIFdyaXRlIDB4MTIwMyB0byBSRiBDaGlwIDAgKi8KLS8qICAgICAgICAgIDIuIFdyaXRlIDB4MTIwMCB0byBSRiBDaGlwcyAxICsyICAqLwotLyogCQkJICAgMi4gMjogKi8KLS8qICAgICAgICAgIDEuIFdyaXRlIDB4MTIwMyB0byBSRiBDaGlwIDAgKi8KLS8qICAgICAgICAgIDIuIFdyaXRlIDB4MTIwMCB0byBSRiBDaGlwIDIgKi8KLS8qICAgICAgICAgIDMuIFdyaXRlIDB4MTIwMSB0byBSRiBDaGlwIDEgICovCi0vKiAJCQkgICAzLiAzOiAqLwotLyogICAgICAgICAgMS4gV3JpdGUgMHgxMjAzIHRvIFJGIENoaXAgMCAqLwotLyogICAgICAgICAgMi4gV3JpdGUgMHgxMjAxIHRvIFJGIENoaXAgMSArIDIgICovCi0vKiAJCQkgICA0LiA0OiAqLwotLyogICAgICAgICAgMS4gV3JpdGUgMHgxMjAzIHRvIFJGIENoaXAgMCArIDEgKi8KLS8qICAgICAgICAgIDIuIFdyaXRlIDB4MTIwMCB0byBSRiBDaGlwIDIgICovCi0KLS8qIAkJCSAgIDUuIDY6ICovCi0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDEsIDB4MTIwMyk7Ci0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDIsIDB4MTIwMSk7Ci0KLQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMXxSRl9DSElQMiwgMHgxMDAwKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SWE9WRVJJREUsIDB4MCk7Ci0KLQkvKiBGSVhNRSBTZXQgdGhlIERpc2FibGUgVHggaW50ZXJydXB0IGJpdCBpbiBJbnRlcnJ1cHQgTWFzawotCSAgIChPciAweDIwMDAwIHRvIEludGVycnVwdCBNYXNrKSAqLwotLyogCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9JTlRfTUFTSyk7ICovCi0vKiAJcmVnIHw9IElSUV9UWF9ESVNBQkxFOyAqLwotLyogCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfSU5UX01BU0ssIHJlZyk7ICovCi0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SU1RHQ1RMLCAweDEpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1JTVEdDVEwsIDB4MCk7Ci0KLQkvKiBDb25maWd1cmUgdGhlIEFudGVubmEgKi8KLQlhbnRlbm5hX2NvbmZpZyhwcml2KTsKLQotCS8qIFdyaXRlIDB4MCB0byBEaXNjb3ZlcnkgTW9kZSBFbmFibGUgZGV0ZWN0IEcsIEIsIEEgcGFja2V0PyAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0RJU0NPVk1PRCwgMCk7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfUlhNX1JFUVJBVEUpOwotCXJlZyB8PSAweDgwMDAwMDAwOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfUlhNX1JFUVJBVEUsIHJlZyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfUlNUR0NUTCwgMHgxKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SU1RHQ1RMLCAweDApOwotCi0JLyogZW5hYmxlIHJhZGlvIG9uIGFuZCB0aGUgcG93ZXIgTEVEICovCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1NZU0lURl9HUElPVVQpOwotCXJlZyAmPSB+MHgxOwotCXJlZyB8PSAweDI7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9TWVNJVEZfR1BJT1VULCByZWcpOwotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX1RYTV9DVEwpOwotCXJlZyB8PSAweDE7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9UWE1fQ1RMLCByZWcpOwotfSAvKiByYWRpb19jaGFubmVsX3NldCAqLwotCi1zdGF0aWMgdm9pZCBiYXNlX2JhbmRfZmlsdGVyX2NhbGlicmF0ZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCi0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDF8UkZfQ0hJUDIsIDB4MTcwMCk7Ci0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDF8UkZfQ0hJUDIsIDB4MTAwMSk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRk9SQ0VDVExDTEssIDB4MCk7Ci0Jc3BpX3JjX3dyaXRlKGN0bCwgUkZfQ0hJUDAsIDB4MjcpOwotCXNwaV9yY193cml0ZShjdGwsIFJGX0NISVAxLCAweDI3KTsKLQlzcGlfcmNfd3JpdGUoY3RsLCBSRl9DSElQMiwgMHgyNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRk9SQ0VDVExDTEssIDB4MSk7Ci19Ci0KLXN0YXRpYyB2b2lkIHByaW50X29mZnNldChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1MzIgY2hhaW4pCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIG9mZnNldDsKLQotCWlvd3JpdGUzMigoY2hhaW4pLCBjdGwgKyBBR05YX0FDSV9TRUxDSEFJTik7Ci0JdWRlbGF5KDEwKTsKLQlvZmZzZXQgPSAoaW9yZWFkMzIoY3RsICsgQUdOWF9BQ0lfT0ZGU0VUKSk7Ci0JcHJpbnRrKFBGWCAiQ2hhaW4gaXMgMHgleCwgT2Zmc2V0IGlzIDB4JXhcbiIsIGNoYWluLCBvZmZzZXQpOwotfQotCi12b2lkIHByaW50X29mZnNldHMoc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQlwcmludF9vZmZzZXQocHJpdiwgMCk7Ci0JcHJpbnRfb2Zmc2V0KHByaXYsIDQpOwotCXByaW50X29mZnNldChwcml2LCAxKTsKLQlwcmludF9vZmZzZXQocHJpdiwgNSk7Ci0JcHJpbnRfb2Zmc2V0KHByaXYsIDIpOwotCXByaW50X29mZnNldChwcml2LCA2KTsKLX0KLQotCi1zdHJ1Y3QgY2hhaW5zIHsKLQl1MzIgY2FsaTsJCS8qIGNhbGlicmF0ZSAgdmFsdWUqLwotCi0jZGVmaW5lICBORUVEX0NBTElCUkFURQkJMAotI2RlZmluZSAgU1VDQ0VTU19DQUxJQlJBVEUJMQotCWludCBzdGF0dXM7Ci19OwotCi1zdGF0aWMgdm9pZCBjaGFpbl9jYWxpYnJhdGUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgc3RydWN0IGNoYWlucyAqY2hhaW5zLAotCQkJICAgIHVuc2lnbmVkIGludCBudW0pCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIGNhbGlicmEgPSBjaGFpbnNbbnVtXS5jYWxpOwotCi0JaWYgKG51bSA8IDMpCi0JCWNhbGlicmEgfD0gMHgxNDAwOwotCWVsc2UKLQkJY2FsaWJyYSB8PSAweDE1MDA7Ci0KLQlzd2l0Y2ggKG51bSkgewotCWNhc2UgMDoKLQljYXNlIDQ6Ci0JCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwLCBjYWxpYnJhKTsKLQkJYnJlYWs7Ci0JY2FzZSAxOgotCWNhc2UgNToKLQkJc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDEsIGNhbGlicmEpOwotCQlicmVhazsKLQljYXNlIDI6Ci0JY2FzZSA2OgotCQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMiwgY2FsaWJyYSk7Ci0JCWJyZWFrOwotCWRlZmF1bHQ6Ci0JCUJVRygpOwotCX0KLX0gLyogY2hhaW5fY2FsaWJyYXRlICovCi0KLXN0YXRpYyBpbmxpbmUgdm9pZCBnZXRfY2FsaWJyZXRlX3ZhbHVlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHN0cnVjdCBjaGFpbnMgKmNoYWlucywKLQkJCQkgICAgICAgdW5zaWduZWQgaW50IG51bSkKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1MzIgb2Zmc2V0OwotCi0JaW93cml0ZTMyKChudW0pLCBjdGwgKyBBR05YX0FDSV9TRUxDSEFJTik7Ci0JLyogRklYTUUgKi8KLQl1ZGVsYXkoMTApOwotCW9mZnNldCA9IChpb3JlYWQzMihjdGwgKyBBR05YX0FDSV9PRkZTRVQpKTsKLQotCWlmIChvZmZzZXQgPCAweGYpIHsKLQkJY2hhaW5zW251bV0uc3RhdHVzID0gU1VDQ0VTU19DQUxJQlJBVEU7Ci0JCXJldHVybjsKLQl9Ci0KLQlpZiAobnVtID09IDAgfHwgbnVtID09IDEgfHwgbnVtID09IDIpIHsKLQkJaWYgKDAgPT0gY2hhaW5zW251bV0uY2FsaSkKLQkJCWNoYWluc1tudW1dLmNhbGkgPSAweGZmOwotCQllbHNlCi0JCQljaGFpbnNbbnVtXS5jYWxpLS07Ci0JfSBlbHNlCi0JCWNoYWluc1tudW1dLmNhbGkrKzsKLQotCWNoYWluc1tudW1dLnN0YXR1cyA9IE5FRURfQ0FMSUJSQVRFOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgY2FsaWJyYV9kZWxheShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXUzMiByZWc7Ci0JdW5zaWduZWQgaW50IGkgPSAxMDA7Ci0KLQl3bWIoKTsKLQl3aGlsZSAoLS1pKSB7Ci0JCXJlZyA9IChpb3JlYWQzMihjdGwgKyBBR05YX0FDSV9TVEFUVVMpKTsKLQkJaWYgKHJlZyA9PSAweDQwMDApCi0JCQlicmVhazsKLQkJdWRlbGF5KDEwKTsKLQl9Ci0JaWYgKCFpKQotCQlwcmludGsoUEZYICJjYWxpYnJhdGlvbiBmYWlsZWRcbiIpOwotfQotCi12b2lkIGRvX2NhbGlicmF0aW9uKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0Jc3RydWN0IGNoYWlucyBjaGFpbnNbN107Ci0JdW5zaWduZWQgaW50IGksIGo7Ci0JQUdOWF9UUkFDRTsKLQotCWZvciAoaSA9IDA7IGkgPCA3OyBpKyspIHsKLQkJaWYgKGkgPT0gMykKLQkJCWNvbnRpbnVlOwotCi0JCWNoYWluc1tpXS5jYWxpID0gMHg3ZjsKLQkJY2hhaW5zW2ldLnN0YXR1cyA9IE5FRURfQ0FMSUJSQVRFOwotCX0KLQotCS8qIEZJWE1FIDB4MzAwIGlzIGEgbWFnaWMgbnVtYmVyICovCi0JZm9yIChqID0gMDsgaiA8IDB4MzAwOyBqKyspIHsKLQkJaWYgKGNoYWluc1swXS5zdGF0dXMgPT0gU1VDQ0VTU19DQUxJQlJBVEUgJiYKLQkJICAgIGNoYWluc1sxXS5zdGF0dXMgPT0gU1VDQ0VTU19DQUxJQlJBVEUgJiYKLQkJICAgIGNoYWluc1syXS5zdGF0dXMgPT0gU1VDQ0VTU19DQUxJQlJBVEUgJiYKLQkJICAgIGNoYWluc1s0XS5zdGF0dXMgPT0gU1VDQ0VTU19DQUxJQlJBVEUgJiYKLQkJICAgIGNoYWluc1s1XS5zdGF0dXMgPT0gU1VDQ0VTU19DQUxJQlJBVEUgJiYKLQkJICAgIGNoYWluc1s2XS5zdGF0dXMgPT0gU1VDQ0VTU19DQUxJQlJBVEUpCi0JCQlicmVhazsKLQotCQkvKiBBdHRlbnRpb24sIHRoZXJlIGlzIG5vIGNoYWluIDMgKi8KLQkJZm9yIChpID0gMDsgaSA8IDc7IGkrKykgewotCQkJaWYgKGkgPT0gMykKLQkJCQljb250aW51ZTsKLQkJCWlmIChjaGFpbnNbaV0uc3RhdHVzID09IE5FRURfQ0FMSUJSQVRFKQotCQkJCWNoYWluX2NhbGlicmF0ZShwcml2LCBjaGFpbnMsIGkpOwotCQl9Ci0JCS8qIFdyaXRlIDB4MSB0byBDYWxpYnJhdGlvbiBNZWFzdXJlICovCi0JCWlvd3JpdGUzMigoMHgxKSwgY3RsICsgQUdOWF9BQ0lfTUVBU1VSRSk7Ci0JCWNhbGlicmFfZGVsYXkocHJpdik7Ci0KLQkJZm9yIChpID0gMDsgaSA8IDc7IGkrKykgewotCQkJaWYgKGkgPT0gMykKLQkJCQljb250aW51ZTsKLQotCQkJZ2V0X2NhbGlicmV0ZV92YWx1ZShwcml2LCBjaGFpbnMsIGkpOwotCQl9Ci0JfQotCXByaW50ayhQRlggIkNsaWJyYXRlIHRpbWVzIGlzICVkXG4iLCBqKTsKLQlwcmludF9vZmZzZXRzKHByaXYpOwotfSAvKiBkb19jYWxpYnJhdGlvbiAqLwotCi12b2lkIGFudGVubmFfY2FsaWJyYXRlKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQlBR05YX1RSQUNFOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkxJU1RBTlQsIDB4Myk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTk1FQVNBTlQsIDB4Myk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkFDVElBTlQsIDB4Myk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfTkNBUFRBTlQsIDB4Myk7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9BTlRDRkcsIDB4MWYpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0JPQUNULCAweDI0KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9CT0lOQUNULCAweDI0KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9CT0RZTkEsIDB4MjApOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBBLCAweDY0KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USEQwQUwsIDB4NjQpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1RIRDBCLCAweDQ2KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9USEQwQlRGRVNULCAweDNjKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9TSUdIVEgsIDB4NjQpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1NJR0xUSCwgMHgzMCk7Ci0KLQlzcGlfcmNfd3JpdGUoY3RsLCBSRl9DSElQMCwgMHgyMCk7Ci0JLyogRml4bWUgKi8KLQl1ZGVsYXkoODApOwotCS8qICAgIDEuIFNob3VsZCByZWFkIDB4MCAgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX1JMU1cpOwotCWlmICgweDAgIT0gcmVnKQotCQlwcmludGsoS0VSTl9XQVJOSU5HIFBGWCAiVW5tYXRjaGVkIHJmIGNoaXBzIHJlc3VsdFxuIik7Ci0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDF8UkZfQ0hJUDIsIDB4MTAwMCk7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SWE9WRVJJREUsIDB4MCk7Ci0KLQlzcGlfcmNfd3JpdGUoY3RsLCBSRl9DSElQMCwgMHgyMik7Ci0JdWRlbGF5KDgwKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfU1BJX1JMU1cpOwotCWlmICgweDAgIT0gcmVnKQotCQlwcmludGsoS0VSTl9XQVJOSU5HIFBGWCAiVW5tYXRjaGVkIHJmIGNoaXBzIHJlc3VsdFxuIik7Ci0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDF8UkZfQ0hJUDIsIDB4MTAwNSk7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SU1RHQ1RMLCAweDEpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX1JTVEdDVEwsIDB4MCk7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfUE1fU09GVFJTVCk7Ci0JcmVnIHw9IDB4MWMwMDAwMzI7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9TT0ZUUlNULCByZWcpOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9QTV9QTExDVEwpOwotCXJlZyB8PSAweDAwMDNmMDc7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9QTV9QTExDVEwsIHJlZyk7Ci0KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIDB4ZWM1MCk7Ci0JcmVnIHw9IDB4NDA7Ci0JYWdueF93cml0ZTMyKGN0bCwgMHhlYzUwLCByZWcpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfUlhPVkVSSURFLCAweGZmOCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfRElTQ09WTU9ELCAweDMpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfQ0hBSU5OVU0sIDB4Nik7Ci0JYWdueF93cml0ZTMyKGN0bCwgMHgxOTg3NCwgMHgwKTsKLQlzcGlfcmZfd3JpdGUoY3RsLCBSRl9DSElQMHxSRl9DSElQMXxSRl9DSElQMiwgMHgxNzAwKTsKLQotCS8qIENhbGlicmF0ZSB0aGUgQmFzZUJhbmRGaWx0ZXIgKi8KLQliYXNlX2JhbmRfZmlsdGVyX2NhbGlicmF0ZShwcml2KTsKLQotCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxfFJGX0NISVAyLCAweDEwMDIpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVDAsIDB4MWQpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVQxLCAweDFkKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9HQUlOU0VUMiwgMHgxZCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVFdSSVRFLCAweDEpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfTU9ERSwgMHgxKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9MRU4sIDB4M2ZmKTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQUNJX1RJTUVSMSwgMHgyNyk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfVElNRVIyLCAweDI3KTsKLQotCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxfFJGX0NISVAyLCAweDE0MDApOwotCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxfFJGX0NISVAyLCAweDE1MDApOwotCi0JLyogTWVhc3VyZSBDYWxpYnJhdGlvbiAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQUNJX01FQVNVUkUsIDB4MSk7Ci0JY2FsaWJyYV9kZWxheShwcml2KTsKLQotCS8qIGRvIGNhbGlicmF0aW9uICovCi0JZG9fY2FsaWJyYXRpb24ocHJpdik7Ci0KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9SWE9WRVJJREUsIDB4MCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfVElNRVIxLCAweDIxKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9USU1FUjIsIDB4MjcpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQUNJX0xFTiwgMHhmKTsKLQotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVDApOwotCXJlZyAmPSAweGY7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVDAsIHJlZyk7Ci0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0dDUl9HQUlOU0VUMSk7Ci0JcmVnICY9IDB4ZjsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9HQUlOU0VUMSwgcmVnKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVQyKTsKLQlyZWcgJj0gMHhmOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVQyLCByZWcpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVFdSSVRFLCAweDApOwotCWRpc2FibGVfcmVjZWl2ZXIocHJpdik7Ci19IC8qIGFudGVubmFfY2FsaWJyYXRlICovCi0KLXZvaWQgX19hbnRlbm5hX2NhbGlicmF0ZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXUzMiByZWc7Ci0KLQkvKiBDYWxpYnJhdGUgdGhlIEJhc2VCYW5kRmlsdGVyICovCi0JLyogYmFzZV9iYW5kX2ZpbHRlcl9jYWxpYnJhdGUocHJpdik7ICovCi0Jc3BpX3JmX3dyaXRlKGN0bCwgUkZfQ0hJUDB8UkZfQ0hJUDF8UkZfQ0hJUDIsIDB4MTAwMik7Ci0KLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVQwLCAweDFkKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9HQUlOU0VUMSwgMHgxZCk7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVDIsIDB4MWQpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVFdSSVRFLCAweDEpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfTU9ERSwgMHgxKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9MRU4sIDB4M2ZmKTsKLQotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfVElNRVIxLCAweDI3KTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9USU1FUjIsIDB4MjcpOwotCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxfFJGX0NISVAyLCAweDE0MDApOwotCXNwaV9yZl93cml0ZShjdGwsIFJGX0NISVAwfFJGX0NISVAxfFJGX0NISVAyLCAweDE1MDApOwotCS8qIE1lYXN1cmUgQ2FsaWJyYXRpb24gKi8KLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9NRUFTVVJFLCAweDEpOwotCWNhbGlicmFfZGVsYXkocHJpdik7Ci0JZG9fY2FsaWJyYXRpb24ocHJpdik7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfUlhPVkVSSURFLCAweDApOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfVElNRVIxLCAweDIxKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0FDSV9USU1FUjIsIDB4MjcpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9BQ0lfTEVOLCAweGYpOwotCi0JcmVnID0gYWdueF9yZWFkMzIoY3RsLCBBR05YX0dDUl9HQUlOU0VUMCk7Ci0JcmVnICY9IDB4ZjsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0dDUl9HQUlOU0VUMCwgcmVnKTsKLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVQxKTsKLQlyZWcgJj0gMHhmOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVQxLCByZWcpOwotCXJlZyA9IGFnbnhfcmVhZDMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVDIpOwotCXJlZyAmPSAweGY7Ci0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9HQ1JfR0FJTlNFVDIsIHJlZyk7Ci0KLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfR0NSX0dBSU5TRVRXUklURSwgMHgwKTsKLQotCS8qIFdyaXRlIDB4MyBHYWluIENvbnRyb2wgRGlzY292ZXJ5IE1vZGUgKi8KLQllbmFibGVfcmVjZWl2ZXIocHJpdik7Ci19Ci0KLWludCBhZ254X3NldF9jaGFubmVsKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHVuc2lnbmVkIGludCBjaGFubmVsKQotewotCUFHTlhfVFJBQ0U7Ci0KLQlwcmludGsoS0VSTl9FUlIgUEZYICJDaGFubmVsIGlzICVkICVzXG4iLCBjaGFubmVsLCBfX2Z1bmNfXyk7Ci0JcmFkaW9fY2hhbm5lbF9zZXQocHJpdiwgY2hhbm5lbCk7Ci0JcmV0dXJuIDA7Ci19CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvYWdueC9zdGEuYyBiL2RyaXZlcnMvc3RhZ2luZy9hZ254L3N0YS5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAzZTdkYjVlLi4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3N0YS5jCisrKyAvZGV2L251bGwKQEAgLTEsMjE4ICswLDAgQEAKLSNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgotI2luY2x1ZGUgPGxpbnV4L2V0aGVyZGV2aWNlLmg+Ci0jaW5jbHVkZSAicGh5LmgiCi0jaW5jbHVkZSAic3RhLmgiCi0jaW5jbHVkZSAiZGVidWcuaCIKLQotdm9pZCBoYXNoX3JlYWQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdTMyIHJlZ2hpLCB1MzIgcmVnbG8sIHU4IHN0YV9pZCkKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQotCXJlZ2xvICY9IDB4RkZGRjsKLQlyZWdsbyB8PSAweDMwMDAwMDAwOwotCXJlZ2xvIHw9IDB4NDAwMDAwMDA7CS8qIFNldCBzdGF0dXMgYnVzeSAqLwotCXJlZ2xvIHw9IHN0YV9pZCA8PCAxNjsKLQotCWlvd3JpdGUzMigwLCBjdGwgKyBBR05YX1JYTV9IQVNIX0NNRF9GTEFHKTsKLQlpb3dyaXRlMzIocmVnaGksIGN0bCArIEFHTlhfUlhNX0hBU0hfQ01EX0hJR0gpOwotCWlvd3JpdGUzMihyZWdsbywgY3RsICsgQUdOWF9SWE1fSEFTSF9DTURfTE9XKTsKLQotCXJlZ2hpID0gaW9yZWFkMzIoY3RsICsgQUdOWF9SWE1fSEFTSF9DTURfSElHSCk7Ci0JcmVnbG8gPSBpb3JlYWQzMihjdGwgKyBBR05YX1JYTV9IQVNIX0NNRF9MT1cpOwotCXByaW50ayhQRlggIlJYIGhhc2ggY21kIGFyZSA6ICUuOHglLjh4XG4iLCByZWdoaSwgcmVnbG8pOwotfQotCi12b2lkIGhhc2hfd3JpdGUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgY29uc3QgdTggKm1hY19hZGRyLCB1OCBzdGFfaWQpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZ2hpLCByZWdsbzsKLQotCWlmICghaXNfdmFsaWRfZXRoZXJfYWRkcihtYWNfYWRkcikpCi0JCXByaW50ayhLRVJOX1dBUk5JTkcgUEZYICJVcGRhdGUgaGFzaCB0YWJsZTogSW52YWxpZCBod2FkZHIhXG4iKTsKLQotCXJlZ2hpID0gbWFjX2FkZHJbMF0gPDwgMjQgfCBtYWNfYWRkclsxXSA8PCAxNiB8IG1hY19hZGRyWzJdIDw8IDggfCBtYWNfYWRkclszXTsKLQlyZWdsbyA9IG1hY19hZGRyWzRdIDw8IDggfCBtYWNfYWRkcls1XTsKLQlyZWdsbyB8PSAweDEwMDAwMDAwOwkvKiBTZXQgaGFzaCBjb21tbWFuZCAqLwotCXJlZ2xvIHw9IDB4NDAwMDAwMDA7CS8qIFNldCBzdGF0dXMgYnVzeSAqLwotCXJlZ2xvIHw9IHN0YV9pZCA8PCAxNjsKLQotCWlvd3JpdGUzMigwLCBjdGwgKyBBR05YX1JYTV9IQVNIX0NNRF9GTEFHKTsKLQlpb3dyaXRlMzIocmVnaGksIGN0bCArIEFHTlhfUlhNX0hBU0hfQ01EX0hJR0gpOwotCWlvd3JpdGUzMihyZWdsbywgY3RsICsgQUdOWF9SWE1fSEFTSF9DTURfTE9XKTsKLQotCXJlZ2xvID0gaW9yZWFkMzIoY3RsICsgQUdOWF9SWE1fSEFTSF9DTURfTE9XKTsKLQlpZiAoIShyZWdsbyAmIDB4ODAwMDAwMDApKQotCQlwcmludGsoS0VSTl9XQVJOSU5HIFBGWCAiVXBkYXRlIGhhc2ggdGFibGUgZmFpbGVkXG4iKTsKLX0KLQotdm9pZCBoYXNoX2RlbGV0ZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1MzIgcmVnaGksIHUzMiByZWdsbywgdTggc3RhX2lkKQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCi0JcmVnbG8gJj0gMHhGRkZGOwotCXJlZ2xvIHw9IDB4MjAwMDAwMDA7Ci0JcmVnbG8gfD0gMHg0MDAwMDAwMDsJLyogU2V0IHN0YXR1cyBidXN5ICovCi0JcmVnbG8gfD0gc3RhX2lkIDw8IDE2OwotCi0JaW93cml0ZTMyKDAsIGN0bCArIEFHTlhfUlhNX0hBU0hfQ01EX0ZMQUcpOwotCWlvd3JpdGUzMihyZWdoaSwgY3RsICsgQUdOWF9SWE1fSEFTSF9DTURfSElHSCk7Ci0JaW93cml0ZTMyKHJlZ2xvLCBjdGwgKyBBR05YX1JYTV9IQVNIX0NNRF9MT1cpOwotCXJlZ2hpID0gaW9yZWFkMzIoY3RsICsgQUdOWF9SWE1fSEFTSF9DTURfSElHSCk7Ci0KLQlyZWdsbyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfUlhNX0hBU0hfQ01EX0xPVyk7Ci0JcHJpbnRrKFBGWCAiUlggaGFzaCBjbWQgYXJlIDogJS44eCUuOHhcbiIsIHJlZ2hpLCByZWdsbyk7Ci0KLX0KLQotdm9pZCBoYXNoX2R1bXAoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdTggc3RhX2lkKQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXUzMiByZWdoaSwgcmVnbG87Ci0KLQlyZWdsbyA9IDB4NDAwMDAwMDA7ICAJLyogc3RhdHVzIGJpdCAqLwotCWlvd3JpdGUzMihyZWdsbywgY3RsICsgQUdOWF9SWE1fSEFTSF9DTURfTE9XKTsKLQlpb3dyaXRlMzIoc3RhX2lkIDw8IDE2LCBjdGwgKyBBR05YX1JYTV9IQVNIX0RVTVBfREFUQSk7Ci0KLQl1ZGVsYXkoODApOwotCi0JcmVnaGkgPSBpb3JlYWQzMihjdGwgKyBBR05YX1JYTV9IQVNIX0NNRF9ISUdIKTsKLQlyZWdsbyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfUlhNX0hBU0hfQ01EX0xPVyk7Ci0JcHJpbnRrKFBGWCAiaGFzaCBjbWQgYXJlIDogJS44eCUuOHhcbiIsIHJlZ2hpLCByZWdsbyk7Ci0JcmVnaGkgPSBpb3JlYWQzMihjdGwgKyBBR05YX1JYTV9IQVNIX0NNRF9GTEFHKTsKLQlwcmludGsoUEZYICJoYXNoIGZsYWcgaXMgOiAlLjh4XG4iLCByZWdoaSk7Ci0JcmVnaGkgPSBpb3JlYWQzMihjdGwgKyBBR05YX1JYTV9IQVNIX0RVTVBfTVNUKTsKLQlyZWdsbyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfUlhNX0hBU0hfRFVNUF9MU1QpOwotCXByaW50ayhQRlggImhhc2ggZHVtcCBtc3QgbHN0OiAlLjh4JS44eFxuIiwgcmVnaGksIHJlZ2xvKTsKLQlyZWdoaSA9IGlvcmVhZDMyKGN0bCArIEFHTlhfUlhNX0hBU0hfRFVNUF9EQVRBKTsKLQlwcmludGsoUEZYICJoYXNoIGR1bXAgZGF0YTogJS44eFxuIiwgcmVnaGkpOwotfQotCi12b2lkIGdldF9zdGFfcG93ZXIoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgc3RydWN0IGFnbnhfc3RhX3Bvd2VyICpwb3dlciwgdW5zaWduZWQgaW50IHN0YV9pZHgpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JbWVtY3B5X2Zyb21pbyhwb3dlciwgY3RsICsgQUdOWF9UWE1fU1RBUE9XVEVNUCArIHNpemVvZigqcG93ZXIpICogc3RhX2lkeCwKLQkJICAgICAgc2l6ZW9mKCpwb3dlcikpOwotfQotCi1pbmxpbmUgdm9pZAotc2V0X3N0YV9wb3dlcihzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3QgYWdueF9zdGFfcG93ZXIgKnBvd2VyLCB1bnNpZ25lZCBpbnQgc3RhX2lkeCkKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQkvKiBGSVhNRSAgIDIuIFdyaXRlIFRlbXBsYXRlIHRvIG9mZnNldCArIHN0YXRpb24gbnVtYmVyICAqLwotCW1lbWNweV90b2lvKGN0bCArIEFHTlhfVFhNX1NUQVBPV1RFTVAgKyBzaXplb2YoKnBvd2VyKSAqIHN0YV9pZHgsCi0JCSAgICBwb3dlciwgc2l6ZW9mKCpwb3dlcikpOwotfQotCi0KLXZvaWQgZ2V0X3N0YV90eF93cShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3QgYWdueF9zdGFfdHhfd3EgKnR4X3dxLAotCQkgICB1bnNpZ25lZCBpbnQgc3RhX2lkeCwgdW5zaWduZWQgaW50IHdxX2lkeCkKLXsKLQl2b2lkIF9faW9tZW0gKmRhdGEgPSBwcml2LT5kYXRhOwotCW1lbWNweV9mcm9taW8odHhfd3EsIGRhdGEgKyBBR05YX1BEVV9UWF9XUSArIHNpemVvZigqdHhfd3EpICogU1RBX1RYX1dRX05VTSAqIHN0YV9pZHggKwotCQkgICAgICBzaXplb2YoKnR4X3dxKSAqIHdxX2lkeCwgIHNpemVvZigqdHhfd3EpKTsKLQotfQotCi1pbmxpbmUgdm9pZCBzZXRfc3RhX3R4X3dxKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHN0cnVjdCBhZ254X3N0YV90eF93cSAqdHhfd3EsCi0JCSAgIHVuc2lnbmVkIGludCBzdGFfaWR4LCB1bnNpZ25lZCBpbnQgd3FfaWR4KQotewotCXZvaWQgX19pb21lbSAqZGF0YSA9IHByaXYtPmRhdGE7Ci0JbWVtY3B5X3RvaW8oZGF0YSArIEFHTlhfUERVX1RYX1dRICsgc2l6ZW9mKCp0eF93cSkgKiBTVEFfVFhfV1FfTlVNICogc3RhX2lkeCArCi0JCSAgICBzaXplb2YoKnR4X3dxKSAqIHdxX2lkeCwgdHhfd3EsIHNpemVvZigqdHhfd3EpKTsKLX0KLQotCi12b2lkIGdldF9zdGEoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgc3RydWN0IGFnbnhfc3RhICpzdGEsIHVuc2lnbmVkIGludCBzdGFfaWR4KQotewotCXZvaWQgX19pb21lbSAqZGF0YSA9IHByaXYtPmRhdGE7Ci0KLQltZW1jcHlfZnJvbWlvKHN0YSwgZGF0YSArIEFHTlhfUERVUE9PTCArIHNpemVvZigqc3RhKSAqIHN0YV9pZHgsCi0JCSAgICAgIHNpemVvZigqc3RhKSk7Ci19Ci0KLWlubGluZSB2b2lkIHNldF9zdGEoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgc3RydWN0IGFnbnhfc3RhICpzdGEsIHVuc2lnbmVkIGludCBzdGFfaWR4KQotewotCXZvaWQgX19pb21lbSAqZGF0YSA9IHByaXYtPmRhdGE7Ci0KLQltZW1jcHlfdG9pbyhkYXRhICsgQUdOWF9QRFVQT09MICsgc2l6ZW9mKCpzdGEpICogc3RhX2lkeCwKLQkJICAgIHN0YSwgc2l6ZW9mKCpzdGEpKTsKLX0KLQotLyogRklYTUUgKi8KLXZvaWQgc3RhX3Bvd2VyX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdW5zaWduZWQgaW50IHN0YV9pZHgpCi17Ci0Jc3RydWN0IGFnbnhfc3RhX3Bvd2VyIHBvd2VyOwotCXUzMiByZWc7Ci0JQUdOWF9UUkFDRTsKLQotCW1lbXNldCgmcG93ZXIsIDAsIHNpemVvZihwb3dlcikpOwotCXJlZyA9IGFnbnhfc2V0X2JpdHMoRURDRiwgRURDRl9TSElGVCwgMHgxKTsKLQlwb3dlci5yZWcgPSBjcHVfdG9fbGUzMihyZWcpOwotCXNldF9zdGFfcG93ZXIocHJpdiwgJnBvd2VyLCBzdGFfaWR4KTsKLQl1ZGVsYXkoNDApOwotfSAvKiBhZGRfcG93ZXJfdGVtcGxhdGUgKi8KLQotCi0vKiBAbnVtOiBUaGUgI251bWJlciBvZiBzdGF0aW9uIHRoYXQgaXMgdmlzaWJsZSB0byB0aGUgY2FyZCAqLwotc3RhdGljIHZvaWQgc3RhX3R4X3dvcmtxdWV1ZV9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHVuc2lnbmVkIGludCBzdGFfaWR4KQotewotCXN0cnVjdCBhZ254X3N0YV90eF93cSB0eF93cTsKLQl1MzIgcmVnOwotCXVuc2lnbmVkIGludCBpOwotCi0JbWVtc2V0KCZ0eF93cSwgMCwgc2l6ZW9mKHR4X3dxKSk7Ci0KLQlyZWcgPSBhZ254X3NldF9iaXRzKFdPUktfUVVFVUVfVkFMSUQsIFdPUktfUVVFVUVfVkFMSURfU0hJRlQsIDEpOwotCXJlZyB8PSBhZ254X3NldF9iaXRzKFdPUktfUVVFVUVfQUNLX1RZUEUsIFdPUktfUVVFVUVfQUNLX1RZUEVfU0hJRlQsIDEpOwotLyoJcmVnIHw9IGFnbnhfc2V0X2JpdHMoV09SS19RVUVVRV9BQ0tfVFlQRSwgV09SS19RVUVVRV9BQ0tfVFlQRV9TSElGVCwgMCk7ICovCi0JdHhfd3EucmVnMiB8PSBjcHVfdG9fbGUzMihyZWcpOwotCi0JLyogU3VwcG9zZSBhbGwgOCB0cmFmZmljIGNsYXNzIGFyZSB1c2VkICovCi0JZm9yIChpID0gMDsgaSA8IFNUQV9UWF9XUV9OVU07IGkrKykKLQkJc2V0X3N0YV90eF93cShwcml2LCAmdHhfd3EsIHN0YV9pZHgsIGkpOwotfSAvKiBzdGFfdHhfd29ya3F1ZXVlX2luaXQgKi8KLQotCi1zdGF0aWMgdm9pZCBzdGFfdHJhZmZpY19pbml0KHN0cnVjdCBhZ254X3N0YV90cmFmZmljICp0cmFmZmljKQotewotCXUzMiByZWc7Ci0JbWVtc2V0KHRyYWZmaWMsIDAsIHNpemVvZigqdHJhZmZpYykpOwotCi0JcmVnID0gYWdueF9zZXRfYml0cyhORVdfUEFDS0VULCBORVdfUEFDS0VUX1NISUZULCAxKTsKLQlyZWcgfD0gYWdueF9zZXRfYml0cyhUUkFGRklDX1ZBTElELCBUUkFGRklDX1ZBTElEX1NISUZULCAxKTsKLS8qCXJlZyB8PSBhZ254X3NldF9iaXRzKFRSQUZGSUNfQUNLX1RZUEUsIFRSQUZGSUNfQUNLX1RZUEVfU0hJRlQsIDEpOyAqLwotCXRyYWZmaWMtPnJlZzAgPSBjcHVfdG9fbGUzMihyZWcpOwotCi0JLyogCTMuIHNldHRpbmcgUlggU2VxdWVuY2UgTnVtYmVyIHRvIDQwOTUgKi8KLQlyZWcgPSBhZ254X3NldF9iaXRzKFJYX1NFUVVFTkNFX05VTSwgUlhfU0VRVUVOQ0VfTlVNX1NISUZULCA0MDk1KTsKLQl0cmFmZmljLT5yZWcxID0gY3B1X3RvX2xlMzIocmVnKTsKLX0KLQotCi0vKiBAbnVtOiBUaGUgI251bWJlciBvZiBzdGF0aW9uIHRoYXQgaXMgdmlzaWJsZSB0byB0aGUgY2FyZCAqLwotdm9pZCBzdGFfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgc3RhX2lkeCkKLXsKLQkvKiBGSVhNRSB0aGUgbGVuZ3RoIG9mIHN0YSBpcyAyNTYgYnl0ZXMgSXMgdGhhdAotCSAqIGRhbmdlcm91cyB0byBzdGFjayBvdmVyZmxvdz8gKi8KLQlzdHJ1Y3QgYWdueF9zdGEgc3RhOwotCXUzMiByZWc7Ci0JaW50IGk7Ci0KLQltZW1zZXQoJnN0YSwgMCwgc2l6ZW9mKHN0YSkpOwotCS8qIFNldCB2YWxpZCB0byAxICovCi0JcmVnID0gYWdueF9zZXRfYml0cyhTVEFUSU9OX1ZBTElELCBTVEFUSU9OX1ZBTElEX1NISUZULCAxKTsKLQkvKiBTZXQgRW5hYmxlIENvbmNhdGVuYXRpb24gdG8gMCAoPykgKi8KLQlyZWcgfD0gYWdueF9zZXRfYml0cyhFTkFCTEVfQ09OQ0FURU5BVElPTiwgRU5BQkxFX0NPTkNBVEVOQVRJT05fU0hJRlQsIDApOwotCS8qIFNldCBFbmFibGUgRGVjb21wcmVzc2lvbiB0byAwICg/KSAqLwotCXJlZyB8PSBhZ254X3NldF9iaXRzKEVOQUJMRV9ERUNPTVBSRVNTSU9OLCBFTkFCTEVfREVDT01QUkVTU0lPTl9TSElGVCwgMCk7Ci0Jc3RhLnJlZyA9IGNwdV90b19sZTMyKHJlZyk7Ci0KLQkvKiBJbml0aWFsaXplIGVhY2ggb2YgdGhlIFRyYWZmaWMgQ2xhc3MgU3RydWN0dXJlcyBieTogKi8KLQlmb3IgKGkgPSAwOyBpIDwgODsgaSsrKQotCQlzdGFfdHJhZmZpY19pbml0KHN0YS50cmFmZmljICsgaSk7Ci0KLQlzZXRfc3RhKHByaXYsICZzdGEsIHN0YV9pZHgpOwotCXN0YV90eF93b3JrcXVldWVfaW5pdChwcml2LCBzdGFfaWR4KTsKLX0gLyogc3RhX2Rlc2NyaXB0b3JfaW5pdCAqLwotCi0KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3N0YS5oIGIvZHJpdmVycy9zdGFnaW5nL2Fnbngvc3RhLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGZkNTA0ZTMuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2Fnbngvc3RhLmgKKysrIC9kZXYvbnVsbApAQCAtMSwyMjIgKzAsMCBAQAotI2lmbmRlZiBBR05YX1NUQV9IXwotI2RlZmluZSBBR05YX1NUQV9IXwotCi0jZGVmaW5lIFNUQV9UWF9XUV9OVU0JOAkvKiBUaGUgbnVtYmVyIG9mIFRYIHdvcmtxdWV1ZSBvbmUgU1RBIGhhcyAqLwotCi1zdHJ1Y3QgYWdueF9oYXNoX2NtZCB7Ci0JX19iZTMyIGNtZGhpOwotI2RlZmluZSBNQUNMTwkJMHhGRkZGMDAwMAotI2RlZmluZSBNQUNMT19TSElGVAkxNgotI2RlZmluZSBTVEFfSUQJCTB4MDAwMEZGRjAKLSNkZWZpbmUgU1RBX0lEX1NISUZUCTQKLSNkZWZpbmUgQ01ECQkweDAwMDAwMDBDCi0jZGVmaW5lIENNRF9TSElGVAkyCi0jZGVmaW5lIFNUQVRVUwkJMHgwMDAwMDAwMgotI2RlZmluZSBTVEFUVVNfU0hJRlQJMQotI2RlZmluZSBQQVNTCQkweDAwMDAwMDAxCi0jZGVmaW5lIFBBU1NfU0hJRlQJMQotCV9fYmUzMiBjbWRsbzsKLX0gX19hdHRyaWJ1dGVfXygoX19wYWNrZWRfXykpOwotCi0KLS8qCi0gKiBTdGF0aW9uIFBvd2VyIFRlbXBsYXRlCi0gKiBGSVhNRSBKdXN0IGZvciBhZ24xMDAgeWV0Ci0gKi8KLXN0cnVjdCBhZ254X3N0YV9wb3dlciB7Ci0JX19sZTMyIHJlZzsKLSNkZWZpbmUgU0lHTkFMCQkJMHgwMDAwMDBGRiAvKiBzaWduYWwgKi8KLSNkZWZpbmUgU0lHTkFMX1NISUZUCQkwCi0jZGVmaW5lIFJBVEUJCQkweDAwMDAwRjAwCi0jZGVmaW5lIFJBVEVfU0hJRlQJCTgKLSNkZWZpbmUgVElGUwkJCTB4MDAwMDEwMDAKLSNkZWZpbmUgVElGU19TSElGVAkJMTIKLSNkZWZpbmUgRURDRgkJCTB4MDAwMDIwMDAKLSNkZWZpbmUgRURDRl9TSElGVAkJMTMKLSNkZWZpbmUgQ0hBTk5FTF9CT05ECQkweDAwMDA0MDAwCi0jZGVmaW5lIENIQU5ORUxfQk9ORF9TSElGVAkxNAotI2RlZmluZSBQSFlfTU9ERQkJMHgwMDAzODAwMAotI2RlZmluZSBQSFlfTU9ERV9TSElGVAkJMTUKLSNkZWZpbmUgUE9XRVJfTEVWRUwJCTB4MDA3QzAwMDAKLSNkZWZpbmUgUE9XRVJfTEVWRUxfU0hJRlQJMTgKLSNkZWZpbmUgTlVNX1RSQU5TTUlUVEVSUwkweDAwODAwMDAwCi0jZGVmaW5lIE5VTV9UUkFOU01JVFRFUlNfU0hJRlQJMjMKLX0gX19hdHRyaWJ1dGVfXygoX19wYWNrZWRfXykpOwotCi0vKgotICogVFggV29ya3F1ZXVlIERlc2NyaXB0b3IKLSAqLwotc3RydWN0IGFnbnhfc3RhX3R4X3dxIHsKLQlfX2xlMzIgcmVnMDsKLSNkZWZpbmUgSEVBRF9QT0lOVEVSX0xPVwkweEZGMDAwMDAwIC8qIEhlYWQgcG9pbnRlciBsb3cgKi8KLSNkZWZpbmUgSEVBRF9QT0lOVEVSX0xPV19TSElGVAkyNAotI2RlZmluZSBUQUlMX1BPSU5URVIJCTB4MDBGRkZGRkYgLyogVGFpbCBwb2ludGVyICovCi0jZGVmaW5lIFRBSUxfUE9JTlRFUl9TSElGVAkwCi0KLQlfX2xlMzIgcmVnMzsKLSNkZWZpbmUgQUNLX1BPSU5URVJfTE9XCSAgICAgICAgMHhGRkZGMDAwMAkvKiBBQ0sgcG9pbnRlciBsb3cgKi8KLSNkZWZpbmUgQUNLX1BPSU5URVJfTE9XX1NISUZUCTE2Ci0jZGVmaW5lIEhFQURfUE9JTlRFUl9ISUdICTB4MDAwMEZGRkYJLyogSGVhZCBwb2ludGVyIGhpZ2ggKi8KLSNkZWZpbmUgSEVBRF9QT0lOVEVSX0hJR0hfU0hJRlQJMAotCi0JX19sZTMyIHJlZzE7Ci0vKiBBQ0sgdGltZW91dCB0YWlsIHBhY2tldCBjb3VudCAqLwotI2RlZmluZSBBQ0tfVElNT1VUX1RBSUxfUEFDS19DTlQJMHhGRkYwMDAwMAotI2RlZmluZSBBQ0tfVElNT1VUX1RBSUxfUEFDS19DTlRfU0hJRlQJMjAKLS8qIEhlYWQgdGltZW91dCB0YWlsIHBhY2tldCBjb3VudCAqLwotI2RlZmluZSBIRUFEX1RJTU9VVF9UQUlMX1BBQ0tfQ05UCTB4MDAwRkZGMDAKLSNkZWZpbmUgSEVBRF9USU1PVVRfVEFJTF9QQUNLX0NOVF9TSElGVAk4Ci0jZGVmaW5lIEFDS19QT0lOVEVSX0hJR0gJICAgICAgICAweDAwMDAwMEZGIC8qIEFDSyBwb2ludGVyIGhpZ2ggKi8KLSNkZWZpbmUgQUNLX1BPSU5URVJfSElHSF9TSElGVAkJMAotCi0JX19sZTMyIHJlZzI7Ci0jZGVmaW5lIFdPUktfUVVFVUVfVkFMSUQJCTB4ODAwMDAwMDAgLyogdmFsaWQgKi8KLSNkZWZpbmUgV09SS19RVUVVRV9WQUxJRF9TSElGVAkJMzEKLSNkZWZpbmUgV09SS19RVUVVRV9BQ0tfVFlQRQkJMHg0MDAwMDAwMCAvKiBBQ0sgdHlwZSAqLwotI2RlZmluZSBXT1JLX1FVRVVFX0FDS19UWVBFX1NISUZUCTMwCi0vKiBIZWFkIHRpbWVvdXQgd2luZG93IGxpbWl0IGZyYWdtZW50YXRpb24gY291bnQgKi8KLSNkZWZpbmUgSEVBRF9USU1PVVRfV0lOX0xJTV9GUkFHX0NOVAkweDNGRkYwMDAwCi0jZGVmaW5lIEhFQURfVElNT1VUX1dJTl9MSU1fRlJBR19DTlRfU0hJRlQJMTYKLS8qIEhlYWQgdGltZW91dCB3aW5kb3cgbGltaXQgYnl0ZSBjb3VudCAqLwotI2RlZmluZSBIRUFEX1RJTU9VVF9XSU5fTElNX0JZVEVfQ05UCTB4MDAwMEZGRkYKLSNkZWZpbmUgSEVBRF9USU1PVVRfV0lOX0xJTV9CWVRFX0NOVF9TSElGVAkgMAotfSBfX2F0dHJpYnV0ZV9fKChfX3BhY2tlZF9fKSk7Ci0KLQotLyoKLSAqIFRyYWZmaWMgQ2xhc3MgU3RydWN0dXJlCi0gKi8KLXN0cnVjdCBhZ254X3N0YV90cmFmZmljIHsKLQlfX2xlMzIgcmVnMDsKLSNkZWZpbmUgQUNLX1RJTU9VVF9DTlQJCTB4RkY4MDAwMDAgLyogQUNLIFRpbWVvdXQgQ291bnRzICovCi0jZGVmaW5lIEFDS19USU1PVVRfQ05UX1NISUZUCTIzCi0jZGVmaW5lIFRSQUZGSUNfQUNLX1RZUEUJMHgwMDYwMDAwMCAvKiBBQ0sgVHlwZSAqLwotI2RlZmluZSBUUkFGRklDX0FDS19UWVBFX1NISUZUCTIxCi0jZGVmaW5lIE5FV19QQUNLRVQJCTB4MDAxMDAwMDAgLyogTmV3IFBhY2tldCAgKi8KLSNkZWZpbmUgTkVXX1BBQ0tFVF9TSElGVAkyMAotI2RlZmluZSBUUkFGRklDX1ZBTElECQkweDAwMDgwMDAwIC8qIFZhbGlkICovCi0jZGVmaW5lIFRSQUZGSUNfVkFMSURfU0hJRlQJMTkKLSNkZWZpbmUgUlhfSERSX0RFU0NfUE9JTlRFUgkweDAwMDdGRkZGIC8qIFJYIEhlYWRlciBEZXNjcmlwdGVyIHBvaW50ZXIgKi8KLSNkZWZpbmUgUlhfSERSX0RFU0NfUE9JTlRFUl9TSElGVAkgMAotCi0JX19sZTMyIHJlZzE7Ci0jZGVmaW5lIFJYX1BBQ0tFVF9USU1FU1RBTVAJMHhGRkZGMDAwMCAvKiBSWCBQYWNrZXQgVGltZXN0YW1wICovCi0jZGVmaW5lIFJYX1BBQ0tFVF9USU1FU1RBTVBfU0hJRlQJMTYKLSNkZWZpbmUgVFJBRkZJQ19SRVNFUlZFRAkweDAwMDBFMDAwIC8qIFJlc2VydmVkICovCi0jZGVmaW5lIFRSQUZGSUNfUkVTRVJWRURfU0hJRlQgIDEzCi0jZGVmaW5lIFNWCQkJMHgwMDAwMTAwMCAvKiBzdiAqLwotI2RlZmluZSBTVl9TSElGVAkJMTIKLSNkZWZpbmUgUlhfU0VRVUVOQ0VfTlVNCQkweDAwMDAwRkZGIC8qIFJYIFNlcXVlbmNlIE51bWJlciAqLwotI2RlZmluZSBSWF9TRVFVRU5DRV9OVU1fU0hJRlQJMAotCi0JX19sZTMyIHR4X3JlcGxheV9jbnRfbG93OyAvKiBUWCBSZXBsYXkgQ291bnRlciBMb3cgKi8KLQotCV9fbGUxNiB0eF9yZXBsYXlfY250X2hpZ2g7IC8qIFRYIFJlcGxheSBDb3VudGVyIEhpZ2ggKi8KLQlfX2xlMTYgcnhfcmVwbGF5X2NudF9oaWdoOyAvKiBSWCBSZXBsYXkgQ291bnRlciBIaWdoICovCi0KLQlfX2JlMzIgcnhfcmVwbGF5X2NudF9sb3c7IC8qIFJYIFJlcGxheSBDb3VudGVyIExvdyAqLwotfSBfX2F0dHJpYnV0ZV9fKChfX3BhY2tlZF9fKSk7Ci0KLS8qCi0gKiBTdGF0aW9uIERlc2NyaXB0b3JzCi0gKi8KLXN0cnVjdCBhZ254X3N0YSB7Ci0JX19sZTMyIHR4X3Nlc3Npb25fa2V5c1s0XTsgLyogVHJhbnNtaXQgU2Vzc2lvbiBLZXkgKDAtMykgKi8KLQlfX2xlMzIgcnhfc2Vzc2lvbl9rZXlzWzRdOyAvKiBSZWNlaXZlIFNlc3Npb24gS2V5ICgwLTMpICovCi0KLQlfX2xlMzIgcmVnOwotI2RlZmluZSBJRF8xCQkJMHhDMDAwMDAwMCAvKiBpZCAxICovCi0jZGVmaW5lIElEXzFfU0hJRlQJCTMwCi0jZGVmaW5lIElEXzAJCQkweDMwMDAwMDAwIC8qIGlkIDAgKi8KLSNkZWZpbmUgSURfMF9TSElGVAkJMjgKLSNkZWZpbmUgRU5BQkxFX0NPTkNBVEVOQVRJT04JMHgwRkYwMDAwMCAvKiBFbmFibGUgY29uY2F0ZW5hdGlvbiAqLwotI2RlZmluZSBFTkFCTEVfQ09OQ0FURU5BVElPTl9TSElGVAkyMAotI2RlZmluZSBFTkFCTEVfREVDT01QUkVTU0lPTgkweDAwMEZGMDAwIC8qIEVuYWJsZSBkZWNvbXByZXNzaW9uICovCi0jZGVmaW5lIEVOQUJMRV9ERUNPTVBSRVNTSU9OX1NISUZUCTEyCi0jZGVmaW5lIFNUQV9SRVNFUlZFRAkJMHgwMDAwMEMwMCAvKiBSZXNlcnZlZCAqLwotI2RlZmluZSBTVEFfUkVTRVJWRURfU0hJRlQJMTAKLSNkZWZpbmUgRUFQCQkJMHgwMDAwMDIwMCAvKiBFQVAgKi8KLSNkZWZpbmUgRUFQX1NISUZUCQk5Ci0jZGVmaW5lIEVEX05VTEwJCQkweDAwMDAwMTAwIC8qIEVEIE5VTEwgKi8KLSNkZWZpbmUgRURfTlVMTF9TSElGVAkJOAotI2RlZmluZSBFTkNSWVBUSU9OX1BPTElDWQkweDAwMDAwMEUwIC8qIEVuY3J5cHRpb24gUG9saWN5ICovCi0jZGVmaW5lIEVOQ1JZUFRJT05fUE9MSUNZX1NISUZUIDUKLSNkZWZpbmUgREVGSU5FRF9LRVlfSUQJCTB4MDAwMDAwMTggLyogRGVmaW5lZCBLZXkgSUQgKi8KLSNkZWZpbmUgREVGSU5FRF9LRVlfSURfU0hJRlQJMwotI2RlZmluZSBGSVhFRF9LRVkJCTB4MDAwMDAwMDQgLyogRml4ZWQgS2V5ICovCi0jZGVmaW5lIEZJWEVEX0tFWV9TSElGVAkJMgotI2RlZmluZSBLRVlfVkFMSUQJCTB4MDAwMDAwMDIgLyogS2V5IFZhbGlkICovCi0jZGVmaW5lIEtFWV9WQUxJRF9TSElGVAkJMQotI2RlZmluZSBTVEFUSU9OX1ZBTElECQkweDAwMDAwMDAxIC8qIFN0YXRpb24gVmFsaWQgKi8KLSNkZWZpbmUgU1RBVElPTl9WQUxJRF9TSElGVAkwCi0KLQlfX2xlMzIgdHhfYWVzX2Jsa3NfdW5pY2FzdDsgLyogVFggQUVTIEJsa3MgVW5pY2FzdCAqLwotCV9fbGUzMiByeF9hZXNfYmxrc191bmljYXN0OyAvKiBSWCBBRVMgQmxrcyBVbmljYXN0ICovCi0KLQlfX2xlMTYgYWVzX2Zvcm1hdF9lcnJfdW5pY2FzdF9jbnQ7IC8qIEFFUyBGb3JtYXQgRXJyb3IgVW5pY2FzdCBDb3VudHMgKi8KLQlfX2xlMTYgYWVzX3JlcGxheV91bmljYXN0OyAvKiBBRVMgUmVwbGF5IFVuaWNhc3QgKi8KLQotCV9fbGUxNiBhZXNfZGVjcnlwdF9lcnJfdW5pY2FzdDsJLyogQUVTIERlY3J5cHQgRXJyb3IgVW5pY2FzdCAqLwotCV9fbGUxNiBhZXNfZGVjcnlwdF9lcnJfZGVmYXVsdDsJLyogQUVTIERlY3J5cHQgRXJyb3IgZGVmYXVsdCAqLwotCi0JX19sZTE2IHNpbmdsZV9yZXRyeV9wYWNrZXRzOyAvKiBTaW5nbGUgUmV0cnkgUGFja2V0cyAqLwotCV9fbGUxNiBmYWlsZWRfdHhfcGFja2V0czsgLyogRmFpbGVkIFR4IFBhY2tldHMgKi8KLQotCV9fbGUxNiBtdXRpX3JldHJ5X3BhY2tldHM7IC8qIE11bHRpcGxlIFJldHJ5IFBhY2tldHMgKi8KLQlfX2xlMTYgYWNrX3RpbWVvdXRzOwkvKiBBQ0sgVGltZW91dHMgKi8KLQotCV9fbGUxNiBmcmFnX3R4X2NudDsJLyogRnJhZ21lbnQgVFggQ291bnRzICovCi0JX19sZTE2IHJ0c19icnFfc2VudDsJLyogUlRTIEJycSBTZW50ICovCi0KLQlfX2xlMTYgdHhfcGFja2V0czsJLyogVFggUGFja2V0cyAqLwotCV9fbGUxNiBjdHNfYmFja190aW1lb3V0OyAvKiBDVFMgQmFjayBUaW1lb3V0ICovCi0KLQlfX2xlMzIgcGh5X3N0YXRzX2hpZ2g7CS8qIFBIWSBTdGF0cyBIaWdoICovCi0JX19sZTMyIHBoeV9zdGF0c19sb3c7CS8qIFBIWSBTdGF0cyBMb3cgKi8KLQotCXN0cnVjdCBhZ254X3N0YV90cmFmZmljIHRyYWZmaWNbOF07CS8qIFRyYWZmaWMgQ2xhc3MgU3RydWN0dXJlICg4KSAqLwotCi0JX19sZTE2IHRyYWZmaWNfY2xhc3MwX2ZyYWdfc3VjY2VzczsgLyogVHJhZmZpYyBDbGFzcyAwIEZyYWdtZW50IFN1Y2Nlc3MgKi8KLQlfX2xlMTYgdHJhZmZpY19jbGFzczFfZnJhZ19zdWNjZXNzOyAvKiBUcmFmZmljIENsYXNzIDEgRnJhZ21lbnQgU3VjY2VzcyAqLwotCV9fbGUxNiB0cmFmZmljX2NsYXNzMl9mcmFnX3N1Y2Nlc3M7IC8qIFRyYWZmaWMgQ2xhc3MgMiBGcmFnbWVudCBTdWNjZXNzICovCi0JX19sZTE2IHRyYWZmaWNfY2xhc3MzX2ZyYWdfc3VjY2VzczsgLyogVHJhZmZpYyBDbGFzcyAzIEZyYWdtZW50IFN1Y2Nlc3MgKi8KLQlfX2xlMTYgdHJhZmZpY19jbGFzczRfZnJhZ19zdWNjZXNzOyAvKiBUcmFmZmljIENsYXNzIDQgRnJhZ21lbnQgU3VjY2VzcyAqLwotCV9fbGUxNiB0cmFmZmljX2NsYXNzNV9mcmFnX3N1Y2Nlc3M7IC8qIFRyYWZmaWMgQ2xhc3MgNSBGcmFnbWVudCBTdWNjZXNzICovCi0JX19sZTE2IHRyYWZmaWNfY2xhc3M2X2ZyYWdfc3VjY2VzczsgLyogVHJhZmZpYyBDbGFzcyA2IEZyYWdtZW50IFN1Y2Nlc3MgKi8KLQlfX2xlMTYgdHJhZmZpY19jbGFzczdfZnJhZ19zdWNjZXNzOyAvKiBUcmFmZmljIENsYXNzIDcgRnJhZ21lbnQgU3VjY2VzcyAqLwotCi0JX19sZTE2IG51bV9mcmFnX25vbl9wcmltZV9yYXRlczsgLyogbnVtYmVyIG9mIEZyYWdtZW50cyBmb3Igbm9uLXByaW1lIHJhdGVzICovCi0JX19sZTE2IGFja190aW1lb3V0X25vbl9wcmltZV9yYXRlczsgLyogQUNLIFRpbWVvdXQgZm9yIG5vbi1wcmltZSByYXRlcyAqLwotCi19IF9fYXR0cmlidXRlX18oKF9fcGFja2VkX18pKTsKLQotCi1zdHJ1Y3QgYWdueF9iZWFjb25faGRyIHsKLQlzdHJ1Y3QgYWdueF9zdGFfcG93ZXIgcG93ZXI7IC8qIFR4IFN0YXRpb24gUG93ZXIgVGVtcGxhdGUgICovCi0JdTggcGh5X2hkcls2XTsJCS8qIFBIWSBIZHIgKi8KLQl1OCBmcmFtZV9sZW5fbG87CS8qIEZyYW1lIExlbmd0aCBMbyAqLwotCXU4IGZyYW1lX2xlbl9oaTsJLyogRnJhbWUgTGVuZ3RoIEhpICovCi0JdTggbWFjX2hkclsyNF07CQkvKiBNQUMgSGVhZGVyICovCi0JLyogRklYTUUgKi8KLQkvKiA4MDIuMTEoYWJnKSBiZWFjb24gKi8KLX0gX19hdHRyaWJ1dGVfXygoX19wYWNrZWRfXykpOwotCi12b2lkIGhhc2hfd3JpdGUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgY29uc3QgdTggKm1hY19hZGRyLCB1OCBzdGFfaWQpOwotdm9pZCBoYXNoX2R1bXAoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdTggc3RhX2lkKTsKLXZvaWQgaGFzaF9yZWFkKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHUzMiByZWdoaSwgdTMyIHJlZ2xvLCB1OCBzdGFfaWQpOwotdm9pZCBoYXNoX2RlbGV0ZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1MzIgcmVnaGksIHUzMiByZWdsbywgdTggc3RhX2lkKTsKLQotdm9pZCBnZXRfc3RhX3Bvd2VyKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHN0cnVjdCBhZ254X3N0YV9wb3dlciAqcG93ZXIsIHVuc2lnbmVkIGludCBzdGFfaWR4KTsKLXZvaWQgc2V0X3N0YV9wb3dlcihzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3QgYWdueF9zdGFfcG93ZXIgKnBvd2VyLAotCQkgICB1bnNpZ25lZCBpbnQgc3RhX2lkeCk7Ci12b2lkIGdldF9zdGFfdHhfd3Eoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgc3RydWN0IGFnbnhfc3RhX3R4X3dxICp0eF93cSwKLQkJICAgdW5zaWduZWQgaW50IHN0YV9pZHgsIHVuc2lnbmVkIGludCB3cV9pZHgpOwotdm9pZCBzZXRfc3RhX3R4X3dxKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHN0cnVjdCBhZ254X3N0YV90eF93cSAqdHhfd3EsCi0JCSAgIHVuc2lnbmVkIGludCBzdGFfaWR4LCB1bnNpZ25lZCBpbnQgd3FfaWR4KTsKLXZvaWQgZ2V0X3N0YShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3QgYWdueF9zdGEgKnN0YSwgdW5zaWduZWQgaW50IHN0YV9pZHgpOwotdm9pZCBzZXRfc3RhKHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHN0cnVjdCBhZ254X3N0YSAqc3RhLCB1bnNpZ25lZCBpbnQgc3RhX2lkeCk7Ci0KLXZvaWQgc3RhX3Bvd2VyX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdW5zaWduZWQgaW50IG51bSk7Ci12b2lkIHN0YV9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHVuc2lnbmVkIGludCBudW0pOwotCi0jZW5kaWYgLyogQUdOWF9TVEFfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3RhYmxlLmMgYi9kcml2ZXJzL3N0YWdpbmcvYWdueC90YWJsZS5jCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiNTJmZWY5Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3RhYmxlLmMKKysrIC9kZXYvbnVsbApAQCAtMSwxNjggKzAsMCBAQAotI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgotI2luY2x1ZGUgPGxpbnV4L2RlbGF5Lmg+Ci0jaW5jbHVkZSAiYWdueC5oIgotI2luY2x1ZGUgImRlYnVnLmgiCi0jaW5jbHVkZSAicGh5LmgiCi0KLXN0YXRpYyBjb25zdCB1MzIKLXR4X2Zpcl90YWJsZVtdID0geyAweDE5LCAweDVkLCAweGNlLCAweDE1MSwgMHgxYzMsIDB4MWZmLCAweDFlYSwgMHgxN2MsIDB4Y2YsCi0JCSAgIDB4MTksIDB4MzhlLCAweDM1MCwgMHgzNjIsIDB4M2FkLCAweDUsIDB4NDQsIDB4NTksIDB4NDksCi0JCSAgIDB4MjEsIDB4M2Y3LCAweDNlMCwgMHgzZTMsIDB4M2YzLCAweDAgfTsKLQotdm9pZCB0eF9maXJfdGFibGVfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCWludCBpOwotCi0JZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodHhfZmlyX3RhYmxlKTsgaSsrKQotCQlpb3dyaXRlMzIodHhfZmlyX3RhYmxlW2ldLCBjdGwgKyBBR05YX0ZJUl9CQVNFICsgaSo0KTsKLX0gLyogZmlyX3RhYmxlX3NldHVwICovCi0KLQotc3RhdGljIGNvbnN0IHUzMgotZ2Fpbl90YWJsZVtdID0geyAweDgsIDB4OCwgMHhmLCAweDEzLCAweDE3LCAweDFiLCAweDFmLCAweDIzLCAweDI3LCAweDJiLAotCQkgMHgyZiwgMHgzMywgMHgzNywgMHgzYiwgMHgzZiwgMHg0MywgMHg0NywgMHg0YiwgMHg0ZiwKLQkJIDB4NTMsIDB4NTcsIDB4NWIsIDB4NWYsIDB4NWYsIDB4NWYsIDB4NWYsIDB4NWYsIDB4NWYsCi0JCSAweDVmLCAweDVmLCAweDVmLCAweDVmIH07Ci0KLXZvaWQgZ2Fpbl90YWJsZV9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JaW50IGk7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgQVJSQVlfU0laRShnYWluX3RhYmxlKTsgaSsrKSB7Ci0JCWlvd3JpdGUzMihnYWluX3RhYmxlW2ldLCBjdGwgKyBBR05YX0dBSU5fVEFCTEUgKyBpKjQpOwotCQlpb3dyaXRlMzIoZ2Fpbl90YWJsZVtpXSwgY3RsICsgQUdOWF9HQUlOX1RBQkxFICsgaSo0ICsgMHg4MCk7Ci0JfQotfSAvKiBnYWluX3RhYmxlX2luaXQgKi8KLQotdm9pZCBtb25pdG9yX2dhaW5fdGFibGVfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXVuc2lnbmVkIGludCBpOwotCi0JZm9yIChpID0gMDsgaSA8IDB4NDQ7IGkgKz0gNCkgewotCQlpb3dyaXRlMzIoMHg2MSwgY3RsICsgQUdOWF9NT05HQ1JfQkFTRSArIGkpOwotCQlpb3dyaXRlMzIoMHg2MSwgY3RsICsgQUdOWF9NT05HQ1JfQkFTRSArIDB4MjAwICsgaSk7Ci0JfQotCWZvciAoaSA9IDB4NDQ7IGkgPCAweDY0OyBpICs9IDQpIHsKLQkJaW93cml0ZTMyKDB4NmUsIGN0bCArIEFHTlhfTU9OR0NSX0JBU0UgKyBpKTsKLQkJaW93cml0ZTMyKDB4NmUsIGN0bCArIEFHTlhfTU9OR0NSX0JBU0UgKyAweDIwMCArIGkpOwotCX0KLQlmb3IgKGkgPSAweDY0OyBpIDwgMHg5NDsgaSArPSA0KSB7Ci0JCWlvd3JpdGUzMigweDdhLCBjdGwgKyBBR05YX01PTkdDUl9CQVNFICsgaSk7Ci0JCWlvd3JpdGUzMigweDdhLCBjdGwgKyBBR05YX01PTkdDUl9CQVNFICsgMHgyMDAgKyBpKTsKLQl9Ci0JZm9yIChpID0gMHg5NDsgaSA8IDB4ZGM7IGkgKz0gNCkgewotCQlpb3dyaXRlMzIoMHg4NywgY3RsICsgQUdOWF9NT05HQ1JfQkFTRSArIGkpOwotCQlpb3dyaXRlMzIoMHg4NywgY3RsICsgQUdOWF9NT05HQ1JfQkFTRSArIDB4MjAwICsgaSk7Ci0JfQotCWZvciAoaSA9IDB4ZGM7IGkgPCAweDE0ODsgaSArPSA0KSB7Ci0JCWlvd3JpdGUzMigweDk1LCBjdGwgKyBBR05YX01PTkdDUl9CQVNFICsgaSk7Ci0JCWlvd3JpdGUzMigweDk1LCBjdGwgKyBBR05YX01PTkdDUl9CQVNFICsgMHgyMDAgKyBpKTsKLQl9Ci0JZm9yIChpID0gMHgxNDg7IGkgPCAweDFlODsgaSArPSA0KSB7Ci0JCWlvd3JpdGUzMigweGEyLCBjdGwgKyBBR05YX01PTkdDUl9CQVNFICsgaSk7Ci0JCWlvd3JpdGUzMigweGEyLCBjdGwgKyBBR05YX01PTkdDUl9CQVNFICsgMHgyMDAgKyBpKTsKLQl9Ci0JZm9yIChpID0gMHgxZTg7IGkgPD0gMHgxZmM7IGkgKz0gNCkgewotCQlpb3dyaXRlMzIoMHhiMCwgY3RsICsgQUdOWF9NT05HQ1JfQkFTRSArIGkpOwotCQlpb3dyaXRlMzIoMHhiMCwgY3RsICsgQUdOWF9NT05HQ1JfQkFTRSArIDB4MjAwICsgaSk7Ci0JfQotfSAvKiBtb25pdG9yX2dhaW5fdGFibGVfaW5pdCAqLwotCi0KLXZvaWQgcm91dGluZ190YWJsZV9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdW5zaWduZWQgaW50IHR5cGUsIHN1YnR5cGU7Ci0JdTMyIHJlZzsKLQotCWRpc2FibGVfcmVjZWl2ZXIocHJpdik7Ci0KLQlmb3IgKHR5cGUgPSAwOyB0eXBlIDwgMHgzOyB0eXBlKyspIHsKLQkJZm9yIChzdWJ0eXBlID0gMDsgc3VidHlwZSA8IDB4MTA7IHN1YnR5cGUrKykgewotCQkJLyogMS4gU2V0IFJvdXRpbmcgdGFibGUgdG8gUi9XIGFuZCB0byBSZXR1cm4gc3RhdHVzIG9uIFJlYWQgKi8KLQkJCXJlZyA9ICh0eXBlIDw8IFJPVVRBQl9UWVBFX1NISUZUKSB8Ci0JCQkJKHN1YnR5cGUgPDwgUk9VVEFCX1NVQlRZUEVfU0hJRlQpOwotCQkJcmVnIHw9ICgxIDw8IFJPVVRBQl9SV19TSElGVCkgfCAoMSA8PCBST1VUQUJfU1RBVFVTX1NISUZUKTsKLQkJCWlmICh0eXBlID09IFJPVVRBQl9UWVBFX0RBVEEpIHsKLQkJCQkvKiBOVUxMIGdvZXMgdG8gUkZQICovCi0JCQkJaWYgKHN1YnR5cGUgPT0gUk9VVEFCX1NVQlRZUEVfTlVMTCkKLS8qCQkJCQlyZWcgfD0gUk9VVEFCX1JPVVRFX1JGUDsgKi8KLQkJCQkJcmVnIHw9IFJPVVRBQl9ST1VURV9DUFU7Ci0JCQkJLyogUU9TIE5VTEwgZ29lcyB0byBDUFUgKi8KLQkJCQllbHNlIGlmIChzdWJ0eXBlID09IFJPVVRBQl9TVUJUWVBFX1FPU05VTEwpCi0JCQkJCXJlZyB8PSBST1VUQUJfUk9VVEVfQ1BVOwotCQkJCS8qIEFsbCBEYXRhIGFuZCBRT1MgZGF0YSBzdWJ0eXBlcyBnbyB0byBFbmNyeXB0aW9uICovCi0JCQkJZWxzZSBpZiAoKHN1YnR5cGUgPT0gUk9VVEFCX1NVQlRZUEVfREFUQSkgfHwKLQkJCQkJIChzdWJ0eXBlID09IFJPVVRBQl9TVUJUWVBFX0RBVEFBQ0spIHx8Ci0JCQkJCSAoc3VidHlwZSA9PSBST1VUQUJfU1VCVFlQRV9EQVRBUE9MTCkgfHwKLQkJCQkJIChzdWJ0eXBlID09IFJPVVRBQl9TVUJUWVBFX0RBVEFQT0xMQUNLKSB8fAotCQkJCQkgKHN1YnR5cGUgPT0gUk9VVEFCX1NVQlRZUEVfUU9TREFUQSkgfHwKLQkJCQkJIChzdWJ0eXBlID09IFJPVVRBQl9TVUJUWVBFX1FPU0RBVEFBQ0spIHx8Ci0JCQkJCSAoc3VidHlwZSA9PSBST1VUQUJfU1VCVFlQRV9RT1NEQVRBUE9MTCkgfHwKLQkJCQkJIChzdWJ0eXBlID09IFJPVVRBQl9TVUJUWVBFX1FPU0RBVEFBQ0tQT0xMKSkKLQkJCQkJcmVnIHw9IFJPVVRBQl9ST1VURV9FTkNSWTsKLS8qCQkJCQlyZWcgfD0gUk9VVEFCX1JPVVRFX0NQVTsgKi8KLQkJCQkvKkRyb3AgTlVMTCBhbmQgUU9TIE5VTEwgYWNrLCBwb2xsIGFuZCBwb2xsIGFjayovCi0JCQkJZWxzZSBpZiAoKHN1YnR5cGUgPT0gUk9VVEFCX1NVQlRZUEVfTlVMTEFDSykgfHwKLQkJCQkJIChzdWJ0eXBlID09IFJPVVRBQl9TVUJUWVBFX1FPU05VTExBQ0spIHx8Ci0JCQkJCSAoc3VidHlwZSA9PSBST1VUQUJfU1VCVFlQRV9OVUxMUE9MTCkgfHwKLQkJCQkJIChzdWJ0eXBlID09IFJPVVRBQl9TVUJUWVBFX1FPU05VTExQT0xMKSB8fAotCQkJCQkgKHN1YnR5cGUgPT0gUk9VVEFCX1NVQlRZUEVfTlVMTFBPTExBQ0spIHx8Ci0JCQkJCSAoc3VidHlwZSA9PSBST1VUQUJfU1VCVFlQRV9RT1NOVUxMUE9MTEFDSykpCi0vKgkJCQkJcmVnIHw9IFJPVVRBQl9ST1VURV9EUk9QOyAqLwotCQkJCQlyZWcgfD0gUk9VVEFCX1JPVVRFX0NQVTsKLQkJCX0gZWxzZSB7Ci0JCQkJcmVnIHw9IChST1VUQUJfUk9VVEVfQ1BVKTsKLQkJCX0KLQkJCWlvd3JpdGUzMihyZWcsIGN0bCArIEFHTlhfUlhNX1JPVVRBQik7Ci0JCQkvKiBDaGVjayB0byB2ZXJpZnkgdGhhdCB0aGUgc3RhdHVzIGJpdCBjbGVhcmVkICovCi0JCQlyb3V0aW5nX3RhYmxlX2RlbGF5KCk7Ci0JCX0KLQl9Ci0JZW5hYmxlX3JlY2VpdmVyKHByaXYpOwotfSAvKiByb3V0aW5nX3RhYmxlX2luaXQgKi8KLQotdm9pZCB0eF9lbmdpbmVfbG9va3VwX3RibF9pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpkYXRhID0gcHJpdi0+ZGF0YTsKLQl1bnNpZ25lZCBpbnQgaTsKLQotCWZvciAoaSA9IDA7IGkgPD0gMjg7IGkgKz0gNCkKLQkJaW93cml0ZTMyKDB4YjAwYywgZGF0YSArIEFHTlhfRU5HSU5FX0xPT0tVUF9UQkwgKyBpKTsKLQlmb3IgKGkgPSAzMjsgaSA8PSAxMjA7IGkgKz0gOCkgewotCQlpb3dyaXRlMzIoMHgxZTU4LCBkYXRhICsgQUdOWF9FTkdJTkVfTE9PS1VQX1RCTCArIGkpOwotCQlpb3dyaXRlMzIoMHhiMDBjLCBkYXRhICsgQUdOWF9FTkdJTkVfTE9PS1VQX1RCTCArIGkgKyA0KTsKLQl9Ci0KLQlmb3IgKGkgPSAxMjg7IGkgPD0gMTU2OyBpICs9IDQpCi0JCWlvd3JpdGUzMigweDk4MGMsIGRhdGEgKyBBR05YX0VOR0lORV9MT09LVVBfVEJMICsgaSk7Ci0JZm9yIChpID0gMTYwOyBpIDw9IDI0ODsgaSArPSA4KSB7Ci0JCWlvd3JpdGUzMigweDE4NTgsIGRhdGEgKyBBR05YX0VOR0lORV9MT09LVVBfVEJMICsgaSk7Ci0JCWlvd3JpdGUzMigweDk4MGMsIGRhdGEgKyBBR05YX0VOR0lORV9MT09LVVBfVEJMICsgaSArIDQpOwotCX0KLQotCWZvciAoaSA9IDI1NjsgaSA8PSAyODQ7IGkgKz0gNCkKLQkJaW93cml0ZTMyKDB4OTgwYywgZGF0YSArIEFHTlhfRU5HSU5FX0xPT0tVUF9UQkwgKyBpKTsKLQlmb3IgKGkgPSAyODg7IGkgPD0gMzc2OyBpICs9IDgpIHsKLQkJaW93cml0ZTMyKDB4MWE1OCwgZGF0YSArIEFHTlhfRU5HSU5FX0xPT0tVUF9UQkwgKyBpKTsKLQkJaW93cml0ZTMyKDB4MTg1OCwgZGF0YSArIEFHTlhfRU5HSU5FX0xPT0tVUF9UQkwgKyBpICsgNCk7Ci0JfQotCi0JZm9yIChpID0gNTEyOyBpIDw9IDU0MDsgaSArPSA0KQotCQlpb3dyaXRlMzIoMHhjMDBjLCBkYXRhICsgQUdOWF9FTkdJTkVfTE9PS1VQX1RCTCArIGkpOwotCWZvciAoaSA9IDU0NDsgaSA8PSA2MzI7IGkgKz0gOCkgewotCQlpb3dyaXRlMzIoMHgyMDU4LCBkYXRhICsgQUdOWF9FTkdJTkVfTE9PS1VQX1RCTCArIGkpOwotCQlpb3dyaXRlMzIoMHhjMDBjLCBkYXRhICsgQUdOWF9FTkdJTkVfTE9PS1VQX1RCTCArIGkgKyA0KTsKLQl9Ci0KLQlmb3IgKGkgPSA2NDA7IGkgPD0gNjY4OyBpICs9IDQpCi0JCWlvd3JpdGUzMigweGM4MGMsIGRhdGEgKyBBR05YX0VOR0lORV9MT09LVVBfVEJMICsgaSk7Ci0JZm9yIChpID0gNjcyOyBpIDw9IDc2NDsgaSArPSA4KSB7Ci0JCWlvd3JpdGUzMigweDIyNTgsIGRhdGEgKyBBR05YX0VOR0lORV9MT09LVVBfVEJMICsgaSk7Ci0JCWlvd3JpdGUzMigweGM4MGMsIGRhdGEgKyBBR05YX0VOR0lORV9MT09LVVBfVEJMICsgaSArIDQpOwotCX0KLX0KLQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2FnbngvdGFibGUuaCBiL2RyaXZlcnMvc3RhZ2luZy9hZ254L3RhYmxlLmgKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGYwNjI2YjUuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2FnbngvdGFibGUuaAorKysgL2Rldi9udWxsCkBAIC0xLDEwICswLDAgQEAKLSNpZm5kZWYgQUdOWF9UQUJMRV9IXwotI2RlZmluZSBBR05YX1RBQkxFX0hfCi0KLXZvaWQgdHhfZmlyX3RhYmxlX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci12b2lkIGdhaW5fdGFibGVfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLXZvaWQgbW9uaXRvcl9nYWluX3RhYmxlX2luaXQoc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci12b2lkIHJvdXRpbmdfdGFibGVfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLXZvaWQgdHhfZW5naW5lX2xvb2t1cF90YmxfaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLQotI2VuZGlmIC8qIEFHTlhfVEFCTEVfSF8gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3htaXQuYyBiL2RyaXZlcnMvc3RhZ2luZy9hZ254L3htaXQuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNDJkYjQxMC4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvYWdueC94bWl0LmMKKysrIC9kZXYvbnVsbApAQCAtMSw4MzYgKzAsMCBAQAotLyoqCi0gKiBBaXJnbyBNSU1PIHdpcmVsZXNzIGRyaXZlcgotICoKLSAqIENvcHlyaWdodCAoYykgMjAwNyBMaSBZYW5CbyA8ZHJlYW1mbHkyODFAZ21haWwuY29tPgotCi0gKiBUaGFua3MgZm9yIEplZmYgV2lsbGlhbXMgPGFuZ2VsYmFuZUBnbWFpbC5jb20+IGRvIHJldmVyc2UgZW5naW5lZXIKLSAqIHdvcmtzIGFuZCBwdWJsaXNoZWQgdGhlIFNQRUNTIGF0IGh0dHA6Ly9haXJnby53ZHdjb25zdWx0aW5nLm5ldC9teW1vaW4KLQotICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKLSAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCi0gKiBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KLSAqLwotCi0jaW5jbHVkZSA8bGludXgvcGNpLmg+Ci0jaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KLSNpbmNsdWRlICJhZ254LmgiCi0jaW5jbHVkZSAiZGVidWcuaCIKLSNpbmNsdWRlICJwaHkuaCIKLQotdW5zaWduZWQgaW50IHJ4X2ZyYW1lX2NudDsKLS8qIHVuc2lnbmVkIGludCBsb2NhbF90eF9zZW50X2NudCA9IDA7ICovCi0KLXN0YXRpYyBpbmxpbmUgdm9pZCBkaXNhYmxlX3J4X2VuZ2luZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCWlvd3JpdGUzMigweDEwMCwgY3RsICsgQUdOWF9DSVJfUlhDVEwpOwotCS8qIFdhaXQgZm9yIFJYIENvbnRyb2wgdG8gaGF2ZSB0aGUgRGlzYWJsZSBSeCBJbnRlcnJ1cHQgKDB4MTAwKSBzZXQgKi8KLQlpb3JlYWQzMihjdGwgKyBBR05YX0NJUl9SWENUTCk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCBlbmFibGVfcnhfZW5naW5lKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JaW93cml0ZTMyKDB4ODAsIGN0bCArIEFHTlhfQ0lSX1JYQ1RMKTsKLQlpb3JlYWQzMihjdGwgKyBBR05YX0NJUl9SWENUTCk7Ci19Ci0KLWlubGluZSB2b2lkIGRpc2FibGVfcnhfaW50ZXJydXB0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQotCWRpc2FibGVfcnhfZW5naW5lKHByaXYpOwotCXJlZyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfQ0lSX1JYQ0ZHKTsKLQlyZWcgJj0gfjB4MjA7Ci0JaW93cml0ZTMyKHJlZywgY3RsICsgQUdOWF9DSVJfUlhDRkcpOwotCWlvcmVhZDMyKGN0bCArIEFHTlhfQ0lSX1JYQ0ZHKTsKLX0KLQotaW5saW5lIHZvaWQgZW5hYmxlX3J4X2ludGVycnVwdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCXZvaWQgX19pb21lbSAqY3RsID0gcHJpdi0+Y3RsOwotCXUzMiByZWc7Ci0KLQlyZWcgPSBpb3JlYWQzMihjdGwgKyBBR05YX0NJUl9SWENGRyk7Ci0JcmVnIHw9IDB4MjA7Ci0JaW93cml0ZTMyKHJlZywgY3RsICsgQUdOWF9DSVJfUlhDRkcpOwotCWlvcmVhZDMyKGN0bCArIEFHTlhfQ0lSX1JYQ0ZHKTsKLQllbmFibGVfcnhfZW5naW5lKHByaXYpOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgcnhfZGVzY19pbml0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHVuc2lnbmVkIGludCBpZHgpCi17Ci0Jc3RydWN0IGFnbnhfZGVzYyAqZGVzYyA9IHByaXYtPnJ4LmRlc2MgKyBpZHg7Ci0Jc3RydWN0IGFnbnhfaW5mbyAqaW5mbyA9IHByaXYtPnJ4LmluZm8gKyBpZHg7Ci0KLQltZW1zZXQoaW5mbywgMCwgc2l6ZW9mKCppbmZvKSk7Ci0KLQlpbmZvLT5kbWFfbGVuID0gSUVFRTgwMjExX01BWF9SVFNfVEhSRVNIT0xEICsgc2l6ZW9mKHN0cnVjdCBhZ254X2hkcik7Ci0JaW5mby0+c2tiID0gZGV2X2FsbG9jX3NrYihpbmZvLT5kbWFfbGVuKTsKLQlpZiAoaW5mby0+c2tiID09IE5VTEwpCi0JCWFnbnhfYnVnKCJyZWZpbGwgZXJyIik7Ci0KLQlpbmZvLT5tYXBwaW5nID0gcGNpX21hcF9zaW5nbGUocHJpdi0+cGRldiwgc2tiX3RhaWxfcG9pbnRlcihpbmZvLT5za2IpLAotCQkJCSAgICAgICBpbmZvLT5kbWFfbGVuLCBQQ0lfRE1BX0ZST01ERVZJQ0UpOwotCW1lbXNldChkZXNjLCAwLCBzaXplb2YoKmRlc2MpKTsKLQlkZXNjLT5kbWFfYWRkciA9IGNwdV90b19iZTMyKGluZm8tPm1hcHBpbmcpOwotCS8qIFNldCB0aGUgb3duZXIgdG8gdGhlIGNhcmQgKi8KLQlkZXNjLT5mcmFnID0gY3B1X3RvX2JlMzIoYmUzMl90b19jcHUoZGVzYy0+ZnJhZykgfCBPV05FUik7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCByeF9kZXNjX3JlaW5pdChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgaWR4KQotewotCXN0cnVjdCBhZ254X2luZm8gKmluZm8gPSBwcml2LT5yeC5pbmZvICsgaWR4OwotCi0JLyogQ2F1c2UgaWVlZTgwMjExIHdpbGwgZnJlZSB0aGUgc2tiIGJ1ZmZlciwgc28gd2UgbmVlZG4ndCB0byBmcmVlIGl0IGFnYWluPyEgKi8KLQlwY2lfdW5tYXBfc2luZ2xlKHByaXYtPnBkZXYsIGluZm8tPm1hcHBpbmcsIGluZm8tPmRtYV9sZW4sIFBDSV9ETUFfRlJPTURFVklDRSk7Ci0JcnhfZGVzY19pbml0KHByaXYsIGlkeCk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgdm9pZCByeF9kZXNjX3JldXNpbmcoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdW5zaWduZWQgaW50IGlkeCkKLXsKLQlzdHJ1Y3QgYWdueF9kZXNjICpkZXNjID0gcHJpdi0+cnguZGVzYyArIGlkeDsKLQlzdHJ1Y3QgYWdueF9pbmZvICppbmZvID0gcHJpdi0+cnguaW5mbyArIGlkeDsKLQotCW1lbXNldChkZXNjLCAwLCBzaXplb2YoKmRlc2MpKTsKLQlkZXNjLT5kbWFfYWRkciA9IGNwdV90b19iZTMyKGluZm8tPm1hcHBpbmcpOwotCS8qIFNldCB0aGUgb3duZXIgdG8gdGhlIGNhcmQgKi8KLQlkZXNjLT5mcmFnID0gY3B1X3RvX2JlMzIoYmUzMl90b19jcHUoZGVzYy0+ZnJhZykgfCBPV05FUik7Ci19Ci0KLXN0YXRpYyB2b2lkIHJ4X2Rlc2NfZnJlZShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCB1bnNpZ25lZCBpbnQgaWR4KQotewotCXN0cnVjdCBhZ254X2Rlc2MgKmRlc2MgPSBwcml2LT5yeC5kZXNjICsgaWR4OwotCXN0cnVjdCBhZ254X2luZm8gKmluZm8gPSBwcml2LT5yeC5pbmZvICsgaWR4OwotCi0JQlVHX09OKCFkZXNjIHx8ICFpbmZvKTsKLQlpZiAoaW5mby0+bWFwcGluZykKLQkJcGNpX3VubWFwX3NpbmdsZShwcml2LT5wZGV2LCBpbmZvLT5tYXBwaW5nLCBpbmZvLT5kbWFfbGVuLCBQQ0lfRE1BX0ZST01ERVZJQ0UpOwotCWlmIChpbmZvLT5za2IpCi0JCWRldl9rZnJlZV9za2IoaW5mby0+c2tiKTsKLQltZW1zZXQoaW5mbywgMCwgc2l6ZW9mKCppbmZvKSk7Ci0JbWVtc2V0KGRlc2MsIDAsIHNpemVvZigqZGVzYykpOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgX190eF9kZXNjX2ZyZWUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwKLQkJCQkgIHN0cnVjdCBhZ254X2Rlc2MgKmRlc2MsIHN0cnVjdCBhZ254X2luZm8gKmluZm8pCi17Ci0JQlVHX09OKCFkZXNjIHx8ICFpbmZvKTsKLQkvKiBUT0RPIG1ha2Ugc3VyZSBtYXBwaW5nLCBza2IgYW5kIGxlbiBhcmUgY29uc2lzdGVuY3kgKi8KLQlpZiAoaW5mby0+bWFwcGluZykKLQkJcGNpX3VubWFwX3NpbmdsZShwcml2LT5wZGV2LCBpbmZvLT5tYXBwaW5nLAotCQkJCSBpbmZvLT5kbWFfbGVuLCBQQ0lfRE1BX1RPREVWSUNFKTsKLQlpZiAoaW5mby0+dHlwZSA9PSBQQUNLRVQpCi0JCWRldl9rZnJlZV9za2IoaW5mby0+c2tiKTsKLQotCW1lbXNldChpbmZvLCAwLCBzaXplb2YoKmluZm8pKTsKLQltZW1zZXQoZGVzYywgMCwgc2l6ZW9mKCpkZXNjKSk7Ci19Ci0KLXN0YXRpYyB2b2lkIHR4bV9kZXNjX2ZyZWUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdW5zaWduZWQgaW50IGlkeCkKLXsKLQlzdHJ1Y3QgYWdueF9kZXNjICpkZXNjID0gcHJpdi0+dHhtLmRlc2MgKyBpZHg7Ci0Jc3RydWN0IGFnbnhfaW5mbyAqaW5mbyA9IHByaXYtPnR4bS5pbmZvICsgaWR4OwotCi0JX190eF9kZXNjX2ZyZWUocHJpdiwgZGVzYywgaW5mbyk7Ci19Ci0KLXN0YXRpYyB2b2lkIHR4ZF9kZXNjX2ZyZWUoc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgdW5zaWduZWQgaW50IGlkeCkKLXsKLQlzdHJ1Y3QgYWdueF9kZXNjICpkZXNjID0gcHJpdi0+dHhkLmRlc2MgKyBpZHg7Ci0Jc3RydWN0IGFnbnhfaW5mbyAqaW5mbyA9IHByaXYtPnR4ZC5pbmZvICsgaWR4OwotCi0JX190eF9kZXNjX2ZyZWUocHJpdiwgZGVzYywgaW5mbyk7Ci19Ci0KLWludCBmaWxsX3JpbmdzKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdW5zaWduZWQgaW50IGk7Ci0JdTMyIHJlZzsKLQlBR05YX1RSQUNFOwotCi0JcHJpdi0+dHhkLmlkeF9zZW50ID0gcHJpdi0+dHhtLmlkeF9zZW50ID0gMDsKLQlwcml2LT5yeC5pZHggPSBwcml2LT50eG0uaWR4ID0gcHJpdi0+dHhkLmlkeCA9IDA7Ci0KLQlmb3IgKGkgPSAwOyBpIDwgcHJpdi0+cnguc2l6ZTsgaSsrKQotCQlyeF9kZXNjX2luaXQocHJpdiwgaSk7Ci0JZm9yIChpID0gMDsgaSA8IHByaXYtPnR4bS5zaXplOyBpKyspIHsKLQkJbWVtc2V0KHByaXYtPnR4bS5kZXNjICsgaSwgMCwgc2l6ZW9mKHN0cnVjdCBhZ254X2Rlc2MpKTsKLQkJbWVtc2V0KHByaXYtPnR4bS5pbmZvICsgaSwgMCwgc2l6ZW9mKHN0cnVjdCBhZ254X2luZm8pKTsKLQl9Ci0JZm9yIChpID0gMDsgaSA8IHByaXYtPnR4ZC5zaXplOyBpKyspIHsKLQkJbWVtc2V0KHByaXYtPnR4ZC5kZXNjICsgaSwgMCwgc2l6ZW9mKHN0cnVjdCBhZ254X2Rlc2MpKTsKLQkJbWVtc2V0KHByaXYtPnR4ZC5pbmZvICsgaSwgMCwgc2l6ZW9mKHN0cnVjdCBhZ254X2luZm8pKTsKLQl9Ci0KLQkvKiBGSVhNRSBTZXQgdGhlIGNhcmQgUlggVFhNIGFuZCBUWEQgYWRkcmVzcyAqLwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX1JYQ01TVEFSVCwgcHJpdi0+cnguZG1hKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9SWENNRU5ELCBwcml2LT50eG0uZG1hKTsKLQotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX1RYTVNUQVJULCBwcml2LT50eG0uZG1hKTsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9UWE1FTkQsIHByaXYtPnR4ZC5kbWEpOwotCi0JYWdueF93cml0ZTMyKGN0bCwgQUdOWF9DSVJfVFhEU1RBUlQsIHByaXYtPnR4ZC5kbWEpOwotCWFnbnhfd3JpdGUzMihjdGwsIEFHTlhfQ0lSX1RYREVORCwgcHJpdi0+dHhkLmRtYSArCi0JCSAgICAgc2l6ZW9mKHN0cnVjdCBhZ254X2Rlc2MpICogcHJpdi0+dHhkLnNpemUpOwotCi0JLyogRklYTUUgUmVsaW5xdWlzaCBjb250cm9sIG9mIHJpbmdzIHRvIGNhcmQgKi8KLQlyZWcgPSBhZ254X3JlYWQzMihjdGwsIEFHTlhfQ0lSX0JMS0NUTCk7Ci0JcmVnICY9IH4weDgwMDsKLQlhZ254X3dyaXRlMzIoY3RsLCBBR05YX0NJUl9CTEtDVEwsIHJlZyk7Ci0JcmV0dXJuIDA7Ci19IC8qIGZpbGxfcmluZ3MgKi8KLQotdm9pZCB1bmZpbGxfcmluZ3Moc3RydWN0IGFnbnhfcHJpdiAqcHJpdikKLXsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCXVuc2lnbmVkIGludCBpOwotCUFHTlhfVFJBQ0U7Ci0KLQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwotCi0JZm9yIChpID0gMDsgaSA8IHByaXYtPnJ4LnNpemU7IGkrKykKLQkJcnhfZGVzY19mcmVlKHByaXYsIGkpOwotCWZvciAoaSA9IDA7IGkgPCBwcml2LT50eG0uc2l6ZTsgaSsrKQotCQl0eG1fZGVzY19mcmVlKHByaXYsIGkpOwotCWZvciAoaSA9IDA7IGkgPCBwcml2LT50eGQuc2l6ZTsgaSsrKQotCQl0eGRfZGVzY19mcmVlKHByaXYsIGkpOwotCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwotfQotCi0vKiBFeHRyYWN0IHRoZSBiaXRyYXRlIG91dCBvZiBhIENDSyBQTENQIGhlYWRlci4KLSAgIGNvcHkgZnJvbSBiY200M3h4IGRyaXZlciAqLwotc3RhdGljIGlubGluZSB1OCBhZ254X3BsY3BfZ2V0X2JpdHJhdGVfY2NrKF9fYmUzMiAqcGh5aGRyXzExYikKLXsKLQkvKiBGSVhNRSAqLwotCXN3aXRjaCAoKih1OCAqKXBoeWhkcl8xMWIpIHsKLQljYXNlIDB4MEE6Ci0JCXJldHVybiAwOwotCWNhc2UgMHgxNDoKLQkJcmV0dXJuIDE7Ci0JY2FzZSAweDM3OgotCQlyZXR1cm4gMjsKLQljYXNlIDB4NkU6Ci0JCXJldHVybiAzOwotCX0KLQlhZ254X2J1ZygiV3JvbmcgcGxjcCByYXRlIik7Ci0JcmV0dXJuIDA7Ci19Ci0KLS8qIEZJWE1FICovCi1zdGF0aWMgaW5saW5lIHU4IGFnbnhfcGxjcF9nZXRfYml0cmF0ZV9vZmRtKF9fYmUzMiAqcGh5aGRyXzExZykKLXsKLQl1OCByYXRlID0gKih1OCAqKXBoeWhkcl8xMWcgJiAweEY7Ci0KLQlwcmludGsoUEZYICJHIG1vZGUgcmF0ZSBpcyAweCV4XG4iLCByYXRlKTsKLQlyZXR1cm4gcmF0ZTsKLX0KLQotLyogRklYTUUgKi8KLXN0YXRpYyB2b2lkIGdldF9yeF9zdGF0cyhzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3QgYWdueF9oZHIgKmhkciwKLQkJCSBzdHJ1Y3QgaWVlZTgwMjExX3J4X3N0YXR1cyAqc3RhdCkKLXsKLQl2b2lkIF9faW9tZW0gKmN0bCA9IHByaXYtPmN0bDsKLQl1OCAqcnNzaTsKLQl1MzIgbm9pc2U7Ci0JLyogRklYTUUganVzdCBmb3IgdGVzdCAqLwotCWludCBzbnIgPSA0MDsJCS8qIHNpZ25hbC10by1ub2lzZSByYXRpbyAqLwotCi0JbWVtc2V0KHN0YXQsIDAsIHNpemVvZigqc3RhdCkpOwotCS8qIFJTU0kgKi8KLQlyc3NpID0gKHU4ICopJmhkci0+cGh5X3N0YXRzX2xvOwotLyoJc3RhdC0+c3NpID0gKHJzc2lbMF0gKyByc3NpWzFdICsgcnNzaVsyXSkgLyAzOyAqLwotCS8qIE5vaXNlICovCi0Jbm9pc2UgPSBpb3JlYWQzMihjdGwgKyBBR05YX0dDUl9OT0lTRTApOwotCW5vaXNlICs9IGlvcmVhZDMyKGN0bCArIEFHTlhfR0NSX05PSVNFMSk7Ci0Jbm9pc2UgKz0gaW9yZWFkMzIoY3RsICsgQUdOWF9HQ1JfTk9JU0UyKTsKLQlzdGF0LT5ub2lzZSA9IG5vaXNlIC8gMzsKLQkvKiBTaWduYWwgcXVhbGl0eSAqLwotLyoJc25yID0gc3RhdC0+c3NpIC0gc3RhdC0+bm9pc2U7ICovCi0JaWYgKHNuciA+PSAwICYmIHNuciA8IDQwKQotCQlzdGF0LT5zaWduYWwgPSA1ICogc25yIC8gMjsKLQllbHNlIGlmIChzbnIgPj0gNDApCi0JCXN0YXQtPnNpZ25hbCA9IDEwMDsKLQllbHNlCi0JCXN0YXQtPnNpZ25hbCA9IDA7Ci0KLQotCWlmIChoZHItPl8xMWIwICYmICFoZHItPl8xMWcwKSB7Ci0JCXN0YXQtPnJhdGVfaWR4ID0gYWdueF9wbGNwX2dldF9iaXRyYXRlX2NjaygmaGRyLT5fMTFiMCk7Ci0JfSBlbHNlIGlmICghaGRyLT5fMTFiMCAmJiBoZHItPl8xMWcwKSB7Ci0JCXByaW50ayhQRlggIlJYOiBGb3VuZCBHIG1vZGUgcGFja2V0XG4iKTsKLQkJc3RhdC0+cmF0ZV9pZHggPSBhZ254X3BsY3BfZ2V0X2JpdHJhdGVfb2ZkbSgmaGRyLT5fMTFnMCk7Ci0JfSBlbHNlCi0JCWFnbnhfYnVnKCJVbmtub3duIHBhY2tldHMgdHlwZSIpOwotCi0KLQlzdGF0LT5iYW5kID0gSUVFRTgwMjExX0JBTkRfMkdIWjsKLQlzdGF0LT5mcmVxID0gYWdueF9jaGFubmVsc1twcml2LT5jaGFubmVsIC0gMV0uY2VudGVyX2ZyZXE7Ci0vKglzdGF0LT5hbnRlbm5hID0gMzsKLQlzdGF0LT5tYWN0aW1lID0gYmUzMl90b19jcHUoaGRyLT50aW1lX3N0YW1wKTsKLQlzdGF0LT5jaGFubmVsID0gcHJpdi0+Y2hhbm5lbDsgKi8KLX0KLQotc3RhdGljIGlubGluZSB2b2lkIGNvbWJpbmVfaGRyX2ZyYWcoc3RydWN0IGllZWU4MDIxMV9oZHIgKmllZWVoZHIsCi0JCQkJICAgIHN0cnVjdCBza19idWZmICpza2IpCi17Ci0JdTE2IGZjdGw7Ci0JdW5zaWduZWQgaW50IGhkcmxlbjsKLQotCWZjdGwgPSBsZTE2X3RvX2NwdShpZWVlaGRyLT5mcmFtZV9jb250cm9sKTsKLQloZHJsZW4gPSBpZWVlODAyMTFfaGRybGVuKGZjdGwpOwotCS8qIEZJWE1FICovCi0JaWYgKGhkcmxlbiA8ICgyKzIrNikvKm1pbmltdW0gaGRyKi8gfHwKLQkgICAgaGRybGVuID4gc2l6ZW9mKHN0cnVjdCBpZWVlODAyMTFfbWdtdCkpIHsKLQkJcHJpbnRrKEtFUk5fRVJSIFBGWCAiaGRyIGxlbiBpcyAlZFxuIiwgaGRybGVuKTsKLQkJYWdueF9idWcoIldyb25nIGllZWU4MDIxMSBoZHIgZGV0ZWN0ZWQiKTsKLQl9Ci0Jc2tiX3B1c2goc2tiLCBoZHJsZW4pOwotCW1lbWNweShza2ItPmRhdGEsIGllZWVoZHIsIGhkcmxlbik7Ci19IC8qIGNvbWJpbmVfaGRyX2ZyYWcgKi8KLQotc3RhdGljIGlubGluZSBpbnQgYWdueF9wYWNrZXRfY2hlY2soc3RydWN0IGFnbnhfcHJpdiAqcHJpdiwgc3RydWN0IGFnbnhfaGRyICphZ254aGRyLAotCQkJCSAgICB1bnNpZ25lZCBwYWNrZXRfbGVuKQotewotCWlmIChhZ254X2dldF9iaXRzKENSQ19GQUlMLCBDUkNfRkFJTF9TSElGVCwgYmUzMl90b19jcHUoYWdueGhkci0+cmVnMSkpID09IDEpIHsKLQkJcHJpbnRrKFBGWCAiUlg6IENSQyBjaGVjayBmYWlsXG4iKTsKLQkJZ290byBkcm9wOwotCX0KLQlpZiAocGFja2V0X2xlbiA+IDIwNDgpIHsKLQkJcHJpbnRrKFBGWCAiUlg6IFRvbyBsb25nIHBhY2tldCBkZXRlY3RlZFxuIik7Ci0JCWdvdG8gZHJvcDsKLQl9Ci0KLQkvKiBGSVhNRSBKdXN0IHVzYWJsZSBmb3IgUHJvbWlvdXMgTW9kZSwgZm9yIE1hbmFnZSBtb2RlIGV4Y2x1ZGUgRkNTICovCi0vKiAJaWYgKHBhY2tldF9sZW4gLSBzaXplb2YoKmFnbnhoZHIpIDwgRkNTX0xFTikgeyAqLwotLyogCQlwcmludGsoUEZYICJSWDogVG9vIHNob3J0IHBhY2tldCBkZXRlY3RlZFxuIik7ICovCi0vKiAJCWdvdG8gZHJvcDsgKi8KLS8qIAl9ICovCi0JcmV0dXJuIDA7Ci1kcm9wOgotCXByaXYtPnN0YXRzLmRvdDExRkNTRXJyb3JDb3VudCsrOwotCXJldHVybiAtMTsKLX0KLQotdm9pZCBoYW5kbGVfcnhfaXJxKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0Jc3RydWN0IGllZWU4MDIxMV9yeF9zdGF0dXMgc3RhdHVzOwotCXVuc2lnbmVkIGludCBsZW47Ci0vKglBR05YX1RSQUNFOyAqLwotCi0JZG8gewotCQlzdHJ1Y3QgYWdueF9kZXNjICpkZXNjOwotCQl1MzIgZnJhZzsKLQkJc3RydWN0IGFnbnhfaW5mbyAqaW5mbzsKLQkJc3RydWN0IGFnbnhfaGRyICpoZHI7Ci0JCXN0cnVjdCBza19idWZmICpza2I7Ci0JCXVuc2lnbmVkIGludCBpID0gcHJpdi0+cnguaWR4ICUgcHJpdi0+cnguc2l6ZTsKLQotCQlkZXNjID0gcHJpdi0+cnguZGVzYyArIGk7Ci0JCWZyYWcgPSBiZTMyX3RvX2NwdShkZXNjLT5mcmFnKTsKLQkJaWYgKGZyYWcgJiBPV05FUikKLQkJCWJyZWFrOwotCi0JCWluZm8gPSBwcml2LT5yeC5pbmZvICsgaTsKLQkJc2tiID0gaW5mby0+c2tiOwotCQloZHIgPSAoc3RydWN0IGFnbnhfaGRyICopKHNrYi0+ZGF0YSk7Ci0KLQkJbGVuID0gKGZyYWcgJiBQQUNLRVRfTEVOKSA+PiBQQUNLRVRfTEVOX1NISUZUOwotCQlpZiAoYWdueF9wYWNrZXRfY2hlY2socHJpdiwgaGRyLCBsZW4pID09IC0xKSB7Ci0JCQlyeF9kZXNjX3JldXNpbmcocHJpdiwgaSk7Ci0JCQljb250aW51ZTsKLQkJfQotCQlza2JfcHV0KHNrYiwgbGVuKTsKLQotCQlkbyB7Ci0JCQkJdTE2IGZjdGw7Ci0JCQlmY3RsID0gbGUxNl90b19jcHUoKChzdHJ1Y3QgaWVlZTgwMjExX2hkciAqKWhkci0+bWFjX2hkciktPmZyYW1lX2NvbnRyb2wpOwotCQkJaWYgKChmY3RsICYgSUVFRTgwMjExX0ZDVExfU1RZUEUpICE9IElFRUU4MDIxMV9TVFlQRV9CRUFDT04pLyogJiYgIShmY3RsICYgSUVFRTgwMjExX1NUWVBFX0JFQUNPTikpICovCi0JCQkJZHVtcF9pZWVlODAyMTFfaGRyKChzdHJ1Y3QgaWVlZTgwMjExX2hkciAqKWhkci0+bWFjX2hkciwgIlJYIik7Ci0JCX0gd2hpbGUgKDApOwotCi0JCWlmIChoZHItPl8xMWIwICYmICFoZHItPl8xMWcwKSB7Ci0vKgkJCWludCBqOwotCQkJdTE2IGZjdGwgPSBsZTE2X3RvX2NwdSgoKHN0cnVjdCBpZWVlODAyMTFfaGRyICopaGRyLT5tYWNfaGRyKQotCQkJCQkgICAgICAgLT5mcmFtZV9jb250cm9sKTsKLQkJCWlmICggKGZjdGwgJiBJRUVFODAyMTFfRkNUTF9GVFlQRSkgPT0gIElFRUU4MDIxMV9GVFlQRV9EQVRBKSB7Ci0JCQkJYWdueF9wcmludF9yeF9oZHIoaGRyKTsKLQkJCQlhZ254X3ByaW50X3N0YShwcml2LCBCU1NJRF9TVEFJRCk7Ci0JCQkJZm9yIChqID0gMDsgaiA8IDg7IGorKykKLQkJCQkJYWdueF9wcmludF9zdGFfdHhfd3EocHJpdiwgQlNTSURfU1RBSUQsIGopOwotCQkJfSAqLwotCi0JCQlnZXRfcnhfc3RhdHMocHJpdiwgaGRyLCAmc3RhdHVzKTsKLQkJCXNrYl9wdWxsKHNrYiwgc2l6ZW9mKCpoZHIpKTsKLQkJCWNvbWJpbmVfaGRyX2ZyYWcoKHN0cnVjdCBpZWVlODAyMTFfaGRyICopaGRyLT5tYWNfaGRyLCBza2IpOwotCQl9IGVsc2UgaWYgKCFoZHItPl8xMWIwICYmIGhkci0+XzExZzApIHsKLS8qCQkJaW50IGo7ICovCi0JCQlhZ254X3ByaW50X3J4X2hkcihoZHIpOwotCQkJYWdueF9wcmludF9zdGEocHJpdiwgQlNTSURfU1RBSUQpOwotLyoJCQlmb3IgKGogPSAwOyBqIDwgODsgaisrKSAqLwotCQkJYWdueF9wcmludF9zdGFfdHhfd3EocHJpdiwgQlNTSURfU1RBSUQsIDApOwotCi0JCQlwcmludF9oZXhfZHVtcF9ieXRlcygiYWdueDogUlhfUEFDS0VUOiAiLCBEVU1QX1BSRUZJWF9OT05FLAotCQkJCQkgICAgIHNrYi0+ZGF0YSwgc2tiLT5sZW4gKyA4KTsKLQotLyoJCQlpZiAoYWdueF9wbGNwX2dldF9iaXRyYXRlX29mZG0oJmhkci0+XzExZzApID09IDApICovCi0JCQlnZXRfcnhfc3RhdHMocHJpdiwgaGRyLCAmc3RhdHVzKTsKLQkJCXNrYl9wdWxsKHNrYiwgc2l6ZW9mKCpoZHIpKTsKLQkJCWNvbWJpbmVfaGRyX2ZyYWcoKHN0cnVjdCBpZWVlODAyMTFfaGRyICopCi0JCQkJCSAoKHZvaWQgKikmaGRyLT5tYWNfaGRyKSwgc2tiKTsKLS8qCQkJZHVtcF9pZWVlODAyMTFfaGRyKChzdHJ1Y3QgaWVlZTgwMjExX2hkciAqKXNrYi0+ZGF0YSwgIlJYIEciKTsgKi8KLQkJfSBlbHNlCi0JCQlhZ254X2J1ZygiVW5rbm93biBwYWNrZXRzIHR5cGUiKTsKLQkJbWVtY3B5KElFRUU4MDIxMV9TS0JfUlhDQihza2IpLCAmc3RhdHVzLCBzaXplb2Yoc3RhdHVzKSk7Ci0JCWllZWU4MDIxMV9yeF9pcnFzYWZlKHByaXYtPmh3LCBza2IpOwotCQlyeF9kZXNjX3JlaW5pdChwcml2LCBpKTsKLQotCX0gd2hpbGUgKHByaXYtPnJ4LmlkeCsrKTsKLX0gLyogaGFuZGxlX3J4X2lycSAqLwotCi1zdGF0aWMgaW5saW5lIHZvaWQgaGFuZGxlX3R4X2lycShzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3QgYWdueF9yaW5nICpyaW5nKQotewotCXN0cnVjdCBhZ254X2Rlc2MgKmRlc2M7Ci0Jc3RydWN0IGFnbnhfaW5mbyAqaW5mbzsKLQl1bnNpZ25lZCBpbnQgaWR4OwotCi0JZm9yIChpZHggPSByaW5nLT5pZHhfc2VudDsgaWR4IDwgcmluZy0+aWR4OyBpZHgrKykgewotCQl1bnNpZ25lZCBpbnQgaSA9IGlkeCAlIHJpbmctPnNpemU7Ci0JCXUzMiAgZnJhZzsKLQotCQlkZXNjID0gcmluZy0+ZGVzYyArIGk7Ci0JCWluZm8gPSByaW5nLT5pbmZvICsgaTsKLQotCQlmcmFnID0gYmUzMl90b19jcHUoZGVzYy0+ZnJhZyk7Ci0JCWlmIChmcmFnICYgT1dORVIpIHsKLQkJCWlmIChpbmZvLT50eXBlID09IEhFQURFUikKLQkJCQlicmVhazsKLQkJCWVsc2UKLQkJCQlhZ254X2J1ZygiVFggZXJyb3IiKTsKLQkJfQotCi0JCXBjaV91bm1hcF9zaW5nbGUocHJpdi0+cGRldiwgaW5mby0+bWFwcGluZywgaW5mby0+ZG1hX2xlbiwgUENJX0RNQV9UT0RFVklDRSk7Ci0KLQkJZG8gewotLyoJCQlpbnQgajsgKi8KLQkJCXNpemVfdCBsZW47Ci0JCQlsZW4gPSBpbmZvLT5za2ItPmxlbiAtIHNpemVvZihzdHJ1Y3QgYWdueF9oZHIpICsgaW5mby0+aGRyX2xlbjsKLS8qCQkJaWYgKGxlbiA9PSA2MTQpIHsgKi8KLS8qCQkJCWFnbnhfcHJpbnRfZGVzYyhkZXNjKTsgKi8KLQkJCQlpZiAoaW5mby0+dHlwZSA9PSBQQUNLRVQpIHsKLS8qCQkJCQlhZ254X3ByaW50X3R4X2hkcigoc3RydWN0IGFnbnhfaGRyICopaW5mby0+c2tiLT5kYXRhKTsgKi8KLS8qCQkJCQlhZ254X3ByaW50X3N0YV9wb3dlcihwcml2LCBMT0NBTF9TVEFJRCk7ICovCi0vKgkJCQkJYWdueF9wcmludF9zdGEocHJpdiwgTE9DQUxfU1RBSUQpOyAqLwotLyoJCQkJCWZvciAoaiA9IDA7IGogPCA4OyBqKyspICovCi0vKgkJCQkJYWdueF9wcmludF9zdGFfdHhfd3EocHJpdiwgTE9DQUxfU1RBSUQsIDApOyAqLwotLyoJCQkJCWFnbnhfcHJpbnRfc3RhX3Bvd2VyKHByaXYsIEJTU0lEX1NUQUlEKTsgKi8KLS8qCQkJCQlhZ254X3ByaW50X3N0YShwcml2LCBCU1NJRF9TVEFJRCk7ICovCi0vKgkJCQkJZm9yIChqID0gMDsgaiA8IDg7IGorKykgKi8KLS8qCQkJCQlhZ254X3ByaW50X3N0YV90eF93cShwcml2LCBCU1NJRF9TVEFJRCwgMCk7ICovCi0JCQkJfQotLyoJCQl9ICovCi0JCX0gd2hpbGUgKDApOwotCi0JCWlmIChpbmZvLT50eXBlID09IFBBQ0tFVCkgewotLyoJCQlkdW1wX3R4bV9yZWdpc3RlcnMocHJpdik7Ci0JCQlkdW1wX3J4bV9yZWdpc3RlcnMocHJpdik7Ci0JCQlkdW1wX2JtX3JlZ2lzdGVycyhwcml2KTsKLQkJCWR1bXBfY2lyX3JlZ2lzdGVycyhwcml2KTsgKi8KLQkJfQotCi0JCWlmIChpbmZvLT50eXBlID09IFBBQ0tFVCkgewotLyoJCQlzdHJ1Y3QgaWVlZTgwMjExX2hkciAqaGRyOyAqLwotCQkJc3RydWN0IGllZWU4MDIxMV90eF9pbmZvICp0eGkgPSBJRUVFODAyMTFfU0tCX0NCKGluZm8tPnNrYik7Ci0KLQkJCXNrYl9wdWxsKGluZm8tPnNrYiwgc2l6ZW9mKHN0cnVjdCBhZ254X2hkcikpOwotCQkJbWVtY3B5KHNrYl9wdXNoKGluZm8tPnNrYiwgaW5mby0+aGRyX2xlbiksICZpbmZvLT5oZHIsIGluZm8tPmhkcl9sZW4pOwotCi0vKgkJCWR1bXBfaWVlZTgwMjExX2hkcigoc3RydWN0IGllZWU4MDIxMV9oZHIgKilpbmZvLT5za2ItPmRhdGEsICJUWF9IQU5ETEUiKTsgKi8KLS8qIAkJCXByaW50X2hleF9kdW1wX2J5dGVzKCJhZ254OiBUWF9IQU5ETEU6ICIsIERVTVBfUFJFRklYX05PTkUsICovCi0vKiAJCQkJCSAgICAgaW5mby0+c2tiLT5kYXRhLCBpbmZvLT5za2ItPmxlbik7ICovCi0KLQkJCWlmICghKHR4aS0+ZmxhZ3MgJiBJRUVFODAyMTFfVFhfQ1RMX05PX0FDSykpCi0JCQkJdHhpLT5mbGFncyB8PSBJRUVFODAyMTFfVFhfU1RBVF9BQ0s7Ci0KLQkJCWllZWU4MDIxMV90eF9zdGF0dXNfaXJxc2FmZShwcml2LT5odywgaW5mby0+c2tiKTsKLQotCi0vKiAJCQkJaW5mby0+dHhfc3RhdHVzLnF1ZXVlX251bWJlciA9IChyaW5nLT5zaXplIC0gaSkgLyAyOyAqLwotLyogCQkJCWllZWU4MDIxMV90eF9zdGF0dXNfaXJxc2FmZShwcml2LT5odywgaW5mby0+c2tiLCAmKGluZm8tPnR4X3N0YXR1cykpOyAqLwotLyogCQkJfSBlbHNlICovCi0vKiAJCQkJZGV2X2tmcmVlX3NrYl9pcnEoaW5mby0+c2tiKTsgKi8KLQkJfQotCQltZW1zZXQoZGVzYywgMCwgc2l6ZW9mKCpkZXNjKSk7Ci0JCW1lbXNldChpbmZvLCAwLCBzaXplb2YoKmluZm8pKTsKLQl9Ci0KLQlyaW5nLT5pZHhfc2VudCA9IGlkeDsKLQkvKiBUT0RPIGZpbGwgdGhlIHByaXYtPmxvd19sZXZlbF9zdGF0cyAqLwotCi0JLyogaWVlZTgwMjExX3dha2VfcXVldWUocHJpdi0+aHcsIDApOyAqLwotfQotCi12b2lkIGhhbmRsZV90eG1faXJxKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpCi17Ci0JaGFuZGxlX3R4X2lycShwcml2LCAmcHJpdi0+dHhtKTsKLX0KLQotdm9pZCBoYW5kbGVfdHhkX2lycShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotCWhhbmRsZV90eF9pcnEocHJpdiwgJnByaXYtPnR4ZCk7Ci19Ci0KLXZvaWQgaGFuZGxlX290aGVyX2lycShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KQotewotLyoJdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7ICovCi0JdTMyIHN0YXR1cyA9IHByaXYtPmlycV9zdGF0dXM7Ci0Jdm9pZCBfX2lvbWVtICpjdGwgPSBwcml2LT5jdGw7Ci0JdTMyIHJlZzsKLQotCWlmIChzdGF0dXMgJiBJUlFfVFhfQkVBQ09OKSB7Ci0JCWlvd3JpdGUzMihJUlFfVFhfQkVBQ09OLCBjdGwgKyBBR05YX0lOVF9TVEFUKTsKLQkJcHJpbnRrKFBGWCAiSVJROiBUWCBCZWFjb24gY29udHJvbCBpcyAwWCUuOFhcbiIsIGlvcmVhZDMyKGN0bCArIEFHTlhfVFhNX0JFQUNPTl9DVEwpKTsKLQkJcHJpbnRrKFBGWCAiSVJROiBUWCBCZWFjb24gcnggZnJhbWUgbnVtOiAlZFxuIiwgcnhfZnJhbWVfY250KTsKLQl9Ci0JaWYgKHN0YXR1cyAmIElSUV9UWF9SRVRSWSkgewotCQlyZWcgPSBpb3JlYWQzMihjdGwgKyBBR05YX1RYTV9SRVRSWVNUQUlEKTsKLQkJcHJpbnRrKFBGWCAiSVJROiBUWCBSZXRyeSwgUkVUUlkgU1RBIElEIGlzICV4XG4iLCByZWcpOwotCX0KLQlpZiAoc3RhdHVzICYgSVJRX1RYX0FDVElWSVRZKQotCQlwcmludGsoUEZYICJJUlE6IFRYIEFjdGl2aXR5XG4iKTsKLQlpZiAoc3RhdHVzICYgSVJRX1JYX0FDVElWSVRZKQotCQlwcmludGsoUEZYICJJUlE6IFJYIEFjdGl2aXR5XG4iKTsKLQlpZiAoc3RhdHVzICYgSVJRX1JYX1gpCi0JCXByaW50ayhQRlggIklSUTogUlggWFxuIik7Ci0JaWYgKHN0YXR1cyAmIElSUV9SWF9ZKSB7Ci0JCXJlZyA9IGlvcmVhZDMyKGN0bCArIEFHTlhfSU5UX01BU0spOwotCQlyZWcgJj0gfklSUV9SWF9ZOwotCQlpb3dyaXRlMzIocmVnLCBjdGwgKyBBR05YX0lOVF9NQVNLKTsKLQkJaW93cml0ZTMyKElSUV9SWF9ZLCBjdGwgKyBBR05YX0lOVF9TVEFUKTsKLQkJcHJpbnRrKFBGWCAiSVJROiBSWCBZXG4iKTsKLQl9Ci0JaWYgKHN0YXR1cyAmIElSUV9SWF9IQVNISElUKSAgewotCQlyZWcgPSBpb3JlYWQzMihjdGwgKyBBR05YX0lOVF9NQVNLKTsKLQkJcmVnICY9IH5JUlFfUlhfSEFTSEhJVDsKLQkJaW93cml0ZTMyKHJlZywgY3RsICsgQUdOWF9JTlRfTUFTSyk7Ci0JCWlvd3JpdGUzMihJUlFfUlhfSEFTSEhJVCwgY3RsICsgQUdOWF9JTlRfU1RBVCk7Ci0JCXByaW50ayhQRlggIklSUTogUlggSGFzaCBIaXRcbiIpOwotCi0JfQotCWlmIChzdGF0dXMgJiBJUlFfUlhfRlJBTUUpIHsKLQkJcmVnID0gaW9yZWFkMzIoY3RsICsgQUdOWF9JTlRfTUFTSyk7Ci0JCXJlZyAmPSB+SVJRX1JYX0ZSQU1FOwotCQlpb3dyaXRlMzIocmVnLCBjdGwgKyBBR05YX0lOVF9NQVNLKTsKLQkJaW93cml0ZTMyKElSUV9SWF9GUkFNRSwgY3RsICsgQUdOWF9JTlRfU1RBVCk7Ci0JCXByaW50ayhQRlggIklSUTogUlggRnJhbWVcbiIpOwotCQlyeF9mcmFtZV9jbnQrKzsKLQl9Ci0JaWYgKHN0YXR1cyAmIElSUV9FUlJfSU5UKSB7Ci0JCWlvd3JpdGUzMihJUlFfRVJSX0lOVCwgY3RsICsgQUdOWF9JTlRfU1RBVCk7Ci0vKgkJYWdueF9od19yZXNldChwcml2KTsgKi8KLQkJcHJpbnRrKFBGWCAiSVJROiBFcnJvciBJbnRlcnJ1cHRcbiIpOwotCX0KLQlpZiAoc3RhdHVzICYgSVJRX1RYX1FVRV9GVUxMKQotCQlwcmludGsoUEZYICJJUlE6IFRYIFdvcmtxdWV1ZSBGdWxsXG4iKTsKLQlpZiAoc3RhdHVzICYgSVJRX0JBTkRNQU5fRVJSKQotCQlwcmludGsoUEZYICJJUlE6IEJhbmR3aWR0aCBNYW5hZ2VtZW50IEVycm9yXG4iKTsKLQlpZiAoc3RhdHVzICYgSVJRX1RYX0RJU0FCTEUpCi0JCXByaW50ayhQRlggIklSUTogVFggRGlzYWJsZVxuIik7Ci0JaWYgKHN0YXR1cyAmIElSUV9SWF9JVkFTRVNLRVkpCi0JCXByaW50ayhQRlggIklSUTogUlggSW52YWxpZCBTZXNzaW9uIEtleVxuIik7Ci0JaWYgKHN0YXR1cyAmIElSUV9SRVBfVEhISVQpCi0JCXByaW50ayhQRlggIklSUTogUmVwbGF5IFRocmVzaG9sZCBIaXRcbiIpOwotCWlmIChzdGF0dXMgJiBJUlFfVElNRVIxKQotCQlwcmludGsoUEZYICJJUlE6IFRpbWVyMVxuIik7Ci0JaWYgKHN0YXR1cyAmIElSUV9USU1FUl9DTlQpCi0JCXByaW50ayhQRlggIklSUTogVGltZXIgQ291bnRcbiIpOwotCWlmIChzdGF0dXMgJiBJUlFfUEhZX0ZBU1RJTlQpCi0JCXByaW50ayhQRlggIklSUTogUGh5IEZhc3QgSW50ZXJydXB0XG4iKTsKLQlpZiAoc3RhdHVzICYgSVJRX1BIWV9TTE9XSU5UKQotCQlwcmludGsoUEZYICJJUlE6IFBoeSBTbG93IEludGVycnVwdFxuIik7Ci0JaWYgKHN0YXR1cyAmIElSUV9PVEhFUikKLQkJcHJpbnRrKFBGWCAiSVJROiAweDgwMDAwMDAwXG4iKTsKLX0gLyogaGFuZGxlX290aGVyX2lycSAqLwotCi0KLXN0YXRpYyBpbmxpbmUgdm9pZCByb3V0ZV9mbGFnX3NldChzdHJ1Y3QgYWdueF9oZHIgKnR4aGRyKQotewotLyoJdTMyIHJlZyA9IDA7ICovCi0KLQkvKiBGSVhNRSAqLwotLyoJcmVnID0gKDB4NyA8PCBST1VURV9DT01QUkVTU0lPTl9TSElGVCkgJiBST1VURV9DT01QUkVTU0lPTjsgKi8KLS8qCXR4aGRyLT5yZWc1ID0gY3B1X3RvX2JlMzIocmVnKTsgKi8KLQl0eGhkci0+cmVnNSA9ICgweGEgPDwgMHgwKSB8ICgweDcgPDwgMHgxOCk7Ci0vKgl0eGhkci0+cmVnNSA9IGNwdV90b19iZTMyKCgweGEgPDwgMHgwKSB8ICgweDcgPDwgMHgxOCkpOyAqLwotLyoJdHhoZHItPnJlZzUgPSBjcHVfdG9fYmUzMigweDcgPDwgMHgwKTsgKi8KLX0KLQotLyogUmV0dXJuIDAgaWYgbm8gbWF0Y2ggKi8KLXN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IGdldF9wb3dlcl9sZXZlbCh1bnNpZ25lZCBpbnQgcmF0ZSwgdW5zaWduZWQgaW50IGFudGVubmFzX251bSkKLXsKLQl1bnNpZ25lZCBpbnQgcG93ZXJfbGV2ZWw7Ci0KLQlzd2l0Y2ggKHJhdGUpIHsKLQljYXNlIDEwOgotCWNhc2UgMjA6Ci0JY2FzZSA1NToKLQljYXNlIDYwOgotCWNhc2UgOTA6Ci0JY2FzZSAxMjA6Ci0JCXBvd2VyX2xldmVsID0gMjI7Ci0JCWJyZWFrOwotCi0JY2FzZSAxODA6Ci0JCXBvd2VyX2xldmVsID0gMTk7Ci0JCWJyZWFrOwotCi0JY2FzZSAyNDA6Ci0JCXBvd2VyX2xldmVsID0gMTg7Ci0JCWJyZWFrOwotCi0JY2FzZSAzNjA6Ci0JCXBvd2VyX2xldmVsID0gMTY7Ci0JCWJyZWFrOwotCi0JY2FzZSA0ODA6Ci0JCXBvd2VyX2xldmVsID0gMTU7Ci0JCWJyZWFrOwotCi0JY2FzZSA1NDA6Ci0JCXBvd2VyX2xldmVsID0gMTQ7Ci0JCWJyZWFrOwotCWRlZmF1bHQ6Ci0JCWFnbnhfYnVnKCJFcnJvciByYXRlIHNldHRpbmdcbiIpOwotCX0KLQotCWlmIChwb3dlcl9sZXZlbCAmJiAoYW50ZW5uYXNfbnVtID09IDIpKQotCQlwb3dlcl9sZXZlbCAtPSAzOwotCi0JcmV0dXJuIHBvd2VyX2xldmVsOwotfQotCi1zdGF0aWMgaW5saW5lIHZvaWQgZmlsbF9hZ254X2hkcihzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3QgYWdueF9pbmZvICp0eF9pbmZvKQotewotCXN0cnVjdCBhZ254X2hkciAqdHhoZHIgPSAoc3RydWN0IGFnbnhfaGRyICopdHhfaW5mby0+c2tiLT5kYXRhOwotCXNpemVfdCBsZW47Ci0JdTE2IGZjID0gbGUxNl90b19jcHUoKihfX2xlMTYgKikmdHhfaW5mby0+aGRyKTsKLQl1MzIgcmVnOwotCi0JbWVtc2V0KHR4aGRyLCAwLCBzaXplb2YoKnR4aGRyKSk7Ci0KLS8qCXJlZyA9IGFnbnhfc2V0X2JpdHMoU1RBVElPTl9JRCwgU1RBVElPTl9JRF9TSElGVCwgTE9DQUxfU1RBSUQpOyAqLwotCXJlZyA9IGFnbnhfc2V0X2JpdHMoU1RBVElPTl9JRCwgU1RBVElPTl9JRF9TSElGVCwgQlNTSURfU1RBSUQpOwotCXJlZyB8PSBhZ254X3NldF9iaXRzKFdPUktRVUVVRV9JRCwgV09SS1FVRVVFX0lEX1NISUZULCAwKTsKLQl0eGhkci0+cmVnNCA9IGNwdV90b19iZTMyKHJlZyk7Ci0KLQkvKiBTZXQgdGhlIEhhcmR3YXJlIFNlcXVlbmNlIE51bWJlciB0byAxPyAqLwotCXJlZyA9IGFnbnhfc2V0X2JpdHMoU0VRVUVOQ0VfTlVNQkVSLCBTRVFVRU5DRV9OVU1CRVJfU0hJRlQsIDApOwotLyoJcmVnID0gYWdueF9zZXRfYml0cyhTRVFVRU5DRV9OVU1CRVIsIFNFUVVFTkNFX05VTUJFUl9TSElGVCwgMSk7ICovCi0JcmVnIHw9IGFnbnhfc2V0X2JpdHMoTUFDX0hEUl9MRU4sIE1BQ19IRFJfTEVOX1NISUZULCB0eF9pbmZvLT5oZHJfbGVuKTsKLQl0eGhkci0+cmVnMSA9IGNwdV90b19iZTMyKHJlZyk7Ci0JLyogU2V0IHRoZSBhZ254X2hkcidzIE1BQyBoZWFkZXIgKi8KLQltZW1jcHkodHhoZHItPm1hY19oZHIsICZ0eF9pbmZvLT5oZHIsIHR4X2luZm8tPmhkcl9sZW4pOwotCi0JcmVnID0gYWdueF9zZXRfYml0cyhBQ0ssIEFDS19TSElGVCwgMSk7Ci0vKglyZWcgPSBhZ254X3NldF9iaXRzKEFDSywgQUNLX1NISUZULCAwKTsgKi8KLQlyZWcgfD0gYWdueF9zZXRfYml0cyhNVUxUSUNBU1QsIE1VTFRJQ0FTVF9TSElGVCwgMCk7Ci0vKglyZWcgfD0gYWdueF9zZXRfYml0cyhNVUxUSUNBU1QsIE1VTFRJQ0FTVF9TSElGVCwgMSk7ICovCi0JcmVnIHw9IGFnbnhfc2V0X2JpdHMoUkVMQVksIFJFTEFZX1NISUZULCAwKTsKLQlyZWcgfD0gYWdueF9zZXRfYml0cyhUTSwgVE1fU0hJRlQsIDApOwotCXR4aGRyLT5yZWcwID0gY3B1X3RvX2JlMzIocmVnKTsKLQotCS8qIFNldCB0aGUgbG9uZyBhbmQgc2hvcnQgcmV0cnkgbGltaXRzICovCi0JdHhoZHItPnR4LnNob3J0X3JldHJ5X2xpbWl0ID0gdHhfaW5mby0+dHhpLT5jb250cm9sLnJhdGVzWzBdLmNvdW50OwotCXR4aGRyLT50eC5sb25nX3JldHJ5X2xpbWl0ID0gdHhfaW5mby0+dHhpLT5jb250cm9sLnJhdGVzWzBdLmNvdW50OwotCi0JLyogRklYTUUgKi8KLQlsZW4gPSB0eF9pbmZvLT5za2ItPmxlbiAtIHNpemVvZigqdHhoZHIpICsgdHhfaW5mby0+aGRyX2xlbiArIEZDU19MRU47Ci0JaWYgKGZjICYgSUVFRTgwMjExX0ZDVExfUFJPVEVDVEVEKQotCQlsZW4gKz0gODsKLQlsZW4gPSAyMzk4OwotCXJlZyA9IGFnbnhfc2V0X2JpdHMoRlJBR19TSVpFLCBGUkFHX1NJWkVfU0hJRlQsIGxlbik7Ci0JbGVuID0gdHhfaW5mby0+c2tiLT5sZW4gLSBzaXplb2YoKnR4aGRyKTsKLQlyZWcgfD0gYWdueF9zZXRfYml0cyhQQVlMT0FEX0xFTiwgUEFZTE9BRF9MRU5fU0hJRlQsIGxlbik7Ci0JdHhoZHItPnJlZzMgPSBjcHVfdG9fYmUzMihyZWcpOwotCi0Jcm91dGVfZmxhZ19zZXQodHhoZHIpOwotfSAvKiBmaWxsX2hkciAqLwotCi1zdGF0aWMgdm9pZCB0eG1fcG93ZXJfc2V0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYsCi0JCQkgIHN0cnVjdCBpZWVlODAyMTFfdHhfaW5mbyAqdHhpKQotewotCXN0cnVjdCBhZ254X3N0YV9wb3dlciBwb3dlcjsKLQl1MzIgcmVnOwotCi0JLyogRklYTUUgKi8KLQlpZiAodHhpLT5jb250cm9sLnJhdGVzWzBdLmlkeCA8IDApIHsKLQkJLyogRm9yIEIgbW9kZSBTaG9ydCBQcmVhbWJsZSAqLwotCQlyZWcgPSBhZ254X3NldF9iaXRzKFBIWV9NT0RFLCBQSFlfTU9ERV9TSElGVCwgQUdOWF9NT0RFXzgwMjExQl9TSE9SVCk7Ci0vKgkJY29udHJvbC0+dHhfcmF0ZSA9IC1jb250cm9sLT50eF9yYXRlOyAqLwotCX0gZWxzZQotCQlyZWcgPSBhZ254X3NldF9iaXRzKFBIWV9NT0RFLCBQSFlfTU9ERV9TSElGVCwgQUdOWF9NT0RFXzgwMjExRyk7Ci0vKgkJcmVnID0gYWdueF9zZXRfYml0cyhQSFlfTU9ERSwgUEhZX01PREVfU0hJRlQsIEFHTlhfTU9ERV84MDIxMUJfTE9ORyk7ICovCi0JcmVnIHw9IGFnbnhfc2V0X2JpdHMoU0lHTkFMLCBTSUdOQUxfU0hJRlQsIDB4Qik7Ci0JcmVnIHw9IGFnbnhfc2V0X2JpdHMoUkFURSwgUkFURV9TSElGVCwgMHhCKTsKLS8qCXJlZyB8PSBhZ254X3NldF9iaXRzKFBPV0VSX0xFVkVMLCBQT1dFUl9MRVZFTF9TSElGVCwgMTUpOyAqLwotCXJlZyB8PSBhZ254X3NldF9iaXRzKFBPV0VSX0xFVkVMLCBQT1dFUl9MRVZFTF9TSElGVCwgMjApOwotCS8qIGlmIHJhdGUgPCAxMU0gc2V0IGl0IHRvIDAgKi8KLQlyZWcgfD0gYWdueF9zZXRfYml0cyhOVU1fVFJBTlNNSVRURVJTLCBOVU1fVFJBTlNNSVRURVJTX1NISUZULCAxKTsKLS8qCXJlZyB8PSBhZ254X3NldF9iaXRzKEVEQ0YsIEVEQ0ZfU0hJRlQsIDEpOyAqLwotLyoJcmVnIHw9IGFnbnhfc2V0X2JpdHMoVElGUywgVElGU19TSElGVCwgMSk7ICovCi0KLQlwb3dlci5yZWcgPSByZWc7Ci0vKglwb3dlci5yZWcgPSBjcHVfdG9fbGUzMihyZWcpOyAqLwotCi0vKglzZXRfc3RhX3Bvd2VyKHByaXYsICZwb3dlciwgTE9DQUxfU1RBSUQpOyAqLwotCXNldF9zdGFfcG93ZXIocHJpdiwgJnBvd2VyLCBCU1NJRF9TVEFJRCk7Ci19Ci0KLXN0YXRpYyBpbmxpbmUgaW50IHR4X3BhY2tldF9jaGVjayhzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQotewotCXVuc2lnbmVkIGludCBpZWVlX2xlbiA9IGllZWU4MDIxMV9nZXRfaGRybGVuX2Zyb21fc2tiKHNrYik7Ci0JaWYgKHNrYi0+bGVuID4gMjA0OCkgewotCQlwcmludGsoS0VSTl9FUlIgUEZYICJsZW5ndGggaXMgJWRcbiIsIHNrYi0+bGVuKTsKLQkJYWdueF9idWcoIlRvbyBsb25nIFRYIHNrYiIpOwotCQlyZXR1cm4gLTE7Ci0JfQotCS8qIEZJWE1FICovCi0JaWYgKHNrYi0+bGVuID09IGllZWVfbGVuKSB7Ci0JCXByaW50ayhQRlggIkEgc3RyYW5nZSBUWCBwYWNrZXRcbiIpOwotCQlyZXR1cm4gLTE7Ci0JCS8qIHR4X2ZhaWxlX2lycXNhZmUoKTsgKi8KLQl9Ci0JcmV0dXJuIDA7Ci19Ci0KLXN0YXRpYyBpbnQgX19hZ254X3R4KHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHN0cnVjdCBza19idWZmICpza2IsCi0JCSAgICAgc3RydWN0IGFnbnhfcmluZyAqcmluZykKLXsKLQlzdHJ1Y3QgYWdueF9kZXNjICpoZHJfZGVzYywgKmZyYWdfZGVzYzsKLQlzdHJ1Y3QgYWdueF9pbmZvICpoZHJfaW5mbywgKmZyYWdfaW5mbzsKLQlzdHJ1Y3QgaWVlZTgwMjExX3R4X2luZm8gKnR4aSA9IElFRUU4MDIxMV9TS0JfQ0Ioc2tiKTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwotCXVuc2lnbmVkIGludCBpOwotCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKLQotCS8qIFRoZSBSWCBpbnRlcnJ1cHQgbmVlZCBiZSBEaXNhYmxlIHVudGlsIHRoaXMgVFggcGFja2V0Ci0JICAgaXMgaGFuZGxlZCBpbiB0aGUgbmV4dCB0eCBpbnRlcnJ1cHQgKi8KLQlkaXNhYmxlX3J4X2ludGVycnVwdChwcml2KTsKLQotCWkgPSByaW5nLT5pZHg7Ci0JcmluZy0+aWR4ICs9IDI7Ci0vKiAgIAlpZiAocHJpdi0+dHhtX2lkeCAtIHByaXYtPnR4bV9pZHhfc2VudCA9PSBBR05YX1RYTV9SSU5HX1NJWkUgLSAyKSAqLwotLyogCQlpZWVlODAyMTFfc3RvcF9xdWV1ZShwcml2LT5odywgMCk7ICovCi0KLQkvKiBTZXQgYWdueCBoZWFkZXIncyBpbmZvIGFuZCBkZXNjICovCi0JaSAlPSByaW5nLT5zaXplOwotCWhkcl9kZXNjID0gcmluZy0+ZGVzYyArIGk7Ci0JaGRyX2luZm8gPSByaW5nLT5pbmZvICsgaTsKLQloZHJfaW5mby0+aGRyX2xlbiA9IGllZWU4MDIxMV9nZXRfaGRybGVuX2Zyb21fc2tiKHNrYik7Ci0JbWVtY3B5KCZoZHJfaW5mby0+aGRyLCBza2ItPmRhdGEsIGhkcl9pbmZvLT5oZHJfbGVuKTsKLQotCS8qIEFkZCB0aGUgYWdueCBoZWFkZXIgdG8gdGhlIGZyb250IG9mIHRoZSBTS0IgKi8KLQlza2JfcHVzaChza2IsIHNpemVvZihzdHJ1Y3QgYWdueF9oZHIpIC0gaGRyX2luZm8tPmhkcl9sZW4pOwotCi0JaGRyX2luZm8tPnR4aSA9IHR4aTsKLQloZHJfaW5mby0+ZG1hX2xlbiA9IHNpemVvZihzdHJ1Y3QgYWdueF9oZHIpOwotCWhkcl9pbmZvLT5za2IgPSBza2I7Ci0JaGRyX2luZm8tPnR5cGUgPSBIRUFERVI7Ci0JZmlsbF9hZ254X2hkcihwcml2LCBoZHJfaW5mbyk7Ci0JaGRyX2luZm8tPm1hcHBpbmcgPSBwY2lfbWFwX3NpbmdsZShwcml2LT5wZGV2LCBza2ItPmRhdGEsCi0JCQkJCSAgIGhkcl9pbmZvLT5kbWFfbGVuLCBQQ0lfRE1BX1RPREVWSUNFKTsKLQlkbyB7Ci0JCXUzMiBmcmFnID0gMDsKLQkJZnJhZyB8PSBhZ254X3NldF9iaXRzKEZJUlNUX0ZSQUcsIEZJUlNUX0ZSQUdfU0hJRlQsIDEpOwotCQlmcmFnIHw9IGFnbnhfc2V0X2JpdHMoTEFTVF9GUkFHLCBMQVNUX0ZSQUdfU0hJRlQsIDApOwotCQlmcmFnIHw9IGFnbnhfc2V0X2JpdHMoUEFDS0VUX0xFTiwgUEFDS0VUX0xFTl9TSElGVCwgc2tiLT5sZW4pOwotCQlmcmFnIHw9IGFnbnhfc2V0X2JpdHMoRklSU1RfRlJBR19MRU4sIEZJUlNUX0ZSQUdfTEVOX1NISUZULCAxKTsKLQkJZnJhZyB8PSBhZ254X3NldF9iaXRzKE9XTkVSLCBPV05FUl9TSElGVCwgMSk7Ci0JCWhkcl9kZXNjLT5mcmFnID0gY3B1X3RvX2JlMzIoZnJhZyk7Ci0JfSB3aGlsZSAoMCk7Ci0JaGRyX2Rlc2MtPmRtYV9hZGRyID0gY3B1X3RvX2JlMzIoaGRyX2luZm8tPm1hcHBpbmcpOwotCi0KLQkvKiBTZXQgRnJhZydzIGluZm8gYW5kIGRlc2MgKi8KLQlpID0gKGkgKyAxKSAlIHJpbmctPnNpemU7Ci0JZnJhZ19kZXNjID0gcmluZy0+ZGVzYyArIGk7Ci0JZnJhZ19pbmZvID0gcmluZy0+aW5mbyArIGk7Ci0JbWVtY3B5KGZyYWdfaW5mbywgaGRyX2luZm8sIHNpemVvZihzdHJ1Y3QgYWdueF9pbmZvKSk7Ci0JZnJhZ19pbmZvLT50eXBlID0gUEFDS0VUOwotCWZyYWdfaW5mby0+ZG1hX2xlbiA9IHNrYi0+bGVuIC0gaGRyX2luZm8tPmRtYV9sZW47Ci0JZnJhZ19pbmZvLT5tYXBwaW5nID0gcGNpX21hcF9zaW5nbGUocHJpdi0+cGRldiwgc2tiLT5kYXRhICsgaGRyX2luZm8tPmRtYV9sZW4sCi0JCQkJCSAgICBmcmFnX2luZm8tPmRtYV9sZW4sIFBDSV9ETUFfVE9ERVZJQ0UpOwotCWRvIHsKLQkJdTMyIGZyYWcgPSAwOwotCQlmcmFnIHw9IGFnbnhfc2V0X2JpdHMoRklSU1RfRlJBRywgRklSU1RfRlJBR19TSElGVCwgMCk7Ci0JCWZyYWcgfD0gYWdueF9zZXRfYml0cyhMQVNUX0ZSQUcsIExBU1RfRlJBR19TSElGVCwgMSk7Ci0JCWZyYWcgfD0gYWdueF9zZXRfYml0cyhQQUNLRVRfTEVOLCBQQUNLRVRfTEVOX1NISUZULCBza2ItPmxlbik7Ci0JCWZyYWcgfD0gYWdueF9zZXRfYml0cyhTVUJfRlJBR19MRU4sIFNVQl9GUkFHX0xFTl9TSElGVCwgZnJhZ19pbmZvLT5kbWFfbGVuKTsKLQkJZnJhZ19kZXNjLT5mcmFnID0gY3B1X3RvX2JlMzIoZnJhZyk7Ci0JfSB3aGlsZSAoMCk7Ci0JZnJhZ19kZXNjLT5kbWFfYWRkciA9IGNwdV90b19iZTMyKGZyYWdfaW5mby0+bWFwcGluZyk7Ci0KLQl0eG1fcG93ZXJfc2V0KHByaXYsIHR4aSk7Ci0KLS8qCWRvIHsgKi8KLS8qCQlpbnQgajsgKi8KLS8qCQlzaXplX3QgbGVuOyAqLwotLyoJCWxlbiA9IHNrYi0+bGVuIC0gaGRyX2luZm8tPmRtYV9sZW4gKyBoZHJfaW5mby0+aGRyX2xlbjsgICovCi0vKgkJaWYgKGxlbiA9PSA2MTQpIHsgKi8KLS8qCQkJYWdueF9wcmludF9kZXNjKGhkcl9kZXNjKTsgKi8KLS8qCQkJYWdueF9wcmludF9kZXNjKGZyYWdfZGVzYyk7ICovCi0vKgkJCWFnbnhfcHJpbnRfdHhfaGRyKChzdHJ1Y3QgYWdueF9oZHIgKilza2ItPmRhdGEpOyAqLwotLyoJCQlhZ254X3ByaW50X3N0YV9wb3dlcihwcml2LCBMT0NBTF9TVEFJRCk7ICovCi0vKgkJCWFnbnhfcHJpbnRfc3RhKHByaXYsIExPQ0FMX1NUQUlEKTsgKi8KLS8qCQkJZm9yIChqID0gMDsgaiA8IDg7IGorKykgKi8KLS8qCQkJCWFnbnhfcHJpbnRfc3RhX3R4X3dxKHByaXYsIExPQ0FMX1NUQUlELCBqKTsgKi8KLS8qCQkJYWdueF9wcmludF9zdGFfcG93ZXIocHJpdiwgQlNTSURfU1RBSUQpOyAqLwotLyoJCQlhZ254X3ByaW50X3N0YShwcml2LCBCU1NJRF9TVEFJRCk7ICovCi0vKgkJCWZvciAoaiA9IDA7IGogPCA4OyBqKyspICovCi0vKgkJCQlhZ254X3ByaW50X3N0YV90eF93cShwcml2LCBCU1NJRF9TVEFJRCwgaik7ICovCi0vKgkJCX0gKi8KLS8qCX0gd2hpbGUgKDApOyAqLwotCi0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+bG9jaywgZmxhZ3MpOwotCi0JLyogRklYTUUgdWdseSBjb2RlICovCi0JLyogVHJpZ2dlciBUWE0gKi8KLQlkbyB7Ci0JCXUzMiByZWc7Ci0JCXJlZyA9IChpb3JlYWQzMihwcml2LT5jdGwgKyBBR05YX0NJUl9UWE1DVEwpKTsKLQkJcmVnIHw9IDB4ODsKLQkJaW93cml0ZTMyKChyZWcpLCBwcml2LT5jdGwgKyBBR05YX0NJUl9UWE1DVEwpOwotCX0gd2hpbGUgKDApOwotCi0JLyogVHJpZ2dlciBUWEQgKi8KLQlkbyB7Ci0JCXUzMiByZWc7Ci0JCXJlZyA9IChpb3JlYWQzMihwcml2LT5jdGwgKyBBR05YX0NJUl9UWERDVEwpKTsKLQkJcmVnIHw9IDB4ODsKLQkJaW93cml0ZTMyKChyZWcpLCBwcml2LT5jdGwgKyBBR05YX0NJUl9UWERDVEwpOwotCX0gd2hpbGUgKDApOwotCi0JcmV0dXJuIDA7Ci19Ci0KLWludCBfYWdueF90eChzdHJ1Y3QgYWdueF9wcml2ICpwcml2LCBzdHJ1Y3Qgc2tfYnVmZiAqc2tiKQotewotCXUxNiBmY3RsOwotCi0JaWYgKHR4X3BhY2tldF9jaGVjayhza2IpKQotCQlyZXR1cm4gMDsKLQotLyoJcHJpbnRfaGV4X2R1bXBfYnl0ZXMoImFnbng6IFRYX1BBQ0tFVDogIiwgRFVNUF9QUkVGSVhfTk9ORSwgKi8KLS8qCQkJICAgICBza2ItPmRhdGEsIHNrYi0+bGVuKTsgKi8KLQotCWZjdGwgPSBsZTE2X3RvX2NwdSgqKChfX2xlMTYgKilza2ItPmRhdGEpKTsKLQotCWlmICgoZmN0bCAmIElFRUU4MDIxMV9GQ1RMX0ZUWVBFKSA9PSBJRUVFODAyMTFfRlRZUEVfREFUQSkKLQkJcmV0dXJuIF9fYWdueF90eChwcml2LCBza2IsICZwcml2LT50eGQpOwotCWVsc2UKLQkJcmV0dXJuIF9fYWdueF90eChwcml2LCBza2IsICZwcml2LT50eG0pOwotfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2FnbngveG1pdC5oIGIvZHJpdmVycy9zdGFnaW5nL2FnbngveG1pdC5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5M2FjNDE1Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9hZ254L3htaXQuaAorKysgL2Rldi9udWxsCkBAIC0xLDI1MCArMCwwIEBACi0jaWZuZGVmIEFHTlhfWE1JVF9IXwotI2RlZmluZSBBR05YX1hNSVRfSF8KLQotI2luY2x1ZGUgPG5ldC9tYWM4MDIxMS5oPgotCi1zdHJ1Y3QgYWdueF9wcml2OwotCi1zdGF0aWMgaW5saW5lIHUzMiBhZ254X3NldF9iaXRzKHUzMiBtYXNrLCB1OCBzaGlmdCwgdTMyIHZhbHVlKQotewotCXJldHVybiAodmFsdWUgPDwgc2hpZnQpICYgbWFzazsKLX0KLQotc3RhdGljIGlubGluZSB1MzIgYWdueF9nZXRfYml0cyh1MzIgbWFzaywgdTggc2hpZnQsIHUzMiB2YWx1ZSkKLXsKLQlyZXR1cm4gKHZhbHVlICYgbWFzaykgPj4gc2hpZnQ7Ci19Ci0KLQotc3RydWN0IGFnbnhfcnggewotCV9fYmUxNiByeF9wYWNrZXRfZHVyYXRpb247IC8qICBSWCBQYWNrZXQgRHVyYXRpb24gKi8KLQlfX2JlMTYgcmVwbGF5X2NudDsJLyogUmVwbGF5IENvdW50ICovCi19IF9fYXR0cmlidXRlX18oKF9fcGFja2VkX18pKTsKLQotCi1zdHJ1Y3QgYWdueF90eCB7Ci0JdTggbG9uZ19yZXRyeV9saW1pdDsgLyogTG9uZyBSZXRyeSBMaW1pdCAqLwotCXU4IHNob3J0X3JldHJ5X2xpbWl0OyAvKiBTaG9ydCBSZXRyeSBMaW1pdCAqLwotCXU4IGxvbmdfcmV0cnlfY250OwkvKiBMb25nIFJldHJ5IENvdW50ICovCi0JdTggc2hvcnRfcmV0cnlfY250OyAvKiBTaG9ydCBSZXRyeSBDb3VudCAqLwotfSBfX2F0dHJpYnV0ZV9fKChfX3BhY2tlZF9fKSk7Ci0KLQotLyogQ29weSBmcm9tIGJjbTQzeHggKi8KLSNkZWZpbmUgUDREX0JZVDNTKG1hZ2ljLCBucl9ieXRlcykgICAgICB1OCBfX3A0ZGRpbmcjI21hZ2ljW25yX2J5dGVzXQotI2RlZmluZSBQNERfQllURVMobGluZSwgbnJfYnl0ZXMpICAgICAgIFA0RF9CWVQzUyhsaW5lLCBucl9ieXRlcykKLSNkZWZpbmUgUEFEX0JZVEVTKG5yX2J5dGVzKSAgICAgICAgICAgICBQNERfQllURVMoX19MSU5FX18sIG5yX2J5dGVzKQotCi0jZGVmaW5lIFA0RF9CSVQzUyhtYWdpYywgbnJfYml0cykgICAgICAgX19iZTMyIF9fcGFkZGluZyMjbWFnaWM6bnJfYml0cwotI2RlZmluZSBQNERfQklUUyhsaW5lLCBucl9iaXRzKSAgICAgICAgIFA0RF9CSVQzUyhsaW5lLCBucl9iaXRzKQotI2RlZmluZSBQQURfQklUUyhucl9iaXRzKQkgICAgICAgIFA0RF9CSVRTKF9fTElORV9fLCBucl9iaXRzKQotCi0KLXN0cnVjdCBhZ254X2hkciB7Ci0JX19iZTMyIHJlZzA7Ci0jZGVmaW5lIFJUUwkJICAgICAgICAweDgwMDAwMDAwIC8qIFJUUyAqLwotI2RlZmluZSBSVFNfU0hJRlQJCTMxCi0jZGVmaW5lIE1VTFRJQ0FTVAkgICAgICAgIDB4NDAwMDAwMDAgLyogbXVsdGljYXN0ICovCi0jZGVmaW5lIE1VTFRJQ0FTVF9TSElGVAkJMzAKLSNkZWZpbmUgQUNLCQkJMHgzMDAwMDAwMCAvKiBBQ0sgKi8KLSNkZWZpbmUgQUNLX1NISUZUCQkyOAotI2RlZmluZSBUTQkJCTB4MDgwMDAwMDAgLyogVE0gKi8KLSNkZWZpbmUgVE1fU0hJRlQJCTI3Ci0jZGVmaW5lIFJFTEFZCQkJMHgwNDAwMDAwMCAvKiBSZWxheSAqLwotI2RlZmluZSBSRUxBWV9TSElGVAkJMjYKLS8qIAlQQURfQklUUyg0KTsgKi8KLSNkZWZpbmUgUkVWSVNFRF9GQ1MJCTB4MDAzODAwMDAgLyogcmV2aXNlZCBGQ1MgKi8KLSNkZWZpbmUgUkVWSVNFRF9GQ1NfU0hJRlQJMTkKLSNkZWZpbmUgTkVYVF9CVUZGRVJfQUREUgkweDAwMDdGRkZGIC8qIE5leHQgQnVmZmVyIEFkZHJlc3MgKi8KLSNkZWZpbmUgTkVYVF9CVUZGRVJfQUREUl9TSElGVAkwCi0KLQlfX2JlMzIgcmVnMTsKLSNkZWZpbmUgTUFDX0hEUl9MRU4JCTB4RkMwMDAwMDAgLyogTUFDIEhlYWRlciBMZW5ndGggICovCi0jZGVmaW5lIE1BQ19IRFJfTEVOX1NISUZUCTI2Ci0jZGVmaW5lIERVUkFUSU9OX09WRVJJREUJMHgwMjAwMDAwMCAvKiBEdXJhdGlvbiBPdmVycmlkZSAqLwotI2RlZmluZSBEVVJBVElPTl9PVkVSSURFX1NISUZUCTI1Ci0jZGVmaW5lIFBIWV9IRFJfT1ZFUklERQkJMHgwMTAwMDAwMCAvKiBQSFkgSGVhZGVyIE92ZXJyaWRlICovCi0jZGVmaW5lIFBIWV9IRFJfT1ZFUklERV9TSElGVAkyNAotI2RlZmluZSBDUkNfRkFJTAkJMHgwMDgwMDAwMCAvKiBDUkMgZmFpbCAqLwotI2RlZmluZSBDUkNfRkFJTF9TSElGVAkJMjMKLS8qCVBBRF9CSVRTKDEpOyAqLwotI2RlZmluZSBTRVFVRU5DRV9OVU1CRVIJCTB4MDAyMDAwMDAgLyogU2VxdWVuY2UgTnVtYmVyICovCi0jZGVmaW5lIFNFUVVFTkNFX05VTUJFUl9TSElGVAkyMQotLyoJUEFEX0JJVFMoMik7ICovCi0jZGVmaW5lIEJVRkZfSEVBRF9BRERSCQkweDAwMDdGRkZGIC8qIEJ1ZmZlciBIZWFkIEFkZHJlc3MgKi8KLSNkZWZpbmUgQlVGRl9IRUFEX0FERFJfU0hJRlQJMAotCi0JX19iZTMyIHJlZzI7Ci0jZGVmaW5lIFBEVV9DT1VOVAkJMHhGQzAwMDAwMCAvKiBQRFUgQ291bnQgKi8KLSNkZWZpbmUgUERVX0NPVU5UX1NISUZUCQkyNgotLyogCVBBRF9CSVRTKDMpOyAqLwotI2RlZmluZSBXRVBfS0VZCQkJMHgwMDYwMDAwMCAvKiBXRVAgS2V5ICMgKi8KLSNkZWZpbmUgV0VQX0tFWV9TSElGVAkJMjEKLSNkZWZpbmUgVVNFU19XRVBfS0VZCQkweDAwMTAwMDAwIC8qIFVzZXMgV0VQIEtleSAqLwotI2RlZmluZSBVU0VTX1dFUF9LRVlfU0hJRlQJMjAKLSNkZWZpbmUgS0VFUF9BTElWRQkJMHgwMDA4MDAwMCAvKiBLZWVwIGFsaXZlICovCi0jZGVmaW5lIEtFRVBfQUxJVkVfU0hJRlQJMTkKLSNkZWZpbmUgQlVGRl9UQUlMX0FERFIJCTB4MDAwN0ZGRkYgLyogQnVmZmVyIFRhaWwgQWRkcmVzcyAqLwotI2RlZmluZSBCVUZGX1RBSUxfQUREUl9TSElGVAkwCi0KLQlfX2JlMzIgcmVnMzsKLSNkZWZpbmUgQ1RTXzExRwkJCTB4ODAwMDAwMDAJLyogQ1RTIGluIDExZyAqLwotI2RlZmluZSBDVFNfMTFHX1NISUZUCQkzMQotI2RlZmluZSBSVFNfMTFHCQkJMHg0MDAwMDAwMAkvKiBSVFMgaW4gMTFnICovCi0jZGVmaW5lIFJUU18xMUdfU0hJRlQJCTMwCi0vKiBQQURfQklUUygyKTsgKi8KLSNkZWZpbmUgRlJBR19TSVpFCQkweDBGRkYwMDAwCS8qIGZyYWdtZW50IHNpemUgKi8KLSNkZWZpbmUgRlJBR19TSVpFX1NISUZUCQkxNgotI2RlZmluZSBQQVlMT0FEX0xFTgkJMHgwMDAwRkZGMAkvKiBwYXlsb2FkIGxlbmd0aCAqLwotI2RlZmluZSBQQVlMT0FEX0xFTl9TSElGVAk0Ci0jZGVmaW5lIEZSQUdfTlVNCQkweDAwMDAwMDBGCS8qIG51bWJlciBvZiBmcmFncyAqLwotI2RlZmluZSBGUkFHX05VTV9TSElGVAkJMAotCi0JX19iZTMyIHJlZzQ7Ci0vKiAJUEFEX0JJVFMoNCk7ICovCi0jZGVmaW5lIFJFTEFZX1NUQUlECQkweDBGRkYwMDAwIC8qIHJlbGF5U3RhbGQgKi8KLSNkZWZpbmUgUkVMQVlfU1RBSURfU0hJRlQJMTYKLSNkZWZpbmUgU1RBVElPTl9JRAkJMHgwMDAwRkZGMCAvKiBTdGF0aW9uIElEICovCi0jZGVmaW5lIFNUQVRJT05fSURfU0hJRlQJNAotI2RlZmluZSBXT1JLUVVFVUVfSUQJCTB4MDAwMDAwMEYgLyogV29ya3F1ZXVlIElEICovCi0jZGVmaW5lIFdPUktRVUVVRV9JRF9TSElGVAkwCi0KLQkvKiBGSVhNRSB0aGlzIHJlZ2lzdGVyIG1heWJlIGlzIExFPyAqLwotCV9fYmUzMiByZWc1OwotLyogCVBBRF9CSVRTKDQpOyAqLwotI2RlZmluZSBST1VURV9IT1NUCQkweDBGMDAwMDAwCi0jZGVmaW5lIFJPVVRFX0hPU1RfU0hJRlQJMjQKLSNkZWZpbmUgUk9VVEVfQ0FSRF9DUFUJCTB4MDBGMDAwMDAKLSNkZWZpbmUgUk9VVEVfQ0FSRF9DUFVfU0hJRlQJMjAKLSNkZWZpbmUgUk9VVEVfRU5DUllQVElPTgkweDAwMEYwMDAwCi0jZGVmaW5lIFJPVVRFX0VOQ1JZUFRJT05fU0hJRlQJMTYKLSNkZWZpbmUgUk9VVEVfVFgJCTB4MDAwMEYwMDAKLSNkZWZpbmUgUk9VVEVfVFhfU0hJRlQJCTEyCi0jZGVmaW5lIFJPVVRFX1JYMQkJMHgwMDAwMEYwMAotI2RlZmluZSBST1VURV9SWDFfU0hJRlQJCTgKLSNkZWZpbmUgUk9VVEVfUlgyCQkweDAwMDAwMEYwCi0jZGVmaW5lIFJPVVRFX1JYMl9TSElGVAkJNAotI2RlZmluZSBST1VURV9DT01QUkVTU0lPTgkweDAwMDAwMDBGCi0jZGVmaW5lIFJPVVRFX0NPTVBSRVNTSU9OX1NISUZUIDAKLQotCV9fYmUzMiBfMTFnMDsJCQkvKiAxMWcgKi8KLQlfX2JlMzIgXzExZzE7CQkJLyogMTFnICovCi0JX19iZTMyIF8xMWIwOwkJCS8qIDExYiAqLwotCV9fYmUzMiBfMTFiMTsJCQkvKiAxMWIgKi8KLQl1OCBtYWNfaGRyWzMyXTsJCQkvKiBNQUMgaGVhZGVyICovCi0KLQlfX2JlMTYgcnRzX2R1cmF0aW9uOwkJLyogUlRTIGR1cmF0aW9uICovCi0JX19iZTE2IGxhc3RfZHVyYXRpb247CQkvKiBMYXN0IGR1cmF0aW9uICovCi0JX19iZTE2IHNlY19sYXN0X2R1cmF0aW9uOwkvKiBTZWNvbmQgdG8gTGFzdCBkdXJhdGlvbiAqLwotCV9fYmUxNiBvdGhlcl9kdXJhdGlvbjsJCS8qIE90aGVyIGR1cmF0aW9uICovCi0JX19iZTE2IHR4X2xhc3RfZHVyYXRpb247CS8qIFRYIExhc3QgZHVyYXRpb24gKi8KLQlfX2JlMTYgdHhfb3RoZXJfZHVyYXRpb247CS8qIFRYIE90aGVyIER1cmF0aW9uICovCi0JX19iZTE2IGxhc3RfMTFnX2xlbjsJCS8qIExlbmd0aCBvZiBsYXN0IDExZyAqLwotCV9fYmUxNiBvdGhlcl8xMWdfbGVuOwkJLyogTGVuZ2h0IG9mIG90aGVyIDExZyAqLwotCi0JX19iZTE2IGxhc3RfMTFiX2xlbjsJCS8qIExlbmd0aCBvZiBsYXN0IDExYiAqLwotCV9fYmUxNiBvdGhlcl8xMWJfbGVuOwkJLyogTGVuZ2h0IG9mIG90aGVyIDExYiAqLwotCi0KLQlfX2JlMTYgcmVnNjsKLSNkZWZpbmUgTUJGCQkJMHhGMDAwIC8qIG1iZiAqLwotI2RlZmluZSBNQkZfU0hJRlQJCTEyCi0jZGVmaW5lIFJTVkQ0CQkJMHgwRkZGIC8qIHJzdmQ0ICovCi0jZGVmaW5lIFJTVkQ0X1NISUZUCQkwCi0KLQlfX2JlMTYgcnhfZnJhZ19zdGF0OwkvKiBSWCBmcmFnbWVudGF0aW9uIHN0YXR1cyAqLwotCi0JX19iZTMyIHRpbWVfc3RhbXA7CS8qIFRpbWVTdGFtcCAqLwotCV9fYmUzMiBwaHlfc3RhdHNfaGk7CS8qIFBIWSBzdGF0cyBoaSAqLwotCV9fYmUzMiBwaHlfc3RhdHNfbG87CS8qIFBIWSBzdGF0cyBsbyAqLwotCV9fYmUzMiBtaWNfa2V5MDsJLyogTUlDIGtleSAwICovCi0JX19iZTMyIG1pY19rZXkxOwkvKiBNSUMga2V5IDEgKi8KLQotCXVuaW9uIHsJCQkvKiBSWC9UWCBVbmlvbiAqLwotCQlzdHJ1Y3QgYWdueF9yeCByeDsKLQkJc3RydWN0IGFnbnhfdHggdHg7Ci0JfTsKLQotCXU4IHJ4X2NoYW5uZWw7CQkvKiBSZWNpZXZlIENoYW5uZWwgKi8KLQlQQURfQllURVMoMyk7Ci0KLQl1OCByZXNlcnZlZFs0XTsKLX0gX19hdHRyaWJ1dGVfXygoX19wYWNrZWRfXykpOwotCi0KLXN0cnVjdCBhZ254X2Rlc2MgewotI2RlZmluZSBQQUNLRVRfTEVOCQkweEZGRjAwMDAwCi0jZGVmaW5lIFBBQ0tFVF9MRU5fU0hJRlQJMjAKLS8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwotI2RlZmluZSBGSVJTVF9QQUNLRVRfTUFTSwkweDAwMDgwMDAwCi0jZGVmaW5lIEZJUlNUX1BBQ0tFVF9NQVNLX1NISUZUCTE5Ci0jZGVmaW5lIEZJUlNUX1JFU0VSVjIJCTB4MDAwNDAwMDAKLSNkZWZpbmUgRklSU1RfUkVTRVJWMl9TSElGVAkxOAotI2RlZmluZSBGSVJTVF9US0lQX0VSUk9SCTB4MDAwMjAwMDAKLSNkZWZpbmUgRklSU1RfVEtJUF9FUlJPUl9TSElGVAkxNwotI2RlZmluZSBGSVJTVF9US0lQX1BBQ0tFVAkweDAwMDEwMDAwCi0jZGVmaW5lIEZJUlNUX1RLSVBfUEFDS0VUX1NISUZUCTE2Ci0jZGVmaW5lIEZJUlNUX1JFU0VSVjEJCTB4MDAwMEYwMDAKLSNkZWZpbmUgRklSU1RfUkVTRVJWMV9TSElGVAkxMgotI2RlZmluZSBGSVJTVF9GUkFHX0xFTgkJMHgwMDAwMEZGOAotI2RlZmluZSBGSVJTVF9GUkFHX0xFTl9TSElGVAkzCi0vKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KLSNkZWZpbmUgU1VCX1JFU0VSVjIJCTB4MDAwYzAwMDAKLSNkZWZpbmUgU1VCX1JFU0VSVjJfU0hJRlQJMTgKLSNkZWZpbmUgU1VCX1RLSVBfRVJST1IJCTB4MDAwMjAwMDAKLSNkZWZpbmUgU1VCX1RLSVBfRVJST1JfU0hJRlQJMTcKLSNkZWZpbmUgU1VCX1RLSVBfUEFDS0VUCQkweDAwMDEwMDAwCi0jZGVmaW5lIFNVQl9US0lQX1BBQ0tFVF9TSElGVAkxNgotI2RlZmluZSBTVUJfUkVTRVJWMQkJMHgwMDAwODAwMAotI2RlZmluZSBTVUJfUkVTRVJWMV9TSElGVAkxNQotI2RlZmluZSBTVUJfRlJBR19MRU4JCTB4MDAwMDdGRjgKLSNkZWZpbmUgU1VCX0ZSQUdfTEVOX1NISUZUCTMKLS8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwotI2RlZmluZSBGSVJTVF9GUkFHCQkweDAwMDAwMDA0Ci0jZGVmaW5lIEZJUlNUX0ZSQUdfU0hJRlQJMgotI2RlZmluZSBMQVNUX0ZSQUcJCTB4MDAwMDAwMDIKLSNkZWZpbmUgTEFTVF9GUkFHX1NISUZUCQkxCi0jZGVmaW5lIE9XTkVSCQkJMHgwMDAwMDAwMQotI2RlZmluZSBPV05FUl9TSElGVAkJMAotCV9fYmUzMiBmcmFnOwotCV9fYmUzMiBkbWFfYWRkcjsKLX0gX19hdHRyaWJ1dGVfXygoX19wYWNrZWRfXykpOwotCi1lbnVtIHtIRUFERVIsIFBBQ0tFVH07Ci0KLXN0cnVjdCBhZ254X2luZm8gewotICAgICAgICBzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwotICAgICAgICBkbWFfYWRkcl90IG1hcHBpbmc7Ci0JdTMyIGRtYV9sZW47CQkvKiBkbWEgYnVmZmVyIGxlbiAgKi8KLQkvKiBCZWxvdyBmaWVsZHMgb25seSB1c2Z1bCBmb3IgdHggKi8KLQl1MzIgaGRyX2xlbjsJCS8qIGllZWU4MDIxMSBoZWFkZXIgbGVuZ3RoICovCi0JdW5zaWduZWQgaW50IHR5cGU7Ci0gICAgICAgIHN0cnVjdCBpZWVlODAyMTFfdHhfaW5mbyAqdHhpOwotICAgICAgICBzdHJ1Y3QgaWVlZTgwMjExX2hkciBoZHI7Ci19OwotCi0KLXN0cnVjdCBhZ254X3JpbmcgewotCXN0cnVjdCBhZ254X2Rlc2MgKmRlc2M7Ci0JZG1hX2FkZHJfdCBkbWE7Ci0Jc3RydWN0IGFnbnhfaW5mbyAqaW5mbzsKLQkvKiBXaWxsIGxlYWQgdG8gb3ZlcmZsb3cgd2hlbiBzZW50IHBhY2tldCBudW1iZXIgZW5vdWdoPyAqLwotCXVuc2lnbmVkIGludCBpZHg7Ci0JdW5zaWduZWQgaW50IGlkeF9zZW50OwkJLyogb25seSB1c2Z1bCBmb3IgdHhkIGFuZCB0eG0gKi8KLQl1bnNpZ25lZCBpbnQgc2l6ZTsKLX07Ci0KLSNkZWZpbmUgQUdOWF9SWF9SSU5HX1NJWkUJMTI4Ci0jZGVmaW5lIEFHTlhfVFhEX1JJTkdfU0laRQkyNTYKLSNkZWZpbmUgQUdOWF9UWE1fUklOR19TSVpFCTEyOAotCi12b2lkIGRpc2FibGVfcnhfaW50ZXJydXB0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpOwotdm9pZCBlbmFibGVfcnhfaW50ZXJydXB0KHN0cnVjdCBhZ254X3ByaXYgKnByaXYpOwotaW50IGZpbGxfcmluZ3Moc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci12b2lkIHVuZmlsbF9yaW5ncyhzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLXZvaWQgaGFuZGxlX3J4X2lycShzdHJ1Y3QgYWdueF9wcml2ICpwcml2KTsKLXZvaWQgaGFuZGxlX3R4ZF9pcnEoc3RydWN0IGFnbnhfcHJpdiAqcHJpdik7Ci12b2lkIGhhbmRsZV90eG1faXJxKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpOwotdm9pZCBoYW5kbGVfb3RoZXJfaXJxKHN0cnVjdCBhZ254X3ByaXYgKnByaXYpOwotaW50IF9hZ254X3R4KHN0cnVjdCBhZ254X3ByaXYgKnByaXYsIHN0cnVjdCBza19idWZmICpza2IpOwotI2VuZGlmIC8qIEFHTlhfWE1JVF9IXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2IzZGZnL2IzZGZnLmMgYi9kcml2ZXJzL3N0YWdpbmcvYjNkZmcvYjNkZmcuYwppbmRleCA5NGM1ZDI3Li5jZGEyNmJiNCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2IzZGZnL2IzZGZnLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2IzZGZnL2IzZGZnLmMKQEAgLTM2LDYgKzM2LDcgQEAKICNpbmNsdWRlIDxsaW51eC93YWl0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KIAogc3RhdGljIHVuc2lnbmVkIGludCBiM2RmZ19uYnVmID0gMjsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9LY29uZmlnIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9LY29uZmlnCmluZGV4IGFmNzIzY2IuLmQ2M2M4ODkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvS2NvbmZpZworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL0tjb25maWcKQEAgLTEsNyArMSw3IEBACiBjb25maWcgQ09NRURJCiAJdHJpc3RhdGUgIkRhdGEgYWNxdWlzaXRpb24gc3VwcG9ydCAoY29tZWRpKSIKIAlkZWZhdWx0IE4KLQlkZXBlbmRzIG9uIG0KKwlkZXBlbmRzIG9uIG0gJiYgKFBDSSB8fCBQQ01DSUEgfHwgUENDQVJEIHx8IFVTQikKIAktLS1oZWxwLS0tCiAJICBFbmFibGUgc3VwcG9ydCBhIHdpZGUgcmFuZ2Ugb2YgZGF0YSBhY3F1aXNpdGlvbiBkZXZpY2VzCiAJICBmb3IgTGludXguCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2NvbWVkaV9mb3BzLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2NvbWVkaV9mb3BzLmMKaW5kZXggZjU0YmI5Yi4uYWFhZDc2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9jb21lZGlfZm9wcy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvY29tZWRpX2ZvcHMuYwpAQCAtMjMzNyw3ICsyMzM3LDcgQEAKIAl9CiAKIAlEUFJJTlRLKCJjb21lZGklaSBzdWJkICVkIGJ1ZmZlciByZXNpemVkIHRvICVpIGJ5dGVzXG4iLAotCQlkZXYtPm1pbm9yLCBzIC0gZGV2LT5zdWJkZXZpY2VzLCBhc3luYy0+cHJlYWxsb2NfYnVmc3opOworCQlkZXYtPm1pbm9yLCAoaW50KShzIC0gZGV2LT5zdWJkZXZpY2VzKSwgYXN5bmMtPnByZWFsbG9jX2J1ZnN6KTsKIAlyZXR1cm4gMDsKIH0KIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2NiX2RhczE2X2NzLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY2JfZGFzMTZfY3MuYwppbmRleCAxMmQxMmI0Li44MGMwZGY4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY2JfZGFzMTZfY3MuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY2JfZGFzMTZfY3MuYwpAQCAtNzQ0LDcgKzc0NCw3IEBACiAKIAkvKiBJbml0aWFsaXplIHRoZSBwY21jaWFfZGV2aWNlIHN0cnVjdHVyZSAqLwogCS8qIEludGVycnVwdCBzZXR1cCAqLwotCWxpbmstPmlycS5BdHRyaWJ1dGVzID0gSVJRX1RZUEVfRVhDTFVTSVZFOworCWxpbmstPmlycS5BdHRyaWJ1dGVzID0gSVJRX1RZUEVfRFlOQU1JQ19TSEFSSU5HOwogCWxpbmstPmlycS5JUlFJbmZvMSA9IElSUV9MRVZFTF9JRDsKIAlsaW5rLT5pcnEuSGFuZGxlciA9IE5VTEw7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9jYl9wY2lkaW8uYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9jYl9wY2lkaW8uYwppbmRleCA0ZDEwYmMzLi4wOWU2ZTNiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvY2JfcGNpZGlvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2NiX3BjaWRpby5jCkBAIC01Myw3ICs1Myw4IEBACiAgKiBTb21lIGRyaXZlcnMgdXNlIGFycmF5cyBzdWNoIGFzIHRoaXMsIG90aGVyIGRvIG5vdC4KICAqLwogc3RydWN0IHBjaWRpb19ib2FyZCB7Ci0JY29uc3QgY2hhciAqbmFtZTsJLyogIGFubWUgb2YgdGhlIGJvYXJkICovCisJY29uc3QgY2hhciAqbmFtZTsJLyogIG5hbWUgb2YgdGhlIGJvYXJkICovCisJaW50IGRldl9pZDsKIAlpbnQgbl84MjU1OwkJLyogIG51bWJlciBvZiA4MjU1IGNoaXBzIG9uIGJvYXJkICovCiAKIAkvKiAgaW5kaWNlcyBvZiBiYXNlIGFkZHJlc3MgcmVnaW9ucyAqLwpAQCAtNjQsMTggKzY1LDIxIEBACiBzdGF0aWMgY29uc3Qgc3RydWN0IHBjaWRpb19ib2FyZCBwY2lkaW9fYm9hcmRzW10gPSB7CiAJewogCSAubmFtZSA9ICJwY2ktZGlvMjQiLAorCSAuZGV2X2lkID0gMHgwMDI4LAogCSAubl84MjU1ID0gMSwKIAkgLnBjaWNvbnRyb2xlcl9iYWRyaW5kZXggPSAxLAogCSAuZGlvcmVnc19iYWRyaW5kZXggPSAyLAogCSB9LAogCXsKIAkgLm5hbWUgPSAicGNpLWRpbzI0aCIsCisJIC5kZXZfaWQgPSAweDAwMTQsCiAJIC5uXzgyNTUgPSAxLAogCSAucGNpY29udHJvbGVyX2JhZHJpbmRleCA9IDEsCiAJIC5kaW9yZWdzX2JhZHJpbmRleCA9IDIsCiAJIH0sCiAJewogCSAubmFtZSA9ICJwY2ktZGlvNDhoIiwKKwkgLmRldl9pZCA9IDB4MDAwYiwKIAkgLm5fODI1NSA9IDIsCiAJIC5wY2ljb250cm9sZXJfYmFkcmluZGV4ID0gMCwKIAkgLmRpb3JlZ3NfYmFkcmluZGV4ID0gMSwKQEAgLTIwNiw3ICsyMTAsNyBAQAogCQkJY29udGludWU7CiAJCS8qICBsb29wIHRocm91Z2ggY2FyZHMgc3VwcG9ydGVkIGJ5IHRoaXMgZHJpdmVyICovCiAJCWZvciAoaW5kZXggPSAwOyBpbmRleCA8IEFSUkFZX1NJWkUocGNpZGlvX2JvYXJkcyk7IGluZGV4KyspIHsKLQkJCWlmIChwY2lkaW9fcGNpX3RhYmxlW2luZGV4XS5kZXZpY2UgIT0gcGNpZGV2LT5kZXZpY2UpCisJCQlpZiAocGNpZGlvX2JvYXJkc1tpbmRleF0uZGV2X2lkICE9IHBjaWRldi0+ZGV2aWNlKQogCQkJCWNvbnRpbnVlOwogCiAJCQkvKiAgd2FzIGEgcGFydGljdWxhciBidXMvc2xvdCByZXF1ZXN0ZWQ/ICovCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvanIzX3BjaS5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL2pyM19wY2kuYwppbmRleCAxNGJmMjliLi4wZDJjMmViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvanIzX3BjaS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9qcjNfcGNpLmMKQEAgLTUxNSw2ICs1MTUsNyBAQAogewogCXN0cnVjdCBwb2xsX2RlbGF5X3QgcmVzdWx0ID0gcG9sbF9kZWxheV9taW5fbWF4KDEwMDAsIDIwMDApOwogCXN0cnVjdCBqcjNfcGNpX3N1YmRldl9wcml2YXRlICpwID0gcy0+cHJpdmF0ZTsKKwlpbnQgaTsKIAogCWlmIChwKSB7CiAJCXZvbGF0aWxlIHN0cnVjdCBqcjNfY2hhbm5lbCAqY2hhbm5lbCA9IHAtPmNoYW5uZWw7CkBAIC01NzAsMTggKzU3MSwxMSBAQAogCQkJCQkgICAgICAgcC0+c2VyaWFsX25vKTsKIAogCQkJCQkvKiAgVHJhbnNmb3JtYXRpb24gYWxsIHplcm9zICovCi0JCQkJCXRyYW5zZi5saW5rWzBdLmxpbmtfdHlwZSA9Ci0JCQkJCSAgICAoZW51bSBsaW5rX3R5cGVzKTA7Ci0JCQkJCXRyYW5zZi5saW5rWzBdLmxpbmtfYW1vdW50ID0gMDsKLQkJCQkJdHJhbnNmLmxpbmtbMV0ubGlua190eXBlID0KLQkJCQkJICAgIChlbnVtIGxpbmtfdHlwZXMpMDsKLQkJCQkJdHJhbnNmLmxpbmtbMV0ubGlua19hbW91bnQgPSAwOwotCQkJCQl0cmFuc2YubGlua1syXS5saW5rX3R5cGUgPQotCQkJCQkgICAgKGVudW0gbGlua190eXBlcykwOwotCQkJCQl0cmFuc2YubGlua1syXS5saW5rX2Ftb3VudCA9IDA7Ci0JCQkJCXRyYW5zZi5saW5rWzNdLmxpbmtfdHlwZSA9Ci0JCQkJCSAgICAoZW51bSBsaW5rX3R5cGVzKTA7Ci0JCQkJCXRyYW5zZi5saW5rWzNdLmxpbmtfYW1vdW50ID0gMDsKKwkJCQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUodHJhbnNmLmxpbmspOyBpKyspIHsKKwkJCQkJCXRyYW5zZi5saW5rW2ldLmxpbmtfdHlwZSA9CisJCQkJCQkJKGVudW0gbGlua190eXBlcykwOworCQkJCQkJdHJhbnNmLmxpbmtbaV0ubGlua19hbW91bnQgPSAwOworCQkJCQl9CiAKIAkJCQkJc2V0X3RyYW5zZm9ybXMoY2hhbm5lbCwgdHJhbnNmLCAwKTsKIAkJCQkJdXNlX3RyYW5zZm9ybShjaGFubmVsLCAwKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9tZV9kYXEuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9tZV9kYXEuYwppbmRleCAyY2RhN2FkLi44MGUxOTJkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbWVfZGFxLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL21lX2RhcS5jCkBAIC01MSw2ICs1MSw3IEBACiAqLwogCiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlICIuLi9jb21lZGlkZXYuaCIKIAogI2luY2x1ZGUgImNvbWVkaV9wY2kuaCIKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV82NXh4LmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfNjV4eC5jCmluZGV4IDZiMTE4YzEuLmJiZjc1ZWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV82NXh4LmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pXzY1eHguYwpAQCAtNDE4LDE1ICs0MTgsMTUgQEAKIAkJcmV0dXJuIC1FSU5WQUw7CiAJYmFzZV9iaXRmaWVsZF9jaGFubmVsID0gQ1JfQ0hBTihpbnNuLT5jaGFuc3BlYyk7CiAJZm9yIChqID0gMDsgaiA8IG1heF9wb3J0c19wZXJfYml0ZmllbGQ7ICsraikgeworCQljb25zdCB1bnNpZ25lZCBwb3J0X29mZnNldCA9IG5pXzY1eHhfcG9ydF9ieV9jaGFubmVsKGJhc2VfYml0ZmllbGRfY2hhbm5lbCkgKyBqOwogCQljb25zdCB1bnNpZ25lZCBwb3J0ID0KLQkJICAgIHNwcml2YXRlKHMpLT5iYXNlX3BvcnQgKwotCQkgICAgbmlfNjV4eF9wb3J0X2J5X2NoYW5uZWwoYmFzZV9iaXRmaWVsZF9jaGFubmVsKSArIGo7CisJCSAgICBzcHJpdmF0ZShzKS0+YmFzZV9wb3J0ICsgcG9ydF9vZmZzZXQ7CiAJCXVuc2lnbmVkIGJhc2VfcG9ydF9jaGFubmVsOwogCQl1bnNpZ25lZCBwb3J0X21hc2ssIHBvcnRfZGF0YSwgcG9ydF9yZWFkX2JpdHM7CiAJCWludCBiaXRzaGlmdDsKIAkJaWYgKHBvcnQgPj0gbmlfNjV4eF90b3RhbF9udW1fcG9ydHMoYm9hcmQoZGV2KSkpCiAJCQlicmVhazsKLQkJYmFzZV9wb3J0X2NoYW5uZWwgPSBwb3J0ICogbmlfNjV4eF9jaGFubmVsc19wZXJfcG9ydDsKKwkJYmFzZV9wb3J0X2NoYW5uZWwgPSBwb3J0X29mZnNldCAqIG5pXzY1eHhfY2hhbm5lbHNfcGVyX3BvcnQ7CiAJCXBvcnRfbWFzayA9IGRhdGFbMF07CiAJCXBvcnRfZGF0YSA9IGRhdGFbMV07CiAJCWJpdHNoaWZ0ID0gYmFzZV9wb3J0X2NoYW5uZWwgLSBiYXNlX2JpdGZpZWxkX2NoYW5uZWw7CkBAIC00NTcsNiArNDU3LDEyIEBACiAJCXBvcnRfcmVhZF9iaXRzID0KIAkJICAgIHJlYWRiKHByaXZhdGUoZGV2KS0+bWl0ZS0+ZGFxX2lvX2FkZHIgKyBQb3J0X0RhdGEocG9ydCkpOwogLyogcHJpbnRrKCJyZWFkIDB4JXggZnJvbSBwb3J0ICVpXG4iLCBwb3J0X3JlYWRfYml0cywgcG9ydCk7ICovCisJCWlmIChzLT50eXBlID09IENPTUVESV9TVUJEX0RPICYmIGJvYXJkKGRldiktPmludmVydF9vdXRwdXRzKSB7CisJCQkvKiBPdXRwdXRzIGludmVydGVkLCBzbyBpbnZlcnQgdmFsdWUgcmVhZCBiYWNrIGZyb20KKwkJCSAqIERPIHN1YmRldmljZS4gIChEb2VzIG5vdCBhcHBseSB0byBib2FyZHMgd2l0aCBESU8KKwkJCSAqIHN1YmRldmljZS4pICovCisJCQlwb3J0X3JlYWRfYml0cyBePSAweEZGOworCQl9CiAJCWlmIChiaXRzaGlmdCA+IDApIHsKIAkJCXBvcnRfcmVhZF9iaXRzIDw8PSBiaXRzaGlmdDsKIAkJfSBlbHNlIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9kYXFfNzAwLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfZGFxXzcwMC5jCmluZGV4IDZhNzc5NzYuLmVjMzFhMzkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9kYXFfNzAwLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2RhcV83MDAuYwpAQCAtNTIwLDcgKzUyMCw3IEBACiAJbGluay0+cHJpdiA9IGxvY2FsOwogCiAJLyogSW50ZXJydXB0IHNldHVwICovCi0JbGluay0+aXJxLkF0dHJpYnV0ZXMgPSBJUlFfVFlQRV9FWENMVVNJVkU7CisJbGluay0+aXJxLkF0dHJpYnV0ZXMgPSBJUlFfVFlQRV9EWU5BTUlDX1NIQVJJTkc7CiAJbGluay0+aXJxLklSUUluZm8xID0gSVJRX0xFVkVMX0lEOwogCWxpbmstPmlycS5IYW5kbGVyID0gTlVMTDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2RhcV9kaW8yNC5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2RhcV9kaW8yNC5jCmluZGV4IGIwNmU4MWMuLjA3MDBhOGIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9kYXFfZGlvMjQuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfZGFxX2RpbzI0LmMKQEAgLTI3MSw3ICsyNzEsNyBAQAogCWxpbmstPnByaXYgPSBsb2NhbDsKIAogCS8qIEludGVycnVwdCBzZXR1cCAqLwotCWxpbmstPmlycS5BdHRyaWJ1dGVzID0gSVJRX1RZUEVfRVhDTFVTSVZFOworCWxpbmstPmlycS5BdHRyaWJ1dGVzID0gSVJRX1RZUEVfRFlOQU1JQ19TSEFSSU5HOwogCWxpbmstPmlycS5JUlFJbmZvMSA9IElSUV9MRVZFTF9JRDsKIAlsaW5rLT5pcnEuSGFuZGxlciA9IE5VTEw7CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9sYWJwY19jcy5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2xhYnBjX2NzLmMKaW5kZXggNTdhZWNmYS4uYTMwNTNiOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2xhYnBjX2NzLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX2xhYnBjX2NzLmMKQEAgLTI0Niw3ICsyNDYsNyBAQAogCWxpbmstPnByaXYgPSBsb2NhbDsKIAogCS8qIEludGVycnVwdCBzZXR1cCAqLwotCWxpbmstPmlycS5BdHRyaWJ1dGVzID0gSVJRX1RZUEVfRVhDTFVTSVZFIHwgSVJRX0ZPUkNFRF9QVUxTRTsKKwlsaW5rLT5pcnEuQXR0cmlidXRlcyA9IElSUV9UWVBFX0RZTkFNSUNfU0hBUklORyB8IElSUV9GT1JDRURfUFVMU0U7CiAJbGluay0+aXJxLklSUUluZm8xID0gSVJRX0lORk8yX1ZBTElEIHwgSVJRX1BVTFNFX0lEOwogCWxpbmstPmlycS5IYW5kbGVyID0gTlVMTDsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX21pb19jb21tb24uYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9taW9fY29tbW9uLmMKaW5kZXggZTNmZmIwNi4uNzUzZWUwNSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX21pb19jb21tb24uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfbWlvX2NvbW1vbi5jCkBAIC02Miw2ICs2Miw3IEBACiAvKiAjZGVmaW5lIERFQlVHX1NUQVRVU19CICovCiAKICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgIjgyNTUuaCIKICNpbmNsdWRlICJtaXRlLmgiCiAjaW5jbHVkZSAiY29tZWRpX2ZjLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfbWlvX2NzLmMgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfbWlvX2NzLmMKaW5kZXggYjczMjI5Ni4uOWFlZjg3ZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX21pb19jcy5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9taW9fY3MuYwpAQCAtMjczLDcgKzI3Myw3IEBACiB7CiAJbGluay0+aW8uQXR0cmlidXRlczEgPSBJT19EQVRBX1BBVEhfV0lEVEhfMTY7CiAJbGluay0+aW8uTnVtUG9ydHMxID0gMTY7Ci0JbGluay0+aXJxLkF0dHJpYnV0ZXMgPSBJUlFfVFlQRV9FWENMVVNJVkU7CisJbGluay0+aXJxLkF0dHJpYnV0ZXMgPSBJUlFfVFlQRV9EWU5BTUlDX1NIQVJJTkc7CiAJbGluay0+aXJxLklSUUluZm8xID0gSVJRX0xFVkVMX0lEOwogCWxpbmstPmNvbmYuQXR0cmlidXRlcyA9IENPTkZfRU5BQkxFX0lSUTsKIAlsaW5rLT5jb25mLkludFR5cGUgPSBJTlRfTUVNT1JZX0FORF9JTzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9wY2lkaW8uYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9wY2lkaW8uYwppbmRleCA1MmIyZWNhLi5kNTQ0Njk4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfcGNpZGlvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX3BjaWRpby5jCkBAIC03MCw2ICs3MCw3IEBACiAvKiAjZGVmaW5lIERFQlVHX0ZMQUdTICovCiAKICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgIi4uL2NvbWVkaWRldi5oIgogCiAjaW5jbHVkZSAibWl0ZS5oIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX3BjaW1pby5jIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL25pX3BjaW1pby5jCmluZGV4IDE5ZDg3NTUuLjI0YzhiOGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9uaV9wY2ltaW8uYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvbmlfcGNpbWlvLmMKQEAgLTI5LDcgKzI5LDcgQEAKICAgUENJLU1JTy0xNlhFLTEwLCBQWEktNjAzMEUsIFBDSS1NSU8tMTZFLTEsIFBDSS1NSU8tMTZFLTQsIFBDSS02MDE0LCBQQ0ktNjA0MEUsCiAgIFBYSS02MDQwRSwgUENJLTYwMzBFLCBQQ0ktNjAzMUUsIFBDSS02MDMyRSwgUENJLTYwMzNFLCBQQ0ktNjA3MUUsIFBDSS02MDIzRSwKICAgUENJLTYwMjRFLCBQQ0ktNjAyNUUsIFBYSS02MDI1RSwgUENJLTYwMzRFLCBQQ0ktNjAzNUUsIFBDSS02MDUyRSwKLSAgUENJLTYxMTAsIFBDSS02MTExLCBQQ0ktNjIyMCwgUENJLTYyMjEsIFBDSS02MjI0LCBQWEktNjIyNCwgUENJLTYyMjUsCisgIFBDSS02MTEwLCBQQ0ktNjExMSwgUENJLTYyMjAsIFBDSS02MjIxLCBQQ0ktNjIyNCwgUFhJLTYyMjQsIFBDSS02MjI1LCBQWEktNjIyNSwKICAgUENJLTYyMjksIFBDSS02MjUwLCBQQ0ktNjI1MSwgUENJZS02MjUxLCBQQ0ktNjI1NCwgUENJLTYyNTksIFBDSWUtNjI1OSwKICAgUENJLTYyODAsIFBDSS02MjgxLCBQWEktNjI4MSwgUENJLTYyODQsIFBDSS02Mjg5LAogICBQQ0ktNjcxMSwgUFhJLTY3MTEsIFBDSS02NzEzLCBQWEktNjcxMywKQEAgLTE3OSw2ICsxNzksNyBAQAogCVBDSV9WRU5ET1JfSURfTkFUSU5TVCwgMHg3MGYyLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwfSwgewogCVBDSV9WRU5ET1JfSURfTkFUSU5TVCwgMHg3MTBkLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwfSwgewogCVBDSV9WRU5ET1JfSURfTkFUSU5TVCwgMHg3MTZjLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwfSwgeworCVBDSV9WRU5ET1JfSURfTkFUSU5TVCwgMHg3MTZkLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwfSwgewogCVBDSV9WRU5ET1JfSURfTkFUSU5TVCwgMHg3MTdmLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwfSwgewogCVBDSV9WRU5ET1JfSURfTkFUSU5TVCwgMHg3MWJjLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwfSwgewogCVBDSV9WRU5ET1JfSURfTkFUSU5TVCwgMHg3MTdkLCBQQ0lfQU5ZX0lELCBQQ0lfQU5ZX0lELCAwLCAwLCAwfSwgewpAQCAtOTUzLDYgKzk1NCwyNSBAQAogCSAuaGFzXzgyNTUgPSAwLAogCSB9LAogCXsKKwkgLmRldmljZV9pZCA9IDB4NzE2ZCwKKwkgLm5hbWUgPSAicHhpLTYyMjUiLAorCSAubl9hZGNoYW4gPSA4MCwKKwkgLmFkYml0cyA9IDE2LAorCSAuYWlfZmlmb19kZXB0aCA9IDQwOTUsCisJIC5nYWlubGt1cCA9IGFpX2dhaW5fNjIyeCwKKwkgLmFpX3NwZWVkID0gNDAwMCwKKwkgLm5fYW9jaGFuID0gMiwKKwkgLmFvYml0cyA9IDE2LAorCSAuYW9fZmlmb19kZXB0aCA9IDgxOTEsCisJIC5hb19yYW5nZV90YWJsZSA9ICZyYW5nZV9uaV9NXzYyMnhfYW8sCisJIC5yZWdfdHlwZSA9IG5pX3JlZ182MjJ4LAorCSAuYW9fdW5pcG9sYXIgPSAwLAorCSAuYW9fc3BlZWQgPSAxMjAwLAorCSAubnVtX3AwX2Rpb19jaGFubmVscyA9IDMyLAorCSAuY2FsZGFjID0ge2NhbGRhY19ub25lfSwKKwkgLmhhc184MjU1ID0gMCwKKwl9LAorCXsKIAkgLmRldmljZV9pZCA9IDB4NzBhYSwKIAkgLm5hbWUgPSAicGNpLTYyMjkiLAogCSAubl9hZGNoYW4gPSAzMiwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9xdWF0ZWNoX2RhcXBfY3MuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9xdWF0ZWNoX2RhcXBfY3MuYwppbmRleCBmNjNiZGMzLi4zNDRiODIzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvcXVhdGVjaF9kYXFwX2NzLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3F1YXRlY2hfZGFxcF9jcy5jCkBAIC0xMDc5LDcgKzEwNzksNyBAQAogCWxpbmstPnByaXYgPSBsb2NhbDsKIAogCS8qIEludGVycnVwdCBzZXR1cCAqLwotCWxpbmstPmlycS5BdHRyaWJ1dGVzID0gSVJRX1RZUEVfRVhDTFVTSVZFIHwgSVJRX0hBTkRMRV9QUkVTRU5UOworCWxpbmstPmlycS5BdHRyaWJ1dGVzID0gSVJRX1RZUEVfRFlOQU1JQ19TSEFSSU5HIHwgSVJRX0hBTkRMRV9QUkVTRU5UOwogCWxpbmstPmlycS5JUlFJbmZvMSA9IElSUV9MRVZFTF9JRDsKIAlsaW5rLT5pcnEuSGFuZGxlciA9IGRhcXBfaW50ZXJydXB0OwogCWxpbmstPmlycS5JbnN0YW5jZSA9IGxvY2FsOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3M1MjYuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9zNTI2LmMKaW5kZXggYjg5ZTFlYy4uMDdjMjFlNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3M1MjYuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvczUyNi5jCkBAIC00Myw2ICs0Myw3IEBACiAKICNpbmNsdWRlICIuLi9jb21lZGlkZXYuaCIKICNpbmNsdWRlIDxsaW51eC9pb3BvcnQuaD4KKyNpbmNsdWRlIDxhc20vYnl0ZW9yZGVyLmg+CiAKICNkZWZpbmUgUzUyNl9TSVpFIDY0CiAKQEAgLTExMyw2ICsxMTQsNyBAQAogfTsKIAogc3RydWN0IGNvdW50ZXJfbW9kZV9yZWdpc3Rlcl90IHsKKyNpZiBkZWZpbmVkIChfX0xJVFRMRV9FTkRJQU5fQklURklFTEQpCiAJdW5zaWduZWQgc2hvcnQgY291dFNvdXJjZToxOwogCXVuc2lnbmVkIHNob3J0IGNvdXRQb2xhcml0eToxOwogCXVuc2lnbmVkIHNob3J0IGF1dG9Mb2FkUmVzZXRSY2FwOjM7CkBAIC0xMjQsMTIgKzEyNiwyNyBAQAogCXVuc2lnbmVkIHNob3J0IG91dHB1dFJlZ0xhdGNoQ3RybDoxOwogCXVuc2lnbmVkIHNob3J0IHByZWxvYWRSZWdTZWw6MTsKIAl1bnNpZ25lZCBzaG9ydCByZXNlcnZlZDoxOworICNlbGlmIGRlZmluZWQoX19CSUdfRU5ESUFOX0JJVEZJRUxEKQorCXVuc2lnbmVkIHNob3J0IHJlc2VydmVkOjE7CisJdW5zaWduZWQgc2hvcnQgcHJlbG9hZFJlZ1NlbDoxOworCXVuc2lnbmVkIHNob3J0IG91dHB1dFJlZ0xhdGNoQ3RybDoxOworCXVuc2lnbmVkIHNob3J0IGNvdW50RGlyQ3RybDoxOworCXVuc2lnbmVkIHNob3J0IGNvdW50RGlyOjE7CisJdW5zaWduZWQgc2hvcnQgY2xvY2tTb3VyY2U6MjsKKwl1bnNpZ25lZCBzaG9ydCBjdEVuYWJsZUN0cmw6MjsKKwl1bnNpZ25lZCBzaG9ydCBod0N0RW5hYmxlU291cmNlOjI7CisJdW5zaWduZWQgc2hvcnQgYXV0b0xvYWRSZXNldFJjYXA6MzsKKwl1bnNpZ25lZCBzaG9ydCBjb3V0UG9sYXJpdHk6MTsKKwl1bnNpZ25lZCBzaG9ydCBjb3V0U291cmNlOjE7CisjZWxzZQorI2Vycm9yIFVua25vd24gYml0IGZpZWxkIG9yZGVyCisjZW5kaWYKIH07CiAKLXVuaW9uIHsKK3VuaW9uIGNtUmVnIHsKIAlzdHJ1Y3QgY291bnRlcl9tb2RlX3JlZ2lzdGVyX3QgcmVnOwogCXVuc2lnbmVkIHNob3J0IHZhbHVlOwotfSBjbVJlZzsKK307CiAKICNkZWZpbmUgTUFYX0dQQ1RfQ09ORklHX0RBVEEgNgogCkBAIC0yODUsNiArMzAyLDcgQEAKIAlpbnQgaSwgbjsKIC8qIHNob3J0IHZhbHVlOyAqLwogLyogaW50IHN1YmRldl9jaGFubmVsID0gMDsgKi8KKwl1bmlvbiBjbVJlZyBjbVJlZzsKIAogCXByaW50aygiY29tZWRpJWQ6IHM1MjY6ICIsIGRldi0+bWlub3IpOwogCkBAIC0zNzUsNyArMzkzLDcgQEAKIAlpZiAodGhpc2JvYXJkLT5oYXZlX2RpbykgewogCQlzLT50eXBlID0gQ09NRURJX1NVQkRfRElPOwogCQlzLT5zdWJkZXZfZmxhZ3MgPSBTREZfUkVBREFCTEUgfCBTREZfV1JJVEFCTEU7Ci0JCXMtPm5fY2hhbiA9IDI7CisJCXMtPm5fY2hhbiA9IDg7CiAJCXMtPm1heGRhdGEgPSAxOwogCQlzLT5yYW5nZV90YWJsZSA9ICZyYW5nZV9kaWdpdGFsOwogCQlzLT5pbnNuX2JpdHMgPSBzNTI2X2Rpb19pbnNuX2JpdHM7CkBAIC00MzUsMTEgKzQ1MywxMSBAQAogCXVkZWxheSgxMDAwKTsKIAlwcmludGsoIlJlYWQgYmFjayBtb2RlIHJlZz0weCUwNHhcbiIsIGludyhBRERSX0NIQU5fUkVHKFJFR19DME0sIG4pKSk7CiAKLQkvKiAgTG9hZCB0aGUgcHJlLWxhb2QgcmVnaXN0ZXIgaGlnaCB3b3JkICovCisJLyogIExvYWQgdGhlIHByZS1sb2FkIHJlZ2lzdGVyIGhpZ2ggd29yZCAqLwogLyogdmFsdWUgPSAoc2hvcnQpICgweDU1KTsgKi8KIC8qIG91dHcodmFsdWUsIEFERFJfQ0hBTl9SRUcoUkVHX0MwSCwgbikpOyAqLwogCi0JLyogIExvYWQgdGhlIHByZS1sYW9kIHJlZ2lzdGVyIGxvdyB3b3JkICovCisJLyogIExvYWQgdGhlIHByZS1sb2FkIHJlZ2lzdGVyIGxvdyB3b3JkICovCiAvKiB2YWx1ZSA9IChzaG9ydCkoMHhhYTU1KTsgKi8KIC8qIG91dHcodmFsdWUsIEFERFJfQ0hBTl9SRUcoUkVHX0MwTCwgbikpOyAqLwogCkBAIC01MTYsNiArNTM0LDcgQEAKIAlpbnQgc3ViZGV2X2NoYW5uZWwgPSBDUl9DSEFOKGluc24tPmNoYW5zcGVjKTsJLyogIFVucGFjayBjaGFuc3BlYyAqLwogCWludCBpOwogCXNob3J0IHZhbHVlOworCXVuaW9uIGNtUmVnIGNtUmVnOwogCiAvKiBwcmludGsoInM1MjY6IEdQQ1RfSU5TTl9DT05GSUc6IENvbmZpZ3VyaW5nIENoYW5uZWwgJWRcbiIsIHN1YmRldl9jaGFubmVsKTsgKi8KIApAQCAtNTY4LDE5ICs1ODcsOCBAQAogCiAjaWYgMQogCQkvKiAgU2V0IENvdW50ZXIgTW9kZSBSZWdpc3RlciAqLwotCQljbVJlZy5yZWcuY291dFNvdXJjZSA9IDA7CS8qICBvdXQgUkNBUCAqLwotCQljbVJlZy5yZWcuY291dFBvbGFyaXR5ID0gMDsJLyogIFBvbGFyaXR5IGludmVydGVkICovCi0JCWNtUmVnLnJlZy5hdXRvTG9hZFJlc2V0UmNhcCA9IDA7CS8qICBBdXRvIGxvYWQgZGlzYWJsZWQgKi8KLQkJY21SZWcucmVnLmh3Q3RFbmFibGVTb3VyY2UgPSAyOwkvKiAgTk9UIFJDQVAgKi8KLQkJY21SZWcucmVnLmN0RW5hYmxlQ3RybCA9IDE7CS8qICAxOiBTb2Z0d2FyZSwgID4xIDogSGFyZHdhcmUgKi8KLQkJY21SZWcucmVnLmNsb2NrU291cmNlID0gMzsJLyogIHg0ICovCi0JCWNtUmVnLnJlZy5jb3VudERpciA9IDA7CS8qICB1cCAqLwotCQljbVJlZy5yZWcuY291bnREaXJDdHJsID0gMDsJLyogIHF1YWRyYXR1cmUgKi8KLQkJY21SZWcucmVnLm91dHB1dFJlZ0xhdGNoQ3RybCA9IDA7CS8qICBsYXRjaCBvbiByZWFkICovCi0JCWNtUmVnLnJlZy5wcmVsb2FkUmVnU2VsID0gMDsJLyogIFBSMCAqLwotCQljbVJlZy5yZWcucmVzZXJ2ZWQgPSAwOworCQljbVJlZy52YWx1ZSA9IGluc24tPmRhdGFbMV0gJiAweEZGRkY7CiAKLQkJLyogIFNldCBDb3VudGVyIE1vZGUgUmVnaXN0ZXIgKi8KIC8qIHByaW50aygiczUyNjogQ291bnRlciBNb2RlIHJlZ2lzdGVyPSV4XG4iLCBjbVJlZy52YWx1ZSk7ICovCiAJCW91dHcoY21SZWcudmFsdWUsIEFERFJfQ0hBTl9SRUcoUkVHX0MwTSwgc3ViZGV2X2NoYW5uZWwpKTsKIApAQCAtNjE1LDExICs2MjMsMTEgQEAKIAkJY21SZWcudmFsdWUgPSAoc2hvcnQpKGluc24tPmRhdGFbMV0gJiAweEZGRkYpOwogCQlvdXR3KGNtUmVnLnZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DME0sIHN1YmRldl9jaGFubmVsKSk7CiAKLQkJLyogIExvYWQgdGhlIHByZS1sYW9kIHJlZ2lzdGVyIGhpZ2ggd29yZCAqLworCQkvKiAgTG9hZCB0aGUgcHJlLWxvYWQgcmVnaXN0ZXIgaGlnaCB3b3JkICovCiAJCXZhbHVlID0gKHNob3J0KSgoaW5zbi0+ZGF0YVsyXSA+PiAxNikgJiAweEZGRkYpOwogCQlvdXR3KHZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DMEgsIHN1YmRldl9jaGFubmVsKSk7CiAKLQkJLyogIExvYWQgdGhlIHByZS1sYW9kIHJlZ2lzdGVyIGxvdyB3b3JkICovCisJCS8qICBMb2FkIHRoZSBwcmUtbG9hZCByZWdpc3RlciBsb3cgd29yZCAqLwogCQl2YWx1ZSA9IChzaG9ydCkoaW5zbi0+ZGF0YVsyXSAmIDB4RkZGRik7CiAJCW91dHcodmFsdWUsIEFERFJfQ0hBTl9SRUcoUkVHX0MwTCwgc3ViZGV2X2NoYW5uZWwpKTsKIApAQCAtNjUzLDExICs2NjEsMTEgQEAKIAkJY21SZWcucmVnLnByZWxvYWRSZWdTZWwgPSAwOwkvKiAgUFIwICovCiAJCW91dHcoY21SZWcudmFsdWUsIEFERFJfQ0hBTl9SRUcoUkVHX0MwTSwgc3ViZGV2X2NoYW5uZWwpKTsKIAotCQkvKiAgTG9hZCB0aGUgcHJlLWxhb2QgcmVnaXN0ZXIgMCBoaWdoIHdvcmQgKi8KKwkJLyogIExvYWQgdGhlIHByZS1sb2FkIHJlZ2lzdGVyIDAgaGlnaCB3b3JkICovCiAJCXZhbHVlID0gKHNob3J0KSgoaW5zbi0+ZGF0YVsyXSA+PiAxNikgJiAweEZGRkYpOwogCQlvdXR3KHZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DMEgsIHN1YmRldl9jaGFubmVsKSk7CiAKLQkJLyogIExvYWQgdGhlIHByZS1sYW9kIHJlZ2lzdGVyIDAgbG93IHdvcmQgKi8KKwkJLyogIExvYWQgdGhlIHByZS1sb2FkIHJlZ2lzdGVyIDAgbG93IHdvcmQgKi8KIAkJdmFsdWUgPSAoc2hvcnQpKGluc24tPmRhdGFbMl0gJiAweEZGRkYpOwogCQlvdXR3KHZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DMEwsIHN1YmRldl9jaGFubmVsKSk7CiAKQEAgLTY2NiwxNyArNjc0LDE3IEBACiAJCWNtUmVnLnJlZy5wcmVsb2FkUmVnU2VsID0gMTsJLyogIFBSMSAqLwogCQlvdXR3KGNtUmVnLnZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DME0sIHN1YmRldl9jaGFubmVsKSk7CiAKLQkJLyogIExvYWQgdGhlIHByZS1sYW9kIHJlZ2lzdGVyIDEgaGlnaCB3b3JkICovCisJCS8qICBMb2FkIHRoZSBwcmUtbG9hZCByZWdpc3RlciAxIGhpZ2ggd29yZCAqLwogCQl2YWx1ZSA9IChzaG9ydCkoKGluc24tPmRhdGFbM10gPj4gMTYpICYgMHhGRkZGKTsKIAkJb3V0dyh2YWx1ZSwgQUREUl9DSEFOX1JFRyhSRUdfQzBILCBzdWJkZXZfY2hhbm5lbCkpOwogCi0JCS8qICBMb2FkIHRoZSBwcmUtbGFvZCByZWdpc3RlciAxIGxvdyB3b3JkICovCisJCS8qICBMb2FkIHRoZSBwcmUtbG9hZCByZWdpc3RlciAxIGxvdyB3b3JkICovCiAJCXZhbHVlID0gKHNob3J0KShpbnNuLT5kYXRhWzNdICYgMHhGRkZGKTsKIAkJb3V0dyh2YWx1ZSwgQUREUl9DSEFOX1JFRyhSRUdfQzBMLCBzdWJkZXZfY2hhbm5lbCkpOwogCiAJCS8qICBXcml0ZSB0aGUgQ291bnRlciBDb250cm9sIFJlZ2lzdGVyICovCi0JCWlmIChpbnNuLT5kYXRhWzNdICE9IDApIHsKLQkJCXZhbHVlID0gKHNob3J0KShpbnNuLT5kYXRhWzNdICYgMHhGRkZGKTsKKwkJaWYgKGluc24tPmRhdGFbNF0gIT0gMCkgeworCQkJdmFsdWUgPSAoc2hvcnQpKGluc24tPmRhdGFbNF0gJiAweEZGRkYpOwogCQkJb3V0dyh2YWx1ZSwgQUREUl9DSEFOX1JFRyhSRUdfQzBDLCBzdWJkZXZfY2hhbm5lbCkpOwogCQl9CiAJCWJyZWFrOwpAQCAtNjk4LDExICs3MDYsMTEgQEAKIAkJY21SZWcucmVnLnByZWxvYWRSZWdTZWwgPSAwOwkvKiAgUFIwICovCiAJCW91dHcoY21SZWcudmFsdWUsIEFERFJfQ0hBTl9SRUcoUkVHX0MwTSwgc3ViZGV2X2NoYW5uZWwpKTsKIAotCQkvKiAgTG9hZCB0aGUgcHJlLWxhb2QgcmVnaXN0ZXIgMCBoaWdoIHdvcmQgKi8KKwkJLyogIExvYWQgdGhlIHByZS1sb2FkIHJlZ2lzdGVyIDAgaGlnaCB3b3JkICovCiAJCXZhbHVlID0gKHNob3J0KSgoaW5zbi0+ZGF0YVsyXSA+PiAxNikgJiAweEZGRkYpOwogCQlvdXR3KHZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DMEgsIHN1YmRldl9jaGFubmVsKSk7CiAKLQkJLyogIExvYWQgdGhlIHByZS1sYW9kIHJlZ2lzdGVyIDAgbG93IHdvcmQgKi8KKwkJLyogIExvYWQgdGhlIHByZS1sb2FkIHJlZ2lzdGVyIDAgbG93IHdvcmQgKi8KIAkJdmFsdWUgPSAoc2hvcnQpKGluc24tPmRhdGFbMl0gJiAweEZGRkYpOwogCQlvdXR3KHZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DMEwsIHN1YmRldl9jaGFubmVsKSk7CiAKQEAgLTcxMSwxNyArNzE5LDE3IEBACiAJCWNtUmVnLnJlZy5wcmVsb2FkUmVnU2VsID0gMTsJLyogIFBSMSAqLwogCQlvdXR3KGNtUmVnLnZhbHVlLCBBRERSX0NIQU5fUkVHKFJFR19DME0sIHN1YmRldl9jaGFubmVsKSk7CiAKLQkJLyogIExvYWQgdGhlIHByZS1sYW9kIHJlZ2lzdGVyIDEgaGlnaCB3b3JkICovCisJCS8qICBMb2FkIHRoZSBwcmUtbG9hZCByZWdpc3RlciAxIGhpZ2ggd29yZCAqLwogCQl2YWx1ZSA9IChzaG9ydCkoKGluc24tPmRhdGFbM10gPj4gMTYpICYgMHhGRkZGKTsKIAkJb3V0dyh2YWx1ZSwgQUREUl9DSEFOX1JFRyhSRUdfQzBILCBzdWJkZXZfY2hhbm5lbCkpOwogCi0JCS8qICBMb2FkIHRoZSBwcmUtbGFvZCByZWdpc3RlciAxIGxvdyB3b3JkICovCisJCS8qICBMb2FkIHRoZSBwcmUtbG9hZCByZWdpc3RlciAxIGxvdyB3b3JkICovCiAJCXZhbHVlID0gKHNob3J0KShpbnNuLT5kYXRhWzNdICYgMHhGRkZGKTsKIAkJb3V0dyh2YWx1ZSwgQUREUl9DSEFOX1JFRyhSRUdfQzBMLCBzdWJkZXZfY2hhbm5lbCkpOwogCiAJCS8qICBXcml0ZSB0aGUgQ291bnRlciBDb250cm9sIFJlZ2lzdGVyICovCi0JCWlmIChpbnNuLT5kYXRhWzNdICE9IDApIHsKLQkJCXZhbHVlID0gKHNob3J0KShpbnNuLT5kYXRhWzNdICYgMHhGRkZGKTsKKwkJaWYgKGluc24tPmRhdGFbNF0gIT0gMCkgeworCQkJdmFsdWUgPSAoc2hvcnQpKGluc24tPmRhdGFbNF0gJiAweEZGRkYpOwogCQkJb3V0dyh2YWx1ZSwgQUREUl9DSEFOX1JFRyhSRUdfQzBDLCBzdWJkZXZfY2hhbm5lbCkpOwogCQl9CiAJCWJyZWFrOwpAQCAtNzQxLDYgKzc0OSw3IEBACiB7CiAJaW50IHN1YmRldl9jaGFubmVsID0gQ1JfQ0hBTihpbnNuLT5jaGFuc3BlYyk7CS8qICBVbnBhY2sgY2hhbnNwZWMgKi8KIAlzaG9ydCB2YWx1ZTsKKwl1bmlvbiBjbVJlZyBjbVJlZzsKIAogCXByaW50aygiczUyNjogR1BDVF9JTlNOX1dSSVRFIG9uIGNoYW5uZWwgJWRcbiIsIHN1YmRldl9jaGFubmVsKTsKIAljbVJlZy52YWx1ZSA9IGludyhBRERSX0NIQU5fUkVHKFJFR19DME0sIHN1YmRldl9jaGFubmVsKSk7CkBAIC03NzUsOSArNzg0LDggQEAKIAkJCShkZXZwcml2LT5zNTI2X2dwY3RfY29uZmlnW3N1YmRldl9jaGFubmVsXSkuZGF0YVsxXSA9CiAJCQkgICAgaW5zbi0+ZGF0YVsxXTsKIAkJfSBlbHNlIHsKLQkJCXByaW50aygiJWQgXHQgJWRcbiIsIGluc24tPmRhdGFbMV0sIGluc24tPmRhdGFbMl0pOwotCQkJcHJpbnRrCi0JCQkgICAgKCJzNTI2OiBJTlNOX1dSSVRFOiBQVEc6IFByb2JsZW0gd2l0aCBQdWxzZSBwYXJhbXNcbiIpOworCQkJcHJpbnRrKCJzNTI2OiBJTlNOX1dSSVRFOiBQVEc6IFByb2JsZW0gd2l0aCBQdWxzZSBwYXJhbXMgLT4gJWQgJWRcbiIsCisJCQkJaW5zbi0+ZGF0YVswXSwgaW5zbi0+ZGF0YVsxXSk7CiAJCQlyZXR1cm4gLUVJTlZBTDsKIAkJfQogCkBAIC05NDksNyArOTU3LDcgQEAKIAlkYXRhWzFdID0gaW53KEFERFJfUkVHKFJFR19ESU8pKSAmIDB4RkY7CS8qICBsb3cgOCBiaXRzIGFyZSB0aGUgZGF0YSAqLwogCS8qIG9yIHdlIGNvdWxkIGp1c3QgcmV0dXJuIHRoZSBzb2Z0d2FyZSBjb3B5IG9mIHRoZSBvdXRwdXQgdmFsdWVzIGlmCiAJICogaXQgd2FzIGEgcHVyZWx5IGRpZ2l0YWwgb3V0cHV0IHN1YmRldmljZSAqLwotCS8qIGRhdGFbMV09cy0+c3RhdGU7ICovCisJLyogZGF0YVsxXT1zLT5zdGF0ZSAmIDB4RkY7ICovCiAKIAlyZXR1cm4gMjsKIH0KQEAgLTk1OSwyOCArOTY3LDMzIEBACiAJCQkJc3RydWN0IGNvbWVkaV9pbnNuICppbnNuLCB1bnNpZ25lZCBpbnQgKmRhdGEpCiB7CiAJaW50IGNoYW4gPSBDUl9DSEFOKGluc24tPmNoYW5zcGVjKTsKLQlzaG9ydCB2YWx1ZTsKKwlpbnQgZ3JvdXAsIG1hc2s7CiAKIAlwcmludGsoIlM1MjYgRElPIGluc25fY29uZmlnXG4iKTsKIAotCWlmIChpbnNuLT5uICE9IDEpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JdmFsdWUgPSBpbncoQUREUl9SRUcoUkVHX0RJTykpOwotCiAJLyogVGhlIGlucHV0IG9yIG91dHB1dCBjb25maWd1cmF0aW9uIG9mIGVhY2ggZGlnaXRhbCBsaW5lIGlzCiAJICogY29uZmlndXJlZCBieSBhIHNwZWNpYWwgaW5zbl9jb25maWcgaW5zdHJ1Y3Rpb24uICBjaGFuc3BlYwogCSAqIGNvbnRhaW5zIHRoZSBjaGFubmVsIHRvIGJlIGNoYW5nZWQsIGFuZCBkYXRhWzBdIGNvbnRhaW5zIHRoZQogCSAqIHZhbHVlIENPTUVESV9JTlBVVCBvciBDT01FRElfT1VUUFVULiAqLwogCi0JaWYgKGRhdGFbMF0gPT0gQ09NRURJX09VVFBVVCkgewotCQl2YWx1ZSB8PSAxIDw8IChjaGFuICsgMTApOwkvKiAgYml0IDEwLzExIHNldCB0aGUgZ3JvdXAgMS8yJ3MgbW9kZSAqLwotCQlzLT5pb19iaXRzIHw9ICgweEYgPDwgY2hhbik7Ci0JfSBlbHNlIHsKLQkJdmFsdWUgJj0gfigxIDw8IChjaGFuICsgMTApKTsJLyogIDEgaXMgb3V0cHV0LCAwIGlzIGlucHV0LiAqLwotCQlzLT5pb19iaXRzICY9IH4oMHhGIDw8IGNoYW4pOworCWdyb3VwID0gY2hhbiA+PiAyOworCW1hc2sgPSAweEYgPDwgKGdyb3VwIDw8IDIpOworCXN3aXRjaCAoZGF0YVswXSkgeworCWNhc2UgSU5TTl9DT05GSUdfRElPX09VVFBVVDoKKwkJcy0+c3RhdGUgfD0gMSA8PCAoZ3JvdXAgKyAxMCk7ICAvLyBiaXQgMTAvMTEgc2V0IHRoZSBncm91cCAxLzIncyBtb2RlCisJCXMtPmlvX2JpdHMgfD0gbWFzazsKKwkJYnJlYWs7CisJY2FzZSBJTlNOX0NPTkZJR19ESU9fSU5QVVQ6CisJCXMtPnN0YXRlICY9IH4oMSA8PCAoZ3JvdXAgKyAxMCkpOy8vIDEgaXMgb3V0cHV0LCAwIGlzIGlucHV0LgorCQlzLT5pb19iaXRzICY9IH5tYXNrOworCQlicmVhazsKKwljYXNlIElOU05fQ09ORklHX0RJT19RVUVSWToKKwkJZGF0YVsxXSA9IChzLT5pb19iaXRzICYgbWFzaykgPyBDT01FRElfT1VUUFVUIDogQ09NRURJX0lOUFVUOworCQlyZXR1cm4gaW5zbi0+bjsKKwlkZWZhdWx0OgorCQlyZXR1cm4gLUVJTlZBTDsKIAl9Ci0Jb3V0dyh2YWx1ZSwgQUREUl9SRUcoUkVHX0RJTykpOworCW91dHcocy0+c3RhdGUsIEFERFJfUkVHKFJFR19ESU8pKTsKIAogCXJldHVybiAxOwogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3NlcmlhbDIwMDIuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb21lZGkvZHJpdmVycy9zZXJpYWwyMDAyLmMKaW5kZXggYTIxOTY3OS4uODJhYTg2ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2NvbWVkaS9kcml2ZXJzL3NlcmlhbDIwMDIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvY29tZWRpL2RyaXZlcnMvc2VyaWFsMjAwMi5jCkBAIC0zNSw2ICszNSw3IEBACiAKICNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAKICNpbmNsdWRlIDxhc20vdGVybWlvcy5oPgogI2luY2x1ZGUgPGFzbS9pb2N0bHMuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb3dsb29wL0tjb25maWcgYi9kcml2ZXJzL3N0YWdpbmcvY293bG9vcC9LY29uZmlnCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA1OGQyYTIzLi4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb3dsb29wL0tjb25maWcKKysrIC9kZXYvbnVsbApAQCAtMSwxNiArMCwwIEBACi1jb25maWcgQ09XTE9PUAotCXRyaXN0YXRlICJjb3B5LW9uLXdyaXRlIHBzZXVkbyBCbG9jayBEcml2ZXIiCi0JZGVwZW5kcyBvbiBCTE9DSwotCWRlZmF1bHQgbgotCS0tLWhlbHAtLS0KLQkgIENvd2xvb3AgaXMgYSAiY29weS1vbi13cml0ZSIgcHNldWRvIGJsb2NrIGRyaXZlci4gSXQgY2FuIGJlCi0JICBzdGFja2VkIG9uIHRvcCBvZiBhICJyZWFsIiBibG9jayBkcml2ZXIsIGFuZCBjYXRjaGVzIGFsbCB3cml0ZQotCSAgb3BlcmF0aW9ucyBvbiB0aGVpciB3YXkgZnJvbSB0aGUgZmlsZSBzeXN0ZW1zIGxheWVyIGFib3ZlIHRvCi0JICB0aGUgcmVhbCBkcml2ZXIgYmVsb3csIGVmZmVjdGl2ZWx5IHNoaWVsZGluZyB0aGUgbG93ZXIgZHJpdmVyCi0JICBmcm9tIHRob3NlIHdyaXRlIGFjY2Vzc2VzLiBUaGUgcmVxdWVzdHMgYXJlIHRoZW4gZGl2ZXJ0ZWQgdG8KLQkgIGFuIG9yZGluYXJ5IGZpbGUsIGxvY2F0ZWQgc29tZXdoZXJlIGVsc2UgKGNvbmZpZ3VyYWJsZSkuIExhdGVyCi0JICByZWFkIHJlcXVlc3RzIGFyZSBjaGVja2VkIHRvIHNlZSB3aGV0aGVyIHRoZXkgY2FuIGJlIHNlcnZpY2VkCi0JICBieSB0aGUgInJlYWwiIGJsb2NrIGRyaXZlciBiZWxvdywgb3IgbXVzdCBiZSBwdWxsZWQgaW4gZnJvbQotCSAgdGhlIGRpdmVydGVkIGxvY2F0aW9uLiBNb3JlIGluZm9ybWF0aW9uIGFuZCB1c2Vyc3BhY2UgdG9vbHMgdG8KLQkgIHVzZSB0aGUgZHJpdmVyIGFyZSBvbiB0aGUgcHJvamVjdCdzIHdlYnNpdGUKLQkgIGh0dHA6Ly93d3cuQVRDb21wdXRpbmcubmwvY293bG9vcC8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb3dsb29wL01ha2VmaWxlIGIvZHJpdmVycy9zdGFnaW5nL2Nvd2xvb3AvTWFrZWZpbGUKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDJiNmI4MWEuLjAwMDAwMDAKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2Nvd2xvb3AvTWFrZWZpbGUKKysrIC9kZXYvbnVsbApAQCAtMSArMCwwIEBACi1vYmotJChDT05GSUdfQ09XTE9PUCkJKz0gY293bG9vcC5vCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvY293bG9vcC9UT0RPIGIvZHJpdmVycy9zdGFnaW5nL2Nvd2xvb3AvVE9ETwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOTM5OWQxYy4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY293bG9vcC9UT0RPCisrKyAvZGV2L251bGwKQEAgLTEsMTEgKzAsMCBAQAotVE9ETzoKLQktIGNoZWNrcGF0Y2gucGwgY2xlYW51cHMKLQktIHJ1biBzcGFyc2UgdG8gZW5zdXJlIGNsZWFuCi0JLSBmaXggdXAgMzIvNjRiaXQgaW9jdGwgaXNzdWVzCi0JLSBtb3ZlIHByb2MgZmlsZSB1c2FnZSB0byBkZWJ1Z2ZzCi0JLSBhdWRpdCBpb2N0bHMKLQktIGFkZCBkb2N1bWVudGF0aW9uCi0JLSBnZXQgbGludXgtZnNkZXZlbCB0byByZXZpZXcgaXQKLQotUGxlYXNlIHNlbmQgcGF0Y2hlcyB0byAiSC5KLiBUaG9tYXNzZW4iIDxoanRAQVRDb21wdXRpbmcubmw+IGFuZAotR3JlZyBLcm9haC1IYXJ0bWFuIDxncmVna2hAc3VzZS5kZT4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9jb3dsb29wL2Nvd2xvb3AuYyBiL2RyaXZlcnMvc3RhZ2luZy9jb3dsb29wL2Nvd2xvb3AuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTcxYzc0My4uMDAwMDAwMAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvY293bG9vcC9jb3dsb29wLmMKKysrIC9kZXYvbnVsbApAQCAtMSwyODQyICswLDAgQEAKLS8qCi0qKiAgICAgICBDT1dMT09QIGJsb2NrIGRldmljZSBkcml2ZXIgKDIuNiBrZXJuZWwgY29tcGxpYW50KQotKiogPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSoqIFJlYWQtd3JpdGUgbG9vcC1kcml2ZXIgd2l0aCBjb3B5LW9uLXdyaXRlIGZ1bmN0aW9uYWxpdHkuCi0qKgotKiogU3lub3BzaXM6Ci0qKgotKiogICAgIG1vZHByb2JlIGNvd2xvb3AgW21heGNvd3M9Li5dIFtyZG9maWxlPS4uLi4uIGNvd2ZpbGU9Li4uLiBbb3B0aW9uPXJdXQotKioKLSoqIERlZmluaXRpb24gb2YgbnVtYmVyIG9mIGNvbmZpZ3VyZWQgY293ZGV2aWNlczoKLSoqICAgbWF4Y293cz0JbnVtYmVyIG9mIGNvbmZpZ3VyZWQgY293ZGV2aWNlcyAoZGVmYXVsdDogMTYpCi0qKiAoZG8gbm90IGNvbmZ1c2UgdGhpcyB3aXRoIE1BWENPV1M6IGFic29sdXRlIG1heGltdW0gYXMgY29tcGlsZWQpCi0qKgotKiogT25lIHBhaXIgb2YgZmlsZW5hbWVzIGNhbiBiZSBzdXBwbGllZCBkdXJpbmcgaW5zbW9kL21vZHByb2JlIHRvIG9wZW4KLSoqIHRoZSBmaXJzdCBjb3dkZXZpY2U6Ci0qKiAgIHJkb2ZpbGU9CXJlYWQtb25seSBmaWxlIChvciBmaWxlc3lzdGVtKQotKiogICBjb3dmaWxlPQlzdG9yYWdlLXNwYWNlIGZvciBtb2RpZmllZCBibG9ja3Mgb2YgcmVhZC1vbmx5IGZpbGUoc3lzdGVtKQotKiogICBvcHRpb249cglyZXBhaXIgY293ZmlsZSBhdXRvbWF0aWNhbGx5IGlmIGl0IGFwcGVhcnMgdG8gYmUgZGlydHkKLSoqCi0qKiBPdGhlciBjb3dkZXZpY2VzIGNhbiBiZSBhY3RpdmF0ZWQgdmlhIHRoZSBjb21tYW5kICJjb3dkZXYiCi0qKiB3aGVuZXZlciB0aGUgY293bG9vcC1kcml2ZXIgaXMgbG9hZGVkLgotKioKLSoqIFRoZSByZWFkLW9ubHkgZmlsZSBtYXkgYmUgb2YgdHlwZSAncmVndWxhcicgb3IgJ2Jsb2NrLWRldmljZScuCi0qKgotKiogVGhlIGNvd2ZpbGUgbXVzdCBiZSBvZiB0eXBlICdyZWd1bGFyJy4KLSoqIElmIGFuIGV4aXN0aW5nIHJlZ3VsYXIgZmlsZSBpcyB1c2VkIGFzIGNvd2ZpbGUsIGl0cyBjb250ZW50cyB3aWxsIGJlCi0qKiB1c2VkIGFnYWluIGZvciB0aGUgY3VycmVudCByZWFkLW9ubHkgZmlsZS4gV2hlbiB0aGUgY293ZmlsZSBoYXMgbm90IGJlZW4KLSoqIGNsb3NlZCBwcm9wZXJseSBkdXJpbmcgYSBwcmV2aW91cyBzZXNzaW9uIChpLmUuIHJtbW9kIGNvd2xvb3ApLCB0aGUKLSoqIGNvd2xvb3AtZHJpdmVyIHJlZnVzZXMgdG8gb3BlbiBpdCB1bmxlc3MgdGhlIHBhcmFtZXRlciAib3B0aW9uPXIiIGlzCi0qKiBzcGVjaWZpZWQuCi0qKgotKiogTGF5b3V0IG9mIGNvd2ZpbGU6Ci0qKgotKiogCSstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSsKLSoqCXwgICAgICAgY293IGhlYWQgYmxvY2sgICAgICAgIHwgICBNQVBVTklUIGJ5dGVzCi0qKgl8LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18Ci0qKgl8ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgTUFQVU5JVCBieXRlcwotKioJfC0tLSAgICAgICAgICAgICAgICAgICAgICAgLS0tfAotKioJfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIE1BUFVOSVQgYnl0ZXMKLSoqCXwtLS0gICAgICAgICAgICAgICAgICAgICAgIC0tLXwKLSoqCXwgICAgICB1c2VkLWJsb2NrIGJpdG1hcCAgICAgIHwgICBNQVBVTklUIGJ5dGVzCi0qKgl8LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18Ci0qKgl8ICBnYXAgdG8gYWxpZ24gc3RhcnQtb2Zmc2V0ICB8Ci0qKgl8ICAgICAgICB0byA0SyBtdWx0aXBsZSAgICAgICB8Ci0qKgl8LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS18ICA8LS0tLSBzdGFydC1vZmZzZXQgY293IGJsb2NrcwotKioJfCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfAotKiogICAgICB8ICAgIHdyaXR0ZW4gY293IGJsb2NrcyAgICAgICB8ICAgTUFQVU5JVCBieXRlcwotKiogICAgICB8ICAgICAgICAgIC4uLi4uICAgICAgICAgICAgICB8Ci0qKgotKiogCWNvd2hlYWQgYmxvY2s6Ci0qKiAgIAkgIC0gY29udGFpbnMgZ2VuZXJhbCBpbmZvIGFib3V0IHRoZSByZG9maWxlIHdoaWNoIGlzIHJlbGF0ZWQKLSoqIAkgICAgdG8gdGhpcyBjb3dmaWxlCi0qKgotKiogCXVzZWQtYmxvY2sgYml0bWFwOgotKiogCSAgLSBjb250YWlucyBvbmUgYml0IHBlciBibG9jayB3aXRoIGEgc2l6ZSBvZiBNQVBVTklUIGJ5dGVzCi0qKiAJICAtIGJpdC12YWx1ZSAnMScgPSBibG9jayBoYXMgYmVlbiB3cml0dGVuIG9uIGNvdwotKiogCSAgICAgICAgICAgICAgJzAnID0gYmxvY2sgdW51c2VkIG9uIGNvdwotKiogCSAgLSB0b3RhbCBiaXRtYXAgcm91bmRlZCB0byBtdWx0aXBsZXMgb2YgTUFQVU5JVAotKioKLSoqID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLSoqIEF1dGhvcjogICAgICAgICAgICAgR2VybG9mIExhbmdldmVsZCAtIEFUIENvbXB1dGluZyAoTWFyY2ggMjAwMykKLSoqIEN1cnJlbnQgbWFpbnRhaW5lcjogSGVuZHJpay1KYW4gVGhvbWFzc2VuIC0gQVQgQ29tcHV0aW5nIChTdW1tZXIgMjAwNikKLSoqIEVtYWlsOiAgICAgICAgICAgICAgaGp0QEFUQ29tcHV0aW5nLm5sCi0qKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi0qKiBDb3B5cmlnaHQgKEMpIDIwMDMtMjAwOSBBVCBDb25zdWx0YW5jeQotKioKLSoqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0Ci0qKiB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKLSoqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiwgb3IgKGF0IHlvdXIgb3B0aW9uKSBhbnkKLSoqIGxhdGVyIHZlcnNpb24uCi0qKgotKiogVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAotKiogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgotKiogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLgotKiogU2VlIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgotKioKLSoqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCi0qKiBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbTsgaWYgbm90LCB3cml0ZSB0byB0aGUgRnJlZSBTb2Z0d2FyZQotKiogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQotKiogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQotKioKLSoqIE1ham9yIG1vZGlmaWNhdGlvbnM6Ci0qKgotKiogCTIwMDQwNQlQb3J0ZWQgdG8ga2VybmVsLXZlcnNpb24gMi42CQlIZW5kcmlrLUphbiBUaG9tYXNzZW4KLSoqCTIwMDQwNQlBZGRlZCBjb3doZWFkIHRvIGNvd2ZpbGUgdG8gZ2FyYW50ZWUKLSoqCQljb25zaXN0ZW5jeSB3aXRoIHJlYWQtb25seSBmaWxlCQlHZXJsb2YgTGFuZ2V2ZWxkCi0qKgkyMDA0MDUJUG9zdHBvbmVkIGZsdXNoaW5nIG9mIGJpdG1hcHMgdG8gaW1wcm92ZQotKioJCXBlcmZvcm1hbmNlLiAJCQkJR2VybG9mIExhbmdldmVsZAotKioJMjAwNDA1CUlubGluZSByZWNvdmVyeSBmb3IgZGlydHkgY293ZmlsZXMuCUdlcmxvZiBMYW5nZXZlbGQKLSoqCTIwMDUwMglSZWRlc2lnbiB0byBzdXBwb3J0IG1vcmUgY293ZGV2aWNlcy4JR2VybG9mIExhbmdldmVsZAotKioJMjAwNTAyCVN1cHBvcnQgZGV2aWNlcy9maWxlID4gMiBHYnl0ZXMuCUdlcmxvZiBMYW5nZXZlbGQKLSoqCTIwMDUwNwlDaGVjayBmb3IgZnJlZSBzcGFjZSB0byBleHBhbmQgY293ZmlsZS4JR2VybG9mIExhbmdldmVsZAotKioJMjAwOTAyICBVcGdyYWRlIGZvciBrZXJuZWwgMi42LjI4ICAgICAgICAgICAgICAgSGVuZHJpay1KYW4gVGhvbWFzc2VuCi0qKgotKiogSW5zcGlyZWQgYnkKLSoqICAgIGxvb3AuYyAgYnkgVGhlb2RvcmUgVHMnbyBhbmQKLSoqICAgIGNsb29wLmMgYnkgUGF1bCBgUnVzdHknIFJ1c3NlbGwgJiBLbGF1cyBLbm9wcGVyLgotKioKLSoqIERlc2lnbi1jb25zaWRlcmF0aW9uczoKLSoqCi0qKiAgIEZvciB0aGUgZmlyc3QgZXhwZXJpbWVudHMgd2l0aCB0aGUgY293bG9vcC1kcml2ZXIsIHRoZSByZXF1ZXN0LXF1ZXVlCi0qKiAgIG1hZGUgdXNlIG9mIHRoZSBkb19nZW5lcmljX2ZpbGVfcmVhZCgpIHdoaWNoIHdvcmtlZCBmaW5lIGV4Y2VwdAotKiogICBpbiBjb21iaW5hdGlvbiB3aXRoIHRoZSBjbG9vcC1kcml2ZXI7IHRoYXQgY29tYmluYXRpb24KLSoqICAgcmVzdWx0ZWQgaW4gYSBub24taW50ZXJydXB0aWJsZSBoYW5ndXAgb2YgdGhlIHN5c3RlbSBkdXJpbmcKLSoqICAgaGVhdnkgbG9hZC4gT3RoZXIgZXhwZXJpbWVudHMgdXNpbmcgdGhlIGBtYWtlX3JlcXVlc3QnIGludGVyZmFjZSBhbHNvCi0qKiAgIHJlc3VsdGVkIGluIHVucHJlZGljdGFibGUgc3lzdGVtIGhhbmd1cHMgKHdpdGggcHJvcGVyIHVzZSBvZiBzcGlubG9ja3MpLgotKioKLSoqICAgVG8gb3ZlcmNvbWUgdGhlc2UgcHJvYmxlbXMsIHRoZSBjb3dsb29wLWRyaXZlciBzdGFydHMgYSBrZXJuZWwtdGhyZWFkCi0qKiAgIGZvciBldmVyeSBhY3RpdmUgY293ZGV2aWNlLgotKiogICBBbGwgcmVhZC0gYW5kIHdyaXRlLXJlcXVlc3Qgb24gdGhlIHJlYWQtb25seSBmaWxlIGFuZCBjb3B5LW9uLXdyaXRlIGZpbGUKLSoqICAgYXJlIGhhbmRsZWQgaW4gdGhlIGNvbnRleHQgb2YgdGhhdCB0aHJlYWQuCi0qKiAgIEEgc2NoZW1lIGhhcyBiZWVuIGRlc2lnbmVkIHRvIHdha2V1cCB0aGUga2VybmVsLXRocmVhZCBhcwotKiogICBzb29uIGFzIEkvTy1yZXF1ZXN0cyBhcmUgYXZhaWxhYmxlIGluIHRoZSByZXF1ZXN0LXF1ZXVlOyB0aGlzIHRocmVhZAotKiogICBoYW5kbGVzIHRoZSByZXF1ZXN0cyBvbmUtYnktb25lIGJ5IGNhbGxpbmcgdGhlIHByb3BlciByZWFkLSBvcgotKiogICB3cml0ZS1mdW5jdGlvbiByZWxhdGVkIHRvIHRoZSBvcGVuIHJlYWQtb25seSBmaWxlIG9yIGNvcHktb24td3JpdGUgZmlsZS4KLSoqICAgV2hlbiBhbGwgcGVuZGluZyByZXF1ZXN0cyBoYXZlIGJlZW4gaGFuZGxlZCwgdGhlIGtlcm5lbC10aHJlYWQgZ29lcwotKiogICBiYWNrIHRvIHNsZWVwLXN0YXRlLgotKiogICBUaGlzIGFwcHJvYWNoIHJlcXVpcmVzIHNvbWUgYWRkaXRpb25hbCBjb250ZXh0LXN3aXRjaGVzOyBob3dldmVyIHRoZQotKiogICBwZXJmb3JtYW5jZSBsb3NzIGR1cmluZyBoZWF2eSBJL08gaXMgbGVzcyB0aGFuIDMlLgotKioKLSoqIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwotLyogVGhlIGZvbGxvd2luZyBpcyB0aGUgY293bG9vcCBwYWNrYWdlIHZlcnNpb24gbnVtYmVyLiBJdCBtdXN0IGJlCi0gICBpZGVudGljYWwgdG8gdGhlIGNvbnRlbnQgb2YgdGhlIGluY2x1ZGUtZmlsZSAidmVyc2lvbi5oIiB0aGF0IGlzCi0gICB1c2VkIGluIGFsbCBzdXBwb3J0aW5nIHV0aWxpdGllczogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KLWNoYXIgcmV2aXNpb25bXSA9ICIkUmV2aXNpb246IDMuMSAkIjsgLyogY293bG9faW5pdF9tb2R1bGUoKSBoYXMKLQkJCSAgICAgYXNzdW1wdGlvbnMgYWJvdXQgdGhpcyBzdHJpbmcncyBmb3JtYXQgICAqLwotCi0vKiBOb3RlIHRoYXQgdGhlIGZvbGxvd2luZyBudW1iZXJzIGFyZSAqbm90KiB0aGUgY293bG9vcCBwYWNrYWdlIHZlcnNpb24KLSAgIG51bWJlcnMsIGJ1dCBzZXBhcmF0ZSByZXZpc2lvbiBoaXN0b3J5IG51bWJlcnMgdG8gdHJhY2sgdGhlCi0gICBtb2RpZmljYXRpb25zIG9mIHRoaXMgcGFydGljdWxhciBzb3VyY2UgZmlsZTogICAgICAgICAgICAgICAgICAgICAgKi8KLS8qICRMb2c6IGNvd2xvb3AuYyx2ICQKLSoqCi0qKiBSZXZpc2lvbiAxLjMwICAyMDA5LzAyLzA4IGhqdAotKiogSW50ZWdyYXRlZCBlYXJsaWVyIGZpeGVzCi0qKiBVcGdyYWRlZCB0byBrZXJuZWwgMi42LjI4ICh0aGFua3MgSmVyb21lIFBvdWxpbikKLSoqCi0qKiBSZXZpc2lvbiAxLjI5ICAyMDA2LzEyLzAzIDIyOjEyOjAwICBoanQKLSoqIGNoYW5nZWQgJ2Nvd2RldmxvY2snIGZyb20gc3BpbmxvY2sgdG8gc2VtYXBob3JlLCB0byBhdm9pZAotKiogInNjaGVkdWxpbmcgd2hpbGUgYXRvbWljIi4gQ29udHJpYnV0ZWQgYnkgSnVlcmdlbiBDaHJpc3QuCi0qKiBBZGRlZCB2ZXJzaW9uLmggYWdhaW4KLSoqCi0qKiBSZXZpc2lvbiAxLjI4ICAyMDA2LzA4LzE2IDE2OjAwOjAwICBoanQKLSoqIG1hbGxvYyBlYWNoIGluZGl2aWR1YWwgY293bG9vcGRldmljZSBzdHJ1Y3Qgc2VwYXJhdGVseQotKioKLSoqIFJldmlzaW9uIDEuMjcgIDIwMDYvMDMvMTQgMTQ6NTc6MDMgIHJvb3QKLSoqIFJlbW92ZWQgaW5jbHVkZSB2ZXJzaW9uLmgKLSoqCi0qKiBSZXZpc2lvbiAxLjI2ICAyMDA1LzA4LzA4IDExOjIyOjQ4ICByb290Ci0qKiBJbXBsZW1lbnQgcG9zc2liaWxpdHkgdG8gY2xvc2UgYSBjb3cgZmlsZSBvciByZW9wZW4gYSBjb3dmaWxlIHJlYWQtb25seS4KLSoqCi0qKiBSZXZpc2lvbiAxLjI1ICAyMDA1LzA4LzAzIDE0OjAwOjM5ICByb290Ci0qKiBBZGRlZCBtb2RpbmZvIGluZm8gdG8gZHJpdmVyLgotKioKLSoqIFJldmlzaW9uIDEuMjQgIDIwMDUvMDcvMjEgMDY6MTQ6NTMgIHJvb3QKLSoqIENvc21ldGljIGNoYW5nZXMgc291cmNlIGNvZGUuCi0qKgotKiogUmV2aXNpb24gMS4yMyAgMjAwNS8wNy8yMCAxMzowNzozMiAgcm9vdAotKiogU3VwcGx5IGlvY3RsIHRvIHdyaXRlIHdhdGNoZG9nIHByb2dyYW0gdG8gcmVhY3Qgb24gbGFjayBvZiBjb3dmaWxlIHNwYWNlLgotKioKLSoqIFJldmlzaW9uIDEuMjIgIDIwMDUvMDcvMjAgMDc6NTM6MzQgIHJvb3QKLSoqIFJlZ3VsYXIgdmVyaWZpY2F0aW9uIG9mIGZyZWUgc3BhY2UgaW4gZmlsZXN5c3RlbSBob2xkaW5nIHRoZSBjb3dmaWxlCi0qKiAoZ2l2ZSB3YXJuaW5ncyB3aGVuZXZlciBzcGFjZSBpcyBhbG1vc3QgZXhoYXVzdGVkKS4KLSoqIFRlcm1pbm9sb2d5IGNoYW5nZTogY2hlY2tzdW0gcmVuYW1lZCB0byBmaW5nZXJwcmludC4KLSoqCi0qKiBSZXZpc2lvbiAxLjIxICAyMDA1LzA3LzE5IDA5OjIxOjUyICByb290Ci0qKiBSZW1vdmluZyBtYXhpbXVtIGxpbWl0IG9mIDE2IEdiIHBlciBjb3dkZXZpY2UuCi0qKgotKiogUmV2aXNpb24gMS4yMCAgMjAwNS8wNy8xOSAwNzo1MDozMyAgcm9vdAotKiogTWlub3IgYnVnZml4ZXMgYW5kIGNvc21ldGljIGNoYW5nZXMuCi0qKgotKiogUmV2aXNpb24gMS4xOSAgMjAwNS8wNi8xMCAxMjoyOTo1NSAgcm9vdAotKiogUmVtb3ZlZCBsb2NrL3VubG9jayBvcGVyYXRpb24gZnJvbSBjb3dsb19vcGVuKCkuCi0qKgotKiogUmV2aXNpb24gMS4xOCAgMjAwNS8wNS8wOSAxMjo1NjoyNiAgcm9vdAotKiogQWxsb3cgYSBjb3dkZXZpY2UgdG8gYmUgb3BlbiBtb3JlIHRoYW4gb25jZQotKiogKG5lZWRlZCBmb3Igc3VwcG9ydCBvZiBSZWlzZXJGUyBhbmQgWEZTKS4KLSoqCi0qKiBSZXZpc2lvbiAxLjE3ICAyMDA1LzAzLzE3IDE0OjM2OjE2ICByb290Ci0qKiBGaXhlZCBzb21lIGxpY2Vuc2UgaXNzdWVzLgotKioKLSoqIFJldmlzaW9uIDEuMTYgIDIwMDUvMDMvMDcgMTQ6NDI6MDUgIHJvb3QKLSoqIE9ubHkgYWxsb3cgb25lIHBhcmFsbGVsIG9wZW4gcGVyIGNvd2RldmljZS4KLSoqCi0qKiBSZXZpc2lvbiAxLjE1ICAyMDA1LzAyLzE4IDExOjUyOjA0ICBnZXJsb2YKLSoqIFJlZGVzaWduIHRvIHN1cHBvcnQgbW9yZSB0aGFuIG9uZSBjb3dkZXZpY2UgPiAyIEdiIHNwYWNlLgotKioKLSoqIFJldmlzaW9uIDEuMTQgIDIwMDQvMDgvMTcgMTQ6MTk6MTYgIGdlcmxvZgotKiogTW9kaWZpZWQgb3V0cHV0IG9mIC9wcm9jL2Nvd2xvb3AuCi0qKgotKiogUmV2aXNpb24gMS4xMyAgMjAwNC8wOC8xNiAwNzoyMToxMCAgZ2VybG9mCi0qKiBTZXBhcmF0ZSBzdGF0aXN0aWNhbCBjb3VudGVyIGZvciByZWFkIG9uIHJkb2ZpbGUgYW5kIGNvd2ZpbGUuCi0qKgotKiogUmV2aXNpb24gMS4xMiAgMjAwNC8wOC8xMSAwNjo1MjoxMSAgZ2VybG9mCi0qKiBNb2RpZmllZCBtZXNzYWdlcy4KLSoqCi0qKiBSZXZpc2lvbiAxLjExICAyMDA0LzA4LzExIDA2OjQ0OjExICBnZXJsb2YKLSoqIE1vZGlmaWVkIGxvZyBtZXNzYWdlcy4KLSoqCi0qKiBSZXZpc2lvbiAxLjEwICAyMDA0LzA4LzEwIDEyOjI3OjI3ICBnZXJsb2YKLSoqIENvc21ldGljIGNoYW5nZXMuCi0qKgotKiogUmV2aXNpb24gMS45ICAyMDA0LzA4LzA5IDExOjQzOjM3ICBnZXJsb2YKLSoqIFJlbW92ZWQgZG91YmxlIGRlZmluaXRpb24gb2YgbWFqb3IgbnVtYmVyIChDT1dNQUpPUikuCi0qKgotKiogUmV2aXNpb24gMS44ICAyMDA0LzA4LzA5IDA4OjAzOjM5ICBnZXJsb2YKLSoqIENsZWFudXAgb2YgbWVzc2FnZXMuCi0qKgotKiogUmV2aXNpb24gMS43ICAyMDA0LzA1LzI3IDA2OjM3OjMzICBnZXJsb2YKLSoqIE1vZGlmaWVkIC9wcm9jIG1lc3NhZ2UuCi0qKgotKiogUmV2aXNpb24gMS42ICAyMDA0LzA1LzI2IDIxOjIzOjI4ICBnZXJsb2YKLSoqIE1vZGlmaWVkIC9wcm9jIG91dHB1dC4KLSoqCi0qKiBSZXZpc2lvbiAxLjUgIDIwMDQvMDUvMjYgMTM6MjM6MzQgIGdlcmxvZgotKiogU3VwcG9ydCBjb3dzeW5jIHRvIGZvcmNlIGZsdXNoaW5nIHRoZSBiaXRtYXBzIGFuZCBjb3doZWFkLgotKioKLSoqIFJldmlzaW9uIDEuNCAgMjAwNC8wNS8yNiAxMToxMToxMCAgZ2VybG9mCi0qKiBVcGRhdGVkIHRoZSBjb21tZW50IHRvIHRoZSBhY3R1YWwgc2l0dWF0aW9uLgotKioKLSoqIFJldmlzaW9uIDEuMyAgMjAwNC8wNS8yNiAxMDo1MDowMCAgZ2VybG9mCi0qKiBJbXBsZW1lbnRlZCByZWNvdmVyeS1vcHRpb24uCi0qKgotKiogUmV2aXNpb24gMS4yICAyMDA0LzA1LzI1IDE1OjE0OjQxICBnZXJsb2YKLSoqIE1vZGlmaWVkIGJpdG1hcCBmbHVzaGluZyBzdHJhdGVneS4KLSoqCi0qLwotCi0jZGVmaW5lIENPV01BSk9SCTI0MQotCi0vLyAjZGVmaW5lIENPV0RFQlVHCi0KLSNpZmRlZiAJQ09XREVCVUcKLSNkZWZpbmUgREVCVUdQCQlwcmludGsKLSNkZWZpbmUgRENPVwkJS0VSTl9BTEVSVAotI2Vsc2UKLSNkZWZpbmUgREVCVUdQKGZvcm1hdCwgeC4uLikKLSNlbmRpZgotCi0jaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KLSNpbmNsdWRlIDxsaW51eC9hdXRvY29uZi5oPgotI2lmbmRlZiBBVVRPQ09ORl9JTkNMVURFRAotI2luY2x1ZGUgPGxpbnV4L2NvbmZpZy5oPgotI2VuZGlmCi0jaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Ci0jaW5jbHVkZSA8bGludXgvdmVyc2lvbi5oPgotI2luY2x1ZGUgPGxpbnV4L21vZHVsZXBhcmFtLmg+Ci0jaW5jbHVkZSA8bGludXgvaW5pdC5oPgotI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+Ci0jaW5jbHVkZSA8bGludXgva2VybmVsLmg+Ci0jaW5jbHVkZSA8bGludXgvbWFqb3IuaD4KLSNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgotI2luY2x1ZGUgPGxpbnV4L2ZzLmg+Ci0jaW5jbHVkZSA8bGludXgvZmlsZS5oPgotI2luY2x1ZGUgPGxpbnV4L3N0YXQuaD4KLSNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+Ci0jaW5jbHVkZSA8bGludXgvc2xhYi5oPgotI2luY2x1ZGUgPGxpbnV4L3NlbWFwaG9yZS5oPgotI2luY2x1ZGUgPGFzbS91YWNjZXNzLmg+Ci0jaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgotI2luY2x1ZGUgPGxpbnV4L2Jsa2Rldi5oPgotI2luY2x1ZGUgPGxpbnV4L2J1ZmZlcl9oZWFkLmg+Ci0jaW5jbHVkZSA8bGludXgvaGRyZWcuaD4KLSNpbmNsdWRlIDxsaW51eC9nZW5oZC5oPgotI2luY2x1ZGUgPGxpbnV4L3N0YXRmcy5oPgotCi0jaW5jbHVkZSAiY293bG9vcC5oIgotCi1NT0RVTEVfTElDRU5TRSgiR1BMIik7Ci0vKiBNT0RVTEVfQVVUSE9SKCJHZXJsb2YgTGFuZ2V2ZWxkIDxnZXJsb2ZAQVRDb21wdXRpbmcubmw+Iik7ICAgICBvYnNvbGV0ZSBhZGRyZXNzICovCi1NT0RVTEVfQVVUSE9SKCJIZW5kcmlrLUphbiBUaG9tYXNzZW4gPGhqdEBBVENvbXB1dGluZy5ubD4iKTsgLyogY3VycmVudCBtYWludGFpbmVyICovCi1NT0RVTEVfREVTQ1JJUFRJT04oIkNvcHktb24td3JpdGUgbG9vcCBkcml2ZXIiKTsKLU1PRFVMRV9QQVJNX0RFU0MobWF4Y293cywgIiBOdW1iZXIgb2YgY29uZmlndXJlZCBjb3dkZXZpY2VzIChkZWZhdWx0IDE2KSIpOwotTU9EVUxFX1BBUk1fREVTQyhyZG9maWxlLCAiIFJlYWQtb25seSBmaWxlIGZvciAvZGV2L2Nvdy8wIik7Ci1NT0RVTEVfUEFSTV9ERVNDKGNvd2ZpbGUsICIgQ293ZmlsZSBmb3IgL2Rldi9jb3cvMCIpOwotTU9EVUxFX1BBUk1fREVTQyhvcHRpb24sICIgIFJlcGFpciBjb3dmaWxlIGlmIGluY29uc2lzdGVudDogb3B0aW9uPXIiKTsKLQotI2RlZmluZSBERVZJQ0VfTkFNRQkiY293IgotCi0jZGVmaW5lCURGTENPV1MJCTE2CQkvKiBkZWZhdWx0IGNvd2xvb3AgZGV2aWNlcwkqLwotCi1zdGF0aWMgaW50IG1heGNvd3MgPSBERkxDT1dTOwotbW9kdWxlX3BhcmFtKG1heGNvd3MsIGludCwgMCk7Ci1zdGF0aWMgY2hhciAqcmRvZmlsZSA9ICIiOwotbW9kdWxlX3BhcmFtKHJkb2ZpbGUsIGNoYXJwLCAwKTsKLXN0YXRpYyBjaGFyICpjb3dmaWxlID0gIiI7Ci1tb2R1bGVfcGFyYW0oY293ZmlsZSwgY2hhcnAsIDApOwotc3RhdGljIGNoYXIgKm9wdGlvbiA9ICIiOwotbW9kdWxlX3BhcmFtKG9wdGlvbiwgY2hhcnAsIDApOwotCi0vKgotKiogcGVyIGNvd2RldmljZSBzZXZlcmFsIGJpdG1hcCBjaHVua3MgYXJlIGFsbG93ZWQgb2YgTUFQQ0hVTktTWiBlYWNoCi0qKgotKiogZWFjaCBiaXRtYXAgY2h1bmsgY2FuIGRlc2NyaWJlIE1BUENIVU5LU1ogKiA4ICogTUFQVU5JVCBieXRlcyBvZiBkYXRhCi0qKiBzdXBwb3NlOgotKioJTUFQQ0hVTktTWiA0MDk2IGFuZCBNQVBVTklUIDEwMjQgLS0+IDQwOTYgKiA4ICogMTAyNCA9IDMyIE1iIHBlciBjaHVuawotKi8KLSNkZWZpbmUJTUFQQ0hVTktTWgk0MDk2CS8qICNieXRlcyBwZXIgYml0bWFwIGNodW5rICAoZG8gbm90IGNoYW5nZSkgICovCi0KLSNkZWZpbmUgU1BDTUlOQkxLCTEwMAkvKiBzcGFjZSB0aHJlc2hvbGQgdG8gZ2l2ZSB3YXJuaW5nIG1lc3NhZ2VzICAqLwotI2RlZmluZSBTUENERkxJTlRWTAkxNgkvKiBvbmNlIGV2ZXJ5IFNQQ0RGTElOVFZMIHdyaXRlcyB0byBjb3dmaWxlLCAqLwotCQkJCS8qIGF2YWlsYWJsZSBzcGFjZSBpbiBmaWxlc3lzdGVtIGlzIGNoZWNrZWQgICovCi0KLSNkZWZpbmUJQ0FMQ01BUCh4KQkoKHgpLyhNQVBDSFVOS1NaKjgpKQotI2RlZmluZQlDQUxDQllURSh4KQkoKCh4KSUoTUFQQ0hVTktTWio4KSk+PjMpCi0jZGVmaW5lCUNBTENCSVQoeCkJKCh4KSY3KQotCi0jZGVmaW5lIEFMTENPVwkJMQotI2RlZmluZSBBTExSRE8JCTIKLSNkZWZpbmUgTUlYRURVUAkJMwotCi1zdGF0aWMgY2hhcglhbGx6ZXJvZXNbTUFQVU5JVF07Ci0KLS8qCi0qKiBhZG1pbmlzdHJhdGlvbiBwZXIgY293ZGV2aWNlIChwYWlyIG9mIGNvd2ZpbGUvcmRvZmlsZSkKLSovCi0KLS8qIGJpdC12YWx1ZXMgZm9yIHN0YXRlICovCi0jZGVmaW5lCUNPV0RFVk9QRU4JMHgwMQkvKiBjb3dkZXZpY2Ugb3BlbmVkICAgICAgICAgICAgICAgICAgICAgICAgICAqLwotI2RlZmluZQlDT1dSV0NPV09QRU4JMHgwMgkvKiBjb3dmaWxlIG9wZW5lZCByZWFkLXdyaXRlICAgICAgICAgICAgICAgICAqLwotI2RlZmluZQlDT1dSRENPV09QRU4JMHgwNAkvKiBjb3dmaWxlIG9wZW5lZCByZWFkLW9ubHkgICAgICAgICAgICAgICAgICAqLwotI2RlZmluZQlDT1dXQVRDSERPRwkweDA4IAkvKiBpb2N0bCBmb3Igd2F0Y2hkb2cgY293ZmlsZSBzcGFjZSBhY3RpdmUgICAqLwotCi0jZGVmaW5lCUNPV0NPV09QRU4JKENPV1JXQ09XT1BFTnxDT1dSRENPV09QRU4pCi0KLXN0cnVjdCBjb3dsb29wX2RldmljZQotewotCS8qCi0JKiogY3VycmVudCBzdGF0dXMKLQkqLwotCWludAkJc3RhdGU7CQkJLyogYml0LXZhbHVlcyAoc2VlIGFib3ZlKSAgICAqLwotCWludAkJb3BlbmNudDsJCS8qICMgb3BlbnMgZm9yIGNvd2RldmljZSAgICAgKi8KLQotICAgICAgICAvKgotCSoqIG9wZW4gZmlsZSBwb2ludGVycwotCSovCi0gICAgICAgIHN0cnVjdCBmaWxlICAJKnJkb2ZwLCAgICpjb3dmcDsJLyogb3BlbiBmaWxlIHBvaW50ZXJzICAgICAgICAqLwotCWNoYXIJCSpyZG9uYW1lLCAqY293bmFtZTsJLyogZmlsZSBuYW1lcyAgICAgICAgICAgICAgICAqLwotCi0JLyoKLQkqKiByZXF1ZXN0IHF1ZXVlIGFkbWluaXN0cmF0aW9uCi0JKi8KLQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZQkqcnF1ZXVlOwotCXNwaW5sb2NrX3QJCXJxbG9jazsKLQlzdHJ1Y3QgZ2VuZGlzawkJKmdkOwotCi0JLyoKLQkqKiBhZG1pbmlzdHJhdGlvbiBhYm91dCByZWFkLW9ubHkgZmlsZQotCSovCi0JdW5zaWduZWQgaW50CSAgICAgbnVtYmxvY2tzOwkvKiAjIGJsb2NrcyBpbnB1dCBmaWxlIGluIE1BUFVOSVQgICAgKi8KLQl1bnNpZ25lZCBpbnQJICAgICBibG9ja3N6OyAgIC8qIG1pbmltdW0gdW5pdCB0byBhY2Nlc3MgdGhpcyBkZXYgICAqLwotCXVuc2lnbmVkIGxvbmcJICAgICBmaW5nZXJwcmludDsgLyogZmluZ2VycHJpbnQgb2YgY3VycmVudCByZG9maWxlICAqLwotCXN0cnVjdCBibG9ja19kZXZpY2UgICpiZWxvd2RldjsJLyogYmxvY2sgZGV2aWNlIGJlbG93IHVzICAgICAgICAgICAgICovCi0Jc3RydWN0IGdlbmRpc2sgICAgICAgKmJlbG93Z2Q7ICAvKiBnZW5kaXNrIGZvciBibGsgZGV2IGJlbG93IHVzICAgICAgKi8KLQlzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqYmVsb3dxOwkvKiByZXEuIHF1ZXVlIG9mIGJsayBkZXYgYmVsb3cgdXMgICAgKi8KLQotCS8qCi0JKiogYml0bWFwIGFkbWluaXN0cmF0aW9uIHRvIHJlZ2lzdGVyIHdoaWNoIGJsb2NrcyBhcmUgbW9kaWZpZWQKLQkqLwotCWxvbmcgaW50CW1hcHNpemU7CS8qIHRvdGFsIHNpemUgb2YgYml0bWFwIChieXRlcykgICAgICAqLwotCWxvbmcgaW50CW1hcHJlbWFpbjsJLyogcmVtYWluaW5nIGJ5dGVzIGluIGxhc3QgYml0bWFwICAgICovCi0JaW50CQltYXBjb3VudDsgICAgICAgLyogbnVtYmVyIG9mIGJpdG1hcHMgaW4gdXNlICAgICAgICAgICovCi0JY2hhciAJCSoqbWFwY2FjaGU7CS8qIGFyZWEgd2l0aCBwb2ludGVycyB0byBiaXRtYXBzICAgICAqLwotCi0JY2hhcgkJKmlvYnVmOwkJLyogZGF0YWJ1ZmZlciBvZiBNQVBVTklUIGJ5dGVzICAgICAgICovCi0Jc3RydWN0IGNvd2hlYWQJKmNvd2hlYWQ7CS8qIGJ1ZmZlciBjb250YWluaW5nIGNvd2hlYWQgICAgICAgICAqLwotCi0JLyoKLQkqKiBhZG1pbmlzdHJhdGlvbiBmb3IgaW50ZXJmYWNlIHdpdGggdGhlIGtlcm5lbC10aHJlYWQKLQkqLwotCWludAkJcGlkOwkJLyogcGlkPT0wOiBubyB0aHJlYWQgYXZhaWxhYmxlICAgICAgICovCi0Jc3RydWN0IHJlcXVlc3QJKnJlcTsJCS8qIHJlcXVlc3QgdG8gYmUgaGFuZGxlZCBub3cgICAgICAgICAqLwotCXdhaXRfcXVldWVfaGVhZF90IHdhaXRxOwkvKiB3YWl0LVE6IHRocmVhZCB3YWl0cyBmb3Igd29yayAgICAgKi8KLQljaGFyCQljbG9zZWRvd247CS8qIGJvb2xlYW46IHRocmVhZCBleGl0IHJlcXVpcmVkICAgICAqLwotCWNoYXIJCXFmaWxsZWQ7CS8qIGJvb2xlYW46IEkvTyByZXF1ZXN0IHBlbmRpbmcgICAgICAqLwotCWNoYXIJCWlvYnVzeTsJCS8qIGJvb2xlYW46IHJlcSB1bmRlciB0cmVhdG1lbnQgICAgICAqLwotCi0JLyoKLQkqKiBhZG1pbmlzdHJhdGlvbiB0byBrZWVwIHRyYWNrIG9mIGZyZWUgc3BhY2UgaW4gY293ZmlsZSBmaWxlc3lzdGVtCi0JKi8KLQl1bnNpZ25lZCBsb25nCWJsa3NpemU7CS8qIGJsb2NrIHNpemUgb2YgZnMgKGJ5dGVzKSAgICAgICAgICAqLwotCXVuc2lnbmVkIGxvbmcJYmxrdG90YWw7CS8qIHJlY2VudCB0b3RhbCBzcGFjZSBpbiBmcyAoYmxvY2tzKSAqLwotCXVuc2lnbmVkIGxvbmcJYmxrYXZhaWw7CS8qIHJlY2VudCBmcmVlICBzcGFjZSBpbiBmcyAoYmxvY2tzKSAqLwotCi0Jd2FpdF9xdWV1ZV9oZWFkX3Qgd2F0Y2hxOwkvKiB3YWl0LVE6IHdhdGNoZXIgYXdhaXRzIHRocmVzaG9sZCAgKi8KLQl1bnNpZ25lZCBsb25nCXdhdGNodGhyZXNoOwkvKiB0aHJlc2hvbGQgb2Ygd2F0Y2hlciAoYmxvY2tzKSAgICAgKi8KLQotCS8qCi0JKiogc3RhdGlzdGljYWwgY291bnRlcnMKLQkqLwotCXVuc2lnbmVkIGxvbmcJcmRvcmVhZHM7CS8qIG51bWJlciBvZiAgcmVhZC1hY3Rpb25zIHJkbyAgICAgICAqLwotCXVuc2lnbmVkIGxvbmcJY293cmVhZHM7CS8qIG51bWJlciBvZiAgcmVhZC1hY3Rpb25zIGNvdyAgICAgICAqLwotCXVuc2lnbmVkIGxvbmcJY293d3JpdGVzOwkvKiBudW1iZXIgb2Ygd3JpdGUtYWN0aW9ucyAgICAgICAgICAgKi8KLQl1bnNpZ25lZCBsb25nCW5yY293YmxvY2tzOwkvKiBudW1iZXIgb2YgYmxvY2tzIGluIHVzZSBvbiBjb3cgICAgKi8KLX07Ci0KLXN0YXRpYyBzdHJ1Y3QgY293bG9vcF9kZXZpY2UJKipjb3dkZXZhbGw7CS8qIHB0ciB0byBwdHJzIHRvIGFsbCBjb3dkZXZpY2VzICovCi1zdGF0aWMgc3RydWN0IHNlbWFwaG9yZSAJY293ZGV2bG9jazsJLyogZ2VuZXJpYyBsb2NrIGZvciBjb3dkZXZzICAgICAgKi8KLQotc3RhdGljIHN0cnVjdCBnZW5kaXNrCQkqY293Y3RsZ2Q7CS8qIGdlbmRpc2sgY29udHJvbCBjaGFubmVsICAgICAgICovCi1zdGF0aWMgc3BpbmxvY2tfdAkJY293Y3RscnFsb2NrOyAgIC8qIGZvciByZXEucS4gb2YgY3RybC4gY2hhbm5lbCAgICovCi0KLS8qCi0qKiBwcml2YXRlIGRpcmVjdG9yeSAvcHJvYy9jb3cKLSovCi1zdHJ1Y3QgcHJvY19kaXJfZW50cnkJKmNvd2xvX3Byb2NkaXI7Ci0KLS8qCi0qKiBmdW5jdGlvbiBwcm90b3R5cGVzCi0qLwotc3RhdGljIGxvbmcgaW50IGNvd2xvX2RvX3JlcXVlc3QgKHN0cnVjdCByZXF1ZXN0ICpyZXEpOwotc3RhdGljIHZvaWQJY293bG9fc3luYyAgICAgICAodm9pZCk7Ci1zdGF0aWMgaW50CWNvd2xvX2NoZWNraW8gICAgKHN0cnVjdCBjb3dsb29wX2RldmljZSAqLCAgICAgICAgIGludCwgbG9mZl90KTsKLXN0YXRpYyBpbnQJY293bG9fcmVhZG1peCAgICAoc3RydWN0IGNvd2xvb3BfZGV2aWNlICosIHZvaWQgKiwgaW50LCBsb2ZmX3QpOwotc3RhdGljIGludAljb3dsb193cml0ZW1peCAgIChzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKiwgdm9pZCAqLCBpbnQsIGxvZmZfdCk7Ci1zdGF0aWMgbG9uZyBpbnQgY293bG9fcmVhZHJkbyAgICAoc3RydWN0IGNvd2xvb3BfZGV2aWNlICosIHZvaWQgKiwgaW50LCBsb2ZmX3QpOwotc3RhdGljIGxvbmcgaW50IGNvd2xvX3JlYWRjb3cgICAgKHN0cnVjdCBjb3dsb29wX2RldmljZSAqLCB2b2lkICosIGludCwgbG9mZl90KTsKLXN0YXRpYyBsb25nIGludCBjb3dsb19yZWFkY293cmF3IChzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKiwgdm9pZCAqLCBpbnQsIGxvZmZfdCk7Ci1zdGF0aWMgbG9uZyBpbnQgY293bG9fd3JpdGVjb3cgICAoc3RydWN0IGNvd2xvb3BfZGV2aWNlICosIHZvaWQgKiwgaW50LCBsb2ZmX3QpOwotc3RhdGljIGxvbmcgaW50IGNvd2xvX3dyaXRlY293cmF3KHN0cnVjdCBjb3dsb29wX2RldmljZSAqLCB2b2lkICosIGludCwgbG9mZl90KTsKLXN0YXRpYyBpbnQgICAgICBjb3dsb19pb2N0bCAgICAgIChzdHJ1Y3QgYmxvY2tfZGV2aWNlICosIGZtb2RlX3QsCi0gICAgICAgICAgIAkJCSAJCXVuc2lnbmVkIGludCwgdW5zaWduZWQgbG9uZyk7Ci1zdGF0aWMgaW50CWNvd2xvX21ha2VwYWlyICAgIChzdHJ1Y3QgY293cGFpciBfX3VzZXIgKik7Ci1zdGF0aWMgaW50CWNvd2xvX3JlbW92ZXBhaXIgICh1bnNpZ25lZCBsb25nICBfX3VzZXIgKik7Ci1zdGF0aWMgaW50CWNvd2xvX3dhdGNoICAgICAgIChzdHJ1Y3QgY293cGFpciBfX3VzZXIgKik7Ci1zdGF0aWMgaW50CWNvd2xvX2Nvd2N0bCAgICAgICh1bnNpZ25lZCBsb25nICBfX3VzZXIgKiwgaW50KTsKLXN0YXRpYyBpbnQJY293bG9fb3BlbnBhaXIgICAgKGNoYXIgKiwgY2hhciAqLCBpbnQsIGludCk7Ci1zdGF0aWMgaW50IAljb3dsb19jbG9zZXBhaXIgICAoc3RydWN0IGNvd2xvb3BfZGV2aWNlICopOwotc3RhdGljIGludAljb3dsb19vcGVucmRvICAgICAoc3RydWN0IGNvd2xvb3BfZGV2aWNlICosIGNoYXIgKik7Ci1zdGF0aWMgaW50CWNvd2xvX29wZW5jb3cgICAgIChzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKiwgY2hhciAqLCBpbnQpOwotc3RhdGljIHZvaWQJY293bG9fdW5kb19vcGVucmRvKHN0cnVjdCBjb3dsb29wX2RldmljZSAqKTsKLXN0YXRpYyB2b2lkCWNvd2xvX3VuZG9fb3BlbmNvdyhzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKik7Ci0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLS8qIFN5c3RlbSBjYWxsIGhhbmRsaW5nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotLyoKLSoqIGhhbmRsZSBzeXN0ZW0gY2FsbCBvcGVuKCkvbW91bnQoKQotKioKLSoqIHJldHVybnM6Ci0qKiAJMCAgIC0gb2theQotKiogICAgPCAwICAgLSBlcnJvciB2YWx1ZQotKi8KLXN0YXRpYyBpbnQgY293bG9fb3BlbihzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2LCBmbW9kZV90IG1vZGUpCi17Ci0Jc3RydWN0IGlub2RlICppbm9kZSA9IGJkZXYtPmJkX2lub2RlOwotCi0JaWYgKCFpbm9kZSkKLQkJcmV0dXJuIC1FSU5WQUw7Ci0KLQlpZiAoaW1ham9yKGlub2RlKSAhPSBDT1dNQUpPUikgewotCQlwcmludGsoS0VSTl9XQVJOSU5HCi0JCSAgICAgICAiY293bG9vcCAtIHVuZXhwZWN0ZWQgbWFqb3IgJWRcbiIsIGltYWpvcihpbm9kZSkpOwotCQlyZXR1cm4gLUVOT0RFVjsKLQl9Ci0KLQlzd2l0Y2ggKGltaW5vcihpbm9kZSkpIHsKLQkgICBjYXNlIENPV0NUTDoKLQkJREVCVUdQKERDT1ciY293bG9vcCAtIG9wZW4gJWQgY29udHJvbFxuIiwgQ09XQ1RMKTsKLQkJYnJlYWs7Ci0KLQkgICBkZWZhdWx0OgotCQlERUJVR1AoRENPVyJjb3dsb29wIC0gb3BlbiBtaW5vciAlZFxuIiwgaW1pbm9yKGlub2RlKSk7Ci0KLQkJaWYgKCBpbWlub3IoaW5vZGUpID49IG1heGNvd3MgKQotCQkJcmV0dXJuIC1FTk9ERVY7Ci0KLQkJaWYgKCAhKChjb3dkZXZhbGxbaW1pbm9yKGlub2RlKV0pLT5zdGF0ZSAmIENPV0RFVk9QRU4pICkKLQkJCXJldHVybiAtRU5PREVWOwotCi0JCShjb3dkZXZhbGxbaW1pbm9yKGlub2RlKV0pLT5vcGVuY250Kys7Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLS8qCi0qKiBoYW5kbGUgc3lzdGVtIGNhbGwgY2xvc2UoKS91bW91bnQoKQotKioKLSoqIHJldHVybnM6Ci0qKiAJMCAgIC0gb2theQotKi8KLXN0YXRpYyBpbnQgY293bG9fcmVsZWFzZShzdHJ1Y3QgZ2VuZGlzayAqZ2QsIGZtb2RlX3QgbW9kZSkKLXsKLQlzdHJ1Y3QgYmxvY2tfZGV2aWNlICpiZGV2OwotCXN0cnVjdCBpbm9kZSAqaW5vZGU7Ci0KLQliZGV2ID0gYmRnZXRfZGlzayhnZCwgMCk7Ci0JaW5vZGUgPSBiZGV2LT5iZF9pbm9kZTsKLQlpZiAoIWlub2RlKQotCQlyZXR1cm4gMDsKLQotCURFQlVHUChEQ09XImNvd2xvb3AgLSByZWxlYXNlIChjbG9zZSkgbWlub3IgJWRcbiIsIGltaW5vcihpbm9kZSkpOwotCi0JaWYgKCBpbWlub3IoaW5vZGUpICE9IENPV0NUTCkKLQkJKGNvd2RldmFsbFtpbWlub3IoaW5vZGUpXSktPm9wZW5jbnQtLTsKLQotCXJldHVybiAwOwotfQotCi0vKgotKiogaGFuZGxlIHN5c3RlbSBjYWxsIGlvY3RsKCkKLSoqCi0qKiByZXR1cm5zOgotKiogCTAgICAtIG9rYXkKLSoqICAgIDwgMCAgIC0gZXJyb3IgdmFsdWUKLSovCi1zdGF0aWMgaW50IGNvd2xvX2lvY3RsKHN0cnVjdCBibG9ja19kZXZpY2UgKmJkZXYsIGZtb2RlX3QgbW9kZSwKLQkJICAgICAgIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKQotewotCXN0cnVjdCBoZF9nZW9tZXRyeQlnZW87Ci0Jc3RydWN0IGlub2RlICppbm9kZSA9IGJkZXYtPmJkX2lub2RlOwotCi0JREVCVUdQKERDT1cgImNvd2xvb3AgLSBpb2N0bCBjbWQgJXhcbiIsIGNtZCk7Ci0KLQlzd2l0Y2ggKCBpbWlub3IoaW5vZGUpICkgewotCi0JICAgLyoKLQkgICAqKiBhbGxvd2VkIHZpYSBjb250cm9sIGRldmljZSBvbmx5Ci0JICAgKi8KLQkgICBjYXNlIENPV0NUTDoKLQkJc3dpdGNoIChjbWQpIHsKLQkJICAgLyoKLQkJICAgKiogd3JpdGUgYWxsIGJpdG1hcCBjaHVua3MgYW5kIGNvd2hlYWRlcnMgdG8gY293ZmlsZXMKLQkJICAgKi8KLQkJICAgY2FzZSBDT1dTWU5DOgotCQkJZG93bigmY293ZGV2bG9jayk7Ci0JCQljb3dsb19zeW5jKCk7Ci0JCQl1cCgmY293ZGV2bG9jayk7Ci0JCQlyZXR1cm4gMDsKLQotCQkgICAvKgotCQkgICAqKiBvcGVuIGEgbmV3IGNvd2RldmljZSAocGFpciBvZiByZG9maWxlL2Nvd2ZpbGUpCi0JCSAgICovCi0JCSAgIGNhc2UgQ09XTUtQQUlSOgotCQkJcmV0dXJuIGNvd2xvX21ha2VwYWlyKCh2b2lkIF9fdXNlciAqKWFyZyk7Ci0KLQkJICAgLyoKLQkJICAgKiogY2xvc2UgYSBjb3dkZXZpY2UgKHBhaXIgb2YgcmRvZmlsZS9jb3dmaWxlKQotCQkgICAqLwotCQkgICBjYXNlIENPV1JNUEFJUjoKLQkJCXJldHVybiBjb3dsb19yZW1vdmVwYWlyKCh2b2lkIF9fdXNlciAqKWFyZyk7Ci0KLQkJICAgLyoKLQkJICAgKiogd2F0Y2ggZnJlZSBzcGFjZSBvZiBmaWxlc3lzdGVtIGNvbnRhaW5pbmcgY293ZmlsZQotCQkgICAqLwotCQkgICBjYXNlIENPV1dBVENIOgotCQkJcmV0dXJuIGNvd2xvX3dhdGNoKCh2b2lkIF9fdXNlciAqKWFyZyk7Ci0KLQkJICAgLyoKLQkJICAgKiogY2xvc2UgY293ZmlsZSBmb3IgYWN0aXZlIGRldmljZQotCQkgICAqLwotCQkgICBjYXNlIENPV0NMT1NFOgotCQkJcmV0dXJuIGNvd2xvX2Nvd2N0bCgodm9pZCBfX3VzZXIgKilhcmcsIENPV0NMT1NFKTsKLQotCQkgICAvKgotCQkgICAqKiByZW9wZW4gY293ZmlsZSByZWFkLW9ubHkgZm9yIGFjdGl2ZSBkZXZpY2UKLQkJICAgKi8KLQkJICAgY2FzZSBDT1dSRE9QRU46Ci0JCQlyZXR1cm4gY293bG9fY293Y3RsKCh2b2lkIF9fdXNlciAqKWFyZywgQ09XUkRPUEVOKTsKLQotCQkgICBkZWZhdWx0OgotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCX0gLyogZW5kIG9mIHN3aXRjaCBvbiBjb21tYW5kICovCi0KLQkgICAvKgotCSAgICoqIGFsbG93ZWQgZm9yIGFueSBvdGhlciBjb3dkZXZpY2UKLQkgICAqLwotCSAgIGRlZmF1bHQ6Ci0JCXN3aXRjaCAoY21kKSB7Ci0JCSAgIC8qCi0JCSAgICoqIEhESU9fR0VUR0VPIG11c3QgYmUgc3VwcG9ydGVkIGZvciBmZGlzaywgZXRjCi0JCSAgICovCi0JCSAgIGNhc2UgSERJT19HRVRHRU86Ci0JCQlnZW8uY3lsaW5kZXJzID0gMDsKLQkJCWdlby5oZWFkcyAgICAgPSAwOwotCQkJZ2VvLnNlY3RvcnMgICA9IDA7Ci0KLQkJCWlmIChjb3B5X3RvX3VzZXIoKHZvaWQgX191c2VyICopYXJnLCAmZ2VvLCBzaXplb2YgZ2VvKSkKLQkJCQlyZXR1cm4gLUVGQVVMVDsKLQkJCXJldHVybiAwOwotCi0JCSAgIGRlZmF1bHQ6Ci0JCQlyZXR1cm4gLUVJTlZBTDsKLQkJfSAvKiBlbmQgb2Ygc3dpdGNoIG9uIGlvY3RsLWNtZCBjb2RlIHBhcmFtZXRlciAqLwotCX0gLyogZW5kIG9mIHN3aXRjaCBvbiBtaW5vciBudW1iZXIgKi8KLX0KLQotc3RhdGljIHN0cnVjdCBibG9ja19kZXZpY2Vfb3BlcmF0aW9ucyBjb3dsb19mb3BzID0KLXsKLQkub3duZXIJID0gICAgIFRISVNfTU9EVUxFLAotICAgICAgICAub3BlbiAgICA9ICAgICBjb3dsb19vcGVuLAkvKiBjYWxsZWQgdXBvbiBvcGVuICAqLwotICAgICAgICAucmVsZWFzZSA9ICAgICBjb3dsb19yZWxlYXNlLAkvKiBjYWxsZWQgdXBvbiBjbG9zZSAqLwotICAgICAgICAuaW9jdGwgICA9ICAgICBjb3dsb19pb2N0bCwgICAgIC8qIGNhbGxlZCB1cG9uIGlvY3RsICovCi19OwotCi0vKgotKiogaGFuZGxlIGlvY3RsLWNvbW1hbmQgQ09XTUtQQUlSOgotKioJb3BlbiBhIG5ldyBjb3dkZXZpY2UgKHBhaXIgb2YgcmRvZmlsZS9jb3dmaWxlKSBvbi10aGUtZmx5Ci0qKgotKiogcmV0dXJuczoKLSoqIAkwICAgLSBva2F5Ci0qKiAgICA8IDAgICAtIGVycm9yIHZhbHVlCi0qLwotc3RhdGljIGludAotY293bG9fbWFrZXBhaXIoc3RydWN0IGNvd3BhaXIgX191c2VyICphcmcpCi17Ci0JaW50CQlpLCBydj0wOwotCXN0cnVjdCBjb3dwYWlyCWNvd3BhaXI7Ci0JdW5zaWduZWQgY2hhcgkqY293cGF0aDsKLQl1bnNpZ25lZCBjaGFyCSpyZG9wYXRoOwotCi0JLyoKLQkqKiByZXRyaWV2ZSBpbmZvIGFib3V0IHBhdGhuYW1lcwotCSovCi0JaWYgKCBjb3B5X2Zyb21fdXNlcigmY293cGFpciwgYXJnLCBzaXplb2YgY293cGFpcikgKQotCQlyZXR1cm4gLUVGQVVMVDsKLQotCWlmICggKE1BSk9SKGNvd3BhaXIuZGV2aWNlKSAhPSBDT1dNQUpPUikgJiYgKGNvd3BhaXIuZGV2aWNlICE9IEFOWURFVikgKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWlmICggKE1JTk9SKGNvd3BhaXIuZGV2aWNlKSA+PSBtYXhjb3dzKSAgJiYgKGNvd3BhaXIuZGV2aWNlICE9IEFOWURFVikgKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCS8qCi0JKiogcmV0cmlldmUgcGF0aG5hbWUgc3RyaW5ncwotCSovCi0JaWYgKCAoY293cGFpci5jb3dmbGVuID4gUEFUSF9NQVgpIHx8IChjb3dwYWlyLnJkb2ZsZW4gPiBQQVRIX01BWCkgKQotCQlyZXR1cm4gLUVOQU1FVE9PTE9ORzsKLQotCWlmICggIShjb3dwYXRoID0ga21hbGxvYyhjb3dwYWlyLmNvd2ZsZW4rMSwgR0ZQX0tFUk5FTCkpICkKLQkJcmV0dXJuIC1FTk9NRU07Ci0KLQlpZiAoIGNvcHlfZnJvbV91c2VyKGNvd3BhdGgsICh2b2lkIF9fdXNlciAqKWNvd3BhaXIuY293ZmlsZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvd3BhaXIuY293ZmxlbikgKSB7Ci0JCWtmcmVlKGNvd3BhdGgpOwotCQlyZXR1cm4gLUVGQVVMVDsKLQl9Ci0JKihjb3dwYXRoK2Nvd3BhaXIuY293ZmxlbikgPSAwOwotCi0JaWYgKCAhKHJkb3BhdGggPSBrbWFsbG9jKGNvd3BhaXIucmRvZmxlbisxLCBHRlBfS0VSTkVMKSkgKSB7Ci0JCWtmcmVlKGNvd3BhdGgpOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0KLQlpZiAoIGNvcHlfZnJvbV91c2VyKHJkb3BhdGgsICh2b2lkIF9fdXNlciAqKWNvd3BhaXIucmRvZmlsZSwKLQkgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvd3BhaXIucmRvZmxlbikgKSB7Ci0JCWtmcmVlKHJkb3BhdGgpOwotCQlrZnJlZShjb3dwYXRoKTsKLQkJcmV0dXJuIC1FRkFVTFQ7Ci0JfQotCSoocmRvcGF0aCtjb3dwYWlyLnJkb2ZsZW4pID0gMDsKLQotCS8qCi0JKiogb3BlbiBuZXcgY293ZGV2aWNlCi0JKi8KLQlpZiAoIGNvd3BhaXIuZGV2aWNlID09IEFOWURFVikgewotCQkvKgotCQkqKiBzZWFyY2ggZmlyc3QgdW51c2VkIG1pbm9yCi0JCSovCi0JCWZvciAoaT0wLCBydj0tRUJVU1k7IGkgPCBtYXhjb3dzOyBpKyspIHsKLQkJCWlmICggISgoY293ZGV2YWxsW2ldKS0+c3RhdGUgJiBDT1dERVZPUEVOKSApIHsKLQkJCQlydiA9IGNvd2xvX29wZW5wYWlyKHJkb3BhdGgsIGNvd3BhdGgsIDAsIGkpOwotCQkJCWJyZWFrOwotCQkJfQotCQl9Ci0KLQkJaWYgKHJ2KSB7IAkJLyogb3BlbiBmYWlsZWQ/ICovCi0JCQlrZnJlZShyZG9wYXRoKTsKLQkJCWtmcmVlKGNvd3BhdGgpOwotCQkJcmV0dXJuIHJ2OwotCQl9Ci0KLQkJLyoKLQkJKiogcmV0dXJuIG5ld2x5IGFsbG9jYXRlZCBjb3dkZXZpY2UgdG8gdXNlciBzcGFjZQotCQkqLwotCQljb3dwYWlyLmRldmljZSA9IE1LREVWKENPV01BSk9SLCBpKTsKLQotCQlpZiAoIGNvcHlfdG9fdXNlcihhcmcsICZjb3dwYWlyLCBzaXplb2YgY293cGFpcikpIHsKLQkJCWtmcmVlKHJkb3BhdGgpOwotCQkJa2ZyZWUoY293cGF0aCk7Ci0JCQlyZXR1cm4gLUVGQVVMVDsKLQkJfQotCX0gZWxzZSB7IAkJLyogc3BlY2lmaWMgbWlub3IgcmVxdWVzdGVkICovCi0JCWlmICggKHJ2ID0gY293bG9fb3BlbnBhaXIocmRvcGF0aCwgY293cGF0aCwgMCwKLQkJCQkJCU1JTk9SKGNvd3BhaXIuZGV2aWNlKSkpKSB7Ci0JCQlrZnJlZShyZG9wYXRoKTsKLQkJCWtmcmVlKGNvd3BhdGgpOwotCQkJcmV0dXJuIHJ2OwotCQl9Ci0JfQotCi0JcmV0dXJuIDA7Ci19Ci0KLS8qCi0qKiBoYW5kbGUgaW9jdGwtY29tbWFuZCBDT1dSTVBBSVI6Ci0qKiAJZGVhY3RpdmF0ZSBhbiBleGlzdGluZyBjb3dkZXZpY2UgKHBhaXIgb2YgcmRvZmlsZS9jb3dmaWxlKSBvbi10aGUtZmx5Ci0qKgotKiogcmV0dXJuczoKLSoqIAkwICAgLSBva2F5Ci0qKiAgICA8IDAgICAtIGVycm9yIHZhbHVlCi0qLwotc3RhdGljIGludAotY293bG9fcmVtb3ZlcGFpcih1bnNpZ25lZCBsb25nIF9fdXNlciAqYXJnKQotewotCXVuc2lnbmVkIGxvbmcJCWNvd2RldmljZTsKLQlzdHJ1Y3QgY293bG9vcF9kZXZpY2UJKmNvd2RldjsKLQotCS8qCi0JKiogcmV0cmlldmUgaW5mbyBhYm91dCBkZXZpY2UgdG8gYmUgcmVtb3ZlZAotCSovCi0JaWYgKCBjb3B5X2Zyb21fdXNlcigmY293ZGV2aWNlLCBhcmcsIHNpemVvZiBjb3dkZXZpY2UpKQotCQlyZXR1cm4gLUVGQVVMVDsKLQotCS8qCi0JKiogdmVyaWZ5IG1ham9yLW1pbm9yIG51bWJlcgotCSovCi0JaWYgKCBNQUpPUihjb3dkZXZpY2UpICE9IENPV01BSk9SKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWlmICggTUlOT1IoY293ZGV2aWNlKSA+PSBtYXhjb3dzKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWNvd2RldiA9IGNvd2RldmFsbFtNSU5PUihjb3dkZXZpY2UpXTsKLQotCWlmICggIShjb3dkZXYtPnN0YXRlICYgQ09XREVWT1BFTikgKQotCQlyZXR1cm4gLUVOT0RFVjsKLQotCS8qCi0JKiogc3luY2hyb25pemUgYml0bWFwcyBhbmQgY2xvc2UgY293ZGV2aWNlCi0JKi8KLQlpZiAoY293ZGV2LT5zdGF0ZSAmIENPV1JXQ09XT1BFTikgewotCQlkb3duKCZjb3dkZXZsb2NrKTsKLQkJY293bG9fc3luYygpOwotCQl1cCgmY293ZGV2bG9jayk7Ci0JfQotCi0JcmV0dXJuIGNvd2xvX2Nsb3NlcGFpcihjb3dkZXYpOwotfQotCi0vKgotKiogaGFuZGxlIGlvY3RsLWNvbW1hbmQgQ09XV0FUQ0g6Ci0qKgl3YXRjaCB0aGUgZnJlZSBzcGFjZSBvZiB0aGUgZmlsZXN5c3RlbSBjb250YWluaW5nIGEgY293ZmlsZQotKiogICAgICBvZiBhbiBvcGVuIGNvd2RldmljZQotKioKLSoqIHJldHVybnM6Ci0qKiAJMCAgIC0gb2theQotKiogICAgPCAwICAgLSBlcnJvciB2YWx1ZQotKi8KLXN0YXRpYyBpbnQKLWNvd2xvX3dhdGNoKHN0cnVjdCBjb3dwYWlyIF9fdXNlciAqYXJnKQotewotCXN0cnVjdCBjb3dsb29wX2RldmljZQkqY293ZGV2OwotCXN0cnVjdCBjb3d3YXRjaAkJY293d2F0Y2g7Ci0KLQkvKgotCSoqIHJldHJpZXZlIHN0cnVjdHVyZSBob2xkaW5nIGluZm8KLQkqLwotCWlmICggY29weV9mcm9tX3VzZXIoJmNvd3dhdGNoLCBhcmcsIHNpemVvZiBjb3d3YXRjaCkpCi0JCXJldHVybiAtRUZBVUxUOwotCi0JLyoKLQkqKiB2ZXJpZnkgaWYgY293ZGV2aWNlIGV4aXN0cyBhbmQgaXMgY3VycmVudGx5IG9wZW4KLQkqLwotCWlmICggTUlOT1IoY293d2F0Y2guZGV2aWNlKSA+PSBtYXhjb3dzKQotCQlyZXR1cm4gLUVJTlZBTDsKLQotCWNvd2RldiA9IGNvd2RldmFsbFtNSU5PUihjb3d3YXRjaC5kZXZpY2UpXTsKLQotCWlmICggIShjb3dkZXYtPnN0YXRlICYgQ09XREVWT1BFTikgKQotCQlyZXR1cm4gLUVOT0RFVjsKLQotCS8qCi0JKiogaWYgdGhlIFdBVENIV0FJVC1vcHRpb24gaXMgc2V0LCB3YWl0IHVudGlsIHRoZSBpbmRpY2F0ZWQKLQkqKiB0aHJlc2hvbGQgaXMgcmVhY2hlZCAob25seSBvbmUgd2FpdGVyIGFsbG93ZWQpCi0JKi8KLQlpZiAoY293d2F0Y2guZmxhZ3MgJiBXQVRDSFdBSVQpIHsKLQkJLyoKLQkJKiogY2hlY2sgaWYgYWxyZWFkeSBhbm90aGVyIHdhaXRlciBhY3RpdmUKLQkJKiogZm9yIHRoaXMgY293ZGV2aWNlCi0JCSovCi0JCWlmIChjb3dkZXYtPnN0YXRlICYgQ09XV0FUQ0hET0cpCi0JCQlyZXR1cm4gLUVBR0FJTjsKLQotCQljb3dkZXYtPnN0YXRlIHw9IENPV1dBVENIRE9HOwotCi0JCWNvd2Rldi0+d2F0Y2h0aHJlc2ggPSAodW5zaWduZWQgbG9uZyBsb25nKQotCQkgICAgICAgICAgICAgICAgICAgICAgY293d2F0Y2gudGhyZXNob2xkIC8KLQkJCQkgICAgICAoY293ZGV2LT5ibGtzaXplIC8gMTAyNCk7Ci0KLQkJaWYgKHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShjb3dkZXYtPndhdGNocSwKLQkJICAgICAgICAgICAgICAgICAgICBjb3dkZXYtPndhdGNodGhyZXNoID49IGNvd2Rldi0+YmxrYXZhaWwpKSB7Ci0JCQljb3dkZXYtPnN0YXRlICY9IH5DT1dXQVRDSERPRzsKLQkJCXJldHVybiBFSU5UUjsKLQkJfQotCi0JCWNvd2Rldi0+c3RhdGUgJj0gfkNPV1dBVENIRE9HOwotCX0KLQotCWNvd3dhdGNoLnRvdGFsa2IgPSAodW5zaWduZWQgbG9uZyBsb25nKWNvd2Rldi0+YmxrdG90YWwgKgotCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvd2Rldi0+Ymxrc2l6ZSAvIDEwMjQ7Ci0JY293d2F0Y2guYXZhaWxrYiA9ICh1bnNpZ25lZCBsb25nIGxvbmcpY293ZGV2LT5ibGthdmFpbCAqCi0JICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY293ZGV2LT5ibGtzaXplIC8gMTAyNDsKLQotCWlmICggY29weV90b191c2VyKGFyZywgJmNvd3dhdGNoLCBzaXplb2YgY293d2F0Y2gpKQotCQlyZXR1cm4gLUVGQVVMVDsKLQotCXJldHVybiAwOwotfQotCi0vKgotKiogaGFuZGxlIGlvY3RsLWNvbW1hbmRzIENPV0NMT1NFIGFuZCBDT1dSRE9QRU46Ci0qKglDT1dDTE9TRSAgLSBjbG9zZSB0aGUgY293ZmlsZSB3aGlsZSB0aGUgY293ZGV2aWNlIHJlbWFpbnMgb3BlbjsKLSoqICAgICAgICAgICAgICAgICAgdGhpcyBhbGxvd3MgYW4gdW5tb3VudCBvZiB0aGUgZmlsZXN5c3RlbSBvbiB3aGljaAotKiogICAgICAgICAgICAgICAgICB0aGUgY293ZmlsZSByZXNpZGVzCi0qKglDT1dSRE9QRU4gLSBjbG9zZSB0aGUgY293ZmlsZSBhbmQgcmVvcGVuIGl0IGZvciByZWFkLW9ubHk7Ci0qKiAgICAgICAgICAgICAgICAgIHRoaXMgYWxsb3dzIGEgcmVtb3VudCByZWFkLW9ueSBvZiB0aGUgZmlsZXN5c3RlbQotKiogICAgICAgICAgICAgICAgICBvbiB3aGljaCB0aGUgY293ZmlsZSByZXNpZGVzCi0qKgotKiogcmV0dXJuczoKLSoqIAkwICAgLSBva2F5Ci0qKiAgICA8IDAgICAtIGVycm9yIHZhbHVlCi0qLwotc3RhdGljIGludAotY293bG9fY293Y3RsKHVuc2lnbmVkIGxvbmcgX191c2VyICphcmcsIGludCBjbWQpCi17Ci0Jc3RydWN0IGNvd2xvb3BfZGV2aWNlCSpjb3dkZXY7Ci0JdW5zaWduZWQgbG9uZwkJY293ZGV2aWNlOwotCi0JLyoKLQkqKiByZXRyaWV2ZSBpbmZvIGFib3V0IGRldmljZSB0byBiZSByZW1vdmVkCi0JKi8KLQlpZiAoIGNvcHlfZnJvbV91c2VyKCZjb3dkZXZpY2UsIGFyZywgc2l6ZW9mIGNvd2RldmljZSkpCi0JCXJldHVybiAtRUZBVUxUOwotCi0JLyoKLQkqKiB2ZXJpZnkgbWFqb3ItbWlub3IgbnVtYmVyCi0JKi8KLQlpZiAoIE1BSk9SKGNvd2RldmljZSkgIT0gQ09XTUFKT1IpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JaWYgKCBNSU5PUihjb3dkZXZpY2UpID49IG1heGNvd3MpCi0JCXJldHVybiAtRUlOVkFMOwotCi0JY293ZGV2ID0gY293ZGV2YWxsW01JTk9SKGNvd2RldmljZSldOwotCi0JaWYgKCAhKGNvd2Rldi0+c3RhdGUgJiBDT1dERVZPUEVOKSApCi0JCXJldHVybiAtRU5PREVWOwotCi0JLyoKLQkqKiBzeW5jaHJvbml6ZSBiaXRtYXBzIGFuZCBjbG9zZSBjb3dmaWxlCi0JKi8KLQlpZiAoY293ZGV2LT5zdGF0ZSAmIENPV1JXQ09XT1BFTikgewotCQlkb3duKCZjb3dkZXZsb2NrKTsKLQkJY293bG9fc3luYygpOwotCQl1cCgmY293ZGV2bG9jayk7Ci0JfQotCi0JLyoKLQkqKiBoYW5kbGUgc3BlY2lmaWMgaW9jdGwtY29tbWFuZAotCSovCi0Jc3dpdGNoIChjbWQpIHsKLQkgICBjYXNlIENPV1JET1BFTjoKLQkJLyoKLQkJKiogaWYgdGhlIGNvd2ZpbGUgaXMgc3RpbGwgb3BlbmVkIHJlYWQtd3JpdGUKLQkJKi8KLQkJaWYgKGNvd2Rldi0+c3RhdGUgJiBDT1dSV0NPV09QRU4pIHsKLQkJCS8qCi0JCQkqKiBjbG9zZSB0aGUgY293ZmlsZQotCQkJKi8KLSAgCQkJaWYgKGNvd2Rldi0+Y293ZnApCi0JCSAgCQlmaWxwX2Nsb3NlKGNvd2Rldi0+Y293ZnAsIDApOwotCi0JCQljb3dkZXYtPnN0YXRlICY9IH5DT1dSV0NPV09QRU47Ci0KLQkJCS8qCi0JCQkqKiBvcGVuIGFnYWluIGZvciByZWFkLW9ubHkKLQkJCSovCi0JCQljb3dkZXYtPmNvd2ZwID0gZmlscF9vcGVuKGNvd2Rldi0+Y293bmFtZSwKLQkJICAgICAgICAgICAgICAgICAgICAgICAgICBPX1JET05MWXxPX0xBUkdFRklMRSwgMDYwMCk7Ci0KLQkJCWlmICggKGNvd2Rldi0+Y293ZnAgPT0gTlVMTCkgfHwgSVNfRVJSKGNvd2Rldi0+Y293ZnApICkgewotCQkJCXByaW50ayhLRVJOX0VSUgotCQkJCSAgICAgImNvd2xvb3AgLSBmYWlsZWQgdG8gcmVvcGVuIGNvd2ZpbGUgJXNcbiIsCi0JCQkJICAgICBjb3dkZXYtPmNvd25hbWUpOwotCQkJCXJldHVybiAtRUlOVkFMOwotCQkJfQotCi0JCQkvKgotCQkJKiogbWFyayBjb3dmaWxlIG9wZW4gZm9yIHJlYWQtb25seQotCQkJKi8KLQkJCWNvd2Rldi0+c3RhdGUgfD0gQ09XUkRDT1dPUEVOOwotCQl9IGVsc2UgewotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCX0KLQkJYnJlYWs7Ci0KLQkgICBjYXNlIENPV0NMT1NFOgotCQkvKgotCQkqKiBpZiB0aGUgY293ZmlsZSBpcyBzdGlsbCBvcGVuCi0JCSovCi0JCWlmIChjb3dkZXYtPnN0YXRlICYgQ09XQ09XT1BFTikgewotCQkJLyoKLQkJCSoqIGNsb3NlIHRoZSBjb3dmaWxlCi0JCQkqLwotICAJCQlpZiAoY293ZGV2LT5jb3dmcCkKLQkJICAJCWZpbHBfY2xvc2UoY293ZGV2LT5jb3dmcCwgMCk7Ci0KLQkJCWNvd2Rldi0+c3RhdGUgJj0gfkNPV0NPV09QRU47Ci0JCX0KLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0vKiBIYW5kbGluZyBvZiBJL08tcmVxdWVzdHMgZm9yIGEgY293ZGV2aWNlICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0KLS8qCi0qKiBmdW5jdGlvbiB0byBiZSBjYWxsZWQgYnkgY29yZS1rZXJuZWwgdG8gaGFuZGxlIHRoZSBJL08tcmVxdWVzdHMKLSoqIGluIHRoZSBxdWV1ZQotKi8KLXN0YXRpYyB2b2lkIGNvd2xvX3JlcXVlc3Qoc3RydWN0IHJlcXVlc3RfcXVldWUgKnEpCi17Ci0Jc3RydWN0IHJlcXVlc3QJCSpyZXE7Ci0Jc3RydWN0IGNvd2xvb3BfZGV2aWNlCSpjb3dkZXY7Ci0KLQlERUJVR1AoRENPVyAiY293bG9vcCAtIHJlcXVlc3QgZnVuY3Rpb24gY2FsbGVkLi4uLlxuIik7Ci0KLQl3aGlsZSgocmVxID0gYmxrX3BlZWtfcmVxdWVzdChxKSkgIT0gTlVMTCkgewotCQlERUJVR1AoRENPVyAiY293bG9vcCAtIGdvdCBuZXh0IHJlcXVlc3RcbiIpOwotCi0JCWlmICghIGJsa19mc19yZXF1ZXN0KHJlcSkpIHsKLSAgICAgICAgICAgICAgIAkJIC8qIHRoaXMgaXMgbm90IGEgbm9ybWFsIGZpbGUgc3lzdGVtIHJlcXVlc3QgKi8KLSAgICAgICAgICAgICAgICAJX19ibGtfZW5kX3JlcXVlc3RfY3VyKHJlcSwgLUVJTyk7Ci0gICAgICAgICAgICAgICAgCWNvbnRpbnVlOwotICAgICAgICAJfQotCQljb3dkZXYgPSByZXEtPnJxX2Rpc2stPnByaXZhdGVfZGF0YTsKLQotCQlpZiAoY293ZGV2LT5pb2J1c3kpCi0JCQlyZXR1cm47Ci0JCWVsc2UKLQkJCWNvd2Rldi0+aW9idXN5ID0gMTsKLQotCQkvKgotCQkqKiB3aGVuIG5vIGtlcm5lbC10aHJlYWQgaXMgYXZhaWxhYmxlLCB0aGUgcmVxdWVzdCB3aWxsCi0JCSoqIHByb2R1Y2UgYW4gSS9PLWVycm9yCi0JCSovCi0JCWlmICghY293ZGV2LT5waWQpIHsKLQkJCXByaW50ayhLRVJOX0VSUiJjb3dsb29wIC0gbm8gdGhyZWFkIGF2YWlsYWJsZVxuIik7Ci0JCQlfX2Jsa19lbmRfcmVxdWVzdF9jdXIocmVxLCAtRUlPKTsJLyogcmVxdWVzdCBmYWlsZWQgKi8KLQkJCWNvd2Rldi0+aW9idXN5CT0gMDsKLQkJCWNvbnRpbnVlOwotCQl9Ci0KLQkJLyoKLQkJKiogaGFuZGxlIEkvTy1yZXF1ZXN0IGluIHRoZSBjb250ZXh0IG9mIHRoZSBrZXJuZWwtdGhyZWFkCi0JCSovCi0JCWNvd2Rldi0+cmVxIAk9IHJlcTsKLQkJY293ZGV2LT5xZmlsbGVkCT0gMTsKLQotCQl3YWtlX3VwX2ludGVycnVwdGlibGVfc3luYygmY293ZGV2LT53YWl0cSk7Ci0KLQkJLyoKLQkJKiogZ2V0IG91dCBvZiB0aGlzIGZ1bmN0aW9uIG5vdyB3aGlsZSB0aGUgSS9PLXJlcXVlc3QgaXMKLQkJKiogdW5kZXIgdHJlYXRtZW50IG9mIHRoZSBrZXJuZWwtdGhyZWFkOyB0aGlzIGZ1bmN0aW9uCi0JCSoqIHdpbGwgYmUgY2FsbGVkIGFnYWluIGFmdGVyIHRoZSBjdXJyZW50IEkvTy1yZXF1ZXN0IGhhcwotCQkqKiBiZWVuIGZpbmlzaGVkIGJ5IHRoZSB0aHJlYWQKLQkJKi8KLQkJcmV0dXJuOwotCX0KLX0KLQotLyoKLSoqIGRhZW1vbi1wcm9jZXNzIChrZXJuZWwtdGhyZWFkKSBleGVjdXRlcyB0aGlzIGZ1bmN0aW9uCi0qLwotc3RhdGljIGludAotY293bG9fZGFlbW9uKHN0cnVjdCBjb3dsb29wX2RldmljZSAqY293ZGV2KQotewotCWludAlydjsKLQlpbnQgICAgIG1pbm9yOwotCWNoYXIJbXluYW1lWzE2XTsKLQotCWZvciAobWlub3IgPSAwOyBtaW5vciA8IG1heGNvd3M7IG1pbm9yKyspIHsKLQkJaWYgKGNvd2RldiA9PSBjb3dkZXZhbGxbbWlub3JdKSBicmVhazsKLQl9Ci0Jc3ByaW50ZihteW5hbWUsICJjb3dsb29wZCVkIiwgbWlub3IpOwotCi0gICAgICAgIGRhZW1vbml6ZShteW5hbWUpOwotCi0Jd2hpbGUgKCFjb3dkZXYtPmNsb3NlZG93bikgewotCQkvKgotCQkqKiBzbGVlcCB3aGlsZSB3YWl0aW5nIGZvciBhbiBJL08gcmVxdWVzdDsKLQkJKiogbm90ZSB0aGF0IG5vIG5vbi1pbnRlcnJ1cHRpYmxlIHdhaXQgaGFzIGJlZW4gdXNlZAotCQkqKiBiZWNhdXNlIHRoZSBub24taW50ZXJydXB0aWJsZSB2ZXJzaW9uIG9mCi0JCSoqIGEgKnN5bmNocm9ub3VzKiB3YWtlX3VwIGRvZXMgbm90IGV4aXN0IChhbnkgbW9yZSkKLQkJKi8KLQkJaWYgKHdhaXRfZXZlbnRfaW50ZXJydXB0aWJsZShjb3dkZXYtPndhaXRxLCBjb3dkZXYtPnFmaWxsZWQpKXsKLQkJCWZsdXNoX3NpZ25hbHMoY3VycmVudCk7IC8qIGlnbm9yZSBzaWduYWwtYmFzZWQgd2FrZXVwICovCi0JCQljb250aW51ZTsKLQkJfQotCi0JCWlmIChjb3dkZXYtPmNsb3NlZG93bikJCS8qIG1vZHVsZSB3aWxsIGJlIHVubG9hZGVkID8gKi97Ci0JCQljb3dkZXYtPnBpZCA9IDA7Ci0JCQlyZXR1cm4gMDsKLQkJfQotCi0JCS8qCi0JCSoqIHdva2VuIHVwIGJ5IHRoZSBJL08tcmVxdWVzdCBoYW5kbGVyOgl0cmVhdCByZXF1ZXN0ZWQgSS9PCi0JCSovCi0JCWNvd2Rldi0+cWZpbGxlZCA9IDA7Ci0KLQkJcnYgPSBjb3dsb19kb19yZXF1ZXN0KGNvd2Rldi0+cmVxKTsKLQotCQkvKgotCQkqKiByZWFjcXVpcmUgdGhlIHF1ZXVlLXNwaW5sb2NrIGZvciBtYW5pcHVsYXRpbmcKLQkJKiogdGhlIHJlcXVlc3QtcXVldWUgYW5kIGRlcXVldWUgdGhlIHJlcXVlc3QKLQkJKi8KLQkJc3Bpbl9sb2NrX2lycSgmY293ZGV2LT5ycWxvY2spOwotCi0JCV9fYmxrX2VuZF9yZXF1ZXN0X2N1cihjb3dkZXYtPnJlcSwgcnYpOwotCQljb3dkZXYtPmlvYnVzeSA9IDA7Ci0KLQkJLyoKLQkJKiogaW5pdGlhdGUgdGhlIG5leHQgcmVxdWVzdCBmcm9tIHRoZSBxdWV1ZQotCQkqLwotCQljb3dsb19yZXF1ZXN0KGNvd2Rldi0+cnF1ZXVlKTsKLQotCQlzcGluX3VubG9ja19pcnEoJmNvd2Rldi0+cnFsb2NrKTsKLQl9Ci0JcmV0dXJuIDA7Ci19Ci0KLS8qCi0qKiBmdW5jdGlvbiB0byBiZSBjYWxsZWQgaW4gdGhlIGNvbnRleHQgb2YgdGhlIGtlcm5lbCB0aHJlYWQKLSoqIHRvIGhhbmRsZSB0aGUgcXVldWVkIEkvTy1yZXF1ZXN0cwotKioKLSoqIHJldHVybnM6Ci0qKiAJMCAgIC0gZmFpbAotKiogICAgICAxICAgLSBzdWNjZXNzCi0qLwotc3RhdGljIGxvbmcgaW50Ci1jb3dsb19kb19yZXF1ZXN0KHN0cnVjdCByZXF1ZXN0ICpyZXEpCi17Ci0JdW5zaWduZWQgbG9uZwkJbGVuOwotCWxvbmcgaW50CQlydjsKLQlsb2ZmX3QgCQkJb2Zmc2V0OwotCXN0cnVjdCBjb3dsb29wX2RldmljZQkqY293ZGV2ID0gcmVxLT5ycV9kaXNrLT5wcml2YXRlX2RhdGE7Ci0KLQkvKgotCSoqIGNhbGN1bGF0ZSBzb21lIHZhcmlhYmxlcyB3aGljaCBhcmUgbmVlZGVkIGxhdGVyIG9uCi0JKi8KLQlsZW4gICAgID0gICAgICAgICAgYmxrX3JxX2N1cl9zZWN0b3JzKHJlcSkgPDwgOTsKLQlvZmZzZXQgID0gKGxvZmZfdCkgYmxrX3JxX3BvcyhyZXEpICAgICAgICAgPDwgOTsKLQotCURFQlVHUChEQ09XImNvd2xvb3AgLSByZXEgY21kPSVkIG9mZnNldD0lbGxkIGxlbj0lbHUgYWRkcj0lcFxuIiwKLQkJCQkqKHJlcS0+Y21kKSwgb2Zmc2V0LCBsZW4sIHJlcS0+YnVmZmVyKTsKLQotCS8qCi0JKiogaGFuZGxlIFJFQUQtIG9yIFdSSVRFLXJlcXVlc3QKLQkqLwotCXN3aXRjaCAocnFfZGF0YV9kaXIocmVxKSkgewotCSAgIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotCSAgIGNhc2UgUkVBRDoKLQkJc3dpdGNoICggY293bG9fY2hlY2tpbyhjb3dkZXYsIGxlbiwgb2Zmc2V0KSApIHsKLQkJICAgY2FzZSBBTExDT1c6Ci0JCQlydiA9IGNvd2xvX3JlYWRjb3coY293ZGV2LCByZXEtPmJ1ZmZlciwgbGVuLCBvZmZzZXQpOwotCQkJYnJlYWs7Ci0KLQkJICAgY2FzZSBBTExSRE86Ci0JCQlydiA9IGNvd2xvX3JlYWRyZG8oY293ZGV2LCByZXEtPmJ1ZmZlciwgbGVuLCBvZmZzZXQpOwotCQkJYnJlYWs7Ci0KLQkgICAJICAgY2FzZSBNSVhFRFVQOgotCQkJcnYgPSBjb3dsb19yZWFkbWl4KGNvd2RldiwgcmVxLT5idWZmZXIsIGxlbiwgb2Zmc2V0KTsKLQkJCWJyZWFrOwotCi0JCSAgIGRlZmF1bHQ6Ci0JCQlydiA9IDA7CS8qIG5ldmVyIGhhcHBlbnMgKi8KLQkJfQotCQlicmVhazsKLQotCSAgIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwotCSAgIGNhc2UgV1JJVEU6Ci0JCXN3aXRjaCAoIGNvd2xvX2NoZWNraW8oY293ZGV2LCBsZW4sIG9mZnNldCkgKSB7Ci0JCSAgIGNhc2UgQUxMQ09XOgotCQkJLyoKLQkJCSoqIHN0cmFpZ2h0LWZvcndhcmQgd3JpdGUgd2lsbCBkby4uLgotCQkJKi8KLQkJCURFQlVHUChEQ09XImNvd2xvb3AgLSB3cml0ZSBzdHJhaWdodCAiKTsKLQotCQkJcnYgPSBjb3dsb193cml0ZWNvdyhjb3dkZXYsIHJlcS0+YnVmZmVyLCBsZW4sIG9mZnNldCk7Ci0JCQlicmVhazsJLyogZnJvbSBzd2l0Y2ggKi8KLQotCQkgICBjYXNlIEFMTFJETzoKLQkJCWlmICggKGxlbiAmIE1VTUFTSykgPT0gMCkgewotCQkJCURFQlVHUChEQ09XImNvd2xvb3AgLSB3cml0ZSBzdHJhaWdodCAiKTsKLQotCQkJCXJ2ID0gY293bG9fd3JpdGVjb3coY293ZGV2LCByZXEtPmJ1ZmZlciwKLQkJCQkJCQkJbGVuLCBvZmZzZXQpOwotCQkJCWJyZWFrOwotCQkJfQotCi0JICAgCSAgIGNhc2UgTUlYRURVUDoKLQkJCXJ2ID0gY293bG9fd3JpdGVtaXgoY293ZGV2LCByZXEtPmJ1ZmZlciwgbGVuLCBvZmZzZXQpOwotCQkJYnJlYWs7Ci0KLQkJICAgZGVmYXVsdDoKLQkJCXJ2ID0gMDsJLyogbmV2ZXIgaGFwcGVucyAqLwotCQl9Ci0JCWJyZWFrOwotCi0JICAgZGVmYXVsdDoKLQkJcHJpbnRrKEtFUk5fRVJSCi0JCSAgICAgICAiY293bG9vcCAtIHVucmVjb2duaXplZCBjb21tYW5kICVkXG4iLCAqKHJlcS0+Y21kKSk7Ci0JCXJ2ID0gMDsKLQl9Ci0KLQlyZXR1cm4gKHJ2IDw9IDAgPyAwIDogMSk7Ci19Ci0KLS8qCi0qKiBjaGVjayBmb3IgYSBnaXZlbiBJL08tcmVxdWVzdCBpZiBhbGwgdW5kZXJseWluZyBibG9ja3MKLSoqICh3aXRoIHNpemUgTUFQVU5JVCkgYXJlIGVpdGhlciBpbiB0aGUgcmVhZC1vbmx5IGZpbGUgb3IgaW4KLSoqIHRoZSBjb3dmaWxlIChvciBhIGNvbWJpbmF0aW9uIG9mIHRoZSB0d28pCi0qKgotKiogcmV0dXJuczoKLSoqIAlBTExSRE8gIC0gYWxsIHVuZGVybHlpbmcgYmxvY2tzIGluIHJkb2ZpbGUKLSoqICAgICAgQUxMQ09XICAtIGFsbCB1bmRlcmx5aW5nIGJsb2NrcyBpbiBjb3dmaWxlCi0qKiAgICAgIE1JWEVEVVAgLSB1bmRlcmx5aW5nIGJsb2NrcyBwYXJ0bHkgaW4gcmRvZmlsZSBhbmQgcGFydGx5IGluIGNvd2ZpbGUKLSovCi1zdGF0aWMgaW50Ci1jb3dsb19jaGVja2lvKHN0cnVjdCBjb3dsb29wX2RldmljZSAqY293ZGV2LCBpbnQgbGVuLCBsb2ZmX3Qgb2Zmc2V0KQotewotCXVuc2lnbmVkIGxvbmcJbWFwbnVtLCBieXRlbnVtLCBiaXRudW0sIGJsb2NrbnIsIHBhcnRsZW47Ci0JbG9uZyBpbnQJdG90Y250LCBjb3djbnQ7Ci0JY2hhcgkJKm1jOwotCi0JLyoKLQkqKiBub3RpY2UgdGhhdCB0aGUgcmVxdWVzdGVkIGJsb2NrIG1pZ2h0IGNyb3NzCi0JKiogYSBibG9ja3NpemUgYm91bmRhcnkgd2hpbGUgb25lIG9mIHRoZSBjb25jZXJuZWQKLQkqKiBibG9ja3MgcmVzaWRlcyBpbiB0aGUgcmVhZC1vbmx5IGZpbGUgYW5kIGFub3RoZXIKLQkqKiBvbmUgaW4gdGhlIGNvcHktb24td3JpdGUgZmlsZTsgaW4gdGhhdCBjYXNlIHRoZQotICAgICAgICAqKiByZXF1ZXN0IHdpbGwgYmUgYnJva2VuIHVwIGludG8gcGllY2VzCi0JKi8KLQlpZiAoIChsZW4gPD0gTUFQVU5JVCkgJiYKLQkgICAgIChNQVBVTklUIC0gKG9mZnNldCAmIE1VTUFTSykgPD0gbGVuKSApIHsKLQkJLyoKLQkJKiogZWFzeSBzaXR1YXRpb246Ci0JCSoqIHJlcXVlc3RlZCBkYXRhLWJsb2NrIGVudGlyZWx5IGZpdHMgd2l0aGluCi0JCSoqIHRoZSBtYXB1bml0IHVzZWQgZm9yIHRoZSBiaXRtYXAKLQkJKiogY2hlY2sgaWYgdGhhdCBibG9jayBpcyBsb2NhdGVkIGluIHJkb2ZpbGUgb3IKLQkJKiogY293ZmlsZQotCQkqLwotCQlibG9ja25yID0gb2Zmc2V0ID4+IE1VU0hJRlQ7Ci0KLQkJbWFwbnVtICA9IENBTENNQVAgKGJsb2NrbnIpOwotCQlieXRlbnVtID0gQ0FMQ0JZVEUoYmxvY2tucik7Ci0JCWJpdG51bSAgPSBDQUxDQklUIChibG9ja25yKTsKLQotCQlpZiAoKigqKGNvd2Rldi0+bWFwY2FjaGUrbWFwbnVtKStieXRlbnVtKSYoMTw8Yml0bnVtKSkKLQkJCXJldHVybiBBTExDT1c7Ci0JCWVsc2UKLQkJCXJldHVybiBBTExSRE87Ci0JfQotCi0JLyoKLQkqKiBsZXNzIGVhc3kgc2l0dWF0aW9uOgotCSoqIHRoZSByZXF1ZXN0ZWQgZGF0YS1ibG9jayBkb2VzIG5vdCBmaXQgd2l0aGluIHRoZSBtYXB1bml0Ci0JKiogdXNlZCBmb3IgdGhlIGJpdG1hcAotCSoqIGNoZWNrIGlmICphbGwqIHVuZGVybHlpbmcgYmxvY2tzIGludm9sdmVkIHJlc2lkZSBvbiB0aGUgcmRvZmlsZQotICAgICAgIAkqKiBvciB0aGUgY293ZmlsZSAoc28gc3RpbGwgbm8gYnJlYWt1cCByZXF1aXJlZCkKLQkqLwotCWZvciAoY293Y250PXRvdGNudD0wOyBsZW4gPiAwOyBsZW4tPXBhcnRsZW4sIG9mZnNldCs9cGFydGxlbiwgdG90Y250KyspewotCQkvKgotCQkqKiBjYWxjdWxhdGUgYmxvY2tuciBvZiBpbnZvbHZlZCBibG9jawotCQkqLwotCQlibG9ja25yID0gb2Zmc2V0ID4+IE1VU0hJRlQ7Ci0KLQkJLyoKLQkJKiogY2FsY3VsYXRlIHBhcnRpYWwgbGVuZ3RoIGZvciB0aGlzIHRyYW5zZmVyCi0JCSovCi0JCXBhcnRsZW4gPSBNQVBVTklUIC0gKG9mZnNldCAmIE1VTUFTSyk7Ci0JCWlmIChwYXJ0bGVuID4gbGVuKQotCQkJcGFydGxlbiA9IGxlbjsKLQotCQkvKgotCQkqKiBpcyB0aGlzIGJsb2NrIGxvY2F0ZWQgaW4gdGhlIGNvd2ZpbGUKLQkJKi8KLQkJbWFwbnVtICA9IENBTENNQVAgKGJsb2NrbnIpOwotCQlieXRlbnVtID0gQ0FMQ0JZVEUoYmxvY2tucik7Ci0JCWJpdG51bSAgPSBDQUxDQklUIChibG9ja25yKTsKLQotCQltYwk9ICooY293ZGV2LT5tYXBjYWNoZSttYXBudW0pOwotCi0JCWlmICgqKG1jK2J5dGVudW0pJigxPDxiaXRudW0pKQotCQkJY293Y250Kys7OwotCi0JCURFQlVHUChEQ09XCi0JCSAgICAgICAiY293bG9vcCAtIGNoZWNrICVsdSAtIG1hcCAlbHUsIGJ5dGUgJWx1LCBiaXQgJWx1LCAiCi0JCSAgICAgICAiY293Y250ICVsZCwgdG90Y250ICVsZCAlMDJ4ICVwXG4iLAotCQkJYmxvY2tuciwgbWFwbnVtLCBieXRlbnVtLCBiaXRudW0sIGNvd2NudCwgdG90Y250LAotCQkJKihtYytieXRlbnVtKSwgbWMpOwotCX0KLQotCWlmIChjb3djbnQgPT0gMCkJLyogYWxsIGludm9sdmVkIGJsb2NrcyBvbiByZG9maWxlPyAqLwotCQlyZXR1cm4gQUxMUkRPOwotCi0JaWYgKGNvd2NudCA9PSB0b3RjbnQpCS8qIGFsbCBpbnZvbHZlZCBibG9ja3Mgb24gY293ZmlsZT8gKi8KLQkJcmV0dXJuIEFMTENPVzsKLQotCS8qCi0JKiogc2l0dWF0aW9uIHNvbWV3aGF0IG1vcmUgY29tcGxpY2F0ZWQ6Ci0JKiogaW52b2x2ZWQgdW5kZXJseWluZyBibG9ja3Mgc3ByZWFkIG92ZXIgYm90aCBmaWxlcwotCSovCi0JcmV0dXJuIE1JWEVEVVA7Ci19Ci0KLS8qCi0qKiByZWFkIHJlcXVlc3RlZCBjaHVuayBwYXJ0bHkgZnJvbSByZG9maWxlIGFuZCBwYXJ0bHkgZnJvbSBjb3dmaWxlCi0qKgotKiogcmV0dXJuczoKLSoqIAkwICAgLSBmYWlsCi0qKiAgICAgIDEgICAtIHN1Y2Nlc3MKLSovCi1zdGF0aWMgaW50Ci1jb3dsb19yZWFkbWl4KHN0cnVjdCBjb3dsb29wX2RldmljZSAqY293ZGV2LCB2b2lkICpidWYsIGludCBsZW4sIGxvZmZfdCBvZmZzZXQpCi17Ci0JdW5zaWduZWQgbG9uZwltYXBudW0sIGJ5dGVudW0sIGJpdG51bSwgYmxvY2tuciwgcGFydGxlbjsKLQlsb25nIGludAlydjsKLQljaGFyCQkqbWM7Ci0KLQkvKgotCSoqIGNvbXBsaWNhdGVkIGFwcHJvYWNoOiBicmVha3VwIHJlcXVpcmVkIG9mIHJlYWQtcmVxdWVzdAotCSovCi0JZm9yIChydj0xOyBsZW4gPiAwOyBsZW4tPXBhcnRsZW4sIGJ1Zis9cGFydGxlbiwgb2Zmc2V0Kz1wYXJ0bGVuKSB7Ci0JCS8qCi0JCSoqIGNhbGN1bGF0ZSBibG9ja25yIG9mIGVudGlyZSBibG9jawotCQkqLwotCQlibG9ja25yID0gb2Zmc2V0ID4+IE1VU0hJRlQ7Ci0KLQkJLyoKLQkJKiogY2FsY3VsYXRlIHBhcnRpYWwgbGVuZ3RoIGZvciB0aGlzIHRyYW5zZmVyCi0JCSovCi0JCXBhcnRsZW4gPSBNQVBVTklUIC0gKG9mZnNldCAmIE1VTUFTSyk7Ci0JCWlmIChwYXJ0bGVuID4gbGVuKQotCQkJcGFydGxlbiA9IGxlbjsKLQotCQkvKgotCQkqKiBpcyB0aGlzIGJsb2NrIGxvY2F0ZWQgaW4gdGhlIGNvd2ZpbGUKLQkJKi8KLQkJbWFwbnVtICA9IENBTENNQVAgKGJsb2NrbnIpOwotCQlieXRlbnVtID0gQ0FMQ0JZVEUoYmxvY2tucik7Ci0JCWJpdG51bSAgPSBDQUxDQklUIChibG9ja25yKTsKLQkJbWMJPSAqKGNvd2Rldi0+bWFwY2FjaGUrbWFwbnVtKTsKLQotCQlpZiAoKihtYytieXRlbnVtKSYoMTw8Yml0bnVtKSkgewotCQkJLyoKLQkJCSoqIHJlYWQgKHBhcnRpYWwpIGJsb2NrIGZyb20gY293ZmlsZQotCQkJKi8KLQkJCURFQlVHUChEQ09XImNvd2xvb3AgLSBzcGxpdCByZWFkICIKLQkJCQkiY293IHBhcnRsZW49JWxkIG9mZj0lbGxkXG4iLCBwYXJ0bGVuLCBvZmZzZXQpOwotCi0JCQlpZiAoY293bG9fcmVhZGNvdyhjb3dkZXYsIGJ1ZiwgcGFydGxlbiwgb2Zmc2V0KSA8PSAwKQotCQkJCXJ2ID0gMDsKLQkJfSBlbHNlIHsKLQkJCS8qCi0JCQkqKiByZWFkIChwYXJ0aWFsKSBibG9jayBmcm9tIHJkb2ZpbGUKLQkJCSovCi0JCQlERUJVR1AoRENPVyJjb3dsb29wIC0gc3BsaXQgcmVhZCAiCi0JCQkJInJkbyBwYXJ0bGVuPSVsZCBvZmY9JWxsZFxuIiwgcGFydGxlbiwgb2Zmc2V0KTsKLQotCQkJaWYgKGNvd2xvX3JlYWRyZG8oY293ZGV2LCBidWYsIHBhcnRsZW4sIG9mZnNldCkgPD0gMCkKLQkJCQlydiA9IDA7Ci0JCX0KLQl9Ci0KLQlyZXR1cm4gcnY7Ci19Ci0KLS8qCi0qKiBjaHVuayB0byBiZSB3cml0dGVuIHRvIHRoZSBjb3dmaWxlIG5lZWRzIHBpZWNlcyB0byBiZQotKiogcmVhZCBmcm9tIHRoZSByZG9maWxlCi0qKgotKiogcmV0dXJuczoKLSoqIAkwICAgLSBmYWlsCi0qKiAgICAgIDEgICAtIHN1Y2Nlc3MKLSovCi1zdGF0aWMgaW50Ci1jb3dsb193cml0ZW1peChzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKmNvd2Rldiwgdm9pZCAqYnVmLCBpbnQgbGVuLCBsb2ZmX3Qgb2Zmc2V0KQotewotCXVuc2lnbmVkIGxvbmcJbWFwbnVtLCBieXRlbnVtLCBiaXRudW0sIGJsb2NrbnIsIHBhcnRsZW47Ci0JbG9uZyBpbnQJcnY7Ci0JY2hhcgkJKm1jOwotCi0JLyoKLQkqKiBzb21ld2hhdCBtb3JlIGNvbXBsaWNhdGVkIHN0dWZmIGlzIHJlcXVpcmVkOgotCSoqIGlmIHRoZSByZXF1ZXN0IGlzIGxhcmdlciB0aGFuIG9uZSB1bmRlcmx5aW5nCi0JKiogYmxvY2sgb3IgaXMgc3ByZWFkIG92ZXIgdHdvIHVuZGVybHlpbmcgYmxvY2tzLAotCSoqIHNwbGl0IHRoZSByZXF1ZXN0IGludG8gcGllY2VzOyBpZiBhIGJsb2NrIGRvZXMgbm90Ci0JKiogc3RhcnQgYXQgYSBibG9jayBib3VuZGFyeSwgdGFrZSBjYXJlIHRoYXQKLQkqKiBzdXJyb3VuZGluZyBkYXRhIGlzIHJlYWQgZmlyc3QgKGlmIG5lZWRlZCksCi0JKiogZml0IHRoZSBuZXcgZGF0YSBpbiBhbmQgd3JpdGUgaXQgYXMgYSBmdWxsIGJsb2NrCi0JKi8KLQlmb3IgKHJ2PTE7IGxlbiA+IDA7IGxlbi09cGFydGxlbiwgYnVmKz1wYXJ0bGVuLCBvZmZzZXQrPXBhcnRsZW4pIHsKLQkJLyoKLQkJKiogY2FsY3VsYXRlIHBhcnRpYWwgbGVuZ3RoIGZvciB0aGlzIHRyYW5zZmVyCi0JCSovCi0JCXBhcnRsZW4gPSBNQVBVTklUIC0gKG9mZnNldCAmIE1VTUFTSyk7Ci0JCWlmIChwYXJ0bGVuID4gbGVuKQotCQkJcGFydGxlbiA9IGxlbjsKLQotCQkvKgotCQkqKiBjYWxjdWxhdGUgYmxvY2tuciBvZiBlbnRpcmUgYmxvY2sKLQkJKi8KLQkJYmxvY2tuciA9IG9mZnNldCA+PiBNVVNISUZUOwotCi0JCS8qCi0JCSoqIGhhcyB0aGlzIGJsb2NrIGJlZW4gd3JpdHRlbiBiZWZvcmU/Ci0JCSovCi0JCW1hcG51bSAgPSBDQUxDTUFQIChibG9ja25yKTsKLQkJYnl0ZW51bSA9IENBTENCWVRFKGJsb2NrbnIpOwotCQliaXRudW0gID0gQ0FMQ0JJVCAoYmxvY2tucik7Ci0JCW1jCT0gKihjb3dkZXYtPm1hcGNhY2hlK21hcG51bSk7Ci0KLQkJaWYgKCoobWMrYnl0ZW51bSkmKDE8PGJpdG51bSkpIHsKLQkJCS8qCi0JCQkqKiBibG9jayBoYXMgYmVlbiB3cml0dGVuIGJlZm9yZTsKLQkJCSoqIHdyaXRlIHRyYW5zcGFyYW50bHkgdG8gY293ZmlsZQotCQkJKi8KLQkJCURFQlVHUChEQ09XCi0JCQkgICAgICAgImNvd2xvb3AgLSBzcGxpdHdyIHRyYW5zcFxuIik7Ci0KLQkJCWlmIChjb3dsb193cml0ZWNvdyhjb3dkZXYsIGJ1ZiwgcGFydGxlbiwgb2Zmc2V0KSA8PSAwKQotCQkJCXJ2ID0gMDsKLQkJfSBlbHNlIHsKLQkJCS8qCi0JCQkqKiBibG9jayBoYXMgbmV2ZXIgYmVlbiB3cml0dGVuIGJlZm9yZSwKLQkJCSoqIHNvIHJlYWQgZW50aXJlIGJsb2NrIGZyb20KLQkJCSoqIHJlYWQtb25seSBmaWxlIGZpcnN0LCB1bmxlc3MKLQkJCSoqIGEgZnVsbCBibG9jayBpcyByZXF1ZXN0ZWQgdG8KLQkJCSoqIGJlIHdyaXR0ZW4KLQkJCSovCi0JCQlpZiAocGFydGxlbiA8IE1BUFVOSVQpIHsKLQkJCQlpZiAoY293bG9fcmVhZHJkbyhjb3dkZXYsIGNvd2Rldi0+aW9idWYsCi0JCQkJICAgICAgTUFQVU5JVCwgKGxvZmZfdClibG9ja25yIDw8IE1VU0hJRlQpIDw9IDApCi0JCQkJCXJ2ID0gMDsKLQkJCX0KLQotCQkJLyoKLQkJCSoqIHRyYW5zZmVyIG1vZGlmaWVkIHBhcnQgaW50bwotCQkJKiogdGhlIGJsb2NrIGp1c3QgcmVhZAotCQkJKi8KLQkJCW1lbWNweShjb3dkZXYtPmlvYnVmICsgKG9mZnNldCAmIE1VTUFTSyksIGJ1ZiwgcGFydGxlbik7Ci0KLQkJCS8qCi0JCQkqKiB3cml0ZSBlbnRpcmUgYmxvY2sgdG8gY293ZmlsZQotCQkJKi8KLQkJCURFQlVHUChEQ09XImNvd2xvb3AgLSBzcGxpdCAiCi0JCQkJInBhcnRsZW49JWxkIG9mZj0lbGxkXG4iLAotCQkJCXBhcnRsZW4sIChsb2ZmX3QpYmxvY2tuciA8PCBNVVNISUZUKTsKLQotCQkJaWYgKGNvd2xvX3dyaXRlY293KGNvd2RldiwgY293ZGV2LT5pb2J1ZiwgTUFQVU5JVCwKLQkJCQkJICAgICAobG9mZl90KWJsb2NrbnIgPDwgTVVTSElGVCkgPD0gMCkKLQkJCQlydiA9IDA7Ci0JCX0KLQl9Ci0KLQlyZXR1cm4gcnY7Ci19Ci0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLS8qIEkvTy1zdXBwb3J0IGZvciByZWFkLW9ubHkgZmlsZSBhbmQgY29weS1vbi13cml0ZSBmaWxlICAgICAgICAgICAgICAgICAgICAgKi8KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotLyoKLSoqIHJlYWQgZGF0YSBmcm9tIHRoZSByZWFkLW9ubHkgZmlsZQotKioKLSoqIHJldHVybi12YWx1ZTogc2ltaWxhciB0byB1c2VyLW1vZGUgcmVhZAotKi8KLXN0YXRpYyBsb25nIGludAotY293bG9fcmVhZHJkbyhzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKmNvd2Rldiwgdm9pZCAqYnVmLCBpbnQgbGVuLCBsb2ZmX3Qgb2Zmc2V0KQotewotCWxvbmcgaW50CXJ2OwotCW1tX3NlZ21lbnRfdAlvbGRfZnM7Ci0JbG9mZl90CQlzYXZlb2Zmc2V0ID0gb2Zmc2V0OwotCi0JREVCVUdQKERDT1ciY293bG9vcCAtIHJlYWRyZG8gY2FsbGVkXG4iKTsKLQotICAgICAgICBvbGRfZnMgPSBnZXRfZnMoKTsKLQlzZXRfZnMoIGdldF9kcygpICk7Ci0JcnYgPSBjb3dkZXYtPnJkb2ZwLT5mX29wLT5yZWFkKGNvd2Rldi0+cmRvZnAsIGJ1ZiwgbGVuLCAmb2Zmc2V0KTsKLSAgICAgICAgc2V0X2ZzKG9sZF9mcyk7Ci0KLQlpZiAocnYgPCBsZW4pIHsKLQkJcHJpbnRrKEtFUk5fV0FSTklORyAiY293bG9vcCAtIHJlYWQtZmFpbHVyZSAlbGQgb24gcmRvZmlsZSIKLQkJICAgICAgICAgICAgICAgICAgICAiLSBvZmZzZXQ9JWxsZCBsZW49JWRcbiIsCi0JCQkJCXJ2LCBzYXZlb2Zmc2V0LCBsZW4pOwotCX0KLQotCWNvd2Rldi0+cmRvcmVhZHMrKzsKLQlyZXR1cm4gcnY7Ci19Ci0KLS8qCi0qKiByZWFkIGNvd2ZpbGUgZnJvbSBhIG1vZGlmaWVkIG9mZnNldCwgaS5lLiBza2lwcGluZyB0aGUgYml0bWFwIGFuZCBjb3doZWFkCi0qKgotKiogcmV0dXJuLXZhbHVlOiBzaW1pbGFyIHRvIHVzZXItbW9kZSByZWFkCi0qLwotc3RhdGljIGxvbmcgaW50Ci1jb3dsb19yZWFkY293KHN0cnVjdCBjb3dsb29wX2RldmljZSAqY293ZGV2LCB2b2lkICpidWYsIGludCBsZW4sIGxvZmZfdCBvZmZzZXQpCi17Ci0JREVCVUdQKERDT1ciY293bG9vcCAtIHJlYWRjb3cgY2FsbGVkXG4iKTsKLQotCW9mZnNldCArPSBjb3dkZXYtPmNvd2hlYWQtPmRvZmZzZXQ7Ci0KLQlyZXR1cm4gY293bG9fcmVhZGNvd3Jhdyhjb3dkZXYsIGJ1ZiwgbGVuLCBvZmZzZXQpOwotfQotCi0vKgotKiogcmVhZCBjb3dmaWxlIGZyb20gYW4gYWJzb2x1dGUgb2Zmc2V0Ci0qKgotKiogcmV0dXJuLXZhbHVlOiBzaW1pbGFyIHRvIHVzZXItbW9kZSByZWFkCi0qLwotc3RhdGljIGxvbmcgaW50Ci1jb3dsb19yZWFkY293cmF3KHN0cnVjdCBjb3dsb29wX2RldmljZSAqY293ZGV2LAotCQkJCQl2b2lkICpidWYsIGludCBsZW4sIGxvZmZfdCBvZmZzZXQpCi17Ci0JbG9uZyBpbnQJcnY7Ci0JbW1fc2VnbWVudF90CW9sZF9mczsKLQlsb2ZmX3QJCXNhdmVvZmZzZXQgPSBvZmZzZXQ7Ci0KLQlERUJVR1AoRENPVyJjb3dsb29wIC0gcmVhZGNvd3JhdyBjYWxsZWRcbiIpOwotCi0JLyoKLQkqKiBiZSBzdXJlIHRoYXQgY293ZmlsZSBpcyBvcGVuZWQgZm9yIHJlYWQtd3JpdGUKLQkqLwotCWlmICggIShjb3dkZXYtPnN0YXRlICYgQ09XQ09XT1BFTikgKSB7Ci0JCSBwcmludGsoS0VSTl9XQVJOSU5HCi0JCSAgICAgICAgImNvd2xvb3AgLSByZWFkIHJlcXVlc3QgZnJvbSBjb3dmaWxlIHJlZnVzZWRcbiIpOwotCi0JCXJldHVybiAtRUJBREY7Ci0JfQotCi0JLyoKLQkqKiBpc3N1ZSBsb3cgbGV2ZWwgcmVhZAotCSovCi0gICAgICAgIG9sZF9mcyA9IGdldF9mcygpOwotCXNldF9mcyggZ2V0X2RzKCkgKTsKLQlydiA9IGNvd2Rldi0+Y293ZnAtPmZfb3AtPnJlYWQoY293ZGV2LT5jb3dmcCwgYnVmLCBsZW4sICZvZmZzZXQpOwotICAgICAgICBzZXRfZnMob2xkX2ZzKTsKLQotCWlmIChydiA8IGxlbikgewotCQlwcmludGsoS0VSTl9XQVJOSU5HCi0JCSAgICAgICAiY293bG9vcCAtIHJlYWQtZmFpbHVyZSAlbGQgb24gY293ZmlsZSIKLQkJICAgICAgICItIG9mZnNldD0lbGxkIGxlbj0lZFxuIiwgcnYsIHNhdmVvZmZzZXQsIGxlbik7Ci0JfQotCi0JY293ZGV2LT5jb3dyZWFkcysrOwotCXJldHVybiBydjsKLX0KLQotLyoKLSoqIHdyaXRlIGNvd2ZpbGUgZnJvbSBhIG1vZGlmaWVkIG9mZnNldCwgaS5lLiBza2lwcGluZyB0aGUgYml0bWFwIGFuZCBjb3doZWFkCi0qKgotKiogaWYgYSBibG9jayBpcyB3cml0dGVuIGZvciB0aGUgZmlyc3QgdGltZSB3aGlsZSBpdHMgY29udGVudHMgY29uc2lzdHMKLSoqIG9mIGJpbmFyeSB6ZXJvZXMgb25seSwgdGhlIGNvbmNlcm5pbmcgYml0bWFwIGlzIGZsdXNoZWQgdG8gdGhlIGNvd2ZpbGUKLSoqCi0qKiByZXR1cm4tdmFsdWU6IHNpbWlsYXIgdG8gdXNlci1tb2RlIHdyaXRlCi0qLwotc3RhdGljIGxvbmcgaW50Ci1jb3dsb193cml0ZWNvdyhzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKmNvd2Rldiwgdm9pZCAqYnVmLCBpbnQgbGVuLCBsb2ZmX3Qgb2Zmc2V0KQotewotCWxvbmcgaW50CXJ2OwotCXVuc2lnbmVkIGxvbmcJbWFwbnVtPTAsIG1hcGJ5dGU9MCwgbWFwYml0PTAsIGNvd2Jsb2NrPTAsIHBhcnRsZW47Ci0JY2hhcgkJKnRtcHB0ciwgICptYXBwdHIgPSBOVUxMOwotCWxvZmZfdAkJdG1wb2Zmc2V0LCBtYXBvZmZzZXQgPSAwOwotCi0JREVCVUdQKERDT1ciY293bG9vcCAtIHdyaXRlY293IGNhbGxlZFxuIik7Ci0KLQkvKgotCSoqIGJlIHN1cmUgdGhhdCBjb3dmaWxlIGlzIG9wZW5lZCBmb3IgcmVhZC13cml0ZQotCSovCi0JaWYgKCAhKGNvd2Rldi0+c3RhdGUgJiBDT1dSV0NPV09QRU4pICkgewotCQkgcHJpbnRrKEtFUk5fV0FSTklORwotCQkgICAgICAgICJjb3dsb29wIC0gV3JpdGUgcmVxdWVzdCB0byBjb3dmaWxlIHJlZnVzZWRcbiIpOwotCi0JCXJldHVybiAtRUJBREY7Ci0JfQotCi0JLyoKLQkqKiB3cml0ZSB0aGUgZW50aXJlIGJsb2NrIHRvIHRoZSBjb3dmaWxlCi0JKi8KLQl0bXBvZmZzZXQgPSBvZmZzZXQgKyBjb3dkZXYtPmNvd2hlYWQtPmRvZmZzZXQ7Ci0KLQlydiA9IGNvd2xvX3dyaXRlY293cmF3KGNvd2RldiwgYnVmLCBsZW4sIHRtcG9mZnNldCk7Ci0KLQkvKgotCSoqIHZlcmlmeSBpZiBlbm91Z2ggc3BhY2UgYXZhaWxhYmxlIG9uIGZpbGVzeXN0ZW0gaG9sZGluZwotCSoqIHRoZSBjb3dmaWxlCi0JKiogICAtIHdoZW4gdGhlIGxhc3Qgd3JpdGUgZmFpbGVkIChtaWdodCBiZSBjYXVzZWQgYnkgbGFjayBvZiBzcGFjZSkKLQkqKiAgIC0gd2hlbiBhIHdhdGNoZXIgaXMgYWN0aXZlICh0byByZWFjdCBhZGVxdWF0bHkpCi0JKiogICAtIHdoZW4gdGhlIHByZXZpb3VzIGNoZWNrIGluZGljYXRlZCBmcyB3YXMgYWxtb3N0IGZ1bGwKLQkqKiAgIC0gd2l0aCByZWd1bGFyIGludGVydmFscwotCSovCi0JaWYgKCAocnYgPD0gMCkJCQkJICAgICAgIHx8Ci0JICAgICAoY293ZGV2LT5zdGF0ZSAgICAgICAgJiBDT1dXQVRDSERPRykgICAgICB8fAotCSAgICAgKGNvd2Rldi0+YmxrYXZhaWwgLyAyIDwgU1BDREZMSU5UVkwpICAgICAgfHwKLQkgICAgIChjb3dkZXYtPmNvd3dyaXRlcyAgICAlIFNQQ0RGTElOVFZMID09IDApICkgewotCQlzdHJ1Y3Qga3N0YXRmcwkJa3M7Ci0KLQkJaWYgKHZmc19zdGF0ZnMoY293ZGV2LT5jb3dmcC0+Zl9kZW50cnksICZrcyk9PTApewotCQkJaWYgKGtzLmZfYmF2YWlsIDw9IFNQQ01JTkJMSykgewotCQkJCXN3aXRjaCAoa3MuZl9iYXZhaWwpIHsKLQkJCQkgICBjYXNlIDA6Ci0JCQkJICAgY2FzZSAxOgotCQkJCSAgIGNhc2UgMjoKLQkJCQkgICBjYXNlIDM6Ci0JCQkJCXByaW50ayhLRVJOX0FMRVJUCi0JCQkJCSAgICAgICAiY293bG9vcCAtICIKLQkJCQkJICAgICAgICJBTEVSVDogY293ZmlsZSBmdWxsIVxuIik7Ci0JCQkJCWJyZWFrOwotCi0JCQkJICAgZGVmYXVsdDoKLQkJCQkJcHJpbnRrKEtFUk5fV0FSTklORwotCQkJCQkgICAgICAgImNvd2xvb3AgLSBjb3dmaWxlIGFsbW9zdCAiCi0JCQkJCSAgICAgICAiZnVsbCAob25seSAlbGx1IEtiIGZyZWUpXG4iLAotCQkJCQkJKHVuc2lnbmVkIGxvbmcgbG9uZykKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGtzLmZfYnNpemUgKiBrcy5mX2JhdmFpbCAvMTAyNCk7Ci0JCQkJfQotCQkJfQotCi0JCQljb3dkZXYtPmJsa3RvdGFsID0ga3MuZl9ibG9ja3M7Ci0JCQljb3dkZXYtPmJsa2F2YWlsID0ga3MuZl9iYXZhaWw7Ci0KLQkJCS8qCi0JCQkqKiB3YWtldXAgd2F0Y2hlciBpZiB0aHJlc2hvbGQgaGFzIGJlZW4gcmVhY2hlZAotCQkJKi8KLQkJCWlmICggKGNvd2Rldi0+c3RhdGUgJiBDT1dXQVRDSERPRykgJiYKLQkJCSAgICAoY293ZGV2LT53YXRjaHRocmVzaCA+PSBjb3dkZXYtPmJsa2F2YWlsKSApIHsKLQkJCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJmNvd2Rldi0+d2F0Y2hxKTsKLQkJCX0KLQkJfQotCX0KLQotCWlmIChydiA8PSAwKQotCQlyZXR1cm4gcnY7Ci0KLQlERUJVR1AoRENPVyJjb3dsb29wIC0gYmxvY2sgd3JpdHRlblxuIik7Ci0KLQkvKgotCSoqIGNoZWNrIGlmIGJsb2NrKHMpIGlzL2FyZSB3cml0dGVuIHRvIHRoZSBjb3dmaWxlCi0JKiogZm9yIHRoZSBmaXJzdCB0aW1lOyBpZiBzbywgYWRhcHQgdGhlIGJpdG1hcAotCSovCi0JZm9yICg7IGxlbiA+IDA7IGxlbi09cGFydGxlbiwgb2Zmc2V0Kz1wYXJ0bGVuLCBidWYrPXBhcnRsZW4pIHsKLQkJLyoKLQkJKiogY2FsY3VsYXRlIHBhcnRpYWwgbGVuZ3RoIGZvciB0aGlzIHRyYW5zZmVyCi0JCSovCi0JCXBhcnRsZW4gPSBNQVBVTklUIC0gKG9mZnNldCAmIE1VTUFTSyk7Ci0JCWlmIChwYXJ0bGVuID4gbGVuKQotCQkJcGFydGxlbiA9IGxlbjsKLQotCQkvKgotCQkqKiBjYWxjdWxhdGUgYml0bnIgb2Ygd3JpdHRlbiBjaHVuayBvZiBjb3dibG9jawotCQkqLwotCQljb3dibG9jayA9IG9mZnNldCA+PiBNVVNISUZUOwotCi0JCW1hcG51bSAgID0gQ0FMQ01BUCAoY293YmxvY2spOwotCQltYXBieXRlICA9IENBTENCWVRFKGNvd2Jsb2NrKTsKLQkJbWFwYml0ICAgPSBDQUxDQklUIChjb3dibG9jayk7Ci0KLQkJaWYgKCooKihjb3dkZXYtPm1hcGNhY2hlK21hcG51bSkrbWFwYnl0ZSkgJiAoMTw8bWFwYml0KSkKLQkJCWNvbnRpbnVlOwkvKiBhbHJlYWR5IHdyaXR0ZW4gYmVmb3JlICovCi0KLQkgICAgICAgCS8qCi0JCSoqIGlmIHRoZSBibG9jayBpcyB3cml0dGVuIGZvciB0aGUgZmlyc3QgdGltZSwKLQkJKiogdGhlIGNvcnJlc3BvbmRpbmcgYml0IHNob3VsZCBiZSBzZXQgaW4gdGhlIGJpdG1hcAotCQkqLwotCQkqKCooY293ZGV2LT5tYXBjYWNoZSttYXBudW0pK21hcGJ5dGUpIHw9ICgxPDxtYXBiaXQpOwotCi0JCWNvd2Rldi0+bnJjb3dibG9ja3MrKzsKLQotCQlERUJVR1AoRENPVyJjb3dsb29wIC0gYml0dXBkYXRlIGJsaz0lbGQgbWFwPSVsZCAiCi0JCSAgICAgICAgImJ5dGU9JWxkIGJpdD0lbGRcbiIsCi0JCQljb3dibG9jaywgbWFwbnVtLCBtYXBieXRlLCBtYXBiaXQpOwotCi0JCS8qCi0JCSoqIGNoZWNrIGlmIHRoZSBjb3doZWFkIGluIHRoZSBjb3dmaWxlIGlzIGN1cnJlbnRseQotCQkqKiBtYXJrZWQgY2xlYW47IGlmIHNvLCBtYXJrIGl0IGRpcnR5IGFuZCBmbHVzaCBpdAotCQkqLwotCQlpZiAoICEoY293ZGV2LT5jb3doZWFkLT5mbGFncyAmPSBDT1dESVJUWSkpIHsKLQkJCWNvd2Rldi0+Y293aGVhZC0+ZmxhZ3MJfD0gQ09XRElSVFk7Ci0KLQkJCWNvd2xvX3dyaXRlY293cmF3KGNvd2RldiwgY293ZGV2LT5jb3doZWFkLAotCQkJCQkJCU1BUFVOSVQsIChsb2ZmX3QpMCk7Ci0JCX0KLQotCQkvKgotCQkqKiBpZiB0aGUgd3JpdHRlbiBkYXRhYmxvY2sgY29udGFpbmVkIGJpbmFyeSB6ZXJvZXMsCi0JCSoqIHRoZSBiaXRtYXAgYmxvY2sgc2hvdWxkIGJlIG1hcmtlZCB0byBiZSBmbHVzaGVkIHRvIGRpc2sKLQkJKiogKGJsb2NrcyBjb250YWluaW5nIGFsbCB6ZXJvZXMgY2Fubm90IGJlIHJlY292ZXJlZCBieQotCQkqKiB0aGUgY293cmVwYWlyLXByb2dyYW0gbGF0ZXIgb24gaWYgY293bG9vcCBpcyBub3QgcHJvcGVybHkKLQkJKiogcmVtb3ZlZCB2aWEgcm1tb2QpCi0JCSovCi0JCWlmICggbWVtY21wKGJ1ZiwgYWxsemVyb2VzLCBwYXJ0bGVuKSApIC8qIG5vdCBhbGwgemVyb2VzPyAqLwotCQkJY29udGludWU7ICAgICAgICAgICAgICAgICAgICAgIC8qIG5vIGZsdXNoIG5lZWRlZCAqLwotCi0JCS8qCi0JCSoqIGNhbGN1bGF0ZSBwb3NpdGlvbnMgb2YgYml0bWFwIGJsb2NrIHRvIGJlIGZsdXNoZWQKLQkJKiogLSBwb2ludGVyIG9mIGJpdG1hcCBibG9jayBpbiBtZW1vcnkKLQkJKiogLSBvZmZzZXQgIG9mIGJpdG1hcCBibG9jayBpbiBjb3dmaWxlCi0JCSovCi0JCXRtcHB0ciAgICA9ICooY293ZGV2LT5tYXBjYWNoZSttYXBudW0pICsgKG1hcGJ5dGUgJiAofk1VTUFTSykpOwotCQl0bXBvZmZzZXQgPSAobG9mZl90KSBNQVBVTklUICsgbWFwbnVtICogTUFQQ0hVTktTWiArCi0JCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChtYXBieXRlICYgKH5NVU1BU0spKTsKLQotCQkvKgotCQkqKiBmbHVzaCBhIGJpdG1hcCBibG9jayBhdCB0aGUgbW9tZW50IHRoYXQgYWxsIGJpdHMgaGF2ZQotCQkqKiBiZWVuIHNldCBpbiB0aGF0IGJsb2NrLCBpLmUuIGF0IHRoZSBtb21lbnQgdGhhdCB3ZQotCQkqKiBzd2l0Y2ggdG8gYW5vdGhlciBiaXRtYXAgYmxvY2sKLQkJKi8KLQkJaWYgKCAobWFwb2Zmc2V0ICE9IDApICYmIChtYXBvZmZzZXQgIT0gdG1wb2Zmc2V0KSApIHsKLQkJCWlmIChjb3dsb193cml0ZWNvd3Jhdyhjb3dkZXYsIG1hcHB0ciwgTUFQVU5JVCwKLQkJCQkJCQltYXBvZmZzZXQpIDwgMCkgewotCQkJCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJCQkgICAgICAgImNvd2xvb3AgLSB3cml0ZS1mYWlsdXJlIG9uIGJpdG1hcCAtICIKLQkJCQkgICAgICAgImJsaz0lbGQgbWFwPSVsZCBieXRlPSVsZCBiaXQ9JWxkXG4iLAotCQkJCSAgCWNvd2Jsb2NrLCBtYXBudW0sIG1hcGJ5dGUsIG1hcGJpdCk7Ci0JCQl9Ci0KLQkJCURFQlVHUChEQ09XImNvd2xvb3AgLSBiaXRtYXAgYmxrIHdyaXR0ZW4gJWxsZFxuIiwKLQkJCQkJCQkJbWFwb2Zmc2V0KTsKLQkJfQotCi0JCS8qCi0JCSoqIHJlbWVtYmVyIG9mZnNldCBpbiBjb3dmaWxlIGFuZCBvZmZzZXQgaW4gbWVtb3J5Ci0JCSoqIGZvciBiaXRtYXAgdG8gYmUgZmx1c2hlZDsgZmx1c2hpbmcgd2lsbCBiZSBkb25lCi0JCSoqIGFzIHNvb24gYXMgYWxsIHVwZGF0ZXMgaW4gdGhpcyBiaXRtYXAgYmxvY2sgaGF2ZQotCQkqKiBiZWVuIGRvbmUKLQkJKi8KLQkJbWFwb2Zmc2V0ID0gdG1wb2Zmc2V0OwotCQltYXBwdHIgICAgPSB0bXBwdHI7Ci0JfQotCi0JLyoKLQkqKiBhbnkgbmV3IGJsb2NrIHdyaXR0ZW4gY29udGFpbmluZyBiaW5hcnkgemVyb2VzPwotCSovCi0JaWYgKG1hcG9mZnNldCkgewotCQlpZiAoY293bG9fd3JpdGVjb3dyYXcoY293ZGV2LCBtYXBwdHIsIE1BUFVOSVQsIG1hcG9mZnNldCkgPCAwKSB7Ci0JCQlwcmludGsoS0VSTl9XQVJOSU5HCi0JCQkgICAgICAgImNvd2xvb3AgLSB3cml0ZS1mYWlsdXJlIG9uIGJpdG1hcCAtICIKLQkJCSAgICAgICAiYmxrPSVsZCBtYXA9JWxkIGJ5dGU9JWxkIGJpdD0lbGRcbiIsCi0JCQkgICAgICAgY293YmxvY2ssIG1hcG51bSwgbWFwYnl0ZSwgbWFwYml0KTsKLQkJfQotCi0JCURFQlVHUChEQ09XImNvd2xvb3AgLSBiaXRtYXAgYmxvY2sgd3JpdHRlbiAlbGxkXG4iLCBtYXBvZmZzZXQpOwotCX0KLQotCXJldHVybiBydjsKLX0KLQotLyoKLSoqIHdyaXRlIGNvd2ZpbGUgZnJvbSBhbiBhYnNvbHV0ZSBvZmZzZXQKLSoqCi0qKiByZXR1cm4tdmFsdWU6IHNpbWlsYXIgdG8gdXNlci1tb2RlIHdyaXRlCi0qLwotc3RhdGljIGxvbmcgaW50Ci1jb3dsb193cml0ZWNvd3JhdyhzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKmNvd2RldiwKLQkJCQkJdm9pZCAqYnVmLCBpbnQgbGVuLCBsb2ZmX3Qgb2Zmc2V0KQotewotCWxvbmcgaW50CXJ2OwotCW1tX3NlZ21lbnRfdAlvbGRfZnM7Ci0JbG9mZl90CQlzYXZlb2Zmc2V0ID0gb2Zmc2V0OwotCi0JREVCVUdQKERDT1ciY293bG9vcCAtIHdyaXRlY293cmF3IGNhbGxlZFxuIik7Ci0KLQkvKgotCSoqIGJlIHN1cmUgdGhhdCBjb3dmaWxlIGlzIG9wZW5lZCBmb3IgcmVhZC13cml0ZQotCSovCi0JaWYgKCAhKGNvd2Rldi0+c3RhdGUgJiBDT1dSV0NPV09QRU4pICkgewotCQkgcHJpbnRrKEtFUk5fV0FSTklORwotCQkgICAgICAgICJjb3dsb29wIC0gd3JpdGUgcmVxdWVzdCB0byBjb3dmaWxlIHJlZnVzZWRcbiIpOwotCi0JCXJldHVybiAtRUJBREY7Ci0JfQotCi0JLyoKLQkqKiBpc3N1ZSBsb3cgbGV2ZWwgd3JpdGUKLQkqLwotICAgICAgICBvbGRfZnMgPSBnZXRfZnMoKTsKLQlzZXRfZnMoIGdldF9kcygpICk7Ci0JcnYgPSBjb3dkZXYtPmNvd2ZwLT5mX29wLT53cml0ZShjb3dkZXYtPmNvd2ZwLCBidWYsIGxlbiwgJm9mZnNldCk7Ci0gICAgICAgIHNldF9mcyhvbGRfZnMpOwotCi0JaWYgKHJ2IDwgbGVuKSB7Ci0JCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJICAgICAgICJjb3dsb29wIC0gd3JpdGUtZmFpbHVyZSAlbGQgb24gY293ZmlsZSIKLQkJICAgICAgICItIG9mZnNldD0lbGxkIGxlbj0lZFxuIiwgcnYsIHNhdmVvZmZzZXQsIGxlbik7Ci0JfQotCi0JY293ZGV2LT5jb3d3cml0ZXMrKzsKLQlyZXR1cm4gcnY7Ci19Ci0KLQotLyoKLSoqIHJlYWRwcm9jLWZ1bmN0aW9uOiBjYWxsZWQgd2hlbiB0aGUgY29ycmVzcG9uZGluZyAvcHJvYy1maWxlIGlzIHJlYWQKLSovCi1zdGF0aWMgaW50Ci1jb3dsb19yZWFkcHJvYyhjaGFyICpidWYsIGNoYXIgKipzdGFydCwgb2ZmX3QgcG9zLCBpbnQgY250LCBpbnQgKmVvZiwgdm9pZCAqcCkKLXsKLQlzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKmNvd2RldiA9IHA7Ci0KLQlyZXZpc2lvbltzaXplb2YgcmV2aXNpb24gLSAzXSA9ICdcMCc7Ci0KLQlyZXR1cm4gc3ByaW50ZihidWYsCi0JCSIgICBjb3dsb29wIHZlcnNpb246ICU5c1xuXG4iCi0JCSIgICAgICBkZXZpY2Ugc3RhdGU6ICVzJXMlcyVzXG4iCi0JCSIgICBudW1iZXIgb2Ygb3BlbnM6ICU5ZFxuIgotCQkiICAgICBwaWQgb2YgdGhyZWFkOiAlOWRcblxuIgotCQkiICAgIHJlYWQtb25seSBmaWxlOiAlOXNcbiIKLQkJIiAgICAgICAgICByZG9yZWFkczogJTlsdVxuXG4iCi0JCSJjb3B5LW9uLXdyaXRlIGZpbGU6ICU5c1xuIgotCQkiICAgICBzdGF0ZSBjb3dmaWxlOiAlOXNcbiIKLQkJIiAgICAgYml0bWFwLWJsb2NrczogJTlsdSAob2YgJWQgYnl0ZXMpXG4iCi0JCSIgIGNvd2Jsb2NrcyBpbiB1c2U6ICU5bHUgKG9mICVkIGJ5dGVzKVxuIgotCQkiICAgICAgICAgIGNvd3JlYWRzOiAlOWx1XG4iCi0JCSIgICAgICAgICBjb3d3cml0ZXM6ICU5bHVcbiIsCi0JCQkmcmV2aXNpb25bMTFdLAotCi0JCQljb3dkZXYtPnN0YXRlICYgQ09XREVWT1BFTiAgID8gImRldm9wZW4gIiAgIDogIiIsCi0JCQljb3dkZXYtPnN0YXRlICYgQ09XUldDT1dPUEVOID8gImNvd29wZW5ydyAiIDogIiIsCi0JCQljb3dkZXYtPnN0YXRlICYgQ09XUkRDT1dPUEVOID8gImNvd29wZW5ybyAiIDogIiIsCi0JCQljb3dkZXYtPnN0YXRlICYgQ09XV0FUQ0hET0cgID8gIndhdGNoZG9nICIgIDogIiIsCi0KLQkJCWNvd2Rldi0+b3BlbmNudCwKLQkJCWNvd2Rldi0+cGlkLAotCQkJY293ZGV2LT5yZG9uYW1lLAotCQkJY293ZGV2LT5yZG9yZWFkcywKLQkJCWNvd2Rldi0+Y293bmFtZSwKLQkJCWNvd2Rldi0+Y293aGVhZC0+ZmxhZ3MgJiBDT1dESVJUWSA/ICJkaXJ0eSI6ImNsZWFuIiwKLQkJCWNvd2Rldi0+bWFwc2l6ZSA+PiBNVVNISUZULCBNQVBVTklULAotCQkJY293ZGV2LT5ucmNvd2Jsb2NrcywgTUFQVU5JVCwKLQkJCWNvd2Rldi0+Y293cmVhZHMsCi0JCQljb3dkZXYtPmNvd3dyaXRlcyk7Ci19Ci0KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLS8qIFNldHVwIGFuZCBkZXN0cm95IGNvd2RldmljZXMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KLS8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLQotLyoKLSoqIG9wZW4gYW5kIHByZXBhcmUgYSBjb3dkZXZpY2UgKHJkb2ZpbGUgYW5kIGNvd2ZpbGUpIGFuZCBhbGxvY2F0ZSBiaXRtYXBzCi0qKgotKiogcmV0dXJuczoKLSoqIAkwICAgLSBva2F5Ci0qKiAgICA8IDAgICAtIGVycm9yIHZhbHVlCi0qLwotc3RhdGljIGludAotY293bG9fb3BlbnBhaXIoY2hhciAqcmRvZiwgY2hhciAqY293ZiwgaW50IGF1dG9yZWNvdmVyLCBpbnQgbWlub3IpCi17Ci0JbG9uZyBpbnQJCXJ2OwotCXN0cnVjdCBjb3dsb29wX2RldmljZQkqY293ZGV2ID0gY293ZGV2YWxsW21pbm9yXTsKLQlzdHJ1Y3Qga3N0YXRmcwkJa3M7Ci0KLQlkb3duKCZjb3dkZXZsb2NrKTsKLQotCS8qCi0JKiogcmVxdWVzdGVkIGRldmljZSBleGlzdHM/Ci0JKi8KLQlpZiAobWlub3IgPj0gbWF4Y293cykgewotCQl1cCgmY293ZGV2bG9jayk7Ci0JCXJldHVybiAtRU5PREVWOwotCX0KLQotCS8qCi0JKiogcmVxdWVzdGVkIGRldmljZSBhbHJlYWR5IGFzc2lnbmVkIHRvIGNvd2RldmljZT8KLQkqLwotCWlmIChjb3dkZXYtPnN0YXRlICYgQ09XREVWT1BFTikgewotCQl1cCgmY293ZGV2bG9jayk7Ci0JCXJldHVybiAtRUJVU1k7Ci0JfQotCi0JLyoKLQkqKiBpbml0aWFsaXplIGFkbWluaXN0cmF0aW9uCi0JKi8KLQltZW1zZXQoY293ZGV2LCAwLCBzaXplb2YgKmNvd2Rldik7Ci0KLQlzcGluX2xvY2tfaW5pdCAgICAgKCZjb3dkZXYtPnJxbG9jayk7Ci0JaW5pdF93YWl0cXVldWVfaGVhZCgmY293ZGV2LT53YWl0cSk7Ci0JaW5pdF93YWl0cXVldWVfaGVhZCgmY293ZGV2LT53YXRjaHEpOwotCi0JLyoKLQkqKiBvcGVuIHRoZSByZWFkLW9ubHkgZmlsZQotCSovCi0JREVCVUdQKERDT1ciY293bG9vcCAtIGNhbGwgb3BlbnJkby4uLi5cbiIpOwotCi0JaWYgKCAocnYgPSBjb3dsb19vcGVucmRvKGNvd2RldiwgcmRvZikpICkgewotCQljb3dsb191bmRvX29wZW5yZG8oY293ZGV2KTsKLQkJdXAoJmNvd2RldmxvY2spOwotCQlyZXR1cm4gcnY7Ci0JfQotCi0JLyoKLQkqKiBvcGVuIHRoZSBjb3dmaWxlCi0JKi8KLQlERUJVR1AoRENPVyJjb3dsb29wIC0gY2FsbCBvcGVuY293Li4uLlxuIik7Ci0KLQlpZiAoIChydiA9IGNvd2xvX29wZW5jb3coY293ZGV2LCBjb3dmLCBhdXRvcmVjb3ZlcikpICkgewotCQljb3dsb191bmRvX29wZW5yZG8oY293ZGV2KTsKLQkJY293bG9fdW5kb19vcGVuY293KGNvd2Rldik7Ci0JCXVwKCZjb3dkZXZsb2NrKTsKLQkJcmV0dXJuIHJ2OwotCX0KLQotCS8qCi0JKiogYWRtaW5pc3RlciB0b3RhbCBhbmQgYXZhaWxhYmxlIHNpemUgb2YgZmlsZXN5c3RlbSBob2xkaW5nIGNvd2ZpbGUKLQkqLwotCWlmICh2ZnNfc3RhdGZzKGNvd2Rldi0+Y293ZnAtPmZfZGVudHJ5LCAma3MpPT0wKSB7Ci0JCWNvd2Rldi0+Ymxrc2l6ZSAgPSBrcy5mX2JzaXplOwotCQljb3dkZXYtPmJsa3RvdGFsID0ga3MuZl9ibG9ja3M7Ci0JCWNvd2Rldi0+YmxrYXZhaWwgPSBrcy5mX2JhdmFpbDsKLQl9IGVsc2UgewotCQljb3dkZXYtPmJsa3NpemUgID0gMTAyNDsJLyogYXZvaWQgZGl2aXNpb24gYnkgemVybyAqLwotCX0KLQotCS8qCi0JKiogZmx1c2ggdGhlIChyZWNvdmVyZWQpIGJpdG1hcHMgYW5kIGNvd2hlYWQgdG8gdGhlIGNvd2ZpbGUKLQkqLwotCURFQlVHUChEQ09XImNvd2xvb3AgLSBjYWxsIGNvd3N5bmMuLi4uXG4iKTsKLQotCWNvd2xvX3N5bmMoKTsKLQotCS8qCi0JKiogYWxsb2NhdGUgZ2VuZGlzayBmb3IgdGhlIGNvdyBkZXZpY2UKLQkqLwotCURFQlVHUChEQ09XImNvd2xvb3AgLSBhbGxvYyBkaXNrLi4uLlxuIik7Ci0KLQlpZiAoKGNvd2Rldi0+Z2QgPSBhbGxvY19kaXNrKDEpKSA9PSBOVUxMKSB7Ci0JCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJICAgICAgICJjb3dsb29wIC0gdW5hYmxlIHRvIGFsbG9jX2Rpc2sgZm9yIGNvd2xvb3BcbiIpOwotCi0JCWNvd2xvX3VuZG9fb3BlbnJkbyhjb3dkZXYpOwotCQljb3dsb191bmRvX29wZW5jb3coY293ZGV2KTsKLQkJdXAoJmNvd2RldmxvY2spOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0KLQljb3dkZXYtPmdkLT5tYWpvciAgICAgICAgPSBDT1dNQUpPUjsKLQljb3dkZXYtPmdkLT5maXJzdF9taW5vciAgPSBtaW5vcjsKLQljb3dkZXYtPmdkLT5taW5vcnMgICAgICAgPSAxOwotCWNvd2Rldi0+Z2QtPmZvcHMgICAgICAgICA9ICZjb3dsb19mb3BzOwotCWNvd2Rldi0+Z2QtPnByaXZhdGVfZGF0YSA9IGNvd2RldjsKLQlzcHJpbnRmKGNvd2Rldi0+Z2QtPmRpc2tfbmFtZSwgIiVzJWQiLCBERVZJQ0VfTkFNRSwgbWlub3IpOwotCi0JLyogaW4gLjUgS2IgdW5pdHMgKi8KLQlzZXRfY2FwYWNpdHkoY293ZGV2LT5nZCwgKGNvd2Rldi0+bnVtYmxvY2tzKihNQVBVTklULzUxMikpKTsKLQotCURFQlVHUChEQ09XImNvd2xvb3AgLSBpbml0IHJlcXVlc3QgcXVldWUuLi4uXG4iKTsKLQotCWlmICgoY293ZGV2LT5ycXVldWUgPSBibGtfaW5pdF9xdWV1ZShjb3dsb19yZXF1ZXN0LCAmY293ZGV2LT5ycWxvY2spKQotCQkJCQkJCQk9PSBOVUxMKSB7Ci0JCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJICAgICAgICJjb3dsb29wIC0gdW5hYmxlIHRvIGdldCByZXF1ZXN0IHF1ZXVlIGZvciBjb3dsb29wXG4iKTsKLQotCQlkZWxfZ2VuZGlzayhjb3dkZXYtPmdkKTsKLQkJY293bG9fdW5kb19vcGVucmRvKGNvd2Rldik7Ci0JCWNvd2xvX3VuZG9fb3BlbmNvdyhjb3dkZXYpOwotCQl1cCgmY293ZGV2bG9jayk7Ci0JCXJldHVybiAtRUlOVkFMOwotCX0KLQotCWJsa19xdWV1ZV9sb2dpY2FsX2Jsb2NrX3NpemUoY293ZGV2LT5ycXVldWUsIGNvd2Rldi0+YmxvY2tzeik7Ci0JY293ZGV2LT5nZC0+cXVldWUgPSBjb3dkZXYtPnJxdWV1ZTsKLQotCS8qCi0JKiogc3RhcnQga2VybmVsIHRocmVhZCB0byBoYW5kbGUgcmVxdWVzdHMKLQkqLwotCURFQlVHUChEQ09XImNvd2xvb3AgLSBraWNrb2ZmIGRhZW1vbi4uLi5cbiIpOwotCi0JY293ZGV2LT5waWQgPSBrZXJuZWxfdGhyZWFkKChpbnQgKCopKHZvaWQgKikpY293bG9fZGFlbW9uLCBjb3dkZXYsIDApOwotCi0JLyoKLQkqKiBjcmVhdGUgYSBmaWxlIGJlbG93IGRpcmVjdG9yeSAvcHJvYy9jb3cgZm9yIHRoaXMgbmV3IGNvd2RldmljZQotCSovCi0JaWYgKGNvd2xvX3Byb2NkaXIpIHsKLQkJY2hhciAJdG1wbmFtZVs2NF07Ci0KLQkJc3ByaW50Zih0bXBuYW1lLCAiJWQiLCBtaW5vcik7Ci0KLQkJY3JlYXRlX3Byb2NfcmVhZF9lbnRyeSh0bXBuYW1lLCAwICwgY293bG9fcHJvY2RpciwKLQkJCQkJCWNvd2xvX3JlYWRwcm9jLCBjb3dkZXYpOwotCX0KLQotCWNvd2Rldi0+c3RhdGUJfD0gQ09XREVWT1BFTjsKLQotCWNvd2Rldi0+cmRvbmFtZSA9IHJkb2Y7Ci0JY293ZGV2LT5jb3duYW1lID0gY293ZjsKLQotCS8qCi0JKiogZW5hYmxlIHRoZSBuZXcgZGlzazsgdGhpcyB0cmlnZ2VycyB0aGUgZmlyc3QgcmVxdWVzdCEKLQkqLwotCURFQlVHUChEQ09XImNvd2xvb3AgLSBjYWxsIGFkZF9kaXNrLi4uLlxuIik7Ci0KLQlhZGRfZGlzayhjb3dkZXYtPmdkKTsKLQotCXVwKCZjb3dkZXZsb2NrKTsKLQlyZXR1cm4gMDsKLX0KLQotLyoKLSoqIGNsb3NlIGEgY293ZGV2aWNlIChwYWlyIG9mIHJkb2ZpbGUvY293ZmlsZSkgYW5kIHJlbGVhc2UgbWVtb3J5Ci0qKgotKiogcmV0dXJuczoKLSoqIAkwICAgLSBva2F5Ci0qKiAgICA8IDAgICAtIGVycm9yIHZhbHVlCi0qLwotc3RhdGljIGludAotY293bG9fY2xvc2VwYWlyKHN0cnVjdCBjb3dsb29wX2RldmljZSAqY293ZGV2KQotewotCWludCBtaW5vcjsKLQotCWRvd24oJmNvd2RldmxvY2spOwotCi0JLyoKLQkqKiBpZiBjb3dkZXZpY2UgaXMgbm90IGFjdGl2YXRlZCBhdCBhbGwsIHJlZnVzZQotCSovCi0JaWYgKCAhKGNvd2Rldi0+c3RhdGUgJiBDT1dERVZPUEVOKSApIHsKLQkJdXAoJmNvd2RldmxvY2spOwotCQlyZXR1cm4gLUVOT0RFVjsKLQl9Ci0KLQkvKgotCSoqIGlmIHRoaXMgY293ZGV2aWNlIGlzIHN0aWxsIG9wZW4sIHJlZnVzZQotCSovCi0JaWYgKGNvd2Rldi0+b3BlbmNudCA+IDApIHsKLQkJdXAoJmNvd2RldmxvY2spOwotCQlyZXR1cm4gLUVCVVNZOwotCX0KLQotCXVwKCZjb3dkZXZsb2NrKTsKLQotCS8qCi0JKiogd2FrZXVwIHdhdGNoZXIgKGlmIGFueSkKLQkqLwotCWlmIChjb3dkZXYtPnN0YXRlICYgQ09XV0FUQ0hET0cpIHsKLQkJY293ZGV2LT53YXRjaHRocmVzaCA9IGNvd2Rldi0+YmxrYXZhaWw7Ci0JCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmY293ZGV2LT53YXRjaHEpOwotCX0KLQotCS8qCi0JKiogd2FrZXVwIGtlcm5lbC10aHJlYWQgdG8gYmUgYWJsZSB0byBleGl0Ci0JKiogYW5kIHdhaXQgdW50aWwgaXQgaGFzIGV4aXRlZAotCSovCi0JY293ZGV2LT5jbG9zZWRvd24gPSAxOwotCWNvd2Rldi0+cWZpbGxlZCAgID0gMTsKLQl3YWtlX3VwX2ludGVycnVwdGlibGUoJmNvd2Rldi0+d2FpdHEpOwotCi0gICAgICAgCXdoaWxlIChjb3dkZXYtPnBpZCkKLSAgICAgICAgICAgICAgIAlzY2hlZHVsZSgpOwotCi0JZGVsX2dlbmRpc2soY293ZGV2LT5nZCk7ICAvKiByZXZlcnQgdGhlIGFsbG9jX2Rpc2soKSAqLwotCXB1dF9kaXNrKGNvd2Rldi0+Z2QpOyAgICAgLyogcmV2ZXJ0IHRoZSBhZGRfZGlzaygpICAgKi8KLQotCWlmIChjb3dsb19wcm9jZGlyKSB7Ci0JCWNoYXIgCXRtcG5hbWVbNjRdOwotCi0JCWZvciAobWlub3IgPSAwOyBtaW5vciA8IG1heGNvd3M7IG1pbm9yKyspIHsKLQkJCWlmIChjb3dkZXYgPT0gY293ZGV2YWxsW21pbm9yXSkgYnJlYWs7Ci0JCX0KLQkJc3ByaW50Zih0bXBuYW1lLCAiJWQiLCBtaW5vcik7Ci0KLQkJcmVtb3ZlX3Byb2NfZW50cnkodG1wbmFtZSwgY293bG9fcHJvY2Rpcik7Ci0JfQotCi0JYmxrX2NsZWFudXBfcXVldWUoY293ZGV2LT5ycXVldWUpOwotCi0JLyoKLQkqKiByZWxlYXNlIG1lbW9yeSBmb3IgZmlsZW5hbWVzIGlmIHRoZXNlIG5hbWVzIGhhdmUKLQkqKiBiZWVuIGFsbG9jYXRlZCBkeW5hbWljYWxseQotCSovCi0JaWYgKCAoY293ZGV2LT5jb3duYW1lKSAmJiAoY293ZGV2LT5jb3duYW1lICE9IGNvd2ZpbGUpKQotCQlrZnJlZShjb3dkZXYtPmNvd25hbWUpOwotCi0JaWYgKCAoY293ZGV2LT5yZG9uYW1lKSAmJiAoY293ZGV2LT5yZG9uYW1lICE9IHJkb2ZpbGUpKQotCQlrZnJlZShjb3dkZXYtPnJkb25hbWUpOwotCi0JY293bG9fdW5kb19vcGVucmRvKGNvd2Rldik7Ci0JY293bG9fdW5kb19vcGVuY293KGNvd2Rldik7Ci0KLQljb3dkZXYtPnN0YXRlICY9IH5DT1dERVZPUEVOOwotCi0JcmV0dXJuIDA7Ci19Ci0KLS8qCi0qKiBvcGVuIHRoZSByZWFkLW9ubHkgZmlsZQotKioKLSoqIHJldHVybnM6Ci0qKiAJMCAgIC0gb2theQotKiogICAgPCAwICAgLSBlcnJvciB2YWx1ZQotKi8KLXN0YXRpYyBpbnQKLWNvd2xvX29wZW5yZG8oc3RydWN0IGNvd2xvb3BfZGV2aWNlICpjb3dkZXYsIGNoYXIgKnJkb2YpCi17Ci0Jc3RydWN0IGZpbGUJKmY7Ci0Jc3RydWN0IGlub2RlCSppbm9kZTsKLQlsb25nIGludAlpLCBucnZhbDsKLQotCURFQlVHUChEQ09XImNvd2xvb3AgLSBvcGVucmRvIGNhbGxlZFxuIik7Ci0KLQkvKgotCSoqIG9wZW4gdGhlIHJlYWQtb25seSBmaWxlCi0JKi8KLSAgICAgICAgaWYoKnJkb2YgPT0gJ1wwJykgewotICAgICAJICAgICAJcHJpbnRrKEtFUk5fRVJSCi0JCSAgICAgICAiY293bG9vcCAtIHNwZWNpZnkgbmFtZSBmb3IgcmVhZC1vbmx5IGZpbGVcblxuIik7Ci0gICAgICAgICAJcmV0dXJuIC1FSU5WQUw7Ci0gICAgICAgIH0KLQotCWYgPSBmaWxwX29wZW4ocmRvZiwgT19SRE9OTFl8T19MQVJHRUZJTEUsIDApOwotCi0JaWYgKCAoZiA9PSBOVUxMKSB8fCBJU19FUlIoZikgKSB7Ci0JCXByaW50ayhLRVJOX0VSUgotCQkgICAgICAgImNvd2xvb3AgLSBvcGVuIG9mIHJkb2ZpbGUgJXMgZmFpbGVkXG4iLCByZG9mKTsKLQkJcmV0dXJuIC1FSU5WQUw7Ci0JfQotCi0JY293ZGV2LT5yZG9mcCA9IGY7Ci0KLQlpbm9kZSA9IGYtPmZfZGVudHJ5LT5kX2lub2RlOwotCi0JaWYgKCAhU19JU1JFRyhpbm9kZS0+aV9tb2RlKSAmJiAhU19JU0JMSyhpbm9kZS0+aV9tb2RlKSApIHsKLQkJcHJpbnRrKEtFUk5fRVJSCi0JCSAgICAgICAiY293bG9vcCAtICVzIG5vdCByZWd1bGFyIGZpbGUgb3IgYmxvY2tkZXZcbiIsIHJkb2YpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlERUJVR1AoRENPVyJjb3dsb29wIC0gZGV0ZXJtaW5lIHNpemUgcmRvLi4uLlxuIik7Ci0KLQkvKgotCSoqIGRldGVybWluZSBibG9jay1zaXplIGFuZCB0b3RhbCBzaXplIG9mIHJlYWQtb25seSBmaWxlCi0JKi8KLQlpZiAoU19JU1JFRyhpbm9kZS0+aV9tb2RlKSkgewotCQkvKgotCQkqKiByZWFkLW9ubHkgZmlsZSBpcyBhIHJlZ3VsYXIgZmlsZQotCQkqLwotCQljb3dkZXYtPmJsb2Nrc3ogICA9IDUxMjsJLyogb3RoZXIgdmFsdWUgZmFpbHMgKi8KLQkJY293ZGV2LT5udW1ibG9ja3MgPSBpbm9kZS0+aV9zaXplID4+IE1VU0hJRlQ7Ci0KLQkJaWYgKGlub2RlLT5pX3NpemUgJiBNVU1BU0spIHsKLQkJCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJCSAgICAgICAiY293bG9vcCAtIHJkb2ZpbGUgJXMgdHJ1bmNhdGVkIHRvIG11bHRpcGxlICIKLQkJCSAgICAgICAib2YgJWQgYnl0ZXNcbiIsIHJkb2YsIE1BUFVOSVQpOwotCQl9Ci0KLQkJREVCVUdQKERDT1ciY293bG9vcCAtIFJPPXJlZ3VsYXI6IG51bWJsb2Nrcz0lZCwgYmxvY2tzej0lZFxuIiwKLQkJCWNvd2Rldi0+bnVtYmxvY2tzLCBjb3dkZXYtPmJsb2Nrc3opOwotCX0gZWxzZSB7Ci0JCS8qCi0JCSoqIHJlYWQtb25seSBmaWxlIGlzIGEgYmxvY2sgZGV2aWNlCi0JCSovCi0JCWNvd2Rldi0+YmVsb3dkZXYgID0gaW5vZGUtPmlfYmRldjsKLQkJY293ZGV2LT5iZWxvd2dkICAgPSBjb3dkZXYtPmJlbG93ZGV2LT5iZF9kaXNrOyAvKiBnZW5kaXNrICovCi0KLQkJaWYgKGNvd2Rldi0+YmVsb3dkZXYtPmJkX3BhcnQpIHsKLQkJCWNvd2Rldi0+bnVtYmxvY2tzID0gY293ZGV2LT5iZWxvd2Rldi0+YmRfcGFydC0+bnJfc2VjdHMKLQkJCQkJCQkJLyAoTUFQVU5JVC81MTIpOwotCQl9Ci0KLQkJaWYgKGNvd2Rldi0+YmVsb3dnZCkgewotCQkJY293ZGV2LT5iZWxvd3EgPSBjb3dkZXYtPmJlbG93Z2QtPnF1ZXVlOwotCi0JCQlpZiAoY293ZGV2LT5udW1ibG9ja3MgPT0gMCkgewotCQkJCWNvd2Rldi0+bnVtYmxvY2tzID0gZ2V0X2NhcGFjaXR5KGNvd2Rldi0+YmVsb3dnZCkKLSAgICAgICAgICAgICAgICAgICAgICAgICAJCQkJCS8gKE1BUFVOSVQvNTEyKTsKLQkJCX0KLQkJfQotCi0KLQkJaWYgKGNvd2Rldi0+YmVsb3dxKQotCQkJY293ZGV2LT5ibG9ja3N6ID0gcXVldWVfbG9naWNhbF9ibG9ja19zaXplKGNvd2Rldi0+YmVsb3dxKTsKLQotCQlpZiAoY293ZGV2LT5ibG9ja3N6ID09IDApCi0JCQljb3dkZXYtPmJsb2Nrc3ogPSBCTE9DS19TSVpFOyAvKiBkZWZhdWx0IDJeMTAgKi8KLQotCQlERUJVR1AoRENPVyJjb3dsb29wIC0gbnVtYmxvY2tzPSVkLCAiCi0JCSAgICAgICAgICAgImJsb2Nrc3o9JWQsIGJlbG93Z2Q9JXAsIGJlbG93cT0lcFxuIiwKLQkJICAJY293ZGV2LT5udW1ibG9ja3MsIGNvd2Rldi0+YmxvY2tzeiwKLQkJCWNvd2Rldi0+YmVsb3dnZCwgY293ZGV2LT5iZWxvd3EpOwotCi0JCURFQlVHUChEQ09XImNvd2xvb3AgLSBiZWxvd2Rldi5iZF9ibG9ja19zaXplPSVkXG4iLAotCQkgIAljb3dkZXYtPmJlbG93ZGV2LT5iZF9ibG9ja19zaXplKTsKLQl9Ci0KLQlpZiAoY293ZGV2LT5udW1ibG9ja3MgPT0gMCkgewotCQlwcmludGsoS0VSTl9FUlIgImNvd2xvb3AgLSAlcyBoYXMgbm8gY29udGVudHNcbiIsIHJkb2YpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQkvKgotCSoqIHJlc2VydmUgc3BhY2UgaW4gbWVtb3J5IGFzIGdlbmVyaWMgSS9PIGJ1ZmZlcgotCSovCi0JY293ZGV2LT5pb2J1ZiAgPSBrbWFsbG9jKE1BUFVOSVQsIEdGUF9LRVJORUwpOwotCi0JaWYgKCFjb3dkZXYtPmlvYnVmKSB7Ci0JCXByaW50ayhLRVJOX0VSUgotCQkgICAgICAgImNvd2xvb3AgLSBjYW5ub3QgZ2V0IHNwYWNlIGZvciBidWZmZXIgJWRcbiIsIE1BUFVOSVQpOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0KLQlERUJVR1AoRENPVyJjb3dsb29wIC0gZGV0ZXJtaW5lIGZpbmdlcnByaW50IHJkby4uLi5cbiIpOwotCi0JLyoKLQkqKiBkZXRlcm1pbmUgZmluZ2VycHJpbnQgZm9yIHJlYWQtb25seSBmaWxlCi0JKiogCWNhbGN1bGF0ZSBmaW5nZXJwcmludCBmcm9tIGZpcnN0IGZvdXIgZGF0YWJsb2NrcwotCSoqCXdoaWNoIGRvIG5vdCBjb250YWluIGJpbmFyeSB6ZXJvZXMKLQkqLwotCWZvciAoaT0wLCBjb3dkZXYtPmZpbmdlcnByaW50PTAsIG5ydmFsPTA7Ci0JCQkobnJ2YWwgPCA0KSYmKGkgPCBjb3dkZXYtPm51bWJsb2Nrcyk7IGkrKykgewotCQlpbnQgCQlqOwotCQl1bnNpZ25lZCBjaGFyCWNzOwotCi0JCS8qCi0JCSoqIHJlYWQgbmV4dCBibG9jawotCQkqLwotCQlpZiAoY293bG9fcmVhZHJkbyhjb3dkZXYsIGNvd2Rldi0+aW9idWYsIE1BUFVOSVQsCi0JCQkJCQkobG9mZl90KWkgPDwgTVVTSElGVCkgPCAxKQotCQkJYnJlYWs7Ci0KLQkJLyoKLQkJKiogY2FsY3VsYXRlIGZpbmdlcnByaW50IGJ5IGFkZGluZyBhbGwgYnl0ZS12YWx1ZXMKLQkJKi8KLQkJZm9yIChqPTAsIGNzPTA7IGogPCBNQVBVTklUOyBqKyspCi0JCQljcyArPSAqKGNvd2Rldi0+aW9idWYraik7Ci0KLQkJaWYgKGNzID09IDApCS8qIGJsb2NrIHByb2JhYmx5IGNvbnRhaW5lZCB6ZXJvZXMgKi8KLQkJCWNvbnRpbnVlOwotCi0JCS8qCi0JCSoqIHNoaWZ0IGJ5dGUtdmFsdWUgdG8gcHJvcGVyIHBsYWNlIGluIGZpbmFsIGZpbmdlcnByaW50Ci0JCSovCi0JCWNvd2Rldi0+ZmluZ2VycHJpbnQgfD0gY3MgPDwgKG5ydmFsKjgpOwotCQlucnZhbCsrOwotCX0KLQotCXJldHVybiAwOwotfQotCi0vKgotKiogdW5kbyBtZW1vcnkgYWxsb2NzIGFuZCBmaWxlIG9wZW5zIGlzc3VlZCBzbyBmYXIKLSoqIHJlbGF0ZWQgdG8gdGhlIHJlYWQtb25seSBmaWxlCi0qLwotc3RhdGljIHZvaWQKLWNvd2xvX3VuZG9fb3BlbnJkbyhzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKmNvd2RldikKLXsKLQlpZihjb3dkZXYtPmlvYnVmKTsKLQkJa2ZyZWUoY293ZGV2LT5pb2J1Zik7Ci0KLQlpZiAoY293ZGV2LT5yZG9mcCkKLSAgCQlmaWxwX2Nsb3NlKGNvd2Rldi0+cmRvZnAsIDApOwotfQotCi0vKgotKiogb3BlbiB0aGUgY293ZmlsZQotKioKLSoqIHJldHVybnM6Ci0qKiAJMCAgIC0gb2theQotKiogICAgPCAwICAgLSBlcnJvciB2YWx1ZQotKi8KLXN0YXRpYyBpbnQKLWNvd2xvX29wZW5jb3coc3RydWN0IGNvd2xvb3BfZGV2aWNlICpjb3dkZXYsIGNoYXIgKmNvd2YsIGludCBhdXRvcmVjb3ZlcikKLXsKLQlsb25nIGludAkJaSwgcnY7Ci0JaW50CQkJbWlub3I7Ci0JdW5zaWduZWQgbG9uZwkJbmI7Ci0Jc3RydWN0IGZpbGUJCSpmOwotCXN0cnVjdCBpbm9kZQkJKmlub2RlOwotCWxvZmZfdAkJCW9mZnNldDsKLQlzdHJ1Y3QgY293bG9vcF9kZXZpY2UJKmNvd3RtcDsKLQotCURFQlVHUChEQ09XImNvd2xvb3AgLSBvcGVuY293IGNhbGxlZFxuIik7Ci0KLQkvKgotCSoqIG9wZW4gY29weS1vbi13cml0ZSBmaWxlIChyZWFkLXdyaXRlKQotCSovCi0gICAgICAgIGlmIChjb3dmWzBdID09ICdcMCcpIHsKLSAgICAgICAgICAJcHJpbnRrKEtFUk5fRVJSCi0gICAgICAgICAgICAgICAgICJjb3dsb29wIC0gc3BlY2lmeSBuYW1lIG9mIGNvcHktb24td3JpdGUgZmlsZVxuXG4iKTsKLSAgICAgICAgIAlyZXR1cm4gLUVJTlZBTDsKLSAgICAgICAgfQotCi0JZiA9IGZpbHBfb3Blbihjb3dmLCBPX1JEV1J8T19MQVJHRUZJTEUsIDA2MDApOwotCi0JaWYgKCAoZiA9PSBOVUxMKSB8fCBJU19FUlIoZikgKSB7Ci0JCS8qCi0JCSoqIG5vbi1leGlzdGluZyBjb3dmaWxlOiB0cnkgdG8gY3JlYXRlCi0JCSovCi0JCWYgPSBmaWxwX29wZW4oY293ZiwgT19SRFdSfE9fQ1JFQVR8T19MQVJHRUZJTEUsIDA2MDApOwotCi0JCWlmICggKGYgPT0gTlVMTCkgfHwgSVNfRVJSKGYpICkgewotCQkJcHJpbnRrKEtFUk5fRVJSCi0JCSAgICAgICAJICAiY293bG9vcCAtIGZhaWxlZCB0byBvcGVuIGZpbGUgJXMgZm9yIHJlYWQtd3JpdGVcblxuIiwKLQkJICAgICAgIAkJCQkJCWNvd2YpOwotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JIAl9Ci0JfQotCi0JY293ZGV2LT5jb3dmcCA9IGY7Ci0KLQlpbm9kZSA9IGYtPmZfZGVudHJ5LT5kX2lub2RlOwotCi0JaWYgKCFTX0lTUkVHKGlub2RlLT5pX21vZGUpKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiY293bG9vcCAtICVzIGlzIG5vdCByZWd1bGFyIGZpbGVcbiIsIGNvd2YpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQkvKgotCSoqIGNoZWNrIGlmIHRoaXMgY293ZmlsZSBpcyBhbHJlYWR5IGluIHVzZSBmb3IgYW5vdGhlciBjb3dkZXZpY2UKLQkqLwotCWZvciAobWlub3IgPSAwOyBtaW5vciA8IG1heGNvd3M7IG1pbm9yKyspIHsKLQotCQljb3d0bXAgPSBjb3dkZXZhbGxbbWlub3JdOwotCi0JCWlmICggIShjb3d0bXAtPnN0YXRlICYgQ09XREVWT1BFTikgKQotCQkJY29udGludWU7Ci0KLQkJaWYgKGNvd3RtcCA9PSBjb3dkZXYpCi0JCQljb250aW51ZTsKLQotCQlpZiAoY293dG1wLT5jb3dmcC0+Zl9kZW50cnktPmRfaW5vZGUgPT0gZi0+Zl9kZW50cnktPmRfaW5vZGUpIHsKLQkJCXByaW50ayhLRVJOX0VSUgotCQkJICAgICAgICJjb3dsb29wIC0gJXM6IGFscmVhZHkgaW4gdXNlIGFzIGNvd1xuIiwgY293Zik7Ci0JCQlyZXR1cm4gLUVCVVNZOwotCQl9Ci0JfQotCi0JLyoKLQkqKiBtYXJrIGNvd2ZpbGUgb3BlbiBmb3IgcmVhZC13cml0ZQotCSovCi0JY293ZGV2LT5zdGF0ZSB8PSBDT1dSV0NPV09QRU47Ci0KLQkvKgotCSoqIGNhbGN1bGF0ZSBzaXplIChpbiBieXRlcykgZm9yIHRvdGFsIGJpdG1hcCBpbiBjb3dmaWxlOwotCSoqIHdoZW4gdGhlIHNpemUgb2YgdGhlIGNvd2hlYWQgYmxvY2sgaXMgYWRkZWQsIHRoZSBzdGFydC1vZmZzZXQKLQkqKiBmb3IgdGhlIG1vZGlmaWVkIGRhdGEgYmxvY2tzIGNhbiBiZSBmb3VuZAotCSovCi0JbmIgPSBjb3dkZXYtPm51bWJsb2NrczsKLQotCWlmIChuYiU4KQkJLyogdHJhbnNmb3JtICNiaXRzIHRvICNieXRlcyAqLwotCQluYis9ODsgIAkvKiByb3VuZGVkIGlmIG5lY2Vzc2FyeSAgICAgICovCi0JbmIgLz0gODsKLQotCWlmIChuYiAmIE1VTUFTSykJLyogcm91bmQgdXAgI2J5dGVzIHRvIE1BUFVOSVQgY2h1bmtzICovCi0JCWNvd2Rldi0+bWFwc2l6ZSA9ICggKG5iPj5NVVNISUZUKSArMSkgPDwgTVVTSElGVDsKLQllbHNlCi0JCWNvd2Rldi0+bWFwc2l6ZSA9IG5iOwotCi0JLyoKLQkqKiByZXNlcnZlIHNwYWNlIGluIG1lbW9yeSBmb3IgdGhlIGNvd2hlYWQKLQkqLwotCWNvd2Rldi0+Y293aGVhZCA9IGttYWxsb2MoTUFQVU5JVCwgR0ZQX0tFUk5FTCk7Ci0KLQlpZiAoIWNvd2Rldi0+Y293aGVhZCkgewotCQlwcmludGsoS0VSTl9FUlIgImNvd2xvb3AgLSBjYW5ub3QgZ2V0IHNwYWNlIGZvciBjb3doZWFkICVkXG4iLAotCQkJCQkJCQkgICAgIE1BUFVOSVQpOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0KLQltZW1zZXQoY293ZGV2LT5jb3doZWFkLCAwLCBNQVBVTklUKTsKLQotCURFQlVHUChEQ09XImNvd2xvb3AgLSBwcmVwYXJlIGNvd2hlYWQuLi4uXG4iKTsKLQotCS8qCi0JKiogY2hlY2sgaWYgdGhlIGNvd2ZpbGUgZXhpc3RzIG9yIHNob3VsZCBiZSBjcmVhdGVkCi0JKi8KLQlpZiAoaW5vZGUtPmlfc2l6ZSAhPSAwKSB7Ci0JCS8qCi0JCSoqIGV4aXN0aW5nIGNvd2ZpbGU6IHJlYWQgdGhlIGNvdyBoZWFkCi0JCSovCi0JCWlmIChpbm9kZS0+aV9zaXplIDwgTUFQVU5JVCkgewotCQkJcHJpbnRrKEtFUk5fRVJSCi0JCQkgICAgICAgImNvd2xvb3AgLSBleGlzdGluZyBjb3dmaWxlICVzIHRvbyBzbWFsbFxuIiwKLQkJCQljb3dmKTsKLQkJCXJldHVybiAtRUlOVkFMOwotCQl9Ci0KLQkJY293bG9fcmVhZGNvd3Jhdyhjb3dkZXYsIGNvd2Rldi0+Y293aGVhZCwgTUFQVU5JVCwgKGxvZmZfdCkgMCk7Ci0KLQkJLyoKLQkJKiogdmVyaWZ5IGlmIHRoZSBleGlzdGluZyBmaWxlIGlzIHJlYWxseSBhIGNvd2ZpbGUKLQkJKi8KLQkJaWYgKGNvd2Rldi0+Y293aGVhZC0+bWFnaWMgIT0gQ09XTUFHSUMpIHsKLQkJCXByaW50ayhLRVJOX0VSUgotCQkJICAgICAgICJjb3dsb29wIC0gY293ZmlsZSAlcyBoYXMgaW5jb3JyZWN0IGZvcm1hdFxuIiwKLQkJCQljb3dmKTsKLQkJCXJldHVybiAtRUlOVkFMOwotCQl9Ci0KLQkJLyoKLQkJKiogdmVyaWZ5IHRoZSBjb3doZWFkIHZlcnNpb24gb2YgdGhlIGNvd2ZpbGUKLQkJKi8KLQkJaWYgKGNvd2Rldi0+Y293aGVhZC0+dmVyc2lvbiA+IENPV1ZFUlNJT04pIHsKLQkJCXByaW50ayhLRVJOX0VSUgotCQkJICAgICAgICJjb3dsb29wIC0gY293ZmlsZSAlcyBuZXdlciB0aGFuIHRoaXMgZHJpdmVyXG4iLAotCQkJCWNvd2YpOwotCQkJcmV0dXJuIC1FSU5WQUw7Ci0JCX0KLQotCQkvKgotCQkqKiBtYWtlIHN1cmUgdGhhdCB0aGlzIGlzIG5vdCBhIHBhY2tlZCBjb3dmaWxlCi0JCSovCi0JCWlmIChjb3dkZXYtPmNvd2hlYWQtPmZsYWdzICYgQ09XUEFDS0VEKSB7Ci0JCQlwcmludGsoS0VSTl9FUlIKLQkJCSAgICAiY293bG9vcCAtIHBhY2tlZCBjb3dmaWxlICVzIG5vdCBhY2NlcHRlZFxuIiwgY293Zik7Ci0JCQlyZXR1cm4gLUVJTlZBTDsKLQkJfQotCi0JCS8qCi0JCSoqIHZlcmlmeSBpZiB0aGUgY293ZmlsZSBoYXMgYmVlbiBwcm9wZXJseSBjbG9zZWQKLQkJKi8KLQkJaWYgKGNvd2Rldi0+Y293aGVhZC0+ZmxhZ3MgJiBDT1dESVJUWSkgewotCQkJLyoKLQkJCSoqIGNvd2ZpbGUgd2FzIG5vdCBwcm9wZXJseSBjbG9zZWQ7Ci0JCQkqKiBjaGVjayBpZiBhdXRvbWF0aWMgcmVjb3ZlcnkgaXMgcmVxdWlyZWQKLQkJCSoqIChhY3R1YWwgcmVjb3Zlcnkgd2lsbCBiZSBkb25lIGxhdGVyIG9uKQotCQkJKi8KLQkJCWlmICghYXV0b3JlY292ZXIpIHsKLQkJCQlwcmludGsoS0VSTl9FUlIKLQkJCQkgICAgICAgImNvd2xvb3AgLSBjb3dmaWxlICVzIGlzIGRpcnR5ICIKLQkJCQkgICAgICAgIihub3QgcHJvcGVybHkgY2xvc2VkIGJ5IHJtbW9kPylcbiIsCi0JCQkJCWNvd2YpOwotCQkJCXByaW50ayhLRVJOX0VSUgotCQkJCSAgICAgICAiY293bG9vcCAtIHJ1biBjb3dyZXBhaXIgb3Igc3BlY2lmeSAiCi0JCQkJICAgICAgICInb3B0aW9uPXInIHRvIHJlY292ZXJcbiIpOwotCQkJCXJldHVybiAtRUlOVkFMOwotCQkJfQotCQl9Ci0KLQkJLyoKLQkJKiogdmVyaWZ5IGlmIHRoZSBjb3dmaWxlIGlzIHJlYWxseSByZWxhdGVkIHRvIHRoaXMgcmRvZmlsZQotCQkqLwotCQlpZiAoY293ZGV2LT5jb3doZWFkLT5yZG9ibG9ja3MgIT0gY293ZGV2LT5udW1ibG9ja3MpIHsKLQkJCXByaW50ayhLRVJOX0VSUgotCQkgICAgICAgCSAgICAgICAiY293bG9vcCAtIGNvd2ZpbGUgJXMgKHNpemUgJWxsZCkgbm90IHJlbGF0ZWQgIgotCQkgICAgICAgCSAgICAgICAidG8gcmRvZmlsZSAoc2l6ZSAlbGxkKVxuIiwKLQkJCQljb3dmLAotCQkJCShsb25nIGxvbmcpY293ZGV2LT5jb3doZWFkLT5yZG9ibG9ja3MgPDxNVVNISUZULAotCQkJCShsb25nIGxvbmcpY293ZGV2LT5udW1ibG9ja3MgPDxNVVNISUZUKTsKLQkJCXJldHVybiAtRUlOVkFMOwotCQl9Ci0KLQkJaWYgKGNvd2Rldi0+Y293aGVhZC0+cmRvZmluZ2VycHJpbnQgIT0gY293ZGV2LT5maW5nZXJwcmludCkgewotCQkJcHJpbnRrKEtFUk5fRVJSCi0JCSAgICAgICAJICAgICAiY293bG9vcCAtIGNvd2ZpbGUgJXMgbm90IHJlbGF0ZWQgdG8gcmRvZmlsZSAiCi0JCQkgICAgICIgKGZpbmdlcnByaW50IGVyciAtIHJkb2ZpbGUgbW9kaWZpZWQ/KVxuIiwgY293Zik7Ci0JCQlyZXR1cm4gLUVJTlZBTDsKLQkJfQotCX0gZWxzZSB7Ci0JCS8qCi0JCSoqIG5ldyBjb3dmaWxlOiBkZXRlcm1pbmUgdGhlIG1pbmltYWwgc2l6ZSAoY293aGVhZCtiaXRtYXApCi0JCSovCi0JCW9mZnNldCA9IChsb2ZmX3QpIE1BUFVOSVQgKyBjb3dkZXYtPm1hcHNpemUgLSAxOwotCi0JCWlmICggY293bG9fd3JpdGVjb3dyYXcoY293ZGV2LCAiIiwgMSwgb2Zmc2V0KSA8IDEpIHsKLQkJCXByaW50ayhLRVJOX0VSUgotCQkJICAgICAgICJjb3dsb29wIC0gY2Fubm90IHNldCBjb3dmaWxlIHRvIHNpemUgJWxsZFxuIiwKLQkJCQlvZmZzZXQrMSk7Ci0JCQlyZXR1cm4gLUVJTlZBTDsKLQkJfQotCi0JCS8qCi0JCSoqIHByZXBhcmUgbmV3IGNvd2hlYWQKLQkJKi8KLQkJY293ZGV2LT5jb3doZWFkLT5tYWdpYwkJPSBDT1dNQUdJQzsKLQkJY293ZGV2LT5jb3doZWFkLT52ZXJzaW9uCT0gQ09XVkVSU0lPTjsKLQkJY293ZGV2LT5jb3doZWFkLT5tYXB1bml0CT0gTUFQVU5JVDsKLQkJY293ZGV2LT5jb3doZWFkLT5tYXBzaXplCT0gY293ZGV2LT5tYXBzaXplOwotCQljb3dkZXYtPmNvd2hlYWQtPnJkb2Jsb2Nrcwk9IGNvd2Rldi0+bnVtYmxvY2tzOwotCQljb3dkZXYtPmNvd2hlYWQtPnJkb2ZpbmdlcnByaW50CT0gY293ZGV2LT5maW5nZXJwcmludDsKLQkJY293ZGV2LT5jb3doZWFkLT5jb3d1c2VkCT0gMDsKLQotCQkvKgotCQkqKiBjYWxjdWxhdGUgc3RhcnQgb2Zmc2V0IG9mIGRhdGEgaW4gY293ZmlsZSwKLQkJKiogcm91bmRlZCB1cCB0byBtdWx0aXBsZSBvZiA0SyB0byBhdm9pZAotCQkqKiB1bm5lY2Vzc2FyeSBkaXNrLXVzYWdlIGZvciB3cml0dGVuIGRhdGFibG9ja3MgaW4KLQkJKiogdGhlIHNwYXJzZWQgY293ZmlsZSBvbiBlLmcuIDRLIGZpbGVzeXN0ZW1zCi0JCSovCi0JCWNvd2Rldi0+Y293aGVhZC0+ZG9mZnNldCA9Ci0JCQkoKE1BUFVOSVQrY293ZGV2LT5tYXBzaXplKzQwOTUpPj4xMik8PDEyOwotCX0KLQotCWNvd2Rldi0+Y293aGVhZC0+ZmxhZ3MJPSAwOwotCi0JREVCVUdQKERDT1ciY293bG9vcCAtIHJlc2VydmUgc3BhY2UgYml0bWFwLi4uLlxuIik7Ci0KLQkvKgotCSoqIHJlc2VydmUgc3BhY2UgaW4gbWVtb3J5IGZvciB0aGUgZW50aXJlIGJpdG1hcCBhbmQKLQkqKiBmaWxsIGl0IHdpdGggdGhlIGJpdG1hcC1kYXRhIGZyb20gZGlzazsgdGhlIGVudGlyZQotCSoqIGJpdG1hcCBpcyBhbGxvY2F0ZWQgaW4gc2V2ZXJhbCBjaHVua3MgYmVjYXVzZSBrbWFsbG9jCi0JKiogaGFzIHJlc3RyaWN0aW9ucyByZWdhcmRpbmcgdGhlIGFsbG93ZWQgc2l6ZSBwZXIga21hbGxvYwotCSovCi0JY293ZGV2LT5tYXBjb3VudCA9IChjb3dkZXYtPm1hcHNpemUrTUFQQ0hVTktTWi0xKS9NQVBDSFVOS1NaOwotCi0JLyoKLQkqKiB0aGUgc2l6ZSBvZiBldmVyeSBiaXRtYXAgY2h1bmsgd2lsbCBiZSBNQVBDSFVOS1NaIGJ5dGVzLCBleGNlcHQgZm9yCi0JKiogdGhlIGxhc3QgYml0bWFwIGNodW5rOiBjYWxjdWxhdGUgcmVtYWluaW5nIHNpemUgZm9yIHRoaXMgY2h1bmsKLQkqLwotCWlmIChjb3dkZXYtPm1hcHNpemUgJSBNQVBDSFVOS1NaID09IDApCi0JCWNvd2Rldi0+bWFwcmVtYWluID0gTUFQQ0hVTktTWjsKLQllbHNlCi0JCWNvd2Rldi0+bWFwcmVtYWluID0gY293ZGV2LT5tYXBzaXplICUgTUFQQ0hVTktTWjsKLQotCS8qCi0JKiogYWxsb2NhdGUgc3BhY2UgdG8gc3RvcmUgYWxsIHBvaW50ZXJzIGZvciB0aGUgYml0bWFwLWNodW5rcwotCSoqIChpbml0aWFsaXplIGFyZWEgd2l0aCB6ZXJvZXMgdG8gYWxsb3cgcHJvcGVyIHVuZG8pCi0JKi8KLQljb3dkZXYtPm1hcGNhY2hlID0ga21hbGxvYyhjb3dkZXYtPm1hcGNvdW50ICogc2l6ZW9mKGNoYXIgKiksCi0JCQkJCQkJCUdGUF9LRVJORUwpOwotCWlmICghY293ZGV2LT5tYXBjYWNoZSkgewotCQlwcmludGsoS0VSTl9FUlIKLQkJICAgICAgICJjb3dsb29wIC0gY2FuIG5vdCBhbGxvY2F0ZSBzcGFjZSBmb3IgYml0bWFwIHB0cnNcbiIpOwotCQlyZXR1cm4gLUVOT01FTTsKLQl9Ci0KLQltZW1zZXQoY293ZGV2LT5tYXBjYWNoZSwgMCwgY293ZGV2LT5tYXBjb3VudCAqIHNpemVvZihjaGFyICopKTsKLQotCS8qCi0JKiogYWxsb2NhdGUgc3BhY2UgdG8gc3RvcmUgdGhlIGJpdG1hcC1jaHVua3MgdGhlbXNlbHZlcwotCSovCi0JZm9yIChpPTA7IGkgPCBjb3dkZXYtPm1hcGNvdW50OyBpKyspIHsKLQkJaWYgKGkgPCAoY293ZGV2LT5tYXBjb3VudC0xKSkKLQkJCSooY293ZGV2LT5tYXBjYWNoZStpKSA9IGttYWxsb2MoTUFQQ0hVTktTWiwgR0ZQX0tFUk5FTCk7Ci0JCWVsc2UKLQkJCSooY293ZGV2LT5tYXBjYWNoZStpKSA9IGttYWxsb2MoY293ZGV2LT5tYXByZW1haW4sCi0JCQkJCQkgICAgICAgICAgICAgICAgICBHRlBfS0VSTkVMKTsKLQotCQlpZiAoKihjb3dkZXYtPm1hcGNhY2hlK2kpID09IE5VTEwpIHsKLQkJCXByaW50ayhLRVJOX0VSUiAiY293bG9vcCAtIG5vIHNwYWNlIGZvciBiaXRtYXBjaHVuayAlbGQiCi0JCQkJCSIgdG90bWFwc3o9JWxkLCBtYXBjbnQ9JWQgbWFwdW5pdD0lZFxuIiwKLQkJCQkJaSwgY293ZGV2LT5tYXBzaXplLCBjb3dkZXYtPm1hcGNvdW50LAotCQkJCQlNQVBVTklUKTsKLQkJCXJldHVybiAtRU5PTUVNOwotCQl9Ci0JfQotCi0JREVCVUdQKERDT1ciY293bG9vcCAtIHJlYWQgYml0bWFwIGZyb20gY293Li4uLlxuIik7Ci0KLQkvKgotCSoqIHJlYWQgdGhlIGVudGlyZSBiaXRtYXAgZnJvbSB0aGUgY293ZmlsZSBpbnRvIHRoZSBpbi1tZW1vcnkgY2FjaGU7Ci0JKiogY291bnQgdGhlIG51bWJlciBvZiBibG9ja3MgdGhhdCBhcmUgaW4gdXNlIGFscmVhZHkKLQkqKiAoc3RhdGlzdGljYWwgcHVycG9zZXMpCi0JKi8KLQlmb3IgKGk9MCwgb2Zmc2V0PU1BUFVOSVQ7IGkgPCBjb3dkZXYtPm1hcGNvdW50OwotCQkJCQlpKyssIG9mZnNldCs9TUFQQ0hVTktTWikgewotCQl1bnNpZ25lZCBsb25nCW51bWJ5dGVzOwotCi0JCWlmIChpIDwgKGNvd2Rldi0+bWFwY291bnQtMSkpCi0JCQkvKgotCQkJKiogZnVsbCBiaXRtYXAgY2h1bmsKLQkJCSovCi0JCQludW1ieXRlcyA9IE1BUENIVU5LU1o7Ci0JCWVsc2UKLQkJCS8qCi0JCQkqKiBsYXN0IGJpdG1hcCBjaHVuazogbWlnaHQgYmUgcGFydGx5IGZpbGxlZAotCQkJKi8KLQkJCW51bWJ5dGVzID0gY293ZGV2LT5tYXByZW1haW47Ci0KLQkJY293bG9fcmVhZGNvd3Jhdyhjb3dkZXYsICooY293ZGV2LT5tYXBjYWNoZStpKSwKLQkJCQkJCQludW1ieXRlcywgb2Zmc2V0KTsKLQl9Ci0KLQkvKgotCSoqIGlmIHRoZSBjb3dmaWxlIHdhcyBkaXJ0eSBhbmQgYXV0b21hdGljIHJlY292ZXJ5IGlzIHJlcXVpcmVkLAotCSoqIHJlY29uc3RydWN0IGEgcHJvcGVyIGJpdG1hcCBpbiBtZW1vcnkgbm93Ci0JKi8KLQlpZiAoY293ZGV2LT5jb3doZWFkLT5mbGFncyAmIENPV0RJUlRZKSB7Ci0JCXVuc2lnbmVkIGxvbmcgbG9uZwlibG9ja251bTsKLQkJY2hhcgkJCWRhdGFidWZbTUFQVU5JVF07Ci0JCXVuc2lnbmVkIGxvbmcJCW1hcG51bSwgbWFwYnl0ZSwgbWFwYml0OwotCi0JCXByaW50ayhLRVJOX05PVElDRSAiY293bG9vcCAtIHJlY292ZXIgZGlydHkgY293ZmlsZSAlcy4uLi5cbiIsCi0JCQkJCQkJY293Zik7Ci0KLQkJLyoKLQkJKiogcmVhZCBhbGwgZGF0YSBibG9ja3MKLQkJKi8KLQkJZm9yIChibG9ja251bT0wLCBydj0xLCBvZmZzZXQ9MDsKLQkJCWNvd2xvX3JlYWRjb3coY293ZGV2LCBkYXRhYnVmLCBNQVBVTklULCBvZmZzZXQpID4gMDsKLQkJCWJsb2NrbnVtKyssIG9mZnNldCArPSBNQVBVTklUKSB7Ci0KLQkJCS8qCi0JCQkqKiBpZiB0aGlzIGRhdGFibG9jayBjb250YWlucyByZWFsIGRhdGEgKG5vdCBiaW5hcnkKLQkJCSoqIHplcm9lcyksIHNldCB0aGUgY29ycmVzcG9uZGluZyBiaXQgaW4gdGhlIGJpdG1hcAotCQkJKi8KLQkJCWlmICggbWVtY21wKGRhdGFidWYsIGFsbHplcm9lcywgTUFQVU5JVCkgPT0gMCkKLQkJCQljb250aW51ZTsKLQotCQkJbWFwbnVtICA9IENBTENNQVAgKGJsb2NrbnVtKTsKLQkJCW1hcGJ5dGUgPSBDQUxDQllURShibG9ja251bSk7Ci0JCQltYXBiaXQgID0gQ0FMQ0JJVCAoYmxvY2tudW0pOwotCi0JCQkqKCooY293ZGV2LT5tYXBjYWNoZSttYXBudW0pK21hcGJ5dGUpIHw9ICgxPDxtYXBiaXQpOwotCQl9Ci0KLQkJcHJpbnRrKEtFUk5fTk9USUNFICJjb3dsb29wIC0gY293ZmlsZSByZWNvdmVyeSBjb21wbGV0ZWRcbiIpOwotCX0KLQotCS8qCi0JKiogY291bnQgYWxsIGJpdHMgc2V0IGluIHRoZSBiaXRtYXBzIGZvciBzdGF0aXN0aWNhbCBwdXJwb3NlcwotCSovCi0JZm9yIChpPTAsIGNvd2Rldi0+bnJjb3dibG9ja3MgPSAwOyBpIDwgY293ZGV2LT5tYXBjb3VudDsgaSsrKSB7Ci0JCWxvbmcJbnVtYnl0ZXM7Ci0JCWNoYXIJKnA7Ci0KLQkJaWYgKGkgPCAoY293ZGV2LT5tYXBjb3VudC0xKSkKLQkJCW51bWJ5dGVzID0gTUFQQ0hVTktTWjsKLQkJZWxzZQotCQkJbnVtYnl0ZXMgPSBjb3dkZXYtPm1hcHJlbWFpbjsKLQotCQlwID0gKihjb3dkZXYtPm1hcGNhY2hlK2kpOwotCi0JCWZvciAobnVtYnl0ZXMtLTsgbnVtYnl0ZXMgPj0gMDsgbnVtYnl0ZXMtLSwgcCsrKSB7Ci0JCQkvKgotCQkJKiogZm9yIG9ubHkgZWlnaHQgY2hlY2tzIHRoZSBmb2xsb3dpbmcgY29uc3RydWN0aW9uCi0JCQkqKiBpcyBmYXN0ZXIgdGhhbiBhIGxvb3AtY29uc3RydWN0aW9uCi0JCQkqLwotCQkJaWYgKCgqcCkgJiAweDAxKQljb3dkZXYtPm5yY293YmxvY2tzKys7Ci0JCQlpZiAoKCpwKSAmIDB4MDIpCWNvd2Rldi0+bnJjb3dibG9ja3MrKzsKLQkJCWlmICgoKnApICYgMHgwNCkJY293ZGV2LT5ucmNvd2Jsb2NrcysrOwotCQkJaWYgKCgqcCkgJiAweDA4KQljb3dkZXYtPm5yY293YmxvY2tzKys7Ci0JCQlpZiAoKCpwKSAmIDB4MTApCWNvd2Rldi0+bnJjb3dibG9ja3MrKzsKLQkJCWlmICgoKnApICYgMHgyMCkJY293ZGV2LT5ucmNvd2Jsb2NrcysrOwotCQkJaWYgKCgqcCkgJiAweDQwKQljb3dkZXYtPm5yY293YmxvY2tzKys7Ci0JCQlpZiAoKCpwKSAmIDB4ODApCWNvd2Rldi0+bnJjb3dibG9ja3MrKzsKLQkJfQotCX0KLQotCS8qCi0JKiogY29uc2lzdGVuY3ktY2hlY2sgZm9yIG51bWJlciBvZiBiaXRzIHNldCBpbiBiaXRtYXAKLQkqLwotCWlmICggIShjb3dkZXYtPmNvd2hlYWQtPmZsYWdzICYgQ09XRElSVFkpICYmCi0JICAgIChjb3dkZXYtPmNvd2hlYWQtPmNvd3VzZWQgIT0gY293ZGV2LT5ucmNvd2Jsb2NrcykgKSB7Ci0JCXByaW50ayhLRVJOX0VSUiAiY293bG9vcCAtIGluY29uc2lzdGVudCBjb3dmaWxlIGFkbWlcbiIpOwotCQlyZXR1cm4gLUVJTlZBTDsKLQl9Ci0KLQlyZXR1cm4gMDsKLX0KLQotLyoKLSoqIHVuZG8gbWVtb3J5IGFsbG9jcyBhbmQgZmlsZSBvcGVucyBpc3N1ZWQgc28gZmFyCi0qKiByZWxhdGVkIHRvIHRoZSBjb3dmaWxlCi0qLwotc3RhdGljIHZvaWQKLWNvd2xvX3VuZG9fb3BlbmNvdyhzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKmNvd2RldikKLXsKLQlpbnQJaTsKLQotCWlmIChjb3dkZXYtPm1hcGNhY2hlKSB7Ci0JCWZvciAoaT0wOyBpIDwgY293ZGV2LT5tYXBjb3VudDsgaSsrKSB7Ci0JCQlpZiAoKihjb3dkZXYtPm1hcGNhY2hlK2kpICE9IE5VTEwpCi0JCQkJa2ZyZWUoICooY293ZGV2LT5tYXBjYWNoZStpKSApOwotCQl9Ci0KLQkJa2ZyZWUoY293ZGV2LT5tYXBjYWNoZSk7Ci0JfQotCi0JaWYgKGNvd2Rldi0+Y293aGVhZCkKLQkJa2ZyZWUoY293ZGV2LT5jb3doZWFkKTsKLQotCWlmICggKGNvd2Rldi0+c3RhdGUgJiBDT1dDT1dPUEVOKSAmJiAoY293ZGV2LT5jb3dmcCkgKQotICAJCWZpbHBfY2xvc2UoY293ZGV2LT5jb3dmcCwgMCk7Ci0KLQkvKgotCSoqIG1hcmsgY293ZmlsZSBjbG9zZWQKLQkqLwotCWNvd2Rldi0+c3RhdGUgJj0gfkNPV0NPV09QRU47Ci19Ci0KLS8qCi0qKiBmbHVzaCB0aGUgZW50aXJlIGJpdG1hcCBhbmQgdGhlIGNvd2hlYWQgKGNsZWFuKSB0byB0aGUgY293ZmlsZQotKioKLSoqIG11c3QgYmUgY2FsbGVkIHdpdGggdGhlIGNvd2RldmljZXMtbG9jayBzZXQKLSovCi1zdGF0aWMgdm9pZAotY293bG9fc3luYyh2b2lkKQotewotCWludAkJCWksIG1pbm9yOwotCWxvZmZfdAkJCW9mZnNldDsKLQlzdHJ1Y3QgY293bG9vcF9kZXZpY2UJKmNvd2RldjsKLQotCWZvciAobWlub3I9MDsgbWlub3IgPCBtYXhjb3dzOyAgbWlub3IrKykgewotCQljb3dkZXYgPSBjb3dkZXZhbGxbbWlub3JdOwotCQlpZiAoICEgKGNvd2Rldi0+c3RhdGUgJiBDT1dSV0NPV09QRU4pICkKLQkJCWNvbnRpbnVlOwotCi0JCWZvciAoaT0wLCBvZmZzZXQ9TUFQVU5JVDsgaSA8IGNvd2Rldi0+bWFwY291bnQ7Ci0JCQkJCWkrKywgb2Zmc2V0ICs9IE1BUENIVU5LU1opIHsKLQkJCXVuc2lnbmVkIGxvbmcJbnVtYnl0ZXM7Ci0KLQkJCWlmIChpIDwgKGNvd2Rldi0+bWFwY291bnQtMSkpCi0JCQkJLyoKLQkJCQkqKiBmdWxsIGJpdG1hcCBjaHVuawotCQkJCSovCi0JCQkJbnVtYnl0ZXMgPSBNQVBDSFVOS1NaOwotCQkJZWxzZQotCQkJCS8qCi0JCQkJKiogbGFzdCBiaXRtYXAgY2h1bms6IG1pZ2h0IGJlIHBhcnRseSBmaWxsZWQKLQkJCQkqLwotCQkJCW51bWJ5dGVzID0gY293ZGV2LT5tYXByZW1haW47Ci0KLQkJCURFQlVHUChEQ09XCi0JCQkgICAgICAgImNvd2xvb3AgLSBmbHVzaGluZyBiaXRtYXAgJTJkICglM2xkIEtiKVxuIiwKLQkJCQkJCQlpLCBudW1ieXRlcy8xMDI0KTsKLQotCQkJaWYgKGNvd2xvX3dyaXRlY293cmF3KGNvd2RldiwgKihjb3dkZXYtPm1hcGNhY2hlK2kpLAotCQkJCQkJbnVtYnl0ZXMsIG9mZnNldCkgPCBudW1ieXRlcykgewotCQkJCWJyZWFrOwotCQkJfQotCQl9Ci0KLQkJLyoKLQkJKiogZmx1c2ggY2xlYW4gdXAtdG8tZGF0ZSBjb3doZWFkIHRvIGNvd2ZpbGUKLQkJKi8KLQkJY293ZGV2LT5jb3doZWFkLT5jb3d1c2VkCSA9IGNvd2Rldi0+bnJjb3dibG9ja3M7Ci0JCWNvd2Rldi0+Y293aGVhZC0+ZmxhZ3MJCSY9IH5DT1dESVJUWTsKLQotCQlERUJVR1AoRENPVyAiY293bG9vcCAtIGZsdXNoaW5nIGNvd2hlYWQgKCUzZCBLYilcbiIsCi0JCQkJCQkJTUFQVU5JVC8xMDI0KTsKLQotCQljb3dsb193cml0ZWNvd3Jhdyhjb3dkZXYsIGNvd2Rldi0+Y293aGVhZCwgTUFQVU5JVCwgKGxvZmZfdCkgMCk7Ci0JfQotfQotCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0vKiBNb2R1bGUgbG9hZGluZy91bmxvYWRpbmcgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCi0vKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi0KLS8qCi0qKiBjYWxsZWQgZHVyaW5nIGluc21vZC9tb2Rwcm9iZQotKi8KLXN0YXRpYyBpbnQgX19pbml0Ci1jb3dsb19pbml0X21vZHVsZSh2b2lkKQotewotCWludAlydjsKLQlpbnQJbWlub3IsIHVwdG9jb3dzOwotCi0gICAgICAgIHJldmlzaW9uW3NpemVvZiByZXZpc2lvbiAtIDNdID0gJ1wwJzsKLQotICAgICAgICBwcmludGsoS0VSTl9OT1RJQ0UgImNvd2xvb3AgLSAoQykgMjAwOSBBVENvbXB1dGluZy5ubCAtIHZlcnNpb246ICVzXG4iLCAmcmV2aXNpb25bMTFdKTsKLSAgICAgICAgcHJpbnRrKEtFUk5fTk9USUNFICJjb3dsb29wIC0gaW5mbzogd3d3LkFUQ29tcHV0aW5nLm5sL2Nvd2xvb3BcbiIpOwotCi0JbWVtc2V0KGFsbHplcm9lcywgMCwgTUFQVU5JVCk7Ci0KLQkvKgotCSoqIFNldHVwIGFkbWluaXN0cmF0aW9uIGZvciBhbGwgcG9zc2libGUgY293ZGV2aWNlcy4KLSAgICAgICAgKiogTm90ZSB0aGF0IHRoZWlyIG1pbm9yIG51bWJlcnMgZ28gZnJvbSAwIHRvIE1BWENPV1MtMSBpbmNsdXNpdmUKLSAgICAgICAgKiogYW5kIG1pbm9yID09IE1BWENPV1MtMSBpcyByZXNlcnZlZCBmb3IgdGhlIGNvbnRyb2wgZGV2aWNlLgotCSovCi0JaWYgKChtYXhjb3dzIDwgMSkgfHwgKG1heGNvd3MgPiBNQVhDT1dTKSkgewotCQlwcmludGsoS0VSTl9XQVJOSU5HCi0JCSAgICAgICAiY293bG9vcCAtIG1heGNvd3MgZXhjZWVkcyBtYXhpbXVtIG9mICVkXG4iLCBNQVhDT1dTKTsKLQotICAgICAgICAgICAgICAgIG1heGNvd3MgPSBERkxDT1dTOwotICAgICAgICB9Ci0KLQkvKiBhbGxvY2F0ZSByb29tIGZvciBhIHRhYmxlIHdpdGggYSBwb2ludGVyIHRvIGVhY2ggY293bG9vcF9kZXZpY2U6ICovCi0gICAgICAgIGlmICggKGNvd2RldmFsbCA9IGttYWxsb2MobWF4Y293cyAqIHNpemVvZihzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKiksCi0JCQkJCQkJR0ZQX0tFUk5FTCkpID09IE5VTEwpIHsKLQkJcHJpbnRrKEtFUk5fV0FSTklORwotCQkgICAgICAgICJjb3dsb29wIC0gY2FuIG5vdCBhbGxvYyB0YWJsZSBmb3IgJWQgZGV2c1xuIiwgbWF4Y293cyk7Ci0JCXVwdG9jb3dzID0gMDsKLQkJcnYgPSAtRU5PTUVNOwotCQlnb3RvIGVycm9yX291dDsKLQl9Ci0JbWVtc2V0KGNvd2RldmFsbCwgMCwgbWF4Y293cyAqIHNpemVvZihzdHJ1Y3QgY293bG9vcF9kZXZpY2UgKikpOwotCS8qIHRoZW4gaG9vayBhbiBhY3R1YWwgY293bG9vcF9kZXZpY2Ugc3RydWN0IHRvIGVhY2ggcG9pbnRlcjogKi8KLQlmb3IgKG1pbm9yPTA7IG1pbm9yIDwgbWF4Y293czsgbWlub3IrKykgewotCQlpZiAoKGNvd2RldmFsbFttaW5vcl0gPSBrbWFsbG9jKHNpemVvZihzdHJ1Y3QgY293bG9vcF9kZXZpY2UpLAotCQkJCQkJR0ZQX0tFUk5FTCkpID09IE5VTEwpIHsKLQkJCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJICAgICAgICAgICAiY293bG9vcCAtIGNhbiBub3QgYWxsb2MgYWRtaW4tc3RydWN0IGZvciBkZXYgbm8gJWRcbiIsIG1pbm9yKTsKLQotCQkJdXB0b2Nvd3MgPSBtaW5vcjsgLyogdGhpcyBpcyBob3cgZmFyIHdlIGdvdC4uLi4gKi8KLQkJCXJ2ID0gLUVOT01FTTsKLQkJCWdvdG8gZXJyb3Jfb3V0OwotCQl9Ci0gICAgICAgIAltZW1zZXQoY293ZGV2YWxsW21pbm9yXSwgMCwgc2l6ZW9mKHN0cnVjdCBjb3dsb29wX2RldmljZSkpOwotCX0KLQl1cHRvY293cyA9IG1heGNvd3M7IC8qIHdlIGdvdCBhbGwgZGV2aWNlcyAqLwotCi0Jc2VtYV9pbml0KCZjb3dkZXZsb2NrLCAxKTsKLQotCS8qCi0JKiogcmVnaXN0ZXIgY293bG9vcCBtb2R1bGUKLQkqLwotCWlmICggcmVnaXN0ZXJfYmxrZGV2KENPV01BSk9SLCBERVZJQ0VfTkFNRSkgPCAwKSB7Ci0JCXByaW50ayhLRVJOX1dBUk5JTkcKLQkJICAgICJjb3dsb29wIC0gdW5hYmxlIHRvIGdldCBtYWpvciAlZCBmb3IgY293bG9vcFxuIiwgQ09XTUFKT1IpOwotCQlydiA9IC1FSU87Ci0JCWdvdG8gZXJyb3Jfb3V0OwotCX0KLQotCS8qCi0JKiogY3JlYXRlIGEgZGlyZWN0b3J5IGJlbG93IC9wcm9jIHRvIGFsbG9jYXRlIGEgZmlsZQotCSoqIGZvciBlYWNoIGNvd2RldmljZSB0aGF0IGlzIGFsbG9jYXRlZCBsYXRlciBvbgotCSovCi0JY293bG9fcHJvY2RpciA9IHByb2NfbWtkaXIoImNvdyIsIE5VTEwpOwotCi0JLyoKLQkqKiBjaGVjayBpZiBhIGNvd2RldmljZSBoYXMgdG8gYmUgb3BlbmVkIGR1cmluZyBpbnNtb2QvbW9kcHJvYmU7Ci0JKiogdHdvIHBhcmFtZXRlcnMgc2hvdWxkIGJlIHNwZWNpZmllZCB0aGVuOiByZG9maWxlPSBhbmQgY293ZmlsZT0KLQkqLwotCWlmKCAocmRvZmlsZVswXSAhPSAnXDAnKSAmJiAoY293ZmlsZVswXSAhPSAnXDAnKSApIHsKLQkJY2hhcgkqcG8gPSBvcHRpb247Ci0JCWludAl3YW50cmVjb3ZlciA9IDA7Ci0KLQkJLyoKLQkJKiogY2hlY2sgaWYgYXV0b21hdGljIHJlY292ZXJ5IGlzIHdhbnRlZAotCQkqLwotCQl3aGlsZSAoKnBvKSB7Ci0JCQlpZiAoKnBvID09ICdyJykgewotCQkJCXdhbnRyZWNvdmVyID0gMTsKLQkJCQlicmVhazsKLSAgICAgICAgICAgICAgICAgICAgICAgIH0KLQkJCXBvKys7Ci0JCX0KLQotCQkvKgotCQkqKiBvcGVuIG5ldyBjb3dkZXZpY2Ugd2l0aCBtaW5vciBudW1iZXIgMAotCQkqLwotCQlpZiAoIChydiA9IGNvd2xvX29wZW5wYWlyKHJkb2ZpbGUsIGNvd2ZpbGUsIHdhbnRyZWNvdmVyLCAwKSkpIHsKLQkJCXJlbW92ZV9wcm9jX2VudHJ5KCJjb3ciLCBOVUxMKTsKLQkJCXVucmVnaXN0ZXJfYmxrZGV2KENPV01BSk9SLCBERVZJQ0VfTkFNRSk7Ci0JCQlnb3RvIGVycm9yX291dDsKLQkJfQotICAgICAgICB9IGVsc2UgewotCQkvKgotCQkqKiBjaGVjayBpZiBvbmx5IG9uZSBwYXJhbWV0ZXIgaGFzIGJlZW4gc3BlY2lmaWVkCi0JCSovCi0JCWlmKCAocmRvZmlsZVswXSAhPSAnXDAnKSB8fCAoY293ZmlsZVswXSAhPSAnXDAnKSApIHsKLQkJCXByaW50ayhLRVJOX0VSUgotCQkJICAgICAgICJjb3dsb29wIC0gb25seSBvbmUgZmlsZW5hbWUgc3BlY2lmaWVkXG4iKTsKLQkJCXJlbW92ZV9wcm9jX2VudHJ5KCJjb3ciLCBOVUxMKTsKLQkJCXVucmVnaXN0ZXJfYmxrZGV2KENPV01BSk9SLCBERVZJQ0VfTkFNRSk7Ci0JCQlydiA9IC1FSU5WQUw7Ci0JCQlnb3RvIGVycm9yX291dDsKLQkJfQotCX0KLQotCS8qCi0JKiogYWxsb2NhdGUgZmFrZSBkaXNrIGFzIGNvbnRyb2wgY2hhbm5lbCB0byBoYW5kbGUgdGhlIHJlcXVlc3RzCi0JKiogdG8gYWN0aXZhdGUgYW5kIGRlYWN0aXZhdGUgY293ZGV2aWNlcyBkeW5hbWljYWxseQotCSovCi0JaWYgKCEoY293Y3RsZ2QgPSBhbGxvY19kaXNrKDEpKSkgewotCQlwcmludGsoS0VSTl9XQVJOSU5HCi0JCSAgICAgICAiY293bG9vcCAtIHVuYWJsZSB0byBhbGxvY19kaXNrIGZvciBjb3djdGxcbiIpOwotCi0JCXJlbW92ZV9wcm9jX2VudHJ5KCJjb3ciLCBOVUxMKTsKLQkJKHZvaWQpIGNvd2xvX2Nsb3NlcGFpcihjb3dkZXZhbGxbMF0pOwotCQl1bnJlZ2lzdGVyX2Jsa2RldihDT1dNQUpPUiwgREVWSUNFX05BTUUpOwotCQlydiA9IC1FTk9NRU07Ci0JCWdvdG8gZXJyb3Jfb3V0OwotCX0KLQotCXNwaW5fbG9ja19pbml0KCZjb3djdGxycWxvY2spOwotCWNvd2N0bGdkLT5tYWpvciAgICAgICAgPSBDT1dNQUpPUjsKLQljb3djdGxnZC0+Zmlyc3RfbWlub3IgID0gQ09XQ1RMOwotCWNvd2N0bGdkLT5taW5vcnMgICAgICAgPSAxOwotCWNvd2N0bGdkLT5mb3BzICAgICAgICAgPSAmY293bG9fZm9wczsKLQljb3djdGxnZC0+cHJpdmF0ZV9kYXRhID0gTlVMTDsKLQkvKiB0aGUgZGV2aWNlIGhhcyBjYXBhY2l0eSAwLCBzbyB0aGVyZSB3aWxsIGJlIG5vIHEtcmVxdWVzdHMgKi8KLQljb3djdGxnZC0+cXVldWUgPSBibGtfaW5pdF9xdWV1ZShOVUxMLCAmY293Y3RscnFsb2NrKTsKLQlzcHJpbnRmKGNvd2N0bGdkLT5kaXNrX25hbWUsICJjb3djdGwiKTsKLQlzZXRfY2FwYWNpdHkoY293Y3RsZ2QsIDApOwotCi0JYWRkX2Rpc2soY293Y3RsZ2QpOwotCi0gICAgICAgIHByaW50ayhLRVJOX05PVElDRSAiY293bG9vcCAtIG51bWJlciBvZiBjb25maWd1cmVkIGNvd2RldmljZXM6ICVkXG4iLAotCQkJCQkJCQltYXhjb3dzKTsKLQlpZiAocmRvZmlsZVswXSAhPSAnXDAnKSB7Ci0JICAgIHByaW50ayhLRVJOX05PVElDRSAiY293bG9vcCAtIGluaXRpYWxpemVkIG9uIHJkb2ZpbGU9JXNcbiIsCi0JCQkJCQkJCXJkb2ZpbGUpOwotCX0gZWxzZSB7Ci0JICAgIHByaW50ayhLRVJOX05PVElDRSAiY293bG9vcCAtIGluaXRpYWxpemVkIHdpdGhvdXQgcmRvZmlsZSB5ZXRcbiIpOwotCX0KLQlyZXR1cm4gMDsKLQotZXJyb3Jfb3V0OgotCWZvciAobWlub3I9MDsgbWlub3IgPCB1cHRvY293cyA7IG1pbm9yKyspIHsKLQkJa2ZyZWUoY293ZGV2YWxsW21pbm9yXSk7Ci0JfQotCWtmcmVlKGNvd2RldmFsbCk7Ci0JcmV0dXJuIHJ2OwotfQotCi0vKgotKiogY2FsbGVkIGR1cmluZyBybW1vZAotKi8KLXN0YXRpYyB2b2lkIF9fZXhpdAotY293bG9fY2xlYW51cF9tb2R1bGUodm9pZCkKLXsKLQlpbnQJbWlub3I7Ci0KLQkvKgotCSoqIGZsdXNoIGJpdG1hcHMgYW5kIGNvd2hlYWRzIHRvIHRoZSBjb3dmaWxlcwotCSovCi0JZG93bigmY293ZGV2bG9jayk7Ci0JY293bG9fc3luYygpOwotCXVwKCZjb3dkZXZsb2NrKTsKLQotCS8qCi0JKiogY2xvc2UgYWxsIGNvd2RldmljZXMKLQkqLwotCWZvciAobWlub3I9MDsgbWlub3IgPCBtYXhjb3dzOyAgbWlub3IrKykKLQkJKHZvaWQpIGNvd2xvX2Nsb3NlcGFpcihjb3dkZXZhbGxbbWlub3JdKTsKLQotCXVucmVnaXN0ZXJfYmxrZGV2KENPV01BSk9SLCBERVZJQ0VfTkFNRSk7Ci0KLQkvKgotCSoqIGdldCByaWQgb2YgL3Byb2MvY293IGFuZCB1bnJlZ2lzdGVyIHRoZSBkcml2ZXIKLQkqLwotCXJlbW92ZV9wcm9jX2VudHJ5KCJjb3ciLCBOVUxMKTsKLQotCWZvciAobWlub3IgPSAwOyBtaW5vciA8IG1heGNvd3M7IG1pbm9yKyspIHsKLQkJa2ZyZWUoY293ZGV2YWxsW21pbm9yXSk7Ci0JfQotCWtmcmVlKGNvd2RldmFsbCk7Ci0KLQlkZWxfZ2VuZGlzayhjb3djdGxnZCk7ICAvKiByZXZlcnQgdGhlIGFsbG9jX2Rpc2soKSAqLwotCXB1dF9kaXNrICAgKGNvd2N0bGdkKTsgIC8qIHJldmVydCB0aGUgYWRkX2Rpc2soKSAgICovCi0JYmxrX2NsZWFudXBfcXVldWUoY293Y3RsZ2QtPnF1ZXVlKTsgLyogY2xlYW51cCB0aGUgZW1wdHkgcXVldWUgKi8KLQotCXByaW50ayhLRVJOX05PVElDRSAiY293bG9vcCAtIHVubG9hZGVkXG4iKTsKLX0KLQotbW9kdWxlX2luaXQoY293bG9faW5pdF9tb2R1bGUpOwotbW9kdWxlX2V4aXQoY293bG9fY2xlYW51cF9tb2R1bGUpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2Nvd2xvb3AvY293bG9vcC5oIGIvZHJpdmVycy9zdGFnaW5nL2Nvd2xvb3AvY293bG9vcC5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBiYmQ0YTM1Li4wMDAwMDAwCi0tLSBhL2RyaXZlcnMvc3RhZ2luZy9jb3dsb29wL2Nvd2xvb3AuaAorKysgL2Rldi9udWxsCkBAIC0xLDY2ICswLDAgQEAKLS8qCi0qKiBETyBOT1QgTU9ESUZZIFRIRVNFIFZBTFVFUyAod291bGQgbWFrZSBvbGQgY293ZmlsZXMgdW51c2FibGUpCi0qLwotI2RlZmluZQlNQVBVTklUCQkxMDI0CQkvKiBibG9ja3NpemUgZm9yIGJpdCBpbiBiaXRtYXAgICAgICAgKi8KLSNkZWZpbmUJTVVTSElGVAkJMTAJCS8qIGJpdHNoaWZ0ICBmb3IgYml0IGluIGJpdG1hcCAgICAgICAqLwotI2RlZmluZQlNVU1BU0sJCTB4M2ZmCQkvKiBiaXRtYXNrICAgZm9yIGJpdCBpbiBiaXRtYXAgICAgICAgKi8KLQotI2RlZmluZQlDT1dNQUdJQwkweDU3NGY0MzdmCS8qIGJ5dGUtc3dhcHBlZCAnN2YgQyBPIFcnICAgICAgICAgICAqLwotI2RlZmluZQlDT1dESVJUWQkweDAxCi0jZGVmaW5lCUNPV1BBQ0tFRAkweDAyCi0jZGVmaW5lCUNPV1ZFUlNJT04JMQotCi1zdHJ1Y3QgY293aGVhZAotewotCWludAkJbWFnaWM7CQkvKiBpZGVudGlmaWVzIGEgY293ZmlsZSAgICAgICAgICAgICAgKi8KLQlzaG9ydAkJdmVyc2lvbjsJLyogdmVyc2lvbiBvZiBjb3doZWFkICAgICAgICAgICAgICAgICovCi0Jc2hvcnQJCWZsYWdzOyAgICAJLyogZmxhZ3MgaW5kaWNhdGluZyBzdGF0dXMgICAgICAgICAgICovCi0JdW5zaWduZWQgbG9uZwltYXB1bml0OwkvKiBibG9ja3NpemUgcGVyIGJpdCBpbiBiaXRtYXAgICAgICAgKi8KLQl1bnNpZ25lZCBsb25nCW1hcHNpemU7CS8qIHRvdGFsIHNpemUgb2YgYml0bWFwIChieXRlcykgICAgICAqLwotCXVuc2lnbmVkIGxvbmcJZG9mZnNldDsJLyogc3RhcnQtb2Zmc2V0IGRhdGFibG9ja3MgaW4gY293ICAgICovCi0JdW5zaWduZWQgbG9uZwlyZG9ibG9ja3M7CS8qIHNpemUgb2YgcmVsYXRlZCByZWFkLW9ubHkgZmlsZSAgICAqLwotCXVuc2lnbmVkIGxvbmcJcmRvZmluZ2VycHJpbnQ7CS8qIGZpbmdlcnByaW50IG9mIHJlYWQtb25seSBmaWxlICAgICAqLwotCXVuc2lnbmVkIGxvbmcJY293dXNlZDsJLyogbnVtYmVyIG9mIGRhdGFibG9ja3MgdXNlZCBpbiBjb3cgICovCi19OwotCi0jZGVmaW5lIENPV0RFVkRJUgkiL2Rldi9jb3cvIgotI2RlZmluZSBDT1dERVZJQ0UJQ09XREVWRElSICIlbGQiCi0jZGVmaW5lIENPV0NPTlRST0wJQ09XREVWRElSICJjdGwiCi0KLSNkZWZpbmUgTUFYQ09XUwkJMTAyNAotI2RlZmluZSBDT1dDVEwJCShNQVhDT1dTLTEpCS8qIG1pbm9yIG51bWJlciBvZiAvZGV2L2Nvdy9jdGwgICAgICovCi0KLSNkZWZpbmUgQ09XUFJPQ0RJUgkiL3Byb2MvY293LyIKLSNkZWZpbmUgQ09XUFJPQ0ZJTEUJQ09XUFJPQ0RJUiAiJWQiCi0KLS8qCi0qKiBpb2N0bCByZWxhdGVkIHN0dWZmCi0qLwotI2RlZmluZSBBTllERVYJCSgodW5zaWduZWQgbG9uZyktMSkKLQotc3RydWN0IGNvd3BhaXIKLXsKLQl1bnNpZ25lZCBjaGFyCSpyZG9maWxlOwkvKiBwYXRobmFtZSBvZiB0aGUgcmRvZmlsZSAgICAgICAgICAgKi8KLQl1bnNpZ25lZCBjaGFyCSpjb3dmaWxlOwkvKiBwYXRobmFtZSBvZiB0aGUgY293ZmlsZSAgICAgICAgICAgKi8KLQl1bnNpZ25lZCBzaG9ydAlyZG9mbGVuOwkvKiBsZW5ndGggb2YgcmRvZmlsZSBwYXRobmFtZSAgICAgICAgKi8KLQl1bnNpZ25lZCBzaG9ydAljb3dmbGVuOwkvKiBsZW5ndGggb2YgY293ZmlsZSBwYXRobmFtZSAgICAgICAgKi8KLQl1bnNpZ25lZCBsb25nCWRldmljZTsJCS8qIHJlcXVlc3RlZC9yZXR1cm5lZCBkZXZpY2UgbnVtYmVyICAqLwotfTsKLQotc3RydWN0IGNvd3dhdGNoCi17Ci0JaW50ICAgICAgCWZsYWdzOwkJLyogcmVxdWVzdCBmbGFncyAgICAgICAgICAgICAgICAgICAgICovCi0JdW5zaWduZWQgbG9uZwlkZXZpY2U7CQkvKiByZXF1ZXN0ZWQgZGV2aWNlIG51bWJlciAgICAgICAgICAgKi8KLQl1bnNpZ25lZCBsb25nCXRocmVzaG9sZDsJLyogY29udGludWUgaWYgZnJlZSBLYiA8IHRocmVzaG9sZCAgICovCi0JdW5zaWduZWQgbG9uZwl0b3RhbGtiOwkvKiByZXQ6IHRvdGFsIGZpbGVzeXN0ZW0gc2l6ZSAoS2IpICAgKi8KLQl1bnNpZ25lZCBsb25nCWF2YWlsa2I7CS8qIHJldDogZnJlZSAgZmlsZXN5c3RlbSBzaXplIChLYikgICAqLwotfTsKLQotI2RlZmluZQlXQVRDSFdBSVQJMHgwMQkJLyogYmxvY2sgdW50aWwgdGhyZXNob2xkIHJlYWNoZWQgICAgICovCi0KLSNkZWZpbmUJQ09XU1lOQwkJX0lPICAoJ0MnLCAxKQotI2RlZmluZQlDT1dNS1BBSVIJX0lPVyAoJ0MnLCAyLCBzdHJ1Y3QgY293cGFpcikKLSNkZWZpbmUJQ09XUk1QQUlSCV9JT1cgKCdDJywgMywgdW5zaWduZWQgbG9uZykKLSNkZWZpbmUJQ09XV0FUQ0gJX0lPVyAoJ0MnLCA0LCBzdHJ1Y3QgY293d2F0Y2gpCi0jZGVmaW5lCUNPV0NMT1NFCV9JT1cgKCdDJywgNSwgdW5zaWduZWQgbG9uZykKLSNkZWZpbmUJQ09XUkRPUEVOCV9JT1cgKCdDJywgNiwgdW5zaWduZWQgbG9uZykKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ldDEzMXgvZXQxMzEwX2FkZHJlc3NfbWFwLmggYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxMF9hZGRyZXNzX21hcC5oCmluZGV4IDYyOTRkMzguLjJjM2Q2NWEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ldDEzMXgvZXQxMzEwX2FkZHJlc3NfbWFwLmgKKysrIGIvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfYWRkcmVzc19tYXAuaApAQCAtMjIzLDcgKzIyMyw3IEBACiAKIGV4dGVybiBpbmxpbmUgdm9pZCBhZGRfMTBiaXQodTMyICp2LCBpbnQgbikKIHsKLQkqdiA9IElOREVYMTAoKnYgKyBuKTsKKwkqdiA9IElOREVYMTAoKnYgKyBuKSB8ICgqdiAmIEVUX0RNQTEwX1dSQVApOwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfcnguYyBiL2RyaXZlcnMvc3RhZ2luZy9ldDEzMXgvZXQxMzEwX3J4LmMKaW5kZXggOGYyZTkxZi4uMTBlMjFkYiAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2V0MTMxeC9ldDEzMTBfcnguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvZXQxMzF4L2V0MTMxMF9yeC5jCkBAIC0xMTc3LDEyICsxMTc3LDIwIEBACiAKIHN0YXRpYyBpbmxpbmUgdTMyIGJ1bXBfZmJyKHUzMiAqZmJyLCB1MzIgbGltaXQpCiB7Ci0JdTMyIHYgPSAqZmJyOwotCWFkZF8xMGJpdCgmdiwgMSk7Ci0JaWYgKHYgPiBsaW1pdCkKLQkJdiA9ICgqZmJyICYgfkVUX0RNQTEwX01BU0spIF4gRVRfRE1BMTBfV1JBUDsKLQkqZmJyID0gdjsKLQlyZXR1cm4gdjsKKyAgICAgICAgdTMyIHYgPSAqZmJyOworICAgICAgICB2Kys7CisgICAgICAgIC8qIFRoaXMgd29ya3MgZm9yIGFsbCBjYXNlcyB3aGVyZSBsaW1pdCA8IDEwMjQuIFRoZSAxMDIzIGNhc2UKKyAgICAgICAgICAgd29ya3MgYmVjYXVzZSAxMDIzKysgaXMgMTAyNCB3aGljaCBtZWFucyB0aGUgaWYgY29uZGl0aW9uIGlzIG5vdAorICAgICAgICAgICB0YWtlbiBidXQgdGhlIGNhcnJ5IG9mIHRoZSBiaXQgaW50byB0aGUgd3JhcCBiaXQgdG9nZ2xlcyB0aGUgd3JhcAorICAgICAgICAgICB2YWx1ZSBjb3JyZWN0bHkgKi8KKyAgICAgICAgaWYgKCh2ICYgRVRfRE1BMTBfTUFTSykgPiBsaW1pdCkgeworICAgICAgICAgICAgICAgIHYgJj0gfkVUX0RNQTEwX01BU0s7CisgICAgICAgICAgICAgICAgdiBePSBFVF9ETUExMF9XUkFQOworICAgICAgICB9CisgICAgICAgIC8qIEZvciB0aGUgMTAyMyBjYXNlICovCisgICAgICAgIHYgJj0gKEVUX0RNQTEwX01BU0t8RVRfRE1BMTBfV1JBUCk7CisgICAgICAgICpmYnIgPSB2OworICAgICAgICByZXR1cm4gdjsKIH0KIAogLyoqCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaHYvb3NkLmMgYi9kcml2ZXJzL3N0YWdpbmcvaHYvb3NkLmMKaW5kZXggOGZlNTQzYi4uM2E0NzkzYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2h2L29zZC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9odi9vc2QuYwpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2lvcG9ydC5oPgogI2luY2x1ZGUgPGxpbnV4L2lycS5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvd2FpdC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvd29ya3F1ZXVlLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL0tjb25maWcgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL0tjb25maWcKaW5kZXggYmViOTlhNS4uNDU4NjY1MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9LY29uZmlnCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vS2NvbmZpZwpAQCAtNCw2ICs0LDcgQEAKIAogbWVudWNvbmZpZyBJSU8KIAl0cmlzdGF0ZSAiSW5kdXN0cmlhbCBJL08gc3VwcG9ydCIKKwlkZXBlbmRzIG9uICFTMzkwCiAJLS0taGVscC0tLQogCSAgVGhlIGluZHVzdHJpYWwgSS9PIHN1YnN5c3RlbSBwcm92aWRlcyBhIHVuaWZpZWQgZnJhbWV3b3JrIGZvcgogCSAgZHJpdmVycyBmb3IgbWFueSBkaWZmZXJlbnQgdHlwZXMgb2YgZW1iZWRkZWQgc2Vuc29ycyB1c2luZyBhCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvaWlvL2luZHVzdHJpYWxpby1jb3JlLmMgYi9kcml2ZXJzL3N0YWdpbmcvaWlvL2luZHVzdHJpYWxpby1jb3JlLmMKaW5kZXggMWZhMThmMi4uNzY4ZjQ0OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL2lpby9pbmR1c3RyaWFsaW8tY29yZS5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9paW8vaW5kdXN0cmlhbGlvLWNvcmUuYwpAQCAtMTgsNiArMTgsOCBAQAogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CiAjaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CiAjaW5jbHVkZSA8bGludXgvcG9sbC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CisjaW5jbHVkZSA8bGludXgvd2FpdC5oPgogI2luY2x1ZGUgPGxpbnV4L2NkZXYuaD4KICNpbmNsdWRlICJpaW8uaCIKICNpbmNsdWRlICJ0cmlnZ2VyX2NvbnN1bWVyLmgiCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcDlhdXRoL3A5YXV0aC5jIGIvZHJpdmVycy9zdGFnaW5nL3A5YXV0aC9wOWF1dGguYwppbmRleCA5MTExZGNiLi44Y2NmZmY3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcDlhdXRoL3A5YXV0aC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9wOWF1dGgvcDlhdXRoLmMKQEAgLTE4Myw3ICsxODMsNyBAQAogCXVzZXJfYnVmX3J1bm5pbmcgPSBOVUxMOwogCWhhc2hfc3RyID0gTlVMTDsKIAlub2RlX3B0ciA9IGttYWxsb2Moc2l6ZW9mKHN0cnVjdCBjYXBfbm9kZSksIEdGUF9LRVJORUwpOwotCXVzZXJfYnVmID0ga3phbGxvYyhjb3VudCwgR0ZQX0tFUk5FTCk7CisJdXNlcl9idWYgPSBremFsbG9jKGNvdW50KzEsIEdGUF9LRVJORUwpOwogCWlmICghbm9kZV9wdHIgfHwgIXVzZXJfYnVmKQogCQlnb3RvIG91dDsKIApAQCAtMjA3LDYgKzIwNyw3IEBACiAJCWxpc3RfYWRkKCYobm9kZV9wdHItPmxpc3QpLCAmKGRldi0+aGVhZC0+bGlzdCkpOwogCQlub2RlX3B0ciA9IE5VTEw7CiAJfSBlbHNlIHsKKwkJY2hhciAqdG1wdTsKIAkJaWYgKCFjYXBfZGV2aWNlc1swXS5oZWFkIHx8CiAJCQkJbGlzdF9lbXB0eSgmKGNhcF9kZXZpY2VzWzBdLmhlYWQtPmxpc3QpKSkgewogCQkJcmV0dmFsID0gLUVJTlZBTDsKQEAgLTIxOCwxMCArMjE5LDEwIEBACiAJCSAqIG5lZWQgdG8gc3BsaXQgaXQgYW5kIGhhc2ggJ3VzZXIxQHVzZXIyJyB1c2luZyAncmFuZG9tc3RyaW5nJwogCQkgKiBhcyB0aGUga2V5LgogCQkgKi8KLQkJdXNlcl9idWZfcnVubmluZyA9IGtzdHJkdXAodXNlcl9idWYsIEdGUF9LRVJORUwpOwotCQlzb3VyY2VfdXNlciA9IHN0cnNlcCgmdXNlcl9idWZfcnVubmluZywgIkAiKTsKLQkJdGFyZ2V0X3VzZXIgPSBzdHJzZXAoJnVzZXJfYnVmX3J1bm5pbmcsICJAIik7Ci0JCXJhbmRfc3RyID0gc3Ryc2VwKCZ1c2VyX2J1Zl9ydW5uaW5nLCAiQCIpOworCQl0bXB1ID0gdXNlcl9idWZfcnVubmluZyA9IGtzdHJkdXAodXNlcl9idWYsIEdGUF9LRVJORUwpOworCQlzb3VyY2VfdXNlciA9IHN0cnNlcCgmdG1wdSwgIkAiKTsKKwkJdGFyZ2V0X3VzZXIgPSBzdHJzZXAoJnRtcHUsICJAIik7CisJCXJhbmRfc3RyID0gdG1wdTsKIAkJaWYgKCFzb3VyY2VfdXNlciB8fCAhdGFyZ2V0X3VzZXIgfHwgIXJhbmRfc3RyKSB7CiAJCQlyZXR2YWwgPSAtRUlOVkFMOwogCQkJZ290byBvdXQ7CkBAIC0yMjksNyArMjMwLDggQEAKIAogCQkvKiBoYXNoIHRoZSBzdHJpbmcgdXNlcjFAdXNlcjIgd2l0aCByYW5kX3N0ciBhcyB0aGUga2V5ICovCiAJCWxlbiA9IHN0cmxlbihzb3VyY2VfdXNlcikgKyBzdHJsZW4odGFyZ2V0X3VzZXIpICsgMTsKLQkJaGFzaF9zdHIgPSBremFsbG9jKGxlbiwgR0ZQX0tFUk5FTCk7CisJCS8qIHNyYywgQCwgbGVuLCBcMCAqLworCQloYXNoX3N0ciA9IGt6YWxsb2MobGVuKzEsIEdGUF9LRVJORUwpOwogCQlzdHJjYXQoaGFzaF9zdHIsIHNvdXJjZV91c2VyKTsKIAkJc3RyY2F0KGhhc2hfc3RyLCAiQCIpOwogCQlzdHJjYXQoaGFzaF9zdHIsIHRhcmdldF91c2VyKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9wb2NoL3BvY2guYyBiL2RyaXZlcnMvc3RhZ2luZy9wb2NoL3BvY2guYwppbmRleCAwZDExMWRkLi4yZWI4ZTNkIDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcG9jaC9wb2NoLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3BvY2gvcG9jaC5jCkBAIC0yMCw2ICsyMCw3IEBACiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgogI2luY2x1ZGUgPGxpbnV4L2lvY3RsLmg+CiAjaW5jbHVkZSA8bGludXgvaW8uaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogCiAjaW5jbHVkZSAicG9jaC5oIgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fZGF0YV8yODYwLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1fZGF0YV8yODYwLmMKaW5kZXggZmIxNzM1NS4uODU3ZmY0NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX2RhdGFfMjg2MC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9kYXRhXzI4NjAuYwpAQCAtMzYzLDYgKzM2Myw4IEBACiAJVUxPTkcJCQlTd0lkeCA9IHBBZC0+TWdtdFJpbmcuVHhDcHVJZHg7CiAKIAlwVHhEICA9IChQVFhEX1NUUlVDKSBwQWQtPk1nbXRSaW5nLkNlbGxbU3dJZHhdLkFsbG9jVmE7CisJaWYgKCFwVHhEKQorCQlyZXR1cm4gMDsKIAogCXBBZC0+TWdtdFJpbmcuQ2VsbFtTd0lkeF0ucE5kaXNQYWNrZXQgPSBwUGFja2V0OwogCXBBZC0+TWdtdFJpbmcuQ2VsbFtTd0lkeF0ucE5leHROZGlzUGFja2V0ID0gTlVMTDsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9pbmZvLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL2NvbW1vbi9jbW1faW5mby5jCmluZGV4IDlkNTg5YzIuLjAxOWNjNDQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvY29tbW9uL2NtbV9pbmZvLmMKKysrIGIvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9jb21tb24vY21tX2luZm8uYwpAQCAtMjUsNiArMjUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCiAKKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgIi4uL3J0X2NvbmZpZy5oIgogCiBJTlQJU2hvd19TU0lEX1Byb2MoCmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3J0X2xpbnV4LmMgYi9kcml2ZXJzL3N0YWdpbmcvcnQyODYwL3J0X2xpbnV4LmMKaW5kZXggYjM5NmE5Yi4uZWQyN2I4NSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3J0Mjg2MC9ydF9saW51eC5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDI4NjAvcnRfbGludXguYwpAQCAtMjUsNiArMjUsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqLwogCisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlICJydF9jb25maWcuaCIKIAogVUxPTkcJUlREZWJ1Z0xldmVsID0gUlRfREVCVUdfRVJST1I7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvcnQzMDkwL2NvbW1vbi9jbW1faW5mby5jIGIvZHJpdmVycy9zdGFnaW5nL3J0MzA5MC9jb21tb24vY21tX2luZm8uYwppbmRleCA1YmUwNzE0Li4zZTUxZTk4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnQzMDkwL2NvbW1vbi9jbW1faW5mby5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy9ydDMwOTAvY29tbW9uL2NtbV9pbmZvLmMKQEAgLTM0LDYgKzM0LDcgQEAKICAgICAtLS0tLS0tLS0gICAgLS0tLS0tLS0tLSAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSAiLi4vcnRfY29uZmlnLmgiCiAKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0MzA5MC9ydF9saW51eC5jIGIvZHJpdmVycy9zdGFnaW5nL3J0MzA5MC9ydF9saW51eC5jCmluZGV4IGQyMjQxZWMuLjliOTRhYTYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvc3RhZ2luZy9ydDMwOTAvcnRfbGludXguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnQzMDkwL3J0X2xpbnV4LmMKQEAgLTI1LDYgKzI1LDcgQEAKICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSAicnRfY29uZmlnLmgiCiAKIFVMT05HCVJURGVidWdMZXZlbCA9IFJUX0RFQlVHX0VSUk9SOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3J0bDgxOTJlL3I4MTkyRV9jb3JlLmMgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvcjgxOTJFX2NvcmUuYwppbmRleCBkNGZhNjU0Li5iMDgwMmE3IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvcjgxOTJFX2NvcmUuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvcnRsODE5MmUvcjgxOTJFX2NvcmUuYwpAQCAtNDYsNiArNDYsNyBAQAogI3VuZGVmIERFQlVHX1RYX0RFU0MKIAogLy8jZGVmaW5lIENPTkZJR19SVEw4MTkyX0lPX01BUAorI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgogI2luY2x1ZGUgInI4MTkyRV9ody5oIgogI2luY2x1ZGUgInI4MTkyRS5oIgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3NlcC9zZXBfZHJpdmVyLmMgYi9kcml2ZXJzL3N0YWdpbmcvc2VwL3NlcF9kcml2ZXIuYwppbmRleCA4N2Y4YTExLi5mODkwYTE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3N0YWdpbmcvc2VwL3NlcF9kcml2ZXIuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvc2VwL3NlcF9kcml2ZXIuYwpAQCAtMzgsNiArMzgsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvcG9sbC5oPgogI2luY2x1ZGUgPGxpbnV4L3dhaXQuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgogI2luY2x1ZGUgPGxpbnV4L2Zpcm13YXJlLmg+CiAjaW5jbHVkZSA8YXNtL2lvY3RsLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL3N0YWdpbmcvdm1lL2JyaWRnZXMvdm1lX2NhOTFjeDQyLmMgYi9kcml2ZXJzL3N0YWdpbmcvdm1lL2JyaWRnZXMvdm1lX2NhOTFjeDQyLmMKaW5kZXggM2QyYTg0Yy4uZTEzOWVhZSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV9jYTkxY3g0Mi5jCisrKyBiL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy92bWVfY2E5MWN4NDIuYwpAQCAtMjUsNiArMjUsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3BvbGwuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8YXNtL3RpbWUuaD4KICNpbmNsdWRlIDxhc20vaW8uaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV90c2kxNDguYyBiL2RyaXZlcnMvc3RhZ2luZy92bWUvYnJpZGdlcy92bWVfdHNpMTQ4LmMKaW5kZXggODk2MGZhOS4uMDBmZTA4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3ZtZS9icmlkZ2VzL3ZtZV90c2kxNDguYworKysgYi9kcml2ZXJzL3N0YWdpbmcvdm1lL2JyaWRnZXMvdm1lX3RzaTE0OC5jCkBAIC0yNSw2ICsyNSw3IEBACiAjaW5jbHVkZSA8bGludXgvZG1hLW1hcHBpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KICNpbmNsdWRlIDxsaW51eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8YXNtL3RpbWUuaD4KICNpbmNsdWRlIDxhc20vaW8uaD4KICNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9zdGFnaW5nL3dpbmJvbmQvd2J1c2IuYyBiL2RyaXZlcnMvc3RhZ2luZy93aW5ib25kL3didXNiLmMKaW5kZXggODk1MDcyNC4uMDY3MDgyYSAxMDA2NDQKLS0tIGEvZHJpdmVycy9zdGFnaW5nL3dpbmJvbmQvd2J1c2IuYworKysgYi9kcml2ZXJzL3N0YWdpbmcvd2luYm9uZC93YnVzYi5jCkBAIC01MSwxMCArNTEsMjYgQEAKIAkubl9iaXRyYXRlcwk9IEFSUkFZX1NJWkUod2Jzb2Z0X3JhdGVzKSwKIH07CiAKK3N0YXRpYyB2b2lkIGhhbF9zZXRfYmVhY29uX3BlcmlvZChzdHJ1Y3QgaHdfZGF0YSAqcEh3RGF0YSwgdTE2IGJlYWNvbl9wZXJpb2QpCit7CisJdTMyIHRtcDsKKworCWlmIChwSHdEYXRhLT5TdXJwcmlzZVJlbW92ZSkKKwkJcmV0dXJuOworCisJcEh3RGF0YS0+QmVhY29uUGVyaW9kID0gYmVhY29uX3BlcmlvZDsKKwl0bXAgPSBwSHdEYXRhLT5CZWFjb25QZXJpb2QgPDwgMTY7CisJdG1wIHw9IHBId0RhdGEtPlByb2JlRGVsYXk7CisJV2IzNVJlZ19Xcml0ZShwSHdEYXRhLCAweDA4NDgsIHRtcCk7Cit9CisKIHN0YXRpYyBpbnQgd2Jzb2Z0X2FkZF9pbnRlcmZhY2Uoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2LAogCQkJCXN0cnVjdCBpZWVlODAyMTFfaWZfaW5pdF9jb25mICpjb25mKQogewotCXByaW50aygid2Jzb2Z0X2FkZCBpbnRlcmZhY2UgY2FsbGVkXG4iKTsKKwlzdHJ1Y3Qgd2Jzb2Z0X3ByaXYgKnByaXYgPSBkZXYtPnByaXY7CisKKwloYWxfc2V0X2JlYWNvbl9wZXJpb2QoJnByaXYtPnNId0RhdGEsIGNvbmYtPnZpZi0+YnNzX2NvbmYuYmVhY29uX2ludCk7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtODMsMTAgKzk5LDE2IEBACiAJcmV0dXJuIDA7CiB9CiAKK3N0YXRpYyB1NjQgd2Jzb2Z0X3ByZXBhcmVfbXVsdGljYXN0KHN0cnVjdCBpZWVlODAyMTFfaHcgKmh3LCBpbnQgbWNfY291bnQsCisJCQkJICAgIHN0cnVjdCBkZXZfYWRkcl9saXN0ICptY19saXN0KQoreworCXJldHVybiBtY19jb3VudDsKK30KKwogc3RhdGljIHZvaWQgd2Jzb2Z0X2NvbmZpZ3VyZV9maWx0ZXIoc3RydWN0IGllZWU4MDIxMV9odyAqZGV2LAogCQkJCSAgICB1bnNpZ25lZCBpbnQgY2hhbmdlZF9mbGFncywKIAkJCQkgICAgdW5zaWduZWQgaW50ICp0b3RhbF9mbGFncywKLQkJCQkgICAgaW50IG1jX2NvdW50LCBzdHJ1Y3QgZGV2X21jX2xpc3QgKm1jbGlzdCkKKwkJCQkgICAgdTY0IG11bHRpY2FzdCkKIHsKIAl1bnNpZ25lZCBpbnQgbmV3X2ZsYWdzOwogCkBAIC05NCw3ICsxMTYsNyBAQAogCiAJaWYgKCp0b3RhbF9mbGFncyAmIEZJRl9QUk9NSVNDX0lOX0JTUykKIAkJbmV3X2ZsYWdzIHw9IEZJRl9QUk9NSVNDX0lOX0JTUzsKLQllbHNlIGlmICgoKnRvdGFsX2ZsYWdzICYgRklGX0FMTE1VTFRJKSB8fCAobWNfY291bnQgPiAzMikpCisJZWxzZSBpZiAoKCp0b3RhbF9mbGFncyAmIEZJRl9BTExNVUxUSSkgfHwgKG11bHRpY2FzdCA+IDMyKSkKIAkJbmV3X2ZsYWdzIHw9IEZJRl9BTExNVUxUSTsKIAogCWRldi0+ZmxhZ3MgJj0gfklFRUU4MDIxMV9IV19SWF9JTkNMVURFU19GQ1M7CkBAIC0xMzgsMTkgKzE2MCw2IEBACiAJV2IzNVJlZ19Xcml0ZShwSHdEYXRhLCAweDA4MjQsIHJlZy0+TTI0X01hY0NvbnRyb2wpOwogfQogCi1zdGF0aWMgdm9pZCBoYWxfc2V0X2JlYWNvbl9wZXJpb2Qoc3RydWN0IGh3X2RhdGEgKnBId0RhdGEsIHUxNiBiZWFjb25fcGVyaW9kKQotewotCXUzMiB0bXA7Ci0KLQlpZiAocEh3RGF0YS0+U3VycHJpc2VSZW1vdmUpCi0JCXJldHVybjsKLQotCXBId0RhdGEtPkJlYWNvblBlcmlvZCA9IGJlYWNvbl9wZXJpb2Q7Ci0JdG1wID0gcEh3RGF0YS0+QmVhY29uUGVyaW9kIDw8IDE2OwotCXRtcCB8PSBwSHdEYXRhLT5Qcm9iZURlbGF5OwotCVdiMzVSZWdfV3JpdGUocEh3RGF0YSwgMHgwODQ4LCB0bXApOwotfQotCiBzdGF0aWMgdm9pZAogaGFsX3NldF9jdXJyZW50X2NoYW5uZWxfZXgoc3RydWN0IGh3X2RhdGEgKnBId0RhdGEsIENoYW5JbmZvIGNoYW5uZWwpCiB7CkBAIC0yNDQsNyArMjUzLDYgQEAKIHN0YXRpYyBpbnQgd2Jzb2Z0X2NvbmZpZyhzdHJ1Y3QgaWVlZTgwMjExX2h3ICpkZXYsIHUzMiBjaGFuZ2VkKQogewogCXN0cnVjdCB3YnNvZnRfcHJpdiAqcHJpdiA9IGRldi0+cHJpdjsKLQlzdHJ1Y3QgaWVlZTgwMjExX2NvbmYgKmNvbmYgPSAmZGV2LT5jb25mOwogCUNoYW5JbmZvIGNoOwogCiAJcHJpbnRrKCJ3YnNvZnRfY29uZmlnIGNhbGxlZFxuIik7CkBAIC0yNTQsNyArMjYyLDYgQEAKIAljaC5DaGFuTm8gPSAxOwogCiAJaGFsX3NldF9jdXJyZW50X2NoYW5uZWwoJnByaXYtPnNId0RhdGEsIGNoKTsKLQloYWxfc2V0X2JlYWNvbl9wZXJpb2QoJnByaXYtPnNId0RhdGEsIGNvbmYtPmJlYWNvbl9pbnQpOwogCWhhbF9zZXRfYWNjZXB0X2Jyb2FkY2FzdCgmcHJpdi0+c0h3RGF0YSwgMSk7CiAJaGFsX3NldF9hY2NlcHRfcHJvbWlzY3VvdXMoJnByaXYtPnNId0RhdGEsIDEpOwogCWhhbF9zZXRfYWNjZXB0X211bHRpY2FzdCgmcHJpdi0+c0h3RGF0YSwgMSk7CkBAIC0yNzcsNiArMjg0LDcgQEAKIAkuYWRkX2ludGVyZmFjZQkJPSB3YnNvZnRfYWRkX2ludGVyZmFjZSwKIAkucmVtb3ZlX2ludGVyZmFjZQk9IHdic29mdF9yZW1vdmVfaW50ZXJmYWNlLAogCS5jb25maWcJCQk9IHdic29mdF9jb25maWcsCisJLnByZXBhcmVfbXVsdGljYXN0CT0gd2Jzb2Z0X3ByZXBhcmVfbXVsdGljYXN0LAogCS5jb25maWd1cmVfZmlsdGVyCT0gd2Jzb2Z0X2NvbmZpZ3VyZV9maWx0ZXIsCiAJLmdldF9zdGF0cwkJPSB3YnNvZnRfZ2V0X3N0YXRzLAogCS5nZXRfdHhfc3RhdHMJCT0gd2Jzb2Z0X2dldF90eF9zdGF0cywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdWlvL3Vpby5jIGIvZHJpdmVycy91aW8vdWlvLmMKaW5kZXggYTlkNzA3MC4uZTk0MTM2NyAxMDA2NDQKLS0tIGEvZHJpdmVycy91aW8vdWlvLmMKKysrIGIvZHJpdmVycy91aW8vdWlvLmMKQEAgLTE5LDYgKzE5LDcgQEAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxpbnV4L2lkci5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgva29iamVjdC5oPgogI2luY2x1ZGUgPGxpbnV4L3Vpb19kcml2ZXIuaD4KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2NsYXNzL3VzYnRtYy5jIGIvZHJpdmVycy91c2IvY2xhc3MvdXNidG1jLmMKaW5kZXggODY0ZjBiYS4uMjQ3M2NmMCAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvY2xhc3MvdXNidG1jLmMKKysrIGIvZHJpdmVycy91c2IvY2xhc3MvdXNidG1jLmMKQEAgLTM5LDcgKzM5LDcgQEAKICNkZWZpbmUgVVNCVE1DX1NJWkVfSU9CVUZGRVIJMjA0OAogCiAvKiBEZWZhdWx0IFVTQiB0aW1lb3V0IChpbiBtaWxsaXNlY29uZHMpICovCi0jZGVmaW5lIFVTQlRNQ19USU1FT1VUCQkxMAorI2RlZmluZSBVU0JUTUNfVElNRU9VVAkJNTAwMAogCiAvKgogICogTWF4aW11bSBudW1iZXIgb2YgcmVhZCBjeWNsZXMgdG8gZW1wdHkgYnVsayBpbiBlbmRwb2ludCBkdXJpbmcgQ0xFQVIgYW5kCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvZXRoZXIuYyBiL2RyaXZlcnMvdXNiL2dhZGdldC9ldGhlci5jCmluZGV4IGYzN2RlMjguLjE2N2NiMmEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2dhZGdldC9ldGhlci5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9ldGhlci5jCkBAIC02MSwxMSArNjEsNiBAQAogICogc2ltcGxlciwgTWljcm9zb2Z0IHB1c2hlcyB0aGVpciBvd24gYXBwcm9hY2g6IFJORElTLiAgVGhlIHB1Ymxpc2hlZAogICogUk5ESVMgc3BlY3MgYXJlIGFtYmlndW91cyBhbmQgYXBwZWFyIHRvIGJlIGluY29tcGxldGUsIGFuZCBhcmUgYWxzbwogICogbmVlZGxlc3NseSBjb21wbGV4LiAgVGhleSBib3Jyb3cgbW9yZSBmcm9tIENEQyBBQ00gdGhhbiBDREMgRUNNLgotICoKLSAqIFdoaWxlIENEQyBFQ00sIENEQyBTdWJzZXQsIGFuZCBSTkRJUyBhcmUgZGVzaWduZWQgdG8gZXh0ZW5kIHRoZSBldGhlcm5ldAotICogaW50ZXJmYWNlIHRvIHRoZSB0YXJnZXQsIENEQyBFRU0gd2FzIGRlc2lnbmVkIHRvIHVzZSBldGhlcm5ldCBvdmVyIHRoZSBVU0IKLSAqIGxpbmsgYmV0d2VlbiB0aGUgaG9zdCBhbmQgdGFyZ2V0LiAgQ0RDIEVFTSBpcyBpbXBsZW1lbnRlZCBhcyBhbiBhbHRlcm5hdGl2ZQotICogdG8gdGhvc2Ugb3RoZXIgcHJvdG9jb2xzIHdoZW4gdGhhdCBjb21tdW5pY2F0aW9uIG1vZGVsIGlzIG1vcmUgYXBwcm9wcmlhdGUKICAqLwogCiAjZGVmaW5lIERSSVZFUl9ERVNDCQkiRXRoZXJuZXQgR2FkZ2V0IgpAQCAtMTU3LDggKzE1Miw4IEBACiAjZGVmaW5lIFJORElTX1BST0RVQ1RfTlVNCTB4YTRhMgkvKiBFdGhlcm5ldC9STkRJUyBHYWRnZXQgKi8KIAogLyogRm9yIEVFTSBnYWRnZXRzICovCi0jZGVmaW5lIEVFTV9WRU5ET1JfTlVNCTB4MDUyNQkvKiBJTlZBTElEIC0gTkVFRFMgVE8gQkUgQUxMT0NBVEVEICovCi0jZGVmaW5lIEVFTV9QUk9EVUNUX05VTQkweGE0YTEJLyogSU5WQUxJRCAtIE5FRURTIFRPIEJFIEFMTE9DQVRFRCAqLworI2RlZmluZSBFRU1fVkVORE9SX05VTQkJMHgxZDZiCS8qIExpbnV4IEZvdW5kYXRpb24gKi8KKyNkZWZpbmUgRUVNX1BST0RVQ1RfTlVNCQkweDAxMDIJLyogRUVNIEdhZGdldCAqLwogCiAvKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvaW14X3VkYy5jIGIvZHJpdmVycy91c2IvZ2FkZ2V0L2lteF91ZGMuYwppbmRleCBjNTJhNjgxLi4wMWVlMGI5IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9nYWRnZXQvaW14X3VkYy5jCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9pbXhfdWRjLmMKQEAgLTE0MDIsNyArMTQwMiw4IEBACiAJc3RydWN0IGNsayAqY2xrOwogCXZvaWQgX19pb21lbSAqYmFzZTsKIAlpbnQgcmV0ID0gMDsKLQlpbnQgaSwgcmVzX3NpemU7CisJaW50IGk7CisJcmVzb3VyY2Vfc2l6ZV90IHJlc19zaXplOwogCiAJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAwKTsKIAlpZiAoIXJlcykgewpAQCAtMTQxNiw3ICsxNDE3LDcgQEAKIAkJcmV0dXJuIC1FTk9ERVY7CiAJfQogCi0JcmVzX3NpemUgPSByZXMtPmVuZCAtIHJlcy0+c3RhcnQgKyAxOworCXJlc19zaXplID0gcmVzb3VyY2Vfc2l6ZShyZXMpOwogCWlmICghcmVxdWVzdF9tZW1fcmVnaW9uKHJlcy0+c3RhcnQsIHJlc19zaXplLCByZXMtPm5hbWUpKSB7CiAJCWRldl9lcnIoJnBkZXYtPmRldiwgImNhbid0IGFsbG9jYXRlICVkIGJ5dGVzIGF0ICVkIGFkZHJlc3NcbiIsCiAJCQlyZXNfc2l6ZSwgcmVzLT5zdGFydCk7CkBAIC0xNTI3LDggKzE1MjgsNyBAQAogCWNsa19kaXNhYmxlKGlteF91c2ItPmNsayk7CiAJaW91bm1hcChpbXhfdXNiLT5iYXNlKTsKIAotCXJlbGVhc2VfbWVtX3JlZ2lvbihpbXhfdXNiLT5yZXMtPnN0YXJ0LAotCQlpbXhfdXNiLT5yZXMtPmVuZCAtIGlteF91c2ItPnJlcy0+c3RhcnQgKyAxKTsKKwlyZWxlYXNlX21lbV9yZWdpb24oaW14X3VzYi0+cmVzLT5zdGFydCwgcmVzb3VyY2Vfc2l6ZShpbXhfdXNiLT5yZXMpKTsKIAogCWlmIChwZGF0YS0+ZXhpdCkKIAkJcGRhdGEtPmV4aXQoJnBkZXYtPmRldik7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9nYWRnZXQvcjhhNjY1OTctdWRjLmggYi9kcml2ZXJzL3VzYi9nYWRnZXQvcjhhNjY1OTctdWRjLmgKaW5kZXggMDMwODdlNy4uOWE1MzdhYSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvZ2FkZ2V0L3I4YTY2NTk3LXVkYy5oCisrKyBiL2RyaXZlcnMvdXNiL2dhZGdldC9yOGE2NjU5Ny11ZGMuaApAQCAtMTMxLDMxICsxMzEsNDggQEAKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIHI4YTY2NTk3X3JlYWRfZmlmbyhzdHJ1Y3QgcjhhNjY1OTcgKnI4YTY2NTk3LAotCQkJCSAgICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1MTYgKmJ1ZiwKKwkJCQkgICAgICB1bnNpZ25lZCBsb25nIG9mZnNldCwKKwkJCQkgICAgICB1bnNpZ25lZCBjaGFyICpidWYsCiAJCQkJICAgICAgaW50IGxlbikKIHsKKwl1bnNpZ25lZCBsb25nIGZpZm9hZGRyID0gcjhhNjY1OTctPnJlZyArIG9mZnNldDsKKwl1bnNpZ25lZCBpbnQgZGF0YTsKKwlpbnQgaTsKKwogCWlmIChyOGE2NjU5Ny0+cGRhdGEtPm9uX2NoaXApIHsKLQkJdW5zaWduZWQgbG9uZyBmaWZvYWRkciA9IHI4YTY2NTk3LT5yZWcgKyBvZmZzZXQ7Ci0JCXVuc2lnbmVkIGxvbmcgY291bnQ7Ci0JCXVuaW9uIHsKLQkJCXVuc2lnbmVkIGxvbmcgZHdvcmQ7Ci0JCQl1bnNpZ25lZCBjaGFyIGJ5dGVbNF07Ci0JCX0gZGF0YTsKLQkJdW5zaWduZWQgY2hhciAqcGI7Ci0JCWludCBpOworCQkvKiAzMi1iaXQgYWNjZXNzZXMgZm9yIG9uX2NoaXAgY29udHJvbGxlcnMgKi8KIAotCQljb3VudCA9IGxlbiAvIDQ7Ci0JCWluc2woZmlmb2FkZHIsIGJ1ZiwgY291bnQpOworCQkvKiBhbGlnbmVkIGJ1ZiBjYXNlICovCisJCWlmIChsZW4gPj0gNCAmJiAhKCh1bnNpZ25lZCBsb25nKWJ1ZiAmIDB4MDMpKSB7CisJCQlpbnNsKGZpZm9hZGRyLCBidWYsIGxlbiAvIDQpOworCQkJYnVmICs9IGxlbiAmIH4weDAzOworCQkJbGVuICY9IDB4MDM7CisJCX0KIAotCQlpZiAobGVuICYgMHgwMDAwMDAwMykgewotCQkJZGF0YS5kd29yZCA9IGlubChmaWZvYWRkcik7Ci0JCQlwYiA9ICh1bnNpZ25lZCBjaGFyICopYnVmICsgY291bnQgKiA0OwotCQkJZm9yIChpID0gMDsgaSA8IChsZW4gJiAweDAwMDAwMDAzKTsgaSsrKQotCQkJCXBiW2ldID0gZGF0YS5ieXRlW2ldOworCQkvKiB1bmFsaWduZWQgYnVmIGNhc2UgKi8KKwkJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKSB7CisJCQlpZiAoIShpICYgMHgwMykpCisJCQkJZGF0YSA9IGlubChmaWZvYWRkcik7CisKKwkJCWJ1ZltpXSA9IChkYXRhID4+ICgoaSAmIDB4MDMpICogOCkpICYgMHhmZjsKIAkJfQogCX0gZWxzZSB7Ci0JCWxlbiA9IChsZW4gKyAxKSAvIDI7Ci0JCWluc3cocjhhNjY1OTctPnJlZyArIG9mZnNldCwgYnVmLCBsZW4pOworCQkvKiAxNi1iaXQgYWNjZXNzZXMgZm9yIGV4dGVybmFsIGNvbnRyb2xsZXJzICovCisKKwkJLyogYWxpZ25lZCBidWYgY2FzZSAqLworCQlpZiAobGVuID49IDIgJiYgISgodW5zaWduZWQgbG9uZylidWYgJiAweDAxKSkgeworCQkJaW5zdyhmaWZvYWRkciwgYnVmLCBsZW4gLyAyKTsKKwkJCWJ1ZiArPSBsZW4gJiB+MHgwMTsKKwkJCWxlbiAmPSAweDAxOworCQl9CisKKwkJLyogdW5hbGlnbmVkIGJ1ZiBjYXNlICovCisJCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykgeworCQkJaWYgKCEoaSAmIDB4MDEpKQorCQkJCWRhdGEgPSBpbncoZmlmb2FkZHIpOworCisJCQlidWZbaV0gPSAoZGF0YSA+PiAoKGkgJiAweDAxKSAqIDgpKSAmIDB4ZmY7CisJCX0KIAl9CiB9CiAKQEAgLTE2NiwzOCArMTgzLDQwIEBACiB9CiAKIHN0YXRpYyBpbmxpbmUgdm9pZCByOGE2NjU5N193cml0ZV9maWZvKHN0cnVjdCByOGE2NjU5NyAqcjhhNjY1OTcsCi0JCQkJICAgICAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCB1MTYgKmJ1ZiwKKwkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBvZmZzZXQsCisJCQkJICAgICAgIHVuc2lnbmVkIGNoYXIgKmJ1ZiwKIAkJCQkgICAgICAgaW50IGxlbikKIHsKIAl1bnNpZ25lZCBsb25nIGZpZm9hZGRyID0gcjhhNjY1OTctPnJlZyArIG9mZnNldDsKKwlpbnQgYWRqID0gMDsKKwlpbnQgaTsKIAogCWlmIChyOGE2NjU5Ny0+cGRhdGEtPm9uX2NoaXApIHsKLQkJdW5zaWduZWQgbG9uZyBjb3VudDsKLQkJdW5zaWduZWQgY2hhciAqcGI7Ci0JCWludCBpOwotCi0JCWNvdW50ID0gbGVuIC8gNDsKLQkJb3V0c2woZmlmb2FkZHIsIGJ1ZiwgY291bnQpOwotCi0JCWlmIChsZW4gJiAweDAwMDAwMDAzKSB7Ci0JCQlwYiA9ICh1bnNpZ25lZCBjaGFyICopYnVmICsgY291bnQgKiA0OwotCQkJZm9yIChpID0gMDsgaSA8IChsZW4gJiAweDAwMDAwMDAzKTsgaSsrKSB7Ci0JCQkJaWYgKHI4YTY2NTk3X3JlYWQocjhhNjY1OTcsIENGSUZPU0VMKSAmIEJJR0VORCkKLQkJCQkJb3V0YihwYltpXSwgZmlmb2FkZHIgKyBpKTsKLQkJCQllbHNlCi0JCQkJCW91dGIocGJbaV0sIGZpZm9hZGRyICsgMyAtIGkpOwotCQkJfQorCQkvKiAzMi1iaXQgYWNjZXNzIG9ubHkgaWYgYnVmIGlzIDMyLWJpdCBhbGlnbmVkICovCisJCWlmIChsZW4gPj0gNCAmJiAhKCh1bnNpZ25lZCBsb25nKWJ1ZiAmIDB4MDMpKSB7CisJCQlvdXRzbChmaWZvYWRkciwgYnVmLCBsZW4gLyA0KTsKKwkJCWJ1ZiArPSBsZW4gJiB+MHgwMzsKKwkJCWxlbiAmPSAweDAzOwogCQl9CiAJfSBlbHNlIHsKLQkJaW50IG9kZCA9IGxlbiAmIDB4MDAwMTsKLQotCQlsZW4gPSBsZW4gLyAyOwotCQlvdXRzdyhmaWZvYWRkciwgYnVmLCBsZW4pOwotCQlpZiAodW5saWtlbHkob2RkKSkgewotCQkJYnVmID0gJmJ1ZltsZW5dOwotCQkJb3V0YigodW5zaWduZWQgY2hhcikqYnVmLCBmaWZvYWRkcik7CisJCS8qIDE2LWJpdCBhY2Nlc3Mgb25seSBpZiBidWYgaXMgMTYtYml0IGFsaWduZWQgKi8KKwkJaWYgKGxlbiA+PSAyICYmICEoKHVuc2lnbmVkIGxvbmcpYnVmICYgMHgwMSkpIHsKKwkJCW91dHN3KGZpZm9hZGRyLCBidWYsIGxlbiAvIDIpOworCQkJYnVmICs9IGxlbiAmIH4weDAxOworCQkJbGVuICY9IDB4MDE7CiAJCX0KIAl9CisKKwkvKiBhZGp1c3QgZmlmbyBhZGRyZXNzIGluIHRoZSBsaXR0bGUgZW5kaWFuIGNhc2UgKi8KKwlpZiAoIShyOGE2NjU5N19yZWFkKHI4YTY2NTk3LCBDRklGT1NFTCkgJiBCSUdFTkQpKSB7CisJCWlmIChyOGE2NjU5Ny0+cGRhdGEtPm9uX2NoaXApCisJCQlhZGogPSAweDAzOyAvKiAzMi1iaXQgd2lkZSAqLworCQllbHNlCisJCQlhZGogPSAweDAxOyAvKiAxNi1iaXQgd2lkZSAqLworCX0KKworCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKykKKwkJb3V0YihidWZbaV0sIGZpZm9hZGRyICsgYWRqIC0gKGkgJiBhZGopKTsKIH0KIAogc3RhdGljIGlubGluZSB2b2lkIHI4YTY2NTk3X21kZnkoc3RydWN0IHI4YTY2NTk3ICpyOGE2NjU5NywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3QvZWhjaS1zY2hlZC5jIGIvZHJpdmVycy91c2IvaG9zdC9laGNpLXNjaGVkLmMKaW5kZXggM2VhMDU5My4uYjI1Y2RlYSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC9laGNpLXNjaGVkLmMKKysrIGIvZHJpdmVycy91c2IvaG9zdC9laGNpLXNjaGVkLmMKQEAgLTE0MDAsNiArMTQwMCwxMCBAQAogCQlnb3RvIGZhaWw7CiAJfQogCisJcGVyaW9kID0gdXJiLT5pbnRlcnZhbDsKKwlpZiAoIXN0cmVhbS0+aGlnaHNwZWVkKQorCQlwZXJpb2QgPDw9IDM7CisKIAlub3cgPSBlaGNpX3JlYWRsKGVoY2ksICZlaGNpLT5yZWdzLT5mcmFtZV9pbmRleCkgJSBtb2Q7CiAKIAkvKiB3aGVuJ3MgdGhlIGxhc3QgdWZyYW1lIHRoaXMgdXJiIGNvdWxkIHN0YXJ0PyAqLwpAQCAtMTQxNywxNCArMTQyMSwxNSBAQAogCiAJCS8qIEZlbGwgYmVoaW5kIChieSB1cCB0byB0d2ljZSB0aGUgc2xvcCBhbW91bnQpPyAqLwogCQlpZiAoc3RhcnQgPj0gbWF4IC0gMiAqIDggKiBTQ0hFRFVMRV9TTE9QKQotCQkJc3RhcnQgKz0gc3RyZWFtLT5pbnRlcnZhbCAqIERJVl9ST1VORF9VUCgKLQkJCQkJbWF4IC0gc3RhcnQsIHN0cmVhbS0+aW50ZXJ2YWwpIC0gbW9kOworCQkJc3RhcnQgKz0gcGVyaW9kICogRElWX1JPVU5EX1VQKAorCQkJCQltYXggLSBzdGFydCwgcGVyaW9kKSAtIG1vZDsKIAogCQkvKiBUcmllZCB0byBzY2hlZHVsZSB0b28gZmFyIGludG8gdGhlIGZ1dHVyZT8gKi8KIAkJaWYgKHVubGlrZWx5KChzdGFydCArIHNjaGVkLT5zcGFuKSA+PSBtYXgpKSB7CiAJCQlzdGF0dXMgPSAtRUZCSUc7CiAJCQlnb3RvIGZhaWw7CiAJCX0KKwkJc3RyZWFtLT5uZXh0X3VmcmFtZSA9IHN0YXJ0OwogCQlnb3RvIHJlYWR5OwogCX0KIApAQCAtMTQ0MCwxMCArMTQ0NSw2IEBACiAKIAkvKiBOT1RFOiAgYXNzdW1lcyBVUkJfSVNPX0FTQVAsIHRvIGxpbWl0IGNvbXBsZXhpdHkvYnVncyAqLwogCi0JcGVyaW9kID0gdXJiLT5pbnRlcnZhbDsKLQlpZiAoIXN0cmVhbS0+aGlnaHNwZWVkKQotCQlwZXJpb2QgPDw9IDM7Ci0KIAkvKiBmaW5kIGEgdWZyYW1lIHNsb3Qgd2l0aCBlbm91Z2ggYmFuZHdpZHRoICovCiAJZm9yICg7IHN0YXJ0IDwgKHN0cmVhbS0+bmV4dF91ZnJhbWUgKyBwZXJpb2QpOyBzdGFydCsrKSB7CiAJCWludAkJZW5vdWdoX3NwYWNlOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9pc3AxMzYyLWhjZC5jIGIvZHJpdmVycy91c2IvaG9zdC9pc3AxMzYyLWhjZC5jCmluZGV4IGUzNWQ4MjguLjVjNzc0YWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QvaXNwMTM2Mi1oY2QuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L2lzcDEzNjItaGNkLmMKQEAgLTIyODQsMTAgKzIyODQsMTAgQEAKIAlkZXZfaW5mbyhoY2QtPnNlbGYuY29udHJvbGxlciwgIklTUDEzNjIgTWVtb3J5IHVzYWdlOlxuIik7CiAJZGV2X2luZm8oaGNkLT5zZWxmLmNvbnRyb2xsZXIsICIgIElTVEw6ICAgIDIgKiAlNGQ6ICAgICAlNGQgQCAkJTA0eDokJTA0eFxuIiwKIAkJIGlzdGxfc2l6ZSAvIDIsIGlzdGxfc2l6ZSwgMCwgaXN0bF9zaXplIC8gMik7Ci0JZGV2X2luZm8oaGNkLT5zZWxmLmNvbnRyb2xsZXIsICIgIElOVEw6ICU0ZCAqICglM3UrOCk6ICAlNGQgQCAkJTA0eFxuIiwKKwlkZXZfaW5mbyhoY2QtPnNlbGYuY29udHJvbGxlciwgIiAgSU5UTDogJTRkICogKCUzbHUrOCk6ICAlNGQgQCAkJTA0eFxuIiwKIAkJIElTUDEzNjJfSU5UTF9CVUZGRVJTLCBpbnRsX2Jsa3NpemUgLSBQVERfSEVBREVSX1NJWkUsCiAJCSBpbnRsX3NpemUsIGlzdGxfc2l6ZSk7Ci0JZGV2X2luZm8oaGNkLT5zZWxmLmNvbnRyb2xsZXIsICIgIEFUTCA6ICU0ZCAqICglM3UrOCk6ICAlNGQgQCAkJTA0eFxuIiwKKwlkZXZfaW5mbyhoY2QtPnNlbGYuY29udHJvbGxlciwgIiAgQVRMIDogJTRkICogKCUzbHUrOCk6ICAlNGQgQCAkJTA0eFxuIiwKIAkJIGF0bF9idWZmZXJzLCBhdGxfYmxrc2l6ZSAtIFBURF9IRUFERVJfU0laRSwKIAkJIGF0bF9zaXplLCBpc3RsX3NpemUgKyBpbnRsX3NpemUpOwogCWRldl9pbmZvKGhjZC0+c2VsZi5jb250cm9sbGVyLCAiICBVU0VEL0ZSRUU6ICAgJTRkICAgICAgJTRkXG4iLCB0b3RhbCwKQEAgLTI2NzcsMTIgKzI2NzcsMTIgQEAKIAlEQkcoMCwgIiVzOiBSZW1vdmluZyBIQ0RcbiIsIF9fZnVuY19fKTsKIAl1c2JfcmVtb3ZlX2hjZChoY2QpOwogCi0JREJHKDAsICIlczogVW5tYXBwaW5nIGRhdGFfcmVnIEAgJTA4eFxuIiwgX19mdW5jX18sCi0JICAgICh1MzIpaXNwMTM2Ml9oY2QtPmRhdGFfcmVnKTsKKwlEQkcoMCwgIiVzOiBVbm1hcHBpbmcgZGF0YV9yZWcgQCAlcFxuIiwgX19mdW5jX18sCisJICAgIGlzcDEzNjJfaGNkLT5kYXRhX3JlZyk7CiAJaW91bm1hcChpc3AxMzYyX2hjZC0+ZGF0YV9yZWcpOwogCi0JREJHKDAsICIlczogVW5tYXBwaW5nIGFkZHJfcmVnIEAgJTA4eFxuIiwgX19mdW5jX18sCi0JICAgICh1MzIpaXNwMTM2Ml9oY2QtPmFkZHJfcmVnKTsKKwlEQkcoMCwgIiVzOiBVbm1hcHBpbmcgYWRkcl9yZWcgQCAlcFxuIiwgX19mdW5jX18sCisJICAgIGlzcDEzNjJfaGNkLT5hZGRyX3JlZyk7CiAJaW91bm1hcChpc3AxMzYyX2hjZC0+YWRkcl9yZWcpOwogCiAJcmVzID0gcGxhdGZvcm1fZ2V0X3Jlc291cmNlKHBkZXYsIElPUkVTT1VSQ0VfTUVNLCAxKTsKQEAgLTI4MTAsMTYgKzI4MTAsMTYgQEAKIAlyZXR1cm4gMDsKIAogIGVycjY6Ci0JREJHKDAsICIlczogRnJlZWluZyBkZXYgJTA4eFxuIiwgX19mdW5jX18sICh1MzIpaXNwMTM2Ml9oY2QpOworCURCRygwLCAiJXM6IEZyZWVpbmcgZGV2ICVwXG4iLCBfX2Z1bmNfXywgaXNwMTM2Ml9oY2QpOwogCXVzYl9wdXRfaGNkKGhjZCk7CiAgZXJyNToKLQlEQkcoMCwgIiVzOiBVbm1hcHBpbmcgZGF0YV9yZWcgQCAlMDh4XG4iLCBfX2Z1bmNfXywgKHUzMilkYXRhX3JlZyk7CisJREJHKDAsICIlczogVW5tYXBwaW5nIGRhdGFfcmVnIEAgJXBcbiIsIF9fZnVuY19fLCBkYXRhX3JlZyk7CiAJaW91bm1hcChkYXRhX3JlZyk7CiAgZXJyNDoKIAlEQkcoMCwgIiVzOiBSZWxlYXNpbmcgbWVtIHJlZ2lvbiAlMDhseFxuIiwgX19mdW5jX18sIChsb25nIHVuc2lnbmVkIGludClkYXRhLT5zdGFydCk7CiAJcmVsZWFzZV9tZW1fcmVnaW9uKGRhdGEtPnN0YXJ0LCByZXNvdXJjZV9sZW4oZGF0YSkpOwogIGVycjM6Ci0JREJHKDAsICIlczogVW5tYXBwaW5nIGFkZHJfcmVnIEAgJTA4eFxuIiwgX19mdW5jX18sICh1MzIpYWRkcl9yZWcpOworCURCRygwLCAiJXM6IFVubWFwcGluZyBhZGRyX3JlZyBAICVwXG4iLCBfX2Z1bmNfXywgYWRkcl9yZWcpOwogCWlvdW5tYXAoYWRkcl9yZWcpOwogIGVycjI6CiAJREJHKDAsICIlczogUmVsZWFzaW5nIG1lbSByZWdpb24gJTA4bHhcbiIsIF9fZnVuY19fLCAobG9uZyB1bnNpZ25lZCBpbnQpYWRkci0+c3RhcnQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC9pc3AxMzYyLmggYi9kcml2ZXJzL3VzYi9ob3N0L2lzcDEzNjIuaAppbmRleCBmZTYwZjYyLi4xYTI1M2ViIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L2lzcDEzNjIuaAorKysgYi9kcml2ZXJzL3VzYi9ob3N0L2lzcDEzNjIuaApAQCAtNTgwLDcgKzU4MCw3IEBACiAKIHN0YXRpYyBpbmxpbmUgdm9pZCBBTElHTlNUQVQoc3RydWN0IGlzcDEzNjJfaGNkICppc3AxMzYyX2hjZCwgdm9pZCAqcHRyKQogewotCXVuc2lnbmVkIHAgPSAodW5zaWduZWQpcHRyOworCXVuc2lnbmVkIGxvbmcgcCA9ICh1bnNpZ25lZCBsb25nKXB0cjsKIAlpZiAoIShwICYgMHhmKSkKIAkJaXNwMTM2Ml9oY2QtPnN0YXQxNisrOwogCWVsc2UgaWYgKCEocCAmIDB4NykpCkBAIC03NzAsNyArNzcwLDcgQEAKIAlpZiAoIWxlbikKIAkJcmV0dXJuOwogCi0JaWYgKCh1bnNpZ25lZClkcCAmIDB4MSkgeworCWlmICgodW5zaWduZWQgbG9uZylkcCAmIDB4MSkgewogCQkvKiBub3QgYWxpZ25lZCAqLwogCQlmb3IgKDsgbGVuID4gMTsgbGVuIC09IDIpIHsKIAkJCWRhdGEgPSAqZHArKzsKQEAgLTk2Miw4ICs5NjIsOCBAQAogCiAJaXNwMTM2Ml93cml0ZV9kaXJhZGRyKGlzcDEzNjJfaGNkLCBvZmZzZXQsIGxlbik7CiAKLQlEQkcoMywgIiVzOiBSZWFkaW5nICVkIGJ5dGUgZnJvbSBidWZmZXIgQCUwNHggdG8gbWVtb3J5IEAgJTA4eFxuIiwgX19mdW5jX18sCi0JICAgIGxlbiwgb2Zmc2V0LCAodTMyKWJ1Zik7CisJREJHKDMsICIlczogUmVhZGluZyAlZCBieXRlIGZyb20gYnVmZmVyIEAlMDR4IHRvIG1lbW9yeSBAICVwXG4iLAorCSAgICBfX2Z1bmNfXywgbGVuLCBvZmZzZXQsIGJ1Zik7CiAKIAlpc3AxMzYyX3dyaXRlX3JlZzE2KGlzcDEzNjJfaGNkLCBIQ3VQSU5ULCBIQ3VQSU5UX0VPVCk7CiAJX1dBUk5fT04oKGlzcDEzNjJfcmVhZF9yZWcxNihpc3AxMzYyX2hjZCwgSEN1UElOVCkgJiBIQ3VQSU5UX0VPVCkpOwpAQCAtOTgyLDggKzk4Miw4IEBACiAKIAlpc3AxMzYyX3dyaXRlX2RpcmFkZHIoaXNwMTM2Ml9oY2QsIG9mZnNldCwgbGVuKTsKIAotCURCRygzLCAiJXM6IFdyaXRpbmcgJWQgYnl0ZSB0byBidWZmZXIgQCUwNHggZnJvbSBtZW1vcnkgQCAlMDh4XG4iLCBfX2Z1bmNfXywKLQkgICAgbGVuLCBvZmZzZXQsICh1MzIpYnVmKTsKKwlEQkcoMywgIiVzOiBXcml0aW5nICVkIGJ5dGUgdG8gYnVmZmVyIEAlMDR4IGZyb20gbWVtb3J5IEAgJXBcbiIsCisJICAgIF9fZnVuY19fLCBsZW4sIG9mZnNldCwgYnVmKTsKIAogCWlzcDEzNjJfd3JpdGVfcmVnMTYoaXNwMTM2Ml9oY2QsIEhDdVBJTlQsIEhDdVBJTlRfRU9UKTsKIAlfV0FSTl9PTigoaXNwMTM2Ml9yZWFkX3JlZzE2KGlzcDEzNjJfaGNkLCBIQ3VQSU5UKSAmIEhDdVBJTlRfRU9UKSk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L3BjaS1xdWlya3MuYyBiL2RyaXZlcnMvdXNiL2hvc3QvcGNpLXF1aXJrcy5jCmluZGV4IDIzY2YzYmQuLjgzYjVmOWMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3QvcGNpLXF1aXJrcy5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QvcGNpLXF1aXJrcy5jCkBAIC00NzUsNCArNDc1LDQgQEAKIAllbHNlIGlmIChwZGV2LT5jbGFzcyA9PSBQQ0lfQ0xBU1NfU0VSSUFMX1VTQl9YSENJKQogCQlxdWlya191c2JfaGFuZG9mZl94aGNpKHBkZXYpOwogfQotREVDTEFSRV9QQ0lfRklYVVBfSEVBREVSKFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIHF1aXJrX3VzYl9lYXJseV9oYW5kb2ZmKTsKK0RFQ0xBUkVfUENJX0ZJWFVQX0ZJTkFMKFBDSV9BTllfSUQsIFBDSV9BTllfSUQsIHF1aXJrX3VzYl9lYXJseV9oYW5kb2ZmKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL2hvc3Qvd2hjaS9hc2wuYyBiL2RyaXZlcnMvdXNiL2hvc3Qvd2hjaS9hc2wuYwppbmRleCBjNjMyNDM3Li41NjJlYmExIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9ob3N0L3doY2kvYXNsLmMKKysrIGIvZHJpdmVycy91c2IvaG9zdC93aGNpL2FzbC5jCkBAIC0xMTUsNiArMTE1LDEwIEBACiAJCWlmIChzdGF0dXMgJiBRVERfU1RTX0hBTFRFRCkgewogCQkJLyogVWcsIGFuIGVycm9yLiAqLwogCQkJcHJvY2Vzc19oYWx0ZWRfcXRkKHdoYywgcXNldCwgdGQpOworCQkJLyogQSBoYWx0ZWQgcVREIGFsd2F5cyB0cmlnZ2VycyBhbiB1cGRhdGUKKwkJCSAgIGJlY2F1c2UgdGhlIHFzZXQgd2FzIGVpdGhlciByZW1vdmVkIG9yCisJCQkgICByZWFjdGl2YXRlZC4gKi8KKwkJCXVwZGF0ZSB8PSBXSENfVVBEQVRFX1VQREFURUQ7CiAJCQlnb3RvIGRvbmU7CiAJCX0KIApAQCAtMzA1LDYgKzMwOSw3IEBACiAJc3RydWN0IHdoY191cmIgKnd1cmIgPSB1cmItPmhjcHJpdjsKIAlzdHJ1Y3Qgd2hjX3FzZXQgKnFzZXQgPSB3dXJiLT5xc2V0OwogCXN0cnVjdCB3aGNfc3RkICpzdGQsICp0OworCWJvb2wgaGFzX3F0ZCA9IGZhbHNlOwogCWludCByZXQ7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIApAQCAtMzE1LDE3ICszMjAsMjEgQEAKIAkJZ290byBvdXQ7CiAKIAlsaXN0X2Zvcl9lYWNoX2VudHJ5X3NhZmUoc3RkLCB0LCAmcXNldC0+c3RkcywgbGlzdF9ub2RlKSB7Ci0JCWlmIChzdGQtPnVyYiA9PSB1cmIpCisJCWlmIChzdGQtPnVyYiA9PSB1cmIpIHsKKwkJCWlmIChzdGQtPnF0ZCkKKwkJCQloYXNfcXRkID0gdHJ1ZTsKIAkJCXFzZXRfZnJlZV9zdGQod2hjLCBzdGQpOwotCQllbHNlCisJCX0gZWxzZQogCQkJc3RkLT5xdGQgPSBOVUxMOyAvKiBzbyB0aGlzIHN0ZCBpcyByZS1hZGRlZCB3aGVuIHRoZSBxc2V0IGlzICovCiAJfQogCi0JYXNsX3FzZXRfcmVtb3ZlKHdoYywgcXNldCk7Ci0Jd3VyYi0+c3RhdHVzID0gc3RhdHVzOwotCXd1cmItPmlzX2FzeW5jID0gdHJ1ZTsKLQlxdWV1ZV93b3JrKHdoYy0+d29ya3F1ZXVlLCAmd3VyYi0+ZGVxdWV1ZV93b3JrKTsKLQorCWlmIChoYXNfcXRkKSB7CisJCWFzbF9xc2V0X3JlbW92ZSh3aGMsIHFzZXQpOworCQl3dXJiLT5zdGF0dXMgPSBzdGF0dXM7CisJCXd1cmItPmlzX2FzeW5jID0gdHJ1ZTsKKwkJcXVldWVfd29yayh3aGMtPndvcmtxdWV1ZSwgJnd1cmItPmRlcXVldWVfd29yayk7CisJfSBlbHNlCisJCXFzZXRfcmVtb3ZlX3VyYih3aGMsIHFzZXQsIHVyYiwgc3RhdHVzKTsKIG91dDoKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ3aGMtPmxvY2ssIGZsYWdzKTsKIApkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvaG9zdC93aGNpL3B6bC5jIGIvZHJpdmVycy91c2IvaG9zdC93aGNpL3B6bC5jCmluZGV4IGE5ZTA1YmEuLjBkYjNmYjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL2hvc3Qvd2hjaS9wemwuYworKysgYi9kcml2ZXJzL3VzYi9ob3N0L3doY2kvcHpsLmMKQEAgLTEyMSw2ICsxMjEsMTAgQEAKIAkJaWYgKHN0YXR1cyAmIFFURF9TVFNfSEFMVEVEKSB7CiAJCQkvKiBVZywgYW4gZXJyb3IuICovCiAJCQlwcm9jZXNzX2hhbHRlZF9xdGQod2hjLCBxc2V0LCB0ZCk7CisJCQkvKiBBIGhhbHRlZCBxVEQgYWx3YXlzIHRyaWdnZXJzIGFuIHVwZGF0ZQorCQkJICAgYmVjYXVzZSB0aGUgcXNldCB3YXMgZWl0aGVyIHJlbW92ZWQgb3IKKwkJCSAgIHJlYWN0aXZhdGVkLiAqLworCQkJdXBkYXRlIHw9IFdIQ19VUERBVEVfVVBEQVRFRDsKIAkJCWdvdG8gZG9uZTsKIAkJfQogCkBAIC0zMzMsNiArMzM3LDcgQEAKIAlzdHJ1Y3Qgd2hjX3VyYiAqd3VyYiA9IHVyYi0+aGNwcml2OwogCXN0cnVjdCB3aGNfcXNldCAqcXNldCA9IHd1cmItPnFzZXQ7CiAJc3RydWN0IHdoY19zdGQgKnN0ZCwgKnQ7CisJYm9vbCBoYXNfcXRkID0gZmFsc2U7CiAJaW50IHJldDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCkBAIC0zNDMsMTcgKzM0OCwyMiBAQAogCQlnb3RvIG91dDsKIAogCWxpc3RfZm9yX2VhY2hfZW50cnlfc2FmZShzdGQsIHQsICZxc2V0LT5zdGRzLCBsaXN0X25vZGUpIHsKLQkJaWYgKHN0ZC0+dXJiID09IHVyYikKKwkJaWYgKHN0ZC0+dXJiID09IHVyYikgeworCQkJaWYgKHN0ZC0+cXRkKQorCQkJCWhhc19xdGQgPSB0cnVlOwogCQkJcXNldF9mcmVlX3N0ZCh3aGMsIHN0ZCk7Ci0JCWVsc2UKKwkJfSBlbHNlCiAJCQlzdGQtPnF0ZCA9IE5VTEw7IC8qIHNvIHRoaXMgc3RkIGlzIHJlLWFkZGVkIHdoZW4gdGhlIHFzZXQgaXMgKi8KIAl9CiAKLQlwemxfcXNldF9yZW1vdmUod2hjLCBxc2V0KTsKLQl3dXJiLT5zdGF0dXMgPSBzdGF0dXM7Ci0Jd3VyYi0+aXNfYXN5bmMgPSBmYWxzZTsKLQlxdWV1ZV93b3JrKHdoYy0+d29ya3F1ZXVlLCAmd3VyYi0+ZGVxdWV1ZV93b3JrKTsKLQorCWlmIChoYXNfcXRkKSB7CisJCXB6bF9xc2V0X3JlbW92ZSh3aGMsIHFzZXQpOworCQl1cGRhdGVfcHpsX2h3X3ZpZXcod2hjKTsKKwkJd3VyYi0+c3RhdHVzID0gc3RhdHVzOworCQl3dXJiLT5pc19hc3luYyA9IGZhbHNlOworCQlxdWV1ZV93b3JrKHdoYy0+d29ya3F1ZXVlLCAmd3VyYi0+ZGVxdWV1ZV93b3JrKTsKKwl9IGVsc2UKKwkJcXNldF9yZW1vdmVfdXJiKHdoYywgcXNldCwgdXJiLCBzdGF0dXMpOwogb3V0OgogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJndoYy0+bG9jaywgZmxhZ3MpOwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9ob3N0L3hoY2ktaGNkLmMgYi9kcml2ZXJzL3VzYi9ob3N0L3hoY2ktaGNkLmMKaW5kZXggOTk5MTFlNy4uOTMyZjk5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvaG9zdC94aGNpLWhjZC5jCisrKyBiL2RyaXZlcnMvdXNiL2hvc3QveGhjaS1oY2QuYwpAQCAtMzM1LDYgKzMzNSwxMiBAQAogCXNwaW5fbG9ja19pcnFzYXZlKCZ4aGNpLT5sb2NrLCBmbGFncyk7CiAJdGVtcCA9IHhoY2lfcmVhZGwoeGhjaSwgJnhoY2ktPm9wX3JlZ3MtPnN0YXR1cyk7CiAJeGhjaV9kYmcoeGhjaSwgIm9wIHJlZyBzdGF0dXMgPSAweCV4XG4iLCB0ZW1wKTsKKwlpZiAodGVtcCA9PSAweGZmZmZmZmZmKSB7CisJCXhoY2lfZGJnKHhoY2ksICJIVyBkaWVkLCBwb2xsaW5nIHN0b3BwZWQuXG4iKTsKKwkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmeGhjaS0+bG9jaywgZmxhZ3MpOworCQlyZXR1cm47CisJfQorCiAJdGVtcCA9IHhoY2lfcmVhZGwoeGhjaSwgJnhoY2ktPmlyX3NldC0+aXJxX3BlbmRpbmcpOwogCXhoY2lfZGJnKHhoY2ksICJpcl9zZXQgMCBwZW5kaW5nID0gMHgleFxuIiwgdGVtcCk7CiAJeGhjaV9kYmcoeGhjaSwgIk5vLW9wIGNvbW1hbmRzIGhhbmRsZWQgPSAlZFxuIiwgeGhjaS0+bm9vcHNfaGFuZGxlZCk7CkBAIC03NzYsNiArNzgyLDcgQEAKIHsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXQ7CisJdTMyIHRlbXA7CiAJc3RydWN0IHhoY2lfaGNkICp4aGNpOwogCXN0cnVjdCB4aGNpX3RkICp0ZDsKIAl1bnNpZ25lZCBpbnQgZXBfaW5kZXg7CkBAIC03ODgsNiArNzk1LDE3IEBACiAJcmV0ID0gdXNiX2hjZF9jaGVja191bmxpbmtfdXJiKGhjZCwgdXJiLCBzdGF0dXMpOwogCWlmIChyZXQgfHwgIXVyYi0+aGNwcml2KQogCQlnb3RvIGRvbmU7CisJdGVtcCA9IHhoY2lfcmVhZGwoeGhjaSwgJnhoY2ktPm9wX3JlZ3MtPnN0YXR1cyk7CisJaWYgKHRlbXAgPT0gMHhmZmZmZmZmZikgeworCQl4aGNpX2RiZyh4aGNpLCAiSFcgZGllZCwgZnJlZWluZyBURC5cbiIpOworCQl0ZCA9IChzdHJ1Y3QgeGhjaV90ZCAqKSB1cmItPmhjcHJpdjsKKworCQl1c2JfaGNkX3VubGlua191cmJfZnJvbV9lcChoY2QsIHVyYik7CisJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnhoY2ktPmxvY2ssIGZsYWdzKTsKKwkJdXNiX2hjZF9naXZlYmFja191cmIoeGhjaV90b19oY2QoeGhjaSksIHVyYiwgLUVTSFVURE9XTik7CisJCWtmcmVlKHRkKTsKKwkJcmV0dXJuIHJldDsKKwl9CiAKIAl4aGNpX2RiZyh4aGNpLCAiQ2FuY2VsIFVSQiAlcFxuIiwgdXJiKTsKIAl4aGNpX2RiZyh4aGNpLCAiRXZlbnQgcmluZzpcbiIpOwpAQCAtODc3LDcgKzg5NSw3IEBACiAJY3RybF9jdHgtPmRyb3BfZmxhZ3MgfD0gZHJvcF9mbGFnOwogCW5ld19kcm9wX2ZsYWdzID0gY3RybF9jdHgtPmRyb3BfZmxhZ3M7CiAKLQljdHJsX2N0eC0+YWRkX2ZsYWdzID0gfmRyb3BfZmxhZzsKKwljdHJsX2N0eC0+YWRkX2ZsYWdzICY9IH5kcm9wX2ZsYWc7CiAJbmV3X2FkZF9mbGFncyA9IGN0cmxfY3R4LT5hZGRfZmxhZ3M7CiAKIAlsYXN0X2N0eCA9IHhoY2lfbGFzdF92YWxpZF9lbmRwb2ludChjdHJsX2N0eC0+YWRkX2ZsYWdzKTsKQEAgLTE0MTAsMTEgKzE0MjgsMjAgQEAKIHsKIAlzdHJ1Y3QgeGhjaV9oY2QgKnhoY2kgPSBoY2RfdG9feGhjaShoY2QpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CisJdTMyIHN0YXRlOwogCiAJaWYgKHVkZXYtPnNsb3RfaWQgPT0gMCkKIAkJcmV0dXJuOwogCiAJc3Bpbl9sb2NrX2lycXNhdmUoJnhoY2ktPmxvY2ssIGZsYWdzKTsKKwkvKiBEb24ndCBkaXNhYmxlIHRoZSBzbG90IGlmIHRoZSBob3N0IGNvbnRyb2xsZXIgaXMgZGVhZC4gKi8KKwlzdGF0ZSA9IHhoY2lfcmVhZGwoeGhjaSwgJnhoY2ktPm9wX3JlZ3MtPnN0YXR1cyk7CisJaWYgKHN0YXRlID09IDB4ZmZmZmZmZmYpIHsKKwkJeGhjaV9mcmVlX3ZpcnRfZGV2aWNlKHhoY2ksIHVkZXYtPnNsb3RfaWQpOworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZ4aGNpLT5sb2NrLCBmbGFncyk7CisJCXJldHVybjsKKwl9CisKIAlpZiAoeGhjaV9xdWV1ZV9zbG90X2NvbnRyb2woeGhjaSwgVFJCX0RJU0FCTEVfU0xPVCwgdWRldi0+c2xvdF9pZCkpIHsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmeGhjaS0+bG9jaywgZmxhZ3MpOwogCQl4aGNpX2RiZyh4aGNpLCAiRklYTUU6IGFsbG9jYXRlIGEgY29tbWFuZCByaW5nIHNlZ21lbnRcbiIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2IvbWlzYy91c2JsY2QuYyBiL2RyaXZlcnMvdXNiL21pc2MvdXNibGNkLmMKaW5kZXggMjkwOTJiOC4uNGZiMTIwMyAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvbWlzYy91c2JsY2QuYworKysgYi9kcml2ZXJzL3VzYi9taXNjL3VzYmxjZC5jCkBAIC0zMTMsNyArMzEzLDggQEAKIAogCWlmIChsZTE2X3RvX2NwdShkZXYtPnVkZXYtPmRlc2NyaXB0b3IuaWRQcm9kdWN0KSAhPSAweDAwMDEpIHsKIAkJZGV2X3dhcm4oJmludGVyZmFjZS0+ZGV2LCAiVVNCTENEIG1vZGVsIG5vdCBzdXBwb3J0ZWQuXG4iKTsKLQkJcmV0dXJuIC1FTk9ERVY7CisJCXJldHZhbCA9IC1FTk9ERVY7CisJCWdvdG8gZXJyb3I7CiAJfQogCQogCS8qIHNldCB1cCB0aGUgZW5kcG9pbnQgaW5mb3JtYXRpb24gKi8KZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL211c2IvS2NvbmZpZyBiL2RyaXZlcnMvdXNiL211c2IvS2NvbmZpZwppbmRleCA4MDNhZGNiLi5iODRhYmQ4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL0tjb25maWcKKysrIGIvZHJpdmVycy91c2IvbXVzYi9LY29uZmlnCkBAIC04LDggKzgsOCBAQAogCiAjIChNKUhEUkMgPSAoTXVsdGlwb2ludCkgSGlnaHNwZWVkIER1YWwtUm9sZSBDb250cm9sbGVyCiBjb25maWcgVVNCX01VU0JfSERSQwotCWRlcGVuZHMgb24gKFVTQiB8fCBVU0JfR0FER0VUKSAmJiBIQVZFX0NMSwotCWRlcGVuZHMgb24gIVNVUEVSSAorCWRlcGVuZHMgb24gKFVTQiB8fCBVU0JfR0FER0VUKQorCWRlcGVuZHMgb24gKEFSTSB8fCBCTEFDS0ZJTikKIAlzZWxlY3QgTk9QX1VTQl9YQ0VJViBpZiBBUkNIX0RBVklOQ0kKIAlzZWxlY3QgVFdMNDAzMF9VU0IgaWYgTUFDSF9PTUFQXzM0MzBTRFAKIAlzZWxlY3QgTk9QX1VTQl9YQ0VJViBpZiBNQUNIX09NQVAzRVZNCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9tdXNiL2JsYWNrZmluLmMgYi9kcml2ZXJzL3VzYi9tdXNiL2JsYWNrZmluLmMKaW5kZXggZjJmNjZlYi4uZmNlYzg3ZSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2IvbXVzYi9ibGFja2Zpbi5jCisrKyBiL2RyaXZlcnMvdXNiL211c2IvYmxhY2tmaW4uYwpAQCAtMTQsNyArMTQsNiBAQAogI2luY2x1ZGUgPGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvbGlzdC5oPgotI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgogI2luY2x1ZGUgPGxpbnV4L2dwaW8uaD4KICNpbmNsdWRlIDxsaW51eC9pby5oPgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfY29yZS5oIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX2NvcmUuaAppbmRleCAzODFkNjQ4Li42YWE1ZjIyIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfY29yZS5oCisrKyBiL2RyaXZlcnMvdXNiL211c2IvbXVzYl9jb3JlLmgKQEAgLTk1LDYgKzk1LDEzIEBACiAjZW5kaWYKICNlbmRpZgkvKiBuZWVkIE1VU0IgZ2FkZ2V0IHNlbGVjdGlvbiAqLwogCisjaWZuZGVmIENPTkZJR19IQVZFX0NMSworLyogRHVtbXkgc3R1YiBmb3IgY2xrIGZyYW1ld29yayAqLworI2RlZmluZSBjbGtfZ2V0KGRldiwgaWQpCU5VTEwKKyNkZWZpbmUgY2xrX3B1dChjbG9jaykJCWRvIHt9IHdoaWxlICgwKQorI2RlZmluZSBjbGtfZW5hYmxlKGNsb2NrKQlkbyB7fSB3aGlsZSAoMCkKKyNkZWZpbmUgY2xrX2Rpc2FibGUoY2xvY2spCWRvIHt9IHdoaWxlICgwKQorI2VuZGlmCiAKICNpZmRlZiBDT05GSUdfUFJPQ19GUwogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfcmVncy5oIGIvZHJpdmVycy91c2IvbXVzYi9tdXNiX3JlZ3MuaAppbmRleCBmYmZkM2ZkLi5jYzFkNzFiIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9tdXNiL211c2JfcmVncy5oCisrKyBiL2RyaXZlcnMvdXNiL211c2IvbXVzYl9yZWdzLmgKQEAgLTQzOSwxNSArNDM5LDYgQEAKIC8qIE5vdCBpbXBsZW1lbnRlZCAtIEhXIGhhcyBzZXBlcmF0ZSBUeC9SeCBGSUZPICovCiAjZGVmaW5lIE1VU0JfVFhDU1JfTU9ERQkJCTB4MDAwMAogCi0vKgotICogRHVtbXkgc3R1YiBmb3IgY2xrIGZyYW1ld29yaywgaXQgd2lsbCBiZSByZW1vdmVkCi0gKiB1bnRpbCBCbGFja2ZpbiBzdXBwb3J0cyBjbGsgZnJhbWV3b3JrCi0gKi8KLSNkZWZpbmUgY2xrX2dldChkZXYsIGlkKQlOVUxMCi0jZGVmaW5lIGNsa19wdXQoY2xvY2spCQlkbyB7fSB3aGlsZSAoMCkKLSNkZWZpbmUgY2xrX2VuYWJsZShjbG9jaykJZG8ge30gd2hpbGUgKDApCi0jZGVmaW5lIGNsa19kaXNhYmxlKGNsb2NrKQlkbyB7fSB3aGlsZSAoMCkKLQogc3RhdGljIGlubGluZSB2b2lkIG11c2Jfd3JpdGVfdHhmaWZvc3oodm9pZCBfX2lvbWVtICptYmFzZSwgdTggY19zaXplKQogewogfQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL2FpcmNhYmxlLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvYWlyY2FibGUuYwppbmRleCAyY2JmYWIzLi5iMTBhYzg0IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvYWlyY2FibGUuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvYWlyY2FibGUuYwpAQCAtNTU0LDEzICs1NTQsMTIgQEAKIHsKIAlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gdHR5LT5kcml2ZXJfZGF0YTsKIAlzdHJ1Y3QgYWlyY2FibGVfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmcHJpdi0+cnhfbG9jayk7CiAJcHJpdi0+cnhfZmxhZ3MgfD0gVEhST1RUTEVEOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJnByaXYtPnJ4X2xvY2spOwogfQogCiAvKiBCYXNlZCBvbiBmdGRpX3Npby5jIHVudGhyb3R0bGUgKi8KQEAgLTU2OSwxNCArNTY4LDEzIEBACiAJc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCA9IHR0eS0+ZHJpdmVyX2RhdGE7CiAJc3RydWN0IGFpcmNhYmxlX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CiAJaW50IGFjdHVhbGx5X3Rocm90dGxlZDsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmcHJpdi0+cnhfbG9jayk7CiAJYWN0dWFsbHlfdGhyb3R0bGVkID0gcHJpdi0+cnhfZmxhZ3MgJiBBQ1RVQUxMWV9USFJPVFRMRUQ7CiAJcHJpdi0+cnhfZmxhZ3MgJj0gfihUSFJPVFRMRUQgfCBBQ1RVQUxMWV9USFJPVFRMRUQpOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJnByaXYtPnJ4X2xvY2spOwogCiAJaWYgKGFjdHVhbGx5X3Rocm90dGxlZCkKIAkJc2NoZWR1bGVfd29yaygmcHJpdi0+cnhfd29yayk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvY3AyMTB4LmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvY3AyMTB4LmMKaW5kZXggNGEyMDhmZS4uNjk4MjUyYSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2NwMjEweC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9jcDIxMHguYwpAQCAtMTEzLDYgKzExMyw3IEBACiAJeyBVU0JfREVWSUNFKDB4MTY2QSwgMHgwMzAzKSB9LCAvKiBDbGlwc2FsIDU1MDBQQ1UgQy1CdXMgVVNCIGludGVyZmFjZSAqLwogCXsgVVNCX0RFVklDRSgweDE2RDYsIDB4MDAwMSkgfSwgLyogSmFibG90cm9uIHNlcmlhbCBpbnRlcmZhY2UgKi8KIAl7IFVTQl9ERVZJQ0UoMHgxOEVGLCAweEUwMEYpIH0sIC8qIEVMViBVU0ItSTJDLUludGVyZmFjZSAqLworCXsgVVNCX0RFVklDRSgweDQxM0MsIDB4OTUwMCkgfSwgLyogRFc3MDAgR1BTIFVTQiBpbnRlcmZhY2UgKi8KIAl7IH0gLyogVGVybWluYXRpbmcgRW50cnkgKi8KIH07CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9jeXByZXNzX204LmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvY3lwcmVzc19tOC5jCmluZGV4IGUwYThiNzEuLmE1OTFlYmUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9jeXByZXNzX204LmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL2N5cHJlc3NfbTguYwpAQCAtMTE1NSwxMyArMTE1NSwxMiBAQAogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCBjeXByZXNzX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Ci0JdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWRiZygiJXMgLSBwb3J0ICVkIiwgX19mdW5jX18sIHBvcnQtPm51bWJlcik7CiAKLQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+bG9jaywgZmxhZ3MpOworCXNwaW5fbG9ja19pcnEoJnByaXYtPmxvY2spOwogCXByaXYtPnJ4X2ZsYWdzID0gVEhST1RUTEVEOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJnByaXYtPmxvY2spOwogfQogCiAKQEAgLTExNzAsMTQgKzExNjksMTMgQEAKIAlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gdHR5LT5kcml2ZXJfZGF0YTsKIAlzdHJ1Y3QgY3lwcmVzc19wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwogCWludCBhY3R1YWxseV90aHJvdHRsZWQsIHJlc3VsdDsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmcHJpdi0+bG9jayk7CiAJYWN0dWFsbHlfdGhyb3R0bGVkID0gcHJpdi0+cnhfZmxhZ3MgJiBBQ1RVQUxMWV9USFJPVFRMRUQ7CiAJcHJpdi0+cnhfZmxhZ3MgPSAwOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJnByaXYtPmxvY2spOwogCiAJaWYgKCFwcml2LT5jb21tX2lzX29rKQogCQlyZXR1cm47CkBAIC0xMTg1LDcgKzExODMsNyBAQAogCWlmIChhY3R1YWxseV90aHJvdHRsZWQpIHsKIAkJcG9ydC0+aW50ZXJydXB0X2luX3VyYi0+ZGV2ID0gcG9ydC0+c2VyaWFsLT5kZXY7CiAKLQkJcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+aW50ZXJydXB0X2luX3VyYiwgR0ZQX0FUT01JQyk7CisJCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPmludGVycnVwdF9pbl91cmIsIEdGUF9LRVJORUwpOwogCQlpZiAocmVzdWx0KSB7CiAJCQlkZXZfZXJyKCZwb3J0LT5kZXYsICIlcyAtIGZhaWxlZCBzdWJtaXR0aW5nIHJlYWQgdXJiLCAiCiAJCQkJCSJlcnJvciAlZFxuIiwgX19mdW5jX18sIHJlc3VsdCk7CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvZGlnaV9hY2NlbGVwb3J0LmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvZGlnaV9hY2NlbGVwb3J0LmMKaW5kZXggYWIzZGQ5OS4uNjhlODBiZSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2RpZ2lfYWNjZWxlcG9ydC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9kaWdpX2FjY2VsZXBvcnQuYwpAQCAtODk4LDE2ICs4OTgsMTYgQEAKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5kcF9wb3J0X2xvY2ssIGZsYWdzKTsKIAotCS8qIHR1cm4gdGhyb3R0bGUgb2ZmICovCi0JcHJpdi0+ZHBfdGhyb3R0bGVkID0gMDsKLQlwcml2LT5kcF90aHJvdHRsZV9yZXN0YXJ0ID0gMDsKLQogCS8qIHJlc3RhcnQgcmVhZCBjaGFpbiAqLwogCWlmIChwcml2LT5kcF90aHJvdHRsZV9yZXN0YXJ0KSB7CiAJCXBvcnQtPnJlYWRfdXJiLT5kZXYgPSBwb3J0LT5zZXJpYWwtPmRldjsKIAkJcmV0ID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+cmVhZF91cmIsIEdGUF9BVE9NSUMpOwogCX0KIAorCS8qIHR1cm4gdGhyb3R0bGUgb2ZmICovCisJcHJpdi0+ZHBfdGhyb3R0bGVkID0gMDsKKwlwcml2LT5kcF90aHJvdHRsZV9yZXN0YXJ0ID0gMDsKKwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmRwX3BvcnRfbG9jaywgZmxhZ3MpOwogCiAJaWYgKHJldCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9lbXBlZy5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2VtcGVnLmMKaW5kZXggMzNjOWU5Yy4uN2RkMGUzZSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2VtcGVnLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL2VtcGVnLmMKQEAgLTM5MSw3ICszOTEsNyBAQAogCWRiZygiJXMgLSBwb3J0ICVkIiwgX19mdW5jX18sIHBvcnQtPm51bWJlcik7CiAKIAlwb3J0LT5yZWFkX3VyYi0+ZGV2ID0gcG9ydC0+c2VyaWFsLT5kZXY7Ci0JcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+cmVhZF91cmIsIEdGUF9BVE9NSUMpOworCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPnJlYWRfdXJiLCBHRlBfS0VSTkVMKTsKIAlpZiAocmVzdWx0KQogCQlkZXZfZXJyKCZwb3J0LT5kZXYsCiAJCQkiJXMgLSBmYWlsZWQgc3VibWl0dGluZyByZWFkIHVyYiwgZXJyb3IgJWRcbiIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvZnRkaV9zaW8uYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5jCmluZGV4IDRmODgzYjEuLjljNjBkNmQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9mdGRpX3Npby5jCkBAIC03NiwxMyArNzYsNyBAQAogCXVuc2lnbmVkIGxvbmcgbGFzdF9kdHJfcnRzOwkvKiBzYXZlZCBtb2RlbSBjb250cm9sIG91dHB1dHMgKi8KIAl3YWl0X3F1ZXVlX2hlYWRfdCBkZWx0YV9tc3Jfd2FpdDsgLyogVXNlZCBmb3IgVElPQ01JV0FJVCAqLwogCWNoYXIgcHJldl9zdGF0dXMsIGRpZmZfc3RhdHVzOyAgICAgICAgLyogVXNlZCBmb3IgVElPQ01JV0FJVCAqLwotCV9fdTggcnhfZmxhZ3M7CQkvKiByZWNlaXZlIHN0YXRlIGZsYWdzICh0aHJvdHRsaW5nKSAqLwotCXNwaW5sb2NrX3QgcnhfbG9jazsJLyogc3BpbmxvY2sgZm9yIHJlY2VpdmUgc3RhdGUgKi8KLQlzdHJ1Y3QgZGVsYXllZF93b3JrIHJ4X3dvcms7CiAJc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydDsKLQlpbnQgcnhfcHJvY2Vzc2VkOwotCXVuc2lnbmVkIGxvbmcgcnhfYnl0ZXM7Ci0KIAlfX3UxNiBpbnRlcmZhY2U7CS8qIEZUMjIzMkMsIEZUMjIzMkggb3IgRlQ0MjMySCBwb3J0IGludGVyZmFjZQogCQkJCSAgICgwIGZvciBGVDIzMi8yNDUpICovCiAKQEAgLTczNywxMCArNzMxLDYgQEAKIC8qIENvbnN0YW50cyBmb3IgcmVhZCB1cmIgYW5kIHdyaXRlIHVyYiAqLwogI2RlZmluZSBCVUZTWiA1MTIKIAotLyogcnhfZmxhZ3MgKi8KLSNkZWZpbmUgVEhST1RUTEVECQkweDAxCi0jZGVmaW5lIEFDVFVBTExZX1RIUk9UVExFRAkweDAyCi0KIC8qIFVzZWQgZm9yIFRJT0NNSVdBSVQgKi8KICNkZWZpbmUgRlRESV9TVEFUVVNfQjBfTUFTSwkoRlRESV9SUzBfQ1RTIHwgRlRESV9SUzBfRFNSIHwgRlRESV9SUzBfUkkgfCBGVERJX1JTMF9STFNEKQogI2RlZmluZSBGVERJX1NUQVRVU19CMV9NQVNLCShGVERJX1JTX0JJKQpAQCAtNzYzLDcgKzc1Myw3IEBACiBzdGF0aWMgaW50ICBmdGRpX2NoYXJzX2luX2J1ZmZlcihzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5KTsKIHN0YXRpYyB2b2lkIGZ0ZGlfd3JpdGVfYnVsa19jYWxsYmFjayhzdHJ1Y3QgdXJiICp1cmIpOwogc3RhdGljIHZvaWQgZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2soc3RydWN0IHVyYiAqdXJiKTsKLXN0YXRpYyB2b2lkIGZ0ZGlfcHJvY2Vzc19yZWFkKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CitzdGF0aWMgdm9pZCBmdGRpX3Byb2Nlc3NfcmVhZChzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KTsKIHN0YXRpYyB2b2lkIGZ0ZGlfc2V0X3Rlcm1pb3Moc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSwKIAkJCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQsIHN0cnVjdCBrdGVybWlvcyAqb2xkKTsKIHN0YXRpYyBpbnQgIGZ0ZGlfdGlvY21nZXQoc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSwgc3RydWN0IGZpbGUgKmZpbGUpOwpAQCAtMTIzNCw3ICsxMjI0LDYgQEAKIAkJCQkJKG5ld19zZXJpYWwuZmxhZ3MgJiBBU1lOQ19GTEFHUykpOwogCXByaXYtPmN1c3RvbV9kaXZpc29yID0gbmV3X3NlcmlhbC5jdXN0b21fZGl2aXNvcjsKIAotCXR0eS0+bG93X2xhdGVuY3kgPSAocHJpdi0+ZmxhZ3MgJiBBU1lOQ19MT1dfTEFURU5DWSkgPyAxIDogMDsKIAl3cml0ZV9sYXRlbmN5X3RpbWVyKHBvcnQpOwogCiBjaGVja19hbmRfZXhpdDoKQEAgLTE1MjcsNyArMTUxNiw2IEBACiAJfQogCiAJa3JlZl9pbml0KCZwcml2LT5rcmVmKTsKLQlzcGluX2xvY2tfaW5pdCgmcHJpdi0+cnhfbG9jayk7CiAJc3Bpbl9sb2NrX2luaXQoJnByaXYtPnR4X2xvY2spOwogCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnByaXYtPmRlbHRhX21zcl93YWl0KTsKIAkvKiBUaGlzIHdpbGwgcHVzaCB0aGUgY2hhcmFjdGVycyB0aHJvdWdoIGltbWVkaWF0ZWx5IHJhdGhlcgpAQCAtMTU0OSw3ICsxNTM3LDYgQEAKIAkJcG9ydC0+cmVhZF91cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGggPSBCVUZTWjsKIAl9CiAKLQlJTklUX0RFTEFZRURfV09SSygmcHJpdi0+cnhfd29yaywgZnRkaV9wcm9jZXNzX3JlYWQpOwogCXByaXYtPnBvcnQgPSBwb3J0OwogCiAJLyogRnJlZSBwb3J0J3MgZXhpc3Rpbmcgd3JpdGUgdXJiIGFuZCB0cmFuc2ZlciBidWZmZXIuICovCkBAIC0xNjg2LDYgKzE2NzMsMjYgQEAKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIGludCBmdGRpX3N1Ym1pdF9yZWFkX3VyYihzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBnZnBfdCBtZW1fZmxhZ3MpCit7CisJc3RydWN0IHVyYiAqdXJiID0gcG9ydC0+cmVhZF91cmI7CisJc3RydWN0IHVzYl9zZXJpYWwgKnNlcmlhbCA9IHBvcnQtPnNlcmlhbDsKKwlpbnQgcmVzdWx0OworCisJdXNiX2ZpbGxfYnVsa191cmIodXJiLCBzZXJpYWwtPmRldiwKKwkJCSAgIHVzYl9yY3ZidWxrcGlwZShzZXJpYWwtPmRldiwKKwkJCQkJcG9ydC0+YnVsa19pbl9lbmRwb2ludEFkZHJlc3MpLAorCQkJICAgdXJiLT50cmFuc2Zlcl9idWZmZXIsCisJCQkgICB1cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGgsCisJCQkgICBmdGRpX3JlYWRfYnVsa19jYWxsYmFjaywgcG9ydCk7CisJcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIodXJiLCBtZW1fZmxhZ3MpOworCWlmIChyZXN1bHQpCisJCWRldl9lcnIoJnBvcnQtPmRldiwKKwkJCSIlcyAtIGZhaWxlZCBzdWJtaXR0aW5nIHJlYWQgdXJiLCBlcnJvciAlZFxuIiwKKwkJCQkJCQlfX2Z1bmNfXywgcmVzdWx0KTsKKwlyZXR1cm4gcmVzdWx0OworfQorCiBzdGF0aWMgaW50IGZ0ZGlfb3BlbihzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5LCBzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KQogeyAvKiBmdGRpX29wZW4gKi8KIAlzdHJ1Y3QgdXNiX2RldmljZSAqZGV2ID0gcG9ydC0+c2VyaWFsLT5kZXY7CkBAIC0xNzAwLDEyICsxNzA3LDYgQEAKIAlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+dHhfbG9jaywgZmxhZ3MpOwogCXByaXYtPnR4X2J5dGVzID0gMDsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT50eF9sb2NrLCBmbGFncyk7Ci0Jc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKLQlwcml2LT5yeF9ieXRlcyA9IDA7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwotCi0JaWYgKHR0eSkKLQkJdHR5LT5sb3dfbGF0ZW5jeSA9IChwcml2LT5mbGFncyAmIEFTWU5DX0xPV19MQVRFTkNZKSA/IDEgOiAwOwogCiAJd3JpdGVfbGF0ZW5jeV90aW1lcihwb3J0KTsKIApAQCAtMTcyNSwyMyArMTcyNiwxNCBAQAogCQlmdGRpX3NldF90ZXJtaW9zKHR0eSwgcG9ydCwgdHR5LT50ZXJtaW9zKTsKIAogCS8qIE5vdCB0aHJvdHRsZWQgKi8KLQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwotCXByaXYtPnJ4X2ZsYWdzICY9IH4oVEhST1RUTEVEIHwgQUNUVUFMTFlfVEhST1RUTEVEKTsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJnBvcnQtPmxvY2ssIGZsYWdzKTsKKwlwb3J0LT50aHJvdHRsZWQgPSAwOworCXBvcnQtPnRocm90dGxlX3JlcSA9IDA7CisJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcG9ydC0+bG9jaywgZmxhZ3MpOwogCiAJLyogU3RhcnQgcmVhZGluZyBmcm9tIHRoZSBkZXZpY2UgKi8KLQlwcml2LT5yeF9wcm9jZXNzZWQgPSAwOwotCXVzYl9maWxsX2J1bGtfdXJiKHBvcnQtPnJlYWRfdXJiLCBkZXYsCi0JCQl1c2JfcmN2YnVsa3BpcGUoZGV2LCBwb3J0LT5idWxrX2luX2VuZHBvaW50QWRkcmVzcyksCi0JCQlwb3J0LT5yZWFkX3VyYi0+dHJhbnNmZXJfYnVmZmVyLAotCQkJCXBvcnQtPnJlYWRfdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoLAotCQkJZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2ssIHBvcnQpOwotCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPnJlYWRfdXJiLCBHRlBfS0VSTkVMKTsKLQlpZiAocmVzdWx0KQotCQlkZXZfZXJyKCZwb3J0LT5kZXYsCi0JCQkiJXMgLSBmYWlsZWQgc3VibWl0dGluZyByZWFkIHVyYiwgZXJyb3IgJWRcbiIsCi0JCQlfX2Z1bmNfXywgcmVzdWx0KTsKLQllbHNlCisJcmVzdWx0ID0gZnRkaV9zdWJtaXRfcmVhZF91cmIocG9ydCwgR0ZQX0tFUk5FTCk7CisJaWYgKCFyZXN1bHQpCiAJCWtyZWZfZ2V0KCZwcml2LT5rcmVmKTsKIAogCXJldHVybiByZXN1bHQ7CkBAIC0xNzg3LDEwICsxNzc5LDYgQEAKIAogCWRiZygiJXMiLCBfX2Z1bmNfXyk7CiAKLQotCS8qIGNhbmNlbCBhbnkgc2NoZWR1bGVkIHJlYWRpbmcgKi8KLQljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJnByaXYtPnJ4X3dvcmspOwotCiAJLyogc2h1dGRvd24gb3VyIGJ1bGsgcmVhZCAqLwogCXVzYl9raWxsX3VyYihwb3J0LT5yZWFkX3VyYik7CiAJa3JlZl9wdXQoJnByaXYtPmtyZWYsIGZ0ZGlfc2lvX3ByaXZfcmVsZWFzZSk7CkBAIC0yMDEzLDI3MSArMjAwMSwxMjEgQEAKIAlyZXR1cm4gYnVmZmVyZWQ7CiB9CiAKK3N0YXRpYyBpbnQgZnRkaV9wcm9jZXNzX3BhY2tldChzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5LAorCQlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2LAorCQljaGFyICpwYWNrZXQsIGludCBsZW4pCit7CisJaW50IGk7CisJY2hhciBzdGF0dXM7CisJY2hhciBmbGFnOworCWNoYXIgKmNoOworCisJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKKworCWlmIChsZW4gPCAyKSB7CisJCWRiZygibWFsZm9ybWVkIHBhY2tldCIpOworCQlyZXR1cm4gMDsKKwl9CisKKwkvKiBDb21wYXJlIG5ldyBsaW5lIHN0YXR1cyB0byB0aGUgb2xkIG9uZSwgc2lnbmFsIGlmIGRpZmZlcmVudC8KKwkgICBOLkIuIHBhY2tldCBtYXkgYmUgcHJvY2Vzc2VkIG1vcmUgdGhhbiBvbmNlLCBidXQgZGlmZmVyZW5jZXMKKwkgICBhcmUgb25seSBwcm9jZXNzZWQgb25jZS4gICovCisJc3RhdHVzID0gcGFja2V0WzBdICYgRlRESV9TVEFUVVNfQjBfTUFTSzsKKwlpZiAoc3RhdHVzICE9IHByaXYtPnByZXZfc3RhdHVzKSB7CisJCXByaXYtPmRpZmZfc3RhdHVzIHw9IHN0YXR1cyBeIHByaXYtPnByZXZfc3RhdHVzOworCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJnByaXYtPmRlbHRhX21zcl93YWl0KTsKKwkJcHJpdi0+cHJldl9zdGF0dXMgPSBzdGF0dXM7CisJfQorCisJLyoKKwkgKiBBbHRob3VnaCB0aGUgZGV2aWNlIHVzZXMgYSBiaXRtYXNrIGFuZCBoZW5jZSBjYW4gaGF2ZSBtdWx0aXBsZQorCSAqIGVycm9ycyBvbiBhIHBhY2tldCAtIHRoZSBvcmRlciBoZXJlIHNldHMgdGhlIHByaW9yaXR5IHRoZSBlcnJvciBpcworCSAqIHJldHVybmVkIHRvIHRoZSB0dHkgbGF5ZXIuCisJICovCisJZmxhZyA9IFRUWV9OT1JNQUw7CisJaWYgKHBhY2tldFsxXSAmIEZURElfUlNfT0UpIHsKKwkJZmxhZyA9IFRUWV9PVkVSUlVOOworCQlkYmcoIk9WRVJSUlVOIGVycm9yIik7CisJfQorCWlmIChwYWNrZXRbMV0gJiBGVERJX1JTX0JJKSB7CisJCWZsYWcgPSBUVFlfQlJFQUs7CisJCWRiZygiQlJFQUsgcmVjZWl2ZWQiKTsKKwkJdXNiX3NlcmlhbF9oYW5kbGVfYnJlYWsocG9ydCk7CisJfQorCWlmIChwYWNrZXRbMV0gJiBGVERJX1JTX1BFKSB7CisJCWZsYWcgPSBUVFlfUEFSSVRZOworCQlkYmcoIlBBUklUWSBlcnJvciIpOworCX0KKwlpZiAocGFja2V0WzFdICYgRlRESV9SU19GRSkgeworCQlmbGFnID0gVFRZX0ZSQU1FOworCQlkYmcoIkZSQU1JTkcgZXJyb3IiKTsKKwl9CisKKwlsZW4gLT0gMjsKKwlpZiAoIWxlbikKKwkJcmV0dXJuIDA7CS8qIHN0YXR1cyBvbmx5ICovCisJY2ggPSBwYWNrZXQgKyAyOworCisJaWYgKCEocG9ydC0+Y29uc29sZSAmJiBwb3J0LT5zeXNycSkgJiYgZmxhZyA9PSBUVFlfTk9STUFMKQorCQl0dHlfaW5zZXJ0X2ZsaXBfc3RyaW5nKHR0eSwgY2gsIGxlbik7CisJZWxzZSB7CisJCWZvciAoaSA9IDA7IGkgPCBsZW47IGkrKywgY2grKykgeworCQkJaWYgKCF1c2Jfc2VyaWFsX2hhbmRsZV9zeXNycV9jaGFyKHR0eSwgcG9ydCwgKmNoKSkKKwkJCQl0dHlfaW5zZXJ0X2ZsaXBfY2hhcih0dHksICpjaCwgZmxhZyk7CisJCX0KKwl9CisJcmV0dXJuIGxlbjsKK30KKworc3RhdGljIHZvaWQgZnRkaV9wcm9jZXNzX3JlYWQoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCkKK3sKKwlzdHJ1Y3QgdXJiICp1cmIgPSBwb3J0LT5yZWFkX3VyYjsKKwlzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5OworCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CisJY2hhciAqZGF0YSA9IChjaGFyICopdXJiLT50cmFuc2Zlcl9idWZmZXI7CisJaW50IGk7CisJaW50IGxlbjsKKwlpbnQgY291bnQgPSAwOworCisJdHR5ID0gdHR5X3BvcnRfdHR5X2dldCgmcG9ydC0+cG9ydCk7CisJaWYgKCF0dHkpCisJCXJldHVybjsKKworCWZvciAoaSA9IDA7IGkgPCB1cmItPmFjdHVhbF9sZW5ndGg7IGkgKz0gcHJpdi0+bWF4X3BhY2tldF9zaXplKSB7CisJCWxlbiA9IG1pbl90KGludCwgdXJiLT5hY3R1YWxfbGVuZ3RoIC0gaSwgcHJpdi0+bWF4X3BhY2tldF9zaXplKTsKKwkJY291bnQgKz0gZnRkaV9wcm9jZXNzX3BhY2tldCh0dHksIHBvcnQsIHByaXYsICZkYXRhW2ldLCBsZW4pOworCX0KKworCWlmIChjb3VudCkKKwkJdHR5X2ZsaXBfYnVmZmVyX3B1c2godHR5KTsKKwl0dHlfa3JlZl9wdXQodHR5KTsKK30KKwogc3RhdGljIHZvaWQgZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2soc3RydWN0IHVyYiAqdXJiKQogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB1cmItPmNvbnRleHQ7Ci0Jc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eTsKLQlzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2OwotCXVuc2lnbmVkIGxvbmcgY291bnRyZWFkOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JaW50IHN0YXR1cyA9IHVyYi0+c3RhdHVzOwotCi0JaWYgKHVyYi0+bnVtYmVyX29mX3BhY2tldHMgPiAwKSB7Ci0JCWRldl9lcnIoJnBvcnQtPmRldiwgIiVzIHRyYW5zZmVyX2J1ZmZlcl9sZW5ndGggJWQgIgotCQkJImFjdHVhbF9sZW5ndGggJWQgbnVtYmVyIG9mIHBhY2tldHMgJWRcbiIsIF9fZnVuY19fLAotCQkJdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoLAotCQkJdXJiLT5hY3R1YWxfbGVuZ3RoLCB1cmItPm51bWJlcl9vZl9wYWNrZXRzKTsKLQkJZGV2X2VycigmcG9ydC0+ZGV2LCAiJXMgdHJhbnNmZXJfZmxhZ3MgJXhcbiIsIF9fZnVuY19fLAotCQkJdXJiLT50cmFuc2Zlcl9mbGFncyk7Ci0JfQotCi0JZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKLQotCWlmIChwb3J0LT5wb3J0LmNvdW50IDw9IDApCi0JCXJldHVybjsKLQotCXR0eSA9IHR0eV9wb3J0X3R0eV9nZXQoJnBvcnQtPnBvcnQpOwotCWlmICghdHR5KSB7Ci0JCWRiZygiJXMgLSBiYWQgdHR5IHBvaW50ZXIgLSBleGl0aW5nIiwgX19mdW5jX18pOwotCQlyZXR1cm47Ci0JfQotCi0JcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKLQlpZiAoIXByaXYpIHsKLQkJZGJnKCIlcyAtIGJhZCBwb3J0IHByaXZhdGUgZGF0YSBwb2ludGVyIC0gZXhpdGluZyIsIF9fZnVuY19fKTsKLQkJZ290byBvdXQ7Ci0JfQotCi0JaWYgKHVyYiAhPSBwb3J0LT5yZWFkX3VyYikKLQkJZGV2X2VycigmcG9ydC0+ZGV2LCAiJXMgLSBOb3QgbXkgdXJiIVxuIiwgX19mdW5jX18pOwotCi0JaWYgKHN0YXR1cykgewotCQkvKiBUaGlzIHdpbGwgaGFwcGVuIGF0IGNsb3NlIGV2ZXJ5IHRpbWUgc28gaXQgaXMgYSBkYmcgbm90IGFuCi0JCSAgIGVyciAqLwotCQlkYmcoIih0aGlzIGlzIG9rIG9uIGNsb3NlKSBub256ZXJvIHJlYWQgYnVsayBzdGF0dXMgcmVjZWl2ZWQ6ICVkIiwgc3RhdHVzKTsKLQkJZ290byBvdXQ7Ci0JfQotCi0JLyogY291bnQgZGF0YSBieXRlcywgYnV0IG5vdCBzdGF0dXMgYnl0ZXMgKi8KLQljb3VudHJlYWQgPSB1cmItPmFjdHVhbF9sZW5ndGg7Ci0JY291bnRyZWFkIC09IDIgKiBESVZfUk9VTkRfVVAoY291bnRyZWFkLCBwcml2LT5tYXhfcGFja2V0X3NpemUpOwotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7Ci0JcHJpdi0+cnhfYnl0ZXMgKz0gY291bnRyZWFkOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKLQotCWZ0ZGlfcHJvY2Vzc19yZWFkKCZwcml2LT5yeF93b3JrLndvcmspOwotb3V0OgotCXR0eV9rcmVmX3B1dCh0dHkpOwotfSAvKiBmdGRpX3JlYWRfYnVsa19jYWxsYmFjayAqLwotCi0KLXN0YXRpYyB2b2lkIGZ0ZGlfcHJvY2Vzc19yZWFkKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yaykKLXsgLyogZnRkaV9wcm9jZXNzX3JlYWQgKi8KLQlzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0KLQkJY29udGFpbmVyX29mKHdvcmssIHN0cnVjdCBmdGRpX3ByaXZhdGUsIHJ4X3dvcmsud29yayk7Ci0Jc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCA9IHByaXYtPnBvcnQ7Ci0Jc3RydWN0IHVyYiAqdXJiOwotCXN0cnVjdCB0dHlfc3RydWN0ICp0dHk7Ci0JY2hhciBlcnJvcl9mbGFnOwotCXVuc2lnbmVkIGNoYXIgKmRhdGE7Ci0KLQlpbnQgaTsKLQlpbnQgcmVzdWx0OwotCWludCBuZWVkX2ZsaXA7Ci0JaW50IHBhY2tldF9vZmZzZXQ7CiAJdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWRiZygiJXMgLSBwb3J0ICVkIiwgX19mdW5jX18sIHBvcnQtPm51bWJlcik7CiAKLQlpZiAocG9ydC0+cG9ydC5jb3VudCA8PSAwKQotCQlyZXR1cm47Ci0KLQl0dHkgPSB0dHlfcG9ydF90dHlfZ2V0KCZwb3J0LT5wb3J0KTsKLQlpZiAoIXR0eSkgewotCQlkYmcoIiVzIC0gYmFkIHR0eSBwb2ludGVyIC0gZXhpdGluZyIsIF9fZnVuY19fKTsKKwlpZiAodXJiLT5zdGF0dXMpIHsKKwkJZGJnKCIlcyAtIG5vbnplcm8gcmVhZCBidWxrIHN0YXR1cyByZWNlaXZlZDogJWQiLAorCQkJCQkJX19mdW5jX18sIHVyYi0+c3RhdHVzKTsKIAkJcmV0dXJuOwogCX0KIAotCXByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Ci0JaWYgKCFwcml2KSB7Ci0JCWRiZygiJXMgLSBiYWQgcG9ydCBwcml2YXRlIGRhdGEgcG9pbnRlciAtIGV4aXRpbmciLCBfX2Z1bmNfXyk7Ci0JCWdvdG8gb3V0OwotCX0KKwl1c2Jfc2VyaWFsX2RlYnVnX2RhdGEoZGVidWcsICZwb3J0LT5kZXYsIF9fZnVuY19fLAorCQkJCXVyYi0+YWN0dWFsX2xlbmd0aCwgdXJiLT50cmFuc2Zlcl9idWZmZXIpOworCWZ0ZGlfcHJvY2Vzc19yZWFkKHBvcnQpOwogCi0JdXJiID0gcG9ydC0+cmVhZF91cmI7Ci0JaWYgKCF1cmIpIHsKLQkJZGJnKCIlcyAtIGJhZCByZWFkX3VyYiBwb2ludGVyIC0gZXhpdGluZyIsIF9fZnVuY19fKTsKLQkJZ290byBvdXQ7Ci0JfQotCi0JZGF0YSA9IHVyYi0+dHJhbnNmZXJfYnVmZmVyOwotCi0JaWYgKHByaXYtPnJ4X3Byb2Nlc3NlZCkgewotCQlkYmcoIiVzIC0gYWxyZWFkeSBwcm9jZXNzZWQ6ICVkIGJ5dGVzLCAlZCByZW1haW4iLCBfX2Z1bmNfXywKLQkJCQlwcml2LT5yeF9wcm9jZXNzZWQsCi0JCQkJdXJiLT5hY3R1YWxfbGVuZ3RoIC0gcHJpdi0+cnhfcHJvY2Vzc2VkKTsKLQl9IGVsc2UgewotCQkvKiBUaGUgZmlyc3QgdHdvIGJ5dGVzIG9mIGV2ZXJ5IHJlYWQgcGFja2V0IGFyZSBzdGF0dXMgKi8KLQkJaWYgKHVyYi0+YWN0dWFsX2xlbmd0aCA+IDIpCi0JCQl1c2Jfc2VyaWFsX2RlYnVnX2RhdGEoZGVidWcsICZwb3J0LT5kZXYsIF9fZnVuY19fLAotCQkJCQkJdXJiLT5hY3R1YWxfbGVuZ3RoLCBkYXRhKTsKLQkJZWxzZQotCQkJZGJnKCJTdGF0dXMgb25seTogJTAzb28gJTAzb28iLCBkYXRhWzBdLCBkYXRhWzFdKTsKLQl9Ci0KLQotCS8qIFRPIERPIC0tIGNoZWNrIGZvciBodW5nIHVwIGxpbmUgYW5kIGhhbmRsZSBhcHByb3ByaWF0ZWx5OiAqLwotCS8qICAgc2VuZCBoYW5ndXAgICovCi0JLyogU2VlIGFjbS5jIC0geW91IGRvIGEgdHR5X2hhbmd1cCAgLSBlZyB0dHlfaGFuZ3VwKHR0eSkgKi8KLQkvKiBpZiBDRCBpcyBkcm9wcGVkIGFuZCB0aGUgbGluZSBpcyBub3QgQ0xPQ0FMIHRoZW4gd2Ugc2hvdWxkIGhhbmd1cCAqLwotCi0JbmVlZF9mbGlwID0gMDsKLQlmb3IgKHBhY2tldF9vZmZzZXQgPSBwcml2LT5yeF9wcm9jZXNzZWQ7Ci0JCXBhY2tldF9vZmZzZXQgPCB1cmItPmFjdHVhbF9sZW5ndGg7IHBhY2tldF9vZmZzZXQgKz0gcHJpdi0+bWF4X3BhY2tldF9zaXplKSB7Ci0JCWludCBsZW5ndGg7Ci0KLQkJLyogQ29tcGFyZSBuZXcgbGluZSBzdGF0dXMgdG8gdGhlIG9sZCBvbmUsIHNpZ25hbCBpZiBkaWZmZXJlbnQvCi0JCSAgIE4uQi4gcGFja2V0IG1heSBiZSBwcm9jZXNzZWQgbW9yZSB0aGFuIG9uY2UsIGJ1dCBkaWZmZXJlbmNlcwotCQkgICBhcmUgb25seSBwcm9jZXNzZWQgb25jZS4gICovCi0JCWNoYXIgbmV3X3N0YXR1cyA9IGRhdGFbcGFja2V0X29mZnNldCArIDBdICYKLQkJCQkJCUZURElfU1RBVFVTX0IwX01BU0s7Ci0JCWlmIChuZXdfc3RhdHVzICE9IHByaXYtPnByZXZfc3RhdHVzKSB7Ci0JCQlwcml2LT5kaWZmX3N0YXR1cyB8PQotCQkJCW5ld19zdGF0dXMgXiBwcml2LT5wcmV2X3N0YXR1czsKLQkJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmcHJpdi0+ZGVsdGFfbXNyX3dhaXQpOwotCQkJcHJpdi0+cHJldl9zdGF0dXMgPSBuZXdfc3RhdHVzOwotCQl9Ci0KLQkJbGVuZ3RoID0gbWluX3QodTMyLCBwcml2LT5tYXhfcGFja2V0X3NpemUsIHVyYi0+YWN0dWFsX2xlbmd0aC1wYWNrZXRfb2Zmc2V0KS0yOwotCQlpZiAobGVuZ3RoIDwgMCkgewotCQkJZGV2X2VycigmcG9ydC0+ZGV2LCAiJXMgLSBiYWQgcGFja2V0IGxlbmd0aDogJWRcbiIsCi0JCQkJX19mdW5jX18sIGxlbmd0aCsyKTsKLQkJCWxlbmd0aCA9IDA7Ci0JCX0KLQotCQlpZiAocHJpdi0+cnhfZmxhZ3MgJiBUSFJPVFRMRUQpIHsKLQkJCWRiZygiJXMgLSB0aHJvdHRsZWQiLCBfX2Z1bmNfXyk7Ci0JCQlicmVhazsKLQkJfQotCQlpZiAodHR5X2J1ZmZlcl9yZXF1ZXN0X3Jvb20odHR5LCBsZW5ndGgpIDwgbGVuZ3RoKSB7Ci0JCQkvKiBicmVhayBvdXQgJiB3YWl0IGZvciB0aHJvdHRsaW5nL3VudGhyb3R0bGluZyB0bwotCQkJICAgaGFwcGVuICovCi0JCQlkYmcoIiVzIC0gcmVjZWl2ZSByb29tIGxvdyIsIF9fZnVuY19fKTsKLQkJCWJyZWFrOwotCQl9Ci0KLQkJLyogSGFuZGxlIGVycm9ycyBhbmQgYnJlYWsgKi8KLQkJZXJyb3JfZmxhZyA9IFRUWV9OT1JNQUw7Ci0JCS8qIEFsdGhvdWdoIHRoZSBkZXZpY2UgdXNlcyBhIGJpdG1hc2sgYW5kIGhlbmNlIGNhbiBoYXZlCi0JCSAgIG11bHRpcGxlIGVycm9ycyBvbiBhIHBhY2tldCAtIHRoZSBvcmRlciBoZXJlIHNldHMgdGhlCi0JCSAgIHByaW9yaXR5IHRoZSBlcnJvciBpcyByZXR1cm5lZCB0byB0aGUgdHR5IGxheWVyICAqLwotCi0JCWlmIChkYXRhW3BhY2tldF9vZmZzZXQrMV0gJiBGVERJX1JTX09FKSB7Ci0JCQllcnJvcl9mbGFnID0gVFRZX09WRVJSVU47Ci0JCQlkYmcoIk9WRVJSUlVOIGVycm9yIik7Ci0JCX0KLQkJaWYgKGRhdGFbcGFja2V0X29mZnNldCsxXSAmIEZURElfUlNfQkkpIHsKLQkJCWVycm9yX2ZsYWcgPSBUVFlfQlJFQUs7Ci0JCQlkYmcoIkJSRUFLIHJlY2VpdmVkIik7Ci0JCQl1c2Jfc2VyaWFsX2hhbmRsZV9icmVhayhwb3J0KTsKLQkJfQotCQlpZiAoZGF0YVtwYWNrZXRfb2Zmc2V0KzFdICYgRlRESV9SU19QRSkgewotCQkJZXJyb3JfZmxhZyA9IFRUWV9QQVJJVFk7Ci0JCQlkYmcoIlBBUklUWSBlcnJvciIpOwotCQl9Ci0JCWlmIChkYXRhW3BhY2tldF9vZmZzZXQrMV0gJiBGVERJX1JTX0ZFKSB7Ci0JCQllcnJvcl9mbGFnID0gVFRZX0ZSQU1FOwotCQkJZGJnKCJGUkFNSU5HIGVycm9yIik7Ci0JCX0KLQkJaWYgKGxlbmd0aCA+IDApIHsKLQkJCWZvciAoaSA9IDI7IGkgPCBsZW5ndGgrMjsgaSsrKSB7Ci0JCQkJLyogTm90ZSB0aGF0IHRoZSBlcnJvciBmbGFnIGlzIGR1cGxpY2F0ZWQgZm9yCi0JCQkJICAgZXZlcnkgY2hhcmFjdGVyIHJlY2VpdmVkIHNpbmNlIHdlIGRvbid0IGtub3cKLQkJCQkgICB3aGljaCBjaGFyYWN0ZXIgaXQgYXBwbGllZCB0byAqLwotCQkJCWlmICghdXNiX3NlcmlhbF9oYW5kbGVfc3lzcnFfY2hhcih0dHksIHBvcnQsCi0JCQkJCQlkYXRhW3BhY2tldF9vZmZzZXQgKyBpXSkpCi0JCQkJCXR0eV9pbnNlcnRfZmxpcF9jaGFyKHR0eSwKLQkJCQkJCWRhdGFbcGFja2V0X29mZnNldCArIGldLAotCQkJCQkJZXJyb3JfZmxhZyk7Ci0JCQl9Ci0JCQluZWVkX2ZsaXAgPSAxOwotCQl9Ci0KLSNpZmRlZiBOT1RfQ09SUkVDVF9CVVRfS0VFUElOR19JVF9GT1JfTk9XCi0JCS8qIGlmIGEgcGFyaXR5IGVycm9yIGlzIGRldGVjdGVkIHlvdSBnZXQgc3RhdHVzIHBhY2tldHMgZm9yZXZlcgotCQkgICB1bnRpbCBhIGNoYXJhY3RlciBpcyBzZW50IHdpdGhvdXQgYSBwYXJpdHkgZXJyb3IuCi0JCSAgIFRoaXMgZG9lc24ndCB3b3JrIHdlbGwgc2luY2UgdGhlIGFwcGxpY2F0aW9uIHJlY2VpdmVzIGEKLQkJICAgbmV2ZXIgZW5kaW5nIHN0cmVhbSBvZiBiYWQgZGF0YSAtIGV2ZW4gdGhvdWdoIG5ldyBkYXRhCi0JCSAgIGhhc24ndCBiZWVuIHNlbnQuIFRoZXJlZm9yZSBJIChiaWxsKSBoYXZlIHRha2VuIHRoaXMgb3V0LgotCQkgICBIb3dldmVyIC0gdGhpcyBtaWdodCBtYWtlIHNlbnNlIGZvciBmcmFtaW5nIGVycm9ycyBhbmQgc28gb24KLQkJICAgc28gSSBhbSBsZWF2aW5nIHRoZSBjb2RlIGluIGZvciBub3cuCi0JCSovCi0JCWVsc2UgewotCQkJaWYgKGVycm9yX2ZsYWcgIT0gVFRZX05PUk1BTCkgewotCQkJCWRiZygiZXJyb3JfZmxhZyBpcyBub3Qgbm9ybWFsIik7Ci0JCQkJLyogSW4gdGhpcyBjYXNlIGl0IGlzIGp1c3Qgc3RhdHVzIC0gaWYgdGhhdCBpcwotCQkJCSAgIGFuIGVycm9yIHNlbmQgYSBiYWQgY2hhcmFjdGVyICovCi0JCQkJaWYgKHR0eS0+ZmxpcC5jb3VudCA+PSBUVFlfRkxJUEJVRl9TSVpFKQotCQkJCQl0dHlfZmxpcF9idWZmZXJfcHVzaCh0dHkpOwotCQkJCXR0eV9pbnNlcnRfZmxpcF9jaGFyKHR0eSwgMHhmZiwgZXJyb3JfZmxhZyk7Ci0JCQkJbmVlZF9mbGlwID0gMTsKLQkJCX0KLQkJfQotI2VuZGlmCi0JfSAvKiAiZm9yKHBhY2tldF9vZmZzZXQ9MC4uLiIgKi8KLQotCS8qIExvdyBsYXRlbmN5ICovCi0JaWYgKG5lZWRfZmxpcCkKLQkJdHR5X2ZsaXBfYnVmZmVyX3B1c2godHR5KTsKLQotCWlmIChwYWNrZXRfb2Zmc2V0IDwgdXJiLT5hY3R1YWxfbGVuZ3RoKSB7Ci0JCS8qIG5vdCBjb21wbGV0ZWx5IHByb2Nlc3NlZCAtIHJlY29yZCBwcm9ncmVzcyAqLwotCQlwcml2LT5yeF9wcm9jZXNzZWQgPSBwYWNrZXRfb2Zmc2V0OwotCQlkYmcoIiVzIC0gaW5jb21wbGV0ZSwgJWQgYnl0ZXMgcHJvY2Vzc2VkLCAlZCByZW1haW4iLAotCQkJCV9fZnVuY19fLCBwYWNrZXRfb2Zmc2V0LAotCQkJCXVyYi0+YWN0dWFsX2xlbmd0aCAtIHBhY2tldF9vZmZzZXQpOwotCQkvKiBjaGVjayBpZiB3ZSB3ZXJlIHRocm90dGxlZCB3aGlsZSBwcm9jZXNzaW5nICovCi0JCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7Ci0JCWlmIChwcml2LT5yeF9mbGFncyAmIFRIUk9UVExFRCkgewotCQkJcHJpdi0+cnhfZmxhZ3MgfD0gQUNUVUFMTFlfVEhST1RUTEVEOwotCQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwotCQkJZGJnKCIlcyAtIGRlZmVycmluZyByZW1haW5kZXIgdW50aWwgdW50aHJvdHRsZWQiLAotCQkJCQlfX2Z1bmNfXyk7Ci0JCQlnb3RvIG91dDsKLQkJfQotCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7Ci0JCS8qIGlmIHRoZSBwb3J0IGlzIGNsb3NlZCBzdG9wIHRyeWluZyB0byByZWFkICovCi0JCWlmIChwb3J0LT5wb3J0LmNvdW50ID4gMCkKLQkJCS8qIGRlbGF5IHByb2Nlc3Npbmcgb2YgcmVtYWluZGVyICovCi0JCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnByaXYtPnJ4X3dvcmssIDEpOwotCQllbHNlCi0JCQlkYmcoIiVzIC0gcG9ydCBpcyBjbG9zZWQiLCBfX2Z1bmNfXyk7Ci0JCWdvdG8gb3V0OwotCX0KLQotCS8qIHVyYiBpcyBjb21wbGV0ZWx5IHByb2Nlc3NlZCAqLwotCXByaXYtPnJ4X3Byb2Nlc3NlZCA9IDA7Ci0KLQkvKiBpZiB0aGUgcG9ydCBpcyBjbG9zZWQgc3RvcCB0cnlpbmcgdG8gcmVhZCAqLwotCWlmIChwb3J0LT5wb3J0LmNvdW50ID4gMCkgewotCQkvKiBDb250aW51ZSB0cnlpbmcgdG8gYWx3YXlzIHJlYWQgICovCi0JCXVzYl9maWxsX2J1bGtfdXJiKHBvcnQtPnJlYWRfdXJiLCBwb3J0LT5zZXJpYWwtPmRldiwKLQkJCXVzYl9yY3ZidWxrcGlwZShwb3J0LT5zZXJpYWwtPmRldiwKLQkJCQkJcG9ydC0+YnVsa19pbl9lbmRwb2ludEFkZHJlc3MpLAotCQkJcG9ydC0+cmVhZF91cmItPnRyYW5zZmVyX2J1ZmZlciwKLQkJCXBvcnQtPnJlYWRfdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoLAotCQkJZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2ssIHBvcnQpOwotCi0JCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPnJlYWRfdXJiLCBHRlBfQVRPTUlDKTsKLQkJaWYgKHJlc3VsdCkKLQkJCWRldl9lcnIoJnBvcnQtPmRldiwKLQkJCQkiJXMgLSBmYWlsZWQgcmVzdWJtaXR0aW5nIHJlYWQgdXJiLCBlcnJvciAlZFxuIiwKLQkJCQlfX2Z1bmNfXywgcmVzdWx0KTsKLQl9Ci1vdXQ6Ci0JdHR5X2tyZWZfcHV0KHR0eSk7Ci19IC8qIGZ0ZGlfcHJvY2Vzc19yZWFkICovCi0KKwlzcGluX2xvY2tfaXJxc2F2ZSgmcG9ydC0+bG9jaywgZmxhZ3MpOworCXBvcnQtPnRocm90dGxlZCA9IHBvcnQtPnRocm90dGxlX3JlcTsKKwlpZiAoIXBvcnQtPnRocm90dGxlZCkgeworCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb3J0LT5sb2NrLCBmbGFncyk7CisJCWZ0ZGlfc3VibWl0X3JlYWRfdXJiKHBvcnQsIEdGUF9BVE9NSUMpOworCX0gZWxzZQorCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb3J0LT5sb2NrLCBmbGFncyk7Cit9CiAKIHN0YXRpYyB2b2lkIGZ0ZGlfYnJlYWtfY3RsKHN0cnVjdCB0dHlfc3RydWN0ICp0dHksIGludCBicmVha19zdGF0ZSkKIHsKQEAgLTI2MDksMzMgKzI0NDcsMzEgQEAKIHN0YXRpYyB2b2lkIGZ0ZGlfdGhyb3R0bGUoc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eSkKIHsKIAlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gdHR5LT5kcml2ZXJfZGF0YTsKLQlzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlkYmcoIiVzIC0gcG9ydCAlZCIsIF9fZnVuY19fLCBwb3J0LT5udW1iZXIpOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKLQlwcml2LT5yeF9mbGFncyB8PSBUSFJPVFRMRUQ7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOworCXNwaW5fbG9ja19pcnFzYXZlKCZwb3J0LT5sb2NrLCBmbGFncyk7CisJcG9ydC0+dGhyb3R0bGVfcmVxID0gMTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb3J0LT5sb2NrLCBmbGFncyk7CiB9CiAKLQotc3RhdGljIHZvaWQgZnRkaV91bnRocm90dGxlKHN0cnVjdCB0dHlfc3RydWN0ICp0dHkpCit2b2lkIGZ0ZGlfdW50aHJvdHRsZShzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5KQogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwotCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Ci0JaW50IGFjdHVhbGx5X3Rocm90dGxlZDsKKwlpbnQgd2FzX3Rocm90dGxlZDsKIAl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7Ci0JYWN0dWFsbHlfdGhyb3R0bGVkID0gcHJpdi0+cnhfZmxhZ3MgJiBBQ1RVQUxMWV9USFJPVFRMRUQ7Ci0JcHJpdi0+cnhfZmxhZ3MgJj0gfihUSFJPVFRMRUQgfCBBQ1RVQUxMWV9USFJPVFRMRUQpOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKKwlzcGluX2xvY2tfaXJxc2F2ZSgmcG9ydC0+bG9jaywgZmxhZ3MpOworCXdhc190aHJvdHRsZWQgPSBwb3J0LT50aHJvdHRsZWQ7CisJcG9ydC0+dGhyb3R0bGVkID0gcG9ydC0+dGhyb3R0bGVfcmVxID0gMDsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwb3J0LT5sb2NrLCBmbGFncyk7CiAKLQlpZiAoYWN0dWFsbHlfdGhyb3R0bGVkKQotCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnByaXYtPnJ4X3dvcmssIDApOworCS8qIFJlc3VibWl0IHVyYiBpZiB0aHJvdHRsZWQgYW5kIG9wZW4uICovCisJaWYgKHdhc190aHJvdHRsZWQgJiYgdGVzdF9iaXQoQVNZTkNCX0lOSVRJQUxJWkVELCAmcG9ydC0+cG9ydC5mbGFncykpCisJCWZ0ZGlfc3VibWl0X3JlYWRfdXJiKHBvcnQsIEdGUF9LRVJORUwpOwogfQogCiBzdGF0aWMgaW50IF9faW5pdCBmdGRpX2luaXQodm9pZCkKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9nYXJtaW5fZ3BzLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvZ2FybWluX2dwcy5jCmluZGV4IDIwNDMyZDMuLjVhYzkwMGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9nYXJtaW5fZ3BzLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL2dhcm1pbl9ncHMuYwpAQCAtMTM5MCwxNCArMTM5MCwxMyBAQAogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCBnYXJtaW5fZGF0YSAqZ2FybWluX2RhdGFfcCA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAkvKiBzZXQgZmxhZywgZGF0YSByZWNlaXZlZCB3aWxsIGJlIHB1dCBpbnRvIGEgcXVldWUKIAkgICBmb3IgbGF0ZXIgcHJvY2Vzc2luZyAqLwotCXNwaW5fbG9ja19pcnFzYXZlKCZnYXJtaW5fZGF0YV9wLT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmZ2FybWluX2RhdGFfcC0+bG9jayk7CiAJZ2FybWluX2RhdGFfcC0+ZmxhZ3MgfD0gRkxBR1NfUVVFVUlOR3xGTEFHU19USFJPVFRMRUQ7Ci0Jc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmZ2FybWluX2RhdGFfcC0+bG9jaywgZmxhZ3MpOworCXNwaW5fdW5sb2NrX2lycSgmZ2FybWluX2RhdGFfcC0+bG9jayk7CiB9CiAKIApAQCAtMTQwNSwxMyArMTQwNCwxMiBAQAogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCBnYXJtaW5fZGF0YSAqZ2FybWluX2RhdGFfcCA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCBzdGF0dXM7CiAKIAlkYmcoIiVzIC0gcG9ydCAlZCIsIF9fZnVuY19fLCBwb3J0LT5udW1iZXIpOwotCXNwaW5fbG9ja19pcnFzYXZlKCZnYXJtaW5fZGF0YV9wLT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmZ2FybWluX2RhdGFfcC0+bG9jayk7CiAJZ2FybWluX2RhdGFfcC0+ZmxhZ3MgJj0gfkZMQUdTX1RIUk9UVExFRDsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZnYXJtaW5fZGF0YV9wLT5sb2NrLCBmbGFncyk7CisJc3Bpbl91bmxvY2tfaXJxKCZnYXJtaW5fZGF0YV9wLT5sb2NrKTsKIAogCS8qIGluIG5hdGl2ZSBtb2RlIHNlbmQgcXVldWVkIGRhdGEgdG8gdHR5LCBpbgogCSAgIHNlcmlhbCBtb2RlIG5vdGhpbmcgbmVlZHMgdG8gYmUgZG9uZSBoZXJlICovCkBAIC0xNDE5LDcgKzE0MTcsNyBAQAogCQlnYXJtaW5fZmx1c2hfcXVldWUoZ2FybWluX2RhdGFfcCk7CiAKIAlpZiAoMCAhPSAoZ2FybWluX2RhdGFfcC0+ZmxhZ3MgJiBGTEFHU19CVUxLX0lOX0FDVElWRSkpIHsKLQkJc3RhdHVzID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+cmVhZF91cmIsIEdGUF9BVE9NSUMpOworCQlzdGF0dXMgPSB1c2Jfc3VibWl0X3VyYihwb3J0LT5yZWFkX3VyYiwgR0ZQX0tFUk5FTCk7CiAJCWlmIChzdGF0dXMpCiAJCQlkZXZfZXJyKCZwb3J0LT5kZXYsCiAJCQkJIiVzIC0gZmFpbGVkIHJlc3VibWl0dGluZyByZWFkIHVyYiwgZXJyb3IgJWRcbiIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvZ2VuZXJpYy5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2dlbmVyaWMuYwppbmRleCBkZWJhMDhjLi5iYmUwMDVjIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvZ2VuZXJpYy5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9nZW5lcmljLmMKQEAgLTU0Niw3ICs1NDYsNyBAQAogCiAJaWYgKHdhc190aHJvdHRsZWQpIHsKIAkJLyogUmVzdW1lIHJlYWRpbmcgZnJvbSBkZXZpY2UgKi8KLQkJdXNiX3NlcmlhbF9nZW5lcmljX3Jlc3VibWl0X3JlYWRfdXJiKHBvcnQsIEdGUF9LRVJORUwpOworCQlmbHVzaF9hbmRfcmVzdWJtaXRfcmVhZF91cmIocG9ydCk7CiAJfQogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvaXBhcS5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2lwYXEuYwppbmRleCAyNGZjYzY0Li5kNjIzMWMzIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvaXBhcS5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9pcGFxLmMKQEAgLTk2Niw2ICs5NjYsMTUgQEAKIHN0YXRpYyBpbnQgaXBhcV9zdGFydHVwKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwpCiB7CiAJZGJnKCIlcyIsIF9fZnVuY19fKTsKKworCS8qIFNvbWUgb2YgdGhlIGRldmljZXMgaW4gaXBhcV9pZF90YWJsZVtdIGFyZSBjb21wb3NpdGUsIGFuZCB3ZQorCSAqIHNob3VsZG4ndCBiaW5kIHRvIGFsbCB0aGUgaW50ZXJmYWNlcy4gIFRoaXMgdGVzdCB3aWxsIHJ1bGUgb3V0CisJICogc29tZSBvYnZpb3VzbHkgaW52YWxpZCBwb3NzaWJpbGl0aWVzLgorCSAqLworCWlmIChzZXJpYWwtPm51bV9idWxrX2luIDwgc2VyaWFsLT5udW1fcG9ydHMgfHwKKwkJCXNlcmlhbC0+bnVtX2J1bGtfb3V0IDwgc2VyaWFsLT5udW1fcG9ydHMpCisJCXJldHVybiAtRU5PREVWOworCiAJaWYgKHNlcmlhbC0+ZGV2LT5hY3Rjb25maWctPmRlc2MuYkNvbmZpZ3VyYXRpb25WYWx1ZSAhPSAxKSB7CiAJCS8qCiAJCSAqIEZJWE1FOiBIUCBpUGFxIHJ4MzcxNSwgcG9zc2libHkgb3RoZXJzLCBoYXZlIDEgY29uZmlnIHRoYXQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9rZXlzcGFuX3BkYS5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW5fcGRhLmMKaW5kZXggMjU3YzE2Yy4uMTI5NmEwOSAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW5fcGRhLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL2tleXNwYW5fcGRhLmMKQEAgLTI5MCw3ICsyOTAsNyBAQAogCS8qIGp1c3QgcmVzdGFydCB0aGUgcmVjZWl2ZSBpbnRlcnJ1cHQgVVJCICovCiAJZGJnKCJrZXlzcGFuX3BkYV9yeF91bnRocm90dGxlIHBvcnQgJWQiLCBwb3J0LT5udW1iZXIpOwogCXBvcnQtPmludGVycnVwdF9pbl91cmItPmRldiA9IHBvcnQtPnNlcmlhbC0+ZGV2OwotCWlmICh1c2Jfc3VibWl0X3VyYihwb3J0LT5pbnRlcnJ1cHRfaW5fdXJiLCBHRlBfQVRPTUlDKSkKKwlpZiAodXNiX3N1Ym1pdF91cmIocG9ydC0+aW50ZXJydXB0X2luX3VyYiwgR0ZQX0tFUk5FTCkpCiAJCWRiZygiIHVzYl9zdWJtaXRfdXJiKHJlYWQgdXJiKSBmYWlsZWQiKTsKIAlyZXR1cm47CiB9CmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwva2w1a3VzYjEwNS5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL2tsNWt1c2IxMDUuYwppbmRleCBmNzM3MzM3Li4zYTc4NzM4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwva2w1a3VzYjEwNS5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9rbDVrdXNiMTA1LmMKQEAgLTk1MSw3ICs5NTEsNyBAQAogCWRiZygiJXMgLSBwb3J0ICVkIiwgX19mdW5jX18sIHBvcnQtPm51bWJlcik7CiAKIAlwb3J0LT5yZWFkX3VyYi0+ZGV2ID0gcG9ydC0+c2VyaWFsLT5kZXY7Ci0JcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+cmVhZF91cmIsIEdGUF9BVE9NSUMpOworCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPnJlYWRfdXJiLCBHRlBfS0VSTkVMKTsKIAlpZiAocmVzdWx0KQogCQlkZXZfZXJyKCZwb3J0LT5kZXYsCiAJCQkiJXMgLSBmYWlsZWQgc3VibWl0dGluZyByZWFkIHVyYiwgZXJyb3IgJWRcbiIsCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvbWN0X3UyMzIuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9tY3RfdTIzMi5jCmluZGV4IGFkNDk5OGIuLmNkMDA5Y2IgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9tY3RfdTIzMi5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9tY3RfdTIzMi5jCkBAIC03NzcsMjAgKzc3NywxOSBAQAogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCBtY3RfdTIzMl9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAJdW5zaWduZWQgaW50IGNvbnRyb2xfc3RhdGU7CiAKIAlkYmcoIiVzIC0gcG9ydCAlZCIsIF9fZnVuY19fLCBwb3J0LT5udW1iZXIpOwogCi0Jc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwlzcGluX2xvY2tfaXJxKCZwcml2LT5sb2NrKTsKIAlwcml2LT5yeF9mbGFncyB8PSBUSFJPVFRMRUQ7CiAJaWYgKENfQ1JUU0NUUyh0dHkpKSB7CiAJCXByaXYtPmNvbnRyb2xfc3RhdGUgJj0gflRJT0NNX1JUUzsKIAkJY29udHJvbF9zdGF0ZSA9IHByaXYtPmNvbnRyb2xfc3RhdGU7Ci0JCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwkJc3Bpbl91bmxvY2tfaXJxKCZwcml2LT5sb2NrKTsKIAkJKHZvaWQpIG1jdF91MjMyX3NldF9tb2RlbV9jdHJsKHBvcnQtPnNlcmlhbCwgY29udHJvbF9zdGF0ZSk7CiAJfSBlbHNlIHsKLQkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+bG9jaywgZmxhZ3MpOworCQlzcGluX3VubG9ja19pcnEoJnByaXYtPmxvY2spOwogCX0KIH0KIApAQCAtNzk5LDIwICs3OTgsMTkgQEAKIHsKIAlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gdHR5LT5kcml2ZXJfZGF0YTsKIAlzdHJ1Y3QgbWN0X3UyMzJfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCXVuc2lnbmVkIGludCBjb250cm9sX3N0YXRlOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmcHJpdi0+bG9jayk7CiAJaWYgKChwcml2LT5yeF9mbGFncyAmIFRIUk9UVExFRCkgJiYgQ19DUlRTQ1RTKHR0eSkpIHsKIAkJcHJpdi0+cnhfZmxhZ3MgJj0gflRIUk9UVExFRDsKIAkJcHJpdi0+Y29udHJvbF9zdGF0ZSB8PSBUSU9DTV9SVFM7CiAJCWNvbnRyb2xfc3RhdGUgPSBwcml2LT5jb250cm9sX3N0YXRlOwotCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJCXNwaW5fdW5sb2NrX2lycSgmcHJpdi0+bG9jayk7CiAJCSh2b2lkKSBtY3RfdTIzMl9zZXRfbW9kZW1fY3RybChwb3J0LT5zZXJpYWwsIGNvbnRyb2xfc3RhdGUpOwogCX0gZWxzZSB7Ci0JCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwkJc3Bpbl91bmxvY2tfaXJxKCZwcml2LT5sb2NrKTsKIAl9CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vcHRpY29uLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvb3B0aWNvbi5jCmluZGV4IDEwODVhNTcuLjgwZjU5YjYgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vcHRpY29uLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL29wdGljb24uYwpAQCAtMzE0LDIxICszMTQsMjQgQEAKIAlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gdHR5LT5kcml2ZXJfZGF0YTsKIAlzdHJ1Y3Qgb3B0aWNvbl9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfZGF0YShwb3J0LT5zZXJpYWwpOwogCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JaW50IHJlc3VsdDsKKwlpbnQgcmVzdWx0LCB3YXNfdGhyb3R0bGVkOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAogCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7CiAJcHJpdi0+dGhyb3R0bGVkID0gZmFsc2U7CisJd2FzX3Rocm90dGxlZCA9IHByaXYtPmFjdHVhbGx5X3Rocm90dGxlZDsKIAlwcml2LT5hY3R1YWxseV90aHJvdHRsZWQgPSBmYWxzZTsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7CiAKIAlwcml2LT5idWxrX3JlYWRfdXJiLT5kZXYgPSBwb3J0LT5zZXJpYWwtPmRldjsKLQlyZXN1bHQgPSB1c2Jfc3VibWl0X3VyYihwcml2LT5idWxrX3JlYWRfdXJiLCBHRlBfQVRPTUlDKTsKLQlpZiAocmVzdWx0KQotCQlkZXZfZXJyKCZwb3J0LT5kZXYsCi0JCQkiJXMgLSBmYWlsZWQgc3VibWl0dGluZyByZWFkIHVyYiwgZXJyb3IgJWRcbiIsCisJaWYgKHdhc190aHJvdHRsZWQpIHsKKwkJcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIocHJpdi0+YnVsa19yZWFkX3VyYiwgR0ZQX0FUT01JQyk7CisJCWlmIChyZXN1bHQpCisJCQlkZXZfZXJyKCZwb3J0LT5kZXYsCisJCQkJIiVzIC0gZmFpbGVkIHN1Ym1pdHRpbmcgcmVhZCB1cmIsIGVycm9yICVkXG4iLAogCQkJCQkJCV9fZnVuY19fLCByZXN1bHQpOworCX0KIH0KIAogc3RhdGljIGludCBvcHRpY29uX3Rpb2NtZ2V0KHN0cnVjdCB0dHlfc3RydWN0ICp0dHksIHN0cnVjdCBmaWxlICpmaWxlKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL29wdGlvbi5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL29wdGlvbi5jCmluZGV4IGY2NmUzOTguLjY1ZDk2YjIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vcHRpb24uYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvb3B0aW9uLmMKQEAgLTE2NSw2ICsxNjUsNyBAQAogI2RlZmluZSBIVUFXRUlfUFJPRFVDVF9FMTQzRAkJCTB4MTQzRAogI2RlZmluZSBIVUFXRUlfUFJPRFVDVF9FMTQzRQkJCTB4MTQzRQogI2RlZmluZSBIVUFXRUlfUFJPRFVDVF9FMTQzRgkJCTB4MTQzRgorI2RlZmluZSBIVUFXRUlfUFJPRFVDVF9FMTRBQwkJCTB4MTRBQwogCiAjZGVmaW5lIFFVQU5UQV9WRU5ET1JfSUQJCQkweDA0MDgKICNkZWZpbmUgUVVBTlRBX1BST0RVQ1RfUTEwMQkJCTB4RUEwMgpAQCAtMzE4LDYgKzMxOSw3IEBACiAvKiBUT1NISUJBIFBST0RVQ1RTICovCiAjZGVmaW5lIFRPU0hJQkFfVkVORE9SX0lECQkJMHgwOTMwCiAjZGVmaW5lIFRPU0hJQkFfUFJPRFVDVF9IU0RQQV9NSU5JQ0FSRAkJMHgxMzAyCisjZGVmaW5lIFRPU0hJQkFfUFJPRFVDVF9HNDUwCQkJMHgwZDQ1CiAKICNkZWZpbmUgQUxJTktfVkVORE9SX0lECQkJCTB4MWUwZQogI2RlZmluZSBBTElOS19QUk9EVUNUXzNHVQkJCTB4OTIwMApAQCAtMzI2LDYgKzMyOCw5IEBACiAjZGVmaW5lIEFMQ0FURUxfVkVORE9SX0lECQkJMHgxYmJiCiAjZGVmaW5lIEFMQ0FURUxfUFJPRFVDVF9YMDYwUwkJCTB4MDAwMAogCisvKiBBaXJwbHVzIHByb2R1Y3RzICovCisjZGVmaW5lIEFJUlBMVVNfVkVORE9SX0lECQkJMHgxMDExCisjZGVmaW5lIEFJUlBMVVNfUFJPRFVDVF9NQ0Q2NTAJCQkweDMxOTgKIAogc3RhdGljIHN0cnVjdCB1c2JfZGV2aWNlX2lkIG9wdGlvbl9pZHNbXSA9IHsKIAl7IFVTQl9ERVZJQ0UoT1BUSU9OX1ZFTkRPUl9JRCwgT1BUSU9OX1BST0RVQ1RfQ09MVCkgfSwKQEAgLTQyNCw2ICs0MjksNyBAQAogCXsgVVNCX0RFVklDRV9BTkRfSU5URVJGQUNFX0lORk8oSFVBV0VJX1ZFTkRPUl9JRCwgSFVBV0VJX1BST0RVQ1RfRTE0M0QsIDB4ZmYsIDB4ZmYsIDB4ZmYpIH0sCiAJeyBVU0JfREVWSUNFX0FORF9JTlRFUkZBQ0VfSU5GTyhIVUFXRUlfVkVORE9SX0lELCBIVUFXRUlfUFJPRFVDVF9FMTQzRSwgMHhmZiwgMHhmZiwgMHhmZikgfSwKIAl7IFVTQl9ERVZJQ0VfQU5EX0lOVEVSRkFDRV9JTkZPKEhVQVdFSV9WRU5ET1JfSUQsIEhVQVdFSV9QUk9EVUNUX0UxNDNGLCAweGZmLCAweGZmLCAweGZmKSB9LAorCXsgVVNCX0RFVklDRShIVUFXRUlfVkVORE9SX0lELCBIVUFXRUlfUFJPRFVDVF9FMTRBQykgfSwKIAl7IFVTQl9ERVZJQ0UoQU1PSV9WRU5ET1JfSUQsIEFNT0lfUFJPRFVDVF85NTA4KSB9LAogCXsgVVNCX0RFVklDRShOT1ZBVEVMV0lSRUxFU1NfVkVORE9SX0lELCBOT1ZBVEVMV0lSRUxFU1NfUFJPRFVDVF9WNjQwKSB9LCAvKiBOb3ZhdGVsIE1lcmxpbiBWNjQwL1hWNjIwICovCiAJeyBVU0JfREVWSUNFKE5PVkFURUxXSVJFTEVTU19WRU5ET1JfSUQsIE5PVkFURUxXSVJFTEVTU19QUk9EVUNUX1Y2MjApIH0sIC8qIE5vdmF0ZWwgTWVybGluIFY2MjAvUzYyMCAqLwpAQCAtNTgxLDEwICs1ODcsMTIgQEAKIAl7IFVTQl9ERVZJQ0UoUUlTREFfVkVORE9SX0lELCBRSVNEQV9QUk9EVUNUX0gyMV80NTIzKSB9LAogCXsgVVNCX0RFVklDRShRSVNEQV9WRU5ET1JfSUQsIFFJU0RBX1BST0RVQ1RfSDIwXzQ1MTUpIH0sCiAJeyBVU0JfREVWSUNFKFFJU0RBX1ZFTkRPUl9JRCwgUUlTREFfUFJPRFVDVF9IMjBfNDUxOSkgfSwKKwl7IFVTQl9ERVZJQ0UoVE9TSElCQV9WRU5ET1JfSUQsIFRPU0hJQkFfUFJPRFVDVF9HNDUwKSB9LAogCXsgVVNCX0RFVklDRShUT1NISUJBX1ZFTkRPUl9JRCwgVE9TSElCQV9QUk9EVUNUX0hTRFBBX01JTklDQVJEICkgfSwgLyogVG9zaGliYSAzRyBIU0RQQSA9PSBOb3ZhdGVsIEV4cGVkaXRlIEVVODcwRCBNaW5pQ2FyZCAqLwogCXsgVVNCX0RFVklDRShBTElOS19WRU5ET1JfSUQsIDB4OTAwMCkgfSwKIAl7IFVTQl9ERVZJQ0VfQU5EX0lOVEVSRkFDRV9JTkZPKEFMSU5LX1ZFTkRPUl9JRCwgQUxJTktfUFJPRFVDVF8zR1UsIDB4ZmYsIDB4ZmYsIDB4ZmYpIH0sCiAJeyBVU0JfREVWSUNFKEFMQ0FURUxfVkVORE9SX0lELCBBTENBVEVMX1BST0RVQ1RfWDA2MFMpIH0sCisJeyBVU0JfREVWSUNFKEFJUlBMVVNfVkVORE9SX0lELCBBSVJQTFVTX1BST0RVQ1RfTUNENjUwKSB9LAogCXsgfSAvKiBUZXJtaW5hdGluZyBlbnRyeSAqLwogfTsKIE1PRFVMRV9ERVZJQ0VfVEFCTEUodXNiLCBvcHRpb25faWRzKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9vdGk2ODU4LmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvb3RpNjg1OC5jCmluZGV4IDBmNGE3MGNlLi5jNjQ0ZTI2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvb3RpNjg1OC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9vdGk2ODU4LmMKQEAgLTI4OCw3ICsyODgsNyBAQAogCiAJZGJnKCIlcygpOiBzdWJtaXR0aW5nIGludGVycnVwdCB1cmIiLCBfX2Z1bmNfXyk7CiAJcG9ydC0+aW50ZXJydXB0X2luX3VyYi0+ZGV2ID0gcG9ydC0+c2VyaWFsLT5kZXY7Ci0JcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+aW50ZXJydXB0X2luX3VyYiwgR0ZQX0FUT01JQyk7CisJcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+aW50ZXJydXB0X2luX3VyYiwgR0ZQX0tFUk5FTCk7CiAJaWYgKHJlc3VsdCAhPSAwKSB7CiAJCWRldl9lcnIoJnBvcnQtPmRldiwgIiVzKCk6IHVzYl9zdWJtaXRfdXJiKCkgZmFpbGVkIgogCQkJCSIgd2l0aCBlcnJvciAlZFxuIiwgX19mdW5jX18sIHJlc3VsdCk7CkBAIC0zMzUsNyArMzM1LDcgQEAKIAogCQlkYmcoIiVzKCk6IHN1Ym1pdHRpbmcgaW50ZXJydXB0IHVyYiIsIF9fZnVuY19fKTsKIAkJcG9ydC0+aW50ZXJydXB0X2luX3VyYi0+ZGV2ID0gcG9ydC0+c2VyaWFsLT5kZXY7Ci0JCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPmludGVycnVwdF9pbl91cmIsIEdGUF9BVE9NSUMpOworCQlyZXN1bHQgPSB1c2Jfc3VibWl0X3VyYihwb3J0LT5pbnRlcnJ1cHRfaW5fdXJiLCBHRlBfTk9JTyk7CiAJCWlmIChyZXN1bHQgIT0gMCkgewogCQkJZGV2X2VycigmcG9ydC0+ZGV2LCAiJXMoKTogdXNiX3N1Ym1pdF91cmIoKSBmYWlsZWQiCiAJCQkJIiB3aXRoIGVycm9yICVkXG4iLCBfX2Z1bmNfXywgcmVzdWx0KTsKQEAgLTM0OSw3ICszNDksNyBAQAogCiAJcG9ydC0+d3JpdGVfdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoID0gY291bnQ7CiAJcG9ydC0+d3JpdGVfdXJiLT5kZXYgPSBwb3J0LT5zZXJpYWwtPmRldjsKLQlyZXN1bHQgPSB1c2Jfc3VibWl0X3VyYihwb3J0LT53cml0ZV91cmIsIEdGUF9BVE9NSUMpOworCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPndyaXRlX3VyYiwgR0ZQX05PSU8pOwogCWlmIChyZXN1bHQgIT0gMCkgewogCQlkZXZfZXJyKCZwb3J0LT5kZXYsICIlcygpOiB1c2Jfc3VibWl0X3VyYigpIGZhaWxlZCIKIAkJCSAgICAgICAiIHdpdGggZXJyb3IgJWRcbiIsIF9fZnVuY19fLCByZXN1bHQpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy91c2Ivc2VyaWFsL3BsMjMwMy5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL3BsMjMwMy5jCmluZGV4IDExMjhlMDEuLjllYzFhNDkgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3NlcmlhbC9wbDIzMDMuYworKysgYi9kcml2ZXJzL3VzYi9zZXJpYWwvcGwyMzAzLmMKQEAgLTEwNDYsMTMgKzEwNDYsMTUgQEAKIAkvKiBvdmVycnVuIGlzIHNwZWNpYWwsIG5vdCBhc3NvY2lhdGVkIHdpdGggYSBjaGFyICovCiAJaWYgKGxpbmVfc3RhdHVzICYgVUFSVF9PVkVSUlVOX0VSUk9SKQogCQl0dHlfaW5zZXJ0X2ZsaXBfY2hhcih0dHksIDAsIFRUWV9PVkVSUlVOKTsKLQlpZiAocG9ydC0+Y29uc29sZSAmJiBwb3J0LT5zeXNycSkgeworCisJaWYgKHR0eV9mbGFnID09IFRUWV9OT1JNQUwgJiYgIShwb3J0LT5jb25zb2xlICYmIHBvcnQtPnN5c3JxKSkKKwkJdHR5X2luc2VydF9mbGlwX3N0cmluZyh0dHksIGRhdGEsIHVyYi0+YWN0dWFsX2xlbmd0aCk7CisJZWxzZSB7CiAJCWludCBpOwogCQlmb3IgKGkgPSAwOyBpIDwgdXJiLT5hY3R1YWxfbGVuZ3RoOyArK2kpCiAJCQlpZiAoIXVzYl9zZXJpYWxfaGFuZGxlX3N5c3JxX2NoYXIodHR5LCBwb3J0LCBkYXRhW2ldKSkKIAkJCQl0dHlfaW5zZXJ0X2ZsaXBfY2hhcih0dHksIGRhdGFbaV0sIHR0eV9mbGFnKTsKLQl9IGVsc2UKLQkJdHR5X2luc2VydF9mbGlwX3N0cmluZyh0dHksIGRhdGEsIHVyYi0+YWN0dWFsX2xlbmd0aCk7CisJfQogCXR0eV9mbGlwX2J1ZmZlcl9wdXNoKHR0eSk7CiB9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC9zaWVycmEuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9zaWVycmEuYwppbmRleCA4YzA3NWIyLi40NTg4Mzk4IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvc2llcnJhLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL3NpZXJyYS5jCkBAIC0xNyw3ICsxNyw3IEBACiAgIFdob20gYmFzZWQgaGlzIG9uIHRoZSBLZXlzcGFuIGRyaXZlciBieSBIdWdoIEJsZW1pbmdzIDxodWdoQGJsZW1pbmdzLm9yZz4KICovCiAKLSNkZWZpbmUgRFJJVkVSX1ZFUlNJT04gInYuMS4zLjciCisjZGVmaW5lIERSSVZFUl9WRVJTSU9OICJ2LjEuMy44IgogI2RlZmluZSBEUklWRVJfQVVUSE9SICJLZXZpbiBMbG95ZCwgRWxpbmEgUGFzaGV2YSwgTWF0dGhldyBTYWZhciwgUm9yeSBGaWxlciIKICNkZWZpbmUgRFJJVkVSX0RFU0MgIlVTQiBEcml2ZXIgZm9yIFNpZXJyYSBXaXJlbGVzcyBVU0IgbW9kZW1zIgogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvc3ltYm9sc2VyaWFsLmMgYi9kcml2ZXJzL3VzYi9zZXJpYWwvc3ltYm9sc2VyaWFsLmMKaW5kZXggY2I3ZTk1Zi4uYjI4MmMwZiAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL3N5bWJvbHNlcmlhbC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC9zeW1ib2xzZXJpYWwuYwpAQCAtMTY1LDM0ICsxNjUsMzYgQEAKIHsKIAlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gdHR5LT5kcml2ZXJfZGF0YTsKIAlzdHJ1Y3Qgc3ltYm9sX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9kYXRhKHBvcnQtPnNlcmlhbCk7Ci0JdW5zaWduZWQgbG9uZyBmbGFnczsKIAogCWRiZygiJXMgLSBwb3J0ICVkIiwgX19mdW5jX18sIHBvcnQtPm51bWJlcik7Ci0Jc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwlzcGluX2xvY2tfaXJxKCZwcml2LT5sb2NrKTsKIAlwcml2LT50aHJvdHRsZWQgPSB0cnVlOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJnByaXYtPmxvY2spOwogfQogCiBzdGF0aWMgdm9pZCBzeW1ib2xfdW50aHJvdHRsZShzdHJ1Y3QgdHR5X3N0cnVjdCAqdHR5KQogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCBzeW1ib2xfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX2RhdGEocG9ydC0+c2VyaWFsKTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCWludCByZXN1bHQ7CisJYm9vbCB3YXNfdGhyb3R0bGVkOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmcHJpdi0+bG9jayk7CiAJcHJpdi0+dGhyb3R0bGVkID0gZmFsc2U7CisJd2FzX3Rocm90dGxlZCA9IHByaXYtPmFjdHVhbGx5X3Rocm90dGxlZDsKIAlwcml2LT5hY3R1YWxseV90aHJvdHRsZWQgPSBmYWxzZTsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJc3Bpbl91bmxvY2tfaXJxKCZwcml2LT5sb2NrKTsKIAogCXByaXYtPmludF91cmItPmRldiA9IHBvcnQtPnNlcmlhbC0+ZGV2OwotCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHByaXYtPmludF91cmIsIEdGUF9BVE9NSUMpOwotCWlmIChyZXN1bHQpCi0JCWRldl9lcnIoJnBvcnQtPmRldiwKLQkJCSIlcyAtIGZhaWxlZCBzdWJtaXR0aW5nIHJlYWQgdXJiLCBlcnJvciAlZFxuIiwKKwlpZiAod2FzX3Rocm90dGxlZCkgeworCQlyZXN1bHQgPSB1c2Jfc3VibWl0X3VyYihwcml2LT5pbnRfdXJiLCBHRlBfS0VSTkVMKTsKKwkJaWYgKHJlc3VsdCkKKwkJCWRldl9lcnIoJnBvcnQtPmRldiwKKwkJCQkiJXMgLSBmYWlsZWQgc3VibWl0dGluZyByZWFkIHVyYiwgZXJyb3IgJWRcbiIsCiAJCQkJCQkJX19mdW5jX18sIHJlc3VsdCk7CisJfQogfQogCiBzdGF0aWMgaW50IHN5bWJvbF9zdGFydHVwKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwpCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi9zZXJpYWwvdXNiLXNlcmlhbC5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL3VzYi1zZXJpYWwuYwppbmRleCBhYTZiMmFlLi5iZDNmYTdmIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvdXNiLXNlcmlhbC5jCisrKyBiL2RyaXZlcnMvdXNiL3NlcmlhbC91c2Itc2VyaWFsLmMKQEAgLTE1Niw3ICsxNTYsOCBAQAogCWlmIChzZXJpYWwtPm1pbm9yICE9IFNFUklBTF9UVFlfTk9fTUlOT1IpCiAJCXJldHVybl9zZXJpYWwoc2VyaWFsKTsKIAotCXNlcmlhbC0+dHlwZS0+cmVsZWFzZShzZXJpYWwpOworCWlmIChzZXJpYWwtPmF0dGFjaGVkKQorCQlzZXJpYWwtPnR5cGUtPnJlbGVhc2Uoc2VyaWFsKTsKIAogCS8qIE5vdyB0aGF0IG5vdGhpbmcgaXMgdXNpbmcgdGhlIHBvcnRzLCB0aGV5IGNhbiBiZSBmcmVlZCAqLwogCWZvciAoaSA9IDA7IGkgPCBzZXJpYWwtPm51bV9wb3J0X3BvaW50ZXJzOyArK2kpIHsKQEAgLTEwNTksMTIgKzEwNjAsMTUgQEAKIAkJbW9kdWxlX3B1dCh0eXBlLT5kcml2ZXIub3duZXIpOwogCQlpZiAocmV0dmFsIDwgMCkKIAkJCWdvdG8gcHJvYmVfZXJyb3I7CisJCXNlcmlhbC0+YXR0YWNoZWQgPSAxOwogCQlpZiAocmV0dmFsID4gMCkgewogCQkJLyogcXVpZXRseSBhY2NlcHQgdGhpcyBkZXZpY2UsIGJ1dCBkb24ndCBiaW5kIHRvIGEKIAkJCSAgIHNlcmlhbCBwb3J0IGFzIGl0J3MgYWJvdXQgdG8gZGlzYXBwZWFyICovCiAJCQlzZXJpYWwtPm51bV9wb3J0cyA9IDA7CiAJCQlnb3RvIGV4aXQ7CiAJCX0KKwl9IGVsc2UgeworCQlzZXJpYWwtPmF0dGFjaGVkID0gMTsKIAl9CiAKIAlpZiAoZ2V0X2ZyZWVfc2VyaWFsKHNlcmlhbCwgbnVtX3BvcnRzLCAmbWlub3IpID09IE5VTEwpIHsKQEAgLTExNjQsOCArMTE2OCwxMCBAQAogCiAJaWYgKHNlcmlhbC0+dHlwZS0+c3VzcGVuZCkgewogCQlyID0gc2VyaWFsLT50eXBlLT5zdXNwZW5kKHNlcmlhbCwgbWVzc2FnZSk7Ci0JCWlmIChyIDwgMCkKKwkJaWYgKHIgPCAwKSB7CisJCQlzZXJpYWwtPnN1c3BlbmRpbmcgPSAwOwogCQkJZ290byBlcnJfb3V0OworCQl9CiAJfQogCiAJZm9yIChpID0gMDsgaSA8IHNlcmlhbC0+bnVtX3BvcnRzOyArK2kpIHsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC92aXNvci5jIGIvZHJpdmVycy91c2Ivc2VyaWFsL3Zpc29yLmMKaW5kZXggMWFhNWQyMC4uYWQxZjkyMyAxMDA2NDQKLS0tIGEvZHJpdmVycy91c2Ivc2VyaWFsL3Zpc29yLmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL3Zpc29yLmMKQEAgLTUxMyw3ICs1MTMsOCBAQAogCQkJdHR5X2tyZWZfcHV0KHR0eSk7CiAJCX0KIAkJc3Bpbl9sb2NrKCZwcml2LT5sb2NrKTsKLQkJcHJpdi0+Ynl0ZXNfaW4gKz0gYXZhaWxhYmxlX3Jvb207CisJCWlmICh0dHkpCisJCQlwcml2LT5ieXRlc19pbiArPSBhdmFpbGFibGVfcm9vbTsKIAogCX0gZWxzZSB7CiAJCXNwaW5fbG9jaygmcHJpdi0+bG9jayk7CkBAIC01ODIsMTIgKzU4MywxMSBAQAogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCB2aXNvcl9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAKIAlkYmcoIiVzIC0gcG9ydCAlZCIsIF9fZnVuY19fLCBwb3J0LT5udW1iZXIpOwotCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmcHJpdi0+bG9jayk7CiAJcHJpdi0+dGhyb3R0bGVkID0gMTsKLQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5sb2NrLCBmbGFncyk7CisJc3Bpbl91bmxvY2tfaXJxKCZwcml2LT5sb2NrKTsKIH0KIAogCkBAIC01OTUsMjEgKzU5NSwyMyBAQAogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCB2aXNvcl9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwotCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Ci0JaW50IHJlc3VsdDsKKwlpbnQgcmVzdWx0LCB3YXNfdGhyb3R0bGVkOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKLQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+bG9jaywgZmxhZ3MpOworCXNwaW5fbG9ja19pcnEoJnByaXYtPmxvY2spOwogCXByaXYtPnRocm90dGxlZCA9IDA7CisJd2FzX3Rocm90dGxlZCA9IHByaXYtPmFjdHVhbGx5X3Rocm90dGxlZDsKIAlwcml2LT5hY3R1YWxseV90aHJvdHRsZWQgPSAwOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPmxvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJnByaXYtPmxvY2spOwogCi0JcG9ydC0+cmVhZF91cmItPmRldiA9IHBvcnQtPnNlcmlhbC0+ZGV2OwotCXJlc3VsdCA9IHVzYl9zdWJtaXRfdXJiKHBvcnQtPnJlYWRfdXJiLCBHRlBfQVRPTUlDKTsKLQlpZiAocmVzdWx0KQotCQlkZXZfZXJyKCZwb3J0LT5kZXYsCi0JCQkiJXMgLSBmYWlsZWQgc3VibWl0dGluZyByZWFkIHVyYiwgZXJyb3IgJWRcbiIsCisJaWYgKHdhc190aHJvdHRsZWQpIHsKKwkJcG9ydC0+cmVhZF91cmItPmRldiA9IHBvcnQtPnNlcmlhbC0+ZGV2OworCQlyZXN1bHQgPSB1c2Jfc3VibWl0X3VyYihwb3J0LT5yZWFkX3VyYiwgR0ZQX0tFUk5FTCk7CisJCWlmIChyZXN1bHQpCisJCQlkZXZfZXJyKCZwb3J0LT5kZXYsCisJCQkJIiVzIC0gZmFpbGVkIHN1Ym1pdHRpbmcgcmVhZCB1cmIsIGVycm9yICVkXG4iLAogCQkJCQkJCV9fZnVuY19fLCByZXN1bHQpOworCX0KIH0KIAogc3RhdGljIGludCBwYWxtX29zXzNfcHJvYmUoc3RydWN0IHVzYl9zZXJpYWwgKnNlcmlhbCwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3NlcmlhbC93aGl0ZWhlYXQuYyBiL2RyaXZlcnMvdXNiL3NlcmlhbC93aGl0ZWhlYXQuYwppbmRleCA2MjQyNGVlLi4xMDkzZDJlIDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi9zZXJpYWwvd2hpdGVoZWF0LmMKKysrIGIvZHJpdmVycy91c2Ivc2VyaWFsL3doaXRlaGVhdC5jCkBAIC05NDksMTMgKzk0OSwxMiBAQAogewogCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0dHktPmRyaXZlcl9kYXRhOwogCXN0cnVjdCB3aGl0ZWhlYXRfcHJpdmF0ZSAqaW5mbyA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZpbmZvLT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmaW5mby0+bG9jayk7CiAJaW5mby0+ZmxhZ3MgfD0gVEhST1RUTEVEOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmluZm8tPmxvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJmluZm8tPmxvY2spOwogCiAJcmV0dXJuOwogfQpAQCAtOTY2LDE0ICs5NjUsMTMgQEAKIAlzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gdHR5LT5kcml2ZXJfZGF0YTsKIAlzdHJ1Y3Qgd2hpdGVoZWF0X3ByaXZhdGUgKmluZm8gPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CiAJaW50IGFjdHVhbGx5X3Rocm90dGxlZDsKLQl1bnNpZ25lZCBsb25nIGZsYWdzOwogCiAJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX2Z1bmNfXywgcG9ydC0+bnVtYmVyKTsKIAotCXNwaW5fbG9ja19pcnFzYXZlKCZpbmZvLT5sb2NrLCBmbGFncyk7CisJc3Bpbl9sb2NrX2lycSgmaW5mby0+bG9jayk7CiAJYWN0dWFsbHlfdGhyb3R0bGVkID0gaW5mby0+ZmxhZ3MgJiBBQ1RVQUxMWV9USFJPVFRMRUQ7CiAJaW5mby0+ZmxhZ3MgJj0gfihUSFJPVFRMRUQgfCBBQ1RVQUxMWV9USFJPVFRMRUQpOwotCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmluZm8tPmxvY2ssIGZsYWdzKTsKKwlzcGluX3VubG9ja19pcnEoJmluZm8tPmxvY2spOwogCiAJaWYgKGFjdHVhbGx5X3Rocm90dGxlZCkKIAkJcnhfZGF0YV9zb2Z0aW50KCZpbmZvLT5yeF93b3JrKTsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdHJhbnNwb3J0LmMgYi9kcml2ZXJzL3VzYi9zdG9yYWdlL3RyYW5zcG9ydC5jCmluZGV4IGUyMGRjNTIuLjU4OWY2YjQgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdHJhbnNwb3J0LmMKKysrIGIvZHJpdmVycy91c2Ivc3RvcmFnZS90cmFuc3BvcnQuYwpAQCAtNjk2LDcgKzY5Niw3IEBACiAJCS8qIGRldmljZSBzdXBwb3J0cyBhbmQgbmVlZHMgYmlnZ2VyIHNlbnNlIGJ1ZmZlciAqLwogCQlpZiAodXMtPmZmbGFncyAmIFVTX0ZMX1NBTkVfU0VOU0UpCiAJCQlzZW5zZV9zaXplID0gfjA7Ci0KK1JldHJ5X1NlbnNlOgogCQlVU19ERUJVR1AoIklzc3VpbmcgYXV0by1SRVFVRVNUX1NFTlNFXG4iKTsKIAogCQlzY3NpX2VoX3ByZXBfY21uZChzcmIsICZzZXMsIE5VTEwsIDAsIHNlbnNlX3NpemUpOwpAQCAtNzIwLDYgKzcyMCwyMSBAQAogCQkJc3JiLT5yZXN1bHQgPSBESURfQUJPUlQgPDwgMTY7CiAJCQlnb3RvIEhhbmRsZV9FcnJvcnM7CiAJCX0KKworCQkvKiBTb21lIGRldmljZXMgY2xhaW0gdG8gc3VwcG9ydCBsYXJnZXIgc2Vuc2UgYnV0IGZhaWwgd2hlbgorCQkgKiB0cnlpbmcgdG8gcmVxdWVzdCBpdC4gV2hlbiBhIHRyYW5zcG9ydCBmYWlsdXJlIGhhcHBlbnMKKwkJICogdXNpbmcgVVNfRlNfU0FORV9TRU5TRSwgd2UgYWx3YXlzIHJldHJ5IHdpdGggYSBzdGFuZGFyZAorCQkgKiAoc21hbGwpIHNlbnNlIHJlcXVlc3QuIFRoaXMgZml4ZXMgc29tZSBVU0IgR1NNIG1vZGVtcworCQkgKi8KKwkJaWYgKHRlbXBfcmVzdWx0ID09IFVTQl9TVE9SX1RSQU5TUE9SVF9GQUlMRUQgJiYKKwkJICAgICh1cy0+ZmZsYWdzICYgVVNfRkxfU0FORV9TRU5TRSkgJiYKKwkJICAgIHNlbnNlX3NpemUgIT0gVVNfU0VOU0VfU0laRSkgeworCQkJVVNfREVCVUdQKCItLSBhdXRvLXNlbnNlIGZhaWx1cmUsIHJldHJ5IHNtYWxsIHNlbnNlXG4iKTsKKwkJCXNlbnNlX3NpemUgPSBVU19TRU5TRV9TSVpFOworCQkJZ290byBSZXRyeV9TZW5zZTsKKwkJfQorCisJCS8qIE90aGVyIGZhaWx1cmVzICovCiAJCWlmICh0ZW1wX3Jlc3VsdCAhPSBVU0JfU1RPUl9UUkFOU1BPUlRfR09PRCkgewogCQkJVVNfREVCVUdQKCItLSBhdXRvLXNlbnNlIGZhaWx1cmVcbiIpOwogCkBAIC03NjgsMTcgKzc4MywzMiBAQAogCQkvKiBzZXQgdGhlIHJlc3VsdCBzbyB0aGUgaGlnaGVyIGxheWVycyBleHBlY3QgdGhpcyBkYXRhICovCiAJCXNyYi0+cmVzdWx0ID0gU0FNX1NUQVRfQ0hFQ0tfQ09ORElUSU9OOwogCi0JCS8qIElmIHRoaW5ncyBhcmUgcmVhbGx5IG9rYXksIHRoZW4gbGV0J3Mgc2hvdyB0aGF0LiAgWmVybwotCQkgKiBvdXQgdGhlIHNlbnNlIGJ1ZmZlciBzbyB0aGUgaGlnaGVyIGxheWVycyB3b24ndCByZWFsaXplCi0JCSAqIHdlIGRpZCBhbiB1bnNvbGljaXRlZCBhdXRvLXNlbnNlLiAqLwotCQlpZiAocmVzdWx0ID09IFVTQl9TVE9SX1RSQU5TUE9SVF9HT09EICYmCi0JCQkvKiBGaWxlbWFyayAwLCBpZ25vcmUgRU9NLCBJTEkgMCwgbm8gc2Vuc2UgKi8KKwkJLyogV2Ugb2Z0ZW4gZ2V0IGVtcHR5IHNlbnNlIGRhdGEuICBUaGlzIGNvdWxkIGluZGljYXRlIHRoYXQKKwkJICogZXZlcnl0aGluZyB3b3JrZWQgb3IgdGhhdCB0aGVyZSB3YXMgYW4gdW5zcGVjaWZpZWQKKwkJICogcHJvYmxlbS4gIFdlIGhhdmUgdG8gZGVjaWRlIHdoaWNoLgorCQkgKi8KKwkJaWYgKAkvKiBGaWxlbWFyayAwLCBpZ25vcmUgRU9NLCBJTEkgMCwgbm8gc2Vuc2UgKi8KIAkJCQkoc3JiLT5zZW5zZV9idWZmZXJbMl0gJiAweGFmKSA9PSAwICYmCiAJCQkvKiBObyBBU0Mgb3IgQVNDUSAqLwogCQkJCXNyYi0+c2Vuc2VfYnVmZmVyWzEyXSA9PSAwICYmCiAJCQkJc3JiLT5zZW5zZV9idWZmZXJbMTNdID09IDApIHsKLQkJCXNyYi0+cmVzdWx0ID0gU0FNX1NUQVRfR09PRDsKLQkJCXNyYi0+c2Vuc2VfYnVmZmVyWzBdID0gMHgwOworCisJCQkvKiBJZiB0aGluZ3MgYXJlIHJlYWxseSBva2F5LCB0aGVuIGxldCdzIHNob3cgdGhhdC4KKwkJCSAqIFplcm8gb3V0IHRoZSBzZW5zZSBidWZmZXIgc28gdGhlIGhpZ2hlciBsYXllcnMKKwkJCSAqIHdvbid0IHJlYWxpemUgd2UgZGlkIGFuIHVuc29saWNpdGVkIGF1dG8tc2Vuc2UuCisJCQkgKi8KKwkJCWlmIChyZXN1bHQgPT0gVVNCX1NUT1JfVFJBTlNQT1JUX0dPT0QpIHsKKwkJCQlzcmItPnJlc3VsdCA9IFNBTV9TVEFUX0dPT0Q7CisJCQkJc3JiLT5zZW5zZV9idWZmZXJbMF0gPSAweDA7CisKKwkJCS8qIElmIHRoZXJlIHdhcyBhIHByb2JsZW0sIHJlcG9ydCBhbiB1bnNwZWNpZmllZAorCQkJICogaGFyZHdhcmUgZXJyb3IgdG8gcHJldmVudCB0aGUgaGlnaGVyIGxheWVycyBmcm9tCisJCQkgKiBlbnRlcmluZyBhbiBpbmZpbml0ZSByZXRyeSBsb29wLgorCQkJICovCisJCQl9IGVsc2UgeworCQkJCXNyYi0+cmVzdWx0ID0gRElEX0VSUk9SIDw8IDE2OworCQkJCXNyYi0+c2Vuc2VfYnVmZmVyWzJdID0gSEFSRFdBUkVfRVJST1I7CisJCQl9CiAJCX0KIAl9CiAKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdW51c3VhbF9kZXZzLmggYi9kcml2ZXJzL3VzYi9zdG9yYWdlL3VudXN1YWxfZGV2cy5oCmluZGV4IDA3OWFlMGYuLmQ0ZjAzNGUgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvdXNiL3N0b3JhZ2UvdW51c3VhbF9kZXZzLmgKKysrIGIvZHJpdmVycy91c2Ivc3RvcmFnZS91bnVzdWFsX2RldnMuaApAQCAtMTgyMyw2ICsxODIzLDEzIEBACiAJCVVTX1NDX0RFVklDRSwgVVNfUFJfREVWSUNFLCBOVUxMLAogCQlVU19GTF9JR05PUkVfUkVTSURVRSApLAogCisvKiBSZXBvcnRlZCBieSBTZXJnZXkgUGluYWV2IDxkZm9AYW50ZXgucnU+ICovCitVTlVTVUFMX0RFViggIDB4NDEwMiwgMHgxMDU5LCAweDAwMDAsICAweDAwMDAsCisgICAgICAgICAgICAgICAiaVJpdmVyIiwKKyAgICAgICAgICAgICAgICJQN0siLAorICAgICAgICAgICAgICAgVVNfU0NfREVWSUNFLCBVU19QUl9ERVZJQ0UsIE5VTEwsCisgICAgICAgICAgICAgICBVU19GTF9NQVhfU0VDVE9SU182NCApLAorCiAvKgogICogRGF2aWQgSMOkcmRlbWFuIDxkYXZpZEAyZ2VuLmNvbT4KICAqIFRoZSBrZXkgbWFrZXMgdGhlIFNDU0kgc3RhY2sgcHJpbnQgY29uZnVzaW5nIChidXQgaGFybWxlc3MpIG1lc3NhZ2VzCmRpZmYgLS1naXQgYS9kcml2ZXJzL3VzYi93dXNiY29yZS9zZWN1cml0eS5jIGIvZHJpdmVycy91c2Ivd3VzYmNvcmUvc2VjdXJpdHkuYwppbmRleCBiMmYxNDlmLi40NTE2YzM2IDEwMDY0NAotLS0gYS9kcml2ZXJzL3VzYi93dXNiY29yZS9zZWN1cml0eS5jCisrKyBiL2RyaXZlcnMvdXNiL3d1c2Jjb3JlL3NlY3VyaXR5LmMKQEAgLTIwMCwzNSArMjAwLDQwIEBACiB7CiAJaW50IHJlc3VsdCwgYnl0ZXMsIHNlY2Rfc2l6ZTsKIAlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmdXNiX2Rldi0+ZGV2OwotCXN0cnVjdCB1c2Jfc2VjdXJpdHlfZGVzY3JpcHRvciBzZWNkOworCXN0cnVjdCB1c2Jfc2VjdXJpdHlfZGVzY3JpcHRvciAqc2VjZDsKIAljb25zdCBzdHJ1Y3QgdXNiX2VuY3J5cHRpb25fZGVzY3JpcHRvciAqZXRkLCAqY2NtMV9ldGQgPSBOVUxMOwotCXZvaWQgKnNlY2RfYnVmOwogCWNvbnN0IHZvaWQgKml0ciwgKnRvcDsKIAljaGFyIGJ1Zls2NF07CiAKKwlzZWNkID0ga21hbGxvYyhzaXplb2Yoc3RydWN0IHVzYl9zZWN1cml0eV9kZXNjcmlwdG9yKSwgR0ZQX0tFUk5FTCk7CisJaWYgKHNlY2QgPT0gTlVMTCkgeworCQlyZXN1bHQgPSAtRU5PTUVNOworCQlnb3RvIG91dDsKKwl9CisKIAlyZXN1bHQgPSB1c2JfZ2V0X2Rlc2NyaXB0b3IodXNiX2RldiwgVVNCX0RUX1NFQ1VSSVRZLAotCQkJCSAgICAwLCAmc2VjZCwgc2l6ZW9mKHNlY2QpKTsKKwkJCQkgICAgMCwgc2VjZCwgc2l6ZW9mKHN0cnVjdCB1c2Jfc2VjdXJpdHlfZGVzY3JpcHRvcikpOwogCWlmIChyZXN1bHQgPCBzaXplb2Yoc2VjZCkpIHsKIAkJZGV2X2VycihkZXYsICJDYW4ndCByZWFkIHNlY3VyaXR5IGRlc2NyaXB0b3Igb3IgIgogCQkJIm5vdCBlbm91Z2ggZGF0YTogJWRcbiIsIHJlc3VsdCk7Ci0JCWdvdG8gZXJyb3Jfc2VjZDsKKwkJZ290byBvdXQ7CiAJfQotCXNlY2Rfc2l6ZSA9IGxlMTZfdG9fY3B1KHNlY2Qud1RvdGFsTGVuZ3RoKTsKLQlzZWNkX2J1ZiA9IGttYWxsb2Moc2VjZF9zaXplLCBHRlBfS0VSTkVMKTsKLQlpZiAoc2VjZF9idWYgPT0gTlVMTCkgeworCXNlY2Rfc2l6ZSA9IGxlMTZfdG9fY3B1KHNlY2QtPndUb3RhbExlbmd0aCk7CisJc2VjZCA9IGtyZWFsbG9jKHNlY2QsIHNlY2Rfc2l6ZSwgR0ZQX0tFUk5FTCk7CisJaWYgKHNlY2QgPT0gTlVMTCkgewogCQlkZXZfZXJyKGRldiwgIkNhbid0IGFsbG9jYXRlIHNwYWNlIGZvciBzZWN1cml0eSBkZXNjcmlwdG9yc1xuIik7Ci0JCWdvdG8gZXJyb3Jfc2VjZF9hbGxvYzsKKwkJZ290byBvdXQ7CiAJfQogCXJlc3VsdCA9IHVzYl9nZXRfZGVzY3JpcHRvcih1c2JfZGV2LCBVU0JfRFRfU0VDVVJJVFksCi0JCQkJICAgIDAsIHNlY2RfYnVmLCBzZWNkX3NpemUpOworCQkJCSAgICAwLCBzZWNkLCBzZWNkX3NpemUpOwogCWlmIChyZXN1bHQgPCBzZWNkX3NpemUpIHsKIAkJZGV2X2VycihkZXYsICJDYW4ndCByZWFkIHNlY3VyaXR5IGRlc2NyaXB0b3Igb3IgIgogCQkJIm5vdCBlbm91Z2ggZGF0YTogJWRcbiIsIHJlc3VsdCk7Ci0JCWdvdG8gZXJyb3Jfc2VjZF9hbGw7CisJCWdvdG8gb3V0OwogCX0KIAlieXRlcyA9IDA7Ci0JaXRyID0gc2VjZF9idWYgKyBzaXplb2Yoc2VjZCk7Ci0JdG9wID0gc2VjZF9idWYgKyByZXN1bHQ7CisJaXRyID0gJnNlY2RbMV07CisJdG9wID0gKHZvaWQgKilzZWNkICsgcmVzdWx0OwogCXdoaWxlIChpdHIgPCB0b3ApIHsKIAkJZXRkID0gaXRyOwogCQlpZiAodG9wIC0gaXRyIDwgc2l6ZW9mKCpldGQpKSB7CkBAIC0yNTksMjQgKzI2NCwxNiBAQAogCQlkZXZfZXJyKGRldiwgIldVU0IgZGV2aWNlIGRvZXNuJ3Qgc3VwcG9ydCBDQ00xIGVuY3J5cHRpb24sICIKIAkJCSJjYW4ndCB1c2UhXG4iKTsKIAkJcmVzdWx0ID0gLUVJTlZBTDsKLQkJZ290byBlcnJvcl9ub19jY20xOworCQlnb3RvIG91dDsKIAl9CiAJd3VzYl9kZXYtPmNjbTFfZXRkID0gKmNjbTFfZXRkOwogCWRldl9kYmcoZGV2LCAic3VwcG9ydGVkIGVuY3J5cHRpb246ICVzOyB1c2luZyAlcyAoMHglMDJ4LyUwMngpXG4iLAogCQlidWYsIHd1c2JfZXRfbmFtZShjY20xX2V0ZC0+YkVuY3J5cHRpb25UeXBlKSwKIAkJY2NtMV9ldGQtPmJFbmNyeXB0aW9uVmFsdWUsIGNjbTFfZXRkLT5iQXV0aEtleUluZGV4KTsKIAlyZXN1bHQgPSAwOwotCWtmcmVlKHNlY2RfYnVmKTsKIG91dDoKKwlrZnJlZShzZWNkKTsKIAlyZXR1cm4gcmVzdWx0OwotCi0KLWVycm9yX25vX2NjbTE6Ci1lcnJvcl9zZWNkX2FsbDoKLQlrZnJlZShzZWNkX2J1Zik7Ci1lcnJvcl9zZWNkX2FsbG9jOgotZXJyb3Jfc2VjZDoKLQlnb3RvIG91dDsKIH0KIAogdm9pZCB3dXNiX2Rldl9zZWNfcm0oc3RydWN0IHd1c2JfZGV2ICp3dXNiX2RldikKZGlmZiAtLWdpdCBhL2RyaXZlcnMvdXdiL3doYy1yYy5jIGIvZHJpdmVycy91d2Ivd2hjLXJjLmMKaW5kZXggMWQ5YTZmNS4uMDE5NTBjNiAxMDA2NDQKLS0tIGEvZHJpdmVycy91d2Ivd2hjLXJjLmMKKysrIGIvZHJpdmVycy91d2Ivd2hjLXJjLmMKQEAgLTQyLDYgKzQyLDcgQEAKICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvcGNpLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9kbWEtbWFwcGluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgogI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgpkaWZmIC0tZ2l0IGEvZHJpdmVycy92aXJ0aW8vdmlydGlvX2JhbGxvb24uYyBiL2RyaXZlcnMvdmlydGlvL3ZpcnRpb19iYWxsb29uLmMKaW5kZXggMjAwYzIyZi4uOWRkNTg4MCAxMDA2NDQKLS0tIGEvZHJpdmVycy92aXJ0aW8vdmlydGlvX2JhbGxvb24uYworKysgYi9kcml2ZXJzL3ZpcnRpby92aXJ0aW9fYmFsbG9vbi5jCkBAIC0xOSw3ICsxOSw2IEBACiAgKi8KIC8vI2RlZmluZSBERUJVRwogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpby5oPgotI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19pZHMuaD4KICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fYmFsbG9vbi5oPgogI2luY2x1ZGUgPGxpbnV4L3N3YXAuaD4KICNpbmNsdWRlIDxsaW51eC9rdGhyZWFkLmg+CkBAIC0yNDgsNyArMjQ3LDcgQEAKIAlyZXR1cm4gZXJyOwogfQogCi1zdGF0aWMgdm9pZCB2aXJ0YmFsbG9vbl9yZW1vdmUoc3RydWN0IHZpcnRpb19kZXZpY2UgKnZkZXYpCitzdGF0aWMgdm9pZCBfX2RldmV4aXQgdmlydGJhbGxvb25fcmVtb3ZlKHN0cnVjdCB2aXJ0aW9fZGV2aWNlICp2ZGV2KQogewogCXN0cnVjdCB2aXJ0aW9fYmFsbG9vbiAqdmIgPSB2ZGV2LT5wcml2OwogCmRpZmYgLS1naXQgYS9kcml2ZXJzL3dhdGNoZG9nL3Jpb3dkLmMgYi9kcml2ZXJzL3dhdGNoZG9nL3Jpb3dkLmMKaW5kZXggMWU4ZjAyZi4uZDNjODI0ZCAxMDA2NDQKLS0tIGEvZHJpdmVycy93YXRjaGRvZy9yaW93ZC5jCisrKyBiL2RyaXZlcnMvd2F0Y2hkb2cvcmlvd2QuYwpAQCAtMjA2LDcgKzIwNiw3IEBACiAKIAlkZXZfc2V0X2RydmRhdGEoJm9wLT5kZXYsIHApOwogCXJpb3dkX2RldmljZSA9IHA7Ci0JZXJyID0gMDsKKwlyZXR1cm4gMDsKIAogb3V0X2lvdW5tYXA6CiAJb2ZfaW91bm1hcCgmb3AtPnJlc291cmNlWzBdLCBwLT5yZWdzLCAyKTsKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2FjbC5jIGIvZnMvYnRyZnMvYWNsLmMKaW5kZXggNjliMzU1YS4uMzYxNjA0MiAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvYWNsLmMKKysrIGIvZnMvYnRyZnMvYWNsLmMKQEAgLTI3LDcgKzI3LDcgQEAKICNpbmNsdWRlICJidHJmc19pbm9kZS5oIgogI2luY2x1ZGUgInhhdHRyLmgiCiAKLSNpZmRlZiBDT05GSUdfQlRSRlNfUE9TSVhfQUNMCisjaWZkZWYgQ09ORklHX0JUUkZTX0ZTX1BPU0lYX0FDTAogCiBzdGF0aWMgc3RydWN0IHBvc2l4X2FjbCAqYnRyZnNfZ2V0X2FjbChzdHJ1Y3QgaW5vZGUgKmlub2RlLCBpbnQgdHlwZSkKIHsKQEAgLTMxMyw3ICszMTMsNyBAQAogCS5zZXQJPSBidHJmc194YXR0cl9hY2xfYWNjZXNzX3NldCwKIH07CiAKLSNlbHNlIC8qIENPTkZJR19CVFJGU19QT1NJWF9BQ0wgKi8KKyNlbHNlIC8qIENPTkZJR19CVFJGU19GU19QT1NJWF9BQ0wgKi8KIAogaW50IGJ0cmZzX2FjbF9jaG1vZChzdHJ1Y3QgaW5vZGUgKmlub2RlKQogewpAQCAtMzI1LDQgKzMyNSw0IEBACiAJcmV0dXJuIDA7CiB9CiAKLSNlbmRpZiAvKiBDT05GSUdfQlRSRlNfUE9TSVhfQUNMICovCisjZW5kaWYgLyogQ09ORklHX0JUUkZTX0ZTX1BPU0lYX0FDTCAqLwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvYXN5bmMtdGhyZWFkLmMgYi9mcy9idHJmcy9hc3luYy10aHJlYWQuYwppbmRleCAyODJjYTA4Li5jMDg2MWU3IDEwMDY0NAotLS0gYS9mcy9idHJmcy9hc3luYy10aHJlYWQuYworKysgYi9mcy9idHJmcy9hc3luYy10aHJlYWQuYwpAQCAtNjQsNiArNjQsNTEgQEAKIH07CiAKIC8qCisgKiBidHJmc19zdGFydF93b3JrZXJzIHVzZXMga3RocmVhZF9ydW4sIHdoaWNoIGNhbiBibG9jayB3YWl0aW5nIGZvciBtZW1vcnkKKyAqIGZvciBhIHZlcnkgbG9uZyB0aW1lLiAgSXQgd2lsbCBhY3R1YWxseSB0aHJvdHRsZSBvbiBwYWdlIHdyaXRlYmFjaywKKyAqIGFuZCBzbyBpdCBtYXkgbm90IG1ha2UgcHJvZ3Jlc3MgdW50aWwgYWZ0ZXIgb3VyIGJ0cmZzIHdvcmtlciB0aHJlYWRzCisgKiBwcm9jZXNzIGFsbCBvZiB0aGUgcGVuZGluZyB3b3JrIHN0cnVjdHMgaW4gdGhlaXIgcXVldWUKKyAqCisgKiBUaGlzIG1lYW5zIHdlIGNhbid0IHVzZSBidHJmc19zdGFydF93b3JrZXJzIGZyb20gaW5zaWRlIGEgYnRyZnMgd29ya2VyCisgKiB0aHJlYWQgdGhhdCBpcyB1c2VkIGFzIHBhcnQgb2YgY2xlYW5pbmcgZGlydHkgbWVtb3J5LCB3aGljaCBwcmV0dHkgbXVjaAorICogaW52b2x2ZXMgYWxsIG9mIHRoZSB3b3JrZXIgdGhyZWFkcy4KKyAqCisgKiBJbnN0ZWFkIHdlIGhhdmUgYSBoZWxwZXIgcXVldWUgd2hvIG5ldmVyIGhhcyBtb3JlIHRoYW4gb25lIHRocmVhZAorICogd2hlcmUgd2Ugc2NoZWR1bGVyIHRocmVhZCBzdGFydCBvcGVyYXRpb25zLiAgVGhpcyB3b3JrZXJfc3RhcnQgc3RydWN0CisgKiBpcyB1c2VkIHRvIGNvbnRhaW4gdGhlIHdvcmsgYW5kIGhvbGQgYSBwb2ludGVyIHRvIHRoZSBxdWV1ZSB0aGF0IG5lZWRzCisgKiBhbm90aGVyIHdvcmtlci4KKyAqLworc3RydWN0IHdvcmtlcl9zdGFydCB7CisJc3RydWN0IGJ0cmZzX3dvcmsgd29yazsKKwlzdHJ1Y3QgYnRyZnNfd29ya2VycyAqcXVldWU7Cit9OworCitzdGF0aWMgdm9pZCBzdGFydF9uZXdfd29ya2VyX2Z1bmMoc3RydWN0IGJ0cmZzX3dvcmsgKndvcmspCit7CisJc3RydWN0IHdvcmtlcl9zdGFydCAqc3RhcnQ7CisJc3RhcnQgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IHdvcmtlcl9zdGFydCwgd29yayk7CisJYnRyZnNfc3RhcnRfd29ya2VycyhzdGFydC0+cXVldWUsIDEpOworCWtmcmVlKHN0YXJ0KTsKK30KKworc3RhdGljIGludCBzdGFydF9uZXdfd29ya2VyKHN0cnVjdCBidHJmc193b3JrZXJzICpxdWV1ZSkKK3sKKwlzdHJ1Y3Qgd29ya2VyX3N0YXJ0ICpzdGFydDsKKwlpbnQgcmV0OworCisJc3RhcnQgPSBremFsbG9jKHNpemVvZigqc3RhcnQpLCBHRlBfTk9GUyk7CisJaWYgKCFzdGFydCkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwlzdGFydC0+d29yay5mdW5jID0gc3RhcnRfbmV3X3dvcmtlcl9mdW5jOworCXN0YXJ0LT5xdWV1ZSA9IHF1ZXVlOworCXJldCA9IGJ0cmZzX3F1ZXVlX3dvcmtlcihxdWV1ZS0+YXRvbWljX3dvcmtlcl9zdGFydCwgJnN0YXJ0LT53b3JrKTsKKwlpZiAocmV0KQorCQlrZnJlZShzdGFydCk7CisJcmV0dXJuIHJldDsKK30KKworLyoKICAqIGhlbHBlciBmdW5jdGlvbiB0byBtb3ZlIGEgdGhyZWFkIG9udG8gdGhlIGlkbGUgbGlzdCBhZnRlciBpdAogICogaGFzIGZpbmlzaGVkIHNvbWUgcmVxdWVzdHMuCiAgKi8KQEAgLTExOCwxMSArMTYzLDEzIEBACiAJCWdvdG8gb3V0OwogCiAJd29ya2Vycy0+YXRvbWljX3N0YXJ0X3BlbmRpbmcgPSAwOwotCWlmICh3b3JrZXJzLT5udW1fd29ya2VycyA+PSB3b3JrZXJzLT5tYXhfd29ya2VycykKKwlpZiAod29ya2Vycy0+bnVtX3dvcmtlcnMgKyB3b3JrZXJzLT5udW1fd29ya2Vyc19zdGFydGluZyA+PQorCSAgICB3b3JrZXJzLT5tYXhfd29ya2VycykKIAkJZ290byBvdXQ7CiAKKwl3b3JrZXJzLT5udW1fd29ya2Vyc19zdGFydGluZyArPSAxOwogCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJndvcmtlcnMtPmxvY2ssIGZsYWdzKTsKLQlidHJmc19zdGFydF93b3JrZXJzKHdvcmtlcnMsIDEpOworCXN0YXJ0X25ld193b3JrZXIod29ya2Vycyk7CiAJcmV0dXJuOwogCiBvdXQ6CkBAIC0zOTAsOSArNDM3LDExIEBACiAvKgogICogc2ltcGxlIGluaXQgb24gc3RydWN0IGJ0cmZzX3dvcmtlcnMKICAqLwotdm9pZCBidHJmc19pbml0X3dvcmtlcnMoc3RydWN0IGJ0cmZzX3dvcmtlcnMgKndvcmtlcnMsIGNoYXIgKm5hbWUsIGludCBtYXgpCit2b2lkIGJ0cmZzX2luaXRfd29ya2VycyhzdHJ1Y3QgYnRyZnNfd29ya2VycyAqd29ya2VycywgY2hhciAqbmFtZSwgaW50IG1heCwKKwkJCXN0cnVjdCBidHJmc193b3JrZXJzICphc3luY19oZWxwZXIpCiB7CiAJd29ya2Vycy0+bnVtX3dvcmtlcnMgPSAwOworCXdvcmtlcnMtPm51bV93b3JrZXJzX3N0YXJ0aW5nID0gMDsKIAlJTklUX0xJU1RfSEVBRCgmd29ya2Vycy0+d29ya2VyX2xpc3QpOwogCUlOSVRfTElTVF9IRUFEKCZ3b3JrZXJzLT5pZGxlX2xpc3QpOwogCUlOSVRfTElTVF9IRUFEKCZ3b3JrZXJzLT5vcmRlcl9saXN0KTsKQEAgLTQwNCwxNCArNDUzLDE1IEBACiAJd29ya2Vycy0+bmFtZSA9IG5hbWU7CiAJd29ya2Vycy0+b3JkZXJlZCA9IDA7CiAJd29ya2Vycy0+YXRvbWljX3N0YXJ0X3BlbmRpbmcgPSAwOwotCXdvcmtlcnMtPmF0b21pY193b3JrZXJfc3RhcnQgPSAwOworCXdvcmtlcnMtPmF0b21pY193b3JrZXJfc3RhcnQgPSBhc3luY19oZWxwZXI7CiB9CiAKIC8qCiAgKiBzdGFydHMgbmV3IHdvcmtlciB0aHJlYWRzLiAgVGhpcyBkb2VzIG5vdCBlbmZvcmNlIHRoZSBtYXggd29ya2VyCiAgKiBjb3VudCBpbiBjYXNlIHlvdSBuZWVkIHRvIHRlbXBvcmFyaWx5IGdvIHBhc3QgaXQuCiAgKi8KLWludCBidHJmc19zdGFydF93b3JrZXJzKHN0cnVjdCBidHJmc193b3JrZXJzICp3b3JrZXJzLCBpbnQgbnVtX3dvcmtlcnMpCitzdGF0aWMgaW50IF9fYnRyZnNfc3RhcnRfd29ya2VycyhzdHJ1Y3QgYnRyZnNfd29ya2VycyAqd29ya2VycywKKwkJCQkgaW50IG51bV93b3JrZXJzKQogewogCXN0cnVjdCBidHJmc193b3JrZXJfdGhyZWFkICp3b3JrZXI7CiAJaW50IHJldCA9IDA7CkBAIC00NDQsNiArNDk0LDggQEAKIAkJbGlzdF9hZGRfdGFpbCgmd29ya2VyLT53b3JrZXJfbGlzdCwgJndvcmtlcnMtPmlkbGVfbGlzdCk7CiAJCXdvcmtlci0+aWRsZSA9IDE7CiAJCXdvcmtlcnMtPm51bV93b3JrZXJzKys7CisJCXdvcmtlcnMtPm51bV93b3JrZXJzX3N0YXJ0aW5nLS07CisJCVdBUk5fT04od29ya2Vycy0+bnVtX3dvcmtlcnNfc3RhcnRpbmcgPCAwKTsKIAkJc3Bpbl91bmxvY2tfaXJxKCZ3b3JrZXJzLT5sb2NrKTsKIAl9CiAJcmV0dXJuIDA7CkBAIC00NTIsNiArNTA0LDE0IEBACiAJcmV0dXJuIHJldDsKIH0KIAoraW50IGJ0cmZzX3N0YXJ0X3dvcmtlcnMoc3RydWN0IGJ0cmZzX3dvcmtlcnMgKndvcmtlcnMsIGludCBudW1fd29ya2VycykKK3sKKwlzcGluX2xvY2tfaXJxKCZ3b3JrZXJzLT5sb2NrKTsKKwl3b3JrZXJzLT5udW1fd29ya2Vyc19zdGFydGluZyArPSBudW1fd29ya2VyczsKKwlzcGluX3VubG9ja19pcnEoJndvcmtlcnMtPmxvY2spOworCXJldHVybiBfX2J0cmZzX3N0YXJ0X3dvcmtlcnMod29ya2VycywgbnVtX3dvcmtlcnMpOworfQorCiAvKgogICogcnVuIHRocm91Z2ggdGhlIGxpc3QgYW5kIGZpbmQgYSB3b3JrZXIgdGhyZWFkIHRoYXQgZG9lc24ndCBoYXZlIGEgbG90CiAgKiB0byBkbyByaWdodCBub3cuICBUaGlzIGNhbiByZXR1cm4gbnVsbCBpZiB3ZSBhcmVuJ3QgeWV0IGF0IHRoZSB0aHJlYWQKQEAgLTQ2MSw3ICs1MjEsMTAgQEAKIHsKIAlzdHJ1Y3QgYnRyZnNfd29ya2VyX3RocmVhZCAqd29ya2VyOwogCXN0cnVjdCBsaXN0X2hlYWQgKm5leHQ7Ci0JaW50IGVuZm9yY2VfbWluID0gd29ya2Vycy0+bnVtX3dvcmtlcnMgPCB3b3JrZXJzLT5tYXhfd29ya2VyczsKKwlpbnQgZW5mb3JjZV9taW47CisKKwllbmZvcmNlX21pbiA9ICh3b3JrZXJzLT5udW1fd29ya2VycyArIHdvcmtlcnMtPm51bV93b3JrZXJzX3N0YXJ0aW5nKSA8CisJCXdvcmtlcnMtPm1heF93b3JrZXJzOwogCiAJLyoKIAkgKiBpZiB3ZSBmaW5kIGFuIGlkbGUgdGhyZWFkLCBkb24ndCBtb3ZlIGl0IHRvIHRoZSBlbmQgb2YgdGhlCkBAIC01MDksMTUgKzU3MiwxNyBAQAogCXdvcmtlciA9IG5leHRfd29ya2VyKHdvcmtlcnMpOwogCiAJaWYgKCF3b3JrZXIpIHsKLQkJaWYgKHdvcmtlcnMtPm51bV93b3JrZXJzID49IHdvcmtlcnMtPm1heF93b3JrZXJzKSB7CisJCWlmICh3b3JrZXJzLT5udW1fd29ya2VycyArIHdvcmtlcnMtPm51bV93b3JrZXJzX3N0YXJ0aW5nID49CisJCSAgICB3b3JrZXJzLT5tYXhfd29ya2VycykgewogCQkJZ290byBmYWxsYmFjazsKIAkJfSBlbHNlIGlmICh3b3JrZXJzLT5hdG9taWNfd29ya2VyX3N0YXJ0KSB7CiAJCQl3b3JrZXJzLT5hdG9taWNfc3RhcnRfcGVuZGluZyA9IDE7CiAJCQlnb3RvIGZhbGxiYWNrOwogCQl9IGVsc2UgeworCQkJd29ya2Vycy0+bnVtX3dvcmtlcnNfc3RhcnRpbmcrKzsKIAkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJndvcmtlcnMtPmxvY2ssIGZsYWdzKTsKIAkJCS8qIHdlJ3JlIGJlbG93IHRoZSBsaW1pdCwgc3RhcnQgYW5vdGhlciB3b3JrZXIgKi8KLQkJCWJ0cmZzX3N0YXJ0X3dvcmtlcnMod29ya2VycywgMSk7CisJCQlfX2J0cmZzX3N0YXJ0X3dvcmtlcnMod29ya2VycywgMSk7CiAJCQlnb3RvIGFnYWluOwogCQl9CiAJfQpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvYXN5bmMtdGhyZWFkLmggYi9mcy9idHJmcy9hc3luYy10aHJlYWQuaAppbmRleCBmYzA4OWI5Li41MDc3NzQ2IDEwMDY0NAotLS0gYS9mcy9idHJmcy9hc3luYy10aHJlYWQuaAorKysgYi9mcy9idHJmcy9hc3luYy10aHJlYWQuaApAQCAtNjQsNiArNjQsOCBAQAogCS8qIGN1cnJlbnQgbnVtYmVyIG9mIHJ1bm5pbmcgd29ya2VycyAqLwogCWludCBudW1fd29ya2VyczsKIAorCWludCBudW1fd29ya2Vyc19zdGFydGluZzsKKwogCS8qIG1heCBudW1iZXIgb2Ygd29ya2VycyBhbGxvd2VkLiAgY2hhbmdlZCBieSBidHJmc19zdGFydF93b3JrZXJzICovCiAJaW50IG1heF93b3JrZXJzOwogCkBAIC03OCw5ICs4MCwxMCBAQAogCiAJLyoKIAkgKiBhcmUgd2UgYWxsb3dlZCB0byBzbGVlcCB3aGlsZSBzdGFydGluZyB3b3JrZXJzIG9yIGFyZSB3ZSByZXF1aXJlZAotCSAqIHRvIHN0YXJ0IHRoZW0gYXQgYSBsYXRlciB0aW1lPworCSAqIHRvIHN0YXJ0IHRoZW0gYXQgYSBsYXRlciB0aW1lPyAgSWYgd2UgY2FuJ3Qgc2xlZXAsIHRoaXMgaW5kaWNhdGVzCisJICogd2hpY2ggcXVldWUgd2UgbmVlZCB0byB1c2UgdG8gc2NoZWR1bGUgdGhyZWFkIGNyZWF0aW9uLgogCSAqLwotCWludCBhdG9taWNfd29ya2VyX3N0YXJ0OworCXN0cnVjdCBidHJmc193b3JrZXJzICphdG9taWNfd29ya2VyX3N0YXJ0OwogCiAJLyogbGlzdCB3aXRoIGFsbCB0aGUgd29yayB0aHJlYWRzLiAgVGhlIHdvcmtlcnMgb24gdGhlIGlkbGUgdGhyZWFkCiAJICogbWF5IGJlIGFjdGl2ZWx5IHNlcnZpY2luZyBqb2JzLCBidXQgdGhleSBoYXZlbid0IHlldCBoaXQgdGhlCkBAIC0xMDksNyArMTEyLDggQEAKIGludCBidHJmc19xdWV1ZV93b3JrZXIoc3RydWN0IGJ0cmZzX3dvcmtlcnMgKndvcmtlcnMsIHN0cnVjdCBidHJmc193b3JrICp3b3JrKTsKIGludCBidHJmc19zdGFydF93b3JrZXJzKHN0cnVjdCBidHJmc193b3JrZXJzICp3b3JrZXJzLCBpbnQgbnVtX3dvcmtlcnMpOwogaW50IGJ0cmZzX3N0b3Bfd29ya2VycyhzdHJ1Y3QgYnRyZnNfd29ya2VycyAqd29ya2Vycyk7Ci12b2lkIGJ0cmZzX2luaXRfd29ya2VycyhzdHJ1Y3QgYnRyZnNfd29ya2VycyAqd29ya2VycywgY2hhciAqbmFtZSwgaW50IG1heCk7Cit2b2lkIGJ0cmZzX2luaXRfd29ya2VycyhzdHJ1Y3QgYnRyZnNfd29ya2VycyAqd29ya2VycywgY2hhciAqbmFtZSwgaW50IG1heCwKKwkJCXN0cnVjdCBidHJmc193b3JrZXJzICphc3luY19zdGFydGVyKTsKIGludCBidHJmc19yZXF1ZXVlX3dvcmsoc3RydWN0IGJ0cmZzX3dvcmsgKndvcmspOwogdm9pZCBidHJmc19zZXRfd29ya19oaWdoX3ByaW8oc3RydWN0IGJ0cmZzX3dvcmsgKndvcmspOwogI2VuZGlmCmRpZmYgLS1naXQgYS9mcy9idHJmcy9idHJmc19pbm9kZS5oIGIvZnMvYnRyZnMvYnRyZnNfaW5vZGUuaAppbmRleCBhNTRkMzU0Li5mNjc4M2E0IDEwMDY0NAotLS0gYS9mcy9idHJmcy9idHJmc19pbm9kZS5oCisrKyBiL2ZzL2J0cmZzL2J0cmZzX2lub2RlLmgKQEAgLTg2LDYgKzg2LDEyIEBACiAJICogdHJhbnNpZCBvZiB0aGUgdHJhbnNfaGFuZGxlIHRoYXQgbGFzdCBtb2RpZmllZCB0aGlzIGlub2RlCiAJICovCiAJdTY0IGxhc3RfdHJhbnM7CisKKwkvKgorCSAqIGxvZyB0cmFuc2lkIHdoZW4gdGhpcyBpbm9kZSB3YXMgbGFzdCBtb2RpZmllZAorCSAqLworCXU2NCBsYXN0X3N1Yl90cmFuczsKKwogCS8qCiAJICogdHJhbnNpZCB0aGF0IGxhc3QgbG9nZ2VkIHRoaXMgaW5vZGUKIAkgKi8KQEAgLTEyOCwxMiArMTM0LDE0IEBACiAJdTY0IGxhc3RfdW5saW5rX3RyYW5zOwogCiAJLyoKLQkgKiBUaGVzZSB0d28gY291bnRlcnMgYXJlIGZvciBkZWxhbGxvYyBtZXRhZGF0YSByZXNlcnZhdGlvbnMuICBXZSBrZWVwCi0JICogdHJhY2sgb2YgaG93IG1hbnkgZXh0ZW50cyB3ZSd2ZSBhY2NvdW50ZWQgZm9yIHZzIGhvdyBtYW55IGV4dGVudHMgd2UKLQkgKiBoYXZlLgorCSAqIENvdW50ZXJzIHRvIGtlZXAgdHJhY2sgb2YgdGhlIG51bWJlciBvZiBleHRlbnQgaXRlbSdzIHdlIG1heSB1c2UgZHVlCisJICogdG8gZGVsYWxsb2MgYW5kIHN1Y2guICBvdXRzdGFuZGluZ19leHRlbnRzIGlzIHRoZSBudW1iZXIgb2YgZXh0ZW50CisJICogaXRlbXMgd2UgdGhpbmsgd2UnbGwgZW5kIHVwIHVzaW5nLCBhbmQgcmVzZXJ2ZWRfZXh0ZW50cyBpcyB0aGUgbnVtYmVyCisJICogb2YgZXh0ZW50IGl0ZW1zIHdlJ3ZlIHJlc2VydmVkIG1ldGFkYXRhIGZvci4KIAkgKi8KLQlpbnQgZGVsYWxsb2NfcmVzZXJ2ZWRfZXh0ZW50czsKLQlpbnQgZGVsYWxsb2NfZXh0ZW50czsKKwlzcGlubG9ja190IGFjY291bnRpbmdfbG9jazsKKwlpbnQgcmVzZXJ2ZWRfZXh0ZW50czsKKwlpbnQgb3V0c3RhbmRpbmdfZXh0ZW50czsKIAogCS8qCiAJICogb3JkZXJlZF9kYXRhX2Nsb3NlIGlzIHNldCBieSB0cnVuY2F0ZSB3aGVuIGEgZmlsZSB0aGF0IHVzZWQKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL2N0cmVlLmggYi9mcy9idHJmcy9jdHJlZS5oCmluZGV4IGRkOGNlZDkuLjQ0NGIzZTkgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL2N0cmVlLmgKKysrIGIvZnMvYnRyZnMvY3RyZWUuaApAQCAtNjkxLDE0ICs2OTEsMTcgQEAKIAogCXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKIAorCS8qIGZvciBjb250cm9sbGluZyBob3cgd2UgZnJlZSB1cCBzcGFjZSBmb3IgYWxsb2NhdGlvbnMgKi8KKwl3YWl0X3F1ZXVlX2hlYWRfdCBhbGxvY2F0ZV93YWl0OworCXdhaXRfcXVldWVfaGVhZF90IGZsdXNoX3dhaXQ7CisJaW50IGFsbG9jYXRpbmdfY2h1bms7CisJaW50IGZsdXNoaW5nOworCiAJLyogZm9yIGJsb2NrIGdyb3VwcyBpbiBvdXIgc2FtZSB0eXBlICovCiAJc3RydWN0IGxpc3RfaGVhZCBibG9ja19ncm91cHM7CiAJc3BpbmxvY2tfdCBsb2NrOwogCXN0cnVjdCByd19zZW1hcGhvcmUgZ3JvdXBzX3NlbTsKIAlhdG9taWNfdCBjYWNoaW5nX3RocmVhZHM7Ci0KLQlpbnQgYWxsb2NhdGluZ19jaHVuazsKLQl3YWl0X3F1ZXVlX2hlYWRfdCB3YWl0OwogfTsKIAogLyoKQEAgLTkwNyw2ICs5MTAsNyBAQAogCSAqIEEgdGhpcmQgcG9vbCBkb2VzIHN1Ym1pdF9iaW8gdG8gYXZvaWQgZGVhZGxvY2tpbmcgd2l0aCB0aGUgb3RoZXIKIAkgKiB0d28KIAkgKi8KKwlzdHJ1Y3QgYnRyZnNfd29ya2VycyBnZW5lcmljX3dvcmtlcjsKIAlzdHJ1Y3QgYnRyZnNfd29ya2VycyB3b3JrZXJzOwogCXN0cnVjdCBidHJmc193b3JrZXJzIGRlbGFsbG9jX3dvcmtlcnM7CiAJc3RydWN0IGJ0cmZzX3dvcmtlcnMgZW5kaW9fd29ya2VyczsKQEAgLTkxNCw2ICs5MTgsNyBAQAogCXN0cnVjdCBidHJmc193b3JrZXJzIGVuZGlvX21ldGFfd3JpdGVfd29ya2VyczsKIAlzdHJ1Y3QgYnRyZnNfd29ya2VycyBlbmRpb193cml0ZV93b3JrZXJzOwogCXN0cnVjdCBidHJmc193b3JrZXJzIHN1Ym1pdF93b3JrZXJzOworCXN0cnVjdCBidHJmc193b3JrZXJzIGVub3NwY193b3JrZXJzOwogCS8qCiAJICogZml4dXAgd29ya2VycyB0YWtlIGRpcnR5IHBhZ2VzIHRoYXQgZGlkbid0IHByb3Blcmx5IGdvIHRocm91Z2gKIAkgKiB0aGUgY293IG1lY2hhbmlzbSBhbmQgbWFrZSB0aGVtIHNhZmUgdG8gd3JpdGUuICBJdCBoYXBwZW5zCkBAIC0xMDA0LDcgKzEwMDksMTAgQEAKIAlhdG9taWNfdCBsb2dfd3JpdGVyczsKIAlhdG9taWNfdCBsb2dfY29tbWl0WzJdOwogCXVuc2lnbmVkIGxvbmcgbG9nX3RyYW5zaWQ7CisJdW5zaWduZWQgbG9uZyBsYXN0X2xvZ19jb21taXQ7CiAJdW5zaWduZWQgbG9uZyBsb2dfYmF0Y2g7CisJcGlkX3QgbG9nX3N0YXJ0X3BpZDsKKwlib29sIGxvZ19tdWx0aXBsZV9waWRzOwogCiAJdTY0IG9iamVjdGlkOwogCXU2NCBsYXN0X3RyYW5zOwpAQCAtMTE0NSw2ICsxMTUzLDcgQEAKICNkZWZpbmUgQlRSRlNfTU9VTlRfRkxVU0hPTkNPTU1JVCAgICAgICAoMSA8PCA3KQogI2RlZmluZSBCVFJGU19NT1VOVF9TU0RfU1BSRUFECQkoMSA8PCA4KQogI2RlZmluZSBCVFJGU19NT1VOVF9OT1NTRAkJKDEgPDwgOSkKKyNkZWZpbmUgQlRSRlNfTU9VTlRfRElTQ0FSRAkJKDEgPDwgMTApCiAKICNkZWZpbmUgYnRyZnNfY2xlYXJfb3B0KG8sIG9wdCkJCSgobykgJj0gfkJUUkZTX01PVU5UXyMjb3B0KQogI2RlZmluZSBidHJmc19zZXRfb3B0KG8sIG9wdCkJCSgobykgfD0gQlRSRlNfTU9VTlRfIyNvcHQpCkBAIC0yMzIzLDcgKzIzMzIsNyBAQAogdm9pZCBidHJmc19vcnBoYW5fY2xlYW51cChzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCk7CiBpbnQgYnRyZnNfY29udF9leHBhbmQoc3RydWN0IGlub2RlICppbm9kZSwgbG9mZl90IHNpemUpOwogaW50IGJ0cmZzX2ludmFsaWRhdGVfaW5vZGVzKHN0cnVjdCBidHJmc19yb290ICpyb290KTsKLWV4dGVybiBzdHJ1Y3QgZGVudHJ5X29wZXJhdGlvbnMgYnRyZnNfZGVudHJ5X29wZXJhdGlvbnM7CitleHRlcm4gY29uc3Qgc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zIGJ0cmZzX2RlbnRyeV9vcGVyYXRpb25zOwogCiAvKiBpb2N0bC5jICovCiBsb25nIGJ0cmZzX2lvY3RsKHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZyk7CkBAIC0yMzY2LDcgKzIzNzUsNyBAQAogaW50IGJ0cmZzX3N5bmNfZnMoc3RydWN0IHN1cGVyX2Jsb2NrICpzYiwgaW50IHdhaXQpOwogCiAvKiBhY2wuYyAqLwotI2lmZGVmIENPTkZJR19CVFJGU19QT1NJWF9BQ0wKKyNpZmRlZiBDT05GSUdfQlRSRlNfRlNfUE9TSVhfQUNMCiBpbnQgYnRyZnNfY2hlY2tfYWNsKHN0cnVjdCBpbm9kZSAqaW5vZGUsIGludCBtYXNrKTsKICNlbHNlCiAjZGVmaW5lIGJ0cmZzX2NoZWNrX2FjbCBOVUxMCmRpZmYgLS1naXQgYS9mcy9idHJmcy9kaXNrLWlvLmMgYi9mcy9idHJmcy9kaXNrLWlvLmMKaW5kZXggYWYwNDM1Zi4uMDJiNmFmYiAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZGlzay1pby5jCisrKyBiL2ZzL2J0cmZzL2Rpc2staW8uYwpAQCAtOTE3LDYgKzkxNyw3IEBACiAJYXRvbWljX3NldCgmcm9vdC0+bG9nX3dyaXRlcnMsIDApOwogCXJvb3QtPmxvZ19iYXRjaCA9IDA7CiAJcm9vdC0+bG9nX3RyYW5zaWQgPSAwOworCXJvb3QtPmxhc3RfbG9nX2NvbW1pdCA9IDA7CiAJZXh0ZW50X2lvX3RyZWVfaW5pdCgmcm9vdC0+ZGlydHlfbG9nX3BhZ2VzLAogCQkJICAgICBmc19pbmZvLT5idHJlZV9pbm9kZS0+aV9tYXBwaW5nLCBHRlBfTk9GUyk7CiAKQEAgLTEwODcsNiArMTA4OCw3IEBACiAJV0FSTl9PTihyb290LT5sb2dfcm9vdCk7CiAJcm9vdC0+bG9nX3Jvb3QgPSBsb2dfcm9vdDsKIAlyb290LT5sb2dfdHJhbnNpZCA9IDA7CisJcm9vdC0+bGFzdF9sb2dfY29tbWl0ID0gMDsKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTc0NiwyMSArMTc0OCwyNSBAQAogCQllcnIgPSAtRUlOVkFMOwogCQlnb3RvIGZhaWxfaXB1dDsKIAl9Ci1wcmludGsoInRocmVhZCBwb29sIGlzICVkXG4iLCBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplKTsKLQkvKgotCSAqIHdlIG5lZWQgdG8gc3RhcnQgYWxsIHRoZSBlbmRfaW8gd29ya2VycyB1cCBmcm9udCBiZWNhdXNlIHRoZQotCSAqIHF1ZXVlIHdvcmsgZnVuY3Rpb24gZ2V0cyBjYWxsZWQgYXQgaW50ZXJydXB0IHRpbWUsIGFuZCBzbyBpdAotCSAqIGNhbm5vdCBkeW5hbWljYWxseSBncm93LgotCSAqLworCisJYnRyZnNfaW5pdF93b3JrZXJzKCZmc19pbmZvLT5nZW5lcmljX3dvcmtlciwKKwkJCSAgICJnZW53b3JrIiwgMSwgTlVMTCk7CisKIAlidHJmc19pbml0X3dvcmtlcnMoJmZzX2luZm8tPndvcmtlcnMsICJ3b3JrZXIiLAotCQkJICAgZnNfaW5mby0+dGhyZWFkX3Bvb2xfc2l6ZSk7CisJCQkgICBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplLAorCQkJICAgJmZzX2luZm8tPmdlbmVyaWNfd29ya2VyKTsKIAogCWJ0cmZzX2luaXRfd29ya2VycygmZnNfaW5mby0+ZGVsYWxsb2Nfd29ya2VycywgImRlbGFsbG9jIiwKLQkJCSAgIGZzX2luZm8tPnRocmVhZF9wb29sX3NpemUpOworCQkJICAgZnNfaW5mby0+dGhyZWFkX3Bvb2xfc2l6ZSwKKwkJCSAgICZmc19pbmZvLT5nZW5lcmljX3dvcmtlcik7CiAKIAlidHJmc19pbml0X3dvcmtlcnMoJmZzX2luZm8tPnN1Ym1pdF93b3JrZXJzLCAic3VibWl0IiwKIAkJCSAgIG1pbl90KHU2NCwgZnNfZGV2aWNlcy0+bnVtX2RldmljZXMsCi0JCQkgICBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplKSk7CisJCQkgICBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplKSwKKwkJCSAgICZmc19pbmZvLT5nZW5lcmljX3dvcmtlcik7CisJYnRyZnNfaW5pdF93b3JrZXJzKCZmc19pbmZvLT5lbm9zcGNfd29ya2VycywgImVub3NwYyIsCisJCQkgICBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplLAorCQkJICAgJmZzX2luZm8tPmdlbmVyaWNfd29ya2VyKTsKIAogCS8qIGEgaGlnaGVyIGlkbGUgdGhyZXNoIG9uIHRoZSBzdWJtaXQgd29ya2VycyBtYWtlcyBpdCBtdWNoIG1vcmUKIAkgKiBsaWtlbHkgdGhhdCBiaW9zIHdpbGwgYmUgc2VuZCBkb3duIGluIGEgc2FuZSBvcmRlciB0byB0aGUKQEAgLTE3NzQsMTUgKzE3ODAsMjAgQEAKIAlmc19pbmZvLT5kZWxhbGxvY193b3JrZXJzLmlkbGVfdGhyZXNoID0gMjsKIAlmc19pbmZvLT5kZWxhbGxvY193b3JrZXJzLm9yZGVyZWQgPSAxOwogCi0JYnRyZnNfaW5pdF93b3JrZXJzKCZmc19pbmZvLT5maXh1cF93b3JrZXJzLCAiZml4dXAiLCAxKTsKKwlidHJmc19pbml0X3dvcmtlcnMoJmZzX2luZm8tPmZpeHVwX3dvcmtlcnMsICJmaXh1cCIsIDEsCisJCQkgICAmZnNfaW5mby0+Z2VuZXJpY193b3JrZXIpOwogCWJ0cmZzX2luaXRfd29ya2VycygmZnNfaW5mby0+ZW5kaW9fd29ya2VycywgImVuZGlvIiwKLQkJCSAgIGZzX2luZm8tPnRocmVhZF9wb29sX3NpemUpOworCQkJICAgZnNfaW5mby0+dGhyZWFkX3Bvb2xfc2l6ZSwKKwkJCSAgICZmc19pbmZvLT5nZW5lcmljX3dvcmtlcik7CiAJYnRyZnNfaW5pdF93b3JrZXJzKCZmc19pbmZvLT5lbmRpb19tZXRhX3dvcmtlcnMsICJlbmRpby1tZXRhIiwKLQkJCSAgIGZzX2luZm8tPnRocmVhZF9wb29sX3NpemUpOworCQkJICAgZnNfaW5mby0+dGhyZWFkX3Bvb2xfc2l6ZSwKKwkJCSAgICZmc19pbmZvLT5nZW5lcmljX3dvcmtlcik7CiAJYnRyZnNfaW5pdF93b3JrZXJzKCZmc19pbmZvLT5lbmRpb19tZXRhX3dyaXRlX3dvcmtlcnMsCi0JCQkgICAiZW5kaW8tbWV0YS13cml0ZSIsIGZzX2luZm8tPnRocmVhZF9wb29sX3NpemUpOworCQkJICAgImVuZGlvLW1ldGEtd3JpdGUiLCBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplLAorCQkJICAgJmZzX2luZm8tPmdlbmVyaWNfd29ya2VyKTsKIAlidHJmc19pbml0X3dvcmtlcnMoJmZzX2luZm8tPmVuZGlvX3dyaXRlX3dvcmtlcnMsICJlbmRpby13cml0ZSIsCi0JCQkgICBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplKTsKKwkJCSAgIGZzX2luZm8tPnRocmVhZF9wb29sX3NpemUsCisJCQkgICAmZnNfaW5mby0+Z2VuZXJpY193b3JrZXIpOwogCiAJLyoKIAkgKiBlbmRpb3MgYXJlIGxhcmdlbHkgcGFyYWxsZWwgYW5kIHNob3VsZCBoYXZlIGEgdmVyeQpAQCAtMTc5NCwxMiArMTgwNSw4IEBACiAJZnNfaW5mby0+ZW5kaW9fd3JpdGVfd29ya2Vycy5pZGxlX3RocmVzaCA9IDI7CiAJZnNfaW5mby0+ZW5kaW9fbWV0YV93cml0ZV93b3JrZXJzLmlkbGVfdGhyZXNoID0gMjsKIAotCWZzX2luZm8tPmVuZGlvX3dvcmtlcnMuYXRvbWljX3dvcmtlcl9zdGFydCA9IDE7Ci0JZnNfaW5mby0+ZW5kaW9fbWV0YV93b3JrZXJzLmF0b21pY193b3JrZXJfc3RhcnQgPSAxOwotCWZzX2luZm8tPmVuZGlvX3dyaXRlX3dvcmtlcnMuYXRvbWljX3dvcmtlcl9zdGFydCA9IDE7Ci0JZnNfaW5mby0+ZW5kaW9fbWV0YV93cml0ZV93b3JrZXJzLmF0b21pY193b3JrZXJfc3RhcnQgPSAxOwotCiAJYnRyZnNfc3RhcnRfd29ya2VycygmZnNfaW5mby0+d29ya2VycywgMSk7CisJYnRyZnNfc3RhcnRfd29ya2VycygmZnNfaW5mby0+Z2VuZXJpY193b3JrZXIsIDEpOwogCWJ0cmZzX3N0YXJ0X3dvcmtlcnMoJmZzX2luZm8tPnN1Ym1pdF93b3JrZXJzLCAxKTsKIAlidHJmc19zdGFydF93b3JrZXJzKCZmc19pbmZvLT5kZWxhbGxvY193b3JrZXJzLCAxKTsKIAlidHJmc19zdGFydF93b3JrZXJzKCZmc19pbmZvLT5maXh1cF93b3JrZXJzLCAxKTsKQEAgLTE4MDcsNiArMTgxNCw3IEBACiAJYnRyZnNfc3RhcnRfd29ya2VycygmZnNfaW5mby0+ZW5kaW9fbWV0YV93b3JrZXJzLCAxKTsKIAlidHJmc19zdGFydF93b3JrZXJzKCZmc19pbmZvLT5lbmRpb19tZXRhX3dyaXRlX3dvcmtlcnMsIDEpOwogCWJ0cmZzX3N0YXJ0X3dvcmtlcnMoJmZzX2luZm8tPmVuZGlvX3dyaXRlX3dvcmtlcnMsIDEpOworCWJ0cmZzX3N0YXJ0X3dvcmtlcnMoJmZzX2luZm8tPmVub3NwY193b3JrZXJzLCAxKTsKIAogCWZzX2luZm8tPmJkaS5yYV9wYWdlcyAqPSBidHJmc19zdXBlcl9udW1fZGV2aWNlcyhkaXNrX3N1cGVyKTsKIAlmc19pbmZvLT5iZGkucmFfcGFnZXMgPSBtYXgoZnNfaW5mby0+YmRpLnJhX3BhZ2VzLApAQCAtMjAxMiw2ICsyMDIwLDcgQEAKIAlmcmVlX2V4dGVudF9idWZmZXIoY2h1bmtfcm9vdC0+bm9kZSk7CiAJZnJlZV9leHRlbnRfYnVmZmVyKGNodW5rX3Jvb3QtPmNvbW1pdF9yb290KTsKIGZhaWxfc2JfYnVmZmVyOgorCWJ0cmZzX3N0b3Bfd29ya2VycygmZnNfaW5mby0+Z2VuZXJpY193b3JrZXIpOwogCWJ0cmZzX3N0b3Bfd29ya2VycygmZnNfaW5mby0+Zml4dXBfd29ya2Vycyk7CiAJYnRyZnNfc3RvcF93b3JrZXJzKCZmc19pbmZvLT5kZWxhbGxvY193b3JrZXJzKTsKIAlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPndvcmtlcnMpOwpAQCAtMjAyMCw2ICsyMDI5LDcgQEAKIAlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPmVuZGlvX21ldGFfd3JpdGVfd29ya2Vycyk7CiAJYnRyZnNfc3RvcF93b3JrZXJzKCZmc19pbmZvLT5lbmRpb193cml0ZV93b3JrZXJzKTsKIAlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPnN1Ym1pdF93b3JrZXJzKTsKKwlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPmVub3NwY193b3JrZXJzKTsKIGZhaWxfaXB1dDoKIAlpbnZhbGlkYXRlX2lub2RlX3BhZ2VzMihmc19pbmZvLT5idHJlZV9pbm9kZS0+aV9tYXBwaW5nKTsKIAlpcHV0KGZzX2luZm8tPmJ0cmVlX2lub2RlKTsKQEAgLTI0MzcsNiArMjQ0Nyw3IEBACiAKIAlpcHV0KGZzX2luZm8tPmJ0cmVlX2lub2RlKTsKIAorCWJ0cmZzX3N0b3Bfd29ya2VycygmZnNfaW5mby0+Z2VuZXJpY193b3JrZXIpOwogCWJ0cmZzX3N0b3Bfd29ya2VycygmZnNfaW5mby0+Zml4dXBfd29ya2Vycyk7CiAJYnRyZnNfc3RvcF93b3JrZXJzKCZmc19pbmZvLT5kZWxhbGxvY193b3JrZXJzKTsKIAlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPndvcmtlcnMpOwpAQCAtMjQ0NSw2ICsyNDU2LDcgQEAKIAlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPmVuZGlvX21ldGFfd3JpdGVfd29ya2Vycyk7CiAJYnRyZnNfc3RvcF93b3JrZXJzKCZmc19pbmZvLT5lbmRpb193cml0ZV93b3JrZXJzKTsKIAlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPnN1Ym1pdF93b3JrZXJzKTsKKwlidHJmc19zdG9wX3dvcmtlcnMoJmZzX2luZm8tPmVub3NwY193b3JrZXJzKTsKIAogCWJ0cmZzX2Nsb3NlX2RldmljZXMoZnNfaW5mby0+ZnNfZGV2aWNlcyk7CiAJYnRyZnNfbWFwcGluZ190cmVlX2ZyZWUoJmZzX2luZm8tPm1hcHBpbmdfdHJlZSk7CmRpZmYgLS1naXQgYS9mcy9idHJmcy9leHRlbnQtdHJlZS5jIGIvZnMvYnRyZnMvZXh0ZW50LXRyZWUuYwppbmRleCAzNTlhNzU0Li5lMjM4YTBjIDEwMDY0NAotLS0gYS9mcy9idHJmcy9leHRlbnQtdHJlZS5jCisrKyBiL2ZzL2J0cmZzL2V4dGVudC10cmVlLmMKQEAgLTE1NjgsMjMgKzE1NjgsMjMgQEAKIAlyZXR1cm4gcmV0OwogfQogCi0jaWZkZWYgQklPX1JXX0RJU0NBUkQKIHN0YXRpYyB2b2lkIGJ0cmZzX2lzc3VlX2Rpc2NhcmQoc3RydWN0IGJsb2NrX2RldmljZSAqYmRldiwKIAkJCQl1NjQgc3RhcnQsIHU2NCBsZW4pCiB7CiAJYmxrZGV2X2lzc3VlX2Rpc2NhcmQoYmRldiwgc3RhcnQgPj4gOSwgbGVuID4+IDksIEdGUF9LRVJORUwsCiAJCQkgICAgIERJU0NBUkRfRkxfQkFSUklFUik7CiB9Ci0jZW5kaWYKIAogc3RhdGljIGludCBidHJmc19kaXNjYXJkX2V4dGVudChzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwgdTY0IGJ5dGVuciwKIAkJCQl1NjQgbnVtX2J5dGVzKQogewotI2lmZGVmIEJJT19SV19ESVNDQVJECiAJaW50IHJldDsKIAl1NjQgbWFwX2xlbmd0aCA9IG51bV9ieXRlczsKIAlzdHJ1Y3QgYnRyZnNfbXVsdGlfYmlvICptdWx0aSA9IE5VTEw7CiAKKwlpZiAoIWJ0cmZzX3Rlc3Rfb3B0KHJvb3QsIERJU0NBUkQpKQorCQlyZXR1cm4gMDsKKwogCS8qIFRlbGwgdGhlIGJsb2NrIGRldmljZShzKSB0aGF0IHRoZSBzZWN0b3JzIGNhbiBiZSBkaXNjYXJkZWQgKi8KIAlyZXQgPSBidHJmc19tYXBfYmxvY2soJnJvb3QtPmZzX2luZm8tPm1hcHBpbmdfdHJlZSwgUkVBRCwKIAkJCSAgICAgIGJ5dGVuciwgJm1hcF9sZW5ndGgsICZtdWx0aSwgMCk7CkBAIC0xNjA0LDkgKzE2MDQsNiBAQAogCX0KIAogCXJldHVybiByZXQ7Ci0jZWxzZQotCXJldHVybiAwOwotI2VuZGlmCiB9CiAKIGludCBidHJmc19pbmNfZXh0ZW50X3JlZihzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKQEAgLTI4MjQsMTQgKzI4MjEsMTcgQEAKIAkJCQkJICAgbnVtX2l0ZW1zKTsKIAogCXNwaW5fbG9jaygmbWV0YV9zaW5mby0+bG9jayk7Ci0JaWYgKEJUUkZTX0koaW5vZGUpLT5kZWxhbGxvY19yZXNlcnZlZF9leHRlbnRzIDw9Ci0JICAgIEJUUkZTX0koaW5vZGUpLT5kZWxhbGxvY19leHRlbnRzKSB7CisJc3Bpbl9sb2NrKCZCVFJGU19JKGlub2RlKS0+YWNjb3VudGluZ19sb2NrKTsKKwlpZiAoQlRSRlNfSShpbm9kZSktPnJlc2VydmVkX2V4dGVudHMgPD0KKwkgICAgQlRSRlNfSShpbm9kZSktPm91dHN0YW5kaW5nX2V4dGVudHMpIHsKKwkJc3Bpbl91bmxvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOwogCQlzcGluX3VubG9jaygmbWV0YV9zaW5mby0+bG9jayk7CiAJCXJldHVybiAwOwogCX0KKwlzcGluX3VubG9jaygmQlRSRlNfSShpbm9kZSktPmFjY291bnRpbmdfbG9jayk7CiAKLQlCVFJGU19JKGlub2RlKS0+ZGVsYWxsb2NfcmVzZXJ2ZWRfZXh0ZW50cy0tOwotCUJVR19PTihCVFJGU19JKGlub2RlKS0+ZGVsYWxsb2NfcmVzZXJ2ZWRfZXh0ZW50cyA8IDApOworCUJUUkZTX0koaW5vZGUpLT5yZXNlcnZlZF9leHRlbnRzLS07CisJQlVHX09OKEJUUkZTX0koaW5vZGUpLT5yZXNlcnZlZF9leHRlbnRzIDwgMCk7CiAKIAlpZiAobWV0YV9zaW5mby0+Ynl0ZXNfZGVsYWxsb2MgPCBudW1fYnl0ZXMpIHsKIAkJYnVnID0gdHJ1ZTsKQEAgLTI4NjQsNiArMjg2NCwxMDcgQEAKIAkJbWV0YV9zaW5mby0+Zm9yY2VfZGVsYWxsb2MgPSAwOwogfQogCitzdHJ1Y3QgYXN5bmNfZmx1c2ggeworCXN0cnVjdCBidHJmc19yb290ICpyb290OworCXN0cnVjdCBidHJmc19zcGFjZV9pbmZvICppbmZvOworCXN0cnVjdCBidHJmc193b3JrIHdvcms7Cit9OworCitzdGF0aWMgbm9pbmxpbmUgdm9pZCBmbHVzaF9kZWxhbGxvY19hc3luYyhzdHJ1Y3QgYnRyZnNfd29yayAqd29yaykKK3sKKwlzdHJ1Y3QgYXN5bmNfZmx1c2ggKmFzeW5jOworCXN0cnVjdCBidHJmc19yb290ICpyb290OworCXN0cnVjdCBidHJmc19zcGFjZV9pbmZvICppbmZvOworCisJYXN5bmMgPSBjb250YWluZXJfb2Yod29yaywgc3RydWN0IGFzeW5jX2ZsdXNoLCB3b3JrKTsKKwlyb290ID0gYXN5bmMtPnJvb3Q7CisJaW5mbyA9IGFzeW5jLT5pbmZvOworCisJYnRyZnNfc3RhcnRfZGVsYWxsb2NfaW5vZGVzKHJvb3QpOworCXdha2VfdXAoJmluZm8tPmZsdXNoX3dhaXQpOworCWJ0cmZzX3dhaXRfb3JkZXJlZF9leHRlbnRzKHJvb3QsIDApOworCisJc3Bpbl9sb2NrKCZpbmZvLT5sb2NrKTsKKwlpbmZvLT5mbHVzaGluZyA9IDA7CisJc3Bpbl91bmxvY2soJmluZm8tPmxvY2spOworCXdha2VfdXAoJmluZm8tPmZsdXNoX3dhaXQpOworCisJa2ZyZWUoYXN5bmMpOworfQorCitzdGF0aWMgdm9pZCB3YWl0X29uX2ZsdXNoKHN0cnVjdCBidHJmc19zcGFjZV9pbmZvICppbmZvKQoreworCURFRklORV9XQUlUKHdhaXQpOworCXU2NCB1c2VkOworCisJd2hpbGUgKDEpIHsKKwkJcHJlcGFyZV90b193YWl0KCZpbmZvLT5mbHVzaF93YWl0LCAmd2FpdCwKKwkJCQlUQVNLX1VOSU5URVJSVVBUSUJMRSk7CisJCXNwaW5fbG9jaygmaW5mby0+bG9jayk7CisJCWlmICghaW5mby0+Zmx1c2hpbmcpIHsKKwkJCXNwaW5fdW5sb2NrKCZpbmZvLT5sb2NrKTsKKwkJCWJyZWFrOworCQl9CisKKwkJdXNlZCA9IGluZm8tPmJ5dGVzX3VzZWQgKyBpbmZvLT5ieXRlc19yZXNlcnZlZCArCisJCQlpbmZvLT5ieXRlc19waW5uZWQgKyBpbmZvLT5ieXRlc19yZWFkb25seSArCisJCQlpbmZvLT5ieXRlc19zdXBlciArIGluZm8tPmJ5dGVzX3Jvb3QgKworCQkJaW5mby0+Ynl0ZXNfbWF5X3VzZSArIGluZm8tPmJ5dGVzX2RlbGFsbG9jOworCQlpZiAodXNlZCA8IGluZm8tPnRvdGFsX2J5dGVzKSB7CisJCQlzcGluX3VubG9jaygmaW5mby0+bG9jayk7CisJCQlicmVhazsKKwkJfQorCQlzcGluX3VubG9jaygmaW5mby0+bG9jayk7CisJCXNjaGVkdWxlKCk7CisJfQorCWZpbmlzaF93YWl0KCZpbmZvLT5mbHVzaF93YWl0LCAmd2FpdCk7Cit9CisKK3N0YXRpYyB2b2lkIGZsdXNoX2RlbGFsbG9jKHN0cnVjdCBidHJmc19yb290ICpyb290LAorCQkJCSBzdHJ1Y3QgYnRyZnNfc3BhY2VfaW5mbyAqaW5mbykKK3sKKwlzdHJ1Y3QgYXN5bmNfZmx1c2ggKmFzeW5jOworCWJvb2wgd2FpdCA9IGZhbHNlOworCisJc3Bpbl9sb2NrKCZpbmZvLT5sb2NrKTsKKworCWlmICghaW5mby0+Zmx1c2hpbmcpIHsKKwkJaW5mby0+Zmx1c2hpbmcgPSAxOworCQlpbml0X3dhaXRxdWV1ZV9oZWFkKCZpbmZvLT5mbHVzaF93YWl0KTsKKwl9IGVsc2UgeworCQl3YWl0ID0gdHJ1ZTsKKwl9CisKKwlzcGluX3VubG9jaygmaW5mby0+bG9jayk7CisKKwlpZiAod2FpdCkgeworCQl3YWl0X29uX2ZsdXNoKGluZm8pOworCQlyZXR1cm47CisJfQorCisJYXN5bmMgPSBremFsbG9jKHNpemVvZigqYXN5bmMpLCBHRlBfTk9GUyk7CisJaWYgKCFhc3luYykKKwkJZ290byBmbHVzaDsKKworCWFzeW5jLT5yb290ID0gcm9vdDsKKwlhc3luYy0+aW5mbyA9IGluZm87CisJYXN5bmMtPndvcmsuZnVuYyA9IGZsdXNoX2RlbGFsbG9jX2FzeW5jOworCisJYnRyZnNfcXVldWVfd29ya2VyKCZyb290LT5mc19pbmZvLT5lbm9zcGNfd29ya2VycywKKwkJCSAgICZhc3luYy0+d29yayk7CisJd2FpdF9vbl9mbHVzaChpbmZvKTsKKwlyZXR1cm47CisKK2ZsdXNoOgorCWJ0cmZzX3N0YXJ0X2RlbGFsbG9jX2lub2Rlcyhyb290KTsKKwlidHJmc193YWl0X29yZGVyZWRfZXh0ZW50cyhyb290LCAwKTsKKworCXNwaW5fbG9jaygmaW5mby0+bG9jayk7CisJaW5mby0+Zmx1c2hpbmcgPSAwOworCXNwaW5fdW5sb2NrKCZpbmZvLT5sb2NrKTsKKwl3YWtlX3VwKCZpbmZvLT5mbHVzaF93YWl0KTsKK30KKwogc3RhdGljIGludCBtYXliZV9hbGxvY2F0ZV9jaHVuayhzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwKIAkJCQkgc3RydWN0IGJ0cmZzX3NwYWNlX2luZm8gKmluZm8pCiB7CkBAIC0yODk0LDcgKzI5OTUsNyBAQAogCWlmICghaW5mby0+YWxsb2NhdGluZ19jaHVuaykgewogCQlpbmZvLT5mb3JjZV9hbGxvYyA9IDE7CiAJCWluZm8tPmFsbG9jYXRpbmdfY2h1bmsgPSAxOwotCQlpbml0X3dhaXRxdWV1ZV9oZWFkKCZpbmZvLT53YWl0KTsKKwkJaW5pdF93YWl0cXVldWVfaGVhZCgmaW5mby0+YWxsb2NhdGVfd2FpdCk7CiAJfSBlbHNlIHsKIAkJd2FpdCA9IHRydWU7CiAJfQpAQCAtMjkwMiw3ICszMDAzLDcgQEAKIAlzcGluX3VubG9jaygmaW5mby0+bG9jayk7CiAKIAlpZiAod2FpdCkgewotCQl3YWl0X2V2ZW50KGluZm8tPndhaXQsCisJCXdhaXRfZXZlbnQoaW5mby0+YWxsb2NhdGVfd2FpdCwKIAkJCSAgICFpbmZvLT5hbGxvY2F0aW5nX2NodW5rKTsKIAkJcmV0dXJuIDE7CiAJfQpAQCAtMjkyMyw3ICszMDI0LDcgQEAKIAlzcGluX2xvY2soJmluZm8tPmxvY2spOwogCWluZm8tPmFsbG9jYXRpbmdfY2h1bmsgPSAwOwogCXNwaW5fdW5sb2NrKCZpbmZvLT5sb2NrKTsKLQl3YWtlX3VwKCZpbmZvLT53YWl0KTsKKwl3YWtlX3VwKCZpbmZvLT5hbGxvY2F0ZV93YWl0KTsKIAogCWlmIChyZXQpCiAJCXJldHVybiAwOwpAQCAtMjk4MSwyMSArMzA4MiwyMCBAQAogCQkJZmlsZW1hcF9mbHVzaChpbm9kZS0+aV9tYXBwaW5nKTsKIAkJCWdvdG8gYWdhaW47CiAJCX0gZWxzZSBpZiAoZmx1c2hlZCA9PSAzKSB7Ci0JCQlidHJmc19zdGFydF9kZWxhbGxvY19pbm9kZXMocm9vdCk7Ci0JCQlidHJmc193YWl0X29yZGVyZWRfZXh0ZW50cyhyb290LCAwKTsKKwkJCWZsdXNoX2RlbGFsbG9jKHJvb3QsIG1ldGFfc2luZm8pOwogCQkJZ290byBhZ2FpbjsKIAkJfQogCQlzcGluX2xvY2soJm1ldGFfc2luZm8tPmxvY2spOwogCQltZXRhX3NpbmZvLT5ieXRlc19kZWxhbGxvYyAtPSBudW1fYnl0ZXM7CiAJCXNwaW5fdW5sb2NrKCZtZXRhX3NpbmZvLT5sb2NrKTsKIAkJcHJpbnRrKEtFUk5fRVJSICJlbm9zcGMsIGhhcyAlZCwgcmVzZXJ2ZWQgJWRcbiIsCi0JCSAgICAgICBCVFJGU19JKGlub2RlKS0+ZGVsYWxsb2NfZXh0ZW50cywKLQkJICAgICAgIEJUUkZTX0koaW5vZGUpLT5kZWxhbGxvY19yZXNlcnZlZF9leHRlbnRzKTsKKwkJICAgICAgIEJUUkZTX0koaW5vZGUpLT5vdXRzdGFuZGluZ19leHRlbnRzLAorCQkgICAgICAgQlRSRlNfSShpbm9kZSktPnJlc2VydmVkX2V4dGVudHMpOwogCQlkdW1wX3NwYWNlX2luZm8obWV0YV9zaW5mbywgMCwgMCk7CiAJCXJldHVybiAtRU5PU1BDOwogCX0KIAotCUJUUkZTX0koaW5vZGUpLT5kZWxhbGxvY19yZXNlcnZlZF9leHRlbnRzKys7CisJQlRSRlNfSShpbm9kZSktPnJlc2VydmVkX2V4dGVudHMrKzsKIAljaGVja19mb3JjZV9kZWxhbGxvYyhtZXRhX3NpbmZvKTsKIAlzcGluX3VubG9jaygmbWV0YV9zaW5mby0+bG9jayk7CiAKQEAgLTMwOTQsOCArMzE5NCw3IEBACiAJCX0KIAogCQlpZiAocmV0cmllcyA9PSAyKSB7Ci0JCQlidHJmc19zdGFydF9kZWxhbGxvY19pbm9kZXMocm9vdCk7Ci0JCQlidHJmc193YWl0X29yZGVyZWRfZXh0ZW50cyhyb290LCAwKTsKKwkJCWZsdXNoX2RlbGFsbG9jKHJvb3QsIG1ldGFfc2luZm8pOwogCQkJZ290byBhZ2FpbjsKIAkJfQogCQlzcGluX2xvY2soJm1ldGFfc2luZm8tPmxvY2spOwpAQCAtMzU4OCw2ICszNjg3LDE0IEBACiAJaWYgKGlzX2RhdGEpCiAJCWdvdG8gcGluaXQ7CiAKKwkvKgorCSAqIGRpc2NhcmQgaXMgc2xvb29vdywgYW5kIHNvIHRyaWdnZXJpbmcgZGlzY2FyZHMgb24KKwkgKiBpbmRpdmlkdWFsIGJ0cmVlIGJsb2NrcyBpc24ndCBhIGdvb2QgcGxhbi4gIEp1c3QKKwkgKiBwaW4gZXZlcnl0aGluZyBpbiBkaXNjYXJkIG1vZGUuCisJICovCisJaWYgKGJ0cmZzX3Rlc3Rfb3B0KHJvb3QsIERJU0NBUkQpKQorCQlnb3RvIHBpbml0OworCiAJYnVmID0gYnRyZnNfZmluZF90cmVlX2Jsb2NrKHJvb3QsIGJ5dGVuciwgbnVtX2J5dGVzKTsKIAlpZiAoIWJ1ZikKIAkJZ290byBwaW5pdDsKQEAgLTQwMjksNiArNDEzNiw3IEBACiAJaW50IGxvb3AgPSAwOwogCWJvb2wgZm91bmRfdW5jYWNoZWRfYmcgPSBmYWxzZTsKIAlib29sIGZhaWxlZF9jbHVzdGVyX3JlZmlsbCA9IGZhbHNlOworCWJvb2wgZmFpbGVkX2FsbG9jID0gZmFsc2U7CiAKIAlXQVJOX09OKG51bV9ieXRlcyA8IHJvb3QtPnNlY3RvcnNpemUpOwogCWJ0cmZzX3NldF9rZXlfdHlwZShpbnMsIEJUUkZTX0VYVEVOVF9JVEVNX0tFWSk7CkBAIC00MjMzLDE0ICs0MzQxLDIzIEBACiAKIAkJb2Zmc2V0ID0gYnRyZnNfZmluZF9zcGFjZV9mb3JfYWxsb2MoYmxvY2tfZ3JvdXAsIHNlYXJjaF9zdGFydCwKIAkJCQkJCSAgICBudW1fYnl0ZXMsIGVtcHR5X3NpemUpOwotCQlpZiAoIW9mZnNldCAmJiAoY2FjaGVkIHx8ICghY2FjaGVkICYmCi0JCQkJCSAgIGxvb3AgPT0gTE9PUF9DQUNISU5HX05PV0FJVCkpKSB7Ci0JCQlnb3RvIGxvb3A7Ci0JCX0gZWxzZSBpZiAoIW9mZnNldCAmJiAoIWNhY2hlZCAmJgotCQkJCSAgICAgICBsb29wID4gTE9PUF9DQUNISU5HX05PV0FJVCkpIHsKKwkJLyoKKwkJICogSWYgd2UgZGlkbid0IGZpbmQgYSBjaHVuaywgYW5kIHdlIGhhdmVuJ3QgZmFpbGVkIG9uIHRoaXMKKwkJICogYmxvY2sgZ3JvdXAgYmVmb3JlLCBhbmQgdGhpcyBibG9jayBncm91cCBpcyBpbiB0aGUgbWlkZGxlIG9mCisJCSAqIGNhY2hpbmcgYW5kIHdlIGFyZSBvayB3aXRoIHdhaXRpbmcsIHRoZW4gZ28gYWhlYWQgYW5kIHdhaXQKKwkJICogZm9yIHByb2dyZXNzIHRvIGJlIG1hZGUsIGFuZCBzZXQgZmFpbGVkX2FsbG9jIHRvIHRydWUuCisJCSAqCisJCSAqIElmIGZhaWxlZF9hbGxvYyBpcyB0cnVlIHRoZW4gd2UndmUgYWxyZWFkeSB3YWl0ZWQgb24gdGhpcworCQkgKiBibG9jayBncm91cCBvbmNlIGFuZCBzaG91bGQgbW92ZSBvbiB0byB0aGUgbmV4dCBibG9jayBncm91cC4KKwkJICovCisJCWlmICghb2Zmc2V0ICYmICFmYWlsZWRfYWxsb2MgJiYgIWNhY2hlZCAmJgorCQkgICAgbG9vcCA+IExPT1BfQ0FDSElOR19OT1dBSVQpIHsKIAkJCXdhaXRfYmxvY2tfZ3JvdXBfY2FjaGVfcHJvZ3Jlc3MoYmxvY2tfZ3JvdXAsCi0JCQkJCW51bV9ieXRlcyArIGVtcHR5X3NpemUpOworCQkJCQkJbnVtX2J5dGVzICsgZW1wdHlfc2l6ZSk7CisJCQlmYWlsZWRfYWxsb2MgPSB0cnVlOwogCQkJZ290byBoYXZlX2Jsb2NrX2dyb3VwOworCQl9IGVsc2UgaWYgKCFvZmZzZXQpIHsKKwkJCWdvdG8gbG9vcDsKIAkJfQogY2hlY2tzOgogCQlzZWFyY2hfc3RhcnQgPSBzdHJpcGVfYWxpZ24ocm9vdCwgb2Zmc2V0KTsKQEAgLTQyODgsNiArNDQwNSw3IEBACiAJCWJyZWFrOwogbG9vcDoKIAkJZmFpbGVkX2NsdXN0ZXJfcmVmaWxsID0gZmFsc2U7CisJCWZhaWxlZF9hbGxvYyA9IGZhbHNlOwogCQlidHJmc19wdXRfYmxvY2tfZ3JvdXAoYmxvY2tfZ3JvdXApOwogCX0KIAl1cF9yZWFkKCZzcGFjZV9pbmZvLT5ncm91cHNfc2VtKTsKQEAgLTQ3OTksNiArNDkxNyw3IEBACiAJdTY0IGJ5dGVucjsKIAl1NjQgZ2VuZXJhdGlvbjsKIAl1NjQgcmVmczsKKwl1NjQgZmxhZ3M7CiAJdTY0IGxhc3QgPSAwOwogCXUzMiBucml0ZW1zOwogCXUzMiBibG9ja3NpemU7CkBAIC00ODM2LDE1ICs0OTU1LDE5IEBACiAJCSAgICBnZW5lcmF0aW9uIDw9IHJvb3QtPnJvb3Rfa2V5Lm9mZnNldCkKIAkJCWNvbnRpbnVlOwogCisJCS8qIFdlIGRvbid0IGxvY2sgdGhlIHRyZWUgYmxvY2ssIGl0J3MgT0sgdG8gYmUgcmFjeSBoZXJlICovCisJCXJldCA9IGJ0cmZzX2xvb2t1cF9leHRlbnRfaW5mbyh0cmFucywgcm9vdCwgYnl0ZW5yLCBibG9ja3NpemUsCisJCQkJCSAgICAgICAmcmVmcywgJmZsYWdzKTsKKwkJQlVHX09OKHJldCk7CisJCUJVR19PTihyZWZzID09IDApOworCiAJCWlmICh3Yy0+c3RhZ2UgPT0gRFJPUF9SRUZFUkVOQ0UpIHsKLQkJCXJldCA9IGJ0cmZzX2xvb2t1cF9leHRlbnRfaW5mbyh0cmFucywgcm9vdCwKLQkJCQkJCWJ5dGVuciwgYmxvY2tzaXplLAotCQkJCQkJJnJlZnMsIE5VTEwpOwotCQkJQlVHX09OKHJldCk7Ci0JCQlCVUdfT04ocmVmcyA9PSAwKTsKIAkJCWlmIChyZWZzID09IDEpCiAJCQkJZ290byByZWFkYTsKIAorCQkJaWYgKHdjLT5sZXZlbCA9PSAxICYmCisJCQkgICAgKGZsYWdzICYgQlRSRlNfQkxPQ0tfRkxBR19GVUxMX0JBQ0tSRUYpKQorCQkJCWNvbnRpbnVlOwogCQkJaWYgKCF3Yy0+dXBkYXRlX3JlZiB8fAogCQkJICAgIGdlbmVyYXRpb24gPD0gcm9vdC0+cm9vdF9rZXkub2Zmc2V0KQogCQkJCWNvbnRpbnVlOwpAQCAtNDg1Myw2ICs0OTc2LDEwIEBACiAJCQkJCQkgICZ3Yy0+dXBkYXRlX3Byb2dyZXNzKTsKIAkJCWlmIChyZXQgPCAwKQogCQkJCWNvbnRpbnVlOworCQl9IGVsc2UgeworCQkJaWYgKHdjLT5sZXZlbCA9PSAxICYmCisJCQkgICAgKGZsYWdzICYgQlRSRlNfQkxPQ0tfRkxBR19GVUxMX0JBQ0tSRUYpKQorCQkJCWNvbnRpbnVlOwogCQl9CiByZWFkYToKIAkJcmV0ID0gcmVhZGFoZWFkX3RyZWVfYmxvY2socm9vdCwgYnl0ZW5yLCBibG9ja3NpemUsCkBAIC00ODc2LDcgKzUwMDMsNyBAQAogc3RhdGljIG5vaW5saW5lIGludCB3YWxrX2Rvd25fcHJvYyhzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKIAkJCQkgICBzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwKIAkJCQkgICBzdHJ1Y3QgYnRyZnNfcGF0aCAqcGF0aCwKLQkJCQkgICBzdHJ1Y3Qgd2Fsa19jb250cm9sICp3YykKKwkJCQkgICBzdHJ1Y3Qgd2Fsa19jb250cm9sICp3YywgaW50IGxvb2t1cF9pbmZvKQogewogCWludCBsZXZlbCA9IHdjLT5sZXZlbDsKIAlzdHJ1Y3QgZXh0ZW50X2J1ZmZlciAqZWIgPSBwYXRoLT5ub2Rlc1tsZXZlbF07CkBAIC00ODkxLDggKzUwMTgsOSBAQAogCSAqIHdoZW4gcmVmZXJlbmNlIGNvdW50IG9mIHRyZWUgYmxvY2sgaXMgMSwgaXQgd29uJ3QgaW5jcmVhc2UKIAkgKiBhZ2Fpbi4gb25jZSBmdWxsIGJhY2tyZWYgZmxhZyBpcyBzZXQsIHdlIG5ldmVyIGNsZWFyIGl0LgogCSAqLwotCWlmICgod2MtPnN0YWdlID09IERST1BfUkVGRVJFTkNFICYmIHdjLT5yZWZzW2xldmVsXSAhPSAxKSB8fAotCSAgICAod2MtPnN0YWdlID09IFVQREFURV9CQUNLUkVGICYmICEod2MtPmZsYWdzW2xldmVsXSAmIGZsYWcpKSkgeworCWlmIChsb29rdXBfaW5mbyAmJgorCSAgICAoKHdjLT5zdGFnZSA9PSBEUk9QX1JFRkVSRU5DRSAmJiB3Yy0+cmVmc1tsZXZlbF0gIT0gMSkgfHwKKwkgICAgICh3Yy0+c3RhZ2UgPT0gVVBEQVRFX0JBQ0tSRUYgJiYgISh3Yy0+ZmxhZ3NbbGV2ZWxdICYgZmxhZykpKSkgewogCQlCVUdfT04oIXBhdGgtPmxvY2tzW2xldmVsXSk7CiAJCXJldCA9IGJ0cmZzX2xvb2t1cF9leHRlbnRfaW5mbyh0cmFucywgcm9vdCwKIAkJCQkJICAgICAgIGViLT5zdGFydCwgZWItPmxlbiwKQEAgLTQ5NTMsNyArNTA4MSw3IEBACiBzdGF0aWMgbm9pbmxpbmUgaW50IGRvX3dhbGtfZG93bihzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKIAkJCQkgc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsCiAJCQkJIHN0cnVjdCBidHJmc19wYXRoICpwYXRoLAotCQkJCSBzdHJ1Y3Qgd2Fsa19jb250cm9sICp3YykKKwkJCQkgc3RydWN0IHdhbGtfY29udHJvbCAqd2MsIGludCAqbG9va3VwX2luZm8pCiB7CiAJdTY0IGJ5dGVucjsKIAl1NjQgZ2VuZXJhdGlvbjsKQEAgLTQ5NzMsOCArNTEwMSwxMCBAQAogCSAqIGZvciB0aGUgc3VidHJlZQogCSAqLwogCWlmICh3Yy0+c3RhZ2UgPT0gVVBEQVRFX0JBQ0tSRUYgJiYKLQkgICAgZ2VuZXJhdGlvbiA8PSByb290LT5yb290X2tleS5vZmZzZXQpCisJICAgIGdlbmVyYXRpb24gPD0gcm9vdC0+cm9vdF9rZXkub2Zmc2V0KSB7CisJCSpsb29rdXBfaW5mbyA9IDE7CiAJCXJldHVybiAxOworCX0KIAogCWJ5dGVuciA9IGJ0cmZzX25vZGVfYmxvY2twdHIocGF0aC0+bm9kZXNbbGV2ZWxdLCBwYXRoLT5zbG90c1tsZXZlbF0pOwogCWJsb2Nrc2l6ZSA9IGJ0cmZzX2xldmVsX3NpemUocm9vdCwgbGV2ZWwgLSAxKTsKQEAgLTQ5ODcsMTQgKzUxMTcsMTkgQEAKIAlidHJmc190cmVlX2xvY2sobmV4dCk7CiAJYnRyZnNfc2V0X2xvY2tfYmxvY2tpbmcobmV4dCk7CiAKLQlpZiAod2MtPnN0YWdlID09IERST1BfUkVGRVJFTkNFKSB7Ci0JCXJldCA9IGJ0cmZzX2xvb2t1cF9leHRlbnRfaW5mbyh0cmFucywgcm9vdCwgYnl0ZW5yLCBibG9ja3NpemUsCi0JCQkJCSAgICAgICAmd2MtPnJlZnNbbGV2ZWwgLSAxXSwKLQkJCQkJICAgICAgICZ3Yy0+ZmxhZ3NbbGV2ZWwgLSAxXSk7Ci0JCUJVR19PTihyZXQpOwotCQlCVUdfT04od2MtPnJlZnNbbGV2ZWwgLSAxXSA9PSAwKTsKKwlyZXQgPSBidHJmc19sb29rdXBfZXh0ZW50X2luZm8odHJhbnMsIHJvb3QsIGJ5dGVuciwgYmxvY2tzaXplLAorCQkJCSAgICAgICAmd2MtPnJlZnNbbGV2ZWwgLSAxXSwKKwkJCQkgICAgICAgJndjLT5mbGFnc1tsZXZlbCAtIDFdKTsKKwlCVUdfT04ocmV0KTsKKwlCVUdfT04od2MtPnJlZnNbbGV2ZWwgLSAxXSA9PSAwKTsKKwkqbG9va3VwX2luZm8gPSAwOwogCisJaWYgKHdjLT5zdGFnZSA9PSBEUk9QX1JFRkVSRU5DRSkgewogCQlpZiAod2MtPnJlZnNbbGV2ZWwgLSAxXSA+IDEpIHsKKwkJCWlmIChsZXZlbCA9PSAxICYmCisJCQkgICAgKHdjLT5mbGFnc1swXSAmIEJUUkZTX0JMT0NLX0ZMQUdfRlVMTF9CQUNLUkVGKSkKKwkJCQlnb3RvIHNraXA7CisKIAkJCWlmICghd2MtPnVwZGF0ZV9yZWYgfHwKIAkJCSAgICBnZW5lcmF0aW9uIDw9IHJvb3QtPnJvb3Rfa2V5Lm9mZnNldCkKIAkJCQlnb3RvIHNraXA7CkBAIC01MDA4LDEyICs1MTQzLDE3IEBACiAJCQl3Yy0+c3RhZ2UgPSBVUERBVEVfQkFDS1JFRjsKIAkJCXdjLT5zaGFyZWRfbGV2ZWwgPSBsZXZlbCAtIDE7CiAJCX0KKwl9IGVsc2UgeworCQlpZiAobGV2ZWwgPT0gMSAmJgorCQkgICAgKHdjLT5mbGFnc1swXSAmIEJUUkZTX0JMT0NLX0ZMQUdfRlVMTF9CQUNLUkVGKSkKKwkJCWdvdG8gc2tpcDsKIAl9CiAKIAlpZiAoIWJ0cmZzX2J1ZmZlcl91cHRvZGF0ZShuZXh0LCBnZW5lcmF0aW9uKSkgewogCQlidHJmc190cmVlX3VubG9jayhuZXh0KTsKIAkJZnJlZV9leHRlbnRfYnVmZmVyKG5leHQpOwogCQluZXh0ID0gTlVMTDsKKwkJKmxvb2t1cF9pbmZvID0gMTsKIAl9CiAKIAlpZiAoIW5leHQpIHsKQEAgLTUwMzYsMjEgKzUxNzYsMjIgQEAKIHNraXA6CiAJd2MtPnJlZnNbbGV2ZWwgLSAxXSA9IDA7CiAJd2MtPmZsYWdzW2xldmVsIC0gMV0gPSAwOworCWlmICh3Yy0+c3RhZ2UgPT0gRFJPUF9SRUZFUkVOQ0UpIHsKKwkJaWYgKHdjLT5mbGFnc1tsZXZlbF0gJiBCVFJGU19CTE9DS19GTEFHX0ZVTExfQkFDS1JFRikgeworCQkJcGFyZW50ID0gcGF0aC0+bm9kZXNbbGV2ZWxdLT5zdGFydDsKKwkJfSBlbHNlIHsKKwkJCUJVR19PTihyb290LT5yb290X2tleS5vYmplY3RpZCAhPQorCQkJICAgICAgIGJ0cmZzX2hlYWRlcl9vd25lcihwYXRoLT5ub2Rlc1tsZXZlbF0pKTsKKwkJCXBhcmVudCA9IDA7CisJCX0KIAotCWlmICh3Yy0+ZmxhZ3NbbGV2ZWxdICYgQlRSRlNfQkxPQ0tfRkxBR19GVUxMX0JBQ0tSRUYpIHsKLQkJcGFyZW50ID0gcGF0aC0+bm9kZXNbbGV2ZWxdLT5zdGFydDsKLQl9IGVsc2UgewotCQlCVUdfT04ocm9vdC0+cm9vdF9rZXkub2JqZWN0aWQgIT0KLQkJICAgICAgIGJ0cmZzX2hlYWRlcl9vd25lcihwYXRoLT5ub2Rlc1tsZXZlbF0pKTsKLQkJcGFyZW50ID0gMDsKKwkJcmV0ID0gYnRyZnNfZnJlZV9leHRlbnQodHJhbnMsIHJvb3QsIGJ5dGVuciwgYmxvY2tzaXplLCBwYXJlbnQsCisJCQkJCXJvb3QtPnJvb3Rfa2V5Lm9iamVjdGlkLCBsZXZlbCAtIDEsIDApOworCQlCVUdfT04ocmV0KTsKIAl9Ci0KLQlyZXQgPSBidHJmc19mcmVlX2V4dGVudCh0cmFucywgcm9vdCwgYnl0ZW5yLCBibG9ja3NpemUsIHBhcmVudCwKLQkJCQlyb290LT5yb290X2tleS5vYmplY3RpZCwgbGV2ZWwgLSAxLCAwKTsKLQlCVUdfT04ocmV0KTsKLQogCWJ0cmZzX3RyZWVfdW5sb2NrKG5leHQpOwogCWZyZWVfZXh0ZW50X2J1ZmZlcihuZXh0KTsKKwkqbG9va3VwX2luZm8gPSAxOwogCXJldHVybiAxOwogfQogCkBAIC01MTY0LDYgKzUzMDUsNyBAQAogCQkJCSAgIHN0cnVjdCB3YWxrX2NvbnRyb2wgKndjKQogewogCWludCBsZXZlbCA9IHdjLT5sZXZlbDsKKwlpbnQgbG9va3VwX2luZm8gPSAxOwogCWludCByZXQ7CiAKIAl3aGlsZSAobGV2ZWwgPj0gMCkgewpAQCAtNTE3MSwxNCArNTMxMywxNCBAQAogCQkgICAgYnRyZnNfaGVhZGVyX25yaXRlbXMocGF0aC0+bm9kZXNbbGV2ZWxdKSkKIAkJCWJyZWFrOwogCi0JCXJldCA9IHdhbGtfZG93bl9wcm9jKHRyYW5zLCByb290LCBwYXRoLCB3Yyk7CisJCXJldCA9IHdhbGtfZG93bl9wcm9jKHRyYW5zLCByb290LCBwYXRoLCB3YywgbG9va3VwX2luZm8pOwogCQlpZiAocmV0ID4gMCkKIAkJCWJyZWFrOwogCiAJCWlmIChsZXZlbCA9PSAwKQogCQkJYnJlYWs7CiAKLQkJcmV0ID0gZG9fd2Fsa19kb3duKHRyYW5zLCByb290LCBwYXRoLCB3Yyk7CisJCXJldCA9IGRvX3dhbGtfZG93bih0cmFucywgcm9vdCwgcGF0aCwgd2MsICZsb29rdXBfaW5mbyk7CiAJCWlmIChyZXQgPiAwKSB7CiAJCQlwYXRoLT5zbG90c1tsZXZlbF0rKzsKIAkJCWNvbnRpbnVlOwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvZXh0ZW50X2lvLmMgYi9mcy9idHJmcy9leHRlbnRfaW8uYwppbmRleCBkZTE3OTNiLi45NjU3N2U4IDEwMDY0NAotLS0gYS9mcy9idHJmcy9leHRlbnRfaW8uYworKysgYi9mcy9idHJmcy9leHRlbnRfaW8uYwpAQCAtNDYwLDcgKzQ2MCw4IEBACiAJCQkgICAgc3RydWN0IGV4dGVudF9zdGF0ZSAqc3RhdGUsIGludCBiaXRzLCBpbnQgd2FrZSwKIAkJCSAgICBpbnQgZGVsZXRlKQogewotCWludCByZXQgPSBzdGF0ZS0+c3RhdGUgJiBiaXRzOworCWludCBiaXRzX3RvX2NsZWFyID0gYml0cyAmIH5FWFRFTlRfRE9fQUNDT1VOVElORzsKKwlpbnQgcmV0ID0gc3RhdGUtPnN0YXRlICYgYml0c190b19jbGVhcjsKIAogCWlmICgoYml0cyAmIEVYVEVOVF9ESVJUWSkgJiYgKHN0YXRlLT5zdGF0ZSAmIEVYVEVOVF9ESVJUWSkpIHsKIAkJdTY0IHJhbmdlID0gc3RhdGUtPmVuZCAtIHN0YXRlLT5zdGFydCArIDE7CkBAIC00NjgsNyArNDY5LDcgQEAKIAkJdHJlZS0+ZGlydHlfYnl0ZXMgLT0gcmFuZ2U7CiAJfQogCWNsZWFyX3N0YXRlX2NiKHRyZWUsIHN0YXRlLCBiaXRzKTsKLQlzdGF0ZS0+c3RhdGUgJj0gfmJpdHM7CisJc3RhdGUtPnN0YXRlICY9IH5iaXRzX3RvX2NsZWFyOwogCWlmICh3YWtlKQogCQl3YWtlX3VwKCZzdGF0ZS0+d3EpOwogCWlmIChkZWxldGUgfHwgc3RhdGUtPnN0YXRlID09IDApIHsKQEAgLTk1Niw3ICs5NTcsOCBAQAogCQkgICAgICAgZ2ZwX3QgbWFzaykKIHsKIAlyZXR1cm4gY2xlYXJfZXh0ZW50X2JpdCh0cmVlLCBzdGFydCwgZW5kLAotCQkJCUVYVEVOVF9ESVJUWSB8IEVYVEVOVF9ERUxBTExPQywgMCwgMCwKKwkJCQlFWFRFTlRfRElSVFkgfCBFWFRFTlRfREVMQUxMT0MgfAorCQkJCUVYVEVOVF9ET19BQ0NPVU5USU5HLCAwLCAwLAogCQkJCU5VTEwsIG1hc2spOwogfQogCkBAIC0xNDAxLDEyICsxNDAzLDcgQEAKIGludCBleHRlbnRfY2xlYXJfdW5sb2NrX2RlbGFsbG9jKHN0cnVjdCBpbm9kZSAqaW5vZGUsCiAJCQkJc3RydWN0IGV4dGVudF9pb190cmVlICp0cmVlLAogCQkJCXU2NCBzdGFydCwgdTY0IGVuZCwgc3RydWN0IHBhZ2UgKmxvY2tlZF9wYWdlLAotCQkJCWludCB1bmxvY2tfcGFnZXMsCi0JCQkJaW50IGNsZWFyX3VubG9jaywKLQkJCQlpbnQgY2xlYXJfZGVsYWxsb2MsIGludCBjbGVhcl9kaXJ0eSwKLQkJCQlpbnQgc2V0X3dyaXRlYmFjaywKLQkJCQlpbnQgZW5kX3dyaXRlYmFjaywKLQkJCQlpbnQgc2V0X3ByaXZhdGUyKQorCQkJCXVuc2lnbmVkIGxvbmcgb3ApCiB7CiAJaW50IHJldDsKIAlzdHJ1Y3QgcGFnZSAqcGFnZXNbMTZdOwpAQCAtMTQxNiwxNyArMTQxMywyMSBAQAogCWludCBpOwogCWludCBjbGVhcl9iaXRzID0gMDsKIAotCWlmIChjbGVhcl91bmxvY2spCisJaWYgKG9wICYgRVhURU5UX0NMRUFSX1VOTE9DSykKIAkJY2xlYXJfYml0cyB8PSBFWFRFTlRfTE9DS0VEOwotCWlmIChjbGVhcl9kaXJ0eSkKKwlpZiAob3AgJiBFWFRFTlRfQ0xFQVJfRElSVFkpCiAJCWNsZWFyX2JpdHMgfD0gRVhURU5UX0RJUlRZOwogCi0JaWYgKGNsZWFyX2RlbGFsbG9jKQorCWlmIChvcCAmIEVYVEVOVF9DTEVBUl9ERUxBTExPQykKIAkJY2xlYXJfYml0cyB8PSBFWFRFTlRfREVMQUxMT0M7CiAKKwlpZiAob3AgJiBFWFRFTlRfQ0xFQVJfQUNDT1VOVElORykKKwkJY2xlYXJfYml0cyB8PSBFWFRFTlRfRE9fQUNDT1VOVElORzsKKwogCWNsZWFyX2V4dGVudF9iaXQodHJlZSwgc3RhcnQsIGVuZCwgY2xlYXJfYml0cywgMSwgMCwgTlVMTCwgR0ZQX05PRlMpOwotCWlmICghKHVubG9ja19wYWdlcyB8fCBjbGVhcl9kaXJ0eSB8fCBzZXRfd3JpdGViYWNrIHx8IGVuZF93cml0ZWJhY2sgfHwKLQkgICAgICBzZXRfcHJpdmF0ZTIpKQorCWlmICghKG9wICYgKEVYVEVOVF9DTEVBUl9VTkxPQ0tfUEFHRSB8IEVYVEVOVF9DTEVBUl9ESVJUWSB8CisJCSAgICBFWFRFTlRfU0VUX1dSSVRFQkFDSyB8IEVYVEVOVF9FTkRfV1JJVEVCQUNLIHwKKwkJICAgIEVYVEVOVF9TRVRfUFJJVkFURTIpKSkKIAkJcmV0dXJuIDA7CiAKIAl3aGlsZSAobnJfcGFnZXMgPiAwKSB7CkBAIC0xNDM1LDIwICsxNDM2LDIwIEBACiAJCQkJICAgICBucl9wYWdlcywgQVJSQVlfU0laRShwYWdlcykpLCBwYWdlcyk7CiAJCWZvciAoaSA9IDA7IGkgPCByZXQ7IGkrKykgewogCi0JCQlpZiAoc2V0X3ByaXZhdGUyKQorCQkJaWYgKG9wICYgRVhURU5UX1NFVF9QUklWQVRFMikKIAkJCQlTZXRQYWdlUHJpdmF0ZTIocGFnZXNbaV0pOwogCiAJCQlpZiAocGFnZXNbaV0gPT0gbG9ja2VkX3BhZ2UpIHsKIAkJCQlwYWdlX2NhY2hlX3JlbGVhc2UocGFnZXNbaV0pOwogCQkJCWNvbnRpbnVlOwogCQkJfQotCQkJaWYgKGNsZWFyX2RpcnR5KQorCQkJaWYgKG9wICYgRVhURU5UX0NMRUFSX0RJUlRZKQogCQkJCWNsZWFyX3BhZ2VfZGlydHlfZm9yX2lvKHBhZ2VzW2ldKTsKLQkJCWlmIChzZXRfd3JpdGViYWNrKQorCQkJaWYgKG9wICYgRVhURU5UX1NFVF9XUklURUJBQ0spCiAJCQkJc2V0X3BhZ2Vfd3JpdGViYWNrKHBhZ2VzW2ldKTsKLQkJCWlmIChlbmRfd3JpdGViYWNrKQorCQkJaWYgKG9wICYgRVhURU5UX0VORF9XUklURUJBQ0spCiAJCQkJZW5kX3BhZ2Vfd3JpdGViYWNrKHBhZ2VzW2ldKTsKLQkJCWlmICh1bmxvY2tfcGFnZXMpCisJCQlpZiAob3AgJiBFWFRFTlRfQ0xFQVJfVU5MT0NLX1BBR0UpCiAJCQkJdW5sb2NrX3BhZ2UocGFnZXNbaV0pOwogCQkJcGFnZV9jYWNoZV9yZWxlYXNlKHBhZ2VzW2ldKTsKIAkJfQpAQCAtMjcxNCw3ICsyNzE1LDggQEAKIAlsb2NrX2V4dGVudCh0cmVlLCBzdGFydCwgZW5kLCBHRlBfTk9GUyk7CiAJd2FpdF9vbl9wYWdlX3dyaXRlYmFjayhwYWdlKTsKIAljbGVhcl9leHRlbnRfYml0KHRyZWUsIHN0YXJ0LCBlbmQsCi0JCQkgRVhURU5UX0xPQ0tFRCB8IEVYVEVOVF9ESVJUWSB8IEVYVEVOVF9ERUxBTExPQywKKwkJCSBFWFRFTlRfTE9DS0VEIHwgRVhURU5UX0RJUlRZIHwgRVhURU5UX0RFTEFMTE9DIHwKKwkJCSBFWFRFTlRfRE9fQUNDT1VOVElORywKIAkJCSAxLCAxLCBOVUxMLCBHRlBfTk9GUyk7CiAJcmV0dXJuIDA7CiB9CmRpZmYgLS1naXQgYS9mcy9idHJmcy9leHRlbnRfaW8uaCBiL2ZzL2J0cmZzL2V4dGVudF9pby5oCmluZGV4IDQ3OTRlYzguLjM2ZGUyNTAgMTAwNjQ0Ci0tLSBhL2ZzL2J0cmZzL2V4dGVudF9pby5oCisrKyBiL2ZzL2J0cmZzL2V4dGVudF9pby5oCkBAIC0xNSw2ICsxNSw3IEBACiAjZGVmaW5lIEVYVEVOVF9CVUZGRVJfRklMTEVEICgxIDw8IDgpCiAjZGVmaW5lIEVYVEVOVF9CT1VOREFSWSAoMSA8PCA5KQogI2RlZmluZSBFWFRFTlRfTk9EQVRBU1VNICgxIDw8IDEwKQorI2RlZmluZSBFWFRFTlRfRE9fQUNDT1VOVElORyAoMSA8PCAxMSkKICNkZWZpbmUgRVhURU5UX0lPQklUUyAoRVhURU5UX0xPQ0tFRCB8IEVYVEVOVF9XUklURUJBQ0spCiAKIC8qIGZsYWdzIGZvciBiaW8gc3VibWlzc2lvbiAqLwpAQCAtMjUsNiArMjYsMTYgQEAKICNkZWZpbmUgRVhURU5UX0JVRkZFUl9CTE9DS0lORyAxCiAjZGVmaW5lIEVYVEVOVF9CVUZGRVJfRElSVFkgMgogCisvKiB0aGVzZSBhcmUgZmxhZ3MgZm9yIGV4dGVudF9jbGVhcl91bmxvY2tfZGVsYWxsb2MgKi8KKyNkZWZpbmUgRVhURU5UX0NMRUFSX1VOTE9DS19QQUdFIDB4MQorI2RlZmluZSBFWFRFTlRfQ0xFQVJfVU5MT0NLCSAweDIKKyNkZWZpbmUgRVhURU5UX0NMRUFSX0RFTEFMTE9DCSAweDQKKyNkZWZpbmUgRVhURU5UX0NMRUFSX0RJUlRZCSAweDgKKyNkZWZpbmUgRVhURU5UX1NFVF9XUklURUJBQ0sJIDB4MTAKKyNkZWZpbmUgRVhURU5UX0VORF9XUklURUJBQ0sJIDB4MjAKKyNkZWZpbmUgRVhURU5UX1NFVF9QUklWQVRFMgkgMHg0MAorI2RlZmluZSBFWFRFTlRfQ0xFQVJfQUNDT1VOVElORyAgMHg4MAorCiAvKgogICogcGFnZS0+cHJpdmF0ZSB2YWx1ZXMuICBFdmVyeSBwYWdlIHRoYXQgaXMgY29udHJvbGxlZCBieSB0aGUgZXh0ZW50CiAgKiBtYXAgaGFzIHBhZ2UtPnByaXZhdGUgc2V0IHRvIG9uZS4KQEAgLTI4OCwxMCArMjk5LDUgQEAKIGludCBleHRlbnRfY2xlYXJfdW5sb2NrX2RlbGFsbG9jKHN0cnVjdCBpbm9kZSAqaW5vZGUsCiAJCQkJc3RydWN0IGV4dGVudF9pb190cmVlICp0cmVlLAogCQkJCXU2NCBzdGFydCwgdTY0IGVuZCwgc3RydWN0IHBhZ2UgKmxvY2tlZF9wYWdlLAotCQkJCWludCB1bmxvY2tfcGFnZSwKLQkJCQlpbnQgY2xlYXJfdW5sb2NrLAotCQkJCWludCBjbGVhcl9kZWxhbGxvYywgaW50IGNsZWFyX2RpcnR5LAotCQkJCWludCBzZXRfd3JpdGViYWNrLAotCQkJCWludCBlbmRfd3JpdGViYWNrLAotCQkJCWludCBzZXRfcHJpdmF0ZTIpOworCQkJCXVuc2lnbmVkIGxvbmcgb3ApOwogI2VuZGlmCmRpZmYgLS1naXQgYS9mcy9idHJmcy9maWxlLmMgYi9mcy9idHJmcy9maWxlLmMKaW5kZXggZjE5ZTEyNS4uMDY1NTBhZiAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvZmlsZS5jCisrKyBiL2ZzL2J0cmZzL2ZpbGUuYwpAQCAtODc4LDcgKzg3OCw4IEBACiAJCQlidHJmc19wdXRfb3JkZXJlZF9leHRlbnQob3JkZXJlZCk7CiAKIAkJY2xlYXJfZXh0ZW50X2JpdHMoJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLCBzdGFydF9wb3MsCi0JCQkJICBsYXN0X3BvcyAtIDEsIEVYVEVOVF9ESVJUWSB8IEVYVEVOVF9ERUxBTExPQywKKwkJCQkgIGxhc3RfcG9zIC0gMSwgRVhURU5UX0RJUlRZIHwgRVhURU5UX0RFTEFMTE9DIHwKKwkJCQkgIEVYVEVOVF9ET19BQ0NPVU5USU5HLAogCQkJCSAgR0ZQX05PRlMpOwogCQl1bmxvY2tfZXh0ZW50KCZCVFJGU19JKGlub2RlKS0+aW9fdHJlZSwKIAkJCSAgICAgIHN0YXJ0X3BvcywgbGFzdF9wb3MgLSAxLCBHRlBfTk9GUyk7CkBAIC0xMDg1LDggKzEwODYsMTAgQEAKIAkJCQkJYnRyZnNfZW5kX3RyYW5zYWN0aW9uKHRyYW5zLCByb290KTsKIAkJCQllbHNlCiAJCQkJCWJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcm9vdCk7Ci0JCQl9IGVsc2UgeworCQkJfSBlbHNlIGlmIChyZXQgIT0gQlRSRlNfTk9fTE9HX1NZTkMpIHsKIAkJCQlidHJmc19jb21taXRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOworCQkJfSBlbHNlIHsKKwkJCQlidHJmc19lbmRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOwogCQkJfQogCQl9CiAJCWlmIChmaWxlLT5mX2ZsYWdzICYgT19ESVJFQ1QpIHsKQEAgLTExMzYsNiArMTEzOSwxMyBAQAogCWludCByZXQgPSAwOwogCXN0cnVjdCBidHJmc190cmFuc19oYW5kbGUgKnRyYW5zOwogCisKKwkvKiB3ZSB3YWl0IGZpcnN0LCBzaW5jZSB0aGUgd3JpdGViYWNrIG1heSBjaGFuZ2UgdGhlIGlub2RlICovCisJcm9vdC0+bG9nX2JhdGNoKys7CisJLyogdGhlIFZGUyBjYWxsZWQgZmlsZW1hcF9mZGF0YXdyaXRlIGZvciB1cyAqLworCWJ0cmZzX3dhaXRfb3JkZXJlZF9yYW5nZShpbm9kZSwgMCwgKHU2NCktMSk7CisJcm9vdC0+bG9nX2JhdGNoKys7CisKIAkvKgogCSAqIGNoZWNrIHRoZSB0cmFuc2FjdGlvbiB0aGF0IGxhc3QgbW9kaWZpZWQgdGhpcyBpbm9kZQogCSAqIGFuZCBzZWUgaWYgaXRzIGFscmVhZHkgYmVlbiBjb21taXR0ZWQKQEAgLTExNDMsNiArMTE1MywxMSBAQAogCWlmICghQlRSRlNfSShpbm9kZSktPmxhc3RfdHJhbnMpCiAJCWdvdG8gb3V0OwogCisJLyoKKwkgKiBpZiB0aGUgbGFzdCB0cmFuc2FjdGlvbiB0aGF0IGNoYW5nZWQgdGhpcyBmaWxlIHdhcyBiZWZvcmUKKwkgKiB0aGUgY3VycmVudCB0cmFuc2FjdGlvbiwgd2UgY2FuIGJhaWwgb3V0IG5vdyB3aXRob3V0IGFueQorCSAqIHN5bmNpbmcKKwkgKi8KIAltdXRleF9sb2NrKCZyb290LT5mc19pbmZvLT50cmFuc19tdXRleCk7CiAJaWYgKEJUUkZTX0koaW5vZGUpLT5sYXN0X3RyYW5zIDw9CiAJICAgIHJvb3QtPmZzX2luZm8tPmxhc3RfdHJhbnNfY29tbWl0dGVkKSB7CkBAIC0xMTUyLDEzICsxMTY3LDYgQEAKIAl9CiAJbXV0ZXhfdW5sb2NrKCZyb290LT5mc19pbmZvLT50cmFuc19tdXRleCk7CiAKLQlyb290LT5sb2dfYmF0Y2grKzsKLQlmaWxlbWFwX2ZkYXRhd3JpdGUoaW5vZGUtPmlfbWFwcGluZyk7Ci0JYnRyZnNfd2FpdF9vcmRlcmVkX3JhbmdlKGlub2RlLCAwLCAodTY0KS0xKTsKLQlyb290LT5sb2dfYmF0Y2grKzsKLQotCWlmIChkYXRhc3luYyAmJiAhKGlub2RlLT5pX3N0YXRlICYgSV9ESVJUWV9QQUdFUykpCi0JCWdvdG8gb3V0OwogCS8qCiAJICogb2sgd2UgaGF2ZW4ndCBjb21taXR0ZWQgdGhlIHRyYW5zYWN0aW9uIHlldCwgbGV0cyBkbyBhIGNvbW1pdAogCSAqLwpAQCAtMTE4NywxNCArMTE5NSwxOCBAQAogCSAqLwogCW11dGV4X3VubG9jaygmZGVudHJ5LT5kX2lub2RlLT5pX211dGV4KTsKIAotCWlmIChyZXQgPiAwKSB7Ci0JCXJldCA9IGJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcm9vdCk7Ci0JfSBlbHNlIHsKLQkJcmV0ID0gYnRyZnNfc3luY19sb2codHJhbnMsIHJvb3QpOwotCQlpZiAocmV0ID09IDApCi0JCQlyZXQgPSBidHJmc19lbmRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOwotCQllbHNlCisJaWYgKHJldCAhPSBCVFJGU19OT19MT0dfU1lOQykgeworCQlpZiAocmV0ID4gMCkgewogCQkJcmV0ID0gYnRyZnNfY29tbWl0X3RyYW5zYWN0aW9uKHRyYW5zLCByb290KTsKKwkJfSBlbHNlIHsKKwkJCXJldCA9IGJ0cmZzX3N5bmNfbG9nKHRyYW5zLCByb290KTsKKwkJCWlmIChyZXQgPT0gMCkKKwkJCQlyZXQgPSBidHJmc19lbmRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOworCQkJZWxzZQorCQkJCXJldCA9IGJ0cmZzX2NvbW1pdF90cmFuc2FjdGlvbih0cmFucywgcm9vdCk7CisJCX0KKwl9IGVsc2UgeworCQlyZXQgPSBidHJmc19lbmRfdHJhbnNhY3Rpb24odHJhbnMsIHJvb3QpOwogCX0KIAltdXRleF9sb2NrKCZkZW50cnktPmRfaW5vZGUtPmlfbXV0ZXgpOwogb3V0OgpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvaW5vZGUuYyBiL2ZzL2J0cmZzL2lub2RlLmMKaW5kZXggMTEyZTVhYS4uZGFlMTJkYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW5vZGUuYworKysgYi9mcy9idHJmcy9pbm9kZS5jCkBAIC00MjQsOSArNDI0LDEyIEBACiAJCQkgKiBhbmQgZnJlZSB1cCBvdXIgdGVtcCBwYWdlcy4KIAkJCSAqLwogCQkJZXh0ZW50X2NsZWFyX3VubG9ja19kZWxhbGxvYyhpbm9kZSwKLQkJCQkJCSAgICAgJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLAotCQkJCQkJICAgICBzdGFydCwgZW5kLCBOVUxMLCAxLCAwLAotCQkJCQkJICAgICAwLCAxLCAxLCAxLCAwKTsKKwkJCSAgICAgJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLAorCQkJICAgICBzdGFydCwgZW5kLCBOVUxMLAorCQkJICAgICBFWFRFTlRfQ0xFQVJfVU5MT0NLX1BBR0UgfCBFWFRFTlRfQ0xFQVJfRElSVFkgfAorCQkJICAgICBFWFRFTlRfQ0xFQVJfREVMQUxMT0MgfAorCQkJICAgICBFWFRFTlRfQ0xFQVJfQUNDT1VOVElORyB8CisJCQkgICAgIEVYVEVOVF9TRVRfV1JJVEVCQUNLIHwgRVhURU5UX0VORF9XUklURUJBQ0spOwogCQkJcmV0ID0gMDsKIAkJCWdvdG8gZnJlZV9wYWdlc19vdXQ7CiAJCX0KQEAgLTYzNywxMSArNjQwLDE0IEBACiAJCSAqIGNsZWFyIGRpcnR5LCBzZXQgd3JpdGViYWNrIGFuZCB1bmxvY2sgdGhlIHBhZ2VzLgogCQkgKi8KIAkJZXh0ZW50X2NsZWFyX3VubG9ja19kZWxhbGxvYyhpbm9kZSwKLQkJCQkJICAgICAmQlRSRlNfSShpbm9kZSktPmlvX3RyZWUsCi0JCQkJCSAgICAgYXN5bmNfZXh0ZW50LT5zdGFydCwKLQkJCQkJICAgICBhc3luY19leHRlbnQtPnN0YXJ0ICsKLQkJCQkJICAgICBhc3luY19leHRlbnQtPnJhbV9zaXplIC0gMSwKLQkJCQkJICAgICBOVUxMLCAxLCAxLCAwLCAxLCAxLCAwLCAwKTsKKwkJCQkmQlRSRlNfSShpbm9kZSktPmlvX3RyZWUsCisJCQkJYXN5bmNfZXh0ZW50LT5zdGFydCwKKwkJCQlhc3luY19leHRlbnQtPnN0YXJ0ICsKKwkJCQlhc3luY19leHRlbnQtPnJhbV9zaXplIC0gMSwKKwkJCQlOVUxMLCBFWFRFTlRfQ0xFQVJfVU5MT0NLX1BBR0UgfAorCQkJCUVYVEVOVF9DTEVBUl9VTkxPQ0sgfAorCQkJCUVYVEVOVF9DTEVBUl9ERUxBTExPQyB8CisJCQkJRVhURU5UX0NMRUFSX0RJUlRZIHwgRVhURU5UX1NFVF9XUklURUJBQ0spOwogCiAJCXJldCA9IGJ0cmZzX3N1Ym1pdF9jb21wcmVzc2VkX3dyaXRlKGlub2RlLAogCQkJCSAgICBhc3luY19leHRlbnQtPnN0YXJ0LApAQCAtNzEyLDkgKzcxOCwxNSBAQAogCQkJCQkgICAgc3RhcnQsIGVuZCwgMCwgTlVMTCk7CiAJCWlmIChyZXQgPT0gMCkgewogCQkJZXh0ZW50X2NsZWFyX3VubG9ja19kZWxhbGxvYyhpbm9kZSwKLQkJCQkJCSAgICAgJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLAotCQkJCQkJICAgICBzdGFydCwgZW5kLCBOVUxMLCAxLCAxLAotCQkJCQkJICAgICAxLCAxLCAxLCAxLCAwKTsKKwkJCQkgICAgICZCVFJGU19JKGlub2RlKS0+aW9fdHJlZSwKKwkJCQkgICAgIHN0YXJ0LCBlbmQsIE5VTEwsCisJCQkJICAgICBFWFRFTlRfQ0xFQVJfVU5MT0NLX1BBR0UgfAorCQkJCSAgICAgRVhURU5UX0NMRUFSX1VOTE9DSyB8CisJCQkJICAgICBFWFRFTlRfQ0xFQVJfREVMQUxMT0MgfAorCQkJCSAgICAgRVhURU5UX0NMRUFSX0FDQ09VTlRJTkcgfAorCQkJCSAgICAgRVhURU5UX0NMRUFSX0RJUlRZIHwKKwkJCQkgICAgIEVYVEVOVF9TRVRfV1JJVEVCQUNLIHwKKwkJCQkgICAgIEVYVEVOVF9FTkRfV1JJVEVCQUNLKTsKIAkJCSpucl93cml0dGVuID0gKm5yX3dyaXR0ZW4gKwogCQkJICAgICAoZW5kIC0gc3RhcnQgKyBQQUdFX0NBQ0hFX1NJWkUpIC8gUEFHRV9DQUNIRV9TSVpFOwogCQkJKnBhZ2Vfc3RhcnRlZCA9IDE7CkBAIC03MzgsNiArNzUwLDggQEAKIAlidHJmc19kcm9wX2V4dGVudF9jYWNoZShpbm9kZSwgc3RhcnQsIHN0YXJ0ICsgbnVtX2J5dGVzIC0gMSwgMCk7CiAKIAl3aGlsZSAoZGlza19udW1fYnl0ZXMgPiAwKSB7CisJCXVuc2lnbmVkIGxvbmcgb3A7CisKIAkJY3VyX2FsbG9jX3NpemUgPSBtaW4oZGlza19udW1fYnl0ZXMsIHJvb3QtPmZzX2luZm8tPm1heF9leHRlbnQpOwogCQlyZXQgPSBidHJmc19yZXNlcnZlX2V4dGVudCh0cmFucywgcm9vdCwgY3VyX2FsbG9jX3NpemUsCiAJCQkJCSAgIHJvb3QtPnNlY3RvcnNpemUsIDAsIGFsbG9jX2hpbnQsCkBAIC03ODksMTAgKzgwMywxMyBAQAogCQkgKiBEbyBzZXQgdGhlIFByaXZhdGUyIGJpdCBzbyB3ZSBrbm93IHRoaXMgcGFnZSB3YXMgcHJvcGVybHkKIAkJICogc2V0dXAgZm9yIHdyaXRlcGFnZQogCQkgKi8KKwkJb3AgPSB1bmxvY2sgPyBFWFRFTlRfQ0xFQVJfVU5MT0NLX1BBR0UgOiAwOworCQlvcCB8PSBFWFRFTlRfQ0xFQVJfVU5MT0NLIHwgRVhURU5UX0NMRUFSX0RFTEFMTE9DIHwKKwkJCUVYVEVOVF9TRVRfUFJJVkFURTI7CisKIAkJZXh0ZW50X2NsZWFyX3VubG9ja19kZWxhbGxvYyhpbm9kZSwgJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLAogCQkJCQkgICAgIHN0YXJ0LCBzdGFydCArIHJhbV9zaXplIC0gMSwKLQkJCQkJICAgICBsb2NrZWRfcGFnZSwgdW5sb2NrLCAxLAotCQkJCQkgICAgIDEsIDAsIDAsIDAsIDEpOworCQkJCQkgICAgIGxvY2tlZF9wYWdlLCBvcCk7CiAJCWRpc2tfbnVtX2J5dGVzIC09IGN1cl9hbGxvY19zaXplOwogCQludW1fYnl0ZXMgLT0gY3VyX2FsbG9jX3NpemU7CiAJCWFsbG9jX2hpbnQgPSBpbnMub2JqZWN0aWQgKyBpbnMub2Zmc2V0OwpAQCAtODY0LDggKzg4MSw4IEBACiAJdTY0IGN1cl9lbmQ7CiAJaW50IGxpbWl0ID0gMTAgKiAxMDI0ICogMTA0MjsKIAotCWNsZWFyX2V4dGVudF9iaXQoJkJUUkZTX0koaW5vZGUpLT5pb190cmVlLCBzdGFydCwgZW5kLCBFWFRFTlRfTE9DS0VEIHwKLQkJCSBFWFRFTlRfREVMQUxMT0MsIDEsIDAsIE5VTEwsIEdGUF9OT0ZTKTsKKwljbGVhcl9leHRlbnRfYml0KCZCVFJGU19JKGlub2RlKS0+aW9fdHJlZSwgc3RhcnQsIGVuZCwgRVhURU5UX0xPQ0tFRCwKKwkJCSAxLCAwLCBOVUxMLCBHRlBfTk9GUyk7CiAJd2hpbGUgKHN0YXJ0IDwgZW5kKSB7CiAJCWFzeW5jX2NvdyA9IGttYWxsb2Moc2l6ZW9mKCphc3luY19jb3cpLCBHRlBfTk9GUyk7CiAJCWFzeW5jX2Nvdy0+aW5vZGUgPSBpbm9kZTsKQEAgLTEwMDYsNiArMTAyMyw3IEBACiAKIAkJaWYgKGZvdW5kX2tleS5vZmZzZXQgPiBjdXJfb2Zmc2V0KSB7CiAJCQlleHRlbnRfZW5kID0gZm91bmRfa2V5Lm9mZnNldDsKKwkJCWV4dGVudF90eXBlID0gMDsKIAkJCWdvdG8gb3V0X2NoZWNrOwogCQl9CiAKQEAgLTExMTIsOCArMTEzMCwxMCBAQAogCQlCVUdfT04ocmV0KTsKIAogCQlleHRlbnRfY2xlYXJfdW5sb2NrX2RlbGFsbG9jKGlub2RlLCAmQlRSRlNfSShpbm9kZSktPmlvX3RyZWUsCi0JCQkJCWN1cl9vZmZzZXQsIGN1cl9vZmZzZXQgKyBudW1fYnl0ZXMgLSAxLAotCQkJCQlsb2NrZWRfcGFnZSwgMSwgMSwgMSwgMCwgMCwgMCwgMSk7CisJCQkJY3VyX29mZnNldCwgY3VyX29mZnNldCArIG51bV9ieXRlcyAtIDEsCisJCQkJbG9ja2VkX3BhZ2UsIEVYVEVOVF9DTEVBUl9VTkxPQ0tfUEFHRSB8CisJCQkJRVhURU5UX0NMRUFSX1VOTE9DSyB8IEVYVEVOVF9DTEVBUl9ERUxBTExPQyB8CisJCQkJRVhURU5UX1NFVF9QUklWQVRFMik7CiAJCWN1cl9vZmZzZXQgPSBleHRlbnRfZW5kOwogCQlpZiAoY3VyX29mZnNldCA+IGVuZCkKIAkJCWJyZWFrOwpAQCAtMTE3OCwxNSArMTE5OCwxNyBAQAogCQkJCQlyb290LT5mc19pbmZvLT5tYXhfZXh0ZW50KTsKIAogCQkvKgotCQkgKiBpZiB3ZSBicmVhayBhIGxhcmdlIGV4dGVudCB1cCB0aGVuIGxlYXZlIGRlbGFsbG9jX2V4dGVudHMgYmUsCi0JCSAqIHNpbmNlIHdlJ3ZlIGFscmVhZHkgYWNjb3VudGVkIGZvciB0aGUgbGFyZ2UgZXh0ZW50LgorCQkgKiBpZiB3ZSBicmVhayBhIGxhcmdlIGV4dGVudCB1cCB0aGVuIGxlYXZlIG91c3RhbmRpbmdfZXh0ZW50cworCQkgKiBiZSwgc2luY2Ugd2UndmUgYWxyZWFkeSBhY2NvdW50ZWQgZm9yIHRoZSBsYXJnZSBleHRlbnQuCiAJCSAqLwogCQlpZiAoZGl2NjRfdTY0KG5ld19zaXplICsgcm9vdC0+ZnNfaW5mby0+bWF4X2V4dGVudCAtIDEsCiAJCQkgICAgICByb290LT5mc19pbmZvLT5tYXhfZXh0ZW50KSA8IG51bV9leHRlbnRzKQogCQkJcmV0dXJuIDA7CiAJfQogCi0JQlRSRlNfSShpbm9kZSktPmRlbGFsbG9jX2V4dGVudHMrKzsKKwlzcGluX2xvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOworCUJUUkZTX0koaW5vZGUpLT5vdXRzdGFuZGluZ19leHRlbnRzKys7CisJc3Bpbl91bmxvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0xMjE3LDcgKzEyMzksOSBAQAogCiAJLyogd2UncmUgbm90IGJpZ2dlciB0aGFuIHRoZSBtYXgsIHVucmVzZXJ2ZSB0aGUgc3BhY2UgYW5kIGdvICovCiAJaWYgKG5ld19zaXplIDw9IHJvb3QtPmZzX2luZm8tPm1heF9leHRlbnQpIHsKLQkJQlRSRlNfSShpbm9kZSktPmRlbGFsbG9jX2V4dGVudHMtLTsKKwkJc3Bpbl9sb2NrKCZCVFJGU19JKGlub2RlKS0+YWNjb3VudGluZ19sb2NrKTsKKwkJQlRSRlNfSShpbm9kZSktPm91dHN0YW5kaW5nX2V4dGVudHMtLTsKKwkJc3Bpbl91bmxvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOwogCQlyZXR1cm4gMDsKIAl9CiAKQEAgLTEyMzEsNyArMTI1NSw5IEBACiAJCSAgICAgIHJvb3QtPmZzX2luZm8tPm1heF9leHRlbnQpID4gbnVtX2V4dGVudHMpCiAJCXJldHVybiAwOwogCi0JQlRSRlNfSShpbm9kZSktPmRlbGFsbG9jX2V4dGVudHMtLTsKKwlzcGluX2xvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOworCUJUUkZTX0koaW5vZGUpLT5vdXRzdGFuZGluZ19leHRlbnRzLS07CisJc3Bpbl91bmxvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOwogCiAJcmV0dXJuIDA7CiB9CkBAIC0xMjUzLDcgKzEyNzksOSBAQAogCWlmICghKG9sZCAmIEVYVEVOVF9ERUxBTExPQykgJiYgKGJpdHMgJiBFWFRFTlRfREVMQUxMT0MpKSB7CiAJCXN0cnVjdCBidHJmc19yb290ICpyb290ID0gQlRSRlNfSShpbm9kZSktPnJvb3Q7CiAKLQkJQlRSRlNfSShpbm9kZSktPmRlbGFsbG9jX2V4dGVudHMrKzsKKwkJc3Bpbl9sb2NrKCZCVFJGU19JKGlub2RlKS0+YWNjb3VudGluZ19sb2NrKTsKKwkJQlRSRlNfSShpbm9kZSktPm91dHN0YW5kaW5nX2V4dGVudHMrKzsKKwkJc3Bpbl91bmxvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOwogCQlidHJmc19kZWxhbGxvY19yZXNlcnZlX3NwYWNlKHJvb3QsIGlub2RlLCBlbmQgLSBzdGFydCArIDEpOwogCQlzcGluX2xvY2soJnJvb3QtPmZzX2luZm8tPmRlbGFsbG9jX2xvY2spOwogCQlCVFJGU19JKGlub2RlKS0+ZGVsYWxsb2NfYnl0ZXMgKz0gZW5kIC0gc3RhcnQgKyAxOwpAQCAtMTI4MSw4ICsxMzA5LDEyIEBACiAJaWYgKChzdGF0ZS0+c3RhdGUgJiBFWFRFTlRfREVMQUxMT0MpICYmIChiaXRzICYgRVhURU5UX0RFTEFMTE9DKSkgewogCQlzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCA9IEJUUkZTX0koaW5vZGUpLT5yb290OwogCi0JCUJUUkZTX0koaW5vZGUpLT5kZWxhbGxvY19leHRlbnRzLS07Ci0JCWJ0cmZzX3VucmVzZXJ2ZV9tZXRhZGF0YV9mb3JfZGVsYWxsb2Mocm9vdCwgaW5vZGUsIDEpOworCQlpZiAoYml0cyAmIEVYVEVOVF9ET19BQ0NPVU5USU5HKSB7CisJCQlzcGluX2xvY2soJkJUUkZTX0koaW5vZGUpLT5hY2NvdW50aW5nX2xvY2spOworCQkJQlRSRlNfSShpbm9kZSktPm91dHN0YW5kaW5nX2V4dGVudHMtLTsKKwkJCXNwaW5fdW5sb2NrKCZCVFJGU19JKGlub2RlKS0+YWNjb3VudGluZ19sb2NrKTsKKwkJCWJ0cmZzX3VucmVzZXJ2ZV9tZXRhZGF0YV9mb3JfZGVsYWxsb2Mocm9vdCwgaW5vZGUsIDEpOworCQl9CiAKIAkJc3Bpbl9sb2NrKCZyb290LT5mc19pbmZvLT5kZWxhbGxvY19sb2NrKTsKIAkJaWYgKHN0YXRlLT5lbmQgLSBzdGF0ZS0+c3RhcnQgKyAxID4KQEAgLTMwMDAsMTIgKzMwMzIsMjIgQEAKIAogCWlmICgob2Zmc2V0ICYgKGJsb2Nrc2l6ZSAtIDEpKSA9PSAwKQogCQlnb3RvIG91dDsKKwlyZXQgPSBidHJmc19jaGVja19kYXRhX2ZyZWVfc3BhY2Uocm9vdCwgaW5vZGUsIFBBR0VfQ0FDSEVfU0laRSk7CisJaWYgKHJldCkKKwkJZ290byBvdXQ7CisKKwlyZXQgPSBidHJmc19yZXNlcnZlX21ldGFkYXRhX2Zvcl9kZWxhbGxvYyhyb290LCBpbm9kZSwgMSk7CisJaWYgKHJldCkKKwkJZ290byBvdXQ7CiAKIAlyZXQgPSAtRU5PTUVNOwogYWdhaW46CiAJcGFnZSA9IGdyYWJfY2FjaGVfcGFnZShtYXBwaW5nLCBpbmRleCk7Ci0JaWYgKCFwYWdlKQorCWlmICghcGFnZSkgeworCQlidHJmc19mcmVlX3Jlc2VydmVkX2RhdGFfc3BhY2Uocm9vdCwgaW5vZGUsIFBBR0VfQ0FDSEVfU0laRSk7CisJCWJ0cmZzX3VucmVzZXJ2ZV9tZXRhZGF0YV9mb3JfZGVsYWxsb2Mocm9vdCwgaW5vZGUsIDEpOwogCQlnb3RvIG91dDsKKwl9CiAKIAlwYWdlX3N0YXJ0ID0gcGFnZV9vZmZzZXQocGFnZSk7CiAJcGFnZV9lbmQgPSBwYWdlX3N0YXJ0ICsgUEFHRV9DQUNIRV9TSVpFIC0gMTsKQEAgLTMwMzgsNiArMzA4MCwxMCBAQAogCQlnb3RvIGFnYWluOwogCX0KIAorCWNsZWFyX2V4dGVudF9iaXRzKCZCVFJGU19JKGlub2RlKS0+aW9fdHJlZSwgcGFnZV9zdGFydCwgcGFnZV9lbmQsCisJCQkgIEVYVEVOVF9ESVJUWSB8IEVYVEVOVF9ERUxBTExPQyB8IEVYVEVOVF9ET19BQ0NPVU5USU5HLAorCQkJICBHRlBfTk9GUyk7CisKIAlyZXQgPSBidHJmc19zZXRfZXh0ZW50X2RlbGFsbG9jKGlub2RlLCBwYWdlX3N0YXJ0LCBwYWdlX2VuZCk7CiAJaWYgKHJldCkgewogCQl1bmxvY2tfZXh0ZW50KGlvX3RyZWUsIHBhZ2Vfc3RhcnQsIHBhZ2VfZW5kLCBHRlBfTk9GUyk7CkBAIC0zMDU2LDYgKzMxMDIsOSBAQAogCXVubG9ja19leHRlbnQoaW9fdHJlZSwgcGFnZV9zdGFydCwgcGFnZV9lbmQsIEdGUF9OT0ZTKTsKIAogb3V0X3VubG9jazoKKwlpZiAocmV0KQorCQlidHJmc19mcmVlX3Jlc2VydmVkX2RhdGFfc3BhY2Uocm9vdCwgaW5vZGUsIFBBR0VfQ0FDSEVfU0laRSk7CisJYnRyZnNfdW5yZXNlcnZlX21ldGFkYXRhX2Zvcl9kZWxhbGxvYyhyb290LCBpbm9kZSwgMSk7CiAJdW5sb2NrX3BhZ2UocGFnZSk7CiAJcGFnZV9jYWNoZV9yZWxlYXNlKHBhZ2UpOwogb3V0OgpAQCAtMzA3OSw3ICszMTI4LDkgQEAKIAlpZiAoc2l6ZSA8PSBob2xlX3N0YXJ0KQogCQlyZXR1cm4gMDsKIAotCWJ0cmZzX3RydW5jYXRlX3BhZ2UoaW5vZGUtPmlfbWFwcGluZywgaW5vZGUtPmlfc2l6ZSk7CisJZXJyID0gYnRyZnNfdHJ1bmNhdGVfcGFnZShpbm9kZS0+aV9tYXBwaW5nLCBpbm9kZS0+aV9zaXplKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gZXJyOwogCiAJd2hpbGUgKDEpIHsKIAkJc3RydWN0IGJ0cmZzX29yZGVyZWRfZXh0ZW50ICpvcmRlcmVkOwpAQCAtMzQ0OCw2ICszNDk5LDcgQEAKIAliaS0+Z2VuZXJhdGlvbiA9IDA7CiAJYmktPnNlcXVlbmNlID0gMDsKIAliaS0+bGFzdF90cmFucyA9IDA7CisJYmktPmxhc3Rfc3ViX3RyYW5zID0gMDsKIAliaS0+bG9nZ2VkX3RyYW5zID0gMDsKIAliaS0+ZGVsYWxsb2NfYnl0ZXMgPSAwOwogCWJpLT5yZXNlcnZlZF9ieXRlcyA9IDA7CkBAIC0zNTk4LDEyICszNjUwLDE0IEBACiB7CiAJc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3Q7CiAKLQlpZiAoIWRlbnRyeS0+ZF9pbm9kZSkKLQkJcmV0dXJuIDA7CisJaWYgKCFkZW50cnktPmRfaW5vZGUgJiYgIUlTX1JPT1QoZGVudHJ5KSkKKwkJZGVudHJ5ID0gZGVudHJ5LT5kX3BhcmVudDsKIAotCXJvb3QgPSBCVFJGU19JKGRlbnRyeS0+ZF9pbm9kZSktPnJvb3Q7Ci0JaWYgKGJ0cmZzX3Jvb3RfcmVmcygmcm9vdC0+cm9vdF9pdGVtKSA9PSAwKQotCQlyZXR1cm4gMTsKKwlpZiAoZGVudHJ5LT5kX2lub2RlKSB7CisJCXJvb3QgPSBCVFJGU19JKGRlbnRyeS0+ZF9pbm9kZSktPnJvb3Q7CisJCWlmIChidHJmc19yb290X3JlZnMoJnJvb3QtPnJvb3RfaXRlbSkgPT0gMCkKKwkJCXJldHVybiAxOworCX0KIAlyZXR1cm4gMDsKIH0KIApAQCAtNDgwOCw3ICs0ODYyLDggQEAKIAkJICovCiAJCWNsZWFyX2V4dGVudF9iaXQodHJlZSwgcGFnZV9zdGFydCwgcGFnZV9lbmQsCiAJCQkJIEVYVEVOVF9ESVJUWSB8IEVYVEVOVF9ERUxBTExPQyB8Ci0JCQkJIEVYVEVOVF9MT0NLRUQsIDEsIDAsIE5VTEwsIEdGUF9OT0ZTKTsKKwkJCQkgRVhURU5UX0xPQ0tFRCB8IEVYVEVOVF9ET19BQ0NPVU5USU5HLCAxLCAwLAorCQkJCSBOVUxMLCBHRlBfTk9GUyk7CiAJCS8qCiAJCSAqIHdob2V2ZXIgY2xlYXJlZCB0aGUgcHJpdmF0ZSBiaXQgaXMgcmVzcG9uc2libGUKIAkJICogZm9yIHRoZSBmaW5pc2hfb3JkZXJlZF9pbwpAQCAtNDgyMSw4ICs0ODc2LDggQEAKIAkJbG9ja19leHRlbnQodHJlZSwgcGFnZV9zdGFydCwgcGFnZV9lbmQsIEdGUF9OT0ZTKTsKIAl9CiAJY2xlYXJfZXh0ZW50X2JpdCh0cmVlLCBwYWdlX3N0YXJ0LCBwYWdlX2VuZCwKLQkJIEVYVEVOVF9MT0NLRUQgfCBFWFRFTlRfRElSVFkgfCBFWFRFTlRfREVMQUxMT0MsCi0JCSAxLCAxLCBOVUxMLCBHRlBfTk9GUyk7CisJCSBFWFRFTlRfTE9DS0VEIHwgRVhURU5UX0RJUlRZIHwgRVhURU5UX0RFTEFMTE9DIHwKKwkJIEVYVEVOVF9ET19BQ0NPVU5USU5HLCAxLCAxLCBOVUxMLCBHRlBfTk9GUyk7CiAJX19idHJmc19yZWxlYXNlcGFnZShwYWdlLCBHRlBfTk9GUyk7CiAKIAlDbGVhclBhZ2VDaGVja2VkKHBhZ2UpOwpAQCAtNDkxNyw3ICs0OTcyLDggQEAKIAkgKiBwcmVwYXJlX3BhZ2VzIGluIHRoZSBub3JtYWwgd3JpdGUgcGF0aC4KIAkgKi8KIAljbGVhcl9leHRlbnRfYml0cygmQlRSRlNfSShpbm9kZSktPmlvX3RyZWUsIHBhZ2Vfc3RhcnQsIHBhZ2VfZW5kLAotCQkJICBFWFRFTlRfRElSVFkgfCBFWFRFTlRfREVMQUxMT0MsIEdGUF9OT0ZTKTsKKwkJCSAgRVhURU5UX0RJUlRZIHwgRVhURU5UX0RFTEFMTE9DIHwgRVhURU5UX0RPX0FDQ09VTlRJTkcsCisJCQkgIEdGUF9OT0ZTKTsKIAogCXJldCA9IGJ0cmZzX3NldF9leHRlbnRfZGVsYWxsb2MoaW5vZGUsIHBhZ2Vfc3RhcnQsIHBhZ2VfZW5kKTsKIAlpZiAocmV0KSB7CkBAIC00OTQ0LDcgKzUwMDAsOSBAQAogCXNldF9wYWdlX2RpcnR5KHBhZ2UpOwogCVNldFBhZ2VVcHRvZGF0ZShwYWdlKTsKIAotCUJUUkZTX0koaW5vZGUpLT5sYXN0X3RyYW5zID0gcm9vdC0+ZnNfaW5mby0+Z2VuZXJhdGlvbiArIDE7CisJQlRSRlNfSShpbm9kZSktPmxhc3RfdHJhbnMgPSByb290LT5mc19pbmZvLT5nZW5lcmF0aW9uOworCUJUUkZTX0koaW5vZGUpLT5sYXN0X3N1Yl90cmFucyA9IEJUUkZTX0koaW5vZGUpLT5yb290LT5sb2dfdHJhbnNpZDsKKwogCXVubG9ja19leHRlbnQoaW9fdHJlZSwgcGFnZV9zdGFydCwgcGFnZV9lbmQsIEdGUF9OT0ZTKTsKIAogb3V0X3VubG9jazoKQEAgLTQ5NjksNyArNTAyNyw5IEBACiAJaWYgKElTX0FQUEVORChpbm9kZSkgfHwgSVNfSU1NVVRBQkxFKGlub2RlKSkKIAkJcmV0dXJuOwogCi0JYnRyZnNfdHJ1bmNhdGVfcGFnZShpbm9kZS0+aV9tYXBwaW5nLCBpbm9kZS0+aV9zaXplKTsKKwlyZXQgPSBidHJmc190cnVuY2F0ZV9wYWdlKGlub2RlLT5pX21hcHBpbmcsIGlub2RlLT5pX3NpemUpOworCWlmIChyZXQpCisJCXJldHVybjsKIAlidHJmc193YWl0X29yZGVyZWRfcmFuZ2UoaW5vZGUsIGlub2RlLT5pX3NpemUgJiAofm1hc2spLCAodTY0KS0xKTsKIAogCXRyYW5zID0gYnRyZnNfc3RhcnRfdHJhbnNhY3Rpb24ocm9vdCwgMSk7CkBAIC01MDY0LDkgKzUxMjQsMTEgQEAKIAlpZiAoIWVpKQogCQlyZXR1cm4gTlVMTDsKIAllaS0+bGFzdF90cmFucyA9IDA7CisJZWktPmxhc3Rfc3ViX3RyYW5zID0gMDsKIAllaS0+bG9nZ2VkX3RyYW5zID0gMDsKLQllaS0+ZGVsYWxsb2NfZXh0ZW50cyA9IDA7Ci0JZWktPmRlbGFsbG9jX3Jlc2VydmVkX2V4dGVudHMgPSAwOworCWVpLT5vdXRzdGFuZGluZ19leHRlbnRzID0gMDsKKwllaS0+cmVzZXJ2ZWRfZXh0ZW50cyA9IDA7CisJc3Bpbl9sb2NrX2luaXQoJmVpLT5hY2NvdW50aW5nX2xvY2spOwogCWJ0cmZzX29yZGVyZWRfaW5vZGVfdHJlZV9pbml0KCZlaS0+b3JkZXJlZF90cmVlKTsKIAlJTklUX0xJU1RfSEVBRCgmZWktPmlfb3JwaGFuKTsKIAlJTklUX0xJU1RfSEVBRCgmZWktPm9yZGVyZWRfb3BlcmF0aW9ucyk7CkBAIC01ODA1LDYgKzU4NjcsNiBAQAogCS5yZW1vdmV4YXR0cgk9IGJ0cmZzX3JlbW92ZXhhdHRyLAogfTsKIAotc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zIGJ0cmZzX2RlbnRyeV9vcGVyYXRpb25zID0geworY29uc3Qgc3RydWN0IGRlbnRyeV9vcGVyYXRpb25zIGJ0cmZzX2RlbnRyeV9vcGVyYXRpb25zID0gewogCS5kX2RlbGV0ZQk9IGJ0cmZzX2RlbnRyeV9kZWxldGUsCiB9OwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvaW9jdGwuYyBiL2ZzL2J0cmZzL2lvY3RsLmMKaW5kZXggOWE3ODBjOC4uY2RiYjA1NCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvaW9jdGwuYworKysgYi9mcy9idHJmcy9pb2N0bC5jCkBAIC04MzAsNiArODMwLDcgQEAKIG91dF91bmxvY2s6CiAJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7CiAJaWYgKCFlcnIpIHsKKwkJc2hyaW5rX2RjYWNoZV9zYihyb290LT5mc19pbmZvLT5zYik7CiAJCWJ0cmZzX2ludmFsaWRhdGVfaW5vZGVzKGRlc3QpOwogCQlkX2RlbGV0ZShkZW50cnkpOwogCX0KQEAgLTExMjIsOCArMTEyMywxMCBAQAogCQkJCQlkYXRhbyArPSBvZmYgLSBrZXkub2Zmc2V0OwogCQkJCQlkYXRhbCAtPSBvZmYgLSBrZXkub2Zmc2V0OwogCQkJCX0KLQkJCQlpZiAoa2V5Lm9mZnNldCArIGRhdGFvICsgZGF0YWwgPiBvZmYgKyBsZW4pCi0JCQkJCWRhdGFsID0gb2ZmICsgbGVuIC0ga2V5Lm9mZnNldCAtIGRhdGFvOworCisJCQkJaWYgKGtleS5vZmZzZXQgKyBkYXRhbCA+IG9mZiArIGxlbikKKwkJCQkJZGF0YWwgPSBvZmYgKyBsZW4gLSBrZXkub2Zmc2V0OworCiAJCQkJLyogZGlza28gPT0gMCBtZWFucyBpdCdzIGEgaG9sZSAqLwogCQkJCWlmICghZGlza28pCiAJCQkJCWRhdGFvID0gMDsKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL29yZGVyZWQtZGF0YS5jIGIvZnMvYnRyZnMvb3JkZXJlZC1kYXRhLmMKaW5kZXggODk3ZmJhOC4uNTc5OWJjNCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvb3JkZXJlZC1kYXRhLmMKKysrIGIvZnMvYnRyZnMvb3JkZXJlZC1kYXRhLmMKQEAgLTMwNiw2ICszMDYsMTIgQEAKIAl0cmVlLT5sYXN0ID0gTlVMTDsKIAlzZXRfYml0KEJUUkZTX09SREVSRURfQ09NUExFVEUsICZlbnRyeS0+ZmxhZ3MpOwogCisJc3Bpbl9sb2NrKCZCVFJGU19JKGlub2RlKS0+YWNjb3VudGluZ19sb2NrKTsKKwlCVFJGU19JKGlub2RlKS0+b3V0c3RhbmRpbmdfZXh0ZW50cy0tOworCXNwaW5fdW5sb2NrKCZCVFJGU19JKGlub2RlKS0+YWNjb3VudGluZ19sb2NrKTsKKwlidHJmc191bnJlc2VydmVfbWV0YWRhdGFfZm9yX2RlbGFsbG9jKEJUUkZTX0koaW5vZGUpLT5yb290LAorCQkJCQkgICAgICBpbm9kZSwgMSk7CisKIAlzcGluX2xvY2soJkJUUkZTX0koaW5vZGUpLT5yb290LT5mc19pbmZvLT5vcmRlcmVkX2V4dGVudF9sb2NrKTsKIAlsaXN0X2RlbF9pbml0KCZlbnRyeS0+cm9vdF9leHRlbnRfbGlzdCk7CiAKZGlmZiAtLWdpdCBhL2ZzL2J0cmZzL3JlbG9jYXRpb24uYyBiL2ZzL2J0cmZzL3JlbG9jYXRpb24uYwppbmRleCAzNjFhZDMyLi5jZmNjOTNjIDEwMDY0NAotLS0gYS9mcy9idHJmcy9yZWxvY2F0aW9uLmMKKysrIGIvZnMvYnRyZnMvcmVsb2NhdGlvbi5jCkBAIC0zNTE4LDcgKzM1MTgsNyBAQAogCUJVR19PTighcmMtPmJsb2NrX2dyb3VwKTsKIAogCWJ0cmZzX2luaXRfd29ya2VycygmcmMtPndvcmtlcnMsICJyZWxvY2F0ZSIsCi0JCQkgICBmc19pbmZvLT50aHJlYWRfcG9vbF9zaXplKTsKKwkJCSAgIGZzX2luZm8tPnRocmVhZF9wb29sX3NpemUsIE5VTEwpOwogCiAJcmMtPmV4dGVudF9yb290ID0gZXh0ZW50X3Jvb3Q7CiAJYnRyZnNfcHJlcGFyZV9ibG9ja19ncm91cF9yZWxvY2F0aW9uKGV4dGVudF9yb290LCByYy0+YmxvY2tfZ3JvdXApOwpAQCAtMzcwMSw3ICszNzAxLDcgQEAKIAltYXBwaW5nX3RyZWVfaW5pdCgmcmMtPnJlbG9jX3Jvb3RfdHJlZSk7CiAJSU5JVF9MSVNUX0hFQUQoJnJjLT5yZWxvY19yb290cyk7CiAJYnRyZnNfaW5pdF93b3JrZXJzKCZyYy0+d29ya2VycywgInJlbG9jYXRlIiwKLQkJCSAgIHJvb3QtPmZzX2luZm8tPnRocmVhZF9wb29sX3NpemUpOworCQkJICAgcm9vdC0+ZnNfaW5mby0+dGhyZWFkX3Bvb2xfc2l6ZSwgTlVMTCk7CiAJcmMtPmV4dGVudF9yb290ID0gcm9vdC0+ZnNfaW5mby0+ZXh0ZW50X3Jvb3Q7CiAKIAlzZXRfcmVsb2NfY29udHJvbChyYyk7CmRpZmYgLS1naXQgYS9mcy9idHJmcy9zdXBlci5jIGIvZnMvYnRyZnMvc3VwZXIuYwppbmRleCA5ZGU5YjIyLi43NTJhNTQ2IDEwMDY0NAotLS0gYS9mcy9idHJmcy9zdXBlci5jCisrKyBiL2ZzL2J0cmZzL3N1cGVyLmMKQEAgLTY2LDcgKzY2LDggQEAKIAlPcHRfZGVncmFkZWQsIE9wdF9zdWJ2b2wsIE9wdF9kZXZpY2UsIE9wdF9ub2RhdGFzdW0sIE9wdF9ub2RhdGFjb3csCiAJT3B0X21heF9leHRlbnQsIE9wdF9tYXhfaW5saW5lLCBPcHRfYWxsb2Nfc3RhcnQsIE9wdF9ub2JhcnJpZXIsCiAJT3B0X3NzZCwgT3B0X25vc3NkLCBPcHRfc3NkX3NwcmVhZCwgT3B0X3RocmVhZF9wb29sLCBPcHRfbm9hY2wsCi0JT3B0X2NvbXByZXNzLCBPcHRfbm90cmVlbG9nLCBPcHRfcmF0aW8sIE9wdF9mbHVzaG9uY29tbWl0LCBPcHRfZXJyLAorCU9wdF9jb21wcmVzcywgT3B0X25vdHJlZWxvZywgT3B0X3JhdGlvLCBPcHRfZmx1c2hvbmNvbW1pdCwKKwlPcHRfZGlzY2FyZCwgT3B0X2VyciwKIH07CiAKIHN0YXRpYyBtYXRjaF90YWJsZV90IHRva2VucyA9IHsKQEAgLTg4LDYgKzg5LDcgQEAKIAl7T3B0X25vdHJlZWxvZywgIm5vdHJlZWxvZyJ9LAogCXtPcHRfZmx1c2hvbmNvbW1pdCwgImZsdXNob25jb21taXQifSwKIAl7T3B0X3JhdGlvLCAibWV0YWRhdGFfcmF0aW89JWQifSwKKwl7T3B0X2Rpc2NhcmQsICJkaXNjYXJkIn0sCiAJe09wdF9lcnIsIE5VTEx9LAogfTsKIApAQCAtMjU3LDYgKzI1OSw5IEBACiAJCQkJICAgICAgIGluZm8tPm1ldGFkYXRhX3JhdGlvKTsKIAkJCX0KIAkJCWJyZWFrOworCQljYXNlIE9wdF9kaXNjYXJkOgorCQkJYnRyZnNfc2V0X29wdChpbmZvLT5tb3VudF9vcHQsIERJU0NBUkQpOworCQkJYnJlYWs7CiAJCWRlZmF1bHQ6CiAJCQlicmVhazsKIAkJfQpAQCAtMzQ0LDcgKzM0OSw3IEBACiAJc2ItPnNfZXhwb3J0X29wID0gJmJ0cmZzX2V4cG9ydF9vcHM7CiAJc2ItPnNfeGF0dHIgPSBidHJmc194YXR0cl9oYW5kbGVyczsKIAlzYi0+c190aW1lX2dyYW4gPSAxOwotI2lmZGVmIENPTkZJR19CVFJGU19QT1NJWF9BQ0wKKyNpZmRlZiBDT05GSUdfQlRSRlNfRlNfUE9TSVhfQUNMCiAJc2ItPnNfZmxhZ3MgfD0gTVNfUE9TSVhBQ0w7CiAjZW5kaWYKIApkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvdHJhbnNhY3Rpb24uYyBiL2ZzL2J0cmZzL3RyYW5zYWN0aW9uLmMKaW5kZXggMGI4ZjM2ZC4uYmNhODJhNCAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvdHJhbnNhY3Rpb24uYworKysgYi9mcy9idHJmcy90cmFuc2FjdGlvbi5jCkBAIC0zNDQsMTAgKzM0NCwxMCBAQAogLyoKICAqIHdoZW4gYnRyZWUgYmxvY2tzIGFyZSBhbGxvY2F0ZWQsIHRoZXkgaGF2ZSBzb21lIGNvcnJlc3BvbmRpbmcgYml0cyBzZXQgZm9yCiAgKiB0aGVtIGluIG9uZSBvZiB0d28gZXh0ZW50X2lvIHRyZWVzLiAgVGhpcyBpcyB1c2VkIHRvIG1ha2Ugc3VyZSBhbGwgb2YKLSAqIHRob3NlIGV4dGVudHMgYXJlIG9uIGRpc2sgZm9yIHRyYW5zYWN0aW9uIG9yIGxvZyBjb21taXQKKyAqIHRob3NlIGV4dGVudHMgYXJlIHNlbnQgdG8gZGlzayBidXQgZG9lcyBub3Qgd2FpdCBvbiB0aGVtCiAgKi8KLWludCBidHJmc193cml0ZV9hbmRfd2FpdF9tYXJrZWRfZXh0ZW50cyhzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwKLQkJCQkJc3RydWN0IGV4dGVudF9pb190cmVlICpkaXJ0eV9wYWdlcykKK2ludCBidHJmc193cml0ZV9tYXJrZWRfZXh0ZW50cyhzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCwKKwkJCSAgICAgICBzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmRpcnR5X3BhZ2VzKQogewogCWludCByZXQ7CiAJaW50IGVyciA9IDA7CkBAIC0zOTQsNiArMzk0LDI5IEBACiAJCQlwYWdlX2NhY2hlX3JlbGVhc2UocGFnZSk7CiAJCX0KIAl9CisJaWYgKGVycikKKwkJd2VyciA9IGVycjsKKwlyZXR1cm4gd2VycjsKK30KKworLyoKKyAqIHdoZW4gYnRyZWUgYmxvY2tzIGFyZSBhbGxvY2F0ZWQsIHRoZXkgaGF2ZSBzb21lIGNvcnJlc3BvbmRpbmcgYml0cyBzZXQgZm9yCisgKiB0aGVtIGluIG9uZSBvZiB0d28gZXh0ZW50X2lvIHRyZWVzLiAgVGhpcyBpcyB1c2VkIHRvIG1ha2Ugc3VyZSBhbGwgb2YKKyAqIHRob3NlIGV4dGVudHMgYXJlIG9uIGRpc2sgZm9yIHRyYW5zYWN0aW9uIG9yIGxvZyBjb21taXQuICBXZSB3YWl0CisgKiBvbiBhbGwgdGhlIHBhZ2VzIGFuZCBjbGVhciB0aGVtIGZyb20gdGhlIGRpcnR5IHBhZ2VzIHN0YXRlIHRyZWUKKyAqLworaW50IGJ0cmZzX3dhaXRfbWFya2VkX2V4dGVudHMoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsCisJCQkgICAgICBzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmRpcnR5X3BhZ2VzKQoreworCWludCByZXQ7CisJaW50IGVyciA9IDA7CisJaW50IHdlcnIgPSAwOworCXN0cnVjdCBwYWdlICpwYWdlOworCXN0cnVjdCBpbm9kZSAqYnRyZWVfaW5vZGUgPSByb290LT5mc19pbmZvLT5idHJlZV9pbm9kZTsKKwl1NjQgc3RhcnQgPSAwOworCXU2NCBlbmQ7CisJdW5zaWduZWQgbG9uZyBpbmRleDsKKwogCXdoaWxlICgxKSB7CiAJCXJldCA9IGZpbmRfZmlyc3RfZXh0ZW50X2JpdChkaXJ0eV9wYWdlcywgMCwgJnN0YXJ0LCAmZW5kLAogCQkJCQkgICAgRVhURU5UX0RJUlRZKTsKQEAgLTQyNCw2ICs0NDcsMjIgQEAKIAlyZXR1cm4gd2VycjsKIH0KIAorLyoKKyAqIHdoZW4gYnRyZWUgYmxvY2tzIGFyZSBhbGxvY2F0ZWQsIHRoZXkgaGF2ZSBzb21lIGNvcnJlc3BvbmRpbmcgYml0cyBzZXQgZm9yCisgKiB0aGVtIGluIG9uZSBvZiB0d28gZXh0ZW50X2lvIHRyZWVzLiAgVGhpcyBpcyB1c2VkIHRvIG1ha2Ugc3VyZSBhbGwgb2YKKyAqIHRob3NlIGV4dGVudHMgYXJlIG9uIGRpc2sgZm9yIHRyYW5zYWN0aW9uIG9yIGxvZyBjb21taXQKKyAqLworaW50IGJ0cmZzX3dyaXRlX2FuZF93YWl0X21hcmtlZF9leHRlbnRzKHN0cnVjdCBidHJmc19yb290ICpyb290LAorCQkJCQlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmRpcnR5X3BhZ2VzKQoreworCWludCByZXQ7CisJaW50IHJldDI7CisKKwlyZXQgPSBidHJmc193cml0ZV9tYXJrZWRfZXh0ZW50cyhyb290LCBkaXJ0eV9wYWdlcyk7CisJcmV0MiA9IGJ0cmZzX3dhaXRfbWFya2VkX2V4dGVudHMocm9vdCwgZGlydHlfcGFnZXMpOworCXJldHVybiByZXQgfHwgcmV0MjsKK30KKwogaW50IGJ0cmZzX3dyaXRlX2FuZF93YWl0X3RyYW5zYWN0aW9uKHN0cnVjdCBidHJmc190cmFuc19oYW5kbGUgKnRyYW5zLAogCQkJCSAgICAgc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpCiB7CmRpZmYgLS1naXQgYS9mcy9idHJmcy90cmFuc2FjdGlvbi5oIGIvZnMvYnRyZnMvdHJhbnNhY3Rpb24uaAppbmRleCA2NjNjNjc0Li5kNGUzZTdhIDEwMDY0NAotLS0gYS9mcy9idHJmcy90cmFuc2FjdGlvbi5oCisrKyBiL2ZzL2J0cmZzL3RyYW5zYWN0aW9uLmgKQEAgLTc5LDYgKzc5LDcgQEAKIAkJCQkJICAgICAgc3RydWN0IGlub2RlICppbm9kZSkKIHsKIAlCVFJGU19JKGlub2RlKS0+bGFzdF90cmFucyA9IHRyYW5zLT50cmFuc2FjdGlvbi0+dHJhbnNpZDsKKwlCVFJGU19JKGlub2RlKS0+bGFzdF9zdWJfdHJhbnMgPSBCVFJGU19JKGlub2RlKS0+cm9vdC0+bG9nX3RyYW5zaWQ7CiB9CiAKIGludCBidHJmc19lbmRfdHJhbnNhY3Rpb24oc3RydWN0IGJ0cmZzX3RyYW5zX2hhbmRsZSAqdHJhbnMsCkBAIC0xMDcsNSArMTA4LDkgQEAKIAkJCQlzdHJ1Y3QgYnRyZnNfcm9vdCAqcm9vdCk7CiBpbnQgYnRyZnNfd3JpdGVfYW5kX3dhaXRfbWFya2VkX2V4dGVudHMoc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QsCiAJCQkJCXN0cnVjdCBleHRlbnRfaW9fdHJlZSAqZGlydHlfcGFnZXMpOworaW50IGJ0cmZzX3dyaXRlX21hcmtlZF9leHRlbnRzKHN0cnVjdCBidHJmc19yb290ICpyb290LAorCQkJCQlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmRpcnR5X3BhZ2VzKTsKK2ludCBidHJmc193YWl0X21hcmtlZF9leHRlbnRzKHN0cnVjdCBidHJmc19yb290ICpyb290LAorCQkJCQlzdHJ1Y3QgZXh0ZW50X2lvX3RyZWUgKmRpcnR5X3BhZ2VzKTsKIGludCBidHJmc190cmFuc2FjdGlvbl9pbl9jb21taXQoc3RydWN0IGJ0cmZzX2ZzX2luZm8gKmluZm8pOwogI2VuZGlmCmRpZmYgLS1naXQgYS9mcy9idHJmcy90cmVlLWxvZy5jIGIvZnMvYnRyZnMvdHJlZS1sb2cuYwppbmRleCA3ODI3ODQxLi43NDE2NjZhIDEwMDY0NAotLS0gYS9mcy9idHJmcy90cmVlLWxvZy5jCisrKyBiL2ZzL2J0cmZzL3RyZWUtbG9nLmMKQEAgLTEzNywxMSArMTM3LDIwIEBACiAKIAltdXRleF9sb2NrKCZyb290LT5sb2dfbXV0ZXgpOwogCWlmIChyb290LT5sb2dfcm9vdCkgeworCQlpZiAoIXJvb3QtPmxvZ19zdGFydF9waWQpIHsKKwkJCXJvb3QtPmxvZ19zdGFydF9waWQgPSBjdXJyZW50LT5waWQ7CisJCQlyb290LT5sb2dfbXVsdGlwbGVfcGlkcyA9IGZhbHNlOworCQl9IGVsc2UgaWYgKHJvb3QtPmxvZ19zdGFydF9waWQgIT0gY3VycmVudC0+cGlkKSB7CisJCQlyb290LT5sb2dfbXVsdGlwbGVfcGlkcyA9IHRydWU7CisJCX0KKwogCQlyb290LT5sb2dfYmF0Y2grKzsKIAkJYXRvbWljX2luYygmcm9vdC0+bG9nX3dyaXRlcnMpOwogCQltdXRleF91bmxvY2soJnJvb3QtPmxvZ19tdXRleCk7CiAJCXJldHVybiAwOwogCX0KKwlyb290LT5sb2dfbXVsdGlwbGVfcGlkcyA9IGZhbHNlOworCXJvb3QtPmxvZ19zdGFydF9waWQgPSBjdXJyZW50LT5waWQ7CiAJbXV0ZXhfbG9jaygmcm9vdC0+ZnNfaW5mby0+dHJlZV9sb2dfbXV0ZXgpOwogCWlmICghcm9vdC0+ZnNfaW5mby0+bG9nX3Jvb3RfdHJlZSkgewogCQlyZXQgPSBidHJmc19pbml0X2xvZ19yb290X3RyZWUodHJhbnMsIHJvb3QtPmZzX2luZm8pOwpAQCAtMTk3MSw2ICsxOTgwLDcgQEAKIAlpbnQgcmV0OwogCXN0cnVjdCBidHJmc19yb290ICpsb2cgPSByb290LT5sb2dfcm9vdDsKIAlzdHJ1Y3QgYnRyZnNfcm9vdCAqbG9nX3Jvb3RfdHJlZSA9IHJvb3QtPmZzX2luZm8tPmxvZ19yb290X3RyZWU7CisJdTY0IGxvZ190cmFuc2lkID0gMDsKIAogCW11dGV4X2xvY2soJnJvb3QtPmxvZ19tdXRleCk7CiAJaW5kZXgxID0gcm9vdC0+bG9nX3RyYW5zaWQgJSAyOwpAQCAtMTk4NywxMCArMTk5NywxMSBAQAogCiAJd2hpbGUgKDEpIHsKIAkJdW5zaWduZWQgbG9uZyBiYXRjaCA9IHJvb3QtPmxvZ19iYXRjaDsKLQkJbXV0ZXhfdW5sb2NrKCZyb290LT5sb2dfbXV0ZXgpOwotCQlzY2hlZHVsZV90aW1lb3V0X3VuaW50ZXJydXB0aWJsZSgxKTsKLQkJbXV0ZXhfbG9jaygmcm9vdC0+bG9nX211dGV4KTsKLQorCQlpZiAocm9vdC0+bG9nX211bHRpcGxlX3BpZHMpIHsKKwkJCW11dGV4X3VubG9jaygmcm9vdC0+bG9nX211dGV4KTsKKwkJCXNjaGVkdWxlX3RpbWVvdXRfdW5pbnRlcnJ1cHRpYmxlKDEpOworCQkJbXV0ZXhfbG9jaygmcm9vdC0+bG9nX211dGV4KTsKKwkJfQogCQl3YWl0X2Zvcl93cml0ZXIodHJhbnMsIHJvb3QpOwogCQlpZiAoYmF0Y2ggPT0gcm9vdC0+bG9nX2JhdGNoKQogCQkJYnJlYWs7CkBAIC0yMDAzLDE0ICsyMDE0LDE5IEBACiAJCWdvdG8gb3V0OwogCX0KIAotCXJldCA9IGJ0cmZzX3dyaXRlX2FuZF93YWl0X21hcmtlZF9leHRlbnRzKGxvZywgJmxvZy0+ZGlydHlfbG9nX3BhZ2VzKTsKKwkvKiB3ZSBzdGFydCBJTyBvbiAgYWxsIHRoZSBtYXJrZWQgZXh0ZW50cyBoZXJlLCBidXQgd2UgZG9uJ3QgYWN0dWFsbHkKKwkgKiB3YWl0IGZvciB0aGVtIHVudGlsIGxhdGVyLgorCSAqLworCXJldCA9IGJ0cmZzX3dyaXRlX21hcmtlZF9leHRlbnRzKGxvZywgJmxvZy0+ZGlydHlfbG9nX3BhZ2VzKTsKIAlCVUdfT04ocmV0KTsKIAogCWJ0cmZzX3NldF9yb290X25vZGUoJmxvZy0+cm9vdF9pdGVtLCBsb2ctPm5vZGUpOwogCiAJcm9vdC0+bG9nX2JhdGNoID0gMDsKKwlsb2dfdHJhbnNpZCA9IHJvb3QtPmxvZ190cmFuc2lkOwogCXJvb3QtPmxvZ190cmFuc2lkKys7CiAJbG9nLT5sb2dfdHJhbnNpZCA9IHJvb3QtPmxvZ190cmFuc2lkOworCXJvb3QtPmxvZ19zdGFydF9waWQgPSAwOwogCXNtcF9tYigpOwogCS8qCiAJICogbG9nIHRyZWUgaGFzIGJlZW4gZmx1c2hlZCB0byBkaXNrLCBuZXcgbW9kaWZpY2F0aW9ucyBvZgpAQCAtMjAzNiw2ICsyMDUyLDcgQEAKIAogCWluZGV4MiA9IGxvZ19yb290X3RyZWUtPmxvZ190cmFuc2lkICUgMjsKIAlpZiAoYXRvbWljX3JlYWQoJmxvZ19yb290X3RyZWUtPmxvZ19jb21taXRbaW5kZXgyXSkpIHsKKwkJYnRyZnNfd2FpdF9tYXJrZWRfZXh0ZW50cyhsb2csICZsb2ctPmRpcnR5X2xvZ19wYWdlcyk7CiAJCXdhaXRfbG9nX2NvbW1pdCh0cmFucywgbG9nX3Jvb3RfdHJlZSwKIAkJCQlsb2dfcm9vdF90cmVlLT5sb2dfdHJhbnNpZCk7CiAJCW11dGV4X3VubG9jaygmbG9nX3Jvb3RfdHJlZS0+bG9nX211dGV4KTsKQEAgLTIwNTUsNiArMjA3Miw3IEBACiAJICogY2hlY2sgdGhlIGZ1bGwgY29tbWl0IGZsYWcgYWdhaW4KIAkgKi8KIAlpZiAocm9vdC0+ZnNfaW5mby0+bGFzdF90cmFuc19sb2dfZnVsbF9jb21taXQgPT0gdHJhbnMtPnRyYW5zaWQpIHsKKwkJYnRyZnNfd2FpdF9tYXJrZWRfZXh0ZW50cyhsb2csICZsb2ctPmRpcnR5X2xvZ19wYWdlcyk7CiAJCW11dGV4X3VubG9jaygmbG9nX3Jvb3RfdHJlZS0+bG9nX211dGV4KTsKIAkJcmV0ID0gLUVBR0FJTjsKIAkJZ290byBvdXRfd2FrZV9sb2dfcm9vdDsKQEAgLTIwNjMsNiArMjA4MSw3IEBACiAJcmV0ID0gYnRyZnNfd3JpdGVfYW5kX3dhaXRfbWFya2VkX2V4dGVudHMobG9nX3Jvb3RfdHJlZSwKIAkJCQkmbG9nX3Jvb3RfdHJlZS0+ZGlydHlfbG9nX3BhZ2VzKTsKIAlCVUdfT04ocmV0KTsKKwlidHJmc193YWl0X21hcmtlZF9leHRlbnRzKGxvZywgJmxvZy0+ZGlydHlfbG9nX3BhZ2VzKTsKIAogCWJ0cmZzX3NldF9zdXBlcl9sb2dfcm9vdCgmcm9vdC0+ZnNfaW5mby0+c3VwZXJfZm9yX2NvbW1pdCwKIAkJCQlsb2dfcm9vdF90cmVlLT5ub2RlLT5zdGFydCk7CkBAIC0yMDgyLDkgKzIxMDEsMTQgQEAKIAkgKiB0aGUgcnVubmluZyB0cmFuc2FjdGlvbiBvcGVuLCBzbyBhIGZ1bGwgY29tbWl0IGNhbid0IGhvcAogCSAqIGluIGFuZCBjYXVzZSBwcm9ibGVtcyBlaXRoZXIuCiAJICovCi0Jd3JpdGVfY3RyZWVfc3VwZXIodHJhbnMsIHJvb3QtPmZzX2luZm8tPnRyZWVfcm9vdCwgMik7CisJd3JpdGVfY3RyZWVfc3VwZXIodHJhbnMsIHJvb3QtPmZzX2luZm8tPnRyZWVfcm9vdCwgMSk7CiAJcmV0ID0gMDsKIAorCW11dGV4X2xvY2soJnJvb3QtPmxvZ19tdXRleCk7CisJaWYgKHJvb3QtPmxhc3RfbG9nX2NvbW1pdCA8IGxvZ190cmFuc2lkKQorCQlyb290LT5sYXN0X2xvZ19jb21taXQgPSBsb2dfdHJhbnNpZDsKKwltdXRleF91bmxvY2soJnJvb3QtPmxvZ19tdXRleCk7CisKIG91dF93YWtlX2xvZ19yb290OgogCWF0b21pY19zZXQoJmxvZ19yb290X3RyZWUtPmxvZ19jb21taXRbaW5kZXgyXSwgMCk7CiAJc21wX21iKCk7CkBAIC0yODUyLDYgKzI4NzYsMjEgQEAKIAlyZXR1cm4gcmV0OwogfQogCitzdGF0aWMgaW50IGlub2RlX2luX2xvZyhzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywKKwkJIHN0cnVjdCBpbm9kZSAqaW5vZGUpCit7CisJc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QgPSBCVFJGU19JKGlub2RlKS0+cm9vdDsKKwlpbnQgcmV0ID0gMDsKKworCW11dGV4X2xvY2soJnJvb3QtPmxvZ19tdXRleCk7CisJaWYgKEJUUkZTX0koaW5vZGUpLT5sb2dnZWRfdHJhbnMgPT0gdHJhbnMtPnRyYW5zaWQgJiYKKwkgICAgQlRSRlNfSShpbm9kZSktPmxhc3Rfc3ViX3RyYW5zIDw9IHJvb3QtPmxhc3RfbG9nX2NvbW1pdCkKKwkJcmV0ID0gMTsKKwltdXRleF91bmxvY2soJnJvb3QtPmxvZ19tdXRleCk7CisJcmV0dXJuIHJldDsKK30KKworCiAvKgogICogaGVscGVyIGZ1bmN0aW9uIGFyb3VuZCBidHJmc19sb2dfaW5vZGUgdG8gbWFrZSBzdXJlIG5ld2x5IGNyZWF0ZWQKICAqIHBhcmVudCBkaXJlY3RvcmllcyBhbHNvIGVuZCB1cCBpbiB0aGUgbG9nLiAgQSBtaW5pbWFsIGlub2RlIGFuZCBiYWNrcmVmCkBAIC0yODkxLDYgKzI5MzAsMTEgQEAKIAlpZiAocmV0KQogCQlnb3RvIGVuZF9ub190cmFuczsKIAorCWlmIChpbm9kZV9pbl9sb2codHJhbnMsIGlub2RlKSkgeworCQlyZXQgPSBCVFJGU19OT19MT0dfU1lOQzsKKwkJZ290byBlbmRfbm9fdHJhbnM7CisJfQorCiAJc3RhcnRfbG9nX3RyYW5zKHRyYW5zLCByb290KTsKIAogCXJldCA9IGJ0cmZzX2xvZ19pbm9kZSh0cmFucywgcm9vdCwgaW5vZGUsIGlub2RlX29ubHkpOwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMvdHJlZS1sb2cuaCBiL2ZzL2J0cmZzL3RyZWUtbG9nLmgKaW5kZXggZDA5Yzc2MC4uMDc3NmVhYyAxMDA2NDQKLS0tIGEvZnMvYnRyZnMvdHJlZS1sb2cuaAorKysgYi9mcy9idHJmcy90cmVlLWxvZy5oCkBAIC0xOSw2ICsxOSw5IEBACiAjaWZuZGVmIF9fVFJFRV9MT0dfCiAjZGVmaW5lIF9fVFJFRV9MT0dfCiAKKy8qIHJldHVybiB2YWx1ZSBmb3IgYnRyZnNfbG9nX2RlbnRyeV9zYWZlIHRoYXQgbWVhbnMgd2UgZG9uJ3QgbmVlZCB0byBsb2cgaXQgYXQgYWxsICovCisjZGVmaW5lIEJUUkZTX05PX0xPR19TWU5DIDI1NgorCiBpbnQgYnRyZnNfc3luY19sb2coc3RydWN0IGJ0cmZzX3RyYW5zX2hhbmRsZSAqdHJhbnMsCiAJCSAgIHN0cnVjdCBidHJmc19yb290ICpyb290KTsKIGludCBidHJmc19mcmVlX2xvZyhzdHJ1Y3QgYnRyZnNfdHJhbnNfaGFuZGxlICp0cmFucywgc3RydWN0IGJ0cmZzX3Jvb3QgKnJvb3QpOwpkaWZmIC0tZ2l0IGEvZnMvYnRyZnMveGF0dHIuYyBiL2ZzL2J0cmZzL3hhdHRyLmMKaW5kZXggYjBmYzkzZi4uYjZkZDU5NiAxMDA2NDQKLS0tIGEvZnMvYnRyZnMveGF0dHIuYworKysgYi9mcy9idHJmcy94YXR0ci5jCkBAIC0yNjAsNyArMjYwLDcgQEAKICAqIGF0dHJpYnV0ZXMgYXJlIGhhbmRsZWQgZGlyZWN0bHkuCiAgKi8KIHN0cnVjdCB4YXR0cl9oYW5kbGVyICpidHJmc194YXR0cl9oYW5kbGVyc1tdID0gewotI2lmZGVmIENPTkZJR19CVFJGU19QT1NJWF9BQ0wKKyNpZmRlZiBDT05GSUdfQlRSRlNfRlNfUE9TSVhfQUNMCiAJJmJ0cmZzX3hhdHRyX2FjbF9hY2Nlc3NfaGFuZGxlciwKIAkmYnRyZnNfeGF0dHJfYWNsX2RlZmF1bHRfaGFuZGxlciwKICNlbmRpZgpkaWZmIC0tZ2l0IGEvZnMvZGxtL2xvd2NvbW1zLmMgYi9mcy9kbG0vbG93Y29tbXMuYwppbmRleCAyNDBjZWYxLi43MDczNmViIDEwMDY0NAotLS0gYS9mcy9kbG0vbG93Y29tbXMuYworKysgYi9mcy9kbG0vbG93Y29tbXMuYwpAQCAtMzE2LDYgKzMxNiwxMCBAQAogewogCXN0cnVjdCBjb25uZWN0aW9uICpjb247CiAKKwkvKiB3aXRoIHNjdHAgdGhlcmUncyBubyBjb25uZWN0aW5nIHdpdGhvdXQgc2VuZGluZyAqLworCWlmIChkbG1fY29uZmlnLmNpX3Byb3RvY29sICE9IDApCisJCXJldHVybiAwOworCiAJaWYgKG5vZGVpZCA9PSBkbG1fb3VyX25vZGVpZCgpKQogCQlyZXR1cm4gMDsKIApAQCAtNDU1LDkgKzQ1OSw5IEBACiAJCQlpbnQgcHJpbV9sZW4sIHJldDsKIAkJCWludCBhZGRyX2xlbjsKIAkJCXN0cnVjdCBjb25uZWN0aW9uICpuZXdfY29uOwotCQkJc3RydWN0IGZpbGUgKmZpbGU7CiAJCQlzY3RwX3BlZWxvZmZfYXJnX3QgcGFyZzsKIAkJCWludCBwYXJnbGVuID0gc2l6ZW9mKHBhcmcpOworCQkJaW50IGVycjsKIAogCQkJLyoKIAkJCSAqIFdlIGdldCB0aGlzIGJlZm9yZSBhbnkgZGF0YSBmb3IgYW4gYXNzb2NpYXRpb24uCkBAIC01MTIsMTkgKzUxNiwyMiBAQAogCQkJcmV0ID0ga2VybmVsX2dldHNvY2tvcHQoY29uLT5zb2NrLCBJUFBST1RPX1NDVFAsCiAJCQkJCQlTQ1RQX1NPQ0tPUFRfUEVFTE9GRiwKIAkJCQkJCSh2b2lkICopJnBhcmcsICZwYXJnbGVuKTsKLQkJCWlmIChyZXQpIHsKKwkJCWlmIChyZXQgPCAwKSB7CiAJCQkJbG9nX3ByaW50KCJDYW4ndCBwZWVsIG9mZiBhIHNvY2tldCBmb3IgIgotCQkJCQkgICJjb25uZWN0aW9uICVkIHRvIG5vZGUgJWQ6IGVycj0lZFxuIiwKKwkJCQkJICAiY29ubmVjdGlvbiAlZCB0byBub2RlICVkOiBlcnI9JWQiLAogCQkJCQkgIHBhcmcuYXNzb2NpZCwgbm9kZWlkLCByZXQpOworCQkJCXJldHVybjsKIAkJCX0KLQkJCWZpbGUgPSBmZ2V0KHBhcmcuc2QpOwotCQkJbmV3X2Nvbi0+c29jayA9IFNPQ0tFVF9JKGZpbGUtPmZfZGVudHJ5LT5kX2lub2RlKTsKKwkJCW5ld19jb24tPnNvY2sgPSBzb2NrZmRfbG9va3VwKHBhcmcuc2QsICZlcnIpOworCQkJaWYgKCFuZXdfY29uLT5zb2NrKSB7CisJCQkJbG9nX3ByaW50KCJzb2NrZmRfbG9va3VwIGVycm9yICVkIiwgZXJyKTsKKwkJCQlyZXR1cm47CisJCQl9CiAJCQlhZGRfc29jayhuZXdfY29uLT5zb2NrLCBuZXdfY29uKTsKLQkJCWZwdXQoZmlsZSk7Ci0JCQlwdXRfdW51c2VkX2ZkKHBhcmcuc2QpOworCQkJc29ja2ZkX3B1dChuZXdfY29uLT5zb2NrKTsKIAotCQkJbG9nX3ByaW50KCJnb3QgbmV3L3Jlc3RhcnRlZCBhc3NvY2lhdGlvbiAlZCBub2RlaWQgJWQiLAotCQkJCSAoaW50KXNuLT5zbl9hc3NvY19jaGFuZ2Uuc2FjX2Fzc29jX2lkLCBub2RlaWQpOworCQkJbG9nX3ByaW50KCJjb25uZWN0aW5nIHRvICVkIHNjdHAgYXNzb2NpYXRpb24gJWQiLAorCQkJCSBub2RlaWQsIChpbnQpc24tPnNuX2Fzc29jX2NoYW5nZS5zYWNfYXNzb2NfaWQpOwogCiAJCQkvKiBTZW5kIGFueSBwZW5kaW5nIHdyaXRlcyAqLwogCQkJY2xlYXJfYml0KENGX0NPTk5FQ1RfUEVORElORywgJm5ld19jb24tPmZsYWdzKTsKQEAgLTgzNyw4ICs4NDQsNiBAQAogCWlmIChjb24tPnJldHJpZXMrKyA+IE1BWF9DT05ORUNUX1JFVFJJRVMpCiAJCXJldHVybjsKIAotCWxvZ19wcmludCgiSW5pdGlhdGluZyBhc3NvY2lhdGlvbiB3aXRoIG5vZGUgJWQiLCBjb24tPm5vZGVpZCk7Ci0KIAlpZiAobm9kZWlkX3RvX2FkZHIoY29uLT5ub2RlaWQsIChzdHJ1Y3Qgc29ja2FkZHIgKikmcmVtX2FkZHIpKSB7CiAJCWxvZ19wcmludCgibm8gYWRkcmVzcyBmb3Igbm9kZWlkICVkIiwgY29uLT5ub2RlaWQpOwogCQlyZXR1cm47CkBAIC04NTUsMTEgKzg2MCwxNCBAQAogCW91dG1lc3NhZ2UubXNnX2ZsYWdzID0gTVNHX0VPUjsKIAogCXNwaW5fbG9jaygmY29uLT53cml0ZXF1ZXVlX2xvY2spOwotCWUgPSBsaXN0X2VudHJ5KGNvbi0+d3JpdGVxdWV1ZS5uZXh0LCBzdHJ1Y3Qgd3JpdGVxdWV1ZV9lbnRyeSwKLQkJICAgICAgIGxpc3QpOwogCi0JQlVHX09OKChzdHJ1Y3QgbGlzdF9oZWFkICopIGUgPT0gJmNvbi0+d3JpdGVxdWV1ZSk7CisJaWYgKGxpc3RfZW1wdHkoJmNvbi0+d3JpdGVxdWV1ZSkpIHsKKwkJc3Bpbl91bmxvY2soJmNvbi0+d3JpdGVxdWV1ZV9sb2NrKTsKKwkJbG9nX3ByaW50KCJ3cml0ZXF1ZXVlIGVtcHR5IGZvciBub2RlaWQgJWQiLCBjb24tPm5vZGVpZCk7CisJCXJldHVybjsKKwl9CiAKKwllID0gbGlzdF9maXJzdF9lbnRyeSgmY29uLT53cml0ZXF1ZXVlLCBzdHJ1Y3Qgd3JpdGVxdWV1ZV9lbnRyeSwgbGlzdCk7CiAJbGVuID0gZS0+bGVuOwogCW9mZnNldCA9IGUtPm9mZnNldDsKIAlzcGluX3VubG9jaygmY29uLT53cml0ZXF1ZXVlX2xvY2spOwpkaWZmIC0tZ2l0IGEvZnMvZWNyeXB0ZnMvS2NvbmZpZyBiL2ZzL2VjcnlwdGZzL0tjb25maWcKaW5kZXggOGFhZGI5OS4uMWNkNmQ5ZCAxMDA2NDQKLS0tIGEvZnMvZWNyeXB0ZnMvS2NvbmZpZworKysgYi9mcy9lY3J5cHRmcy9LY29uZmlnCkBAIC0xLDggKzEsOSBAQAogY29uZmlnIEVDUllQVF9GUwogCXRyaXN0YXRlICJlQ3J5cHQgZmlsZXN5c3RlbSBsYXllciBzdXBwb3J0IChFWFBFUklNRU5UQUwpIgotCWRlcGVuZHMgb24gRVhQRVJJTUVOVEFMICYmIEtFWVMgJiYgTkVUCisJZGVwZW5kcyBvbiBFWFBFUklNRU5UQUwgJiYgS0VZUyAmJiBDUllQVE8KIAlzZWxlY3QgQ1JZUFRPX0VDQgogCXNlbGVjdCBDUllQVE9fQ0JDCisJc2VsZWN0IENSWVBUT19NRDUKIAloZWxwCiAJICBFbmNyeXB0ZWQgZmlsZXN5c3RlbSB0aGF0IG9wZXJhdGVzIG9uIHRoZSBWRlMgbGF5ZXIuICBTZWUKIAkgIDxmaWxlOkRvY3VtZW50YXRpb24vZmlsZXN5c3RlbXMvZWNyeXB0ZnMudHh0PiB0byBsZWFybiBtb3JlIGFib3V0CmRpZmYgLS1naXQgYS9mcy9lY3J5cHRmcy9tYWluLmMgYi9mcy9lY3J5cHRmcy9tYWluLmMKaW5kZXggMTAxZmU0Yy4uYzZhYzg1ZCAxMDA2NDQKLS0tIGEvZnMvZWNyeXB0ZnMvbWFpbi5jCisrKyBiL2ZzL2VjcnlwdGZzL21haW4uYwpAQCAtMzUsNiArMzUsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2tleS5oPgogI2luY2x1ZGUgPGxpbnV4L3BhcnNlci5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzX3N0YWNrLmg+CisjaW5jbHVkZSA8bGludXgvaW1hLmg+CiAjaW5jbHVkZSAiZWNyeXB0ZnNfa2VybmVsLmgiCiAKIC8qKgpAQCAtMTE4LDYgKzExOSw3IEBACiAJY29uc3Qgc3RydWN0IGNyZWQgKmNyZWQgPSBjdXJyZW50X2NyZWQoKTsKIAlzdHJ1Y3QgZWNyeXB0ZnNfaW5vZGVfaW5mbyAqaW5vZGVfaW5mbyA9CiAJCWVjcnlwdGZzX2lub2RlX3RvX3ByaXZhdGUoZWNyeXB0ZnNfZGVudHJ5LT5kX2lub2RlKTsKKwlpbnQgb3BlbmVkX2xvd2VyX2ZpbGUgPSAwOwogCWludCByYyA9IDA7CiAKIAltdXRleF9sb2NrKCZpbm9kZV9pbmZvLT5sb3dlcl9maWxlX211dGV4KTsKQEAgLTEzNCw5ICsxMzYsMTIgQEAKIAkJCSAgICAgICAiZm9yIGxvd2VyX2RlbnRyeSBbMHglcF0gYW5kIGxvd2VyX21udCBbMHglcF07ICIKIAkJCSAgICAgICAicmMgPSBbJWRdXG4iLCBsb3dlcl9kZW50cnksIGxvd2VyX21udCwgcmMpOwogCQkJaW5vZGVfaW5mby0+bG93ZXJfZmlsZSA9IE5VTEw7Ci0JCX0KKwkJfSBlbHNlCisJCQlvcGVuZWRfbG93ZXJfZmlsZSA9IDE7CiAJfQogCW11dGV4X3VubG9jaygmaW5vZGVfaW5mby0+bG93ZXJfZmlsZV9tdXRleCk7CisJaWYgKG9wZW5lZF9sb3dlcl9maWxlKQorCQlpbWFfY291bnRzX2dldChpbm9kZV9pbmZvLT5sb3dlcl9maWxlKTsKIAlyZXR1cm4gcmM7CiB9CiAKZGlmZiAtLWdpdCBhL2ZzL2V4dDMvc3VwZXIuYyBiL2ZzL2V4dDMvc3VwZXIuYwppbmRleCA3Mjc0M2QzLi43YTUyMGE4IDEwMDY0NAotLS0gYS9mcy9leHQzL3N1cGVyLmMKKysrIGIvZnMvZXh0My9zdXBlci5jCkBAIC0yMzIxLDcgKzIzMjEsMTggQEAKIAogCWlmICghc2JoKQogCQlyZXR1cm4gZXJyb3I7Ci0JZXMtPnNfd3RpbWUgPSBjcHVfdG9fbGUzMihnZXRfc2Vjb25kcygpKTsKKwkvKgorCSAqIElmIHRoZSBmaWxlIHN5c3RlbSBpcyBtb3VudGVkIHJlYWQtb25seSwgZG9uJ3QgdXBkYXRlIHRoZQorCSAqIHN1cGVyYmxvY2sgd3JpdGUgdGltZS4gIFRoaXMgYXZvaWRzIHVwZGF0aW5nIHRoZSBzdXBlcmJsb2NrCisJICogd3JpdGUgdGltZSB3aGVuIHdlIGFyZSBtb3VudGluZyB0aGUgcm9vdCBmaWxlIHN5c3RlbQorCSAqIHJlYWQvb25seSBidXQgd2UgbmVlZCB0byByZXBsYXkgdGhlIGpvdXJuYWw7IGF0IHRoYXQgcG9pbnQsCisJICogZm9yIHBlb3BsZSB3aG8gYXJlIGVhc3Qgb2YgR01UIGFuZCB3aG8gbWFrZSB0aGVpciBjbG9jaworCSAqIHRpY2sgaW4gbG9jYWx0aW1lIGZvciBXaW5kb3dzIGJ1Zy1mb3ItYnVnIGNvbXBhdGliaWxpdHksCisJICogdGhlIGNsb2NrIGlzIHNldCBpbiB0aGUgZnV0dXJlLCBhbmQgdGhpcyB3aWxsIGNhdXNlIGUyZnNjaworCSAqIHRvIGNvbXBsYWluIGFuZCBmb3JjZSBhIGZ1bGwgZmlsZSBzeXN0ZW0gY2hlY2suCisJICovCisJaWYgKCEoc2ItPnNfZmxhZ3MgJiBNU19SRE9OTFkpKQorCQllcy0+c193dGltZSA9IGNwdV90b19sZTMyKGdldF9zZWNvbmRzKCkpOwogCWVzLT5zX2ZyZWVfYmxvY2tzX2NvdW50ID0gY3B1X3RvX2xlMzIoZXh0M19jb3VudF9mcmVlX2Jsb2NrcyhzYikpOwogCWVzLT5zX2ZyZWVfaW5vZGVzX2NvdW50ID0gY3B1X3RvX2xlMzIoZXh0M19jb3VudF9mcmVlX2lub2RlcyhzYikpOwogCUJVRkZFUl9UUkFDRShzYmgsICJtYXJraW5nIGRpcnR5Iik7CmRpZmYgLS1naXQgYS9mcy9maWxlLmMgYi9mcy9maWxlLmMKaW5kZXggZjMxMzMxNC4uODdlMTI5MCAxMDA2NDQKLS0tIGEvZnMvZmlsZS5jCisrKyBiL2ZzL2ZpbGUuYwpAQCAtMTAsNiArMTAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC90aW1lLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvdm1hbGxvYy5oPgogI2luY2x1ZGUgPGxpbnV4L2ZpbGUuaD4KZGlmZiAtLWdpdCBhL2ZzL2hmcy9idHJlZS5jIGIvZnMvaGZzL2J0cmVlLmMKaW5kZXggOWI5ZDYzOS4uMDUyZjIxNCAxMDA2NDQKLS0tIGEvZnMvaGZzL2J0cmVlLmMKKysrIGIvZnMvaGZzL2J0cmVlLmMKQEAgLTU4LDYgKzU4LDExIEBACiAJfQogCXVubG9ja19uZXdfaW5vZGUodHJlZS0+aW5vZGUpOwogCisJaWYgKCFIRlNfSSh0cmVlLT5pbm9kZSktPmZpcnN0X2Jsb2NrcykgeworCQlwcmludGsoS0VSTl9FUlIgImhmczogaW52YWxpZCBidHJlZSBleHRlbnQgcmVjb3JkcyAoMCBzaXplKS5cbiIpOworCQlnb3RvIGZyZWVfaW5vZGU7CisJfQorCiAJbWFwcGluZyA9IHRyZWUtPmlub2RlLT5pX21hcHBpbmc7CiAJcGFnZSA9IHJlYWRfbWFwcGluZ19wYWdlKG1hcHBpbmcsIDAsIE5VTEwpOwogCWlmIChJU19FUlIocGFnZSkpCmRpZmYgLS1naXQgYS9mcy9oZnNwbHVzL3dyYXBwZXIuYyBiL2ZzL2hmc3BsdXMvd3JhcHBlci5jCmluZGV4IDE3NWQwOGUuLmJlZDc4YWM4IDEwMDY0NAotLS0gYS9mcy9oZnNwbHVzL3dyYXBwZXIuYworKysgYi9mcy9oZnNwbHVzL3dyYXBwZXIuYwpAQCAtOTksNiArOTksMTAgQEAKIAogCWlmIChoZnNwbHVzX2dldF9sYXN0X3Nlc3Npb24oc2IsICZwYXJ0X3N0YXJ0LCAmcGFydF9zaXplKSkKIAkJcmV0dXJuIC1FSU5WQUw7CisJaWYgKCh1NjQpcGFydF9zdGFydCArIHBhcnRfc2l6ZSA+IDB4MTAwMDAwMDAwVUxMKSB7CisJCXByX2VycigiaGZzOiB2b2x1bWVzIGxhcmdlciB0aGFuIDJUQiBhcmUgbm90IHN1cHBvcnRlZCB5ZXRcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CiAJd2hpbGUgKDEpIHsKIAkJYmggPSBzYl9icmVhZDUxMihzYiwgcGFydF9zdGFydCArIEhGU1BMVVNfVk9MSEVBRF9TRUNUT1IsIHZoZHIpOwogCQlpZiAoIWJoKQpkaWZmIC0tZ2l0IGEvZnMvbmZzL2NsaWVudC5jIGIvZnMvbmZzL2NsaWVudC5jCmluZGV4IDYzOTc2YzAuLjk5ZWExOTYgMTAwNjQ0Ci0tLSBhL2ZzL25mcy9jbGllbnQuYworKysgYi9mcy9uZnMvY2xpZW50LmMKQEAgLTExODAsNyArMTE4MCw3IEBACiAJCQkJICAgICAgMSwgZmxhZ3MgJiBORlNfTU9VTlRfTk9SRVNWUE9SVCk7CiAJaWYgKGVycm9yIDwgMCkKIAkJZ290byBlcnJvcjsKLQltZW1jcHkoY2xwLT5jbF9pcGFkZHIsIGlwX2FkZHIsIHNpemVvZihjbHAtPmNsX2lwYWRkcikpOworCXN0cmxjcHkoY2xwLT5jbF9pcGFkZHIsIGlwX2FkZHIsIHNpemVvZihjbHAtPmNsX2lwYWRkcikpOwogCiAJZXJyb3IgPSBuZnNfaWRtYXBfbmV3KGNscCk7CiAJaWYgKGVycm9yIDwgMCkgewpkaWZmIC0tZ2l0IGEvZnMvbmZzL25mczRuYW1lc3BhY2UuYyBiL2ZzL25mcy9uZnM0bmFtZXNwYWNlLmMKaW5kZXggMjYzNmMyNi4uZmEzNDA4ZiAxMDA2NDQKLS0tIGEvZnMvbmZzL25mczRuYW1lc3BhY2UuYworKysgYi9mcy9uZnMvbmZzNG5hbWVzcGFjZS5jCkBAIC0xMjEsNyArMTIxLDcgQEAKIAogCW1udF9wYXRoID0gbmZzNF9wYXRobmFtZV9zdHJpbmcoJmxvY2F0aW9uLT5yb290cGF0aCwgcGFnZTIsIFBBR0VfU0laRSk7CiAJaWYgKElTX0VSUihtbnRfcGF0aCkpCi0JCXJldHVybiBtbnQ7CisJCXJldHVybiBFUlJfQ0FTVChtbnRfcGF0aCk7CiAJbW91bnRkYXRhLT5tbnRfcGF0aCA9IG1udF9wYXRoOwogCW1heGJ1ZmxlbiA9IG1udF9wYXRoIC0gMSAtIHBhZ2UyOwogCkBAIC0xMzIsMTUgKzEzMiwxNSBAQAogCQlpZiAoYnVmLT5sZW4gPD0gMCB8fCBidWYtPmxlbiA+PSBtYXhidWZsZW4pCiAJCQljb250aW51ZTsKIAotCQltb3VudGRhdGEtPmFkZHIgPSAoc3RydWN0IHNvY2thZGRyICopJmFkZHI7Ci0KIAkJaWYgKG1lbWNocihidWYtPmRhdGEsIElQVjZfU0NPUEVfREVMSU1JVEVSLCBidWYtPmxlbikpCiAJCQljb250aW51ZTsKLQkJbW91bnRkYXRhLT5hZGRybGVuID0gbmZzX3BhcnNlX3NlcnZlcl9uYW1lKGJ1Zi0+ZGF0YSwKLQkJCQlidWYtPmxlbiwKLQkJCQltb3VudGRhdGEtPmFkZHIsIG1vdW50ZGF0YS0+YWRkcmxlbik7CisKKwkJbW91bnRkYXRhLT5hZGRybGVuID0gbmZzX3BhcnNlX3NlcnZlcl9uYW1lKGJ1Zi0+ZGF0YSwgYnVmLT5sZW4sCisJCQkJKHN0cnVjdCBzb2NrYWRkciAqKSZhZGRyLCBzaXplb2YoYWRkcikpOwogCQlpZiAobW91bnRkYXRhLT5hZGRybGVuID09IDApCiAJCQljb250aW51ZTsKKworCQltb3VudGRhdGEtPmFkZHIgPSAoc3RydWN0IHNvY2thZGRyICopJmFkZHI7CiAJCXJwY19zZXRfcG9ydChtb3VudGRhdGEtPmFkZHIsIE5GU19QT1JUKTsKIAogCQltZW1jcHkocGFnZTIsIGJ1Zi0+ZGF0YSwgYnVmLT5sZW4pOwpkaWZmIC0tZ2l0IGEvZnMvbmZzL25mczRyZW5ld2QuYyBiL2ZzL25mcy9uZnM0cmVuZXdkLmMKaW5kZXggZTI3YzZjZS4uMDE1NmMwMSAxMDA2NDQKLS0tIGEvZnMvbmZzL25mczRyZW5ld2QuYworKysgYi9mcy9uZnMvbmZzNHJlbmV3ZC5jCkBAIC0xMjcsMTIgKzEyNyw2IEBACiB9CiAKIHZvaWQKLW5mczRfcmVuZXdkX3ByZXBhcmVfc2h1dGRvd24oc3RydWN0IG5mc19zZXJ2ZXIgKnNlcnZlcikKLXsKLQljYW5jZWxfZGVsYXllZF93b3JrKCZzZXJ2ZXItPm5mc19jbGllbnQtPmNsX3JlbmV3ZCk7Ci19Ci0KLXZvaWQKIG5mczRfa2lsbF9yZW5ld2Qoc3RydWN0IG5mc19jbGllbnQgKmNscCkKIHsKIAljYW5jZWxfZGVsYXllZF93b3JrX3N5bmMoJmNscC0+Y2xfcmVuZXdkKTsKZGlmZiAtLWdpdCBhL2ZzL25mcy9zdXBlci5jIGIvZnMvbmZzL3N1cGVyLmMKaW5kZXggMjk3ODZkMy4uOTBiZTU1MSAxMDA2NDQKLS0tIGEvZnMvbmZzL3N1cGVyLmMKKysrIGIvZnMvbmZzL3N1cGVyLmMKQEAgLTcyOCwyMiArNzI4LDI0IEBACiAJdW5sb2NrX2tlcm5lbCgpOwogfQogCi1zdGF0aWMgc3RydWN0IG5mc19wYXJzZWRfbW91bnRfZGF0YSAqbmZzX2FsbG9jX3BhcnNlZF9tb3VudF9kYXRhKGludCBmbGFncykKK3N0YXRpYyBzdHJ1Y3QgbmZzX3BhcnNlZF9tb3VudF9kYXRhICpuZnNfYWxsb2NfcGFyc2VkX21vdW50X2RhdGEodW5zaWduZWQgaW50IHZlcnNpb24pCiB7CiAJc3RydWN0IG5mc19wYXJzZWRfbW91bnRfZGF0YSAqZGF0YTsKIAogCWRhdGEgPSBremFsbG9jKHNpemVvZigqZGF0YSksIEdGUF9LRVJORUwpOwogCWlmIChkYXRhKSB7Ci0JCWRhdGEtPmZsYWdzCQk9IGZsYWdzOwogCQlkYXRhLT5yc2l6ZQkJPSBORlNfTUFYX0ZJTEVfSU9fU0laRTsKIAkJZGF0YS0+d3NpemUJCT0gTkZTX01BWF9GSUxFX0lPX1NJWkU7CiAJCWRhdGEtPmFjcmVnbWluCQk9IE5GU19ERUZfQUNSRUdNSU47CiAJCWRhdGEtPmFjcmVnbWF4CQk9IE5GU19ERUZfQUNSRUdNQVg7CiAJCWRhdGEtPmFjZGlybWluCQk9IE5GU19ERUZfQUNESVJNSU47CiAJCWRhdGEtPmFjZGlybWF4CQk9IE5GU19ERUZfQUNESVJNQVg7CisJCWRhdGEtPm1vdW50X3NlcnZlci5wb3J0CT0gTkZTX1VOU1BFQ19QT1JUOwogCQlkYXRhLT5uZnNfc2VydmVyLnBvcnQJPSBORlNfVU5TUEVDX1BPUlQ7CisJCWRhdGEtPm5mc19zZXJ2ZXIucHJvdG9jb2wgPSBYUFJUX1RSQU5TUE9SVF9UQ1A7CiAJCWRhdGEtPmF1dGhfZmxhdm9yc1swXQk9IFJQQ19BVVRIX1VOSVg7CiAJCWRhdGEtPmF1dGhfZmxhdm9yX2xlbgk9IDE7CisJCWRhdGEtPnZlcnNpb24JCT0gdmVyc2lvbjsKIAkJZGF0YS0+bWlub3J2ZXJzaW9uCT0gMDsKIAl9CiAJcmV0dXJuIGRhdGE7CkBAIC03NzYsMTUgKzc3OCwxMyBAQAogICogU2VsZWN0IGJldHdlZW4gYSBkZWZhdWx0IHBvcnQgdmFsdWUgYW5kIGEgdXNlci1zcGVjaWZpZWQgcG9ydCB2YWx1ZS4KICAqIElmIGEgemVybyB2YWx1ZSBpcyBzZXQsIHRoZW4gYXV0b2JpbmQgd2lsbCBiZSB1c2VkLgogICovCi1zdGF0aWMgdm9pZCBuZnNfc2V0X2RlZmF1bHRfcG9ydChzdHJ1Y3Qgc29ja2FkZHIgKnNhcCwgY29uc3QgaW50IHBhcnNlZF9wb3J0LAorc3RhdGljIHZvaWQgbmZzX3NldF9wb3J0KHN0cnVjdCBzb2NrYWRkciAqc2FwLCBpbnQgKnBvcnQsCiAJCQkJIGNvbnN0IHVuc2lnbmVkIHNob3J0IGRlZmF1bHRfcG9ydCkKIHsKLQl1bnNpZ25lZCBzaG9ydCBwb3J0ID0gZGVmYXVsdF9wb3J0OworCWlmICgqcG9ydCA9PSBORlNfVU5TUEVDX1BPUlQpCisJCSpwb3J0ID0gZGVmYXVsdF9wb3J0OwogCi0JaWYgKHBhcnNlZF9wb3J0ICE9IE5GU19VTlNQRUNfUE9SVCkKLQkJcG9ydCA9IHBhcnNlZF9wb3J0OwotCi0JcnBjX3NldF9wb3J0KHNhcCwgcG9ydCk7CisJcnBjX3NldF9wb3J0KHNhcCwgKnBvcnQpOwogfQogCiAvKgpAQCAtMTI1Myw2ICsxMjUzLDcgQEAKIAkJCWRlZmF1bHQ6CiAJCQkJZGZwcmludGsoTU9VTlQsICJORlM6ICAgdW5yZWNvZ25pemVkICIKIAkJCQkJCSJ0cmFuc3BvcnQgcHJvdG9jb2xcbiIpOworCQkJCWtmcmVlKHN0cmluZyk7CiAJCQkJcmV0dXJuIDA7CiAJCQl9CiAJCQlicmVhazsKQEAgLTE0NzUsNyArMTQ3Niw3IEBACiAJCWFyZ3MtPm1vdW50X3NlcnZlci5hZGRybGVuID0gYXJncy0+bmZzX3NlcnZlci5hZGRybGVuOwogCX0KIAlyZXF1ZXN0LnNhbGVuID0gYXJncy0+bW91bnRfc2VydmVyLmFkZHJsZW47Ci0JbmZzX3NldF9kZWZhdWx0X3BvcnQocmVxdWVzdC5zYXAsIGFyZ3MtPm1vdW50X3NlcnZlci5wb3J0LCAwKTsKKwluZnNfc2V0X3BvcnQocmVxdWVzdC5zYXAsICZhcmdzLT5tb3VudF9zZXJ2ZXIucG9ydCwgMCk7CiAKIAkvKgogCSAqIE5vdyBhc2sgdGhlIG1vdW50IHNlcnZlciB0byBtYXAgb3VyIGV4cG9ydCBwYXRoCkBAIC0xNzExLDggKzE3MTIsNiBAQAogCiAJCWlmICghKGRhdGEtPmZsYWdzICYgTkZTX01PVU5UX1RDUCkpCiAJCQlhcmdzLT5uZnNfc2VydmVyLnByb3RvY29sID0gWFBSVF9UUkFOU1BPUlRfVURQOwotCQllbHNlCi0JCQlhcmdzLT5uZnNfc2VydmVyLnByb3RvY29sID0gWFBSVF9UUkFOU1BPUlRfVENQOwogCQkvKiBOLkIuIGNhbGxlciB3aWxsIGZyZWUgbmZzX3NlcnZlci5ob3N0bmFtZSBpbiBhbGwgY2FzZXMgKi8KIAkJYXJncy0+bmZzX3NlcnZlci5ob3N0bmFtZSA9IGtzdHJkdXAoZGF0YS0+aG9zdG5hbWUsIEdGUF9LRVJORUwpOwogCQlhcmdzLT5uYW1sZW4JCT0gZGF0YS0+bmFtbGVuOwpAQCAtMTc2Nyw3ICsxNzY2LDcgQEAKIAkJCWdvdG8gb3V0X3Y0X25vdF9jb21waWxlZDsKICNlbmRpZgogCi0JCW5mc19zZXRfZGVmYXVsdF9wb3J0KHNhcCwgYXJncy0+bmZzX3NlcnZlci5wb3J0LCAwKTsKKwkJbmZzX3NldF9wb3J0KHNhcCwgJmFyZ3MtPm5mc19zZXJ2ZXIucG9ydCwgMCk7CiAKIAkJbmZzX3NldF9tb3VudF90cmFuc3BvcnRfcHJvdG9jb2woYXJncyk7CiAKQEAgLTE4NDgsOSArMTg0NywxMCBAQAogCSAgICBkYXRhLT5hY2Rpcm1pbiAhPSBuZnNzLT5hY2Rpcm1pbiAvIEhaIHx8CiAJICAgIGRhdGEtPmFjZGlybWF4ICE9IG5mc3MtPmFjZGlybWF4IC8gSFogfHwKIAkgICAgZGF0YS0+dGltZW8gIT0gKDEwVSAqIG5mc3MtPmNsaWVudC0+Y2xfdGltZW91dC0+dG9faW5pdHZhbCAvIEhaKSB8fAorCSAgICBkYXRhLT5uZnNfc2VydmVyLnBvcnQgIT0gbmZzcy0+cG9ydCB8fAogCSAgICBkYXRhLT5uZnNfc2VydmVyLmFkZHJsZW4gIT0gbmZzcy0+bmZzX2NsaWVudC0+Y2xfYWRkcmxlbiB8fAotCSAgICBtZW1jbXAoJmRhdGEtPm5mc19zZXJ2ZXIuYWRkcmVzcywgJm5mc3MtPm5mc19jbGllbnQtPmNsX2FkZHIsCi0JCSAgIGRhdGEtPm5mc19zZXJ2ZXIuYWRkcmxlbikgIT0gMCkKKwkgICAgIXJwY19jbXBfYWRkcigoc3RydWN0IHNvY2thZGRyICopJmRhdGEtPm5mc19zZXJ2ZXIuYWRkcmVzcywKKwkJCSAgKHN0cnVjdCBzb2NrYWRkciAqKSZuZnNzLT5uZnNfY2xpZW50LT5jbF9hZGRyKSkKIAkJcmV0dXJuIC1FSU5WQUw7CiAKIAlyZXR1cm4gMDsKQEAgLTE4OTMsNiArMTg5Myw3IEBACiAJZGF0YS0+YWNkaXJtaW4gPSBuZnNzLT5hY2Rpcm1pbiAvIEhaOwogCWRhdGEtPmFjZGlybWF4ID0gbmZzcy0+YWNkaXJtYXggLyBIWjsKIAlkYXRhLT50aW1lbyA9IDEwVSAqIG5mc3MtPmNsaWVudC0+Y2xfdGltZW91dC0+dG9faW5pdHZhbCAvIEhaOworCWRhdGEtPm5mc19zZXJ2ZXIucG9ydCA9IG5mc3MtPnBvcnQ7CiAJZGF0YS0+bmZzX3NlcnZlci5hZGRybGVuID0gbmZzcy0+bmZzX2NsaWVudC0+Y2xfYWRkcmxlbjsKIAltZW1jcHkoJmRhdGEtPm5mc19zZXJ2ZXIuYWRkcmVzcywgJm5mc3MtPm5mc19jbGllbnQtPmNsX2FkZHIsCiAJCWRhdGEtPm5mc19zZXJ2ZXIuYWRkcmxlbik7CkBAIC0yMTA2LDcgKzIxMDcsNyBAQAogCX07CiAJaW50IGVycm9yID0gLUVOT01FTTsKIAotCWRhdGEgPSBuZnNfYWxsb2NfcGFyc2VkX21vdW50X2RhdGEoTkZTX01PVU5UX1ZFUjMgfCBORlNfTU9VTlRfVENQKTsKKwlkYXRhID0gbmZzX2FsbG9jX3BhcnNlZF9tb3VudF9kYXRhKDMpOwogCW1udGZoID0ga3phbGxvYyhzaXplb2YoKm1udGZoKSwgR0ZQX0tFUk5FTCk7CiAJaWYgKGRhdGEgPT0gTlVMTCB8fCBtbnRmaCA9PSBOVUxMKQogCQlnb3RvIG91dF9mcmVlX2ZoOwpAQCAtMjMzMSw3ICsyMzMyLDcgQEAKIHsKIAlzdHJ1Y3Qgc29ja2FkZHIgKnNhcCA9IChzdHJ1Y3Qgc29ja2FkZHIgKikmYXJncy0+bmZzX3NlcnZlci5hZGRyZXNzOwogCi0JbmZzX3NldF9kZWZhdWx0X3BvcnQoc2FwLCBhcmdzLT5uZnNfc2VydmVyLnBvcnQsIE5GU19QT1JUKTsKKwluZnNfc2V0X3BvcnQoc2FwLCAmYXJncy0+bmZzX3NlcnZlci5wb3J0LCBORlNfUE9SVCk7CiAKIAluZnNfdmFsaWRhdGVfdHJhbnNwb3J0X3Byb3RvY29sKGFyZ3MpOwogCkBAIC0yMzc2LDcgKzIzNzcsNiBAQAogCWlmIChkYXRhID09IE5VTEwpCiAJCWdvdG8gb3V0X25vX2RhdGE7CiAKLQlhcmdzLT52ZXJzaW9uCQk9IDQ7CiAJc3dpdGNoIChkYXRhLT52ZXJzaW9uKSB7CiAJY2FzZSAxOgogCQlpZiAoZGF0YS0+aG9zdF9hZGRybGVuID4gc2l6ZW9mKGFyZ3MtPm5mc19zZXJ2ZXIuYWRkcmVzcykpCkBAIC0yNjYwLDcgKzI2NjAsNyBAQAogCXN0cnVjdCBuZnNfcGFyc2VkX21vdW50X2RhdGEgKmRhdGE7CiAJaW50IGVycm9yID0gLUVOT01FTTsKIAotCWRhdGEgPSBuZnNfYWxsb2NfcGFyc2VkX21vdW50X2RhdGEoMCk7CisJZGF0YSA9IG5mc19hbGxvY19wYXJzZWRfbW91bnRfZGF0YSg0KTsKIAlpZiAoZGF0YSA9PSBOVUxMKQogCQlnb3RvIG91dF9mcmVlX2RhdGE7CiAKQEAgLTI2OTAsNyArMjY5MCw2IEBACiAJZHByaW50aygiLS0+ICVzXG4iLCBfX2Z1bmNfXyk7CiAJbmZzX3N1cGVyX3JldHVybl9hbGxfZGVsZWdhdGlvbnMoc2IpOwogCWtpbGxfYW5vbl9zdXBlcihzYik7Ci0JbmZzNF9yZW5ld2RfcHJlcGFyZV9zaHV0ZG93bihzZXJ2ZXIpOwogCW5mc19mc2NhY2hlX3JlbGVhc2Vfc3VwZXJfY29va2llKHNiKTsKIAluZnNfZnJlZV9zZXJ2ZXIoc2VydmVyKTsKIAlkcHJpbnRrKCI8LS0gJXNcbiIsIF9fZnVuY19fKTsKZGlmZiAtLWdpdCBhL2ZzL25vdGlmeS9kbm90aWZ5L2Rub3RpZnkuYyBiL2ZzL25vdGlmeS9kbm90aWZ5L2Rub3RpZnkuYwppbmRleCA4MjhhODg5Li43ZTU0ZTUyIDEwMDY0NAotLS0gYS9mcy9ub3RpZnkvZG5vdGlmeS9kbm90aWZ5LmMKKysrIGIvZnMvbm90aWZ5L2Rub3RpZnkvZG5vdGlmeS5jCkBAIC05MSw2ICs5MSw3IEBACiAJc3RydWN0IGRub3RpZnlfc3RydWN0ICpkbjsKIAlzdHJ1Y3QgZG5vdGlmeV9zdHJ1Y3QgKipwcmV2OwogCXN0cnVjdCBmb3duX3N0cnVjdCAqZm93bjsKKwlfX3UzMiB0ZXN0X21hc2sgPSBldmVudC0+bWFzayAmIH5GU19FVkVOVF9PTl9DSElMRDsKIAogCXRvX3RlbGwgPSBldmVudC0+dG9fdGVsbDsKIApAQCAtMTA2LDcgKzEwNyw3IEBACiAJc3Bpbl9sb2NrKCZlbnRyeS0+bG9jayk7CiAJcHJldiA9ICZkbmVudHJ5LT5kbjsKIAl3aGlsZSAoKGRuID0gKnByZXYpICE9IE5VTEwpIHsKLQkJaWYgKChkbi0+ZG5fbWFzayAmIGV2ZW50LT5tYXNrKSA9PSAwKSB7CisJCWlmICgoZG4tPmRuX21hc2sgJiB0ZXN0X21hc2spID09IDApIHsKIAkJCXByZXYgPSAmZG4tPmRuX25leHQ7CiAJCQljb250aW51ZTsKIAkJfQpkaWZmIC0tZ2l0IGEvZnMvbm90aWZ5L2lub2RlX21hcmsuYyBiL2ZzL25vdGlmeS9pbm9kZV9tYXJrLmMKaW5kZXggYzhhMDdjNi4uMzE2NWQ4NSAxMDA2NDQKLS0tIGEvZnMvbm90aWZ5L2lub2RlX21hcmsuYworKysgYi9mcy9ub3RpZnkvaW5vZGVfbWFyay5jCkBAIC0zMjQsMTEgKzMyNCwxMSBAQAogCXNwaW5fbG9jaygmZ3JvdXAtPm1hcmtfbG9jayk7CiAJc3Bpbl9sb2NrKCZpbm9kZS0+aV9sb2NrKTsKIAotCWVudHJ5LT5ncm91cCA9IGdyb3VwOwotCWVudHJ5LT5pbm9kZSA9IGlub2RlOwotCiAJbGVudHJ5ID0gZnNub3RpZnlfZmluZF9tYXJrX2VudHJ5KGdyb3VwLCBpbm9kZSk7CiAJaWYgKCFsZW50cnkpIHsKKwkJZW50cnktPmdyb3VwID0gZ3JvdXA7CisJCWVudHJ5LT5pbm9kZSA9IGlub2RlOworCiAJCWhsaXN0X2FkZF9oZWFkKCZlbnRyeS0+aV9saXN0LCAmaW5vZGUtPmlfZnNub3RpZnlfbWFya19lbnRyaWVzKTsKIAkJbGlzdF9hZGQoJmVudHJ5LT5nX2xpc3QsICZncm91cC0+bWFya19lbnRyaWVzKTsKIApkaWZmIC0tZ2l0IGEvZnMvbm90aWZ5L25vdGlmaWNhdGlvbi5jIGIvZnMvbm90aWZ5L25vdGlmaWNhdGlvbi5jCmluZGV4IDM4MTZkNTcuLmI4YmY1M2IgMTAwNjQ0Ci0tLSBhL2ZzL25vdGlmeS9ub3RpZmljYXRpb24uYworKysgYi9mcy9ub3RpZnkvbm90aWZpY2F0aW9uLmMKQEAgLTE0Myw3ICsxNDMsNyBAQAogCQkJLyogcmVtZW1iZXIsIGFmdGVyIG9sZCB3YXMgcHV0IG9uIHRoZSB3YWl0X3Egd2UgYXJlbid0CiAJCQkgKiBhbGxvd2VkIHRvIGxvb2sgYXQgdGhlIGlub2RlIGFueSBtb3JlLCBvbmx5IHRoaW5nCiAJCQkgKiBsZWZ0IHRvIGNoZWNrIHdhcyBpZiB0aGUgZmlsZV9uYW1lIGlzIHRoZSBzYW1lICovCi0JCQlpZiAob2xkLT5uYW1lX2xlbiAmJgorCQkJaWYgKCFvbGQtPm5hbWVfbGVuIHx8CiAJCQkgICAgIXN0cmNtcChvbGQtPmZpbGVfbmFtZSwgbmV3LT5maWxlX25hbWUpKQogCQkJCXJldHVybiB0cnVlOwogCQkJYnJlYWs7CmRpZmYgLS1naXQgYS9mcy9wYXJ0aXRpb25zL2NoZWNrLmMgYi9mcy9wYXJ0aXRpb25zL2NoZWNrLmMKaW5kZXggZjM4ZmVlMC4uN2I2ODVlMSAxMDA2NDQKLS0tIGEvZnMvcGFydGl0aW9ucy9jaGVjay5jCisrKyBiL2ZzL3BhcnRpdGlvbnMvY2hlY2suYwpAQCAtMjQ4LDExICsyNDgsMTkgQEAKIAkJcGFydF9zdGF0X3JlYWQocCwgbWVyZ2VzW1dSSVRFXSksCiAJCSh1bnNpZ25lZCBsb25nIGxvbmcpcGFydF9zdGF0X3JlYWQocCwgc2VjdG9yc1tXUklURV0pLAogCQlqaWZmaWVzX3RvX21zZWNzKHBhcnRfc3RhdF9yZWFkKHAsIHRpY2tzW1dSSVRFXSkpLAotCQlwLT5pbl9mbGlnaHQsCisJCXBhcnRfaW5fZmxpZ2h0KHApLAogCQlqaWZmaWVzX3RvX21zZWNzKHBhcnRfc3RhdF9yZWFkKHAsIGlvX3RpY2tzKSksCiAJCWppZmZpZXNfdG9fbXNlY3MocGFydF9zdGF0X3JlYWQocCwgdGltZV9pbl9xdWV1ZSkpKTsKIH0KIAorc3NpemVfdCBwYXJ0X2luZmxpZ2h0X3Nob3coc3RydWN0IGRldmljZSAqZGV2LAorCQkJc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgaGRfc3RydWN0ICpwID0gZGV2X3RvX3BhcnQoZGV2KTsKKworCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiU4dSAlOHVcbiIsIHAtPmluX2ZsaWdodFswXSwgcC0+aW5fZmxpZ2h0WzFdKTsKK30KKwogI2lmZGVmIENPTkZJR19GQUlMX01BS0VfUkVRVUVTVAogc3NpemVfdCBwYXJ0X2ZhaWxfc2hvdyhzdHJ1Y3QgZGV2aWNlICpkZXYsCiAJCSAgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKQpAQCAtMjgxLDYgKzI4OSw3IEBACiBzdGF0aWMgREVWSUNFX0FUVFIoc2l6ZSwgU19JUlVHTywgcGFydF9zaXplX3Nob3csIE5VTEwpOwogc3RhdGljIERFVklDRV9BVFRSKGFsaWdubWVudF9vZmZzZXQsIFNfSVJVR08sIHBhcnRfYWxpZ25tZW50X29mZnNldF9zaG93LCBOVUxMKTsKIHN0YXRpYyBERVZJQ0VfQVRUUihzdGF0LCBTX0lSVUdPLCBwYXJ0X3N0YXRfc2hvdywgTlVMTCk7CitzdGF0aWMgREVWSUNFX0FUVFIoaW5mbGlnaHQsIFNfSVJVR08sIHBhcnRfaW5mbGlnaHRfc2hvdywgTlVMTCk7CiAjaWZkZWYgQ09ORklHX0ZBSUxfTUFLRV9SRVFVRVNUCiBzdGF0aWMgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgZGV2X2F0dHJfZmFpbCA9CiAJX19BVFRSKG1ha2UtaXQtZmFpbCwgU19JUlVHT3xTX0lXVVNSLCBwYXJ0X2ZhaWxfc2hvdywgcGFydF9mYWlsX3N0b3JlKTsKQEAgLTI5Miw2ICszMDEsNyBAQAogCSZkZXZfYXR0cl9zaXplLmF0dHIsCiAJJmRldl9hdHRyX2FsaWdubWVudF9vZmZzZXQuYXR0ciwKIAkmZGV2X2F0dHJfc3RhdC5hdHRyLAorCSZkZXZfYXR0cl9pbmZsaWdodC5hdHRyLAogI2lmZGVmIENPTkZJR19GQUlMX01BS0VfUkVRVUVTVAogCSZkZXZfYXR0cl9mYWlsLmF0dHIsCiAjZW5kaWYKZGlmZiAtLWdpdCBhL2ZzL3BpcGUuYyBiL2ZzL3BpcGUuYwppbmRleCA1MmM0MTUxLi5hZTE3ZDAyIDEwMDY0NAotLS0gYS9mcy9waXBlLmMKKysrIGIvZnMvcGlwZS5jCkBAIC03NzcsMzYgKzc3Nyw1NSBAQAogc3RhdGljIGludAogcGlwZV9yZWFkX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbHApCiB7Ci0JLyogV2UgY291bGQgaGF2ZSBwZXJoYXBzIHVzZWQgYXRvbWljX3QsIGJ1dCB0aGlzIGFuZCBmcmllbmRzCi0JICAgYmVsb3cgYXJlIHRoZSBvbmx5IHBsYWNlcy4gIFNvIGl0IGRvZXNuJ3Qgc2VlbSB3b3J0aHdoaWxlLiAgKi8KKwlpbnQgcmV0ID0gLUVOT0VOVDsKKwogCW11dGV4X2xvY2soJmlub2RlLT5pX211dGV4KTsKLQlpbm9kZS0+aV9waXBlLT5yZWFkZXJzKys7CisKKwlpZiAoaW5vZGUtPmlfcGlwZSkgeworCQlyZXQgPSAwOworCQlpbm9kZS0+aV9waXBlLT5yZWFkZXJzKys7CisJfQorCiAJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7CiAKLQlyZXR1cm4gMDsKKwlyZXR1cm4gcmV0OwogfQogCiBzdGF0aWMgaW50CiBwaXBlX3dyaXRlX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbHApCiB7CisJaW50IHJldCA9IC1FTk9FTlQ7CisKIAltdXRleF9sb2NrKCZpbm9kZS0+aV9tdXRleCk7Ci0JaW5vZGUtPmlfcGlwZS0+d3JpdGVycysrOworCisJaWYgKGlub2RlLT5pX3BpcGUpIHsKKwkJcmV0ID0gMDsKKwkJaW5vZGUtPmlfcGlwZS0+d3JpdGVycysrOworCX0KKwogCW11dGV4X3VubG9jaygmaW5vZGUtPmlfbXV0ZXgpOwogCi0JcmV0dXJuIDA7CisJcmV0dXJuIHJldDsKIH0KIAogc3RhdGljIGludAogcGlwZV9yZHdyX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbHApCiB7CisJaW50IHJldCA9IC1FTk9FTlQ7CisKIAltdXRleF9sb2NrKCZpbm9kZS0+aV9tdXRleCk7Ci0JaWYgKGZpbHAtPmZfbW9kZSAmIEZNT0RFX1JFQUQpCi0JCWlub2RlLT5pX3BpcGUtPnJlYWRlcnMrKzsKLQlpZiAoZmlscC0+Zl9tb2RlICYgRk1PREVfV1JJVEUpCi0JCWlub2RlLT5pX3BpcGUtPndyaXRlcnMrKzsKKworCWlmIChpbm9kZS0+aV9waXBlKSB7CisJCXJldCA9IDA7CisJCWlmIChmaWxwLT5mX21vZGUgJiBGTU9ERV9SRUFEKQorCQkJaW5vZGUtPmlfcGlwZS0+cmVhZGVycysrOworCQlpZiAoZmlscC0+Zl9tb2RlICYgRk1PREVfV1JJVEUpCisJCQlpbm9kZS0+aV9waXBlLT53cml0ZXJzKys7CisJfQorCiAJbXV0ZXhfdW5sb2NrKCZpbm9kZS0+aV9tdXRleCk7CiAKLQlyZXR1cm4gMDsKKwlyZXR1cm4gcmV0OwogfQogCiAvKgpkaWZmIC0tZ2l0IGEvZnMvcHJvYy9tZW1pbmZvLmMgYi9mcy9wcm9jL21lbWluZm8uYwppbmRleCBjN2JmZjRmLi5hNjUyMzljIDEwMDY0NAotLS0gYS9mcy9wcm9jL21lbWluZm8uYworKysgYi9mcy9wcm9jL21lbWluZm8uYwpAQCAtOTksNyArOTksNyBAQAogCQkiVm1hbGxvY1VzZWQ6ICAgICU4bHUga0JcbiIKIAkJIlZtYWxsb2NDaHVuazogICAlOGx1IGtCXG4iCiAjaWZkZWYgQ09ORklHX01FTU9SWV9GQUlMVVJFCi0JCSJIYXJkd2FyZUNvcnJ1cHRlZDogJThsdSBrQlxuIgorCQkiSGFyZHdhcmVDb3JydXB0ZWQ6ICU1bHUga0JcbiIKICNlbmRpZgogCQksCiAJCUsoaS50b3RhbHJhbSksCmRpZmYgLS1naXQgYS9mcy9yb21mcy9zdG9yYWdlLmMgYi9mcy9yb21mcy9zdG9yYWdlLmMKaW5kZXggYjMyMDhhZC4uNzFlMmI0ZCAxMDA2NDQKLS0tIGEvZnMvcm9tZnMvc3RvcmFnZS5jCisrKyBiL2ZzL3JvbWZzL3N0b3JhZ2UuYwpAQCAtMjUzLDExICsyNTMsMTEgQEAKIAogI2lmZGVmIENPTkZJR19ST01GU19PTl9NVEQKIAlpZiAoc2ItPnNfbXRkKQotCQlyZXR1cm4gcm9tZnNfbXRkX3N0cm5sZW4oc2IsIHBvcywgbGltaXQpOworCQlyZXR1cm4gcm9tZnNfbXRkX3N0cm5sZW4oc2IsIHBvcywgbWF4bGVuKTsKICNlbmRpZgogI2lmZGVmIENPTkZJR19ST01GU19PTl9CTE9DSwogCWlmIChzYi0+c19iZGV2KQotCQlyZXR1cm4gcm9tZnNfYmxrX3N0cm5sZW4oc2IsIHBvcywgbGltaXQpOworCQlyZXR1cm4gcm9tZnNfYmxrX3N0cm5sZW4oc2IsIHBvcywgbWF4bGVuKTsKICNlbmRpZgogCXJldHVybiAtRUlPOwogfQpkaWZmIC0tZ2l0IGEvZnMvc3lzZnMvZGlyLmMgYi9mcy9zeXNmcy9kaXIuYwppbmRleCAwMDUwZmM0Li41ZmFkNDg5IDEwMDY0NAotLS0gYS9mcy9zeXNmcy9kaXIuYworKysgYi9mcy9zeXNmcy9kaXIuYwpAQCAtODk0LDcgKzg5NCw4IEBACiAKIAltdXRleF9sb2NrKCZzeXNmc19yZW5hbWVfbXV0ZXgpOwogCUJVR19PTighc2QtPnNfcGFyZW50KTsKLQluZXdfcGFyZW50X3NkID0gbmV3X3BhcmVudF9rb2JqLT5zZCA/IG5ld19wYXJlbnRfa29iai0+c2QgOiAmc3lzZnNfcm9vdDsKKwluZXdfcGFyZW50X3NkID0gKG5ld19wYXJlbnRfa29iaiAmJiBuZXdfcGFyZW50X2tvYmotPnNkKSA/CisJCW5ld19wYXJlbnRfa29iai0+c2QgOiAmc3lzZnNfcm9vdDsKIAogCWVycm9yID0gMDsKIAlpZiAoc2QtPnNfcGFyZW50ID09IG5ld19wYXJlbnRfc2QpCmRpZmYgLS1naXQgYS9mcy9zeXNmcy9maWxlLmMgYi9mcy9zeXNmcy9maWxlLmMKaW5kZXggNTYxYTljMC4uZjVlYTQ2OCAxMDA2NDQKLS0tIGEvZnMvc3lzZnMvZmlsZS5jCisrKyBiL2ZzL3N5c2ZzL2ZpbGUuYwpAQCAtMjY4LDcgKzI2OCw3IEBACiAJc3RydWN0IHN5c2ZzX29wZW5fZGlyZW50ICpvZCwgKm5ld19vZCA9IE5VTEw7CiAKICByZXRyeToKLQlzcGluX2xvY2soJnN5c2ZzX29wZW5fZGlyZW50X2xvY2spOworCXNwaW5fbG9ja19pcnEoJnN5c2ZzX29wZW5fZGlyZW50X2xvY2spOwogCiAJaWYgKCFzZC0+c19hdHRyLm9wZW4gJiYgbmV3X29kKSB7CiAJCXNkLT5zX2F0dHIub3BlbiA9IG5ld19vZDsKQEAgLTI4MSw3ICsyODEsNyBAQAogCQlsaXN0X2FkZF90YWlsKCZidWZmZXItPmxpc3QsICZvZC0+YnVmZmVycyk7CiAJfQogCi0Jc3Bpbl91bmxvY2soJnN5c2ZzX29wZW5fZGlyZW50X2xvY2spOworCXNwaW5fdW5sb2NrX2lycSgmc3lzZnNfb3Blbl9kaXJlbnRfbG9jayk7CiAKIAlpZiAob2QpIHsKIAkJa2ZyZWUobmV3X29kKTsKQEAgLTMxNSw4ICszMTUsOSBAQAogCQkJCSAgc3RydWN0IHN5c2ZzX2J1ZmZlciAqYnVmZmVyKQogewogCXN0cnVjdCBzeXNmc19vcGVuX2RpcmVudCAqb2QgPSBzZC0+c19hdHRyLm9wZW47CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9jaygmc3lzZnNfb3Blbl9kaXJlbnRfbG9jayk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJnN5c2ZzX29wZW5fZGlyZW50X2xvY2ssIGZsYWdzKTsKIAogCWxpc3RfZGVsKCZidWZmZXItPmxpc3QpOwogCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZvZC0+cmVmY250KSkKQEAgLTMyNCw3ICszMjUsNyBAQAogCWVsc2UKIAkJb2QgPSBOVUxMOwogCi0Jc3Bpbl91bmxvY2soJnN5c2ZzX29wZW5fZGlyZW50X2xvY2spOworCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN5c2ZzX29wZW5fZGlyZW50X2xvY2ssIGZsYWdzKTsKIAogCWtmcmVlKG9kKTsKIH0KQEAgLTQ1Niw4ICs0NTcsOSBAQAogdm9pZCBzeXNmc19ub3RpZnlfZGlyZW50KHN0cnVjdCBzeXNmc19kaXJlbnQgKnNkKQogewogCXN0cnVjdCBzeXNmc19vcGVuX2RpcmVudCAqb2Q7CisJdW5zaWduZWQgbG9uZyBmbGFnczsKIAotCXNwaW5fbG9jaygmc3lzZnNfb3Blbl9kaXJlbnRfbG9jayk7CisJc3Bpbl9sb2NrX2lycXNhdmUoJnN5c2ZzX29wZW5fZGlyZW50X2xvY2ssIGZsYWdzKTsKIAogCW9kID0gc2QtPnNfYXR0ci5vcGVuOwogCWlmIChvZCkgewpAQCAtNDY1LDcgKzQ2Nyw3IEBACiAJCXdha2VfdXBfaW50ZXJydXB0aWJsZSgmb2QtPnBvbGwpOwogCX0KIAotCXNwaW5fdW5sb2NrKCZzeXNmc19vcGVuX2RpcmVudF9sb2NrKTsKKwlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzeXNmc19vcGVuX2RpcmVudF9sb2NrLCBmbGFncyk7CiB9CiBFWFBPUlRfU1lNQk9MX0dQTChzeXNmc19ub3RpZnlfZGlyZW50KTsKIApkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfYW9wcy5jIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfYW9wcy5jCmluZGV4IDM4MTg1NDQuLmMyZTMwZWUgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9saW51eC0yLjYveGZzX2FvcHMuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19hb3BzLmMKQEAgLTE4NiwxOSArMTg2LDM3IEBACiB9CiAKIC8qCisgKiBJZiB0aGUgZW5kIG9mIHRoZSBjdXJyZW50IGlvZW5kIGlzIGJleW9uZCB0aGUgY3VycmVudCBFT0YsCisgKiByZXR1cm4gdGhlIG5ldyBFT0YgdmFsdWUsIG90aGVyd2lzZSB6ZXJvLgorICovCitTVEFUSUMgeGZzX2ZzaXplX3QKK3hmc19pb2VuZF9uZXdfZW9mKAorCXhmc19pb2VuZF90CQkqaW9lbmQpCit7CisJeGZzX2lub2RlX3QJCSppcCA9IFhGU19JKGlvZW5kLT5pb19pbm9kZSk7CisJeGZzX2ZzaXplX3QJCWlzaXplOworCXhmc19mc2l6ZV90CQlic2l6ZTsKKworCWJzaXplID0gaW9lbmQtPmlvX29mZnNldCArIGlvZW5kLT5pb19zaXplOworCWlzaXplID0gTUFYKGlwLT5pX3NpemUsIGlwLT5pX25ld19zaXplKTsKKwlpc2l6ZSA9IE1JTihpc2l6ZSwgYnNpemUpOworCXJldHVybiBpc2l6ZSA+IGlwLT5pX2QuZGlfc2l6ZSA/IGlzaXplIDogMDsKK30KKworLyoKICAqIFVwZGF0ZSBvbi1kaXNrIGZpbGUgc2l6ZSBub3cgdGhhdCBkYXRhIGhhcyBiZWVuIHdyaXR0ZW4gdG8gZGlzay4KICAqIFRoZSBjdXJyZW50IGluLW1lbW9yeSBmaWxlIHNpemUgaXMgaV9zaXplLiAgSWYgYSB3cml0ZSBpcyBiZXlvbmQKICAqIGVvZiBpX25ld19zaXplIHdpbGwgYmUgdGhlIGludGVuZGVkIGZpbGUgc2l6ZSB1bnRpbCBpX3NpemUgaXMKICAqIHVwZGF0ZWQuICBJZiB0aGlzIHdyaXRlIGRvZXMgbm90IGV4dGVuZCBhbGwgdGhlIHdheSB0byB0aGUgdmFsaWQKICAqIGZpbGUgc2l6ZSB0aGVuIHJlc3RyaWN0IHRoaXMgdXBkYXRlIHRvIHRoZSBlbmQgb2YgdGhlIHdyaXRlLgogICovCisKIFNUQVRJQyB2b2lkCiB4ZnNfc2V0ZmlsZXNpemUoCiAJeGZzX2lvZW5kX3QJCSppb2VuZCkKIHsKIAl4ZnNfaW5vZGVfdAkJKmlwID0gWEZTX0koaW9lbmQtPmlvX2lub2RlKTsKIAl4ZnNfZnNpemVfdAkJaXNpemU7Ci0JeGZzX2ZzaXplX3QJCWJzaXplOwogCiAJQVNTRVJUKChpcC0+aV9kLmRpX21vZGUgJiBTX0lGTVQpID09IFNfSUZSRUcpOwogCUFTU0VSVChpb2VuZC0+aW9fdHlwZSAhPSBJT01BUF9SRUFEKTsKQEAgLTIwNiwxNiArMjI0LDEwIEBACiAJaWYgKHVubGlrZWx5KGlvZW5kLT5pb19lcnJvcikpCiAJCXJldHVybjsKIAotCWJzaXplID0gaW9lbmQtPmlvX29mZnNldCArIGlvZW5kLT5pb19zaXplOwotCiAJeGZzX2lsb2NrKGlwLCBYRlNfSUxPQ0tfRVhDTCk7Ci0KLQlpc2l6ZSA9IE1BWChpcC0+aV9zaXplLCBpcC0+aV9uZXdfc2l6ZSk7Ci0JaXNpemUgPSBNSU4oaXNpemUsIGJzaXplKTsKLQotCWlmIChpcC0+aV9kLmRpX3NpemUgPCBpc2l6ZSkgeworCWlzaXplID0geGZzX2lvZW5kX25ld19lb2YoaW9lbmQpOworCWlmIChpc2l6ZSkgewogCQlpcC0+aV9kLmRpX3NpemUgPSBpc2l6ZTsKLQkJaXAtPmlfdXBkYXRlX2NvcmUgPSAxOwogCQl4ZnNfbWFya19pbm9kZV9kaXJ0eV9zeW5jKGlwKTsKIAl9CiAKQEAgLTQwNCwxMCArNDE2LDE2IEBACiAJc3RydWN0IGJpbwkqYmlvKQogewogCWF0b21pY19pbmMoJmlvZW5kLT5pb19yZW1haW5pbmcpOwotCiAJYmlvLT5iaV9wcml2YXRlID0gaW9lbmQ7CiAJYmlvLT5iaV9lbmRfaW8gPSB4ZnNfZW5kX2JpbzsKIAorCS8qCisJICogSWYgdGhlIEkvTyBpcyBiZXlvbmQgRU9GIHdlIG1hcmsgdGhlIGlub2RlIGRpcnR5IGltbWVkaWF0ZWx5CisJICogYnV0IGRvbid0IHVwZGF0ZSB0aGUgaW5vZGUgc2l6ZSB1bnRpbCBJL08gY29tcGxldGlvbi4KKwkgKi8KKwlpZiAoeGZzX2lvZW5kX25ld19lb2YoaW9lbmQpKQorCQl4ZnNfbWFya19pbm9kZV9kaXJ0eV9zeW5jKFhGU19JKGlvZW5kLT5pb19pbm9kZSkpOworCiAJc3VibWl0X2JpbyhXUklURSwgYmlvKTsKIAlBU1NFUlQoIWJpb19mbGFnZ2VkKGJpbywgQklPX0VPUE5PVFNVUFApKTsKIAliaW9fcHV0KGJpbyk7CmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19maWxlLmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19maWxlLmMKaW5kZXggNjI5MzcwOS4uZWZmNjFlMiAxMDA2NDQKLS0tIGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfZmlsZS5jCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX2ZpbGUuYwpAQCAtMTc2LDE0ICsxNzYsNyBAQAogCXN0cnVjdCBkZW50cnkJCSpkZW50cnksCiAJaW50CQkJZGF0YXN5bmMpCiB7Ci0Jc3RydWN0IGlub2RlCQkqaW5vZGUgPSBkZW50cnktPmRfaW5vZGU7Ci0Jc3RydWN0IHhmc19pbm9kZQkqaXAgPSBYRlNfSShpbm9kZSk7Ci0JaW50CQkJZXJyb3I7Ci0KLQkvKiBjYXB0dXJlIHNpemUgdXBkYXRlcyBpbiBJL08gY29tcGxldGlvbiBiZWZvcmUgd3JpdGluZyB0aGUgaW5vZGUuICovCi0JZXJyb3IgPSBmaWxlbWFwX2ZkYXRhd2FpdChpbm9kZS0+aV9tYXBwaW5nKTsKLQlpZiAoZXJyb3IpCi0JCXJldHVybiBlcnJvcjsKKwlzdHJ1Y3QgeGZzX2lub2RlCSppcCA9IFhGU19JKGRlbnRyeS0+ZF9pbm9kZSk7CiAKIAl4ZnNfaWZsYWdzX2NsZWFyKGlwLCBYRlNfSVRSVU5DQVRFRCk7CiAJcmV0dXJuIC14ZnNfZnN5bmMoaXApOwpkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfaW9wcy5jIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfaW9wcy5jCmluZGV4IGRhMDE1OWQuLmNkNDJlZjcgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy9saW51eC0yLjYveGZzX2lvcHMuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19pb3BzLmMKQEAgLTU3LDE5ICs1NywyMiBAQAogI2luY2x1ZGUgPGxpbnV4L2ZpZW1hcC5oPgogCiAvKgotICogQnJpbmcgdGhlIGF0aW1lIGluIHRoZSBYRlMgaW5vZGUgdXB0b2RhdGUuCi0gKiBVc2VkIGJlZm9yZSBsb2dnaW5nIHRoZSBpbm9kZSB0byBkaXNrIG9yIHdoZW4gdGhlIExpbnV4IGlub2RlIGdvZXMgYXdheS4KKyAqIEJyaW5nIHRoZSB0aW1lc3RhbXBzIGluIHRoZSBYRlMgaW5vZGUgdXB0b2RhdGUuCisgKgorICogVXNlZCBiZWZvcmUgd3JpdGluZyB0aGUgaW5vZGUgdG8gZGlzay4KICAqLwogdm9pZAoteGZzX3N5bmNocm9uaXplX2F0aW1lKAoreGZzX3N5bmNocm9uaXplX3RpbWVzKAogCXhmc19pbm9kZV90CSppcCkKIHsKIAlzdHJ1Y3QgaW5vZGUJKmlub2RlID0gVkZTX0koaXApOwogCi0JaWYgKCEoaW5vZGUtPmlfc3RhdGUgJiBJX0NMRUFSKSkgewotCQlpcC0+aV9kLmRpX2F0aW1lLnRfc2VjID0gKF9faW50MzJfdClpbm9kZS0+aV9hdGltZS50dl9zZWM7Ci0JCWlwLT5pX2QuZGlfYXRpbWUudF9uc2VjID0gKF9faW50MzJfdClpbm9kZS0+aV9hdGltZS50dl9uc2VjOwotCX0KKwlpcC0+aV9kLmRpX2F0aW1lLnRfc2VjID0gKF9faW50MzJfdClpbm9kZS0+aV9hdGltZS50dl9zZWM7CisJaXAtPmlfZC5kaV9hdGltZS50X25zZWMgPSAoX19pbnQzMl90KWlub2RlLT5pX2F0aW1lLnR2X25zZWM7CisJaXAtPmlfZC5kaV9jdGltZS50X3NlYyA9IChfX2ludDMyX3QpaW5vZGUtPmlfY3RpbWUudHZfc2VjOworCWlwLT5pX2QuZGlfY3RpbWUudF9uc2VjID0gKF9faW50MzJfdClpbm9kZS0+aV9jdGltZS50dl9uc2VjOworCWlwLT5pX2QuZGlfbXRpbWUudF9zZWMgPSAoX19pbnQzMl90KWlub2RlLT5pX210aW1lLnR2X3NlYzsKKwlpcC0+aV9kLmRpX210aW1lLnRfbnNlYyA9IChfX2ludDMyX3QpaW5vZGUtPmlfbXRpbWUudHZfbnNlYzsKIH0KIAogLyoKQEAgLTEwNiwzMiArMTA5LDIwIEBACiAJaWYgKChmbGFncyAmIFhGU19JQ0hHVElNRV9NT0QpICYmCiAJICAgICF0aW1lc3BlY19lcXVhbCgmaW5vZGUtPmlfbXRpbWUsICZ0dikpIHsKIAkJaW5vZGUtPmlfbXRpbWUgPSB0djsKLQkJaXAtPmlfZC5kaV9tdGltZS50X3NlYyA9IChfX2ludDMyX3QpdHYudHZfc2VjOwotCQlpcC0+aV9kLmRpX210aW1lLnRfbnNlYyA9IChfX2ludDMyX3QpdHYudHZfbnNlYzsKIAkJc3luY19pdCA9IDE7CiAJfQogCWlmICgoZmxhZ3MgJiBYRlNfSUNIR1RJTUVfQ0hHKSAmJgogCSAgICAhdGltZXNwZWNfZXF1YWwoJmlub2RlLT5pX2N0aW1lLCAmdHYpKSB7CiAJCWlub2RlLT5pX2N0aW1lID0gdHY7Ci0JCWlwLT5pX2QuZGlfY3RpbWUudF9zZWMgPSAoX19pbnQzMl90KXR2LnR2X3NlYzsKLQkJaXAtPmlfZC5kaV9jdGltZS50X25zZWMgPSAoX19pbnQzMl90KXR2LnR2X25zZWM7CiAJCXN5bmNfaXQgPSAxOwogCX0KIAogCS8qCi0JICogV2UgdXBkYXRlIHRoZSBpX3VwZGF0ZV9jb3JlIGZpZWxkIF9hZnRlcl8gY2hhbmdpbmcKLQkgKiB0aGUgdGltZXN0YW1wcyBpbiBvcmRlciB0byBjb29yZGluYXRlIHByb3Blcmx5IHdpdGgKLQkgKiB4ZnNfaWZsdXNoKCkgc28gdGhhdCB3ZSBkb24ndCBsb3NlIHRpbWVzdGFtcCB1cGRhdGVzLgotCSAqIFRoaXMga2VlcHMgdXMgZnJvbSBoYXZpbmcgdG8gaG9sZCB0aGUgaW5vZGUgbG9jawotCSAqIHdoaWxlIGRvaW5nIHRoaXMuICBXZSB1c2UgdGhlIFNZTkNIUk9OSVpFIG1hY3JvIHRvCi0JICogZW5zdXJlIHRoYXQgdGhlIGNvbXBpbGVyIGRvZXMgbm90IHJlb3JkZXIgdGhlIHVwZGF0ZQotCSAqIG9mIGlfdXBkYXRlX2NvcmUgYWJvdmUgdGhlIHRpbWVzdGFtcCB1cGRhdGVzIGFib3ZlLgorCSAqIFVwZGF0ZSBjb21wbGV0ZSAtIG5vdyBtYWtlIHN1cmUgZXZlcnlvbmUga25vd3MgdGhhdCB0aGUgaW5vZGUKKwkgKiBpcyBkaXJ0eS4KIAkgKi8KLQlpZiAoc3luY19pdCkgewotCQlTWU5DSFJPTklaRSgpOwotCQlpcC0+aV91cGRhdGVfY29yZSA9IDE7CisJaWYgKHN5bmNfaXQpCiAJCXhmc19tYXJrX2lub2RlX2RpcnR5X3N5bmMoaXApOwotCX0KIH0KIAogLyoKQEAgLTUwNiwxMCArNDk3LDggQEAKIAlzdGF0LT5naWQgPSBpcC0+aV9kLmRpX2dpZDsKIAlzdGF0LT5pbm8gPSBpcC0+aV9pbm87CiAJc3RhdC0+YXRpbWUgPSBpbm9kZS0+aV9hdGltZTsKLQlzdGF0LT5tdGltZS50dl9zZWMgPSBpcC0+aV9kLmRpX210aW1lLnRfc2VjOwotCXN0YXQtPm10aW1lLnR2X25zZWMgPSBpcC0+aV9kLmRpX210aW1lLnRfbnNlYzsKLQlzdGF0LT5jdGltZS50dl9zZWMgPSBpcC0+aV9kLmRpX2N0aW1lLnRfc2VjOwotCXN0YXQtPmN0aW1lLnR2X25zZWMgPSBpcC0+aV9kLmRpX2N0aW1lLnRfbnNlYzsKKwlzdGF0LT5tdGltZSA9IGlub2RlLT5pX210aW1lOworCXN0YXQtPmN0aW1lID0gaW5vZGUtPmlfY3RpbWU7CiAJc3RhdC0+YmxvY2tzID0KIAkJWEZTX0ZTQl9UT19CQihtcCwgaXAtPmlfZC5kaV9uYmxvY2tzICsgaXAtPmlfZGVsYXllZF9ibGtzKTsKIApkaWZmIC0tZ2l0IGEvZnMveGZzL2xpbnV4LTIuNi94ZnNfbHJ3LmMgYi9mcy94ZnMvbGludXgtMi42L3hmc19scncuYwppbmRleCA0OWU0YTZhLi4wNzIwNTBmIDEwMDY0NAotLS0gYS9mcy94ZnMvbGludXgtMi42L3hmc19scncuYworKysgYi9mcy94ZnMvbGludXgtMi42L3hmc19scncuYwpAQCAtNjY3LDcgKzY2Nyw3IEBACiAJCXhpcC0+aV9uZXdfc2l6ZSA9IG5ld19zaXplOwogCiAJaWYgKGxpa2VseSghKGlvZmxhZ3MgJiBJT19JTlZJUykpKQotCQl4ZnNfaWNoZ3RpbWUoeGlwLCBYRlNfSUNIR1RJTUVfTU9EIHwgWEZTX0lDSEdUSU1FX0NIRyk7CisJCWZpbGVfdXBkYXRlX3RpbWUoZmlsZSk7CiAKIAkvKgogCSAqIElmIHRoZSBvZmZzZXQgaXMgYmV5b25kIHRoZSBzaXplIG9mIHRoZSBmaWxlLCB3ZSBoYXZlIGEgY291cGxlCmRpZmYgLS1naXQgYS9mcy94ZnMvbGludXgtMi42L3hmc19zdXBlci5jIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfc3VwZXIuYwppbmRleCBiZGQ0MWM4Li4xOGE0YjhlIDEwMDY0NAotLS0gYS9mcy94ZnMvbGludXgtMi42L3hmc19zdXBlci5jCisrKyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX3N1cGVyLmMKQEAgLTk3Nyw2ICs5NzcsMjggQEAKIH0KIAogLyoKKyAqIERpcnR5IHRoZSBYRlMgaW5vZGUgd2hlbiBtYXJrX2lub2RlX2RpcnR5X3N5bmMoKSBpcyBjYWxsZWQgc28gdGhhdAorICogd2UgY2F0Y2ggdW5sb2dnZWQgVkZTIGxldmVsIHVwZGF0ZXMgdG8gdGhlIGlub2RlLiBDYXJlIG11c3QgYmUgdGFrZW4KKyAqIGhlcmUgLSB0aGUgdHJhbnNhY3Rpb24gY29kZSBjYWxscyBtYXJrX2lub2RlX2RpcnR5X3N5bmMoKSB0byBtYXJrIHRoZQorICogVkZTIGlub2RlIGRpcnR5IGluIGEgdHJhbnNhY3Rpb24gYW5kIGNsZWFycyB0aGUgaV91cGRhdGVfY29yZSBmaWVsZDsKKyAqIGl0IG11c3QgY2xlYXIgdGhlIGZpZWxkIGFmdGVyIGNhbGxpbmcgbWFya19pbm9kZV9kaXJ0eV9zeW5jKCkgdG8KKyAqIGNvcnJlY3RseSBpbmRpY2F0ZSB0aGF0IHRoZSBkaXJ0eSBzdGF0ZSBoYXMgYmVlbiBwcm9wYWdhdGVkIGludG8gdGhlCisgKiBpbm9kZSBsb2cgaXRlbS4KKyAqCisgKiBXZSBuZWVkIHRoZSBiYXJyaWVyKCkgdG8gbWFpbnRhaW4gY29ycmVjdCBvcmRlcmluZyBiZXR3ZWVuIHVubG9nZ2VkCisgKiB1cGRhdGVzIGFuZCB0aGUgdHJhbnNhY3Rpb24gY29tbWl0IGNvZGUgdGhhdCBjbGVhcnMgdGhlIGlfdXBkYXRlX2NvcmUKKyAqIGZpZWxkLiBUaGlzIHJlcXVpcmVzIGFsbCB1cGRhdGVzIHRvIGJlIGNvbXBsZXRlZCBiZWZvcmUgbWFya2luZyB0aGUKKyAqIGlub2RlIGRpcnR5LgorICovCitTVEFUSUMgdm9pZAoreGZzX2ZzX2RpcnR5X2lub2RlKAorCXN0cnVjdCBpbm9kZQkqaW5vZGUpCit7CisJYmFycmllcigpOworCVhGU19JKGlub2RlKS0+aV91cGRhdGVfY29yZSA9IDE7Cit9CisKKy8qCiAgKiBBdHRlbXB0IHRvIGZsdXNoIHRoZSBpbm9kZSwgdGhpcyB3aWxsIGFjdHVhbGx5IGZhaWwKICAqIGlmIHRoZSBpbm9kZSBpcyBwaW5uZWQsIGJ1dCB3ZSBkaXJ0eSB0aGUgaW5vZGUgYWdhaW4KICAqIGF0IHRoZSBwb2ludCB3aGVuIGl0IGlzIHVucGlubmVkIGFmdGVyIGEgbG9nIHdyaXRlLApAQCAtMTEyNiw3ICsxMTQ4LDcgQEAKIH0KIAogU1RBVElDIGludAoteGZzX2ZzX3N5bmNfc3VwZXIoCit4ZnNfZnNfc3luY19mcygKIAlzdHJ1Y3Qgc3VwZXJfYmxvY2sJKnNiLAogCWludAkJCXdhaXQpCiB7CkBAIC0xMTM0LDIzICsxMTU2LDIzIEBACiAJaW50CQkJZXJyb3I7CiAKIAkvKgotCSAqIFRyZWF0IGEgc3luYyBvcGVyYXRpb24gbGlrZSBhIGZyZWV6ZS4gIFRoaXMgaXMgdG8gd29yawotCSAqIGFyb3VuZCBhIHJhY2UgaW4gc3luY19pbm9kZXMoKSB3aGljaCB3b3JrcyBpbiB0d28gcGhhc2VzCi0JICogLSBhbiBhc3luY2hyb25vdXMgZmx1c2gsIHdoaWNoIGNhbiB3cml0ZSBvdXQgYW4gaW5vZGUKLQkgKiB3aXRob3V0IHdhaXRpbmcgZm9yIGZpbGUgc2l6ZSB1cGRhdGVzIHRvIGNvbXBsZXRlLCBhbmQgYQotCSAqIHN5bmNocm9ub3VzIGZsdXNoLCB3aGljaCB3b250IGRvIGFueXRoaW5nIGJlY2F1c2UgdGhlCi0JICogYXN5bmMgZmx1c2ggcmVtb3ZlZCB0aGUgaW5vZGUncyBkaXJ0eSBmbGFnLiAgQWxzbwotCSAqIHN5bmNfaW5vZGVzKCkgd2lsbCBub3Qgc2VlIGFueSBmaWxlcyB0aGF0IGp1c3QgaGF2ZQotCSAqIG91dHN0YW5kaW5nIHRyYW5zYWN0aW9ucyB0byBiZSBmbHVzaGVkIGJlY2F1c2Ugd2UgZG9uJ3QKLQkgKiBkaXJ0eSB0aGUgTGludXggaW5vZGUgdW50aWwgYWZ0ZXIgdGhlIHRyYW5zYWN0aW9uIEkvTwotCSAqIGNvbXBsZXRlcy4KKwkgKiBOb3QgbXVjaCB3ZSBjYW4gZG8gZm9yIHRoZSBmaXJzdCBhc3luYyBwYXNzLiAgV3JpdGluZyBvdXQgdGhlCisJICogc3VwZXJibG9jayB3b3VsZCBiZSBjb3VudGVyLXByb2R1Y3RpdmUgYXMgd2UgYXJlIGdvaW5nIHRvIHJlZGlydHkKKwkgKiB3aGVuIHdyaXRpbmcgb3V0IG90aGVyIGRhdGEgYW5kIG1ldGFkYXRhIChhbmQgd3JpdGluZyBvdXQgYSBzaW5nbGUKKwkgKiBibG9jayBpcyBxdWl0ZSBmYXN0IGFueXdheSkuCisJICoKKwkgKiBUcnkgdG8gYXN5bmNocm9ub3VzbHkga2ljayBvZmYgcXVvdGEgc3luY2luZyBhdCBsZWFzdC4KIAkgKi8KLQlpZiAod2FpdCB8fCB1bmxpa2VseShzYi0+c19mcm96ZW4gPT0gU0JfRlJFRVpFX1dSSVRFKSkKLQkJZXJyb3IgPSB4ZnNfcXVpZXNjZV9kYXRhKG1wKTsKLQllbHNlCi0JCWVycm9yID0geGZzX3N5bmNfZnNkYXRhKG1wLCAwKTsKKwlpZiAoIXdhaXQpIHsKKwkJeGZzX3FtX3N5bmMobXAsIFNZTkNfVFJZTE9DSyk7CisJCXJldHVybiAwOworCX0KIAotCWlmICh1bmxpa2VseShsYXB0b3BfbW9kZSkpIHsKKwllcnJvciA9IHhmc19xdWllc2NlX2RhdGEobXApOworCWlmIChlcnJvcikKKwkJcmV0dXJuIC1lcnJvcjsKKworCWlmIChsYXB0b3BfbW9kZSkgewogCQlpbnQJcHJldl9zeW5jX3NlcSA9IG1wLT5tX3N5bmNfc2VxOwogCiAJCS8qCkBAIC0xMTY5LDcgKzExOTEsNyBAQAogCQkJCW1wLT5tX3N5bmNfc2VxICE9IHByZXZfc3luY19zZXEpOwogCX0KIAotCXJldHVybiAtZXJyb3I7CisJcmV0dXJuIDA7CiB9CiAKIFNUQVRJQyBpbnQKQEAgLTE1MzksMTAgKzE1NjEsMTEgQEAKIHN0YXRpYyBjb25zdCBzdHJ1Y3Qgc3VwZXJfb3BlcmF0aW9ucyB4ZnNfc3VwZXJfb3BlcmF0aW9ucyA9IHsKIAkuYWxsb2NfaW5vZGUJCT0geGZzX2ZzX2FsbG9jX2lub2RlLAogCS5kZXN0cm95X2lub2RlCQk9IHhmc19mc19kZXN0cm95X2lub2RlLAorCS5kaXJ0eV9pbm9kZQkJPSB4ZnNfZnNfZGlydHlfaW5vZGUsCiAJLndyaXRlX2lub2RlCQk9IHhmc19mc193cml0ZV9pbm9kZSwKIAkuY2xlYXJfaW5vZGUJCT0geGZzX2ZzX2NsZWFyX2lub2RlLAogCS5wdXRfc3VwZXIJCT0geGZzX2ZzX3B1dF9zdXBlciwKLQkuc3luY19mcwkJPSB4ZnNfZnNfc3luY19zdXBlciwKKwkuc3luY19mcwkJPSB4ZnNfZnNfc3luY19mcywKIAkuZnJlZXplX2ZzCQk9IHhmc19mc19mcmVlemUsCiAJLnN0YXRmcwkJCT0geGZzX2ZzX3N0YXRmcywKIAkucmVtb3VudF9mcwkJPSB4ZnNfZnNfcmVtb3VudCwKZGlmZiAtLWdpdCBhL2ZzL3hmcy9saW51eC0yLjYveGZzX3N5bmMuYyBiL2ZzL3hmcy9saW51eC0yLjYveGZzX3N5bmMuYwppbmRleCAzMjBiZTZhLi45NjFkZjBhIDEwMDY0NAotLS0gYS9mcy94ZnMvbGludXgtMi42L3hmc19zeW5jLmMKKysrIGIvZnMveGZzL2xpbnV4LTIuNi94ZnNfc3luYy5jCkBAIC0zMDksMTEgKzMwOSwxNSBAQAogU1RBVElDIGludAogeGZzX2NvbW1pdF9kdW1teV90cmFucygKIAlzdHJ1Y3QgeGZzX21vdW50CSptcCwKLQl1aW50CQkJbG9nX2ZsYWdzKQorCXVpbnQJCQlmbGFncykKIHsKIAlzdHJ1Y3QgeGZzX2lub2RlCSppcCA9IG1wLT5tX3Jvb3RpcDsKIAlzdHJ1Y3QgeGZzX3RyYW5zCSp0cDsKIAlpbnQJCQllcnJvcjsKKwlpbnQJCQlsb2dfZmxhZ3MgPSBYRlNfTE9HX0ZPUkNFOworCisJaWYgKGZsYWdzICYgU1lOQ19XQUlUKQorCQlsb2dfZmxhZ3MgfD0gWEZTX0xPR19TWU5DOwogCiAJLyoKIAkgKiBQdXQgYSBkdW1teSB0cmFuc2FjdGlvbiBpbiB0aGUgbG9nIHRvIHRlbGwgcmVjb3ZlcnkKQEAgLTMzMSwxMyArMzM1LDEyIEBACiAJeGZzX3RyYW5zX2lqb2luKHRwLCBpcCwgWEZTX0lMT0NLX0VYQ0wpOwogCXhmc190cmFuc19paG9sZCh0cCwgaXApOwogCXhmc190cmFuc19sb2dfaW5vZGUodHAsIGlwLCBYRlNfSUxPR19DT1JFKTsKLQkvKiBYWFgoaGNoKTogaWdub3JpbmcgdGhlIGVycm9yIGhlcmUuLiAqLwogCWVycm9yID0geGZzX3RyYW5zX2NvbW1pdCh0cCwgMCk7Ci0KIAl4ZnNfaXVubG9jayhpcCwgWEZTX0lMT0NLX0VYQ0wpOwogCisJLyogdGhlIGxvZyBmb3JjZSBlbnN1cmVzIHRoaXMgdHJhbnNhY3Rpb24gaXMgcHVzaGVkIHRvIGRpc2sgKi8KIAl4ZnNfbG9nX2ZvcmNlKG1wLCAwLCBsb2dfZmxhZ3MpOwotCXJldHVybiAwOworCXJldHVybiBlcnJvcjsKIH0KIAogaW50CkBAIC0zODUsNyArMzg4LDIwIEBACiAJZWxzZQogCQlYRlNfQlVGX0FTWU5DKGJwKTsKIAotCXJldHVybiB4ZnNfYndyaXRlKG1wLCBicCk7CisJZXJyb3IgPSB4ZnNfYndyaXRlKG1wLCBicCk7CisJaWYgKGVycm9yKQorCQlyZXR1cm4gZXJyb3I7CisKKwkvKgorCSAqIElmIHRoaXMgaXMgYSBkYXRhIGludGVncml0eSBzeW5jIG1ha2Ugc3VyZSBhbGwgcGVuZGluZyBidWZmZXJzCisJICogYXJlIGZsdXNoZWQgb3V0IGZvciB0aGUgbG9nIGNvdmVyYWdlIGNoZWNrIGJlbG93LgorCSAqLworCWlmIChmbGFncyAmIFNZTkNfV0FJVCkKKwkJeGZzX2ZsdXNoX2J1ZnRhcmcobXAtPm1fZGRldl90YXJncCwgMSk7CisKKwlpZiAoeGZzX2xvZ19uZWVkX2NvdmVyZWQobXApKQorCQllcnJvciA9IHhmc19jb21taXRfZHVtbXlfdHJhbnMobXAsIGZsYWdzKTsKKwlyZXR1cm4gZXJyb3I7CiAKICBvdXRfYnJlbHNlOgogCXhmc19idWZfcmVsc2UoYnApOwpAQCAtNDE5LDE0ICs0MzUsMTYgQEAKIAkvKiBwdXNoIG5vbi1ibG9ja2luZyAqLwogCXhmc19zeW5jX2RhdGEobXAsIDApOwogCXhmc19xbV9zeW5jKG1wLCBTWU5DX1RSWUxPQ0spOwotCXhmc19maWxlc3RyZWFtX2ZsdXNoKG1wKTsKIAotCS8qIHB1c2ggYW5kIGJsb2NrICovCisJLyogcHVzaCBhbmQgYmxvY2sgdGlsbCBjb21wbGV0ZSAqLwogCXhmc19zeW5jX2RhdGEobXAsIFNZTkNfV0FJVCk7CiAJeGZzX3FtX3N5bmMobXAsIFNZTkNfV0FJVCk7CiAKKwkvKiBkcm9wIGlub2RlIHJlZmVyZW5jZXMgcGlubmVkIGJ5IGZpbGVzdHJlYW1zICovCisJeGZzX2ZpbGVzdHJlYW1fZmx1c2gobXApOworCiAJLyogd3JpdGUgc3VwZXJibG9jayBhbmQgaG9vdmVyIHVwIHNodXRkb3duIGVycm9ycyAqLwotCWVycm9yID0geGZzX3N5bmNfZnNkYXRhKG1wLCAwKTsKKwllcnJvciA9IHhmc19zeW5jX2ZzZGF0YShtcCwgU1lOQ19XQUlUKTsKIAogCS8qIGZsdXNoIGRhdGEtb25seSBkZXZpY2VzICovCiAJaWYgKG1wLT5tX3J0ZGV2X3RhcmdwKQpAQCAtNTcwLDggKzU4OCw2IEBACiAJCS8qIGRnYzogZXJyb3JzIGlnbm9yZWQgaGVyZSAqLwogCQllcnJvciA9IHhmc19xbV9zeW5jKG1wLCBTWU5DX1RSWUxPQ0spOwogCQllcnJvciA9IHhmc19zeW5jX2ZzZGF0YShtcCwgU1lOQ19UUllMT0NLKTsKLQkJaWYgKHhmc19sb2dfbmVlZF9jb3ZlcmVkKG1wKSkKLQkJCWVycm9yID0geGZzX2NvbW1pdF9kdW1teV90cmFucyhtcCwgWEZTX0xPR19GT1JDRSk7CiAJfQogCW1wLT5tX3N5bmNfc2VxKys7CiAJd2FrZV91cCgmbXAtPm1fd2FpdF9zaW5nbGVfc3luY190YXNrKTsKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfZGZyYWcuYyBiL2ZzL3hmcy94ZnNfZGZyYWcuYwppbmRleCA3NDY1ZjllLi5hYjg5YTdlIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2RmcmFnLmMKKysrIGIvZnMveGZzL3hmc19kZnJhZy5jCkBAIC0yMDYsMTAgKzIwNiwxMCBAQAogCSAqIHByb2Nlc3MgdGhhdCB0aGUgZmlsZSB3YXMgbm90IGNoYW5nZWQgb3V0IGZyb20KIAkgKiB1bmRlciBpdC4KIAkgKi8KLQlpZiAoKHNicC0+YnNfY3RpbWUudHZfc2VjICE9IGlwLT5pX2QuZGlfY3RpbWUudF9zZWMpIHx8Ci0JICAgIChzYnAtPmJzX2N0aW1lLnR2X25zZWMgIT0gaXAtPmlfZC5kaV9jdGltZS50X25zZWMpIHx8Ci0JICAgIChzYnAtPmJzX210aW1lLnR2X3NlYyAhPSBpcC0+aV9kLmRpX210aW1lLnRfc2VjKSB8fAotCSAgICAoc2JwLT5ic19tdGltZS50dl9uc2VjICE9IGlwLT5pX2QuZGlfbXRpbWUudF9uc2VjKSkgeworCWlmICgoc2JwLT5ic19jdGltZS50dl9zZWMgIT0gVkZTX0koaXApLT5pX2N0aW1lLnR2X3NlYykgfHwKKwkgICAgKHNicC0+YnNfY3RpbWUudHZfbnNlYyAhPSBWRlNfSShpcCktPmlfY3RpbWUudHZfbnNlYykgfHwKKwkgICAgKHNicC0+YnNfbXRpbWUudHZfc2VjICE9IFZGU19JKGlwKS0+aV9tdGltZS50dl9zZWMpIHx8CisJICAgIChzYnAtPmJzX210aW1lLnR2X25zZWMgIT0gVkZTX0koaXApLT5pX210aW1lLnR2X25zZWMpKSB7CiAJCWVycm9yID0gWEZTX0VSUk9SKEVCVVNZKTsKIAkJZ290byBvdXRfdW5sb2NrOwogCX0KZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfZGlyMl9sZWFmLmMgYi9mcy94ZnMveGZzX2RpcjJfbGVhZi5jCmluZGV4IGZhOTEzZTQ1Li40MWFkNTM3IDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2RpcjJfbGVhZi5jCisrKyBiL2ZzL3hmcy94ZnNfZGlyMl9sZWFmLmMKQEAgLTg1NCw2ICs4NTQsNyBAQAogCQkJICovCiAJCQlyYV93YW50ID0gaG93bWFueShidWZzaXplICsgbXAtPm1fZGlyYmxrc2l6ZSwKIAkJCQkJICBtcC0+bV9zYi5zYl9ibG9ja3NpemUpIC0gMTsKKwkJCUFTU0VSVChyYV93YW50ID49IDApOwogCiAJCQkvKgogCQkJICogSWYgd2UgZG9uJ3QgaGF2ZSBhcyBtYW55IGFzIHdlIHdhbnQsIGFuZCB3ZSBoYXZlbid0CkBAIC0xMDg4LDcgKzEwODksOCBAQAogCQkgKi8KIAkJcHRyICs9IGxlbmd0aDsKIAkJY3Vyb2ZmICs9IGxlbmd0aDsKLQkJYnVmc2l6ZSAtPSBsZW5ndGg7CisJCS8qIGJ1ZnNpemUgbWF5IGhhdmUganVzdCBiZWVuIGEgZ3Vlc3M7IGRvbid0IGdvIG5lZ2F0aXZlICovCisJCWJ1ZnNpemUgPSBidWZzaXplID4gbGVuZ3RoID8gYnVmc2l6ZSAtIGxlbmd0aCA6IDA7CiAJfQogCiAJLyoKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfaW5vZGUuYyBiL2ZzL3hmcy94ZnNfaW5vZGUuYwppbmRleCBjMWRjN2VmLi5iOTJhNGZhIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2lub2RlLmMKKysrIGIvZnMveGZzL3hmc19pbm9kZS5jCkBAIC0zMDY4LDkgKzMwNjgsOSBAQAogCVNZTkNIUk9OSVpFKCk7CiAKIAkvKgotCSAqIE1ha2Ugc3VyZSB0byBnZXQgdGhlIGxhdGVzdCBhdGltZSBmcm9tIHRoZSBMaW51eCBpbm9kZS4KKwkgKiBNYWtlIHN1cmUgdG8gZ2V0IHRoZSBsYXRlc3QgdGltZXN0YW1wcyBmcm9tIHRoZSBMaW51eCBpbm9kZS4KIAkgKi8KLQl4ZnNfc3luY2hyb25pemVfYXRpbWUoaXApOworCXhmc19zeW5jaHJvbml6ZV90aW1lcyhpcCk7CiAKIAlpZiAoWEZTX1RFU1RfRVJST1IoYmUxNl90b19jcHUoZGlwLT5kaV9tYWdpYykgIT0gWEZTX0RJTk9ERV9NQUdJQywKIAkJCSAgICAgICBtcCwgWEZTX0VSUlRBR19JRkxVU0hfMSwgWEZTX1JBTkRPTV9JRkxVU0hfMSkpIHsKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfaW5vZGUuaCBiL2ZzL3hmcy94ZnNfaW5vZGUuaAppbmRleCAwYjM4YjlhLi40MTU1NWRlIDEwMDY0NAotLS0gYS9mcy94ZnMveGZzX2lub2RlLmgKKysrIGIvZnMveGZzL3hmc19pbm9kZS5oCkBAIC01MDQsNyArNTA0LDcgQEAKIHZvaWQJCXhmc19sb2NrX2lub2Rlcyh4ZnNfaW5vZGVfdCAqKiwgaW50LCB1aW50KTsKIHZvaWQJCXhmc19sb2NrX3R3b19pbm9kZXMoeGZzX2lub2RlX3QgKiwgeGZzX2lub2RlX3QgKiwgdWludCk7CiAKLXZvaWQJCXhmc19zeW5jaHJvbml6ZV9hdGltZSh4ZnNfaW5vZGVfdCAqKTsKK3ZvaWQJCXhmc19zeW5jaHJvbml6ZV90aW1lcyh4ZnNfaW5vZGVfdCAqKTsKIHZvaWQJCXhmc19tYXJrX2lub2RlX2RpcnR5X3N5bmMoeGZzX2lub2RlX3QgKik7CiAKICNpZiBkZWZpbmVkKFhGU19JTk9ERV9UUkFDRSkKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfaW5vZGVfaXRlbS5jIGIvZnMveGZzL3hmc19pbm9kZV9pdGVtLmMKaW5kZXggNDdkNWI2Ni4uOTc5NGI4NyAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc19pbm9kZV9pdGVtLmMKKysrIGIvZnMveGZzL3hmc19pbm9kZV9pdGVtLmMKQEAgLTIzMiw2ICsyMzIsMTUgQEAKIAludmVjcwkgICAgID0gMTsKIAogCS8qCisJICogTWFrZSBzdXJlIHRoZSBsaW51eCBpbm9kZSBpcyBkaXJ0eS4gV2UgZG8gdGhpcyBiZWZvcmUKKwkgKiBjbGVhcmluZyBpX3VwZGF0ZV9jb3JlIGFzIHRoZSBWRlMgd2lsbCBjYWxsIGJhY2sgaW50bworCSAqIFhGUyBoZXJlIGFuZCBzZXQgaV91cGRhdGVfY29yZSwgc28gd2UgbmVlZCB0byBkaXJ0eSB0aGUKKwkgKiBpbm9kZSBmaXJzdCBzbyB0aGF0IHRoZSBvcmRlcmluZyBvZiBpX3VwZGF0ZV9jb3JlIGFuZAorCSAqIHVubG9nZ2VkIG1vZGlmaWNhdGlvbnMgc3RpbGwgd29ya3MgYXMgZGVzY3JpYmVkIGJlbG93LgorCSAqLworCXhmc19tYXJrX2lub2RlX2RpcnR5X3N5bmMoaXApOworCisJLyoKIAkgKiBDbGVhciBpX3VwZGF0ZV9jb3JlIGlmIHRoZSB0aW1lc3RhbXBzIChvciBhbnkgb3RoZXIKIAkgKiBub24tdHJhbnNhY3Rpb25hbCBtb2RpZmljYXRpb24pIG5lZWQgZmx1c2hpbmcvbG9nZ2luZwogCSAqIGFuZCB3ZSdyZSBhYm91dCB0byBsb2cgdGhlbSB3aXRoIHRoZSByZXN0IG9mIHRoZSBjb3JlLgpAQCAtMjYzLDE0ICsyNzIsOSBAQAogCX0KIAogCS8qCi0JICogTWFrZSBzdXJlIHRvIGdldCB0aGUgbGF0ZXN0IGF0aW1lIGZyb20gdGhlIExpbnV4IGlub2RlLgorCSAqIE1ha2Ugc3VyZSB0byBnZXQgdGhlIGxhdGVzdCB0aW1lc3RhbXBzIGZyb20gdGhlIExpbnV4IGlub2RlLgogCSAqLwotCXhmc19zeW5jaHJvbml6ZV9hdGltZShpcCk7Ci0KLQkvKgotCSAqIG1ha2Ugc3VyZSB0aGUgbGludXggaW5vZGUgaXMgZGlydHkKLQkgKi8KLQl4ZnNfbWFya19pbm9kZV9kaXJ0eV9zeW5jKGlwKTsKKwl4ZnNfc3luY2hyb25pemVfdGltZXMoaXApOwogCiAJdmVjcC0+aV9hZGRyID0gKHhmc19jYWRkcl90KSZpcC0+aV9kOwogCXZlY3AtPmlfbGVuICA9IHNpemVvZihzdHJ1Y3QgeGZzX2ljZGlub2RlKTsKZGlmZiAtLWdpdCBhL2ZzL3hmcy94ZnNfaXRhYmxlLmMgYi9mcy94ZnMveGZzX2l0YWJsZS5jCmluZGV4IGI2OGY5MTAuLjYyZWZhYjIgMTAwNjQ0Ci0tLSBhL2ZzL3hmcy94ZnNfaXRhYmxlLmMKKysrIGIvZnMveGZzL3hmc19pdGFibGUuYwpAQCAtNTksNiArNTksNyBAQAogewogCXhmc19pY2Rpbm9kZV90CSpkaWM7CS8qIGRpbm9kZSBjb3JlIGluZm8gcG9pbnRlciAqLwogCXhmc19pbm9kZV90CSppcDsJCS8qIGluY29yZSBpbm9kZSBwb2ludGVyICovCisJc3RydWN0IGlub2RlCSppbm9kZTsKIAlpbnQJCWVycm9yOwogCiAJZXJyb3IgPSB4ZnNfaWdldChtcCwgTlVMTCwgaW5vLApAQCAtNzIsNiArNzMsNyBAQAogCUFTU0VSVChpcC0+aV9pbWFwLmltX2Jsa25vICE9IDApOwogCiAJZGljID0gJmlwLT5pX2Q7CisJaW5vZGUgPSBWRlNfSShpcCk7CiAKIAkvKiB4ZnNfaWdldCByZXR1cm5zIHRoZSBmb2xsb3dpbmcgd2l0aG91dCBuZWVkaW5nCiAJICogZnVydGhlciBjaGFuZ2UuCkBAIC04MywxNiArODUsMTkgQEAKIAlidWYtPmJzX3VpZCA9IGRpYy0+ZGlfdWlkOwogCWJ1Zi0+YnNfZ2lkID0gZGljLT5kaV9naWQ7CiAJYnVmLT5ic19zaXplID0gZGljLT5kaV9zaXplOworCiAJLyoKLQkgKiBXZSBhcmUgcmVhZGluZyB0aGUgYXRpbWUgZnJvbSB0aGUgTGludXggaW5vZGUgYmVjYXVzZSB0aGUKLQkgKiBkaW5vZGUgbWlnaHQgbm90IGJlIHVwdG9kYXRlLgorCSAqIFdlIG5lZWQgdG8gcmVhZCB0aGUgdGltZXN0YW1wcyBmcm9tIHRoZSBMaW51eCBpbm9kZSBiZWNhdXNlCisJICogdGhlIFZGUyBrZWVwcyB3cml0aW5nIGRpcmVjdGx5IGludG8gdGhlIGlub2RlIHN0cnVjdHVyZSBpbnN0ZWFkCisJICogb2YgdGVsbGluZyB1cyBhYm91dCB0aGUgdXBkYXRlcy4KIAkgKi8KLQlidWYtPmJzX2F0aW1lLnR2X3NlYyA9IFZGU19JKGlwKS0+aV9hdGltZS50dl9zZWM7Ci0JYnVmLT5ic19hdGltZS50dl9uc2VjID0gVkZTX0koaXApLT5pX2F0aW1lLnR2X25zZWM7Ci0JYnVmLT5ic19tdGltZS50dl9zZWMgPSBkaWMtPmRpX210aW1lLnRfc2VjOwotCWJ1Zi0+YnNfbXRpbWUudHZfbnNlYyA9IGRpYy0+ZGlfbXRpbWUudF9uc2VjOwotCWJ1Zi0+YnNfY3RpbWUudHZfc2VjID0gZGljLT5kaV9jdGltZS50X3NlYzsKLQlidWYtPmJzX2N0aW1lLnR2X25zZWMgPSBkaWMtPmRpX2N0aW1lLnRfbnNlYzsKKwlidWYtPmJzX2F0aW1lLnR2X3NlYyA9IGlub2RlLT5pX2F0aW1lLnR2X3NlYzsKKwlidWYtPmJzX2F0aW1lLnR2X25zZWMgPSBpbm9kZS0+aV9hdGltZS50dl9uc2VjOworCWJ1Zi0+YnNfbXRpbWUudHZfc2VjID0gaW5vZGUtPmlfbXRpbWUudHZfc2VjOworCWJ1Zi0+YnNfbXRpbWUudHZfbnNlYyA9IGlub2RlLT5pX210aW1lLnR2X25zZWM7CisJYnVmLT5ic19jdGltZS50dl9zZWMgPSBpbm9kZS0+aV9jdGltZS50dl9zZWM7CisJYnVmLT5ic19jdGltZS50dl9uc2VjID0gaW5vZGUtPmlfY3RpbWUudHZfbnNlYzsKKwogCWJ1Zi0+YnNfeGZsYWdzID0geGZzX2lwMnhmbGFncyhpcCk7CiAJYnVmLT5ic19leHRzaXplID0gZGljLT5kaV9leHRzaXplIDw8IG1wLT5tX3NiLnNiX2Jsb2NrbG9nOwogCWJ1Zi0+YnNfZXh0ZW50cyA9IGRpYy0+ZGlfbmV4dGVudHM7CmRpZmYgLS1naXQgYS9mcy94ZnMveGZzX3Zub2Rlb3BzLmMgYi9mcy94ZnMveGZzX3Zub2Rlb3BzLmMKaW5kZXggYTQzNGYyOC4uYjU3MmY3ZSAxMDA2NDQKLS0tIGEvZnMveGZzL3hmc192bm9kZW9wcy5jCisrKyBiL2ZzL3hmcy94ZnNfdm5vZGVvcHMuYwpAQCAtMjQ3NiwxMiArMjQ3Niw2IEBACiAJQVNTRVJUKFhGU19GT1JDRURfU0hVVERPV04oaXAtPmlfbW91bnQpIHx8IGlwLT5pX2RlbGF5ZWRfYmxrcyA9PSAwKTsKIAogCS8qCi0JICogTWFrZSBzdXJlIHRoZSBhdGltZSBpbiB0aGUgWEZTIGlub2RlIGlzIGNvcnJlY3QgYmVmb3JlIGZyZWVpbmcgdGhlCi0JICogTGludXggaW5vZGUuCi0JICovCi0JeGZzX3N5bmNocm9uaXplX2F0aW1lKGlwKTsKLQotCS8qCiAJICogSWYgd2UgaGF2ZSBub3RoaW5nIHRvIGZsdXNoIHdpdGggdGhpcyBpbm9kZSB0aGVuIGNvbXBsZXRlIHRoZQogCSAqIHRlYXJkb3duIG5vdywgb3RoZXJ3aXNlIGJyZWFrIHRoZSBsaW5rIGJldHdlZW4gdGhlIHhmcyBpbm9kZSBhbmQgdGhlCiAJICogbGludXggaW5vZGUgYW5kIGNsZWFuIHVwIHRoZSB4ZnMgaW5vZGUgbGF0ZXIuIFRoaXMgYXZvaWRzIGZsdXNoaW5nCmRpZmYgLS1naXQgYS9pbmNsdWRlL2FzbS1nZW5lcmljL2hhcmRpcnEuaCBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvaGFyZGlycS5oCmluZGV4IDIzYmI0ZGEuLjYyZjU5MDggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvYXNtLWdlbmVyaWMvaGFyZGlycS5oCisrKyBiL2luY2x1ZGUvYXNtLWdlbmVyaWMvaGFyZGlycS5oCkBAIC02LDcgKzYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2lycS5oPgogCiB0eXBlZGVmIHN0cnVjdCB7Ci0JdW5zaWduZWQgbG9uZyBfX3NvZnRpcnFfcGVuZGluZzsKKwl1bnNpZ25lZCBpbnQgX19zb2Z0aXJxX3BlbmRpbmc7CiB9IF9fX19jYWNoZWxpbmVfYWxpZ25lZCBpcnFfY3B1c3RhdF90OwogCiAjaW5jbHVkZSA8bGludXgvaXJxX2NwdXN0YXQuaD4JLyogU3RhbmRhcmQgbWFwcGluZ3MgZm9yIGlycV9jcHVzdGF0X3QgYWJvdmUgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvS2J1aWxkIGIvaW5jbHVkZS9saW51eC9LYnVpbGQKaW5kZXggM2YzODRkNC4uMWZlZWQ3MSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9LYnVpbGQKKysrIGIvaW5jbHVkZS9saW51eC9LYnVpbGQKQEAgLTM2NCw2ICszNjQsNyBAQAogdW5pZmRlZi15ICs9IHZpZGVvZGV2Mi5oCiB1bmlmZGVmLXkgKz0gdmlkZW9kZXYuaAogdW5pZmRlZi15ICs9IHZpcnRpb19jb25maWcuaAordW5pZmRlZi15ICs9IHZpcnRpb19pZHMuaAogdW5pZmRlZi15ICs9IHZpcnRpb19ibGsuaAogdW5pZmRlZi15ICs9IHZpcnRpb19uZXQuaAogdW5pZmRlZi15ICs9IHZpcnRpb185cC5oCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oIGIvaW5jbHVkZS9saW51eC9ibGtkZXYuaAppbmRleCAyNTExOTA0Li4yMjFjZWNkIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L2Jsa2Rldi5oCisrKyBiL2luY2x1ZGUvbGludXgvYmxrZGV2LmgKQEAgLTExNzIsMTEgKzExNzIsNyBAQAogfQogCiBzdHJ1Y3Qgd29ya19zdHJ1Y3Q7Ci1zdHJ1Y3QgZGVsYXllZF93b3JrOwogaW50IGtibG9ja2Rfc2NoZWR1bGVfd29yayhzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSwgc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKTsKLWludCBrYmxvY2tkX3NjaGVkdWxlX2RlbGF5ZWRfd29yayhzdHJ1Y3QgcmVxdWVzdF9xdWV1ZSAqcSwKLQkJCQkJc3RydWN0IGRlbGF5ZWRfd29yayAqd29yaywKLQkJCQkgCXVuc2lnbmVkIGxvbmcgZGVsYXkpOwogCiAjZGVmaW5lIE1PRFVMRV9BTElBU19CTE9DS0RFVihtYWpvcixtaW5vcikgXAogCU1PRFVMRV9BTElBUygiYmxvY2stbWFqb3ItIiBfX3N0cmluZ2lmeShtYWpvcikgIi0iIF9fc3RyaW5naWZ5KG1pbm9yKSkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvY3B1ZnJlcS5oIGIvaW5jbHVkZS9saW51eC9jcHVmcmVxLmgKaW5kZXggNDQ3MTdlYi4uNzlhMjM0MCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9jcHVmcmVxLmgKKysrIGIvaW5jbHVkZS9saW51eC9jcHVmcmVxLmgKQEAgLTI5MSw4ICsyOTEsMTUgQEAKIGludCBjcHVmcmVxX2dldF9wb2xpY3koc3RydWN0IGNwdWZyZXFfcG9saWN5ICpwb2xpY3ksIHVuc2lnbmVkIGludCBjcHUpOwogaW50IGNwdWZyZXFfdXBkYXRlX3BvbGljeSh1bnNpZ25lZCBpbnQgY3B1KTsKIAorI2lmZGVmIENPTkZJR19DUFVfRlJFUQogLyogcXVlcnkgdGhlIGN1cnJlbnQgQ1BVIGZyZXF1ZW5jeSAoaW4ga0h6KS4gSWYgemVybywgY3B1ZnJlcSBjb3VsZG4ndCBkZXRlY3QgaXQgKi8KIHVuc2lnbmVkIGludCBjcHVmcmVxX2dldCh1bnNpZ25lZCBpbnQgY3B1KTsKKyNlbHNlCitzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGludCBjcHVmcmVxX2dldCh1bnNpZ25lZCBpbnQgY3B1KQoreworCXJldHVybiAwOworfQorI2VuZGlmCiAKIC8qIHF1ZXJ5IHRoZSBsYXN0IGtub3duIENQVSBmcmVxIChpbiBrSHopLiBJZiB6ZXJvLCBjcHVmcmVxIGNvdWxkbid0IGRldGVjdCBpdCAqLwogI2lmZGVmIENPTkZJR19DUFVfRlJFUQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9lbGYuaCBiL2luY2x1ZGUvbGludXgvZWxmLmgKaW5kZXggNDVhOTM3Yi4uOTBhNGVkMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9lbGYuaAorKysgYi9pbmNsdWRlL2xpbnV4L2VsZi5oCkBAIC0zNjEsNiArMzYxLDcgQEAKICNkZWZpbmUgTlRfUFBDX1ZTWAkweDEwMgkJLyogUG93ZXJQQyBWU1ggcmVnaXN0ZXJzICovCiAjZGVmaW5lIE5UXzM4Nl9UTFMJMHgyMDAJCS8qIGkzODYgVExTIHNsb3RzIChzdHJ1Y3QgdXNlcl9kZXNjKSAqLwogI2RlZmluZSBOVF8zODZfSU9QRVJNCTB4MjAxCQkvKiB4ODYgaW8gcGVybWlzc2lvbiBiaXRtYXAgKDE9ZGVueSkgKi8KKyNkZWZpbmUgTlRfUFJYU1RBVFVTCTB4MzAwCQkvKiBzMzkwIHVwcGVyIHJlZ2lzdGVyIGhhbHZlcyAqLwogCiAKIC8qIE5vdGUgaGVhZGVyIGluIGEgUFRfTk9URSBzZWN0aW9uICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2dlbmhkLmggYi9pbmNsdWRlL2xpbnV4L2dlbmhkLmgKaW5kZXggN2JlYWEyMS4uMjk3ZGY0NSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9nZW5oZC5oCisrKyBiL2luY2x1ZGUvbGludXgvZ2VuaGQuaApAQCAtOTgsNyArOTgsNyBAQAogCWludCBtYWtlX2l0X2ZhaWw7CiAjZW5kaWYKIAl1bnNpZ25lZCBsb25nIHN0YW1wOwotCWludCBpbl9mbGlnaHQ7CisJaW50IGluX2ZsaWdodFsyXTsKICNpZmRlZglDT05GSUdfU01QCiAJc3RydWN0IGRpc2tfc3RhdHMgKmRrc3RhdHM7CiAjZWxzZQpAQCAtMzIyLDE4ICszMjIsMjMgQEAKICNkZWZpbmUgcGFydF9zdGF0X3N1YihjcHUsIGdlbmRpc2twLCBmaWVsZCwgc3VibmQpCQkJXAogCXBhcnRfc3RhdF9hZGQoY3B1LCBnZW5kaXNrcCwgZmllbGQsIC1zdWJuZCkKIAotc3RhdGljIGlubGluZSB2b2lkIHBhcnRfaW5jX2luX2ZsaWdodChzdHJ1Y3QgaGRfc3RydWN0ICpwYXJ0KQorc3RhdGljIGlubGluZSB2b2lkIHBhcnRfaW5jX2luX2ZsaWdodChzdHJ1Y3QgaGRfc3RydWN0ICpwYXJ0LCBpbnQgcncpCiB7Ci0JcGFydC0+aW5fZmxpZ2h0Kys7CisJcGFydC0+aW5fZmxpZ2h0W3J3XSsrOwogCWlmIChwYXJ0LT5wYXJ0bm8pCi0JCXBhcnRfdG9fZGlzayhwYXJ0KS0+cGFydDAuaW5fZmxpZ2h0Kys7CisJCXBhcnRfdG9fZGlzayhwYXJ0KS0+cGFydDAuaW5fZmxpZ2h0W3J3XSsrOwogfQogCi1zdGF0aWMgaW5saW5lIHZvaWQgcGFydF9kZWNfaW5fZmxpZ2h0KHN0cnVjdCBoZF9zdHJ1Y3QgKnBhcnQpCitzdGF0aWMgaW5saW5lIHZvaWQgcGFydF9kZWNfaW5fZmxpZ2h0KHN0cnVjdCBoZF9zdHJ1Y3QgKnBhcnQsIGludCBydykKIHsKLQlwYXJ0LT5pbl9mbGlnaHQtLTsKKwlwYXJ0LT5pbl9mbGlnaHRbcnddLS07CiAJaWYgKHBhcnQtPnBhcnRubykKLQkJcGFydF90b19kaXNrKHBhcnQpLT5wYXJ0MC5pbl9mbGlnaHQtLTsKKwkJcGFydF90b19kaXNrKHBhcnQpLT5wYXJ0MC5pbl9mbGlnaHRbcnddLS07Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IHBhcnRfaW5fZmxpZ2h0KHN0cnVjdCBoZF9zdHJ1Y3QgKnBhcnQpCit7CisJcmV0dXJuIHBhcnQtPmluX2ZsaWdodFswXSArIHBhcnQtPmluX2ZsaWdodFsxXTsKIH0KIAogLyogYmxvY2svYmxrLWNvcmUuYyAqLwpAQCAtNTQ2LDYgKzU1MSw4IEBACiAJCQkgICAgICBzdHJ1Y3QgZGV2aWNlX2F0dHJpYnV0ZSAqYXR0ciwgY2hhciAqYnVmKTsKIGV4dGVybiBzc2l6ZV90IHBhcnRfc3RhdF9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwKIAkJCSAgICAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpOworZXh0ZXJuIHNzaXplX3QgcGFydF9pbmZsaWdodF9zaG93KHN0cnVjdCBkZXZpY2UgKmRldiwKKwkJCSAgICAgIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpOwogI2lmZGVmIENPTkZJR19GQUlMX01BS0VfUkVRVUVTVAogZXh0ZXJuIHNzaXplX3QgcGFydF9mYWlsX3Nob3coc3RydWN0IGRldmljZSAqZGV2LAogCQkJICAgICAgc3RydWN0IGRldmljZV9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1Zik7CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2kyYy90d2w0MDMwLmggYi9pbmNsdWRlL2xpbnV4L2kyYy90d2w0MDMwLmgKaW5kZXggMmQwMmRmZC4uNTA4ODI0ZWUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaTJjL3R3bDQwMzAuaAorKysgYi9pbmNsdWRlL2xpbnV4L2kyYy90d2w0MDMwLmgKQEAgLTM0OSwxMSArMzQ5LDExIEBACiAJaW50CQlpcnFfbGluZTsKIH07CiAKLS8qIEJvYXJkcyBoYXZlIHVuaXFlIG1hcHBpbmdzIG9mIHtjb2wsIHJvd30gLS0+IGtleWNvZGUuCi0gKiBDb2x1bW4gYW5kIHJvdyBhcmUgNCBiaXRzLCBidXQgcmFuZ2Ugb25seSBmcm9tIDAuLjcuCisvKiBCb2FyZHMgaGF2ZSB1bmlxZSBtYXBwaW5ncyBvZiB7cm93LCBjb2x9IC0tPiBrZXljb2RlLgorICogQ29sdW1uIGFuZCByb3cgYXJlIDggYml0cyBlYWNoLCBidXQgcmFuZ2Ugb25seSBmcm9tIDAuLjcuCiAgKiBhIFBFUlNJU1RFTlRfS0VZIGlzICJhbHdheXMgb24iIGFuZCBuZXZlciByZXBvcnRlZC4KICAqLwotI2RlZmluZSBQRVJTSVNURU5UX0tFWShjLCByKQlLRVkoKGMpLCAociksIEtFWV9SRVNFUlZFRCkKKyNkZWZpbmUgUEVSU0lTVEVOVF9LRVkociwgYykJS0VZKChyKSwgKGMpLCBLRVlfUkVTRVJWRUQpCiAKIHN0cnVjdCB0d2w0MDMwX2tleXBhZF9kYXRhIHsKIAljb25zdCBzdHJ1Y3QgbWF0cml4X2tleW1hcF9kYXRhICprZXltYXBfZGF0YTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvaW50ZXJydXB0LmggYi9pbmNsdWRlL2xpbnV4L2ludGVycnVwdC5oCmluZGV4IGI3OGNmODEuLjdjYTcyYjcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvaW50ZXJydXB0LmgKKysrIGIvaW5jbHVkZS9saW51eC9pbnRlcnJ1cHQuaApAQCAtMTAsNyArMTAsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2lycXJldHVybi5oPgogI2luY2x1ZGUgPGxpbnV4L2lycW5yLmg+CiAjaW5jbHVkZSA8bGludXgvaGFyZGlycS5oPgotI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvaXJxZmxhZ3MuaD4KICNpbmNsdWRlIDxsaW51eC9zbXAuaD4KICNpbmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KQEAgLTYxMCw2ICs2MDksNyBAQAogc3RhdGljIGlubGluZSB2b2lkIGRlYnVnX3BvbGxfYWxsX3NoYXJlZF9pcnFzKHZvaWQpIHsgfQogI2VuZGlmCiAKK3N0cnVjdCBzZXFfZmlsZTsKIGludCBzaG93X2ludGVycnVwdHMoc3RydWN0IHNlcV9maWxlICpwLCB2b2lkICp2KTsKIAogc3RydWN0IGlycV9kZXNjOwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9rZXJuZWwuaCBiL2luY2x1ZGUvbGludXgva2VybmVsLmgKaW5kZXggZDNjZDIzZi4uZjRlMzE4NCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9rZXJuZWwuaAorKysgYi9pbmNsdWRlL2xpbnV4L2tlcm5lbC5oCkBAIC02NTksNiArNjU5LDEyIEBACiAKICNlbmRpZiAvKiBfX0tFUk5FTF9fICovCiAKKyNpZm5kZWYgX19FWFBPUlRFRF9IRUFERVJTX18KKyNpZm5kZWYgX19LRVJORUxfXworI3dhcm5pbmcgQXR0ZW1wdCB0byB1c2Uga2VybmVsIGhlYWRlcnMgZnJvbSB1c2VyIHNwYWNlLCBzZWUgaHR0cDovL2tlcm5lbG5ld2JpZXMub3JnL0tlcm5lbEhlYWRlcnMKKyNlbmRpZiAvKiBfX0tFUk5FTF9fICovCisjZW5kaWYgLyogX19FWFBPUlRFRF9IRUFERVJTX18gKi8KKwogI2RlZmluZSBTSV9MT0FEX1NISUZUCTE2CiBzdHJ1Y3Qgc3lzaW5mbyB7CiAJbG9uZyB1cHRpbWU7CQkJLyogU2Vjb25kcyBzaW5jZSBib290ICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tYy9ob3N0LmggYi9pbmNsdWRlL2xpbnV4L21tYy9ob3N0LmgKaW5kZXggODFiYjQyMy4uZWFmMzYzNiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbWMvaG9zdC5oCisrKyBiL2luY2x1ZGUvbGludXgvbW1jL2hvc3QuaApAQCAtMTEsNiArMTEsNyBAQAogI2RlZmluZSBMSU5VWF9NTUNfSE9TVF9ICiAKICNpbmNsdWRlIDxsaW51eC9sZWRzLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KIAogI2luY2x1ZGUgPGxpbnV4L21tYy9jb3JlLmg+CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbmV0ZGV2aWNlLmggYi9pbmNsdWRlL2xpbnV4L25ldGRldmljZS5oCmluZGV4IDk0OTU4YzEuLjgxMmE1ZjMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbmV0ZGV2aWNlLmgKKysrIGIvaW5jbHVkZS9saW51eC9uZXRkZXZpY2UuaApAQCAtNTU3LDcgKzU1Nyw3IEBACiAgKglDYWxsYmFjayB1c2VzIHdoZW4gdGhlIHRyYW5zbWl0dGVyIGhhcyBub3QgbWFkZSBhbnkgcHJvZ3Jlc3MKICAqCWZvciBkZXYtPndhdGNoZG9nIHRpY2tzLgogICoKLSAqIHN0cnVjdCBuZXRfZGV2aWNlX3N0YXRzKiAoKmdldF9zdGF0cykoc3RydWN0IG5ldF9kZXZpY2UgKmRldik7CisgKiBzdHJ1Y3QgbmV0X2RldmljZV9zdGF0cyogKCpuZG9fZ2V0X3N0YXRzKShzdHJ1Y3QgbmV0X2RldmljZSAqZGV2KTsKICAqCUNhbGxlZCB3aGVuIGEgdXNlciB3YW50cyB0byBnZXQgdGhlIG5ldHdvcmsgZGV2aWNlIHVzYWdlCiAgKglzdGF0aXN0aWNzLiBJZiBub3QgZGVmaW5lZCwgdGhlIGNvdW50ZXJzIGluIGRldi0+c3RhdHMgd2lsbAogICoJYmUgdXNlZC4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGNpX2lkcy5oIGIvaW5jbHVkZS9saW51eC9wY2lfaWRzLmgKaW5kZXggZGExZmRhOC4uYjBmMGYzOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9wY2lfaWRzLmgKKysrIGIvaW5jbHVkZS9saW51eC9wY2lfaWRzLmgKQEAgLTM3OSw5ICszNzksNiBAQAogI2RlZmluZSBQQ0lfREVWSUNFX0lEX0FUSV9JWFA2MDBfSURFCTB4NDM4YwogI2RlZmluZSBQQ0lfREVWSUNFX0lEX0FUSV9JWFA3MDBfU0FUQQkweDQzOTAKICNkZWZpbmUgUENJX0RFVklDRV9JRF9BVElfSVhQNzAwX0lERQkweDQzOWMKLS8qIEFNRCBTQiBDaGlwc2V0ICovCi0jZGVmaW5lIFBDSV9ERVZJQ0VfSURfQU1EX1NCOTAwX0lERQkgMHg3ODBjCi0jZGVmaW5lIFBDSV9ERVZJQ0VfSURfQU1EX1NCOTAwX1NBVEFfSURFIDB4NzgwMAogCiAjZGVmaW5lIFBDSV9WRU5ET1JfSURfVkxTSQkJMHgxMDA0CiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfVkxTSV84MkM1OTIJMHgwMDA1CkBAIC00ODUsNiArNDgyLDkgQEAKICNkZWZpbmUgUENJX0RFVklDRV9JRF9JQk1fSUNPTV9WMl9PTkVfUE9SVF9SVlhfT05FX1BPUlRfTURNX1BDSUUgMHgwMzYxCiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfSUJNX0lDT01fRk9VUl9QT1JUX01PREVMCTB4MjUyCiAKKyNkZWZpbmUgUENJX1NVQlZFTkRPUl9JRF9JQk0JCTB4MTAxNAorI2RlZmluZSBQQ0lfU1VCREVWSUNFX0lEX0lCTV9TQVRVUk5fU0VSSUFMX09ORV9QT1JUCTB4MDNkNAorCiAjZGVmaW5lIFBDSV9WRU5ET1JfSURfVU5JU1lTCQkweDEwMTgKICNkZWZpbmUgUENJX0RFVklDRV9JRF9VTklTWVNfRE1BX0RJUkVDVE9SIDB4MDAxQwogCkBAIC01NTMsOSArNTUzLDEwIEBACiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfQU1EX0NTNTUzNl9VREMgICAgMHgyMDk2CiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfQU1EX0NTNTUzNl9VT0MgICAgMHgyMDk3CiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfQU1EX0NTNTUzNl9JREUgICAgMHgyMDlBCi0KICNkZWZpbmUgUENJX0RFVklDRV9JRF9BTURfTFhfVklERU8gIDB4MjA4MQogI2RlZmluZSBQQ0lfREVWSUNFX0lEX0FNRF9MWF9BRVMgICAgMHgyMDgyCisjZGVmaW5lIFBDSV9ERVZJQ0VfSURfQU1EX0hVRFNPTjJfSURFCQkweDc4MGMKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9BTURfSFVEU09OMl9TQVRBX0lERQkweDc4MDAKIAogI2RlZmluZSBQQ0lfVkVORE9SX0lEX1RSSURFTlQJCTB4MTAyMwogI2RlZmluZSBQQ0lfREVWSUNFX0lEX1RSSURFTlRfNERXQVZFX0RYCTB4MjAwMApAQCAtNzc2LDYgKzc3Nyw3IEBACiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfVElfWDUxNQkJMHg4MDM2CiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfVElfWFgxMgkJMHg4MDM5CiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfVElfWFgxMl9GTQkweDgwM2IKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9USV9YSU8yMDAwQQkweDgyMzEKICNkZWZpbmUgUENJX0RFVklDRV9JRF9USV8xMTMwCQkweGFjMTIKICNkZWZpbmUgUENJX0RFVklDRV9JRF9USV8xMDMxCQkweGFjMTMKICNkZWZpbmUgUENJX0RFVklDRV9JRF9USV8xMTMxCQkweGFjMTUKQEAgLTIxNjEsNiArMjE2MywxMCBAQAogI2RlZmluZSBQQ0lfREVWSUNFX0lEX0FERElEQVRBX0FQQ0k3NDIwXzMgICAgICAweDcwMEQKICNkZWZpbmUgUENJX0RFVklDRV9JRF9BRERJREFUQV9BUENJNzMwMF8zICAgICAgMHg3MDBFCiAjZGVmaW5lIFBDSV9ERVZJQ0VfSURfQURESURBVEFfQVBDSTc4MDBfMyAgICAgIDB4NzAwRgorI2RlZmluZSBQQ0lfREVWSUNFX0lEX0FERElEQVRBX0FQQ0llNzMwMCAgICAgICAweDcwMTAKKyNkZWZpbmUgUENJX0RFVklDRV9JRF9BRERJREFUQV9BUENJZTc0MjAgICAgICAgMHg3MDExCisjZGVmaW5lIFBDSV9ERVZJQ0VfSURfQURESURBVEFfQVBDSWU3NTAwICAgICAgIDB4NzAxMgorI2RlZmluZSBQQ0lfREVWSUNFX0lEX0FERElEQVRBX0FQQ0llNzgwMCAgICAgICAweDcwMTMKIAogI2RlZmluZSBQQ0lfVkVORE9SX0lEX1BEQwkJMHgxNWU5CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3RyaW5nLmggYi9pbmNsdWRlL2xpbnV4L3N0cmluZy5oCmluZGV4IDQ4OTAxOWUuLmI4NTA4ODYgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc3RyaW5nLmgKKysrIGIvaW5jbHVkZS9saW51eC9zdHJpbmcuaApAQCAtNjIsNyArNjIsNyBAQAogI2lmbmRlZiBfX0hBVkVfQVJDSF9TVFJSQ0hSCiBleHRlcm4gY2hhciAqIHN0cnJjaHIoY29uc3QgY2hhciAqLGludCk7CiAjZW5kaWYKLWV4dGVybiBjaGFyICogc3Ryc3RyaXAoY2hhciAqKTsKK2V4dGVybiBjaGFyICogX19tdXN0X2NoZWNrIHN0cnN0cmlwKGNoYXIgKik7CiAjaWZuZGVmIF9fSEFWRV9BUkNIX1NUUlNUUgogZXh0ZXJuIGNoYXIgKiBzdHJzdHIoY29uc3QgY2hhciAqLGNvbnN0IGNoYXIgKik7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdXNiL3NlcmlhbC5oIGIvaW5jbHVkZS9saW51eC91c2Ivc2VyaWFsLmgKaW5kZXggYzE3ZWI2NC4uY2U5MTFlYiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC91c2Ivc2VyaWFsLmgKKysrIGIvaW5jbHVkZS9saW51eC91c2Ivc2VyaWFsLmgKQEAgLTE1MCw2ICsxNTAsNyBAQAogCXN0cnVjdCB1c2JfaW50ZXJmYWNlCQkqaW50ZXJmYWNlOwogCXVuc2lnbmVkIGNoYXIJCQlkaXNjb25uZWN0ZWQ6MTsKIAl1bnNpZ25lZCBjaGFyCQkJc3VzcGVuZGluZzoxOworCXVuc2lnbmVkIGNoYXIJCQlhdHRhY2hlZDoxOwogCXVuc2lnbmVkIGNoYXIJCQltaW5vcjsKIAl1bnNpZ25lZCBjaGFyCQkJbnVtX3BvcnRzOwogCXVuc2lnbmVkIGNoYXIJCQludW1fcG9ydF9wb2ludGVyczsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdmlydGlvXzlwLmggYi9pbmNsdWRlL2xpbnV4L3ZpcnRpb185cC5oCmluZGV4IGVhNzIyNmEuLjA5NWUxMGQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdmlydGlvXzlwLmgKKysrIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fOXAuaApAQCAtMiw2ICsyLDcgQEAKICNkZWZpbmUgX0xJTlVYX1ZJUlRJT185UF9ICiAvKiBUaGlzIGhlYWRlciBpcyBCU0QgbGljZW5zZWQgc28gYW55b25lIGNhbiB1c2UgdGhlIGRlZmluaXRpb25zIHRvIGltcGxlbWVudAogICogY29tcGF0aWJsZSBkcml2ZXJzL3NlcnZlcnMuICovCisjaW5jbHVkZSA8bGludXgvdmlydGlvX2lkcy5oPgogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19jb25maWcuaD4KIAogLyogTWF4aW11bSBudW1iZXIgb2YgdmlydGlvIGNoYW5uZWxzIHBlciBwYXJ0aXRpb24gKDEgZm9yIG5vdykgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdmlydGlvX2JhbGxvb24uaCBiL2luY2x1ZGUvbGludXgvdmlydGlvX2JhbGxvb24uaAppbmRleCAwOWQ3MzAwLi4xNDE4ZjA0IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3ZpcnRpb19iYWxsb29uLmgKKysrIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fYmFsbG9vbi5oCkBAIC0yLDYgKzIsNyBAQAogI2RlZmluZSBfTElOVVhfVklSVElPX0JBTExPT05fSAogLyogVGhpcyBoZWFkZXIgaXMgQlNEIGxpY2Vuc2VkIHNvIGFueW9uZSBjYW4gdXNlIHRoZSBkZWZpbml0aW9ucyB0byBpbXBsZW1lbnQKICAqIGNvbXBhdGlibGUgZHJpdmVycy9zZXJ2ZXJzLiAqLworI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19pZHMuaD4KICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fY29uZmlnLmg+CiAKIC8qIFRoZSBmZWF0dXJlIGJpdG1hcCBmb3IgdmlydGlvIGJhbGxvb24gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdmlydGlvX2Jsay5oIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fYmxrLmgKaW5kZXggMTVjYjY2Ni4uZmQyOTRjNSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC92aXJ0aW9fYmxrLmgKKysrIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fYmxrLmgKQEAgLTMsNiArMyw3IEBACiAvKiBUaGlzIGhlYWRlciBpcyBCU0QgbGljZW5zZWQgc28gYW55b25lIGNhbiB1c2UgdGhlIGRlZmluaXRpb25zIHRvIGltcGxlbWVudAogICogY29tcGF0aWJsZSBkcml2ZXJzL3NlcnZlcnMuICovCiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW9faWRzLmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX2NvbmZpZy5oPgogCiAvKiBGZWF0dXJlIGJpdHMgKi8KQEAgLTEzLDExICsxNCw4IEBACiAjZGVmaW5lIFZJUlRJT19CTEtfRl9STwkJNQkvKiBEaXNrIGlzIHJlYWQtb25seSAqLwogI2RlZmluZSBWSVJUSU9fQkxLX0ZfQkxLX1NJWkUJNgkvKiBCbG9jayBzaXplIG9mIGRpc2sgaXMgYXZhaWxhYmxlKi8KICNkZWZpbmUgVklSVElPX0JMS19GX1NDU0kJNwkvKiBTdXBwb3J0cyBzY3NpIGNvbW1hbmQgcGFzc3RocnUgKi8KLSNkZWZpbmUgVklSVElPX0JMS19GX0lERU5USUZZCTgJLyogQVRBIElERU5USUZZIHN1cHBvcnRlZCAqLwogI2RlZmluZSBWSVJUSU9fQkxLX0ZfRkxVU0gJOQkvKiBDYWNoZSBmbHVzaCBjb21tYW5kIHN1cHBvcnQgKi8KIAotI2RlZmluZSBWSVJUSU9fQkxLX0lEX0JZVEVTCShzaXplb2YoX191MTZbMjU2XSkpCS8qIElERU5USUZZIERBVEEgKi8KLQogc3RydWN0IHZpcnRpb19ibGtfY29uZmlnIHsKIAkvKiBUaGUgY2FwYWNpdHkgKGluIDUxMi1ieXRlIHNlY3RvcnMpLiAqLwogCV9fdTY0IGNhcGFjaXR5OwpAQCAtMzMsNyArMzEsNiBAQAogCX0gZ2VvbWV0cnk7CiAJLyogYmxvY2sgc2l6ZSBvZiBkZXZpY2UgKGlmIFZJUlRJT19CTEtfRl9CTEtfU0laRSkgKi8KIAlfX3UzMiBibGtfc2l6ZTsKLQlfX3U4IGlkZW50aWZ5W1ZJUlRJT19CTEtfSURfQllURVNdOwogfSBfX2F0dHJpYnV0ZV9fKChwYWNrZWQpKTsKIAogLyoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdmlydGlvX2NvbnNvbGUuaCBiL2luY2x1ZGUvbGludXgvdmlydGlvX2NvbnNvbGUuaAppbmRleCBiNWY1MTk4Li5mZTg4NTE3IDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3ZpcnRpb19jb25zb2xlLmgKKysrIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fY29uc29sZS5oCkBAIC0xLDYgKzEsNyBAQAogI2lmbmRlZiBfTElOVVhfVklSVElPX0NPTlNPTEVfSAogI2RlZmluZSBfTElOVVhfVklSVElPX0NPTlNPTEVfSAogI2luY2x1ZGUgPGxpbnV4L3R5cGVzLmg+CisjaW5jbHVkZSA8bGludXgvdmlydGlvX2lkcy5oPgogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19jb25maWcuaD4KIC8qIFRoaXMgaGVhZGVyLCBleGNsdWRpbmcgdGhlICNpZmRlZiBfX0tFUk5FTF9fIHBhcnQsIGlzIEJTRCBsaWNlbnNlZCBzbwogICogYW55b25lIGNhbiB1c2UgdGhlIGRlZmluaXRpb25zIHRvIGltcGxlbWVudCBjb21wYXRpYmxlIGRyaXZlcnMvc2VydmVycy4gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdmlydGlvX25ldC5oIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fbmV0LmgKaW5kZXggMWY0MTczNC4uMDg1ZTQyMiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC92aXJ0aW9fbmV0LmgKKysrIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fbmV0LmgKQEAgLTMsNiArMyw3IEBACiAvKiBUaGlzIGhlYWRlciBpcyBCU0QgbGljZW5zZWQgc28gYW55b25lIGNhbiB1c2UgdGhlIGRlZmluaXRpb25zIHRvIGltcGxlbWVudAogICogY29tcGF0aWJsZSBkcml2ZXJzL3NlcnZlcnMuICovCiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW9faWRzLmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX2NvbmZpZy5oPgogI2luY2x1ZGUgPGxpbnV4L2lmX2V0aGVyLmg+CiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdmlydGlvX3JuZy5oIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fcm5nLmgKaW5kZXggNDgxMjFjMy4uYzRkNWRlOCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC92aXJ0aW9fcm5nLmgKKysrIGIvaW5jbHVkZS9saW51eC92aXJ0aW9fcm5nLmgKQEAgLTIsNiArMiw3IEBACiAjZGVmaW5lIF9MSU5VWF9WSVJUSU9fUk5HX0gKIC8qIFRoaXMgaGVhZGVyIGlzIEJTRCBsaWNlbnNlZCBzbyBhbnlvbmUgY2FuIHVzZSB0aGUgZGVmaW5pdGlvbnMgdG8gaW1wbGVtZW50CiAgKiBjb21wYXRpYmxlIGRyaXZlcnMvc2VydmVycy4gKi8KKyNpbmNsdWRlIDxsaW51eC92aXJ0aW9faWRzLmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX2NvbmZpZy5oPgogCiAjZW5kaWYgLyogX0xJTlVYX1ZJUlRJT19STkdfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC93b3JrcXVldWUuaCBiL2luY2x1ZGUvbGludXgvd29ya3F1ZXVlLmgKaW5kZXggN2VmMGM3Yi4uY2YyNGMyMCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC93b3JrcXVldWUuaAorKysgYi9pbmNsdWRlL2xpbnV4L3dvcmtxdWV1ZS5oCkBAIC0yMDcsNiArMjA3LDcgQEAKIAogZXh0ZXJuIHZvaWQgZmx1c2hfd29ya3F1ZXVlKHN0cnVjdCB3b3JrcXVldWVfc3RydWN0ICp3cSk7CiBleHRlcm4gdm9pZCBmbHVzaF9zY2hlZHVsZWRfd29yayh2b2lkKTsKK2V4dGVybiB2b2lkIGZsdXNoX2RlbGF5ZWRfd29yayhzdHJ1Y3QgZGVsYXllZF93b3JrICp3b3JrKTsKIAogZXh0ZXJuIGludCBzY2hlZHVsZV93b3JrKHN0cnVjdCB3b3JrX3N0cnVjdCAqd29yayk7CiBleHRlcm4gaW50IHNjaGVkdWxlX3dvcmtfb24oaW50IGNwdSwgc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L2luZXRfdGltZXdhaXRfc29jay5oIGIvaW5jbHVkZS9uZXQvaW5ldF90aW1ld2FpdF9zb2NrLmgKaW5kZXggYjYzYjgwZi4uZjkzYWQ5MCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9uZXQvaW5ldF90aW1ld2FpdF9zb2NrLmgKKysrIGIvaW5jbHVkZS9uZXQvaW5ldF90aW1ld2FpdF9zb2NrLmgKQEAgLTEzMCwxMSArMTMwLDExIEBACiAJX191MTYJCQl0d19udW07CiAJa21lbWNoZWNrX2JpdGZpZWxkX2JlZ2luKGZsYWdzKTsKIAkvKiBBbmQgdGhlc2UgYXJlIG91cnMuICovCi0JX191OAkJCXR3X2lwdjZvbmx5OjEsCi0JCQkJdHdfdHJhbnNwYXJlbnQ6MTsKLQkvKiAxNCBiaXRzIGhvbGUsIHRyeSB0byBwYWNrICovCisJdW5zaWduZWQgaW50CQl0d19pcHY2b25seSAgICAgOiAxLAorCQkJCXR3X3RyYW5zcGFyZW50ICA6IDEsCisJCQkJdHdfcGFkCQk6IDE0LAkvKiAxNCBiaXRzIGhvbGUgKi8KKwkJCQl0d19pcHY2X29mZnNldCAgOiAxNjsKIAlrbWVtY2hlY2tfYml0ZmllbGRfZW5kKGZsYWdzKTsKLQlfX3UxNgkJCXR3X2lwdjZfb2Zmc2V0OwogCXVuc2lnbmVkIGxvbmcJCXR3X3R0ZDsKIAlzdHJ1Y3QgaW5ldF9iaW5kX2J1Y2tldAkqdHdfdGI7CiAJc3RydWN0IGhsaXN0X25vZGUJdHdfZGVhdGhfbm9kZTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L21hYzgwMjExLmggYi9pbmNsdWRlL25ldC9tYWM4MDIxMS5oCmluZGV4IDQ2Njg1OWIuLmM3NWI5NjAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbmV0L21hYzgwMjExLmgKKysrIGIvaW5jbHVkZS9uZXQvbWFjODAyMTEuaApAQCAtMTY2OSw2ICsxNjY5LDggQEAKICAqIHRvIHRoaXMgZnVuY3Rpb24gYW5kIGllZWU4MDIxMV9yeF9pcnFzYWZlKCkgbWF5IG5vdCBiZSBtaXhlZCBmb3IgYQogICogc2luZ2xlIGhhcmR3YXJlLgogICoKKyAqIE5vdGUgdGhhdCByaWdodCBub3csIHRoaXMgZnVuY3Rpb24gbXVzdCBiZSBjYWxsZWQgd2l0aCBzb2Z0aXJxcyBkaXNhYmxlZC4KKyAqCiAgKiBAaHc6IHRoZSBoYXJkd2FyZSB0aGlzIGZyYW1lIGNhbWUgaW4gb24KICAqIEBza2I6IHRoZSBidWZmZXIgdG8gcmVjZWl2ZSwgb3duZWQgYnkgbWFjODAyMTEgYWZ0ZXIgdGhpcyBjYWxsCiAgKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUvbmV0L3NvY2suaCBiL2luY2x1ZGUvbmV0L3NvY2suaAppbmRleCAxNjIxOTM1Li45Zjk2Mzk0IDEwMDY0NAotLS0gYS9pbmNsdWRlL25ldC9zb2NrLmgKKysrIGIvaW5jbHVkZS9uZXQvc29jay5oCkBAIC0yMjYsMTIgKzIyNiwxMiBAQAogI2RlZmluZSBza19wcm90CQkJX19za19jb21tb24uc2tjX3Byb3QKICNkZWZpbmUgc2tfbmV0CQkJX19za19jb21tb24uc2tjX25ldAogCWttZW1jaGVja19iaXRmaWVsZF9iZWdpbihmbGFncyk7Ci0JdW5zaWduZWQgY2hhcgkJc2tfc2h1dGRvd24gOiAyLAotCQkJCXNrX25vX2NoZWNrIDogMiwKLQkJCQlza191c2VybG9ja3MgOiA0OworCXVuc2lnbmVkIGludAkJc2tfc2h1dGRvd24gIDogMiwKKwkJCQlza19ub19jaGVjayAgOiAyLAorCQkJCXNrX3VzZXJsb2NrcyA6IDQsCisJCQkJc2tfcHJvdG9jb2wgIDogOCwKKwkJCQlza190eXBlICAgICAgOiAxNjsKIAlrbWVtY2hlY2tfYml0ZmllbGRfZW5kKGZsYWdzKTsKLQl1bnNpZ25lZCBjaGFyCQlza19wcm90b2NvbDsKLQl1bnNpZ25lZCBzaG9ydAkJc2tfdHlwZTsKIAlpbnQJCQlza19yY3ZidWY7CiAJc29ja2V0X2xvY2tfdAkJc2tfbG9jazsKIAkvKgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zY3NpL2xpYmlzY3NpLmggYi9pbmNsdWRlL3Njc2kvbGliaXNjc2kuaAppbmRleCA4ODdlNTdlLi5hNzJlZGQ0IDEwMDY0NAotLS0gYS9pbmNsdWRlL3Njc2kvbGliaXNjc2kuaAorKysgYi9pbmNsdWRlL3Njc2kvbGliaXNjc2kuaApAQCAtMzAzLDYgKzMwMyw3IEBACiAJaW50CQkJY21kc19tYXg7CS8qIHNpemUgb2YgY21kcyBhcnJheSAqLwogCXN0cnVjdCBpc2NzaV90YXNrCSoqY21kczsJCS8qIE9yaWdpbmFsIENtZHMgYXJyICovCiAJc3RydWN0IGlzY3NpX3Bvb2wJY21kcG9vbDsJLyogUERVJ3MgcG9vbCAqLworCXZvaWQJCQkqZGRfZGF0YTsJLyogTExEIHByaXZhdGUgZGF0YSAqLwogfTsKIAogZW51bSB7CkBAIC0zNjMsNyArMzY0LDcgQEAKICAqLwogZXh0ZXJuIHN0cnVjdCBpc2NzaV9jbHNfc2Vzc2lvbiAqCiBpc2NzaV9zZXNzaW9uX3NldHVwKHN0cnVjdCBpc2NzaV90cmFuc3BvcnQgKiwgc3RydWN0IFNjc2lfSG9zdCAqc2hvc3QsCi0JCSAgICB1aW50MTZfdCwgaW50LCB1aW50MzJfdCwgdW5zaWduZWQgaW50KTsKKwkJICAgIHVpbnQxNl90LCBpbnQsIGludCwgdWludDMyX3QsIHVuc2lnbmVkIGludCk7CiBleHRlcm4gdm9pZCBpc2NzaV9zZXNzaW9uX3RlYXJkb3duKHN0cnVjdCBpc2NzaV9jbHNfc2Vzc2lvbiAqKTsKIGV4dGVybiB2b2lkIGlzY3NpX3Nlc3Npb25fcmVjb3ZlcnlfdGltZWRvdXQoc3RydWN0IGlzY3NpX2Nsc19zZXNzaW9uICopOwogZXh0ZXJuIGludCBpc2NzaV9zZXRfcGFyYW0oc3RydWN0IGlzY3NpX2Nsc19jb25uICpjbHNfY29ubiwKZGlmZiAtLWdpdCBhL2luY2x1ZGUvc2NzaS9zY3NpLmggYi9pbmNsdWRlL3Njc2kvc2NzaS5oCmluZGV4IDA4NDQ3OGUuLjM0YzQ2YWIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvc2NzaS9zY3NpLmgKKysrIGIvaW5jbHVkZS9zY3NpL3Njc2kuaApAQCAtMTI5LDYgKzEyOSw5IEBACiAjZGVmaW5lIE1JX1JFUE9SVF9UQVJHRVRfUEdTICAweDBhCiAvKiB2YWx1ZXMgZm9yIG1haW50ZW5hbmNlIG91dCAqLwogI2RlZmluZSBNT19TRVRfVEFSR0VUX1BHUyAgICAgMHgwYQorLyogdmFsdWVzIGZvciB2YXJpYWJsZSBsZW5ndGggY29tbWFuZCAqLworI2RlZmluZSBSRUFEXzMyCQkgICAgICAweDA5CisjZGVmaW5lIFdSSVRFXzMyCSAgICAgIDB4MGIKIAogLyogVmFsdWVzIGZvciBUMTAvMDQtMjYycjcgKi8KICNkZWZpbmUJQVRBXzE2CQkgICAgICAweDg1CS8qIDE2LWJ5dGUgcGFzcy10aHJ1ICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3Njc2kvc2NzaV9jbW5kLmggYi9pbmNsdWRlL3Njc2kvc2NzaV9jbW5kLmgKaW5kZXggMzg3OGQxZC4uYTVlODg1YSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zY3NpL3Njc2lfY21uZC5oCisrKyBiL2luY2x1ZGUvc2NzaS9zY3NpX2NtbmQuaApAQCAtMjI5LDEwICsyMjksNiBAQAogCS8qIE9TLUhCQTogUHJvdGVjdGVkLCBIQkEtVGFyZ2V0OiBQcm90ZWN0ZWQgKi8KIAlTQ1NJX1BST1RfUkVBRF9QQVNTLAogCVNDU0lfUFJPVF9XUklURV9QQVNTLAotCi0JLyogT1MtSEJBOiBQcm90ZWN0ZWQsIEhCQS1UYXJnZXQ6IFByb3RlY3RlZCwgY2hlY2tzdW0gY29udmVyc2lvbiAqLwotCVNDU0lfUFJPVF9SRUFEX0NPTlZFUlQsCi0JU0NTSV9QUk9UX1dSSVRFX0NPTlZFUlQsCiB9OwogCiBzdGF0aWMgaW5saW5lIHZvaWQgc2NzaV9zZXRfcHJvdF9vcChzdHJ1Y3Qgc2NzaV9jbW5kICpzY21kLCB1bnNpZ25lZCBjaGFyIG9wKQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9zY3NpL3Njc2lfaG9zdC5oIGIvaW5jbHVkZS9zY3NpL3Njc2lfaG9zdC5oCmluZGV4IGI2MmEwOTcuLjZlNzI4YjEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvc2NzaS9zY3NpX2hvc3QuaAorKysgYi9pbmNsdWRlL3Njc2kvc2NzaV9ob3N0LmgKQEAgLTc5OCw5ICs3OTgsMTUgQEAKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IHNjc2lfaG9zdF9kaWZfY2FwYWJsZShzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCwgdW5zaWduZWQgaW50IHRhcmdldF90eXBlKQogewogCXN3aXRjaCAodGFyZ2V0X3R5cGUpIHsKLQljYXNlIDE6IHJldHVybiBzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESUZfVFlQRTFfUFJPVEVDVElPTjsKLQljYXNlIDI6IHJldHVybiBzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESUZfVFlQRTJfUFJPVEVDVElPTjsKLQljYXNlIDM6IHJldHVybiBzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESUZfVFlQRTNfUFJPVEVDVElPTjsKKwljYXNlIDE6CisJCWlmIChzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESUZfVFlQRTFfUFJPVEVDVElPTikKKwkJCXJldHVybiB0YXJnZXRfdHlwZTsKKwljYXNlIDI6CisJCWlmIChzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESUZfVFlQRTJfUFJPVEVDVElPTikKKwkJCXJldHVybiB0YXJnZXRfdHlwZTsKKwljYXNlIDM6CisJCWlmIChzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESUZfVFlQRTNfUFJPVEVDVElPTikKKwkJCXJldHVybiB0YXJnZXRfdHlwZTsKIAl9CiAKIAlyZXR1cm4gMDsKQEAgLTgwOCwxMyArODE0LDE0IEBACiAKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgaW50IHNjc2lfaG9zdF9kaXhfY2FwYWJsZShzdHJ1Y3QgU2NzaV9Ib3N0ICpzaG9zdCwgdW5zaWduZWQgaW50IHRhcmdldF90eXBlKQogeworI2lmIGRlZmluZWQoQ09ORklHX0JMS19ERVZfSU5URUdSSVRZKQogCXN3aXRjaCAodGFyZ2V0X3R5cGUpIHsKIAljYXNlIDA6IHJldHVybiBzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESVhfVFlQRTBfUFJPVEVDVElPTjsKIAljYXNlIDE6IHJldHVybiBzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESVhfVFlQRTFfUFJPVEVDVElPTjsKIAljYXNlIDI6IHJldHVybiBzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESVhfVFlQRTJfUFJPVEVDVElPTjsKIAljYXNlIDM6IHJldHVybiBzaG9zdC0+cHJvdF9jYXBhYmlsaXRpZXMgJiBTSE9TVF9ESVhfVFlQRTNfUFJPVEVDVElPTjsKIAl9Ci0KKyNlbmRpZgogCXJldHVybiAwOwogfQogCmRpZmYgLS1naXQgYS9rZXJuZWwvY2dyb3VwLmMgYi9rZXJuZWwvY2dyb3VwLmMKaW5kZXggY2E4M2I3My4uMDI0OWY0YiAxMDA2NDQKLS0tIGEva2VybmVsL2Nncm91cC5jCisrKyBiL2tlcm5lbC9jZ3JvdXAuYwpAQCAtMTcxMCwxNCArMTcxMCwxMyBAQAogCQlyZXR1cm4gLUVGQVVMVDsKIAogCWJ1ZmZlcltuYnl0ZXNdID0gMDsgICAgIC8qIG51bC10ZXJtaW5hdGUgKi8KLQlzdHJzdHJpcChidWZmZXIpOwogCWlmIChjZnQtPndyaXRlX3U2NCkgewotCQl1NjQgdmFsID0gc2ltcGxlX3N0cnRvdWxsKGJ1ZmZlciwgJmVuZCwgMCk7CisJCXU2NCB2YWwgPSBzaW1wbGVfc3RydG91bGwoc3Ryc3RyaXAoYnVmZmVyKSwgJmVuZCwgMCk7CiAJCWlmICgqZW5kKQogCQkJcmV0dXJuIC1FSU5WQUw7CiAJCXJldHZhbCA9IGNmdC0+d3JpdGVfdTY0KGNncnAsIGNmdCwgdmFsKTsKIAl9IGVsc2UgewotCQlzNjQgdmFsID0gc2ltcGxlX3N0cnRvbGwoYnVmZmVyLCAmZW5kLCAwKTsKKwkJczY0IHZhbCA9IHNpbXBsZV9zdHJ0b2xsKHN0cnN0cmlwKGJ1ZmZlciksICZlbmQsIDApOwogCQlpZiAoKmVuZCkKIAkJCXJldHVybiAtRUlOVkFMOwogCQlyZXR2YWwgPSBjZnQtPndyaXRlX3M2NChjZ3JwLCBjZnQsIHZhbCk7CkBAIC0xNzUzLDggKzE3NTIsNyBAQAogCX0KIAogCWJ1ZmZlcltuYnl0ZXNdID0gMDsgICAgIC8qIG51bC10ZXJtaW5hdGUgKi8KLQlzdHJzdHJpcChidWZmZXIpOwotCXJldHZhbCA9IGNmdC0+d3JpdGVfc3RyaW5nKGNncnAsIGNmdCwgYnVmZmVyKTsKKwlyZXR2YWwgPSBjZnQtPndyaXRlX3N0cmluZyhjZ3JwLCBjZnQsIHN0cnN0cmlwKGJ1ZmZlcikpOwogCWlmICghcmV0dmFsKQogCQlyZXR2YWwgPSBuYnl0ZXM7CiBvdXQ6CmRpZmYgLS1naXQgYS9rZXJuZWwvZXhpdC5jIGIva2VybmVsL2V4aXQuYwppbmRleCBlNjE4OTFmLi5mNzg2NGFjIDEwMDY0NAotLS0gYS9rZXJuZWwvZXhpdC5jCisrKyBiL2tlcm5lbC9leGl0LmMKQEAgLTM1OSwxMCArMzU5LDggQEAKIHsKIAlzdHJ1Y3QgdGFza19zdHJ1Y3QgKmN1cnIgPSBjdXJyZW50LT5ncm91cF9sZWFkZXI7CiAKLQlpZiAodGFza19zZXNzaW9uKGN1cnIpICE9IHBpZCkgeworCWlmICh0YXNrX3Nlc3Npb24oY3VycikgIT0gcGlkKQogCQljaGFuZ2VfcGlkKGN1cnIsIFBJRFRZUEVfU0lELCBwaWQpOwotCQlwcm9jX3NpZF9jb25uZWN0b3IoY3Vycik7Ci0JfQogCiAJaWYgKHRhc2tfcGdycChjdXJyKSAhPSBwaWQpCiAJCWNoYW5nZV9waWQoY3VyciwgUElEVFlQRV9QR0lELCBwaWQpOwpkaWZmIC0tZ2l0IGEva2VybmVsL2lycS9oYW5kbGUuYyBiL2tlcm5lbC9pcnEvaGFuZGxlLmMKaW5kZXggYTgxY2Y4MC4uMTdjNzFiYiAxMDA2NDQKLS0tIGEva2VybmVsL2lycS9oYW5kbGUuYworKysgYi9rZXJuZWwvaXJxL2hhbmRsZS5jCkBAIC0xMSw2ICsxMSw3IEBACiAgKi8KIAogI2luY2x1ZGUgPGxpbnV4L2lycS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3JhbmRvbS5oPgpkaWZmIC0tZ2l0IGEva2VybmVsL2xvY2tkZXAuYyBiL2tlcm5lbC9sb2NrZGVwLmMKaW5kZXggMzgxNWFjMWQuLjlhZjU2NzIgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9sb2NrZGVwLmMKKysrIGIva2VybmVsL2xvY2tkZXAuYwpAQCAtMTQyLDYgKzE0MiwxMSBAQAogI2lmZGVmIENPTkZJR19MT0NLX1NUQVQKIHN0YXRpYyBERUZJTkVfUEVSX0NQVShzdHJ1Y3QgbG9ja19jbGFzc19zdGF0c1tNQVhfTE9DS0RFUF9LRVlTXSwgbG9ja19zdGF0cyk7CiAKK3N0YXRpYyBpbmxpbmUgdTY0IGxvY2tzdGF0X2Nsb2NrKHZvaWQpCit7CisJcmV0dXJuIGNwdV9jbG9jayhzbXBfcHJvY2Vzc29yX2lkKCkpOworfQorCiBzdGF0aWMgaW50IGxvY2tfcG9pbnQodW5zaWduZWQgbG9uZyBwb2ludHNbXSwgdW5zaWduZWQgbG9uZyBpcCkKIHsKIAlpbnQgaTsKQEAgLTE1OCw3ICsxNjMsNyBAQAogCXJldHVybiBpOwogfQogCi1zdGF0aWMgdm9pZCBsb2NrX3RpbWVfaW5jKHN0cnVjdCBsb2NrX3RpbWUgKmx0LCBzNjQgdGltZSkKK3N0YXRpYyB2b2lkIGxvY2tfdGltZV9pbmMoc3RydWN0IGxvY2tfdGltZSAqbHQsIHU2NCB0aW1lKQogewogCWlmICh0aW1lID4gbHQtPm1heCkKIAkJbHQtPm1heCA9IHRpbWU7CkBAIC0yMzQsMTIgKzIzOSwxMiBAQAogc3RhdGljIHZvaWQgbG9ja19yZWxlYXNlX2hvbGR0aW1lKHN0cnVjdCBoZWxkX2xvY2sgKmhsb2NrKQogewogCXN0cnVjdCBsb2NrX2NsYXNzX3N0YXRzICpzdGF0czsKLQlzNjQgaG9sZHRpbWU7CisJdTY0IGhvbGR0aW1lOwogCiAJaWYgKCFsb2NrX3N0YXQpCiAJCXJldHVybjsKIAotCWhvbGR0aW1lID0gc2NoZWRfY2xvY2soKSAtIGhsb2NrLT5ob2xkdGltZV9zdGFtcDsKKwlob2xkdGltZSA9IGxvY2tzdGF0X2Nsb2NrKCkgLSBobG9jay0+aG9sZHRpbWVfc3RhbXA7CiAKIAlzdGF0cyA9IGdldF9sb2NrX3N0YXRzKGhsb2NrX2NsYXNzKGhsb2NrKSk7CiAJaWYgKGhsb2NrLT5yZWFkKQpAQCAtMjc5Miw3ICsyNzk3LDcgQEAKIAlobG9jay0+cmVmZXJlbmNlcyA9IHJlZmVyZW5jZXM7CiAjaWZkZWYgQ09ORklHX0xPQ0tfU1RBVAogCWhsb2NrLT53YWl0dGltZV9zdGFtcCA9IDA7Ci0JaGxvY2stPmhvbGR0aW1lX3N0YW1wID0gc2NoZWRfY2xvY2soKTsKKwlobG9jay0+aG9sZHRpbWVfc3RhbXAgPSBsb2Nrc3RhdF9jbG9jaygpOwogI2VuZGlmCiAKIAlpZiAoY2hlY2sgPT0gMiAmJiAhbWFya19pcnFmbGFncyhjdXJyLCBobG9jaykpCkBAIC0zMzIyLDcgKzMzMjcsNyBAQAogCWlmIChobG9jay0+aW5zdGFuY2UgIT0gbG9jaykKIAkJcmV0dXJuOwogCi0JaGxvY2stPndhaXR0aW1lX3N0YW1wID0gc2NoZWRfY2xvY2soKTsKKwlobG9jay0+d2FpdHRpbWVfc3RhbXAgPSBsb2Nrc3RhdF9jbG9jaygpOwogCiAJY29udGVudGlvbl9wb2ludCA9IGxvY2tfcG9pbnQoaGxvY2tfY2xhc3MoaGxvY2spLT5jb250ZW50aW9uX3BvaW50LCBpcCk7CiAJY29udGVuZGluZ19wb2ludCA9IGxvY2tfcG9pbnQoaGxvY2tfY2xhc3MoaGxvY2spLT5jb250ZW5kaW5nX3BvaW50LApAQCAtMzM0NSw4ICszMzUwLDcgQEAKIAlzdHJ1Y3QgaGVsZF9sb2NrICpobG9jaywgKnByZXZfaGxvY2s7CiAJc3RydWN0IGxvY2tfY2xhc3Nfc3RhdHMgKnN0YXRzOwogCXVuc2lnbmVkIGludCBkZXB0aDsKLQl1NjQgbm93OwotCXM2NCB3YWl0dGltZSA9IDA7CisJdTY0IG5vdywgd2FpdHRpbWUgPSAwOwogCWludCBpLCBjcHU7CiAKIAlkZXB0aCA9IGN1cnItPmxvY2tkZXBfZGVwdGg7CkBAIC0zMzc0LDcgKzMzNzgsNyBAQAogCiAJY3B1ID0gc21wX3Byb2Nlc3Nvcl9pZCgpOwogCWlmIChobG9jay0+d2FpdHRpbWVfc3RhbXApIHsKLQkJbm93ID0gc2NoZWRfY2xvY2soKTsKKwkJbm93ID0gbG9ja3N0YXRfY2xvY2soKTsKIAkJd2FpdHRpbWUgPSBub3cgLSBobG9jay0+d2FpdHRpbWVfc3RhbXA7CiAJCWhsb2NrLT5ob2xkdGltZV9zdGFtcCA9IG5vdzsKIAl9CmRpZmYgLS1naXQgYS9rZXJuZWwvbXV0ZXgtZGVidWcuYyBiL2tlcm5lbC9tdXRleC1kZWJ1Zy5jCmluZGV4IDUwZDAyMmUuLmVjODE1YTkgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9tdXRleC1kZWJ1Zy5jCisrKyBiL2tlcm5lbC9tdXRleC1kZWJ1Zy5jCkBAIC0xNiw2ICsxNiw3IEBACiAjaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9wb2lzb24uaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiAjaW5jbHVkZSA8bGludXgva2FsbHN5bXMuaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KZGlmZiAtLWdpdCBhL2tlcm5lbC9wb3dlci9zdXNwZW5kX3Rlc3QuYyBiL2tlcm5lbC9wb3dlci9zdXNwZW5kX3Rlc3QuYwppbmRleCAxN2Q4YmIxLi4yNTU5NmU0IDEwMDY0NAotLS0gYS9rZXJuZWwvcG93ZXIvc3VzcGVuZF90ZXN0LmMKKysrIGIva2VybmVsL3Bvd2VyL3N1c3BlbmRfdGVzdC5jCkBAIC0xOSw3ICsxOSw3IEBACiAgKiBUaGUgdGltZSBpdCB0YWtlcyBpcyBzeXN0ZW0tc3BlY2lmaWMgdGhvdWdoLCBzbyB3aGVuIHdlIHRlc3QgdGhpcwogICogZHVyaW5nIHN5c3RlbSBib290dXAgd2UgYWxsb3cgYSBMT1Qgb2YgdGltZS4KICAqLwotI2RlZmluZSBURVNUX1NVU1BFTkRfU0VDT05EUwk1CisjZGVmaW5lIFRFU1RfU1VTUEVORF9TRUNPTkRTCTEwCiAKIHN0YXRpYyB1bnNpZ25lZCBsb25nIHN1c3BlbmRfdGVzdF9zdGFydF90aW1lOwogCkBAIC00OSw3ICs0OSw4IEBACiAJICogaGFzIHNvbWUgcGVyZm9ybWFuY2UgaXNzdWVzLiAgVGhlIHN0YWNrIGR1bXAgb2YgYSBXQVJOX09OCiAJICogaXMgbW9yZSBsaWtlbHkgdG8gZ2V0IHRoZSByaWdodCBhdHRlbnRpb24gdGhhbiBhIHByaW50ay4uLgogCSAqLwotCVdBUk4obXNlYyA+IChURVNUX1NVU1BFTkRfU0VDT05EUyAqIDEwMDApLCAiQ29tcG9uZW50OiAlc1xuIiwgbGFiZWwpOworCVdBUk4obXNlYyA+IChURVNUX1NVU1BFTkRfU0VDT05EUyAqIDEwMDApLAorCSAgICAgIkNvbXBvbmVudDogJXMsIHRpbWU6ICV1XG4iLCBsYWJlbCwgbXNlYyk7CiB9CiAKIC8qCmRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWQuYyBiL2tlcm5lbC9zY2hlZC5jCmluZGV4IDc4OTAwMWQuLmU4ODY4OTUgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zY2hlZC5jCisrKyBiL2tlcm5lbC9zY2hlZC5jCkBAIC02NzI0LDkgKzY3MjQsNiBAQAogLyoKICAqIFRoaXMgdGFzayBpcyBhYm91dCB0byBnbyB0byBzbGVlcCBvbiBJTy4gSW5jcmVtZW50IHJxLT5ucl9pb3dhaXQgc28KICAqIHRoYXQgcHJvY2VzcyBhY2NvdW50aW5nIGtub3dzIHRoYXQgdGhpcyBpcyBhIHRhc2sgaW4gSU8gd2FpdCBzdGF0ZS4KLSAqCi0gKiBCdXQgZG9uJ3QgZG8gdGhhdCBpZiBpdCBpcyBhIGRlbGliZXJhdGUsIHRocm90dGxpbmcgSU8gd2FpdCAodGhpcyB0YXNrCi0gKiBoYXMgc2V0IGl0cyBiYWNraW5nX2Rldl9pbmZvOiB0aGUgcXVldWUgYWdhaW5zdCB3aGljaCBpdCBzaG91bGQgdGhyb3R0bGUpCiAgKi8KIHZvaWQgX19zY2hlZCBpb19zY2hlZHVsZSh2b2lkKQogewpkaWZmIC0tZ2l0IGEva2VybmVsL3N5cy5jIGIva2VybmVsL3N5cy5jCmluZGV4IDI1NTQ3NWQuLjE4MjhmOGQgMTAwNjQ0Ci0tLSBhL2tlcm5lbC9zeXMuYworKysgYi9rZXJuZWwvc3lzLmMKQEAgLTExMTAsNiArMTExMCw4IEBACiAJZXJyID0gc2Vzc2lvbjsKIG91dDoKIAl3cml0ZV91bmxvY2tfaXJxKCZ0YXNrbGlzdF9sb2NrKTsKKwlpZiAoZXJyID4gMCkKKwkJcHJvY19zaWRfY29ubmVjdG9yKGdyb3VwX2xlYWRlcik7CiAJcmV0dXJuIGVycjsKIH0KIApkaWZmIC0tZ2l0IGEva2VybmVsL3N5c2N0bF9jaGVjay5jIGIva2VybmVsL3N5c2N0bF9jaGVjay5jCmluZGV4IGIzODQyM2MuLmI2ZTdhYWVhIDEwMDY0NAotLS0gYS9rZXJuZWwvc3lzY3RsX2NoZWNrLmMKKysrIGIva2VybmVsL3N5c2N0bF9jaGVjay5jCkBAIC0xNTIxLDcgKzE1MjEsNyBAQAogCQkJaWYgKCF0YWJsZS0+Y3RsX25hbWUgJiYgdGFibGUtPnN0cmF0ZWd5KQogCQkJCXNldF9mYWlsKCZmYWlsLCB0YWJsZSwgIlN0cmF0ZWd5IHdpdGhvdXQgY3RsX25hbWUiKTsKICNlbmRpZgotI2lmZGVmIENPTkZJR19QUk9DX0ZTCisjaWZkZWYgQ09ORklHX1BST0NfU1lTQ1RMCiAJCQlpZiAodGFibGUtPnByb2NuYW1lICYmICF0YWJsZS0+cHJvY19oYW5kbGVyKQogCQkJCXNldF9mYWlsKCZmYWlsLCB0YWJsZSwgIk5vIHByb2NfaGFuZGxlciIpOwogI2VuZGlmCmRpZmYgLS1naXQgYS9rZXJuZWwvdGltZS90aW1la2VlcGluZy5jIGIva2VybmVsL3RpbWUvdGltZWtlZXBpbmcuYwppbmRleCBmYjBmNDZmLi5jM2E0ZTI5IDEwMDY0NAotLS0gYS9rZXJuZWwvdGltZS90aW1la2VlcGluZy5jCisrKyBiL2tlcm5lbC90aW1lL3RpbWVrZWVwaW5nLmMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlIDxsaW51eC9wZXJjcHUuaD4KICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3N5c2Rldi5oPgogI2luY2x1ZGUgPGxpbnV4L2Nsb2Nrc291cmNlLmg+CiAjaW5jbHVkZSA8bGludXgvamlmZmllcy5oPgpkaWZmIC0tZ2l0IGEva2VybmVsL3RyYWNlL3RyYWNlLmMgYi9rZXJuZWwvdHJhY2UvdHJhY2UuYwppbmRleCA0NTA2ODI2Li5jODIwYjAzIDEwMDY0NAotLS0gYS9rZXJuZWwvdHJhY2UvdHJhY2UuYworKysgYi9rZXJuZWwvdHJhY2UvdHJhY2UuYwpAQCAtMTM5Myw3ICsxMzkzLDcgQEAKIAogaW50IHRyYWNlX3ZwcmludGsodW5zaWduZWQgbG9uZyBpcCwgY29uc3QgY2hhciAqZm10LCB2YV9saXN0IGFyZ3MpCiB7Ci0JcmV0dXJuIHRyYWNlX2FycmF5X3ByaW50aygmZ2xvYmFsX3RyYWNlLCBpcCwgZm10LCBhcmdzKTsKKwlyZXR1cm4gdHJhY2VfYXJyYXlfdnByaW50aygmZ2xvYmFsX3RyYWNlLCBpcCwgZm10LCBhcmdzKTsKIH0KIEVYUE9SVF9TWU1CT0xfR1BMKHRyYWNlX3ZwcmludGspOwogCmRpZmYgLS1naXQgYS9rZXJuZWwvdHJhY2UvdHJhY2VfZXZlbnRzX2ZpbHRlci5jIGIva2VybmVsL3RyYWNlL3RyYWNlX2V2ZW50c19maWx0ZXIuYwppbmRleCAyMzI0NTc4Li45OGE2Y2M1IDEwMDY0NAotLS0gYS9rZXJuZWwvdHJhY2UvdHJhY2VfZXZlbnRzX2ZpbHRlci5jCisrKyBiL2tlcm5lbC90cmFjZS90cmFjZV9ldmVudHNfZmlsdGVyLmMKQEAgLTkzMyw4ICs5MzMsOSBAQAogCiAJd2hpbGUgKCFsaXN0X2VtcHR5KCZwcy0+cG9zdGZpeCkpIHsKIAkJZWx0ID0gbGlzdF9maXJzdF9lbnRyeSgmcHMtPnBvc3RmaXgsIHN0cnVjdCBwb3N0Zml4X2VsdCwgbGlzdCk7Ci0JCWtmcmVlKGVsdC0+b3BlcmFuZCk7CiAJCWxpc3RfZGVsKCZlbHQtPmxpc3QpOworCQlrZnJlZShlbHQtPm9wZXJhbmQpOworCQlrZnJlZShlbHQpOwogCX0KIH0KIApkaWZmIC0tZ2l0IGEva2VybmVsL3dvcmtxdWV1ZS5jIGIva2VybmVsL3dvcmtxdWV1ZS5jCmluZGV4IGFkZGZlMmQuLjQ3Y2RkN2UgMTAwNjQ0Ci0tLSBhL2tlcm5lbC93b3JrcXVldWUuYworKysgYi9rZXJuZWwvd29ya3F1ZXVlLmMKQEAgLTY0MCw2ICs2NDAsMjQgQEAKIEVYUE9SVF9TWU1CT0woc2NoZWR1bGVfZGVsYXllZF93b3JrKTsKIAogLyoqCisgKiBmbHVzaF9kZWxheWVkX3dvcmsgLSBibG9jayB1bnRpbCBhIGR3b3JrX3N0cnVjdCdzIGNhbGxiYWNrIGhhcyB0ZXJtaW5hdGVkCisgKiBAZHdvcms6IHRoZSBkZWxheWVkIHdvcmsgd2hpY2ggaXMgdG8gYmUgZmx1c2hlZAorICoKKyAqIEFueSB0aW1lb3V0IGlzIGNhbmNlbGxlZCwgYW5kIGFueSBwZW5kaW5nIHdvcmsgaXMgcnVuIGltbWVkaWF0ZWx5LgorICovCit2b2lkIGZsdXNoX2RlbGF5ZWRfd29yayhzdHJ1Y3QgZGVsYXllZF93b3JrICpkd29yaykKK3sKKwlpZiAoZGVsX3RpbWVyX3N5bmMoJmR3b3JrLT50aW1lcikpIHsKKwkJc3RydWN0IGNwdV93b3JrcXVldWVfc3RydWN0ICpjd3E7CisJCWN3cSA9IHdxX3Blcl9jcHUoa2V2ZW50ZF93cSwgZ2V0X2NwdSgpKTsKKwkJX19xdWV1ZV93b3JrKGN3cSwgJmR3b3JrLT53b3JrKTsKKwkJcHV0X2NwdSgpOworCX0KKwlmbHVzaF93b3JrKCZkd29yay0+d29yayk7Cit9CitFWFBPUlRfU1lNQk9MKGZsdXNoX2RlbGF5ZWRfd29yayk7CisKKy8qKgogICogc2NoZWR1bGVfZGVsYXllZF93b3JrX29uIC0gcXVldWUgd29yayBpbiBnbG9iYWwgd29ya3F1ZXVlIG9uIENQVSBhZnRlciBkZWxheQogICogQGNwdTogY3B1IHRvIHVzZQogICogQGR3b3JrOiBqb2IgdG8gYmUgZG9uZQpkaWZmIC0tZ2l0IGEvbGliL0tjb25maWcuZGVidWcgYi9saWIvS2NvbmZpZy5kZWJ1ZwppbmRleCA4OTExNTU4Li4zMGRmNTg2IDEwMDY0NAotLS0gYS9saWIvS2NvbmZpZy5kZWJ1ZworKysgYi9saWIvS2NvbmZpZy5kZWJ1ZwpAQCAtMzQ2LDggKzM0Niw5IEBACiAKIGNvbmZpZyBERUJVR19LTUVNTEVBSwogCWJvb2wgIktlcm5lbCBtZW1vcnkgbGVhayBkZXRlY3RvciIKLQlkZXBlbmRzIG9uIERFQlVHX0tFUk5FTCAmJiBFWFBFUklNRU5UQUwgJiYgKFg4NiB8fCBBUk0gfHwgUFBDKSAmJiBcCi0JCSFNRU1PUllfSE9UUExVRworCWRlcGVuZHMgb24gREVCVUdfS0VSTkVMICYmIEVYUEVSSU1FTlRBTCAmJiAhTUVNT1JZX0hPVFBMVUcgJiYgXAorCQkoWDg2IHx8IEFSTSB8fCBQUEMgfHwgUzM5MCkKKwogCXNlbGVjdCBERUJVR19GUyBpZiBTWVNGUwogCXNlbGVjdCBTVEFDS1RSQUNFIGlmIFNUQUNLVFJBQ0VfU1VQUE9SVAogCXNlbGVjdCBLQUxMU1lNUwpAQCAtMzcwLDcgKzM3MSw3IEBACiBjb25maWcgREVCVUdfS01FTUxFQUtfRUFSTFlfTE9HX1NJWkUKIAlpbnQgIk1heGltdW0ga21lbWxlYWsgZWFybHkgbG9nIGVudHJpZXMiCiAJZGVwZW5kcyBvbiBERUJVR19LTUVNTEVBSwotCXJhbmdlIDIwMCAyMDAwCisJcmFuZ2UgMjAwIDQwMDAwCiAJZGVmYXVsdCA0MDAKIAloZWxwCiAJICBLbWVtbGVhayBtdXN0IHRyYWNrIGFsbCB0aGUgbWVtb3J5IGFsbG9jYXRpb25zIHRvIGF2b2lkCmRpZmYgLS1naXQgYS9saWIvZGVidWdvYmplY3RzLmMgYi9saWIvZGVidWdvYmplY3RzLmMKaW5kZXggMjc1NWEzYi4uZWFlNTZmZCAxMDA2NDQKLS0tIGEvbGliL2RlYnVnb2JqZWN0cy5jCisrKyBiL2xpYi9kZWJ1Z29iamVjdHMuYwpAQCAtOSw2ICs5LDcgQEAKICAqLwogI2luY2x1ZGUgPGxpbnV4L2RlYnVnb2JqZWN0cy5oPgogI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KICNpbmNsdWRlIDxsaW51eC9kZWJ1Z2ZzLmg+CiAjaW5jbHVkZSA8bGludXgvaGFzaC5oPgpkaWZmIC0tZ2l0IGEvbGliL2ZhdWx0LWluamVjdC5jIGIvbGliL2ZhdWx0LWluamVjdC5jCmluZGV4IGY5N2FmNTViLi43ZTY1YWY3IDEwMDY0NAotLS0gYS9saWIvZmF1bHQtaW5qZWN0LmMKKysrIGIvbGliL2ZhdWx0LWluamVjdC5jCkBAIC0xLDYgKzEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KICNpbmNsdWRlIDxsaW51eC9yYW5kb20uaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPGxpbnV4L3N0YXQuaD4KICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L2ZzLmg+CmRpZmYgLS1naXQgYS9tbS9LY29uZmlnIGIvbW0vS2NvbmZpZwppbmRleCA1Nzk2M2M2Li5mNzkxMTk2IDEwMDY0NAotLS0gYS9tbS9LY29uZmlnCisrKyBiL21tL0tjb25maWcKQEAgLTY3LDcgKzY3LDcgQEAKIAogY29uZmlnIFNQQVJTRU1FTQogCWRlZl9ib29sIHkKLQlkZXBlbmRzIG9uIFNQQVJTRU1FTV9NQU5VQUwKKwlkZXBlbmRzIG9uICghU0VMRUNUX01FTU9SWV9NT0RFTCAmJiBBUkNIX1NQQVJTRU1FTV9FTkFCTEUpIHx8IFNQQVJTRU1FTV9NQU5VQUwKIAogY29uZmlnIEZMQVRNRU0KIAlkZWZfYm9vbCB5CmRpZmYgLS1naXQgYS9tbS9iYWNraW5nLWRldi5jIGIvbW0vYmFja2luZy1kZXYuYwppbmRleCAzZDNhY2NiLi41YTM3ZTIwIDEwMDY0NAotLS0gYS9tbS9iYWNraW5nLWRldi5jCisrKyBiL21tL2JhY2tpbmctZGV2LmMKQEAgLTkyLDcgKzkyLDcgQEAKIAkJICAgIkJkaURpcnR5VGhyZXNoOiAgICU4bHUga0JcbiIKIAkJICAgIkRpcnR5VGhyZXNoOiAgICAgICU4bHUga0JcbiIKIAkJICAgIkJhY2tncm91bmRUaHJlc2g6ICU4bHUga0JcbiIKLQkJICAgIldyaXRlQmFjayB0aHJlYWRzOiU4bHVcbiIKKwkJICAgIldyaXRlYmFja1RocmVhZHM6ICU4bHVcbiIKIAkJICAgImJfZGlydHk6ICAgICAgICAgICU4bHVcbiIKIAkJICAgImJfaW86ICAgICAgICAgICAgICU4bHVcbiIKIAkJICAgImJfbW9yZV9pbzogICAgICAgICU4bHVcbiIKZGlmZiAtLWdpdCBhL21tL2ttZW1sZWFrLmMgYi9tbS9rbWVtbGVhay5jCmluZGV4IDRlYTQ1MTAuLjhiZjc2NWMgMTAwNjQ0Ci0tLSBhL21tL2ttZW1sZWFrLmMKKysrIGIvbW0va21lbWxlYWsuYwpAQCAtODMzLDEyICs4MzMsMTUgQEAKIAkgKi8KIAlyY3VfcmVhZF9sb2NrKCk7CiAJb2JqZWN0ID0gY3JlYXRlX29iamVjdCgodW5zaWduZWQgbG9uZylsb2ctPnB0ciwgbG9nLT5zaXplLAotCQkJICAgICAgIGxvZy0+bWluX2NvdW50LCBHRlBfS0VSTkVMKTsKKwkJCSAgICAgICBsb2ctPm1pbl9jb3VudCwgR0ZQX0FUT01JQyk7CisJaWYgKCFvYmplY3QpCisJCWdvdG8gb3V0OwogCXNwaW5fbG9ja19pcnFzYXZlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKIAlmb3IgKGkgPSAwOyBpIDwgbG9nLT50cmFjZV9sZW47IGkrKykKIAkJb2JqZWN0LT50cmFjZVtpXSA9IGxvZy0+dHJhY2VbaV07CiAJb2JqZWN0LT50cmFjZV9sZW4gPSBsb2ctPnRyYWNlX2xlbjsKIAlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZvYmplY3QtPmxvY2ssIGZsYWdzKTsKK291dDoKIAlyY3VfcmVhZF91bmxvY2soKTsKIH0KIApkaWZmIC0tZ2l0IGEvbW0vbWVtb3J5LWZhaWx1cmUuYyBiL21tL21lbW9yeS1mYWlsdXJlLmMKaW5kZXggNzI5ZDRiMS4uN2ZjMjEzMCAxMDA2NDQKLS0tIGEvbW0vbWVtb3J5LWZhaWx1cmUuYworKysgYi9tbS9tZW1vcnktZmFpbHVyZS5jCkBAIC0zNSw2ICszNSw3IEBACiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC9wYWdlLWZsYWdzLmg+CiAjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KKyNpbmNsdWRlIDxsaW51eC9rc20uaD4KICNpbmNsdWRlIDxsaW51eC9ybWFwLmg+CiAjaW5jbHVkZSA8bGludXgvcGFnZW1hcC5oPgogI2luY2x1ZGUgPGxpbnV4L3N3YXAuaD4KQEAgLTY2MSw3ICs2NjIsNyBAQAogCWludCBpOwogCWludCBraWxsID0gMTsKIAotCWlmIChQYWdlUmVzZXJ2ZWQocCkgfHwgUGFnZUNvbXBvdW5kKHApIHx8IFBhZ2VTbGFiKHApKQorCWlmIChQYWdlUmVzZXJ2ZWQocCkgfHwgUGFnZUNvbXBvdW5kKHApIHx8IFBhZ2VTbGFiKHApIHx8IFBhZ2VLc20ocCkpCiAJCXJldHVybjsKIAogCWlmICghUGFnZUxSVShwKSkKZGlmZiAtLWdpdCBhL21tL21lbW9yeS5jIGIvbW0vbWVtb3J5LmMKaW5kZXggN2U5MWI1Zi4uNjBlYTYwMSAxMDA2NDQKLS0tIGEvbW0vbWVtb3J5LmMKKysrIGIvbW0vbWVtb3J5LmMKQEAgLTY0MSw2ICs2NDEsNyBAQAogCQlwbWRfdCAqZHN0X3BtZCwgcG1kX3QgKnNyY19wbWQsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAogCQl1bnNpZ25lZCBsb25nIGFkZHIsIHVuc2lnbmVkIGxvbmcgZW5kKQogeworCXB0ZV90ICpvcmlnX3NyY19wdGUsICpvcmlnX2RzdF9wdGU7CiAJcHRlX3QgKnNyY19wdGUsICpkc3RfcHRlOwogCXNwaW5sb2NrX3QgKnNyY19wdGwsICpkc3RfcHRsOwogCWludCBwcm9ncmVzcyA9IDA7CkBAIC02NTQsNiArNjU1LDggQEAKIAlzcmNfcHRlID0gcHRlX29mZnNldF9tYXBfbmVzdGVkKHNyY19wbWQsIGFkZHIpOwogCXNyY19wdGwgPSBwdGVfbG9ja3B0cihzcmNfbW0sIHNyY19wbWQpOwogCXNwaW5fbG9ja19uZXN0ZWQoc3JjX3B0bCwgU0lOR0xFX0RFUFRIX05FU1RJTkcpOworCW9yaWdfc3JjX3B0ZSA9IHNyY19wdGU7CisJb3JpZ19kc3RfcHRlID0gZHN0X3B0ZTsKIAlhcmNoX2VudGVyX2xhenlfbW11X21vZGUoKTsKIAogCWRvIHsKQEAgLTY3Nyw5ICs2ODAsOSBAQAogCiAJYXJjaF9sZWF2ZV9sYXp5X21tdV9tb2RlKCk7CiAJc3Bpbl91bmxvY2soc3JjX3B0bCk7Ci0JcHRlX3VubWFwX25lc3RlZChzcmNfcHRlIC0gMSk7CisJcHRlX3VubWFwX25lc3RlZChvcmlnX3NyY19wdGUpOwogCWFkZF9tbV9yc3MoZHN0X21tLCByc3NbMF0sIHJzc1sxXSk7Ci0JcHRlX3VubWFwX3VubG9jayhkc3RfcHRlIC0gMSwgZHN0X3B0bCk7CisJcHRlX3VubWFwX3VubG9jayhvcmlnX2RzdF9wdGUsIGRzdF9wdGwpOwogCWNvbmRfcmVzY2hlZCgpOwogCWlmIChhZGRyICE9IGVuZCkKIAkJZ290byBhZ2FpbjsKQEAgLTE4MjAsMTAgKzE4MjMsMTAgQEAKIAl0b2tlbiA9IHBtZF9wZ3RhYmxlKCpwbWQpOwogCiAJZG8gewotCQllcnIgPSBmbihwdGUsIHRva2VuLCBhZGRyLCBkYXRhKTsKKwkJZXJyID0gZm4ocHRlKyssIHRva2VuLCBhZGRyLCBkYXRhKTsKIAkJaWYgKGVycikKIAkJCWJyZWFrOwotCX0gd2hpbGUgKHB0ZSsrLCBhZGRyICs9IFBBR0VfU0laRSwgYWRkciAhPSBlbmQpOworCX0gd2hpbGUgKGFkZHIgKz0gUEFHRV9TSVpFLCBhZGRyICE9IGVuZCk7CiAKIAlhcmNoX2xlYXZlX2xhenlfbW11X21vZGUoKTsKIApkaWZmIC0tZ2l0IGEvbW0vbWVtcG9saWN5LmMgYi9tbS9tZW1wb2xpY3kuYwppbmRleCA3ZGQ5ZDlmLi40NTQ1ZDU5IDEwMDY0NAotLS0gYS9tbS9tZW1wb2xpY3kuYworKysgYi9tbS9tZW1wb2xpY3kuYwpAQCAtMTAyNCw3ICsxMDI0LDcgQEAKIAogCQllcnIgPSBtaWdyYXRlX3ByZXAoKTsKIAkJaWYgKGVycikKLQkJCXJldHVybiBlcnI7CisJCQlnb3RvIG1wb2xfb3V0OwogCX0KIAl7CiAJCU5PREVNQVNLX1NDUkFUQ0goc2NyYXRjaCk7CkBAIC0xMDM5LDEwICsxMDM5LDkgQEAKIAkJCWVyciA9IC1FTk9NRU07CiAJCU5PREVNQVNLX1NDUkFUQ0hfRlJFRShzY3JhdGNoKTsKIAl9Ci0JaWYgKGVycikgewotCQltcG9sX3B1dChuZXcpOwotCQlyZXR1cm4gZXJyOwotCX0KKwlpZiAoZXJyKQorCQlnb3RvIG1wb2xfb3V0OworCiAJdm1hID0gY2hlY2tfcmFuZ2UobW0sIHN0YXJ0LCBlbmQsIG5tYXNrLAogCQkJICBmbGFncyB8IE1QT0xfTUZfSU5WRVJULCAmcGFnZWxpc3QpOwogCkBAIC0xMDU4LDkgKzEwNTcsMTEgQEAKIAogCQlpZiAoIWVyciAmJiBucl9mYWlsZWQgJiYgKGZsYWdzICYgTVBPTF9NRl9TVFJJQ1QpKQogCQkJZXJyID0gLUVJTzsKLQl9CisJfSBlbHNlCisJCXB1dGJhY2tfbHJ1X3BhZ2VzKCZwYWdlbGlzdCk7CiAKIAl1cF93cml0ZSgmbW0tPm1tYXBfc2VtKTsKKyBtcG9sX291dDoKIAltcG9sX3B1dChuZXcpOwogCXJldHVybiBlcnI7CiB9CmRpZmYgLS1naXQgYS9tbS9wYWdlLXdyaXRlYmFjay5jIGIvbW0vcGFnZS13cml0ZWJhY2suYwppbmRleCBhM2IxNDA5Li4yYzVkNzkyIDEwMDY0NAotLS0gYS9tbS9wYWdlLXdyaXRlYmFjay5jCisrKyBiL21tL3BhZ2Utd3JpdGViYWNrLmMKQEAgLTU2Niw3ICs1NjYsOCBAQAogCQlpZiAocGFnZXNfd3JpdHRlbiA+PSB3cml0ZV9jaHVuaykKIAkJCWJyZWFrOwkJLyogV2UndmUgZG9uZSBvdXIgZHV0eSAqLwogCi0JCXNjaGVkdWxlX3RpbWVvdXRfaW50ZXJydXB0aWJsZShwYXVzZSk7CisJCV9fc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19JTlRFUlJVUFRJQkxFKTsKKwkJaW9fc2NoZWR1bGVfdGltZW91dChwYXVzZSk7CiAKIAkJLyoKIAkJICogSW5jcmVhc2UgdGhlIGRlbGF5IGZvciBlYWNoIGxvb3AsIHVwIHRvIG91ciBwcmV2aW91cwpkaWZmIC0tZ2l0IGEvbW0vcGFnZV9hbGxvYy5jIGIvbW0vcGFnZV9hbGxvYy5jCmluZGV4IGJmNzIwNTUuLmNkY2VkZjYgMTAwNjQ0Ci0tLSBhL21tL3BhZ2VfYWxsb2MuYworKysgYi9tbS9wYWdlX2FsbG9jLmMKQEAgLTIxODMsNyArMjE4Myw3IEBACiAJcHJpbnRrKCJhY3RpdmVfYW5vbjolbHUgaW5hY3RpdmVfYW5vbjolbHUgaXNvbGF0ZWRfYW5vbjolbHVcbiIKIAkJIiBhY3RpdmVfZmlsZTolbHUgaW5hY3RpdmVfZmlsZTolbHUgaXNvbGF0ZWRfZmlsZTolbHVcbiIKIAkJIiB1bmV2aWN0YWJsZTolbHUiCi0JCSIgZGlydHk6JWx1IHdyaXRlYmFjazolbHUgdW5zdGFibGU6JWx1IGJ1ZmZlcjolbHVcbiIKKwkJIiBkaXJ0eTolbHUgd3JpdGViYWNrOiVsdSB1bnN0YWJsZTolbHVcbiIKIAkJIiBmcmVlOiVsdSBzbGFiX3JlY2xhaW1hYmxlOiVsdSBzbGFiX3VucmVjbGFpbWFibGU6JWx1XG4iCiAJCSIgbWFwcGVkOiVsdSBzaG1lbTolbHUgcGFnZXRhYmxlczolbHUgYm91bmNlOiVsdVxuIiwKIAkJZ2xvYmFsX3BhZ2Vfc3RhdGUoTlJfQUNUSVZFX0FOT04pLApAQCAtMjE5Niw3ICsyMTk2LDYgQEAKIAkJZ2xvYmFsX3BhZ2Vfc3RhdGUoTlJfRklMRV9ESVJUWSksCiAJCWdsb2JhbF9wYWdlX3N0YXRlKE5SX1dSSVRFQkFDSyksCiAJCWdsb2JhbF9wYWdlX3N0YXRlKE5SX1VOU1RBQkxFX05GUyksCi0JCW5yX2Jsb2NrZGV2X3BhZ2VzKCksCiAJCWdsb2JhbF9wYWdlX3N0YXRlKE5SX0ZSRUVfUEFHRVMpLAogCQlnbG9iYWxfcGFnZV9zdGF0ZShOUl9TTEFCX1JFQ0xBSU1BQkxFKSwKIAkJZ2xvYmFsX3BhZ2Vfc3RhdGUoTlJfU0xBQl9VTlJFQ0xBSU1BQkxFKSwKZGlmZiAtLWdpdCBhL21tL3BlcmNwdS5jIGIvbW0vcGVyY3B1LmMKaW5kZXggNGEwNDhhYi4uNmFmNzhjMWUgMTAwNjQ0Ci0tLSBhL21tL3BlcmNwdS5jCisrKyBiL21tL3BlcmNwdS5jCkBAIC0xODcwLDEzICsxODcwLDE0IEBACiAJbWF4X2Rpc3RhbmNlID0gMDsKIAlmb3IgKGdyb3VwID0gMDsgZ3JvdXAgPCBhaS0+bnJfZ3JvdXBzOyBncm91cCsrKSB7CiAJCWFpLT5ncm91cHNbZ3JvdXBdLmJhc2Vfb2Zmc2V0ID0gYXJlYXNbZ3JvdXBdIC0gYmFzZTsKLQkJbWF4X2Rpc3RhbmNlID0gbWF4KG1heF9kaXN0YW5jZSwgYWktPmdyb3Vwc1tncm91cF0uYmFzZV9vZmZzZXQpOworCQltYXhfZGlzdGFuY2UgPSBtYXhfdChzaXplX3QsIG1heF9kaXN0YW5jZSwKKwkJCQkgICAgIGFpLT5ncm91cHNbZ3JvdXBdLmJhc2Vfb2Zmc2V0KTsKIAl9CiAJbWF4X2Rpc3RhbmNlICs9IGFpLT51bml0X3NpemU7CiAKIAkvKiB3YXJuIGlmIG1heGltdW0gZGlzdGFuY2UgaXMgZnVydGhlciB0aGFuIDc1JSBvZiB2bWFsbG9jIHNwYWNlICovCiAJaWYgKG1heF9kaXN0YW5jZSA+IChWTUFMTE9DX0VORCAtIFZNQUxMT0NfU1RBUlQpICogMyAvIDQpIHsKLQkJcHJfd2FybmluZygiUEVSQ1BVOiBtYXhfZGlzdGFuY2U9MHglbHggdG9vIGxhcmdlIGZvciB2bWFsbG9jICIKKwkJcHJfd2FybmluZygiUEVSQ1BVOiBtYXhfZGlzdGFuY2U9MHglenggdG9vIGxhcmdlIGZvciB2bWFsbG9jICIKIAkJCSAgICJzcGFjZSAweCVseFxuIiwKIAkJCSAgIG1heF9kaXN0YW5jZSwgVk1BTExPQ19FTkQgLSBWTUFMTE9DX1NUQVJUKTsKICNpZmRlZiBDT05GSUdfTkVFRF9QRVJfQ1BVX1BBR0VfRklSU1RfQ0hVTksKZGlmZiAtLWdpdCBhL21tL3ZtYWxsb2MuYyBiL21tL3ZtYWxsb2MuYwppbmRleCA1ZTdhZWQwLi4wZjU1MWE0IDEwMDY0NAotLS0gYS9tbS92bWFsbG9jLmMKKysrIGIvbW0vdm1hbGxvYy5jCkBAIC0xMiw2ICsxMiw3IEBACiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KICNpbmNsdWRlIDxsaW51eC9oaWdobWVtLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIvbW0vdm1zY2FuLmMKaW5kZXggNjRlNDM4ODkuLjc3N2FmNTcgMTAwNjQ0Ci0tLSBhL21tL3Ztc2Nhbi5jCisrKyBiL21tL3Ztc2Nhbi5jCkBAIC01NDQsNiArNTQ0LDE2IEBACiAJCSAqLwogCQlscnUgPSBMUlVfVU5FVklDVEFCTEU7CiAJCWFkZF9wYWdlX3RvX3VuZXZpY3RhYmxlX2xpc3QocGFnZSk7CisJCS8qCisJCSAqIFdoZW4gcmFjaW5nIHdpdGggYW4gbWxvY2sgY2xlYXJpbmcgKHBhZ2UgaXMKKwkJICogdW5sb2NrZWQpLCBtYWtlIHN1cmUgdGhhdCBpZiB0aGUgb3RoZXIgdGhyZWFkIGRvZXMKKwkJICogbm90IG9ic2VydmUgb3VyIHNldHRpbmcgb2YgUEdfbHJ1IGFuZCBmYWlscworCQkgKiBpc29sYXRpb24sIHdlIHNlZSBQR19tbG9ja2VkIGNsZWFyZWQgYmVsb3cgYW5kIG1vdmUKKwkJICogdGhlIHBhZ2UgYmFjayB0byB0aGUgZXZpY3RhYmxlIGxpc3QuCisJCSAqCisJCSAqIFRoZSBvdGhlciBzaWRlIGlzIFRlc3RDbGVhclBhZ2VNbG9ja2VkKCkuCisJCSAqLworCQlzbXBfbWIoKTsKIAl9CiAKIAkvKgpAQCAtMTA4OCw3ICsxMDk4LDcgQEAKIAlpbnQgbHVtcHlfcmVjbGFpbSA9IDA7CiAKIAl3aGlsZSAodW5saWtlbHkodG9vX21hbnlfaXNvbGF0ZWQoem9uZSwgZmlsZSwgc2MpKSkgewotCQljb25nZXN0aW9uX3dhaXQoV1JJVEUsIEhaLzEwKTsKKwkJY29uZ2VzdGlvbl93YWl0KEJMS19SV19BU1lOQywgSFovMTApOwogCiAJCS8qIFdlIGFyZSBhYm91dCB0byBkaWUgYW5kIGZyZWUgb3VyIG1lbW9yeS4gUmV0dXJuIG5vdy4gKi8KIAkJaWYgKGZhdGFsX3NpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKQpAQCAtMTM1Niw3ICsxMzY2LDcgQEAKIAkJCSAqIElPLCBwbHVzIEpWTSBjYW4gY3JlYXRlIGxvdHMgb2YgYW5vbiBWTV9FWEVDIHBhZ2VzLAogCQkJICogc28gd2UgaWdub3JlIHRoZW0gaGVyZS4KIAkJCSAqLwotCQkJaWYgKCh2bV9mbGFncyAmIFZNX0VYRUMpICYmICFQYWdlQW5vbihwYWdlKSkgeworCQkJaWYgKCh2bV9mbGFncyAmIFZNX0VYRUMpICYmIHBhZ2VfaXNfZmlsZV9jYWNoZShwYWdlKSkgewogCQkJCWxpc3RfYWRkKCZwYWdlLT5scnUsICZsX2FjdGl2ZSk7CiAJCQkJY29udGludWU7CiAJCQl9CmRpZmYgLS1naXQgYS9uZXQvOXAvdHJhbnNfdmlydGlvLmMgYi9uZXQvOXAvdHJhbnNfdmlydGlvLmMKaW5kZXggYjJlMDdmMC4uZWExZTNkYSAxMDA2NDQKLS0tIGEvbmV0LzlwL3RyYW5zX3ZpcnRpby5jCisrKyBiL25ldC85cC90cmFuc192aXJ0aW8uYwpAQCAtNDMsNyArNDMsNiBAQAogI2luY2x1ZGUgPG5ldC85cC90cmFuc3BvcnQuaD4KICNpbmNsdWRlIDxsaW51eC9zY2F0dGVybGlzdC5oPgogI2luY2x1ZGUgPGxpbnV4L3ZpcnRpby5oPgotI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19pZHMuaD4KICNpbmNsdWRlIDxsaW51eC92aXJ0aW9fOXAuaD4KIAogI2RlZmluZSBWSVJUUVVFVUVfTlVNCTEyOApkaWZmIC0tZ2l0IGEvbmV0L2JsdWV0b290aC9oY2lfc3lzZnMuYyBiL25ldC9ibHVldG9vdGgvaGNpX3N5c2ZzLmMKaW5kZXggN2Y5MzljZS4uMmJjNmY2YSAxMDA2NDQKLS0tIGEvbmV0L2JsdWV0b290aC9oY2lfc3lzZnMuYworKysgYi9uZXQvYmx1ZXRvb3RoL2hjaV9zeXNmcy5jCkBAIC05Miw2ICs5Miw4IEBACiAKIAlkZXZfc2V0X25hbWUoJmNvbm4tPmRldiwgIiVzOiVkIiwgaGRldi0+bmFtZSwgY29ubi0+aGFuZGxlKTsKIAorCWRldl9zZXRfZHJ2ZGF0YSgmY29ubi0+ZGV2LCBjb25uKTsKKwogCWlmIChkZXZpY2VfYWRkKCZjb25uLT5kZXYpIDwgMCkgewogCQlCVF9FUlIoIkZhaWxlZCB0byByZWdpc3RlciBjb25uZWN0aW9uIGRldmljZSIpOwogCQlyZXR1cm47CkBAIC0xNDQsOCArMTQ2LDYgQEAKIAljb25uLT5kZXYuY2xhc3MgPSBidF9jbGFzczsKIAljb25uLT5kZXYucGFyZW50ID0gJmhkZXYtPmRldjsKIAotCWRldl9zZXRfZHJ2ZGF0YSgmY29ubi0+ZGV2LCBjb25uKTsKLQogCWRldmljZV9pbml0aWFsaXplKCZjb25uLT5kZXYpOwogCiAJSU5JVF9XT1JLKCZjb25uLT53b3JrX2FkZCwgYWRkX2Nvbm4pOwpkaWZmIC0tZ2l0IGEvbmV0L2JsdWV0b290aC9sMmNhcC5jIGIvbmV0L2JsdWV0b290aC9sMmNhcC5jCmluZGV4IDU1NWQ5ZGEuLjc3ZTlmYjEgMTAwNjQ0Ci0tLSBhL25ldC9ibHVldG9vdGgvbDJjYXAuYworKysgYi9uZXQvYmx1ZXRvb3RoL2wyY2FwLmMKQEAgLTU1NSwxMiArNTU1LDEyIEBACiAKIAljb25uLT5mZWF0X21hc2sgPSAwOwogCi0Jc2V0dXBfdGltZXIoJmNvbm4tPmluZm9fdGltZXIsIGwyY2FwX2luZm9fdGltZW91dCwKLQkJCQkJCSh1bnNpZ25lZCBsb25nKSBjb25uKTsKLQogCXNwaW5fbG9ja19pbml0KCZjb25uLT5sb2NrKTsKIAlyd2xvY2tfaW5pdCgmY29ubi0+Y2hhbl9saXN0LmxvY2spOwogCisJc2V0dXBfdGltZXIoJmNvbm4tPmluZm9fdGltZXIsIGwyY2FwX2luZm9fdGltZW91dCwKKwkJCQkJCSh1bnNpZ25lZCBsb25nKSBjb25uKTsKKwogCWNvbm4tPmRpc2NfcmVhc29uID0gMHgxMzsKIAogCXJldHVybiBjb25uOwpAQCAtNzgzLDYgKzc4Myw5IEBACiAJLyogRGVmYXVsdCBjb25maWcgb3B0aW9ucyAqLwogCXBpLT5jb25mX2xlbiA9IDA7CiAJcGktPmZsdXNoX3RvID0gTDJDQVBfREVGQVVMVF9GTFVTSF9UTzsKKwlza2JfcXVldWVfaGVhZF9pbml0KFRYX1FVRVVFKHNrKSk7CisJc2tiX3F1ZXVlX2hlYWRfaW5pdChTUkVKX1FVRVVFKHNrKSk7CisJSU5JVF9MSVNUX0hFQUQoU1JFSl9MSVNUKHNrKSk7CiB9CiAKIHN0YXRpYyBzdHJ1Y3QgcHJvdG8gbDJjYXBfcHJvdG8gPSB7CmRpZmYgLS1naXQgYS9uZXQvaXB2NC9pbmV0X2Nvbm5lY3Rpb25fc29jay5jIGIvbmV0L2lwdjQvaW5ldF9jb25uZWN0aW9uX3NvY2suYwppbmRleCA0MzUxY2EyLi41Mzc3MzFiIDEwMDY0NAotLS0gYS9uZXQvaXB2NC9pbmV0X2Nvbm5lY3Rpb25fc29jay5jCisrKyBiL25ldC9pcHY0L2luZXRfY29ubmVjdGlvbl9zb2NrLmMKQEAgLTQ0Niw2ICs0NDYsMjggQEAKIAogRVhQT1JUX1NZTUJPTF9HUEwoaW5ldF9jc2tfcmVxc2tfcXVldWVfaGFzaF9hZGQpOwogCisvKiBEZWNpZGUgd2hlbiB0byBleHBpcmUgdGhlIHJlcXVlc3QgYW5kIHdoZW4gdG8gcmVzZW5kIFNZTi1BQ0sgKi8KK3N0YXRpYyBpbmxpbmUgdm9pZCBzeW5fYWNrX3JlY2FsYyhzdHJ1Y3QgcmVxdWVzdF9zb2NrICpyZXEsIGNvbnN0IGludCB0aHJlc2gsCisJCQkJICBjb25zdCBpbnQgbWF4X3JldHJpZXMsCisJCQkJICBjb25zdCB1OCByc2txX2RlZmVyX2FjY2VwdCwKKwkJCQkgIGludCAqZXhwaXJlLCBpbnQgKnJlc2VuZCkKK3sKKwlpZiAoIXJza3FfZGVmZXJfYWNjZXB0KSB7CisJCSpleHBpcmUgPSByZXEtPnJldHJhbnMgPj0gdGhyZXNoOworCQkqcmVzZW5kID0gMTsKKwkJcmV0dXJuOworCX0KKwkqZXhwaXJlID0gcmVxLT5yZXRyYW5zID49IHRocmVzaCAmJgorCQkgICghaW5ldF9yc2socmVxKS0+YWNrZWQgfHwgcmVxLT5yZXRyYW5zID49IG1heF9yZXRyaWVzKTsKKwkvKgorCSAqIERvIG5vdCByZXNlbmQgd2hpbGUgd2FpdGluZyBmb3IgZGF0YSBhZnRlciBBQ0ssCisJICogc3RhcnQgdG8gcmVzZW5kIG9uIGVuZCBvZiBkZWZlcnJpbmcgcGVyaW9kIHRvIGdpdmUKKwkgKiBsYXN0IGNoYW5jZSBmb3IgZGF0YSBvciBBQ0sgdG8gY3JlYXRlIGVzdGFibGlzaGVkIHNvY2tldC4KKwkgKi8KKwkqcmVzZW5kID0gIWluZXRfcnNrKHJlcSktPmFja2VkIHx8CisJCSAgcmVxLT5yZXRyYW5zID49IHJza3FfZGVmZXJfYWNjZXB0IC0gMTsKK30KKwogdm9pZCBpbmV0X2Nza19yZXFza19xdWV1ZV9wcnVuZShzdHJ1Y3Qgc29jayAqcGFyZW50LAogCQkJCWNvbnN0IHVuc2lnbmVkIGxvbmcgaW50ZXJ2YWwsCiAJCQkJY29uc3QgdW5zaWduZWQgbG9uZyB0aW1lb3V0LApAQCAtNTAxLDkgKzUyMywxNSBAQAogCQlyZXFwPSZsb3B0LT5zeW5fdGFibGVbaV07CiAJCXdoaWxlICgocmVxID0gKnJlcXApICE9IE5VTEwpIHsKIAkJCWlmICh0aW1lX2FmdGVyX2VxKG5vdywgcmVxLT5leHBpcmVzKSkgewotCQkJCWlmICgocmVxLT5yZXRyYW5zIDwgdGhyZXNoIHx8Ci0JCQkJICAgICAoaW5ldF9yc2socmVxKS0+YWNrZWQgJiYgcmVxLT5yZXRyYW5zIDwgbWF4X3JldHJpZXMpKQotCQkJCSAgICAmJiAhcmVxLT5yc2tfb3BzLT5ydHhfc3luX2FjayhwYXJlbnQsIHJlcSkpIHsKKwkJCQlpbnQgZXhwaXJlID0gMCwgcmVzZW5kID0gMDsKKworCQkJCXN5bl9hY2tfcmVjYWxjKHJlcSwgdGhyZXNoLCBtYXhfcmV0cmllcywKKwkJCQkJICAgICAgIHF1ZXVlLT5yc2txX2RlZmVyX2FjY2VwdCwKKwkJCQkJICAgICAgICZleHBpcmUsICZyZXNlbmQpOworCQkJCWlmICghZXhwaXJlICYmCisJCQkJICAgICghcmVzZW5kIHx8CisJCQkJICAgICAhcmVxLT5yc2tfb3BzLT5ydHhfc3luX2FjayhwYXJlbnQsIHJlcSkgfHwKKwkJCQkgICAgIGluZXRfcnNrKHJlcSktPmFja2VkKSkgewogCQkJCQl1bnNpZ25lZCBsb25nIHRpbWVvOwogCiAJCQkJCWlmIChyZXEtPnJldHJhbnMrKyA9PSAwKQpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvaXBfc29ja2dsdWUuYyBiL25ldC9pcHY0L2lwX3NvY2tnbHVlLmMKaW5kZXggMGMwYjZlMy4uZTk4MmI1YyAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvaXBfc29ja2dsdWUuYworKysgYi9uZXQvaXB2NC9pcF9zb2NrZ2x1ZS5jCkBAIC02MzQsMTcgKzYzNCwxNiBAQAogCQkJCWJyZWFrOwogCQkJfQogCQkJZGV2ID0gaXBfZGV2X2ZpbmQoc29ja19uZXQoc2spLCBtcmVxLmltcl9hZGRyZXNzLnNfYWRkcik7Ci0JCQlpZiAoZGV2KSB7CisJCQlpZiAoZGV2KQogCQkJCW1yZXEuaW1yX2lmaW5kZXggPSBkZXYtPmlmaW5kZXg7Ci0JCQkJZGV2X3B1dChkZXYpOwotCQkJfQogCQl9IGVsc2UKLQkJCWRldiA9IF9fZGV2X2dldF9ieV9pbmRleChzb2NrX25ldChzayksIG1yZXEuaW1yX2lmaW5kZXgpOworCQkJZGV2ID0gZGV2X2dldF9ieV9pbmRleChzb2NrX25ldChzayksIG1yZXEuaW1yX2lmaW5kZXgpOwogCiAKIAkJZXJyID0gLUVBRERSTk9UQVZBSUw7CiAJCWlmICghZGV2KQogCQkJYnJlYWs7CisJCWRldl9wdXQoZGV2KTsKIAogCQllcnIgPSAtRUlOVkFMOwogCQlpZiAoc2stPnNrX2JvdW5kX2Rldl9pZiAmJgpkaWZmIC0tZ2l0IGEvbmV0L2lwdjQvdGNwLmMgYi9uZXQvaXB2NC90Y3AuYwppbmRleCA2NGQwYWY2Li45MGIyZTA2IDEwMDY0NAotLS0gYS9uZXQvaXB2NC90Y3AuYworKysgYi9uZXQvaXB2NC90Y3AuYwpAQCAtMzI2LDYgKzMyNiw0MyBAQAogCiBFWFBPUlRfU1lNQk9MKHRjcF9lbnRlcl9tZW1vcnlfcHJlc3N1cmUpOwogCisvKiBDb252ZXJ0IHNlY29uZHMgdG8gcmV0cmFuc21pdHMgYmFzZWQgb24gaW5pdGlhbCBhbmQgbWF4IHRpbWVvdXQgKi8KK3N0YXRpYyB1OCBzZWNzX3RvX3JldHJhbnMoaW50IHNlY29uZHMsIGludCB0aW1lb3V0LCBpbnQgcnRvX21heCkKK3sKKwl1OCByZXMgPSAwOworCisJaWYgKHNlY29uZHMgPiAwKSB7CisJCWludCBwZXJpb2QgPSB0aW1lb3V0OworCisJCXJlcyA9IDE7CisJCXdoaWxlIChzZWNvbmRzID4gcGVyaW9kICYmIHJlcyA8IDI1NSkgeworCQkJcmVzKys7CisJCQl0aW1lb3V0IDw8PSAxOworCQkJaWYgKHRpbWVvdXQgPiBydG9fbWF4KQorCQkJCXRpbWVvdXQgPSBydG9fbWF4OworCQkJcGVyaW9kICs9IHRpbWVvdXQ7CisJCX0KKwl9CisJcmV0dXJuIHJlczsKK30KKworLyogQ29udmVydCByZXRyYW5zbWl0cyB0byBzZWNvbmRzIGJhc2VkIG9uIGluaXRpYWwgYW5kIG1heCB0aW1lb3V0ICovCitzdGF0aWMgaW50IHJldHJhbnNfdG9fc2Vjcyh1OCByZXRyYW5zLCBpbnQgdGltZW91dCwgaW50IHJ0b19tYXgpCit7CisJaW50IHBlcmlvZCA9IDA7CisKKwlpZiAocmV0cmFucyA+IDApIHsKKwkJcGVyaW9kID0gdGltZW91dDsKKwkJd2hpbGUgKC0tcmV0cmFucykgeworCQkJdGltZW91dCA8PD0gMTsKKwkJCWlmICh0aW1lb3V0ID4gcnRvX21heCkKKwkJCQl0aW1lb3V0ID0gcnRvX21heDsKKwkJCXBlcmlvZCArPSB0aW1lb3V0OworCQl9CisJfQorCXJldHVybiBwZXJpb2Q7Cit9CisKIC8qCiAgKglXYWl0IGZvciBhIFRDUCBldmVudC4KICAqCkBAIC0xNDA1LDcgKzE0NDIsOSBAQAogCQkJCWdvdG8gZm91bmRfb2tfc2tiOwogCQkJaWYgKHRjcF9oZHIoc2tiKS0+ZmluKQogCQkJCWdvdG8gZm91bmRfZmluX29rOwotCQkJV0FSTl9PTighKGZsYWdzICYgTVNHX1BFRUspKTsKKwkJCWlmIChXQVJOX09OKCEoZmxhZ3MgJiBNU0dfUEVFSykpKQorCQkJCXByaW50ayhLRVJOX0lORk8gInJlY3Ztc2cgYnVnIDI6IGNvcGllZCAlWCAiCisJCQkJICAgICAgICJzZXEgJVhcbiIsICpzZXEsIFRDUF9TS0JfQ0Ioc2tiKS0+c2VxKTsKIAkJfQogCiAJCS8qIFdlbGwsIGlmIHdlIGhhdmUgYmFja2xvZywgdHJ5IHRvIHByb2Nlc3MgaXQgbm93IHlldC4gKi8KQEAgLTIxNjMsMTYgKzIyMDIsMTAgQEAKIAkJYnJlYWs7CiAKIAljYXNlIFRDUF9ERUZFUl9BQ0NFUFQ6Ci0JCWljc2stPmljc2tfYWNjZXB0X3F1ZXVlLnJza3FfZGVmZXJfYWNjZXB0ID0gMDsKLQkJaWYgKHZhbCA+IDApIHsKLQkJCS8qIFRyYW5zbGF0ZSB2YWx1ZSBpbiBzZWNvbmRzIHRvIG51bWJlciBvZgotCQkJICogcmV0cmFuc21pdHMgKi8KLQkJCXdoaWxlIChpY3NrLT5pY3NrX2FjY2VwdF9xdWV1ZS5yc2txX2RlZmVyX2FjY2VwdCA8IDMyICYmCi0JCQkgICAgICAgdmFsID4gKChUQ1BfVElNRU9VVF9JTklUIC8gSFopIDw8Ci0JCQkJICAgICAgIGljc2stPmljc2tfYWNjZXB0X3F1ZXVlLnJza3FfZGVmZXJfYWNjZXB0KSkKLQkJCQlpY3NrLT5pY3NrX2FjY2VwdF9xdWV1ZS5yc2txX2RlZmVyX2FjY2VwdCsrOwotCQkJaWNzay0+aWNza19hY2NlcHRfcXVldWUucnNrcV9kZWZlcl9hY2NlcHQrKzsKLQkJfQorCQkvKiBUcmFuc2xhdGUgdmFsdWUgaW4gc2Vjb25kcyB0byBudW1iZXIgb2YgcmV0cmFuc21pdHMgKi8KKwkJaWNzay0+aWNza19hY2NlcHRfcXVldWUucnNrcV9kZWZlcl9hY2NlcHQgPQorCQkJc2Vjc190b19yZXRyYW5zKHZhbCwgVENQX1RJTUVPVVRfSU5JVCAvIEhaLAorCQkJCQlUQ1BfUlRPX01BWCAvIEhaKTsKIAkJYnJlYWs7CiAKIAljYXNlIFRDUF9XSU5ET1dfQ0xBTVA6CkBAIC0yMzUzLDggKzIzODYsOCBAQAogCQkJdmFsID0gKHZhbCA/IDogc3lzY3RsX3RjcF9maW5fdGltZW91dCkgLyBIWjsKIAkJYnJlYWs7CiAJY2FzZSBUQ1BfREVGRVJfQUNDRVBUOgotCQl2YWwgPSAhaWNzay0+aWNza19hY2NlcHRfcXVldWUucnNrcV9kZWZlcl9hY2NlcHQgPyAwIDoKLQkJCSgoVENQX1RJTUVPVVRfSU5JVCAvIEhaKSA8PCAoaWNzay0+aWNza19hY2NlcHRfcXVldWUucnNrcV9kZWZlcl9hY2NlcHQgLSAxKSk7CisJCXZhbCA9IHJldHJhbnNfdG9fc2VjcyhpY3NrLT5pY3NrX2FjY2VwdF9xdWV1ZS5yc2txX2RlZmVyX2FjY2VwdCwKKwkJCQkgICAgICBUQ1BfVElNRU9VVF9JTklUIC8gSFosIFRDUF9SVE9fTUFYIC8gSFopOwogCQlicmVhazsKIAljYXNlIFRDUF9XSU5ET1dfQ0xBTVA6CiAJCXZhbCA9IHRwLT53aW5kb3dfY2xhbXA7CmRpZmYgLS1naXQgYS9uZXQvaXB2NC90Y3BfbWluaXNvY2tzLmMgYi9uZXQvaXB2NC90Y3BfbWluaXNvY2tzLmMKaW5kZXggNjI0YzNjOS4uNGMwMzU5OCAxMDA2NDQKLS0tIGEvbmV0L2lwdjQvdGNwX21pbmlzb2Nrcy5jCisrKyBiL25ldC9pcHY0L3RjcF9taW5pc29ja3MuYwpAQCAtNjQxLDggKzY0MSw4IEBACiAJaWYgKCEoZmxnICYgVENQX0ZMQUdfQUNLKSkKIAkJcmV0dXJuIE5VTEw7CiAKLQkvKiBJZiBUQ1BfREVGRVJfQUNDRVBUIGlzIHNldCwgZHJvcCBiYXJlIEFDSy4gKi8KLQlpZiAoaW5ldF9jc2soc2spLT5pY3NrX2FjY2VwdF9xdWV1ZS5yc2txX2RlZmVyX2FjY2VwdCAmJgorCS8qIFdoaWxlIFRDUF9ERUZFUl9BQ0NFUFQgaXMgYWN0aXZlLCBkcm9wIGJhcmUgQUNLLiAqLworCWlmIChyZXEtPnJldHJhbnMgPCBpbmV0X2NzayhzayktPmljc2tfYWNjZXB0X3F1ZXVlLnJza3FfZGVmZXJfYWNjZXB0ICYmCiAJICAgIFRDUF9TS0JfQ0Ioc2tiKS0+ZW5kX3NlcSA9PSB0Y3BfcnNrKHJlcSktPnJjdl9pc24gKyAxKSB7CiAJCWluZXRfcnNrKHJlcSktPmFja2VkID0gMTsKIAkJcmV0dXJuIE5VTEw7CmRpZmYgLS1naXQgYS9uZXQvaXB2NC91ZHAuYyBiL25ldC9pcHY0L3VkcC5jCmluZGV4IDZlYzZhOGEuLmQwZDQzNmQgMTAwNjQ0Ci0tLSBhL25ldC9pcHY0L3VkcC5jCisrKyBiL25ldC9pcHY0L3VkcC5jCkBAIC04NDEsNiArODQxLDQyIEBACiAJcmV0dXJuIHJldDsKIH0KIAorCisvKioKKyAqCWZpcnN0X3BhY2tldF9sZW5ndGgJLSByZXR1cm4gbGVuZ3RoIG9mIGZpcnN0IHBhY2tldCBpbiByZWNlaXZlIHF1ZXVlCisgKglAc2s6IHNvY2tldAorICoKKyAqCURyb3BzIGFsbCBiYWQgY2hlY2tzdW0gZnJhbWVzLCB1bnRpbCBhIHZhbGlkIG9uZSBpcyBmb3VuZC4KKyAqCVJldHVybnMgdGhlIGxlbmd0aCBvZiBmb3VuZCBza2IsIG9yIDAgaWYgbm9uZSBpcyBmb3VuZC4KKyAqLworc3RhdGljIHVuc2lnbmVkIGludCBmaXJzdF9wYWNrZXRfbGVuZ3RoKHN0cnVjdCBzb2NrICpzaykKK3sKKwlzdHJ1Y3Qgc2tfYnVmZl9oZWFkIGxpc3Rfa2lsbCwgKnJjdnEgPSAmc2stPnNrX3JlY2VpdmVfcXVldWU7CisJc3RydWN0IHNrX2J1ZmYgKnNrYjsKKwl1bnNpZ25lZCBpbnQgcmVzOworCisJX19za2JfcXVldWVfaGVhZF9pbml0KCZsaXN0X2tpbGwpOworCisJc3Bpbl9sb2NrX2JoKCZyY3ZxLT5sb2NrKTsKKwl3aGlsZSAoKHNrYiA9IHNrYl9wZWVrKHJjdnEpKSAhPSBOVUxMICYmCisJCXVkcF9saWJfY2hlY2tzdW1fY29tcGxldGUoc2tiKSkgeworCQlVRFBfSU5DX1NUQVRTX0JIKHNvY2tfbmV0KHNrKSwgVURQX01JQl9JTkVSUk9SUywKKwkJCQkgSVNfVURQTElURShzaykpOworCQlfX3NrYl91bmxpbmsoc2tiLCByY3ZxKTsKKwkJX19za2JfcXVldWVfdGFpbCgmbGlzdF9raWxsLCBza2IpOworCX0KKwlyZXMgPSBza2IgPyBza2ItPmxlbiA6IDA7CisJc3Bpbl91bmxvY2tfYmgoJnJjdnEtPmxvY2spOworCisJaWYgKCFza2JfcXVldWVfZW1wdHkoJmxpc3Rfa2lsbCkpIHsKKwkJbG9ja19zb2NrKHNrKTsKKwkJX19za2JfcXVldWVfcHVyZ2UoJmxpc3Rfa2lsbCk7CisJCXNrX21lbV9yZWNsYWltX3BhcnRpYWwoc2spOworCQlyZWxlYXNlX3NvY2soc2spOworCX0KKwlyZXR1cm4gcmVzOworfQorCiAvKgogICoJSU9DVEwgcmVxdWVzdHMgYXBwbGljYWJsZSB0byB0aGUgVURQIHByb3RvY29sCiAgKi8KQEAgLTg1NywyMSArODkzLDE2IEBACiAKIAljYXNlIFNJT0NJTlE6CiAJewotCQlzdHJ1Y3Qgc2tfYnVmZiAqc2tiOwotCQl1bnNpZ25lZCBsb25nIGFtb3VudDsKKwkJdW5zaWduZWQgaW50IGFtb3VudCA9IGZpcnN0X3BhY2tldF9sZW5ndGgoc2spOwogCi0JCWFtb3VudCA9IDA7Ci0JCXNwaW5fbG9ja19iaCgmc2stPnNrX3JlY2VpdmVfcXVldWUubG9jayk7Ci0JCXNrYiA9IHNrYl9wZWVrKCZzay0+c2tfcmVjZWl2ZV9xdWV1ZSk7Ci0JCWlmIChza2IgIT0gTlVMTCkgeworCQlpZiAoYW1vdW50KQogCQkJLyoKIAkJCSAqIFdlIHdpbGwgb25seSByZXR1cm4gdGhlIGFtb3VudAogCQkJICogb2YgdGhpcyBwYWNrZXQgc2luY2UgdGhhdCBpcyBhbGwKIAkJCSAqIHRoYXQgd2lsbCBiZSByZWFkLgogCQkJICovCi0JCQlhbW91bnQgPSBza2ItPmxlbiAtIHNpemVvZihzdHJ1Y3QgdWRwaGRyKTsKLQkJfQotCQlzcGluX3VubG9ja19iaCgmc2stPnNrX3JlY2VpdmVfcXVldWUubG9jayk7CisJCQlhbW91bnQgLT0gc2l6ZW9mKHN0cnVjdCB1ZHBoZHIpOworCiAJCXJldHVybiBwdXRfdXNlcihhbW91bnQsIChpbnQgX191c2VyICopYXJnKTsKIAl9CiAKQEAgLTE1NDAsMjkgKzE1NzEsMTEgQEAKIHsKIAl1bnNpZ25lZCBpbnQgbWFzayA9IGRhdGFncmFtX3BvbGwoZmlsZSwgc29jaywgd2FpdCk7CiAJc3RydWN0IHNvY2sgKnNrID0gc29jay0+c2s7Ci0JaW50IAlpc19saXRlID0gSVNfVURQTElURShzayk7CiAKIAkvKiBDaGVjayBmb3IgZmFsc2UgcG9zaXRpdmVzIGR1ZSB0byBjaGVja3N1bSBlcnJvcnMgKi8KLQlpZiAoKG1hc2sgJiBQT0xMUkROT1JNKSAmJgotCSAgICAhKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKSAmJgotCSAgICAhKHNrLT5za19zaHV0ZG93biAmIFJDVl9TSFVURE9XTikpIHsKLQkJc3RydWN0IHNrX2J1ZmZfaGVhZCAqcmN2cSA9ICZzay0+c2tfcmVjZWl2ZV9xdWV1ZTsKLQkJc3RydWN0IHNrX2J1ZmYgKnNrYjsKLQotCQlzcGluX2xvY2tfYmgoJnJjdnEtPmxvY2spOwotCQl3aGlsZSAoKHNrYiA9IHNrYl9wZWVrKHJjdnEpKSAhPSBOVUxMICYmCi0JCSAgICAgICB1ZHBfbGliX2NoZWNrc3VtX2NvbXBsZXRlKHNrYikpIHsKLQkJCVVEUF9JTkNfU1RBVFNfQkgoc29ja19uZXQoc2spLAotCQkJCQlVRFBfTUlCX0lORVJST1JTLCBpc19saXRlKTsKLQkJCV9fc2tiX3VubGluayhza2IsIHJjdnEpOwotCQkJa2ZyZWVfc2tiKHNrYik7Ci0JCX0KLQkJc3Bpbl91bmxvY2tfYmgoJnJjdnEtPmxvY2spOwotCi0JCS8qIG5vdGhpbmcgdG8gc2VlLCBtb3ZlIGFsb25nICovCi0JCWlmIChza2IgPT0gTlVMTCkKLQkJCW1hc2sgJj0gfihQT0xMSU4gfCBQT0xMUkROT1JNKTsKLQl9CisJaWYgKChtYXNrICYgUE9MTFJETk9STSkgJiYgIShmaWxlLT5mX2ZsYWdzICYgT19OT05CTE9DSykgJiYKKwkgICAgIShzay0+c2tfc2h1dGRvd24gJiBSQ1ZfU0hVVERPV04pICYmICFmaXJzdF9wYWNrZXRfbGVuZ3RoKHNrKSkKKwkJbWFzayAmPSB+KFBPTExJTiB8IFBPTExSRE5PUk0pOwogCiAJcmV0dXJuIG1hc2s7CiAKZGlmZiAtLWdpdCBhL25ldC9pcHY2L2lwdjZfc29ja2dsdWUuYyBiL25ldC9pcHY2L2lwdjZfc29ja2dsdWUuYwppbmRleCAxNGY1NGViLi40ZjdhYWY2IDEwMDY0NAotLS0gYS9uZXQvaXB2Ni9pcHY2X3NvY2tnbHVlLmMKKysrIGIvbmV0L2lwdjYvaXB2Nl9zb2NrZ2x1ZS5jCkBAIC00OTYsMTMgKzQ5NiwxNyBAQAogCQkJZ290byBlX2ludmFsOwogCiAJCWlmICh2YWwpIHsKKwkJCXN0cnVjdCBuZXRfZGV2aWNlICpkZXY7CisKIAkJCWlmIChzay0+c2tfYm91bmRfZGV2X2lmICYmIHNrLT5za19ib3VuZF9kZXZfaWYgIT0gdmFsKQogCQkJCWdvdG8gZV9pbnZhbDsKIAotCQkJaWYgKF9fZGV2X2dldF9ieV9pbmRleChuZXQsIHZhbCkgPT0gTlVMTCkgeworCQkJZGV2ID0gZGV2X2dldF9ieV9pbmRleChuZXQsIHZhbCk7CisJCQlpZiAoIWRldikgewogCQkJCXJldHYgPSAtRU5PREVWOwogCQkJCWJyZWFrOwogCQkJfQorCQkJZGV2X3B1dChkZXYpOwogCQl9CiAJCW5wLT5tY2FzdF9vaWYgPSB2YWw7CiAJCXJldHYgPSAwOwpkaWZmIC0tZ2l0IGEvbmV0L2lyZGEvaXJjb21tL2lyY29tbV90dHlfYXR0YWNoLmMgYi9uZXQvaXJkYS9pcmNvbW0vaXJjb21tX3R0eV9hdHRhY2guYwppbmRleCBlYWZjMDEwLi4zYzE3NTQwIDEwMDY0NAotLS0gYS9uZXQvaXJkYS9pcmNvbW0vaXJjb21tX3R0eV9hdHRhY2guYworKysgYi9uZXQvaXJkYS9pcmNvbW0vaXJjb21tX3R0eV9hdHRhY2guYwpAQCAtMzAsNiArMzAsNyBAQAogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwogCiAjaW5jbHVkZSA8bGludXgvaW5pdC5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAKICNpbmNsdWRlIDxuZXQvaXJkYS9pcmRhLmg+CiAjaW5jbHVkZSA8bmV0L2lyZGEvaXJsbXAuaD4KZGlmZiAtLWdpdCBhL25ldC9pcmRhL2lybGFuL2lybGFuX2NvbW1vbi5jIGIvbmV0L2lyZGEvaXJsYW4vaXJsYW5fY29tbW9uLmMKaW5kZXggNjIxMTY4Mi4uMzE1ZWFkMyAxMDA2NDQKLS0tIGEvbmV0L2lyZGEvaXJsYW4vaXJsYW5fY29tbW9uLmMKKysrIGIvbmV0L2lyZGEvaXJsYW4vaXJsYW5fY29tbW9uLmMKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiAjaW5jbHVkZSA8bGludXgvZXJybm8uaD4KICNpbmNsdWRlIDxsaW51eC9wcm9jX2ZzLmg+CisjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KICNpbmNsdWRlIDxsaW51eC9zZXFfZmlsZS5oPgogI2luY2x1ZGUgPGxpbnV4L3JhbmRvbS5oPgogI2luY2x1ZGUgPGxpbnV4L25ldGRldmljZS5oPgpkaWZmIC0tZ2l0IGEvbmV0L2lyZGEvaXJsYW4vaXJsYW5fZXRoLmMgYi9uZXQvaXJkYS9pcmxhbi9pcmxhbl9ldGguYwppbmRleCA3YjZiNjMxLi5kMzQwMTEwIDEwMDY0NAotLS0gYS9uZXQvaXJkYS9pcmxhbi9pcmxhbl9ldGguYworKysgYi9uZXQvaXJkYS9pcmxhbi9pcmxhbl9ldGguYwpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2luZXRkZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9pZl9hcnAuaD4KICNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KKyNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgogI2luY2x1ZGUgPG5ldC9hcnAuaD4KIAogI2luY2x1ZGUgPG5ldC9pcmRhL2lyZGEuaD4KZGlmZiAtLWdpdCBhL25ldC9pcmRhL2lybmV0L2lybmV0X2lyZGEuYyBiL25ldC9pcmRhL2lybmV0L2lybmV0X2lyZGEuYwppbmRleCBjZjlhNGI1Li5jY2NjMmU5IDEwMDY0NAotLS0gYS9uZXQvaXJkYS9pcm5ldC9pcm5ldF9pcmRhLmMKKysrIGIvbmV0L2lyZGEvaXJuZXQvaXJuZXRfaXJkYS5jCkBAIC05LDYgKzksNyBAQAogICovCiAKICNpbmNsdWRlICJpcm5ldF9pcmRhLmgiCQkvKiBQcml2YXRlIGhlYWRlciAqLworI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KICNpbmNsdWRlIDxhc20vdW5hbGlnbmVkLmg+CiAKZGlmZiAtLWdpdCBhL25ldC9pcmRhL2lybmV0L2lybmV0X3BwcC5jIGIvbmV0L2lyZGEvaXJuZXQvaXJuZXRfcHBwLmMKaW5kZXggNjhjYmNiMS4uN2RlYTg4MiAxMDA2NDQKLS0tIGEvbmV0L2lyZGEvaXJuZXQvaXJuZXRfcHBwLmMKKysrIGIvbmV0L2lyZGEvaXJuZXQvaXJuZXRfcHBwLmMKQEAgLTEzLDYgKzEzLDcgQEAKICAqCTIpIGFzIGEgY29udHJvbCBjaGFubmVsICh3cml0ZSBjb21tYW5kcywgcmVhZCBldmVudHMpCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc21wX2xvY2suaD4KICNpbmNsdWRlICJpcm5ldF9wcHAuaCIJCS8qIFByaXZhdGUgaGVhZGVyICovCiAvKiBQbGVhc2UgcHV0IG90aGVyIGhlYWRlcnMgaW4gaXJuZXQuaCAtIFRoYW5rcyAqLwpkaWZmIC0tZ2l0IGEvbmV0L21hYzgwMjExL2lic3MuYyBiL25ldC9tYWM4MDIxMS9pYnNzLmMKaW5kZXggOTIwZWM4Ny4uNmVhZjY5OCAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL2lic3MuYworKysgYi9uZXQvbWFjODAyMTEvaWJzcy5jCkBAIC01NDQsNyArNTQ0LDcgQEAKIAkJICAgICAgICIlcE1cbiIsIGJzcy0+Y2Jzcy5ic3NpZCwgaWZpYnNzLT5ic3NpZCk7CiAjZW5kaWYgLyogQ09ORklHX01BQzgwMjExX0lCU1NfREVCVUcgKi8KIAotCWlmIChic3MgJiYgbWVtY21wKGlmaWJzcy0+YnNzaWQsIGJzcy0+Y2Jzcy5ic3NpZCwgRVRIX0FMRU4pKSB7CisJaWYgKGJzcyAmJiAhbWVtY21wKGlmaWJzcy0+YnNzaWQsIGJzcy0+Y2Jzcy5ic3NpZCwgRVRIX0FMRU4pKSB7CiAJCXByaW50ayhLRVJOX0RFQlVHICIlczogU2VsZWN0ZWQgSUJTUyBCU1NJRCAlcE0iCiAJCSAgICAgICAiIGJhc2VkIG9uIGNvbmZpZ3VyZWQgU1NJRFxuIiwKIAkJICAgICAgIHNkYXRhLT5kZXYtPm5hbWUsIGJzcy0+Y2Jzcy5ic3NpZCk7CkBAIC04MjksNyArODI5LDcgQEAKIAkJaWYgKCFzZGF0YS0+dS5pYnNzLnNzaWRfbGVuKQogCQkJY29udGludWU7CiAJCXNkYXRhLT51Lmlic3MubGFzdF9zY2FuX2NvbXBsZXRlZCA9IGppZmZpZXM7Ci0JCWllZWU4MDIxMV9zdGFfZmluZF9pYnNzKHNkYXRhKTsKKwkJbW9kX3RpbWVyKCZzZGF0YS0+dS5pYnNzLnRpbWVyLCAwKTsKIAl9CiAJbXV0ZXhfdW5sb2NrKCZsb2NhbC0+aWZsaXN0X210eCk7CiB9CmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvcmM4MDIxMV9waWRfZGVidWdmcy5jIGIvbmV0L21hYzgwMjExL3JjODAyMTFfcGlkX2RlYnVnZnMuYwppbmRleCBhNTkwNDNmYi4uNDU2NjcwNSAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3JjODAyMTFfcGlkX2RlYnVnZnMuYworKysgYi9uZXQvbWFjODAyMTEvcmM4MDIxMV9waWRfZGVidWdmcy5jCkBAIC02LDYgKzYsNyBAQAogICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxsaW51eC9wb2xsLmg+CiAjaW5jbHVkZSA8bGludXgvbmV0ZGV2aWNlLmg+CmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvcnguYyBiL25ldC9tYWM4MDIxMS9yeC5jCmluZGV4IGMwMTU4OGYuLjcxNzBiZjQgMTAwNjQ0Ci0tLSBhL25ldC9tYWM4MDIxMS9yeC5jCisrKyBiL25ldC9tYWM4MDIxMS9yeC5jCkBAIC0yMTY0LDExICsyMTY0LDE3IEBACiAKIAlza2IgPSByeC5za2I7CiAKLQlsaXN0X2Zvcl9lYWNoX2VudHJ5X3JjdShzZGF0YSwgJmxvY2FsLT5pbnRlcmZhY2VzLCBsaXN0KSB7CisJaWYgKHJ4LnNkYXRhICYmIGllZWU4MDIxMV9pc19kYXRhKGhkci0+ZnJhbWVfY29udHJvbCkpIHsKKwkJcnguZmxhZ3MgfD0gSUVFRTgwMjExX1JYX1JBX01BVENIOworCQlwcmVwYXJlcyA9IHByZXBhcmVfZm9yX2hhbmRsZXJzKHJ4LnNkYXRhLCAmcngsIGhkcik7CisJCWlmIChwcmVwYXJlcykKKwkJCXByZXYgPSByeC5zZGF0YTsKKwl9IGVsc2UgbGlzdF9mb3JfZWFjaF9lbnRyeV9yY3Uoc2RhdGEsICZsb2NhbC0+aW50ZXJmYWNlcywgbGlzdCkgewogCQlpZiAoIW5ldGlmX3J1bm5pbmcoc2RhdGEtPmRldikpCiAJCQljb250aW51ZTsKIAotCQlpZiAoc2RhdGEtPnZpZi50eXBlID09IE5MODAyMTFfSUZUWVBFX01PTklUT1IpCisJCWlmIChzZGF0YS0+dmlmLnR5cGUgPT0gTkw4MDIxMV9JRlRZUEVfTU9OSVRPUiB8fAorCQkgICAgc2RhdGEtPnZpZi50eXBlID09IE5MODAyMTFfSUZUWVBFX0FQX1ZMQU4pCiAJCQljb250aW51ZTsKIAogCQlyeC5mbGFncyB8PSBJRUVFODAyMTFfUlhfUkFfTUFUQ0g7CkBAIC0yNDQ3LDYgKzI0NTMsOCBAQAogCXN0cnVjdCBpZWVlODAyMTFfc3VwcG9ydGVkX2JhbmQgKnNiYW5kOwogCXN0cnVjdCBpZWVlODAyMTFfcnhfc3RhdHVzICpzdGF0dXMgPSBJRUVFODAyMTFfU0tCX1JYQ0Ioc2tiKTsKIAorCVdBUk5fT05fT05DRShzb2Z0aXJxX2NvdW50KCkgPT0gMCk7CisKIAlpZiAoV0FSTl9PTihzdGF0dXMtPmJhbmQgPCAwIHx8CiAJCSAgICBzdGF0dXMtPmJhbmQgPj0gSUVFRTgwMjExX05VTV9CQU5EUykpCiAJCWdvdG8gZHJvcDsKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS9zdGFfaW5mby5jIGIvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKaW5kZXggZWVjMDAxNC4uNTk0ZjIzMSAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKKysrIGIvbmV0L21hYzgwMjExL3N0YV9pbmZvLmMKQEAgLTM2MSw2ICszNjEsNyBAQAogCQkJCQkgICAgIHUuYXApOwogCiAJCWRydl9zdGFfbm90aWZ5KGxvY2FsLCAmc2RhdGEtPnZpZiwgU1RBX05PVElGWV9BREQsICZzdGEtPnN0YSk7CisJCXNkYXRhID0gc3RhLT5zZGF0YTsKIAl9CiAKICNpZmRlZiBDT05GSUdfTUFDODAyMTFfVkVSQk9TRV9ERUJVRwpAQCAtNDk2LDYgKzQ5Nyw3IEBACiAKIAkJZHJ2X3N0YV9ub3RpZnkobG9jYWwsICZzZGF0YS0+dmlmLCBTVEFfTk9USUZZX1JFTU9WRSwKIAkJCSAgICAgICAmKCpzdGEpLT5zdGEpOworCQlzZGF0YSA9ICgqc3RhKS0+c2RhdGE7CiAJfQogCiAJaWYgKGllZWU4MDIxMV92aWZfaXNfbWVzaCgmc2RhdGEtPnZpZikpIHsKZGlmZiAtLWdpdCBhL25ldC9tYWM4MDIxMS90eC5jIGIvbmV0L21hYzgwMjExL3R4LmMKaW5kZXggZmQ0MDI4Mi4uZGI0YmRhNiAxMDA2NDQKLS0tIGEvbmV0L21hYzgwMjExL3R4LmMKKysrIGIvbmV0L21hYzgwMjExL3R4LmMKQEAgLTE3MDQsNyArMTcwNCw4IEBACiAJaWYgKCFpc19tdWx0aWNhc3RfZXRoZXJfYWRkcihoZHIuYWRkcjEpKSB7CiAJCXJjdV9yZWFkX2xvY2soKTsKIAkJc3RhID0gc3RhX2luZm9fZ2V0KGxvY2FsLCBoZHIuYWRkcjEpOwotCQlpZiAoc3RhKQorCQkvKiBYWFg6IGluIHRoZSBmdXR1cmUsIHVzZSBzZGF0YSB0byBsb29rIHVwIHRoZSBzdGEgKi8KKwkJaWYgKHN0YSAmJiBzdGEtPnNkYXRhID09IHNkYXRhKQogCQkJc3RhX2ZsYWdzID0gZ2V0X3N0YV9mbGFncyhzdGEpOwogCQlyY3VfcmVhZF91bmxvY2soKTsKIAl9CmRpZmYgLS1naXQgYS9uZXQvbWFjODAyMTEvdXRpbC5jIGIvbmV0L21hYzgwMjExL3V0aWwuYwppbmRleCBkZDY1NjQzLi5hZWI2NWIzIDEwMDY0NAotLS0gYS9uZXQvbWFjODAyMTEvdXRpbC5jCisrKyBiL25ldC9tYWM4MDIxMS91dGlsLmMKQEAgLTMzOSw3ICszMzksNyBAQAogCXN0cnVjdCBpZWVlODAyMTFfdHhfaW5mbyAqaW5mbyA9IElFRUU4MDIxMV9TS0JfQ0Ioc2tiKTsKIAogCWlmIChXQVJOX09OKCFpbmZvLT5jb250cm9sLnZpZikpIHsKLQkJa2ZyZWUoc2tiKTsKKwkJa2ZyZWVfc2tiKHNrYik7CiAJCXJldHVybjsKIAl9CiAKQEAgLTM2Nyw3ICszNjcsNyBAQAogCQlzdHJ1Y3QgaWVlZTgwMjExX3R4X2luZm8gKmluZm8gPSBJRUVFODAyMTFfU0tCX0NCKHNrYik7CiAKIAkJaWYgKFdBUk5fT04oIWluZm8tPmNvbnRyb2wudmlmKSkgewotCQkJa2ZyZWUoc2tiKTsKKwkJCWtmcmVlX3NrYihza2IpOwogCQkJY29udGludWU7CiAJCX0KIApkaWZmIC0tZ2l0IGEvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfY29yZS5jIGIvbmV0L25ldGZpbHRlci9uZl9jb25udHJhY2tfY29yZS5jCmluZGV4IDdjOWVjM2QuLmNhNmU2OGQgMTAwNjQ0Ci0tLSBhL25ldC9uZXRmaWx0ZXIvbmZfY29ubnRyYWNrX2NvcmUuYworKysgYi9uZXQvbmV0ZmlsdGVyL25mX2Nvbm50cmFja19jb3JlLmMKQEAgLTE0LDYgKzE0LDcgQEAKICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L25ldGZpbHRlci5oPgogI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc2tidWZmLmg+CiAjaW5jbHVkZSA8bGludXgvcHJvY19mcy5oPgogI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KZGlmZiAtLWdpdCBhL25ldC9zY2hlZC9hY3RfcGVkaXQuYyBiL25ldC9zY2hlZC9hY3RfcGVkaXQuYwppbmRleCA5NmMwZWQxLi42YjAzNTlhIDEwMDY0NAotLS0gYS9uZXQvc2NoZWQvYWN0X3BlZGl0LmMKKysrIGIvbmV0L3NjaGVkL2FjdF9wZWRpdC5jCkBAIC0zNCw3ICszNCw3IEBACiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IG5sYV9wb2xpY3kgcGVkaXRfcG9saWN5W1RDQV9QRURJVF9NQVggKyAxXSA9IHsKLQlbVENBX1BFRElUX1BBUk1TXQk9IHsgLmxlbiA9IHNpemVvZihzdHJ1Y3QgdGNmX3BlZGl0KSB9LAorCVtUQ0FfUEVESVRfUEFSTVNdCT0geyAubGVuID0gc2l6ZW9mKHN0cnVjdCB0Y19wZWRpdCkgfSwKIH07CiAKIHN0YXRpYyBpbnQgdGNmX3BlZGl0X2luaXQoc3RydWN0IG5sYXR0ciAqbmxhLCBzdHJ1Y3QgbmxhdHRyICplc3QsCmRpZmYgLS1naXQgYS9uZXQvc2NoZWQvY2xzX2FwaS5jIGIvbmV0L3NjaGVkL2Nsc19hcGkuYwppbmRleCA2YTUzNjk0Li43Y2Y2YzBmIDEwMDY0NAotLS0gYS9uZXQvc2NoZWQvY2xzX2FwaS5jCisrKyBiL25ldC9zY2hlZC9jbHNfYXBpLmMKQEAgLTM1MCw3ICszNTAsNyBAQAogCXRjbSA9IE5MTVNHX0RBVEEobmxoKTsKIAl0Y20tPnRjbV9mYW1pbHkgPSBBRl9VTlNQRUM7CiAJdGNtLT50Y21fX3BhZDEgPSAwOwotCXRjbS0+dGNtX19wYWQxID0gMDsKKwl0Y20tPnRjbV9fcGFkMiA9IDA7CiAJdGNtLT50Y21faWZpbmRleCA9IHFkaXNjX2Rldih0cC0+cSktPmlmaW5kZXg7CiAJdGNtLT50Y21fcGFyZW50ID0gdHAtPmNsYXNzaWQ7CiAJdGNtLT50Y21faW5mbyA9IFRDX0hfTUFLRSh0cC0+cHJpbywgdHAtPnByb3RvY29sKTsKZGlmZiAtLWdpdCBhL25ldC9zdW5ycGMveHBydHJkbWEvc3ZjX3JkbWFfdHJhbnNwb3J0LmMgYi9uZXQvc3VucnBjL3hwcnRyZG1hL3N2Y19yZG1hX3RyYW5zcG9ydC5jCmluZGV4IDBjZjVlOGMuLjNmYTU3NTEgMTAwNjQ0Ci0tLSBhL25ldC9zdW5ycGMveHBydHJkbWEvc3ZjX3JkbWFfdHJhbnNwb3J0LmMKKysrIGIvbmV0L3N1bnJwYy94cHJ0cmRtYS9zdmNfcmRtYV90cmFuc3BvcnQuYwpAQCAtNDIsNiArNDIsNyBAQAogI2luY2x1ZGUgPGxpbnV4L3N1bnJwYy9zdmNfeHBydC5oPgogI2luY2x1ZGUgPGxpbnV4L3N1bnJwYy9kZWJ1Zy5oPgogI2luY2x1ZGUgPGxpbnV4L3N1bnJwYy9ycGNfcmRtYS5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KICNpbmNsdWRlIDxyZG1hL2liX3ZlcmJzLmg+CiAjaW5jbHVkZSA8cmRtYS9yZG1hX2NtLmg+CmRpZmYgLS1naXQgYS9uZXQvdW5peC9hZl91bml4LmMgYi9uZXQvdW5peC9hZl91bml4LmMKaW5kZXggNTFhYjQ5Ny4uZmM4MjBjZCAxMDA2NDQKLS0tIGEvbmV0L3VuaXgvYWZfdW5peC5jCisrKyBiL25ldC91bml4L2FmX3VuaXguYwpAQCAtMTA3NCw2ICsxMDc0LDggQEAKIAllcnIgPSAtRUNPTk5SRUZVU0VEOwogCWlmIChvdGhlci0+c2tfc3RhdGUgIT0gVENQX0xJU1RFTikKIAkJZ290byBvdXRfdW5sb2NrOworCWlmIChvdGhlci0+c2tfc2h1dGRvd24gJiBSQ1ZfU0hVVERPV04pCisJCWdvdG8gb3V0X3VubG9jazsKIAogCWlmICh1bml4X3JlY3ZxX2Z1bGwob3RoZXIpKSB7CiAJCWVyciA9IC1FQUdBSU47CmRpZmYgLS1naXQgYS9uZXQvd2lyZWxlc3MvY29yZS5jIGIvbmV0L3dpcmVsZXNzL2NvcmUuYwppbmRleCA0NWIyYmUzLi5hNTk1ZjcxIDEwMDY0NAotLS0gYS9uZXQvd2lyZWxlc3MvY29yZS5jCisrKyBiL25ldC93aXJlbGVzcy9jb3JlLmMKQEAgLTE0LDYgKzE0LDcgQEAKICNpbmNsdWRlIDxsaW51eC9kZXZpY2UuaD4KICNpbmNsdWRlIDxsaW51eC9ldGhlcmRldmljZS5oPgogI2luY2x1ZGUgPGxpbnV4L3J0bmV0bGluay5oPgorI2luY2x1ZGUgPGxpbnV4L3NjaGVkLmg+CiAjaW5jbHVkZSA8bmV0L2dlbmV0bGluay5oPgogI2luY2x1ZGUgPG5ldC9jZmc4MDIxMS5oPgogI2luY2x1ZGUgIm5sODAyMTEuaCIKZGlmZiAtLWdpdCBhL25ldC93aXJlbGVzcy9ubDgwMjExLmMgYi9uZXQvd2lyZWxlc3Mvbmw4MDIxMS5jCmluZGV4IGVkZGFiMDkuLmNhM2M5MmEgMTAwNjQ0Ci0tLSBhL25ldC93aXJlbGVzcy9ubDgwMjExLmMKKysrIGIvbmV0L3dpcmVsZXNzL25sODAyMTEuYwpAQCAtNDAyOSw3ICs0MDI5LDcgQEAKIAlyZGV2ID0gY2ZnODAyMTFfZ2V0X2Rldl9mcm9tX2luZm8oaW5mbyk7CiAJaWYgKElTX0VSUihyZGV2KSkgewogCQllcnIgPSBQVFJfRVJSKHJkZXYpOwotCQlnb3RvIG91dDsKKwkJZ290byBvdXRfcnRubDsKIAl9CiAKIAluZXQgPSBnZXRfbmV0X25zX2J5X3BpZChwaWQpOwpAQCAtNDA0OSw2ICs0MDQ5LDcgQEAKIAlwdXRfbmV0KG5ldCk7CiAgb3V0OgogCWNmZzgwMjExX3VubG9ja19yZGV2KHJkZXYpOworIG91dF9ydG5sOgogCXJ0bmxfdW5sb2NrKCk7CiAJcmV0dXJuIGVycjsKIH0KZGlmZiAtLWdpdCBhL3NjcmlwdHMvS2J1aWxkLmluY2x1ZGUgYi9zY3JpcHRzL0tidWlsZC5pbmNsdWRlCmluZGV4IDRmOWMxOTAuLmM2N2U3M2UgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvS2J1aWxkLmluY2x1ZGUKKysrIGIvc2NyaXB0cy9LYnVpbGQuaW5jbHVkZQpAQCAtMTAwLDcgKzEwMCw3IEBACiAjIFVzYWdlOiBjZmxhZ3MteSArPSAkKGNhbGwgYXMtaW5zdHIsaW5zdHIsb3B0aW9uMSxvcHRpb24yKQogCiBhcy1pbnN0ciA9ICQoY2FsbCB0cnktcnVuLFwKLQllY2hvIC1lICIkKDEpIiB8ICQoQ0MpICQoS0JVSUxEX0FGTEFHUykgLWMgLXhhc3NlbWJsZXIgLW8gIiQkVE1QIiAtLCQoMiksJCgzKSkKKwkvYmluL2VjaG8gLWUgIiQoMSkiIHwgJChDQykgJChLQlVJTERfQUZMQUdTKSAtYyAteGFzc2VtYmxlciAtbyAiJCRUTVAiIC0sJCgyKSwkKDMpKQogCiAjIGNjLW9wdGlvbgogIyBVc2FnZTogY2ZsYWdzLXkgKz0gJChjYWxsIGNjLW9wdGlvbiwtbWFyY2g9d2luY2hpcC1jNiwtbWFyY2g9aTU4NikKZGlmZiAtLWdpdCBhL3NjcmlwdHMvTWFrZWZpbGUubGliIGIvc2NyaXB0cy9NYWtlZmlsZS5saWIKaW5kZXggN2E3Nzc4Ny4uZmZkYWZiMiAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZS5saWIKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5saWIKQEAgLTIwOCw3ICsyMDgsNyBAQAogCiAjIEJ6aXAyIGFuZCBMWk1BIGRvIG5vdCBpbmNsdWRlIHNpemUgaW4gZmlsZS4uLiBzbyB3ZSBoYXZlIHRvIGZha2UgdGhhdDsKICMgYXBwZW5kIHRoZSBzaXplIGFzIGEgMzItYml0IGxpdHRsZWVuZGlhbiBudW1iZXIgYXMgZ3ppcCBkb2VzLgotc2l6ZV9hcHBlbmQgPSBlY2hvIC1uZSAkKHNoZWxsCQkJCQkJXAorc2l6ZV9hcHBlbmQgPSAvYmluL2VjaG8gLW5lICQoc2hlbGwJCQkJCVwKIGRlY19zaXplPTA7CQkJCQkJCQlcCiBmb3IgRiBpbiAkMTsgZG8JCQkJCQkJCVwKIAlmc2l6ZT0kJChzdGF0IC1jICIlcyIgJCRGKTsJCQkJCVwKZGlmZiAtLWdpdCBhL3NjcmlwdHMvY2hlY2trY29uZmlnc3ltYm9scy5zaCBiL3NjcmlwdHMvY2hlY2trY29uZmlnc3ltYm9scy5zaAppbmRleCAzOTY3N2M4Li40NmJlM2M1IDEwMDc1NQotLS0gYS9zY3JpcHRzL2NoZWNra2NvbmZpZ3N5bWJvbHMuc2gKKysrIGIvc2NyaXB0cy9jaGVja2tjb25maWdzeW1ib2xzLnNoCkBAIC05LDcgKzksNyBAQAogIyBEb2luZyB0aGlzIG9uY2UgYXQgdGhlIGJlZ2lubmluZyBzYXZlcyBhIGxvdCBvZiB0aW1lLCBvbiBhIGNhY2hlLWhvdCB0cmVlLgogS2NvbmZpZ3M9ImBmaW5kIC4gLW5hbWUgJ0tjb25maWcnIC1vIC1uYW1lICdLY29uZmlnKltefl0nYCIKIAotZWNobyAtZSAiRmlsZSBsaXN0IFx0dW5kZWZpbmVkIHN5bWJvbCB1c2VkIgorL2Jpbi9lY2hvIC1lICJGaWxlIGxpc3QgXHR1bmRlZmluZWQgc3ltYm9sIHVzZWQiCiBmaW5kICRwYXRocyAtbmFtZSAnKi5bY2hTXScgLW8gLW5hbWUgJ01ha2VmaWxlJyAtbyAtbmFtZSAnTWFrZWZpbGUqW15+XSd8IHdoaWxlIHJlYWQgaQogZG8KIAkjIE91dHB1dCB0aGUgYmFyZSBLY29uZmlnIHZhcmlhYmxlIGFuZCB0aGUgZmlsZW5hbWU7IHRoZSBfTU9EVUxFIHBhcnQgYXQKQEAgLTU0LDYgKzU0LDYgQEAKIAkjIGJleW9uZCB0aGUgcHVycG9zZSBvZiB0aGlzIHNjcmlwdC4KIAlzeW1iX2JhcmU9YGVjaG8gJHN5bWIgfCBzZWQgLWUgJ3MvX01PRFVMRS8vJ2AKIAlpZiAhIGdyZXAgLXEgIlw8JHN5bWJfYmFyZVw+IiAkS2NvbmZpZ3M7IHRoZW4KLQkJZWNobyAtZSAiJGZpbGVzOiBcdCRzeW1iIgorCQkvYmluL2VjaG8gLWUgIiRmaWxlczogXHQkc3ltYiIKIAlmaQogZG9uZXxzb3J0CmRpZmYgLS1naXQgYS9zY3JpcHRzL2NoZWNrcGF0Y2gucGwgYi9zY3JpcHRzL2NoZWNrcGF0Y2gucGwKaW5kZXggODdiYmI4Yi4uYmM0MTE0ZiAxMDA3NTUKLS0tIGEvc2NyaXB0cy9jaGVja3BhdGNoLnBsCisrKyBiL3NjcmlwdHMvY2hlY2twYXRjaC5wbApAQCAtMiw3ICsyLDcgQEAKICMgKGMpIDIwMDEsIERhdmUgSm9uZXMuIDxkYXZlakByZWRoYXQuY29tPiAodGhlIGZpbGUgaGFuZGxpbmcgYml0KQogIyAoYykgMjAwNSwgSm9lbCBTY2hvcHAgPGpzY2hvcHBAYXVzdGluLmlibS5jb20+ICh0aGUgdWdseSBiaXQpCiAjIChjKSAyMDA3LDIwMDgsIEFuZHkgV2hpdGNyb2Z0IDxhcHdAdWsuaWJtLmNvbT4gKG5ldyBjb25kaXRpb25zLCB0ZXN0IHN1aXRlKQotIyAoYykgMjAwOCwgQW5keSBXaGl0Y3JvZnQgPGFwd0BjYW5vbmljYWwuY29tPgorIyAoYykgMjAwOCwyMDA5LCBBbmR5IFdoaXRjcm9mdCA8YXB3QGNhbm9uaWNhbC5jb20+CiAjIExpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdQTCBMaWNlbnNlIHZlcnNpb24gMgogCiB1c2Ugc3RyaWN0OwpAQCAtMTAsNyArMTAsNyBAQAogbXkgJFAgPSAkMDsKICRQID1+IHNALiovQEBnOwogCi1teSAkViA9ICcwLjI5JzsKK215ICRWID0gJzAuMzAnOwogCiB1c2UgR2V0b3B0OjpMb25nIHF3KDpjb25maWcgbm9fYXV0b19hYmJyZXYpOwogCkBAIC0xMzAsNyArMTMwLDEwIEBACiAKIG15ICRlbWl0dGVkX2NvcnJ1cHQgPSAwOwogCi1vdXIgJElkZW50ICAgICAgID0gcXJ7W0EtWmEtel9dW0EtWmEtelxkX10qfTsKK291ciAkSWRlbnQJPSBxcnsKKwkJCVtBLVphLXpfXVtBLVphLXpcZF9dKgorCQkJKD86XHMqXCNcI1xzKltBLVphLXpfXVtBLVphLXpcZF9dKikqCisJCX14Owogb3VyICRTdG9yYWdlCT0gcXJ7ZXh0ZXJufHN0YXRpY3xhc21saW5rYWdlfTsKIG91ciAkU3BhcnNlCT0gcXJ7CiAJCQlfX3VzZXJ8CkBAIC05OTcsMjMgKzEwMDAsMjUgQEAKIAogc3ViIHBvc3NpYmxlIHsKIAlteSAoJHBvc3NpYmxlLCAkbGluZSkgPSBAXzsKLQotCXByaW50ICJDSEVDSzwkcG9zc2libGU+ICgkbGluZSlcbiIgaWYgKCRkYmdfcG9zc2libGUgPiAyKTsKLQlpZiAoJHBvc3NpYmxlICF+IC8oPzoKKwlteSAkbm90UGVybWl0dGVkID0gcXJ7KD86CiAJCV4oPzoKIAkJCSRNb2RpZmllcnwKIAkJCSRTdG9yYWdlfAogCQkJJFR5cGV8Ci0JCQlERUZJTkVfXFMrfAorCQkJREVGSU5FX1xTKworCQkpJHwKKwkJXig/OgogCQkJZ290b3wKIAkJCXJldHVybnwKIAkJCWNhc2V8CiAJCQllbHNlfAogCQkJYXNtfF9fYXNtX198CiAJCQlkbwotCQkpJHwKKwkJKSg/OlxzfCQpfAogCQleKD86dHlwZWRlZnxzdHJ1Y3R8ZW51bSlcYgotCSAgICApL3gpIHsKKwkgICAgKX14OworCXdhcm4gIkNIRUNLPCRwb3NzaWJsZT4gKCRsaW5lKVxuIiBpZiAoJGRiZ19wb3NzaWJsZSA+IDIpOworCWlmICgkcG9zc2libGUgIX4gJG5vdFBlcm1pdHRlZCkgewogCQkjIENoZWNrIGZvciBtb2RpZmllcnMuCiAJCSRwb3NzaWJsZSA9fiBzL1xzKiRTdG9yYWdlXHMqLy9nOwogCQkkcG9zc2libGUgPX4gcy9ccyokU3BhcnNlXHMqLy9nOwpAQCAtMTAyMiw4ICsxMDI3LDEwIEBACiAJCX0gZWxzaWYgKCRwb3NzaWJsZSA9fiAvXHMvKSB7CiAJCQkkcG9zc2libGUgPX4gcy9ccyokVHlwZVxzKi8vZzsKIAkJCWZvciBteSAkbW9kaWZpZXIgKHNwbGl0KCcgJywgJHBvc3NpYmxlKSkgewotCQkJCXdhcm4gIk1PRElGSUVSOiAkbW9kaWZpZXIgKCRwb3NzaWJsZSkgKCRsaW5lKVxuIiBpZiAoJGRiZ19wb3NzaWJsZSk7Ci0JCQkJcHVzaChAbW9kaWZpZXJMaXN0LCAkbW9kaWZpZXIpOworCQkJCWlmICgkbW9kaWZpZXIgIX4gJG5vdFBlcm1pdHRlZCkgeworCQkJCQl3YXJuICJNT0RJRklFUjogJG1vZGlmaWVyICgkcG9zc2libGUpICgkbGluZSlcbiIgaWYgKCRkYmdfcG9zc2libGUpOworCQkJCQlwdXNoKEBtb2RpZmllckxpc3QsICRtb2RpZmllcik7CisJCQkJfQogCQkJfQogCiAJCX0gZWxzZSB7CkBAIC0xMTM4LDYgKzExNDUsNyBAQAogCSMgc3VwcHJlc3Npb24gZmxhZ3MKIAlteSAlc3VwcHJlc3NfaWZicmFjZXM7CiAJbXkgJXN1cHByZXNzX3doaWxldHJhaWxlcnM7CisJbXkgJXN1cHByZXNzX2V4cG9ydDsKIAogCSMgUHJlLXNjYW4gdGhlIHBhdGNoIHNhbml0aXppbmcgdGhlIGxpbmVzLgogCSMgUHJlLXNjYW4gdGhlIHBhdGNoIGxvb2tpbmcgZm9yIGFueSBfX3NldHVwIGRvY3VtZW50YXRpb24uCkBAIC0xMjMwLDcgKzEyMzgsNiBAQAogCQkkbGluZW5yKys7CiAKIAkJbXkgJHJhd2xpbmUgPSAkcmF3bGluZXNbJGxpbmVuciAtIDFdOwotCQlteSAkaHVua19saW5lID0gKCRyZWFsY250ICE9IDApOwogCiAjZXh0cmFjdCB0aGUgbGluZSByYW5nZSBpbiB0aGUgZmlsZSBhZnRlciB0aGUgcGF0Y2ggaXMgYXBwbGllZAogCQlpZiAoJGxpbmU9fi9eXEBcQCAtXGQrKD86LFxkKyk/IFwrKFxkKykoLChcZCspKT8gXEBcQC8pIHsKQEAgLTEyNDcsNiArMTI1NCw3IEBACiAKIAkJCSVzdXBwcmVzc19pZmJyYWNlcyA9ICgpOwogCQkJJXN1cHByZXNzX3doaWxldHJhaWxlcnMgPSAoKTsKKwkJCSVzdXBwcmVzc19leHBvcnQgPSAoKTsKIAkJCW5leHQ7CiAKICMgdHJhY2sgdGhlIGxpbmUgbnVtYmVyIGFzIHdlIG1vdmUgdGhyb3VnaCB0aGUgaHVuaywgbm90ZSB0aGF0CkBAIC0xMjcwLDYgKzEyNzgsOCBAQAogCQkJJHJlYWxjbnQtLTsKIAkJfQogCisJCW15ICRodW5rX2xpbmUgPSAoJHJlYWxjbnQgIT0gMCk7CisKICNtYWtlIHVwIHRoZSBoYW5kbGUgZm9yIGFueSBlcnJvciB3ZSByZXBvcnQgb24gdGhpcyBsaW5lCiAJCSRwcmVmaXggPSAiJGZpbGVuYW1lOiRyZWFsbGluZTogIiBpZiAoJGVtYWNzICYmICRmaWxlKTsKIAkJJHByZWZpeCA9ICIkZmlsZW5hbWU6JGxpbmVucjogIiBpZiAoJGVtYWNzICYmICEkZmlsZSk7CkBAIC0xNDIwLDEzICsxNDMwLDIyIEBACiAJCX0KIAogIyBDaGVjayBmb3IgcG90ZW50aWFsICdiYXJlJyB0eXBlcwotCQlteSAoJHN0YXQsICRjb25kLCAkbGluZV9ucl9uZXh0LCAkcmVtYWluX25leHQsICRvZmZfbmV4dCk7CisJCW15ICgkc3RhdCwgJGNvbmQsICRsaW5lX25yX25leHQsICRyZW1haW5fbmV4dCwgJG9mZl9uZXh0LAorCQkgICAgJHJlYWxsaW5lX25leHQpOwogCQlpZiAoJHJlYWxjbnQgJiYgJGxpbmUgPX4gLy5ccypcUy8pIHsKIAkJCSgkc3RhdCwgJGNvbmQsICRsaW5lX25yX25leHQsICRyZW1haW5fbmV4dCwgJG9mZl9uZXh0KSA9CiAJCQkJY3R4X3N0YXRlbWVudF9ibG9jaygkbGluZW5yLCAkcmVhbGNudCwgMCk7CiAJCQkkc3RhdCA9fiBzL1xuLi9cbiAvZzsKIAkJCSRjb25kID1+IHMvXG4uL1xuIC9nOwogCisJCQkjIEZpbmQgdGhlIHJlYWwgbmV4dCBsaW5lLgorCQkJJHJlYWxsaW5lX25leHQgPSAkbGluZV9ucl9uZXh0OworCQkJaWYgKGRlZmluZWQgJHJlYWxsaW5lX25leHQgJiYKKwkJCSAgICAoIWRlZmluZWQgJGxpbmVzWyRyZWFsbGluZV9uZXh0IC0gMV0gfHwKKwkJCSAgICAgc3Vic3RyKCRsaW5lc1skcmVhbGxpbmVfbmV4dCAtIDFdLCAkb2ZmX25leHQpID1+IC9eXHMqJC8pKSB7CisJCQkJJHJlYWxsaW5lX25leHQrKzsKKwkJCX0KKwogCQkJbXkgJHMgPSAkc3RhdDsKIAkJCSRzID1+IHMvey4qJC8vczsKIApAQCAtMTY2MSw4ICsxNjgwLDggQEAKIAkJfQogCiAjIGNoZWNrIGZvciBpbml0aWFsaXNhdGlvbiB0byBhZ2dyZWdhdGVzIG9wZW4gYnJhY2Ugb24gdGhlIG5leHQgbGluZQotCQlpZiAoJHByZXZsaW5lID1+IC8kRGVjbGFyZVxzKiRJZGVudFxzKj1ccyokLyAmJgotCQkgICAgJGxpbmUgPX4gL14uXHMqey8pIHsKKwkJaWYgKCRsaW5lID1+IC9eLlxzKnsvICYmCisJCSAgICAkcHJldmxpbmUgPX4gLyg/Ol58W149XSk9XHMqJC8pIHsKIAkJCUVSUk9SKCJ0aGF0IG9wZW4gYnJhY2UgeyBzaG91bGQgYmUgb24gdGhlIHByZXZpb3VzIGxpbmVcbiIgLiAkaGVyZXByZXYpOwogCQl9CiAKQEAgLTE2ODcsMjEgKzE3MDYsNDAgQEAKIAkJJGxpbmUgPX4gc0AvLy4qQEA7CiAJCSRvcGxpbmUgPX4gc0AvLy4qQEA7CiAKLSNFWFBPUlRfU1lNQk9MIHNob3VsZCBpbW1lZGlhdGVseSBmb2xsb3cgaXRzIGZ1bmN0aW9uIGNsb3NpbmcgfS4KLQkJaWYgKCgkbGluZSA9fiAvRVhQT1JUX1NZTUJPTC4qXCgoLiopXCkvKSB8fAotCQkgICAgKCRsaW5lID1+IC9FWFBPUlRfVU5VU0VEX1NZTUJPTC4qXCgoLiopXCkvKSkgeworIyBFWFBPUlRfU1lNQk9MIHNob3VsZCBpbW1lZGlhdGVseSBmb2xsb3cgdGhlIHRoaW5nIGl0IGlzIGV4cG9ydGluZywgY29uc2lkZXIKKyMgdGhlIHdob2xlIHN0YXRlbWVudC4KKyNwcmludCAiQVBXIDwkbGluZXNbJHJlYWxsaW5lX25leHQgLSAxXT5cbiI7CisJCWlmIChkZWZpbmVkICRyZWFsbGluZV9uZXh0ICYmCisJCSAgICBleGlzdHMgJGxpbmVzWyRyZWFsbGluZV9uZXh0IC0gMV0gJiYKKwkJICAgICFkZWZpbmVkICRzdXBwcmVzc19leHBvcnR7JHJlYWxsaW5lX25leHR9ICYmCisJCSAgICAoJGxpbmVzWyRyZWFsbGluZV9uZXh0IC0gMV0gPX4gL0VYUE9SVF9TWU1CT0wuKlwoKC4qKVwpLyB8fAorCQkgICAgICRsaW5lc1skcmVhbGxpbmVfbmV4dCAtIDFdID1+IC9FWFBPUlRfVU5VU0VEX1NZTUJPTC4qXCgoLiopXCkvKSkgewogCQkJbXkgJG5hbWUgPSAkMTsKLQkJCWlmICgkcHJldmxpbmUgIX4gLyg/OgotCQkJCV4ufXwKKwkJCWlmICgkc3RhdCAhfiAvKD86CisJCQkJXG4ufVxzKiR8CiAJCQkJXi5ERUZJTkVfJElkZW50XChcUSRuYW1lXEVcKXwKIAkJCQleLkRFQ0xBUkVfJElkZW50XChcUSRuYW1lXEVcKXwKIAkJCQleLkxJU1RfSEVBRFwoXFEkbmFtZVxFXCl8Ci0JCQkJXi4kVHlwZVxzKlwoXHMqXCpccypcUSRuYW1lXEVccypcKVxzKlwofAotCQkJCVxiXFEkbmFtZVxFKD86XHMrJEF0dHJpYnV0ZSk/XHMqKD86O3w9fFxbKQorCQkJCV4uKD86JFN0b3JhZ2VccyspPyRUeXBlXHMqXChccypcKlxzKlxRJG5hbWVcRVxzKlwpXHMqXCh8CisJCQkJXGJcUSRuYW1lXEUoPzpccyskQXR0cmlidXRlKSpccyooPzo7fD18XFt8XCgpCiAJCQkgICAgKS94KSB7Ci0JCQkJV0FSTigiRVhQT1JUX1NZTUJPTChmb28pOyBzaG91bGQgaW1tZWRpYXRlbHkgZm9sbG93IGl0cyBmdW5jdGlvbi92YXJpYWJsZVxuIiAuICRoZXJlY3Vycik7CisjcHJpbnQgIkZPTyBBPCRsaW5lc1skcmVhbGxpbmVfbmV4dCAtIDFdPiBzdGF0PCRzdGF0PiBuYW1lPCRuYW1lPlxuIjsKKwkJCQkkc3VwcHJlc3NfZXhwb3J0eyRyZWFsbGluZV9uZXh0fSA9IDI7CisJCQl9IGVsc2UgeworCQkJCSRzdXBwcmVzc19leHBvcnR7JHJlYWxsaW5lX25leHR9ID0gMTsKIAkJCX0KIAkJfQorCQlpZiAoIWRlZmluZWQgJHN1cHByZXNzX2V4cG9ydHskbGluZW5yfSAmJgorCQkgICAgJHByZXZsaW5lID1+IC9eLlxzKiQvICYmCisJCSAgICAoJGxpbmUgPX4gL0VYUE9SVF9TWU1CT0wuKlwoKC4qKVwpLyB8fAorCQkgICAgICRsaW5lID1+IC9FWFBPUlRfVU5VU0VEX1NZTUJPTC4qXCgoLiopXCkvKSkgeworI3ByaW50ICJGT08gQiA8JGxpbmVzWyRsaW5lbnIgLSAxXT5cbiI7CisJCQkkc3VwcHJlc3NfZXhwb3J0eyRsaW5lbnJ9ID0gMjsKKwkJfQorCQlpZiAoZGVmaW5lZCAkc3VwcHJlc3NfZXhwb3J0eyRsaW5lbnJ9ICYmCisJCSAgICAkc3VwcHJlc3NfZXhwb3J0eyRsaW5lbnJ9ID09IDIpIHsKKwkJCVdBUk4oIkVYUE9SVF9TWU1CT0woZm9vKTsgc2hvdWxkIGltbWVkaWF0ZWx5IGZvbGxvdyBpdHMgZnVuY3Rpb24vdmFyaWFibGVcbiIgLiAkaGVyZWN1cnIpOworCQl9CiAKICMgY2hlY2sgZm9yIGV4dGVybmFsIGluaXRpYWxpc2Vycy4KIAkJaWYgKCRsaW5lID1+IC9eLiRUeXBlXHMqJElkZW50XHMqKD86XHMrJE1vZGlmaWVyKSpccyo9XHMqKDB8TlVMTHxmYWxzZSlccyo7LykgewpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9nZXRfbWFpbnRhaW5lci5wbCBiL3NjcmlwdHMvZ2V0X21haW50YWluZXIucGwKaW5kZXggY2RiNDRiNi4uMTAyYjc2NiAxMDA3NTUKLS0tIGEvc2NyaXB0cy9nZXRfbWFpbnRhaW5lci5wbAorKysgYi9zY3JpcHRzL2dldF9tYWludGFpbmVyLnBsCkBAIC0xMyw3ICsxMyw3IEBACiB1c2Ugc3RyaWN0OwogCiBteSAkUCA9ICQwOwotbXkgJFYgPSAnMC4yMCc7CitteSAkViA9ICcwLjIxJzsKIAogdXNlIEdldG9wdDo6TG9uZyBxdyg6Y29uZmlnIG5vX2F1dG9fYWJicmV2KTsKIApAQCAtMzcsNiArMzcsNyBAQAogbXkgJHdlYiA9IDA7CiBteSAkc3Vic3lzdGVtID0gMDsKIG15ICRzdGF0dXMgPSAwOworbXkgJGtleXdvcmRzID0gMTsKIG15ICRmcm9tX2ZpbGVuYW1lID0gMDsKIG15ICRwYXR0ZXJuX2RlcHRoID0gMDsKIG15ICR2ZXJzaW9uID0gMDsKQEAgLTg0LDYgKzg1LDcgQEAKIAkJJ3NjbSEnID0+IFwkc2NtLAogCQknd2ViIScgPT4gXCR3ZWIsCiAJCSdwYXR0ZXJuLWRlcHRoPWknID0+IFwkcGF0dGVybl9kZXB0aCwKKwkJJ2t8a2V5d29yZHMhJyA9PiBcJGtleXdvcmRzLAogCQknZnxmaWxlJyA9PiBcJGZyb21fZmlsZW5hbWUsCiAJCSd2fHZlcnNpb24nID0+IFwkdmVyc2lvbiwKIAkJJ2h8aGVscCcgPT4gXCRoZWxwLApAQCAtMTMyLDYgKzEzNCw4IEBACiAjIyBSZWFkIE1BSU5UQUlORVJTIGZvciB0eXBlL3ZhbHVlIHBhaXJzCiAKIG15IEB0eXBldmFsdWUgPSAoKTsKK215ICVrZXl3b3JkX2hhc2g7CisKIG9wZW4oTUFJTlQsICI8JHtsa19wYXRofU1BSU5UQUlORVJTIikgfHwgZGllICIkUDogQ2FuJ3Qgb3BlbiBNQUlOVEFJTkVSU1xuIjsKIHdoaWxlICg8TUFJTlQ+KSB7CiAgICAgbXkgJGxpbmUgPSAkXzsKQEAgLTE0OSw2ICsxNTMsOCBAQAogCSAgICBpZiAoKC1kICR2YWx1ZSkpIHsKIAkJJHZhbHVlID1+IHNAKFteL10pJEAkMS9AOwogCSAgICB9CisJfSBlbHNpZiAoJHR5cGUgZXEgIksiKSB7CisJICAgICRrZXl3b3JkX2hhc2h7QHR5cGV2YWx1ZX0gPSAkdmFsdWU7CiAJfQogCXB1c2goQHR5cGV2YWx1ZSwgIiR0eXBlOiR2YWx1ZSIpOwogICAgIH0gZWxzaWYgKCEvXihccykqJC8pIHsKQEAgLTE4OCw2ICsxOTQsNyBAQAogCiBteSBAZmlsZXMgPSAoKTsKIG15IEByYW5nZSA9ICgpOworbXkgQGtleXdvcmRfdHZpID0gKCk7CiAKIGZvcmVhY2ggbXkgJGZpbGUgKEBBUkdWKSB7CiAgICAgIyNpZiAkZmlsZSBpcyBhIGRpcmVjdG9yeSBhbmQgaXQgbGFja3MgYSB0cmFpbGluZyBzbGFzaCwgYWRkIG9uZQpAQCAtMTk4LDExICsyMDUsMjQgQEAKICAgICB9CiAgICAgaWYgKCRmcm9tX2ZpbGVuYW1lKSB7CiAJcHVzaChAZmlsZXMsICRmaWxlKTsKKwlpZiAoLWYgJGZpbGUgJiYgJGtleXdvcmRzKSB7CisJICAgIG9wZW4oRklMRSwgIjwkZmlsZSIpIG9yIGRpZSAiJFA6IENhbid0IG9wZW4gJHtmaWxlfVxuIjsKKwkgICAgd2hpbGUgKDxGSUxFPikgeworCQlteSAkcGF0Y2hfbGluZSA9ICRfOworCQlmb3JlYWNoIG15ICRsaW5lIChrZXlzICVrZXl3b3JkX2hhc2gpIHsKKwkJICAgIGlmICgkcGF0Y2hfbGluZSA9fiBtL14uKiRrZXl3b3JkX2hhc2h7JGxpbmV9L3gpIHsKKwkJCXB1c2goQGtleXdvcmRfdHZpLCAkbGluZSk7CisJCSAgICB9CisJCX0KKwkgICAgfQorCSAgICBjbG9zZShGSUxFKTsKKwl9CiAgICAgfSBlbHNlIHsKIAlteSAkZmlsZV9jbnQgPSBAZmlsZXM7CiAJbXkgJGxhc3RmaWxlOwogCW9wZW4oUEFUQ0gsICI8JGZpbGUiKSBvciBkaWUgIiRQOiBDYW4ndCBvcGVuICR7ZmlsZX1cbiI7CiAJd2hpbGUgKDxQQVRDSD4pIHsKKwkgICAgbXkgJHBhdGNoX2xpbmUgPSAkXzsKIAkgICAgaWYgKG0vXlwrXCtcK1xzKyhcUyspLykgewogCQlteSAkZmlsZW5hbWUgPSAkMTsKIAkJJGZpbGVuYW1lID1+IHNAXlteL10qL0BAOwpAQCAtMjEzLDYgKzIzMywxMiBAQAogCQlpZiAoJGVtYWlsX2dpdF9ibGFtZSkgewogCQkgICAgcHVzaChAcmFuZ2UsICIkbGFzdGZpbGU6JDE6JDIiKTsKIAkJfQorCSAgICB9IGVsc2lmICgka2V5d29yZHMpIHsKKwkJZm9yZWFjaCBteSAkbGluZSAoa2V5cyAla2V5d29yZF9oYXNoKSB7CisJCSAgICBpZiAoJHBhdGNoX2xpbmUgPX4gbS9eWystXS4qJGtleXdvcmRfaGFzaHskbGluZX0veCkgeworCQkJcHVzaChAa2V5d29yZF90dmksICRsaW5lKTsKKwkJICAgIH0KKwkJfQogCSAgICB9CiAJfQogCWNsb3NlKFBBVENIKTsKQEAgLTI4Niw2ICszMTIsMTMgQEAKICAgICB9CiB9CiAKK2lmICgka2V5d29yZHMpIHsKKyAgICBAa2V5d29yZF90dmkgPSBzb3J0X2FuZF91bmlxKEBrZXl3b3JkX3R2aSk7CisgICAgZm9yZWFjaCBteSAkbGluZSAoQGtleXdvcmRfdHZpKSB7CisJYWRkX2NhdGVnb3JpZXMoJGxpbmUpOworICAgIH0KK30KKwogaWYgKCRlbWFpbCkgewogICAgIGZvcmVhY2ggbXkgJGNoaWVmIChAcGVuZ3Vpbl9jaGllZikgewogCWlmICgkY2hpZWYgPX4gbS9eKC4qKTooLiopLykgewpAQCAtMzg0LDYgKzQxNyw3IEBACiAKIE90aGVyIG9wdGlvbnM6CiAgIC0tcGF0dGVybi1kZXB0aCA9PiBOdW1iZXIgb2YgcGF0dGVybiBkaXJlY3RvcnkgdHJhdmVyc2FscyAoZGVmYXVsdDogMCAoYWxsKSkKKyAgLS1rZXl3b3JkcyA9PiBzY2FuIHBhdGNoIGZvciBrZXl3b3JkcyAoZGVmYXVsdDogMSAob24pKQogICAtLXZlcnNpb24gPT4gc2hvdyB2ZXJzaW9uCiAgIC0taGVscCA9PiBzaG93IHRoaXMgaGVscCBpbmZvcm1hdGlvbgogCkBAIC00ODYsNyArNTIwLDYgQEAKIH0KIAogc3ViIGZpbmRfc3RhcnRpbmdfaW5kZXggewotCiAgICAgbXkgKCRpbmRleCkgPSBAXzsKIAogICAgIHdoaWxlICgkaW5kZXggPiAwKSB7CmRpZmYgLS1naXQgYS9zY3JpcHRzL2hlYWRlcnNfaW5zdGFsbC5wbCBiL3NjcmlwdHMvaGVhZGVyc19pbnN0YWxsLnBsCmluZGV4IGM2YWU0MDUuLmI4OWNhMmMgMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvaGVhZGVyc19pbnN0YWxsLnBsCisrKyBiL3NjcmlwdHMvaGVhZGVyc19pbnN0YWxsLnBsCkBAIC0yMCw3ICsyMCw3IEBACiAKIG15ICgkcmVhZGRpciwgJGluc3RhbGxkaXIsICRhcmNoLCBAZmlsZXMpID0gQEFSR1Y7CiAKLW15ICR1bmlmZGVmID0gInNjcmlwdHMvdW5pZmRlZiAtVV9fS0VSTkVMX18iOworbXkgJHVuaWZkZWYgPSAic2NyaXB0cy91bmlmZGVmIC1VX19LRVJORUxfXyAtRF9fRVhQT1JURURfSEVBREVSU19fIjsKIAogZm9yZWFjaCBteSAkZmlsZSAoQGZpbGVzKSB7CiAJbG9jYWwgKklORklMRTsKZGlmZiAtLWdpdCBhL3NjcmlwdHMvbWtjb21waWxlX2ggYi9zY3JpcHRzL21rY29tcGlsZV9oCmluZGV4IDZhMTJkZDkuLmJjZTNkMGYgMTAwNzU1Ci0tLSBhL3NjcmlwdHMvbWtjb21waWxlX2gKKysrIGIvc2NyaXB0cy9ta2NvbXBpbGVfaApAQCAtMSwzICsxLDUgQEAKKyMhL2Jpbi9zaAorCiBUQVJHRVQ9JDEKIEFSQ0g9JDIKIFNNUD0kMwpAQCAtNTAsNyArNTIsNyBAQAogIyBUcnVuY2F0ZSB0byBtYXhpbXVtIGxlbmd0aAogCiBVVFNfTEVOPTY0Ci1VVFNfVFJVTkNBVEU9InNlZCAtZSBzL1woLlx7MSwkVVRTX0xFTlx9XCkuKi9cMS8iCitVVFNfVFJVTkNBVEU9ImN1dCAtYiAtJFVUU19MRU4iCiAKICMgR2VuZXJhdGUgYSB0ZW1wb3JhcnkgY29tcGlsZS5oCiAKQEAgLTY2LDkgKzY4LDEzIEBACiAgIGVjaG8gXCNkZWZpbmUgTElOVVhfQ09NUElMRV9IT1NUIFwiYGhvc3RuYW1lIHwgJFVUU19UUlVOQ0FURWBcIgogCiAgIGlmIFsgLXggL2Jpbi9kbnNkb21haW5uYW1lIF07IHRoZW4KLSAgICBlY2hvIFwjZGVmaW5lIExJTlVYX0NPTVBJTEVfRE9NQUlOIFwiYGRuc2RvbWFpbm5hbWUgfCAkVVRTX1RSVU5DQVRFYFwiCisgICAgZG9tYWluPWBkbnNkb21haW5uYW1lIDI+IC9kZXYvbnVsbGAKICAgZWxpZiBbIC14IC9iaW4vZG9tYWlubmFtZSBdOyB0aGVuCi0gICAgZWNobyBcI2RlZmluZSBMSU5VWF9DT01QSUxFX0RPTUFJTiBcImBkb21haW5uYW1lIHwgJFVUU19UUlVOQ0FURWBcIgorICAgIGRvbWFpbj1gZG9tYWlubmFtZSAyPiAvZGV2L251bGxgCisgIGZpCisKKyAgaWYgWyAtbiAiJGRvbWFpbiIgXTsgdGhlbgorICAgIGVjaG8gXCNkZWZpbmUgTElOVVhfQ09NUElMRV9ET01BSU4gXCJgZWNobyAkZG9tYWluIHwgJFVUU19UUlVOQ0FURWBcIgogICBlbHNlCiAgICAgZWNobyBcI2RlZmluZSBMSU5VWF9DT01QSUxFX0RPTUFJTgogICBmaQpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9wYWNrYWdlL01ha2VmaWxlIGIvc2NyaXB0cy9wYWNrYWdlL01ha2VmaWxlCmluZGV4IGZhNGEwYTEuLmY2N2NjODggMTAwNjQ0Ci0tLSBhL3NjcmlwdHMvcGFja2FnZS9NYWtlZmlsZQorKysgYi9zY3JpcHRzL3BhY2thZ2UvTWFrZWZpbGUKQEAgLTE4LDYgKzE4LDkgQEAKICMgZSkgZ2VuZXJhdGUgdGhlIHJwbSBmaWxlcywgYmFzZWQgb24ga2VybmVsLnNwZWMKICMgLSBVc2UgLy4gdG8gYXZvaWQgdGFyIHBhY2tpbmcganVzdCB0aGUgc3ltbGluawogCisjIE5vdGUgdGhhdCB0aGUgcnBtLXBrZyB0YXJnZXQgY2Fubm90IGJlIHVzZWQgd2l0aCBLQlVJTERfT1VUUFVULAorIyBidXQgdGhlIGJpbnJwbS1wa2cgdGFyZ2V0IGNhbjsgZm9yIHNvbWUgcmVhc29uIE89IGdldHMgaWdub3JlZC4KKwogIyBEbyB3ZSBoYXZlIHJwbWJ1aWxkLCBvdGhlcndpc2UgZmFsbCBiYWNrIHRvIHRoZSBvbGRlciBycG0KIFJQTSA6PSAkKHNoZWxsIGlmIFsgLXggIi91c3IvYmluL3JwbWJ1aWxkIiBdOyB0aGVuIGVjaG8gcnBtYnVpbGQ7IFwKIAkgICAgICAgICAgIGVsc2UgZWNobyBycG07IGZpKQpAQCAtMzMsNiArMzYsMTIgQEAKIAkkKENPTkZJR19TSEVMTCkgJChNS1NQRUMpID4gJEAKIAogcnBtLXBrZyBycG06ICQob2JqdHJlZSkva2VybmVsLnNwZWMgRk9SQ0UKKwlAaWYgdGVzdCAtbiAiJChLQlVJTERfT1VUUFVUKSI7IHRoZW4gXAorCQllY2hvICJCdWlsZGluZyBzb3VyY2UgKyBiaW5hcnkgUlBNIGlzIG5vdCBwb3NzaWJsZSBvdXRzaWRlIHRoZSI7IFwKKwkJZWNobyAia2VybmVsIHNvdXJjZSB0cmVlLiBEb24ndCBzZXQgS0JVSUxEX09VVFBVVCwgb3IgdXNlIHRoZSI7IFwKKwkJZWNobyAiYmlucnBtLXBrZyB0YXJnZXQgaW5zdGVhZC4iOyBcCisJCWZhbHNlOyBcCisJZmkKIAkkKE1BS0UpIGNsZWFuCiAJJChQUkVWKSBsbiAtc2YgJChzcmN0cmVlKSAkKEtFUk5FTFBBVEgpCiAJJChDT05GSUdfU0hFTEwpICQoc3JjdHJlZSkvc2NyaXB0cy9zZXRsb2NhbHZlcnNpb24gPiAkKG9ianRyZWUpLy5zY212ZXJzaW9uCkBAIC02MSw3ICs3MCw3IEBACiAJc2V0IC1lOyBcCiAJbXYgLWYgJChvYmp0cmVlKS8udG1wX3ZlcnNpb24gJChvYmp0cmVlKS8udmVyc2lvbgogCi0JJChSUE0pICQoUlBNT1BUUykgLS1kZWZpbmUgIl9idWlsZGRpciAkKHNyY3RyZWUpIiAtLXRhcmdldCBcCisJJChSUE0pICQoUlBNT1BUUykgLS1kZWZpbmUgIl9idWlsZGRpciAkKG9ianRyZWUpIiAtLXRhcmdldCBcCiAJCSQoVVRTX01BQ0hJTkUpIC1iYiAkPAogCiBjbGVhbi1maWxlcyArPSAkKG9ianRyZWUpL2Jpbmtlcm5lbC5zcGVjCmRpZmYgLS1naXQgYS9zY3JpcHRzL3BhY2thZ2UvbWtzcGVjIGIvc2NyaXB0cy9wYWNrYWdlL21rc3BlYwppbmRleCAzZDkzZjhjLi40N2JkZDJmIDEwMDc1NQotLS0gYS9zY3JpcHRzL3BhY2thZ2UvbWtzcGVjCisrKyBiL3NjcmlwdHMvcGFja2FnZS9ta3NwZWMKQEAgLTcwLDcgKzcwLDcgQEAKIGVjaG8gJ21rZGlyIC1wICRSUE1fQlVJTERfUk9PVC9saWIvZmlybXdhcmUnCiBlY2hvICIlZW5kaWYiCiAKLWVjaG8gJ0lOU1RBTExfTU9EX1BBVEg9JFJQTV9CVUlMRF9ST09UIG1ha2UgJXtfc21wX21mbGFnc30gbW9kdWxlc19pbnN0YWxsJworZWNobyAnSU5TVEFMTF9NT0RfUEFUSD0kUlBNX0JVSUxEX1JPT1QgbWFrZSAle19zbXBfbWZsYWdzfSBLQlVJTERfU1JDPSBtb2R1bGVzX2luc3RhbGwnCiBlY2hvICIlaWZhcmNoIGlhNjQiCiBlY2hvICdjcCAkS0JVSUxEX0lNQUdFICRSUE1fQlVJTERfUk9PVCciL2Jvb3QvZWZpL3ZtbGludXotJEtFUk5FTFJFTEVBU0UiCiBlY2hvICdsbiAtcyAnImVmaS92bWxpbnV6LSRLRVJORUxSRUxFQVNFIiAnJFJQTV9CVUlMRF9ST09UJyIvYm9vdC8iCmRpZmYgLS1naXQgYS9zZWN1cml0eS9rZXlzL2tleWN0bC5jIGIvc2VjdXJpdHkva2V5cy9rZXljdGwuYwppbmRleCAyZmIyOGVmLi4wNmVjNzIyIDEwMDY0NAotLS0gYS9zZWN1cml0eS9rZXlzL2tleWN0bC5jCisrKyBiL3NlY3VyaXR5L2tleXMva2V5Y3RsLmMKQEAgLTg3Myw3ICs4NzMsNyBAQAogCS8qIG90aGVyd2lzZSBzcGVjaWZ5IHRoZSBkZXN0aW5hdGlvbiBrZXlyaW5nIHJlY29yZGVkIGluIHRoZQogCSAqIGF1dGhvcmlzYXRpb24ga2V5IChhbnkgS0VZX1NQRUNfKl9LRVlSSU5HKSAqLwogCWlmIChyaW5naWQgPj0gS0VZX1NQRUNfUkVRVUVTVE9SX0tFWVJJTkcpIHsKLQkJKl9kZXN0X2tleXJpbmcgPSBya2EtPmRlc3Rfa2V5cmluZzsKKwkJKl9kZXN0X2tleXJpbmcgPSBrZXlfZ2V0KHJrYS0+ZGVzdF9rZXlyaW5nKTsKIAkJcmV0dXJuIDA7CiAJfQogCmRpZmYgLS1naXQgYS9zb3VuZC9hcm0vYWFjaS5jIGIvc291bmQvYXJtL2FhY2kuYwppbmRleCBkYzc4MjcyLi4xZjBmODIxIDEwMDY0NAotLS0gYS9zb3VuZC9hcm0vYWFjaS5jCisrKyBiL3NvdW5kL2FybS9hYWNpLmMKQEAgLTkzNyw2ICs5MzcsNyBAQAogCXN0cnVjdCBzbmRfYWM5NyAqYWM5NzsKIAlpbnQgcmV0OwogCisJd3JpdGVsKDAsIGFhY2ktPmJhc2UgKyBBQzk3X1BPV0VSRE9XTik7CiAJLyoKIAkgKiBBc3NlcnQgQUFDSVJFU0VUIGZvciAydXMKIAkgKi8KZGlmZiAtLWdpdCBhL3NvdW5kL3BjaS9idDg3eC5jIGIvc291bmQvcGNpL2J0ODd4LmMKaW5kZXggMjQ1ODVjNi4uNGUyYjkyNSAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2J0ODd4LmMKKysrIGIvc291bmQvcGNpL2J0ODd4LmMKQEAgLTgwOCw2ICs4MDgsOCBAQAogCUJUX0RFVklDRShQQ0lfREVWSUNFX0lEX0JST09LVFJFRV84NzgsIDB4MTAwMiwgMHgwMDAxLCBHRU5FUklDKSwKIAkvKiBMZWFkdGVrIFdpbmZhc3QgdHYgMjAwMHhwIGRlbHV4ICovCiAJQlRfREVWSUNFKFBDSV9ERVZJQ0VfSURfQlJPT0tUUkVFXzg3OCwgMHgxMDdkLCAweDY2MDYsIEdFTkVSSUMpLAorCS8qIFBpbm5hY2xlIFBDVFYgKi8KKwlCVF9ERVZJQ0UoUENJX0RFVklDRV9JRF9CUk9PS1RSRUVfODc4LCAweDExYmQsIDB4MDAxMiwgR0VORVJJQyksCiAJLyogVm9vZG9vIFRWIDIwMCAqLwogCUJUX0RFVklDRShQQ0lfREVWSUNFX0lEX0JST09LVFJFRV84NzgsIDB4MTIxYSwgMHgzMDAwLCBHRU5FUklDKSwKIAkvKiBBc2tleSBDb21wdXRlciBDb3JwLiBNYWdpY1RWaWV3Jzk5ICovCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaGRhL3BhdGNoX252aGRtaS5jIGIvc291bmQvcGNpL2hkYS9wYXRjaF9udmhkbWkuYwppbmRleCBjODQzNWM5Li45ZmI2MDI3IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaGRhL3BhdGNoX252aGRtaS5jCisrKyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfbnZoZG1pLmMKQEAgLTI5LDYgKzI5LDkgQEAKICNpbmNsdWRlICJoZGFfY29kZWMuaCIKICNpbmNsdWRlICJoZGFfbG9jYWwuaCIKIAorLyogZGVmaW5lIGJlbG93IHRvIHJlc3RyaWN0IHRoZSBzdXBwb3J0ZWQgcmF0ZXMgYW5kIGZvcm1hdHMgKi8KKy8qICNkZWZpbmUgTElNSVRFRF9SQVRFX0ZNVF9TVVBQT1JUICovCisKIHN0cnVjdCBudmhkbWlfc3BlYyB7CiAJc3RydWN0IGhkYV9tdWx0aV9vdXQgbXVsdGlvdXQ7CiAKQEAgLTYwLDYgKzYzLDIyIEBACiAJe30gLyogdGVybWluYXRvciAqLwogfTsKIAorI2lmZGVmIExJTUlURURfUkFURV9GTVRfU1VQUE9SVAorLyogc3VwcG9ydCBvbmx5IHRoZSBzYWZlIGZvcm1hdCBhbmQgcmF0ZSAqLworI2RlZmluZSBTVVBQT1JURURfUkFURVMJCVNORFJWX1BDTV9SQVRFXzQ4MDAwCisjZGVmaW5lIFNVUFBPUlRFRF9NQVhCUFMJMTYKKyNkZWZpbmUgU1VQUE9SVEVEX0ZPUk1BVFMJU05EUlZfUENNX0ZNVEJJVF9TMTZfTEUKKyNlbHNlCisvKiBzdXBwb3J0IGFsbCByYXRlcyBhbmQgZm9ybWF0cyAqLworI2RlZmluZSBTVVBQT1JURURfUkFURVMgXAorCShTTkRSVl9QQ01fUkFURV8yMjA1MCB8IFNORFJWX1BDTV9SQVRFXzQ0MTAwIHwgU05EUlZfUENNX1JBVEVfNDgwMDAgfFwKKwlTTkRSVl9QQ01fUkFURV84ODIwMCB8IFNORFJWX1BDTV9SQVRFXzk2MDAwIHwgU05EUlZfUENNX1JBVEVfMTc2NDAwIHxcCisJIFNORFJWX1BDTV9SQVRFXzE5MjAwMCkKKyNkZWZpbmUgU1VQUE9SVEVEX01BWEJQUwkyNAorI2RlZmluZSBTVVBQT1JURURfRk9STUFUUyBcCisJKFNORFJWX1BDTV9GTVRCSVRfUzE2X0xFIHwgU05EUlZfUENNX0ZNVEJJVF9TMzJfTEUpCisjZW5kaWYKKwogLyoKICAqIENvbnRyb2xzCiAgKi8KQEAgLTI1OCw5ICsyNzcsOSBAQAogCS5jaGFubmVsc19taW4gPSAyLAogCS5jaGFubmVsc19tYXggPSA4LAogCS5uaWQgPSBOdl9NYXN0ZXJfQ29udmVydF9uaWQsCi0JLnJhdGVzID0gU05EUlZfUENNX1JBVEVfNDgwMDAsCi0JLm1heGJwcyA9IDE2LAotCS5mb3JtYXRzID0gU05EUlZfUENNX0ZNVEJJVF9TMTZfTEUsCisJLnJhdGVzID0gU1VQUE9SVEVEX1JBVEVTLAorCS5tYXhicHMgPSBTVVBQT1JURURfTUFYQlBTLAorCS5mb3JtYXRzID0gU1VQUE9SVEVEX0ZPUk1BVFMsCiAJLm9wcyA9IHsKIAkJLm9wZW4gPSBudmhkbWlfZGlnX3BsYXliYWNrX3BjbV9vcGVuLAogCQkuY2xvc2UgPSBudmhkbWlfZGlnX3BsYXliYWNrX3BjbV9jbG9zZV84Y2gsCkBAIC0yNzMsOSArMjkyLDkgQEAKIAkuY2hhbm5lbHNfbWluID0gMiwKIAkuY2hhbm5lbHNfbWF4ID0gMiwKIAkubmlkID0gTnZfTWFzdGVyX0NvbnZlcnRfbmlkLAotCS5yYXRlcyA9IFNORFJWX1BDTV9SQVRFXzQ4MDAwLAotCS5tYXhicHMgPSAxNiwKLQkuZm9ybWF0cyA9IFNORFJWX1BDTV9GTVRCSVRfUzE2X0xFLAorCS5yYXRlcyA9IFNVUFBPUlRFRF9SQVRFUywKKwkubWF4YnBzID0gU1VQUE9SVEVEX01BWEJQUywKKwkuZm9ybWF0cyA9IFNVUFBPUlRFRF9GT1JNQVRTLAogCS5vcHMgPSB7CiAJCS5vcGVuID0gbnZoZG1pX2RpZ19wbGF5YmFja19wY21fb3BlbiwKIAkJLmNsb3NlID0gbnZoZG1pX2RpZ19wbGF5YmFja19wY21fY2xvc2VfMmNoLApkaWZmIC0tZ2l0IGEvc291bmQvcGNpL2hkYS9wYXRjaF9yZWFsdGVrLmMgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX3JlYWx0ZWsuYwppbmRleCA0NzBmZDc0Li5jMDhjYTY2IDEwMDY0NAotLS0gYS9zb3VuZC9wY2kvaGRhL3BhdGNoX3JlYWx0ZWsuYworKysgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX3JlYWx0ZWsuYwpAQCAtMjc1LDcgKzI3NSw3IEBACiAJc3RydWN0IHNuZF9rY29udHJvbF9uZXcgKmNhcF9taXhlcjsJLyogY2FwdHVyZSBtaXhlciAqLwogCXVuc2lnbmVkIGludCBiZWVwX2FtcDsJLyogYmVlcCBhbXAgdmFsdWUsIHNldCB2aWEgc2V0X2JlZXBfYW1wKCkgKi8KIAotCWNvbnN0IHN0cnVjdCBoZGFfdmVyYiAqaW5pdF92ZXJic1s1XTsJLyogaW5pdGlhbGl6YXRpb24gdmVyYnMKKwljb25zdCBzdHJ1Y3QgaGRhX3ZlcmIgKmluaXRfdmVyYnNbMTBdOwkvKiBpbml0aWFsaXphdGlvbiB2ZXJicwogCQkJCQkJICogZG9uJ3QgZm9yZ2V0IE5VTEwKIAkJCQkJCSAqIHRlcm1pbmF0aW9uIQogCQkJCQkJICovCmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaGRhL3BhdGNoX3NpZ21hdGVsLmMgYi9zb3VuZC9wY2kvaGRhL3BhdGNoX3NpZ21hdGVsLmMKaW5kZXggYTliMjY4Mi4uNjZjMDg3NiAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2hkYS9wYXRjaF9zaWdtYXRlbC5jCisrKyBiL3NvdW5kL3BjaS9oZGEvcGF0Y2hfc2lnbWF0ZWwuYwpAQCAtMTU4LDYgKzE1OCw3IEBACiAJU1RBQ19EOTY1XzVTVF9OT19GUCwKIAlTVEFDX0RFTExfM1NULAogCVNUQUNfREVMTF9CSU9TLAorCVNUQUNfOTI3WF9WT0xLTk9CLAogCVNUQUNfOTI3WF9NT0RFTFMKIH07CiAKQEAgLTkwNyw2ICs5MDgsMTYgQEAKIAl7fQogfTsKIAorc3RhdGljIHN0cnVjdCBoZGFfdmVyYiBkZWxsXzNzdF9jb3JlX2luaXRbXSA9IHsKKwkvKiBkb24ndCBzZXQgZGVsdGEgYml0ICovCisJezB4MjQsIEFDX1ZFUkJfU0VUX1ZPTFVNRV9LTk9CX0NPTlRST0wsIDB4N2Z9LAorCS8qIHVubXV0ZSBub2RlIDB4MWIgKi8KKwl7MHgxYiwgQUNfVkVSQl9TRVRfQU1QX0dBSU5fTVVURSwgMHhiMDAwfSwKKwkvKiBzZWxlY3Qgbm9kZSAweDAzIGFzIERBQyAqLworCXsweDBiLCBBQ19WRVJCX1NFVF9DT05ORUNUX1NFTCwgMHgwMX0sCisJe30KK307CisKIHN0YXRpYyBzdHJ1Y3QgaGRhX3ZlcmIgc3RhYzkyN3hfY29yZV9pbml0W10gPSB7CiAJLyogc2V0IG1hc3RlciB2b2x1bWUgYW5kIGRpcmVjdCBjb250cm9sICovCQogCXsgMHgyNCwgQUNfVkVSQl9TRVRfVk9MVU1FX0tOT0JfQ09OVFJPTCwgMHhmZn0sCkBAIC05MTUsNiArOTI2LDE0IEBACiAJe30KIH07CiAKK3N0YXRpYyBzdHJ1Y3QgaGRhX3ZlcmIgc3RhYzkyN3hfdm9sa25vYl9jb3JlX2luaXRbXSA9IHsKKwkvKiBkb24ndCBzZXQgZGVsdGEgYml0ICovCisJezB4MjQsIEFDX1ZFUkJfU0VUX1ZPTFVNRV9LTk9CX0NPTlRST0wsIDB4N2Z9LAorCS8qIGVuYWJsZSBhbmFsb2cgcGMgYmVlcCBwYXRoICovCisJezB4MDEsIEFDX1ZFUkJfU0VUX0RJR0lfQ09OVkVSVF8yLCAxIDw8IDV9LAorCXt9Cit9OworCiBzdGF0aWMgc3RydWN0IGhkYV92ZXJiIHN0YWM5MjA1X2NvcmVfaW5pdFtdID0gewogCS8qIHNldCBtYXN0ZXIgdm9sdW1lIGFuZCBkaXJlY3QgY29udHJvbCAqLwkKIAl7IDB4MjQsIEFDX1ZFUkJfU0VUX1ZPTFVNRV9LTk9CX0NPTlRST0wsIDB4ZmZ9LApAQCAtMTk5OSw2ICsyMDE4LDcgQEAKIAlbU1RBQ19EOTY1XzVTVF9OT19GUF0gID0gZDk2NV81c3Rfbm9fZnBfcGluX2NvbmZpZ3MsCiAJW1NUQUNfREVMTF8zU1RdICA9IGRlbGxfM3N0X3Bpbl9jb25maWdzLAogCVtTVEFDX0RFTExfQklPU10gPSBOVUxMLAorCVtTVEFDXzkyN1hfVk9MS05PQl0gPSBOVUxMLAogfTsKIAogc3RhdGljIGNvbnN0IGNoYXIgKnN0YWM5Mjd4X21vZGVsc1tTVEFDXzkyN1hfTU9ERUxTXSA9IHsKQEAgLTIwMTAsNiArMjAzMCw3IEBACiAJW1NUQUNfRDk2NV81U1RfTk9fRlBdCT0gIjVzdGFjay1uby1mcCIsCiAJW1NUQUNfREVMTF8zU1RdCQk9ICJkZWxsLTNzdGFjayIsCiAJW1NUQUNfREVMTF9CSU9TXQk9ICJkZWxsLWJpb3MiLAorCVtTVEFDXzkyN1hfVk9MS05PQl0JPSAidm9sa25vYiIsCiB9OwogCiBzdGF0aWMgc3RydWN0IHNuZF9wY2lfcXVpcmsgc3RhYzkyN3hfY2ZnX3RibFtdID0gewpAQCAtMjA0NSw2ICsyMDY2LDggQEAKIAkJCSAgICJJbnRlbCBEOTY1IiwgU1RBQ19EOTY1XzVTVCksCiAJU05EX1BDSV9RVUlSS19NQVNLKFBDSV9WRU5ET1JfSURfSU5URUwsIDB4ZmYwMCwgMHgyNTAwLAogCQkJICAgIkludGVsIEQ5NjUiLCBTVEFDX0Q5NjVfNVNUKSwKKwkvKiB2b2x1bWUta25vYiBmaXhlcyAqLworCVNORF9QQ0lfUVVJUktfVkVORE9SKDB4MTBjZiwgIkZTQyIsIFNUQUNfOTI3WF9WT0xLTk9CKSwKIAl7fSAvKiB0ZXJtaW5hdG9yICovCiB9OwogCkBAIC01NjEyLDEwICs1NjM1LDE0IEBACiAJCXNwZWMtPmRtaWNfbmlkcyA9IHN0YWM5Mjd4X2RtaWNfbmlkczsKIAkJc3BlYy0+bnVtX2RtaWNzID0gU1RBQzkyN1hfTlVNX0RNSUNTOwogCi0JCXNwZWMtPmluaXQgPSBkOTY1X2NvcmVfaW5pdDsKKwkJc3BlYy0+aW5pdCA9IGRlbGxfM3N0X2NvcmVfaW5pdDsKIAkJc3BlYy0+ZG11eF9uaWRzID0gc3RhYzkyN3hfZG11eF9uaWRzOwogCQlzcGVjLT5udW1fZG11eGVzID0gQVJSQVlfU0laRShzdGFjOTI3eF9kbXV4X25pZHMpOwogCQlicmVhazsKKwljYXNlIFNUQUNfOTI3WF9WT0xLTk9COgorCQlzcGVjLT5udW1fZG1pY3MgPSAwOworCQlzcGVjLT5pbml0ID0gc3RhYzkyN3hfdm9sa25vYl9jb3JlX2luaXQ7CisJCWJyZWFrOwogCWRlZmF1bHQ6CiAJCXNwZWMtPm51bV9kbWljcyA9IDA7CiAJCXNwZWMtPmluaXQgPSBzdGFjOTI3eF9jb3JlX2luaXQ7CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaWNlMTcxMi9hbXAuYyBiL3NvdW5kL3BjaS9pY2UxNzEyL2FtcC5jCmluZGV4IDM3NTY0MzAuLjZkYTIxYTIgMTAwNjQ0Ci0tLSBhL3NvdW5kL3BjaS9pY2UxNzEyL2FtcC5jCisrKyBiL3NvdW5kL3BjaS9pY2UxNzEyL2FtcC5jCkBAIC01MiwxMSArNTIsMTMgQEAKIAogCS8qIG9ubHkgdXNlIGJhc2ljIGZ1bmN0aW9uYWxpdHkgZm9yIG5vdyAqLwogCi0JaWNlLT5udW1fdG90YWxfZGFjcyA9IDI7CS8qIG9ubHkgUFNET1VUMCBpcyBjb25uZWN0ZWQgKi8KKwkvKiBWVDE2MTYgNmNoIGNvZGVjIGNvbm5lY3RlZCB0byBQU0RPVVQwIHVzaW5nIHBhY2tlZCBtb2RlICovCisJaWNlLT5udW1fdG90YWxfZGFjcyA9IDY7CiAJaWNlLT5udW1fdG90YWxfYWRjcyA9IDI7CiAKLQkvKiBDaGFpbnRlY2ggQVYtNzEwIGhhcyBhbm90aGVyIGNvZGVjcywgd2hpY2ggbmVlZCBpbml0aWFsaXphdGlvbiAqLwotCS8qIGluaXRpYWxpemUgV004NzI4IGNvZGVjICovCisJLyogQ2hhaW50ZWNoIEFWLTcxMCBoYXMgYW5vdGhlciBXTTg3MjggY29kZWMgY29ubmVjdGVkIHRvIFBTRE9VVDQKKwkgICAoc2hhcmVkIHdpdGggdGhlIFNQRElGIG91dHB1dCkuIE1peGVyIGNvbnRyb2wgZm9yIHRoaXMgY29kZWMKKwkgICBpcyBub3QgeWV0IHN1cHBvcnRlZC4gKi8KIAlpZiAoaWNlLT5lZXByb20uc3VidmVuZG9yID09IFZUMTcyNF9TVUJERVZJQ0VfQVY3MTApIHsKIAkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUod21faW5pdHMpOyBpICs9IDIpCiAJCQl3bV9wdXQoaWNlLCB3bV9pbml0c1tpXSwgd21faW5pdHNbaSsxXSk7CmRpZmYgLS1naXQgYS9zb3VuZC9wY2kvaWNlMTcxMi9pY2UxNzI0LmMgYi9zb3VuZC9wY2kvaWNlMTcxMi9pY2UxNzI0LmMKaW5kZXggNzZiNzE3ZC4uMTBmYzkyYyAxMDA2NDQKLS0tIGEvc291bmQvcGNpL2ljZTE3MTIvaWNlMTcyNC5jCisrKyBiL3NvdW5kL3BjaS9pY2UxNzEyL2ljZTE3MjQuYwpAQCAtNjQ4LDcgKzY0OCw3IEBACiAJICAgIChpbmIoSUNFTVQxNzI0KGljZSwgRE1BX1BBVVNFKSkgJiBETUFfUEFVU0VTKSkgewogCQkvKiBydW5uaW5nPyB3ZSBjYW5ub3QgY2hhbmdlIHRoZSByYXRlIG5vdy4uLiAqLwogCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZpY2UtPnJlZ19sb2NrLCBmbGFncyk7Ci0JCXJldHVybiAtRUJVU1k7CisJCXJldHVybiAoKHJhdGUgPT0gaWNlLT5jdXJfcmF0ZSkgJiYgIWZvcmNlKSA/IDAgOiAtRUJVU1k7CiAJfQogCWlmICghZm9yY2UgJiYgaXNfcHJvX3JhdGVfbG9ja2VkKGljZSkpIHsKIAkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmaWNlLT5yZWdfbG9jaywgZmxhZ3MpOwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9NYWtlZmlsZSBiL3Rvb2xzL3BlcmYvTWFrZWZpbGUKaW5kZXggNTg4MTk0My4uNzQyYTMyZSAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi9NYWtlZmlsZQorKysgYi90b29scy9wZXJmL01ha2VmaWxlCkBAIC0xNTcsMTEgKzE1NywxOCBAQAogdW5hbWVfUCA6PSAkKHNoZWxsIHNoIC1jICd1bmFtZSAtcCAyPi9kZXYvbnVsbCB8fCBlY2hvIG5vdCcpCiB1bmFtZV9WIDo9ICQoc2hlbGwgc2ggLWMgJ3VuYW1lIC12IDI+L2Rldi9udWxsIHx8IGVjaG8gbm90JykKIAotIyBJZiB3ZSdyZSBvbiBhIDY0LWJpdCBrZXJuZWwsIHVzZSAtbTY0Ci1pZm5kZWYgTk9fNjRCSVQKLQlpZm5lcSAoJChwYXRzdWJzdCAlNjQsJSwkKHVuYW1lX00pKSwkKHVuYW1lX00pKQotCSAgTTY0IDo9IC1tNjQKLQllbmRpZgorIworIyBBZGQgLW0zMiBmb3IgY3Jvc3MtYnVpbGRzOgorIworaWZkZWYgTk9fNjRCSVQKKyAgTUJJVFMgOj0gLW0zMgorZWxzZQorICAjCisgICMgSWYgd2UncmUgb24gYSA2NC1iaXQga2VybmVsLCB1c2UgLW02NDoKKyAgIworICBpZm5lcSAoJChwYXRzdWJzdCAlNjQsJSwkKHVuYW1lX00pKSwkKHVuYW1lX00pKQorICAgIE1CSVRTIDo9IC1tNjQKKyAgZW5kaWYKIGVuZGlmCiAKICMgQ0ZMQUdTIGFuZCBMREZMQUdTIGFyZSBmb3IgdGhlIHVzZXJzIHRvIG92ZXJyaWRlIGZyb20gdGhlIGNvbW1hbmQgbGluZS4KQEAgLTE5NCw3ICsyMDEsNyBAQAogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdzdHJpY3QtcHJvdG90eXBlcwogRVhUUkFfV0FSTklOR1MgOj0gJChFWFRSQV9XQVJOSU5HUykgLVdkZWNsYXJhdGlvbi1hZnRlci1zdGF0ZW1lbnQKIAotQ0ZMQUdTID0gJChNNjQpIC1nZ2RiMyAtV2FsbCAtV2V4dHJhIC1zdGQ9Z251OTkgLVdlcnJvciAtTzYgLWZzdGFjay1wcm90ZWN0b3ItYWxsIC1EX0ZPUlRJRllfU09VUkNFPTIgJChFWFRSQV9XQVJOSU5HUykKK0NGTEFHUyA9ICQoTUJJVFMpIC1nZ2RiMyAtV2FsbCAtV2V4dHJhIC1zdGQ9Z251OTkgLVdlcnJvciAtTzYgLWZzdGFjay1wcm90ZWN0b3ItYWxsIC1EX0ZPUlRJRllfU09VUkNFPTIgJChFWFRSQV9XQVJOSU5HUykKIExERkxBR1MgPSAtbHB0aHJlYWQgLWxydCAtbGVsZiAtbG0KIEFMTF9DRkxBR1MgPSAkKENGTEFHUykKIEFMTF9MREZMQUdTID0gJChMREZMQUdTKQpAQCAtNDE2LDcgKzQyMyw3IEBACiBlbmRpZgogCiBpZm5lcSAoJChzaGVsbCBzaCAtYyAiKGVjaG8gJ1wjaW5jbHVkZSA8bGliZWxmLmg+JzsgZWNobyAnaW50IG1haW4odm9pZCkgeyBFbGYgKiBlbGYgPSBlbGZfYmVnaW4oMCwgRUxGX0NfUkVBRF9NTUFQLCAwKTsgcmV0dXJuIChsb25nKWVsZjsgfScpIHwgJChDQykgLXggYyAtICQoQUxMX0NGTEFHUykgLURfTEFSR0VGSUxFNjRfU09VUkNFIC1EX0ZJTEVfT0ZGU0VUX0JJVFM9NjQgLW8gL2Rldi9udWxsICQoQUxMX0xERkxBR1MpID4gL2Rldi9udWxsIDI+JjEgJiYgZWNobyB5IiksIHkpCi0JbXNnIDo9ICQoZXJyb3IgTm8gbGliZWxmLmgvbGliZWxmIGZvdW5kLCBwbGVhc2UgaW5zdGFsbCBsaWJlbGYtZGV2L2VsZnV0aWxzLWxpYmVsZi1kZXZlbCk7CisJbXNnIDo9ICQoZXJyb3IgTm8gbGliZWxmLmgvbGliZWxmIGZvdW5kLCBwbGVhc2UgaW5zdGFsbCBsaWJlbGYtZGV2L2VsZnV0aWxzLWxpYmVsZi1kZXZlbCBhbmQgZ2xpYmMtZGV2W2VsXSk7CiBlbmRpZgogCiBpZmRlZiBOT19ERU1BTkdMRQpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi9idWlsdGluLXNjaGVkLmMgYi90b29scy9wZXJmL2J1aWx0aW4tc2NoZWQuYwppbmRleCBlYTljMTVjLi5jZTJkNWJlIDEwMDY0NAotLS0gYS90b29scy9wZXJmL2J1aWx0aW4tc2NoZWQuYworKysgYi90b29scy9wZXJmL2J1aWx0aW4tc2NoZWQuYwpAQCAtMTI4Nyw3ICsxMjg3LDcgQEAKIAogc3RhdGljIExJU1RfSEVBRChzb3J0X2xpc3QpOwogCi1zdGF0aWMgaW50IHNvcnRfZGltZW5zaW9uX19hZGQoY2hhciAqdG9rLCBzdHJ1Y3QgbGlzdF9oZWFkICpsaXN0KQorc3RhdGljIGludCBzb3J0X2RpbWVuc2lvbl9fYWRkKGNvbnN0IGNoYXIgKnRvaywgc3RydWN0IGxpc3RfaGVhZCAqbGlzdCkKIHsKIAlpbnQgaTsKIApAQCAtMTkxNyw3ICsxOTE3LDcgQEAKIAogCWZyZWUoc3RyKTsKIAotCXNvcnRfZGltZW5zaW9uX19hZGQoKGNoYXIgKikicGlkIiwgJmNtcF9waWQpOworCXNvcnRfZGltZW5zaW9uX19hZGQoInBpZCIsICZjbXBfcGlkKTsKIH0KIAogc3RhdGljIGNvbnN0IGNoYXIgKnJlY29yZF9hcmdzW10gPSB7CmRpZmYgLS1naXQgYS90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmMgYi90b29scy9wZXJmL3V0aWwvcGFyc2UtZXZlbnRzLmMKaW5kZXggODdjNDI0ZC4uOGNmYjQ4YyAxMDA2NDQKLS0tIGEvdG9vbHMvcGVyZi91dGlsL3BhcnNlLWV2ZW50cy5jCisrKyBiL3Rvb2xzL3BlcmYvdXRpbC9wYXJzZS1ldmVudHMuYwpAQCAtNjkxLDcgKzY5MSwxMCBAQAogCUZJTEUgKmZpbGU7CiAJaW50IGlkOwogCi0Jc3ByaW50ZihmaWxlbmFtZSwgIi9zeXMva2VybmVsL2RlYnVnL3RyYWNpbmcvZXZlbnRzLyVzL2lkIiwgb3JnbmFtZSk7CisJc3ByaW50ZihmaWxlbmFtZSwgIiVzLyIsIGRlYnVnZnNfcGF0aCk7CisJc3RybmNhdChmaWxlbmFtZSwgb3JnbmFtZSwgc3RybGVuKG9yZ25hbWUpKTsKKwlzdHJjYXQoZmlsZW5hbWUsICIvaWQiKTsKKwogCWMgPSBzdHJjaHIoZmlsZW5hbWUsICc6Jyk7CiAJaWYgKGMpCiAJCSpjID0gJy8nOwpkaWZmIC0tZ2l0IGEvdG9vbHMvcGVyZi91dGlsL3RyYWNlLWV2ZW50LXBhcnNlLmMgYi90b29scy9wZXJmL3V0aWwvdHJhY2UtZXZlbnQtcGFyc2UuYwppbmRleCA1NWI0MWI5Li41NWM5NjU5IDEwMDY0NAotLS0gYS90b29scy9wZXJmL3V0aWwvdHJhY2UtZXZlbnQtcGFyc2UuYworKysgYi90b29scy9wZXJmL3V0aWwvdHJhY2UtZXZlbnQtcGFyc2UuYwpAQCAtNjE4LDcgKzYxOCw3IEBACiB9CiAKIHN0YXRpYyBpbnQgdGVzdF90eXBlX3Rva2VuKGVudW0gZXZlbnRfdHlwZSB0eXBlLCBjaGFyICp0b2tlbiwKLQkJICAgIGVudW0gZXZlbnRfdHlwZSBleHBlY3QsIGNoYXIgKmV4cGVjdF90b2spCisJCSAgICBlbnVtIGV2ZW50X3R5cGUgZXhwZWN0LCBjb25zdCBjaGFyICpleHBlY3RfdG9rKQogewogCWlmICh0eXBlICE9IGV4cGVjdCkgewogCQlkaWUoIkVycm9yOiBleHBlY3RlZCB0eXBlICVkIGJ1dCByZWFkICVkIiwKQEAgLTY1MCw3ICs2NTAsNyBAQAogCXJldHVybiBfX3JlYWRfZXhwZWN0X3R5cGUoZXhwZWN0LCB0b2ssIDEpOwogfQogCi1zdGF0aWMgaW50IF9fcmVhZF9leHBlY3RlZChlbnVtIGV2ZW50X3R5cGUgZXhwZWN0LCBjaGFyICpzdHIsIGludCBuZXdsaW5lX29rKQorc3RhdGljIGludCBfX3JlYWRfZXhwZWN0ZWQoZW51bSBldmVudF90eXBlIGV4cGVjdCwgY29uc3QgY2hhciAqc3RyLCBpbnQgbmV3bGluZV9vaykKIHsKIAllbnVtIGV2ZW50X3R5cGUgdHlwZTsKIAljaGFyICp0b2tlbjsKQEAgLTY2OCwxMiArNjY4LDEyIEBACiAJcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQgcmVhZF9leHBlY3RlZChlbnVtIGV2ZW50X3R5cGUgZXhwZWN0LCBjaGFyICpzdHIpCitzdGF0aWMgaW50IHJlYWRfZXhwZWN0ZWQoZW51bSBldmVudF90eXBlIGV4cGVjdCwgY29uc3QgY2hhciAqc3RyKQogewogCXJldHVybiBfX3JlYWRfZXhwZWN0ZWQoZXhwZWN0LCBzdHIsIDEpOwogfQogCi1zdGF0aWMgaW50IHJlYWRfZXhwZWN0ZWRfaXRlbShlbnVtIGV2ZW50X3R5cGUgZXhwZWN0LCBjaGFyICpzdHIpCitzdGF0aWMgaW50IHJlYWRfZXhwZWN0ZWRfaXRlbShlbnVtIGV2ZW50X3R5cGUgZXhwZWN0LCBjb25zdCBjaGFyICpzdHIpCiB7CiAJcmV0dXJuIF9fcmVhZF9leHBlY3RlZChleHBlY3QsIHN0ciwgMCk7CiB9CmRpZmYgLS1naXQgYS92aXJ0L2t2bS9rdm1fbWFpbi5jIGIvdmlydC9rdm0va3ZtX21haW4uYwppbmRleCBiN2M3OGE0Li43NDk1Y2UzIDEwMDY0NAotLS0gYS92aXJ0L2t2bS9rdm1fbWFpbi5jCisrKyBiL3ZpcnQva3ZtL2t2bV9tYWluLmMKQEAgLTI3MTcsOCArMjcxNyw2IEBACiAJaW50IHI7CiAJaW50IGNwdTsKIAotCWt2bV9pbml0X2RlYnVnKCk7Ci0KIAlyID0ga3ZtX2FyY2hfaW5pdChvcGFxdWUpOwogCWlmIChyKQogCQlnb3RvIG91dF9mYWlsOwpAQCAtMjc4NSw2ICsyNzgzLDggQEAKIAlrdm1fcHJlZW1wdF9vcHMuc2NoZWRfaW4gPSBrdm1fc2NoZWRfaW47CiAJa3ZtX3ByZWVtcHRfb3BzLnNjaGVkX291dCA9IGt2bV9zY2hlZF9vdXQ7CiAKKwlrdm1faW5pdF9kZWJ1ZygpOworCiAJcmV0dXJuIDA7CiAKIG91dF9mcmVlOgpAQCAtMjgwNyw3ICsyODA3LDYgQEAKIG91dDoKIAlrdm1fYXJjaF9leGl0KCk7CiBvdXRfZmFpbDoKLQlrdm1fZXhpdF9kZWJ1ZygpOwogCXJldHVybiByOwogfQogRVhQT1JUX1NZTUJPTF9HUEwoa3ZtX2luaXQpOwpAQCAtMjgxNSw2ICsyODE0LDcgQEAKIHZvaWQga3ZtX2V4aXQodm9pZCkKIHsKIAl0cmFjZXBvaW50X3N5bmNocm9uaXplX3VucmVnaXN0ZXIoKTsKKwlrdm1fZXhpdF9kZWJ1ZygpOwogCW1pc2NfZGVyZWdpc3Rlcigma3ZtX2Rldik7CiAJa21lbV9jYWNoZV9kZXN0cm95KGt2bV92Y3B1X2NhY2hlKTsKIAlzeXNkZXZfdW5yZWdpc3Rlcigma3ZtX3N5c2Rldik7CkBAIC0yODI0LDcgKzI4MjQsNiBAQAogCW9uX2VhY2hfY3B1KGhhcmR3YXJlX2Rpc2FibGUsIE5VTEwsIDEpOwogCWt2bV9hcmNoX2hhcmR3YXJlX3Vuc2V0dXAoKTsKIAlrdm1fYXJjaF9leGl0KCk7Ci0Ja3ZtX2V4aXRfZGVidWcoKTsKIAlmcmVlX2NwdW1hc2tfdmFyKGNwdXNfaGFyZHdhcmVfZW5hYmxlZCk7CiAJX19mcmVlX3BhZ2UoYmFkX3BhZ2UpOwogfQo=