LyoKICogIGxpbnV4L2FyY2gvYXJtL3BsYXQtb21hcC9ncGlvLmMKICoKICogU3VwcG9ydCBmdW5jdGlvbnMgZm9yIE9NQVAgR1BJTwogKgogKiBDb3B5cmlnaHQgKEMpIDIwMDMtMjAwNSBOb2tpYSBDb3Jwb3JhdGlvbgogKiBXcml0dGVuIGJ5IEp1aGEgWXJq9mzkIDxqdWhhLnlyam9sYUBub2tpYS5jb20+CiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCiAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgogKi8KCiNpbmNsdWRlIDxsaW51eC9jb25maWcuaD4KI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KI2luY2x1ZGUgPGxpbnV4L21vZHVsZS5oPgojaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvcHRyYWNlLmg+CiNpbmNsdWRlIDxsaW51eC9zeXNkZXYuaD4KI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgojaW5jbHVkZSA8bGludXgvY2xrLmg+CgojaW5jbHVkZSA8YXNtL2hhcmR3YXJlLmg+CiNpbmNsdWRlIDxhc20vaXJxLmg+CiNpbmNsdWRlIDxhc20vYXJjaC9pcnFzLmg+CiNpbmNsdWRlIDxhc20vYXJjaC9ncGlvLmg+CiNpbmNsdWRlIDxhc20vbWFjaC9pcnEuaD4KCiNpbmNsdWRlIDxhc20vaW8uaD4KCi8qCiAqIE9NQVAxNTEwIEdQSU8gcmVnaXN0ZXJzCiAqLwojZGVmaW5lIE9NQVAxNTEwX0dQSU9fQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmY2UwMDAKI2RlZmluZSBPTUFQMTUxMF9HUElPX0RBVEFfSU5QVVQJMHgwMAojZGVmaW5lIE9NQVAxNTEwX0dQSU9fREFUQV9PVVRQVVQJMHgwNAojZGVmaW5lIE9NQVAxNTEwX0dQSU9fRElSX0NPTlRST0wJMHgwOAojZGVmaW5lIE9NQVAxNTEwX0dQSU9fSU5UX0NPTlRST0wJMHgwYwojZGVmaW5lIE9NQVAxNTEwX0dQSU9fSU5UX01BU0sJCTB4MTAKI2RlZmluZSBPTUFQMTUxMF9HUElPX0lOVF9TVEFUVVMJMHgxNAojZGVmaW5lIE9NQVAxNTEwX0dQSU9fUElOX0NPTlRST0wJMHgxOAoKI2RlZmluZSBPTUFQMTUxMF9JSF9HUElPX0JBU0UJCTY0CgovKgogKiBPTUFQMTYxMCBzcGVjaWZpYyBHUElPIHJlZ2lzdGVycwogKi8KI2RlZmluZSBPTUFQMTYxMF9HUElPMV9CQVNFCQkodm9pZCBfX2lvbWVtICopMHhmZmZiZTQwMAojZGVmaW5lIE9NQVAxNjEwX0dQSU8yX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweGZmZmJlYzAwCiNkZWZpbmUgT01BUDE2MTBfR1BJTzNfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmYmI0MDAKI2RlZmluZSBPTUFQMTYxMF9HUElPNF9CQVNFCQkodm9pZCBfX2lvbWVtICopMHhmZmZiYmMwMAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fUkVWSVNJT04JCTB4MDAwMAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fU1lTQ09ORklHCQkweDAwMTAKI2RlZmluZSBPTUFQMTYxMF9HUElPX1NZU1NUQVRVUwkJMHgwMDE0CiNkZWZpbmUgT01BUDE2MTBfR1BJT19JUlFTVEFUVVMxCTB4MDAxOAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fSVJRRU5BQkxFMQkweDAwMWMKI2RlZmluZSBPTUFQMTYxMF9HUElPX1dBS0VVUEVOQUJMRQkweDAwMjgKI2RlZmluZSBPTUFQMTYxMF9HUElPX0RBVEFJTgkJMHgwMDJjCiNkZWZpbmUgT01BUDE2MTBfR1BJT19EQVRBT1VUCQkweDAwMzAKI2RlZmluZSBPTUFQMTYxMF9HUElPX0RJUkVDVElPTgkJMHgwMDM0CiNkZWZpbmUgT01BUDE2MTBfR1BJT19FREdFX0NUUkwxCTB4MDAzOAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fRURHRV9DVFJMMgkweDAwM2MKI2RlZmluZSBPTUFQMTYxMF9HUElPX0NMRUFSX0lSUUVOQUJMRTEJMHgwMDljCiNkZWZpbmUgT01BUDE2MTBfR1BJT19DTEVBUl9XQUtFVVBFTkEJMHgwMGE4CiNkZWZpbmUgT01BUDE2MTBfR1BJT19DTEVBUl9EQVRBT1VUCTB4MDBiMAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fU0VUX0lSUUVOQUJMRTEJMHgwMGRjCiNkZWZpbmUgT01BUDE2MTBfR1BJT19TRVRfV0FLRVVQRU5BCTB4MDBlOAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fU0VUX0RBVEFPVVQJMHgwMGYwCgovKgogKiBPTUFQNzMwIHNwZWNpZmljIEdQSU8gcmVnaXN0ZXJzCiAqLwojZGVmaW5lIE9NQVA3MzBfR1BJTzFfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmYmMwMDAKI2RlZmluZSBPTUFQNzMwX0dQSU8yX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweGZmZmJjODAwCiNkZWZpbmUgT01BUDczMF9HUElPM19CQVNFCQkodm9pZCBfX2lvbWVtICopMHhmZmZiZDAwMAojZGVmaW5lIE9NQVA3MzBfR1BJTzRfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmYmQ4MDAKI2RlZmluZSBPTUFQNzMwX0dQSU81X0JBU0UJCSh2b2lkIF9faW9tZW0gKikweGZmZmJlMDAwCiNkZWZpbmUgT01BUDczMF9HUElPNl9CQVNFCQkodm9pZCBfX2lvbWVtICopMHhmZmZiZTgwMAojZGVmaW5lIE9NQVA3MzBfR1BJT19EQVRBX0lOUFVUCQkweDAwCiNkZWZpbmUgT01BUDczMF9HUElPX0RBVEFfT1VUUFVUCTB4MDQKI2RlZmluZSBPTUFQNzMwX0dQSU9fRElSX0NPTlRST0wJMHgwOAojZGVmaW5lIE9NQVA3MzBfR1BJT19JTlRfQ09OVFJPTAkweDBjCiNkZWZpbmUgT01BUDczMF9HUElPX0lOVF9NQVNLCQkweDEwCiNkZWZpbmUgT01BUDczMF9HUElPX0lOVF9TVEFUVVMJCTB4MTQKCi8qCiAqIG9tYXAyNHh4IHNwZWNpZmljIEdQSU8gcmVnaXN0ZXJzCiAqLwojZGVmaW5lIE9NQVAyNFhYX0dQSU8xX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweDQ4MDE4MDAwCiNkZWZpbmUgT01BUDI0WFhfR1BJTzJfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4NDgwMWEwMDAKI2RlZmluZSBPTUFQMjRYWF9HUElPM19CQVNFCQkodm9pZCBfX2lvbWVtICopMHg0ODAxYzAwMAojZGVmaW5lIE9NQVAyNFhYX0dQSU80X0JBU0UJCSh2b2lkIF9faW9tZW0gKikweDQ4MDFlMDAwCiNkZWZpbmUgT01BUDI0WFhfR1BJT19SRVZJU0lPTgkJMHgwMDAwCiNkZWZpbmUgT01BUDI0WFhfR1BJT19TWVNDT05GSUcJCTB4MDAxMAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fU1lTU1RBVFVTCQkweDAwMTQKI2RlZmluZSBPTUFQMjRYWF9HUElPX0lSUVNUQVRVUzEJMHgwMDE4CiNkZWZpbmUgT01BUDI0WFhfR1BJT19JUlFFTkFCTEUxCTB4MDAxYwojZGVmaW5lIE9NQVAyNFhYX0dQSU9fQ1RSTAkJMHgwMDMwCiNkZWZpbmUgT01BUDI0WFhfR1BJT19PRQkJMHgwMDM0CiNkZWZpbmUgT01BUDI0WFhfR1BJT19EQVRBSU4JCTB4MDAzOAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fREFUQU9VVAkJMHgwMDNjCiNkZWZpbmUgT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDAJMHgwMDQwCiNkZWZpbmUgT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDEJMHgwMDQ0CiNkZWZpbmUgT01BUDI0WFhfR1BJT19SSVNJTkdERVRFQ1QJMHgwMDQ4CiNkZWZpbmUgT01BUDI0WFhfR1BJT19GQUxMSU5HREVURUNUCTB4MDA0YwojZGVmaW5lIE9NQVAyNFhYX0dQSU9fQ0xFQVJJUlFFTkFCTEUxCTB4MDA2MAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fU0VUSVJRRU5BQkxFMQkweDAwNjQKI2RlZmluZSBPTUFQMjRYWF9HUElPX0NMRUFSV0tVRU5BCTB4MDA4MAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fU0VUV0tVRU5BCQkweDAwODQKI2RlZmluZSBPTUFQMjRYWF9HUElPX0NMRUFSREFUQU9VVAkweDAwOTAKI2RlZmluZSBPTUFQMjRYWF9HUElPX1NFVERBVEFPVVQJMHgwMDk0CgojZGVmaW5lIE9NQVBfTVBVSU9fTUFTSwkJKH5PTUFQX01BWF9HUElPX0xJTkVTICYgMHhmZikKCnN0cnVjdCBncGlvX2JhbmsgewoJdm9pZCBfX2lvbWVtICpiYXNlOwoJdTE2IGlycTsKCXUxNiB2aXJ0dWFsX2lycV9zdGFydDsKCWludCBtZXRob2Q7Cgl1MzIgcmVzZXJ2ZWRfbWFwOwoJdTMyIHN1c3BlbmRfd2FrZXVwOwoJdTMyIHNhdmVkX3dha2V1cDsKCXNwaW5sb2NrX3QgbG9jazsKfTsKCiNkZWZpbmUgTUVUSE9EX01QVUlPCQkwCiNkZWZpbmUgTUVUSE9EX0dQSU9fMTUxMAkxCiNkZWZpbmUgTUVUSE9EX0dQSU9fMTYxMAkyCiNkZWZpbmUgTUVUSE9EX0dQSU9fNzMwCQkzCiNkZWZpbmUgTUVUSE9EX0dQSU9fMjRYWAk0CgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE2WFgKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgZ3Bpb19iYW5rXzE2MTBbNV0gPSB7Cgl7IE9NQVBfTVBVSU9fQkFTRSwgICAgIElOVF9NUFVJTywJICAgIElIX01QVUlPX0JBU0UsICAgICBNRVRIT0RfTVBVSU99LAoJeyBPTUFQMTYxMF9HUElPMV9CQVNFLCBJTlRfR1BJT19CQU5LMSwJICAgIElIX0dQSU9fQkFTRSwgICAgICBNRVRIT0RfR1BJT18xNjEwIH0sCgl7IE9NQVAxNjEwX0dQSU8yX0JBU0UsIElOVF8xNjEwX0dQSU9fQkFOSzIsIElIX0dQSU9fQkFTRSArIDE2LCBNRVRIT0RfR1BJT18xNjEwIH0sCgl7IE9NQVAxNjEwX0dQSU8zX0JBU0UsIElOVF8xNjEwX0dQSU9fQkFOSzMsIElIX0dQSU9fQkFTRSArIDMyLCBNRVRIT0RfR1BJT18xNjEwIH0sCgl7IE9NQVAxNjEwX0dQSU80X0JBU0UsIElOVF8xNjEwX0dQSU9fQkFOSzQsIElIX0dQSU9fQkFTRSArIDQ4LCBNRVRIT0RfR1BJT18xNjEwIH0sCn07CiNlbmRpZgoKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNVhYCnN0YXRpYyBzdHJ1Y3QgZ3Bpb19iYW5rIGdwaW9fYmFua18xNTEwWzJdID0gewoJeyBPTUFQX01QVUlPX0JBU0UsICAgIElOVF9NUFVJTywgICAgICBJSF9NUFVJT19CQVNFLCBNRVRIT0RfTVBVSU8gfSwKCXsgT01BUDE1MTBfR1BJT19CQVNFLCBJTlRfR1BJT19CQU5LMSwgSUhfR1BJT19CQVNFLCAgTUVUSE9EX0dQSU9fMTUxMCB9Cn07CiNlbmRpZgoKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgZ3Bpb19iYW5rXzczMFs3XSA9IHsKCXsgT01BUF9NUFVJT19CQVNFLCAgICAgSU5UXzczMF9NUFVJTywJICAgIElIX01QVUlPX0JBU0UsCU1FVEhPRF9NUFVJTyB9LAoJeyBPTUFQNzMwX0dQSU8xX0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzEsICBJSF9HUElPX0JBU0UsCU1FVEhPRF9HUElPXzczMCB9LAoJeyBPTUFQNzMwX0dQSU8yX0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzIsICBJSF9HUElPX0JBU0UgKyAzMiwJTUVUSE9EX0dQSU9fNzMwIH0sCgl7IE9NQVA3MzBfR1BJTzNfQkFTRSwgIElOVF83MzBfR1BJT19CQU5LMywgIElIX0dQSU9fQkFTRSArIDY0LAlNRVRIT0RfR1BJT183MzAgfSwKCXsgT01BUDczMF9HUElPNF9CQVNFLCAgSU5UXzczMF9HUElPX0JBTks0LCAgSUhfR1BJT19CQVNFICsgOTYsCU1FVEhPRF9HUElPXzczMCB9LAoJeyBPTUFQNzMwX0dQSU81X0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzUsICBJSF9HUElPX0JBU0UgKyAxMjgsIE1FVEhPRF9HUElPXzczMCB9LAoJeyBPTUFQNzMwX0dQSU82X0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzYsICBJSF9HUElPX0JBU0UgKyAxNjAsIE1FVEhPRF9HUElPXzczMCB9LAp9OwojZW5kaWYKCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWApzdGF0aWMgc3RydWN0IGdwaW9fYmFuayBncGlvX2JhbmtfMjR4eFs0XSA9IHsKCXsgT01BUDI0WFhfR1BJTzFfQkFTRSwgSU5UXzI0WFhfR1BJT19CQU5LMSwgSUhfR1BJT19CQVNFLAlNRVRIT0RfR1BJT18yNFhYIH0sCgl7IE9NQVAyNFhYX0dQSU8yX0JBU0UsIElOVF8yNFhYX0dQSU9fQkFOSzIsIElIX0dQSU9fQkFTRSArIDMyLAlNRVRIT0RfR1BJT18yNFhYIH0sCgl7IE9NQVAyNFhYX0dQSU8zX0JBU0UsIElOVF8yNFhYX0dQSU9fQkFOSzMsIElIX0dQSU9fQkFTRSArIDY0LAlNRVRIT0RfR1BJT18yNFhYIH0sCgl7IE9NQVAyNFhYX0dQSU80X0JBU0UsIElOVF8yNFhYX0dQSU9fQkFOSzQsIElIX0dQSU9fQkFTRSArIDk2LAlNRVRIT0RfR1BJT18yNFhYIH0sCn07CiNlbmRpZgoKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgKmdwaW9fYmFuazsKc3RhdGljIGludCBncGlvX2JhbmtfY291bnQ7CgpzdGF0aWMgaW5saW5lIHN0cnVjdCBncGlvX2JhbmsgKmdldF9ncGlvX2JhbmsoaW50IGdwaW8pCnsKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNVhYCglpZiAoY3B1X2lzX29tYXAxNXh4KCkpIHsKCQlpZiAoT01BUF9HUElPX0lTX01QVUlPKGdwaW8pKQoJCQlyZXR1cm4gJmdwaW9fYmFua1swXTsKCQlyZXR1cm4gJmdwaW9fYmFua1sxXTsKCX0KI2VuZGlmCiNpZiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNlhYKQoJaWYgKGNwdV9pc19vbWFwMTZ4eCgpKSB7CgkJaWYgKE9NQVBfR1BJT19JU19NUFVJTyhncGlvKSkKCQkJcmV0dXJuICZncGlvX2JhbmtbMF07CgkJcmV0dXJuICZncGlvX2JhbmtbMSArIChncGlvID4+IDQpXTsKCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQNzMwCglpZiAoY3B1X2lzX29tYXA3MzAoKSkgewoJCWlmIChPTUFQX0dQSU9fSVNfTVBVSU8oZ3BpbykpCgkJCXJldHVybiAmZ3Bpb19iYW5rWzBdOwoJCXJldHVybiAmZ3Bpb19iYW5rWzEgKyAoZ3BpbyA+PiA1KV07Cgl9CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWlmIChjcHVfaXNfb21hcDI0eHgoKSkKCQlyZXR1cm4gJmdwaW9fYmFua1tncGlvID4+IDVdOwojZW5kaWYKfQoKc3RhdGljIGlubGluZSBpbnQgZ2V0X2dwaW9faW5kZXgoaW50IGdwaW8pCnsKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCWlmIChjcHVfaXNfb21hcDczMCgpKQoJCXJldHVybiBncGlvICYgMHgxZjsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGNwdV9pc19vbWFwMjR4eCgpKQoJCXJldHVybiBncGlvICYgMHgxZjsKI2VuZGlmCglyZXR1cm4gZ3BpbyAmIDB4MGY7Cn0KCnN0YXRpYyBpbmxpbmUgaW50IGdwaW9fdmFsaWQoaW50IGdwaW8pCnsKCWlmIChncGlvIDwgMCkKCQlyZXR1cm4gLTE7CglpZiAoT01BUF9HUElPX0lTX01QVUlPKGdwaW8pKSB7CgkJaWYgKChncGlvICYgT01BUF9NUFVJT19NQVNLKSA+IDE2KQoJCQlyZXR1cm4gLTE7CgkJcmV0dXJuIDA7Cgl9CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJaWYgKGNwdV9pc19vbWFwMTV4eCgpICYmIGdwaW8gPCAxNikKCQlyZXR1cm4gMDsKI2VuZGlmCiNpZiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNlhYKQoJaWYgKChjcHVfaXNfb21hcDE2eHgoKSkgJiYgZ3BpbyA8IDY0KQoJCXJldHVybiAwOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCWlmIChjcHVfaXNfb21hcDczMCgpICYmIGdwaW8gPCAxOTIpCgkJcmV0dXJuIDA7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWlmIChjcHVfaXNfb21hcDI0eHgoKSAmJiBncGlvIDwgMTI4KQoJCXJldHVybiAwOwojZW5kaWYKCXJldHVybiAtMTsKfQoKc3RhdGljIGludCBjaGVja19ncGlvKGludCBncGlvKQp7CglpZiAodW5saWtlbHkoZ3Bpb192YWxpZChncGlvKSkgPCAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJvbWFwLWdwaW86IGludmFsaWQgR1BJTyAlZFxuIiwgZ3Bpbyk7CgkJZHVtcF9zdGFjaygpOwoJCXJldHVybiAtMTsKCX0KCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBfc2V0X2dwaW9fZGlyZWN0aW9uKHN0cnVjdCBncGlvX2JhbmsgKmJhbmssIGludCBncGlvLCBpbnQgaXNfaW5wdXQpCnsKCXZvaWQgX19pb21lbSAqcmVnID0gYmFuay0+YmFzZTsKCXUzMiBsOwoKCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CgljYXNlIE1FVEhPRF9NUFVJTzoKCQlyZWcgKz0gT01BUF9NUFVJT19JT19DTlRMOwoJCWJyZWFrOwoJY2FzZSBNRVRIT0RfR1BJT18xNTEwOgoJCXJlZyArPSBPTUFQMTUxMF9HUElPX0RJUl9DT05UUk9MOwoJCWJyZWFrOwoJY2FzZSBNRVRIT0RfR1BJT18xNjEwOgoJCXJlZyArPSBPTUFQMTYxMF9HUElPX0RJUkVDVElPTjsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fNzMwOgoJCXJlZyArPSBPTUFQNzMwX0dQSU9fRElSX0NPTlRST0w7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJcmVnICs9IE9NQVAyNFhYX0dQSU9fT0U7CgkJYnJlYWs7Cgl9CglsID0gX19yYXdfcmVhZGwocmVnKTsKCWlmIChpc19pbnB1dCkKCQlsIHw9IDEgPDwgZ3BpbzsKCWVsc2UKCQlsICY9IH4oMSA8PCBncGlvKTsKCV9fcmF3X3dyaXRlbChsLCByZWcpOwp9Cgp2b2lkIG9tYXBfc2V0X2dwaW9fZGlyZWN0aW9uKGludCBncGlvLCBpbnQgaXNfaW5wdXQpCnsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7CgoJaWYgKGNoZWNrX2dwaW8oZ3BpbykgPCAwKQoJCXJldHVybjsKCWJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoJc3Bpbl9sb2NrKCZiYW5rLT5sb2NrKTsKCV9zZXRfZ3Bpb19kaXJlY3Rpb24oYmFuaywgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIGlzX2lucHV0KTsKCXNwaW5fdW5sb2NrKCZiYW5rLT5sb2NrKTsKfQoKc3RhdGljIHZvaWQgX3NldF9ncGlvX2RhdGFvdXQoc3RydWN0IGdwaW9fYmFuayAqYmFuaywgaW50IGdwaW8sIGludCBlbmFibGUpCnsKCXZvaWQgX19pb21lbSAqcmVnID0gYmFuay0+YmFzZTsKCXUzMiBsID0gMDsKCglzd2l0Y2ggKGJhbmstPm1ldGhvZCkgewoJY2FzZSBNRVRIT0RfTVBVSU86CgkJcmVnICs9IE9NQVBfTVBVSU9fT1VUUFVUOwoJCWwgPSBfX3Jhd19yZWFkbChyZWcpOwoJCWlmIChlbmFibGUpCgkJCWwgfD0gMSA8PCBncGlvOwoJCWVsc2UKCQkJbCAmPSB+KDEgPDwgZ3Bpbyk7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzE1MTA6CgkJcmVnICs9IE9NQVAxNTEwX0dQSU9fREFUQV9PVVRQVVQ7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKGVuYWJsZSkKCQkJbCB8PSAxIDw8IGdwaW87CgkJZWxzZQoJCQlsICY9IH4oMSA8PCBncGlvKTsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQlpZiAoZW5hYmxlKQoJCQlyZWcgKz0gT01BUDE2MTBfR1BJT19TRVRfREFUQU9VVDsKCQllbHNlCgkJCXJlZyArPSBPTUFQMTYxMF9HUElPX0NMRUFSX0RBVEFPVVQ7CgkJbCA9IDEgPDwgZ3BpbzsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fNzMwOgoJCXJlZyArPSBPTUFQNzMwX0dQSU9fREFUQV9PVVRQVVQ7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKGVuYWJsZSkKCQkJbCB8PSAxIDw8IGdwaW87CgkJZWxzZQoJCQlsICY9IH4oMSA8PCBncGlvKTsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQlpZiAoZW5hYmxlKQoJCQlyZWcgKz0gT01BUDI0WFhfR1BJT19TRVREQVRBT1VUOwoJCWVsc2UKCQkJcmVnICs9IE9NQVAyNFhYX0dQSU9fQ0xFQVJEQVRBT1VUOwoJCWwgPSAxIDw8IGdwaW87CgkJYnJlYWs7CglkZWZhdWx0OgoJCUJVRygpOwoJCXJldHVybjsKCX0KCV9fcmF3X3dyaXRlbChsLCByZWcpOwp9Cgp2b2lkIG9tYXBfc2V0X2dwaW9fZGF0YW91dChpbnQgZ3BpbywgaW50IGVuYWJsZSkKewoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCglpZiAoY2hlY2tfZ3BpbyhncGlvKSA8IDApCgkJcmV0dXJuOwoJYmFuayA9IGdldF9ncGlvX2JhbmsoZ3Bpbyk7CglzcGluX2xvY2soJmJhbmstPmxvY2spOwoJX3NldF9ncGlvX2RhdGFvdXQoYmFuaywgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIGVuYWJsZSk7CglzcGluX3VubG9jaygmYmFuay0+bG9jayk7Cn0KCmludCBvbWFwX2dldF9ncGlvX2RhdGFpbihpbnQgZ3BpbykKewoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCXZvaWQgX19pb21lbSAqcmVnOwoKCWlmIChjaGVja19ncGlvKGdwaW8pIDwgMCkKCQlyZXR1cm4gLTE7CgliYW5rID0gZ2V0X2dwaW9fYmFuayhncGlvKTsKCXJlZyA9IGJhbmstPmJhc2U7Cglzd2l0Y2ggKGJhbmstPm1ldGhvZCkgewoJY2FzZSBNRVRIT0RfTVBVSU86CgkJcmVnICs9IE9NQVBfTVBVSU9fSU5QVVRfTEFUQ0g7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzE1MTA6CgkJcmVnICs9IE9NQVAxNTEwX0dQSU9fREFUQV9JTlBVVDsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQlyZWcgKz0gT01BUDE2MTBfR1BJT19EQVRBSU47CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzczMDoKCQlyZWcgKz0gT01BUDczMF9HUElPX0RBVEFfSU5QVVQ7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJcmVnICs9IE9NQVAyNFhYX0dQSU9fREFUQUlOOwoJCWJyZWFrOwoJZGVmYXVsdDoKCQlCVUcoKTsKCQlyZXR1cm4gLTE7Cgl9CglyZXR1cm4gKF9fcmF3X3JlYWRsKHJlZykKCQkJJiAoMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSkpICE9IDA7Cn0KCiNkZWZpbmUgTU9EX1JFR19CSVQocmVnLCBiaXRfbWFzaywgc2V0KQlcCmRvIHsJXAoJaW50IGwgPSBfX3Jhd19yZWFkbChiYXNlICsgcmVnKTsgXAoJaWYgKHNldCkgbCB8PSBiaXRfbWFzazsgXAoJZWxzZSBsICY9IH5iaXRfbWFzazsgXAoJX19yYXdfd3JpdGVsKGwsIGJhc2UgKyByZWcpOyBcCn0gd2hpbGUoMCkKCnN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfMjR4eF9ncGlvX3RyaWdnZXJpbmcodm9pZCBfX2lvbWVtICpiYXNlLCBpbnQgZ3BpbywgaW50IHRyaWdnZXIpCnsKCXUzMiBncGlvX2JpdCA9IDEgPDwgZ3BpbzsKCglNT0RfUkVHX0JJVChPTUFQMjRYWF9HUElPX0xFVkVMREVURUNUMCwgZ3Bpb19iaXQsCgkJdHJpZ2dlciAmIF9fSVJRVF9MT1dMVkwpOwoJTU9EX1JFR19CSVQoT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDEsIGdwaW9fYml0LAoJCXRyaWdnZXIgJiBfX0lSUVRfSElHSExWTCk7CglNT0RfUkVHX0JJVChPTUFQMjRYWF9HUElPX1JJU0lOR0RFVEVDVCwgZ3Bpb19iaXQsCgkJdHJpZ2dlciAmIF9fSVJRVF9SSVNFREdFKTsKCU1PRF9SRUdfQklUKE9NQVAyNFhYX0dQSU9fRkFMTElOR0RFVEVDVCwgZ3Bpb19iaXQsCgkJdHJpZ2dlciAmIF9fSVJRVF9GQUxFREdFKTsKCS8qIEZJWE1FOiBQb3NzaWJseSBkbyAnc2V0X2lycV9oYW5kbGVyKGosIGRvX2xldmVsX0lSUSknIGlmIG9ubHkgbGV2ZWwKCSAqIHRyaWdnZXJpbmcgcmVxdWVzdGVkLiAqLwp9CgpzdGF0aWMgaW50IF9zZXRfZ3Bpb190cmlnZ2VyaW5nKHN0cnVjdCBncGlvX2JhbmsgKmJhbmssIGludCBncGlvLCBpbnQgdHJpZ2dlcikKewoJdm9pZCBfX2lvbWVtICpyZWcgPSBiYW5rLT5iYXNlOwoJdTMyIGwgPSAwOwoKCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CgljYXNlIE1FVEhPRF9NUFVJTzoKCQlyZWcgKz0gT01BUF9NUFVJT19HUElPX0lOVF9FREdFOwoJCWwgPSBfX3Jhd19yZWFkbChyZWcpOwoJCWlmICh0cmlnZ2VyICYgX19JUlFUX1JJU0VER0UpCgkJCWwgfD0gMSA8PCBncGlvOwoJCWVsc2UgaWYgKHRyaWdnZXIgJiBfX0lSUVRfRkFMRURHRSkKCQkJbCAmPSB+KDEgPDwgZ3Bpbyk7CgkJZWxzZQoJCQlnb3RvIGJhZDsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fMTUxMDoKCQlyZWcgKz0gT01BUDE1MTBfR1BJT19JTlRfQ09OVFJPTDsKCQlsID0gX19yYXdfcmVhZGwocmVnKTsKCQlpZiAodHJpZ2dlciAmIF9fSVJRVF9SSVNFREdFKQoJCQlsIHw9IDEgPDwgZ3BpbzsKCQllbHNlIGlmICh0cmlnZ2VyICYgX19JUlFUX0ZBTEVER0UpCgkJCWwgJj0gfigxIDw8IGdwaW8pOwoJCWVsc2UKCQkJZ290byBiYWQ7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzE2MTA6CgkJaWYgKGdwaW8gJiAweDA4KQoJCQlyZWcgKz0gT01BUDE2MTBfR1BJT19FREdFX0NUUkwyOwoJCWVsc2UKCQkJcmVnICs9IE9NQVAxNjEwX0dQSU9fRURHRV9DVFJMMTsKCQlncGlvICY9IDB4MDc7CgkJLyogV2UgYWxsb3cgb25seSBlZGdlIHRyaWdnZXJpbmcsIGkuZS4gdHdvIGxvd2VzdCBiaXRzICovCgkJaWYgKHRyaWdnZXIgJiAoX19JUlFUX0xPV0xWTCB8IF9fSVJRVF9ISUdITFZMKSkKCQkJQlVHKCk7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJbCAmPSB+KDMgPDwgKGdwaW8gPDwgMSkpOwoJCWlmICh0cmlnZ2VyICYgX19JUlFUX1JJU0VER0UpCgkJCWwgfD0gMiA8PCAoZ3BpbyA8PCAxKTsKCQlpZiAodHJpZ2dlciAmIF9fSVJRVF9GQUxFREdFKQoJCQlsIHw9IDEgPDwgKGdwaW8gPDwgMSk7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzczMDoKCQlyZWcgKz0gT01BUDczMF9HUElPX0lOVF9DT05UUk9MOwoJCWwgPSBfX3Jhd19yZWFkbChyZWcpOwoJCWlmICh0cmlnZ2VyICYgX19JUlFUX1JJU0VER0UpCgkJCWwgfD0gMSA8PCBncGlvOwoJCWVsc2UgaWYgKHRyaWdnZXIgJiBfX0lSUVRfRkFMRURHRSkKCQkJbCAmPSB+KDEgPDwgZ3Bpbyk7CgkJZWxzZQoJCQlnb3RvIGJhZDsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQlzZXRfMjR4eF9ncGlvX3RyaWdnZXJpbmcocmVnLCBncGlvLCB0cmlnZ2VyKTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJQlVHKCk7CgkJZ290byBiYWQ7Cgl9CglfX3Jhd193cml0ZWwobCwgcmVnKTsKCXJldHVybiAwOwpiYWQ6CglyZXR1cm4gLUVJTlZBTDsKfQoKc3RhdGljIGludCBncGlvX2lycV90eXBlKHVuc2lnbmVkIGlycSwgdW5zaWduZWQgdHlwZSkKewoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCXVuc2lnbmVkIGdwaW87CglpbnQgcmV0dmFsOwoKCWlmIChpcnEgPiBJSF9NUFVJT19CQVNFKQoJCWdwaW8gPSBPTUFQX01QVUlPKGlycSAtIElIX01QVUlPX0JBU0UpOwoJZWxzZQoJCWdwaW8gPSBpcnEgLSBJSF9HUElPX0JBU0U7CgoJaWYgKGNoZWNrX2dwaW8oZ3BpbykgPCAwKQoJCXJldHVybiAtRUlOVkFMOwoKCWlmICh0eXBlICYgSVJRVF9QUk9CRSkKCQlyZXR1cm4gLUVJTlZBTDsKCWlmICghY3B1X2lzX29tYXAyNHh4KCkgJiYgKHR5cGUgJiAoX19JUlFUX0xPV0xWTHxfX0lSUVRfSElHSExWTCkpKQoJCXJldHVybiAtRUlOVkFMOwoKCWJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoJc3Bpbl9sb2NrKCZiYW5rLT5sb2NrKTsKCXJldHZhbCA9IF9zZXRfZ3Bpb190cmlnZ2VyaW5nKGJhbmssIGdldF9ncGlvX2luZGV4KGdwaW8pLCB0eXBlKTsKCXNwaW5fdW5sb2NrKCZiYW5rLT5sb2NrKTsKCXJldHVybiByZXR2YWw7Cn0KCnN0YXRpYyB2b2lkIF9jbGVhcl9ncGlvX2lycWJhbmsoc3RydWN0IGdwaW9fYmFuayAqYmFuaywgaW50IGdwaW9fbWFzaykKewoJdm9pZCBfX2lvbWVtICpyZWcgPSBiYW5rLT5iYXNlOwoKCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CgljYXNlIE1FVEhPRF9NUFVJTzoKCQkvKiBNUFVJTyBpcnFzdGF0dXMgaXMgcmVzZXQgYnkgcmVhZGluZyB0aGUgc3RhdHVzIHJlZ2lzdGVyLAoJCSAqIHNvIGRvIG5vdGhpbmcgaGVyZSAqLwoJCXJldHVybjsKCWNhc2UgTUVUSE9EX0dQSU9fMTUxMDoKCQlyZWcgKz0gT01BUDE1MTBfR1BJT19JTlRfU1RBVFVTOwoJCWJyZWFrOwoJY2FzZSBNRVRIT0RfR1BJT18xNjEwOgoJCXJlZyArPSBPTUFQMTYxMF9HUElPX0lSUVNUQVRVUzE7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzczMDoKCQlyZWcgKz0gT01BUDczMF9HUElPX0lOVF9TVEFUVVM7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJcmVnICs9IE9NQVAyNFhYX0dQSU9fSVJRU1RBVFVTMTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJQlVHKCk7CgkJcmV0dXJuOwoJfQoJX19yYXdfd3JpdGVsKGdwaW9fbWFzaywgcmVnKTsKfQoKc3RhdGljIGlubGluZSB2b2lkIF9jbGVhcl9ncGlvX2lycXN0YXR1cyhzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rLCBpbnQgZ3BpbykKewoJX2NsZWFyX2dwaW9faXJxYmFuayhiYW5rLCAxIDw8IGdldF9ncGlvX2luZGV4KGdwaW8pKTsKfQoKc3RhdGljIHZvaWQgX2VuYWJsZV9ncGlvX2lycWJhbmsoc3RydWN0IGdwaW9fYmFuayAqYmFuaywgaW50IGdwaW9fbWFzaywgaW50IGVuYWJsZSkKewoJdm9pZCBfX2lvbWVtICpyZWcgPSBiYW5rLT5iYXNlOwoJdTMyIGw7CgoJc3dpdGNoIChiYW5rLT5tZXRob2QpIHsKCWNhc2UgTUVUSE9EX01QVUlPOgoJCXJlZyArPSBPTUFQX01QVUlPX0dQSU9fTUFTS0lUOwoJCWwgPSBfX3Jhd19yZWFkbChyZWcpOwoJCWlmIChlbmFibGUpCgkJCWwgJj0gfihncGlvX21hc2spOwoJCWVsc2UKCQkJbCB8PSBncGlvX21hc2s7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzE1MTA6CgkJcmVnICs9IE9NQVAxNTEwX0dQSU9fSU5UX01BU0s7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKGVuYWJsZSkKCQkJbCAmPSB+KGdwaW9fbWFzayk7CgkJZWxzZQoJCQlsIHw9IGdwaW9fbWFzazsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQlpZiAoZW5hYmxlKQoJCQlyZWcgKz0gT01BUDE2MTBfR1BJT19TRVRfSVJRRU5BQkxFMTsKCQllbHNlCgkJCXJlZyArPSBPTUFQMTYxMF9HUElPX0NMRUFSX0lSUUVOQUJMRTE7CgkJbCA9IGdwaW9fbWFzazsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fNzMwOgoJCXJlZyArPSBPTUFQNzMwX0dQSU9fSU5UX01BU0s7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKGVuYWJsZSkKCQkJbCAmPSB+KGdwaW9fbWFzayk7CgkJZWxzZQoJCQlsIHw9IGdwaW9fbWFzazsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQlpZiAoZW5hYmxlKQoJCQlyZWcgKz0gT01BUDI0WFhfR1BJT19TRVRJUlFFTkFCTEUxOwoJCWVsc2UKCQkJcmVnICs9IE9NQVAyNFhYX0dQSU9fQ0xFQVJJUlFFTkFCTEUxOwoJCWwgPSBncGlvX21hc2s7CgkJYnJlYWs7CglkZWZhdWx0OgoJCUJVRygpOwoJCXJldHVybjsKCX0KCV9fcmF3X3dyaXRlbChsLCByZWcpOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgX3NldF9ncGlvX2lycWVuYWJsZShzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rLCBpbnQgZ3BpbywgaW50IGVuYWJsZSkKewoJX2VuYWJsZV9ncGlvX2lycWJhbmsoYmFuaywgMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSwgZW5hYmxlKTsKfQoKLyoKICogTm90ZSB0aGF0IEVOQVdBS0VVUCBuZWVkcyB0byBiZSBlbmFibGVkIGluIEdQSU9fU1lTQ09ORklHIHJlZ2lzdGVyLgogKiAxNTEwIGRvZXMgbm90IHNlZW0gdG8gaGF2ZSBhIHdha2UtdXAgcmVnaXN0ZXIuIElmIEpUQUcgaXMgY29ubmVjdGVkCiAqIHRvIHRoZSB0YXJnZXQsIHN5c3RlbSB3aWxsIHdha2UgdXAgYWx3YXlzIG9uIEdQSU8gZXZlbnRzLiBXaGlsZQogKiBzeXN0ZW0gaXMgcnVubmluZyBhbGwgcmVnaXN0ZXJlZCBHUElPIGludGVycnVwdHMgbmVlZCB0byBoYXZlIHdha2UtdXAKICogZW5hYmxlZC4gV2hlbiBzeXN0ZW0gaXMgc3VzcGVuZGVkLCBvbmx5IHNlbGVjdGVkIEdQSU8gaW50ZXJydXB0cyBuZWVkCiAqIHRvIGhhdmUgd2FrZS11cCBlbmFibGVkLgogKi8Kc3RhdGljIGludCBfc2V0X2dwaW9fd2FrZXVwKHN0cnVjdCBncGlvX2JhbmsgKmJhbmssIGludCBncGlvLCBpbnQgZW5hYmxlKQp7Cglzd2l0Y2ggKGJhbmstPm1ldGhvZCkgewoJY2FzZSBNRVRIT0RfR1BJT18xNjEwOgoJY2FzZSBNRVRIT0RfR1BJT18yNFhYOgoJCXNwaW5fbG9jaygmYmFuay0+bG9jayk7CgkJaWYgKGVuYWJsZSkKCQkJYmFuay0+c3VzcGVuZF93YWtldXAgfD0gKDEgPDwgZ3Bpbyk7CgkJZWxzZQoJCQliYW5rLT5zdXNwZW5kX3dha2V1cCAmPSB+KDEgPDwgZ3Bpbyk7CgkJc3Bpbl91bmxvY2soJmJhbmstPmxvY2spOwoJCXJldHVybiAwOwoJZGVmYXVsdDoKCQlwcmludGsoS0VSTl9FUlIgIkNhbid0IGVuYWJsZSBHUElPIHdha2V1cCBmb3IgbWV0aG9kICVpXG4iLAoJCSAgICAgICBiYW5rLT5tZXRob2QpOwoJCXJldHVybiAtRUlOVkFMOwoJfQp9CgovKiBVc2UgZGlzYWJsZV9pcnFfd2FrZSgpIGFuZCBlbmFibGVfaXJxX3dha2UoKSBmdW5jdGlvbnMgZnJvbSBkcml2ZXJzICovCnN0YXRpYyBpbnQgZ3Bpb193YWtlX2VuYWJsZSh1bnNpZ25lZCBpbnQgaXJxLCB1bnNpZ25lZCBpbnQgZW5hYmxlKQp7Cgl1bnNpZ25lZCBpbnQgZ3BpbyA9IGlycSAtIElIX0dQSU9fQkFTRTsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7CglpbnQgcmV0dmFsOwoKCWlmIChjaGVja19ncGlvKGdwaW8pIDwgMCkKCQlyZXR1cm4gLUVOT0RFVjsKCWJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoJc3Bpbl9sb2NrKCZiYW5rLT5sb2NrKTsKCXJldHZhbCA9IF9zZXRfZ3Bpb193YWtldXAoYmFuaywgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIGVuYWJsZSk7CglzcGluX3VubG9jaygmYmFuay0+bG9jayk7CgoJcmV0dXJuIHJldHZhbDsKfQoKaW50IG9tYXBfcmVxdWVzdF9ncGlvKGludCBncGlvKQp7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rOwoKCWlmIChjaGVja19ncGlvKGdwaW8pIDwgMCkKCQlyZXR1cm4gLUVJTlZBTDsKCgliYW5rID0gZ2V0X2dwaW9fYmFuayhncGlvKTsKCXNwaW5fbG9jaygmYmFuay0+bG9jayk7CglpZiAodW5saWtlbHkoYmFuay0+cmVzZXJ2ZWRfbWFwICYgKDEgPDwgZ2V0X2dwaW9faW5kZXgoZ3BpbykpKSkgewoJCXByaW50ayhLRVJOX0VSUiAib21hcC1ncGlvOiBHUElPICVkIGlzIGFscmVhZHkgcmVzZXJ2ZWQhXG4iLCBncGlvKTsKCQlkdW1wX3N0YWNrKCk7CgkJc3Bpbl91bmxvY2soJmJhbmstPmxvY2spOwoJCXJldHVybiAtMTsKCX0KCWJhbmstPnJlc2VydmVkX21hcCB8PSAoMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSk7CgoJLyogU2V0IHRyaWdnZXIgdG8gbm9uZS4gWW91IG5lZWQgdG8gZW5hYmxlIHRoZSB0cmlnZ2VyIGFmdGVyIHJlcXVlc3RfaXJxICovCglfc2V0X2dwaW9fdHJpZ2dlcmluZyhiYW5rLCBnZXRfZ3Bpb19pbmRleChncGlvKSwgSVJRVF9OT0VER0UpOwoKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNVhYCglpZiAoYmFuay0+bWV0aG9kID09IE1FVEhPRF9HUElPXzE1MTApIHsKCQl2b2lkIF9faW9tZW0gKnJlZzsKCgkJLyogQ2xhaW0gdGhlIHBpbiBmb3IgTVBVICovCgkJcmVnID0gYmFuay0+YmFzZSArIE9NQVAxNTEwX0dQSU9fUElOX0NPTlRST0w7CgkJX19yYXdfd3JpdGVsKF9fcmF3X3JlYWRsKHJlZykgfCAoMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSksIHJlZyk7Cgl9CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE2WFgKCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX0dQSU9fMTYxMCkgewoJCS8qIEVuYWJsZSB3YWtlLXVwIGR1cmluZyBpZGxlIGZvciBkeW5hbWljIHRpY2sgKi8KCQl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX1NFVF9XQUtFVVBFTkE7CgkJX19yYXdfd3JpdGVsKDEgPDwgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIHJlZyk7Cgl9CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX0dQSU9fMjRYWCkgewoJCS8qIEVuYWJsZSB3YWtlLXVwIGR1cmluZyBpZGxlIGZvciBkeW5hbWljIHRpY2sgKi8KCQl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX1NFVFdLVUVOQTsKCQlfX3Jhd193cml0ZWwoMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSwgcmVnKTsKCX0KI2VuZGlmCglzcGluX3VubG9jaygmYmFuay0+bG9jayk7CgoJcmV0dXJuIDA7Cn0KCnZvaWQgb21hcF9mcmVlX2dwaW8oaW50IGdwaW8pCnsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7CgoJaWYgKGNoZWNrX2dwaW8oZ3BpbykgPCAwKQoJCXJldHVybjsKCWJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoJc3Bpbl9sb2NrKCZiYW5rLT5sb2NrKTsKCWlmICh1bmxpa2VseSghKGJhbmstPnJlc2VydmVkX21hcCAmICgxIDw8IGdldF9ncGlvX2luZGV4KGdwaW8pKSkpKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJvbWFwLWdwaW86IEdQSU8gJWQgd2Fzbid0IHJlc2VydmVkIVxuIiwgZ3Bpbyk7CgkJZHVtcF9zdGFjaygpOwoJCXNwaW5fdW5sb2NrKCZiYW5rLT5sb2NrKTsKCQlyZXR1cm47Cgl9CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTZYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18xNjEwKSB7CgkJLyogRGlzYWJsZSB3YWtlLXVwIGR1cmluZyBpZGxlIGZvciBkeW5hbWljIHRpY2sgKi8KCQl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX0NMRUFSX1dBS0VVUEVOQTsKCQlfX3Jhd193cml0ZWwoMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSwgcmVnKTsKCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18yNFhYKSB7CgkJLyogRGlzYWJsZSB3YWtlLXVwIGR1cmluZyBpZGxlIGZvciBkeW5hbWljIHRpY2sgKi8KCQl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0NMRUFSV0tVRU5BOwoJCV9fcmF3X3dyaXRlbCgxIDw8IGdldF9ncGlvX2luZGV4KGdwaW8pLCByZWcpOwoJfQojZW5kaWYKCWJhbmstPnJlc2VydmVkX21hcCAmPSB+KDEgPDwgZ2V0X2dwaW9faW5kZXgoZ3BpbykpOwoJX3NldF9ncGlvX2RpcmVjdGlvbihiYW5rLCBnZXRfZ3Bpb19pbmRleChncGlvKSwgMSk7Cglfc2V0X2dwaW9faXJxZW5hYmxlKGJhbmssIGdwaW8sIDApOwoJX2NsZWFyX2dwaW9faXJxc3RhdHVzKGJhbmssIGdwaW8pOwoJc3Bpbl91bmxvY2soJmJhbmstPmxvY2spOwp9CgovKgogKiBXZSBuZWVkIHRvIHVubWFzayB0aGUgR1BJTyBiYW5rIGludGVycnVwdCBhcyBzb29uIGFzIHBvc3NpYmxlIHRvCiAqIGF2b2lkIG1pc3NpbmcgR1BJTyBpbnRlcnJ1cHRzIGZvciBvdGhlciBsaW5lcyBpbiB0aGUgYmFuay4KICogVGhlbiB3ZSBuZWVkIHRvIG1hc2stcmVhZC1jbGVhci11bm1hc2sgdGhlIHRyaWdnZXJlZCBHUElPIGxpbmVzCiAqIGluIHRoZSBiYW5rIHRvIGF2b2lkIG1pc3NpbmcgbmVzdGVkIGludGVycnVwdHMgZm9yIGEgR1BJTyBsaW5lLgogKiBJZiB3ZSB3YWl0IHRvIHVubWFzayBpbmRpdmlkdWFsIEdQSU8gbGluZXMgaW4gdGhlIGJhbmsgYWZ0ZXIgdGhlCiAqIGxpbmUncyBpbnRlcnJ1cHQgaGFuZGxlciBoYXMgYmVlbiBydW4sIHdlIG1heSBtaXNzIHNvbWUgbmVzdGVkCiAqIGludGVycnVwdHMuCiAqLwpzdGF0aWMgdm9pZCBncGlvX2lycV9oYW5kbGVyKHVuc2lnbmVkIGludCBpcnEsIHN0cnVjdCBpcnFkZXNjICpkZXNjLAoJCQkgICAgIHN0cnVjdCBwdF9yZWdzICpyZWdzKQp7Cgl2b2lkIF9faW9tZW0gKmlzcl9yZWcgPSBOVUxMOwoJdTMyIGlzcjsKCXVuc2lnbmVkIGludCBncGlvX2lycTsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7CgoJZGVzYy0+Y2hpcC0+YWNrKGlycSk7CgoJYmFuayA9IChzdHJ1Y3QgZ3Bpb19iYW5rICopIGRlc2MtPmRhdGE7CglpZiAoYmFuay0+bWV0aG9kID09IE1FVEhPRF9NUFVJTykKCQlpc3JfcmVnID0gYmFuay0+YmFzZSArIE9NQVBfTVBVSU9fR1BJT19JTlQ7CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18xNTEwKQoJCWlzcl9yZWcgPSBiYW5rLT5iYXNlICsgT01BUDE1MTBfR1BJT19JTlRfU1RBVFVTOwojZW5kaWYKI2lmIGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDE2WFgpCglpZiAoYmFuay0+bWV0aG9kID09IE1FVEhPRF9HUElPXzE2MTApCgkJaXNyX3JlZyA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX0lSUVNUQVRVUzE7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDczMAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT183MzApCgkJaXNyX3JlZyA9IGJhbmstPmJhc2UgKyBPTUFQNzMwX0dQSU9fSU5UX1NUQVRVUzsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18yNFhYKQoJCWlzcl9yZWcgPSBiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19JUlFTVEFUVVMxOwojZW5kaWYKCXdoaWxlKDEpIHsKCQl1MzIgaXNyX3NhdmVkLCBsZXZlbF9tYXNrID0gMDsKCgkJaXNyX3NhdmVkID0gaXNyID0gX19yYXdfcmVhZGwoaXNyX3JlZyk7CgoJCWlmIChjcHVfaXNfb21hcDE1eHgoKSAmJiAoYmFuay0+bWV0aG9kID09IE1FVEhPRF9NUFVJTykpCgkJCWlzciAmPSAweDAwMDBmZmZmOwoKCQlpZiAoY3B1X2lzX29tYXAyNHh4KCkpCgkJCWxldmVsX21hc2sgPQoJCQkJX19yYXdfcmVhZGwoYmFuay0+YmFzZSArCgkJCQkJT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDApIHwKCQkJCV9fcmF3X3JlYWRsKGJhbmstPmJhc2UgKwoJCQkJCU9NQVAyNFhYX0dQSU9fTEVWRUxERVRFQ1QxKTsKCgkJLyogY2xlYXIgZWRnZSBzZW5zaXRpdmUgaW50ZXJydXB0cyBiZWZvcmUgaGFuZGxlcihzKSBhcmUKCQljYWxsZWQgc28gdGhhdCB3ZSBkb24ndCBtaXNzIGFueSBpbnRlcnJ1cHQgb2NjdXJyZWQgd2hpbGUKCQlleGVjdXRpbmcgdGhlbSAqLwoJCV9lbmFibGVfZ3Bpb19pcnFiYW5rKGJhbmssIGlzcl9zYXZlZCAmIH5sZXZlbF9tYXNrLCAwKTsKCQlfY2xlYXJfZ3Bpb19pcnFiYW5rKGJhbmssIGlzcl9zYXZlZCAmIH5sZXZlbF9tYXNrKTsKCQlfZW5hYmxlX2dwaW9faXJxYmFuayhiYW5rLCBpc3Jfc2F2ZWQgJiB+bGV2ZWxfbWFzaywgMSk7CgoJCS8qIGlmIHRoZXJlIGlzIG9ubHkgZWRnZSBzZW5zaXRpdmUgR1BJTyBwaW4gaW50ZXJydXB0cwoJCWNvbmZpZ3VyZWQsIHdlIGNvdWxkIHVubWFzayBHUElPIGJhbmsgaW50ZXJydXB0IGltbWVkaWF0ZWx5ICovCgkJaWYgKCFsZXZlbF9tYXNrKQoJCQlkZXNjLT5jaGlwLT51bm1hc2soaXJxKTsKCgkJaWYgKCFpc3IpCgkJCWJyZWFrOwoKCQlncGlvX2lycSA9IGJhbmstPnZpcnR1YWxfaXJxX3N0YXJ0OwoJCWZvciAoOyBpc3IgIT0gMDsgaXNyID4+PSAxLCBncGlvX2lycSsrKSB7CgkJCXN0cnVjdCBpcnFkZXNjICpkOwoJCQlpZiAoIShpc3IgJiAxKSkKCQkJCWNvbnRpbnVlOwoJCQlkID0gaXJxX2Rlc2MgKyBncGlvX2lycTsKCQkJZGVzY19oYW5kbGVfaXJxKGdwaW9faXJxLCBkLCByZWdzKTsKCQl9CgoJCWlmIChjcHVfaXNfb21hcDI0eHgoKSkgewoJCQkvKiBjbGVhciBsZXZlbCBzZW5zaXRpdmUgaW50ZXJydXB0cyBhZnRlciBoYW5kbGVyKHMpICovCgkJCV9lbmFibGVfZ3Bpb19pcnFiYW5rKGJhbmssIGlzcl9zYXZlZCAmIGxldmVsX21hc2ssIDApOwoJCQlfY2xlYXJfZ3Bpb19pcnFiYW5rKGJhbmssIGlzcl9zYXZlZCAmIGxldmVsX21hc2spOwoJCQlfZW5hYmxlX2dwaW9faXJxYmFuayhiYW5rLCBpc3Jfc2F2ZWQgJiBsZXZlbF9tYXNrLCAxKTsKCQl9CgoJCS8qIGlmIGJhbmsgaGFzIGFueSBsZXZlbCBzZW5zaXRpdmUgR1BJTyBwaW4gaW50ZXJydXB0CgkJY29uZmlndXJlZCwgd2UgbXVzdCB1bm1hc2sgdGhlIGJhbmsgaW50ZXJydXB0IG9ubHkgYWZ0ZXIKCQloYW5kbGVyKHMpIGFyZSBleGVjdXRlZCBpbiBvcmRlciB0byBhdm9pZCBzcHVyaW91cyBiYW5rCgkJaW50ZXJydXB0ICovCgkJaWYgKGxldmVsX21hc2spCgkJCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOwoJfQp9CgpzdGF0aWMgdm9pZCBncGlvX2Fja19pcnEodW5zaWduZWQgaW50IGlycSkKewoJdW5zaWduZWQgaW50IGdwaW8gPSBpcnEgLSBJSF9HUElPX0JBU0U7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2dwaW9fYmFuayhncGlvKTsKCglfY2xlYXJfZ3Bpb19pcnFzdGF0dXMoYmFuaywgZ3Bpbyk7Cn0KCnN0YXRpYyB2b2lkIGdwaW9fbWFza19pcnEodW5zaWduZWQgaW50IGlycSkKewoJdW5zaWduZWQgaW50IGdwaW8gPSBpcnEgLSBJSF9HUElPX0JBU0U7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2dwaW9fYmFuayhncGlvKTsKCglfc2V0X2dwaW9faXJxZW5hYmxlKGJhbmssIGdwaW8sIDApOwp9CgpzdGF0aWMgdm9pZCBncGlvX3VubWFza19pcnEodW5zaWduZWQgaW50IGlycSkKewoJdW5zaWduZWQgaW50IGdwaW8gPSBpcnEgLSBJSF9HUElPX0JBU0U7Cgl1bnNpZ25lZCBpbnQgZ3Bpb19pZHggPSBnZXRfZ3Bpb19pbmRleChncGlvKTsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoKCV9zZXRfZ3Bpb19pcnFlbmFibGUoYmFuaywgZ3Bpb19pZHgsIDEpOwp9CgpzdGF0aWMgdm9pZCBtcHVpb19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCnsKCS8qIFRoZSBJU1IgaXMgcmVzZXQgYXV0b21hdGljYWxseSwgc28gZG8gbm90aGluZyBoZXJlLiAqLwp9CgpzdGF0aWMgdm9pZCBtcHVpb19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQp7Cgl1bnNpZ25lZCBpbnQgZ3BpbyA9IE9NQVBfTVBVSU8oaXJxIC0gSUhfTVBVSU9fQkFTRSk7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2dwaW9fYmFuayhncGlvKTsKCglfc2V0X2dwaW9faXJxZW5hYmxlKGJhbmssIGdwaW8sIDApOwp9CgpzdGF0aWMgdm9pZCBtcHVpb191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCnsKCXVuc2lnbmVkIGludCBncGlvID0gT01BUF9NUFVJTyhpcnEgLSBJSF9NUFVJT19CQVNFKTsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoKCV9zZXRfZ3Bpb19pcnFlbmFibGUoYmFuaywgZ3BpbywgMSk7Cn0KCnN0YXRpYyBzdHJ1Y3QgaXJxY2hpcCBncGlvX2lycV9jaGlwID0gewoJLmFjawkJPSBncGlvX2Fja19pcnEsCgkubWFzawkJPSBncGlvX21hc2tfaXJxLAoJLnVubWFzawkJPSBncGlvX3VubWFza19pcnEsCgkuc2V0X3R5cGUJPSBncGlvX2lycV90eXBlLAoJLnNldF93YWtlCT0gZ3Bpb193YWtlX2VuYWJsZSwKfTsKCnN0YXRpYyBzdHJ1Y3QgaXJxY2hpcCBtcHVpb19pcnFfY2hpcCA9IHsKCS5hY2sJPSBtcHVpb19hY2tfaXJxLAoJLm1hc2sJPSBtcHVpb19tYXNrX2lycSwKCS51bm1hc2sgPSBtcHVpb191bm1hc2tfaXJxCn07CgpzdGF0aWMgaW50IGluaXRpYWxpemVkOwpzdGF0aWMgc3RydWN0IGNsayAqIGdwaW9faWNrOwpzdGF0aWMgc3RydWN0IGNsayAqIGdwaW9fZmNrOwoKc3RhdGljIGludCBfX2luaXQgX29tYXBfZ3Bpb19pbml0KHZvaWQpCnsKCWludCBpOwoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCglpbml0aWFsaXplZCA9IDE7CgoJaWYgKGNwdV9pc19vbWFwMTV4eCgpKSB7CgkJZ3Bpb19pY2sgPSBjbGtfZ2V0KE5VTEwsICJhcm1fZ3Bpb19jayIpOwoJCWlmIChJU19FUlIoZ3Bpb19pY2spKQoJCQlwcmludGsoIkNvdWxkIG5vdCBnZXQgYXJtX2dwaW9fY2tcbiIpOwoJCWVsc2UKCQkJY2xrX2VuYWJsZShncGlvX2ljayk7Cgl9CglpZiAoY3B1X2lzX29tYXAyNHh4KCkpIHsKCQlncGlvX2ljayA9IGNsa19nZXQoTlVMTCwgImdwaW9zX2ljayIpOwoJCWlmIChJU19FUlIoZ3Bpb19pY2spKQoJCQlwcmludGsoIkNvdWxkIG5vdCBnZXQgZ3Bpb3NfaWNrXG4iKTsKCQllbHNlCgkJCWNsa19lbmFibGUoZ3Bpb19pY2spOwoJCWdwaW9fZmNrID0gY2xrX2dldChOVUxMLCAiZ3Bpb3NfZmNrIik7CgkJaWYgKElTX0VSUihncGlvX2ljaykpCgkJCXByaW50aygiQ291bGQgbm90IGdldCBncGlvc19mY2tcbiIpOwoJCWVsc2UKCQkJY2xrX2VuYWJsZShncGlvX2Zjayk7Cgl9CgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE1WFgKCWlmIChjcHVfaXNfb21hcDE1eHgoKSkgewoJCXByaW50ayhLRVJOX0lORk8gIk9NQVAxNTEwIEdQSU8gaGFyZHdhcmVcbiIpOwoJCWdwaW9fYmFua19jb3VudCA9IDI7CgkJZ3Bpb19iYW5rID0gZ3Bpb19iYW5rXzE1MTA7Cgl9CiNlbmRpZgojaWYgZGVmaW5lZChDT05GSUdfQVJDSF9PTUFQMTZYWCkKCWlmIChjcHVfaXNfb21hcDE2eHgoKSkgewoJCXUzMiByZXY7CgoJCWdwaW9fYmFua19jb3VudCA9IDU7CgkJZ3Bpb19iYW5rID0gZ3Bpb19iYW5rXzE2MTA7CgkJcmV2ID0gb21hcF9yZWFkdyhncGlvX2JhbmtbMV0uYmFzZSArIE9NQVAxNjEwX0dQSU9fUkVWSVNJT04pOwoJCXByaW50ayhLRVJOX0lORk8gIk9NQVAgR1BJTyBoYXJkd2FyZSB2ZXJzaW9uICVkLiVkXG4iLAoJCSAgICAgICAocmV2ID4+IDQpICYgMHgwZiwgcmV2ICYgMHgwZik7Cgl9CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDczMAoJaWYgKGNwdV9pc19vbWFwNzMwKCkpIHsKCQlwcmludGsoS0VSTl9JTkZPICJPTUFQNzMwIEdQSU8gaGFyZHdhcmVcbiIpOwoJCWdwaW9fYmFua19jb3VudCA9IDc7CgkJZ3Bpb19iYW5rID0gZ3Bpb19iYW5rXzczMDsKCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGNwdV9pc19vbWFwMjR4eCgpKSB7CgkJaW50IHJldjsKCgkJZ3Bpb19iYW5rX2NvdW50ID0gNDsKCQlncGlvX2JhbmsgPSBncGlvX2JhbmtfMjR4eDsKCQlyZXYgPSBvbWFwX3JlYWRsKGdwaW9fYmFua1swXS5iYXNlICsgT01BUDI0WFhfR1BJT19SRVZJU0lPTik7CgkJcHJpbnRrKEtFUk5fSU5GTyAiT01BUDI0eHggR1BJTyBoYXJkd2FyZSB2ZXJzaW9uICVkLiVkXG4iLAoJCQkocmV2ID4+IDQpICYgMHgwZiwgcmV2ICYgMHgwZik7Cgl9CiNlbmRpZgoJZm9yIChpID0gMDsgaSA8IGdwaW9fYmFua19jb3VudDsgaSsrKSB7CgkJaW50IGosIGdwaW9fY291bnQgPSAxNjsKCgkJYmFuayA9ICZncGlvX2JhbmtbaV07CgkJYmFuay0+cmVzZXJ2ZWRfbWFwID0gMDsKCQliYW5rLT5iYXNlID0gSU9fQUREUkVTUyhiYW5rLT5iYXNlKTsKCQlzcGluX2xvY2tfaW5pdCgmYmFuay0+bG9jayk7CgkJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfTVBVSU8pIHsKCQkJb21hcF93cml0ZXcoMHhGRkZGLCBPTUFQX01QVUlPX0JBU0UgKyBPTUFQX01QVUlPX0dQSU9fTUFTS0lUKTsKCQl9CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX0dQSU9fMTUxMCkgewoJCQlfX3Jhd193cml0ZXcoMHhmZmZmLCBiYW5rLT5iYXNlICsgT01BUDE1MTBfR1BJT19JTlRfTUFTSyk7CgkJCV9fcmF3X3dyaXRldygweDAwMDAsIGJhbmstPmJhc2UgKyBPTUFQMTUxMF9HUElPX0lOVF9TVEFUVVMpOwoJCX0KI2VuZGlmCiNpZiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNlhYKQoJCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX0dQSU9fMTYxMCkgewoJCQlfX3Jhd193cml0ZXcoMHgwMDAwLCBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19JUlFFTkFCTEUxKTsKCQkJX19yYXdfd3JpdGV3KDB4ZmZmZiwgYmFuay0+YmFzZSArIE9NQVAxNjEwX0dQSU9fSVJRU1RBVFVTMSk7CgkJCV9fcmF3X3dyaXRldygweDAwMTQsIGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX1NZU0NPTkZJRyk7CgkJfQojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCQlpZiAoYmFuay0+bWV0aG9kID09IE1FVEhPRF9HUElPXzczMCkgewoJCQlfX3Jhd193cml0ZWwoMHhmZmZmZmZmZiwgYmFuay0+YmFzZSArIE9NQVA3MzBfR1BJT19JTlRfTUFTSyk7CgkJCV9fcmF3X3dyaXRlbCgweDAwMDAwMDAwLCBiYW5rLT5iYXNlICsgT01BUDczMF9HUElPX0lOVF9TVEFUVVMpOwoKCQkJZ3Bpb19jb3VudCA9IDMyOyAvKiA3MzAgaGFzIDMyLWJpdCBHUElPcyAqLwoJCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX0dQSU9fMjRYWCkgewoJCQlfX3Jhd193cml0ZWwoMHgwMDAwMDAwMCwgYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fSVJRRU5BQkxFMSk7CgkJCV9fcmF3X3dyaXRlbCgweGZmZmZmZmZmLCBiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19JUlFTVEFUVVMxKTsKCgkJCWdwaW9fY291bnQgPSAzMjsKCQl9CiNlbmRpZgoJCWZvciAoaiA9IGJhbmstPnZpcnR1YWxfaXJxX3N0YXJ0OwoJCSAgICAgaiA8IGJhbmstPnZpcnR1YWxfaXJxX3N0YXJ0ICsgZ3Bpb19jb3VudDsgaisrKSB7CgkJCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX01QVUlPKQoJCQkJc2V0X2lycV9jaGlwKGosICZtcHVpb19pcnFfY2hpcCk7CgkJCWVsc2UKCQkJCXNldF9pcnFfY2hpcChqLCAmZ3Bpb19pcnFfY2hpcCk7CgkJCXNldF9pcnFfaGFuZGxlcihqLCBkb19zaW1wbGVfSVJRKTsKCQkJc2V0X2lycV9mbGFncyhqLCBJUlFGX1ZBTElEKTsKCQl9CgkJc2V0X2lycV9jaGFpbmVkX2hhbmRsZXIoYmFuay0+aXJxLCBncGlvX2lycV9oYW5kbGVyKTsKCQlzZXRfaXJxX2RhdGEoYmFuay0+aXJxLCBiYW5rKTsKCX0KCgkvKiBFbmFibGUgc3lzdGVtIGNsb2NrIGZvciBHUElPIG1vZHVsZS4KCSAqIFRoZSBDQU1fQ0xLX0NUUkwgKmlzKiByZWFsbHkgdGhlIHJpZ2h0IHBsYWNlLiAqLwoJaWYgKGNwdV9pc19vbWFwMTZ4eCgpKQoJCW9tYXBfd3JpdGVsKG9tYXBfcmVhZGwoVUxQRF9DQU1fQ0xLX0NUUkwpIHwgMHgwNCwgVUxQRF9DQU1fQ0xLX0NUUkwpOwoKCXJldHVybiAwOwp9CgojaWYgZGVmaW5lZCAoQ09ORklHX0FSQ0hfT01BUDE2WFgpIHx8IGRlZmluZWQgKENPTkZJR19BUkNIX09NQVAyNFhYKQpzdGF0aWMgaW50IG9tYXBfZ3Bpb19zdXNwZW5kKHN0cnVjdCBzeXNfZGV2aWNlICpkZXYsIHBtX21lc3NhZ2VfdCBtZXNnKQp7CglpbnQgaTsKCglpZiAoIWNwdV9pc19vbWFwMjR4eCgpICYmICFjcHVfaXNfb21hcDE2eHgoKSkKCQlyZXR1cm4gMDsKCglmb3IgKGkgPSAwOyBpIDwgZ3Bpb19iYW5rX2NvdW50OyBpKyspIHsKCQlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gJmdwaW9fYmFua1tpXTsKCQl2b2lkIF9faW9tZW0gKndha2Vfc3RhdHVzOwoJCXZvaWQgX19pb21lbSAqd2FrZV9jbGVhcjsKCQl2b2lkIF9faW9tZW0gKndha2Vfc2V0OwoKCQlzd2l0Y2ggKGJhbmstPm1ldGhvZCkgewoJCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQkJd2FrZV9zdGF0dXMgPSBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19XQUtFVVBFTkFCTEU7CgkJCXdha2VfY2xlYXIgPSBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19DTEVBUl9XQUtFVVBFTkE7CgkJCXdha2Vfc2V0ID0gYmFuay0+YmFzZSArIE9NQVAxNjEwX0dQSU9fU0VUX1dBS0VVUEVOQTsKCQkJYnJlYWs7CgkJY2FzZSBNRVRIT0RfR1BJT18yNFhYOgoJCQl3YWtlX3N0YXR1cyA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX1NFVFdLVUVOQTsKCQkJd2FrZV9jbGVhciA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0NMRUFSV0tVRU5BOwoJCQl3YWtlX3NldCA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX1NFVFdLVUVOQTsKCQkJYnJlYWs7CgkJZGVmYXVsdDoKCQkJY29udGludWU7CgkJfQoKCQlzcGluX2xvY2soJmJhbmstPmxvY2spOwoJCWJhbmstPnNhdmVkX3dha2V1cCA9IF9fcmF3X3JlYWRsKHdha2Vfc3RhdHVzKTsKCQlfX3Jhd193cml0ZWwoMHhmZmZmZmZmZiwgd2FrZV9jbGVhcik7CgkJX19yYXdfd3JpdGVsKGJhbmstPnN1c3BlbmRfd2FrZXVwLCB3YWtlX3NldCk7CgkJc3Bpbl91bmxvY2soJmJhbmstPmxvY2spOwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IG9tYXBfZ3Bpb19yZXN1bWUoc3RydWN0IHN5c19kZXZpY2UgKmRldikKewoJaW50IGk7CgoJaWYgKCFjcHVfaXNfb21hcDI0eHgoKSAmJiAhY3B1X2lzX29tYXAxNnh4KCkpCgkJcmV0dXJuIDA7CgoJZm9yIChpID0gMDsgaSA8IGdwaW9fYmFua19jb3VudDsgaSsrKSB7CgkJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9ICZncGlvX2JhbmtbaV07CgkJdm9pZCBfX2lvbWVtICp3YWtlX2NsZWFyOwoJCXZvaWQgX19pb21lbSAqd2FrZV9zZXQ7CgoJCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CgkJY2FzZSBNRVRIT0RfR1BJT18xNjEwOgoJCQl3YWtlX2NsZWFyID0gYmFuay0+YmFzZSArIE9NQVAxNjEwX0dQSU9fQ0xFQVJfV0FLRVVQRU5BOwoJCQl3YWtlX3NldCA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX1NFVF9XQUtFVVBFTkE7CgkJCWJyZWFrOwoJCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQkJd2FrZV9jbGVhciA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX0NMRUFSX1dBS0VVUEVOQTsKCQkJd2FrZV9zZXQgPSBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19TRVRfV0FLRVVQRU5BOwoJCQlicmVhazsKCQlkZWZhdWx0OgoJCQljb250aW51ZTsKCQl9CgoJCXNwaW5fbG9jaygmYmFuay0+bG9jayk7CgkJX19yYXdfd3JpdGVsKDB4ZmZmZmZmZmYsIHdha2VfY2xlYXIpOwoJCV9fcmF3X3dyaXRlbChiYW5rLT5zYXZlZF93YWtldXAsIHdha2Vfc2V0KTsKCQlzcGluX3VubG9jaygmYmFuay0+bG9jayk7Cgl9CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBzdHJ1Y3Qgc3lzZGV2X2NsYXNzIG9tYXBfZ3Bpb19zeXNjbGFzcyA9IHsKCXNldF9rc2V0X25hbWUoImdwaW8iKSwKCS5zdXNwZW5kCT0gb21hcF9ncGlvX3N1c3BlbmQsCgkucmVzdW1lCQk9IG9tYXBfZ3Bpb19yZXN1bWUsCn07CgpzdGF0aWMgc3RydWN0IHN5c19kZXZpY2Ugb21hcF9ncGlvX2RldmljZSA9IHsKCS5pZAkJPSAwLAoJLmNscwkJPSAmb21hcF9ncGlvX3N5c2NsYXNzLAp9OwojZW5kaWYKCi8qCiAqIFRoaXMgbWF5IGdldCBjYWxsZWQgZWFybHkgZnJvbSBib2FyZCBzcGVjaWZpYyBpbml0CiAqIGZvciBib2FyZHMgdGhhdCBoYXZlIGludGVycnVwdHMgcm91dGVkIHZpYSBGUEdBLgogKi8KaW50IG9tYXBfZ3Bpb19pbml0KHZvaWQpCnsKCWlmICghaW5pdGlhbGl6ZWQpCgkJcmV0dXJuIF9vbWFwX2dwaW9faW5pdCgpOwoJZWxzZQoJCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IF9faW5pdCBvbWFwX2dwaW9fc3lzaW5pdCh2b2lkKQp7CglpbnQgcmV0ID0gMDsKCglpZiAoIWluaXRpYWxpemVkKQoJCXJldCA9IF9vbWFwX2dwaW9faW5pdCgpOwoKI2lmIGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDE2WFgpIHx8IGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDI0WFgpCglpZiAoY3B1X2lzX29tYXAxNnh4KCkgfHwgY3B1X2lzX29tYXAyNHh4KCkpIHsKCQlpZiAocmV0ID09IDApIHsKCQkJcmV0ID0gc3lzZGV2X2NsYXNzX3JlZ2lzdGVyKCZvbWFwX2dwaW9fc3lzY2xhc3MpOwoJCQlpZiAocmV0ID09IDApCgkJCQlyZXQgPSBzeXNkZXZfcmVnaXN0ZXIoJm9tYXBfZ3Bpb19kZXZpY2UpOwoJCX0KCX0KI2VuZGlmCgoJcmV0dXJuIHJldDsKfQoKRVhQT1JUX1NZTUJPTChvbWFwX3JlcXVlc3RfZ3Bpbyk7CkVYUE9SVF9TWU1CT0wob21hcF9mcmVlX2dwaW8pOwpFWFBPUlRfU1lNQk9MKG9tYXBfc2V0X2dwaW9fZGlyZWN0aW9uKTsKRVhQT1JUX1NZTUJPTChvbWFwX3NldF9ncGlvX2RhdGFvdXQpOwpFWFBPUlRfU1lNQk9MKG9tYXBfZ2V0X2dwaW9fZGF0YWluKTsKCmFyY2hfaW5pdGNhbGwob21hcF9ncGlvX3N5c2luaXQpOwo=