LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCiAqIENvcHlyaWdodCCpIDIwMDcgUmVkIEhhdCBJbmMuCiAqIENvcHlyaWdodCCpIDIwMDctMjAxMiBJbnRlbCBDb3Jwb3JhdGlvbgogKiBDb3B5cmlnaHQgMjAwNiBUdW5nc3RlbiBHcmFwaGljcywgSW5jLiwgQmlzbWFyY2ssIE5ELiwgVVNBCiAqIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCiAqCiAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0byBhbnkgcGVyc29uIG9idGFpbmluZyBhCiAqIGNvcHkgb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVzICh0aGUKICogIlNvZnR3YXJlIiksIHRvIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZwogKiB3aXRob3V0IGxpbWl0YXRpb24gdGhlIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1Ymxpc2gsCiAqIGRpc3RyaWJ1dGUsIHN1YiBsaWNlbnNlLCBhbmQvb3Igc2VsbCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlLCBhbmQgdG8KICogcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUgaXMgZnVybmlzaGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvCiAqIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKICoKICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCiAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFORCBOT04tSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBTSEFMTAogKiBUSEUgQ09QWVJJR0hUIEhPTERFUlMsIEFVVEhPUlMgQU5EL09SIElUUyBTVVBQTElFUlMgQkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sCiAqIERBTUFHRVMgT1IgT1RIRVIgTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9SVCBPUgogKiBPVEhFUldJU0UsIEFSSVNJTkcgRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFCiAqIFVTRSBPUiBPVEhFUiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuCiAqCiAqIFRoZSBhYm92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIChpbmNsdWRpbmcgdGhlCiAqIG5leHQgcGFyYWdyYXBoKSBzaGFsbCBiZSBpbmNsdWRlZCBpbiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zCiAqIG9mIHRoZSBTb2Z0d2FyZS4KICoKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwovKgogKiBBdXRob3JzOiBUaG9tYXMgSGVsbHN0cvZtIDx0aG9tYXMtYXQtdHVuZ3N0ZW5ncmFwaGljcy1kb3QtY29tPgogKiAgICAgICAgICBLZWl0aCBXaGl0d2VsbCA8a2VpdGh3LWF0LXR1bmdzdGVuZ3JhcGhpY3MtZG90LWNvbT4KICoJICAgIEVyaWMgQW5ob2x0IDxlcmljQGFuaG9sdC5uZXQ+CiAqCSAgICBEYXZlIEFpcmxpZSA8YWlybGllZEBsaW51eC5pZT4KICovCgojaWZkZWYgSEFWRV9DT05GSUdfSAojaW5jbHVkZSAiY29uZmlnLmgiCiNlbmRpZgoKI2luY2x1ZGUgPHhmODZkcm0uaD4KI2luY2x1ZGUgPHhmODZhdG9taWMuaD4KI2luY2x1ZGUgPGZjbnRsLmg+CiNpbmNsdWRlIDxzdGRpby5oPgojaW5jbHVkZSA8c3RkbGliLmg+CiNpbmNsdWRlIDxzdHJpbmcuaD4KI2luY2x1ZGUgPHVuaXN0ZC5oPgojaW5jbHVkZSA8YXNzZXJ0Lmg+CiNpbmNsdWRlIDxwdGhyZWFkLmg+CiNpbmNsdWRlIDxzeXMvaW9jdGwuaD4KI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CiNpbmNsdWRlIDxzeXMvdHlwZXMuaD4KI2luY2x1ZGUgPHN0ZGJvb2wuaD4KCiNpbmNsdWRlICJlcnJuby5oIgojaWZuZGVmIEVUSU1FCiNkZWZpbmUgRVRJTUUgRVRJTUVET1VUCiNlbmRpZgojaW5jbHVkZSAibGliZHJtX21hY3Jvcy5oIgojaW5jbHVkZSAibGliZHJtX2xpc3RzLmgiCiNpbmNsdWRlICJpbnRlbF9idWZtZ3IuaCIKI2luY2x1ZGUgImludGVsX2J1Zm1ncl9wcml2LmgiCiNpbmNsdWRlICJpbnRlbF9jaGlwc2V0LmgiCiNpbmNsdWRlICJzdHJpbmcuaCIKCiNpbmNsdWRlICJpOTE1X2RybS5oIgoKI2lmZGVmIEhBVkVfVkFMR1JJTkQKI2luY2x1ZGUgPHZhbGdyaW5kLmg+CiNpbmNsdWRlIDxtZW1jaGVjay5oPgojZGVmaW5lIFZHKHgpIHgKI2Vsc2UKI2RlZmluZSBWRyh4KQojZW5kaWYKCiNkZWZpbmUgbWVtY2xlYXIocykgbWVtc2V0KCZzLCAwLCBzaXplb2YocykpCgojZGVmaW5lIERCRyguLi4pIGRvIHsJCQkJCVwKCWlmIChidWZtZ3JfZ2VtLT5idWZtZ3IuZGVidWcpCQkJXAoJCWZwcmludGYoc3RkZXJyLCBfX1ZBX0FSR1NfXyk7CQlcCn0gd2hpbGUgKDApCgojZGVmaW5lIEFSUkFZX1NJWkUoeCkgKHNpemVvZih4KSAvIHNpemVvZigoeClbMF0pKQojZGVmaW5lIE1BWDIoQSwgQikgKChBKSA+IChCKSA/IChBKSA6IChCKSkKCi8qKgogKiB1cHBlcl8zMl9iaXRzIC0gcmV0dXJuIGJpdHMgMzItNjMgb2YgYSBudW1iZXIKICogQG46IHRoZSBudW1iZXIgd2UncmUgYWNjZXNzaW5nCiAqCiAqIEEgYmFzaWMgc2hpZnQtcmlnaHQgb2YgYSA2NC0gb3IgMzItYml0IHF1YW50aXR5LiAgVXNlIHRoaXMgdG8gc3VwcHJlc3MKICogdGhlICJyaWdodCBzaGlmdCBjb3VudCA+PSB3aWR0aCBvZiB0eXBlIiB3YXJuaW5nIHdoZW4gdGhhdCBxdWFudGl0eSBpcwogKiAzMi1iaXRzLgogKi8KI2RlZmluZSB1cHBlcl8zMl9iaXRzKG4pICgoX191MzIpKCgobikgPj4gMTYpID4+IDE2KSkKCi8qKgogKiBsb3dlcl8zMl9iaXRzIC0gcmV0dXJuIGJpdHMgMC0zMSBvZiBhIG51bWJlcgogKiBAbjogdGhlIG51bWJlciB3ZSdyZSBhY2Nlc3NpbmcKICovCiNkZWZpbmUgbG93ZXJfMzJfYml0cyhuKSAoKF9fdTMyKShuKSkKCnR5cGVkZWYgc3RydWN0IF9kcm1faW50ZWxfYm9fZ2VtIGRybV9pbnRlbF9ib19nZW07CgpzdHJ1Y3QgZHJtX2ludGVsX2dlbV9ib19idWNrZXQgewoJZHJtTU1MaXN0SGVhZCBoZWFkOwoJdW5zaWduZWQgbG9uZyBzaXplOwp9OwoKdHlwZWRlZiBzdHJ1Y3QgX2RybV9pbnRlbF9idWZtZ3JfZ2VtIHsKCWRybV9pbnRlbF9idWZtZ3IgYnVmbWdyOwoKCWF0b21pY190IHJlZmNvdW50OwoKCWludCBmZDsKCglpbnQgbWF4X3JlbG9jczsKCglwdGhyZWFkX211dGV4X3QgbG9jazsKCglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2V4ZWNfb2JqZWN0ICpleGVjX29iamVjdHM7CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2V4ZWNfb2JqZWN0MiAqZXhlYzJfb2JqZWN0czsKCWRybV9pbnRlbF9ibyAqKmV4ZWNfYm9zOwoJaW50IGV4ZWNfc2l6ZTsKCWludCBleGVjX2NvdW50OwoKCS8qKiBBcnJheSBvZiBsaXN0cyBvZiBjYWNoZWQgZ2VtIG9iamVjdHMgb2YgcG93ZXItb2YtdHdvIHNpemVzICovCglzdHJ1Y3QgZHJtX2ludGVsX2dlbV9ib19idWNrZXQgY2FjaGVfYnVja2V0WzE0ICogNF07CglpbnQgbnVtX2J1Y2tldHM7Cgl0aW1lX3QgdGltZTsKCglkcm1NTUxpc3RIZWFkIG1hbmFnZXJzOwoKCWRybU1NTGlzdEhlYWQgbmFtZWQ7Cglkcm1NTUxpc3RIZWFkIHZtYV9jYWNoZTsKCWludCB2bWFfY291bnQsIHZtYV9vcGVuLCB2bWFfbWF4OwoKCXVpbnQ2NF90IGd0dF9zaXplOwoJaW50IGF2YWlsYWJsZV9mZW5jZXM7CglpbnQgcGNpX2RldmljZTsKCWludCBnZW47Cgl1bnNpZ25lZCBpbnQgaGFzX2JzZCA6IDE7Cgl1bnNpZ25lZCBpbnQgaGFzX2JsdCA6IDE7Cgl1bnNpZ25lZCBpbnQgaGFzX3JlbGF4ZWRfZmVuY2luZyA6IDE7Cgl1bnNpZ25lZCBpbnQgaGFzX2xsYyA6IDE7Cgl1bnNpZ25lZCBpbnQgaGFzX3dhaXRfdGltZW91dCA6IDE7Cgl1bnNpZ25lZCBpbnQgYm9fcmV1c2UgOiAxOwoJdW5zaWduZWQgaW50IG5vX2V4ZWMgOiAxOwoJdW5zaWduZWQgaW50IGhhc192ZWJveCA6IDE7Cglib29sIGZlbmNlZF9yZWxvY3M7CgoJc3RydWN0IHsKCQl2b2lkICpwdHI7CgkJdWludDMyX3QgaGFuZGxlOwoJfSB1c2VycHRyX2FjdGl2ZTsKCn0gZHJtX2ludGVsX2J1Zm1ncl9nZW07CgojZGVmaW5lIERSTV9JTlRFTF9SRUxPQ19GRU5DRSAoMTw8MCkKCnR5cGVkZWYgc3RydWN0IF9kcm1faW50ZWxfcmVsb2NfdGFyZ2V0X2luZm8gewoJZHJtX2ludGVsX2JvICpibzsKCWludCBmbGFnczsKfSBkcm1faW50ZWxfcmVsb2NfdGFyZ2V0OwoKc3RydWN0IF9kcm1faW50ZWxfYm9fZ2VtIHsKCWRybV9pbnRlbF9ibyBibzsKCglhdG9taWNfdCByZWZjb3VudDsKCXVpbnQzMl90IGdlbV9oYW5kbGU7Cgljb25zdCBjaGFyICpuYW1lOwoKCS8qKgoJICogS2VuZWwtYXNzaWduZWQgZ2xvYmFsIG5hbWUgZm9yIHRoaXMgb2JqZWN0CiAgICAgICAgICoKICAgICAgICAgKiBMaXN0IGNvbnRhaW5zIGJvdGggZmxpbmsgbmFtZWQgYW5kIHByaW1lIGZkJ2Qgb2JqZWN0cwoJICovCgl1bnNpZ25lZCBpbnQgZ2xvYmFsX25hbWU7Cglkcm1NTUxpc3RIZWFkIG5hbWVfbGlzdDsKCgkvKioKCSAqIEluZGV4IG9mIHRoZSBidWZmZXIgd2l0aGluIHRoZSB2YWxpZGF0aW9uIGxpc3Qgd2hpbGUgcHJlcGFyaW5nIGEKCSAqIGJhdGNoYnVmZmVyIGV4ZWN1dGlvbi4KCSAqLwoJaW50IHZhbGlkYXRlX2luZGV4OwoKCS8qKgoJICogQ3VycmVudCB0aWxpbmcgbW9kZQoJICovCgl1aW50MzJfdCB0aWxpbmdfbW9kZTsKCXVpbnQzMl90IHN3aXp6bGVfbW9kZTsKCXVuc2lnbmVkIGxvbmcgc3RyaWRlOwoKCXRpbWVfdCBmcmVlX3RpbWU7CgoJLyoqIEFycmF5IHBhc3NlZCB0byB0aGUgRFJNIGNvbnRhaW5pbmcgcmVsb2NhdGlvbiBpbmZvcm1hdGlvbi4gKi8KCXN0cnVjdCBkcm1faTkxNV9nZW1fcmVsb2NhdGlvbl9lbnRyeSAqcmVsb2NzOwoJLyoqCgkgKiBBcnJheSBvZiBpbmZvIHN0cnVjdHMgY29ycmVzcG9uZGluZyB0byByZWxvY3NbaV0udGFyZ2V0X2hhbmRsZSBldGMKCSAqLwoJZHJtX2ludGVsX3JlbG9jX3RhcmdldCAqcmVsb2NfdGFyZ2V0X2luZm87CgkvKiogTnVtYmVyIG9mIGVudHJpZXMgaW4gcmVsb2NzICovCglpbnQgcmVsb2NfY291bnQ7CgkvKiogQXJyYXkgb2YgQk9zIHRoYXQgYXJlIHJlZmVyZW5jZWQgYnkgdGhpcyBidWZmZXIgYW5kIHdpbGwgYmUgc29mdHBpbm5lZCAqLwoJZHJtX2ludGVsX2JvICoqc29mdHBpbl90YXJnZXQ7CgkvKiogTnVtYmVyIHNvZnRwaW5uZWQgQk9zIHRoYXQgYXJlIHJlZmVyZW5jZWQgYnkgdGhpcyBidWZmZXIgKi8KCWludCBzb2Z0cGluX3RhcmdldF9jb3VudDsKCS8qKiBNYXhpbXVtIGFtb3VudCBvZiBzb2Z0cGlubmVkIEJPcyB0aGF0IGFyZSByZWZlcmVuY2VkIGJ5IHRoaXMgYnVmZmVyICovCglpbnQgc29mdHBpbl90YXJnZXRfc2l6ZTsKCgkvKiogTWFwcGVkIGFkZHJlc3MgZm9yIHRoZSBidWZmZXIsIHNhdmVkIGFjcm9zcyBtYXAvdW5tYXAgY3ljbGVzICovCgl2b2lkICptZW1fdmlydHVhbDsKCS8qKiBHVFQgdmlydHVhbCBhZGRyZXNzIGZvciB0aGUgYnVmZmVyLCBzYXZlZCBhY3Jvc3MgbWFwL3VubWFwIGN5Y2xlcyAqLwoJdm9pZCAqZ3R0X3ZpcnR1YWw7CgkvKioKCSAqIFZpcnR1YWwgYWRkcmVzcyBvZiB0aGUgYnVmZmVyIGFsbG9jYXRlZCBieSB1c2VyLCB1c2VkIGZvciB1c2VycHRyCgkgKiBvYmplY3RzIG9ubHkuCgkgKi8KCXZvaWQgKnVzZXJfdmlydHVhbDsKCWludCBtYXBfY291bnQ7Cglkcm1NTUxpc3RIZWFkIHZtYV9saXN0OwoKCS8qKiBCTyBjYWNoZSBsaXN0ICovCglkcm1NTUxpc3RIZWFkIGhlYWQ7CgoJLyoqCgkgKiBCb29sZWFuIG9mIHdoZXRoZXIgdGhpcyBCTyBhbmQgaXRzIGNoaWxkcmVuIGhhdmUgYmVlbiBpbmNsdWRlZCBpbgoJICogdGhlIGN1cnJlbnQgZHJtX2ludGVsX2J1Zm1ncl9jaGVja19hcGVydHVyZV9zcGFjZSgpIHRvdGFsLgoJICovCglib29sIGluY2x1ZGVkX2luX2NoZWNrX2FwZXJ0dXJlOwoKCS8qKgoJICogQm9vbGVhbiBvZiB3aGV0aGVyIHRoaXMgYnVmZmVyIGhhcyBiZWVuIHVzZWQgYXMgYSByZWxvY2F0aW9uCgkgKiB0YXJnZXQgYW5kIGhhZCBpdHMgc2l6ZSBhY2NvdW50ZWQgZm9yLCBhbmQgdGh1cyBjYW4ndCBoYXZlIGFueQoJICogZnVydGhlciByZWxvY2F0aW9ucyBhZGRlZCB0byBpdC4KCSAqLwoJYm9vbCB1c2VkX2FzX3JlbG9jX3RhcmdldDsKCgkvKioKCSAqIEJvb2xlYW4gb2Ygd2hldGhlciB3ZSBoYXZlIGVuY291bnRlcmVkIGFuIGVycm9yIHdoaWxzdCBidWlsZGluZyB0aGUgcmVsb2NhdGlvbiB0cmVlLgoJICovCglib29sIGhhc19lcnJvcjsKCgkvKioKCSAqIEJvb2xlYW4gb2Ygd2hldGhlciB0aGlzIGJ1ZmZlciBjYW4gYmUgcmUtdXNlZAoJICovCglib29sIHJldXNhYmxlOwoKCS8qKgoJICogQm9vbGVhbiBvZiB3aGV0aGVyIHRoZSBHUFUgaXMgZGVmaW5pdGVseSBub3QgYWNjZXNzaW5nIHRoZSBidWZmZXIuCgkgKgoJICogVGhpcyBpcyBvbmx5IHZhbGlkIHdoZW4gcmV1c2FibGUsIHNpbmNlIG5vbi1yZXVzYWJsZQoJICogYnVmZmVycyBhcmUgdGhvc2UgdGhhdCBoYXZlIGJlZW4gc2hhcmVkIHd0aCBvdGhlcgoJICogcHJvY2Vzc2VzLCBzbyB3ZSBkb24ndCBrbm93IHRoZWlyIHN0YXRlLgoJICovCglib29sIGlkbGU7CgoJLyoqCgkgKiBCb29sZWFuIG9mIHdoZXRoZXIgdGhpcyBidWZmZXIgd2FzIGFsbG9jYXRlZCB3aXRoIHVzZXJwdHIKCSAqLwoJYm9vbCBpc191c2VycHRyOwoKCS8qKgoJICogQm9vbGVhbiBvZiB3aGV0aGVyIHRoaXMgYnVmZmVyIGNhbiBiZSBwbGFjZWQgaW4gdGhlIGZ1bGwgNDgtYml0CgkgKiBhZGRyZXNzIHJhbmdlIG9uIGdlbjgrLgoJICoKCSAqIEJ5IGRlZmF1bHQsIGJ1ZmZlcnMgd2lsbCBiZSBrZWVwIGluIGEgMzItYml0IHJhbmdlLCB1bmxlc3MgdGhpcwoJICogZmxhZyBpcyBleHBsaWNpdGx5IHNldC4KCSAqLwoJYm9vbCB1c2VfNDhiX2FkZHJlc3NfcmFuZ2U7CgoJLyoqCgkgKiBXaGV0aGVyIHRoaXMgYnVmZmVyIGlzIHNvZnRwaW5uZWQgYXQgb2Zmc2V0IHNwZWNpZmllZCBieSB0aGUgdXNlcgoJICovCglib29sIGlzX3NvZnRwaW47CgoJLyoqCgkgKiBTaXplIGluIGJ5dGVzIG9mIHRoaXMgYnVmZmVyIGFuZCBpdHMgcmVsb2NhdGlvbiBkZXNjZW5kZW50cy4KCSAqCgkgKiBVc2VkIHRvIGF2b2lkIGNvc3RseSB0cmVlIHdhbGtpbmcgaW4KCSAqIGRybV9pbnRlbF9idWZtZ3JfY2hlY2tfYXBlcnR1cmUgaW4gdGhlIGNvbW1vbiBjYXNlLgoJICovCglpbnQgcmVsb2NfdHJlZV9zaXplOwoKCS8qKgoJICogTnVtYmVyIG9mIHBvdGVudGlhbCBmZW5jZSByZWdpc3RlcnMgcmVxdWlyZWQgYnkgdGhpcyBidWZmZXIgYW5kIGl0cwoJICogcmVsb2NhdGlvbnMuCgkgKi8KCWludCByZWxvY190cmVlX2ZlbmNlczsKCgkvKiogRmxhZ3MgdGhhdCB3ZSBtYXkgbmVlZCB0byBkbyB0aGUgU1dfRklOU0lIIGlvY3RsIG9uIHVubWFwLiAqLwoJYm9vbCBtYXBwZWRfY3B1X3dyaXRlOwp9OwoKc3RhdGljIHVuc2lnbmVkIGludApkcm1faW50ZWxfZ2VtX2VzdGltYXRlX2JhdGNoX3NwYWNlKGRybV9pbnRlbF9ibyAqKiBib19hcnJheSwgaW50IGNvdW50KTsKCnN0YXRpYyB1bnNpZ25lZCBpbnQKZHJtX2ludGVsX2dlbV9jb21wdXRlX2JhdGNoX3NwYWNlKGRybV9pbnRlbF9ibyAqKiBib19hcnJheSwgaW50IGNvdW50KTsKCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19nZXRfdGlsaW5nKGRybV9pbnRlbF9ibyAqYm8sIHVpbnQzMl90ICogdGlsaW5nX21vZGUsCgkJCSAgICB1aW50MzJfdCAqIHN3aXp6bGVfbW9kZSk7CgpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fYm9fc2V0X3RpbGluZ19pbnRlcm5hbChkcm1faW50ZWxfYm8gKmJvLAoJCQkJICAgICB1aW50MzJfdCB0aWxpbmdfbW9kZSwKCQkJCSAgICAgdWludDMyX3Qgc3RyaWRlKTsKCnN0YXRpYyB2b2lkIGRybV9pbnRlbF9nZW1fYm9fdW5yZWZlcmVuY2VfbG9ja2VkX3RpbWVkKGRybV9pbnRlbF9ibyAqYm8sCgkJCQkJCSAgICAgIHRpbWVfdCB0aW1lKTsKCnN0YXRpYyB2b2lkIGRybV9pbnRlbF9nZW1fYm9fdW5yZWZlcmVuY2UoZHJtX2ludGVsX2JvICpibyk7CgpzdGF0aWMgdm9pZCBkcm1faW50ZWxfZ2VtX2JvX2ZyZWUoZHJtX2ludGVsX2JvICpibyk7CgpzdGF0aWMgaW5saW5lIGRybV9pbnRlbF9ib19nZW0gKnRvX2JvX2dlbShkcm1faW50ZWxfYm8gKmJvKQp7CiAgICAgICAgcmV0dXJuIChkcm1faW50ZWxfYm9fZ2VtICopYm87Cn0KCnN0YXRpYyB1bnNpZ25lZCBsb25nCmRybV9pbnRlbF9nZW1fYm9fdGlsZV9zaXplKGRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtLCB1bnNpZ25lZCBsb25nIHNpemUsCgkJCSAgIHVpbnQzMl90ICp0aWxpbmdfbW9kZSkKewoJdW5zaWduZWQgbG9uZyBtaW5fc2l6ZSwgbWF4X3NpemU7Cgl1bnNpZ25lZCBsb25nIGk7CgoJaWYgKCp0aWxpbmdfbW9kZSA9PSBJOTE1X1RJTElOR19OT05FKQoJCXJldHVybiBzaXplOwoKCS8qIDk2NSsganVzdCBuZWVkIG11bHRpcGxlcyBvZiBwYWdlIHNpemUgZm9yIHRpbGluZyAqLwoJaWYgKGJ1Zm1ncl9nZW0tPmdlbiA+PSA0KQoJCXJldHVybiBST1VORF9VUF9UTyhzaXplLCA0MDk2KTsKCgkvKiBPbGRlciBjaGlwcyBuZWVkIHBvd2VycyBvZiB0d28sIG9mIGF0IGxlYXN0IDUxMmsgb3IgMU0gKi8KCWlmIChidWZtZ3JfZ2VtLT5nZW4gPT0gMykgewoJCW1pbl9zaXplID0gMTAyNCoxMDI0OwoJCW1heF9zaXplID0gMTI4KjEwMjQqMTAyNDsKCX0gZWxzZSB7CgkJbWluX3NpemUgPSA1MTIqMTAyNDsKCQltYXhfc2l6ZSA9IDY0KjEwMjQqMTAyNDsKCX0KCglpZiAoc2l6ZSA+IG1heF9zaXplKSB7CgkJKnRpbGluZ19tb2RlID0gSTkxNV9USUxJTkdfTk9ORTsKCQlyZXR1cm4gc2l6ZTsKCX0KCgkvKiBEbyB3ZSBuZWVkIHRvIGFsbG9jYXRlIGV2ZXJ5IHBhZ2UgZm9yIHRoZSBmZW5jZT8gKi8KCWlmIChidWZtZ3JfZ2VtLT5oYXNfcmVsYXhlZF9mZW5jaW5nKQoJCXJldHVybiBST1VORF9VUF9UTyhzaXplLCA0MDk2KTsKCglmb3IgKGkgPSBtaW5fc2l6ZTsgaSA8IHNpemU7IGkgPDw9IDEpCgkJOwoKCXJldHVybiBpOwp9CgovKgogKiBSb3VuZCBhIGdpdmVuIHBpdGNoIHVwIHRvIHRoZSBtaW5pbXVtIHJlcXVpcmVkIGZvciBYIHRpbGluZyBvbiBhCiAqIGdpdmVuIGNoaXAuICBXZSB1c2UgNTEyIGFzIHRoZSBtaW5pbXVtIHRvIGFsbG93IGZvciBhIGxhdGVyIHRpbGluZwogKiBjaGFuZ2UuCiAqLwpzdGF0aWMgdW5zaWduZWQgbG9uZwpkcm1faW50ZWxfZ2VtX2JvX3RpbGVfcGl0Y2goZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0sCgkJCSAgICB1bnNpZ25lZCBsb25nIHBpdGNoLCB1aW50MzJfdCAqdGlsaW5nX21vZGUpCnsKCXVuc2lnbmVkIGxvbmcgdGlsZV93aWR0aDsKCXVuc2lnbmVkIGxvbmcgaTsKCgkvKiBJZiB1bnRpbGVkLCB0aGVuIGp1c3QgYWxpZ24gaXQgc28gdGhhdCB3ZSBjYW4gZG8gcmVuZGVyaW5nCgkgKiB0byBpdCB3aXRoIHRoZSAzRCBlbmdpbmUuCgkgKi8KCWlmICgqdGlsaW5nX21vZGUgPT0gSTkxNV9USUxJTkdfTk9ORSkKCQlyZXR1cm4gQUxJR04ocGl0Y2gsIDY0KTsKCglpZiAoKnRpbGluZ19tb2RlID09IEk5MTVfVElMSU5HX1gKCQkJfHwgKElTXzkxNShidWZtZ3JfZ2VtLT5wY2lfZGV2aWNlKQoJCQkgICAgJiYgKnRpbGluZ19tb2RlID09IEk5MTVfVElMSU5HX1kpKQoJCXRpbGVfd2lkdGggPSA1MTI7CgllbHNlCgkJdGlsZV93aWR0aCA9IDEyODsKCgkvKiA5NjUgaXMgZmxleGlibGUgKi8KCWlmIChidWZtZ3JfZ2VtLT5nZW4gPj0gNCkKCQlyZXR1cm4gUk9VTkRfVVBfVE8ocGl0Y2gsIHRpbGVfd2lkdGgpOwoKCS8qIFRoZSBvbGRlciBoYXJkd2FyZSBoYXMgYSBtYXhpbXVtIHBpdGNoIG9mIDgxOTIgd2l0aCB0aWxlZAoJICogc3VyZmFjZXMsIHNvIGZhbGxiYWNrIHRvIHVudGlsZWQgaWYgaXQncyB0b28gbGFyZ2UuCgkgKi8KCWlmIChwaXRjaCA+IDgxOTIpIHsKCQkqdGlsaW5nX21vZGUgPSBJOTE1X1RJTElOR19OT05FOwoJCXJldHVybiBBTElHTihwaXRjaCwgNjQpOwoJfQoKCS8qIFByZS05NjUgbmVlZHMgcG93ZXIgb2YgdHdvIHRpbGUgd2lkdGggKi8KCWZvciAoaSA9IHRpbGVfd2lkdGg7IGkgPCBwaXRjaDsgaSA8PD0gMSkKCQk7CgoJcmV0dXJuIGk7Cn0KCnN0YXRpYyBzdHJ1Y3QgZHJtX2ludGVsX2dlbV9ib19idWNrZXQgKgpkcm1faW50ZWxfZ2VtX2JvX2J1Y2tldF9mb3Jfc2l6ZShkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSwKCQkJCSB1bnNpZ25lZCBsb25nIHNpemUpCnsKCWludCBpOwoKCWZvciAoaSA9IDA7IGkgPCBidWZtZ3JfZ2VtLT5udW1fYnVja2V0czsgaSsrKSB7CgkJc3RydWN0IGRybV9pbnRlbF9nZW1fYm9fYnVja2V0ICpidWNrZXQgPQoJCSAgICAmYnVmbWdyX2dlbS0+Y2FjaGVfYnVja2V0W2ldOwoJCWlmIChidWNrZXQtPnNpemUgPj0gc2l6ZSkgewoJCQlyZXR1cm4gYnVja2V0OwoJCX0KCX0KCglyZXR1cm4gTlVMTDsKfQoKc3RhdGljIHZvaWQKZHJtX2ludGVsX2dlbV9kdW1wX3ZhbGlkYXRpb25fbGlzdChkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSkKewoJaW50IGksIGo7CgoJZm9yIChpID0gMDsgaSA8IGJ1Zm1ncl9nZW0tPmV4ZWNfY291bnQ7IGkrKykgewoJCWRybV9pbnRlbF9ibyAqYm8gPSBidWZtZ3JfZ2VtLT5leGVjX2Jvc1tpXTsKCQlkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCgkJaWYgKGJvX2dlbS0+cmVsb2NzID09IE5VTEwgJiYgYm9fZ2VtLT5zb2Z0cGluX3RhcmdldCA9PSBOVUxMKSB7CgkJCURCRygiJTJkOiAlZCAlcyglcylcbiIsIGksIGJvX2dlbS0+Z2VtX2hhbmRsZSwKCQkJICAgIGJvX2dlbS0+aXNfc29mdHBpbiA/ICIqIiA6ICIiLAoJCQkgICAgYm9fZ2VtLT5uYW1lKTsKCQkJY29udGludWU7CgkJfQoKCQlmb3IgKGogPSAwOyBqIDwgYm9fZ2VtLT5yZWxvY19jb3VudDsgaisrKSB7CgkJCWRybV9pbnRlbF9ibyAqdGFyZ2V0X2JvID0gYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mb1tqXS5ibzsKCQkJZHJtX2ludGVsX2JvX2dlbSAqdGFyZ2V0X2dlbSA9CgkJCSAgICAoZHJtX2ludGVsX2JvX2dlbSAqKSB0YXJnZXRfYm87CgoJCQlEQkcoIiUyZDogJWQgJXMoJXMpQDB4JTA4eCAlMDh4IC0+ICIKCQkJICAgICIlZCAoJXMpQDB4JTA4eCAlMDh4ICsgMHglMDh4XG4iLAoJCQkgICAgaSwKCQkJICAgIGJvX2dlbS0+Z2VtX2hhbmRsZSwKCQkJICAgIGJvX2dlbS0+aXNfc29mdHBpbiA/ICIqIiA6ICIiLAoJCQkgICAgYm9fZ2VtLT5uYW1lLAoJCQkgICAgdXBwZXJfMzJfYml0cyhib19nZW0tPnJlbG9jc1tqXS5vZmZzZXQpLAoJCQkgICAgbG93ZXJfMzJfYml0cyhib19nZW0tPnJlbG9jc1tqXS5vZmZzZXQpLAoJCQkgICAgdGFyZ2V0X2dlbS0+Z2VtX2hhbmRsZSwKCQkJICAgIHRhcmdldF9nZW0tPm5hbWUsCgkJCSAgICB1cHBlcl8zMl9iaXRzKHRhcmdldF9iby0+b2Zmc2V0NjQpLAoJCQkgICAgbG93ZXJfMzJfYml0cyh0YXJnZXRfYm8tPm9mZnNldDY0KSwKCQkJICAgIGJvX2dlbS0+cmVsb2NzW2pdLmRlbHRhKTsKCQl9CgoJCWZvciAoaiA9IDA7IGogPCBib19nZW0tPnNvZnRwaW5fdGFyZ2V0X2NvdW50OyBqKyspIHsKCQkJZHJtX2ludGVsX2JvICp0YXJnZXRfYm8gPSBib19nZW0tPnNvZnRwaW5fdGFyZ2V0W2pdOwoJCQlkcm1faW50ZWxfYm9fZ2VtICp0YXJnZXRfZ2VtID0KCQkJICAgIChkcm1faW50ZWxfYm9fZ2VtICopIHRhcmdldF9ibzsKCQkJREJHKCIlMmQ6ICVkICVzKCVzKSAtPiAiCgkJCSAgICAiJWQgKiglcylAMHglMDh4ICUwOHhcbiIsCgkJCSAgICBpLAoJCQkgICAgYm9fZ2VtLT5nZW1faGFuZGxlLAoJCQkgICAgYm9fZ2VtLT5pc19zb2Z0cGluID8gIioiIDogIiIsCgkJCSAgICBib19nZW0tPm5hbWUsCgkJCSAgICB0YXJnZXRfZ2VtLT5nZW1faGFuZGxlLAoJCQkgICAgdGFyZ2V0X2dlbS0+bmFtZSwKCQkJICAgIHVwcGVyXzMyX2JpdHModGFyZ2V0X2JvLT5vZmZzZXQ2NCksCgkJCSAgICBsb3dlcl8zMl9iaXRzKHRhcmdldF9iby0+b2Zmc2V0NjQpKTsKCQl9Cgl9Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZApkcm1faW50ZWxfZ2VtX2JvX3JlZmVyZW5jZShkcm1faW50ZWxfYm8gKmJvKQp7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCglhdG9taWNfaW5jKCZib19nZW0tPnJlZmNvdW50KTsKfQoKLyoqCiAqIEFkZHMgdGhlIGdpdmVuIGJ1ZmZlciB0byB0aGUgbGlzdCBvZiBidWZmZXJzIHRvIGJlIHZhbGlkYXRlZCAobW92ZWQgaW50byB0aGUKICogYXBwcm9wcmlhdGUgbWVtb3J5IHR5cGUpIHdpdGggdGhlIG5leHQgYmF0Y2ggc3VibWlzc2lvbi4KICoKICogSWYgYSBidWZmZXIgaXMgdmFsaWRhdGVkIG11bHRpcGxlIHRpbWVzIGluIGEgYmF0Y2ggc3VibWlzc2lvbiwgaXQgZW5kcyB1cAogKiB3aXRoIHRoZSBpbnRlcnNlY3Rpb24gb2YgdGhlIG1lbW9yeSB0eXBlIGZsYWdzIGFuZCB0aGUgdW5pb24gb2YgdGhlCiAqIGFjY2VzcyBmbGFncy4KICovCnN0YXRpYyB2b2lkCmRybV9pbnRlbF9hZGRfdmFsaWRhdGVfYnVmZmVyKGRybV9pbnRlbF9ibyAqYm8pCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCWludCBpbmRleDsKCglpZiAoYm9fZ2VtLT52YWxpZGF0ZV9pbmRleCAhPSAtMSkKCQlyZXR1cm47CgoJLyogRXh0ZW5kIHRoZSBhcnJheSBvZiB2YWxpZGF0aW9uIGVudHJpZXMgYXMgbmVjZXNzYXJ5LiAqLwoJaWYgKGJ1Zm1ncl9nZW0tPmV4ZWNfY291bnQgPT0gYnVmbWdyX2dlbS0+ZXhlY19zaXplKSB7CgkJaW50IG5ld19zaXplID0gYnVmbWdyX2dlbS0+ZXhlY19zaXplICogMjsKCgkJaWYgKG5ld19zaXplID09IDApCgkJCW5ld19zaXplID0gNTsKCgkJYnVmbWdyX2dlbS0+ZXhlY19vYmplY3RzID0KCQkgICAgcmVhbGxvYyhidWZtZ3JfZ2VtLT5leGVjX29iamVjdHMsCgkJCSAgICBzaXplb2YoKmJ1Zm1ncl9nZW0tPmV4ZWNfb2JqZWN0cykgKiBuZXdfc2l6ZSk7CgkJYnVmbWdyX2dlbS0+ZXhlY19ib3MgPQoJCSAgICByZWFsbG9jKGJ1Zm1ncl9nZW0tPmV4ZWNfYm9zLAoJCQkgICAgc2l6ZW9mKCpidWZtZ3JfZ2VtLT5leGVjX2JvcykgKiBuZXdfc2l6ZSk7CgkJYnVmbWdyX2dlbS0+ZXhlY19zaXplID0gbmV3X3NpemU7Cgl9CgoJaW5kZXggPSBidWZtZ3JfZ2VtLT5leGVjX2NvdW50OwoJYm9fZ2VtLT52YWxpZGF0ZV9pbmRleCA9IGluZGV4OwoJLyogRmlsbCBpbiBhcnJheSBlbnRyeSAqLwoJYnVmbWdyX2dlbS0+ZXhlY19vYmplY3RzW2luZGV4XS5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CglidWZtZ3JfZ2VtLT5leGVjX29iamVjdHNbaW5kZXhdLnJlbG9jYXRpb25fY291bnQgPSBib19nZW0tPnJlbG9jX2NvdW50OwoJYnVmbWdyX2dlbS0+ZXhlY19vYmplY3RzW2luZGV4XS5yZWxvY3NfcHRyID0gKHVpbnRwdHJfdCkgYm9fZ2VtLT5yZWxvY3M7CglidWZtZ3JfZ2VtLT5leGVjX29iamVjdHNbaW5kZXhdLmFsaWdubWVudCA9IGJvLT5hbGlnbjsKCWJ1Zm1ncl9nZW0tPmV4ZWNfb2JqZWN0c1tpbmRleF0ub2Zmc2V0ID0gMDsKCWJ1Zm1ncl9nZW0tPmV4ZWNfYm9zW2luZGV4XSA9IGJvOwoJYnVmbWdyX2dlbS0+ZXhlY19jb3VudCsrOwp9CgpzdGF0aWMgdm9pZApkcm1faW50ZWxfYWRkX3ZhbGlkYXRlX2J1ZmZlcjIoZHJtX2ludGVsX2JvICpibywgaW50IG5lZWRfZmVuY2UpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopYm87CglpbnQgaW5kZXg7CglpbnQgZmxhZ3MgPSAwOwoKCWlmIChuZWVkX2ZlbmNlKQoJCWZsYWdzIHw9IEVYRUNfT0JKRUNUX05FRURTX0ZFTkNFOwoJaWYgKGJvX2dlbS0+dXNlXzQ4Yl9hZGRyZXNzX3JhbmdlKQoJCWZsYWdzIHw9IEVYRUNfT0JKRUNUX1NVUFBPUlRTXzQ4Ql9BRERSRVNTOwoJaWYgKGJvX2dlbS0+aXNfc29mdHBpbikKCQlmbGFncyB8PSBFWEVDX09CSkVDVF9QSU5ORUQ7CgoJaWYgKGJvX2dlbS0+dmFsaWRhdGVfaW5kZXggIT0gLTEpIHsKCQlidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzW2JvX2dlbS0+dmFsaWRhdGVfaW5kZXhdLmZsYWdzIHw9IGZsYWdzOwoJCXJldHVybjsKCX0KCgkvKiBFeHRlbmQgdGhlIGFycmF5IG9mIHZhbGlkYXRpb24gZW50cmllcyBhcyBuZWNlc3NhcnkuICovCglpZiAoYnVmbWdyX2dlbS0+ZXhlY19jb3VudCA9PSBidWZtZ3JfZ2VtLT5leGVjX3NpemUpIHsKCQlpbnQgbmV3X3NpemUgPSBidWZtZ3JfZ2VtLT5leGVjX3NpemUgKiAyOwoKCQlpZiAobmV3X3NpemUgPT0gMCkKCQkJbmV3X3NpemUgPSA1OwoKCQlidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzID0KCQkJcmVhbGxvYyhidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzLAoJCQkJc2l6ZW9mKCpidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzKSAqIG5ld19zaXplKTsKCQlidWZtZ3JfZ2VtLT5leGVjX2JvcyA9CgkJCXJlYWxsb2MoYnVmbWdyX2dlbS0+ZXhlY19ib3MsCgkJCQlzaXplb2YoKmJ1Zm1ncl9nZW0tPmV4ZWNfYm9zKSAqIG5ld19zaXplKTsKCQlidWZtZ3JfZ2VtLT5leGVjX3NpemUgPSBuZXdfc2l6ZTsKCX0KCglpbmRleCA9IGJ1Zm1ncl9nZW0tPmV4ZWNfY291bnQ7Cglib19nZW0tPnZhbGlkYXRlX2luZGV4ID0gaW5kZXg7CgkvKiBGaWxsIGluIGFycmF5IGVudHJ5ICovCglidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzW2luZGV4XS5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CglidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzW2luZGV4XS5yZWxvY2F0aW9uX2NvdW50ID0gYm9fZ2VtLT5yZWxvY19jb3VudDsKCWJ1Zm1ncl9nZW0tPmV4ZWMyX29iamVjdHNbaW5kZXhdLnJlbG9jc19wdHIgPSAodWludHB0cl90KWJvX2dlbS0+cmVsb2NzOwoJYnVmbWdyX2dlbS0+ZXhlYzJfb2JqZWN0c1tpbmRleF0uYWxpZ25tZW50ID0gYm8tPmFsaWduOwoJYnVmbWdyX2dlbS0+ZXhlYzJfb2JqZWN0c1tpbmRleF0ub2Zmc2V0ID0gYm9fZ2VtLT5pc19zb2Z0cGluID8KCQliby0+b2Zmc2V0NjQgOiAwOwoJYnVmbWdyX2dlbS0+ZXhlY19ib3NbaW5kZXhdID0gYm87CglidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzW2luZGV4XS5mbGFncyA9IGZsYWdzOwoJYnVmbWdyX2dlbS0+ZXhlYzJfb2JqZWN0c1tpbmRleF0ucnN2ZDEgPSAwOwoJYnVmbWdyX2dlbS0+ZXhlYzJfb2JqZWN0c1tpbmRleF0ucnN2ZDIgPSAwOwoJYnVmbWdyX2dlbS0+ZXhlY19jb3VudCsrOwp9CgojZGVmaW5lIFJFTE9DX0JVRl9TSVpFKHgpICgoSTkxNV9SRUxPQ19IRUFERVIgKyB4ICogSTkxNV9SRUxPQzBfU1RSSURFKSAqIFwKCXNpemVvZih1aW50MzJfdCkpCgpzdGF0aWMgdm9pZApkcm1faW50ZWxfYm9fZ2VtX3NldF9pbl9hcGVydHVyZV9zaXplKGRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtLAoJCQkJICAgICAgZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtLAoJCQkJICAgICAgdW5zaWduZWQgaW50IGFsaWdubWVudCkKewoJdW5zaWduZWQgaW50IHNpemU7CgoJYXNzZXJ0KCFib19nZW0tPnVzZWRfYXNfcmVsb2NfdGFyZ2V0KTsKCgkvKiBUaGUgb2xkZXIgY2hpcHNldHMgYXJlIGZhci1sZXNzIGZsZXhpYmxlIGluIHRlcm1zIG9mIHRpbGluZywKCSAqIGFuZCByZXF1aXJlIHRpbGVkIGJ1ZmZlciB0byBiZSBzaXplIGFsaWduZWQgaW4gdGhlIGFwZXJ0dXJlLgoJICogVGhpcyBtZWFucyB0aGF0IGluIHRoZSB3b3JzdCBwb3NzaWJsZSBjYXNlIHdlIHdpbGwgbmVlZCBhIGhvbGUKCSAqIHR3aWNlIGFzIGxhcmdlIGFzIHRoZSBvYmplY3QgaW4gb3JkZXIgZm9yIGl0IHRvIGZpdCBpbnRvIHRoZQoJICogYXBlcnR1cmUuIE9wdGltYWwgcGFja2luZyBpcyBmb3Igd2ltcHMuCgkgKi8KCXNpemUgPSBib19nZW0tPmJvLnNpemU7CglpZiAoYnVmbWdyX2dlbS0+Z2VuIDwgNCAmJiBib19nZW0tPnRpbGluZ19tb2RlICE9IEk5MTVfVElMSU5HX05PTkUpIHsKCQl1bnNpZ25lZCBpbnQgbWluX3NpemU7CgoJCWlmIChidWZtZ3JfZ2VtLT5oYXNfcmVsYXhlZF9mZW5jaW5nKSB7CgkJCWlmIChidWZtZ3JfZ2VtLT5nZW4gPT0gMykKCQkJCW1pbl9zaXplID0gMTAyNCoxMDI0OwoJCQllbHNlCgkJCQltaW5fc2l6ZSA9IDUxMioxMDI0OwoKCQkJd2hpbGUgKG1pbl9zaXplIDwgc2l6ZSkKCQkJCW1pbl9zaXplICo9IDI7CgkJfSBlbHNlCgkJCW1pbl9zaXplID0gc2l6ZTsKCgkJLyogQWNjb3VudCBmb3Igd29yc3QtY2FzZSBhbGlnbm1lbnQuICovCgkJYWxpZ25tZW50ID0gTUFYMihhbGlnbm1lbnQsIG1pbl9zaXplKTsKCX0KCglib19nZW0tPnJlbG9jX3RyZWVfc2l6ZSA9IHNpemUgKyBhbGlnbm1lbnQ7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX3NldHVwX3JlbG9jX2xpc3QoZHJtX2ludGVsX2JvICpibykKewoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoJdW5zaWduZWQgaW50IG1heF9yZWxvY3MgPSBidWZtZ3JfZ2VtLT5tYXhfcmVsb2NzOwoKCWlmIChiby0+c2l6ZSAvIDQgPCBtYXhfcmVsb2NzKQoJCW1heF9yZWxvY3MgPSBiby0+c2l6ZSAvIDQ7CgoJYm9fZ2VtLT5yZWxvY3MgPSBtYWxsb2MobWF4X3JlbG9jcyAqCgkJCQlzaXplb2Yoc3RydWN0IGRybV9pOTE1X2dlbV9yZWxvY2F0aW9uX2VudHJ5KSk7Cglib19nZW0tPnJlbG9jX3RhcmdldF9pbmZvID0gbWFsbG9jKG1heF9yZWxvY3MgKgoJCQkJCSAgIHNpemVvZihkcm1faW50ZWxfcmVsb2NfdGFyZ2V0KSk7CglpZiAoYm9fZ2VtLT5yZWxvY3MgPT0gTlVMTCB8fCBib19nZW0tPnJlbG9jX3RhcmdldF9pbmZvID09IE5VTEwpIHsKCQlib19nZW0tPmhhc19lcnJvciA9IHRydWU7CgoJCWZyZWUgKGJvX2dlbS0+cmVsb2NzKTsKCQlib19nZW0tPnJlbG9jcyA9IE5VTEw7CgoJCWZyZWUgKGJvX2dlbS0+cmVsb2NfdGFyZ2V0X2luZm8pOwoJCWJvX2dlbS0+cmVsb2NfdGFyZ2V0X2luZm8gPSBOVUxMOwoKCQlyZXR1cm4gMTsKCX0KCglyZXR1cm4gMDsKfQoKc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2J1c3koZHJtX2ludGVsX2JvICpibykKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJc3RydWN0IGRybV9pOTE1X2dlbV9idXN5IGJ1c3k7CglpbnQgcmV0OwoKCWlmIChib19nZW0tPnJldXNhYmxlICYmIGJvX2dlbS0+aWRsZSkKCQlyZXR1cm4gZmFsc2U7CgoJbWVtY2xlYXIoYnVzeSk7CglidXN5LmhhbmRsZSA9IGJvX2dlbS0+Z2VtX2hhbmRsZTsKCglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwgRFJNX0lPQ1RMX0k5MTVfR0VNX0JVU1ksICZidXN5KTsKCWlmIChyZXQgPT0gMCkgewoJCWJvX2dlbS0+aWRsZSA9ICFidXN5LmJ1c3k7CgkJcmV0dXJuIGJ1c3kuYnVzeTsKCX0gZWxzZSB7CgkJcmV0dXJuIGZhbHNlOwoJfQoJcmV0dXJuIChyZXQgPT0gMCAmJiBidXN5LmJ1c3kpOwp9CgpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fYm9fbWFkdmlzZV9pbnRlcm5hbChkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSwKCQkJCSAgZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtLCBpbnQgc3RhdGUpCnsKCXN0cnVjdCBkcm1faTkxNV9nZW1fbWFkdmlzZSBtYWR2OwoKCW1lbWNsZWFyKG1hZHYpOwoJbWFkdi5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CgltYWR2Lm1hZHYgPSBzdGF0ZTsKCW1hZHYucmV0YWluZWQgPSAxOwoJZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsIERSTV9JT0NUTF9JOTE1X0dFTV9NQURWSVNFLCAmbWFkdik7CgoJcmV0dXJuIG1hZHYucmV0YWluZWQ7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19tYWR2aXNlKGRybV9pbnRlbF9ibyAqYm8sIGludCBtYWR2KQp7CglyZXR1cm4gZHJtX2ludGVsX2dlbV9ib19tYWR2aXNlX2ludGVybmFsCgkJKChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyLAoJCSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibywKCQkgbWFkdik7Cn0KCi8qIGRyb3AgdGhlIG9sZGVzdCBlbnRyaWVzIHRoYXQgaGF2ZSBiZWVuIHB1cmdlZCBieSB0aGUga2VybmVsICovCnN0YXRpYyB2b2lkCmRybV9pbnRlbF9nZW1fYm9fY2FjaGVfcHVyZ2VfYnVja2V0KGRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtLAoJCQkJICAgIHN0cnVjdCBkcm1faW50ZWxfZ2VtX2JvX2J1Y2tldCAqYnVja2V0KQp7Cgl3aGlsZSAoIURSTUxJU1RFTVBUWSgmYnVja2V0LT5oZWFkKSkgewoJCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbTsKCgkJYm9fZ2VtID0gRFJNTElTVEVOVFJZKGRybV9pbnRlbF9ib19nZW0sCgkJCQkgICAgICBidWNrZXQtPmhlYWQubmV4dCwgaGVhZCk7CgkJaWYgKGRybV9pbnRlbF9nZW1fYm9fbWFkdmlzZV9pbnRlcm5hbAoJCSAgICAoYnVmbWdyX2dlbSwgYm9fZ2VtLCBJOTE1X01BRFZfRE9OVE5FRUQpKQoJCQlicmVhazsKCgkJRFJNTElTVERFTCgmYm9fZ2VtLT5oZWFkKTsKCQlkcm1faW50ZWxfZ2VtX2JvX2ZyZWUoJmJvX2dlbS0+Ym8pOwoJfQp9CgpzdGF0aWMgZHJtX2ludGVsX2JvICoKZHJtX2ludGVsX2dlbV9ib19hbGxvY19pbnRlcm5hbChkcm1faW50ZWxfYnVmbWdyICpidWZtZ3IsCgkJCQljb25zdCBjaGFyICpuYW1lLAoJCQkJdW5zaWduZWQgbG9uZyBzaXplLAoJCQkJdW5zaWduZWQgbG9uZyBmbGFncywKCQkJCXVpbnQzMl90IHRpbGluZ19tb2RlLAoJCQkJdW5zaWduZWQgbG9uZyBzdHJpZGUsCgkJCQl1bnNpZ25lZCBpbnQgYWxpZ25tZW50KQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBidWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW07Cgl1bnNpZ25lZCBpbnQgcGFnZV9zaXplID0gZ2V0cGFnZXNpemUoKTsKCWludCByZXQ7CglzdHJ1Y3QgZHJtX2ludGVsX2dlbV9ib19idWNrZXQgKmJ1Y2tldDsKCWJvb2wgYWxsb2NfZnJvbV9jYWNoZTsKCXVuc2lnbmVkIGxvbmcgYm9fc2l6ZTsKCWJvb2wgZm9yX3JlbmRlciA9IGZhbHNlOwoKCWlmIChmbGFncyAmIEJPX0FMTE9DX0ZPUl9SRU5ERVIpCgkJZm9yX3JlbmRlciA9IHRydWU7CgoJLyogUm91bmQgdGhlIGFsbG9jYXRlZCBzaXplIHVwIHRvIGEgcG93ZXIgb2YgdHdvIG51bWJlciBvZiBwYWdlcy4gKi8KCWJ1Y2tldCA9IGRybV9pbnRlbF9nZW1fYm9fYnVja2V0X2Zvcl9zaXplKGJ1Zm1ncl9nZW0sIHNpemUpOwoKCS8qIElmIHdlIGRvbid0IGhhdmUgY2FjaGluZyBhdCB0aGlzIHNpemUsIGRvbid0IGFjdHVhbGx5IHJvdW5kIHRoZQoJICogYWxsb2NhdGlvbiB1cC4KCSAqLwoJaWYgKGJ1Y2tldCA9PSBOVUxMKSB7CgkJYm9fc2l6ZSA9IHNpemU7CgkJaWYgKGJvX3NpemUgPCBwYWdlX3NpemUpCgkJCWJvX3NpemUgPSBwYWdlX3NpemU7Cgl9IGVsc2UgewoJCWJvX3NpemUgPSBidWNrZXQtPnNpemU7Cgl9CgoJcHRocmVhZF9tdXRleF9sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCS8qIEdldCBhIGJ1ZmZlciBvdXQgb2YgdGhlIGNhY2hlIGlmIGF2YWlsYWJsZSAqLwpyZXRyeToKCWFsbG9jX2Zyb21fY2FjaGUgPSBmYWxzZTsKCWlmIChidWNrZXQgIT0gTlVMTCAmJiAhRFJNTElTVEVNUFRZKCZidWNrZXQtPmhlYWQpKSB7CgkJaWYgKGZvcl9yZW5kZXIpIHsKCQkJLyogQWxsb2NhdGUgbmV3IHJlbmRlci10YXJnZXQgQk9zIGZyb20gdGhlIHRhaWwgKE1SVSkKCQkJICogb2YgdGhlIGxpc3QsIGFzIGl0IHdpbGwgbGlrZWx5IGJlIGhvdCBpbiB0aGUgR1BVCgkJCSAqIGNhY2hlIGFuZCBpbiB0aGUgYXBlcnR1cmUgZm9yIHVzLgoJCQkgKi8KCQkJYm9fZ2VtID0gRFJNTElTVEVOVFJZKGRybV9pbnRlbF9ib19nZW0sCgkJCQkJICAgICAgYnVja2V0LT5oZWFkLnByZXYsIGhlYWQpOwoJCQlEUk1MSVNUREVMKCZib19nZW0tPmhlYWQpOwoJCQlhbGxvY19mcm9tX2NhY2hlID0gdHJ1ZTsKCQkJYm9fZ2VtLT5iby5hbGlnbiA9IGFsaWdubWVudDsKCQl9IGVsc2UgewoJCQlhc3NlcnQoYWxpZ25tZW50ID09IDApOwoJCQkvKiBGb3Igbm9uLXJlbmRlci10YXJnZXQgQk9zICh3aGVyZSB3ZSdyZSBwcm9iYWJseQoJCQkgKiBnb2luZyB0byBtYXAgaXQgZmlyc3QgdGhpbmcgaW4gb3JkZXIgdG8gZmlsbCBpdAoJCQkgKiB3aXRoIGRhdGEpLCBjaGVjayBpZiB0aGUgbGFzdCBCTyBpbiB0aGUgY2FjaGUgaXMKCQkJICogdW5idXN5LCBhbmQgb25seSByZXVzZSBpbiB0aGF0IGNhc2UuIE90aGVyd2lzZSwKCQkJICogYWxsb2NhdGluZyBhIG5ldyBidWZmZXIgaXMgcHJvYmFibHkgZmFzdGVyIHRoYW4KCQkJICogd2FpdGluZyBmb3IgdGhlIEdQVSB0byBmaW5pc2guCgkJCSAqLwoJCQlib19nZW0gPSBEUk1MSVNURU5UUlkoZHJtX2ludGVsX2JvX2dlbSwKCQkJCQkgICAgICBidWNrZXQtPmhlYWQubmV4dCwgaGVhZCk7CgkJCWlmICghZHJtX2ludGVsX2dlbV9ib19idXN5KCZib19nZW0tPmJvKSkgewoJCQkJYWxsb2NfZnJvbV9jYWNoZSA9IHRydWU7CgkJCQlEUk1MSVNUREVMKCZib19nZW0tPmhlYWQpOwoJCQl9CgkJfQoKCQlpZiAoYWxsb2NfZnJvbV9jYWNoZSkgewoJCQlpZiAoIWRybV9pbnRlbF9nZW1fYm9fbWFkdmlzZV9pbnRlcm5hbAoJCQkgICAgKGJ1Zm1ncl9nZW0sIGJvX2dlbSwgSTkxNV9NQURWX1dJTExORUVEKSkgewoJCQkJZHJtX2ludGVsX2dlbV9ib19mcmVlKCZib19nZW0tPmJvKTsKCQkJCWRybV9pbnRlbF9nZW1fYm9fY2FjaGVfcHVyZ2VfYnVja2V0KGJ1Zm1ncl9nZW0sCgkJCQkJCQkJICAgIGJ1Y2tldCk7CgkJCQlnb3RvIHJldHJ5OwoJCQl9CgoJCQlpZiAoZHJtX2ludGVsX2dlbV9ib19zZXRfdGlsaW5nX2ludGVybmFsKCZib19nZW0tPmJvLAoJCQkJCQkJCSB0aWxpbmdfbW9kZSwKCQkJCQkJCQkgc3RyaWRlKSkgewoJCQkJZHJtX2ludGVsX2dlbV9ib19mcmVlKCZib19nZW0tPmJvKTsKCQkJCWdvdG8gcmV0cnk7CgkJCX0KCQl9Cgl9CglwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgoJaWYgKCFhbGxvY19mcm9tX2NhY2hlKSB7CgkJc3RydWN0IGRybV9pOTE1X2dlbV9jcmVhdGUgY3JlYXRlOwoKCQlib19nZW0gPSBjYWxsb2MoMSwgc2l6ZW9mKCpib19nZW0pKTsKCQlpZiAoIWJvX2dlbSkKCQkJcmV0dXJuIE5VTEw7CgoJCWJvX2dlbS0+Ym8uc2l6ZSA9IGJvX3NpemU7CgoJCW1lbWNsZWFyKGNyZWF0ZSk7CgkJY3JlYXRlLnNpemUgPSBib19zaXplOwoKCQlyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwKCQkJICAgICAgIERSTV9JT0NUTF9JOTE1X0dFTV9DUkVBVEUsCgkJCSAgICAgICAmY3JlYXRlKTsKCQlib19nZW0tPmdlbV9oYW5kbGUgPSBjcmVhdGUuaGFuZGxlOwoJCWJvX2dlbS0+Ym8uaGFuZGxlID0gYm9fZ2VtLT5nZW1faGFuZGxlOwoJCWlmIChyZXQgIT0gMCkgewoJCQlmcmVlKGJvX2dlbSk7CgkJCXJldHVybiBOVUxMOwoJCX0KCQlib19nZW0tPmJvLmJ1Zm1nciA9IGJ1Zm1ncjsKCQlib19nZW0tPmJvLmFsaWduID0gYWxpZ25tZW50OwoKCQlib19nZW0tPnRpbGluZ19tb2RlID0gSTkxNV9USUxJTkdfTk9ORTsKCQlib19nZW0tPnN3aXp6bGVfbW9kZSA9IEk5MTVfQklUXzZfU1dJWlpMRV9OT05FOwoJCWJvX2dlbS0+c3RyaWRlID0gMDsKCgkJLyogZHJtX2ludGVsX2dlbV9ib19mcmVlIGNhbGxzIERSTUxJU1RERUwoKSBmb3IgYW4gdW5pbml0aWFsaXplZAoJCSAgIGxpc3QgKHZtYV9saXN0KSwgc28gYmV0dGVyIHNldCB0aGUgbGlzdCBoZWFkIGhlcmUgKi8KCQlEUk1JTklUTElTVEhFQUQoJmJvX2dlbS0+bmFtZV9saXN0KTsKCQlEUk1JTklUTElTVEhFQUQoJmJvX2dlbS0+dm1hX2xpc3QpOwoJCWlmIChkcm1faW50ZWxfZ2VtX2JvX3NldF90aWxpbmdfaW50ZXJuYWwoJmJvX2dlbS0+Ym8sCgkJCQkJCQkgdGlsaW5nX21vZGUsCgkJCQkJCQkgc3RyaWRlKSkgewoJCSAgICBkcm1faW50ZWxfZ2VtX2JvX2ZyZWUoJmJvX2dlbS0+Ym8pOwoJCSAgICByZXR1cm4gTlVMTDsKCQl9Cgl9CgoJYm9fZ2VtLT5uYW1lID0gbmFtZTsKCWF0b21pY19zZXQoJmJvX2dlbS0+cmVmY291bnQsIDEpOwoJYm9fZ2VtLT52YWxpZGF0ZV9pbmRleCA9IC0xOwoJYm9fZ2VtLT5yZWxvY190cmVlX2ZlbmNlcyA9IDA7Cglib19nZW0tPnVzZWRfYXNfcmVsb2NfdGFyZ2V0ID0gZmFsc2U7Cglib19nZW0tPmhhc19lcnJvciA9IGZhbHNlOwoJYm9fZ2VtLT5yZXVzYWJsZSA9IHRydWU7Cglib19nZW0tPnVzZV80OGJfYWRkcmVzc19yYW5nZSA9IGZhbHNlOwoKCWRybV9pbnRlbF9ib19nZW1fc2V0X2luX2FwZXJ0dXJlX3NpemUoYnVmbWdyX2dlbSwgYm9fZ2VtLCBhbGlnbm1lbnQpOwoKCURCRygiYm9fY3JlYXRlOiBidWYgJWQgKCVzKSAlbGRiXG4iLAoJICAgIGJvX2dlbS0+Z2VtX2hhbmRsZSwgYm9fZ2VtLT5uYW1lLCBzaXplKTsKCglyZXR1cm4gJmJvX2dlbS0+Ym87Cn0KCnN0YXRpYyBkcm1faW50ZWxfYm8gKgpkcm1faW50ZWxfZ2VtX2JvX2FsbG9jX2Zvcl9yZW5kZXIoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyLAoJCQkJICBjb25zdCBjaGFyICpuYW1lLAoJCQkJICB1bnNpZ25lZCBsb25nIHNpemUsCgkJCQkgIHVuc2lnbmVkIGludCBhbGlnbm1lbnQpCnsKCXJldHVybiBkcm1faW50ZWxfZ2VtX2JvX2FsbG9jX2ludGVybmFsKGJ1Zm1nciwgbmFtZSwgc2l6ZSwKCQkJCQkgICAgICAgQk9fQUxMT0NfRk9SX1JFTkRFUiwKCQkJCQkgICAgICAgSTkxNV9USUxJTkdfTk9ORSwgMCwKCQkJCQkgICAgICAgYWxpZ25tZW50KTsKfQoKc3RhdGljIGRybV9pbnRlbF9ibyAqCmRybV9pbnRlbF9nZW1fYm9fYWxsb2MoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyLAoJCSAgICAgICBjb25zdCBjaGFyICpuYW1lLAoJCSAgICAgICB1bnNpZ25lZCBsb25nIHNpemUsCgkJICAgICAgIHVuc2lnbmVkIGludCBhbGlnbm1lbnQpCnsKCXJldHVybiBkcm1faW50ZWxfZ2VtX2JvX2FsbG9jX2ludGVybmFsKGJ1Zm1nciwgbmFtZSwgc2l6ZSwgMCwKCQkJCQkgICAgICAgSTkxNV9USUxJTkdfTk9ORSwgMCwgMCk7Cn0KCnN0YXRpYyBkcm1faW50ZWxfYm8gKgpkcm1faW50ZWxfZ2VtX2JvX2FsbG9jX3RpbGVkKGRybV9pbnRlbF9idWZtZ3IgKmJ1Zm1nciwgY29uc3QgY2hhciAqbmFtZSwKCQkJICAgICBpbnQgeCwgaW50IHksIGludCBjcHAsIHVpbnQzMl90ICp0aWxpbmdfbW9kZSwKCQkJICAgICB1bnNpZ25lZCBsb25nICpwaXRjaCwgdW5zaWduZWQgbG9uZyBmbGFncykKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKilidWZtZ3I7Cgl1bnNpZ25lZCBsb25nIHNpemUsIHN0cmlkZTsKCXVpbnQzMl90IHRpbGluZzsKCglkbyB7CgkJdW5zaWduZWQgbG9uZyBhbGlnbmVkX3ksIGhlaWdodF9hbGlnbm1lbnQ7CgoJCXRpbGluZyA9ICp0aWxpbmdfbW9kZTsKCgkJLyogSWYgd2UncmUgdGlsZWQsIG91ciBhbGxvY2F0aW9ucyBhcmUgaW4gOCBvciAzMi1yb3cgYmxvY2tzLAoJCSAqIHNvIGZhaWx1cmUgdG8gYWxpZ24gb3VyIGhlaWdodCBtZWFucyB0aGF0IHdlIHdvbid0IGFsbG9jYXRlCgkJICogZW5vdWdoIHBhZ2VzLgoJCSAqCgkJICogSWYgd2UncmUgdW50aWxlZCwgd2Ugc3RpbGwgaGF2ZSB0byBhbGlnbiB0byAyIHJvd3MgaGlnaAoJCSAqIGJlY2F1c2UgdGhlIGRhdGEgcG9ydCBhY2Nlc3NlcyAyeDIgYmxvY2tzIGV2ZW4gaWYgdGhlCgkJICogYm90dG9tIHJvdyBpc24ndCB0byBiZSByZW5kZXJlZCwgc28gZmFpbHVyZSB0byBhbGlnbiBtZWFucwoJCSAqIHdlIGNvdWxkIHdhbGsgb2ZmIHRoZSBlbmQgb2YgdGhlIEdUVCBhbmQgZmF1bHQuICBUaGlzIGlzCgkJICogZG9jdW1lbnRlZCBvbiA5NjUsIGFuZCBtYXkgYmUgdGhlIGNhc2Ugb24gb2xkZXIgY2hpcHNldHMKCQkgKiB0b28gc28gd2UgdHJ5IHRvIGJlIGNhcmVmdWwuCgkJICovCgkJYWxpZ25lZF95ID0geTsKCQloZWlnaHRfYWxpZ25tZW50ID0gMjsKCgkJaWYgKChidWZtZ3JfZ2VtLT5nZW4gPT0gMikgJiYgdGlsaW5nICE9IEk5MTVfVElMSU5HX05PTkUpCgkJCWhlaWdodF9hbGlnbm1lbnQgPSAxNjsKCQllbHNlIGlmICh0aWxpbmcgPT0gSTkxNV9USUxJTkdfWAoJCQl8fCAoSVNfOTE1KGJ1Zm1ncl9nZW0tPnBjaV9kZXZpY2UpCgkJCSAgICAmJiB0aWxpbmcgPT0gSTkxNV9USUxJTkdfWSkpCgkJCWhlaWdodF9hbGlnbm1lbnQgPSA4OwoJCWVsc2UgaWYgKHRpbGluZyA9PSBJOTE1X1RJTElOR19ZKQoJCQloZWlnaHRfYWxpZ25tZW50ID0gMzI7CgkJYWxpZ25lZF95ID0gQUxJR04oeSwgaGVpZ2h0X2FsaWdubWVudCk7CgoJCXN0cmlkZSA9IHggKiBjcHA7CgkJc3RyaWRlID0gZHJtX2ludGVsX2dlbV9ib190aWxlX3BpdGNoKGJ1Zm1ncl9nZW0sIHN0cmlkZSwgdGlsaW5nX21vZGUpOwoJCXNpemUgPSBzdHJpZGUgKiBhbGlnbmVkX3k7CgkJc2l6ZSA9IGRybV9pbnRlbF9nZW1fYm9fdGlsZV9zaXplKGJ1Zm1ncl9nZW0sIHNpemUsIHRpbGluZ19tb2RlKTsKCX0gd2hpbGUgKCp0aWxpbmdfbW9kZSAhPSB0aWxpbmcpOwoJKnBpdGNoID0gc3RyaWRlOwoKCWlmICh0aWxpbmcgPT0gSTkxNV9USUxJTkdfTk9ORSkKCQlzdHJpZGUgPSAwOwoKCXJldHVybiBkcm1faW50ZWxfZ2VtX2JvX2FsbG9jX2ludGVybmFsKGJ1Zm1nciwgbmFtZSwgc2l6ZSwgZmxhZ3MsCgkJCQkJICAgICAgIHRpbGluZywgc3RyaWRlLCAwKTsKfQoKc3RhdGljIGRybV9pbnRlbF9ibyAqCmRybV9pbnRlbF9nZW1fYm9fYWxsb2NfdXNlcnB0cihkcm1faW50ZWxfYnVmbWdyICpidWZtZ3IsCgkJCQljb25zdCBjaGFyICpuYW1lLAoJCQkJdm9pZCAqYWRkciwKCQkJCXVpbnQzMl90IHRpbGluZ19tb2RlLAoJCQkJdWludDMyX3Qgc3RyaWRlLAoJCQkJdW5zaWduZWQgbG9uZyBzaXplLAoJCQkJdW5zaWduZWQgbG9uZyBmbGFncykKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYnVmbWdyOwoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtOwoJaW50IHJldDsKCXN0cnVjdCBkcm1faTkxNV9nZW1fdXNlcnB0ciB1c2VycHRyOwoKCS8qIFRpbGluZyB3aXRoIHVzZXJwdHIgc3VyZmFjZXMgaXMgbm90IHN1cHBvcnRlZAoJICogb24gYWxsIGhhcmR3YXJlIHNvIHJlZnVzZSBpdCBmb3IgdGltZSBiZWluZy4KCSAqLwoJaWYgKHRpbGluZ19tb2RlICE9IEk5MTVfVElMSU5HX05PTkUpCgkJcmV0dXJuIE5VTEw7CgoJYm9fZ2VtID0gY2FsbG9jKDEsIHNpemVvZigqYm9fZ2VtKSk7CglpZiAoIWJvX2dlbSkKCQlyZXR1cm4gTlVMTDsKCglib19nZW0tPmJvLnNpemUgPSBzaXplOwoKCW1lbWNsZWFyKHVzZXJwdHIpOwoJdXNlcnB0ci51c2VyX3B0ciA9IChfX3U2NCkoKHVuc2lnbmVkIGxvbmcpYWRkcik7Cgl1c2VycHRyLnVzZXJfc2l6ZSA9IHNpemU7Cgl1c2VycHRyLmZsYWdzID0gZmxhZ3M7CgoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsCgkJCURSTV9JT0NUTF9JOTE1X0dFTV9VU0VSUFRSLAoJCQkmdXNlcnB0cik7CglpZiAocmV0ICE9IDApIHsKCQlEQkcoImJvX2NyZWF0ZV91c2VycHRyOiAiCgkJICAgICJpb2N0bCBmYWlsZWQgd2l0aCB1c2VyIHB0ciAlcCBzaXplIDB4JWx4LCAiCgkJICAgICJ1c2VyIGZsYWdzIDB4JWx4XG4iLCBhZGRyLCBzaXplLCBmbGFncyk7CgkJZnJlZShib19nZW0pOwoJCXJldHVybiBOVUxMOwoJfQoKCWJvX2dlbS0+Z2VtX2hhbmRsZSA9IHVzZXJwdHIuaGFuZGxlOwoJYm9fZ2VtLT5iby5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7Cglib19nZW0tPmJvLmJ1Zm1nciAgICA9IGJ1Zm1ncjsKCWJvX2dlbS0+aXNfdXNlcnB0ciAgID0gdHJ1ZTsKCWJvX2dlbS0+Ym8udmlydHVhbCAgID0gYWRkcjsKCS8qIFNhdmUgdGhlIGFkZHJlc3MgcHJvdmlkZWQgYnkgdXNlciAqLwoJYm9fZ2VtLT51c2VyX3ZpcnR1YWwgPSBhZGRyOwoJYm9fZ2VtLT50aWxpbmdfbW9kZSAgPSBJOTE1X1RJTElOR19OT05FOwoJYm9fZ2VtLT5zd2l6emxlX21vZGUgPSBJOTE1X0JJVF82X1NXSVpaTEVfTk9ORTsKCWJvX2dlbS0+c3RyaWRlICAgICAgID0gMDsKCglEUk1JTklUTElTVEhFQUQoJmJvX2dlbS0+bmFtZV9saXN0KTsKCURSTUlOSVRMSVNUSEVBRCgmYm9fZ2VtLT52bWFfbGlzdCk7CgoJYm9fZ2VtLT5uYW1lID0gbmFtZTsKCWF0b21pY19zZXQoJmJvX2dlbS0+cmVmY291bnQsIDEpOwoJYm9fZ2VtLT52YWxpZGF0ZV9pbmRleCA9IC0xOwoJYm9fZ2VtLT5yZWxvY190cmVlX2ZlbmNlcyA9IDA7Cglib19nZW0tPnVzZWRfYXNfcmVsb2NfdGFyZ2V0ID0gZmFsc2U7Cglib19nZW0tPmhhc19lcnJvciA9IGZhbHNlOwoJYm9fZ2VtLT5yZXVzYWJsZSA9IGZhbHNlOwoJYm9fZ2VtLT51c2VfNDhiX2FkZHJlc3NfcmFuZ2UgPSBmYWxzZTsKCglkcm1faW50ZWxfYm9fZ2VtX3NldF9pbl9hcGVydHVyZV9zaXplKGJ1Zm1ncl9nZW0sIGJvX2dlbSwgMCk7CgoJREJHKCJib19jcmVhdGVfdXNlcnB0cjogIgoJICAgICJwdHIgJXAgYnVmICVkICglcykgc2l6ZSAlbGRiLCBzdHJpZGUgMHgleCwgdGlsZSBtb2RlICVkXG4iLAoJCWFkZHIsIGJvX2dlbS0+Z2VtX2hhbmRsZSwgYm9fZ2VtLT5uYW1lLAoJCXNpemUsIHN0cmlkZSwgdGlsaW5nX21vZGUpOwoKCXJldHVybiAmYm9fZ2VtLT5ibzsKfQoKc3RhdGljIGJvb2wKaGFzX3VzZXJwdHIoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0pCnsKCWludCByZXQ7Cgl2b2lkICpwdHI7Cglsb25nIHBnc3o7CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX3VzZXJwdHIgdXNlcnB0cjsKCglwZ3N6ID0gc3lzY29uZihfU0NfUEFHRVNJWkUpOwoJYXNzZXJ0KHBnc3ogPiAwKTsKCglyZXQgPSBwb3NpeF9tZW1hbGlnbigmcHRyLCBwZ3N6LCBwZ3N6KTsKCWlmIChyZXQpIHsKCQlEQkcoIkZhaWxlZCB0byBnZXQgYSBwYWdlICglbGQpIGZvciB1c2VycHRyIGRldGVjdGlvbiFcbiIsCgkJCXBnc3opOwoJCXJldHVybiBmYWxzZTsKCX0KCgltZW1jbGVhcih1c2VycHRyKTsKCXVzZXJwdHIudXNlcl9wdHIgPSAoX191NjQpKHVuc2lnbmVkIGxvbmcpcHRyOwoJdXNlcnB0ci51c2VyX3NpemUgPSBwZ3N6OwoKcmV0cnk6CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwgRFJNX0lPQ1RMX0k5MTVfR0VNX1VTRVJQVFIsICZ1c2VycHRyKTsKCWlmIChyZXQpIHsKCQlpZiAoZXJybm8gPT0gRU5PREVWICYmIHVzZXJwdHIuZmxhZ3MgPT0gMCkgewoJCQl1c2VycHRyLmZsYWdzID0gSTkxNV9VU0VSUFRSX1VOU1lOQ0hST05JWkVEOwoJCQlnb3RvIHJldHJ5OwoJCX0KCQlmcmVlKHB0cik7CgkJcmV0dXJuIGZhbHNlOwoJfQoKCS8qIFdlIGRvbid0IHJlbGVhc2UgdGhlIHVzZXJwdHIgYm8gaGVyZSBhcyB3ZSB3YW50IHRvIGtlZXAgdGhlCgkgKiBrZXJuZWwgbW0gdHJhY2tpbmcgYWxpdmUgZm9yIG91ciBsaWZldGltZS4gVGhlIGZpcnN0IHRpbWUgd2UKCSAqIGNyZWF0ZSBhIHVzZXJwdHIgb2JqZWN0IHRoZSBrZXJuZWwgaGFzIHRvIGluc3RhbGwgYSBtbXVfbm90aWZlcgoJICogd2hpY2ggaXMgYSBoZWF2eXdlaWdodCBvcGVyYXRpb24gKGUuZy4gaXQgcmVxdWlyZXMgdGFraW5nIGFsbAoJICogbW1fbG9ja3MgYW5kIHN0b3BfbWFjaGluZSgpKS4KCSAqLwoKCWJ1Zm1ncl9nZW0tPnVzZXJwdHJfYWN0aXZlLnB0ciA9IHB0cjsKCWJ1Zm1ncl9nZW0tPnVzZXJwdHJfYWN0aXZlLmhhbmRsZSA9IHVzZXJwdHIuaGFuZGxlOwoKCXJldHVybiB0cnVlOwp9CgpzdGF0aWMgZHJtX2ludGVsX2JvICoKY2hlY2tfYm9fYWxsb2NfdXNlcnB0cihkcm1faW50ZWxfYnVmbWdyICpidWZtZ3IsCgkJICAgICAgIGNvbnN0IGNoYXIgKm5hbWUsCgkJICAgICAgIHZvaWQgKmFkZHIsCgkJICAgICAgIHVpbnQzMl90IHRpbGluZ19tb2RlLAoJCSAgICAgICB1aW50MzJfdCBzdHJpZGUsCgkJICAgICAgIHVuc2lnbmVkIGxvbmcgc2l6ZSwKCQkgICAgICAgdW5zaWduZWQgbG9uZyBmbGFncykKewoJaWYgKGhhc191c2VycHRyKChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKWJ1Zm1ncikpCgkJYnVmbWdyLT5ib19hbGxvY191c2VycHRyID0gZHJtX2ludGVsX2dlbV9ib19hbGxvY191c2VycHRyOwoJZWxzZQoJCWJ1Zm1nci0+Ym9fYWxsb2NfdXNlcnB0ciA9IE5VTEw7CgoJcmV0dXJuIGRybV9pbnRlbF9ib19hbGxvY191c2VycHRyKGJ1Zm1nciwgbmFtZSwgYWRkciwKCQkJCQkgIHRpbGluZ19tb2RlLCBzdHJpZGUsIHNpemUsIGZsYWdzKTsKfQoKLyoqCiAqIFJldHVybnMgYSBkcm1faW50ZWxfYm8gd3JhcHBpbmcgdGhlIGdpdmVuIGJ1ZmZlciBvYmplY3QgaGFuZGxlLgogKgogKiBUaGlzIGNhbiBiZSB1c2VkIHdoZW4gb25lIGFwcGxpY2F0aW9uIG5lZWRzIHRvIHBhc3MgYSBidWZmZXIgb2JqZWN0CiAqIHRvIGFub3RoZXIuCiAqLwpkcm1faW50ZWxfYm8gKgpkcm1faW50ZWxfYm9fZ2VtX2NyZWF0ZV9mcm9tX25hbWUoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyLAoJCQkJICBjb25zdCBjaGFyICpuYW1lLAoJCQkJICB1bnNpZ25lZCBpbnQgaGFuZGxlKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBidWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW07CglpbnQgcmV0OwoJc3RydWN0IGRybV9nZW1fb3BlbiBvcGVuX2FyZzsKCXN0cnVjdCBkcm1faTkxNV9nZW1fZ2V0X3RpbGluZyBnZXRfdGlsaW5nOwoJZHJtTU1MaXN0SGVhZCAqbGlzdDsKCgkvKiBBdCB0aGUgbW9tZW50IG1vc3QgYXBwbGljYXRpb25zIG9ubHkgaGF2ZSBhIGZldyBuYW1lZCBiby4KCSAqIEZvciBpbnN0YW5jZSwgaW4gYSBEUkkgY2xpZW50IG9ubHkgdGhlIHJlbmRlciBidWZmZXJzIHBhc3NlZAoJICogYmV0d2VlbiBYIGFuZCB0aGUgY2xpZW50IGFyZSBuYW1lZC4gQW5kIHNpbmNlIFggcmV0dXJucyB0aGUKCSAqIGFsdGVybmF0aW5nIG5hbWVzIGZvciB0aGUgZnJvbnQvYmFjayBidWZmZXIgYSBsaW5lYXIgc2VhcmNoCgkgKiBwcm92aWRlcyBhIHN1ZmZpY2llbnRseSBmYXN0IG1hdGNoLgoJICovCglwdGhyZWFkX211dGV4X2xvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoJZm9yIChsaXN0ID0gYnVmbWdyX2dlbS0+bmFtZWQubmV4dDsKCSAgICAgbGlzdCAhPSAmYnVmbWdyX2dlbS0+bmFtZWQ7CgkgICAgIGxpc3QgPSBsaXN0LT5uZXh0KSB7CgkJYm9fZ2VtID0gRFJNTElTVEVOVFJZKGRybV9pbnRlbF9ib19nZW0sIGxpc3QsIG5hbWVfbGlzdCk7CgkJaWYgKGJvX2dlbS0+Z2xvYmFsX25hbWUgPT0gaGFuZGxlKSB7CgkJCWRybV9pbnRlbF9nZW1fYm9fcmVmZXJlbmNlKCZib19nZW0tPmJvKTsKCQkJcHRocmVhZF9tdXRleF91bmxvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoJCQlyZXR1cm4gJmJvX2dlbS0+Ym87CgkJfQoJfQoKCW1lbWNsZWFyKG9wZW5fYXJnKTsKCW9wZW5fYXJnLm5hbWUgPSBoYW5kbGU7CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwKCQkgICAgICAgRFJNX0lPQ1RMX0dFTV9PUEVOLAoJCSAgICAgICAmb3Blbl9hcmcpOwoJaWYgKHJldCAhPSAwKSB7CgkJREJHKCJDb3VsZG4ndCByZWZlcmVuY2UgJXMgaGFuZGxlIDB4JTA4eDogJXNcbiIsCgkJICAgIG5hbWUsIGhhbmRsZSwgc3RyZXJyb3IoZXJybm8pKTsKCQlwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgkJcmV0dXJuIE5VTEw7Cgl9CiAgICAgICAgLyogTm93IHNlZSBpZiBzb21lb25lIGhhcyB1c2VkIGEgcHJpbWUgaGFuZGxlIHRvIGdldCB0aGlzCiAgICAgICAgICogb2JqZWN0IGZyb20gdGhlIGtlcm5lbCBiZWZvcmUgYnkgbG9va2luZyB0aHJvdWdoIHRoZSBsaXN0CiAgICAgICAgICogYWdhaW4gZm9yIGEgbWF0Y2hpbmcgZ2VtX2hhbmRsZQogICAgICAgICAqLwoJZm9yIChsaXN0ID0gYnVmbWdyX2dlbS0+bmFtZWQubmV4dDsKCSAgICAgbGlzdCAhPSAmYnVmbWdyX2dlbS0+bmFtZWQ7CgkgICAgIGxpc3QgPSBsaXN0LT5uZXh0KSB7CgkJYm9fZ2VtID0gRFJNTElTVEVOVFJZKGRybV9pbnRlbF9ib19nZW0sIGxpc3QsIG5hbWVfbGlzdCk7CgkJaWYgKGJvX2dlbS0+Z2VtX2hhbmRsZSA9PSBvcGVuX2FyZy5oYW5kbGUpIHsKCQkJZHJtX2ludGVsX2dlbV9ib19yZWZlcmVuY2UoJmJvX2dlbS0+Ym8pOwoJCQlwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgkJCXJldHVybiAmYm9fZ2VtLT5ibzsKCQl9Cgl9CgoJYm9fZ2VtID0gY2FsbG9jKDEsIHNpemVvZigqYm9fZ2VtKSk7CglpZiAoIWJvX2dlbSkgewoJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCQlyZXR1cm4gTlVMTDsKCX0KCglib19nZW0tPmJvLnNpemUgPSBvcGVuX2FyZy5zaXplOwoJYm9fZ2VtLT5iby5vZmZzZXQgPSAwOwoJYm9fZ2VtLT5iby5vZmZzZXQ2NCA9IDA7Cglib19nZW0tPmJvLnZpcnR1YWwgPSBOVUxMOwoJYm9fZ2VtLT5iby5idWZtZ3IgPSBidWZtZ3I7Cglib19nZW0tPm5hbWUgPSBuYW1lOwoJYXRvbWljX3NldCgmYm9fZ2VtLT5yZWZjb3VudCwgMSk7Cglib19nZW0tPnZhbGlkYXRlX2luZGV4ID0gLTE7Cglib19nZW0tPmdlbV9oYW5kbGUgPSBvcGVuX2FyZy5oYW5kbGU7Cglib19nZW0tPmJvLmhhbmRsZSA9IG9wZW5fYXJnLmhhbmRsZTsKCWJvX2dlbS0+Z2xvYmFsX25hbWUgPSBoYW5kbGU7Cglib19nZW0tPnJldXNhYmxlID0gZmFsc2U7Cglib19nZW0tPnVzZV80OGJfYWRkcmVzc19yYW5nZSA9IGZhbHNlOwoKCW1lbWNsZWFyKGdldF90aWxpbmcpOwoJZ2V0X3RpbGluZy5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwKCQkgICAgICAgRFJNX0lPQ1RMX0k5MTVfR0VNX0dFVF9USUxJTkcsCgkJICAgICAgICZnZXRfdGlsaW5nKTsKCWlmIChyZXQgIT0gMCkgewoJCWRybV9pbnRlbF9nZW1fYm9fdW5yZWZlcmVuY2UoJmJvX2dlbS0+Ym8pOwoJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCQlyZXR1cm4gTlVMTDsKCX0KCWJvX2dlbS0+dGlsaW5nX21vZGUgPSBnZXRfdGlsaW5nLnRpbGluZ19tb2RlOwoJYm9fZ2VtLT5zd2l6emxlX21vZGUgPSBnZXRfdGlsaW5nLnN3aXp6bGVfbW9kZTsKCS8qIFhYWCBzdHJpZGUgaXMgdW5rbm93biAqLwoJZHJtX2ludGVsX2JvX2dlbV9zZXRfaW5fYXBlcnR1cmVfc2l6ZShidWZtZ3JfZ2VtLCBib19nZW0sIDApOwoKCURSTUlOSVRMSVNUSEVBRCgmYm9fZ2VtLT52bWFfbGlzdCk7CglEUk1MSVNUQUREVEFJTCgmYm9fZ2VtLT5uYW1lX2xpc3QsICZidWZtZ3JfZ2VtLT5uYW1lZCk7CglwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CglEQkcoImJvX2NyZWF0ZV9mcm9tX2hhbmRsZTogJWQgKCVzKVxuIiwgaGFuZGxlLCBib19nZW0tPm5hbWUpOwoKCXJldHVybiAmYm9fZ2VtLT5ibzsKfQoKc3RhdGljIHZvaWQKZHJtX2ludGVsX2dlbV9ib19mcmVlKGRybV9pbnRlbF9ibyAqYm8pCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCXN0cnVjdCBkcm1fZ2VtX2Nsb3NlIGNsb3NlOwoJaW50IHJldDsKCglEUk1MSVNUREVMKCZib19nZW0tPnZtYV9saXN0KTsKCWlmIChib19nZW0tPm1lbV92aXJ0dWFsKSB7CgkJVkcoVkFMR1JJTkRfRlJFRUxJS0VfQkxPQ0soYm9fZ2VtLT5tZW1fdmlydHVhbCwgMCkpOwoJCWRybV9tdW5tYXAoYm9fZ2VtLT5tZW1fdmlydHVhbCwgYm9fZ2VtLT5iby5zaXplKTsKCQlidWZtZ3JfZ2VtLT52bWFfY291bnQtLTsKCX0KCWlmIChib19nZW0tPmd0dF92aXJ0dWFsKSB7CgkJZHJtX211bm1hcChib19nZW0tPmd0dF92aXJ0dWFsLCBib19nZW0tPmJvLnNpemUpOwoJCWJ1Zm1ncl9nZW0tPnZtYV9jb3VudC0tOwoJfQoKCS8qIENsb3NlIHRoaXMgb2JqZWN0ICovCgltZW1jbGVhcihjbG9zZSk7CgljbG9zZS5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwgRFJNX0lPQ1RMX0dFTV9DTE9TRSwgJmNsb3NlKTsKCWlmIChyZXQgIT0gMCkgewoJCURCRygiRFJNX0lPQ1RMX0dFTV9DTE9TRSAlZCBmYWlsZWQgKCVzKTogJXNcbiIsCgkJICAgIGJvX2dlbS0+Z2VtX2hhbmRsZSwgYm9fZ2VtLT5uYW1lLCBzdHJlcnJvcihlcnJubykpOwoJfQoJZnJlZShibyk7Cn0KCnN0YXRpYyB2b2lkCmRybV9pbnRlbF9nZW1fYm9fbWFya19tbWFwc19pbmNvaGVyZW50KGRybV9pbnRlbF9ibyAqYm8pCnsKI2lmIEhBVkVfVkFMR1JJTkQKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoKCWlmIChib19nZW0tPm1lbV92aXJ0dWFsKQoJCVZBTEdSSU5EX01BS0VfTUVNX05PQUNDRVNTKGJvX2dlbS0+bWVtX3ZpcnR1YWwsIGJvLT5zaXplKTsKCglpZiAoYm9fZ2VtLT5ndHRfdmlydHVhbCkKCQlWQUxHUklORF9NQUtFX01FTV9OT0FDQ0VTUyhib19nZW0tPmd0dF92aXJ0dWFsLCBiby0+c2l6ZSk7CiNlbmRpZgp9CgovKiogRnJlZXMgYWxsIGNhY2hlZCBidWZmZXJzIHNpZ25pZmljYW50bHkgb2xkZXIgdGhhbiBAdGltZS4gKi8Kc3RhdGljIHZvaWQKZHJtX2ludGVsX2dlbV9jbGVhbnVwX2JvX2NhY2hlKGRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtLCB0aW1lX3QgdGltZSkKewoJaW50IGk7CgoJaWYgKGJ1Zm1ncl9nZW0tPnRpbWUgPT0gdGltZSkKCQlyZXR1cm47CgoJZm9yIChpID0gMDsgaSA8IGJ1Zm1ncl9nZW0tPm51bV9idWNrZXRzOyBpKyspIHsKCQlzdHJ1Y3QgZHJtX2ludGVsX2dlbV9ib19idWNrZXQgKmJ1Y2tldCA9CgkJICAgICZidWZtZ3JfZ2VtLT5jYWNoZV9idWNrZXRbaV07CgoJCXdoaWxlICghRFJNTElTVEVNUFRZKCZidWNrZXQtPmhlYWQpKSB7CgkJCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbTsKCgkJCWJvX2dlbSA9IERSTUxJU1RFTlRSWShkcm1faW50ZWxfYm9fZ2VtLAoJCQkJCSAgICAgIGJ1Y2tldC0+aGVhZC5uZXh0LCBoZWFkKTsKCQkJaWYgKHRpbWUgLSBib19nZW0tPmZyZWVfdGltZSA8PSAxKQoJCQkJYnJlYWs7CgoJCQlEUk1MSVNUREVMKCZib19nZW0tPmhlYWQpOwoKCQkJZHJtX2ludGVsX2dlbV9ib19mcmVlKCZib19nZW0tPmJvKTsKCQl9Cgl9CgoJYnVmbWdyX2dlbS0+dGltZSA9IHRpbWU7Cn0KCnN0YXRpYyB2b2lkIGRybV9pbnRlbF9nZW1fYm9fcHVyZ2Vfdm1hX2NhY2hlKGRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtKQp7CglpbnQgbGltaXQ7CgoJREJHKCIlczogY2FjaGVkPSVkLCBvcGVuPSVkLCBsaW1pdD0lZFxuIiwgX19GVU5DVElPTl9fLAoJICAgIGJ1Zm1ncl9nZW0tPnZtYV9jb3VudCwgYnVmbWdyX2dlbS0+dm1hX29wZW4sIGJ1Zm1ncl9nZW0tPnZtYV9tYXgpOwoKCWlmIChidWZtZ3JfZ2VtLT52bWFfbWF4IDwgMCkKCQlyZXR1cm47CgoJLyogV2UgbWF5IG5lZWQgdG8gZXZpY3QgYSBmZXcgZW50cmllcyBpbiBvcmRlciB0byBjcmVhdGUgbmV3IG1tYXBzICovCglsaW1pdCA9IGJ1Zm1ncl9nZW0tPnZtYV9tYXggLSAyKmJ1Zm1ncl9nZW0tPnZtYV9vcGVuOwoJaWYgKGxpbWl0IDwgMCkKCQlsaW1pdCA9IDA7CgoJd2hpbGUgKGJ1Zm1ncl9nZW0tPnZtYV9jb3VudCA+IGxpbWl0KSB7CgkJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtOwoKCQlib19nZW0gPSBEUk1MSVNURU5UUlkoZHJtX2ludGVsX2JvX2dlbSwKCQkJCSAgICAgIGJ1Zm1ncl9nZW0tPnZtYV9jYWNoZS5uZXh0LAoJCQkJICAgICAgdm1hX2xpc3QpOwoJCWFzc2VydChib19nZW0tPm1hcF9jb3VudCA9PSAwKTsKCQlEUk1MSVNUREVMSU5JVCgmYm9fZ2VtLT52bWFfbGlzdCk7CgoJCWlmIChib19nZW0tPm1lbV92aXJ0dWFsKSB7CgkJCWRybV9tdW5tYXAoYm9fZ2VtLT5tZW1fdmlydHVhbCwgYm9fZ2VtLT5iby5zaXplKTsKCQkJYm9fZ2VtLT5tZW1fdmlydHVhbCA9IE5VTEw7CgkJCWJ1Zm1ncl9nZW0tPnZtYV9jb3VudC0tOwoJCX0KCQlpZiAoYm9fZ2VtLT5ndHRfdmlydHVhbCkgewoJCQlkcm1fbXVubWFwKGJvX2dlbS0+Z3R0X3ZpcnR1YWwsIGJvX2dlbS0+Ym8uc2l6ZSk7CgkJCWJvX2dlbS0+Z3R0X3ZpcnR1YWwgPSBOVUxMOwoJCQlidWZtZ3JfZ2VtLT52bWFfY291bnQtLTsKCQl9Cgl9Cn0KCnN0YXRpYyB2b2lkIGRybV9pbnRlbF9nZW1fYm9fY2xvc2Vfdm1hKGRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtLAoJCQkJICAgICAgIGRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSkKewoJYnVmbWdyX2dlbS0+dm1hX29wZW4tLTsKCURSTUxJU1RBRERUQUlMKCZib19nZW0tPnZtYV9saXN0LCAmYnVmbWdyX2dlbS0+dm1hX2NhY2hlKTsKCWlmIChib19nZW0tPm1lbV92aXJ0dWFsKQoJCWJ1Zm1ncl9nZW0tPnZtYV9jb3VudCsrOwoJaWYgKGJvX2dlbS0+Z3R0X3ZpcnR1YWwpCgkJYnVmbWdyX2dlbS0+dm1hX2NvdW50Kys7Cglkcm1faW50ZWxfZ2VtX2JvX3B1cmdlX3ZtYV9jYWNoZShidWZtZ3JfZ2VtKTsKfQoKc3RhdGljIHZvaWQgZHJtX2ludGVsX2dlbV9ib19vcGVuX3ZtYShkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSwKCQkJCSAgICAgIGRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSkKewoJYnVmbWdyX2dlbS0+dm1hX29wZW4rKzsKCURSTUxJU1RERUwoJmJvX2dlbS0+dm1hX2xpc3QpOwoJaWYgKGJvX2dlbS0+bWVtX3ZpcnR1YWwpCgkJYnVmbWdyX2dlbS0+dm1hX2NvdW50LS07CglpZiAoYm9fZ2VtLT5ndHRfdmlydHVhbCkKCQlidWZtZ3JfZ2VtLT52bWFfY291bnQtLTsKCWRybV9pbnRlbF9nZW1fYm9fcHVyZ2Vfdm1hX2NhY2hlKGJ1Zm1ncl9nZW0pOwp9CgpzdGF0aWMgdm9pZApkcm1faW50ZWxfZ2VtX2JvX3VucmVmZXJlbmNlX2ZpbmFsKGRybV9pbnRlbF9ibyAqYm8sIHRpbWVfdCB0aW1lKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CglzdHJ1Y3QgZHJtX2ludGVsX2dlbV9ib19idWNrZXQgKmJ1Y2tldDsKCWludCBpOwoKCS8qIFVucmVmZXJlbmNlIGFsbCB0aGUgdGFyZ2V0IGJ1ZmZlcnMgKi8KCWZvciAoaSA9IDA7IGkgPCBib19nZW0tPnJlbG9jX2NvdW50OyBpKyspIHsKCQlpZiAoYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mb1tpXS5ibyAhPSBibykgewoJCQlkcm1faW50ZWxfZ2VtX2JvX3VucmVmZXJlbmNlX2xvY2tlZF90aW1lZChib19nZW0tPgoJCQkJCQkJCSAgcmVsb2NfdGFyZ2V0X2luZm9baV0uYm8sCgkJCQkJCQkJICB0aW1lKTsKCQl9Cgl9Cglmb3IgKGkgPSAwOyBpIDwgYm9fZ2VtLT5zb2Z0cGluX3RhcmdldF9jb3VudDsgaSsrKQoJCWRybV9pbnRlbF9nZW1fYm9fdW5yZWZlcmVuY2VfbG9ja2VkX3RpbWVkKGJvX2dlbS0+c29mdHBpbl90YXJnZXRbaV0sCgkJCQkJCQkJICB0aW1lKTsKCWJvX2dlbS0+cmVsb2NfY291bnQgPSAwOwoJYm9fZ2VtLT51c2VkX2FzX3JlbG9jX3RhcmdldCA9IGZhbHNlOwoJYm9fZ2VtLT5zb2Z0cGluX3RhcmdldF9jb3VudCA9IDA7CgoJREJHKCJib191bnJlZmVyZW5jZSBmaW5hbDogJWQgKCVzKVxuIiwKCSAgICBib19nZW0tPmdlbV9oYW5kbGUsIGJvX2dlbS0+bmFtZSk7CgoJLyogcmVsZWFzZSBtZW1vcnkgYXNzb2NpYXRlZCB3aXRoIHRoaXMgb2JqZWN0ICovCglpZiAoYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mbykgewoJCWZyZWUoYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mbyk7CgkJYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mbyA9IE5VTEw7Cgl9CglpZiAoYm9fZ2VtLT5yZWxvY3MpIHsKCQlmcmVlKGJvX2dlbS0+cmVsb2NzKTsKCQlib19nZW0tPnJlbG9jcyA9IE5VTEw7Cgl9CglpZiAoYm9fZ2VtLT5zb2Z0cGluX3RhcmdldCkgewoJCWZyZWUoYm9fZ2VtLT5zb2Z0cGluX3RhcmdldCk7CgkJYm9fZ2VtLT5zb2Z0cGluX3RhcmdldCA9IE5VTEw7CgkJYm9fZ2VtLT5zb2Z0cGluX3RhcmdldF9zaXplID0gMDsKCX0KCgkvKiBDbGVhciBhbnkgbGVmdC1vdmVyIG1hcHBpbmdzICovCglpZiAoYm9fZ2VtLT5tYXBfY291bnQpIHsKCQlEQkcoImJvIGZyZWVkIHdpdGggbm9uLXplcm8gbWFwLWNvdW50ICVkXG4iLCBib19nZW0tPm1hcF9jb3VudCk7CgkJYm9fZ2VtLT5tYXBfY291bnQgPSAwOwoJCWRybV9pbnRlbF9nZW1fYm9fY2xvc2Vfdm1hKGJ1Zm1ncl9nZW0sIGJvX2dlbSk7CgkJZHJtX2ludGVsX2dlbV9ib19tYXJrX21tYXBzX2luY29oZXJlbnQoYm8pOwoJfQoKCURSTUxJU1RERUwoJmJvX2dlbS0+bmFtZV9saXN0KTsKCglidWNrZXQgPSBkcm1faW50ZWxfZ2VtX2JvX2J1Y2tldF9mb3Jfc2l6ZShidWZtZ3JfZ2VtLCBiby0+c2l6ZSk7CgkvKiBQdXQgdGhlIGJ1ZmZlciBpbnRvIG91ciBpbnRlcm5hbCBjYWNoZSBmb3IgcmV1c2UgaWYgd2UgY2FuLiAqLwoJaWYgKGJ1Zm1ncl9nZW0tPmJvX3JldXNlICYmIGJvX2dlbS0+cmV1c2FibGUgJiYgYnVja2V0ICE9IE5VTEwgJiYKCSAgICBkcm1faW50ZWxfZ2VtX2JvX21hZHZpc2VfaW50ZXJuYWwoYnVmbWdyX2dlbSwgYm9fZ2VtLAoJCQkJCSAgICAgIEk5MTVfTUFEVl9ET05UTkVFRCkpIHsKCQlib19nZW0tPmZyZWVfdGltZSA9IHRpbWU7CgoJCWJvX2dlbS0+bmFtZSA9IE5VTEw7CgkJYm9fZ2VtLT52YWxpZGF0ZV9pbmRleCA9IC0xOwoKCQlEUk1MSVNUQUREVEFJTCgmYm9fZ2VtLT5oZWFkLCAmYnVja2V0LT5oZWFkKTsKCX0gZWxzZSB7CgkJZHJtX2ludGVsX2dlbV9ib19mcmVlKGJvKTsKCX0KfQoKc3RhdGljIHZvaWQgZHJtX2ludGVsX2dlbV9ib191bnJlZmVyZW5jZV9sb2NrZWRfdGltZWQoZHJtX2ludGVsX2JvICpibywKCQkJCQkJICAgICAgdGltZV90IHRpbWUpCnsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoKCWFzc2VydChhdG9taWNfcmVhZCgmYm9fZ2VtLT5yZWZjb3VudCkgPiAwKTsKCWlmIChhdG9taWNfZGVjX2FuZF90ZXN0KCZib19nZW0tPnJlZmNvdW50KSkKCQlkcm1faW50ZWxfZ2VtX2JvX3VucmVmZXJlbmNlX2ZpbmFsKGJvLCB0aW1lKTsKfQoKc3RhdGljIHZvaWQgZHJtX2ludGVsX2dlbV9ib191bnJlZmVyZW5jZShkcm1faW50ZWxfYm8gKmJvKQp7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCglhc3NlcnQoYXRvbWljX3JlYWQoJmJvX2dlbS0+cmVmY291bnQpID4gMCk7CgoJaWYgKGF0b21pY19hZGRfdW5sZXNzKCZib19nZW0tPnJlZmNvdW50LCAtMSwgMSkpIHsKCQlkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9CgkJICAgIChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoJCXN0cnVjdCB0aW1lc3BlYyB0aW1lOwoKCQljbG9ja19nZXR0aW1lKENMT0NLX01PTk9UT05JQywgJnRpbWUpOwoKCQlwdGhyZWFkX211dGV4X2xvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoKCQlpZiAoYXRvbWljX2RlY19hbmRfdGVzdCgmYm9fZ2VtLT5yZWZjb3VudCkpIHsKCQkJZHJtX2ludGVsX2dlbV9ib191bnJlZmVyZW5jZV9maW5hbChibywgdGltZS50dl9zZWMpOwoJCQlkcm1faW50ZWxfZ2VtX2NsZWFudXBfYm9fY2FjaGUoYnVmbWdyX2dlbSwgdGltZS50dl9zZWMpOwoJCX0KCgkJcHRocmVhZF9tdXRleF91bmxvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoJfQp9CgpzdGF0aWMgaW50IGRybV9pbnRlbF9nZW1fYm9fbWFwKGRybV9pbnRlbF9ibyAqYm8sIGludCB3cml0ZV9lbmFibGUpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCXN0cnVjdCBkcm1faTkxNV9nZW1fc2V0X2RvbWFpbiBzZXRfZG9tYWluOwoJaW50IHJldDsKCglpZiAoYm9fZ2VtLT5pc191c2VycHRyKSB7CgkJLyogUmV0dXJuIHRoZSBzYW1lIHVzZXIgcHRyICovCgkJYm8tPnZpcnR1YWwgPSBib19nZW0tPnVzZXJfdmlydHVhbDsKCQlyZXR1cm4gMDsKCX0KCglwdGhyZWFkX211dGV4X2xvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoKCWlmIChib19nZW0tPm1hcF9jb3VudCsrID09IDApCgkJZHJtX2ludGVsX2dlbV9ib19vcGVuX3ZtYShidWZtZ3JfZ2VtLCBib19nZW0pOwoKCWlmICghYm9fZ2VtLT5tZW1fdmlydHVhbCkgewoJCXN0cnVjdCBkcm1faTkxNV9nZW1fbW1hcCBtbWFwX2FyZzsKCgkJREJHKCJib19tYXA6ICVkICglcyksIG1hcF9jb3VudD0lZFxuIiwKCQkgICAgYm9fZ2VtLT5nZW1faGFuZGxlLCBib19nZW0tPm5hbWUsIGJvX2dlbS0+bWFwX2NvdW50KTsKCgkJbWVtY2xlYXIobW1hcF9hcmcpOwoJCW1tYXBfYXJnLmhhbmRsZSA9IGJvX2dlbS0+Z2VtX2hhbmRsZTsKCQltbWFwX2FyZy5zaXplID0gYm8tPnNpemU7CgkJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsCgkJCSAgICAgICBEUk1fSU9DVExfSTkxNV9HRU1fTU1BUCwKCQkJICAgICAgICZtbWFwX2FyZyk7CgkJaWYgKHJldCAhPSAwKSB7CgkJCXJldCA9IC1lcnJubzsKCQkJREJHKCIlczolZDogRXJyb3IgbWFwcGluZyBidWZmZXIgJWQgKCVzKTogJXMgLlxuIiwKCQkJICAgIF9fRklMRV9fLCBfX0xJTkVfXywgYm9fZ2VtLT5nZW1faGFuZGxlLAoJCQkgICAgYm9fZ2VtLT5uYW1lLCBzdHJlcnJvcihlcnJubykpOwoJCQlpZiAoLS1ib19nZW0tPm1hcF9jb3VudCA9PSAwKQoJCQkJZHJtX2ludGVsX2dlbV9ib19jbG9zZV92bWEoYnVmbWdyX2dlbSwgYm9fZ2VtKTsKCQkJcHRocmVhZF9tdXRleF91bmxvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoJCQlyZXR1cm4gcmV0OwoJCX0KCQlWRyhWQUxHUklORF9NQUxMT0NMSUtFX0JMT0NLKG1tYXBfYXJnLmFkZHJfcHRyLCBtbWFwX2FyZy5zaXplLCAwLCAxKSk7CgkJYm9fZ2VtLT5tZW1fdmlydHVhbCA9ICh2b2lkICopKHVpbnRwdHJfdCkgbW1hcF9hcmcuYWRkcl9wdHI7Cgl9CglEQkcoImJvX21hcDogJWQgKCVzKSAtPiAlcFxuIiwgYm9fZ2VtLT5nZW1faGFuZGxlLCBib19nZW0tPm5hbWUsCgkgICAgYm9fZ2VtLT5tZW1fdmlydHVhbCk7Cgliby0+dmlydHVhbCA9IGJvX2dlbS0+bWVtX3ZpcnR1YWw7CgoJbWVtY2xlYXIoc2V0X2RvbWFpbik7CglzZXRfZG9tYWluLmhhbmRsZSA9IGJvX2dlbS0+Z2VtX2hhbmRsZTsKCXNldF9kb21haW4ucmVhZF9kb21haW5zID0gSTkxNV9HRU1fRE9NQUlOX0NQVTsKCWlmICh3cml0ZV9lbmFibGUpCgkJc2V0X2RvbWFpbi53cml0ZV9kb21haW4gPSBJOTE1X0dFTV9ET01BSU5fQ1BVOwoJZWxzZQoJCXNldF9kb21haW4ud3JpdGVfZG9tYWluID0gMDsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLAoJCSAgICAgICBEUk1fSU9DVExfSTkxNV9HRU1fU0VUX0RPTUFJTiwKCQkgICAgICAgJnNldF9kb21haW4pOwoJaWYgKHJldCAhPSAwKSB7CgkJREJHKCIlczolZDogRXJyb3Igc2V0dGluZyB0byBDUFUgZG9tYWluICVkOiAlc1xuIiwKCQkgICAgX19GSUxFX18sIF9fTElORV9fLCBib19nZW0tPmdlbV9oYW5kbGUsCgkJICAgIHN0cmVycm9yKGVycm5vKSk7Cgl9CgoJaWYgKHdyaXRlX2VuYWJsZSkKCQlib19nZW0tPm1hcHBlZF9jcHVfd3JpdGUgPSB0cnVlOwoKCWRybV9pbnRlbF9nZW1fYm9fbWFya19tbWFwc19pbmNvaGVyZW50KGJvKTsKCVZHKFZBTEdSSU5EX01BS0VfTUVNX0RFRklORUQoYm9fZ2VtLT5tZW1fdmlydHVhbCwgYm8tPnNpemUpKTsKCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIGludAptYXBfZ3R0KGRybV9pbnRlbF9ibyAqYm8pCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCWludCByZXQ7CgoJaWYgKGJvX2dlbS0+aXNfdXNlcnB0cikKCQlyZXR1cm4gLUVJTlZBTDsKCglpZiAoYm9fZ2VtLT5tYXBfY291bnQrKyA9PSAwKQoJCWRybV9pbnRlbF9nZW1fYm9fb3Blbl92bWEoYnVmbWdyX2dlbSwgYm9fZ2VtKTsKCgkvKiBHZXQgYSBtYXBwaW5nIG9mIHRoZSBidWZmZXIgaWYgd2UgaGF2ZW4ndCBiZWZvcmUuICovCglpZiAoYm9fZ2VtLT5ndHRfdmlydHVhbCA9PSBOVUxMKSB7CgkJc3RydWN0IGRybV9pOTE1X2dlbV9tbWFwX2d0dCBtbWFwX2FyZzsKCgkJREJHKCJib19tYXBfZ3R0OiBtbWFwICVkICglcyksIG1hcF9jb3VudD0lZFxuIiwKCQkgICAgYm9fZ2VtLT5nZW1faGFuZGxlLCBib19nZW0tPm5hbWUsIGJvX2dlbS0+bWFwX2NvdW50KTsKCgkJbWVtY2xlYXIobW1hcF9hcmcpOwoJCW1tYXBfYXJnLmhhbmRsZSA9IGJvX2dlbS0+Z2VtX2hhbmRsZTsKCgkJLyogR2V0IHRoZSBmYWtlIG9mZnNldCBiYWNrLi4uICovCgkJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsCgkJCSAgICAgICBEUk1fSU9DVExfSTkxNV9HRU1fTU1BUF9HVFQsCgkJCSAgICAgICAmbW1hcF9hcmcpOwoJCWlmIChyZXQgIT0gMCkgewoJCQlyZXQgPSAtZXJybm87CgkJCURCRygiJXM6JWQ6IEVycm9yIHByZXBhcmluZyBidWZmZXIgbWFwICVkICglcyk6ICVzIC5cbiIsCgkJCSAgICBfX0ZJTEVfXywgX19MSU5FX18sCgkJCSAgICBib19nZW0tPmdlbV9oYW5kbGUsIGJvX2dlbS0+bmFtZSwKCQkJICAgIHN0cmVycm9yKGVycm5vKSk7CgkJCWlmICgtLWJvX2dlbS0+bWFwX2NvdW50ID09IDApCgkJCQlkcm1faW50ZWxfZ2VtX2JvX2Nsb3NlX3ZtYShidWZtZ3JfZ2VtLCBib19nZW0pOwoJCQlyZXR1cm4gcmV0OwoJCX0KCgkJLyogYW5kIG1tYXAgaXQgKi8KCQlib19nZW0tPmd0dF92aXJ0dWFsID0gZHJtX21tYXAoMCwgYm8tPnNpemUsIFBST1RfUkVBRCB8IFBST1RfV1JJVEUsCgkJCQkJICAgICAgIE1BUF9TSEFSRUQsIGJ1Zm1ncl9nZW0tPmZkLAoJCQkJCSAgICAgICBtbWFwX2FyZy5vZmZzZXQpOwoJCWlmIChib19nZW0tPmd0dF92aXJ0dWFsID09IE1BUF9GQUlMRUQpIHsKCQkJYm9fZ2VtLT5ndHRfdmlydHVhbCA9IE5VTEw7CgkJCXJldCA9IC1lcnJubzsKCQkJREJHKCIlczolZDogRXJyb3IgbWFwcGluZyBidWZmZXIgJWQgKCVzKTogJXMgLlxuIiwKCQkJICAgIF9fRklMRV9fLCBfX0xJTkVfXywKCQkJICAgIGJvX2dlbS0+Z2VtX2hhbmRsZSwgYm9fZ2VtLT5uYW1lLAoJCQkgICAgc3RyZXJyb3IoZXJybm8pKTsKCQkJaWYgKC0tYm9fZ2VtLT5tYXBfY291bnQgPT0gMCkKCQkJCWRybV9pbnRlbF9nZW1fYm9fY2xvc2Vfdm1hKGJ1Zm1ncl9nZW0sIGJvX2dlbSk7CgkJCXJldHVybiByZXQ7CgkJfQoJfQoKCWJvLT52aXJ0dWFsID0gYm9fZ2VtLT5ndHRfdmlydHVhbDsKCglEQkcoImJvX21hcF9ndHQ6ICVkICglcykgLT4gJXBcbiIsIGJvX2dlbS0+Z2VtX2hhbmRsZSwgYm9fZ2VtLT5uYW1lLAoJICAgIGJvX2dlbS0+Z3R0X3ZpcnR1YWwpOwoKCXJldHVybiAwOwp9CgppbnQKZHJtX2ludGVsX2dlbV9ib19tYXBfZ3R0KGRybV9pbnRlbF9ibyAqYm8pCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCXN0cnVjdCBkcm1faTkxNV9nZW1fc2V0X2RvbWFpbiBzZXRfZG9tYWluOwoJaW50IHJldDsKCglwdGhyZWFkX211dGV4X2xvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoKCXJldCA9IG1hcF9ndHQoYm8pOwoJaWYgKHJldCkgewoJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCQlyZXR1cm4gcmV0OwoJfQoKCS8qIE5vdyBtb3ZlIGl0IHRvIHRoZSBHVFQgZG9tYWluIHNvIHRoYXQgdGhlIEdQVSBhbmQgQ1BVCgkgKiBjYWNoZXMgYXJlIGZsdXNoZWQgYW5kIHRoZSBHUFUgaXNuJ3QgYWN0aXZlbHkgdXNpbmcgdGhlCgkgKiBidWZmZXIuCgkgKgoJICogVGhlIHBhZ2VmYXVsdCBoYW5kbGVyIGRvZXMgdGhpcyBkb21haW4gY2hhbmdlIGZvciB1cyB3aGVuCgkgKiBpdCBoYXMgdW5ib3VuZCB0aGUgQk8gZnJvbSB0aGUgR1RULCBidXQgaXQncyB1cCB0byB1cyB0bwoJICogdGVsbCBpdCB3aGVuIHdlJ3JlIGFib3V0IHRvIHVzZSB0aGluZ3MgaWYgd2UgaGFkIGRvbmUKCSAqIHJlbmRlcmluZyBhbmQgaXQgc3RpbGwgaGFwcGVucyB0byBiZSBib3VuZCB0byB0aGUgR1RULgoJICovCgltZW1jbGVhcihzZXRfZG9tYWluKTsKCXNldF9kb21haW4uaGFuZGxlID0gYm9fZ2VtLT5nZW1faGFuZGxlOwoJc2V0X2RvbWFpbi5yZWFkX2RvbWFpbnMgPSBJOTE1X0dFTV9ET01BSU5fR1RUOwoJc2V0X2RvbWFpbi53cml0ZV9kb21haW4gPSBJOTE1X0dFTV9ET01BSU5fR1RUOwoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsCgkJICAgICAgIERSTV9JT0NUTF9JOTE1X0dFTV9TRVRfRE9NQUlOLAoJCSAgICAgICAmc2V0X2RvbWFpbik7CglpZiAocmV0ICE9IDApIHsKCQlEQkcoIiVzOiVkOiBFcnJvciBzZXR0aW5nIGRvbWFpbiAlZDogJXNcbiIsCgkJICAgIF9fRklMRV9fLCBfX0xJTkVfXywgYm9fZ2VtLT5nZW1faGFuZGxlLAoJCSAgICBzdHJlcnJvcihlcnJubykpOwoJfQoKCWRybV9pbnRlbF9nZW1fYm9fbWFya19tbWFwc19pbmNvaGVyZW50KGJvKTsKCVZHKFZBTEdSSU5EX01BS0VfTUVNX0RFRklORUQoYm9fZ2VtLT5ndHRfdmlydHVhbCwgYm8tPnNpemUpKTsKCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCglyZXR1cm4gMDsKfQoKLyoqCiAqIFBlcmZvcm1zIGEgbWFwcGluZyBvZiB0aGUgYnVmZmVyIG9iamVjdCBsaWtlIHRoZSBub3JtYWwgR1RUCiAqIG1hcHBpbmcsIGJ1dCBhdm9pZHMgd2FpdGluZyBmb3IgdGhlIEdQVSB0byBiZSBkb25lIHJlYWRpbmcgZnJvbSBvcgogKiByZW5kZXJpbmcgdG8gdGhlIGJ1ZmZlci4KICoKICogVGhpcyBpcyB1c2VkIGluIHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBHTF9BUkJfbWFwX2J1ZmZlcl9yYW5nZTogVGhlCiAqIHVzZXIgYXNrcyB0byBjcmVhdGUgYSBidWZmZXIsIHRoZW4gZG9lcyBhIG1hcHBpbmcsIGZpbGxzIHNvbWUKICogc3BhY2UsIHJ1bnMgYSBkcmF3aW5nIGNvbW1hbmQsIHRoZW4gYXNrcyB0byBtYXAgaXQgYWdhaW4gd2l0aG91dAogKiBzeW5jaHJvbml6aW5nIGJlY2F1c2UgaXQgZ3VhcmFudGVlcyB0aGF0IGl0IHdvbid0IHdyaXRlIG92ZXIgdGhlCiAqIGRhdGEgdGhhdCB0aGUgR1BVIGlzIGJ1c3kgdXNpbmcgKG9yLCBtb3JlIHNwZWNpZmljYWxseSwgdGhhdCBpZiBpdAogKiBkb2VzIHdyaXRlIG92ZXIgdGhlIGRhdGEsIGl0IGFja25vd2xlZGdlcyB0aGF0IHJlbmRlcmluZyBpcwogKiB1bmRlZmluZWQpLgogKi8KCmludApkcm1faW50ZWxfZ2VtX2JvX21hcF91bnN5bmNocm9uaXplZChkcm1faW50ZWxfYm8gKmJvKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwojaWZkZWYgSEFWRV9WQUxHUklORAoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CiNlbmRpZgoJaW50IHJldDsKCgkvKiBJZiB0aGUgQ1BVIGNhY2hlIGlzbid0IGNvaGVyZW50IHdpdGggdGhlIEdUVCwgdGhlbiB1c2UgYQoJICogcmVndWxhciBzeW5jaHJvbml6ZWQgbWFwcGluZy4gIFRoZSBwcm9ibGVtIGlzIHRoYXQgd2UgZG9uJ3QKCSAqIHRyYWNrIHdoZXJlIHRoZSBidWZmZXIgd2FzIGxhc3QgdXNlZCBvbiB0aGUgQ1BVIHNpZGUgaW4KCSAqIHRlcm1zIG9mIGRybV9pbnRlbF9ib19tYXAgdnMgZHJtX2ludGVsX2dlbV9ib19tYXBfZ3R0LCBzbwoJICogd2Ugd291bGQgcG90ZW50aWFsbHkgY29ycnVwdCB0aGUgYnVmZmVyIGV2ZW4gd2hlbiB0aGUgdXNlcgoJICogZG9lcyByZWFzb25hYmxlIHRoaW5ncy4KCSAqLwoJaWYgKCFidWZtZ3JfZ2VtLT5oYXNfbGxjKQoJCXJldHVybiBkcm1faW50ZWxfZ2VtX2JvX21hcF9ndHQoYm8pOwoKCXB0aHJlYWRfbXV0ZXhfbG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgoJcmV0ID0gbWFwX2d0dChibyk7CglpZiAocmV0ID09IDApIHsKCQlkcm1faW50ZWxfZ2VtX2JvX21hcmtfbW1hcHNfaW5jb2hlcmVudChibyk7CgkJVkcoVkFMR1JJTkRfTUFLRV9NRU1fREVGSU5FRChib19nZW0tPmd0dF92aXJ0dWFsLCBiby0+c2l6ZSkpOwoJfQoKCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgaW50IGRybV9pbnRlbF9nZW1fYm9fdW5tYXAoZHJtX2ludGVsX2JvICpibykKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW07Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCWludCByZXQgPSAwOwoKCWlmIChibyA9PSBOVUxMKQoJCXJldHVybiAwOwoKCWlmIChib19nZW0tPmlzX3VzZXJwdHIpCgkJcmV0dXJuIDA7CgoJYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoKCXB0aHJlYWRfbXV0ZXhfbG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgoJaWYgKGJvX2dlbS0+bWFwX2NvdW50IDw9IDApIHsKCQlEQkcoImF0dGVtcHRlZCB0byB1bm1hcCBhbiB1bm1hcHBlZCBib1xuIik7CgkJcHRocmVhZF9tdXRleF91bmxvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoJCS8qIFByZXNlcnZlIHRoZSBvbGQgYmVoYXZpb3VyIG9mIGp1c3QgdHJlYXRpbmcgdGhpcyBhcyBhCgkJICogbm8tb3AgcmF0aGVyIHRoYW4gcmVwb3J0aW5nIHRoZSBlcnJvci4KCQkgKi8KCQlyZXR1cm4gMDsKCX0KCglpZiAoYm9fZ2VtLT5tYXBwZWRfY3B1X3dyaXRlKSB7CgkJc3RydWN0IGRybV9pOTE1X2dlbV9zd19maW5pc2ggc3dfZmluaXNoOwoKCQkvKiBDYXVzZSBhIGZsdXNoIHRvIGhhcHBlbiBpZiB0aGUgYnVmZmVyJ3MgcGlubmVkIGZvcgoJCSAqIHNjYW5vdXQsIHNvIHRoZSByZXN1bHRzIHNob3cgdXAgaW4gYSB0aW1lbHkgbWFubmVyLgoJCSAqIFVubGlrZSBHVFQgc2V0IGRvbWFpbnMsIHRoaXMgb25seSBkb2VzIHdvcmsgaWYgdGhlCgkJICogYnVmZmVyIHNob3VsZCBiZSBzY2Fub3V0LXJlbGF0ZWQuCgkJICovCgkJbWVtY2xlYXIoc3dfZmluaXNoKTsKCQlzd19maW5pc2guaGFuZGxlID0gYm9fZ2VtLT5nZW1faGFuZGxlOwoJCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLAoJCQkgICAgICAgRFJNX0lPQ1RMX0k5MTVfR0VNX1NXX0ZJTklTSCwKCQkJICAgICAgICZzd19maW5pc2gpOwoJCXJldCA9IHJldCA9PSAtMSA/IC1lcnJubyA6IDA7CgoJCWJvX2dlbS0+bWFwcGVkX2NwdV93cml0ZSA9IGZhbHNlOwoJfQoKCS8qIFdlIG5lZWQgdG8gdW5tYXAgYWZ0ZXIgZXZlcnkgaW5ub3ZhdGlvbiBhcyB3ZSBjYW5ub3QgdHJhY2sKCSAqIGFuIG9wZW4gdm1hIGZvciBldmVyeSBibyBhcyB0aGF0IHdpbGwgZXhoYWFzdXQgdGhlIHN5c3RlbQoJICogbGltaXRzIGFuZCBjYXVzZSBsYXRlciBmYWlsdXJlcy4KCSAqLwoJaWYgKC0tYm9fZ2VtLT5tYXBfY291bnQgPT0gMCkgewoJCWRybV9pbnRlbF9nZW1fYm9fY2xvc2Vfdm1hKGJ1Zm1ncl9nZW0sIGJvX2dlbSk7CgkJZHJtX2ludGVsX2dlbV9ib19tYXJrX21tYXBzX2luY29oZXJlbnQoYm8pOwoJCWJvLT52aXJ0dWFsID0gTlVMTDsKCX0KCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCglyZXR1cm4gcmV0Owp9CgppbnQKZHJtX2ludGVsX2dlbV9ib191bm1hcF9ndHQoZHJtX2ludGVsX2JvICpibykKewoJcmV0dXJuIGRybV9pbnRlbF9nZW1fYm9fdW5tYXAoYm8pOwp9CgpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fYm9fc3ViZGF0YShkcm1faW50ZWxfYm8gKmJvLCB1bnNpZ25lZCBsb25nIG9mZnNldCwKCQkJIHVuc2lnbmVkIGxvbmcgc2l6ZSwgY29uc3Qgdm9pZCAqZGF0YSkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJc3RydWN0IGRybV9pOTE1X2dlbV9wd3JpdGUgcHdyaXRlOwoJaW50IHJldDsKCglpZiAoYm9fZ2VtLT5pc191c2VycHRyKQoJCXJldHVybiAtRUlOVkFMOwoKCW1lbWNsZWFyKHB3cml0ZSk7Cglwd3JpdGUuaGFuZGxlID0gYm9fZ2VtLT5nZW1faGFuZGxlOwoJcHdyaXRlLm9mZnNldCA9IG9mZnNldDsKCXB3cml0ZS5zaXplID0gc2l6ZTsKCXB3cml0ZS5kYXRhX3B0ciA9ICh1aW50NjRfdCkgKHVpbnRwdHJfdCkgZGF0YTsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLAoJCSAgICAgICBEUk1fSU9DVExfSTkxNV9HRU1fUFdSSVRFLAoJCSAgICAgICAmcHdyaXRlKTsKCWlmIChyZXQgIT0gMCkgewoJCXJldCA9IC1lcnJubzsKCQlEQkcoIiVzOiVkOiBFcnJvciB3cml0aW5nIGRhdGEgdG8gYnVmZmVyICVkOiAoJWQgJWQpICVzIC5cbiIsCgkJICAgIF9fRklMRV9fLCBfX0xJTkVfXywgYm9fZ2VtLT5nZW1faGFuZGxlLCAoaW50KW9mZnNldCwKCQkgICAgKGludClzaXplLCBzdHJlcnJvcihlcnJubykpOwoJfQoKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9nZXRfcGlwZV9mcm9tX2NydGNfaWQoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyLCBpbnQgY3J0Y19pZCkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYnVmbWdyOwoJc3RydWN0IGRybV9pOTE1X2dldF9waXBlX2Zyb21fY3J0Y19pZCBnZXRfcGlwZV9mcm9tX2NydGNfaWQ7CglpbnQgcmV0OwoKCW1lbWNsZWFyKGdldF9waXBlX2Zyb21fY3J0Y19pZCk7CglnZXRfcGlwZV9mcm9tX2NydGNfaWQuY3J0Y19pZCA9IGNydGNfaWQ7CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwKCQkgICAgICAgRFJNX0lPQ1RMX0k5MTVfR0VUX1BJUEVfRlJPTV9DUlRDX0lELAoJCSAgICAgICAmZ2V0X3BpcGVfZnJvbV9jcnRjX2lkKTsKCWlmIChyZXQgIT0gMCkgewoJCS8qIFdlIHJldHVybiAtMSBoZXJlIHRvIHNpZ25hbCB0aGF0IHdlIGRvbid0CgkJICoga25vdyB3aGljaCBwaXBlIGlzIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGNydGMuCgkJICogVGhpcyBsZXRzIHRoZSBjYWxsZXIga25vdyB0aGF0IHRoaXMgaW5mb3JtYXRpb24KCQkgKiBpc24ndCBhdmFpbGFibGU7IHVzaW5nIHRoZSB3cm9uZyBwaXBlIGZvcgoJCSAqIHZibGFuayB3YWl0aW5nIGNhbiBjYXVzZSB0aGUgY2hpcHNldCB0byBsb2NrIHVwCgkJICovCgkJcmV0dXJuIC0xOwoJfQoKCXJldHVybiBnZXRfcGlwZV9mcm9tX2NydGNfaWQucGlwZTsKfQoKc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2dldF9zdWJkYXRhKGRybV9pbnRlbF9ibyAqYm8sIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LAoJCQkgICAgIHVuc2lnbmVkIGxvbmcgc2l6ZSwgdm9pZCAqZGF0YSkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJc3RydWN0IGRybV9pOTE1X2dlbV9wcmVhZCBwcmVhZDsKCWludCByZXQ7CgoJaWYgKGJvX2dlbS0+aXNfdXNlcnB0cikKCQlyZXR1cm4gLUVJTlZBTDsKCgltZW1jbGVhcihwcmVhZCk7CglwcmVhZC5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CglwcmVhZC5vZmZzZXQgPSBvZmZzZXQ7CglwcmVhZC5zaXplID0gc2l6ZTsKCXByZWFkLmRhdGFfcHRyID0gKHVpbnQ2NF90KSAodWludHB0cl90KSBkYXRhOwoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsCgkJICAgICAgIERSTV9JT0NUTF9JOTE1X0dFTV9QUkVBRCwKCQkgICAgICAgJnByZWFkKTsKCWlmIChyZXQgIT0gMCkgewoJCXJldCA9IC1lcnJubzsKCQlEQkcoIiVzOiVkOiBFcnJvciByZWFkaW5nIGRhdGEgZnJvbSBidWZmZXIgJWQ6ICglZCAlZCkgJXMgLlxuIiwKCQkgICAgX19GSUxFX18sIF9fTElORV9fLCBib19nZW0tPmdlbV9oYW5kbGUsIChpbnQpb2Zmc2V0LAoJCSAgICAoaW50KXNpemUsIHN0cmVycm9yKGVycm5vKSk7Cgl9CgoJcmV0dXJuIHJldDsKfQoKLyoqIFdhaXRzIGZvciBhbGwgR1BVIHJlbmRlcmluZyB3aXRoIHRoZSBvYmplY3QgdG8gaGF2ZSBjb21wbGV0ZWQuICovCnN0YXRpYyB2b2lkCmRybV9pbnRlbF9nZW1fYm9fd2FpdF9yZW5kZXJpbmcoZHJtX2ludGVsX2JvICpibykKewoJZHJtX2ludGVsX2dlbV9ib19zdGFydF9ndHRfYWNjZXNzKGJvLCAxKTsKfQoKLyoqCiAqIFdhaXRzIG9uIGEgQk8gZm9yIHRoZSBnaXZlbiBhbW91bnQgb2YgdGltZS4KICoKICogQGJvOiBidWZmZXIgb2JqZWN0IHRvIHdhaXQgZm9yCiAqIEB0aW1lb3V0X25zOiBhbW91bnQgb2YgdGltZSB0byB3YWl0IGluIG5hbm9zZWNvbmRzLgogKiAgIElmIHZhbHVlIGlzIGxlc3MgdGhhbiAwLCBhbiBpbmZpbml0ZSB3YWl0IHdpbGwgb2NjdXIuCiAqCiAqIFJldHVybnMgMCBpZiB0aGUgd2FpdCB3YXMgc3VjY2Vzc2Z1bCBpZS4gdGhlIGxhc3QgYmF0Y2ggcmVmZXJlbmNpbmcgdGhlCiAqIG9iamVjdCBoYXMgY29tcGxldGVkIHdpdGhpbiB0aGUgYWxsb3R0ZWQgdGltZS4gT3RoZXJ3aXNlIHNvbWUgbmVnYXRpdmUgcmV0dXJuCiAqIHZhbHVlIGRlc2NyaWJlcyB0aGUgZXJyb3IuIE9mIHBhcnRpY3VsYXIgaW50ZXJlc3QgaXMgLUVUSU1FIHdoZW4gdGhlIHdhaXQgaGFzCiAqIGZhaWxlZCB0byB5aWVsZCB0aGUgZGVzaXJlZCByZXN1bHQuCiAqCiAqIFNpbWlsYXIgdG8gZHJtX2ludGVsX2dlbV9ib193YWl0X3JlbmRlcmluZyBleGNlcHQgYSB0aW1lb3V0IHBhcmFtZXRlciBhbGxvd3MKICogdGhlIG9wZXJhdGlvbiB0byBnaXZlIHVwIGFmdGVyIGEgY2VydGFpbiBhbW91bnQgb2YgdGltZS4gQW5vdGhlciBzdWJ0bGUKICogZGlmZmVyZW5jZSBpcyB0aGUgaW50ZXJuYWwgbG9ja2luZyBzZW1hbnRpY3MgYXJlIGRpZmZlcmVudCAodGhpcyB2YXJpYW50IGRvZXMKICogbm90IGhvbGQgdGhlIGxvY2sgZm9yIHRoZSBkdXJhdGlvbiBvZiB0aGUgd2FpdCkuIFRoaXMgbWFrZXMgdGhlIHdhaXQgc3ViamVjdAogKiB0byBhIGxhcmdlciB1c2Vyc3BhY2UgcmFjZSB3aW5kb3cuCiAqCiAqIFRoZSBpbXBsZW1lbnRhdGlvbiBzaGFsbCB3YWl0IHVudGlsIHRoZSBvYmplY3QgaXMgbm8gbG9uZ2VyIGFjdGl2ZWx5CiAqIHJlZmVyZW5jZWQgd2l0aGluIGEgYmF0Y2ggYnVmZmVyIGF0IHRoZSB0aW1lIG9mIHRoZSBjYWxsLiBUaGUgd2FpdCB3aWxsCiAqIG5vdCBndWFyYW50ZWUgdGhhdCB0aGUgYnVmZmVyIGlzIHJlLWlzc3VlZCB2aWEgYW5vdGhlciB0aHJlYWQsIG9yIGFuIGZsaW5rZWQKICogaGFuZGxlLiBVc2Vyc3BhY2UgbXVzdCBtYWtlIHN1cmUgdGhpcyByYWNlIGRvZXMgbm90IG9jY3VyIGlmIHN1Y2ggcHJlY2lzaW9uCiAqIGlzIGltcG9ydGFudC4KICoKICogTm90ZSB0aGF0IHNvbWUga2VybmVscyBoYXZlIGJyb2tlbiB0aGUgaW5pZml0ZSB3YWl0IGZvciBuZWdhdGl2ZSB2YWx1ZXMKICogcHJvbWlzZSwgdXBncmFkZSB0byBsYXRlc3Qgc3RhYmxlIGtlcm5lbHMgaWYgdGhpcyBpcyB0aGUgY2FzZS4KICovCmludApkcm1faW50ZWxfZ2VtX2JvX3dhaXQoZHJtX2ludGVsX2JvICpibywgaW50NjRfdCB0aW1lb3V0X25zKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX3dhaXQgd2FpdDsKCWludCByZXQ7CgoJaWYgKCFidWZtZ3JfZ2VtLT5oYXNfd2FpdF90aW1lb3V0KSB7CgkJREJHKCIlczolZDogVGltZWQgd2FpdCBpcyBub3Qgc3VwcG9ydGVkLiBGYWxsaW5nIGJhY2sgdG8gIgoJCSAgICAiaW5maW5pdGUgd2FpdFxuIiwgX19GSUxFX18sIF9fTElORV9fKTsKCQlpZiAodGltZW91dF9ucykgewoJCQlkcm1faW50ZWxfZ2VtX2JvX3dhaXRfcmVuZGVyaW5nKGJvKTsKCQkJcmV0dXJuIDA7CgkJfSBlbHNlIHsKCQkJcmV0dXJuIGRybV9pbnRlbF9nZW1fYm9fYnVzeShibykgPyAtRVRJTUUgOiAwOwoJCX0KCX0KCgltZW1jbGVhcih3YWl0KTsKCXdhaXQuYm9faGFuZGxlID0gYm9fZ2VtLT5nZW1faGFuZGxlOwoJd2FpdC50aW1lb3V0X25zID0gdGltZW91dF9uczsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRU1fV0FJVCwgJndhaXQpOwoJaWYgKHJldCA9PSAtMSkKCQlyZXR1cm4gLWVycm5vOwoKCXJldHVybiByZXQ7Cn0KCi8qKgogKiBTZXRzIHRoZSBvYmplY3QgdG8gdGhlIEdUVCByZWFkIGFuZCBwb3NzaWJseSB3cml0ZSBkb21haW4sIHVzZWQgYnkgdGhlIFgKICogMkQgZHJpdmVyIGluIHRoZSBhYnNlbmNlIG9mIGtlcm5lbCBzdXBwb3J0IHRvIGRvIGRybV9pbnRlbF9nZW1fYm9fbWFwX2d0dCgpLgogKgogKiBJbiBjb21iaW5hdGlvbiB3aXRoIGRybV9pbnRlbF9nZW1fYm9fcGluKCkgYW5kIG1hbnVhbCBmZW5jZSBtYW5hZ2VtZW50LCB3ZQogKiBjYW4gZG8gdGlsZWQgcGl4bWFwcyB0aGlzIHdheS4KICovCnZvaWQKZHJtX2ludGVsX2dlbV9ib19zdGFydF9ndHRfYWNjZXNzKGRybV9pbnRlbF9ibyAqYm8sIGludCB3cml0ZV9lbmFibGUpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCXN0cnVjdCBkcm1faTkxNV9nZW1fc2V0X2RvbWFpbiBzZXRfZG9tYWluOwoJaW50IHJldDsKCgltZW1jbGVhcihzZXRfZG9tYWluKTsKCXNldF9kb21haW4uaGFuZGxlID0gYm9fZ2VtLT5nZW1faGFuZGxlOwoJc2V0X2RvbWFpbi5yZWFkX2RvbWFpbnMgPSBJOTE1X0dFTV9ET01BSU5fR1RUOwoJc2V0X2RvbWFpbi53cml0ZV9kb21haW4gPSB3cml0ZV9lbmFibGUgPyBJOTE1X0dFTV9ET01BSU5fR1RUIDogMDsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLAoJCSAgICAgICBEUk1fSU9DVExfSTkxNV9HRU1fU0VUX0RPTUFJTiwKCQkgICAgICAgJnNldF9kb21haW4pOwoJaWYgKHJldCAhPSAwKSB7CgkJREJHKCIlczolZDogRXJyb3Igc2V0dGluZyBtZW1vcnkgZG9tYWlucyAlZCAoJTA4eCAlMDh4KTogJXMgLlxuIiwKCQkgICAgX19GSUxFX18sIF9fTElORV9fLCBib19nZW0tPmdlbV9oYW5kbGUsCgkJICAgIHNldF9kb21haW4ucmVhZF9kb21haW5zLCBzZXRfZG9tYWluLndyaXRlX2RvbWFpbiwKCQkgICAgc3RyZXJyb3IoZXJybm8pKTsKCX0KfQoKc3RhdGljIHZvaWQKZHJtX2ludGVsX2J1Zm1ncl9nZW1fZGVzdHJveShkcm1faW50ZWxfYnVmbWdyICpidWZtZ3IpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJ1Zm1ncjsKCXN0cnVjdCBkcm1fZ2VtX2Nsb3NlIGNsb3NlX2JvOwoJaW50IGksIHJldDsKCglmcmVlKGJ1Zm1ncl9nZW0tPmV4ZWMyX29iamVjdHMpOwoJZnJlZShidWZtZ3JfZ2VtLT5leGVjX29iamVjdHMpOwoJZnJlZShidWZtZ3JfZ2VtLT5leGVjX2Jvcyk7CgoJcHRocmVhZF9tdXRleF9kZXN0cm95KCZidWZtZ3JfZ2VtLT5sb2NrKTsKCgkvKiBGcmVlIGFueSBjYWNoZWQgYnVmZmVyIG9iamVjdHMgd2Ugd2VyZSBnb2luZyB0byByZXVzZSAqLwoJZm9yIChpID0gMDsgaSA8IGJ1Zm1ncl9nZW0tPm51bV9idWNrZXRzOyBpKyspIHsKCQlzdHJ1Y3QgZHJtX2ludGVsX2dlbV9ib19idWNrZXQgKmJ1Y2tldCA9CgkJICAgICZidWZtZ3JfZ2VtLT5jYWNoZV9idWNrZXRbaV07CgkJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtOwoKCQl3aGlsZSAoIURSTUxJU1RFTVBUWSgmYnVja2V0LT5oZWFkKSkgewoJCQlib19nZW0gPSBEUk1MSVNURU5UUlkoZHJtX2ludGVsX2JvX2dlbSwKCQkJCQkgICAgICBidWNrZXQtPmhlYWQubmV4dCwgaGVhZCk7CgkJCURSTUxJU1RERUwoJmJvX2dlbS0+aGVhZCk7CgoJCQlkcm1faW50ZWxfZ2VtX2JvX2ZyZWUoJmJvX2dlbS0+Ym8pOwoJCX0KCX0KCgkvKiBSZWxlYXNlIHVzZXJwdHIgYm8ga2VwdCBoYW5naW5nIGFyb3VuZCBmb3Igb3B0aW1pc2F0aW9uLiAqLwoJaWYgKGJ1Zm1ncl9nZW0tPnVzZXJwdHJfYWN0aXZlLnB0cikgewoJCW1lbWNsZWFyKGNsb3NlX2JvKTsKCQljbG9zZV9iby5oYW5kbGUgPSBidWZtZ3JfZ2VtLT51c2VycHRyX2FjdGl2ZS5oYW5kbGU7CgkJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsIERSTV9JT0NUTF9HRU1fQ0xPU0UsICZjbG9zZV9ibyk7CgkJZnJlZShidWZtZ3JfZ2VtLT51c2VycHRyX2FjdGl2ZS5wdHIpOwoJCWlmIChyZXQpCgkJCWZwcmludGYoc3RkZXJyLAoJCQkJIkZhaWxlZCB0byByZWxlYXNlIHRlc3QgdXNlcnB0ciBvYmplY3QhICglZCkgIgoJCQkJImk5MTUga2VybmVsIGRyaXZlciBtYXkgbm90IGJlIHNhbmUhXG4iLCBlcnJubyk7Cgl9CgoJZnJlZShidWZtZ3IpOwp9CgovKioKICogQWRkcyB0aGUgdGFyZ2V0IGJ1ZmZlciB0byB0aGUgdmFsaWRhdGlvbiBsaXN0IGFuZCBhZGRzIHRoZSByZWxvY2F0aW9uCiAqIHRvIHRoZSByZWxvY19idWZmZXIncyByZWxvY2F0aW9uIGxpc3QuCiAqCiAqIFRoZSByZWxvY2F0aW9uIGVudHJ5IGF0IHRoZSBnaXZlbiBvZmZzZXQgbXVzdCBhbHJlYWR5IGNvbnRhaW4gdGhlCiAqIHByZWNvbXB1dGVkIHJlbG9jYXRpb24gdmFsdWUsIGJlY2F1c2UgdGhlIGtlcm5lbCB3aWxsIG9wdGltaXplIG91dAogKiB0aGUgcmVsb2NhdGlvbiBlbnRyeSB3cml0ZSB3aGVuIHRoZSBidWZmZXIgaGFzbid0IG1vdmVkIGZyb20gdGhlCiAqIGxhc3Qga25vd24gb2Zmc2V0IGluIHRhcmdldF9iby4KICovCnN0YXRpYyBpbnQKZG9fYm9fZW1pdF9yZWxvYyhkcm1faW50ZWxfYm8gKmJvLCB1aW50MzJfdCBvZmZzZXQsCgkJIGRybV9pbnRlbF9ibyAqdGFyZ2V0X2JvLCB1aW50MzJfdCB0YXJnZXRfb2Zmc2V0LAoJCSB1aW50MzJfdCByZWFkX2RvbWFpbnMsIHVpbnQzMl90IHdyaXRlX2RvbWFpbiwKCQkgYm9vbCBuZWVkX2ZlbmNlKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87Cglkcm1faW50ZWxfYm9fZ2VtICp0YXJnZXRfYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgdGFyZ2V0X2JvOwoJYm9vbCBmZW5jZWRfY29tbWFuZDsKCglpZiAoYm9fZ2VtLT5oYXNfZXJyb3IpCgkJcmV0dXJuIC1FTk9NRU07CgoJaWYgKHRhcmdldF9ib19nZW0tPmhhc19lcnJvcikgewoJCWJvX2dlbS0+aGFzX2Vycm9yID0gdHJ1ZTsKCQlyZXR1cm4gLUVOT01FTTsKCX0KCgkvKiBXZSBuZXZlciB1c2UgSFcgZmVuY2VzIGZvciByZW5kZXJpbmcgb24gOTY1KyAqLwoJaWYgKGJ1Zm1ncl9nZW0tPmdlbiA+PSA0KQoJCW5lZWRfZmVuY2UgPSBmYWxzZTsKCglmZW5jZWRfY29tbWFuZCA9IG5lZWRfZmVuY2U7CglpZiAodGFyZ2V0X2JvX2dlbS0+dGlsaW5nX21vZGUgPT0gSTkxNV9USUxJTkdfTk9ORSkKCQluZWVkX2ZlbmNlID0gZmFsc2U7CgoJLyogQ3JlYXRlIGEgbmV3IHJlbG9jYXRpb24gbGlzdCBpZiBuZWVkZWQgKi8KCWlmIChib19nZW0tPnJlbG9jcyA9PSBOVUxMICYmIGRybV9pbnRlbF9zZXR1cF9yZWxvY19saXN0KGJvKSkKCQlyZXR1cm4gLUVOT01FTTsKCgkvKiBDaGVjayBvdmVyZmxvdyAqLwoJYXNzZXJ0KGJvX2dlbS0+cmVsb2NfY291bnQgPCBidWZtZ3JfZ2VtLT5tYXhfcmVsb2NzKTsKCgkvKiBDaGVjayBhcmdzICovCglhc3NlcnQob2Zmc2V0IDw9IGJvLT5zaXplIC0gNCk7Cglhc3NlcnQoKHdyaXRlX2RvbWFpbiAmICh3cml0ZV9kb21haW4gLSAxKSkgPT0gMCk7CgoJLyogQW4gb2JqZWN0IG5lZWRpbmcgYSBmZW5jZSBpcyBhIHRpbGVkIGJ1ZmZlciwgc28gaXQgd29uJ3QgaGF2ZQoJICogcmVsb2NzIHRvIG90aGVyIGJ1ZmZlcnMuCgkgKi8KCWlmIChuZWVkX2ZlbmNlKSB7CgkJYXNzZXJ0KHRhcmdldF9ib19nZW0tPnJlbG9jX2NvdW50ID09IDApOwoJCXRhcmdldF9ib19nZW0tPnJlbG9jX3RyZWVfZmVuY2VzID0gMTsKCX0KCgkvKiBNYWtlIHN1cmUgdGhhdCB3ZSdyZSBub3QgYWRkaW5nIGEgcmVsb2MgdG8gc29tZXRoaW5nIHdob3NlIHNpemUgaGFzCgkgKiBhbHJlYWR5IGJlZW4gYWNjb3VudGVkIGZvci4KCSAqLwoJYXNzZXJ0KCFib19nZW0tPnVzZWRfYXNfcmVsb2NfdGFyZ2V0KTsKCWlmICh0YXJnZXRfYm9fZ2VtICE9IGJvX2dlbSkgewoJCXRhcmdldF9ib19nZW0tPnVzZWRfYXNfcmVsb2NfdGFyZ2V0ID0gdHJ1ZTsKCQlib19nZW0tPnJlbG9jX3RyZWVfc2l6ZSArPSB0YXJnZXRfYm9fZ2VtLT5yZWxvY190cmVlX3NpemU7CgkJYm9fZ2VtLT5yZWxvY190cmVlX2ZlbmNlcyArPSB0YXJnZXRfYm9fZ2VtLT5yZWxvY190cmVlX2ZlbmNlczsKCX0KCglib19nZW0tPnJlbG9jX3RhcmdldF9pbmZvW2JvX2dlbS0+cmVsb2NfY291bnRdLmJvID0gdGFyZ2V0X2JvOwoJaWYgKHRhcmdldF9ibyAhPSBibykKCQlkcm1faW50ZWxfZ2VtX2JvX3JlZmVyZW5jZSh0YXJnZXRfYm8pOwoJaWYgKGZlbmNlZF9jb21tYW5kKQoJCWJvX2dlbS0+cmVsb2NfdGFyZ2V0X2luZm9bYm9fZ2VtLT5yZWxvY19jb3VudF0uZmxhZ3MgPQoJCQlEUk1fSU5URUxfUkVMT0NfRkVOQ0U7CgllbHNlCgkJYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mb1tib19nZW0tPnJlbG9jX2NvdW50XS5mbGFncyA9IDA7CgoJYm9fZ2VtLT5yZWxvY3NbYm9fZ2VtLT5yZWxvY19jb3VudF0ub2Zmc2V0ID0gb2Zmc2V0OwoJYm9fZ2VtLT5yZWxvY3NbYm9fZ2VtLT5yZWxvY19jb3VudF0uZGVsdGEgPSB0YXJnZXRfb2Zmc2V0OwoJYm9fZ2VtLT5yZWxvY3NbYm9fZ2VtLT5yZWxvY19jb3VudF0udGFyZ2V0X2hhbmRsZSA9CgkgICAgdGFyZ2V0X2JvX2dlbS0+Z2VtX2hhbmRsZTsKCWJvX2dlbS0+cmVsb2NzW2JvX2dlbS0+cmVsb2NfY291bnRdLnJlYWRfZG9tYWlucyA9IHJlYWRfZG9tYWluczsKCWJvX2dlbS0+cmVsb2NzW2JvX2dlbS0+cmVsb2NfY291bnRdLndyaXRlX2RvbWFpbiA9IHdyaXRlX2RvbWFpbjsKCWJvX2dlbS0+cmVsb2NzW2JvX2dlbS0+cmVsb2NfY291bnRdLnByZXN1bWVkX29mZnNldCA9IHRhcmdldF9iby0+b2Zmc2V0NjQ7Cglib19nZW0tPnJlbG9jX2NvdW50Kys7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkCmRybV9pbnRlbF9nZW1fYm9fdXNlXzQ4Yl9hZGRyZXNzX3JhbmdlKGRybV9pbnRlbF9ibyAqYm8sIHVpbnQzMl90IGVuYWJsZSkKewoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87Cglib19nZW0tPnVzZV80OGJfYWRkcmVzc19yYW5nZSA9IGVuYWJsZTsKfQoKc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2FkZF9zb2Z0cGluX3RhcmdldChkcm1faW50ZWxfYm8gKmJvLCBkcm1faW50ZWxfYm8gKnRhcmdldF9ibykKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJZHJtX2ludGVsX2JvX2dlbSAqdGFyZ2V0X2JvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIHRhcmdldF9ibzsKCWlmIChib19nZW0tPmhhc19lcnJvcikKCQlyZXR1cm4gLUVOT01FTTsKCglpZiAodGFyZ2V0X2JvX2dlbS0+aGFzX2Vycm9yKSB7CgkJYm9fZ2VtLT5oYXNfZXJyb3IgPSB0cnVlOwoJCXJldHVybiAtRU5PTUVNOwoJfQoKCWlmICghdGFyZ2V0X2JvX2dlbS0+aXNfc29mdHBpbikKCQlyZXR1cm4gLUVJTlZBTDsKCWlmICh0YXJnZXRfYm9fZ2VtID09IGJvX2dlbSkKCQlyZXR1cm4gLUVJTlZBTDsKCglpZiAoYm9fZ2VtLT5zb2Z0cGluX3RhcmdldF9jb3VudCA9PSBib19nZW0tPnNvZnRwaW5fdGFyZ2V0X3NpemUpIHsKCQlpbnQgbmV3X3NpemUgPSBib19nZW0tPnNvZnRwaW5fdGFyZ2V0X3NpemUgKiAyOwoJCWlmIChuZXdfc2l6ZSA9PSAwKQoJCQluZXdfc2l6ZSA9IGJ1Zm1ncl9nZW0tPm1heF9yZWxvY3M7CgoJCWJvX2dlbS0+c29mdHBpbl90YXJnZXQgPSByZWFsbG9jKGJvX2dlbS0+c29mdHBpbl90YXJnZXQsIG5ld19zaXplICoKCQkJCXNpemVvZihkcm1faW50ZWxfYm8gKikpOwoJCWlmICghYm9fZ2VtLT5zb2Z0cGluX3RhcmdldCkKCQkJcmV0dXJuIC1FTk9NRU07CgoJCWJvX2dlbS0+c29mdHBpbl90YXJnZXRfc2l6ZSA9IG5ld19zaXplOwoJfQoJYm9fZ2VtLT5zb2Z0cGluX3RhcmdldFtib19nZW0tPnNvZnRwaW5fdGFyZ2V0X2NvdW50XSA9IHRhcmdldF9ibzsKCWRybV9pbnRlbF9nZW1fYm9fcmVmZXJlbmNlKHRhcmdldF9ibyk7Cglib19nZW0tPnNvZnRwaW5fdGFyZ2V0X2NvdW50Kys7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19lbWl0X3JlbG9jKGRybV9pbnRlbF9ibyAqYm8sIHVpbnQzMl90IG9mZnNldCwKCQkJICAgIGRybV9pbnRlbF9ibyAqdGFyZ2V0X2JvLCB1aW50MzJfdCB0YXJnZXRfb2Zmc2V0LAoJCQkgICAgdWludDMyX3QgcmVhZF9kb21haW5zLCB1aW50MzJfdCB3cml0ZV9kb21haW4pCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKnRhcmdldF9ib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKXRhcmdldF9ibzsKCglpZiAodGFyZ2V0X2JvX2dlbS0+aXNfc29mdHBpbikKCQlyZXR1cm4gZHJtX2ludGVsX2dlbV9ib19hZGRfc29mdHBpbl90YXJnZXQoYm8sIHRhcmdldF9ibyk7CgllbHNlCgkJcmV0dXJuIGRvX2JvX2VtaXRfcmVsb2MoYm8sIG9mZnNldCwgdGFyZ2V0X2JvLCB0YXJnZXRfb2Zmc2V0LAoJCQkJCXJlYWRfZG9tYWlucywgd3JpdGVfZG9tYWluLAoJCQkJCSFidWZtZ3JfZ2VtLT5mZW5jZWRfcmVsb2NzKTsKfQoKc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2VtaXRfcmVsb2NfZmVuY2UoZHJtX2ludGVsX2JvICpibywgdWludDMyX3Qgb2Zmc2V0LAoJCQkJICBkcm1faW50ZWxfYm8gKnRhcmdldF9ibywKCQkJCSAgdWludDMyX3QgdGFyZ2V0X29mZnNldCwKCQkJCSAgdWludDMyX3QgcmVhZF9kb21haW5zLCB1aW50MzJfdCB3cml0ZV9kb21haW4pCnsKCXJldHVybiBkb19ib19lbWl0X3JlbG9jKGJvLCBvZmZzZXQsIHRhcmdldF9ibywgdGFyZ2V0X29mZnNldCwKCQkJCXJlYWRfZG9tYWlucywgd3JpdGVfZG9tYWluLCB0cnVlKTsKfQoKaW50CmRybV9pbnRlbF9nZW1fYm9fZ2V0X3JlbG9jX2NvdW50KGRybV9pbnRlbF9ibyAqYm8pCnsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoKCXJldHVybiBib19nZW0tPnJlbG9jX2NvdW50Owp9CgovKioKICogUmVtb3ZlcyBleGlzdGluZyByZWxvY2F0aW9uIGVudHJpZXMgaW4gdGhlIEJPIGFmdGVyICJzdGFydCIuCiAqCiAqIFRoaXMgYWxsb3dzIGEgdXNlciB0byBhdm9pZCBhIHR3by1zdGVwIHByb2Nlc3MgZm9yIHN0YXRlIHNldHVwIHdpdGgKICogY291bnRpbmcgdXAgYWxsIHRoZSBidWZmZXIgb2JqZWN0cyBhbmQgZG9pbmcgYQogKiBkcm1faW50ZWxfYnVmbWdyX2NoZWNrX2FwZXJ0dXJlX3NwYWNlKCkgYmVmb3JlIGVtaXR0aW5nIGFueSBvZiB0aGUKICogcmVsb2NhdGlvbnMgZm9yIHRoZSBzdGF0ZSBzZXR1cC4gIEluc3RlYWQsIHNhdmUgdGhlIHN0YXRlIG9mIHRoZQogKiBiYXRjaGJ1ZmZlciBpbmNsdWRpbmcgZHJtX2ludGVsX2dlbV9nZXRfcmVsb2NfY291bnQoKSwgZW1pdCBhbGwgdGhlCiAqIHN0YXRlLCBhbmQgdGhlbiBjaGVjayBpZiBpdCBzdGlsbCBmaXRzIGluIHRoZSBhcGVydHVyZS4KICoKICogQW55IGZ1cnRoZXIgZHJtX2ludGVsX2J1Zm1ncl9jaGVja19hcGVydHVyZV9zcGFjZSgpIHF1ZXJpZXMKICogaW52b2x2aW5nIHRoaXMgYnVmZmVyIGluIHRoZSB0cmVlIGFyZSB1bmRlZmluZWQgYWZ0ZXIgdGhpcyBjYWxsLgogKgogKiBUaGlzIGFsc28gcmVtb3ZlcyBhbGwgc29mdHBpbm5lZCB0YXJnZXRzIGJlaW5nIHJlZmVyZW5jZWQgYnkgdGhlIEJPLgogKi8Kdm9pZApkcm1faW50ZWxfZ2VtX2JvX2NsZWFyX3JlbG9jcyhkcm1faW50ZWxfYm8gKmJvLCBpbnQgc3RhcnQpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCWludCBpOwoJc3RydWN0IHRpbWVzcGVjIHRpbWU7CgoJY2xvY2tfZ2V0dGltZShDTE9DS19NT05PVE9OSUMsICZ0aW1lKTsKCglhc3NlcnQoYm9fZ2VtLT5yZWxvY19jb3VudCA+PSBzdGFydCk7CgoJLyogVW5yZWZlcmVuY2UgdGhlIGNsZWFyZWQgdGFyZ2V0IGJ1ZmZlcnMgKi8KCXB0aHJlYWRfbXV0ZXhfbG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgoJZm9yIChpID0gc3RhcnQ7IGkgPCBib19nZW0tPnJlbG9jX2NvdW50OyBpKyspIHsKCQlkcm1faW50ZWxfYm9fZ2VtICp0YXJnZXRfYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mb1tpXS5ibzsKCQlpZiAoJnRhcmdldF9ib19nZW0tPmJvICE9IGJvKSB7CgkJCWJvX2dlbS0+cmVsb2NfdHJlZV9mZW5jZXMgLT0gdGFyZ2V0X2JvX2dlbS0+cmVsb2NfdHJlZV9mZW5jZXM7CgkJCWRybV9pbnRlbF9nZW1fYm9fdW5yZWZlcmVuY2VfbG9ja2VkX3RpbWVkKCZ0YXJnZXRfYm9fZ2VtLT5ibywKCQkJCQkJCQkgIHRpbWUudHZfc2VjKTsKCQl9Cgl9Cglib19nZW0tPnJlbG9jX2NvdW50ID0gc3RhcnQ7CgoJZm9yIChpID0gMDsgaSA8IGJvX2dlbS0+c29mdHBpbl90YXJnZXRfY291bnQ7IGkrKykgewoJCWRybV9pbnRlbF9ib19nZW0gKnRhcmdldF9ib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBib19nZW0tPnNvZnRwaW5fdGFyZ2V0W2ldOwoJCWRybV9pbnRlbF9nZW1fYm9fdW5yZWZlcmVuY2VfbG9ja2VkX3RpbWVkKCZ0YXJnZXRfYm9fZ2VtLT5ibywgdGltZS50dl9zZWMpOwoJfQoJYm9fZ2VtLT5zb2Z0cGluX3RhcmdldF9jb3VudCA9IDA7CgoJcHRocmVhZF9tdXRleF91bmxvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoKfQoKLyoqCiAqIFdhbGsgdGhlIHRyZWUgb2YgcmVsb2NhdGlvbnMgcm9vdGVkIGF0IEJPIGFuZCBhY2N1bXVsYXRlIHRoZSBsaXN0IG9mCiAqIHZhbGlkYXRpb25zIHRvIGJlIHBlcmZvcm1lZCBhbmQgdXBkYXRlIHRoZSByZWxvY2F0aW9uIGJ1ZmZlcnMgd2l0aAogKiBpbmRleCB2YWx1ZXMgaW50byB0aGUgdmFsaWRhdGlvbiBsaXN0LgogKi8Kc3RhdGljIHZvaWQKZHJtX2ludGVsX2dlbV9ib19wcm9jZXNzX3JlbG9jKGRybV9pbnRlbF9ibyAqYm8pCnsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJaW50IGk7CgoJaWYgKGJvX2dlbS0+cmVsb2NzID09IE5VTEwpCgkJcmV0dXJuOwoKCWZvciAoaSA9IDA7IGkgPCBib19nZW0tPnJlbG9jX2NvdW50OyBpKyspIHsKCQlkcm1faW50ZWxfYm8gKnRhcmdldF9ibyA9IGJvX2dlbS0+cmVsb2NfdGFyZ2V0X2luZm9baV0uYm87CgoJCWlmICh0YXJnZXRfYm8gPT0gYm8pCgkJCWNvbnRpbnVlOwoKCQlkcm1faW50ZWxfZ2VtX2JvX21hcmtfbW1hcHNfaW5jb2hlcmVudChibyk7CgoJCS8qIENvbnRpbnVlIHdhbGtpbmcgdGhlIHRyZWUgZGVwdGgtZmlyc3QuICovCgkJZHJtX2ludGVsX2dlbV9ib19wcm9jZXNzX3JlbG9jKHRhcmdldF9ibyk7CgoJCS8qIEFkZCB0aGUgdGFyZ2V0IHRvIHRoZSB2YWxpZGF0ZSBsaXN0ICovCgkJZHJtX2ludGVsX2FkZF92YWxpZGF0ZV9idWZmZXIodGFyZ2V0X2JvKTsKCX0KfQoKc3RhdGljIHZvaWQKZHJtX2ludGVsX2dlbV9ib19wcm9jZXNzX3JlbG9jMihkcm1faW50ZWxfYm8gKmJvKQp7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKWJvOwoJaW50IGk7CgoJaWYgKGJvX2dlbS0+cmVsb2NzID09IE5VTEwgJiYgYm9fZ2VtLT5zb2Z0cGluX3RhcmdldCA9PSBOVUxMKQoJCXJldHVybjsKCglmb3IgKGkgPSAwOyBpIDwgYm9fZ2VtLT5yZWxvY19jb3VudDsgaSsrKSB7CgkJZHJtX2ludGVsX2JvICp0YXJnZXRfYm8gPSBib19nZW0tPnJlbG9jX3RhcmdldF9pbmZvW2ldLmJvOwoJCWludCBuZWVkX2ZlbmNlOwoKCQlpZiAodGFyZ2V0X2JvID09IGJvKQoJCQljb250aW51ZTsKCgkJZHJtX2ludGVsX2dlbV9ib19tYXJrX21tYXBzX2luY29oZXJlbnQoYm8pOwoKCQkvKiBDb250aW51ZSB3YWxraW5nIHRoZSB0cmVlIGRlcHRoLWZpcnN0LiAqLwoJCWRybV9pbnRlbF9nZW1fYm9fcHJvY2Vzc19yZWxvYzIodGFyZ2V0X2JvKTsKCgkJbmVlZF9mZW5jZSA9IChib19nZW0tPnJlbG9jX3RhcmdldF9pbmZvW2ldLmZsYWdzICYKCQkJICAgICAgRFJNX0lOVEVMX1JFTE9DX0ZFTkNFKTsKCgkJLyogQWRkIHRoZSB0YXJnZXQgdG8gdGhlIHZhbGlkYXRlIGxpc3QgKi8KCQlkcm1faW50ZWxfYWRkX3ZhbGlkYXRlX2J1ZmZlcjIodGFyZ2V0X2JvLCBuZWVkX2ZlbmNlKTsKCX0KCglmb3IgKGkgPSAwOyBpIDwgYm9fZ2VtLT5zb2Z0cGluX3RhcmdldF9jb3VudDsgaSsrKSB7CgkJZHJtX2ludGVsX2JvICp0YXJnZXRfYm8gPSBib19nZW0tPnNvZnRwaW5fdGFyZ2V0W2ldOwoKCQlpZiAodGFyZ2V0X2JvID09IGJvKQoJCQljb250aW51ZTsKCgkJZHJtX2ludGVsX2dlbV9ib19tYXJrX21tYXBzX2luY29oZXJlbnQoYm8pOwoJCWRybV9pbnRlbF9nZW1fYm9fcHJvY2Vzc19yZWxvYzIodGFyZ2V0X2JvKTsKCQlkcm1faW50ZWxfYWRkX3ZhbGlkYXRlX2J1ZmZlcjIodGFyZ2V0X2JvLCBmYWxzZSk7Cgl9Cn0KCgpzdGF0aWMgdm9pZApkcm1faW50ZWxfdXBkYXRlX2J1ZmZlcl9vZmZzZXRzKGRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtKQp7CglpbnQgaTsKCglmb3IgKGkgPSAwOyBpIDwgYnVmbWdyX2dlbS0+ZXhlY19jb3VudDsgaSsrKSB7CgkJZHJtX2ludGVsX2JvICpibyA9IGJ1Zm1ncl9nZW0tPmV4ZWNfYm9zW2ldOwoJCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoKCQkvKiBVcGRhdGUgdGhlIGJ1ZmZlciBvZmZzZXQgKi8KCQlpZiAoYnVmbWdyX2dlbS0+ZXhlY19vYmplY3RzW2ldLm9mZnNldCAhPSBiby0+b2Zmc2V0NjQpIHsKCQkJREJHKCJCTyAlZCAoJXMpIG1pZ3JhdGVkOiAweCUwOHggJTA4eCAtPiAweCUwOHggJTA4eFxuIiwKCQkJICAgIGJvX2dlbS0+Z2VtX2hhbmRsZSwgYm9fZ2VtLT5uYW1lLAoJCQkgICAgdXBwZXJfMzJfYml0cyhiby0+b2Zmc2V0NjQpLAoJCQkgICAgbG93ZXJfMzJfYml0cyhiby0+b2Zmc2V0NjQpLAoJCQkgICAgdXBwZXJfMzJfYml0cyhidWZtZ3JfZ2VtLT5leGVjX29iamVjdHNbaV0ub2Zmc2V0KSwKCQkJICAgIGxvd2VyXzMyX2JpdHMoYnVmbWdyX2dlbS0+ZXhlY19vYmplY3RzW2ldLm9mZnNldCkpOwoJCQliby0+b2Zmc2V0NjQgPSBidWZtZ3JfZ2VtLT5leGVjX29iamVjdHNbaV0ub2Zmc2V0OwoJCQliby0+b2Zmc2V0ID0gYnVmbWdyX2dlbS0+ZXhlY19vYmplY3RzW2ldLm9mZnNldDsKCQl9Cgl9Cn0KCnN0YXRpYyB2b2lkCmRybV9pbnRlbF91cGRhdGVfYnVmZmVyX29mZnNldHMyIChkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSkKewoJaW50IGk7CgoJZm9yIChpID0gMDsgaSA8IGJ1Zm1ncl9nZW0tPmV4ZWNfY291bnQ7IGkrKykgewoJCWRybV9pbnRlbF9ibyAqYm8gPSBidWZtZ3JfZ2VtLT5leGVjX2Jvc1tpXTsKCQlkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKWJvOwoKCQkvKiBVcGRhdGUgdGhlIGJ1ZmZlciBvZmZzZXQgKi8KCQlpZiAoYnVmbWdyX2dlbS0+ZXhlYzJfb2JqZWN0c1tpXS5vZmZzZXQgIT0gYm8tPm9mZnNldDY0KSB7CgkJCS8qIElmIHdlJ3JlIHNlZWluZyBzb2Z0cGlubmVkIG9iamVjdCBoZXJlIGl0IG1lYW5zIHRoYXQgdGhlIGtlcm5lbAoJCQkgKiBoYXMgcmVsb2NhdGVkIG91ciBvYmplY3QuLi4gSW5kaWNhdGluZyBhIHByb2dyYW1taW5nIGVycm9yCgkJCSAqLwoJCQlhc3NlcnQoIWJvX2dlbS0+aXNfc29mdHBpbik7CgkJCURCRygiQk8gJWQgKCVzKSBtaWdyYXRlZDogMHglMDh4ICUwOHggLT4gMHglMDh4ICUwOHhcbiIsCgkJCSAgICBib19nZW0tPmdlbV9oYW5kbGUsIGJvX2dlbS0+bmFtZSwKCQkJICAgIHVwcGVyXzMyX2JpdHMoYm8tPm9mZnNldDY0KSwKCQkJICAgIGxvd2VyXzMyX2JpdHMoYm8tPm9mZnNldDY0KSwKCQkJICAgIHVwcGVyXzMyX2JpdHMoYnVmbWdyX2dlbS0+ZXhlYzJfb2JqZWN0c1tpXS5vZmZzZXQpLAoJCQkgICAgbG93ZXJfMzJfYml0cyhidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzW2ldLm9mZnNldCkpOwoJCQliby0+b2Zmc2V0NjQgPSBidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzW2ldLm9mZnNldDsKCQkJYm8tPm9mZnNldCA9IGJ1Zm1ncl9nZW0tPmV4ZWMyX29iamVjdHNbaV0ub2Zmc2V0OwoJCX0KCX0KfQoKdm9pZApkcm1faW50ZWxfZ2VtX2JvX2F1Yl9kdW1wX2JtcChkcm1faW50ZWxfYm8gKmJvLAoJCQkgICAgICBpbnQgeDEsIGludCB5MSwgaW50IHdpZHRoLCBpbnQgaGVpZ2h0LAoJCQkgICAgICBlbnVtIGF1Yl9kdW1wX2JtcF9mb3JtYXQgZm9ybWF0LAoJCQkgICAgICBpbnQgcGl0Y2gsIGludCBvZmZzZXQpCnsKfQoKc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2V4ZWMoZHJtX2ludGVsX2JvICpibywgaW50IHVzZWQsCgkJICAgICAgZHJtX2NsaXBfcmVjdF90ICogY2xpcHJlY3RzLCBpbnQgbnVtX2NsaXByZWN0cywgaW50IERSNCkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCXN0cnVjdCBkcm1faTkxNV9nZW1fZXhlY2J1ZmZlciBleGVjYnVmOwoJaW50IHJldCwgaTsKCglpZiAodG9fYm9fZ2VtKGJvKS0+aGFzX2Vycm9yKQoJCXJldHVybiAtRU5PTUVNOwoKCXB0aHJlYWRfbXV0ZXhfbG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgkvKiBVcGRhdGUgaW5kaWNlcyBhbmQgc2V0IHVwIHRoZSB2YWxpZGF0ZSBsaXN0LiAqLwoJZHJtX2ludGVsX2dlbV9ib19wcm9jZXNzX3JlbG9jKGJvKTsKCgkvKiBBZGQgdGhlIGJhdGNoIGJ1ZmZlciB0byB0aGUgdmFsaWRhdGlvbiBsaXN0LiAgVGhlcmUgYXJlIG5vCgkgKiByZWxvY2F0aW9ucyBwb2ludGluZyB0byBpdC4KCSAqLwoJZHJtX2ludGVsX2FkZF92YWxpZGF0ZV9idWZmZXIoYm8pOwoKCW1lbWNsZWFyKGV4ZWNidWYpOwoJZXhlY2J1Zi5idWZmZXJzX3B0ciA9ICh1aW50cHRyX3QpIGJ1Zm1ncl9nZW0tPmV4ZWNfb2JqZWN0czsKCWV4ZWNidWYuYnVmZmVyX2NvdW50ID0gYnVmbWdyX2dlbS0+ZXhlY19jb3VudDsKCWV4ZWNidWYuYmF0Y2hfc3RhcnRfb2Zmc2V0ID0gMDsKCWV4ZWNidWYuYmF0Y2hfbGVuID0gdXNlZDsKCWV4ZWNidWYuY2xpcHJlY3RzX3B0ciA9ICh1aW50cHRyX3QpIGNsaXByZWN0czsKCWV4ZWNidWYubnVtX2NsaXByZWN0cyA9IG51bV9jbGlwcmVjdHM7CglleGVjYnVmLkRSMSA9IDA7CglleGVjYnVmLkRSNCA9IERSNDsKCglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwKCQkgICAgICAgRFJNX0lPQ1RMX0k5MTVfR0VNX0VYRUNCVUZGRVIsCgkJICAgICAgICZleGVjYnVmKTsKCWlmIChyZXQgIT0gMCkgewoJCXJldCA9IC1lcnJubzsKCQlpZiAoZXJybm8gPT0gRU5PU1BDKSB7CgkJCURCRygiRXhlY2J1ZmZlciBmYWlscyB0byBwaW4uICIKCQkJICAgICJFc3RpbWF0ZTogJXUuIEFjdHVhbDogJXUuIEF2YWlsYWJsZTogJXVcbiIsCgkJCSAgICBkcm1faW50ZWxfZ2VtX2VzdGltYXRlX2JhdGNoX3NwYWNlKGJ1Zm1ncl9nZW0tPmV4ZWNfYm9zLAoJCQkJCQkJICAgICAgIGJ1Zm1ncl9nZW0tPgoJCQkJCQkJICAgICAgIGV4ZWNfY291bnQpLAoJCQkgICAgZHJtX2ludGVsX2dlbV9jb21wdXRlX2JhdGNoX3NwYWNlKGJ1Zm1ncl9nZW0tPmV4ZWNfYm9zLAoJCQkJCQkJICAgICAgYnVmbWdyX2dlbS0+CgkJCQkJCQkgICAgICBleGVjX2NvdW50KSwKCQkJICAgICh1bnNpZ25lZCBpbnQpYnVmbWdyX2dlbS0+Z3R0X3NpemUpOwoJCX0KCX0KCWRybV9pbnRlbF91cGRhdGVfYnVmZmVyX29mZnNldHMoYnVmbWdyX2dlbSk7CgoJaWYgKGJ1Zm1ncl9nZW0tPmJ1Zm1nci5kZWJ1ZykKCQlkcm1faW50ZWxfZ2VtX2R1bXBfdmFsaWRhdGlvbl9saXN0KGJ1Zm1ncl9nZW0pOwoKCWZvciAoaSA9IDA7IGkgPCBidWZtZ3JfZ2VtLT5leGVjX2NvdW50OyBpKyspIHsKCQlkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSB0b19ib19nZW0oYnVmbWdyX2dlbS0+ZXhlY19ib3NbaV0pOwoKCQlib19nZW0tPmlkbGUgPSBmYWxzZTsKCgkJLyogRGlzY29ubmVjdCB0aGUgYnVmZmVyIGZyb20gdGhlIHZhbGlkYXRlIGxpc3QgKi8KCQlib19nZW0tPnZhbGlkYXRlX2luZGV4ID0gLTE7CgkJYnVmbWdyX2dlbS0+ZXhlY19ib3NbaV0gPSBOVUxMOwoJfQoJYnVmbWdyX2dlbS0+ZXhlY19jb3VudCA9IDA7CglwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgoJcmV0dXJuIHJldDsKfQoKc3RhdGljIGludApkb19leGVjMihkcm1faW50ZWxfYm8gKmJvLCBpbnQgdXNlZCwgZHJtX2ludGVsX2NvbnRleHQgKmN0eCwKCSBkcm1fY2xpcF9yZWN0X3QgKmNsaXByZWN0cywgaW50IG51bV9jbGlwcmVjdHMsIGludCBEUjQsCgkgdW5zaWduZWQgaW50IGZsYWdzKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKWJvLT5idWZtZ3I7CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2V4ZWNidWZmZXIyIGV4ZWNidWY7CglpbnQgcmV0ID0gMDsKCWludCBpOwoKCWlmICh0b19ib19nZW0oYm8pLT5oYXNfZXJyb3IpCgkJcmV0dXJuIC1FTk9NRU07CgoJc3dpdGNoIChmbGFncyAmIDB4NykgewoJZGVmYXVsdDoKCQlyZXR1cm4gLUVJTlZBTDsKCWNhc2UgSTkxNV9FWEVDX0JMVDoKCQlpZiAoIWJ1Zm1ncl9nZW0tPmhhc19ibHQpCgkJCXJldHVybiAtRUlOVkFMOwoJCWJyZWFrOwoJY2FzZSBJOTE1X0VYRUNfQlNEOgoJCWlmICghYnVmbWdyX2dlbS0+aGFzX2JzZCkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJYnJlYWs7CgljYXNlIEk5MTVfRVhFQ19WRUJPWDoKCQlpZiAoIWJ1Zm1ncl9nZW0tPmhhc192ZWJveCkKCQkJcmV0dXJuIC1FSU5WQUw7CgkJYnJlYWs7CgljYXNlIEk5MTVfRVhFQ19SRU5ERVI6CgljYXNlIEk5MTVfRVhFQ19ERUZBVUxUOgoJCWJyZWFrOwoJfQoKCXB0aHJlYWRfbXV0ZXhfbG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgkvKiBVcGRhdGUgaW5kaWNlcyBhbmQgc2V0IHVwIHRoZSB2YWxpZGF0ZSBsaXN0LiAqLwoJZHJtX2ludGVsX2dlbV9ib19wcm9jZXNzX3JlbG9jMihibyk7CgoJLyogQWRkIHRoZSBiYXRjaCBidWZmZXIgdG8gdGhlIHZhbGlkYXRpb24gbGlzdC4gIFRoZXJlIGFyZSBubyByZWxvY2F0aW9ucwoJICogcG9pbnRpbmcgdG8gaXQuCgkgKi8KCWRybV9pbnRlbF9hZGRfdmFsaWRhdGVfYnVmZmVyMihibywgMCk7CgoJbWVtY2xlYXIoZXhlY2J1Zik7CglleGVjYnVmLmJ1ZmZlcnNfcHRyID0gKHVpbnRwdHJfdClidWZtZ3JfZ2VtLT5leGVjMl9vYmplY3RzOwoJZXhlY2J1Zi5idWZmZXJfY291bnQgPSBidWZtZ3JfZ2VtLT5leGVjX2NvdW50OwoJZXhlY2J1Zi5iYXRjaF9zdGFydF9vZmZzZXQgPSAwOwoJZXhlY2J1Zi5iYXRjaF9sZW4gPSB1c2VkOwoJZXhlY2J1Zi5jbGlwcmVjdHNfcHRyID0gKHVpbnRwdHJfdCljbGlwcmVjdHM7CglleGVjYnVmLm51bV9jbGlwcmVjdHMgPSBudW1fY2xpcHJlY3RzOwoJZXhlY2J1Zi5EUjEgPSAwOwoJZXhlY2J1Zi5EUjQgPSBEUjQ7CglleGVjYnVmLmZsYWdzID0gZmxhZ3M7CglpZiAoY3R4ID09IE5VTEwpCgkJaTkxNV9leGVjYnVmZmVyMl9zZXRfY29udGV4dF9pZChleGVjYnVmLCAwKTsKCWVsc2UKCQlpOTE1X2V4ZWNidWZmZXIyX3NldF9jb250ZXh0X2lkKGV4ZWNidWYsIGN0eC0+Y3R4X2lkKTsKCWV4ZWNidWYucnN2ZDIgPSAwOwoKCWlmIChidWZtZ3JfZ2VtLT5ub19leGVjKQoJCWdvdG8gc2tpcF9leGVjdXRpb247CgoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsCgkJICAgICAgIERSTV9JT0NUTF9JOTE1X0dFTV9FWEVDQlVGRkVSMiwKCQkgICAgICAgJmV4ZWNidWYpOwoJaWYgKHJldCAhPSAwKSB7CgkJcmV0ID0gLWVycm5vOwoJCWlmIChyZXQgPT0gLUVOT1NQQykgewoJCQlEQkcoIkV4ZWNidWZmZXIgZmFpbHMgdG8gcGluLiAiCgkJCSAgICAiRXN0aW1hdGU6ICV1LiBBY3R1YWw6ICV1LiBBdmFpbGFibGU6ICV1XG4iLAoJCQkgICAgZHJtX2ludGVsX2dlbV9lc3RpbWF0ZV9iYXRjaF9zcGFjZShidWZtZ3JfZ2VtLT5leGVjX2JvcywKCQkJCQkJCSAgICAgICBidWZtZ3JfZ2VtLT5leGVjX2NvdW50KSwKCQkJICAgIGRybV9pbnRlbF9nZW1fY29tcHV0ZV9iYXRjaF9zcGFjZShidWZtZ3JfZ2VtLT5leGVjX2JvcywKCQkJCQkJCSAgICAgIGJ1Zm1ncl9nZW0tPmV4ZWNfY291bnQpLAoJCQkgICAgKHVuc2lnbmVkIGludCkgYnVmbWdyX2dlbS0+Z3R0X3NpemUpOwoJCX0KCX0KCWRybV9pbnRlbF91cGRhdGVfYnVmZmVyX29mZnNldHMyKGJ1Zm1ncl9nZW0pOwoKc2tpcF9leGVjdXRpb246CglpZiAoYnVmbWdyX2dlbS0+YnVmbWdyLmRlYnVnKQoJCWRybV9pbnRlbF9nZW1fZHVtcF92YWxpZGF0aW9uX2xpc3QoYnVmbWdyX2dlbSk7CgoJZm9yIChpID0gMDsgaSA8IGJ1Zm1ncl9nZW0tPmV4ZWNfY291bnQ7IGkrKykgewoJCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IHRvX2JvX2dlbShidWZtZ3JfZ2VtLT5leGVjX2Jvc1tpXSk7CgoJCWJvX2dlbS0+aWRsZSA9IGZhbHNlOwoKCQkvKiBEaXNjb25uZWN0IHRoZSBidWZmZXIgZnJvbSB0aGUgdmFsaWRhdGUgbGlzdCAqLwoJCWJvX2dlbS0+dmFsaWRhdGVfaW5kZXggPSAtMTsKCQlidWZtZ3JfZ2VtLT5leGVjX2Jvc1tpXSA9IE5VTEw7Cgl9CglidWZtZ3JfZ2VtLT5leGVjX2NvdW50ID0gMDsKCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fYm9fZXhlYzIoZHJtX2ludGVsX2JvICpibywgaW50IHVzZWQsCgkJICAgICAgIGRybV9jbGlwX3JlY3RfdCAqY2xpcHJlY3RzLCBpbnQgbnVtX2NsaXByZWN0cywKCQkgICAgICAgaW50IERSNCkKewoJcmV0dXJuIGRvX2V4ZWMyKGJvLCB1c2VkLCBOVUxMLCBjbGlwcmVjdHMsIG51bV9jbGlwcmVjdHMsIERSNCwKCQkJSTkxNV9FWEVDX1JFTkRFUik7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19tcmJfZXhlYzIoZHJtX2ludGVsX2JvICpibywgaW50IHVzZWQsCgkJCWRybV9jbGlwX3JlY3RfdCAqY2xpcHJlY3RzLCBpbnQgbnVtX2NsaXByZWN0cywgaW50IERSNCwKCQkJdW5zaWduZWQgaW50IGZsYWdzKQp7CglyZXR1cm4gZG9fZXhlYzIoYm8sIHVzZWQsIE5VTEwsIGNsaXByZWN0cywgbnVtX2NsaXByZWN0cywgRFI0LAoJCQlmbGFncyk7Cn0KCmludApkcm1faW50ZWxfZ2VtX2JvX2NvbnRleHRfZXhlYyhkcm1faW50ZWxfYm8gKmJvLCBkcm1faW50ZWxfY29udGV4dCAqY3R4LAoJCQkgICAgICBpbnQgdXNlZCwgdW5zaWduZWQgaW50IGZsYWdzKQp7CglyZXR1cm4gZG9fZXhlYzIoYm8sIHVzZWQsIGN0eCwgTlVMTCwgMCwgMCwgZmxhZ3MpOwp9CgpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fYm9fcGluKGRybV9pbnRlbF9ibyAqYm8sIHVpbnQzMl90IGFsaWdubWVudCkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJc3RydWN0IGRybV9pOTE1X2dlbV9waW4gcGluOwoJaW50IHJldDsKCgltZW1jbGVhcihwaW4pOwoJcGluLmhhbmRsZSA9IGJvX2dlbS0+Z2VtX2hhbmRsZTsKCXBpbi5hbGlnbm1lbnQgPSBhbGlnbm1lbnQ7CgoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsCgkJICAgICAgIERSTV9JT0NUTF9JOTE1X0dFTV9QSU4sCgkJICAgICAgICZwaW4pOwoJaWYgKHJldCAhPSAwKQoJCXJldHVybiAtZXJybm87CgoJYm8tPm9mZnNldDY0ID0gcGluLm9mZnNldDsKCWJvLT5vZmZzZXQgPSBwaW4ub2Zmc2V0OwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib191bnBpbihkcm1faW50ZWxfYm8gKmJvKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX3VucGluIHVucGluOwoJaW50IHJldDsKCgltZW1jbGVhcih1bnBpbik7Cgl1bnBpbi5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CgoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsIERSTV9JT0NUTF9JOTE1X0dFTV9VTlBJTiwgJnVucGluKTsKCWlmIChyZXQgIT0gMCkKCQlyZXR1cm4gLWVycm5vOwoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fYm9fc2V0X3RpbGluZ19pbnRlcm5hbChkcm1faW50ZWxfYm8gKmJvLAoJCQkJICAgICB1aW50MzJfdCB0aWxpbmdfbW9kZSwKCQkJCSAgICAgdWludDMyX3Qgc3RyaWRlKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBiby0+YnVmbWdyOwoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX3NldF90aWxpbmcgc2V0X3RpbGluZzsKCWludCByZXQ7CgoJaWYgKGJvX2dlbS0+Z2xvYmFsX25hbWUgPT0gMCAmJgoJICAgIHRpbGluZ19tb2RlID09IGJvX2dlbS0+dGlsaW5nX21vZGUgJiYKCSAgICBzdHJpZGUgPT0gYm9fZ2VtLT5zdHJpZGUpCgkJcmV0dXJuIDA7CgoJbWVtc2V0KCZzZXRfdGlsaW5nLCAwLCBzaXplb2Yoc2V0X3RpbGluZykpOwoJZG8gewoJCS8qIHNldF90aWxpbmcgaXMgc2xpZ2h0bHkgYnJva2VuIGFuZCBvdmVyd3JpdGVzIHRoZQoJCSAqIGlucHV0IG9uIHRoZSBlcnJvciBwYXRoLCBzbyB3ZSBoYXZlIHRvIG9wZW4gY29kZQoJCSAqIHJtSW9jdGwuCgkJICovCgkJc2V0X3RpbGluZy5oYW5kbGUgPSBib19nZW0tPmdlbV9oYW5kbGU7CgkJc2V0X3RpbGluZy50aWxpbmdfbW9kZSA9IHRpbGluZ19tb2RlOwoJCXNldF90aWxpbmcuc3RyaWRlID0gc3RyaWRlOwoKCQlyZXQgPSBpb2N0bChidWZtZ3JfZ2VtLT5mZCwKCQkJICAgIERSTV9JT0NUTF9JOTE1X0dFTV9TRVRfVElMSU5HLAoJCQkgICAgJnNldF90aWxpbmcpOwoJfSB3aGlsZSAocmV0ID09IC0xICYmIChlcnJubyA9PSBFSU5UUiB8fCBlcnJubyA9PSBFQUdBSU4pKTsKCWlmIChyZXQgPT0gLTEpCgkJcmV0dXJuIC1lcnJubzsKCglib19nZW0tPnRpbGluZ19tb2RlID0gc2V0X3RpbGluZy50aWxpbmdfbW9kZTsKCWJvX2dlbS0+c3dpenpsZV9tb2RlID0gc2V0X3RpbGluZy5zd2l6emxlX21vZGU7Cglib19nZW0tPnN0cmlkZSA9IHNldF90aWxpbmcuc3RyaWRlOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19zZXRfdGlsaW5nKGRybV9pbnRlbF9ibyAqYm8sIHVpbnQzMl90ICogdGlsaW5nX21vZGUsCgkJCSAgICB1aW50MzJfdCBzdHJpZGUpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJvLT5idWZtZ3I7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCWludCByZXQ7CgoJLyogVGlsaW5nIHdpdGggdXNlcnB0ciBzdXJmYWNlcyBpcyBub3Qgc3VwcG9ydGVkCgkgKiBvbiBhbGwgaGFyZHdhcmUgc28gcmVmdXNlIGl0IGZvciB0aW1lIGJlaW5nLgoJICovCglpZiAoYm9fZ2VtLT5pc191c2VycHRyKQoJCXJldHVybiAtRUlOVkFMOwoKCS8qIExpbmVhciBidWZmZXJzIGhhdmUgbm8gc3RyaWRlLiBCeSBlbnN1cmluZyB0aGF0IHdlIG9ubHkgZXZlciB1c2UKCSAqIHN0cmlkZSAwIHdpdGggbGluZWFyIGJ1ZmZlcnMsIHdlIHNpbXBsaWZ5IG91ciBjb2RlLgoJICovCglpZiAoKnRpbGluZ19tb2RlID09IEk5MTVfVElMSU5HX05PTkUpCgkJc3RyaWRlID0gMDsKCglyZXQgPSBkcm1faW50ZWxfZ2VtX2JvX3NldF90aWxpbmdfaW50ZXJuYWwoYm8sICp0aWxpbmdfbW9kZSwgc3RyaWRlKTsKCWlmIChyZXQgPT0gMCkKCQlkcm1faW50ZWxfYm9fZ2VtX3NldF9pbl9hcGVydHVyZV9zaXplKGJ1Zm1ncl9nZW0sIGJvX2dlbSwgMCk7CgoJKnRpbGluZ19tb2RlID0gYm9fZ2VtLT50aWxpbmdfbW9kZTsKCXJldHVybiByZXQ7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19nZXRfdGlsaW5nKGRybV9pbnRlbF9ibyAqYm8sIHVpbnQzMl90ICogdGlsaW5nX21vZGUsCgkJCSAgICB1aW50MzJfdCAqIHN3aXp6bGVfbW9kZSkKewoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CgoJKnRpbGluZ19tb2RlID0gYm9fZ2VtLT50aWxpbmdfbW9kZTsKCSpzd2l6emxlX21vZGUgPSBib19nZW0tPnN3aXp6bGVfbW9kZTsKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fYm9fc2V0X3NvZnRwaW5fb2Zmc2V0KGRybV9pbnRlbF9ibyAqYm8sIHVpbnQ2NF90IG9mZnNldCkKewoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CgoJYm9fZ2VtLT5pc19zb2Z0cGluID0gdHJ1ZTsKCWJvLT5vZmZzZXQ2NCA9IG9mZnNldDsKCWJvLT5vZmZzZXQgPSBvZmZzZXQ7CglyZXR1cm4gMDsKfQoKZHJtX2ludGVsX2JvICoKZHJtX2ludGVsX2JvX2dlbV9jcmVhdGVfZnJvbV9wcmltZShkcm1faW50ZWxfYnVmbWdyICpidWZtZ3IsIGludCBwcmltZV9mZCwgaW50IHNpemUpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJ1Zm1ncjsKCWludCByZXQ7Cgl1aW50MzJfdCBoYW5kbGU7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW07CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2dldF90aWxpbmcgZ2V0X3RpbGluZzsKCWRybU1NTGlzdEhlYWQgKmxpc3Q7CgoJcHRocmVhZF9tdXRleF9sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCXJldCA9IGRybVByaW1lRkRUb0hhbmRsZShidWZtZ3JfZ2VtLT5mZCwgcHJpbWVfZmQsICZoYW5kbGUpOwoJaWYgKHJldCkgewoJCURCRygiY3JlYXRlX2Zyb21fcHJpbWU6IGZhaWxlZCB0byBvYnRhaW4gaGFuZGxlIGZyb20gZmQ6ICVzXG4iLCBzdHJlcnJvcihlcnJubykpOwoJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCQlyZXR1cm4gTlVMTDsKCX0KCgkvKgoJICogU2VlIGlmIHRoZSBrZXJuZWwgaGFzIGFscmVhZHkgcmV0dXJuZWQgdGhpcyBidWZmZXIgdG8gdXMuIEp1c3QgYXMKCSAqIGZvciBuYW1lZCBidWZmZXJzLCB3ZSBtdXN0IG5vdCBjcmVhdGUgdHdvIGJvJ3MgcG9pbnRpbmcgYXQgdGhlIHNhbWUKCSAqIGtlcm5lbCBvYmplY3QKCSAqLwoJZm9yIChsaXN0ID0gYnVmbWdyX2dlbS0+bmFtZWQubmV4dDsKCSAgICAgbGlzdCAhPSAmYnVmbWdyX2dlbS0+bmFtZWQ7CgkgICAgIGxpc3QgPSBsaXN0LT5uZXh0KSB7CgkJYm9fZ2VtID0gRFJNTElTVEVOVFJZKGRybV9pbnRlbF9ib19nZW0sIGxpc3QsIG5hbWVfbGlzdCk7CgkJaWYgKGJvX2dlbS0+Z2VtX2hhbmRsZSA9PSBoYW5kbGUpIHsKCQkJZHJtX2ludGVsX2dlbV9ib19yZWZlcmVuY2UoJmJvX2dlbS0+Ym8pOwoJCQlwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgkJCXJldHVybiAmYm9fZ2VtLT5ibzsKCQl9Cgl9CgoJYm9fZ2VtID0gY2FsbG9jKDEsIHNpemVvZigqYm9fZ2VtKSk7CglpZiAoIWJvX2dlbSkgewoJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCQlyZXR1cm4gTlVMTDsKCX0KCS8qIERldGVybWluZSBzaXplIG9mIGJvLiAgVGhlIGZkLXRvLWhhbmRsZSBpb2N0bCByZWFsbHkgc2hvdWxkCgkgKiByZXR1cm4gdGhlIHNpemUsIGJ1dCBpdCBkb2Vzbid0LiAgSWYgd2UgaGF2ZSBrZXJuZWwgMy4xMiBvcgoJICogbGF0ZXIsIHdlIGNhbiBsc2VlayBvbiB0aGUgcHJpbWUgZmQgdG8gZ2V0IHRoZSBzaXplLiAgT2xkZXIKCSAqIGtlcm5lbHMgd2lsbCBqdXN0IGZhaWwsIGluIHdoaWNoIGNhc2Ugd2UgZmFsbCBiYWNrIHRvIHRoZQoJICogcHJvdmlkZWQgKGVzdGltYXRlZCBvciBndWVzcyBzaXplKS4gKi8KCXJldCA9IGxzZWVrKHByaW1lX2ZkLCAwLCBTRUVLX0VORCk7CglpZiAocmV0ICE9IC0xKQoJCWJvX2dlbS0+Ym8uc2l6ZSA9IHJldDsKCWVsc2UKCQlib19nZW0tPmJvLnNpemUgPSBzaXplOwoKCWJvX2dlbS0+Ym8uaGFuZGxlID0gaGFuZGxlOwoJYm9fZ2VtLT5iby5idWZtZ3IgPSBidWZtZ3I7CgoJYm9fZ2VtLT5nZW1faGFuZGxlID0gaGFuZGxlOwoKCWF0b21pY19zZXQoJmJvX2dlbS0+cmVmY291bnQsIDEpOwoKCWJvX2dlbS0+bmFtZSA9ICJwcmltZSI7Cglib19nZW0tPnZhbGlkYXRlX2luZGV4ID0gLTE7Cglib19nZW0tPnJlbG9jX3RyZWVfZmVuY2VzID0gMDsKCWJvX2dlbS0+dXNlZF9hc19yZWxvY190YXJnZXQgPSBmYWxzZTsKCWJvX2dlbS0+aGFzX2Vycm9yID0gZmFsc2U7Cglib19nZW0tPnJldXNhYmxlID0gZmFsc2U7Cglib19nZW0tPnVzZV80OGJfYWRkcmVzc19yYW5nZSA9IGZhbHNlOwoKCURSTUlOSVRMSVNUSEVBRCgmYm9fZ2VtLT52bWFfbGlzdCk7CglEUk1MSVNUQUREVEFJTCgmYm9fZ2VtLT5uYW1lX2xpc3QsICZidWZtZ3JfZ2VtLT5uYW1lZCk7CglwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CgoJbWVtY2xlYXIoZ2V0X3RpbGluZyk7CglnZXRfdGlsaW5nLmhhbmRsZSA9IGJvX2dlbS0+Z2VtX2hhbmRsZTsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLAoJCSAgICAgICBEUk1fSU9DVExfSTkxNV9HRU1fR0VUX1RJTElORywKCQkgICAgICAgJmdldF90aWxpbmcpOwoJaWYgKHJldCAhPSAwKSB7CgkJREJHKCJjcmVhdGVfZnJvbV9wcmltZTogZmFpbGVkIHRvIGdldCB0aWxpbmc6ICVzXG4iLCBzdHJlcnJvcihlcnJubykpOwoJCWRybV9pbnRlbF9nZW1fYm9fdW5yZWZlcmVuY2UoJmJvX2dlbS0+Ym8pOwoJCXJldHVybiBOVUxMOwoJfQoJYm9fZ2VtLT50aWxpbmdfbW9kZSA9IGdldF90aWxpbmcudGlsaW5nX21vZGU7Cglib19nZW0tPnN3aXp6bGVfbW9kZSA9IGdldF90aWxpbmcuc3dpenpsZV9tb2RlOwoJLyogWFhYIHN0cmlkZSBpcyB1bmtub3duICovCglkcm1faW50ZWxfYm9fZ2VtX3NldF9pbl9hcGVydHVyZV9zaXplKGJ1Zm1ncl9nZW0sIGJvX2dlbSwgMCk7CgoJcmV0dXJuICZib19nZW0tPmJvOwp9CgppbnQKZHJtX2ludGVsX2JvX2dlbV9leHBvcnRfdG9fcHJpbWUoZHJtX2ludGVsX2JvICpibywgaW50ICpwcmltZV9mZCkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoKCXB0aHJlYWRfbXV0ZXhfbG9jaygmYnVmbWdyX2dlbS0+bG9jayk7CiAgICAgICAgaWYgKERSTUxJU1RFTVBUWSgmYm9fZ2VtLT5uYW1lX2xpc3QpKQogICAgICAgICAgICAgICAgRFJNTElTVEFERFRBSUwoJmJvX2dlbS0+bmFtZV9saXN0LCAmYnVmbWdyX2dlbS0+bmFtZWQpOwoJcHRocmVhZF9tdXRleF91bmxvY2soJmJ1Zm1ncl9nZW0tPmxvY2spOwoKCWlmIChkcm1QcmltZUhhbmRsZVRvRkQoYnVmbWdyX2dlbS0+ZmQsIGJvX2dlbS0+Z2VtX2hhbmRsZSwKCQkJICAgICAgIERSTV9DTE9FWEVDLCBwcmltZV9mZCkgIT0gMCkKCQlyZXR1cm4gLWVycm5vOwoKCWJvX2dlbS0+cmV1c2FibGUgPSBmYWxzZTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2ZsaW5rKGRybV9pbnRlbF9ibyAqYm8sIHVpbnQzMl90ICogbmFtZSkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKikgYm8tPmJ1Zm1ncjsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJaW50IHJldDsKCglpZiAoIWJvX2dlbS0+Z2xvYmFsX25hbWUpIHsKCQlzdHJ1Y3QgZHJtX2dlbV9mbGluayBmbGluazsKCgkJbWVtY2xlYXIoZmxpbmspOwoJCWZsaW5rLmhhbmRsZSA9IGJvX2dlbS0+Z2VtX2hhbmRsZTsKCgkJcHRocmVhZF9tdXRleF9sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCgkJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsIERSTV9JT0NUTF9HRU1fRkxJTkssICZmbGluayk7CgkJaWYgKHJldCAhPSAwKSB7CgkJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfZ2VtLT5sb2NrKTsKCQkJcmV0dXJuIC1lcnJubzsKCQl9CgoJCWJvX2dlbS0+Z2xvYmFsX25hbWUgPSBmbGluay5uYW1lOwoJCWJvX2dlbS0+cmV1c2FibGUgPSBmYWxzZTsKCiAgICAgICAgICAgICAgICBpZiAoRFJNTElTVEVNUFRZKCZib19nZW0tPm5hbWVfbGlzdCkpCiAgICAgICAgICAgICAgICAgICAgICAgIERSTUxJU1RBRERUQUlMKCZib19nZW0tPm5hbWVfbGlzdCwgJmJ1Zm1ncl9nZW0tPm5hbWVkKTsKCQlwdGhyZWFkX211dGV4X3VubG9jaygmYnVmbWdyX2dlbS0+bG9jayk7Cgl9CgoJKm5hbWUgPSBib19nZW0tPmdsb2JhbF9uYW1lOwoJcmV0dXJuIDA7Cn0KCi8qKgogKiBFbmFibGVzIHVubGltaXRlZCBjYWNoaW5nIG9mIGJ1ZmZlciBvYmplY3RzIGZvciByZXVzZS4KICoKICogVGhpcyBpcyBwb3RlbnRpYWxseSB2ZXJ5IG1lbW9yeSBleHBlbnNpdmUsIGFzIHRoZSBjYWNoZSBhdCBlYWNoIGJ1Y2tldAogKiBzaXplIGlzIG9ubHkgYm91bmRlZCBieSBob3cgbWFueSBidWZmZXJzIG9mIHRoYXQgc2l6ZSB3ZSd2ZSBtYW5hZ2VkIHRvIGhhdmUKICogaW4gZmxpZ2h0IGF0IG9uY2UuCiAqLwp2b2lkCmRybV9pbnRlbF9idWZtZ3JfZ2VtX2VuYWJsZV9yZXVzZShkcm1faW50ZWxfYnVmbWdyICpidWZtZ3IpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopIGJ1Zm1ncjsKCglidWZtZ3JfZ2VtLT5ib19yZXVzZSA9IHRydWU7Cn0KCi8qKgogKiBFbmFibGUgdXNlIG9mIGZlbmNlZCByZWxvYyB0eXBlLgogKgogKiBOZXcgY29kZSBzaG91bGQgZW5hYmxlIHRoaXMgdG8gYXZvaWQgdW5uZWNlc3NhcnkgZmVuY2UgcmVnaXN0ZXIKICogYWxsb2NhdGlvbi4gIElmIHRoaXMgb3B0aW9uIGlzIG5vdCBlbmFibGVkLCBhbGwgcmVsb2NzIHdpbGwgaGF2ZSBmZW5jZQogKiByZWdpc3RlciBhbGxvY2F0ZWQuCiAqLwp2b2lkCmRybV9pbnRlbF9idWZtZ3JfZ2VtX2VuYWJsZV9mZW5jZWRfcmVsb2NzKGRybV9pbnRlbF9idWZtZ3IgKmJ1Zm1ncikKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKilidWZtZ3I7CgoJaWYgKGJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19leGVjID09IGRybV9pbnRlbF9nZW1fYm9fZXhlYzIpCgkJYnVmbWdyX2dlbS0+ZmVuY2VkX3JlbG9jcyA9IHRydWU7Cn0KCi8qKgogKiBSZXR1cm4gdGhlIGFkZGl0aW9uYWwgYXBlcnR1cmUgc3BhY2UgcmVxdWlyZWQgYnkgdGhlIHRyZWUgb2YgYnVmZmVyIG9iamVjdHMKICogcm9vdGVkIGF0IGJvLgogKi8Kc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2dldF9hcGVydHVyZV9zcGFjZShkcm1faW50ZWxfYm8gKmJvKQp7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCWludCBpOwoJaW50IHRvdGFsID0gMDsKCglpZiAoYm8gPT0gTlVMTCB8fCBib19nZW0tPmluY2x1ZGVkX2luX2NoZWNrX2FwZXJ0dXJlKQoJCXJldHVybiAwOwoKCXRvdGFsICs9IGJvLT5zaXplOwoJYm9fZ2VtLT5pbmNsdWRlZF9pbl9jaGVja19hcGVydHVyZSA9IHRydWU7CgoJZm9yIChpID0gMDsgaSA8IGJvX2dlbS0+cmVsb2NfY291bnQ7IGkrKykKCQl0b3RhbCArPQoJCSAgICBkcm1faW50ZWxfZ2VtX2JvX2dldF9hcGVydHVyZV9zcGFjZShib19nZW0tPgoJCQkJCQkJcmVsb2NfdGFyZ2V0X2luZm9baV0uYm8pOwoKCXJldHVybiB0b3RhbDsKfQoKLyoqCiAqIENvdW50IHRoZSBudW1iZXIgb2YgYnVmZmVycyBpbiB0aGlzIGxpc3QgdGhhdCBuZWVkIGEgZmVuY2UgcmVnCiAqCiAqIElmIHRoZSBjb3VudCBpcyBncmVhdGVyIHRoYW4gdGhlIG51bWJlciBvZiBhdmFpbGFibGUgcmVncywgd2UnbGwgaGF2ZQogKiB0byBhc2sgdGhlIGNhbGxlciB0byByZXN1Ym1pdCBhIGJhdGNoIHdpdGggZmV3ZXIgdGlsZWQgYnVmZmVycy4KICoKICogVGhpcyBmdW5jdGlvbiBvdmVyLWNvdW50cyBpZiB0aGUgc2FtZSBidWZmZXIgaXMgdXNlZCBtdWx0aXBsZSB0aW1lcy4KICovCnN0YXRpYyB1bnNpZ25lZCBpbnQKZHJtX2ludGVsX2dlbV90b3RhbF9mZW5jZXMoZHJtX2ludGVsX2JvICoqIGJvX2FycmF5LCBpbnQgY291bnQpCnsKCWludCBpOwoJdW5zaWduZWQgaW50IHRvdGFsID0gMDsKCglmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykgewoJCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvX2FycmF5W2ldOwoKCQlpZiAoYm9fZ2VtID09IE5VTEwpCgkJCWNvbnRpbnVlOwoKCQl0b3RhbCArPSBib19nZW0tPnJlbG9jX3RyZWVfZmVuY2VzOwoJfQoJcmV0dXJuIHRvdGFsOwp9CgovKioKICogQ2xlYXIgdGhlIGZsYWcgc2V0IGJ5IGRybV9pbnRlbF9nZW1fYm9fZ2V0X2FwZXJ0dXJlX3NwYWNlKCkgc28gd2UncmUgcmVhZHkKICogZm9yIHRoZSBuZXh0IGRybV9pbnRlbF9idWZtZ3JfY2hlY2tfYXBlcnR1cmVfc3BhY2UoKSBjYWxsLgogKi8Kc3RhdGljIHZvaWQKZHJtX2ludGVsX2dlbV9ib19jbGVhcl9hcGVydHVyZV9zcGFjZV9mbGFnKGRybV9pbnRlbF9ibyAqYm8pCnsKCWRybV9pbnRlbF9ib19nZW0gKmJvX2dlbSA9IChkcm1faW50ZWxfYm9fZ2VtICopIGJvOwoJaW50IGk7CgoJaWYgKGJvID09IE5VTEwgfHwgIWJvX2dlbS0+aW5jbHVkZWRfaW5fY2hlY2tfYXBlcnR1cmUpCgkJcmV0dXJuOwoKCWJvX2dlbS0+aW5jbHVkZWRfaW5fY2hlY2tfYXBlcnR1cmUgPSBmYWxzZTsKCglmb3IgKGkgPSAwOyBpIDwgYm9fZ2VtLT5yZWxvY19jb3VudDsgaSsrKQoJCWRybV9pbnRlbF9nZW1fYm9fY2xlYXJfYXBlcnR1cmVfc3BhY2VfZmxhZyhib19nZW0tPgoJCQkJCQkJICAgcmVsb2NfdGFyZ2V0X2luZm9baV0uYm8pOwp9CgovKioKICogUmV0dXJuIGEgY29uc2VydmF0aXZlIGVzdGltYXRlIGZvciB0aGUgYW1vdW50IG9mIGFwZXJ0dXJlIHJlcXVpcmVkCiAqIGZvciBhIGNvbGxlY3Rpb24gb2YgYnVmZmVycy4gVGhpcyBtYXkgZG91YmxlLWNvdW50IHNvbWUgYnVmZmVycy4KICovCnN0YXRpYyB1bnNpZ25lZCBpbnQKZHJtX2ludGVsX2dlbV9lc3RpbWF0ZV9iYXRjaF9zcGFjZShkcm1faW50ZWxfYm8gKipib19hcnJheSwgaW50IGNvdW50KQp7CglpbnQgaTsKCXVuc2lnbmVkIGludCB0b3RhbCA9IDA7CgoJZm9yIChpID0gMDsgaSA8IGNvdW50OyBpKyspIHsKCQlkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBib19hcnJheVtpXTsKCQlpZiAoYm9fZ2VtICE9IE5VTEwpCgkJCXRvdGFsICs9IGJvX2dlbS0+cmVsb2NfdHJlZV9zaXplOwoJfQoJcmV0dXJuIHRvdGFsOwp9CgovKioKICogUmV0dXJuIHRoZSBhbW91bnQgb2YgYXBlcnR1cmUgbmVlZGVkIGZvciBhIGNvbGxlY3Rpb24gb2YgYnVmZmVycy4KICogVGhpcyBhdm9pZHMgZG91YmxlIGNvdW50aW5nIGFueSBidWZmZXJzLCBhdCB0aGUgY29zdCBvZiBsb29raW5nCiAqIGF0IGV2ZXJ5IGJ1ZmZlciBpbiB0aGUgc2V0LgogKi8Kc3RhdGljIHVuc2lnbmVkIGludApkcm1faW50ZWxfZ2VtX2NvbXB1dGVfYmF0Y2hfc3BhY2UoZHJtX2ludGVsX2JvICoqYm9fYXJyYXksIGludCBjb3VudCkKewoJaW50IGk7Cgl1bnNpZ25lZCBpbnQgdG90YWwgPSAwOwoKCWZvciAoaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7CgkJdG90YWwgKz0gZHJtX2ludGVsX2dlbV9ib19nZXRfYXBlcnR1cmVfc3BhY2UoYm9fYXJyYXlbaV0pOwoJCS8qIEZvciB0aGUgZmlyc3QgYnVmZmVyIG9iamVjdCBpbiB0aGUgYXJyYXksIHdlIGdldCBhbgoJCSAqIGFjY3VyYXRlIGNvdW50IGJhY2sgZm9yIGl0cyByZWxvY190cmVlIHNpemUgKHNpbmNlIG5vdGhpbmcKCQkgKiBoYWQgYmVlbiBmbGFnZ2VkIGFzIGJlaW5nIGNvdW50ZWQgeWV0KS4gIFdlIGNhbiBzYXZlIHRoYXQKCQkgKiB2YWx1ZSBvdXQgYXMgYSBtb3JlIGNvbnNlcnZhdGl2ZSByZWxvY190cmVlX3NpemUgdGhhdAoJCSAqIGF2b2lkcyBkb3VibGUtY291bnRpbmcgdGFyZ2V0IGJ1ZmZlcnMuICBTaW5jZSB0aGUgZmlyc3QKCQkgKiBidWZmZXIgaGFwcGVucyB0byB1c3VhbGx5IGJlIHRoZSBiYXRjaCBidWZmZXIgaW4gb3VyCgkJICogY2FsbGVycywgdGhpcyBjYW4gcHVsbCB1cyBiYWNrIGZyb20gZG9pbmcgdGhlIHRyZWUKCQkgKiB3YWxrIG9uIGV2ZXJ5IG5ldyBiYXRjaCBlbWl0LgoJCSAqLwoJCWlmIChpID09IDApIHsKCQkJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0KCQkJICAgIChkcm1faW50ZWxfYm9fZ2VtICopIGJvX2FycmF5W2ldOwoJCQlib19nZW0tPnJlbG9jX3RyZWVfc2l6ZSA9IHRvdGFsOwoJCX0KCX0KCglmb3IgKGkgPSAwOyBpIDwgY291bnQ7IGkrKykKCQlkcm1faW50ZWxfZ2VtX2JvX2NsZWFyX2FwZXJ0dXJlX3NwYWNlX2ZsYWcoYm9fYXJyYXlbaV0pOwoJcmV0dXJuIHRvdGFsOwp9CgovKioKICogUmV0dXJuIC0xIGlmIHRoZSBiYXRjaGJ1ZmZlciBzaG91bGQgYmUgZmx1c2hlZCBiZWZvcmUgYXR0ZW1wdGluZyB0bwogKiBlbWl0IHJlbmRlcmluZyByZWZlcmVuY2luZyB0aGUgYnVmZmVycyBwb2ludGVkIHRvIGJ5IGJvX2FycmF5LgogKgogKiBUaGlzIGlzIHJlcXVpcmVkIGJlY2F1c2UgaWYgd2UgdHJ5IHRvIGVtaXQgYSBiYXRjaGJ1ZmZlciB3aXRoIHJlbG9jYXRpb25zCiAqIHRvIGEgdHJlZSBvZiBidWZmZXJzIHRoYXQgd29uJ3Qgc2ltdWx0YW5lb3VzbHkgZml0IGluIHRoZSBhcGVydHVyZSwKICogdGhlIHJlbmRlcmluZyB3aWxsIHJldHVybiBhbiBlcnJvciBhdCBhIHBvaW50IHdoZXJlIHRoZSBzb2Z0d2FyZSBpcyBub3QKICogcHJlcGFyZWQgdG8gcmVjb3ZlciBmcm9tIGl0LgogKgogKiBIb3dldmVyLCB3ZSBhbHNvIHdhbnQgdG8gZW1pdCB0aGUgYmF0Y2hidWZmZXIgc2lnbmlmaWNhbnRseSBiZWZvcmUgd2UgcmVhY2gKICogdGhlIGxpbWl0LCBhcyBhIHNlcmllcyBvZiBiYXRjaGJ1ZmZlcnMgZWFjaCBvZiB3aGljaCByZWZlcmVuY2VzIGJ1ZmZlcnMKICogY292ZXJpbmcgYWxtb3N0IGFsbCBvZiB0aGUgYXBlcnR1cmUgbWVhbnMgdGhhdCBhdCBlYWNoIGVtaXQgd2UgZW5kIHVwCiAqIHdhaXRpbmcgdG8gZXZpY3QgYSBidWZmZXIgZnJvbSB0aGUgbGFzdCByZW5kZXJpbmcsIGFuZCB3ZSBnZXQgc3luY2hyb25vdXMKICogcGVyZm9ybWFuY2UuICBCeSBlbWl0dGluZyBzbWFsbGVyIGJhdGNoYnVmZmVycywgd2UgZWF0IHNvbWUgQ1BVIG92ZXJoZWFkIHRvCiAqIGdldCBiZXR0ZXIgcGFyYWxsZWxpc20uCiAqLwpzdGF0aWMgaW50CmRybV9pbnRlbF9nZW1fY2hlY2tfYXBlcnR1cmVfc3BhY2UoZHJtX2ludGVsX2JvICoqYm9fYXJyYXksIGludCBjb3VudCkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPQoJICAgIChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKSBib19hcnJheVswXS0+YnVmbWdyOwoJdW5zaWduZWQgaW50IHRvdGFsID0gMDsKCXVuc2lnbmVkIGludCB0aHJlc2hvbGQgPSBidWZtZ3JfZ2VtLT5ndHRfc2l6ZSAqIDMgLyA0OwoJaW50IHRvdGFsX2ZlbmNlczsKCgkvKiBDaGVjayBmb3IgZmVuY2UgcmVnIGNvbnN0cmFpbnRzIGlmIG5lY2Vzc2FyeSAqLwoJaWYgKGJ1Zm1ncl9nZW0tPmF2YWlsYWJsZV9mZW5jZXMpIHsKCQl0b3RhbF9mZW5jZXMgPSBkcm1faW50ZWxfZ2VtX3RvdGFsX2ZlbmNlcyhib19hcnJheSwgY291bnQpOwoJCWlmICh0b3RhbF9mZW5jZXMgPiBidWZtZ3JfZ2VtLT5hdmFpbGFibGVfZmVuY2VzKQoJCQlyZXR1cm4gLUVOT1NQQzsKCX0KCgl0b3RhbCA9IGRybV9pbnRlbF9nZW1fZXN0aW1hdGVfYmF0Y2hfc3BhY2UoYm9fYXJyYXksIGNvdW50KTsKCglpZiAodG90YWwgPiB0aHJlc2hvbGQpCgkJdG90YWwgPSBkcm1faW50ZWxfZ2VtX2NvbXB1dGVfYmF0Y2hfc3BhY2UoYm9fYXJyYXksIGNvdW50KTsKCglpZiAodG90YWwgPiB0aHJlc2hvbGQpIHsKCQlEQkcoImNoZWNrX3NwYWNlOiBvdmVyZmxvd2VkIGF2YWlsYWJsZSBhcGVydHVyZSwgIgoJCSAgICAiJWRrYiB2cyAlZGtiXG4iLAoJCSAgICB0b3RhbCAvIDEwMjQsIChpbnQpYnVmbWdyX2dlbS0+Z3R0X3NpemUgLyAxMDI0KTsKCQlyZXR1cm4gLUVOT1NQQzsKCX0gZWxzZSB7CgkJREJHKCJkcm1fY2hlY2tfc3BhY2U6IHRvdGFsICVka2IgdnMgYnVmZ3IgJWRrYlxuIiwgdG90YWwgLyAxMDI0LAoJCSAgICAoaW50KWJ1Zm1ncl9nZW0tPmd0dF9zaXplIC8gMTAyNCk7CgkJcmV0dXJuIDA7Cgl9Cn0KCi8qCiAqIERpc2FibGUgYnVmZmVyIHJldXNlIGZvciBvYmplY3RzIHdoaWNoIGFyZSBzaGFyZWQgd2l0aCB0aGUga2VybmVsCiAqIGFzIHNjYW5vdXQgYnVmZmVycwogKi8Kc3RhdGljIGludApkcm1faW50ZWxfZ2VtX2JvX2Rpc2FibGVfcmV1c2UoZHJtX2ludGVsX2JvICpibykKewoJZHJtX2ludGVsX2JvX2dlbSAqYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgYm87CgoJYm9fZ2VtLT5yZXVzYWJsZSA9IGZhbHNlOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19pc19yZXVzYWJsZShkcm1faW50ZWxfYm8gKmJvKQp7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCglyZXR1cm4gYm9fZ2VtLT5yZXVzYWJsZTsKfQoKc3RhdGljIGludApfZHJtX2ludGVsX2dlbV9ib19yZWZlcmVuY2VzKGRybV9pbnRlbF9ibyAqYm8sIGRybV9pbnRlbF9ibyAqdGFyZ2V0X2JvKQp7Cglkcm1faW50ZWxfYm9fZ2VtICpib19nZW0gPSAoZHJtX2ludGVsX2JvX2dlbSAqKSBibzsKCWludCBpOwoKCWZvciAoaSA9IDA7IGkgPCBib19nZW0tPnJlbG9jX2NvdW50OyBpKyspIHsKCQlpZiAoYm9fZ2VtLT5yZWxvY190YXJnZXRfaW5mb1tpXS5ibyA9PSB0YXJnZXRfYm8pCgkJCXJldHVybiAxOwoJCWlmIChibyA9PSBib19nZW0tPnJlbG9jX3RhcmdldF9pbmZvW2ldLmJvKQoJCQljb250aW51ZTsKCQlpZiAoX2RybV9pbnRlbF9nZW1fYm9fcmVmZXJlbmNlcyhib19nZW0tPnJlbG9jX3RhcmdldF9pbmZvW2ldLmJvLAoJCQkJCQl0YXJnZXRfYm8pKQoJCQlyZXR1cm4gMTsKCX0KCglmb3IgKGkgPSAwOyBpPCBib19nZW0tPnNvZnRwaW5fdGFyZ2V0X2NvdW50OyBpKyspIHsKCQlpZiAoYm9fZ2VtLT5zb2Z0cGluX3RhcmdldFtpXSA9PSB0YXJnZXRfYm8pCgkJCXJldHVybiAxOwoJCWlmIChfZHJtX2ludGVsX2dlbV9ib19yZWZlcmVuY2VzKGJvX2dlbS0+c29mdHBpbl90YXJnZXRbaV0sIHRhcmdldF9ibykpCgkJCXJldHVybiAxOwoJfQoKCXJldHVybiAwOwp9CgovKiogUmV0dXJuIHRydWUgaWYgdGFyZ2V0X2JvIGlzIHJlZmVyZW5jZWQgYnkgYm8ncyByZWxvY2F0aW9uIHRyZWUuICovCnN0YXRpYyBpbnQKZHJtX2ludGVsX2dlbV9ib19yZWZlcmVuY2VzKGRybV9pbnRlbF9ibyAqYm8sIGRybV9pbnRlbF9ibyAqdGFyZ2V0X2JvKQp7Cglkcm1faW50ZWxfYm9fZ2VtICp0YXJnZXRfYm9fZ2VtID0gKGRybV9pbnRlbF9ib19nZW0gKikgdGFyZ2V0X2JvOwoKCWlmIChibyA9PSBOVUxMIHx8IHRhcmdldF9ibyA9PSBOVUxMKQoJCXJldHVybiAwOwoJaWYgKHRhcmdldF9ib19nZW0tPnVzZWRfYXNfcmVsb2NfdGFyZ2V0KQoJCXJldHVybiBfZHJtX2ludGVsX2dlbV9ib19yZWZlcmVuY2VzKGJvLCB0YXJnZXRfYm8pOwoJcmV0dXJuIDA7Cn0KCnN0YXRpYyB2b2lkCmFkZF9idWNrZXQoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0sIGludCBzaXplKQp7Cgl1bnNpZ25lZCBpbnQgaSA9IGJ1Zm1ncl9nZW0tPm51bV9idWNrZXRzOwoKCWFzc2VydChpIDwgQVJSQVlfU0laRShidWZtZ3JfZ2VtLT5jYWNoZV9idWNrZXQpKTsKCglEUk1JTklUTElTVEhFQUQoJmJ1Zm1ncl9nZW0tPmNhY2hlX2J1Y2tldFtpXS5oZWFkKTsKCWJ1Zm1ncl9nZW0tPmNhY2hlX2J1Y2tldFtpXS5zaXplID0gc2l6ZTsKCWJ1Zm1ncl9nZW0tPm51bV9idWNrZXRzKys7Cn0KCnN0YXRpYyB2b2lkCmluaXRfY2FjaGVfYnVja2V0cyhkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSkKewoJdW5zaWduZWQgbG9uZyBzaXplLCBjYWNoZV9tYXhfc2l6ZSA9IDY0ICogMTAyNCAqIDEwMjQ7CgoJLyogT0ssIHNvIHBvd2VyIG9mIHR3byBidWNrZXRzIHdhcyB0b28gd2FzdGVmdWwgb2YgbWVtb3J5LgoJICogR2l2ZSAzIG90aGVyIHNpemVzIGJldHdlZW4gZWFjaCBwb3dlciBvZiB0d28sIHRvIGhvcGVmdWxseQoJICogY292ZXIgdGhpbmdzIGFjY3VyYXRlbHkgZW5vdWdoLiAgKFRoZSBhbHRlcm5hdGl2ZSBpcwoJICogcHJvYmFibHkgdG8ganVzdCBnbyBmb3IgZXhhY3QgbWF0Y2hpbmcgb2Ygc2l6ZXMsIGFuZCBhc3N1bWUKCSAqIHRoYXQgZm9yIHRoaW5ncyBsaWtlIGNvbXBvc2l0ZWQgd2luZG93IHJlc2l6ZSB0aGUgdGlsZWQKCSAqIHdpZHRoL2hlaWdodCBhbGlnbm1lbnQgYW5kIHJvdW5kaW5nIG9mIHNpemVzIHRvIHBhZ2VzIHdpbGwKCSAqIGdldCB1cyB1c2VmdWwgY2FjaGUgaGl0IHJhdGVzIGFueXdheSkKCSAqLwoJYWRkX2J1Y2tldChidWZtZ3JfZ2VtLCA0MDk2KTsKCWFkZF9idWNrZXQoYnVmbWdyX2dlbSwgNDA5NiAqIDIpOwoJYWRkX2J1Y2tldChidWZtZ3JfZ2VtLCA0MDk2ICogMyk7CgoJLyogSW5pdGlhbGl6ZSB0aGUgbGlua2VkIGxpc3RzIGZvciBCTyByZXVzZSBjYWNoZS4gKi8KCWZvciAoc2l6ZSA9IDQgKiA0MDk2OyBzaXplIDw9IGNhY2hlX21heF9zaXplOyBzaXplICo9IDIpIHsKCQlhZGRfYnVja2V0KGJ1Zm1ncl9nZW0sIHNpemUpOwoKCQlhZGRfYnVja2V0KGJ1Zm1ncl9nZW0sIHNpemUgKyBzaXplICogMSAvIDQpOwoJCWFkZF9idWNrZXQoYnVmbWdyX2dlbSwgc2l6ZSArIHNpemUgKiAyIC8gNCk7CgkJYWRkX2J1Y2tldChidWZtZ3JfZ2VtLCBzaXplICsgc2l6ZSAqIDMgLyA0KTsKCX0KfQoKdm9pZApkcm1faW50ZWxfYnVmbWdyX2dlbV9zZXRfdm1hX2NhY2hlX3NpemUoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyLCBpbnQgbGltaXQpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopYnVmbWdyOwoKCWJ1Zm1ncl9nZW0tPnZtYV9tYXggPSBsaW1pdDsKCglkcm1faW50ZWxfZ2VtX2JvX3B1cmdlX3ZtYV9jYWNoZShidWZtZ3JfZ2VtKTsKfQoKLyoqCiAqIEdldCB0aGUgUENJIElEIGZvciB0aGUgZGV2aWNlLiAgVGhpcyBjYW4gYmUgb3ZlcnJpZGRlbiBieSBzZXR0aW5nIHRoZQogKiBJTlRFTF9ERVZJRF9PVkVSUklERSBlbnZpcm9ubWVudCB2YXJpYWJsZSB0byB0aGUgZGVzaXJlZCBJRC4KICovCnN0YXRpYyBpbnQKZ2V0X3BjaV9kZXZpY2VfaWQoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0pCnsKCWNoYXIgKmRldmlkX292ZXJyaWRlOwoJaW50IGRldmlkID0gMDsKCWludCByZXQ7Cglkcm1faTkxNV9nZXRwYXJhbV90IGdwOwoKCWlmIChnZXRldWlkKCkgPT0gZ2V0dWlkKCkpIHsKCQlkZXZpZF9vdmVycmlkZSA9IGdldGVudigiSU5URUxfREVWSURfT1ZFUlJJREUiKTsKCQlpZiAoZGV2aWRfb3ZlcnJpZGUpIHsKCQkJYnVmbWdyX2dlbS0+bm9fZXhlYyA9IHRydWU7CgkJCXJldHVybiBzdHJ0b2QoZGV2aWRfb3ZlcnJpZGUsIE5VTEwpOwoJCX0KCX0KCgltZW1jbGVhcihncCk7CglncC5wYXJhbSA9IEk5MTVfUEFSQU1fQ0hJUFNFVF9JRDsKCWdwLnZhbHVlID0gJmRldmlkOwoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsIERSTV9JT0NUTF9JOTE1X0dFVFBBUkFNLCAmZ3ApOwoJaWYgKHJldCkgewoJCWZwcmludGYoc3RkZXJyLCAiZ2V0IGNoaXAgaWQgZmFpbGVkOiAlZCBbJWRdXG4iLCByZXQsIGVycm5vKTsKCQlmcHJpbnRmKHN0ZGVyciwgInBhcmFtOiAlZCwgdmFsOiAlZFxuIiwgZ3AucGFyYW0sICpncC52YWx1ZSk7Cgl9CglyZXR1cm4gZGV2aWQ7Cn0KCmludApkcm1faW50ZWxfYnVmbWdyX2dlbV9nZXRfZGV2aWQoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKWJ1Zm1ncjsKCglyZXR1cm4gYnVmbWdyX2dlbS0+cGNpX2RldmljZTsKfQoKLyoqCiAqIFNldHMgdGhlIEFVQiBmaWxlbmFtZS4KICoKICogVGhpcyBmdW5jdGlvbiBoYXMgdG8gYmUgY2FsbGVkIGJlZm9yZSBkcm1faW50ZWxfYnVmbWdyX2dlbV9zZXRfYXViX2R1bXAoKQogKiBmb3IgaXQgdG8gaGF2ZSBhbnkgZWZmZWN0LgogKi8Kdm9pZApkcm1faW50ZWxfYnVmbWdyX2dlbV9zZXRfYXViX2ZpbGVuYW1lKGRybV9pbnRlbF9idWZtZ3IgKmJ1Zm1nciwKCQkJCSAgICAgIGNvbnN0IGNoYXIgKmZpbGVuYW1lKQp7Cn0KCi8qKgogKiBTZXRzIHVwIEFVQiBkdW1waW5nLgogKgogKiBUaGlzIGlzIGEgdHJhY2UgZmlsZSBmb3JtYXQgdGhhdCBjYW4gYmUgdXNlZCB3aXRoIHRoZSBzaW11bGF0b3IuCiAqIFBhY2tldHMgYXJlIGVtaXR0ZWQgaW4gYSBmb3JtYXQgc29tZXdoYXQgbGlrZSBHUFUgY29tbWFuZCBwYWNrZXRzLgogKiBZb3UgY2FuIHNldCB1cCBhIEdUVCBhbmQgdXBsb2FkIHlvdXIgb2JqZWN0cyBpbnRvIHRoZSByZWZlcmVuY2VkCiAqIHNwYWNlLCB0aGVuIHNlbmQgb2ZmIGJhdGNoYnVmZmVycyBhbmQgZ2V0IEJNUHMgb3V0IHRoZSBvdGhlciBlbmQuCiAqLwp2b2lkCmRybV9pbnRlbF9idWZtZ3JfZ2VtX3NldF9hdWJfZHVtcChkcm1faW50ZWxfYnVmbWdyICpidWZtZ3IsIGludCBlbmFibGUpCnsKCWZwcmludGYoc3RkZXJyLCAibGliZHJtIGF1YiBkdW1waW5nIGlzIGRlcHJlY2F0ZWQuXG5cbiIKCQkiVXNlIGludGVsX2F1YmR1bXAgZnJvbSBpbnRlbC1ncHUtdG9vbHMgaW5zdGVhZC4gIEluc3RhbGwgaW50ZWwtZ3B1LXRvb2xzLFxuIgoJCSJ0aGVuIHJ1biAoZm9yIGV4YW1wbGUpXG5cbiIKCQkiXHQkIGludGVsX2F1YmR1bXAgLS1vdXRwdXQ9dHJhY2UuYXViIGdseGdlYXJzIC1nZW9tZXRyeSA1MDB4NTAwXG5cbiIKCQkiU2VlIHRoZSBpbnRlbF9hdWJkdW1wIG1hbiBwYWdlIGZvciBtb3JlIGRldGFpbHMuXG4iKTsKfQoKZHJtX2ludGVsX2NvbnRleHQgKgpkcm1faW50ZWxfZ2VtX2NvbnRleHRfY3JlYXRlKGRybV9pbnRlbF9idWZtZ3IgKmJ1Zm1ncikKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW0gPSAoZHJtX2ludGVsX2J1Zm1ncl9nZW0gKilidWZtZ3I7CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2NvbnRleHRfY3JlYXRlIGNyZWF0ZTsKCWRybV9pbnRlbF9jb250ZXh0ICpjb250ZXh0ID0gTlVMTDsKCWludCByZXQ7CgoJY29udGV4dCA9IGNhbGxvYygxLCBzaXplb2YoKmNvbnRleHQpKTsKCWlmICghY29udGV4dCkKCQlyZXR1cm4gTlVMTDsKCgltZW1jbGVhcihjcmVhdGUpOwoJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsIERSTV9JT0NUTF9JOTE1X0dFTV9DT05URVhUX0NSRUFURSwgJmNyZWF0ZSk7CglpZiAocmV0ICE9IDApIHsKCQlEQkcoIkRSTV9JT0NUTF9JOTE1X0dFTV9DT05URVhUX0NSRUFURSBmYWlsZWQ6ICVzXG4iLAoJCSAgICBzdHJlcnJvcihlcnJubykpOwoJCWZyZWUoY29udGV4dCk7CgkJcmV0dXJuIE5VTEw7Cgl9CgoJY29udGV4dC0+Y3R4X2lkID0gY3JlYXRlLmN0eF9pZDsKCWNvbnRleHQtPmJ1Zm1nciA9IGJ1Zm1ncjsKCglyZXR1cm4gY29udGV4dDsKfQoKdm9pZApkcm1faW50ZWxfZ2VtX2NvbnRleHRfZGVzdHJveShkcm1faW50ZWxfY29udGV4dCAqY3R4KQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbTsKCXN0cnVjdCBkcm1faTkxNV9nZW1fY29udGV4dF9kZXN0cm95IGRlc3Ryb3k7CglpbnQgcmV0OwoKCWlmIChjdHggPT0gTlVMTCkKCQlyZXR1cm47CgoJbWVtY2xlYXIoZGVzdHJveSk7CgoJYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKWN0eC0+YnVmbWdyOwoJZGVzdHJveS5jdHhfaWQgPSBjdHgtPmN0eF9pZDsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRU1fQ09OVEVYVF9ERVNUUk9ZLAoJCSAgICAgICAmZGVzdHJveSk7CglpZiAocmV0ICE9IDApCgkJZnByaW50ZihzdGRlcnIsICJEUk1fSU9DVExfSTkxNV9HRU1fQ09OVEVYVF9ERVNUUk9ZIGZhaWxlZDogJXNcbiIsCgkJCXN0cmVycm9yKGVycm5vKSk7CgoJZnJlZShjdHgpOwp9CgppbnQKZHJtX2ludGVsX2dldF9yZXNldF9zdGF0cyhkcm1faW50ZWxfY29udGV4dCAqY3R4LAoJCQkgIHVpbnQzMl90ICpyZXNldF9jb3VudCwKCQkJICB1aW50MzJfdCAqYWN0aXZlLAoJCQkgIHVpbnQzMl90ICpwZW5kaW5nKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbTsKCXN0cnVjdCBkcm1faTkxNV9yZXNldF9zdGF0cyBzdGF0czsKCWludCByZXQ7CgoJaWYgKGN0eCA9PSBOVUxMKQoJCXJldHVybiAtRUlOVkFMOwoKCW1lbWNsZWFyKHN0YXRzKTsKCglidWZtZ3JfZ2VtID0gKGRybV9pbnRlbF9idWZtZ3JfZ2VtICopY3R4LT5idWZtZ3I7CglzdGF0cy5jdHhfaWQgPSBjdHgtPmN0eF9pZDsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLAoJCSAgICAgICBEUk1fSU9DVExfSTkxNV9HRVRfUkVTRVRfU1RBVFMsCgkJICAgICAgICZzdGF0cyk7CglpZiAocmV0ID09IDApIHsKCQlpZiAocmVzZXRfY291bnQgIT0gTlVMTCkKCQkJKnJlc2V0X2NvdW50ID0gc3RhdHMucmVzZXRfY291bnQ7CgoJCWlmIChhY3RpdmUgIT0gTlVMTCkKCQkJKmFjdGl2ZSA9IHN0YXRzLmJhdGNoX2FjdGl2ZTsKCgkJaWYgKHBlbmRpbmcgIT0gTlVMTCkKCQkJKnBlbmRpbmcgPSBzdGF0cy5iYXRjaF9wZW5kaW5nOwoJfQoKCXJldHVybiByZXQ7Cn0KCmludApkcm1faW50ZWxfcmVnX3JlYWQoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyLAoJCSAgIHVpbnQzMl90IG9mZnNldCwKCQkgICB1aW50NjRfdCAqcmVzdWx0KQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKWJ1Zm1ncjsKCXN0cnVjdCBkcm1faTkxNV9yZWdfcmVhZCByZWdfcmVhZDsKCWludCByZXQ7CgoJbWVtY2xlYXIocmVnX3JlYWQpOwoJcmVnX3JlYWQub2Zmc2V0ID0gb2Zmc2V0OwoKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9SRUdfUkVBRCwgJnJlZ19yZWFkKTsKCgkqcmVzdWx0ID0gcmVnX3JlYWQudmFsOwoJcmV0dXJuIHJldDsKfQoKaW50CmRybV9pbnRlbF9nZXRfc3Vic2xpY2VfdG90YWwoaW50IGZkLCB1bnNpZ25lZCBpbnQgKnN1YnNsaWNlX3RvdGFsKQp7Cglkcm1faTkxNV9nZXRwYXJhbV90IGdwOwoJaW50IHJldDsKCgltZW1jbGVhcihncCk7CglncC52YWx1ZSA9IChpbnQqKXN1YnNsaWNlX3RvdGFsOwoJZ3AucGFyYW0gPSBJOTE1X1BBUkFNX1NVQlNMSUNFX1RPVEFMOwoJcmV0ID0gZHJtSW9jdGwoZmQsIERSTV9JT0NUTF9JOTE1X0dFVFBBUkFNLCAmZ3ApOwoJaWYgKHJldCkKCQlyZXR1cm4gLWVycm5vOwoKCXJldHVybiAwOwp9CgppbnQKZHJtX2ludGVsX2dldF9ldV90b3RhbChpbnQgZmQsIHVuc2lnbmVkIGludCAqZXVfdG90YWwpCnsKCWRybV9pOTE1X2dldHBhcmFtX3QgZ3A7CglpbnQgcmV0OwoKCW1lbWNsZWFyKGdwKTsKCWdwLnZhbHVlID0gKGludCopZXVfdG90YWw7CglncC5wYXJhbSA9IEk5MTVfUEFSQU1fRVVfVE9UQUw7CglyZXQgPSBkcm1Jb2N0bChmZCwgRFJNX0lPQ1RMX0k5MTVfR0VUUEFSQU0sICZncCk7CglpZiAocmV0KQoJCXJldHVybiAtZXJybm87CgoJcmV0dXJuIDA7Cn0KCi8qKgogKiBBbm5vdGF0ZSB0aGUgZ2l2ZW4gYm8gZm9yIHVzZSBpbiBhdWIgZHVtcGluZy4KICoKICogXHBhcmFtIGFubm90YXRpb25zIGlzIGFuIGFycmF5IG9mIGRybV9pbnRlbF9hdWJfYW5ub3RhdGlvbiBvYmplY3RzCiAqIGRlc2NyaWJpbmcgdGhlIHR5cGUgb2YgZGF0YSBpbiB2YXJpb3VzIHNlY3Rpb25zIG9mIHRoZSBiby4gIEVhY2gKICogZWxlbWVudCBvZiB0aGUgYXJyYXkgc3BlY2lmaWVzIHRoZSB0eXBlIGFuZCBzdWJ0eXBlIG9mIGEgc2VjdGlvbiBvZgogKiB0aGUgYm8sIGFuZCB0aGUgcGFzdC10aGUtZW5kIG9mZnNldCBvZiB0aGF0IHNlY3Rpb24uICBUaGUgZWxlbWVudHMKICogb2YgXGMgYW5ub3RhdGlvbnMgbXVzdCBiZSBzb3J0ZWQgc28gdGhhdCBlbmRpbmdfb2Zmc2V0IGlzCiAqIGluY3JlYXNpbmcuCiAqCiAqIFxwYXJhbSBjb3VudCBpcyB0aGUgbnVtYmVyIG9mIGVsZW1lbnRzIGluIHRoZSBcYyBhbm5vdGF0aW9ucyBhcnJheS4KICogSWYgXGMgY291bnQgaXMgemVybywgdGhlbiBcYyBhbm5vdGF0aW9ucyB3aWxsIG5vdCBiZSBkZXJlZmVyZW5jZWQuCiAqCiAqIEFubm90YXRpb25zIGFyZSBjb3BpZWQgaW50byBhIHByaXZhdGUgZGF0YSBzdHJ1Y3R1cmUsIHNvIGNhbGxlciBtYXkKICogcmUtdXNlIHRoZSBtZW1vcnkgcG9pbnRlZCB0byBieSBcYyBhbm5vdGF0aW9ucyBhZnRlciB0aGUgY2FsbAogKiByZXR1cm5zLgogKgogKiBBbm5vdGF0aW9ucyBhcmUgc3RvcmVkIGZvciB0aGUgbGlmZXRpbWUgb2YgdGhlIGJvOyB0byByZXNldCB0byB0aGUKICogZGVmYXVsdCBzdGF0ZSAobm8gYW5ub3RhdGlvbnMpLCBjYWxsIHRoaXMgZnVuY3Rpb24gd2l0aCBhIFxjIGNvdW50CiAqIG9mIHplcm8uCiAqLwp2b2lkCmRybV9pbnRlbF9idWZtZ3JfZ2VtX3NldF9hdWJfYW5ub3RhdGlvbnMoZHJtX2ludGVsX2JvICpibywKCQkJCQkgZHJtX2ludGVsX2F1Yl9hbm5vdGF0aW9uICphbm5vdGF0aW9ucywKCQkJCQkgdW5zaWduZWQgY291bnQpCnsKfQoKc3RhdGljIHB0aHJlYWRfbXV0ZXhfdCBidWZtZ3JfbGlzdF9tdXRleCA9IFBUSFJFQURfTVVURVhfSU5JVElBTElaRVI7CnN0YXRpYyBkcm1NTUxpc3RIZWFkIGJ1Zm1ncl9saXN0ID0geyAmYnVmbWdyX2xpc3QsICZidWZtZ3JfbGlzdCB9OwoKc3RhdGljIGRybV9pbnRlbF9idWZtZ3JfZ2VtICoKZHJtX2ludGVsX2J1Zm1ncl9nZW1fZmluZChpbnQgZmQpCnsKCWRybV9pbnRlbF9idWZtZ3JfZ2VtICpidWZtZ3JfZ2VtOwoKCURSTUxJU1RGT1JFQUNIRU5UUlkoYnVmbWdyX2dlbSwgJmJ1Zm1ncl9saXN0LCBtYW5hZ2VycykgewoJCWlmIChidWZtZ3JfZ2VtLT5mZCA9PSBmZCkgewoJCQlhdG9taWNfaW5jKCZidWZtZ3JfZ2VtLT5yZWZjb3VudCk7CgkJCXJldHVybiBidWZtZ3JfZ2VtOwoJCX0KCX0KCglyZXR1cm4gTlVMTDsKfQoKc3RhdGljIHZvaWQKZHJtX2ludGVsX2J1Zm1ncl9nZW1fdW5yZWYoZHJtX2ludGVsX2J1Zm1nciAqYnVmbWdyKQp7Cglkcm1faW50ZWxfYnVmbWdyX2dlbSAqYnVmbWdyX2dlbSA9IChkcm1faW50ZWxfYnVmbWdyX2dlbSAqKWJ1Zm1ncjsKCglpZiAoYXRvbWljX2FkZF91bmxlc3MoJmJ1Zm1ncl9nZW0tPnJlZmNvdW50LCAtMSwgMSkpIHsKCQlwdGhyZWFkX211dGV4X2xvY2soJmJ1Zm1ncl9saXN0X211dGV4KTsKCgkJaWYgKGF0b21pY19kZWNfYW5kX3Rlc3QoJmJ1Zm1ncl9nZW0tPnJlZmNvdW50KSkgewoJCQlEUk1MSVNUREVMKCZidWZtZ3JfZ2VtLT5tYW5hZ2Vycyk7CgkJCWRybV9pbnRlbF9idWZtZ3JfZ2VtX2Rlc3Ryb3koYnVmbWdyKTsKCQl9CgoJCXB0aHJlYWRfbXV0ZXhfdW5sb2NrKCZidWZtZ3JfbGlzdF9tdXRleCk7Cgl9Cn0KCi8qKgogKiBJbml0aWFsaXplcyB0aGUgR0VNIGJ1ZmZlciBtYW5hZ2VyLCB3aGljaCB1c2VzIHRoZSBrZXJuZWwgdG8gYWxsb2NhdGUsIG1hcCwKICogYW5kIG1hbmFnZSBtYXAgYnVmZmVyIG9iamVjdGlvbnMuCiAqCiAqIFxwYXJhbSBmZCBGaWxlIGRlc2NyaXB0b3Igb2YgdGhlIG9wZW5lZCBEUk0gZGV2aWNlLgogKi8KZHJtX2ludGVsX2J1Zm1nciAqCmRybV9pbnRlbF9idWZtZ3JfZ2VtX2luaXQoaW50IGZkLCBpbnQgYmF0Y2hfc2l6ZSkKewoJZHJtX2ludGVsX2J1Zm1ncl9nZW0gKmJ1Zm1ncl9nZW07CglzdHJ1Y3QgZHJtX2k5MTVfZ2VtX2dldF9hcGVydHVyZSBhcGVydHVyZTsKCWRybV9pOTE1X2dldHBhcmFtX3QgZ3A7CglpbnQgcmV0LCB0bXA7Cglib29sIGV4ZWMyID0gZmFsc2U7CgoJcHRocmVhZF9tdXRleF9sb2NrKCZidWZtZ3JfbGlzdF9tdXRleCk7CgoJYnVmbWdyX2dlbSA9IGRybV9pbnRlbF9idWZtZ3JfZ2VtX2ZpbmQoZmQpOwoJaWYgKGJ1Zm1ncl9nZW0pCgkJZ290byBleGl0OwoKCWJ1Zm1ncl9nZW0gPSBjYWxsb2MoMSwgc2l6ZW9mKCpidWZtZ3JfZ2VtKSk7CglpZiAoYnVmbWdyX2dlbSA9PSBOVUxMKQoJCWdvdG8gZXhpdDsKCglidWZtZ3JfZ2VtLT5mZCA9IGZkOwoJYXRvbWljX3NldCgmYnVmbWdyX2dlbS0+cmVmY291bnQsIDEpOwoKCWlmIChwdGhyZWFkX211dGV4X2luaXQoJmJ1Zm1ncl9nZW0tPmxvY2ssIE5VTEwpICE9IDApIHsKCQlmcmVlKGJ1Zm1ncl9nZW0pOwoJCWJ1Zm1ncl9nZW0gPSBOVUxMOwoJCWdvdG8gZXhpdDsKCX0KCgltZW1jbGVhcihhcGVydHVyZSk7CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwKCQkgICAgICAgRFJNX0lPQ1RMX0k5MTVfR0VNX0dFVF9BUEVSVFVSRSwKCQkgICAgICAgJmFwZXJ0dXJlKTsKCglpZiAocmV0ID09IDApCgkJYnVmbWdyX2dlbS0+Z3R0X3NpemUgPSBhcGVydHVyZS5hcGVyX2F2YWlsYWJsZV9zaXplOwoJZWxzZSB7CgkJZnByaW50ZihzdGRlcnIsICJEUk1fSU9DVExfSTkxNV9HRU1fQVBFUlRVUkUgZmFpbGVkOiAlc1xuIiwKCQkJc3RyZXJyb3IoZXJybm8pKTsKCQlidWZtZ3JfZ2VtLT5ndHRfc2l6ZSA9IDEyOCAqIDEwMjQgKiAxMDI0OwoJCWZwcmludGYoc3RkZXJyLCAiQXNzdW1pbmcgJWRrQiBhdmFpbGFibGUgYXBlcnR1cmUgc2l6ZS5cbiIKCQkJIk1heSBsZWFkIHRvIHJlZHVjZWQgcGVyZm9ybWFuY2Ugb3IgaW5jb3JyZWN0ICIKCQkJInJlbmRlcmluZy5cbiIsCgkJCShpbnQpYnVmbWdyX2dlbS0+Z3R0X3NpemUgLyAxMDI0KTsKCX0KCglidWZtZ3JfZ2VtLT5wY2lfZGV2aWNlID0gZ2V0X3BjaV9kZXZpY2VfaWQoYnVmbWdyX2dlbSk7CgoJaWYgKElTX0dFTjIoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gMjsKCWVsc2UgaWYgKElTX0dFTjMoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gMzsKCWVsc2UgaWYgKElTX0dFTjQoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gNDsKCWVsc2UgaWYgKElTX0dFTjUoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gNTsKCWVsc2UgaWYgKElTX0dFTjYoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gNjsKCWVsc2UgaWYgKElTX0dFTjcoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gNzsKCWVsc2UgaWYgKElTX0dFTjgoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gODsKCWVsc2UgaWYgKElTX0dFTjkoYnVmbWdyX2dlbS0+cGNpX2RldmljZSkpCgkJYnVmbWdyX2dlbS0+Z2VuID0gOTsKCWVsc2UgewoJCWZyZWUoYnVmbWdyX2dlbSk7CgkJYnVmbWdyX2dlbSA9IE5VTEw7CgkJZ290byBleGl0OwoJfQoKCWlmIChJU19HRU4zKGJ1Zm1ncl9nZW0tPnBjaV9kZXZpY2UpICYmCgkgICAgYnVmbWdyX2dlbS0+Z3R0X3NpemUgPiAyNTYqMTAyNCoxMDI0KSB7CgkJLyogVGhlIHVubWFwcGFibGUgcGFydCBvZiBndHQgb24gZ2VuIDMgKGkuZS4gYWJvdmUgMjU2TUIpIGNhbid0CgkJICogYmUgdXNlZCBmb3IgdGlsZWQgYmxpdHMuIFRvIHNpbXBsaWZ5IHRoZSBhY2NvdW50aW5nLCBqdXN0CgkJICogc3VidHJhY3QgdGhlIHVubWFwcGFibGUgcGFydCAoZml4ZWQgdG8gMjU2TUIgb24gYWxsIGtub3duCgkJICogZ2VuMyBkZXZpY2VzKSBpZiB0aGUga2VybmVsIGFkdmVydGlzZXMgaXQuICovCgkJYnVmbWdyX2dlbS0+Z3R0X3NpemUgLT0gMjU2KjEwMjQqMTAyNDsKCX0KCgltZW1jbGVhcihncCk7CglncC52YWx1ZSA9ICZ0bXA7CgoJZ3AucGFyYW0gPSBJOTE1X1BBUkFNX0hBU19FWEVDQlVGMjsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRVRQQVJBTSwgJmdwKTsKCWlmICghcmV0KQoJCWV4ZWMyID0gdHJ1ZTsKCglncC5wYXJhbSA9IEk5MTVfUEFSQU1fSEFTX0JTRDsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRVRQQVJBTSwgJmdwKTsKCWJ1Zm1ncl9nZW0tPmhhc19ic2QgPSByZXQgPT0gMDsKCglncC5wYXJhbSA9IEk5MTVfUEFSQU1fSEFTX0JMVDsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRVRQQVJBTSwgJmdwKTsKCWJ1Zm1ncl9nZW0tPmhhc19ibHQgPSByZXQgPT0gMDsKCglncC5wYXJhbSA9IEk5MTVfUEFSQU1fSEFTX1JFTEFYRURfRkVOQ0lORzsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRVRQQVJBTSwgJmdwKTsKCWJ1Zm1ncl9nZW0tPmhhc19yZWxheGVkX2ZlbmNpbmcgPSByZXQgPT0gMDsKCglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fYWxsb2NfdXNlcnB0ciA9IGNoZWNrX2JvX2FsbG9jX3VzZXJwdHI7CgoJZ3AucGFyYW0gPSBJOTE1X1BBUkFNX0hBU19XQUlUX1RJTUVPVVQ7CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwgRFJNX0lPQ1RMX0k5MTVfR0VUUEFSQU0sICZncCk7CglidWZtZ3JfZ2VtLT5oYXNfd2FpdF90aW1lb3V0ID0gcmV0ID09IDA7CgoJZ3AucGFyYW0gPSBJOTE1X1BBUkFNX0hBU19MTEM7CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwgRFJNX0lPQ1RMX0k5MTVfR0VUUEFSQU0sICZncCk7CglpZiAocmV0ICE9IDApIHsKCQkvKiBLZXJuZWwgZG9lcyBub3Qgc3VwcG9ydHMgSEFTX0xMQyBxdWVyeSwgZmFsbGJhY2sgdG8gR1BVCgkJICogZ2VuZXJhdGlvbiBkZXRlY3Rpb24gYW5kIGFzc3VtZSB0aGF0IHdlIGhhdmUgTExDIG9uIEdFTjYvNwoJCSAqLwoJCWJ1Zm1ncl9nZW0tPmhhc19sbGMgPSAoSVNfR0VONihidWZtZ3JfZ2VtLT5wY2lfZGV2aWNlKSB8CgkJCQlJU19HRU43KGJ1Zm1ncl9nZW0tPnBjaV9kZXZpY2UpKTsKCX0gZWxzZQoJCWJ1Zm1ncl9nZW0tPmhhc19sbGMgPSAqZ3AudmFsdWU7CgoJZ3AucGFyYW0gPSBJOTE1X1BBUkFNX0hBU19WRUJPWDsKCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRVRQQVJBTSwgJmdwKTsKCWJ1Zm1ncl9nZW0tPmhhc192ZWJveCA9IChyZXQgPT0gMCkgJiAoKmdwLnZhbHVlID4gMCk7CgoJZ3AucGFyYW0gPSBJOTE1X1BBUkFNX0hBU19FWEVDX1NPRlRQSU47CglyZXQgPSBkcm1Jb2N0bChidWZtZ3JfZ2VtLT5mZCwgRFJNX0lPQ1RMX0k5MTVfR0VUUEFSQU0sICZncCk7CglpZiAocmV0ID09IDAgJiYgKmdwLnZhbHVlID4gMCkKCQlidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fc2V0X3NvZnRwaW5fb2Zmc2V0ID0gZHJtX2ludGVsX2dlbV9ib19zZXRfc29mdHBpbl9vZmZzZXQ7CgoJaWYgKGJ1Zm1ncl9nZW0tPmdlbiA8IDQpIHsKCQlncC5wYXJhbSA9IEk5MTVfUEFSQU1fTlVNX0ZFTkNFU19BVkFJTDsKCQlncC52YWx1ZSA9ICZidWZtZ3JfZ2VtLT5hdmFpbGFibGVfZmVuY2VzOwoJCXJldCA9IGRybUlvY3RsKGJ1Zm1ncl9nZW0tPmZkLCBEUk1fSU9DVExfSTkxNV9HRVRQQVJBTSwgJmdwKTsKCQlpZiAocmV0KSB7CgkJCWZwcmludGYoc3RkZXJyLCAiZ2V0IGZlbmNlcyBmYWlsZWQ6ICVkIFslZF1cbiIsIHJldCwKCQkJCWVycm5vKTsKCQkJZnByaW50ZihzdGRlcnIsICJwYXJhbTogJWQsIHZhbDogJWRcbiIsIGdwLnBhcmFtLAoJCQkJKmdwLnZhbHVlKTsKCQkJYnVmbWdyX2dlbS0+YXZhaWxhYmxlX2ZlbmNlcyA9IDA7CgkJfSBlbHNlIHsKCQkJLyogWFhYIFRoZSBrZXJuZWwgcmVwb3J0cyB0aGUgdG90YWwgbnVtYmVyIG9mIGZlbmNlcywKCQkJICogaW5jbHVkaW5nIGFueSB0aGF0IG1heSBiZSBwaW5uZWQuCgkJCSAqCgkJCSAqIFdlIHByZXN1bWUgdGhhdCB0aGVyZSB3aWxsIGJlIGF0IGxlYXN0IG9uZSBwaW5uZWQKCQkJICogZmVuY2UgZm9yIHRoZSBzY2Fub3V0IGJ1ZmZlciwgYnV0IHRoZXJlIG1heSBiZSBtb3JlCgkJCSAqIHRoYW4gb25lIHNjYW5vdXQgYW5kIHRoZSB1c2VyIG1heSBiZSBtYW51YWxseQoJCQkgKiBwaW5uaW5nIGJ1ZmZlcnMuIExldCdzIG1vdmUgdG8gZXhlY2J1ZmZlcjIgYW5kCgkJCSAqIHRoZXJlYnkgZm9yZ2V0IHRoZSBpbnNhbml0eSBvZiB1c2luZyBmZW5jZXMuLi4KCQkJICovCgkJCWJ1Zm1ncl9nZW0tPmF2YWlsYWJsZV9mZW5jZXMgLT0gMjsKCQkJaWYgKGJ1Zm1ncl9nZW0tPmF2YWlsYWJsZV9mZW5jZXMgPCAwKQoJCQkJYnVmbWdyX2dlbS0+YXZhaWxhYmxlX2ZlbmNlcyA9IDA7CgkJfQoJfQoKCWlmIChidWZtZ3JfZ2VtLT5nZW4gPj0gOCkgewoJCWdwLnBhcmFtID0gSTkxNV9QQVJBTV9IQVNfQUxJQVNJTkdfUFBHVFQ7CgkJcmV0ID0gZHJtSW9jdGwoYnVmbWdyX2dlbS0+ZmQsIERSTV9JT0NUTF9JOTE1X0dFVFBBUkFNLCAmZ3ApOwoJCWlmIChyZXQgPT0gMCAmJiAqZ3AudmFsdWUgPT0gMykKCQkJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX3VzZV80OGJfYWRkcmVzc19yYW5nZSA9IGRybV9pbnRlbF9nZW1fYm9fdXNlXzQ4Yl9hZGRyZXNzX3JhbmdlOwoJfQoKCS8qIExldCdzIGdvIHdpdGggb25lIHJlbG9jYXRpb24gcGVyIGV2ZXJ5IDIgZHdvcmRzIChidXQgcm91bmQgZG93biBhIGJpdAoJICogc2luY2UgYSBwb3dlciBvZiB0d28gd2lsbCBtZWFuIGFuIGV4dHJhIHBhZ2UgYWxsb2NhdGlvbiBmb3IgdGhlIHJlbG9jCgkgKiBidWZmZXIpLgoJICoKCSAqIEV2ZXJ5IDQgd2FzIHRvbyBmZXcgZm9yIHRoZSBibGVuZGVyIGJlbmNobWFyay4KCSAqLwoJYnVmbWdyX2dlbS0+bWF4X3JlbG9jcyA9IGJhdGNoX3NpemUgLyBzaXplb2YodWludDMyX3QpIC8gMiAtIDI7CgoJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX2FsbG9jID0gZHJtX2ludGVsX2dlbV9ib19hbGxvYzsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19hbGxvY19mb3JfcmVuZGVyID0KCSAgICBkcm1faW50ZWxfZ2VtX2JvX2FsbG9jX2Zvcl9yZW5kZXI7CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fYWxsb2NfdGlsZWQgPSBkcm1faW50ZWxfZ2VtX2JvX2FsbG9jX3RpbGVkOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX3JlZmVyZW5jZSA9IGRybV9pbnRlbF9nZW1fYm9fcmVmZXJlbmNlOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX3VucmVmZXJlbmNlID0gZHJtX2ludGVsX2dlbV9ib191bnJlZmVyZW5jZTsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19tYXAgPSBkcm1faW50ZWxfZ2VtX2JvX21hcDsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib191bm1hcCA9IGRybV9pbnRlbF9nZW1fYm9fdW5tYXA7CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fc3ViZGF0YSA9IGRybV9pbnRlbF9nZW1fYm9fc3ViZGF0YTsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19nZXRfc3ViZGF0YSA9IGRybV9pbnRlbF9nZW1fYm9fZ2V0X3N1YmRhdGE7CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fd2FpdF9yZW5kZXJpbmcgPSBkcm1faW50ZWxfZ2VtX2JvX3dhaXRfcmVuZGVyaW5nOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX2VtaXRfcmVsb2MgPSBkcm1faW50ZWxfZ2VtX2JvX2VtaXRfcmVsb2M7CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fZW1pdF9yZWxvY19mZW5jZSA9IGRybV9pbnRlbF9nZW1fYm9fZW1pdF9yZWxvY19mZW5jZTsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19waW4gPSBkcm1faW50ZWxfZ2VtX2JvX3BpbjsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib191bnBpbiA9IGRybV9pbnRlbF9nZW1fYm9fdW5waW47CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fZ2V0X3RpbGluZyA9IGRybV9pbnRlbF9nZW1fYm9fZ2V0X3RpbGluZzsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19zZXRfdGlsaW5nID0gZHJtX2ludGVsX2dlbV9ib19zZXRfdGlsaW5nOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX2ZsaW5rID0gZHJtX2ludGVsX2dlbV9ib19mbGluazsKCS8qIFVzZSB0aGUgbmV3IG9uZSBpZiBhdmFpbGFibGUgKi8KCWlmIChleGVjMikgewoJCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19leGVjID0gZHJtX2ludGVsX2dlbV9ib19leGVjMjsKCQlidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fbXJiX2V4ZWMgPSBkcm1faW50ZWxfZ2VtX2JvX21yYl9leGVjMjsKCX0gZWxzZQoJCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5ib19leGVjID0gZHJtX2ludGVsX2dlbV9ib19leGVjOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX2J1c3kgPSBkcm1faW50ZWxfZ2VtX2JvX2J1c3k7CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fbWFkdmlzZSA9IGRybV9pbnRlbF9nZW1fYm9fbWFkdmlzZTsKCWJ1Zm1ncl9nZW0tPmJ1Zm1nci5kZXN0cm95ID0gZHJtX2ludGVsX2J1Zm1ncl9nZW1fdW5yZWY7CglidWZtZ3JfZ2VtLT5idWZtZ3IuZGVidWcgPSAwOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmNoZWNrX2FwZXJ0dXJlX3NwYWNlID0KCSAgICBkcm1faW50ZWxfZ2VtX2NoZWNrX2FwZXJ0dXJlX3NwYWNlOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmJvX2Rpc2FibGVfcmV1c2UgPSBkcm1faW50ZWxfZ2VtX2JvX2Rpc2FibGVfcmV1c2U7CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9faXNfcmV1c2FibGUgPSBkcm1faW50ZWxfZ2VtX2JvX2lzX3JldXNhYmxlOwoJYnVmbWdyX2dlbS0+YnVmbWdyLmdldF9waXBlX2Zyb21fY3J0Y19pZCA9CgkgICAgZHJtX2ludGVsX2dlbV9nZXRfcGlwZV9mcm9tX2NydGNfaWQ7CglidWZtZ3JfZ2VtLT5idWZtZ3IuYm9fcmVmZXJlbmNlcyA9IGRybV9pbnRlbF9nZW1fYm9fcmVmZXJlbmNlczsKCglEUk1JTklUTElTVEhFQUQoJmJ1Zm1ncl9nZW0tPm5hbWVkKTsKCWluaXRfY2FjaGVfYnVja2V0cyhidWZtZ3JfZ2VtKTsKCglEUk1JTklUTElTVEhFQUQoJmJ1Zm1ncl9nZW0tPnZtYV9jYWNoZSk7CglidWZtZ3JfZ2VtLT52bWFfbWF4ID0gLTE7IC8qIHVubGltaXRlZCBieSBkZWZhdWx0ICovCgoJRFJNTElTVEFERCgmYnVmbWdyX2dlbS0+bWFuYWdlcnMsICZidWZtZ3JfbGlzdCk7CgpleGl0OgoJcHRocmVhZF9tdXRleF91bmxvY2soJmJ1Zm1ncl9saXN0X211dGV4KTsKCglyZXR1cm4gYnVmbWdyX2dlbSAhPSBOVUxMID8gJmJ1Zm1ncl9nZW0tPmJ1Zm1nciA6IE5VTEw7Cn0K