LyoKICogIGxpbnV4L2FyY2gvYXJtL3BsYXQtb21hcC9ncGlvLmMKICoKICogU3VwcG9ydCBmdW5jdGlvbnMgZm9yIE9NQVAgR1BJTwogKgogKiBDb3B5cmlnaHQgKEMpIDIwMDMtMjAwNSBOb2tpYSBDb3Jwb3JhdGlvbgogKiBXcml0dGVuIGJ5IEp1aGEgWXJq9mzkIDxqdWhhLnlyam9sYUBub2tpYS5jb20+CiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgdmVyc2lvbiAyIGFzCiAqIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLgogKi8KCiNpbmNsdWRlIDxsaW51eC9pbml0Lmg+CiNpbmNsdWRlIDxsaW51eC9tb2R1bGUuaD4KI2luY2x1ZGUgPGxpbnV4L2ludGVycnVwdC5oPgojaW5jbHVkZSA8bGludXgvc3lzZGV2Lmg+CiNpbmNsdWRlIDxsaW51eC9lcnIuaD4KI2luY2x1ZGUgPGxpbnV4L2Nsay5oPgoKI2luY2x1ZGUgPGFzbS9oYXJkd2FyZS5oPgojaW5jbHVkZSA8YXNtL2lycS5oPgojaW5jbHVkZSA8YXNtL2FyY2gvaXJxcy5oPgojaW5jbHVkZSA8YXNtL2FyY2gvZ3Bpby5oPgojaW5jbHVkZSA8YXNtL21hY2gvaXJxLmg+CgojaW5jbHVkZSA8YXNtL2lvLmg+CgovKgogKiBPTUFQMTUxMCBHUElPIHJlZ2lzdGVycwogKi8KI2RlZmluZSBPTUFQMTUxMF9HUElPX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweGZmZmNlMDAwCiNkZWZpbmUgT01BUDE1MTBfR1BJT19EQVRBX0lOUFVUCTB4MDAKI2RlZmluZSBPTUFQMTUxMF9HUElPX0RBVEFfT1VUUFVUCTB4MDQKI2RlZmluZSBPTUFQMTUxMF9HUElPX0RJUl9DT05UUk9MCTB4MDgKI2RlZmluZSBPTUFQMTUxMF9HUElPX0lOVF9DT05UUk9MCTB4MGMKI2RlZmluZSBPTUFQMTUxMF9HUElPX0lOVF9NQVNLCQkweDEwCiNkZWZpbmUgT01BUDE1MTBfR1BJT19JTlRfU1RBVFVTCTB4MTQKI2RlZmluZSBPTUFQMTUxMF9HUElPX1BJTl9DT05UUk9MCTB4MTgKCiNkZWZpbmUgT01BUDE1MTBfSUhfR1BJT19CQVNFCQk2NAoKLyoKICogT01BUDE2MTAgc3BlY2lmaWMgR1BJTyByZWdpc3RlcnMKICovCiNkZWZpbmUgT01BUDE2MTBfR1BJTzFfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmYmU0MDAKI2RlZmluZSBPTUFQMTYxMF9HUElPMl9CQVNFCQkodm9pZCBfX2lvbWVtICopMHhmZmZiZWMwMAojZGVmaW5lIE9NQVAxNjEwX0dQSU8zX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweGZmZmJiNDAwCiNkZWZpbmUgT01BUDE2MTBfR1BJTzRfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmYmJjMDAKI2RlZmluZSBPTUFQMTYxMF9HUElPX1JFVklTSU9OCQkweDAwMDAKI2RlZmluZSBPTUFQMTYxMF9HUElPX1NZU0NPTkZJRwkJMHgwMDEwCiNkZWZpbmUgT01BUDE2MTBfR1BJT19TWVNTVEFUVVMJCTB4MDAxNAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fSVJRU1RBVFVTMQkweDAwMTgKI2RlZmluZSBPTUFQMTYxMF9HUElPX0lSUUVOQUJMRTEJMHgwMDFjCiNkZWZpbmUgT01BUDE2MTBfR1BJT19XQUtFVVBFTkFCTEUJMHgwMDI4CiNkZWZpbmUgT01BUDE2MTBfR1BJT19EQVRBSU4JCTB4MDAyYwojZGVmaW5lIE9NQVAxNjEwX0dQSU9fREFUQU9VVAkJMHgwMDMwCiNkZWZpbmUgT01BUDE2MTBfR1BJT19ESVJFQ1RJT04JCTB4MDAzNAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fRURHRV9DVFJMMQkweDAwMzgKI2RlZmluZSBPTUFQMTYxMF9HUElPX0VER0VfQ1RSTDIJMHgwMDNjCiNkZWZpbmUgT01BUDE2MTBfR1BJT19DTEVBUl9JUlFFTkFCTEUxCTB4MDA5YwojZGVmaW5lIE9NQVAxNjEwX0dQSU9fQ0xFQVJfV0FLRVVQRU5BCTB4MDBhOAojZGVmaW5lIE9NQVAxNjEwX0dQSU9fQ0xFQVJfREFUQU9VVAkweDAwYjAKI2RlZmluZSBPTUFQMTYxMF9HUElPX1NFVF9JUlFFTkFCTEUxCTB4MDBkYwojZGVmaW5lIE9NQVAxNjEwX0dQSU9fU0VUX1dBS0VVUEVOQQkweDAwZTgKI2RlZmluZSBPTUFQMTYxMF9HUElPX1NFVF9EQVRBT1VUCTB4MDBmMAoKLyoKICogT01BUDczMCBzcGVjaWZpYyBHUElPIHJlZ2lzdGVycwogKi8KI2RlZmluZSBPTUFQNzMwX0dQSU8xX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweGZmZmJjMDAwCiNkZWZpbmUgT01BUDczMF9HUElPMl9CQVNFCQkodm9pZCBfX2lvbWVtICopMHhmZmZiYzgwMAojZGVmaW5lIE9NQVA3MzBfR1BJTzNfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmYmQwMDAKI2RlZmluZSBPTUFQNzMwX0dQSU80X0JBU0UJCSh2b2lkIF9faW9tZW0gKikweGZmZmJkODAwCiNkZWZpbmUgT01BUDczMF9HUElPNV9CQVNFCQkodm9pZCBfX2lvbWVtICopMHhmZmZiZTAwMAojZGVmaW5lIE9NQVA3MzBfR1BJTzZfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4ZmZmYmU4MDAKI2RlZmluZSBPTUFQNzMwX0dQSU9fREFUQV9JTlBVVAkJMHgwMAojZGVmaW5lIE9NQVA3MzBfR1BJT19EQVRBX09VVFBVVAkweDA0CiNkZWZpbmUgT01BUDczMF9HUElPX0RJUl9DT05UUk9MCTB4MDgKI2RlZmluZSBPTUFQNzMwX0dQSU9fSU5UX0NPTlRST0wJMHgwYwojZGVmaW5lIE9NQVA3MzBfR1BJT19JTlRfTUFTSwkJMHgxMAojZGVmaW5lIE9NQVA3MzBfR1BJT19JTlRfU1RBVFVTCQkweDE0CgovKgogKiBvbWFwMjR4eCBzcGVjaWZpYyBHUElPIHJlZ2lzdGVycwogKi8KI2RlZmluZSBPTUFQMjQyWF9HUElPMV9CQVNFCQkodm9pZCBfX2lvbWVtICopMHg0ODAxODAwMAojZGVmaW5lIE9NQVAyNDJYX0dQSU8yX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweDQ4MDFhMDAwCiNkZWZpbmUgT01BUDI0MlhfR1BJTzNfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4NDgwMWMwMDAKI2RlZmluZSBPTUFQMjQyWF9HUElPNF9CQVNFCQkodm9pZCBfX2lvbWVtICopMHg0ODAxZTAwMAoKI2RlZmluZSBPTUFQMjQzWF9HUElPMV9CQVNFCQkodm9pZCBfX2lvbWVtICopMHg0OTAwQzAwMAojZGVmaW5lIE9NQVAyNDNYX0dQSU8yX0JBU0UJCSh2b2lkIF9faW9tZW0gKikweDQ5MDBFMDAwCiNkZWZpbmUgT01BUDI0M1hfR1BJTzNfQkFTRQkJKHZvaWQgX19pb21lbSAqKTB4NDkwMTAwMDAKI2RlZmluZSBPTUFQMjQzWF9HUElPNF9CQVNFCQkodm9pZCBfX2lvbWVtICopMHg0OTAxMjAwMAojZGVmaW5lIE9NQVAyNDNYX0dQSU81X0JBU0UJCSh2b2lkIF9faW9tZW0gKikweDQ4MEI2MDAwCgojZGVmaW5lIE9NQVAyNFhYX0dQSU9fUkVWSVNJT04JCTB4MDAwMAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fU1lTQ09ORklHCQkweDAwMTAKI2RlZmluZSBPTUFQMjRYWF9HUElPX1NZU1NUQVRVUwkJMHgwMDE0CiNkZWZpbmUgT01BUDI0WFhfR1BJT19JUlFTVEFUVVMxCTB4MDAxOAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fSVJRU1RBVFVTMgkweDAwMjgKI2RlZmluZSBPTUFQMjRYWF9HUElPX0lSUUVOQUJMRTIJMHgwMDJjCiNkZWZpbmUgT01BUDI0WFhfR1BJT19JUlFFTkFCTEUxCTB4MDAxYwojZGVmaW5lIE9NQVAyNFhYX0dQSU9fQ1RSTAkJMHgwMDMwCiNkZWZpbmUgT01BUDI0WFhfR1BJT19PRQkJMHgwMDM0CiNkZWZpbmUgT01BUDI0WFhfR1BJT19EQVRBSU4JCTB4MDAzOAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fREFUQU9VVAkJMHgwMDNjCiNkZWZpbmUgT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDAJMHgwMDQwCiNkZWZpbmUgT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDEJMHgwMDQ0CiNkZWZpbmUgT01BUDI0WFhfR1BJT19SSVNJTkdERVRFQ1QJMHgwMDQ4CiNkZWZpbmUgT01BUDI0WFhfR1BJT19GQUxMSU5HREVURUNUCTB4MDA0YwojZGVmaW5lIE9NQVAyNFhYX0dQSU9fQ0xFQVJJUlFFTkFCTEUxCTB4MDA2MAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fU0VUSVJRRU5BQkxFMQkweDAwNjQKI2RlZmluZSBPTUFQMjRYWF9HUElPX0NMRUFSV0tVRU5BCTB4MDA4MAojZGVmaW5lIE9NQVAyNFhYX0dQSU9fU0VUV0tVRU5BCQkweDAwODQKI2RlZmluZSBPTUFQMjRYWF9HUElPX0NMRUFSREFUQU9VVAkweDAwOTAKI2RlZmluZSBPTUFQMjRYWF9HUElPX1NFVERBVEFPVVQJMHgwMDk0CgpzdHJ1Y3QgZ3Bpb19iYW5rIHsKCXZvaWQgX19pb21lbSAqYmFzZTsKCXUxNiBpcnE7Cgl1MTYgdmlydHVhbF9pcnFfc3RhcnQ7CglpbnQgbWV0aG9kOwoJdTMyIHJlc2VydmVkX21hcDsKI2lmIGRlZmluZWQgKENPTkZJR19BUkNIX09NQVAxNlhYKSB8fCBkZWZpbmVkIChDT05GSUdfQVJDSF9PTUFQMjRYWCkKCXUzMiBzdXNwZW5kX3dha2V1cDsKCXUzMiBzYXZlZF93YWtldXA7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCXUzMiBub25fd2FrZXVwX2dwaW9zOwoJdTMyIGVuYWJsZWRfbm9uX3dha2V1cF9ncGlvczsKCgl1MzIgc2F2ZWRfZGF0YWluOwoJdTMyIHNhdmVkX2ZhbGxpbmdkZXRlY3Q7Cgl1MzIgc2F2ZWRfcmlzaW5nZGV0ZWN0OwojZW5kaWYKCXNwaW5sb2NrX3QgbG9jazsKfTsKCiNkZWZpbmUgTUVUSE9EX01QVUlPCQkwCiNkZWZpbmUgTUVUSE9EX0dQSU9fMTUxMAkxCiNkZWZpbmUgTUVUSE9EX0dQSU9fMTYxMAkyCiNkZWZpbmUgTUVUSE9EX0dQSU9fNzMwCQkzCiNkZWZpbmUgTUVUSE9EX0dQSU9fMjRYWAk0CgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE2WFgKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgZ3Bpb19iYW5rXzE2MTBbNV0gPSB7Cgl7IE9NQVBfTVBVSU9fQkFTRSwgICAgIElOVF9NUFVJTywJICAgIElIX01QVUlPX0JBU0UsICAgICBNRVRIT0RfTVBVSU99LAoJeyBPTUFQMTYxMF9HUElPMV9CQVNFLCBJTlRfR1BJT19CQU5LMSwJICAgIElIX0dQSU9fQkFTRSwgICAgICBNRVRIT0RfR1BJT18xNjEwIH0sCgl7IE9NQVAxNjEwX0dQSU8yX0JBU0UsIElOVF8xNjEwX0dQSU9fQkFOSzIsIElIX0dQSU9fQkFTRSArIDE2LCBNRVRIT0RfR1BJT18xNjEwIH0sCgl7IE9NQVAxNjEwX0dQSU8zX0JBU0UsIElOVF8xNjEwX0dQSU9fQkFOSzMsIElIX0dQSU9fQkFTRSArIDMyLCBNRVRIT0RfR1BJT18xNjEwIH0sCgl7IE9NQVAxNjEwX0dQSU80X0JBU0UsIElOVF8xNjEwX0dQSU9fQkFOSzQsIElIX0dQSU9fQkFTRSArIDQ4LCBNRVRIT0RfR1BJT18xNjEwIH0sCn07CiNlbmRpZgoKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNVhYCnN0YXRpYyBzdHJ1Y3QgZ3Bpb19iYW5rIGdwaW9fYmFua18xNTEwWzJdID0gewoJeyBPTUFQX01QVUlPX0JBU0UsICAgIElOVF9NUFVJTywgICAgICBJSF9NUFVJT19CQVNFLCBNRVRIT0RfTVBVSU8gfSwKCXsgT01BUDE1MTBfR1BJT19CQVNFLCBJTlRfR1BJT19CQU5LMSwgSUhfR1BJT19CQVNFLCAgTUVUSE9EX0dQSU9fMTUxMCB9Cn07CiNlbmRpZgoKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgZ3Bpb19iYW5rXzczMFs3XSA9IHsKCXsgT01BUF9NUFVJT19CQVNFLCAgICAgSU5UXzczMF9NUFVJTywJICAgIElIX01QVUlPX0JBU0UsCU1FVEhPRF9NUFVJTyB9LAoJeyBPTUFQNzMwX0dQSU8xX0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzEsICBJSF9HUElPX0JBU0UsCU1FVEhPRF9HUElPXzczMCB9LAoJeyBPTUFQNzMwX0dQSU8yX0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzIsICBJSF9HUElPX0JBU0UgKyAzMiwJTUVUSE9EX0dQSU9fNzMwIH0sCgl7IE9NQVA3MzBfR1BJTzNfQkFTRSwgIElOVF83MzBfR1BJT19CQU5LMywgIElIX0dQSU9fQkFTRSArIDY0LAlNRVRIT0RfR1BJT183MzAgfSwKCXsgT01BUDczMF9HUElPNF9CQVNFLCAgSU5UXzczMF9HUElPX0JBTks0LCAgSUhfR1BJT19CQVNFICsgOTYsCU1FVEhPRF9HUElPXzczMCB9LAoJeyBPTUFQNzMwX0dQSU81X0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzUsICBJSF9HUElPX0JBU0UgKyAxMjgsIE1FVEhPRF9HUElPXzczMCB9LAoJeyBPTUFQNzMwX0dQSU82X0JBU0UsICBJTlRfNzMwX0dQSU9fQkFOSzYsICBJSF9HUElPX0JBU0UgKyAxNjAsIE1FVEhPRF9HUElPXzczMCB9LAp9OwojZW5kaWYKCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgZ3Bpb19iYW5rXzI0MnhbNF0gPSB7Cgl7IE9NQVAyNDJYX0dQSU8xX0JBU0UsIElOVF8yNFhYX0dQSU9fQkFOSzEsIElIX0dQSU9fQkFTRSwJTUVUSE9EX0dQSU9fMjRYWCB9LAoJeyBPTUFQMjQyWF9HUElPMl9CQVNFLCBJTlRfMjRYWF9HUElPX0JBTksyLCBJSF9HUElPX0JBU0UgKyAzMiwJTUVUSE9EX0dQSU9fMjRYWCB9LAoJeyBPTUFQMjQyWF9HUElPM19CQVNFLCBJTlRfMjRYWF9HUElPX0JBTkszLCBJSF9HUElPX0JBU0UgKyA2NCwJTUVUSE9EX0dQSU9fMjRYWCB9LAoJeyBPTUFQMjQyWF9HUElPNF9CQVNFLCBJTlRfMjRYWF9HUElPX0JBTks0LCBJSF9HUElPX0JBU0UgKyA5NiwJTUVUSE9EX0dQSU9fMjRYWCB9LAp9OwoKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgZ3Bpb19iYW5rXzI0M3hbNV0gPSB7Cgl7IE9NQVAyNDNYX0dQSU8xX0JBU0UsIElOVF8yNFhYX0dQSU9fQkFOSzEsIElIX0dQSU9fQkFTRSwJTUVUSE9EX0dQSU9fMjRYWCB9LAoJeyBPTUFQMjQzWF9HUElPMl9CQVNFLCBJTlRfMjRYWF9HUElPX0JBTksyLCBJSF9HUElPX0JBU0UgKyAzMiwJTUVUSE9EX0dQSU9fMjRYWCB9LAoJeyBPTUFQMjQzWF9HUElPM19CQVNFLCBJTlRfMjRYWF9HUElPX0JBTkszLCBJSF9HUElPX0JBU0UgKyA2NCwJTUVUSE9EX0dQSU9fMjRYWCB9LAoJeyBPTUFQMjQzWF9HUElPNF9CQVNFLCBJTlRfMjRYWF9HUElPX0JBTks0LCBJSF9HUElPX0JBU0UgKyA5NiwJTUVUSE9EX0dQSU9fMjRYWCB9LAoJeyBPTUFQMjQzWF9HUElPNV9CQVNFLCBJTlRfMjRYWF9HUElPX0JBTks1LCBJSF9HUElPX0JBU0UgKyAxMjgsIE1FVEhPRF9HUElPXzI0WFggfSwKfTsKCiNlbmRpZgoKc3RhdGljIHN0cnVjdCBncGlvX2JhbmsgKmdwaW9fYmFuazsKc3RhdGljIGludCBncGlvX2JhbmtfY291bnQ7CgpzdGF0aWMgaW5saW5lIHN0cnVjdCBncGlvX2JhbmsgKmdldF9ncGlvX2JhbmsoaW50IGdwaW8pCnsKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNVhYCglpZiAoY3B1X2lzX29tYXAxNXh4KCkpIHsKCQlpZiAoT01BUF9HUElPX0lTX01QVUlPKGdwaW8pKQoJCQlyZXR1cm4gJmdwaW9fYmFua1swXTsKCQlyZXR1cm4gJmdwaW9fYmFua1sxXTsKCX0KI2VuZGlmCiNpZiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNlhYKQoJaWYgKGNwdV9pc19vbWFwMTZ4eCgpKSB7CgkJaWYgKE9NQVBfR1BJT19JU19NUFVJTyhncGlvKSkKCQkJcmV0dXJuICZncGlvX2JhbmtbMF07CgkJcmV0dXJuICZncGlvX2JhbmtbMSArIChncGlvID4+IDQpXTsKCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQNzMwCglpZiAoY3B1X2lzX29tYXA3MzAoKSkgewoJCWlmIChPTUFQX0dQSU9fSVNfTVBVSU8oZ3BpbykpCgkJCXJldHVybiAmZ3Bpb19iYW5rWzBdOwoJCXJldHVybiAmZ3Bpb19iYW5rWzEgKyAoZ3BpbyA+PiA1KV07Cgl9CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWlmIChjcHVfaXNfb21hcDI0eHgoKSkKCQlyZXR1cm4gJmdwaW9fYmFua1tncGlvID4+IDVdOwojZW5kaWYKfQoKc3RhdGljIGlubGluZSBpbnQgZ2V0X2dwaW9faW5kZXgoaW50IGdwaW8pCnsKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCWlmIChjcHVfaXNfb21hcDczMCgpKQoJCXJldHVybiBncGlvICYgMHgxZjsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGNwdV9pc19vbWFwMjR4eCgpKQoJCXJldHVybiBncGlvICYgMHgxZjsKI2VuZGlmCglyZXR1cm4gZ3BpbyAmIDB4MGY7Cn0KCnN0YXRpYyBpbmxpbmUgaW50IGdwaW9fdmFsaWQoaW50IGdwaW8pCnsKCWlmIChncGlvIDwgMCkKCQlyZXR1cm4gLTE7CiNpZm5kZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWlmIChPTUFQX0dQSU9fSVNfTVBVSU8oZ3BpbykpIHsKCQlpZiAoZ3BpbyA+PSBPTUFQX01BWF9HUElPX0xJTkVTICsgMTYpCgkJCXJldHVybiAtMTsKCQlyZXR1cm4gMDsKCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJaWYgKGNwdV9pc19vbWFwMTV4eCgpICYmIGdwaW8gPCAxNikKCQlyZXR1cm4gMDsKI2VuZGlmCiNpZiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNlhYKQoJaWYgKChjcHVfaXNfb21hcDE2eHgoKSkgJiYgZ3BpbyA8IDY0KQoJCXJldHVybiAwOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCWlmIChjcHVfaXNfb21hcDczMCgpICYmIGdwaW8gPCAxOTIpCgkJcmV0dXJuIDA7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWlmIChjcHVfaXNfb21hcDI0eHgoKSAmJiBncGlvIDwgMTI4KQoJCXJldHVybiAwOwojZW5kaWYKCXJldHVybiAtMTsKfQoKc3RhdGljIGludCBjaGVja19ncGlvKGludCBncGlvKQp7CglpZiAodW5saWtlbHkoZ3Bpb192YWxpZChncGlvKSkgPCAwKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJvbWFwLWdwaW86IGludmFsaWQgR1BJTyAlZFxuIiwgZ3Bpbyk7CgkJZHVtcF9zdGFjaygpOwoJCXJldHVybiAtMTsKCX0KCXJldHVybiAwOwp9CgpzdGF0aWMgdm9pZCBfc2V0X2dwaW9fZGlyZWN0aW9uKHN0cnVjdCBncGlvX2JhbmsgKmJhbmssIGludCBncGlvLCBpbnQgaXNfaW5wdXQpCnsKCXZvaWQgX19pb21lbSAqcmVnID0gYmFuay0+YmFzZTsKCXUzMiBsOwoKCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMQoJY2FzZSBNRVRIT0RfTVBVSU86CgkJcmVnICs9IE9NQVBfTVBVSU9fSU9fQ05UTDsKCQlicmVhazsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJY2FzZSBNRVRIT0RfR1BJT18xNTEwOgoJCXJlZyArPSBPTUFQMTUxMF9HUElPX0RJUl9DT05UUk9MOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNlhYCgljYXNlIE1FVEhPRF9HUElPXzE2MTA6CgkJcmVnICs9IE9NQVAxNjEwX0dQSU9fRElSRUNUSU9OOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCWNhc2UgTUVUSE9EX0dQSU9fNzMwOgoJCXJlZyArPSBPTUFQNzMwX0dQSU9fRElSX0NPTlRST0w7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQlyZWcgKz0gT01BUDI0WFhfR1BJT19PRTsKCQlicmVhazsKI2VuZGlmCglkZWZhdWx0OgoJCVdBUk5fT04oMSk7CgkJcmV0dXJuOwoJfQoJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CglpZiAoaXNfaW5wdXQpCgkJbCB8PSAxIDw8IGdwaW87CgllbHNlCgkJbCAmPSB+KDEgPDwgZ3Bpbyk7CglfX3Jhd193cml0ZWwobCwgcmVnKTsKfQoKdm9pZCBvbWFwX3NldF9ncGlvX2RpcmVjdGlvbihpbnQgZ3BpbywgaW50IGlzX2lucHV0KQp7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rOwoKCWlmIChjaGVja19ncGlvKGdwaW8pIDwgMCkKCQlyZXR1cm47CgliYW5rID0gZ2V0X2dwaW9fYmFuayhncGlvKTsKCXNwaW5fbG9jaygmYmFuay0+bG9jayk7Cglfc2V0X2dwaW9fZGlyZWN0aW9uKGJhbmssIGdldF9ncGlvX2luZGV4KGdwaW8pLCBpc19pbnB1dCk7CglzcGluX3VubG9jaygmYmFuay0+bG9jayk7Cn0KCnN0YXRpYyB2b2lkIF9zZXRfZ3Bpb19kYXRhb3V0KHN0cnVjdCBncGlvX2JhbmsgKmJhbmssIGludCBncGlvLCBpbnQgZW5hYmxlKQp7Cgl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2U7Cgl1MzIgbCA9IDA7CgoJc3dpdGNoIChiYW5rLT5tZXRob2QpIHsKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxCgljYXNlIE1FVEhPRF9NUFVJTzoKCQlyZWcgKz0gT01BUF9NUFVJT19PVVRQVVQ7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKGVuYWJsZSkKCQkJbCB8PSAxIDw8IGdwaW87CgkJZWxzZQoJCQlsICY9IH4oMSA8PCBncGlvKTsKCQlicmVhazsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJY2FzZSBNRVRIT0RfR1BJT18xNTEwOgoJCXJlZyArPSBPTUFQMTUxMF9HUElPX0RBVEFfT1VUUFVUOwoJCWwgPSBfX3Jhd19yZWFkbChyZWcpOwoJCWlmIChlbmFibGUpCgkJCWwgfD0gMSA8PCBncGlvOwoJCWVsc2UKCQkJbCAmPSB+KDEgPDwgZ3Bpbyk7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE2WFgKCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQlpZiAoZW5hYmxlKQoJCQlyZWcgKz0gT01BUDE2MTBfR1BJT19TRVRfREFUQU9VVDsKCQllbHNlCgkJCXJlZyArPSBPTUFQMTYxMF9HUElPX0NMRUFSX0RBVEFPVVQ7CgkJbCA9IDEgPDwgZ3BpbzsKCQlicmVhazsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQNzMwCgljYXNlIE1FVEhPRF9HUElPXzczMDoKCQlyZWcgKz0gT01BUDczMF9HUElPX0RBVEFfT1VUUFVUOwoJCWwgPSBfX3Jhd19yZWFkbChyZWcpOwoJCWlmIChlbmFibGUpCgkJCWwgfD0gMSA8PCBncGlvOwoJCWVsc2UKCQkJbCAmPSB+KDEgPDwgZ3Bpbyk7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQlpZiAoZW5hYmxlKQoJCQlyZWcgKz0gT01BUDI0WFhfR1BJT19TRVREQVRBT1VUOwoJCWVsc2UKCQkJcmVnICs9IE9NQVAyNFhYX0dQSU9fQ0xFQVJEQVRBT1VUOwoJCWwgPSAxIDw8IGdwaW87CgkJYnJlYWs7CiNlbmRpZgoJZGVmYXVsdDoKCQlXQVJOX09OKDEpOwoJCXJldHVybjsKCX0KCV9fcmF3X3dyaXRlbChsLCByZWcpOwp9Cgp2b2lkIG9tYXBfc2V0X2dwaW9fZGF0YW91dChpbnQgZ3BpbywgaW50IGVuYWJsZSkKewoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCglpZiAoY2hlY2tfZ3BpbyhncGlvKSA8IDApCgkJcmV0dXJuOwoJYmFuayA9IGdldF9ncGlvX2JhbmsoZ3Bpbyk7CglzcGluX2xvY2soJmJhbmstPmxvY2spOwoJX3NldF9ncGlvX2RhdGFvdXQoYmFuaywgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIGVuYWJsZSk7CglzcGluX3VubG9jaygmYmFuay0+bG9jayk7Cn0KCmludCBvbWFwX2dldF9ncGlvX2RhdGFpbihpbnQgZ3BpbykKewoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCXZvaWQgX19pb21lbSAqcmVnOwoKCWlmIChjaGVja19ncGlvKGdwaW8pIDwgMCkKCQlyZXR1cm4gLUVJTlZBTDsKCWJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoJcmVnID0gYmFuay0+YmFzZTsKCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMQoJY2FzZSBNRVRIT0RfTVBVSU86CgkJcmVnICs9IE9NQVBfTVBVSU9fSU5QVVRfTEFUQ0g7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE1WFgKCWNhc2UgTUVUSE9EX0dQSU9fMTUxMDoKCQlyZWcgKz0gT01BUDE1MTBfR1BJT19EQVRBX0lOUFVUOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNlhYCgljYXNlIE1FVEhPRF9HUElPXzE2MTA6CgkJcmVnICs9IE9NQVAxNjEwX0dQSU9fREFUQUlOOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCWNhc2UgTUVUSE9EX0dQSU9fNzMwOgoJCXJlZyArPSBPTUFQNzMwX0dQSU9fREFUQV9JTlBVVDsKCQlicmVhazsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJY2FzZSBNRVRIT0RfR1BJT18yNFhYOgoJCXJlZyArPSBPTUFQMjRYWF9HUElPX0RBVEFJTjsKCQlicmVhazsKI2VuZGlmCglkZWZhdWx0OgoJCXJldHVybiAtRUlOVkFMOwoJfQoJcmV0dXJuIChfX3Jhd19yZWFkbChyZWcpCgkJCSYgKDEgPDwgZ2V0X2dwaW9faW5kZXgoZ3BpbykpKSAhPSAwOwp9CgojZGVmaW5lIE1PRF9SRUdfQklUKHJlZywgYml0X21hc2ssIHNldCkJXApkbyB7CVwKCWludCBsID0gX19yYXdfcmVhZGwoYmFzZSArIHJlZyk7IFwKCWlmIChzZXQpIGwgfD0gYml0X21hc2s7IFwKCWVsc2UgbCAmPSB+Yml0X21hc2s7IFwKCV9fcmF3X3dyaXRlbChsLCBiYXNlICsgcmVnKTsgXAp9IHdoaWxlKDApCgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKc3RhdGljIGlubGluZSB2b2lkIHNldF8yNHh4X2dwaW9fdHJpZ2dlcmluZyhzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rLCBpbnQgZ3BpbywgaW50IHRyaWdnZXIpCnsKCXZvaWQgX19pb21lbSAqYmFzZSA9IGJhbmstPmJhc2U7Cgl1MzIgZ3Bpb19iaXQgPSAxIDw8IGdwaW87CgoJTU9EX1JFR19CSVQoT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDAsIGdwaW9fYml0LAoJCXRyaWdnZXIgJiBfX0lSUVRfTE9XTFZMKTsKCU1PRF9SRUdfQklUKE9NQVAyNFhYX0dQSU9fTEVWRUxERVRFQ1QxLCBncGlvX2JpdCwKCQl0cmlnZ2VyICYgX19JUlFUX0hJR0hMVkwpOwoJTU9EX1JFR19CSVQoT01BUDI0WFhfR1BJT19SSVNJTkdERVRFQ1QsIGdwaW9fYml0LAoJCXRyaWdnZXIgJiBfX0lSUVRfUklTRURHRSk7CglNT0RfUkVHX0JJVChPTUFQMjRYWF9HUElPX0ZBTExJTkdERVRFQ1QsIGdwaW9fYml0LAoJCXRyaWdnZXIgJiBfX0lSUVRfRkFMRURHRSk7CglpZiAobGlrZWx5KCEoYmFuay0+bm9uX3dha2V1cF9ncGlvcyAmIGdwaW9fYml0KSkpIHsKCQlpZiAodHJpZ2dlciAhPSAwKQoJCQlfX3Jhd193cml0ZWwoMSA8PCBncGlvLCBiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19TRVRXS1VFTkEpOwoJCWVsc2UKCQkJX19yYXdfd3JpdGVsKDEgPDwgZ3BpbywgYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fQ0xFQVJXS1VFTkEpOwoJfSBlbHNlIHsKCQlpZiAodHJpZ2dlciAhPSAwKQoJCQliYW5rLT5lbmFibGVkX25vbl93YWtldXBfZ3Bpb3MgfD0gZ3Bpb19iaXQ7CgkJZWxzZQoJCQliYW5rLT5lbmFibGVkX25vbl93YWtldXBfZ3Bpb3MgJj0gfmdwaW9fYml0OwoJfQoJLyogRklYTUU6IFBvc3NpYmx5IGRvICdzZXRfaXJxX2hhbmRsZXIoaiwgaGFuZGxlX2xldmVsX2lycSknIGlmIG9ubHkgbGV2ZWwKCSAqIHRyaWdnZXJpbmcgcmVxdWVzdGVkLiAqLwp9CiNlbmRpZgoKc3RhdGljIGludCBfc2V0X2dwaW9fdHJpZ2dlcmluZyhzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rLCBpbnQgZ3BpbywgaW50IHRyaWdnZXIpCnsKCXZvaWQgX19pb21lbSAqcmVnID0gYmFuay0+YmFzZTsKCXUzMiBsID0gMDsKCglzd2l0Y2ggKGJhbmstPm1ldGhvZCkgewojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDEKCWNhc2UgTUVUSE9EX01QVUlPOgoJCXJlZyArPSBPTUFQX01QVUlPX0dQSU9fSU5UX0VER0U7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKHRyaWdnZXIgJiBfX0lSUVRfUklTRURHRSkKCQkJbCB8PSAxIDw8IGdwaW87CgkJZWxzZSBpZiAodHJpZ2dlciAmIF9fSVJRVF9GQUxFREdFKQoJCQlsICY9IH4oMSA8PCBncGlvKTsKCQllbHNlCgkJCWdvdG8gYmFkOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNVhYCgljYXNlIE1FVEhPRF9HUElPXzE1MTA6CgkJcmVnICs9IE9NQVAxNTEwX0dQSU9fSU5UX0NPTlRST0w7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKHRyaWdnZXIgJiBfX0lSUVRfUklTRURHRSkKCQkJbCB8PSAxIDw8IGdwaW87CgkJZWxzZSBpZiAodHJpZ2dlciAmIF9fSVJRVF9GQUxFREdFKQoJCQlsICY9IH4oMSA8PCBncGlvKTsKCQllbHNlCgkJCWdvdG8gYmFkOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNlhYCgljYXNlIE1FVEhPRF9HUElPXzE2MTA6CgkJaWYgKGdwaW8gJiAweDA4KQoJCQlyZWcgKz0gT01BUDE2MTBfR1BJT19FREdFX0NUUkwyOwoJCWVsc2UKCQkJcmVnICs9IE9NQVAxNjEwX0dQSU9fRURHRV9DVFJMMTsKCQlncGlvICY9IDB4MDc7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJbCAmPSB+KDMgPDwgKGdwaW8gPDwgMSkpOwoJCWlmICh0cmlnZ2VyICYgX19JUlFUX1JJU0VER0UpCgkJCWwgfD0gMiA8PCAoZ3BpbyA8PCAxKTsKCQlpZiAodHJpZ2dlciAmIF9fSVJRVF9GQUxFREdFKQoJCQlsIHw9IDEgPDwgKGdwaW8gPDwgMSk7CgkJaWYgKHRyaWdnZXIpCgkJCS8qIEVuYWJsZSB3YWtlLXVwIGR1cmluZyBpZGxlIGZvciBkeW5hbWljIHRpY2sgKi8KCQkJX19yYXdfd3JpdGVsKDEgPDwgZ3BpbywgYmFuay0+YmFzZSArIE9NQVAxNjEwX0dQSU9fU0VUX1dBS0VVUEVOQSk7CgkJZWxzZQoJCQlfX3Jhd193cml0ZWwoMSA8PCBncGlvLCBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19DTEVBUl9XQUtFVVBFTkEpOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVA3MzAKCWNhc2UgTUVUSE9EX0dQSU9fNzMwOgoJCXJlZyArPSBPTUFQNzMwX0dQSU9fSU5UX0NPTlRST0w7CgkJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CgkJaWYgKHRyaWdnZXIgJiBfX0lSUVRfUklTRURHRSkKCQkJbCB8PSAxIDw8IGdwaW87CgkJZWxzZSBpZiAodHJpZ2dlciAmIF9fSVJRVF9GQUxFREdFKQoJCQlsICY9IH4oMSA8PCBncGlvKTsKCQllbHNlCgkJCWdvdG8gYmFkOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAyNFhYCgljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJc2V0XzI0eHhfZ3Bpb190cmlnZ2VyaW5nKGJhbmssIGdwaW8sIHRyaWdnZXIpOwoJCWJyZWFrOwojZW5kaWYKCWRlZmF1bHQ6CgkJZ290byBiYWQ7Cgl9CglfX3Jhd193cml0ZWwobCwgcmVnKTsKCXJldHVybiAwOwpiYWQ6CglyZXR1cm4gLUVJTlZBTDsKfQoKc3RhdGljIGludCBncGlvX2lycV90eXBlKHVuc2lnbmVkIGlycSwgdW5zaWduZWQgdHlwZSkKewoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCXVuc2lnbmVkIGdwaW87CglpbnQgcmV0dmFsOwoKCWlmICghY3B1X2lzX29tYXAyNHh4KCkgJiYgaXJxID4gSUhfTVBVSU9fQkFTRSkKCQlncGlvID0gT01BUF9NUFVJTyhpcnEgLSBJSF9NUFVJT19CQVNFKTsKCWVsc2UKCQlncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOwoKCWlmIChjaGVja19ncGlvKGdwaW8pIDwgMCkKCQlyZXR1cm4gLUVJTlZBTDsKCglpZiAodHlwZSAmIH5JUlFfVFlQRV9TRU5TRV9NQVNLKQoJCXJldHVybiAtRUlOVkFMOwoKCS8qIE9NQVAxIGFsbG93cyBvbmx5IG9ubHkgZWRnZSB0cmlnZ2VyaW5nICovCglpZiAoIWNwdV9pc19vbWFwMjR4eCgpCgkJCSYmICh0eXBlICYgKElSUV9UWVBFX0xFVkVMX0xPV3xJUlFfVFlQRV9MRVZFTF9ISUdIKSkpCgkJcmV0dXJuIC1FSU5WQUw7CgoJYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CglzcGluX2xvY2soJmJhbmstPmxvY2spOwoJcmV0dmFsID0gX3NldF9ncGlvX3RyaWdnZXJpbmcoYmFuaywgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIHR5cGUpOwoJaWYgKHJldHZhbCA9PSAwKSB7CgkJaXJxX2Rlc2NbaXJxXS5zdGF0dXMgJj0gfklSUV9UWVBFX1NFTlNFX01BU0s7CgkJaXJxX2Rlc2NbaXJxXS5zdGF0dXMgfD0gdHlwZTsKCX0KCXNwaW5fdW5sb2NrKCZiYW5rLT5sb2NrKTsKCXJldHVybiByZXR2YWw7Cn0KCnN0YXRpYyB2b2lkIF9jbGVhcl9ncGlvX2lycWJhbmsoc3RydWN0IGdwaW9fYmFuayAqYmFuaywgaW50IGdwaW9fbWFzaykKewoJdm9pZCBfX2lvbWVtICpyZWcgPSBiYW5rLT5iYXNlOwoKCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMQoJY2FzZSBNRVRIT0RfTVBVSU86CgkJLyogTVBVSU8gaXJxc3RhdHVzIGlzIHJlc2V0IGJ5IHJlYWRpbmcgdGhlIHN0YXR1cyByZWdpc3RlciwKCQkgKiBzbyBkbyBub3RoaW5nIGhlcmUgKi8KCQlyZXR1cm47CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE1WFgKCWNhc2UgTUVUSE9EX0dQSU9fMTUxMDoKCQlyZWcgKz0gT01BUDE1MTBfR1BJT19JTlRfU1RBVFVTOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNlhYCgljYXNlIE1FVEhPRF9HUElPXzE2MTA6CgkJcmVnICs9IE9NQVAxNjEwX0dQSU9fSVJRU1RBVFVTMTsKCQlicmVhazsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQNzMwCgljYXNlIE1FVEhPRF9HUElPXzczMDoKCQlyZWcgKz0gT01BUDczMF9HUElPX0lOVF9TVEFUVVM7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQlyZWcgKz0gT01BUDI0WFhfR1BJT19JUlFTVEFUVVMxOwoJCWJyZWFrOwojZW5kaWYKCWRlZmF1bHQ6CgkJV0FSTl9PTigxKTsKCQlyZXR1cm47Cgl9CglfX3Jhd193cml0ZWwoZ3Bpb19tYXNrLCByZWcpOwoKCS8qIFdvcmthcm91bmQgZm9yIGNsZWFyaW5nIERTUCBHUElPIGludGVycnVwdHMgdG8gYWxsb3cgcmV0ZW50aW9uICovCglpZiAoY3B1X2lzX29tYXAyNDIwKCkpCgkJX19yYXdfd3JpdGVsKGdwaW9fbWFzaywgYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fSVJRU1RBVFVTMik7Cn0KCnN0YXRpYyBpbmxpbmUgdm9pZCBfY2xlYXJfZ3Bpb19pcnFzdGF0dXMoc3RydWN0IGdwaW9fYmFuayAqYmFuaywgaW50IGdwaW8pCnsKCV9jbGVhcl9ncGlvX2lycWJhbmsoYmFuaywgMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSk7Cn0KCnN0YXRpYyB1MzIgX2dldF9ncGlvX2lycWJhbmtfbWFzayhzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rKQp7Cgl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2U7CglpbnQgaW52ID0gMDsKCXUzMiBsOwoJdTMyIG1hc2s7CgoJc3dpdGNoIChiYW5rLT5tZXRob2QpIHsKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxCgljYXNlIE1FVEhPRF9NUFVJTzoKCQlyZWcgKz0gT01BUF9NUFVJT19HUElPX01BU0tJVDsKCQltYXNrID0gMHhmZmZmOwoJCWludiA9IDE7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE1WFgKCWNhc2UgTUVUSE9EX0dQSU9fMTUxMDoKCQlyZWcgKz0gT01BUDE1MTBfR1BJT19JTlRfTUFTSzsKCQltYXNrID0gMHhmZmZmOwoJCWludiA9IDE7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE2WFgKCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQlyZWcgKz0gT01BUDE2MTBfR1BJT19JUlFFTkFCTEUxOwoJCW1hc2sgPSAweGZmZmY7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDczMAoJY2FzZSBNRVRIT0RfR1BJT183MzA6CgkJcmVnICs9IE9NQVA3MzBfR1BJT19JTlRfTUFTSzsKCQltYXNrID0gMHhmZmZmZmZmZjsKCQlpbnYgPSAxOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAyNFhYCgljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJcmVnICs9IE9NQVAyNFhYX0dQSU9fSVJRRU5BQkxFMTsKCQltYXNrID0gMHhmZmZmZmZmZjsKCQlicmVhazsKI2VuZGlmCglkZWZhdWx0OgoJCVdBUk5fT04oMSk7CgkJcmV0dXJuIDA7Cgl9CgoJbCA9IF9fcmF3X3JlYWRsKHJlZyk7CglpZiAoaW52KQoJCWwgPSB+bDsKCWwgJj0gbWFzazsKCXJldHVybiBsOwp9CgpzdGF0aWMgdm9pZCBfZW5hYmxlX2dwaW9faXJxYmFuayhzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rLCBpbnQgZ3Bpb19tYXNrLCBpbnQgZW5hYmxlKQp7Cgl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2U7Cgl1MzIgbDsKCglzd2l0Y2ggKGJhbmstPm1ldGhvZCkgewojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDEKCWNhc2UgTUVUSE9EX01QVUlPOgoJCXJlZyArPSBPTUFQX01QVUlPX0dQSU9fTUFTS0lUOwoJCWwgPSBfX3Jhd19yZWFkbChyZWcpOwoJCWlmIChlbmFibGUpCgkJCWwgJj0gfihncGlvX21hc2spOwoJCWVsc2UKCQkJbCB8PSBncGlvX21hc2s7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE1WFgKCWNhc2UgTUVUSE9EX0dQSU9fMTUxMDoKCQlyZWcgKz0gT01BUDE1MTBfR1BJT19JTlRfTUFTSzsKCQlsID0gX19yYXdfcmVhZGwocmVnKTsKCQlpZiAoZW5hYmxlKQoJCQlsICY9IH4oZ3Bpb19tYXNrKTsKCQllbHNlCgkJCWwgfD0gZ3Bpb19tYXNrOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNlhYCgljYXNlIE1FVEhPRF9HUElPXzE2MTA6CgkJaWYgKGVuYWJsZSkKCQkJcmVnICs9IE9NQVAxNjEwX0dQSU9fU0VUX0lSUUVOQUJMRTE7CgkJZWxzZQoJCQlyZWcgKz0gT01BUDE2MTBfR1BJT19DTEVBUl9JUlFFTkFCTEUxOwoJCWwgPSBncGlvX21hc2s7CgkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDczMAoJY2FzZSBNRVRIT0RfR1BJT183MzA6CgkJcmVnICs9IE9NQVA3MzBfR1BJT19JTlRfTUFTSzsKCQlsID0gX19yYXdfcmVhZGwocmVnKTsKCQlpZiAoZW5hYmxlKQoJCQlsICY9IH4oZ3Bpb19tYXNrKTsKCQllbHNlCgkJCWwgfD0gZ3Bpb19tYXNrOwoJCWJyZWFrOwojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAyNFhYCgljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJaWYgKGVuYWJsZSkKCQkJcmVnICs9IE9NQVAyNFhYX0dQSU9fU0VUSVJRRU5BQkxFMTsKCQllbHNlCgkJCXJlZyArPSBPTUFQMjRYWF9HUElPX0NMRUFSSVJRRU5BQkxFMTsKCQlsID0gZ3Bpb19tYXNrOwoJCWJyZWFrOwojZW5kaWYKCWRlZmF1bHQ6CgkJV0FSTl9PTigxKTsKCQlyZXR1cm47Cgl9CglfX3Jhd193cml0ZWwobCwgcmVnKTsKfQoKc3RhdGljIGlubGluZSB2b2lkIF9zZXRfZ3Bpb19pcnFlbmFibGUoc3RydWN0IGdwaW9fYmFuayAqYmFuaywgaW50IGdwaW8sIGludCBlbmFibGUpCnsKCV9lbmFibGVfZ3Bpb19pcnFiYW5rKGJhbmssIDEgPDwgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIGVuYWJsZSk7Cn0KCi8qCiAqIE5vdGUgdGhhdCBFTkFXQUtFVVAgbmVlZHMgdG8gYmUgZW5hYmxlZCBpbiBHUElPX1NZU0NPTkZJRyByZWdpc3Rlci4KICogMTUxMCBkb2VzIG5vdCBzZWVtIHRvIGhhdmUgYSB3YWtlLXVwIHJlZ2lzdGVyLiBJZiBKVEFHIGlzIGNvbm5lY3RlZAogKiB0byB0aGUgdGFyZ2V0LCBzeXN0ZW0gd2lsbCB3YWtlIHVwIGFsd2F5cyBvbiBHUElPIGV2ZW50cy4gV2hpbGUKICogc3lzdGVtIGlzIHJ1bm5pbmcgYWxsIHJlZ2lzdGVyZWQgR1BJTyBpbnRlcnJ1cHRzIG5lZWQgdG8gaGF2ZSB3YWtlLXVwCiAqIGVuYWJsZWQuIFdoZW4gc3lzdGVtIGlzIHN1c3BlbmRlZCwgb25seSBzZWxlY3RlZCBHUElPIGludGVycnVwdHMgbmVlZAogKiB0byBoYXZlIHdha2UtdXAgZW5hYmxlZC4KICovCnN0YXRpYyBpbnQgX3NldF9ncGlvX3dha2V1cChzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rLCBpbnQgZ3BpbywgaW50IGVuYWJsZSkKewoJc3dpdGNoIChiYW5rLT5tZXRob2QpIHsKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNlhYCgljYXNlIE1FVEhPRF9NUFVJTzoKCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQlzcGluX2xvY2soJmJhbmstPmxvY2spOwoJCWlmIChlbmFibGUpIHsKCQkJYmFuay0+c3VzcGVuZF93YWtldXAgfD0gKDEgPDwgZ3Bpbyk7CgkJCWVuYWJsZV9pcnFfd2FrZShiYW5rLT5pcnEpOwoJCX0gZWxzZSB7CgkJCWRpc2FibGVfaXJxX3dha2UoYmFuay0+aXJxKTsKCQkJYmFuay0+c3VzcGVuZF93YWtldXAgJj0gfigxIDw8IGdwaW8pOwoJCX0KCQlzcGluX3VubG9jaygmYmFuay0+bG9jayk7CgkJcmV0dXJuIDA7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQlpZiAoYmFuay0+bm9uX3dha2V1cF9ncGlvcyAmICgxIDw8IGdwaW8pKSB7CgkJCXByaW50ayhLRVJOX0VSUiAiVW5hYmxlIHRvIG1vZGlmeSB3YWtldXAgb24gIgoJCQkJCSJub24td2FrZXVwIEdQSU8lZFxuIiwKCQkJCQkoYmFuayAtIGdwaW9fYmFuaykgKiAzMiArIGdwaW8pOwoJCQlyZXR1cm4gLUVJTlZBTDsKCQl9CgkJc3Bpbl9sb2NrKCZiYW5rLT5sb2NrKTsKCQlpZiAoZW5hYmxlKSB7CgkJCWJhbmstPnN1c3BlbmRfd2FrZXVwIHw9ICgxIDw8IGdwaW8pOwoJCQllbmFibGVfaXJxX3dha2UoYmFuay0+aXJxKTsKCQl9IGVsc2UgewoJCQlkaXNhYmxlX2lycV93YWtlKGJhbmstPmlycSk7CgkJCWJhbmstPnN1c3BlbmRfd2FrZXVwICY9IH4oMSA8PCBncGlvKTsKCQl9CgkJc3Bpbl91bmxvY2soJmJhbmstPmxvY2spOwoJCXJldHVybiAwOwojZW5kaWYKCWRlZmF1bHQ6CgkJcHJpbnRrKEtFUk5fRVJSICJDYW4ndCBlbmFibGUgR1BJTyB3YWtldXAgZm9yIG1ldGhvZCAlaVxuIiwKCQkgICAgICAgYmFuay0+bWV0aG9kKTsKCQlyZXR1cm4gLUVJTlZBTDsKCX0KfQoKc3RhdGljIHZvaWQgX3Jlc2V0X2dwaW8oc3RydWN0IGdwaW9fYmFuayAqYmFuaywgaW50IGdwaW8pCnsKCV9zZXRfZ3Bpb19kaXJlY3Rpb24oYmFuaywgZ2V0X2dwaW9faW5kZXgoZ3BpbyksIDEpOwoJX3NldF9ncGlvX2lycWVuYWJsZShiYW5rLCBncGlvLCAwKTsKCV9jbGVhcl9ncGlvX2lycXN0YXR1cyhiYW5rLCBncGlvKTsKCV9zZXRfZ3Bpb190cmlnZ2VyaW5nKGJhbmssIGdldF9ncGlvX2luZGV4KGdwaW8pLCBJUlFUX05PRURHRSk7Cn0KCi8qIFVzZSBkaXNhYmxlX2lycV93YWtlKCkgYW5kIGVuYWJsZV9pcnFfd2FrZSgpIGZ1bmN0aW9ucyBmcm9tIGRyaXZlcnMgKi8Kc3RhdGljIGludCBncGlvX3dha2VfZW5hYmxlKHVuc2lnbmVkIGludCBpcnEsIHVuc2lnbmVkIGludCBlbmFibGUpCnsKCXVuc2lnbmVkIGludCBncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOwoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCWludCByZXR2YWw7CgoJaWYgKGNoZWNrX2dwaW8oZ3BpbykgPCAwKQoJCXJldHVybiAtRU5PREVWOwoJYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CglyZXR2YWwgPSBfc2V0X2dwaW9fd2FrZXVwKGJhbmssIGdldF9ncGlvX2luZGV4KGdwaW8pLCBlbmFibGUpOwoKCXJldHVybiByZXR2YWw7Cn0KCmludCBvbWFwX3JlcXVlc3RfZ3BpbyhpbnQgZ3BpbykKewoJc3RydWN0IGdwaW9fYmFuayAqYmFuazsKCglpZiAoY2hlY2tfZ3BpbyhncGlvKSA8IDApCgkJcmV0dXJuIC1FSU5WQUw7CgoJYmFuayA9IGdldF9ncGlvX2JhbmsoZ3Bpbyk7CglzcGluX2xvY2soJmJhbmstPmxvY2spOwoJaWYgKHVubGlrZWx5KGJhbmstPnJlc2VydmVkX21hcCAmICgxIDw8IGdldF9ncGlvX2luZGV4KGdwaW8pKSkpIHsKCQlwcmludGsoS0VSTl9FUlIgIm9tYXAtZ3BpbzogR1BJTyAlZCBpcyBhbHJlYWR5IHJlc2VydmVkIVxuIiwgZ3Bpbyk7CgkJZHVtcF9zdGFjaygpOwoJCXNwaW5fdW5sb2NrKCZiYW5rLT5sb2NrKTsKCQlyZXR1cm4gLTE7Cgl9CgliYW5rLT5yZXNlcnZlZF9tYXAgfD0gKDEgPDwgZ2V0X2dwaW9faW5kZXgoZ3BpbykpOwoKCS8qIFNldCB0cmlnZ2VyIHRvIG5vbmUuIFlvdSBuZWVkIHRvIGVuYWJsZSB0aGUgZGVzaXJlZCB0cmlnZ2VyIHdpdGgKCSAqIHJlcXVlc3RfaXJxKCkgb3Igc2V0X2lycV90eXBlKCkuCgkgKi8KCV9zZXRfZ3Bpb190cmlnZ2VyaW5nKGJhbmssIGdldF9ncGlvX2luZGV4KGdwaW8pLCBJUlFUX05PRURHRSk7CgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE1WFgKCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX0dQSU9fMTUxMCkgewoJCXZvaWQgX19pb21lbSAqcmVnOwoKCQkvKiBDbGFpbSB0aGUgcGluIGZvciBNUFUgKi8KCQlyZWcgPSBiYW5rLT5iYXNlICsgT01BUDE1MTBfR1BJT19QSU5fQ09OVFJPTDsKCQlfX3Jhd193cml0ZWwoX19yYXdfcmVhZGwocmVnKSB8ICgxIDw8IGdldF9ncGlvX2luZGV4KGdwaW8pKSwgcmVnKTsKCX0KI2VuZGlmCglzcGluX3VubG9jaygmYmFuay0+bG9jayk7CgoJcmV0dXJuIDA7Cn0KCnZvaWQgb21hcF9mcmVlX2dwaW8oaW50IGdwaW8pCnsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7CgoJaWYgKGNoZWNrX2dwaW8oZ3BpbykgPCAwKQoJCXJldHVybjsKCWJhbmsgPSBnZXRfZ3Bpb19iYW5rKGdwaW8pOwoJc3Bpbl9sb2NrKCZiYW5rLT5sb2NrKTsKCWlmICh1bmxpa2VseSghKGJhbmstPnJlc2VydmVkX21hcCAmICgxIDw8IGdldF9ncGlvX2luZGV4KGdwaW8pKSkpKSB7CgkJcHJpbnRrKEtFUk5fRVJSICJvbWFwLWdwaW86IEdQSU8gJWQgd2Fzbid0IHJlc2VydmVkIVxuIiwgZ3Bpbyk7CgkJZHVtcF9zdGFjaygpOwoJCXNwaW5fdW5sb2NrKCZiYW5rLT5sb2NrKTsKCQlyZXR1cm47Cgl9CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTZYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18xNjEwKSB7CgkJLyogRGlzYWJsZSB3YWtlLXVwIGR1cmluZyBpZGxlIGZvciBkeW5hbWljIHRpY2sgKi8KCQl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX0NMRUFSX1dBS0VVUEVOQTsKCQlfX3Jhd193cml0ZWwoMSA8PCBnZXRfZ3Bpb19pbmRleChncGlvKSwgcmVnKTsKCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18yNFhYKSB7CgkJLyogRGlzYWJsZSB3YWtlLXVwIGR1cmluZyBpZGxlIGZvciBkeW5hbWljIHRpY2sgKi8KCQl2b2lkIF9faW9tZW0gKnJlZyA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0NMRUFSV0tVRU5BOwoJCV9fcmF3X3dyaXRlbCgxIDw8IGdldF9ncGlvX2luZGV4KGdwaW8pLCByZWcpOwoJfQojZW5kaWYKCWJhbmstPnJlc2VydmVkX21hcCAmPSB+KDEgPDwgZ2V0X2dwaW9faW5kZXgoZ3BpbykpOwoJX3Jlc2V0X2dwaW8oYmFuaywgZ3Bpbyk7CglzcGluX3VubG9jaygmYmFuay0+bG9jayk7Cn0KCi8qCiAqIFdlIG5lZWQgdG8gdW5tYXNrIHRoZSBHUElPIGJhbmsgaW50ZXJydXB0IGFzIHNvb24gYXMgcG9zc2libGUgdG8KICogYXZvaWQgbWlzc2luZyBHUElPIGludGVycnVwdHMgZm9yIG90aGVyIGxpbmVzIGluIHRoZSBiYW5rLgogKiBUaGVuIHdlIG5lZWQgdG8gbWFzay1yZWFkLWNsZWFyLXVubWFzayB0aGUgdHJpZ2dlcmVkIEdQSU8gbGluZXMKICogaW4gdGhlIGJhbmsgdG8gYXZvaWQgbWlzc2luZyBuZXN0ZWQgaW50ZXJydXB0cyBmb3IgYSBHUElPIGxpbmUuCiAqIElmIHdlIHdhaXQgdG8gdW5tYXNrIGluZGl2aWR1YWwgR1BJTyBsaW5lcyBpbiB0aGUgYmFuayBhZnRlciB0aGUKICogbGluZSdzIGludGVycnVwdCBoYW5kbGVyIGhhcyBiZWVuIHJ1biwgd2UgbWF5IG1pc3Mgc29tZSBuZXN0ZWQKICogaW50ZXJydXB0cy4KICovCnN0YXRpYyB2b2lkIGdwaW9faXJxX2hhbmRsZXIodW5zaWduZWQgaW50IGlycSwgc3RydWN0IGlycV9kZXNjICpkZXNjKQp7Cgl2b2lkIF9faW9tZW0gKmlzcl9yZWcgPSBOVUxMOwoJdTMyIGlzcjsKCXVuc2lnbmVkIGludCBncGlvX2lycTsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbms7Cgl1MzIgcmV0cmlnZ2VyID0gMDsKCWludCB1bm1hc2tlZCA9IDA7CgoJZGVzYy0+Y2hpcC0+YWNrKGlycSk7CgoJYmFuayA9IGdldF9pcnFfZGF0YShpcnEpOwojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDEKCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX01QVUlPKQoJCWlzcl9yZWcgPSBiYW5rLT5iYXNlICsgT01BUF9NUFVJT19HUElPX0lOVDsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18xNTEwKQoJCWlzcl9yZWcgPSBiYW5rLT5iYXNlICsgT01BUDE1MTBfR1BJT19JTlRfU1RBVFVTOwojZW5kaWYKI2lmIGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDE2WFgpCglpZiAoYmFuay0+bWV0aG9kID09IE1FVEhPRF9HUElPXzE2MTApCgkJaXNyX3JlZyA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX0lSUVNUQVRVUzE7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDczMAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT183MzApCgkJaXNyX3JlZyA9IGJhbmstPmJhc2UgKyBPTUFQNzMwX0dQSU9fSU5UX1NUQVRVUzsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18yNFhYKQoJCWlzcl9yZWcgPSBiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19JUlFTVEFUVVMxOwojZW5kaWYKCXdoaWxlKDEpIHsKCQl1MzIgaXNyX3NhdmVkLCBsZXZlbF9tYXNrID0gMDsKCQl1MzIgZW5hYmxlZDsKCgkJZW5hYmxlZCA9IF9nZXRfZ3Bpb19pcnFiYW5rX21hc2soYmFuayk7CgkJaXNyX3NhdmVkID0gaXNyID0gX19yYXdfcmVhZGwoaXNyX3JlZykgJiBlbmFibGVkOwoKCQlpZiAoY3B1X2lzX29tYXAxNXh4KCkgJiYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfTVBVSU8pKQoJCQlpc3IgJj0gMHgwMDAwZmZmZjsKCgkJaWYgKGNwdV9pc19vbWFwMjR4eCgpKSB7CgkJCWxldmVsX21hc2sgPQoJCQkJX19yYXdfcmVhZGwoYmFuay0+YmFzZSArCgkJCQkJT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDApIHwKCQkJCV9fcmF3X3JlYWRsKGJhbmstPmJhc2UgKwoJCQkJCU9NQVAyNFhYX0dQSU9fTEVWRUxERVRFQ1QxKTsKCQkJbGV2ZWxfbWFzayAmPSBlbmFibGVkOwoJCX0KCgkJLyogY2xlYXIgZWRnZSBzZW5zaXRpdmUgaW50ZXJydXB0cyBiZWZvcmUgaGFuZGxlcihzKSBhcmUKCQljYWxsZWQgc28gdGhhdCB3ZSBkb24ndCBtaXNzIGFueSBpbnRlcnJ1cHQgb2NjdXJyZWQgd2hpbGUKCQlleGVjdXRpbmcgdGhlbSAqLwoJCV9lbmFibGVfZ3Bpb19pcnFiYW5rKGJhbmssIGlzcl9zYXZlZCAmIH5sZXZlbF9tYXNrLCAwKTsKCQlfY2xlYXJfZ3Bpb19pcnFiYW5rKGJhbmssIGlzcl9zYXZlZCAmIH5sZXZlbF9tYXNrKTsKCQlfZW5hYmxlX2dwaW9faXJxYmFuayhiYW5rLCBpc3Jfc2F2ZWQgJiB+bGV2ZWxfbWFzaywgMSk7CgoJCS8qIGlmIHRoZXJlIGlzIG9ubHkgZWRnZSBzZW5zaXRpdmUgR1BJTyBwaW4gaW50ZXJydXB0cwoJCWNvbmZpZ3VyZWQsIHdlIGNvdWxkIHVubWFzayBHUElPIGJhbmsgaW50ZXJydXB0IGltbWVkaWF0ZWx5ICovCgkJaWYgKCFsZXZlbF9tYXNrICYmICF1bm1hc2tlZCkgewoJCQl1bm1hc2tlZCA9IDE7CgkJCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOwoJCX0KCgkJaXNyIHw9IHJldHJpZ2dlcjsKCQlyZXRyaWdnZXIgPSAwOwoJCWlmICghaXNyKQoJCQlicmVhazsKCgkJZ3Bpb19pcnEgPSBiYW5rLT52aXJ0dWFsX2lycV9zdGFydDsKCQlmb3IgKDsgaXNyICE9IDA7IGlzciA+Pj0gMSwgZ3Bpb19pcnErKykgewoJCQlzdHJ1Y3QgaXJxX2Rlc2MgKmQ7CgkJCWludCBpcnFfbWFzazsKCQkJaWYgKCEoaXNyICYgMSkpCgkJCQljb250aW51ZTsKCQkJZCA9IGlycV9kZXNjICsgZ3Bpb19pcnE7CgkJCS8qIERvbid0IHJ1biB0aGUgaGFuZGxlciBpZiBpdCdzIGFscmVhZHkgcnVubmluZwoJCQkgKiBvciB3YXMgZGlzYWJsZWQgbGF6ZWx5LgoJCQkgKi8KCQkJaWYgKHVubGlrZWx5KChkLT5kZXB0aCB8fAoJCQkJICAgICAgKGQtPnN0YXR1cyAmIElSUV9JTlBST0dSRVNTKSkpKSB7CgkJCQlpcnFfbWFzayA9IDEgPDwKCQkJCQkoZ3Bpb19pcnEgLSBiYW5rLT52aXJ0dWFsX2lycV9zdGFydCk7CgkJCQkvKiBUaGUgdW5tYXNraW5nIHdpbGwgYmUgZG9uZSBieQoJCQkJICogZW5hYmxlX2lycSBpbiBjYXNlIGl0IGlzIGRpc2FibGVkIG9yCgkJCQkgKiBhZnRlciByZXR1cm5pbmcgZnJvbSB0aGUgaGFuZGxlciBpZgoJCQkJICogaXQncyBhbHJlYWR5IHJ1bm5pbmcuCgkJCQkgKi8KCQkJCV9lbmFibGVfZ3Bpb19pcnFiYW5rKGJhbmssIGlycV9tYXNrLCAwKTsKCQkJCWlmICghZC0+ZGVwdGgpIHsKCQkJCQkvKiBMZXZlbCB0cmlnZ2VyZWQgaW50ZXJydXB0cwoJCQkJCSAqIHdvbid0IGV2ZXIgYmUgcmVlbnRlcmVkCgkJCQkJICovCgkJCQkJQlVHX09OKGxldmVsX21hc2sgJiBpcnFfbWFzayk7CgkJCQkJZC0+c3RhdHVzIHw9IElSUV9QRU5ESU5HOwoJCQkJfQoJCQkJY29udGludWU7CgkJCX0KCgkJCWRlc2NfaGFuZGxlX2lycShncGlvX2lycSwgZCk7CgoJCQlpZiAodW5saWtlbHkoKGQtPnN0YXR1cyAmIElSUV9QRU5ESU5HKSAmJiAhZC0+ZGVwdGgpKSB7CgkJCQlpcnFfbWFzayA9IDEgPDwKCQkJCQkoZ3Bpb19pcnEgLSBiYW5rLT52aXJ0dWFsX2lycV9zdGFydCk7CgkJCQlkLT5zdGF0dXMgJj0gfklSUV9QRU5ESU5HOwoJCQkJX2VuYWJsZV9ncGlvX2lycWJhbmsoYmFuaywgaXJxX21hc2ssIDEpOwoJCQkJcmV0cmlnZ2VyIHw9IGlycV9tYXNrOwoJCQl9CgkJfQoKCQlpZiAoY3B1X2lzX29tYXAyNHh4KCkpIHsKCQkJLyogY2xlYXIgbGV2ZWwgc2Vuc2l0aXZlIGludGVycnVwdHMgYWZ0ZXIgaGFuZGxlcihzKSAqLwoJCQlfZW5hYmxlX2dwaW9faXJxYmFuayhiYW5rLCBpc3Jfc2F2ZWQgJiBsZXZlbF9tYXNrLCAwKTsKCQkJX2NsZWFyX2dwaW9faXJxYmFuayhiYW5rLCBpc3Jfc2F2ZWQgJiBsZXZlbF9tYXNrKTsKCQkJX2VuYWJsZV9ncGlvX2lycWJhbmsoYmFuaywgaXNyX3NhdmVkICYgbGV2ZWxfbWFzaywgMSk7CgkJfQoKCX0KCS8qIGlmIGJhbmsgaGFzIGFueSBsZXZlbCBzZW5zaXRpdmUgR1BJTyBwaW4gaW50ZXJydXB0Cgljb25maWd1cmVkLCB3ZSBtdXN0IHVubWFzayB0aGUgYmFuayBpbnRlcnJ1cHQgb25seSBhZnRlcgoJaGFuZGxlcihzKSBhcmUgZXhlY3V0ZWQgaW4gb3JkZXIgdG8gYXZvaWQgc3B1cmlvdXMgYmFuawoJaW50ZXJydXB0ICovCglpZiAoIXVubWFza2VkKQoJCWRlc2MtPmNoaXAtPnVubWFzayhpcnEpOwoKfQoKc3RhdGljIHZvaWQgZ3Bpb19pcnFfc2h1dGRvd24odW5zaWduZWQgaW50IGlycSkKewoJdW5zaWduZWQgaW50IGdwaW8gPSBpcnEgLSBJSF9HUElPX0JBU0U7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKCglfcmVzZXRfZ3BpbyhiYW5rLCBncGlvKTsKfQoKc3RhdGljIHZvaWQgZ3Bpb19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCnsKCXVuc2lnbmVkIGludCBncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOwoJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CgoJX2NsZWFyX2dwaW9faXJxc3RhdHVzKGJhbmssIGdwaW8pOwp9CgpzdGF0aWMgdm9pZCBncGlvX21hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCnsKCXVuc2lnbmVkIGludCBncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOwoJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9IGdldF9pcnFfY2hpcF9kYXRhKGlycSk7CgoJX3NldF9ncGlvX2lycWVuYWJsZShiYW5rLCBncGlvLCAwKTsKfQoKc3RhdGljIHZvaWQgZ3Bpb191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCnsKCXVuc2lnbmVkIGludCBncGlvID0gaXJxIC0gSUhfR1BJT19CQVNFOwoJdW5zaWduZWQgaW50IGdwaW9faWR4ID0gZ2V0X2dwaW9faW5kZXgoZ3Bpbyk7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKCglfc2V0X2dwaW9faXJxZW5hYmxlKGJhbmssIGdwaW9faWR4LCAxKTsKfQoKc3RhdGljIHN0cnVjdCBpcnFfY2hpcCBncGlvX2lycV9jaGlwID0gewoJLm5hbWUJCT0gIkdQSU8iLAoJLnNodXRkb3duCT0gZ3Bpb19pcnFfc2h1dGRvd24sCgkuYWNrCQk9IGdwaW9fYWNrX2lycSwKCS5tYXNrCQk9IGdwaW9fbWFza19pcnEsCgkudW5tYXNrCQk9IGdwaW9fdW5tYXNrX2lycSwKCS5zZXRfdHlwZQk9IGdwaW9faXJxX3R5cGUsCgkuc2V0X3dha2UJPSBncGlvX3dha2VfZW5hYmxlLAp9OwoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwoKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxCgovKiBNUFVJTyB1c2VzIHRoZSBhbHdheXMtb24gMzJrIGNsb2NrICovCgpzdGF0aWMgdm9pZCBtcHVpb19hY2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCnsKCS8qIFRoZSBJU1IgaXMgcmVzZXQgYXV0b21hdGljYWxseSwgc28gZG8gbm90aGluZyBoZXJlLiAqLwp9CgpzdGF0aWMgdm9pZCBtcHVpb19tYXNrX2lycSh1bnNpZ25lZCBpbnQgaXJxKQp7Cgl1bnNpZ25lZCBpbnQgZ3BpbyA9IE9NQVBfTVBVSU8oaXJxIC0gSUhfTVBVSU9fQkFTRSk7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gZ2V0X2lycV9jaGlwX2RhdGEoaXJxKTsKCglfc2V0X2dwaW9faXJxZW5hYmxlKGJhbmssIGdwaW8sIDApOwp9CgpzdGF0aWMgdm9pZCBtcHVpb191bm1hc2tfaXJxKHVuc2lnbmVkIGludCBpcnEpCnsKCXVuc2lnbmVkIGludCBncGlvID0gT01BUF9NUFVJTyhpcnEgLSBJSF9NUFVJT19CQVNFKTsKCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSBnZXRfaXJxX2NoaXBfZGF0YShpcnEpOwoKCV9zZXRfZ3Bpb19pcnFlbmFibGUoYmFuaywgZ3BpbywgMSk7Cn0KCnN0YXRpYyBzdHJ1Y3QgaXJxX2NoaXAgbXB1aW9faXJxX2NoaXAgPSB7CgkubmFtZQkJPSAiTVBVSU8iLAoJLmFjawkJPSBtcHVpb19hY2tfaXJxLAoJLm1hc2sJCT0gbXB1aW9fbWFza19pcnEsCgkudW5tYXNrCQk9IG1wdWlvX3VubWFza19pcnEsCgkuc2V0X3R5cGUJPSBncGlvX2lycV90eXBlLAojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDE2WFgKCS8qIFJFVklTSVQ6IGFzc3VtaW5nIG9ubHkgMTZ4eCBzdXBwb3J0cyBNUFVJTyB3YWtlIGV2ZW50cyAqLwoJLnNldF93YWtlCT0gZ3Bpb193YWtlX2VuYWJsZSwKI2VuZGlmCn07CgoKI2RlZmluZSBiYW5rX2lzX21wdWlvKGJhbmspCSgoYmFuayktPm1ldGhvZCA9PSBNRVRIT0RfTVBVSU8pCgoKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNlhYCgojaW5jbHVkZSA8bGludXgvcGxhdGZvcm1fZGV2aWNlLmg+CgpzdGF0aWMgaW50IG9tYXBfbXB1aW9fc3VzcGVuZF9sYXRlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYsIHBtX21lc3NhZ2VfdCBtZXNnKQp7CglzdHJ1Y3QgZ3Bpb19iYW5rCSpiYW5rID0gcGxhdGZvcm1fZ2V0X2RydmRhdGEocGRldik7Cgl2b2lkIF9faW9tZW0JCSptYXNrX3JlZyA9IGJhbmstPmJhc2UgKyBPTUFQX01QVUlPX0dQSU9fTUFTS0lUOwoKCXNwaW5fbG9jaygmYmFuay0+bG9jayk7CgliYW5rLT5zYXZlZF93YWtldXAgPSBfX3Jhd19yZWFkbChtYXNrX3JlZyk7CglfX3Jhd193cml0ZWwoMHhmZmZmICYgfmJhbmstPnN1c3BlbmRfd2FrZXVwLCBtYXNrX3JlZyk7CglzcGluX3VubG9jaygmYmFuay0+bG9jayk7CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBpbnQgb21hcF9tcHVpb19yZXN1bWVfZWFybHkoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKewoJc3RydWN0IGdwaW9fYmFuawkqYmFuayA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwoJdm9pZCBfX2lvbWVtCQkqbWFza19yZWcgPSBiYW5rLT5iYXNlICsgT01BUF9NUFVJT19HUElPX01BU0tJVDsKCglzcGluX2xvY2soJmJhbmstPmxvY2spOwoJX19yYXdfd3JpdGVsKGJhbmstPnNhdmVkX3dha2V1cCwgbWFza19yZWcpOwoJc3Bpbl91bmxvY2soJmJhbmstPmxvY2spOwoKCXJldHVybiAwOwp9CgovKiB1c2UgcGxhdGZvcm1fZHJpdmVyIGZvciB0aGlzLCBub3cgdGhhdCB0aGVyZSdzIG5vIGxvbmdlciBhbnkKICogcG9pbnQgdG8gc3lzX2RldmljZSAob3RoZXIgdGhhbiBub3QgZGlzdHVyYmluZyBvbGQgY29kZSkuCiAqLwpzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RyaXZlciBvbWFwX21wdWlvX2RyaXZlciA9IHsKCS5zdXNwZW5kX2xhdGUJPSBvbWFwX21wdWlvX3N1c3BlbmRfbGF0ZSwKCS5yZXN1bWVfZWFybHkJPSBvbWFwX21wdWlvX3Jlc3VtZV9lYXJseSwKCS5kcml2ZXIJCT0gewoJCS5uYW1lCT0gIm1wdWlvIiwKCX0sCn07CgpzdGF0aWMgc3RydWN0IHBsYXRmb3JtX2RldmljZSBvbWFwX21wdWlvX2RldmljZSA9IHsKCS5uYW1lCQk9ICJtcHVpbyIsCgkuaWQJCT0gLTEsCgkuZGV2ID0gewoJCS5kcml2ZXIgPSAmb21hcF9tcHVpb19kcml2ZXIuZHJpdmVyLAoJfQoJLyogY291bGQgbGlzdCB0aGUgL3Byb2MvaW9tZW0gcmVzb3VyY2VzICovCn07CgpzdGF0aWMgaW5saW5lIHZvaWQgbXB1aW9faW5pdCh2b2lkKQp7CglwbGF0Zm9ybV9zZXRfZHJ2ZGF0YSgmb21hcF9tcHVpb19kZXZpY2UsICZncGlvX2JhbmtfMTYxMFswXSk7CgoJaWYgKHBsYXRmb3JtX2RyaXZlcl9yZWdpc3Rlcigmb21hcF9tcHVpb19kcml2ZXIpID09IDApCgkJKHZvaWQpIHBsYXRmb3JtX2RldmljZV9yZWdpc3Rlcigmb21hcF9tcHVpb19kZXZpY2UpOwp9CgojZWxzZQpzdGF0aWMgaW5saW5lIHZvaWQgbXB1aW9faW5pdCh2b2lkKSB7fQojZW5kaWYJLyogMTZ4eCAqLwoKI2Vsc2UKCmV4dGVybiBzdHJ1Y3QgaXJxX2NoaXAgbXB1aW9faXJxX2NoaXA7CgojZGVmaW5lIGJhbmtfaXNfbXB1aW8oYmFuaykJMApzdGF0aWMgaW5saW5lIHZvaWQgbXB1aW9faW5pdCh2b2lkKSB7fQoKI2VuZGlmCgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCgpzdGF0aWMgaW50IGluaXRpYWxpemVkOwpzdGF0aWMgc3RydWN0IGNsayAqIGdwaW9faWNrOwpzdGF0aWMgc3RydWN0IGNsayAqIGdwaW9fZmNrOwoKI2lmZGVmIENPTkZJR19BUkNIX09NQVAyNDMwCnN0YXRpYyBzdHJ1Y3QgY2xrICogZ3BpbzVfaWNrOwpzdGF0aWMgc3RydWN0IGNsayAqIGdwaW81X2ZjazsKI2VuZGlmCgpzdGF0aWMgaW50IF9faW5pdCBfb21hcF9ncGlvX2luaXQodm9pZCkKewoJaW50IGk7CglzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rOwoKCWluaXRpYWxpemVkID0gMTsKCglpZiAoY3B1X2lzX29tYXAxNXh4KCkpIHsKCQlncGlvX2ljayA9IGNsa19nZXQoTlVMTCwgImFybV9ncGlvX2NrIik7CgkJaWYgKElTX0VSUihncGlvX2ljaykpCgkJCXByaW50aygiQ291bGQgbm90IGdldCBhcm1fZ3Bpb19ja1xuIik7CgkJZWxzZQoJCQljbGtfZW5hYmxlKGdwaW9faWNrKTsKCX0KCWlmIChjcHVfaXNfb21hcDI0eHgoKSkgewoJCWdwaW9faWNrID0gY2xrX2dldChOVUxMLCAiZ3Bpb3NfaWNrIik7CgkJaWYgKElTX0VSUihncGlvX2ljaykpCgkJCXByaW50aygiQ291bGQgbm90IGdldCBncGlvc19pY2tcbiIpOwoJCWVsc2UKCQkJY2xrX2VuYWJsZShncGlvX2ljayk7CgkJZ3Bpb19mY2sgPSBjbGtfZ2V0KE5VTEwsICJncGlvc19mY2siKTsKCQlpZiAoSVNfRVJSKGdwaW9fZmNrKSkKCQkJcHJpbnRrKCJDb3VsZCBub3QgZ2V0IGdwaW9zX2Zja1xuIik7CgkJZWxzZQoJCQljbGtfZW5hYmxlKGdwaW9fZmNrKTsKCgkJLyoKCQkgKiBPbiAyNDMwIEdQSU8gNSB1c2VzIENPUkUgTDQgSUNMSwoJCSAqLwojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0MzAKCQlpZiAoY3B1X2lzX29tYXAyNDMwKCkpIHsKCQkJZ3BpbzVfaWNrID0gY2xrX2dldChOVUxMLCAiZ3BpbzVfaWNrIik7CgkJCWlmIChJU19FUlIoZ3BpbzVfaWNrKSkKCQkJCXByaW50aygiQ291bGQgbm90IGdldCBncGlvNV9pY2tcbiIpOwoJCQllbHNlCgkJCQljbGtfZW5hYmxlKGdwaW81X2ljayk7CgkJCWdwaW81X2ZjayA9IGNsa19nZXQoTlVMTCwgImdwaW81X2ZjayIpOwoJCQlpZiAoSVNfRVJSKGdwaW81X2ZjaykpCgkJCQlwcmludGsoIkNvdWxkIG5vdCBnZXQgZ3BpbzVfZmNrXG4iKTsKCQkJZWxzZQoJCQkJY2xrX2VuYWJsZShncGlvNV9mY2spOwoJCX0KI2VuZGlmCn0KCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTVYWAoJaWYgKGNwdV9pc19vbWFwMTV4eCgpKSB7CgkJcHJpbnRrKEtFUk5fSU5GTyAiT01BUDE1MTAgR1BJTyBoYXJkd2FyZVxuIik7CgkJZ3Bpb19iYW5rX2NvdW50ID0gMjsKCQlncGlvX2JhbmsgPSBncGlvX2JhbmtfMTUxMDsKCX0KI2VuZGlmCiNpZiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNlhYKQoJaWYgKGNwdV9pc19vbWFwMTZ4eCgpKSB7CgkJdTMyIHJldjsKCgkJZ3Bpb19iYW5rX2NvdW50ID0gNTsKCQlncGlvX2JhbmsgPSBncGlvX2JhbmtfMTYxMDsKCQlyZXYgPSBvbWFwX3JlYWR3KGdwaW9fYmFua1sxXS5iYXNlICsgT01BUDE2MTBfR1BJT19SRVZJU0lPTik7CgkJcHJpbnRrKEtFUk5fSU5GTyAiT01BUCBHUElPIGhhcmR3YXJlIHZlcnNpb24gJWQuJWRcbiIsCgkJICAgICAgIChyZXYgPj4gNCkgJiAweDBmLCByZXYgJiAweDBmKTsKCX0KI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQNzMwCglpZiAoY3B1X2lzX29tYXA3MzAoKSkgewoJCXByaW50ayhLRVJOX0lORk8gIk9NQVA3MzAgR1BJTyBoYXJkd2FyZVxuIik7CgkJZ3Bpb19iYW5rX2NvdW50ID0gNzsKCQlncGlvX2JhbmsgPSBncGlvX2JhbmtfNzMwOwoJfQojZW5kaWYKCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJaWYgKGNwdV9pc19vbWFwMjQyeCgpKSB7CgkJaW50IHJldjsKCgkJZ3Bpb19iYW5rX2NvdW50ID0gNDsKCQlncGlvX2JhbmsgPSBncGlvX2JhbmtfMjQyeDsKCQlyZXYgPSBvbWFwX3JlYWRsKGdwaW9fYmFua1swXS5iYXNlICsgT01BUDI0WFhfR1BJT19SRVZJU0lPTik7CgkJcHJpbnRrKEtFUk5fSU5GTyAiT01BUDI0MnggR1BJTyBoYXJkd2FyZSB2ZXJzaW9uICVkLiVkXG4iLAoJCQkocmV2ID4+IDQpICYgMHgwZiwgcmV2ICYgMHgwZik7Cgl9CglpZiAoY3B1X2lzX29tYXAyNDN4KCkpIHsKCQlpbnQgcmV2OwoKCQlncGlvX2JhbmtfY291bnQgPSA1OwoJCWdwaW9fYmFuayA9IGdwaW9fYmFua18yNDN4OwoJCXJldiA9IG9tYXBfcmVhZGwoZ3Bpb19iYW5rWzBdLmJhc2UgKyBPTUFQMjRYWF9HUElPX1JFVklTSU9OKTsKCQlwcmludGsoS0VSTl9JTkZPICJPTUFQMjQzeCBHUElPIGhhcmR3YXJlIHZlcnNpb24gJWQuJWRcbiIsCgkJCShyZXYgPj4gNCkgJiAweDBmLCByZXYgJiAweDBmKTsKCX0KI2VuZGlmCglmb3IgKGkgPSAwOyBpIDwgZ3Bpb19iYW5rX2NvdW50OyBpKyspIHsKCQlpbnQgaiwgZ3Bpb19jb3VudCA9IDE2OwoKCQliYW5rID0gJmdwaW9fYmFua1tpXTsKCQliYW5rLT5yZXNlcnZlZF9tYXAgPSAwOwoJCWJhbmstPmJhc2UgPSBJT19BRERSRVNTKGJhbmstPmJhc2UpOwoJCXNwaW5fbG9ja19pbml0KCZiYW5rLT5sb2NrKTsKCQlpZiAoYmFua19pc19tcHVpbyhiYW5rKSkKCQkJb21hcF93cml0ZXcoMHhGRkZGLCBPTUFQX01QVUlPX0JBU0UgKyBPTUFQX01QVUlPX0dQSU9fTUFTS0lUKTsKI2lmZGVmIENPTkZJR19BUkNIX09NQVAxNVhYCgkJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18xNTEwKSB7CgkJCV9fcmF3X3dyaXRldygweGZmZmYsIGJhbmstPmJhc2UgKyBPTUFQMTUxMF9HUElPX0lOVF9NQVNLKTsKCQkJX19yYXdfd3JpdGV3KDB4MDAwMCwgYmFuay0+YmFzZSArIE9NQVAxNTEwX0dQSU9fSU5UX1NUQVRVUyk7CgkJfQojZW5kaWYKI2lmIGRlZmluZWQoQ09ORklHX0FSQ0hfT01BUDE2WFgpCgkJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18xNjEwKSB7CgkJCV9fcmF3X3dyaXRldygweDAwMDAsIGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX0lSUUVOQUJMRTEpOwoJCQlfX3Jhd193cml0ZXcoMHhmZmZmLCBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19JUlFTVEFUVVMxKTsKCQkJX19yYXdfd3JpdGV3KDB4MDAxNCwgYmFuay0+YmFzZSArIE9NQVAxNjEwX0dQSU9fU1lTQ09ORklHKTsKCQl9CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDczMAoJCWlmIChiYW5rLT5tZXRob2QgPT0gTUVUSE9EX0dQSU9fNzMwKSB7CgkJCV9fcmF3X3dyaXRlbCgweGZmZmZmZmZmLCBiYW5rLT5iYXNlICsgT01BUDczMF9HUElPX0lOVF9NQVNLKTsKCQkJX19yYXdfd3JpdGVsKDB4MDAwMDAwMDAsIGJhbmstPmJhc2UgKyBPTUFQNzMwX0dQSU9fSU5UX1NUQVRVUyk7CgoJCQlncGlvX2NvdW50ID0gMzI7IC8qIDczMCBoYXMgMzItYml0IEdQSU9zICovCgkJfQojZW5kaWYKI2lmZGVmIENPTkZJR19BUkNIX09NQVAyNFhYCgkJaWYgKGJhbmstPm1ldGhvZCA9PSBNRVRIT0RfR1BJT18yNFhYKSB7CgkJCXN0YXRpYyBjb25zdCB1MzIgbm9uX3dha2V1cF9ncGlvc1tdID0gewoJCQkJMHhlMjAzZmZjMCwgMHgwODcwMDA0MAoJCQl9OwoKCQkJX19yYXdfd3JpdGVsKDB4MDAwMDAwMDAsIGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0lSUUVOQUJMRTEpOwoJCQlfX3Jhd193cml0ZWwoMHhmZmZmZmZmZiwgYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fSVJRU1RBVFVTMSk7CgkJCV9fcmF3X3dyaXRldygweDAwMTUsIGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX1NZU0NPTkZJRyk7CgoJCQkvKiBJbml0aWFsaXplIGludGVyZmFjZSBjbG9jayB1bmdhdGVkLCBtb2R1bGUgZW5hYmxlZCAqLwoJCQlfX3Jhd193cml0ZWwoMCwgYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fQ1RSTCk7CgkJCWlmIChpIDwgQVJSQVlfU0laRShub25fd2FrZXVwX2dwaW9zKSkKCQkJCWJhbmstPm5vbl93YWtldXBfZ3Bpb3MgPSBub25fd2FrZXVwX2dwaW9zW2ldOwoJCQlncGlvX2NvdW50ID0gMzI7CgkJfQojZW5kaWYKCQlmb3IgKGogPSBiYW5rLT52aXJ0dWFsX2lycV9zdGFydDsKCQkgICAgIGogPCBiYW5rLT52aXJ0dWFsX2lycV9zdGFydCArIGdwaW9fY291bnQ7IGorKykgewoJCQlzZXRfaXJxX2NoaXBfZGF0YShqLCBiYW5rKTsKCQkJaWYgKGJhbmtfaXNfbXB1aW8oYmFuaykpCgkJCQlzZXRfaXJxX2NoaXAoaiwgJm1wdWlvX2lycV9jaGlwKTsKCQkJZWxzZQoJCQkJc2V0X2lycV9jaGlwKGosICZncGlvX2lycV9jaGlwKTsKCQkJc2V0X2lycV9oYW5kbGVyKGosIGhhbmRsZV9zaW1wbGVfaXJxKTsKCQkJc2V0X2lycV9mbGFncyhqLCBJUlFGX1ZBTElEKTsKCQl9CgkJc2V0X2lycV9jaGFpbmVkX2hhbmRsZXIoYmFuay0+aXJxLCBncGlvX2lycV9oYW5kbGVyKTsKCQlzZXRfaXJxX2RhdGEoYmFuay0+aXJxLCBiYW5rKTsKCX0KCgkvKiBFbmFibGUgc3lzdGVtIGNsb2NrIGZvciBHUElPIG1vZHVsZS4KCSAqIFRoZSBDQU1fQ0xLX0NUUkwgKmlzKiByZWFsbHkgdGhlIHJpZ2h0IHBsYWNlLiAqLwoJaWYgKGNwdV9pc19vbWFwMTZ4eCgpKQoJCW9tYXBfd3JpdGVsKG9tYXBfcmVhZGwoVUxQRF9DQU1fQ0xLX0NUUkwpIHwgMHgwNCwgVUxQRF9DQU1fQ0xLX0NUUkwpOwoKI2lmZGVmIENPTkZJR19BUkNIX09NQVAyNFhYCgkvKiBFbmFibGUgYXV0b2lkbGUgZm9yIHRoZSBPQ1AgaW50ZXJmYWNlICovCglpZiAoY3B1X2lzX29tYXAyNHh4KCkpCgkJb21hcF93cml0ZWwoMSA8PCAwLCAweDQ4MDE5MDEwKTsKI2VuZGlmCgoJcmV0dXJuIDA7Cn0KCiNpZiBkZWZpbmVkIChDT05GSUdfQVJDSF9PTUFQMTZYWCkgfHwgZGVmaW5lZCAoQ09ORklHX0FSQ0hfT01BUDI0WFgpCnN0YXRpYyBpbnQgb21hcF9ncGlvX3N1c3BlbmQoc3RydWN0IHN5c19kZXZpY2UgKmRldiwgcG1fbWVzc2FnZV90IG1lc2cpCnsKCWludCBpOwoKCWlmICghY3B1X2lzX29tYXAyNHh4KCkgJiYgIWNwdV9pc19vbWFwMTZ4eCgpKQoJCXJldHVybiAwOwoKCWZvciAoaSA9IDA7IGkgPCBncGlvX2JhbmtfY291bnQ7IGkrKykgewoJCXN0cnVjdCBncGlvX2JhbmsgKmJhbmsgPSAmZ3Bpb19iYW5rW2ldOwoJCXZvaWQgX19pb21lbSAqd2FrZV9zdGF0dXM7CgkJdm9pZCBfX2lvbWVtICp3YWtlX2NsZWFyOwoJCXZvaWQgX19pb21lbSAqd2FrZV9zZXQ7CgoJCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTZYWAoJCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQkJd2FrZV9zdGF0dXMgPSBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19XQUtFVVBFTkFCTEU7CgkJCXdha2VfY2xlYXIgPSBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19DTEVBUl9XQUtFVVBFTkE7CgkJCXdha2Vfc2V0ID0gYmFuay0+YmFzZSArIE9NQVAxNjEwX0dQSU9fU0VUX1dBS0VVUEVOQTsKCQkJYnJlYWs7CiNlbmRpZgojaWZkZWYgQ09ORklHX0FSQ0hfT01BUDI0WFgKCQljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJCXdha2Vfc3RhdHVzID0gYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fU0VUV0tVRU5BOwoJCQl3YWtlX2NsZWFyID0gYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fQ0xFQVJXS1VFTkE7CgkJCXdha2Vfc2V0ID0gYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fU0VUV0tVRU5BOwoJCQlicmVhazsKI2VuZGlmCgkJZGVmYXVsdDoKCQkJY29udGludWU7CgkJfQoKCQlzcGluX2xvY2soJmJhbmstPmxvY2spOwoJCWJhbmstPnNhdmVkX3dha2V1cCA9IF9fcmF3X3JlYWRsKHdha2Vfc3RhdHVzKTsKCQlfX3Jhd193cml0ZWwoMHhmZmZmZmZmZiwgd2FrZV9jbGVhcik7CgkJX19yYXdfd3JpdGVsKGJhbmstPnN1c3BlbmRfd2FrZXVwLCB3YWtlX3NldCk7CgkJc3Bpbl91bmxvY2soJmJhbmstPmxvY2spOwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IG9tYXBfZ3Bpb19yZXN1bWUoc3RydWN0IHN5c19kZXZpY2UgKmRldikKewoJaW50IGk7CgoJaWYgKCFjcHVfaXNfb21hcDI0eHgoKSAmJiAhY3B1X2lzX29tYXAxNnh4KCkpCgkJcmV0dXJuIDA7CgoJZm9yIChpID0gMDsgaSA8IGdwaW9fYmFua19jb3VudDsgaSsrKSB7CgkJc3RydWN0IGdwaW9fYmFuayAqYmFuayA9ICZncGlvX2JhbmtbaV07CgkJdm9pZCBfX2lvbWVtICp3YWtlX2NsZWFyOwoJCXZvaWQgX19pb21lbSAqd2FrZV9zZXQ7CgoJCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMTZYWAoJCWNhc2UgTUVUSE9EX0dQSU9fMTYxMDoKCQkJd2FrZV9jbGVhciA9IGJhbmstPmJhc2UgKyBPTUFQMTYxMF9HUElPX0NMRUFSX1dBS0VVUEVOQTsKCQkJd2FrZV9zZXQgPSBiYW5rLT5iYXNlICsgT01BUDE2MTBfR1BJT19TRVRfV0FLRVVQRU5BOwoJCQlicmVhazsKI2VuZGlmCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoJCWNhc2UgTUVUSE9EX0dQSU9fMjRYWDoKCQkJd2FrZV9jbGVhciA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0NMRUFSV0tVRU5BOwoJCQl3YWtlX3NldCA9IGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX1NFVFdLVUVOQTsKCQkJYnJlYWs7CiNlbmRpZgoJCWRlZmF1bHQ6CgkJCWNvbnRpbnVlOwoJCX0KCgkJc3Bpbl9sb2NrKCZiYW5rLT5sb2NrKTsKCQlfX3Jhd193cml0ZWwoMHhmZmZmZmZmZiwgd2FrZV9jbGVhcik7CgkJX19yYXdfd3JpdGVsKGJhbmstPnNhdmVkX3dha2V1cCwgd2FrZV9zZXQpOwoJCXNwaW5fdW5sb2NrKCZiYW5rLT5sb2NrKTsKCX0KCglyZXR1cm4gMDsKfQoKc3RhdGljIHN0cnVjdCBzeXNkZXZfY2xhc3Mgb21hcF9ncGlvX3N5c2NsYXNzID0gewoJc2V0X2tzZXRfbmFtZSgiZ3BpbyIpLAoJLnN1c3BlbmQJPSBvbWFwX2dwaW9fc3VzcGVuZCwKCS5yZXN1bWUJCT0gb21hcF9ncGlvX3Jlc3VtZSwKfTsKCnN0YXRpYyBzdHJ1Y3Qgc3lzX2RldmljZSBvbWFwX2dwaW9fZGV2aWNlID0gewoJLmlkCQk9IDAsCgkuY2xzCQk9ICZvbWFwX2dwaW9fc3lzY2xhc3MsCn07CgojZW5kaWYKCiNpZmRlZiBDT05GSUdfQVJDSF9PTUFQMjRYWAoKc3RhdGljIGludCB3b3JrYXJvdW5kX2VuYWJsZWQ7Cgp2b2lkIG9tYXAyX2dwaW9fcHJlcGFyZV9mb3JfcmV0ZW50aW9uKHZvaWQpCnsKCWludCBpLCBjID0gMDsKCgkvKiBSZW1vdmUgdHJpZ2dlcmluZyBmb3IgYWxsIG5vbi13YWtldXAgR1BJT3MuICBPdGhlcndpc2Ugc3B1cmlvdXMKCSAqIElSUXMgd2lsbCBiZSBnZW5lcmF0ZWQuICBTZWUgT01BUDI0MjAgRXJyYXRhIGl0ZW0gMS4xMDEuICovCglmb3IgKGkgPSAwOyBpIDwgZ3Bpb19iYW5rX2NvdW50OyBpKyspIHsKCQlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gJmdwaW9fYmFua1tpXTsKCQl1MzIgbDEsIGwyOwoKCQlpZiAoIShiYW5rLT5lbmFibGVkX25vbl93YWtldXBfZ3Bpb3MpKQoJCQljb250aW51ZTsKCQliYW5rLT5zYXZlZF9kYXRhaW4gPSBfX3Jhd19yZWFkbChiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19EQVRBSU4pOwoJCWwxID0gX19yYXdfcmVhZGwoYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fRkFMTElOR0RFVEVDVCk7CgkJbDIgPSBfX3Jhd19yZWFkbChiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19SSVNJTkdERVRFQ1QpOwoJCWJhbmstPnNhdmVkX2ZhbGxpbmdkZXRlY3QgPSBsMTsKCQliYW5rLT5zYXZlZF9yaXNpbmdkZXRlY3QgPSBsMjsKCQlsMSAmPSB+YmFuay0+ZW5hYmxlZF9ub25fd2FrZXVwX2dwaW9zOwoJCWwyICY9IH5iYW5rLT5lbmFibGVkX25vbl93YWtldXBfZ3Bpb3M7CgkJX19yYXdfd3JpdGVsKGwxLCBiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19GQUxMSU5HREVURUNUKTsKCQlfX3Jhd193cml0ZWwobDIsIGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX1JJU0lOR0RFVEVDVCk7CgkJYysrOwoJfQoJaWYgKCFjKSB7CgkJd29ya2Fyb3VuZF9lbmFibGVkID0gMDsKCQlyZXR1cm47Cgl9Cgl3b3JrYXJvdW5kX2VuYWJsZWQgPSAxOwp9Cgp2b2lkIG9tYXAyX2dwaW9fcmVzdW1lX2FmdGVyX3JldGVudGlvbih2b2lkKQp7CglpbnQgaTsKCglpZiAoIXdvcmthcm91bmRfZW5hYmxlZCkKCQlyZXR1cm47Cglmb3IgKGkgPSAwOyBpIDwgZ3Bpb19iYW5rX2NvdW50OyBpKyspIHsKCQlzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rID0gJmdwaW9fYmFua1tpXTsKCQl1MzIgbDsKCgkJaWYgKCEoYmFuay0+ZW5hYmxlZF9ub25fd2FrZXVwX2dwaW9zKSkKCQkJY29udGludWU7CgkJX19yYXdfd3JpdGVsKGJhbmstPnNhdmVkX2ZhbGxpbmdkZXRlY3QsCgkJCQkgYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fRkFMTElOR0RFVEVDVCk7CgkJX19yYXdfd3JpdGVsKGJhbmstPnNhdmVkX3Jpc2luZ2RldGVjdCwKCQkJCSBiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19SSVNJTkdERVRFQ1QpOwoJCS8qIENoZWNrIGlmIGFueSBvZiB0aGUgbm9uLXdha2V1cCBpbnRlcnJ1cHQgR1BJT3MgaGF2ZSBjaGFuZ2VkCgkJICogc3RhdGUuICBJZiBzbywgZ2VuZXJhdGUgYW4gSVJRIGJ5IHNvZnR3YXJlLiAgVGhpcyBpcwoJCSAqIGhvcnJpYmx5IHJhY3ksIGJ1dCBpdCdzIHRoZSBiZXN0IHdlIGNhbiBkbyB0byB3b3JrIGFyb3VuZAoJCSAqIHRoaXMgc2lsaWNvbiBidWcuICovCgkJbCA9IF9fcmF3X3JlYWRsKGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0RBVEFJTik7CgkJbCBePSBiYW5rLT5zYXZlZF9kYXRhaW47CgkJbCAmPSBiYW5rLT5ub25fd2FrZXVwX2dwaW9zOwoJCWlmIChsKSB7CgkJCXUzMiBvbGQwLCBvbGQxOwoKCQkJb2xkMCA9IF9fcmF3X3JlYWRsKGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0xFVkVMREVURUNUMCk7CgkJCW9sZDEgPSBfX3Jhd19yZWFkbChiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDEpOwoJCQlfX3Jhd193cml0ZWwob2xkMCB8IGwsIGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0xFVkVMREVURUNUMCk7CgkJCV9fcmF3X3dyaXRlbChvbGQxIHwgbCwgYmFuay0+YmFzZSArIE9NQVAyNFhYX0dQSU9fTEVWRUxERVRFQ1QxKTsKCQkJX19yYXdfd3JpdGVsKG9sZDAsIGJhbmstPmJhc2UgKyBPTUFQMjRYWF9HUElPX0xFVkVMREVURUNUMCk7CgkJCV9fcmF3X3dyaXRlbChvbGQxLCBiYW5rLT5iYXNlICsgT01BUDI0WFhfR1BJT19MRVZFTERFVEVDVDEpOwoJCX0KCX0KCn0KCiNlbmRpZgoKLyoKICogVGhpcyBtYXkgZ2V0IGNhbGxlZCBlYXJseSBmcm9tIGJvYXJkIHNwZWNpZmljIGluaXQKICogZm9yIGJvYXJkcyB0aGF0IGhhdmUgaW50ZXJydXB0cyByb3V0ZWQgdmlhIEZQR0EuCiAqLwppbnQgX19pbml0IG9tYXBfZ3Bpb19pbml0KHZvaWQpCnsKCWlmICghaW5pdGlhbGl6ZWQpCgkJcmV0dXJuIF9vbWFwX2dwaW9faW5pdCgpOwoJZWxzZQoJCXJldHVybiAwOwp9CgpzdGF0aWMgaW50IF9faW5pdCBvbWFwX2dwaW9fc3lzaW5pdCh2b2lkKQp7CglpbnQgcmV0ID0gMDsKCglpZiAoIWluaXRpYWxpemVkKQoJCXJldCA9IF9vbWFwX2dwaW9faW5pdCgpOwoKCW1wdWlvX2luaXQoKTsKCiNpZiBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAxNlhYKSB8fCBkZWZpbmVkKENPTkZJR19BUkNIX09NQVAyNFhYKQoJaWYgKGNwdV9pc19vbWFwMTZ4eCgpIHx8IGNwdV9pc19vbWFwMjR4eCgpKSB7CgkJaWYgKHJldCA9PSAwKSB7CgkJCXJldCA9IHN5c2Rldl9jbGFzc19yZWdpc3Rlcigmb21hcF9ncGlvX3N5c2NsYXNzKTsKCQkJaWYgKHJldCA9PSAwKQoJCQkJcmV0ID0gc3lzZGV2X3JlZ2lzdGVyKCZvbWFwX2dwaW9fZGV2aWNlKTsKCQl9Cgl9CiNlbmRpZgoKCXJldHVybiByZXQ7Cn0KCkVYUE9SVF9TWU1CT0wob21hcF9yZXF1ZXN0X2dwaW8pOwpFWFBPUlRfU1lNQk9MKG9tYXBfZnJlZV9ncGlvKTsKRVhQT1JUX1NZTUJPTChvbWFwX3NldF9ncGlvX2RpcmVjdGlvbik7CkVYUE9SVF9TWU1CT0wob21hcF9zZXRfZ3Bpb19kYXRhb3V0KTsKRVhQT1JUX1NZTUJPTChvbWFwX2dldF9ncGlvX2RhdGFpbik7CgphcmNoX2luaXRjYWxsKG9tYXBfZ3Bpb19zeXNpbml0KTsKCgojaWZkZWYJQ09ORklHX0RFQlVHX0ZTCgojaW5jbHVkZSA8bGludXgvZGVidWdmcy5oPgojaW5jbHVkZSA8bGludXgvc2VxX2ZpbGUuaD4KCnN0YXRpYyBpbnQgZ3Bpb19pc19pbnB1dChzdHJ1Y3QgZ3Bpb19iYW5rICpiYW5rLCBpbnQgbWFzaykKewoJdm9pZCBfX2lvbWVtICpyZWcgPSBiYW5rLT5iYXNlOwoKCXN3aXRjaCAoYmFuay0+bWV0aG9kKSB7CgljYXNlIE1FVEhPRF9NUFVJTzoKCQlyZWcgKz0gT01BUF9NUFVJT19JT19DTlRMOwoJCWJyZWFrOwoJY2FzZSBNRVRIT0RfR1BJT18xNTEwOgoJCXJlZyArPSBPTUFQMTUxMF9HUElPX0RJUl9DT05UUk9MOwoJCWJyZWFrOwoJY2FzZSBNRVRIT0RfR1BJT18xNjEwOgoJCXJlZyArPSBPTUFQMTYxMF9HUElPX0RJUkVDVElPTjsKCQlicmVhazsKCWNhc2UgTUVUSE9EX0dQSU9fNzMwOgoJCXJlZyArPSBPTUFQNzMwX0dQSU9fRElSX0NPTlRST0w7CgkJYnJlYWs7CgljYXNlIE1FVEhPRF9HUElPXzI0WFg6CgkJcmVnICs9IE9NQVAyNFhYX0dQSU9fT0U7CgkJYnJlYWs7Cgl9CglyZXR1cm4gX19yYXdfcmVhZGwocmVnKSAmIG1hc2s7Cn0KCgpzdGF0aWMgaW50IGRiZ19ncGlvX3Nob3coc3RydWN0IHNlcV9maWxlICpzLCB2b2lkICp1bnVzZWQpCnsKCXVuc2lnbmVkCWksIGosIGdwaW87CgoJZm9yIChpID0gMCwgZ3BpbyA9IDA7IGkgPCBncGlvX2JhbmtfY291bnQ7IGkrKykgewoJCXN0cnVjdCBncGlvX2JhbmsJKmJhbmsgPSBncGlvX2JhbmsgKyBpOwoJCXVuc2lnbmVkCQliYW5rd2lkdGggPSAxNjsKCQl1MzIJCQltYXNrID0gMTsKCgkJaWYgKGJhbmtfaXNfbXB1aW8oYmFuaykpCgkJCWdwaW8gPSBPTUFQX01QVUlPKDApOwoJCWVsc2UgaWYgKGNwdV9pc19vbWFwMjR4eCgpIHx8IGNwdV9pc19vbWFwNzMwKCkpCgkJCWJhbmt3aWR0aCA9IDMyOwoKCQlmb3IgKGogPSAwOyBqIDwgYmFua3dpZHRoOyBqKyssIGdwaW8rKywgbWFzayA8PD0gMSkgewoJCQl1bnNpZ25lZAlpcnEsIHZhbHVlLCBpc19pbiwgaXJxc3RhdDsKCgkJCWlmICghKGJhbmstPnJlc2VydmVkX21hcCAmIG1hc2spKQoJCQkJY29udGludWU7CgoJCQlpcnEgPSBiYW5rLT52aXJ0dWFsX2lycV9zdGFydCArIGo7CgkJCXZhbHVlID0gb21hcF9nZXRfZ3Bpb19kYXRhaW4oZ3Bpbyk7CgkJCWlzX2luID0gZ3Bpb19pc19pbnB1dChiYW5rLCBtYXNrKTsKCgkJCWlmIChiYW5rX2lzX21wdWlvKGJhbmspKQoJCQkJc2VxX3ByaW50ZihzLCAiTVBVSU8gJTJkOiAiLCBqKTsKCQkJZWxzZQoJCQkJc2VxX3ByaW50ZihzLCAiR1BJTyAlM2Q6ICIsIGdwaW8pOwoJCQlzZXFfcHJpbnRmKHMsICIlcyAlcyIsCgkJCQkJaXNfaW4gPyAiaW4gIiA6ICJvdXQiLAoJCQkJCXZhbHVlID8gImhpIiAgOiAibG8iKTsKCgkJCWlycXN0YXQgPSBpcnFfZGVzY1tpcnFdLnN0YXR1czsKCQkJaWYgKGlzX2luICYmICgoYmFuay0+c3VzcGVuZF93YWtldXAgJiBtYXNrKQoJCQkJCXx8IGlycXN0YXQgJiBJUlFfVFlQRV9TRU5TRV9NQVNLKSkgewoJCQkJY2hhcgkqdHJpZ2dlciA9IE5VTEw7CgoJCQkJc3dpdGNoIChpcnFzdGF0ICYgSVJRX1RZUEVfU0VOU0VfTUFTSykgewoJCQkJY2FzZSBJUlFfVFlQRV9FREdFX0ZBTExJTkc6CgkJCQkJdHJpZ2dlciA9ICJmYWxsaW5nIjsKCQkJCQlicmVhazsKCQkJCWNhc2UgSVJRX1RZUEVfRURHRV9SSVNJTkc6CgkJCQkJdHJpZ2dlciA9ICJyaXNpbmciOwoJCQkJCWJyZWFrOwoJCQkJY2FzZSBJUlFfVFlQRV9FREdFX0JPVEg6CgkJCQkJdHJpZ2dlciA9ICJib3RoZWRnZSI7CgkJCQkJYnJlYWs7CgkJCQljYXNlIElSUV9UWVBFX0xFVkVMX0xPVzoKCQkJCQl0cmlnZ2VyID0gImxvdyI7CgkJCQkJYnJlYWs7CgkJCQljYXNlIElSUV9UWVBFX0xFVkVMX0hJR0g6CgkJCQkJdHJpZ2dlciA9ICJoaWdoIjsKCQkJCQlicmVhazsKCQkJCWNhc2UgSVJRX1RZUEVfTk9ORToKCQkJCQl0cmlnZ2VyID0gIih1bnNwZWNpZmllZCkiOwoJCQkJCWJyZWFrOwoJCQkJfQoJCQkJc2VxX3ByaW50ZihzLCAiLCBpcnEtJWQgJXMlcyIsCgkJCQkJCWlycSwgdHJpZ2dlciwKCQkJCQkJKGJhbmstPnN1c3BlbmRfd2FrZXVwICYgbWFzaykKCQkJCQkJCT8gIiB3YWtldXAiIDogIiIpOwoJCQl9CgkJCXNlcV9wcmludGYocywgIlxuIik7CgkJfQoKCQlpZiAoYmFua19pc19tcHVpbyhiYW5rKSkgewoJCQlzZXFfcHJpbnRmKHMsICJcbiIpOwoJCQlncGlvID0gMDsKCQl9Cgl9CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBkYmdfZ3Bpb19vcGVuKHN0cnVjdCBpbm9kZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQp7CglyZXR1cm4gc2luZ2xlX29wZW4oZmlsZSwgZGJnX2dwaW9fc2hvdywgJmlub2RlLT5pX3ByaXZhdGUpOwp9CgpzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBkZWJ1Z19mb3BzID0gewoJLm9wZW4JCT0gZGJnX2dwaW9fb3BlbiwKCS5yZWFkCQk9IHNlcV9yZWFkLAoJLmxsc2VlawkJPSBzZXFfbHNlZWssCgkucmVsZWFzZQk9IHNpbmdsZV9yZWxlYXNlLAp9OwoKc3RhdGljIGludCBfX2luaXQgb21hcF9ncGlvX2RlYnVnaW5pdCh2b2lkKQp7Cgkodm9pZCkgZGVidWdmc19jcmVhdGVfZmlsZSgib21hcF9ncGlvIiwgU19JUlVHTywKCQkJCQlOVUxMLCBOVUxMLCAmZGVidWdfZm9wcyk7CglyZXR1cm4gMDsKfQpsYXRlX2luaXRjYWxsKG9tYXBfZ3Bpb19kZWJ1Z2luaXQpOwojZW5kaWYK