LyoKICogVVNCIEZUREkgU0lPIGRyaXZlcgogKgogKglDb3B5cmlnaHQgKEMpIDE5OTkgLSAyMDAxCiAqCSAgICBHcmVnIEtyb2FoLUhhcnRtYW4gKGdyZWdAa3JvYWguY29tKQogKiAgICAgICAgICBCaWxsIFJ5ZGVyIChicnlkZXJAc2dpLmNvbSkKICoJQ29weXJpZ2h0IChDKSAyMDAyCiAqCSAgICBLdWJhIE9iZXIgKGt1YmFAbWFyZWltYnJpdW0ub3JnKQogKgogKglUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQogKglpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQogKgl0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvcgogKgkoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiBTZWUgRG9jdW1lbnRhdGlvbi91c2IvdXNiLXNlcmlhbC50eHQgZm9yIG1vcmUgaW5mb3JtYXRpb24gb24gdXNpbmcgdGhpcyBkcml2ZXIKICoKICogU2VlIGh0dHA6Ly9mdGRpLXVzYi1zaW8uc291cmNlZm9yZ2UubmV0IGZvciB1cHRvIGRhdGUgdGVzdGluZyBpbmZvCiAqCWFuZCBleHRyYSBkb2N1bWVudGF0aW9uCiAqCiAqICgyMS9KdWwvMjAwNCkgSWFuIEFiYm90dAogKiAgICAgIEluY29ycG9yYXRlZCBTdGV2ZW4gVHVybmVyJ3MgY29kZSB0byBhZGQgc3VwcG9ydCBmb3IgdGhlIEZUMjIzMkMgY2hpcC4KICogICAgICBUaGUgcHJlbGltaWxhcnkgcG9ydCB0byB0aGUgMi42IGtlcm5lbCB3YXMgYnkgUnVzIFYuIEJydXNoa29mZi4gIEkgaGF2ZQogKiAgICAgIGZpeGVkIGEgY291cGxlIG9mIHRoaW5ncy4KICoKICogKDI3L01heS8yMDA0KSBJYW4gQWJib3R0CiAqICAgICAgSW1wcm92ZWQgdGhyb3R0bGluZyBjb2RlLCBtb3N0bHkgc3RvbGVuIGZyb20gdGhlIFdoaXRlSEVBVCBkcml2ZXIuCiAqCiAqICgyNi9NYXIvMjAwNCkgSmFuIENhcGVrCiAqICAgICAgQWRkZWQgUElEJ3MgZm9yIElDRC1VMjAvSUNELVU0MCAtIGluY2lyY3VpdCBQSUMgZGVidWdnZXJzIGZyb20gQ0NTIEluYy4KICoKICogKDA5L0ZlYi8yMDA0KSBJYW4gQWJib3R0CiAqICAgICAgQ2hhbmdlZCBmdWxsIG5hbWUgb2YgVVNCLVVJUlQgZGV2aWNlIHRvIGF2b2lkICIvIiBjaGFyYWN0ZXIuCiAqICAgICAgQWRkZWQgRlRESSdzIGFsdGVybmF0ZSBQSUQgKDB4NjAwNikgZm9yIEZUMjMyLzI0NSBkZXZpY2VzLgogKiAgICAgIEFkZGVkIFBJRCBmb3IgIkVMViBVU0IgTW9kdWxlIFVPMTAwIiBmcm9tIFN0ZWZhbiBGcmluZ3MuCiAqCiAqICgyMS9PY3QvMjAwMykgSWFuIEFiYm90dAogKiAgICAgIFJlbmFtZWQgc29tZSBWSUQvUElEIG1hY3JvcyBmb3IgTWF0cml4IE9yYml0YWwgYW5kIFBlcmxlIFN5c3RlbXMKICogICAgICBkZXZpY2VzLiAgUmVtb3ZlZCBNYXRyaXggT3JiaXRhbCBhbmQgUGVybGUgU3lzdGVtcyBkZXZpY2VzIGZyb20gdGhlCiAqICAgICAgOFUyMzJBTSBkZXZpY2UgdGFibGUsIGJ1dCBsZWZ0IHRoZW0gaW4gdGhlIEZUMjMyQk0gdGFibGUsIGFzIHRoZXkgYXJlCiAqICAgICAga25vd24gdG8gdXNlIG9ubHkgRlQyMzJCTS4KICoKICogKDE3L09jdC8yMDAzKSBTY290dCBBbGxlbgogKiAgICAgIEFkZGVkIHZpZC9waWQgZm9yIFBlcmxlIFN5c3RlbXMgVWx0cmFQb3J0IFVTQiBzZXJpYWwgY29udmVydGVycwogKgogKiAoMjEvU2VwLzIwMDMpIElhbiBBYmJvdHQKICogICAgICBBZGRlZCBWSUQvUElEIGZvciBPbW5pZGlyZWN0aW9uYWwgQ29udHJvbCBUZWNobm9sb2d5IFVTMTAxIFVTQiB0bwogKiAgICAgIFJTLTIzMiBhZGFwdGVyIChhbHNvIHJlYmFkZ2VkIGFzIERpY2sgU21pdGggRWxlY3Ryb25pY3MgWEg2MzgxKS4KICogICAgICBWSUQvUElEIHN1cHBsaWVkIGJ5IERvbmFsZCBHb3Jkb24uCiAqCiAqICgxOS9BdWcvMjAwMykgSWFuIEFiYm90dAogKiAgICAgIEZyZWVkIHVyYidzIHRyYW5zZmVyIGJ1ZmZlciBpbiB3cml0ZSBidWxrIGNhbGxiYWNrLgogKiAgICAgIE9taXR0ZWQgc29tZSBwYXJhbm9pZCBjaGVja3MgaW4gd3JpdGUgYnVsayBjYWxsYmFjayB0aGF0IGRvbid0IG1hdHRlci4KICogICAgICBTY2hlZHVsZWQgd29yayBpbiB3cml0ZSBidWxrIGNhbGxiYWNrIHJlZ2FyZGxlc3Mgb2YgcG9ydCdzIG9wZW4gY291bnQuCiAqCiAqICgwNS9BdWcvMjAwMykgSWFuIEFiYm90dAogKiAgICAgIEFkZGVkIFZJRC9QSUQgZm9yIElEIFRFQ0ggSURUMTIyMVUgVVNCIHRvIFJTLTIzMiBhZGFwdGVyLgogKiAgICAgIFZJRC9QSUQgcHJvdmlkZWQgYnkgU3RldmUgQnJpZ2dzLgogKgogKiAoMjMvSnVsLzIwMDMpIElhbiBBYmJvdHQKICogICAgICBBZGRlZCBQSURzIGZvciBDcnlzdGFsRm9udHogNTQ3LCA2MzMsIDYzMSwgNjM1LCA2NDAgYW5kIDY0MCBmcm9tCiAqICAgICAgV2F5bmUgV3lsdXBza2kuCiAqCiAqICgxMC9KdWwvMjAwMykgRGF2aWQgR2xhbmNlCiAqICAgICAgQWRkZWQgUElEIGZvciBEU1MtMjAgU3luY1N0YXRpb24gY3JhZGxlIGZvciBTb255LUVyaWNzc29uIFA4MDAuCiAqCiAqICgyNy9KdW4vMjAwMykgSWFuIEFiYm90dAogKglSZXdvcmtlZCB0aGUgdXJiIGhhbmRsaW5nIGxvZ2ljLiAgV2UgaGF2ZSBubyBtb3JlIHBvb2wsIGJ1dCBkeW5hbWljYWxseQogKglhbGxvY2F0ZSB0aGUgdXJiIGFuZCB0aGUgdHJhbnNmZXIgYnVmZmVyIG9uIHRoZSBmbHkuICBJbiB0ZXN0aW5nIHRoaXMKICoJZG9lcyBub3QgaW5jdXJlIGFueSBtZWFzdXJhYmxlIG92ZXJoZWFkLiAgVGhpcyBhbHNvIHJlbGllcyBvbiB0aGUgZmFjdAogKgl0aGF0IHdlIGhhdmUgcHJvcGVyIHJlZmVyZW5jZSBjb3VudGluZyBsb2dpYyBmb3IgdXJicy4gIEkgbmlja2VkIHRoaXMKICoJZnJvbSBHcmVnIEtIJ3MgVmlzb3IgZHJpdmVyLgogKgogKiAoMjMvSnVuLzIwMDMpIElhbiBBYmJvdHQKICogICAgICBSZWR1Y2VkIGZsaXAgYnVmZmVyIHB1c2hlcyBhbmQgY29ycmVjdGVkIGEgZGF0YSBsZW5ndGggdGVzdCBpbgogKiAgICAgIGZ0ZGlfcmVhZF9idWxrX2NhbGxiYWNrLgogKiAgICAgIERlZmVyZXJlbmNlIHBvaW50ZXJzIGFmdGVyIGFueSBwYXJhbm9pZCBjaGVja3MsIG5vdCBiZWZvcmUuCiAqCiAqICgyMS9KdW4vMjAwMykgRXJpayBOeWdyZW4KICogICAgICBBZGRlZCBzdXBwb3J0IGZvciBIb21lIEVsZWN0cm9uaWNzIFRpcmEtMSBJUiB0cmFuc2NlaXZlciB1c2luZyBGVDIzMkJNIGNoaXAuCiAqICAgICAgU2VlIDxodHRwOi8vd3d3LmhvbWUtZWxlY3Ryby5jb20vdGlyYTEuaHRtPi4gIE9ubHkgb3BlcmF0ZXMgcHJvcGVybHkKICogICAgICBhdCAxMDAwMDAgYW5kIFJUUy1DVFMsIHNvIHNldCBjdXN0b20gZGl2aXNvciBtb2RlIG9uIHN0YXJ0dXAuCiAqICAgICAgQWxzbyBmb3JjZSB0aGUgVGlyYS0xIGFuZCBVU0ItVUlSVCB0byBvbmx5IHVzZSB0aGVpciBjdXN0b20gYmF1ZCByYXRlcy4KICoKICogKDE4L0p1bi8yMDAzKSBJYW4gQWJib3R0CiAqICAgICAgQWRkZWQgRGV2aWNlIElEIG9mIHRoZSBVU0IgcmVsYWlzIGZyb20gUnVkb2xmIEd1Z2xlciAoYmFja3BvcnRlZCBmcm9tCiAqICAgICAgUGhpbGlwcCBH/GhyaW5nJ3MgcGF0Y2ggZm9yIDIuNS54IGtlcm5lbCkuCiAqICAgICAgTW92ZWQgcmVhZCB0cmFuc2ZlciBidWZmZXIgcmVhbGxvY2F0aW9uIGludG8gc3RhcnR1cCBmdW5jdGlvbi4KICogICAgICBGcmVlIGV4aXN0aW5nIHdyaXRlIHVyYiBhbmQgdHJhbnNmZXIgYnVmZmVyIGluIHN0YXJ0dXAgZnVuY3Rpb24uCiAqICAgICAgT25seSB1c2UgdXJicyBpbiB3cml0ZSB1cmIgcG9vbCB0aGF0IHdlcmUgc3VjY2Vzc2Z1bGx5IGFsbG9jYXRlZC4KICogICAgICBNb3ZlZCBzb21lIGNvbnN0YW50IG1hY3JvcyBvdXQgb2YgZnVuY3Rpb25zLgogKiAgICAgIE1pbm9yIHdoaXRlc3BhY2UgYW5kIGNvbW1lbnQgY2hhbmdlcy4KICoKICogKDEyL0p1bi8yMDAzKSBEYXZpZCBOb3J3b29kCiAqICAgICAgQWRkZWQgc3VwcG9ydCBmb3IgVVNCLVVJUlQgSVIgdHJhbnNjZWl2ZXIgdXNpbmcgOFUyMzJBTSBjaGlwLgogKiAgICAgIFNlZSA8aHR0cDovL2hvbWUuZWFydGhsaW5rLm5ldC9+anJoZWVzL1VTQlVJUlQvaW5kZXguaHRtPi4gIE9ubHkKICogICAgICBvcGVyYXRlcyBwcm9wZXJseSBhdCAzMTI1MDAsIHNvIHNldCBjdXN0b20gZGl2aXNvciBtb2RlIG9uIHN0YXJ0dXAuCiAqCiAqICgxMi9KdW4vMjAwMykgSWFuIEFiYm90dAogKiAgICAgIEFkZGVkIFNlYWxldmVsIFNlYUxJTksrIDIxMHgsIDIyMHgsIDI0MHgsIDI4MHggdmlkL3BpZHMgZnJvbSBUdWFuIEhvYW5nCiAqICAgICAgLSBJJ3ZlIGVsaW1pbmF0ZWQgc29tZSB0aGF0IGRvbid0IHNlZW0gdG8gZXhpc3QhCiAqICAgICAgQWRkZWQgSG9tZSBFbGVjdHJvbmljcyBUaXJhLTEgSVIgdHJhbnNjZWl2ZXIgcGlkIGZyb20gQ2hyaXMgSG9ybgogKiAgICAgIFNvbWUgd2hpdGVzcGFjZS9jb2Rpbmctc3R5bGUgY2xlYW51cHMKICoKICogKDExL0p1bi8yMDAzKSBJYW4gQWJib3R0CiAqICAgICAgRml4ZWQgdW5zYWZlIHNwaW5sb2NrIHVzYWdlIGluIGZ0ZGlfd3JpdGUKICoKICogKDI0L0ZlYi8yMDAzKSBSaWNoYXJkIFNob290ZXIKICogICAgICBJbmNyZWFzZSByZWFkIGJ1ZmZlciBzaXplIHRvIGltcHJvdmUgcmVhZCBzcGVlZHMgYXQgaGlnaGVyIGJhdWQgcmF0ZXMKICogICAgICAoc3BlY2lmaWNhbGx5IHRlc3RlZCB3aXRoIHVwIHRvIDFNYi9zZWMgYXQgMS41TSBiYXVkKQogKgogKiAoMjMvRmViLzIwMDMpIEpvaG4gV2lsa2lucwogKiAgICAgIEFkZGVkIFhvbi94b2ZmIGZsb3cgY29udHJvbCAoYWN0aXZhdGluZyBzdXBwb3J0IGluIHRoZSBmdGRpIGRldmljZSkKICogICAgICBBZGRlZCB2aWQvcGlkIGZvciBWaWRlb25ldHdvcmtzL0hvbWVjaG9pY2UgKFVLIElTUCkKICoKICogKDIzL0ZlYi8yMDAzKSBCaWxsIFJ5ZGVyCiAqICAgICAgQWRkZWQgbWF0cml4IG9yYiBkZXZpY2UgdmlkL3BpZHMgZnJvbSBXYXluZSBXeWx1cHNraQogKgogKiAoMTkvRmViLzIwMDMpIElhbiBBYmJvdHQKICogICAgICBGb3IgVElPQ1NTRVJJQUwsIHNldCBhbHRfc3BlZWQgdG8gMCB3aGVuIEFTWU5DX1NQRF9NQVNLIHZhbHVlIGhhcwogKiAgICAgIGNoYW5nZWQgdG8gc29tZXRoaW5nIG90aGVyIHRoYW4gQVNZTkNfU1BEX0hJLCBBU1lOQ19TUERfVkhJLAogKiAgICAgIEFTWU5DX1NQRF9TSEkgb3IgQVNZTkNfU1BEX1dBUlAuICBBbHNvLCB1bmxlc3MgQVNZTkNfU1BEX0NVU1QgaXMgaW4KICogICAgICBmb3JjZSwgZG9uJ3QgYm90aGVyIGNoYW5naW5nIGJhdWQgcmF0ZSB3aGVuIGN1c3RvbV9kaXZpc29yIGhhcyBjaGFuZ2VkLgogKgogKiAoMTgvRmViLzIwMDMpIElhbiBBYmJvdHQKICogICAgICBGaXhlZCBUSU9DTUdFVCBoYW5kbGluZyB0byBpbmNsdWRlIHN0YXRlIG9mIERUUiBhbmQgUlRTLCB0aGUgc3RhdGUKICogICAgICBvZiB3aGljaCBhcmUgbm93IHNhdmVkIGJ5IHNldF9kdHIoKSBhbmQgc2V0X3J0cygpLgogKiAgICAgIEZpeGVkIGltcHJvcGVyIHN0b3JhZ2UgY2xhc3MgZm9yIGJ1ZiBpbiBzZXRfZHRyKCkgYW5kIHNldF9ydHMoKS4KICogICAgICBBZGRlZCBGVDIzMkJNIGNoaXAgdHlwZSBhbmQgc3VwcG9ydCBmb3IgaXRzIGV4dHJhIGJhdWQgcmF0ZXMgKGNvbXBhcmVkCiAqICAgICAgdG8gRlQ4VTIzMkFNKS4KICogICAgICBUb29rIGFjY291bnQgb2Ygc3BlY2lhbCBjYXNlIGRpdmlzb3IgdmFsdWVzIGZvciBoaWdoZXN0IGJhdWQgcmF0ZXMgb2YKICogICAgICBGVDhVMjMyQU0gYW5kIEZUMjMyQk0uCiAqICAgICAgRm9yIFRJT0NTU0VSSUFMLCBmb3JjZWQgYWx0X3NwZWVkIHRvIDAgd2hlbiBBU1lOQ19TUERfQ1VTVCBrbHVkZ2UgdXNlZCwKICogICAgICBhcyBwcmV2aW91cyBhbHRfc3BlZWQgc2V0dGluZyBpcyBub3cgc3RhbGUuCiAqICAgICAgTW92ZWQgc3RhcnR1cCBjb2RlIGNvbW1vbiBiZXR3ZWVuIHRoZSBzdGFydHVwIHJvdXRpbmVzIGZvciB0aGUKICogICAgICBkaWZmZXJlbnQgY2hpcCB0eXBlcyBpbnRvIGEgY29tbW9uIHN1YnJvdXRpbmUuCiAqCiAqICgxNy9GZWIvMjAwMykgQmlsbCBSeWRlcgogKiAgICAgIEFkZGVkIHdyaXRlIHVyYiBidWZmZXIgcG9vbCBvbiBhIHBlciBkZXZpY2UgYmFzaXMKICogICAgICBBZGRlZCBtb3JlIGNoZWNraW5nIGZvciBvcGVuIGZpbGUgb24gY2FsbGJhY2tzIChmaXhlZCBPT1BTKQogKiAgICAgIEFkZGVkIENyeXN0YWxGb250eiA2MzIgYW5kIDYzNCBQSURzCiAqICAgICAgICAgKHRoYW54IHRvIENyeXN0YWxGb250eiBmb3IgdGhlIHNhbXBsZSBkZXZpY2VzIC0gdGhleSBmbHVzaGVkIG91dAogKiAgICAgICAgICAgc29tZSBkcml2ZXIgYnVncykKICogICAgICBNaW5vciBkZWJ1Z2dpbmcgbWVzc2FnZSBjaGFuZ2VzCiAqICAgICAgQWRkZWQgdGhyb3R0bGUsIHVudGhyb3R0bGUgYW5kIGNoYXJzX2luX2J1ZmZlciBmdW5jdGlvbnMKICogICAgICBGaXhlZCBGVERJX1NJTyAodGhlIG9yaWdpbmFsIGRldmljZSkgYnVnCiAqICAgICAgRml4ZWQgc29tZSBzaHV0ZG93biBoYW5kbGluZwogKgogKgogKgogKgogKiAoMDcvSnVuLzIwMDIpIEt1YmEgT2JlcgogKglDaGFuZ2VkIEZURElfU0lPX0JBU0VfQkFVRF9UT19ESVZJU09SIG1hY3JvIGludG8gZnRkaV9iYXVkX3RvX2Rpdmlzb3IKICoJZnVuY3Rpb24uIEl0IHdhcyBnZXR0aW5nIHRvbyBjb21wbGV4LgogKglGaXggdGhlIGRpdmlzb3IgY2FsY3VsYXRpb24gbG9naWMgd2hpY2ggd2FzIHNldHRpbmcgZGl2aXNvciBvZiAwLjEyNQogKglpbnN0ZWFkIG9mIDAuNSBmb3IgZnJhY3Rpb25hbCBwYXJ0cyBvZiBkaXZpc29yIGVxdWFsIHRvIDUvOCwgNi84LCA3LzguCiAqCUFsc28gbWFrZSBpdCBidW1wIHVwIHRoZSBkaXZpc29yIHRvIG5leHQgaW50ZWdlciBpbiBjYXNlIG9mIDcvOCAtIGl0J3MKICoJYSBiZXR0ZXIgYXBwcm94aW1hdGlvbi4KICoKICogKDI1L0p1bC8yMDAyKSBCaWxsIFJ5ZGVyIGluc2VydGVkIERtaXRyaSdzIFRJT0NNSVdBSVQgcGF0Y2gKICogICAgICBOb3QgdGVzdGVkIGJ5IG1lIGJ1dCBpdCBkb2Vzbid0IGJyZWFrIGFueXRoaW5nIEkgdXNlLgogKgogKiAoMDQvSmFuLzIwMDIpIEt1YmEgT2JlcgogKglJbXBsZW1lbnRlZCAzODQwMCBiYXVkcmF0ZSBrbHVkZ2UsIHdoZXJlIGl0IGNhbiBiZSBzdWJzdGl0dXRlZCB3aXRoIG90aGVyCiAqCSAgdmFsdWVzLiBUaGF0J3MgdGhlIG9ubHkgd2F5IHRvIHNldCBjdXN0b20gYmF1ZHJhdGVzLgogKglJbXBsZW1lbnRlZCBUSU9DU1NFUklBTCwgVElPQ0dTRVJJQUwgaW9jdGwncyBzbyB0aGF0IHNldHNlcmlhbCBpcyBoYXBweS4KICoJRklYTUU6IGJvdGggYmF1ZHJhdGUgdGhpbmdzIHNob3VsZCBldmVudHVhbGx5IGdvIHRvIHVzYnNlcmlhbC5jIGFzIG90aGVyCiAqCSAgZGV2aWNlcyBtYXkgbmVlZCB0aGF0IGZ1bmN0aW9uYWxpdHkgdG9vLiBBY3R1YWxseSwgaXQgY2FuIHByb2JhYmx5IGJlCiAqCSAgbWVyZ2VkIGluIHNlcmlhbC5jIHNvbWVob3cgLSB0b28gbWFueSBkcml2ZXJzIHJlcGVhdCB0aGlzIGNvZGUgb3ZlcgogKgkgIGFuZCBvdmVyLgogKglGaXhlZCBiYXVkcmF0ZSBmb3JnZXRmdWxuZXNzIC0gb3BlbigpIHVzZWQgdG8gcmVzZXQgYmF1ZHJhdGUgdG8gOTYwMCBldmVyeSB0aW1lLgogKglEaXZpc29ycyBmb3IgYmF1ZHJhdGVzIGFyZSBjYWxjdWxhdGVkIGJ5IGEgbWFjcm8uCiAqCVNtYWxsIGNvZGUgY2xlYW51cHMuIFVnbHkgd2hpdGVzcGFjZSBjaGFuZ2VzIGZvciBQbGF0bydzIHNha2Ugb25seSA7LV0uCiAqCiAqICgwNC9Ob3YvMjAwMSkgQmlsbCBSeWRlcgogKglGaXhlZCBidWcgaW4gcmVhZF9idWxrX2NhbGxiYWNrIHdoZXJlIGluY29ycmVjdCB1cmIgYnVmZmVyIHdhcyB1c2VkLgogKglDbGVhbmVkIHVwIHdyaXRlIG9mZnNldCBjYWxjdWxhdGlvbgogKglBZGRlZCB3cml0ZV9yb29tIHNpbmNlIGRlZmF1bHQgdmFsdWVzIGNhbiBiZSBpbmNvcnJlY3QgZm9yIHNpbwogKglDaGFuZ2VkIHdyaXRlX2J1bGtfY2FsbGJhY2sgdG8gdXNlIHNhbWUgcXVldWVfdGFzayBhcyBvdGhlciBkcml2ZXJzCiAqICAgICAgICAodGhlIHByZXZpb3VzIHZlcnNpb24gY2F1c2VkIHBhbmljcykKICoJUmVtb3ZlZCBwb3J0IGl0ZXJhdGlvbiBjb2RlIHNpbmNlIHRoZSBkZXZpY2Ugb25seSBoYXMgb25lIEkvTyBwb3J0IGFuZCBpdAogKgkgIHdhcyB3cm9uZyBhbnl3YXkuCiAqCiAqICgzMS9NYXkvMjAwMSkgZ2toCiAqCVN3aXRjaGVkIGZyb20gdXNpbmcgc3BpbmxvY2sgdG8gYSBzZW1hcGhvcmUsIHdoaWNoIGZpeGVzIGxvdHMgb2YgcHJvYmxlbXMuCiAqCiAqICgyMy9NYXkvMjAwMSkgICBCaWxsIFJ5ZGVyCiAqCUFkZGVkIHJ1bnRpbWUgZGVidWcgcGF0Y2ggKHRoYW54IFR5c29uIEQgU2F3eWVyKS4KICoJQ2xlYW5lZCB1cCBjb21tZW50cyBmb3IgOFUyMzIKICoJQWRkZWQgcGFyaXR5LCBmcmFtaW5nIGFuZCBvdmVycnVuIGVycm9yIGhhbmRsaW5nCiAqCUFkZGVkIHJlY2VpdmUgYnJlYWsgaGFuZGxpbmcuCiAqCiAqICgwNC8wOC8yMDAxKSBnYgogKglJZGVudGlmeSB2ZXJzaW9uIG9uIG1vZHVsZSBsb2FkLgogKgogKiAoMTgvTWFyY2gvMjAwMSkgQmlsbCBSeWRlcgogKgkoTm90IHJlbGVhc2VkKQogKglBZGRlZCBzZW5kIGJyZWFrIGhhbmRsaW5nLiAocmVxdWlyZXMga2VybmVsIHBhdGNoIHRvbykKICoJRml4ZWQgOFUyMzJBTSBoYXJkd2FyZSBSVFMvQ1RTIGV0YyBzdGF0dXMgcmVwb3J0aW5nLgogKglBZGRlZCBmbGlwYnVmIGZpeCBjb3BpZWQgZnJvbSBnZW5lcmljIGRldmljZQogKgogKiAoMTIvMy8yMDAwKSBCaWxsIFJ5ZGVyCiAqCUFkZGVkIHN1cHBvcnQgZm9yIDhVMjMyQU0gZGV2aWNlLgogKglNb3ZlZCBQSUQgYW5kIFZJRHMgaW50byBoZWFkZXIgZmlsZSBvbmx5LgogKglUdXJuZWQgb24gbG93LWxhdGVuY3kgZm9yIHRoZSB0dHkgKGRldmljZSB3aWxsIGRvIGhpZ2ggYmF1ZHJhdGVzKQogKglBZGRlZCBzaHV0ZG93biByb3V0aW5lIHRvIGNsb3NlIGZpbGVzIHdoZW4gZGV2aWNlIHJlbW92ZWQuCiAqCU1vcmUgZGVidWcgYW5kIGVycm9yIG1lc3NhZ2UgY2xlYW51cHMuCiAqCiAqICgxMS8xMy8yMDAwKSBCaWxsIFJ5ZGVyCiAqCUFkZGVkIHNwaW5sb2NrIHByb3RlY3RlZCBvcGVuIGNvZGUgYW5kIGNsb3NlIGNvZGUuCiAqCU11bHRpcGxlIG9wZW5zIHdvcmsgKHNvcnQgb2YgLSBzZWUgd2VicGFnZSBtZW50aW9uZWQgYWJvdmUpLgogKglDbGVhbmVkIHVwIGNvbW1lbnRzLiBSZW1vdmVkIG11bHRpcGxlIFBJRC9WSUQgZGVmaW5pdGlvbnMuCiAqCUZhY3RvcmlzZWQgY3RzL2R0ciBjb2RlCiAqCU1hZGUgdXNlIG9mIF9fRlVOQ1RJT05fXyBpbiBkYmcncwogKgogKiAoMTEvMDEvMjAwMCkgQWRhbSBKLiBSaWNodGVyCiAqCXVzYl9kZXZpY2VfaWQgdGFibGUgc3VwcG9ydAogKgogKiAoMTAvMDUvMjAwMCkgZ2toCiAqCUZpeGVkIGJ1ZyB3aXRoIHVyYi0+ZGV2IG5vdCBiZWluZyBzZXQgcHJvcGVybHksIG5vdyB0aGF0IHRoZSB1c2IKICoJY29yZSBuZWVkcyBpdC4KICoKICogKDA5LzExLzIwMDApIGdraAogKglSZW1vdmVkIERFQlVHICNpZmRlZnMgd2l0aCBjYWxsIHRvIHVzYl9zZXJpYWxfZGVidWdfZGF0YQogKgogKiAoMDcvMTkvMjAwMCkgZ2toCiAqCUFkZGVkIG1vZHVsZV9pbml0IGFuZCBtb2R1bGVfZXhpdCBmdW5jdGlvbnMgdG8gaGFuZGxlIHRoZSBmYWN0IHRoYXQgdGhpcwogKglkcml2ZXIgaXMgYSBsb2FkYWJsZSBtb2R1bGUgbm93LgogKgogKiAoMDQvMDQvMjAwMCkgQmlsbCBSeWRlcgogKglGaXhlZCBidWdzIGluIFRDR0VUL1RDU0VUIGlvY3RscyAoYnkgcmVtb3ZpbmcgdGhlbSAtIHRoZXkgYXJlCiAqICAgICAgICBoYW5kbGVkIGVsc2V3aGVyZSBpbiB0aGUgdHR5IGlvIGRyaXZlciBjaGFpbikuCiAqCiAqICgwMy8zMC8yMDAwKSBCaWxsIFJ5ZGVyCiAqCUltcGxlbWVudGVkIGxvdHMgb2YgaW9jdGxzCiAqCUZpeGVkIGEgcmFjZSBjb25kaXRpb24gaW4gd3JpdGUKICoJQ2hhbmdlZCBzb21lIGRiZydzIHRvIGVycnMKICoKICogKDAzLzI2LzIwMDApIGdraAogKglTcGxpdCBkcml2ZXIgdXAgaW50byBkZXZpY2Ugc3BlY2lmaWMgcGllY2VzLgogKgogKi8KCi8qIEJpbGwgUnlkZXIgLSBicnlkZXJAc2dpLmNvbSAtIHdyb3RlIHRoZSBGVERJX1NJTyBpbXBsZW1lbnRhdGlvbiAqLwovKiBUaGFueCB0byBGVERJIGZvciBzbyBraW5kbHkgcHJvdmlkaW5nIGRldGFpbHMgb2YgdGhlIHByb3RvY29sIHJlcXVpcmVkICovCi8qICAgdG8gdGFsayB0byB0aGUgZGV2aWNlICovCi8qIFRoYW54IHRvIGdraCBhbmQgdGhlIHJlc3Qgb2YgdGhlIHVzYiBkZXYgZ3JvdXAgZm9yIGFsbCBjb2RlIEkgaGF2ZSBhc3NpbWlsYXRlZCA6LSkgKi8KCiNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KI2luY2x1ZGUgPGxpbnV4L2Vycm5vLmg+CiNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiNpbmNsdWRlIDxsaW51eC9zbGFiLmg+CiNpbmNsdWRlIDxsaW51eC90dHkuaD4KI2luY2x1ZGUgPGxpbnV4L3R0eV9kcml2ZXIuaD4KI2luY2x1ZGUgPGxpbnV4L3R0eV9mbGlwLmg+CiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiNpbmNsdWRlIDxhc20vdWFjY2Vzcy5oPgojaW5jbHVkZSA8bGludXgvdXNiLmg+CiNpbmNsdWRlIDxsaW51eC9zZXJpYWwuaD4KI2luY2x1ZGUgPGxpbnV4L3VzYi9zZXJpYWwuaD4KI2luY2x1ZGUgImZ0ZGlfc2lvLmgiCgovKgogKiBWZXJzaW9uIEluZm9ybWF0aW9uCiAqLwojZGVmaW5lIERSSVZFUl9WRVJTSU9OICJ2MS40LjMiCiNkZWZpbmUgRFJJVkVSX0FVVEhPUiAiR3JlZyBLcm9haC1IYXJ0bWFuIDxncmVnQGtyb2FoLmNvbT4sIEJpbGwgUnlkZXIgPGJyeWRlckBzZ2kuY29tPiwgS3ViYSBPYmVyIDxrdWJhQG1hcmVpbWJyaXVtLm9yZz4iCiNkZWZpbmUgRFJJVkVSX0RFU0MgIlVTQiBGVERJIFNlcmlhbCBDb252ZXJ0ZXJzIERyaXZlciIKCnN0YXRpYyBpbnQgZGVidWc7CnN0YXRpYyBfX3UxNiB2ZW5kb3IgPSBGVERJX1ZJRDsKc3RhdGljIF9fdTE2IHByb2R1Y3Q7CgovKiBzdHJ1Y3QgZnRkaV9zaW9fcXVpcmsgaXMgdXNlZCBieSBkZXZpY2VzIHJlcXVpcmluZyBzcGVjaWFsIGF0dGVudGlvbi4gKi8Kc3RydWN0IGZ0ZGlfc2lvX3F1aXJrIHsKCXZvaWQgKCpzZXR1cCkoc3RydWN0IHVzYl9zZXJpYWwgKik7IC8qIFNwZWNpYWwgc2V0dGluZ3MgZHVyaW5nIHN0YXJ0dXAuICovCn07CgpzdGF0aWMgdm9pZCAgZnRkaV9VU0JfVUlSVF9zZXR1cAkoc3RydWN0IHVzYl9zZXJpYWwgKnNlcmlhbCk7CnN0YXRpYyB2b2lkICBmdGRpX0hFX1RJUkExX3NldHVwCShzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKTsKCnN0YXRpYyBzdHJ1Y3QgZnRkaV9zaW9fcXVpcmsgZnRkaV9VU0JfVUlSVF9xdWlyayA9IHsKCS5zZXR1cCA9IGZ0ZGlfVVNCX1VJUlRfc2V0dXAsCn07CgpzdGF0aWMgc3RydWN0IGZ0ZGlfc2lvX3F1aXJrIGZ0ZGlfSEVfVElSQTFfcXVpcmsgPSB7Cgkuc2V0dXAgPSBmdGRpX0hFX1RJUkExX3NldHVwLAp9OwoKLyoKICogVGhlIDhVMjMyQU0gaGFzIHRoZSBzYW1lIEFQSSBhcyB0aGUgc2lvIGV4Y2VwdCBmb3I6CiAqIC0gaXQgY2FuIHN1cHBvcnQgTVVDSCBoaWdoZXIgYmF1ZHJhdGVzOyB1cCB0bzoKICogICBvIDkyMTYwMCBmb3IgUlMyMzIgYW5kIDIwMDAwMDAgZm9yIFJTNDIyLzQ4NSBhdCA0OE1IegogKiAgIG8gMjMwNDAwIGF0IDEyTUh6CiAqICAgc28gLi4gOFUyMzJBTSdzIGJhdWRyYXRlIHNldHRpbmcgY29kZXMgYXJlIGRpZmZlcmVudAogKiAtIGl0IGhhcyBhIHR3byBieXRlIHN0YXR1cyBjb2RlLgogKiAtIGl0IHJldHVybnMgY2hhcmFjdGVycyBldmVyeSAxNm1zICh0aGUgRlRESSBkb2VzIGl0IGV2ZXJ5IDQwbXMpCiAqCiAqIHRoZSBiY2REZXZpY2UgdmFsdWUgaXMgdXNlZCB0byBkaWZmZXJlbnRpYXRlIEZUMjMyQk0gYW5kIEZUMjQ1Qk0gZnJvbQogKiB0aGUgZWFybGllciBGVDhVMjMyQU0gYW5kIEZUOFUyMzJCTS4gIEZvciBub3csIGluY2x1ZGUgYWxsIGtub3duIFZJRC9QSUQKICogY29tYmluYXRpb25zIGluIGJvdGggdGFibGVzLgogKiBGSVhNRTogcGVyaGFwcyBiY2REZXZpY2UgY2FuIGFsc28gaWRlbnRpZnkgMTJNSHogRlQ4VTIzMkFNIGRldmljZXMsCiAqIGJ1dCBJIGRvbid0IGtub3cgaWYgdGhvc2UgZXZlciB3ZW50IGludG8gbWFzcyBwcm9kdWN0aW9uLiBbSWFuIEFiYm90dF0KICovCgoKCnN0YXRpYyBzdHJ1Y3QgdXNiX2RldmljZV9pZCBpZF90YWJsZV9jb21iaW5lZCBbXSA9IHsKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9BTUMyMzJfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0NBTlVTQl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfQUNUWldBVkVfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0lSVFJBTlNfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0lQTFVTX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9ETVg0QUxMKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1NJT19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfOFUyMzJBTV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfOFUyMzJBTV9BTFRfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJXzhVMjIzMkNfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX01JQ1JPX0NIQU1FTEVPTl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfUkVMQUlTX1BJRCkgfSwKCXsgVVNCX0RFVklDRShJTlRFUkJJT01FVFJJQ1NfVklELCBJTlRFUkJJT01FVFJJQ1NfSU9CT0FSRF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoSU5URVJCSU9NRVRSSUNTX1ZJRCwgSU5URVJCSU9NRVRSSUNTX01JTklfSU9CT0FSRF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfWEZfNjMyX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9YRl82MzRfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1hGXzU0N19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfWEZfNjMzX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9YRl82MzFfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1hGXzYzNV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfWEZfNjQwX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9YRl82NDJfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0RTUzIwX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX05GX1JJQ19WSUQsIEZURElfTkZfUklDX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9WTkhDUENVU0JfRF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTVRYT1JCXzBfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX01UWE9SQl8xX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9NVFhPUkJfMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTVRYT1JCXzNfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX01UWE9SQl80X1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9NVFhPUkJfNV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTVRYT1JCXzZfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1BFUkxFX1VMVFJBUE9SVF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfUElFR1JPVVBfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1ROQ19YX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzIxMDFfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjEwMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yMTAzX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzIxMDRfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjEwNl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yMjAxXzFfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjIwMV8yX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzIyMDJfMV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yMjAyXzJfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjIwM18xX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzIyMDNfMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yNDAxXzFfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjQwMV8yX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI0MDFfM19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yNDAxXzRfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjQwMl8xX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI0MDJfMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yNDAyXzNfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjQwMl80X1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI0MDNfMV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yNDAzXzJfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjQwM18zX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI0MDNfNF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAxXzFfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwMV8yX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDFfM19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAxXzRfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwMV81X1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDFfNl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAxXzdfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwMV84X1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDJfMV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAyXzJfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwMl8zX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDJfNF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAyXzVfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwMl82X1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDJfN19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAyXzhfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwM18xX1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDNfMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAzXzNfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwM180X1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDNfNV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoU0VBTEVWRUxfVklELCBTRUFMRVZFTF8yODAzXzZfUElEKSB9LAoJeyBVU0JfREVWSUNFKFNFQUxFVkVMX1ZJRCwgU0VBTEVWRUxfMjgwM183X1BJRCkgfSwKCXsgVVNCX0RFVklDRShTRUFMRVZFTF9WSUQsIFNFQUxFVkVMXzI4MDNfOF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoSURURUNIX1ZJRCwgSURURUNIX0lEVDEyMjFVX1BJRCkgfSwKCXsgVVNCX0RFVklDRShPQ1RfVklELCBPQ1RfVVMxMDFfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0hFX1RJUkExX1BJRCksCgkJLmRyaXZlcl9pbmZvID0gKGtlcm5lbF91bG9uZ190KSZmdGRpX0hFX1RJUkExX3F1aXJrIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfVVNCX1VJUlRfUElEKSwKCQkuZHJpdmVyX2luZm8gPSAoa2VybmVsX3Vsb25nX3QpJmZ0ZGlfVVNCX1VJUlRfcXVpcmsgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgUFJPVEVHT19TUEVDSUFMXzEpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIFBST1RFR09fUjJYMCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgUFJPVEVHT19TUEVDSUFMXzMpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIFBST1RFR09fU1BFQ0lBTF80KSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0dVREVBRFNfRTgwOF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfR1VERUFEU19FODA5X1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9HVURFQURTX0U4MEFfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0dVREVBRFNfRTgwQl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfR1VERUFEU19FODBDX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9HVURFQURTX0U4MERfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0dVREVBRFNfRTgwRV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfR1VERUFEU19FODBGX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9HVURFQURTX0U4ODhfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0dVREVBRFNfRTg4OV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfR1VERUFEU19FODhBX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9HVURFQURTX0U4OEJfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0dVREVBRFNfRTg4Q19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfR1VERUFEU19FODhEX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9HVURFQURTX0U4OEVfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0dVREVBRFNfRTg4Rl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1VPMTAwX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9FTFZfVU0xMDBfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0VMVl9VUjEwMF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX0FMQzg1MDBfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1BZUkFNSURfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0VMVl9GSFoxMDAwUENfUElEKSB9LAoJLyoKCSAqIFRoZXNlIHdpbGwgcHJvYmFibHkgdXNlIHVzZXItc3BhY2UgZHJpdmVycy4gIFVuY29tbWVudCB0aGVtIGlmCgkgKiB5b3UgbmVlZCB0aGVtIG9yIHVzZSB0aGUgdXNlci1zcGVjaWZpZWQgdmVuZG9yL3Byb2R1Y3QgbW9kdWxlCgkgKiBwYXJhbWV0ZXJzIChzZWUgZnRkaV9zaW8uaCBmb3IgdGhlIG51bWJlcnMpLiAgTWFrZSBhIGZ1c3MgaWYKCSAqIHlvdSB0aGluayB0aGUgZHJpdmVyIHNob3VsZCByZWNvZ25pemUgYW55IG9mIHRoZW0gYnkgZGVmYXVsdC4KCSAqLwoJLyogeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0VMVl9DTEk3MDAwX1BJRCkgfSwgKi8KCS8qIHsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9FTFZfUFBTNzMzMF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1RGTTEwMF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1VERjc3X1BJRCkgfSwgKi8KCS8qIHsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9FTFZfVUlPODhfUElEKSB9LCAqLwoJLyogeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0VMVl9VQUQ4X1BJRCkgfSwgKi8KCS8qIHsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9FTFZfVURBN19QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1VTSTJfUElEKSB9LCAqLwoJLyogeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0VMVl9UMTEwMF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1BDRDIwMF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1VMQTIwMF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX0NTSThfUElEKSB9LCAqLwoJLyogeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0VMVl9FTTEwMDBETF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1BDSzEwMF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX1JGUDUwMF9QSUQpIH0sICovCgkvKiB7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUxWX0ZTMjBTSUdfUElEKSB9LCAqLwoJLyogeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0VMVl9XUzMwMFBDX1BJRCkgfSwgKi8KCS8qIHsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9FTFZfRkhaMTMwMFBDX1BJRCkgfSwgKi8KCS8qIHsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9FTFZfV1M1MDBfUElEKSB9LCAqLwoJeyBVU0JfREVWSUNFKEZURElfVklELCBMSU5YX1NETVVTQlFTU19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIExJTlhfTUFTVEVSREVWRUwyX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgTElOWF9GVVRVUkVfMF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIExJTlhfRlVUVVJFXzFfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBMSU5YX0ZVVFVSRV8yX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9DQ1NJQ0RVMjBfMF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfQ0NTSUNEVTQwXzFfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBJTlNJREVfQUNDRVNTTykgfSwKCXsgVVNCX0RFVklDRShJTlRSRVBJRF9WSUQsIElOVFJFUElEX1ZBTFVFQ0FOX1BJRCkgfSwKCXsgVVNCX0RFVklDRShJTlRSRVBJRF9WSUQsIElOVFJFUElEX05FT1ZJX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGQUxDT01fVklELCBGQUxDT01fVFdJU1RfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZBTENPTV9WSUQsIEZBTENPTV9TQU1CQV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfU1VVTlRPX1NQT1JUU19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfUk1fQ0FOVklFV19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoQkFOREJfVklELCBCQU5EQl9VU09UTDRfUElEKSB9LAoJeyBVU0JfREVWSUNFKEJBTkRCX1ZJRCwgQkFOREJfVVNUTDRfUElEKSB9LAoJeyBVU0JfREVWSUNFKEJBTkRCX1ZJRCwgQkFOREJfVVNPOU1MMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEVWRVJfRUNPX1BST19DRFMpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfNE5fR0FMQVhZX0RFXzBfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJXzROX0dBTEFYWV9ERV8xX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV80Tl9HQUxBWFlfREVfMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIFhTRU5TX0NPTlZFUlRFUl8wX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgWFNFTlNfQ09OVkVSVEVSXzFfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBYU0VOU19DT05WRVJURVJfMl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIFhTRU5TX0NPTlZFUlRFUl8zX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgWFNFTlNfQ09OVkVSVEVSXzRfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBYU0VOU19DT05WRVJURVJfNV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIFhTRU5TX0NPTlZFUlRFUl82X1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgWFNFTlNfQ09OVkVSVEVSXzdfUElEKSB9LAoJeyBVU0JfREVWSUNFKE1PQklMSVRZX1ZJRCwgTU9CSUxJVFlfVVNCX1NFUklBTF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfQUNUSVZFX1JPQk9UU19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTUhBTV9LV19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTUhBTV9ZU19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTUhBTV9ZNl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTUhBTV9ZOF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTUhBTV9JQ19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfTUhBTV9EQjlfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX01IQU1fUlMyMzJfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX01IQU1fWTlfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1RFUkFUUk9OSUtfVkNQX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9URVJBVFJPTklLX0QyWFhfUElEKSB9LAoJeyBVU0JfREVWSUNFKEVWT0xVVElPTl9WSUQsIEVWT0xVVElPTl9FUjFfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0FSVEVNSVNfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0FUSUtfQVRLMTZfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0FUSUtfQVRLMTZDX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9BVElLX0FUSzE2SFJfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0FUSUtfQVRLMTZIUkNfUElEKSB9LAoJeyBVU0JfREVWSUNFKEtPQklMX1ZJRCwgS09CSUxfQ09OVl9CMV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoS09CSUxfVklELCBLT0JJTF9DT05WX0tBQU5fUElEKSB9LAoJeyBVU0JfREVWSUNFKFBPU0lGTEVYX1ZJRCwgUE9TSUZMRVhfUFA3MDAwX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9UVFVTQl9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfRUNMT19DT01fMVdJUkVfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1dFU1RSRVhfTU9ERUxfNzc3X1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9XRVNUUkVYX01PREVMXzg5MDBGX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9QQ0RKX0RBQzJfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1JSQ0lSS0lUU19MT0NPQlVGRkVSX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9BU0tfUkRSNDAwX1BJRCkgfSwKCXsgVVNCX0RFVklDRShJQ09NX0lEMV9WSUQsIElDT01fSUQxX1BJRCkgfSwKCXsgVVNCX0RFVklDRShQQVBPVUNIX1ZJRCwgUEFQT1VDSF9UTVVfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX0FDR19IRkRVQUxfUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1lFSV9TRVJWT0NFTlRFUjMxX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9USE9STEFCU19QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoVEVTVE9fVklELCBURVNUT19VU0JfSU5URVJGQUNFX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9HQU1NQV9TQ09VVF9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRlRESV9WSUQsIEZURElfVEFDVFJJWF9PUEVOUE9SVF8xM01fUElEKSB9LAoJeyBVU0JfREVWSUNFKEZURElfVklELCBGVERJX1RBQ1RSSVhfT1BFTlBPUlRfMTNTX1BJRCkgfSwKCXsgVVNCX0RFVklDRShGVERJX1ZJRCwgRlRESV9UQUNUUklYX09QRU5QT1JUXzEzVV9QSUQpIH0sCgl7IFVTQl9ERVZJQ0UoRUxFS1RPUl9WSUQsIEVMRUtUT1JfRlQzMjNSX1BJRCkgfSwKCXsgfSwJCQkJCS8qIE9wdGlvbmFsIHBhcmFtZXRlciBlbnRyeSAqLwoJeyB9CQkJCQkvKiBUZXJtaW5hdGluZyBlbnRyeSAqLwp9OwoKTU9EVUxFX0RFVklDRV9UQUJMRSAodXNiLCBpZF90YWJsZV9jb21iaW5lZCk7CgpzdGF0aWMgc3RydWN0IHVzYl9kcml2ZXIgZnRkaV9kcml2ZXIgPSB7CgkubmFtZSA9CQkiZnRkaV9zaW8iLAoJLnByb2JlID0JdXNiX3NlcmlhbF9wcm9iZSwKCS5kaXNjb25uZWN0ID0JdXNiX3NlcmlhbF9kaXNjb25uZWN0LAoJLmlkX3RhYmxlID0JaWRfdGFibGVfY29tYmluZWQsCgkubm9fZHluYW1pY19pZCA9CTEsCn07CgpzdGF0aWMgY29uc3QgY2hhciAqZnRkaV9jaGlwX25hbWVbXSA9IHsKCVtTSU9dID0gIlNJTyIsCS8qIHRoZSBzZXJpYWwgcGFydCBvZiBGVDhVMTAwQVggKi8KCVtGVDhVMjMyQU1dID0gIkZUOFUyMzJBTSIsCglbRlQyMzJCTV0gPSAiRlQyMzJCTSIsCglbRlQyMjMyQ10gPSAiRlQyMjMyQyIsCn07CgoKLyogQ29uc3RhbnRzIGZvciByZWFkIHVyYiBhbmQgd3JpdGUgdXJiICovCiNkZWZpbmUgQlVGU1ogNTEyCiNkZWZpbmUgUEtUU1ogNjQKCi8qIHJ4X2ZsYWdzICovCiNkZWZpbmUgVEhST1RUTEVECQkweDAxCiNkZWZpbmUgQUNUVUFMTFlfVEhST1RUTEVECTB4MDIKCnN0cnVjdCBmdGRpX3ByaXZhdGUgewoJZnRkaV9jaGlwX3R5cGVfdCBjaGlwX3R5cGU7CgkJCQkvKiB0eXBlIG9mIHRoZSBkZXZpY2UsIGVpdGhlciBTSU8gb3IgRlQ4VTIzMkFNICovCglpbnQgYmF1ZF9iYXNlOwkJLyogYmF1ZCBiYXNlIGNsb2NrIGZvciBkaXZpc29yIHNldHRpbmcgKi8KCWludCBjdXN0b21fZGl2aXNvcjsJLyogY3VzdG9tX2Rpdmlzb3Iga2x1ZGdlLCB0aGlzIGlzIGZvciBiYXVkX2Jhc2UgKGRpZmZlcmVudCBmcm9tIHdoYXQgZ29lcyB0byB0aGUgY2hpcCEpICovCglfX3UxNiBsYXN0X3NldF9kYXRhX3VyYl92YWx1ZSA7CgkJCQkvKiB0aGUgbGFzdCBkYXRhIHN0YXRlIHNldCAtIG5lZWRlZCBmb3IgZG9pbmcgYSBicmVhayAqLwogICAgICAgIGludCB3cml0ZV9vZmZzZXQ7ICAgICAgIC8qIFRoaXMgaXMgdGhlIG9mZnNldCBpbiB0aGUgdXNiIGRhdGEgYmxvY2sgdG8gd3JpdGUgdGhlIHNlcmlhbCBkYXRhIC0KCQkJCSAqIGl0IGlzIGRpZmZlcmVudCBiZXR3ZWVuIGRldmljZXMKCQkJCSAqLwoJaW50IGZsYWdzOwkJLyogc29tZSBBU1lOQ194eHh4IGZsYWdzIGFyZSBzdXBwb3J0ZWQgKi8KCXVuc2lnbmVkIGxvbmcgbGFzdF9kdHJfcnRzOwkvKiBzYXZlZCBtb2RlbSBjb250cm9sIG91dHB1dHMgKi8KICAgICAgICB3YWl0X3F1ZXVlX2hlYWRfdCBkZWx0YV9tc3Jfd2FpdDsgLyogVXNlZCBmb3IgVElPQ01JV0FJVCAqLwoJY2hhciBwcmV2X3N0YXR1cywgZGlmZl9zdGF0dXM7ICAgICAgICAvKiBVc2VkIGZvciBUSU9DTUlXQUlUICovCglfX3U4IHJ4X2ZsYWdzOwkJLyogcmVjZWl2ZSBzdGF0ZSBmbGFncyAodGhyb3R0bGluZykgKi8KCXNwaW5sb2NrX3QgcnhfbG9jazsJLyogc3BpbmxvY2sgZm9yIHJlY2VpdmUgc3RhdGUgKi8KCXN0cnVjdCBkZWxheWVkX3dvcmsgcnhfd29yazsKCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQ7CglpbnQgcnhfcHJvY2Vzc2VkOwoJdW5zaWduZWQgbG9uZyByeF9ieXRlczsKCglfX3UxNiBpbnRlcmZhY2U7CS8qIEZUMjIzMkMgcG9ydCBpbnRlcmZhY2UgKDAgZm9yIEZUMjMyLzI0NSkgKi8KCglpbnQgZm9yY2VfYmF1ZDsJCS8qIGlmIG5vbi16ZXJvLCBmb3JjZSB0aGUgYmF1ZCByYXRlIHRvIHRoaXMgdmFsdWUgKi8KCWludCBmb3JjZV9ydHNjdHM7CS8qIGlmIG5vbi16ZXJvLCBmb3JjZSBSVFMtQ1RTIHRvIGFsd2F5cyBiZSBlbmFibGVkICovCgoJc3BpbmxvY2tfdCB0eF9sb2NrOwkvKiBzcGlubG9jayBmb3IgdHJhbnNtaXQgc3RhdGUgKi8KCXVuc2lnbmVkIGxvbmcgdHhfYnl0ZXM7Cgl1bnNpZ25lZCBsb25nIHR4X291dHN0YW5kaW5nX2J5dGVzOwoJdW5zaWduZWQgbG9uZyB0eF9vdXRzdGFuZGluZ191cmJzOwp9OwoKLyogVXNlZCBmb3IgVElPQ01JV0FJVCAqLwojZGVmaW5lIEZURElfU1RBVFVTX0IwX01BU0sJKEZURElfUlMwX0NUUyB8IEZURElfUlMwX0RTUiB8IEZURElfUlMwX1JJIHwgRlRESV9SUzBfUkxTRCkKI2RlZmluZSBGVERJX1NUQVRVU19CMV9NQVNLCShGVERJX1JTX0JJKQovKiBFbmQgVElPQ01JV0FJVCAqLwoKI2RlZmluZSBGVERJX0lNUExfQVNZTkNfRkxBR1MgPSAoIEFTWU5DX1NQRF9ISSB8IEFTWU5DX1NQRF9WSEkgXAogQVNZTkNfU1BEX0NVU1QgfCBBU1lOQ19TUERfU0hJIHwgQVNZTkNfU1BEX1dBUlAgKQoKLyogZnVuY3Rpb24gcHJvdG90eXBlcyBmb3IgYSBGVERJIHNlcmlhbCBjb252ZXJ0ZXIgKi8Kc3RhdGljIGludCAgZnRkaV9zaW9fcHJvYmUJKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwsIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCk7CnN0YXRpYyBpbnQgIGZ0ZGlfc2lvX2F0dGFjaAkJKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwpOwpzdGF0aWMgdm9pZCBmdGRpX3NodXRkb3duCQkoc3RydWN0IHVzYl9zZXJpYWwgKnNlcmlhbCk7CnN0YXRpYyBpbnQgIGZ0ZGlfb3BlbgkJCShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBzdHJ1Y3QgZmlsZSAqZmlscCk7CnN0YXRpYyB2b2lkIGZ0ZGlfY2xvc2UJCQkoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwgc3RydWN0IGZpbGUgKmZpbHApOwpzdGF0aWMgaW50ICBmdGRpX3dyaXRlCQkJKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQsIGNvbnN0IHVuc2lnbmVkIGNoYXIgKmJ1ZiwgaW50IGNvdW50KTsKc3RhdGljIGludCAgZnRkaV93cml0ZV9yb29tCQkoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCk7CnN0YXRpYyBpbnQgIGZ0ZGlfY2hhcnNfaW5fYnVmZmVyCShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KTsKc3RhdGljIHZvaWQgZnRkaV93cml0ZV9idWxrX2NhbGxiYWNrCShzdHJ1Y3QgdXJiICp1cmIpOwpzdGF0aWMgdm9pZCBmdGRpX3JlYWRfYnVsa19jYWxsYmFjawkoc3RydWN0IHVyYiAqdXJiKTsKc3RhdGljIHZvaWQgZnRkaV9wcm9jZXNzX3JlYWQJCShzdHJ1Y3Qgd29ya19zdHJ1Y3QgKndvcmspOwpzdGF0aWMgdm9pZCBmdGRpX3NldF90ZXJtaW9zCQkoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwgc3RydWN0IHRlcm1pb3MgKiBvbGQpOwpzdGF0aWMgaW50ICBmdGRpX3Rpb2NtZ2V0ICAgICAgICAgICAgICAgKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQsIHN0cnVjdCBmaWxlICpmaWxlKTsKc3RhdGljIGludCAgZnRkaV90aW9jbXNldAkJKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQsIHN0cnVjdCBmaWxlICogZmlsZSwgdW5zaWduZWQgaW50IHNldCwgdW5zaWduZWQgaW50IGNsZWFyKTsKc3RhdGljIGludCAgZnRkaV9pb2N0bAkJCShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBzdHJ1Y3QgZmlsZSAqIGZpbGUsIHVuc2lnbmVkIGludCBjbWQsIHVuc2lnbmVkIGxvbmcgYXJnKTsKc3RhdGljIHZvaWQgZnRkaV9icmVha19jdGwJCShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBpbnQgYnJlYWtfc3RhdGUgKTsKc3RhdGljIHZvaWQgZnRkaV90aHJvdHRsZQkJKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQpOwpzdGF0aWMgdm9pZCBmdGRpX3VudGhyb3R0bGUJCShzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KTsKCnN0YXRpYyB1bnNpZ25lZCBzaG9ydCBpbnQgZnRkaV8yMzJhbV9iYXVkX2Jhc2VfdG9fZGl2aXNvciAoaW50IGJhdWQsIGludCBiYXNlKTsKc3RhdGljIHVuc2lnbmVkIHNob3J0IGludCBmdGRpXzIzMmFtX2JhdWRfdG9fZGl2aXNvciAoaW50IGJhdWQpOwpzdGF0aWMgX191MzIgZnRkaV8yMzJibV9iYXVkX2Jhc2VfdG9fZGl2aXNvciAoaW50IGJhdWQsIGludCBiYXNlKTsKc3RhdGljIF9fdTMyIGZ0ZGlfMjMyYm1fYmF1ZF90b19kaXZpc29yIChpbnQgYmF1ZCk7CgpzdGF0aWMgc3RydWN0IHVzYl9zZXJpYWxfZHJpdmVyIGZ0ZGlfc2lvX2RldmljZSA9IHsKCS5kcml2ZXIgPSB7CgkJLm93bmVyID0JVEhJU19NT0RVTEUsCgkJLm5hbWUgPQkJImZ0ZGlfc2lvIiwKCX0sCgkuZGVzY3JpcHRpb24gPQkJIkZUREkgVVNCIFNlcmlhbCBEZXZpY2UiLAoJLmlkX3RhYmxlID0JCWlkX3RhYmxlX2NvbWJpbmVkLAoJLm51bV9pbnRlcnJ1cHRfaW4gPQkwLAoJLm51bV9idWxrX2luID0JCTEsCgkubnVtX2J1bGtfb3V0ID0JCTEsCgkubnVtX3BvcnRzID0JCTEsCgkucHJvYmUgPQkJZnRkaV9zaW9fcHJvYmUsCgkub3BlbiA9CQkJZnRkaV9vcGVuLAoJLmNsb3NlID0JCWZ0ZGlfY2xvc2UsCgkudGhyb3R0bGUgPQkJZnRkaV90aHJvdHRsZSwKCS51bnRocm90dGxlID0JCWZ0ZGlfdW50aHJvdHRsZSwKCS53cml0ZSA9CQlmdGRpX3dyaXRlLAoJLndyaXRlX3Jvb20gPQkJZnRkaV93cml0ZV9yb29tLAoJLmNoYXJzX2luX2J1ZmZlciA9CWZ0ZGlfY2hhcnNfaW5fYnVmZmVyLAoJLnJlYWRfYnVsa19jYWxsYmFjayA9CWZ0ZGlfcmVhZF9idWxrX2NhbGxiYWNrLAoJLndyaXRlX2J1bGtfY2FsbGJhY2sgPQlmdGRpX3dyaXRlX2J1bGtfY2FsbGJhY2ssCgkudGlvY21nZXQgPSAgICAgICAgICAgICBmdGRpX3Rpb2NtZ2V0LAoJLnRpb2Ntc2V0ID0gICAgICAgICAgICAgZnRkaV90aW9jbXNldCwKCS5pb2N0bCA9CQlmdGRpX2lvY3RsLAoJLnNldF90ZXJtaW9zID0JCWZ0ZGlfc2V0X3Rlcm1pb3MsCgkuYnJlYWtfY3RsID0JCWZ0ZGlfYnJlYWtfY3RsLAoJLmF0dGFjaCA9CQlmdGRpX3Npb19hdHRhY2gsCgkuc2h1dGRvd24gPQkJZnRkaV9zaHV0ZG93biwKfTsKCgojZGVmaW5lIFdEUl9USU1FT1VUIDUwMDAgLyogZGVmYXVsdCB1cmIgdGltZW91dCAqLwojZGVmaW5lIFdEUl9TSE9SVF9USU1FT1VUIDEwMDAJLyogc2hvcnRlciB1cmIgdGltZW91dCAqLwoKLyogSGlnaCBhbmQgbG93IGFyZSBmb3IgRFRSLCBSVFMgZXRjIGV0YyAqLwojZGVmaW5lIEhJR0ggMQojZGVmaW5lIExPVyAwCgovKiBudW1iZXIgb2Ygb3V0c3RhbmRpbmcgdXJicyB0byBwcmV2ZW50IHVzZXJzcGFjZSBEb1MgZnJvbSBoYXBwZW5pbmcgKi8KI2RlZmluZSBVUkJfVVBQRVJfTElNSVQJNDIKCi8qCiAqICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiBVdGxpdHkgZnVuY3Rpb25zCiAqICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8KCnN0YXRpYyB1bnNpZ25lZCBzaG9ydCBpbnQgZnRkaV8yMzJhbV9iYXVkX2Jhc2VfdG9fZGl2aXNvcihpbnQgYmF1ZCwgaW50IGJhc2UpCnsKCXVuc2lnbmVkIHNob3J0IGludCBkaXZpc29yOwoJaW50IGRpdmlzb3IzID0gYmFzZSAvIDIgLyBiYXVkOyAvLyBkaXZpc29yIHNoaWZ0ZWQgMyBiaXRzIHRvIHRoZSBsZWZ0CglpZiAoKGRpdmlzb3IzICYgMHg3KSA9PSA3KSBkaXZpc29yMyArKzsgLy8gcm91bmQgeC43LzggdXAgdG8geCsxCglkaXZpc29yID0gZGl2aXNvcjMgPj4gMzsKCWRpdmlzb3IzICY9IDB4NzsKCWlmIChkaXZpc29yMyA9PSAxKSBkaXZpc29yIHw9IDB4YzAwMDsgZWxzZSAvLyAwLjEyNQoJaWYgKGRpdmlzb3IzID49IDQpIGRpdmlzb3IgfD0gMHg0MDAwOyBlbHNlIC8vIDAuNQoJaWYgKGRpdmlzb3IzICE9IDApIGRpdmlzb3IgfD0gMHg4MDAwOyAgICAgIC8vIDAuMjUKCWlmIChkaXZpc29yID09IDEpIGRpdmlzb3IgPSAwOwkvKiBzcGVjaWFsIGNhc2UgZm9yIG1heGltdW0gYmF1ZCByYXRlICovCglyZXR1cm4gZGl2aXNvcjsKfQoKc3RhdGljIHVuc2lnbmVkIHNob3J0IGludCBmdGRpXzIzMmFtX2JhdWRfdG9fZGl2aXNvcihpbnQgYmF1ZCkKewoJIHJldHVybihmdGRpXzIzMmFtX2JhdWRfYmFzZV90b19kaXZpc29yKGJhdWQsIDQ4MDAwMDAwKSk7Cn0KCnN0YXRpYyBfX3UzMiBmdGRpXzIzMmJtX2JhdWRfYmFzZV90b19kaXZpc29yKGludCBiYXVkLCBpbnQgYmFzZSkKewoJc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNoYXIgZGl2ZnJhY1s4XSA9IHsgMCwgMywgMiwgNCwgMSwgNSwgNiwgNyB9OwoJX191MzIgZGl2aXNvcjsKCWludCBkaXZpc29yMyA9IGJhc2UgLyAyIC8gYmF1ZDsgLy8gZGl2aXNvciBzaGlmdGVkIDMgYml0cyB0byB0aGUgbGVmdAoJZGl2aXNvciA9IGRpdmlzb3IzID4+IDM7CglkaXZpc29yIHw9IChfX3UzMilkaXZmcmFjW2Rpdmlzb3IzICYgMHg3XSA8PCAxNDsKCS8qIERlYWwgd2l0aCBzcGVjaWFsIGNhc2VzIGZvciBoaWdoZXN0IGJhdWQgcmF0ZXMuICovCglpZiAoZGl2aXNvciA9PSAxKSBkaXZpc29yID0gMDsgZWxzZQkvLyAxLjAKCWlmIChkaXZpc29yID09IDB4NDAwMSkgZGl2aXNvciA9IDE7CS8vIDEuNQoJcmV0dXJuIGRpdmlzb3I7Cn0KCnN0YXRpYyBfX3UzMiBmdGRpXzIzMmJtX2JhdWRfdG9fZGl2aXNvcihpbnQgYmF1ZCkKewoJIHJldHVybihmdGRpXzIzMmJtX2JhdWRfYmFzZV90b19kaXZpc29yKGJhdWQsIDQ4MDAwMDAwKSk7Cn0KCiNkZWZpbmUgc2V0X21jdHJsKHBvcnQsIHNldCkJCXVwZGF0ZV9tY3RybCgocG9ydCksIChzZXQpLCAwKQojZGVmaW5lIGNsZWFyX21jdHJsKHBvcnQsIGNsZWFyKQl1cGRhdGVfbWN0cmwoKHBvcnQpLCAwLCAoY2xlYXIpKQoKc3RhdGljIGludCB1cGRhdGVfbWN0cmwoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwgdW5zaWduZWQgaW50IHNldCwgdW5zaWduZWQgaW50IGNsZWFyKQp7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJY2hhciAqYnVmOwoJdW5zaWduZWQgdXJiX3ZhbHVlOwoJaW50IHJ2OwoKCWlmICgoKHNldCB8IGNsZWFyKSAmIChUSU9DTV9EVFIgfCBUSU9DTV9SVFMpKSA9PSAwKSB7CgkJZGJnKCIlcyAtIERUUnxSVFMgbm90IGJlaW5nIHNldHxjbGVhcmVkIiwgX19GVU5DVElPTl9fKTsKCQlyZXR1cm4gMDsJLyogbm8gY2hhbmdlICovCgl9CgoJYnVmID0ga21hbGxvYygxLCBHRlBfTk9JTyk7CglpZiAoIWJ1ZikgewoJCXJldHVybiAtRU5PTUVNOwoJfQoKCWNsZWFyICY9IH5zZXQ7CS8qICdzZXQnIHRha2VzIHByZWNlZGVuY2Ugb3ZlciAnY2xlYXInICovCgl1cmJfdmFsdWUgPSAwOwoJaWYgKGNsZWFyICYgVElPQ01fRFRSKQoJCXVyYl92YWx1ZSB8PSBGVERJX1NJT19TRVRfRFRSX0xPVzsKCWlmIChjbGVhciAmIFRJT0NNX1JUUykKCQl1cmJfdmFsdWUgfD0gRlRESV9TSU9fU0VUX1JUU19MT1c7CglpZiAoc2V0ICYgVElPQ01fRFRSKQoJCXVyYl92YWx1ZSB8PSBGVERJX1NJT19TRVRfRFRSX0hJR0g7CglpZiAoc2V0ICYgVElPQ01fUlRTKQoJCXVyYl92YWx1ZSB8PSBGVERJX1NJT19TRVRfUlRTX0hJR0g7CglydiA9IHVzYl9jb250cm9sX21zZyhwb3J0LT5zZXJpYWwtPmRldiwKCQkJICAgICAgIHVzYl9zbmRjdHJscGlwZShwb3J0LT5zZXJpYWwtPmRldiwgMCksCgkJCSAgICAgICBGVERJX1NJT19TRVRfTU9ERU1fQ1RSTF9SRVFVRVNULAoJCQkgICAgICAgRlRESV9TSU9fU0VUX01PREVNX0NUUkxfUkVRVUVTVF9UWVBFLAoJCQkgICAgICAgdXJiX3ZhbHVlLCBwcml2LT5pbnRlcmZhY2UsCgkJCSAgICAgICBidWYsIDAsIFdEUl9USU1FT1VUKTsKCglrZnJlZShidWYpOwoJaWYgKHJ2IDwgMCkgewoJCWVycigiJXMgRXJyb3IgZnJvbSBNT0RFTV9DVFJMIHVyYjogRFRSICVzLCBSVFMgJXMiLAoJCQkJX19GVU5DVElPTl9fLAoJCQkJKHNldCAmIFRJT0NNX0RUUikgPyAiSElHSCIgOgoJCQkJKGNsZWFyICYgVElPQ01fRFRSKSA/ICJMT1ciIDogInVuY2hhbmdlZCIsCgkJCQkoc2V0ICYgVElPQ01fUlRTKSA/ICJISUdIIiA6CgkJCQkoY2xlYXIgJiBUSU9DTV9SVFMpID8gIkxPVyIgOiAidW5jaGFuZ2VkIik7Cgl9IGVsc2UgewoJCWRiZygiJXMgLSBEVFIgJXMsIFJUUyAlcyIsIF9fRlVOQ1RJT05fXywKCQkJCShzZXQgJiBUSU9DTV9EVFIpID8gIkhJR0giIDoKCQkJCShjbGVhciAmIFRJT0NNX0RUUikgPyAiTE9XIiA6ICJ1bmNoYW5nZWQiLAoJCQkJKHNldCAmIFRJT0NNX1JUUykgPyAiSElHSCIgOgoJCQkJKGNsZWFyICYgVElPQ01fUlRTKSA/ICJMT1ciIDogInVuY2hhbmdlZCIpOwoJCXByaXYtPmxhc3RfZHRyX3J0cyA9IChwcml2LT5sYXN0X2R0cl9ydHMgJiB+Y2xlYXIpIHwgc2V0OwoJfQoJcmV0dXJuIHJ2Owp9CgoKc3RhdGljIF9fdTMyIGdldF9mdGRpX2Rpdmlzb3Ioc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqIHBvcnQpOwoKCnN0YXRpYyBpbnQgY2hhbmdlX3NwZWVkKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQpCnsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CgljaGFyICpidWY7CiAgICAgICAgX191MTYgdXJiX3ZhbHVlOwoJX191MTYgdXJiX2luZGV4OwoJX191MzIgdXJiX2luZGV4X3ZhbHVlOwoJaW50IHJ2OwoKCWJ1ZiA9IGttYWxsb2MoMSwgR0ZQX05PSU8pOwoJaWYgKCFidWYpCgkJcmV0dXJuIC1FTk9NRU07CgoJdXJiX2luZGV4X3ZhbHVlID0gZ2V0X2Z0ZGlfZGl2aXNvcihwb3J0KTsKCXVyYl92YWx1ZSA9IChfX3UxNil1cmJfaW5kZXhfdmFsdWU7Cgl1cmJfaW5kZXggPSAoX191MTYpKHVyYl9pbmRleF92YWx1ZSA+PiAxNik7CglpZiAocHJpdi0+aW50ZXJmYWNlKSB7CS8qIEZUMjIzMkMgKi8KCQl1cmJfaW5kZXggPSAoX191MTYpKCh1cmJfaW5kZXggPDwgOCkgfCBwcml2LT5pbnRlcmZhY2UpOwoJfQoKCXJ2ID0gdXNiX2NvbnRyb2xfbXNnKHBvcnQtPnNlcmlhbC0+ZGV2LAoJCQkgICAgdXNiX3NuZGN0cmxwaXBlKHBvcnQtPnNlcmlhbC0+ZGV2LCAwKSwKCQkJICAgIEZURElfU0lPX1NFVF9CQVVEUkFURV9SRVFVRVNULAoJCQkgICAgRlRESV9TSU9fU0VUX0JBVURSQVRFX1JFUVVFU1RfVFlQRSwKCQkJICAgIHVyYl92YWx1ZSwgdXJiX2luZGV4LAoJCQkgICAgYnVmLCAwLCBXRFJfU0hPUlRfVElNRU9VVCk7CgoJa2ZyZWUoYnVmKTsKCXJldHVybiBydjsKfQoKCnN0YXRpYyBfX3UzMiBnZXRfZnRkaV9kaXZpc29yKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKiBwb3J0KQp7IC8qIGdldF9mdGRpX2Rpdmlzb3IgKi8KCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CglfX3UzMiBkaXZfdmFsdWUgPSAwOwoJaW50IGRpdl9va2F5ID0gMTsKCWludCBiYXVkOwoKCS8qCgkgKiBUaGUgbG9naWMgaW52b2x2ZWQgaW4gc2V0dGluZyB0aGUgYmF1ZHJhdGUgY2FuIGJlIGNsZWFubHkgc3BsaXQgaW4gMyBzdGVwcy4KCSAqIE9idGFpbmluZyB0aGUgYWN0dWFsIGJhdWQgcmF0ZSBpcyBhIGxpdHRsZSB0cmlja3kgc2luY2UgdW5peCB0cmFkaXRpb25hbGx5CgkgKiBzb21laG93IGlnbm9yZWQgdGhlIHBvc3NpYmlsaXR5IHRvIHNldCBub24tc3RhbmRhcmQgYmF1ZCByYXRlcy4KCSAqIDEuIFN0YW5kYXJkIGJhdWQgcmF0ZXMgYXJlIHNldCBpbiB0dHktPnRlcm1pb3MtPmNfY2ZsYWcKCSAqIDIuIElmIHRoZXNlIGFyZSBub3QgZW5vdWdoLCB5b3UgY2FuIHNldCBhbnkgc3BlZWQgdXNpbmcgYWx0X3NwZWVkIGFzIGZvbGxvd3M6CgkgKiAgICAtIHNldCB0dHktPnRlcm1pb3MtPmNfY2ZsYWcgc3BlZWQgdG8gQjM4NDAwCgkgKiAgICAtIHNldCB5b3VyIHJlYWwgc3BlZWQgaW4gdHR5LT5hbHRfc3BlZWQ7IGl0IGdldHMgaWdub3JlZCB3aGVuCgkgKiAgICAgIGFsdF9zcGVlZD09MCwgKG9yKQoJICogICAgLSBjYWxsIFRJT0NTU0VSSUFMIGlvY3RsIHdpdGggKHN0cnVjdCBzZXJpYWxfc3RydWN0KSBzZXQgYXMgZm9sbG93czoKCSAqICAgICAgZmxhZ3MgJiBBU1lOQ19TUERfTUFTSyA9PSBBU1lOQ19TUERfW0hJLCBWSEksIFNISSwgV0FSUF0sIHRoaXMganVzdAoJICogICAgICBzZXRzIGFsdF9zcGVlZCB0byAoSEk6IDU3NjAwLCBWSEk6IDExNTIwMCwgU0hJOiAyMzA0MDAsIFdBUlA6IDQ2MDgwMCkKCSAqICoqIFN0ZXBzIDEsIDIgYXJlIGRvbmUgY291cnRlc3kgb2YgdHR5X2dldF9iYXVkX3JhdGUKCSAqIDMuIFlvdSBjYW4gYWxzbyBzZXQgYmF1ZCByYXRlIGJ5IHNldHRpbmcgY3VzdG9tIGRpdmlzb3IgYXMgZm9sbG93cwoJICogICAgLSBzZXQgdHR5LT50ZXJtaW9zLT5jX2NmbGFnIHNwZWVkIHRvIEIzODQwMAoJICogICAgLSBjYWxsIFRJT0NTU0VSSUFMIGlvY3RsIHdpdGggKHN0cnVjdCBzZXJpYWxfc3RydWN0KSBzZXQgYXMgZm9sbG93czoKCSAqICAgICAgbyBmbGFncyAmIEFTWU5DX1NQRF9NQVNLID09IEFTWU5DX1NQRF9DVVNUCgkgKiAgICAgIG8gY3VzdG9tX2Rpdmlzb3Igc2V0IHRvIGJhdWRfYmFzZSAvIHlvdXJfbmV3X2JhdWRyYXRlCgkgKiAqKiBTdGVwIDMgaXMgZG9uZSBjb3VydGVzeSBvZiBjb2RlIGJvcnJvd2VkIGZyb20gc2VyaWFsLmMgLSBJIHNob3VsZCByZWFsbHkKCSAqICAgIHNwZW5kIHNvbWUgdGltZSBhbmQgc2VwYXJhdGUrbW92ZSB0aGlzIGNvbW1vbiBjb2RlIHRvIHNlcmlhbC5jLCBpdCBpcwoJICogICAgcmVwbGljYXRlZCBpbiBuZWFybHkgZXZlcnkgc2VyaWFsIGRyaXZlciB5b3Ugc2VlLgoJICovCgoJLyogMS4gR2V0IHRoZSBiYXVkIHJhdGUgZnJvbSB0aGUgdHR5IHNldHRpbmdzLCB0aGlzIG9ic2VydmVzIGFsdF9zcGVlZCBoYWNrICovCgoJYmF1ZCA9IHR0eV9nZXRfYmF1ZF9yYXRlKHBvcnQtPnR0eSk7CglkYmcoIiVzIC0gdHR5X2dldF9iYXVkX3JhdGUgcmVwb3J0cyBzcGVlZCAlZCIsIF9fRlVOQ1RJT05fXywgYmF1ZCk7CgoJLyogMi4gT2JzZXJ2ZSBhc3luYy1jb21wYXRpYmxlIGN1c3RvbV9kaXZpc29yIGhhY2ssIHVwZGF0ZSBiYXVkcmF0ZSBpZiBuZWVkZWQgKi8KCglpZiAoYmF1ZCA9PSAzODQwMCAmJgoJICAgICgocHJpdi0+ZmxhZ3MgJiBBU1lOQ19TUERfTUFTSykgPT0gQVNZTkNfU1BEX0NVU1QpICYmCgkgICAgIChwcml2LT5jdXN0b21fZGl2aXNvcikpIHsKCQliYXVkID0gcHJpdi0+YmF1ZF9iYXNlIC8gcHJpdi0+Y3VzdG9tX2Rpdmlzb3I7CgkJZGJnKCIlcyAtIGN1c3RvbSBkaXZpc29yICVkIHNldHMgYmF1ZCByYXRlIHRvICVkIiwgX19GVU5DVElPTl9fLCBwcml2LT5jdXN0b21fZGl2aXNvciwgYmF1ZCk7Cgl9CgoJLyogMy4gQ29udmVydCBiYXVkcmF0ZSB0byBkZXZpY2Utc3BlY2lmaWMgZGl2aXNvciAqLwoKCWlmICghYmF1ZCkgYmF1ZCA9IDk2MDA7Cglzd2l0Y2gocHJpdi0+Y2hpcF90eXBlKSB7CgljYXNlIFNJTzogLyogU0lPIGNoaXAgKi8KCQlzd2l0Y2goYmF1ZCkgewoJCWNhc2UgMzAwOiBkaXZfdmFsdWUgPSBmdGRpX3Npb19iMzAwOyBicmVhazsKCQljYXNlIDYwMDogZGl2X3ZhbHVlID0gZnRkaV9zaW9fYjYwMDsgYnJlYWs7CgkJY2FzZSAxMjAwOiBkaXZfdmFsdWUgPSBmdGRpX3Npb19iMTIwMDsgYnJlYWs7CgkJY2FzZSAyNDAwOiBkaXZfdmFsdWUgPSBmdGRpX3Npb19iMjQwMDsgYnJlYWs7CgkJY2FzZSA0ODAwOiBkaXZfdmFsdWUgPSBmdGRpX3Npb19iNDgwMDsgYnJlYWs7CgkJY2FzZSA5NjAwOiBkaXZfdmFsdWUgPSBmdGRpX3Npb19iOTYwMDsgYnJlYWs7CgkJY2FzZSAxOTIwMDogZGl2X3ZhbHVlID0gZnRkaV9zaW9fYjE5MjAwOyBicmVhazsKCQljYXNlIDM4NDAwOiBkaXZfdmFsdWUgPSBmdGRpX3Npb19iMzg0MDA7IGJyZWFrOwoJCWNhc2UgNTc2MDA6IGRpdl92YWx1ZSA9IGZ0ZGlfc2lvX2I1NzYwMDsgIGJyZWFrOwoJCWNhc2UgMTE1MjAwOiBkaXZfdmFsdWUgPSBmdGRpX3Npb19iMTE1MjAwOyBicmVhazsKCQl9IC8qIGJhdWQgKi8KCQlpZiAoZGl2X3ZhbHVlID09IDApIHsKCQkJZGJnKCIlcyAtIEJhdWRyYXRlICglZCkgcmVxdWVzdGVkIGlzIG5vdCBzdXBwb3J0ZWQiLCBfX0ZVTkNUSU9OX18sICBiYXVkKTsKCQkJZGl2X3ZhbHVlID0gZnRkaV9zaW9fYjk2MDA7CgkJCWRpdl9va2F5ID0gMDsKCQl9CgkJYnJlYWs7CgljYXNlIEZUOFUyMzJBTTogLyogOFUyMzJBTSBjaGlwICovCgkJaWYgKGJhdWQgPD0gMzAwMDAwMCkgewoJCQlkaXZfdmFsdWUgPSBmdGRpXzIzMmFtX2JhdWRfdG9fZGl2aXNvcihiYXVkKTsKCQl9IGVsc2UgewoJICAgICAgICAgICAgICAgIGRiZygiJXMgLSBCYXVkIHJhdGUgdG9vIGhpZ2ghIiwgX19GVU5DVElPTl9fKTsKCQkJZGl2X3ZhbHVlID0gZnRkaV8yMzJhbV9iYXVkX3RvX2Rpdmlzb3IoOTYwMCk7CgkJCWRpdl9va2F5ID0gMDsKCQl9CgkJYnJlYWs7CgljYXNlIEZUMjMyQk06IC8qIEZUMjMyQk0gY2hpcCAqLwoJY2FzZSBGVDIyMzJDOiAvKiBGVDIyMzJDIGNoaXAgKi8KCQlpZiAoYmF1ZCA8PSAzMDAwMDAwKSB7CgkJCWRpdl92YWx1ZSA9IGZ0ZGlfMjMyYm1fYmF1ZF90b19kaXZpc29yKGJhdWQpOwoJCX0gZWxzZSB7CgkgICAgICAgICAgICAgICAgZGJnKCIlcyAtIEJhdWQgcmF0ZSB0b28gaGlnaCEiLCBfX0ZVTkNUSU9OX18pOwoJCQlkaXZfdmFsdWUgPSBmdGRpXzIzMmJtX2JhdWRfdG9fZGl2aXNvcig5NjAwKTsKCQkJZGl2X29rYXkgPSAwOwoJCX0KCQlicmVhazsKCX0gLyogcHJpdi0+Y2hpcF90eXBlICovCgoJaWYgKGRpdl9va2F5KSB7CgkJZGJnKCIlcyAtIEJhdWQgcmF0ZSBzZXQgdG8gJWQgKGRpdmlzb3IgMHglbFgpIG9uIGNoaXAgJXMiLAoJCQlfX0ZVTkNUSU9OX18sIGJhdWQsICh1bnNpZ25lZCBsb25nKWRpdl92YWx1ZSwKCQkJZnRkaV9jaGlwX25hbWVbcHJpdi0+Y2hpcF90eXBlXSk7Cgl9CgoJcmV0dXJuKGRpdl92YWx1ZSk7Cn0KCgpzdGF0aWMgaW50IGdldF9zZXJpYWxfaW5mbyhzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICogcG9ydCwgc3RydWN0IHNlcmlhbF9zdHJ1Y3QgX191c2VyICogcmV0aW5mbykKewoJc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKCXN0cnVjdCBzZXJpYWxfc3RydWN0IHRtcDsKCglpZiAoIXJldGluZm8pCgkJcmV0dXJuIC1FRkFVTFQ7CgltZW1zZXQoJnRtcCwgMCwgc2l6ZW9mKHRtcCkpOwoJdG1wLmZsYWdzID0gcHJpdi0+ZmxhZ3M7Cgl0bXAuYmF1ZF9iYXNlID0gcHJpdi0+YmF1ZF9iYXNlOwoJdG1wLmN1c3RvbV9kaXZpc29yID0gcHJpdi0+Y3VzdG9tX2Rpdmlzb3I7CglpZiAoY29weV90b191c2VyKHJldGluZm8sICZ0bXAsIHNpemVvZigqcmV0aW5mbykpKQoJCXJldHVybiAtRUZBVUxUOwoJcmV0dXJuIDA7Cn0gLyogZ2V0X3NlcmlhbF9pbmZvICovCgoKc3RhdGljIGludCBzZXRfc2VyaWFsX2luZm8oc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqIHBvcnQsIHN0cnVjdCBzZXJpYWxfc3RydWN0IF9fdXNlciAqIG5ld2luZm8pCnsgLyogc2V0X3NlcmlhbF9pbmZvICovCglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJc3RydWN0IHNlcmlhbF9zdHJ1Y3QgbmV3X3NlcmlhbDsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgb2xkX3ByaXY7CgoJaWYgKGNvcHlfZnJvbV91c2VyKCZuZXdfc2VyaWFsLCBuZXdpbmZvLCBzaXplb2YobmV3X3NlcmlhbCkpKQoJCXJldHVybiAtRUZBVUxUOwoJb2xkX3ByaXYgPSAqIHByaXY7CgoJLyogRG8gZXJyb3IgY2hlY2tpbmcgYW5kIHBlcm1pc3Npb24gY2hlY2tpbmcgKi8KCglpZiAoIWNhcGFibGUoQ0FQX1NZU19BRE1JTikpIHsKCQlpZiAoKChuZXdfc2VyaWFsLmZsYWdzICYgfkFTWU5DX1VTUl9NQVNLKSAhPQoJCSAgICAgKHByaXYtPmZsYWdzICYgfkFTWU5DX1VTUl9NQVNLKSkpCgkJCXJldHVybiAtRVBFUk07CgkJcHJpdi0+ZmxhZ3MgPSAoKHByaXYtPmZsYWdzICYgfkFTWU5DX1VTUl9NQVNLKSB8CgkJCSAgICAgICAobmV3X3NlcmlhbC5mbGFncyAmIEFTWU5DX1VTUl9NQVNLKSk7CgkJcHJpdi0+Y3VzdG9tX2Rpdmlzb3IgPSBuZXdfc2VyaWFsLmN1c3RvbV9kaXZpc29yOwoJCWdvdG8gY2hlY2tfYW5kX2V4aXQ7Cgl9CgoJaWYgKChuZXdfc2VyaWFsLmJhdWRfYmFzZSAhPSBwcml2LT5iYXVkX2Jhc2UpICYmCgkgICAgKG5ld19zZXJpYWwuYmF1ZF9iYXNlIDwgOTYwMCkpCgkJcmV0dXJuIC1FSU5WQUw7CgoJLyogTWFrZSB0aGUgY2hhbmdlcyAtIHRoZXNlIGFyZSBwcml2aWxlZ2VkIGNoYW5nZXMhICovCgoJcHJpdi0+ZmxhZ3MgPSAoKHByaXYtPmZsYWdzICYgfkFTWU5DX0ZMQUdTKSB8CgkgICAgICAgICAgICAgICAobmV3X3NlcmlhbC5mbGFncyAmIEFTWU5DX0ZMQUdTKSk7Cglwcml2LT5jdXN0b21fZGl2aXNvciA9IG5ld19zZXJpYWwuY3VzdG9tX2Rpdmlzb3I7CgoJcG9ydC0+dHR5LT5sb3dfbGF0ZW5jeSA9IChwcml2LT5mbGFncyAmIEFTWU5DX0xPV19MQVRFTkNZKSA/IDEgOiAwOwoKY2hlY2tfYW5kX2V4aXQ6CglpZiAoKG9sZF9wcml2LmZsYWdzICYgQVNZTkNfU1BEX01BU0spICE9CgkgICAgIChwcml2LT5mbGFncyAmIEFTWU5DX1NQRF9NQVNLKSkgewoJCWlmICgocHJpdi0+ZmxhZ3MgJiBBU1lOQ19TUERfTUFTSykgPT0gQVNZTkNfU1BEX0hJKQoJCQlwb3J0LT50dHktPmFsdF9zcGVlZCA9IDU3NjAwOwoJCWVsc2UgaWYgKChwcml2LT5mbGFncyAmIEFTWU5DX1NQRF9NQVNLKSA9PSBBU1lOQ19TUERfVkhJKQoJCQlwb3J0LT50dHktPmFsdF9zcGVlZCA9IDExNTIwMDsKCQllbHNlIGlmICgocHJpdi0+ZmxhZ3MgJiBBU1lOQ19TUERfTUFTSykgPT0gQVNZTkNfU1BEX1NISSkKCQkJcG9ydC0+dHR5LT5hbHRfc3BlZWQgPSAyMzA0MDA7CgkJZWxzZSBpZiAoKHByaXYtPmZsYWdzICYgQVNZTkNfU1BEX01BU0spID09IEFTWU5DX1NQRF9XQVJQKQoJCQlwb3J0LT50dHktPmFsdF9zcGVlZCA9IDQ2MDgwMDsKCQllbHNlCgkJCXBvcnQtPnR0eS0+YWx0X3NwZWVkID0gMDsKCX0KCWlmICgoKG9sZF9wcml2LmZsYWdzICYgQVNZTkNfU1BEX01BU0spICE9CgkgICAgIChwcml2LT5mbGFncyAmIEFTWU5DX1NQRF9NQVNLKSkgfHwKCSAgICAoKChwcml2LT5mbGFncyAmIEFTWU5DX1NQRF9NQVNLKSA9PSBBU1lOQ19TUERfQ1VTVCkgJiYKCSAgICAgKG9sZF9wcml2LmN1c3RvbV9kaXZpc29yICE9IHByaXYtPmN1c3RvbV9kaXZpc29yKSkpIHsKCQljaGFuZ2Vfc3BlZWQocG9ydCk7Cgl9CgoJcmV0dXJuICgwKTsKCn0gLyogc2V0X3NlcmlhbF9pbmZvICovCgoKLyogRGV0ZXJtaW5lIHR5cGUgb2YgRlRESSBjaGlwIGJhc2VkIG9uIFVTQiBjb25maWcgYW5kIGRlc2NyaXB0b3IuICovCnN0YXRpYyB2b2lkIGZ0ZGlfZGV0ZXJtaW5lX3R5cGUoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCkKewoJc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKCXN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwgPSBwb3J0LT5zZXJpYWw7CglzdHJ1Y3QgdXNiX2RldmljZSAqdWRldiA9IHNlcmlhbC0+ZGV2OwoJdW5zaWduZWQgdmVyc2lvbjsKCXVuc2lnbmVkIGludGVyZmFjZXM7CgoJLyogQXNzdW1lIGl0IGlzIG5vdCB0aGUgb3JpZ2luYWwgU0lPIGRldmljZSBmb3Igbm93LiAqLwoJcHJpdi0+YmF1ZF9iYXNlID0gNDgwMDAwMDAgLyAyOwoJcHJpdi0+d3JpdGVfb2Zmc2V0ID0gMDsKCgl2ZXJzaW9uID0gbGUxNl90b19jcHUodWRldi0+ZGVzY3JpcHRvci5iY2REZXZpY2UpOwoJaW50ZXJmYWNlcyA9IHVkZXYtPmFjdGNvbmZpZy0+ZGVzYy5iTnVtSW50ZXJmYWNlczsKCWRiZygiJXM6IGJjZERldmljZSA9IDB4JXgsIGJOdW1JbnRlcmZhY2VzID0gJXUiLCBfX0ZVTkNUSU9OX18sCgkJCXZlcnNpb24sIGludGVyZmFjZXMpOwoJaWYgKGludGVyZmFjZXMgPiAxKSB7CgkJaW50IGludGVyOwoKCQkvKiBNdWx0aXBsZSBpbnRlcmZhY2VzLiAgQXNzdW1lIEZUMjIzMkMuICovCgkJcHJpdi0+Y2hpcF90eXBlID0gRlQyMjMyQzsKCQkvKiBEZXRlcm1pbmUgaW50ZXJmYWNlIGNvZGUuICovCgkJaW50ZXIgPSBzZXJpYWwtPmludGVyZmFjZS0+YWx0c2V0dGluZy0+ZGVzYy5iSW50ZXJmYWNlTnVtYmVyOwoJCWlmIChpbnRlciA9PSAwKSB7CgkJCXByaXYtPmludGVyZmFjZSA9IFBJVF9TSU9BOwoJCX0gZWxzZSB7CgkJCXByaXYtPmludGVyZmFjZSA9IFBJVF9TSU9COwoJCX0KCQkvKiBCTS10eXBlIGRldmljZXMgaGF2ZSBhIGJ1ZyB3aGVyZSBiY2REZXZpY2UgZ2V0cyBzZXQKCQkgKiB0byAweDIwMCB3aGVuIGlTZXJpYWxOdW1iZXIgaXMgMC4gICovCgkJaWYgKHZlcnNpb24gPCAweDUwMCkgewoJCQlkYmcoIiVzOiBzb21ldGhpbmcgZmlzaHkgLSBiY2REZXZpY2UgdG9vIGxvdyBmb3IgbXVsdGktaW50ZXJmYWNlIGRldmljZSIsCgkJCQkJX19GVU5DVElPTl9fKTsKCQl9Cgl9IGVsc2UgaWYgKHZlcnNpb24gPCAweDIwMCkgewoJCS8qIE9sZCBkZXZpY2UuICBBc3N1bWUgaXRzIHRoZSBvcmlnaW5hbCBTSU8uICovCgkJcHJpdi0+Y2hpcF90eXBlID0gU0lPOwoJCXByaXYtPmJhdWRfYmFzZSA9IDEyMDAwMDAwIC8gMTY7CgkJcHJpdi0+d3JpdGVfb2Zmc2V0ID0gMTsKCX0gZWxzZSBpZiAodmVyc2lvbiA8IDB4NDAwKSB7CgkJLyogQXNzdW1lIGl0cyBhbiBGVDhVMjMyQU0gKG9yIEZUOFUyNDVBTSkgKi8KCQkvKiAoSXQgbWlnaHQgYmUgYSBCTSBiZWNhdXNlIG9mIHRoZSBpU2VyaWFsTnVtYmVyIGJ1ZywKCQkgKiBidXQgaXQgd2lsbCBzdGlsbCB3b3JrIGFzIGFuIEFNIGRldmljZS4pICovCgkJcHJpdi0+Y2hpcF90eXBlID0gRlQ4VTIzMkFNOwoJfSBlbHNlIHsKCQkvKiBBc3N1bWUgaXRzIGFuIEZUMjMyQk0gKG9yIEZUMjQ1Qk0pICovCgkJcHJpdi0+Y2hpcF90eXBlID0gRlQyMzJCTTsKCX0KCWluZm8oIkRldGVjdGVkICVzIiwgZnRkaV9jaGlwX25hbWVbcHJpdi0+Y2hpcF90eXBlXSk7Cn0KCgovKgogKiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogU3lzZnMgQXR0cmlidXRlCiAqICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKi8KCnN0YXRpYyBzc2l6ZV90IHNob3dfbGF0ZW5jeV90aW1lcihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjaGFyICpidWYpCnsKCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0b191c2Jfc2VyaWFsX3BvcnQoZGV2KTsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CglzdHJ1Y3QgdXNiX2RldmljZSAqdWRldjsKCXVuc2lnbmVkIHNob3J0IGxhdGVuY3kgPSAwOwoJaW50IHJ2ID0gMDsKCgl1ZGV2ID0gdG9fdXNiX2RldmljZShkZXYpOwoKCWRiZygiJXMiLF9fRlVOQ1RJT05fXyk7CgoJcnYgPSB1c2JfY29udHJvbF9tc2codWRldiwKCQkJICAgICB1c2JfcmN2Y3RybHBpcGUodWRldiwgMCksCgkJCSAgICAgRlRESV9TSU9fR0VUX0xBVEVOQ1lfVElNRVJfUkVRVUVTVCwKCQkJICAgICBGVERJX1NJT19HRVRfTEFURU5DWV9USU1FUl9SRVFVRVNUX1RZUEUsCgkJCSAgICAgMCwgcHJpdi0+aW50ZXJmYWNlLAoJCQkgICAgIChjaGFyKikgJmxhdGVuY3ksIDEsIFdEUl9USU1FT1VUKTsKCglpZiAocnYgPCAwKSB7CgkJZGV2X2VycihkZXYsICJVbmFibGUgdG8gcmVhZCBsYXRlbmN5IHRpbWVyOiAlaSIsIHJ2KTsKCQlyZXR1cm4gLUVJTzsKCX0KCXJldHVybiBzcHJpbnRmKGJ1ZiwgIiVpXG4iLCBsYXRlbmN5KTsKfQoKLyogV3JpdGUgYSBuZXcgdmFsdWUgb2YgdGhlIGxhdGVuY3kgdGltZXIsIGluIHVuaXRzIG9mIG1pbGxpc2Vjb25kcy4gKi8Kc3RhdGljIHNzaXplX3Qgc3RvcmVfbGF0ZW5jeV90aW1lcihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICp2YWxidWYsCgkJCQkgICBzaXplX3QgY291bnQpCnsKCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0b191c2Jfc2VyaWFsX3BvcnQoZGV2KTsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CglzdHJ1Y3QgdXNiX2RldmljZSAqdWRldjsKCWNoYXIgYnVmWzFdOwoJaW50IHYgPSBzaW1wbGVfc3RydG91bCh2YWxidWYsIE5VTEwsIDEwKTsKCWludCBydiA9IDA7CgoJdWRldiA9IHRvX3VzYl9kZXZpY2UoZGV2KTsKCglkYmcoIiVzOiBzZXR0aW5nIGxhdGVuY3kgdGltZXIgPSAlaSIsIF9fRlVOQ1RJT05fXywgdik7CgoJcnYgPSB1c2JfY29udHJvbF9tc2codWRldiwKCQkJICAgICB1c2Jfc25kY3RybHBpcGUodWRldiwgMCksCgkJCSAgICAgRlRESV9TSU9fU0VUX0xBVEVOQ1lfVElNRVJfUkVRVUVTVCwKCQkJICAgICBGVERJX1NJT19TRVRfTEFURU5DWV9USU1FUl9SRVFVRVNUX1RZUEUsCgkJCSAgICAgdiwgcHJpdi0+aW50ZXJmYWNlLAoJCQkgICAgIGJ1ZiwgMCwgV0RSX1RJTUVPVVQpOwoKCWlmIChydiA8IDApIHsKCQlkZXZfZXJyKGRldiwgIlVuYWJsZSB0byB3cml0ZSBsYXRlbmN5IHRpbWVyOiAlaSIsIHJ2KTsKCQlyZXR1cm4gLUVJTzsKCX0KCglyZXR1cm4gY291bnQ7Cn0KCi8qIFdyaXRlIGFuIGV2ZW50IGNoYXJhY3RlciBkaXJlY3RseSB0byB0aGUgRlRESSByZWdpc3Rlci4gIFRoZSBBU0NJSQogICB2YWx1ZSBpcyBpbiB0aGUgbG93IDggYml0cywgd2l0aCB0aGUgZW5hYmxlIGJpdCBpbiB0aGUgOXRoIGJpdC4gKi8Kc3RhdGljIHNzaXplX3Qgc3RvcmVfZXZlbnRfY2hhcihzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2VfYXR0cmlidXRlICphdHRyLCBjb25zdCBjaGFyICp2YWxidWYsCgkJCQlzaXplX3QgY291bnQpCnsKCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSB0b191c2Jfc2VyaWFsX3BvcnQoZGV2KTsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CglzdHJ1Y3QgdXNiX2RldmljZSAqdWRldjsKCWNoYXIgYnVmWzFdOwoJaW50IHYgPSBzaW1wbGVfc3RydG91bCh2YWxidWYsIE5VTEwsIDEwKTsKCWludCBydiA9IDA7CgoJdWRldiA9IHRvX3VzYl9kZXZpY2UoZGV2KTsKCglkYmcoIiVzOiBzZXR0aW5nIGV2ZW50IGNoYXIgPSAlaSIsIF9fRlVOQ1RJT05fXywgdik7CgoJcnYgPSB1c2JfY29udHJvbF9tc2codWRldiwKCQkJICAgICB1c2Jfc25kY3RybHBpcGUodWRldiwgMCksCgkJCSAgICAgRlRESV9TSU9fU0VUX0VWRU5UX0NIQVJfUkVRVUVTVCwKCQkJICAgICBGVERJX1NJT19TRVRfRVZFTlRfQ0hBUl9SRVFVRVNUX1RZUEUsCgkJCSAgICAgdiwgcHJpdi0+aW50ZXJmYWNlLAoJCQkgICAgIGJ1ZiwgMCwgV0RSX1RJTUVPVVQpOwoKCWlmIChydiA8IDApIHsKCQlkYmcoIlVuYWJsZSB0byB3cml0ZSBldmVudCBjaGFyYWN0ZXI6ICVpIiwgcnYpOwoJCXJldHVybiAtRUlPOwoJfQoKCXJldHVybiBjb3VudDsKfQoKc3RhdGljIERFVklDRV9BVFRSKGxhdGVuY3lfdGltZXIsIFNfSVdVU1IgfCBTX0lSVUdPLCBzaG93X2xhdGVuY3lfdGltZXIsIHN0b3JlX2xhdGVuY3lfdGltZXIpOwpzdGF0aWMgREVWSUNFX0FUVFIoZXZlbnRfY2hhciwgU19JV1VTUiwgTlVMTCwgc3RvcmVfZXZlbnRfY2hhcik7CgpzdGF0aWMgaW50IGNyZWF0ZV9zeXNmc19hdHRycyhzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKQp7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2OwoJc3RydWN0IHVzYl9kZXZpY2UgKnVkZXY7CglpbnQgcmV0dmFsID0gMDsKCglkYmcoIiVzIixfX0ZVTkNUSU9OX18pOwoKCXByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEoc2VyaWFsLT5wb3J0WzBdKTsKCXVkZXYgPSBzZXJpYWwtPmRldjsKCgkvKiBYWFggSSd2ZSBubyBpZGVhIGlmIHRoZSBvcmlnaW5hbCBTSU8gc3VwcG9ydHMgdGhlIGV2ZW50X2NoYXIKCSAqIHN5c2ZzIHBhcmFtZXRlciwgc28gSSdtIHBsYXlpbmcgaXQgc2FmZS4gICovCglpZiAocHJpdi0+Y2hpcF90eXBlICE9IFNJTykgewoJCWRiZygic3lzZnMgYXR0cmlidXRlcyBmb3IgJXMiLCBmdGRpX2NoaXBfbmFtZVtwcml2LT5jaGlwX3R5cGVdKTsKCQlyZXR2YWwgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnVkZXYtPmRldiwgJmRldl9hdHRyX2V2ZW50X2NoYXIpOwoJCWlmICgoIXJldHZhbCkgJiYKCQkgICAgKHByaXYtPmNoaXBfdHlwZSA9PSBGVDIzMkJNIHx8IHByaXYtPmNoaXBfdHlwZSA9PSBGVDIyMzJDKSkgewoJCQlyZXR2YWwgPSBkZXZpY2VfY3JlYXRlX2ZpbGUoJnVkZXYtPmRldiwKCQkJCQkJICAgICZkZXZfYXR0cl9sYXRlbmN5X3RpbWVyKTsKCQl9Cgl9CglyZXR1cm4gcmV0dmFsOwp9CgpzdGF0aWMgdm9pZCByZW1vdmVfc3lzZnNfYXR0cnMoc3RydWN0IHVzYl9zZXJpYWwgKnNlcmlhbCkKewoJc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdjsKCXN0cnVjdCB1c2JfZGV2aWNlICp1ZGV2OwoKCWRiZygiJXMiLF9fRlVOQ1RJT05fXyk7CgoJcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShzZXJpYWwtPnBvcnRbMF0pOwoJdWRldiA9IHNlcmlhbC0+ZGV2OwoKCS8qIFhYWCBzZWUgY3JlYXRlX3N5c2ZzX2F0dHJzICovCglpZiAocHJpdi0+Y2hpcF90eXBlICE9IFNJTykgewoJCWRldmljZV9yZW1vdmVfZmlsZSgmdWRldi0+ZGV2LCAmZGV2X2F0dHJfZXZlbnRfY2hhcik7CgkJaWYgKHByaXYtPmNoaXBfdHlwZSA9PSBGVDIzMkJNIHx8IHByaXYtPmNoaXBfdHlwZSA9PSBGVDIyMzJDKSB7CgkJCWRldmljZV9yZW1vdmVfZmlsZSgmdWRldi0+ZGV2LCAmZGV2X2F0dHJfbGF0ZW5jeV90aW1lcik7CgkJfQoJfQoKfQoKLyoKICogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIEZUREkgZHJpdmVyIHNwZWNpZmljIGZ1bmN0aW9ucwogKiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICovCgovKiBQcm9iZSBmdW5jdGlvbiB0byBjaGVjayBmb3Igc3BlY2lhbCBkZXZpY2VzICovCnN0YXRpYyBpbnQgZnRkaV9zaW9fcHJvYmUgKHN0cnVjdCB1c2Jfc2VyaWFsICpzZXJpYWwsIGNvbnN0IHN0cnVjdCB1c2JfZGV2aWNlX2lkICppZCkKewoJdXNiX3NldF9zZXJpYWxfZGF0YShzZXJpYWwsICh2b2lkICopaWQtPmRyaXZlcl9pbmZvKTsKCglyZXR1cm4gKDApOwp9CgovKiBhdHRhY2ggc3Vicm91dGluZSAqLwpzdGF0aWMgaW50IGZ0ZGlfc2lvX2F0dGFjaCAoc3RydWN0IHVzYl9zZXJpYWwgKnNlcmlhbCkKewoJc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCA9IHNlcmlhbC0+cG9ydFswXTsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXY7CglzdHJ1Y3QgZnRkaV9zaW9fcXVpcmsgKnF1aXJrOwoJaW50IHJldHZhbDsKCglkYmcoIiVzIixfX0ZVTkNUSU9OX18pOwoKCXByaXYgPSBremFsbG9jKHNpemVvZihzdHJ1Y3QgZnRkaV9wcml2YXRlKSwgR0ZQX0tFUk5FTCk7CglpZiAoIXByaXYpewoJCWVycigiJXMtIGttYWxsb2MoJVpkKSBmYWlsZWQuIiwgX19GVU5DVElPTl9fLCBzaXplb2Yoc3RydWN0IGZ0ZGlfcHJpdmF0ZSkpOwoJCXJldHVybiAtRU5PTUVNOwoJfQoKCXNwaW5fbG9ja19pbml0KCZwcml2LT5yeF9sb2NrKTsKCXNwaW5fbG9ja19pbml0KCZwcml2LT50eF9sb2NrKTsKICAgICAgICBpbml0X3dhaXRxdWV1ZV9oZWFkKCZwcml2LT5kZWx0YV9tc3Jfd2FpdCk7CgkvKiBUaGlzIHdpbGwgcHVzaCB0aGUgY2hhcmFjdGVycyB0aHJvdWdoIGltbWVkaWF0ZWx5IHJhdGhlcgoJICAgdGhhbiBxdWV1ZSBhIHRhc2sgdG8gZGVsaXZlciB0aGVtICovCglwcml2LT5mbGFncyA9IEFTWU5DX0xPV19MQVRFTkNZOwoKCS8qIEluY3JlYXNlIHRoZSBzaXplIG9mIHJlYWQgYnVmZmVycyAqLwoJa2ZyZWUocG9ydC0+YnVsa19pbl9idWZmZXIpOwoJcG9ydC0+YnVsa19pbl9idWZmZXIgPSBrbWFsbG9jIChCVUZTWiwgR0ZQX0tFUk5FTCk7CglpZiAoIXBvcnQtPmJ1bGtfaW5fYnVmZmVyKSB7CgkJa2ZyZWUgKHByaXYpOwoJCXJldHVybiAtRU5PTUVNOwoJfQoJaWYgKHBvcnQtPnJlYWRfdXJiKSB7CgkJcG9ydC0+cmVhZF91cmItPnRyYW5zZmVyX2J1ZmZlciA9IHBvcnQtPmJ1bGtfaW5fYnVmZmVyOwoJCXBvcnQtPnJlYWRfdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoID0gQlVGU1o7Cgl9CgoJSU5JVF9ERUxBWUVEX1dPUksoJnByaXYtPnJ4X3dvcmssIGZ0ZGlfcHJvY2Vzc19yZWFkKTsKCXByaXYtPnBvcnQgPSBwb3J0OwoKCS8qIEZyZWUgcG9ydCdzIGV4aXN0aW5nIHdyaXRlIHVyYiBhbmQgdHJhbnNmZXIgYnVmZmVyLiAqLwoJaWYgKHBvcnQtPndyaXRlX3VyYikgewoJCXVzYl9mcmVlX3VyYiAocG9ydC0+d3JpdGVfdXJiKTsKCQlwb3J0LT53cml0ZV91cmIgPSBOVUxMOwoJfQoJa2ZyZWUocG9ydC0+YnVsa19vdXRfYnVmZmVyKTsKCXBvcnQtPmJ1bGtfb3V0X2J1ZmZlciA9IE5VTEw7CgoJdXNiX3NldF9zZXJpYWxfcG9ydF9kYXRhKHNlcmlhbC0+cG9ydFswXSwgcHJpdik7CgoJZnRkaV9kZXRlcm1pbmVfdHlwZSAoc2VyaWFsLT5wb3J0WzBdKTsKCXJldHZhbCA9IGNyZWF0ZV9zeXNmc19hdHRycyhzZXJpYWwpOwoJaWYgKHJldHZhbCkKCQlkZXZfZXJyKCZzZXJpYWwtPmRldi0+ZGV2LCAiRXJyb3IgY3JlYXRpbmcgc3lzZnMgZmlsZXMsICIKCQkJImNvbnRpbnVpbmdcbiIpOwoKCS8qIENoZWNrIGZvciBkZXZpY2UgcmVxdWlyaW5nIHNwZWNpYWwgc2V0IHVwLiAqLwoJcXVpcmsgPSAoc3RydWN0IGZ0ZGlfc2lvX3F1aXJrICopdXNiX2dldF9zZXJpYWxfZGF0YShzZXJpYWwpOwoJaWYgKHF1aXJrICYmIHF1aXJrLT5zZXR1cCkgewoJCXF1aXJrLT5zZXR1cChzZXJpYWwpOwoJfQoKCXJldHVybiAwOwp9IC8qIGZ0ZGlfc2lvX2F0dGFjaCAqLwoKCi8qIFNldHVwIGZvciB0aGUgVVNCLVVJUlQgZGV2aWNlLCB3aGljaCByZXF1aXJlcyBoYXJkd2lyZWQKICogYmF1ZHJhdGUgKDM4NDAwIGdldHMgbWFwcGVkIHRvIDMxMjUwMCkgKi8KLyogQ2FsbGVkIGZyb20gdXNic2VyaWFsOnNlcmlhbF9wcm9iZSAqLwpzdGF0aWMgdm9pZCBmdGRpX1VTQl9VSVJUX3NldHVwIChzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKQp7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2OwoKCWRiZygiJXMiLF9fRlVOQ1RJT05fXyk7CgoJcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShzZXJpYWwtPnBvcnRbMF0pOwoJcHJpdi0+ZmxhZ3MgfD0gQVNZTkNfU1BEX0NVU1Q7Cglwcml2LT5jdXN0b21fZGl2aXNvciA9IDc3OwoJcHJpdi0+Zm9yY2VfYmF1ZCA9IEIzODQwMDsKfSAvKiBmdGRpX1VTQl9VSVJUX3NldHVwICovCgovKiBTZXR1cCBmb3IgdGhlIEhFLVRJUkExIGRldmljZSwgd2hpY2ggcmVxdWlyZXMgaGFyZHdpcmVkCiAqIGJhdWRyYXRlICgzODQwMCBnZXRzIG1hcHBlZCB0byAxMDAwMDApIGFuZCBSVFMtQ1RTIGVuYWJsZWQuICAqLwpzdGF0aWMgdm9pZCBmdGRpX0hFX1RJUkExX3NldHVwIChzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKQp7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2OwoKCWRiZygiJXMiLF9fRlVOQ1RJT05fXyk7CgoJcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShzZXJpYWwtPnBvcnRbMF0pOwoJcHJpdi0+ZmxhZ3MgfD0gQVNZTkNfU1BEX0NVU1Q7Cglwcml2LT5jdXN0b21fZGl2aXNvciA9IDI0MDsKCXByaXYtPmZvcmNlX2JhdWQgPSBCMzg0MDA7Cglwcml2LT5mb3JjZV9ydHNjdHMgPSAxOwp9IC8qIGZ0ZGlfSEVfVElSQTFfc2V0dXAgKi8KCgovKiBmdGRpX3NodXRkb3duIGlzIGNhbGxlZCBmcm9tIHVzYnNlcmlhbDp1c2Jfc2VyaWFsX2Rpc2Nvbm5lY3QKICogICBpdCBpcyBjYWxsZWQgd2hlbiB0aGUgdXNiIGRldmljZSBpcyBkaXNjb25uZWN0ZWQKICoKICogICB1c2JzZXJpYWw6dXNiX3NlcmlhbF9kaXNjb25uZWN0CiAqICAgICAgY2FsbHMgX19zZXJpYWxfY2xvc2UgZm9yIGVhY2ggb3BlbiBvZiB0aGUgcG9ydAogKiAgICAgIHNodXRkb3duIGlzIGNhbGxlZCB0aGVuIChpZSBmdGRpX3NodXRkb3duKQogKi8KCgpzdGF0aWMgdm9pZCBmdGRpX3NodXRkb3duIChzdHJ1Y3QgdXNiX3NlcmlhbCAqc2VyaWFsKQp7IC8qIGZ0ZGlfc2h1dGRvd24gKi8KCglzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gc2VyaWFsLT5wb3J0WzBdOwoJc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKCglkYmcoIiVzIiwgX19GVU5DVElPTl9fKTsKCglyZW1vdmVfc3lzZnNfYXR0cnMoc2VyaWFsKTsKCgkvKiBhbGwgb3BlbiBwb3J0cyBhcmUgY2xvc2VkIGF0IHRoaXMgcG9pbnQKICAgICAgICAgKiAgICAoYnkgdXNic2VyaWFsLmM6X19zZXJpYWxfY2xvc2UsIHdoaWNoIGNhbGxzIGZ0ZGlfY2xvc2UpCgkgKi8KCglpZiAocHJpdikgewoJCXVzYl9zZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0LCBOVUxMKTsKCQlrZnJlZShwcml2KTsKCX0KfSAvKiBmdGRpX3NodXRkb3duICovCgoKc3RhdGljIGludCAgZnRkaV9vcGVuIChzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBzdHJ1Y3QgZmlsZSAqZmlscCkKeyAvKiBmdGRpX29wZW4gKi8KCXN0cnVjdCB1c2JfZGV2aWNlICpkZXYgPSBwb3J0LT5zZXJpYWwtPmRldjsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCWludCByZXN1bHQgPSAwOwoJY2hhciBidWZbMV07IC8qIE5lZWRlZCBmb3IgdGhlIHVzYl9jb250cm9sX21zZyBJIHRoaW5rICovCgoJZGJnKCIlcyIsIF9fRlVOQ1RJT05fXyk7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPnR4X2xvY2ssIGZsYWdzKTsKCXByaXYtPnR4X2J5dGVzID0gMDsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnR4X2xvY2ssIGZsYWdzKTsKCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7Cglwcml2LT5yeF9ieXRlcyA9IDA7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7CgoJaWYgKHBvcnQtPnR0eSkKCQlwb3J0LT50dHktPmxvd19sYXRlbmN5ID0gKHByaXYtPmZsYWdzICYgQVNZTkNfTE9XX0xBVEVOQ1kpID8gMSA6IDA7CgoJLyogTm8gZXJyb3IgY2hlY2tpbmcgZm9yIHRoaXMgKHdpbGwgZ2V0IGVycm9ycyBsYXRlciBhbnl3YXkpICovCgkvKiBTZWUgZnRkaV9zaW8uaCBmb3IgZGVzY3JpcHRpb24gb2Ygd2hhdCBpcyByZXNldCAqLwoJdXNiX2NvbnRyb2xfbXNnKGRldiwgdXNiX3NuZGN0cmxwaXBlKGRldiwgMCksCgkJCUZURElfU0lPX1JFU0VUX1JFUVVFU1QsIEZURElfU0lPX1JFU0VUX1JFUVVFU1RfVFlQRSwKCQkJRlRESV9TSU9fUkVTRVRfU0lPLAoJCQlwcml2LT5pbnRlcmZhY2UsIGJ1ZiwgMCwgV0RSX1RJTUVPVVQpOwoKCS8qIFRlcm1pb3MgZGVmYXVsdHMgYXJlIHNldCBieSB1c2Jfc2VyaWFsX2luaXQuIFdlIGRvbid0IGNoYW5nZQoJICAgcG9ydC0+dHR5LT50ZXJtaW9zIC0gdGhpcyB3b3VsZCBsb29zZSBzcGVlZCBzZXR0aW5ncywgZXRjLgoJICAgVGhpcyBpcyBzYW1lIGJlaGF2aW91ciBhcyBzZXJpYWwuYy9yc19vcGVuKCkgLSBLdWJhICovCgoJLyogZnRkaV9zZXRfdGVybWlvcyAgd2lsbCBzZW5kIHVzYiBjb250cm9sIG1lc3NhZ2VzICovCglpZiAocG9ydC0+dHR5KQoJCWZ0ZGlfc2V0X3Rlcm1pb3MocG9ydCwgTlVMTCk7CgoJLyogRklYTUU6IEZsb3cgY29udHJvbCBtaWdodCBiZSBlbmFibGVkLCBzbyBpdCBzaG91bGQgYmUgY2hlY2tlZCAtCgkgICB3ZSBoYXZlIG5vIGNvbnRyb2wgb2YgZGVmYXVsdHMhICovCgkvKiBUdXJuIG9uIFJUUyBhbmQgRFRSIHNpbmNlIHdlIGFyZSBub3QgZmxvdyBjb250cm9sbGluZyBieSBkZWZhdWx0ICovCglzZXRfbWN0cmwocG9ydCwgVElPQ01fRFRSIHwgVElPQ01fUlRTKTsKCgkvKiBOb3QgdGhyb3R0bGVkICovCglzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwoJcHJpdi0+cnhfZmxhZ3MgJj0gfihUSFJPVFRMRUQgfCBBQ1RVQUxMWV9USFJPVFRMRUQpOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwoKCS8qIFN0YXJ0IHJlYWRpbmcgZnJvbSB0aGUgZGV2aWNlICovCglwcml2LT5yeF9wcm9jZXNzZWQgPSAwOwoJdXNiX2ZpbGxfYnVsa191cmIocG9ydC0+cmVhZF91cmIsIGRldiwKCQkgICAgICB1c2JfcmN2YnVsa3BpcGUoZGV2LCBwb3J0LT5idWxrX2luX2VuZHBvaW50QWRkcmVzcyksCgkJICAgICAgcG9ydC0+cmVhZF91cmItPnRyYW5zZmVyX2J1ZmZlciwgcG9ydC0+cmVhZF91cmItPnRyYW5zZmVyX2J1ZmZlcl9sZW5ndGgsCgkJICAgICAgZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2ssIHBvcnQpOwoJcmVzdWx0ID0gdXNiX3N1Ym1pdF91cmIocG9ydC0+cmVhZF91cmIsIEdGUF9LRVJORUwpOwoJaWYgKHJlc3VsdCkKCQllcnIoIiVzIC0gZmFpbGVkIHN1Ym1pdHRpbmcgcmVhZCB1cmIsIGVycm9yICVkIiwgX19GVU5DVElPTl9fLCByZXN1bHQpOwoKCglyZXR1cm4gcmVzdWx0Owp9IC8qIGZ0ZGlfb3BlbiAqLwoKCgovKgogKiB1c2JzZXJpYWw6X19zZXJpYWxfY2xvc2UgIG9ubHkgY2FsbHMgZnRkaV9jbG9zZSBpZiB0aGUgcG9pbnQgaXMgb3BlbgogKgogKiAgIFRoaXMgb25seSBnZXRzIGNhbGxlZCB3aGVuIGl0IGlzIHRoZSBsYXN0IGNsb3NlCiAqCiAqCiAqLwoKc3RhdGljIHZvaWQgZnRkaV9jbG9zZSAoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwgc3RydWN0IGZpbGUgKmZpbHApCnsgLyogZnRkaV9jbG9zZSAqLwoJdW5zaWduZWQgaW50IGNfY2ZsYWcgPSBwb3J0LT50dHktPnRlcm1pb3MtPmNfY2ZsYWc7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJY2hhciBidWZbMV07CgoJZGJnKCIlcyIsIF9fRlVOQ1RJT05fXyk7CgoJaWYgKGNfY2ZsYWcgJiBIVVBDTCl7CgkJLyogRGlzYWJsZSBmbG93IGNvbnRyb2wgKi8KCQlpZiAodXNiX2NvbnRyb2xfbXNnKHBvcnQtPnNlcmlhbC0+ZGV2LAoJCQkJICAgIHVzYl9zbmRjdHJscGlwZShwb3J0LT5zZXJpYWwtPmRldiwgMCksCgkJCQkgICAgRlRESV9TSU9fU0VUX0ZMT1dfQ1RSTF9SRVFVRVNULAoJCQkJICAgIEZURElfU0lPX1NFVF9GTE9XX0NUUkxfUkVRVUVTVF9UWVBFLAoJCQkJICAgIDAsIHByaXYtPmludGVyZmFjZSwgYnVmLCAwLAoJCQkJICAgIFdEUl9USU1FT1VUKSA8IDApIHsKCQkJZXJyKCJlcnJvciBmcm9tIGZsb3djb250cm9sIHVyYiIpOwoJCX0KCgkJLyogZHJvcCBSVFMgYW5kIERUUiAqLwoJCWNsZWFyX21jdHJsKHBvcnQsIFRJT0NNX0RUUiB8IFRJT0NNX1JUUyk7Cgl9IC8qIE5vdGUgY2hhbmdlIG5vIGxpbmUgaWYgaHVwY2wgaXMgb2ZmICovCgoJLyogY2FuY2VsIGFueSBzY2hlZHVsZWQgcmVhZGluZyAqLwoJY2FuY2VsX2RlbGF5ZWRfd29yaygmcHJpdi0+cnhfd29yayk7CglmbHVzaF9zY2hlZHVsZWRfd29yaygpOwoKCS8qIHNodXRkb3duIG91ciBidWxrIHJlYWQgKi8KCWlmIChwb3J0LT5yZWFkX3VyYikKCQl1c2Jfa2lsbF91cmIocG9ydC0+cmVhZF91cmIpOwp9IC8qIGZ0ZGlfY2xvc2UgKi8KCgoKLyogVGhlIFNJTyByZXF1aXJlcyB0aGUgZmlyc3QgYnl0ZSB0byBoYXZlOgogKiAgQjAgMQogKiAgQjEgMAogKiAgQjIuLjcgbGVuZ3RoIG9mIG1lc3NhZ2UgZXhjbHVkaW5nIGJ5dGUgMAogKgogKiBUaGUgbmV3IGRldmljZXMgZG8gbm90IHJlcXVpcmUgdGhpcyBieXRlCiAqLwpzdGF0aWMgaW50IGZ0ZGlfd3JpdGUgKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQsCgkJCSAgIGNvbnN0IHVuc2lnbmVkIGNoYXIgKmJ1ZiwgaW50IGNvdW50KQp7IC8qIGZ0ZGlfd3JpdGUgKi8KCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CglzdHJ1Y3QgdXJiICp1cmI7Cgl1bnNpZ25lZCBjaGFyICpidWZmZXI7CglpbnQgZGF0YV9vZmZzZXQgOyAgICAgICAvKiB3aWxsIGJlIDEgZm9yIHRoZSBTSU8gYW5kIDAgb3RoZXJ3aXNlICovCglpbnQgc3RhdHVzOwoJaW50IHRyYW5zZmVyX3NpemU7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCWRiZygiJXMgcG9ydCAlZCwgJWQgYnl0ZXMiLCBfX0ZVTkNUSU9OX18sIHBvcnQtPm51bWJlciwgY291bnQpOwoKCWlmIChjb3VudCA9PSAwKSB7CgkJZGJnKCJ3cml0ZSByZXF1ZXN0IG9mIDAgYnl0ZXMiKTsKCQlyZXR1cm4gMDsKCX0KCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT50eF9sb2NrLCBmbGFncyk7CglpZiAocHJpdi0+dHhfb3V0c3RhbmRpbmdfdXJicyA+IFVSQl9VUFBFUl9MSU1JVCkgewoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnR4X2xvY2ssIGZsYWdzKTsKCQlkYmcoIiVzIC0gd3JpdGUgbGltaXQgaGl0XG4iLCBfX0ZVTkNUSU9OX18pOwoJCXJldHVybiAwOwoJfQoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+dHhfbG9jaywgZmxhZ3MpOwoKCWRhdGFfb2Zmc2V0ID0gcHJpdi0+d3JpdGVfb2Zmc2V0OwogICAgICAgIGRiZygiZGF0YV9vZmZzZXQgc2V0IHRvICVkIixkYXRhX29mZnNldCk7CgoJLyogRGV0ZXJtaW5lIHRvdGFsIHRyYW5zZmVyIHNpemUgKi8KCXRyYW5zZmVyX3NpemUgPSBjb3VudDsKCWlmIChkYXRhX29mZnNldCA+IDApIHsKCQkvKiBPcmlnaW5hbCBzaW8gbmVlZHMgY29udHJvbCBieXRlcyB0b28uLi4gKi8KCQl0cmFuc2Zlcl9zaXplICs9IChkYXRhX29mZnNldCAqCgkJCQkoKGNvdW50ICsgKFBLVFNaIC0gMSAtIGRhdGFfb2Zmc2V0KSkgLwoJCQkJIChQS1RTWiAtIGRhdGFfb2Zmc2V0KSkpOwoJfQoKCWJ1ZmZlciA9IGttYWxsb2MgKHRyYW5zZmVyX3NpemUsIEdGUF9BVE9NSUMpOwoJaWYgKCFidWZmZXIpIHsKCQllcnIoIiVzIHJhbiBvdXQgb2Yga2VybmVsIG1lbW9yeSBmb3IgdXJiIC4uLiIsIF9fRlVOQ1RJT05fXyk7CgkJcmV0dXJuIC1FTk9NRU07Cgl9CgoJdXJiID0gdXNiX2FsbG9jX3VyYigwLCBHRlBfQVRPTUlDKTsKCWlmICghdXJiKSB7CgkJZXJyKCIlcyAtIG5vIG1vcmUgZnJlZSB1cmJzIiwgX19GVU5DVElPTl9fKTsKCQlrZnJlZSAoYnVmZmVyKTsKCQlyZXR1cm4gLUVOT01FTTsKCX0KCgkvKiBDb3B5IGRhdGEgKi8KCWlmIChkYXRhX29mZnNldCA+IDApIHsKCQkvKiBPcmlnaW5hbCBzaW8gcmVxdWlyZXMgY29udHJvbCBieXRlIGF0IHN0YXJ0IG9mIGVhY2ggcGFja2V0LiAqLwoJCWludCB1c2VyX3BrdHN6ID0gUEtUU1ogLSBkYXRhX29mZnNldDsKCQlpbnQgdG9kbyA9IGNvdW50OwoJCXVuc2lnbmVkIGNoYXIgKmZpcnN0X2J5dGUgPSBidWZmZXI7CgkJY29uc3QgdW5zaWduZWQgY2hhciAqY3VycmVudF9wb3NpdGlvbiA9IGJ1ZjsKCgkJd2hpbGUgKHRvZG8gPiAwKSB7CgkJCWlmICh1c2VyX3BrdHN6ID4gdG9kbykgewoJCQkJdXNlcl9wa3RzeiA9IHRvZG87CgkJCX0KCQkJLyogV3JpdGUgdGhlIGNvbnRyb2wgYnl0ZSBhdCB0aGUgZnJvbnQgb2YgdGhlIHBhY2tldCovCgkJCSpmaXJzdF9ieXRlID0gMSB8ICgodXNlcl9wa3RzeikgPDwgMik7CgkJCS8qIENvcHkgZGF0YSBmb3IgcGFja2V0ICovCgkJCW1lbWNweSAoZmlyc3RfYnl0ZSArIGRhdGFfb2Zmc2V0LAoJCQkJY3VycmVudF9wb3NpdGlvbiwgdXNlcl9wa3Rzeik7CgkJCWZpcnN0X2J5dGUgKz0gdXNlcl9wa3RzeiArIGRhdGFfb2Zmc2V0OwoJCQljdXJyZW50X3Bvc2l0aW9uICs9IHVzZXJfcGt0c3o7CgkJCXRvZG8gLT0gdXNlcl9wa3RzejsKCQl9Cgl9IGVsc2UgewoJCS8qIE5vIGNvbnRyb2wgYnl0ZSByZXF1aXJlZC4gKi8KCQkvKiBDb3B5IGluIHRoZSBkYXRhIHRvIHNlbmQgKi8KCQltZW1jcHkgKGJ1ZmZlciwgYnVmLCBjb3VudCk7Cgl9CgoJdXNiX3NlcmlhbF9kZWJ1Z19kYXRhKGRlYnVnLCAmcG9ydC0+ZGV2LCBfX0ZVTkNUSU9OX18sIHRyYW5zZmVyX3NpemUsIGJ1ZmZlcik7CgoJLyogZmlsbCB0aGUgYnVmZmVyIGFuZCBzZW5kIGl0ICovCgl1c2JfZmlsbF9idWxrX3VyYih1cmIsIHBvcnQtPnNlcmlhbC0+ZGV2LAoJCSAgICAgIHVzYl9zbmRidWxrcGlwZShwb3J0LT5zZXJpYWwtPmRldiwgcG9ydC0+YnVsa19vdXRfZW5kcG9pbnRBZGRyZXNzKSwKCQkgICAgICBidWZmZXIsIHRyYW5zZmVyX3NpemUsCgkJICAgICAgZnRkaV93cml0ZV9idWxrX2NhbGxiYWNrLCBwb3J0KTsKCglzdGF0dXMgPSB1c2Jfc3VibWl0X3VyYih1cmIsIEdGUF9BVE9NSUMpOwoJaWYgKHN0YXR1cykgewoJCWVycigiJXMgLSBmYWlsZWQgc3VibWl0dGluZyB3cml0ZSB1cmIsIGVycm9yICVkIiwgX19GVU5DVElPTl9fLCBzdGF0dXMpOwoJCWNvdW50ID0gc3RhdHVzOwoJCWtmcmVlIChidWZmZXIpOwoJfSBlbHNlIHsKCQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+dHhfbG9jaywgZmxhZ3MpOwoJCSsrcHJpdi0+dHhfb3V0c3RhbmRpbmdfdXJiczsKCQlwcml2LT50eF9vdXRzdGFuZGluZ19ieXRlcyArPSBjb3VudDsKCQlwcml2LT50eF9ieXRlcyArPSBjb3VudDsKCQlzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT50eF9sb2NrLCBmbGFncyk7Cgl9CgoJLyogd2UgYXJlIGRvbmUgd2l0aCB0aGlzIHVyYiwgc28gbGV0IHRoZSBob3N0IGRyaXZlcgoJICogcmVhbGx5IGZyZWUgaXQgd2hlbiBpdCBpcyBmaW5pc2hlZCB3aXRoIGl0ICovCgl1c2JfZnJlZV91cmIgKHVyYik7CgoJZGJnKCIlcyB3cml0ZSByZXR1cm5pbmc6ICVkIiwgX19GVU5DVElPTl9fLCBjb3VudCk7CglyZXR1cm4gY291bnQ7Cn0gLyogZnRkaV93cml0ZSAqLwoKCi8qIFRoaXMgZnVuY3Rpb24gbWF5IGdldCBjYWxsZWQgd2hlbiB0aGUgZGV2aWNlIGlzIGNsb3NlZCAqLwoKc3RhdGljIHZvaWQgZnRkaV93cml0ZV9idWxrX2NhbGxiYWNrIChzdHJ1Y3QgdXJiICp1cmIpCnsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CglzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0ID0gKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKil1cmItPmNvbnRleHQ7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2OwoJaW50IGRhdGFfb2Zmc2V0OyAgICAgICAvKiB3aWxsIGJlIDEgZm9yIHRoZSBTSU8gYW5kIDAgb3RoZXJ3aXNlICovCgl1bnNpZ25lZCBsb25nIGNvdW50YmFjazsKCgkvKiBmcmVlIHVwIHRoZSB0cmFuc2ZlciBidWZmZXIsIGFzIHVzYl9mcmVlX3VyYigpIGRvZXMgbm90IGRvIHRoaXMgKi8KCWtmcmVlICh1cmItPnRyYW5zZmVyX2J1ZmZlcik7CgoJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX0ZVTkNUSU9OX18sIHBvcnQtPm51bWJlcik7CgoJaWYgKHVyYi0+c3RhdHVzKSB7CgkJZGJnKCJub256ZXJvIHdyaXRlIGJ1bGsgc3RhdHVzIHJlY2VpdmVkOiAlZCIsIHVyYi0+c3RhdHVzKTsKCQlyZXR1cm47Cgl9CgoJcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKCWlmICghcHJpdikgewoJCWRiZygiJXMgLSBiYWQgcG9ydCBwcml2YXRlIGRhdGEgcG9pbnRlciAtIGV4aXRpbmciLCBfX0ZVTkNUSU9OX18pOwoJCXJldHVybjsKCX0KCS8qIGFjY291bnQgZm9yIHRyYW5zZmVycmVkIGRhdGEgKi8KCWNvdW50YmFjayA9IHVyYi0+YWN0dWFsX2xlbmd0aDsKCWRhdGFfb2Zmc2V0ID0gcHJpdi0+d3JpdGVfb2Zmc2V0OwoJaWYgKGRhdGFfb2Zmc2V0ID4gMCkgewoJCS8qIFN1YnRyYWN0IHRoZSBjb250cm9sIGJ5dGVzICovCgkJY291bnRiYWNrIC09IChkYXRhX29mZnNldCAqICgoY291bnRiYWNrICsgKFBLVFNaIC0gMSkpIC8gUEtUU1opKTsKCX0KCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT50eF9sb2NrLCBmbGFncyk7CgktLXByaXYtPnR4X291dHN0YW5kaW5nX3VyYnM7Cglwcml2LT50eF9vdXRzdGFuZGluZ19ieXRlcyAtPSBjb3VudGJhY2s7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT50eF9sb2NrLCBmbGFncyk7CgoJdXNiX3NlcmlhbF9wb3J0X3NvZnRpbnQocG9ydCk7Cn0gLyogZnRkaV93cml0ZV9idWxrX2NhbGxiYWNrICovCgoKc3RhdGljIGludCBmdGRpX3dyaXRlX3Jvb20oIHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgKQp7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJaW50IHJvb207Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCWRiZygiJXMgLSBwb3J0ICVkIiwgX19GVU5DVElPTl9fLCBwb3J0LT5udW1iZXIpOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT50eF9sb2NrLCBmbGFncyk7CglpZiAocHJpdi0+dHhfb3V0c3RhbmRpbmdfdXJicyA8IFVSQl9VUFBFUl9MSU1JVCkgewoJCS8qCgkJICogV2UgcmVhbGx5IGNhbiB0YWtlIGFueXRoaW5nIHRoZSB1c2VyIHRocm93cyBhdCB1cwoJCSAqIGJ1dCBsZXQncyBwaWNrIGEgbmljZSBiaWcgbnVtYmVyIHRvIHRlbGwgdGhlIHR0eQoJCSAqIGxheWVyIHRoYXQgd2UgaGF2ZSBsb3RzIG9mIGZyZWUgc3BhY2UKCQkgKi8KCQlyb29tID0gMjA0ODsKCX0gZWxzZSB7CgkJcm9vbSA9IDA7Cgl9CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT50eF9sb2NrLCBmbGFncyk7CglyZXR1cm4gcm9vbTsKfSAvKiBmdGRpX3dyaXRlX3Jvb20gKi8KCgpzdGF0aWMgaW50IGZ0ZGlfY2hhcnNfaW5fYnVmZmVyIChzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0KQp7IC8qIGZ0ZGlfY2hhcnNfaW5fYnVmZmVyICovCglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJaW50IGJ1ZmZlcmVkOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglkYmcoIiVzIC0gcG9ydCAlZCIsIF9fRlVOQ1RJT05fXywgcG9ydC0+bnVtYmVyKTsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+dHhfbG9jaywgZmxhZ3MpOwoJYnVmZmVyZWQgPSAoaW50KXByaXYtPnR4X291dHN0YW5kaW5nX2J5dGVzOwoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+dHhfbG9jaywgZmxhZ3MpOwoJaWYgKGJ1ZmZlcmVkIDwgMCkgewoJCWVycigiJXMgb3V0c3RhbmRpbmcgdHggYnl0ZXMgaXMgbmVnYXRpdmUhIiwgX19GVU5DVElPTl9fKTsKCQlidWZmZXJlZCA9IDA7Cgl9CglyZXR1cm4gYnVmZmVyZWQ7Cn0gLyogZnRkaV9jaGFyc19pbl9idWZmZXIgKi8KCgoKc3RhdGljIHZvaWQgZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2sgKHN0cnVjdCB1cmIgKnVyYikKeyAvKiBmdGRpX3JlYWRfYnVsa19jYWxsYmFjayAqLwoJc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCA9IChzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICopdXJiLT5jb250ZXh0OwoJc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eTsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXY7Cgl1bnNpZ25lZCBsb25nIGNvdW50cmVhZDsKCXVuc2lnbmVkIGxvbmcgZmxhZ3M7CgoJaWYgKHVyYi0+bnVtYmVyX29mX3BhY2tldHMgPiAwKSB7CgkJZXJyKCIlcyB0cmFuc2Zlcl9idWZmZXJfbGVuZ3RoICVkIGFjdHVhbF9sZW5ndGggJWQgbnVtYmVyIG9mIHBhY2tldHMgJWQiLF9fRlVOQ1RJT05fXywKCQkgICAgdXJiLT50cmFuc2Zlcl9idWZmZXJfbGVuZ3RoLCB1cmItPmFjdHVhbF9sZW5ndGgsIHVyYi0+bnVtYmVyX29mX3BhY2tldHMgKTsKCQllcnIoIiVzIHRyYW5zZmVyX2ZsYWdzICV4ICIsIF9fRlVOQ1RJT05fXyx1cmItPnRyYW5zZmVyX2ZsYWdzICk7Cgl9CgoJZGJnKCIlcyAtIHBvcnQgJWQiLCBfX0ZVTkNUSU9OX18sIHBvcnQtPm51bWJlcik7CgoJaWYgKHBvcnQtPm9wZW5fY291bnQgPD0gMCkKCQlyZXR1cm47CgoJdHR5ID0gcG9ydC0+dHR5OwoJaWYgKCF0dHkpIHsKCQlkYmcoIiVzIC0gYmFkIHR0eSBwb2ludGVyIC0gZXhpdGluZyIsX19GVU5DVElPTl9fKTsKCQlyZXR1cm47Cgl9CgoJcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKCWlmICghcHJpdikgewoJCWRiZygiJXMgLSBiYWQgcG9ydCBwcml2YXRlIGRhdGEgcG9pbnRlciAtIGV4aXRpbmciLCBfX0ZVTkNUSU9OX18pOwoJCXJldHVybjsKCX0KCglpZiAodXJiICE9IHBvcnQtPnJlYWRfdXJiKSB7CgkJZXJyKCIlcyAtIE5vdCBteSB1cmIhIiwgX19GVU5DVElPTl9fKTsKCX0KCglpZiAodXJiLT5zdGF0dXMpIHsKCQkvKiBUaGlzIHdpbGwgaGFwcGVuIGF0IGNsb3NlIGV2ZXJ5IHRpbWUgc28gaXQgaXMgYSBkYmcgbm90IGFuIGVyciAqLwoJCWRiZygiKHRoaXMgaXMgb2sgb24gY2xvc2UpIG5vbnplcm8gcmVhZCBidWxrIHN0YXR1cyByZWNlaXZlZDogJWQiLCB1cmItPnN0YXR1cyk7CgkJcmV0dXJuOwoJfQoKCS8qIGNvdW50IGRhdGEgYnl0ZXMsIGJ1dCBub3Qgc3RhdHVzIGJ5dGVzICovCgljb3VudHJlYWQgPSB1cmItPmFjdHVhbF9sZW5ndGg7Cgljb3VudHJlYWQgLT0gMiAqICgoY291bnRyZWFkICsgKFBLVFNaIC0gMSkpIC8gUEtUU1opOwoJc3Bpbl9sb2NrX2lycXNhdmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKCXByaXYtPnJ4X2J5dGVzICs9IGNvdW50cmVhZDsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKCglmdGRpX3Byb2Nlc3NfcmVhZCgmcHJpdi0+cnhfd29yay53b3JrKTsKCn0gLyogZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2sgKi8KCgpzdGF0aWMgdm9pZCBmdGRpX3Byb2Nlc3NfcmVhZCAoc3RydWN0IHdvcmtfc3RydWN0ICp3b3JrKQp7IC8qIGZ0ZGlfcHJvY2Vzc19yZWFkICovCglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0KCQljb250YWluZXJfb2Yod29yaywgc3RydWN0IGZ0ZGlfcHJpdmF0ZSwgcnhfd29yay53b3JrKTsKCXN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQgPSBwcml2LT5wb3J0OwoJc3RydWN0IHVyYiAqdXJiOwoJc3RydWN0IHR0eV9zdHJ1Y3QgKnR0eTsKCWNoYXIgZXJyb3JfZmxhZzsKCXVuc2lnbmVkIGNoYXIgKmRhdGE7CgoJaW50IGk7CglpbnQgcmVzdWx0OwoJaW50IG5lZWRfZmxpcDsKCWludCBwYWNrZXRfb2Zmc2V0OwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglkYmcoIiVzIC0gcG9ydCAlZCIsIF9fRlVOQ1RJT05fXywgcG9ydC0+bnVtYmVyKTsKCglpZiAocG9ydC0+b3Blbl9jb3VudCA8PSAwKQoJCXJldHVybjsKCgl0dHkgPSBwb3J0LT50dHk7CglpZiAoIXR0eSkgewoJCWRiZygiJXMgLSBiYWQgdHR5IHBvaW50ZXIgLSBleGl0aW5nIixfX0ZVTkNUSU9OX18pOwoJCXJldHVybjsKCX0KCglwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJaWYgKCFwcml2KSB7CgkJZGJnKCIlcyAtIGJhZCBwb3J0IHByaXZhdGUgZGF0YSBwb2ludGVyIC0gZXhpdGluZyIsIF9fRlVOQ1RJT05fXyk7CgkJcmV0dXJuOwoJfQoKCXVyYiA9IHBvcnQtPnJlYWRfdXJiOwoJaWYgKCF1cmIpIHsKCQlkYmcoIiVzIC0gYmFkIHJlYWRfdXJiIHBvaW50ZXIgLSBleGl0aW5nIiwgX19GVU5DVElPTl9fKTsKCQlyZXR1cm47Cgl9CgoJZGF0YSA9IHVyYi0+dHJhbnNmZXJfYnVmZmVyOwoKCWlmIChwcml2LT5yeF9wcm9jZXNzZWQpIHsKCQlkYmcoIiVzIC0gYWxyZWFkeSBwcm9jZXNzZWQ6ICVkIGJ5dGVzLCAlZCByZW1haW4iLCBfX0ZVTkNUSU9OX18sCgkJCQlwcml2LT5yeF9wcm9jZXNzZWQsCgkJCQl1cmItPmFjdHVhbF9sZW5ndGggLSBwcml2LT5yeF9wcm9jZXNzZWQpOwoJfSBlbHNlIHsKCQkvKiBUaGUgZmlyc3QgdHdvIGJ5dGVzIG9mIGV2ZXJ5IHJlYWQgcGFja2V0IGFyZSBzdGF0dXMgKi8KCQlpZiAodXJiLT5hY3R1YWxfbGVuZ3RoID4gMikgewoJCQl1c2Jfc2VyaWFsX2RlYnVnX2RhdGEoZGVidWcsICZwb3J0LT5kZXYsIF9fRlVOQ1RJT05fXywgdXJiLT5hY3R1YWxfbGVuZ3RoLCBkYXRhKTsKCQl9IGVsc2UgewoJCQlkYmcoIlN0YXR1cyBvbmx5OiAlMDNvbyAlMDNvbyIsZGF0YVswXSxkYXRhWzFdKTsKCQl9Cgl9CgoKCS8qIFRPIERPIC0tIGNoZWNrIGZvciBodW5nIHVwIGxpbmUgYW5kIGhhbmRsZSBhcHByb3ByaWF0ZWx5OiAqLwoJLyogICBzZW5kIGhhbmd1cCAgKi8KCS8qIFNlZSBhY20uYyAtIHlvdSBkbyBhIHR0eV9oYW5ndXAgIC0gZWcgdHR5X2hhbmd1cCh0dHkpICovCgkvKiBpZiBDRCBpcyBkcm9wcGVkIGFuZCB0aGUgbGluZSBpcyBub3QgQ0xPQ0FMIHRoZW4gd2Ugc2hvdWxkIGhhbmd1cCAqLwoKCW5lZWRfZmxpcCA9IDA7Cglmb3IgKHBhY2tldF9vZmZzZXQgPSBwcml2LT5yeF9wcm9jZXNzZWQ7IHBhY2tldF9vZmZzZXQgPCB1cmItPmFjdHVhbF9sZW5ndGg7IHBhY2tldF9vZmZzZXQgKz0gUEtUU1opIHsKCQlpbnQgbGVuZ3RoOwoKCQkvKiBDb21wYXJlIG5ldyBsaW5lIHN0YXR1cyB0byB0aGUgb2xkIG9uZSwgc2lnbmFsIGlmIGRpZmZlcmVudCAqLwoJCS8qIE4uQi4gcGFja2V0IG1heSBiZSBwcm9jZXNzZWQgbW9yZSB0aGFuIG9uY2UsIGJ1dCBkaWZmZXJlbmNlcwoJCSAqIGFyZSBvbmx5IHByb2Nlc3NlZCBvbmNlLiAgKi8KCQlpZiAocHJpdiAhPSBOVUxMKSB7CgkJCWNoYXIgbmV3X3N0YXR1cyA9IGRhdGFbcGFja2V0X29mZnNldCswXSAmIEZURElfU1RBVFVTX0IwX01BU0s7CgkJCWlmIChuZXdfc3RhdHVzICE9IHByaXYtPnByZXZfc3RhdHVzKSB7CgkJCQlwcml2LT5kaWZmX3N0YXR1cyB8PSBuZXdfc3RhdHVzIF4gcHJpdi0+cHJldl9zdGF0dXM7CgkJCQl3YWtlX3VwX2ludGVycnVwdGlibGUoJnByaXYtPmRlbHRhX21zcl93YWl0KTsKCQkJCXByaXYtPnByZXZfc3RhdHVzID0gbmV3X3N0YXR1czsKCQkJfQoJCX0KCgkJbGVuZ3RoID0gbWluKFBLVFNaLCB1cmItPmFjdHVhbF9sZW5ndGgtcGFja2V0X29mZnNldCktMjsKCQlpZiAobGVuZ3RoIDwgMCkgewoJCQllcnIoIiVzIC0gYmFkIHBhY2tldCBsZW5ndGg6ICVkIiwgX19GVU5DVElPTl9fLCBsZW5ndGgrMik7CgkJCWxlbmd0aCA9IDA7CgkJfQoKCQlpZiAocHJpdi0+cnhfZmxhZ3MgJiBUSFJPVFRMRUQpIHsKCQkJZGJnKCIlcyAtIHRocm90dGxlZCIsIF9fRlVOQ1RJT05fXyk7CgkJCWJyZWFrOwoJCX0KCQlpZiAodHR5X2J1ZmZlcl9yZXF1ZXN0X3Jvb20odHR5LCBsZW5ndGgpIDwgbGVuZ3RoKSB7CgkJCS8qIGJyZWFrIG91dCAmIHdhaXQgZm9yIHRocm90dGxpbmcvdW50aHJvdHRsaW5nIHRvIGhhcHBlbiAqLwoJCQlkYmcoIiVzIC0gcmVjZWl2ZSByb29tIGxvdyIsIF9fRlVOQ1RJT05fXyk7CgkJCWJyZWFrOwoJCX0KCgkJLyogSGFuZGxlIGVycm9ycyBhbmQgYnJlYWsgKi8KCQllcnJvcl9mbGFnID0gVFRZX05PUk1BTDsKCQkvKiBBbHRob3VnaCB0aGUgZGV2aWNlIHVzZXMgYSBiaXRtYXNrIGFuZCBoZW5jZSBjYW4gaGF2ZSBtdWx0aXBsZSAqLwoJCS8qIGVycm9ycyBvbiBhIHBhY2tldCAtIHRoZSBvcmRlciBoZXJlIHNldHMgdGhlIHByaW9yaXR5IHRoZSAqLwoJCS8qIGVycm9yIGlzIHJldHVybmVkIHRvIHRoZSB0dHkgbGF5ZXIgICovCgoJCWlmICggZGF0YVtwYWNrZXRfb2Zmc2V0KzFdICYgRlRESV9SU19PRSApIHsKCQkJZXJyb3JfZmxhZyA9IFRUWV9PVkVSUlVOOwoJCQlkYmcoIk9WRVJSUlVOIGVycm9yIik7CgkJfQoJCWlmICggZGF0YVtwYWNrZXRfb2Zmc2V0KzFdICYgRlRESV9SU19CSSApIHsKCQkJZXJyb3JfZmxhZyA9IFRUWV9CUkVBSzsKCQkJZGJnKCJCUkVBSyByZWNlaXZlZCIpOwoJCX0KCQlpZiAoIGRhdGFbcGFja2V0X29mZnNldCsxXSAmIEZURElfUlNfUEUgKSB7CgkJCWVycm9yX2ZsYWcgPSBUVFlfUEFSSVRZOwoJCQlkYmcoIlBBUklUWSBlcnJvciIpOwoJCX0KCQlpZiAoIGRhdGFbcGFja2V0X29mZnNldCsxXSAmIEZURElfUlNfRkUgKSB7CgkJCWVycm9yX2ZsYWcgPSBUVFlfRlJBTUU7CgkJCWRiZygiRlJBTUlORyBlcnJvciIpOwoJCX0KCQlpZiAobGVuZ3RoID4gMCkgewoJCQlmb3IgKGkgPSAyOyBpIDwgbGVuZ3RoKzI7IGkrKykgewoJCQkJLyogTm90ZSB0aGF0IHRoZSBlcnJvciBmbGFnIGlzIGR1cGxpY2F0ZWQgZm9yCgkJCQkgICBldmVyeSBjaGFyYWN0ZXIgcmVjZWl2ZWQgc2luY2Ugd2UgZG9uJ3Qga25vdwoJCQkJICAgd2hpY2ggY2hhcmFjdGVyIGl0IGFwcGxpZWQgdG8gKi8KCQkJCXR0eV9pbnNlcnRfZmxpcF9jaGFyKHR0eSwgZGF0YVtwYWNrZXRfb2Zmc2V0K2ldLCBlcnJvcl9mbGFnKTsKCQkJfQoJCQluZWVkX2ZsaXAgPSAxOwoJCX0KCiNpZmRlZiBOT1RfQ09SUkVDVF9CVVRfS0VFUElOR19JVF9GT1JfTk9XCgkJLyogaWYgYSBwYXJpdHkgZXJyb3IgaXMgZGV0ZWN0ZWQgeW91IGdldCBzdGF0dXMgcGFja2V0cyBmb3JldmVyCgkJICAgdW50aWwgYSBjaGFyYWN0ZXIgaXMgc2VudCB3aXRob3V0IGEgcGFyaXR5IGVycm9yLgoJCSAgIFRoaXMgZG9lc24ndCB3b3JrIHdlbGwgc2luY2UgdGhlIGFwcGxpY2F0aW9uIHJlY2VpdmVzIGEgbmV2ZXIKCQkgICBlbmRpbmcgc3RyZWFtIG9mIGJhZCBkYXRhIC0gZXZlbiB0aG91Z2ggbmV3IGRhdGEgaGFzbid0IGJlZW4gc2VudC4KCQkgICBUaGVyZWZvcmUgSSAoYmlsbCkgaGF2ZSB0YWtlbiB0aGlzIG91dC4KCQkgICBIb3dldmVyIC0gdGhpcyBtaWdodCBtYWtlIHNlbnNlIGZvciBmcmFtaW5nIGVycm9ycyBhbmQgc28gb24KCQkgICBzbyBJIGFtIGxlYXZpbmcgdGhlIGNvZGUgaW4gZm9yIG5vdy4KCQkqLwoJCWVsc2UgewoJCQlpZiAoZXJyb3JfZmxhZyAhPSBUVFlfTk9STUFMKXsKCQkJCWRiZygiZXJyb3JfZmxhZyBpcyBub3Qgbm9ybWFsIik7CgkJCQkvKiBJbiB0aGlzIGNhc2UgaXQgaXMganVzdCBzdGF0dXMgLSBpZiB0aGF0IGlzIGFuIGVycm9yIHNlbmQgYSBiYWQgY2hhcmFjdGVyICovCgkJCQlpZih0dHktPmZsaXAuY291bnQgPj0gVFRZX0ZMSVBCVUZfU0laRSkgewoJCQkJCXR0eV9mbGlwX2J1ZmZlcl9wdXNoKHR0eSk7CgkJCQl9CgkJCQl0dHlfaW5zZXJ0X2ZsaXBfY2hhcih0dHksIDB4ZmYsIGVycm9yX2ZsYWcpOwoJCQkJbmVlZF9mbGlwID0gMTsKCQkJfQoJCX0KI2VuZGlmCgl9IC8qICJmb3IocGFja2V0X29mZnNldD0wLi4uIiAqLwoKCS8qIExvdyBsYXRlbmN5ICovCglpZiAobmVlZF9mbGlwKSB7CgkJdHR5X2ZsaXBfYnVmZmVyX3B1c2godHR5KTsKCX0KCglpZiAocGFja2V0X29mZnNldCA8IHVyYi0+YWN0dWFsX2xlbmd0aCkgewoJCS8qIG5vdCBjb21wbGV0ZWx5IHByb2Nlc3NlZCAtIHJlY29yZCBwcm9ncmVzcyAqLwoJCXByaXYtPnJ4X3Byb2Nlc3NlZCA9IHBhY2tldF9vZmZzZXQ7CgkJZGJnKCIlcyAtIGluY29tcGxldGUsICVkIGJ5dGVzIHByb2Nlc3NlZCwgJWQgcmVtYWluIiwKCQkJCV9fRlVOQ1RJT05fXywgcGFja2V0X29mZnNldCwKCQkJCXVyYi0+YWN0dWFsX2xlbmd0aCAtIHBhY2tldF9vZmZzZXQpOwoJCS8qIGNoZWNrIGlmIHdlIHdlcmUgdGhyb3R0bGVkIHdoaWxlIHByb2Nlc3NpbmcgKi8KCQlzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwoJCWlmIChwcml2LT5yeF9mbGFncyAmIFRIUk9UVExFRCkgewoJCQlwcml2LT5yeF9mbGFncyB8PSBBQ1RVQUxMWV9USFJPVFRMRUQ7CgkJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnByaXYtPnJ4X2xvY2ssIGZsYWdzKTsKCQkJZGJnKCIlcyAtIGRlZmVycmluZyByZW1haW5kZXIgdW50aWwgdW50aHJvdHRsZWQiLAoJCQkJCV9fRlVOQ1RJT05fXyk7CgkJCXJldHVybjsKCQl9CgkJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwoJCS8qIGlmIHRoZSBwb3J0IGlzIGNsb3NlZCBzdG9wIHRyeWluZyB0byByZWFkICovCgkJaWYgKHBvcnQtPm9wZW5fY291bnQgPiAwKXsKCQkJLyogZGVsYXkgcHJvY2Vzc2luZyBvZiByZW1haW5kZXIgKi8KCQkJc2NoZWR1bGVfZGVsYXllZF93b3JrKCZwcml2LT5yeF93b3JrLCAxKTsKCQl9IGVsc2UgewoJCQlkYmcoIiVzIC0gcG9ydCBpcyBjbG9zZWQiLCBfX0ZVTkNUSU9OX18pOwoJCX0KCQlyZXR1cm47Cgl9CgoJLyogdXJiIGlzIGNvbXBsZXRlbHkgcHJvY2Vzc2VkICovCglwcml2LT5yeF9wcm9jZXNzZWQgPSAwOwoKCS8qIGlmIHRoZSBwb3J0IGlzIGNsb3NlZCBzdG9wIHRyeWluZyB0byByZWFkICovCglpZiAocG9ydC0+b3Blbl9jb3VudCA+IDApewoJCS8qIENvbnRpbnVlIHRyeWluZyB0byBhbHdheXMgcmVhZCAgKi8KCQl1c2JfZmlsbF9idWxrX3VyYihwb3J0LT5yZWFkX3VyYiwgcG9ydC0+c2VyaWFsLT5kZXYsCgkJCSAgICAgIHVzYl9yY3ZidWxrcGlwZShwb3J0LT5zZXJpYWwtPmRldiwgcG9ydC0+YnVsa19pbl9lbmRwb2ludEFkZHJlc3MpLAoJCQkgICAgICBwb3J0LT5yZWFkX3VyYi0+dHJhbnNmZXJfYnVmZmVyLCBwb3J0LT5yZWFkX3VyYi0+dHJhbnNmZXJfYnVmZmVyX2xlbmd0aCwKCQkJICAgICAgZnRkaV9yZWFkX2J1bGtfY2FsbGJhY2ssIHBvcnQpOwoKCQlyZXN1bHQgPSB1c2Jfc3VibWl0X3VyYihwb3J0LT5yZWFkX3VyYiwgR0ZQX0FUT01JQyk7CgkJaWYgKHJlc3VsdCkKCQkJZXJyKCIlcyAtIGZhaWxlZCByZXN1Ym1pdHRpbmcgcmVhZCB1cmIsIGVycm9yICVkIiwgX19GVU5DVElPTl9fLCByZXN1bHQpOwoJfQoKCXJldHVybjsKfSAvKiBmdGRpX3Byb2Nlc3NfcmVhZCAqLwoKCnN0YXRpYyB2b2lkIGZ0ZGlfYnJlYWtfY3RsKCBzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBpbnQgYnJlYWtfc3RhdGUgKQp7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJX191MTYgdXJiX3ZhbHVlID0gMDsKCWNoYXIgYnVmWzFdOwoKCS8qIGJyZWFrX3N0YXRlID0gLTEgdG8gdHVybiBvbiBicmVhaywgYW5kIDAgdG8gdHVybiBvZmYgYnJlYWsgKi8KCS8qIHNlZSBkcml2ZXJzL2NoYXIvdHR5X2lvLmMgdG8gc2VlIGl0IHVzZWQgKi8KCS8qIGxhc3Rfc2V0X2RhdGFfdXJiX3ZhbHVlIE5FVkVSIGhhcyB0aGUgYnJlYWsgYml0IHNldCBpbiBpdCAqLwoKCWlmIChicmVha19zdGF0ZSkgewoJCXVyYl92YWx1ZSA9IHByaXYtPmxhc3Rfc2V0X2RhdGFfdXJiX3ZhbHVlIHwgRlRESV9TSU9fU0VUX0JSRUFLOwoJfSBlbHNlIHsKCQl1cmJfdmFsdWUgPSBwcml2LT5sYXN0X3NldF9kYXRhX3VyYl92YWx1ZTsKCX0KCgoJaWYgKHVzYl9jb250cm9sX21zZyhwb3J0LT5zZXJpYWwtPmRldiwgdXNiX3NuZGN0cmxwaXBlKHBvcnQtPnNlcmlhbC0+ZGV2LCAwKSwKCQkJICAgIEZURElfU0lPX1NFVF9EQVRBX1JFUVVFU1QsCgkJCSAgICBGVERJX1NJT19TRVRfREFUQV9SRVFVRVNUX1RZUEUsCgkJCSAgICB1cmJfdmFsdWUgLCBwcml2LT5pbnRlcmZhY2UsCgkJCSAgICBidWYsIDAsIFdEUl9USU1FT1VUKSA8IDApIHsKCQllcnIoIiVzIEZBSUxFRCB0byBlbmFibGUvZGlzYWJsZSBicmVhayBzdGF0ZSAoc3RhdGUgd2FzICVkKSIsIF9fRlVOQ1RJT05fXyxicmVha19zdGF0ZSk7Cgl9CgoJZGJnKCIlcyBicmVhayBzdGF0ZSBpcyAlZCAtIHVyYiBpcyAlZCIsIF9fRlVOQ1RJT05fXyxicmVha19zdGF0ZSwgdXJiX3ZhbHVlKTsKCn0KCgovKiBvbGRfdGVybWlvcyBjb250YWlucyB0aGUgb3JpZ2luYWwgdGVybWlvcyBzZXR0aW5ncyBhbmQgdHR5LT50ZXJtaW9zIGNvbnRhaW5zCiAqIHRoZSBuZXcgc2V0dGluZyB0byBiZSB1c2VkCiAqIFdBUk5JTkc6IHNldF90ZXJtaW9zIGNhbGxzIHRoaXMgd2l0aCBvbGRfdGVybWlvcyBpbiBrZXJuZWwgc3BhY2UKICovCgpzdGF0aWMgdm9pZCBmdGRpX3NldF90ZXJtaW9zIChzdHJ1Y3QgdXNiX3NlcmlhbF9wb3J0ICpwb3J0LCBzdHJ1Y3QgdGVybWlvcyAqb2xkX3Rlcm1pb3MpCnsgLyogZnRkaV90ZXJtaW9zICovCglzdHJ1Y3QgdXNiX2RldmljZSAqZGV2ID0gcG9ydC0+c2VyaWFsLT5kZXY7Cgl1bnNpZ25lZCBpbnQgY2ZsYWcgPSBwb3J0LT50dHktPnRlcm1pb3MtPmNfY2ZsYWc7CglzdHJ1Y3QgZnRkaV9wcml2YXRlICpwcml2ID0gdXNiX2dldF9zZXJpYWxfcG9ydF9kYXRhKHBvcnQpOwoJX191MTYgdXJiX3ZhbHVlOyAvKiB3aWxsIGhvbGQgdGhlIG5ldyBmbGFncyAqLwoJY2hhciBidWZbMV07IC8qIFBlcmhhcHMgSSBzaG91bGQgZHluYW1pY2FsbHkgYWxsb2MgdGhpcz8gKi8KCgkvLyBBZGRlZCBmb3IgeG9uL3hvZmYgc3VwcG9ydAoJdW5zaWduZWQgaW50IGlmbGFnID0gcG9ydC0+dHR5LT50ZXJtaW9zLT5jX2lmbGFnOwoJdW5zaWduZWQgY2hhciB2c3RvcDsKCXVuc2lnbmVkIGNoYXIgdnN0YXJ0OwoKCWRiZygiJXMiLCBfX0ZVTkNUSU9OX18pOwoKCS8qIEZvcmNlIGJhdWQgcmF0ZSBpZiB0aGlzIGRldmljZSByZXF1aXJlcyBpdCwgdW5sZXNzIGl0IGlzIHNldCB0byBCMC4gKi8KCWlmIChwcml2LT5mb3JjZV9iYXVkICYmICgocG9ydC0+dHR5LT50ZXJtaW9zLT5jX2NmbGFnICYgQ0JBVUQpICE9IEIwKSkgewoJCWRiZygiJXM6IGZvcmNpbmcgYmF1ZCByYXRlIGZvciB0aGlzIGRldmljZSIsIF9fRlVOQ1RJT05fXyk7CgkJcG9ydC0+dHR5LT50ZXJtaW9zLT5jX2NmbGFnICY9IH5DQkFVRDsKCQlwb3J0LT50dHktPnRlcm1pb3MtPmNfY2ZsYWcgfD0gcHJpdi0+Zm9yY2VfYmF1ZDsKCX0KCgkvKiBGb3JjZSBSVFMtQ1RTIGlmIHRoaXMgZGV2aWNlIHJlcXVpcmVzIGl0LiAqLwoJaWYgKHByaXYtPmZvcmNlX3J0c2N0cykgewoJCWRiZygiJXM6IGZvcmNpbmcgcnRzY3RzIGZvciB0aGlzIGRldmljZSIsIF9fRlVOQ1RJT05fXyk7CgkJcG9ydC0+dHR5LT50ZXJtaW9zLT5jX2NmbGFnIHw9IENSVFNDVFM7Cgl9CgoJY2ZsYWcgPSBwb3J0LT50dHktPnRlcm1pb3MtPmNfY2ZsYWc7CgoJLyogRklYTUUgLUZvciB0aGlzIGN1dCBJIGRvbid0IGNhcmUgaWYgdGhlIGxpbmUgaXMgcmVhbGx5IGNoYW5naW5nIG9yCgkgICBub3QgIC0gc28ganVzdCBkbyB0aGUgY2hhbmdlIHJlZ2FyZGxlc3MgIC0gc2hvdWxkIGJlIGFibGUgdG8KCSAgIGNvbXBhcmUgb2xkX3Rlcm1pb3MgYW5kIHR0eS0+dGVybWlvcyAqLwoJLyogTk9URSBUaGVzZSByb3V0aW5lcyBjYW4gZ2V0IGludGVycnVwdGVkIGJ5CgkgICBmdGRpX3Npb19yZWFkX2J1bGtfY2FsbGJhY2sgIC0gbmVlZCB0byBleGFtaW5lIHdoYXQgdGhpcwogICAgICAgICAgIG1lYW5zIC0gZG9uJ3Qgc2VlIGFueSBwcm9ibGVtcyB5ZXQgKi8KCgkvKiBTZXQgbnVtYmVyIG9mIGRhdGEgYml0cywgcGFyaXR5LCBzdG9wIGJpdHMgKi8KCgl1cmJfdmFsdWUgPSAwOwoJdXJiX3ZhbHVlIHw9IChjZmxhZyAmIENTVE9QQiA/IEZURElfU0lPX1NFVF9EQVRBX1NUT1BfQklUU18yIDoKCQkgICAgICBGVERJX1NJT19TRVRfREFUQV9TVE9QX0JJVFNfMSk7Cgl1cmJfdmFsdWUgfD0gKGNmbGFnICYgUEFSRU5CID8KCQkgICAgICAoY2ZsYWcgJiBQQVJPREQgPyBGVERJX1NJT19TRVRfREFUQV9QQVJJVFlfT0REIDoKCQkgICAgICAgRlRESV9TSU9fU0VUX0RBVEFfUEFSSVRZX0VWRU4pIDoKCQkgICAgICBGVERJX1NJT19TRVRfREFUQV9QQVJJVFlfTk9ORSk7CglpZiAoY2ZsYWcgJiBDU0laRSkgewoJCXN3aXRjaCAoY2ZsYWcgJiBDU0laRSkgewoJCWNhc2UgQ1M1OiB1cmJfdmFsdWUgfD0gNTsgZGJnKCJTZXR0aW5nIENTNSIpOyBicmVhazsKCQljYXNlIENTNjogdXJiX3ZhbHVlIHw9IDY7IGRiZygiU2V0dGluZyBDUzYiKTsgYnJlYWs7CgkJY2FzZSBDUzc6IHVyYl92YWx1ZSB8PSA3OyBkYmcoIlNldHRpbmcgQ1M3Iik7IGJyZWFrOwoJCWNhc2UgQ1M4OiB1cmJfdmFsdWUgfD0gODsgZGJnKCJTZXR0aW5nIENTOCIpOyBicmVhazsKCQlkZWZhdWx0OgoJCQllcnIoIkNTSVpFIHdhcyBzZXQgYnV0IG5vdCBDUzUtQ1M4Iik7CgkJfQoJfQoKCS8qIFRoaXMgaXMgbmVlZGVkIGJ5IHRoZSBicmVhayBjb21tYW5kIHNpbmNlIGl0IHVzZXMgdGhlIHNhbWUgY29tbWFuZCAtIGJ1dCBpcwoJICogIG9yJ2VkIHdpdGggdGhpcyB2YWx1ZSAgKi8KCXByaXYtPmxhc3Rfc2V0X2RhdGFfdXJiX3ZhbHVlID0gdXJiX3ZhbHVlOwoKCWlmICh1c2JfY29udHJvbF9tc2coZGV2LCB1c2Jfc25kY3RybHBpcGUoZGV2LCAwKSwKCQkJICAgIEZURElfU0lPX1NFVF9EQVRBX1JFUVVFU1QsCgkJCSAgICBGVERJX1NJT19TRVRfREFUQV9SRVFVRVNUX1RZUEUsCgkJCSAgICB1cmJfdmFsdWUgLCBwcml2LT5pbnRlcmZhY2UsCgkJCSAgICBidWYsIDAsIFdEUl9TSE9SVF9USU1FT1VUKSA8IDApIHsKCQllcnIoIiVzIEZBSUxFRCB0byBzZXQgZGF0YWJpdHMvc3RvcGJpdHMvcGFyaXR5IiwgX19GVU5DVElPTl9fKTsKCX0KCgkvKiBOb3cgZG8gdGhlIGJhdWRyYXRlICovCglpZiAoKGNmbGFnICYgQ0JBVUQpID09IEIwICkgewoJCS8qIERpc2FibGUgZmxvdyBjb250cm9sICovCgkJaWYgKHVzYl9jb250cm9sX21zZyhkZXYsIHVzYl9zbmRjdHJscGlwZShkZXYsIDApLAoJCQkJICAgIEZURElfU0lPX1NFVF9GTE9XX0NUUkxfUkVRVUVTVCwKCQkJCSAgICBGVERJX1NJT19TRVRfRkxPV19DVFJMX1JFUVVFU1RfVFlQRSwKCQkJCSAgICAwLCBwcml2LT5pbnRlcmZhY2UsCgkJCQkgICAgYnVmLCAwLCBXRFJfVElNRU9VVCkgPCAwKSB7CgkJCWVycigiJXMgZXJyb3IgZnJvbSBkaXNhYmxlIGZsb3djb250cm9sIHVyYiIsIF9fRlVOQ1RJT05fXyk7CgkJfQoJCS8qIERyb3AgUlRTIGFuZCBEVFIgKi8KCQljbGVhcl9tY3RybChwb3J0LCBUSU9DTV9EVFIgfCBUSU9DTV9SVFMpOwoJfSBlbHNlIHsKCQkvKiBzZXQgdGhlIGJhdWRyYXRlIGRldGVybWluZWQgYmVmb3JlICovCgkJaWYgKGNoYW5nZV9zcGVlZChwb3J0KSkgewoJCQllcnIoIiVzIHVyYiBmYWlsZWQgdG8gc2V0IGJhdWRyYXRlIiwgX19GVU5DVElPTl9fKTsKCQl9CgkJLyogRW5zdXJlIFJUUyBhbmQgRFRSIGFyZSByYWlzZWQgd2hlbiBiYXVkcmF0ZSBjaGFuZ2VkIGZyb20gMCAqLwoJCWlmICghb2xkX3Rlcm1pb3MgfHwgKG9sZF90ZXJtaW9zLT5jX2NmbGFnICYgQ0JBVUQpID09IEIwKSB7CgkJCXNldF9tY3RybChwb3J0LCBUSU9DTV9EVFIgfCBUSU9DTV9SVFMpOwoJCX0KCX0KCgkvKiBTZXQgZmxvdyBjb250cm9sICovCgkvKiBOb3RlIGRldmljZSBhbHNvIHN1cHBvcnRzIERUUi9DRCAodWdoKSBhbmQgWG9uL1hvZmYgaW4gaGFyZHdhcmUgKi8KCWlmIChjZmxhZyAmIENSVFNDVFMpIHsKCQlkYmcoIiVzIFNldHRpbmcgdG8gQ1JUU0NUUyBmbG93IGNvbnRyb2wiLCBfX0ZVTkNUSU9OX18pOwoJCWlmICh1c2JfY29udHJvbF9tc2coZGV2LAoJCQkJICAgIHVzYl9zbmRjdHJscGlwZShkZXYsIDApLAoJCQkJICAgIEZURElfU0lPX1NFVF9GTE9XX0NUUkxfUkVRVUVTVCwKCQkJCSAgICBGVERJX1NJT19TRVRfRkxPV19DVFJMX1JFUVVFU1RfVFlQRSwKCQkJCSAgICAwICwgKEZURElfU0lPX1JUU19DVFNfSFMgfCBwcml2LT5pbnRlcmZhY2UpLAoJCQkJICAgIGJ1ZiwgMCwgV0RSX1RJTUVPVVQpIDwgMCkgewoJCQllcnIoInVyYiBmYWlsZWQgdG8gc2V0IHRvIHJ0cy9jdHMgZmxvdyBjb250cm9sIik7CgkJfQoKCX0gZWxzZSB7CgkJLyoKCQkgKiBYb24vWG9mZiBjb2RlCgkJICoKCQkgKiBDaGVjayB0aGUgSVhPRkYgc3RhdHVzIGluIHRoZSBpZmxhZyBjb21wb25lbnQgb2YgdGhlIHRlcm1pb3Mgc3RydWN0dXJlCgkJICogaWYgSVhPRkYgaXMgbm90IHNldCwgdGhlIHByZS14b24veG9mZiBjb2RlIGlzIGV4ZWN1dGVkLgoJCSovCgkJaWYgKGlmbGFnICYgSVhPRkYpIHsKCQkJZGJnKCIlcyAgcmVxdWVzdCB0byBlbmFibGUgeG9ueG9mZiBpZmxhZz0lMDR4IixfX0ZVTkNUSU9OX18saWZsYWcpOwoJCQkvLyBUcnkgdG8gZW5hYmxlIHRoZSBYT04vWE9GRiBvbiB0aGUgZnRkaV9zaW8KCQkJLy8gU2V0IHRoZSB2c3RhcnQgYW5kIHZzdG9wIC0tIGNvdWxkIGhhdmUgYmVlbiBkb25lIHVwIGFib3ZlIHdoZXJlCgkJCS8vIGEgbG90IG9mIG90aGVyIGRlcmVmZXJlbmNpbmcgaXMgZG9uZSBidXQgdGhhdCB3b3VsZCBiZSB2ZXJ5CgkJCS8vIGluZWZmaWNpZW50IGFzIHZzdGFydCBhbmQgdnN0b3AgYXJlIG5vdCBhbHdheXMgbmVlZGVkCgkJCXZzdGFydD1wb3J0LT50dHktPnRlcm1pb3MtPmNfY2NbVlNUQVJUXTsKCQkJdnN0b3A9cG9ydC0+dHR5LT50ZXJtaW9zLT5jX2NjW1ZTVE9QXTsKCQkJdXJiX3ZhbHVlPSh2c3RvcCA8PCA4KSB8ICh2c3RhcnQpOwoKCQkJaWYgKHVzYl9jb250cm9sX21zZyhkZXYsCgkJCQkJICAgIHVzYl9zbmRjdHJscGlwZShkZXYsIDApLAoJCQkJCSAgICBGVERJX1NJT19TRVRfRkxPV19DVFJMX1JFUVVFU1QsCgkJCQkJICAgIEZURElfU0lPX1NFVF9GTE9XX0NUUkxfUkVRVUVTVF9UWVBFLAoJCQkJCSAgICB1cmJfdmFsdWUgLCAoRlRESV9TSU9fWE9OX1hPRkZfSFMKCQkJCQkJCSB8IHByaXYtPmludGVyZmFjZSksCgkJCQkJICAgIGJ1ZiwgMCwgV0RSX1RJTUVPVVQpIDwgMCkgewoJCQkJZXJyKCJ1cmIgZmFpbGVkIHRvIHNldCB0byB4b24veG9mZiBmbG93IGNvbnRyb2wiKTsKCQkJfQoJCX0gZWxzZSB7CgkJCS8qIGVsc2UgY2xhdXNlIHRvIG9ubHkgcnVuIGlmIGNmYWcgISBDUlRTQ1RTIGFuZCBpZmxhZyAhIFhPRkYgKi8KCQkJLyogQ0hFQ0tNRSBBc3N1bWluZyBYT04vWE9GRiBoYW5kbGVkIGJ5IHR0eSBzdGFjayAtIG5vdCBieSBkZXZpY2UgKi8KCQkJZGJnKCIlcyBUdXJuaW5nIG9mZiBoYXJkd2FyZSBmbG93IGNvbnRyb2wiLCBfX0ZVTkNUSU9OX18pOwoJCQlpZiAodXNiX2NvbnRyb2xfbXNnKGRldiwKCQkJCQkgICAgdXNiX3NuZGN0cmxwaXBlKGRldiwgMCksCgkJCQkJICAgIEZURElfU0lPX1NFVF9GTE9XX0NUUkxfUkVRVUVTVCwKCQkJCQkgICAgRlRESV9TSU9fU0VUX0ZMT1dfQ1RSTF9SRVFVRVNUX1RZUEUsCgkJCQkJICAgIDAsIHByaXYtPmludGVyZmFjZSwKCQkJCQkgICAgYnVmLCAwLCBXRFJfVElNRU9VVCkgPCAwKSB7CgkJCQllcnIoInVyYiBmYWlsZWQgdG8gY2xlYXIgZmxvdyBjb250cm9sIik7CgkJCX0KCQl9CgoJfQoJcmV0dXJuOwp9IC8qIGZ0ZGlfdGVybWlvcyAqLwoKCnN0YXRpYyBpbnQgZnRkaV90aW9jbWdldCAoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwgc3RydWN0IGZpbGUgKmZpbGUpCnsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Cgl1bnNpZ25lZCBjaGFyIGJ1ZlsyXTsKCWludCByZXQ7CgoJZGJnKCIlcyBUSU9DTUdFVCIsIF9fRlVOQ1RJT05fXyk7Cglzd2l0Y2ggKHByaXYtPmNoaXBfdHlwZSkgewoJY2FzZSBTSU86CgkJLyogUmVxdWVzdCB0aGUgc3RhdHVzIGZyb20gdGhlIGRldmljZSAqLwoJCWlmICgocmV0ID0gdXNiX2NvbnRyb2xfbXNnKHBvcnQtPnNlcmlhbC0+ZGV2LAoJCQkJCSAgIHVzYl9yY3ZjdHJscGlwZShwb3J0LT5zZXJpYWwtPmRldiwgMCksCgkJCQkJICAgRlRESV9TSU9fR0VUX01PREVNX1NUQVRVU19SRVFVRVNULAoJCQkJCSAgIEZURElfU0lPX0dFVF9NT0RFTV9TVEFUVVNfUkVRVUVTVF9UWVBFLAoJCQkJCSAgIDAsIDAsCgkJCQkJICAgYnVmLCAxLCBXRFJfVElNRU9VVCkpIDwgMCApIHsKCQkJZXJyKCIlcyBDb3VsZCBub3QgZ2V0IG1vZGVtIHN0YXR1cyBvZiBkZXZpY2UgLSBlcnI6ICVkIiwgX19GVU5DVElPTl9fLAoJCQkgICAgcmV0KTsKCQkJcmV0dXJuKHJldCk7CgkJfQoJCWJyZWFrOwoJY2FzZSBGVDhVMjMyQU06CgljYXNlIEZUMjMyQk06CgljYXNlIEZUMjIzMkM6CgkJLyogdGhlIDhVMjMyQU0gcmV0dXJucyBhIHR3byBieXRlIHZhbHVlICh0aGUgc2lvIGlzIGEgMSBieXRlIHZhbHVlKSAtIGluIHRoZSBzYW1lCgkJICAgZm9ybWF0IGFzIHRoZSBkYXRhIHJldHVybmVkIGZyb20gdGhlIGluIHBvaW50ICovCgkJaWYgKChyZXQgPSB1c2JfY29udHJvbF9tc2cocG9ydC0+c2VyaWFsLT5kZXYsCgkJCQkJICAgdXNiX3JjdmN0cmxwaXBlKHBvcnQtPnNlcmlhbC0+ZGV2LCAwKSwKCQkJCQkgICBGVERJX1NJT19HRVRfTU9ERU1fU1RBVFVTX1JFUVVFU1QsCgkJCQkJICAgRlRESV9TSU9fR0VUX01PREVNX1NUQVRVU19SRVFVRVNUX1RZUEUsCgkJCQkJICAgMCwgcHJpdi0+aW50ZXJmYWNlLAoJCQkJCSAgIGJ1ZiwgMiwgV0RSX1RJTUVPVVQpKSA8IDAgKSB7CgkJCWVycigiJXMgQ291bGQgbm90IGdldCBtb2RlbSBzdGF0dXMgb2YgZGV2aWNlIC0gZXJyOiAlZCIsIF9fRlVOQ1RJT05fXywKCQkJICAgIHJldCk7CgkJCXJldHVybihyZXQpOwoJCX0KCQlicmVhazsKCWRlZmF1bHQ6CgkJcmV0dXJuIC1FRkFVTFQ7CgkJYnJlYWs7Cgl9CgoJcmV0dXJuICAoYnVmWzBdICYgRlRESV9TSU9fRFNSX01BU0sgPyBUSU9DTV9EU1IgOiAwKSB8CgkJKGJ1ZlswXSAmIEZURElfU0lPX0NUU19NQVNLID8gVElPQ01fQ1RTIDogMCkgfAoJCShidWZbMF0gICYgRlRESV9TSU9fUklfTUFTSyAgPyBUSU9DTV9SSSAgOiAwKSB8CgkJKGJ1ZlswXSAgJiBGVERJX1NJT19STFNEX01BU0sgPyBUSU9DTV9DRCAgOiAwKSB8CgkJcHJpdi0+bGFzdF9kdHJfcnRzOwp9CgpzdGF0aWMgaW50IGZ0ZGlfdGlvY21zZXQoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwgc3RydWN0IGZpbGUgKiBmaWxlLCB1bnNpZ25lZCBpbnQgc2V0LCB1bnNpZ25lZCBpbnQgY2xlYXIpCnsKCWRiZygiJXMgVElPQ01TRVQiLCBfX0ZVTkNUSU9OX18pOwoJcmV0dXJuIHVwZGF0ZV9tY3RybChwb3J0LCBzZXQsIGNsZWFyKTsKfQoKCnN0YXRpYyBpbnQgZnRkaV9pb2N0bCAoc3RydWN0IHVzYl9zZXJpYWxfcG9ydCAqcG9ydCwgc3RydWN0IGZpbGUgKiBmaWxlLCB1bnNpZ25lZCBpbnQgY21kLCB1bnNpZ25lZCBsb25nIGFyZykKewoJc3RydWN0IGZ0ZGlfcHJpdmF0ZSAqcHJpdiA9IHVzYl9nZXRfc2VyaWFsX3BvcnRfZGF0YShwb3J0KTsKCglkYmcoIiVzIGNtZCAweCUwNHgiLCBfX0ZVTkNUSU9OX18sIGNtZCk7CgoJLyogQmFzZWQgb24gY29kZSBmcm9tIGFjbS5jIGFuZCBvdGhlcnMgKi8KCXN3aXRjaCAoY21kKSB7CgoJY2FzZSBUSU9DR1NFUklBTDogLyogZ2V0cyBzZXJpYWwgcG9ydCBkYXRhICovCgkJcmV0dXJuIGdldF9zZXJpYWxfaW5mbyhwb3J0LCAoc3RydWN0IHNlcmlhbF9zdHJ1Y3QgX191c2VyICopIGFyZyk7CgoJY2FzZSBUSU9DU1NFUklBTDogLyogc2V0cyBzZXJpYWwgcG9ydCBkYXRhICovCgkJcmV0dXJuIHNldF9zZXJpYWxfaW5mbyhwb3J0LCAoc3RydWN0IHNlcmlhbF9zdHJ1Y3QgX191c2VyICopIGFyZyk7CgoJLyoKCSAqIFdhaXQgZm9yIGFueSBvZiB0aGUgNCBtb2RlbSBpbnB1dHMgKERDRCxSSSxEU1IsQ1RTKSB0byBjaGFuZ2UKCSAqIC0gbWFzayBwYXNzZWQgaW4gYXJnIGZvciBsaW5lcyBvZiBpbnRlcmVzdAoJICogICAodXNlIHwnZWQgVElPQ01fUk5HL0RTUi9DRC9DVFMgZm9yIG1hc2tpbmcpCgkgKiBDYWxsZXIgc2hvdWxkIHVzZSBUSU9DR0lDT1VOVCB0byBzZWUgd2hpY2ggb25lIGl0IHdhcy4KCSAqCgkgKiBUaGlzIGNvZGUgaXMgYm9ycm93ZWQgZnJvbSBsaW51eC9kcml2ZXJzL2NoYXIvc2VyaWFsLmMKCSAqLwoJY2FzZSBUSU9DTUlXQUlUOgoJCXdoaWxlIChwcml2ICE9IE5VTEwpIHsKCQkJaW50ZXJydXB0aWJsZV9zbGVlcF9vbigmcHJpdi0+ZGVsdGFfbXNyX3dhaXQpOwoJCQkvKiBzZWUgaWYgYSBzaWduYWwgZGlkIGl0ICovCgkJCWlmIChzaWduYWxfcGVuZGluZyhjdXJyZW50KSkKCQkJCXJldHVybiAtRVJFU1RBUlRTWVM7CgkJCWVsc2UgewoJCQkJY2hhciBkaWZmID0gcHJpdi0+ZGlmZl9zdGF0dXM7CgoJCQkJaWYgKGRpZmYgPT0gMCkgewoJCQkJCXJldHVybiAtRUlPOyAvKiBubyBjaGFuZ2UgPT4gZXJyb3IgKi8KCQkJCX0KCgkJCQkvKiBDb25zdW1lIGFsbCBldmVudHMgKi8KCQkJCXByaXYtPmRpZmZfc3RhdHVzID0gMDsKCgkJCQkvKiBSZXR1cm4gMCBpZiBjYWxsZXIgd2FudGVkIHRvIGtub3cgYWJvdXQgdGhlc2UgYml0cyAqLwoJCQkJaWYgKCAoKGFyZyAmIFRJT0NNX1JORykgJiYgKGRpZmYgJiBGVERJX1JTMF9SSSkpIHx8CgkJCQkgICAgICgoYXJnICYgVElPQ01fRFNSKSAmJiAoZGlmZiAmIEZURElfUlMwX0RTUikpIHx8CgkJCQkgICAgICgoYXJnICYgVElPQ01fQ0QpICAmJiAoZGlmZiAmIEZURElfUlMwX1JMU0QpKSB8fAoJCQkJICAgICAoKGFyZyAmIFRJT0NNX0NUUykgJiYgKGRpZmYgJiBGVERJX1JTMF9DVFMpKSApIHsKCQkJCQlyZXR1cm4gMDsKCQkJCX0KCQkJCS8qCgkJCQkgKiBPdGhlcndpc2UgY2FsbGVyIGNhbid0IGNhcmUgbGVzcyBhYm91dCB3aGF0IGhhcHBlbmVkLAoJCQkJICogYW5kIHNvIHdlIGNvbnRpbnVlIHRvIHdhaXQgZm9yIG1vcmUgZXZlbnRzLgoJCQkJICovCgkJCX0KCQl9CgkJcmV0dXJuKDApOwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlicmVhazsKCgl9CgoKCS8qIFRoaXMgaXMgbm90IG5lY2Vzc2FyaWx5IGFuIGVycm9yIC0gdHVybnMgb3V0IHRoZSBoaWdoZXIgbGF5ZXJzIHdpbGwgZG8KCSAqICBzb21lIGlvY3RscyBpdHNlbGYgKHNlZSBjb21tZW50IGFib3ZlKQoJICovCglkYmcoIiVzIGFyZyBub3Qgc3VwcG9ydGVkIC0gaXQgd2FzIDB4JTA0eCAtIGNoZWNrIC91c3IvaW5jbHVkZS9hc20vaW9jdGxzLmgiLCBfX0ZVTkNUSU9OX18sIGNtZCk7CgoJcmV0dXJuKC1FTk9JT0NUTENNRCk7Cn0gLyogZnRkaV9pb2N0bCAqLwoKCnN0YXRpYyB2b2lkIGZ0ZGlfdGhyb3R0bGUgKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQpCnsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCWRiZygiJXMgLSBwb3J0ICVkIiwgX19GVU5DVElPTl9fLCBwb3J0LT5udW1iZXIpOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7Cglwcml2LT5yeF9mbGFncyB8PSBUSFJPVFRMRUQ7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7Cn0KCgpzdGF0aWMgdm9pZCBmdGRpX3VudGhyb3R0bGUgKHN0cnVjdCB1c2Jfc2VyaWFsX3BvcnQgKnBvcnQpCnsKCXN0cnVjdCBmdGRpX3ByaXZhdGUgKnByaXYgPSB1c2JfZ2V0X3NlcmlhbF9wb3J0X2RhdGEocG9ydCk7CglpbnQgYWN0dWFsbHlfdGhyb3R0bGVkOwoJdW5zaWduZWQgbG9uZyBmbGFnczsKCglkYmcoIiVzIC0gcG9ydCAlZCIsIF9fRlVOQ1RJT05fXywgcG9ydC0+bnVtYmVyKTsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcHJpdi0+cnhfbG9jaywgZmxhZ3MpOwoJYWN0dWFsbHlfdGhyb3R0bGVkID0gcHJpdi0+cnhfZmxhZ3MgJiBBQ1RVQUxMWV9USFJPVFRMRUQ7Cglwcml2LT5yeF9mbGFncyAmPSB+KFRIUk9UVExFRCB8IEFDVFVBTExZX1RIUk9UVExFRCk7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwcml2LT5yeF9sb2NrLCBmbGFncyk7CgoJaWYgKGFjdHVhbGx5X3Rocm90dGxlZCkKCQlzY2hlZHVsZV9kZWxheWVkX3dvcmsoJnByaXYtPnJ4X3dvcmssIDApOwp9CgpzdGF0aWMgaW50IF9faW5pdCBmdGRpX2luaXQgKHZvaWQpCnsKCWludCByZXR2YWw7CgoJZGJnKCIlcyIsIF9fRlVOQ1RJT05fXyk7CglpZiAodmVuZG9yID4gMCAmJiBwcm9kdWN0ID4gMCkgewoJCS8qIEFkZCB1c2VyIHNwZWNpZmllZCBWSUQvUElEIHRvIHJlc2VydmVkIGVsZW1lbnQgb2YgdGFibGUuICovCgkJaW50IGk7CgkJZm9yIChpID0gMDsgaWRfdGFibGVfY29tYmluZWRbaV0uaWRWZW5kb3I7IGkrKykKCQkJOwoJCWlkX3RhYmxlX2NvbWJpbmVkW2ldLm1hdGNoX2ZsYWdzID0gVVNCX0RFVklDRV9JRF9NQVRDSF9ERVZJQ0U7CgkJaWRfdGFibGVfY29tYmluZWRbaV0uaWRWZW5kb3IgPSB2ZW5kb3I7CgkJaWRfdGFibGVfY29tYmluZWRbaV0uaWRQcm9kdWN0ID0gcHJvZHVjdDsKCX0KCXJldHZhbCA9IHVzYl9zZXJpYWxfcmVnaXN0ZXIoJmZ0ZGlfc2lvX2RldmljZSk7CglpZiAocmV0dmFsKQoJCWdvdG8gZmFpbGVkX3Npb19yZWdpc3RlcjsKCXJldHZhbCA9IHVzYl9yZWdpc3RlcigmZnRkaV9kcml2ZXIpOwoJaWYgKHJldHZhbCkKCQlnb3RvIGZhaWxlZF91c2JfcmVnaXN0ZXI7CgoJaW5mbyhEUklWRVJfVkVSU0lPTiAiOiIgRFJJVkVSX0RFU0MpOwoJcmV0dXJuIDA7CmZhaWxlZF91c2JfcmVnaXN0ZXI6Cgl1c2Jfc2VyaWFsX2RlcmVnaXN0ZXIoJmZ0ZGlfc2lvX2RldmljZSk7CmZhaWxlZF9zaW9fcmVnaXN0ZXI6CglyZXR1cm4gcmV0dmFsOwp9CgoKc3RhdGljIHZvaWQgX19leGl0IGZ0ZGlfZXhpdCAodm9pZCkKewoKCWRiZygiJXMiLCBfX0ZVTkNUSU9OX18pOwoKCXVzYl9kZXJlZ2lzdGVyICgmZnRkaV9kcml2ZXIpOwoJdXNiX3NlcmlhbF9kZXJlZ2lzdGVyICgmZnRkaV9zaW9fZGV2aWNlKTsKCn0KCgptb2R1bGVfaW5pdChmdGRpX2luaXQpOwptb2R1bGVfZXhpdChmdGRpX2V4aXQpOwoKTU9EVUxFX0FVVEhPUiggRFJJVkVSX0FVVEhPUiApOwpNT0RVTEVfREVTQ1JJUFRJT04oIERSSVZFUl9ERVNDICk7Ck1PRFVMRV9MSUNFTlNFKCJHUEwiKTsKCm1vZHVsZV9wYXJhbShkZWJ1ZywgYm9vbCwgU19JUlVHTyB8IFNfSVdVU1IpOwpNT0RVTEVfUEFSTV9ERVNDKGRlYnVnLCAiRGVidWcgZW5hYmxlZCBvciBub3QiKTsKbW9kdWxlX3BhcmFtKHZlbmRvciwgdXNob3J0LCAwKTsKTU9EVUxFX1BBUk1fREVTQyh2ZW5kb3IsICJVc2VyIHNwZWNpZmllZCB2ZW5kb3IgSUQgKGRlZmF1bHQ9IgoJCV9fTU9EVUxFX1NUUklORyhGVERJX1ZJRCkiKSIpOwptb2R1bGVfcGFyYW0ocHJvZHVjdCwgdXNob3J0LCAwKTsKTU9EVUxFX1BBUk1fREVTQyh2ZW5kb3IsICJVc2VyIHNwZWNpZmllZCBwcm9kdWN0IElEIik7Cgo=