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+cmVxdWVzdF9idWZmZXI7CgljbWQtPlNDcC5idWZmZXJzX3Jlc2lkdWFsID0gY21kLT51c2Vfc2cgLSAxOwoJY21kLT5TQ3AucHRyID0gKGNoYXIgKilwYWdlX2FkZHJlc3MoY21kLT5TQ3AuYnVmZmVyLT5wYWdlKSsKCQkgICAgICAgY21kLT5TQ3AuYnVmZmVyLT5vZmZzZXQ7CgljbWQtPlNDcC50aGlzX3Jlc2lkdWFsID0gY21kLT5TQ3AuYnVmZmVyLT5sZW5ndGg7CgkvKiArK3JvbWFuOiBUcnkgdG8gbWVyZ2Ugc29tZSBzY2F0dGVyLWJ1ZmZlcnMgaWYgdGhleSBhcmUgYXQKCSAqIGNvbnRpZ3VvdXMgcGh5c2ljYWwgYWRkcmVzc2VzLgoJICovCgltZXJnZV9jb250aWd1b3VzX2J1ZmZlcnMoIGNtZCApOwogICAgfSBlbHNlIHsKCWNtZC0+U0NwLmJ1ZmZlciA9IE5VTEw7CgljbWQtPlNDcC5idWZmZXJzX3Jlc2lkdWFsID0gMDsKCWNtZC0+U0NwLnB0ciA9IChjaGFyICopIGNtZC0+cmVxdWVzdF9idWZmZXI7CgljbWQtPlNDcC50aGlzX3Jlc2lkdWFsID0gY21kLT5yZXF1ZXN0X2J1ZmZsZW47CiAgICB9Cn0KCiNpbmNsdWRlIDxsaW51eC9kZWxheS5oPgoKI2lmIE5ERUJVRwpzdGF0aWMgc3RydWN0IHsKICAgIHVuc2lnbmVkIGNoYXIgbWFzazsKICAgIGNvbnN0IGNoYXIgKiBuYW1lO30gCnNpZ25hbHNbXSA9IHt7IFNSX0RCUCwgIlBBUklUWSJ9LCB7IFNSX1JTVCwgIlJTVCIgfSwgeyBTUl9CU1ksICJCU1kiIH0sIAogICAgeyBTUl9SRVEsICJSRVEiIH0sIHsgU1JfTVNHLCAiTVNHIiB9LCB7IFNSX0NELCAgIkNEIiB9LCB7IFNSX0lPLCAiSU8iIH0sIAogICAgeyBTUl9TRUwsICJTRUwiIH0sIHswLCBOVUxMfX0sIApiYXNyc1tdID0ge3tCQVNSX0FUTiwgIkFUTiJ9LCB7QkFTUl9BQ0ssICJBQ0sifSwgezAsIE5VTEx9fSwKaWNyc1tdID0ge3tJQ1JfQVNTRVJUX1JTVCwgIkFTU0VSVCBSU1QifSx7SUNSX0FTU0VSVF9BQ0ssICJBU1NFUlQgQUNLIn0sCiAgICB7SUNSX0FTU0VSVF9CU1ksICJBU1NFUlQgQlNZIn0sIHtJQ1JfQVNTRVJUX1NFTCwgIkFTU0VSVCBTRUwifSwgCiAgICB7SUNSX0FTU0VSVF9BVE4sICJBU1NFUlQgQVROIn0sIHtJQ1JfQVNTRVJUX0RBVEEsICJBU1NFUlQgREFUQSJ9LCAKICAgIHswLCBOVUxMfX0sCm1yc1tdID0ge3tNUl9CTE9DS19ETUFfTU9ERSwgIk1PREUgQkxPQ0sgRE1BIn0sIHtNUl9UQVJHRVQsICJNT0RFIFRBUkdFVCJ9LCAKICAgIHtNUl9FTkFCTEVfUEFSX0NIRUNLLCAiTU9ERSBQQVJJVFkgQ0hFQ0sifSwge01SX0VOQUJMRV9QQVJfSU5UUiwgCiAgICAiTU9ERSBQQVJJVFkgSU5UUiJ9LCB7TVJfRU5BQkxFX0VPUF9JTlRSLCJNT0RFIEVPUCBJTlRSIn0sCiAgICB7TVJfTU9OSVRPUl9CU1ksICJNT0RFIE1PTklUT1IgQlNZIn0sCiAgICB7TVJfRE1BX01PREUsICJNT0RFIERNQSJ9LCB7TVJfQVJCSVRSQVRFLCAiTU9ERSBBUkJJVFJBVElPTiJ9LCAKICAgIHswLCBOVUxMfX07CgovKgogKiBGdW5jdGlvbiA6IHZvaWQgTkNSNTM4MF9wcmludChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IHByaW50IHRoZSBTQ1NJIGJ1cyBzaWduYWxzIGZvciBkZWJ1Z2dpbmcgcHVycG9zZXMKICoKICogSW5wdXQgOiBpbnN0YW5jZSAtIHdoaWNoIE5DUjUzODAKICovCgpzdGF0aWMgdm9pZCBOQ1I1MzgwX3ByaW50KHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKSB7CiAgICB1bnNpZ25lZCBjaGFyIHN0YXR1cywgZGF0YSwgYmFzciwgbXIsIGljciwgaTsKICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7CgogICAgbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwogICAgZGF0YSA9IE5DUjUzODBfcmVhZChDVVJSRU5UX1NDU0lfREFUQV9SRUcpOwogICAgc3RhdHVzID0gTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpOwogICAgbXIgPSBOQ1I1MzgwX3JlYWQoTU9ERV9SRUcpOwogICAgaWNyID0gTkNSNTM4MF9yZWFkKElOSVRJQVRPUl9DT01NQU5EX1JFRyk7CiAgICBiYXNyID0gTkNSNTM4MF9yZWFkKEJVU19BTkRfU1RBVFVTX1JFRyk7CiAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiAgICBwcmludGsoIlNUQVRVU19SRUc6ICUwMnggIiwgc3RhdHVzKTsKICAgIGZvciAoaSA9IDA7IHNpZ25hbHNbaV0ubWFzayA7ICsraSkgCglpZiAoc3RhdHVzICYgc2lnbmFsc1tpXS5tYXNrKQoJICAgIHByaW50aygiLCVzIiwgc2lnbmFsc1tpXS5uYW1lKTsKICAgIHByaW50aygiXG5CQVNSOiAlMDJ4ICIsIGJhc3IpOwogICAgZm9yIChpID0gMDsgYmFzcnNbaV0ubWFzayA7ICsraSkgCglpZiAoYmFzciAmIGJhc3JzW2ldLm1hc2spCgkgICAgcHJpbnRrKCIsJXMiLCBiYXNyc1tpXS5uYW1lKTsKICAgIHByaW50aygiXG5JQ1I6ICUwMnggIiwgaWNyKTsKICAgIGZvciAoaSA9IDA7IGljcnNbaV0ubWFzazsgKytpKSAKCWlmIChpY3IgJiBpY3JzW2ldLm1hc2spCgkgICAgcHJpbnRrKCIsJXMiLCBpY3JzW2ldLm5hbWUpOwogICAgcHJpbnRrKCJcbk1PREU6ICUwMnggIiwgbXIpOwogICAgZm9yIChpID0gMDsgbXJzW2ldLm1hc2s7ICsraSkgCglpZiAobXIgJiBtcnNbaV0ubWFzaykKCSAgICBwcmludGsoIiwlcyIsIG1yc1tpXS5uYW1lKTsKICAgIHByaW50aygiXG4iKTsKfQoKc3RhdGljIHN0cnVjdCB7CiAgICB1bnNpZ25lZCBjaGFyIHZhbHVlOwogICAgY29uc3QgY2hhciAqbmFtZTsKfSBwaGFzZXNbXSA9IHsKICAgIHtQSEFTRV9EQVRBT1VULCAiREFUQU9VVCJ9LCB7UEhBU0VfREFUQUlOLCAiREFUQUlOIn0sIHtQSEFTRV9DTURPVVQsICJDTURPVVQifSwKICAgIHtQSEFTRV9TVEFUSU4sICJTVEFUSU4ifSwge1BIQVNFX01TR09VVCwgIk1TR09VVCJ9LCB7UEhBU0VfTVNHSU4sICJNU0dJTiJ9LAogICAge1BIQVNFX1VOS05PV04sICJVTktOT1dOIn19OwoKLyogCiAqIEZ1bmN0aW9uIDogdm9pZCBOQ1I1MzgwX3ByaW50X3BoYXNlKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQogKgogKiBQdXJwb3NlIDogcHJpbnQgdGhlIGN1cnJlbnQgU0NTSSBwaGFzZSBmb3IgZGVidWdnaW5nIHB1cnBvc2VzCiAqCiAqIElucHV0IDogaW5zdGFuY2UgLSB3aGljaCBOQ1I1MzgwCiAqLwoKc3RhdGljIHZvaWQgTkNSNTM4MF9wcmludF9waGFzZShzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKewogICAgdW5zaWduZWQgY2hhciBzdGF0dXM7CiAgICBpbnQgaTsKCiAgICBzdGF0dXMgPSBOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRyk7CiAgICBpZiAoIShzdGF0dXMgJiBTUl9SRVEpKSAKCXByaW50ayhLRVJOX0RFQlVHICJzY3NpJWQ6IFJFUSBub3QgYXNzZXJ0ZWQsIHBoYXNlIHVua25vd24uXG4iLCBIT1NUTk8pOwogICAgZWxzZSB7Cglmb3IgKGkgPSAwOyAocGhhc2VzW2ldLnZhbHVlICE9IFBIQVNFX1VOS05PV04pICYmIAoJICAgIChwaGFzZXNbaV0udmFsdWUgIT0gKHN0YXR1cyAmIFBIQVNFX01BU0spKTsgKytpKTsgCglwcmludGsoS0VSTl9ERUJVRyAic2NzaSVkOiBwaGFzZSAlc1xuIiwgSE9TVE5PLCBwaGFzZXNbaV0ubmFtZSk7CiAgICB9Cn0KCiNlbHNlIC8qICFOREVCVUcgKi8KCi8qIGR1bW1pZXMuLi4gKi8KX19pbmxpbmVfXyB2b2lkIE5DUjUzODBfcHJpbnQoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpIHsgfTsKX19pbmxpbmVfXyB2b2lkIE5DUjUzODBfcHJpbnRfcGhhc2Uoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpIHsgfTsKCiNlbmRpZgoKLyoKICogKytyb21hbjogTmV3IHNjaGVtZSBvZiBjYWxsaW5nIE5DUjUzODBfbWFpbigpCiAqIAogKiBJZiB3ZSdyZSBub3QgaW4gYW4gaW50ZXJydXB0LCB3ZSBjYW4gY2FsbCBvdXIgbWFpbiBkaXJlY3RseSwgaXQgY2Fubm90IGJlCiAqIGFscmVhZHkgcnVubmluZy4gRWxzZSwgd2UgcXVldWUgaXQgb24gYSB0YXNrIHF1ZXVlLCBpZiBub3QgJ21haW5fcnVubmluZycKICogdGVsbHMgdXMgdGhhdCBhIGxvd2VyIGxldmVsIGlzIGFscmVhZHkgZXhlY3V0aW5nIGl0LiBUaGlzIHdheSwKICogJ21haW5fcnVubmluZycgbmVlZHMgbm90IGJlIHByb3RlY3RlZCBpbiBhIHNwZWNpYWwgd2F5LgogKgogKiBxdWV1ZV9tYWluKCkgaXMgYSB1dGlsaXR5IGZ1bmN0aW9uIGZvciBwdXR0aW5nIG91ciBtYWluIG9udG8gdGhlIHRhc2sKICogcXVldWUsIGlmIG1haW5fcnVubmluZyBpcyBmYWxzZS4gSXQgc2hvdWxkIGJlIGNhbGxlZCBvbmx5IGZyb20gYQogKiBpbnRlcnJ1cHQgb3IgYm90dG9tIGhhbGYuCiAqLwoKI2luY2x1ZGUgPGxpbnV4L3dvcmtxdWV1ZS5oPgojaW5jbHVkZSA8bGludXgvaW50ZXJydXB0Lmg+CgpzdGF0aWMgdm9sYXRpbGUgaW50IG1haW5fcnVubmluZyA9IDA7CnN0YXRpYyBERUNMQVJFX1dPUksoTkNSNTM4MF90cXVldWUsICh2b2lkICgqKSh2b2lkKikpTkNSNTM4MF9tYWluLCBOVUxMKTsKCnN0YXRpYyBfX2lubGluZV9fIHZvaWQgcXVldWVfbWFpbih2b2lkKQp7CiAgICBpZiAoIW1haW5fcnVubmluZykgewoJLyogSWYgaW4gaW50ZXJydXB0IGFuZCBOQ1I1MzgwX21haW4oKSBub3QgYWxyZWFkeSBydW5uaW5nLAoJICAgcXVldWUgaXQgb24gdGhlICdpbW1lZGlhdGUnIHRhc2sgcXVldWUsIHRvIGJlIHByb2Nlc3NlZAoJICAgaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIGN1cnJlbnQgaW50ZXJydXB0IHByb2Nlc3NpbmcgaGFzCgkgICBmaW5pc2hlZC4gKi8KCXNjaGVkdWxlX3dvcmsoJk5DUjUzODBfdHF1ZXVlKTsKICAgIH0KICAgIC8qIGVsc2U6IG5vdGhpbmcgdG8gZG86IHRoZSBydW5uaW5nIE5DUjUzODBfbWFpbigpIHdpbGwgcGljayB1cAogICAgICAgYW55IG5ld2x5IHF1ZXVlZCBjb21tYW5kLiAqLwp9CgoKc3RhdGljIGlubGluZSB2b2lkIE5DUjUzODBfYWxsX2luaXQgKHZvaWQpCnsKICAgIHN0YXRpYyBpbnQgZG9uZSA9IDA7CiAgICBpZiAoIWRvbmUpIHsKCUlOSV9QUklOVEsoInNjc2kgOiBOQ1I1MzgwX2FsbF9pbml0KClcbiIpOwoJZG9uZSA9IDE7CiAgICB9Cn0KCiAKLyoKICogRnVuY3Rpb24gOiB2b2lkIE5DUjU4MzgwX3ByaW50X29wdGlvbnMgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQogKgogKiBQdXJwb3NlIDogY2FsbGVkIGJ5IHByb2JlIGNvZGUgaW5kaWNhdGluZyB0aGUgTkNSNTM4MCBkcml2ZXIKICoJICAgICBvcHRpb25zIHRoYXQgd2VyZSBzZWxlY3RlZC4KICoKICogSW5wdXRzIDogaW5zdGFuY2UsIHBvaW50ZXIgdG8gdGhpcyBpbnN0YW5jZS4gIFVudXNlZC4KICovCgpzdGF0aWMgdm9pZCBfX2luaXQgTkNSNTM4MF9wcmludF9vcHRpb25zIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKewogICAgcHJpbnRrKCIgZ2VuZXJpYyBvcHRpb25zIgojaWZkZWYgQVVUT1NFTlNFIAogICAgIiBBVVRPU0VOU0UiCiNlbmRpZgojaWZkZWYgUkVBTF9ETUEKICAgICIgUkVBTCBETUEiCiNlbmRpZgojaWZkZWYgUEFSSVRZCiAgICAiIFBBUklUWSIKI2VuZGlmCiNpZmRlZiBTVVBQT1JUX1RBR1MKICAgICIgU0NTSS0yIFRBR0dFRCBRVUVVSU5HIgojZW5kaWYKICAgICk7CiAgICBwcmludGsoIiBnZW5lcmljIHJlbGVhc2U9JWQiLCBOQ1I1MzgwX1BVQkxJQ19SRUxFQVNFKTsKfQoKLyoKICogRnVuY3Rpb24gOiB2b2lkIE5DUjUzODBfcHJpbnRfc3RhdHVzIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IHByaW50IGNvbW1hbmRzIGluIHRoZSB2YXJpb3VzIHF1ZXVlcywgY2FsbGVkIGZyb20KICoJTkNSNTM4MF9hYm9ydCBhbmQgTkNSNTM4MF9kZWJ1ZyB0byBhaWQgZGVidWdnaW5nLgogKgogKiBJbnB1dHMgOiBpbnN0YW5jZSwgcG9pbnRlciB0byB0aGlzIGluc3RhbmNlLiAgCiAqLwoKc3RhdGljIHZvaWQgTkNSNTM4MF9wcmludF9zdGF0dXMgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQp7CiAgICBjaGFyICpwcl9iZnI7CiAgICBjaGFyICpzdGFydDsKICAgIGludCBsZW47CgogICAgTkNSX1BSSU5UKE5ERUJVR19BTlkpOwogICAgTkNSX1BSSU5UX1BIQVNFKE5ERUJVR19BTlkpOwoKICAgIHByX2JmciA9IChjaGFyICopIF9fZ2V0X2ZyZWVfcGFnZShHRlBfQVRPTUlDKTsKICAgIGlmICghcHJfYmZyKSB7CglwcmludGsoIk5DUjUzODBfcHJpbnRfc3RhdHVzOiBubyBtZW1vcnkgZm9yIHByaW50IGJ1ZmZlclxuIik7CglyZXR1cm47CiAgICB9CiAgICBsZW4gPSBOQ1I1MzgwX3Byb2NfaW5mbyhwcl9iZnIsICZzdGFydCwgMCwgUEFHRV9TSVpFLCBIT1NUTk8sIDApOwogICAgcHJfYmZyW2xlbl0gPSAwOwogICAgcHJpbnRrKCJcbiVzXG4iLCBwcl9iZnIpOwogICAgZnJlZV9wYWdlKCh1bnNpZ25lZCBsb25nKSBwcl9iZnIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLyoKICogL3Byb2Mvc2NzaS9bZHRjIHBhczE2IHQxMjggZ2VuZXJpY10vWzAtQVNDX05VTV9CT0FSRF9TVVBQT1JURURdCiAqCiAqICpidWZmZXI6IEkvTyBidWZmZXIKICogKipzdGFydDogaWYgaW5vdXQgPT0gRkFMU0UgcG9pbnRlciBpbnRvIGJ1ZmZlciB3aGVyZSB1c2VyIHJlYWQgc2hvdWxkIHN0YXJ0CiAqIG9mZnNldDogY3VycmVudCBvZmZzZXQKICogbGVuZ3RoOiBsZW5ndGggb2YgYnVmZmVyCiAqIGhvc3RubzogU2NzaV9Ib3N0IGhvc3Rfbm8KICogaW5vdXQ6IFRSVUUgLSB1c2VyIGlzIHdyaXRpbmc7IEZBTFNFIC0gdXNlciBpcyByZWFkaW5nCiAqCiAqIFJldHVybiB0aGUgbnVtYmVyIG9mIGJ5dGVzIHJlYWQgZnJvbSBvciB3cml0dGVuCiovCgojdW5kZWYgU1BSSU5URgojZGVmaW5lIFNQUklOVEYoZm10LGFyZ3MuLi4pIFwKICBkbyB7IGlmIChwb3MgKyBzdHJsZW4oZm10KSArIDIwIC8qIHNsb3AgKi8gPCBidWZmZXIgKyBsZW5ndGgpIFwKCSBwb3MgKz0gc3ByaW50Zihwb3MsIGZtdCAsICMjIGFyZ3MpOyB9IHdoaWxlKDApCnN0YXRpYwpjaGFyICpscHJpbnRfU2NzaV9DbW5kIChTY3NpX0NtbmQgKmNtZCwgY2hhciAqcG9zLCBjaGFyICpidWZmZXIsIGludCBsZW5ndGgpOwoKc3RhdGljCmludCBOQ1I1MzgwX3Byb2NfaW5mbyAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UsIGNoYXIgKmJ1ZmZlciwgY2hhciAqKnN0YXJ0LCBvZmZfdCBvZmZzZXQsCgkJICAgICAgIGludCBsZW5ndGgsIGludCBpbm91dCkKewogICAgY2hhciAqcG9zID0gYnVmZmVyOwogICAgc3RydWN0IE5DUjUzODBfaG9zdGRhdGEgKmhvc3RkYXRhOwogICAgU2NzaV9DbW5kICpwdHI7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwogICAgb2ZmX3QgYmVnaW4gPSAwOwojZGVmaW5lIGNoZWNrX29mZnNldCgpCQkJCVwKICAgIGRvIHsJCQkJCVwKCWlmIChwb3MgLSBidWZmZXIgPCBvZmZzZXQgLSBiZWdpbikgewlcCgkgICAgYmVnaW4gKz0gcG9zIC0gYnVmZmVyOwkJXAoJICAgIHBvcyA9IGJ1ZmZlcjsJCQlcCgl9CQkJCQlcCiAgICB9IHdoaWxlICgwKQoKICAgIGhvc3RkYXRhID0gKHN0cnVjdCBOQ1I1MzgwX2hvc3RkYXRhICopaW5zdGFuY2UtPmhvc3RkYXRhOwoKICAgIGlmIChpbm91dCkgeyAvKiBIYXMgZGF0YSBiZWVuIHdyaXR0ZW4gdG8gdGhlIGZpbGUgPyAqLwoJcmV0dXJuKC1FTk9TWVMpOyAgLyogQ3VycmVudGx5IHRoaXMgaXMgYSBuby1vcCAqLwogICAgfQogICAgU1BSSU5URigiTkNSNTM4MCBjb3JlIHJlbGVhc2U9JWQuXG4iLCBOQ1I1MzgwX1BVQkxJQ19SRUxFQVNFKTsKICAgIGNoZWNrX29mZnNldCgpOwogICAgbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwogICAgU1BSSU5URigiTkNSNTM4MDogY29yb3V0aW5lIGlzJXMgcnVubmluZy5cbiIsIG1haW5fcnVubmluZyA/ICIiIDogIm4ndCIpOwogICAgY2hlY2tfb2Zmc2V0KCk7CiAgICBpZiAoIWhvc3RkYXRhLT5jb25uZWN0ZWQpCglTUFJJTlRGKCJzY3NpJWQ6IG5vIGN1cnJlbnRseSBjb25uZWN0ZWQgY29tbWFuZFxuIiwgSE9TVE5PKTsKICAgIGVsc2UKCXBvcyA9IGxwcmludF9TY3NpX0NtbmQgKChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmNvbm5lY3RlZCwKCQkJCXBvcywgYnVmZmVyLCBsZW5ndGgpOwogICAgU1BSSU5URigic2NzaSVkOiBpc3N1ZV9xdWV1ZVxuIiwgSE9TVE5PKTsKICAgIGNoZWNrX29mZnNldCgpOwogICAgZm9yIChwdHIgPSAoU2NzaV9DbW5kICopIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZTsgcHRyOyBwdHIgPSBORVhUKHB0cikpIHsKCXBvcyA9IGxwcmludF9TY3NpX0NtbmQgKHB0ciwgcG9zLCBidWZmZXIsIGxlbmd0aCk7CgljaGVja19vZmZzZXQoKTsKICAgIH0KCiAgICBTUFJJTlRGKCJzY3NpJWQ6IGRpc2Nvbm5lY3RlZF9xdWV1ZVxuIiwgSE9TVE5PKTsKICAgIGNoZWNrX29mZnNldCgpOwogICAgZm9yIChwdHIgPSAoU2NzaV9DbW5kICopIGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWU7IHB0cjsKCSBwdHIgPSBORVhUKHB0cikpIHsKCXBvcyA9IGxwcmludF9TY3NpX0NtbmQgKHB0ciwgcG9zLCBidWZmZXIsIGxlbmd0aCk7CgljaGVja19vZmZzZXQoKTsKICAgIH0KCiAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CiAgICAqc3RhcnQgPSBidWZmZXIgKyAob2Zmc2V0IC0gYmVnaW4pOwogICAgaWYgKHBvcyAtIGJ1ZmZlciA8IG9mZnNldCAtIGJlZ2luKQoJcmV0dXJuIDA7CiAgICBlbHNlIGlmIChwb3MgLSBidWZmZXIgLSAob2Zmc2V0IC0gYmVnaW4pIDwgbGVuZ3RoKQoJcmV0dXJuIHBvcyAtIGJ1ZmZlciAtIChvZmZzZXQgLSBiZWdpbik7CiAgICByZXR1cm4gbGVuZ3RoOwp9CgpzdGF0aWMgY2hhciAqCmxwcmludF9TY3NpX0NtbmQgKFNjc2lfQ21uZCAqY21kLCBjaGFyICpwb3MsIGNoYXIgKmJ1ZmZlciwgaW50IGxlbmd0aCkKewogICAgaW50IGksIHM7CiAgICB1bnNpZ25lZCBjaGFyICpjb21tYW5kOwogICAgU1BSSU5URigic2NzaSVkOiBkZXN0aW5hdGlvbiB0YXJnZXQgJWQsIGx1biAlZFxuIiwKCSAgICBIX05PKGNtZCksIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1bik7CiAgICBTUFJJTlRGKCIgICAgICAgIGNvbW1hbmQgPSAiKTsKICAgIGNvbW1hbmQgPSBjbWQtPmNtbmQ7CiAgICBTUFJJTlRGKCIlMmQgKDB4JTAyeCkiLCBjb21tYW5kWzBdLCBjb21tYW5kWzBdKTsKICAgIGZvciAoaSA9IDEsIHMgPSBDT01NQU5EX1NJWkUoY29tbWFuZFswXSk7IGkgPCBzOyArK2kpCglTUFJJTlRGKCIgJTAyeCIsIGNvbW1hbmRbaV0pOwogICAgU1BSSU5URigiXG4iKTsKICAgIHJldHVybiBwb3M7Cn0KCgovKiAKICogRnVuY3Rpb24gOiB2b2lkIE5DUjUzODBfaW5pdCAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCiAqCiAqIFB1cnBvc2UgOiBpbml0aWFsaXplcyAqaW5zdGFuY2UgYW5kIGNvcnJlc3BvbmRpbmcgNTM4MCBjaGlwLgogKgogKiBJbnB1dHMgOiBpbnN0YW5jZSAtIGluc3RhbnRpYXRpb24gb2YgdGhlIDUzODAgZHJpdmVyLiAgCiAqCiAqIE5vdGVzIDogSSBhc3N1bWUgdGhhdCB0aGUgaG9zdCwgaG9zdG5vLCBhbmQgaWQgYml0cyBoYXZlIGJlZW4KICogCXNldCBjb3JyZWN0bHkuICBJIGRvbid0IGNhcmUgYWJvdXQgdGhlIGlycSBhbmQgb3RoZXIgZmllbGRzLiAKICogCiAqLwoKc3RhdGljIGludCBOQ1I1MzgwX2luaXQgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlLCBpbnQgZmxhZ3MpCnsKICAgIGludCBpOwogICAgU0VUVVBfSE9TVERBVEEoaW5zdGFuY2UpOwoKICAgIE5DUjUzODBfYWxsX2luaXQoKTsKCiAgICBob3N0ZGF0YS0+YWJvcnRlZCA9IDA7CiAgICBob3N0ZGF0YS0+aWRfbWFzayA9IDEgPDwgaW5zdGFuY2UtPnRoaXNfaWQ7CiAgICBob3N0ZGF0YS0+aWRfaGlnaGVyX21hc2sgPSAwOwogICAgZm9yIChpID0gaG9zdGRhdGEtPmlkX21hc2s7IGkgPD0gMHg4MDsgaSA8PD0gMSkKCWlmIChpID4gaG9zdGRhdGEtPmlkX21hc2spCgkgICAgaG9zdGRhdGEtPmlkX2hpZ2hlcl9tYXNrIHw9IGk7CiAgICBmb3IgKGkgPSAwOyBpIDwgODsgKytpKQoJaG9zdGRhdGEtPmJ1c3lbaV0gPSAwOwojaWZkZWYgU1VQUE9SVF9UQUdTCiAgICBpbml0X3RhZ3MoKTsKI2VuZGlmCiNpZiBkZWZpbmVkIChSRUFMX0RNQSkKICAgIGhvc3RkYXRhLT5kbWFfbGVuID0gMDsKI2VuZGlmCiAgICBob3N0ZGF0YS0+dGFyZ2V0c19wcmVzZW50ID0gMDsKICAgIGhvc3RkYXRhLT5jb25uZWN0ZWQgPSBOVUxMOwogICAgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlID0gTlVMTDsKICAgIGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUgPSBOVUxMOwogICAgaG9zdGRhdGEtPmZsYWdzID0gRkxBR19DSEVDS19MQVNUX0JZVEVfU0VOVDsKCiAgICBpZiAoIXRoZV90ZW1wbGF0ZSkgewoJdGhlX3RlbXBsYXRlID0gaW5zdGFuY2UtPmhvc3R0OwoJZmlyc3RfaW5zdGFuY2UgPSBpbnN0YW5jZTsKICAgIH0KCQoKI2lmbmRlZiBBVVRPU0VOU0UKICAgIGlmICgoaW5zdGFuY2UtPmNtZF9wZXJfbHVuID4gMSkgfHwgKGluc3RhbmNlLT5jYW5fcXVldWUgPiAxKSkKCSBwcmludGsoInNjc2klZDogV0FSTklORyA6IHN1cHBvcnQgZm9yIG11bHRpcGxlIG91dHN0YW5kaW5nIGNvbW1hbmRzIGVuYWJsZWRcbiIKCSAgICAgICAgIiAgICAgICAgd2l0aG91dCBBVVRPU0VOU0Ugb3B0aW9uLCBjb250aW5nZW50IGFsbGVnaWFuY2UgY29uZGl0aW9ucyBtYXlcbiIKCSAgICAgICAgIiAgICAgICAgYmUgaW5jb3JyZWN0bHkgY2xlYXJlZC5cbiIsIEhPU1ROTyk7CiNlbmRpZiAvKiBkZWYgQVVUT1NFTlNFICovCgogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKICAgIE5DUjUzODBfd3JpdGUoTU9ERV9SRUcsIE1SX0JBU0UpOwogICAgTkNSNTM4MF93cml0ZShUQVJHRVRfQ09NTUFORF9SRUcsIDApOwogICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgMCk7CgogICAgcmV0dXJuIDA7Cn0KCi8qIAogKiBGdW5jdGlvbiA6IGludCBOQ1I1MzgwX3F1ZXVlX2NvbW1hbmQgKFNjc2lfQ21uZCAqY21kLCAKICoJdm9pZCAoKmRvbmUpKFNjc2lfQ21uZCAqKSkgCiAqCiAqIFB1cnBvc2UgOiAgZW5xdWV1ZXMgYSBTQ1NJIGNvbW1hbmQKICoKICogSW5wdXRzIDogY21kIC0gU0NTSSBjb21tYW5kLCBkb25lIC0gZnVuY3Rpb24gY2FsbGVkIG9uIGNvbXBsZXRpb24sIHdpdGgKICoJYSBwb2ludGVyIHRvIHRoZSBjb21tYW5kIGRlc2NyaXB0b3IuCiAqIAogKiBSZXR1cm5zIDogMAogKgogKiBTaWRlIGVmZmVjdHMgOiAKICogICAgICBjbWQgaXMgYWRkZWQgdG8gdGhlIHBlciBpbnN0YW5jZSBpc3N1ZV9xdWV1ZSwgd2l0aCBtaW5vciAKICoJdHdpZGRsaW5nIGRvbmUgdG8gdGhlIGhvc3Qgc3BlY2lmaWMgZmllbGRzIG9mIGNtZC4gIElmIHRoZSAKICoJbWFpbiBjb3JvdXRpbmUgaXMgbm90IHJ1bm5pbmcsIGl0IGlzIHJlc3RhcnRlZC4KICoKICovCgpzdGF0aWMKaW50IE5DUjUzODBfcXVldWVfY29tbWFuZCAoU2NzaV9DbW5kICpjbWQsIHZvaWQgKCpkb25lKShTY3NpX0NtbmQgKikpCnsKICAgIFNFVFVQX0hPU1REQVRBKGNtZC0+ZGV2aWNlLT5ob3N0KTsKICAgIFNjc2lfQ21uZCAqdG1wOwogICAgaW50IG9sZHRvOwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKICAgIGV4dGVybiBpbnQgdXBkYXRlX3RpbWVvdXQoU2NzaV9DbW5kICogU0NzZXQsIGludCB0aW1lb3V0KTsKCiNpZiAoTkRFQlVHICYgTkRFQlVHX05PX1dSSVRFKQogICAgc3dpdGNoIChjbWQtPmNtbmRbMF0pIHsKICAgIGNhc2UgV1JJVEVfNjoKICAgIGNhc2UgV1JJVEVfMTA6CglwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogV1JJVEUgYXR0ZW1wdGVkIHdpdGggTk9fV1JJVEUgZGVidWdnaW5nIGZsYWcgc2V0XG4iLAoJICAgICAgIEhfTk8oY21kKSk7CgljbWQtPnJlc3VsdCA9IChESURfRVJST1IgPDwgMTYpOwoJZG9uZShjbWQpOwoJcmV0dXJuIDA7CiAgICB9CiNlbmRpZiAvKiAoTkRFQlVHICYgTkRFQlVHX05PX1dSSVRFKSAqLwoKCiNpZmRlZiBOQ1I1MzgwX1NUQVRTCiMgaWYgMAogICAgaWYgKCFob3N0ZGF0YS0+Y29ubmVjdGVkICYmICFob3N0ZGF0YS0+aXNzdWVfcXVldWUgJiYKCSFob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlKSB7Cglob3N0ZGF0YS0+dGltZWJhc2UgPSBqaWZmaWVzOwogICAgfQojIGVuZGlmCiMgaWZkZWYgTkNSNTM4MF9TVEFUX0xJTUlUCiAgICBpZiAoY21kLT5yZXF1ZXN0X2J1ZmZsZW4gPiBOQ1I1MzgwX1NUQVRfTElNSVQpCiMgZW5kaWYKCXN3aXRjaCAoY21kLT5jbW5kWzBdKQoJewoJICAgIGNhc2UgV1JJVEU6CgkgICAgY2FzZSBXUklURV82OgoJICAgIGNhc2UgV1JJVEVfMTA6CgkJaG9zdGRhdGEtPnRpbWVfd3JpdGVbY21kLT5kZXZpY2UtPmlkXSAtPSAoamlmZmllcyAtIGhvc3RkYXRhLT50aW1lYmFzZSk7CgkJaG9zdGRhdGEtPmJ5dGVzX3dyaXRlW2NtZC0+ZGV2aWNlLT5pZF0gKz0gY21kLT5yZXF1ZXN0X2J1ZmZsZW47CgkJaG9zdGRhdGEtPnBlbmRpbmd3Kys7CgkJYnJlYWs7CgkgICAgY2FzZSBSRUFEOgoJICAgIGNhc2UgUkVBRF82OgoJICAgIGNhc2UgUkVBRF8xMDoKCQlob3N0ZGF0YS0+dGltZV9yZWFkW2NtZC0+ZGV2aWNlLT5pZF0gLT0gKGppZmZpZXMgLSBob3N0ZGF0YS0+dGltZWJhc2UpOwoJCWhvc3RkYXRhLT5ieXRlc19yZWFkW2NtZC0+ZGV2aWNlLT5pZF0gKz0gY21kLT5yZXF1ZXN0X2J1ZmZsZW47CgkJaG9zdGRhdGEtPnBlbmRpbmdyKys7CgkJYnJlYWs7Cgl9CiNlbmRpZgoKICAgIC8qIAogICAgICogV2UgdXNlIHRoZSBob3N0X3NjcmliYmxlIGZpZWxkIGFzIGEgcG9pbnRlciB0byB0aGUgbmV4dCBjb21tYW5kICAKICAgICAqIGluIGEgcXVldWUgCiAgICAgKi8KCiAgICBORVhUKGNtZCkgPSBOVUxMOwogICAgY21kLT5zY3NpX2RvbmUgPSBkb25lOwoKICAgIGNtZC0+cmVzdWx0ID0gMDsKCgogICAgLyogCiAgICAgKiBJbnNlcnQgdGhlIGNtZCBpbnRvIHRoZSBpc3N1ZSBxdWV1ZS4gTm90ZSB0aGF0IFJFUVVFU1QgU0VOU0UgCiAgICAgKiBjb21tYW5kcyBhcmUgYWRkZWQgdG8gdGhlIGhlYWQgb2YgdGhlIHF1ZXVlIHNpbmNlIGFueSBjb21tYW5kIHdpbGwKICAgICAqIGNsZWFyIHRoZSBjb250aW5nZW50IGFsbGVnaWFuY2UgY29uZGl0aW9uIHRoYXQgZXhpc3RzIGFuZCB0aGUgCiAgICAgKiBzZW5zZSBkYXRhIGlzIG9ubHkgZ3VhcmFudGVlZCB0byBiZSB2YWxpZCB3aGlsZSB0aGUgY29uZGl0aW9uIGV4aXN0cy4KICAgICAqLwoKICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKICAgIC8qICsrZ3VlbnRoZXI6IG5vdyB0aGF0IHRoZSBpc3N1ZSBxdWV1ZSBpcyBiZWluZyBzZXQgdXAsIHdlIGNhbiBsb2NrIFNULURNQS4KICAgICAqIE90aGVyd2lzZSBhIHJ1bm5pbmcgTkNSNTM4MF9tYWluIG1heSBzdGVhbCB0aGUgbG9jay4KICAgICAqIExvY2sgYmVmb3JlIGFjdHVhbGx5IGluc2VydGluZyBkdWUgdG8gZmFpcm5lc3MgcmVhc29ucyBleHBsYWluZWQgaW4KICAgICAqIGF0YXJpX3Njc2kuYy4gSWYgd2UgaW5zZXJ0IGZpcnN0LCB0aGVuIGl0J3MgaW1wb3NzaWJsZSBmb3IgdGhpcyBkcml2ZXIKICAgICAqIHRvIHJlbGVhc2UgdGhlIGxvY2suCiAgICAgKiBTdG9wIHRpbWVyIGZvciB0aGlzIGNvbW1hbmQgd2hpbGUgd2FpdGluZyBmb3IgdGhlIGxvY2ssIG9yIHRpbWVvdXRzCiAgICAgKiBtYXkgaGFwcGVuIChhbmQgdGhleSByZWFsbHkgZG8pLCBhbmQgaXQncyBubyBnb29kIGlmIHRoZSBjb21tYW5kIGRvZXNuJ3QKICAgICAqIGFwcGVhciBpbiBhbnkgb2YgdGhlIHF1ZXVlcy4KICAgICAqICsrcm9tYW46IEp1c3QgZGlzYWJsaW5nIHRoZSBOQ1IgaW50ZXJydXB0IGlzbid0IHN1ZmZpY2llbnQgaGVyZSwKICAgICAqIGJlY2F1c2UgYWxzbyBhIHRpbWVyIGludCBjYW4gdHJpZ2dlciBhbiBhYm9ydCBvciByZXNldCwgd2hpY2ggd291bGQKICAgICAqIGFsdGVyIHF1ZXVlcyBhbmQgdG91Y2ggdGhlIGxvY2suCiAgICAgKi8KICAgIGlmICghSVNfQV9UVCgpKSB7CglvbGR0byA9IHVwZGF0ZV90aW1lb3V0KGNtZCwgMCk7CglmYWxjb25fZ2V0X2xvY2soKTsKCXVwZGF0ZV90aW1lb3V0KGNtZCwgb2xkdG8pOwogICAgfQogICAgaWYgKCEoaG9zdGRhdGEtPmlzc3VlX3F1ZXVlKSB8fCAoY21kLT5jbW5kWzBdID09IFJFUVVFU1RfU0VOU0UpKSB7CglMSVNUKGNtZCwgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlKTsKCU5FWFQoY21kKSA9IGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZTsKCWhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSA9IGNtZDsKICAgIH0gZWxzZSB7Cglmb3IgKHRtcCA9IChTY3NpX0NtbmQgKilob3N0ZGF0YS0+aXNzdWVfcXVldWU7CgkgICAgIE5FWFQodG1wKTsgdG1wID0gTkVYVCh0bXApKQoJICAgIDsKCUxJU1QoY21kLCB0bXApOwoJTkVYVCh0bXApID0gY21kOwogICAgfQogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoKICAgIFFVX1BSSU5USygic2NzaSVkOiBjb21tYW5kIGFkZGVkIHRvICVzIG9mIHF1ZXVlXG4iLCBIX05PKGNtZCksCgkgICAgICAoY21kLT5jbW5kWzBdID09IFJFUVVFU1RfU0VOU0UpID8gImhlYWQiIDogInRhaWwiKTsKCiAgICAvKiBJZiBxdWV1ZV9jb21tYW5kKCkgaXMgY2FsbGVkIGZyb20gYW4gaW50ZXJydXB0IChyZWFsIG9uZSBvciBib3R0b20KICAgICAqIGhhbGYpLCB3ZSBsZXQgcXVldWVfbWFpbigpIGRvIHRoZSBqb2Igb2YgdGFraW5nIGNhcmUgYWJvdXQgbWFpbi4gSWYgaXQKICAgICAqIGlzIGFscmVhZHkgcnVubmluZywgdGhpcyBpcyBhIG5vLW9wLCBlbHNlIG1haW4gd2lsbCBiZSBxdWV1ZWQuCiAgICAgKgogICAgICogSWYgd2UncmUgbm90IGluIGFuIGludGVycnVwdCwgd2UgY2FuIGNhbGwgTkNSNTM4MF9tYWluKCkKICAgICAqIHVuY29uZGl0aW9uYWxseSwgYmVjYXVzZSBpdCBjYW5ub3QgYmUgYWxyZWFkeSBydW5uaW5nLgogICAgICovCiAgICBpZiAoaW5faW50ZXJydXB0KCkgfHwgKChmbGFncyA+PiA4KSAmIDcpID49IDYpCglxdWV1ZV9tYWluKCk7CiAgICBlbHNlCglOQ1I1MzgwX21haW4oTlVMTCk7CiAgICByZXR1cm4gMDsKfQoKLyoKICogRnVuY3Rpb24gOiBOQ1I1MzgwX21haW4gKHZvaWQpIAogKgogKiBQdXJwb3NlIDogTkNSNTM4MF9tYWluIGlzIGEgY29yb3V0aW5lIHRoYXQgcnVucyBhcyBsb25nIGFzIG1vcmUgd29yayBjYW4gCiAqCWJlIGRvbmUgb24gdGhlIE5DUjUzODAgaG9zdCBhZGFwdGVycyBpbiBhIHN5c3RlbS4gIEJvdGggCiAqCU5DUjUzODBfcXVldWVfY29tbWFuZCgpIGFuZCBOQ1I1MzgwX2ludHIoKSB3aWxsIHRyeSB0byBzdGFydCBpdCAKICoJaW4gY2FzZSBpdCBpcyBub3QgcnVubmluZy4KICogCiAqIE5PVEUgOiBOQ1I1MzgwX21haW4gZXhpdHMgd2l0aCBpbnRlcnJ1cHRzICpkaXNhYmxlZCosIHRoZSBjYWxsZXIgc2hvdWxkIAogKiAgcmVlbmFibGUgdGhlbS4gIFRoaXMgcHJldmVudHMgcmVlbnRyYW5jeSBhbmQga2VybmVsIHN0YWNrIG92ZXJmbG93LgogKi8gCQogICAgCnN0YXRpYyB2b2lkIE5DUjUzODBfbWFpbiAodm9pZCAqYmwpCnsKICAgIFNjc2lfQ21uZCAqdG1wLCAqcHJldjsKICAgIHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlID0gZmlyc3RfaW5zdGFuY2U7CiAgICBzdHJ1Y3QgTkNSNTM4MF9ob3N0ZGF0YSAqaG9zdGRhdGEgPSBIT1NUREFUQShpbnN0YW5jZSk7CiAgICBpbnQgZG9uZTsKICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7CiAgICAKICAgIC8qCiAgICAgKiBXZSBydW4gKHdpdGggaW50ZXJydXB0cyBkaXNhYmxlZCkgdW50aWwgd2UncmUgc3VyZSB0aGF0IG5vbmUgb2YgCiAgICAgKiB0aGUgaG9zdCBhZGFwdGVycyBoYXZlIGFueXRoaW5nIHRoYXQgY2FuIGJlIGRvbmUsIGF0IHdoaWNoIHBvaW50IAogICAgICogd2Ugc2V0IG1haW5fcnVubmluZyB0byAwIGFuZCBleGl0LgogICAgICoKICAgICAqIEludGVycnVwdHMgYXJlIGVuYWJsZWQgYmVmb3JlIGRvaW5nIHZhcmlvdXMgb3RoZXIgaW50ZXJuYWwgCiAgICAgKiBpbnN0cnVjdGlvbnMsIGFmdGVyIHdlJ3ZlIGRlY2lkZWQgdGhhdCB3ZSBuZWVkIHRvIHJ1biB0aHJvdWdoCiAgICAgKiB0aGUgbG9vcCBhZ2Fpbi4KICAgICAqCiAgICAgKiB0aGlzIHNob3VsZCBwcmV2ZW50IGFueSByYWNlIGNvbmRpdGlvbnMuCiAgICAgKiAKICAgICAqICsrcm9tYW46IEp1c3QgZGlzYWJsaW5nIHRoZSBOQ1IgaW50ZXJydXB0IGlzbid0IHN1ZmZpY2llbnQgaGVyZSwKICAgICAqIGJlY2F1c2UgYWxzbyBhIHRpbWVyIGludCBjYW4gdHJpZ2dlciBhbiBhYm9ydCBvciByZXNldCwgd2hpY2ggY2FuCiAgICAgKiBhbHRlciBxdWV1ZXMgYW5kIHRvdWNoIHRoZSBGYWxjb24gbG9jay4KICAgICAqLwoKICAgIC8qIFRlbGwgaW50IGhhbmRsZXJzIG1haW4oKSBpcyBub3cgYWxyZWFkeSBleGVjdXRpbmcuICBOb3RlIHRoYXQKICAgICAgIG5vIHJhY2VzIGFyZSBwb3NzaWJsZSBoZXJlLiBJZiBhbiBpbnQgY29tZXMgaW4gYmVmb3JlCiAgICAgICAnbWFpbl9ydW5uaW5nJyBpcyBzZXQgaGVyZSwgYW5kIHF1ZXVlcy9leGVjdXRlcyBtYWluIHZpYSB0aGUKICAgICAgIHRhc2sgcXVldWUsIGl0IGRvZXNuJ3QgZG8gYW55IGhhcm0sIGp1c3QgdGhpcyBpbnN0YW5jZSBvZiBtYWluCiAgICAgICB3b24ndCBmaW5kIGFueSB3b3JrIGxlZnQgdG8gZG8uICovCiAgICBpZiAobWFpbl9ydW5uaW5nKQogICAgCXJldHVybjsKICAgIG1haW5fcnVubmluZyA9IDE7CgogICAgbG9jYWxfc2F2ZV9mbGFncyhmbGFncyk7CiAgICBkbyB7Cglsb2NhbF9pcnFfZGlzYWJsZSgpOyAvKiBGcmVlemUgcmVxdWVzdCBxdWV1ZXMgKi8KCWRvbmUgPSAxOwoJCglpZiAoIWhvc3RkYXRhLT5jb25uZWN0ZWQpIHsKCSAgICBNQUlOX1BSSU5USyggInNjc2klZDogbm90IGNvbm5lY3RlZFxuIiwgSE9TVE5PICk7CgkgICAgLyoKCSAgICAgKiBTZWFyY2ggdGhyb3VnaCB0aGUgaXNzdWVfcXVldWUgZm9yIGEgY29tbWFuZCBkZXN0aW5lZAoJICAgICAqIGZvciBhIHRhcmdldCB0aGF0J3Mgbm90IGJ1c3kuCgkgICAgICovCiNpZiAoTkRFQlVHICYgTkRFQlVHX0xJU1RTKQoJICAgIGZvciAodG1wID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+aXNzdWVfcXVldWUsIHByZXYgPSBOVUxMOwoJCSB0bXAgJiYgKHRtcCAhPSBwcmV2KTsgcHJldiA9IHRtcCwgdG1wID0gTkVYVCh0bXApKQoJCTsKCQkvKnByaW50aygiJXAgICIsIHRtcCk7Ki8KCSAgICBpZiAoKHRtcCA9PSBwcmV2KSAmJiB0bXApIHByaW50aygiIExPT1BcbiIpOy8qIGVsc2UgcHJpbnRrKCJcbiIpOyovCiNlbmRpZgoJICAgIGZvciAodG1wID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+aXNzdWVfcXVldWUsIAoJCSBwcmV2ID0gTlVMTDsgdG1wOyBwcmV2ID0gdG1wLCB0bXAgPSBORVhUKHRtcCkgKSB7CgojaWYgKE5ERUJVRyAmIE5ERUJVR19MSVNUUykKCQlpZiAocHJldiAhPSB0bXApCgkJICAgIHByaW50aygiTUFJTiB0bXA9JXAgICB0YXJnZXQ9JWQgICBidXN5PSVkIGx1bj0lZFxuIiwKCQkJICAgdG1wLCB0bXAtPmRldmljZS0+aWQsIGhvc3RkYXRhLT5idXN5W3RtcC0+ZGV2aWNlLT5pZF0sCgkJCSAgIHRtcC0+ZGV2aWNlLT5sdW4pOwojZW5kaWYKCQkvKiAgV2hlbiB3ZSBmaW5kIG9uZSwgcmVtb3ZlIGl0IGZyb20gdGhlIGlzc3VlIHF1ZXVlLiAqLwoJCS8qICsrZ3VlbnRoZXI6IHBvc3NpYmxlIHJhY2Ugd2l0aCBGYWxjb24gbG9ja2luZyAqLwoJCWlmICgKI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSAgICAhaXNfbHVuX2J1c3koIHRtcCwgdG1wLT5jbW5kWzBdICE9IFJFUVVFU1RfU0VOU0UpCiNlbHNlCgkJICAgICEoaG9zdGRhdGEtPmJ1c3lbdG1wLT5kZXZpY2UtPmlkXSAmICgxIDw8IHRtcC0+ZGV2aWNlLT5sdW4pKQojZW5kaWYKCQkgICAgKSB7CgkJICAgIC8qICsrZ3VlbnRoZXI6IGp1c3QgdG8gYmUgc3VyZSwgdGhpcyBtdXN0IGJlIGF0b21pYyAqLwoJCSAgICBsb2NhbF9pcnFfZGlzYWJsZSgpOwoJCSAgICBpZiAocHJldikgewoJCSAgICAgICAgUkVNT1ZFKHByZXYsIE5FWFQocHJldiksIHRtcCwgTkVYVCh0bXApKTsKCQkJTkVYVChwcmV2KSA9IE5FWFQodG1wKTsKCQkgICAgfSBlbHNlIHsKCQkgICAgICAgIFJFTU9WRSgtMSwgaG9zdGRhdGEtPmlzc3VlX3F1ZXVlLCB0bXAsIE5FWFQodG1wKSk7CgkJCWhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSA9IE5FWFQodG1wKTsKCQkgICAgfQoJCSAgICBORVhUKHRtcCkgPSBOVUxMOwoJCSAgICBmYWxjb25fZG9udF9yZWxlYXNlKys7CgkJICAgIAoJCSAgICAvKiByZWVuYWJsZSBpbnRlcnJ1cHRzIGFmdGVyIGZpbmRpbmcgb25lICovCgkJICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCQkgICAgCgkJICAgIC8qIAoJCSAgICAgKiBBdHRlbXB0IHRvIGVzdGFibGlzaCBhbiBJX1RfTCBuZXh1cyBoZXJlLiAKCQkgICAgICogT24gc3VjY2VzcywgaW5zdGFuY2UtPmhvc3RkYXRhLT5jb25uZWN0ZWQgaXMgc2V0LgoJCSAgICAgKiBPbiBmYWlsdXJlLCB3ZSBtdXN0IGFkZCB0aGUgY29tbWFuZCBiYWNrIHRvIHRoZQoJCSAgICAgKiAgIGlzc3VlIHF1ZXVlIHNvIHdlIGNhbiBrZWVwIHRyeWluZy4JCgkJICAgICAqLwoJCSAgICBNQUlOX1BSSU5USygic2NzaSVkOiBtYWluKCk6IGNvbW1hbmQgZm9yIHRhcmdldCAlZCAiCgkJCQkibHVuICVkIHJlbW92ZWQgZnJvbSBpc3N1ZV9xdWV1ZVxuIiwKCQkJCUhPU1ROTywgdG1wLT5kZXZpY2UtPmlkLCB0bXAtPmRldmljZS0+bHVuKTsKCQkgICAgLyogCgkJICAgICAqIFJFUVVFU1QgU0VOU0UgY29tbWFuZHMgYXJlIGlzc3VlZCB3aXRob3V0IHRhZ2dlZAoJCSAgICAgKiBxdWV1ZWluZywgZXZlbiBvbiBTQ1NJLUlJIGRldmljZXMgYmVjYXVzZSB0aGUgCgkJICAgICAqIGNvbnRpbmdlbnQgYWxsZWdpYW5jZSBjb25kaXRpb24gZXhpc3RzIGZvciB0aGUgCgkJICAgICAqIGVudGlyZSB1bml0LgoJCSAgICAgKi8KCQkgICAgLyogKytyb21hbjogLi4uYW5kIHRoZSBzdGFuZGFyZCBhbHNvIHJlcXVpcmVzIHRoYXQKCQkgICAgICogUkVRVUVTVCBTRU5TRSBjb21tYW5kIGFyZSB1bnRhZ2dlZC4KCQkgICAgICovCgkJICAgIAojaWZkZWYgU1VQUE9SVF9UQUdTCgkJICAgIGNtZF9nZXRfdGFnKCB0bXAsIHRtcC0+Y21uZFswXSAhPSBSRVFVRVNUX1NFTlNFICk7CiNlbmRpZgoJCSAgICBpZiAoIU5DUjUzODBfc2VsZWN0KGluc3RhbmNlLCB0bXAsIAoJCQkgICAgKHRtcC0+Y21uZFswXSA9PSBSRVFVRVNUX1NFTlNFKSA/IFRBR19OT05FIDogCgkJCSAgICBUQUdfTkVYVCkpIHsKCQkJZmFsY29uX2RvbnRfcmVsZWFzZS0tOwoJCQkvKiByZWxlYXNlIGlmIHRhcmdldCBkaWQgbm90IHJlc3BvbnNlISAqLwoJCQlmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOwoJCQlicmVhazsKCQkgICAgfSBlbHNlIHsKCQkJbG9jYWxfaXJxX2Rpc2FibGUoKTsKCQkJTElTVCh0bXAsIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSk7CgkJCU5FWFQodG1wKSA9IGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZTsKCQkJaG9zdGRhdGEtPmlzc3VlX3F1ZXVlID0gdG1wOwojaWZkZWYgU1VQUE9SVF9UQUdTCgkJCWNtZF9mcmVlX3RhZyggdG1wICk7CiNlbmRpZgoJCQlmYWxjb25fZG9udF9yZWxlYXNlLS07CgkJCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCQkJTUFJTl9QUklOVEsoInNjc2klZDogbWFpbigpOiBzZWxlY3QoKSBmYWlsZWQsICIKCQkJCSAgICAicmV0dXJuZWQgdG8gaXNzdWVfcXVldWVcbiIsIEhPU1ROTyk7CgkJCWlmIChob3N0ZGF0YS0+Y29ubmVjdGVkKQoJCQkgICAgYnJlYWs7CgkJICAgIH0KCQl9IC8qIGlmIHRhcmdldC9sdW4vdGFyZ2V0IHF1ZXVlIGlzIG5vdCBidXN5ICovCgkgICAgfSAvKiBmb3IgaXNzdWVfcXVldWUgKi8KCX0gLyogaWYgKCFob3N0ZGF0YS0+Y29ubmVjdGVkKSAqLwoJCQoJaWYgKGhvc3RkYXRhLT5jb25uZWN0ZWQgCiNpZmRlZiBSRUFMX0RNQQoJICAgICYmICFob3N0ZGF0YS0+ZG1hX2xlbgojZW5kaWYKCSAgICApIHsKCSAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkgICAgTUFJTl9QUklOVEsoInNjc2klZDogbWFpbjogcGVyZm9ybWluZyBpbmZvcm1hdGlvbiB0cmFuc2ZlclxuIiwKCQkJSE9TVE5PKTsKCSAgICBOQ1I1MzgwX2luZm9ybWF0aW9uX3RyYW5zZmVyKGluc3RhbmNlKTsKCSAgICBNQUlOX1BSSU5USygic2NzaSVkOiBtYWluOiBkb25lIHNldCBmYWxzZVxuIiwgSE9TVE5PKTsKCSAgICBkb25lID0gMDsKCX0KICAgIH0gd2hpbGUgKCFkb25lKTsKCiAgICAvKiBCZXR0ZXIgYWxsb3cgaW50cyBfYWZ0ZXJfICdtYWluX3J1bm5pbmcnIGhhcyBiZWVuIGNsZWFyZWQsIGVsc2UKICAgICAgIGFuIGludGVycnVwdCBjb3VsZCBiZWxpZXZlIHdlJ2xsIHBpY2sgdXAgdGhlIHdvcmsgaXQgbGVmdCBmb3IKICAgICAgIHVzLCBidXQgd2Ugd29uJ3Qgc2VlIGl0IGFueW1vcmUgaGVyZS4uLiAqLwogICAgbWFpbl9ydW5uaW5nID0gMDsKICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKfQoKCiNpZmRlZiBSRUFMX0RNQQovKgogKiBGdW5jdGlvbiA6IHZvaWQgTkNSNTM4MF9kbWFfY29tcGxldGUgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlKQogKgogKiBQdXJwb3NlIDogQ2FsbGVkIGJ5IGludGVycnVwdCBoYW5kbGVyIHdoZW4gRE1BIGZpbmlzaGVzIG9yIGEgcGhhc2UKICoJbWlzbWF0Y2ggb2NjdXJzICh3aGljaCB3b3VsZCBmaW5pc2ggdGhlIERNQSB0cmFuc2ZlcikuICAKICoKICogSW5wdXRzIDogaW5zdGFuY2UgLSB0aGlzIGluc3RhbmNlIG9mIHRoZSBOQ1I1MzgwLgogKgogKi8KCnN0YXRpYyB2b2lkIE5DUjUzODBfZG1hX2NvbXBsZXRlKCBzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSApCnsKICAgIFNFVFVQX0hPU1REQVRBKGluc3RhbmNlKTsKICAgIGludCAgICAgICAgICAgdHJhbnNmZXJlZCwgc2F2ZWRfZGF0YSA9IDAsIG92ZXJydW4gPSAwLCBjbnQsIHRvUElPOwogICAgdW5zaWduZWQgY2hhciAqKmRhdGEsIHA7CiAgICB2b2xhdGlsZSBpbnQgICpjb3VudDsKCiAgICBpZiAoIWhvc3RkYXRhLT5jb25uZWN0ZWQpIHsKCXByaW50ayhLRVJOX1dBUk5JTkcgInNjc2klZDogcmVjZWl2ZWQgZW5kIG9mIERNQSBpbnRlcnJ1cHQgd2l0aCAiCgkgICAgICAgIm5vIGNvbm5lY3RlZCBjbWRcbiIsIEhPU1ROTyk7CglyZXR1cm47CiAgICB9CiAgICAKICAgIGlmIChhdGFyaV9yZWFkX292ZXJydW5zKSB7CglwID0gaG9zdGRhdGEtPmNvbm5lY3RlZC0+U0NwLnBoYXNlOwoJaWYgKHAgJiBTUl9JTykgewoJICAgIHVkZWxheSgxMCk7CgkgICAgaWYgKCgoKE5DUjUzODBfcmVhZChCVVNfQU5EX1NUQVRVU19SRUcpKSAmCgkJICAoQkFTUl9QSEFTRV9NQVRDSHxCQVNSX0FDSykpID09CgkJIChCQVNSX1BIQVNFX01BVENIfEJBU1JfQUNLKSkpIHsKCQlzYXZlZF9kYXRhID0gTkNSNTM4MF9yZWFkKElOUFVUX0RBVEFfUkVHKTsKCQlvdmVycnVuID0gMTsKCQlETUFfUFJJTlRLKCJzY3NpJWQ6IHJlYWQgb3ZlcnJ1biBoYW5kbGVkXG4iLCBIT1NUTk8pOwoJICAgIH0KCX0KICAgIH0KCiAgICBETUFfUFJJTlRLKCJzY3NpJWQ6IHJlYWwgRE1BIHRyYW5zZmVyIGNvbXBsZXRlLCBiYXNyIDB4JVgsIHNyIDB4JVhcbiIsCgkgICAgICAgSE9TVE5PLCBOQ1I1MzgwX3JlYWQoQlVTX0FORF9TVEFUVVNfUkVHKSwKCSAgICAgICBOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykpOwoKICAgICh2b2lkKSBOQ1I1MzgwX3JlYWQoUkVTRVRfUEFSSVRZX0lOVEVSUlVQVF9SRUcpOwogICAgTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7CiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoKICAgIHRyYW5zZmVyZWQgPSBob3N0ZGF0YS0+ZG1hX2xlbiAtIE5DUjUzODBfZG1hX3Jlc2lkdWFsKGluc3RhbmNlKTsKICAgIGhvc3RkYXRhLT5kbWFfbGVuID0gMDsKCiAgICBkYXRhID0gKHVuc2lnbmVkIGNoYXIgKiopICYoaG9zdGRhdGEtPmNvbm5lY3RlZC0+U0NwLnB0cik7CiAgICBjb3VudCA9ICYoaG9zdGRhdGEtPmNvbm5lY3RlZC0+U0NwLnRoaXNfcmVzaWR1YWwpOwogICAgKmRhdGEgKz0gdHJhbnNmZXJlZDsKICAgICpjb3VudCAtPSB0cmFuc2ZlcmVkOwoKICAgIGlmIChhdGFyaV9yZWFkX292ZXJydW5zKSB7CglpZiAoKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFBIQVNFX01BU0spID09IHAgJiYgKHAgJiBTUl9JTykpIHsKCSAgICBjbnQgPSB0b1BJTyA9IGF0YXJpX3JlYWRfb3ZlcnJ1bnM7CgkgICAgaWYgKG92ZXJydW4pIHsKCQlETUFfUFJJTlRLKCJHb3QgYW4gaW5wdXQgb3ZlcnJ1biwgdXNpbmcgc2F2ZWQgYnl0ZVxuIik7CgkJKigqZGF0YSkrKyA9IHNhdmVkX2RhdGE7CgkJKCpjb3VudCktLTsKCQljbnQtLTsKCQl0b1BJTy0tOwoJICAgIH0KCSAgICBETUFfUFJJTlRLKCJEb2luZyAlZC1ieXRlIFBJTyB0byAweCUwOGx4XG4iLCBjbnQsIChsb25nKSpkYXRhKTsKCSAgICBOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnAsICZjbnQsIGRhdGEpOwoJICAgICpjb3VudCAtPSB0b1BJTyAtIGNudDsKCX0KICAgIH0KfQojZW5kaWYgLyogUkVBTF9ETUEgKi8KCgovKgogKiBGdW5jdGlvbiA6IHZvaWQgTkNSNTM4MF9pbnRyIChpbnQgaXJxKQogKiAKICogUHVycG9zZSA6IGhhbmRsZSBpbnRlcnJ1cHRzLCByZWVzdGFibGlzaGluZyBJX1RfTCBvciBJX1RfTF9RIG5leHVzZXMKICoJZnJvbSB0aGUgZGlzY29ubmVjdGVkIHF1ZXVlLCBhbmQgcmVzdGFydGluZyBOQ1I1MzgwX21haW4oKSAKICoJYXMgcmVxdWlyZWQuCiAqCiAqIElucHV0cyA6IGludCBpcnEsIGlycSB0aGF0IGNhdXNlZCB0aGlzIGludGVycnVwdC4KICoKICovCgpzdGF0aWMgaXJxcmV0dXJuX3QgTkNSNTM4MF9pbnRyIChpbnQgaXJxLCB2b2lkICpkZXZfaWQpCnsKICAgIHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlID0gZmlyc3RfaW5zdGFuY2U7CiAgICBpbnQgZG9uZSA9IDEsIGhhbmRsZWQgPSAwOwogICAgdW5zaWduZWQgY2hhciBiYXNyOwoKICAgIElOVF9QUklOVEsoInNjc2klZDogTkNSNTM4MCBpcnEgdHJpZ2dlcmVkXG4iLCBIT1NUTk8pOwoKICAgIC8qIExvb2sgZm9yIHBlbmRpbmcgaW50ZXJydXB0cyAqLwogICAgYmFzciA9IE5DUjUzODBfcmVhZChCVVNfQU5EX1NUQVRVU19SRUcpOwogICAgSU5UX1BSSU5USygic2NzaSVkOiBCQVNSPSUwMnhcbiIsIEhPU1ROTywgYmFzcik7CiAgICAvKiBkaXNwYXRjaCB0byBhcHByb3ByaWF0ZSByb3V0aW5lIGlmIGZvdW5kIGFuZCBkb25lPTAgKi8KICAgIGlmIChiYXNyICYgQkFTUl9JUlEpIHsKCU5DUl9QUklOVChOREVCVUdfSU5UUik7CglpZiAoKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIChTUl9TRUx8U1JfSU8pKSA9PSAoU1JfU0VMfFNSX0lPKSkgewoJICAgIGRvbmUgPSAwOwoJICAgIEVOQUJMRV9JUlEoKTsKCSAgICBJTlRfUFJJTlRLKCJzY3NpJWQ6IFNFTCBpbnRlcnJ1cHRcbiIsIEhPU1ROTyk7CgkgICAgTkNSNTM4MF9yZXNlbGVjdChpbnN0YW5jZSk7CgkgICAgKHZvaWQpIE5DUjUzODBfcmVhZChSRVNFVF9QQVJJVFlfSU5URVJSVVBUX1JFRyk7Cgl9CgllbHNlIGlmIChiYXNyICYgQkFTUl9QQVJJVFlfRVJST1IpIHsKCSAgICBJTlRfUFJJTlRLKCJzY3NpJWQ6IFBBUklUWSBpbnRlcnJ1cHRcbiIsIEhPU1ROTyk7CgkgICAgKHZvaWQpIE5DUjUzODBfcmVhZChSRVNFVF9QQVJJVFlfSU5URVJSVVBUX1JFRyk7Cgl9CgllbHNlIGlmICgoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfUlNUKSA9PSBTUl9SU1QpIHsKCSAgICBJTlRfUFJJTlRLKCJzY3NpJWQ6IFJFU0VUIGludGVycnVwdFxuIiwgSE9TVE5PKTsKCSAgICAodm9pZClOQ1I1MzgwX3JlYWQoUkVTRVRfUEFSSVRZX0lOVEVSUlVQVF9SRUcpOwoJfQoJZWxzZSB7CgkgICAgLyogIAoJICAgICAqIFRoZSByZXN0IG9mIHRoZSBpbnRlcnJ1cHQgY29uZGl0aW9ucyBjYW4gb2NjdXIgb25seSBkdXJpbmcgYQoJICAgICAqIERNQSB0cmFuc2ZlcgoJICAgICAqLwoKI2lmIGRlZmluZWQoUkVBTF9ETUEpCgkgICAgLyoKCSAgICAgKiBXZSBzaG91bGQgb25seSBnZXQgUEhBU0UgTUlTTUFUQ0ggYW5kIEVPUCBpbnRlcnJ1cHRzIGlmIHdlIGhhdmUKCSAgICAgKiBETUEgZW5hYmxlZCwgc28gZG8gYSBzYW5pdHkgY2hlY2sgYmFzZWQgb24gdGhlIGN1cnJlbnQgc2V0dGluZwoJICAgICAqIG9mIHRoZSBNT0RFIHJlZ2lzdGVyLgoJICAgICAqLwoKCSAgICBpZiAoKE5DUjUzODBfcmVhZChNT0RFX1JFRykgJiBNUl9ETUFfTU9ERSkgJiYKCQkoKGJhc3IgJiBCQVNSX0VORF9ETUFfVFJBTlNGRVIpIHx8IAoJCSAhKGJhc3IgJiBCQVNSX1BIQVNFX01BVENIKSkpIHsKCQkgICAgCgkJSU5UX1BSSU5USygic2NzaSVkOiBQSEFTRSBNSVNNIG9yIEVPUCBpbnRlcnJ1cHRcbiIsIEhPU1ROTyk7CgkJTkNSNTM4MF9kbWFfY29tcGxldGUoIGluc3RhbmNlICk7CgkJZG9uZSA9IDA7CgkJRU5BQkxFX0lSUSgpOwoJICAgIH0gZWxzZQojZW5kaWYgLyogUkVBTF9ETUEgKi8KCSAgICB7Ci8qIE1TOiBJZ25vcmUgdW5rbm93biBwaGFzZSBtaXNtYXRjaCBpbnRlcnJ1cHRzIChjYXVzZWQgYnkgRU9QIGludGVycnVwdCkgKi8KCQlpZiAoYmFzciAmIEJBU1JfUEhBU0VfTUFUQ0gpCgkJICAgIHByaW50ayhLRVJOX05PVElDRSAic2NzaSVkOiB1bmtub3duIGludGVycnVwdCwgIgoJCQkgICAiQkFTUiAweCV4LCBNUiAweCV4LCBTUiAweCV4XG4iLAoJCQkgICBIT1NUTk8sIGJhc3IsIE5DUjUzODBfcmVhZChNT0RFX1JFRyksCgkJCSAgIE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSk7CgkJKHZvaWQpIE5DUjUzODBfcmVhZChSRVNFVF9QQVJJVFlfSU5URVJSVVBUX1JFRyk7CgkgICAgfQoJfSAvKiBpZiAhKFNFTEVDVElPTiB8fCBQQVJJVFkpICovCgloYW5kbGVkID0gMTsKICAgIH0gLyogQkFTUiAmIElSUSAqLwogICAgZWxzZSB7CglwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogaW50ZXJydXB0IHdpdGhvdXQgSVJRIGJpdCBzZXQgaW4gQkFTUiwgIgoJICAgICAgICJCQVNSIDB4JVgsIE1SIDB4JVgsIFNSIDB4JXhcbiIsIEhPU1ROTywgYmFzciwKCSAgICAgICBOQ1I1MzgwX3JlYWQoTU9ERV9SRUcpLCBOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykpOwoJKHZvaWQpIE5DUjUzODBfcmVhZChSRVNFVF9QQVJJVFlfSU5URVJSVVBUX1JFRyk7CiAgICB9CiAgICAKICAgIGlmICghZG9uZSkgewoJSU5UX1BSSU5USygic2NzaSVkOiBpbiBpbnQgcm91dGluZSwgY2FsbGluZyBtYWluXG4iLCBIT1NUTk8pOwoJLyogUHV0IGEgY2FsbCB0byBOQ1I1MzgwX21haW4oKSBvbiB0aGUgcXVldWUuLi4gKi8KCXF1ZXVlX21haW4oKTsKICAgIH0KICAgIHJldHVybiBJUlFfUkVUVkFMKGhhbmRsZWQpOwp9CgojaWZkZWYgTkNSNTM4MF9TVEFUUwpzdGF0aWMgdm9pZCBjb2xsZWN0X3N0YXRzKHN0cnVjdCBOQ1I1MzgwX2hvc3RkYXRhKiBob3N0ZGF0YSwgU2NzaV9DbW5kKiBjbWQpCnsKIyBpZmRlZiBOQ1I1MzgwX1NUQVRfTElNSVQKICAgIGlmIChjbWQtPnJlcXVlc3RfYnVmZmxlbiA+IE5DUjUzODBfU1RBVF9MSU1JVCkKIyBlbmRpZgoJc3dpdGNoIChjbWQtPmNtbmRbMF0pCgl7CgkgICAgY2FzZSBXUklURToKCSAgICBjYXNlIFdSSVRFXzY6CgkgICAgY2FzZSBXUklURV8xMDoKCQlob3N0ZGF0YS0+dGltZV93cml0ZVtjbWQtPmRldmljZS0+aWRdICs9IChqaWZmaWVzIC0gaG9zdGRhdGEtPnRpbWViYXNlKTsKCQkvKmhvc3RkYXRhLT5ieXRlc193cml0ZVtjbWQtPmRldmljZS0+aWRdICs9IGNtZC0+cmVxdWVzdF9idWZmbGVuOyovCgkJaG9zdGRhdGEtPnBlbmRpbmd3LS07CgkJYnJlYWs7CgkgICAgY2FzZSBSRUFEOgoJICAgIGNhc2UgUkVBRF82OgoJICAgIGNhc2UgUkVBRF8xMDoKCQlob3N0ZGF0YS0+dGltZV9yZWFkW2NtZC0+ZGV2aWNlLT5pZF0gKz0gKGppZmZpZXMgLSBob3N0ZGF0YS0+dGltZWJhc2UpOwoJCS8qaG9zdGRhdGEtPmJ5dGVzX3JlYWRbY21kLT5kZXZpY2UtPmlkXSArPSBjbWQtPnJlcXVlc3RfYnVmZmxlbjsqLwoJCWhvc3RkYXRhLT5wZW5kaW5nci0tOwoJCWJyZWFrOwoJfQp9CiNlbmRpZgoKLyogCiAqIEZ1bmN0aW9uIDogaW50IE5DUjUzODBfc2VsZWN0IChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSwgU2NzaV9DbW5kICpjbWQsIAogKglpbnQgdGFnKTsKICoKICogUHVycG9zZSA6IGVzdGFibGlzaGVzIElfVF9MIG9yIElfVF9MX1EgbmV4dXMgZm9yIG5ldyBvciBleGlzdGluZyBjb21tYW5kLAogKglpbmNsdWRpbmcgQVJCSVRSQVRJT04sIFNFTEVDVElPTiwgYW5kIGluaXRpYWwgbWVzc2FnZSBvdXQgZm9yIAogKglJREVOVElGWSBhbmQgcXVldWUgbWVzc2FnZXMuIAogKgogKiBJbnB1dHMgOiBpbnN0YW5jZSAtIGluc3RhbnRpYXRpb24gb2YgdGhlIDUzODAgZHJpdmVyIG9uIHdoaWNoIHRoaXMgCiAqIAl0YXJnZXQgbGl2ZXMsIGNtZCAtIFNDU0kgY29tbWFuZCB0byBleGVjdXRlLCB0YWcgLSBzZXQgdG8gVEFHX05FWFQgZm9yIAogKgluZXcgdGFnLCBUQUdfTk9ORSBmb3IgdW50YWdnZWQgcXVldWVpbmcsIG90aGVyd2lzZSBzZXQgdG8gdGhlIHRhZyBmb3IgCiAqCXRoZSBjb21tYW5kIHRoYXQgaXMgcHJlc2VudGx5IGNvbm5lY3RlZC4KICogCiAqIFJldHVybnMgOiAtMSBpZiBzZWxlY3Rpb24gY291bGQgbm90IGV4ZWN1dGUgZm9yIHNvbWUgcmVhc29uLAogKgkwIGlmIHNlbGVjdGlvbiBzdWNjZWVkZWQgb3IgZmFpbGVkIGJlY2F1c2UgdGhlIHRhcmdldCAKICogCWRpZCBub3QgcmVzcG9uZC4KICoKICogU2lkZSBlZmZlY3RzIDogCiAqIAlJZiBidXMgYnVzeSwgYXJiaXRyYXRpb24gZmFpbGVkLCBldGMsIE5DUjUzODBfc2VsZWN0KCkgd2lsbCBleGl0IAogKgkJd2l0aCByZWdpc3RlcnMgYXMgdGhleSBzaG91bGQgaGF2ZSBiZWVuIG9uIGVudHJ5IC0gaWUKICoJCVNFTEVDVF9FTkFCTEUgd2lsbCBiZSBzZXQgYXBwcm9wcmlhdGVseSwgdGhlIE5DUjUzODAKICoJCXdpbGwgY2Vhc2UgdG8gZHJpdmUgYW55IFNDU0kgYnVzIHNpZ25hbHMuCiAqCiAqCUlmIHN1Y2Nlc3NmdWwgOiBJX1RfTCBvciBJX1RfTF9RIG5leHVzIHdpbGwgYmUgZXN0YWJsaXNoZWQsIAogKgkJaW5zdGFuY2UtPmNvbm5lY3RlZCB3aWxsIGJlIHNldCB0byBjbWQuICAKICogCQlTRUxFQ1QgaW50ZXJydXB0IHdpbGwgYmUgZGlzYWJsZWQuCiAqCiAqCUlmIGZhaWxlZCAobm8gdGFyZ2V0KSA6IGNtZC0+c2NzaV9kb25lKCkgd2lsbCBiZSBjYWxsZWQsIGFuZCB0aGUgCiAqCQljbWQtPnJlc3VsdCBob3N0IGJ5dGUgc2V0IHRvIERJRF9CQURfVEFSR0VULgogKi8KCnN0YXRpYyBpbnQgTkNSNTM4MF9zZWxlY3QgKHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlLCBTY3NpX0NtbmQgKmNtZCwgaW50IHRhZykKewogICAgU0VUVVBfSE9TVERBVEEoaW5zdGFuY2UpOwogICAgdW5zaWduZWQgY2hhciB0bXBbM10sIHBoYXNlOwogICAgdW5zaWduZWQgY2hhciAqZGF0YTsKICAgIGludCBsZW47CiAgICB1bnNpZ25lZCBsb25nIHRpbWVvdXQ7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwoKICAgIGhvc3RkYXRhLT5yZXN0YXJ0X3NlbGVjdCA9IDA7CiAgICBOQ1JfUFJJTlQoTkRFQlVHX0FSQklUUkFUSU9OKTsKICAgIEFSQl9QUklOVEsoInNjc2klZDogc3RhcnRpbmcgYXJiaXRyYXRpb24sIGlkID0gJWRcbiIsIEhPU1ROTywKCSAgICAgICBpbnN0YW5jZS0+dGhpc19pZCk7CgogICAgLyogCiAgICAgKiBTZXQgdGhlIHBoYXNlIGJpdHMgdG8gMCwgb3RoZXJ3aXNlIHRoZSBOQ1I1MzgwIHdvbid0IGRyaXZlIHRoZSAKICAgICAqIGRhdGEgYnVzIGR1cmluZyBTRUxFQ1RJT04uCiAgICAgKi8KCiAgICBsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAgICBpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCkgewoJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJcmV0dXJuIC0xOwogICAgfQogICAgTkNSNTM4MF93cml0ZShUQVJHRVRfQ09NTUFORF9SRUcsIDApOwoKCiAgICAvKiAKICAgICAqIFN0YXJ0IGFyYml0cmF0aW9uLgogICAgICovCiAgICAKICAgIE5DUjUzODBfd3JpdGUoT1VUUFVUX0RBVEFfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CiAgICBOQ1I1MzgwX3dyaXRlKE1PREVfUkVHLCBNUl9BUkJJVFJBVEUpOwoKICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCiAgICAvKiBXYWl0IGZvciBhcmJpdHJhdGlvbiBsb2dpYyB0byBjb21wbGV0ZSAqLwojaWYgTkNSX1RJTUVPVVQKICAgIHsKICAgICAgdW5zaWduZWQgbG9uZyB0aW1lb3V0ID0gamlmZmllcyArIDIqTkNSX1RJTUVPVVQ7CgogICAgICB3aGlsZSAoIShOQ1I1MzgwX3JlYWQoSU5JVElBVE9SX0NPTU1BTkRfUkVHKSAmIElDUl9BUkJJVFJBVElPTl9QUk9HUkVTUykKCSAgICYmIHRpbWVfYmVmb3JlKGppZmZpZXMsIHRpbWVvdXQpICYmICFob3N0ZGF0YS0+Y29ubmVjdGVkKQoJOwogICAgICBpZiAodGltZV9hZnRlcl9lcShqaWZmaWVzLCB0aW1lb3V0KSkKICAgICAgewoJcHJpbnRrKCJzY3NpIDogYXJiaXRyYXRpb24gdGltZW91dCBhdCAlZFxuIiwgX19MSU5FX18pOwoJTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7CglOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CglyZXR1cm4gLTE7CiAgICAgIH0KICAgIH0KI2Vsc2UgLyogTkNSX1RJTUVPVVQgKi8KICAgIHdoaWxlICghKE5DUjUzODBfcmVhZChJTklUSUFUT1JfQ09NTUFORF9SRUcpICYgSUNSX0FSQklUUkFUSU9OX1BST0dSRVNTKQoJICYmICFob3N0ZGF0YS0+Y29ubmVjdGVkKTsKI2VuZGlmCgogICAgQVJCX1BSSU5USygic2NzaSVkOiBhcmJpdHJhdGlvbiBjb21wbGV0ZVxuIiwgSE9TVE5PKTsKCiAgICBpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCkgewoJTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7IAoJcmV0dXJuIC0xOwogICAgfQogICAgLyogCiAgICAgKiBUaGUgYXJiaXRyYXRpb24gZGVsYXkgaXMgMi4ydXMsIGJ1dCB0aGlzIGlzIGEgbWluaW11bSBhbmQgdGhlcmUgaXMgCiAgICAgKiBubyBtYXhpbXVtIHNvIHdlIGNhbiBzYWZlbHkgc2xlZXAgZm9yIGNlaWwoMi4yKSB1c2VjcyB0byBhY2NvbW1vZGF0ZQogICAgICogdGhlIGludGVncmFsIG5hdHVyZSBvZiB1ZGVsYXkoKS4KICAgICAqCiAgICAgKi8KCiAgICB1ZGVsYXkoMyk7CgogICAgLyogQ2hlY2sgZm9yIGxvc3QgYXJiaXRyYXRpb24gKi8KICAgIGlmICgoTkNSNTM4MF9yZWFkKElOSVRJQVRPUl9DT01NQU5EX1JFRykgJiBJQ1JfQVJCSVRSQVRJT05fTE9TVCkgfHwKCShOQ1I1MzgwX3JlYWQoQ1VSUkVOVF9TQ1NJX0RBVEFfUkVHKSAmIGhvc3RkYXRhLT5pZF9oaWdoZXJfbWFzaykgfHwKCShOQ1I1MzgwX3JlYWQoSU5JVElBVE9SX0NPTU1BTkRfUkVHKSAmIElDUl9BUkJJVFJBVElPTl9MT1NUKSB8fAoJaG9zdGRhdGEtPmNvbm5lY3RlZCkgewoJTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7IAoJQVJCX1BSSU5USygic2NzaSVkOiBsb3N0IGFyYml0cmF0aW9uLCBkZWFzc2VydGluZyBNUl9BUkJJVFJBVEVcbiIsCgkJICAgSE9TVE5PKTsKCXJldHVybiAtMTsKICAgIH0KCiAgICAgLyogYWZ0ZXIvZHVyaW5nIGFyYml0cmF0aW9uLCBCU1kgc2hvdWxkIGJlIGFzc2VydGVkLgoJSUJNIERQRVMtMzEwODAgVmVyc2lvbiBTMzFRIHdvcmtzIG5vdyAqLwogICAgIC8qIFRueCB0byBUaG9tYXNfUm9lc2NoQG0yLm1hdXMuZGUgZm9yIGZpbmRpbmcgdGhpcyEgKFJvbWFuKSAqLwogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9TRUwgfAoJCQkJCSBJQ1JfQVNTRVJUX0JTWSApIDsKICAgIAogICAgaWYgKChOQ1I1MzgwX3JlYWQoSU5JVElBVE9SX0NPTU1BTkRfUkVHKSAmIElDUl9BUkJJVFJBVElPTl9MT1NUKSB8fAoJaG9zdGRhdGEtPmNvbm5lY3RlZCkgewoJTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7CglOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJQVJCX1BSSU5USygic2NzaSVkOiBsb3N0IGFyYml0cmF0aW9uLCBkZWFzc2VydGluZyBJQ1JfQVNTRVJUX1NFTFxuIiwKCQkgICBIT1NUTk8pOwoJcmV0dXJuIC0xOwogICAgfQoKICAgIC8qIAogICAgICogQWdhaW4sIGJ1cyBjbGVhciArIGJ1cyBzZXR0bGUgdGltZSBpcyAxLjJ1cywgaG93ZXZlciwgdGhpcyBpcyAKICAgICAqIGEgbWluaW11bSBzbyB3ZSdsbCB1ZGVsYXkgY2VpbCgxLjIpCiAgICAgKi8KCiNpZmRlZiBDT05GSUdfQVRBUklfU0NTSV9UT1NISUJBX0RFTEFZCiAgICAvKiArK3JvbWFuOiBCdXQgc29tZSB0YXJnZXRzIChzZWUgYWJvdmUgOi0pIHNlZW0gdG8gbmVlZCBhIGJpdCBtb3JlLi4uICovCiAgICB1ZGVsYXkoMTUpOwojZWxzZQogICAgdWRlbGF5KDIpOwojZW5kaWYKICAgIAogICAgaWYgKGhvc3RkYXRhLT5jb25uZWN0ZWQpIHsKCU5DUjUzODBfd3JpdGUoTU9ERV9SRUcsIE1SX0JBU0UpOwoJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCXJldHVybiAtMTsKICAgIH0KCiAgICBBUkJfUFJJTlRLKCJzY3NpJWQ6IHdvbiBhcmJpdHJhdGlvblxuIiwgSE9TVE5PKTsKCiAgICAvKiAKICAgICAqIE5vdyB0aGF0IHdlIGhhdmUgd29uIGFyYml0cmF0aW9uLCBzdGFydCBTZWxlY3Rpb24gcHJvY2VzcywgYXNzZXJ0aW5nIAogICAgICogdGhlIGhvc3QgYW5kIHRhcmdldCBJRCdzIG9uIHRoZSBTQ1NJIGJ1cy4KICAgICAqLwoKICAgIE5DUjUzODBfd3JpdGUoT1VUUFVUX0RBVEFfUkVHLCAoaG9zdGRhdGEtPmlkX21hc2sgfCAoMSA8PCBjbWQtPmRldmljZS0+aWQpKSk7CgogICAgLyogCiAgICAgKiBSYWlzZSBBVE4gd2hpbGUgU0VMIGlzIHRydWUgYmVmb3JlIEJTWSBnb2VzIGZhbHNlIGZyb20gYXJiaXRyYXRpb24sCiAgICAgKiBzaW5jZSB0aGlzIGlzIHRoZSBvbmx5IHdheSB0byBndWFyYW50ZWUgdGhhdCB3ZSdsbCBnZXQgYSBNRVNTQUdFIE9VVAogICAgICogcGhhc2UgaW1tZWRpYXRlbHkgYWZ0ZXIgc2VsZWN0aW9uLgogICAgICovCgogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIChJQ1JfQkFTRSB8IElDUl9BU1NFUlRfQlNZIHwgCglJQ1JfQVNTRVJUX0RBVEEgfCBJQ1JfQVNTRVJUX0FUTiB8IElDUl9BU1NFUlRfU0VMICkpOwogICAgTkNSNTM4MF93cml0ZShNT0RFX1JFRywgTVJfQkFTRSk7CgogICAgLyogCiAgICAgKiBSZXNlbGVjdCBpbnRlcnJ1cHRzIG11c3QgYmUgdHVybmVkIG9mZiBwcmlvciB0byB0aGUgZHJvcHBpbmcgb2YgQlNZLAogICAgICogb3RoZXJ3aXNlIHdlIHdpbGwgdHJpZ2dlciBhbiBpbnRlcnJ1cHQuCiAgICAgKi8KCiAgICBpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCkgewoJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCXJldHVybiAtMTsKICAgIH0KCiAgICBOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCAwKTsKCiAgICAvKgogICAgICogVGhlIGluaXRpYXRvciBzaGFsbCB0aGVuIHdhaXQgYXQgbGVhc3QgdHdvIGRlc2tldyBkZWxheXMgYW5kIHJlbGVhc2UgCiAgICAgKiB0aGUgQlNZIHNpZ25hbC4KICAgICAqLwogICAgdWRlbGF5KDEpOyAgICAgICAgLyogd2luZ2VsIC0tIHdhaXQgdHdvIGJ1cyBkZXNrZXcgZGVsYXkgPjIqNDVucyAqLwoKICAgIC8qIFJlc2V0IEJTWSAqLwogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIChJQ1JfQkFTRSB8IElDUl9BU1NFUlRfREFUQSB8IAoJSUNSX0FTU0VSVF9BVE4gfCBJQ1JfQVNTRVJUX1NFTCkpOwoKICAgIC8qIAogICAgICogU29tZXRoaW5nIHdlaXJkIGhhcHBlbnMgd2hlbiB3ZSBjZWFzZSB0byBkcml2ZSBCU1kgLSBsb29rcwogICAgICogbGlrZSB0aGUgYm9hcmQvY2hpcCBpcyBsZXR0aW5nIHVzIGRvIGFub3RoZXIgcmVhZCBiZWZvcmUgdGhlIAogICAgICogYXBwcm9wcmlhdGUgcHJvcGFnYXRpb24gZGVsYXkgaGFzIGV4cGlyZWQsIGFuZCB3ZSdyZSBjb25mdXNpbmcKICAgICAqIGEgQlNZIHNpZ25hbCBmcm9tIG91cnNlbHZlcyBhcyB0aGUgdGFyZ2V0J3MgcmVzcG9uc2UgdG8gU0VMRUNUSU9OLgogICAgICoKICAgICAqIEEgc21hbGwgZGVsYXkgKHRoZSAnQysrJyBmcm9udGVuZCBicmVha3MgdGhlIHBpcGVsaW5lIHdpdGggYW4KICAgICAqIHVubmVjZXNzYXJ5IGp1bXAsIG1ha2luZyBpdCB3b3JrIG9uIG15IDM4Ni0zMy9UcmFudG9yIFQxMjgsIHRoZQogICAgICogdGlnaHRlciAnQycgY29kZSBicmVha3MgYW5kIHJlcXVpcmVzIHRoaXMpIHNvbHZlcyB0aGUgcHJvYmxlbSAtIAogICAgICogdGhlIDEgdXMgZGVsYXkgaXMgYXJiaXRyYXJ5LCBhbmQgb25seSB1c2VkIGJlY2F1c2UgdGhpcyBkZWxheSB3aWxsIAogICAgICogYmUgdGhlIHNhbWUgb24gb3RoZXIgcGxhdGZvcm1zIGFuZCBzaW5jZSBpdCB3b3JrcyBoZXJlLCBpdCBzaG91bGQgCiAgICAgKiB3b3JrIHRoZXJlLgogICAgICoKICAgICAqIHdpbmdlbCBzdWdnZXN0cyB0aGF0IHRoaXMgY291bGQgYmUgZHVlIHRvIGZhaWxpbmcgdG8gd2FpdAogICAgICogb25lIGRlc2tldyBkZWxheS4KICAgICAqLwoKICAgIHVkZWxheSgxKTsKCiAgICBTRUxfUFJJTlRLKCJzY3NpJWQ6IHNlbGVjdGluZyB0YXJnZXQgJWRcbiIsIEhPU1ROTywgY21kLT5kZXZpY2UtPmlkKTsKCiAgICAvKiAKICAgICAqIFRoZSBTQ1NJIHNwZWNpZmljYXRpb24gY2FsbHMgZm9yIGEgMjUwIG1zIHRpbWVvdXQgZm9yIHRoZSBhY3R1YWwgCiAgICAgKiBzZWxlY3Rpb24uCiAgICAgKi8KCiAgICB0aW1lb3V0ID0gamlmZmllcyArIDI1OyAKCiAgICAvKiAKICAgICAqIFhYWCB2ZXJ5IGludGVyZXN0aW5nIC0gd2UncmUgc2VlaW5nIGEgYm91bmNlIHdoZXJlIHRoZSBCU1kgd2UgCiAgICAgKiBhc3NlcnRlZCBpcyBiZWluZyByZWZsZWN0ZWQgLyBzdGlsbCBhc3NlcnRlZCAocHJvcGFnYXRpb24gZGVsYXk/KQogICAgICogYW5kIGl0J3MgZGV0ZWN0aW5nIGFzIHRydWUuICBTaWdoLgogICAgICovCgojaWYgMAogICAgLyogKytyb21hbjogSWYgYSB0YXJnZXQgY29uZm9ybWVkIHRvIHRoZSBTQ1NJIHN0YW5kYXJkLCBpdCB3b3VsZG4ndCBhc3NlcnQKICAgICAqIElPIHdoaWxlIFNFTCBpcyB0cnVlLiBCdXQgYWdhaW4sIHRoZXJlIGFyZSBzb21lIGRpc2tzIG91dCB0aGUgaW4gdGhlCiAgICAgKiB3b3JsZCB0aGF0IGRvIHRoYXQgbmV2ZXJ0aGVsZXNzLiAoU29tZWJvZHkgY2xhaW1lZCB0aGF0IHRoaXMgYW5ub3VuY2VzCiAgICAgKiByZXNlbGVjdGlvbiBjYXBhYmlsaXR5IG9mIHRoZSB0YXJnZXQuKSBTbyB3ZSBiZXR0ZXIgc2tpcCB0aGF0IHRlc3QgYW5kCiAgICAgKiBvbmx5IHdhaXQgZm9yIEJTWS4uLiAoRmFtb3VzIGdlcm1hbiB3b3JkczogRGVyIEts/GdlcmUgZ2lidCBuYWNoIDotKQogICAgICovCgogICAgd2hpbGUgKHRpbWVfYmVmb3JlKGppZmZpZXMsIHRpbWVvdXQpICYmICEoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgCgkoU1JfQlNZIHwgU1JfSU8pKSk7CgogICAgaWYgKChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiAoU1JfU0VMIHwgU1JfSU8pKSA9PSAKCSAgICAoU1JfU0VMIHwgU1JfSU8pKSB7CgkgICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCSAgICBOQ1I1MzgwX3Jlc2VsZWN0KGluc3RhbmNlKTsKCSAgICBwcmludGsgKEtFUk5fRVJSICJzY3NpJWQ6IHJlc2VsZWN0aW9uIGFmdGVyIHdvbiBhcmJpdHJhdGlvbj9cbiIsCgkJICAgIEhPU1ROTyk7CgkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJICAgIHJldHVybiAtMTsKICAgIH0KI2Vsc2UKICAgIHdoaWxlICh0aW1lX2JlZm9yZShqaWZmaWVzLCB0aW1lb3V0KSAmJiAhKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFNSX0JTWSkpOwojZW5kaWYKCiAgICAvKiAKICAgICAqIE5vIGxlc3MgdGhhbiB0d28gZGVza2V3IGRlbGF5cyBhZnRlciB0aGUgaW5pdGlhdG9yIGRldGVjdHMgdGhlIAogICAgICogQlNZIHNpZ25hbCBpcyB0cnVlLCBpdCBzaGFsbCByZWxlYXNlIHRoZSBTRUwgc2lnbmFsIGFuZCBtYXkgCiAgICAgKiBjaGFuZ2UgdGhlIERBVEEgQlVTLiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtd2luZ2VsCiAgICAgKi8KCiAgICB1ZGVsYXkoMSk7CgogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9BVE4pOwoKICAgIGlmICghKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFNSX0JTWSkpIHsKCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CglpZiAoaG9zdGRhdGEtPnRhcmdldHNfcHJlc2VudCAmICgxIDw8IGNtZC0+ZGV2aWNlLT5pZCkpIHsKCSAgICBwcmludGsoS0VSTl9FUlIgInNjc2klZDogd2VpcmRuZXNzXG4iLCBIT1NUTk8pOwoJICAgIGlmIChob3N0ZGF0YS0+cmVzdGFydF9zZWxlY3QpCgkJcHJpbnRrKEtFUk5fTk9USUNFICJcdHJlc3RhcnQgc2VsZWN0XG4iKTsKCSAgICBOQ1JfUFJJTlQoTkRFQlVHX0FOWSk7CgkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJICAgIHJldHVybiAtMTsKCX0KCWNtZC0+cmVzdWx0ID0gRElEX0JBRF9UQVJHRVQgPDwgMTY7CiNpZmRlZiBOQ1I1MzgwX1NUQVRTCgljb2xsZWN0X3N0YXRzKGhvc3RkYXRhLCBjbWQpOwojZW5kaWYKI2lmZGVmIFNVUFBPUlRfVEFHUwoJY21kX2ZyZWVfdGFnKCBjbWQgKTsKI2VuZGlmCgljbWQtPnNjc2lfZG9uZShjbWQpOwoJTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJU0VMX1BSSU5USygic2NzaSVkOiB0YXJnZXQgZGlkIG5vdCByZXNwb25kIHdpdGhpbiAyNTBtc1xuIiwgSE9TVE5PKTsKCU5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKCXJldHVybiAwOwogICAgfSAKCiAgICBob3N0ZGF0YS0+dGFyZ2V0c19wcmVzZW50IHw9ICgxIDw8IGNtZC0+ZGV2aWNlLT5pZCk7CgogICAgLyoKICAgICAqIFNpbmNlIHdlIGZvbGxvd2VkIHRoZSBTQ1NJIHNwZWMsIGFuZCByYWlzZWQgQVROIHdoaWxlIFNFTCAKICAgICAqIHdhcyB0cnVlIGJ1dCBiZWZvcmUgQlNZIHdhcyBmYWxzZSBkdXJpbmcgc2VsZWN0aW9uLCB0aGUgaW5mb3JtYXRpb24KICAgICAqIHRyYW5zZmVyIHBoYXNlIHNob3VsZCBiZSBhIE1FU1NBR0UgT1VUIHBoYXNlIHNvIHRoYXQgd2UgY2FuIHNlbmQgdGhlCiAgICAgKiBJREVOVElGWSBtZXNzYWdlLgogICAgICogCiAgICAgKiBJZiBTQ1NJLUlJIHRhZ2dlZCBxdWV1aW5nIGlzIGVuYWJsZWQsIHdlIGFsc28gc2VuZCBhIFNJTVBMRV9RVUVVRV9UQUcKICAgICAqIG1lc3NhZ2UgKDIgYnl0ZXMpIHdpdGggYSB0YWcgSUQgdGhhdCB3ZSBpbmNyZW1lbnQgd2l0aCBldmVyeSBjb21tYW5kCiAgICAgKiB1bnRpbCBpdCB3cmFwcyBiYWNrIHRvIDAuCiAgICAgKgogICAgICogWFhYIC0gaXQgdHVybnMgb3V0IHRoYXQgdGhlcmUgYXJlIHNvbWUgYnJva2VuIFNDU0ktSUkgZGV2aWNlcywKICAgICAqCSAgICAgd2hpY2ggY2xhaW0gdG8gc3VwcG9ydCB0YWdnZWQgcXVldWluZyBidXQgZmFpbCB3aGVuIG1vcmUgdGhhbgogICAgICoJICAgICBzb21lIG51bWJlciBvZiBjb21tYW5kcyBhcmUgaXNzdWVkIGF0IG9uY2UuCiAgICAgKi8KCiAgICAvKiBXYWl0IGZvciBzdGFydCBvZiBSRVEvQUNLIGhhbmRzaGFrZSAqLwogICAgd2hpbGUgKCEoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfUkVRKSk7CgogICAgU0VMX1BSSU5USygic2NzaSVkOiB0YXJnZXQgJWQgc2VsZWN0ZWQsIGdvaW5nIGludG8gTUVTU0FHRSBPVVQgcGhhc2UuXG4iLAoJICAgICAgIEhPU1ROTywgY21kLT5kZXZpY2UtPmlkKTsKICAgIHRtcFswXSA9IElERU5USUZZKDEsIGNtZC0+ZGV2aWNlLT5sdW4pOwoKI2lmZGVmIFNVUFBPUlRfVEFHUwogICAgaWYgKGNtZC0+dGFnICE9IFRBR19OT05FKSB7Cgl0bXBbMV0gPSBob3N0ZGF0YS0+bGFzdF9tZXNzYWdlID0gU0lNUExFX1FVRVVFX1RBRzsKCXRtcFsyXSA9IGNtZC0+dGFnOwoJbGVuID0gMzsKICAgIH0gZWxzZSAKCWxlbiA9IDE7CiNlbHNlCiAgICBsZW4gPSAxOwogICAgY21kLT50YWc9MDsKI2VuZGlmIC8qIFNVUFBPUlRfVEFHUyAqLwoKICAgIC8qIFNlbmQgbWVzc2FnZShzKSAqLwogICAgZGF0YSA9IHRtcDsKICAgIHBoYXNlID0gUEhBU0VfTVNHT1VUOwogICAgTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpOwogICAgU0VMX1BSSU5USygic2NzaSVkOiBuZXh1cyBlc3RhYmxpc2hlZC5cbiIsIEhPU1ROTyk7CiAgICAvKiBYWFggbmVlZCB0byBoYW5kbGUgZXJyb3JzIGhlcmUgKi8KICAgIGhvc3RkYXRhLT5jb25uZWN0ZWQgPSBjbWQ7CiNpZm5kZWYgU1VQUE9SVF9UQUdTCiAgICBob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdIHw9ICgxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwojZW5kaWYgICAgCgogICAgaW5pdGlhbGl6ZV9TQ3AoY21kKTsKCgogICAgcmV0dXJuIDA7Cn0KCi8qIAogKiBGdW5jdGlvbiA6IGludCBOQ1I1MzgwX3RyYW5zZmVyX3BpbyAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UsIAogKiAgICAgIHVuc2lnbmVkIGNoYXIgKnBoYXNlLCBpbnQgKmNvdW50LCB1bnNpZ25lZCBjaGFyICoqZGF0YSkKICoKICogUHVycG9zZSA6IHRyYW5zZmVycyBkYXRhIGluIGdpdmVuIHBoYXNlIHVzaW5nIHBvbGxlZCBJL08KICoKICogSW5wdXRzIDogaW5zdGFuY2UgLSBpbnN0YW5jZSBvZiBkcml2ZXIsICpwaGFzZSAtIHBvaW50ZXIgdG8gCiAqCXdoYXQgcGhhc2UgaXMgZXhwZWN0ZWQsICpjb3VudCAtIHBvaW50ZXIgdG8gbnVtYmVyIG9mIAogKglieXRlcyB0byB0cmFuc2ZlciwgKipkYXRhIC0gcG9pbnRlciB0byBkYXRhIHBvaW50ZXIuCiAqIAogKiBSZXR1cm5zIDogLTEgd2hlbiBkaWZmZXJlbnQgcGhhc2UgaXMgZW50ZXJlZCB3aXRob3V0IHRyYW5zZmVycmluZwogKgltYXhpbXVtIG51bWJlciBvZiBieXRlcywgMCBpZiBhbGwgYnl0ZXMgYXJlIHRyYW5zZmVyZWQgb3IgZXhpdAogKglpcyBpbiBzYW1lIHBoYXNlLgogKgogKiAJQWxzbywgKnBoYXNlLCAqY291bnQsICpkYXRhIGFyZSBtb2RpZmllZCBpbiBwbGFjZS4KICoKICogWFhYIE5vdGUgOiBoYW5kbGluZyBmb3IgYnVzIGZyZWUgbWF5IGJlIHVzZWZ1bC4KICovCgovKgogKiBOb3RlIDogdGhpcyBjb2RlIGlzIG5vdCBhcyBxdWljayBhcyBpdCBjb3VsZCBiZSwgaG93ZXZlciBpdCAKICogSVMgMTAwJSByZWxpYWJsZSwgYW5kIGZvciB0aGUgYWN0dWFsIGRhdGEgdHJhbnNmZXIgd2hlcmUgc3BlZWQKICogY291bnRzLCB3ZSB3aWxsIGFsd2F5cyBkbyBhIHBzZXVkbyBETUEgb3IgRE1BIHRyYW5zZmVyLgogKi8KCnN0YXRpYyBpbnQgTkNSNTM4MF90cmFuc2Zlcl9waW8oIHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlLCAKCQkJCSB1bnNpZ25lZCBjaGFyICpwaGFzZSwgaW50ICpjb3VudCwKCQkJCSB1bnNpZ25lZCBjaGFyICoqZGF0YSkKewogICAgcmVnaXN0ZXIgdW5zaWduZWQgY2hhciBwID0gKnBoYXNlLCB0bXA7CiAgICByZWdpc3RlciBpbnQgYyA9ICpjb3VudDsKICAgIHJlZ2lzdGVyIHVuc2lnbmVkIGNoYXIgKmQgPSAqZGF0YTsKCiAgICAvKiAKICAgICAqIFRoZSBOQ1I1MzgwIGNoaXAgd2lsbCBvbmx5IGRyaXZlIHRoZSBTQ1NJIGJ1cyB3aGVuIHRoZSAKICAgICAqIHBoYXNlIHNwZWNpZmllZCBpbiB0aGUgYXBwcm9wcmlhdGUgYml0cyBvZiB0aGUgVEFSR0VUIENPTU1BTkQKICAgICAqIFJFR0lTVEVSIG1hdGNoIHRoZSBTVEFUVVMgUkVHSVNURVIKICAgICAqLwoKICAgIE5DUjUzODBfd3JpdGUoVEFSR0VUX0NPTU1BTkRfUkVHLCBQSEFTRV9TUl9UT19UQ1IocCkpOwoKICAgIGRvIHsKCS8qIAoJICogV2FpdCBmb3IgYXNzZXJ0aW9uIG9mIFJFUSwgYWZ0ZXIgd2hpY2ggdGhlIHBoYXNlIGJpdHMgd2lsbCBiZSAKCSAqIHZhbGlkIAoJICovCgl3aGlsZSAoISgodG1wID0gTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpKSAmIFNSX1JFUSkpOwoKCUhTSF9QUklOVEsoInNjc2klZDogUkVRIGRldGVjdGVkXG4iLCBIT1NUTk8pOwoKCS8qIENoZWNrIGZvciBwaGFzZSBtaXNtYXRjaCAqLwkKCWlmICgodG1wICYgUEhBU0VfTUFTSykgIT0gcCkgewoJICAgIFBJT19QUklOVEsoInNjc2klZDogcGhhc2UgbWlzbWF0Y2hcbiIsIEhPU1ROTyk7CgkgICAgTkNSX1BSSU5UX1BIQVNFKE5ERUJVR19QSU8pOwoJICAgIGJyZWFrOwoJfQoKCS8qIERvIGFjdHVhbCB0cmFuc2ZlciBmcm9tIFNDU0kgYnVzIHRvIC8gZnJvbSBtZW1vcnkgKi8KCWlmICghKHAgJiBTUl9JTykpIAoJICAgIE5DUjUzODBfd3JpdGUoT1VUUFVUX0RBVEFfUkVHLCAqZCk7CgllbHNlIAoJICAgICpkID0gTkNSNTM4MF9yZWFkKENVUlJFTlRfU0NTSV9EQVRBX1JFRyk7CgoJKytkOwoKCS8qIAoJICogVGhlIFNDU0kgc3RhbmRhcmQgc3VnZ2VzdHMgdGhhdCBpbiBNU0dPVVQgcGhhc2UsIHRoZSBpbml0aWF0b3IKCSAqIHNob3VsZCBkcm9wIEFUTiBvbiB0aGUgbGFzdCBieXRlIG9mIHRoZSBtZXNzYWdlIHBoYXNlCgkgKiBhZnRlciBSRVEgaGFzIGJlZW4gYXNzZXJ0ZWQgZm9yIHRoZSBoYW5kc2hha2UgYnV0IGJlZm9yZQoJICogdGhlIGluaXRpYXRvciByYWlzZXMgQUNLLgoJICovCgoJaWYgKCEocCAmIFNSX0lPKSkgewoJICAgIGlmICghKChwICYgU1JfTVNHKSAmJiBjID4gMSkpIHsKCQlOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCAKCQkgICAgSUNSX0FTU0VSVF9EQVRBKTsKCQlOQ1JfUFJJTlQoTkRFQlVHX1BJTyk7CgkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgCgkJCUlDUl9BU1NFUlRfREFUQSB8IElDUl9BU1NFUlRfQUNLKTsKCSAgICB9IGVsc2UgewoJCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8CgkJICAgIElDUl9BU1NFUlRfREFUQSB8IElDUl9BU1NFUlRfQVROKTsKCQlOQ1JfUFJJTlQoTkRFQlVHX1BJTyk7CgkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgCgkJICAgIElDUl9BU1NFUlRfREFUQSB8IElDUl9BU1NFUlRfQVROIHwgSUNSX0FTU0VSVF9BQ0spOwoJICAgIH0KCX0gZWxzZSB7CgkgICAgTkNSX1BSSU5UKE5ERUJVR19QSU8pOwoJICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfQUNLKTsKCX0KCgl3aGlsZSAoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfUkVRKTsKCglIU0hfUFJJTlRLKCJzY3NpJWQ6IHJlcSBmYWxzZSwgaGFuZHNoYWtlIGNvbXBsZXRlXG4iLCBIT1NUTk8pOwoKLyoKICogV2UgaGF2ZSBzZXZlcmFsIHNwZWNpYWwgY2FzZXMgdG8gY29uc2lkZXIgZHVyaW5nIFJFUS9BQ0sgaGFuZHNoYWtpbmcgOiAKICogMS4gIFdlIHdlcmUgaW4gTVNHT1VUIHBoYXNlLCBhbmQgd2UgYXJlIG9uIHRoZSBsYXN0IGJ5dGUgb2YgdGhlIAogKgltZXNzYWdlLiAgQVROIG11c3QgYmUgZHJvcHBlZCBhcyBBQ0sgaXMgZHJvcHBlZC4KICoKICogMi4gIFdlIGFyZSBpbiBhIE1TR0lOIHBoYXNlLCBhbmQgd2UgYXJlIG9uIHRoZSBsYXN0IGJ5dGUgb2YgdGhlICAKICoJbWVzc2FnZS4gIFdlIG11c3QgZXhpdCB3aXRoIEFDSyBhc3NlcnRlZCwgc28gdGhhdCB0aGUgY2FsbGluZwogKgljb2RlIG1heSByYWlzZSBBVE4gYmVmb3JlIGRyb3BwaW5nIEFDSyB0byByZWplY3QgdGhlIG1lc3NhZ2UuCiAqCiAqIDMuICBBQ0sgYW5kIEFUTiBhcmUgY2xlYXIgYW5kIHRoZSB0YXJnZXQgbWF5IHByb2NlZWQgYXMgbm9ybWFsLgogKi8KCWlmICghKHAgPT0gUEhBU0VfTVNHSU4gJiYgYyA9PSAxKSkgeyAgCgkgICAgaWYgKHAgPT0gUEhBU0VfTVNHT1VUICYmIGMgPiAxKQoJCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfQVROKTsKCSAgICBlbHNlCgkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCX0gCiAgICB9IHdoaWxlICgtLWMpOwoKICAgIFBJT19QUklOVEsoInNjc2klZDogcmVzaWR1YWwgJWRcbiIsIEhPU1ROTywgYyk7CgogICAgKmNvdW50ID0gYzsKICAgICpkYXRhID0gZDsKICAgIHRtcCA9IE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKTsKICAgIC8qIFRoZSBwaGFzZSByZWFkIGZyb20gdGhlIGJ1cyBpcyB2YWxpZCBpZiBlaXRoZXIgUkVRIGlzIChhbHJlYWR5KQogICAgICogYXNzZXJ0ZWQgb3IgaWYgQUNLIGhhc24ndCBiZWVuIHJlbGVhc2VkIHlldC4gVGhlIGxhdHRlciBpcyB0aGUgY2FzZSBpZgogICAgICogd2UncmUgaW4gTVNHSU4gYW5kIGFsbCB3YW50ZWQgYnl0ZXMgaGF2ZSBiZWVuIHJlY2VpdmVkLiAqLwogICAgaWYgKCh0bXAgJiBTUl9SRVEpIHx8IChwID09IFBIQVNFX01TR0lOICYmIGMgPT0gMCkpCgkqcGhhc2UgPSB0bXAgJiBQSEFTRV9NQVNLOwogICAgZWxzZSAKCSpwaGFzZSA9IFBIQVNFX1VOS05PV047CgogICAgaWYgKCFjIHx8ICgqcGhhc2UgPT0gcCkpCglyZXR1cm4gMDsKICAgIGVsc2UgCglyZXR1cm4gLTE7Cn0KCi8qCiAqIEZ1bmN0aW9uIDogZG9fYWJvcnQgKFNjc2lfSG9zdCAqaG9zdCkKICogCiAqIFB1cnBvc2UgOiBhYm9ydCB0aGUgY3VycmVudGx5IGVzdGFibGlzaGVkIG5leHVzLiAgU2hvdWxkIG9ubHkgYmUgCiAqIAljYWxsZWQgZnJvbSBhIHJvdXRpbmUgd2hpY2ggY2FuIGRyb3AgaW50byBhIAogKiAKICogUmV0dXJucyA6IDAgb24gc3VjY2VzcywgLTEgb24gZmFpbHVyZS4KICovCgpzdGF0aWMgaW50IGRvX2Fib3J0IChzdHJ1Y3QgU2NzaV9Ib3N0ICpob3N0KSAKewogICAgdW5zaWduZWQgY2hhciB0bXAsICptc2dwdHIsIHBoYXNlOwogICAgaW50IGxlbjsKCiAgICAvKiBSZXF1ZXN0IG1lc3NhZ2Ugb3V0IHBoYXNlICovCiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCBJQ1JfQVNTRVJUX0FUTik7CgogICAgLyogCiAgICAgKiBXYWl0IGZvciB0aGUgdGFyZ2V0IHRvIGluZGljYXRlIGEgdmFsaWQgcGhhc2UgYnkgYXNzZXJ0aW5nIAogICAgICogUkVRLiAgT25jZSB0aGlzIGhhcHBlbnMsIHdlJ2xsIGhhdmUgZWl0aGVyIGEgTVNHT1VUIHBoYXNlIAogICAgICogYW5kIGNhbiBpbW1lZGlhdGVseSBzZW5kIHRoZSBBQk9SVCBtZXNzYWdlLCBvciB3ZSdsbCBoYXZlIHNvbWUgCiAgICAgKiBvdGhlciBwaGFzZSBhbmQgd2lsbCBoYXZlIHRvIHNvdXJjZS9zaW5rIGRhdGEuCiAgICAgKiAKICAgICAqIFdlIHJlYWxseSBkb24ndCBjYXJlIHdoYXQgdmFsdWUgd2FzIG9uIHRoZSBidXMgb3Igd2hhdCB2YWx1ZQogICAgICogdGhlIHRhcmdldCBzZWVzLCBzbyB3ZSBqdXN0IGhhbmRzaGFrZS4KICAgICAqLwogICAgCiAgICB3aGlsZSAoISh0bXAgPSBOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykpICYgU1JfUkVRKTsKCiAgICBOQ1I1MzgwX3dyaXRlKFRBUkdFVF9DT01NQU5EX1JFRywgUEhBU0VfU1JfVE9fVENSKHRtcCkpOwoKICAgIGlmICgodG1wICYgUEhBU0VfTUFTSykgIT0gUEhBU0VfTVNHT1VUKSB7CglOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCBJQ1JfQVNTRVJUX0FUTiB8IAoJCSAgICAgIElDUl9BU1NFUlRfQUNLKTsKCXdoaWxlIChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBTUl9SRVEpOwoJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9BVE4pOwogICAgfQogICAKICAgIHRtcCA9IEFCT1JUOwogICAgbXNncHRyID0gJnRtcDsKICAgIGxlbiA9IDE7CiAgICBwaGFzZSA9IFBIQVNFX01TR09VVDsKICAgIE5DUjUzODBfdHJhbnNmZXJfcGlvIChob3N0LCAmcGhhc2UsICZsZW4sICZtc2dwdHIpOwoKICAgIC8qCiAgICAgKiBJZiB3ZSBnb3QgaGVyZSwgYW5kIHRoZSBjb21tYW5kIGNvbXBsZXRlZCBzdWNjZXNzZnVsbHksCiAgICAgKiB3ZSdyZSBhYm91dCB0byBnbyBpbnRvIGJ1cyBmcmVlIHN0YXRlLgogICAgICovCgogICAgcmV0dXJuIGxlbiA/IC0xIDogMDsKfQoKI2lmIGRlZmluZWQoUkVBTF9ETUEpCi8qIAogKiBGdW5jdGlvbiA6IGludCBOQ1I1MzgwX3RyYW5zZmVyX2RtYSAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UsIAogKiAgICAgIHVuc2lnbmVkIGNoYXIgKnBoYXNlLCBpbnQgKmNvdW50LCB1bnNpZ25lZCBjaGFyICoqZGF0YSkKICoKICogUHVycG9zZSA6IHRyYW5zZmVycyBkYXRhIGluIGdpdmVuIHBoYXNlIHVzaW5nIGVpdGhlciByZWFsCiAqCW9yIHBzZXVkbyBETUEuCiAqCiAqIElucHV0cyA6IGluc3RhbmNlIC0gaW5zdGFuY2Ugb2YgZHJpdmVyLCAqcGhhc2UgLSBwb2ludGVyIHRvIAogKgl3aGF0IHBoYXNlIGlzIGV4cGVjdGVkLCAqY291bnQgLSBwb2ludGVyIHRvIG51bWJlciBvZiAKICoJYnl0ZXMgdG8gdHJhbnNmZXIsICoqZGF0YSAtIHBvaW50ZXIgdG8gZGF0YSBwb2ludGVyLgogKiAKICogUmV0dXJucyA6IC0xIHdoZW4gZGlmZmVyZW50IHBoYXNlIGlzIGVudGVyZWQgd2l0aG91dCB0cmFuc2ZlcnJpbmcKICoJbWF4aW11bSBudW1iZXIgb2YgYnl0ZXMsIDAgaWYgYWxsIGJ5dGVzIG9yIHRyYW5zZmVyZWQgb3IgZXhpdAogKglpcyBpbiBzYW1lIHBoYXNlLgogKgogKiAJQWxzbywgKnBoYXNlLCAqY291bnQsICpkYXRhIGFyZSBtb2RpZmllZCBpbiBwbGFjZS4KICoKICovCgoKc3RhdGljIGludCBOQ1I1MzgwX3RyYW5zZmVyX2RtYSggc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UsIAoJCQkJIHVuc2lnbmVkIGNoYXIgKnBoYXNlLCBpbnQgKmNvdW50LAoJCQkJIHVuc2lnbmVkIGNoYXIgKipkYXRhKQp7CiAgICBTRVRVUF9IT1NUREFUQShpbnN0YW5jZSk7CiAgICByZWdpc3RlciBpbnQgYyA9ICpjb3VudDsKICAgIHJlZ2lzdGVyIHVuc2lnbmVkIGNoYXIgcCA9ICpwaGFzZTsKICAgIHJlZ2lzdGVyIHVuc2lnbmVkIGNoYXIgKmQgPSAqZGF0YTsKICAgIHVuc2lnbmVkIGNoYXIgdG1wOwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKCiAgICBpZiAoKHRtcCA9IChOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgJiBQSEFTRV9NQVNLKSkgIT0gcCkgewogICAgICAgICpwaGFzZSA9IHRtcDsKICAgICAgICByZXR1cm4gLTE7CiAgICB9CgogICAgaWYgKGF0YXJpX3JlYWRfb3ZlcnJ1bnMgJiYgKHAgJiBTUl9JTykpIHsKCWMgLT0gYXRhcmlfcmVhZF9vdmVycnVuczsKICAgIH0KCiAgICBETUFfUFJJTlRLKCJzY3NpJWQ6IGluaXRpYWxpemluZyBETUEgZm9yICVzLCAlZCBieXRlcyAlcyAlcFxuIiwKCSAgICAgICBIT1NUTk8sIChwICYgU1JfSU8pID8gInJlYWRpbmciIDogIndyaXRpbmciLAoJICAgICAgIGMsIChwICYgU1JfSU8pID8gInRvIiA6ICJmcm9tIiwgZCk7CgogICAgTkNSNTM4MF93cml0ZShUQVJHRVRfQ09NTUFORF9SRUcsIFBIQVNFX1NSX1RPX1RDUihwKSk7CgojaWZkZWYgUkVBTF9ETUEKICAgIE5DUjUzODBfd3JpdGUoTU9ERV9SRUcsIE1SX0JBU0UgfCBNUl9ETUFfTU9ERSB8IE1SX0VOQUJMRV9FT1BfSU5UUiB8IE1SX01PTklUT1JfQlNZKTsKI2VuZGlmIC8qIGRlZiBSRUFMX0RNQSAgKi8KCiAgICBpZiAoSVNfQV9UVCgpKSB7CgkvKiBPbiB0aGUgTWVkdXNhLCBpdCBpcyBhIG11c3QgdG8gaW5pdGlhbGl6ZSB0aGUgRE1BIGJlZm9yZQoJICogc3RhcnRpbmcgdGhlIE5DUi4gVGhpcyBpcyBhbHNvIHRoZSBjbGVhbmVyIHdheSBmb3IgdGhlIFRULgoJICovCglsb2NhbF9pcnFfc2F2ZShmbGFncyk7Cglob3N0ZGF0YS0+ZG1hX2xlbiA9IChwICYgU1JfSU8pID8KCSAgICBOQ1I1MzgwX2RtYV9yZWFkX3NldHVwKGluc3RhbmNlLCBkLCBjKSA6IAoJICAgIE5DUjUzODBfZG1hX3dyaXRlX3NldHVwKGluc3RhbmNlLCBkLCBjKTsKCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKICAgIH0KICAgIAogICAgaWYgKHAgJiBTUl9JTykKCU5DUjUzODBfd3JpdGUoU1RBUlRfRE1BX0lOSVRJQVRPUl9SRUNFSVZFX1JFRywgMCk7CiAgICBlbHNlIHsKCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfREFUQSk7CglOQ1I1MzgwX3dyaXRlKFNUQVJUX0RNQV9TRU5EX1JFRywgMCk7CiAgICB9CgogICAgaWYgKCFJU19BX1RUKCkpIHsKCS8qIE9uIHRoZSBGYWxjb24sIHRoZSBETUEgc2V0dXAgbXVzdCBiZSBkb25lIGFmdGVyIHRoZSBsYXN0ICovCgkvKiBOQ1IgYWNjZXNzLCBlbHNlIHRoZSBETUEgc2V0dXAgZ2V0cyB0cmFzaGVkIQoJICovCglsb2NhbF9pcnFfc2F2ZShmbGFncyk7Cglob3N0ZGF0YS0+ZG1hX2xlbiA9IChwICYgU1JfSU8pID8KCSAgICBOQ1I1MzgwX2RtYV9yZWFkX3NldHVwKGluc3RhbmNlLCBkLCBjKSA6IAoJICAgIE5DUjUzODBfZG1hX3dyaXRlX3NldHVwKGluc3RhbmNlLCBkLCBjKTsKCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKICAgIH0KICAgIHJldHVybiAwOwp9CiNlbmRpZiAvKiBkZWZpbmVkKFJFQUxfRE1BKSAqLwoKLyoKICogRnVuY3Rpb24gOiBOQ1I1MzgwX2luZm9ybWF0aW9uX3RyYW5zZmVyIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKICoKICogUHVycG9zZSA6IHJ1biB0aHJvdWdoIHRoZSB2YXJpb3VzIFNDU0kgcGhhc2VzIGFuZCBkbyBhcyB0aGUgdGFyZ2V0IAogKiAJZGlyZWN0cyB1cyB0by4gIE9wZXJhdGVzIG9uIHRoZSBjdXJyZW50bHkgY29ubmVjdGVkIGNvbW1hbmQsIAogKglpbnN0YW5jZS0+Y29ubmVjdGVkLgogKgogKiBJbnB1dHMgOiBpbnN0YW5jZSwgaW5zdGFuY2UgZm9yIHdoaWNoIHdlIGFyZSBkb2luZyBjb21tYW5kcwogKgogKiBTaWRlIGVmZmVjdHMgOiBTQ1NJIHRoaW5ncyBoYXBwZW4sIHRoZSBkaXNjb25uZWN0ZWQgcXVldWUgd2lsbCBiZSAKICoJbW9kaWZpZWQgaWYgYSBjb21tYW5kIGRpc2Nvbm5lY3RzLCAqaW5zdGFuY2UtPmNvbm5lY3RlZCB3aWxsCiAqCWNoYW5nZS4KICoKICogWFhYIE5vdGUgOiB3ZSBuZWVkIHRvIHdhdGNoIGZvciBidXMgZnJlZSBvciBhIHJlc2V0IGNvbmRpdGlvbiBoZXJlIAogKiAJdG8gcmVjb3ZlciBmcm9tIGFuIHVuZXhwZWN0ZWQgYnVzIGZyZWUgY29uZGl0aW9uLgogKi8KIApzdGF0aWMgdm9pZCBOQ1I1MzgwX2luZm9ybWF0aW9uX3RyYW5zZmVyIChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKewogICAgU0VUVVBfSE9TVERBVEEoaW5zdGFuY2UpOwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKICAgIHVuc2lnbmVkIGNoYXIgbXNnb3V0ID0gTk9QOwogICAgaW50IHNpbmsgPSAwOwogICAgaW50IGxlbjsKI2lmIGRlZmluZWQoUkVBTF9ETUEpCiAgICBpbnQgdHJhbnNmZXJzaXplOwojZW5kaWYKICAgIHVuc2lnbmVkIGNoYXIgKmRhdGE7CiAgICB1bnNpZ25lZCBjaGFyIHBoYXNlLCB0bXAsIGV4dGVuZGVkX21zZ1sxMF0sIG9sZF9waGFzZT0weGZmOwogICAgU2NzaV9DbW5kICpjbWQgPSAoU2NzaV9DbW5kICopIGhvc3RkYXRhLT5jb25uZWN0ZWQ7CgogICAgd2hpbGUgKDEpIHsKCXRtcCA9IE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKTsKCS8qIFdlIG9ubHkgaGF2ZSBhIHZhbGlkIFNDU0kgcGhhc2Ugd2hlbiBSRVEgaXMgYXNzZXJ0ZWQgKi8KCWlmICh0bXAgJiBTUl9SRVEpIHsKCSAgICBwaGFzZSA9ICh0bXAgJiBQSEFTRV9NQVNLKTsgCgkgICAgaWYgKHBoYXNlICE9IG9sZF9waGFzZSkgewoJCW9sZF9waGFzZSA9IHBoYXNlOwoJCU5DUl9QUklOVF9QSEFTRShOREVCVUdfSU5GT1JNQVRJT04pOwoJICAgIH0KCSAgICAKCSAgICBpZiAoc2luayAmJiAocGhhc2UgIT0gUEhBU0VfTVNHT1VUKSkgewoJCU5DUjUzODBfd3JpdGUoVEFSR0VUX0NPTU1BTkRfUkVHLCBQSEFTRV9TUl9UT19UQ1IodG1wKSk7CgoJCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfQVROIHwgCgkJICAgIElDUl9BU1NFUlRfQUNLKTsKCQl3aGlsZSAoTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpICYgU1JfUkVRKTsKCQlOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCAKCQkgICAgSUNSX0FTU0VSVF9BVE4pOwoJCXNpbmsgPSAwOwoJCWNvbnRpbnVlOwoJICAgIH0KCgkgICAgc3dpdGNoIChwaGFzZSkgewoJICAgIGNhc2UgUEhBU0VfREFUQU9VVDoKI2lmIChOREVCVUcgJiBOREVCVUdfTk9fREFUQU9VVCkKCQlwcmludGsoInNjc2klZDogTkRFQlVHX05PX0RBVEFPVVQgc2V0LCBhdHRlbXB0ZWQgREFUQU9VVCAiCgkJICAgICAgICJhYm9ydGVkXG4iLCBIT1NUTk8pOwoJCXNpbmsgPSAxOwoJCWRvX2Fib3J0KGluc3RhbmNlKTsKCQljbWQtPnJlc3VsdCA9IERJRF9FUlJPUiAgPDwgMTY7CgkJY21kLT5kb25lKGNtZCk7CgkJcmV0dXJuOwojZW5kaWYKCSAgICBjYXNlIFBIQVNFX0RBVEFJTjoKCQkvKiAKCQkgKiBJZiB0aGVyZSBpcyBubyByb29tIGxlZnQgaW4gdGhlIGN1cnJlbnQgYnVmZmVyIGluIHRoZQoJCSAqIHNjYXR0ZXItZ2F0aGVyIGxpc3QsIG1vdmUgb250byB0aGUgbmV4dCBvbmUuCgkJICovCgoJCWlmICghY21kLT5TQ3AudGhpc19yZXNpZHVhbCAmJiBjbWQtPlNDcC5idWZmZXJzX3Jlc2lkdWFsKSB7CgkJICAgICsrY21kLT5TQ3AuYnVmZmVyOwoJCSAgICAtLWNtZC0+U0NwLmJ1ZmZlcnNfcmVzaWR1YWw7CgkJICAgIGNtZC0+U0NwLnRoaXNfcmVzaWR1YWwgPSBjbWQtPlNDcC5idWZmZXItPmxlbmd0aDsKCQkgICAgY21kLT5TQ3AucHRyID0gcGFnZV9hZGRyZXNzKGNtZC0+U0NwLmJ1ZmZlci0+cGFnZSkrCgkJCQkgICBjbWQtPlNDcC5idWZmZXItPm9mZnNldDsKCQkgICAgLyogKytyb21hbjogVHJ5IHRvIG1lcmdlIHNvbWUgc2NhdHRlci1idWZmZXJzIGlmCgkJICAgICAqIHRoZXkgYXJlIGF0IGNvbnRpZ3VvdXMgcGh5c2ljYWwgYWRkcmVzc2VzLgoJCSAgICAgKi8KCQkgICAgbWVyZ2VfY29udGlndW91c19idWZmZXJzKCBjbWQgKTsKCQkgICAgSU5GX1BSSU5USygic2NzaSVkOiAlZCBieXRlcyBhbmQgJWQgYnVmZmVycyBsZWZ0XG4iLAoJCQkgICAgICAgSE9TVE5PLCBjbWQtPlNDcC50aGlzX3Jlc2lkdWFsLAoJCQkgICAgICAgY21kLT5TQ3AuYnVmZmVyc19yZXNpZHVhbCk7CgkJfQoKCQkvKgoJCSAqIFRoZSBwcmVmZXJyZWQgdHJhbnNmZXIgbWV0aG9kIGlzIGdvaW5nIHRvIGJlIAoJCSAqIFBTRVVETy1ETUEgZm9yIHN5c3RlbXMgdGhhdCBhcmUgc3RyaWN0bHkgUElPLAoJCSAqIHNpbmNlIHdlIGNhbiBsZXQgdGhlIGhhcmR3YXJlIGRvIHRoZSBoYW5kc2hha2luZy4KCQkgKgoJCSAqIEZvciB0aGlzIHRvIHdvcmssIHdlIG5lZWQgdG8ga25vdyB0aGUgdHJhbnNmZXJzaXplCgkJICogYWhlYWQgb2YgdGltZSwgc2luY2UgdGhlIHBzZXVkby1ETUEgY29kZSB3aWxsIHNpdAoJCSAqIGluIGFuIHVuY29uZGl0aW9uYWwgbG9vcC4KCQkgKi8KCi8qICsrcm9tYW46IEkgc3VnZ2VzdCwgdGhpcyBzaG91bGQgYmUKICogICAjaWYgZGVmKFJFQUxfRE1BKQogKiBpbnN0ZWFkIG9mIGxlYXZpbmcgUkVBTF9ETUEgb3V0LgogKi8KCiNpZiBkZWZpbmVkKFJFQUxfRE1BKQoJCWlmICghY21kLT5kZXZpY2UtPmJvcmtlbiAmJgoJCSAgICAodHJhbnNmZXJzaXplID0gTkNSNTM4MF9kbWFfeGZlcl9sZW4oaW5zdGFuY2UsY21kLHBoYXNlKSkgPiAzMSkgewoJCSAgICBsZW4gPSB0cmFuc2ZlcnNpemU7CgkJICAgIGNtZC0+U0NwLnBoYXNlID0gcGhhc2U7CgkJICAgIGlmIChOQ1I1MzgwX3RyYW5zZmVyX2RtYShpbnN0YW5jZSwgJnBoYXNlLAoJCQkmbGVuLCAodW5zaWduZWQgY2hhciAqKikgJmNtZC0+U0NwLnB0cikpIHsKCQkJLyoKCQkJICogSWYgdGhlIHdhdGNoZG9nIHRpbWVyIGZpcmVzLCBhbGwgZnV0dXJlCgkJCSAqIGFjY2Vzc2VzIHRvIHRoaXMgZGV2aWNlIHdpbGwgdXNlIHRoZQoJCQkgKiBwb2xsZWQtSU8uICovIAoJCQlwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogc3dpdGNoaW5nIHRhcmdldCAlZCAiCgkJCSAgICAgICAibHVuICVkIHRvIHNsb3cgaGFuZHNoYWtlXG4iLCBIT1NUTk8sCgkJCSAgICAgICBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwoJCQljbWQtPmRldmljZS0+Ym9ya2VuID0gMTsKCQkJTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgCgkJCSAgICBJQ1JfQVNTRVJUX0FUTik7CgkJCXNpbmsgPSAxOwoJCQlkb19hYm9ydChpbnN0YW5jZSk7CgkJCWNtZC0+cmVzdWx0ID0gRElEX0VSUk9SICA8PCAxNjsKCQkJY21kLT5kb25lKGNtZCk7CgkJCS8qIFhYWCAtIG5lZWQgdG8gc291cmNlIG9yIHNpbmsgZGF0YSBoZXJlLCBhcyBhcHByb3ByaWF0ZSAqLwoJCSAgICB9IGVsc2UgewojaWZkZWYgUkVBTF9ETUEKCQkJLyogKytyb21hbjogV2hlbiB1c2luZyByZWFsIERNQSwKCQkJICogaW5mb3JtYXRpb25fdHJhbnNmZXIoKSBzaG91bGQgcmV0dXJuIGFmdGVyCgkJCSAqIHN0YXJ0aW5nIERNQSBzaW5jZSBpdCBoYXMgbm90aGluZyBtb3JlIHRvCgkJCSAqIGRvLgoJCQkgKi8KCQkJcmV0dXJuOwojZWxzZQkJCQoJCQljbWQtPlNDcC50aGlzX3Jlc2lkdWFsIC09IHRyYW5zZmVyc2l6ZSAtIGxlbjsKI2VuZGlmCgkJICAgIH0KCQl9IGVsc2UKI2VuZGlmIC8qIGRlZmluZWQoUkVBTF9ETUEpICovCgkJICBOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAKCQkgICAgKGludCAqKSAmY21kLT5TQ3AudGhpc19yZXNpZHVhbCwgKHVuc2lnbmVkIGNoYXIgKiopCgkJICAgICZjbWQtPlNDcC5wdHIpOwoJCWJyZWFrOwoJICAgIGNhc2UgUEhBU0VfTVNHSU46CgkJbGVuID0gMTsKCQlkYXRhID0gJnRtcDsKCQlOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCAwKTsgCS8qIGRpc2FibGUgcmVzZWxlY3RzICovCgkJTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpOwoJCWNtZC0+U0NwLk1lc3NhZ2UgPSB0bXA7CgoJCXN3aXRjaCAodG1wKSB7CgkJLyoKCQkgKiBMaW5raW5nIGxldHMgdXMgcmVkdWNlIHRoZSB0aW1lIHJlcXVpcmVkIHRvIGdldCB0aGUgCgkJICogbmV4dCBjb21tYW5kIG91dCB0byB0aGUgZGV2aWNlLCBob3BlZnVsbHkgdGhpcyB3aWxsCgkJICogbWVhbiB3ZSBkb24ndCB3YXN0ZSBhbm90aGVyIHJldm9sdXRpb24gZHVlIHRvIHRoZSBkZWxheXMKCQkgKiByZXF1aXJlZCBieSBBUkJJVFJBVElPTiBhbmQgYW5vdGhlciBTRUxFQ1RJT04uCgkJICoKCQkgKiBJbiB0aGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbiBwcm9wb3NhbCwgbG93IGxldmVsIGRyaXZlcnMKCQkgKiBtZXJlbHkgaGF2ZSB0byBzdGFydCB0aGUgbmV4dCBjb21tYW5kLCBwb2ludGVkIHRvIGJ5IAoJCSAqIG5leHRfbGluaywgZG9uZSgpIGlzIGNhbGxlZCBhcyB3aXRoIHVubGlua2VkIGNvbW1hbmRzLgoJCSAqLwojaWZkZWYgTElOS0VECgkJY2FzZSBMSU5LRURfQ01EX0NPTVBMRVRFOgoJCWNhc2UgTElOS0VEX0ZMR19DTURfQ09NUExFVEU6CgkJICAgIC8qIEFjY2VwdCBtZXNzYWdlIGJ5IGNsZWFyaW5nIEFDSyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJCSAgICAKCQkgICAgTE5LX1BSSU5USygic2NzaSVkOiB0YXJnZXQgJWQgbHVuICVkIGxpbmtlZCBjb21tYW5kICIKCQkJICAgICAgICJjb21wbGV0ZS5cbiIsIEhPU1ROTywgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuKTsKCgkJICAgIC8qIEVuYWJsZSByZXNlbGVjdCBpbnRlcnJ1cHRzICovCgkJICAgIE5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKCQkgICAgLyoKCQkgICAgICogU2FuaXR5IGNoZWNrIDogQSBsaW5rZWQgY29tbWFuZCBzaG91bGQgb25seSB0ZXJtaW5hdGUKCQkgICAgICogd2l0aCBvbmUgb2YgdGhlc2UgbWVzc2FnZXMgaWYgdGhlcmUgYXJlIG1vcmUgbGlua2VkCgkJICAgICAqIGNvbW1hbmRzIGF2YWlsYWJsZS4KCQkgICAgICovCgoJCSAgICBpZiAoIWNtZC0+bmV4dF9saW5rKSB7CgkJCSBwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogdGFyZ2V0ICVkIGx1biAlZCAiCgkJCQkibGlua2VkIGNvbW1hbmQgY29tcGxldGUsIG5vIG5leHRfbGlua1xuIiwKCQkJCUhPU1ROTywgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuKTsKCQkJICAgIHNpbmsgPSAxOwoJCQkgICAgZG9fYWJvcnQgKGluc3RhbmNlKTsKCQkJICAgIHJldHVybjsKCQkgICAgfQoKCQkgICAgaW5pdGlhbGl6ZV9TQ3AoY21kLT5uZXh0X2xpbmspOwoJCSAgICAvKiBUaGUgbmV4dCBjb21tYW5kIGlzIHN0aWxsIHBhcnQgb2YgdGhpcyBwcm9jZXNzOyBjb3B5IGl0CgkJICAgICAqIGFuZCBkb24ndCBmcmVlIGl0ISAqLwoJCSAgICBjbWQtPm5leHRfbGluay0+dGFnID0gY21kLT50YWc7CgkJICAgIGNtZC0+cmVzdWx0ID0gY21kLT5TQ3AuU3RhdHVzIHwgKGNtZC0+U0NwLk1lc3NhZ2UgPDwgOCk7IAoJCSAgICBMTktfUFJJTlRLKCJzY3NpJWQ6IHRhcmdldCAlZCBsdW4gJWQgbGlua2VkIHJlcXVlc3QgIgoJCQkgICAgICAgImRvbmUsIGNhbGxpbmcgc2NzaV9kb25lKCkuXG4iLAoJCQkgICAgICAgSE9TVE5PLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwojaWZkZWYgTkNSNTM4MF9TVEFUUwoJCSAgICBjb2xsZWN0X3N0YXRzKGhvc3RkYXRhLCBjbWQpOwojZW5kaWYKCQkgICAgY21kLT5zY3NpX2RvbmUoY21kKTsKCQkgICAgY21kID0gaG9zdGRhdGEtPmNvbm5lY3RlZDsKCQkgICAgYnJlYWs7CiNlbmRpZiAvKiBkZWYgTElOS0VEICovCgkJY2FzZSBBQk9SVDoKCQljYXNlIENPTU1BTkRfQ09NUExFVEU6IAoJCSAgICAvKiBBY2NlcHQgbWVzc2FnZSBieSBjbGVhcmluZyBBQ0sgKi8KCQkgICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCQkgICAgLyogKytndWVudGhlcjogcG9zc2libGUgcmFjZSB3aXRoIEZhbGNvbiBsb2NraW5nICovCgkJICAgIGZhbGNvbl9kb250X3JlbGVhc2UrKzsKCQkgICAgaG9zdGRhdGEtPmNvbm5lY3RlZCA9IE5VTEw7CgkJICAgIFFVX1BSSU5USygic2NzaSVkOiBjb21tYW5kIGZvciB0YXJnZXQgJWQsIGx1biAlZCAiCgkJCSAgICAgICJjb21wbGV0ZWRcbiIsIEhPU1ROTywgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuKTsKI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSAgICBjbWRfZnJlZV90YWcoIGNtZCApOwoJCSAgICBpZiAoc3RhdHVzX2J5dGUoY21kLT5TQ3AuU3RhdHVzKSA9PSBRVUVVRV9GVUxMKSB7CgkJCS8qIFR1cm4gYSBRVUVVRSBGVUxMIHN0YXR1cyBpbnRvIEJVU1ksIEkgdGhpbmsgdGhlCgkJCSAqIG1pZCBsZXZlbCBjYW5ub3QgaGFuZGxlIFFVRVVFIEZVTEwgOi0oIChUaGUKCQkJICogY29tbWFuZCBpcyByZXRyaWVkIGFmdGVyIEJVU1kpLiBBbHNvIHVwZGF0ZSBvdXIKCQkJICogcXVldWUgc2l6ZSB0byB0aGUgbnVtYmVyIG9mIGN1cnJlbnRseSBpc3N1ZWQKCQkJICogY29tbWFuZHMgbm93LgoJCQkgKi8KCQkJLyogKytBbmRyZWFzOiB0aGUgbWlkIGxldmVsIGNvZGUga25vd3MgYWJvdXQKCQkJICAgUVVFVUVfRlVMTCBub3cuICovCgkJCVRBR19BTExPQyAqdGEgPSAmVGFnQWxsb2NbY21kLT5kZXZpY2UtPmlkXVtjbWQtPmRldmljZS0+bHVuXTsKCQkJVEFHX1BSSU5USygic2NzaSVkOiB0YXJnZXQgJWQgbHVuICVkIHJldHVybmVkICIKCQkJCSAgICJRVUVVRV9GVUxMIGFmdGVyICVkIGNvbW1hbmRzXG4iLAoJCQkJICAgSE9TVE5PLCBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4sCgkJCQkgICB0YS0+bnJfYWxsb2NhdGVkKTsKCQkJaWYgKHRhLT5xdWV1ZV9zaXplID4gdGEtPm5yX2FsbG9jYXRlZCkKCQkJICAgIHRhLT5ucl9hbGxvY2F0ZWQgPSB0YS0+cXVldWVfc2l6ZTsKCQkgICAgfQojZWxzZQoJCSAgICBob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdICY9IH4oMSA8PCBjbWQtPmRldmljZS0+bHVuKTsKI2VuZGlmCgkJICAgIC8qIEVuYWJsZSByZXNlbGVjdCBpbnRlcnJ1cHRzICovCgkJICAgIE5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKCgkJICAgIC8qIAoJCSAgICAgKiBJJ20gbm90IHN1cmUgd2hhdCB0aGUgY29ycmVjdCB0aGluZyB0byBkbyBoZXJlIGlzIDogCgkJICAgICAqIAoJCSAgICAgKiBJZiB0aGUgY29tbWFuZCB0aGF0IGp1c3QgZXhlY3V0ZWQgaXMgTk9UIGEgcmVxdWVzdCAKCQkgICAgICogc2Vuc2UsIHRoZSBvYnZpb3VzIHRoaW5nIHRvIGRvIGlzIHRvIHNldCB0aGUgcmVzdWx0CgkJICAgICAqIGNvZGUgdG8gdGhlIHZhbHVlcyBvZiB0aGUgc3RvcmVkIHBhcmFtZXRlcnMuCgkJICAgICAqIAoJCSAgICAgKiBJZiBpdCB3YXMgYSBSRVFVRVNUIFNFTlNFIGNvbW1hbmQsIHdlIG5lZWQgc29tZSB3YXkgdG8KCQkgICAgICogZGlmZmVyZW50aWF0ZSBiZXR3ZWVuIHRoZSBmYWlsdXJlIGNvZGUgb2YgdGhlIG9yaWdpbmFsCgkJICAgICAqIGFuZCB0aGUgZmFpbHVyZSBjb2RlIG9mIHRoZSBSRVFVRVNUIHNlbnNlIC0gdGhlIG9idmlvdXMKCQkgICAgICogY2FzZSBpcyBzdWNjZXNzLCB3aGVyZSB3ZSBmYWxsIHRocm91Z2ggYW5kIGxlYXZlIHRoZQoJCSAgICAgKiByZXN1bHQgY29kZSB1bmNoYW5nZWQuCgkJICAgICAqIAoJCSAgICAgKiBUaGUgbm9uLW9idmlvdXMgcGxhY2UgaXMgd2hlcmUgdGhlIFJFUVVFU1QgU0VOU0UgZmFpbGVkCgkJICAgICAqLwoKCQkgICAgaWYgKGNtZC0+Y21uZFswXSAhPSBSRVFVRVNUX1NFTlNFKSAKCQkJY21kLT5yZXN1bHQgPSBjbWQtPlNDcC5TdGF0dXMgfCAoY21kLT5TQ3AuTWVzc2FnZSA8PCA4KTsgCgkJICAgIGVsc2UgaWYgKHN0YXR1c19ieXRlKGNtZC0+U0NwLlN0YXR1cykgIT0gR09PRCkKCQkJY21kLT5yZXN1bHQgPSAoY21kLT5yZXN1bHQgJiAweDAwZmZmZikgfCAoRElEX0VSUk9SIDw8IDE2KTsKCQkgICAgCiNpZmRlZiBBVVRPU0VOU0UKCQkgICAgaWYgKChjbWQtPmNtbmRbMF0gIT0gUkVRVUVTVF9TRU5TRSkgJiYgCgkJCShzdGF0dXNfYnl0ZShjbWQtPlNDcC5TdGF0dXMpID09IENIRUNLX0NPTkRJVElPTikpIHsKCQkJQVNFTl9QUklOVEsoInNjc2klZDogcGVyZm9ybWluZyByZXF1ZXN0IHNlbnNlXG4iLAoJCQkJICAgIEhPU1ROTyk7CgkJCWNtZC0+Y21uZFswXSA9IFJFUVVFU1RfU0VOU0U7CgkJCWNtZC0+Y21uZFsxXSAmPSAweGUwOwoJCQljbWQtPmNtbmRbMl0gPSAwOwoJCQljbWQtPmNtbmRbM10gPSAwOwoJCQljbWQtPmNtbmRbNF0gPSBzaXplb2YoY21kLT5zZW5zZV9idWZmZXIpOwoJCQljbWQtPmNtbmRbNV0gPSAwOwoJCQljbWQtPmNtZF9sZW4gPSBDT01NQU5EX1NJWkUoY21kLT5jbW5kWzBdKTsKCgkJCWNtZC0+dXNlX3NnID0gMDsKCQkJLyogdGhpcyBpcyBpbml0aWFsaXplZCBmcm9tIGluaXRpYWxpemVfU0NwIAoJCQljbWQtPlNDcC5idWZmZXIgPSBOVUxMOwoJCQljbWQtPlNDcC5idWZmZXJzX3Jlc2lkdWFsID0gMDsKCQkJKi8KCQkJY21kLT5yZXF1ZXN0X2J1ZmZlciA9IChjaGFyICopIGNtZC0+c2Vuc2VfYnVmZmVyOwoJCQljbWQtPnJlcXVlc3RfYnVmZmxlbiA9IHNpemVvZihjbWQtPnNlbnNlX2J1ZmZlcik7CgoJCQlsb2NhbF9pcnFfc2F2ZShmbGFncyk7CgkJCUxJU1QoY21kLGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSk7CgkJCU5FWFQoY21kKSA9IGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZTsKCQkgICAgICAgIGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSA9IChTY3NpX0NtbmQgKikgY21kOwoJCSAgICAgICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJCQlRVV9QUklOVEsoInNjc2klZDogUkVRVUVTVCBTRU5TRSBhZGRlZCB0byBoZWFkIG9mICIKCQkJCSAgImlzc3VlIHF1ZXVlXG4iLCBIX05PKGNtZCkpOwoJCSAgIH0gZWxzZQojZW5kaWYgLyogZGVmIEFVVE9TRU5TRSAqLwoJCSAgIHsKI2lmZGVmIE5DUjUzODBfU1RBVFMKCQkgICAgICAgY29sbGVjdF9zdGF0cyhob3N0ZGF0YSwgY21kKTsKI2VuZGlmCgkJICAgICAgIGNtZC0+c2NzaV9kb25lKGNtZCk7CgkJICAgIH0KCgkJICAgIE5DUjUzODBfd3JpdGUoU0VMRUNUX0VOQUJMRV9SRUcsIGhvc3RkYXRhLT5pZF9tYXNrKTsKCQkgICAgLyogCgkJICAgICAqIFJlc3RvcmUgcGhhc2UgYml0cyB0byAwIHNvIGFuIGludGVycnVwdGVkIHNlbGVjdGlvbiwgCgkJICAgICAqIGFyYml0cmF0aW9uIGNhbiByZXN1bWUuCgkJICAgICAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKFRBUkdFVF9DT01NQU5EX1JFRywgMCk7CgkJICAgIAoJCSAgICB3aGlsZSAoKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFNSX0JTWSkgJiYgIWhvc3RkYXRhLT5jb25uZWN0ZWQpCgkJCWJhcnJpZXIoKTsKCgkJICAgIGZhbGNvbl9kb250X3JlbGVhc2UtLTsKCQkgICAgLyogKytyb21hbjogRm9yIEZhbGNvbiBTQ1NJLCByZWxlYXNlIHRoZSBsb2NrIG9uIHRoZQoJCSAgICAgKiBTVC1ETUEgaGVyZSBpZiBubyBvdGhlciBjb21tYW5kcyBhcmUgd2FpdGluZyBvbiB0aGUKCQkgICAgICogZGlzY29ubmVjdGVkIHF1ZXVlLgoJCSAgICAgKi8KCQkgICAgZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsKCQkgICAgcmV0dXJuOwoJCWNhc2UgTUVTU0FHRV9SRUpFQ1Q6CgkJICAgIC8qIEFjY2VwdCBtZXNzYWdlIGJ5IGNsZWFyaW5nIEFDSyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoJCSAgICAvKiBFbmFibGUgcmVzZWxlY3QgaW50ZXJydXB0cyAqLwoJCSAgICBOQ1I1MzgwX3dyaXRlKFNFTEVDVF9FTkFCTEVfUkVHLCBob3N0ZGF0YS0+aWRfbWFzayk7CgkJICAgIHN3aXRjaCAoaG9zdGRhdGEtPmxhc3RfbWVzc2FnZSkgewoJCSAgICBjYXNlIEhFQURfT0ZfUVVFVUVfVEFHOgoJCSAgICBjYXNlIE9SREVSRURfUVVFVUVfVEFHOgoJCSAgICBjYXNlIFNJTVBMRV9RVUVVRV9UQUc6CgkJCS8qIFRoZSB0YXJnZXQgb2J2aW91c2x5IGRvZXNuJ3Qgc3VwcG9ydCB0YWdnZWQKCQkJICogcXVldWluZywgZXZlbiB0aG91Z2ggaXQgYW5ub3VuY2VkIHRoaXMgYWJpbGl0eSBpbgoJCQkgKiBpdHMgSU5RVUlSWSBkYXRhID8hPyAobWF5YmUgb25seSB0aGlzIExVTj8pIE9rLAoJCQkgKiBjbGVhciAndGFnZ2VkX3N1cHBvcnRlZCcgYW5kIGxvY2sgdGhlIExVTiwgc2luY2UKCQkJICogdGhlIGNvbW1hbmQgaXMgdHJlYXRlZCBhcyB1bnRhZ2dlZCBmdXJ0aGVyIG9uLgoJCQkgKi8KCQkJY21kLT5kZXZpY2UtPnRhZ2dlZF9zdXBwb3J0ZWQgPSAwOwoJCQlob3N0ZGF0YS0+YnVzeVtjbWQtPmRldmljZS0+aWRdIHw9ICgxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwoJCQljbWQtPnRhZyA9IFRBR19OT05FOwoJCQlUQUdfUFJJTlRLKCJzY3NpJWQ6IHRhcmdldCAlZCBsdW4gJWQgcmVqZWN0ZWQgIgoJCQkJICAgIlFVRVVFX1RBRyBtZXNzYWdlOyB0YWdnZWQgcXVldWluZyAiCgkJCQkgICAiZGlzYWJsZWRcbiIsCgkJCQkgICBIT1NUTk8sIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1bik7CgkJCWJyZWFrOwoJCSAgICB9CgkJICAgIGJyZWFrOwoJCWNhc2UgRElTQ09OTkVDVDoKCQkgICAgLyogQWNjZXB0IG1lc3NhZ2UgYnkgY2xlYXJpbmcgQUNLICovCgkJICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CgkJICAgIGxvY2FsX2lycV9zYXZlKGZsYWdzKTsKCQkgICAgY21kLT5kZXZpY2UtPmRpc2Nvbm5lY3QgPSAxOwoJCSAgICBMSVNUKGNtZCxob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlKTsKCQkgICAgTkVYVChjbWQpID0gaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZTsKCQkgICAgaG9zdGRhdGEtPmNvbm5lY3RlZCA9IE5VTEw7CgkJICAgIGhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUgPSBjbWQ7CgkJICAgIGxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKCQkgICAgUVVfUFJJTlRLKCJzY3NpJWQ6IGNvbW1hbmQgZm9yIHRhcmdldCAlZCBsdW4gJWQgd2FzICIKCQkJICAgICAgIm1vdmVkIGZyb20gY29ubmVjdGVkIHRvIHRoZSAiCgkJCSAgICAgICJkaXNjb25uZWN0ZWRfcXVldWVcbiIsIEhPU1ROTywgCgkJCSAgICAgIGNtZC0+ZGV2aWNlLT5pZCwgY21kLT5kZXZpY2UtPmx1bik7CgkJICAgIC8qIAoJCSAgICAgKiBSZXN0b3JlIHBoYXNlIGJpdHMgdG8gMCBzbyBhbiBpbnRlcnJ1cHRlZCBzZWxlY3Rpb24sIAoJCSAgICAgKiBhcmJpdHJhdGlvbiBjYW4gcmVzdW1lLgoJCSAgICAgKi8KCQkgICAgTkNSNTM4MF93cml0ZShUQVJHRVRfQ09NTUFORF9SRUcsIDApOwoKCQkgICAgLyogRW5hYmxlIHJlc2VsZWN0IGludGVycnVwdHMgKi8KCQkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJCSAgICAvKiBXYWl0IGZvciBidXMgZnJlZSB0byBhdm9pZCBuYXN0eSB0aW1lb3V0cyAqLwoJCSAgICB3aGlsZSAoKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFNSX0JTWSkgJiYgIWhvc3RkYXRhLT5jb25uZWN0ZWQpCgkJICAgIAliYXJyaWVyKCk7CgkJICAgIHJldHVybjsKCQkvKiAKCQkgKiBUaGUgU0NTSSBkYXRhIHBvaW50ZXIgaXMgKklNUExJQ0lUTFkqIHNhdmVkIG9uIGEgZGlzY29ubmVjdAoJCSAqIG9wZXJhdGlvbiwgaW4gdmlvbGF0aW9uIG9mIHRoZSBTQ1NJIHNwZWMgc28gd2UgY2FuIHNhZmVseSAKCQkgKiBpZ25vcmUgU0FWRS9SRVNUT1JFIHBvaW50ZXJzIGNhbGxzLgoJCSAqCgkJICogVW5mb3J0dW5hdGVseSwgc29tZSBkaXNrcyB2aW9sYXRlIHRoZSBTQ1NJIHNwZWMgYW5kIAoJCSAqIGRvbid0IGlzc3VlIHRoZSByZXF1aXJlZCBTQVZFX1BPSU5URVJTIG1lc3NhZ2UgYmVmb3JlCgkJICogZGlzY29ubmVjdGluZywgYW5kIHdlIGhhdmUgdG8gYnJlYWsgc3BlYyB0byByZW1haW4gCgkJICogY29tcGF0aWJsZS4KCQkgKi8KCQljYXNlIFNBVkVfUE9JTlRFUlM6CgkJY2FzZSBSRVNUT1JFX1BPSU5URVJTOgoJCSAgICAvKiBBY2NlcHQgbWVzc2FnZSBieSBjbGVhcmluZyBBQ0sgKi8KCQkgICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCQkgICAgLyogRW5hYmxlIHJlc2VsZWN0IGludGVycnVwdHMgKi8KCQkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJCSAgICBicmVhazsKCQljYXNlIEVYVEVOREVEX01FU1NBR0U6Ci8qIAogKiBFeHRlbmRlZCBtZXNzYWdlcyBhcmUgc2VudCBpbiB0aGUgZm9sbG93aW5nIGZvcm1hdCA6CiAqIEJ5dGUgCQogKiAwCQlFWFRFTkRFRF9NRVNTQUdFID09IDEKICogMQkJbGVuZ3RoIChpbmNsdWRlcyBvbmUgYnl0ZSBmb3IgY29kZSwgZG9lc24ndCAKICoJCWluY2x1ZGUgZmlyc3QgdHdvIGJ5dGVzKQogKiAyIAkJY29kZQogKiAzLi5sZW5ndGgrMQlhcmd1bWVudHMKICoKICogU3RhcnQgdGhlIGV4dGVuZGVkIG1lc3NhZ2UgYnVmZmVyIHdpdGggdGhlIEVYVEVOREVEX01FU1NBR0UKICogYnl0ZSwgc2luY2Ugc3BpX3ByaW50X21zZygpIHdhbnRzIHRoZSB3aG9sZSB0aGluZy4gIAogKi8KCQkgICAgZXh0ZW5kZWRfbXNnWzBdID0gRVhURU5ERURfTUVTU0FHRTsKCQkgICAgLyogQWNjZXB0IGZpcnN0IGJ5dGUgYnkgY2xlYXJpbmcgQUNLICovCgkJICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CgoJCSAgICBFWFRfUFJJTlRLKCJzY3NpJWQ6IHJlY2VpdmluZyBleHRlbmRlZCBtZXNzYWdlXG4iLCBIT1NUTk8pOwoKCQkgICAgbGVuID0gMjsKCQkgICAgZGF0YSA9IGV4dGVuZGVkX21zZyArIDE7CgkJICAgIHBoYXNlID0gUEhBU0VfTVNHSU47CgkJICAgIE5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sICZkYXRhKTsKCQkgICAgRVhUX1BSSU5USygic2NzaSVkOiBsZW5ndGg9JWQsIGNvZGU9MHglMDJ4XG4iLCBIT1NUTk8sCgkJCSAgICAgICAoaW50KWV4dGVuZGVkX21zZ1sxXSwgKGludClleHRlbmRlZF9tc2dbMl0pOwoKCQkgICAgaWYgKCFsZW4gJiYgZXh0ZW5kZWRfbXNnWzFdIDw9IAoJCQkoc2l6ZW9mIChleHRlbmRlZF9tc2cpIC0gMSkpIHsKCQkJLyogQWNjZXB0IHRoaXJkIGJ5dGUgYnkgY2xlYXJpbmcgQUNLICovCgkJCU5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSk7CgkJCWxlbiA9IGV4dGVuZGVkX21zZ1sxXSAtIDE7CgkJCWRhdGEgPSBleHRlbmRlZF9tc2cgKyAzOwoJCQlwaGFzZSA9IFBIQVNFX01TR0lOOwoKCQkJTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpOwoJCQlFWFRfUFJJTlRLKCJzY3NpJWQ6IG1lc3NhZ2UgcmVjZWl2ZWQsIHJlc2lkdWFsICVkXG4iLAoJCQkJICAgSE9TVE5PLCBsZW4pOwoKCQkJc3dpdGNoIChleHRlbmRlZF9tc2dbMl0pIHsKCQkJY2FzZSBFWFRFTkRFRF9TRFRSOgoJCQljYXNlIEVYVEVOREVEX1dEVFI6CgkJCWNhc2UgRVhURU5ERURfTU9ESUZZX0RBVEFfUE9JTlRFUjoKCQkJY2FzZSBFWFRFTkRFRF9FWFRFTkRFRF9JREVOVElGWToKCQkJICAgIHRtcCA9IDA7CgkJCX0KCQkgICAgfSBlbHNlIGlmIChsZW4pIHsKCQkJcHJpbnRrKEtFUk5fTk9USUNFICJzY3NpJWQ6IGVycm9yIHJlY2VpdmluZyAiCgkJCSAgICAgICAiZXh0ZW5kZWQgbWVzc2FnZVxuIiwgSE9TVE5PKTsKCQkJdG1wID0gMDsKCQkgICAgfSBlbHNlIHsKCQkJcHJpbnRrKEtFUk5fTk9USUNFICJzY3NpJWQ6IGV4dGVuZGVkIG1lc3NhZ2UgIgoJCQkgICAgICAgImNvZGUgJTAyeCBsZW5ndGggJWQgaXMgdG9vIGxvbmdcbiIsCgkJCSAgICAgICBIT1NUTk8sIGV4dGVuZGVkX21zZ1syXSwgZXh0ZW5kZWRfbXNnWzFdKTsKCQkJdG1wID0gMDsKCQkgICAgfQoJCS8qIEZhbGwgdGhyb3VnaCB0byByZWplY3QgbWVzc2FnZSAqLwoKCQkvKiAKICAJCSAqIElmIHdlIGdldCBzb21ldGhpbmcgd2VpcmQgdGhhdCB3ZSBhcmVuJ3QgZXhwZWN0aW5nLCAKIAkJICogcmVqZWN0IGl0LgoJCSAqLwoJCWRlZmF1bHQ6CgkJICAgIGlmICghdG1wKSB7CgkJCXByaW50ayhLRVJOX0RFQlVHICJzY3NpJWQ6IHJlamVjdGluZyBtZXNzYWdlICIsIEhPU1ROTyk7CgkJCXNwaV9wcmludF9tc2coZXh0ZW5kZWRfbXNnKTsKCQkJcHJpbnRrKCJcbiIpOwoJCSAgICB9IGVsc2UgaWYgKHRtcCAhPSBFWFRFTkRFRF9NRVNTQUdFKQoJCQlwcmludGsoS0VSTl9ERUJVRyAic2NzaSVkOiByZWplY3RpbmcgdW5rbm93biAiCgkJCSAgICAgICAibWVzc2FnZSAlMDJ4IGZyb20gdGFyZ2V0ICVkLCBsdW4gJWRcbiIsCgkJCSAgICAgICBIT1NUTk8sIHRtcCwgY21kLT5kZXZpY2UtPmlkLCBjbWQtPmRldmljZS0+bHVuKTsKCQkgICAgZWxzZQoJCQlwcmludGsoS0VSTl9ERUJVRyAic2NzaSVkOiByZWplY3RpbmcgdW5rbm93biAiCgkJCSAgICAgICAiZXh0ZW5kZWQgbWVzc2FnZSAiCgkJCSAgICAgICAiY29kZSAlMDJ4LCBsZW5ndGggJWQgZnJvbSB0YXJnZXQgJWQsIGx1biAlZFxuIiwKCQkJICAgICAgIEhPU1ROTywgZXh0ZW5kZWRfbXNnWzFdLCBleHRlbmRlZF9tc2dbMF0sCgkJCSAgICAgICBjbWQtPmRldmljZS0+aWQsIGNtZC0+ZGV2aWNlLT5sdW4pOwogICAKCgkJICAgIG1zZ291dCA9IE1FU1NBR0VfUkVKRUNUOwoJCSAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgfCAKCQkJSUNSX0FTU0VSVF9BVE4pOwoJCSAgICBicmVhazsKCQl9IC8qIHN3aXRjaCAodG1wKSAqLwoJCWJyZWFrOwoJICAgIGNhc2UgUEhBU0VfTVNHT1VUOgoJCWxlbiA9IDE7CgkJZGF0YSA9ICZtc2dvdXQ7CgkJaG9zdGRhdGEtPmxhc3RfbWVzc2FnZSA9IG1zZ291dDsKCQlOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAmZGF0YSk7CgkJaWYgKG1zZ291dCA9PSBBQk9SVCkgewojaWZkZWYgU1VQUE9SVF9UQUdTCgkJICAgIGNtZF9mcmVlX3RhZyggY21kICk7CiNlbHNlCgkJICAgIGhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gJj0gfigxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwojZW5kaWYKCQkgICAgaG9zdGRhdGEtPmNvbm5lY3RlZCA9IE5VTEw7CgkJICAgIGNtZC0+cmVzdWx0ID0gRElEX0VSUk9SIDw8IDE2OwojaWZkZWYgTkNSNTM4MF9TVEFUUwoJCSAgICBjb2xsZWN0X3N0YXRzKGhvc3RkYXRhLCBjbWQpOwojZW5kaWYKCQkgICAgY21kLT5zY3NpX2RvbmUoY21kKTsKCQkgICAgTkNSNTM4MF93cml0ZShTRUxFQ1RfRU5BQkxFX1JFRywgaG9zdGRhdGEtPmlkX21hc2spOwoJCSAgICBmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOwoJCSAgICByZXR1cm47CgkJfQoJCW1zZ291dCA9IE5PUDsKCQlicmVhazsKCSAgICBjYXNlIFBIQVNFX0NNRE9VVDoKCQlsZW4gPSBjbWQtPmNtZF9sZW47CgkJZGF0YSA9IGNtZC0+Y21uZDsKCQkvKiAKCQkgKiBYWFggZm9yIHBlcmZvcm1hbmNlIHJlYXNvbnMsIG9uIG1hY2hpbmVzIHdpdGggYSAKCQkgKiBQU0VVRE8tRE1BIGFyY2hpdGVjdHVyZSB3ZSBzaG91bGQgcHJvYmFibHkgCgkJICogdXNlIHRoZSBkbWEgdHJhbnNmZXIgZnVuY3Rpb24uICAKCQkgKi8KCQlOQ1I1MzgwX3RyYW5zZmVyX3BpbyhpbnN0YW5jZSwgJnBoYXNlLCAmbGVuLCAKCQkgICAgJmRhdGEpOwoJCWJyZWFrOwoJICAgIGNhc2UgUEhBU0VfU1RBVElOOgoJCWxlbiA9IDE7CgkJZGF0YSA9ICZ0bXA7CgkJTkNSNTM4MF90cmFuc2Zlcl9waW8oaW5zdGFuY2UsICZwaGFzZSwgJmxlbiwgJmRhdGEpOwoJCWNtZC0+U0NwLlN0YXR1cyA9IHRtcDsKCQlicmVhazsKCSAgICBkZWZhdWx0OgoJCXByaW50aygic2NzaSVkOiB1bmtub3duIHBoYXNlXG4iLCBIT1NUTk8pOwoJCU5DUl9QUklOVChOREVCVUdfQU5ZKTsKCSAgICB9IC8qIHN3aXRjaChwaGFzZSkgKi8KCX0gLyogaWYgKHRtcCAqIFNSX1JFUSkgKi8gCiAgICB9IC8qIHdoaWxlICgxKSAqLwp9CgovKgogKiBGdW5jdGlvbiA6IHZvaWQgTkNSNTM4MF9yZXNlbGVjdCAoc3RydWN0IFNjc2lfSG9zdCAqaW5zdGFuY2UpCiAqCiAqIFB1cnBvc2UgOiBkb2VzIHJlc2VsZWN0aW9uLCBpbml0aWFsaXppbmcgdGhlIGluc3RhbmNlLT5jb25uZWN0ZWQgCiAqCWZpZWxkIHRvIHBvaW50IHRvIHRoZSBTY3NpX0NtbmQgZm9yIHdoaWNoIHRoZSBJX1RfTCBvciBJX1RfTF9RIAogKgluZXh1cyBoYXMgYmVlbiByZWVzdGFibGlzaGVkLAogKgkKICogSW5wdXRzIDogaW5zdGFuY2UgLSB0aGlzIGluc3RhbmNlIG9mIHRoZSBOQ1I1MzgwLgogKgogKi8KCgpzdGF0aWMgdm9pZCBOQ1I1MzgwX3Jlc2VsZWN0IChzdHJ1Y3QgU2NzaV9Ib3N0ICppbnN0YW5jZSkKewogICAgU0VUVVBfSE9TVERBVEEoaW5zdGFuY2UpOwogICAgdW5zaWduZWQgY2hhciB0YXJnZXRfbWFzazsKICAgIHVuc2lnbmVkIGNoYXIgbHVuLCBwaGFzZTsKICAgIGludCBsZW47CiNpZmRlZiBTVVBQT1JUX1RBR1MKICAgIHVuc2lnbmVkIGNoYXIgdGFnOwojZW5kaWYKICAgIHVuc2lnbmVkIGNoYXIgbXNnWzNdOwogICAgdW5zaWduZWQgY2hhciAqZGF0YTsKICAgIFNjc2lfQ21uZCAqdG1wID0gTlVMTCwgKnByZXY7Ci8qICAgIHVuc2lnbmVkIGxvbmcgZmxhZ3M7ICovCgogICAgLyoKICAgICAqIERpc2FibGUgYXJiaXRyYXRpb24sIGV0Yy4gc2luY2UgdGhlIGhvc3QgYWRhcHRlciBvYnZpb3VzbHkKICAgICAqIGxvc3QsIGFuZCB0ZWxsIGFuIGludGVycnVwdGVkIE5DUjUzODBfc2VsZWN0KCkgdG8gcmVzdGFydC4KICAgICAqLwoKICAgIE5DUjUzODBfd3JpdGUoTU9ERV9SRUcsIE1SX0JBU0UpOwogICAgaG9zdGRhdGEtPnJlc3RhcnRfc2VsZWN0ID0gMTsKCiAgICB0YXJnZXRfbWFzayA9IE5DUjUzODBfcmVhZChDVVJSRU5UX1NDU0lfREFUQV9SRUcpICYgfihob3N0ZGF0YS0+aWRfbWFzayk7CgogICAgUlNMX1BSSU5USygic2NzaSVkOiByZXNlbGVjdFxuIiwgSE9TVE5PKTsKCiAgICAvKiAKICAgICAqIEF0IHRoaXMgcG9pbnQsIHdlIGhhdmUgZGV0ZWN0ZWQgdGhhdCBvdXIgU0NTSSBJRCBpcyBvbiB0aGUgYnVzLAogICAgICogU0VMIGlzIHRydWUgYW5kIEJTWSB3YXMgZmFsc2UgZm9yIGF0IGxlYXN0IG9uZSBidXMgc2V0dGxlIGRlbGF5CiAgICAgKiAoNDAwIG5zKS4KICAgICAqCiAgICAgKiBXZSBtdXN0IGFzc2VydCBCU1kgb3Vyc2VsdmVzLCB1bnRpbCB0aGUgdGFyZ2V0IGRyb3BzIHRoZSBTRUwKICAgICAqIHNpZ25hbC4KICAgICAqLwoKICAgIE5DUjUzODBfd3JpdGUoSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSB8IElDUl9BU1NFUlRfQlNZKTsKICAgIAogICAgd2hpbGUgKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFNSX1NFTCk7CiAgICBOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UpOwoKICAgIC8qCiAgICAgKiBXYWl0IGZvciB0YXJnZXQgdG8gZ28gaW50byBNU0dJTi4KICAgICAqLwoKICAgIHdoaWxlICghKE5DUjUzODBfcmVhZChTVEFUVVNfUkVHKSAmIFNSX1JFUSkpOwoKICAgIGxlbiA9IDE7CiAgICBkYXRhID0gbXNnOwogICAgcGhhc2UgPSBQSEFTRV9NU0dJTjsKICAgIE5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sICZkYXRhKTsKCiAgICBpZiAoIShtc2dbMF0gJiAweDgwKSkgewoJcHJpbnRrKEtFUk5fREVCVUcgInNjc2klZDogZXhwZWN0aW5nIElERU5USUZZIG1lc3NhZ2UsIGdvdCAiLCBIT1NUTk8pOwoJc3BpX3ByaW50X21zZyhtc2cpOwoJZG9fYWJvcnQoaW5zdGFuY2UpOwoJcmV0dXJuOwogICAgfQogICAgbHVuID0gKG1zZ1swXSAmIDB4MDcpOwoKI2lmZGVmIFNVUFBPUlRfVEFHUwogICAgLyogSWYgdGhlIHBoYXNlIGlzIHN0aWxsIE1TR0lOLCB0aGUgdGFyZ2V0IHdhbnRzIHRvIHNlbmQgc29tZSBtb3JlCiAgICAgKiBtZXNzYWdlcy4gSW4gY2FzZSBpdCBzdXBwb3J0cyB0YWdnZWQgcXVldWluZywgdGhpcyBpcyBwcm9iYWJseSBhCiAgICAgKiBTSU1QTEVfUVVFVUVfVEFHIGZvciB0aGUgSV9UX0xfUSBuZXh1cy4KICAgICAqLwogICAgdGFnID0gVEFHX05PTkU7CiAgICBpZiAocGhhc2UgPT0gUEhBU0VfTVNHSU4gJiYgc2V0dXBfdXNlX3RhZ2dlZF9xdWV1aW5nKSB7CgkvKiBBY2NlcHQgcHJldmlvdXMgSURFTlRJRlkgbWVzc2FnZSBieSBjbGVhcmluZyBBQ0sgKi8KCU5DUjUzODBfd3JpdGUoIElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0JBU0UgKTsKCWxlbiA9IDI7CglkYXRhID0gbXNnKzE7CglpZiAoIU5DUjUzODBfdHJhbnNmZXJfcGlvKGluc3RhbmNlLCAmcGhhc2UsICZsZW4sICZkYXRhKSAmJgoJICAgIG1zZ1sxXSA9PSBTSU1QTEVfUVVFVUVfVEFHKQoJICAgIHRhZyA9IG1zZ1syXTsKCVRBR19QUklOVEsoInNjc2klZDogdGFyZ2V0IG1hc2sgJTAyeCwgbHVuICVkIHNlbnQgdGFnICVkIGF0ICIKCQkgICAicmVzZWxlY3Rpb25cbiIsIEhPU1ROTywgdGFyZ2V0X21hc2ssIGx1biwgdGFnKTsKICAgIH0KI2VuZGlmCiAgICAKICAgIC8qIAogICAgICogRmluZCB0aGUgY29tbWFuZCBjb3JyZXNwb25kaW5nIHRvIHRoZSBJX1RfTCBvciBJX1RfTF9RICBuZXh1cyB3ZSAKICAgICAqIGp1c3QgcmVlc3RhYmxpc2hlZCwgYW5kIHJlbW92ZSBpdCBmcm9tIHRoZSBkaXNjb25uZWN0ZWQgcXVldWUuCiAgICAgKi8KCiAgICBmb3IgKHRtcCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSwgcHJldiA9IE5VTEw7IAoJIHRtcDsgcHJldiA9IHRtcCwgdG1wID0gTkVYVCh0bXApICkgewoJaWYgKCh0YXJnZXRfbWFzayA9PSAoMSA8PCB0bXAtPmRldmljZS0+aWQpKSAmJiAobHVuID09IHRtcC0+ZGV2aWNlLT5sdW4pCiNpZmRlZiBTVVBQT1JUX1RBR1MKCSAgICAmJiAodGFnID09IHRtcC0+dGFnKSAKI2VuZGlmCgkgICAgKSB7CgkgICAgLyogKytndWVudGhlcjogcHJldmVudCByYWNlIHdpdGggZmFsY29uX3JlbGVhc2VfbG9jayAqLwoJICAgIGZhbGNvbl9kb250X3JlbGVhc2UrKzsKCSAgICBpZiAocHJldikgewoJCVJFTU9WRShwcmV2LCBORVhUKHByZXYpLCB0bXAsIE5FWFQodG1wKSk7CgkJTkVYVChwcmV2KSA9IE5FWFQodG1wKTsKCSAgICB9IGVsc2UgewoJCVJFTU9WRSgtMSwgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSwgdG1wLCBORVhUKHRtcCkpOwoJCWhvc3RkYXRhLT5kaXNjb25uZWN0ZWRfcXVldWUgPSBORVhUKHRtcCk7CgkgICAgfQoJICAgIE5FWFQodG1wKSA9IE5VTEw7CgkgICAgYnJlYWs7Cgl9CiAgICB9CiAgICAKICAgIGlmICghdG1wKSB7CglwcmludGsoS0VSTl9XQVJOSU5HICJzY3NpJWQ6IHdhcm5pbmc6IHRhcmdldCBiaXRtYXNrICUwMnggbHVuICVkICIKI2lmZGVmIFNVUFBPUlRfVEFHUwoJCSJ0YWcgJWQgIgojZW5kaWYKCQkibm90IGluIGRpc2Nvbm5lY3RlZF9xdWV1ZS5cbiIsCgkJSE9TVE5PLCB0YXJnZXRfbWFzaywgbHVuCiNpZmRlZiBTVVBQT1JUX1RBR1MKCQksIHRhZwojZW5kaWYKCQkpOwoJLyogCgkgKiBTaW5jZSB3ZSBoYXZlIGFuIGVzdGFibGlzaGVkIG5leHVzIHRoYXQgd2UgY2FuJ3QgZG8gYW55dGhpbmcKCSAqIHdpdGgsIHdlIG11c3QgYWJvcnQgaXQuICAKCSAqLwoJZG9fYWJvcnQoaW5zdGFuY2UpOwoJcmV0dXJuOwogICAgfQoKICAgIC8qIEFjY2VwdCBtZXNzYWdlIGJ5IGNsZWFyaW5nIEFDSyAqLwogICAgTkNSNTM4MF93cml0ZShJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFKTsKCiAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gdG1wOwogICAgUlNMX1BSSU5USygic2NzaSVkOiBuZXh1cyBlc3RhYmxpc2hlZCwgdGFyZ2V0ID0gJWQsIGx1biA9ICVkLCB0YWcgPSAlZFxuIiwKCSAgICAgICBIT1NUTk8sIHRtcC0+ZGV2aWNlLT5pZCwgdG1wLT5kZXZpY2UtPmx1biwgdG1wLT50YWcpOwogICAgZmFsY29uX2RvbnRfcmVsZWFzZS0tOwp9CgoKLyoKICogRnVuY3Rpb24gOiBpbnQgTkNSNTM4MF9hYm9ydCAoU2NzaV9DbW5kICpjbWQpCiAqCiAqIFB1cnBvc2UgOiBhYm9ydCBhIGNvbW1hbmQKICoKICogSW5wdXRzIDogY21kIC0gdGhlIFNjc2lfQ21uZCB0byBhYm9ydCwgY29kZSAtIGNvZGUgdG8gc2V0IHRoZSAKICogCWhvc3QgYnl0ZSBvZiB0aGUgcmVzdWx0IGZpZWxkIHRvLCBpZiB6ZXJvIERJRF9BQk9SVEVEIGlzIAogKgl1c2VkLgogKgogKiBSZXR1cm5zIDogMCAtIHN1Y2Nlc3MsIC0xIG9uIGZhaWx1cmUuCiAqCiAqIFhYWCAtIHRoZXJlIGlzIG5vIHdheSB0byBhYm9ydCB0aGUgY29tbWFuZCB0aGF0IGlzIGN1cnJlbnRseSAKICogCSBjb25uZWN0ZWQsIHlvdSBoYXZlIHRvIHdhaXQgZm9yIGl0IHRvIGNvbXBsZXRlLiAgSWYgdGhpcyBpcyAKICoJIGEgcHJvYmxlbSwgd2UgY291bGQgaW1wbGVtZW50IGxvbmdqbXAoKSAvIHNldGptcCgpLCBzZXRqbXAoKQogKiAJIGNhbGxlZCB3aGVyZSB0aGUgbG9vcCBzdGFydGVkIGluIE5DUjUzODBfbWFpbigpLgogKi8KCnN0YXRpYwppbnQgTkNSNTM4MF9hYm9ydCAoU2NzaV9DbW5kICpjbWQpCnsKICAgIHN0cnVjdCBTY3NpX0hvc3QgKmluc3RhbmNlID0gY21kLT5kZXZpY2UtPmhvc3Q7CiAgICBTRVRVUF9IT1NUREFUQShpbnN0YW5jZSk7CiAgICBTY3NpX0NtbmQgKnRtcCwgKipwcmV2OwogICAgdW5zaWduZWQgbG9uZyBmbGFnczsKCiAgICBwcmludGsoS0VSTl9OT1RJQ0UgInNjc2klZDogYWJvcnRpbmcgY29tbWFuZFxuIiwgSE9TVE5PKTsKICAgIHNjc2lfcHJpbnRfY29tbWFuZChjbWQpOwoKICAgIE5DUjUzODBfcHJpbnRfc3RhdHVzIChpbnN0YW5jZSk7CgogICAgbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwogICAgCiAgICBpZiAoIUlTX0FfVFQoKSAmJiAhZmFsY29uX2dvdF9sb2NrKQoJcHJpbnRrKEtFUk5fRVJSICJzY3NpJWQ6ICEhQklOR08hISBGYWxjb24gaGFzIG5vIGxvY2sgaW4gTkNSNTM4MF9hYm9ydFxuIiwKCSAgICAgICBIT1NUTk8pOwoKICAgIEFCUlRfUFJJTlRLKCJzY3NpJWQ6IGFib3J0IGNhbGxlZCBiYXNyIDB4JTAyeCwgc3IgMHglMDJ4XG4iLCBIT1NUTk8sCgkJTkNSNTM4MF9yZWFkKEJVU19BTkRfU1RBVFVTX1JFRyksCgkJTkNSNTM4MF9yZWFkKFNUQVRVU19SRUcpKTsKCiNpZiAxCi8qIAogKiBDYXNlIDEgOiBJZiB0aGUgY29tbWFuZCBpcyB0aGUgY3VycmVudGx5IGV4ZWN1dGluZyBjb21tYW5kLCAKICogd2UnbGwgc2V0IHRoZSBhYm9ydGVkIGZsYWcgYW5kIHJldHVybiBjb250cm9sIHNvIHRoYXQgCiAqIGluZm9ybWF0aW9uIHRyYW5zZmVyIHJvdXRpbmUgY2FuIGV4aXQgY2xlYW5seS4KICovCgogICAgaWYgKGhvc3RkYXRhLT5jb25uZWN0ZWQgPT0gY21kKSB7CgoJQUJSVF9QUklOVEsoInNjc2klZDogYWJvcnRpbmcgY29ubmVjdGVkIGNvbW1hbmRcbiIsIEhPU1ROTyk7Ci8qCiAqIFdlIHNob3VsZCBwZXJmb3JtIEJTWSBjaGVja2luZywgYW5kIG1ha2Ugc3VyZSB3ZSBoYXZlbid0IHNsaXBwZWQKICogaW50byBCVVMgRlJFRS4KICovCgovKglOQ1I1MzgwX3dyaXRlKElOSVRJQVRPUl9DT01NQU5EX1JFRywgSUNSX0FTU0VSVF9BVE4pOyAqLwovKiAKICogU2luY2Ugd2UgY2FuJ3QgY2hhbmdlIHBoYXNlcyB1bnRpbCB3ZSd2ZSBjb21wbGV0ZWQgdGhlIGN1cnJlbnQgCiAqIGhhbmRzaGFrZSwgd2UgaGF2ZSB0byBzb3VyY2Ugb3Igc2luayBhIGJ5dGUgb2YgZGF0YSBpZiB0aGUgY3VycmVudAogKiBwaGFzZSBpcyBub3QgTVNHT1VULgogKi8KCi8qIAogKiBSZXR1cm4gY29udHJvbCB0byB0aGUgZXhlY3V0aW5nIE5DUiBkcml2ZSBzbyB3ZSBjYW4gY2xlYXIgdGhlCiAqIGFib3J0ZWQgZmxhZyBhbmQgZ2V0IGJhY2sgaW50byBvdXIgbWFpbiBsb29wLgogKi8gCgoJaWYgKGRvX2Fib3J0KGluc3RhbmNlKSA9PSAwKSB7CgkgIGhvc3RkYXRhLT5hYm9ydGVkID0gMTsKCSAgaG9zdGRhdGEtPmNvbm5lY3RlZCA9IE5VTEw7CgkgIGNtZC0+cmVzdWx0ID0gRElEX0FCT1JUIDw8IDE2OwojaWZkZWYgU1VQUE9SVF9UQUdTCgkgIGNtZF9mcmVlX3RhZyggY21kICk7CiNlbHNlCgkgIGhvc3RkYXRhLT5idXN5W2NtZC0+ZGV2aWNlLT5pZF0gJj0gfigxIDw8IGNtZC0+ZGV2aWNlLT5sdW4pOwojZW5kaWYKCSAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJICBjbWQtPnNjc2lfZG9uZShjbWQpOwoJICBmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOwoJICByZXR1cm4gU0NTSV9BQk9SVF9TVUNDRVNTOwoJfSBlbHNlIHsKLyoJICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7ICovCgkgIHByaW50aygic2NzaSVkOiBhYm9ydCBvZiBjb25uZWN0ZWQgY29tbWFuZCBmYWlsZWQhXG4iLCBIT1NUTk8pOwoJICByZXR1cm4gU0NTSV9BQk9SVF9FUlJPUjsKCX0gCiAgIH0KI2VuZGlmCgovKiAKICogQ2FzZSAyIDogSWYgdGhlIGNvbW1hbmQgaGFzbid0IGJlZW4gaXNzdWVkIHlldCwgd2Ugc2ltcGx5IHJlbW92ZSBpdCAKICogCSAgICBmcm9tIHRoZSBpc3N1ZSBxdWV1ZS4KICovCiAgICBmb3IgKHByZXYgPSAoU2NzaV9DbW5kICoqKSAmKGhvc3RkYXRhLT5pc3N1ZV9xdWV1ZSksIAoJdG1wID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+aXNzdWVfcXVldWU7Cgl0bXA7IHByZXYgPSBORVhUQUREUih0bXApLCB0bXAgPSBORVhUKHRtcCkgKQoJaWYgKGNtZCA9PSB0bXApIHsKCSAgICBSRU1PVkUoNSwgKnByZXYsIHRtcCwgTkVYVCh0bXApKTsKCSAgICAoKnByZXYpID0gTkVYVCh0bXApOwoJICAgIE5FWFQodG1wKSA9IE5VTEw7CgkgICAgdG1wLT5yZXN1bHQgPSBESURfQUJPUlQgPDwgMTY7CgkgICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJICAgIEFCUlRfUFJJTlRLKCJzY3NpJWQ6IGFib3J0IHJlbW92ZWQgY29tbWFuZCBmcm9tIGlzc3VlIHF1ZXVlLlxuIiwKCQkJSE9TVE5PKTsKCSAgICAvKiBUYWdnZWQgcXVldWluZyBub3RlOiBubyB0YWcgdG8gZnJlZSBoZXJlLCBoYXNuJ3QgYmVlbiBhc3NpZ25lZAoJICAgICAqIHlldC4uLiAqLwoJICAgIHRtcC0+c2NzaV9kb25lKHRtcCk7CgkgICAgZmFsY29uX3JlbGVhc2VfbG9ja19pZl9wb3NzaWJsZSggaG9zdGRhdGEgKTsKCSAgICByZXR1cm4gU0NTSV9BQk9SVF9TVUNDRVNTOwoJfQoKLyogCiAqIENhc2UgMyA6IElmIGFueSBjb21tYW5kcyBhcmUgY29ubmVjdGVkLCB3ZSdyZSBnb2luZyB0byBmYWlsIHRoZSBhYm9ydAogKgkgICAgYW5kIGxldCB0aGUgaGlnaCBsZXZlbCBTQ1NJIGRyaXZlciByZXRyeSBhdCBhIGxhdGVyIHRpbWUgb3IgCiAqCSAgICBpc3N1ZSBhIHJlc2V0LgogKgogKgkgICAgVGltZW91dHMsIGFuZCB0aGVyZWZvcmUgYWJvcnRlZCBjb21tYW5kcywgd2lsbCBiZSBoaWdobHkgdW5saWtlbHkKICogICAgICAgICAgYW5kIGhhbmRsaW5nIHRoZW0gY2xlYW5seSBpbiB0aGlzIHNpdHVhdGlvbiB3b3VsZCBtYWtlIHRoZSBjb21tb24KICoJICAgIGNhc2Ugb2Ygbm9yZXNldHMgbGVzcyBlZmZpY2llbnQsIGFuZCB3b3VsZCBwb2xsdXRlIG91ciBjb2RlLiAgU28sCiAqCSAgICB3ZSBmYWlsLgogKi8KCiAgICBpZiAoaG9zdGRhdGEtPmNvbm5lY3RlZCkgewoJbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJQUJSVF9QUklOVEsoInNjc2klZDogYWJvcnQgZmFpbGVkLCBjb21tYW5kIGNvbm5lY3RlZC5cbiIsIEhPU1ROTyk7CiAgICAgICAgcmV0dXJuIFNDU0lfQUJPUlRfU05PT1pFOwogICAgfQoKLyoKICogQ2FzZSA0OiBJZiB0aGUgY29tbWFuZCBpcyBjdXJyZW50bHkgZGlzY29ubmVjdGVkIGZyb20gdGhlIGJ1cywgYW5kIAogKiAJdGhlcmUgYXJlIG5vIGNvbm5lY3RlZCBjb21tYW5kcywgd2UgcmVjb25uZWN0IHRoZSBJX1RfTCBvciAKICoJSV9UX0xfUSBuZXh1cyBhc3NvY2lhdGVkIHdpdGggaXQsIGdvIGludG8gbWVzc2FnZSBvdXQsIGFuZCBzZW5kIAogKiAgICAgIGFuIGFib3J0IG1lc3NhZ2UuCiAqCiAqIFRoaXMgY2FzZSBpcyBlc3BlY2lhbGx5IHVnbHkuIEluIG9yZGVyIHRvIHJlZXN0YWJsaXNoIHRoZSBuZXh1cywgd2UKICogbmVlZCB0byBjYWxsIE5DUjUzODBfc2VsZWN0KCkuICBUaGUgZWFzaWVzdCB3YXkgdG8gaW1wbGVtZW50IHRoaXMgCiAqIGZ1bmN0aW9uIHdhcyB0byBhYm9ydCBpZiB0aGUgYnVzIHdhcyBidXN5LCBhbmQgbGV0IHRoZSBpbnRlcnJ1cHQKICogaGFuZGxlciB0cmlnZ2VyZWQgb24gdGhlIFNFTCBmb3IgcmVzZWxlY3QgdGFrZSBjYXJlIG9mIGxvc3QgYXJiaXRyYXRpb25zCiAqIHdoZXJlIG5lY2Vzc2FyeSwgbWVhbmluZyBpbnRlcnJ1cHRzIG5lZWQgdG8gYmUgZW5hYmxlZC4KICoKICogV2hlbiBpbnRlcnJ1cHRzIGFyZSBlbmFibGVkLCB0aGUgcXVldWVzIG1heSBjaGFuZ2UgLSBzbyB3ZSAKICogY2FuJ3QgcmVtb3ZlIGl0IGZyb20gdGhlIGRpc2Nvbm5lY3RlZCBxdWV1ZSBiZWZvcmUgc2VsZWN0aW5nIGl0CiAqIGJlY2F1c2UgdGhhdCBjb3VsZCBjYXVzZSBhIGZhaWx1cmUgaW4gaGFzaGluZyB0aGUgbmV4dXMgaWYgdGhhdCAKICogZGV2aWNlIHJlc2VsZWN0ZWQuCiAqIAogKiBTaW5jZSB0aGUgcXVldWVzIG1heSBjaGFuZ2UsIHdlIGNhbid0IHVzZSB0aGUgcG9pbnRlcnMgZnJvbSB3aGVuIHdlCiAqIGZpcnN0IGxvY2F0ZSBpdC4KICoKICogU28sIHdlIG11c3QgZmlyc3QgbG9jYXRlIHRoZSBjb21tYW5kLCBhbmQgaWYgTkNSNTM4MF9zZWxlY3QoKQogKiBzdWNjZWVkcywgdGhlbiBpc3N1ZSB0aGUgYWJvcnQsIHJlbG9jYXRlIHRoZSBjb21tYW5kIGFuZCByZW1vdmUKICogaXQgZnJvbSB0aGUgZGlzY29ubmVjdGVkIHF1ZXVlLgogKi8KCiAgICBmb3IgKHRtcCA9IChTY3NpX0NtbmQgKikgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZTsgdG1wOwoJIHRtcCA9IE5FWFQodG1wKSkgCiAgICAgICAgaWYgKGNtZCA9PSB0bXApIHsKICAgICAgICAgICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoJICAgIEFCUlRfUFJJTlRLKCJzY3NpJWQ6IGFib3J0aW5nIGRpc2Nvbm5lY3RlZCBjb21tYW5kLlxuIiwgSE9TVE5PKTsKICAKICAgICAgICAgICAgaWYgKE5DUjUzODBfc2VsZWN0IChpbnN0YW5jZSwgY21kLCAoaW50KSBjbWQtPnRhZykpIAoJCXJldHVybiBTQ1NJX0FCT1JUX0JVU1k7CgoJICAgIEFCUlRfUFJJTlRLKCJzY3NpJWQ6IG5leHVzIHJlZXN0YWJsaXNoZWQuXG4iLCBIT1NUTk8pOwoKCSAgICBkb19hYm9ydCAoaW5zdGFuY2UpOwoKCSAgICBsb2NhbF9pcnFfc2F2ZShmbGFncyk7CgkgICAgZm9yIChwcmV2ID0gKFNjc2lfQ21uZCAqKikgJihob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlKSwgCgkJdG1wID0gKFNjc2lfQ21uZCAqKSBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlOwoJCXRtcDsgcHJldiA9IE5FWFRBRERSKHRtcCksIHRtcCA9IE5FWFQodG1wKSApCgkJICAgIGlmIChjbWQgPT0gdG1wKSB7CgkJICAgIFJFTU9WRSg1LCAqcHJldiwgdG1wLCBORVhUKHRtcCkpOwoJCSAgICAqcHJldiA9IE5FWFQodG1wKTsKCQkgICAgTkVYVCh0bXApID0gTlVMTDsKCQkgICAgdG1wLT5yZXN1bHQgPSBESURfQUJPUlQgPDwgMTY7CgkJICAgIC8qIFdlIG11c3QgdW5sb2NrIHRoZSB0YWcvTFVOIGltbWVkaWF0ZWx5IGhlcmUsIHNpbmNlIHRoZQoJCSAgICAgKiB0YXJnZXQgZ29lcyB0byBCVVMgRlJFRSBhbmQgZG9lc24ndCBzZW5kIHVzIGFub3RoZXIKCQkgICAgICogbWVzc2FnZSAoQ09NTUFORF9DT01QTEVURSBvciB0aGUgbGlrZSkKCQkgICAgICovCiNpZmRlZiBTVVBQT1JUX1RBR1MKCQkgICAgY21kX2ZyZWVfdGFnKCB0bXAgKTsKI2Vsc2UKCQkgICAgaG9zdGRhdGEtPmJ1c3lbY21kLT5kZXZpY2UtPmlkXSAmPSB+KDEgPDwgY21kLT5kZXZpY2UtPmx1bik7CiNlbmRpZgoJCSAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgkJICAgIHRtcC0+c2NzaV9kb25lKHRtcCk7CgkJICAgIGZhbGNvbl9yZWxlYXNlX2xvY2tfaWZfcG9zc2libGUoIGhvc3RkYXRhICk7CgkJICAgIHJldHVybiBTQ1NJX0FCT1JUX1NVQ0NFU1M7CgkJfQoJfQoKLyoKICogQ2FzZSA1IDogSWYgd2UgcmVhY2hlZCB0aGlzIHBvaW50LCB0aGUgY29tbWFuZCB3YXMgbm90IGZvdW5kIGluIGFueSBvZiAKICoJICAgIHRoZSBxdWV1ZXMuCiAqCiAqIFdlIHByb2JhYmx5IHJlYWNoZWQgdGhpcyBwb2ludCBiZWNhdXNlIG9mIGFuIHVubGlrZWx5IHJhY2UgY29uZGl0aW9uCiAqIGJldHdlZW4gdGhlIGNvbW1hbmQgY29tcGxldGluZyBzdWNjZXNzZnVsbHkgYW5kIHRoZSBhYm9ydGlvbiBjb2RlLAogKiBzbyB3ZSB3b24ndCBwYW5pYywgYnV0IHdlIHdpbGwgbm90aWZ5IHRoZSB1c2VyIGluIGNhc2Ugc29tZXRoaW5nIHJlYWxseQogKiBicm9rZS4KICovCgogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwogICAgcHJpbnRrKEtFUk5fSU5GTyAic2NzaSVkOiB3YXJuaW5nIDogU0NTSSBjb21tYW5kIHByb2JhYmx5IGNvbXBsZXRlZCBzdWNjZXNzZnVsbHlcbiIKICAgICAgICAgICBLRVJOX0lORk8gIiAgICAgICAgYmVmb3JlIGFib3J0aW9uXG4iLCBIT1NUTk8pOyAKCi8qIE1heWJlIGl0IGlzIHN1ZmZpY2llbnQganVzdCB0byByZWxlYXNlIHRoZSBTVC1ETUEgbG9jay4uLiAoaWYKICogcG9zc2libGUgYXQgYWxsKSBBdCBsZWFzdCwgd2Ugc2hvdWxkIGNoZWNrIGlmIHRoZSBsb2NrIGNvdWxkIGJlCiAqIHJlbGVhc2VkIGFmdGVyIHRoZSBhYm9ydCwgaW4gY2FzZSBpdCBpcyBrZXB0IGR1ZSB0byBzb21lIGJ1Zy4KICovCiAgICBmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOwoKICAgIHJldHVybiBTQ1NJX0FCT1JUX05PVF9SVU5OSU5HOwp9CgoKLyogCiAqIEZ1bmN0aW9uIDogaW50IE5DUjUzODBfcmVzZXQgKFNjc2lfQ21uZCAqY21kKQogKiAKICogUHVycG9zZSA6IHJlc2V0IHRoZSBTQ1NJIGJ1cy4KICoKICogUmV0dXJucyA6IFNDU0lfUkVTRVRfV0FLRVVQCiAqCiAqLyAKCnN0YXRpYyBpbnQgTkNSNTM4MF9idXNfcmVzZXQoIFNjc2lfQ21uZCAqY21kKQp7CiAgICBTRVRVUF9IT1NUREFUQShjbWQtPmRldmljZS0+aG9zdCk7CiAgICBpbnQgICAgICAgICAgIGk7CiAgICB1bnNpZ25lZCBsb25nIGZsYWdzOwojaWYgMQogICAgU2NzaV9DbW5kICpjb25uZWN0ZWQsICpkaXNjb25uZWN0ZWRfcXVldWU7CiNlbmRpZgoKICAgIGlmICghSVNfQV9UVCgpICYmICFmYWxjb25fZ290X2xvY2spCglwcmludGsoS0VSTl9FUlIgInNjc2klZDogISFCSU5HTyEhIEZhbGNvbiBoYXMgbm8gbG9jayBpbiBOQ1I1MzgwX3Jlc2V0XG4iLAoJICAgICAgIEhfTk8oY21kKSApOwoKICAgIE5DUjUzODBfcHJpbnRfc3RhdHVzIChjbWQtPmRldmljZS0+aG9zdCk7CgogICAgLyogZ2V0IGluIHBoYXNlICovCiAgICBOQ1I1MzgwX3dyaXRlKCBUQVJHRVRfQ09NTUFORF9SRUcsCgkJICAgUEhBU0VfU1JfVE9fVENSKCBOQ1I1MzgwX3JlYWQoU1RBVFVTX1JFRykgKSk7CiAgICAvKiBhc3NlcnQgUlNUICovCiAgICBOQ1I1MzgwX3dyaXRlKCBJTklUSUFUT1JfQ09NTUFORF9SRUcsIElDUl9CQVNFIHwgSUNSX0FTU0VSVF9SU1QgKTsKICAgIHVkZWxheSAoNDApOwogICAgLyogcmVzZXQgTkNSIHJlZ2lzdGVycyAqLwogICAgTkNSNTM4MF93cml0ZSggSU5JVElBVE9SX0NPTU1BTkRfUkVHLCBJQ1JfQkFTRSApOwogICAgTkNSNTM4MF93cml0ZSggTU9ERV9SRUcsIE1SX0JBU0UgKTsKICAgIE5DUjUzODBfd3JpdGUoIFRBUkdFVF9DT01NQU5EX1JFRywgMCApOwogICAgTkNSNTM4MF93cml0ZSggU0VMRUNUX0VOQUJMRV9SRUcsIDAgKTsKICAgIC8qICsrcm9tYW46IHJlc2V0IGludGVycnVwdCBjb25kaXRpb24hIG90aGVyd2lzZSBubyBpbnRlcnJ1cHRzIGRvbid0IGdldAogICAgICogdGhyb3VnaCBhbnltb3JlIC4uLiAqLwogICAgKHZvaWQpTkNSNTM4MF9yZWFkKCBSRVNFVF9QQVJJVFlfSU5URVJSVVBUX1JFRyApOwoKI2lmIDEgLyogWFhYIFNob3VsZCBub3cgYmUgZG9uZSBieSBtaWRsZXZlbCBjb2RlLCBidXQgaXQncyBicm9rZW4gWFhYICovCiAgICAgIC8qIFhYWCBzZWUgYmVsb3cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFhYWCAqLwoKICAgIC8qIE1TY2g6IG9sZC1zdHlsZSByZXNldDogYWN0dWFsbHkgYWJvcnQgYWxsIGNvbW1hbmQgcHJvY2Vzc2luZyBoZXJlICovCgogICAgLyogQWZ0ZXIgdGhlIHJlc2V0LCB0aGVyZSBhcmUgbm8gbW9yZSBjb25uZWN0ZWQgb3IgZGlzY29ubmVjdGVkIGNvbW1hbmRzCiAgICAgKiBhbmQgbm8gYnVzeSB1bml0czsgdG8gYXZvaWQgcHJvYmxlbXMgd2l0aCByZS1pbnNlcnRpbmcgdGhlIGNvbW1hbmRzCiAgICAgKiBpbnRvIHRoZSBpc3N1ZV9xdWV1ZSAodmlhIHNjc2lfZG9uZSgpKSwgdGhlIGFib3J0ZWQgY29tbWFuZHMgYXJlCiAgICAgKiByZW1lbWJlcmVkIGluIGxvY2FsIHZhcmlhYmxlcyBmaXJzdC4KICAgICAqLwogICAgbG9jYWxfaXJxX3NhdmUoZmxhZ3MpOwogICAgY29ubmVjdGVkID0gKFNjc2lfQ21uZCAqKWhvc3RkYXRhLT5jb25uZWN0ZWQ7CiAgICBob3N0ZGF0YS0+Y29ubmVjdGVkID0gTlVMTDsKICAgIGRpc2Nvbm5lY3RlZF9xdWV1ZSA9IChTY3NpX0NtbmQgKilob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlOwogICAgaG9zdGRhdGEtPmRpc2Nvbm5lY3RlZF9xdWV1ZSA9IE5VTEw7CiNpZmRlZiBTVVBQT1JUX1RBR1MKICAgIGZyZWVfYWxsX3RhZ3MoKTsKI2VuZGlmCiAgICBmb3IoIGkgPSAwOyBpIDwgODsgKytpICkKCWhvc3RkYXRhLT5idXN5W2ldID0gMDsKI2lmZGVmIFJFQUxfRE1BCiAgICBob3N0ZGF0YS0+ZG1hX2xlbiA9IDA7CiNlbmRpZgogICAgbG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwoKICAgIC8qIEluIG9yZGVyIHRvIHRlbGwgdGhlIG1pZC1sZXZlbCBjb2RlIHdoaWNoIGNvbW1hbmRzIHdlcmUgYWJvcnRlZCwgCiAgICAgKiBzZXQgdGhlIGNvbW1hbmQgc3RhdHVzIHRvIERJRF9SRVNFVCBhbmQgY2FsbCBzY3NpX2RvbmUoKSAhISEKICAgICAqIFRoaXMgdWx0aW1hdGVseSBhYm9ydHMgcHJvY2Vzc2luZyBvZiB0aGVzZSBjb21tYW5kcyBpbiB0aGUgbWlkLWxldmVsLgogICAgICovCgogICAgaWYgKChjbWQgPSBjb25uZWN0ZWQpKSB7CglBQlJUX1BSSU5USygic2NzaSVkOiByZXNldCBhYm9ydGVkIGEgY29ubmVjdGVkIGNvbW1hbmRcbiIsIEhfTk8oY21kKSk7CgljbWQtPnJlc3VsdCA9IChjbWQtPnJlc3VsdCAmIDB4ZmZmZikgfCAoRElEX1JFU0VUIDw8IDE2KTsKCWNtZC0+c2NzaV9kb25lKCBjbWQgKTsKICAgIH0KCiAgICBmb3IgKGkgPSAwOyAoY21kID0gZGlzY29ubmVjdGVkX3F1ZXVlKTsgKytpKSB7CglkaXNjb25uZWN0ZWRfcXVldWUgPSBORVhUKGNtZCk7CglORVhUKGNtZCkgPSBOVUxMOwoJY21kLT5yZXN1bHQgPSAoY21kLT5yZXN1bHQgJiAweGZmZmYpIHwgKERJRF9SRVNFVCA8PCAxNik7CgljbWQtPnNjc2lfZG9uZSggY21kICk7CiAgICB9CiAgICBpZiAoaSA+IDApCglBQlJUX1BSSU5USygic2NzaTogcmVzZXQgYWJvcnRlZCAlZCBkaXNjb25uZWN0ZWQgY29tbWFuZChzKVxuIiwgaSk7CgovKiBUaGUgRmFsY29uIGxvY2sgc2hvdWxkIGJlIHJlbGVhc2VkIGFmdGVyIGEgcmVzZXQuLi4KICovCi8qICsrZ3VlbnRoZXI6IG1vdmVkIHRvIGF0YXJpX3Njc2lfcmVzZXQoKSwgdG8gcHJldmVudCBhIHJhY2UgYmV0d2VlbgogKiB1bmxvY2tpbmcgYW5kIGVuYWJsaW5nIGRtYSBpbnRlcnJ1cHQuCiAqLwovKiAgICBmYWxjb25fcmVsZWFzZV9sb2NrX2lmX3Bvc3NpYmxlKCBob3N0ZGF0YSApOyovCgogICAgLyogc2luY2UgYWxsIGNvbW1hbmRzIGhhdmUgYmVlbiBleHBsaWNpdGx5IHRlcm1pbmF0ZWQsIHdlIG5lZWQgdG8gdGVsbAogICAgICogdGhlIG1pZGxldmVsIGNvZGUgdGhhdCB0aGUgcmVzZXQgd2FzIFNVQ0NFU1NGVUwsIGFuZCB0aGVyZSBpcyBubyAKICAgICAqIG5lZWQgdG8gJ3dha2UgdXAnIHRoZSBjb21tYW5kcyBieSBhIHJlcXVlc3Rfc2Vuc2UKICAgICAqLwogICAgcmV0dXJuIFNDU0lfUkVTRVRfU1VDQ0VTUyB8IFNDU0lfUkVTRVRfQlVTX1JFU0VUOwojZWxzZSAvKiAxICovCgogICAgLyogTVNjaDogbmV3LXN0eWxlIHJlc2V0IGhhbmRsaW5nOiBsZXQgdGhlIG1pZC1sZXZlbCBkbyB3aGF0IGl0IGNhbiAqLwoKICAgIC8qICsrZ3VlbnRoZXI6IE1JRC1MRVZFTCBJUyBTVElMTCBCUk9LRU4uCiAgICAgKiBNaWQtbGV2ZWwgaXMgc3VwcG9zZWQgdG8gcmVxdWV1ZSBhbGwgY29tbWFuZHMgdGhhdCB3ZXJlIGFjdGl2ZSBvbiB0aGUKICAgICAqIHZhcmlvdXMgbG93LWxldmVsIHF1ZXVlcy4gSW4gZmFjdCBpdCBkb2VzIHRoaXMsIGJ1dCB0aGF0J3Mgbm90IGVub3VnaAogICAgICogYmVjYXVzZSBhbGwgdGhlc2UgY29tbWFuZHMgYXJlIHN1YmplY3QgdG8gdGltZW91dC4gQW5kIGlmIGEgdGltZW91dAogICAgICogaGFwcGVucyBmb3IgYW55IHJlbW92ZWQgY29tbWFuZCwgKl9hYm9ydCgpIGlzIGNhbGxlZCBidXQgYWxsIHF1ZXVlcwogICAgICogYXJlIG5vdyBlbXB0eS4gQWJvcnQgdGhlbiBnaXZlcyB1cCB0aGUgZmFsY29uIGxvY2ssIHdoaWNoIGlzIGZhdGFsLAogICAgICogc2luY2UgdGhlIG1pZC1sZXZlbCB3aWxsIHF1ZXVlIG1vcmUgY29tbWFuZHMgYW5kIG11c3QgaGF2ZSB0aGUgbG9jawogICAgICogKGl0J3MgYWxsIGhhcHBlbmluZyBpbnNpZGUgdGltZXIgaW50ZXJydXB0IGhhbmRsZXIhISkuCiAgICAgKiBFdmVuIHdvcnNlLCBhYm9ydCB3aWxsIHJldHVybiBOT1RfUlVOTklORyBmb3IgYWxsIHRob3NlIGNvbW1hbmRzIG5vdAogICAgICogb24gYW55IHF1ZXVlLCBzbyB0aGV5IHdvbid0IGJlIHJldHJpZWQgLi4uCiAgICAgKgogICAgICogQ29uY2x1c2lvbjogZWl0aGVyIHNjc2kuYyBkaXNhYmxlcyB0aW1lb3V0IGZvciBhbGwgcmVzZXR0ZWQgY29tbWFuZHMKICAgICAqIGltbWVkaWF0ZWx5LCBvciB3ZSBsb3NlISAgQXMgb2YgbGludXgtMi4wLjIwIGl0IGRvZXNuJ3QuCiAgICAgKi8KCiAgICAvKiBBZnRlciB0aGUgcmVzZXQsIHRoZXJlIGFyZSBubyBtb3JlIGNvbm5lY3RlZCBvciBkaXNjb25uZWN0ZWQgY29tbWFuZHMKICAgICAqIGFuZCBubyBidXN5IHVuaXRzOyBzbyBjbGVhciB0aGUgbG93LWxldmVsIHN0YXR1cyBoZXJlIHRvIGF2b2lkIAogICAgICogY29uZmxpY3RzIHdoZW4gdGhlIG1pZC1sZXZlbCBjb2RlIHRyaWVzIHRvIHdha2UgdXAgdGhlIGFmZmVjdGVkIAogICAgICogY29tbWFuZHMhCiAgICAgKi8KCiAgICBpZiAoaG9zdGRhdGEtPmlzc3VlX3F1ZXVlKQoJQUJSVF9QUklOVEsoInNjc2klZDogcmVzZXQgYWJvcnRlZCBpc3N1ZWQgY29tbWFuZChzKVxuIiwgSF9OTyhjbWQpKTsKICAgIGlmIChob3N0ZGF0YS0+Y29ubmVjdGVkKSAKCUFCUlRfUFJJTlRLKCJzY3NpJWQ6IHJlc2V0IGFib3J0ZWQgYSBjb25uZWN0ZWQgY29tbWFuZFxuIiwgSF9OTyhjbWQpKTsKICAgIGlmIChob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlKQoJQUJSVF9QUklOVEsoInNjc2klZDogcmVzZXQgYWJvcnRlZCBkaXNjb25uZWN0ZWQgY29tbWFuZChzKVxuIiwgSF9OTyhjbWQpKTsKCiAgICBsb2NhbF9pcnFfc2F2ZShmbGFncyk7CiAgICBob3N0ZGF0YS0+aXNzdWVfcXVldWUgPSBOVUxMOwogICAgaG9zdGRhdGEtPmNvbm5lY3RlZCA9IE5VTEw7CiAgICBob3N0ZGF0YS0+ZGlzY29ubmVjdGVkX3F1ZXVlID0gTlVMTDsKI2lmZGVmIFNVUFBPUlRfVEFHUwogICAgZnJlZV9hbGxfdGFncygpOwojZW5kaWYKICAgIGZvciggaSA9IDA7IGkgPCA4OyArK2kgKQoJaG9zdGRhdGEtPmJ1c3lbaV0gPSAwOwojaWZkZWYgUkVBTF9ETUEKICAgIGhvc3RkYXRhLT5kbWFfbGVuID0gMDsKI2VuZGlmCiAgICBsb2NhbF9pcnFfcmVzdG9yZShmbGFncyk7CgogICAgLyogd2UgZGlkIG5vIGNvbXBsZXRlIHJlc2V0IG9mIGFsbCBjb21tYW5kcywgc28gYSB3YWtldXAgaXMgcmVxdWlyZWQgKi8KICAgIHJldHVybiBTQ1NJX1JFU0VUX1dBS0VVUCB8IFNDU0lfUkVTRVRfQlVTX1JFU0VUOwojZW5kaWYgLyogMSAqLwp9CgovKiBMb2NhbCBWYXJpYWJsZXM6ICovCi8qIHRhYi13aWR0aDogOCAgICAgKi8KLyogRW5kOiAgICAgICAgICAgICAqLwo=