LyogCiAqIE5DUiA1MzgwIGdlbmVyaWMgZHJpdmVyIHJvdXRpbmVzLiAgVGhlc2Ugc2hvdWxkIG1ha2UgaXQgKnRyaXZpYWwqCiAqIAl0byBpbXBsZW1lbnQgNTM4MCBTQ1NJIGRyaXZlcnMgdW5kZXIgTGludXggd2l0aCBhIG5vbi10cmFudG9yCiAqCWFyY2hpdGVjdHVyZS4KICoKICoJTm90ZSB0aGF0IHRoZXNlIHJvdXRpbmVzIGFsc28gd29yayB3aXRoIE5SNTNjNDAwIGZhbWlseSBjaGlwcy4KICoKICogQ29weXJpZ2h0IDE5OTMsIERyZXcgRWNraGFyZHQKICoJVmlzaW9uYXJ5IENvbXB1dGluZyAKICoJKFVuaXggYW5kIExpbnV4IGNvbnN1bHRpbmcgYW5kIGN1c3RvbSBwcm9ncmFtbWluZykKICogCWRyZXdAY29sb3JhZG8uZWR1CiAqCSsxICgzMDMpIDY2Ni01ODM2CiAqCiAqIERJU1RSSUJVVElPTiBSRUxFQVNFIDYuIAogKgogKiBGb3IgbW9yZSBpbmZvcm1hdGlvbiwgcGxlYXNlIGNvbnN1bHQgCiAqCiAqIE5DUiA1MzgwIEZhbWlseQogKiBTQ1NJIFByb3RvY29sIENvbnRyb2xsZXIKICogRGF0YWJvb2sKICoKICogTkNSIE1pY3JvZWxlY3Ryb25pY3MKICogMTYzNSBBZXJvcGxhemEgRHJpdmUKICogQ29sb3JhZG8gU3ByaW5ncywgQ08gODA5MTYKICogMSsgKDcxOSkgNTc4LTM0MDAKICogMSsgKDgwMCkgMzM0LTU0NTQKICovCgovKgogKiArK3JvbWFuOiBUbyBwb3J0IHRoZSA1MzgwIGRyaXZlciB0byB0aGUgQXRhcmksIEkgaGFkIHRvIGRvIHNvbWUgY2hhbmdlcyBpbgogKiB0aGlzIGZpbGUsIHRvbzoKICoKICogIC0gU29tZSBvZiB0aGUgZGVidWcgc3RhdGVtZW50cyB3ZXJlIGluY29ycmVjdCAodW5kZWZpbmVkIHZhcmlhYmxlcyBhbmQgdGhlCiAqICAgIGxpa2UpLiBJIGZpeGVkIHRoYXQuCiAqCiAqICAtIEluIGluZm9ybWF0aW9uX3RyYW5zZmVyKCksIEkgdGhpbmsgYSAjaWZkZWYgd2FzIHdyb25nLiBMb29raW5nIGF0IHRoZQogKiAgICBwb3NzaWJsZSBETUEgdHJhbnNmZXIgc2l6ZSBzaG91bGQgYWxzbyBoYXBwZW4gZm9yIFJFQUxfRE1BLiBJIGFkZGVkIHRoaXMKICogICAgaW4gdGhlICNpZiBzdGF0ZW1lbnQuCiAqCiAqICAtIFdoZW4gdXNpbmcgcmVhbCBETUEsIGluZm9ybWF0aW9uX3RyYW5zZmVyKCkgc2hvdWxkIHJldHVybiBpbiBhIERBVEFPVVQKICogICAgcGhhc2UgYWZ0ZXIgc3RhcnRpbmcgdGhlIERNQS4gSXQgaGFzIG5vdGhpbmcgbW9yZSB0byBkby4KICoKICogIC0gVGhlIGludGVycnVwdCBzZXJ2aWNlIHJvdXRpbmUgc2hvdWxkIHJ1biBtYWluIGFmdGVyIGVuZCBvZiBETUEsIHRvbyAobm90CiAqICAgIG9ubHkgYWZ0ZXIgUkVTRUxFQ1RJT04gaW50ZXJydXB0cykuIEFkZGl0aW9uYWxseSwgaXQgc2hvdWxkIF9ub3RfIHRlc3QKICogICAgZm9yIG1vcmUgaW50ZXJydXB0cyBhZnRlciBydW5uaW5nIG1haW4sIHNpbmNlIGEgRE1BIHByb2Nlc3MgbWF5IGhhdmUKICogICAgYmVlbiBzdGFydGVkIGFuZCBpbnRlcnJ1cHRzIGFyZSB0dXJuZWQgb24gbm93LiBUaGUgbmV3IGludCBjb3VsZCBoYXBwZW4KICogICAgaW5zaWRlIHRoZSBleGVjdXRpb24gb2YgTkNSNTM4MF9pbnRyKCksIGxlYWRpbmcgdG8gcmVjdXJzaXZlCiAqICAgIGNhbGxzLgogKgogKiAgLSBJJ3ZlIGFkZGVkIGEgZnVuY3Rpb24gbWVyZ2VfY29udGlndW91c19idWZmZXJzKCkgdGhhdCB0cmllcyB0bwogKiAgICBtZXJnZSBzY2F0dGVyLWdhdGhlciBidWZmZXJzIHRoYXQgYXJlIGxvY2F0ZWQgYXQgY29udGlndW91cwogKiAgICBwaHlzaWNhbCBhZGRyZXNzZXMgYW5kIGNhbiBiZSBwcm9jZXNzZWQgd2l0aCB0aGUgc2FtZSBETUEgc2V0dXAuCiAqICAgIFNpbmNlIG1vc3Qgc2NhdHRlci1nYXRoZXIgb3BlcmF0aW9ucyB3b3JrIG9uIGEgcGFnZSAoNEspIG9mCiAqICAgIDQgYnVmZmVycyAoMUspLCBpbiBtb3JlIHRoYW4gOTAlIG9mIGFsbCBjYXNlcyB0aHJlZSBpbnRlcnJ1cHRzIGFuZAogKiAgICBETUEgc2V0dXAgYWN0aW9ucyBhcmUgc2F2ZWQuCiAqCiAqIC0gSSd2ZSBkZWxldGVkIGFsbCB0aGUgc3R1ZmYgZm9yIEFVVE9QUk9CRV9JUlEsIFJFQUxfRE1BX1BPTEwsIFBTRVVET19ETUEKICogICAgYW5kIFVTTEVFUCwgYmVjYXVzZSB0aGVzZSB3ZXJlIG1lc3NpbmcgdXAgcmVhZGFiaWxpdHkgYW5kIHdpbGwgbmV2ZXIgYmUKICogICAgbmVlZGVkIGZvciBBdGFyaSBTQ1NJLgogKiAKICogLSBJJ3ZlIHJldmlzZWQgdGhlIE5DUjUzODBfbWFpbigpIGNhbGxpbmcgc2NoZW1lIChyZWxheCB0aGUgJ21haW5fcnVubmluZycKICogICBzdHVmZiksIGFuZCAnbWFpbicgaXMgZXhlY3V0ZWQgaW4gYSBib3R0b20gaGFsZiBpZiBhd29rZW4gYnkgYW4KICogICBpbnRlcnJ1cHQuCiAqCiAqIC0gVGhlIGNvZGUgd2FzIHF1aXRlIGNsdXR0ZXJlZCB1cCBieSAiI2lmIChOREVCVUcgJiBOREVCVUdfKikgcHJpbnRrLi4uIgogKiAgIGNvbnN0cnVjdHMuIEluIG15IGV5ZXMsIHRoaXMgbWFkZSB0aGUgc291cmNlIHJhdGhlciB1bnJlYWRhYmxlLCBzbyBJCiAqICAgZmluYWxseSByZXBsYWNlZCB0aGF0IGJ5IHRoZSAqX1BSSU5USygpIG1hY3Jvcy4KICoKICovCgovKgogKiBGdXJ0aGVyIGRldmVsb3BtZW50IC8gdGVzdGluZyB0aGF0IHNob3VsZCBiZSBkb25lIDogCiAqIDEuICBUZXN0IGxpbmtlZCBjb21tYW5kIGhhbmRsaW5nIGNvZGUgYWZ0ZXIgRXJpYyBpcyByZWFkeSB3aXRoIAogKiAgICAgdGhlIGhpZ2ggbGV2ZWwgY29kZS4KICovCiNpbmNsdWRlIDxzY3NpL3Njc2lfZGJnLmg+CiNpbmNsdWRlIDxzY3NpL3Njc2lfdHJhbnNwb3J0X3NwaS5oPgoKI2lmIChOREVCVUcgJiBOREVCVUdfTElTVFMpCiNkZWZpbmUgTElTVCh4LHkpIFwKICB7IHByaW50aygiTElORTolZCAgIEFkZGluZyAlcCB0byAlcFxuIiwgX19MSU5FX18sICh2b2lkKikoeCksICh2b2lkKikoeSkpOyBcCiAgICBpZiAoKHgpPT0oeSkpIHVkZWxheSg1KTsgfQojZGVmaW5lIFJFTU9WRSh3LHgseSx6KSBcCiAgeyBwcmludGsoIkxJTkU6JWQgICBSZW1vdmluZzogJXAtPiVwICAlcC0+JXAgXG4iLCBfX0xJTkVfXywgXAoJICAgKHZvaWQqKSh3KSwgKHZvaWQqKSh4KSwgKHZvaWQqKSh5KSwgKHZvaWQqKSh6KSk7IFwKICAgIGlmICgoeCk9PSh5KSkgdWRlbGF5KDUpOyB9CiNlbHNlCiNkZWZpbmUgTElTVCh4LHkpCiNkZWZpbmUgUkVNT1ZFKHcseCx5LHopCiNlbmRpZgoKI2lmbmRlZiBub3R5ZXQKI3VuZGVmIExJTktFRAojZW5kaWYKCi8qCiAqIERlc2lnbgogKiBJc3N1ZXMgOgogKgogKiBUaGUgb3RoZXIgTGludXggU0NTSSBkcml2ZXJzIHdlcmUgd3JpdHRlbiB3aGVuIExpbnV4IHdhcyBJbnRlbCBQQy1vbmx5LAogKiBhbmQgc3BlY2lmaWNhbGx5IGZvciBlYWNoIGJvYXJkIHJhdGhlciB0aGFuIGVhY2ggY2hpcC4gIFRoaXMgbWFrZXMgdGhlaXIKICogYWRhcHRhdGlvbiB0byBwbGF0Zm9ybXMgbGlrZSB0aGUgTWFjIChTb21lIG9mIHdoaWNoIHVzZSBOQ1I1MzgwJ3MpCiAqIG1vcmUgZGlmZmljdWx0IHRoYW4gaXQgaGFzIHRvIGJlLgogKgogKiBBbHNvLCBtYW55IG9mIHRoZSBTQ1NJIGRyaXZlcnMgd2VyZSB3cml0dGVuIGJlZm9yZSB0aGUgY29tbWFuZCBxdWV1aW5nCiAqIHJvdXRpbmVzIHdlcmUgaW1wbGVtZW50ZWQsIG1lYW5pbmcgdGhlaXIgaW1wbGVtZW50YXRpb25zIG9mIHF1ZXVlZCAKICogY29tbWFuZHMgd2VyZSBoYWNrZWQgb24gcmF0aGVyIHRoYW4gZGVzaWduZWQgaW4gZnJvbSB0aGUgc3RhcnQuCiAqCiAqIFdoZW4gSSBkZXNpZ25lZCB0aGUgTGludXggU0NTSSBkcml2ZXJzIEkgZmlndXJlZCB0aGF0IAogKiB3aGlsZSBoYXZpbmcgdHdvIGRpZmZlcmVudCBTQ1NJIGJvYXJkcyBpbiBhIHN5c3RlbSBtaWdodCBiZSB1c2VmdWwKICogZm9yIGRlYnVnZ2luZyB0aGluZ3MsIHR3byBvZiB0aGUgc2FtZSB0eXBlIHdvdWxkbid0IGJlIHVzZWQuCiAqIFdlbGwsIEkgd2FzIHdyb25nIGFuZCBhIG51bWJlciBvZiB1c2VycyBoYXZlIG1haWxlZCBtZSBhYm91dCBydW5uaW5nCiAqIG11bHRpcGxlIGhpZ2gtcGVyZm9ybWFuY2UgU0NTSSBib2FyZHMgaW4gYSBzZXJ2ZXIuCiAqCiAqIEZpbmFsbHksIHdoZW4gSSBnZXQgcXVlc3Rpb25zIGZyb20gdXNlcnMsIEkgaGF2ZSBubyBpZGVhIHdoYXQgCiAqIHJldmlzaW9uIG9mIG15IGRyaXZlciB0aGV5IGFyZSBydW5uaW5nLgogKgogKiBUaGlzIGRyaXZlciBhdHRlbXB0cyB0byBhZGRyZXNzIHRoZXNlIHByb2JsZW1zIDoKICogVGhpcyBpcyBhIGdlbmVyaWMgNTM4MCBkcml2ZXIuICBUbyB1c2UgaXQgb24gYSBkaWZmZXJlbnQgcGxhdGZvcm0sIAogKiBvbmUgc2ltcGx5IHdyaXRlcyBhcHByb3ByaWF0ZSBzeXN0ZW0gc3BlY2lmaWMgbWFjcm9zIChpZSwgZGF0YQogKiB0cmFuc2ZlciAtIHNvbWUgUEMncyB3aWxsIHVzZSB0aGUgSS9PIGJ1cywgNjhLJ3MgbXVzdCB1c2UgCiAqIG1lbW9yeSBtYXBwZWQpIGFuZCBkcm9wcyB0aGlzIGZpbGUgaW4gdGhlaXIgJ0MnIHdyYXBwZXIuCiAqCiAqIEFzIGZhciBhcyBjb21tYW5kIHF1ZXVlaW5nLCB0d28gcXVldWVzIGFyZSBtYWludGFpbmVkIGZvciAKICogZWFjaCA1MzgwIGluIHRoZSBzeXN0ZW0gLSBjb21tYW5kcyB0aGF0IGhhdmVuJ3QgYmVlbiBpc3N1ZWQgeWV0LAogKiBhbmQgY29tbWFuZHMgdGhhdCBhcmUgY3VycmVudGx5IGV4ZWN1dGluZy4gIFRoaXMgbWVhbnMgdGhhdCBhbiAKICogdW5saW1pdGVkIG51bWJlciBvZiBjb21tYW5kcyBtYXkgYmUgcXVldWVkLCBsZXR0aW5nIAogKiBtb3JlIGNvbW1hbmRzIHByb3BhZ2F0ZSBmcm9tIHRoZSBoaWdoZXIgZHJpdmVyIGxldmVscyBnaXZpbmcgaGlnaGVyIAogKiB0aHJvdWdocHV0LiAgTm90ZSB0aGF0IGJvdGggSV9UX0wgYW5kIElfVF9MX1EgbmV4dXNlcyBhcmUgc3VwcG9ydGVkLCAKICogYWxsb3dpbmcgbXVsdGlwbGUgY29tbWFuZHMgdG8gcHJvcGFnYXRlIGFsbCB0aGUgd2F5IHRvIGEgU0NTSS1JSSBkZXZpY2UgCiAqIHdoaWxlIGEgY29tbWFuZCBpcyBhbHJlYWR5IGV4ZWN1dGluZy4KICoKICogVG8gc29sdmUgdGhlIG11bHRpcGxlLWJvYXJkcy1pbi10aGUtc2FtZS1zeXN0ZW0gcHJvYmxlbSwgCiAqIHRoZXJlIGlzIGEgc2VwYXJhdGUgaW5zdGFuY2Ugc3RydWN0dXJlIGZvciBlYWNoIGluc3RhbmNlCiAqIG9mIGEgNTM4MCBpbiB0aGUgc3lzdGVtLiAgU28sIG11bHRpcGxlIE5DUjUzODAgZHJpdmVycyB3aWxsCiAqIGJlIGFibGUgdG8gY29leGlzdCB3aXRoIGFwcHJvcHJpYXRlIGNoYW5nZXMgdG8gdGhlIGhpZ2ggbGV2ZWwKICogU0NTSSBjb2RlLiAgCiAqCiAqIEEgTkNSNTM4MF9QVUJMSUNfUkVWSVNJT04gbWFjcm8gaXMgcHJvdmlkZWQsIHdpdGggdGhlIHJlbGVhc2UKICogbnVtYmVyICh1cGRhdGVkIGZvciBlYWNoIHB1YmxpYyByZWxlYXNlKSBwcmludGVkIGJ5IHRoZSAKICogTkNSNTM4MF9wcmludF9vcHRpb25zIGNvbW1hbmQsIHdoaWNoIHNob3VsZCBiZSBjYWxsZWQgZnJvbSB0aGUgCiAqIHdyYXBwZXIgZGV0ZWN0IGZ1bmN0aW9uLCBzbyB0aGF0IEkga25vdyB3aGF0IHJlbGVhc2Ugb2YgdGhlIGRyaXZlcgogKiB1c2VycyBhcmUgdXNpbmcuCiAqCiAqIElzc3VlcyBzcGVjaWZpYyB0byB0aGUgTkNSNTM4MCA6IAogKgogKiBXaGVuIHVzZWQgaW4gYSBQSU8gb3IgcHNldWRvLWRtYSBtb2RlLCB0aGUgTkNSNTM4MCBpcyBhIGJyYWluZGVhZCAKICogcGllY2Ugb2YgaGFyZHdhcmUgdGhhdCByZXF1aXJlcyB5b3UgdG8gc2l0IGluIGEgbG9vcCBwb2xsaW5nIGZvciAKICogdGhlIFJFUSBzaWduYWwgYXMgbG9uZyBhcyB5b3UgYXJlIGNvbm5lY3RlZC4gIFNvbWUgZGV2aWNlcyBhcmUgCiAqIGJyYWluIGRlYWQgKGllLCBtYW55IFRFWEVMIENEIFJPTSBkcml2ZXMpIGFuZCB3b24ndCBkaXNjb25uZWN0IAogKiB3aGlsZSBkb2luZyBsb25nIHNlZWsgb3BlcmF0aW9ucy4KICogCiAqIFRoZSB3b3JrYXJvdW5kIGZvciB0aGlzIGlzIHRvIGtlZXAgdHJhY2sgb2YgZGV2aWNlcyB0aGF0IGhhdmUKICogZGlzY29ubmVjdGVkLiAgSWYgdGhlIGRldmljZSBoYXNuJ3QgZGlzY29ubmVjdGVkLCBmb3IgY29tbWFuZHMgdGhhdAogKiBzaG91bGQgZGlzY29ubmVjdCwgd2UgZG8gc29tZXRoaW5nIGxpa2UgCiAqCiAqIHdoaWxlICghUkVRIGlzIGFzc2VydGVkKSB7IHNsZWVwIGZvciBOIHVzZWNzOyBwb2xsIGZvciBNIHVzZWNzIH0KICogCiAqIFNvbWUgdHdlYWtpbmcgb2YgTiBhbmQgTSBuZWVkcyB0byBiZSBkb25lLiAgQW4gYWxnb3JpdGhtIGJhc2VkIAogKiBvbiAidGltZSB0byBkYXRhIiB3b3VsZCBnaXZlIHRoZSBiZXN0IHJlc3VsdHMgYXMgbG9uZyBhcyBzaG9ydCB0aW1lCiAqIHRvIGRhdGFzIChpZSwgb24gdGhlIHNhbWUgdHJhY2spIHdlcmUgY29uc2lkZXJlZCwgaG93ZXZlciB0aGVzZSAKICogYnJva2VuIGRldmljZXMgYXJlIHRoZSBleGNlcHRpb24gcmF0aGVyIHRoYW4gdGhlIHJ1bGUgYW5kIEknZCByYXRoZXIKICogc3BlbmQgbXkgdGltZSBvcHRpbWl6aW5nIGZvciB0aGUgbm9ybWFsIGNhc2UuCiAqCiAqIEFyY2hpdGVjdHVyZSA6CiAqCiAqIEF0IHRoZSBoZWFydCBvZiB0aGUgZGVzaWduIGlzIGEgY29yb3V0aW5lLCBOQ1I1MzgwX21haW4sCiAqIHdoaWNoIGlzIHN0YXJ0ZWQgd2hlbiBub3QgcnVubmluZyBieSB0aGUgaW50ZXJydXB0IGhhbmRsZXIsCiAqIHRpbWVyLCBhbmQgcXVldWUgY29tbWFuZCBmdW5jdGlvbi4gIEl0IGF0dGVtcHRzIHRvIGVzdGFibGlzaAogKiBJX1RfTCBvciBJX1RfTF9RIG5leHVzZXMgYnkgcmVtb3ZpbmcgdGhlIGNvbW1hbmRzIGZyb20gdGhlIAogKiBpc3N1ZSBxdWV1ZSBhbmQgY2FsbGluZyBOQ1I1MzgwX3NlbGVjdCgpIGlmIGEgbmV4dXMgCiAqIGlzIG5vdCBlc3RhYmxpc2hlZC4gCiAqCiAqIE9uY2UgYSBuZXh1cyBpcyBlc3RhYmxpc2hlZCwgdGhlIE5DUjUzODBfaW5mb3JtYXRpb25fdHJhbnNmZXIoKQogKiBwaGFzZSBnb2VzIHRocm91Z2ggdGhlIHZhcmlvdXMgcGhhc2VzIGFzIGluc3RydWN0ZWQgYnkgdGhlIHRhcmdldC4KICogaWYgdGhlIHRhcmdldCBnb2VzIGludG8gTVNHIElOIGFuZCBzZW5kcyBhIERJU0NPTk5FQ1QgbWVzc2FnZSwKICogdGhlIGNvbW1hbmQgc3RydWN0dXJlIGlzIHBsYWNlZCBpbnRvIHRoZSBwZXIgaW5zdGFuY2UgZGlzY29ubmVjdGVkCiAqIHF1ZXVlLCBhbmQgTkNSNTM4MF9tYWluIHRyaWVzIHRvIGZpbmQgbW9yZSB3b3JrLiAgSWYgVVNMRUVQCiAqIHdhcyBkZWZpbmVkLCBhbmQgdGhlIHRhcmdldCBpcyBpZGxlIGZvciB0b28gbG9uZywgdGhlIHN5c3RlbQogKiB3aWxsIHRyeSB0byBzbGVlcC4KICoKICogSWYgYSBjb21tYW5kIGhhcyBkaXNjb25uZWN0ZWQsIGV2ZW50dWFsbHkgYW4gaW50ZXJydXB0IHdpbGwgdHJpZ2dlciwKICogY2FsbGluZyBOQ1I1MzgwX2ludHIoKSAgd2hpY2ggd2lsbCBpbiB0dXJuIGNhbGwgTkNSNTM4MF9yZXNlbGVjdAogKiB0byByZWVzdGFibGlzaCBhIG5leHVzLiAgVGhpcyB3aWxsIHJ1biBtYWluIGlmIG5lY2Vzc2FyeS4KICoKICogT24gY29tbWFuZCB0ZXJtaW5hdGlvbiwgdGhlIGRvbmUgZnVuY3Rpb24gd2lsbCBiZSBjYWxsZWQgYXMgCiAqIGFwcHJvcHJpYXRlLgogKgogKiBTQ1NJIHBvaW50ZXJzIGFyZSBtYWludGFpbmVkIGluIHRoZSBTQ3AgZmllbGQgb2YgU0NTSSBjb21tYW5kIAogKiBzdHJ1Y3R1cmVzLCBiZWluZyBpbml0aWFsaXplZCBhZnRlciB0aGUgY29tbWFuZCBpcyBjb25uZWN0ZWQKICogaW4gTkNSNTM4MF9zZWxlY3QsIGFuZCBzZXQgYXMgYXBwcm9wcmlhdGUgaW4gTkNSNTM4MF9pbmZvcm1hdGlvbl90cmFuc2Zlci4KICogTm90ZSB0aGF0IGluIHZpb2xhdGlvbiBvZiB0aGUgc3RhbmRhcmQsIGFuIGltcGxpY2l0IFNBVkUgUE9JTlRFUlMgb3BlcmF0aW9uCiAqIGlzIGRvbmUsIHNpbmNlIHNvbWUgQlJPS0VOIGRpc2tzIGZhaWwgdG8gaXNzdWUgYW4gZXhwbGljaXQgU0FWRSBQT0lOVEVSUy4KICovCgovKgogKiBVc2luZyB0aGlzIGZpbGUgOgogKiBUaGlzIGZpbGUgYSBza2VsZXRvbiBMaW51eCBTQ1NJIGRyaXZlciBmb3IgdGhlIE5DUiA1MzgwIHNlcmllcwogKiBvZiBjaGlwcy4gIFRvIHVzZSBpdCwgeW91IHdyaXRlIGFuIGFyY2hpdGVjdHVyZSBzcGVjaWZpYyBmdW5jdGlvbnMgCiAqIGFuZCBtYWNyb3MgYW5kIGluY2x1ZGUgdGhpcyBmaWxlIGluIHlvdXIgZHJpdmVyLgogKgogKiBUaGVzZSBtYWNyb3MgY29udHJvbCBvcHRpb25zIDogCiAqIEFVVE9TRU5TRSAtIGlmIGRlZmluZWQsIFJFUVVFU1QgU0VOU0Ugd2lsbCBiZSBwZXJmb3JtZWQgYXV0b21hdGljYWxseQogKglmb3IgY29tbWFuZHMgdGhhdCByZXR1cm4gd2l0aCBhIENIRUNLIENPTkRJVElPTiBzdGF0dXMuIAogKgogKiBMSU5LRUQgLSBpZiBkZWZpbmVkLCBsaW5rZWQgY29tbWFuZHMgYXJlIHN1cHBvcnRlZC4KICoKICogUkVBTF9ETUEgLSBpZiBkZWZpbmVkLCBSRUFMIERNQSBpcyB1c2VkIGR1cmluZyB0aGUgZGF0YSB0cmFuc2ZlciBwaGFzZXMuCiAqCiAqIFNVUFBPUlRfVEFHUyAtIGlmIGRlZmluZWQsIFNDU0ktMiB0YWdnZWQgcXVldWluZyBpcyB1c2VkIHdoZXJlIHBvc3NpYmxlCiAqCiAqIFRoZXNlIG1hY3JvcyBNVVNUIGJlIGRlZmluZWQgOgogKiAKICogTkNSNTM4MF9yZWFkKHJlZ2lzdGVyKSAgLSByZWFkIGZyb20gdGhlIHNwZWNpZmllZCByZWdpc3RlcgogKgogKiBOQ1I1MzgwX3dyaXRlKHJlZ2lzdGVyLCB2YWx1ZSkgLSB3cml0ZSB0byB0aGUgc3BlY2lmaWMgcmVnaXN0ZXIgCiAqCiAqIEVpdGhlciByZWFsIERNQSAqb3IqIHBzZXVkbyBETUEgbWF5IGJlIGltcGxlbWVudGVkCiAqIFJFQUwgZnVuY3Rpb25zIDogCiAqIE5DUjUzODBfUkVBTF9ETUEgc2hvdWxkIGJlIGRlZmluZWQgaWYgcmVhbCBETUEgaXMgdG8gYmUgdXNlZC4KICogTm90ZSB0aGF0IHRoZSBETUEgc2V0dXAgZnVuY3Rpb25zIHNob3VsZCByZXR1cm4gdGhlIG51bWJlciBvZiBieXRlcyAKICoJdGhhdCB0aGV5IHdlcmUgYWJsZSB0byBwcm9ncmFtIHRoZSBjb250cm9sbGVyIGZvci4KICoKICogQWxzbyBub3RlIHRoYXQgZ2VuZXJpYyBpMzg2L1BDIHZlcnNpb25zIG9mIHRoZXNlIG1hY3JvcyBhcmUgCiAqCWF2YWlsYWJsZSBhcyBOQ1I1MzgwX2kzODZfZG1hX3dyaXRlX3NldHVwLAogKglOQ1I1MzgwX2kzODZfZG1hX3JlYWRfc2V0dXAsIGFuZCBOQ1I1MzgwX2kzODZfZG1hX3Jlc2lkdWFsLgogKgogKiBOQ1I1MzgwX2RtYV93cml0ZV9zZXR1cChpbnN0YW5jZSwgc3JjLCBjb3VudCkgLSBpbml0aWFsaXplCiAqIE5DUjUzODBfZG1hX3JlYWRfc2V0dXAoaW5zdGFuY2UsIGRzdCwgY291bnQpIC0gaW5pdGlhbGl6ZQogKiBOQ1I1MzgwX2RtYV9yZXNpZHVhbChpbnN0YW5jZSk7IC0gcmVzaWR1YWwgY291bnQKICoKICogUFNFVURPIGZ1bmN0aW9ucyA6CiAqIE5DUjUzODBfcHdyaXRlKGluc3RhbmNlLCBzcmMsIGNvdW50KQogKiBOQ1I1MzgwX3ByZWFkKGluc3RhbmNlLCBkc3QsIGNvdW50KTsKICoKICogSWYgbm90aGluZyBzcGVjaWZpYyB0byB0aGlzIGltcGxlbWVudGF0aW9uIG5lZWRzIGRvaW5nIChpZSwgd2l0aCBleHRlcm5hbAogKiBoYXJkd2FyZSksIHlvdSBtdXN0IGFsc28gZGVmaW5lIAogKiAgCiAqIE5DUjUzODBfcXVldWVfY29tbWFuZAogKiBOQ1I1MzgwX3Jlc2V0CiAqIE5DUjUzODBfYWJvcnQKICogTkNSNTM4MF9wcm9jX2luZm8KICoKICogdG8gYmUgdGhlIGdsb2JhbCBlbnRyeSBwb2ludHMgaW50byB0aGUgc3BlY2lmaWMgZHJpdmVyLCBpZSAKICogI2RlZmluZSBOQ1I1MzgwX3F1ZXVlX2NvbW1hbmQgdDEyOF9xdWV1ZV9jb21tYW5kLgogKgogKiBJZiB0aGlzIGlzIG5vdCBkb25lLCB0aGUgcm91dGluZXMgd2lsbCBiZSBkZWZpbmVkIGFzIHN0YXRpYyBmdW5jdGlvbnMKICogd2l0aCB0aGUgTkNSNTM4MCogbmFtZXMgYW5kIHRoZSB1c2VyIG11c3QgcHJvdmlkZSBhIGdsb2JhbGx5CiAqIGFjY2Vzc2libGUgd3JhcHBlciBmdW5jdGlvbi4KICoKICogVGhlIGdlbmVyaWMgZHJpdmVyIGlzIGluaXRpYWxpemVkIGJ5IGNhbGxpbmcgTkNSNTM4MF9pbml0KGluc3RhbmNlKSwKICogYWZ0ZXIgc2V0dGluZyB0aGUgYXBwcm9wcmlhdGUgaG9zdCBzcGVjaWZpYyBmaWVsZHMgYW5kIElELiAgSWYgdGhlIAogKiBkcml2ZXIgd2lzaGVzIHRvIGF1dG9wcm9iZSBmb3IgYW4gSVJRIGxpbmUsIHRoZSBOQ1I1MzgwX3Byb2JlX2lycShpbnN0YW5jZSwKICogcG9zc2libGUpIGZ1bmN0aW9uIG1heSBiZSB1c2VkLiAgQmVmb3JlIHRoZSBzcGVjaWZpYyBkcml2ZXIgaW5pdGlhbGl6YXRpb24KICogY29kZSBmaW5pc2hlcywgTkNSNTM4MF9wcmludF9vcHRpb25zIHNob3VsZCBiZSBjYWxsZWQuCiAqLwoKc3RhdGljIHN0cnVjdCBTY3NpX0hvc3QgKmZpcnN0X2luc3RhbmNlID0gTlVMTDsKc3RhdGljIHN0cnVjdCBzY3NpX2hvc3RfdGVtcGxhdGUgKnRoZV90ZW1wbGF0ZSA9IE5VTEw7CgovKiBNYWNyb3MgZWFzZSBsaWZlLi4uIDotKSAqLwojZGVmaW5lCVNFVFVQX0hPU1REQVRBKGluKQkJCQlcCiAgICBzdHJ1Y3QgTkNSNTM4MF9ob3N0ZGF0YSAqaG9zdGRhdGEgPQkJCVwKCShzdHJ1Y3QgTkNSNTM4MF9ob3N0ZGF0YSAqKShpbiktPmhvc3RkYXRhCiNkZWZpbmUJSE9TVERBVEEoaW4pICgoc3RydWN0IE5DUjUzODBfaG9zdGRhdGEgKikoaW4pLT5ob3N0ZGF0YSkKCiNkZWZpbmUJTkVYVChjbWQpCSgoU2NzaV9DbW5kICopKChjbWQpLT5ob3N0X3NjcmliYmxlKSkKI2RlZmluZQlORVhUQUREUihjbWQpCSgoU2NzaV9DbW5kICoqKSYoKGNtZCktPmhvc3Rfc2NyaWJibGUpKQoKI2RlZmluZQlIT1NUTk8JCWluc3RhbmNlLT5ob3N0X25vCiNkZWZpbmUJSF9OTyhjbWQpCShjbWQpLT5kZXZpY2UtPmhvc3QtPmhvc3Rfbm8KCiNpZmRlZiBTVVBQT1JUX1RBR1MKCi8qCiAqIEZ1bmN0aW9ucyBmb3IgaGFuZGxpbmcgdGFnZ2VkIHF1ZXVpbmcKICogPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogKgogKiArK3JvbWFuICgwMS85Nik6IE5vdyBJJ3ZlIGltcGxlbWVudGVkIFNDU0ktMiB0YWdnZWQgcXVldWluZy4gU29tZSBub3RlczoKICoKICogVXNpbmcgY29uc2VjdXRpdmUgbnVtYmVycyBmb3IgdGhlIHRhZ3MgaXMgbm8gZ29vZCBpZGVhIGluIG15IGV5ZXMuIFRoZXJlCiAqIGNvdWxkIGJlIHdyb25nIHJlLXVzaW5ncyBpZiB0aGUgY291bnRlciAoOCBiaXQhKSB3cmFwcyBhbmQgc29tZSBlYXJseQogKiBjb21tYW5kIGhhcyBiZWVuIHByZWVtcHRlZCBmb3IgYSBsb25nIHRpbWUuIE15IHNvbHV0aW9uOiBhIGJpdGZpZWxkIGZvcgogKiByZW1lbWJlcmluZyB1c2VkIHRhZ3MuCiAqCiAqIFRoZXJlJ3MgYWxzbyB0aGUgcHJvYmxlbSB0aGF0IGVhY2ggdGFyZ2V0IGhhcyBhIGNlcnRhaW4gcXVldWUgc2l6ZSwgYnV0IHdlCiAqIGNhbm5vdCBrbm93IGl0IGluIGFkdmFuY2UgOi0oIFdlIGp1c3Qgc2VlIGEgUVVFVUVfRlVMTCBzdGF0dXMgYmVpbmcKICogcmV0dXJuZWQuIFNvLCBpbiB0aGlzIGNhc2UsIHRoZSBkcml2ZXIgaW50ZXJuYWwgcXVldWUgc2l6ZSBhc3N1bXB0aW9uIGlzCiAqIHJlZHVjZWQgdG8gdGhlIG51bWJlciBvZiBhY3RpdmUgdGFncyBpZiBRVUVVRV9GVUxMIGlzIHJldHVybmVkIGJ5IHRoZQogKiB0YXJnZXQuIFRoZSBjb21tYW5kIGlzIHJldHVybmVkIHRvIHRoZSBtaWQtbGV2ZWwsIGJ1dCB3aXRoIHN0YXR1cyBjaGFuZ2VkCiAqIHRvIEJVU1ksIHNpbmNlIC0tYXMgSSd2ZSBzZWVuLS0gdGhlIG1pZC1sZXZlbCBjYW4ndCBoYW5kbGUgUVVFVUVfRlVMTAogKiBjb3JyZWN0bHkuCiAqCiAqIFdlJ3JlIGFsc28gbm90IGFsbG93ZWQgcnVubmluZyB0YWdnZWQgY29tbWFuZHMgYXMgbG9uZyBhcyBhbiB1bnRhZ2dlZAogKiBjb21tYW5kIGlzIGFjdGl2ZS4gQW5kIFJFUVVFU1QgU0VOU0UgY29tbWFuZHMgYWZ0ZXIgYSBjb250aW5nZW50IGFsbGVnaWFuY2UKICogY29uZGl0aW9uIF9tdXN0XyBiZSB1bnRhZ2dlZC4gVG8ga2VlcCB0cmFjayB3aGV0aGVyIGFuIHVudGFnZ2VkIGNvbW1hbmQgaGFzCiAqIGJlZW4gaXNzdWVkLCB0aGUgaG9zdC0+YnVzeSBhcnJheSBpcyBzdGlsbCBlbXBsb3llZCwgYXMgaXQgaXMgd2l0aG91dAogKiBzdXBwb3J0IGZvciB0YWdnZWQgcXVldWluZy4KICoKICogT25lIGNvdWxkIHN1c3BlY3QgdGhhdCB0aGVyZSBhcmUgcG9zc2libGUgcmFjZSBjb25kaXRpb25zIGJldHdlZW4KICogaXNfbHVuX2J1c3koKSwgY21kX2dldF90YWcoKSBhbmQgY21kX2ZyZWVfdGFnKCkuIEJ1dCBJIHRoaW5rIHRoaXMgaXNuJ3QgdGhlCiAqIGNhc2U6IGlzX2x1bl9idXN5KCkgYW5kIGNtZF9nZXRfdGFnKCkgYXJlIGJvdGggY2FsbGVkIGZyb20gTkNSNTM4MF9tYWluKCksCiAqIHdoaWNoIGFscmVhZHkgZ3VhcmFudGVlZCB0byBiZSBydW5uaW5nIGF0IG1vc3Qgb25jZS4gSXQgaXMgYWxzbyB0aGUgb25seQogKiBwbGFjZSB3aGVyZSB0YWdzL0xVTnMgYXJlIGFsbG9jYXRlZC4gU28gbm8gb3RoZXIgYWxsb2NhdGlvbiBjYW4gc2xpcAogKiBiZXR3ZWVuIHRoYXQgcGFpciwgdGhlcmUgY291bGQgb25seSBoYXBwZW4gYSByZXNlbGVjdGlvbiwgd2hpY2ggY2FuIGZyZWUgYQogKiB0YWcsIGJ1dCB0aGF0IGRvZXNuJ3QgaHVydC4gT25seSB0aGUgc2VxdWVuY2UgaW4gY21kX2ZyZWVfdGFnKCkgYmVjb21lcwogKiBpbXBvcnRhbnQ6IHRoZSB0YWcgYml0IG11c3QgYmUgY2xlYXJlZCBiZWZvcmUgJ25yX2FsbG9jYXRlZCcgaXMgZGVjcmVhc2VkLgogKi8KCi8qIC0xIGZvciBUQUdfTk9ORSBpcyBub3QgcG9zc2libGUgd2l0aCB1bnNpZ25lZCBjaGFyIGNtZC0+dGFnICovCiN1bmRlZiBUQUdfTk9ORQojZGVmaW5lIFRBR19OT05FIDB4ZmYKCnR5cGVkZWYgc3RydWN0IHsKICAgIERFQ0xBUkVfQklUTUFQKGFsbG9jYXRlZCwgTUFYX1RBR1MpOwogICAgaW50CQlucl9hbGxvY2F0ZWQ7CiAgICBpbnQJCXF1ZXVlX3NpemU7Cn0gVEFHX0FMTE9DOwoKc3RhdGljIFRBR19BTExPQyBUYWdBbGxvY1s4XVs4XTsgLyogOCB0YXJnZXRzIGFuZCA4IExVTnMgKi8KCgpzdGF0aWMgdm9pZCBfX2luaXQgaW5pdF90YWdzKCB2b2lkICkKewogICAgaW50IHRhcmdldCwgbHVuOwogICAgVEFHX0FMTE9DICp0YTsKICAgIAogICAgaWYgKCFzZXR1cF91c2VfdGFnZ2VkX3F1ZXVpbmcpCglyZXR1cm47CiAgICAKICAgIGZvciggdGFyZ2V0ID0gMDsgdGFyZ2V0IDwgODsgKyt0YXJnZXQgKSB7Cglmb3IoIGx1biA9IDA7IGx1biA8IDg7ICsrbHVuICkgewoJICAgIHRhID0gJlRhZ0FsbG9jW3RhcmdldF1bbHVuXTsKCSAgICBiaXRtYXBfemVybyh0YS0+YWxsb2NhdGVkLCBNQVhfVEFHUyk7CgkgICAgdGEtPm5yX2FsbG9jYXRlZCA9IDA7CgkgICAgLyogQXQgdGhlIGJlZ2lubmluZywgYXNzdW1lIHRoZSBtYXhpbXVtIHF1ZXVlIHNpemUgd2UgY291bGQKCSAgICAgKiBzdXBwb3J0IChNQVhfVEFHUykuIFRoaXMgdmFsdWUgd2lsbCBiZSBkZWNyZWFzZWQgaWYgdGhlIHRhcmdldAoJICAgICAqIHJldHVybnMgUVVFVUVfRlVMTCBzdGF0dXMuCgkgICAgICovCgkgICAgdGEtPnF1ZXVlX3NpemUgPSBNQVhfVEFHUzsKCX0KICAgIH0KfQoKCi8qIENoZWNrIGlmIHdlIGNhbiBpc3N1ZSBhIGNvbW1hbmQgdG8gdGhpcyBMVU46IEZpcnN0IHNlZSBpZiB0aGUgTFVOIGlzIG1hcmtlZAogKiBidXN5IGJ5IGFuIHVudGFnZ2VkIGNvbW1hbmQuIElmIHRoZSBjb21tYW5kIHNob3VsZCB1c2UgdGFnZ2VkIHF1ZXVpbmcsIGFsc28KICogY2hlY2sgdGhhdCB0aGVyZSBpcyBhIGZyZWUgdGFnIGFuZCB0aGUgdGFyZ2V0J3MgcXVldWUgd29uJ3Qgb3ZlcmZsb3cuIFRoaXMKICogZnVuY3Rpb24gc2hvdWxkIGJlIGNhbGxlZCB3aXRoIGludGVycnVwdHMgZGlzYWJsZWQgdG8gYXZvaWQgcmFjZQogKiBjb25kaXRpb25zLgogKi8gCgpzdGF0aWMgaW50IGlzX2x1bl9idXN5KCBTY3NpX0NtbmQgKmNtZCwgaW50IHNob3VsZF9iZV90YWdnZWQgKQp7CiAgICBTRVRVUF9IT1NUREFUQShjbWQtPmRldmljZS0+aG9zdCk7CgogICAgaWYgKGhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gJiAoMSA8PCBjbWQtPmRldmljZS0+bHVuKSkKCXJldHVybiggMSApOwogICAgaWYgKCFzaG91bGRfYmVfdGFnZ2VkIHx8Cgkhc2V0dXBfdXNlX3RhZ2dlZF9xdWV1aW5nIHx8ICFjbWQtPmRldmljZS0+dGFnZ2VkX3N1cHBvcnRlZCkKCXJldHVybiggMCApOwogICAgaWYgKFRhZ0FsbG9jW2NtZC0+ZGV2aWNlLT5pZF1bY21kLT5kZXZpY2UtPmx1bl0ubnJfYWxsb2NhdGVkID49CglUYWdBbGxvY1tjbWQtPmRldmljZS0+aWRdW2NtZC0+ZGV2aWNlLT5sdW5dLnF1ZXVlX3NpemUgKSB7CglUQUdfUFJJTlRLKCAic2NzaSVkOiB0YXJnZXQgJWQgbHVuICVkOiBubyBmcmVlIHRhZ3NcbiIsCgkJICAgIEhfTk8oY21kKSwgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuICk7CglyZXR1cm4oIDEgKTsKICAgIH0KICAgIHJldHVybiggMCApOwp9CgoKLyogQWxsb2NhdGUgYSB0YWcgZm9yIGEgY29tbWFuZCAodGhlcmUgYXJlIG5vIGNoZWNrcyBhbnltb3JlLCBjaGVja19sdW5fYnVzeSgpCiAqIG11c3QgYmUgY2FsbGVkIGJlZm9yZSEpLCBvciByZXNlcnZlIHRoZSBMVU4gaW4gJ2J1c3knIGlmIHRoZSBjb21tYW5kIGlzCiAqIHVudGFnZ2VkLgogKi8KCnN0YXRpYyB2b2lkIGNtZF9nZXRfdGFnKCBTY3NpX0NtbmQgKmNtZCwgaW50IHNob3VsZF9iZV90YWdnZWQgKQp7CiAgICBTRVRVUF9IT1NUREFUQShjbWQtPmRldmljZS0+aG9zdCk7CgogICAgLyogSWYgd2Ugb3IgdGhlIHRhcmdldCBkb24ndCBzdXBwb3J0IHRhZ2dlZCBxdWV1aW5nLCBhbGxvY2F0ZSB0aGUgTFVOIGZvcgogICAgICogYW4gdW50YWdnZWQgY29tbWFuZC4KICAgICAqLwogICAgaWYgKCFzaG91bGRfYmVfdGFnZ2VkIHx8Cgkhc2V0dXBfdXNlX3RhZ2dlZF9xdWV1aW5nIHx8ICFjbWQtPmRldmljZS0+dGFnZ2VkX3N1cHBvcnRlZCkgewoJY21kLT50YWcgPSBUQUdfTk9ORTsKCWhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gfD0gKDEgPDwgY21kLT5kZXZpY2UtPmx1bik7CglUQUdfUFJJTlRLKCAic2NzaSVkOiB0YXJnZXQgJWQgbHVuICVkIG5vdyBhbGxvY2F0ZWQgYnkgdW50YWdnZWQgIgoJCSAgICAiY29tbWFuZFxuIiwgSF9OTyhjbWQpLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4gKTsKICAgIH0KICAgIGVsc2UgewoJVEFHX0FMTE9DICp0YSA9ICZUYWdBbGxvY1tjbWQtPmRldmljZS0+aWRdW2NtZC0+ZGV2aWNlLT5sdW5dOwoKCWNtZC0+dGFnID0gZmluZF9maXJzdF96ZXJvX2JpdCggdGEtPmFsbG9jYXRlZCwgTUFYX1RBR1MgKTsKCXNldF9iaXQoIGNtZC0+dGFnLCB0YS0+YWxsb2NhdGVkICk7Cgl0YS0+bnJfYWxsb2NhdGVkKys7CglUQUdfUFJJTlRLKCAic2NzaSVkOiB1c2luZyB0YWcgJWQgZm9yIHRhcmdldCAlZCBsdW4gJWQgIgoJCSAgICAiKG5vdyAlZCB0YWdzIGluIHVzZSlcbiIsCgkJICAgIEhfTk8oY21kKSwgY21kLT50YWcsIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1biwKCQkgICAgdGEtPm5yX2FsbG9jYXRlZCApOwogICAgfQp9CgoKLyogTWFyayB0aGUgdGFnIG9mIGNvbW1hbmQgJ2NtZCcgYXMgZnJlZSwgb3IgaW4gY2FzZSBvZiBhbiB1bnRhZ2dlZCBjb21tYW5kLAogKiB1bmxvY2sgdGhlIExVTi4KICovCgpzdGF0aWMgdm9pZCBjbWRfZnJlZV90YWcoIFNjc2lfQ21uZCAqY21kICkKewogICAgU0VUVVBfSE9TVERBVEEoY21kLT5kZXZpY2UtPmhvc3QpOwoKICAgIGlmIChjbWQtPnRhZyA9PSBUQUdfTk9ORSkgewoJaG9zdGRhdGEtPmJ1c3lbY21kLT5kZXZpY2UtPmlkXSAmPSB+KDEgPDwgY21kLT5kZXZpY2UtPmx1bik7CglUQUdfUFJJTlRLKCAic2NzaSVkOiB0YXJnZXQgJWQgbHVuICVkIHVudGFnZ2VkIGNtZCBmaW5pc2hlZFxuIiwKCQkgICAgSF9OTyhjbWQpLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4gKTsKICAgIH0KICAgIGVsc2UgaWYgKGNtZC0+dGFnID49IE1BWF9UQUdTKSB7CglwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogdHJ5aW5nIHRvIGZyZWUgYmFkIHRhZyAlZCFcbiIsCgkJSF9OTyhjbWQpLCBjbWQtPnRhZyApOwogICAgfQogICAgZWxzZSB7CglUQUdfQUxMT0MgKnRhID0gJlRhZ0FsbG9jW2NtZC0+ZGV2aWNlLT5pZF1bY21kLT5kZXZpY2UtPmx1bl07CgljbGVhcl9iaXQoIGNtZC0+dGFnLCB0YS0+YWxsb2NhdGVkICk7Cgl0YS0+bnJfYWxsb2NhdGVkLS07CglUQUdfUFJJTlRLKCAic2NzaSVkOiBmcmVlZCB0YWcgJWQgZm9yIHRhcmdldCAlZCBsdW4gJWRcbiIsCgkJICAgIEhfTk8oY21kKSwgY21kLT50YWcsIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1biApOwogICAgfQp9CgoKc3RhdGljIHZvaWQgZnJlZV9hbGxfdGFncyggdm9pZCApCnsKICAgIGludCB0YXJnZXQsIGx1bjsKICAgIFRBR19BTExPQyAqdGE7CgogICAgaWYgKCFzZXR1cF91c2VfdGFnZ2VkX3F1ZXVpbmcpCglyZXR1cm47CiAgICAKICAgIGZvciggdGFyZ2V0ID0gMDsgdGFyZ2V0IDwgODsgKyt0YXJnZXQgKSB7Cglmb3IoIGx1biA9IDA7IGx1biA8IDg7ICsrbHVuICkgewoJICAgIHRhID0gJlRhZ0FsbG9jW3RhcmdldF1bbHVuXTsKCSAgICBiaXRtYXBfemVybyh0YS0+YWxsb2NhdGVkLCBNQVhfVEFHUyk7CgkgICAgdGEtPm5yX2FsbG9jYXRlZCA9IDA7Cgl9CiAgICB9Cn0KCiNlbmRpZiAvKiBTVVBQT1JUX1RBR1MgKi8KCgovKgogKiBGdW5jdGlvbjogdm9pZCBtZXJnZV9jb250aWd1b3VzX2J1ZmZlcnMoIFNjc2lfQ21uZCAqY21kICkKICoKICogUHVycG9zZTogVHJ5IHRvIG1lcmdlIHNldmVyYWwgc2NhdHRlci1nYXRoZXIgcmVxdWVzdHMgaW50byBvbmUgRE1BCiAqICAgIHRyYW5zZmVyLiBUaGlzIGlzIHBvc3NpYmxlIGlmIHRoZSBzY2F0dGVyIGJ1ZmZlcnMgbGllIG9uCiAqICAgIHBoeXNpY2FsIGNvbnRpZ3VvdXMgYWRkcmVzc2VzLgogKgogKiBQYXJhbWV0ZXJzOiBTY3NpX0NtbmQgKmNtZAogKiAgICBUaGUgY29tbWFuZCB0byB3b3JrIG9uLiBUaGUgZmlyc3Qgc2NhdHRlciBidWZmZXIncyBkYXRhIGFyZQogKiAgICBhc3N1bWVkIHRvIGJlIGFscmVhZHkgdHJhbnNmZXJlZCBpbnRvIHB0ci90aGlzX3Jlc2lkdWFsLgogKi8KCnN0YXRpYyB2b2lkIG1lcmdlX2NvbnRpZ3VvdXNfYnVmZmVycyggU2NzaV9DbW5kICpjbWQgKQp7CiAgICB1bnNpZ25lZCBsb25nIGVuZGFkZHI7CiNpZiAoTkRFQlVHICYgTkRFQlVHX01FUkdJTkcpCiAgICB1bnNpZ25lZCBsb25nIG9sZGxlbiA9IGNtZC0+U0NwLnRoaXNfcmVzaWR1YWw7CiAgICBpbnQJCSAgY250ID0gMTsKI2VuZGlmCgogICAgZm9yIChlbmRhZGRyID0gdmlydF90b19waHlzKGNtZC0+U0NwLnB0ciArIGNtZC0+U0NwLnRoaXNfcmVzaWR1YWwgLSAxKSArIDE7CgkgY21kLT5TQ3AuYnVmZmVyc19yZXNpZHVhbCAmJgoJIHZpcnRfdG9fcGh5cyhwYWdlX2FkZHJlc3MoY21kLT5TQ3AuYnVmZmVyWzFdLnBhZ2UpKwoJCSAgICAgIGNtZC0+U0NwLmJ1ZmZlclsxXS5vZmZzZXQpID09IGVuZGFkZHI7ICkgewoJTUVSX1BSSU5USygiVlRPUCglcCkgPT0gJTA4bHggLT4gbWVyZ2luZ1xuIiwKCQkgICBjbWQtPlNDcC5idWZmZXJbMV0uYWRkcmVzcywgZW5kYWRkcik7CiNpZiAoTkRFQlVHICYgTkRFQlVHX01FUkdJTkcpCgkrK2NudDsKI2VuZGlmCgkrK2NtZC0+U0NwLmJ1ZmZlcjsKCS0tY21kLT5TQ3AuYnVmZmVyc19yZXNpZHVhbDsKCWNtZC0+U0NwLnRoaXNfcmVzaWR1YWwgKz0gY21kLT5TQ3AuYnVmZmVyLT5sZW5ndGg7CgllbmRhZGRyICs9IGNtZC0+U0NwLmJ1ZmZlci0+bGVuZ3RoOwogICAgfQojaWYgKE5ERUJVRyAmIE5ERUJVR19NRVJHSU5HKQogICAgaWYgKG9sZGxlbiAhPSBjbWQtPlNDcC50aGlzX3Jlc2lkdWFsKQoJTUVSX1BSSU5USygibWVyZ2VkICVkIGJ1ZmZlcnMgZnJvbSAlcCwgbmV3IGxlbmd0aCAlMDh4XG4iLAoJCSAgIGNudCwgY21kLT5TQ3AucHRyLCBjbWQtPlNDcC50aGlzX3Jlc2lkdWFsKTsKI2VuZGlmCn0KCi8qCiAqIEZ1bmN0aW9uIDogdm9pZCBpbml0aWFsaXplX1NDcChTY3NpX0NtbmQgKmNtZCkKICoKICogUHVycG9zZSA6IGluaXRpYWxpemUgdGhlIHNhdmVkIGRhdGEgcG9pbnRlcnMgZm9yIGNtZCB0byBwb2ludCB0byB0aGUgCiAqCXN0YXJ0IG9mIHRoZSBidWZmZXIuCiAqCiAqIElucHV0cyA6IGNtZCAtIFNjc2lfQ21uZCBzdHJ1Y3R1cmUgdG8gaGF2ZSBwb2ludGVycyByZXNldC4KICovCgpzdGF0aWMgX19pbmxpbmVfXyB2b2lkIGluaXRpYWxpemVfU0NwKFNjc2lfQ21uZCAqY21kKQp7CiAgICAvKiAKICAgICAqIEluaXRpYWxpemUgdGhlIFNjc2kgUG9pbnRlciBmaWVsZCBzbyB0aGF0IGFsbCBvZiB0aGUgY29tbWFuZHMgaW4gdGhlIAogICAgICogdmFyaW91cyBxdWV1ZXMgYXJlIHZhbGlkLgogICAgICovCgogICAgaWYgKGNtZC0+dXNlX3NnKSB7CgljbWQtPlNDcC5idWZmZXIgPSAoc3RydWN0IHNjYXR0ZXJsaXN0ICopIGNtZC0+YnVmZmVyOwoJY21kLT5TQ3AuYnVmZmVyc19yZXNpZHVhbCA9IGNtZC0+dXNlX3NnIC0gMTsKCWNtZC0+U0NwLnB0ciA9IChjaGFyICopcGFnZV9hZGRyZXNzKGNtZC0+U0NwLmJ1ZmZlci0+cGFnZSkrCgkJICAgICAgIGNtZC0+U0NwLmJ1ZmZlci0+b2Zmc2V0OwoJY21kLT5TQ3AudGhpc19yZXNpZHVhbCA9IGNtZC0+U0NwLmJ1ZmZlci0+bGVuZ3RoOwoJLyogKytyb21hbjogVHJ5IHRvIG1lcmdlIHNvbWUgc2NhdHRlci1idWZmZXJzIGlmIHRoZXkgYXJlIGF0CgkgKiBjb250aWd1b3VzIHBoeXNpY2FsIGFkZHJlc3Nlcy4KCSAqLwoJbWVyZ2VfY29udGlndW91c19idWZmZXJzKCBjbWQgKTsKICAgIH0gZWxzZSB7CgljbWQtPlNDcC5idWZmZXIgPSBOVUxMOwoJY21kLT5TQ3AuYnVmZmVyc19yZXNpZHVhbCA9IDA7CgljbWQtPlNDcC5wdHIgPSAoY2hhciAqKSBjbWQtPnJlcXVlc3RfYnVmZmVyOwoJY21kLT5TQ3AudGhpc19yZXNpZHVhbCA9IGNtZC0+cmVxdWVzdF9idWZmbGVuOwogICAgfQp9CgojaW5jbHVkZSA8bGludXgvZGVsYXkuaD4KCiNpZiBOREVCVUcKc3RhdGljIHN0cnVjdCB7CiAgICB1bnNpZ25lZCBjaGFyIG1hc2s7CiAgICBjb25zdCBjaGFyICogbmFtZTt9IApzaWduYWxzW10gPSB7eyBTUl9EQlAsICJQQVJJVFkifSwgeyBTUl9SU1QsICJSU1QiIH0sIHsgU1JfQlNZLCAiQlNZIiB9LCAKICAgIHsgU1JfUkVRLCAiUkVRIiB9LCB7IFNSX01TRywgIk1TRyIgfSwgeyBTUl9DRCwgICJDRCIgfSwgeyBTUl9JTywgIklPIiB9LCAKICAgIHsgU1JfU0VMLCAiU0VMIiB9LCB7MCwgTlVMTH19LCAKYmFzcnNbXSA9IHt7QkFTUl9BVE4sICJBVE4ifSwge0JBU1JfQUNLLCAiQUNLIn0sIHswLCBOVUxMfX0sCmljcnNbXSA9IHt7SUNSX0FTU0VSVF9SU1QsICJBU1NFUlQgUlNUIn0se0lDUl9BU1NFUlRfQUNLLCAiQVNTRVJUIEFDSyJ9LAogICAge0lDUl9BU1NFUlRfQlNZLCAiQVNTRVJUIEJTWSJ9LCB7SUNSX0FTU0VSVF9TRUwsICJBU1NFUlQgU0VMIn0sIAogICAge0lDUl9BU1NFUlRfQVROLCAiQVNTRVJUIEFUTiJ9LCB7SUNSX0FTU0VSVF9EQVRBLCAiQVNTRVJUIERBVEEifSwgCiAgICB7MCwgTlVMTH19LAptcnNbXSA9IHt7TVJfQkxPQ0tfRE1BX01PREUsICJNT0RFIEJMT0NLIERNQSJ9LCB7TVJfVEFSR0VULCAiTU9ERSBUQVJHRVQifSwgCiAgICB7TVJfRU5BQkxFX1BBUl9DSEVDSywgIk1PREUgUEFSSVRZIENIRUNLIn0sIHtNUl9FTkFCTEVfUEFSX0lOVFIsIAogICAgIk1PREUgUEFSSVRZIElOVFIifSwge01SX0VOQUJMRV9FT1BfSU5UUiwiTU9ERSBFT1AgSU5UUiJ9LAogICAge01SX01PTklUT1JfQlNZLCAiTU9ERSBNT05JVE9SIEJTWSJ9LAogICAge01SX0RNQV9NT0RFLCAiTU9ERSBETUEifSwge01SX0FSQklUUkFURSwgIk1PREUgQVJCSVRSQVRJT04ifSwgCiAgICB7MCwgTlVMTH19OwoKLyoKICogRnVuY3Rpb24gOiB2b2lkIE5DUjUzODBfcHJpbnQoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCiAqCiAqIFB1cnBvc2UgOiBwcmludCB0aGUgU0NTSSBidXMgc2lnbmFscyBmb3IgZGVidWdnaW5nIHB1cnBvc2VzCiAqCiAqIElucHV0IDogaW5zdGFuY2UgLSB3aGljaCBOQ1I1MzgwCiAqLwoKc3RhdGljIHZvaWQgTkNSNTM4MF9wcmludChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkgewogICAgdW5zaWduZWQgY2hhciBzdGF0dXMsIGRhdGEsIGJhc3IsIG1yLCBpY3IsIGk7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwoKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIGRhdGEgPSBOQ1I1MzgwX3JlYWQoQ1VSUkVOVF9TQ1NJX0RBVEFfUkVHKTsKICAgIHN0YXR1cyA9IE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKTsKICAgIG1yID0gTkNSNTM4MF9yZWFkKE1PREVfUkVHKTsKICAgIGljciA9IE5DUjUzODBfcmVhZChJTklUSUFUT1JfQ09NTUFORF9SRUcpOwogICAgYmFzciA9IE5DUjUzODBfcmVhZChCVVNfQU5EX1NUQVRVU19SRUcpOwogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogICAgcHJpbnRrKCJTVEFUVVNfUkVHOiAlMDJ4ICIsIHN0YXR1cyk7CiAgICBmb3IgKGkgPSAwOyBzaWduYWxzW2ldLm1hc2sgOyArK2kpIAoJaWYgKHN0YXR1cyAmIHNpZ25hbHNbaV0ubWFzaykKCSAgICBwcmludGsoIiwlcyIsIHNpZ25hbHNbaV0ubmFtZSk7CiAgICBwcmludGsoIlxuQkFTUjogJTAyeCAiLCBiYXNyKTsKICAgIGZvciAoaSA9IDA7IGJhc3JzW2ldLm1hc2sgOyArK2kpIAoJaWYgKGJhc3IgJiBiYXNyc1tpXS5tYXNrKQoJICAgIHByaW50aygiLCVzIiwgYmFzcnNbaV0ubmFtZSk7CiAgICBwcmludGsoIlxuSUNSOiAlMDJ4ICIsIGljcik7CiAgICBmb3IgKGkgPSAwOyBpY3JzW2ldLm1hc2s7ICsraSkgCglpZiAoaWNyICYgaWNyc1tpXS5tYXNrKQoJICAgIHByaW50aygiLCVzIiwgaWNyc1tpXS5uYW1lKTsKICAgIHByaW50aygiXG5NT0RFOiAlMDJ4ICIsIG1yKTsKICAgIGZvciAoaSA9IDA7IG1yc1tpXS5tYXNrOyArK2kpIAoJaWYgKG1yICYgbXJzW2ldLm1hc2spCgkgICAgcHJpbnRrKCIsJXMiLCBtcnNbaV0ubmFtZSk7CiAgICBwcmludGsoIlxuIik7Cn0KCnN0YXRpYyBzdHJ1Y3QgewogICAgdW5zaWduZWQgY2hhciB2YWx1ZTsKICAgIGNvbnN0IGNoYXIgKm5hbWU7Cn0gcGhhc2VzW10gPSB7CiAgICB7UEhBU0VfREFUQU9VVCwgIkRBVEFPVVQifSwge1BIQVNFX0RBVEFJTiwgIkRBVEFJTiJ9LCB7UEhBU0VfQ01ET1VULCAiQ01ET1VUIn0sCiAgICB7UEhBU0VfU1RBVElOLCAiU1RBVElOIn0sIHtQSEFTRV9NU0dPVVQsICJNU0dPVVQifSwge1BIQVNFX01TR0lOLCAiTVNHSU4ifSwKICAgIHtQSEFTRV9VTktOT1dOLCAiVU5LTk9XTiJ9fTsKCi8qIAogKiBGdW5jdGlvbiA6IHZvaWQgTkNSNTM4MF9wcmludF9waGFzZShzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IHByaW50IHRoZSBjdXJyZW50IFNDU0kgcGhhc2UgZm9yIGRlYnVnZ2luZyBwdXJwb3NlcwogKgogKiBJbnB1dCA6IGluc3RhbmNlIC0gd2hpY2ggTkNSNTM4MAogKi8KCnN0YXRpYyB2b2lkIE5DUjUzODBfcHJpbnRfcGhhc2Uoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCnsKICAgIHVuc2lnbmVkIGNoYXIgc3RhdHVzOwogICAgaW50IGk7CgogICAgc3RhdHVzID0gTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpOwogICAgaWYgKCEoc3RhdHVzICYgU1JfUkVRKSkgCglwcmludGsoS0VSTl9ERUJVRyAic2NzaSVkOiBSRVEgbm90IGFzc2VydGVkLCBwaGFzZSB1bmtub3duLlxuIiwgSE9TVE5PKTsKICAgIGVsc2UgewoJZm9yIChpID0gMDsgKHBoYXNlc1tpXS52YWx1ZSAhPSBQSEFTRV9VTktOT1dOKSAmJiAKCSAgICAocGhhc2VzW2ldLnZhbHVlICE9IChzdGF0dXMgJiBQSEFTRV9NQVNLKSk7ICsraSk7IAoJcHJpbnRrKEtFUk5fREVCVUcgInNjc2klZDogcGhhc2UgJXNcbiIsIEhPU1ROTywgcGhhc2VzW2ldLm5hbWUpOwogICAgfQp9CgojZWxzZSAvKiAhTkRFQlVHICovCgovKiBkdW1taWVzLi4uICovCl9faW5saW5lX18gdm9pZCBOQ1I1MzgwX3ByaW50KHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKSB7IH07Cl9faW5saW5lX18gdm9pZCBOQ1I1MzgwX3ByaW50X3BoYXNlKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKSB7IH07CgojZW5kaWYKCi8qCiAqICsrcm9tYW46IE5ldyBzY2hlbWUgb2YgY2FsbGluZyBOQ1I1MzgwX21haW4oKQogKiAKICogSWYgd2UncmUgbm90IGluIGFuIGludGVycnVwdCwgd2UgY2FuIGNhbGwgb3VyIG1haW4gZGlyZWN0bHksIGl0IGNhbm5vdCBiZQogKiBhbHJlYWR5IHJ1bm5pbmcuIEVsc2UsIHdlIHF1ZXVlIGl0IG9uIGEgdGFzayBxdWV1ZSwgaWYgbm90ICdtYWluX3J1bm5pbmcnCiAqIHRlbGxzIHVzIHRoYXQgYSBsb3dlciBsZXZlbCBpcyBhbHJlYWR5IGV4ZWN1dGluZyBpdC4gVGhpcyB3YXksCiAqICdtYWluX3J1bm5pbmcnIG5lZWRzIG5vdCBiZSBwcm90ZWN0ZWQgaW4gYSBzcGVjaWFsIHdheS4KICoKICogcXVldWVfbWFpbigpIGlzIGEgdXRpbGl0eSBmdW5jdGlvbiBmb3IgcHV0dGluZyBvdXIgbWFpbiBvbnRvIHRoZSB0YXNrCiAqIHF1ZXVlLCBpZiBtYWluX3J1bm5pbmcgaXMgZmFsc2UuIEl0IHNob3VsZCBiZSBjYWxsZWQgb25seSBmcm9tIGEKICogaW50ZXJydXB0IG9yIGJvdHRvbSBoYWxmLgogKi8KCiNpbmNsdWRlIDxsaW51eC93b3JrcXVldWUuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgoKc3RhdGljIHZvbGF0aWxlIGludCBtYWluX3J1bm5pbmcgPSAwOwpzdGF0aWMgREVDTEFSRV9XT1JLKE5DUjUzODBfdHF1ZXVlLCAodm9pZCAoKikodm9pZCopKU5DUjUzODBfbWFpbiwgTlVMTCk7CgpzdGF0aWMgX19pbmxpbmVfXyB2b2lkIHF1ZXVlX21haW4odm9pZCkKewogICAgaWYgKCFtYWluX3J1bm5pbmcpIHsKCS8qIElmIGluIGludGVycnVwdCBhbmQgTkNSNTM4MF9tYWluKCkgbm90IGFscmVhZHkgcnVubmluZywKCSAgIHF1ZXVlIGl0IG9uIHRoZSAnaW1tZWRpYXRlJyB0YXNrIHF1ZXVlLCB0byBiZSBwcm9jZXNzZWQKCSAgIGltbWVkaWF0ZWx5IGFmdGVyIHRoZSBjdXJyZW50IGludGVycnVwdCBwcm9jZXNzaW5nIGhhcwoJICAgZmluaXNoZWQuICovCglzY2hlZHVsZV93b3JrKCZOQ1I1MzgwX3RxdWV1ZSk7CiAgICB9CiAgICAvKiBlbHNlOiBub3RoaW5nIHRvIGRvOiB0aGUgcnVubmluZyBOQ1I1MzgwX21haW4oKSB3aWxsIHBpY2sgdXAKICAgICAgIGFueSBuZXdseSBxdWV1ZWQgY29tbWFuZC4gKi8KfQoKCnN0YXRpYyBpbmxpbmUgdm9pZCBOQ1I1MzgwX2FsbF9pbml0ICh2b2lkKQp7CiAgICBzdGF0aWMgaW50IGRvbmUgPSAwOwogICAgaWYgKCFkb25lKSB7CglJTklfUFJJTlRLKCJzY3NpIDogTkNSNTM4MF9hbGxfaW5pdCgpXG4iKTsKCWRvbmUgPSAxOwogICAgfQp9CgogCi8qCiAqIEZ1bmN0aW9uIDogdm9pZCBOQ1I1ODM4MF9wcmludF9vcHRpb25zIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IGNhbGxlZCBieSBwcm9iZSBjb2RlIGluZGljYXRpbmcgdGhlIE5DUjUzODAgZHJpdmVyCiAqCSAgICAgb3B0aW9ucyB0aGF0IHdlcmUgc2VsZWN0ZWQuCiAqCiAqIElucHV0cyA6IGluc3RhbmNlLCBwb2ludGVyIHRvIHRoaXMgaW5zdGFuY2UuICBVbnVzZWQuCiAqLwoKc3RhdGljIHZvaWQgX19pbml0IE5DUjUzODBfcHJpbnRfb3B0aW9ucyAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCnsKICAgIHByaW50aygiIGdlbmVyaWMgb3B0aW9ucyIKI2lmZGVmIEFVVE9TRU5TRSAKICAgICIgQVVUT1NFTlNFIgojZW5kaWYKI2lmZGVmIFJFQUxfRE1BCiAgICAiIFJFQUwgRE1BIgojZW5kaWYKI2lmZGVmIFBBUklUWQogICAgIiBQQVJJVFkiCiNlbmRpZgojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICAiIFNDU0ktMiBUQUdHRUQgUVVFVUlORyIKI2VuZGlmCiAgICApOwogICAgcHJpbnRrKCIgZ2VuZXJpYyByZWxlYXNlPSVkIiwgTkNSNTM4MF9QVUJMSUNfUkVMRUFTRSk7Cn0KCi8qCiAqIEZ1bmN0aW9uIDogdm9pZCBOQ1I1MzgwX3ByaW50X3N0YXR1cyAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCiAqCiAqIFB1cnBvc2UgOiBwcmludCBjb21tYW5kcyBpbiB0aGUgdmFyaW91cyBxdWV1ZXMsIGNhbGxlZCBmcm9tCiAqCU5DUjUzODBfYWJvcnQgYW5kIE5DUjUzODBfZGVidWcgdG8gYWlkIGRlYnVnZ2luZy4KICoKICogSW5wdXRzIDogaW5zdGFuY2UsIHBvaW50ZXIgdG8gdGhpcyBpbnN0YW5jZS4gIAogKi8KCnN0YXRpYyB2b2lkIE5DUjUzODBfcHJpbnRfc3RhdHVzIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKewogICAgY2hhciAqcHJfYmZyOwogICAgY2hhciAqc3RhcnQ7CiAgICBpbnQgbGVuOwoKICAgIE5DUl9QUklOVChOREVCVUdfQU5ZKTsKICAgIE5DUl9QUklOVF9QSEFTRShOREVCVUdfQU5ZKTsKCiAgICBwcl9iZnIgPSAoY2hhciAqKSBfX2dldF9mcmVlX3BhZ2UoR0ZQX0FUT01JQyk7CiAgICBpZiAoIXByX2JmcikgewoJcHJpbnRrKCJOQ1I1MzgwX3ByaW50X3N0YXR1czogbm8gbWVtb3J5IGZvciBwcmludCBidWZmZXJcbiIpOwoJcmV0dXJuOwogICAgfQogICAgbGVuID0gTkNSNTM4MF9wcm9jX2luZm8ocHJfYmZyLCAmc3RhcnQsIDAsIFBBR0VfU0laRSwgSE9TVE5PLCAwKTsKICAgIHByX2JmcltsZW5dID0gMDsKICAgIHByaW50aygiXG4lc1xuIiwgcHJfYmZyKTsKICAgIGZyZWVfcGFnZSgodW5zaWduZWQgbG9uZykgcHJfYmZyKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi8qCiAqIC9wcm9jL3Njc2kvW2R0YyBwYXMxNiB0MTI4IGdlbmVyaWNdL1swLUFTQ19OVU1fQk9BUkRfU1VQUE9SVEVEXQogKgogKiAqYnVmZmVyOiBJL08gYnVmZmVyCiAqICoqc3RhcnQ6IGlmIGlub3V0ID09IEZBTFNFIHBvaW50ZXIgaW50byBidWZmZXIgd2hlcmUgdXNlciByZWFkIHNob3VsZCBzdGFydAogKiBvZmZzZXQ6IGN1cnJlbnQgb2Zmc2V0CiAqIGxlbmd0aDogbGVuZ3RoIG9mIGJ1ZmZlcgogKiBob3N0bm86IFNjc2lfSG9zdCBob3N0X25vCiAqIGlub3V0OiBUUlVFIC0gdXNlciBpcyB3cml0aW5nOyBGQUxTRSAtIHVzZXIgaXMgcmVhZGluZwogKgogKiBSZXR1cm4gdGhlIG51bWJlciBvZiBieXRlcyByZWFkIGZyb20gb3Igd3JpdHRlbgoqLwoKI3VuZGVmIFNQUklOVEYKI2RlZmluZSBTUFJJTlRGKGZtdCxhcmdzLi4uKSBcCiAgZG8geyBpZiAocG9zICsgc3RybGVuKGZtdCkgKyAyMCAvKiBzbG9wICovIDwgYnVmZmVyICsgbGVuZ3RoKSBcCgkgcG9zICs9IHNwcmludGYocG9zLCBmbXQgLCAjIyBhcmdzKTsgfSB3aGlsZSgwKQpzdGF0aWMKY2hhciAqbHByaW50X1Njc2lfQ21uZCAoU2NzaV9DbW5kICpjbWQsIGNoYXIgKnBvcywgY2hhciAqYnVmZmVyLCBpbnQgbGVuZ3RoKTsKCnN0YXRpYwppbnQgTkNSNTM4MF9wcm9jX2luZm8gKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlLCBjaGFyICpidWZmZXIsIGNoYXIgKipzdGFydCwgb2ZmX3Qgb2Zmc2V0LAoJCSAgICAgICBpbnQgbGVuZ3RoLCBpbnQgaW5vdXQpCnsKICAgIGNoYXIgKnBvcyA9IGJ1ZmZlcjsKICAgIHN0cnVjdCBOQ1I1MzgwX2hvc3RkYXRhICpob3N0ZGF0YTsKICAgIFNjc2lfQ21uZCAqcHRyOwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKICAgIG9mZl90IGJlZ2luID0gMDsKI2RlZmluZSBjaGVja19vZmZzZXQoKQkJCQlcCiAgICBkbyB7CQkJCQlcCglpZiAocG9zIC0gYnVmZmVyIDwgb2Zmc2V0IC0gYmVnaW4pIHsJXAoJICAgIGJlZ2luICs9IHBvcyAtIGJ1ZmZlcjsJCVwKCSAgICBwb3MgPSBidWZmZXI7CQkJXAoJfQkJCQkJXAogICAgfSB3aGlsZSAoMCkKCiAgICBob3N0ZGF0YSA9IChzdHJ1Y3QgTkNSNTM4MF9ob3N0ZGF0YSAqKWluc3RhbmNlLT5ob3N0ZGF0YTsKCiAgICBpZiAoaW5vdXQpIHsgLyogSGFzIGRhdGEgYmVlbiB3cml0dGVuIHRvIHRoZSBmaWxlID8gKi8KCXJldHVybigtRU5PU1lTKTsgIC8qIEN1cnJlbnRseSB0aGlzIGlzIGEgbm8tb3AgKi8KICAgIH0KICAgIFNQUklOVEYoIk5DUjUzODAgY29yZSByZWxlYXNlPSVkLlxuIiwgTkNSNTM4MF9QVUJMSUNfUkVMRUFTRSk7CiAgICBjaGVja19vZmZzZXQoKTsKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIFNQUklOVEYoIk5DUjUzODA6IGNvcm91dGluZSBpcyVzIHJ1bm5pbmcuXG4iLCBtYWluX3J1bm5pbmcgPyAiIiA6ICJuJ3QiKTsKICAgIGNoZWNrX29mZnNldCgpOwogICAgaWYgKCFob3N0ZGF0YS0+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+aWRfbWFzayk7CgkJICAgIGJyZWFrOwoJCWNhc2UgRVhURU5ERURfTUVTU0FHRToKLyogCiAqIEV4dGVuZGVkIG1lc3NhZ2VzIGFyZSBzZW50IGluIHRoZSBmb2xsb3dpbmcgZm9ybWF0IDoKICogQnl0ZSAJCiAqIDAJCUVYVEVOREVEX01FU1NBR0UgPT0gMQogKiAxCQlsZW5ndGggKGluY2x1ZGVzIG9uZSBieXRlIGZvciBjb2RlLCBkb2Vzbid0IAogKgkJaW5jbHVkZSBmaXJzdCB0d28gYnl0ZXMpCiAqIDIgCQljb2RlCiAqIDMuLmxlbmd0aCsxCWFyZ3VtZW50cwogKgogKiBTdGFydCB0aGUgZXh0ZW5kZWQgbWVzc2FnZSBidWZmZXIgd2l0aCB0aGUgRVhURU5ERURfTUVTU0FHRQogKiBieXRlLCBzaW5jZSBzcGlfcHJpbnRfbXNnKCkgd2FudHMgdGhlIHdob2xlIHRoaW5nLiAgCiAqLwoJCSAgICBleHRlbmRlZF9tc2dbMF0gPSBFWFRFTkRFRF9NRVNTQUdFOwoJCSAgICAvKiBBY2NlcHQgZmlyc3QgYnl0ZSBieSBjbGVhcmluZyBBQ0sgKi8KCQkgICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCgkJICAgIEVYVF9QUklOVEsoInNjc2klZDogcmVjZWl2aW5nIGV4dGVuZGVkIG1lc3NhZ2VcbiIsIEhPU1ROTyk7CgoJCSAgICBsZW4gPSAyOwoJCSAgICBkYXRhID0gZXh0ZW5kZWRfbXNnICsgMTsKCQkgICAgcGhhc2UgPSBQSEFTRV9NU0dJTjsKCQkgICAgTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpOwoJCSAgICBFWFRfUFJJTlRLKCJzY3NpJWQ6IGxlbmd0aD0lZCwgY29kZT0weCUwMnhcbiIsIEhPU1ROTywKCQkJICAgICAgIChpbnQpZXh0ZW5kZWRfbXNnWzFdLCAoaW50KWV4dGVuZGVkX21zZ1syXSk7CgoJCSAgICBpZiAoIWxlbiAmJiBleHRlbmRlZF9tc2dbMV0gPD0gCgkJCShzaXplb2YgKGV4dGVuZGVkX21zZykgLSAxKSkgewoJCQkvKiBBY2NlcHQgdGhpcmQgYnl0ZSBieSBjbGVhcmluZyBBQ0sgKi8KCQkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCQkJbGVuID0gZXh0ZW5kZWRfbXNnWzFdIC0gMTsKCQkJZGF0YSA9IGV4dGVuZGVkX21zZyArIDM7CgkJCXBoYXNlID0gUEhBU0VfTVNHSU47CgoJCQlOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAmZGF0YSk7CgkJCUVYVF9QUklOVEsoInNjc2klZDogbWVzc2FnZSByZWNlaXZlZCwgcmVzaWR1YWwgJWRcbiIsCgkJCQkgICBIT1NUTk8sIGxlbik7CgoJCQlzd2l0Y2ggKGV4dGVuZGVkX21zZ1syXSkgewoJCQljYXNlIEVYVEVOREVEX1NEVFI6CgkJCWNhc2UgRVhURU5ERURfV0RUUjoKCQkJY2FzZSBFWFRFTkRFRF9NT0RJRllfREFUQV9QT0lOVEVSOgoJCQljYXNlIEVYVEVOREVEX0VYVEVOREVEX0lERU5USUZZOgoJCQkgICAgdG1wID0gMDsKCQkJfQoJCSAgICB9IGVsc2UgaWYgKGxlbikgewoJCQlwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogZXJyb3IgcmVjZWl2aW5nICIKCQkJICAgICAgICJleHRlbmRlZCBtZXNzYWdlXG4iLCBIT1NUTk8pOwoJCQl0bXAgPSAwOwoJCSAgICB9IGVsc2UgewoJCQlwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogZXh0ZW5kZWQgbWVzc2FnZSAiCgkJCSAgICAgICAiY29kZSAlMDJ4IGxlbmd0aCAlZCBpcyB0b28gbG9uZ1xuIiwKCQkJICAgICAgIEhPU1ROTywgZXh0ZW5kZWRfbXNnWzJdLCBleHRlbmRlZF9tc2dbMV0pOwoJCQl0bXAgPSAwOwoJCSAgICB9CgkJLyogRmFsbCB0aHJvdWdoIHRvIHJlamVjdCBtZXNzYWdlICovCgoJCS8qIAogIAkJICogSWYgd2UgZ2V0IHNvbWV0aGluZyB3ZWlyZCB0aGF0IHdlIGFyZW4ndCBleHBlY3RpbmcsIAogCQkgKiByZWplY3QgaXQuCgkJICovCgkJZGVmYXVsdDoKCQkgICAgaWYgKCF0bXApIHsKCQkJcHJpbnRrKEtFUk5fREVCVUcgInNjc2klZDogcmVqZWN0aW5nIG1lc3NhZ2UgIiwgSE9TVE5PKTsKCQkJc3BpX3ByaW50X21zZyhleHRlbmRlZF9tc2cpOwoJCQlwcmludGsoIlxuIik7CgkJICAgIH0gZWxzZSBpZiAodG1wICE9IEVYVEVOREVEX01FU1NBR0UpCgkJCXByaW50ayhLRVJOX0RFQlVHICJzY3NpJWQ6IHJlamVjdGluZyB1bmtub3duICIKCQkJICAgICAgICJtZXNzYWdlICUwMnggZnJvbSB0YXJnZXQgJWQsIGx1biAlZFxuIiwKCQkJICAgICAgIEhPU1ROTywgdG1wLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwoJCSAgICBlbHNlCgkJCXByaW50ayhLRVJOX0RFQlVHICJzY3NpJWQ6IHJlamVjdGluZyB1bmtub3duICIKCQkJICAgICAgICJleHRlbmRlZCBtZXNzYWdlICIKCQkJICAgICAgICJjb2RlICUwMngsIGxlbmd0aCAlZCBmcm9tIHRhcmdldCAlZCwgbHVuICVkXG4iLAoJCQkgICAgICAgSE9TVE5PLCBleHRlbmRlZF9tc2dbMV0sIGV4dGVuZGVkX21zZ1swXSwKCQkJICAgICAgIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1bik7CiAgIAoKCQkgICAgbXNnb3V0ID0gTUVTU0FHRV9SRUpFQ1Q7CgkJICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IAoJCQlJQ1JfQVNTRVJUX0FUTik7CgkJICAgIGJyZWFrOwoJCX0gLyogc3dpdGNoICh0bXApICovCgkJYnJlYWs7CgkgICAgY2FzZSBQSEFTRV9NU0dPVVQ6CgkJbGVuID0gMTsKCQlkYXRhID0gJm1zZ291dDsKCQlob3N0ZGF0YS0+bGFzdF9tZXNzYWdlID0gbXNnb3V0OwoJCU5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sICZkYXRhKTsKCQlpZiAobXNnb3V0ID09IEFCT1JUKSB7CiNpZmRlZiBTVVBQT1JUX1RBR1MKCQkgICAgY21kX2ZyZWVfdGFnKCBjbWQgKTsKI2Vsc2UKCQkgICAgaG9zdGRhdGEtPmJ1c3lbY21kLT5kZXZpY2UtPmlkXSAmPSB+KDEgPDwgY21kLT5kZXZpY2UtPmx1bik7CiNlbmRpZgoJCSAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gTlVMTDsKCQkgICAgY21kLT5yZXN1bHQgPSBESURfRVJST1IgPDwgMTY7CiNpZmRlZiBOQ1I1MzgwX1NUQVRTCgkJICAgIGNvbGxlY3Rfc3RhdHMoaG9zdGRhdGEsIGNtZCk7CiNlbmRpZgoJCSAgICBjbWQtPnNjc2lfZG9uZShjbWQpOwoJCSAgICBOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CgkJICAgIGZhbGNvbl9yZWxlYXNlX2xvY2tfaWZfcG9zc2libGUoIGhvc3RkYXRhICk7CgkJICAgIHJldHVybjsKCQl9CgkJbXNnb3V0ID0gTk9QOwoJCWJyZWFrOwoJICAgIGNhc2UgUEhBU0VfQ01ET1VUOgoJCWxlbiA9IGNtZC0+Y21kX2xlbjsKCQlkYXRhID0gY21kLT5jbW5kOwoJCS8qIAoJCSAqIFhYWCBmb3IgcGVyZm9ybWFuY2UgcmVhc29ucywgb24gbWFjaGluZXMgd2l0aCBhIAoJCSAqIFBTRVVETy1ETUEgYXJjaGl0ZWN0dXJlIHdlIHNob3VsZCBwcm9iYWJseSAKCQkgKiB1c2UgdGhlIGRtYSB0cmFuc2ZlciBmdW5jdGlvbi4gIAoJCSAqLwoJCU5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sIAoJCSAgICAmZGF0YSk7CgkJYnJlYWs7CgkgICAgY2FzZSBQSEFTRV9TVEFUSU46CgkJbGVuID0gMTsKCQlkYXRhID0gJnRtcDsKCQlOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAmZGF0YSk7CgkJY21kLT5TQ3AuU3RhdHVzID0gdG1wOwoJCWJyZWFrOwoJICAgIGRlZmF1bHQ6CgkJcHJpbnRrKCJzY3NpJWQ6IHVua25vd24gcGhhc2VcbiIsIEhPU1ROTyk7CgkJTkNSX1BSSU5UKE5ERUJVR19BTlkpOwoJICAgIH0gLyogc3dpdGNoKHBoYXNlKSAqLwoJfSAvKiBpZiAodG1wICogU1JfUkVRKSAqLyAKICAgIH0gLyogd2hpbGUgKDEpICovCn0KCi8qCiAqIEZ1bmN0aW9uIDogdm9pZCBOQ1I1MzgwX3Jlc2VsZWN0IChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IGRvZXMgcmVzZWxlY3Rpb24sIGluaXRpYWxpemluZyB0aGUgaW5zdGFuY2UtPmNvbm5lY3RlZCAKICoJZmllbGQgdG8gcG9pbnQgdG8gdGhlIFNjc2lfQ21uZCBmb3Igd2hpY2ggdGhlIElfVF9MIG9yIElfVF9MX1EgCiAqCW5leHVzIGhhcyBiZWVuIHJlZXN0YWJsaXNoZWQsCiAqCQogKiBJbnB1dHMgOiBpbnN0YW5jZSAtIHRoaXMgaW5zdGFuY2Ugb2YgdGhlIE5DUjUzODAuCiAqCiAqLwoKCnN0YXRpYyB2b2lkIE5DUjUzODBfcmVzZWxlY3QgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQp7CiAgICBTRVRVUF9IT1NUREFUQShpbnN0YW5jZSk7CiAgICB1bnNpZ25lZCBjaGFyIHRhcmdldF9tYXNrOwogICAgdW5zaWduZWQgY2hhciBsdW4sIHBoYXNlOwogICAgaW50IGxlbjsKI2lmZGVmIFNVUFBPUlRfVEFHUwogICAgdW5zaWduZWQgY2hhciB0YWc7CiNlbmRpZgogICAgdW5zaWduZWQgY2hhciBtc2dbM107CiAgICB1bnNpZ25lZCBjaGFyICpkYXRhOwogICAgU2NzaV9DbW5kICp0bXAgPSBOVUxMLCAqcHJldjsKLyogICAgdW5zaWduZWQgbG9uZyBmbGFnczsgKi8KCiAgICAvKgogICAgICogRGlzYWJsZSBhcmJpdHJhdGlvbiwgZXRjLiBzaW5jZSB0aGUgaG9zdCBhZGFwdGVyIG9idmlvdXNseQogICAgICogbG9zdCwgYW5kIHRlbGwgYW4gaW50ZXJydXB0ZWQgTkNSNTM4MF9zZWxlY3QoKSB0byByZXN0YXJ0LgogICAgICovCgogICAgTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7CiAgICBob3N0ZGF0YS0+cmVzdGFydF9zZWxlY3QgPSAxOwoKICAgIHRhcmdldF9tYXNrID0gTkNSNTM4MF9yZWFkKENVUlJFTlRfU0NTSV9EQVRBX1JFRykgJiB+KGhvc3RkYXRhLT5pZF9tYXNrKTsKCiAgICBSU0xfUFJJTlRLKCJzY3NpJWQ6IHJlc2VsZWN0XG4iLCBIT1NUTk8pOwoKICAgIC8qIAogICAgICogQXQgdGhpcyBwb2ludCwgd2UgaGF2ZSBkZXRlY3RlZCB0aGF0IG91ciBTQ1NJIElEIGlzIG9uIHRoZSBidXMsCiAgICAgKiBTRUwgaXMgdHJ1ZSBhbmQgQlNZIHdhcyBmYWxzZSBmb3IgYXQgbGVhc3Qgb25lIGJ1cyBzZXR0bGUgZGVsYXkKICAgICAqICg0MDAgbnMpLgogICAgICoKICAgICAqIFdlIG11c3QgYXNzZXJ0IEJTWSBvdXJzZWx2ZXMsIHVudGlsIHRoZSB0YXJnZXQgZHJvcHMgdGhlIFNFTAogICAgICogc2lnbmFsLgogICAgICovCgogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9CU1kpOwogICAgCiAgICB3aGlsZSAoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfU0VMKTsKICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CgogICAgLyoKICAgICAqIFdhaXQgZm9yIHRhcmdldCB0byBnbyBpbnRvIE1TR0lOLgogICAgICovCgogICAgd2hpbGUgKCEoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfUkVRKSk7CgogICAgbGVuID0gMTsKICAgIGRhdGEgPSBtc2c7CiAgICBwaGFzZSA9IFBIQVNFX01TR0lOOwogICAgTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpOwoKICAgIGlmICghKG1zZ1swXSAmIDB4ODApKSB7CglwcmludGsoS0VSTl9ERUJVRyAic2NzaSVkOiBleHBlY3RpbmcgSURFTlRJRlkgbWVzc2FnZSwgZ290ICIsIEhPU1ROTyk7CglzcGlfcHJpbnRfbXNnKG1zZyk7Cglkb19hYm9ydChpbnN0YW5jZSk7CglyZXR1cm47CiAgICB9CiAgICBsdW4gPSAobXNnWzBdICYgMHgwNyk7CgojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICAvKiBJZiB0aGUgcGhhc2UgaXMgc3RpbGwgTVNHSU4sIHRoZSB0YXJnZXQgd2FudHMgdG8gc2VuZCBzb21lIG1vcmUKICAgICAqIG1lc3NhZ2VzLiBJbiBjYXNlIGl0IHN1cHBvcnRzIHRhZ2dlZCBxdWV1aW5nLCB0aGlzIGlzIHByb2JhYmx5IGEKICAgICAqIFNJTVBMRV9RVUVVRV9UQUcgZm9yIHRoZSBJX1RfTF9RIG5leHVzLgogICAgICovCiAgICB0YWcgPSBUQUdfTk9ORTsKICAgIGlmIChwaGFzZSA9PSBQSEFTRV9NU0dJTiAmJiBzZXR1cF91c2VfdGFnZ2VkX3F1ZXVpbmcpIHsKCS8qIEFjY2VwdCBwcmV2aW91cyBJREVOVElGWSBtZXNzYWdlIGJ5IGNsZWFyaW5nIEFDSyAqLwoJTkNSNTM4MF93cml0ZSggSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSApOwoJbGVuID0gMjsKCWRhdGEgPSBtc2crMTsKCWlmICghTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpICYmCgkgICAgbXNnWzFdID09IFNJTVBMRV9RVUVVRV9UQUcpCgkgICAgdGFnID0gbXNnWzJdOwoJVEFHX1BSSU5USygic2NzaSVkOiB0YXJnZXQgbWFzayAlMDJ4LCBsdW4gJWQgc2VudCB0YWcgJWQgYXQgIgoJCSAgICJyZXNlbGVjdGlvblxuIiwgSE9TVE5PLCB0YXJnZXRfbWFzaywgbHVuLCB0YWcpOwogICAgfQojZW5kaWYKICAgIAogICAgLyogCiAgICAgKiBGaW5kIHRoZSBjb21tYW5kIGNvcnJlc3BvbmRpbmcgdG8gdGhlIElfVF9MIG9yIElfVF9MX1EgIG5leHVzIHdlIAogICAgICoganVzdCByZWVzdGFibGlzaGVkLCBhbmQgcmVtb3ZlIGl0IGZyb20gdGhlIGRpc2Nvbm5lY3RlZCBxdWV1ZS4KICAgICAqLwoKICAgIGZvciAodG1wID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlLCBwcmV2ID0gTlVMTDsgCgkgdG1wOyBwcmV2ID0gdG1wLCB0bXAgPSBORVhUKHRtcCkgKSB7CglpZiAoKHRhcmdldF9tYXNrID09ICgxIDw8IHRtcC0+ZGV2aWNlLT5pZCkpICYmIChsdW4gPT0gdG1wLT5kZXZpY2UtPmx1bikKI2lmZGVmIFNVUFBPUlRfVEFHUwoJICAgICYmICh0YWcgPT0gdG1wLT50YWcpIAojZW5kaWYKCSAgICApIHsKCSAgICAvKiArK2d1ZW50aGVyOiBwcmV2ZW50IHJhY2Ugd2l0aCBmYWxjb25fcmVsZWFzZV9sb2NrICovCgkgICAgZmFsY29uX2RvbnRfcmVsZWFzZSsrOwoJICAgIGlmIChwcmV2KSB7CgkJUkVNT1ZFKHByZXYsIE5FWFQocHJldiksIHRtcCwgTkVYVCh0bXApKTsKCQlORVhUKHByZXYpID0gTkVYVCh0bXApOwoJICAgIH0gZWxzZSB7CgkJUkVNT1ZFKC0xLCBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlLCB0bXAsIE5FWFQodG1wKSk7CgkJaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSA9IE5FWFQodG1wKTsKCSAgICB9CgkgICAgTkVYVCh0bXApID0gTlVMTDsKCSAgICBicmVhazsKCX0KICAgIH0KICAgIAogICAgaWYgKCF0bXApIHsKCXByaW50ayhLRVJOX1dBUk5JTkcgInNjc2klZDogd2FybmluZzogdGFyZ2V0IGJpdG1hc2sgJTAyeCBsdW4gJWQgIgojaWZkZWYgU1VQUE9SVF9UQUdTCgkJInRhZyAlZCAiCiNlbmRpZgoJCSJub3QgaW4gZGlzY29ubmVjdGVkX3F1ZXVlLlxuIiwKCQlIT1NUTk8sIHRhcmdldF9tYXNrLCBsdW4KI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSwgdGFnCiNlbmRpZgoJCSk7CgkvKiAKCSAqIFNpbmNlIHdlIGhhdmUgYW4gZXN0YWJsaXNoZWQgbmV4dXMgdGhhdCB3ZSBjYW4ndCBkbyBhbnl0aGluZwoJICogd2l0aCwgd2UgbXVzdCBhYm9ydCBpdC4gIAoJICovCglkb19hYm9ydChpbnN0YW5jZSk7CglyZXR1cm47CiAgICB9CgogICAgLyogQWNjZXB0IG1lc3NhZ2UgYnkgY2xlYXJpbmcgQUNLICovCiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoKICAgIGhvc3RkYXRhLT5jb25uZWN0ZWQgPSB0bXA7CiAgICBSU0xfUFJJTlRLKCJzY3NpJWQ6IG5leHVzIGVzdGFibGlzaGVkLCB0YXJnZXQgPSAlZCwgbHVuID0gJWQsIHRhZyA9ICVkXG4iLAoJICAgICAgIEhPU1ROTywgdG1wLT5kZXZpY2UtPmlkLCB0bXAtPmRldmljZS0+bHVuLCB0bXAtPnRhZyk7CiAgICBmYWxjb25fZG9udF9yZWxlYXNlLS07Cn0KCgovKgogKiBGdW5jdGlvbiA6IGludCBOQ1I1MzgwX2Fib3J0IChTY3NpX0NtbmQgKmNtZCkKICoKICogUHVycG9zZSA6IGFib3J0IGEgY29tbWFuZAogKgogKiBJbnB1dHMgOiBjbWQgLSB0aGUgU2NzaV9DbW5kIHRvIGFib3J0LCBjb2RlIC0gY29kZSB0byBzZXQgdGhlIAogKiAJaG9zdCBieXRlIG9mIHRoZSByZXN1bHQgZmllbGQgdG8sIGlmIHplcm8gRElEX0FCT1JURUQgaXMgCiAqCXVzZWQuCiAqCiAqIFJldHVybnMgOiAwIC0gc3VjY2VzcywgLTEgb24gZmFpbHVyZS4KICoKICogWFhYIC0gdGhlcmUgaXMgbm8gd2F5IHRvIGFib3J0IHRoZSBjb21tYW5kIHRoYXQgaXMgY3VycmVudGx5IAogKiAJIGNvbm5lY3RlZCwgeW91IGhhdmUgdG8gd2FpdCBmb3IgaXQgdG8gY29tcGxldGUuICBJZiB0aGlzIGlzIAogKgkgYSBwcm9ibGVtLCB3ZSBjb3VsZCBpbXBsZW1lbnQgbG9uZ2ptcCgpIC8gc2V0am1wKCksIHNldGptcCgpCiAqIAkgY2FsbGVkIHdoZXJlIHRoZSBsb29wIHN0YXJ0ZWQgaW4gTkNSNTM4MF9tYWluKCkuCiAqLwoKc3RhdGljCmludCBOQ1I1MzgwX2Fib3J0IChTY3NpX0NtbmQgKmNtZCkKewogICAgc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UgPSBjbWQtPmRldmljZS0+aG9zdDsKICAgIFNFVFVQX0hPU1REQVRBKGluc3RhbmNlKTsKICAgIFNjc2lfQ21uZCAqdG1wLCAqKnByZXY7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwoKICAgIHByaW50ayhLRVJOX05PVElDRSAic2NzaSVkOiBhYm9ydGluZyBjb21tYW5kXG4iLCBIT1NUTk8pOwogICAgc2NzaV9wcmludF9jb21tYW5kKGNtZCk7CgogICAgTkNSNTM4MF9wcmludF9zdGF0dXMgKGluc3RhbmNlKTsKCiAgICBsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAgICAKICAgIGlmICghSVNfQV9UVCgpICYmICFmYWxjb25fZ290X2xvY2spCglwcmludGsoS0VSTl9FUlIgInNjc2klZDogISFCSU5HTyEhIEZhbGNvbiBoYXMgbm8gbG9jayBpbiBOQ1I1MzgwX2Fib3J0XG4iLAoJICAgICAgIEhPU1ROTyk7CgogICAgQUJSVF9QUklOVEsoInNjc2klZDogYWJvcnQgY2FsbGVkIGJhc3IgMHglMDJ4LCBzciAweCUwMnhcbiIsIEhPU1ROTywKCQlOQ1I1MzgwX3JlYWQoQlVTX0FORF9TVEFUVVNfUkVHKSwKCQlOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykpOwoKI2lmIDEKLyogCiAqIENhc2UgMSA6IElmIHRoZSBjb21tYW5kIGlzIHRoZSBjdXJyZW50bHkgZXhlY3V0aW5nIGNvbW1hbmQsIAogKiB3ZSdsbCBzZXQgdGhlIGFib3J0ZWQgZmxhZyBhbmQgcmV0dXJuIGNvbnRyb2wgc28gdGhhdCAKICogaW5mb3JtYXRpb24gdHJhbnNmZXIgcm91dGluZSBjYW4gZXhpdCBjbGVhbmx5LgogKi8KCiAgICBpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCA9PSBjbWQpIHsKCglBQlJUX1BSSU5USygic2NzaSVkOiBhYm9ydGluZyBjb25uZWN0ZWQgY29tbWFuZFxuIiwgSE9TVE5PKTsKLyoKICogV2Ugc2hvdWxkIHBlcmZvcm0gQlNZIGNoZWNraW5nLCBhbmQgbWFrZSBzdXJlIHdlIGhhdmVuJ3Qgc2xpcHBlZAogKiBpbnRvIEJVUyBGUkVFLgogKi8KCi8qCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQVNTRVJUX0FUTik7ICovCi8qIAogKiBTaW5jZSB3ZSBjYW4ndCBjaGFuZ2UgcGhhc2VzIHVudGlsIHdlJ3ZlIGNvbXBsZXRlZCB0aGUgY3VycmVudCAKICogaGFuZHNoYWtlLCB3ZSBoYXZlIHRvIHNvdXJjZSBvciBzaW5rIGEgYnl0ZSBvZiBkYXRhIGlmIHRoZSBjdXJyZW50CiAqIHBoYXNlIGlzIG5vdCBNU0dPVVQuCiAqLwoKLyogCiAqIFJldHVybiBjb250cm9sIHRvIHRoZSBleGVjdXRpbmcgTkNSIGRyaXZlIHNvIHdlIGNhbiBjbGVhciB0aGUKICogYWJvcnRlZCBmbGFnIGFuZCBnZXQgYmFjayBpbnRvIG91ciBtYWluIGxvb3AuCiAqLyAKCglpZiAoZG9fYWJvcnQoaW5zdGFuY2UpID09IDApIHsKCSAgaG9zdGRhdGEtPmFib3J0ZWQgPSAxOwoJICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gTlVMTDsKCSAgY21kLT5yZXN1bHQgPSBESURfQUJPUlQgPDwgMTY7CiNpZmRlZiBTVVBQT1JUX1RBR1MKCSAgY21kX2ZyZWVfdGFnKCBjbWQgKTsKI2Vsc2UKCSAgaG9zdGRhdGEtPmJ1c3lbY21kLT5kZXZpY2UtPmlkXSAmPSB+KDEgPDwgY21kLT5kZXZpY2UtPmx1bik7CiNlbmRpZgoJICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkgIGNtZC0+c2NzaV9kb25lKGNtZCk7CgkgIGZhbGNvbl9yZWxlYXNlX2xvY2tfaWZfcG9zc2libGUoIGhvc3RkYXRhICk7CgkgIHJldHVybiBTQ1NJX0FCT1JUX1NVQ0NFU1M7Cgl9IGVsc2UgewovKgkgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsgKi8KCSAgcHJpbnRrKCJzY3NpJWQ6IGFib3J0IG9mIGNvbm5lY3RlZCBjb21tYW5kIGZhaWxlZCFcbiIsIEhPU1ROTyk7CgkgIHJldHVybiBTQ1NJX0FCT1JUX0VSUk9SOwoJfSAKICAgfQojZW5kaWYKCi8qIAogKiBDYXNlIDIgOiBJZiB0aGUgY29tbWFuZCBoYXNuJ3QgYmVlbiBpc3N1ZWQgeWV0LCB3ZSBzaW1wbHkgcmVtb3ZlIGl0IAogKiAJICAgIGZyb20gdGhlIGlzc3VlIHF1ZXVlLgogKi8KICAgIGZvciAocHJldiA9IChTY3NpX0NtbmQgKiopICYoaG9zdGRhdGEtPmlzc3VlX3F1ZXVlKSwgCgl0bXAgPSAoU2NzaV9DbW5kICopIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZTsKCXRtcDsgcHJldiA9IE5FWFRBRERSKHRtcCksIHRtcCA9IE5FWFQodG1wKSApCglpZiAoY21kID09IHRtcCkgewoJICAgIFJFTU9WRSg1LCAqcHJldiwgdG1wLCBORVhUKHRtcCkpOwoJICAgICgqcHJldikgPSBORVhUKHRtcCk7CgkgICAgTkVYVCh0bXApID0gTlVMTDsKCSAgICB0bXAtPnJlc3VsdCA9IERJRF9BQk9SVCA8PCAxNjsKCSAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkgICAgQUJSVF9QUklOVEsoInNjc2klZDogYWJvcnQgcmVtb3ZlZCBjb21tYW5kIGZyb20gaXNzdWUgcXVldWUuXG4iLAoJCQlIT1NUTk8pOwoJICAgIC8qIFRhZ2dlZCBxdWV1aW5nIG5vdGU6IG5vIHRhZyB0byBmcmVlIGhlcmUsIGhhc24ndCBiZWVuIGFzc2lnbmVkCgkgICAgICogeWV0Li4uICovCgkgICAgdG1wLT5zY3NpX2RvbmUodG1wKTsKCSAgICBmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOwoJICAgIHJldHVybiBTQ1NJX0FCT1JUX1NVQ0NFU1M7Cgl9CgovKiAKICogQ2FzZSAzIDogSWYgYW55IGNvbW1hbmRzIGFyZSBjb25uZWN0ZWQsIHdlJ3JlIGdvaW5nIHRvIGZhaWwgdGhlIGFib3J0CiAqCSAgICBhbmQgbGV0IHRoZSBoaWdoIGxldmVsIFNDU0kgZHJpdmVyIHJldHJ5IGF0IGEgbGF0ZXIgdGltZSBvciAKICoJICAgIGlzc3VlIGEgcmVzZXQuCiAqCiAqCSAgICBUaW1lb3V0cywgYW5kIHRoZXJlZm9yZSBhYm9ydGVkIGNvbW1hbmRzLCB3aWxsIGJlIGhpZ2hseSB1bmxpa2VseQogKiAgICAgICAgICBhbmQgaGFuZGxpbmcgdGhlbSBjbGVhbmx5IGluIHRoaXMgc2l0dWF0aW9uIHdvdWxkIG1ha2UgdGhlIGNvbW1vbgogKgkgICAgY2FzZSBvZiBub3Jlc2V0cyBsZXNzIGVmZmljaWVudCwgYW5kIHdvdWxkIHBvbGx1dGUgb3VyIGNvZGUuICBTbywKICoJICAgIHdlIGZhaWwuCiAqLwoKICAgIGlmIChob3N0ZGF0YS0+Y29ubmVjdGVkKSB7Cglsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CglBQlJUX1BSSU5USygic2NzaSVkOiBhYm9ydCBmYWlsZWQsIGNvbW1hbmQgY29ubmVjdGVkLlxuIiwgSE9TVE5PKTsKICAgICAgICByZXR1cm4gU0NTSV9BQk9SVF9TTk9PWkU7CiAgICB9CgovKgogKiBDYXNlIDQ6IElmIHRoZSBjb21tYW5kIGlzIGN1cnJlbnRseSBkaXNjb25uZWN0ZWQgZnJvbSB0aGUgYnVzLCBhbmQgCiAqIAl0aGVyZSBhcmUgbm8gY29ubmVjdGVkIGNvbW1hbmRzLCB3ZSByZWNvbm5lY3QgdGhlIElfVF9MIG9yIAogKglJX1RfTF9RIG5leHVzIGFzc29jaWF0ZWQgd2l0aCBpdCwgZ28gaW50byBtZXNzYWdlIG91dCwgYW5kIHNlbmQgCiAqICAgICAgYW4gYWJvcnQgbWVzc2FnZS4KICoKICogVGhpcyBjYXNlIGlzIGVzcGVjaWFsbHkgdWdseS4gSW4gb3JkZXIgdG8gcmVlc3RhYmxpc2ggdGhlIG5leHVzLCB3ZQogKiBuZWVkIHRvIGNhbGwgTkNSNTM4MF9zZWxlY3QoKS4gIFRoZSBlYXNpZXN0IHdheSB0byBpbXBsZW1lbnQgdGhpcyAKICogZnVuY3Rpb24gd2FzIHRvIGFib3J0IGlmIHRoZSBidXMgd2FzIGJ1c3ksIGFuZCBsZXQgdGhlIGludGVycnVwdAogKiBoYW5kbGVyIHRyaWdnZXJlZCBvbiB0aGUgU0VMIGZvciByZXNlbGVjdCB0YWtlIGNhcmUgb2YgbG9zdCBhcmJpdHJhdGlvbnMKICogd2hlcmUgbmVjZXNzYXJ5LCBtZWFuaW5nIGludGVycnVwdHMgbmVlZCB0byBiZSBlbmFibGVkLgogKgogKiBXaGVuIGludGVycnVwdHMgYXJlIGVuYWJsZWQsIHRoZSBxdWV1ZXMgbWF5IGNoYW5nZSAtIHNvIHdlIAogKiBjYW4ndCByZW1vdmUgaXQgZnJvbSB0aGUgZGlzY29ubmVjdGVkIHF1ZXVlIGJlZm9yZSBzZWxlY3RpbmcgaXQKICogYmVjYXVzZSB0aGF0IGNvdWxkIGNhdXNlIGEgZmFpbHVyZSBpbiBoYXNoaW5nIHRoZSBuZXh1cyBpZiB0aGF0IAogKiBkZXZpY2UgcmVzZWxlY3RlZC4KICogCiAqIFNpbmNlIHRoZSBxdWV1ZXMgbWF5IGNoYW5nZSwgd2UgY2FuJ3QgdXNlIHRoZSBwb2ludGVycyBmcm9tIHdoZW4gd2UKICogZmlyc3QgbG9jYXRlIGl0LgogKgogKiBTbywgd2UgbXVzdCBmaXJzdCBsb2NhdGUgdGhlIGNvbW1hbmQsIGFuZCBpZiBOQ1I1MzgwX3NlbGVjdCgpCiAqIHN1Y2NlZWRzLCB0aGVuIGlzc3VlIHRoZSBhYm9ydCwgcmVsb2NhdGUgdGhlIGNvbW1hbmQgYW5kIHJlbW92ZQogKiBpdCBmcm9tIHRoZSBkaXNjb25uZWN0ZWQgcXVldWUuCiAqLwoKICAgIGZvciAodG1wID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlOyB0bXA7CgkgdG1wID0gTkVYVCh0bXApKSAKICAgICAgICBpZiAoY21kID09IHRtcCkgewogICAgICAgICAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkgICAgQUJSVF9QUklOVEsoInNjc2klZDogYWJvcnRpbmcgZGlzY29ubmVjdGVkIGNvbW1hbmQuXG4iLCBIT1NUTk8pOwogIAogICAgICAgICAgICBpZiAoTkNSNTM4MF9zZWxlY3QgKGluc3RhbmNlLCBjbWQsIChpbnQpIGNtZC0+dGFnKSkgCgkJcmV0dXJuIFNDU0lfQUJPUlRfQlVTWTsKCgkgICAgQUJSVF9QUklOVEsoInNjc2klZDogbmV4dXMgcmVlc3RhYmxpc2hlZC5cbiIsIEhPU1ROTyk7CgoJICAgIGRvX2Fib3J0IChpbnN0YW5jZSk7CgoJICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKCSAgICBmb3IgKHByZXYgPSAoU2NzaV9DbW5kICoqKSAmKGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUpLCAKCQl0bXAgPSAoU2NzaV9DbW5kICopIGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWU7CgkJdG1wOyBwcmV2ID0gTkVYVEFERFIodG1wKSwgdG1wID0gTkVYVCh0bXApICkKCQkgICAgaWYgKGNtZCA9PSB0bXApIHsKCQkgICAgUkVNT1ZFKDUsICpwcmV2LCB0bXAsIE5FWFQodG1wKSk7CgkJICAgICpwcmV2ID0gTkVYVCh0bXApOwoJCSAgICBORVhUKHRtcCkgPSBOVUxMOwoJCSAgICB0bXAtPnJlc3VsdCA9IERJRF9BQk9SVCA8PCAxNjsKCQkgICAgLyogV2UgbXVzdCB1bmxvY2sgdGhlIHRhZy9MVU4gaW1tZWRpYXRlbHkgaGVyZSwgc2luY2UgdGhlCgkJICAgICAqIHRhcmdldCBnb2VzIHRvIEJVUyBGUkVFIGFuZCBkb2Vzbid0IHNlbmQgdXMgYW5vdGhlcgoJCSAgICAgKiBtZXNzYWdlIChDT01NQU5EX0NPTVBMRVRFIG9yIHRoZSBsaWtlKQoJCSAgICAgKi8KI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSAgICBjbWRfZnJlZV90YWcoIHRtcCApOwojZWxzZQoJCSAgICBob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdICY9IH4oMSA8PCBjbWQtPmRldmljZS0+bHVuKTsKI2VuZGlmCgkJICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCQkgICAgdG1wLT5zY3NpX2RvbmUodG1wKTsKCQkgICAgZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsKCQkgICAgcmV0dXJuIFNDU0lfQUJPUlRfU1VDQ0VTUzsKCQl9Cgl9CgovKgogKiBDYXNlIDUgOiBJZiB3ZSByZWFjaGVkIHRoaXMgcG9pbnQsIHRoZSBjb21tYW5kIHdhcyBub3QgZm91bmQgaW4gYW55IG9mIAogKgkgICAgdGhlIHF1ZXVlcy4KICoKICogV2UgcHJvYmFibHkgcmVhY2hlZCB0aGlzIHBvaW50IGJlY2F1c2Ugb2YgYW4gdW5saWtlbHkgcmFjZSBjb25kaXRpb24KICogYmV0d2VlbiB0aGUgY29tbWFuZCBjb21wbGV0aW5nIHN1Y2Nlc3NmdWxseSBhbmQgdGhlIGFib3J0aW9uIGNvZGUsCiAqIHNvIHdlIHdvbid0IHBhbmljLCBidXQgd2Ugd2lsbCBub3RpZnkgdGhlIHVzZXIgaW4gY2FzZSBzb21ldGhpbmcgcmVhbGx5CiAqIGJyb2tlLgogKi8KCiAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiAgICBwcmludGsoS0VSTl9JTkZPICJzY3NpJWQ6IHdhcm5pbmcgOiBTQ1NJIGNvbW1hbmQgcHJvYmFibHkgY29tcGxldGVkIHN1Y2Nlc3NmdWxseVxuIgogICAgICAgICAgIEtFUk5fSU5GTyAiICAgICAgICBiZWZvcmUgYWJvcnRpb25cbiIsIEhPU1ROTyk7IAoKLyogTWF5YmUgaXQgaXMgc3VmZmljaWVudCBqdXN0IHRvIHJlbGVhc2UgdGhlIFNULURNQSBsb2NrLi4uIChpZgogKiBwb3NzaWJsZSBhdCBhbGwpIEF0IGxlYXN0LCB3ZSBzaG91bGQgY2hlY2sgaWYgdGhlIGxvY2sgY291bGQgYmUKICogcmVsZWFzZWQgYWZ0ZXIgdGhlIGFib3J0LCBpbiBjYXNlIGl0IGlzIGtlcHQgZHVlIHRvIHNvbWUgYnVnLgogKi8KICAgIGZhbGNvbl9yZWxlYXNlX2xvY2tfaWZfcG9zc2libGUoIGhvc3RkYXRhICk7CgogICAgcmV0dXJuIFNDU0lfQUJPUlRfTk9UX1JVTk5JTkc7Cn0KCgovKiAKICogRnVuY3Rpb24gOiBpbnQgTkNSNTM4MF9yZXNldCAoU2NzaV9DbW5kICpjbWQpCiAqIAogKiBQdXJwb3NlIDogcmVzZXQgdGhlIFNDU0kgYnVzLgogKgogKiBSZXR1cm5zIDogU0NTSV9SRVNFVF9XQUtFVVAKICoKICovIAoKc3RhdGljIGludCBOQ1I1MzgwX2J1c19yZXNldCggU2NzaV9DbW5kICpjbWQpCnsKICAgIFNFVFVQX0hPU1REQVRBKGNtZC0+ZGV2aWNlLT5ob3N0KTsKICAgIGludCAgICAgICAgICAgaTsKICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7CiNpZiAxCiAgICBTY3NpX0NtbmQgKmNvbm5lY3RlZCwgKmRpc2Nvbm5lY3RlZF9xdWV1ZTsKI2VuZGlmCgogICAgaWYgKCFJU19BX1RUKCkgJiYgIWZhbGNvbl9nb3RfbG9jaykKCXByaW50ayhLRVJOX0VSUiAic2NzaSVkOiAhIUJJTkdPISEgRmFsY29uIGhhcyBubyBsb2NrIGluIE5DUjUzODBfcmVzZXRcbiIsCgkgICAgICAgSF9OTyhjbWQpICk7CgogICAgTkNSNTM4MF9wcmludF9zdGF0dXMgKGNtZC0+ZGV2aWNlLT5ob3N0KTsKCiAgICAvKiBnZXQgaW4gcGhhc2UgKi8KICAgIE5DUjUzODBfd3JpdGUoIFRBUkdFVF9DT01NQU5EX1JFRywKCQkgICBQSEFTRV9TUl9UT19UQ1IoIE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSApKTsKICAgIC8qIGFzc2VydCBSU1QgKi8KICAgIE5DUjUzODBfd3JpdGUoIElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCBJQ1JfQVNTRVJUX1JTVCApOwogICAgdWRlbGF5ICg0MCk7CiAgICAvKiByZXNldCBOQ1IgcmVnaXN0ZXJzICovCiAgICBOQ1I1MzgwX3dyaXRlKCBJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFICk7CiAgICBOQ1I1MzgwX3dyaXRlKCBNT0RFX1JFRywgTVJfQkFTRSApOwogICAgTkNSNTM4MF93cml0ZSggVEFSR0VUX0NPTU1BTkRfUkVHLCAwICk7CiAgICBOQ1I1MzgwX3dyaXRlKCBTRUxFQ1RfRU5BQkxFX1JFRywgMCApOwogICAgLyogKytyb21hbjogcmVzZXQgaW50ZXJydXB0IGNvbmRpdGlvbiEgb3RoZXJ3aXNlIG5vIGludGVycnVwdHMgZG9uJ3QgZ2V0CiAgICAgKiB0aHJvdWdoIGFueW1vcmUgLi4uICovCiAgICAodm9pZClOQ1I1MzgwX3JlYWQoIFJFU0VUX1BBUklUWV9JTlRFUlJVUFRfUkVHICk7CgojaWYgMSAvKiBYWFggU2hvdWxkIG5vdyBiZSBkb25lIGJ5IG1pZGxldmVsIGNvZGUsIGJ1dCBpdCdzIGJyb2tlbiBYWFggKi8KICAgICAgLyogWFhYIHNlZSBiZWxvdyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgWFhYICovCgogICAgLyogTVNjaDogb2xkLXN0eWxlIHJlc2V0OiBhY3R1YWxseSBhYm9ydCBhbGwgY29tbWFuZCBwcm9jZXNzaW5nIGhlcmUgKi8KCiAgICAvKiBBZnRlciB0aGUgcmVzZXQsIHRoZXJlIGFyZSBubyBtb3JlIGNvbm5lY3RlZCBvciBkaXNjb25uZWN0ZWQgY29tbWFuZHMKICAgICAqIGFuZCBubyBidXN5IHVuaXRzOyB0byBhdm9pZCBwcm9ibGVtcyB3aXRoIHJlLWluc2VydGluZyB0aGUgY29tbWFuZHMKICAgICAqIGludG8gdGhlIGlzc3VlX3F1ZXVlICh2aWEgc2NzaV9kb25lKCkpLCB0aGUgYWJvcnRlZCBjb21tYW5kcyBhcmUKICAgICAqIHJlbWVtYmVyZWQgaW4gbG9jYWwgdmFyaWFibGVzIGZpcnN0LgogICAgICovCiAgICBsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAgICBjb25uZWN0ZWQgPSAoU2NzaV9DbW5kICopaG9zdGRhdGEtPmNvbm5lY3RlZDsKICAgIGhvc3RkYXRhLT5jb25uZWN0ZWQgPSBOVUxMOwogICAgZGlzY29ubmVjdGVkX3F1ZXVlID0gKFNjc2lfQ21uZCAqKWhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWU7CiAgICBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlID0gTlVMTDsKI2lmZGVmIFNVUFBPUlRfVEFHUwogICAgZnJlZV9hbGxfdGFncygpOwojZW5kaWYKICAgIGZvciggaSA9IDA7IGkgPCA4OyArK2kgKQoJaG9zdGRhdGEtPmJ1c3lbaV0gPSAwOwojaWZkZWYgUkVBTF9ETUEKICAgIGhvc3RkYXRhLT5kbWFfbGVuID0gMDsKI2VuZGlmCiAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgogICAgLyogSW4gb3JkZXIgdG8gdGVsbCB0aGUgbWlkLWxldmVsIGNvZGUgd2hpY2ggY29tbWFuZHMgd2VyZSBhYm9ydGVkLCAKICAgICAqIHNldCB0aGUgY29tbWFuZCBzdGF0dXMgdG8gRElEX1JFU0VUIGFuZCBjYWxsIHNjc2lfZG9uZSgpICEhIQogICAgICogVGhpcyB1bHRpbWF0ZWx5IGFib3J0cyBwcm9jZXNzaW5nIG9mIHRoZXNlIGNvbW1hbmRzIGluIHRoZSBtaWQtbGV2ZWwuCiAgICAgKi8KCiAgICBpZiAoKGNtZCA9IGNvbm5lY3RlZCkpIHsKCUFCUlRfUFJJTlRLKCJzY3NpJWQ6IHJlc2V0IGFib3J0ZWQgYSBjb25uZWN0ZWQgY29tbWFuZFxuIiwgSF9OTyhjbWQpKTsKCWNtZC0+cmVzdWx0ID0gKGNtZC0+cmVzdWx0ICYgMHhmZmZmKSB8IChESURfUkVTRVQgPDwgMTYpOwoJY21kLT5zY3NpX2RvbmUoIGNtZCApOwogICAgfQoKICAgIGZvciAoaSA9IDA7IChjbWQgPSBkaXNjb25uZWN0ZWRfcXVldWUpOyArK2kpIHsKCWRpc2Nvbm5lY3RlZF9xdWV1ZSA9IE5FWFQoY21kKTsKCU5FWFQoY21kKSA9IE5VTEw7CgljbWQtPnJlc3VsdCA9IChjbWQtPnJlc3VsdCAmIDB4ZmZmZikgfCAoRElEX1JFU0VUIDw8IDE2KTsKCWNtZC0+c2NzaV9kb25lKCBjbWQgKTsKICAgIH0KICAgIGlmIChpID4gMCkKCUFCUlRfUFJJTlRLKCJzY3NpOiByZXNldCBhYm9ydGVkICVkIGRpc2Nvbm5lY3RlZCBjb21tYW5kKHMpXG4iLCBpKTsKCi8qIFRoZSBGYWxjb24gbG9jayBzaG91bGQgYmUgcmVsZWFzZWQgYWZ0ZXIgYSByZXNldC4uLgogKi8KLyogKytndWVudGhlcjogbW92ZWQgdG8gYXRhcmlfc2NzaV9yZXNldCgpLCB0byBwcmV2ZW50IGEgcmFjZSBiZXR3ZWVuCiAqIHVubG9ja2luZyBhbmQgZW5hYmxpbmcgZG1hIGludGVycnVwdC4KICovCi8qICAgIGZhbGNvbl9yZWxlYXNlX2xvY2tfaWZfcG9zc2libGUoIGhvc3RkYXRhICk7Ki8KCiAgICAvKiBzaW5jZSBhbGwgY29tbWFuZHMgaGF2ZSBiZWVuIGV4cGxpY2l0bHkgdGVybWluYXRlZCwgd2UgbmVlZCB0byB0ZWxsCiAgICAgKiB0aGUgbWlkbGV2ZWwgY29kZSB0aGF0IHRoZSByZXNldCB3YXMgU1VDQ0VTU0ZVTCwgYW5kIHRoZXJlIGlzIG5vIAogICAgICogbmVlZCB0byAnd2FrZSB1cCcgdGhlIGNvbW1hbmRzIGJ5IGEgcmVxdWVzdF9zZW5zZQogICAgICovCiAgICByZXR1cm4gU0NTSV9SRVNFVF9TVUNDRVNTIHwgU0NTSV9SRVNFVF9CVVNfUkVTRVQ7CiNlbHNlIC8qIDEgKi8KCiAgICAvKiBNU2NoOiBuZXctc3R5bGUgcmVzZXQgaGFuZGxpbmc6IGxldCB0aGUgbWlkLWxldmVsIGRvIHdoYXQgaXQgY2FuICovCgogICAgLyogKytndWVudGhlcjogTUlELUxFVkVMIElTIFNUSUxMIEJST0tFTi4KICAgICAqIE1pZC1sZXZlbCBpcyBzdXBwb3NlZCB0byByZXF1ZXVlIGFsbCBjb21tYW5kcyB0aGF0IHdlcmUgYWN0aXZlIG9uIHRoZQogICAgICogdmFyaW91cyBsb3ctbGV2ZWwgcXVldWVzLiBJbiBmYWN0IGl0IGRvZXMgdGhpcywgYnV0IHRoYXQncyBub3QgZW5vdWdoCiAgICAgKiBiZWNhdXNlIGFsbCB0aGVzZSBjb21tYW5kcyBhcmUgc3ViamVjdCB0byB0aW1lb3V0LiBBbmQgaWYgYSB0aW1lb3V0CiAgICAgKiBoYXBwZW5zIGZvciBhbnkgcmVtb3ZlZCBjb21tYW5kLCAqX2Fib3J0KCkgaXMgY2FsbGVkIGJ1dCBhbGwgcXVldWVzCiAgICAgKiBhcmUgbm93IGVtcHR5LiBBYm9ydCB0aGVuIGdpdmVzIHVwIHRoZSBmYWxjb24gbG9jaywgd2hpY2ggaXMgZmF0YWwsCiAgICAgKiBzaW5jZSB0aGUgbWlkLWxldmVsIHdpbGwgcXVldWUgbW9yZSBjb21tYW5kcyBhbmQgbXVzdCBoYXZlIHRoZSBsb2NrCiAgICAgKiAoaXQncyBhbGwgaGFwcGVuaW5nIGluc2lkZSB0aW1lciBpbnRlcnJ1cHQgaGFuZGxlciEhKS4KICAgICAqIEV2ZW4gd29yc2UsIGFib3J0IHdpbGwgcmV0dXJuIE5PVF9SVU5OSU5HIGZvciBhbGwgdGhvc2UgY29tbWFuZHMgbm90CiAgICAgKiBvbiBhbnkgcXVldWUsIHNvIHRoZXkgd29uJ3QgYmUgcmV0cmllZCAuLi4KICAgICAqCiAgICAgKiBDb25jbHVzaW9uOiBlaXRoZXIgc2NzaS5jIGRpc2FibGVzIHRpbWVvdXQgZm9yIGFsbCByZXNldHRlZCBjb21tYW5kcwogICAgICogaW1tZWRpYXRlbHksIG9yIHdlIGxvc2UhICBBcyBvZiBsaW51eC0yLjAuMjAgaXQgZG9lc24ndC4KICAgICAqLwoKICAgIC8qIEFmdGVyIHRoZSByZXNldCwgdGhlcmUgYXJlIG5vIG1vcmUgY29ubmVjdGVkIG9yIGRpc2Nvbm5lY3RlZCBjb21tYW5kcwogICAgICogYW5kIG5vIGJ1c3kgdW5pdHM7IHNvIGNsZWFyIHRoZSBsb3ctbGV2ZWwgc3RhdHVzIGhlcmUgdG8gYXZvaWQgCiAgICAgKiBjb25mbGljdHMgd2hlbiB0aGUgbWlkLWxldmVsIGNvZGUgdHJpZXMgdG8gd2FrZSB1cCB0aGUgYWZmZWN0ZWQgCiAgICAgKiBjb21tYW5kcyEKICAgICAqLwoKICAgIGlmIChob3N0ZGF0YS0+aXNzdWVfcXVldWUpCglBQlJUX1BSSU5USygic2NzaSVkOiByZXNldCBhYm9ydGVkIGlzc3VlZCBjb21tYW5kKHMpXG4iLCBIX05PKGNtZCkpOwogICAgaWYgKGhvc3RkYXRhLT5jb25uZWN0ZWQpIAoJQUJSVF9QUklOVEsoInNjc2klZDogcmVzZXQgYWJvcnRlZCBhIGNvbm5lY3RlZCBjb21tYW5kXG4iLCBIX05PKGNtZCkpOwogICAgaWYgKGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUpCglBQlJUX1BSSU5USygic2NzaSVkOiByZXNldCBhYm9ydGVkIGRpc2Nvbm5lY3RlZCBjb21tYW5kKHMpXG4iLCBIX05PKGNtZCkpOwoKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSA9IE5VTEw7CiAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gTlVMTDsKICAgIGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUgPSBOVUxMOwojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICBmcmVlX2FsbF90YWdzKCk7CiNlbmRpZgogICAgZm9yKCBpID0gMDsgaSA8IDg7ICsraSApCglob3N0ZGF0YS0+YnVzeVtpXSA9IDA7CiNpZmRlZiBSRUFMX0RNQQogICAgaG9zdGRhdGEtPmRtYV9sZW4gPSAwOwojZW5kaWYKICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCiAgICAvKiB3ZSBkaWQgbm8gY29tcGxldGUgcmVzZXQgb2YgYWxsIGNvbW1hbmRzLCBzbyBhIHdha2V1cCBpcyByZXF1aXJlZCAqLwogICAgcmV0dXJuIFNDU0lfUkVTRVRfV0FLRVVQIHwgU0NTSV9SRVNFVF9CVVNfUkVTRVQ7CiNlbmRpZiAvKiAxICovCn0KCi8qIExvY2FsIFZhcmlhYmxlczogKi8KLyogdGFiLXdpZHRoOiA4ICAgICAqLwovKiBFbmQ6ICAgICAgICAgICAgICovCg==