LyogCiAqIE5DUiA1MzgwIGdlbmVyaWMgZHJpdmVyIHJvdXRpbmVzLiAgVGhlc2Ugc2hvdWxkIG1ha2UgaXQgKnRyaXZpYWwqCiAqIAl0byBpbXBsZW1lbnQgNTM4MCBTQ1NJIGRyaXZlcnMgdW5kZXIgTGludXggd2l0aCBhIG5vbi10cmFudG9yCiAqCWFyY2hpdGVjdHVyZS4KICoKICoJTm90ZSB0aGF0IHRoZXNlIHJvdXRpbmVzIGFsc28gd29yayB3aXRoIE5SNTNjNDAwIGZhbWlseSBjaGlwcy4KICoKICogQ29weXJpZ2h0IDE5OTMsIERyZXcgRWNraGFyZHQKICoJVmlzaW9uYXJ5IENvbXB1dGluZyAKICoJKFVuaXggYW5kIExpbnV4IGNvbnN1bHRpbmcgYW5kIGN1c3RvbSBwcm9ncmFtbWluZykKICogCWRyZXdAY29sb3JhZG8uZWR1CiAqCSsxICgzMDMpIDY2Ni01ODM2CiAqCiAqIERJU1RSSUJVVElPTiBSRUxFQVNFIDYuIAogKgogKiBGb3IgbW9yZSBpbmZvcm1hdGlvbiwgcGxlYXNlIGNvbnN1bHQgCiAqCiAqIE5DUiA1MzgwIEZhbWlseQogKiBTQ1NJIFByb3RvY29sIENvbnRyb2xsZXIKICogRGF0YWJvb2sKICoKICogTkNSIE1pY3JvZWxlY3Ryb25pY3MKICogMTYzNSBBZXJvcGxhemEgRHJpdmUKICogQ29sb3JhZG8gU3ByaW5ncywgQ08gODA5MTYKICogMSsgKDcxOSkgNTc4LTM0MDAKICogMSsgKDgwMCkgMzM0LTU0NTQKICovCgovKgogKiArK3JvbWFuOiBUbyBwb3J0IHRoZSA1MzgwIGRyaXZlciB0byB0aGUgQXRhcmksIEkgaGFkIHRvIGRvIHNvbWUgY2hhbmdlcyBpbgogKiB0aGlzIGZpbGUsIHRvbzoKICoKICogIC0gU29tZSBvZiB0aGUgZGVidWcgc3RhdGVtZW50cyB3ZXJlIGluY29ycmVjdCAodW5kZWZpbmVkIHZhcmlhYmxlcyBhbmQgdGhlCiAqICAgIGxpa2UpLiBJIGZpeGVkIHRoYXQuCiAqCiAqICAtIEluIGluZm9ybWF0aW9uX3RyYW5zZmVyKCksIEkgdGhpbmsgYSAjaWZkZWYgd2FzIHdyb25nLiBMb29raW5nIGF0IHRoZQogKiAgICBwb3NzaWJsZSBETUEgdHJhbnNmZXIgc2l6ZSBzaG91bGQgYWxzbyBoYXBwZW4gZm9yIFJFQUxfRE1BLiBJIGFkZGVkIHRoaXMKICogICAgaW4gdGhlICNpZiBzdGF0ZW1lbnQuCiAqCiAqICAtIFdoZW4gdXNpbmcgcmVhbCBETUEsIGluZm9ybWF0aW9uX3RyYW5zZmVyKCkgc2hvdWxkIHJldHVybiBpbiBhIERBVEFPVVQKICogICAgcGhhc2UgYWZ0ZXIgc3RhcnRpbmcgdGhlIERNQS4gSXQgaGFzIG5vdGhpbmcgbW9yZSB0byBkby4KICoKICogIC0gVGhlIGludGVycnVwdCBzZXJ2aWNlIHJvdXRpbmUgc2hvdWxkIHJ1biBtYWluIGFmdGVyIGVuZCBvZiBETUEsIHRvbyAobm90CiAqICAgIG9ubHkgYWZ0ZXIgUkVTRUxFQ1RJT04gaW50ZXJydXB0cykuIEFkZGl0aW9uYWxseSwgaXQgc2hvdWxkIF9ub3RfIHRlc3QKICogICAgZm9yIG1vcmUgaW50ZXJydXB0cyBhZnRlciBydW5uaW5nIG1haW4sIHNpbmNlIGEgRE1BIHByb2Nlc3MgbWF5IGhhdmUKICogICAgYmVlbiBzdGFydGVkIGFuZCBpbnRlcnJ1cHRzIGFyZSB0dXJuZWQgb24gbm93LiBUaGUgbmV3IGludCBjb3VsZCBoYXBwZW4KICogICAgaW5zaWRlIHRoZSBleGVjdXRpb24gb2YgTkNSNTM4MF9pbnRyKCksIGxlYWRpbmcgdG8gcmVjdXJzaXZlCiAqICAgIGNhbGxzLgogKgogKiAgLSBJJ3ZlIGFkZGVkIGEgZnVuY3Rpb24gbWVyZ2VfY29udGlndW91c19idWZmZXJzKCkgdGhhdCB0cmllcyB0bwogKiAgICBtZXJnZSBzY2F0dGVyLWdhdGhlciBidWZmZXJzIHRoYXQgYXJlIGxvY2F0ZWQgYXQgY29udGlndW91cwogKiAgICBwaHlzaWNhbCBhZGRyZXNzZXMgYW5kIGNhbiBiZSBwcm9jZXNzZWQgd2l0aCB0aGUgc2FtZSBETUEgc2V0dXAuCiAqICAgIFNpbmNlIG1vc3Qgc2NhdHRlci1nYXRoZXIgb3BlcmF0aW9ucyB3b3JrIG9uIGEgcGFnZSAoNEspIG9mCiAqICAgIDQgYnVmZmVycyAoMUspLCBpbiBtb3JlIHRoYW4gOTAlIG9mIGFsbCBjYXNlcyB0aHJlZSBpbnRlcnJ1cHRzIGFuZAogKiAgICBETUEgc2V0dXAgYWN0aW9ucyBhcmUgc2F2ZWQuCiAqCiAqIC0gSSd2ZSBkZWxldGVkIGFsbCB0aGUgc3R1ZmYgZm9yIEFVVE9QUk9CRV9JUlEsIFJFQUxfRE1BX1BPTEwsIFBTRVVET19ETUEKICogICAgYW5kIFVTTEVFUCwgYmVjYXVzZSB0aGVzZSB3ZXJlIG1lc3NpbmcgdXAgcmVhZGFiaWxpdHkgYW5kIHdpbGwgbmV2ZXIgYmUKICogICAgbmVlZGVkIGZvciBBdGFyaSBTQ1NJLgogKiAKICogLSBJJ3ZlIHJldmlzZWQgdGhlIE5DUjUzODBfbWFpbigpIGNhbGxpbmcgc2NoZW1lIChyZWxheCB0aGUgJ21haW5fcnVubmluZycKICogICBzdHVmZiksIGFuZCAnbWFpbicgaXMgZXhlY3V0ZWQgaW4gYSBib3R0b20gaGFsZiBpZiBhd29rZW4gYnkgYW4KICogICBpbnRlcnJ1cHQuCiAqCiAqIC0gVGhlIGNvZGUgd2FzIHF1aXRlIGNsdXR0ZXJlZCB1cCBieSAiI2lmIChOREVCVUcgJiBOREVCVUdfKikgcHJpbnRrLi4uIgogKiAgIGNvbnN0cnVjdHMuIEluIG15IGV5ZXMsIHRoaXMgbWFkZSB0aGUgc291cmNlIHJhdGhlciB1bnJlYWRhYmxlLCBzbyBJCiAqICAgZmluYWxseSByZXBsYWNlZCB0aGF0IGJ5IHRoZSAqX1BSSU5USygpIG1hY3Jvcy4KICoKICovCgovKgogKiBGdXJ0aGVyIGRldmVsb3BtZW50IC8gdGVzdGluZyB0aGF0IHNob3VsZCBiZSBkb25lIDogCiAqIDEuICBUZXN0IGxpbmtlZCBjb21tYW5kIGhhbmRsaW5nIGNvZGUgYWZ0ZXIgRXJpYyBpcyByZWFkeSB3aXRoIAogKiAgICAgdGhlIGhpZ2ggbGV2ZWwgY29kZS4KICovCgojaWYgKE5ERUJVRyAmIE5ERUJVR19MSVNUUykKI2RlZmluZSBMSVNUKHgseSkgXAogIHsgcHJpbnRrKCJMSU5FOiVkICAgQWRkaW5nICVwIHRvICVwXG4iLCBfX0xJTkVfXywgKHZvaWQqKSh4KSwgKHZvaWQqKSh5KSk7IFwKICAgIGlmICgoeCk9PSh5KSkgdWRlbGF5KDUpOyB9CiNkZWZpbmUgUkVNT1ZFKHcseCx5LHopIFwKICB7IHByaW50aygiTElORTolZCAgIFJlbW92aW5nOiAlcC0+JXAgICVwLT4lcCBcbiIsIF9fTElORV9fLCBcCgkgICAodm9pZCopKHcpLCAodm9pZCopKHgpLCAodm9pZCopKHkpLCAodm9pZCopKHopKTsgXAogICAgaWYgKCh4KT09KHkpKSB1ZGVsYXkoNSk7IH0KI2Vsc2UKI2RlZmluZSBMSVNUKHgseSkKI2RlZmluZSBSRU1PVkUodyx4LHkseikKI2VuZGlmCgojaWZuZGVmIG5vdHlldAojdW5kZWYgTElOS0VECiNlbmRpZgoKLyoKICogRGVzaWduCiAqIElzc3VlcyA6CiAqCiAqIFRoZSBvdGhlciBMaW51eCBTQ1NJIGRyaXZlcnMgd2VyZSB3cml0dGVuIHdoZW4gTGludXggd2FzIEludGVsIFBDLW9ubHksCiAqIGFuZCBzcGVjaWZpY2FsbHkgZm9yIGVhY2ggYm9hcmQgcmF0aGVyIHRoYW4gZWFjaCBjaGlwLiAgVGhpcyBtYWtlcyB0aGVpcgogKiBhZGFwdGF0aW9uIHRvIHBsYXRmb3JtcyBsaWtlIHRoZSBNYWMgKFNvbWUgb2Ygd2hpY2ggdXNlIE5DUjUzODAncykKICogbW9yZSBkaWZmaWN1bHQgdGhhbiBpdCBoYXMgdG8gYmUuCiAqCiAqIEFsc28sIG1hbnkgb2YgdGhlIFNDU0kgZHJpdmVycyB3ZXJlIHdyaXR0ZW4gYmVmb3JlIHRoZSBjb21tYW5kIHF1ZXVpbmcKICogcm91dGluZXMgd2VyZSBpbXBsZW1lbnRlZCwgbWVhbmluZyB0aGVpciBpbXBsZW1lbnRhdGlvbnMgb2YgcXVldWVkIAogKiBjb21tYW5kcyB3ZXJlIGhhY2tlZCBvbiByYXRoZXIgdGhhbiBkZXNpZ25lZCBpbiBmcm9tIHRoZSBzdGFydC4KICoKICogV2hlbiBJIGRlc2lnbmVkIHRoZSBMaW51eCBTQ1NJIGRyaXZlcnMgSSBmaWd1cmVkIHRoYXQgCiAqIHdoaWxlIGhhdmluZyB0d28gZGlmZmVyZW50IFNDU0kgYm9hcmRzIGluIGEgc3lzdGVtIG1pZ2h0IGJlIHVzZWZ1bAogKiBmb3IgZGVidWdnaW5nIHRoaW5ncywgdHdvIG9mIHRoZSBzYW1lIHR5cGUgd291bGRuJ3QgYmUgdXNlZC4KICogV2VsbCwgSSB3YXMgd3JvbmcgYW5kIGEgbnVtYmVyIG9mIHVzZXJzIGhhdmUgbWFpbGVkIG1lIGFib3V0IHJ1bm5pbmcKICogbXVsdGlwbGUgaGlnaC1wZXJmb3JtYW5jZSBTQ1NJIGJvYXJkcyBpbiBhIHNlcnZlci4KICoKICogRmluYWxseSwgd2hlbiBJIGdldCBxdWVzdGlvbnMgZnJvbSB1c2VycywgSSBoYXZlIG5vIGlkZWEgd2hhdCAKICogcmV2aXNpb24gb2YgbXkgZHJpdmVyIHRoZXkgYXJlIHJ1bm5pbmcuCiAqCiAqIFRoaXMgZHJpdmVyIGF0dGVtcHRzIHRvIGFkZHJlc3MgdGhlc2UgcHJvYmxlbXMgOgogKiBUaGlzIGlzIGEgZ2VuZXJpYyA1MzgwIGRyaXZlci4gIFRvIHVzZSBpdCBvbiBhIGRpZmZlcmVudCBwbGF0Zm9ybSwgCiAqIG9uZSBzaW1wbHkgd3JpdGVzIGFwcHJvcHJpYXRlIHN5c3RlbSBzcGVjaWZpYyBtYWNyb3MgKGllLCBkYXRhCiAqIHRyYW5zZmVyIC0gc29tZSBQQydzIHdpbGwgdXNlIHRoZSBJL08gYnVzLCA2OEsncyBtdXN0IHVzZSAKICogbWVtb3J5IG1hcHBlZCkgYW5kIGRyb3BzIHRoaXMgZmlsZSBpbiB0aGVpciAnQycgd3JhcHBlci4KICoKICogQXMgZmFyIGFzIGNvbW1hbmQgcXVldWVpbmcsIHR3byBxdWV1ZXMgYXJlIG1haW50YWluZWQgZm9yIAogKiBlYWNoIDUzODAgaW4gdGhlIHN5c3RlbSAtIGNvbW1hbmRzIHRoYXQgaGF2ZW4ndCBiZWVuIGlzc3VlZCB5ZXQsCiAqIGFuZCBjb21tYW5kcyB0aGF0IGFyZSBjdXJyZW50bHkgZXhlY3V0aW5nLiAgVGhpcyBtZWFucyB0aGF0IGFuIAogKiB1bmxpbWl0ZWQgbnVtYmVyIG9mIGNvbW1hbmRzIG1heSBiZSBxdWV1ZWQsIGxldHRpbmcgCiAqIG1vcmUgY29tbWFuZHMgcHJvcGFnYXRlIGZyb20gdGhlIGhpZ2hlciBkcml2ZXIgbGV2ZWxzIGdpdmluZyBoaWdoZXIgCiAqIHRocm91Z2hwdXQuICBOb3RlIHRoYXQgYm90aCBJX1RfTCBhbmQgSV9UX0xfUSBuZXh1c2VzIGFyZSBzdXBwb3J0ZWQsIAogKiBhbGxvd2luZyBtdWx0aXBsZSBjb21tYW5kcyB0byBwcm9wYWdhdGUgYWxsIHRoZSB3YXkgdG8gYSBTQ1NJLUlJIGRldmljZSAKICogd2hpbGUgYSBjb21tYW5kIGlzIGFscmVhZHkgZXhlY3V0aW5nLgogKgogKiBUbyBzb2x2ZSB0aGUgbXVsdGlwbGUtYm9hcmRzLWluLXRoZS1zYW1lLXN5c3RlbSBwcm9ibGVtLCAKICogdGhlcmUgaXMgYSBzZXBhcmF0ZSBpbnN0YW5jZSBzdHJ1Y3R1cmUgZm9yIGVhY2ggaW5zdGFuY2UKICogb2YgYSA1MzgwIGluIHRoZSBzeXN0ZW0uICBTbywgbXVsdGlwbGUgTkNSNTM4MCBkcml2ZXJzIHdpbGwKICogYmUgYWJsZSB0byBjb2V4aXN0IHdpdGggYXBwcm9wcmlhdGUgY2hhbmdlcyB0byB0aGUgaGlnaCBsZXZlbAogKiBTQ1NJIGNvZGUuICAKICoKICogQSBOQ1I1MzgwX1BVQkxJQ19SRVZJU0lPTiBtYWNybyBpcyBwcm92aWRlZCwgd2l0aCB0aGUgcmVsZWFzZQogKiBudW1iZXIgKHVwZGF0ZWQgZm9yIGVhY2ggcHVibGljIHJlbGVhc2UpIHByaW50ZWQgYnkgdGhlIAogKiBOQ1I1MzgwX3ByaW50X29wdGlvbnMgY29tbWFuZCwgd2hpY2ggc2hvdWxkIGJlIGNhbGxlZCBmcm9tIHRoZSAKICogd3JhcHBlciBkZXRlY3QgZnVuY3Rpb24sIHNvIHRoYXQgSSBrbm93IHdoYXQgcmVsZWFzZSBvZiB0aGUgZHJpdmVyCiAqIHVzZXJzIGFyZSB1c2luZy4KICoKICogSXNzdWVzIHNwZWNpZmljIHRvIHRoZSBOQ1I1MzgwIDogCiAqCiAqIFdoZW4gdXNlZCBpbiBhIFBJTyBvciBwc2V1ZG8tZG1hIG1vZGUsIHRoZSBOQ1I1MzgwIGlzIGEgYnJhaW5kZWFkIAogKiBwaWVjZSBvZiBoYXJkd2FyZSB0aGF0IHJlcXVpcmVzIHlvdSB0byBzaXQgaW4gYSBsb29wIHBvbGxpbmcgZm9yIAogKiB0aGUgUkVRIHNpZ25hbCBhcyBsb25nIGFzIHlvdSBhcmUgY29ubmVjdGVkLiAgU29tZSBkZXZpY2VzIGFyZSAKICogYnJhaW4gZGVhZCAoaWUsIG1hbnkgVEVYRUwgQ0QgUk9NIGRyaXZlcykgYW5kIHdvbid0IGRpc2Nvbm5lY3QgCiAqIHdoaWxlIGRvaW5nIGxvbmcgc2VlayBvcGVyYXRpb25zLgogKiAKICogVGhlIHdvcmthcm91bmQgZm9yIHRoaXMgaXMgdG8ga2VlcCB0cmFjayBvZiBkZXZpY2VzIHRoYXQgaGF2ZQogKiBkaXNjb25uZWN0ZWQuICBJZiB0aGUgZGV2aWNlIGhhc24ndCBkaXNjb25uZWN0ZWQsIGZvciBjb21tYW5kcyB0aGF0CiAqIHNob3VsZCBkaXNjb25uZWN0LCB3ZSBkbyBzb21ldGhpbmcgbGlrZSAKICoKICogd2hpbGUgKCFSRVEgaXMgYXNzZXJ0ZWQpIHsgc2xlZXAgZm9yIE4gdXNlY3M7IHBvbGwgZm9yIE0gdXNlY3MgfQogKiAKICogU29tZSB0d2Vha2luZyBvZiBOIGFuZCBNIG5lZWRzIHRvIGJlIGRvbmUuICBBbiBhbGdvcml0aG0gYmFzZWQgCiAqIG9uICJ0aW1lIHRvIGRhdGEiIHdvdWxkIGdpdmUgdGhlIGJlc3QgcmVzdWx0cyBhcyBsb25nIGFzIHNob3J0IHRpbWUKICogdG8gZGF0YXMgKGllLCBvbiB0aGUgc2FtZSB0cmFjaykgd2VyZSBjb25zaWRlcmVkLCBob3dldmVyIHRoZXNlIAogKiBicm9rZW4gZGV2aWNlcyBhcmUgdGhlIGV4Y2VwdGlvbiByYXRoZXIgdGhhbiB0aGUgcnVsZSBhbmQgSSdkIHJhdGhlcgogKiBzcGVuZCBteSB0aW1lIG9wdGltaXppbmcgZm9yIHRoZSBub3JtYWwgY2FzZS4KICoKICogQXJjaGl0ZWN0dXJlIDoKICoKICogQXQgdGhlIGhlYXJ0IG9mIHRoZSBkZXNpZ24gaXMgYSBjb3JvdXRpbmUsIE5DUjUzODBfbWFpbiwKICogd2hpY2ggaXMgc3RhcnRlZCB3aGVuIG5vdCBydW5uaW5nIGJ5IHRoZSBpbnRlcnJ1cHQgaGFuZGxlciwKICogdGltZXIsIGFuZCBxdWV1ZSBjb21tYW5kIGZ1bmN0aW9uLiAgSXQgYXR0ZW1wdHMgdG8gZXN0YWJsaXNoCiAqIElfVF9MIG9yIElfVF9MX1EgbmV4dXNlcyBieSByZW1vdmluZyB0aGUgY29tbWFuZHMgZnJvbSB0aGUgCiAqIGlzc3VlIHF1ZXVlIGFuZCBjYWxsaW5nIE5DUjUzODBfc2VsZWN0KCkgaWYgYSBuZXh1cyAKICogaXMgbm90IGVzdGFibGlzaGVkLiAKICoKICogT25jZSBhIG5leHVzIGlzIGVzdGFibGlzaGVkLCB0aGUgTkNSNTM4MF9pbmZvcm1hdGlvbl90cmFuc2ZlcigpCiAqIHBoYXNlIGdvZXMgdGhyb3VnaCB0aGUgdmFyaW91cyBwaGFzZXMgYXMgaW5zdHJ1Y3RlZCBieSB0aGUgdGFyZ2V0LgogKiBpZiB0aGUgdGFyZ2V0IGdvZXMgaW50byBNU0cgSU4gYW5kIHNlbmRzIGEgRElTQ09OTkVDVCBtZXNzYWdlLAogKiB0aGUgY29tbWFuZCBzdHJ1Y3R1cmUgaXMgcGxhY2VkIGludG8gdGhlIHBlciBpbnN0YW5jZSBkaXNjb25uZWN0ZWQKICogcXVldWUsIGFuZCBOQ1I1MzgwX21haW4gdHJpZXMgdG8gZmluZCBtb3JlIHdvcmsuICBJZiBVU0xFRVAKICogd2FzIGRlZmluZWQsIGFuZCB0aGUgdGFyZ2V0IGlzIGlkbGUgZm9yIHRvbyBsb25nLCB0aGUgc3lzdGVtCiAqIHdpbGwgdHJ5IHRvIHNsZWVwLgogKgogKiBJZiBhIGNvbW1hbmQgaGFzIGRpc2Nvbm5lY3RlZCwgZXZlbnR1YWxseSBhbiBpbnRlcnJ1cHQgd2lsbCB0cmlnZ2VyLAogKiBjYWxsaW5nIE5DUjUzODBfaW50cigpICB3aGljaCB3aWxsIGluIHR1cm4gY2FsbCBOQ1I1MzgwX3Jlc2VsZWN0CiAqIHRvIHJlZXN0YWJsaXNoIGEgbmV4dXMuICBUaGlzIHdpbGwgcnVuIG1haW4gaWYgbmVjZXNzYXJ5LgogKgogKiBPbiBjb21tYW5kIHRlcm1pbmF0aW9uLCB0aGUgZG9uZSBmdW5jdGlvbiB3aWxsIGJlIGNhbGxlZCBhcyAKICogYXBwcm9wcmlhdGUuCiAqCiAqIFNDU0kgcG9pbnRlcnMgYXJlIG1haW50YWluZWQgaW4gdGhlIFNDcCBmaWVsZCBvZiBTQ1NJIGNvbW1hbmQgCiAqIHN0cnVjdHVyZXMsIGJlaW5nIGluaXRpYWxpemVkIGFmdGVyIHRoZSBjb21tYW5kIGlzIGNvbm5lY3RlZAogKiBpbiBOQ1I1MzgwX3NlbGVjdCwgYW5kIHNldCBhcyBhcHByb3ByaWF0ZSBpbiBOQ1I1MzgwX2luZm9ybWF0aW9uX3RyYW5zZmVyLgogKiBOb3RlIHRoYXQgaW4gdmlvbGF0aW9uIG9mIHRoZSBzdGFuZGFyZCwgYW4gaW1wbGljaXQgU0FWRSBQT0lOVEVSUyBvcGVyYXRpb24KICogaXMgZG9uZSwgc2luY2Ugc29tZSBCUk9LRU4gZGlza3MgZmFpbCB0byBpc3N1ZSBhbiBleHBsaWNpdCBTQVZFIFBPSU5URVJTLgogKi8KCi8qCiAqIFVzaW5nIHRoaXMgZmlsZSA6CiAqIFRoaXMgZmlsZSBhIHNrZWxldG9uIExpbnV4IFNDU0kgZHJpdmVyIGZvciB0aGUgTkNSIDUzODAgc2VyaWVzCiAqIG9mIGNoaXBzLiAgVG8gdXNlIGl0LCB5b3Ugd3JpdGUgYW4gYXJjaGl0ZWN0dXJlIHNwZWNpZmljIGZ1bmN0aW9ucyAKICogYW5kIG1hY3JvcyBhbmQgaW5jbHVkZSB0aGlzIGZpbGUgaW4geW91ciBkcml2ZXIuCiAqCiAqIFRoZXNlIG1hY3JvcyBjb250cm9sIG9wdGlvbnMgOiAKICogQVVUT1NFTlNFIC0gaWYgZGVmaW5lZCwgUkVRVUVTVCBTRU5TRSB3aWxsIGJlIHBlcmZvcm1lZCBhdXRvbWF0aWNhbGx5CiAqCWZvciBjb21tYW5kcyB0aGF0IHJldHVybiB3aXRoIGEgQ0hFQ0sgQ09ORElUSU9OIHN0YXR1cy4gCiAqCiAqIExJTktFRCAtIGlmIGRlZmluZWQsIGxpbmtlZCBjb21tYW5kcyBhcmUgc3VwcG9ydGVkLgogKgogKiBSRUFMX0RNQSAtIGlmIGRlZmluZWQsIFJFQUwgRE1BIGlzIHVzZWQgZHVyaW5nIHRoZSBkYXRhIHRyYW5zZmVyIHBoYXNlcy4KICoKICogU1VQUE9SVF9UQUdTIC0gaWYgZGVmaW5lZCwgU0NTSS0yIHRhZ2dlZCBxdWV1aW5nIGlzIHVzZWQgd2hlcmUgcG9zc2libGUKICoKICogVGhlc2UgbWFjcm9zIE1VU1QgYmUgZGVmaW5lZCA6CiAqIAogKiBOQ1I1MzgwX3JlYWQocmVnaXN0ZXIpICAtIHJlYWQgZnJvbSB0aGUgc3BlY2lmaWVkIHJlZ2lzdGVyCiAqCiAqIE5DUjUzODBfd3JpdGUocmVnaXN0ZXIsIHZhbHVlKSAtIHdyaXRlIHRvIHRoZSBzcGVjaWZpYyByZWdpc3RlciAKICoKICogRWl0aGVyIHJlYWwgRE1BICpvciogcHNldWRvIERNQSBtYXkgYmUgaW1wbGVtZW50ZWQKICogUkVBTCBmdW5jdGlvbnMgOiAKICogTkNSNTM4MF9SRUFMX0RNQSBzaG91bGQgYmUgZGVmaW5lZCBpZiByZWFsIERNQSBpcyB0byBiZSB1c2VkLgogKiBOb3RlIHRoYXQgdGhlIERNQSBzZXR1cCBmdW5jdGlvbnMgc2hvdWxkIHJldHVybiB0aGUgbnVtYmVyIG9mIGJ5dGVzIAogKgl0aGF0IHRoZXkgd2VyZSBhYmxlIHRvIHByb2dyYW0gdGhlIGNvbnRyb2xsZXIgZm9yLgogKgogKiBBbHNvIG5vdGUgdGhhdCBnZW5lcmljIGkzODYvUEMgdmVyc2lvbnMgb2YgdGhlc2UgbWFjcm9zIGFyZSAKICoJYXZhaWxhYmxlIGFzIE5DUjUzODBfaTM4Nl9kbWFfd3JpdGVfc2V0dXAsCiAqCU5DUjUzODBfaTM4Nl9kbWFfcmVhZF9zZXR1cCwgYW5kIE5DUjUzODBfaTM4Nl9kbWFfcmVzaWR1YWwuCiAqCiAqIE5DUjUzODBfZG1hX3dyaXRlX3NldHVwKGluc3RhbmNlLCBzcmMsIGNvdW50KSAtIGluaXRpYWxpemUKICogTkNSNTM4MF9kbWFfcmVhZF9zZXR1cChpbnN0YW5jZSwgZHN0LCBjb3VudCkgLSBpbml0aWFsaXplCiAqIE5DUjUzODBfZG1hX3Jlc2lkdWFsKGluc3RhbmNlKTsgLSByZXNpZHVhbCBjb3VudAogKgogKiBQU0VVRE8gZnVuY3Rpb25zIDoKICogTkNSNTM4MF9wd3JpdGUoaW5zdGFuY2UsIHNyYywgY291bnQpCiAqIE5DUjUzODBfcHJlYWQoaW5zdGFuY2UsIGRzdCwgY291bnQpOwogKgogKiBJZiBub3RoaW5nIHNwZWNpZmljIHRvIHRoaXMgaW1wbGVtZW50YXRpb24gbmVlZHMgZG9pbmcgKGllLCB3aXRoIGV4dGVybmFsCiAqIGhhcmR3YXJlKSwgeW91IG11c3QgYWxzbyBkZWZpbmUgCiAqICAKICogTkNSNTM4MF9xdWV1ZV9jb21tYW5kCiAqIE5DUjUzODBfcmVzZXQKICogTkNSNTM4MF9hYm9ydAogKiBOQ1I1MzgwX3Byb2NfaW5mbwogKgogKiB0byBiZSB0aGUgZ2xvYmFsIGVudHJ5IHBvaW50cyBpbnRvIHRoZSBzcGVjaWZpYyBkcml2ZXIsIGllIAogKiAjZGVmaW5lIE5DUjUzODBfcXVldWVfY29tbWFuZCB0MTI4X3F1ZXVlX2NvbW1hbmQuCiAqCiAqIElmIHRoaXMgaXMgbm90IGRvbmUsIHRoZSByb3V0aW5lcyB3aWxsIGJlIGRlZmluZWQgYXMgc3RhdGljIGZ1bmN0aW9ucwogKiB3aXRoIHRoZSBOQ1I1MzgwKiBuYW1lcyBhbmQgdGhlIHVzZXIgbXVzdCBwcm92aWRlIGEgZ2xvYmFsbHkKICogYWNjZXNzaWJsZSB3cmFwcGVyIGZ1bmN0aW9uLgogKgogKiBUaGUgZ2VuZXJpYyBkcml2ZXIgaXMgaW5pdGlhbGl6ZWQgYnkgY2FsbGluZyBOQ1I1MzgwX2luaXQoaW5zdGFuY2UpLAogKiBhZnRlciBzZXR0aW5nIHRoZSBhcHByb3ByaWF0ZSBob3N0IHNwZWNpZmljIGZpZWxkcyBhbmQgSUQuICBJZiB0aGUgCiAqIGRyaXZlciB3aXNoZXMgdG8gYXV0b3Byb2JlIGZvciBhbiBJUlEgbGluZSwgdGhlIE5DUjUzODBfcHJvYmVfaXJxKGluc3RhbmNlLAogKiBwb3NzaWJsZSkgZnVuY3Rpb24gbWF5IGJlIHVzZWQuICBCZWZvcmUgdGhlIHNwZWNpZmljIGRyaXZlciBpbml0aWFsaXphdGlvbgogKiBjb2RlIGZpbmlzaGVzLCBOQ1I1MzgwX3ByaW50X29wdGlvbnMgc2hvdWxkIGJlIGNhbGxlZC4KICovCgpzdGF0aWMgc3RydWN0IFNjc2lfSG9zdCAqZmlyc3RfaW5zdGFuY2UgPSBOVUxMOwpzdGF0aWMgU2NzaV9Ib3N0X1RlbXBsYXRlICp0aGVfdGVtcGxhdGUgPSBOVUxMOwoKLyogTWFjcm9zIGVhc2UgbGlmZS4uLiA6LSkgKi8KI2RlZmluZQlTRVRVUF9IT1NUREFUQShpbikJCQkJXAogICAgc3RydWN0IE5DUjUzODBfaG9zdGRhdGEgKmhvc3RkYXRhID0JCQlcCgkoc3RydWN0IE5DUjUzODBfaG9zdGRhdGEgKikoaW4pLT5ob3N0ZGF0YQojZGVmaW5lCUhPU1REQVRBKGluKSAoKHN0cnVjdCBOQ1I1MzgwX2hvc3RkYXRhICopKGluKS0+aG9zdGRhdGEpCgojZGVmaW5lCU5FWFQoY21kKQkoKFNjc2lfQ21uZCAqKSgoY21kKS0+aG9zdF9zY3JpYmJsZSkpCiNkZWZpbmUJTkVYVEFERFIoY21kKQkoKFNjc2lfQ21uZCAqKikmKChjbWQpLT5ob3N0X3NjcmliYmxlKSkKCiNkZWZpbmUJSE9TVE5PCQlpbnN0YW5jZS0+aG9zdF9ubwojZGVmaW5lCUhfTk8oY21kKQkoY21kKS0+ZGV2aWNlLT5ob3N0LT5ob3N0X25vCgojaWZkZWYgU1VQUE9SVF9UQUdTCgovKgogKiBGdW5jdGlvbnMgZm9yIGhhbmRsaW5nIHRhZ2dlZCBxdWV1aW5nCiAqID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICoKICogKytyb21hbiAoMDEvOTYpOiBOb3cgSSd2ZSBpbXBsZW1lbnRlZCBTQ1NJLTIgdGFnZ2VkIHF1ZXVpbmcuIFNvbWUgbm90ZXM6CiAqCiAqIFVzaW5nIGNvbnNlY3V0aXZlIG51bWJlcnMgZm9yIHRoZSB0YWdzIGlzIG5vIGdvb2QgaWRlYSBpbiBteSBleWVzLiBUaGVyZQogKiBjb3VsZCBiZSB3cm9uZyByZS11c2luZ3MgaWYgdGhlIGNvdW50ZXIgKDggYml0ISkgd3JhcHMgYW5kIHNvbWUgZWFybHkKICogY29tbWFuZCBoYXMgYmVlbiBwcmVlbXB0ZWQgZm9yIGEgbG9uZyB0aW1lLiBNeSBzb2x1dGlvbjogYSBiaXRmaWVsZCBmb3IKICogcmVtZW1iZXJpbmcgdXNlZCB0YWdzLgogKgogKiBUaGVyZSdzIGFsc28gdGhlIHByb2JsZW0gdGhhdCBlYWNoIHRhcmdldCBoYXMgYSBjZXJ0YWluIHF1ZXVlIHNpemUsIGJ1dCB3ZQogKiBjYW5ub3Qga25vdyBpdCBpbiBhZHZhbmNlIDotKCBXZSBqdXN0IHNlZSBhIFFVRVVFX0ZVTEwgc3RhdHVzIGJlaW5nCiAqIHJldHVybmVkLiBTbywgaW4gdGhpcyBjYXNlLCB0aGUgZHJpdmVyIGludGVybmFsIHF1ZXVlIHNpemUgYXNzdW1wdGlvbiBpcwogKiByZWR1Y2VkIHRvIHRoZSBudW1iZXIgb2YgYWN0aXZlIHRhZ3MgaWYgUVVFVUVfRlVMTCBpcyByZXR1cm5lZCBieSB0aGUKICogdGFyZ2V0LiBUaGUgY29tbWFuZCBpcyByZXR1cm5lZCB0byB0aGUgbWlkLWxldmVsLCBidXQgd2l0aCBzdGF0dXMgY2hhbmdlZAogKiB0byBCVVNZLCBzaW5jZSAtLWFzIEkndmUgc2Vlbi0tIHRoZSBtaWQtbGV2ZWwgY2FuJ3QgaGFuZGxlIFFVRVVFX0ZVTEwKICogY29ycmVjdGx5LgogKgogKiBXZSdyZSBhbHNvIG5vdCBhbGxvd2VkIHJ1bm5pbmcgdGFnZ2VkIGNvbW1hbmRzIGFzIGxvbmcgYXMgYW4gdW50YWdnZWQKICogY29tbWFuZCBpcyBhY3RpdmUuIEFuZCBSRVFVRVNUIFNFTlNFIGNvbW1hbmRzIGFmdGVyIGEgY29udGluZ2VudCBhbGxlZ2lhbmNlCiAqIGNvbmRpdGlvbiBfbXVzdF8gYmUgdW50YWdnZWQuIFRvIGtlZXAgdHJhY2sgd2hldGhlciBhbiB1bnRhZ2dlZCBjb21tYW5kIGhhcwogKiBiZWVuIGlzc3VlZCwgdGhlIGhvc3QtPmJ1c3kgYXJyYXkgaXMgc3RpbGwgZW1wbG95ZWQsIGFzIGl0IGlzIHdpdGhvdXQKICogc3VwcG9ydCBmb3IgdGFnZ2VkIHF1ZXVpbmcuCiAqCiAqIE9uZSBjb3VsZCBzdXNwZWN0IHRoYXQgdGhlcmUgYXJlIHBvc3NpYmxlIHJhY2UgY29uZGl0aW9ucyBiZXR3ZWVuCiAqIGlzX2x1bl9idXN5KCksIGNtZF9nZXRfdGFnKCkgYW5kIGNtZF9mcmVlX3RhZygpLiBCdXQgSSB0aGluayB0aGlzIGlzbid0IHRoZQogKiBjYXNlOiBpc19sdW5fYnVzeSgpIGFuZCBjbWRfZ2V0X3RhZygpIGFyZSBib3RoIGNhbGxlZCBmcm9tIE5DUjUzODBfbWFpbigpLAogKiB3aGljaCBhbHJlYWR5IGd1YXJhbnRlZWQgdG8gYmUgcnVubmluZyBhdCBtb3N0IG9uY2UuIEl0IGlzIGFsc28gdGhlIG9ubHkKICogcGxhY2Ugd2hlcmUgdGFncy9MVU5zIGFyZSBhbGxvY2F0ZWQuIFNvIG5vIG90aGVyIGFsbG9jYXRpb24gY2FuIHNsaXAKICogYmV0d2VlbiB0aGF0IHBhaXIsIHRoZXJlIGNvdWxkIG9ubHkgaGFwcGVuIGEgcmVzZWxlY3Rpb24sIHdoaWNoIGNhbiBmcmVlIGEKICogdGFnLCBidXQgdGhhdCBkb2Vzbid0IGh1cnQuIE9ubHkgdGhlIHNlcXVlbmNlIGluIGNtZF9mcmVlX3RhZygpIGJlY29tZXMKICogaW1wb3J0YW50OiB0aGUgdGFnIGJpdCBtdXN0IGJlIGNsZWFyZWQgYmVmb3JlICducl9hbGxvY2F0ZWQnIGlzIGRlY3JlYXNlZC4KICovCgovKiAtMSBmb3IgVEFHX05PTkUgaXMgbm90IHBvc3NpYmxlIHdpdGggdW5zaWduZWQgY2hhciBjbWQtPnRhZyAqLwojdW5kZWYgVEFHX05PTkUKI2RlZmluZSBUQUdfTk9ORSAweGZmCgp0eXBlZGVmIHN0cnVjdCB7CiAgICBERUNMQVJFX0JJVE1BUChhbGxvY2F0ZWQsIE1BWF9UQUdTKTsKICAgIGludAkJbnJfYWxsb2NhdGVkOwogICAgaW50CQlxdWV1ZV9zaXplOwp9IFRBR19BTExPQzsKCnN0YXRpYyBUQUdfQUxMT0MgVGFnQWxsb2NbOF1bOF07IC8qIDggdGFyZ2V0cyBhbmQgOCBMVU5zICovCgoKc3RhdGljIHZvaWQgX19pbml0IGluaXRfdGFncyggdm9pZCApCnsKICAgIGludCB0YXJnZXQsIGx1bjsKICAgIFRBR19BTExPQyAqdGE7CiAgICAKICAgIGlmICghc2V0dXBfdXNlX3RhZ2dlZF9xdWV1aW5nKQoJcmV0dXJuOwogICAgCiAgICBmb3IoIHRhcmdldCA9IDA7IHRhcmdldCA8IDg7ICsrdGFyZ2V0ICkgewoJZm9yKCBsdW4gPSAwOyBsdW4gPCA4OyArK2x1biApIHsKCSAgICB0YSA9ICZUYWdBbGxvY1t0YXJnZXRdW2x1bl07CgkgICAgYml0bWFwX3plcm8odGEtPmFsbG9jYXRlZCwgTUFYX1RBR1MpOwoJICAgIHRhLT5ucl9hbGxvY2F0ZWQgPSAwOwoJICAgIC8qIEF0IHRoZSBiZWdpbm5pbmcsIGFzc3VtZSB0aGUgbWF4aW11bSBxdWV1ZSBzaXplIHdlIGNvdWxkCgkgICAgICogc3VwcG9ydCAoTUFYX1RBR1MpLiBUaGlzIHZhbHVlIHdpbGwgYmUgZGVjcmVhc2VkIGlmIHRoZSB0YXJnZXQKCSAgICAgKiByZXR1cm5zIFFVRVVFX0ZVTEwgc3RhdHVzLgoJICAgICAqLwoJICAgIHRhLT5xdWV1ZV9zaXplID0gTUFYX1RBR1M7Cgl9CiAgICB9Cn0KCgovKiBDaGVjayBpZiB3ZSBjYW4gaXNzdWUgYSBjb21tYW5kIHRvIHRoaXMgTFVOOiBGaXJzdCBzZWUgaWYgdGhlIExVTiBpcyBtYXJrZWQKICogYnVzeSBieSBhbiB1bnRhZ2dlZCBjb21tYW5kLiBJZiB0aGUgY29tbWFuZCBzaG91bGQgdXNlIHRhZ2dlZCBxdWV1aW5nLCBhbHNvCiAqIGNoZWNrIHRoYXQgdGhlcmUgaXMgYSBmcmVlIHRhZyBhbmQgdGhlIHRhcmdldCdzIHF1ZXVlIHdvbid0IG92ZXJmbG93LiBUaGlzCiAqIGZ1bmN0aW9uIHNob3VsZCBiZSBjYWxsZWQgd2l0aCBpbnRlcnJ1cHRzIGRpc2FibGVkIHRvIGF2b2lkIHJhY2UKICogY29uZGl0aW9ucy4KICovIAoKc3RhdGljIGludCBpc19sdW5fYnVzeSggU2NzaV9DbW5kICpjbWQsIGludCBzaG91bGRfYmVfdGFnZ2VkICkKewogICAgU0VUVVBfSE9TVERBVEEoY21kLT5kZXZpY2UtPmhvc3QpOwoKICAgIGlmIChob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdICYgKDEgPDwgY21kLT5kZXZpY2UtPmx1bikpCglyZXR1cm4oIDEgKTsKICAgIGlmICghc2hvdWxkX2JlX3RhZ2dlZCB8fAoJIXNldHVwX3VzZV90YWdnZWRfcXVldWluZyB8fCAhY21kLT5kZXZpY2UtPnRhZ2dlZF9zdXBwb3J0ZWQpCglyZXR1cm4oIDAgKTsKICAgIGlmIChUYWdBbGxvY1tjbWQtPmRldmljZS0+aWRdW2NtZC0+ZGV2aWNlLT5sdW5dLm5yX2FsbG9jYXRlZCA+PQoJVGFnQWxsb2NbY21kLT5kZXZpY2UtPmlkXVtjbWQtPmRldmljZS0+bHVuXS5xdWV1ZV9zaXplICkgewoJVEFHX1BSSU5USyggInNjc2klZDogdGFyZ2V0ICVkIGx1biAlZDogbm8gZnJlZSB0YWdzXG4iLAoJCSAgICBIX05PKGNtZCksIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1biApOwoJcmV0dXJuKCAxICk7CiAgICB9CiAgICByZXR1cm4oIDAgKTsKfQoKCi8qIEFsbG9jYXRlIGEgdGFnIGZvciBhIGNvbW1hbmQgKHRoZXJlIGFyZSBubyBjaGVja3MgYW55bW9yZSwgY2hlY2tfbHVuX2J1c3koKQogKiBtdXN0IGJlIGNhbGxlZCBiZWZvcmUhKSwgb3IgcmVzZXJ2ZSB0aGUgTFVOIGluICdidXN5JyBpZiB0aGUgY29tbWFuZCBpcwogKiB1bnRhZ2dlZC4KICovCgpzdGF0aWMgdm9pZCBjbWRfZ2V0X3RhZyggU2NzaV9DbW5kICpjbWQsIGludCBzaG91bGRfYmVfdGFnZ2VkICkKewogICAgU0VUVVBfSE9TVERBVEEoY21kLT5kZXZpY2UtPmhvc3QpOwoKICAgIC8qIElmIHdlIG9yIHRoZSB0YXJnZXQgZG9uJ3Qgc3VwcG9ydCB0YWdnZWQgcXVldWluZywgYWxsb2NhdGUgdGhlIExVTiBmb3IKICAgICAqIGFuIHVudGFnZ2VkIGNvbW1hbmQuCiAgICAgKi8KICAgIGlmICghc2hvdWxkX2JlX3RhZ2dlZCB8fAoJIXNldHVwX3VzZV90YWdnZWRfcXVldWluZyB8fCAhY21kLT5kZXZpY2UtPnRhZ2dlZF9zdXBwb3J0ZWQpIHsKCWNtZC0+dGFnID0gVEFHX05PTkU7Cglob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdIHw9ICgxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwoJVEFHX1BSSU5USyggInNjc2klZDogdGFyZ2V0ICVkIGx1biAlZCBub3cgYWxsb2NhdGVkIGJ5IHVudGFnZ2VkICIKCQkgICAgImNvbW1hbmRcbiIsIEhfTk8oY21kKSwgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuICk7CiAgICB9CiAgICBlbHNlIHsKCVRBR19BTExPQyAqdGEgPSAmVGFnQWxsb2NbY21kLT5kZXZpY2UtPmlkXVtjbWQtPmRldmljZS0+bHVuXTsKCgljbWQtPnRhZyA9IGZpbmRfZmlyc3RfemVyb19iaXQoIHRhLT5hbGxvY2F0ZWQsIE1BWF9UQUdTICk7CglzZXRfYml0KCBjbWQtPnRhZywgdGEtPmFsbG9jYXRlZCApOwoJdGEtPm5yX2FsbG9jYXRlZCsrOwoJVEFHX1BSSU5USyggInNjc2klZDogdXNpbmcgdGFnICVkIGZvciB0YXJnZXQgJWQgbHVuICVkICIKCQkgICAgIihub3cgJWQgdGFncyBpbiB1c2UpXG4iLAoJCSAgICBIX05PKGNtZCksIGNtZC0+dGFnLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4sCgkJICAgIHRhLT5ucl9hbGxvY2F0ZWQgKTsKICAgIH0KfQoKCi8qIE1hcmsgdGhlIHRhZyBvZiBjb21tYW5kICdjbWQnIGFzIGZyZWUsIG9yIGluIGNhc2Ugb2YgYW4gdW50YWdnZWQgY29tbWFuZCwKICogdW5sb2NrIHRoZSBMVU4uCiAqLwoKc3RhdGljIHZvaWQgY21kX2ZyZWVfdGFnKCBTY3NpX0NtbmQgKmNtZCApCnsKICAgIFNFVFVQX0hPU1REQVRBKGNtZC0+ZGV2aWNlLT5ob3N0KTsKCiAgICBpZiAoY21kLT50YWcgPT0gVEFHX05PTkUpIHsKCWhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gJj0gfigxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwoJVEFHX1BSSU5USyggInNjc2klZDogdGFyZ2V0ICVkIGx1biAlZCB1bnRhZ2dlZCBjbWQgZmluaXNoZWRcbiIsCgkJICAgIEhfTk8oY21kKSwgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuICk7CiAgICB9CiAgICBlbHNlIGlmIChjbWQtPnRhZyA+PSBNQVhfVEFHUykgewoJcHJpbnRrKEtFUk5fTk9USUNFICJzY3NpJWQ6IHRyeWluZyB0byBmcmVlIGJhZCB0YWcgJWQhXG4iLAoJCUhfTk8oY21kKSwgY21kLT50YWcgKTsKICAgIH0KICAgIGVsc2UgewoJVEFHX0FMTE9DICp0YSA9ICZUYWdBbGxvY1tjbWQtPmRldmljZS0+aWRdW2NtZC0+ZGV2aWNlLT5sdW5dOwoJY2xlYXJfYml0KCBjbWQtPnRhZywgdGEtPmFsbG9jYXRlZCApOwoJdGEtPm5yX2FsbG9jYXRlZC0tOwoJVEFHX1BSSU5USyggInNjc2klZDogZnJlZWQgdGFnICVkIGZvciB0YXJnZXQgJWQgbHVuICVkXG4iLAoJCSAgICBIX05PKGNtZCksIGNtZC0+dGFnLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4gKTsKICAgIH0KfQoKCnN0YXRpYyB2b2lkIGZyZWVfYWxsX3RhZ3MoIHZvaWQgKQp7CiAgICBpbnQgdGFyZ2V0LCBsdW47CiAgICBUQUdfQUxMT0MgKnRhOwoKICAgIGlmICghc2V0dXBfdXNlX3RhZ2dlZF9xdWV1aW5nKQoJcmV0dXJuOwogICAgCiAgICBmb3IoIHRhcmdldCA9IDA7IHRhcmdldCA8IDg7ICsrdGFyZ2V0ICkgewoJZm9yKCBsdW4gPSAwOyBsdW4gPCA4OyArK2x1biApIHsKCSAgICB0YSA9ICZUYWdBbGxvY1t0YXJnZXRdW2x1bl07CgkgICAgYml0bWFwX3plcm8odGEtPmFsbG9jYXRlZCwgTUFYX1RBR1MpOwoJICAgIHRhLT5ucl9hbGxvY2F0ZWQgPSAwOwoJfQogICAgfQp9CgojZW5kaWYgLyogU1VQUE9SVF9UQUdTICovCgoKLyoKICogRnVuY3Rpb246IHZvaWQgbWVyZ2VfY29udGlndW91c19idWZmZXJzKCBTY3NpX0NtbmQgKmNtZCApCiAqCiAqIFB1cnBvc2U6IFRyeSB0byBtZXJnZSBzZXZlcmFsIHNjYXR0ZXItZ2F0aGVyIHJlcXVlc3RzIGludG8gb25lIERNQQogKiAgICB0cmFuc2Zlci4gVGhpcyBpcyBwb3NzaWJsZSBpZiB0aGUgc2NhdHRlciBidWZmZXJzIGxpZSBvbgogKiAgICBwaHlzaWNhbCBjb250aWd1b3VzIGFkZHJlc3Nlcy4KICoKICogUGFyYW1ldGVyczogU2NzaV9DbW5kICpjbWQKICogICAgVGhlIGNvbW1hbmQgdG8gd29yayBvbi4gVGhlIGZpcnN0IHNjYXR0ZXIgYnVmZmVyJ3MgZGF0YSBhcmUKICogICAgYXNzdW1lZCB0byBiZSBhbHJlYWR5IHRyYW5zZmVyZWQgaW50byBwdHIvdGhpc19yZXNpZHVhbC4KICovCgpzdGF0aWMgdm9pZCBtZXJnZV9jb250aWd1b3VzX2J1ZmZlcnMoIFNjc2lfQ21uZCAqY21kICkKewogICAgdW5zaWduZWQgbG9uZyBlbmRhZGRyOwojaWYgKE5ERUJVRyAmIE5ERUJVR19NRVJHSU5HKQogICAgdW5zaWduZWQgbG9uZyBvbGRsZW4gPSBjbWQtPlNDcC50aGlzX3Jlc2lkdWFsOwogICAgaW50CQkgIGNudCA9IDE7CiNlbmRpZgoKICAgIGZvciAoZW5kYWRkciA9IHZpcnRfdG9fcGh5cyhjbWQtPlNDcC5wdHIgKyBjbWQtPlNDcC50aGlzX3Jlc2lkdWFsIC0gMSkgKyAxOwoJIGNtZC0+U0NwLmJ1ZmZlcnNfcmVzaWR1YWwgJiYKCSB2aXJ0X3RvX3BoeXMocGFnZV9hZGRyZXNzKGNtZC0+U0NwLmJ1ZmZlclsxXS5wYWdlKSsKCQkgICAgICBjbWQtPlNDcC5idWZmZXJbMV0ub2Zmc2V0KSA9PSBlbmRhZGRyOyApIHsKCU1FUl9QUklOVEsoIlZUT1AoJXApID09ICUwOGx4IC0+IG1lcmdpbmdcbiIsCgkJICAgY21kLT5TQ3AuYnVmZmVyWzFdLmFkZHJlc3MsIGVuZGFkZHIpOwojaWYgKE5ERUJVRyAmIE5ERUJVR19NRVJHSU5HKQoJKytjbnQ7CiNlbmRpZgoJKytjbWQtPlNDcC5idWZmZXI7CgktLWNtZC0+U0NwLmJ1ZmZlcnNfcmVzaWR1YWw7CgljbWQtPlNDcC50aGlzX3Jlc2lkdWFsICs9IGNtZC0+U0NwLmJ1ZmZlci0+bGVuZ3RoOwoJZW5kYWRkciArPSBjbWQtPlNDcC5idWZmZXItPmxlbmd0aDsKICAgIH0KI2lmIChOREVCVUcgJiBOREVCVUdfTUVSR0lORykKICAgIGlmIChvbGRsZW4gIT0gY21kLT5TQ3AudGhpc19yZXNpZHVhbCkKCU1FUl9QUklOVEsoIm1lcmdlZCAlZCBidWZmZXJzIGZyb20gJXAsIG5ldyBsZW5ndGggJTA4eFxuIiwKCQkgICBjbnQsIGNtZC0+U0NwLnB0ciwgY21kLT5TQ3AudGhpc19yZXNpZHVhbCk7CiNlbmRpZgp9CgovKgogKiBGdW5jdGlvbiA6IHZvaWQgaW5pdGlhbGl6ZV9TQ3AoU2NzaV9DbW5kICpjbWQpCiAqCiAqIFB1cnBvc2UgOiBpbml0aWFsaXplIHRoZSBzYXZlZCBkYXRhIHBvaW50ZXJzIGZvciBjbWQgdG8gcG9pbnQgdG8gdGhlIAogKglzdGFydCBvZiB0aGUgYnVmZmVyLgogKgogKiBJbnB1dHMgOiBjbWQgLSBTY3NpX0NtbmQgc3RydWN0dXJlIHRvIGhhdmUgcG9pbnRlcnMgcmVzZXQuCiAqLwoKc3RhdGljIF9faW5saW5lX18gdm9pZCBpbml0aWFsaXplX1NDcChTY3NpX0NtbmQgKmNtZCkKewogICAgLyogCiAgICAgKiBJbml0aWFsaXplIHRoZSBTY3NpIFBvaW50ZXIgZmllbGQgc28gdGhhdCBhbGwgb2YgdGhlIGNvbW1hbmRzIGluIHRoZSAKICAgICAqIHZhcmlvdXMgcXVldWVzIGFyZSB2YWxpZC4KICAgICAqLwoKICAgIGlmIChjbWQtPnVzZV9zZykgewoJY21kLT5TQ3AuYnVmZmVyID0gKHN0cnVjdCBzY2F0dGVybGlzdCAqKSBjbWQtPmJ1ZmZlcjsKCWNtZC0+U0NwLmJ1ZmZlcnNfcmVzaWR1YWwgPSBjbWQtPnVzZV9zZyAtIDE7CgljbWQtPlNDcC5wdHIgPSAoY2hhciAqKXBhZ2VfYWRkcmVzcyhjbWQtPlNDcC5idWZmZXItPnBhZ2UpKwoJCSAgICAgICBjbWQtPlNDcC5idWZmZXItPm9mZnNldDsKCWNtZC0+U0NwLnRoaXNfcmVzaWR1YWwgPSBjbWQtPlNDcC5idWZmZXItPmxlbmd0aDsKCS8qICsrcm9tYW46IFRyeSB0byBtZXJnZSBzb21lIHNjYXR0ZXItYnVmZmVycyBpZiB0aGV5IGFyZSBhdAoJICogY29udGlndW91cyBwaHlzaWNhbCBhZGRyZXNzZXMuCgkgKi8KCW1lcmdlX2NvbnRpZ3VvdXNfYnVmZmVycyggY21kICk7CiAgICB9IGVsc2UgewoJY21kLT5TQ3AuYnVmZmVyID0gTlVMTDsKCWNtZC0+U0NwLmJ1ZmZlcnNfcmVzaWR1YWwgPSAwOwoJY21kLT5TQ3AucHRyID0gKGNoYXIgKikgY21kLT5yZXF1ZXN0X2J1ZmZlcjsKCWNtZC0+U0NwLnRoaXNfcmVzaWR1YWwgPSBjbWQtPnJlcXVlc3RfYnVmZmxlbjsKICAgIH0KfQoKI2luY2x1ZGUgPGxpbnV4L2NvbmZpZy5oPgojaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KCiNpZiBOREVCVUcKc3RhdGljIHN0cnVjdCB7CiAgICB1bnNpZ25lZCBjaGFyIG1hc2s7CiAgICBjb25zdCBjaGFyICogbmFtZTt9IApzaWduYWxzW10gPSB7eyBTUl9EQlAsICJQQVJJVFkifSwgeyBTUl9SU1QsICJSU1QiIH0sIHsgU1JfQlNZLCAiQlNZIiB9LCAKICAgIHsgU1JfUkVRLCAiUkVRIiB9LCB7IFNSX01TRywgIk1TRyIgfSwgeyBTUl9DRCwgICJDRCIgfSwgeyBTUl9JTywgIklPIiB9LCAKICAgIHsgU1JfU0VMLCAiU0VMIiB9LCB7MCwgTlVMTH19LCAKYmFzcnNbXSA9IHt7QkFTUl9BVE4sICJBVE4ifSwge0JBU1JfQUNLLCAiQUNLIn0sIHswLCBOVUxMfX0sCmljcnNbXSA9IHt7SUNSX0FTU0VSVF9SU1QsICJBU1NFUlQgUlNUIn0se0lDUl9BU1NFUlRfQUNLLCAiQVNTRVJUIEFDSyJ9LAogICAge0lDUl9BU1NFUlRfQlNZLCAiQVNTRVJUIEJTWSJ9LCB7SUNSX0FTU0VSVF9TRUwsICJBU1NFUlQgU0VMIn0sIAogICAge0lDUl9BU1NFUlRfQVROLCAiQVNTRVJUIEFUTiJ9LCB7SUNSX0FTU0VSVF9EQVRBLCAiQVNTRVJUIERBVEEifSwgCiAgICB7MCwgTlVMTH19LAptcnNbXSA9IHt7TVJfQkxPQ0tfRE1BX01PREUsICJNT0RFIEJMT0NLIERNQSJ9LCB7TVJfVEFSR0VULCAiTU9ERSBUQVJHRVQifSwgCiAgICB7TVJfRU5BQkxFX1BBUl9DSEVDSywgIk1PREUgUEFSSVRZIENIRUNLIn0sIHtNUl9FTkFCTEVfUEFSX0lOVFIsIAogICAgIk1PREUgUEFSSVRZIElOVFIifSwge01SX0VOQUJMRV9FT1BfSU5UUiwiTU9ERSBFT1AgSU5UUiJ9LAogICAge01SX01PTklUT1JfQlNZLCAiTU9ERSBNT05JVE9SIEJTWSJ9LAogICAge01SX0RNQV9NT0RFLCAiTU9ERSBETUEifSwge01SX0FSQklUUkFURSwgIk1PREUgQVJCSVRSQVRJT04ifSwgCiAgICB7MCwgTlVMTH19OwoKLyoKICogRnVuY3Rpb24gOiB2b2lkIE5DUjUzODBfcHJpbnQoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCiAqCiAqIFB1cnBvc2UgOiBwcmludCB0aGUgU0NTSSBidXMgc2lnbmFscyBmb3IgZGVidWdnaW5nIHB1cnBvc2VzCiAqCiAqIElucHV0IDogaW5zdGFuY2UgLSB3aGljaCBOQ1I1MzgwCiAqLwoKc3RhdGljIHZvaWQgTkNSNTM4MF9wcmludChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkgewogICAgdW5zaWduZWQgY2hhciBzdGF0dXMsIGRhdGEsIGJhc3IsIG1yLCBpY3IsIGk7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwoKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIGRhdGEgPSBOQ1I1MzgwX3JlYWQoQ1VSUkVOVF9TQ1NJX0RBVEFfUkVHKTsKICAgIHN0YXR1cyA9IE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKTsKICAgIG1yID0gTkNSNTM4MF9yZWFkKE1PREVfUkVHKTsKICAgIGljciA9IE5DUjUzODBfcmVhZChJTklUSUFUT1JfQ09NTUFORF9SRUcpOwogICAgYmFzciA9IE5DUjUzODBfcmVhZChCVVNfQU5EX1NUQVRVU19SRUcpOwogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogICAgcHJpbnRrKCJTVEFUVVNfUkVHOiAlMDJ4ICIsIHN0YXR1cyk7CiAgICBmb3IgKGkgPSAwOyBzaWduYWxzW2ldLm1hc2sgOyArK2kpIAoJaWYgKHN0YXR1cyAmIHNpZ25hbHNbaV0ubWFzaykKCSAgICBwcmludGsoIiwlcyIsIHNpZ25hbHNbaV0ubmFtZSk7CiAgICBwcmludGsoIlxuQkFTUjogJTAyeCAiLCBiYXNyKTsKICAgIGZvciAoaSA9IDA7IGJhc3JzW2ldLm1hc2sgOyArK2kpIAoJaWYgKGJhc3IgJiBiYXNyc1tpXS5tYXNrKQoJICAgIHByaW50aygiLCVzIiwgYmFzcnNbaV0ubmFtZSk7CiAgICBwcmludGsoIlxuSUNSOiAlMDJ4ICIsIGljcik7CiAgICBmb3IgKGkgPSAwOyBpY3JzW2ldLm1hc2s7ICsraSkgCglpZiAoaWNyICYgaWNyc1tpXS5tYXNrKQoJICAgIHByaW50aygiLCVzIiwgaWNyc1tpXS5uYW1lKTsKICAgIHByaW50aygiXG5NT0RFOiAlMDJ4ICIsIG1yKTsKICAgIGZvciAoaSA9IDA7IG1yc1tpXS5tYXNrOyArK2kpIAoJaWYgKG1yICYgbXJzW2ldLm1hc2spCgkgICAgcHJpbnRrKCIsJXMiLCBtcnNbaV0ubmFtZSk7CiAgICBwcmludGsoIlxuIik7Cn0KCnN0YXRpYyBzdHJ1Y3QgewogICAgdW5zaWduZWQgY2hhciB2YWx1ZTsKICAgIGNvbnN0IGNoYXIgKm5hbWU7Cn0gcGhhc2VzW10gPSB7CiAgICB7UEhBU0VfREFUQU9VVCwgIkRBVEFPVVQifSwge1BIQVNFX0RBVEFJTiwgIkRBVEFJTiJ9LCB7UEhBU0VfQ01ET1VULCAiQ01ET1VUIn0sCiAgICB7UEhBU0VfU1RBVElOLCAiU1RBVElOIn0sIHtQSEFTRV9NU0dPVVQsICJNU0dPVVQifSwge1BIQVNFX01TR0lOLCAiTVNHSU4ifSwKICAgIHtQSEFTRV9VTktOT1dOLCAiVU5LTk9XTiJ9fTsKCi8qIAogKiBGdW5jdGlvbiA6IHZvaWQgTkNSNTM4MF9wcmludF9waGFzZShzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IHByaW50IHRoZSBjdXJyZW50IFNDU0kgcGhhc2UgZm9yIGRlYnVnZ2luZyBwdXJwb3NlcwogKgogKiBJbnB1dCA6IGluc3RhbmNlIC0gd2hpY2ggTkNSNTM4MAogKi8KCnN0YXRpYyB2b2lkIE5DUjUzODBfcHJpbnRfcGhhc2Uoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCnsKICAgIHVuc2lnbmVkIGNoYXIgc3RhdHVzOwogICAgaW50IGk7CgogICAgc3RhdHVzID0gTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpOwogICAgaWYgKCEoc3RhdHVzICYgU1JfUkVRKSkgCglwcmludGsoS0VSTl9ERUJVRyAic2NzaSVkOiBSRVEgbm90IGFzc2VydGVkLCBwaGFzZSB1bmtub3duLlxuIiwgSE9TVE5PKTsKICAgIGVsc2UgewoJZm9yIChpID0gMDsgKHBoYXNlc1tpXS52YWx1ZSAhPSBQSEFTRV9VTktOT1dOKSAmJiAKCSAgICAocGhhc2VzW2ldLnZhbHVlICE9IChzdGF0dXMgJiBQSEFTRV9NQVNLKSk7ICsraSk7IAoJcHJpbnRrKEtFUk5fREVCVUcgInNjc2klZDogcGhhc2UgJXNcbiIsIEhPU1ROTywgcGhhc2VzW2ldLm5hbWUpOwogICAgfQp9CgojZWxzZSAvKiAhTkRFQlVHICovCgovKiBkdW1taWVzLi4uICovCl9faW5saW5lX18gdm9pZCBOQ1I1MzgwX3ByaW50KHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKSB7IH07Cl9faW5saW5lX18gdm9pZCBOQ1I1MzgwX3ByaW50X3BoYXNlKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKSB7IH07CgojZW5kaWYKCi8qCiAqICsrcm9tYW46IE5ldyBzY2hlbWUgb2YgY2FsbGluZyBOQ1I1MzgwX21haW4oKQogKiAKICogSWYgd2UncmUgbm90IGluIGFuIGludGVycnVwdCwgd2UgY2FuIGNhbGwgb3VyIG1haW4gZGlyZWN0bHksIGl0IGNhbm5vdCBiZQogKiBhbHJlYWR5IHJ1bm5pbmcuIEVsc2UsIHdlIHF1ZXVlIGl0IG9uIGEgdGFzayBxdWV1ZSwgaWYgbm90ICdtYWluX3J1bm5pbmcnCiAqIHRlbGxzIHVzIHRoYXQgYSBsb3dlciBsZXZlbCBpcyBhbHJlYWR5IGV4ZWN1dGluZyBpdC4gVGhpcyB3YXksCiAqICdtYWluX3J1bm5pbmcnIG5lZWRzIG5vdCBiZSBwcm90ZWN0ZWQgaW4gYSBzcGVjaWFsIHdheS4KICoKICogcXVldWVfbWFpbigpIGlzIGEgdXRpbGl0eSBmdW5jdGlvbiBmb3IgcHV0dGluZyBvdXIgbWFpbiBvbnRvIHRoZSB0YXNrCiAqIHF1ZXVlLCBpZiBtYWluX3J1bm5pbmcgaXMgZmFsc2UuIEl0IHNob3VsZCBiZSBjYWxsZWQgb25seSBmcm9tIGEKICogaW50ZXJydXB0IG9yIGJvdHRvbSBoYWxmLgogKi8KCiNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgoKc3RhdGljIHZvbGF0aWxlIGludCBtYWluX3J1bm5pbmcgPSAwOwpzdGF0aWMgREVDTEFSRV9XT1JLKE5DUjUzODBfdHF1ZXVlLCAodm9pZCAoKikodm9pZCopKU5DUjUzODBfbWFpbiwgTlVMTCk7CgpzdGF0aWMgX19pbmxpbmVfXyB2b2lkIHF1ZXVlX21haW4odm9pZCkKewogICAgaWYgKCFtYWluX3J1bm5pbmcpIHsKCS8qIElmIGluIGludGVycnVwdCBhbmQgTkNSNTM4MF9tYWluKCkgbm90IGFscmVhZHkgcnVubmluZywKCSAgIHF1ZXVlIGl0IG9uIHRoZSAnaW1tZWRpYXRlJyB0YXNrIHF1ZXVlLCB0byBiZSBwcm9jZXNzZWQKCSAgIGltbWVkaWF0ZWx5IGFmdGVyIHRoZSBjdXJyZW50IGludGVycnVwdCBwcm9jZXNzaW5nIGhhcwoJICAgZmluaXNoZWQuICovCglzY2hlZHVsZV93b3JrKCZOQ1I1MzgwX3RxdWV1ZSk7CiAgICB9CiAgICAvKiBlbHNlOiBub3RoaW5nIHRvIGRvOiB0aGUgcnVubmluZyBOQ1I1MzgwX21haW4oKSB3aWxsIHBpY2sgdXAKICAgICAgIGFueSBuZXdseSBxdWV1ZWQgY29tbWFuZC4gKi8KfQoKCnN0YXRpYyBpbmxpbmUgdm9pZCBOQ1I1MzgwX2FsbF9pbml0ICh2b2lkKQp7CiAgICBzdGF0aWMgaW50IGRvbmUgPSAwOwogICAgaWYgKCFkb25lKSB7CglJTklfUFJJTlRLKCJzY3NpIDogTkNSNTM4MF9hbGxfaW5pdCgpXG4iKTsKCWRvbmUgPSAxOwogICAgfQp9CgogCi8qCiAqIEZ1bmN0aW9uIDogdm9pZCBOQ1I1ODM4MF9wcmludF9vcHRpb25zIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IGNhbGxlZCBieSBwcm9iZSBjb2RlIGluZGljYXRpbmcgdGhlIE5DUjUzODAgZHJpdmVyCiAqCSAgICAgb3B0aW9ucyB0aGF0IHdlcmUgc2VsZWN0ZWQuCiAqCiAqIElucHV0cyA6IGluc3RhbmNlLCBwb2ludGVyIHRvIHRoaXMgaW5zdGFuY2UuICBVbnVzZWQuCiAqLwoKc3RhdGljIHZvaWQgX19pbml0IE5DUjUzODBfcHJpbnRfb3B0aW9ucyAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCnsKICAgIHByaW50aygiIGdlbmVyaWMgb3B0aW9ucyIKI2lmZGVmIEFVVE9TRU5TRSAKICAgICIgQVVUT1NFTlNFIgojZW5kaWYKI2lmZGVmIFJFQUxfRE1BCiAgICAiIFJFQUwgRE1BIgojZW5kaWYKI2lmZGVmIFBBUklUWQogICAgIiBQQVJJVFkiCiNlbmRpZgojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICAiIFNDU0ktMiBUQUdHRUQgUVVFVUlORyIKI2VuZGlmCiAgICApOwogICAgcHJpbnRrKCIgZ2VuZXJpYyByZWxlYXNlPSVkIiwgTkNSNTM4MF9QVUJMSUNfUkVMRUFTRSk7Cn0KCi8qCiAqIEZ1bmN0aW9uIDogdm9pZCBOQ1I1MzgwX3ByaW50X3N0YXR1cyAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCiAqCiAqIFB1cnBvc2UgOiBwcmludCBjb21tYW5kcyBpbiB0aGUgdmFyaW91cyBxdWV1ZXMsIGNhbGxlZCBmcm9tCiAqCU5DUjUzODBfYWJvcnQgYW5kIE5DUjUzODBfZGVidWcgdG8gYWlkIGRlYnVnZ2luZy4KICoKICogSW5wdXRzIDogaW5zdGFuY2UsIHBvaW50ZXIgdG8gdGhpcyBpbnN0YW5jZS4gIAogKi8KCnN0YXRpYyB2b2lkIE5DUjUzODBfcHJpbnRfc3RhdHVzIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKewogICAgY2hhciAqcHJfYmZyOwogICAgY2hhciAqc3RhcnQ7CiAgICBpbnQgbGVuOwoKICAgIE5DUl9QUklOVChOREVCVUdfQU5ZKTsKICAgIE5DUl9QUklOVF9QSEFTRShOREVCVUdfQU5ZKTsKCiAgICBwcl9iZnIgPSAoY2hhciAqKSBfX2dldF9mcmVlX3BhZ2UoR0ZQX0FUT01JQyk7CiAgICBpZiAoIXByX2JmcikgewoJcHJpbnRrKCJOQ1I1MzgwX3ByaW50X3N0YXR1czogbm8gbWVtb3J5IGZvciBwcmludCBidWZmZXJcbiIpOwoJcmV0dXJuOwogICAgfQogICAgbGVuID0gTkNSNTM4MF9wcm9jX2luZm8ocHJfYmZyLCAmc3RhcnQsIDAsIFBBR0VfU0laRSwgSE9TVE5PLCAwKTsKICAgIHByX2JmcltsZW5dID0gMDsKICAgIHByaW50aygiXG4lc1xuIiwgcHJfYmZyKTsKICAgIGZyZWVfcGFnZSgodW5zaWduZWQgbG9uZykgcHJfYmZyKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi8qCiAqIC9wcm9jL3Njc2kvW2R0YyBwYXMxNiB0MTI4IGdlbmVyaWNdL1swLUFTQ19OVU1fQk9BUkRfU1VQUE9SVEVEXQogKgogKiAqYnVmZmVyOiBJL08gYnVmZmVyCiAqICoqc3RhcnQ6IGlmIGlub3V0ID09IEZBTFNFIHBvaW50ZXIgaW50byBidWZmZXIgd2hlcmUgdXNlciByZWFkIHNob3VsZCBzdGFydAogKiBvZmZzZXQ6IGN1cnJlbnQgb2Zmc2V0CiAqIGxlbmd0aDogbGVuZ3RoIG9mIGJ1ZmZlcgogKiBob3N0bm86IFNjc2lfSG9zdCBob3N0X25vCiAqIGlub3V0OiBUUlVFIC0gdXNlciBpcyB3cml0aW5nOyBGQUxTRSAtIHVzZXIgaXMgcmVhZGluZwogKgogKiBSZXR1cm4gdGhlIG51bWJlciBvZiBieXRlcyByZWFkIGZyb20gb3Igd3JpdHRlbgoqLwoKI3VuZGVmIFNQUklOVEYKI2RlZmluZSBTUFJJTlRGKGZtdCxhcmdzLi4uKSBcCiAgZG8geyBpZiAocG9zICsgc3RybGVuKGZtdCkgKyAyMCAvKiBzbG9wICovIDwgYnVmZmVyICsgbGVuZ3RoKSBcCgkgcG9zICs9IHNwcmludGYocG9zLCBmbXQgLCAjIyBhcmdzKTsgfSB3aGlsZSgwKQpzdGF0aWMKY2hhciAqbHByaW50X1Njc2lfQ21uZCAoU2NzaV9DbW5kICpjbWQsIGNoYXIgKnBvcywgY2hhciAqYnVmZmVyLCBpbnQgbGVuZ3RoKTsKCnN0YXRpYwppbnQgTkNSNTM4MF9wcm9jX2luZm8gKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlLCBjaGFyICpidWZmZXIsIGNoYXIgKipzdGFydCwgb2ZmX3Qgb2Zmc2V0LAoJCSAgICAgICBpbnQgbGVuZ3RoLCBpbnQgaW5vdXQpCnsKICAgIGNoYXIgKnBvcyA9IGJ1ZmZlcjsKICAgIHN0cnVjdCBOQ1I1MzgwX2hvc3RkYXRhICpob3N0ZGF0YTsKICAgIFNjc2lfQ21uZCAqcHRyOwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKICAgIG9mZl90IGJlZ2luID0gMDsKI2RlZmluZSBjaGVja19vZmZzZXQoKQkJCQlcCiAgICBkbyB7CQkJCQlcCglpZiAocG9zIC0gYnVmZmVyIDwgb2Zmc2V0IC0gYmVnaW4pIHsJXAoJICAgIGJlZ2luICs9IHBvcyAtIGJ1ZmZlcjsJCVwKCSAgICBwb3MgPSBidWZmZXI7CQkJXAoJfQkJCQkJXAogICAgfSB3aGlsZSAoMCkKCiAgICBob3N0ZGF0YSA9IChzdHJ1Y3QgTkNSNTM4MF9ob3N0ZGF0YSAqKWluc3RhbmNlLT5ob3N0ZGF0YTsKCiAgICBpZiAoaW5vdXQpIHsgLyogSGFzIGRhdGEgYmVlbiB3cml0dGVuIHRvIHRoZSBmaWxlID8gKi8KCXJldHVybigtRU5PU1lTKTsgIC8qIEN1cnJlbnRseSB0aGlzIGlzIGEgbm8tb3AgKi8KICAgIH0KICAgIFNQUklOVEYoIk5DUjUzODAgY29yZSByZWxlYXNlPSVkLlxuIiwgTkNSNTM4MF9QVUJMSUNfUkVMRUFTRSk7CiAgICBjaGVja19vZmZzZXQoKTsKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIFNQUklOVEYoIk5DUjUzODA6IGNvcm91dGluZSBpcyVzIHJ1bm5pbmcuXG4iLCBtYWluX3J1bm5pbmcgPyAiIiA6ICJuJ3QiKTsKICAgIGNoZWNrX29mZnNldCgpOwogICAgaWYgKCFob3N0ZGF0YS0+Y29ubmVjdGVkKQoJU1BSSU5URigic2NzaSVkOiBubyBjdXJyZW50bHkgY29ubmVjdGVkIGNvbW1hbmRcbiIsIEhPU1ROTyk7CiAgICBlbHNlCglwb3MgPSBscHJpbnRfU2NzaV9DbW5kICgoU2NzaV9DbW5kICopIGhvc3RkYXRhLT5jb25uZWN0ZWQsCgkJCQlwb3MsIGJ1ZmZlciwgbGVuZ3RoKTsKICAgIFNQUklOVEYoInNjc2klZDogaXNzdWVfcXVldWVcbiIsIEhPU1ROTyk7CiAgICBjaGVja19vZmZzZXQoKTsKICAgIGZvciAocHRyID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+aXNzdWVfcXVldWU7IHB0cjsgcHRyID0gTkVYVChwdHIpKSB7Cglwb3MgPSBscHJpbnRfU2NzaV9DbW5kIChwdHIsIHBvcywgYnVmZmVyLCBsZW5ndGgpOwoJY2hlY2tfb2Zmc2V0KCk7CiAgICB9CgogICAgU1BSSU5URigic2NzaSVkOiBkaXNjb25uZWN0ZWRfcXVldWVcbiIsIEhPU1ROTyk7CiAgICBjaGVja19vZmZzZXQoKTsKICAgIGZvciAocHRyID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlOyBwdHI7CgkgcHRyID0gTkVYVChwdHIpKSB7Cglwb3MgPSBscHJpbnRfU2NzaV9DbW5kIChwdHIsIHBvcywgYnVmZmVyLCBsZW5ndGgpOwoJY2hlY2tfb2Zmc2V0KCk7CiAgICB9CgogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogICAgKnN0YXJ0ID0gYnVmZmVyICsgKG9mZnNldCAtIGJlZ2luKTsKICAgIGlmIChwb3MgLSBidWZmZXIgPCBvZmZzZXQgLSBiZWdpbikKCXJldHVybiAwOwogICAgZWxzZSBpZiAocG9zIC0gYnVmZmVyIC0gKG9mZnNldCAtIGJlZ2luKSA8IGxlbmd0aCkKCXJldHVybiBwb3MgLSBidWZmZXIgLSAob2Zmc2V0IC0gYmVnaW4pOwogICAgcmV0dXJuIGxlbmd0aDsKfQoKc3RhdGljIGNoYXIgKgpscHJpbnRfU2NzaV9DbW5kIChTY3NpX0NtbmQgKmNtZCwgY2hhciAqcG9zLCBjaGFyICpidWZmZXIsIGludCBsZW5ndGgpCnsKICAgIGludCBpLCBzOwogICAgdW5zaWduZWQgY2hhciAqY29tbWFuZDsKICAgIFNQUklOVEYoInNjc2klZDogZGVzdGluYXRpb24gdGFyZ2V0ICVkLCBsdW4gJWRcbiIsCgkgICAgSF9OTyhjbWQpLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwogICAgU1BSSU5URigiICAgICAgICBjb21tYW5kID0gIik7CiAgICBjb21tYW5kID0gY21kLT5jbW5kOwogICAgU1BSSU5URigiJTJkICgweCUwMngpIiwgY29tbWFuZFswXSwgY29tbWFuZFswXSk7CiAgICBmb3IgKGkgPSAxLCBzID0gQ09NTUFORF9TSVpFKGNvbW1hbmRbMF0pOyBpIDwgczsgKytpKQoJU1BSSU5URigiICUwMngiLCBjb21tYW5kW2ldKTsKICAgIFNQUklOVEYoIlxuIik7CiAgICByZXR1cm4gcG9zOwp9CgoKLyogCiAqIEZ1bmN0aW9uIDogdm9pZCBOQ1I1MzgwX2luaXQgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQogKgogKiBQdXJwb3NlIDogaW5pdGlhbGl6ZXMgKmluc3RhbmNlIGFuZCBjb3JyZXNwb25kaW5nIDUzODAgY2hpcC4KICoKICogSW5wdXRzIDogaW5zdGFuY2UgLSBpbnN0YW50aWF0aW9uIG9mIHRoZSA1MzgwIGRyaXZlci4gIAogKgogKiBOb3RlcyA6IEkgYXNzdW1lIHRoYXQgdGhlIGhvc3QsIGhvc3RubywgYW5kIGlkIGJpdHMgaGF2ZSBiZWVuCiAqIAlzZXQgY29ycmVjdGx5LiAgSSBkb24ndCBjYXJlIGFib3V0IHRoZSBpcnEgYW5kIG90aGVyIGZpZWxkcy4gCiAqIAogKi8KCnN0YXRpYyBpbnQgTkNSNTM4MF9pbml0IChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSwgaW50IGZsYWdzKQp7CiAgICBpbnQgaTsKICAgIFNFVFVQX0hPU1REQVRBKGluc3RhbmNlKTsKCiAgICBOQ1I1MzgwX2FsbF9pbml0KCk7CgogICAgaG9zdGRhdGEtPmFib3J0ZWQgPSAwOwogICAgaG9zdGRhdGEtPmlkX21hc2sgPSAxIDw8IGluc3RhbmNlLT50aGlzX2lkOwogICAgaG9zdGRhdGEtPmlkX2hpZ2hlcl9tYXNrID0gMDsKICAgIGZvciAoaSA9IGhvc3RkYXRhLT5pZF9tYXNrOyBpIDw9IDB4ODA7IGkgPDw9IDEpCglpZiAoaSA+IGhvc3RkYXRhLT5pZF9tYXNrKQoJICAgIGhvc3RkYXRhLT5pZF9oaWdoZXJfbWFzayB8PSBpOwogICAgZm9yIChpID0gMDsgaSA8IDg7ICsraSkKCWhvc3RkYXRhLT5idXN5W2ldID0gMDsKI2lmZGVmIFNVUFBPUlRfVEFHUwogICAgaW5pdF90YWdzKCk7CiNlbmRpZgojaWYgZGVmaW5lZCAoUkVBTF9ETUEpCiAgICBob3N0ZGF0YS0+ZG1hX2xlbiA9IDA7CiNlbmRpZgogICAgaG9zdGRhdGEtPnRhcmdldHNfcHJlc2VudCA9IDA7CiAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gTlVMTDsKICAgIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSA9IE5VTEw7CiAgICBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlID0gTlVMTDsKICAgIGhvc3RkYXRhLT5mbGFncyA9IEZMQUdfQ0hFQ0tfTEFTVF9CWVRFX1NFTlQ7CgogICAgaWYgKCF0aGVfdGVtcGxhdGUpIHsKCXRoZV90ZW1wbGF0ZSA9IGluc3RhbmNlLT5ob3N0dDsKCWZpcnN0X2luc3RhbmNlID0gaW5zdGFuY2U7CiAgICB9CgkKCiNpZm5kZWYgQVVUT1NFTlNFCiAgICBpZiAoKGluc3RhbmNlLT5jbWRfcGVyX2x1biA+IDEpIHx8IChpbnN0YW5jZS0+Y2FuX3F1ZXVlID4gMSkpCgkgcHJpbnRrKCJzY3NpJWQ6IFdBUk5JTkcgOiBzdXBwb3J0IGZvciBtdWx0aXBsZSBvdXRzdGFuZGluZyBjb21tYW5kcyBlbmFibGVkXG4iCgkgICAgICAgICIgICAgICAgIHdpdGhvdXQgQVVUT1NFTlNFIG9wdGlvbiwgY29udGluZ2VudCBhbGxlZ2lhbmNlIGNvbmRpdGlvbnMgbWF5XG4iCgkgICAgICAgICIgICAgICAgIGJlIGluY29ycmVjdGx5IGNsZWFyZWQuXG4iLCBIT1NUTk8pOwojZW5kaWYgLyogZGVmIEFVVE9TRU5TRSAqLwoKICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CiAgICBOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9CQVNFKTsKICAgIE5DUjUzODBfd3JpdGUoVEFSR0VUX0NPTU1BTkRfUkVHLCAwKTsKICAgIE5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIDApOwoKICAgIHJldHVybiAwOwp9CgovKiAKICogRnVuY3Rpb24gOiBpbnQgTkNSNTM4MF9xdWV1ZV9jb21tYW5kIChTY3NpX0NtbmQgKmNtZCwgCiAqCXZvaWQgKCpkb25lKShTY3NpX0NtbmQgKikpIAogKgogKiBQdXJwb3NlIDogIGVucXVldWVzIGEgU0NTSSBjb21tYW5kCiAqCiAqIElucHV0cyA6IGNtZCAtIFNDU0kgY29tbWFuZCwgZG9uZSAtIGZ1bmN0aW9uIGNhbGxlZCBvbiBjb21wbGV0aW9uLCB3aXRoCiAqCWEgcG9pbnRlciB0byB0aGUgY29tbWFuZCBkZXNjcmlwdG9yLgogKiAKICogUmV0dXJucyA6IDAKICoKICogU2lkZSBlZmZlY3RzIDogCiAqICAgICAgY21kIGlzIGFkZGVkIHRvIHRoZSBwZXIgaW5zdGFuY2UgaXNzdWVfcXVldWUsIHdpdGggbWlub3IgCiAqCXR3aWRkbGluZyBkb25lIHRvIHRoZSBob3N0IHNwZWNpZmljIGZpZWxkcyBvZiBjbWQuICBJZiB0aGUgCiAqCW1haW4gY29yb3V0aW5lIGlzIG5vdCBydW5uaW5nLCBpdCBpcyByZXN0YXJ0ZWQuCiAqCiAqLwoKc3RhdGljCmludCBOQ1I1MzgwX3F1ZXVlX2NvbW1hbmQgKFNjc2lfQ21uZCAqY21kLCB2b2lkICgqZG9uZSkoU2NzaV9DbW5kICopKQp7CiAgICBTRVRVUF9IT1NUREFUQShjbWQtPmRldmljZS0+aG9zdCk7CiAgICBTY3NpX0NtbmQgKnRtcDsKICAgIGludCBvbGR0bzsKICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAgICBleHRlcm4gaW50IHVwZGF0ZV90aW1lb3V0KFNjc2lfQ21uZCAqIFNDc2V0LCBpbnQgdGltZW91dCk7CgojaWYgKE5ERUJVRyAmIE5ERUJVR19OT19XUklURSkKICAgIHN3aXRjaCAoY21kLT5jbW5kWzBdKSB7CiAgICBjYXNlIFdSSVRFXzY6CiAgICBjYXNlIFdSSVRFXzEwOgoJcHJpbnRrKEtFUk5fTk9USUNFICJzY3NpJWQ6IFdSSVRFIGF0dGVtcHRlZCB3aXRoIE5PX1dSSVRFIGRlYnVnZ2luZyBmbGFnIHNldFxuIiwKCSAgICAgICBIX05PKGNtZCkpOwoJY21kLT5yZXN1bHQgPSAoRElEX0VSUk9SIDw8IDE2KTsKCWRvbmUoY21kKTsKCXJldHVybiAwOwogICAgfQojZW5kaWYgLyogKE5ERUJVRyAmIE5ERUJVR19OT19XUklURSkgKi8KCgojaWZkZWYgTkNSNTM4MF9TVEFUUwojIGlmIDAKICAgIGlmICghaG9zdGRhdGEtPmNvbm5lY3RlZCAmJiAhaG9zdGRhdGEtPmlzc3VlX3F1ZXVlICYmCgkhaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSkgewoJaG9zdGRhdGEtPnRpbWViYXNlID0gamlmZmllczsKICAgIH0KIyBlbmRpZgojIGlmZGVmIE5DUjUzODBfU1RBVF9MSU1JVAogICAgaWYgKGNtZC0+cmVxdWVzdF9idWZmbGVuID4gTkNSNTM4MF9TVEFUX0xJTUlUKQojIGVuZGlmCglzd2l0Y2ggKGNtZC0+Y21uZFswXSkKCXsKCSAgICBjYXNlIFdSSVRFOgoJICAgIGNhc2UgV1JJVEVfNjoKCSAgICBjYXNlIFdSSVRFXzEwOgoJCWhvc3RkYXRhLT50aW1lX3dyaXRlW2NtZC0+ZGV2aWNlLT5pZF0gLT0gKGppZmZpZXMgLSBob3N0ZGF0YS0+dGltZWJhc2UpOwoJCWhvc3RkYXRhLT5ieXRlc193cml0ZVtjbWQtPmRldmljZS0+aWRdICs9IGNtZC0+cmVxdWVzdF9idWZmbGVuOwoJCWhvc3RkYXRhLT5wZW5kaW5ndysrOwoJCWJyZWFrOwoJICAgIGNhc2UgUkVBRDoKCSAgICBjYXNlIFJFQURfNjoKCSAgICBjYXNlIFJFQURfMTA6CgkJaG9zdGRhdGEtPnRpbWVfcmVhZFtjbWQtPmRldmljZS0+aWRdIC09IChqaWZmaWVzIC0gaG9zdGRhdGEtPnRpbWViYXNlKTsKCQlob3N0ZGF0YS0+Ynl0ZXNfcmVhZFtjbWQtPmRldmljZS0+aWRdICs9IGNtZC0+cmVxdWVzdF9idWZmbGVuOwoJCWhvc3RkYXRhLT5wZW5kaW5ncisrOwoJCWJyZWFrOwoJfQojZW5kaWYKCiAgICAvKiAKICAgICAqIFdlIHVzZSB0aGUgaG9zdF9zY3JpYmJsZSBmaWVsZCBhcyBhIHBvaW50ZXIgdG8gdGhlIG5leHQgY29tbWFuZCAgCiAgICAgKiBpbiBhIHF1ZXVlIAogICAgICovCgogICAgTkVYVChjbWQpID0gTlVMTDsKICAgIGNtZC0+c2NzaV9kb25lID0gZG9uZTsKCiAgICBjbWQtPnJlc3VsdCA9IDA7CgoKICAgIC8qIAogICAgICogSW5zZXJ0IHRoZSBjbWQgaW50byB0aGUgaXNzdWUgcXVldWUuIE5vdGUgdGhhdCBSRVFVRVNUIFNFTlNFIAogICAgICogY29tbWFuZHMgYXJlIGFkZGVkIHRvIHRoZSBoZWFkIG9mIHRoZSBxdWV1ZSBzaW5jZSBhbnkgY29tbWFuZCB3aWxsCiAgICAgKiBjbGVhciB0aGUgY29udGluZ2VudCBhbGxlZ2lhbmNlIGNvbmRpdGlvbiB0aGF0IGV4aXN0cyBhbmQgdGhlIAogICAgICogc2Vuc2UgZGF0YSBpcyBvbmx5IGd1YXJhbnRlZWQgdG8gYmUgdmFsaWQgd2hpbGUgdGhlIGNvbmRpdGlvbiBleGlzdHMuCiAgICAgKi8KCiAgICBsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAgICAvKiArK2d1ZW50aGVyOiBub3cgdGhhdCB0aGUgaXNzdWUgcXVldWUgaXMgYmVpbmcgc2V0IHVwLCB3ZSBjYW4gbG9jayBTVC1ETUEuCiAgICAgKiBPdGhlcndpc2UgYSBydW5uaW5nIE5DUjUzODBfbWFpbiBtYXkgc3RlYWwgdGhlIGxvY2suCiAgICAgKiBMb2NrIGJlZm9yZSBhY3R1YWxseSBpbnNlcnRpbmcgZHVlIHRvIGZhaXJuZXNzIHJlYXNvbnMgZXhwbGFpbmVkIGluCiAgICAgKiBhdGFyaV9zY3NpLmMuIElmIHdlIGluc2VydCBmaXJzdCwgdGhlbiBpdCdzIGltcG9zc2libGUgZm9yIHRoaXMgZHJpdmVyCiAgICAgKiB0byByZWxlYXNlIHRoZSBsb2NrLgogICAgICogU3RvcCB0aW1lciBmb3IgdGhpcyBjb21tYW5kIHdoaWxlIHdhaXRpbmcgZm9yIHRoZSBsb2NrLCBvciB0aW1lb3V0cwogICAgICogbWF5IGhhcHBlbiAoYW5kIHRoZXkgcmVhbGx5IGRvKSwgYW5kIGl0J3Mgbm8gZ29vZCBpZiB0aGUgY29tbWFuZCBkb2Vzbid0CiAgICAgKiBhcHBlYXIgaW4gYW55IG9mIHRoZSBxdWV1ZXMuCiAgICAgKiArK3JvbWFuOiBKdXN0IGRpc2FibGluZyB0aGUgTkNSIGludGVycnVwdCBpc24ndCBzdWZmaWNpZW50IGhlcmUsCiAgICAgKiBiZWNhdXNlIGFsc28gYSB0aW1lciBpbnQgY2FuIHRyaWdnZXIgYW4gYWJvcnQgb3IgcmVzZXQsIHdoaWNoIHdvdWxkCiAgICAgKiBhbHRlciBxdWV1ZXMgYW5kIHRvdWNoIHRoZSBsb2NrLgogICAgICovCiAgICBpZiAoIUlTX0FfVFQoKSkgewoJb2xkdG8gPSB1cGRhdGVfdGltZW91dChjbWQsIDApOwoJZmFsY29uX2dldF9sb2NrKCk7Cgl1cGRhdGVfdGltZW91dChjbWQsIG9sZHRvKTsKICAgIH0KICAgIGlmICghKGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSkgfHwgKGNtZC0+Y21uZFswXSA9PSBSRVFVRVNUX1NFTlNFKSkgewoJTElTVChjbWQsIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSk7CglORVhUKGNtZCkgPSBob3N0ZGF0YS0+aXNzdWVfcXVldWU7Cglob3N0ZGF0YS0+aXNzdWVfcXVldWUgPSBjbWQ7CiAgICB9IGVsc2UgewoJZm9yICh0bXAgPSAoU2NzaV9DbW5kICopaG9zdGRhdGEtPmlzc3VlX3F1ZXVlOwoJICAgICBORVhUKHRtcCk7IHRtcCA9IE5FWFQodG1wKSkKCSAgICA7CglMSVNUKGNtZCwgdG1wKTsKCU5FWFQodG1wKSA9IGNtZDsKICAgIH0KICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCiAgICBRVV9QUklOVEsoInNjc2klZDogY29tbWFuZCBhZGRlZCB0byAlcyBvZiBxdWV1ZVxuIiwgSF9OTyhjbWQpLAoJICAgICAgKGNtZC0+Y21uZFswXSA9PSBSRVFVRVNUX1NFTlNFKSA/ICJoZWFkIiA6ICJ0YWlsIik7CgogICAgLyogSWYgcXVldWVfY29tbWFuZCgpIGlzIGNhbGxlZCBmcm9tIGFuIGludGVycnVwdCAocmVhbCBvbmUgb3IgYm90dG9tCiAgICAgKiBoYWxmKSwgd2UgbGV0IHF1ZXVlX21haW4oKSBkbyB0aGUgam9iIG9mIHRha2luZyBjYXJlIGFib3V0IG1haW4uIElmIGl0CiAgICAgKiBpcyBhbHJlYWR5IHJ1bm5pbmcsIHRoaXMgaXMgYSBuby1vcCwgZWxzZSBtYWluIHdpbGwgYmUgcXVldWVkLgogICAgICoKICAgICAqIElmIHdlJ3JlIG5vdCBpbiBhbiBpbnRlcnJ1cHQsIHdlIGNhbiBjYWxsIE5DUjUzODBfbWFpbigpCiAgICAgKiB1bmNvbmRpdGlvbmFsbHksIGJlY2F1c2UgaXQgY2Fubm90IGJlIGFscmVhZHkgcnVubmluZy4KICAgICAqLwogICAgaWYgKGluX2ludGVycnVwdCgpIHx8ICgoZmxhZ3MgPj4gOCkgJiA3KSA+PSA2KQoJcXVldWVfbWFpbigpOwogICAgZWxzZQoJTkNSNTM4MF9tYWluKE5VTEwpOwogICAgcmV0dXJuIDA7Cn0KCi8qCiAqIEZ1bmN0aW9uIDogTkNSNTM4MF9tYWluICh2b2lkKSAKICoKICogUHVycG9zZSA6IE5DUjUzODBfbWFpbiBpcyBhIGNvcm91dGluZSB0aGF0IHJ1bnMgYXMgbG9uZyBhcyBtb3JlIHdvcmsgY2FuIAogKgliZSBkb25lIG9uIHRoZSBOQ1I1MzgwIGhvc3QgYWRhcHRlcnMgaW4gYSBzeXN0ZW0uICBCb3RoIAogKglOQ1I1MzgwX3F1ZXVlX2NvbW1hbmQoKSBhbmQgTkNSNTM4MF9pbnRyKCkgd2lsbCB0cnkgdG8gc3RhcnQgaXQgCiAqCWluIGNhc2UgaXQgaXMgbm90IHJ1bm5pbmcuCiAqIAogKiBOT1RFIDogTkNSNTM4MF9tYWluIGV4aXRzIHdpdGggaW50ZXJydXB0cyAqZGlzYWJsZWQqLCB0aGUgY2FsbGVyIHNob3VsZCAKICogIHJlZW5hYmxlIHRoZW0uICBUaGlzIHByZXZlbnRzIHJlZW50cmFuY3kgYW5kIGtlcm5lbCBzdGFjayBvdmVyZmxvdy4KICovIAkKICAgIApzdGF0aWMgdm9pZCBOQ1I1MzgwX21haW4gKHZvaWQgKmJsKQp7CiAgICBTY3NpX0NtbmQgKnRtcCwgKnByZXY7CiAgICBzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSA9IGZpcnN0X2luc3RhbmNlOwogICAgc3RydWN0IE5DUjUzODBfaG9zdGRhdGEgKmhvc3RkYXRhID0gSE9TVERBVEEoaW5zdGFuY2UpOwogICAgaW50IGRvbmU7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwogICAgCiAgICAvKgogICAgICogV2UgcnVuICh3aXRoIGludGVycnVwdHMgZGlzYWJsZWQpIHVudGlsIHdlJ3JlIHN1cmUgdGhhdCBub25lIG9mIAogICAgICogdGhlIGhvc3QgYWRhcHRlcnMgaGF2ZSBhbnl0aGluZyB0aGF0IGNhbiBiZSBkb25lLCBhdCB3aGljaCBwb2ludCAKICAgICAqIHdlIHNldCBtYWluX3J1bm5pbmcgdG8gMCBhbmQgZXhpdC4KICAgICAqCiAgICAgKiBJbnRlcnJ1cHRzIGFyZSBlbmFibGVkIGJlZm9yZSBkb2luZyB2YXJpb3VzIG90aGVyIGludGVybmFsIAogICAgICogaW5zdHJ1Y3Rpb25zLCBhZnRlciB3ZSd2ZSBkZWNpZGVkIHRoYXQgd2UgbmVlZCB0byBydW4gdGhyb3VnaAogICAgICogdGhlIGxvb3AgYWdhaW4uCiAgICAgKgogICAgICogdGhpcyBzaG91bGQgcHJldmVudCBhbnkgcmFjZSBjb25kaXRpb25zLgogICAgICogCiAgICAgKiArK3JvbWFuOiBKdXN0IGRpc2FibGluZyB0aGUgTkNSIGludGVycnVwdCBpc24ndCBzdWZmaWNpZW50IGhlcmUsCiAgICAgKiBiZWNhdXNlIGFsc28gYSB0aW1lciBpbnQgY2FuIHRyaWdnZXIgYW4gYWJvcnQgb3IgcmVzZXQsIHdoaWNoIGNhbgogICAgICogYWx0ZXIgcXVldWVzIGFuZCB0b3VjaCB0aGUgRmFsY29uIGxvY2suCiAgICAgKi8KCiAgICAvKiBUZWxsIGludCBoYW5kbGVycyBtYWluKCkgaXMgbm93IGFscmVhZHkgZXhlY3V0aW5nLiAgTm90ZSB0aGF0CiAgICAgICBubyByYWNlcyBhcmUgcG9zc2libGUgaGVyZS4gSWYgYW4gaW50IGNvbWVzIGluIGJlZm9yZQogICAgICAgJ21haW5fcnVubmluZycgaXMgc2V0IGhlcmUsIGFuZCBxdWV1ZXMvZXhlY3V0ZXMgbWFpbiB2aWEgdGhlCiAgICAgICB0YXNrIHF1ZXVlLCBpdCBkb2Vzbid0IGRvIGFueSBoYXJtLCBqdXN0IHRoaXMgaW5zdGFuY2Ugb2YgbWFpbgogICAgICAgd29uJ3QgZmluZCBhbnkgd29yayBsZWZ0IHRvIGRvLiAqLwogICAgaWYgKG1haW5fcnVubmluZykKICAgIAlyZXR1cm47CiAgICBtYWluX3J1bm5pbmcgPSAxOwoKICAgIGxvY2FsX3NhdmVfZmxhZ3MoZmxhZ3MpOwogICAgZG8gewoJbG9jYWxfaXJxX2Rpc2FibGUoKTsgLyogRnJlZXplIHJlcXVlc3QgcXVldWVzICovCglkb25lID0gMTsKCQoJaWYgKCFob3N0ZGF0YS0+Y29ubmVjdGVkKSB7CgkgICAgTUFJTl9QUklOVEsoICJzY3NpJWQ6IG5vdCBjb25uZWN0ZWRcbiIsIEhPU1ROTyApOwoJICAgIC8qCgkgICAgICogU2VhcmNoIHRocm91Z2ggdGhlIGlzc3VlX3F1ZXVlIGZvciBhIGNvbW1hbmQgZGVzdGluZWQKCSAgICAgKiBmb3IgYSB0YXJnZXQgdGhhdCdzIG5vdCBidXN5LgoJICAgICAqLwojaWYgKE5ERUJVRyAmIE5ERUJVR19MSVNUUykKCSAgICBmb3IgKHRtcCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlLCBwcmV2ID0gTlVMTDsKCQkgdG1wICYmICh0bXAgIT0gcHJldik7IHByZXYgPSB0bXAsIHRtcCA9IE5FWFQodG1wKSkKCQk7CgkJLypwcmludGsoIiVwICAiLCB0bXApOyovCgkgICAgaWYgKCh0bXAgPT0gcHJldikgJiYgdG1wKSBwcmludGsoIiBMT09QXG4iKTsvKiBlbHNlIHByaW50aygiXG4iKTsqLwojZW5kaWYKCSAgICBmb3IgKHRtcCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlLCAKCQkgcHJldiA9IE5VTEw7IHRtcDsgcHJldiA9IHRtcCwgdG1wID0gTkVYVCh0bXApICkgewoKI2lmIChOREVCVUcgJiBOREVCVUdfTElTVFMpCgkJaWYgKHByZXYgIT0gdG1wKQoJCSAgICBwcmludGsoIk1BSU4gdG1wPSVwICAgdGFyZ2V0PSVkICAgYnVzeT0lZCBsdW49JWRcbiIsCgkJCSAgIHRtcCwgdG1wLT5kZXZpY2UtPmlkLCBob3N0ZGF0YS0+YnVzeVt0bXAtPmRldmljZS0+aWRdLAoJCQkgICB0bXAtPmRldmljZS0+bHVuKTsKI2VuZGlmCgkJLyogIFdoZW4gd2UgZmluZCBvbmUsIHJlbW92ZSBpdCBmcm9tIHRoZSBpc3N1ZSBxdWV1ZS4gKi8KCQkvKiArK2d1ZW50aGVyOiBwb3NzaWJsZSByYWNlIHdpdGggRmFsY29uIGxvY2tpbmcgKi8KCQlpZiAoCiNpZmRlZiBTVVBQT1JUX1RBR1MKCQkgICAgIWlzX2x1bl9idXN5KCB0bXAsIHRtcC0+Y21uZFswXSAhPSBSRVFVRVNUX1NFTlNFKQojZWxzZQoJCSAgICAhKGhvc3RkYXRhLT5idXN5W3RtcC0+ZGV2aWNlLT5pZF0gJiAoMSA8PCB0bXAtPmRldmljZS0+bHVuKSkKI2VuZGlmCgkJICAgICkgewoJCSAgICAvKiArK2d1ZW50aGVyOiBqdXN0IHRvIGJlIHN1cmUsIHRoaXMgbXVzdCBiZSBhdG9taWMgKi8KCQkgICAgbG9jYWxfaXJxX2Rpc2FibGUoKTsKCQkgICAgaWYgKHByZXYpIHsKCQkgICAgICAgIFJFTU9WRShwcmV2LCBORVhUKHByZXYpLCB0bXAsIE5FWFQodG1wKSk7CgkJCU5FWFQocHJldikgPSBORVhUKHRtcCk7CgkJICAgIH0gZWxzZSB7CgkJICAgICAgICBSRU1PVkUoLTEsIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSwgdG1wLCBORVhUKHRtcCkpOwoJCQlob3N0ZGF0YS0+aXNzdWVfcXVldWUgPSBORVhUKHRtcCk7CgkJICAgIH0KCQkgICAgTkVYVCh0bXApID0gTlVMTDsKCQkgICAgZmFsY29uX2RvbnRfcmVsZWFzZSsrOwoJCSAgICAKCQkgICAgLyogcmVlbmFibGUgaW50ZXJydXB0cyBhZnRlciBmaW5kaW5nIG9uZSAqLwoJCSAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkJICAgIAoJCSAgICAvKiAKCQkgICAgICogQXR0ZW1wdCB0byBlc3RhYmxpc2ggYW4gSV9UX0wgbmV4dXMgaGVyZS4gCgkJICAgICAqIE9uIHN1Y2Nlc3MsIGluc3RhbmNlLT5ob3N0ZGF0YS0+Y29ubmVjdGVkIGlzIHNldC4KCQkgICAgICogT24gZmFpbHVyZSwgd2UgbXVzdCBhZGQgdGhlIGNvbW1hbmQgYmFjayB0byB0aGUKCQkgICAgICogICBpc3N1ZSBxdWV1ZSBzbyB3ZSBjYW4ga2VlcCB0cnlpbmcuCQoJCSAgICAgKi8KCQkgICAgTUFJTl9QUklOVEsoInNjc2klZDogbWFpbigpOiBjb21tYW5kIGZvciB0YXJnZXQgJWQgIgoJCQkJImx1biAlZCByZW1vdmVkIGZyb20gaXNzdWVfcXVldWVcbiIsCgkJCQlIT1NUTk8sIHRtcC0+ZGV2aWNlLT5pZCwgdG1wLT5kZXZpY2UtPmx1bik7CgkJICAgIC8qIAoJCSAgICAgKiBSRVFVRVNUIFNFTlNFIGNvbW1hbmRzIGFyZSBpc3N1ZWQgd2l0aG91dCB0YWdnZWQKCQkgICAgICogcXVldWVpbmcsIGV2ZW4gb24gU0NTSS1JSSBkZXZpY2VzIGJlY2F1c2UgdGhlIAoJCSAgICAgKiBjb250aW5nZW50IGFsbGVnaWFuY2UgY29uZGl0aW9uIGV4aXN0cyBmb3IgdGhlIAoJCSAgICAgKiBlbnRpcmUgdW5pdC4KCQkgICAgICovCgkJICAgIC8qICsrcm9tYW46IC4uLmFuZCB0aGUgc3RhbmRhcmQgYWxzbyByZXF1aXJlcyB0aGF0CgkJICAgICAqIFJFUVVFU1QgU0VOU0UgY29tbWFuZCBhcmUgdW50YWdnZWQuCgkJICAgICAqLwoJCSAgICAKI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSAgICBjbWRfZ2V0X3RhZyggdG1wLCB0bXAtPmNtbmRbMF0gIT0gUkVRVUVTVF9TRU5TRSApOwojZW5kaWYKCQkgICAgaWYgKCFOQ1I1MzgwX3NlbGVjdChpbnN0YW5jZSwgdG1wLCAKCQkJICAgICh0bXAtPmNtbmRbMF0gPT0gUkVRVUVTVF9TRU5TRSkgPyBUQUdfTk9ORSA6IAoJCQkgICAgVEFHX05FWFQpKSB7CgkJCWZhbGNvbl9kb250X3JlbGVhc2UtLTsKCQkJLyogcmVsZWFzZSBpZiB0YXJnZXQgZGlkIG5vdCByZXNwb25zZSEgKi8KCQkJZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsKCQkJYnJlYWs7CgkJICAgIH0gZWxzZSB7CgkJCWxvY2FsX2lycV9kaXNhYmxlKCk7CgkJCUxJU1QodG1wLCBob3N0ZGF0YS0+aXNzdWVfcXVldWUpOwoJCQlORVhUKHRtcCkgPSBob3N0ZGF0YS0+aXNzdWVfcXVldWU7CgkJCWhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSA9IHRtcDsKI2lmZGVmIFNVUFBPUlRfVEFHUwoJCQljbWRfZnJlZV90YWcoIHRtcCApOwojZW5kaWYKCQkJZmFsY29uX2RvbnRfcmVsZWFzZS0tOwoJCQlsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkJCU1BSU5fUFJJTlRLKCJzY3NpJWQ6IG1haW4oKTogc2VsZWN0KCkgZmFpbGVkLCAiCgkJCQkgICAgInJldHVybmVkIHRvIGlzc3VlX3F1ZXVlXG4iLCBIT1NUTk8pOwoJCQlpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCkKCQkJICAgIGJyZWFrOwoJCSAgICB9CgkJfSAvKiBpZiB0YXJnZXQvbHVuL3RhcmdldCBxdWV1ZSBpcyBub3QgYnVzeSAqLwoJICAgIH0gLyogZm9yIGlzc3VlX3F1ZXVlICovCgl9IC8qIGlmICghaG9zdGRhdGEtPmNvbm5lY3RlZCkgKi8KCQkKCWlmIChob3N0ZGF0YS0+Y29ubmVjdGVkIAojaWZkZWYgUkVBTF9ETUEKCSAgICAmJiAhaG9zdGRhdGEtPmRtYV9sZW4KI2VuZGlmCgkgICAgKSB7CgkgICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJICAgIE1BSU5fUFJJTlRLKCJzY3NpJWQ6IG1haW46IHBlcmZvcm1pbmcgaW5mb3JtYXRpb24gdHJhbnNmZXJcbiIsCgkJCUhPU1ROTyk7CgkgICAgTkNSNTM4MF9pbmZvcm1hdGlvbl90cmFuc2ZlcihpbnN0YW5jZSk7CgkgICAgTUFJTl9QUklOVEsoInNjc2klZDogbWFpbjogZG9uZSBzZXQgZmFsc2VcbiIsIEhPU1ROTyk7CgkgICAgZG9uZSA9IDA7Cgl9CiAgICB9IHdoaWxlICghZG9uZSk7CgogICAgLyogQmV0dGVyIGFsbG93IGludHMgX2FmdGVyXyAnbWFpbl9ydW5uaW5nJyBoYXMgYmVlbiBjbGVhcmVkLCBlbHNlCiAgICAgICBhbiBpbnRlcnJ1cHQgY291bGQgYmVsaWV2ZSB3ZSdsbCBwaWNrIHVwIHRoZSB3b3JrIGl0IGxlZnQgZm9yCiAgICAgICB1cywgYnV0IHdlIHdvbid0IHNlZSBpdCBhbnltb3JlIGhlcmUuLi4gKi8KICAgIG1haW5fcnVubmluZyA9IDA7CiAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7Cn0KCgojaWZkZWYgUkVBTF9ETUEKLyoKICogRnVuY3Rpb24gOiB2b2lkIE5DUjUzODBfZG1hX2NvbXBsZXRlIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IENhbGxlZCBieSBpbnRlcnJ1cHQgaGFuZGxlciB3aGVuIERNQSBmaW5pc2hlcyBvciBhIHBoYXNlCiAqCW1pc21hdGNoIG9jY3VycyAod2hpY2ggd291bGQgZmluaXNoIHRoZSBETUEgdHJhbnNmZXIpLiAgCiAqCiAqIElucHV0cyA6IGluc3RhbmNlIC0gdGhpcyBpbnN0YW5jZSBvZiB0aGUgTkNSNTM4MC4KICoKICovCgpzdGF0aWMgdm9pZCBOQ1I1MzgwX2RtYV9jb21wbGV0ZSggc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UgKQp7CiAgICBTRVRVUF9IT1NUREFUQShpbnN0YW5jZSk7CiAgICBpbnQgICAgICAgICAgIHRyYW5zZmVyZWQsIHNhdmVkX2RhdGEgPSAwLCBvdmVycnVuID0gMCwgY250LCB0b1BJTzsKICAgIHVuc2lnbmVkIGNoYXIgKipkYXRhLCBwOwogICAgdm9sYXRpbGUgaW50ICAqY291bnQ7CgogICAgaWYgKCFob3N0ZGF0YS0+Y29ubmVjdGVkKSB7CglwcmludGsoS0VSTl9XQVJOSU5HICJzY3NpJWQ6IHJlY2VpdmVkIGVuZCBvZiBETUEgaW50ZXJydXB0IHdpdGggIgoJICAgICAgICJubyBjb25uZWN0ZWQgY21kXG4iLCBIT1NUTk8pOwoJcmV0dXJuOwogICAgfQogICAgCiAgICBpZiAoYXRhcmlfcmVhZF9vdmVycnVucykgewoJcCA9IGhvc3RkYXRhLT5jb25uZWN0ZWQtPlNDcC5waGFzZTsKCWlmIChwICYgU1JfSU8pIHsKCSAgICB1ZGVsYXkoMTApOwoJICAgIGlmICgoKChOQ1I1MzgwX3JlYWQoQlVTX0FORF9TVEFUVVNfUkVHKSkgJgoJCSAgKEJBU1JfUEhBU0VfTUFUQ0h8QkFTUl9BQ0spKSA9PQoJCSAoQkFTUl9QSEFTRV9NQVRDSHxCQVNSX0FDSykpKSB7CgkJc2F2ZWRfZGF0YSA9IE5DUjUzODBfcmVhZChJTlBVVF9EQVRBX1JFRyk7CgkJb3ZlcnJ1biA9IDE7CgkJRE1BX1BSSU5USygic2NzaSVkOiByZWFkIG92ZXJydW4gaGFuZGxlZFxuIiwgSE9TVE5PKTsKCSAgICB9Cgl9CiAgICB9CgogICAgRE1BX1BSSU5USygic2NzaSVkOiByZWFsIERNQSB0cmFuc2ZlciBjb21wbGV0ZSwgYmFzciAweCVYLCBzciAweCVYXG4iLAoJICAgICAgIEhPU1ROTywgTkNSNTM4MF9yZWFkKEJVU19BTkRfU1RBVFVTX1JFRyksCgkgICAgICAgTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpKTsKCiAgICAodm9pZCkgTkNSNTM4MF9yZWFkKFJFU0VUX1BBUklUWV9JTlRFUlJVUFRfUkVHKTsKICAgIE5DUjUzODBfd3JpdGUoTU9ERV9SRUcsIE1SX0JBU0UpOwogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCiAgICB0cmFuc2ZlcmVkID0gaG9zdGRhdGEtPmRtYV9sZW4gLSBOQ1I1MzgwX2RtYV9yZXNpZHVhbChpbnN0YW5jZSk7CiAgICBob3N0ZGF0YS0+ZG1hX2xlbiA9IDA7CgogICAgZGF0YSA9ICh1bnNpZ25lZCBjaGFyICoqKSAmKGhvc3RkYXRhLT5jb25uZWN0ZWQtPlNDcC5wdHIpOwogICAgY291bnQgPSAmKGhvc3RkYXRhLT5jb25uZWN0ZWQtPlNDcC50aGlzX3Jlc2lkdWFsKTsKICAgICpkYXRhICs9IHRyYW5zZmVyZWQ7CiAgICAqY291bnQgLT0gdHJhbnNmZXJlZDsKCiAgICBpZiAoYXRhcmlfcmVhZF9vdmVycnVucykgewoJaWYgKChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBQSEFTRV9NQVNLKSA9PSBwICYmIChwICYgU1JfSU8pKSB7CgkgICAgY250ID0gdG9QSU8gPSBhdGFyaV9yZWFkX292ZXJydW5zOwoJICAgIGlmIChvdmVycnVuKSB7CgkJRE1BX1BSSU5USygiR290IGFuIGlucHV0IG92ZXJydW4sIHVzaW5nIHNhdmVkIGJ5dGVcbiIpOwoJCSooKmRhdGEpKysgPSBzYXZlZF9kYXRhOwoJCSgqY291bnQpLS07CgkJY250LS07CgkJdG9QSU8tLTsKCSAgICB9CgkgICAgRE1BX1BSSU5USygiRG9pbmcgJWQtYnl0ZSBQSU8gdG8gMHglMDhseFxuIiwgY250LCAobG9uZykqZGF0YSk7CgkgICAgTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwLCAmY250LCBkYXRhKTsKCSAgICAqY291bnQgLT0gdG9QSU8gLSBjbnQ7Cgl9CiAgICB9Cn0KI2VuZGlmIC8qIFJFQUxfRE1BICovCgoKLyoKICogRnVuY3Rpb24gOiB2b2lkIE5DUjUzODBfaW50ciAoaW50IGlycSkKICogCiAqIFB1cnBvc2UgOiBoYW5kbGUgaW50ZXJydXB0cywgcmVlc3RhYmxpc2hpbmcgSV9UX0wgb3IgSV9UX0xfUSBuZXh1c2VzCiAqCWZyb20gdGhlIGRpc2Nvbm5lY3RlZCBxdWV1ZSwgYW5kIHJlc3RhcnRpbmcgTkNSNTM4MF9tYWluKCkgCiAqCWFzIHJlcXVpcmVkLgogKgogKiBJbnB1dHMgOiBpbnQgaXJxLCBpcnEgdGhhdCBjYXVzZWQgdGhpcyBpbnRlcnJ1cHQuCiAqCiAqLwoKc3RhdGljIGlycXJldHVybl90IE5DUjUzODBfaW50ciAoaW50IGlycSwgdm9pZCAqZGV2X2lkLCBzdHJ1Y3QgcHRfcmVncyAqcmVncykKewogICAgc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UgPSBmaXJzdF9pbnN0YW5jZTsKICAgIGludCBkb25lID0gMSwgaGFuZGxlZCA9IDA7CiAgICB1bnNpZ25lZCBjaGFyIGJhc3I7CgogICAgSU5UX1BSSU5USygic2NzaSVkOiBOQ1I1MzgwIGlycSB0cmlnZ2VyZWRcbiIsIEhPU1ROTyk7CgogICAgLyogTG9vayBmb3IgcGVuZGluZyBpbnRlcnJ1cHRzICovCiAgICBiYXNyID0gTkNSNTM4MF9yZWFkKEJVU19BTkRfU1RBVFVTX1JFRyk7CiAgICBJTlRfUFJJTlRLKCJzY3NpJWQ6IEJBU1I9JTAyeFxuIiwgSE9TVE5PLCBiYXNyKTsKICAgIC8qIGRpc3BhdGNoIHRvIGFwcHJvcHJpYXRlIHJvdXRpbmUgaWYgZm91bmQgYW5kIGRvbmU9MCAqLwogICAgaWYgKGJhc3IgJiBCQVNSX0lSUSkgewoJTkNSX1BSSU5UKE5ERUJVR19JTlRSKTsKCWlmICgoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgKFNSX1NFTHxTUl9JTykpID09IChTUl9TRUx8U1JfSU8pKSB7CgkgICAgZG9uZSA9IDA7CgkgICAgRU5BQkxFX0lSUSgpOwoJICAgIElOVF9QUklOVEsoInNjc2klZDogU0VMIGludGVycnVwdFxuIiwgSE9TVE5PKTsKCSAgICBOQ1I1MzgwX3Jlc2VsZWN0KGluc3RhbmNlKTsKCSAgICAodm9pZCkgTkNSNTM4MF9yZWFkKFJFU0VUX1BBUklUWV9JTlRFUlJVUFRfUkVHKTsKCX0KCWVsc2UgaWYgKGJhc3IgJiBCQVNSX1BBUklUWV9FUlJPUikgewoJICAgIElOVF9QUklOVEsoInNjc2klZDogUEFSSVRZIGludGVycnVwdFxuIiwgSE9TVE5PKTsKCSAgICAodm9pZCkgTkNSNTM4MF9yZWFkKFJFU0VUX1BBUklUWV9JTlRFUlJVUFRfUkVHKTsKCX0KCWVsc2UgaWYgKChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBTUl9SU1QpID09IFNSX1JTVCkgewoJICAgIElOVF9QUklOVEsoInNjc2klZDogUkVTRVQgaW50ZXJydXB0XG4iLCBIT1NUTk8pOwoJICAgICh2b2lkKU5DUjUzODBfcmVhZChSRVNFVF9QQVJJVFlfSU5URVJSVVBUX1JFRyk7Cgl9CgllbHNlIHsKCSAgICAvKiAgCgkgICAgICogVGhlIHJlc3Qgb2YgdGhlIGludGVycnVwdCBjb25kaXRpb25zIGNhbiBvY2N1ciBvbmx5IGR1cmluZyBhCgkgICAgICogRE1BIHRyYW5zZmVyCgkgICAgICovCgojaWYgZGVmaW5lZChSRUFMX0RNQSkKCSAgICAvKgoJICAgICAqIFdlIHNob3VsZCBvbmx5IGdldCBQSEFTRSBNSVNNQVRDSCBhbmQgRU9QIGludGVycnVwdHMgaWYgd2UgaGF2ZQoJICAgICAqIERNQSBlbmFibGVkLCBzbyBkbyBhIHNhbml0eSBjaGVjayBiYXNlZCBvbiB0aGUgY3VycmVudCBzZXR0aW5nCgkgICAgICogb2YgdGhlIE1PREUgcmVnaXN0ZXIuCgkgICAgICovCgoJICAgIGlmICgoTkNSNTM4MF9yZWFkKE1PREVfUkVHKSAmIE1SX0RNQV9NT0RFKSAmJgoJCSgoYmFzciAmIEJBU1JfRU5EX0RNQV9UUkFOU0ZFUikgfHwgCgkJICEoYmFzciAmIEJBU1JfUEhBU0VfTUFUQ0gpKSkgewoJCSAgICAKCQlJTlRfUFJJTlRLKCJzY3NpJWQ6IFBIQVNFIE1JU00gb3IgRU9QIGludGVycnVwdFxuIiwgSE9TVE5PKTsKCQlOQ1I1MzgwX2RtYV9jb21wbGV0ZSggaW5zdGFuY2UgKTsKCQlkb25lID0gMDsKCQlFTkFCTEVfSVJRKCk7CgkgICAgfSBlbHNlCiNlbmRpZiAvKiBSRUFMX0RNQSAqLwoJICAgIHsKLyogTVM6IElnbm9yZSB1bmtub3duIHBoYXNlIG1pc21hdGNoIGludGVycnVwdHMgKGNhdXNlZCBieSBFT1AgaW50ZXJydXB0KSAqLwoJCWlmIChiYXNyICYgQkFTUl9QSEFTRV9NQVRDSCkKCQkgICAgcHJpbnRrKEtFUk5fTk9USUNFICJzY3NpJWQ6IHVua25vd24gaW50ZXJydXB0LCAiCgkJCSAgICJCQVNSIDB4JXgsIE1SIDB4JXgsIFNSIDB4JXhcbiIsCgkJCSAgIEhPU1ROTywgYmFzciwgTkNSNTM4MF9yZWFkKE1PREVfUkVHKSwKCQkJICAgTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpKTsKCQkodm9pZCkgTkNSNTM4MF9yZWFkKFJFU0VUX1BBUklUWV9JTlRFUlJVUFRfUkVHKTsKCSAgICB9Cgl9IC8qIGlmICEoU0VMRUNUSU9OIHx8IFBBUklUWSkgKi8KCWhhbmRsZWQgPSAxOwogICAgfSAvKiBCQVNSICYgSVJRICovCiAgICBlbHNlIHsKCXByaW50ayhLRVJOX05PVElDRSAic2NzaSVkOiBpbnRlcnJ1cHQgd2l0aG91dCBJUlEgYml0IHNldCBpbiBCQVNSLCAiCgkgICAgICAgIkJBU1IgMHglWCwgTVIgMHglWCwgU1IgMHgleFxuIiwgSE9TVE5PLCBiYXNyLAoJICAgICAgIE5DUjUzODBfcmVhZChNT0RFX1JFRyksIE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSk7Cgkodm9pZCkgTkNSNTM4MF9yZWFkKFJFU0VUX1BBUklUWV9JTlRFUlJVUFRfUkVHKTsKICAgIH0KICAgIAogICAgaWYgKCFkb25lKSB7CglJTlRfUFJJTlRLKCJzY3NpJWQ6IGluIGludCByb3V0aW5lLCBjYWxsaW5nIG1haW5cbiIsIEhPU1ROTyk7CgkvKiBQdXQgYSBjYWxsIHRvIE5DUjUzODBfbWFpbigpIG9uIHRoZSBxdWV1ZS4uLiAqLwoJcXVldWVfbWFpbigpOwogICAgfQogICAgcmV0dXJuIElSUV9SRVRWQUwoaGFuZGxlZCk7Cn0KCiNpZmRlZiBOQ1I1MzgwX1NUQVRTCnN0YXRpYyB2b2lkIGNvbGxlY3Rfc3RhdHMoc3RydWN0IE5DUjUzODBfaG9zdGRhdGEqIGhvc3RkYXRhLCBTY3NpX0NtbmQqIGNtZCkKewojIGlmZGVmIE5DUjUzODBfU1RBVF9MSU1JVAogICAgaWYgKGNtZC0+cmVxdWVzdF9idWZmbGVuID4gTkNSNTM4MF9TVEFUX0xJTUlUKQojIGVuZGlmCglzd2l0Y2ggKGNtZC0+Y21uZFswXSkKCXsKCSAgICBjYXNlIFdSSVRFOgoJICAgIGNhc2UgV1JJVEVfNjoKCSAgICBjYXNlIFdSSVRFXzEwOgoJCWhvc3RkYXRhLT50aW1lX3dyaXRlW2NtZC0+ZGV2aWNlLT5pZF0gKz0gKGppZmZpZXMgLSBob3N0ZGF0YS0+dGltZWJhc2UpOwoJCS8qaG9zdGRhdGEtPmJ5dGVzX3dyaXRlW2NtZC0+ZGV2aWNlLT5pZF0gKz0gY21kLT5yZXF1ZXN0X2J1ZmZsZW47Ki8KCQlob3N0ZGF0YS0+cGVuZGluZ3ctLTsKCQlicmVhazsKCSAgICBjYXNlIFJFQUQ6CgkgICAgY2FzZSBSRUFEXzY6CgkgICAgY2FzZSBSRUFEXzEwOgoJCWhvc3RkYXRhLT50aW1lX3JlYWRbY21kLT5kZXZpY2UtPmlkXSArPSAoamlmZmllcyAtIGhvc3RkYXRhLT50aW1lYmFzZSk7CgkJLypob3N0ZGF0YS0+Ynl0ZXNfcmVhZFtjbWQtPmRldmljZS0+aWRdICs9IGNtZC0+cmVxdWVzdF9idWZmbGVuOyovCgkJaG9zdGRhdGEtPnBlbmRpbmdyLS07CgkJYnJlYWs7Cgl9Cn0KI2VuZGlmCgovKiAKICogRnVuY3Rpb24gOiBpbnQgTkNSNTM4MF9zZWxlY3QgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlLCBTY3NpX0NtbmQgKmNtZCwgCiAqCWludCB0YWcpOwogKgogKiBQdXJwb3NlIDogZXN0YWJsaXNoZXMgSV9UX0wgb3IgSV9UX0xfUSBuZXh1cyBmb3IgbmV3IG9yIGV4aXN0aW5nIGNvbW1hbmQsCiAqCWluY2x1ZGluZyBBUkJJVFJBVElPTiwgU0VMRUNUSU9OLCBhbmQgaW5pdGlhbCBtZXNzYWdlIG91dCBmb3IgCiAqCUlERU5USUZZIGFuZCBxdWV1ZSBtZXNzYWdlcy4gCiAqCiAqIElucHV0cyA6IGluc3RhbmNlIC0gaW5zdGFudGlhdGlvbiBvZiB0aGUgNTM4MCBkcml2ZXIgb24gd2hpY2ggdGhpcyAKICogCXRhcmdldCBsaXZlcywgY21kIC0gU0NTSSBjb21tYW5kIHRvIGV4ZWN1dGUsIHRhZyAtIHNldCB0byBUQUdfTkVYVCBmb3IgCiAqCW5ldyB0YWcsIFRBR19OT05FIGZvciB1bnRhZ2dlZCBxdWV1ZWluZywgb3RoZXJ3aXNlIHNldCB0byB0aGUgdGFnIGZvciAKICoJdGhlIGNvbW1hbmQgdGhhdCBpcyBwcmVzZW50bHkgY29ubmVjdGVkLgogKiAKICogUmV0dXJucyA6IC0xIGlmIHNlbGVjdGlvbiBjb3VsZCBub3QgZXhlY3V0ZSBmb3Igc29tZSByZWFzb24sCiAqCTAgaWYgc2VsZWN0aW9uIHN1Y2NlZWRlZCBvciBmYWlsZWQgYmVjYXVzZSB0aGUgdGFyZ2V0IAogKiAJZGlkIG5vdCByZXNwb25kLgogKgogKiBTaWRlIGVmZmVjdHMgOiAKICogCUlmIGJ1cyBidXN5LCBhcmJpdHJhdGlvbiBmYWlsZWQsIGV0YywgTkNSNTM4MF9zZWxlY3QoKSB3aWxsIGV4aXQgCiAqCQl3aXRoIHJlZ2lzdGVycyBhcyB0aGV5IHNob3VsZCBoYXZlIGJlZW4gb24gZW50cnkgLSBpZQogKgkJU0VMRUNUX0VOQUJMRSB3aWxsIGJlIHNldCBhcHByb3ByaWF0ZWx5LCB0aGUgTkNSNTM4MAogKgkJd2lsbCBjZWFzZSB0byBkcml2ZSBhbnkgU0NTSSBidXMgc2lnbmFscy4KICoKICoJSWYgc3VjY2Vzc2Z1bCA6IElfVF9MIG9yIElfVF9MX1EgbmV4dXMgd2lsbCBiZSBlc3RhYmxpc2hlZCwgCiAqCQlpbnN0YW5jZS0+Y29ubmVjdGVkIHdpbGwgYmUgc2V0IHRvIGNtZC4gIAogKiAJCVNFTEVDVCBpbnRlcnJ1cHQgd2lsbCBiZSBkaXNhYmxlZC4KICoKICoJSWYgZmFpbGVkIChubyB0YXJnZXQpIDogY21kLT5zY3NpX2RvbmUoKSB3aWxsIGJlIGNhbGxlZCwgYW5kIHRoZSAKICoJCWNtZC0+cmVzdWx0IGhvc3QgYnl0ZSBzZXQgdG8gRElEX0JBRF9UQVJHRVQuCiAqLwoKc3RhdGljIGludCBOQ1I1MzgwX3NlbGVjdCAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UsIFNjc2lfQ21uZCAqY21kLCBpbnQgdGFnKQp7CiAgICBTRVRVUF9IT1NUREFUQShpbnN0YW5jZSk7CiAgICB1bnNpZ25lZCBjaGFyIHRtcFszXSwgcGhhc2U7CiAgICB1bnNpZ25lZCBjaGFyICpkYXRhOwogICAgaW50IGxlbjsKICAgIHVuc2lnbmVkIGxvbmcgdGltZW91dDsKICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7CgogICAgaG9zdGRhdGEtPnJlc3RhcnRfc2VsZWN0ID0gMDsKICAgIE5DUl9QUklOVChOREVCVUdfQVJCSVRSQVRJT04pOwogICAgQVJCX1BSSU5USygic2NzaSVkOiBzdGFydGluZyBhcmJpdHJhdGlvbiwgaWQgPSAlZFxuIiwgSE9TVE5PLAoJICAgICAgIGluc3RhbmNlLT50aGlzX2lkKTsKCiAgICAvKiAKICAgICAqIFNldCB0aGUgcGhhc2UgYml0cyB0byAwLCBvdGhlcndpc2UgdGhlIE5DUjUzODAgd29uJ3QgZHJpdmUgdGhlIAogICAgICogZGF0YSBidXMgZHVyaW5nIFNFTEVDVElPTi4KICAgICAqLwoKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIGlmIChob3N0ZGF0YS0+Y29ubmVjdGVkKSB7Cglsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CglyZXR1cm4gLTE7CiAgICB9CiAgICBOQ1I1MzgwX3dyaXRlKFRBUkdFVF9DT01NQU5EX1JFRywgMCk7CgoKICAgIC8qIAogICAgICogU3RhcnQgYXJiaXRyYXRpb24uCiAgICAgKi8KICAgIAogICAgTkNSNTM4MF93cml0ZShPVVRQVVRfREFUQV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKICAgIE5DUjUzODBfd3JpdGUoTU9ERV9SRUcsIE1SX0FSQklUUkFURSk7CgogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoKICAgIC8qIFdhaXQgZm9yIGFyYml0cmF0aW9uIGxvZ2ljIHRvIGNvbXBsZXRlICovCiNpZiBOQ1JfVElNRU9VVAogICAgewogICAgICB1bnNpZ25lZCBsb25nIHRpbWVvdXQgPSBqaWZmaWVzICsgMipOQ1JfVElNRU9VVDsKCiAgICAgIHdoaWxlICghKE5DUjUzODBfcmVhZChJTklUSUFUT1JfQ09NTUFORF9SRUcpICYgSUNSX0FSQklUUkFUSU9OX1BST0dSRVNTKQoJICAgJiYgdGltZV9iZWZvcmUoamlmZmllcywgdGltZW91dCkgJiYgIWhvc3RkYXRhLT5jb25uZWN0ZWQpCgk7CiAgICAgIGlmICh0aW1lX2FmdGVyX2VxKGppZmZpZXMsIHRpbWVvdXQpKQogICAgICB7CglwcmludGsoInNjc2kgOiBhcmJpdHJhdGlvbiB0aW1lb3V0IGF0ICVkXG4iLCBfX0xJTkVfXyk7CglOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9CQVNFKTsKCU5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKCXJldHVybiAtMTsKICAgICAgfQogICAgfQojZWxzZSAvKiBOQ1JfVElNRU9VVCAqLwogICAgd2hpbGUgKCEoTkNSNTM4MF9yZWFkKElOSVRJQVRPUl9DT01NQU5EX1JFRykgJiBJQ1JfQVJCSVRSQVRJT05fUFJPR1JFU1MpCgkgJiYgIWhvc3RkYXRhLT5jb25uZWN0ZWQpOwojZW5kaWYKCiAgICBBUkJfUFJJTlRLKCJzY3NpJWQ6IGFyYml0cmF0aW9uIGNvbXBsZXRlXG4iLCBIT1NUTk8pOwoKICAgIGlmIChob3N0ZGF0YS0+Y29ubmVjdGVkKSB7CglOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9CQVNFKTsgCglyZXR1cm4gLTE7CiAgICB9CiAgICAvKiAKICAgICAqIFRoZSBhcmJpdHJhdGlvbiBkZWxheSBpcyAyLjJ1cywgYnV0IHRoaXMgaXMgYSBtaW5pbXVtIGFuZCB0aGVyZSBpcyAKICAgICAqIG5vIG1heGltdW0gc28gd2UgY2FuIHNhZmVseSBzbGVlcCBmb3IgY2VpbCgyLjIpIHVzZWNzIHRvIGFjY29tbW9kYXRlCiAgICAgKiB0aGUgaW50ZWdyYWwgbmF0dXJlIG9mIHVkZWxheSgpLgogICAgICoKICAgICAqLwoKICAgIHVkZWxheSgzKTsKCiAgICAvKiBDaGVjayBmb3IgbG9zdCBhcmJpdHJhdGlvbiAqLwogICAgaWYgKChOQ1I1MzgwX3JlYWQoSU5JVElBVE9SX0NPTU1BTkRfUkVHKSAmIElDUl9BUkJJVFJBVElPTl9MT1NUKSB8fAoJKE5DUjUzODBfcmVhZChDVVJSRU5UX1NDU0lfREFUQV9SRUcpICYgaG9zdGRhdGEtPmlkX2hpZ2hlcl9tYXNrKSB8fAoJKE5DUjUzODBfcmVhZChJTklUSUFUT1JfQ09NTUFORF9SRUcpICYgSUNSX0FSQklUUkFUSU9OX0xPU1QpIHx8Cglob3N0ZGF0YS0+Y29ubmVjdGVkKSB7CglOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9CQVNFKTsgCglBUkJfUFJJTlRLKCJzY3NpJWQ6IGxvc3QgYXJiaXRyYXRpb24sIGRlYXNzZXJ0aW5nIE1SX0FSQklUUkFURVxuIiwKCQkgICBIT1NUTk8pOwoJcmV0dXJuIC0xOwogICAgfQoKICAgICAvKiBhZnRlci9kdXJpbmcgYXJiaXRyYXRpb24sIEJTWSBzaG91bGQgYmUgYXNzZXJ0ZWQuCglJQk0gRFBFUy0zMTA4MCBWZXJzaW9uIFMzMVEgd29ya3Mgbm93ICovCiAgICAgLyogVG54IHRvIFRob21hc19Sb2VzY2hAbTIubWF1cy5kZSBmb3IgZmluZGluZyB0aGlzISAoUm9tYW4pICovCiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCBJQ1JfQVNTRVJUX1NFTCB8CgkJCQkJIElDUl9BU1NFUlRfQlNZICkgOwogICAgCiAgICBpZiAoKE5DUjUzODBfcmVhZChJTklUSUFUT1JfQ09NTUFORF9SRUcpICYgSUNSX0FSQklUUkFUSU9OX0xPU1QpIHx8Cglob3N0ZGF0YS0+Y29ubmVjdGVkKSB7CglOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9CQVNFKTsKCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CglBUkJfUFJJTlRLKCJzY3NpJWQ6IGxvc3QgYXJiaXRyYXRpb24sIGRlYXNzZXJ0aW5nIElDUl9BU1NFUlRfU0VMXG4iLAoJCSAgIEhPU1ROTyk7CglyZXR1cm4gLTE7CiAgICB9CgogICAgLyogCiAgICAgKiBBZ2FpbiwgYnVzIGNsZWFyICsgYnVzIHNldHRsZSB0aW1lIGlzIDEuMnVzLCBob3dldmVyLCB0aGlzIGlzIAogICAgICogYSBtaW5pbXVtIHNvIHdlJ2xsIHVkZWxheSBjZWlsKDEuMikKICAgICAqLwoKI2lmZGVmIENPTkZJR19BVEFSSV9TQ1NJX1RPU0hJQkFfREVMQVkKICAgIC8qICsrcm9tYW46IEJ1dCBzb21lIHRhcmdldHMgKHNlZSBhYm92ZSA6LSkgc2VlbSB0byBuZWVkIGEgYml0IG1vcmUuLi4gKi8KICAgIHVkZWxheSgxNSk7CiNlbHNlCiAgICB1ZGVsYXkoMik7CiNlbmRpZgogICAgCiAgICBpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCkgewoJTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7CglOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJcmV0dXJuIC0xOwogICAgfQoKICAgIEFSQl9QUklOVEsoInNjc2klZDogd29uIGFyYml0cmF0aW9uXG4iLCBIT1NUTk8pOwoKICAgIC8qIAogICAgICogTm93IHRoYXQgd2UgaGF2ZSB3b24gYXJiaXRyYXRpb24sIHN0YXJ0IFNlbGVjdGlvbiBwcm9jZXNzLCBhc3NlcnRpbmcgCiAgICAgKiB0aGUgaG9zdCBhbmQgdGFyZ2V0IElEJ3Mgb24gdGhlIFNDU0kgYnVzLgogICAgICovCgogICAgTkNSNTM4MF93cml0ZShPVVRQVVRfREFUQV9SRUcsIChob3N0ZGF0YS0+aWRfbWFzayB8ICgxIDw8IGNtZC0+ZGV2aWNlLT5pZCkpKTsKCiAgICAvKiAKICAgICAqIFJhaXNlIEFUTiB3aGlsZSBTRUwgaXMgdHJ1ZSBiZWZvcmUgQlNZIGdvZXMgZmFsc2UgZnJvbSBhcmJpdHJhdGlvbiwKICAgICAqIHNpbmNlIHRoaXMgaXMgdGhlIG9ubHkgd2F5IHRvIGd1YXJhbnRlZSB0aGF0IHdlJ2xsIGdldCBhIE1FU1NBR0UgT1VUCiAgICAgKiBwaGFzZSBpbW1lZGlhdGVseSBhZnRlciBzZWxlY3Rpb24uCiAgICAgKi8KCiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgKElDUl9CQVNFIHwgSUNSX0FTU0VSVF9CU1kgfCAKCUlDUl9BU1NFUlRfREFUQSB8IElDUl9BU1NFUlRfQVROIHwgSUNSX0FTU0VSVF9TRUwgKSk7CiAgICBOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9CQVNFKTsKCiAgICAvKiAKICAgICAqIFJlc2VsZWN0IGludGVycnVwdHMgbXVzdCBiZSB0dXJuZWQgb2ZmIHByaW9yIHRvIHRoZSBkcm9wcGluZyBvZiBCU1ksCiAgICAgKiBvdGhlcndpc2Ugd2Ugd2lsbCB0cmlnZ2VyIGFuIGludGVycnVwdC4KICAgICAqLwoKICAgIGlmIChob3N0ZGF0YS0+Y29ubmVjdGVkKSB7CglOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJcmV0dXJuIC0xOwogICAgfQoKICAgIE5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIDApOwoKICAgIC8qCiAgICAgKiBUaGUgaW5pdGlhdG9yIHNoYWxsIHRoZW4gd2FpdCBhdCBsZWFzdCB0d28gZGVza2V3IGRlbGF5cyBhbmQgcmVsZWFzZSAKICAgICAqIHRoZSBCU1kgc2lnbmFsLgogICAgICovCiAgICB1ZGVsYXkoMSk7ICAgICAgICAvKiB3aW5nZWwgLS0gd2FpdCB0d28gYnVzIGRlc2tldyBkZWxheSA+Mio0NW5zICovCgogICAgLyogUmVzZXQgQlNZICovCiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgKElDUl9CQVNFIHwgSUNSX0FTU0VSVF9EQVRBIHwgCglJQ1JfQVNTRVJUX0FUTiB8IElDUl9BU1NFUlRfU0VMKSk7CgogICAgLyogCiAgICAgKiBTb21ldGhpbmcgd2VpcmQgaGFwcGVucyB3aGVuIHdlIGNlYXNlIHRvIGRyaXZlIEJTWSAtIGxvb2tzCiAgICAgKiBsaWtlIHRoZSBib2FyZC9jaGlwIGlzIGxldHRpbmcgdXMgZG8gYW5vdGhlciByZWFkIGJlZm9yZSB0aGUgCiAgICAgKiBhcHByb3ByaWF0ZSBwcm9wYWdhdGlvbiBkZWxheSBoYXMgZXhwaXJlZCwgYW5kIHdlJ3JlIGNvbmZ1c2luZwogICAgICogYSBCU1kgc2lnbmFsIGZyb20gb3Vyc2VsdmVzIGFzIHRoZSB0YXJnZXQncyByZXNwb25zZSB0byBTRUxFQ1RJT04uCiAgICAgKgogICAgICogQSBzbWFsbCBkZWxheSAodGhlICdDKysnIGZyb250ZW5kIGJyZWFrcyB0aGUgcGlwZWxpbmUgd2l0aCBhbgogICAgICogdW5uZWNlc3NhcnkganVtcCwgbWFraW5nIGl0IHdvcmsgb24gbXkgMzg2LTMzL1RyYW50b3IgVDEyOCwgdGhlCiAgICAgKiB0aWdodGVyICdDJyBjb2RlIGJyZWFrcyBhbmQgcmVxdWlyZXMgdGhpcykgc29sdmVzIHRoZSBwcm9ibGVtIC0gCiAgICAgKiB0aGUgMSB1cyBkZWxheSBpcyBhcmJpdHJhcnksIGFuZCBvbmx5IHVzZWQgYmVjYXVzZSB0aGlzIGRlbGF5IHdpbGwgCiAgICAgKiBiZSB0aGUgc2FtZSBvbiBvdGhlciBwbGF0Zm9ybXMgYW5kIHNpbmNlIGl0IHdvcmtzIGhlcmUsIGl0IHNob3VsZCAKICAgICAqIHdvcmsgdGhlcmUuCiAgICAgKgogICAgICogd2luZ2VsIHN1Z2dlc3RzIHRoYXQgdGhpcyBjb3VsZCBiZSBkdWUgdG8gZmFpbGluZyB0byB3YWl0CiAgICAgKiBvbmUgZGVza2V3IGRlbGF5LgogICAgICovCgogICAgdWRlbGF5KDEpOwoKICAgIFNFTF9QUklOVEsoInNjc2klZDogc2VsZWN0aW5nIHRhcmdldCAlZFxuIiwgSE9TVE5PLCBjbWQtPmRldmljZS0+aWQpOwoKICAgIC8qIAogICAgICogVGhlIFNDU0kgc3BlY2lmaWNhdGlvbiBjYWxscyBmb3IgYSAyNTAgbXMgdGltZW91dCBmb3IgdGhlIGFjdHVhbCAKICAgICAqIHNlbGVjdGlvbi4KICAgICAqLwoKICAgIHRpbWVvdXQgPSBqaWZmaWVzICsgMjU7IAoKICAgIC8qIAogICAgICogWFhYIHZlcnkgaW50ZXJlc3RpbmcgLSB3ZSdyZSBzZWVpbmcgYSBib3VuY2Ugd2hlcmUgdGhlIEJTWSB3ZSAKICAgICAqIGFzc2VydGVkIGlzIGJlaW5nIHJlZmxlY3RlZCAvIHN0aWxsIGFzc2VydGVkIChwcm9wYWdhdGlvbiBkZWxheT8pCiAgICAgKiBhbmQgaXQncyBkZXRlY3RpbmcgYXMgdHJ1ZS4gIFNpZ2guCiAgICAgKi8KCiNpZiAwCiAgICAvKiArK3JvbWFuOiBJZiBhIHRhcmdldCBjb25mb3JtZWQgdG8gdGhlIFNDU0kgc3RhbmRhcmQsIGl0IHdvdWxkbid0IGFzc2VydAogICAgICogSU8gd2hpbGUgU0VMIGlzIHRydWUuIEJ1dCBhZ2FpbiwgdGhlcmUgYXJlIHNvbWUgZGlza3Mgb3V0IHRoZSBpbiB0aGUKICAgICAqIHdvcmxkIHRoYXQgZG8gdGhhdCBuZXZlcnRoZWxlc3MuIChTb21lYm9keSBjbGFpbWVkIHRoYXQgdGhpcyBhbm5vdW5jZXMKICAgICAqIHJlc2VsZWN0aW9uIGNhcGFiaWxpdHkgb2YgdGhlIHRhcmdldC4pIFNvIHdlIGJldHRlciBza2lwIHRoYXQgdGVzdCBhbmQKICAgICAqIG9ubHkgd2FpdCBmb3IgQlNZLi4uIChGYW1vdXMgZ2VybWFuIHdvcmRzOiBEZXIgS2z8Z2VyZSBnaWJ0IG5hY2ggOi0pCiAgICAgKi8KCiAgICB3aGlsZSAodGltZV9iZWZvcmUoamlmZmllcywgdGltZW91dCkgJiYgIShOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiAKCShTUl9CU1kgfCBTUl9JTykpKTsKCiAgICBpZiAoKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIChTUl9TRUwgfCBTUl9JTykpID09IAoJICAgIChTUl9TRUwgfCBTUl9JTykpIHsKCSAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJICAgIE5DUjUzODBfcmVzZWxlY3QoaW5zdGFuY2UpOwoJICAgIHByaW50ayAoS0VSTl9FUlIgInNjc2klZDogcmVzZWxlY3Rpb24gYWZ0ZXIgd29uIGFyYml0cmF0aW9uP1xuIiwKCQkgICAgSE9TVE5PKTsKCSAgICBOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CgkgICAgcmV0dXJuIC0xOwogICAgfQojZWxzZQogICAgd2hpbGUgKHRpbWVfYmVmb3JlKGppZmZpZXMsIHRpbWVvdXQpICYmICEoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfQlNZKSk7CiNlbmRpZgoKICAgIC8qIAogICAgICogTm8gbGVzcyB0aGFuIHR3byBkZXNrZXcgZGVsYXlzIGFmdGVyIHRoZSBpbml0aWF0b3IgZGV0ZWN0cyB0aGUgCiAgICAgKiBCU1kgc2lnbmFsIGlzIHRydWUsIGl0IHNoYWxsIHJlbGVhc2UgdGhlIFNFTCBzaWduYWwgYW5kIG1heSAKICAgICAqIGNoYW5nZSB0aGUgREFUQSBCVVMuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC13aW5nZWwKICAgICAqLwoKICAgIHVkZWxheSgxKTsKCiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCBJQ1JfQVNTRVJUX0FUTik7CgogICAgaWYgKCEoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfQlNZKSkgewoJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCWlmIChob3N0ZGF0YS0+dGFyZ2V0c19wcmVzZW50ICYgKDEgPDwgY21kLT5kZXZpY2UtPmlkKSkgewoJICAgIHByaW50ayhLRVJOX0VSUiAic2NzaSVkOiB3ZWlyZG5lc3NcbiIsIEhPU1ROTyk7CgkgICAgaWYgKGhvc3RkYXRhLT5yZXN0YXJ0X3NlbGVjdCkKCQlwcmludGsoS0VSTl9OT1RJQ0UgIlx0cmVzdGFydCBzZWxlY3RcbiIpOwoJICAgIE5DUl9QUklOVChOREVCVUdfQU5ZKTsKCSAgICBOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CgkgICAgcmV0dXJuIC0xOwoJfQoJY21kLT5yZXN1bHQgPSBESURfQkFEX1RBUkdFVCA8PCAxNjsKI2lmZGVmIE5DUjUzODBfU1RBVFMKCWNvbGxlY3Rfc3RhdHMoaG9zdGRhdGEsIGNtZCk7CiNlbmRpZgojaWZkZWYgU1VQUE9SVF9UQUdTCgljbWRfZnJlZV90YWcoIGNtZCApOwojZW5kaWYKCWNtZC0+c2NzaV9kb25lKGNtZCk7CglOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CglTRUxfUFJJTlRLKCJzY3NpJWQ6IHRhcmdldCBkaWQgbm90IHJlc3BvbmQgd2l0aGluIDI1MG1zXG4iLCBIT1NUTk8pOwoJTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJcmV0dXJuIDA7CiAgICB9IAoKICAgIGhvc3RkYXRhLT50YXJnZXRzX3ByZXNlbnQgfD0gKDEgPDwgY21kLT5kZXZpY2UtPmlkKTsKCiAgICAvKgogICAgICogU2luY2Ugd2UgZm9sbG93ZWQgdGhlIFNDU0kgc3BlYywgYW5kIHJhaXNlZCBBVE4gd2hpbGUgU0VMIAogICAgICogd2FzIHRydWUgYnV0IGJlZm9yZSBCU1kgd2FzIGZhbHNlIGR1cmluZyBzZWxlY3Rpb24sIHRoZSBpbmZvcm1hdGlvbgogICAgICogdHJhbnNmZXIgcGhhc2Ugc2hvdWxkIGJlIGEgTUVTU0FHRSBPVVQgcGhhc2Ugc28gdGhhdCB3ZSBjYW4gc2VuZCB0aGUKICAgICAqIElERU5USUZZIG1lc3NhZ2UuCiAgICAgKiAKICAgICAqIElmIFNDU0ktSUkgdGFnZ2VkIHF1ZXVpbmcgaXMgZW5hYmxlZCwgd2UgYWxzbyBzZW5kIGEgU0lNUExFX1FVRVVFX1RBRwogICAgICogbWVzc2FnZSAoMiBieXRlcykgd2l0aCBhIHRhZyBJRCB0aGF0IHdlIGluY3JlbWVudCB3aXRoIGV2ZXJ5IGNvbW1hbmQKICAgICAqIHVudGlsIGl0IHdyYXBzIGJhY2sgdG8gMC4KICAgICAqCiAgICAgKiBYWFggLSBpdCB0dXJucyBvdXQgdGhhdCB0aGVyZSBhcmUgc29tZSBicm9rZW4gU0NTSS1JSSBkZXZpY2VzLAogICAgICoJICAgICB3aGljaCBjbGFpbSB0byBzdXBwb3J0IHRhZ2dlZCBxdWV1aW5nIGJ1dCBmYWlsIHdoZW4gbW9yZSB0aGFuCiAgICAgKgkgICAgIHNvbWUgbnVtYmVyIG9mIGNvbW1hbmRzIGFyZSBpc3N1ZWQgYXQgb25jZS4KICAgICAqLwoKICAgIC8qIFdhaXQgZm9yIHN0YXJ0IG9mIFJFUS9BQ0sgaGFuZHNoYWtlICovCiAgICB3aGlsZSAoIShOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBTUl9SRVEpKTsKCiAgICBTRUxfUFJJTlRLKCJzY3NpJWQ6IHRhcmdldCAlZCBzZWxlY3RlZCwgZ29pbmcgaW50byBNRVNTQUdFIE9VVCBwaGFzZS5cbiIsCgkgICAgICAgSE9TVE5PLCBjbWQtPmRldmljZS0+aWQpOwogICAgdG1wWzBdID0gSURFTlRJRlkoMSwgY21kLT5kZXZpY2UtPmx1bik7CgojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICBpZiAoY21kLT50YWcgIT0gVEFHX05PTkUpIHsKCXRtcFsxXSA9IGhvc3RkYXRhLT5sYXN0X21lc3NhZ2UgPSBTSU1QTEVfUVVFVUVfVEFHOwoJdG1wWzJdID0gY21kLT50YWc7CglsZW4gPSAzOwogICAgfSBlbHNlIAoJbGVuID0gMTsKI2Vsc2UKICAgIGxlbiA9IDE7CiAgICBjbWQtPnRhZz0wOwojZW5kaWYgLyogU1VQUE9SVF9UQUdTICovCgogICAgLyogU2VuZCBtZXNzYWdlKHMpICovCiAgICBkYXRhID0gdG1wOwogICAgcGhhc2UgPSBQSEFTRV9NU0dPVVQ7CiAgICBOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAmZGF0YSk7CiAgICBTRUxfUFJJTlRLKCJzY3NpJWQ6IG5leHVzIGVzdGFibGlzaGVkLlxuIiwgSE9TVE5PKTsKICAgIC8qIFhYWCBuZWVkIHRvIGhhbmRsZSBlcnJvcnMgaGVyZSAqLwogICAgaG9zdGRhdGEtPmNvbm5lY3RlZCA9IGNtZDsKI2lmbmRlZiBTVVBQT1JUX1RBR1MKICAgIGhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gfD0gKDEgPDwgY21kLT5kZXZpY2UtPmx1bik7CiNlbmRpZiAgICAKCiAgICBpbml0aWFsaXplX1NDcChjbWQpOwoKCiAgICByZXR1cm4gMDsKfQoKLyogCiAqIEZ1bmN0aW9uIDogaW50IE5DUjUzODBfdHJhbnNmZXJfcGlvIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSwgCiAqICAgICAgdW5zaWduZWQgY2hhciAqcGhhc2UsIGludCAqY291bnQsIHVuc2lnbmVkIGNoYXIgKipkYXRhKQogKgogKiBQdXJwb3NlIDogdHJhbnNmZXJzIGRhdGEgaW4gZ2l2ZW4gcGhhc2UgdXNpbmcgcG9sbGVkIEkvTwogKgogKiBJbnB1dHMgOiBpbnN0YW5jZSAtIGluc3RhbmNlIG9mIGRyaXZlciwgKnBoYXNlIC0gcG9pbnRlciB0byAKICoJd2hhdCBwaGFzZSBpcyBleHBlY3RlZCwgKmNvdW50IC0gcG9pbnRlciB0byBudW1iZXIgb2YgCiAqCWJ5dGVzIHRvIHRyYW5zZmVyLCAqKmRhdGEgLSBwb2ludGVyIHRvIGRhdGEgcG9pbnRlci4KICogCiAqIFJldHVybnMgOiAtMSB3aGVuIGRpZmZlcmVudCBwaGFzZSBpcyBlbnRlcmVkIHdpdGhvdXQgdHJhbnNmZXJyaW5nCiAqCW1heGltdW0gbnVtYmVyIG9mIGJ5dGVzLCAwIGlmIGFsbCBieXRlcyBhcmUgdHJhbnNmZXJlZCBvciBleGl0CiAqCWlzIGluIHNhbWUgcGhhc2UuCiAqCiAqIAlBbHNvLCAqcGhhc2UsICpjb3VudCwgKmRhdGEgYXJlIG1vZGlmaWVkIGluIHBsYWNlLgogKgogKiBYWFggTm90ZSA6IGhhbmRsaW5nIGZvciBidXMgZnJlZSBtYXkgYmUgdXNlZnVsLgogKi8KCi8qCiAqIE5vdGUgOiB0aGlzIGNvZGUgaXMgbm90IGFzIHF1aWNrIGFzIGl0IGNvdWxkIGJlLCBob3dldmVyIGl0IAogKiBJUyAxMDAlIHJlbGlhYmxlLCBhbmQgZm9yIHRoZSBhY3R1YWwgZGF0YSB0cmFuc2ZlciB3aGVyZSBzcGVlZAogKiBjb3VudHMsIHdlIHdpbGwgYWx3YXlzIGRvIGEgcHNldWRvIERNQSBvciBETUEgdHJhbnNmZXIuCiAqLwoKc3RhdGljIGludCBOQ1I1MzgwX3RyYW5zZmVyX3Bpbyggc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UsIAoJCQkJIHVuc2lnbmVkIGNoYXIgKnBoYXNlLCBpbnQgKmNvdW50LAoJCQkJIHVuc2lnbmVkIGNoYXIgKipkYXRhKQp7CiAgICByZWdpc3RlciB1bnNpZ25lZCBjaGFyIHAgPSAqcGhhc2UsIHRtcDsKICAgIHJlZ2lzdGVyIGludCBjID0gKmNvdW50OwogICAgcmVnaXN0ZXIgdW5zaWduZWQgY2hhciAqZCA9ICpkYXRhOwoKICAgIC8qIAogICAgICogVGhlIE5DUjUzODAgY2hpcCB3aWxsIG9ubHkgZHJpdmUgdGhlIFNDU0kgYnVzIHdoZW4gdGhlIAogICAgICogcGhhc2Ugc3BlY2lmaWVkIGluIHRoZSBhcHByb3ByaWF0ZSBiaXRzIG9mIHRoZSBUQVJHRVQgQ09NTUFORAogICAgICogUkVHSVNURVIgbWF0Y2ggdGhlIFNUQVRVUyBSRUdJU1RFUgogICAgICovCgogICAgTkNSNTM4MF93cml0ZShUQVJHRVRfQ09NTUFORF9SRUcsIFBIQVNFX1NSX1RPX1RDUihwKSk7CgogICAgZG8gewoJLyogCgkgKiBXYWl0IGZvciBhc3NlcnRpb24gb2YgUkVRLCBhZnRlciB3aGljaCB0aGUgcGhhc2UgYml0cyB3aWxsIGJlIAoJICogdmFsaWQgCgkgKi8KCXdoaWxlICghKCh0bXAgPSBOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykpICYgU1JfUkVRKSk7CgoJSFNIX1BSSU5USygic2NzaSVkOiBSRVEgZGV0ZWN0ZWRcbiIsIEhPU1ROTyk7CgoJLyogQ2hlY2sgZm9yIHBoYXNlIG1pc21hdGNoICovCQoJaWYgKCh0bXAgJiBQSEFTRV9NQVNLKSAhPSBwKSB7CgkgICAgUElPX1BSSU5USygic2NzaSVkOiBwaGFzZSBtaXNtYXRjaFxuIiwgSE9TVE5PKTsKCSAgICBOQ1JfUFJJTlRfUEhBU0UoTkRFQlVHX1BJTyk7CgkgICAgYnJlYWs7Cgl9CgoJLyogRG8gYWN0dWFsIHRyYW5zZmVyIGZyb20gU0NTSSBidXMgdG8gLyBmcm9tIG1lbW9yeSAqLwoJaWYgKCEocCAmIFNSX0lPKSkgCgkgICAgTkNSNTM4MF93cml0ZShPVVRQVVRfREFUQV9SRUcsICpkKTsKCWVsc2UgCgkgICAgKmQgPSBOQ1I1MzgwX3JlYWQoQ1VSUkVOVF9TQ1NJX0RBVEFfUkVHKTsKCgkrK2Q7CgoJLyogCgkgKiBUaGUgU0NTSSBzdGFuZGFyZCBzdWdnZXN0cyB0aGF0IGluIE1TR09VVCBwaGFzZSwgdGhlIGluaXRpYXRvcgoJICogc2hvdWxkIGRyb3AgQVROIG9uIHRoZSBsYXN0IGJ5dGUgb2YgdGhlIG1lc3NhZ2UgcGhhc2UKCSAqIGFmdGVyIFJFUSBoYXMgYmVlbiBhc3NlcnRlZCBmb3IgdGhlIGhhbmRzaGFrZSBidXQgYmVmb3JlCgkgKiB0aGUgaW5pdGlhdG9yIHJhaXNlcyBBQ0suCgkgKi8KCglpZiAoIShwICYgU1JfSU8pKSB7CgkgICAgaWYgKCEoKHAgJiBTUl9NU0cpICYmIGMgPiAxKSkgewoJCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IAoJCSAgICBJQ1JfQVNTRVJUX0RBVEEpOwoJCU5DUl9QUklOVChOREVCVUdfUElPKTsKCQlOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCAKCQkJSUNSX0FTU0VSVF9EQVRBIHwgSUNSX0FTU0VSVF9BQ0spOwoJICAgIH0gZWxzZSB7CgkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwKCQkgICAgSUNSX0FTU0VSVF9EQVRBIHwgSUNSX0FTU0VSVF9BVE4pOwoJCU5DUl9QUklOVChOREVCVUdfUElPKTsKCQlOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCAKCQkgICAgSUNSX0FTU0VSVF9EQVRBIHwgSUNSX0FTU0VSVF9BVE4gfCBJQ1JfQVNTRVJUX0FDSyk7CgkgICAgfQoJfSBlbHNlIHsKCSAgICBOQ1JfUFJJTlQoTkRFQlVHX1BJTyk7CgkgICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9BQ0spOwoJfQoKCXdoaWxlIChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBTUl9SRVEpOwoKCUhTSF9QUklOVEsoInNjc2klZDogcmVxIGZhbHNlLCBoYW5kc2hha2UgY29tcGxldGVcbiIsIEhPU1ROTyk7CgovKgogKiBXZSBoYXZlIHNldmVyYWwgc3BlY2lhbCBjYXNlcyB0byBjb25zaWRlciBkdXJpbmcgUkVRL0FDSyBoYW5kc2hha2luZyA6IAogKiAxLiAgV2Ugd2VyZSBpbiBNU0dPVVQgcGhhc2UsIGFuZCB3ZSBhcmUgb24gdGhlIGxhc3QgYnl0ZSBvZiB0aGUgCiAqCW1lc3NhZ2UuICBBVE4gbXVzdCBiZSBkcm9wcGVkIGFzIEFDSyBpcyBkcm9wcGVkLgogKgogKiAyLiAgV2UgYXJlIGluIGEgTVNHSU4gcGhhc2UsIGFuZCB3ZSBhcmUgb24gdGhlIGxhc3QgYnl0ZSBvZiB0aGUgIAogKgltZXNzYWdlLiAgV2UgbXVzdCBleGl0IHdpdGggQUNLIGFzc2VydGVkLCBzbyB0aGF0IHRoZSBjYWxsaW5nCiAqCWNvZGUgbWF5IHJhaXNlIEFUTiBiZWZvcmUgZHJvcHBpbmcgQUNLIHRvIHJlamVjdCB0aGUgbWVzc2FnZS4KICoKICogMy4gIEFDSyBhbmQgQVROIGFyZSBjbGVhciBhbmQgdGhlIHRhcmdldCBtYXkgcHJvY2VlZCBhcyBub3JtYWwuCiAqLwoJaWYgKCEocCA9PSBQSEFTRV9NU0dJTiAmJiBjID09IDEpKSB7ICAKCSAgICBpZiAocCA9PSBQSEFTRV9NU0dPVVQgJiYgYyA+IDEpCgkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9BVE4pOwoJICAgIGVsc2UKCQlOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJfSAKICAgIH0gd2hpbGUgKC0tYyk7CgogICAgUElPX1BSSU5USygic2NzaSVkOiByZXNpZHVhbCAlZFxuIiwgSE9TVE5PLCBjKTsKCiAgICAqY291bnQgPSBjOwogICAgKmRhdGEgPSBkOwogICAgdG1wID0gTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpOwogICAgLyogVGhlIHBoYXNlIHJlYWQgZnJvbSB0aGUgYnVzIGlzIHZhbGlkIGlmIGVpdGhlciBSRVEgaXMgKGFscmVhZHkpCiAgICAgKiBhc3NlcnRlZCBvciBpZiBBQ0sgaGFzbid0IGJlZW4gcmVsZWFzZWQgeWV0LiBUaGUgbGF0dGVyIGlzIHRoZSBjYXNlIGlmCiAgICAgKiB3ZSdyZSBpbiBNU0dJTiBhbmQgYWxsIHdhbnRlZCBieXRlcyBoYXZlIGJlZW4gcmVjZWl2ZWQuICovCiAgICBpZiAoKHRtcCAmIFNSX1JFUSkgfHwgKHAgPT0gUEhBU0VfTVNHSU4gJiYgYyA9PSAwKSkKCSpwaGFzZSA9IHRtcCAmIFBIQVNFX01BU0s7CiAgICBlbHNlIAoJKnBoYXNlID0gUEhBU0VfVU5LTk9XTjsKCiAgICBpZiAoIWMgfHwgKCpwaGFzZSA9PSBwKSkKCXJldHVybiAwOwogICAgZWxzZSAKCXJldHVybiAtMTsKfQoKLyoKICogRnVuY3Rpb24gOiBkb19hYm9ydCAoU2NzaV9Ib3N0ICpob3N0KQogKiAKICogUHVycG9zZSA6IGFib3J0IHRoZSBjdXJyZW50bHkgZXN0YWJsaXNoZWQgbmV4dXMuICBTaG91bGQgb25seSBiZSAKICogCWNhbGxlZCBmcm9tIGEgcm91dGluZSB3aGljaCBjYW4gZHJvcCBpbnRvIGEgCiAqIAogKiBSZXR1cm5zIDogMCBvbiBzdWNjZXNzLCAtMSBvbiBmYWlsdXJlLgogKi8KCnN0YXRpYyBpbnQgZG9fYWJvcnQgKHN0cnVjdCBTY3NpX0hvc3QgKmhvc3QpIAp7CiAgICB1bnNpZ25lZCBjaGFyIHRtcCwgKm1zZ3B0ciwgcGhhc2U7CiAgICBpbnQgbGVuOwoKICAgIC8qIFJlcXVlc3QgbWVzc2FnZSBvdXQgcGhhc2UgKi8KICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfQVROKTsKCiAgICAvKiAKICAgICAqIFdhaXQgZm9yIHRoZSB0YXJnZXQgdG8gaW5kaWNhdGUgYSB2YWxpZCBwaGFzZSBieSBhc3NlcnRpbmcgCiAgICAgKiBSRVEuICBPbmNlIHRoaXMgaGFwcGVucywgd2UnbGwgaGF2ZSBlaXRoZXIgYSBNU0dPVVQgcGhhc2UgCiAgICAgKiBhbmQgY2FuIGltbWVkaWF0ZWx5IHNlbmQgdGhlIEFCT1JUIG1lc3NhZ2UsIG9yIHdlJ2xsIGhhdmUgc29tZSAKICAgICAqIG90aGVyIHBoYXNlIGFuZCB3aWxsIGhhdmUgdG8gc291cmNlL3NpbmsgZGF0YS4KICAgICAqIAogICAgICogV2UgcmVhbGx5IGRvbid0IGNhcmUgd2hhdCB2YWx1ZSB3YXMgb24gdGhlIGJ1cyBvciB3aGF0IHZhbHVlCiAgICAgKiB0aGUgdGFyZ2V0IHNlZXMsIHNvIHdlIGp1c3QgaGFuZHNoYWtlLgogICAgICovCiAgICAKICAgIHdoaWxlICghKHRtcCA9IE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSkgJiBTUl9SRVEpOwoKICAgIE5DUjUzODBfd3JpdGUoVEFSR0VUX0NPTU1BTkRfUkVHLCBQSEFTRV9TUl9UT19UQ1IodG1wKSk7CgogICAgaWYgKCh0bXAgJiBQSEFTRV9NQVNLKSAhPSBQSEFTRV9NU0dPVVQpIHsKCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfQVROIHwgCgkJICAgICAgSUNSX0FTU0VSVF9BQ0spOwoJd2hpbGUgKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFNSX1JFUSk7CglOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCBJQ1JfQVNTRVJUX0FUTik7CiAgICB9CiAgIAogICAgdG1wID0gQUJPUlQ7CiAgICBtc2dwdHIgPSAmdG1wOwogICAgbGVuID0gMTsKICAgIHBoYXNlID0gUEhBU0VfTVNHT1VUOwogICAgTkNSNTM4MF90cmFuc2Zlcl9waW8gKGhvc3QsICZwaGFzZSwgJmxlbiwgJm1zZ3B0cik7CgogICAgLyoKICAgICAqIElmIHdlIGdvdCBoZXJlLCBhbmQgdGhlIGNvbW1hbmQgY29tcGxldGVkIHN1Y2Nlc3NmdWxseSwKICAgICAqIHdlJ3JlIGFib3V0IHRvIGdvIGludG8gYnVzIGZyZWUgc3RhdGUuCiAgICAgKi8KCiAgICByZXR1cm4gbGVuID8gLTEgOiAwOwp9CgojaWYgZGVmaW5lZChSRUFMX0RNQSkKLyogCiAqIEZ1bmN0aW9uIDogaW50IE5DUjUzODBfdHJhbnNmZXJfZG1hIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSwgCiAqICAgICAgdW5zaWduZWQgY2hhciAqcGhhc2UsIGludCAqY291bnQsIHVuc2lnbmVkIGNoYXIgKipkYXRhKQogKgogKiBQdXJwb3NlIDogdHJhbnNmZXJzIGRhdGEgaW4gZ2l2ZW4gcGhhc2UgdXNpbmcgZWl0aGVyIHJlYWwKICoJb3IgcHNldWRvIERNQS4KICoKICogSW5wdXRzIDogaW5zdGFuY2UgLSBpbnN0YW5jZSBvZiBkcml2ZXIsICpwaGFzZSAtIHBvaW50ZXIgdG8gCiAqCXdoYXQgcGhhc2UgaXMgZXhwZWN0ZWQsICpjb3VudCAtIHBvaW50ZXIgdG8gbnVtYmVyIG9mIAogKglieXRlcyB0byB0cmFuc2ZlciwgKipkYXRhIC0gcG9pbnRlciB0byBkYXRhIHBvaW50ZXIuCiAqIAogKiBSZXR1cm5zIDogLTEgd2hlbiBkaWZmZXJlbnQgcGhhc2UgaXMgZW50ZXJlZCB3aXRob3V0IHRyYW5zZmVycmluZwogKgltYXhpbXVtIG51bWJlciBvZiBieXRlcywgMCBpZiBhbGwgYnl0ZXMgb3IgdHJhbnNmZXJlZCBvciBleGl0CiAqCWlzIGluIHNhbWUgcGhhc2UuCiAqCiAqIAlBbHNvLCAqcGhhc2UsICpjb3VudCwgKmRhdGEgYXJlIG1vZGlmaWVkIGluIHBsYWNlLgogKgogKi8KCgpzdGF0aWMgaW50IE5DUjUzODBfdHJhbnNmZXJfZG1hKCBzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSwgCgkJCQkgdW5zaWduZWQgY2hhciAqcGhhc2UsIGludCAqY291bnQsCgkJCQkgdW5zaWduZWQgY2hhciAqKmRhdGEpCnsKICAgIFNFVFVQX0hPU1REQVRBKGluc3RhbmNlKTsKICAgIHJlZ2lzdGVyIGludCBjID0gKmNvdW50OwogICAgcmVnaXN0ZXIgdW5zaWduZWQgY2hhciBwID0gKnBoYXNlOwogICAgcmVnaXN0ZXIgdW5zaWduZWQgY2hhciAqZCA9ICpkYXRhOwogICAgdW5zaWduZWQgY2hhciB0bXA7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwoKICAgIGlmICgodG1wID0gKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFBIQVNFX01BU0spKSAhPSBwKSB7CiAgICAgICAgKnBoYXNlID0gdG1wOwogICAgICAgIHJldHVybiAtMTsKICAgIH0KCiAgICBpZiAoYXRhcmlfcmVhZF9vdmVycnVucyAmJiAocCAmIFNSX0lPKSkgewoJYyAtPSBhdGFyaV9yZWFkX292ZXJydW5zOwogICAgfQoKICAgIERNQV9QUklOVEsoInNjc2klZDogaW5pdGlhbGl6aW5nIERNQSBmb3IgJXMsICVkIGJ5dGVzICVzICVwXG4iLAoJICAgICAgIEhPU1ROTywgKHAgJiBTUl9JTykgPyAicmVhZGluZyIgOiAid3JpdGluZyIsCgkgICAgICAgYywgKHAgJiBTUl9JTykgPyAidG8iIDogImZyb20iLCBkKTsKCiAgICBOQ1I1MzgwX3dyaXRlKFRBUkdFVF9DT01NQU5EX1JFRywgUEhBU0VfU1JfVE9fVENSKHApKTsKCiNpZmRlZiBSRUFMX0RNQQogICAgTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSB8IE1SX0RNQV9NT0RFIHwgTVJfRU5BQkxFX0VPUF9JTlRSIHwgTVJfTU9OSVRPUl9CU1kpOwojZW5kaWYgLyogZGVmIFJFQUxfRE1BICAqLwoKICAgIGlmIChJU19BX1RUKCkpIHsKCS8qIE9uIHRoZSBNZWR1c2EsIGl0IGlzIGEgbXVzdCB0byBpbml0aWFsaXplIHRoZSBETUEgYmVmb3JlCgkgKiBzdGFydGluZyB0aGUgTkNSLiBUaGlzIGlzIGFsc28gdGhlIGNsZWFuZXIgd2F5IGZvciB0aGUgVFQuCgkgKi8KCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKCWhvc3RkYXRhLT5kbWFfbGVuID0gKHAgJiBTUl9JTykgPwoJICAgIE5DUjUzODBfZG1hX3JlYWRfc2V0dXAoaW5zdGFuY2UsIGQsIGMpIDogCgkgICAgTkNSNTM4MF9kbWFfd3JpdGVfc2V0dXAoaW5zdGFuY2UsIGQsIGMpOwoJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogICAgfQogICAgCiAgICBpZiAocCAmIFNSX0lPKQoJTkNSNTM4MF93cml0ZShTVEFSVF9ETUFfSU5JVElBVE9SX1JFQ0VJVkVfUkVHLCAwKTsKICAgIGVsc2UgewoJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9EQVRBKTsKCU5DUjUzODBfd3JpdGUoU1RBUlRfRE1BX1NFTkRfUkVHLCAwKTsKICAgIH0KCiAgICBpZiAoIUlTX0FfVFQoKSkgewoJLyogT24gdGhlIEZhbGNvbiwgdGhlIERNQSBzZXR1cCBtdXN0IGJlIGRvbmUgYWZ0ZXIgdGhlIGxhc3QgKi8KCS8qIE5DUiBhY2Nlc3MsIGVsc2UgdGhlIERNQSBzZXR1cCBnZXRzIHRyYXNoZWQhCgkgKi8KCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKCWhvc3RkYXRhLT5kbWFfbGVuID0gKHAgJiBTUl9JTykgPwoJICAgIE5DUjUzODBfZG1hX3JlYWRfc2V0dXAoaW5zdGFuY2UsIGQsIGMpIDogCgkgICAgTkNSNTM4MF9kbWFfd3JpdGVfc2V0dXAoaW5zdGFuY2UsIGQsIGMpOwoJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogICAgfQogICAgcmV0dXJuIDA7Cn0KI2VuZGlmIC8qIGRlZmluZWQoUkVBTF9ETUEpICovCgovKgogKiBGdW5jdGlvbiA6IE5DUjUzODBfaW5mb3JtYXRpb25fdHJhbnNmZXIgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQogKgogKiBQdXJwb3NlIDogcnVuIHRocm91Z2ggdGhlIHZhcmlvdXMgU0NTSSBwaGFzZXMgYW5kIGRvIGFzIHRoZSB0YXJnZXQgCiAqIAlkaXJlY3RzIHVzIHRvLiAgT3BlcmF0ZXMgb24gdGhlIGN1cnJlbnRseSBjb25uZWN0ZWQgY29tbWFuZCwgCiAqCWluc3RhbmNlLT5jb25uZWN0ZWQuCiAqCiAqIElucHV0cyA6IGluc3RhbmNlLCBpbnN0YW5jZSBmb3Igd2hpY2ggd2UgYXJlIGRvaW5nIGNvbW1hbmRzCiAqCiAqIFNpZGUgZWZmZWN0cyA6IFNDU0kgdGhpbmdzIGhhcHBlbiwgdGhlIGRpc2Nvbm5lY3RlZCBxdWV1ZSB3aWxsIGJlIAogKgltb2RpZmllZCBpZiBhIGNvbW1hbmQgZGlzY29ubmVjdHMsICppbnN0YW5jZS0+Y29ubmVjdGVkIHdpbGwKICoJY2hhbmdlLgogKgogKiBYWFggTm90ZSA6IHdlIG5lZWQgdG8gd2F0Y2ggZm9yIGJ1cyBmcmVlIG9yIGEgcmVzZXQgY29uZGl0aW9uIGhlcmUgCiAqIAl0byByZWNvdmVyIGZyb20gYW4gdW5leHBlY3RlZCBidXMgZnJlZSBjb25kaXRpb24uCiAqLwogCnN0YXRpYyB2b2lkIE5DUjUzODBfaW5mb3JtYXRpb25fdHJhbnNmZXIgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQp7CiAgICBTRVRVUF9IT1NUREFUQShpbnN0YW5jZSk7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwogICAgdW5zaWduZWQgY2hhciBtc2dvdXQgPSBOT1A7CiAgICBpbnQgc2luayA9IDA7CiAgICBpbnQgbGVuOwojaWYgZGVmaW5lZChSRUFMX0RNQSkKICAgIGludCB0cmFuc2ZlcnNpemU7CiNlbmRpZgogICAgdW5zaWduZWQgY2hhciAqZGF0YTsKICAgIHVuc2lnbmVkIGNoYXIgcGhhc2UsIHRtcCwgZXh0ZW5kZWRfbXNnWzEwXSwgb2xkX3BoYXNlPTB4ZmY7CiAgICBTY3NpX0NtbmQgKmNtZCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmNvbm5lY3RlZDsKCiAgICB3aGlsZSAoMSkgewoJdG1wID0gTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpOwoJLyogV2Ugb25seSBoYXZlIGEgdmFsaWQgU0NTSSBwaGFzZSB3aGVuIFJFUSBpcyBhc3NlcnRlZCAqLwoJaWYgKHRtcCAmIFNSX1JFUSkgewoJICAgIHBoYXNlID0gKHRtcCAmIFBIQVNFX01BU0spOyAKCSAgICBpZiAocGhhc2UgIT0gb2xkX3BoYXNlKSB7CgkJb2xkX3BoYXNlID0gcGhhc2U7CgkJTkNSX1BSSU5UX1BIQVNFKE5ERUJVR19JTkZPUk1BVElPTik7CgkgICAgfQoJICAgIAoJICAgIGlmIChzaW5rICYmIChwaGFzZSAhPSBQSEFTRV9NU0dPVVQpKSB7CgkJTkNSNTM4MF93cml0ZShUQVJHRVRfQ09NTUFORF9SRUcsIFBIQVNFX1NSX1RPX1RDUih0bXApKTsKCgkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9BVE4gfCAKCQkgICAgSUNSX0FTU0VSVF9BQ0spOwoJCXdoaWxlIChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBTUl9SRVEpOwoJCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IAoJCSAgICBJQ1JfQVNTRVJUX0FUTik7CgkJc2luayA9IDA7CgkJY29udGludWU7CgkgICAgfQoKCSAgICBzd2l0Y2ggKHBoYXNlKSB7CgkgICAgY2FzZSBQSEFTRV9EQVRBT1VUOgojaWYgKE5ERUJVRyAmIE5ERUJVR19OT19EQVRBT1VUKQoJCXByaW50aygic2NzaSVkOiBOREVCVUdfTk9fREFUQU9VVCBzZXQsIGF0dGVtcHRlZCBEQVRBT1VUICIKCQkgICAgICAgImFib3J0ZWRcbiIsIEhPU1ROTyk7CgkJc2luayA9IDE7CgkJZG9fYWJvcnQoaW5zdGFuY2UpOwoJCWNtZC0+cmVzdWx0ID0gRElEX0VSUk9SICA8PCAxNjsKCQljbWQtPmRvbmUoY21kKTsKCQlyZXR1cm47CiNlbmRpZgoJICAgIGNhc2UgUEhBU0VfREFUQUlOOgoJCS8qIAoJCSAqIElmIHRoZXJlIGlzIG5vIHJvb20gbGVmdCBpbiB0aGUgY3VycmVudCBidWZmZXIgaW4gdGhlCgkJICogc2NhdHRlci1nYXRoZXIgbGlzdCwgbW92ZSBvbnRvIHRoZSBuZXh0IG9uZS4KCQkgKi8KCgkJaWYgKCFjbWQtPlNDcC50aGlzX3Jlc2lkdWFsICYmIGNtZC0+U0NwLmJ1ZmZlcnNfcmVzaWR1YWwpIHsKCQkgICAgKytjbWQtPlNDcC5idWZmZXI7CgkJICAgIC0tY21kLT5TQ3AuYnVmZmVyc19yZXNpZHVhbDsKCQkgICAgY21kLT5TQ3AudGhpc19yZXNpZHVhbCA9IGNtZC0+U0NwLmJ1ZmZlci0+bGVuZ3RoOwoJCSAgICBjbWQtPlNDcC5wdHIgPSBwYWdlX2FkZHJlc3MoY21kLT5TQ3AuYnVmZmVyLT5wYWdlKSsKCQkJCSAgIGNtZC0+U0NwLmJ1ZmZlci0+b2Zmc2V0OwoJCSAgICAvKiArK3JvbWFuOiBUcnkgdG8gbWVyZ2Ugc29tZSBzY2F0dGVyLWJ1ZmZlcnMgaWYKCQkgICAgICogdGhleSBhcmUgYXQgY29udGlndW91cyBwaHlzaWNhbCBhZGRyZXNzZXMuCgkJICAgICAqLwoJCSAgICBtZXJnZV9jb250aWd1b3VzX2J1ZmZlcnMoIGNtZCApOwoJCSAgICBJTkZfUFJJTlRLKCJzY3NpJWQ6ICVkIGJ5dGVzIGFuZCAlZCBidWZmZXJzIGxlZnRcbiIsCgkJCSAgICAgICBIT1NUTk8sIGNtZC0+U0NwLnRoaXNfcmVzaWR1YWwsCgkJCSAgICAgICBjbWQtPlNDcC5idWZmZXJzX3Jlc2lkdWFsKTsKCQl9CgoJCS8qCgkJICogVGhlIHByZWZlcnJlZCB0cmFuc2ZlciBtZXRob2QgaXMgZ29pbmcgdG8gYmUgCgkJICogUFNFVURPLURNQSBmb3Igc3lzdGVtcyB0aGF0IGFyZSBzdHJpY3RseSBQSU8sCgkJICogc2luY2Ugd2UgY2FuIGxldCB0aGUgaGFyZHdhcmUgZG8gdGhlIGhhbmRzaGFraW5nLgoJCSAqCgkJICogRm9yIHRoaXMgdG8gd29yaywgd2UgbmVlZCB0byBrbm93IHRoZSB0cmFuc2ZlcnNpemUKCQkgKiBhaGVhZCBvZiB0aW1lLCBzaW5jZSB0aGUgcHNldWRvLURNQSBjb2RlIHdpbGwgc2l0CgkJICogaW4gYW4gdW5jb25kaXRpb25hbCBsb29wLgoJCSAqLwoKLyogKytyb21hbjogSSBzdWdnZXN0LCB0aGlzIHNob3VsZCBiZQogKiAgICNpZiBkZWYoUkVBTF9ETUEpCiAqIGluc3RlYWQgb2YgbGVhdmluZyBSRUFMX0RNQSBvdXQuCiAqLwoKI2lmIGRlZmluZWQoUkVBTF9ETUEpCgkJaWYgKCFjbWQtPmRldmljZS0+Ym9ya2VuICYmCgkJICAgICh0cmFuc2ZlcnNpemUgPSBOQ1I1MzgwX2RtYV94ZmVyX2xlbihpbnN0YW5jZSxjbWQscGhhc2UpKSA+IDMxKSB7CgkJICAgIGxlbiA9IHRyYW5zZmVyc2l6ZTsKCQkgICAgY21kLT5TQ3AucGhhc2UgPSBwaGFzZTsKCQkgICAgaWYgKE5DUjUzODBfdHJhbnNmZXJfZG1hKGluc3RhbmNlLCAmcGhhc2UsCgkJCSZsZW4sICh1bnNpZ25lZCBjaGFyICoqKSAmY21kLT5TQ3AucHRyKSkgewoJCQkvKgoJCQkgKiBJZiB0aGUgd2F0Y2hkb2cgdGltZXIgZmlyZXMsIGFsbCBmdXR1cmUKCQkJICogYWNjZXNzZXMgdG8gdGhpcyBkZXZpY2Ugd2lsbCB1c2UgdGhlCgkJCSAqIHBvbGxlZC1JTy4gKi8gCgkJCXByaW50ayhLRVJOX05PVElDRSAic2NzaSVkOiBzd2l0Y2hpbmcgdGFyZ2V0ICVkICIKCQkJICAgICAgICJsdW4gJWQgdG8gc2xvdyBoYW5kc2hha2VcbiIsIEhPU1ROTywKCQkJICAgICAgIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1bik7CgkJCWNtZC0+ZGV2aWNlLT5ib3JrZW4gPSAxOwoJCQlOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCAKCQkJICAgIElDUl9BU1NFUlRfQVROKTsKCQkJc2luayA9IDE7CgkJCWRvX2Fib3J0KGluc3RhbmNlKTsKCQkJY21kLT5yZXN1bHQgPSBESURfRVJST1IgIDw8IDE2OwoJCQljbWQtPmRvbmUoY21kKTsKCQkJLyogWFhYIC0gbmVlZCB0byBzb3VyY2Ugb3Igc2luayBkYXRhIGhlcmUsIGFzIGFwcHJvcHJpYXRlICovCgkJICAgIH0gZWxzZSB7CiNpZmRlZiBSRUFMX0RNQQoJCQkvKiArK3JvbWFuOiBXaGVuIHVzaW5nIHJlYWwgRE1BLAoJCQkgKiBpbmZvcm1hdGlvbl90cmFuc2ZlcigpIHNob3VsZCByZXR1cm4gYWZ0ZXIKCQkJICogc3RhcnRpbmcgRE1BIHNpbmNlIGl0IGhhcyBub3RoaW5nIG1vcmUgdG8KCQkJICogZG8uCgkJCSAqLwoJCQlyZXR1cm47CiNlbHNlCQkJCgkJCWNtZC0+U0NwLnRoaXNfcmVzaWR1YWwgLT0gdHJhbnNmZXJzaXplIC0gbGVuOwojZW5kaWYKCQkgICAgfQoJCX0gZWxzZQojZW5kaWYgLyogZGVmaW5lZChSRUFMX0RNQSkgKi8KCQkgIE5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsIAoJCSAgICAoaW50ICopICZjbWQtPlNDcC50aGlzX3Jlc2lkdWFsLCAodW5zaWduZWQgY2hhciAqKikKCQkgICAgJmNtZC0+U0NwLnB0cik7CgkJYnJlYWs7CgkgICAgY2FzZSBQSEFTRV9NU0dJTjoKCQlsZW4gPSAxOwoJCWRhdGEgPSAmdG1wOwoJCU5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIDApOyAJLyogZGlzYWJsZSByZXNlbGVjdHMgKi8KCQlOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAmZGF0YSk7CgkJY21kLT5TQ3AuTWVzc2FnZSA9IHRtcDsKCgkJc3dpdGNoICh0bXApIHsKCQkvKgoJCSAqIExpbmtpbmcgbGV0cyB1cyByZWR1Y2UgdGhlIHRpbWUgcmVxdWlyZWQgdG8gZ2V0IHRoZSAKCQkgKiBuZXh0IGNvbW1hbmQgb3V0IHRvIHRoZSBkZXZpY2UsIGhvcGVmdWxseSB0aGlzIHdpbGwKCQkgKiBtZWFuIHdlIGRvbid0IHdhc3RlIGFub3RoZXIgcmV2b2x1dGlvbiBkdWUgdG8gdGhlIGRlbGF5cwoJCSAqIHJlcXVpcmVkIGJ5IEFSQklUUkFUSU9OIGFuZCBhbm90aGVyIFNFTEVDVElPTi4KCQkgKgoJCSAqIEluIHRoZSBjdXJyZW50IGltcGxlbWVudGF0aW9uIHByb3Bvc2FsLCBsb3cgbGV2ZWwgZHJpdmVycwoJCSAqIG1lcmVseSBoYXZlIHRvIHN0YXJ0IHRoZSBuZXh0IGNvbW1hbmQsIHBvaW50ZWQgdG8gYnkgCgkJICogbmV4dF9saW5rLCBkb25lKCkgaXMgY2FsbGVkIGFzIHdpdGggdW5saW5rZWQgY29tbWFuZHMuCgkJICovCiNpZmRlZiBMSU5LRUQKCQljYXNlIExJTktFRF9DTURfQ09NUExFVEU6CgkJY2FzZSBMSU5LRURfRkxHX0NNRF9DT01QTEVURToKCQkgICAgLyogQWNjZXB0IG1lc3NhZ2UgYnkgY2xlYXJpbmcgQUNLICovCgkJICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CgkJICAgIAoJCSAgICBMTktfUFJJTlRLKCJzY3NpJWQ6IHRhcmdldCAlZCBsdW4gJWQgbGlua2VkIGNvbW1hbmQgIgoJCQkgICAgICAgImNvbXBsZXRlLlxuIiwgSE9TVE5PLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwoKCQkgICAgLyogRW5hYmxlIHJlc2VsZWN0IGludGVycnVwdHMgKi8KCQkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJCSAgICAvKgoJCSAgICAgKiBTYW5pdHkgY2hlY2sgOiBBIGxpbmtlZCBjb21tYW5kIHNob3VsZCBvbmx5IHRlcm1pbmF0ZQoJCSAgICAgKiB3aXRoIG9uZSBvZiB0aGVzZSBtZXNzYWdlcyBpZiB0aGVyZSBhcmUgbW9yZSBsaW5rZWQKCQkgICAgICogY29tbWFuZHMgYXZhaWxhYmxlLgoJCSAgICAgKi8KCgkJICAgIGlmICghY21kLT5uZXh0X2xpbmspIHsKCQkJIHByaW50ayhLRVJOX05PVElDRSAic2NzaSVkOiB0YXJnZXQgJWQgbHVuICVkICIKCQkJCSJsaW5rZWQgY29tbWFuZCBjb21wbGV0ZSwgbm8gbmV4dF9saW5rXG4iLAoJCQkJSE9TVE5PLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwoJCQkgICAgc2luayA9IDE7CgkJCSAgICBkb19hYm9ydCAoaW5zdGFuY2UpOwoJCQkgICAgcmV0dXJuOwoJCSAgICB9CgoJCSAgICBpbml0aWFsaXplX1NDcChjbWQtPm5leHRfbGluayk7CgkJICAgIC8qIFRoZSBuZXh0IGNvbW1hbmQgaXMgc3RpbGwgcGFydCBvZiB0aGlzIHByb2Nlc3M7IGNvcHkgaXQKCQkgICAgICogYW5kIGRvbid0IGZyZWUgaXQhICovCgkJICAgIGNtZC0+bmV4dF9saW5rLT50YWcgPSBjbWQtPnRhZzsKCQkgICAgY21kLT5yZXN1bHQgPSBjbWQtPlNDcC5TdGF0dXMgfCAoY21kLT5TQ3AuTWVzc2FnZSA8PCA4KTsgCgkJICAgIExOS19QUklOVEsoInNjc2klZDogdGFyZ2V0ICVkIGx1biAlZCBsaW5rZWQgcmVxdWVzdCAiCgkJCSAgICAgICAiZG9uZSwgY2FsbGluZyBzY3NpX2RvbmUoKS5cbiIsCgkJCSAgICAgICBIT1NUTk8sIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1bik7CiNpZmRlZiBOQ1I1MzgwX1NUQVRTCgkJICAgIGNvbGxlY3Rfc3RhdHMoaG9zdGRhdGEsIGNtZCk7CiNlbmRpZgoJCSAgICBjbWQtPnNjc2lfZG9uZShjbWQpOwoJCSAgICBjbWQgPSBob3N0ZGF0YS0+Y29ubmVjdGVkOwoJCSAgICBicmVhazsKI2VuZGlmIC8qIGRlZiBMSU5LRUQgKi8KCQljYXNlIEFCT1JUOgoJCWNhc2UgQ09NTUFORF9DT01QTEVURTogCgkJICAgIC8qIEFjY2VwdCBtZXNzYWdlIGJ5IGNsZWFyaW5nIEFDSyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJCSAgICAvKiArK2d1ZW50aGVyOiBwb3NzaWJsZSByYWNlIHdpdGggRmFsY29uIGxvY2tpbmcgKi8KCQkgICAgZmFsY29uX2RvbnRfcmVsZWFzZSsrOwoJCSAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gTlVMTDsKCQkgICAgUVVfUFJJTlRLKCJzY3NpJWQ6IGNvbW1hbmQgZm9yIHRhcmdldCAlZCwgbHVuICVkICIKCQkJICAgICAgImNvbXBsZXRlZFxuIiwgSE9TVE5PLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwojaWZkZWYgU1VQUE9SVF9UQUdTCgkJICAgIGNtZF9mcmVlX3RhZyggY21kICk7CgkJICAgIGlmIChzdGF0dXNfYnl0ZShjbWQtPlNDcC5TdGF0dXMpID09IFFVRVVFX0ZVTEwpIHsKCQkJLyogVHVybiBhIFFVRVVFIEZVTEwgc3RhdHVzIGludG8gQlVTWSwgSSB0aGluayB0aGUKCQkJICogbWlkIGxldmVsIGNhbm5vdCBoYW5kbGUgUVVFVUUgRlVMTCA6LSggKFRoZQoJCQkgKiBjb21tYW5kIGlzIHJldHJpZWQgYWZ0ZXIgQlVTWSkuIEFsc28gdXBkYXRlIG91cgoJCQkgKiBxdWV1ZSBzaXplIHRvIHRoZSBudW1iZXIgb2YgY3VycmVudGx5IGlzc3VlZAoJCQkgKiBjb21tYW5kcyBub3cuCgkJCSAqLwoJCQkvKiArK0FuZHJlYXM6IHRoZSBtaWQgbGV2ZWwgY29kZSBrbm93cyBhYm91dAoJCQkgICBRVUVVRV9GVUxMIG5vdy4gKi8KCQkJVEFHX0FMTE9DICp0YSA9ICZUYWdBbGxvY1tjbWQtPmRldmljZS0+aWRdW2NtZC0+ZGV2aWNlLT5sdW5dOwoJCQlUQUdfUFJJTlRLKCJzY3NpJWQ6IHRhcmdldCAlZCBsdW4gJWQgcmV0dXJuZWQgIgoJCQkJICAgIlFVRVVFX0ZVTEwgYWZ0ZXIgJWQgY29tbWFuZHNcbiIsCgkJCQkgICBIT1NUTk8sIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1biwKCQkJCSAgIHRhLT5ucl9hbGxvY2F0ZWQpOwoJCQlpZiAodGEtPnF1ZXVlX3NpemUgPiB0YS0+bnJfYWxsb2NhdGVkKQoJCQkgICAgdGEtPm5yX2FsbG9jYXRlZCA9IHRhLT5xdWV1ZV9zaXplOwoJCSAgICB9CiNlbHNlCgkJICAgIGhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gJj0gfigxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwojZW5kaWYKCQkgICAgLyogRW5hYmxlIHJlc2VsZWN0IGludGVycnVwdHMgKi8KCQkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoKCQkgICAgLyogCgkJICAgICAqIEknbSBub3Qgc3VyZSB3aGF0IHRoZSBjb3JyZWN0IHRoaW5nIHRvIGRvIGhlcmUgaXMgOiAKCQkgICAgICogCgkJICAgICAqIElmIHRoZSBjb21tYW5kIHRoYXQganVzdCBleGVjdXRlZCBpcyBOT1QgYSByZXF1ZXN0IAoJCSAgICAgKiBzZW5zZSwgdGhlIG9idmlvdXMgdGhpbmcgdG8gZG8gaXMgdG8gc2V0IHRoZSByZXN1bHQKCQkgICAgICogY29kZSB0byB0aGUgdmFsdWVzIG9mIHRoZSBzdG9yZWQgcGFyYW1ldGVycy4KCQkgICAgICogCgkJICAgICAqIElmIGl0IHdhcyBhIFJFUVVFU1QgU0VOU0UgY29tbWFuZCwgd2UgbmVlZCBzb21lIHdheSB0bwoJCSAgICAgKiBkaWZmZXJlbnRpYXRlIGJldHdlZW4gdGhlIGZhaWx1cmUgY29kZSBvZiB0aGUgb3JpZ2luYWwKCQkgICAgICogYW5kIHRoZSBmYWlsdXJlIGNvZGUgb2YgdGhlIFJFUVVFU1Qgc2Vuc2UgLSB0aGUgb2J2aW91cwoJCSAgICAgKiBjYXNlIGlzIHN1Y2Nlc3MsIHdoZXJlIHdlIGZhbGwgdGhyb3VnaCBhbmQgbGVhdmUgdGhlCgkJICAgICAqIHJlc3VsdCBjb2RlIHVuY2hhbmdlZC4KCQkgICAgICogCgkJICAgICAqIFRoZSBub24tb2J2aW91cyBwbGFjZSBpcyB3aGVyZSB0aGUgUkVRVUVTVCBTRU5TRSBmYWlsZWQKCQkgICAgICovCgoJCSAgICBpZiAoY21kLT5jbW5kWzBdICE9IFJFUVVFU1RfU0VOU0UpIAoJCQljbWQtPnJlc3VsdCA9IGNtZC0+U0NwLlN0YXR1cyB8IChjbWQtPlNDcC5NZXNzYWdlIDw8IDgpOyAKCQkgICAgZWxzZSBpZiAoc3RhdHVzX2J5dGUoY21kLT5TQ3AuU3RhdHVzKSAhPSBHT09EKQoJCQljbWQtPnJlc3VsdCA9IChjbWQtPnJlc3VsdCAmIDB4MDBmZmZmKSB8IChESURfRVJST1IgPDwgMTYpOwoJCSAgICAKI2lmZGVmIEFVVE9TRU5TRQoJCSAgICBpZiAoKGNtZC0+Y21uZFswXSAhPSBSRVFVRVNUX1NFTlNFKSAmJiAKCQkJKHN0YXR1c19ieXRlKGNtZC0+U0NwLlN0YXR1cykgPT0gQ0hFQ0tfQ09ORElUSU9OKSkgewoJCQlBU0VOX1BSSU5USygic2NzaSVkOiBwZXJmb3JtaW5nIHJlcXVlc3Qgc2Vuc2VcbiIsCgkJCQkgICAgSE9TVE5PKTsKCQkJY21kLT5jbW5kWzBdID0gUkVRVUVTVF9TRU5TRTsKCQkJY21kLT5jbW5kWzFdICY9IDB4ZTA7CgkJCWNtZC0+Y21uZFsyXSA9IDA7CgkJCWNtZC0+Y21uZFszXSA9IDA7CgkJCWNtZC0+Y21uZFs0XSA9IHNpemVvZihjbWQtPnNlbnNlX2J1ZmZlcik7CgkJCWNtZC0+Y21uZFs1XSA9IDA7CgkJCWNtZC0+Y21kX2xlbiA9IENPTU1BTkRfU0laRShjbWQtPmNtbmRbMF0pOwoKCQkJY21kLT51c2Vfc2cgPSAwOwoJCQkvKiB0aGlzIGlzIGluaXRpYWxpemVkIGZyb20gaW5pdGlhbGl6ZV9TQ3AgCgkJCWNtZC0+U0NwLmJ1ZmZlciA9IE5VTEw7CgkJCWNtZC0+U0NwLmJ1ZmZlcnNfcmVzaWR1YWwgPSAwOwoJCQkqLwoJCQljbWQtPnJlcXVlc3RfYnVmZmVyID0gKGNoYXIgKikgY21kLT5zZW5zZV9idWZmZXI7CgkJCWNtZC0+cmVxdWVzdF9idWZmbGVuID0gc2l6ZW9mKGNtZC0+c2Vuc2VfYnVmZmVyKTsKCgkJCWxvY2FsX2lycV9zYXZlKGZsYWdzKTsKCQkJTElTVChjbWQsaG9zdGRhdGEtPmlzc3VlX3F1ZXVlKTsKCQkJTkVYVChjbWQpID0gaG9zdGRhdGEtPmlzc3VlX3F1ZXVlOwoJCSAgICAgICAgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlID0gKFNjc2lfQ21uZCAqKSBjbWQ7CgkJICAgICAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkJCVFVX1BSSU5USygic2NzaSVkOiBSRVFVRVNUIFNFTlNFIGFkZGVkIHRvIGhlYWQgb2YgIgoJCQkJICAiaXNzdWUgcXVldWVcbiIsIEhfTk8oY21kKSk7CgkJICAgfSBlbHNlCiNlbmRpZiAvKiBkZWYgQVVUT1NFTlNFICovCgkJICAgewojaWZkZWYgTkNSNTM4MF9TVEFUUwoJCSAgICAgICBjb2xsZWN0X3N0YXRzKGhvc3RkYXRhLCBjbWQpOwojZW5kaWYKCQkgICAgICAgY21kLT5zY3NpX2RvbmUoY21kKTsKCQkgICAgfQoKCQkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJCSAgICAvKiAKCQkgICAgICogUmVzdG9yZSBwaGFzZSBiaXRzIHRvIDAgc28gYW4gaW50ZXJydXB0ZWQgc2VsZWN0aW9uLCAKCQkgICAgICogYXJiaXRyYXRpb24gY2FuIHJlc3VtZS4KCQkgICAgICovCgkJICAgIE5DUjUzODBfd3JpdGUoVEFSR0VUX0NPTU1BTkRfUkVHLCAwKTsKCQkgICAgCgkJICAgIHdoaWxlICgoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfQlNZKSAmJiAhaG9zdGRhdGEtPmNvbm5lY3RlZCkKCQkJYmFycmllcigpOwoKCQkgICAgZmFsY29uX2RvbnRfcmVsZWFzZS0tOwoJCSAgICAvKiArK3JvbWFuOiBGb3IgRmFsY29uIFNDU0ksIHJlbGVhc2UgdGhlIGxvY2sgb24gdGhlCgkJICAgICAqIFNULURNQSBoZXJlIGlmIG5vIG90aGVyIGNvbW1hbmRzIGFyZSB3YWl0aW5nIG9uIHRoZQoJCSAgICAgKiBkaXNjb25uZWN0ZWQgcXVldWUuCgkJICAgICAqLwoJCSAgICBmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOwoJCSAgICByZXR1cm47CgkJY2FzZSBNRVNTQUdFX1JFSkVDVDoKCQkgICAgLyogQWNjZXB0IG1lc3NhZ2UgYnkgY2xlYXJpbmcgQUNLICovCgkJICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CgkJICAgIC8qIEVuYWJsZSByZXNlbGVjdCBpbnRlcnJ1cHRzICovCgkJICAgIE5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKCQkgICAgc3dpdGNoIChob3N0ZGF0YS0+bGFzdF9tZXNzYWdlKSB7CgkJICAgIGNhc2UgSEVBRF9PRl9RVUVVRV9UQUc6CgkJICAgIGNhc2UgT1JERVJFRF9RVUVVRV9UQUc6CgkJICAgIGNhc2UgU0lNUExFX1FVRVVFX1RBRzoKCQkJLyogVGhlIHRhcmdldCBvYnZpb3VzbHkgZG9lc24ndCBzdXBwb3J0IHRhZ2dlZAoJCQkgKiBxdWV1aW5nLCBldmVuIHRob3VnaCBpdCBhbm5vdW5jZWQgdGhpcyBhYmlsaXR5IGluCgkJCSAqIGl0cyBJTlFVSVJZIGRhdGEgPyE/IChtYXliZSBvbmx5IHRoaXMgTFVOPykgT2ssCgkJCSAqIGNsZWFyICd0YWdnZWRfc3VwcG9ydGVkJyBhbmQgbG9jayB0aGUgTFVOLCBzaW5jZQoJCQkgKiB0aGUgY29tbWFuZCBpcyB0cmVhdGVkIGFzIHVudGFnZ2VkIGZ1cnRoZXIgb24uCgkJCSAqLwoJCQljbWQtPmRldmljZS0+dGFnZ2VkX3N1cHBvcnRlZCA9IDA7CgkJCWhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gfD0gKDEgPDwgY21kLT5kZXZpY2UtPmx1bik7CgkJCWNtZC0+dGFnID0gVEFHX05PTkU7CgkJCVRBR19QUklOVEsoInNjc2klZDogdGFyZ2V0ICVkIGx1biAlZCByZWplY3RlZCAiCgkJCQkgICAiUVVFVUVfVEFHIG1lc3NhZ2U7IHRhZ2dlZCBxdWV1aW5nICIKCQkJCSAgICJkaXNhYmxlZFxuIiwKCQkJCSAgIEhPU1ROTywgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuKTsKCQkJYnJlYWs7CgkJICAgIH0KCQkgICAgYnJlYWs7CgkJY2FzZSBESVNDT05ORUNUOgoJCSAgICAvKiBBY2NlcHQgbWVzc2FnZSBieSBjbGVhcmluZyBBQ0sgKi8KCQkgICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCQkgICAgbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwoJCSAgICBjbWQtPmRldmljZS0+ZGlzY29ubmVjdCA9IDE7CgkJICAgIExJU1QoY21kLGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUpOwoJCSAgICBORVhUKGNtZCkgPSBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlOwoJCSAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gTlVMTDsKCQkgICAgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSA9IGNtZDsKCQkgICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJCSAgICBRVV9QUklOVEsoInNjc2klZDogY29tbWFuZCBmb3IgdGFyZ2V0ICVkIGx1biAlZCB3YXMgIgoJCQkgICAgICAibW92ZWQgZnJvbSBjb25uZWN0ZWQgdG8gdGhlICIKCQkJICAgICAgImRpc2Nvbm5lY3RlZF9xdWV1ZVxuIiwgSE9TVE5PLCAKCQkJICAgICAgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuKTsKCQkgICAgLyogCgkJICAgICAqIFJlc3RvcmUgcGhhc2UgYml0cyB0byAwIHNvIGFuIGludGVycnVwdGVkIHNlbGVjdGlvbiwgCgkJICAgICAqIGFyYml0cmF0aW9uIGNhbiByZXN1bWUuCgkJICAgICAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKFRBUkdFVF9DT01NQU5EX1JFRywgMCk7CgoJCSAgICAvKiBFbmFibGUgcmVzZWxlY3QgaW50ZXJydXB0cyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CgkJICAgIC8qIFdhaXQgZm9yIGJ1cyBmcmVlIHRvIGF2b2lkIG5hc3R5IHRpbWVvdXRzICovCgkJICAgIHdoaWxlICgoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfQlNZKSAmJiAhaG9zdGRhdGEtPmNvbm5lY3RlZCkKCQkgICAgCWJhcnJpZXIoKTsKCQkgICAgcmV0dXJuOwoJCS8qIAoJCSAqIFRoZSBTQ1NJIGRhdGEgcG9pbnRlciBpcyAqSU1QTElDSVRMWSogc2F2ZWQgb24gYSBkaXNjb25uZWN0CgkJICogb3BlcmF0aW9uLCBpbiB2aW9sYXRpb24gb2YgdGhlIFNDU0kgc3BlYyBzbyB3ZSBjYW4gc2FmZWx5IAoJCSAqIGlnbm9yZSBTQVZFL1JFU1RPUkUgcG9pbnRlcnMgY2FsbHMuCgkJICoKCQkgKiBVbmZvcnR1bmF0ZWx5LCBzb21lIGRpc2tzIHZpb2xhdGUgdGhlIFNDU0kgc3BlYyBhbmQgCgkJICogZG9uJ3QgaXNzdWUgdGhlIHJlcXVpcmVkIFNBVkVfUE9JTlRFUlMgbWVzc2FnZSBiZWZvcmUKCQkgKiBkaXNjb25uZWN0aW5nLCBhbmQgd2UgaGF2ZSB0byBicmVhayBzcGVjIHRvIHJlbWFpbiAKCQkgKiBjb21wYXRpYmxlLgoJCSAqLwoJCWNhc2UgU0FWRV9QT0lOVEVSUzoKCQljYXNlIFJFU1RPUkVfUE9JTlRFUlM6CgkJICAgIC8qIEFjY2VwdCBtZXNzYWdlIGJ5IGNsZWFyaW5nIEFDSyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJCSAgICAvKiBFbmFibGUgcmVzZWxlY3QgaW50ZXJydXB0cyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CgkJICAgIGJyZWFrOwoJCWNhc2UgRVhURU5ERURfTUVTU0FHRToKLyogCiAqIEV4dGVuZGVkIG1lc3NhZ2VzIGFyZSBzZW50IGluIHRoZSBmb2xsb3dpbmcgZm9ybWF0IDoKICogQnl0ZSAJCiAqIDAJCUVYVEVOREVEX01FU1NBR0UgPT0gMQogKiAxCQlsZW5ndGggKGluY2x1ZGVzIG9uZSBieXRlIGZvciBjb2RlLCBkb2Vzbid0IAogKgkJaW5jbHVkZSBmaXJzdCB0d28gYnl0ZXMpCiAqIDIgCQljb2RlCiAqIDMuLmxlbmd0aCsxCWFyZ3VtZW50cwogKgogKiBTdGFydCB0aGUgZXh0ZW5kZWQgbWVzc2FnZSBidWZmZXIgd2l0aCB0aGUgRVhURU5ERURfTUVTU0FHRQogKiBieXRlLCBzaW5jZSBwcmludF9tc2coKSB3YW50cyB0aGUgd2hvbGUgdGhpbmcuICAKICovCgkJICAgIGV4dGVuZGVkX21zZ1swXSA9IEVYVEVOREVEX01FU1NBR0U7CgkJICAgIC8qIEFjY2VwdCBmaXJzdCBieXRlIGJ5IGNsZWFyaW5nIEFDSyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoKCQkgICAgRVhUX1BSSU5USygic2NzaSVkOiByZWNlaXZpbmcgZXh0ZW5kZWQgbWVzc2FnZVxuIiwgSE9TVE5PKTsKCgkJICAgIGxlbiA9IDI7CgkJICAgIGRhdGEgPSBleHRlbmRlZF9tc2cgKyAxOwoJCSAgICBwaGFzZSA9IFBIQVNFX01TR0lOOwoJCSAgICBOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAmZGF0YSk7CgkJICAgIEVYVF9QUklOVEsoInNjc2klZDogbGVuZ3RoPSVkLCBjb2RlPTB4JTAyeFxuIiwgSE9TVE5PLAoJCQkgICAgICAgKGludClleHRlbmRlZF9tc2dbMV0sIChpbnQpZXh0ZW5kZWRfbXNnWzJdKTsKCgkJICAgIGlmICghbGVuICYmIGV4dGVuZGVkX21zZ1sxXSA8PSAKCQkJKHNpemVvZiAoZXh0ZW5kZWRfbXNnKSAtIDEpKSB7CgkJCS8qIEFjY2VwdCB0aGlyZCBieXRlIGJ5IGNsZWFyaW5nIEFDSyAqLwoJCQlOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJCQlsZW4gPSBleHRlbmRlZF9tc2dbMV0gLSAxOwoJCQlkYXRhID0gZXh0ZW5kZWRfbXNnICsgMzsKCQkJcGhhc2UgPSBQSEFTRV9NU0dJTjsKCgkJCU5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sICZkYXRhKTsKCQkJRVhUX1BSSU5USygic2NzaSVkOiBtZXNzYWdlIHJlY2VpdmVkLCByZXNpZHVhbCAlZFxuIiwKCQkJCSAgIEhPU1ROTywgbGVuKTsKCgkJCXN3aXRjaCAoZXh0ZW5kZWRfbXNnWzJdKSB7CgkJCWNhc2UgRVhURU5ERURfU0RUUjoKCQkJY2FzZSBFWFRFTkRFRF9XRFRSOgoJCQljYXNlIEVYVEVOREVEX01PRElGWV9EQVRBX1BPSU5URVI6CgkJCWNhc2UgRVhURU5ERURfRVhURU5ERURfSURFTlRJRlk6CgkJCSAgICB0bXAgPSAwOwoJCQl9CgkJICAgIH0gZWxzZSBpZiAobGVuKSB7CgkJCXByaW50ayhLRVJOX05PVElDRSAic2NzaSVkOiBlcnJvciByZWNlaXZpbmcgIgoJCQkgICAgICAgImV4dGVuZGVkIG1lc3NhZ2VcbiIsIEhPU1ROTyk7CgkJCXRtcCA9IDA7CgkJICAgIH0gZWxzZSB7CgkJCXByaW50ayhLRVJOX05PVElDRSAic2NzaSVkOiBleHRlbmRlZCBtZXNzYWdlICIKCQkJICAgICAgICJjb2RlICUwMnggbGVuZ3RoICVkIGlzIHRvbyBsb25nXG4iLAoJCQkgICAgICAgSE9TVE5PLCBleHRlbmRlZF9tc2dbMl0sIGV4dGVuZGVkX21zZ1sxXSk7CgkJCXRtcCA9IDA7CgkJICAgIH0KCQkvKiBGYWxsIHRocm91Z2ggdG8gcmVqZWN0IG1lc3NhZ2UgKi8KCgkJLyogCiAgCQkgKiBJZiB3ZSBnZXQgc29tZXRoaW5nIHdlaXJkIHRoYXQgd2UgYXJlbid0IGV4cGVjdGluZywgCiAJCSAqIHJlamVjdCBpdC4KCQkgKi8KCQlkZWZhdWx0OgoJCSAgICBpZiAoIXRtcCkgewoJCQlwcmludGsoS0VSTl9ERUJVRyAic2NzaSVkOiByZWplY3RpbmcgbWVzc2FnZSAiLCBIT1NUTk8pOwoJCQlwcmludF9tc2cgKGV4dGVuZGVkX21zZyk7CgkJCXByaW50aygiXG4iKTsKCQkgICAgfSBlbHNlIGlmICh0bXAgIT0gRVhURU5ERURfTUVTU0FHRSkKCQkJcHJpbnRrKEtFUk5fREVCVUcgInNjc2klZDogcmVqZWN0aW5nIHVua25vd24gIgoJCQkgICAgICAgIm1lc3NhZ2UgJTAyeCBmcm9tIHRhcmdldCAlZCwgbHVuICVkXG4iLAoJCQkgICAgICAgSE9TVE5PLCB0bXAsIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1bik7CgkJICAgIGVsc2UKCQkJcHJpbnRrKEtFUk5fREVCVUcgInNjc2klZDogcmVqZWN0aW5nIHVua25vd24gIgoJCQkgICAgICAgImV4dGVuZGVkIG1lc3NhZ2UgIgoJCQkgICAgICAgImNvZGUgJTAyeCwgbGVuZ3RoICVkIGZyb20gdGFyZ2V0ICVkLCBsdW4gJWRcbiIsCgkJCSAgICAgICBIT1NUTk8sIGV4dGVuZGVkX21zZ1sxXSwgZXh0ZW5kZWRfbXNnWzBdLAoJCQkgICAgICAgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuKTsKICAgCgoJCSAgICBtc2dvdXQgPSBNRVNTQUdFX1JFSkVDVDsKCQkgICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgCgkJCUlDUl9BU1NFUlRfQVROKTsKCQkgICAgYnJlYWs7CgkJfSAvKiBzd2l0Y2ggKHRtcCkgKi8KCQlicmVhazsKCSAgICBjYXNlIFBIQVNFX01TR09VVDoKCQlsZW4gPSAxOwoJCWRhdGEgPSAmbXNnb3V0OwoJCWhvc3RkYXRhLT5sYXN0X21lc3NhZ2UgPSBtc2dvdXQ7CgkJTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpOwoJCWlmIChtc2dvdXQgPT0gQUJPUlQpIHsKI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSAgICBjbWRfZnJlZV90YWcoIGNtZCApOwojZWxzZQoJCSAgICBob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdICY9IH4oMSA8PCBjbWQtPmRldmljZS0+bHVuKTsKI2VuZGlmCgkJICAgIGhvc3RkYXRhLT5jb25uZWN0ZWQgPSBOVUxMOwoJCSAgICBjbWQtPnJlc3VsdCA9IERJRF9FUlJPUiA8PCAxNjsKI2lmZGVmIE5DUjUzODBfU1RBVFMKCQkgICAgY29sbGVjdF9zdGF0cyhob3N0ZGF0YSwgY21kKTsKI2VuZGlmCgkJICAgIGNtZC0+c2NzaV9kb25lKGNtZCk7CgkJICAgIE5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKCQkgICAgZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsKCQkgICAgcmV0dXJuOwoJCX0KCQltc2dvdXQgPSBOT1A7CgkJYnJlYWs7CgkgICAgY2FzZSBQSEFTRV9DTURPVVQ6CgkJbGVuID0gY21kLT5jbWRfbGVuOwoJCWRhdGEgPSBjbWQtPmNtbmQ7CgkJLyogCgkJICogWFhYIGZvciBwZXJmb3JtYW5jZSByZWFzb25zLCBvbiBtYWNoaW5lcyB3aXRoIGEgCgkJICogUFNFVURPLURNQSBhcmNoaXRlY3R1cmUgd2Ugc2hvdWxkIHByb2JhYmx5IAoJCSAqIHVzZSB0aGUgZG1hIHRyYW5zZmVyIGZ1bmN0aW9uLiAgCgkJICovCgkJTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgCgkJICAgICZkYXRhKTsKCQlicmVhazsKCSAgICBjYXNlIFBIQVNFX1NUQVRJTjoKCQlsZW4gPSAxOwoJCWRhdGEgPSAmdG1wOwoJCU5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sICZkYXRhKTsKCQljbWQtPlNDcC5TdGF0dXMgPSB0bXA7CgkJYnJlYWs7CgkgICAgZGVmYXVsdDoKCQlwcmludGsoInNjc2klZDogdW5rbm93biBwaGFzZVxuIiwgSE9TVE5PKTsKCQlOQ1JfUFJJTlQoTkRFQlVHX0FOWSk7CgkgICAgfSAvKiBzd2l0Y2gocGhhc2UpICovCgl9IC8qIGlmICh0bXAgKiBTUl9SRVEpICovIAogICAgfSAvKiB3aGlsZSAoMSkgKi8KfQoKLyoKICogRnVuY3Rpb24gOiB2b2lkIE5DUjUzODBfcmVzZWxlY3QgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQogKgogKiBQdXJwb3NlIDogZG9lcyByZXNlbGVjdGlvbiwgaW5pdGlhbGl6aW5nIHRoZSBpbnN0YW5jZS0+Y29ubmVjdGVkIAogKglmaWVsZCB0byBwb2ludCB0byB0aGUgU2NzaV9DbW5kIGZvciB3aGljaCB0aGUgSV9UX0wgb3IgSV9UX0xfUSAKICoJbmV4dXMgaGFzIGJlZW4gcmVlc3RhYmxpc2hlZCwKICoJCiAqIElucHV0cyA6IGluc3RhbmNlIC0gdGhpcyBpbnN0YW5jZSBvZiB0aGUgTkNSNTM4MC4KICoKICovCgoKc3RhdGljIHZvaWQgTkNSNTM4MF9yZXNlbGVjdCAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCnsKICAgIFNFVFVQX0hPU1REQVRBKGluc3RhbmNlKTsKICAgIHVuc2lnbmVkIGNoYXIgdGFyZ2V0X21hc2s7CiAgICB1bnNpZ25lZCBjaGFyIGx1biwgcGhhc2U7CiAgICBpbnQgbGVuOwojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICB1bnNpZ25lZCBjaGFyIHRhZzsKI2VuZGlmCiAgICB1bnNpZ25lZCBjaGFyIG1zZ1szXTsKICAgIHVuc2lnbmVkIGNoYXIgKmRhdGE7CiAgICBTY3NpX0NtbmQgKnRtcCA9IE5VTEwsICpwcmV2OwovKiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOyAqLwoKICAgIC8qCiAgICAgKiBEaXNhYmxlIGFyYml0cmF0aW9uLCBldGMuIHNpbmNlIHRoZSBob3N0IGFkYXB0ZXIgb2J2aW91c2x5CiAgICAgKiBsb3N0LCBhbmQgdGVsbCBhbiBpbnRlcnJ1cHRlZCBOQ1I1MzgwX3NlbGVjdCgpIHRvIHJlc3RhcnQuCiAgICAgKi8KCiAgICBOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9CQVNFKTsKICAgIGhvc3RkYXRhLT5yZXN0YXJ0X3NlbGVjdCA9IDE7CgogICAgdGFyZ2V0X21hc2sgPSBOQ1I1MzgwX3JlYWQoQ1VSUkVOVF9TQ1NJX0RBVEFfUkVHKSAmIH4oaG9zdGRhdGEtPmlkX21hc2spOwoKICAgIFJTTF9QUklOVEsoInNjc2klZDogcmVzZWxlY3RcbiIsIEhPU1ROTyk7CgogICAgLyogCiAgICAgKiBBdCB0aGlzIHBvaW50LCB3ZSBoYXZlIGRldGVjdGVkIHRoYXQgb3VyIFNDU0kgSUQgaXMgb24gdGhlIGJ1cywKICAgICAqIFNFTCBpcyB0cnVlIGFuZCBCU1kgd2FzIGZhbHNlIGZvciBhdCBsZWFzdCBvbmUgYnVzIHNldHRsZSBkZWxheQogICAgICogKDQwMCBucykuCiAgICAgKgogICAgICogV2UgbXVzdCBhc3NlcnQgQlNZIG91cnNlbHZlcywgdW50aWwgdGhlIHRhcmdldCBkcm9wcyB0aGUgU0VMCiAgICAgKiBzaWduYWwuCiAgICAgKi8KCiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCBJQ1JfQVNTRVJUX0JTWSk7CiAgICAKICAgIHdoaWxlIChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBTUl9TRUwpOwogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCiAgICAvKgogICAgICogV2FpdCBmb3IgdGFyZ2V0IHRvIGdvIGludG8gTVNHSU4uCiAgICAgKi8KCiAgICB3aGlsZSAoIShOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBTUl9SRVEpKTsKCiAgICBsZW4gPSAxOwogICAgZGF0YSA9IG1zZzsKICAgIHBoYXNlID0gUEhBU0VfTVNHSU47CiAgICBOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAmZGF0YSk7CgogICAgaWYgKCEobXNnWzBdICYgMHg4MCkpIHsKCXByaW50ayhLRVJOX0RFQlVHICJzY3NpJWQ6IGV4cGVjdGluZyBJREVOVElGWSBtZXNzYWdlLCBnb3QgIiwgSE9TVE5PKTsKCXByaW50X21zZyhtc2cpOwoJZG9fYWJvcnQoaW5zdGFuY2UpOwoJcmV0dXJuOwogICAgfQogICAgbHVuID0gKG1zZ1swXSAmIDB4MDcpOwoKI2lmZGVmIFNVUFBPUlRfVEFHUwogICAgLyogSWYgdGhlIHBoYXNlIGlzIHN0aWxsIE1TR0lOLCB0aGUgdGFyZ2V0IHdhbnRzIHRvIHNlbmQgc29tZSBtb3JlCiAgICAgKiBtZXNzYWdlcy4gSW4gY2FzZSBpdCBzdXBwb3J0cyB0YWdnZWQgcXVldWluZywgdGhpcyBpcyBwcm9iYWJseSBhCiAgICAgKiBTSU1QTEVfUVVFVUVfVEFHIGZvciB0aGUgSV9UX0xfUSBuZXh1cy4KICAgICAqLwogICAgdGFnID0gVEFHX05PTkU7CiAgICBpZiAocGhhc2UgPT0gUEhBU0VfTVNHSU4gJiYgc2V0dXBfdXNlX3RhZ2dlZF9xdWV1aW5nKSB7CgkvKiBBY2NlcHQgcHJldmlvdXMgSURFTlRJRlkgbWVzc2FnZSBieSBjbGVhcmluZyBBQ0sgKi8KCU5DUjUzODBfd3JpdGUoIElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgKTsKCWxlbiA9IDI7CglkYXRhID0gbXNnKzE7CglpZiAoIU5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sICZkYXRhKSAmJgoJICAgIG1zZ1sxXSA9PSBTSU1QTEVfUVVFVUVfVEFHKQoJICAgIHRhZyA9IG1zZ1syXTsKCVRBR19QUklOVEsoInNjc2klZDogdGFyZ2V0IG1hc2sgJTAyeCwgbHVuICVkIHNlbnQgdGFnICVkIGF0ICIKCQkgICAicmVzZWxlY3Rpb25cbiIsIEhPU1ROTywgdGFyZ2V0X21hc2ssIGx1biwgdGFnKTsKICAgIH0KI2VuZGlmCiAgICAKICAgIC8qIAogICAgICogRmluZCB0aGUgY29tbWFuZCBjb3JyZXNwb25kaW5nIHRvIHRoZSBJX1RfTCBvciBJX1RfTF9RICBuZXh1cyB3ZSAKICAgICAqIGp1c3QgcmVlc3RhYmxpc2hlZCwgYW5kIHJlbW92ZSBpdCBmcm9tIHRoZSBkaXNjb25uZWN0ZWQgcXVldWUuCiAgICAgKi8KCiAgICBmb3IgKHRtcCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSwgcHJldiA9IE5VTEw7IAoJIHRtcDsgcHJldiA9IHRtcCwgdG1wID0gTkVYVCh0bXApICkgewoJaWYgKCh0YXJnZXRfbWFzayA9PSAoMSA8PCB0bXAtPmRldmljZS0+aWQpKSAmJiAobHVuID09IHRtcC0+ZGV2aWNlLT5sdW4pCiNpZmRlZiBTVVBQT1JUX1RBR1MKCSAgICAmJiAodGFnID09IHRtcC0+dGFnKSAKI2VuZGlmCgkgICAgKSB7CgkgICAgLyogKytndWVudGhlcjogcHJldmVudCByYWNlIHdpdGggZmFsY29uX3JlbGVhc2VfbG9jayAqLwoJICAgIGZhbGNvbl9kb250X3JlbGVhc2UrKzsKCSAgICBpZiAocHJldikgewoJCVJFTU9WRShwcmV2LCBORVhUKHByZXYpLCB0bXAsIE5FWFQodG1wKSk7CgkJTkVYVChwcmV2KSA9IE5FWFQodG1wKTsKCSAgICB9IGVsc2UgewoJCVJFTU9WRSgtMSwgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSwgdG1wLCBORVhUKHRtcCkpOwoJCWhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUgPSBORVhUKHRtcCk7CgkgICAgfQoJICAgIE5FWFQodG1wKSA9IE5VTEw7CgkgICAgYnJlYWs7Cgl9CiAgICB9CiAgICAKICAgIGlmICghdG1wKSB7CglwcmludGsoS0VSTl9XQVJOSU5HICJzY3NpJWQ6IHdhcm5pbmc6IHRhcmdldCBiaXRtYXNrICUwMnggbHVuICVkICIKI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSJ0YWcgJWQgIgojZW5kaWYKCQkibm90IGluIGRpc2Nvbm5lY3RlZF9xdWV1ZS5cbiIsCgkJSE9TVE5PLCB0YXJnZXRfbWFzaywgbHVuCiNpZmRlZiBTVVBQT1JUX1RBR1MKCQksIHRhZwojZW5kaWYKCQkpOwoJLyogCgkgKiBTaW5jZSB3ZSBoYXZlIGFuIGVzdGFibGlzaGVkIG5leHVzIHRoYXQgd2UgY2FuJ3QgZG8gYW55dGhpbmcKCSAqIHdpdGgsIHdlIG11c3QgYWJvcnQgaXQuICAKCSAqLwoJZG9fYWJvcnQoaW5zdGFuY2UpOwoJcmV0dXJuOwogICAgfQoKICAgIC8qIEFjY2VwdCBtZXNzYWdlIGJ5IGNsZWFyaW5nIEFDSyAqLwogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCiAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gdG1wOwogICAgUlNMX1BSSU5USygic2NzaSVkOiBuZXh1cyBlc3RhYmxpc2hlZCwgdGFyZ2V0ID0gJWQsIGx1biA9ICVkLCB0YWcgPSAlZFxuIiwKCSAgICAgICBIT1NUTk8sIHRtcC0+ZGV2aWNlLT5pZCwgdG1wLT5kZXZpY2UtPmx1biwgdG1wLT50YWcpOwogICAgZmFsY29uX2RvbnRfcmVsZWFzZS0tOwp9CgoKLyoKICogRnVuY3Rpb24gOiBpbnQgTkNSNTM4MF9hYm9ydCAoU2NzaV9DbW5kICpjbWQpCiAqCiAqIFB1cnBvc2UgOiBhYm9ydCBhIGNvbW1hbmQKICoKICogSW5wdXRzIDogY21kIC0gdGhlIFNjc2lfQ21uZCB0byBhYm9ydCwgY29kZSAtIGNvZGUgdG8gc2V0IHRoZSAKICogCWhvc3QgYnl0ZSBvZiB0aGUgcmVzdWx0IGZpZWxkIHRvLCBpZiB6ZXJvIERJRF9BQk9SVEVEIGlzIAogKgl1c2VkLgogKgogKiBSZXR1cm5zIDogMCAtIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUuCiAqCiAqIFhYWCAtIHRoZXJlIGlzIG5vIHdheSB0byBhYm9ydCB0aGUgY29tbWFuZCB0aGF0IGlzIGN1cnJlbnRseSAKICogCSBjb25uZWN0ZWQsIHlvdSBoYXZlIHRvIHdhaXQgZm9yIGl0IHRvIGNvbXBsZXRlLiAgSWYgdGhpcyBpcyAKICoJIGEgcHJvYmxlbSwgd2UgY291bGQgaW1wbGVtZW50IGxvbmdqbXAoKSAvIHNldGptcCgpLCBzZXRqbXAoKQogKiAJIGNhbGxlZCB3aGVyZSB0aGUgbG9vcCBzdGFydGVkIGluIE5DUjUzODBfbWFpbigpLgogKi8KCnN0YXRpYwppbnQgTkNSNTM4MF9hYm9ydCAoU2NzaV9DbW5kICpjbWQpCnsKICAgIHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlID0gY21kLT5kZXZpY2UtPmhvc3Q7CiAgICBTRVRVUF9IT1NUREFUQShpbnN0YW5jZSk7CiAgICBTY3NpX0NtbmQgKnRtcCwgKipwcmV2OwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKCiAgICBwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogYWJvcnRpbmcgY29tbWFuZFxuIiwgSE9TVE5PKTsKICAgIHByaW50X1Njc2lfQ21uZCAoY21kKTsKCiAgICBOQ1I1MzgwX3ByaW50X3N0YXR1cyAoaW5zdGFuY2UpOwoKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIAogICAgaWYgKCFJU19BX1RUKCkgJiYgIWZhbGNvbl9nb3RfbG9jaykKCXByaW50ayhLRVJOX0VSUiAic2NzaSVkOiAhIUJJTkdPISEgRmFsY29uIGhhcyBubyBsb2NrIGluIE5DUjUzODBfYWJvcnRcbiIsCgkgICAgICAgSE9TVE5PKTsKCiAgICBBQlJUX1BSSU5USygic2NzaSVkOiBhYm9ydCBjYWxsZWQgYmFzciAweCUwMngsIHNyIDB4JTAyeFxuIiwgSE9TVE5PLAoJCU5DUjUzODBfcmVhZChCVVNfQU5EX1NUQVRVU19SRUcpLAoJCU5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSk7CgojaWYgMQovKiAKICogQ2FzZSAxIDogSWYgdGhlIGNvbW1hbmQgaXMgdGhlIGN1cnJlbnRseSBleGVjdXRpbmcgY29tbWFuZCwgCiAqIHdlJ2xsIHNldCB0aGUgYWJvcnRlZCBmbGFnIGFuZCByZXR1cm4gY29udHJvbCBzbyB0aGF0IAogKiBpbmZvcm1hdGlvbiB0cmFuc2ZlciByb3V0aW5lIGNhbiBleGl0IGNsZWFubHkuCiAqLwoKICAgIGlmIChob3N0ZGF0YS0+Y29ubmVjdGVkID09IGNtZCkgewoKCUFCUlRfUFJJTlRLKCJzY3NpJWQ6IGFib3J0aW5nIGNvbm5lY3RlZCBjb21tYW5kXG4iLCBIT1NUTk8pOwovKgogKiBXZSBzaG91bGQgcGVyZm9ybSBCU1kgY2hlY2tpbmcsIGFuZCBtYWtlIHN1cmUgd2UgaGF2ZW4ndCBzbGlwcGVkCiAqIGludG8gQlVTIEZSRUUuCiAqLwoKLyoJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9BU1NFUlRfQVROKTsgKi8KLyogCiAqIFNpbmNlIHdlIGNhbid0IGNoYW5nZSBwaGFzZXMgdW50aWwgd2UndmUgY29tcGxldGVkIHRoZSBjdXJyZW50IAogKiBoYW5kc2hha2UsIHdlIGhhdmUgdG8gc291cmNlIG9yIHNpbmsgYSBieXRlIG9mIGRhdGEgaWYgdGhlIGN1cnJlbnQKICogcGhhc2UgaXMgbm90IE1TR09VVC4KICovCgovKiAKICogUmV0dXJuIGNvbnRyb2wgdG8gdGhlIGV4ZWN1dGluZyBOQ1IgZHJpdmUgc28gd2UgY2FuIGNsZWFyIHRoZQogKiBhYm9ydGVkIGZsYWcgYW5kIGdldCBiYWNrIGludG8gb3VyIG1haW4gbG9vcC4KICovIAoKCWlmIChkb19hYm9ydChpbnN0YW5jZSkgPT0gMCkgewoJICBob3N0ZGF0YS0+YWJvcnRlZCA9IDE7CgkgIGhvc3RkYXRhLT5jb25uZWN0ZWQgPSBOVUxMOwoJICBjbWQtPnJlc3VsdCA9IERJRF9BQk9SVCA8PCAxNjsKI2lmZGVmIFNVUFBPUlRfVEFHUwoJICBjbWRfZnJlZV90YWcoIGNtZCApOwojZWxzZQoJICBob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdICY9IH4oMSA8PCBjbWQtPmRldmljZS0+bHVuKTsKI2VuZGlmCgkgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCSAgY21kLT5zY3NpX2RvbmUoY21kKTsKCSAgZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsKCSAgcmV0dXJuIFNDU0lfQUJPUlRfU1VDQ0VTUzsKCX0gZWxzZSB7Ci8qCSAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOyAqLwoJICBwcmludGsoInNjc2klZDogYWJvcnQgb2YgY29ubmVjdGVkIGNvbW1hbmQgZmFpbGVkIVxuIiwgSE9TVE5PKTsKCSAgcmV0dXJuIFNDU0lfQUJPUlRfRVJST1I7Cgl9IAogICB9CiNlbmRpZgoKLyogCiAqIENhc2UgMiA6IElmIHRoZSBjb21tYW5kIGhhc24ndCBiZWVuIGlzc3VlZCB5ZXQsIHdlIHNpbXBseSByZW1vdmUgaXQgCiAqIAkgICAgZnJvbSB0aGUgaXNzdWUgcXVldWUuCiAqLwogICAgZm9yIChwcmV2ID0gKFNjc2lfQ21uZCAqKikgJihob3N0ZGF0YS0+aXNzdWVfcXVldWUpLCAKCXRtcCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlOwoJdG1wOyBwcmV2ID0gTkVYVEFERFIodG1wKSwgdG1wID0gTkVYVCh0bXApICkKCWlmIChjbWQgPT0gdG1wKSB7CgkgICAgUkVNT1ZFKDUsICpwcmV2LCB0bXAsIE5FWFQodG1wKSk7CgkgICAgKCpwcmV2KSA9IE5FWFQodG1wKTsKCSAgICBORVhUKHRtcCkgPSBOVUxMOwoJICAgIHRtcC0+cmVzdWx0ID0gRElEX0FCT1JUIDw8IDE2OwoJICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCSAgICBBQlJUX1BSSU5USygic2NzaSVkOiBhYm9ydCByZW1vdmVkIGNvbW1hbmQgZnJvbSBpc3N1ZSBxdWV1ZS5cbiIsCgkJCUhPU1ROTyk7CgkgICAgLyogVGFnZ2VkIHF1ZXVpbmcgbm90ZTogbm8gdGFnIHRvIGZyZWUgaGVyZSwgaGFzbid0IGJlZW4gYXNzaWduZWQKCSAgICAgKiB5ZXQuLi4gKi8KCSAgICB0bXAtPnNjc2lfZG9uZSh0bXApOwoJICAgIGZhbGNvbl9yZWxlYXNlX2xvY2tfaWZfcG9zc2libGUoIGhvc3RkYXRhICk7CgkgICAgcmV0dXJuIFNDU0lfQUJPUlRfU1VDQ0VTUzsKCX0KCi8qIAogKiBDYXNlIDMgOiBJZiBhbnkgY29tbWFuZHMgYXJlIGNvbm5lY3RlZCwgd2UncmUgZ29pbmcgdG8gZmFpbCB0aGUgYWJvcnQKICoJICAgIGFuZCBsZXQgdGhlIGhpZ2ggbGV2ZWwgU0NTSSBkcml2ZXIgcmV0cnkgYXQgYSBsYXRlciB0aW1lIG9yIAogKgkgICAgaXNzdWUgYSByZXNldC4KICoKICoJICAgIFRpbWVvdXRzLCBhbmQgdGhlcmVmb3JlIGFib3J0ZWQgY29tbWFuZHMsIHdpbGwgYmUgaGlnaGx5IHVubGlrZWx5CiAqICAgICAgICAgIGFuZCBoYW5kbGluZyB0aGVtIGNsZWFubHkgaW4gdGhpcyBzaXR1YXRpb24gd291bGQgbWFrZSB0aGUgY29tbW9uCiAqCSAgICBjYXNlIG9mIG5vcmVzZXRzIGxlc3MgZWZmaWNpZW50LCBhbmQgd291bGQgcG9sbHV0ZSBvdXIgY29kZS4gIFNvLAogKgkgICAgd2UgZmFpbC4KICovCgogICAgaWYgKGhvc3RkYXRhLT5jb25uZWN0ZWQpIHsKCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCUFCUlRfUFJJTlRLKCJzY3NpJWQ6IGFib3J0IGZhaWxlZCwgY29tbWFuZCBjb25uZWN0ZWQuXG4iLCBIT1NUTk8pOwogICAgICAgIHJldHVybiBTQ1NJX0FCT1JUX1NOT09aRTsKICAgIH0KCi8qCiAqIENhc2UgNDogSWYgdGhlIGNvbW1hbmQgaXMgY3VycmVudGx5IGRpc2Nvbm5lY3RlZCBmcm9tIHRoZSBidXMsIGFuZCAKICogCXRoZXJlIGFyZSBubyBjb25uZWN0ZWQgY29tbWFuZHMsIHdlIHJlY29ubmVjdCB0aGUgSV9UX0wgb3IgCiAqCUlfVF9MX1EgbmV4dXMgYXNzb2NpYXRlZCB3aXRoIGl0LCBnbyBpbnRvIG1lc3NhZ2Ugb3V0LCBhbmQgc2VuZCAKICogICAgICBhbiBhYm9ydCBtZXNzYWdlLgogKgogKiBUaGlzIGNhc2UgaXMgZXNwZWNpYWxseSB1Z2x5LiBJbiBvcmRlciB0byByZWVzdGFibGlzaCB0aGUgbmV4dXMsIHdlCiAqIG5lZWQgdG8gY2FsbCBOQ1I1MzgwX3NlbGVjdCgpLiAgVGhlIGVhc2llc3Qgd2F5IHRvIGltcGxlbWVudCB0aGlzIAogKiBmdW5jdGlvbiB3YXMgdG8gYWJvcnQgaWYgdGhlIGJ1cyB3YXMgYnVzeSwgYW5kIGxldCB0aGUgaW50ZXJydXB0CiAqIGhhbmRsZXIgdHJpZ2dlcmVkIG9uIHRoZSBTRUwgZm9yIHJlc2VsZWN0IHRha2UgY2FyZSBvZiBsb3N0IGFyYml0cmF0aW9ucwogKiB3aGVyZSBuZWNlc3NhcnksIG1lYW5pbmcgaW50ZXJydXB0cyBuZWVkIHRvIGJlIGVuYWJsZWQuCiAqCiAqIFdoZW4gaW50ZXJydXB0cyBhcmUgZW5hYmxlZCwgdGhlIHF1ZXVlcyBtYXkgY2hhbmdlIC0gc28gd2UgCiAqIGNhbid0IHJlbW92ZSBpdCBmcm9tIHRoZSBkaXNjb25uZWN0ZWQgcXVldWUgYmVmb3JlIHNlbGVjdGluZyBpdAogKiBiZWNhdXNlIHRoYXQgY291bGQgY2F1c2UgYSBmYWlsdXJlIGluIGhhc2hpbmcgdGhlIG5leHVzIGlmIHRoYXQgCiAqIGRldmljZSByZXNlbGVjdGVkLgogKiAKICogU2luY2UgdGhlIHF1ZXVlcyBtYXkgY2hhbmdlLCB3ZSBjYW4ndCB1c2UgdGhlIHBvaW50ZXJzIGZyb20gd2hlbiB3ZQogKiBmaXJzdCBsb2NhdGUgaXQuCiAqCiAqIFNvLCB3ZSBtdXN0IGZpcnN0IGxvY2F0ZSB0aGUgY29tbWFuZCwgYW5kIGlmIE5DUjUzODBfc2VsZWN0KCkKICogc3VjY2VlZHMsIHRoZW4gaXNzdWUgdGhlIGFib3J0LCByZWxvY2F0ZSB0aGUgY29tbWFuZCBhbmQgcmVtb3ZlCiAqIGl0IGZyb20gdGhlIGRpc2Nvbm5lY3RlZCBxdWV1ZS4KICovCgogICAgZm9yICh0bXAgPSAoU2NzaV9DbW5kICopIGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWU7IHRtcDsKCSB0bXAgPSBORVhUKHRtcCkpIAogICAgICAgIGlmIChjbWQgPT0gdG1wKSB7CiAgICAgICAgICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCSAgICBBQlJUX1BSSU5USygic2NzaSVkOiBhYm9ydGluZyBkaXNjb25uZWN0ZWQgY29tbWFuZC5cbiIsIEhPU1ROTyk7CiAgCiAgICAgICAgICAgIGlmIChOQ1I1MzgwX3NlbGVjdCAoaW5zdGFuY2UsIGNtZCwgKGludCkgY21kLT50YWcpKSAKCQlyZXR1cm4gU0NTSV9BQk9SVF9CVVNZOwoKCSAgICBBQlJUX1BSSU5USygic2NzaSVkOiBuZXh1cyByZWVzdGFibGlzaGVkLlxuIiwgSE9TVE5PKTsKCgkgICAgZG9fYWJvcnQgKGluc3RhbmNlKTsKCgkgICAgbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwoJICAgIGZvciAocHJldiA9IChTY3NpX0NtbmQgKiopICYoaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSksIAoJCXRtcCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZTsKCQl0bXA7IHByZXYgPSBORVhUQUREUih0bXApLCB0bXAgPSBORVhUKHRtcCkgKQoJCSAgICBpZiAoY21kID09IHRtcCkgewoJCSAgICBSRU1PVkUoNSwgKnByZXYsIHRtcCwgTkVYVCh0bXApKTsKCQkgICAgKnByZXYgPSBORVhUKHRtcCk7CgkJICAgIE5FWFQodG1wKSA9IE5VTEw7CgkJICAgIHRtcC0+cmVzdWx0ID0gRElEX0FCT1JUIDw8IDE2OwoJCSAgICAvKiBXZSBtdXN0IHVubG9jayB0aGUgdGFnL0xVTiBpbW1lZGlhdGVseSBoZXJlLCBzaW5jZSB0aGUKCQkgICAgICogdGFyZ2V0IGdvZXMgdG8gQlVTIEZSRUUgYW5kIGRvZXNuJ3Qgc2VuZCB1cyBhbm90aGVyCgkJICAgICAqIG1lc3NhZ2UgKENPTU1BTkRfQ09NUExFVEUgb3IgdGhlIGxpa2UpCgkJICAgICAqLwojaWZkZWYgU1VQUE9SVF9UQUdTCgkJICAgIGNtZF9mcmVlX3RhZyggdG1wICk7CiNlbHNlCgkJICAgIGhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gJj0gfigxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwojZW5kaWYKCQkgICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJCSAgICB0bXAtPnNjc2lfZG9uZSh0bXApOwoJCSAgICBmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOwoJCSAgICByZXR1cm4gU0NTSV9BQk9SVF9TVUNDRVNTOwoJCX0KCX0KCi8qCiAqIENhc2UgNSA6IElmIHdlIHJlYWNoZWQgdGhpcyBwb2ludCwgdGhlIGNvbW1hbmQgd2FzIG5vdCBmb3VuZCBpbiBhbnkgb2YgCiAqCSAgICB0aGUgcXVldWVzLgogKgogKiBXZSBwcm9iYWJseSByZWFjaGVkIHRoaXMgcG9pbnQgYmVjYXVzZSBvZiBhbiB1bmxpa2VseSByYWNlIGNvbmRpdGlvbgogKiBiZXR3ZWVuIHRoZSBjb21tYW5kIGNvbXBsZXRpbmcgc3VjY2Vzc2Z1bGx5IGFuZCB0aGUgYWJvcnRpb24gY29kZSwKICogc28gd2Ugd29uJ3QgcGFuaWMsIGJ1dCB3ZSB3aWxsIG5vdGlmeSB0aGUgdXNlciBpbiBjYXNlIHNvbWV0aGluZyByZWFsbHkKICogYnJva2UuCiAqLwoKICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKICAgIHByaW50ayhLRVJOX0lORk8gInNjc2klZDogd2FybmluZyA6IFNDU0kgY29tbWFuZCBwcm9iYWJseSBjb21wbGV0ZWQgc3VjY2Vzc2Z1bGx5XG4iCiAgICAgICAgICAgS0VSTl9JTkZPICIgICAgICAgIGJlZm9yZSBhYm9ydGlvblxuIiwgSE9TVE5PKTsgCgovKiBNYXliZSBpdCBpcyBzdWZmaWNpZW50IGp1c3QgdG8gcmVsZWFzZSB0aGUgU1QtRE1BIGxvY2suLi4gKGlmCiAqIHBvc3NpYmxlIGF0IGFsbCkgQXQgbGVhc3QsIHdlIHNob3VsZCBjaGVjayBpZiB0aGUgbG9jayBjb3VsZCBiZQogKiByZWxlYXNlZCBhZnRlciB0aGUgYWJvcnQsIGluIGNhc2UgaXQgaXMga2VwdCBkdWUgdG8gc29tZSBidWcuCiAqLwogICAgZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsKCiAgICByZXR1cm4gU0NTSV9BQk9SVF9OT1RfUlVOTklORzsKfQoKCi8qIAogKiBGdW5jdGlvbiA6IGludCBOQ1I1MzgwX3Jlc2V0IChTY3NpX0NtbmQgKmNtZCkKICogCiAqIFB1cnBvc2UgOiByZXNldCB0aGUgU0NTSSBidXMuCiAqCiAqIFJldHVybnMgOiBTQ1NJX1JFU0VUX1dBS0VVUAogKgogKi8gCgpzdGF0aWMgaW50IE5DUjUzODBfYnVzX3Jlc2V0KCBTY3NpX0NtbmQgKmNtZCkKewogICAgU0VUVVBfSE9TVERBVEEoY21kLT5kZXZpY2UtPmhvc3QpOwogICAgaW50ICAgICAgICAgICBpOwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKI2lmIDEKICAgIFNjc2lfQ21uZCAqY29ubmVjdGVkLCAqZGlzY29ubmVjdGVkX3F1ZXVlOwojZW5kaWYKCiAgICBpZiAoIUlTX0FfVFQoKSAmJiAhZmFsY29uX2dvdF9sb2NrKQoJcHJpbnRrKEtFUk5fRVJSICJzY3NpJWQ6ICEhQklOR08hISBGYWxjb24gaGFzIG5vIGxvY2sgaW4gTkNSNTM4MF9yZXNldFxuIiwKCSAgICAgICBIX05PKGNtZCkgKTsKCiAgICBOQ1I1MzgwX3ByaW50X3N0YXR1cyAoY21kLT5kZXZpY2UtPmhvc3QpOwoKICAgIC8qIGdldCBpbiBwaGFzZSAqLwogICAgTkNSNTM4MF93cml0ZSggVEFSR0VUX0NPTU1BTkRfUkVHLAoJCSAgIFBIQVNFX1NSX1RPX1RDUiggTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICkpOwogICAgLyogYXNzZXJ0IFJTVCAqLwogICAgTkNSNTM4MF93cml0ZSggSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfUlNUICk7CiAgICB1ZGVsYXkgKDQwKTsKICAgIC8qIHJlc2V0IE5DUiByZWdpc3RlcnMgKi8KICAgIE5DUjUzODBfd3JpdGUoIElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgKTsKICAgIE5DUjUzODBfd3JpdGUoIE1PREVfUkVHLCBNUl9CQVNFICk7CiAgICBOQ1I1MzgwX3dyaXRlKCBUQVJHRVRfQ09NTUFORF9SRUcsIDAgKTsKICAgIE5DUjUzODBfd3JpdGUoIFNFTEVDVF9FTkFCTEVfUkVHLCAwICk7CiAgICAvKiArK3JvbWFuOiByZXNldCBpbnRlcnJ1cHQgY29uZGl0aW9uISBvdGhlcndpc2Ugbm8gaW50ZXJydXB0cyBkb24ndCBnZXQKICAgICAqIHRocm91Z2ggYW55bW9yZSAuLi4gKi8KICAgICh2b2lkKU5DUjUzODBfcmVhZCggUkVTRVRfUEFSSVRZX0lOVEVSUlVQVF9SRUcgKTsKCiNpZiAxIC8qIFhYWCBTaG91bGQgbm93IGJlIGRvbmUgYnkgbWlkbGV2ZWwgY29kZSwgYnV0IGl0J3MgYnJva2VuIFhYWCAqLwogICAgICAvKiBYWFggc2VlIGJlbG93ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBYWFggKi8KCiAgICAvKiBNU2NoOiBvbGQtc3R5bGUgcmVzZXQ6IGFjdHVhbGx5IGFib3J0IGFsbCBjb21tYW5kIHByb2Nlc3NpbmcgaGVyZSAqLwoKICAgIC8qIEFmdGVyIHRoZSByZXNldCwgdGhlcmUgYXJlIG5vIG1vcmUgY29ubmVjdGVkIG9yIGRpc2Nvbm5lY3RlZCBjb21tYW5kcwogICAgICogYW5kIG5vIGJ1c3kgdW5pdHM7IHRvIGF2b2lkIHByb2JsZW1zIHdpdGggcmUtaW5zZXJ0aW5nIHRoZSBjb21tYW5kcwogICAgICogaW50byB0aGUgaXNzdWVfcXVldWUgKHZpYSBzY3NpX2RvbmUoKSksIHRoZSBhYm9ydGVkIGNvbW1hbmRzIGFyZQogICAgICogcmVtZW1iZXJlZCBpbiBsb2NhbCB2YXJpYWJsZXMgZmlyc3QuCiAgICAgKi8KICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIGNvbm5lY3RlZCA9IChTY3NpX0NtbmQgKilob3N0ZGF0YS0+Y29ubmVjdGVkOwogICAgaG9zdGRhdGEtPmNvbm5lY3RlZCA9IE5VTEw7CiAgICBkaXNjb25uZWN0ZWRfcXVldWUgPSAoU2NzaV9DbW5kICopaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZTsKICAgIGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUgPSBOVUxMOwojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICBmcmVlX2FsbF90YWdzKCk7CiNlbmRpZgogICAgZm9yKCBpID0gMDsgaSA8IDg7ICsraSApCglob3N0ZGF0YS0+YnVzeVtpXSA9IDA7CiNpZmRlZiBSRUFMX0RNQQogICAgaG9zdGRhdGEtPmRtYV9sZW4gPSAwOwojZW5kaWYKICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCiAgICAvKiBJbiBvcmRlciB0byB0ZWxsIHRoZSBtaWQtbGV2ZWwgY29kZSB3aGljaCBjb21tYW5kcyB3ZXJlIGFib3J0ZWQsIAogICAgICogc2V0IHRoZSBjb21tYW5kIHN0YXR1cyB0byBESURfUkVTRVQgYW5kIGNhbGwgc2NzaV9kb25lKCkgISEhCiAgICAgKiBUaGlzIHVsdGltYXRlbHkgYWJvcnRzIHByb2Nlc3Npbmcgb2YgdGhlc2UgY29tbWFuZHMgaW4gdGhlIG1pZC1sZXZlbC4KICAgICAqLwoKICAgIGlmICgoY21kID0gY29ubmVjdGVkKSkgewoJQUJSVF9QUklOVEsoInNjc2klZDogcmVzZXQgYWJvcnRlZCBhIGNvbm5lY3RlZCBjb21tYW5kXG4iLCBIX05PKGNtZCkpOwoJY21kLT5yZXN1bHQgPSAoY21kLT5yZXN1bHQgJiAweGZmZmYpIHwgKERJRF9SRVNFVCA8PCAxNik7CgljbWQtPnNjc2lfZG9uZSggY21kICk7CiAgICB9CgogICAgZm9yIChpID0gMDsgKGNtZCA9IGRpc2Nvbm5lY3RlZF9xdWV1ZSk7ICsraSkgewoJZGlzY29ubmVjdGVkX3F1ZXVlID0gTkVYVChjbWQpOwoJTkVYVChjbWQpID0gTlVMTDsKCWNtZC0+cmVzdWx0ID0gKGNtZC0+cmVzdWx0ICYgMHhmZmZmKSB8IChESURfUkVTRVQgPDwgMTYpOwoJY21kLT5zY3NpX2RvbmUoIGNtZCApOwogICAgfQogICAgaWYgKGkgPiAwKQoJQUJSVF9QUklOVEsoInNjc2k6IHJlc2V0IGFib3J0ZWQgJWQgZGlzY29ubmVjdGVkIGNvbW1hbmQocylcbiIsIGkpOwoKLyogVGhlIEZhbGNvbiBsb2NrIHNob3VsZCBiZSByZWxlYXNlZCBhZnRlciBhIHJlc2V0Li4uCiAqLwovKiArK2d1ZW50aGVyOiBtb3ZlZCB0byBhdGFyaV9zY3NpX3Jlc2V0KCksIHRvIHByZXZlbnQgYSByYWNlIGJldHdlZW4KICogdW5sb2NraW5nIGFuZCBlbmFibGluZyBkbWEgaW50ZXJydXB0LgogKi8KLyogICAgZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsqLwoKICAgIC8qIHNpbmNlIGFsbCBjb21tYW5kcyBoYXZlIGJlZW4gZXhwbGljaXRseSB0ZXJtaW5hdGVkLCB3ZSBuZWVkIHRvIHRlbGwKICAgICAqIHRoZSBtaWRsZXZlbCBjb2RlIHRoYXQgdGhlIHJlc2V0IHdhcyBTVUNDRVNTRlVMLCBhbmQgdGhlcmUgaXMgbm8gCiAgICAgKiBuZWVkIHRvICd3YWtlIHVwJyB0aGUgY29tbWFuZHMgYnkgYSByZXF1ZXN0X3NlbnNlCiAgICAgKi8KICAgIHJldHVybiBTQ1NJX1JFU0VUX1NVQ0NFU1MgfCBTQ1NJX1JFU0VUX0JVU19SRVNFVDsKI2Vsc2UgLyogMSAqLwoKICAgIC8qIE1TY2g6IG5ldy1zdHlsZSByZXNldCBoYW5kbGluZzogbGV0IHRoZSBtaWQtbGV2ZWwgZG8gd2hhdCBpdCBjYW4gKi8KCiAgICAvKiArK2d1ZW50aGVyOiBNSUQtTEVWRUwgSVMgU1RJTEwgQlJPS0VOLgogICAgICogTWlkLWxldmVsIGlzIHN1cHBvc2VkIHRvIHJlcXVldWUgYWxsIGNvbW1hbmRzIHRoYXQgd2VyZSBhY3RpdmUgb24gdGhlCiAgICAgKiB2YXJpb3VzIGxvdy1sZXZlbCBxdWV1ZXMuIEluIGZhY3QgaXQgZG9lcyB0aGlzLCBidXQgdGhhdCdzIG5vdCBlbm91Z2gKICAgICAqIGJlY2F1c2UgYWxsIHRoZXNlIGNvbW1hbmRzIGFyZSBzdWJqZWN0IHRvIHRpbWVvdXQuIEFuZCBpZiBhIHRpbWVvdXQKICAgICAqIGhhcHBlbnMgZm9yIGFueSByZW1vdmVkIGNvbW1hbmQsICpfYWJvcnQoKSBpcyBjYWxsZWQgYnV0IGFsbCBxdWV1ZXMKICAgICAqIGFyZSBub3cgZW1wdHkuIEFib3J0IHRoZW4gZ2l2ZXMgdXAgdGhlIGZhbGNvbiBsb2NrLCB3aGljaCBpcyBmYXRhbCwKICAgICAqIHNpbmNlIHRoZSBtaWQtbGV2ZWwgd2lsbCBxdWV1ZSBtb3JlIGNvbW1hbmRzIGFuZCBtdXN0IGhhdmUgdGhlIGxvY2sKICAgICAqIChpdCdzIGFsbCBoYXBwZW5pbmcgaW5zaWRlIHRpbWVyIGludGVycnVwdCBoYW5kbGVyISEpLgogICAgICogRXZlbiB3b3JzZSwgYWJvcnQgd2lsbCByZXR1cm4gTk9UX1JVTk5JTkcgZm9yIGFsbCB0aG9zZSBjb21tYW5kcyBub3QKICAgICAqIG9uIGFueSBxdWV1ZSwgc28gdGhleSB3b24ndCBiZSByZXRyaWVkIC4uLgogICAgICoKICAgICAqIENvbmNsdXNpb246IGVpdGhlciBzY3NpLmMgZGlzYWJsZXMgdGltZW91dCBmb3IgYWxsIHJlc2V0dGVkIGNvbW1hbmRzCiAgICAgKiBpbW1lZGlhdGVseSwgb3Igd2UgbG9zZSEgIEFzIG9mIGxpbnV4LTIuMC4yMCBpdCBkb2Vzbid0LgogICAgICovCgogICAgLyogQWZ0ZXIgdGhlIHJlc2V0LCB0aGVyZSBhcmUgbm8gbW9yZSBjb25uZWN0ZWQgb3IgZGlzY29ubmVjdGVkIGNvbW1hbmRzCiAgICAgKiBhbmQgbm8gYnVzeSB1bml0czsgc28gY2xlYXIgdGhlIGxvdy1sZXZlbCBzdGF0dXMgaGVyZSB0byBhdm9pZCAKICAgICAqIGNvbmZsaWN0cyB3aGVuIHRoZSBtaWQtbGV2ZWwgY29kZSB0cmllcyB0byB3YWtlIHVwIHRoZSBhZmZlY3RlZCAKICAgICAqIGNvbW1hbmRzIQogICAgICovCgogICAgaWYgKGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSkKCUFCUlRfUFJJTlRLKCJzY3NpJWQ6IHJlc2V0IGFib3J0ZWQgaXNzdWVkIGNvbW1hbmQocylcbiIsIEhfTk8oY21kKSk7CiAgICBpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCkgCglBQlJUX1BSSU5USygic2NzaSVkOiByZXNldCBhYm9ydGVkIGEgY29ubmVjdGVkIGNvbW1hbmRcbiIsIEhfTk8oY21kKSk7CiAgICBpZiAoaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSkKCUFCUlRfUFJJTlRLKCJzY3NpJWQ6IHJlc2V0IGFib3J0ZWQgZGlzY29ubmVjdGVkIGNvbW1hbmQocylcbiIsIEhfTk8oY21kKSk7CgogICAgbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwogICAgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlID0gTlVMTDsKICAgIGhvc3RkYXRhLT5jb25uZWN0ZWQgPSBOVUxMOwogICAgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSA9IE5VTEw7CiNpZmRlZiBTVVBQT1JUX1RBR1MKICAgIGZyZWVfYWxsX3RhZ3MoKTsKI2VuZGlmCiAgICBmb3IoIGkgPSAwOyBpIDwgODsgKytpICkKCWhvc3RkYXRhLT5idXN5W2ldID0gMDsKI2lmZGVmIFJFQUxfRE1BCiAgICBob3N0ZGF0YS0+ZG1hX2xlbiA9IDA7CiNlbmRpZgogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoKICAgIC8qIHdlIGRpZCBubyBjb21wbGV0ZSByZXNldCBvZiBhbGwgY29tbWFuZHMsIHNvIGEgd2FrZXVwIGlzIHJlcXVpcmVkICovCiAgICByZXR1cm4gU0NTSV9SRVNFVF9XQUtFVVAgfCBTQ1NJX1JFU0VUX0JVU19SRVNFVDsKI2VuZGlmIC8qIDEgKi8KfQoKLyogTG9jYWwgVmFyaWFibGVzOiAqLwovKiB0YWItd2lkdGg6IDggICAgICovCi8qIEVuZDogICAgICAgICAgICAgKi8K