Lyogdmk6IHNldCBzdz00IHRzPTQ6ICovCi8qCiAqIE1pbmkgaW5zbW9kIGltcGxlbWVudGF0aW9uIGZvciBidXN5Ym94CiAqCiAqIFRoaXMgdmVyc2lvbiBvZiBpbnNtb2Qgc3VwcG9ydHMgQVJNLCBDUklTLCBIOC8zMDAsIHg4NiwgaWE2NCwgeDg2XzY0LAogKiBtNjhrLCBNSVBTLCBQb3dlclBDLCBTMzkwLCBTSDMvNC81LCBTcGFyYywgdjg1MGUsIGFuZCB4ODZfNjQuCiAqCiAqIENvcHlyaWdodCAoQykgMTk5OS0yMDA0IGJ5IEVyaWsgQW5kZXJzZW4gPGFuZGVyc2VuQGNvZGVwb2V0Lm9yZz4KICogYW5kIFJvbiBBbGRlciA8YWxkZXJAbGluZW8uY29tPgogKgogKiBSb2RuZXkgUmFkZm9yZCA8cnJhZGZvcmRAbWluZHNwcmluZy5jb20+IDE3LUF1Zy0yMDA0LgogKiAgIEFkZGVkIHg4Nl82NCBzdXBwb3J0LgogKgogKiBNaWxlcyBCYWRlciA8bWlsZXNAZ251Lm9yZz4gYWRkZWQgTkVDIFY4NTBFIHN1cHBvcnQuCiAqCiAqIE1vZGlmaWVkIGJ5IEJyeWFuIFJpdHRtZXllciA8YnJ5YW5AaXhpYWNvbS5jb20+IHRvIHN1cHBvcnQgU0g0CiAqIGFuZCAodGhlb3JldGljYWxseSkgU0gzLiBJIGhhdmUgb25seSB0ZXN0ZWQgU0g0IGluIGxpdHRsZSBlbmRpYW4gbW9kZS4KICoKICogTW9kaWZpZWQgYnkgQWxjb3ZlLCBKdWxpZW4gR2F1bG1pbiA8anVsaWVuLmdhdWxtaW5AYWxjb3ZlLmZyPiBhbmQKICogTmljb2xhcyBGZXJyZSA8bmljb2xhcy5mZXJyZUBhbGNvdmUuZnI+IHRvIHN1cHBvcnQgQVJNN1RETUkuICBPbmx5CiAqIHZlcnkgbWlub3IgY2hhbmdlcyByZXF1aXJlZCB0byBhbHNvIHdvcmsgd2l0aCBTdHJvbmdBcm0gYW5kIHByZXN1bWFibHkKICogYWxsIEFSTSBiYXNlZCBzeXN0ZW1zLgogKgogKiBZb3NoaW5vcmkgU2F0byA8eXNhdG9AdXNlcnMuc291cmNlZm9yZ2UuanA+IDE5LU1heS0yMDA0LgogKiAgIGFkZGVkIFJlbmVzYXMgSDgvMzAwIHN1cHBvcnQuCiAqCiAqIFBhdWwgTXVuZHQgPGxldGhhbEBsaW51eC1zaC5vcmc+IDA4LUF1Zy0yMDAzLgogKiAgIEludGVncmF0ZWQgc3VwcG9ydCBmb3Igc2g2NCAoU0gtNSksIGZyb20gcHJlbGltaW5hcnkgbW9kdXRpbHMKICogICBwYXRjaGVzIGZyb20gQmVuZWRpY3QgR2FzdGVyIDxiZW5lZGljdC5nYXN0ZXJAc3VwZXJoLmNvbT4uCiAqICAgQ3VycmVudGx5IGxpbWl0ZWQgdG8gc3VwcG9ydCBmb3IgMzJiaXQgQUJJLgogKgogKiBNYWdudXMgRGFtbSA8ZGFtbUBvcGVuc291cmNlLnNlPiAyMi1NYXktMjAwMi4KICogICBUaGUgcGx0IGFuZCBnb3QgY29kZSBhcmUgbm93IHVzaW5nIHRoZSBzYW1lIHN0cnVjdHMuCiAqICAgQWRkZWQgZ2VuZXJpYyBsaW5rZWQgbGlzdCBjb2RlIHRvIGZ1bGx5IHN1cHBvcnQgUG93ZXJQQy4KICogICBSZXBsYWNlZCB0aGUgbWVzcyBpbiBhcmNoX2FwcGx5X3JlbG9jYXRpb24oKSB3aXRoIGFyY2hpdGVjdHVyZSBibG9ja3MuCiAqICAgVGhlIGFyY2hfY3JlYXRlX2dvdCgpIGZ1bmN0aW9uIGdvdCBjbGVhbmVkIHVwIHdpdGggYXJjaGl0ZWN0dXJlIGJsb2Nrcy4KICogICBUaGVzZSBibG9ja3Mgc2hvdWxkIGJlIGVhc3kgbWFpbnRhaW4gYW5kIHN5bmMgd2l0aCBvYmpfeHh4LmMgaW4gbW9kdXRpbHMuCiAqCiAqIE1hZ251cyBEYW1tIDxkYW1tQG9wZW5zb3VyY2Uuc2U+IGFkZGVkIFBvd2VyUEMgc3VwcG9ydCAyMC1GZWItMjAwMS4KICogICBQb3dlclBDIHNwZWNpZmljIGNvZGUgc3RvbGVuIGZyb20gbW9kdXRpbHMtMi4zLjE2LAogKiAgIHdyaXR0ZW4gYnkgUGF1bCBNYWNrZXJyYXMsIENvcHlyaWdodCAxOTk2LCAxOTk3IExpbnV4IEludGVybmF0aW9uYWwuCiAqICAgSSd2ZSBvbmx5IHRlc3RlZCB0aGUgY29kZSBvbiBtcGM4eHggcGxhdGZvcm1zIGluIGJpZy1lbmRpYW4gbW9kZS4KICogICBEaWQgc29tZSBjbGVhbnVwIGFuZCBhZGRlZCBVU0VfeHh4X0VOVFJJRVMuLi4KICoKICogUXVpbm4gSmVuc2VuIDxqZW5zZW5xQGxpbmVvLmNvbT4gYWRkZWQgTUlQUyBzdXBwb3J0IDIzLUZlYi0yMDAxLgogKiAgIGJhc2VkIG9uIG1vZHV0aWxzLTIuNC4yCiAqICAgTUlQUyBzcGVjaWZpYyBzdXBwb3J0IGZvciBFbGYgbG9hZGluZyBhbmQgcmVsb2NhdGlvbi4KICogICBDb3B5cmlnaHQgMTk5NiwgMTk5NyBMaW51eCBJbnRlcm5hdGlvbmFsLgogKiAgIENvbnRyaWJ1dGVkIGJ5IFJhbGYgQmFlY2hsZSA8cmFsZkBnbnUuYWkubWl0LmVkdT4KICoKICogQmFzZWQgYWxtb3N0IGVudGlyZWx5IG9uIHRoZSBMaW51eCBtb2R1dGlscy0yLjMuMTEgaW1wbGVtZW50YXRpb24uCiAqICAgQ29weXJpZ2h0IDE5OTYsIDE5OTcgTGludXggSW50ZXJuYXRpb25hbC4KICogICBOZXcgaW1wbGVtZW50YXRpb24gY29udHJpYnV0ZWQgYnkgUmljaGFyZCBIZW5kZXJzb24gPHJ0aEB0YW11LmVkdT4KICogICBCYXNlZCBvbiBvcmlnaW5hbCB3b3JrIGJ5IEJqb3JuIEVrd2FsbCA8Ymowcm5AYmxveC5zZT4KICogICBSZXN0cnVjdHVyZWQgKGFuZCBwYXJ0bHkgcmV3cml0dGVuKSBieToKICogICBCavZybiBFa3dhbGwgPGJqMHJuQGJsb3guc2U+IEZlYnJ1YXJ5IDE5OTkKICoKICogTGljZW5zZWQgdW5kZXIgR1BMdjIgb3IgbGF0ZXIsIHNlZSBmaWxlIExJQ0VOU0UgaW4gdGhpcyBzb3VyY2UgdHJlZS4KICovCgovL2tidWlsZDpsaWItJChDT05GSUdfRkVBVFVSRV8yXzRfTU9EVUxFUykgKz0gbW9kdXRpbHMtMjQubwoKI2luY2x1ZGUgImxpYmJiLmgiCiNpbmNsdWRlICJtb2R1dGlscy5oIgojaW5jbHVkZSA8c3lzL3V0c25hbWUuaD4KCiNpZiBFTkFCTEVfRkVBVFVSRV9JTlNNT0RfTE9BRElOS01FTQojZGVmaW5lIExPQURCSVRTIDAKI2Vsc2UKI2RlZmluZSBMT0FEQklUUyAxCiNlbmRpZgoKLyogQWxwaGEgKi8KI2lmIGRlZmluZWQoX19hbHBoYV9fKQojZGVmaW5lIE1BVENIX01BQ0hJTkUoeCkgKHggPT0gRU1fQUxQSEEpCiNkZWZpbmUgU0hUX1JFTE0gICAgICAgU0hUX1JFTEEKI2RlZmluZSBFbGY2NF9SZWxNICAgICBFbGY2NF9SZWxhCiNkZWZpbmUgRUxGQ0xBU1NNICAgICAgRUxGQ0xBU1M2NAojZW5kaWYKCi8qIEFSTSBzdXBwb3J0ICovCiNpZiBkZWZpbmVkKF9fYXJtX18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9BUk0pCiNkZWZpbmUgU0hUX1JFTE0JU0hUX1JFTAojZGVmaW5lIEVsZjMyX1JlbE0JRWxmMzJfUmVsCiNkZWZpbmUgRUxGQ0xBU1NNCUVMRkNMQVNTMzIKI2RlZmluZSBVU0VfUExUX0VOVFJJRVMKI2RlZmluZSBQTFRfRU5UUllfU0laRSA4CiNkZWZpbmUgVVNFX0dPVF9FTlRSSUVTCiNkZWZpbmUgR09UX0VOVFJZX1NJWkUgOAojZGVmaW5lIFVTRV9TSU5HTEUKI2VuZGlmCgovKiBORFMzMiBzdXBwb3J0ICovCiNpZiBkZWZpbmVkKF9fbmRzMzJfXykgfHwgZGVmaW5lZChfX05EUzMyX18pCiNkZWZpbmUgQ09ORklHX1VTRV9HT1RfRU5UUklFUwojZGVmaW5lIENPTkZJR19HT1RfRU5UUllfU0laRSA0CiNkZWZpbmUgQ09ORklHX1VTRV9TSU5HTEUKCiNpZiBkZWZpbmVkKF9fTkRTMzJfRUJfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNX05EUzMyKQojZGVmaW5lIFNIVF9SRUxNICAgIFNIVF9SRUxBCiNkZWZpbmUgRWxmMzJfUmVsTSAgRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTSAgIEVMRkNMQVNTMzIKI2VuZGlmCgojaWYgZGVmaW5lZChfX05EUzMyX0VMX18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9ORFMzMikKI2RlZmluZSBTSFRfUkVMTSAgICBTSFRfUkVMQQojZGVmaW5lIEVsZjMyX1JlbE0gIEVsZjMyX1JlbGEKI2RlZmluZSBFTEZDTEFTU00gICBFTEZDTEFTUzMyCiNlbmRpZgojZW5kaWYKCi8qIGJsYWNrZmluICovCiNpZiBkZWZpbmVkKEJGSU4pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9CTEFDS0ZJTikKI2RlZmluZSBTSFRfUkVMTQlTSFRfUkVMQQojZGVmaW5lIEVsZjMyX1JlbE0JRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTQlFTEZDTEFTUzMyCiNlbmRpZgoKLyogQ1JJUyAqLwojaWYgZGVmaW5lZChfX2NyaXNfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNX0NSSVMpCiNkZWZpbmUgU0hUX1JFTE0JU0hUX1JFTEEKI2RlZmluZSBFbGYzMl9SZWxNCUVsZjMyX1JlbGEKI2RlZmluZSBFTEZDTEFTU00JRUxGQ0xBU1MzMgojaWZuZGVmIEVNX0NSSVMKI2RlZmluZSBFTV9DUklTIDc2CiNkZWZpbmUgUl9DUklTX05PTkUgMAojZGVmaW5lIFJfQ1JJU18zMiAgIDMKI2VuZGlmCiNlbmRpZgoKLyogSDgvMzAwICovCiNpZiBkZWZpbmVkKF9fSDgzMDBIX18pIHx8IGRlZmluZWQoX19IODMwMFNfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNX0g4XzMwMCkKI2RlZmluZSBTSFRfUkVMTQlTSFRfUkVMQQojZGVmaW5lIEVsZjMyX1JlbE0JRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTQlFTEZDTEFTUzMyCiNkZWZpbmUgVVNFX1NJTkdMRQojZGVmaW5lIFNZTUJPTF9QUkVGSVgJIl8iCiNlbmRpZgoKLyogUEEtUklTQyAvIEhQLVBBICovCiNpZiBkZWZpbmVkKF9faHBwYV9fKQojZGVmaW5lIE1BVENIX01BQ0hJTkUoeCkgKHggPT0gRU1fUEFSSVNDKQojZGVmaW5lIFNIVF9SRUxNICAgICAgIFNIVF9SRUxBCiNpZiBkZWZpbmVkKF9fTFA2NF9fKQojZGVmaW5lIEVsZjY0X1JlbE0gICAgIEVsZjY0X1JlbGEKI2RlZmluZSBFTEZDTEFTU00gICAgICBFTEZDTEFTUzY0CiNlbHNlCiNkZWZpbmUgRWxmMzJfUmVsTSAgICAgRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTSAgICAgIEVMRkNMQVNTMzIKI2VuZGlmCiNlbmRpZgoKLyogeDg2ICovCiNpZiBkZWZpbmVkKF9faTM4Nl9fKQojaWZuZGVmIEVNXzQ4NgojZGVmaW5lIE1BVENIX01BQ0hJTkUoeCkgKHggPT0gRU1fMzg2KQojZWxzZQojZGVmaW5lIE1BVENIX01BQ0hJTkUoeCkgKHggPT0gRU1fMzg2IHx8IHggPT0gRU1fNDg2KQojZW5kaWYKI2RlZmluZSBTSFRfUkVMTQlTSFRfUkVMCiNkZWZpbmUgRWxmMzJfUmVsTQlFbGYzMl9SZWwKI2RlZmluZSBFTEZDTEFTU00JRUxGQ0xBU1MzMgojZGVmaW5lIFVTRV9HT1RfRU5UUklFUwojZGVmaW5lIEdPVF9FTlRSWV9TSVpFIDQKI2RlZmluZSBVU0VfU0lOR0xFCiNlbmRpZgoKLyogSUE2NCwgYWthIEl0YW5pdW0gKi8KI2lmIGRlZmluZWQoX19pYTY0X18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9JQV82NCkKI2RlZmluZSBTSFRfUkVMTSAgICAgICBTSFRfUkVMQQojZGVmaW5lIEVsZjY0X1JlbE0gICAgIEVsZjY0X1JlbGEKI2RlZmluZSBFTEZDTEFTU00gICAgICBFTEZDTEFTUzY0CiNlbmRpZgoKLyogbTY4ayAqLwojaWYgZGVmaW5lZChfX21jNjgwMDBfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNXzY4SykKI2RlZmluZSBTSFRfUkVMTQlTSFRfUkVMQQojZGVmaW5lIEVsZjMyX1JlbE0JRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTQlFTEZDTEFTUzMyCiNkZWZpbmUgVVNFX0dPVF9FTlRSSUVTCiNkZWZpbmUgR09UX0VOVFJZX1NJWkUgNAojZGVmaW5lIFVTRV9TSU5HTEUKI2VuZGlmCgovKiBNaWNyb2JsYXplICovCiNpZiBkZWZpbmVkKF9fbWljcm9ibGF6ZV9fKQojZGVmaW5lIFVTRV9TSU5HTEUKI2luY2x1ZGUgPGxpbnV4L2VsZi1lbS5oPgojZGVmaW5lIE1BVENIX01BQ0hJTkUoeCkgKHggPT0gRU1fWElMSU5YX01JQ1JPQkxBWkUpCiNkZWZpbmUgU0hUX1JFTE0JU0hUX1JFTEEKI2RlZmluZSBFbGYzMl9SZWxNCUVsZjMyX1JlbGEKI2RlZmluZSBFTEZDTEFTU00JRUxGQ0xBU1MzMgojZW5kaWYKCi8qIE1JUFMgKi8KI2lmIGRlZmluZWQoX19taXBzX18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9NSVBTIHx8IHggPT0gRU1fTUlQU19SUzNfTEUpCiNkZWZpbmUgU0hUX1JFTE0JU0hUX1JFTAojZGVmaW5lIEVsZjMyX1JlbE0JRWxmMzJfUmVsCiNkZWZpbmUgRUxGQ0xBU1NNCUVMRkNMQVNTMzIKLyogQWNjb3VudCBmb3IgRUxGIHNwZWMgY2hhbmdlcy4gICovCiNpZm5kZWYgRU1fTUlQU19SUzNfTEUKI2lmZGVmIEVNX01JUFNfUlM0X0JFCiNkZWZpbmUgRU1fTUlQU19SUzNfTEUJRU1fTUlQU19SUzRfQkUKI2Vsc2UKI2RlZmluZSBFTV9NSVBTX1JTM19MRQkxMAojZW5kaWYKI2VuZGlmIC8qICFFTV9NSVBTX1JTM19MRSAqLwojZGVmaW5lIEFSQ0hEQVRBTSAgICAgICAiX19kYmVfdGFibGUiCiNlbmRpZgoKLyogTmlvcyBJSSAqLwojaWYgZGVmaW5lZChfX25pb3MyX18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9BTFRFUkFfTklPUzIpCiNkZWZpbmUgU0hUX1JFTE0JU0hUX1JFTEEKI2RlZmluZSBFbGYzMl9SZWxNCUVsZjMyX1JlbGEKI2RlZmluZSBFTEZDTEFTU00JRUxGQ0xBU1MzMgojZW5kaWYKCi8qIFBvd2VyUEMgKi8KI2lmIGRlZmluZWQoX19wb3dlcnBjNjRfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNX1BQQzY0KQojZGVmaW5lIFNIVF9SRUxNCVNIVF9SRUxBCiNkZWZpbmUgRWxmNjRfUmVsTQlFbGY2NF9SZWxhCiNkZWZpbmUgRUxGQ0xBU1NNCUVMRkNMQVNTNjQKI2VsaWYgZGVmaW5lZChfX3Bvd2VycGNfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNX1BQQykKI2RlZmluZSBTSFRfUkVMTQlTSFRfUkVMQQojZGVmaW5lIEVsZjMyX1JlbE0JRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTQlFTEZDTEFTUzMyCiNkZWZpbmUgVVNFX1BMVF9FTlRSSUVTCiNkZWZpbmUgUExUX0VOVFJZX1NJWkUgMTYKI2RlZmluZSBVU0VfUExUX0xJU1QKI2RlZmluZSBMSVNUX0FSQ0hUWVBFIEVsZlcoQWRkcikKI2RlZmluZSBVU0VfTElTVAojZGVmaW5lIEFSQ0hEQVRBTSAgICAgICAiX19mdHJfZml4dXAiCiNlbmRpZgoKLyogUzM5MCAqLwojaWYgZGVmaW5lZChfX3MzOTBfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNX1MzOTApCiNkZWZpbmUgU0hUX1JFTE0JU0hUX1JFTEEKI2RlZmluZSBFbGYzMl9SZWxNCUVsZjMyX1JlbGEKI2RlZmluZSBFTEZDTEFTU00JRUxGQ0xBU1MzMgojZGVmaW5lIFVTRV9QTFRfRU5UUklFUwojZGVmaW5lIFBMVF9FTlRSWV9TSVpFIDgKI2RlZmluZSBVU0VfR09UX0VOVFJJRVMKI2RlZmluZSBHT1RfRU5UUllfU0laRSA4CiNkZWZpbmUgVVNFX1NJTkdMRQojZW5kaWYKCi8qIFN1cGVySCAqLwojaWYgZGVmaW5lZChfX3NoX18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9TSCkKI2RlZmluZSBTSFRfUkVMTQlTSFRfUkVMQQojZGVmaW5lIEVsZjMyX1JlbE0JRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTQlFTEZDTEFTUzMyCiNkZWZpbmUgVVNFX0dPVF9FTlRSSUVTCiNkZWZpbmUgR09UX0VOVFJZX1NJWkUgNAojZGVmaW5lIFVTRV9TSU5HTEUKLyogdGhlIFNIIGNoYW5nZXMgaGF2ZSBvbmx5IGJlZW4gdGVzdGVkIGluID1saXR0bGUgZW5kaWFuPSBtb2RlICovCi8qIEknbSBub3Qgc3VyZSBhYm91dCBiaWcgZW5kaWFuLCBzbyBsZXQncyB3YXJuOiAqLwojaWYgZGVmaW5lZChfX3NoX18pICYmIEJCX0JJR19FTkRJQU4KIyBlcnJvciBpbnNtb2QuYyBtYXkgcmVxdWlyZSBjaGFuZ2VzIGZvciB1c2Ugb24gYmlnIGVuZGlhbiBTSAojZW5kaWYKLyogaXQgbWF5IG9yIG1heSBub3Qgd29yayBvbiB0aGUgU0gxL1NIMi4uLiBFcnJvciBvbiB0aG9zZSBhbHNvICovCiNpZiAoKCEoZGVmaW5lZChfX1NIM19fKSB8fCBkZWZpbmVkKF9fU0g0X18pIHx8IGRlZmluZWQoX19TSDVfXykpKSkgJiYgKGRlZmluZWQoX19zaF9fKSkKI2Vycm9yIGluc21vZC5jIG1heSByZXF1aXJlIGNoYW5nZXMgZm9yIFNIMSBvciBTSDIgdXNlCiNlbmRpZgojZW5kaWYKCi8qIFNwYXJjICovCiNpZiBkZWZpbmVkKF9fc3BhcmNfXykKI2RlZmluZSBNQVRDSF9NQUNISU5FKHgpICh4ID09IEVNX1NQQVJDKQojZGVmaW5lIFNIVF9SRUxNICAgICAgIFNIVF9SRUxBCiNkZWZpbmUgRWxmMzJfUmVsTSAgICAgRWxmMzJfUmVsYQojZGVmaW5lIEVMRkNMQVNTTSAgICAgIEVMRkNMQVNTMzIKI2VuZGlmCgovKiB2ODUwZSAqLwojaWYgZGVmaW5lZChfX3Y4NTBlX18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoKHgpID09IEVNX1Y4NTAgfHwgKHgpID09IEVNX0NZR05VU19WODUwKQojZGVmaW5lIFNIVF9SRUxNCVNIVF9SRUxBCiNkZWZpbmUgRWxmMzJfUmVsTQlFbGYzMl9SZWxhCiNkZWZpbmUgRUxGQ0xBU1NNCUVMRkNMQVNTMzIKI2RlZmluZSBVU0VfUExUX0VOVFJJRVMKI2RlZmluZSBQTFRfRU5UUllfU0laRSA4CiNkZWZpbmUgVVNFX1NJTkdMRQojaWZuZGVmIEVNX0NZR05VU19WODUwCS8qIGdydW1ibGUgKi8KI2RlZmluZSBFTV9DWUdOVVNfVjg1MAkweDkwODAKI2VuZGlmCiNkZWZpbmUgU1lNQk9MX1BSRUZJWAkiXyIKI2VuZGlmCgovKiBYODZfNjQgICovCiNpZiBkZWZpbmVkKF9feDg2XzY0X18pCiNkZWZpbmUgTUFUQ0hfTUFDSElORSh4KSAoeCA9PSBFTV9YODZfNjQpCiNkZWZpbmUgU0hUX1JFTE0JU0hUX1JFTEEKI2RlZmluZSBVU0VfR09UX0VOVFJJRVMKI2RlZmluZSBHT1RfRU5UUllfU0laRSA4CiNkZWZpbmUgVVNFX1NJTkdMRQojZGVmaW5lIEVsZjY0X1JlbE0JRWxmNjRfUmVsYQojZGVmaW5lIEVMRkNMQVNTTQlFTEZDTEFTUzY0CiNlbmRpZgoKI2lmbmRlZiBTSFRfUkVMTQojZXJyb3IgU29ycnksIGJ1dCBpbnNtb2QuYyBkb2VzIG5vdCB5ZXQgc3VwcG9ydCB0aGlzIGFyY2hpdGVjdHVyZS4uLgojZW5kaWYKCgovLy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KLy8tLS0tLS0tLW1vZHV0aWxzIG1vZHVsZS5oLCBsaW5lcyA0NS0yNDIKLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgovKiBEZWZpbml0aW9ucyBmb3IgdGhlIExpbnV4IG1vZHVsZSBzeXNjYWxsIGludGVyZmFjZS4KICAgQ29weXJpZ2h0IDE5OTYsIDE5OTcgTGludXggSW50ZXJuYXRpb25hbC4KCiAgIENvbnRyaWJ1dGVkIGJ5IFJpY2hhcmQgSGVuZGVyc29uIDxydGhAdGFtdS5lZHU+CgogICBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgTGludXggbW9kdXRpbHMuCgogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKICAgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91cgogICBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgoKICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogICBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAgIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KCiAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCiAgIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuICAqLwoKCiNpZm5kZWYgTU9EVVRJTFNfTU9EVUxFX0gKCi8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSovCi8qIEZvciBzaXplb2YoKSB3aGljaCBhcmUgcmVsYXRlZCB0byB0aGUgbW9kdWxlIHBsYXRmb3JtIGFuZCBub3QgdG8gdGhlCiAgIGVudmlyb25tZW50IGlzbm1vZCBpcyBydW5uaW5nIGluLCB1c2Ugc2l6ZW9mX3h4IGluc3RlYWQgb2Ygc2l6ZW9mKHh4KS4gICovCgojZGVmaW5lIHRndF9zaXplb2ZfY2hhcgkJc2l6ZW9mKGNoYXIpCiNkZWZpbmUgdGd0X3NpemVvZl9zaG9ydAlzaXplb2Yoc2hvcnQpCiNkZWZpbmUgdGd0X3NpemVvZl9pbnQJCXNpemVvZihpbnQpCiNkZWZpbmUgdGd0X3NpemVvZl9sb25nCQlzaXplb2YobG9uZykKI2RlZmluZSB0Z3Rfc2l6ZW9mX2NoYXJfcAlzaXplb2YoY2hhciAqKQojZGVmaW5lIHRndF9zaXplb2Zfdm9pZF9wCXNpemVvZih2b2lkICopCiNkZWZpbmUgdGd0X2xvbmcJCWxvbmcKCiNpZiBkZWZpbmVkKF9fc3BhcmNfXykgJiYgIWRlZmluZWQoX19zcGFyY192OV9fKSAmJiBkZWZpbmVkKEFSQ0hfc3BhcmM2NCkKI3VuZGVmIHRndF9zaXplb2ZfbG9uZwojdW5kZWYgdGd0X3NpemVvZl9jaGFyX3AKI3VuZGVmIHRndF9zaXplb2Zfdm9pZF9wCiN1bmRlZiB0Z3RfbG9uZwplbnVtIHsKCXRndF9zaXplb2ZfbG9uZyA9IDgsCgl0Z3Rfc2l6ZW9mX2NoYXJfcCA9IDgsCgl0Z3Rfc2l6ZW9mX3ZvaWRfcCA9IDgKfTsKI2RlZmluZSB0Z3RfbG9uZwkJbG9uZyBsb25nCiNlbmRpZgoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KLyogVGhlIHN0cnVjdHVyZXMgdXNlZCBpbiBMaW51eCAyLjEuICAqLwoKLyogTm90ZTogbmV3X21vZHVsZV9zeW1ib2wgZG9lcyBub3QgdXNlIHRndF9sb25nIGludGVudGlvbmFsbHkgKi8Kc3RydWN0IG5ld19tb2R1bGVfc3ltYm9sIHsKCXVuc2lnbmVkIGxvbmcgdmFsdWU7Cgl1bnNpZ25lZCBsb25nIG5hbWU7Cn07CgpzdHJ1Y3QgbmV3X21vZHVsZV9wZXJzaXN0OwoKc3RydWN0IG5ld19tb2R1bGVfcmVmIHsKCXVuc2lnbmVkIHRndF9sb25nIGRlcDsJCS8qIGtlcm5lbCBhZGRyZXNzZXMgKi8KCXVuc2lnbmVkIHRndF9sb25nIHJlZjsKCXVuc2lnbmVkIHRndF9sb25nIG5leHRfcmVmOwp9OwoKc3RydWN0IG5ld19tb2R1bGUgewoJdW5zaWduZWQgdGd0X2xvbmcgc2l6ZV9vZl9zdHJ1Y3Q7CS8qID09IHNpemVvZihtb2R1bGUpICovCgl1bnNpZ25lZCB0Z3RfbG9uZyBuZXh0OwoJdW5zaWduZWQgdGd0X2xvbmcgbmFtZTsKCXVuc2lnbmVkIHRndF9sb25nIHNpemU7CgoJdGd0X2xvbmcgdXNlY291bnQ7Cgl1bnNpZ25lZCB0Z3RfbG9uZyBmbGFnczsJCS8qIEFVVE9DTEVBTiBldCBhbCAqLwoKCXVuc2lnbmVkIG5zeW1zOwoJdW5zaWduZWQgbmRlcHM7CgoJdW5zaWduZWQgdGd0X2xvbmcgc3ltczsKCXVuc2lnbmVkIHRndF9sb25nIGRlcHM7Cgl1bnNpZ25lZCB0Z3RfbG9uZyByZWZzOwoJdW5zaWduZWQgdGd0X2xvbmcgaW5pdDsKCXVuc2lnbmVkIHRndF9sb25nIGNsZWFudXA7Cgl1bnNpZ25lZCB0Z3RfbG9uZyBleF90YWJsZV9zdGFydDsKCXVuc2lnbmVkIHRndF9sb25nIGV4X3RhYmxlX2VuZDsKI2lmZGVmIF9fYWxwaGFfXwoJdW5zaWduZWQgdGd0X2xvbmcgZ3A7CiNlbmRpZgoJLyogRXZlcnl0aGluZyBhZnRlciBoZXJlIGlzIGV4dGVuc2lvbi4gICovCgl1bnNpZ25lZCB0Z3RfbG9uZyBwZXJzaXN0X3N0YXJ0OwoJdW5zaWduZWQgdGd0X2xvbmcgcGVyc2lzdF9lbmQ7Cgl1bnNpZ25lZCB0Z3RfbG9uZyBjYW5fdW5sb2FkOwoJdW5zaWduZWQgdGd0X2xvbmcgcnVuc2l6ZTsKCWNvbnN0IGNoYXIgKmthbGxzeW1zX3N0YXJ0OyAgICAgLyogQWxsIHN5bWJvbHMgZm9yIGtlcm5lbCBkZWJ1Z2dpbmcgKi8KCWNvbnN0IGNoYXIgKmthbGxzeW1zX2VuZDsKCWNvbnN0IGNoYXIgKmFyY2hkYXRhX3N0YXJ0OyAgICAgLyogYXJjaCBzcGVjaWZpYyBkYXRhIGZvciBtb2R1bGUgKi8KCWNvbnN0IGNoYXIgKmFyY2hkYXRhX2VuZDsKCWNvbnN0IGNoYXIgKmtlcm5lbF9kYXRhOyAgICAgICAgLyogUmVzZXJ2ZWQgZm9yIGtlcm5lbCBpbnRlcm5hbCB1c2UgKi8KfTsKCiNpZmRlZiBBUkNIREFUQU0KI2RlZmluZSBBUkNIREFUQV9TRUNfTkFNRSBBUkNIREFUQU0KI2Vsc2UKI2RlZmluZSBBUkNIREFUQV9TRUNfTkFNRSAiX19hcmNoZGF0YSIKI2VuZGlmCiNkZWZpbmUgS0FMTFNZTVNfU0VDX05BTUUgIl9fa2FsbHN5bXMiCgoKc3RydWN0IG5ld19tb2R1bGVfaW5mbyB7Cgl1bnNpZ25lZCBsb25nIGFkZHI7Cgl1bnNpZ25lZCBsb25nIHNpemU7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoJbG9uZyB1c2Vjb3VudDsKfTsKCi8qIEJpdHMgb2YgbW9kdWxlLmZsYWdzLiAgKi8KZW51bSB7CglORVdfTU9EX1JVTk5JTkcgPSAxLAoJTkVXX01PRF9ERUxFVEVEID0gMiwKCU5FV19NT0RfQVVUT0NMRUFOID0gNCwKCU5FV19NT0RfVklTSVRFRCA9IDgsCglORVdfTU9EX1VTRURfT05DRSA9IDE2Cn07CgppbnQgaW5pdF9tb2R1bGUoY29uc3QgY2hhciAqbmFtZSwgY29uc3Qgc3RydWN0IG5ld19tb2R1bGUgKik7CmludCBxdWVyeV9tb2R1bGUoY29uc3QgY2hhciAqbmFtZSwgaW50IHdoaWNoLCB2b2lkICpidWYsCgkJc2l6ZV90IGJ1ZnNpemUsIHNpemVfdCAqcmV0KTsKCi8qIFZhbHVlcyBmb3IgcXVlcnlfbW9kdWxlJ3Mgd2hpY2guICAqLwplbnVtIHsKCVFNX01PRFVMRVMgPSAxLAoJUU1fREVQUyA9IDIsCglRTV9SRUZTID0gMywKCVFNX1NZTUJPTFMgPSA0LAoJUU1fSU5GTyA9IDUKfTsKCi8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSovCi8qIFRoZSBzeXN0ZW0gY2FsbHMgdW5jaGFuZ2VkIGJldHdlZW4gMi4wIGFuZCAyLjEuICAqLwoKdW5zaWduZWQgbG9uZyBjcmVhdGVfbW9kdWxlKGNvbnN0IGNoYXIgKiwgc2l6ZV90KTsKaW50IGRlbGV0ZV9tb2R1bGUoY29uc3QgY2hhciAqbW9kdWxlLCB1bnNpZ25lZCBpbnQgZmxhZ3MpOwoKCiNlbmRpZiAvKiBtb2R1bGUuaCAqLwoKLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi8vLS0tLS0tLS1lbmQgb2YgbW9kdXRpbHMgbW9kdWxlLmgKLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgoKCi8vLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQovLy0tLS0tLS0tbW9kdXRpbHMgb2JqLmgsIGxpbmVzIDI1My00NjIKLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgovKiBFbGYgb2JqZWN0IGZpbGUgbG9hZGluZyBhbmQgcmVsb2NhdGlvbiByb3V0aW5lcy4KICAgQ29weXJpZ2h0IDE5OTYsIDE5OTcgTGludXggSW50ZXJuYXRpb25hbC4KCiAgIENvbnRyaWJ1dGVkIGJ5IFJpY2hhcmQgSGVuZGVyc29uIDxydGhAdGFtdS5lZHU+CgogICBUaGlzIGZpbGUgaXMgcGFydCBvZiB0aGUgTGludXggbW9kdXRpbHMuCgogICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeSBpdAogICB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUKICAgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91cgogICBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgoKICAgVGhpcyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dAogICBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCiAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VCiAgIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KCiAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCiAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sCiAgIEluYy4sIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAwMjExMS0xMzA3LCBVU0EuICAqLwoKCiNpZm5kZWYgTU9EVVRJTFNfT0JKX0gKCi8qIFRoZSByZWxvY2F0YWJsZSBvYmplY3QgaXMgbWFuaXB1bGF0ZWQgdXNpbmcgZWxmaW4gdHlwZXMuICAqLwoKI2luY2x1ZGUgPGVsZi5oPgojaW5jbHVkZSA8ZW5kaWFuLmg+CgojaWZuZGVmIEVsZlcKIyBpZiBFTEZDTEFTU00gPT0gRUxGQ0xBU1MzMgojICBkZWZpbmUgRWxmVyh4KSAgRWxmMzJfICMjIHgKIyAgZGVmaW5lIEVMRlcoeCkgIEVMRjMyXyAjIyB4CiMgZWxzZQojICBkZWZpbmUgRWxmVyh4KSAgRWxmNjRfICMjIHgKIyAgZGVmaW5lIEVMRlcoeCkgIEVMRjY0XyAjIyB4CiMgZW5kaWYKI2VuZGlmCgovKiBGb3Igc29tZSByZWFzb24gdGhpcyBpcyBtaXNzaW5nIGZyb20gc29tZSBhbmNpZW50IEMgbGlicmFyaWVzLi4uLiAgKi8KI2lmbmRlZiBFTEYzMl9TVF9JTkZPCiMgZGVmaW5lIEVMRjMyX1NUX0lORk8oYmluZCwgdHlwZSkgICAgICAgKCgoYmluZCkgPDwgNCkgKyAoKHR5cGUpICYgMHhmKSkKI2VuZGlmCgojaWZuZGVmIEVMRjY0X1NUX0lORk8KIyBkZWZpbmUgRUxGNjRfU1RfSU5GTyhiaW5kLCB0eXBlKSAgICAgICAoKChiaW5kKSA8PCA0KSArICgodHlwZSkgJiAweGYpKQojZW5kaWYKCiNkZWZpbmUgRUxGX1NUX0JJTkQoaW5mbykgRUxGVyhTVF9CSU5EKShpbmZvKQojZGVmaW5lIEVMRl9TVF9UWVBFKGluZm8pIEVMRlcoU1RfVFlQRSkoaW5mbykKI2RlZmluZSBFTEZfU1RfSU5GTyhiaW5kLCB0eXBlKSBFTEZXKFNUX0lORk8pKGJpbmQsIHR5cGUpCiNkZWZpbmUgRUxGX1JfVFlQRSh2YWwpIEVMRlcoUl9UWVBFKSh2YWwpCiNkZWZpbmUgRUxGX1JfU1lNKHZhbCkgRUxGVyhSX1NZTSkodmFsKQoKc3RydWN0IG9ial9zdHJpbmdfcGF0Y2g7CnN0cnVjdCBvYmpfc3ltYm9sX3BhdGNoOwoKc3RydWN0IG9ial9zZWN0aW9uIHsKCUVsZlcoU2hkcikgaGVhZGVyOwoJY29uc3QgY2hhciAqbmFtZTsKCWNoYXIgKmNvbnRlbnRzOwoJc3RydWN0IG9ial9zZWN0aW9uICpsb2FkX25leHQ7CglpbnQgaWR4Owp9OwoKc3RydWN0IG9ial9zeW1ib2wgewoJc3RydWN0IG9ial9zeW1ib2wgKm5leHQ7CS8qIGhhc2ggdGFibGUgbGluayAqLwoJY29uc3QgY2hhciAqbmFtZTsKCXVuc2lnbmVkIGxvbmcgdmFsdWU7Cgl1bnNpZ25lZCBsb25nIHNpemU7CglpbnQgc2VjaWR4OwkJCS8qIHRoZSBkZWZpbmluZyBzZWN0aW9uIGluZGV4L21vZHVsZSAqLwoJaW50IGluZm87CglpbnQga3N5bWlkeDsJCQkvKiBmb3IgZXhwb3J0IHRvIHRoZSBrZXJuZWwgc3ltdGFiICovCglpbnQgcmVmZXJlbmNlZDsJCS8qIGFjdHVhbGx5IHVzZWQgaW4gdGhlIGxpbmsgKi8KfTsKCi8qIEhhcmRjb2RlIHRoZSBoYXNoIHRhYmxlIHNpemUuICBXZSBzaG91bGRuJ3QgYmUgbmVlZGluZyBzbyBtYW55CiAgIHN5bWJvbHMgdGhhdCB3ZSBiZWdpbiB0byBkZWdyYWRlIHBlcmZvcm1hbmNlLCBhbmQgd2UgZ2V0IGEgYmlnIHdpbgogICBieSBnaXZpbmcgdGhlIGNvbXBpbGVyIGEgY29uc3RhbnQgZGl2aXNvci4gICovCgojZGVmaW5lIEhBU0hfQlVDS0VUUyAgNTIxCgpzdHJ1Y3Qgb2JqX2ZpbGUgewoJRWxmVyhFaGRyKSBoZWFkZXI7CglFbGZXKEFkZHIpIGJhc2VhZGRyOwoJc3RydWN0IG9ial9zZWN0aW9uICoqc2VjdGlvbnM7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKmxvYWRfb3JkZXI7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKipsb2FkX29yZGVyX3NlYXJjaF9zdGFydDsKCXN0cnVjdCBvYmpfc3RyaW5nX3BhdGNoICpzdHJpbmdfcGF0Y2hlczsKCXN0cnVjdCBvYmpfc3ltYm9sX3BhdGNoICpzeW1ib2xfcGF0Y2hlczsKCWludCAoKnN5bWJvbF9jbXApKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKTsgLyogY2FudCBiZSBGQVNUX0ZVTkMgKi8KCXVuc2lnbmVkIGxvbmcgKCpzeW1ib2xfaGFzaCkoY29uc3QgY2hhciAqKSBGQVNUX0ZVTkM7Cgl1bnNpZ25lZCBsb25nIGxvY2FsX3N5bXRhYl9zaXplOwoJc3RydWN0IG9ial9zeW1ib2wgKipsb2NhbF9zeW10YWI7CglzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltdGFiW0hBU0hfQlVDS0VUU107Cn07CgplbnVtIG9ial9yZWxvYyB7CglvYmpfcmVsb2Nfb2ssCglvYmpfcmVsb2Nfb3ZlcmZsb3csCglvYmpfcmVsb2NfZGFuZ2Vyb3VzLAoJb2JqX3JlbG9jX3VuaGFuZGxlZAp9OwoKc3RydWN0IG9ial9zdHJpbmdfcGF0Y2ggewoJc3RydWN0IG9ial9zdHJpbmdfcGF0Y2ggKm5leHQ7CglpbnQgcmVsb2Nfc2VjaWR4OwoJRWxmVyhBZGRyKSByZWxvY19vZmZzZXQ7CglFbGZXKEFkZHIpIHN0cmluZ19vZmZzZXQ7Cn07CgpzdHJ1Y3Qgb2JqX3N5bWJvbF9wYXRjaCB7CglzdHJ1Y3Qgb2JqX3N5bWJvbF9wYXRjaCAqbmV4dDsKCWludCByZWxvY19zZWNpZHg7CglFbGZXKEFkZHIpIHJlbG9jX29mZnNldDsKCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07Cn07CgoKLyogR2VuZXJpYyBvYmplY3QgbWFuaXB1bGF0aW9uIHJvdXRpbmVzLiAgKi8KCnN0YXRpYyB1bnNpZ25lZCBsb25nIEZBU1RfRlVOQyBvYmpfZWxmX2hhc2goY29uc3QgY2hhciAqKTsKCnN0YXRpYyB1bnNpZ25lZCBsb25nIG9ial9lbGZfaGFzaF9uKGNvbnN0IGNoYXIgKiwgdW5zaWduZWQgbG9uZyBsZW4pOwoKc3RhdGljIHN0cnVjdCBvYmpfc3ltYm9sICpvYmpfZmluZF9zeW1ib2woc3RydWN0IG9ial9maWxlICpmLAoJCWNvbnN0IGNoYXIgKm5hbWUpOwoKc3RhdGljIEVsZlcoQWRkcikgb2JqX3N5bWJvbF9maW5hbF92YWx1ZShzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bSk7CgojaWYgRU5BQkxFX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcKc3RhdGljIHZvaWQgb2JqX3NldF9zeW1ib2xfY29tcGFyZShzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJaW50ICgqY21wKShjb25zdCBjaGFyICosIGNvbnN0IGNoYXIgKiksCgkJdW5zaWduZWQgbG9uZyAoKmhhc2gpKGNvbnN0IGNoYXIgKikgRkFTVF9GVU5DKTsKI2VuZGlmCgpzdGF0aWMgc3RydWN0IG9ial9zZWN0aW9uICpvYmpfZmluZF9zZWN0aW9uKHN0cnVjdCBvYmpfZmlsZSAqZiwKCQljb25zdCBjaGFyICpuYW1lKTsKCnN0YXRpYyB2b2lkIG9ial9pbnNlcnRfc2VjdGlvbl9sb2FkX29yZGVyKHN0cnVjdCBvYmpfZmlsZSAqZiwKCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYyk7CgpzdGF0aWMgc3RydWN0IG9ial9zZWN0aW9uICpvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbihzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJY29uc3QgY2hhciAqbmFtZSwKCQl1bnNpZ25lZCBsb25nIGFsaWduLAoJCXVuc2lnbmVkIGxvbmcgc2l6ZSk7CgpzdGF0aWMgc3RydWN0IG9ial9zZWN0aW9uICpvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbl9maXJzdChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJY29uc3QgY2hhciAqbmFtZSwKCQl1bnNpZ25lZCBsb25nIGFsaWduLAoJCXVuc2lnbmVkIGxvbmcgc2l6ZSk7CgpzdGF0aWMgdm9pZCAqb2JqX2V4dGVuZF9zZWN0aW9uKHN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjLCB1bnNpZ25lZCBsb25nIG1vcmUpOwoKc3RhdGljIHZvaWQgb2JqX3N0cmluZ19wYXRjaChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIGludCBzZWNpZHgsIEVsZlcoQWRkcikgb2Zmc2V0LAoJCWNvbnN0IGNoYXIgKnN0cmluZyk7CgpzdGF0aWMgdm9pZCBvYmpfc3ltYm9sX3BhdGNoKHN0cnVjdCBvYmpfZmlsZSAqZiwgaW50IHNlY2lkeCwgRWxmVyhBZGRyKSBvZmZzZXQsCgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bSk7CgpzdGF0aWMgdm9pZCBvYmpfY2hlY2tfdW5kZWZpbmVkcyhzdHJ1Y3Qgb2JqX2ZpbGUgKmYpOwoKc3RhdGljIHZvaWQgb2JqX2FsbG9jYXRlX2NvbW1vbnMoc3RydWN0IG9ial9maWxlICpmKTsKCnN0YXRpYyB1bnNpZ25lZCBsb25nIG9ial9sb2FkX3NpemUoc3RydWN0IG9ial9maWxlICpmKTsKCnN0YXRpYyBpbnQgb2JqX3JlbG9jYXRlKHN0cnVjdCBvYmpfZmlsZSAqZiwgRWxmVyhBZGRyKSBiYXNlKTsKCiNpZiAhTE9BREJJVFMKI2RlZmluZSBvYmpfbG9hZChpbWFnZSwgaW1hZ2Vfc2l6ZSwgbG9hZHByb2diaXRzKSBcCglvYmpfbG9hZChpbWFnZSwgaW1hZ2Vfc2l6ZSkKI2VuZGlmCnN0YXRpYyBzdHJ1Y3Qgb2JqX2ZpbGUgKm9ial9sb2FkKGNoYXIgKmltYWdlLCBzaXplX3QgaW1hZ2Vfc2l6ZSwgaW50IGxvYWRwcm9nYml0cyk7CgpzdGF0aWMgaW50IG9ial9jcmVhdGVfaW1hZ2Uoc3RydWN0IG9ial9maWxlICpmLCBjaGFyICppbWFnZSk7CgovKiBBcmNoaXRlY3R1cmUgc3BlY2lmaWMgbWFuaXB1bGF0aW9uIHJvdXRpbmVzLiAgKi8KCnN0YXRpYyBzdHJ1Y3Qgb2JqX2ZpbGUgKmFyY2hfbmV3X2ZpbGUodm9pZCk7CgpzdGF0aWMgc3RydWN0IG9ial9zZWN0aW9uICphcmNoX25ld19zZWN0aW9uKHZvaWQpOwoKc3RhdGljIHN0cnVjdCBvYmpfc3ltYm9sICphcmNoX25ld19zeW1ib2wodm9pZCk7CgpzdGF0aWMgZW51bSBvYmpfcmVsb2MgYXJjaF9hcHBseV9yZWxvY2F0aW9uKHN0cnVjdCBvYmpfZmlsZSAqZiwKCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnRhcmdzZWMsCgkJLypzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnN5bXNlYywqLwoJCXN0cnVjdCBvYmpfc3ltYm9sICpzeW0sCgkJRWxmVyhSZWxNKSAqcmVsLCBFbGZXKEFkZHIpIHZhbHVlKTsKCnN0YXRpYyB2b2lkIGFyY2hfY3JlYXRlX2dvdChzdHJ1Y3Qgb2JqX2ZpbGUgKmYpOwojaWYgRU5BQkxFX0ZFQVRVUkVfQ0hFQ0tfVEFJTlRFRF9NT0RVTEUKc3RhdGljIGludCBvYmpfZ3BsX2xpY2Vuc2Uoc3RydWN0IG9ial9maWxlICpmLCBjb25zdCBjaGFyICoqbGljZW5zZSk7CiNlbmRpZgojZW5kaWYgLyogb2JqLmggKi8KLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCi8vLS0tLS0tLS1lbmQgb2YgbW9kdXRpbHMgb2JqLmgKLy8tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgoKLyogU1BGWCBpcyBhbHdheXMgYSBzdHJpbmcsIHNvIGl0IGNhbiBiZSBjb25jYXRlbmF0ZWQgdG8gc3RyaW5nIGNvbnN0YW50cy4gICovCiNpZmRlZiBTWU1CT0xfUFJFRklYCiNkZWZpbmUgU1BGWAlTWU1CT0xfUFJFRklYCiNlbHNlCiNkZWZpbmUgU1BGWAkiIgojZW5kaWYKCmVudW0geyBTVFJWRVJTSU9OTEVOID0gNjQgfTsKCi8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSovCgojZGVmaW5lIGZsYWdfZm9yY2VfbG9hZCAob3B0aW9uX21hc2szMiAmIElOU01PRF9PUFRfRk9SQ0UpCiNkZWZpbmUgZmxhZ19hdXRvY2xlYW4gKG9wdGlvbl9tYXNrMzIgJiBJTlNNT0RfT1BUX0tFUk5FTEQpCiNkZWZpbmUgZmxhZ192ZXJib3NlIChvcHRpb25fbWFzazMyICYgSU5TTU9EX09QVF9WRVJCT1NFKQojZGVmaW5lIGZsYWdfcXVpZXQgKG9wdGlvbl9tYXNrMzIgJiBJTlNNT0RfT1BUX1NJTEVOVCkKI2RlZmluZSBmbGFnX25vZXhwb3J0IChvcHRpb25fbWFzazMyICYgSU5TTU9EX09QVF9OT19FWFBPUlQpCiNkZWZpbmUgZmxhZ19wcmludF9sb2FkX21hcCAob3B0aW9uX21hc2szMiAmIElOU01PRF9PUFRfUFJJTlRfTUFQKQoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCiNpZiBkZWZpbmVkKFVTRV9MSVNUKQoKc3RydWN0IGFyY2hfbGlzdF9lbnRyeSB7CglzdHJ1Y3QgYXJjaF9saXN0X2VudHJ5ICpuZXh0OwoJTElTVF9BUkNIVFlQRSBhZGRlbmQ7CglpbnQgb2Zmc2V0OwoJaW50IGluaXRlZCA6IDE7Cn07CgojZW5kaWYKCiNpZiBkZWZpbmVkKFVTRV9TSU5HTEUpCgpzdHJ1Y3QgYXJjaF9zaW5nbGVfZW50cnkgewoJaW50IG9mZnNldDsKCWludCBpbml0ZWQgOiAxOwoJaW50IGFsbG9jYXRlZCA6IDE7Cn07CgojZW5kaWYKCiNpZiBkZWZpbmVkKF9fbWlwc19fKQpzdHJ1Y3QgbWlwc19oaTE2IHsKCXN0cnVjdCBtaXBzX2hpMTYgKm5leHQ7CglFbGZXKEFkZHIpICphZGRyOwoJRWxmVyhBZGRyKSB2YWx1ZTsKfTsKI2VuZGlmCgpzdHJ1Y3QgYXJjaF9maWxlIHsKCXN0cnVjdCBvYmpfZmlsZSByb290OwojaWYgZGVmaW5lZChVU0VfUExUX0VOVFJJRVMpCglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnBsdDsKI2VuZGlmCiNpZiBkZWZpbmVkKFVTRV9HT1RfRU5UUklFUykKCXN0cnVjdCBvYmpfc2VjdGlvbiAqZ290OwojZW5kaWYKI2lmIGRlZmluZWQoX19taXBzX18pCglzdHJ1Y3QgbWlwc19oaTE2ICptaXBzX2hpMTZfbGlzdDsKI2VuZGlmCn07CgpzdHJ1Y3QgYXJjaF9zeW1ib2wgewoJc3RydWN0IG9ial9zeW1ib2wgcm9vdDsKI2lmIGRlZmluZWQoVVNFX1BMVF9FTlRSSUVTKQojaWYgZGVmaW5lZChVU0VfUExUX0xJU1QpCglzdHJ1Y3QgYXJjaF9saXN0X2VudHJ5ICpwbHRlbnQ7CiNlbHNlCglzdHJ1Y3QgYXJjaF9zaW5nbGVfZW50cnkgcGx0ZW50OwojZW5kaWYKI2VuZGlmCiNpZiBkZWZpbmVkKFVTRV9HT1RfRU5UUklFUykKCXN0cnVjdCBhcmNoX3NpbmdsZV9lbnRyeSBnb3RlbnQ7CiNlbmRpZgp9OwoKCnN0cnVjdCBleHRlcm5hbF9tb2R1bGUgewoJY29uc3QgY2hhciAqbmFtZTsKCUVsZlcoQWRkcikgYWRkcjsKCWludCB1c2VkOwoJc2l6ZV90IG5zeW1zOwoJc3RydWN0IG5ld19tb2R1bGVfc3ltYm9sICpzeW1zOwp9OwoKc3RhdGljIHN0cnVjdCBuZXdfbW9kdWxlX3N5bWJvbCAqa3N5bXM7CnN0YXRpYyBzaXplX3QgbmtzeW1zOwoKc3RhdGljIHN0cnVjdCBleHRlcm5hbF9tb2R1bGUgKmV4dF9tb2R1bGVzOwpzdGF0aWMgaW50IG5fZXh0X21vZHVsZXM7CnN0YXRpYyBpbnQgbl9leHRfbW9kdWxlc191c2VkOwoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCgpzdGF0aWMgc3RydWN0IG9ial9maWxlICphcmNoX25ld19maWxlKHZvaWQpCnsKCXN0cnVjdCBhcmNoX2ZpbGUgKmY7CglmID0geHphbGxvYyhzaXplb2YoKmYpKTsKCXJldHVybiAmZi0+cm9vdDsgLyogaXQncyBhIGZpcnN0IG1lbWJlciAqLwp9CgpzdGF0aWMgc3RydWN0IG9ial9zZWN0aW9uICphcmNoX25ld19zZWN0aW9uKHZvaWQpCnsKCXJldHVybiB4emFsbG9jKHNpemVvZihzdHJ1Y3Qgb2JqX3NlY3Rpb24pKTsKfQoKc3RhdGljIHN0cnVjdCBvYmpfc3ltYm9sICphcmNoX25ld19zeW1ib2wodm9pZCkKewoJc3RydWN0IGFyY2hfc3ltYm9sICpzeW07CglzeW0gPSB4emFsbG9jKHNpemVvZigqc3ltKSk7CglyZXR1cm4gJnN5bS0+cm9vdDsKfQoKc3RhdGljIGVudW0gb2JqX3JlbG9jCmFyY2hfYXBwbHlfcmVsb2NhdGlvbihzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJc3RydWN0IG9ial9zZWN0aW9uICp0YXJnc2VjLAoJCS8qc3RydWN0IG9ial9zZWN0aW9uICpzeW1zZWMsKi8KCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltLAoJCUVsZlcoUmVsTSkgKnJlbCwgRWxmVyhBZGRyKSB2KQp7CiNpZiBkZWZpbmVkKF9fYXJtX18pIHx8IGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX19tYzY4MDAwX18pIFwKIHx8IGRlZmluZWQoX19zaF9fKSB8fCBkZWZpbmVkKF9fczM5MF9fKSB8fCBkZWZpbmVkKF9feDg2XzY0X18pIFwKIHx8IGRlZmluZWQoX19wb3dlcnBjX18pIHx8IGRlZmluZWQoX19taXBzX18pCglzdHJ1Y3QgYXJjaF9maWxlICppZmlsZSA9IChzdHJ1Y3QgYXJjaF9maWxlICopIGY7CiNlbmRpZgoJZW51bSBvYmpfcmVsb2MgcmV0ID0gb2JqX3JlbG9jX29rOwoJRWxmVyhBZGRyKSAqbG9jID0gKEVsZlcoQWRkcikgKikgKHRhcmdzZWMtPmNvbnRlbnRzICsgcmVsLT5yX29mZnNldCk7CiNpZiBkZWZpbmVkKF9fYXJtX18pIHx8IGRlZmluZWQoX19IODMwMEhfXykgfHwgZGVmaW5lZChfX0g4MzAwU19fKSBcCiB8fCBkZWZpbmVkKF9faTM4Nl9fKSB8fCBkZWZpbmVkKF9fbWM2ODAwMF9fKSB8fCBkZWZpbmVkKF9fbWljcm9ibGF6ZV9fKSBcCiB8fCBkZWZpbmVkKF9fbWlwc19fKSB8fCBkZWZpbmVkKF9fbmlvczJfXykgfHwgZGVmaW5lZChfX3Bvd2VycGNfXykgXAogfHwgZGVmaW5lZChfX3MzOTBfXykgfHwgZGVmaW5lZChfX3NoX18pIHx8IGRlZmluZWQoX194ODZfNjRfXykKCUVsZlcoQWRkcikgZG90ID0gdGFyZ3NlYy0+aGVhZGVyLnNoX2FkZHIgKyByZWwtPnJfb2Zmc2V0OwojZW5kaWYKI2lmIGRlZmluZWQoVVNFX0dPVF9FTlRSSUVTKSB8fCBkZWZpbmVkKFVTRV9QTFRfRU5UUklFUykKCXN0cnVjdCBhcmNoX3N5bWJvbCAqaXN5bSA9IChzdHJ1Y3QgYXJjaF9zeW1ib2wgKikgc3ltOwojZW5kaWYKI2lmIGRlZmluZWQoX19hcm1fXykgfHwgZGVmaW5lZChfX2kzODZfXykgfHwgZGVmaW5lZChfX21jNjgwMDBfXykgXAogfHwgZGVmaW5lZChfX3NoX18pIHx8IGRlZmluZWQoX19zMzkwX18pCiNpZiBkZWZpbmVkKFVTRV9HT1RfRU5UUklFUykKCUVsZlcoQWRkcikgZ290ID0gaWZpbGUtPmdvdCA/IGlmaWxlLT5nb3QtPmhlYWRlci5zaF9hZGRyIDogMDsKI2VuZGlmCiNlbmRpZgojaWYgZGVmaW5lZChVU0VfUExUX0VOVFJJRVMpCglFbGZXKEFkZHIpIHBsdCA9IGlmaWxlLT5wbHQgPyBpZmlsZS0+cGx0LT5oZWFkZXIuc2hfYWRkciA6IDA7Cgl1bnNpZ25lZCBsb25nICppcDsKIyBpZiBkZWZpbmVkKFVTRV9QTFRfTElTVCkKCXN0cnVjdCBhcmNoX2xpc3RfZW50cnkgKnBlOwojIGVsc2UKCXN0cnVjdCBhcmNoX3NpbmdsZV9lbnRyeSAqcGU7CiMgZW5kaWYKI2VuZGlmCgoJc3dpdGNoIChFTEZfUl9UWVBFKHJlbC0+cl9pbmZvKSkgewoKI2lmIGRlZmluZWQoX19hcm1fXykKCgkJY2FzZSBSX0FSTV9OT05FOgoJCQlicmVhazsKCgkJY2FzZSBSX0FSTV9BQlMzMjoKCQkJKmxvYyArPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSX0FSTV9HT1QzMjoKCQkJZ290byBiYl91c2VfZ290OwoKCQljYXNlIFJfQVJNX0dPVFBDOgoJCQkvKiByZWxhdGl2ZSByZWxvYywgYWx3YXlzIHRvIF9HTE9CQUxfT0ZGU0VUX1RBQkxFXwoJCQkgKiAod2hpY2ggaXMgLmdvdCkgc2ltaWxhciB0byBicmFuY2gsCgkJCSAqIGJ1dCBpcyBmdWxsIDMyIGJpdHMgcmVsYXRpdmUgKi8KCgkJCSpsb2MgKz0gZ290IC0gZG90OwoJCQlicmVhazsKCgkJY2FzZSBSX0FSTV9QQzI0OgoJCWNhc2UgUl9BUk1fUExUMzI6CgkJCWdvdG8gYmJfdXNlX3BsdDsKCgkJY2FzZSBSX0FSTV9HT1RPRkY6IC8qIGFkZHJlc3MgcmVsYXRpdmUgdG8gdGhlIGdvdCAqLwoJCQkqbG9jICs9IHYgLSBnb3Q7CgkJCWJyZWFrOwoKI2VsaWYgZGVmaW5lZChfX2NyaXNfXykKCgkJY2FzZSBSX0NSSVNfTk9ORToKCQkJYnJlYWs7CgoJCWNhc2UgUl9DUklTXzMyOgoJCQkvKiBDUklTIGtlZXBzIHRoZSByZWxvY2F0aW9uIHZhbHVlIGluIHRoZSByX2FkZGVuZCBmaWVsZCBhbmQKCQkJICogc2hvdWxkIG5vdCB1c2Ugd2hhdHMgaW4gKmxvYyBhdCBhbGwKCQkJICovCgkJCSpsb2MgPSB2OwoJCQlicmVhazsKCiNlbGlmIGRlZmluZWQoX19IODMwMEhfXykgfHwgZGVmaW5lZChfX0g4MzAwU19fKQoKCQljYXNlIFJfSDhfRElSMjRSODoKCQkJbG9jID0gKEVsZlcoQWRkcikgKikoKEVsZlcoQWRkcikpbG9jIC0gMSk7CgkJCSpsb2MgPSAoKmxvYyAmIDB4ZmYwMDAwMDApIHwgKCgqbG9jICYgMHhmZmZmZmYpICsgdik7CgkJCWJyZWFrOwoJCWNhc2UgUl9IOF9ESVIyNEE4OgoJCQkqbG9jICs9IHY7CgkJCWJyZWFrOwoJCWNhc2UgUl9IOF9ESVIzMjoKCQljYXNlIFJfSDhfRElSMzJBMTY6CgkJCSpsb2MgKz0gdjsKCQkJYnJlYWs7CgkJY2FzZSBSX0g4X1BDUkVMMTY6CgkJCXYgLT0gZG90ICsgMjsKCQkJaWYgKChFbGZXKFN3b3JkKSl2ID4gMHg3ZmZmCgkJCSB8fCAoRWxmVyhTd29yZCkpdiA8IC0oRWxmVyhTd29yZCkpMHg4MDAwCgkJCSkgewoJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQl9IGVsc2UgewoJCQkJKih1bnNpZ25lZCBzaG9ydCAqKWxvYyA9IHY7CgkJCX0KCQkJYnJlYWs7CgkJY2FzZSBSX0g4X1BDUkVMODoKCQkJdiAtPSBkb3QgKyAxOwoJCQlpZiAoKEVsZlcoU3dvcmQpKXYgPiAweDdmCgkJCSB8fCAoRWxmVyhTd29yZCkpdiA8IC0oRWxmVyhTd29yZCkpMHg4MAoJCQkpIHsKCQkJCXJldCA9IG9ial9yZWxvY19vdmVyZmxvdzsKCQkJfSBlbHNlIHsKCQkJCSoodW5zaWduZWQgY2hhciAqKWxvYyA9IHY7CgkJCX0KCQkJYnJlYWs7CgojZWxpZiBkZWZpbmVkKF9faTM4Nl9fKQoKCQljYXNlIFJfMzg2X05PTkU6CgkJCWJyZWFrOwoKCQljYXNlIFJfMzg2XzMyOgoJCQkqbG9jICs9IHY7CgkJCWJyZWFrOwoKCQljYXNlIFJfMzg2X1BMVDMyOgoJCWNhc2UgUl8zODZfUEMzMjoKCQljYXNlIFJfMzg2X0dPVE9GRjoKCQkJKmxvYyArPSB2IC0gZG90OwoJCQlicmVhazsKCgkJY2FzZSBSXzM4Nl9HTE9CX0RBVDoKCQljYXNlIFJfMzg2X0pNUF9TTE9UOgoJCQkqbG9jID0gdjsKCQkJYnJlYWs7CgoJCWNhc2UgUl8zODZfUkVMQVRJVkU6CgkJCSpsb2MgKz0gZi0+YmFzZWFkZHI7CgkJCWJyZWFrOwoKCQljYXNlIFJfMzg2X0dPVFBDOgoJCQkqbG9jICs9IGdvdCAtIGRvdDsKCQkJYnJlYWs7CgoJCWNhc2UgUl8zODZfR09UMzI6CgkJCWdvdG8gYmJfdXNlX2dvdDsKCQkJYnJlYWs7CgojZWxpZiBkZWZpbmVkKF9fbWljcm9ibGF6ZV9fKQoJCWNhc2UgUl9NSUNST0JMQVpFX05PTkU6CgkJY2FzZSBSX01JQ1JPQkxBWkVfNjRfTk9ORToKCQljYXNlIFJfTUlDUk9CTEFaRV8zMl9TWU1fT1BfU1lNOgoJCWNhc2UgUl9NSUNST0JMQVpFXzMyX1BDUkVMOgoJCQlicmVhazsKCgkJY2FzZSBSX01JQ1JPQkxBWkVfNjRfUENSRUw6IHsKCQkJLyogZG90IGlzIHRoZSBhZGRyZXNzIG9mIHRoZSBjdXJyZW50IGluc3RydWN0aW9uLgoJCQkgKiB2IGlzIHRoZSB0YXJnZXQgc3ltYm9sIGFkZHJlc3MuCgkJCSAqIFNvIHdlIG5lZWQgdG8gZXh0cmFjdCB0aGUgb2Zmc2V0IGluIHRoZSBjb2RlLAoJCQkgKiBhZGRpbmcgdiwgdGhlbiBzdWJ0cmF0aW5nIHRoZSBjdXJyZW50IGFkZHJlc3MKCQkJICogb2YgdGhpcyBpbnN0cnVjdGlvbi4KCQkJICogRXg6ICJJTU0gMHhGRkZFICBicmFsaWQgMHgwMDAwIiA9ICJicmFsaWQgMHhGRkZFMDAwMCIKCQkJICovCgoJCQkvKiBHZXQgc3BsaXQgb2Zmc2V0IHN0b3JlZCBpbiBjb2RlICovCgkJCXVuc2lnbmVkIGludCB0ZW1wID0gKGxvY1swXSAmIDB4RkZGRikgPDwgMTYgfAoJCQkJCQkobG9jWzFdICYgMHhGRkZGKTsKCgkJCS8qIEFkanVzdCByZWxhdGl2ZSBvZmZzZXQuIC00IGFkanVzdG1lbnQgcmVxdWlyZWQKCQkJICogYmVjYXVzZSBkb3QgcG9pbnRzIHRvIHRoZSBJTU0gaW5zbiwgYnV0IGJyYW5jaAoJCQkgKiBpcyBjb21wdXRlZCByZWxhdGl2ZSB0byB0aGUgYnJhbmNoIGluc3RydWN0aW9uIGl0c2VsZi4KCQkJICovCgkJCXRlbXAgKz0gdiAtIGRvdCAtIDQ7CgoJCQkvKiBTdG9yZSBiYWNrIGludG8gY29kZSAqLwoJCQlsb2NbMF0gPSAobG9jWzBdICYgMHhGRkZGMDAwMCkgfCB0ZW1wID4+IDE2OwoJCQlsb2NbMV0gPSAobG9jWzFdICYgMHhGRkZGMDAwMCkgfCAodGVtcCAmIDB4RkZGRik7CgoJCQlicmVhazsKCQl9CgoJCWNhc2UgUl9NSUNST0JMQVpFXzMyOgoJCQkqbG9jICs9IHY7CgkJCWJyZWFrOwoKCQljYXNlIFJfTUlDUk9CTEFaRV82NDogewoJCQkvKiBHZXQgc3BsaXQgcG9pbnRlciBzdG9yZWQgaW4gY29kZSAqLwoJCQl1bnNpZ25lZCBpbnQgdGVtcDEgPSAobG9jWzBdICYgMHhGRkZGKSA8PCAxNiB8CgkJCQkJCShsb2NbMV0gJiAweEZGRkYpOwoKCQkJLyogQWRkIHJlbG9jIG9mZnNldCAqLwoJCQl0ZW1wMSs9djsKCgkJCS8qIFN0b3JlIGJhY2sgaW50byBjb2RlICovCgkJCWxvY1swXSA9IChsb2NbMF0gJiAweEZGRkYwMDAwKSB8IHRlbXAxID4+IDE2OwoJCQlsb2NbMV0gPSAobG9jWzFdICYgMHhGRkZGMDAwMCkgfCAodGVtcDEgJiAweEZGRkYpOwoKCQkJYnJlYWs7CgkJfQoKCQljYXNlIFJfTUlDUk9CTEFaRV8zMl9QQ1JFTF9MTzoKCQljYXNlIFJfTUlDUk9CTEFaRV8zMl9MTzoKCQljYXNlIFJfTUlDUk9CTEFaRV9TUk8zMjoKCQljYXNlIFJfTUlDUk9CTEFaRV9TUlczMjoKCQkJcmV0ID0gb2JqX3JlbG9jX3VuaGFuZGxlZDsKCQkJYnJlYWs7CgojZWxpZiBkZWZpbmVkKF9fbWM2ODAwMF9fKQoKCQljYXNlIFJfNjhLX05PTkU6CgkJCWJyZWFrOwoKCQljYXNlIFJfNjhLXzMyOgoJCQkqbG9jICs9IHY7CgkJCWJyZWFrOwoKCQljYXNlIFJfNjhLXzg6CgkJCWlmICh2ID4gMHhmZikgewoJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQl9CgkJCSooY2hhciAqKWxvYyA9IHY7CgkJCWJyZWFrOwoKCQljYXNlIFJfNjhLXzE2OgoJCQlpZiAodiA+IDB4ZmZmZikgewoJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQl9CgkJCSooc2hvcnQgKilsb2MgPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSXzY4S19QQzg6CgkJCXYgLT0gZG90OwoJCQlpZiAoKEVsZlcoU3dvcmQpKXYgPiAweDdmCgkJCSB8fCAoRWxmVyhTd29yZCkpdiA8IC0oRWxmVyhTd29yZCkpMHg4MAoJCQkpIHsKCQkJCXJldCA9IG9ial9yZWxvY19vdmVyZmxvdzsKCQkJfQoJCQkqKGNoYXIgKilsb2MgPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSXzY4S19QQzE2OgoJCQl2IC09IGRvdDsKCQkJaWYgKChFbGZXKFN3b3JkKSl2ID4gMHg3ZmZmCgkJCSB8fCAoRWxmVyhTd29yZCkpdiA8IC0oRWxmVyhTd29yZCkpMHg4MDAwCgkJCSkgewoJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQl9CgkJCSooc2hvcnQgKilsb2MgPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSXzY4S19QQzMyOgoJCQkqKGludCAqKWxvYyA9IHYgLSBkb3Q7CgkJCWJyZWFrOwoKCQljYXNlIFJfNjhLX0dMT0JfREFUOgoJCWNhc2UgUl82OEtfSk1QX1NMT1Q6CgkJCSpsb2MgPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSXzY4S19SRUxBVElWRToKCQkJKihpbnQgKilsb2MgKz0gZi0+YmFzZWFkZHI7CgkJCWJyZWFrOwoKCQljYXNlIFJfNjhLX0dPVDMyOgoJCQlnb3RvIGJiX3VzZV9nb3Q7CgojIGlmZGVmIFJfNjhLX0dPVE9GRgoJCWNhc2UgUl82OEtfR09UT0ZGOgoJCQkqbG9jICs9IHYgLSBnb3Q7CgkJCWJyZWFrOwojIGVuZGlmCgojZWxpZiBkZWZpbmVkKF9fbWlwc19fKQoKCQljYXNlIFJfTUlQU19OT05FOgoJCQlicmVhazsKCgkJY2FzZSBSX01JUFNfMzI6CgkJCSpsb2MgKz0gdjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9NSVBTXzI2OgoJCQlpZiAodiAlIDQpCgkJCQlyZXQgPSBvYmpfcmVsb2NfZGFuZ2Vyb3VzOwoJCQlpZiAoKHYgJiAweGYwMDAwMDAwKSAhPSAoKGRvdCArIDQpICYgMHhmMDAwMDAwMCkpCgkJCQlyZXQgPSBvYmpfcmVsb2Nfb3ZlcmZsb3c7CgkJCSpsb2MgPQoJCQkJKCpsb2MgJiB+MHgwM2ZmZmZmZikgfCAoKCpsb2MgKyAodiA+PiAyKSkgJgoJCQkJCQkJCQkJMHgwM2ZmZmZmZik7CgkJCWJyZWFrOwoKCQljYXNlIFJfTUlQU19ISTE2OgoJCQl7CgkJCQlzdHJ1Y3QgbWlwc19oaTE2ICpuOwoKCQkJCS8qIFdlIGNhbm5vdCByZWxvY2F0ZSB0aGlzIG9uZSBub3cgYmVjYXVzZSB3ZSBkb24ndCBrbm93IHRoZSB2YWx1ZQoJCQkJICAgb2YgdGhlIGNhcnJ5IHdlIG5lZWQgdG8gYWRkLiAgU2F2ZSB0aGUgaW5mb3JtYXRpb24sIGFuZCBsZXQgTE8xNgoJCQkJICAgZG8gdGhlIGFjdHVhbCByZWxvY2F0aW9uLiAgKi8KCQkJCW4gPSB4bWFsbG9jKHNpemVvZiAqbik7CgkJCQluLT5hZGRyID0gbG9jOwoJCQkJbi0+dmFsdWUgPSB2OwoJCQkJbi0+bmV4dCA9IGlmaWxlLT5taXBzX2hpMTZfbGlzdDsKCQkJCWlmaWxlLT5taXBzX2hpMTZfbGlzdCA9IG47CgkJCQlicmVhazsKCQkJfQoKCQljYXNlIFJfTUlQU19MTzE2OgoJCQl7CgkJCQl1bnNpZ25lZCBsb25nIGluc25sbyA9ICpsb2M7CgkJCQlFbGZXKEFkZHIpIHZhbCwgdmFsbG87CgoJCQkJLyogU2lnbiBleHRlbmQgdGhlIGFkZGVuZCB3ZSBleHRyYWN0IGZyb20gdGhlIGxvIGluc24uICAqLwoJCQkJdmFsbG8gPSAoKGluc25sbyAmIDB4ZmZmZikgXiAweDgwMDApIC0gMHg4MDAwOwoKCQkJCWlmIChpZmlsZS0+bWlwc19oaTE2X2xpc3QgIT0gTlVMTCkgewoJCQkJCXN0cnVjdCBtaXBzX2hpMTYgKmw7CgoJCQkJCWwgPSBpZmlsZS0+bWlwc19oaTE2X2xpc3Q7CgkJCQkJd2hpbGUgKGwgIT0gTlVMTCkgewoJCQkJCQlzdHJ1Y3QgbWlwc19oaTE2ICpuZXh0OwoJCQkJCQl1bnNpZ25lZCBsb25nIGluc247CgoJCQkJCQkvKiBEbyB0aGUgSEkxNiByZWxvY2F0aW9uLiAgTm90ZSB0aGF0IHdlIGFjdHVhbGx5IGRvbid0CgkJCQkJCSAgIG5lZWQgdG8ga25vdyBhbnl0aGluZyBhYm91dCB0aGUgTE8xNiBpdHNlbGYsIGV4Y2VwdCB3aGVyZQoJCQkJCQkgICB0byBmaW5kIHRoZSBsb3cgMTYgYml0cyBvZiB0aGUgYWRkZW5kIG5lZWRlZCBieSB0aGUgTE8xNi4gICovCgkJCQkJCWluc24gPSAqbC0+YWRkcjsKCQkJCQkJdmFsID0KCQkJCQkJCSgoaW5zbiAmIDB4ZmZmZikgPDwgMTYpICsKCQkJCQkJCXZhbGxvOwoJCQkJCQl2YWwgKz0gdjsKCgkJCQkJCS8qIEFjY291bnQgZm9yIHRoZSBzaWduIGV4dGVuc2lvbiB0aGF0IHdpbGwgaGFwcGVuIGluIHRoZQoJCQkJCQkgICBsb3cgYml0cy4gICovCgkJCQkJCXZhbCA9CgkJCQkJCQkoKHZhbCA+PiAxNikgKwoJCQkJCQkJICgodmFsICYgMHg4MDAwKSAhPQoJCQkJCQkJICAwKSkgJiAweGZmZmY7CgoJCQkJCQlpbnNuID0gKGluc24gJiB+MHhmZmZmKSB8IHZhbDsKCQkJCQkJKmwtPmFkZHIgPSBpbnNuOwoKCQkJCQkJbmV4dCA9IGwtPm5leHQ7CgkJCQkJCWZyZWUobCk7CgkJCQkJCWwgPSBuZXh0OwoJCQkJCX0KCgkJCQkJaWZpbGUtPm1pcHNfaGkxNl9saXN0ID0gTlVMTDsKCQkJCX0KCgkJCQkvKiBPaywgd2UncmUgZG9uZSB3aXRoIHRoZSBISTE2IHJlbG9jcy4gIE5vdyBkZWFsIHdpdGggdGhlIExPMTYuICAqLwoJCQkJdmFsID0gdiArIHZhbGxvOwoJCQkJaW5zbmxvID0gKGluc25sbyAmIH4weGZmZmYpIHwgKHZhbCAmIDB4ZmZmZik7CgkJCQkqbG9jID0gaW5zbmxvOwoJCQkJYnJlYWs7CgkJCX0KCiNlbGlmIGRlZmluZWQoX19uaW9zMl9fKQoKCQljYXNlIFJfTklPUzJfTk9ORToKCQkJYnJlYWs7CgoJCWNhc2UgUl9OSU9TMl9CRkRfUkVMT0NfMzI6CgkJCSpsb2MgKz0gdjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9OSU9TMl9CRkRfUkVMT0NfMTY6CgkJCWlmICh2ID4gMHhmZmZmKSB7CgkJCQlyZXQgPSBvYmpfcmVsb2Nfb3ZlcmZsb3c7CgkJCX0KCQkJKihzaG9ydCAqKWxvYyA9IHY7CgkJCWJyZWFrOwoKCQljYXNlIFJfTklPUzJfQkZEX1JFTE9DXzg6CgkJCWlmICh2ID4gMHhmZikgewoJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQl9CgkJCSooY2hhciAqKWxvYyA9IHY7CgkJCWJyZWFrOwoKCQljYXNlIFJfTklPUzJfUzE2OgoJCQl7CgkJCQlFbGYzMl9BZGRyIHdvcmQ7CgoJCQkJaWYgKChFbGYzMl9Td29yZCl2ID4gMHg3ZmZmCgkJCQkgfHwgKEVsZjMyX1N3b3JkKXYgPCAtKEVsZjMyX1N3b3JkKTB4ODAwMAoJCQkJKSB7CgkJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQkJfQoKCQkJCXdvcmQgPSAqbG9jOwoJCQkJKmxvYyA9ICgoKCh3b3JkID4+IDIyKSA8PCAxNikgfCAodiAmIDB4ZmZmZikpIDw8IDYpIHwKCQkJCSAgICAgICAod29yZCAmIDB4M2YpOwoJCQl9CgkJCWJyZWFrOwoKCQljYXNlIFJfTklPUzJfVTE2OgoJCQl7CgkJCQlFbGYzMl9BZGRyIHdvcmQ7CgoJCQkJaWYgKHYgPiAweGZmZmYpIHsKCQkJCQlyZXQgPSBvYmpfcmVsb2Nfb3ZlcmZsb3c7CgkJCQl9CgoJCQkJd29yZCA9ICpsb2M7CgkJCQkqbG9jID0gKCgoKHdvcmQgPj4gMjIpIDw8IDE2KSB8ICh2ICYgMHhmZmZmKSkgPDwgNikgfAoJCQkJICAgICAgICh3b3JkICYgMHgzZik7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUl9OSU9TMl9QQ1JFTDE2OgoJCQl7CgkJCQlFbGYzMl9BZGRyIHdvcmQ7CgoJCQkJdiAtPSBkb3QgKyA0OwoJCQkJaWYgKChFbGYzMl9Td29yZCl2ID4gMHg3ZmZmCgkJCQkgfHwgKEVsZjMyX1N3b3JkKXYgPCAtKEVsZjMyX1N3b3JkKTB4ODAwMAoJCQkJKSB7CgkJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQkJfQoKCQkJCXdvcmQgPSAqbG9jOwoJCQkJKmxvYyA9ICgoKCh3b3JkID4+IDIyKSA8PCAxNikgfCAodiAmIDB4ZmZmZikpIDw8IDYpIHwgKHdvcmQgJiAweDNmKTsKCQkJfQoJCQlicmVhazsKCgkJY2FzZSBSX05JT1MyX0dQUkVMOgoJCQl7CgkJCQlFbGYzMl9BZGRyIHdvcmQsIGdwOwoJCQkJLyogZ2V0IF9ncCAqLwoJCQkJZ3AgPSBvYmpfc3ltYm9sX2ZpbmFsX3ZhbHVlKGYsIG9ial9maW5kX3N5bWJvbChmLCBTUEZYICJfZ3AiKSk7CgkJCQl2IC09IGdwOwoJCQkJaWYgKChFbGYzMl9Td29yZCl2ID4gMHg3ZmZmCgkJCQkgfHwgKEVsZjMyX1N3b3JkKXYgPCAtKEVsZjMyX1N3b3JkKTB4ODAwMAoJCQkJKSB7CgkJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQkJfQoKCQkJCXdvcmQgPSAqbG9jOwoJCQkJKmxvYyA9ICgoKCh3b3JkID4+IDIyKSA8PCAxNikgfCAodiAmIDB4ZmZmZikpIDw8IDYpIHwgKHdvcmQgJiAweDNmKTsKCQkJfQoJCQlicmVhazsKCgkJY2FzZSBSX05JT1MyX0NBTEwyNjoKCQkJaWYgKHYgJiAzKQoJCQkJcmV0ID0gb2JqX3JlbG9jX2Rhbmdlcm91czsKCQkJaWYgKCh2ID4+IDI4KSAhPSAoZG90ID4+IDI4KSkKCQkJCXJldCA9IG9ial9yZWxvY19vdmVyZmxvdzsKCQkJKmxvYyA9ICgqbG9jICYgMHgzZikgfCAoKHYgPj4gMikgPDwgNik7CgkJCWJyZWFrOwoKCQljYXNlIFJfTklPUzJfSU1NNToKCQkJewoJCQkJRWxmMzJfQWRkciB3b3JkOwoKCQkJCWlmICh2ID4gMHgxZikgewoJCQkJCXJldCA9IG9ial9yZWxvY19vdmVyZmxvdzsKCQkJCX0KCgkJCQl3b3JkID0gKmxvYyAmIH4weDdjMDsKCQkJCSpsb2MgPSB3b3JkIHwgKCh2ICYgMHgxZikgPDwgNik7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUl9OSU9TMl9JTU02OgoJCQl7CgkJCQlFbGYzMl9BZGRyIHdvcmQ7CgoJCQkJaWYgKHYgPiAweDNmKSB7CgkJCQkJcmV0ID0gb2JqX3JlbG9jX292ZXJmbG93OwoJCQkJfQoKCQkJCXdvcmQgPSAqbG9jICYgfjB4ZmMwOwoJCQkJKmxvYyA9IHdvcmQgfCAoKHYgJiAweDNmKSA8PCA2KTsKCQkJfQoJCQlicmVhazsKCgkJY2FzZSBSX05JT1MyX0lNTTg6CgkJCXsKCQkJCUVsZjMyX0FkZHIgd29yZDsKCgkJCQlpZiAodiA+IDB4ZmYpIHsKCQkJCQlyZXQgPSBvYmpfcmVsb2Nfb3ZlcmZsb3c7CgkJCQl9CgoJCQkJd29yZCA9ICpsb2MgJiB+MHgzZmMwOwoJCQkJKmxvYyA9IHdvcmQgfCAoKHYgJiAweGZmKSA8PCA2KTsKCQkJfQoJCQlicmVhazsKCgkJY2FzZSBSX05JT1MyX0hJMTY6CgkJCXsKCQkJCUVsZjMyX0FkZHIgd29yZDsKCgkJCQl3b3JkID0gKmxvYzsKCQkJCSpsb2MgPSAoKCgod29yZCA+PiAyMikgPDwgMTYpIHwgKCh2ID4+MTYpICYgMHhmZmZmKSkgPDwgNikgfAoJCQkJICAgICAgICh3b3JkICYgMHgzZik7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUl9OSU9TMl9MTzE2OgoJCQl7CgkJCQlFbGYzMl9BZGRyIHdvcmQ7CgoJCQkJd29yZCA9ICpsb2M7CgkJCQkqbG9jID0gKCgoKHdvcmQgPj4gMjIpIDw8IDE2KSB8ICh2ICYgMHhmZmZmKSkgPDwgNikgfAoJCQkJICAgICAgICh3b3JkICYgMHgzZik7CgkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgUl9OSU9TMl9ISUFESjE2OgoJCQl7CgkJCQlFbGYzMl9BZGRyIHdvcmQxLCB3b3JkMjsKCgkJCQl3b3JkMSA9ICpsb2M7CgkJCQl3b3JkMiA9ICgodiA+PiAxNikgKyAoKHYgPj4gMTUpICYgMSkpICYgMHhmZmZmOwoJCQkJKmxvYyA9ICgoKCh3b3JkMSA+PiAyMikgPDwgMTYpIHwgd29yZDIpIDw8IDYpIHwKCQkJCSAgICAgICAod29yZDEgJiAweDNmKTsKCQkJfQoJCQlicmVhazsKCiNlbGlmIGRlZmluZWQoX19wb3dlcnBjNjRfXykKCQkvKiBQUEM2NCBuZWVkcyBhIDIuNiBrZXJuZWwsIDIuNCBtb2R1bGUgcmVsb2NhdGlvbiBpcnJlbGV2YW50ICovCgojZWxpZiBkZWZpbmVkKF9fcG93ZXJwY19fKQoKCQljYXNlIFJfUFBDX0FERFIxNl9IQToKCQkJKih1bnNpZ25lZCBzaG9ydCAqKWxvYyA9ICh2ICsgMHg4MDAwKSA+PiAxNjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9QUENfQUREUjE2X0hJOgoJCQkqKHVuc2lnbmVkIHNob3J0ICopbG9jID0gdiA+PiAxNjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9QUENfQUREUjE2X0xPOgoJCQkqKHVuc2lnbmVkIHNob3J0ICopbG9jID0gdjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9QUENfUkVMMjQ6CgkJCWdvdG8gYmJfdXNlX3BsdDsKCgkJY2FzZSBSX1BQQ19SRUwzMjoKCQkJKmxvYyA9IHYgLSBkb3Q7CgkJCWJyZWFrOwoKCQljYXNlIFJfUFBDX0FERFIzMjoKCQkJKmxvYyA9IHY7CgkJCWJyZWFrOwoKI2VsaWYgZGVmaW5lZChfX3MzOTBfXykKCgkJY2FzZSBSXzM5MF8zMjoKCQkJKih1bnNpZ25lZCBpbnQgKikgbG9jICs9IHY7CgkJCWJyZWFrOwoJCWNhc2UgUl8zOTBfMTY6CgkJCSoodW5zaWduZWQgc2hvcnQgKikgbG9jICs9IHY7CgkJCWJyZWFrOwoJCWNhc2UgUl8zOTBfODoKCQkJKih1bnNpZ25lZCBjaGFyICopIGxvYyArPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSXzM5MF9QQzMyOgoJCQkqKHVuc2lnbmVkIGludCAqKSBsb2MgKz0gdiAtIGRvdDsKCQkJYnJlYWs7CgkJY2FzZSBSXzM5MF9QQzE2REJMOgoJCQkqKHVuc2lnbmVkIHNob3J0ICopIGxvYyArPSAodiAtIGRvdCkgPj4gMTsKCQkJYnJlYWs7CgkJY2FzZSBSXzM5MF9QQzE2OgoJCQkqKHVuc2lnbmVkIHNob3J0ICopIGxvYyArPSB2IC0gZG90OwoJCQlicmVhazsKCgkJY2FzZSBSXzM5MF9QTFQzMjoKCQljYXNlIFJfMzkwX1BMVDE2REJMOgoJCQkvKiBmaW5kIHRoZSBwbHQgZW50cnkgYW5kIGluaXRpYWxpemUgaXQuICAqLwoJCQlwZSA9IChzdHJ1Y3QgYXJjaF9zaW5nbGVfZW50cnkgKikgJmlzeW0tPnBsdGVudDsKCQkJaWYgKHBlLT5pbml0ZWQgPT0gMCkgewoJCQkJaXAgPSAodW5zaWduZWQgbG9uZyAqKShpZmlsZS0+cGx0LT5jb250ZW50cyArIHBlLT5vZmZzZXQpOwoJCQkJaXBbMF0gPSAweDBkMTA1ODEwOyAvKiBiYXNyIDEsMDsgbGcgMSwxMCgxKTsgYnIgMSAqLwoJCQkJaXBbMV0gPSAweDEwMDYwN2YxOwoJCQkJaWYgKEVMRl9SX1RZUEUocmVsLT5yX2luZm8pID09IFJfMzkwX1BMVDE2REJMKQoJCQkJCWlwWzJdID0gdiAtIDI7CgkJCQllbHNlCgkJCQkJaXBbMl0gPSB2OwoJCQkJcGUtPmluaXRlZCA9IDE7CgkJCX0KCgkJCS8qIEluc2VydCByZWxhdGl2ZSBkaXN0YW5jZSB0byB0YXJnZXQuICAqLwoJCQl2ID0gcGx0ICsgcGUtPm9mZnNldCAtIGRvdDsKCQkJaWYgKEVMRl9SX1RZUEUocmVsLT5yX2luZm8pID09IFJfMzkwX1BMVDMyKQoJCQkJKih1bnNpZ25lZCBpbnQgKikgbG9jID0gKHVuc2lnbmVkIGludCkgdjsKCQkJZWxzZSBpZiAoRUxGX1JfVFlQRShyZWwtPnJfaW5mbykgPT0gUl8zOTBfUExUMTZEQkwpCgkJCQkqKHVuc2lnbmVkIHNob3J0ICopIGxvYyA9ICh1bnNpZ25lZCBzaG9ydCkgKCh2ICsgMikgPj4gMSk7CgkJCWJyZWFrOwoKCQljYXNlIFJfMzkwX0dMT0JfREFUOgoJCWNhc2UgUl8zOTBfSk1QX1NMT1Q6CgkJCSpsb2MgPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSXzM5MF9SRUxBVElWRToKCQkJKmxvYyArPSBmLT5iYXNlYWRkcjsKCQkJYnJlYWs7CgoJCWNhc2UgUl8zOTBfR09UUEM6CgkJCSoodW5zaWduZWQgbG9uZyAqKSBsb2MgKz0gZ290IC0gZG90OwoJCQlicmVhazsKCgkJY2FzZSBSXzM5MF9HT1QxMjoKCQljYXNlIFJfMzkwX0dPVDE2OgoJCWNhc2UgUl8zOTBfR09UMzI6CgkJCWlmICghaXN5bS0+Z290ZW50LmluaXRlZCkKCQkJewoJCQkJaXN5bS0+Z290ZW50LmluaXRlZCA9IDE7CgkJCQkqKEVsZlcoQWRkcikgKikoaWZpbGUtPmdvdC0+Y29udGVudHMgKyBpc3ltLT5nb3RlbnQub2Zmc2V0KSA9IHY7CgkJCX0KCQkJaWYgKEVMRl9SX1RZUEUocmVsLT5yX2luZm8pID09IFJfMzkwX0dPVDEyKQoJCQkJKih1bnNpZ25lZCBzaG9ydCAqKSBsb2MgfD0gKCoodW5zaWduZWQgc2hvcnQgKikgbG9jICsgaXN5bS0+Z290ZW50Lm9mZnNldCkgJiAweGZmZjsKCQkJZWxzZSBpZiAoRUxGX1JfVFlQRShyZWwtPnJfaW5mbykgPT0gUl8zOTBfR09UMTYpCgkJCQkqKHVuc2lnbmVkIHNob3J0ICopIGxvYyArPSBpc3ltLT5nb3RlbnQub2Zmc2V0OwoJCQllbHNlIGlmIChFTEZfUl9UWVBFKHJlbC0+cl9pbmZvKSA9PSBSXzM5MF9HT1QzMikKCQkJCSoodW5zaWduZWQgaW50ICopIGxvYyArPSBpc3ltLT5nb3RlbnQub2Zmc2V0OwoJCQlicmVhazsKCiMgaWZuZGVmIFJfMzkwX0dPVE9GRjMyCiMgIGRlZmluZSBSXzM5MF9HT1RPRkYzMiBSXzM5MF9HT1RPRkYKIyBlbmRpZgoJCWNhc2UgUl8zOTBfR09UT0ZGMzI6CgkJCSpsb2MgKz0gdiAtIGdvdDsKCQkJYnJlYWs7CgojZWxpZiBkZWZpbmVkKF9fc2hfXykKCgkJY2FzZSBSX1NIX05PTkU6CgkJCWJyZWFrOwoKCQljYXNlIFJfU0hfRElSMzI6CgkJCSpsb2MgKz0gdjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9TSF9SRUwzMjoKCQkJKmxvYyArPSB2IC0gZG90OwoJCQlicmVhazsKCgkJY2FzZSBSX1NIX1BMVDMyOgoJCQkqbG9jID0gdiAtIGRvdDsKCQkJYnJlYWs7CgoJCWNhc2UgUl9TSF9HTE9CX0RBVDoKCQljYXNlIFJfU0hfSk1QX1NMT1Q6CgkJCSpsb2MgPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSX1NIX1JFTEFUSVZFOgoJCQkqbG9jID0gZi0+YmFzZWFkZHIgKyByZWwtPnJfYWRkZW5kOwoJCQlicmVhazsKCgkJY2FzZSBSX1NIX0dPVFBDOgoJCQkqbG9jID0gZ290IC0gZG90ICsgcmVsLT5yX2FkZGVuZDsKCQkJYnJlYWs7CgoJCWNhc2UgUl9TSF9HT1QzMjoKCQkJZ290byBiYl91c2VfZ290OwoKCQljYXNlIFJfU0hfR09UT0ZGOgoJCQkqbG9jID0gdiAtIGdvdDsKCQkJYnJlYWs7CgojIGlmIGRlZmluZWQoX19TSDVfXykKCQljYXNlIFJfU0hfSU1NX01FRExPVzE2OgoJCWNhc2UgUl9TSF9JTU1fTE9XMTY6CgkJCXsKCQkJCUVsZlcoQWRkcikgd29yZDsKCgkJCQlpZiAoRUxGX1JfVFlQRShyZWwtPnJfaW5mbykgPT0gUl9TSF9JTU1fTUVETE9XMTYpCgkJCQkJdiA+Pj0gMTY7CgoJCQkJLyoKCQkJCSAqICBtb3ZpIGFuZCBzaG9yaSBoYXZlIHRoZSBmb3JtYXQ6CgkJCQkgKgoJCQkJICogIHwgIG9wICB8IGltbSAgfCByZWcgfCByZXNlcnZlZCB8CgkJCQkgKiAgIDMxLi4yNiAyNS4uMTAgOS4uIDQgMyAgIC4uICAgMAoJCQkJICoKCQkJCSAqIHNvIHdlIHNpbXBseSBtYXNrIGFuZCBvciBpbiBpbW0uCgkJCQkgKi8KCQkJCXdvcmQgPSAqbG9jICYgfjB4M2ZmZmMwMDsKCQkJCXdvcmQgfD0gKHYgJiAweGZmZmYpIDw8IDEwOwoKCQkJCSpsb2MgPSB3b3JkOwoKCQkJCWJyZWFrOwoJCQl9CgoJCWNhc2UgUl9TSF9JTU1fTUVETE9XMTZfUENSRUw6CgkJY2FzZSBSX1NIX0lNTV9MT1cxNl9QQ1JFTDoKCQkJewoJCQkJRWxmVyhBZGRyKSB3b3JkOwoKCQkJCXdvcmQgPSAqbG9jICYgfjB4M2ZmZmMwMDsKCgkJCQl2IC09IGRvdDsKCgkJCQlpZiAoRUxGX1JfVFlQRShyZWwtPnJfaW5mbykgPT0gUl9TSF9JTU1fTUVETE9XMTZfUENSRUwpCgkJCQkJdiA+Pj0gMTY7CgoJCQkJd29yZCB8PSAodiAmIDB4ZmZmZikgPDwgMTA7CgoJCQkJKmxvYyA9IHdvcmQ7CgoJCQkJYnJlYWs7CgkJCX0KIyBlbmRpZiAvKiBfX1NINV9fICovCgojZWxpZiBkZWZpbmVkKF9fdjg1MGVfXykKCgkJY2FzZSBSX1Y4NTBfTk9ORToKCQkJYnJlYWs7CgoJCWNhc2UgUl9WODUwXzMyOgoJCQkvKiBXZSB3cml0ZSB0d28gc2hvcnRzIGluc3RlYWQgb2YgYSBsb25nIGJlY2F1c2UgZXZlbgoJCQkgICAzMi1iaXQgaW5zbnMgb25seSBuZWVkIGhhbGYtd29yZCBhbGlnbm1lbnQsIGJ1dAoJCQkgICAzMi1iaXQgZGF0YSBuZWVkcyB0byBiZSBsb25nLXdvcmQgYWxpZ25lZC4gICovCgkJCXYgKz0gKCh1bnNpZ25lZCBzaG9ydCAqKWxvYylbMF07CgkJCXYgKz0gKCh1bnNpZ25lZCBzaG9ydCAqKWxvYylbMV0gPDwgMTY7CgkJCSgodW5zaWduZWQgc2hvcnQgKilsb2MpWzBdID0gdiAmIDB4ZmZmZjsKCQkJKCh1bnNpZ25lZCBzaG9ydCAqKWxvYylbMV0gPSAodiA+PiAxNikgJiAweGZmZmY7CgkJCWJyZWFrOwoKCQljYXNlIFJfVjg1MF8yMl9QQ1JFTDoKCQkJZ290byBiYl91c2VfcGx0OwoKI2VsaWYgZGVmaW5lZChfX3g4Nl82NF9fKQoKCQljYXNlIFJfWDg2XzY0X05PTkU6CgkJCWJyZWFrOwoKCQljYXNlIFJfWDg2XzY0XzY0OgoJCQkqbG9jICs9IHY7CgkJCWJyZWFrOwoKCQljYXNlIFJfWDg2XzY0XzMyOgoJCQkqKHVuc2lnbmVkIGludCAqKSBsb2MgKz0gdjsKCQkJaWYgKHYgPiAweGZmZmZmZmZmKQoJCQl7CgkJCQlyZXQgPSBvYmpfcmVsb2Nfb3ZlcmZsb3c7IC8qIEtlcm5lbCBtb2R1bGUgY29tcGlsZWQgd2l0aG91dCAtbWNtb2RlbD1rZXJuZWwuICovCgkJCQkvKiBlcnJvcigiUG9zc2libHkgaXMgbW9kdWxlIGNvbXBpbGVkIHdpdGhvdXQgLW1jbW9kZWw9a2VybmVsISIpOyAqLwoJCQl9CgkJCWJyZWFrOwoKCQljYXNlIFJfWDg2XzY0XzMyUzoKCQkJKihzaWduZWQgaW50ICopIGxvYyArPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSX1g4Nl82NF8xNjoKCQkJKih1bnNpZ25lZCBzaG9ydCAqKSBsb2MgKz0gdjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9YODZfNjRfODoKCQkJKih1bnNpZ25lZCBjaGFyICopIGxvYyArPSB2OwoJCQlicmVhazsKCgkJY2FzZSBSX1g4Nl82NF9QQzMyOgoJCQkqKHVuc2lnbmVkIGludCAqKSBsb2MgKz0gdiAtIGRvdDsKCQkJYnJlYWs7CgoJCWNhc2UgUl9YODZfNjRfUEMxNjoKCQkJKih1bnNpZ25lZCBzaG9ydCAqKSBsb2MgKz0gdiAtIGRvdDsKCQkJYnJlYWs7CgoJCWNhc2UgUl9YODZfNjRfUEM4OgoJCQkqKHVuc2lnbmVkIGNoYXIgKikgbG9jICs9IHYgLSBkb3Q7CgkJCWJyZWFrOwoKCQljYXNlIFJfWDg2XzY0X0dMT0JfREFUOgoJCWNhc2UgUl9YODZfNjRfSlVNUF9TTE9UOgoJCQkqbG9jID0gdjsKCQkJYnJlYWs7CgoJCWNhc2UgUl9YODZfNjRfUkVMQVRJVkU6CgkJCSpsb2MgKz0gZi0+YmFzZWFkZHI7CgkJCWJyZWFrOwoKCQljYXNlIFJfWDg2XzY0X0dPVDMyOgoJCWNhc2UgUl9YODZfNjRfR09UUENSRUw6CgkJCWdvdG8gYmJfdXNlX2dvdDsKIyBpZiAwCgkJCWlmICghaXN5bS0+Z290ZW50LnJlbG9jX2RvbmUpCgkJCXsKCQkJCWlzeW0tPmdvdGVudC5yZWxvY19kb25lID0gMTsKCQkJCSooRWxmNjRfQWRkciAqKShpZmlsZS0+Z290LT5jb250ZW50cyArIGlzeW0tPmdvdGVudC5vZmZzZXQpID0gdjsKCQkJfQoJCQkvKiBYWFggYXJlIHRoZXNlIHJlYWxseSBjb3JyZWN0PyAgKi8KCQkJaWYgKEVMRjY0X1JfVFlQRShyZWwtPnJfaW5mbykgPT0gUl9YODZfNjRfR09UUENSRUwpCgkJCQkqKHVuc2lnbmVkIGludCAqKSBsb2MgKz0gdiArIGlzeW0tPmdvdGVudC5vZmZzZXQ7CgkJCWVsc2UKCQkJCSpsb2MgKz0gaXN5bS0+Z290ZW50Lm9mZnNldDsKCQkJYnJlYWs7CiMgZW5kaWYKCiNlbHNlCiMgd2FybmluZyAibm8gaWRlYSBob3cgdG8gaGFuZGxlIHJlbG9jYXRpb25zIG9uIHlvdXIgYXJjaCIKI2VuZGlmCgoJCWRlZmF1bHQ6CgkJCXByaW50ZigiV2FybmluZzogdW5oYW5kbGVkIHJlbG9jICVkXG4iLCAoaW50KUVMRl9SX1RZUEUocmVsLT5yX2luZm8pKTsKCQkJcmV0ID0gb2JqX3JlbG9jX3VuaGFuZGxlZDsKCQkJYnJlYWs7CgojaWYgZGVmaW5lZChVU0VfUExUX0VOVFJJRVMpCgpiYl91c2VfcGx0OgoKCQkJLyogZmluZCB0aGUgcGx0IGVudHJ5IGFuZCBpbml0aWFsaXplIGl0IGlmIG5lY2Vzc2FyeSAqLwoKI2lmIGRlZmluZWQoVVNFX1BMVF9MSVNUKQoJCQlmb3IgKHBlID0gaXN5bS0+cGx0ZW50OyBwZSAhPSBOVUxMICYmIHBlLT5hZGRlbmQgIT0gcmVsLT5yX2FkZGVuZDspCgkJCQlwZSA9IHBlLT5uZXh0OwojZWxzZQoJCQlwZSA9ICZpc3ltLT5wbHRlbnQ7CiNlbmRpZgoKCQkJaWYgKCEgcGUtPmluaXRlZCkgewoJCQkJaXAgPSAodW5zaWduZWQgbG9uZyAqKSAoaWZpbGUtPnBsdC0+Y29udGVudHMgKyBwZS0+b2Zmc2V0KTsKCgkJCQkvKiBnZW5lcmF0ZSBzb21lIG1hY2hpbmUgY29kZSAqLwoKI2lmIGRlZmluZWQoX19hcm1fXykKCQkJCWlwWzBdID0gMHhlNTFmZjAwNDsJCQkvKiBsZHIgcGMsW3BjLCMtNF0gKi8KCQkJCWlwWzFdID0gdjsJCQkJLyogc3ltQCAqLwojZW5kaWYKI2lmIGRlZmluZWQoX19wb3dlcnBjX18pCgkJCQlpcFswXSA9IDB4M2Q2MDAwMDAgKyAoKHYgKyAweDgwMDApID4+IDE2KTsgIC8qIGxpcyByMTEsc3ltQGhhICovCgkJCQlpcFsxXSA9IDB4Mzk2YjAwMDAgKyAodiAmIDB4ZmZmZik7ICAgICAgICAgIC8qIGFkZGkgcjExLHIxMSxzeW1AbCAqLwoJCQkJaXBbMl0gPSAweDdkNjkwM2E2OwkJCSAgICAgIC8qIG10Y3RyIHIxMSAqLwoJCQkJaXBbM10gPSAweDRlODAwNDIwOwkJCSAgICAgIC8qIGJjdHIgKi8KI2VuZGlmCiNpZiBkZWZpbmVkKF9fdjg1MGVfXykKCQkJCS8qIFdlIGhhdmUgdG8gdHJhc2ggYSByZWdpc3Rlciwgc28gd2UgYXNzdW1lIHRoYXQgYW55IGNvbnRyb2wKCQkJCSAgIHRyYW5zZmVyIG1vcmUgdGhhbiAyMS1iaXRzIGF3YXkgbXVzdCBiZSBhIGZ1bmN0aW9uIGNhbGwKCQkJCSAgIChzbyB3ZSBjYW4gdXNlIGEgY2FsbC1jbG9iYmVyZWQgcmVnaXN0ZXIpLiAgKi8KCQkJCWlwWzBdID0gMHgwNjIxICsgKCh2ICYgMHhmZmZmKSA8PCAxNik7ICAgLyogbW92IHN5bSwgcjEgLi4uICovCgkJCQlpcFsxXSA9ICgodiA+PiAxNikgJiAweGZmZmYpICsgMHg2MTAwMDA7IC8qIC4uLjsgam1wIHIxICovCiNlbmRpZgoJCQkJcGUtPmluaXRlZCA9IDE7CgkJCX0KCgkJCS8qIHJlbGF0aXZlIGRpc3RhbmNlIHRvIHRhcmdldCAqLwoJCQl2IC09IGRvdDsKCQkJLyogaWYgdGhlIHRhcmdldCBpcyB0b28gZmFyIGF3YXkuLi4uICovCiNpZiBkZWZpbmVkKF9fYXJtX18pIHx8IGRlZmluZWQoX19wb3dlcnBjX18pCgkJCWlmICgoaW50KXYgPCAtMHgwMjAwMDAwMCB8fCAoaW50KXYgPj0gMHgwMjAwMDAwMCkKI2VsaWYgZGVmaW5lZChfX3Y4NTBlX18pCgkJCQlpZiAoKEVsZlcoU3dvcmQpKXYgPiAweDFmZmZmZiB8fCAoRWxmVyhTd29yZCkpdiA8IChFbGZXKFN3b3JkKSktMHgyMDAwMDApCiNlbmRpZgoJCQkJCS8qIGdvIHZpYSB0aGUgcGx0ICovCgkJCQkJdiA9IHBsdCArIHBlLT5vZmZzZXQgLSBkb3Q7CgojaWYgZGVmaW5lZChfX3Y4NTBlX18pCgkJCWlmICh2ICYgMSkKI2Vsc2UKCQkJCWlmICh2ICYgMykKI2VuZGlmCgkJCQkJcmV0ID0gb2JqX3JlbG9jX2Rhbmdlcm91czsKCgkJCS8qIG1lcmdlIHRoZSBvZmZzZXQgaW50byB0aGUgaW5zdHJ1Y3Rpb24uICovCiNpZiBkZWZpbmVkKF9fYXJtX18pCgkJCS8qIENvbnZlcnQgdG8gd29yZHMuICovCgkJCXYgPj49IDI7CgoJCQkqbG9jID0gKCpsb2MgJiB+MHgwMGZmZmZmZikgfCAoKHYgKyAqbG9jKSAmIDB4MDBmZmZmZmYpOwojZW5kaWYKI2lmIGRlZmluZWQoX19wb3dlcnBjX18pCgkJCSpsb2MgPSAoKmxvYyAmIH4weDAzZmZmZmZjKSB8ICh2ICYgMHgwM2ZmZmZmYyk7CiNlbmRpZgojaWYgZGVmaW5lZChfX3Y4NTBlX18pCgkJCS8qIFdlIHdyaXRlIHR3byBzaG9ydHMgaW5zdGVhZCBvZiBhIGxvbmcgYmVjYXVzZSBldmVuIDMyLWJpdCBpbnNucwoJCQkgICBvbmx5IG5lZWQgaGFsZi13b3JkIGFsaWdubWVudCwgYnV0IHRoZSAzMi1iaXQgZGF0YSB3cml0ZSBuZWVkcwoJCQkgICB0byBiZSBsb25nLXdvcmQgYWxpZ25lZC4gICovCgkJCSgodW5zaWduZWQgc2hvcnQgKilsb2MpWzBdID0KCQkJCSgqKHVuc2lnbmVkIHNob3J0ICopbG9jICYgMHhmZmMwKSAvKiBvcGNvZGUgKyByZWcgKi8KCQkJCXwgKCh2ID4+IDE2KSAmIDB4M2YpOyAgICAgICAgICAgICAvKiBvZmZzIGhpZ2ggcGFydCAqLwoJCQkoKHVuc2lnbmVkIHNob3J0ICopbG9jKVsxXSA9CgkJCQkodiAmIDB4ZmZmZik7ICAgICAgICAgICAgICAgICAgICAvKiBvZmZzIGxvdyBwYXJ0ICovCiNlbmRpZgoJCQlicmVhazsKI2VuZGlmIC8qIFVTRV9QTFRfRU5UUklFUyAqLwoKI2lmIGRlZmluZWQoVVNFX0dPVF9FTlRSSUVTKQpiYl91c2VfZ290OgoKCQkJLyogbmVlZHMgYW4gZW50cnkgaW4gdGhlIC5nb3Q6IHNldCBpdCwgb25jZSAqLwoJCQlpZiAoIWlzeW0tPmdvdGVudC5pbml0ZWQpIHsKCQkJCWlzeW0tPmdvdGVudC5pbml0ZWQgPSAxOwoJCQkJKihFbGZXKEFkZHIpICopIChpZmlsZS0+Z290LT5jb250ZW50cyArIGlzeW0tPmdvdGVudC5vZmZzZXQpID0gdjsKCQkJfQoJCQkvKiBtYWtlIHRoZSByZWxvYyB3aXRoX3Jlc3BlY3RfdG9fLmdvdCAqLwojaWYgZGVmaW5lZChfX3NoX18pCgkJCSpsb2MgKz0gaXN5bS0+Z290ZW50Lm9mZnNldCArIHJlbC0+cl9hZGRlbmQ7CiNlbGlmIGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX19hcm1fXykgfHwgZGVmaW5lZChfX21jNjgwMDBfXykKCQkJKmxvYyArPSBpc3ltLT5nb3RlbnQub2Zmc2V0OwojZW5kaWYKCQkJYnJlYWs7CgojZW5kaWYgLyogVVNFX0dPVF9FTlRSSUVTICovCgl9CgoJcmV0dXJuIHJldDsKfQoKCiNpZiBkZWZpbmVkKFVTRV9MSVNUKQoKc3RhdGljIGludCBhcmNoX2xpc3RfYWRkKEVsZlcoUmVsTSkgKnJlbCwgc3RydWN0IGFyY2hfbGlzdF9lbnRyeSAqKmxpc3QsCgkJCSAgaW50IG9mZnNldCwgaW50IHNpemUpCnsKCXN0cnVjdCBhcmNoX2xpc3RfZW50cnkgKnBlOwoKCWZvciAocGUgPSAqbGlzdDsgcGUgIT0gTlVMTDsgcGUgPSBwZS0+bmV4dCkgewoJCWlmIChwZS0+YWRkZW5kID09IHJlbC0+cl9hZGRlbmQpIHsKCQkJYnJlYWs7CgkJfQoJfQoKCWlmIChwZSA9PSBOVUxMKSB7CgkJcGUgPSB4emFsbG9jKHNpemVvZihzdHJ1Y3QgYXJjaF9saXN0X2VudHJ5KSk7CgkJcGUtPm5leHQgPSAqbGlzdDsKCQlwZS0+YWRkZW5kID0gcmVsLT5yX2FkZGVuZDsKCQlwZS0+b2Zmc2V0ID0gb2Zmc2V0OwoJCS8qcGUtPmluaXRlZCA9IDA7Ki8KCQkqbGlzdCA9IHBlOwoJCXJldHVybiBzaXplOwoJfQoJcmV0dXJuIDA7Cn0KCiNlbmRpZgoKI2lmIGRlZmluZWQoVVNFX1NJTkdMRSkKCnN0YXRpYyBpbnQgYXJjaF9zaW5nbGVfaW5pdCgvKkVsZlcoUmVsTSkgKnJlbCwqLyBzdHJ1Y3QgYXJjaF9zaW5nbGVfZW50cnkgKnNpbmdsZSwKCQlpbnQgb2Zmc2V0LCBpbnQgc2l6ZSkKewoJaWYgKHNpbmdsZS0+YWxsb2NhdGVkID09IDApIHsKCQlzaW5nbGUtPmFsbG9jYXRlZCA9IDE7CgkJc2luZ2xlLT5vZmZzZXQgPSBvZmZzZXQ7CgkJc2luZ2xlLT5pbml0ZWQgPSAwOwoJCXJldHVybiBzaXplOwoJfQoJcmV0dXJuIDA7Cn0KCiNlbmRpZgoKI2lmIGRlZmluZWQoVVNFX0dPVF9FTlRSSUVTKSB8fCBkZWZpbmVkKFVTRV9QTFRfRU5UUklFUykKCnN0YXRpYyBzdHJ1Y3Qgb2JqX3NlY3Rpb24gKmFyY2hfeHNlY3RfaW5pdChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIGNvbnN0IGNoYXIgKm5hbWUsCgkJaW50IG9mZnNldCwgaW50IHNpemUpCnsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqbXlyZWxzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsIG5hbWUpOwoKCWlmIChvZmZzZXQgPT0gMCkgewoJCW9mZnNldCArPSBzaXplOwoJfQoKCWlmIChteXJlbHNlYykgewoJCW9ial9leHRlbmRfc2VjdGlvbihteXJlbHNlYywgb2Zmc2V0KTsKCX0gZWxzZSB7CgkJbXlyZWxzZWMgPSBvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbihmLCBuYW1lLAoJCQkJc2l6ZSwgb2Zmc2V0KTsKCX0KCglyZXR1cm4gbXlyZWxzZWM7Cn0KCiNlbmRpZgoKc3RhdGljIHZvaWQgYXJjaF9jcmVhdGVfZ290KHN0cnVjdCBvYmpfZmlsZSAqZikKewojaWYgZGVmaW5lZChVU0VfR09UX0VOVFJJRVMpIHx8IGRlZmluZWQoVVNFX1BMVF9FTlRSSUVTKQoJc3RydWN0IGFyY2hfZmlsZSAqaWZpbGUgPSAoc3RydWN0IGFyY2hfZmlsZSAqKSBmOwoJaW50IGk7CiNpZiBkZWZpbmVkKFVTRV9HT1RfRU5UUklFUykKCWludCBnb3Rfb2Zmc2V0ID0gMCwgZ290X25lZWRlZCA9IDAsIGdvdF9hbGxvY2F0ZTsKI2VuZGlmCiNpZiBkZWZpbmVkKFVTRV9QTFRfRU5UUklFUykKCWludCBwbHRfb2Zmc2V0ID0gMCwgcGx0X25lZWRlZCA9IDAsIHBsdF9hbGxvY2F0ZTsKI2VuZGlmCglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnJlbHNlYywgKnN5bXNlYywgKnN0cnNlYzsKCUVsZlcoUmVsTSkgKnJlbCwgKnJlbGVuZDsKCUVsZlcoU3ltKSAqc3ltdGFiLCAqZXh0c3ltOwoJY29uc3QgY2hhciAqc3RydGFiLCAqbmFtZTsKCXN0cnVjdCBhcmNoX3N5bWJvbCAqaW50c3ltOwoKCWZvciAoaSA9IDA7IGkgPCBmLT5oZWFkZXIuZV9zaG51bTsgKytpKSB7CgkJcmVsc2VjID0gZi0+c2VjdGlvbnNbaV07CgkJaWYgKHJlbHNlYy0+aGVhZGVyLnNoX3R5cGUgIT0gU0hUX1JFTE0pCgkJCWNvbnRpbnVlOwoKCQlzeW1zZWMgPSBmLT5zZWN0aW9uc1tyZWxzZWMtPmhlYWRlci5zaF9saW5rXTsKCQlzdHJzZWMgPSBmLT5zZWN0aW9uc1tzeW1zZWMtPmhlYWRlci5zaF9saW5rXTsKCgkJcmVsID0gKEVsZlcoUmVsTSkgKikgcmVsc2VjLT5jb250ZW50czsKCQlyZWxlbmQgPSByZWwgKyAocmVsc2VjLT5oZWFkZXIuc2hfc2l6ZSAvIHNpemVvZihFbGZXKFJlbE0pKSk7CgkJc3ltdGFiID0gKEVsZlcoU3ltKSAqKSBzeW1zZWMtPmNvbnRlbnRzOwoJCXN0cnRhYiA9IChjb25zdCBjaGFyICopIHN0cnNlYy0+Y29udGVudHM7CgoJCWZvciAoOyByZWwgPCByZWxlbmQ7ICsrcmVsKSB7CgkJCWV4dHN5bSA9ICZzeW10YWJbRUxGX1JfU1lNKHJlbC0+cl9pbmZvKV07CgojaWYgZGVmaW5lZChVU0VfR09UX0VOVFJJRVMpCgkJCWdvdF9hbGxvY2F0ZSA9IDA7CiNlbmRpZgojaWYgZGVmaW5lZChVU0VfUExUX0VOVFJJRVMpCgkJCXBsdF9hbGxvY2F0ZSA9IDA7CiNlbmRpZgoKCQkJc3dpdGNoIChFTEZfUl9UWVBFKHJlbC0+cl9pbmZvKSkgewojaWYgZGVmaW5lZChfX2FybV9fKQoJCQljYXNlIFJfQVJNX1BDMjQ6CgkJCWNhc2UgUl9BUk1fUExUMzI6CgkJCQlwbHRfYWxsb2NhdGUgPSAxOwoJCQkJYnJlYWs7CgoJCQljYXNlIFJfQVJNX0dPVE9GRjoKCQkJY2FzZSBSX0FSTV9HT1RQQzoKCQkJCWdvdF9uZWVkZWQgPSAxOwoJCQkJY29udGludWU7CgoJCQljYXNlIFJfQVJNX0dPVDMyOgoJCQkJZ290X2FsbG9jYXRlID0gMTsKCQkJCWJyZWFrOwoKI2VsaWYgZGVmaW5lZChfX2kzODZfXykKCQkJY2FzZSBSXzM4Nl9HT1RQQzoKCQkJY2FzZSBSXzM4Nl9HT1RPRkY6CgkJCQlnb3RfbmVlZGVkID0gMTsKCQkJCWNvbnRpbnVlOwoKCQkJY2FzZSBSXzM4Nl9HT1QzMjoKCQkJCWdvdF9hbGxvY2F0ZSA9IDE7CgkJCQlicmVhazsKCiNlbGlmIGRlZmluZWQoX19wb3dlcnBjX18pCgkJCWNhc2UgUl9QUENfUkVMMjQ6CgkJCQlwbHRfYWxsb2NhdGUgPSAxOwoJCQkJYnJlYWs7CgojZWxpZiBkZWZpbmVkKF9fbWM2ODAwMF9fKQoJCQljYXNlIFJfNjhLX0dPVDMyOgoJCQkJZ290X2FsbG9jYXRlID0gMTsKCQkJCWJyZWFrOwoKI2lmZGVmIFJfNjhLX0dPVE9GRgoJCQljYXNlIFJfNjhLX0dPVE9GRjoKCQkJCWdvdF9uZWVkZWQgPSAxOwoJCQkJY29udGludWU7CiNlbmRpZgoKI2VsaWYgZGVmaW5lZChfX3NoX18pCgkJCWNhc2UgUl9TSF9HT1QzMjoKCQkJCWdvdF9hbGxvY2F0ZSA9IDE7CgkJCQlicmVhazsKCgkJCWNhc2UgUl9TSF9HT1RQQzoKCQkJY2FzZSBSX1NIX0dPVE9GRjoKCQkJCWdvdF9uZWVkZWQgPSAxOwoJCQkJY29udGludWU7CgojZWxpZiBkZWZpbmVkKF9fdjg1MGVfXykKCQkJY2FzZSBSX1Y4NTBfMjJfUENSRUw6CgkJCQlwbHRfbmVlZGVkID0gMTsKCQkJCWJyZWFrOwoKI2VuZGlmCgkJCWRlZmF1bHQ6CgkJCQljb250aW51ZTsKCQkJfQoKCQkJaWYgKGV4dHN5bS0+c3RfbmFtZSAhPSAwKSB7CgkJCQluYW1lID0gc3RydGFiICsgZXh0c3ltLT5zdF9uYW1lOwoJCQl9IGVsc2UgewoJCQkJbmFtZSA9IGYtPnNlY3Rpb25zW2V4dHN5bS0+c3Rfc2huZHhdLT5uYW1lOwoJCQl9CgkJCWludHN5bSA9IChzdHJ1Y3QgYXJjaF9zeW1ib2wgKikgb2JqX2ZpbmRfc3ltYm9sKGYsIG5hbWUpOwojaWYgZGVmaW5lZChVU0VfR09UX0VOVFJJRVMpCgkJCWlmIChnb3RfYWxsb2NhdGUpIHsKCQkJCWdvdF9vZmZzZXQgKz0gYXJjaF9zaW5nbGVfaW5pdCgKCQkJCQkJLypyZWwsKi8gJmludHN5bS0+Z290ZW50LAoJCQkJCQlnb3Rfb2Zmc2V0LCBHT1RfRU5UUllfU0laRSk7CgoJCQkJZ290X25lZWRlZCA9IDE7CgkJCX0KI2VuZGlmCiNpZiBkZWZpbmVkKFVTRV9QTFRfRU5UUklFUykKCQkJaWYgKHBsdF9hbGxvY2F0ZSkgewojaWYgZGVmaW5lZChVU0VfUExUX0xJU1QpCgkJCQlwbHRfb2Zmc2V0ICs9IGFyY2hfbGlzdF9hZGQoCgkJCQkJCXJlbCwgJmludHN5bS0+cGx0ZW50LAoJCQkJCQlwbHRfb2Zmc2V0LCBQTFRfRU5UUllfU0laRSk7CiNlbHNlCgkJCQlwbHRfb2Zmc2V0ICs9IGFyY2hfc2luZ2xlX2luaXQoCgkJCQkJCS8qcmVsLCovICZpbnRzeW0tPnBsdGVudCwKCQkJCQkJcGx0X29mZnNldCwgUExUX0VOVFJZX1NJWkUpOwojZW5kaWYKCQkJCXBsdF9uZWVkZWQgPSAxOwoJCQl9CiNlbmRpZgoJCX0KCX0KCiNpZiBkZWZpbmVkKFVTRV9HT1RfRU5UUklFUykKCWlmIChnb3RfbmVlZGVkKSB7CgkJaWZpbGUtPmdvdCA9IGFyY2hfeHNlY3RfaW5pdChmLCAiLmdvdCIsIGdvdF9vZmZzZXQsCgkJCQlHT1RfRU5UUllfU0laRSk7Cgl9CiNlbmRpZgoKI2lmIGRlZmluZWQoVVNFX1BMVF9FTlRSSUVTKQoJaWYgKHBsdF9uZWVkZWQpIHsKCQlpZmlsZS0+cGx0ID0gYXJjaF94c2VjdF9pbml0KGYsICIucGx0IiwgcGx0X29mZnNldCwKCQkJCVBMVF9FTlRSWV9TSVpFKTsKCX0KI2VuZGlmCgojZW5kaWYgLyogZGVmaW5lZChVU0VfR09UX0VOVFJJRVMpIHx8IGRlZmluZWQoVVNFX1BMVF9FTlRSSUVTKSAqLwp9CgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwoKLyogU3RhbmRhcmQgRUxGIGhhc2ggZnVuY3Rpb24uICAqLwpzdGF0aWMgdW5zaWduZWQgbG9uZyBvYmpfZWxmX2hhc2hfbihjb25zdCBjaGFyICpuYW1lLCB1bnNpZ25lZCBsb25nIG4pCnsKCXVuc2lnbmVkIGxvbmcgaCA9IDA7Cgl1bnNpZ25lZCBsb25nIGc7Cgl1bnNpZ25lZCBjaGFyIGNoOwoKCXdoaWxlIChuID4gMCkgewoJCWNoID0gKm5hbWUrKzsKCQloID0gKGggPDwgNCkgKyBjaDsKCQlnID0gKGggJiAweGYwMDAwMDAwKTsKCQlpZiAoZyAhPSAwKSB7CgkJCWggXj0gZyA+PiAyNDsKCQkJaCAmPSB+ZzsKCQl9CgkJbi0tOwoJfQoJcmV0dXJuIGg7Cn0KCnN0YXRpYyB1bnNpZ25lZCBsb25nIEZBU1RfRlVOQyBvYmpfZWxmX2hhc2goY29uc3QgY2hhciAqbmFtZSkKewoJcmV0dXJuIG9ial9lbGZfaGFzaF9uKG5hbWUsIHN0cmxlbihuYW1lKSk7Cn0KCiNpZiBFTkFCTEVfRkVBVFVSRV9JTlNNT0RfVkVSU0lPTl9DSEVDS0lORwovKiBTdHJpbmcgY29tcGFyaXNvbiBmb3Igbm9uLWNvLXZlcnNpb25lZCBrZXJuZWwgYW5kIG1vZHVsZS4gICovCgpzdGF0aWMgaW50IG5jdl9zdHJjbXAoY29uc3QgY2hhciAqYSwgY29uc3QgY2hhciAqYikKewoJc2l6ZV90IGFsZW4gPSBzdHJsZW4oYSksIGJsZW4gPSBzdHJsZW4oYik7CgoJaWYgKGJsZW4gPT0gYWxlbiArIDEwICYmIGJbYWxlbl0gPT0gJ18nICYmIGJbYWxlbiArIDFdID09ICdSJykKCQlyZXR1cm4gc3RybmNtcChhLCBiLCBhbGVuKTsKCWVsc2UgaWYgKGFsZW4gPT0gYmxlbiArIDEwICYmIGFbYmxlbl0gPT0gJ18nICYmIGFbYmxlbiArIDFdID09ICdSJykKCQlyZXR1cm4gc3RybmNtcChhLCBiLCBibGVuKTsKCWVsc2UKCQlyZXR1cm4gc3RyY21wKGEsIGIpOwp9CgovKiBTdHJpbmcgaGFzaGluZyBmb3Igbm9uLWNvLXZlcnNpb25lZCBrZXJuZWwgYW5kIG1vZHVsZS4gIEhlcmUKICAgd2UgYXJlIHNpbXBseSBmb3JjZWQgdG8gZHJvcCB0aGUgY3JjIGZyb20gdGhlIGhhc2guICAqLwoKc3RhdGljIHVuc2lnbmVkIGxvbmcgRkFTVF9GVU5DIG5jdl9zeW1ib2xfaGFzaChjb25zdCBjaGFyICpzdHIpCnsKCXNpemVfdCBsZW4gPSBzdHJsZW4oc3RyKTsKCWlmIChsZW4gPiAxMCAmJiBzdHJbbGVuIC0gMTBdID09ICdfJyAmJiBzdHJbbGVuIC0gOV0gPT0gJ1InKQoJCWxlbiAtPSAxMDsKCXJldHVybiBvYmpfZWxmX2hhc2hfbihzdHIsIGxlbik7Cn0KCnN0YXRpYyB2b2lkCm9ial9zZXRfc3ltYm9sX2NvbXBhcmUoc3RydWN0IG9ial9maWxlICpmLAoJCWludCAoKmNtcCkgKGNvbnN0IGNoYXIgKiwgY29uc3QgY2hhciAqKSwKCQl1bnNpZ25lZCBsb25nICgqaGFzaCkgKGNvbnN0IGNoYXIgKikgRkFTVF9GVU5DKQp7CglpZiAoY21wKQoJCWYtPnN5bWJvbF9jbXAgPSBjbXA7CglpZiAoaGFzaCkgewoJCXN0cnVjdCBvYmpfc3ltYm9sICp0bXB0YWJbSEFTSF9CVUNLRVRTXSwgKnN5bSwgKm5leHQ7CgkJaW50IGk7CgoJCWYtPnN5bWJvbF9oYXNoID0gaGFzaDsKCgkJbWVtY3B5KHRtcHRhYiwgZi0+c3ltdGFiLCBzaXplb2YodG1wdGFiKSk7CgkJbWVtc2V0KGYtPnN5bXRhYiwgMCwgc2l6ZW9mKGYtPnN5bXRhYikpOwoKCQlmb3IgKGkgPSAwOyBpIDwgSEFTSF9CVUNLRVRTOyArK2kpIHsKCQkJZm9yIChzeW0gPSB0bXB0YWJbaV07IHN5bTsgc3ltID0gbmV4dCkgewoJCQkJdW5zaWduZWQgbG9uZyBoID0gaGFzaChzeW0tPm5hbWUpICUgSEFTSF9CVUNLRVRTOwoJCQkJbmV4dCA9IHN5bS0+bmV4dDsKCQkJCXN5bS0+bmV4dCA9IGYtPnN5bXRhYltoXTsKCQkJCWYtPnN5bXRhYltoXSA9IHN5bTsKCQkJfQoJCX0KCX0KfQoKI2VuZGlmIC8qIEZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcgKi8KCnN0YXRpYyBzdHJ1Y3Qgb2JqX3N5bWJvbCAqCm9ial9hZGRfc3ltYm9sKHN0cnVjdCBvYmpfZmlsZSAqZiwgY29uc3QgY2hhciAqbmFtZSwKCQl1bnNpZ25lZCBsb25nIHN5bWlkeCwgaW50IGluZm8sCgkJaW50IHNlY2lkeCwgRWxmVyhBZGRyKSB2YWx1ZSwKCQl1bnNpZ25lZCBsb25nIHNpemUpCnsKCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07Cgl1bnNpZ25lZCBsb25nIGhhc2ggPSBmLT5zeW1ib2xfaGFzaChuYW1lKSAlIEhBU0hfQlVDS0VUUzsKCWludCBuX3R5cGUgPSBFTEZfU1RfVFlQRShpbmZvKTsKCWludCBuX2JpbmRpbmcgPSBFTEZfU1RfQklORChpbmZvKTsKCglmb3IgKHN5bSA9IGYtPnN5bXRhYltoYXNoXTsgc3ltOyBzeW0gPSBzeW0tPm5leHQpIHsKCQlpZiAoZi0+c3ltYm9sX2NtcChzeW0tPm5hbWUsIG5hbWUpID09IDApIHsKCQkJaW50IG9fc2VjaWR4ID0gc3ltLT5zZWNpZHg7CgkJCWludCBvX2luZm8gPSBzeW0tPmluZm87CgkJCWludCBvX3R5cGUgPSBFTEZfU1RfVFlQRShvX2luZm8pOwoJCQlpbnQgb19iaW5kaW5nID0gRUxGX1NUX0JJTkQob19pbmZvKTsKCgkJCS8qIEEgcmVkZWZpbml0aW9uISAgSXMgaXQgbGVnYWw/ICAqLwoKCQkJaWYgKHNlY2lkeCA9PSBTSE5fVU5ERUYpCgkJCQlyZXR1cm4gc3ltOwoJCQllbHNlIGlmIChvX3NlY2lkeCA9PSBTSE5fVU5ERUYpCgkJCQlnb3RvIGZvdW5kOwoJCQllbHNlIGlmIChuX2JpbmRpbmcgPT0gU1RCX0dMT0JBTCAmJiBvX2JpbmRpbmcgPT0gU1RCX0xPQ0FMKSB7CgkJCQkvKiBDb3BlIHdpdGggbG9jYWwgYW5kIGdsb2JhbCBzeW1ib2xzIG9mIHRoZSBzYW1lIG5hbWUKCQkJCSAgIGluIHRoZSBzYW1lIG9iamVjdCBmaWxlLCBhcyBtaWdodCBoYXZlIGJlZW4gY3JlYXRlZAoJCQkJICAgYnkgbGQgLXIuICBUaGUgb25seSByZWFzb24gbG9jYWxzIGFyZSBub3cgc2VlbiBhdCB0aGlzCgkJCQkgICBsZXZlbCBhdCBhbGwgaXMgc28gdGhhdCB3ZSBjYW4gZG8gc2VtaS1zZW5zaWJsZSB0aGluZ3MKCQkJCSAgIHdpdGggcGFyYW1ldGVycy4gICovCgoJCQkJc3RydWN0IG9ial9zeW1ib2wgKm5zeW0sICoqcDsKCgkJCQluc3ltID0gYXJjaF9uZXdfc3ltYm9sKCk7CgkJCQluc3ltLT5uZXh0ID0gc3ltLT5uZXh0OwoJCQkJbnN5bS0+a3N5bWlkeCA9IC0xOwoKCQkJCS8qIEV4Y2lzZSB0aGUgb2xkIChsb2NhbCkgc3ltYm9sIGZyb20gdGhlIGhhc2ggY2hhaW4uICAqLwoJCQkJZm9yIChwID0gJmYtPnN5bXRhYltoYXNoXTsgKnAgIT0gc3ltOyBwID0gJigqcCktPm5leHQpCgkJCQkJY29udGludWU7CgkJCQkqcCA9IHN5bSA9IG5zeW07CgkJCQlnb3RvIGZvdW5kOwoJCQl9IGVsc2UgaWYgKG5fYmluZGluZyA9PSBTVEJfTE9DQUwpIHsKCQkJCS8qIEFub3RoZXIgc3ltYm9sIG9mIHRoZSBzYW1lIG5hbWUgaGFzIGFscmVhZHkgYmVlbiBkZWZpbmVkLgoJCQkJICAgSnVzdCBhZGQgdGhpcyB0byB0aGUgbG9jYWwgdGFibGUuICAqLwoJCQkJc3ltID0gYXJjaF9uZXdfc3ltYm9sKCk7CgkJCQlzeW0tPm5leHQgPSBOVUxMOwoJCQkJc3ltLT5rc3ltaWR4ID0gLTE7CgkJCQlmLT5sb2NhbF9zeW10YWJbc3ltaWR4XSA9IHN5bTsKCQkJCWdvdG8gZm91bmQ7CgkJCX0gZWxzZSBpZiAobl9iaW5kaW5nID09IFNUQl9XRUFLKQoJCQkJcmV0dXJuIHN5bTsKCQkJZWxzZSBpZiAob19iaW5kaW5nID09IFNUQl9XRUFLKQoJCQkJZ290byBmb3VuZDsKCQkJLyogRG9uJ3QgdW5pZnkgQ09NTU9OIHN5bWJvbHMgd2l0aCBvYmplY3QgdHlwZXMgdGhlIHByb2dyYW1tZXIKCQkJICAgZG9lc24ndCBleHBlY3QuICAqLwoJCQllbHNlIGlmIChzZWNpZHggPT0gU0hOX0NPTU1PTgoJCQkJCSYmIChvX3R5cGUgPT0gU1RUX05PVFlQRSB8fCBvX3R5cGUgPT0gU1RUX09CSkVDVCkpCgkJCQlyZXR1cm4gc3ltOwoJCQllbHNlIGlmIChvX3NlY2lkeCA9PSBTSE5fQ09NTU9OCgkJCQkJJiYgKG5fdHlwZSA9PSBTVFRfTk9UWVBFIHx8IG5fdHlwZSA9PSBTVFRfT0JKRUNUKSkKCQkJCWdvdG8gZm91bmQ7CgkJCWVsc2UgewoJCQkJLyogRG9uJ3QgcmVwb3J0IGFuIGVycm9yIGlmIHRoZSBzeW1ib2wgaXMgY29taW5nIGZyb20KCQkJCSAgIHRoZSBrZXJuZWwgb3Igc29tZSBleHRlcm5hbCBtb2R1bGUuICAqLwoJCQkJaWYgKHNlY2lkeCA8PSBTSE5fSElSRVNFUlZFKQoJCQkJCWJiX2Vycm9yX21zZygiJXMgbXVsdGlwbHkgZGVmaW5lZCIsIG5hbWUpOwoJCQkJcmV0dXJuIHN5bTsKCQkJfQoJCX0KCX0KCgkvKiBDb21wbGV0ZWx5IG5ldyBzeW1ib2wuICAqLwoJc3ltID0gYXJjaF9uZXdfc3ltYm9sKCk7CglzeW0tPm5leHQgPSBmLT5zeW10YWJbaGFzaF07CglmLT5zeW10YWJbaGFzaF0gPSBzeW07CglzeW0tPmtzeW1pZHggPSAtMTsKCWlmIChFTEZfU1RfQklORChpbmZvKSA9PSBTVEJfTE9DQUwgJiYgc3ltaWR4ICE9ICh1bnNpZ25lZCBsb25nKSgtMSkpIHsKCQlpZiAoc3ltaWR4ID49IGYtPmxvY2FsX3N5bXRhYl9zaXplKQoJCQliYl9lcnJvcl9tc2coImxvY2FsIHN5bWJvbCAlcyB3aXRoIGluZGV4ICVsZCBleGNlZWRzIGxvY2FsX3N5bXRhYl9zaXplICVsZCIsCgkJCQkJbmFtZSwgKGxvbmcpIHN5bWlkeCwgKGxvbmcpIGYtPmxvY2FsX3N5bXRhYl9zaXplKTsKCQllbHNlCgkJCWYtPmxvY2FsX3N5bXRhYltzeW1pZHhdID0gc3ltOwoJfQoKZm91bmQ6CglzeW0tPm5hbWUgPSBuYW1lOwoJc3ltLT52YWx1ZSA9IHZhbHVlOwoJc3ltLT5zaXplID0gc2l6ZTsKCXN5bS0+c2VjaWR4ID0gc2VjaWR4OwoJc3ltLT5pbmZvID0gaW5mbzsKCglyZXR1cm4gc3ltOwp9CgpzdGF0aWMgc3RydWN0IG9ial9zeW1ib2wgKgpvYmpfZmluZF9zeW1ib2woc3RydWN0IG9ial9maWxlICpmLCBjb25zdCBjaGFyICpuYW1lKQp7CglzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwoJdW5zaWduZWQgbG9uZyBoYXNoID0gZi0+c3ltYm9sX2hhc2gobmFtZSkgJSBIQVNIX0JVQ0tFVFM7CgoJZm9yIChzeW0gPSBmLT5zeW10YWJbaGFzaF07IHN5bTsgc3ltID0gc3ltLT5uZXh0KQoJCWlmIChmLT5zeW1ib2xfY21wKHN5bS0+bmFtZSwgbmFtZSkgPT0gMCkKCQkJcmV0dXJuIHN5bTsKCXJldHVybiBOVUxMOwp9CgpzdGF0aWMgRWxmVyhBZGRyKSBvYmpfc3ltYm9sX2ZpbmFsX3ZhbHVlKHN0cnVjdCBvYmpfZmlsZSAqIGYsIHN0cnVjdCBvYmpfc3ltYm9sICogc3ltKQp7CglpZiAoc3ltKSB7CgkJaWYgKHN5bS0+c2VjaWR4ID49IFNITl9MT1JFU0VSVkUpCgkJCXJldHVybiBzeW0tPnZhbHVlOwoJCXJldHVybiBzeW0tPnZhbHVlICsgZi0+c2VjdGlvbnNbc3ltLT5zZWNpZHhdLT5oZWFkZXIuc2hfYWRkcjsKCX0KCS8qIEFzIGEgc3BlY2lhbCBjYXNlLCBhIE5VTEwgc3ltIGhhcyB2YWx1ZSB6ZXJvLiAgKi8KCXJldHVybiAwOwp9CgpzdGF0aWMgc3RydWN0IG9ial9zZWN0aW9uICpvYmpfZmluZF9zZWN0aW9uKHN0cnVjdCBvYmpfZmlsZSAqZiwgY29uc3QgY2hhciAqbmFtZSkKewoJaW50IGksIG4gPSBmLT5oZWFkZXIuZV9zaG51bTsKCglmb3IgKGkgPSAwOyBpIDwgbjsgKytpKQoJCWlmIChzdHJjbXAoZi0+c2VjdGlvbnNbaV0tPm5hbWUsIG5hbWUpID09IDApCgkJCXJldHVybiBmLT5zZWN0aW9uc1tpXTsKCXJldHVybiBOVUxMOwp9CgpzdGF0aWMgaW50IG9ial9sb2FkX29yZGVyX3ByaW8oc3RydWN0IG9ial9zZWN0aW9uICphKQp7Cgl1bnNpZ25lZCBsb25nIGFmLCBhYzsKCglhZiA9IGEtPmhlYWRlci5zaF9mbGFnczsKCglhYyA9IDA7CglpZiAoYS0+bmFtZVswXSAhPSAnLicgfHwgc3RybGVuKGEtPm5hbWUpICE9IDEwCgkgfHwgc3RyY21wKGEtPm5hbWUgKyA1LCAiLmluaXQiKSAhPSAwCgkpIHsKCQlhYyB8PSAzMjsKCX0KCWlmIChhZiAmIFNIRl9BTExPQykKCQlhYyB8PSAxNjsKCWlmICghKGFmICYgU0hGX1dSSVRFKSkKCQlhYyB8PSA4OwoJaWYgKGFmICYgU0hGX0VYRUNJTlNUUikKCQlhYyB8PSA0OwoJaWYgKGEtPmhlYWRlci5zaF90eXBlICE9IFNIVF9OT0JJVFMpCgkJYWMgfD0gMjsKCglyZXR1cm4gYWM7Cn0KCnN0YXRpYyB2b2lkCm9ial9pbnNlcnRfc2VjdGlvbl9sb2FkX29yZGVyKHN0cnVjdCBvYmpfZmlsZSAqZiwgc3RydWN0IG9ial9zZWN0aW9uICpzZWMpCnsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqKnA7CglpbnQgcHJpbyA9IG9ial9sb2FkX29yZGVyX3ByaW8oc2VjKTsKCWZvciAocCA9IGYtPmxvYWRfb3JkZXJfc2VhcmNoX3N0YXJ0OyAqcDsgcCA9ICYoKnApLT5sb2FkX25leHQpCgkJaWYgKG9ial9sb2FkX29yZGVyX3ByaW8oKnApIDwgcHJpbykKCQkJYnJlYWs7CglzZWMtPmxvYWRfbmV4dCA9ICpwOwoJKnAgPSBzZWM7Cn0KCnN0YXRpYyBzdHJ1Y3Qgb2JqX3NlY3Rpb24gKmhlbHBlcl9jcmVhdGVfYWxsb2NlZF9zZWN0aW9uKHN0cnVjdCBvYmpfZmlsZSAqZiwKCQljb25zdCBjaGFyICpuYW1lLAoJCXVuc2lnbmVkIGxvbmcgYWxpZ24sCgkJdW5zaWduZWQgbG9uZyBzaXplKQp7CglpbnQgbmV3aWR4ID0gZi0+aGVhZGVyLmVfc2hudW0rKzsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwoKCWYtPnNlY3Rpb25zID0geHJlYWxsb2NfdmVjdG9yKGYtPnNlY3Rpb25zLCAyLCBuZXdpZHgpOwoJZi0+c2VjdGlvbnNbbmV3aWR4XSA9IHNlYyA9IGFyY2hfbmV3X3NlY3Rpb24oKTsKCglzZWMtPmhlYWRlci5zaF90eXBlID0gU0hUX1BST0dCSVRTOwoJc2VjLT5oZWFkZXIuc2hfZmxhZ3MgPSBTSEZfV1JJVEUgfCBTSEZfQUxMT0M7CglzZWMtPmhlYWRlci5zaF9zaXplID0gc2l6ZTsKCXNlYy0+aGVhZGVyLnNoX2FkZHJhbGlnbiA9IGFsaWduOwoJc2VjLT5uYW1lID0gbmFtZTsKCXNlYy0+aWR4ID0gbmV3aWR4OwoJaWYgKHNpemUpCgkJc2VjLT5jb250ZW50cyA9IHh6YWxsb2Moc2l6ZSk7CgoJcmV0dXJuIHNlYzsKfQoKc3RhdGljIHN0cnVjdCBvYmpfc2VjdGlvbiAqb2JqX2NyZWF0ZV9hbGxvY2VkX3NlY3Rpb24oc3RydWN0IG9ial9maWxlICpmLAoJCWNvbnN0IGNoYXIgKm5hbWUsCgkJdW5zaWduZWQgbG9uZyBhbGlnbiwKCQl1bnNpZ25lZCBsb25nIHNpemUpCnsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwoKCXNlYyA9IGhlbHBlcl9jcmVhdGVfYWxsb2NlZF9zZWN0aW9uKGYsIG5hbWUsIGFsaWduLCBzaXplKTsKCW9ial9pbnNlcnRfc2VjdGlvbl9sb2FkX29yZGVyKGYsIHNlYyk7CglyZXR1cm4gc2VjOwp9CgpzdGF0aWMgc3RydWN0IG9ial9zZWN0aW9uICpvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbl9maXJzdChzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJY29uc3QgY2hhciAqbmFtZSwKCQl1bnNpZ25lZCBsb25nIGFsaWduLAoJCXVuc2lnbmVkIGxvbmcgc2l6ZSkKewoJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CgoJc2VjID0gaGVscGVyX2NyZWF0ZV9hbGxvY2VkX3NlY3Rpb24oZiwgbmFtZSwgYWxpZ24sIHNpemUpOwoJc2VjLT5sb2FkX25leHQgPSBmLT5sb2FkX29yZGVyOwoJZi0+bG9hZF9vcmRlciA9IHNlYzsKCWlmIChmLT5sb2FkX29yZGVyX3NlYXJjaF9zdGFydCA9PSAmZi0+bG9hZF9vcmRlcikKCQlmLT5sb2FkX29yZGVyX3NlYXJjaF9zdGFydCA9ICZzZWMtPmxvYWRfbmV4dDsKCglyZXR1cm4gc2VjOwp9CgpzdGF0aWMgdm9pZCAqb2JqX2V4dGVuZF9zZWN0aW9uKHN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjLCB1bnNpZ25lZCBsb25nIG1vcmUpCnsKCXVuc2lnbmVkIGxvbmcgb2xkc2l6ZSA9IHNlYy0+aGVhZGVyLnNoX3NpemU7CglpZiAobW9yZSkgewoJCXNlYy0+aGVhZGVyLnNoX3NpemUgKz0gbW9yZTsKCQlzZWMtPmNvbnRlbnRzID0geHJlYWxsb2Moc2VjLT5jb250ZW50cywgc2VjLT5oZWFkZXIuc2hfc2l6ZSk7Cgl9CglyZXR1cm4gc2VjLT5jb250ZW50cyArIG9sZHNpemU7Cn0KCgovKiBDb25kaXRpb25hbGx5IGFkZCB0aGUgc3ltYm9scyBmcm9tIHRoZSBnaXZlbiBzeW1ib2wgc2V0IHRvIHRoZQogICBuZXcgbW9kdWxlLiAgKi8KCnN0YXRpYyBpbnQgYWRkX3N5bWJvbHNfZnJvbShzdHJ1Y3Qgb2JqX2ZpbGUgKmYsCgkJaW50IGlkeCwKCQlzdHJ1Y3QgbmV3X21vZHVsZV9zeW1ib2wgKnN5bXMsCgkJc2l6ZV90IG5zeW1zKQp7CglzdHJ1Y3QgbmV3X21vZHVsZV9zeW1ib2wgKnM7CglzaXplX3QgaTsKCWludCB1c2VkID0gMDsKI2lmZGVmIFNZTUJPTF9QUkVGSVgKCWNoYXIgKm5hbWVfYnVmID0gTlVMTDsKCXNpemVfdCBuYW1lX2FsbG9jZWRfc2l6ZSA9IDA7CiNlbmRpZgojaWYgRU5BQkxFX0ZFQVRVUkVfQ0hFQ0tfVEFJTlRFRF9NT0RVTEUKCWludCBncGw7CgoJZ3BsID0gb2JqX2dwbF9saWNlbnNlKGYsIE5VTEwpID09IDA7CiNlbmRpZgoJZm9yIChpID0gMCwgcyA9IHN5bXM7IGkgPCBuc3ltczsgKytpLCArK3MpIHsKCQkvKiBPbmx5IGFkZCBzeW1ib2xzIHRoYXQgYXJlIGFscmVhZHkgbWFya2VkIGV4dGVybmFsLgoJCSAgIElmIHdlIG92ZXJyaWRlIGxvY2FscyB3ZSBtYXkgY2F1c2UgcHJvYmxlbXMgZm9yCgkJICAgYXJndW1lbnQgaW5pdGlhbGl6YXRpb24uICBXZSB3aWxsIGFsc28gY3JlYXRlIGEgZmFsc2UKCQkgICBkZXBlbmRlbmN5IG9uIHRoZSBtb2R1bGUuICAqLwoJCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07CgkJY2hhciAqbmFtZTsKCgkJLyogR1BMIGxpY2Vuc2VkIG1vZHVsZXMgY2FuIHVzZSBzeW1ib2xzIGV4cG9ydGVkIHdpdGgKCQkgKiBFWFBPUlRfU1lNQk9MX0dQTCwgc28gaWdub3JlIGFueSBHUExPTkxZXyBwcmVmaXggb24gdGhlCgkJICogZXhwb3J0ZWQgbmFtZXMuICBOb24tR1BMIG1vZHVsZXMgbmV2ZXIgc2VlIGFueSBHUExPTkxZXwoJCSAqIHN5bWJvbHMgc28gdGhleSBjYW5ub3QgZnVkZ2UgaXQgYnkgYWRkaW5nIHRoZSBwcmVmaXggb24KCQkgKiB0aGVpciByZWZlcmVuY2VzLgoJCSAqLwoJCWlmIChpc19wcmVmaXhlZF93aXRoKChjaGFyICopcy0+bmFtZSwgIkdQTE9OTFlfIikpIHsKI2lmIEVOQUJMRV9GRUFUVVJFX0NIRUNLX1RBSU5URURfTU9EVUxFCgkJCWlmIChncGwpCgkJCQlzLT5uYW1lICs9IDg7CgkJCWVsc2UKI2VuZGlmCgkJCQljb250aW51ZTsKCQl9CgkJbmFtZSA9IChjaGFyICopcy0+bmFtZTsKCiNpZmRlZiBTWU1CT0xfUFJFRklYCgkJLyogUHJlcGVuZCBTWU1CT0xfUFJFRklYIHRvIHRoZSBzeW1ib2wncyBuYW1lICh0aGUKCQkgICBrZXJuZWwgZXhwb3J0cyAnQyBuYW1lcycsIGJ1dCBtb2R1bGUgb2JqZWN0IGZpbGVzCgkJICAgcmVmZXJlbmNlICdsaW5rZXIgbmFtZXMnKS4gICovCgkJc2l6ZV90IGV4dHJhID0gc2l6ZW9mIFNZTUJPTF9QUkVGSVg7CgkJc2l6ZV90IG5hbWVfc2l6ZSA9IHN0cmxlbihuYW1lKSArIGV4dHJhOwoJCWlmIChuYW1lX3NpemUgPiBuYW1lX2FsbG9jZWRfc2l6ZSkgewoJCQluYW1lX2FsbG9jZWRfc2l6ZSA9IG5hbWVfc2l6ZSAqIDI7CgkJCW5hbWVfYnVmID0gYWxsb2NhKG5hbWVfYWxsb2NlZF9zaXplKTsKCQl9CgkJc3RyY3B5KG5hbWVfYnVmLCBTWU1CT0xfUFJFRklYKTsKCQlzdHJjcHkobmFtZV9idWYgKyBleHRyYSAtIDEsIG5hbWUpOwoJCW5hbWUgPSBuYW1lX2J1ZjsKI2VuZGlmCgoJCXN5bSA9IG9ial9maW5kX3N5bWJvbChmLCBuYW1lKTsKCQlpZiAoc3ltICYmICEoRUxGX1NUX0JJTkQoc3ltLT5pbmZvKSA9PSBTVEJfTE9DQUwpKSB7CiNpZmRlZiBTWU1CT0xfUFJFRklYCgkJCS8qIFB1dCBOQU1FX0JVRiBpbnRvIG1vcmUgcGVybWFuZW50IHN0b3JhZ2UuICAqLwoJCQluYW1lID0geG1hbGxvYyhuYW1lX3NpemUpOwoJCQlzdHJjcHkobmFtZSwgbmFtZV9idWYpOwojZW5kaWYKCQkJc3ltID0gb2JqX2FkZF9zeW1ib2woZiwgbmFtZSwgLTEsCgkJCQkJRUxGX1NUX0lORk8oU1RCX0dMT0JBTCwKCQkJCQkJU1RUX05PVFlQRSksCgkJCQkJaWR4LCBzLT52YWx1ZSwgMCk7CgkJCS8qIERpZCBvdXIgc3ltYm9sIGp1c3QgZ2V0IGluc3RhbGxlZD8gIElmIHNvLCBtYXJrIHRoZQoJCQkgICBtb2R1bGUgYXMgInVzZWQiLiAgKi8KCQkJaWYgKHN5bS0+c2VjaWR4ID09IGlkeCkKCQkJCXVzZWQgPSAxOwoJCX0KCX0KCglyZXR1cm4gdXNlZDsKfQoKc3RhdGljIHZvaWQgYWRkX2tlcm5lbF9zeW1ib2xzKHN0cnVjdCBvYmpfZmlsZSAqZikKewoJc3RydWN0IGV4dGVybmFsX21vZHVsZSAqbTsKCWludCBpLCBudXNlZCA9IDA7CgoJLyogQWRkIG1vZHVsZSBzeW1ib2xzIGZpcnN0LiAgKi8KCglmb3IgKGkgPSAwLCBtID0gZXh0X21vZHVsZXM7IGkgPCBuX2V4dF9tb2R1bGVzOyArK2ksICsrbSkgewoJCWlmIChtLT5uc3ltcwoJCSAmJiBhZGRfc3ltYm9sc19mcm9tKGYsIFNITl9ISVJFU0VSVkUgKyAyICsgaSwgbS0+c3ltcywgbS0+bnN5bXMpCgkJKSB7CgkJCW0tPnVzZWQgPSAxOwoJCQkrK251c2VkOwoJCX0KCX0KCgluX2V4dF9tb2R1bGVzX3VzZWQgPSBudXNlZDsKCgkvKiBBbmQgZmluYWxseSB0aGUgc3ltYm9scyBmcm9tIHRoZSBrZXJuZWwgcHJvcGVyLiAgKi8KCglpZiAobmtzeW1zKQoJCWFkZF9zeW1ib2xzX2Zyb20oZiwgU0hOX0hJUkVTRVJWRSArIDEsIGtzeW1zLCBua3N5bXMpOwp9CgpzdGF0aWMgY2hhciAqZ2V0X21vZGluZm9fdmFsdWUoc3RydWN0IG9ial9maWxlICpmLCBjb25zdCBjaGFyICprZXkpCnsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwoJY2hhciAqcCwgKnYsICpuLCAqZXA7CglzaXplX3Qga2xlbiA9IHN0cmxlbihrZXkpOwoKCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi5tb2RpbmZvIik7CglpZiAoc2VjID09IE5VTEwpCgkJcmV0dXJuIE5VTEw7CglwID0gc2VjLT5jb250ZW50czsKCWVwID0gcCArIHNlYy0+aGVhZGVyLnNoX3NpemU7Cgl3aGlsZSAocCA8IGVwKSB7CgkJdiA9IHN0cmNocihwLCAnPScpOwoJCW4gPSBzdHJjaHIocCwgJ1wwJyk7CgkJaWYgKHYpIHsKCQkJaWYgKHAgKyBrbGVuID09IHYgJiYgc3RybmNtcChwLCBrZXksIGtsZW4pID09IDApCgkJCQlyZXR1cm4gdiArIDE7CgkJfSBlbHNlIHsKCQkJaWYgKHAgKyBrbGVuID09IG4gJiYgc3RyY21wKHAsIGtleSkgPT0gMCkKCQkJCXJldHVybiBuOwoJCX0KCQlwID0gbiArIDE7Cgl9CgoJcmV0dXJuIE5VTEw7Cn0KCgovKj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwovKiBGdW5jdGlvbnMgcmVsYXRpbmcgdG8gbW9kdWxlIGxvYWRpbmcgYWZ0ZXIgMi4xLjE4LiAgKi8KCi8qIEZyb20gTGludXgtMi42IHNvdXJjZXMgKi8KLyogWW91IGNhbiB1c2UgIiBhcm91bmQgc3BhY2VzLCBidXQgY2FuJ3QgZXNjYXBlICIuICovCi8qIEh5cGhlbnMgYW5kIHVuZGVyc2NvcmVzIGVxdWl2YWxlbnQgaW4gcGFyYW1ldGVyIG5hbWVzLiAqLwpzdGF0aWMgY2hhciAqbmV4dF9hcmcoY2hhciAqYXJncywgY2hhciAqKnBhcmFtLCBjaGFyICoqdmFsKQp7Cgl1bnNpZ25lZCBpbnQgaSwgZXF1YWxzID0gMDsKCWludCBpbl9xdW90ZSA9IDAsIHF1b3RlZCA9IDA7CgljaGFyICpuZXh0OwoKCWlmICgqYXJncyA9PSAnIicpIHsKCQlhcmdzKys7CgkJaW5fcXVvdGUgPSAxOwoJCXF1b3RlZCA9IDE7Cgl9CgoJZm9yIChpID0gMDsgYXJnc1tpXTsgaSsrKSB7CgkJaWYgKGFyZ3NbaV0gPT0gJyAnICYmICFpbl9xdW90ZSkKCQkJYnJlYWs7CgkJaWYgKGVxdWFscyA9PSAwKSB7CgkJCWlmIChhcmdzW2ldID09ICc9JykKCQkJCWVxdWFscyA9IGk7CgkJfQoJCWlmIChhcmdzW2ldID09ICciJykKCQkJaW5fcXVvdGUgPSAhaW5fcXVvdGU7Cgl9CgoJKnBhcmFtID0gYXJnczsKCWlmICghZXF1YWxzKQoJCSp2YWwgPSBOVUxMOwoJZWxzZSB7CgkJYXJnc1tlcXVhbHNdID0gJ1wwJzsKCQkqdmFsID0gYXJncyArIGVxdWFscyArIDE7CgoJCS8qIERvbid0IGluY2x1ZGUgcXVvdGVzIGluIHZhbHVlLiAqLwoJCWlmICgqKnZhbCA9PSAnIicpIHsKCQkJKCp2YWwpKys7CgkJCWlmIChhcmdzW2ktMV0gPT0gJyInKQoJCQkJYXJnc1tpLTFdID0gJ1wwJzsKCQl9CgkJaWYgKHF1b3RlZCAmJiBhcmdzW2ktMV0gPT0gJyInKQoJCQlhcmdzW2ktMV0gPSAnXDAnOwoJfQoKCWlmIChhcmdzW2ldKSB7CgkJYXJnc1tpXSA9ICdcMCc7CgkJbmV4dCA9IGFyZ3MgKyBpICsgMTsKCX0gZWxzZQoJCW5leHQgPSBhcmdzICsgaTsKCgkvKiBDaGV3IHVwIHRyYWlsaW5nIHNwYWNlcy4gKi8KCXJldHVybiBza2lwX3doaXRlc3BhY2UobmV4dCk7Cn0KCnN0YXRpYyB2b2lkCm5ld19wcm9jZXNzX21vZHVsZV9hcmd1bWVudHMoc3RydWN0IG9ial9maWxlICpmLCBjb25zdCBjaGFyICpvcHRpb25zKQp7CgljaGFyICp4b3B0aW9ucywgKnBvczsKCWNoYXIgKnBhcmFtLCAqdmFsOwoKCXhvcHRpb25zID0gcG9zID0geHN0cmR1cChza2lwX3doaXRlc3BhY2Uob3B0aW9ucykpOwoJd2hpbGUgKCpwb3MpIHsKCQl1bnNpZ25lZCBsb25nIGNoYXJzc2l6ZSA9IDA7CgkJY2hhciAqdG1wLCAqY29udGVudHMsICpsb2MsICpwaW5mbywgKnA7CgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCQlpbnQgbWluLCBtYXgsIG4sIGxlbjsKCgkJcG9zID0gbmV4dF9hcmcocG9zLCAmcGFyYW0sICZ2YWwpOwoKCQl0bXAgPSB4YXNwcmludGYoInBhcm1fJXMiLCBwYXJhbSk7CgkJcGluZm8gPSBnZXRfbW9kaW5mb192YWx1ZShmLCB0bXApOwoJCWZyZWUodG1wKTsKCQlpZiAocGluZm8gPT0gTlVMTCkKCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoImludmFsaWQgcGFyYW1ldGVyICVzIiwgcGFyYW0pOwoKI2lmZGVmIFNZTUJPTF9QUkVGSVgKCQl0bXAgPSB4YXNwcmludGYoU1lNQk9MX1BSRUZJWCAiJXMiLCBwYXJhbSk7CgkJc3ltID0gb2JqX2ZpbmRfc3ltYm9sKGYsIHRtcCk7CgkJZnJlZSh0bXApOwojZWxzZQoJCXN5bSA9IG9ial9maW5kX3N5bWJvbChmLCBwYXJhbSk7CiNlbmRpZgoKCQkvKiBBbHNvIGNoZWNrIHRoYXQgdGhlIHBhcmFtZXRlciB3YXMgbm90IHJlc29sdmVkIGZyb20gdGhlIGtlcm5lbC4gICovCgkJaWYgKHN5bSA9PSBOVUxMIHx8IHN5bS0+c2VjaWR4ID4gU0hOX0hJUkVTRVJWRSkKCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoInN5bWJvbCBmb3IgcGFyYW1ldGVyICVzIG5vdCBmb3VuZCIsIHBhcmFtKTsKCgkJLyogTnVtYmVyIG9mIHBhcmFtZXRlcnMgKi8KCQltaW4gPSBtYXggPSAxOwoJCWlmIChpc2RpZ2l0KCpwaW5mbykpIHsKCQkJbWluID0gbWF4ID0gc3RydG91bChwaW5mbywgJnBpbmZvLCAxMCk7CgkJCWlmICgqcGluZm8gPT0gJy0nKQoJCQkJbWF4ID0gc3RydG91bChwaW5mbyArIDEsICZwaW5mbywgMTApOwoJCX0KCgkJY29udGVudHMgPSBmLT5zZWN0aW9uc1tzeW0tPnNlY2lkeF0tPmNvbnRlbnRzOwoJCWxvYyA9IGNvbnRlbnRzICsgc3ltLT52YWx1ZTsKCgkJaWYgKCpwaW5mbyA9PSAnYycpIHsKCQkJaWYgKCFpc2RpZ2l0KHBpbmZvWzFdKSkgewoJCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoInBhcmFtZXRlciB0eXBlICdjJyBmb3IgJXMgbXVzdCBiZSBmb2xsb3dlZCBieSIKCQkJCQkJICAgICAiIHRoZSBtYXhpbXVtIHNpemUiLCBwYXJhbSk7CgkJCX0KCQkJY2hhcnNzaXplID0gc3RydG91bChwaW5mbyArIDEsIE5VTEwsIDEwKTsKCQl9CgoJCWlmICh2YWwgPT0gTlVMTCkgewoJCQlpZiAoKnBpbmZvICE9ICdiJykKCQkJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJhcmd1bWVudCBleHBlY3RlZCBmb3IgcGFyYW1ldGVyICVzIiwgcGFyYW0pOwoJCQl2YWwgPSAoY2hhciAqKSAiMSI7CgkJfQoKCQkvKiBQYXJzZSBwYXJhbWV0ZXIgdmFsdWVzICovCgkJbiA9IDA7CgkJcCA9IHZhbDsKCQl3aGlsZSAoKnApIHsKCQkJY2hhciBzdl9jaDsKCQkJY2hhciAqZW5kcDsKCgkJCWlmICgrK24gPiBtYXgpCgkJCQliYl9lcnJvcl9tc2dfYW5kX2RpZSgidG9vIG1hbnkgdmFsdWVzIGZvciAlcyAobWF4ICVkKSIsIHBhcmFtLCBtYXgpOwoKCQkJc3dpdGNoICgqcGluZm8pIHsKCQkJY2FzZSAncyc6CgkJCQlsZW4gPSBzdHJjc3BuKHAsICIsIik7CgkJCQlzdl9jaCA9IHBbbGVuXTsKCQkJCXBbbGVuXSA9ICdcMCc7CgkJCQlvYmpfc3RyaW5nX3BhdGNoKGYsIHN5bS0+c2VjaWR4LAoJCQkJCQkgbG9jIC0gY29udGVudHMsIHApOwoJCQkJbG9jICs9IHRndF9zaXplb2ZfY2hhcl9wOwoJCQkJcCArPSBsZW47CgkJCQkqcCA9IHN2X2NoOwoJCQkJYnJlYWs7CgkJCWNhc2UgJ2MnOgoJCQkJbGVuID0gc3RyY3NwbihwLCAiLCIpOwoJCQkJc3ZfY2ggPSBwW2xlbl07CgkJCQlwW2xlbl0gPSAnXDAnOwoJCQkJaWYgKGxlbiA+PSBjaGFyc3NpemUpCgkJCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoInN0cmluZyB0b28gbG9uZyBmb3IgJXMgKG1heCAlbGQpIiwgcGFyYW0sCgkJCQkJCQkgICAgIGNoYXJzc2l6ZSAtIDEpOwoJCQkJc3RyY3B5KChjaGFyICopIGxvYywgcCk7CgkJCQlsb2MgKz0gY2hhcnNzaXplOwoJCQkJcCArPSBsZW47CgkJCQkqcCA9IHN2X2NoOwoJCQkJYnJlYWs7CgkJCWNhc2UgJ2InOgoJCQkJKmxvYysrID0gc3RydG91bChwLCAmZW5kcCwgMCk7CgkJCQlwID0gZW5kcDsgLyogZ2NjIGxpa2VzIHRlbXAgdmFyIGZvciAmZW5kcCAqLwoJCQkJYnJlYWs7CgkJCWNhc2UgJ2gnOgoJCQkJKihzaG9ydCAqKSBsb2MgPSBzdHJ0b3VsKHAsICZlbmRwLCAwKTsKCQkJCWxvYyArPSB0Z3Rfc2l6ZW9mX3Nob3J0OwoJCQkJcCA9IGVuZHA7CgkJCQlicmVhazsKCQkJY2FzZSAnaSc6CgkJCQkqKGludCAqKSBsb2MgPSBzdHJ0b3VsKHAsICZlbmRwLCAwKTsKCQkJCWxvYyArPSB0Z3Rfc2l6ZW9mX2ludDsKCQkJCXAgPSBlbmRwOwoJCQkJYnJlYWs7CgkJCWNhc2UgJ2wnOgoJCQkJKihsb25nICopIGxvYyA9IHN0cnRvdWwocCwgJmVuZHAsIDApOwoJCQkJbG9jICs9IHRndF9zaXplb2ZfbG9uZzsKCQkJCXAgPSBlbmRwOwoJCQkJYnJlYWs7CgkJCWRlZmF1bHQ6CgkJCQliYl9lcnJvcl9tc2dfYW5kX2RpZSgidW5rbm93biBwYXJhbWV0ZXIgdHlwZSAnJWMnIGZvciAlcyIsCgkJCQkJCSAgICAgKnBpbmZvLCBwYXJhbSk7CgkJCX0KCgkJCXAgPSBza2lwX3doaXRlc3BhY2UocCk7CgkJCWlmICgqcCAhPSAnLCcpCgkJCQlicmVhazsKCQkJcCA9IHNraXBfd2hpdGVzcGFjZShwICsgMSk7CgkJfQoKCQlpZiAobiA8IG1pbikKCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoInBhcmFtZXRlciAlcyByZXF1aXJlcyBhdCBsZWFzdCAlZCBhcmd1bWVudHMiLCBwYXJhbSwgbWluKTsKCQlpZiAoKnAgIT0gJ1wwJykKCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoImludmFsaWQgYXJndW1lbnQgc3ludGF4IGZvciAlcyIsIHBhcmFtKTsKCX0KCglmcmVlKHhvcHRpb25zKTsKfQoKI2lmIEVOQUJMRV9GRUFUVVJFX0lOU01PRF9WRVJTSU9OX0NIRUNLSU5HCnN0YXRpYyBpbnQgbmV3X2lzX21vZHVsZV9jaGVja3N1bW1lZChzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCWNvbnN0IGNoYXIgKnAgPSBnZXRfbW9kaW5mb192YWx1ZShmLCAidXNpbmdfY2hlY2tzdW1zIik7CglpZiAocCkKCQlyZXR1cm4geGF0b2kocCk7CglyZXR1cm4gMDsKfQoKLyogR2V0IHRoZSBtb2R1bGUncyBrZXJuZWwgdmVyc2lvbiBpbiB0aGUgY2Fub25pY2FsIGludGVnZXIgZm9ybS4gICovCgpzdGF0aWMgaW50Cm5ld19nZXRfbW9kdWxlX3ZlcnNpb24oc3RydWN0IG9ial9maWxlICpmLCBjaGFyIHN0cltTVFJWRVJTSU9OTEVOXSkKewoJY2hhciAqcCwgKnE7CglpbnQgYSwgYiwgYzsKCglwID0gZ2V0X21vZGluZm9fdmFsdWUoZiwgImtlcm5lbF92ZXJzaW9uIik7CglpZiAocCA9PSBOVUxMKQoJCXJldHVybiAtMTsKCXNhZmVfc3RybmNweShzdHIsIHAsIFNUUlZFUlNJT05MRU4pOwoKCWEgPSBzdHJ0b3VsKHAsICZwLCAxMCk7CglpZiAoKnAgIT0gJy4nKQoJCXJldHVybiAtMTsKCWIgPSBzdHJ0b3VsKHAgKyAxLCAmcCwgMTApOwoJaWYgKCpwICE9ICcuJykKCQlyZXR1cm4gLTE7CgljID0gc3RydG91bChwICsgMSwgJnEsIDEwKTsKCWlmIChwICsgMSA9PSBxKQoJCXJldHVybiAtMTsKCglyZXR1cm4gYSA8PCAxNiB8IGIgPDwgOCB8IGM7Cn0KCiNlbmRpZiAgIC8qIEZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcgKi8KCgovKiBGZXRjaCB0aGUgbG9hZGVkIG1vZHVsZXMsIGFuZCBhbGwgY3VycmVudGx5IGV4cG9ydGVkIHN5bWJvbHMuICAqLwoKc3RhdGljIHZvaWQgbmV3X2dldF9rZXJuZWxfc3ltYm9scyh2b2lkKQp7CgljaGFyICptb2R1bGVfbmFtZXMsICptbjsKCXN0cnVjdCBleHRlcm5hbF9tb2R1bGUgKm1vZHVsZXMsICptOwoJc3RydWN0IG5ld19tb2R1bGVfc3ltYm9sICpzeW1zLCAqczsKCXNpemVfdCByZXQsIGJ1ZnNpemUsIG5tb2QsIG5zeW1zLCBpLCBqOwoKCS8qIENvbGxlY3QgdGhlIGxvYWRlZCBtb2R1bGVzLiAgKi8KCglidWZzaXplID0gMjU2OwoJbW9kdWxlX25hbWVzID0geG1hbGxvYyhidWZzaXplKTsKCiByZXRyeV9tb2R1bGVzX2xvYWQ6CglpZiAocXVlcnlfbW9kdWxlKE5VTEwsIFFNX01PRFVMRVMsIG1vZHVsZV9uYW1lcywgYnVmc2l6ZSwgJnJldCkpIHsKCQlpZiAoZXJybm8gPT0gRU5PU1BDICYmIGJ1ZnNpemUgPCByZXQpIHsKCQkJYnVmc2l6ZSA9IHJldDsKCQkJbW9kdWxlX25hbWVzID0geHJlYWxsb2MobW9kdWxlX25hbWVzLCBidWZzaXplKTsKCQkJZ290byByZXRyeV9tb2R1bGVzX2xvYWQ7CgkJfQoJCWJiX3NpbXBsZV9wZXJyb3JfbXNnX2FuZF9kaWUoIlFNX01PRFVMRVMiKTsKCX0KCgluX2V4dF9tb2R1bGVzID0gbm1vZCA9IHJldDsKCgkvKiBDb2xsZWN0IHRoZSBtb2R1bGVzJyBzeW1ib2xzLiAgKi8KCglpZiAobm1vZCkgewoJCWV4dF9tb2R1bGVzID0gbW9kdWxlcyA9IHh6YWxsb2Mobm1vZCAqIHNpemVvZigqbW9kdWxlcykpOwoJCWZvciAoaSA9IDAsIG1uID0gbW9kdWxlX25hbWVzLCBtID0gbW9kdWxlczsKCQkJCWkgPCBubW9kOyArK2ksICsrbSwgbW4gKz0gc3RybGVuKG1uKSArIDEpIHsKCQkJc3RydWN0IG5ld19tb2R1bGVfaW5mbyBpbmZvOwoKCQkJaWYgKHF1ZXJ5X21vZHVsZShtbiwgUU1fSU5GTywgJmluZm8sIHNpemVvZihpbmZvKSwgJnJldCkpIHsKCQkJCWlmIChlcnJubyA9PSBFTk9FTlQpIHsKCQkJCQkvKiBUaGUgbW9kdWxlIHdhcyByZW1vdmVkIG91dCBmcm9tIHVuZGVybmVhdGggdXMuICAqLwoJCQkJCWNvbnRpbnVlOwoJCQkJfQoJCQkJYmJfcGVycm9yX21zZ19hbmRfZGllKCJxdWVyeV9tb2R1bGU6IFFNX0lORk86ICVzIiwgbW4pOwoJCQl9CgoJCQlidWZzaXplID0gMTAyNDsKCQkJc3ltcyA9IHhtYWxsb2MoYnVmc2l6ZSk7CiByZXRyeV9tb2Rfc3ltX2xvYWQ6CgkJCWlmIChxdWVyeV9tb2R1bGUobW4sIFFNX1NZTUJPTFMsIHN5bXMsIGJ1ZnNpemUsICZyZXQpKSB7CgkJCQlzd2l0Y2ggKGVycm5vKSB7CgkJCQkJY2FzZSBFTk9TUEM6CgkJCQkJCWJ1ZnNpemUgPSByZXQ7CgkJCQkJCXN5bXMgPSB4cmVhbGxvYyhzeW1zLCBidWZzaXplKTsKCQkJCQkJZ290byByZXRyeV9tb2Rfc3ltX2xvYWQ7CgkJCQkJY2FzZSBFTk9FTlQ6CgkJCQkJCS8qIFRoZSBtb2R1bGUgd2FzIHJlbW92ZWQgb3V0IGZyb20gdW5kZXJuZWF0aCB1cy4gICovCgkJCQkJCWNvbnRpbnVlOwoJCQkJCWRlZmF1bHQ6CgkJCQkJCWJiX3BlcnJvcl9tc2dfYW5kX2RpZSgicXVlcnlfbW9kdWxlOiBRTV9TWU1CT0xTOiAlcyIsIG1uKTsKCQkJCX0KCQkJfQoJCQluc3ltcyA9IHJldDsKCgkJCW0tPm5hbWUgPSBtbjsKCQkJbS0+YWRkciA9IGluZm8uYWRkcjsKCQkJbS0+bnN5bXMgPSBuc3ltczsKCQkJbS0+c3ltcyA9IHN5bXM7CgoJCQlmb3IgKGogPSAwLCBzID0gc3ltczsgaiA8IG5zeW1zOyArK2osICsrcykgewoJCQkJcy0+bmFtZSArPSAodW5zaWduZWQgbG9uZykgc3ltczsKCQkJfQoJCX0KCX0KCgkvKiBDb2xsZWN0IHRoZSBrZXJuZWwncyBzeW1ib2xzLiAgKi8KCglidWZzaXplID0gMTYgKiAxMDI0OwoJc3ltcyA9IHhtYWxsb2MoYnVmc2l6ZSk7CiByZXRyeV9rZXJuX3N5bV9sb2FkOgoJaWYgKHF1ZXJ5X21vZHVsZShOVUxMLCBRTV9TWU1CT0xTLCBzeW1zLCBidWZzaXplLCAmcmV0KSkgewoJCWlmIChlcnJubyA9PSBFTk9TUEMgJiYgYnVmc2l6ZSA8IHJldCkgewoJCQlidWZzaXplID0gcmV0OwoJCQlzeW1zID0geHJlYWxsb2Moc3ltcywgYnVmc2l6ZSk7CgkJCWdvdG8gcmV0cnlfa2Vybl9zeW1fbG9hZDsKCQl9CgkJYmJfc2ltcGxlX3BlcnJvcl9tc2dfYW5kX2RpZSgia2VybmVsOiBRTV9TWU1CT0xTIik7Cgl9Cglua3N5bXMgPSBuc3ltcyA9IHJldDsKCWtzeW1zID0gc3ltczsKCglmb3IgKGogPSAwLCBzID0gc3ltczsgaiA8IG5zeW1zOyArK2osICsrcykgewoJCXMtPm5hbWUgKz0gKHVuc2lnbmVkIGxvbmcpIHN5bXM7Cgl9Cn0KCgovKiBSZXR1cm4gdGhlIGtlcm5lbCBzeW1ib2wgY2hlY2tzdW0gdmVyc2lvbiwgb3IgemVybyBpZiBub3QgdXNlZC4gICovCgpzdGF0aWMgaW50IG5ld19pc19rZXJuZWxfY2hlY2tzdW1tZWQodm9pZCkKewoJc3RydWN0IG5ld19tb2R1bGVfc3ltYm9sICpzOwoJc2l6ZV90IGk7CgoJLyogVXNpbmdfVmVyc2lvbnMgaXMgbm90IHRoZSBmaXJzdCBzeW1ib2wsIGJ1dCBpdCBzaG91bGQgYmUgaW4gdGhlcmUuICAqLwoKCWZvciAoaSA9IDAsIHMgPSBrc3ltczsgaSA8IG5rc3ltczsgKytpLCArK3MpCgkJaWYgKHN0cmNtcCgoY2hhciAqKSBzLT5uYW1lLCAiVXNpbmdfVmVyc2lvbnMiKSA9PSAwKQoJCQlyZXR1cm4gcy0+dmFsdWU7CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgdm9pZCBuZXdfY3JlYXRlX3RoaXNfbW9kdWxlKHN0cnVjdCBvYmpfZmlsZSAqZiwgY29uc3QgY2hhciAqbV9uYW1lKQp7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCglzZWMgPSBvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbl9maXJzdChmLCAiLnRoaXMiLCB0Z3Rfc2l6ZW9mX2xvbmcsCgkJCXNpemVvZihzdHJ1Y3QgbmV3X21vZHVsZSkpOwoJLyogZG9uZSBieSBvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbl9maXJzdDogKi8KCS8qbWVtc2V0KHNlYy0+Y29udGVudHMsIDAsIHNpemVvZihzdHJ1Y3QgbmV3X21vZHVsZSkpOyovCgoJb2JqX2FkZF9zeW1ib2woZiwgU1BGWCAiX190aGlzX21vZHVsZSIsIC0xLAoJCQlFTEZfU1RfSU5GTyhTVEJfTE9DQUwsIFNUVF9PQkpFQ1QpLCBzZWMtPmlkeCwgMCwKCQkJc2l6ZW9mKHN0cnVjdCBuZXdfbW9kdWxlKSk7CgoJb2JqX3N0cmluZ19wYXRjaChmLCBzZWMtPmlkeCwgb2Zmc2V0b2Yoc3RydWN0IG5ld19tb2R1bGUsIG5hbWUpLAoJCQltX25hbWUpOwp9CgojaWYgRU5BQkxFX0ZFQVRVUkVfSU5TTU9EX0tTWU1PT1BTX1NZTUJPTFMKLyogYWRkIGFuIGVudHJ5IHRvIHRoZSBfX2tzeW10YWIgc2VjdGlvbiwgY3JlYXRpbmcgaXQgaWYgbmVjZXNzYXJ5ICovCnN0YXRpYyB2b2lkIG5ld19hZGRfa3N5bXRhYihzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIHN0cnVjdCBvYmpfc3ltYm9sICpzeW0pCnsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwoJRWxmVyhBZGRyKSBvZnM7CgoJLyogZW5zdXJlIF9fa3N5bXRhYiBpcyBhbGxvY2F0ZWQsIEVYUE9SVF9OT1NZTUJPTFMgY3JlYXRlcyBhIG5vbi1hbGxvYyBzZWN0aW9uLgoJICogSWYgX19rc3ltdGFiIGlzIGRlZmluZWQgYnV0IG5vdCBtYXJrZWQgYWxsb2MsIHggb3V0IHRoZSBmaXJzdCBjaGFyYWN0ZXIKCSAqIChubyBvYmpfZGVsZXRlIHJvdXRpbmUpIGFuZCBjcmVhdGUgYSBuZXcgX19rc3ltdGFiIHdpdGggdGhlIGNvcnJlY3QKCSAqIGNoYXJhY3RlcmlzdGljcy4KCSAqLwoJc2VjID0gb2JqX2ZpbmRfc2VjdGlvbihmLCAiX19rc3ltdGFiIik7CglpZiAoc2VjICYmICEoc2VjLT5oZWFkZXIuc2hfZmxhZ3MgJiBTSEZfQUxMT0MpKSB7CgkJKigoY2hhciAqKShzZWMtPm5hbWUpKSA9ICd4JzsJLyogb3ZlcnJpZGUgY29uc3QgKi8KCQlzZWMgPSBOVUxMOwoJfQoJaWYgKCFzZWMpCgkJc2VjID0gb2JqX2NyZWF0ZV9hbGxvY2VkX3NlY3Rpb24oZiwgIl9fa3N5bXRhYiIsCgkJCQl0Z3Rfc2l6ZW9mX3ZvaWRfcCwgMCk7CglpZiAoIXNlYykKCQlyZXR1cm47CglzZWMtPmhlYWRlci5zaF9mbGFncyB8PSBTSEZfQUxMT0M7CgkvKiBFbXB0eSBzZWN0aW9uIG1pZ2h0IGJlIGJ5dGUtYWxpZ25lZCAqLwoJc2VjLT5oZWFkZXIuc2hfYWRkcmFsaWduID0gdGd0X3NpemVvZl92b2lkX3A7CglvZnMgPSBzZWMtPmhlYWRlci5zaF9zaXplOwoJb2JqX3N5bWJvbF9wYXRjaChmLCBzZWMtPmlkeCwgb2ZzLCBzeW0pOwoJb2JqX3N0cmluZ19wYXRjaChmLCBzZWMtPmlkeCwgb2ZzICsgdGd0X3NpemVvZl92b2lkX3AsIHN5bS0+bmFtZSk7CglvYmpfZXh0ZW5kX3NlY3Rpb24oc2VjLCAyICogdGd0X3NpemVvZl9jaGFyX3ApOwp9CiNlbmRpZiAvKiBGRUFUVVJFX0lOU01PRF9LU1lNT09QU19TWU1CT0xTICovCgpzdGF0aWMgaW50IG5ld19jcmVhdGVfbW9kdWxlX2tzeW10YWIoc3RydWN0IG9ial9maWxlICpmKQp7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCWludCBpOwoKCS8qIFdlIG11c3QgYWx3YXlzIGFkZCB0aGUgbW9kdWxlIHJlZmVyZW5jZXMuICAqLwoKCWlmIChuX2V4dF9tb2R1bGVzX3VzZWQpIHsKCQlzdHJ1Y3QgbmV3X21vZHVsZV9yZWYgKmRlcDsKCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqdG07CgoJCXNlYyA9IG9ial9jcmVhdGVfYWxsb2NlZF9zZWN0aW9uKGYsICIua21vZHRhYiIsIHRndF9zaXplb2Zfdm9pZF9wLAoJCQkJKHNpemVvZihzdHJ1Y3QgbmV3X21vZHVsZV9yZWYpCgkJCQkgKiBuX2V4dF9tb2R1bGVzX3VzZWQpKTsKCQlpZiAoIXNlYykKCQkJcmV0dXJuIDA7CgoJCXRtID0gb2JqX2ZpbmRfc3ltYm9sKGYsIFNQRlggIl9fdGhpc19tb2R1bGUiKTsKCQlkZXAgPSAoc3RydWN0IG5ld19tb2R1bGVfcmVmICopIHNlYy0+Y29udGVudHM7CgkJZm9yIChpID0gMDsgaSA8IG5fZXh0X21vZHVsZXM7ICsraSkKCQkJaWYgKGV4dF9tb2R1bGVzW2ldLnVzZWQpIHsKCQkJCWRlcC0+ZGVwID0gZXh0X21vZHVsZXNbaV0uYWRkcjsKCQkJCW9ial9zeW1ib2xfcGF0Y2goZiwgc2VjLT5pZHgsCgkJCQkJCShjaGFyICopICZkZXAtPnJlZiAtIHNlYy0+Y29udGVudHMsIHRtKTsKCQkJCWRlcC0+bmV4dF9yZWYgPSAwOwoJCQkJKytkZXA7CgkJCX0KCX0KCglpZiAoIWZsYWdfbm9leHBvcnQgJiYgIW9ial9maW5kX3NlY3Rpb24oZiwgIl9fa3N5bXRhYiIpKSB7CgkJc2l6ZV90IG5zeW1zOwoJCWludCAqbG9hZGVkOwoKCQlzZWMgPSBvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbihmLCAiX19rc3ltdGFiIiwgdGd0X3NpemVvZl92b2lkX3AsIDApOwoKCQkvKiBXZSBkb24ndCB3YW50IHRvIGV4cG9ydCBzeW1ib2xzIHJlc2lkaW5nIGluIHNlY3Rpb25zIHRoYXQKCQkgICBhcmVuJ3QgbG9hZGVkLiAgVGhlcmUgYXJlIGEgbnVtYmVyIG9mIHRoZXNlIGNyZWF0ZWQgc28gdGhhdAoJCSAgIHdlIG1ha2Ugc3VyZSBjZXJ0YWluIG1vZHVsZSBvcHRpb25zIGRvbid0IGFwcGVhciB0d2ljZS4gICovCgkJaSA9IGYtPmhlYWRlci5lX3NobnVtOwoJCWxvYWRlZCA9IGFsbG9jYShzaXplb2YoaW50KSAqIGkpOwoJCXdoaWxlICgtLWkgPj0gMCkKCQkJbG9hZGVkW2ldID0gKGYtPnNlY3Rpb25zW2ldLT5oZWFkZXIuc2hfZmxhZ3MgJiBTSEZfQUxMT0MpICE9IDA7CgoJCWZvciAobnN5bXMgPSBpID0gMDsgaSA8IEhBU0hfQlVDS0VUUzsgKytpKSB7CgkJCXN0cnVjdCBvYmpfc3ltYm9sICpzeW07CgkJCWZvciAoc3ltID0gZi0+c3ltdGFiW2ldOyBzeW07IHN5bSA9IHN5bS0+bmV4dCkgewoJCQkJaWYgKEVMRl9TVF9CSU5EKHN5bS0+aW5mbykgIT0gU1RCX0xPQ0FMCgkJCQkgJiYgc3ltLT5zZWNpZHggPD0gU0hOX0hJUkVTRVJWRQoJCQkJICYmIChzeW0tPnNlY2lkeCA+PSBTSE5fTE9SRVNFUlZFIHx8IGxvYWRlZFtzeW0tPnNlY2lkeF0pCgkJCQkpIHsKCQkJCQlFbGZXKEFkZHIpIG9mcyA9IG5zeW1zICogMiAqIHRndF9zaXplb2Zfdm9pZF9wOwoKCQkJCQlvYmpfc3ltYm9sX3BhdGNoKGYsIHNlYy0+aWR4LCBvZnMsIHN5bSk7CgkJCQkJb2JqX3N0cmluZ19wYXRjaChmLCBzZWMtPmlkeCwgb2ZzICsgdGd0X3NpemVvZl92b2lkX3AsCgkJCQkJCQlzeW0tPm5hbWUpOwoJCQkJCW5zeW1zKys7CgkJCQl9CgkJCX0KCQl9CgoJCW9ial9leHRlbmRfc2VjdGlvbihzZWMsIG5zeW1zICogMiAqIHRndF9zaXplb2ZfY2hhcl9wKTsKCX0KCglyZXR1cm4gMTsKfQoKCnN0YXRpYyBpbnQKbmV3X2luaXRfbW9kdWxlKGNvbnN0IGNoYXIgKm1fbmFtZSwgc3RydWN0IG9ial9maWxlICpmLCB1bnNpZ25lZCBsb25nIG1fc2l6ZSkKewoJc3RydWN0IG5ld19tb2R1bGUgKm1vZHVsZTsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwoJdm9pZCAqaW1hZ2U7CglpbnQgcmV0OwoJdGd0X2xvbmcgbV9hZGRyOwoKCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi50aGlzIik7CglpZiAoIXNlYyB8fCAhc2VjLT5jb250ZW50cykgewoJCWJiX3BlcnJvcl9tc2dfYW5kX2RpZSgiY29ycnVwdCBtb2R1bGUgJXM/IiwgbV9uYW1lKTsKCX0KCW1vZHVsZSA9IChzdHJ1Y3QgbmV3X21vZHVsZSAqKSBzZWMtPmNvbnRlbnRzOwoJbV9hZGRyID0gc2VjLT5oZWFkZXIuc2hfYWRkcjsKCgltb2R1bGUtPnNpemVfb2Zfc3RydWN0ID0gc2l6ZW9mKCptb2R1bGUpOwoJbW9kdWxlLT5zaXplID0gbV9zaXplOwoJbW9kdWxlLT5mbGFncyA9IGZsYWdfYXV0b2NsZWFuID8gTkVXX01PRF9BVVRPQ0xFQU4gOiAwOwoKCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIl9fa3N5bXRhYiIpOwoJaWYgKHNlYyAmJiBzZWMtPmhlYWRlci5zaF9zaXplKSB7CgkJbW9kdWxlLT5zeW1zID0gc2VjLT5oZWFkZXIuc2hfYWRkcjsKCQltb2R1bGUtPm5zeW1zID0gc2VjLT5oZWFkZXIuc2hfc2l6ZSAvICgyICogdGd0X3NpemVvZl9jaGFyX3ApOwoJfQoKCWlmIChuX2V4dF9tb2R1bGVzX3VzZWQpIHsKCQlzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsICIua21vZHRhYiIpOwoJCW1vZHVsZS0+ZGVwcyA9IHNlYy0+aGVhZGVyLnNoX2FkZHI7CgkJbW9kdWxlLT5uZGVwcyA9IG5fZXh0X21vZHVsZXNfdXNlZDsKCX0KCgltb2R1bGUtPmluaXQgPSBvYmpfc3ltYm9sX2ZpbmFsX3ZhbHVlKGYsIG9ial9maW5kX3N5bWJvbChmLCBTUEZYICJpbml0X21vZHVsZSIpKTsKCW1vZHVsZS0+Y2xlYW51cCA9IG9ial9zeW1ib2xfZmluYWxfdmFsdWUoZiwgb2JqX2ZpbmRfc3ltYm9sKGYsIFNQRlggImNsZWFudXBfbW9kdWxlIikpOwoKCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIl9fZXhfdGFibGUiKTsKCWlmIChzZWMpIHsKCQltb2R1bGUtPmV4X3RhYmxlX3N0YXJ0ID0gc2VjLT5oZWFkZXIuc2hfYWRkcjsKCQltb2R1bGUtPmV4X3RhYmxlX2VuZCA9IHNlYy0+aGVhZGVyLnNoX2FkZHIgKyBzZWMtPmhlYWRlci5zaF9zaXplOwoJfQoKCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi50ZXh0LmluaXQiKTsKCWlmIChzZWMpIHsKCQltb2R1bGUtPnJ1bnNpemUgPSBzZWMtPmhlYWRlci5zaF9hZGRyIC0gbV9hZGRyOwoJfQoJc2VjID0gb2JqX2ZpbmRfc2VjdGlvbihmLCAiLmRhdGEuaW5pdCIpOwoJaWYgKHNlYykgewoJCWlmICghbW9kdWxlLT5ydW5zaXplCgkJIHx8IG1vZHVsZS0+cnVuc2l6ZSA+IHNlYy0+aGVhZGVyLnNoX2FkZHIgLSBtX2FkZHIKCQkpIHsKCQkJbW9kdWxlLT5ydW5zaXplID0gc2VjLT5oZWFkZXIuc2hfYWRkciAtIG1fYWRkcjsKCQl9Cgl9CglzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsIEFSQ0hEQVRBX1NFQ19OQU1FKTsKCWlmIChzZWMgJiYgc2VjLT5oZWFkZXIuc2hfc2l6ZSkgewoJCW1vZHVsZS0+YXJjaGRhdGFfc3RhcnQgPSAodm9pZCopc2VjLT5oZWFkZXIuc2hfYWRkcjsKCQltb2R1bGUtPmFyY2hkYXRhX2VuZCA9IG1vZHVsZS0+YXJjaGRhdGFfc3RhcnQgKyBzZWMtPmhlYWRlci5zaF9zaXplOwoJfQoJc2VjID0gb2JqX2ZpbmRfc2VjdGlvbihmLCBLQUxMU1lNU19TRUNfTkFNRSk7CglpZiAoc2VjICYmIHNlYy0+aGVhZGVyLnNoX3NpemUpIHsKCQltb2R1bGUtPmthbGxzeW1zX3N0YXJ0ID0gKHZvaWQqKXNlYy0+aGVhZGVyLnNoX2FkZHI7CgkJbW9kdWxlLT5rYWxsc3ltc19lbmQgPSBtb2R1bGUtPmthbGxzeW1zX3N0YXJ0ICsgc2VjLT5oZWFkZXIuc2hfc2l6ZTsKCX0KCgkvKiBXaGV3ISAgQWxsIG9mIHRoZSBpbml0aWFsaXphdGlvbiBpcyBjb21wbGV0ZS4gIENvbGxlY3QgdGhlIGZpbmFsCgkgICBtb2R1bGUgaW1hZ2UgYW5kIGdpdmUgaXQgdG8gdGhlIGtlcm5lbC4gICovCgoJaW1hZ2UgPSB4bWFsbG9jKG1fc2l6ZSk7CglvYmpfY3JlYXRlX2ltYWdlKGYsIGltYWdlKTsKCglyZXQgPSBpbml0X21vZHVsZShtX25hbWUsIChzdHJ1Y3QgbmV3X21vZHVsZSAqKSBpbWFnZSk7CglpZiAocmV0KQoJCWJiX3BlcnJvcl9tc2coImluaXRfbW9kdWxlOiAlcyIsIG1fbmFtZSk7CgoJZnJlZShpbWFnZSk7CgoJcmV0dXJuIHJldCA9PSAwOwp9CgoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCnN0YXRpYyB2b2lkCm9ial9zdHJpbmdfcGF0Y2goc3RydWN0IG9ial9maWxlICpmLCBpbnQgc2VjaWR4LCBFbGZXKEFkZHIpIG9mZnNldCwKCQkJCSBjb25zdCBjaGFyICpzdHJpbmcpCnsKCXN0cnVjdCBvYmpfc3RyaW5nX3BhdGNoICpwOwoJc3RydWN0IG9ial9zZWN0aW9uICpzdHJzZWM7CglzaXplX3QgbGVuID0gc3RybGVuKHN0cmluZykgKyAxOwoJY2hhciAqbG9jOwoKCXAgPSB4emFsbG9jKHNpemVvZigqcCkpOwoJcC0+bmV4dCA9IGYtPnN0cmluZ19wYXRjaGVzOwoJcC0+cmVsb2Nfc2VjaWR4ID0gc2VjaWR4OwoJcC0+cmVsb2Nfb2Zmc2V0ID0gb2Zmc2V0OwoJZi0+c3RyaW5nX3BhdGNoZXMgPSBwOwoKCXN0cnNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi5rc3RydGFiIik7CglpZiAoc3Ryc2VjID09IE5VTEwpIHsKCQlzdHJzZWMgPSBvYmpfY3JlYXRlX2FsbG9jZWRfc2VjdGlvbihmLCAiLmtzdHJ0YWIiLCAxLCBsZW4pOwoJCS8qcC0+c3RyaW5nX29mZnNldCA9IDA7Ki8KCQlsb2MgPSBzdHJzZWMtPmNvbnRlbnRzOwoJfSBlbHNlIHsKCQlwLT5zdHJpbmdfb2Zmc2V0ID0gc3Ryc2VjLT5oZWFkZXIuc2hfc2l6ZTsKCQlsb2MgPSBvYmpfZXh0ZW5kX3NlY3Rpb24oc3Ryc2VjLCBsZW4pOwoJfQoJbWVtY3B5KGxvYywgc3RyaW5nLCBsZW4pOwp9CgpzdGF0aWMgdm9pZApvYmpfc3ltYm9sX3BhdGNoKHN0cnVjdCBvYmpfZmlsZSAqZiwgaW50IHNlY2lkeCwgRWxmVyhBZGRyKSBvZmZzZXQsCgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bSkKewoJc3RydWN0IG9ial9zeW1ib2xfcGF0Y2ggKnA7CgoJcCA9IHhtYWxsb2Moc2l6ZW9mKCpwKSk7CglwLT5uZXh0ID0gZi0+c3ltYm9sX3BhdGNoZXM7CglwLT5yZWxvY19zZWNpZHggPSBzZWNpZHg7CglwLT5yZWxvY19vZmZzZXQgPSBvZmZzZXQ7CglwLT5zeW0gPSBzeW07CglmLT5zeW1ib2xfcGF0Y2hlcyA9IHA7Cn0KCnN0YXRpYyB2b2lkIG9ial9jaGVja191bmRlZmluZWRzKHN0cnVjdCBvYmpfZmlsZSAqZikKewoJdW5zaWduZWQgaTsKCglmb3IgKGkgPSAwOyBpIDwgSEFTSF9CVUNLRVRTOyArK2kpIHsKCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwoJCWZvciAoc3ltID0gZi0+c3ltdGFiW2ldOyBzeW07IHN5bSA9IHN5bS0+bmV4dCkgewoJCQlpZiAoc3ltLT5zZWNpZHggPT0gU0hOX1VOREVGKSB7CgkJCQlpZiAoRUxGX1NUX0JJTkQoc3ltLT5pbmZvKSA9PSBTVEJfV0VBSykgewoJCQkJCXN5bS0+c2VjaWR4ID0gU0hOX0FCUzsKCQkJCQlzeW0tPnZhbHVlID0gMDsKCQkJCX0gZWxzZSB7CgkJCQkJaWYgKCFmbGFnX3F1aWV0KQoJCQkJCQliYl9lcnJvcl9tc2dfYW5kX2RpZSgidW5yZXNvbHZlZCBzeW1ib2wgJXMiLCBzeW0tPm5hbWUpOwoJCQkJfQoJCQl9CgkJfQoJfQp9CgpzdGF0aWMgdm9pZCBvYmpfYWxsb2NhdGVfY29tbW9ucyhzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCXN0cnVjdCBjb21tb25fZW50cnkgewoJCXN0cnVjdCBjb21tb25fZW50cnkgKm5leHQ7CgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCX0gKmNvbW1vbl9oZWFkID0gTlVMTDsKCgl1bnNpZ25lZCBsb25nIGk7CgoJZm9yIChpID0gMDsgaSA8IEhBU0hfQlVDS0VUUzsgKytpKSB7CgkJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCQlmb3IgKHN5bSA9IGYtPnN5bXRhYltpXTsgc3ltOyBzeW0gPSBzeW0tPm5leHQpIHsKCQkJaWYgKHN5bS0+c2VjaWR4ID09IFNITl9DT01NT04pIHsKCQkJCS8qIENvbGxlY3QgYWxsIENPTU1PTiBzeW1ib2xzIGFuZCBzb3J0IHRoZW0gYnkgc2l6ZSBzbyBhcyB0bwoJCQkJICAgbWluaW1pemUgc3BhY2Ugd2FzdGVkIGJ5IGFsaWdubWVudCByZXF1aXJlbWVudHMuICAqLwoJCQkJc3RydWN0IGNvbW1vbl9lbnRyeSAqKnAsICpuOwoJCQkJZm9yIChwID0gJmNvbW1vbl9oZWFkOyAqcDsgcCA9ICYoKnApLT5uZXh0KQoJCQkJCWlmIChzeW0tPnNpemUgPD0gKCpwKS0+c3ltLT5zaXplKQoJCQkJCQlicmVhazsKCQkJCW4gPSBhbGxvY2Eoc2l6ZW9mKCpuKSk7CgkJCQluLT5uZXh0ID0gKnA7CgkJCQluLT5zeW0gPSBzeW07CgkJCQkqcCA9IG47CgkJCX0KCQl9Cgl9CgoJZm9yIChpID0gMTsgaSA8IGYtPmxvY2FsX3N5bXRhYl9zaXplOyArK2kpIHsKCQlzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltID0gZi0+bG9jYWxfc3ltdGFiW2ldOwoJCWlmIChzeW0gJiYgc3ltLT5zZWNpZHggPT0gU0hOX0NPTU1PTikgewoJCQlzdHJ1Y3QgY29tbW9uX2VudHJ5ICoqcCwgKm47CgkJCWZvciAocCA9ICZjb21tb25faGVhZDsgKnA7IHAgPSAmKCpwKS0+bmV4dCkgewoJCQkJaWYgKHN5bSA9PSAoKnApLT5zeW0pCgkJCQkJYnJlYWs7CgkJCQlpZiAoc3ltLT5zaXplIDwgKCpwKS0+c3ltLT5zaXplKSB7CgkJCQkJbiA9IGFsbG9jYShzaXplb2YoKm4pKTsKCQkJCQluLT5uZXh0ID0gKnA7CgkJCQkJbi0+c3ltID0gc3ltOwoJCQkJCSpwID0gbjsKCQkJCQlicmVhazsKCQkJCX0KCQkJfQoJCX0KCX0KCglpZiAoY29tbW9uX2hlYWQpIHsKCQkvKiBGaW5kIHRoZSBic3Mgc2VjdGlvbi4gICovCgkJZm9yIChpID0gMDsgaSA8IGYtPmhlYWRlci5lX3NobnVtOyArK2kpCgkJCWlmIChmLT5zZWN0aW9uc1tpXS0+aGVhZGVyLnNoX3R5cGUgPT0gU0hUX05PQklUUykKCQkJCWJyZWFrOwoKCQkvKiBJZiBmb3Igc29tZSByZWFzb24gdGhlcmUgaGFkbid0IGJlZW4gb25lLCBjcmVhdGUgb25lLiAgKi8KCQlpZiAoaSA9PSBmLT5oZWFkZXIuZV9zaG51bSkgewoJCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCgkJCWYtPmhlYWRlci5lX3NobnVtKys7CgkJCWYtPnNlY3Rpb25zID0geHJlYWxsb2NfdmVjdG9yKGYtPnNlY3Rpb25zLCAyLCBpKTsKCQkJZi0+c2VjdGlvbnNbaV0gPSBzZWMgPSBhcmNoX25ld19zZWN0aW9uKCk7CgoJCQlzZWMtPmhlYWRlci5zaF90eXBlID0gU0hUX1BST0dCSVRTOwoJCQlzZWMtPmhlYWRlci5zaF9mbGFncyA9IFNIRl9XUklURSB8IFNIRl9BTExPQzsKCQkJc2VjLT5uYW1lID0gIi5ic3MiOwoJCQlzZWMtPmlkeCA9IGk7CgkJfQoKCQkvKiBBbGxvY2F0ZSB0aGUgQ09NTU9OUy4gICovCgkJewoJCQlFbGZXKEFkZHIpIGJzc19zaXplID0gZi0+c2VjdGlvbnNbaV0tPmhlYWRlci5zaF9zaXplOwoJCQlFbGZXKEFkZHIpIG1heF9hbGlnbiA9IGYtPnNlY3Rpb25zW2ldLT5oZWFkZXIuc2hfYWRkcmFsaWduOwoJCQlzdHJ1Y3QgY29tbW9uX2VudHJ5ICpjOwoKCQkJZm9yIChjID0gY29tbW9uX2hlYWQ7IGM7IGMgPSBjLT5uZXh0KSB7CgkJCQlFbGZXKEFkZHIpIGFsaWduID0gYy0+c3ltLT52YWx1ZTsKCgkJCQlpZiAoYWxpZ24gPiBtYXhfYWxpZ24pCgkJCQkJbWF4X2FsaWduID0gYWxpZ247CgkJCQlpZiAoYnNzX3NpemUgJiAoYWxpZ24gLSAxKSkKCQkJCQlic3Nfc2l6ZSA9IChic3Nfc2l6ZSB8IChhbGlnbiAtIDEpKSArIDE7CgoJCQkJYy0+c3ltLT5zZWNpZHggPSBpOwoJCQkJYy0+c3ltLT52YWx1ZSA9IGJzc19zaXplOwoKCQkJCWJzc19zaXplICs9IGMtPnN5bS0+c2l6ZTsKCQkJfQoKCQkJZi0+c2VjdGlvbnNbaV0tPmhlYWRlci5zaF9zaXplID0gYnNzX3NpemU7CgkJCWYtPnNlY3Rpb25zW2ldLT5oZWFkZXIuc2hfYWRkcmFsaWduID0gbWF4X2FsaWduOwoJCX0KCX0KCgkvKiBGb3IgdGhlIHNha2Ugb2YgcGF0Y2ggcmVsb2NhdGlvbiBhbmQgcGFyYW1ldGVyIGluaXRpYWxpemF0aW9uLAoJICAgYWxsb2NhdGUgemVyb2VkIGRhdGEgZm9yIE5PQklUUyBzZWN0aW9ucyBub3cuICBOb3RlIHRoYXQgYWZ0ZXIKCSAgIHRoaXMgd2UgY2Fubm90IGFzc3VtZSBOT0JJVFMgYXJlIHJlYWxseSBlbXB0eS4gICovCglmb3IgKGkgPSAwOyBpIDwgZi0+aGVhZGVyLmVfc2hudW07ICsraSkgewoJCXN0cnVjdCBvYmpfc2VjdGlvbiAqcyA9IGYtPnNlY3Rpb25zW2ldOwoJCWlmIChzLT5oZWFkZXIuc2hfdHlwZSA9PSBTSFRfTk9CSVRTKSB7CgkJCXMtPmNvbnRlbnRzID0gTlVMTDsKCQkJaWYgKHMtPmhlYWRlci5zaF9zaXplICE9IDApCgkJCQlzLT5jb250ZW50cyA9IHh6YWxsb2Mocy0+aGVhZGVyLnNoX3NpemUpOwoJCQlzLT5oZWFkZXIuc2hfdHlwZSA9IFNIVF9QUk9HQklUUzsKCQl9Cgl9Cn0KCnN0YXRpYyB1bnNpZ25lZCBsb25nIG9ial9sb2FkX3NpemUoc3RydWN0IG9ial9maWxlICpmKQp7Cgl1bnNpZ25lZCBsb25nIGRvdCA9IDA7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCgkvKiBGaW5hbGl6ZSB0aGUgcG9zaXRpb25zIG9mIHRoZSBzZWN0aW9ucyByZWxhdGl2ZSB0byBvbmUgYW5vdGhlci4gICovCgoJZm9yIChzZWMgPSBmLT5sb2FkX29yZGVyOyBzZWM7IHNlYyA9IHNlYy0+bG9hZF9uZXh0KSB7CgkJRWxmVyhBZGRyKSBhbGlnbjsKCgkJYWxpZ24gPSBzZWMtPmhlYWRlci5zaF9hZGRyYWxpZ247CgkJaWYgKGFsaWduICYmIChkb3QgJiAoYWxpZ24gLSAxKSkpCgkJCWRvdCA9IChkb3QgfCAoYWxpZ24gLSAxKSkgKyAxOwoKCQlzZWMtPmhlYWRlci5zaF9hZGRyID0gZG90OwoJCWRvdCArPSBzZWMtPmhlYWRlci5zaF9zaXplOwoJfQoKCXJldHVybiBkb3Q7Cn0KCnN0YXRpYyBpbnQgb2JqX3JlbG9jYXRlKHN0cnVjdCBvYmpfZmlsZSAqZiwgRWxmVyhBZGRyKSBiYXNlKQp7CglpbnQgaSwgbiA9IGYtPmhlYWRlci5lX3NobnVtOwoJaW50IHJldCA9IDE7CgoJLyogRmluYWxpemUgdGhlIGFkZHJlc3NlcyBvZiB0aGUgc2VjdGlvbnMuICAqLwoKCWYtPmJhc2VhZGRyID0gYmFzZTsKCWZvciAoaSA9IDA7IGkgPCBuOyArK2kpCgkJZi0+c2VjdGlvbnNbaV0tPmhlYWRlci5zaF9hZGRyICs9IGJhc2U7CgoJLyogQW5kIGl0ZXJhdGUgb3ZlciBhbGwgb2YgdGhlIHJlbG9jYXRpb25zLiAgKi8KCglmb3IgKGkgPSAwOyBpIDwgbjsgKytpKSB7CgkJc3RydWN0IG9ial9zZWN0aW9uICpyZWxzZWMsICpzeW1zZWMsICp0YXJnc2VjLCAqc3Ryc2VjOwoJCUVsZlcoUmVsTSkgKiByZWwsICpyZWxlbmQ7CgkJRWxmVyhTeW0pICogc3ltdGFiOwoJCWNvbnN0IGNoYXIgKnN0cnRhYjsKCgkJcmVsc2VjID0gZi0+c2VjdGlvbnNbaV07CgkJaWYgKHJlbHNlYy0+aGVhZGVyLnNoX3R5cGUgIT0gU0hUX1JFTE0pCgkJCWNvbnRpbnVlOwoKCQlzeW1zZWMgPSBmLT5zZWN0aW9uc1tyZWxzZWMtPmhlYWRlci5zaF9saW5rXTsKCQl0YXJnc2VjID0gZi0+c2VjdGlvbnNbcmVsc2VjLT5oZWFkZXIuc2hfaW5mb107CgkJc3Ryc2VjID0gZi0+c2VjdGlvbnNbc3ltc2VjLT5oZWFkZXIuc2hfbGlua107CgoJCXJlbCA9IChFbGZXKFJlbE0pICopIHJlbHNlYy0+Y29udGVudHM7CgkJcmVsZW5kID0gcmVsICsgKHJlbHNlYy0+aGVhZGVyLnNoX3NpemUgLyBzaXplb2YoRWxmVyhSZWxNKSkpOwoJCXN5bXRhYiA9IChFbGZXKFN5bSkgKikgc3ltc2VjLT5jb250ZW50czsKCQlzdHJ0YWIgPSAoY29uc3QgY2hhciAqKSBzdHJzZWMtPmNvbnRlbnRzOwoKCQlmb3IgKDsgcmVsIDwgcmVsZW5kOyArK3JlbCkgewoJCQlFbGZXKEFkZHIpIHZhbHVlID0gMDsKCQkJc3RydWN0IG9ial9zeW1ib2wgKmludHN5bSA9IE5VTEw7CgkJCXVuc2lnbmVkIGxvbmcgc3ltbmR4OwoJCQlFbGZXKFN5bSkgKmV4dHN5bSA9IE5VTEw7CgkJCWNvbnN0IGNoYXIgKmVycm1zZzsKCgkJCS8qIEF0dGVtcHQgdG8gZmluZCBhIHZhbHVlIHRvIHVzZSBmb3IgdGhpcyByZWxvY2F0aW9uLiAgKi8KCgkJCXN5bW5keCA9IEVMRl9SX1NZTShyZWwtPnJfaW5mbyk7CgkJCWlmIChzeW1uZHgpIHsKCQkJCS8qIE5vdGUgd2UndmUgYWxyZWFkeSBjaGVja2VkIGZvciB1bmRlZmluZWQgc3ltYm9scy4gICovCgoJCQkJZXh0c3ltID0gJnN5bXRhYltzeW1uZHhdOwoJCQkJaWYgKEVMRl9TVF9CSU5EKGV4dHN5bS0+c3RfaW5mbykgPT0gU1RCX0xPQ0FMKSB7CgkJCQkJLyogTG9jYWwgc3ltYm9scyB3ZSBsb29rIHVwIGluIHRoZSBsb2NhbCB0YWJsZSB0byBiZSBzdXJlCgkJCQkJICAgd2UgZ2V0IHRoZSBvbmUgdGhhdCBpcyByZWFsbHkgaW50ZW5kZWQuICAqLwoJCQkJCWludHN5bSA9IGYtPmxvY2FsX3N5bXRhYltzeW1uZHhdOwoJCQkJfSBlbHNlIHsKCQkJCQkvKiBPdGhlcnMgd2UgbG9vayB1cCBpbiB0aGUgaGFzaCB0YWJsZS4gICovCgkJCQkJY29uc3QgY2hhciAqbmFtZTsKCQkJCQlpZiAoZXh0c3ltLT5zdF9uYW1lKQoJCQkJCQluYW1lID0gc3RydGFiICsgZXh0c3ltLT5zdF9uYW1lOwoJCQkJCWVsc2UKCQkJCQkJbmFtZSA9IGYtPnNlY3Rpb25zW2V4dHN5bS0+c3Rfc2huZHhdLT5uYW1lOwoJCQkJCWludHN5bSA9IG9ial9maW5kX3N5bWJvbChmLCBuYW1lKTsKCQkJCX0KCgkJCQl2YWx1ZSA9IG9ial9zeW1ib2xfZmluYWxfdmFsdWUoZiwgaW50c3ltKTsKCQkJCWludHN5bS0+cmVmZXJlbmNlZCA9IDE7CgkJCX0KI2lmIFNIVF9SRUxNID09IFNIVF9SRUxBCiNpZiBkZWZpbmVkKF9fYWxwaGFfXykgJiYgZGVmaW5lZChBWFBfQlJPS0VOX0dBUykKCQkJLyogV29yayBhcm91bmQgYSBuYXN0eSBHQVMgYnVnLCB0aGF0IGlzIGZpeGVkIGFzIG9mIDIuNy4wLjkuICAqLwoJCQlpZiAoIWV4dHN5bSB8fCAhZXh0c3ltLT5zdF9uYW1lCgkJCSB8fCBFTEZfU1RfQklORChleHRzeW0tPnN0X2luZm8pICE9IFNUQl9MT0NBTCkKI2VuZGlmCgkJCQl2YWx1ZSArPSByZWwtPnJfYWRkZW5kOwojZW5kaWYKCgkJCS8qIERvIGl0ISAqLwoJCQlzd2l0Y2ggKGFyY2hfYXBwbHlfcmVsb2NhdGlvbgoJCQkJCShmLCB0YXJnc2VjLCAvKnN5bXNlYywqLyBpbnRzeW0sIHJlbCwgdmFsdWUpCgkJCSkgewoJCQljYXNlIG9ial9yZWxvY19vazoKCQkJCWJyZWFrOwoKCQkJY2FzZSBvYmpfcmVsb2Nfb3ZlcmZsb3c6CgkJCQllcnJtc2cgPSAiUmVsb2NhdGlvbiBvdmVyZmxvdyI7CgkJCQlnb3RvIGJhZF9yZWxvYzsKCQkJY2FzZSBvYmpfcmVsb2NfZGFuZ2Vyb3VzOgoJCQkJZXJybXNnID0gIkRhbmdlcm91cyByZWxvY2F0aW9uIjsKCQkJCWdvdG8gYmFkX3JlbG9jOwoJCQljYXNlIG9ial9yZWxvY191bmhhbmRsZWQ6CgkJCQllcnJtc2cgPSAiVW5oYW5kbGVkIHJlbG9jYXRpb24iOwpiYWRfcmVsb2M6CgkJCQlpZiAoZXh0c3ltKSB7CgkJCQkJYmJfZXJyb3JfbXNnKCIlcyBvZiB0eXBlICVsZCBmb3IgJXMiLCBlcnJtc2csCgkJCQkJCQkobG9uZykgRUxGX1JfVFlQRShyZWwtPnJfaW5mbyksCgkJCQkJCQlzdHJ0YWIgKyBleHRzeW0tPnN0X25hbWUpOwoJCQkJfSBlbHNlIHsKCQkJCQliYl9lcnJvcl9tc2coIiVzIG9mIHR5cGUgJWxkIiwgZXJybXNnLAoJCQkJCQkJKGxvbmcpIEVMRl9SX1RZUEUocmVsLT5yX2luZm8pKTsKCQkJCX0KCQkJCXJldCA9IDA7CgkJCQlicmVhazsKCQkJfQoJCX0KCX0KCgkvKiBGaW5hbGx5LCB0YWtlIGNhcmUgb2YgdGhlIHBhdGNoZXMuICAqLwoKCWlmIChmLT5zdHJpbmdfcGF0Y2hlcykgewoJCXN0cnVjdCBvYmpfc3RyaW5nX3BhdGNoICpwOwoJCXN0cnVjdCBvYmpfc2VjdGlvbiAqc3Ryc2VjOwoJCUVsZlcoQWRkcikgc3Ryc2VjX2Jhc2U7CgkJc3Ryc2VjID0gb2JqX2ZpbmRfc2VjdGlvbihmLCAiLmtzdHJ0YWIiKTsKCQlzdHJzZWNfYmFzZSA9IHN0cnNlYy0+aGVhZGVyLnNoX2FkZHI7CgoJCWZvciAocCA9IGYtPnN0cmluZ19wYXRjaGVzOyBwOyBwID0gcC0+bmV4dCkgewoJCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnRhcmdzZWMgPSBmLT5zZWN0aW9uc1twLT5yZWxvY19zZWNpZHhdOwoJCQkqKEVsZlcoQWRkcikgKikgKHRhcmdzZWMtPmNvbnRlbnRzICsgcC0+cmVsb2Nfb2Zmc2V0KQoJCQkJPSBzdHJzZWNfYmFzZSArIHAtPnN0cmluZ19vZmZzZXQ7CgkJfQoJfQoKCWlmIChmLT5zeW1ib2xfcGF0Y2hlcykgewoJCXN0cnVjdCBvYmpfc3ltYm9sX3BhdGNoICpwOwoKCQlmb3IgKHAgPSBmLT5zeW1ib2xfcGF0Y2hlczsgcDsgcCA9IHAtPm5leHQpIHsKCQkJc3RydWN0IG9ial9zZWN0aW9uICp0YXJnc2VjID0gZi0+c2VjdGlvbnNbcC0+cmVsb2Nfc2VjaWR4XTsKCQkJKihFbGZXKEFkZHIpICopICh0YXJnc2VjLT5jb250ZW50cyArIHAtPnJlbG9jX29mZnNldCkKCQkJCT0gb2JqX3N5bWJvbF9maW5hbF92YWx1ZShmLCBwLT5zeW0pOwoJCX0KCX0KCglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgaW50IG9ial9jcmVhdGVfaW1hZ2Uoc3RydWN0IG9ial9maWxlICpmLCBjaGFyICppbWFnZSkKewoJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CglFbGZXKEFkZHIpIGJhc2UgPSBmLT5iYXNlYWRkcjsKCglmb3IgKHNlYyA9IGYtPmxvYWRfb3JkZXI7IHNlYzsgc2VjID0gc2VjLT5sb2FkX25leHQpIHsKCQljaGFyICpzZWNpbWc7CgoJCWlmIChzZWMtPmNvbnRlbnRzID09IDAgfHwgc2VjLT5oZWFkZXIuc2hfc2l6ZSA9PSAwKQoJCQljb250aW51ZTsKCgkJc2VjaW1nID0gaW1hZ2UgKyAoc2VjLT5oZWFkZXIuc2hfYWRkciAtIGJhc2UpOwoKCQkvKiBOb3RlIHRoYXQgd2UgYWxsb2NhdGVkIGRhdGEgZm9yIE5PQklUUyBzZWN0aW9ucyBlYXJsaWVyLiAgKi8KCQltZW1jcHkoc2VjaW1nLCBzZWMtPmNvbnRlbnRzLCBzZWMtPmhlYWRlci5zaF9zaXplKTsKCX0KCglyZXR1cm4gMTsKfQoKLyo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ki8KCnN0YXRpYyBzdHJ1Y3Qgb2JqX2ZpbGUgKm9ial9sb2FkKGNoYXIgKmltYWdlLCBzaXplX3QgaW1hZ2Vfc2l6ZSwgaW50IGxvYWRwcm9nYml0cykKewoJdHlwZWRlZiB1aW50MzJfdCBhbGlhc2VkX3VpbnQzMl90IEZJWF9BTElBU0lORzsKI2lmIEJCX0xJVFRMRV9FTkRJQU4KIyBkZWZpbmUgRUxGTUFHX1UzMiAoKHVpbnQzMl90KShFTEZNQUcwICsgMHgxMDAgKiAoRUxGTUFHMSArICgweDEwMCAqIChFTEZNQUcyICsgMHgxMDAgKiBFTEZNQUczKSkpKSkKI2Vsc2UKIyBkZWZpbmUgRUxGTUFHX1UzMiAoKHVpbnQzMl90KSgoKChFTEZNQUcwICogMHgxMDApICsgRUxGTUFHMSkgKiAweDEwMCArIEVMRk1BRzIpICogMHgxMDAgKyBFTEZNQUczKSkKI2VuZGlmCglzdHJ1Y3Qgb2JqX2ZpbGUgKmY7CglFbGZXKFNoZHIpICogc2VjdGlvbl9oZWFkZXJzOwoJc2l6ZV90IHNobnVtLCBpOwoJY2hhciAqc2hzdHJ0YWI7CgoJLyogUmVhZCB0aGUgZmlsZSBoZWFkZXIuICAqLwoKCWYgPSBhcmNoX25ld19maWxlKCk7CglmLT5zeW1ib2xfY21wID0gc3RyY21wOwoJZi0+c3ltYm9sX2hhc2ggPSBvYmpfZWxmX2hhc2g7CglmLT5sb2FkX29yZGVyX3NlYXJjaF9zdGFydCA9ICZmLT5sb2FkX29yZGVyOwoKCWlmIChpbWFnZV9zaXplIDwgc2l6ZW9mKGYtPmhlYWRlcikpCgkJYmJfc2ltcGxlX2Vycm9yX21zZ19hbmRfZGllKCJlcnJvciB3aGlsZSBsb2FkaW5nIEVMRiBoZWFkZXIiKTsKCW1lbWNweSgmZi0+aGVhZGVyLCBpbWFnZSwgc2l6ZW9mKGYtPmhlYWRlcikpOwoKCWlmICgqKGFsaWFzZWRfdWludDMyX3QqKSgmZi0+aGVhZGVyLmVfaWRlbnQpICE9IEVMRk1BR19VMzIpIHsKCQliYl9zaW1wbGVfZXJyb3JfbXNnX2FuZF9kaWUoIm5vdCBhbiBFTEYgZmlsZSIpOwoJfQoJaWYgKGYtPmhlYWRlci5lX2lkZW50W0VJX0NMQVNTXSAhPSBFTEZDTEFTU00KCSB8fCBmLT5oZWFkZXIuZV9pZGVudFtFSV9EQVRBXSAhPSAoQkJfQklHX0VORElBTiA/IEVMRkRBVEEyTVNCIDogRUxGREFUQTJMU0IpCgkgfHwgZi0+aGVhZGVyLmVfaWRlbnRbRUlfVkVSU0lPTl0gIT0gRVZfQ1VSUkVOVAoJIHx8ICFNQVRDSF9NQUNISU5FKGYtPmhlYWRlci5lX21hY2hpbmUpCgkpIHsKCQliYl9zaW1wbGVfZXJyb3JfbXNnX2FuZF9kaWUoIkVMRiBmaWxlIG5vdCBmb3IgdGhpcyBhcmNoaXRlY3R1cmUiKTsKCX0KCWlmIChmLT5oZWFkZXIuZV90eXBlICE9IEVUX1JFTCkgewoJCWJiX3NpbXBsZV9lcnJvcl9tc2dfYW5kX2RpZSgiRUxGIGZpbGUgbm90IGEgcmVsb2NhdGFibGUgb2JqZWN0Iik7Cgl9CgoJLyogUmVhZCB0aGUgc2VjdGlvbiBoZWFkZXJzLiAgKi8KCglpZiAoZi0+aGVhZGVyLmVfc2hlbnRzaXplICE9IHNpemVvZihFbGZXKFNoZHIpKSkgewoJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJzZWN0aW9uIGhlYWRlciBzaXplIG1pc21hdGNoOiAlbHUgIT0gJWx1IiwKCQkJCSh1bnNpZ25lZCBsb25nKSBmLT5oZWFkZXIuZV9zaGVudHNpemUsCgkJCQkodW5zaWduZWQgbG9uZykgc2l6ZW9mKEVsZlcoU2hkcikpKTsKCX0KCglzaG51bSA9IGYtPmhlYWRlci5lX3NobnVtOwoJLyogR3Jvd3RoIG9mIC0+c2VjdGlvbnMgdmVjdG9yIHdpbGwgYmUgZG9uZSBieQoJICogeHJlYWxsb2NfdmVjdG9yKC4uLiwgMiwgLi4uKSwgdGhlcmVmb3JlIHdlIG11c3QgYWxsb2NhdGUKCSAqIGF0IGxlYXN0IDJeMiA9IDQgZXh0cmEgZWxlbWVudHMgaGVyZS4gKi8KCWYtPnNlY3Rpb25zID0geHphbGxvYyhzaXplb2YoZi0+c2VjdGlvbnNbMF0pICogKHNobnVtICsgNCkpOwoKCXNlY3Rpb25faGVhZGVycyA9IGFsbG9jYShzaXplb2YoRWxmVyhTaGRyKSkgKiBzaG51bSk7CglpZiAoaW1hZ2Vfc2l6ZSA8IGYtPmhlYWRlci5lX3Nob2ZmICsgc2l6ZW9mKEVsZlcoU2hkcikpICogc2hudW0pCgkJYmJfc2ltcGxlX2Vycm9yX21zZ19hbmRfZGllKCJlcnJvciB3aGlsZSBsb2FkaW5nIHNlY3Rpb24gaGVhZGVycyIpOwoJbWVtY3B5KHNlY3Rpb25faGVhZGVycywgaW1hZ2UgKyBmLT5oZWFkZXIuZV9zaG9mZiwgc2l6ZW9mKEVsZlcoU2hkcikpICogc2hudW0pOwoKCS8qIFJlYWQgdGhlIHNlY3Rpb24gZGF0YS4gICovCgoJZm9yIChpID0gMDsgaSA8IHNobnVtOyArK2kpIHsKCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYzsKCgkJZi0+c2VjdGlvbnNbaV0gPSBzZWMgPSBhcmNoX25ld19zZWN0aW9uKCk7CgoJCXNlYy0+aGVhZGVyID0gc2VjdGlvbl9oZWFkZXJzW2ldOwoJCXNlYy0+aWR4ID0gaTsKCgkJaWYgKHNlYy0+aGVhZGVyLnNoX3NpemUpIHsKCQkJc3dpdGNoIChzZWMtPmhlYWRlci5zaF90eXBlKSB7CgkJCWNhc2UgU0hUX05VTEw6CgkJCWNhc2UgU0hUX05PVEU6CgkJCWNhc2UgU0hUX05PQklUUzoKCQkJCS8qIGlnbm9yZSAqLwoJCQkJYnJlYWs7CgkJCWNhc2UgU0hUX1BST0dCSVRTOgojaWYgTE9BREJJVFMKCQkJCWlmICghbG9hZHByb2diaXRzKSB7CgkJCQkJc2VjLT5jb250ZW50cyA9IE5VTEw7CgkJCQkJYnJlYWs7CgkJCQl9CiNlbmRpZgoJCQljYXNlIFNIVF9TWU1UQUI6CgkJCWNhc2UgU0hUX1NUUlRBQjoKCQkJY2FzZSBTSFRfUkVMTToKI2lmIGRlZmluZWQoX19taXBzX18pCgkJCWNhc2UgU0hUX01JUFNfRFdBUkY6CiNlbmRpZgoJCQkJc2VjLT5jb250ZW50cyA9IE5VTEw7CgkJCQlpZiAoc2VjLT5oZWFkZXIuc2hfc2l6ZSA+IDApIHsKCQkJCQlzZWMtPmNvbnRlbnRzID0geG1hbGxvYyhzZWMtPmhlYWRlci5zaF9zaXplKTsKCQkJCQlpZiAoaW1hZ2Vfc2l6ZSA8IChzZWMtPmhlYWRlci5zaF9vZmZzZXQgKyBzZWMtPmhlYWRlci5zaF9zaXplKSkKCQkJCQkJYmJfc2ltcGxlX2Vycm9yX21zZ19hbmRfZGllKCJlcnJvciB3aGlsZSBsb2FkaW5nIHNlY3Rpb24gZGF0YSIpOwoJCQkJCW1lbWNweShzZWMtPmNvbnRlbnRzLCBpbWFnZSArIHNlYy0+aGVhZGVyLnNoX29mZnNldCwgc2VjLT5oZWFkZXIuc2hfc2l6ZSk7CgkJCQl9CgkJCQlicmVhazsKI2lmIFNIVF9SRUxNID09IFNIVF9SRUwKCQkJY2FzZSBTSFRfUkVMQToKCQkJCWJiX3NpbXBsZV9lcnJvcl9tc2dfYW5kX2RpZSgiUkVMQSByZWxvY2F0aW9ucyBub3Qgc3VwcG9ydGVkIG9uIHRoaXMgYXJjaGl0ZWN0dXJlIik7CiNlbHNlCgkJCWNhc2UgU0hUX1JFTDoKCQkJCWJiX3NpbXBsZV9lcnJvcl9tc2dfYW5kX2RpZSgiUkVMIHJlbG9jYXRpb25zIG5vdCBzdXBwb3J0ZWQgb24gdGhpcyBhcmNoaXRlY3R1cmUiKTsKI2VuZGlmCgkJCWRlZmF1bHQ6CgkJCQlpZiAoc2VjLT5oZWFkZXIuc2hfdHlwZSA+PSBTSFRfTE9QUk9DKSB7CgkJCQkJLyogQXNzdW1lIHByb2Nlc3NvciBzcGVjaWZpYyBzZWN0aW9uIHR5cGVzIGFyZSBkZWJ1ZwoJCQkJCSAgIGluZm8gYW5kIGNhbiBzYWZlbHkgYmUgaWdub3JlZC4gIElmIHRoaXMgaXMgZXZlciBub3QKCQkJCQkgICB0aGUgY2FzZSAoSGVsbG8gTUlQUz8pLCBkb24ndCBwdXQgaWZkZWZzIGhlcmUgYnV0CgkJCQkJICAgY3JlYXRlIGFuIGFyY2hfbG9hZF9wcm9jX3NlY3Rpb24oKS4gICovCgkJCQkJYnJlYWs7CgkJCQl9CgoJCQkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoImNhbid0IGhhbmRsZSBzZWN0aW9ucyBvZiB0eXBlICVsZCIsCgkJCQkJCShsb25nKSBzZWMtPmhlYWRlci5zaF90eXBlKTsKCQkJfQoJCX0KCX0KCgkvKiBEbyB3aGF0IHNvcnQgb2YgaW50ZXJwcmV0YXRpb24gYXMgbmVlZGVkIGJ5IGVhY2ggc2VjdGlvbi4gICovCgoJc2hzdHJ0YWIgPSBmLT5zZWN0aW9uc1tmLT5oZWFkZXIuZV9zaHN0cm5keF0tPmNvbnRlbnRzOwoKCWZvciAoaSA9IDA7IGkgPCBzaG51bTsgKytpKSB7CgkJc3RydWN0IG9ial9zZWN0aW9uICpzZWMgPSBmLT5zZWN0aW9uc1tpXTsKCQlzZWMtPm5hbWUgPSBzaHN0cnRhYiArIHNlYy0+aGVhZGVyLnNoX25hbWU7Cgl9CgoJZm9yIChpID0gMDsgaSA8IHNobnVtOyArK2kpIHsKCQlzdHJ1Y3Qgb2JqX3NlY3Rpb24gKnNlYyA9IGYtPnNlY3Rpb25zW2ldOwoKCQkvKiAubW9kaW5mbyBzaG91bGQgYmUgY29udGVudHMgb25seSBidXQgZ2NjIGhhcyBubyBhdHRyaWJ1dGUgZm9yIHRoYXQuCgkJICogVGhlIGtlcm5lbCBtYXkgaGF2ZSBtYXJrZWQgLm1vZGluZm8gYXMgQUxMT0MsIGlnbm9yZSB0aGlzIGJpdC4KCQkgKi8KCQlpZiAoc3RyY21wKHNlYy0+bmFtZSwgIi5tb2RpbmZvIikgPT0gMCkKCQkJc2VjLT5oZWFkZXIuc2hfZmxhZ3MgJj0gflNIRl9BTExPQzsKCgkJaWYgKHNlYy0+aGVhZGVyLnNoX2ZsYWdzICYgU0hGX0FMTE9DKQoJCQlvYmpfaW5zZXJ0X3NlY3Rpb25fbG9hZF9vcmRlcihmLCBzZWMpOwoKCQlzd2l0Y2ggKHNlYy0+aGVhZGVyLnNoX3R5cGUpIHsKCQljYXNlIFNIVF9TWU1UQUI6CgkJCXsKCQkJCXVuc2lnbmVkIGxvbmcgbnN5bSwgajsKCQkJCWNoYXIgKnN0cnRhYjsKCQkJCUVsZlcoU3ltKSAqIHN5bTsKCgkJCQlpZiAoc2VjLT5oZWFkZXIuc2hfZW50c2l6ZSAhPSBzaXplb2YoRWxmVyhTeW0pKSkgewoJCQkJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJzeW1ib2wgc2l6ZSBtaXNtYXRjaDogJWx1ICE9ICVsdSIsCgkJCQkJCQkodW5zaWduZWQgbG9uZykgc2VjLT5oZWFkZXIuc2hfZW50c2l6ZSwKCQkJCQkJCSh1bnNpZ25lZCBsb25nKSBzaXplb2YoRWxmVyhTeW0pKSk7CgkJCQl9CgoJCQkJbnN5bSA9IHNlYy0+aGVhZGVyLnNoX3NpemUgLyBzaXplb2YoRWxmVyhTeW0pKTsKCQkJCXN0cnRhYiA9IGYtPnNlY3Rpb25zW3NlYy0+aGVhZGVyLnNoX2xpbmtdLT5jb250ZW50czsKCQkJCXN5bSA9IChFbGZXKFN5bSkgKikgc2VjLT5jb250ZW50czsKCgkJCQkvKiBBbGxvY2F0ZSBzcGFjZSBmb3IgYSB0YWJsZSBvZiBsb2NhbCBzeW1ib2xzLiAgKi8KCQkJCWogPSBmLT5sb2NhbF9zeW10YWJfc2l6ZSA9IHNlYy0+aGVhZGVyLnNoX2luZm87CgkJCQlmLT5sb2NhbF9zeW10YWIgPSB4emFsbG9jKGogKiBzaXplb2Yoc3RydWN0IG9ial9zeW1ib2wgKikpOwoKCQkJCS8qIEluc2VydCBhbGwgc3ltYm9scyBpbnRvIHRoZSBoYXNoIHRhYmxlLiAgKi8KCQkJCWZvciAoaiA9IDEsICsrc3ltOyBqIDwgbnN5bTsgKytqLCArK3N5bSkgewoJCQkJCUVsZlcoQWRkcikgdmFsID0gc3ltLT5zdF92YWx1ZTsKCQkJCQljb25zdCBjaGFyICpuYW1lOwoJCQkJCWlmIChzeW0tPnN0X25hbWUpCgkJCQkJCW5hbWUgPSBzdHJ0YWIgKyBzeW0tPnN0X25hbWU7CgkJCQkJZWxzZSBpZiAoc3ltLT5zdF9zaG5keCA8IHNobnVtKQoJCQkJCQluYW1lID0gZi0+c2VjdGlvbnNbc3ltLT5zdF9zaG5keF0tPm5hbWU7CgkJCQkJZWxzZQoJCQkJCQljb250aW51ZTsKI2lmIGRlZmluZWQoX19TSDVfXykKCQkJCQkvKgoJCQkJCSAqIEZvciBzaDY0IGl0IGlzIHBvc3NpYmxlIHRoYXQgdGhlIHRhcmdldCBvZiBhIGJyYW5jaAoJCQkJCSAqIHJlcXVpcmVzIGEgbW9kZSBzd2l0Y2ggKDMyIHRvIDE2IGFuZCBiYWNrIGFnYWluKS4KCQkJCQkgKgoJCQkJCSAqIFRoaXMgaXMgaW1wbGllZCBieSB0aGUgbHNiIGJlaW5nIHNldCBpbiB0aGUgdGFyZ2V0CgkJCQkJICogYWRkcmVzcyBmb3IgU0htZWRpYSBtb2RlIGFuZCBjbGVhciBmb3IgU0hjb21wYWN0LgoJCQkJCSAqLwoJCQkJCXZhbCB8PSBzeW0tPnN0X290aGVyICYgNDsKI2VuZGlmCgkJCQkJb2JqX2FkZF9zeW1ib2woZiwgbmFtZSwgaiwgc3ltLT5zdF9pbmZvLCBzeW0tPnN0X3NobmR4LAoJCQkJCQkJdmFsLCBzeW0tPnN0X3NpemUpOwoJCQkJfQoJCQl9CgkJCWJyZWFrOwoKCQljYXNlIFNIVF9SRUxNOgoJCQlpZiAoc2VjLT5oZWFkZXIuc2hfZW50c2l6ZSAhPSBzaXplb2YoRWxmVyhSZWxNKSkpIHsKCQkJCWJiX2Vycm9yX21zZ19hbmRfZGllKCJyZWxvY2F0aW9uIGVudHJ5IHNpemUgbWlzbWF0Y2g6ICVsdSAhPSAlbHUiLAoJCQkJCQkodW5zaWduZWQgbG9uZykgc2VjLT5oZWFkZXIuc2hfZW50c2l6ZSwKCQkJCQkJKHVuc2lnbmVkIGxvbmcpIHNpemVvZihFbGZXKFJlbE0pKSk7CgkJCX0KCQkJYnJlYWs7CgkJCS8qIFhYWCAgUmVsb2NhdGlvbiBjb2RlIGZyb20gbW9kdXRpbHMtMi4zLjE5IGlzIG5vdCBoZXJlLgoJCQkgKiBXaHk/ICBUaGF0J3MgYWJvdXQgMjAgbGluZXMgb2YgY29kZSBmcm9tIG9iai9vYmpfbG9hZC5jLAoJCQkgKiB3aGljaCBnZXRzIGRvbmUgaW4gYSBzZWNvbmQgcGFzcyB0aHJvdWdoIHRoZSBzZWN0aW9ucy4KCQkJICogVGhpcyBCdXN5Qm94IGluc21vZCBkb2VzIHNpbWlsYXIgd29yayBpbiBvYmpfcmVsb2NhdGUoKS4gKi8KCQl9Cgl9CgoJcmV0dXJuIGY7Cn0KCiNpZiBFTkFCTEVfRkVBVFVSRV9JTlNNT0RfTE9BRElOS01FTQovKgogKiBsb2FkIHRoZSB1bmxvYWRlZCBzZWN0aW9ucyBkaXJlY3RseSBpbnRvIHRoZSBtZW1vcnkgYWxsb2NhdGVkIGJ5CiAqIGtlcm5lbCBmb3IgdGhlIG1vZHVsZQogKi8KCnN0YXRpYyBpbnQgb2JqX2xvYWRfcHJvZ2JpdHMoY2hhciAqaW1hZ2UsIHNpemVfdCBpbWFnZV9zaXplLCBzdHJ1Y3Qgb2JqX2ZpbGUgKmYsIGNoYXIgKmltYWdlYmFzZSkKewoJRWxmVyhBZGRyKSBiYXNlID0gZi0+YmFzZWFkZHI7CglzdHJ1Y3Qgb2JqX3NlY3Rpb24qIHNlYzsKCglmb3IgKHNlYyA9IGYtPmxvYWRfb3JkZXI7IHNlYzsgc2VjID0gc2VjLT5sb2FkX25leHQpIHsKCQkvKiBzZWN0aW9uIGFscmVhZHkgbG9hZGVkPyAqLwoJCWlmIChzZWMtPmNvbnRlbnRzICE9IE5VTEwpCgkJCWNvbnRpbnVlOwoJCWlmIChzZWMtPmhlYWRlci5zaF9zaXplID09IDApCgkJCWNvbnRpbnVlOwoJCXNlYy0+Y29udGVudHMgPSBpbWFnZWJhc2UgKyAoc2VjLT5oZWFkZXIuc2hfYWRkciAtIGJhc2UpOwoJCWlmIChpbWFnZV9zaXplIDwgKHNlYy0+aGVhZGVyLnNoX29mZnNldCArIHNlYy0+aGVhZGVyLnNoX3NpemUpKSB7CgkJCWJiX3NpbXBsZV9lcnJvcl9tc2coImVycm9yIHJlYWRpbmcgRUxGIHNlY3Rpb24gZGF0YSIpOwoJCQlyZXR1cm4gMDsgLyogbmVlZCB0byBkZWxldGUgaGFsZi1sb2FkZWQgbW9kdWxlISAqLwoJCX0KCQltZW1jcHkoc2VjLT5jb250ZW50cywgaW1hZ2UgKyBzZWMtPmhlYWRlci5zaF9vZmZzZXQsIHNlYy0+aGVhZGVyLnNoX3NpemUpOwoJfQoJcmV0dXJuIDE7Cn0KI2VuZGlmCgpzdGF0aWMgdm9pZCBoaWRlX3NwZWNpYWxfc3ltYm9scyhzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCXN0YXRpYyBjb25zdCBjaGFyICpjb25zdCBzcGVjaWFsc1tdID0gewoJCVNQRlggImNsZWFudXBfbW9kdWxlIiwKCQlTUEZYICJpbml0X21vZHVsZSIsCgkJU1BGWCAia2VybmVsX3ZlcnNpb24iLAoJCU5VTEwKCX07CgoJc3RydWN0IG9ial9zeW1ib2wgKnN5bTsKCWNvbnN0IGNoYXIgKmNvbnN0ICpwOwoKCWZvciAocCA9IHNwZWNpYWxzOyAqcDsgKytwKSB7CgkJc3ltID0gb2JqX2ZpbmRfc3ltYm9sKGYsICpwKTsKCQlpZiAoc3ltICE9IE5VTEwpCgkJCXN5bS0+aW5mbyA9IEVMRl9TVF9JTkZPKFNUQl9MT0NBTCwgRUxGX1NUX1RZUEUoc3ltLT5pbmZvKSk7Cgl9Cn0KCgojaWYgRU5BQkxFX0ZFQVRVUkVfQ0hFQ0tfVEFJTlRFRF9NT0RVTEUKc3RhdGljIGludCBvYmpfZ3BsX2xpY2Vuc2Uoc3RydWN0IG9ial9maWxlICpmLCBjb25zdCBjaGFyICoqbGljZW5zZSkKewoJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CgkvKiBUaGlzIGxpc3QgbXVzdCBtYXRjaCAqZXhhY3RseSogdGhlIGxpc3Qgb2YgYWxsb3dhYmxlIGxpY2Vuc2VzIGluCgkgKiBsaW51eC9pbmNsdWRlL2xpbnV4L21vZHVsZS5oLiAgQ2hlY2tpbmcgZm9yIGxlYWRpbmcgIkdQTCIgd2lsbCBub3QKCSAqIHdvcmssIHNvbWVib2R5IHdpbGwgdXNlICJHUEwgc3Vja3MsIHRoaXMgaXMgcHJvcHJpZXRhcnkiLgoJICovCglzdGF0aWMgY29uc3QgY2hhciAqY29uc3QgZ3BsX2xpY2Vuc2VzW10gPSB7CgkJIkdQTCIsCgkJIkdQTCB2MiIsCgkJIkdQTCBhbmQgYWRkaXRpb25hbCByaWdodHMiLAoJCSJEdWFsIEJTRC9HUEwiLAoJCSJEdWFsIE1QTC9HUEwiCgl9OwoKCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgIi5tb2RpbmZvIik7CglpZiAoc2VjKSB7CgkJY29uc3QgY2hhciAqdmFsdWUsICpwdHIsICplbmRwdHI7CgkJcHRyID0gc2VjLT5jb250ZW50czsKCQllbmRwdHIgPSBwdHIgKyBzZWMtPmhlYWRlci5zaF9zaXplOwoJCXdoaWxlIChwdHIgPCBlbmRwdHIpIHsKCQkJdmFsdWUgPSBzdHJjaHIocHRyLCAnPScpOwoJCQlpZiAodmFsdWUgJiYgc3RybmNtcChwdHIsICJsaWNlbnNlIiwgdmFsdWUtcHRyKSA9PSAwKSB7CgkJCQl1bnNpZ25lZCBpOwoJCQkJaWYgKGxpY2Vuc2UpCgkJCQkJKmxpY2Vuc2UgPSB2YWx1ZSsxOwoJCQkJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoZ3BsX2xpY2Vuc2VzKTsgKytpKSB7CgkJCQkJaWYgKHN0cmNtcCh2YWx1ZSsxLCBncGxfbGljZW5zZXNbaV0pID09IDApCgkJCQkJCXJldHVybiAwOwoJCQkJfQoJCQkJcmV0dXJuIDI7CgkJCX0KCQkJcHRyID0gc3RyY2hyKHB0ciwgJ1wwJyk7CgkJCWlmIChwdHIpCgkJCQlwdHIrKzsKCQkJZWxzZQoJCQkJcHRyID0gZW5kcHRyOwoJCX0KCX0KCXJldHVybiAxOwp9CgojZGVmaW5lIFRBSU5UX0ZJTEVOQU1FICAgICAgICAgICAgICAgICAgIi9wcm9jL3N5cy9rZXJuZWwvdGFpbnRlZCIKI2RlZmluZSBUQUlOVF9QUk9QUklFVE9SWV9NT0RVTEUgICAgICAgICgxIDw8IDApCiNkZWZpbmUgVEFJTlRfRk9SQ0VEX01PRFVMRSAgICAgICAgICAgICAoMSA8PCAxKQojZGVmaW5lIFRBSU5UX1VOU0FGRV9TTVAgICAgICAgICAgICAgICAgKDEgPDwgMikKI2RlZmluZSBUQUlOVF9VUkwgICAgICAgICAgICAgICAgICAgICAgICJodHRwOi8vd3d3LnR1eC5vcmcvbGttbC8jZXhwb3J0LXRhaW50ZWQiCgpzdGF0aWMgdm9pZCBzZXRfdGFpbnRlZChpbnQgZmQsIGNvbnN0IGNoYXIgKm1fbmFtZSwKCQlpbnQga2VybmVsX2hhc190YWludGVkLCBpbnQgdGFpbnQsCgkJY29uc3QgY2hhciAqdGV4dDEsIGNvbnN0IGNoYXIgKnRleHQyKQp7CglzdGF0aWMgc21hbGxpbnQgcHJpbnRlZF9pbmZvOwoKCWNoYXIgYnVmWzgwXTsKCWludCBvbGR2YWw7CgoJaWYgKGZkIDwgMCAmJiAha2VybmVsX2hhc190YWludGVkKQoJCXJldHVybjsJCS8qIE5ldyBtb2R1dGlscyBvbiBvbGQga2VybmVsICovCglwcmludGYoIldhcm5pbmc6IGxvYWRpbmcgJXMgd2lsbCB0YWludCB0aGUga2VybmVsOiAlcyVzXG4iLAoJCQltX25hbWUsIHRleHQxLCB0ZXh0Mik7CglpZiAoIXByaW50ZWRfaW5mbykgewoJCXByaW50ZigiICBTZWUgJXMgZm9yIGluZm9ybWF0aW9uIGFib3V0IHRhaW50ZWQgbW9kdWxlc1xuIiwgVEFJTlRfVVJMKTsKCQlwcmludGVkX2luZm8gPSAxOwoJfQoJaWYgKGZkID49IDApIHsKCQlyZWFkKGZkLCBidWYsIHNpemVvZihidWYpLTEpOwoJCWJ1ZltzaXplb2YoYnVmKS0xXSA9ICdcMCc7CgkJb2xkdmFsID0gc3RydG91bChidWYsIE5VTEwsIDEwKTsKCQlzcHJpbnRmKGJ1ZiwgIiVkXG4iLCBvbGR2YWwgfCB0YWludCk7CgkJeHdyaXRlX3N0cihmZCwgYnVmKTsKCX0KfQoKLyogQ2hlY2sgaWYgbG9hZGluZyB0aGlzIG1vZHVsZSB3aWxsIHRhaW50IHRoZSBrZXJuZWwuICovCnN0YXRpYyB2b2lkIGNoZWNrX3RhaW50ZWRfbW9kdWxlKHN0cnVjdCBvYmpfZmlsZSAqZiwgY29uc3QgY2hhciAqbV9uYW1lKQp7CglpbnQgZmQsIGtlcm5lbF9oYXNfdGFpbnRlZDsKCWNvbnN0IGNoYXIgKnB0cjsKCglrZXJuZWxfaGFzX3RhaW50ZWQgPSAxOwoJZmQgPSBvcGVuKFRBSU5UX0ZJTEVOQU1FLCBPX1JEV1IpOwoJaWYgKGZkIDwgMCkgewoJCWlmIChlcnJubyA9PSBFTk9FTlQpCgkJCWtlcm5lbF9oYXNfdGFpbnRlZCA9IDA7CgkJZWxzZSBpZiAoZXJybm8gPT0gRUFDQ0VTKQoJCQlrZXJuZWxfaGFzX3RhaW50ZWQgPSAxOwoJCWVsc2UgewoJCQliYl9zaW1wbGVfcGVycm9yX21zZyhUQUlOVF9GSUxFTkFNRSk7CgkJCWtlcm5lbF9oYXNfdGFpbnRlZCA9IDA7CgkJfQoJfQoKCXN3aXRjaCAob2JqX2dwbF9saWNlbnNlKGYsICZwdHIpKSB7CgkJY2FzZSAwOgoJCQlicmVhazsKCQljYXNlIDE6CgkJCXNldF90YWludGVkKGZkLCBtX25hbWUsIGtlcm5lbF9oYXNfdGFpbnRlZCwgVEFJTlRfUFJPUFJJRVRPUllfTU9EVUxFLCAibm8gbGljZW5zZSIsICIiKTsKCQkJYnJlYWs7CgkJZGVmYXVsdDogLyogY2FzZSAyOiAqLwoJCQkvKiBUaGUgbW9kdWxlIGhhcyBhIG5vbi1HUEwgbGljZW5zZSBzbyB3ZSBwcmV0ZW5kIHRoYXQgdGhlCgkJCSAqIGtlcm5lbCBhbHdheXMgaGFzIGEgdGFpbnQgZmxhZyB0byBnZXQgYSB3YXJuaW5nIGV2ZW4gb24KCQkJICoga2VybmVscyB3aXRob3V0IHRoZSBwcm9jIGZsYWcuCgkJCSAqLwoJCQlzZXRfdGFpbnRlZChmZCwgbV9uYW1lLCAxLCBUQUlOVF9QUk9QUklFVE9SWV9NT0RVTEUsICJub24tR1BMIGxpY2Vuc2UgLSAiLCBwdHIpOwoJCQlicmVhazsKCX0KCglpZiAoZmxhZ19mb3JjZV9sb2FkKQoJCXNldF90YWludGVkKGZkLCBtX25hbWUsIDEsIFRBSU5UX0ZPUkNFRF9NT0RVTEUsICJmb3JjZWQgbG9hZCIsICIiKTsKCglpZiAoZmQgPj0gMCkKCQljbG9zZShmZCk7Cn0KI2Vsc2UgLyogIUZFQVRVUkVfQ0hFQ0tfVEFJTlRFRF9NT0RVTEUgKi8KI2RlZmluZSBjaGVja190YWludGVkX21vZHVsZSh4LCB5KSBkbyB7IH0gd2hpbGUgKDApOwojZW5kaWYKCiNpZiBFTkFCTEVfRkVBVFVSRV9JTlNNT0RfS1NZTU9PUFNfU1lNQk9MUwovKiBhZGQgbW9kdWxlIHNvdXJjZSwgdGltZXN0YW1wLCBrZXJuZWwgdmVyc2lvbiBhbmQgYSBzeW1ib2wgZm9yIHRoZQogKiBzdGFydCBvZiBzb21lIHNlY3Rpb25zLiAgdGhpcyBpbmZvIGlzIHVzZWQgYnkga3N5bW9vcHMgdG8gZG8gYmV0dGVyCiAqIGRlYnVnZ2luZy4KICovCiNpZiAhRU5BQkxFX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcKI2RlZmluZSBnZXRfbW9kdWxlX3ZlcnNpb24oZiwgc3RyKSBnZXRfbW9kdWxlX3ZlcnNpb24oc3RyKQojZW5kaWYKc3RhdGljIGludApnZXRfbW9kdWxlX3ZlcnNpb24oc3RydWN0IG9ial9maWxlICpmLCBjaGFyIHN0cltTVFJWRVJTSU9OTEVOXSkKewojaWYgRU5BQkxFX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcKCXJldHVybiBuZXdfZ2V0X21vZHVsZV92ZXJzaW9uKGYsIHN0cik7CiNlbHNlCglzdHJuY3B5KHN0ciwgIj8/PyIsIHNpemVvZihzdHIpKTsKCXJldHVybiAtMTsKI2VuZGlmCn0KCi8qIGFkZCBtb2R1bGUgc291cmNlLCB0aW1lc3RhbXAsIGtlcm5lbCB2ZXJzaW9uIGFuZCBhIHN5bWJvbCBmb3IgdGhlCiAqIHN0YXJ0IG9mIHNvbWUgc2VjdGlvbnMuICB0aGlzIGluZm8gaXMgdXNlZCBieSBrc3ltb29wcyB0byBkbyBiZXR0ZXIKICogZGVidWdnaW5nLgogKi8Kc3RhdGljIHZvaWQKYWRkX2tzeW1vb3BzX3N5bWJvbHMoc3RydWN0IG9ial9maWxlICpmLCBjb25zdCBjaGFyICpmaWxlbmFtZSwKCQljb25zdCBjaGFyICptX25hbWUpCnsKCXN0YXRpYyBjb25zdCBjaGFyIHN5bXByZWZpeFtdIEFMSUdOMSA9ICJfX2luc21vZF8iOwoJc3RhdGljIGNvbnN0IGNoYXIgc2VjdGlvbl9uYW1lc1tdWzhdID0gewoJCSIudGV4dCIsCgkJIi5yb2RhdGEiLAoJCSIuZGF0YSIsCgkJIi5ic3MiLAoJCSIuc2JzcyIKCX07CgoJc3RydWN0IG9ial9zZWN0aW9uICpzZWM7CglzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwoJY2hhciAqbmFtZSwgKmFic29sdXRlX2ZpbGVuYW1lOwoJY2hhciBzdHJbU1RSVkVSU0lPTkxFTl07Cgl1bnNpZ25lZCBpOwoJaW50IGxtX25hbWUsIGxmaWxlbmFtZSwgdXNlX2tzeW10YWIsIHZlcnNpb247CglzdHJ1Y3Qgc3RhdCBzdGF0YnVmOwoKCS8qIFdBUk5JTkc6IHdhcyB1c2luZyByZWFscGF0aCwgYnV0IHJlcGxhY2VkIGJ5IHJlYWRsaW5rIHRvIHN0b3AgdXNpbmcKCSAqIGxvdHMgb2Ygc3RhY2suIEJ1dCBoZXJlIGl0IHNlZW1zIHRvIGJlIGFibGUgdG8gY2F1c2UgcHJvYmxlbXM/ICovCglhYnNvbHV0ZV9maWxlbmFtZSA9IHhtYWxsb2NfcmVhZGxpbmsoZmlsZW5hbWUpOwoJaWYgKCFhYnNvbHV0ZV9maWxlbmFtZSkKCQlhYnNvbHV0ZV9maWxlbmFtZSA9IHhzdHJkdXAoZmlsZW5hbWUpOwoKCWxtX25hbWUgPSBzdHJsZW4obV9uYW1lKTsKCWxmaWxlbmFtZSA9IHN0cmxlbihhYnNvbHV0ZV9maWxlbmFtZSk7CgoJLyogYWRkIHRvIGtzeW10YWIgaWYgaXQgYWxyZWFkeSBleGlzdHMgb3IgdGhlcmUgaXMgbm8ga3N5bXRhYiBhbmQgb3RoZXIgc3ltYm9scwoJICogYXJlIG5vdCB0byBiZSBleHBvcnRlZC4gIG90aGVyd2lzZSBsZWF2ZSBrc3ltdGFiIGFsb25lIGZvciBub3csIHRoZQoJICogImV4cG9ydCBhbGwgc3ltYm9scyIgY29tcGF0aWJpbGl0eSBjb2RlIHdpbGwgZXhwb3J0IHRoZXNlIHN5bWJvbHMgbGF0ZXIuCgkgKi8KCXVzZV9rc3ltdGFiID0gb2JqX2ZpbmRfc2VjdGlvbihmLCAiX19rc3ltdGFiIikgfHwgZmxhZ19ub2V4cG9ydDsKCglzZWMgPSBvYmpfZmluZF9zZWN0aW9uKGYsICIudGhpcyIpOwoJaWYgKHNlYykgewoJCS8qIHRhZyB0aGUgbW9kdWxlIGhlYWRlciB3aXRoIHRoZSBvYmplY3QgbmFtZSwgbGFzdCBtb2RpZmllZAoJCSAqIHRpbWVzdGFtcCBhbmQgbW9kdWxlIHZlcnNpb24uICB3b3JzdCBjYXNlIGZvciBtb2R1bGUgdmVyc2lvbgoJCSAqIGlzIDB4ZmZmZmZmLCBkZWNpbWFsIDE2Nzc3MjE1LiAgcHV0dGluZyBhbGwgdGhyZWUgZmllbGRzIGluCgkJICogb25lIHN5bWJvbCBpcyBsZXNzIHJlYWRhYmxlIGJ1dCBzYXZlcyBrZXJuZWwgc3BhY2UuCgkJICovCgkJaWYgKHN0YXQoYWJzb2x1dGVfZmlsZW5hbWUsICZzdGF0YnVmKSAhPSAwKQoJCQlzdGF0YnVmLnN0X210aW1lID0gMDsKCQl2ZXJzaW9uID0gZ2V0X21vZHVsZV92ZXJzaW9uKGYsIHN0cik7CS8qIC0xIGlmIG5vdCBmb3VuZCAqLwoJCW5hbWUgPSB4YXNwcmludGYoIiVzJXNfTyVzX00lMCpsWF9WJWQiLAoJCQkJc3ltcHJlZml4LCBtX25hbWUsIGFic29sdXRlX2ZpbGVuYW1lLAoJCQkJKGludCkoMiAqIHNpemVvZihzdGF0YnVmLnN0X210aW1lKSksCgkJCQkobG9uZylzdGF0YnVmLnN0X210aW1lLAoJCQkJdmVyc2lvbik7CgkJc3ltID0gb2JqX2FkZF9zeW1ib2woZiwgbmFtZSwgLTEsCgkJCQlFTEZfU1RfSU5GTyhTVEJfR0xPQkFMLCBTVFRfTk9UWVBFKSwKCQkJCXNlYy0+aWR4LCBzZWMtPmhlYWRlci5zaF9hZGRyLCAwKTsKCQlpZiAodXNlX2tzeW10YWIpCgkJCW5ld19hZGRfa3N5bXRhYihmLCBzeW0pOwoJfQoJZnJlZShhYnNvbHV0ZV9maWxlbmFtZSk7CiNpZmRlZiBfTk9UX1NVUFBPUlRFRF8KCS8qIHJlY29yZCB3aGVyZSB0aGUgcGVyc2lzdGVudCBkYXRhIGlzIGdvaW5nLCBzYW1lIGFkZHJlc3MgYXMgcHJldmlvdXMgc3ltYm9sICovCglpZiAoZi0+cGVyc2lzdCkgewoJCW5hbWUgPSB4YXNwcmludGYoIiVzJXNfUCVzIiwKCQkJCXN5bXByZWZpeCwgbV9uYW1lLCBmLT5wZXJzaXN0KTsKCQlzeW0gPSBvYmpfYWRkX3N5bWJvbChmLCBuYW1lLCAtMSwgRUxGX1NUX0lORk8oU1RCX0dMT0JBTCwgU1RUX05PVFlQRSksCgkJCQlzZWMtPmlkeCwgc2VjLT5oZWFkZXIuc2hfYWRkciwgMCk7CgkJaWYgKHVzZV9rc3ltdGFiKQoJCQluZXdfYWRkX2tzeW10YWIoZiwgc3ltKTsKCX0KI2VuZGlmCgkvKiB0YWcgdGhlIGRlc2lyZWQgc2VjdGlvbnMgaWYgc2l6ZSBpcyBub24temVybyAqLwoJZm9yIChpID0gMDsgaSA8IEFSUkFZX1NJWkUoc2VjdGlvbl9uYW1lcyk7ICsraSkgewoJCXNlYyA9IG9ial9maW5kX3NlY3Rpb24oZiwgc2VjdGlvbl9uYW1lc1tpXSk7CgkJaWYgKHNlYyAmJiBzZWMtPmhlYWRlci5zaF9zaXplKSB7CgkJCW5hbWUgPSB4YXNwcmludGYoIiVzJXNfUyVzX0wlbGQiLAoJCQkJCXN5bXByZWZpeCwgbV9uYW1lLCBzZWMtPm5hbWUsCgkJCQkJKGxvbmcpc2VjLT5oZWFkZXIuc2hfc2l6ZSk7CgkJCXN5bSA9IG9ial9hZGRfc3ltYm9sKGYsIG5hbWUsIC0xLCBFTEZfU1RfSU5GTyhTVEJfR0xPQkFMLCBTVFRfTk9UWVBFKSwKCQkJCQlzZWMtPmlkeCwgc2VjLT5oZWFkZXIuc2hfYWRkciwgMCk7CgkJCWlmICh1c2Vfa3N5bXRhYikKCQkJCW5ld19hZGRfa3N5bXRhYihmLCBzeW0pOwoJCX0KCX0KfQojZW5kaWYgLyogRkVBVFVSRV9JTlNNT0RfS1NZTU9PUFNfU1lNQk9MUyAqLwoKI2lmIEVOQUJMRV9GRUFUVVJFX0lOU01PRF9MT0FEX01BUApzdGF0aWMgdm9pZCBwcmludF9sb2FkX21hcChzdHJ1Y3Qgb2JqX2ZpbGUgKmYpCnsKCXN0cnVjdCBvYmpfc2VjdGlvbiAqc2VjOwojaWYgRU5BQkxFX0ZFQVRVUkVfSU5TTU9EX0xPQURfTUFQX0ZVTEwKCXN0cnVjdCBvYmpfc3ltYm9sICoqYWxsLCAqKnA7CglpbnQgaSwgbnN5bXM7CgljaGFyICpsb2FkZWQ7IC8qIGFycmF5IG9mIGJvb2xlYW5zICovCglzdHJ1Y3Qgb2JqX3N5bWJvbCAqc3ltOwojZW5kaWYKCS8qIFJlcG9ydCBvbiB0aGUgc2VjdGlvbiBsYXlvdXQuICAqLwoJcHJpbnRmKCJTZWN0aW9uczogICAgICAgU2l6ZSAgICAgICUtKnMgIEFsaWduXG4iLAoJCQkoaW50KSAoMiAqIHNpemVvZih2b2lkICopKSwgIkFkZHJlc3MiKTsKCglmb3IgKHNlYyA9IGYtPmxvYWRfb3JkZXI7IHNlYzsgc2VjID0gc2VjLT5sb2FkX25leHQpIHsKCQlpbnQgYTsKCQl1bnNpZ25lZCBsb25nIHRtcDsKCgkJZm9yIChhID0gLTEsIHRtcCA9IHNlYy0+aGVhZGVyLnNoX2FkZHJhbGlnbjsgdG1wOyArK2EpCgkJCXRtcCA+Pj0gMTsKCQlpZiAoYSA9PSAtMSkKCQkJYSA9IDA7CgoJCXByaW50ZigiJS0xNXMgJTA4bHggICUwKmx4ICAyKiolZFxuIiwKCQkJCXNlYy0+bmFtZSwKCQkJCShsb25nKXNlYy0+aGVhZGVyLnNoX3NpemUsCgkJCQkoaW50KSAoMiAqIHNpemVvZih2b2lkICopKSwKCQkJCShsb25nKXNlYy0+aGVhZGVyLnNoX2FkZHIsCgkJCQlhKTsKCX0KI2lmIEVOQUJMRV9GRUFUVVJFX0lOU01PRF9MT0FEX01BUF9GVUxMCgkvKiBRdWljayByZWZlcmVuY2Ugd2hpY2ggc2VjdGlvbiBpbmRpY2VzIGFyZSBsb2FkZWQuICAqLwoJaSA9IGYtPmhlYWRlci5lX3NobnVtOwoJbG9hZGVkID0gYWxsb2NhKGkgKiBzaXplb2YobG9hZGVkWzBdKSk7Cgl3aGlsZSAoLS1pID49IDApCgkJbG9hZGVkW2ldID0gKChmLT5zZWN0aW9uc1tpXS0+aGVhZGVyLnNoX2ZsYWdzICYgU0hGX0FMTE9DKSAhPSAwKTsKCgkvKiBDb2xsZWN0IHRoZSBzeW1ib2xzIHdlJ2xsIGJlIGxpc3RpbmcuICAqLwoJZm9yIChuc3ltcyA9IGkgPSAwOyBpIDwgSEFTSF9CVUNLRVRTOyArK2kpCgkJZm9yIChzeW0gPSBmLT5zeW10YWJbaV07IHN5bTsgc3ltID0gc3ltLT5uZXh0KQoJCQlpZiAoc3ltLT5zZWNpZHggPD0gU0hOX0hJUkVTRVJWRQoJCQkgJiYgKHN5bS0+c2VjaWR4ID49IFNITl9MT1JFU0VSVkUgfHwgbG9hZGVkW3N5bS0+c2VjaWR4XSkKCQkJKSB7CgkJCQkrK25zeW1zOwoJCQl9CgoJYWxsID0gYWxsb2NhKG5zeW1zICogc2l6ZW9mKGFsbFswXSkpOwoKCWZvciAoaSA9IDAsIHAgPSBhbGw7IGkgPCBIQVNIX0JVQ0tFVFM7ICsraSkKCQlmb3IgKHN5bSA9IGYtPnN5bXRhYltpXTsgc3ltOyBzeW0gPSBzeW0tPm5leHQpCgkJCWlmIChzeW0tPnNlY2lkeCA8PSBTSE5fSElSRVNFUlZFCgkJCSAmJiAoc3ltLT5zZWNpZHggPj0gU0hOX0xPUkVTRVJWRSB8fCBsb2FkZWRbc3ltLT5zZWNpZHhdKQoJCQkpIHsKCQkJCSpwKysgPSBzeW07CgkJCX0KCgkvKiBBbmQgbGlzdCB0aGVtLiAgKi8KCXByaW50ZigiXG5TeW1ib2xzOlxuIik7Cglmb3IgKHAgPSBhbGw7IHAgPCBhbGwgKyBuc3ltczsgKytwKSB7CgkJY2hhciB0eXBlID0gJz8nOwoJCXVuc2lnbmVkIGxvbmcgdmFsdWU7CgoJCXN5bSA9ICpwOwoJCWlmIChzeW0tPnNlY2lkeCA9PSBTSE5fQUJTKSB7CgkJCXR5cGUgPSAnQSc7CgkJCXZhbHVlID0gc3ltLT52YWx1ZTsKCQl9IGVsc2UgaWYgKHN5bS0+c2VjaWR4ID09IFNITl9VTkRFRikgewoJCQl0eXBlID0gJ1UnOwoJCQl2YWx1ZSA9IDA7CgkJfSBlbHNlIHsKCQkJc2VjID0gZi0+c2VjdGlvbnNbc3ltLT5zZWNpZHhdOwoKCQkJaWYgKHNlYy0+aGVhZGVyLnNoX3R5cGUgPT0gU0hUX05PQklUUykKCQkJCXR5cGUgPSAnQic7CgkJCWVsc2UgaWYgKHNlYy0+aGVhZGVyLnNoX2ZsYWdzICYgU0hGX0FMTE9DKSB7CgkJCQlpZiAoc2VjLT5oZWFkZXIuc2hfZmxhZ3MgJiBTSEZfRVhFQ0lOU1RSKQoJCQkJCXR5cGUgPSAnVCc7CgkJCQllbHNlIGlmIChzZWMtPmhlYWRlci5zaF9mbGFncyAmIFNIRl9XUklURSkKCQkJCQl0eXBlID0gJ0QnOwoJCQkJZWxzZQoJCQkJCXR5cGUgPSAnUic7CgkJCX0KCQkJdmFsdWUgPSBzeW0tPnZhbHVlICsgc2VjLT5oZWFkZXIuc2hfYWRkcjsKCQl9CgoJCWlmIChFTEZfU1RfQklORChzeW0tPmluZm8pID09IFNUQl9MT0NBTCkKCQkJdHlwZSB8PSAweDIwOyAvKiB0b2xvd2VyLiBzYWZlIGZvciAnPycgdG9vICovCgoJCXByaW50ZigiJTAqbHggJWMgJXNcbiIsIChpbnQpICgyICogc2l6ZW9mKHZvaWQgKikpLCB2YWx1ZSwKCQkJCXR5cGUsIHN5bS0+bmFtZSk7Cgl9CiNlbmRpZgp9CiNlbHNlIC8qICFGRUFUVVJFX0lOU01PRF9MT0FEX01BUCAqLwpzdGF0aWMgdm9pZCBwcmludF9sb2FkX21hcChzdHJ1Y3Qgb2JqX2ZpbGUgKmYgVU5VU0VEX1BBUkFNKQp7Cn0KI2VuZGlmCgppbnQgRkFTVF9GVU5DIGJiX2luaXRfbW9kdWxlXzI0KGNvbnN0IGNoYXIgKm1fZmlsZW5hbWUsIGNvbnN0IGNoYXIgKm9wdGlvbnMpCnsKCWludCBrX2NyY3M7Cgl1bnNpZ25lZCBsb25nIG1fc2l6ZTsKCUVsZlcoQWRkcikgbV9hZGRyOwoJc3RydWN0IG9ial9maWxlICpmOwoJaW50IGV4aXRfc3RhdHVzID0gRVhJVF9GQUlMVVJFOwoJY2hhciAqbV9uYW1lOwojaWYgRU5BQkxFX0ZFQVRVUkVfSU5TTU9EX1ZFUlNJT05fQ0hFQ0tJTkcKCWludCBtX2hhc19tb2RpbmZvOwojZW5kaWYKCWNoYXIgKmltYWdlOwoJc2l6ZV90IGltYWdlX3NpemU7Cglib29sIG1tYXBlZDsKCglpbWFnZV9zaXplID0gSU5UX01BWCAtIDQwOTU7CgltbWFwZWQgPSAwOwoJaW1hZ2UgPSB0cnlfdG9fbW1hcF9tb2R1bGUobV9maWxlbmFtZSwgJmltYWdlX3NpemUpOwoJaWYgKGltYWdlKSB7CgkJbW1hcGVkID0gMTsKCX0gZWxzZSB7CgkJLyogTG9hZCBtb2R1bGUgaW50byBtZW1vcnkgYW5kIHVuemlwIGlmIGNvbXByZXNzZWQgKi8KCQlpbWFnZSA9IHhtYWxsb2Nfb3Blbl96aXBwZWRfcmVhZF9jbG9zZShtX2ZpbGVuYW1lLCAmaW1hZ2Vfc2l6ZSk7CgkJaWYgKCFpbWFnZSkKCQkJcmV0dXJuIEVYSVRfRkFJTFVSRTsKCX0KCgltX25hbWUgPSB4c3RyZHVwKGJiX2Jhc2VuYW1lKG1fZmlsZW5hbWUpKTsKCS8qICJtb2R1bGUub1suZ3pdIiAtPiAibW9kdWxlIiAqLwoJKnN0cmNocm51bChtX25hbWUsICcuJykgPSAnXDAnOwoKCWYgPSBvYmpfbG9hZChpbWFnZSwgaW1hZ2Vfc2l6ZSwgTE9BREJJVFMpOwoKI2lmIEVOQUJMRV9GRUFUVVJFX0lOU01PRF9WRVJTSU9OX0NIRUNLSU5HCgkvKiBWZXJzaW9uIGNvcnJlc3BvbmRlbmNlPyAgKi8KCW1faGFzX21vZGluZm8gPSAoZ2V0X21vZGluZm9fdmFsdWUoZiwgImtlcm5lbF92ZXJzaW9uIikgIT0gTlVMTCk7CglpZiAoIWZsYWdfcXVpZXQpIHsKCQljaGFyIG1fc3RydmVyc2lvbltTVFJWRVJTSU9OTEVOXTsKCQlzdHJ1Y3QgdXRzbmFtZSB1dHM7CgoJCWlmIChtX2hhc19tb2RpbmZvKSB7CgkJCWludCBtX3ZlcnNpb24gPSBuZXdfZ2V0X21vZHVsZV92ZXJzaW9uKGYsIG1fc3RydmVyc2lvbik7CgkJCWlmIChtX3ZlcnNpb24gPT0gLTEpIHsKCQkJCWJiX3NpbXBsZV9lcnJvcl9tc2dfYW5kX2RpZSgiY2FuJ3QgZmluZCB0aGUga2VybmVsIHZlcnNpb24gIgoJCQkJCSJ0aGUgbW9kdWxlIHdhcyBjb21waWxlZCBmb3IiKTsKCQkJfQoJCX0KCgkJdW5hbWUoJnV0cyk7CgkJaWYgKHN0cm5jbXAodXRzLnJlbGVhc2UsIG1fc3RydmVyc2lvbiwgU1RSVkVSU0lPTkxFTikgIT0gMCkgewoJCQliYl9lcnJvcl9tc2coIiVza2VybmVsLW1vZHVsZSB2ZXJzaW9uIG1pc21hdGNoXG4iCgkJCQkiXHQlcyB3YXMgY29tcGlsZWQgZm9yIGtlcm5lbCB2ZXJzaW9uICVzXG4iCgkJCQkiXHR3aGlsZSB0aGlzIGtlcm5lbCBpcyB2ZXJzaW9uICVzIiwKCQkJCWZsYWdfZm9yY2VfbG9hZCA/ICJ3YXJuaW5nOiAiIDogIiIsCgkJCQltX25hbWUsIG1fc3RydmVyc2lvbiwgdXRzLnJlbGVhc2UpOwoJCQlpZiAoIWZsYWdfZm9yY2VfbG9hZCkKCQkJCWdvdG8gb3V0OwoJCX0KCX0KI2VuZGlmCgoJaWYgKHF1ZXJ5X21vZHVsZShOVUxMLCAwLCBOVUxMLCAwLCBOVUxMKSkKCQliYl9zaW1wbGVfZXJyb3JfbXNnX2FuZF9kaWUoIm9sZCAodW5zdXBwb3J0ZWQpIGtlcm5lbCIpOwoJbmV3X2dldF9rZXJuZWxfc3ltYm9scygpOwoJa19jcmNzID0gbmV3X2lzX2tlcm5lbF9jaGVja3N1bW1lZCgpOwoKI2lmIEVOQUJMRV9GRUFUVVJFX0lOU01PRF9WRVJTSU9OX0NIRUNLSU5HCgl7CgkJaW50IG1fY3JjcyA9IDA7CgkJaWYgKG1faGFzX21vZGluZm8pCgkJCW1fY3JjcyA9IG5ld19pc19tb2R1bGVfY2hlY2tzdW1tZWQoZik7CgkJaWYgKG1fY3JjcyAhPSBrX2NyY3MpCgkJCW9ial9zZXRfc3ltYm9sX2NvbXBhcmUoZiwgbmN2X3N0cmNtcCwgbmN2X3N5bWJvbF9oYXNoKTsKCX0KI2VuZGlmCgoJLyogTGV0IHRoZSBtb2R1bGUga25vdyBhYm91dCB0aGUga2VybmVsIHN5bWJvbHMuICAqLwoJYWRkX2tlcm5lbF9zeW1ib2xzKGYpOwoKCS8qIEFsbG9jYXRlIGNvbW1vbiBzeW1ib2xzLCBzeW1ib2wgdGFibGVzLCBhbmQgc3RyaW5nIHRhYmxlcy4gICovCgluZXdfY3JlYXRlX3RoaXNfbW9kdWxlKGYsIG1fbmFtZSk7CglvYmpfY2hlY2tfdW5kZWZpbmVkcyhmKTsKCW9ial9hbGxvY2F0ZV9jb21tb25zKGYpOwoJY2hlY2tfdGFpbnRlZF9tb2R1bGUoZiwgbV9uYW1lKTsKCgkvKiBEb25lIHdpdGggdGhlIG1vZHVsZSBuYW1lLCBvbiB0byB0aGUgb3B0aW9uYWwgdmFyPXZhbHVlIGFyZ3VtZW50cyAqLwoJbmV3X3Byb2Nlc3NfbW9kdWxlX2FyZ3VtZW50cyhmLCBvcHRpb25zKTsKCglhcmNoX2NyZWF0ZV9nb3QoZik7CgloaWRlX3NwZWNpYWxfc3ltYm9scyhmKTsKCiNpZiBFTkFCTEVfRkVBVFVSRV9JTlNNT0RfS1NZTU9PUFNfU1lNQk9MUwoJYWRkX2tzeW1vb3BzX3N5bWJvbHMoZiwgbV9maWxlbmFtZSwgbV9uYW1lKTsKI2VuZGlmCgoJbmV3X2NyZWF0ZV9tb2R1bGVfa3N5bXRhYihmKTsKCgkvKiBGaW5kIGN1cnJlbnQgc2l6ZSBvZiB0aGUgbW9kdWxlICovCgltX3NpemUgPSBvYmpfbG9hZF9zaXplKGYpOwoKCW1fYWRkciA9IGNyZWF0ZV9tb2R1bGUobV9uYW1lLCBtX3NpemUpOwoJaWYgKG1fYWRkciA9PSAoRWxmVyhBZGRyKSkoLTEpKSBzd2l0Y2ggKGVycm5vKSB7CgljYXNlIEVFWElTVDoKCQliYl9lcnJvcl9tc2dfYW5kX2RpZSgiYSBtb2R1bGUgbmFtZWQgJXMgYWxyZWFkeSBleGlzdHMiLCBtX25hbWUpOwoJY2FzZSBFTk9NRU06CgkJYmJfZXJyb3JfbXNnX2FuZF9kaWUoImNhbid0IGFsbG9jYXRlIGtlcm5lbCBtZW1vcnkgZm9yIG1vZHVsZTsgbmVlZGVkICVsdSBieXRlcyIsCgkJCQltX3NpemUpOwoJZGVmYXVsdDoKCQliYl9wZXJyb3JfbXNnX2FuZF9kaWUoImNyZWF0ZV9tb2R1bGU6ICVzIiwgbV9uYW1lKTsKCX0KCiNpZiAhTE9BREJJVFMKCS8qCgkgKiB0aGUgUFJPR0JJVFMgc2VjdGlvbiB3YXMgbm90IGxvYWRlZCBieSB0aGUgb2JqX2xvYWQKCSAqIG5vdyB3ZSBjYW4gbG9hZCB0aGVtIGRpcmVjdGx5IGludG8gdGhlIGtlcm5lbCBtZW1vcnkKCSAqLwoJaWYgKCFvYmpfbG9hZF9wcm9nYml0cyhpbWFnZSwgaW1hZ2Vfc2l6ZSwgZiwgKGNoYXIqKW1fYWRkcikpIHsKCQlkZWxldGVfbW9kdWxlKG1fbmFtZSwgMCk7CgkJZ290byBvdXQ7Cgl9CiNlbmRpZgoKCWlmICghb2JqX3JlbG9jYXRlKGYsIG1fYWRkcikpIHsKCQlkZWxldGVfbW9kdWxlKG1fbmFtZSwgMCk7CgkJZ290byBvdXQ7Cgl9CgoJaWYgKCFuZXdfaW5pdF9tb2R1bGUobV9uYW1lLCBmLCBtX3NpemUpKSB7CgkJZGVsZXRlX21vZHVsZShtX25hbWUsIDApOwoJCWdvdG8gb3V0OwoJfQoKCWlmIChmbGFnX3ByaW50X2xvYWRfbWFwKQoJCXByaW50X2xvYWRfbWFwKGYpOwoKCWV4aXRfc3RhdHVzID0gRVhJVF9TVUNDRVNTOwoKIG91dDoKCWlmIChtbWFwZWQpCgkJbXVubWFwKGltYWdlLCBpbWFnZV9zaXplKTsKCWVsc2UKCQlmcmVlKGltYWdlKTsKCWZyZWUobV9uYW1lKTsKCglyZXR1cm4gZXhpdF9zdGF0dXM7Cn0K