LyoKICoJT1NTIGRyaXZlciBmb3IgTGludXggMi5bNDZdLnggZm9yCiAqCiAqCVRyaWRlbnQgNEQtV2F2ZQogKglTaVMgNzAxOAogKglBTGkgNTQ1MQogKglUdmlhL0lHU1QgQ3liZXJQcm8gNTA1MAogKgogKglEcml2ZXI6IEFsYW4gQ294IDxhbGFuQHJlZGhhdC5jb20+CiAqCiAqICBCdWlsdCBmcm9tOgogKglMb3cgbGV2ZWwgY29kZTogPGF1ZGlvQHRyaWRlbnRtaWNyby5jb20+IGZyb20gQUxTQQogKglGcmFtZXdvcms6IFRob21hcyBTYWlsZXIgPHNhaWxlckBpZmUuZWUuZXRoei5jaD4KICoJRXh0ZW5kZWQgYnk6IFphY2ggQnJvd24gPHphYkByZWRoYXQuY29tPiAgCiAqCiAqICBIYWNrZWQgdXAgYnk6CiAqCUFhcm9uIEhvbHR6bWFuIDxhaG9sdHptYUBlc3MuZW5nci51dmljLmNhPgogKglPbGxpZSBMaG8gPG9sbGllQHNpcy5jb20udHc+IFNpUyA3MDE4IEF1ZGlvIENvcmUgU3VwcG9ydAogKglDaGluZy1MaW5nIExlZSA8Y2xpbmctbGlAYWxpLmNvbS50dz4gQUxpIDU0NTEgQXVkaW8gQ29yZSBTdXBwb3J0IAogKglNYXR0IFd1IDxtYXR0d3VAYWNlcnNvZnRlY2guY29tLmNuPiBBTGkgNTQ1MSBBdWRpbyBDb3JlIFN1cHBvcnQKICoJUGV0ZXIgV+RjaHRsZXIgPHB3YWVjaHRsZXJAbG9ld2Uta29tcC5kZT4gQ3liZXJQcm81MDUwIHN1cHBvcnQKICogICAgICBNdWxpIEJlbi1ZZWh1ZGEgPG11bGl4QG11bGl4Lm9yZz4KICoKICoKICoJVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICoJaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKICoJdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMiBvZiB0aGUgTGljZW5zZSwgb3IKICoJKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KICoKICoJVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsCiAqCWJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAqCU1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKICoJR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICoJWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKICoJYWxvbmcgd2l0aCB0aGlzIHByb2dyYW07IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICoJRm91bmRhdGlvbiwgSW5jLiwgNjc1IE1hc3MgQXZlLCBDYW1icmlkZ2UsIE1BIDAyMTM5LCBVU0EuCiAqCiAqICBIaXN0b3J5CiAqICB2MC4xNC4xMGoKICogIAlKYW51YXJ5IDMgMjAwNCBFdWdlbmUgVGVvIDxldWdlbmV0ZW9AZXVnZW5ldGVvLm5ldD4KICogIAltaW5vciBjbGVhbnVwIHRvIHVzZSBwcl9kZWJ1ZyBpbnN0ZWFkIG9mIFRSREJHIHNpbmNlIGl0IGlzIGFscmVhZHkKICogIAlkZWZpbmVkIGluIGxpbnV4L2tlcm5lbC5oLgogKiAgdjAuMTQuMTBpCiAqICAgICAgRGVjZW1iZXIgMjkgMjAwMyBNdWxpIEJlbi1ZZWh1ZGEgPG11bGl4QG11bGl4Lm9yZz4KICogICAgICBtYWpvciBjbGVhbnVwIGZvciAyLjYsIGZpeCBhIGZldyBlcnJvciBwYXRjaCBidWdsZXRzCiAqICAgICAgd2l0aCByZXR1cm5pbmcgd2l0aG91dCBwcm9wZXJseSBjbGVhbmluZyB1cCBmaXJzdCwKICogICAgICBnZXQgcmlkIG9mIGxvY2tfa2VybmVsKCkuCiAqICB2MC4xNC4xMGgKICoJU2VwdCAxMCAyMDAyIFBhc2NhbCBTY2htaWR0IDxkZXIuZXJlbWl0QGVtYWlsLmRlPgogKglhZGRlZCBzdXBwb3J0IGZvciBBTGkgNTQ1MSBqb3lzdGljayBwb3J0CiAqICB2MC4xNC4xMGcKICoJU2VwdCAwNSAyMDAyIEFsYW4gQ294IDxhbGFuQHJlZGhhdC5jb20+CiAqCWFkYXB0IHRvIG5ldyBwY2kgam95c3RpY2sgYXR0YWNobWVudCBpbnRlcmZhY2UKICogIHYwLjE0LjEwZgogKiAgICAgIEp1bHkgMjQgMjAwMiBNdWxpIEJlbi1ZZWh1ZGEgPG11bGl4QGFjdGNvbS5jby5pbD4KICogICAgICBwYXRjaCBmcm9tIEVyaWMgTGVtYXIgKHZpYSBJYW4gU29ib3JvZmYpOiBpbiBzdXNwZW5kIGFuZCByZXN1bWUsIAogKiAgICAgIGZpeCB3cm9uZyBjYXN0IGZyb20gcGNpX2RldiogdG8gc3RydWN0IHRyaWRlbnRfY2FyZCouIAogKiAgdjAuMTQuMTBlCiAqICAgICAgSnVseSAxOSAyMDAyIE11bGkgQmVuLVllaHVkYSA8bXVsaXhAYWN0Y29tLmNvLmlsPgogKiAgICAgIHJld3JpdGUgdGhlIERNQSBidWZmZXIgYWxsb2NhdGlvbi9kZWFsbGNvYXRpb24gZnVuY3Rpb25zLCB0byBtYWtlIGl0IAogKiAgICAgIG1vZHVsYXIgYW5kIGZpeCBhIGJ1ZyB3aGVyZSB3ZSB3b3VsZCBjYWxsIGZyZWVfcGFnZXMgb24gbWVtb3J5IAogKiAgICAgIG9idGFpbmVkIHdpdGggcGNpX2FsbG9jX2NvbnNpc3RlbnQuIEFsc28gcmVtb3ZlIHVubmVjZXNzYXJ5ICNpZmRlZiAKICogICAgICBDT05GSUdfUFJPQ19GUyBhbmQgdmFyaW91cyBvdGhlciBjbGVhbnVwcy4KICogIHYwLjE0LjEwZAogKiAgICAgIEp1bHkgMTkgMjAwMiBNdWxpIEJlbi1ZZWh1ZGEgPG11bGl4QGFjdGNvbS5jby5pbD4KICogICAgICBtYWRlIHNldmVyYWwgcHJpbnRrKEtFUk5fTk9USUNFLi4uKSBpbnRvIFRSREJHKC4uLiksIHRvIGF2b2lkIHNwYW1taW5nCiAqICAgICAgbXkgc3lzbG9nIHdpdGggaHVuZHJlZHMgb2YgbWVzc2FnZXMuIAogKiAgdjAuMTQuMTBjCiAqICAgICAgSnVseSAxNiAyMDAyIE11bGkgQmVuLVllaHVkYSA8bXVsaXhAYWN0Y29tLmNvLmlsPgogKiAgICAgIENsZWFuZWQgdXAgTGVpIEh1J3MgMC40LjEwIGRyaXZlciB0byBjb25mb3JtIHRvIERvY3VtZW50YXRpb24vQ29kaW5nU3R5bGUKICogICAgICBhbmQgdGhlIGNvZGluZyBzdHlsZSB1c2VkIGluIHRoZSByZXN0IG9mIHRoZSBmaWxlLiAKICogIHYwLjE0LjEwYgogKiAgICAgIEp1bmUgMjMgMjAwMiBNdWxpIEJlbi1ZZWh1ZGEgPG11bGl4QGFjdGNvbS5jby5pbD4KICogICAgICBhZGQgYSBtaXNzaW5nIHVubG9ja19zZXRfZm10LCByZW1vdmUgYSBzdXBlcmZsb3VzIGxvY2svdW5sb2NrIHBhaXIgCiAqICAgICAgd2l0aCBub3RoaW5nIGluIGJldHdlZW4uIAogKiAgdjAuMTQuMTBhCiAqICAgICAgSnVuZSAyMSAyMDAyIE11bGkgQmVuLVllaHVkYSA8bXVsaXhAYWN0Y29tLmNvLmlsPiAKICogICAgICB1c2UgYSBkZWJ1ZyBtYWNybyBpbnN0ZWFkIG9mICNpZmRlZiBDT05GSUdfREVCVUcsIHRyaW0gdG8gODAgY29sdW1ucyAKICogICAgICBwZXIgbGluZSwgdXNlICdkbyB7fSB3aGlsZSAoMCknIGluIHN0YXRlbWVudCBtYWNyb3MuIAogKiAgdjAuMTQuMTAKICogICAgICBKdW5lIDYgMjAwMiBMZWkgSHUgPExlaV9odUBhbGkuY29tLnR3PgogKiAgICAgIHJld3JpdGUgdGhlIHBhcnQgdG8gcmVhZC93cml0ZSByZWdpc3RlcnMgb2YgYXVkaW8gY29kZWMgZm9yIEFsaTU0NTEgCiAqICB2MC4xNC45ZQogKiAgICAgIEphbnVhcnkgMiAyMDAyIFZvanRlY2ggUGF2bGlrIDx2b2p0ZWNoQHVjdy5jej4gYWRkZWQgZ2FtZXBvcnQKICogICAgICBzdXBwb3J0IHRvIGF2b2lkIHJlc291cmNlIGNvbmZsaWN0IHdpdGggcGNpZ2FtZS5jCiAqICB2MC4xNC45ZAogKiAgCU9jdG9iZXIgOCAyMDAxIEFybmFsZG8gQ2FydmFsaG8gZGUgTWVsbyA8YWNtZUBjb25lY3RpdmEuY29tLmJyPgogKgl1c2Ugc2V0X2N1cnJlbnRfc3RhdGUsIHByb3Blcmx5IHJlbGVhc2UgcmVzb3VyY2VzIG9uIGZhaWx1cmUgaW4KICoJdHJpZGVudF9wcm9iZSwgZ2V0IHJpZCBvZiBjaGVja19yZWdpb24KICogIHYwLjE0LjljCiAqCUF1Z3VzdCAxMCAyMDAxIFBldGVyIFfkY2h0bGVyIDxwd2FlY2h0bGVyQGxvZXdlLWtvbXAuZGU+CiAqCWFkZGVkIHN1cHBvcnQgZm9yIFR2aWEgKGZvcm1lcmx5IEludGVncmFwaGljcy9JR1NUKSBDeWJlclBybzUwNTAKICoJdGhpcyBjaGlwIGlzIG9mdGVuIGZvdW5kIGluIHNldHRvcCBib3hlcyAoY29tYmluZWQgdmlkZW8rYXVkaW8pCiAqICB2MC4xNC45YgogKglTd2l0Y2ggdG8gc3RhdGljIGlubGluZSBub3QgZXh0ZXJuIGlubGluZSAoZ2NjIDMpCiAqICB2MC4xNC45YQogKglBdWcgNiAyMDAxIEFsYW4gQ294CiAqCTAuMTQuOSBjcmFzaGVkIG9uIHJtbW9kIGR1ZSB0byBhIHRpbWVyL2JoIGxlZnQgcnVubmluZy4gU2ltcGxpZmllZAogKgl0aGUgZXhpc3RpbmcgbG9naWMgKHRoZSBCSCBkb2Vzbid0IGhlbHAgYXMgYWM5NyBpcyBsb2NrX2lycXNhdmUpCiAqCWFuZCB1c2VkIGRlbF90aW1lcl9zeW5jIHRvIGNsZWFuIHVwCiAqCUZpeGVkIGEgcHJvYmxlbSB3aGVyZSB0aGUgQUxpIGNoYW5nZSBicm9rZSBteSBnZW5lcmljIGNhcmQKICogIHYwLjE0LjkKICoJSnVsIDEwIDIwMDEgTWF0dCBXdQogKglBZGQgSC9XIFZvbHVtZSBDb250cm9sCiAqICB2MC4xNC44YQogKglKdWx5IDcgMjAwMSBBbGFuIENveAogKglNb3ZlZCBNYXR0IFd1J3MgYWM5NyByZWdpc3RlciBjYWNoZSBpbnRvIHRoZSBjYXJkIHN0cnVjdHVyZQogKiAgdjAuMTQuOAogKglBcHIgMzAgMjAwMSBNYXR0IFd1CiAqCVNldCBFQlVGMSBhbmQgRUJVRjIgdG8gc3RpbGwgbW9kZQogKglBZGQgZGM5Ny9hYzk3IHJlc2V0IGZ1bmN0aW9uCiAqCUZpeCBwb3dlciBtYW5hZ2VtZW50OiBhbGlfcmVzdG9yZV9yZWdzCiAqICB1bnJlbGVhc2VkIAogKglNYXIgMDkgMjAwMSBNYXR0IFd1CiAqCUFkZCBjYWNoZSBmb3IgYWM5NyBhY2Nlc3MKICogIHYwLjE0LjcKICoJRmViIDA2IDIwMDEgTWF0dCBXdQogKglGaXggYWM5NyBpbml0aWFsaXphdGlvbgogKglGaXggYnVnOiBhbiBleHRyYSB0YWlsIHdpbGwgYmUgcGxheWVkIHdoZW4gcGxheWluZwogKglKYW4gMDUgMjAwMSBNYXR0IFd1CiAqCUltcGxlbWVudCBtdWx0aS1jaGFubmVscyBhbmQgUy9QRElGIGluIHN1cHBvcnQgZm9yIEFMaSAxNTM1KwogKiAgdjAuMTQuNiAKICoJTm92IDEgMjAwMCBDaGluZy1MaW5nIExlZQogKglGaXggdGhlIGJ1ZyBvZiBtZW1vcnkgbGVhayB3aGVuIHN3aXRjaGluZyA1LjEtY2hhbm5lbHMgdG8gMiBjaGFubmVscy4KICoJQWRkIGxvY2sgcHJvdGVjdGlvbiBpbnRvIGR5bmFtaWMgY2hhbmdpbmcgZm9ybWF0IG9mIGRhdGEuCiAqCU9jdCAxOCAyMDAwIENoaW5nLUxpbmcgTGVlCiAqCTUuMS1jaGFubmVscyBzdXBwb3J0IGZvciBBTGkKICoJSnVuZSAyOCAyMDAwIENoaW5nLUxpbmcgTGVlCiAqCVMvUERJRiBvdXQvaW4ocGxheWJhY2svcmVjb3JkKSBzdXBwb3J0IGZvciBBTGkgMTUzNSssIHVzaW5nIC9wcm9jIHRvIGJlIHNlbGVjdGVkIGJ5IHVzZXIKICoJU2ltcGxlIFBvd2VyIE1hbmFnZW1lbnQgc3VwcG9ydCBmb3IgQUxpCiAqICB2MC4xNC41IE1heSAyMyAyMDAwIE9sbGllIExobwogKiAgCU1pc2MgYnVnIGZpeCBmcm9tIHRoZSBOZXQKICogIHYwLjE0LjQgTWF5IDIwIDIwMDAgQWFyb24gSG9sdHptYW4KICogIAlGaXgga2ZyZWUnZCBtZW1vcnkgYWNjZXNzIGluIHJlbGVhc2UKICogIAlGaXggcmFjZSBpbiBvcGVuIHdoaWxlIGxvb2tpbmcgZm9yIGEgZnJlZSB2aXJ0dWFsIGNoYW5uZWwgc2xvdAogKiAgCXJlbW92ZSBvcGVuX3dhaXQgd3EgKHdoaWNoIGFwcGVhcnMgdG8gYmUgdW51c2VkKQogKiAgdjAuMTQuMyBNYXkgMTAgMjAwMCBPbGxpZSBMaG8KICoJZml4ZWQgYSBzbWFsbCBidWcgaW4gdHJpZGVudF91cGRhdGVfcHRyLCB4bW1zIDEuMC4xIG5vIGxvbmdlciB1c2VzIDEwMCUgQ1BVCiAqICB2MC4xNC4yIE1hciAyOSAyMDAwIENoaW5nLUxpbmcgTGVlCiAqCUFkZCBjbGVhciB0byBzaWxlbmNlIGFkdmFuY2UgaW4gdHJpZGVudF91cGRhdGVfcHRyIAogKglmaXggaW52YWxpZCBkYXRhIG9mIHRoZSBlbmQgb2YgdGhlIHNvdW5kCiAqICB2MC4xNC4xIE1hciAyNCAyMDAwIENoaW5nLUxpbmcgTGVlCiAqCUFMaSA1NDUxIHN1cHBvcnQgYWRkZWQsIHBsYXliYWNrIGFuZCByZWNvcmRpbmcgTy5LLgogKglBTGkgNTQ1MSBvcmlnaW5hbGx5IGRldmVsb3BlZCBhbmQgc3RydWN0dXJlZCBiYXNlZCBvbiBzb25pY3ZpYmVzLCBhbmQKICoJc3VnZ2VzdGVkIHRvIG1lcmdlIGludG8gdGhpcyBmaWxlIGJ5IEFsYW4gQ294LgogKiAgdjAuMTQgTWFyIDE1IDIwMDAgT2xsaWUgTGhvCiAqCTUuMSBjaGFubmVsIG91dHB1dCBzdXBwb3J0IHdpdGggY2hhbm5lbCBiaW5kaW5nLiBXaGF0J3MgdGhlIE1hdHJpeCA/CiAqICB2MC4xMy4xIE1hciAxMCAyMDAwIE9sbGllIExobwogKglmZXcgbWlub3IgYnVncyBvbiBkdWFsIGNvZGVjIHN1cHBvcnQsIG5lZWRzIG1vcmUgdGVzdGluZwogKiAgdjAuMTMgTWFyIDAzIDIwMDAgT2xsaWUgTGhvCiAqCW5ldyBwY2lfKiBmb3IgMi40IGtlcm5lbCwgYmFjayBwb3J0ZWQgdG8gMi4yCiAqICB2MC4xMiBGZWIgMjMgMjAwMCBPbGxpZSBMaG8KICoJUHJlbGltaW5hcnkgUmVjb3JkaW5nIHN1cHBvcnQKICogIHYwLjExLjIgRmViIDE5IDIwMDAgT2xsaWUgTGhvCiAqCXJlbW92ZWQgaW5jb21wbGV0ZSBmdWxsLWR1bHBsZXggc3VwcG9ydAogKiAgdjAuMTEuMSBKYW4gMjggMjAwMCBPbGxpZSBMaG8KICoJc21hbGwgYnVnIGluIHNldHRpbmcgc2FtcGxlIHJhdGUgZm9yIDRkLW54IChyZXBvcnRlZCBieSBBYXJvbikKICogIHYwLjExIEphbiAyNyAyMDAwIE9sbGllIExobwogKglETUEgYnVnLCBzY2hlZHVsZXIgbGF0ZW5jeSwgc2Vjb25kIHRyeQogKiAgdjAuMTAgSmFuIDI0IDIwMDAgT2xsaWUgTGhvCiAqCURNQSBidWcgZml4ZWQsIGZvdW5kIGtlcm5lbCBzY2hlZHVsaW5nIHByb2JsZW0KICogIHYwLjA5IEphbiAyMCAyMDAwIE9sbGllIExobwogKglDbGVhbiB1cCBvZiBjaGFubmVsIHJlZ2lzdGVyIGFjY2VzcyByb3V0aW5lIChwcmVwYXJlIGZvciBjaGFubmVsIGJpbmRpbmcpCiAqICB2MC4wOCBKYW4gMTQgMjAwMCBPbGxpZSBMaG8KICoJSXNvbGF0aW9uIG9mIEFDOTcgY29kZWMgY29kZQogKiAgdjAuMDcgSmFuIDEzIDIwMDAgT2xsaWUgTGhvCiAqCUdldCByaWQgb2YgdWdseSBvbGQgbG93IGxldmVsIGFjY2VzcyByb3V0aW5lcyAoZS5nLiBDSFJlZ3MubHAqKioqKQogKiAgdjAuMDYgSmFuIDExIDIwMDAgT2xsaWUgTGhvCiAqCVByZWxpbWluYXJ5IHN1cHBvcnQgZm9yIGR1YWwgKG1vcmUgPykgQUM5NyBjb2RlY3MKICogIHYwLjA1IEphbiAwOCAyMDAwIEx1Y2EgTW9udGVjY2hpYW5pIDxtLmx1Y2FAaW5hbWUuY29tPgogKglhZGFwdCB0byAyLjMueCBuZXcgX19zZXR1cC9fX2luaXQgY2FsbAogKiAgdjAuMDQgRGVjIDMxIDE5OTkgT2xsaWUgTGhvCiAqCU11bHRpcGxlIE9wZW4sIHVzaW5nIE1pZGRsZSBMb29wIEludGVycnVwdCB0byBzbW9vdGggcGxheWJhY2sKICogIHYwLjAzIERlYyAyNCAxOTk5IE9sbGllIExobwogKgltZW0gbGVhayBpbiBwcm9nX2RtYWJ1ZiBhbmQgZGVhbGxvY19kbWFidWYgcmVtb3ZlZAogKiAgdjAuMDIgRGVjIDE1IDE5OTkgT2xsaWUgTGhvCiAqCVNpUyA3MDE4IHN1cHBvcnQgYWRkZWQsIHBsYXliYWNrIE8uSy4KICogIHYwLjAxIEFsYW4gQ294IGV0LiBhbC4KICoJSW5pdGlhbCBSZWxlYXNlIGluIGtlcm5lbCAyLjMuMzAsIGRvZXMgbm90IHdvcmsKICogCiAqICBUb0RvCiAqCUNsZWFuIHVwIG9mIGxvdyBsZXZlbCBjaGFubmVsIHJlZ2lzdGVyIGFjY2VzcyBjb2RlLiAoZG9uZSkKICoJRml4IHRoZSBidWcgb24gZG1hIGJ1ZmZlciBtYW5hZ2VtZW50IGluIHVwZGF0ZV9wdHIsIHJlYWQvd3JpdGUsIGRyYWluX2RhYyAoZG9uZSkKICoJRHVhbCBBQzk3IGNvZGVjcyBzdXBwb3J0IChkb25lKQogKglSZWNvcmRpbmcgc3VwcG9ydCAoZG9uZSkKICoJTW1hcCBzdXBwb3J0CiAqCSJDaGFubmVsIEJpbmRpbmciIGlvY3RsIGV4dGVuc2lvbiAoZG9uZSkKICoJbmV3IHBjaSBkZXZpY2UgZHJpdmVyIGludGVyZmFjZSBmb3IgMi40IGtlcm5lbCAoZG9uZSkKICoKICoJTG9jayBvcmRlciAoaGlnaC0+bG93KQogKgkJbG9jawktCWhhcmR3YXJlIGxvY2sKICoJCW9wZW5fbXV0ZXggLSAJZ3VhcmQgb3BlbnMKICoJCXNlbQktCWd1YXJkIGRtYWJ1Ziwgd3JpdGUgcmUtZW50cnkgZXRjCiAqLwoKI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvc3RyaW5nLmg+CiNpbmNsdWRlIDxsaW51eC9jdHlwZS5oPgojaW5jbHVkZSA8bGludXgvaW9wb3J0Lmg+CiNpbmNsdWRlIDxsaW51eC9zY2hlZC5oPgojaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KI2luY2x1ZGUgPGxpbnV4L3NvdW5kLmg+CiNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiNpbmNsdWRlIDxsaW51eC9zb3VuZGNhcmQuaD4KI2luY2x1ZGUgPGxpbnV4L3BjaS5oPgojaW5jbHVkZSA8bGludXgvaW5pdC5oPgojaW5jbHVkZSA8bGludXgvcG9sbC5oPgojaW5jbHVkZSA8bGludXgvc3BpbmxvY2suaD4KI2luY2x1ZGUgPGxpbnV4L3NtcF9sb2NrLmg+CiNpbmNsdWRlIDxsaW51eC9hYzk3X2NvZGVjLmg+CiNpbmNsdWRlIDxsaW51eC9iaXRvcHMuaD4KI2luY2x1ZGUgPGxpbnV4L3Byb2NfZnMuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvcG0uaD4KI2luY2x1ZGUgPGxpbnV4L2dhbWVwb3J0Lmg+CiNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KI2luY2x1ZGUgPGxpbnV4L211dGV4Lmg+CgojaW5jbHVkZSA8YXNtL3VhY2Nlc3MuaD4KI2luY2x1ZGUgPGFzbS9pby5oPgojaW5jbHVkZSA8YXNtL2RtYS5oPgoKI2lmIGRlZmluZWQoQ09ORklHX0FMUEhBX05BVVRJTFVTKSB8fCBkZWZpbmVkKENPTkZJR19BTFBIQV9HRU5FUklDKQojaW5jbHVkZSA8YXNtL2h3cnBiLmg+CiNlbmRpZgoKI2luY2x1ZGUgInRyaWRlbnQuaCIKCiNkZWZpbmUgRFJJVkVSX1ZFUlNJT04gIjAuMTQuMTBqLTIuNiIKCiNpZiBkZWZpbmVkKENPTkZJR19HQU1FUE9SVCkgfHwgKGRlZmluZWQoTU9EVUxFKSAmJiBkZWZpbmVkKENPTkZJR19HQU1FUE9SVF9NT0RVTEUpKQojZGVmaW5lIFNVUFBPUlRfSk9ZU1RJQ0sgMQojZW5kaWYKCi8qIG1hZ2ljIG51bWJlcnMgdG8gcHJvdGVjdCBvdXIgZGF0YSBzdHJ1Y3R1cmVzICovCiNkZWZpbmUgVFJJREVOVF9DQVJEX01BR0lDCTB4NTA3MjY5NkUJLyogIlByaW4iICovCiNkZWZpbmUgVFJJREVOVF9TVEFURV9NQUdJQwkweDYzNjU3MzczCS8qICJjZXNzIiAqLwoKI2RlZmluZSBUUklERU5UX0RNQV9NQVNLCTB4M2ZmZmZmZmYJLyogRE1BIGJ1ZmZlciBtYXNrIGZvciBwY2lfYWxsb2NfY29uc2lzdCAqLwojZGVmaW5lIEFMSV9ETUFfTUFTSwkJMHg3ZmZmZmZmZgkvKiBBTEkgVHJpZGVudHMgaGF2ZSAzMS1iaXQgRE1BLiBXb3cuICovCgojZGVmaW5lIE5SX0hXX0NICQkzMgoKLyogbWF4aW11bSBudW1iZXIgb2YgQUM5NyBjb2RlY3MgY29ubmVjdGVkLCBBQzk3IDIuMCBkZWZpbmVkIDQsIGJ1dCA3MDE4IGFuZCA0RC1OWCBvbmx5CiAgIGhhdmUgMiBTREFUQV9JTiBsaW5lcyAoY3VycmVudGx5KSAqLwojZGVmaW5lIE5SX0FDOTcJCTIKCi8qIG1pbm9yIG51bWJlciBvZiAvZGV2L3N3bW9kZW0gKHRlbXBvcmFyeSwgZXhwZXJpbWVudGFsKSAqLwojZGVmaW5lIFNORF9ERVZfU1dNT0RFTQk3CgpzdGF0aWMgY29uc3QgdW5zaWduZWQgYWxpX211bHRpX2NoYW5uZWxzXzVfMVtdID0gewoJLypBTElfU1VSUl9MRUZUX0NIQU5ORUwsIEFMSV9TVVJSX1JJR0hUX0NIQU5ORUwsICovCglBTElfQ0VOVEVSX0NIQU5ORUwsCglBTElfTEVGX0NIQU5ORUwsCglBTElfU1VSUl9MRUZUX0NIQU5ORUwsCglBTElfU1VSUl9SSUdIVF9DSEFOTkVMCn07CgpzdGF0aWMgY29uc3QgdW5zaWduZWQgc2FtcGxlX3NpemVbXSA9IHsgMSwgMiwgMiwgNCB9OwpzdGF0aWMgY29uc3QgdW5zaWduZWQgc2FtcGxlX3NoaWZ0W10gPSB7IDAsIDEsIDEsIDIgfTsKCnN0YXRpYyBjb25zdCBjaGFyIGludmFsaWRfbWFnaWNbXSA9IEtFUk5fQ1JJVCAidHJpZGVudDogaW52YWxpZCBtYWdpYyB2YWx1ZSBpbiAlc1xuIjsKCmVudW0gewoJVFJJREVOVF80RF9EWCA9IDAsCglUUklERU5UXzREX05YLAoJU0lTXzcwMTgsCglBTElfNTQ1MSwKCUNZQkVSNTA1MAp9OwoKc3RhdGljIGNoYXIgKmNhcmRfbmFtZXNbXSA9IHsKCSJUcmlkZW50IDREV2F2ZSBEWCIsCgkiVHJpZGVudCA0RFdhdmUgTlgiLAoJIlNpUyA3MDE4IFBDSSBBdWRpbyIsCgkiQUxpIEF1ZGlvIEFjY2VsZXJhdG9yIiwKCSJUdmlhL0lHU1QgQ3liZXJQcm8gNTA1MCIKfTsKCnN0YXRpYyBzdHJ1Y3QgcGNpX2RldmljZV9pZCB0cmlkZW50X3BjaV90YmxbXSA9IHsKCXtQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfVFJJREVOVCwgUENJX0RFVklDRV9JRF9UUklERU5UXzREV0FWRV9EWCksCgkJUENJX0NMQVNTX01VTFRJTUVESUFfQVVESU8gPDwgOCwgMHhmZmZmMDAsIFRSSURFTlRfNERfRFh9LAoJe1BDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9UUklERU5ULCBQQ0lfREVWSUNFX0lEX1RSSURFTlRfNERXQVZFX05YKSwKCQkwLCAwLCBUUklERU5UXzREX05YfSwKCXtQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfU0ksIFBDSV9ERVZJQ0VfSURfU0lfNzAxOCksIDAsIDAsIFNJU183MDE4fSwKCXtQQ0lfREVWSUNFKFBDSV9WRU5ET1JfSURfQUxJLCBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKSwgMCwgMCwgQUxJXzU0NTF9LAoJe1BDSV9ERVZJQ0UoUENJX1ZFTkRPUl9JRF9JTlRFUkcsIFBDSV9ERVZJQ0VfSURfSU5URVJHXzUwNTApLAoJCTAsIDAsIENZQkVSNTA1MH0sCgl7MCx9Cn07CgpNT0RVTEVfREVWSUNFX1RBQkxFKHBjaSwgdHJpZGVudF9wY2lfdGJsKTsKCi8qICJzb2Z0d2FyZSIgb3IgdmlydHVhbCBjaGFubmVsLCBhbiBpbnN0YW5jZSBvZiBvcGVuZWQgL2Rldi9kc3AgKi8Kc3RydWN0IHRyaWRlbnRfc3RhdGUgewoJdW5zaWduZWQgaW50IG1hZ2ljOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZDsJLyogQ2FyZCBpbmZvICovCgoJLyogZmlsZSBtb2RlICovCgltb2RlX3Qgb3Blbl9tb2RlOwoKCS8qIHZpcnR1YWwgY2hhbm5lbCBudW1iZXIgKi8KCWludCB2aXJ0OwoKCXN0cnVjdCBkbWFidWYgewoJCS8qIHdhdmUgc2FtcGxlIHN0dWZmICovCgkJdW5zaWduZWQgaW50IHJhdGU7CgkJdW5zaWduZWQgY2hhciBmbXQsIGVuYWJsZTsKCgkJLyogaGFyZHdhcmUgY2hhbm5lbCAqLwoJCXN0cnVjdCB0cmlkZW50X2NoYW5uZWwgKmNoYW5uZWw7CgoJCS8qIE9TUyBidWZmZXIgbWFuYWdlbWVudCBzdHVmZiAqLwoJCXZvaWQgKnJhd2J1ZjsKCQlkbWFfYWRkcl90IGRtYV9oYW5kbGU7CgkJdW5zaWduZWQgYnVmb3JkZXI7CgkJdW5zaWduZWQgbnVtZnJhZzsKCQl1bnNpZ25lZCBmcmFnc2hpZnQ7CgoJCS8qIG91ciBidWZmZXIgYWN0cyBsaWtlIGEgY2lyY3VsYXIgcmluZyAqLwoJCXVuc2lnbmVkIGh3cHRyOwkvKiB3aGVyZSBkbWEgbGFzdCBzdGFydGVkLCB1cGRhdGVkIGJ5IHVwZGF0ZV9wdHIgKi8KCQl1bnNpZ25lZCBzd3B0cjsJLyogd2hlcmUgZHJpdmVyIGxhc3QgY2xlYXIvZmlsbGVkLCB1cGRhdGVkIGJ5IHJlYWQvd3JpdGUgKi8KCQlpbnQgY291bnQ7CS8qIGJ5dGVzIHRvIGJlIGNvbXN1bWVkIG9yIGJlZW4gZ2VuZXJhdGVkIGJ5IGRtYSBtYWNoaW5lICovCgkJdW5zaWduZWQgdG90YWxfYnl0ZXM7CS8qIHRvdGFsIGJ5dGVzIGRtYWVkIGJ5IGhhcmR3YXJlICovCgoJCXVuc2lnbmVkIGVycm9yOwkvKiBudW1iZXIgb2Ygb3Zlci91bmRlcnJ1bnMgKi8KICAgICAgICAgICAgICAgIC8qIHB1dCBwcm9jZXNzIG9uIHdhaXQgcXVldWUgd2hlbiBubyBtb3JlIHNwYWNlIGluIGJ1ZmZlciAqLwoJCXdhaXRfcXVldWVfaGVhZF90IHdhaXQ7CQoKCQkvKiByZWR1bmRhbnQsIGJ1dCBtYWtlcyBjYWxjdWxhdGlvbnMgZWFzaWVyICovCgkJdW5zaWduZWQgZnJhZ3NpemU7CgkJdW5zaWduZWQgZG1hc2l6ZTsKCQl1bnNpZ25lZCBmcmFnc2FtcGxlczsKCgkJLyogT1NTIHN0dWZmICovCgkJdW5zaWduZWQgbWFwcGVkOjE7CgkJdW5zaWduZWQgcmVhZHk6MTsKCQl1bnNpZ25lZCBlbmRjbGVhcmVkOjE7CgkJdW5zaWduZWQgdXBkYXRlX2ZsYWc7CgkJdW5zaWduZWQgb3NzZnJhZ3NoaWZ0OwoJCWludCBvc3NtYXhmcmFnczsKCQl1bnNpZ25lZCBzdWJkaXZpc2lvbjsKCgl9IGRtYWJ1ZjsKCgkvKiA1LjEgY2hhbm5lbHMgKi8KCXN0cnVjdCB0cmlkZW50X3N0YXRlICpvdGhlcl9zdGF0ZXNbNF07CglpbnQgbXVsdGlfY2hhbm5lbHNfYWRqdXN0X2NvdW50OwoJdW5zaWduZWQgY2hhbnNfbnVtOwoJdW5zaWduZWQgbG9uZyBmbXRfZmxhZzsKCS8qIEd1YXJkIGFnYWluc3QgbW1hcC93cml0ZS9yZWFkIHJhY2VzICovCglzdHJ1Y3QgbXV0ZXggc2VtOwoKfTsKCi8qIGhhcmR3YXJlIGNoYW5uZWxzICovCnN0cnVjdCB0cmlkZW50X2NoYW5uZWwgewoJaW50IG51bTsgLyogY2hhbm5lbCBudW1iZXIgKi8KCXUzMiBsYmE7IC8qIExvb3AgQmVnaW5lIEFkZHJlc3MsIHdoZXJlIGRtYSBidWZmZXIgc3RhcnRzICovCgl1MzIgZXNvOyAvKiBFbmQgU2FtcGxlIE9mZnNldCwgd2VocmUgZG1hIGJ1ZmZlciBlbmRzICovIAoJICAgICAgICAgLyogKGluIHRoZSB1bml0IG9mIHNhbXBsZXMpICovCgl1MzIgZGVsdGE7IC8qIGRlbHRhIHZhbHVlLCBzYW1wbGUgcmF0ZSAvIDQ4ayBmb3IgcGxheWJhY2ssICovCgkgICAgICAgICAgIC8qIDQ4ay9zYW1wbGUgcmF0ZSBmb3IgcmVjb3JkaW5nICovCgl1MTYgYXR0cmlidXRlOyAvKiBjb250cm9sIHdoZXJlIFBDTSBkYXRhIGdvIGFuZCBjb21lICAqLwoJdTE2IGZtX3ZvbDsKCXUzMiBjb250cm9sOyAvKiBzaWduZWQvdW5zaWduZWQsIDgvMTYgYml0cywgbW9uby9zdGVyZW8gKi8KfTsKCnN0cnVjdCB0cmlkZW50X3BjbV9iYW5rX2FkZHJlc3MgewoJdTMyIHN0YXJ0OwoJdTMyIHN0b3A7Cgl1MzIgYWludDsKCXUzMiBhaW50X2VuOwp9OwoKc3RhdGljIHN0cnVjdCB0cmlkZW50X3BjbV9iYW5rX2FkZHJlc3MgYmFua19hX2FkZHJzID0gewoJVDREX1NUQVJUX0EsCglUNERfU1RPUF9BLAoJVDREX0FJTlRfQSwKCVQ0RF9BSU5URU5fQQp9OwoKc3RhdGljIHN0cnVjdCB0cmlkZW50X3BjbV9iYW5rX2FkZHJlc3MgYmFua19iX2FkZHJzID0gewoJVDREX1NUQVJUX0IsCglUNERfU1RPUF9CLAoJVDREX0FJTlRfQiwKCVQ0RF9BSU5URU5fQgp9OwoKc3RydWN0IHRyaWRlbnRfcGNtX2JhbmsgewoJLyogcmVnaXN0ZXIgYWRkcmVzc2VzIHRvIGNvbnRyb2wgYmFuayBvcGVyYXRpb25zICovCglzdHJ1Y3QgdHJpZGVudF9wY21fYmFua19hZGRyZXNzICphZGRyZXNzZXM7CgkvKiBlYWNoIGJhbmsgaGFzIDMyIGNoYW5uZWxzICovCgl1MzIgYml0bWFwOwkJLyogY2hhbm5lbCBhbGxvY2F0aW9uIGJpdG1hcCAqLwoJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCBjaGFubmVsc1szMl07Cn07CgpzdHJ1Y3QgdHJpZGVudF9jYXJkIHsKCXVuc2lnbmVkIGludCBtYWdpYzsKCgkvKiBXZSBrZWVwIHRyaWRlbnQgY2FyZHMgaW4gYSBsaW5rZWQgbGlzdCAqLwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqbmV4dDsKCgkvKiBzaW5nbGUgb3BlbiBsb2NrIG1lY2hhbmlzbSwgb25seSB1c2VkIGZvciByZWNvcmRpbmcgKi8KCXN0cnVjdCBtdXRleCBvcGVuX211dGV4OwoKCS8qIFRoZSB0cmlkZW50IGhhcyBhIGNlcnRhaW4gYW1vdW50IG9mIGNyb3NzIGNoYW5uZWwgaW50ZXJhY3Rpb24KCSAgIHNvIHdlIHVzZSBhIHNpbmdsZSBwZXIgY2FyZCBsb2NrICovCglzcGlubG9ja190IGxvY2s7CgoJLyogUENJIGRldmljZSBzdHVmZiAqLwoJc3RydWN0IHBjaV9kZXYgKnBjaV9kZXY7Cgl1MTYgcGNpX2lkOwoJdTggcmV2aXNpb247CgoJLyogc291bmRjb3JlIHN0dWZmICovCglpbnQgZGV2X2F1ZGlvOwoKCS8qIHN0cnVjdHVyZXMgZm9yIGFic3RyYWN0aW9uIG9mIGhhcmR3YXJlIGZhY2lsaXRpZXMsIGNvZGVjcywgKi8gCgkvKiBiYW5rcyBhbmQgY2hhbm5lbHMgKi8KCXN0cnVjdCBhYzk3X2NvZGVjICphYzk3X2NvZGVjW05SX0FDOTddOwoJc3RydWN0IHRyaWRlbnRfcGNtX2JhbmsgYmFua3NbTlJfQkFOS1NdOwoJc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlc1tOUl9IV19DSF07CgoJLyogaGFyZHdhcmUgcmVzb3VyY2VzICovCgl1bnNpZ25lZCBsb25nIGlvYmFzZTsKCXUzMiBpcnE7CgoJLyogRnVuY3Rpb24gc3VwcG9ydCAqLwoJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqKCphbGxvY19wY21fY2hhbm5lbCkgKHN0cnVjdCB0cmlkZW50X2NhcmQgKik7CglzdHJ1Y3QgdHJpZGVudF9jaGFubmVsICooKmFsbG9jX3JlY19wY21fY2hhbm5lbCkgKHN0cnVjdCB0cmlkZW50X2NhcmQgKik7Cgl2b2lkICgqZnJlZV9wY21fY2hhbm5lbCkgKHN0cnVjdCB0cmlkZW50X2NhcmQgKiwgdW5zaWduZWQgaW50IGNoYW4pOwoJdm9pZCAoKmFkZHJlc3NfaW50ZXJydXB0KSAoc3RydWN0IHRyaWRlbnRfY2FyZCAqKTsKCgkvKiBBZGRlZCBieSBNYXR0IFd1IDAxLTA1LTIwMDEgZm9yIHNwZGlmIGluICovCglpbnQgbXVsdGlfY2hhbm5lbF91c2VfY291bnQ7CglpbnQgcmVjX2NoYW5uZWxfdXNlX2NvdW50OwoJdTE2IG1peGVyX3JlZ3NbNjRdW05SX0FDOTddOwkvKiBNYWRlIGNhcmQgbG9jYWwgYnkgQWxhbiAqLwoJaW50IG1peGVyX3JlZ3NfcmVhZHk7CgoJLyogQWRkZWQgZm9yIGhhcmR3YXJlIHZvbHVtZSBjb250cm9sICovCglpbnQgaHd2b2xjdGw7CglzdHJ1Y3QgdGltZXJfbGlzdCB0aW1lcjsKCgkvKiBHYW1lIHBvcnQgc3VwcG9ydCAqLwoJc3RydWN0IGdhbWVwb3J0ICpnYW1lcG9ydDsKfTsKCmVudW0gZG1hYnVmX21vZGUgewoJRE1fUExBWUJBQ0sgPSAwLAoJRE1fUkVDT1JECn07CgovKiB0YWJsZSB0byBtYXAgZnJvbSBDSEFOTkVMTUFTSyB0byBjaGFubmVsIGF0dHJpYnV0ZSBmb3IgU2lTIDcwMTggKi8Kc3RhdGljIHUxNiBtYXNrMmF0dHJbXSA9IHsKCVBDTV9MUiwgUENNX0xSLCBTVVJSX0xSLCBDRU5URVJfTEZFLAoJSFNFVCwgTUlDLCBNT0RFTV9MSU5FMSwgTU9ERU1fTElORTIsCglJMlNfTFIsIFNQRElGX0xSCn07CgovKiB0YWJsZSB0byBtYXAgZnJvbSBjaGFubmVsIGF0dHJpYnV0ZSB0byBDSEFOTkVMTUFTSyBmb3IgU2lTIDcwMTggKi8Kc3RhdGljIGludCBhdHRyMm1hc2tbXSA9IHsKCURTUF9CSU5EX01PREVNMSwgRFNQX0JJTkRfTU9ERU0yLCBEU1BfQklORF9GUk9OVCwgRFNQX0JJTkRfSEFORFNFVCwKCURTUF9CSU5EX0kyUywgRFNQX0JJTkRfQ0VOVEVSX0xGRSwgRFNQX0JJTkRfU1VSUiwgRFNQX0JJTkRfU1BESUYKfTsKCi8qIEFkZGVkIGJ5IE1hdHQgV3UgMDEtMDUtMjAwMSBmb3Igc3BkaWYgaW4gKi8Kc3RhdGljIGludCBhbGlfY2xvc2VfbXVsdGlfY2hhbm5lbHModm9pZCk7CnN0YXRpYyB2b2lkIGFsaV9kZWxheShzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCBpbnQgaW50ZXJ2YWwpOwpzdGF0aWMgdm9pZCBhbGlfZGV0ZWN0X3NwZGlmX3JhdGUoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCk7CgpzdGF0aWMgdm9pZCBhbGlfYWM5N193cml0ZShzdHJ1Y3QgYWM5N19jb2RlYyAqY29kZWMsIHU4IHJlZywgdTE2IHZhbCk7CnN0YXRpYyB1MTYgYWxpX2FjOTdfcmVhZChzdHJ1Y3QgYWM5N19jb2RlYyAqY29kZWMsIHU4IHJlZyk7CgpzdGF0aWMgc3RydWN0IHRyaWRlbnRfY2FyZCAqZGV2czsKCnN0YXRpYyB2b2lkIHRyaWRlbnRfYWM5N19zZXQoc3RydWN0IGFjOTdfY29kZWMgKmNvZGVjLCB1OCByZWcsIHUxNiB2YWwpOwpzdGF0aWMgdTE2IHRyaWRlbnRfYWM5N19nZXQoc3RydWN0IGFjOTdfY29kZWMgKmNvZGVjLCB1OCByZWcpOwoKc3RhdGljIGludCB0cmlkZW50X29wZW5fbWl4ZGV2KHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKTsKc3RhdGljIGludCB0cmlkZW50X2lvY3RsX21peGRldihzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSwgCgkJCQl1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZyk7CgpzdGF0aWMgdm9pZCBhbGlfYWM5N19zZXQoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgaW50IHNlY29uZGFyeSwgdTggcmVnLCB1MTYgdmFsKTsKc3RhdGljIHUxNiBhbGlfYWM5N19nZXQoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgaW50IHNlY29uZGFyeSwgdTggcmVnKTsKc3RhdGljIHZvaWQgYWxpX3NldF9zcGRpZl9vdXRfcmF0ZShzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCB1bnNpZ25lZCBpbnQgcmF0ZSk7CnN0YXRpYyB2b2lkIGFsaV9lbmFibGVfc3BlY2lhbF9jaGFubmVsKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0KTsKc3RhdGljIHN0cnVjdCB0cmlkZW50X2NoYW5uZWwgKmFsaV9hbGxvY19yZWNfcGNtX2NoYW5uZWwoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCk7CnN0YXRpYyBzdHJ1Y3QgdHJpZGVudF9jaGFubmVsICphbGlfYWxsb2NfcGNtX2NoYW5uZWwoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCk7CnN0YXRpYyB2b2lkIGFsaV9yZXN0b3JlX3JlZ3Moc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCk7CnN0YXRpYyB2b2lkIGFsaV9zYXZlX3JlZ3Moc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCk7CnN0YXRpYyBpbnQgdHJpZGVudF9zdXNwZW5kKHN0cnVjdCBwY2lfZGV2ICpkZXYsIHBtX21lc3NhZ2VfdCB1bnVzZWQpOwpzdGF0aWMgaW50IHRyaWRlbnRfcmVzdW1lKHN0cnVjdCBwY2lfZGV2ICpkZXYpOwpzdGF0aWMgdm9pZCBhbGlfZnJlZV9wY21fY2hhbm5lbChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCB1bnNpZ25lZCBpbnQgY2hhbm5lbCk7CnN0YXRpYyBpbnQgYWxpX3NldHVwX211bHRpX2NoYW5uZWxzKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIGludCBjaGFuX251bXMpOwpzdGF0aWMgdW5zaWduZWQgaW50IGFsaV9nZXRfc3BkaWZfaW5fcmF0ZShzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKTsKc3RhdGljIHZvaWQgYWxpX3NldHVwX3NwZGlmX2luKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpOwpzdGF0aWMgdm9pZCBhbGlfZGlzYWJsZV9zcGRpZl9pbihzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKTsKc3RhdGljIHZvaWQgYWxpX2Rpc2FibGVfc3BlY2lhbF9jaGFubmVsKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIGludCBjaCk7CnN0YXRpYyB2b2lkIGFsaV9zZXR1cF9zcGRpZl9vdXQoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgaW50IGZsYWcpOwpzdGF0aWMgaW50IGFsaV93cml0ZV81XzEoc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlLAoJCQkgY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwgCgkJCSBpbnQgY250X2Zvcl9tdWx0aV9jaGFubmVsLCB1bnNpZ25lZCBpbnQgKmNvcHlfY291bnQsIAoJCQkgdW5zaWduZWQgaW50ICpzdGF0ZV9jbnQpOwpzdGF0aWMgaW50IGFsaV9hbGxvY2F0ZV9vdGhlcl9zdGF0ZXNfcmVzb3VyY2VzKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSwgCgkJCQkJICAgICAgIGludCBjaGFuX251bXMpOwpzdGF0aWMgdm9pZCBhbGlfZnJlZV9vdGhlcl9zdGF0ZXNfcmVzb3VyY2VzKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSk7CgovKiBzYXZlIHJlZ2lzdGVycyBmb3IgQUxpIFBvd2VyIE1hbmFnZW1lbnQgKi8Kc3RhdGljIHN0cnVjdCBhbGlfc2F2ZWRfcmVnaXN0ZXJzIHsKCXVuc2lnbmVkIGxvbmcgZ2xvYmFsX3JlZ3NbQUxJX0dMT0JBTF9SRUdTXTsKCXVuc2lnbmVkIGxvbmcgY2hhbm5lbF9yZWdzW0FMSV9DSEFOTkVMU11bQUxJX0NIQU5ORUxfUkVHU107Cgl1bnNpZ25lZCBtaXhlcl9yZWdzW0FMSV9NSVhFUl9SRUdTXTsKfSBhbGlfcmVnaXN0ZXJzOwoKI2RlZmluZSBzZWVrX29mZnNldChkbWFfcHRyLCBidWZmZXIsIGNudCwgb2Zmc2V0LCBjb3B5X2NvdW50KQlkbyB7IFwKICAgICAgICAoZG1hX3B0cikgKz0gKG9mZnNldCk7CSAgXAoJKGJ1ZmZlcikgKz0gKG9mZnNldCk7CSAgXAogICAgICAgIChjbnQpIC09IChvZmZzZXQpOwkgIFwKCShjb3B5X2NvdW50KSArPSAob2Zmc2V0KTsgXAp9IHdoaWxlICgwKQoKc3RhdGljIGlubGluZSBpbnQgbG9ja19zZXRfZm10KHN0cnVjdCB0cmlkZW50X3N0YXRlKiBzdGF0ZSkKewoJaWYgKHRlc3RfYW5kX3NldF9iaXQoMCwgJnN0YXRlLT5mbXRfZmxhZykpCgkJcmV0dXJuIC1FRkFVTFQ7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCB1bmxvY2tfc2V0X2ZtdChzdHJ1Y3QgdHJpZGVudF9zdGF0ZSogc3RhdGUpCnsKCWNsZWFyX2JpdCgwLCAmc3RhdGUtPmZtdF9mbGFnKTsKfQoKc3RhdGljIGludAp0cmlkZW50X2VuYWJsZV9sb29wX2ludGVycnVwdHMoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkKewoJdTMyIGdsb2JhbF9jb250cm9sOwoKCWdsb2JhbF9jb250cm9sID0gaW5sKFRSSURfUkVHKGNhcmQsIFQ0RF9MRk9fR0NfQ0lSKSk7CgoJc3dpdGNoIChjYXJkLT5wY2lfaWQpIHsKCWNhc2UgUENJX0RFVklDRV9JRF9TSV83MDE4OgoJCWdsb2JhbF9jb250cm9sIHw9IChFTkRMUF9JRSB8IE1JRExQX0lFIHwgQkFOS19CX0VOKTsKCQlicmVhazsKCWNhc2UgUENJX0RFVklDRV9JRF9BTElfNTQ1MToKCWNhc2UgUENJX0RFVklDRV9JRF9UUklERU5UXzREV0FWRV9EWDoKCWNhc2UgUENJX0RFVklDRV9JRF9UUklERU5UXzREV0FWRV9OWDoKCWNhc2UgUENJX0RFVklDRV9JRF9JTlRFUkdfNTA1MDoKCQlnbG9iYWxfY29udHJvbCB8PSAoRU5ETFBfSUUgfCBNSURMUF9JRSk7CgkJYnJlYWs7CglkZWZhdWx0OgoJCXJldHVybiAwOwoJfQoKCW91dGwoZ2xvYmFsX2NvbnRyb2wsIFRSSURfUkVHKGNhcmQsIFQ0RF9MRk9fR0NfQ0lSKSk7CgoJcHJfZGVidWcoInRyaWRlbnQ6IEVuYWJsZSBMb29wIEludGVycnVwdHMsIGdsb2JjdGwgPSAweCUwOFhcbiIsCgkJIGlubChUUklEX1JFRyhjYXJkLCBUNERfTEZPX0dDX0NJUikpKTsKCglyZXR1cm4gMTsKfQoKc3RhdGljIGludAp0cmlkZW50X2Rpc2FibGVfbG9vcF9pbnRlcnJ1cHRzKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCXUzMiBnbG9iYWxfY29udHJvbDsKCglnbG9iYWxfY29udHJvbCA9IGlubChUUklEX1JFRyhjYXJkLCBUNERfTEZPX0dDX0NJUikpOwoJZ2xvYmFsX2NvbnRyb2wgJj0gfihFTkRMUF9JRSB8IE1JRExQX0lFKTsKCW91dGwoZ2xvYmFsX2NvbnRyb2wsIFRSSURfUkVHKGNhcmQsIFQ0RF9MRk9fR0NfQ0lSKSk7CgoJcHJfZGVidWcoInRyaWRlbnQ6IERpc2FibGVkIExvb3AgSW50ZXJydXB0cywgZ2xvYmN0bCA9IDB4JTA4WFxuIiwKCQkgZ2xvYmFsX2NvbnRyb2wpOwoKCXJldHVybiAxOwp9CgpzdGF0aWMgdm9pZAp0cmlkZW50X2VuYWJsZV92b2ljZV9pcnEoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgdW5zaWduZWQgaW50IGNoYW5uZWwpCnsKCXVuc2lnbmVkIGludCBtYXNrID0gMSA8PCAoY2hhbm5lbCAmIDB4MWYpOwoJc3RydWN0IHRyaWRlbnRfcGNtX2JhbmsgKmJhbmsgPSAmY2FyZC0+YmFua3NbY2hhbm5lbCA+PiA1XTsKCXUzMiByZWcsIGFkZHIgPSBiYW5rLT5hZGRyZXNzZXMtPmFpbnRfZW47CgoJcmVnID0gaW5sKFRSSURfUkVHKGNhcmQsIGFkZHIpKTsKCXJlZyB8PSBtYXNrOwoJb3V0bChyZWcsIFRSSURfUkVHKGNhcmQsIGFkZHIpKTsKCiNpZmRlZiBERUJVRwoJcmVnID0gaW5sKFRSSURfUkVHKGNhcmQsIGFkZHIpKTsKCXByX2RlYnVnKCJ0cmlkZW50OiBlbmFibGVkIElSUSBvbiBjaGFubmVsICVkLCAlcyA9IDB4JTA4eChhZGRyOiVYKVxuIiwKCQkgY2hhbm5lbCwgYWRkciA9PSBUNERfQUlOVEVOX0IgPyAiQUlOVEVOX0IiIDogIkFJTlRFTl9BIiwKCQkgcmVnLCBhZGRyKTsKI2VuZGlmIC8qIERFQlVHICovCn0KCnN0YXRpYyB2b2lkCnRyaWRlbnRfZGlzYWJsZV92b2ljZV9pcnEoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgdW5zaWduZWQgaW50IGNoYW5uZWwpCnsKCXVuc2lnbmVkIGludCBtYXNrID0gMSA8PCAoY2hhbm5lbCAmIDB4MWYpOwoJc3RydWN0IHRyaWRlbnRfcGNtX2JhbmsgKmJhbmsgPSAmY2FyZC0+YmFua3NbY2hhbm5lbCA+PiA1XTsKCXUzMiByZWcsIGFkZHIgPSBiYW5rLT5hZGRyZXNzZXMtPmFpbnRfZW47CgoJcmVnID0gaW5sKFRSSURfUkVHKGNhcmQsIGFkZHIpKTsKCXJlZyAmPSB+bWFzazsKCW91dGwocmVnLCBUUklEX1JFRyhjYXJkLCBhZGRyKSk7CgoJLyogQWNrIHRoZSBjaGFubmVsIGluIGNhc2UgdGhlIGludGVycnVwdCB3YXMgc2V0IGJlZm9yZSB3ZSBkaXNhYmxlIGl0LiAqLwoJb3V0bChtYXNrLCBUUklEX1JFRyhjYXJkLCBiYW5rLT5hZGRyZXNzZXMtPmFpbnQpKTsKCiNpZmRlZiBERUJVRwoJcmVnID0gaW5sKFRSSURfUkVHKGNhcmQsIGFkZHIpKTsKCXByX2RlYnVnKCJ0cmlkZW50OiBkaXNhYmxlZCBJUlEgb24gY2hhbm5lbCAlZCwgJXMgPSAweCUwOHgoYWRkcjolWClcbiIsCgkJIGNoYW5uZWwsIGFkZHIgPT0gVDREX0FJTlRFTl9CID8gIkFJTlRFTl9CIiA6ICJBSU5URU5fQSIsCgkJIHJlZywgYWRkcik7CiNlbmRpZiAvKiBERUJVRyAqLwp9CgpzdGF0aWMgdm9pZAp0cmlkZW50X3N0YXJ0X3ZvaWNlKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIHVuc2lnbmVkIGludCBjaGFubmVsKQp7Cgl1bnNpZ25lZCBpbnQgbWFzayA9IDEgPDwgKGNoYW5uZWwgJiAweDFmKTsKCXN0cnVjdCB0cmlkZW50X3BjbV9iYW5rICpiYW5rID0gJmNhcmQtPmJhbmtzW2NoYW5uZWwgPj4gNV07Cgl1MzIgYWRkciA9IGJhbmstPmFkZHJlc3Nlcy0+c3RhcnQ7CgojaWZkZWYgREVCVUcKCXUzMiByZWc7CiNlbmRpZiAvKiBERUJVRyAqLwoKCW91dGwobWFzaywgVFJJRF9SRUcoY2FyZCwgYWRkcikpOwoKI2lmZGVmIERFQlVHCglyZWcgPSBpbmwoVFJJRF9SRUcoY2FyZCwgYWRkcikpOwoJcHJfZGVidWcoInRyaWRlbnQ6IHN0YXJ0IHZvaWNlIG9uIGNoYW5uZWwgJWQsICVzID0gMHglMDh4KGFkZHI6JVgpXG4iLAoJCSBjaGFubmVsLCBhZGRyID09IFQ0RF9TVEFSVF9CID8gIlNUQVJUX0IiIDogIlNUQVJUX0EiLAoJCSByZWcsIGFkZHIpOwojZW5kaWYgLyogREVCVUcgKi8KfQoKc3RhdGljIHZvaWQKdHJpZGVudF9zdG9wX3ZvaWNlKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIHVuc2lnbmVkIGludCBjaGFubmVsKQp7Cgl1bnNpZ25lZCBpbnQgbWFzayA9IDEgPDwgKGNoYW5uZWwgJiAweDFmKTsKCXN0cnVjdCB0cmlkZW50X3BjbV9iYW5rICpiYW5rID0gJmNhcmQtPmJhbmtzW2NoYW5uZWwgPj4gNV07Cgl1MzIgYWRkciA9IGJhbmstPmFkZHJlc3Nlcy0+c3RvcDsKCiNpZmRlZiBERUJVRwoJdTMyIHJlZzsKI2VuZGlmIC8qIERFQlVHICovCgoJb3V0bChtYXNrLCBUUklEX1JFRyhjYXJkLCBhZGRyKSk7CgojaWZkZWYgREVCVUcKCXJlZyA9IGlubChUUklEX1JFRyhjYXJkLCBhZGRyKSk7Cglwcl9kZWJ1ZygidHJpZGVudDogc3RvcCB2b2ljZSBvbiBjaGFubmVsICVkLCAlcyA9IDB4JTA4eChhZGRyOiVYKVxuIiwKCQkgY2hhbm5lbCwgYWRkciA9PSBUNERfU1RPUF9CID8gIlNUT1BfQiIgOiAiU1RPUF9BIiwKCQkgcmVnLCBhZGRyKTsKI2VuZGlmIC8qIERFQlVHICovCn0KCnN0YXRpYyB1MzIKdHJpZGVudF9nZXRfaW50ZXJydXB0X21hc2soc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgdW5zaWduZWQgaW50IGNoYW5uZWwpCnsKCXN0cnVjdCB0cmlkZW50X3BjbV9iYW5rICpiYW5rID0gJmNhcmQtPmJhbmtzW2NoYW5uZWxdOwoJdTMyIGFkZHIgPSBiYW5rLT5hZGRyZXNzZXMtPmFpbnQ7CglyZXR1cm4gaW5sKFRSSURfUkVHKGNhcmQsIGFkZHIpKTsKfQoKc3RhdGljIGludAp0cmlkZW50X2NoZWNrX2NoYW5uZWxfaW50ZXJydXB0KHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIHVuc2lnbmVkIGludCBjaGFubmVsKQp7Cgl1bnNpZ25lZCBpbnQgbWFzayA9IDEgPDwgKGNoYW5uZWwgJiAweDFmKTsKCXUzMiByZWcgPSB0cmlkZW50X2dldF9pbnRlcnJ1cHRfbWFzayhjYXJkLCBjaGFubmVsID4+IDUpOwoKI2lmZGVmIERFQlVHCglpZiAocmVnICYgbWFzaykKCQlwcl9kZWJ1ZygidHJpZGVudDogY2hhbm5lbCAlZCBoYXMgaW50ZXJydXB0LCAlcyA9IDB4JTA4eFxuIiwKCQkJIGNoYW5uZWwsIHJlZyA9PSBUNERfQUlOVF9CID8gIkFJTlRfQiIgOiAiQUlOVF9BIiwKCQkJIHJlZyk7CiNlbmRpZiAvKiBERUJVRyAqLwoJcmV0dXJuIChyZWcgJiBtYXNrKSA/IDEgOiAwOwp9CgpzdGF0aWMgdm9pZAp0cmlkZW50X2Fja19jaGFubmVsX2ludGVycnVwdChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCB1bnNpZ25lZCBpbnQgY2hhbm5lbCkKewoJdW5zaWduZWQgaW50IG1hc2sgPSAxIDw8IChjaGFubmVsICYgMHgxZik7CglzdHJ1Y3QgdHJpZGVudF9wY21fYmFuayAqYmFuayA9ICZjYXJkLT5iYW5rc1tjaGFubmVsID4+IDVdOwoJdTMyIHJlZywgYWRkciA9IGJhbmstPmFkZHJlc3Nlcy0+YWludDsKCglyZWcgPSBpbmwoVFJJRF9SRUcoY2FyZCwgYWRkcikpOwoJcmVnICY9IG1hc2s7CglvdXRsKHJlZywgVFJJRF9SRUcoY2FyZCwgYWRkcikpOwoKI2lmZGVmIERFQlVHCglyZWcgPSBpbmwoVFJJRF9SRUcoY2FyZCwgVDREX0FJTlRfQikpOwoJcHJfZGVidWcoInRyaWRlbnQ6IEFjayBjaGFubmVsICVkIGludGVycnVwdCwgQUlOVF9CID0gMHglMDh4XG4iLAoJCSBjaGFubmVsLCByZWcpOwojZW5kaWYgLyogREVCVUcgKi8KfQoKc3RhdGljIHN0cnVjdCB0cmlkZW50X2NoYW5uZWwgKgp0cmlkZW50X2FsbG9jX3BjbV9jaGFubmVsKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCXN0cnVjdCB0cmlkZW50X3BjbV9iYW5rICpiYW5rOwoJaW50IGlkeDsKCgliYW5rID0gJmNhcmQtPmJhbmtzW0JBTktfQl07CgoJZm9yIChpZHggPSAzMTsgaWR4ID49IDA7IGlkeC0tKSB7CgkJaWYgKCEoYmFuay0+Yml0bWFwICYgKDEgPDwgaWR4KSkpIHsKCQkJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqY2hhbm5lbCA9ICZiYW5rLT5jaGFubmVsc1tpZHhdOwoJCQliYW5rLT5iaXRtYXAgfD0gMSA8PCBpZHg7CgkJCWNoYW5uZWwtPm51bSA9IGlkeCArIDMyOwoJCQlyZXR1cm4gY2hhbm5lbDsKCQl9Cgl9CgoJLyogbm8gbW9yZSBmcmVlIGNoYW5uZWxzIGF2YWlsYWJsZSAqLwoJcHJpbnRrKEtFUk5fRVJSICJ0cmlkZW50OiBubyBtb3JlIGNoYW5uZWxzIGF2YWlsYWJsZSBvbiBCYW5rIEIuXG4iKTsKCXJldHVybiBOVUxMOwp9CgpzdGF0aWMgdm9pZAp0cmlkZW50X2ZyZWVfcGNtX2NoYW5uZWwoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgdW5zaWduZWQgaW50IGNoYW5uZWwpCnsKCWludCBiYW5rOwoJdW5zaWduZWQgY2hhciBiOwoKCWlmIChjaGFubmVsIDwgMzEgfHwgY2hhbm5lbCA+IDYzKQoJCXJldHVybjsKCglpZiAoY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfRFggfHwgCgkgICAgY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfTlgpIHsKCQliID0gaW5iKFRSSURfUkVHKGNhcmQsIFQ0RF9SRUNfQ0gpKTsKCQlpZiAoKGIgJiB+MHg4MCkgPT0gY2hhbm5lbCkKCQkJb3V0YigweDAsIFRSSURfUkVHKGNhcmQsIFQ0RF9SRUNfQ0gpKTsKCX0KCgliYW5rID0gY2hhbm5lbCA+PiA1OwoJY2hhbm5lbCA9IGNoYW5uZWwgJiAweDFmOwoKCWNhcmQtPmJhbmtzW2JhbmtdLmJpdG1hcCAmPSB+KDEgPDwgKGNoYW5uZWwpKTsKfQoKc3RhdGljIHN0cnVjdCB0cmlkZW50X2NoYW5uZWwgKgpjeWJlcl9hbGxvY19wY21fY2hhbm5lbChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7CglzdHJ1Y3QgdHJpZGVudF9wY21fYmFuayAqYmFuazsKCWludCBpZHg7CgoJLyogVGhlIGN5YmVycHJvIDUwNTAgaGFzIG9ubHkgMzIgdm9pY2VzIGFuZCBvbmUgYmFuayAqLwoJLyogLi4gYXQgbGVhc3QgdGhleSBhcmUgbm90IGRvY3VtZW50ZWQgKGlmIHlvdSB3YW50IHRvIGNhbGwgdGhhdCAKCSAqIGNyYXAgZG9jdW1lbnRhdGlvbiksIHBlcmhhcHMgYnJva2VuID8gKi8KCgliYW5rID0gJmNhcmQtPmJhbmtzW0JBTktfQV07CgoJZm9yIChpZHggPSAzMTsgaWR4ID49IDA7IGlkeC0tKSB7CgkJaWYgKCEoYmFuay0+Yml0bWFwICYgKDEgPDwgaWR4KSkpIHsKCQkJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqY2hhbm5lbCA9ICZiYW5rLT5jaGFubmVsc1tpZHhdOwoJCQliYW5rLT5iaXRtYXAgfD0gMSA8PCBpZHg7CgkJCWNoYW5uZWwtPm51bSA9IGlkeDsKCQkJcmV0dXJuIGNoYW5uZWw7CgkJfQoJfQoKCS8qIG5vIG1vcmUgZnJlZSBjaGFubmVscyBhdmFpbGFibGUgKi8KCXByaW50ayhLRVJOX0VSUiAiY3liZXJwcm81MDUwOiBubyBtb3JlIGNoYW5uZWxzIGF2YWlsYWJsZSBvbiBCYW5rIEEuXG4iKTsKCXJldHVybiBOVUxMOwp9CgpzdGF0aWMgdm9pZApjeWJlcl9mcmVlX3BjbV9jaGFubmVsKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIHVuc2lnbmVkIGludCBjaGFubmVsKQp7CglpZiAoY2hhbm5lbCA+IDMxKQoJCXJldHVybjsKCWNhcmQtPmJhbmtzW0JBTktfQV0uYml0bWFwICY9IH4oMSA8PCAoY2hhbm5lbCkpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQKY3liZXJfb3V0aWR4KGludCBwb3J0LCBpbnQgaWR4LCBpbnQgZGF0YSkKewoJb3V0YihpZHgsIHBvcnQpOwoJb3V0YihkYXRhLCBwb3J0ICsgMSk7Cn0KCnN0YXRpYyBpbmxpbmUgaW50CmN5YmVyX2luaWR4KGludCBwb3J0LCBpbnQgaWR4KQp7CglvdXRiKGlkeCwgcG9ydCk7CglyZXR1cm4gaW5iKHBvcnQgKyAxKTsKfQoKc3RhdGljIGludApjeWJlcl9pbml0X3JpdHVhbChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7CgkvKiBzb21lIGJsYWNrIG1hZ2ljLCB0YWtlbiBmcm9tIFNESyBzYW1wbGVzICovCgkvKiByZW1vdmUgdGhpcyBhbmQgbm90aGluZyB3aWxsIHdvcmsgKi8KCWludCBwb3J0RGF0OwoJaW50IHJldCA9IDA7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCS8qCgkgKiAgICAgIEtlZXAgaW50ZXJydXB0cyBvZmYgZm9yIHRoZSBjb25maWd1cmUgLSB3ZSBkb24ndCB3YW50IHRvCgkgKiAgICAgIGNsYXNoIHdpdGggYW5vdGhlciBjeWJlcnBybyBjb25maWcgZXZlbnQKCSAqLwoKCXNwaW5fbG9ja19pcnFzYXZlKCZjYXJkLT5sb2NrLCBmbGFncyk7Cglwb3J0RGF0ID0gY3liZXJfaW5pZHgoQ1lCRVJfUE9SVF9BVURJTywgQ1lCRVJfSURYX0FVRElPX0VOQUJMRSk7CgkvKiBlbmFibGUsIGlmIGl0IHdhcyBkaXNhYmxlZCAqLwoJaWYgKChwb3J0RGF0ICYgQ1lCRVJfQk1TS19BVUVOWikgIT0gQ1lCRVJfQk1TS19BVUVOWl9FTkFCTEUpIHsKCQlwcmludGsoS0VSTl9JTkZPICJjeWJlcnBybzUwNTA6IGVuYWJsaW5nIGF1ZGlvIGNvbnRyb2xsZXJcbiIpOwoJCWN5YmVyX291dGlkeChDWUJFUl9QT1JUX0FVRElPLCBDWUJFUl9JRFhfQVVESU9fRU5BQkxFLCAKCQkJICAgICBwb3J0RGF0IHwgQ1lCRVJfQk1TS19BVUVOWl9FTkFCTEUpOwoJCS8qIGNoZWNrIGFnYWluIGlmIGhhcmR3YXJlIGlzIGVuYWJsZWQgbm93ICovCgkJcG9ydERhdCA9IGN5YmVyX2luaWR4KENZQkVSX1BPUlRfQVVESU8sIENZQkVSX0lEWF9BVURJT19FTkFCTEUpOwoJfQoJaWYgKChwb3J0RGF0ICYgQ1lCRVJfQk1TS19BVUVOWikgIT0gQ1lCRVJfQk1TS19BVUVOWl9FTkFCTEUpIHsKCQlwcmludGsoS0VSTl9FUlIgImN5YmVycHJvNTA1MDogaW5pdEF1ZGlvQWNjZXNzOiBubyBzdWNjZXNzXG4iKTsKCQlyZXQgPSAtMTsKCX0gZWxzZSB7CgkJY3liZXJfb3V0aWR4KENZQkVSX1BPUlRfQVVESU8sIENZQkVSX0lEWF9JUlFfRU5BQkxFLCAKCQkJICAgICBDWUJFUl9CTVNLX0FVRElPX0lOVF9FTkFCTEUpOwoJCWN5YmVyX291dGlkeChDWUJFUl9QT1JUX0FVRElPLCAweGJmLCAweDAxKTsKCQljeWJlcl9vdXRpZHgoQ1lCRVJfUE9SVF9BVURJTywgMHhiYSwgMHgyMCk7CgkJY3liZXJfb3V0aWR4KENZQkVSX1BPUlRfQVVESU8sIDB4YmIsIDB4MDgpOwoJCWN5YmVyX291dGlkeChDWUJFUl9QT1JUX0FVRElPLCAweGJmLCAweDAyKTsKCQljeWJlcl9vdXRpZHgoQ1lCRVJfUE9SVF9BVURJTywgMHhiMywgMHgwNik7CgkJY3liZXJfb3V0aWR4KENZQkVSX1BPUlRfQVVESU8sIDB4YmYsIDB4MDApOwoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwoJcmV0dXJuIHJldDsKfQoKLyogIGNhbGxlZCB3aXRoIHNwaW4gbG9jayBoZWxkICovCgpzdGF0aWMgaW50CnRyaWRlbnRfbG9hZF9jaGFubmVsX3JlZ2lzdGVycyhzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCB1MzIgKiBkYXRhLCAKCQkJICAgICAgIHVuc2lnbmVkIGludCBjaGFubmVsKQp7CglpbnQgaTsKCglpZiAoY2hhbm5lbCA+IDYzKQoJCXJldHVybiAwOwoKCS8qIHNlbGVjdCBoYXJkd2FyZSBjaGFubmVsIHRvIHdyaXRlICovCglvdXRiKGNoYW5uZWwsIFRSSURfUkVHKGNhcmQsIFQ0RF9MRk9fR0NfQ0lSKSk7CgoJLyogT3V0cHV0IHRoZSBjaGFubmVsIHJlZ2lzdGVycywgYnV0IGRvbid0IHdyaXRlIHJlZ2lzdGVyCgkgICB0aHJlZSB0byBhbiBBTEkgY2hpcC4gKi8KCWZvciAoaSA9IDA7IGkgPCBDSEFOTkVMX1JFR1M7IGkrKykgewoJCWlmIChpID09IDMgJiYgY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfQUxJXzU0NTEpCgkJCWNvbnRpbnVlOwoJCW91dGwoZGF0YVtpXSwgVFJJRF9SRUcoY2FyZCwgQ0hBTk5FTF9TVEFSVCArIDQgKiBpKSk7Cgl9CglpZiAoY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfQUxJXzU0NTEgfHwgCgkgICAgY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfSU5URVJHXzUwNTApIHsKCQlvdXRsKEFMSV9FTU9EX1N0aWxsLCBUUklEX1JFRyhjYXJkLCBBTElfRUJVRjEpKTsKCQlvdXRsKEFMSV9FTU9EX1N0aWxsLCBUUklEX1JFRyhjYXJkLCBBTElfRUJVRjIpKTsKCX0KCXJldHVybiAxOwp9CgovKiBjYWxsZWQgd2l0aCBzcGluIGxvY2sgaGVsZCAqLwpzdGF0aWMgaW50CnRyaWRlbnRfd3JpdGVfdm9pY2VfcmVncyhzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCXVuc2lnbmVkIGludCBkYXRhW0NIQU5ORUxfUkVHUyArIDFdOwoJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqY2hhbm5lbDsKCgljaGFubmVsID0gc3RhdGUtPmRtYWJ1Zi5jaGFubmVsOwoKCWRhdGFbMV0gPSBjaGFubmVsLT5sYmE7CglkYXRhWzRdID0gY2hhbm5lbC0+Y29udHJvbDsKCglzd2l0Y2ggKHN0YXRlLT5jYXJkLT5wY2lfaWQpIHsKCWNhc2UgUENJX0RFVklDRV9JRF9BTElfNTQ1MToKCQlkYXRhWzBdID0gMDsJLyogQ3VycmVudCBTYW1wbGUgT2Zmc2V0ICovCgkJZGF0YVsyXSA9IChjaGFubmVsLT5lc28gPDwgMTYpIHwgKGNoYW5uZWwtPmRlbHRhICYgMHhmZmZmKTsKCQlkYXRhWzNdID0gMDsKCQlicmVhazsKCWNhc2UgUENJX0RFVklDRV9JRF9TSV83MDE4OgoJY2FzZSBQQ0lfREVWSUNFX0lEX0lOVEVSR181MDUwOgoJCWRhdGFbMF0gPSAwOwkvKiBDdXJyZW50IFNhbXBsZSBPZmZzZXQgKi8KCQlkYXRhWzJdID0gKGNoYW5uZWwtPmVzbyA8PCAxNikgfCAoY2hhbm5lbC0+ZGVsdGEgJiAweGZmZmYpOwoJCWRhdGFbM10gPSAoY2hhbm5lbC0+YXR0cmlidXRlIDw8IDE2KSB8IChjaGFubmVsLT5mbV92b2wgJiAweGZmZmYpOwoJCWJyZWFrOwoJY2FzZSBQQ0lfREVWSUNFX0lEX1RSSURFTlRfNERXQVZFX0RYOgoJCWRhdGFbMF0gPSAwOwkvKiBDdXJyZW50IFNhbXBsZSBPZmZzZXQgKi8KCQlkYXRhWzJdID0gKGNoYW5uZWwtPmVzbyA8PCAxNikgfCAoY2hhbm5lbC0+ZGVsdGEgJiAweGZmZmYpOwoJCWRhdGFbM10gPSBjaGFubmVsLT5mbV92b2wgJiAweGZmZmY7CgkJYnJlYWs7CgljYXNlIFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfTlg6CgkJZGF0YVswXSA9IChjaGFubmVsLT5kZWx0YSA8PCAyNCk7CgkJZGF0YVsyXSA9ICgoY2hhbm5lbC0+ZGVsdGEgPDwgMTYpICYgMHhmZjAwMDAwMCkgfCAKCQkJKGNoYW5uZWwtPmVzbyAmIDB4MDBmZmZmZmYpOwoJCWRhdGFbM10gPSBjaGFubmVsLT5mbV92b2wgJiAweGZmZmY7CgkJYnJlYWs7CglkZWZhdWx0OgoJCXJldHVybiAwOwoJfQoKCXJldHVybiB0cmlkZW50X2xvYWRfY2hhbm5lbF9yZWdpc3RlcnMoc3RhdGUtPmNhcmQsIGRhdGEsIGNoYW5uZWwtPm51bSk7Cn0KCnN0YXRpYyBpbnQKY29tcHV0ZV9yYXRlX3BsYXkodTMyIHJhdGUpCnsKCWludCBkZWx0YTsKCS8qIFdlIHNwZWNpYWwgY2FzZSA0NDEwMCBhbmQgODAwMCBzaW5jZSByb3VuZGluZyB3aXRoIHRoZSBlcXVhdGlvbgoJICAgZG9lcyBub3QgZ2l2ZSB1cyBhbiBhY2N1cmF0ZSBlbm91Z2ggdmFsdWUuIEZvciAxMTAyNSBhbmQgMjIwNTAKCSAgIHRoZSBlcXVhdGlvbiBnaXZlcyB1cyB0aGUgYmVzdCBhbnN3ZXIuIEFsbCBvdGhlciBmcmVxdWVuY2llcyB3aWxsCgkgICBhbHNvIHVzZSB0aGUgZXF1YXRpb24uIEpEVyAqLwoJaWYgKHJhdGUgPT0gNDQxMDApCgkJZGVsdGEgPSAweGViMzsKCWVsc2UgaWYgKHJhdGUgPT0gODAwMCkKCQlkZWx0YSA9IDB4MmFiOwoJZWxzZSBpZiAocmF0ZSA9PSA0ODAwMCkKCQlkZWx0YSA9IDB4MTAwMDsKCWVsc2UKCQlkZWx0YSA9ICgoKHJhdGUgPDwgMTIpICsgcmF0ZSkgLyA0ODAwMCkgJiAweDAwMDBmZmZmOwoJcmV0dXJuIGRlbHRhOwp9CgpzdGF0aWMgaW50CmNvbXB1dGVfcmF0ZV9yZWModTMyIHJhdGUpCnsKCWludCBkZWx0YTsKCglpZiAocmF0ZSA9PSA0NDEwMCkKCQlkZWx0YSA9IDB4MTE2YTsKCWVsc2UgaWYgKHJhdGUgPT0gODAwMCkKCQlkZWx0YSA9IDB4NjAwMDsKCWVsc2UgaWYgKHJhdGUgPT0gNDgwMDApCgkJZGVsdGEgPSAweDEwMDA7CgllbHNlCgkJZGVsdGEgPSAoKDQ4MDAwIDw8IDEyKSAvIHJhdGUpICYgMHgwMDAwZmZmZjsKCglyZXR1cm4gZGVsdGE7Cn0KCi8qIHNldCBwbGF5YmFjayBzYW1wbGUgcmF0ZSAqLwpzdGF0aWMgdW5zaWduZWQgaW50CnRyaWRlbnRfc2V0X2RhY19yYXRlKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSwgdW5zaWduZWQgaW50IHJhdGUpCnsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoKCWlmIChyYXRlID4gNDgwMDApCgkJcmF0ZSA9IDQ4MDAwOwoJaWYgKHJhdGUgPCA0MDAwKQoJCXJhdGUgPSA0MDAwOwoKCWRtYWJ1Zi0+cmF0ZSA9IHJhdGU7CglkbWFidWYtPmNoYW5uZWwtPmRlbHRhID0gY29tcHV0ZV9yYXRlX3BsYXkocmF0ZSk7CgoJdHJpZGVudF93cml0ZV92b2ljZV9yZWdzKHN0YXRlKTsKCglwcl9kZWJ1ZygidHJpZGVudDogY2FsbGVkIHRyaWRlbnRfc2V0X2RhY19yYXRlIDogcmF0ZSA9ICVkXG4iLCByYXRlKTsKCglyZXR1cm4gcmF0ZTsKfQoKLyogc2V0IHJlY29yZGluZyBzYW1wbGUgcmF0ZSAqLwpzdGF0aWMgdW5zaWduZWQgaW50CnRyaWRlbnRfc2V0X2FkY19yYXRlKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSwgdW5zaWduZWQgaW50IHJhdGUpCnsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoKCWlmIChyYXRlID4gNDgwMDApCgkJcmF0ZSA9IDQ4MDAwOwoJaWYgKHJhdGUgPCA0MDAwKQoJCXJhdGUgPSA0MDAwOwoKCWRtYWJ1Zi0+cmF0ZSA9IHJhdGU7CglkbWFidWYtPmNoYW5uZWwtPmRlbHRhID0gY29tcHV0ZV9yYXRlX3JlYyhyYXRlKTsKCgl0cmlkZW50X3dyaXRlX3ZvaWNlX3JlZ3Moc3RhdGUpOwoKCXByX2RlYnVnKCJ0cmlkZW50OiBjYWxsZWQgdHJpZGVudF9zZXRfYWRjX3JhdGUgOiByYXRlID0gJWRcbiIsIHJhdGUpOwoKCXJldHVybiByYXRlOwp9CgovKiBwcmVwYXJlIGNoYW5uZWwgYXR0cmlidXRlcyBmb3IgcGxheWJhY2sgKi8Kc3RhdGljIHZvaWQKdHJpZGVudF9wbGF5X3NldHVwKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSkKewoJc3RydWN0IGRtYWJ1ZiAqZG1hYnVmID0gJnN0YXRlLT5kbWFidWY7CglzdHJ1Y3QgdHJpZGVudF9jaGFubmVsICpjaGFubmVsID0gZG1hYnVmLT5jaGFubmVsOwoKCWNoYW5uZWwtPmxiYSA9IGRtYWJ1Zi0+ZG1hX2hhbmRsZTsKCWNoYW5uZWwtPmRlbHRhID0gY29tcHV0ZV9yYXRlX3BsYXkoZG1hYnVmLT5yYXRlKTsKCgljaGFubmVsLT5lc28gPSBkbWFidWYtPmRtYXNpemUgPj4gc2FtcGxlX3NoaWZ0W2RtYWJ1Zi0+Zm10XTsKCWNoYW5uZWwtPmVzbyAtPSAxOwoKCWlmIChzdGF0ZS0+Y2FyZC0+cGNpX2lkICE9IFBDSV9ERVZJQ0VfSURfU0lfNzAxOCkgewoJCWNoYW5uZWwtPmF0dHJpYnV0ZSA9IDA7CgkJaWYgKHN0YXRlLT5jYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSkgewoJCQlpZiAoKGNoYW5uZWwtPm51bSA9PSBBTElfU1BESUZfSU5fQ0hBTk5FTCkgfHwgCgkJCSAgICAoY2hhbm5lbC0+bnVtID09IEFMSV9QQ01fSU5fQ0hBTk5FTCkpCgkJCQlhbGlfZGlzYWJsZV9zcGVjaWFsX2NoYW5uZWwoc3RhdGUtPmNhcmQsIGNoYW5uZWwtPm51bSk7CgkJCWVsc2UgaWYgKChpbmwoVFJJRF9SRUcoc3RhdGUtPmNhcmQsIEFMSV9HTE9CQUxfQ09OVFJPTCkpIAoJCQkJICAmIEFMSV9TUERJRl9PVVRfQ0hfRU5BQkxFKQoJCQkJICYmIChjaGFubmVsLT5udW0gPT0gQUxJX1NQRElGX09VVF9DSEFOTkVMKSkgewoJCQkJYWxpX3NldF9zcGRpZl9vdXRfcmF0ZShzdGF0ZS0+Y2FyZCwgCgkJCQkJCSAgICAgICBzdGF0ZS0+ZG1hYnVmLnJhdGUpOwoJCQkJc3RhdGUtPmRtYWJ1Zi5jaGFubmVsLT5kZWx0YSA9IDB4MTAwMDsKCQkJfQoJCX0KCX0KCgljaGFubmVsLT5mbV92b2wgPSAweDA7CgoJY2hhbm5lbC0+Y29udHJvbCA9IENIQU5ORUxfTE9PUDsKCWlmIChkbWFidWYtPmZtdCAmIFRSSURFTlRfRk1UXzE2QklUKSB7CgkJLyogMTYtYml0cyAqLwoJCWNoYW5uZWwtPmNvbnRyb2wgfD0gQ0hBTk5FTF8xNkJJVFM7CgkJLyogc2lnbmVkICovCgkJY2hhbm5lbC0+Y29udHJvbCB8PSBDSEFOTkVMX1NJR05FRDsKCX0KCWlmIChkbWFidWYtPmZtdCAmIFRSSURFTlRfRk1UX1NURVJFTykKCQkvKiBzdGVyZW8gKi8KCQljaGFubmVsLT5jb250cm9sIHw9IENIQU5ORUxfU1RFUkVPOwoKCXByX2RlYnVnKCJ0cmlkZW50OiB0cmlkZW50X3BsYXlfc2V0dXAsIExCQSA9IDB4JTA4eCwgRGVsdGEgPSAweCUwOHgsICIKCQkgIkVTTyA9IDB4JTA4eCwgQ29udHJvbCA9IDB4JTA4eFxuIiwgY2hhbm5lbC0+bGJhLAoJCSBjaGFubmVsLT5kZWx0YSwgY2hhbm5lbC0+ZXNvLCBjaGFubmVsLT5jb250cm9sKTsKCgl0cmlkZW50X3dyaXRlX3ZvaWNlX3JlZ3Moc3RhdGUpOwp9CgovKiBwcmVwYXJlIGNoYW5uZWwgYXR0cmlidXRlcyBmb3IgcmVjb3JkaW5nICovCnN0YXRpYyB2b2lkCnRyaWRlbnRfcmVjX3NldHVwKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSkKewoJdTE2IHc7Cgl1OCBidmFsOwoKCXN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQgPSBzdGF0ZS0+Y2FyZDsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqY2hhbm5lbCA9IGRtYWJ1Zi0+Y2hhbm5lbDsKCXVuc2lnbmVkIGludCByYXRlOwoKCS8qIEVuYWJsZSBBQy05NyBBREMgKGNhcHR1cmUpICovCglzd2l0Y2ggKGNhcmQtPnBjaV9pZCkgewoJY2FzZSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxOgoJCWFsaV9lbmFibGVfc3BlY2lhbF9jaGFubmVsKHN0YXRlKTsKCQlicmVhazsKCWNhc2UgUENJX0RFVklDRV9JRF9TSV83MDE4OgoJCS8qIGZvciA3MDE4LCB0aGUgYWM5NyBpcyBhbHdheXMgaW4gcGxheWJhY2svcmVjb3JkIChkdXBsZXgpIG1vZGUgKi8KCQlicmVhazsKCWNhc2UgUENJX0RFVklDRV9JRF9UUklERU5UXzREV0FWRV9EWDoKCQl3ID0gaW5iKFRSSURfUkVHKGNhcmQsIERYX0FDUjJfQUM5N19DT01fU1RBVCkpOwoJCW91dGIodyB8IDB4NDgsIFRSSURfUkVHKGNhcmQsIERYX0FDUjJfQUM5N19DT01fU1RBVCkpOwoJCS8qIGVuYWJsZSBhbmQgc2V0IHJlY29yZCBjaGFubmVsICovCgkJb3V0YigweDgwIHwgY2hhbm5lbC0+bnVtLCBUUklEX1JFRyhjYXJkLCBUNERfUkVDX0NIKSk7CgkJYnJlYWs7CgljYXNlIFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfTlg6CgkJdyA9IGludyhUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCkpOwoJCW91dHcodyB8IDB4MTAwMCwgVFJJRF9SRUcoY2FyZCwgVDREX01JU0NJTlQpKTsKCQkvKiBlbmFibGUgYW5kIHNldCByZWNvcmQgY2hhbm5lbCAqLwoJCW91dGIoMHg4MCB8IGNoYW5uZWwtPm51bSwgVFJJRF9SRUcoY2FyZCwgVDREX1JFQ19DSCkpOwoJCWJyZWFrOwoJY2FzZSBQQ0lfREVWSUNFX0lEX0lOVEVSR181MDUwOgoJCS8qIGRvbid0IGtub3cgeWV0LCB1c2luZyBzcGVjaWFsIGNoYW5uZWwgMjIgaW4gR0MxKDB4ZDQpPyAqLwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlyZXR1cm47Cgl9CgoJY2hhbm5lbC0+bGJhID0gZG1hYnVmLT5kbWFfaGFuZGxlOwoJY2hhbm5lbC0+ZGVsdGEgPSBjb21wdXRlX3JhdGVfcmVjKGRtYWJ1Zi0+cmF0ZSk7CglpZiAoKGNhcmQtPnBjaV9pZCA9PSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKSAmJiAKCSAgICAoY2hhbm5lbC0+bnVtID09IEFMSV9TUERJRl9JTl9DSEFOTkVMKSkgewoJCXJhdGUgPSBhbGlfZ2V0X3NwZGlmX2luX3JhdGUoY2FyZCk7CgkJaWYgKHJhdGUgPT0gMCkgewoJCQlwcmludGsoS0VSTl9XQVJOSU5HICJ0cmlkZW50OiBBTGkgNTQ1MSAiCgkJCSAgICAgICAiUy9QRElGIGlucHV0IHNldHVwIGVycm9yIVxuIik7CgkJCXJhdGUgPSA0ODAwMDsKCQl9CgkJYnZhbCA9IGluYihUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1RSTCkpOwoJCWlmIChidmFsICYgMHgxMCkgewoJCQlvdXRiKGJ2YWwsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMKSk7CgkJCXByaW50ayhLRVJOX1dBUk5JTkcgInRyaWRlbnQ6IGNsZWFyZWQgQUxpICIKCQkJICAgICAgICI1NDUxIFMvUERJRiBwYXJpdHkgZXJyb3IgZmxhZy5cbiIpOwoJCX0KCgkJaWYgKHJhdGUgIT0gNDgwMDApCgkJCWNoYW5uZWwtPmRlbHRhID0gKChyYXRlIDw8IDEyKSAvIGRtYWJ1Zi0+cmF0ZSkgJiAweDAwMDBmZmZmOwoJfQoKCWNoYW5uZWwtPmVzbyA9IGRtYWJ1Zi0+ZG1hc2l6ZSA+PiBzYW1wbGVfc2hpZnRbZG1hYnVmLT5mbXRdOwoJY2hhbm5lbC0+ZXNvIC09IDE7CgoJaWYgKHN0YXRlLT5jYXJkLT5wY2lfaWQgIT0gUENJX0RFVklDRV9JRF9TSV83MDE4KSB7CgkJY2hhbm5lbC0+YXR0cmlidXRlID0gMDsKCX0KCgljaGFubmVsLT5mbV92b2wgPSAweDA7CgoJY2hhbm5lbC0+Y29udHJvbCA9IENIQU5ORUxfTE9PUDsKCWlmIChkbWFidWYtPmZtdCAmIFRSSURFTlRfRk1UXzE2QklUKSB7CgkJLyogMTYtYml0cyAqLwoJCWNoYW5uZWwtPmNvbnRyb2wgfD0gQ0hBTk5FTF8xNkJJVFM7CgkJLyogc2lnbmVkICovCgkJY2hhbm5lbC0+Y29udHJvbCB8PSBDSEFOTkVMX1NJR05FRDsKCX0KCWlmIChkbWFidWYtPmZtdCAmIFRSSURFTlRfRk1UX1NURVJFTykKCQkvKiBzdGVyZW8gKi8KCQljaGFubmVsLT5jb250cm9sIHw9IENIQU5ORUxfU1RFUkVPOwoKCXByX2RlYnVnKCJ0cmlkZW50OiB0cmlkZW50X3JlY19zZXR1cCwgTEJBID0gMHglMDh4LCBEZWxhdCA9IDB4JTA4eCwgIgoJCSAiRVNPID0gMHglMDh4LCBDb250cm9sID0gMHglMDh4XG4iLCBjaGFubmVsLT5sYmEsCgkJIGNoYW5uZWwtPmRlbHRhLCBjaGFubmVsLT5lc28sIGNoYW5uZWwtPmNvbnRyb2wpOwoKCXRyaWRlbnRfd3JpdGVfdm9pY2VfcmVncyhzdGF0ZSk7Cn0KCi8qIGdldCBjdXJyZW50IHBsYXliYWNrL3JlY29yZGluZyBkbWEgYnVmZmVyIHBvaW50ZXIgKGJ5dGUgb2Zmc2V0IGZyb20gTEJBKSwKICAgY2FsbGVkIHdpdGggc3BpbmxvY2sgaGVsZCEgKi8Kc3RhdGljIGlubGluZSB1bnNpZ25lZAp0cmlkZW50X2dldF9kbWFfYWRkcihzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJdTMyIGNzbzsKCglpZiAoIWRtYWJ1Zi0+ZW5hYmxlKQoJCXJldHVybiAwOwoKCW91dGIoZG1hYnVmLT5jaGFubmVsLT5udW0sIFRSSURfUkVHKHN0YXRlLT5jYXJkLCBUNERfTEZPX0dDX0NJUikpOwoKCXN3aXRjaCAoc3RhdGUtPmNhcmQtPnBjaV9pZCkgewoJY2FzZSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxOgoJY2FzZSBQQ0lfREVWSUNFX0lEX1NJXzcwMTg6CgljYXNlIFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfRFg6CgljYXNlIFBDSV9ERVZJQ0VfSURfSU5URVJHXzUwNTA6CgkJLyogMTYgYml0cyBFU08sIENTTyBmb3IgNzAxOCBhbmQgRFggKi8KCQljc28gPSBpbncoVFJJRF9SRUcoc3RhdGUtPmNhcmQsIENIX0RYX0NTT19BTFBIQV9GTVMgKyAyKSk7CgkJYnJlYWs7CgljYXNlIFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfTlg6CgkJLyogMjQgYml0cyBFU08sIENTTyBmb3IgTlggKi8KCQljc28gPSBpbmwoVFJJRF9SRUcoc3RhdGUtPmNhcmQsIENIX05YX0RFTFRBX0NTTykpICYgMHgwMGZmZmZmZjsKCQlicmVhazsKCWRlZmF1bHQ6CgkJcmV0dXJuIDA7Cgl9CgoJcHJfZGVidWcoInRyaWRlbnQ6IHRyaWRlbnRfZ2V0X2RtYV9hZGRyOiBjaGlwIHJlcG9ydGVkIGNoYW5uZWw6ICVkLCAiCgkJICJjc28gPSAweCUwNHhcbiIsIGRtYWJ1Zi0+Y2hhbm5lbC0+bnVtLCBjc28pOwoKCS8qIEVTTyBhbmQgQ1NPIGFyZSBpbiB1bml0cyBvZiBTYW1wbGVzLCBjb252ZXJ0IHRvIGJ5dGUgb2Zmc2V0ICovCgljc28gPDw9IHNhbXBsZV9zaGlmdFtkbWFidWYtPmZtdF07CgoJcmV0dXJuIChjc28gJSBkbWFidWYtPmRtYXNpemUpOwp9CgovKiBTdG9wIHJlY29yZGluZyAobG9jayBoZWxkKSAqLwpzdGF0aWMgaW5saW5lIHZvaWQKX19zdG9wX2FkYyhzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJdW5zaWduZWQgaW50IGNoYW5fbnVtID0gZG1hYnVmLT5jaGFubmVsLT5udW07CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gc3RhdGUtPmNhcmQ7CgoJZG1hYnVmLT5lbmFibGUgJj0gfkFEQ19SVU5OSU5HOwoJdHJpZGVudF9zdG9wX3ZvaWNlKGNhcmQsIGNoYW5fbnVtKTsKCXRyaWRlbnRfZGlzYWJsZV92b2ljZV9pcnEoY2FyZCwgY2hhbl9udW0pOwp9CgpzdGF0aWMgdm9pZApzdG9wX2FkYyhzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCXN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQgPSBzdGF0ZS0+Y2FyZDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCV9fc3RvcF9hZGMoc3RhdGUpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZApzdGFydF9hZGMoc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlKQp7CglzdHJ1Y3QgZG1hYnVmICpkbWFidWYgPSAmc3RhdGUtPmRtYWJ1ZjsKCXVuc2lnbmVkIGludCBjaGFuX251bSA9IGRtYWJ1Zi0+Y2hhbm5lbC0+bnVtOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCA9IHN0YXRlLT5jYXJkOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglzcGluX2xvY2tfaXJxc2F2ZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwoJaWYgKChkbWFidWYtPm1hcHBlZCB8fCAKCSAgICAgZG1hYnVmLT5jb3VudCA8IChzaWduZWQpIGRtYWJ1Zi0+ZG1hc2l6ZSkgJiYgCgkgICAgZG1hYnVmLT5yZWFkeSkgewoJCWRtYWJ1Zi0+ZW5hYmxlIHw9IEFEQ19SVU5OSU5HOwoJCXRyaWRlbnRfZW5hYmxlX3ZvaWNlX2lycShjYXJkLCBjaGFuX251bSk7CgkJdHJpZGVudF9zdGFydF92b2ljZShjYXJkLCBjaGFuX251bSk7Cgl9CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjYXJkLT5sb2NrLCBmbGFncyk7Cn0KCi8qIHN0b3AgcGxheWJhY2sgKGxvY2sgaGVsZCkgKi8Kc3RhdGljIGlubGluZSB2b2lkCl9fc3RvcF9kYWMoc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlKQp7CglzdHJ1Y3QgZG1hYnVmICpkbWFidWYgPSAmc3RhdGUtPmRtYWJ1ZjsKCXVuc2lnbmVkIGludCBjaGFuX251bSA9IGRtYWJ1Zi0+Y2hhbm5lbC0+bnVtOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCA9IHN0YXRlLT5jYXJkOwoKCWRtYWJ1Zi0+ZW5hYmxlICY9IH5EQUNfUlVOTklORzsKCXRyaWRlbnRfc3RvcF92b2ljZShjYXJkLCBjaGFuX251bSk7CglpZiAoc3RhdGUtPmNoYW5zX251bSA9PSA2KSB7CgkJdHJpZGVudF9zdG9wX3ZvaWNlKGNhcmQsIHN0YXRlLT5vdGhlcl9zdGF0ZXNbMF0tPgoJCQkJICAgZG1hYnVmLmNoYW5uZWwtPm51bSk7CgkJdHJpZGVudF9zdG9wX3ZvaWNlKGNhcmQsIHN0YXRlLT5vdGhlcl9zdGF0ZXNbMV0tPgoJCQkJICAgZG1hYnVmLmNoYW5uZWwtPm51bSk7CgkJdHJpZGVudF9zdG9wX3ZvaWNlKGNhcmQsIHN0YXRlLT5vdGhlcl9zdGF0ZXNbMl0tPgoJCQkJICAgZG1hYnVmLmNoYW5uZWwtPm51bSk7CgkJdHJpZGVudF9zdG9wX3ZvaWNlKGNhcmQsIHN0YXRlLT5vdGhlcl9zdGF0ZXNbM10tPgoJCQkJICAgZG1hYnVmLmNoYW5uZWwtPm51bSk7Cgl9Cgl0cmlkZW50X2Rpc2FibGVfdm9pY2VfaXJxKGNhcmQsIGNoYW5fbnVtKTsKfQoKc3RhdGljIHZvaWQKc3RvcF9kYWMoc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlKQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gc3RhdGUtPmNhcmQ7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZjYXJkLT5sb2NrLCBmbGFncyk7CglfX3N0b3BfZGFjKHN0YXRlKTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKfQoKc3RhdGljIHZvaWQKc3RhcnRfZGFjKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSkKewoJc3RydWN0IGRtYWJ1ZiAqZG1hYnVmID0gJnN0YXRlLT5kbWFidWY7Cgl1bnNpZ25lZCBpbnQgY2hhbl9udW0gPSBkbWFidWYtPmNoYW5uZWwtPm51bTsKCXN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQgPSBzdGF0ZS0+Y2FyZDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCWlmICgoZG1hYnVmLT5tYXBwZWQgfHwgZG1hYnVmLT5jb3VudCA+IDApICYmIGRtYWJ1Zi0+cmVhZHkpIHsKCQlkbWFidWYtPmVuYWJsZSB8PSBEQUNfUlVOTklORzsKCQl0cmlkZW50X2VuYWJsZV92b2ljZV9pcnEoY2FyZCwgY2hhbl9udW0pOwoJCXRyaWRlbnRfc3RhcnRfdm9pY2UoY2FyZCwgY2hhbl9udW0pOwoJCWlmIChzdGF0ZS0+Y2hhbnNfbnVtID09IDYpIHsKCQkJdHJpZGVudF9zdGFydF92b2ljZShjYXJkLCBzdGF0ZS0+b3RoZXJfc3RhdGVzWzBdLT4KCQkJCQkgICAgZG1hYnVmLmNoYW5uZWwtPm51bSk7CgkJCXRyaWRlbnRfc3RhcnRfdm9pY2UoY2FyZCwgc3RhdGUtPm90aGVyX3N0YXRlc1sxXS0+CgkJCQkJICAgIGRtYWJ1Zi5jaGFubmVsLT5udW0pOwoJCQl0cmlkZW50X3N0YXJ0X3ZvaWNlKGNhcmQsIHN0YXRlLT5vdGhlcl9zdGF0ZXNbMl0tPgoJCQkJCSAgICBkbWFidWYuY2hhbm5lbC0+bnVtKTsKCQkJdHJpZGVudF9zdGFydF92b2ljZShjYXJkLCBzdGF0ZS0+b3RoZXJfc3RhdGVzWzNdLT4KCQkJCQkgICAgZG1hYnVmLmNoYW5uZWwtPm51bSk7CgkJfQoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwp9CgojZGVmaW5lIERNQUJVRl9ERUZBVUxUT1JERVIgKDE1LVBBR0VfU0hJRlQpCiNkZWZpbmUgRE1BQlVGX01JTk9SREVSIDEKCi8qIGFsbG9jIGEgRE1BIGJ1ZmZlciBvZiB3aXRoIGEgYnVmZmVyIG9mIHRoaXMgb3JkZXIgKi8Kc3RhdGljIGludAphbGxvY19kbWFidWYoc3RydWN0IGRtYWJ1ZiAqZG1hYnVmLCBzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldiwgaW50IG9yZGVyKQp7Cgl2b2lkICpyYXdidWYgPSBOVUxMOwoJc3RydWN0IHBhZ2UgKnBhZ2UsICpwZW5kOwoKCWlmICghKHJhd2J1ZiA9IHBjaV9hbGxvY19jb25zaXN0ZW50KHBjaV9kZXYsIFBBR0VfU0laRSA8PCBvcmRlciwgCgkJCQkJICAgICZkbWFidWYtPmRtYV9oYW5kbGUpKSkKCQlyZXR1cm4gLUVOT01FTTsKCglwcl9kZWJ1ZygidHJpZGVudDogYWxsb2NhdGVkICVsZCAob3JkZXIgPSAlZCkgYnl0ZXMgYXQgJXBcbiIsCgkJIFBBR0VfU0laRSA8PCBvcmRlciwgb3JkZXIsIHJhd2J1Zik7CgoJZG1hYnVmLT5yZWFkeSA9IGRtYWJ1Zi0+bWFwcGVkID0gMDsKCWRtYWJ1Zi0+cmF3YnVmID0gcmF3YnVmOwoJZG1hYnVmLT5idWZvcmRlciA9IG9yZGVyOwoKCS8qIG5vdyBtYXJrIHRoZSBwYWdlcyBhcyByZXNlcnZlZDsgb3RoZXJ3aXNlICovIAoJLyogcmVtYXBfcGZuX3JhbmdlIGRvZXNuJ3QgZG8gd2hhdCB3ZSB3YW50ICovCglwZW5kID0gdmlydF90b19wYWdlKHJhd2J1ZiArIChQQUdFX1NJWkUgPDwgb3JkZXIpIC0gMSk7Cglmb3IgKHBhZ2UgPSB2aXJ0X3RvX3BhZ2UocmF3YnVmKTsgcGFnZSA8PSBwZW5kOyBwYWdlKyspCgkJU2V0UGFnZVJlc2VydmVkKHBhZ2UpOwoKCXJldHVybiAwOwp9CgovKiBhbGxvY2F0ZSB0aGUgbWFpbiBETUEgYnVmZmVyLCBwbGF5YmFjayBhbmQgcmVjb3JkaW5nIGJ1ZmZlciBzaG91bGQgYmUgKi8KLyogYWxsb2NhdGVkIHNlcGFyYXRlbHkgKi8Kc3RhdGljIGludAphbGxvY19tYWluX2RtYWJ1ZihzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJaW50IG9yZGVyOwoJaW50IHJldCA9IC1FTk9NRU07CgoJLyogYWxsb2MgYXMgYmlnIGEgY2h1bmsgYXMgd2UgY2FuLCBGSVhNRTogaXMgdGhpcyBuZWNlc3NhcnkgPz8gKi8KCWZvciAob3JkZXIgPSBETUFCVUZfREVGQVVMVE9SREVSOyBvcmRlciA+PSBETUFCVUZfTUlOT1JERVI7IG9yZGVyLS0pIHsKCQlpZiAoIShyZXQgPSBhbGxvY19kbWFidWYoZG1hYnVmLCBzdGF0ZS0+Y2FyZC0+cGNpX2Rldiwgb3JkZXIpKSkKCQkJcmV0dXJuIDA7CgkJLyogZWxzZSB0cnkgYWdhaW4gKi8KCX0KCXJldHVybiByZXQ7Cn0KCi8qIGRlYWxsb2NhdGUgYSBETUEgYnVmZmVyICovCnN0YXRpYyB2b2lkCmRlYWxsb2NfZG1hYnVmKHN0cnVjdCBkbWFidWYgKmRtYWJ1Ziwgc3RydWN0IHBjaV9kZXYgKnBjaV9kZXYpCnsKCXN0cnVjdCBwYWdlICpwYWdlLCAqcGVuZDsKCglpZiAoZG1hYnVmLT5yYXdidWYpIHsKCQkvKiB1bmRvIG1hcmtpbmcgdGhlIHBhZ2VzIGFzIHJlc2VydmVkICovCgkJcGVuZCA9IHZpcnRfdG9fcGFnZShkbWFidWYtPnJhd2J1ZiArIChQQUdFX1NJWkUgPDwgZG1hYnVmLT5idWZvcmRlcikgLSAxKTsKCQlmb3IgKHBhZ2UgPSB2aXJ0X3RvX3BhZ2UoZG1hYnVmLT5yYXdidWYpOyBwYWdlIDw9IHBlbmQ7IHBhZ2UrKykKCQkJQ2xlYXJQYWdlUmVzZXJ2ZWQocGFnZSk7CgkJcGNpX2ZyZWVfY29uc2lzdGVudChwY2lfZGV2LCBQQUdFX1NJWkUgPDwgZG1hYnVmLT5idWZvcmRlciwgCgkJCQkgICAgZG1hYnVmLT5yYXdidWYsIGRtYWJ1Zi0+ZG1hX2hhbmRsZSk7CgkJZG1hYnVmLT5yYXdidWYgPSBOVUxMOwoJfQoJZG1hYnVmLT5tYXBwZWQgPSBkbWFidWYtPnJlYWR5ID0gMDsKfQoKc3RhdGljIGludApwcm9nX2RtYWJ1ZihzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUsIGVudW0gZG1hYnVmX21vZGUgcmVjKQp7CglzdHJ1Y3QgZG1hYnVmICpkbWFidWYgPSAmc3RhdGUtPmRtYWJ1ZjsKCXVuc2lnbmVkIGJ5dGVwZXJzZWM7CglzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqcyA9IHN0YXRlOwoJdW5zaWduZWQgYnVmc2l6ZSwgZG1hX251bXM7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJaW50IHJldCwgaSwgb3JkZXI7CgoJaWYgKChyZXQgPSBsb2NrX3NldF9mbXQoc3RhdGUpKSA8IDApCgkJcmV0dXJuIHJldDsKCglpZiAoc3RhdGUtPmNoYW5zX251bSA9PSA2KQoJCWRtYV9udW1zID0gNTsKCWVsc2UKCQlkbWFfbnVtcyA9IDE7CgoJZm9yIChpID0gMDsgaSA8IGRtYV9udW1zOyBpKyspIHsKCQlpZiAoaSA+IDApIHsKCQkJcyA9IHN0YXRlLT5vdGhlcl9zdGF0ZXNbaSAtIDFdOwoJCQlkbWFidWYgPSAmcy0+ZG1hYnVmOwoJCQlkbWFidWYtPmZtdCA9IHN0YXRlLT5kbWFidWYuZm10OwoJCQlkbWFidWYtPnJhdGUgPSBzdGF0ZS0+ZG1hYnVmLnJhdGU7CgkJfQoKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcy0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJCWRtYWJ1Zi0+aHdwdHIgPSBkbWFidWYtPnN3cHRyID0gZG1hYnVmLT50b3RhbF9ieXRlcyA9IDA7CgkJZG1hYnVmLT5jb3VudCA9IGRtYWJ1Zi0+ZXJyb3IgPSAwOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCgkJLyogYWxsb2NhdGUgRE1BIGJ1ZmZlciBpZiBub3QgYWxsb2NhdGVkIHlldCAqLwoJCWlmICghZG1hYnVmLT5yYXdidWYpIHsKCQkJaWYgKGkgPT0gMCkgewoJCQkJaWYgKChyZXQgPSBhbGxvY19tYWluX2RtYWJ1ZihzdGF0ZSkpKSB7CgkJCQkJdW5sb2NrX3NldF9mbXQoc3RhdGUpOwoJCQkJCXJldHVybiByZXQ7CgkJCQl9CgkJCX0gZWxzZSB7CgkJCQlyZXQgPSAtRU5PTUVNOwoJCQkJb3JkZXIgPSBzdGF0ZS0+ZG1hYnVmLmJ1Zm9yZGVyIC0gMTsKCQkJCWlmIChvcmRlciA+PSBETUFCVUZfTUlOT1JERVIpIHsKCQkJCQlyZXQgPSBhbGxvY19kbWFidWYoZG1hYnVmLAoJCQkJCQkJICAgc3RhdGUtPmNhcmQtPnBjaV9kZXYsCgkJCQkJCQkgICBvcmRlcik7CgkJCQl9CgkJCQlpZiAocmV0KSB7CgkJCQkJLyogcmVsZWFzZSB0aGUgbWFpbiBETUEgYnVmZmVyICovCgkJCQkJZGVhbGxvY19kbWFidWYoJnN0YXRlLT5kbWFidWYsIHN0YXRlLT5jYXJkLT5wY2lfZGV2KTsKCQkJCQkvKiByZWxlYXNlIHRoZSBhdXhpbGlhcnkgRE1BIGJ1ZmZlcnMgKi8KCQkJCQlmb3IgKGkgLT0gMjsgaSA+PSAwOyBpLS0pCgkJCQkJCWRlYWxsb2NfZG1hYnVmKCZzdGF0ZS0+b3RoZXJfc3RhdGVzW2ldLT5kbWFidWYsIAoJCQkJCQkJICAgICAgIHN0YXRlLT5jYXJkLT5wY2lfZGV2KTsKCQkJCQl1bmxvY2tfc2V0X2ZtdChzdGF0ZSk7CgkJCQkJcmV0dXJuIHJldDsKCQkJCX0KCQkJfQoJCX0KCQkvKiBGSVhNRTogZmlndXJlIG91dCBhbGwgdGhpcyBPU1MgZnJhZ21lbnQgc3R1ZmYgKi8KCQlieXRlcGVyc2VjID0gZG1hYnVmLT5yYXRlIDw8IHNhbXBsZV9zaGlmdFtkbWFidWYtPmZtdF07CgkJYnVmc2l6ZSA9IFBBR0VfU0laRSA8PCBkbWFidWYtPmJ1Zm9yZGVyOwoJCWlmIChkbWFidWYtPm9zc2ZyYWdzaGlmdCkgewoJCQlpZiAoKDEwMDAgPDwgZG1hYnVmLT5vc3NmcmFnc2hpZnQpIDwgYnl0ZXBlcnNlYykKCQkJCWRtYWJ1Zi0+ZnJhZ3NoaWZ0ID0gbGQyKGJ5dGVwZXJzZWMgLyAxMDAwKTsKCQkJZWxzZQoJCQkJZG1hYnVmLT5mcmFnc2hpZnQgPSBkbWFidWYtPm9zc2ZyYWdzaGlmdDsKCQl9IGVsc2UgewoJCQkvKiBsZXRzIGhhbmQgb3V0IHJlYXNvbmFibGUgYmlnIGFzcyBidWZmZXJzIGJ5IGRlZmF1bHQgKi8KCQkJZG1hYnVmLT5mcmFnc2hpZnQgPSAoZG1hYnVmLT5idWZvcmRlciArIFBBR0VfU0hJRlQgLSAyKTsKCQl9CgkJZG1hYnVmLT5udW1mcmFnID0gYnVmc2l6ZSA+PiBkbWFidWYtPmZyYWdzaGlmdDsKCQl3aGlsZSAoZG1hYnVmLT5udW1mcmFnIDwgNCAmJiBkbWFidWYtPmZyYWdzaGlmdCA+IDMpIHsKCQkJZG1hYnVmLT5mcmFnc2hpZnQtLTsKCQkJZG1hYnVmLT5udW1mcmFnID0gYnVmc2l6ZSA+PiBkbWFidWYtPmZyYWdzaGlmdDsKCQl9CgkJZG1hYnVmLT5mcmFnc2l6ZSA9IDEgPDwgZG1hYnVmLT5mcmFnc2hpZnQ7CgkJaWYgKGRtYWJ1Zi0+b3NzbWF4ZnJhZ3MgPj0gNCAmJiBkbWFidWYtPm9zc21heGZyYWdzIDwgZG1hYnVmLT5udW1mcmFnKQoJCQlkbWFidWYtPm51bWZyYWcgPSBkbWFidWYtPm9zc21heGZyYWdzOwoJCWRtYWJ1Zi0+ZnJhZ3NhbXBsZXMgPSBkbWFidWYtPmZyYWdzaXplID4+IHNhbXBsZV9zaGlmdFtkbWFidWYtPmZtdF07CgkJZG1hYnVmLT5kbWFzaXplID0gZG1hYnVmLT5udW1mcmFnIDw8IGRtYWJ1Zi0+ZnJhZ3NoaWZ0OwoKCQltZW1zZXQoZG1hYnVmLT5yYXdidWYsIChkbWFidWYtPmZtdCAmIFRSSURFTlRfRk1UXzE2QklUKSA/IDAgOiAweDgwLCAKCQkgICAgICAgZG1hYnVmLT5kbWFzaXplKTsKCgkJc3Bpbl9sb2NrX2lycXNhdmUoJnMtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCQlpZiAocmVjID09IERNX1JFQ09SRCkKCQkJdHJpZGVudF9yZWNfc2V0dXAocyk7CgkJZWxzZSAvKiBETV9QTEFZQkFDSyAqLwoJCQl0cmlkZW50X3BsYXlfc2V0dXAocyk7CgoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnMtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCgkJLyogc2V0IHRoZSByZWFkeSBmbGFnIGZvciB0aGUgZG1hIGJ1ZmZlciAqLwoJCWRtYWJ1Zi0+cmVhZHkgPSAxOwoKCQlwcl9kZWJ1ZygidHJpZGVudDogcHJvZ19kbWFidWYoJWQpLCBzYW1wbGUgcmF0ZSA9ICVkLCAiCgkJCSAiZm9ybWF0ID0gJWQsIG51bWZyYWcgPSAlZCwgZnJhZ3NpemUgPSAlZCAiCgkJCSAiZG1hc2l6ZSA9ICVkXG4iLCBkbWFidWYtPmNoYW5uZWwtPm51bSwKCQkJIGRtYWJ1Zi0+cmF0ZSwgZG1hYnVmLT5mbXQsIGRtYWJ1Zi0+bnVtZnJhZywKCQkJIGRtYWJ1Zi0+ZnJhZ3NpemUsIGRtYWJ1Zi0+ZG1hc2l6ZSk7Cgl9Cgl1bmxvY2tfc2V0X2ZtdChzdGF0ZSk7CglyZXR1cm4gMDsKfQoKCnN0YXRpYyBpbmxpbmUgaW50IHByb2dfZG1hYnVmX3JlY29yZChzdHJ1Y3QgdHJpZGVudF9zdGF0ZSogc3RhdGUpCnsKCXJldHVybiBwcm9nX2RtYWJ1ZihzdGF0ZSwgRE1fUkVDT1JEKTsKfQoKc3RhdGljIGlubGluZSBpbnQgcHJvZ19kbWFidWZfcGxheWJhY2soc3RydWN0IHRyaWRlbnRfc3RhdGUqIHN0YXRlKQp7CglyZXR1cm4gcHJvZ19kbWFidWYoc3RhdGUsIERNX1BMQVlCQUNLKTsKfQoKLyogd2UgYXJlIGRvaW5nIHF1YW50dW0gbWVjaGFuaWNzIGhlcmUsIHRoZSBidWZmZXIgY2FuIG9ubHkgYmUgZW1wdHksIGhhbGYgb3IgZnVsbCBmaWxsZWQgaS5lLgogICB8LS0tLS0tLS0tLS0tfC0tLS0tLS0tLS0tLXwgICBvciAgIHx4eHh4eHh4eHh4eHh8LS0tLS0tLS0tLS0tfCAgIG9yICAgfHh4eHh4eHh4eHh4eHx4eHh4eHh4eHh4eHh8CiAgIGJ1dCB3ZSBhbG1vc3QgYWx3YXlzIGdldCB0aGlzCiAgIHx4eHh4eHgtLS0tLS18LS0tLS0tLS0tLS0tfCAgIG9yICAgfHh4eHh4eHh4eHh4eHx4eHh4eC0tLS0tLS18CiAgIHNvIHdlIGhhdmUgdG8gY2xlYXIgdGhlIHRhaWwgc3BhY2UgdG8gInNpbGVuY2UiCiAgIHx4eHh4eHgwMDAwMDB8LS0tLS0tLS0tLS0tfCAgIG9yICAgfHh4eHh4eHh4eHh4eHx4eHh4eHgwMDAwMDB8CiovCnN0YXRpYyB2b2lkCnRyaWRlbnRfY2xlYXJfdGFpbChzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJdW5zaWduZWQgc3dwdHI7Cgl1bnNpZ25lZCBjaGFyIHNpbGVuY2UgPSAoZG1hYnVmLT5mbXQgJiBUUklERU5UX0ZNVF8xNkJJVCkgPyAwIDogMHg4MDsKCXVuc2lnbmVkIGludCBsZW47Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZzdGF0ZS0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJc3dwdHIgPSBkbWFidWYtPnN3cHRyOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCglpZiAoc3dwdHIgPT0gMCB8fCBzd3B0ciA9PSBkbWFidWYtPmRtYXNpemUgLyAyIHx8IAoJICAgIHN3cHRyID09IGRtYWJ1Zi0+ZG1hc2l6ZSkKCQlyZXR1cm47CgoJaWYgKHN3cHRyIDwgZG1hYnVmLT5kbWFzaXplIC8gMikKCQlsZW4gPSBkbWFidWYtPmRtYXNpemUgLyAyIC0gc3dwdHI7CgllbHNlCgkJbGVuID0gZG1hYnVmLT5kbWFzaXplIC0gc3dwdHI7CgoJbWVtc2V0KGRtYWJ1Zi0+cmF3YnVmICsgc3dwdHIsIHNpbGVuY2UsIGxlbik7CglpZiAoc3RhdGUtPmNhcmQtPnBjaV9pZCAhPSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKSB7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJZG1hYnVmLT5zd3B0ciArPSBsZW47CgkJZG1hYnVmLT5jb3VudCArPSBsZW47CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCX0KCgkvKiByZXN0YXJ0IHRoZSBkbWEgbWFjaGluZSBpbiBjYXNlIGl0IGlzIGhhbHRlZCAqLwoJc3RhcnRfZGFjKHN0YXRlKTsKfQoKc3RhdGljIGludApkcmFpbl9kYWMoc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlLCBpbnQgbm9uYmxvY2spCnsKCURFQ0xBUkVfV0FJVFFVRVVFKHdhaXQsIGN1cnJlbnQpOwoJc3RydWN0IGRtYWJ1ZiAqZG1hYnVmID0gJnN0YXRlLT5kbWFidWY7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgbG9uZyB0bW87CglpbnQgY291bnQ7Cgl1bnNpZ25lZCBsb25nIGRpZmYgPSAwOwoKCWlmIChkbWFidWYtPm1hcHBlZCB8fCAhZG1hYnVmLT5yZWFkeSkKCQlyZXR1cm4gMDsKCglhZGRfd2FpdF9xdWV1ZSgmZG1hYnVmLT53YWl0LCAmd2FpdCk7Cglmb3IgKDs7KSB7CgkJLyogSXQgc2VlbXMgdGhhdCB3ZSBoYXZlIHRvIHNldCB0aGUgY3VycmVudCBzdGF0ZSB0byBUQVNLX0lOVEVSUlVQVElCTEUKCQkgICBldmVyeSB0aW1lIHRvIG1ha2UgdGhlIHByb2Nlc3MgcmVhbGx5IGdvIHRvIHNsZWVwICovCgkJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19JTlRFUlJVUFRJQkxFKTsKCgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJY291bnQgPSBkbWFidWYtPmNvdW50OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgoJCWlmIChjb3VudCA8PSAwKQoJCQlicmVhazsKCgkJaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKQoJCQlicmVhazsKCgkJaWYgKG5vbmJsb2NrKSB7CgkJCXJlbW92ZV93YWl0X3F1ZXVlKCZkbWFidWYtPndhaXQsICZ3YWl0KTsKCQkJc2V0X2N1cnJlbnRfc3RhdGUoVEFTS19SVU5OSU5HKTsKCQkJcmV0dXJuIC1FQlVTWTsKCQl9CgoJCS8qIE5vIG1hdHRlciBob3cgbXVjaCBkYXRhIGlzIGxlZnQgaW4gdGhlIGJ1ZmZlciwgd2UgaGF2ZSB0byB3YWl0IHVudGlsCgkJICAgQ1NPID09IEVTTy8yIG9yIENTTyA9PSBFU08gd2hlbiBhZGRyZXNzIGVuZ2luZSBpbnRlcnJ1cHRzICovCgkJaWYgKHN0YXRlLT5jYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSB8fCAKCQkgICAgc3RhdGUtPmNhcmQtPnBjaV9pZCA9PSBQQ0lfREVWSUNFX0lEX0lOVEVSR181MDUwKSB7CgkJCWRpZmYgPSBkbWFidWYtPnN3cHRyIC0gdHJpZGVudF9nZXRfZG1hX2FkZHIoc3RhdGUpICsgZG1hYnVmLT5kbWFzaXplOwoJCQlkaWZmID0gZGlmZiAlIChkbWFidWYtPmRtYXNpemUpOwoJCQl0bW8gPSAoZGlmZiAqIEhaKSAvIGRtYWJ1Zi0+cmF0ZTsKCQl9IGVsc2UgewoJCQl0bW8gPSAoZG1hYnVmLT5kbWFzaXplICogSFopIC8gZG1hYnVmLT5yYXRlOwoJCX0KCQl0bW8gPj49IHNhbXBsZV9zaGlmdFtkbWFidWYtPmZtdF07CgkJaWYgKCFzY2hlZHVsZV90aW1lb3V0KHRtbyA/IHRtbyA6IDEpICYmIHRtbykgewoJCQlicmVhazsKCQl9Cgl9CglyZW1vdmVfd2FpdF9xdWV1ZSgmZG1hYnVmLT53YWl0LCAmd2FpdCk7CglzZXRfY3VycmVudF9zdGF0ZShUQVNLX1JVTk5JTkcpOwoJaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKQoJCXJldHVybiAtRVJFU1RBUlRTWVM7CgoJcmV0dXJuIDA7Cn0KCi8qIHVwZGF0ZSBidWZmZXIgbWFuYW5nZW1lbnQgcG9pbnRlcnMsIGVzcGVjaWFsbHksICovIAovKiBkbWFidWYtPmNvdW50IGFuZCBkbWFidWYtPmh3cHRyICovCnN0YXRpYyB2b2lkCnRyaWRlbnRfdXBkYXRlX3B0cihzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJdW5zaWduZWQgaHdwdHIsIHN3cHRyOwoJaW50IGNsZWFyX2NudCA9IDA7CglpbnQgZGlmZjsKCXVuc2lnbmVkIGNoYXIgc2lsZW5jZTsKCXVuc2lnbmVkIGhhbGZfZG1hc2l6ZTsKCgkvKiB1cGRhdGUgaGFyZHdhcmUgcG9pbnRlciAqLwoJaHdwdHIgPSB0cmlkZW50X2dldF9kbWFfYWRkcihzdGF0ZSk7CglkaWZmID0gKGRtYWJ1Zi0+ZG1hc2l6ZSArIGh3cHRyIC0gZG1hYnVmLT5od3B0cikgJSBkbWFidWYtPmRtYXNpemU7CglkbWFidWYtPmh3cHRyID0gaHdwdHI7CglkbWFidWYtPnRvdGFsX2J5dGVzICs9IGRpZmY7CgoJLyogZXJyb3IgaGFuZGxpbmcgYW5kIHByb2Nlc3Mgd2FrZSB1cCBmb3IgQURDICovCglpZiAoZG1hYnVmLT5lbmFibGUgPT0gQURDX1JVTk5JTkcpIHsKCQlpZiAoZG1hYnVmLT5tYXBwZWQpIHsKCQkJZG1hYnVmLT5jb3VudCAtPSBkaWZmOwoJCQlpZiAoZG1hYnVmLT5jb3VudCA+PSAoc2lnbmVkKSBkbWFidWYtPmZyYWdzaXplKQoJCQkJd2FrZV91cCgmZG1hYnVmLT53YWl0KTsKCQl9IGVsc2UgewoJCQlkbWFidWYtPmNvdW50ICs9IGRpZmY7CgoJCQlpZiAoZG1hYnVmLT5jb3VudCA8IDAgfHwgCgkJCSAgICBkbWFidWYtPmNvdW50ID4gZG1hYnVmLT5kbWFzaXplKSB7CgkJCQkvKiBidWZmZXIgdW5kZXJydW4gb3IgYnVmZmVyIG92ZXJydW4sICovIAoJCQkJLyogd2UgaGF2ZSBubyB3YXkgdG8gcmVjb3ZlciBpdCBoZXJlLCBqdXN0ICovIAoJCQkJLyogc3RvcCB0aGUgbWFjaGluZSBhbmQgbGV0IHRoZSBwcm9jZXNzICovIAoJCQkJLyogZm9yY2UgaHdwdHIgYW5kIHN3cHRyIHRvIHN5bmMgKi8KCQkJCV9fc3RvcF9hZGMoc3RhdGUpOwoJCQkJZG1hYnVmLT5lcnJvcisrOwoJCQl9CgkJCWlmIChkbWFidWYtPmNvdW50IDwgKHNpZ25lZCkgZG1hYnVmLT5kbWFzaXplIC8gMikKCQkJCXdha2VfdXAoJmRtYWJ1Zi0+d2FpdCk7CgkJfQoJfQoKCS8qIGVycm9yIGhhbmRsaW5nIGFuZCBwcm9jZXNzIHdha2UgdXAgZm9yIERBQyAqLwoJaWYgKGRtYWJ1Zi0+ZW5hYmxlID09IERBQ19SVU5OSU5HKSB7CgkJaWYgKGRtYWJ1Zi0+bWFwcGVkKSB7CgkJCWRtYWJ1Zi0+Y291bnQgKz0gZGlmZjsKCQkJaWYgKGRtYWJ1Zi0+Y291bnQgPj0gKHNpZ25lZCkgZG1hYnVmLT5mcmFnc2l6ZSkKCQkJCXdha2VfdXAoJmRtYWJ1Zi0+d2FpdCk7CgkJfSBlbHNlIHsKCQkJZG1hYnVmLT5jb3VudCAtPSBkaWZmOwoKCQkJaWYgKGRtYWJ1Zi0+Y291bnQgPCAwIHx8IAoJCQkgICAgZG1hYnVmLT5jb3VudCA+IGRtYWJ1Zi0+ZG1hc2l6ZSkgewoJCQkJLyogYnVmZmVyIHVuZGVycnVuIG9yIGJ1ZmZlciBvdmVycnVuLCB3ZSBoYXZlIG5vIHdheSB0byByZWNvdmVyCgkJCQkgICBpdCBoZXJlLCBqdXN0IHN0b3AgdGhlIG1hY2hpbmUgYW5kIGxldCB0aGUgcHJvY2VzcyBmb3JjZSBod3B0cgoJCQkJICAgYW5kIHN3cHRyIHRvIHN5bmMgKi8KCQkJCV9fc3RvcF9kYWMoc3RhdGUpOwoJCQkJZG1hYnVmLT5lcnJvcisrOwoJCQl9IGVsc2UgaWYgKCFkbWFidWYtPmVuZGNsZWFyZWQpIHsKCQkJCXN3cHRyID0gZG1hYnVmLT5zd3B0cjsKCQkJCXNpbGVuY2UgPSAoZG1hYnVmLT5mbXQgJiBUUklERU5UX0ZNVF8xNkJJVCA/IDAgOiAweDgwKTsKCQkJCWlmIChkbWFidWYtPnVwZGF0ZV9mbGFnICYgQUxJX0FERFJFU1NfSU5UX1VQREFURSkgewoJCQkJCS8qIFdlIG11c3QgY2xlYXIgZW5kIGRhdGEgb2YgMS8yIGRtYWJ1ZiBpZiBuZWVkZWQuCgkJCQkJICAgQWNjb3JkaW5nIHRvIDEvMiBhbGdvcml0aG0gb2YgQWRkcmVzcyBFbmdpbmUgSW50ZXJydXB0LAoJCQkJCSAgIGNoZWNrIHRoZSB2YWxpZGF0aW9uIG9mIHRoZSBkYXRhIG9mIGhhbGYgZG1hc2l6ZS4gKi8KCQkJCQloYWxmX2RtYXNpemUgPSBkbWFidWYtPmRtYXNpemUgLyAyOwoJCQkJCWlmICgoZGlmZiA9IGh3cHRyIC0gaGFsZl9kbWFzaXplKSA8IDApCgkJCQkJCWRpZmYgPSBod3B0cjsKCQkJCQlpZiAoKGRtYWJ1Zi0+Y291bnQgKyBkaWZmKSA8IGhhbGZfZG1hc2l6ZSkgewoJCQkJCQkvL3RoZXJlIGlzIGludmFsaWQgZGF0YSBpbiB0aGUgZW5kIG9mIGhhbGYgYnVmZmVyCgkJCQkJCWlmICgoY2xlYXJfY250ID0gaGFsZl9kbWFzaXplIC0gc3dwdHIpIDwgMCkKCQkJCQkJCWNsZWFyX2NudCArPSBoYWxmX2RtYXNpemU7CgkJCQkJCS8vY2xlYXIgdGhlIGludmFsaWQgZGF0YQoJCQkJCQltZW1zZXQoZG1hYnVmLT5yYXdidWYgKyBzd3B0ciwgc2lsZW5jZSwgY2xlYXJfY250KTsKCQkJCQkJaWYgKHN0YXRlLT5jaGFuc19udW0gPT0gNikgewoJCQkJCQkJY2xlYXJfY250ID0gY2xlYXJfY250IC8gMjsKCQkJCQkJCXN3cHRyID0gc3dwdHIgLyAyOwoJCQkJCQkJbWVtc2V0KHN0YXRlLT5vdGhlcl9zdGF0ZXNbMF0tPmRtYWJ1Zi5yYXdidWYgKyBzd3B0ciwgCgkJCQkJCQkgICAgICAgc2lsZW5jZSwgY2xlYXJfY250KTsKCQkJCQkJCW1lbXNldChzdGF0ZS0+b3RoZXJfc3RhdGVzWzFdLT5kbWFidWYucmF3YnVmICsgc3dwdHIsIAoJCQkJCQkJICAgICAgIHNpbGVuY2UsIGNsZWFyX2NudCk7CgkJCQkJCQltZW1zZXQoc3RhdGUtPm90aGVyX3N0YXRlc1syXS0+ZG1hYnVmLnJhd2J1ZiArIHN3cHRyLCAKCQkJCQkJCSAgICAgICBzaWxlbmNlLCBjbGVhcl9jbnQpOwoJCQkJCQkJbWVtc2V0KHN0YXRlLT5vdGhlcl9zdGF0ZXNbM10tPmRtYWJ1Zi5yYXdidWYgKyBzd3B0ciwgCgkJCQkJCQkgICAgICAgc2lsZW5jZSwgY2xlYXJfY250KTsKCQkJCQkJfQoJCQkJCQlkbWFidWYtPmVuZGNsZWFyZWQgPSAxOwoJCQkJCX0KCQkJCX0gZWxzZSBpZiAoZG1hYnVmLT5jb3VudCA8IChzaWduZWQpIGRtYWJ1Zi0+ZnJhZ3NpemUpIHsKCQkJCQljbGVhcl9jbnQgPSBkbWFidWYtPmZyYWdzaXplOwoJCQkJCWlmICgoc3dwdHIgKyBjbGVhcl9jbnQpID4gZG1hYnVmLT5kbWFzaXplKQoJCQkJCQljbGVhcl9jbnQgPSBkbWFidWYtPmRtYXNpemUgLSBzd3B0cjsKCQkJCQltZW1zZXQoZG1hYnVmLT5yYXdidWYgKyBzd3B0ciwgc2lsZW5jZSwgY2xlYXJfY250KTsKCQkJCQlpZiAoc3RhdGUtPmNoYW5zX251bSA9PSA2KSB7CgkJCQkJCWNsZWFyX2NudCA9IGNsZWFyX2NudCAvIDI7CgkJCQkJCXN3cHRyID0gc3dwdHIgLyAyOwoJCQkJCQltZW1zZXQoc3RhdGUtPm90aGVyX3N0YXRlc1swXS0+ZG1hYnVmLnJhd2J1ZiArIHN3cHRyLCAKCQkJCQkJICAgICAgIHNpbGVuY2UsIGNsZWFyX2NudCk7CgkJCQkJCW1lbXNldChzdGF0ZS0+b3RoZXJfc3RhdGVzWzFdLT5kbWFidWYucmF3YnVmICsgc3dwdHIsIAoJCQkJCQkgICAgICAgc2lsZW5jZSwgY2xlYXJfY250KTsKCQkJCQkJbWVtc2V0KHN0YXRlLT5vdGhlcl9zdGF0ZXNbMl0tPmRtYWJ1Zi5yYXdidWYgKyBzd3B0ciwgCgkJCQkJCSAgICAgICBzaWxlbmNlLCBjbGVhcl9jbnQpOwoJCQkJCQltZW1zZXQoc3RhdGUtPm90aGVyX3N0YXRlc1szXS0+ZG1hYnVmLnJhd2J1ZiArIHN3cHRyLCAKCQkJCQkJICAgICAgIHNpbGVuY2UsIGNsZWFyX2NudCk7CgkJCQkJfQoJCQkJCWRtYWJ1Zi0+ZW5kY2xlYXJlZCA9IDE7CgkJCQl9CgkJCX0KCQkJLyogdHJpZGVudF91cGRhdGVfcHRyIGlzIGNhbGxlZCBieSBpbnRlcnJ1cHQgaGFuZGxlciBvciBieSBwcm9jZXNzIHZpYQoJCQkgICBpb2N0bC9wb2xsLCB3ZSBvbmx5IHdha2UgdXAgdGhlIHdhaXRpbmcgcHJvY2VzcyB3aGVuIHdlIGhhdmUgbW9yZQoJCQkgICB0aGFuIDEvMiBidWZmZXIgZnJlZSAoYWx3YXlzIHRydWUgZm9yIGludGVycnVwdCBoYW5kbGVyKSAqLwoJCQlpZiAoZG1hYnVmLT5jb3VudCA8IChzaWduZWQpIGRtYWJ1Zi0+ZG1hc2l6ZSAvIDIpCgkJCQl3YWtlX3VwKCZkbWFidWYtPndhaXQpOwoJCX0KCX0KCWRtYWJ1Zi0+dXBkYXRlX2ZsYWcgJj0gfkFMSV9BRERSRVNTX0lOVF9VUERBVEU7Cn0KCnN0YXRpYyB2b2lkCnRyaWRlbnRfYWRkcmVzc19pbnRlcnJ1cHQoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkKewoJaW50IGk7CglzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGU7Cgl1bnNpZ25lZCBpbnQgY2hhbm5lbDsKCgkvKiBVcGRhdGUgdGhlIHBvaW50ZXJzIGZvciBhbGwgY2hhbm5lbHMgd2UgYXJlIHJ1bm5pbmcuICovCgkvKiBGSVhNRTogc2hvdWxkIHJlYWQgaW50ZXJydXB0IHN0YXR1cyBvbmx5IG9uY2UgKi8KCWZvciAoaSA9IDA7IGkgPCBOUl9IV19DSDsgaSsrKSB7CgkJY2hhbm5lbCA9IDYzIC0gaTsKCQlpZiAodHJpZGVudF9jaGVja19jaGFubmVsX2ludGVycnVwdChjYXJkLCBjaGFubmVsKSkgewoJCQl0cmlkZW50X2Fja19jaGFubmVsX2ludGVycnVwdChjYXJkLCBjaGFubmVsKTsKCQkJaWYgKChzdGF0ZSA9IGNhcmQtPnN0YXRlc1tpXSkgIT0gTlVMTCkgewoJCQkJdHJpZGVudF91cGRhdGVfcHRyKHN0YXRlKTsKCQkJfSBlbHNlIHsKCQkJCXByaW50ayhLRVJOX1dBUk5JTkcgInRyaWRlbnQ6IHNwdXJpb3VzIGNoYW5uZWwgIiAKCQkJCSAgICAgICAiaXJxICVkLlxuIiwgY2hhbm5lbCk7CgkJCQl0cmlkZW50X3N0b3Bfdm9pY2UoY2FyZCwgY2hhbm5lbCk7CgkJCQl0cmlkZW50X2Rpc2FibGVfdm9pY2VfaXJxKGNhcmQsIGNoYW5uZWwpOwoJCQl9CgkJfQoJfQp9CgpzdGF0aWMgdm9pZAphbGlfaHd2b2xfY29udHJvbChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCBpbnQgb3B0KQp7Cgl1MTYgZHdUZW1wLCB2b2x1bWVbMl0sIG11dGUsIGRpZmYsICpwVm9sWzJdOwoKCWR3VGVtcCA9IGFsaV9hYzk3X3JlYWQoY2FyZC0+YWM5N19jb2RlY1swXSwgMHgwMik7CgltdXRlID0gZHdUZW1wICYgMHg4MDAwOwoJdm9sdW1lWzBdID0gZHdUZW1wICYgMHgwMDFmOwoJdm9sdW1lWzFdID0gKGR3VGVtcCAmIDB4MWYwMCkgPj4gODsKCWlmICh2b2x1bWVbMF0gPCB2b2x1bWVbMV0pIHsKCQlwVm9sWzBdID0gJnZvbHVtZVswXTsKCQlwVm9sWzFdID0gJnZvbHVtZVsxXTsKCX0gZWxzZSB7CgkJcFZvbFsxXSA9ICZ2b2x1bWVbMF07CgkJcFZvbFswXSA9ICZ2b2x1bWVbMV07Cgl9CglkaWZmID0gKihwVm9sWzFdKSAtICoocFZvbFswXSk7CgoJaWYgKG9wdCA9PSAxKSB7CQkvLyBNVVRFCgkJZHdUZW1wIF49IDB4ODAwMDsKCQlhbGlfYWM5N193cml0ZShjYXJkLT5hYzk3X2NvZGVjWzBdLCAKCQkJICAgICAgIDB4MDIsIGR3VGVtcCk7Cgl9IGVsc2UgaWYgKG9wdCA9PSAyKSB7CS8vIERvd24KCQlpZiAobXV0ZSkKCQkJcmV0dXJuOwoJCWlmICgqKHBWb2xbMV0pIDwgMHgwMDFmKSB7CgkJCSgqcFZvbFsxXSkrKzsKCQkJKihwVm9sWzBdKSA9ICoocFZvbFsxXSkgLSBkaWZmOwoJCX0KCQlkd1RlbXAgJj0gMHhlMGUwOwoJCWR3VGVtcCB8PSAodm9sdW1lWzBdKSB8ICh2b2x1bWVbMV0gPDwgOCk7CgkJYWxpX2FjOTdfd3JpdGUoY2FyZC0+YWM5N19jb2RlY1swXSwgMHgwMiwgZHdUZW1wKTsKCQljYXJkLT5hYzk3X2NvZGVjWzBdLT5taXhlcl9zdGF0ZVswXSA9ICgoMzIgLSB2b2x1bWVbMF0pICogMjUgLyA4KSB8IAoJCQkoKCgzMiAtIHZvbHVtZVsxXSkgKiAyNSAvIDgpIDw8IDgpOwoJfSBlbHNlIGlmIChvcHQgPT0gNCkgewkvLyBVcAoJCWlmIChtdXRlKQoJCQlyZXR1cm47CgkJaWYgKCoocFZvbFswXSkgPiAwKSB7CgkJCSgqcFZvbFswXSktLTsKCQkJKihwVm9sWzFdKSA9ICoocFZvbFswXSkgKyBkaWZmOwoJCX0KCQlkd1RlbXAgJj0gMHhlMGUwOwoJCWR3VGVtcCB8PSAodm9sdW1lWzBdKSB8ICh2b2x1bWVbMV0gPDwgOCk7CgkJYWxpX2FjOTdfd3JpdGUoY2FyZC0+YWM5N19jb2RlY1swXSwgMHgwMiwgZHdUZW1wKTsKCQljYXJkLT5hYzk3X2NvZGVjWzBdLT5taXhlcl9zdGF0ZVswXSA9ICgoMzIgLSB2b2x1bWVbMF0pICogMjUgLyA4KSB8IAoJCQkoKCgzMiAtIHZvbHVtZVsxXSkgKiAyNSAvIDgpIDw8IDgpOwoJfSBlbHNlIHsKCQkvKiBOb3RoaW5nIG5lZWRzIGRvaW5nICovCgl9Cn0KCi8qCiAqCVJlLWVuYWJsZSByZXBvcnRpbmcgb2Ygdm9sIGNoYW5nZSBhZnRlciAwLjEgc2Vjb25kcwogKi8KCnN0YXRpYyB2b2lkCmFsaV90aW1lb3V0KHVuc2lnbmVkIGxvbmcgcHRyKQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gKHN0cnVjdCB0cmlkZW50X2NhcmQgKikgcHRyOwoJdTE2IHRlbXAgPSAwOwoKCS8qIEVuYWJsZSBHUElPIElSUSAoTUlTQ0lOVCBiaXQgMThoKSAqLwoJdGVtcCA9IGludyhUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCArIDIpKTsKCXRlbXAgfD0gMHgwMDA0OwoJb3V0dyh0ZW1wLCBUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCArIDIpKTsKfQoKLyoKICoJU2V0IHVwIHRoZSB0aW1lciB0byBjbGVhciB0aGUgdm9sIGNoYW5nZSBub3RpZmljYXRpb24KICovCgpzdGF0aWMgdm9pZAphbGlfc2V0X3RpbWVyKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCS8qIEFkZCBUaW1lciBSb3V0aW5lIHRvIEVuYWJsZSBHUElPIElSUSAqLwoJZGVsX3RpbWVyKCZjYXJkLT50aW1lcik7CS8qIE5ldmVyIHF1ZXVlIHR3aWNlICovCgljYXJkLT50aW1lci5mdW5jdGlvbiA9IGFsaV90aW1lb3V0OwoJY2FyZC0+dGltZXIuZGF0YSA9ICh1bnNpZ25lZCBsb25nKSBjYXJkOwoJY2FyZC0+dGltZXIuZXhwaXJlcyA9IGppZmZpZXMgKyBIWiAvIDEwOwoJYWRkX3RpbWVyKCZjYXJkLT50aW1lcik7Cn0KCi8qCiAqCVByb2Nlc3MgYSBHUElPIGV2ZW50CiAqLwoKc3RhdGljIHZvaWQKYWxpX3F1ZXVlX3Rhc2soc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgaW50IG9wdCkKewoJdTE2IHRlbXA7CgoJLyogRGlzYWJsZSBHUElPIElSUSAoTUlTQ0lOVCBiaXQgMThoKSAqLwoJdGVtcCA9IGludyhUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCArIDIpKTsKCXRlbXAgJj0gKHUxNikgKH4weDAwMDQpOwoJb3V0dyh0ZW1wLCBUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCArIDIpKTsKCgkvKiBBZGp1c3QgdGhlIHZvbHVtZSAqLwoJYWxpX2h3dm9sX2NvbnRyb2woY2FyZCwgb3B0KTsKCgkvKiBTZXQgdGhlIHRpbWVyIGZvciAxLzEwdGggc2VjICovCglhbGlfc2V0X3RpbWVyKGNhcmQpOwp9CgpzdGF0aWMgdm9pZApjeWJlcl9hZGRyZXNzX2ludGVycnVwdChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7CglpbnQgaSwgaXJxX3N0YXR1czsKCXN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZTsKCXVuc2lnbmVkIGludCBjaGFubmVsOwoKCS8qIFVwZGF0ZSB0aGUgcG9pbnRlcnMgZm9yIGFsbCBjaGFubmVscyB3ZSBhcmUgcnVubmluZy4gKi8KCS8qIEZJWEVEOiByZWFkIGludGVycnVwdCBzdGF0dXMgb25seSBvbmNlICovCglpcnFfc3RhdHVzID0gaW5sKFRSSURfUkVHKGNhcmQsIFQ0RF9BSU5UX0EpKTsKCglwcl9kZWJ1ZygiY3liZXJfYWRkcmVzc19pbnRlcnJ1cHQ6IGlycV9zdGF0dXMgMHglWFxuIiwgaXJxX3N0YXR1cyk7CgoJZm9yIChpID0gMDsgaSA8IE5SX0hXX0NIOyBpKyspIHsKCQljaGFubmVsID0gMzEgLSBpOwoJCWlmIChpcnFfc3RhdHVzICYgKDEgPDwgY2hhbm5lbCkpIHsKCQkJLyogY2xlYXIgYml0IGJ5IHdyaXRpbmcgYSAxLCB6ZXJvZXMgYXJlIGlnbm9yZWQgKi8KCQkJb3V0bCgoMSA8PCBjaGFubmVsKSwgVFJJRF9SRUcoY2FyZCwgVDREX0FJTlRfQSkpOwoKCQkJcHJfZGVidWcoImN5YmVyX2ludGVycnVwdDogY2hhbm5lbCAlZFxuIiwgY2hhbm5lbCk7CgoJCQlpZiAoKHN0YXRlID0gY2FyZC0+c3RhdGVzW2ldKSAhPSBOVUxMKSB7CgkJCQl0cmlkZW50X3VwZGF0ZV9wdHIoc3RhdGUpOwoJCQl9IGVsc2UgewoJCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiY3liZXI1MDUwOiBzcHVyaW91cyAiIAoJCQkJICAgICAgICJjaGFubmVsIGlycSAlZC5cbiIsIGNoYW5uZWwpOwoJCQkJdHJpZGVudF9zdG9wX3ZvaWNlKGNhcmQsIGNoYW5uZWwpOwoJCQkJdHJpZGVudF9kaXNhYmxlX3ZvaWNlX2lycShjYXJkLCBjaGFubmVsKTsKCQkJfQoJCX0KCX0KfQoKc3RhdGljIGlycXJldHVybl90CnRyaWRlbnRfaW50ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCwgc3RydWN0IHB0X3JlZ3MgKnJlZ3MpCnsKCXN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQgPSAoc3RydWN0IHRyaWRlbnRfY2FyZCAqKSBkZXZfaWQ7Cgl1MzIgZXZlbnQ7Cgl1MzIgZ3BpbzsKCglzcGluX2xvY2soJmNhcmQtPmxvY2spOwoJZXZlbnQgPSBpbmwoVFJJRF9SRUcoY2FyZCwgVDREX01JU0NJTlQpKTsKCglwcl9kZWJ1ZygidHJpZGVudDogdHJpZGVudF9pbnRlcnJ1cHQgY2FsbGVkLCBNSVNDSU5UID0gMHglMDh4XG4iLAoJCSBldmVudCk7CgoJaWYgKGV2ZW50ICYgQUREUkVTU19JUlEpIHsKCQljYXJkLT5hZGRyZXNzX2ludGVycnVwdChjYXJkKTsKCX0KCglpZiAoY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfQUxJXzU0NTEpIHsKCQkvKiBHUElPIElSUSAoSC9XIFZvbHVtZSBDb250cm9sKSAqLwoJCWV2ZW50ID0gaW5sKFRSSURfUkVHKGNhcmQsIFQ0RF9NSVNDSU5UKSk7CgkJaWYgKGV2ZW50ICYgKDEgPDwgMjUpKSB7CgkJCWdwaW8gPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0dQSU8pKTsKCQkJaWYgKCF0aW1lcl9wZW5kaW5nKCZjYXJkLT50aW1lcikpCgkJCQlhbGlfcXVldWVfdGFzayhjYXJkLCBncGlvICYgMHgwNyk7CgkJfQoJCWV2ZW50ID0gaW5sKFRSSURfUkVHKGNhcmQsIFQ0RF9NSVNDSU5UKSk7CgkJb3V0bChldmVudCB8IChTVF9UQVJHRVRfUkVBQ0hFRCB8IE1JWEVSX09WRVJGTE9XIHwgTUlYRVJfVU5ERVJGTE9XKSwgCgkJICAgICBUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCkpOwoJCXNwaW5fdW5sb2NrKCZjYXJkLT5sb2NrKTsKCQlyZXR1cm4gSVJRX0hBTkRMRUQ7Cgl9CgoJLyogbWFudWFsbHkgY2xlYXIgaW50ZXJydXB0IHN0YXR1cywgYmFkIGhhcmR3YXJlIGRlc2lnbiwgYmxhbWUgVF4yICovCglvdXRsKChTVF9UQVJHRVRfUkVBQ0hFRCB8IE1JWEVSX09WRVJGTE9XIHwgTUlYRVJfVU5ERVJGTE9XKSwgCgkgICAgIFRSSURfUkVHKGNhcmQsIFQ0RF9NSVNDSU5UKSk7CglzcGluX3VubG9jaygmY2FyZC0+bG9jayk7CglyZXR1cm4gSVJRX0hBTkRMRUQ7Cn0KCi8qIGluIHRoaXMgbG9vcCwgZG1hYnVmLmNvdW50IHNpZ25pZmllcyB0aGUgYW1vdW50IG9mIGRhdGEgdGhhdCBpcyB3YWl0aW5nICovIAovKiB0byBiZSBjb3BpZWQgdG8gdGhlIHVzZXIncyBidWZmZXIuICBpdCBpcyBmaWxsZWQgYnkgdGhlIGRtYSBtYWNoaW5lIGFuZCAqLyAKLyogZHJhaW5lZCBieSB0aGlzIGxvb3AuICovCnN0YXRpYyBzc2l6ZV90CnRyaWRlbnRfcmVhZChzdHJ1Y3QgZmlsZSAqZmlsZSwgY2hhciBfX3VzZXIgKmJ1ZmZlciwgc2l6ZV90IGNvdW50LCBsb2ZmX3QgKiBwcG9zKQp7CglzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUgPSAoc3RydWN0IHRyaWRlbnRfc3RhdGUgKilmaWxlLT5wcml2YXRlX2RhdGE7CglzdHJ1Y3QgZG1hYnVmICpkbWFidWYgPSAmc3RhdGUtPmRtYWJ1ZjsKCXNzaXplX3QgcmV0ID0gMDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1bnNpZ25lZCBzd3B0cjsKCWludCBjbnQ7CgoJcHJfZGVidWcoInRyaWRlbnQ6IHRyaWRlbnRfcmVhZCBjYWxsZWQsIGNvdW50ID0gJWRcbiIsIGNvdW50KTsKCglWQUxJREFURV9TVEFURShzdGF0ZSk7CgoJaWYgKGRtYWJ1Zi0+bWFwcGVkKQoJCXJldHVybiAtRU5YSU87CglpZiAoIWFjY2Vzc19vayhWRVJJRllfV1JJVEUsIGJ1ZmZlciwgY291bnQpKQoJCXJldHVybiAtRUZBVUxUOwoKCW11dGV4X2xvY2soJnN0YXRlLT5zZW0pOwoJaWYgKCFkbWFidWYtPnJlYWR5ICYmIChyZXQgPSBwcm9nX2RtYWJ1Zl9yZWNvcmQoc3RhdGUpKSkKCQlnb3RvIG91dDsKCgl3aGlsZSAoY291bnQgPiAwKSB7CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJaWYgKGRtYWJ1Zi0+Y291bnQgPiAoc2lnbmVkKSBkbWFidWYtPmRtYXNpemUpIHsKCQkJLyogYnVmZmVyIG92ZXJydW4sIHdlIGFyZSByZWNvdmVyaW5nIGZyb20gKi8gCgkJCS8qIHNsZWVwX29uX3RpbWVvdXQsIHJlc3luYyBod3B0ciBhbmQgc3dwdHIsICovIAoJCQkvKiBtYWtlIHByb2Nlc3MgZmx1c2ggdGhlIGJ1ZmZlciAqLwoJCQlkbWFidWYtPmNvdW50ID0gZG1hYnVmLT5kbWFzaXplOwoJCQlkbWFidWYtPnN3cHRyID0gZG1hYnVmLT5od3B0cjsKCQl9CgkJc3dwdHIgPSBkbWFidWYtPnN3cHRyOwoJCWNudCA9IGRtYWJ1Zi0+ZG1hc2l6ZSAtIHN3cHRyOwoJCWlmIChkbWFidWYtPmNvdW50IDwgY250KQoJCQljbnQgPSBkbWFidWYtPmNvdW50OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgoJCWlmIChjbnQgPiBjb3VudCkKCQkJY250ID0gY291bnQ7CgkJaWYgKGNudCA8PSAwKSB7CgkJCXVuc2lnbmVkIGxvbmcgdG1vOwoJCQkvKiBidWZmZXIgaXMgZW1wdHksIHN0YXJ0IHRoZSBkbWEgbWFjaGluZSBhbmQgKi8gCgkJCS8qIHdhaXQgZm9yIGRhdGEgdG8gYmUgcmVjb3JkZWQgKi8KCQkJc3RhcnRfYWRjKHN0YXRlKTsKCQkJaWYgKGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKSB7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRUFHQUlOOwoJCQkJZ290byBvdXQ7CgkJCX0KCgkJCW11dGV4X3VubG9jaygmc3RhdGUtPnNlbSk7CgkJCS8qIE5vIG1hdHRlciBob3cgbXVjaCBzcGFjZSBsZWZ0IGluIHRoZSBidWZmZXIsICovIAoJCQkvKiB3ZSBoYXZlIHRvIHdhaXQgdW50aWwgQ1NPID09IEVTTy8yIG9yIENTTyA9PSBFU08gKi8gCgkJCS8qIHdoZW4gYWRkcmVzcyBlbmdpbmUgaW50ZXJydXB0cyAqLwoJCQl0bW8gPSAoZG1hYnVmLT5kbWFzaXplICogSFopIC8gKGRtYWJ1Zi0+cmF0ZSAqIDIpOwoJCQl0bW8gPj49IHNhbXBsZV9zaGlmdFtkbWFidWYtPmZtdF07CgkJCS8qIFRoZXJlIGFyZSB0d28gc2l0dWF0aW9ucyB3aGVuIHNsZWVwX29uX3RpbWVvdXQgcmV0dXJucywgb25lIGlzIHdoZW4KCQkJICAgdGhlIGludGVycnVwdCBpcyBzZXJ2aWNlZCBjb3JyZWN0bHkgYW5kIHRoZSBwcm9jZXNzIGlzIHdha2VkIHVwIGJ5CgkJCSAgIElTUiBPTiBUSU1FLiBBbm90aGVyIGlzIHdoZW4gdGltZW91dCBpcyBleHBpcmVkLCB3aGljaCBtZWFucyB0aGF0CgkJCSAgIGVpdGhlciBpbnRlcnJ1cHQgaXMgTk9UIHNlcnZpY2VkIGNvcnJlY3RseSAocGVuZGluZyBpbnRlcnJ1cHQpIG9yIGl0CgkJCSAgIGlzIFRPTyBMQVRFIGZvciB0aGUgcHJvY2VzcyB0byBiZSBzY2hlZHVsZWQgdG8gcnVuIChzY2hlZHVsZXIgbGF0ZW5jeSkKCQkJICAgd2hpY2ggcmVzdWx0cyBpbiBhIChwb3RlbnRpYWwpIGJ1ZmZlciBvdmVycnVuLiBBbmQgd29yc2UsIHRoZXJlIGlzCgkJCSAgIE5PVEhJTkcgd2UgY2FuIGRvIHRvIHByZXZlbnQgaXQuICovCgkJCWlmICghaW50ZXJydXB0aWJsZV9zbGVlcF9vbl90aW1lb3V0KCZkbWFidWYtPndhaXQsIHRtbykpIHsKCQkJCXByX2RlYnVnKEtFUk5fRVJSICJ0cmlkZW50OiByZWNvcmRpbmcgc2NoZWR1bGUgdGltZW91dCwgIgoJCQkJCSAiZG1hc3ogJXUgZnJhZ3N6ICV1IGNvdW50ICVpIGh3cHRyICV1IHN3cHRyICV1XG4iLAoJCQkJCSBkbWFidWYtPmRtYXNpemUsIGRtYWJ1Zi0+ZnJhZ3NpemUsIGRtYWJ1Zi0+Y291bnQsCgkJCQkJIGRtYWJ1Zi0+aHdwdHIsIGRtYWJ1Zi0+c3dwdHIpOwoKCQkJCS8qIGEgYnVmZmVyIG92ZXJydW4sIHdlIGRlbGF5IHRoZSByZWNvdmVyeSB1bnRpbCBuZXh0IHRpbWUgdGhlCgkJCQkgICB3aGlsZSBsb29wIGJlZ2luIGFuZCB3ZSBSRUFMTFkgaGF2ZSBzcGFjZSB0byByZWNvcmQgKi8KCQkJfQoJCQlpZiAoc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpIHsKCQkJCWlmICghcmV0KQoJCQkJCXJldCA9IC1FUkVTVEFSVFNZUzsKCQkJCWdvdG8gb3V0OwoJCQl9CgkJCW11dGV4X2xvY2soJnN0YXRlLT5zZW0pOwoJCQlpZiAoZG1hYnVmLT5tYXBwZWQpIHsKCQkJCWlmICghcmV0KQoJCQkJCXJldCA9IC1FTlhJTzsKCQkJCWdvdG8gb3V0OwoJCQl9CgkJCWNvbnRpbnVlOwoJCX0KCgkJaWYgKGNvcHlfdG9fdXNlcihidWZmZXIsIGRtYWJ1Zi0+cmF3YnVmICsgc3dwdHIsIGNudCkpIHsKCQkJaWYgKCFyZXQpCgkJCQlyZXQgPSAtRUZBVUxUOwoJCQlnb3RvIG91dDsKCQl9CgoJCXN3cHRyID0gKHN3cHRyICsgY250KSAlIGRtYWJ1Zi0+ZG1hc2l6ZTsKCgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJZG1hYnVmLT5zd3B0ciA9IHN3cHRyOwoJCWRtYWJ1Zi0+Y291bnQgLT0gY250OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgoJCWNvdW50IC09IGNudDsKCQlidWZmZXIgKz0gY250OwoJCXJldCArPSBjbnQ7CgkJc3RhcnRfYWRjKHN0YXRlKTsKCX0Kb3V0OgoJbXV0ZXhfdW5sb2NrKCZzdGF0ZS0+c2VtKTsKCXJldHVybiByZXQ7Cn0KCi8qIGluIHRoaXMgbG9vcCwgZG1hYnVmLmNvdW50IHNpZ25pZmllcyB0aGUgYW1vdW50IG9mIGRhdGEgdGhhdCBpcyB3YWl0aW5nIHRvIGJlIGRtYSB0bwogICB0aGUgc291bmRjYXJkLiAgaXQgaXMgZHJhaW5lZCBieSB0aGUgZG1hIG1hY2hpbmUgYW5kIGZpbGxlZCBieSB0aGlzIGxvb3AuICovCgpzdGF0aWMgc3NpemVfdAp0cmlkZW50X3dyaXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqYnVmZmVyLCBzaXplX3QgY291bnQsIGxvZmZfdCAqIHBwb3MpCnsKCXN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSA9IChzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJc3NpemVfdCByZXQ7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgc3dwdHI7CglpbnQgY250OwoJdW5zaWduZWQgaW50IHN0YXRlX2NudDsKCXVuc2lnbmVkIGludCBjb3B5X2NvdW50OwoJaW50IGxyZXQ7IC8qIGZvciBsb2NrX3NldF9mbXQgKi8KCglwcl9kZWJ1ZygidHJpZGVudDogdHJpZGVudF93cml0ZSBjYWxsZWQsIGNvdW50ID0gJWRcbiIsIGNvdW50KTsKCglWQUxJREFURV9TVEFURShzdGF0ZSk7CgoJLyoKCSAqICAgICAgR3VhcmQgYWdhaW5zdCBhbiBtbWFwIG9yIGlvY3RsIHdoaWxlIHdyaXRpbmcKCSAqLwoKCW11dGV4X2xvY2soJnN0YXRlLT5zZW0pOwoKCWlmIChkbWFidWYtPm1hcHBlZCkgewoJCXJldCA9IC1FTlhJTzsKCQlnb3RvIG91dDsKCX0KCWlmICghZG1hYnVmLT5yZWFkeSAmJiAocmV0ID0gcHJvZ19kbWFidWZfcGxheWJhY2soc3RhdGUpKSkKCQlnb3RvIG91dDsKCglpZiAoIWFjY2Vzc19vayhWRVJJRllfUkVBRCwgYnVmZmVyLCBjb3VudCkpIHsKCQlyZXQgPSAtRUZBVUxUOwoJCWdvdG8gb3V0OwoJfQoKCXJldCA9IDA7CgoJd2hpbGUgKGNvdW50ID4gMCkgewoJCXNwaW5fbG9ja19pcnFzYXZlKCZzdGF0ZS0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJCWlmIChkbWFidWYtPmNvdW50IDwgMCkgewoJCQkvKiBidWZmZXIgdW5kZXJydW4sIHdlIGFyZSByZWNvdmVyaW5nIGZyb20gKi8gCgkJCS8qIHNsZWVwX29uX3RpbWVvdXQsIHJlc3luYyBod3B0ciBhbmQgc3dwdHIgKi8KCQkJZG1hYnVmLT5jb3VudCA9IDA7CgkJCWRtYWJ1Zi0+c3dwdHIgPSBkbWFidWYtPmh3cHRyOwoJCX0KCQlzd3B0ciA9IGRtYWJ1Zi0+c3dwdHI7CgkJY250ID0gZG1hYnVmLT5kbWFzaXplIC0gc3dwdHI7CgkJaWYgKGRtYWJ1Zi0+Y291bnQgKyBjbnQgPiBkbWFidWYtPmRtYXNpemUpCgkJCWNudCA9IGRtYWJ1Zi0+ZG1hc2l6ZSAtIGRtYWJ1Zi0+Y291bnQ7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCgkJaWYgKGNudCA+IGNvdW50KQoJCQljbnQgPSBjb3VudDsKCQlpZiAoY250IDw9IDApIHsKCQkJdW5zaWduZWQgbG9uZyB0bW87CgkJCS8qIGJ1ZmZlciBpcyBmdWxsLCBzdGFydCB0aGUgZG1hIG1hY2hpbmUgYW5kICovIAoJCQkvKiB3YWl0IGZvciBkYXRhIHRvIGJlIHBsYXllZCAqLwoJCQlzdGFydF9kYWMoc3RhdGUpOwoJCQlpZiAoZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spIHsKCQkJCWlmICghcmV0KQoJCQkJCXJldCA9IC1FQUdBSU47CgkJCQlnb3RvIG91dDsKCQkJfQoJCQkvKiBObyBtYXR0ZXIgaG93IG11Y2ggZGF0YSBsZWZ0IGluIHRoZSBidWZmZXIsICovIAoJCQkvKiB3ZSBoYXZlIHRvIHdhaXQgdW50aWwgQ1NPID09IEVTTy8yIG9yIENTTyA9PSBFU08gKi8gCgkJCS8qIHdoZW4gYWRkcmVzcyBlbmdpbmUgaW50ZXJydXB0cyAqLwoJCQlsb2NrX3NldF9mbXQoc3RhdGUpOwoJCQl0bW8gPSAoZG1hYnVmLT5kbWFzaXplICogSFopIC8gKGRtYWJ1Zi0+cmF0ZSAqIDIpOwoJCQl0bW8gPj49IHNhbXBsZV9zaGlmdFtkbWFidWYtPmZtdF07CgkJCXVubG9ja19zZXRfZm10KHN0YXRlKTsKCQkJbXV0ZXhfdW5sb2NrKCZzdGF0ZS0+c2VtKTsKCgkJCS8qIFRoZXJlIGFyZSB0d28gc2l0dWF0aW9ucyB3aGVuIHNsZWVwX29uX3RpbWVvdXQgKi8gCgkJCS8qIHJldHVybnMsIG9uZSBpcyB3aGVuIHRoZSBpbnRlcnJ1cHQgaXMgc2VydmljZWQgKi8gCgkJCS8qIGNvcnJlY3RseSBhbmQgdGhlIHByb2Nlc3MgaXMgd2FrZWQgdXAgYnkgSVNSICovIAoJCQkvKiBPTiBUSU1FLiBBbm90aGVyIGlzIHdoZW4gdGltZW91dCBpcyBleHBpcmVkLCB3aGljaCAqLyAKCQkJLyogbWVhbnMgdGhhdCBlaXRoZXIgaW50ZXJydXB0IGlzIE5PVCBzZXJ2aWNlZCAqLyAKCQkJLyogY29ycmVjdGx5IChwZW5kaW5nIGludGVycnVwdCkgb3IgaXQgaXMgVE9PIExBVEUgKi8gCgkJCS8qIGZvciB0aGUgcHJvY2VzcyB0byBiZSBzY2hlZHVsZWQgdG8gcnVuICovIAoJCQkvKiAoc2NoZWR1bGVyIGxhdGVuY3kpIHdoaWNoIHJlc3VsdHMgaW4gYSAocG90ZW50aWFsKSAqLyAKCQkJLyogYnVmZmVyIHVuZGVycnVuLiBBbmQgd29yc2UsIHRoZXJlIGlzIE5PVEhJTkcgd2UgKi8gCgkJCS8qIGNhbiBkbyB0byBwcmV2ZW50IGl0LiAqLwoJCQlpZiAoIWludGVycnVwdGlibGVfc2xlZXBfb25fdGltZW91dCgmZG1hYnVmLT53YWl0LCB0bW8pKSB7CgkJCQlwcl9kZWJ1ZyhLRVJOX0VSUiAidHJpZGVudDogcGxheWJhY2sgc2NoZWR1bGUgIgoJCQkJCSAidGltZW91dCwgZG1hc3ogJXUgZnJhZ3N6ICV1IGNvdW50ICVpICIKCQkJCQkgImh3cHRyICV1IHN3cHRyICV1XG4iLCBkbWFidWYtPmRtYXNpemUsCgkJCQkJIGRtYWJ1Zi0+ZnJhZ3NpemUsIGRtYWJ1Zi0+Y291bnQsCgkJCQkJIGRtYWJ1Zi0+aHdwdHIsIGRtYWJ1Zi0+c3dwdHIpOwoKCQkJCS8qIGEgYnVmZmVyIHVuZGVycnVuLCB3ZSBkZWxheSB0aGUgcmVjb3ZlcnkgKi8gCgkJCQkvKiB1bnRpbCBuZXh0IHRpbWUgdGhlIHdoaWxlIGxvb3AgYmVnaW4gYW5kICovIAoJCQkJLyogd2UgUkVBTExZIGhhdmUgZGF0YSB0byBwbGF5ICovCgkJCX0KCQkJaWYgKHNpZ25hbF9wZW5kaW5nKGN1cnJlbnQpKSB7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRVJFU1RBUlRTWVM7CgkJCQlnb3RvIG91dF9ub2xvY2s7CgkJCX0KCQkJbXV0ZXhfbG9jaygmc3RhdGUtPnNlbSk7CgkJCWlmIChkbWFidWYtPm1hcHBlZCkgewoJCQkJaWYgKCFyZXQpCgkJCQkJcmV0ID0gLUVOWElPOwoJCQkJZ290byBvdXQ7CgkJCX0KCQkJY29udGludWU7CgkJfQoJCWlmICgobHJldCA9IGxvY2tfc2V0X2ZtdChzdGF0ZSkpIDwgMCkgewoJCQlyZXQgPSBscmV0OwoJCQlnb3RvIG91dDsKCQl9CgoJCWlmIChzdGF0ZS0+Y2hhbnNfbnVtID09IDYpIHsKCQkJY29weV9jb3VudCA9IDA7CgkJCXN0YXRlX2NudCA9IDA7CgkJCWlmIChhbGlfd3JpdGVfNV8xKHN0YXRlLCBidWZmZXIsIGNudCwgJmNvcHlfY291bnQsIAoJCQkJCSAgJnN0YXRlX2NudCkgPT0gLUVGQVVMVCkgewoJCQkJaWYgKHN0YXRlX2NudCkgewoJCQkJCXN3cHRyID0gKHN3cHRyICsgc3RhdGVfY250KSAlIGRtYWJ1Zi0+ZG1hc2l6ZTsKCQkJCQlzcGluX2xvY2tfaXJxc2F2ZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCQkJCQlkbWFidWYtPnN3cHRyID0gc3dwdHI7CgkJCQkJZG1hYnVmLT5jb3VudCArPSBzdGF0ZV9jbnQ7CgkJCQkJZG1hYnVmLT5lbmRjbGVhcmVkID0gMDsKCQkJCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzdGF0ZS0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJCQkJfQoJCQkJcmV0ICs9IGNvcHlfY291bnQ7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRUZBVUxUOwoJCQkJdW5sb2NrX3NldF9mbXQoc3RhdGUpOwoJCQkJZ290byBvdXQ7CgkJCX0KCQl9IGVsc2UgewoJCQlpZiAoY29weV9mcm9tX3VzZXIoZG1hYnVmLT5yYXdidWYgKyBzd3B0ciwgCgkJCQkJICAgYnVmZmVyLCBjbnQpKSB7CgkJCQlpZiAoIXJldCkKCQkJCQlyZXQgPSAtRUZBVUxUOwoJCQkJdW5sb2NrX3NldF9mbXQoc3RhdGUpOwoJCQkJZ290byBvdXQ7CgkJCX0KCQkJc3RhdGVfY250ID0gY250OwoJCX0KCQl1bmxvY2tfc2V0X2ZtdChzdGF0ZSk7CgoJCXN3cHRyID0gKHN3cHRyICsgc3RhdGVfY250KSAlIGRtYWJ1Zi0+ZG1hc2l6ZTsKCgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJZG1hYnVmLT5zd3B0ciA9IHN3cHRyOwoJCWRtYWJ1Zi0+Y291bnQgKz0gc3RhdGVfY250OwoJCWRtYWJ1Zi0+ZW5kY2xlYXJlZCA9IDA7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCgkJY291bnQgLT0gY250OwoJCWJ1ZmZlciArPSBjbnQ7CgkJcmV0ICs9IGNudDsKCQlzdGFydF9kYWMoc3RhdGUpOwoJfQpvdXQ6CgltdXRleF91bmxvY2soJnN0YXRlLT5zZW0pOwpvdXRfbm9sb2NrOgoJcmV0dXJuIHJldDsKfQoKLyogTm8ga2VybmVsIGxvY2sgLSB3ZSBoYXZlIG91ciBvd24gc3BpbmxvY2sgKi8Kc3RhdGljIHVuc2lnbmVkIGludAp0cmlkZW50X3BvbGwoc3RydWN0IGZpbGUgKmZpbGUsIHN0cnVjdCBwb2xsX3RhYmxlX3N0cnVjdCAqd2FpdCkKewoJc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlID0gKHN0cnVjdCB0cmlkZW50X3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJc3RydWN0IGRtYWJ1ZiAqZG1hYnVmID0gJnN0YXRlLT5kbWFidWY7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJdW5zaWduZWQgaW50IG1hc2sgPSAwOwoKCVZBTElEQVRFX1NUQVRFKHN0YXRlKTsKCgkvKgoJICogICAgICBHdWFyZCBhZ2FpbnN0IGEgcGFyYWxsZWwgcG9sbCBhbmQgd3JpdGUgY2F1c2luZyBtdWx0aXBsZQoJICogICAgICBwcm9nX2RtYWJ1ZiBldmVudHMKCSAqLwoKCW11dGV4X2xvY2soJnN0YXRlLT5zZW0pOwoKCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCWlmICghZG1hYnVmLT5yZWFkeSAmJiBwcm9nX2RtYWJ1Zl9wbGF5YmFjayhzdGF0ZSkpIHsKCQkJbXV0ZXhfdW5sb2NrKCZzdGF0ZS0+c2VtKTsKCQkJcmV0dXJuIDA7CgkJfQoJCXBvbGxfd2FpdChmaWxlLCAmZG1hYnVmLT53YWl0LCB3YWl0KTsKCX0KCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJaWYgKCFkbWFidWYtPnJlYWR5ICYmIHByb2dfZG1hYnVmX3JlY29yZChzdGF0ZSkpIHsKCQkJbXV0ZXhfdW5sb2NrKCZzdGF0ZS0+c2VtKTsKCQkJcmV0dXJuIDA7CgkJfQoJCXBvbGxfd2FpdChmaWxlLCAmZG1hYnVmLT53YWl0LCB3YWl0KTsKCX0KCgltdXRleF91bmxvY2soJnN0YXRlLT5zZW0pOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZzdGF0ZS0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJdHJpZGVudF91cGRhdGVfcHRyKHN0YXRlKTsKCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJaWYgKGRtYWJ1Zi0+Y291bnQgPj0gKHNpZ25lZCkgZG1hYnVmLT5mcmFnc2l6ZSkKCQkJbWFzayB8PSBQT0xMSU4gfCBQT0xMUkROT1JNOwoJfQoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJaWYgKGRtYWJ1Zi0+bWFwcGVkKSB7CgkJCWlmIChkbWFidWYtPmNvdW50ID49IChzaWduZWQpIGRtYWJ1Zi0+ZnJhZ3NpemUpCgkJCQltYXNrIHw9IFBPTExPVVQgfCBQT0xMV1JOT1JNOwoJCX0gZWxzZSB7CgkJCWlmICgoc2lnbmVkKSBkbWFidWYtPmRtYXNpemUgPj0gZG1hYnVmLT5jb3VudCArIAoJCQkgICAgKHNpZ25lZCkgZG1hYnVmLT5mcmFnc2l6ZSkKCQkJCW1hc2sgfD0gUE9MTE9VVCB8IFBPTExXUk5PUk07CgkJfQoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCglyZXR1cm4gbWFzazsKfQoKc3RhdGljIGludAp0cmlkZW50X21tYXAoc3RydWN0IGZpbGUgKmZpbGUsIHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQp7CglzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUgPSAoc3RydWN0IHRyaWRlbnRfc3RhdGUgKilmaWxlLT5wcml2YXRlX2RhdGE7CglzdHJ1Y3QgZG1hYnVmICpkbWFidWYgPSAmc3RhdGUtPmRtYWJ1ZjsKCWludCByZXQgPSAtRUlOVkFMOwoJdW5zaWduZWQgbG9uZyBzaXplOwoKCVZBTElEQVRFX1NUQVRFKHN0YXRlKTsKCgkvKgoJICogICAgICBMb2NrIGFnYWluc3QgcG9sbCByZWFkIHdyaXRlIG9yIG1tYXAgY3JlYXRpbmcgYnVmZmVycy4gQWxzbyBsb2NrCgkgKiAgICAgIGEgcmVhZCBvciB3cml0ZSBhZ2FpbnN0IGFuIG1tYXAuCgkgKi8KCgltdXRleF9sb2NrKCZzdGF0ZS0+c2VtKTsKCglpZiAodm1hLT52bV9mbGFncyAmIFZNX1dSSVRFKSB7CgkJaWYgKChyZXQgPSBwcm9nX2RtYWJ1Zl9wbGF5YmFjayhzdGF0ZSkpICE9IDApCgkJCWdvdG8gb3V0OwoJfSBlbHNlIGlmICh2bWEtPnZtX2ZsYWdzICYgVk1fUkVBRCkgewoJCWlmICgocmV0ID0gcHJvZ19kbWFidWZfcmVjb3JkKHN0YXRlKSkgIT0gMCkKCQkJZ290byBvdXQ7Cgl9IGVsc2UKCQlnb3RvIG91dDsKCglyZXQgPSAtRUlOVkFMOwoJaWYgKHZtYS0+dm1fcGdvZmYgIT0gMCkKCQlnb3RvIG91dDsKCXNpemUgPSB2bWEtPnZtX2VuZCAtIHZtYS0+dm1fc3RhcnQ7CglpZiAoc2l6ZSA+IChQQUdFX1NJWkUgPDwgZG1hYnVmLT5idWZvcmRlcikpCgkJZ290byBvdXQ7CglyZXQgPSAtRUFHQUlOOwoJaWYgKHJlbWFwX3Bmbl9yYW5nZSh2bWEsIHZtYS0+dm1fc3RhcnQsCgkJCSAgICAgdmlydF90b19waHlzKGRtYWJ1Zi0+cmF3YnVmKSA+PiBQQUdFX1NISUZULAoJCQkgICAgIHNpemUsIHZtYS0+dm1fcGFnZV9wcm90KSkKCQlnb3RvIG91dDsKCWRtYWJ1Zi0+bWFwcGVkID0gMTsKCXJldCA9IDA7Cm91dDoKCW11dGV4X3VubG9jaygmc3RhdGUtPnNlbSk7CglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgaW50CnRyaWRlbnRfaW9jdGwoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUsIAoJICAgICAgdW5zaWduZWQgaW50IGNtZCwgdW5zaWduZWQgbG9uZyBhcmcpCnsKCXN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSA9IChzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqKWZpbGUtPnByaXZhdGVfZGF0YTsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWF1ZGlvX2J1Zl9pbmZvIGFiaW5mbzsKCWNvdW50X2luZm8gY2luZm87CglpbnQgdmFsLCBtYXBwZWQsIHJldCA9IDA7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gc3RhdGUtPmNhcmQ7Cgl2b2lkIF9fdXNlciAqYXJncCA9ICh2b2lkIF9fdXNlciAqKWFyZzsKCWludCBfX3VzZXIgKnAgPSBhcmdwOwoKCVZBTElEQVRFX1NUQVRFKHN0YXRlKTsKCgoJbWFwcGVkID0gKChmaWxlLT5mX21vZGUgJiAoRk1PREVfV1JJVEUgfCBGTU9ERV9SRUFEKSkgJiYgZG1hYnVmLT5tYXBwZWQpOwoKCXByX2RlYnVnKCJ0cmlkZW50OiB0cmlkZW50X2lvY3RsLCBjb21tYW5kID0gJTJkLCBhcmcgPSAweCUwOHhcbiIsCgkJIF9JT0NfTlIoY21kKSwgYXJnID8gKnAgOiAwKTsKCglzd2l0Y2ggKGNtZCkgewoJY2FzZSBPU1NfR0VUVkVSU0lPTjoKCQlyZXQgPSBwdXRfdXNlcihTT1VORF9WRVJTSU9OLCBwKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfUkVTRVQ6CgkJLyogRklYTUU6IHNwaW5fbG9jayA/ICovCgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJCXN0b3BfZGFjKHN0YXRlKTsKCQkJc3luY2hyb25pemVfaXJxKGNhcmQtPmlycSk7CgkJCWRtYWJ1Zi0+cmVhZHkgPSAwOwoJCQlkbWFidWYtPnN3cHRyID0gZG1hYnVmLT5od3B0ciA9IDA7CgkJCWRtYWJ1Zi0+Y291bnQgPSBkbWFidWYtPnRvdGFsX2J5dGVzID0gMDsKCQl9CgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQkJc3RvcF9hZGMoc3RhdGUpOwoJCQlzeW5jaHJvbml6ZV9pcnEoY2FyZC0+aXJxKTsKCQkJZG1hYnVmLT5yZWFkeSA9IDA7CgkJCWRtYWJ1Zi0+c3dwdHIgPSBkbWFidWYtPmh3cHRyID0gMDsKCQkJZG1hYnVmLT5jb3VudCA9IGRtYWJ1Zi0+dG90YWxfYnl0ZXMgPSAwOwoJCX0KCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfU1lOQzoKCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpCgkJCXJldCA9IGRyYWluX2RhYyhzdGF0ZSwgZmlsZS0+Zl9mbGFncyAmIE9fTk9OQkxPQ0spOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9TUEVFRDoJLyogc2V0IHNtYXBsZSByYXRlICovCgkJaWYgKGdldF91c2VyKHZhbCwgcCkpIHsKCQkJcmV0ID0gLUVGQVVMVDsKCQkJYnJlYWs7CgkJfQoJCWlmICh2YWwgPj0gMCkgewoJCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpIHsKCQkJCXN0b3BfZGFjKHN0YXRlKTsKCQkJCWRtYWJ1Zi0+cmVhZHkgPSAwOwoJCQkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJCQl0cmlkZW50X3NldF9kYWNfcmF0ZShzdGF0ZSwgdmFsKTsKCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJCX0KCQkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQkJCXN0b3BfYWRjKHN0YXRlKTsKCQkJCWRtYWJ1Zi0+cmVhZHkgPSAwOwoJCQkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJCQl0cmlkZW50X3NldF9hZGNfcmF0ZShzdGF0ZSwgdmFsKTsKCQkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJCX0KCQl9CgkJcmV0ID0gcHV0X3VzZXIoZG1hYnVmLT5yYXRlLCBwKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfU1RFUkVPOgkvKiBzZXQgc3RlcmVvIG9yIG1vbm8gY2hhbm5lbCAqLwoJCWlmIChnZXRfdXNlcih2YWwsIHApKSB7CgkJCXJldCA9IC1FRkFVTFQ7CgkJCWJyZWFrOwoJCX0KCQlpZiAoKHJldCA9IGxvY2tfc2V0X2ZtdChzdGF0ZSkpIDwgMCkKCQkJcmV0dXJuIHJldDsKCgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJCXN0b3BfZGFjKHN0YXRlKTsKCQkJZG1hYnVmLT5yZWFkeSA9IDA7CgkJCWlmICh2YWwpCgkJCQlkbWFidWYtPmZtdCB8PSBUUklERU5UX0ZNVF9TVEVSRU87CgkJCWVsc2UKCQkJCWRtYWJ1Zi0+Zm10ICY9IH5UUklERU5UX0ZNVF9TVEVSRU87CgkJfQoJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJCXN0b3BfYWRjKHN0YXRlKTsKCQkJZG1hYnVmLT5yZWFkeSA9IDA7CgkJCWlmICh2YWwpCgkJCQlkbWFidWYtPmZtdCB8PSBUUklERU5UX0ZNVF9TVEVSRU87CgkJCWVsc2UKCQkJCWRtYWJ1Zi0+Zm10ICY9IH5UUklERU5UX0ZNVF9TVEVSRU87CgkJfQoJCXVubG9ja19zZXRfZm10KHN0YXRlKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfR0VUQkxLU0laRToKCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpIHsKCQkJaWYgKCh2YWwgPSBwcm9nX2RtYWJ1Zl9wbGF5YmFjayhzdGF0ZSkpKQoJCQkJcmV0ID0gdmFsOwoJCQllbHNlCgkJCQlyZXQgPSBwdXRfdXNlcihkbWFidWYtPmZyYWdzaXplLCBwKTsKCQkJYnJlYWs7CgkJfQoJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJCWlmICgodmFsID0gcHJvZ19kbWFidWZfcmVjb3JkKHN0YXRlKSkpCgkJCQlyZXQgPSB2YWw7CgkJCWVsc2UKCQkJCXJldCA9IHB1dF91c2VyKGRtYWJ1Zi0+ZnJhZ3NpemUsIHApOwoJCQlicmVhazsKCQl9CgkJLyogbmVpdGhlciBSRUFEIG5vciBXUklURT8gaXMgdGhpcyBldmVuIHBvc3NpYmxlPyAqLwoJCXJldCA9IC1FSU5WQUw7CgkJYnJlYWs7CgoKCWNhc2UgU05EQ1RMX0RTUF9HRVRGTVRTOiAvKiBSZXR1cm5zIGEgbWFzayBvZiBzdXBwb3J0ZWQgc2FtcGxlIGZvcm1hdCAqLwoJCXJldCA9IHB1dF91c2VyKEFGTVRfUzE2X0xFIHwgQUZNVF9VMTZfTEUgfCBBRk1UX1M4IHwgCgkJCSAgICAgICBBRk1UX1U4LCBwKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfU0VURk1UOgkvKiBTZWxlY3Qgc2FtcGxlIGZvcm1hdCAqLwoJCWlmIChnZXRfdXNlcih2YWwsIHApKSB7CgkJCXJldCA9IC1FRkFVTFQ7CgkJCWJyZWFrOwoJCX0KCQlpZiAoKHJldCA9IGxvY2tfc2V0X2ZtdChzdGF0ZSkpIDwgMCkKCQkJcmV0dXJuIHJldDsKCgkJaWYgKHZhbCAhPSBBRk1UX1FVRVJZKSB7CgkJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCQkJc3RvcF9kYWMoc3RhdGUpOwoJCQkJZG1hYnVmLT5yZWFkeSA9IDA7CgkJCQlpZiAodmFsID09IEFGTVRfUzE2X0xFKQoJCQkJCWRtYWJ1Zi0+Zm10IHw9IFRSSURFTlRfRk1UXzE2QklUOwoJCQkJZWxzZQoJCQkJCWRtYWJ1Zi0+Zm10ICY9IH5UUklERU5UX0ZNVF8xNkJJVDsKCQkJfQoJCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgewoJCQkJc3RvcF9hZGMoc3RhdGUpOwoJCQkJZG1hYnVmLT5yZWFkeSA9IDA7CgkJCQlpZiAodmFsID09IEFGTVRfUzE2X0xFKQoJCQkJCWRtYWJ1Zi0+Zm10IHw9IFRSSURFTlRfRk1UXzE2QklUOwoJCQkJZWxzZQoJCQkJCWRtYWJ1Zi0+Zm10ICY9IH5UUklERU5UX0ZNVF8xNkJJVDsKCQkJfQoJCX0KCQl1bmxvY2tfc2V0X2ZtdChzdGF0ZSk7CgkJcmV0ID0gcHV0X3VzZXIoKGRtYWJ1Zi0+Zm10ICYgVFJJREVOVF9GTVRfMTZCSVQpID8gQUZNVF9TMTZfTEUgOiAKCQkJICAgICAgIEFGTVRfVTgsIHApOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9DSEFOTkVMUzoKCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkgewoJCQlyZXQgPSAtRUZBVUxUOwoJCQlicmVhazsKCQl9CgkJaWYgKHZhbCAhPSAwKSB7CgkJCWlmICgocmV0ID0gbG9ja19zZXRfZm10KHN0YXRlKSkgPCAwKQoJCQkJcmV0dXJuIHJldDsKCgkJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkgewoJCQkJc3RvcF9kYWMoc3RhdGUpOwoJCQkJZG1hYnVmLT5yZWFkeSA9IDA7CgoJCQkJLy9wcmV2ZW50IGZyb20gbWVtb3J5IGxlYWsKCQkJCWlmICgoc3RhdGUtPmNoYW5zX251bSA+IDIpICYmIChzdGF0ZS0+Y2hhbnNfbnVtICE9IHZhbCkpIHsKCQkJCQlhbGlfZnJlZV9vdGhlcl9zdGF0ZXNfcmVzb3VyY2VzKHN0YXRlKTsKCQkJCQlzdGF0ZS0+Y2hhbnNfbnVtID0gMTsKCQkJCX0KCgkJCQlpZiAodmFsID49IDIpIHsKCgkJCQkJZG1hYnVmLT5mbXQgfD0gVFJJREVOVF9GTVRfU1RFUkVPOwoJCQkJCWlmICgodmFsID09IDYpICYmIChzdGF0ZS0+Y2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfQUxJXzU0NTEpKSB7CgkJCQkJCWlmIChjYXJkLT5yZWNfY2hhbm5lbF91c2VfY291bnQgPiAwKSB7CgkJCQkJCQlwcmludGsoS0VSTl9FUlIgInRyaWRlbnQ6IFJlY29yZCBpcyAiCgkJCQkJCQkgICAgICAgIndvcmtpbmcgb24gdGhlIGNhcmQhXG4iKTsKCQkJCQkJCXJldCA9IC1FQlVTWTsKCQkJCQkJCXVubG9ja19zZXRfZm10KHN0YXRlKTsKCQkJCQkJCWJyZWFrOwoJCQkJCQl9CgoJCQkJCQlyZXQgPSBhbGlfc2V0dXBfbXVsdGlfY2hhbm5lbHMoc3RhdGUtPmNhcmQsIDYpOwoJCQkJCQlpZiAocmV0IDwgMCkgewoJCQkJCQkJdW5sb2NrX3NldF9mbXQoc3RhdGUpOwoJCQkJCQkJYnJlYWs7CgkJCQkJCX0KCQkJCQkJbXV0ZXhfbG9jaygmc3RhdGUtPmNhcmQtPm9wZW5fbXV0ZXgpOwoJCQkJCQlyZXQgPSBhbGlfYWxsb2NhdGVfb3RoZXJfc3RhdGVzX3Jlc291cmNlcyhzdGF0ZSwgNik7CgkJCQkJCWlmIChyZXQgPCAwKSB7CgkJCQkJCQltdXRleF91bmxvY2soJnN0YXRlLT5jYXJkLT5vcGVuX211dGV4KTsKCQkJCQkJCXVubG9ja19zZXRfZm10KHN0YXRlKTsKCQkJCQkJCWJyZWFrOwoJCQkJCQl9CgkJCQkJCXN0YXRlLT5jYXJkLT5tdWx0aV9jaGFubmVsX3VzZV9jb3VudCsrOwoJCQkJCQltdXRleF91bmxvY2soJnN0YXRlLT5jYXJkLT5vcGVuX211dGV4KTsKCQkJCQl9IGVsc2UKCQkJCQkJdmFsID0gMjsJLyp5aWVsZCB0byAyLWNoYW5uZWxzICovCgkJCQl9IGVsc2UKCQkJCQlkbWFidWYtPmZtdCAmPSB+VFJJREVOVF9GTVRfU1RFUkVPOwoJCQkJc3RhdGUtPmNoYW5zX251bSA9IHZhbDsKCQkJfQoJCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgewoJCQkJc3RvcF9hZGMoc3RhdGUpOwoJCQkJZG1hYnVmLT5yZWFkeSA9IDA7CgkJCQlpZiAodmFsID49IDIpIHsKCQkJCQlpZiAoISgoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpICYmIAoJCQkJCSAgICAgICh2YWwgPT0gNikpKQoJCQkJCQl2YWwgPSAyOwoJCQkJCWRtYWJ1Zi0+Zm10IHw9IFRSSURFTlRfRk1UX1NURVJFTzsKCQkJCX0gZWxzZQoJCQkJCWRtYWJ1Zi0+Zm10ICY9IH5UUklERU5UX0ZNVF9TVEVSRU87CgkJCQlzdGF0ZS0+Y2hhbnNfbnVtID0gdmFsOwoJCQl9CgkJCXVubG9ja19zZXRfZm10KHN0YXRlKTsKCQl9CgkJcmV0ID0gcHV0X3VzZXIodmFsLCBwKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfUE9TVDoKCQkvKiBDYXVzZSB0aGUgd29ya2luZyBmcmFnbWVudCB0byBiZSBvdXRwdXQgKi8KCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfU1VCRElWSURFOgoJCWlmIChkbWFidWYtPnN1YmRpdmlzaW9uKSB7CgkJCXJldCA9IC1FSU5WQUw7CgkJCWJyZWFrOwoJCX0KCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkgewoJCQlyZXQgPSAtRUZBVUxUOwoJCQlicmVhazsKCQl9CgkJaWYgKHZhbCAhPSAxICYmIHZhbCAhPSAyICYmIHZhbCAhPSA0KSB7CgkJCXJldCA9IC1FSU5WQUw7CgkJCWJyZWFrOwoJCX0KCQlkbWFidWYtPnN1YmRpdmlzaW9uID0gdmFsOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9TRVRGUkFHTUVOVDoKCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkgewoJCQlyZXQgPSAtRUZBVUxUOwoJCQlicmVhazsKCQl9CgoJCWRtYWJ1Zi0+b3NzZnJhZ3NoaWZ0ID0gdmFsICYgMHhmZmZmOwoJCWRtYWJ1Zi0+b3NzbWF4ZnJhZ3MgPSAodmFsID4+IDE2KSAmIDB4ZmZmZjsKCQlpZiAoZG1hYnVmLT5vc3NmcmFnc2hpZnQgPCA0KQoJCQlkbWFidWYtPm9zc2ZyYWdzaGlmdCA9IDQ7CgkJaWYgKGRtYWJ1Zi0+b3NzZnJhZ3NoaWZ0ID4gMTUpCgkJCWRtYWJ1Zi0+b3NzZnJhZ3NoaWZ0ID0gMTU7CgkJaWYgKGRtYWJ1Zi0+b3NzbWF4ZnJhZ3MgPCA0KQoJCQlkbWFidWYtPm9zc21heGZyYWdzID0gNDsKCgkJYnJlYWs7CgoJY2FzZSBTTkRDVExfRFNQX0dFVE9TUEFDRToKCQlpZiAoIShmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkpIHsKCQkJcmV0ID0gLUVJTlZBTDsKCQkJYnJlYWs7CgkJfQoJCWlmICghZG1hYnVmLT5yZWFkeSAmJiAodmFsID0gcHJvZ19kbWFidWZfcGxheWJhY2soc3RhdGUpKSAhPSAwKSB7CgkJCXJldCA9IHZhbDsKCQkJYnJlYWs7CgkJfQoJCXNwaW5fbG9ja19pcnFzYXZlKCZzdGF0ZS0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJCXRyaWRlbnRfdXBkYXRlX3B0cihzdGF0ZSk7CgkJYWJpbmZvLmZyYWdzaXplID0gZG1hYnVmLT5mcmFnc2l6ZTsKCQlhYmluZm8uYnl0ZXMgPSBkbWFidWYtPmRtYXNpemUgLSBkbWFidWYtPmNvdW50OwoJCWFiaW5mby5mcmFnc3RvdGFsID0gZG1hYnVmLT5udW1mcmFnOwoJCWFiaW5mby5mcmFnbWVudHMgPSBhYmluZm8uYnl0ZXMgPj4gZG1hYnVmLT5mcmFnc2hpZnQ7CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCQlyZXQgPSBjb3B5X3RvX3VzZXIoYXJncCwgJmFiaW5mbywgc2l6ZW9mIChhYmluZm8pKSA/IAoJCQktRUZBVUxUIDogMDsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfR0VUSVNQQUNFOgoJCWlmICghKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpKSB7CgkJCXJldCA9IC1FSU5WQUw7CgkJCWJyZWFrOwoJCX0KCQlpZiAoIWRtYWJ1Zi0+cmVhZHkgJiYgKHZhbCA9IHByb2dfZG1hYnVmX3JlY29yZChzdGF0ZSkpICE9IDApIHsKCQkJcmV0ID0gdmFsOwoJCQlicmVhazsKCQl9CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJdHJpZGVudF91cGRhdGVfcHRyKHN0YXRlKTsKCQlhYmluZm8uZnJhZ3NpemUgPSBkbWFidWYtPmZyYWdzaXplOwoJCWFiaW5mby5ieXRlcyA9IGRtYWJ1Zi0+Y291bnQ7CgkJYWJpbmZvLmZyYWdzdG90YWwgPSBkbWFidWYtPm51bWZyYWc7CgkJYWJpbmZvLmZyYWdtZW50cyA9IGFiaW5mby5ieXRlcyA+PiBkbWFidWYtPmZyYWdzaGlmdDsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzdGF0ZS0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJCXJldCA9IGNvcHlfdG9fdXNlcihhcmdwLCAmYWJpbmZvLCBzaXplb2YgKGFiaW5mbykpID8gCgkJCS1FRkFVTFQgOiAwOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9OT05CTE9DSzoKCQlmaWxlLT5mX2ZsYWdzIHw9IE9fTk9OQkxPQ0s7CgkJYnJlYWs7CgoJY2FzZSBTTkRDVExfRFNQX0dFVENBUFM6CgkJcmV0ID0gcHV0X3VzZXIoRFNQX0NBUF9SRUFMVElNRSB8IERTUF9DQVBfVFJJR0dFUiB8IAoJCQkgICAgICAgRFNQX0NBUF9NTUFQIHwgRFNQX0NBUF9CSU5ELCBwKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfR0VUVFJJR0dFUjoKCQl2YWwgPSAwOwoJCWlmICgoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgJiYgZG1hYnVmLT5lbmFibGUpCgkJCXZhbCB8PSBQQ01fRU5BQkxFX0lOUFVUOwoJCWlmICgoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpICYmIGRtYWJ1Zi0+ZW5hYmxlKQoJCQl2YWwgfD0gUENNX0VOQUJMRV9PVVRQVVQ7CgkJcmV0ID0gcHV0X3VzZXIodmFsLCBwKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfU0VUVFJJR0dFUjoKCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkgewoJCQlyZXQgPSAtRUZBVUxUOwoJCQlicmVhazsKCQl9CgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQkJaWYgKHZhbCAmIFBDTV9FTkFCTEVfSU5QVVQpIHsKCQkJCWlmICghZG1hYnVmLT5yZWFkeSAmJiAKCQkJCSAgICAocmV0ID0gcHJvZ19kbWFidWZfcmVjb3JkKHN0YXRlKSkpCgkJCQkJYnJlYWs7CgkJCQlzdGFydF9hZGMoc3RhdGUpOwoJCQl9IGVsc2UKCQkJCXN0b3BfYWRjKHN0YXRlKTsKCQl9CgkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJCWlmICh2YWwgJiBQQ01fRU5BQkxFX09VVFBVVCkgewoJCQkJaWYgKCFkbWFidWYtPnJlYWR5ICYmIAoJCQkJICAgIChyZXQgPSBwcm9nX2RtYWJ1Zl9wbGF5YmFjayhzdGF0ZSkpKQoJCQkJCWJyZWFrOwoJCQkJc3RhcnRfZGFjKHN0YXRlKTsKCQkJfSBlbHNlCgkJCQlzdG9wX2RhYyhzdGF0ZSk7CgkJfQoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9HRVRJUFRSOgoJCWlmICghKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpKSB7CgkJCXJldCA9IC1FSU5WQUw7CgkJCWJyZWFrOwoJCX0KCQlpZiAoIWRtYWJ1Zi0+cmVhZHkgJiYgKHZhbCA9IHByb2dfZG1hYnVmX3JlY29yZChzdGF0ZSkpCgkJICAgICE9IDApIHsKCQkJcmV0ID0gdmFsOwoJCQlicmVhazsKCQl9CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJdHJpZGVudF91cGRhdGVfcHRyKHN0YXRlKTsKCQljaW5mby5ieXRlcyA9IGRtYWJ1Zi0+dG90YWxfYnl0ZXM7CgkJY2luZm8uYmxvY2tzID0gZG1hYnVmLT5jb3VudCA+PiBkbWFidWYtPmZyYWdzaGlmdDsKCQljaW5mby5wdHIgPSBkbWFidWYtPmh3cHRyOwoJCWlmIChkbWFidWYtPm1hcHBlZCkKCQkJZG1hYnVmLT5jb3VudCAmPSBkbWFidWYtPmZyYWdzaXplIC0gMTsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZzdGF0ZS0+Y2FyZC0+bG9jaywgZmxhZ3MpOwoJCXJldCA9IGNvcHlfdG9fdXNlcihhcmdwLCAmY2luZm8sIHNpemVvZiAoY2luZm8pKSA/IAoJCQktRUZBVUxUIDogMDsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfR0VUT1BUUjoKCQlpZiAoIShmaWxlLT5mX21vZGUgJiBGTU9ERV9XUklURSkpIHsKCQkJcmV0ID0gLUVJTlZBTDsKCQkJYnJlYWs7CgkJfQoJCWlmICghZG1hYnVmLT5yZWFkeSAmJiAodmFsID0gcHJvZ19kbWFidWZfcGxheWJhY2soc3RhdGUpKQoJCSAgICAhPSAwKSB7CgkJCXJldCA9IHZhbDsKCQkJYnJlYWs7CgkJfQoKCQlzcGluX2xvY2tfaXJxc2F2ZSgmc3RhdGUtPmNhcmQtPmxvY2ssIGZsYWdzKTsKCQl0cmlkZW50X3VwZGF0ZV9wdHIoc3RhdGUpOwoJCWNpbmZvLmJ5dGVzID0gZG1hYnVmLT50b3RhbF9ieXRlczsKCQljaW5mby5ibG9ja3MgPSBkbWFidWYtPmNvdW50ID4+IGRtYWJ1Zi0+ZnJhZ3NoaWZ0OwoJCWNpbmZvLnB0ciA9IGRtYWJ1Zi0+aHdwdHI7CgkJaWYgKGRtYWJ1Zi0+bWFwcGVkKQoJCQlkbWFidWYtPmNvdW50ICY9IGRtYWJ1Zi0+ZnJhZ3NpemUgLSAxOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJcmV0ID0gY29weV90b191c2VyKGFyZ3AsICZjaW5mbywgc2l6ZW9mIChjaW5mbykpID8gCgkJCS1FRkFVTFQgOiAwOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9TRVREVVBMRVg6CgkJcmV0ID0gLUVJTlZBTDsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfR0VUT0RFTEFZOgoJCWlmICghKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSkgewoJCQlyZXQgPSAtRUlOVkFMOwoJCQlicmVhazsKCQl9CgkJaWYgKCFkbWFidWYtPnJlYWR5ICYmICh2YWwgPSBwcm9nX2RtYWJ1Zl9wbGF5YmFjayhzdGF0ZSkpICE9IDApIHsKCQkJcmV0ID0gdmFsOwoJCQlicmVhazsKCQl9CgkJc3Bpbl9sb2NrX2lycXNhdmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJdHJpZGVudF91cGRhdGVfcHRyKHN0YXRlKTsKCQl2YWwgPSBkbWFidWYtPmNvdW50OwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnN0YXRlLT5jYXJkLT5sb2NrLCBmbGFncyk7CgkJcmV0ID0gcHV0X3VzZXIodmFsLCBwKTsKCQlicmVhazsKCgljYXNlIFNPVU5EX1BDTV9SRUFEX1JBVEU6CgkJcmV0ID0gcHV0X3VzZXIoZG1hYnVmLT5yYXRlLCBwKTsKCQlicmVhazsKCgljYXNlIFNPVU5EX1BDTV9SRUFEX0NIQU5ORUxTOgoJCXJldCA9IHB1dF91c2VyKChkbWFidWYtPmZtdCAmIFRSSURFTlRfRk1UX1NURVJFTykgPyAyIDogMSwgCgkJCSAgICAgICBwKTsKCQlicmVhazsKCgljYXNlIFNPVU5EX1BDTV9SRUFEX0JJVFM6CgkJcmV0ID0gcHV0X3VzZXIoKGRtYWJ1Zi0+Zm10ICYgVFJJREVOVF9GTVRfMTZCSVQpID8gQUZNVF9TMTZfTEUgOiAKCQkJICAgICAgIEFGTVRfVTgsIHApOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9HRVRDSEFOTkVMTUFTSzoKCQlyZXQgPSBwdXRfdXNlcihEU1BfQklORF9GUk9OVCB8IERTUF9CSU5EX1NVUlIgfCAKCQkJICAgICAgIERTUF9CSU5EX0NFTlRFUl9MRkUsICBwKTsKCQlicmVhazsKCgljYXNlIFNORENUTF9EU1BfQklORF9DSEFOTkVMOgoJCWlmIChzdGF0ZS0+Y2FyZC0+cGNpX2lkICE9IFBDSV9ERVZJQ0VfSURfU0lfNzAxOCkgewoJCQlyZXQgPSAtRUlOVkFMOwoJCQlicmVhazsKCQl9CgoJCWlmIChnZXRfdXNlcih2YWwsIHApKSB7CgkJCXJldCA9IC1FRkFVTFQ7CgkJCWJyZWFrOwoJCX0KCQlpZiAodmFsID09IERTUF9CSU5EX1FVRVJZKSB7CgkJCXZhbCA9IGRtYWJ1Zi0+Y2hhbm5lbC0+YXR0cmlidXRlIHwgMHgzYzAwOwoJCQl2YWwgPSBhdHRyMm1hc2tbdmFsID4+IDhdOwoJCX0gZWxzZSB7CgkJCWRtYWJ1Zi0+cmVhZHkgPSAwOwoJCQlpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkKCQkJCWRtYWJ1Zi0+Y2hhbm5lbC0+YXR0cmlidXRlID0gKENIQU5ORUxfUkVDIHwgCgkJCQkJCQkgICAgICBTUkNfRU5BQkxFKTsKCQkJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKQoJCQkJZG1hYnVmLT5jaGFubmVsLT5hdHRyaWJ1dGUgPSAoQ0hBTk5FTF9TUENfUEIgfCAKCQkJCQkJCSAgICAgIFNSQ19FTkFCTEUpOwoJCQlkbWFidWYtPmNoYW5uZWwtPmF0dHJpYnV0ZSB8PSBtYXNrMmF0dHJbZmZzKHZhbCldOwoJCX0KCQlyZXQgPSBwdXRfdXNlcih2YWwsIHApOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9NQVBJTkJVRjoKCWNhc2UgU05EQ1RMX0RTUF9NQVBPVVRCVUY6CgljYXNlIFNORENUTF9EU1BfU0VUU1lOQ1JPOgoJY2FzZSBTT1VORF9QQ01fV1JJVEVfRklMVEVSOgoJY2FzZSBTT1VORF9QQ01fUkVBRF9GSUxURVI6CglkZWZhdWx0OgoJCXJldCA9IC1FSU5WQUw7CgkJYnJlYWs7CgoJfQoJcmV0dXJuIHJldDsKfQoKc3RhdGljIGludAp0cmlkZW50X29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCWludCBpID0gMDsKCWludCBtaW5vciA9IGltaW5vcihpbm9kZSk7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gZGV2czsKCXN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSA9IE5VTEw7CglzdHJ1Y3QgZG1hYnVmICpkbWFidWYgPSBOVUxMOwoKCS8qIEFkZGVkIGJ5IE1hdHQgV3UgMDEtMDUtMjAwMSAqLwoJLyogVE9ETzogdGhlcmUncyBzb21lIHJlZHVuZGFjeSBoZXJlIHdydCB0aGUgY2hlY2sgYmVsb3cgKi8KCS8qIGZvciBtdWx0aV91c2VfY291bnQgPiAwLiBTaG91bGQgd2UgcmV0dXJuIC1FQlVTWSBvciBmaW5kICovCgkvKiBhIGRpZmZlcmVudCBjYXJkPyBmb3Igbm93LCBkb24ndCBicmVhayBjdXJyZW50IGJlaGF2aW91ciAqLwoJLyogLS0gbXVsaXggKi8KCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJaWYgKGNhcmQtPnBjaV9pZCA9PSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKSB7CgkJCWlmIChjYXJkLT5tdWx0aV9jaGFubmVsX3VzZV9jb3VudCA+IDApCgkJCQlyZXR1cm4gLUVCVVNZOwoJCX0KCX0KCgkvKiBmaW5kIGFuIGF2YWlsYWJsZSB2aXJ0dWFsIGNoYW5uZWwgKGluc3RhbmNlIG9mIC9kZXYvZHNwKSAqLwoJd2hpbGUgKGNhcmQgIT0gTlVMTCkgewoJCW11dGV4X2xvY2soJmNhcmQtPm9wZW5fbXV0ZXgpOwoJCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKSB7CgkJCS8qIFNraXAgb3BlbnMgb24gY2FyZHMgdGhhdCBhcmUgaW4gNiBjaGFubmVsIG1vZGUgKi8KCQkJaWYgKGNhcmQtPm11bHRpX2NoYW5uZWxfdXNlX2NvdW50ID4gMCkgewoJCQkJbXV0ZXhfdW5sb2NrKCZjYXJkLT5vcGVuX211dGV4KTsKCQkJCWNhcmQgPSBjYXJkLT5uZXh0OwoJCQkJY29udGludWU7CgkJCX0KCQl9CgkJZm9yIChpID0gMDsgaSA8IE5SX0hXX0NIOyBpKyspIHsKCQkJaWYgKGNhcmQtPnN0YXRlc1tpXSA9PSBOVUxMKSB7CgkJCQlzdGF0ZSA9IGNhcmQtPnN0YXRlc1tpXSA9IGttYWxsb2Moc2l6ZW9mKCpzdGF0ZSksIEdGUF9LRVJORUwpOwoJCQkJaWYgKHN0YXRlID09IE5VTEwpIHsKCQkJCQltdXRleF91bmxvY2soJmNhcmQtPm9wZW5fbXV0ZXgpOwoJCQkJCXJldHVybiAtRU5PTUVNOwoJCQkJfQoJCQkJbWVtc2V0KHN0YXRlLCAwLCBzaXplb2YoKnN0YXRlKSk7CgkJCQltdXRleF9pbml0KCZzdGF0ZS0+c2VtKTsKCQkJCWRtYWJ1ZiA9ICZzdGF0ZS0+ZG1hYnVmOwoJCQkJZ290byBmb3VuZF92aXJ0OwoJCQl9CgkJfQoJCW11dGV4X3VubG9jaygmY2FyZC0+b3Blbl9tdXRleCk7CgkJY2FyZCA9IGNhcmQtPm5leHQ7Cgl9CgkvKiBubyBtb3JlIHZpcnR1YWwgY2hhbm5lbCBhdmFpYWJsZSAqLwoJaWYgKCFzdGF0ZSkgewoJCXJldHVybiAtRU5PREVWOwoJfQogICAgICBmb3VuZF92aXJ0OgoJLyogZm91bmQgYSBmcmVlIHZpcnR1YWwgY2hhbm5lbCwgYWxsb2NhdGUgaGFyZHdhcmUgY2hhbm5lbHMgKi8KCWlmIChmaWxlLT5mX21vZGUgJiBGTU9ERV9SRUFEKQoJCWRtYWJ1Zi0+Y2hhbm5lbCA9IGNhcmQtPmFsbG9jX3JlY19wY21fY2hhbm5lbChjYXJkKTsKCWVsc2UKCQlkbWFidWYtPmNoYW5uZWwgPSBjYXJkLT5hbGxvY19wY21fY2hhbm5lbChjYXJkKTsKCglpZiAoZG1hYnVmLT5jaGFubmVsID09IE5VTEwpIHsKCQlrZnJlZShjYXJkLT5zdGF0ZXNbaV0pOwoJCWNhcmQtPnN0YXRlc1tpXSA9IE5VTEw7CgkJcmV0dXJuIC1FTk9ERVY7Cgl9CgoJLyogaW5pdGlhbGl6ZSB0aGUgdmlydHVhbCBjaGFubmVsICovCglzdGF0ZS0+dmlydCA9IGk7CglzdGF0ZS0+Y2FyZCA9IGNhcmQ7CglzdGF0ZS0+bWFnaWMgPSBUUklERU5UX1NUQVRFX01BR0lDOwoJaW5pdF93YWl0cXVldWVfaGVhZCgmZG1hYnVmLT53YWl0KTsKCWZpbGUtPnByaXZhdGVfZGF0YSA9IHN0YXRlOwoKCS8qIHNldCBkZWZhdWx0IHNhbXBsZSBmb3JtYXQuIEFjY29yZGluZyB0byBPU1MgUHJvZ3JhbW1lcidzICovIAoJLyogR3VpZGUgIC9kZXYvZHNwIHNob3VsZCBiZSBkZWZhdWx0IHRvIHVuc2lnbmVkIDgtYml0cywgbW9ubywgKi8gCgkvKiB3aXRoIHNhbXBsZSByYXRlIDhrSHogYW5kIC9kZXYvZHNwVyB3aWxsIGFjY2VwdCAxNi1iaXRzIHNhbXBsZSAqLwoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJZG1hYnVmLT5mbXQgJj0gflRSSURFTlRfRk1UX01BU0s7CgkJaWYgKChtaW5vciAmIDB4MGYpID09IFNORF9ERVZfRFNQMTYpCgkJCWRtYWJ1Zi0+Zm10IHw9IFRSSURFTlRfRk1UXzE2QklUOwoJCWRtYWJ1Zi0+b3NzZnJhZ3NoaWZ0ID0gMDsKCQlkbWFidWYtPm9zc21heGZyYWdzID0gMDsKCQlkbWFidWYtPnN1YmRpdmlzaW9uID0gMDsKCQlpZiAoY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfU0lfNzAxOCkgewoJCQkvKiBzZXQgZGVmYXVsdCBjaGFubmVsIGF0dHJpYnV0ZSB0byBub3JtYWwgcGxheWJhY2sgKi8KCQkJZG1hYnVmLT5jaGFubmVsLT5hdHRyaWJ1dGUgPSBDSEFOTkVMX1BCOwoJCX0KCQl0cmlkZW50X3NldF9kYWNfcmF0ZShzdGF0ZSwgODAwMCk7Cgl9CgoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1JFQUQpIHsKCQkvKiBGSVhNRTogVHJpZGVudCA0ZCBjYW4gb25seSByZWNvcmQgaW4gc2lnbmVkIDE2LWJpdHMgc3RlcmVvLCAqLyAKCQkvKiA0OGtIeiBzYW1wbGUsIHRvIGJlIGRlYWxlZCB3aXRoIGluIHRyaWRlbnRfc2V0X2FkY19yYXRlKCkgPz8gKi8KCQlkbWFidWYtPmZtdCAmPSB+VFJJREVOVF9GTVRfTUFTSzsKCQlpZiAoKG1pbm9yICYgMHgwZikgPT0gU05EX0RFVl9EU1AxNikKCQkJZG1hYnVmLT5mbXQgfD0gVFJJREVOVF9GTVRfMTZCSVQ7CgkJZG1hYnVmLT5vc3NmcmFnc2hpZnQgPSAwOwoJCWRtYWJ1Zi0+b3NzbWF4ZnJhZ3MgPSAwOwoJCWRtYWJ1Zi0+c3ViZGl2aXNpb24gPSAwOwoJCWlmIChjYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9TSV83MDE4KSB7CgkJCS8qIHNldCBkZWZhdWx0IGNoYW5uZWwgYXR0cmlidXRlIHRvIDB4OGE4MCwgcmVjb3JkIGZyb20KCQkJICAgUENNIEwvUiBGSUZPIGFuZCBtb25vID0gKGxlZnQgKyByaWdodCArIDEpLzIgKi8KCQkJZG1hYnVmLT5jaGFubmVsLT5hdHRyaWJ1dGUgPSAoQ0hBTk5FTF9SRUMgfCBQQ01fTFIgfCAKCQkJCQkJICAgICAgTU9OT19NSVgpOwoJCX0KCQl0cmlkZW50X3NldF9hZGNfcmF0ZShzdGF0ZSwgODAwMCk7CgoJCS8qIEFkZGVkIGJ5IE1hdHQgV3UgMDEtMDUtMjAwMSAqLwoJCWlmIChjYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSkKCQkJY2FyZC0+cmVjX2NoYW5uZWxfdXNlX2NvdW50Kys7Cgl9CgoJc3RhdGUtPm9wZW5fbW9kZSB8PSBmaWxlLT5mX21vZGUgJiAoRk1PREVfUkVBRCB8IEZNT0RFX1dSSVRFKTsKCW11dGV4X3VubG9jaygmY2FyZC0+b3Blbl9tdXRleCk7CgoJcHJfZGVidWcoInRyaWRlbnQ6IG9wZW4gdmlydHVhbCBjaGFubmVsICVkLCBoYXJkIGNoYW5uZWwgJWRcbiIsCgkJIHN0YXRlLT52aXJ0LCBkbWFidWYtPmNoYW5uZWwtPm51bSk7CgoJcmV0dXJuIG5vbnNlZWthYmxlX29wZW4oaW5vZGUsIGZpbGUpOwp9CgpzdGF0aWMgaW50CnRyaWRlbnRfcmVsZWFzZShzdHJ1Y3QgaW5vZGUgKmlub2RlLCBzdHJ1Y3QgZmlsZSAqZmlsZSkKewoJc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlID0gKHN0cnVjdCB0cmlkZW50X3N0YXRlICopZmlsZS0+cHJpdmF0ZV9kYXRhOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZDsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1ZjsKCglWQUxJREFURV9TVEFURShzdGF0ZSk7CgoJY2FyZCA9IHN0YXRlLT5jYXJkOwoJZG1hYnVmID0gJnN0YXRlLT5kbWFidWY7CgoJaWYgKGZpbGUtPmZfbW9kZSAmIEZNT0RFX1dSSVRFKSB7CgkJdHJpZGVudF9jbGVhcl90YWlsKHN0YXRlKTsKCQlkcmFpbl9kYWMoc3RhdGUsIGZpbGUtPmZfZmxhZ3MgJiBPX05PTkJMT0NLKTsKCX0KCglwcl9kZWJ1ZygidHJpZGVudDogY2xvc2luZyB2aXJ0dWFsIGNoYW5uZWwgJWQsIGhhcmQgY2hhbm5lbCAlZFxuIiwKCQkgc3RhdGUtPnZpcnQsIGRtYWJ1Zi0+Y2hhbm5lbC0+bnVtKTsKCgkvKiBzdG9wIERNQSBzdGF0ZSBtYWNoaW5lIGFuZCBmcmVlIERNQSBidWZmZXJzL2NoYW5uZWxzICovCgltdXRleF9sb2NrKCZjYXJkLT5vcGVuX211dGV4KTsKCglpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfV1JJVEUpIHsKCQlzdG9wX2RhYyhzdGF0ZSk7CgkJZGVhbGxvY19kbWFidWYoJnN0YXRlLT5kbWFidWYsIHN0YXRlLT5jYXJkLT5wY2lfZGV2KTsKCQlzdGF0ZS0+Y2FyZC0+ZnJlZV9wY21fY2hhbm5lbChzdGF0ZS0+Y2FyZCwgZG1hYnVmLT5jaGFubmVsLT5udW0pOwoKCQkvKiBBZGRlZCBieSBNYXR0IFd1ICovCgkJaWYgKGNhcmQtPnBjaV9pZCA9PSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKSB7CgkJCWlmIChzdGF0ZS0+Y2hhbnNfbnVtID4gMikgewoJCQkJaWYgKGNhcmQtPm11bHRpX2NoYW5uZWxfdXNlX2NvdW50LS0gPCAwKQoJCQkJCWNhcmQtPm11bHRpX2NoYW5uZWxfdXNlX2NvdW50ID0gMDsKCQkJCWlmIChjYXJkLT5tdWx0aV9jaGFubmVsX3VzZV9jb3VudCA9PSAwKQoJCQkJCWFsaV9jbG9zZV9tdWx0aV9jaGFubmVscygpOwoJCQkJYWxpX2ZyZWVfb3RoZXJfc3RhdGVzX3Jlc291cmNlcyhzdGF0ZSk7CgkJCX0KCQl9Cgl9CglpZiAoZmlsZS0+Zl9tb2RlICYgRk1PREVfUkVBRCkgewoJCXN0b3BfYWRjKHN0YXRlKTsKCQlkZWFsbG9jX2RtYWJ1Zigmc3RhdGUtPmRtYWJ1Ziwgc3RhdGUtPmNhcmQtPnBjaV9kZXYpOwoJCXN0YXRlLT5jYXJkLT5mcmVlX3BjbV9jaGFubmVsKHN0YXRlLT5jYXJkLCBkbWFidWYtPmNoYW5uZWwtPm51bSk7CgoJCS8qIEFkZGVkIGJ5IE1hdHQgV3UgKi8KCQlpZiAoY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfQUxJXzU0NTEpIHsKCQkJaWYgKGNhcmQtPnJlY19jaGFubmVsX3VzZV9jb3VudC0tIDwgMCkKCQkJCWNhcmQtPnJlY19jaGFubmVsX3VzZV9jb3VudCA9IDA7CgkJfQoJfQoKCWNhcmQtPnN0YXRlc1tzdGF0ZS0+dmlydF0gPSBOVUxMOwoJa2ZyZWUoc3RhdGUpOwoKCS8qIHdlJ3JlIGNvdmVyZWQgYnkgdGhlIG9wZW5fbXV0ZXggKi8KCW11dGV4X3VubG9jaygmY2FyZC0+b3Blbl9tdXRleCk7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyAvKmNvbnN0ICovIHN0cnVjdCBmaWxlX29wZXJhdGlvbnMgdHJpZGVudF9hdWRpb19mb3BzID0gewoJLm93bmVyID0gVEhJU19NT0RVTEUsCgkubGxzZWVrID0gbm9fbGxzZWVrLAoJLnJlYWQgPSB0cmlkZW50X3JlYWQsCgkud3JpdGUgPSB0cmlkZW50X3dyaXRlLAoJLnBvbGwgPSB0cmlkZW50X3BvbGwsCgkuaW9jdGwgPSB0cmlkZW50X2lvY3RsLAoJLm1tYXAgPSB0cmlkZW50X21tYXAsCgkub3BlbiA9IHRyaWRlbnRfb3BlbiwKCS5yZWxlYXNlID0gdHJpZGVudF9yZWxlYXNlLAp9OwoKLyogdHJpZGVudCBzcGVjaWZpYyBBQzk3IGZ1bmN0aW9ucyAqLwovKiBXcml0ZSBBQzk3IGNvZGVjIHJlZ2lzdGVycyAqLwpzdGF0aWMgdm9pZAp0cmlkZW50X2FjOTdfc2V0KHN0cnVjdCBhYzk3X2NvZGVjICpjb2RlYywgdTggcmVnLCB1MTYgdmFsKQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gKHN0cnVjdCB0cmlkZW50X2NhcmQgKiljb2RlYy0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgaW50IGFkZHJlc3MsIG1hc2ssIGJ1c3k7Cgl1bnNpZ25lZCBzaG9ydCBjb3VudCA9IDB4ZmZmZjsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1MzIgZGF0YTsKCglkYXRhID0gKCh1MzIpIHZhbCkgPDwgMTY7CgoJc3dpdGNoIChjYXJkLT5wY2lfaWQpIHsKCWRlZmF1bHQ6CgljYXNlIFBDSV9ERVZJQ0VfSURfU0lfNzAxODoKCQlhZGRyZXNzID0gU0lfQUM5N19XUklURTsKCQltYXNrID0gU0lfQUM5N19CVVNZX1dSSVRFIHwgU0lfQUM5N19BVURJT19CVVNZOwoJCWlmIChjb2RlYy0+aWQpCgkJCW1hc2sgfD0gU0lfQUM5N19TRUNPTkRBUlk7CgkJYnVzeSA9IFNJX0FDOTdfQlVTWV9XUklURTsKCQlicmVhazsKCWNhc2UgUENJX0RFVklDRV9JRF9UUklERU5UXzREV0FWRV9EWDoKCQlhZGRyZXNzID0gRFhfQUNSMF9BQzk3X1c7CgkJbWFzayA9IGJ1c3kgPSBEWF9BQzk3X0JVU1lfV1JJVEU7CgkJYnJlYWs7CgljYXNlIFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfTlg6CgkJYWRkcmVzcyA9IE5YX0FDUjFfQUM5N19XOwoJCW1hc2sgPSBOWF9BQzk3X0JVU1lfV1JJVEU7CgkJaWYgKGNvZGVjLT5pZCkKCQkJbWFzayB8PSBOWF9BQzk3X1dSSVRFX1NFQ09OREFSWTsKCQlidXN5ID0gTlhfQUM5N19CVVNZX1dSSVRFOwoJCWJyZWFrOwoJY2FzZSBQQ0lfREVWSUNFX0lEX0lOVEVSR181MDUwOgoJCWFkZHJlc3MgPSBTSV9BQzk3X1dSSVRFOwoJCW1hc2sgPSBidXN5ID0gU0lfQUM5N19CVVNZX1dSSVRFOwoJCWlmIChjb2RlYy0+aWQpCgkJCW1hc2sgfD0gU0lfQUM5N19TRUNPTkRBUlk7CgkJYnJlYWs7Cgl9CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCWRvIHsKCQlpZiAoKGludyhUUklEX1JFRyhjYXJkLCBhZGRyZXNzKSkgJiBidXN5KSA9PSAwKQoJCQlicmVhazsKCX0gd2hpbGUgKGNvdW50LS0pOwoKCWRhdGEgfD0gKG1hc2sgfCAocmVnICYgQUM5N19SRUdfQUREUikpOwoKCWlmIChjb3VudCA9PSAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJ0cmlkZW50OiBBQzk3IENPREVDIHdyaXRlIHRpbWVkIG91dC5cbiIpOwoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCQlyZXR1cm47Cgl9CgoJb3V0bChkYXRhLCBUUklEX1JFRyhjYXJkLCBhZGRyZXNzKSk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjYXJkLT5sb2NrLCBmbGFncyk7Cn0KCi8qIFJlYWQgQUM5NyBjb2RlYyByZWdpc3RlcnMgKi8Kc3RhdGljIHUxNgp0cmlkZW50X2FjOTdfZ2V0KHN0cnVjdCBhYzk3X2NvZGVjICpjb2RlYywgdTggcmVnKQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gKHN0cnVjdCB0cmlkZW50X2NhcmQgKiljb2RlYy0+cHJpdmF0ZV9kYXRhOwoJdW5zaWduZWQgaW50IGFkZHJlc3MsIG1hc2ssIGJ1c3k7Cgl1bnNpZ25lZCBzaG9ydCBjb3VudCA9IDB4ZmZmZjsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cgl1MzIgZGF0YTsKCglzd2l0Y2ggKGNhcmQtPnBjaV9pZCkgewoJZGVmYXVsdDoKCWNhc2UgUENJX0RFVklDRV9JRF9TSV83MDE4OgoJCWFkZHJlc3MgPSBTSV9BQzk3X1JFQUQ7CgkJbWFzayA9IFNJX0FDOTdfQlVTWV9SRUFEIHwgU0lfQUM5N19BVURJT19CVVNZOwoJCWlmIChjb2RlYy0+aWQpCgkJCW1hc2sgfD0gU0lfQUM5N19TRUNPTkRBUlk7CgkJYnVzeSA9IFNJX0FDOTdfQlVTWV9SRUFEOwoJCWJyZWFrOwoJY2FzZSBQQ0lfREVWSUNFX0lEX1RSSURFTlRfNERXQVZFX0RYOgoJCWFkZHJlc3MgPSBEWF9BQ1IxX0FDOTdfUjsKCQltYXNrID0gYnVzeSA9IERYX0FDOTdfQlVTWV9SRUFEOwoJCWJyZWFrOwoJY2FzZSBQQ0lfREVWSUNFX0lEX1RSSURFTlRfNERXQVZFX05YOgoJCWlmIChjb2RlYy0+aWQpCgkJCWFkZHJlc3MgPSBOWF9BQ1IzX0FDOTdfUl9TRUNPTkRBUlk7CgkJZWxzZQoJCQlhZGRyZXNzID0gTlhfQUNSMl9BQzk3X1JfUFJJTUFSWTsKCQltYXNrID0gTlhfQUM5N19CVVNZX1JFQUQ7CgkJYnVzeSA9IE5YX0FDOTdfQlVTWV9SRUFEIHwgTlhfQUM5N19CVVNZX0RBVEE7CgkJYnJlYWs7CgljYXNlIFBDSV9ERVZJQ0VfSURfSU5URVJHXzUwNTA6CgkJYWRkcmVzcyA9IFNJX0FDOTdfUkVBRDsKCQltYXNrID0gYnVzeSA9IFNJX0FDOTdfQlVTWV9SRUFEOwoJCWlmIChjb2RlYy0+aWQpCgkJCW1hc2sgfD0gU0lfQUM5N19TRUNPTkRBUlk7CgkJYnJlYWs7Cgl9CgoJZGF0YSA9IChtYXNrIHwgKHJlZyAmIEFDOTdfUkVHX0FERFIpKTsKCglzcGluX2xvY2tfaXJxc2F2ZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwoJb3V0bChkYXRhLCBUUklEX1JFRyhjYXJkLCBhZGRyZXNzKSk7CglkbyB7CgkJZGF0YSA9IGlubChUUklEX1JFRyhjYXJkLCBhZGRyZXNzKSk7CgkJaWYgKChkYXRhICYgYnVzeSkgPT0gMCkKCQkJYnJlYWs7Cgl9IHdoaWxlIChjb3VudC0tKTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCglpZiAoY291bnQgPT0gMCkgewoJCXByaW50ayhLRVJOX0VSUiAidHJpZGVudDogQUM5NyBDT0RFQyByZWFkIHRpbWVkIG91dC5cbiIpOwoJCWRhdGEgPSAwOwoJfQoJcmV0dXJuICgodTE2KSAoZGF0YSA+PiAxNikpOwp9CgovKiByZXdyaXRlIGFjOTcgcmVhZCBhbmQgd3JpdGUgbWl4ZXIgcmVnaXN0ZXIgYnkgaHVsZWkgZm9yIEFMSSovCnN0YXRpYyBpbnQKYWNxdWlyZWNvZGVjYWNjZXNzKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCXUxNiB3c2VtYW1hc2sgPSAweDYwMDA7CS8qIGJpdCAxNC4uMTMgKi8KCXUxNiB3c2VtYWJpdHM7Cgl1MTYgd2NvbnRyb2w7CglpbnQgYmxvY2sgPSAwOwoJaW50IG5jb3VudCA9IDI1OwoJd2hpbGUgKDEpIHsKCQl3Y29udHJvbCA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpOwoJCXdzZW1hYml0cyA9IHdjb250cm9sICYgd3NlbWFtYXNrOwoKCQlpZiAod3NlbWFiaXRzID09IDB4NDAwMCkKCQkJcmV0dXJuIDE7CS8qIDB4NDAwMCBpcyBhdWRpbyAsdGhlbiBzdWNjZXNzICovCgkJaWYgKG5jb3VudC0tIDwgMCkKCQkJYnJlYWs7CgkJaWYgKHdzZW1hYml0cyA9PSAwKSB7CgkJICAgICAgdW5sb2NrOgoJCQlvdXRsKCgodTMyKSAod2NvbnRyb2wgJiAweDFlZmYpIHwgMHgwMDAwNDAwMCksIAoJCQkgICAgIFRSSURfUkVHKGNhcmQsIEFMSV9BQzk3X1dSSVRFKSk7CgkJCWNvbnRpbnVlOwoJCX0KCQl1ZGVsYXkoMjApOwoJfQoJaWYgKCFibG9jaykgewoJCXByX2RlYnVnKCJhY2Nlc3Njb2RlY3NlbWFwaG9yZTogdHJ5IHVubG9ja1xuIik7CgkJYmxvY2sgPSAxOwoJCWdvdG8gdW5sb2NrOwoJfQoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkCnJlbGVhc2Vjb2RlY2FjY2VzcyhzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7Cgl1bnNpZ25lZCBsb25nIHdjb250cm9sOwoJd2NvbnRyb2wgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0FDOTdfV1JJVEUpKTsKCW91dGwoKHdjb250cm9sICYgMHhmZmZmMWVmZiksIFRSSURfUkVHKGNhcmQsIEFMSV9BQzk3X1dSSVRFKSk7Cn0KCnN0YXRpYyBpbnQKd2FpdGZvcnN0aW1lcnRpY2soc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkKewoJdW5zaWduZWQgbG9uZyBjaGsxLCBjaGsyOwoJdW5zaWduZWQgaW50IHdjb3VudCA9IDB4ZmZmZjsKCWNoazEgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX1NUSU1FUikpOwoKCXdoaWxlICgxKSB7CgkJY2hrMiA9IGlubChUUklEX1JFRyhjYXJkLCBBTElfU1RJTUVSKSk7CgkJaWYgKCh3Y291bnQgPiAwKSAmJiBjaGsxICE9IGNoazIpCgkJCXJldHVybiAxOwoJCWlmICh3Y291bnQgPD0gMCkKCQkJYnJlYWs7CgkJdWRlbGF5KDUwKTsKCX0KCXJldHVybiAwOwp9CgovKiBSZWFkIEFDOTcgY29kZWMgcmVnaXN0ZXJzIGZvciBBTGkqLwpzdGF0aWMgdTE2CmFsaV9hYzk3X2dldChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCBpbnQgc2Vjb25kYXJ5LCB1OCByZWcpCnsKCXVuc2lnbmVkIGludCBhZGRyZXNzLCBtYXNrOwoJdW5zaWduZWQgaW50IG5jb3VudDsKCXVuc2lnbmVkIGxvbmcgYXVkX3JlZzsKCXUzMiBkYXRhOwoJdTE2IHdjb250cm9sOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglpZiAoIWNhcmQpCgkJQlVHKCk7CgoJYWRkcmVzcyA9IEFMSV9BQzk3X1JFQUQ7CglpZiAoY2FyZC0+cmV2aXNpb24gPT0gQUxJXzU0NTFfVjAyKSB7CgkJYWRkcmVzcyA9IEFMSV9BQzk3X1dSSVRFOwoJfQoJbWFzayA9IEFMSV9BQzk3X1JFQURfQUNUSU9OIHwgQUxJX0FDOTdfQVVESU9fQlVTWTsKCWlmIChzZWNvbmRhcnkpCgkJbWFzayB8PSBBTElfQUM5N19TRUNPTkRBUlk7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCglpZiAoIWFjcXVpcmVjb2RlY2FjY2VzcyhjYXJkKSkKCQlwcmludGsoS0VSTl9FUlIgImFjY2VzcyBjb2RlYyBmYWlsXG4iKTsKCgl3Y29udHJvbCA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpOwoJd2NvbnRyb2wgJj0gMHhmZTAwOwoJd2NvbnRyb2wgfD0gKDB4ODAwMCB8IHJlZyk7CglvdXR3KHdjb250cm9sLCBUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpOwoKCWRhdGEgPSAobWFzayB8IChyZWcgJiBBQzk3X1JFR19BRERSKSk7CgoJaWYgKCF3YWl0Zm9yc3RpbWVydGljayhjYXJkKSkgewoJCXByaW50ayhLRVJOX0VSUiAiYWxpX2FjOTdfcmVhZDogQklUX0NMT0NLIGlzIGRlYWRcbiIpOwoJCWdvdG8gcmVsZWFzZWNvZGVjOwoJfQoKCXVkZWxheSgyMCk7CgoJbmNvdW50ID0gMTA7CgoJd2hpbGUgKDEpIHsKCQlpZiAoKGludyhUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpICYgQUxJX0FDOTdfQlVTWV9SRUFEKSAKCQkgICAgIT0gMCkKCQkJYnJlYWs7CgkJaWYgKG5jb3VudCA8PSAwKQoJCQlicmVhazsKCQlpZiAobmNvdW50LS0gPT0gMSkgewoJCQlwcl9kZWJ1ZygiYWxpX2FjOTdfcmVhZCA6dHJ5IGNsZWFyIGJ1c3kgZmxhZ1xuIik7CgkJCWF1ZF9yZWcgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0FDOTdfV1JJVEUpKTsKCQkJb3V0bCgoYXVkX3JlZyAmIDB4ZmZmZjdmZmYpLCAKCQkJICAgICBUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpOwoJCX0KCQl1ZGVsYXkoMTApOwoJfQoKCWRhdGEgPSBpbmwoVFJJRF9SRUcoY2FyZCwgYWRkcmVzcykpOwoKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCglyZXR1cm4gKCh1MTYpIChkYXRhID4+IDE2KSk7CgogICAgICByZWxlYXNlY29kZWM6CglyZWxlYXNlY29kZWNhY2Nlc3MoY2FyZCk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZjYXJkLT5sb2NrLCBmbGFncyk7CglwcmludGsoS0VSTl9FUlIgImFsaV9hYzk3X3JlYWQ6IEFDOTcgQ09ERUMgcmVhZCB0aW1lZCBvdXQuXG4iKTsKCXJldHVybiAwOwp9CgovKiBXcml0ZSBBQzk3IGNvZGVjIHJlZ2lzdGVycyBmb3IgaHVsZWkqLwpzdGF0aWMgdm9pZAphbGlfYWM5N19zZXQoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgaW50IHNlY29uZGFyeSwgdTggcmVnLCB1MTYgdmFsKQp7Cgl1bnNpZ25lZCBpbnQgYWRkcmVzcywgbWFzazsKCXVuc2lnbmVkIGludCBuY291bnQ7Cgl1MzIgZGF0YTsKCXUxNiB3Y29udHJvbDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJZGF0YSA9ICgodTMyKSB2YWwpIDw8IDE2OwoKCWlmICghY2FyZCkKCQlCVUcoKTsKCglhZGRyZXNzID0gQUxJX0FDOTdfV1JJVEU7CgltYXNrID0gQUxJX0FDOTdfV1JJVEVfQUNUSU9OIHwgQUxJX0FDOTdfQVVESU9fQlVTWTsKCWlmIChzZWNvbmRhcnkpCgkJbWFzayB8PSBBTElfQUM5N19TRUNPTkRBUlk7CglpZiAoY2FyZC0+cmV2aXNpb24gPT0gQUxJXzU0NTFfVjAyKQoJCW1hc2sgfD0gQUxJX0FDOTdfV1JJVEVfTUlYRVJfUkVHSVNURVI7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKCWlmICghYWNxdWlyZWNvZGVjYWNjZXNzKGNhcmQpKQoJCXByaW50ayhLRVJOX0VSUiAiYWxpX2FjOTdfd3JpdGU6IGFjY2VzcyBjb2RlYyBmYWlsXG4iKTsKCgl3Y29udHJvbCA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpOwoJd2NvbnRyb2wgJj0gMHhmZjAwOwoJd2NvbnRyb2wgfD0gKDB4ODEwMCB8IHJlZyk7IC8qIGJpdCA4PTE6IChhbGkxNTM1IClyZXNlcnZlZC8gKi8gCgkgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogYWxpMTUzNSsgd3JpdGUgKi8KCW91dGwoKGRhdGEgfCB3Y29udHJvbCksIFRSSURfUkVHKGNhcmQsIEFMSV9BQzk3X1dSSVRFKSk7CgoJaWYgKCF3YWl0Zm9yc3RpbWVydGljayhjYXJkKSkgewoJCXByaW50ayhLRVJOX0VSUiAiQklUX0NMT0NLIGlzIGRlYWRcbiIpOwoJCWdvdG8gcmVsZWFzZWNvZGVjOwoJfQoKCW5jb3VudCA9IDEwOwoJd2hpbGUgKDEpIHsKCQl3Y29udHJvbCA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpOwoJCWlmICghKHdjb250cm9sICYgMHg4MDAwKSkKCQkJYnJlYWs7CgkJaWYgKG5jb3VudCA8PSAwKQoJCQlicmVhazsKCQlpZiAobmNvdW50LS0gPT0gMSkgewoJCQlwcl9kZWJ1ZygiYWxpX2FjOTdfc2V0IDp0cnkgY2xlYXIgYnVzeSBmbGFnISFcbiIpOwoJCQlvdXR3KHdjb250cm9sICYgMHg3ZmZmLCAKCQkJICAgICBUUklEX1JFRyhjYXJkLCBBTElfQUM5N19XUklURSkpOwoJCX0KCQl1ZGVsYXkoMTApOwoJfQoKICAgICAgcmVsZWFzZWNvZGVjOgoJcmVsZWFzZWNvZGVjYWNjZXNzKGNhcmQpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwoJcmV0dXJuOwp9CgpzdGF0aWMgdm9pZAphbGlfZW5hYmxlX3NwZWNpYWxfY2hhbm5lbChzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdCkKewoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCA9IHN0YXQtPmNhcmQ7Cgl1bnNpZ25lZCBsb25nIHNfY2hhbm5lbHM7CgoJc19jaGFubmVscyA9IGlubChUUklEX1JFRyhjYXJkLCBBTElfR0xPQkFMX0NPTlRST0wpKTsKCXNfY2hhbm5lbHMgfD0gKDEgPDwgc3RhdC0+ZG1hYnVmLmNoYW5uZWwtPm51bSk7CglvdXRsKHNfY2hhbm5lbHMsIFRSSURfUkVHKGNhcmQsIEFMSV9HTE9CQUxfQ09OVFJPTCkpOwp9CgpzdGF0aWMgdTE2CmFsaV9hYzk3X3JlYWQoc3RydWN0IGFjOTdfY29kZWMgKmNvZGVjLCB1OCByZWcpCnsKCWludCBpZDsKCXUxNiBkYXRhOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCA9IE5VTEw7CgoJLyogQWRkZWQgYnkgTWF0dCBXdSAqLwoJaWYgKCFjb2RlYykKCQlCVUcoKTsKCgljYXJkID0gKHN0cnVjdCB0cmlkZW50X2NhcmQgKikgY29kZWMtPnByaXZhdGVfZGF0YTsKCglpZiAoIWNhcmQtPm1peGVyX3JlZ3NfcmVhZHkpCgkJcmV0dXJuIGFsaV9hYzk3X2dldChjYXJkLCBjb2RlYy0+aWQsIHJlZyk7CgoJLyoKCSAqICAgICAgRklYTUU6IG5lZWQgdG8gc3RvcCB0aGlzIGNhY2hpbmcgc29tZSByZWdpc3RlcnMKCSAqLwoJaWYgKGNvZGVjLT5pZCkKCQlpZCA9IDE7CgllbHNlCgkJaWQgPSAwOwoKCWRhdGEgPSBjYXJkLT5taXhlcl9yZWdzW3JlZyAvIDJdW2lkXTsKCXJldHVybiBkYXRhOwp9CgpzdGF0aWMgdm9pZAphbGlfYWM5N193cml0ZShzdHJ1Y3QgYWM5N19jb2RlYyAqY29kZWMsIHU4IHJlZywgdTE2IHZhbCkKewoJaW50IGlkOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZDsKCgkvKiAgQWRkZWQgYnkgTWF0dCBXdSAqLwoJaWYgKCFjb2RlYykKCQlCVUcoKTsKCgljYXJkID0gKHN0cnVjdCB0cmlkZW50X2NhcmQgKikgY29kZWMtPnByaXZhdGVfZGF0YTsKCglpZiAoIWNhcmQtPm1peGVyX3JlZ3NfcmVhZHkpIHsKCQlhbGlfYWM5N19zZXQoY2FyZCwgY29kZWMtPmlkLCByZWcsIHZhbCk7CgkJcmV0dXJuOwoJfQoKCWlmIChjb2RlYy0+aWQpCgkJaWQgPSAxOwoJZWxzZQoJCWlkID0gMDsKCgljYXJkLT5taXhlcl9yZWdzW3JlZyAvIDJdW2lkXSA9IHZhbDsKCWFsaV9hYzk3X3NldChjYXJkLCBjb2RlYy0+aWQsIHJlZywgdmFsKTsKfQoKLyoKZmxhZzoJQUxJX1NQRElGX09VVF9UT19TUERJRl9PVVQKCUFMSV9QQ01fVE9fU1BESUZfT1VUCiovCgpzdGF0aWMgdm9pZAphbGlfc2V0dXBfc3BkaWZfb3V0KHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIGludCBmbGFnKQp7Cgl1bnNpZ25lZCBsb25nIHNwZGlmOwoJdW5zaWduZWQgY2hhciBjaDsKCgljaGFyIHRlbXA7CglzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldiA9IE5VTEw7CgoJcGNpX2RldiA9IHBjaV9maW5kX2RldmljZShQQ0lfVkVORE9SX0lEX0FMLCBQQ0lfREVWSUNFX0lEX0FMX00xNTMzLCAKCQkJCSAgcGNpX2Rldik7CglpZiAocGNpX2RldiA9PSBOVUxMKQoJCXJldHVybjsKCXBjaV9yZWFkX2NvbmZpZ19ieXRlKHBjaV9kZXYsIDB4NjEsICZ0ZW1wKTsKCXRlbXAgfD0gMHg0MDsKCXBjaV93cml0ZV9jb25maWdfYnl0ZShwY2lfZGV2LCAweDYxLCB0ZW1wKTsKCXBjaV9yZWFkX2NvbmZpZ19ieXRlKHBjaV9kZXYsIDB4N2QsICZ0ZW1wKTsKCXRlbXAgfD0gMHgwMTsKCXBjaV93cml0ZV9jb25maWdfYnl0ZShwY2lfZGV2LCAweDdkLCB0ZW1wKTsKCXBjaV9yZWFkX2NvbmZpZ19ieXRlKHBjaV9kZXYsIDB4N2UsICZ0ZW1wKTsKCXRlbXAgJj0gKH4weDIwKTsKCXRlbXAgfD0gMHgxMDsKCXBjaV93cml0ZV9jb25maWdfYnl0ZShwY2lfZGV2LCAweDdlLCB0ZW1wKTsKCgljaCA9IGluYihUUklEX1JFRyhjYXJkLCBBTElfU0NUUkwpKTsKCW91dGIoY2ggfCBBTElfU1BESUZfT1VUX0VOQUJMRSwgVFJJRF9SRUcoY2FyZCwgQUxJX1NDVFJMKSk7CgljaCA9IGluYihUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1RSTCkpOwoJb3V0YihjaCAmIEFMSV9TUERJRl9PVVRfQ0hfU1RBVFVTLCBUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1RSTCkpOwoKCWlmIChmbGFnICYgQUxJX1NQRElGX09VVF9UT19TUERJRl9PVVQpIHsKCQlzcGRpZiA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfR0xPQkFMX0NPTlRST0wpKTsKCQlzcGRpZiB8PSBBTElfU1BESUZfT1VUX0NIX0VOQUJMRTsKCQlzcGRpZiAmPSBBTElfU1BESUZfT1VUX1NFTF9TUERJRjsKCQlvdXR3KHNwZGlmLCBUUklEX1JFRyhjYXJkLCBBTElfR0xPQkFMX0NPTlRST0wpKTsKCQlzcGRpZiA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1MpKTsKCQlpZiAoZmxhZyAmIEFMSV9TUERJRl9PVVRfTk9OX1BDTSkKCQkJc3BkaWYgfD0gMHgwMDAyOwoJCWVsc2UKCQkJc3BkaWYgJj0gKH4weDAwMDIpOwoJCW91dHcoc3BkaWYsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DUykpOwoJfSBlbHNlIHsKCQlzcGRpZiA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfR0xPQkFMX0NPTlRST0wpKTsKCQlzcGRpZiB8PSBBTElfU1BESUZfT1VUX1NFTF9QQ007CgkJb3V0dyhzcGRpZiwgVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7Cgl9Cn0KCnN0YXRpYyB2b2lkCmFsaV9kaXNhYmxlX3NwZWNpYWxfY2hhbm5lbChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCBpbnQgY2gpCnsKCXVuc2lnbmVkIGxvbmcgc2M7CgoJc2MgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7CglzYyAmPSB+KDEgPDwgY2gpOwoJb3V0bChzYywgVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7Cn0KCnN0YXRpYyB2b2lkCmFsaV9kaXNhYmxlX3NwZGlmX2luKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCXVuc2lnbmVkIGxvbmcgc3BkaWY7CgoJc3BkaWYgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7CglzcGRpZiAmPSAofkFMSV9TUERJRl9JTl9TVVBQT1JUKTsKCW91dGwoc3BkaWYsIFRSSURfUkVHKGNhcmQsIEFMSV9HTE9CQUxfQ09OVFJPTCkpOwoKCWFsaV9kaXNhYmxlX3NwZWNpYWxfY2hhbm5lbChjYXJkLCBBTElfU1BESUZfSU5fQ0hBTk5FTCk7Cn0KCnN0YXRpYyB2b2lkCmFsaV9zZXR1cF9zcGRpZl9pbihzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7Cgl1bnNpZ25lZCBsb25nIHNwZGlmOwoKCS8vU2V0IFNQRElGIElOIFN1cHBvcnRlZAoJc3BkaWYgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7CglzcGRpZiB8PSBBTElfU1BESUZfSU5fU1VQUE9SVDsKCW91dGwoc3BkaWYsIFRSSURfUkVHKGNhcmQsIEFMSV9HTE9CQUxfQ09OVFJPTCkpOwoKCS8vU2V0IFNQRElGIElOIFJlYwoJc3BkaWYgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7CglzcGRpZiB8PSBBTElfU1BESUZfSU5fQ0hfRU5BQkxFOwoJb3V0bChzcGRpZiwgVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7CgoJc3BkaWYgPSBpbmIoVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NUUkwpKTsKCXNwZGlmIHw9IEFMSV9TUERJRl9JTl9DSF9TVEFUVVM7CglvdXRiKHNwZGlmLCBUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1RSTCkpOwovKgoJc3BkaWYgPSBpbmIoVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NUUkwpKTsKCXNwZGlmIHw9IEFMSV9TUERJRl9JTl9GVU5DX0VOQUJMRTsKCW91dGIoc3BkaWYsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMKSk7CiovCn0KCnN0YXRpYyB2b2lkCmFsaV9kZWxheShzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCBpbnQgaW50ZXJ2YWwpCnsKCXVuc2lnbmVkIGxvbmcgYmVnaW50aW1lciwgY3VycmVudHRpbWVyOwoKCWJlZ2ludGltZXIgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX1NUSU1FUikpOwoJY3VycmVudHRpbWVyID0gaW5sKFRSSURfUkVHKGNhcmQsIEFMSV9TVElNRVIpKTsKCgl3aGlsZSAoY3VycmVudHRpbWVyIDwgYmVnaW50aW1lciArIGludGVydmFsKQoJCWN1cnJlbnR0aW1lciA9IGlubChUUklEX1JFRyhjYXJkLCBBTElfU1RJTUVSKSk7Cn0KCnN0YXRpYyB2b2lkCmFsaV9kZXRlY3Rfc3BkaWZfcmF0ZShzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7Cgl1MTYgd3ZhbCA9IDA7Cgl1MTYgY291bnQgPSAwOwoJdTggYnZhbCA9IDAsIFIxID0gMCwgUjIgPSAwOwoKCWJ2YWwgPSBpbmIoVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NUUkwpKTsKCWJ2YWwgfD0gMHgwMjsKCW91dGIoYnZhbCwgVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NUUkwpKTsKCglidmFsID0gaW5iKFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMICsgMSkpOwoJYnZhbCB8PSAweDFGOwoJb3V0YihidmFsLCBUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1RSTCArIDEpKTsKCgl3aGlsZSAoKChSMSA8IDB4MEIpIHx8IChSMSA+IDB4MEUpKSAmJiAoUjEgIT0gMHgxMikgJiYgCgkgICAgICAgY291bnQgPD0gNTAwMDApIHsKCQljb3VudCsrOwoKCQlhbGlfZGVsYXkoY2FyZCwgNik7CgoJCWJ2YWwgPSBpbmIoVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NUUkwgKyAxKSk7CgkJUjEgPSBidmFsICYgMHgxRjsKCX0KCglpZiAoY291bnQgPiA1MDAwMCkgewoJCXByaW50ayhLRVJOX1dBUk5JTkcgInRyaWRlbnQ6IEVycm9yIGluICIKCQkgICAgICAgImFsaV9kZXRlY3Rfc3BkaWZfcmF0ZSFcbiIpOwoJCXJldHVybjsKCX0KCgljb3VudCA9IDA7CgoJd2hpbGUgKGNvdW50IDw9IDUwMDAwKSB7CgkJY291bnQrKzsKCgkJYWxpX2RlbGF5KGNhcmQsIDYpOwoKCQlidmFsID0gaW5iKFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMICsgMSkpOwoJCVIyID0gYnZhbCAmIDB4MUY7CgoJCWlmIChSMiAhPSBSMSkKCQkJUjEgPSBSMjsKCQllbHNlCgkJCWJyZWFrOwoJfQoKCWlmIChjb3VudCA+IDUwMDAwKSB7CgkJcHJpbnRrKEtFUk5fV0FSTklORyAidHJpZGVudDogRXJyb3IgaW4gIgoJCSAgICAgICAiYWxpX2RldGVjdF9zcGRpZl9yYXRlIVxuIik7CgkJcmV0dXJuOwoJfQoKCXN3aXRjaCAoUjIpIHsKCWNhc2UgMHgwYjoKCWNhc2UgMHgwYzoKCWNhc2UgMHgwZDoKCWNhc2UgMHgwZToKCQl3dmFsID0gaW53KFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMICsgMikpOwoJCXd2YWwgJj0gMHhFMEYwOwoJCXd2YWwgfD0gKHUxNikgMHgwOSA8PCA4IHwgKHUxNikgMHgwNTsKCQlvdXR3KHd2YWwsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMICsgMikpOwoKCQlidmFsID0gaW5iKFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DUyArIDMpKSAmIDB4RjA7CgkJb3V0YihidmFsIHwgMHgwMiwgVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NTICsgMykpOwoJCWJyZWFrOwoKCWNhc2UgMHgxMjoKCQl3dmFsID0gaW53KFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMICsgMikpOwoJCXd2YWwgJj0gMHhFMEYwOwoJCXd2YWwgfD0gKHUxNikgMHgwRSA8PCA4IHwgKHUxNikgMHgwODsKCQlvdXR3KHd2YWwsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMICsgMikpOwoKCQlidmFsID0gaW5iKFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DUyArIDMpKSAmIDB4RjA7CgkJb3V0YihidmFsIHwgMHgwMywgVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NTICsgMykpOwoJCWJyZWFrOwoKCWRlZmF1bHQ6CgkJYnJlYWs7Cgl9Cgp9CgpzdGF0aWMgdW5zaWduZWQgaW50CmFsaV9nZXRfc3BkaWZfaW5fcmF0ZShzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7Cgl1MzIgZHdSYXRlID0gMDsKCXU4IGJ2YWwgPSAwOwoKCWFsaV9kZXRlY3Rfc3BkaWZfcmF0ZShjYXJkKTsKCglidmFsID0gaW5iKFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMKSk7CglidmFsICY9IDB4N0Y7CglidmFsIHw9IDB4NDA7CglvdXRiKGJ2YWwsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMKSk7CgoJYnZhbCA9IGluYihUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1MgKyAzKSk7CglidmFsICY9IDB4MEY7CgoJc3dpdGNoIChidmFsKSB7CgljYXNlIDA6CgkJZHdSYXRlID0gNDQxMDA7CgkJYnJlYWs7CgljYXNlIDE6CgkJZHdSYXRlID0gNDgwMDA7CgkJYnJlYWs7CgljYXNlIDI6CgkJZHdSYXRlID0gMzIwMDA7CgkJYnJlYWs7CglkZWZhdWx0OgoJCS8vIEVycm9yIG9jY3VycwoJCWJyZWFrOwoJfQoKCXJldHVybiBkd1JhdGU7Cgp9CgpzdGF0aWMgaW50CmFsaV9jbG9zZV9tdWx0aV9jaGFubmVscyh2b2lkKQp7CgljaGFyIHRlbXAgPSAwOwoJc3RydWN0IHBjaV9kZXYgKnBjaV9kZXYgPSBOVUxMOwoKCXBjaV9kZXYgPSBwY2lfZmluZF9kZXZpY2UoUENJX1ZFTkRPUl9JRF9BTCwgUENJX0RFVklDRV9JRF9BTF9NMTUzMywgCgkJCQkgIHBjaV9kZXYpOwoJaWYgKHBjaV9kZXYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CglwY2lfcmVhZF9jb25maWdfYnl0ZShwY2lfZGV2LCAweDU5LCAmdGVtcCk7Cgl0ZW1wICY9IH4weDgwOwoJcGNpX3dyaXRlX2NvbmZpZ19ieXRlKHBjaV9kZXYsIDB4NTksIHRlbXApOwoKCXBjaV9kZXYgPSBwY2lfZmluZF9kZXZpY2UoUENJX1ZFTkRPUl9JRF9BTCwgUENJX0RFVklDRV9JRF9BTF9NNzEwMSwgCgkJCQkgIHBjaV9kZXYpOwoJaWYgKHBjaV9kZXYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJcGNpX3JlYWRfY29uZmlnX2J5dGUocGNpX2RldiwgMHhCOCwgJnRlbXApOwoJdGVtcCAmPSB+MHgyMDsKCXBjaV93cml0ZV9jb25maWdfYnl0ZShwY2lfZGV2LCAweEI4LCB0ZW1wKTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIGludAphbGlfc2V0dXBfbXVsdGlfY2hhbm5lbHMoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCwgaW50IGNoYW5fbnVtcykKewoJdW5zaWduZWQgbG9uZyBkd1ZhbHVlOwoJY2hhciB0ZW1wID0gMDsKCXN0cnVjdCBwY2lfZGV2ICpwY2lfZGV2ID0gTlVMTDsKCglwY2lfZGV2ID0gcGNpX2ZpbmRfZGV2aWNlKFBDSV9WRU5ET1JfSURfQUwsIFBDSV9ERVZJQ0VfSURfQUxfTTE1MzMsIAoJCQkJICBwY2lfZGV2KTsKCWlmIChwY2lfZGV2ID09IE5VTEwpCgkJcmV0dXJuIC0xOwoJcGNpX3JlYWRfY29uZmlnX2J5dGUocGNpX2RldiwgMHg1OSwgJnRlbXApOwoJdGVtcCB8PSAweDgwOwoJcGNpX3dyaXRlX2NvbmZpZ19ieXRlKHBjaV9kZXYsIDB4NTksIHRlbXApOwoKCXBjaV9kZXYgPSBwY2lfZmluZF9kZXZpY2UoUENJX1ZFTkRPUl9JRF9BTCwgUENJX0RFVklDRV9JRF9BTF9NNzEwMSwgCgkJCQkgIHBjaV9kZXYpOwoJaWYgKHBjaV9kZXYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CglwY2lfcmVhZF9jb25maWdfYnl0ZShwY2lfZGV2LCAoaW50KSAweEI4LCAmdGVtcCk7Cgl0ZW1wIHw9IDB4MjA7CglwY2lfd3JpdGVfY29uZmlnX2J5dGUocGNpX2RldiwgKGludCkgMHhCOCwgKHU4KSB0ZW1wKTsKCWlmIChjaGFuX251bXMgPT0gNikgewoJCWR3VmFsdWUgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX1NDVFJMKSkgfCAweDAwMGYwMDAwOwoJCW91dGwoZHdWYWx1ZSwgVFJJRF9SRUcoY2FyZCwgQUxJX1NDVFJMKSk7CgkJbWRlbGF5KDQpOwoJCWR3VmFsdWUgPSBpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX1NDVFJMKSk7CgkJaWYgKGR3VmFsdWUgJiAweDIwMDAwMDApIHsKCQkJYWxpX2FjOTdfd3JpdGUoY2FyZC0+YWM5N19jb2RlY1swXSwgMHgwMiwgODA4MCk7CgkJCWFsaV9hYzk3X3dyaXRlKGNhcmQtPmFjOTdfY29kZWNbMF0sIDB4MzYsIDApOwoJCQlhbGlfYWM5N193cml0ZShjYXJkLT5hYzk3X2NvZGVjWzBdLCAweDM4LCAwKTsKCQkJLyoKCQkJICogICAgICBPbiBhIGJvYXJkIHdpdGggYSBzaW5nbGUgY29kZWMgeW91IHdvbid0IGdldCB0aGUKCQkJICogICAgICBzdXJyb3VuZC4gT24gb3RoZXIgYm9hcmRzIGNvbmZpZ3VyZSBpdC4KCQkJICovCgkJCWlmIChjYXJkLT5hYzk3X2NvZGVjWzFdICE9IE5VTEwpIHsKCQkJCWFsaV9hYzk3X3dyaXRlKGNhcmQtPmFjOTdfY29kZWNbMV0sIDB4MzYsIDApOwoJCQkJYWxpX2FjOTdfd3JpdGUoY2FyZC0+YWM5N19jb2RlY1sxXSwgMHgzOCwgMCk7CgkJCQlhbGlfYWM5N193cml0ZShjYXJkLT5hYzk3X2NvZGVjWzFdLCAweDAyLCAweDA2MDYpOwoJCQkJYWxpX2FjOTdfd3JpdGUoY2FyZC0+YWM5N19jb2RlY1sxXSwgMHgxOCwgMHgwMzAzKTsKCQkJCWFsaV9hYzk3X3dyaXRlKGNhcmQtPmFjOTdfY29kZWNbMV0sIDB4NzQsIDB4Myk7CgkJCX0KCQkJcmV0dXJuIDE7CgkJfQoJfQoJcmV0dXJuIC1FSU5WQUw7Cn0KCnN0YXRpYyB2b2lkCmFsaV9mcmVlX3BjbV9jaGFubmVsKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQsIHVuc2lnbmVkIGludCBjaGFubmVsKQp7CglpbnQgYmFuazsKCglpZiAoY2hhbm5lbCA+IDMxKQoJCXJldHVybjsKCgliYW5rID0gY2hhbm5lbCA+PiA1OwoJY2hhbm5lbCA9IGNoYW5uZWwgJiAweDFmOwoKCWNhcmQtPmJhbmtzW2JhbmtdLmJpdG1hcCAmPSB+KDEgPDwgKGNoYW5uZWwpKTsKfQoKc3RhdGljIGludAphbGlfYWxsb2NhdGVfb3RoZXJfc3RhdGVzX3Jlc291cmNlcyhzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUsIGludCBjaGFuX251bXMpCnsKCXN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQgPSBzdGF0ZS0+Y2FyZDsKCXN0cnVjdCB0cmlkZW50X3N0YXRlICpzOwoJaW50IGksIHN0YXRlX2NvdW50ID0gMDsKCXN0cnVjdCB0cmlkZW50X3BjbV9iYW5rICpiYW5rOwoJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqY2hhbm5lbDsKCXVuc2lnbmVkIGxvbmcgbnVtOwoKCWJhbmsgPSAmY2FyZC0+YmFua3NbQkFOS19BXTsKCglpZiAoY2hhbl9udW1zICE9IDYpCgkJcmV0dXJuIDA7CgoJZm9yIChpID0gMDsgKGkgPCBBTElfQ0hBTk5FTFMpICYmIChzdGF0ZV9jb3VudCAhPSA0KTsgaSsrKSB7CgkJaWYgKGNhcmQtPnN0YXRlc1tpXSkKCQkJY29udGludWU7CgoJCW51bSA9IGFsaV9tdWx0aV9jaGFubmVsc181XzFbc3RhdGVfY291bnRdOwoJCWlmICghKGJhbmstPmJpdG1hcCAmICgxIDw8IG51bSkpKSB7CgkJCWJhbmstPmJpdG1hcCB8PSAxIDw8IG51bTsKCQkJY2hhbm5lbCA9ICZiYW5rLT5jaGFubmVsc1tudW1dOwoJCQljaGFubmVsLT5udW0gPSBudW07CgkJfSBlbHNlIHsKCQkJc3RhdGVfY291bnQtLTsKCQkJZm9yICg7IHN0YXRlX2NvdW50ID49IDA7IHN0YXRlX2NvdW50LS0pIHsKCQkJCWtmcmVlKHN0YXRlLT5vdGhlcl9zdGF0ZXNbc3RhdGVfY291bnRdKTsKCQkJCW51bSA9IGFsaV9tdWx0aV9jaGFubmVsc181XzFbc3RhdGVfY291bnRdOwoJCQkJCWFsaV9mcmVlX3BjbV9jaGFubmVsKGNhcmQsIG51bSk7CgkJCX0KCQkJcmV0dXJuIC1FQlVTWTsKCQl9CgkJcyA9IGNhcmQtPnN0YXRlc1tpXSA9IGttYWxsb2Moc2l6ZW9mKCpzdGF0ZSksIEdGUF9LRVJORUwpOwoJCWlmICghcykgewoJCQludW0gPSBhbGlfbXVsdGlfY2hhbm5lbHNfNV8xW3N0YXRlX2NvdW50XTsKCQkJYWxpX2ZyZWVfcGNtX2NoYW5uZWwoY2FyZCwgbnVtKTsKCQkJc3RhdGVfY291bnQtLTsKCQkJZm9yICg7IHN0YXRlX2NvdW50ID49IDA7IHN0YXRlX2NvdW50LS0pIHsKCQkJCW51bSA9IGFsaV9tdWx0aV9jaGFubmVsc181XzFbc3RhdGVfY291bnRdOwoJCQkJYWxpX2ZyZWVfcGNtX2NoYW5uZWwoY2FyZCwgbnVtKTsKCQkJCWtmcmVlKHN0YXRlLT5vdGhlcl9zdGF0ZXNbc3RhdGVfY291bnRdKTsKCQkJfQoJCQlyZXR1cm4gLUVOT01FTTsKCQl9CgkJbWVtc2V0KHMsIDAsIHNpemVvZigqc3RhdGUpKTsKCgkJcy0+ZG1hYnVmLmNoYW5uZWwgPSBjaGFubmVsOwoJCXMtPmRtYWJ1Zi5vc3NmcmFnc2hpZnQgPSBzLT5kbWFidWYub3NzbWF4ZnJhZ3MgPQoJCQlzLT5kbWFidWYuc3ViZGl2aXNpb24gPSAwOwoJCWluaXRfd2FpdHF1ZXVlX2hlYWQoJnMtPmRtYWJ1Zi53YWl0KTsKCQlzLT5tYWdpYyA9IGNhcmQtPm1hZ2ljOwoJCXMtPmNhcmQgPSBjYXJkOwoJCXMtPnZpcnQgPSBpOwoJCWFsaV9lbmFibGVfc3BlY2lhbF9jaGFubmVsKHMpOwoJCXN0YXRlLT5vdGhlcl9zdGF0ZXNbc3RhdGVfY291bnQrK10gPSBzOwoJfQoKCWlmIChzdGF0ZV9jb3VudCAhPSA0KSB7CgkJc3RhdGVfY291bnQtLTsKCQlmb3IgKDsgc3RhdGVfY291bnQgPj0gMDsgc3RhdGVfY291bnQtLSkgewoJCQlrZnJlZShzdGF0ZS0+b3RoZXJfc3RhdGVzW3N0YXRlX2NvdW50XSk7CgkJCW51bSA9IGFsaV9tdWx0aV9jaGFubmVsc181XzFbc3RhdGVfY291bnRdOwoJCQlhbGlfZnJlZV9wY21fY2hhbm5lbChjYXJkLCBudW0pOwoJCX0KCQlyZXR1cm4gLUVCVVNZOwoJfQoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkCmFsaV9zYXZlX3JlZ3Moc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkKewoJdW5zaWduZWQgbG9uZyBmbGFnczsKCWludCBpLCBqOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZjYXJkLT5sb2NrLCBmbGFncyk7CgoJYWxpX3JlZ2lzdGVycy5nbG9iYWxfcmVnc1sweDJjXSA9IGlubChUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCkpOwoJLy9hbGlfcmVnaXN0ZXJzLmdsb2JhbF9yZWdzWzB4MjBdID0gaW5sKFRSSURfUkVHKGNhcmQsVDREX1NUQVJUX0EpKTsgICAgCglhbGlfcmVnaXN0ZXJzLmdsb2JhbF9yZWdzWzB4MjFdID0gaW5sKFRSSURfUkVHKGNhcmQsIFQ0RF9TVE9QX0EpKTsKCgkvL2Rpc2FibGUgYWxsIElSUSBiaXRzCglvdXRsKEFMSV9ESVNBQkxFX0FMTF9JUlEsIFRSSURfUkVHKGNhcmQsIFQ0RF9NSVNDSU5UKSk7CgoJZm9yIChpID0gMTsgaSA8IEFMSV9NSVhFUl9SRUdTOyBpKyspCgkJYWxpX3JlZ2lzdGVycy5taXhlcl9yZWdzW2ldID0gYWxpX2FjOTdfcmVhZChjYXJkLT5hYzk3X2NvZGVjWzBdLCAKCQkJCQkJCSAgICBpICogMik7CgoJZm9yIChpID0gMDsgaSA8IEFMSV9HTE9CQUxfUkVHUzsgaSsrKSB7CgkJaWYgKChpICogNCA9PSBUNERfTUlTQ0lOVCkgfHwgKGkgKiA0ID09IFQ0RF9TVE9QX0EpKQoJCQljb250aW51ZTsKCQlhbGlfcmVnaXN0ZXJzLmdsb2JhbF9yZWdzW2ldID0gaW5sKFRSSURfUkVHKGNhcmQsIGkgKiA0KSk7Cgl9CgoJZm9yIChpID0gMDsgaSA8IEFMSV9DSEFOTkVMUzsgaSsrKSB7CgkJb3V0YihpLCBUUklEX1JFRyhjYXJkLCBUNERfTEZPX0dDX0NJUikpOwoJCWZvciAoaiA9IDA7IGogPCBBTElfQ0hBTk5FTF9SRUdTOyBqKyspCgkJCWFsaV9yZWdpc3RlcnMuY2hhbm5lbF9yZWdzW2ldW2pdID0gaW5sKFRSSURfUkVHKGNhcmQsIAoJCQkJCQkJCQlqICogNCArIDB4ZTApKTsKCX0KCgkvL1N0b3AgYWxsIEhXIGNoYW5uZWwKCW91dGwoQUxJX1NUT1BfQUxMX0NIQU5ORUxTLCBUUklEX1JFRyhjYXJkLCBUNERfU1RPUF9BKSk7CgoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZAphbGlfcmVzdG9yZV9yZWdzKHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglpbnQgaSwgajsKCglzcGluX2xvY2tfaXJxc2F2ZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwoKCWZvciAoaSA9IDE7IGkgPCBBTElfTUlYRVJfUkVHUzsgaSsrKQoJCWFsaV9hYzk3X3dyaXRlKGNhcmQtPmFjOTdfY29kZWNbMF0sIGkgKiAyLCAKCQkJICAgICAgIGFsaV9yZWdpc3RlcnMubWl4ZXJfcmVnc1tpXSk7CgoJZm9yIChpID0gMDsgaSA8IEFMSV9DSEFOTkVMUzsgaSsrKSB7CgkJb3V0YihpLCBUUklEX1JFRyhjYXJkLCBUNERfTEZPX0dDX0NJUikpOwoJCWZvciAoaiA9IDA7IGogPCBBTElfQ0hBTk5FTF9SRUdTOyBqKyspCgkJCW91dGwoYWxpX3JlZ2lzdGVycy5jaGFubmVsX3JlZ3NbaV1bal0sIAoJCQkgICAgIFRSSURfUkVHKGNhcmQsIGogKiA0ICsgMHhlMCkpOwoJfQoKCWZvciAoaSA9IDA7IGkgPCBBTElfR0xPQkFMX1JFR1M7IGkrKykgewoJCWlmICgoaSAqIDQgPT0gVDREX01JU0NJTlQpIHx8IChpICogNCA9PSBUNERfU1RPUF9BKSB8fCAKCQkgICAgKGkgKiA0ID09IFQ0RF9TVEFSVF9BKSkKCQkJY29udGludWU7CgkJb3V0bChhbGlfcmVnaXN0ZXJzLmdsb2JhbF9yZWdzW2ldLCBUUklEX1JFRyhjYXJkLCBpICogNCkpOwoJfQoKCS8vc3RhcnQgSFcgY2hhbm5lbAoJb3V0bChhbGlfcmVnaXN0ZXJzLmdsb2JhbF9yZWdzWzB4MjBdLCBUUklEX1JFRyhjYXJkLCBUNERfU1RBUlRfQSkpOwoJLy9yZXN0b3JlIElSUSBlbmFibGUgYml0cwoJb3V0bChhbGlfcmVnaXN0ZXJzLmdsb2JhbF9yZWdzWzB4MmNdLCBUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCkpOwoKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJmNhcmQtPmxvY2ssIGZsYWdzKTsKfQoKc3RhdGljIGludAp0cmlkZW50X3N1c3BlbmQoc3RydWN0IHBjaV9kZXYgKmRldiwgcG1fbWVzc2FnZV90IHVudXNlZCkKewoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCA9IHBjaV9nZXRfZHJ2ZGF0YShkZXYpOwoKCWlmIChjYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSkgewoJCWFsaV9zYXZlX3JlZ3MoY2FyZCk7Cgl9CglyZXR1cm4gMDsKfQoKc3RhdGljIGludAp0cmlkZW50X3Jlc3VtZShzdHJ1Y3QgcGNpX2RldiAqZGV2KQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gcGNpX2dldF9kcnZkYXRhKGRldik7CgoJaWYgKGNhcmQtPnBjaV9pZCA9PSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKSB7CgkJYWxpX3Jlc3RvcmVfcmVncyhjYXJkKTsKCX0KCXJldHVybiAwOwp9CgpzdGF0aWMgc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqCmFsaV9hbGxvY19wY21fY2hhbm5lbChzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkKQp7CglzdHJ1Y3QgdHJpZGVudF9wY21fYmFuayAqYmFuazsKCWludCBpZHg7CgoJYmFuayA9ICZjYXJkLT5iYW5rc1tCQU5LX0FdOwoKCWlmIChpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSkgJiAKCSAgICAoQUxJX1NQRElGX09VVF9DSF9FTkFCTEUpKSB7CgkJaWR4ID0gQUxJX1NQRElGX09VVF9DSEFOTkVMOwoJCWlmICghKGJhbmstPmJpdG1hcCAmICgxIDw8IGlkeCkpKSB7CgkJCXN0cnVjdCB0cmlkZW50X2NoYW5uZWwgKmNoYW5uZWwgPSAmYmFuay0+Y2hhbm5lbHNbaWR4XTsKCQkJYmFuay0+Yml0bWFwIHw9IDEgPDwgaWR4OwoJCQljaGFubmVsLT5udW0gPSBpZHg7CgkJCXJldHVybiBjaGFubmVsOwoJCX0KCX0KCglmb3IgKGlkeCA9IEFMSV9QQ01fT1VUX0NIQU5ORUxfRklSU1Q7IGlkeCA8PSBBTElfUENNX09VVF9DSEFOTkVMX0xBU1Q7IAoJICAgICBpZHgrKykgewoJCWlmICghKGJhbmstPmJpdG1hcCAmICgxIDw8IGlkeCkpKSB7CgkJCXN0cnVjdCB0cmlkZW50X2NoYW5uZWwgKmNoYW5uZWwgPSAmYmFuay0+Y2hhbm5lbHNbaWR4XTsKCQkJYmFuay0+Yml0bWFwIHw9IDEgPDwgaWR4OwoJCQljaGFubmVsLT5udW0gPSBpZHg7CgkJCXJldHVybiBjaGFubmVsOwoJCX0KCX0KCgkvKiBubyBtb3JlIGZyZWUgY2hhbm5lbHMgYXZhbGlhYmxlICovCiNpZiAwIAoJcHJpbnRrKEtFUk5fRVJSICJhbGk6IG5vIG1vcmUgY2hhbm5lbHMgYXZhaWxhYmxlIG9uIEJhbmsgQS5cbiIpOwojZW5kaWYgLyogMCAqLyAKCXJldHVybiBOVUxMOwp9CgpzdGF0aWMgc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqCmFsaV9hbGxvY19yZWNfcGNtX2NoYW5uZWwoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkKewoJc3RydWN0IHRyaWRlbnRfcGNtX2JhbmsgKmJhbms7CglpbnQgaWR4OwoKCWlmIChpbmwoVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSkgJiBBTElfU1BESUZfSU5fU1VQUE9SVCkKCQlpZHggPSBBTElfU1BESUZfSU5fQ0hBTk5FTDsKCWVsc2UKCQlpZHggPSBBTElfUENNX0lOX0NIQU5ORUw7CgoJYmFuayA9ICZjYXJkLT5iYW5rc1tCQU5LX0FdOwoKCWlmICghKGJhbmstPmJpdG1hcCAmICgxIDw8IGlkeCkpKSB7CgkJc3RydWN0IHRyaWRlbnRfY2hhbm5lbCAqY2hhbm5lbCA9ICZiYW5rLT5jaGFubmVsc1tpZHhdOwoJCWJhbmstPmJpdG1hcCB8PSAxIDw8IGlkeDsKCQljaGFubmVsLT5udW0gPSBpZHg7CgkJcmV0dXJuIGNoYW5uZWw7Cgl9CgoJLyogbm8gZnJlZSByZWNvcmRhYmxlIGNoYW5uZWxzIGF2YWxpYWJsZSAqLwojaWYgMCAKCXByaW50ayhLRVJOX0VSUiAiYWxpOiBubyByZWNvcmRhYmxlIGNoYW5uZWxzIGF2YWlsYWJsZSBvbiBCYW5rIEEuXG4iKTsKI2VuZGlmIC8qIDAgKi8gCglyZXR1cm4gTlVMTDsKfQoKc3RhdGljIHZvaWQKYWxpX3NldF9zcGRpZl9vdXRfcmF0ZShzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkLCB1bnNpZ25lZCBpbnQgcmF0ZSkKewoJdW5zaWduZWQgY2hhciBjaF9zdF9zZWw7Cgl1bnNpZ25lZCBzaG9ydCBzdGF0dXNfcmF0ZTsKCglzd2l0Y2ggKHJhdGUpIHsKCWNhc2UgNDQxMDA6CgkJc3RhdHVzX3JhdGUgPSAwOwoJCWJyZWFrOwoJY2FzZSAzMjAwMDoKCQlzdGF0dXNfcmF0ZSA9IDB4MzAwOwoJCWJyZWFrOwoJY2FzZSA0ODAwMDoKCWRlZmF1bHQ6CgkJc3RhdHVzX3JhdGUgPSAweDIwMDsKCQlicmVhazsKCX0KCgkvKiBzZWxlY3Qgc3BkaWZfb3V0ICovIAoJY2hfc3Rfc2VsID0gaW5iKFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMKSkgJiBBTElfU1BESUZfT1VUX0NIX1NUQVRVUzsKCgljaF9zdF9zZWwgfD0gMHg4MDsJLyogc2VsZWN0IHJpZ2h0ICovIAoJb3V0YihjaF9zdF9zZWwsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DVFJMKSk7CglvdXRiKHN0YXR1c19yYXRlIHwgMHgyMCwgVFJJRF9SRUcoY2FyZCwgQUxJX1NQRElGX0NTICsgMikpOwoKCWNoX3N0X3NlbCAmPSAofjB4ODApOwkvKiBzZWxlY3QgbGVmdCAqLyAKCW91dGIoY2hfc3Rfc2VsLCBUUklEX1JFRyhjYXJkLCBBTElfU1BESUZfQ1RSTCkpOwoJb3V0dyhzdGF0dXNfcmF0ZSB8IDB4MTAsIFRSSURfUkVHKGNhcmQsIEFMSV9TUERJRl9DUyArIDIpKTsKfQoKc3RhdGljIHZvaWQKYWxpX2FkZHJlc3NfaW50ZXJydXB0KHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCWludCBpLCBjaGFubmVsOwoJc3RydWN0IHRyaWRlbnRfc3RhdGUgKnN0YXRlOwoJdTMyIG1hc2ssIGNoYW5uZWxfbWFzazsKCgltYXNrID0gdHJpZGVudF9nZXRfaW50ZXJydXB0X21hc2soY2FyZCwgMCk7Cglmb3IgKGkgPSAwOyBpIDwgTlJfSFdfQ0g7IGkrKykgewoJCWlmICgoc3RhdGUgPSBjYXJkLT5zdGF0ZXNbaV0pID09IE5VTEwpCgkJCWNvbnRpbnVlOwoJCWNoYW5uZWwgPSBzdGF0ZS0+ZG1hYnVmLmNoYW5uZWwtPm51bTsKCQlpZiAoKGNoYW5uZWxfbWFzayA9IDEgPDwgY2hhbm5lbCkgJiBtYXNrKSB7CgkJCW1hc2sgJj0gfmNoYW5uZWxfbWFzazsKCQkJdHJpZGVudF9hY2tfY2hhbm5lbF9pbnRlcnJ1cHQoY2FyZCwgY2hhbm5lbCk7CgkJCXVkZWxheSgxMDApOwoJCQlzdGF0ZS0+ZG1hYnVmLnVwZGF0ZV9mbGFnIHw9IEFMSV9BRERSRVNTX0lOVF9VUERBVEU7CgkJCXRyaWRlbnRfdXBkYXRlX3B0cihzdGF0ZSk7CgkJfQoJfQoJaWYgKG1hc2spIHsKCQlmb3IgKGkgPSAwOyBpIDwgTlJfSFdfQ0g7IGkrKykgewoJCQlpZiAobWFzayAmICgxIDw8IGkpKSB7CgkJCQlwcmludGsoImFsaTogc3B1cmlvdXMgY2hhbm5lbCBpcnEgJWQuXG4iLCBpKTsKCQkJCXRyaWRlbnRfYWNrX2NoYW5uZWxfaW50ZXJydXB0KGNhcmQsIGkpOwoJCQkJdHJpZGVudF9zdG9wX3ZvaWNlKGNhcmQsIGkpOwoJCQkJdHJpZGVudF9kaXNhYmxlX3ZvaWNlX2lycShjYXJkLCBpKTsKCQkJfQoJCX0KCX0KfQoKLyogVXBkYXRpbmcgdGhlIHZhbHVlcyBvZiBjb3VudGVycyBvZiBvdGhlcl9zdGF0ZXMnIERNQXMgd2l0aG91dCBsb2NrIApwcm90ZWN0aW9uIGlzIG5vIGhhcm0gYmVjYXVzZSBhbGwgRE1BcyBvZiBtdWx0aS1jaGFubmVscyBhbmQgaW50ZXJydXB0CmRlcGVuZCBvbiBhIG1hc3RlciBzdGF0ZSdzIERNQSwgYW5kIGNoYW5naW5nIHRoZSBjb3VudGVycyBvZiB0aGUgbWFzdGVyCnN0YXRlIERNQSBpcyBwcm90ZWN0ZWQgYnkgYSBzcGlubG9jay4KKi8Kc3RhdGljIGludAphbGlfd3JpdGVfNV8xKHN0cnVjdCB0cmlkZW50X3N0YXRlICpzdGF0ZSwgY29uc3QgY2hhciBfX3VzZXIgKmJ1ZiwgCgkgICAgICBpbnQgY250X2Zvcl9tdWx0aV9jaGFubmVsLCB1bnNpZ25lZCBpbnQgKmNvcHlfY291bnQsIAoJICAgICAgdW5zaWduZWQgaW50ICpzdGF0ZV9jbnQpCnsKCglzdHJ1Y3QgZG1hYnVmICpkbWFidWYgPSAmc3RhdGUtPmRtYWJ1ZjsKCXN0cnVjdCBkbWFidWYgKmRtYWJ1Zl90ZW1wOwoJY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciA9IGJ1ZjsKCXVuc2lnbmVkIHN3cHRyLCBvdGhlcl9kbWFfbnVtcywgc2FtcGxlX3M7Cgl1bnNpZ25lZCBpbnQgaSwgbG9vcDsKCglvdGhlcl9kbWFfbnVtcyA9IDQ7CglzYW1wbGVfcyA9IHNhbXBsZV9zaXplW2RtYWJ1Zi0+Zm10XSA+PiAxOwoJc3dwdHIgPSBkbWFidWYtPnN3cHRyOwoKCWlmICgoaSA9IHN0YXRlLT5tdWx0aV9jaGFubmVsc19hZGp1c3RfY291bnQpID4gMCkgewoJCWlmIChpID09IDEpIHsKCQkJaWYgKGNvcHlfZnJvbV91c2VyKGRtYWJ1Zi0+cmF3YnVmICsgc3dwdHIsIAoJCQkJCSAgIGJ1ZmZlciwgc2FtcGxlX3MpKQoJCQkJcmV0dXJuIC1FRkFVTFQ7CgkJCXNlZWtfb2Zmc2V0KHN3cHRyLCBidWZmZXIsIGNudF9mb3JfbXVsdGlfY2hhbm5lbCwgCgkJCQkgICAgc2FtcGxlX3MsICpjb3B5X2NvdW50KTsKCQkJaS0tOwoJCQkoKnN0YXRlX2NudCkgKz0gc2FtcGxlX3M7CgkJCXN0YXRlLT5tdWx0aV9jaGFubmVsc19hZGp1c3RfY291bnQrKzsKCQl9IGVsc2UKCQkJaSA9IGkgLSAoc3RhdGUtPmNoYW5zX251bSAtIG90aGVyX2RtYV9udW1zKTsKCQlmb3IgKDsgKGkgPCBvdGhlcl9kbWFfbnVtcykgJiYgKGNudF9mb3JfbXVsdGlfY2hhbm5lbCA+IDApOyBpKyspIHsKCQkJZG1hYnVmX3RlbXAgPSAmc3RhdGUtPm90aGVyX3N0YXRlc1tpXS0+ZG1hYnVmOwoJCQlpZiAoY29weV9mcm9tX3VzZXIoZG1hYnVmX3RlbXAtPnJhd2J1ZiArIGRtYWJ1Zl90ZW1wLT5zd3B0ciwgCgkJCQkJICAgYnVmZmVyLCBzYW1wbGVfcykpCgkJCQlyZXR1cm4gLUVGQVVMVDsKCQkJc2Vla19vZmZzZXQoZG1hYnVmX3RlbXAtPnN3cHRyLCBidWZmZXIsIGNudF9mb3JfbXVsdGlfY2hhbm5lbCwgCgkJCQkgICAgc2FtcGxlX3MsICpjb3B5X2NvdW50KTsKCQl9CgkJaWYgKGNudF9mb3JfbXVsdGlfY2hhbm5lbCA9PSAwKQoJCQlzdGF0ZS0+bXVsdGlfY2hhbm5lbHNfYWRqdXN0X2NvdW50ICs9IGk7Cgl9CglpZiAoY250X2Zvcl9tdWx0aV9jaGFubmVsID4gMCkgewoJCWxvb3AgPSBjbnRfZm9yX211bHRpX2NoYW5uZWwgLyAoc3RhdGUtPmNoYW5zX251bSAqIHNhbXBsZV9zKTsKCQlmb3IgKGkgPSAwOyBpIDwgbG9vcDsgaSsrKSB7CgkJCWlmIChjb3B5X2Zyb21fdXNlcihkbWFidWYtPnJhd2J1ZiArIHN3cHRyLCBidWZmZXIsIAoJCQkJCSAgIHNhbXBsZV9zICogMikpCgkJCQlyZXR1cm4gLUVGQVVMVDsKCQkJc2Vla19vZmZzZXQoc3dwdHIsIGJ1ZmZlciwgY250X2Zvcl9tdWx0aV9jaGFubmVsLCAKCQkJCSAgICBzYW1wbGVfcyAqIDIsICpjb3B5X2NvdW50KTsKCQkJKCpzdGF0ZV9jbnQpICs9IChzYW1wbGVfcyAqIDIpOwoKCQkJZG1hYnVmX3RlbXAgPSAmc3RhdGUtPm90aGVyX3N0YXRlc1swXS0+ZG1hYnVmOwoJCQlpZiAoY29weV9mcm9tX3VzZXIoZG1hYnVmX3RlbXAtPnJhd2J1ZiArIGRtYWJ1Zl90ZW1wLT5zd3B0ciwgCgkJCQkJICAgYnVmZmVyLCBzYW1wbGVfcykpCgkJCQlyZXR1cm4gLUVGQVVMVDsKCQkJc2Vla19vZmZzZXQoZG1hYnVmX3RlbXAtPnN3cHRyLCBidWZmZXIsIGNudF9mb3JfbXVsdGlfY2hhbm5lbCwgCgkJCQkgICAgc2FtcGxlX3MsICpjb3B5X2NvdW50KTsKCgkJCWRtYWJ1Zl90ZW1wID0gJnN0YXRlLT5vdGhlcl9zdGF0ZXNbMV0tPmRtYWJ1ZjsKCQkJaWYgKGNvcHlfZnJvbV91c2VyKGRtYWJ1Zl90ZW1wLT5yYXdidWYgKyBkbWFidWZfdGVtcC0+c3dwdHIsIAoJCQkJCSAgIGJ1ZmZlciwgc2FtcGxlX3MpKQoJCQkJcmV0dXJuIC1FRkFVTFQ7CgkJCXNlZWtfb2Zmc2V0KGRtYWJ1Zl90ZW1wLT5zd3B0ciwgYnVmZmVyLCBjbnRfZm9yX211bHRpX2NoYW5uZWwsIAoJCQkJICAgIHNhbXBsZV9zLCAqY29weV9jb3VudCk7CgoJCQlkbWFidWZfdGVtcCA9ICZzdGF0ZS0+b3RoZXJfc3RhdGVzWzJdLT5kbWFidWY7CgkJCWlmIChjb3B5X2Zyb21fdXNlcihkbWFidWZfdGVtcC0+cmF3YnVmICsgZG1hYnVmX3RlbXAtPnN3cHRyLCAKCQkJCQkgICBidWZmZXIsIHNhbXBsZV9zKSkKCQkJCXJldHVybiAtRUZBVUxUOwoJCQlzZWVrX29mZnNldChkbWFidWZfdGVtcC0+c3dwdHIsIGJ1ZmZlciwgY250X2Zvcl9tdWx0aV9jaGFubmVsLCAKCQkJCSAgICBzYW1wbGVfcywgKmNvcHlfY291bnQpOwoKCQkJZG1hYnVmX3RlbXAgPSAmc3RhdGUtPm90aGVyX3N0YXRlc1szXS0+ZG1hYnVmOwoJCQlpZiAoY29weV9mcm9tX3VzZXIoZG1hYnVmX3RlbXAtPnJhd2J1ZiArIGRtYWJ1Zl90ZW1wLT5zd3B0ciwgCgkJCQkJICAgYnVmZmVyLCBzYW1wbGVfcykpCgkJCQlyZXR1cm4gLUVGQVVMVDsKCQkJc2Vla19vZmZzZXQoZG1hYnVmX3RlbXAtPnN3cHRyLCBidWZmZXIsIGNudF9mb3JfbXVsdGlfY2hhbm5lbCwgCgkJCQkgICAgc2FtcGxlX3MsICpjb3B5X2NvdW50KTsKCQl9CgoJCWlmIChjbnRfZm9yX211bHRpX2NoYW5uZWwgPiAwKSB7CgkJCXN0YXRlLT5tdWx0aV9jaGFubmVsc19hZGp1c3RfY291bnQgPSBjbnRfZm9yX211bHRpX2NoYW5uZWwgLyBzYW1wbGVfczsKCgkJCWlmIChjb3B5X2Zyb21fdXNlcihkbWFidWYtPnJhd2J1ZiArIHN3cHRyLCBidWZmZXIsIHNhbXBsZV9zKSkKCQkJCXJldHVybiAtRUZBVUxUOwoJCQlzZWVrX29mZnNldChzd3B0ciwgYnVmZmVyLCBjbnRfZm9yX211bHRpX2NoYW5uZWwsIAoJCQkJICAgIHNhbXBsZV9zLCAqY29weV9jb3VudCk7CgkJCSgqc3RhdGVfY250KSArPSBzYW1wbGVfczsKCgkJCWlmIChjbnRfZm9yX211bHRpX2NoYW5uZWwgPiAwKSB7CgkJCQlpZiAoY29weV9mcm9tX3VzZXIoZG1hYnVmLT5yYXdidWYgKyBzd3B0ciwgCgkJCQkJCSAgIGJ1ZmZlciwgc2FtcGxlX3MpKQoJCQkJCXJldHVybiAtRUZBVUxUOwoJCQkJc2Vla19vZmZzZXQoc3dwdHIsIGJ1ZmZlciwgY250X2Zvcl9tdWx0aV9jaGFubmVsLCAKCQkJCQkgICAgc2FtcGxlX3MsICpjb3B5X2NvdW50KTsKCQkJCSgqc3RhdGVfY250KSArPSBzYW1wbGVfczsKCgkJCQlpZiAoY250X2Zvcl9tdWx0aV9jaGFubmVsID4gMCkgewoJCQkJCWludCBkaWZmID0gc3RhdGUtPmNoYW5zX251bSAtIG90aGVyX2RtYV9udW1zOwoJCQkJCWxvb3AgPSBzdGF0ZS0+bXVsdGlfY2hhbm5lbHNfYWRqdXN0X2NvdW50IC0gZGlmZjsKCQkJCQlmb3IgKGkgPSAwOyBpIDwgbG9vcDsgaSsrKSB7CgkJCQkJCWRtYWJ1Zl90ZW1wID0gJnN0YXRlLT5vdGhlcl9zdGF0ZXNbaV0tPmRtYWJ1ZjsKCQkJCQkJaWYgKGNvcHlfZnJvbV91c2VyKGRtYWJ1Zl90ZW1wLT5yYXdidWYgKyAKCQkJCQkJCQkgICBkbWFidWZfdGVtcC0+c3dwdHIsIAoJCQkJCQkJCSAgIGJ1ZmZlciwgc2FtcGxlX3MpKQoJCQkJCQkJcmV0dXJuIC1FRkFVTFQ7CgkJCQkJCXNlZWtfb2Zmc2V0KGRtYWJ1Zl90ZW1wLT5zd3B0ciwgYnVmZmVyLCAKCQkJCQkJCSAgICBjbnRfZm9yX211bHRpX2NoYW5uZWwsIAoJCQkJCQkJICAgIHNhbXBsZV9zLCAqY29weV9jb3VudCk7CgkJCQkJfQoJCQkJfQoJCQl9CgkJfSBlbHNlCgkJCXN0YXRlLT5tdWx0aV9jaGFubmVsc19hZGp1c3RfY291bnQgPSAwOwoJfQoJZm9yIChpID0gMDsgaSA8IG90aGVyX2RtYV9udW1zOyBpKyspIHsKCQlkbWFidWZfdGVtcCA9ICZzdGF0ZS0+b3RoZXJfc3RhdGVzW2ldLT5kbWFidWY7CgkJZG1hYnVmX3RlbXAtPnN3cHRyID0gZG1hYnVmX3RlbXAtPnN3cHRyICUgZG1hYnVmX3RlbXAtPmRtYXNpemU7Cgl9CglyZXR1cm4gKnN0YXRlX2NudDsKfQoKc3RhdGljIHZvaWQKYWxpX2ZyZWVfb3RoZXJfc3RhdGVzX3Jlc291cmNlcyhzdHJ1Y3QgdHJpZGVudF9zdGF0ZSAqc3RhdGUpCnsKCWludCBpOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCA9IHN0YXRlLT5jYXJkOwoJc3RydWN0IHRyaWRlbnRfc3RhdGUgKnM7Cgl1bnNpZ25lZCBvdGhlcl9zdGF0ZXNfY291bnQ7CgoJb3RoZXJfc3RhdGVzX2NvdW50ID0gc3RhdGUtPmNoYW5zX251bSAtIDI7IC8qIGV4Y2VwdCBQQ00gTC9SIGNoYW5uZWxzICovCglmb3IgKGkgPSAwOyBpIDwgb3RoZXJfc3RhdGVzX2NvdW50OyBpKyspIHsKCQlzID0gc3RhdGUtPm90aGVyX3N0YXRlc1tpXTsKCQlkZWFsbG9jX2RtYWJ1Zigmcy0+ZG1hYnVmLCBjYXJkLT5wY2lfZGV2KTsKCQlhbGlfZGlzYWJsZV9zcGVjaWFsX2NoYW5uZWwocy0+Y2FyZCwgcy0+ZG1hYnVmLmNoYW5uZWwtPm51bSk7CgkJc3RhdGUtPmNhcmQtPmZyZWVfcGNtX2NoYW5uZWwocy0+Y2FyZCwgcy0+ZG1hYnVmLmNoYW5uZWwtPm51bSk7CgkJY2FyZC0+c3RhdGVzW3MtPnZpcnRdID0gTlVMTDsKCQlrZnJlZShzKTsKCX0KfQoKc3RhdGljIHN0cnVjdCBwcm9jX2Rpcl9lbnRyeSAqcmVzOwoKc3RhdGljIGludAphbGlfd3JpdGVfcHJvYyhzdHJ1Y3QgZmlsZSAqZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKmJ1ZmZlciwgdW5zaWduZWQgbG9uZyBjb3VudCwgdm9pZCAqZGF0YSkKewoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCA9IChzdHJ1Y3QgdHJpZGVudF9jYXJkICopIGRhdGE7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJY2hhciBjOwoKCWlmIChjb3VudCA8IDApCgkJcmV0dXJuIC1FSU5WQUw7CglpZiAoY291bnQgPT0gMCkKCQlyZXR1cm4gMDsKCWlmIChnZXRfdXNlcihjLCBidWZmZXIpKQoJCXJldHVybiAtRUZBVUxUOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZjYXJkLT5sb2NrLCBmbGFncyk7Cglzd2l0Y2ggKGMpIHsKCWNhc2UgJzAnOgoJCWFsaV9zZXR1cF9zcGRpZl9vdXQoY2FyZCwgQUxJX1BDTV9UT19TUERJRl9PVVQpOwoJCWFsaV9kaXNhYmxlX3NwZWNpYWxfY2hhbm5lbChjYXJkLCBBTElfU1BESUZfT1VUX0NIQU5ORUwpOwoJCWJyZWFrOwoJY2FzZSAnMSc6CgkJYWxpX3NldHVwX3NwZGlmX291dChjYXJkLCBBTElfU1BESUZfT1VUX1RPX1NQRElGX09VVCB8IAoJCQkJICAgIEFMSV9TUERJRl9PVVRfUENNKTsKCQlicmVhazsKCWNhc2UgJzInOgoJCWFsaV9zZXR1cF9zcGRpZl9vdXQoY2FyZCwgQUxJX1NQRElGX09VVF9UT19TUERJRl9PVVQgfCAKCQkJCSAgICBBTElfU1BESUZfT1VUX05PTl9QQ00pOwoJCWJyZWFrOwoJY2FzZSAnMyc6CgkJYWxpX2Rpc2FibGVfc3BkaWZfaW4oY2FyZCk7CS8vZGVmYXVsdAoJCWJyZWFrOwoJY2FzZSAnNCc6CgkJYWxpX3NldHVwX3NwZGlmX2luKGNhcmQpOwoJCWJyZWFrOwoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmY2FyZC0+bG9jaywgZmxhZ3MpOwoKCXJldHVybiBjb3VudDsKfQoKLyogT1NTIC9kZXYvbWl4ZXIgZmlsZSBvcGVyYXRpb24gbWV0aG9kcyAqLwpzdGF0aWMgaW50CnRyaWRlbnRfb3Blbl9taXhkZXYoc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCWludCBpID0gMDsKCWludCBtaW5vciA9IGltaW5vcihpbm9kZSk7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gZGV2czsKCglmb3IgKGNhcmQgPSBkZXZzOyBjYXJkICE9IE5VTEw7IGNhcmQgPSBjYXJkLT5uZXh0KQoJCWZvciAoaSA9IDA7IGkgPCBOUl9BQzk3OyBpKyspCgkJCWlmIChjYXJkLT5hYzk3X2NvZGVjW2ldICE9IE5VTEwgJiYgCgkJCSAgICBjYXJkLT5hYzk3X2NvZGVjW2ldLT5kZXZfbWl4ZXIgPT0gbWlub3IpCgkJCQlnb3RvIG1hdGNoOwoKCWlmICghY2FyZCkgewoJCXJldHVybiAtRU5PREVWOwoJfQogICAgICBtYXRjaDoKCWZpbGUtPnByaXZhdGVfZGF0YSA9IGNhcmQtPmFjOTdfY29kZWNbaV07CgoJcmV0dXJuIG5vbnNlZWthYmxlX29wZW4oaW5vZGUsIGZpbGUpOwp9CgpzdGF0aWMgaW50CnRyaWRlbnRfaW9jdGxfbWl4ZGV2KHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCAKCQkgICAgIHVuc2lnbmVkIGxvbmcgYXJnKQp7CglzdHJ1Y3QgYWM5N19jb2RlYyAqY29kZWMgPSAoc3RydWN0IGFjOTdfY29kZWMgKikgZmlsZS0+cHJpdmF0ZV9kYXRhOwoKCXJldHVybiBjb2RlYy0+bWl4ZXJfaW9jdGwoY29kZWMsIGNtZCwgYXJnKTsKfQoKc3RhdGljIC8qY29uc3QgKi8gc3RydWN0IGZpbGVfb3BlcmF0aW9ucyB0cmlkZW50X21peGVyX2ZvcHMgPSB7Cgkub3duZXIgPSBUSElTX01PRFVMRSwKCS5sbHNlZWsgPSBub19sbHNlZWssCgkuaW9jdGwgPSB0cmlkZW50X2lvY3RsX21peGRldiwKCS5vcGVuID0gdHJpZGVudF9vcGVuX21peGRldiwKfTsKCnN0YXRpYyBpbnQKYWxpX3Jlc2V0XzU0NTEoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkKewoJc3RydWN0IHBjaV9kZXYgKnBjaV9kZXYgPSBOVUxMOwoJdW5zaWduZWQgaW50IGR3VmFsOwoJdW5zaWduZWQgc2hvcnQgd0NvdW50LCB3UmVnOwoKCXBjaV9kZXYgPSBwY2lfZmluZF9kZXZpY2UoUENJX1ZFTkRPUl9JRF9BTCwgUENJX0RFVklDRV9JRF9BTF9NMTUzMywgCgkJCQkgIHBjaV9kZXYpOwoJaWYgKHBjaV9kZXYgPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJcGNpX3JlYWRfY29uZmlnX2R3b3JkKHBjaV9kZXYsIDB4N2MsICZkd1ZhbCk7CglwY2lfd3JpdGVfY29uZmlnX2R3b3JkKHBjaV9kZXYsIDB4N2MsIGR3VmFsIHwgMHgwODAwMDAwMCk7Cgl1ZGVsYXkoNTAwMCk7CglwY2lfcmVhZF9jb25maWdfZHdvcmQocGNpX2RldiwgMHg3YywgJmR3VmFsKTsKCXBjaV93cml0ZV9jb25maWdfZHdvcmQocGNpX2RldiwgMHg3YywgZHdWYWwgJiAweGY3ZmZmZmZmKTsKCXVkZWxheSg1MDAwKTsKCglwY2lfZGV2ID0gY2FyZC0+cGNpX2RldjsKCWlmIChwY2lfZGV2ID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCXBjaV9yZWFkX2NvbmZpZ19kd29yZChwY2lfZGV2LCAweDQ0LCAmZHdWYWwpOwoJcGNpX3dyaXRlX2NvbmZpZ19kd29yZChwY2lfZGV2LCAweDQ0LCBkd1ZhbCB8IDB4MDAwYzAwMDApOwoJdWRlbGF5KDUwMCk7CglwY2lfcmVhZF9jb25maWdfZHdvcmQocGNpX2RldiwgMHg0NCwgJmR3VmFsKTsKCXBjaV93cml0ZV9jb25maWdfZHdvcmQocGNpX2RldiwgMHg0NCwgZHdWYWwgJiAweGZmZmJmZmZmKTsKCXVkZWxheSg1MDAwKTsKCgkvKiBUT0RPOiByZWNvZ25pemUgaWYgd2UgaGF2ZSBhIFBNIGNhcGFibGUgY29kZWMgYW5kIG9ubHkgZG8gdGhpcyAqLwoJLyogaWYgdGhlIGNvZGVjIGlzIFBNIGNhcGFibGUgKi8KCXdDb3VudCA9IDIwMDA7Cgl3aGlsZSAod0NvdW50LS0pIHsKCQl3UmVnID0gYWxpX2FjOTdfZ2V0KGNhcmQsIDAsIEFDOTdfUE9XRVJfQ09OVFJPTCk7CgkJaWYgKCh3UmVnICYgMHgwMDBmKSA9PSAweDAwMGYpCgkJCXJldHVybiAwOwoJCXVkZWxheSg1MDAwKTsKCX0KCS8qIFRoaXMgaXMgbm9uIGZhdGFsIGlmIHlvdSBoYXZlIGEgbm9uIFBNIGNhcGFibGUgY29kZWMuLiAqLwoJcmV0dXJuIDA7Cn0KCi8qIEFDOTcgY29kZWMgaW5pdGlhbGlzYXRpb24uICovCnN0YXRpYyBpbnQgX19kZXZpbml0CnRyaWRlbnRfYWM5N19pbml0KHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCWludCBudW1fYWM5NyA9IDA7Cgl1bnNpZ25lZCBsb25nIHJlYWR5XzJuZCA9IDA7CglzdHJ1Y3QgYWM5N19jb2RlYyAqY29kZWM7CglpbnQgaSA9IDA7CgoJLyogaW5pdGlhbGl6ZSBjb250cm9sbGVyIHNpZGUgb2YgQUMgbGluaywgYW5kIGZpbmQgb3V0IGlmIHNlY29uZGFyeSBjb2RlcwoJICAgcmVhbGx5IGV4aXN0ICovCglzd2l0Y2ggKGNhcmQtPnBjaV9pZCkgewoJY2FzZSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxOgoJCWlmIChhbGlfcmVzZXRfNTQ1MShjYXJkKSkgewoJCQlwcmludGsoS0VSTl9FUlIgInRyaWRlbnRfYWM5N19pbml0OiBlcnJvciAiCgkJCSAgICAgICAicmVzZXR0aW5nIDU0NTEuXG4iKTsKCQkJcmV0dXJuIC0xOwoJCX0KCQlvdXRsKDB4ODAwMDAwMDEsIFRSSURfUkVHKGNhcmQsIEFMSV9HTE9CQUxfQ09OVFJPTCkpOwoJCW91dGwoMHgwMDAwMDAwMCwgVFJJRF9SRUcoY2FyZCwgVDREX0FJTlRFTl9BKSk7CgkJb3V0bCgweGZmZmZmZmZmLCBUUklEX1JFRyhjYXJkLCBUNERfQUlOVF9BKSk7CgkJb3V0bCgweDAwMDAwMDAwLCBUUklEX1JFRyhjYXJkLCBUNERfTVVTSUNWT0xfV0FWRVZPTCkpOwoJCW91dGIoMHgxMCwgVFJJRF9SRUcoY2FyZCwgQUxJX01QVVIyKSk7CgkJcmVhZHlfMm5kID0gaW5sKFRSSURfUkVHKGNhcmQsIEFMSV9TQ1RSTCkpOwoJCXJlYWR5XzJuZCAmPSAweDNmZmY7CgkJb3V0bChyZWFkeV8ybmQgfCBQQ01PVVQgfCAweDgwMDAsIFRSSURfUkVHKGNhcmQsIEFMSV9TQ1RSTCkpOwoJCXJlYWR5XzJuZCA9IGlubChUUklEX1JFRyhjYXJkLCBBTElfU0NUUkwpKTsKCQlyZWFkeV8ybmQgJj0gU0lfQUM5N19TRUNPTkRBUllfUkVBRFk7CgkJaWYgKGNhcmQtPnJldmlzaW9uIDwgQUxJXzU0NTFfVjAyKQoJCQlyZWFkeV8ybmQgPSAwOwoJCWJyZWFrOwoJY2FzZSBQQ0lfREVWSUNFX0lEX1NJXzcwMTg6CgkJLyogZGlzYWJsZSBBQzk3IEdQSU8gaW50ZXJydXB0ICovCgkJb3V0bCgweDAwLCBUUklEX1JFRyhjYXJkLCBTSV9BQzk3X0dQSU8pKTsKCQkvKiB3aGVuIHBvd2VyIHVwIHRoZSBBQyBsaW5rIGlzIGluIGNvbGQgcmVzZXQgbW9kZSBzbyBzdG9wIGl0ICovCgkJb3V0bChQQ01PVVQgfCBTVVJST1VUIHwgQ0VOVEVST1VUIHwgTEZFT1VUIHwgU0VDT05EQVJZX0lELCAKCQkgICAgIFRSSURfUkVHKGNhcmQsIFNJX1NFUklBTF9JTlRGX0NUUkwpKTsKCQkvKiBpdCB0YWtlIGEgbG9uZyB0aW1lIHRvIHJlY292ZXIgZnJvbSBhIGNvbGQgcmVzZXQgKi8gCgkJLyogKGVzcGVjaWFsbHkgd2hlbiB5b3UgaGF2ZSBtb3JlIHRoYW4gb25lIGNvZGVjKSAqLwoJCXVkZWxheSgyMDAwKTsKCQlyZWFkeV8ybmQgPSBpbmwoVFJJRF9SRUcoY2FyZCwgU0lfU0VSSUFMX0lOVEZfQ1RSTCkpOwoJCXJlYWR5XzJuZCAmPSBTSV9BQzk3X1NFQ09OREFSWV9SRUFEWTsKCQlicmVhazsKCWNhc2UgUENJX0RFVklDRV9JRF9UUklERU5UXzREV0FWRV9EWDoKCQkvKiBwbGF5YmFjayBvbiAqLwoJCW91dGwoRFhfQUM5N19QTEFZQkFDSywgVFJJRF9SRUcoY2FyZCwgRFhfQUNSMl9BQzk3X0NPTV9TVEFUKSk7CgkJYnJlYWs7CgljYXNlIFBDSV9ERVZJQ0VfSURfVFJJREVOVF80RFdBVkVfTlg6CgkJLyogZW5hYmxlIEFDOTcgT3V0cHV0IFNsb3QgMyw0IChQQ00gTGVmdC9SaWdodCBQbGF5YmFjaykgKi8KCQlvdXRsKE5YX0FDOTdfUENNX09VVFBVVCwgVFJJRF9SRUcoY2FyZCwgTlhfQUNSMF9BQzk3X0NPTV9TVEFUKSk7CgkJcmVhZHlfMm5kID0gaW5sKFRSSURfUkVHKGNhcmQsIE5YX0FDUjBfQUM5N19DT01fU1RBVCkpOwoJCXJlYWR5XzJuZCAmPSBOWF9BQzk3X1NFQ09OREFSWV9SRUFEWTsKCQlicmVhazsKCWNhc2UgUENJX0RFVklDRV9JRF9JTlRFUkdfNTA1MDoKCQkvKiBkaXNhYmxlIEFDOTcgR1BJTyBpbnRlcnJ1cHQgKi8KCQlvdXRsKDB4MDAsIFRSSURfUkVHKGNhcmQsIFNJX0FDOTdfR1BJTykpOwoJCS8qIHdoZW4gcG93ZXIgdXAsIHRoZSBBQyBsaW5rIGlzIGluIGNvbGQgcmVzZXQgbW9kZSwgc28gc3RvcCBpdCAqLwoJCW91dGwoUENNT1VUIHwgU1VSUk9VVCB8IENFTlRFUk9VVCB8IExGRU9VVCwgCgkJICAgICBUUklEX1JFRyhjYXJkLCBTSV9TRVJJQUxfSU5URl9DVFJMKSk7CgkJLyogaXQgdGFrZSBhIGxvbmcgdGltZSB0byByZWNvdmVyIGZyb20gYSBjb2xkIHJlc2V0IChlc3BlY2lhbGx5ICovIAoJCS8qIHdoZW4geW91IGhhdmUgbW9yZSB0aGFuIG9uZSBjb2RlYykgKi8KCQl1ZGVsYXkoMjAwMCk7CgkJcmVhZHlfMm5kID0gaW5sKFRSSURfUkVHKGNhcmQsIFNJX1NFUklBTF9JTlRGX0NUUkwpKTsKCQlyZWFkeV8ybmQgJj0gU0lfQUM5N19TRUNPTkRBUllfUkVBRFk7CgkJYnJlYWs7Cgl9CgoJZm9yIChudW1fYWM5NyA9IDA7IG51bV9hYzk3IDwgTlJfQUM5NzsgbnVtX2FjOTcrKykgewoJCWlmICgoY29kZWMgPSBhYzk3X2FsbG9jX2NvZGVjKCkpID09IE5VTEwpCgkJCXJldHVybiAtRU5PTUVNOwoKCQkvKiBpbml0aWFsaXplIHNvbWUgYmFzaWMgY29kZWMgaW5mb3JtYXRpb24sIG90aGVyIGZpZWxkcyAqLyAKCQkvKiB3aWxsIGJlIGZpbGxlZCBpbiBhYzk3X3Byb2JlX2NvZGVjICovCgkJY29kZWMtPnByaXZhdGVfZGF0YSA9IGNhcmQ7CgkJY29kZWMtPmlkID0gbnVtX2FjOTc7CgoJCWlmIChjYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSkgewoJCQljb2RlYy0+Y29kZWNfcmVhZCA9IGFsaV9hYzk3X3JlYWQ7CgkJCWNvZGVjLT5jb2RlY193cml0ZSA9IGFsaV9hYzk3X3dyaXRlOwoJCX0gZWxzZSB7CgkJCWNvZGVjLT5jb2RlY19yZWFkID0gdHJpZGVudF9hYzk3X2dldDsKCQkJY29kZWMtPmNvZGVjX3dyaXRlID0gdHJpZGVudF9hYzk3X3NldDsKCQl9CgoJCWlmIChhYzk3X3Byb2JlX2NvZGVjKGNvZGVjKSA9PSAwKQoJCQlicmVhazsKCgkJY29kZWMtPmRldl9taXhlciA9IHJlZ2lzdGVyX3NvdW5kX21peGVyKCZ0cmlkZW50X21peGVyX2ZvcHMsIC0xKTsKCQlpZiAoY29kZWMtPmRldl9taXhlciA8IDApIHsKCQkJcHJpbnRrKEtFUk5fRVJSICJ0cmlkZW50OiBjb3VsZG4ndCByZWdpc3RlciBtaXhlciFcbiIpOwoJCQlhYzk3X3JlbGVhc2VfY29kZWMoY29kZWMpOwoJCQlicmVhazsKCQl9CgoJCWNhcmQtPmFjOTdfY29kZWNbbnVtX2FjOTddID0gY29kZWM7CgoJCS8qIGlmIHRoZXJlIGlzIG5vIHNlY29uZGFyeSBjb2RlYyBhdCBhbGwsIGRvbid0IHByb2JlIGFueSBtb3JlICovCgkJaWYgKCFyZWFkeV8ybmQpCgkJCWJyZWFrOwoJfQoKCWlmIChjYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSkgewoJCWZvciAobnVtX2FjOTcgPSAwOyBudW1fYWM5NyA8IE5SX0FDOTc7IG51bV9hYzk3KyspIHsKCQkJaWYgKGNhcmQtPmFjOTdfY29kZWNbbnVtX2FjOTddID09IE5VTEwpCgkJCQlicmVhazsKCQkJZm9yIChpID0gMDsgaSA8IDY0OyBpKyspIHsKCQkJCXUxNiByZWcgPSBhbGlfYWM5N19nZXQoY2FyZCwgbnVtX2FjOTcsIGkgKiAyKTsKCQkJCWNhcmQtPm1peGVyX3JlZ3NbaV1bbnVtX2FjOTddID0gcmVnOwoJCQl9CgkJfQoJfQoJcmV0dXJuIG51bV9hYzk3ICsgMTsKfQoKI2lmZGVmIFNVUFBPUlRfSk9ZU1RJQ0sKLyogR2FtZXBvcnQgZnVuY3Rpb25zIGZvciB0aGUgY2FyZHMgQURDIGdhbWVwb3J0ICovCgpzdGF0aWMgdW5zaWduZWQgY2hhciB0cmlkZW50X2dhbWVfcmVhZChzdHJ1Y3QgZ2FtZXBvcnQgKmdhbWVwb3J0KQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gZ2FtZXBvcnQtPnBvcnRfZGF0YTsKCglyZXR1cm4gaW5iKFRSSURfUkVHKGNhcmQsIFQ0RF9HQU1FX0xFRykpOwp9CgpzdGF0aWMgdm9pZCB0cmlkZW50X2dhbWVfdHJpZ2dlcihzdHJ1Y3QgZ2FtZXBvcnQgKmdhbWVwb3J0KQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gZ2FtZXBvcnQtPnBvcnRfZGF0YTsKCglvdXRiKDB4ZmYsIFRSSURfUkVHKGNhcmQsIFQ0RF9HQU1FX0xFRykpOwp9CgpzdGF0aWMgaW50IHRyaWRlbnRfZ2FtZV9jb29rZWRfcmVhZChzdHJ1Y3QgZ2FtZXBvcnQgKmdhbWVwb3J0LAoJCQkJICAgIGludCAqYXhlcywgaW50ICpidXR0b25zKQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gZ2FtZXBvcnQtPnBvcnRfZGF0YTsKCWludCBpOwoKCSpidXR0b25zID0gKH5pbmIoVFJJRF9SRUcoY2FyZCwgVDREX0dBTUVfTEVHKSkgPj4gNCkgJiAweGY7CgoJZm9yIChpID0gMDsgaSA8IDQ7IGkrKykgewoJCWF4ZXNbaV0gPSBpbncoVFJJRF9SRUcoY2FyZCwgVDREX0dBTUVfQVhEKSArIGkgKiBzaXplb2YgKHUxNikpOwoJCWlmIChheGVzW2ldID09IDB4ZmZmZikKCQkJYXhlc1tpXSA9IC0xOwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IHRyaWRlbnRfZ2FtZV9vcGVuKHN0cnVjdCBnYW1lcG9ydCAqZ2FtZXBvcnQsIGludCBtb2RlKQp7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gZ2FtZXBvcnQtPnBvcnRfZGF0YTsKCglzd2l0Y2ggKG1vZGUpIHsKCWNhc2UgR0FNRVBPUlRfTU9ERV9DT09LRUQ6CgkJb3V0YigweDgwLCBUUklEX1JFRyhjYXJkLCBUNERfR0FNRV9DUikpOwoJCW1zbGVlcCgyMCk7CgkJcmV0dXJuIDA7CgljYXNlIEdBTUVQT1JUX01PREVfUkFXOgoJCW91dGIoMHgwMCwgVFJJRF9SRUcoY2FyZCwgVDREX0dBTUVfQ1IpKTsKCQlyZXR1cm4gMDsKCWRlZmF1bHQ6CgkJcmV0dXJuIC0xOwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IF9fZGV2aW5pdCB0cmlkZW50X3JlZ2lzdGVyX2dhbWVwb3J0KHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpCnsKCXN0cnVjdCBnYW1lcG9ydCAqZ3A7CgoJY2FyZC0+Z2FtZXBvcnQgPSBncCA9IGdhbWVwb3J0X2FsbG9jYXRlX3BvcnQoKTsKCWlmICghZ3ApIHsKCQlwcmludGsoS0VSTl9FUlIgInRyaWRlbnQ6IGNhbiBub3QgYWxsb2NhdGUgbWVtb3J5IGZvciBnYW1lcG9ydFxuIik7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgoJZ2FtZXBvcnRfc2V0X25hbWUoZ3AsICJUcmlkZW50IDREV2F2ZSIpOwoJZ2FtZXBvcnRfc2V0X3BoeXMoZ3AsICJwY2klcy9nYW1lcG9ydDAiLCBwY2lfbmFtZShjYXJkLT5wY2lfZGV2KSk7CglncC0+cmVhZCA9IHRyaWRlbnRfZ2FtZV9yZWFkOwoJZ3AtPnRyaWdnZXIgPSB0cmlkZW50X2dhbWVfdHJpZ2dlcjsKCWdwLT5jb29rZWRfcmVhZCA9IHRyaWRlbnRfZ2FtZV9jb29rZWRfcmVhZDsKCWdwLT5vcGVuID0gdHJpZGVudF9nYW1lX29wZW47CglncC0+ZnV6eiA9IDY0OwoJZ3AtPnBvcnRfZGF0YSA9IGNhcmQ7CgoJZ2FtZXBvcnRfcmVnaXN0ZXJfcG9ydChncCk7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCB0cmlkZW50X3VucmVnaXN0ZXJfZ2FtZXBvcnQoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkKewoJaWYgKGNhcmQtPmdhbWVwb3J0KQoJCWdhbWVwb3J0X3VucmVnaXN0ZXJfcG9ydChjYXJkLT5nYW1lcG9ydCk7Cn0KCiNlbHNlCnN0YXRpYyBpbmxpbmUgaW50IHRyaWRlbnRfcmVnaXN0ZXJfZ2FtZXBvcnQoc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZCkgeyByZXR1cm4gLUVOT1NZUzsgfQpzdGF0aWMgaW5saW5lIHZvaWQgdHJpZGVudF91bnJlZ2lzdGVyX2dhbWVwb3J0KHN0cnVjdCB0cmlkZW50X2NhcmQgKmNhcmQpIHsgfQojZW5kaWYgLyogU1VQUE9SVF9KT1lTVElDSyAqLwoKLyogaW5zdGFsbCB0aGUgZHJpdmVyLCB3ZSBkbyBub3QgYWxsb2NhdGUgaGFyZHdhcmUgY2hhbm5lbCBub3IgRE1BIGJ1ZmZlciAqLyAKLyogbm93LCB0aGV5IGFyZSBkZWZlcmVkIHVudGlsICJBQ0NFU1MiIHRpbWUgKGluIHByb2dfZG1hYnVmIGNhbGxlZCBieSAqLyAKLyogb3Blbi9yZWFkL3dyaXRlL2lvY3RsL21tYXApICovCnN0YXRpYyBpbnQgX19kZXZpbml0CnRyaWRlbnRfcHJvYmUoc3RydWN0IHBjaV9kZXYgKnBjaV9kZXYsIGNvbnN0IHN0cnVjdCBwY2lfZGV2aWNlX2lkICpwY2lfaWQpCnsKCXVuc2lnbmVkIGxvbmcgaW9iYXNlOwoJc3RydWN0IHRyaWRlbnRfY2FyZCAqY2FyZDsKCXU4IGJpdHM7Cgl1OCByZXZpc2lvbjsKCWludCBpID0gMDsKCXUxNiB0ZW1wOwoJc3RydWN0IHBjaV9kZXYgKnBjaV9kZXZfbTE1MzMgPSBOVUxMOwoJaW50IHJjID0gLUVOT0RFVjsKCXU2NCBkbWFfbWFzazsKCglpZiAocGNpX2VuYWJsZV9kZXZpY2UocGNpX2RldikpCgkJZ290byBvdXQ7CgoJaWYgKHBjaV9kZXYtPmRldmljZSA9PSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKQoJCWRtYV9tYXNrID0gQUxJX0RNQV9NQVNLOwoJZWxzZQoJCWRtYV9tYXNrID0gVFJJREVOVF9ETUFfTUFTSzsKCWlmIChwY2lfc2V0X2RtYV9tYXNrKHBjaV9kZXYsIGRtYV9tYXNrKSkgewoJCXByaW50ayhLRVJOX0VSUiAidHJpZGVudDogYXJjaGl0ZWN0dXJlIGRvZXMgbm90IHN1cHBvcnQiIAoJCSAgICAgICAiICVzIFBDSSBidXNtYXN0ZXIgRE1BXG4iLCAKCQkgICAgICAgcGNpX2Rldi0+ZGV2aWNlID09IFBDSV9ERVZJQ0VfSURfQUxJXzU0NTEgPyAKCQkgICAgICAgIjMyLWJpdCIgOiAiMzAtYml0Iik7CgkJZ290byBvdXQ7Cgl9CglwY2lfcmVhZF9jb25maWdfYnl0ZShwY2lfZGV2LCBQQ0lfQ0xBU1NfUkVWSVNJT04sICZyZXZpc2lvbik7CgoJaWYgKHBjaV9pZC0+ZGV2aWNlID09IFBDSV9ERVZJQ0VfSURfSU5URVJHXzUwNTApCgkJaW9iYXNlID0gcGNpX3Jlc291cmNlX3N0YXJ0KHBjaV9kZXYsIDEpOwoJZWxzZQoJCWlvYmFzZSA9IHBjaV9yZXNvdXJjZV9zdGFydChwY2lfZGV2LCAwKTsKCglpZiAoIXJlcXVlc3RfcmVnaW9uKGlvYmFzZSwgMjU2LCBjYXJkX25hbWVzW3BjaV9pZC0+ZHJpdmVyX2RhdGFdKSkgewoJCXByaW50ayhLRVJOX0VSUiAidHJpZGVudDogY2FuJ3QgYWxsb2NhdGUgSS9PIHNwYWNlIGF0ICIKCQkgICAgICAgIjB4JTQuNGx4XG4iLCBpb2Jhc2UpOwoJCWdvdG8gb3V0OwoJfQoKCXJjID0gLUVOT01FTTsKCWlmICgoY2FyZCA9IGttYWxsb2Moc2l6ZW9mKCpjYXJkKSwgR0ZQX0tFUk5FTCkpID09IE5VTEwpIHsKCQlwcmludGsoS0VSTl9FUlIgInRyaWRlbnQ6IG91dCBvZiBtZW1vcnlcbiIpOwoJCWdvdG8gb3V0X3JlbGVhc2VfcmVnaW9uOwoJfQoJbWVtc2V0KGNhcmQsIDAsIHNpemVvZiAoKmNhcmQpKTsKCglpbml0X3RpbWVyKCZjYXJkLT50aW1lcik7CgljYXJkLT5pb2Jhc2UgPSBpb2Jhc2U7CgljYXJkLT5wY2lfZGV2ID0gcGNpX2RldjsKCWNhcmQtPnBjaV9pZCA9IHBjaV9pZC0+ZGV2aWNlOwoJY2FyZC0+cmV2aXNpb24gPSByZXZpc2lvbjsKCWNhcmQtPmlycSA9IHBjaV9kZXYtPmlycTsKCWNhcmQtPm5leHQgPSBkZXZzOwoJY2FyZC0+bWFnaWMgPSBUUklERU5UX0NBUkRfTUFHSUM7CgljYXJkLT5iYW5rc1tCQU5LX0FdLmFkZHJlc3NlcyA9ICZiYW5rX2FfYWRkcnM7CgljYXJkLT5iYW5rc1tCQU5LX0FdLmJpdG1hcCA9IDBVTDsKCWNhcmQtPmJhbmtzW0JBTktfQl0uYWRkcmVzc2VzID0gJmJhbmtfYl9hZGRyczsKCWNhcmQtPmJhbmtzW0JBTktfQl0uYml0bWFwID0gMFVMOwoKCW11dGV4X2luaXQoJmNhcmQtPm9wZW5fbXV0ZXgpOwoJc3Bpbl9sb2NrX2luaXQoJmNhcmQtPmxvY2spOwoJaW5pdF90aW1lcigmY2FyZC0+dGltZXIpOwoKCWRldnMgPSBjYXJkOwoKCXBjaV9zZXRfbWFzdGVyKHBjaV9kZXYpOwoKCXByaW50ayhLRVJOX0lORk8gInRyaWRlbnQ6ICVzIGZvdW5kIGF0IElPIDB4JTA0bHgsIElSUSAlZFxuIiwgCgkgICAgICAgY2FyZF9uYW1lc1twY2lfaWQtPmRyaXZlcl9kYXRhXSwgY2FyZC0+aW9iYXNlLCBjYXJkLT5pcnEpOwoKCWlmIChjYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSkgewoJCS8qIEFMaSBjaGFubmVsIE1hbmFnZW1lbnQgKi8KCQljYXJkLT5hbGxvY19wY21fY2hhbm5lbCA9IGFsaV9hbGxvY19wY21fY2hhbm5lbDsKCQljYXJkLT5hbGxvY19yZWNfcGNtX2NoYW5uZWwgPSBhbGlfYWxsb2NfcmVjX3BjbV9jaGFubmVsOwoJCWNhcmQtPmZyZWVfcGNtX2NoYW5uZWwgPSBhbGlfZnJlZV9wY21fY2hhbm5lbDsKCgkJY2FyZC0+YWRkcmVzc19pbnRlcnJ1cHQgPSBhbGlfYWRkcmVzc19pbnRlcnJ1cHQ7CgoJCS8qIEFkZGVkIGJ5IE1hdHQgV3UgMDEtMDUtMjAwMSBmb3Igc3BkaWYgaW4gKi8KCQljYXJkLT5tdWx0aV9jaGFubmVsX3VzZV9jb3VudCA9IDA7CgkJY2FyZC0+cmVjX2NoYW5uZWxfdXNlX2NvdW50ID0gMDsKCgkJLyogQUxpIFNQRElGIE9VVCBmdW5jdGlvbiAqLwoJCWlmIChjYXJkLT5yZXZpc2lvbiA9PSBBTElfNTQ1MV9WMDIpIHsKCQkJYWxpX3NldHVwX3NwZGlmX291dChjYXJkLCBBTElfUENNX1RPX1NQRElGX09VVCk7CgkJCXJlcyA9IGNyZWF0ZV9wcm9jX2VudHJ5KCJBTGk1NDUxIiwgMCwgTlVMTCk7CgkJCWlmIChyZXMpIHsKCQkJCXJlcy0+d3JpdGVfcHJvYyA9IGFsaV93cml0ZV9wcm9jOwoJCQkJcmVzLT5kYXRhID0gY2FyZDsKCQkJfQoJCX0KCgkJLyogQWRkIEgvVyBWb2x1bWUgQ29udHJvbCBCeSBNYXR0IFd1IEp1bC4gMDYsIDIwMDEgKi8KCQljYXJkLT5od3ZvbGN0bCA9IDA7CgkJcGNpX2Rldl9tMTUzMyA9IHBjaV9maW5kX2RldmljZShQQ0lfVkVORE9SX0lEX0FMLCAKCQkJCQkJUENJX0RFVklDRV9JRF9BTF9NMTUzMywgCgkJCQkJCXBjaV9kZXZfbTE1MzMpOwoJCXJjID0gLUVOT0RFVjsKCQlpZiAocGNpX2Rldl9tMTUzMyA9PSBOVUxMKQoJCQlnb3RvIG91dF9wcm9jX2ZzOwoJCXBjaV9yZWFkX2NvbmZpZ19ieXRlKHBjaV9kZXZfbTE1MzMsIDB4NjMsICZiaXRzKTsKCQlpZiAoYml0cyAmICgxIDw8IDUpKQoJCQljYXJkLT5od3ZvbGN0bCA9IDE7CgkJaWYgKGNhcmQtPmh3dm9sY3RsKSB7CgkJCS8qIENsZWFyIG0xNTMzIHBjaSBjZmcgNzhoIGJpdCAzMCB0byB6ZXJvLCB3aGljaCBtYWtlcwoJCQkgICBHUElPMTEvMTIvMTMgd29yayBhcyBBQ0dQX1VQL0RPV04vTVVURS4gKi8KCQkJcGNpX3JlYWRfY29uZmlnX2J5dGUocGNpX2Rldl9tMTUzMywgMHg3YiwgJmJpdHMpOwoJCQliaXRzICY9IDB4YmY7CS8qY2xlYXIgYml0IDYgKi8KCQkJcGNpX3dyaXRlX2NvbmZpZ19ieXRlKHBjaV9kZXZfbTE1MzMsIDB4N2IsIGJpdHMpOwoJCX0KCX0gZWxzZSBpZiAoY2FyZC0+cGNpX2lkID09IFBDSV9ERVZJQ0VfSURfSU5URVJHXzUwNTApIHsKCQljYXJkLT5hbGxvY19wY21fY2hhbm5lbCA9IGN5YmVyX2FsbG9jX3BjbV9jaGFubmVsOwoJCWNhcmQtPmFsbG9jX3JlY19wY21fY2hhbm5lbCA9IGN5YmVyX2FsbG9jX3BjbV9jaGFubmVsOwoJCWNhcmQtPmZyZWVfcGNtX2NoYW5uZWwgPSBjeWJlcl9mcmVlX3BjbV9jaGFubmVsOwoJCWNhcmQtPmFkZHJlc3NfaW50ZXJydXB0ID0gY3liZXJfYWRkcmVzc19pbnRlcnJ1cHQ7CgkJY3liZXJfaW5pdF9yaXR1YWwoY2FyZCk7Cgl9IGVsc2UgewoJCWNhcmQtPmFsbG9jX3BjbV9jaGFubmVsID0gdHJpZGVudF9hbGxvY19wY21fY2hhbm5lbDsKCQljYXJkLT5hbGxvY19yZWNfcGNtX2NoYW5uZWwgPSB0cmlkZW50X2FsbG9jX3BjbV9jaGFubmVsOwoJCWNhcmQtPmZyZWVfcGNtX2NoYW5uZWwgPSB0cmlkZW50X2ZyZWVfcGNtX2NoYW5uZWw7CgkJY2FyZC0+YWRkcmVzc19pbnRlcnJ1cHQgPSB0cmlkZW50X2FkZHJlc3NfaW50ZXJydXB0OwoJfQoKCS8qIGNsYWltIG91ciBpcnEgKi8KCXJjID0gLUVOT0RFVjsKCWlmIChyZXF1ZXN0X2lycShjYXJkLT5pcnEsICZ0cmlkZW50X2ludGVycnVwdCwgSVJRRl9TSEFSRUQsCgkJCWNhcmRfbmFtZXNbcGNpX2lkLT5kcml2ZXJfZGF0YV0sIGNhcmQpKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJ0cmlkZW50OiB1bmFibGUgdG8gYWxsb2NhdGUgaXJxICVkXG4iLCAKCQkgICAgICAgY2FyZC0+aXJxKTsKCQlnb3RvIG91dF9wcm9jX2ZzOwoJfQoJLyogcmVnaXN0ZXIgL2Rldi9kc3AgKi8KCWlmICgoY2FyZC0+ZGV2X2F1ZGlvID0gcmVnaXN0ZXJfc291bmRfZHNwKCZ0cmlkZW50X2F1ZGlvX2ZvcHMsIC0xKSkgPCAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJ0cmlkZW50OiBjb3VsZG4ndCByZWdpc3RlciBEU1AgZGV2aWNlIVxuIik7CgkJZ290byBvdXRfZnJlZV9pcnE7Cgl9CgljYXJkLT5taXhlcl9yZWdzX3JlYWR5ID0gMDsKCS8qIGluaXRpYWxpemUgQUM5NyBjb2RlYyBhbmQgcmVnaXN0ZXIgL2Rldi9taXhlciAqLwoJaWYgKHRyaWRlbnRfYWM5N19pbml0KGNhcmQpIDw9IDApIHsKCQkvKiB1bnJlZ2lzdGVyIGF1ZGlvIGRldmljZXMgKi8KCQlmb3IgKGkgPSAwOyBpIDwgTlJfQUM5NzsgaSsrKSB7CgkJCWlmIChjYXJkLT5hYzk3X2NvZGVjW2ldICE9IE5VTEwpIHsKCQkJCXN0cnVjdCBhYzk3X2NvZGVjKiBjb2RlYyA9IGNhcmQtPmFjOTdfY29kZWNbaV07CgkJCQl1bnJlZ2lzdGVyX3NvdW5kX21peGVyKGNvZGVjLT5kZXZfbWl4ZXIpOwoJCQkJYWM5N19yZWxlYXNlX2NvZGVjKGNvZGVjKTsKCQkJfQoJCX0KCQlnb3RvIG91dF91bnJlZ2lzdGVyX3NvdW5kX2RzcDsKCX0KCWNhcmQtPm1peGVyX3JlZ3NfcmVhZHkgPSAxOwoJb3V0bCgweDAwLCBUUklEX1JFRyhjYXJkLCBUNERfTVVTSUNWT0xfV0FWRVZPTCkpOwoKCWlmIChjYXJkLT5wY2lfaWQgPT0gUENJX0RFVklDRV9JRF9BTElfNTQ1MSkgewoJCS8qIEFkZCBIL1cgVm9sdW1lIENvbnRyb2wgQnkgTWF0dCBXdSBKdWwuIDA2LCAyMDAxICovCgkJaWYgKGNhcmQtPmh3dm9sY3RsKSB7CgkJCS8qIEVuYWJsZSBHUElPIElSUSAoTUlTQ0lOVCBiaXQgMThoKSAqLwoJCQl0ZW1wID0gaW53KFRSSURfUkVHKGNhcmQsIFQ0RF9NSVNDSU5UICsgMikpOwoJCQl0ZW1wIHw9IDB4MDAwNDsKCQkJb3V0dyh0ZW1wLCBUUklEX1JFRyhjYXJkLCBUNERfTUlTQ0lOVCArIDIpKTsKCgkJCS8qIEVuYWJsZSBIL1cgVm9sdW1lIENvbnRyb2wgR0xPVkFMIENPTlRST0wgYml0IDAgKi8KCQkJdGVtcCA9IGludyhUUklEX1JFRyhjYXJkLCBBTElfR0xPQkFMX0NPTlRST0wpKTsKCQkJdGVtcCB8PSAweDAwMDE7CgkJCW91dHcodGVtcCwgVFJJRF9SRUcoY2FyZCwgQUxJX0dMT0JBTF9DT05UUk9MKSk7CgoJCX0KCQlpZiAoY2FyZC0+cmV2aXNpb24gPT0gQUxJXzU0NTFfVjAyKQoJCQlhbGlfY2xvc2VfbXVsdGlfY2hhbm5lbHMoKTsKCQkvKiBlZGl0ZWQgYnkgSE1TRU8gZm9yIEdUIHNvdW5kICovCiNpZiBkZWZpbmVkKENPTkZJR19BTFBIQV9OQVVUSUxVUykgfHwgZGVmaW5lZChDT05GSUdfQUxQSEFfR0VORVJJQykKCQl7CgkJCXUxNiBhYzk3X2RhdGE7CgkJCWV4dGVybiBzdHJ1Y3QgaHdycGJfc3RydWN0ICpod3JwYjsKCgkJCWlmICgoaHdycGItPnN5c190eXBlKSA9PSAyMDEpIHsKCQkJCXByaW50ayhLRVJOX0lORk8gInRyaWRlbnQ6IFJ1bm5pbmcgb24gQWxwaGEgc3lzdGVtICIKCQkJCSAgICAgICAidHlwZSBOYXV0aWx1c1xuIik7CgkJCQlhYzk3X2RhdGEgPSBhbGlfYWM5N19nZXQoY2FyZCwgMCwgQUM5N19QT1dFUl9DT05UUk9MKTsKCQkJCWFsaV9hYzk3X3NldChjYXJkLCAwLCBBQzk3X1BPV0VSX0NPTlRST0wsIAoJCQkJCSAgICAgYWM5N19kYXRhIHwgQUxJX0VBUERfUE9XRVJfRE9XTik7CgkJCX0KCQl9CiNlbmRpZgkJCQkvKiBDT05GSUdfQUxQSEFfTkFVVElMVVMgfHwgQ09ORklHX0FMUEhBX0dFTkVSSUMgKi8KCQkvKiBlZGl0ZWQgYnkgSE1TRU8gZm9yIEdUIHNvdW5kICovCgl9CglyYyA9IDA7CglwY2lfc2V0X2RydmRhdGEocGNpX2RldiwgY2FyZCk7CgoJLyogRW5hYmxlIEFkZHJlc3MgRW5naW5lIEludGVycnVwdHMgKi8KCXRyaWRlbnRfZW5hYmxlX2xvb3BfaW50ZXJydXB0cyhjYXJkKTsKCgkvKiBSZWdpc3RlciBnYW1lcG9ydCAqLwoJdHJpZGVudF9yZWdpc3Rlcl9nYW1lcG9ydChjYXJkKTsKCm91dDoKCXJldHVybiByYzsKCm91dF91bnJlZ2lzdGVyX3NvdW5kX2RzcDoKCXVucmVnaXN0ZXJfc291bmRfZHNwKGNhcmQtPmRldl9hdWRpbyk7Cm91dF9mcmVlX2lycToKCWZyZWVfaXJxKGNhcmQtPmlycSwgY2FyZCk7Cm91dF9wcm9jX2ZzOgoJaWYgKHJlcykgewoJCXJlbW92ZV9wcm9jX2VudHJ5KCJBTGk1NDUxIiwgTlVMTCk7CgkJcmVzID0gTlVMTDsKCX0KCWtmcmVlKGNhcmQpOwoJZGV2cyA9IE5VTEw7Cm91dF9yZWxlYXNlX3JlZ2lvbjoKCXJlbGVhc2VfcmVnaW9uKGlvYmFzZSwgMjU2KTsKCXJldHVybiByYzsgCn0KCnN0YXRpYyB2b2lkIF9fZGV2ZXhpdAp0cmlkZW50X3JlbW92ZShzdHJ1Y3QgcGNpX2RldiAqcGNpX2RldikKewoJaW50IGk7CglzdHJ1Y3QgdHJpZGVudF9jYXJkICpjYXJkID0gcGNpX2dldF9kcnZkYXRhKHBjaV9kZXYpOwoKCS8qCgkgKiAgICAgIEtpbGwgcnVubmluZyB0aW1lcnMgYmVmb3JlIHVubG9hZC4gV2UgY2FuJ3QgaGF2ZSB0aGVtCgkgKiAgICAgIGdvaW5nIG9mZiBhZnRlciBybW1vZCEKCSAqLwoJaWYgKGNhcmQtPmh3dm9sY3RsKQoJCWRlbF90aW1lcl9zeW5jKCZjYXJkLT50aW1lcik7CgoJLyogQUxpIFMvUERJRiBhbmQgUG93ZXIgTWFuYWdlbWVudCAqLwoJaWYgKGNhcmQtPnBjaV9pZCA9PSBQQ0lfREVWSUNFX0lEX0FMSV81NDUxKSB7CgkJYWxpX3NldHVwX3NwZGlmX291dChjYXJkLCBBTElfUENNX1RPX1NQRElGX09VVCk7CgkJYWxpX2Rpc2FibGVfc3BlY2lhbF9jaGFubmVsKGNhcmQsIEFMSV9TUERJRl9PVVRfQ0hBTk5FTCk7CgkJYWxpX2Rpc2FibGVfc3BkaWZfaW4oY2FyZCk7CgkJcmVtb3ZlX3Byb2NfZW50cnkoIkFMaTU0NTEiLCBOVUxMKTsKCX0KCgkvKiBVbnJlZ2lzdGVyIGdhbWVwb3J0ICovCgl0cmlkZW50X3VucmVnaXN0ZXJfZ2FtZXBvcnQoY2FyZCk7CgoJLyogS2lsbCBpbnRlcnJ1cHRzLCBhbmQgU1AvRElGICovCgl0cmlkZW50X2Rpc2FibGVfbG9vcF9pbnRlcnJ1cHRzKGNhcmQpOwoKCS8qIGZyZWUgaGFyZHdhcmUgcmVzb3VyY2VzICovCglmcmVlX2lycShjYXJkLT5pcnEsIGNhcmQpOwoJcmVsZWFzZV9yZWdpb24oY2FyZC0+aW9iYXNlLCAyNTYpOwoKCS8qIHVucmVnaXN0ZXIgYXVkaW8gZGV2aWNlcyAqLwoJZm9yIChpID0gMDsgaSA8IE5SX0FDOTc7IGkrKykKCQlpZiAoY2FyZC0+YWM5N19jb2RlY1tpXSAhPSBOVUxMKSB7CgkJCXVucmVnaXN0ZXJfc291bmRfbWl4ZXIoY2FyZC0+YWM5N19jb2RlY1tpXS0+ZGV2X21peGVyKTsKCQkJYWM5N19yZWxlYXNlX2NvZGVjKGNhcmQtPmFjOTdfY29kZWNbaV0pOwoJCX0KCXVucmVnaXN0ZXJfc291bmRfZHNwKGNhcmQtPmRldl9hdWRpbyk7CgoJa2ZyZWUoY2FyZCk7CgoJcGNpX3NldF9kcnZkYXRhKHBjaV9kZXYsIE5VTEwpOwp9CgpNT0RVTEVfQVVUSE9SKCJBbGFuIENveCwgQWFyb24gSG9sdHptYW4sIE9sbGllIExobywgQ2hpbmcgTGluZyBMZWUsIE11bGkgQmVuLVllaHVkYSIpOwpNT0RVTEVfREVTQ1JJUFRJT04oIlRyaWRlbnQgNERXYXZlL1NpUyA3MDE4L0FMaSA1NDUxIGFuZCBUdmlhL0lHU1QgQ3liZXJQcm81MDUwIFBDSSAiCgkJICAgIkF1ZGlvIERyaXZlciIpOwpNT0RVTEVfTElDRU5TRSgiR1BMIik7CgojZGVmaW5lIFRSSURFTlRfTU9EVUxFX05BTUUgInRyaWRlbnQiCgpzdGF0aWMgc3RydWN0IHBjaV9kcml2ZXIgdHJpZGVudF9wY2lfZHJpdmVyID0gewoJLm5hbWUgPSBUUklERU5UX01PRFVMRV9OQU1FLAoJLmlkX3RhYmxlID0gdHJpZGVudF9wY2lfdGJsLAoJLnByb2JlID0gdHJpZGVudF9wcm9iZSwKCS5yZW1vdmUgPSBfX2RldmV4aXRfcCh0cmlkZW50X3JlbW92ZSksCgkuc3VzcGVuZCA9IHRyaWRlbnRfc3VzcGVuZCwKCS5yZXN1bWUgPSB0cmlkZW50X3Jlc3VtZQp9OwoKc3RhdGljIGludCBfX2luaXQKdHJpZGVudF9pbml0X21vZHVsZSh2b2lkKQp7CglwcmludGsoS0VSTl9JTkZPICJUcmlkZW50IDREV2F2ZS9TaVMgNzAxOC9BTGkgNTQ1MSxUdmlhIEN5YmVyUHJvICIgCgkgICAgICAgIjUwNTAgUENJIEF1ZGlvLCB2ZXJzaW9uICIgRFJJVkVSX1ZFUlNJT04gIiwgIiBfX1RJTUVfXyAiICIgCgkgICAgICAgX19EQVRFX18gIlxuIik7CgoJcmV0dXJuIHBjaV9yZWdpc3Rlcl9kcml2ZXIoJnRyaWRlbnRfcGNpX2RyaXZlcik7Cn0KCnN0YXRpYyB2b2lkIF9fZXhpdAp0cmlkZW50X2NsZWFudXBfbW9kdWxlKHZvaWQpCnsKCXBjaV91bnJlZ2lzdGVyX2RyaXZlcigmdHJpZGVudF9wY2lfZHJpdmVyKTsKfQoKbW9kdWxlX2luaXQodHJpZGVudF9pbml0X21vZHVsZSk7Cm1vZHVsZV9leGl0KHRyaWRlbnRfY2xlYW51cF9tb2R1bGUpOwo=