LyoKICogV2luZWZpbGUKICoKICogQ29weXJpZ2h0IDIwMDAsIDIwMDMsIDIwMDQsIDIwMDUgTWFydGluIEZ1Y2hzCiAqCiAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwogKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKICogdmVyc2lvbiAyLjEgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAqCiAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAogKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQogKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgogKgogKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCiAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTkgVGVtcGxlIFBsYWNlLCBTdWl0ZSAzMzAsIEJvc3RvbiwgTUEgIDAyMTExLTEzMDcgIFVTQQogKi8KCiNpZmRlZiBfX1dJTkVfXwojaW5jbHVkZSAiY29uZmlnLmgiCiNpbmNsdWRlICJ3aW5lL3BvcnQuaCIKI2VuZGlmCgojaW5jbHVkZSA8bG9jYWxlLmg+CgojZGVmaW5lIE5PTkFNRUxFU1NVTklPTgojaW5jbHVkZSAid2luZWZpbGUuaCIKI2luY2x1ZGUgInJlc291cmNlLmgiCgovKiBmb3IgcmVhZF9kaXJlY3RvcnlfdW5peCgpICovCiNpZiAhZGVmaW5lZChfTk9fRVhURU5TSU9OUykgJiYgZGVmaW5lZChfX1dJTkVfXykKI2luY2x1ZGUgPGRpcmVudC5oPgojaW5jbHVkZSA8c3lzL3N0YXQuaD4KI2lmZGVmIEhBVkVfVU5JU1REX0gKIyBpbmNsdWRlIDx1bmlzdGQuaD4KI2VuZGlmCiNpbmNsdWRlIDx0aW1lLmg+CiNlbmRpZgoKI2lmZGVmIF9OT19FWFRFTlNJT05TCiN1bmRlZiBfTEVGVF9GSUxFUwojZW5kaWYKCiNpZm5kZWYgX01BWF9QQVRICiNkZWZpbmUgX01BWF9EUklWRSAgICAgICAgICAzCiNkZWZpbmUgX01BWF9GTkFNRSAgICAgICAgICAyNTYKI2RlZmluZSBfTUFYX0RJUiAgICAgICAgICAgIF9NQVhfRk5BTUUKI2RlZmluZSBfTUFYX0VYVCAgICAgICAgICAgIF9NQVhfRk5BTUUKI2RlZmluZSBfTUFYX1BBVEggICAgICAgICAgIDI2MAojZW5kaWYKCiNpZmRlZiBOT05BTUVMRVNTVU5JT04KI2RlZmluZQlVTklPTl9NRU1CRVIoeCkgRFVNTVlVTklPTk5BTUUueAojZWxzZQojZGVmaW5lCVVOSU9OX01FTUJFUih4KSB4CiNlbmRpZgoKCiNpZmRlZiBfU0hFTExfRk9MREVSUwojZGVmaW5lCURFRkFVTFRfU1BMSVRfUE9TCTMwMAojZWxzZQojZGVmaW5lCURFRkFVTFRfU1BMSVRfUE9TCTIwMAojZW5kaWYKCgplbnVtIEVOVFJZX1RZUEUgewoJRVRfV0lORE9XUywKCUVUX1VOSVgsCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJRVRfU0hFTEwKI2VuZGlmCn07Cgp0eXBlZGVmIHN0cnVjdCBfRW50cnkgewoJc3RydWN0IF9FbnRyeSoJbmV4dDsKCXN0cnVjdCBfRW50cnkqCWRvd247CglzdHJ1Y3QgX0VudHJ5Kgl1cDsKCglCT09MCQkJZXhwYW5kZWQ7CglCT09MCQkJc2Nhbm5lZDsKCWludAkJCQlsZXZlbDsKCglXSU4zMl9GSU5EX0RBVEEJZGF0YTsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCUJZX0hBTkRMRV9GSUxFX0lORk9STUFUSU9OIGJoZmk7CglCT09MCQkJYmhmaV92YWxpZDsKCWVudW0gRU5UUllfVFlQRQlldHlwZTsKI2VuZGlmCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJTFBJVEVNSURMSVNUCXBpZGw7CglJU2hlbGxGb2xkZXIqCWZvbGRlcjsKCUhJQ09OCQkJaGljb247CiNlbmRpZgp9IEVudHJ5OwoKdHlwZWRlZiBzdHJ1Y3QgewoJRW50cnkJZW50cnk7CglUQ0hBUglwYXRoW01BWF9QQVRIXTsKCVRDSEFSCXZvbG5hbWVbX01BWF9GTkFNRV07CglUQ0hBUglmc1tfTUFYX0RJUl07CglEV09SRAlkcml2ZV90eXBlOwoJRFdPUkQJZnNfZmxhZ3M7Cn0gUm9vdDsKCmVudW0gQ09MVU1OX0ZMQUdTIHsKCUNPTF9TSVpFCQk9IDB4MDEsCglDT0xfREFURQkJPSAweDAyLAoJQ09MX1RJTUUJCT0gMHgwNCwKCUNPTF9BVFRSSUJVVEVTCT0gMHgwOCwKCUNPTF9ET1NOQU1FUwk9IDB4MTAsCiNpZmRlZiBfTk9fRVhURU5TSU9OUwoJQ09MX0FMTCA9IENPTF9TSVpFfENPTF9EQVRFfENPTF9USU1FfENPTF9BVFRSSUJVVEVTfENPTF9ET1NOQU1FUwojZWxzZQoJQ09MX0lOREVYCQk9IDB4MjAsCglDT0xfTElOS1MJCT0gMHg0MCwKCUNPTF9BTEwgPSBDT0xfU0laRXxDT0xfREFURXxDT0xfVElNRXxDT0xfQVRUUklCVVRFU3xDT0xfRE9TTkFNRVN8Q09MX0lOREVYfENPTF9MSU5LUwojZW5kaWYKfTsKCnR5cGVkZWYgZW51bSB7CglTT1JUX05BTUUsCglTT1JUX0VYVCwKCVNPUlRfU0laRSwKCVNPUlRfREFURQp9IFNPUlRfT1JERVI7Cgp0eXBlZGVmIHN0cnVjdCB7CglIV05ECWh3bmQ7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCUhXTkQJaHduZEhlYWRlcjsKI2VuZGlmCgojaWZuZGVmIF9OT19FWFRFTlNJT05TCiNkZWZpbmUJQ09MVU1OUwkxMAojZWxzZQojZGVmaW5lCUNPTFVNTlMJNQojZW5kaWYKCWludAkJd2lkdGhzW0NPTFVNTlNdOwoJaW50CQlwb3NpdGlvbnNbQ09MVU1OUysxXTsKCglCT09MCXRyZWVQYW5lOwoJaW50CQl2aXNpYmxlX2NvbHM7CglFbnRyeSoJcm9vdDsKCUVudHJ5KgljdXI7Cn0gUGFuZTsKCnR5cGVkZWYgc3RydWN0IHsKCUhXTkQJaHduZDsKCVBhbmUJbGVmdDsKCVBhbmUJcmlnaHQ7CglpbnQJCWZvY3VzX3BhbmU7CQkvKiAwOiBsZWZ0ICAxOiByaWdodCAqLwoJV0lORE9XUExBQ0VNRU5UIHBvczsKCWludAkJc3BsaXRfcG9zOwoJQk9PTAloZWFkZXJfd2R0aHNfb2s7CgoJVENIQVIJcGF0aFtNQVhfUEFUSF07CglSb290CXJvb3Q7CgoJU09SVF9PUkRFUiBzb3J0T3JkZXI7Cn0gQ2hpbGRXbmQ7CgoKZXh0ZXJuIHZvaWQgV2luZUxpY2Vuc2UoSFdORCBod25kKTsKZXh0ZXJuIHZvaWQgV2luZVdhcnJhbnR5KEhXTkQgaHduZCk7CgoKc3RhdGljIHZvaWQgcmVhZF9kaXJlY3RvcnkoRW50cnkqIGRpciwgTFBDVFNUUiBwYXRoLCBTT1JUX09SREVSIHNvcnRPcmRlciwgSFdORCBod25kKTsKc3RhdGljIHZvaWQgc2V0X2N1cmRpcihDaGlsZFduZCogY2hpbGQsIEVudHJ5KiBlbnRyeSwgaW50IGlkeCwgSFdORCBod25kKTsKc3RhdGljIHZvaWQgcmVmcmVzaF9jaGlsZChDaGlsZFduZCogY2hpbGQpOwpzdGF0aWMgdm9pZCByZWZyZXNoX2RyaXZlcygpOwpzdGF0aWMgdm9pZCBnZXRfcGF0aChFbnRyeSogZGlyLCBQVFNUUiBwYXRoKTsKCkxSRVNVTFQgQ0FMTEJBQ0sgRnJhbWVXbmRQcm9jKEhXTkQgaHduZCwgVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKTsKTFJFU1VMVCBDQUxMQkFDSyBDaGlsZFduZFByb2MoSFdORCBod25kLCBVSU5UIG5tc2csIFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pOwpMUkVTVUxUIENBTExCQUNLIFRyZWVXbmRQcm9jKEhXTkQgaHduZCwgVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKTsKCgovKiBnbG9iYWxzICovCldJTkVGSUxFX0dMT0JBTFMgR2xvYmFsczsKCi8qIHNvbWUgY29tbW9uIHN0cmluZyBjb25zdGFudHMgKi8KY29uc3Qgc3RhdGljIFRDSEFSIHNFbXB0eVtdID0geydcMCd9Owpjb25zdCBzdGF0aWMgVENIQVIgc1NwYWNlW10gPSB7JyAnLCAnXDAnfTsKY29uc3Qgc3RhdGljIFRDSEFSIHNOdW1GbXRbXSA9IHsnJScsJ2QnLCdcMCd9Owpjb25zdCBzdGF0aWMgVENIQVIgc1FNYXJrc1tdID0geyc/JywnPycsJz8nLCdcMCd9OwoKLyogd2luZG93IGNsYXNzIG5hbWVzICovCmNvbnN0IHN0YXRpYyBUQ0hBUiBzV0lORUZJTEVGUkFNRVtdID0geydXJywnRicsJ1MnLCdfJywnRicsJ3InLCdhJywnbScsJ2UnLCdcMCd9Owpjb25zdCBzdGF0aWMgVENIQVIgc1dJTkVGSUxFVFJFRVtdID0geydXJywnRicsJ1MnLCdfJywnVCcsJ3InLCdlJywnZScsJ1wwJ307CgojaWZkZWYgX01TQ19WRVIKLyogI2RlZmluZSBMT05HTE9OR0FSRyBfVCgiSTY0IikgKi8KY29uc3Qgc3RhdGljIFRDSEFSIHNMb25nSGV4Rm10W10gPSB7JyUnLCdJJywnNicsJzQnLCdYJywnXDAnfTsKY29uc3Qgc3RhdGljIFRDSEFSIHNMb25nTnVtRm10W10gPSB7JyUnLCdJJywnNicsJzQnLCdkJywnXDAnfTsKI2Vsc2UKLyogI2RlZmluZSBMT05HTE9OR0FSRyBfVCgiTCIpICovCmNvbnN0IHN0YXRpYyBUQ0hBUiBzTG9uZ0hleEZtdFtdID0geyclJywnTCcsJ1gnLCdcMCd9Owpjb25zdCBzdGF0aWMgVENIQVIgc0xvbmdOdW1GbXRbXSA9IHsnJScsJ0wnLCdkJywnXDAnfTsKI2VuZGlmCgoKLyogbG9hZCByZXNvdXJjZSBzdHJpbmcgKi8Kc3RhdGljIExQVFNUUiBsb2FkX3N0cmluZyhMUFRTVFIgYnVmZmVyLCBVSU5UIGlkKQp7CglMb2FkU3RyaW5nKEdsb2JhbHMuaEluc3RhbmNlLCBpZCwgYnVmZmVyLCBCVUZGRVJfTEVOKTsKCglyZXR1cm4gYnVmZmVyOwp9CgojZGVmaW5lIFJTKGIsIGkpIGxvYWRfc3RyaW5nKGIsIGkpCgoKLyogZGlzcGxheSBlcnJvciBtZXNzYWdlIGZvciB0aGUgc3BlY2lmaWVkIFdJTjMyIGVycm9yIGNvZGUgKi8Kc3RhdGljIHZvaWQgZGlzcGxheV9lcnJvcihIV05EIGh3bmQsIERXT1JEIGVycm9yKQp7CglUQ0hBUiBiMVtCVUZGRVJfTEVOXSwgYjJbQlVGRkVSX0xFTl07CglQVFNUUiBtc2c7CgoJaWYgKEZvcm1hdE1lc3NhZ2UoRk9STUFUX01FU1NBR0VfQUxMT0NBVEVfQlVGRkVSfEZPUk1BVF9NRVNTQUdFX0ZST01fU1lTVEVNLAoJCTAsIGVycm9yLCBNQUtFTEFOR0lEKExBTkdfTkVVVFJBTCxTVUJMQU5HX0RFRkFVTFQpLCAoUFRTVFIpJm1zZywgMCwgTlVMTCkpCgkJTWVzc2FnZUJveChod25kLCBtc2csIFJTKGIyLElEU19XSU5FRklMRSksIE1CX09LKTsKCWVsc2UKCQlNZXNzYWdlQm94KGh3bmQsIFJTKGIxLElEU19FUlJPUiksIFJTKGIyLElEU19XSU5FRklMRSksIE1CX09LKTsKCglMb2NhbEZyZWUobXNnKTsKfQoKCi8qIGRpc3BsYXkgbmV0d29yayBlcnJvciBtZXNzYWdlIHVzaW5nIFdOZXRHZXRMYXN0RXJyb3IoKSAqLwpzdGF0aWMgdm9pZCBkaXNwbGF5X25ldHdvcmtfZXJyb3IoSFdORCBod25kKQp7CglUQ0hBUiBtc2dbQlVGRkVSX0xFTl0sIHByb3ZpZGVyW0JVRkZFUl9MRU5dLCBiMltCVUZGRVJfTEVOXTsKCURXT1JEIGVycm9yOwoKCWlmIChXTmV0R2V0TGFzdEVycm9yKCZlcnJvciwgbXNnLCBCVUZGRVJfTEVOLCBwcm92aWRlciwgQlVGRkVSX0xFTikgPT0gTk9fRVJST1IpCgkJTWVzc2FnZUJveChod25kLCBtc2csIFJTKGIyLElEU19XSU5FRklMRSksIE1CX09LKTsKfQoKCi8qIGFsbG9jYXRlIGFuZCBpbml0aWFsaXNlIGEgZGlyZWN0b3J5IGVudHJ5ICovCnN0YXRpYyBFbnRyeSogYWxsb2NfZW50cnkoKQp7CglFbnRyeSogZW50cnkgPSAoRW50cnkqKSBtYWxsb2Moc2l6ZW9mKEVudHJ5KSk7CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCWVudHJ5LT5waWRsID0gTlVMTDsKCWVudHJ5LT5mb2xkZXIgPSBOVUxMOwoJZW50cnktPmhpY29uID0gMDsKI2VuZGlmCgoJcmV0dXJuIGVudHJ5Owp9CgovKiBmcmVlIGEgZGlyZWN0b3J5IGVudHJ5ICovCnN0YXRpYyB2b2lkIGZyZWVfZW50cnkoRW50cnkqIGVudHJ5KQp7CiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKGVudHJ5LT5oaWNvbiAmJiBlbnRyeS0+aGljb24hPShISUNPTiktMSkKCQlEZXN0cm95SWNvbihlbnRyeS0+aGljb24pOwoKCWlmIChlbnRyeS0+Zm9sZGVyICYmIGVudHJ5LT5mb2xkZXIhPUdsb2JhbHMuaURlc2t0b3ApCgkJKCplbnRyeS0+Zm9sZGVyLT5scFZ0YmwtPlJlbGVhc2UpKGVudHJ5LT5mb2xkZXIpOwoKCWlmIChlbnRyeS0+cGlkbCkKCQkoKkdsb2JhbHMuaU1hbGxvYy0+bHBWdGJsLT5GcmVlKShHbG9iYWxzLmlNYWxsb2MsIGVudHJ5LT5waWRsKTsKI2VuZGlmCgoJZnJlZShlbnRyeSk7Cn0KCi8qIHJlY3Vyc2l2ZWx5IGZyZWUgYWxsIGNoaWxkIGVudHJpZXMgKi8Kc3RhdGljIHZvaWQgZnJlZV9lbnRyaWVzKEVudHJ5KiBkaXIpCnsKCUVudHJ5ICplbnRyeSwgKm5leHQ9ZGlyLT5kb3duOwoKCWlmIChuZXh0KSB7CgkJZGlyLT5kb3duID0gMDsKCgkJZG8gewoJCQllbnRyeSA9IG5leHQ7CgkJCW5leHQgPSBlbnRyeS0+bmV4dDsKCgkJCWZyZWVfZW50cmllcyhlbnRyeSk7CgkJCWZyZWVfZW50cnkoZW50cnkpOwoJCX0gd2hpbGUobmV4dCk7Cgl9Cn0KCgpzdGF0aWMgdm9pZCByZWFkX2RpcmVjdG9yeV93aW4oRW50cnkqIGRpciwgTFBDVFNUUiBwYXRoKQp7CglFbnRyeSogZmlyc3RfZW50cnkgPSBOVUxMOwoJRW50cnkqIGxhc3QgPSBOVUxMOwoJRW50cnkqIGVudHJ5OwoKCWludCBsZXZlbCA9IGRpci0+bGV2ZWwgKyAxOwoJV0lOMzJfRklORF9EQVRBIHczMmZkOwoJSEFORExFIGhGaW5kOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCglIQU5ETEUgaEZpbGU7CiNlbmRpZgoKCVRDSEFSIGJ1ZmZlcltNQVhfUEFUSF0sICpwOwoJZm9yKHA9YnVmZmVyOyAqcGF0aDsgKQoJCSpwKysgPSAqcGF0aCsrOwoKCSpwKysgPSAnXFwnOwoJcFswXSA9ICcqJzsKCXBbMV0gPSAnXDAnOwoKCWhGaW5kID0gRmluZEZpcnN0RmlsZShidWZmZXIsICZ3MzJmZCk7CgoJaWYgKGhGaW5kICE9IElOVkFMSURfSEFORExFX1ZBTFVFKSB7CgkJZG8gewoJCQllbnRyeSA9IGFsbG9jX2VudHJ5KCk7CgoJCQlpZiAoIWZpcnN0X2VudHJ5KQoJCQkJZmlyc3RfZW50cnkgPSBlbnRyeTsKCgkJCWlmIChsYXN0KQoJCQkJbGFzdC0+bmV4dCA9IGVudHJ5OwoKCQkJbWVtY3B5KCZlbnRyeS0+ZGF0YSwgJnczMmZkLCBzaXplb2YoV0lOMzJfRklORF9EQVRBKSk7CgkJCWVudHJ5LT5kb3duID0gTlVMTDsKCQkJZW50cnktPnVwID0gZGlyOwoJCQllbnRyeS0+ZXhwYW5kZWQgPSBGQUxTRTsKCQkJZW50cnktPnNjYW5uZWQgPSBGQUxTRTsKCQkJZW50cnktPmxldmVsID0gbGV2ZWw7CgojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJLyogaGlkZSBkaXJlY3RvcnkgZW50cnkgIi4iICovCgkJCWlmIChlbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSB7CgkJCQlMUENUU1RSIG5hbWUgPSBlbnRyeS0+ZGF0YS5jRmlsZU5hbWU7CgoJCQkJaWYgKG5hbWVbMF09PScuJyAmJiBuYW1lWzFdPT0nXDAnKQoJCQkJCWNvbnRpbnVlOwoJCQl9CiNlbHNlCgkJCWVudHJ5LT5ldHlwZSA9IEVUX1dJTkRPV1M7CgkJCWVudHJ5LT5iaGZpX3ZhbGlkID0gRkFMU0U7CgoJCQlsc3RyY3B5KHAsIGVudHJ5LT5kYXRhLmNGaWxlTmFtZSk7CgoJCQloRmlsZSA9IENyZWF0ZUZpbGUoYnVmZmVyLCBHRU5FUklDX1JFQUQsIEZJTEVfU0hBUkVfUkVBRHxGSUxFX1NIQVJFX1dSSVRFfEZJTEVfU0hBUkVfREVMRVRFLAoJCQkJCQkJCTAsIE9QRU5fRVhJU1RJTkcsIEZJTEVfRkxBR19CQUNLVVBfU0VNQU5USUNTLCAwKTsKCgkJCWlmIChoRmlsZSAhPSBJTlZBTElEX0hBTkRMRV9WQUxVRSkgewoJCQkJaWYgKEdldEZpbGVJbmZvcm1hdGlvbkJ5SGFuZGxlKGhGaWxlLCAmZW50cnktPmJoZmkpKQoJCQkJCWVudHJ5LT5iaGZpX3ZhbGlkID0gVFJVRTsKCgkJCQlDbG9zZUhhbmRsZShoRmlsZSk7CgkJCX0KI2VuZGlmCgoJCQlsYXN0ID0gZW50cnk7CgkJfSB3aGlsZShGaW5kTmV4dEZpbGUoaEZpbmQsICZlbnRyeS0+ZGF0YSkpOwoKCQlsYXN0LT5uZXh0ID0gTlVMTDsKCgkJRmluZENsb3NlKGhGaW5kKTsKCX0KCglkaXItPmRvd24gPSBmaXJzdF9lbnRyeTsKCWRpci0+c2Nhbm5lZCA9IFRSVUU7Cn0KCgpzdGF0aWMgRW50cnkqIGZpbmRfZW50cnlfd2luKEVudHJ5KiBkaXIsIExQQ1RTVFIgbmFtZSkKewoJRW50cnkqIGVudHJ5OwoKCWZvcihlbnRyeT1kaXItPmRvd247IGVudHJ5OyBlbnRyeT1lbnRyeS0+bmV4dCkgewoJCUxQQ1RTVFIgcCA9IG5hbWU7CgkJTFBDVFNUUiBxID0gZW50cnktPmRhdGEuY0ZpbGVOYW1lOwoKCQlkbyB7CgkJCWlmICghKnAgfHwgKnA9PVRFWFQoJ1xcJykgfHwgKnA9PVRFWFQoJy8nKSkKCQkJCXJldHVybiBlbnRyeTsKCQl9IHdoaWxlKHRvbG93ZXIoKnArKykgPT0gdG9sb3dlcigqcSsrKSk7CgoJCXAgPSBuYW1lOwoJCXEgPSBlbnRyeS0+ZGF0YS5jQWx0ZXJuYXRlRmlsZU5hbWU7CgoJCWRvIHsKCQkJaWYgKCEqcCB8fCAqcD09VEVYVCgnXFwnKSB8fCAqcD09VEVYVCgnLycpKQoJCQkJcmV0dXJuIGVudHJ5OwoJCX0gd2hpbGUodG9sb3dlcigqcCsrKSA9PSB0b2xvd2VyKCpxKyspKTsKCX0KCglyZXR1cm4gMDsKfQoKCnN0YXRpYyBFbnRyeSogcmVhZF90cmVlX3dpbihSb290KiByb290LCBMUENUU1RSIHBhdGgsIFNPUlRfT1JERVIgc29ydE9yZGVyLCBIV05EIGh3bmQpCnsKCVRDSEFSIGJ1ZmZlcltNQVhfUEFUSF07CglFbnRyeSogZW50cnkgPSAmcm9vdC0+ZW50cnk7CglMUENUU1RSIHMgPSBwYXRoOwoJUFRTVFIgZCA9IGJ1ZmZlcjsKCglIQ1VSU09SIG9sZF9jdXJzb3IgPSBTZXRDdXJzb3IoTG9hZEN1cnNvcigwLCBJRENfV0FJVCkpOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJZW50cnktPmV0eXBlID0gRVRfV0lORE9XUzsKI2VuZGlmCgoJd2hpbGUoZW50cnkpIHsKCQl3aGlsZSgqcyAmJiAqcyE9VEVYVCgnXFwnKSAmJiAqcyE9VEVYVCgnLycpKQoJCQkqZCsrID0gKnMrKzsKCgkJd2hpbGUoKnM9PVRFWFQoJ1xcJykgfHwgKnM9PVRFWFQoJy8nKSkKCQkJcysrOwoKCQkqZCsrID0gVEVYVCgnXFwnKTsKCQkqZCA9IFRFWFQoJ1wwJyk7CgoJCXJlYWRfZGlyZWN0b3J5KGVudHJ5LCBidWZmZXIsIHNvcnRPcmRlciwgaHduZCk7CgoJCWlmIChlbnRyeS0+ZG93bikKCQkJZW50cnktPmV4cGFuZGVkID0gVFJVRTsKCgkJaWYgKCEqcykKCQkJYnJlYWs7CgoJCWVudHJ5ID0gZmluZF9lbnRyeV93aW4oZW50cnksIHMpOwoJfQoKCVNldEN1cnNvcihvbGRfY3Vyc29yKTsKCglyZXR1cm4gZW50cnk7Cn0KCgojaWYgIWRlZmluZWQoX05PX0VYVEVOU0lPTlMpICYmIGRlZmluZWQoX19XSU5FX18pCgpzdGF0aWMgQk9PTCB0aW1lX3RvX2ZpbGV0aW1lKGNvbnN0IHRpbWVfdCogdCwgRklMRVRJTUUqIGZ0aW1lKQp7CglzdHJ1Y3QgdG0qIHRtID0gZ210aW1lKHQpOwoJU1lTVEVNVElNRSBzdGltZTsKCglpZiAoIXRtKQoJCXJldHVybiBGQUxTRTsKCglzdGltZS53WWVhciA9IHRtLT50bV95ZWFyKzE5MDA7CglzdGltZS53TW9udGggPSB0bS0+dG1fbW9uKzE7CgkvKglzdGltZS53RGF5T2ZXZWVrICovCglzdGltZS53RGF5ID0gdG0tPnRtX21kYXk7CglzdGltZS53SG91ciA9IHRtLT50bV9ob3VyOwoJc3RpbWUud01pbnV0ZSA9IHRtLT50bV9taW47CglzdGltZS53U2Vjb25kID0gdG0tPnRtX3NlYzsKCglyZXR1cm4gU3lzdGVtVGltZVRvRmlsZVRpbWUoJnN0aW1lLCBmdGltZSk7Cn0KCnN0YXRpYyB2b2lkIHJlYWRfZGlyZWN0b3J5X3VuaXgoRW50cnkqIGRpciwgTFBDVFNUUiBwYXRoKQp7CglFbnRyeSogZmlyc3RfZW50cnkgPSBOVUxMOwoJRW50cnkqIGxhc3QgPSBOVUxMOwoJRW50cnkqIGVudHJ5OwoKCWludCBsZXZlbCA9IGRpci0+bGV2ZWwgKyAxOwoKCURJUiogcGRpciA9IG9wZW5kaXIocGF0aCk7CgoJaWYgKHBkaXIpIHsKCQlzdHJ1Y3Qgc3RhdCBzdDsKCQlzdHJ1Y3QgZGlyZW50KiBlbnQ7CgkJVENIQVIgYnVmZmVyW01BWF9QQVRIXSwgKnA7CgoJCWZvcihwPWJ1ZmZlcjsgKnBhdGg7ICkKCQkJKnArKyA9ICpwYXRoKys7CgoJCWlmIChwPT1idWZmZXIgfHwgcFstMV0hPScvJykKCQkJKnArKyA9ICcvJzsKCgkJd2hpbGUoKGVudD1yZWFkZGlyKHBkaXIpKSkgewoJCQllbnRyeSA9IGFsbG9jX2VudHJ5KCk7CgoJCQlpZiAoIWZpcnN0X2VudHJ5KQoJCQkJZmlyc3RfZW50cnkgPSBlbnRyeTsKCgkJCWlmIChsYXN0KQoJCQkJbGFzdC0+bmV4dCA9IGVudHJ5OwoKCQkJZW50cnktPmV0eXBlID0gRVRfVU5JWDsKCgkJCWxzdHJjcHkoZW50cnktPmRhdGEuY0ZpbGVOYW1lLCBlbnQtPmRfbmFtZSk7CgkJCWVudHJ5LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgPSBlbnQtPmRfbmFtZVswXT09Jy4nPyBGSUxFX0FUVFJJQlVURV9ISURERU46IDA7CgoJCQlzdHJjcHkocCwgZW50LT5kX25hbWUpOwoKCQkJaWYgKCFzdGF0KGJ1ZmZlciwgJnN0KSkgewoJCQkJaWYgKFNfSVNESVIoc3Quc3RfbW9kZSkpCgkJCQkJZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyB8PSBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk7CgoJCQkJZW50cnktPmRhdGEubkZpbGVTaXplTG93ID0gc3Quc3Rfc2l6ZSAmIDB4RkZGRkZGRkY7CgkJCQllbnRyeS0+ZGF0YS5uRmlsZVNpemVIaWdoID0gc3Quc3Rfc2l6ZSA+PiAzMjsKCgkJCQltZW1zZXQoJmVudHJ5LT5kYXRhLmZ0Q3JlYXRpb25UaW1lLCAwLCBzaXplb2YoRklMRVRJTUUpKTsKCQkJCXRpbWVfdG9fZmlsZXRpbWUoJnN0LnN0X2F0aW1lLCAmZW50cnktPmRhdGEuZnRMYXN0QWNjZXNzVGltZSk7CgkJCQl0aW1lX3RvX2ZpbGV0aW1lKCZzdC5zdF9tdGltZSwgJmVudHJ5LT5kYXRhLmZ0TGFzdFdyaXRlVGltZSk7CgoJCQkJZW50cnktPmJoZmkubkZpbGVJbmRleExvdyA9IGVudC0+ZF9pbm87CgkJCQllbnRyeS0+YmhmaS5uRmlsZUluZGV4SGlnaCA9IDA7CgoJCQkJZW50cnktPmJoZmkubk51bWJlck9mTGlua3MgPSBzdC5zdF9ubGluazsKCgkJCQllbnRyeS0+YmhmaV92YWxpZCA9IFRSVUU7CgkJCX0gZWxzZSB7CgkJCQllbnRyeS0+ZGF0YS5uRmlsZVNpemVMb3cgPSAwOwoJCQkJZW50cnktPmRhdGEubkZpbGVTaXplSGlnaCA9IDA7CgkJCQllbnRyeS0+YmhmaV92YWxpZCA9IEZBTFNFOwoJCQl9CgoJCQllbnRyeS0+ZG93biA9IE5VTEw7CgkJCWVudHJ5LT51cCA9IGRpcjsKCQkJZW50cnktPmV4cGFuZGVkID0gRkFMU0U7CgkJCWVudHJ5LT5zY2FubmVkID0gRkFMU0U7CgkJCWVudHJ5LT5sZXZlbCA9IGxldmVsOwoKCQkJbGFzdCA9IGVudHJ5OwoJCX0KCgkJbGFzdC0+bmV4dCA9IE5VTEw7CgoJCWNsb3NlZGlyKHBkaXIpOwoJfQoKCWRpci0+ZG93biA9IGZpcnN0X2VudHJ5OwoJZGlyLT5zY2FubmVkID0gVFJVRTsKfQoKc3RhdGljIEVudHJ5KiBmaW5kX2VudHJ5X3VuaXgoRW50cnkqIGRpciwgTFBDVFNUUiBuYW1lKQp7CglFbnRyeSogZW50cnk7CgoJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KSB7CgkJTFBDVFNUUiBwID0gbmFtZTsKCQlMUENUU1RSIHEgPSBlbnRyeS0+ZGF0YS5jRmlsZU5hbWU7CgoJCWRvIHsKCQkJaWYgKCEqcCB8fCAqcD09VEVYVCgnLycpKQoJCQkJcmV0dXJuIGVudHJ5OwoJCX0gd2hpbGUoKnArKyA9PSAqcSsrKTsKCX0KCglyZXR1cm4gMDsKfQoKc3RhdGljIEVudHJ5KiByZWFkX3RyZWVfdW5peChSb290KiByb290LCBMUENUU1RSIHBhdGgsIFNPUlRfT1JERVIgc29ydE9yZGVyLCBIV05EIGh3bmQpCnsKCVRDSEFSIGJ1ZmZlcltNQVhfUEFUSF07CglFbnRyeSogZW50cnkgPSAmcm9vdC0+ZW50cnk7CglMUENUU1RSIHMgPSBwYXRoOwoJUFRTVFIgZCA9IGJ1ZmZlcjsKCglIQ1VSU09SIG9sZF9jdXJzb3IgPSBTZXRDdXJzb3IoTG9hZEN1cnNvcigwLCBJRENfV0FJVCkpOwoKCWVudHJ5LT5ldHlwZSA9IEVUX1VOSVg7CgoJd2hpbGUoZW50cnkpIHsKCQl3aGlsZSgqcyAmJiAqcyE9VEVYVCgnLycpKQoJCQkqZCsrID0gKnMrKzsKCgkJd2hpbGUoKnMgPT0gVEVYVCgnLycpKQoJCQlzKys7CgoJCSpkKysgPSBURVhUKCcvJyk7CgkJKmQgPSBURVhUKCdcMCcpOwoKCQlyZWFkX2RpcmVjdG9yeShlbnRyeSwgYnVmZmVyLCBzb3J0T3JkZXIsIGh3bmQpOwoKCQlpZiAoZW50cnktPmRvd24pCgkJCWVudHJ5LT5leHBhbmRlZCA9IFRSVUU7CgoJCWlmICghKnMpCgkJCWJyZWFrOwoKCQllbnRyeSA9IGZpbmRfZW50cnlfdW5peChlbnRyeSwgcyk7Cgl9CgoJU2V0Q3Vyc29yKG9sZF9jdXJzb3IpOwoKCXJldHVybiBlbnRyeTsKfQoKI2VuZGlmIC8qICFkZWZpbmVkKF9OT19FWFRFTlNJT05TKSAmJiBkZWZpbmVkKF9fV0lORV9fKSAqLwoKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoKI2lmZGVmIFVOSUNPREUKI2RlZmluZQl0Y3NjcHluIHN0cmNweW4KI2RlZmluZQlnZXRfc3RycmV0IGdldF9zdHJyZXRXCiNkZWZpbmUJcGF0aF9mcm9tX3BpZGwgcGF0aF9mcm9tX3BpZGxXCiNlbHNlCiNkZWZpbmUJdGNzY3B5biB3Y3NjcHluCiNkZWZpbmUJZ2V0X3N0cnJldCBnZXRfc3RycmV0QQojZGVmaW5lCXBhdGhfZnJvbV9waWRsIHBhdGhfZnJvbV9waWRsQQojZW5kaWYKCgpzdGF0aWMgTFBTVFIgc3RyY3B5bihMUFNUUiBkZXN0LCBMUENTVFIgc291cmNlLCBzaXplX3QgY291bnQpCnsKIExQQ1NUUiBzOwogTFBTVFIgZCA9IGRlc3Q7CgogZm9yKHM9c291cmNlOyBjb3VudCYmKCpkKys9KnMrKyk7ICkKICBjb3VudC0tOwoKIHJldHVybiBkZXN0Owp9CgpzdGF0aWMgTFBXU1RSIHdjc2NweW4oTFBXU1RSIGRlc3QsIExQQ1dTVFIgc291cmNlLCBzaXplX3QgY291bnQpCnsKIExQQ1dTVFIgczsKIExQV1NUUiBkID0gZGVzdDsKCiBmb3Iocz1zb3VyY2U7IGNvdW50JiYoKmQrKz0qcysrKTsgKQogIGNvdW50LS07CgogcmV0dXJuIGRlc3Q7Cn0KCgpzdGF0aWMgdm9pZCBnZXRfc3RycmV0QShTVFJSRVQqIHN0ciwgY29uc3QgU0hJVEVNSUQqIHNoaWlkLCBMUFNUUiBidWZmZXIsIGludCBsZW4pCnsKIHN3aXRjaChzdHItPnVUeXBlKSB7CiAgY2FzZSBTVFJSRVRfV1NUUjoKCVdpZGVDaGFyVG9NdWx0aUJ5dGUoQ1BfQUNQLCAwLCBzdHItPlVOSU9OX01FTUJFUihwT2xlU3RyKSwgLTEsIGJ1ZmZlciwgbGVuLCBOVUxMLCBOVUxMKTsKCWJyZWFrOwoKICBjYXNlIFNUUlJFVF9PRkZTRVQ6CglzdHJjcHluKGJ1ZmZlciwgKExQQ1NUUilzaGlpZCtzdHItPlVOSU9OX01FTUJFUih1T2Zmc2V0KSwgbGVuKTsKCWJyZWFrOwoKICBjYXNlIFNUUlJFVF9DU1RSOgoJc3RyY3B5bihidWZmZXIsIHN0ci0+VU5JT05fTUVNQkVSKGNTdHIpLCBsZW4pOwogfQp9CgpzdGF0aWMgdm9pZCBnZXRfc3RycmV0VyhTVFJSRVQqIHN0ciwgY29uc3QgU0hJVEVNSUQqIHNoaWlkLCBMUFdTVFIgYnVmZmVyLCBpbnQgbGVuKQp7CiBzd2l0Y2goc3RyLT51VHlwZSkgewogIGNhc2UgU1RSUkVUX1dTVFI6Cgl3Y3NjcHluKGJ1ZmZlciwgc3RyLT5VTklPTl9NRU1CRVIocE9sZVN0ciksIGxlbik7CglicmVhazsKCiAgY2FzZSBTVFJSRVRfT0ZGU0VUOgoJTXVsdGlCeXRlVG9XaWRlQ2hhcihDUF9BQ1AsIDAsIChMUENTVFIpc2hpaWQrc3RyLT5VTklPTl9NRU1CRVIodU9mZnNldCksIC0xLCBidWZmZXIsIGxlbik7CglicmVhazsKCiAgY2FzZSBTVFJSRVRfQ1NUUjoKCU11bHRpQnl0ZVRvV2lkZUNoYXIoQ1BfQUNQLCAwLCBzdHItPlVOSU9OX01FTUJFUihjU3RyKSwgLTEsIGJ1ZmZlciwgbGVuKTsKIH0KfQoKCnN0YXRpYyB2b2lkIGZyZWVfc3RycmV0KFNUUlJFVCogc3RyKQp7CglpZiAoc3RyLT51VHlwZSA9PSBTVFJSRVRfV1NUUikKCQkoKkdsb2JhbHMuaU1hbGxvYy0+bHBWdGJsLT5GcmVlKShHbG9iYWxzLmlNYWxsb2MsIHN0ci0+VU5JT05fTUVNQkVSKHBPbGVTdHIpKTsKfQoKCkhSRVNVTFQgbmFtZV9mcm9tX3BpZGwoSVNoZWxsRm9sZGVyKiBmb2xkZXIsIExQSVRFTUlETElTVCBwaWRsLCBMUFRTVFIgYnVmZmVyLCBpbnQgbGVuLCBTSEdETkYgZmxhZ3MpCnsKCVNUUlJFVCBzdHI7CgoJSFJFU1VMVCBociA9ICgqZm9sZGVyLT5scFZ0YmwtPkdldERpc3BsYXlOYW1lT2YpKGZvbGRlciwgcGlkbCwgZmxhZ3MsICZzdHIpOwoKCWlmIChTVUNDRUVERUQoaHIpKSB7CgkJZ2V0X3N0cnJldCgmc3RyLCAmcGlkbC0+bWtpZCwgYnVmZmVyLCBsZW4pOwoJCWZyZWVfc3RycmV0KCZzdHIpOwoJfSBlbHNlCgkJYnVmZmVyWzBdID0gJ1wwJzsKCglyZXR1cm4gaHI7Cn0KCgpIUkVTVUxUIHBhdGhfZnJvbV9waWRsQShJU2hlbGxGb2xkZXIqIGZvbGRlciwgTFBJVEVNSURMSVNUIHBpZGwsIExQU1RSIGJ1ZmZlciwgaW50IGxlbikKewoJU1RSUkVUIHN0cjsKCgkgLyogU0hHRE5fRk9SUEFSU0lORzogZ2V0IGZ1bGwgcGF0aCBvZiBpZCBsaXN0ICovCglIUkVTVUxUIGhyID0gKCpmb2xkZXItPmxwVnRibC0+R2V0RGlzcGxheU5hbWVPZikoZm9sZGVyLCBwaWRsLCBTSEdETl9GT1JQQVJTSU5HLCAmc3RyKTsKCglpZiAoU1VDQ0VFREVEKGhyKSkgewoJCWdldF9zdHJyZXRBKCZzdHIsICZwaWRsLT5ta2lkLCBidWZmZXIsIGxlbik7CgkJZnJlZV9zdHJyZXQoJnN0cik7Cgl9IGVsc2UKCQlidWZmZXJbMF0gPSAnXDAnOwoKCXJldHVybiBocjsKfQoKSFJFU1VMVCBwYXRoX2Zyb21fcGlkbFcoSVNoZWxsRm9sZGVyKiBmb2xkZXIsIExQSVRFTUlETElTVCBwaWRsLCBMUFdTVFIgYnVmZmVyLCBpbnQgbGVuKQp7CglTVFJSRVQgc3RyOwoKCSAvKiBTSEdETl9GT1JQQVJTSU5HOiBnZXQgZnVsbCBwYXRoIG9mIGlkIGxpc3QgKi8KCUhSRVNVTFQgaHIgPSAoKmZvbGRlci0+bHBWdGJsLT5HZXREaXNwbGF5TmFtZU9mKShmb2xkZXIsIHBpZGwsIFNIR0ROX0ZPUlBBUlNJTkcsICZzdHIpOwoKCWlmIChTVUNDRUVERUQoaHIpKSB7CgkJZ2V0X3N0cnJldFcoJnN0ciwgJnBpZGwtPm1raWQsIGJ1ZmZlciwgbGVuKTsKCQlmcmVlX3N0cnJldCgmc3RyKTsKCX0gZWxzZQoJCWJ1ZmZlclswXSA9ICdcMCc7CgoJcmV0dXJuIGhyOwp9CgoKIC8qIGNyZWF0ZSBhbiBpdGVtIGlkIGxpc3QgZnJvbSBhIGZpbGUgc3lzdGVtIHBhdGggKi8KCnN0YXRpYyBMUElURU1JRExJU1QgZ2V0X3BhdGhfcGlkbChMUFRTVFIgcGF0aCwgSFdORCBod25kKQp7CglMUElURU1JRExJU1QgcGlkbDsKCUhSRVNVTFQgaHI7CglVTE9ORyBsZW47CgojaWZkZWYgVU5JQ09ERQoJTFBXU1RSIGJ1ZmZlciA9IHBhdGg7CiNlbHNlCglXQ0hBUiBidWZmZXJbTUFYX1BBVEhdOwoJTXVsdGlCeXRlVG9XaWRlQ2hhcihDUF9BQ1AsIDAsIHBhdGgsIC0xLCBidWZmZXIsIE1BWF9QQVRIKTsKI2VuZGlmCgoJaHIgPSAoKkdsb2JhbHMuaURlc2t0b3AtPmxwVnRibC0+UGFyc2VEaXNwbGF5TmFtZSkoR2xvYmFscy5pRGVza3RvcCwgaHduZCwgTlVMTCwgYnVmZmVyLCAmbGVuLCAmcGlkbCwgTlVMTCk7CglpZiAoRkFJTEVEKGhyKSkKCQlyZXR1cm4gTlVMTDsKCglyZXR1cm4gcGlkbDsKfQoKCiAvKiBjb252ZXJ0IGFuIGl0ZW0gaWQgbGlzdCBmcm9tIHJlbGF0aXZlIHRvIGFic29sdXRlICg9cmVsYXRpdmUgdG8gdGhlIGRlc2t0b3ApIGZvcm1hdCAqLwoKc3RhdGljIExQSVRFTUlETElTVCBnZXRfdG9fYWJzb2x1dGVfcGlkbChFbnRyeSogZW50cnksIEhXTkQgaHduZCkKewoJaWYgKGVudHJ5LT51cCAmJiBlbnRyeS0+dXAtPmV0eXBlPT1FVF9TSEVMTCkgewoJCUlTaGVsbEZvbGRlciogZm9sZGVyID0gZW50cnktPnVwLT5mb2xkZXI7CgkJV0NIQVIgYnVmZmVyW01BWF9QQVRIXTsKCgkJSFJFU1VMVCBociA9IHBhdGhfZnJvbV9waWRsVyhmb2xkZXIsIGVudHJ5LT5waWRsLCBidWZmZXIsIE1BWF9QQVRIKTsKCgkJaWYgKFNVQ0NFRURFRChocikpIHsKCQkJTFBJVEVNSURMSVNUIHBpZGw7CgkJCVVMT05HIGxlbjsKCgkJCWhyID0gKCpHbG9iYWxzLmlEZXNrdG9wLT5scFZ0YmwtPlBhcnNlRGlzcGxheU5hbWUpKEdsb2JhbHMuaURlc2t0b3AsIGh3bmQsIE5VTEwsIGJ1ZmZlciwgJmxlbiwgJnBpZGwsIE5VTEwpOwoKCQkJaWYgKFNVQ0NFRURFRChocikpCgkJCQlyZXR1cm4gcGlkbDsKCQl9Cgl9IGVsc2UgaWYgKGVudHJ5LT5ldHlwZSA9PSBFVF9XSU5ET1dTKSB7CgkJVENIQVIgcGF0aFtNQVhfUEFUSF07CgoJCWdldF9wYXRoKGVudHJ5LCBwYXRoKTsKCgkJcmV0dXJuIGdldF9wYXRoX3BpZGwocGF0aCwgaHduZCk7Cgl9IGVsc2UgaWYgKGVudHJ5LT5waWRsKQoJCXJldHVybiBJTENsb25lKGVudHJ5LT5waWRsKTsKCglyZXR1cm4gTlVMTDsKfQoKCkhJQ09OIGV4dHJhY3RfaWNvbihJU2hlbGxGb2xkZXIqIGZvbGRlciwgTFBDSVRFTUlETElTVCBwaWRsKQp7CglJRXh0cmFjdEljb24qIHBFeHRyYWN0OwoKCWlmIChTVUNDRUVERUQoKCpmb2xkZXItPmxwVnRibC0+R2V0VUlPYmplY3RPZikoZm9sZGVyLCAwLCAxLCAoTFBDSVRFTUlETElTVCopJnBpZGwsICZJSURfSUV4dHJhY3RJY29uLCAwLCAoTFBWT0lEKikmcEV4dHJhY3QpKSkgewoJCVRDSEFSIHBhdGhbX01BWF9QQVRIXTsKCQl1bnNpZ25lZCBmbGFnczsKCQlISUNPTiBoaWNvbjsKCQlpbnQgaWR4OwoKCQlpZiAoU1VDQ0VFREVEKCgqcEV4dHJhY3QtPmxwVnRibC0+R2V0SWNvbkxvY2F0aW9uKShwRXh0cmFjdCwgR0lMX0ZPUlNIRUxMLCBwYXRoLCBfTUFYX1BBVEgsICZpZHgsICZmbGFncykpKSB7CgkJCWlmICghKGZsYWdzICYgR0lMX05PVEZJTEVOQU1FKSkgewoJCQkJaWYgKGlkeCA9PSAtMSkKCQkJCQlpZHggPSAwOwkvKiBzcGVjaWFsIGNhc2UgZm9yIHNvbWUgY29udHJvbCBwYW5lbCBhcHBsaWNhdGlvbnMgKi8KCgkJCQlpZiAoKGludClFeHRyYWN0SWNvbkV4KHBhdGgsIGlkeCwgMCwgJmhpY29uLCAxKSA+IDApCgkJCQkJZmxhZ3MgJj0gfkdJTF9ET05UQ0FDSEU7CgkJCX0gZWxzZSB7CgkJCQlISUNPTiBoSWNvbkxhcmdlID0gMDsKCgkJCQlIUkVTVUxUIGhyID0gKCpwRXh0cmFjdC0+bHBWdGJsLT5FeHRyYWN0KShwRXh0cmFjdCwgcGF0aCwgaWR4LCAmaEljb25MYXJnZSwgJmhpY29uLCBNQUtFTE9ORygwLypHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYSUNPTikqLyxHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU01JQ09OKSkpOwoKCQkJCWlmIChTVUNDRUVERUQoaHIpKQoJCQkJCURlc3Ryb3lJY29uKGhJY29uTGFyZ2UpOwoJCQl9CgoJCQlyZXR1cm4gaGljb247CgkJfQoJfQoKCXJldHVybiAwOwp9CgoKc3RhdGljIEVudHJ5KiBmaW5kX2VudHJ5X3NoZWxsKEVudHJ5KiBkaXIsIExQSVRFTUlETElTVCBwaWRsKQp7CglFbnRyeSogZW50cnk7CgoJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KSB7CgkJaWYgKGVudHJ5LT5waWRsLT5ta2lkLmNiID09IHBpZGwtPm1raWQuY2IgJiYKCQkJIW1lbWNtcChlbnRyeS0+cGlkbCwgcGlkbCwgZW50cnktPnBpZGwtPm1raWQuY2IpKQoJCQlyZXR1cm4gZW50cnk7Cgl9CgoJcmV0dXJuIDA7Cn0KCnN0YXRpYyBFbnRyeSogcmVhZF90cmVlX3NoZWxsKFJvb3QqIHJvb3QsIExQSVRFTUlETElTVCBwaWRsLCBTT1JUX09SREVSIHNvcnRPcmRlciwgSFdORCBod25kKQp7CglFbnRyeSogZW50cnkgPSAmcm9vdC0+ZW50cnk7CglFbnRyeSogbmV4dDsKCUxQSVRFTUlETElTVCBuZXh0X3BpZGwgPSBwaWRsOwoJSVNoZWxsRm9sZGVyKiBmb2xkZXI7CglJU2hlbGxGb2xkZXIqIGNoaWxkID0gTlVMTDsKCUhSRVNVTFQgaHI7CgoJSENVUlNPUiBvbGRfY3Vyc29yID0gU2V0Q3Vyc29yKExvYWRDdXJzb3IoMCwgSURDX1dBSVQpKTsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCWVudHJ5LT5ldHlwZSA9IEVUX1NIRUxMOwojZW5kaWYKCglmb2xkZXIgPSBHbG9iYWxzLmlEZXNrdG9wOwoKCXdoaWxlKGVudHJ5KSB7CgkJZW50cnktPnBpZGwgPSBuZXh0X3BpZGw7CgkJZW50cnktPmZvbGRlciA9IGZvbGRlcjsKCgkJaWYgKCFwaWRsLT5ta2lkLmNiKQoJCQlicmVhazsKCgkJIC8qIGNvcHkgZmlyc3QgZWxlbWVudCBvZiBpdGVtIGlkbGlzdCAqLwoJCW5leHRfcGlkbCA9ICgqR2xvYmFscy5pTWFsbG9jLT5scFZ0YmwtPkFsbG9jKShHbG9iYWxzLmlNYWxsb2MsIHBpZGwtPm1raWQuY2Irc2l6ZW9mKFVTSE9SVCkpOwoJCW1lbWNweShuZXh0X3BpZGwsIHBpZGwsIHBpZGwtPm1raWQuY2IpOwoJCSgoTFBJVEVNSURMSVNUKSgoTFBCWVRFKW5leHRfcGlkbCtwaWRsLT5ta2lkLmNiKSktPm1raWQuY2IgPSAwOwoKCQlociA9ICgqZm9sZGVyLT5scFZ0YmwtPkJpbmRUb09iamVjdCkoZm9sZGVyLCBuZXh0X3BpZGwsIDAsICZJSURfSVNoZWxsRm9sZGVyLCAodm9pZCoqKSZjaGlsZCk7CgkJaWYgKCFTVUNDRUVERUQoaHIpKQoJCQlicmVhazsKCgkJcmVhZF9kaXJlY3RvcnkoZW50cnksIE5VTEwsIHNvcnRPcmRlciwgaHduZCk7CgoJCWlmIChlbnRyeS0+ZG93bikKCQkJZW50cnktPmV4cGFuZGVkID0gVFJVRTsKCgkJbmV4dCA9IGZpbmRfZW50cnlfc2hlbGwoZW50cnksIG5leHRfcGlkbCk7CgkJaWYgKCFuZXh0KQoJCQlicmVhazsKCgkJZm9sZGVyID0gY2hpbGQ7CgkJZW50cnkgPSBuZXh0OwoKCQkgLyogZ28gdG8gbmV4dCBlbGVtZW50ICovCgkJcGlkbCA9IChMUElURU1JRExJU1QpICgoTFBCWVRFKXBpZGwrcGlkbC0+bWtpZC5jYik7Cgl9CgoJU2V0Q3Vyc29yKG9sZF9jdXJzb3IpOwoKCXJldHVybiBlbnRyeTsKfQoKCnN0YXRpYyB2b2lkIGZpbGxfdzMyZmRhdGFfc2hlbGwoSVNoZWxsRm9sZGVyKiBmb2xkZXIsIExQQ0lURU1JRExJU1QgcGlkbCwgU0ZHQU9GIGF0dHJpYnMsIFdJTjMyX0ZJTkRfREFUQSogdzMyZmRhdGEpCnsKCWlmICghKGF0dHJpYnMgJiBTRkdBT19GSUxFU1lTVEVNKSB8fAoJCSAgRkFJTEVEKFNIR2V0RGF0YUZyb21JRExpc3QoZm9sZGVyLCBwaWRsLCBTSEdERklMX0ZJTkREQVRBLCB3MzJmZGF0YSwgc2l6ZW9mKFdJTjMyX0ZJTkRfREFUQSkpKSkgewoJCVdJTjMyX0ZJTEVfQVRUUklCVVRFX0RBVEEgZmFkOwoJCUlEYXRhT2JqZWN0KiBwRGF0YU9iajsKCgkJU1RHTUVESVVNIG1lZGl1bSA9IHswLCB7MH0sIDB9OwoJCUZPUk1BVEVUQyBmbXQgPSB7R2xvYmFscy5jZlN0ckZOYW1lLCAwLCBEVkFTUEVDVF9DT05URU5ULCAtMSwgVFlNRURfSEdMT0JBTH07CgoJCUhSRVNVTFQgaHIgPSAoKmZvbGRlci0+bHBWdGJsLT5HZXRVSU9iamVjdE9mKShmb2xkZXIsIDAsIDEsICZwaWRsLCAmSUlEX0lEYXRhT2JqZWN0LCAwLCAoTFBWT0lEKikmcERhdGFPYmopOwoKCQlpZiAoU1VDQ0VFREVEKGhyKSkgewoJCQlociA9ICgqcERhdGFPYmotPmxwVnRibC0+R2V0RGF0YSkocERhdGFPYmosICZmbXQsICZtZWRpdW0pOwoKCQkJKCpwRGF0YU9iai0+bHBWdGJsLT5SZWxlYXNlKShwRGF0YU9iaik7CgoJCQlpZiAoU1VDQ0VFREVEKGhyKSkgewoJCQkJTFBDVFNUUiBwYXRoID0gKExQQ1RTVFIpR2xvYmFsTG9jayhtZWRpdW0uVU5JT05fTUVNQkVSKGhHbG9iYWwpKTsKCQkJCVVJTlQgc2VtX29yZyA9IFNldEVycm9yTW9kZShTRU1fRkFJTENSSVRJQ0FMRVJST1JTKTsKCgkJCQlpZiAoR2V0RmlsZUF0dHJpYnV0ZXNFeChwYXRoLCBHZXRGaWxlRXhJbmZvU3RhbmRhcmQsICZmYWQpKSB7CgkJCQkJdzMyZmRhdGEtPmR3RmlsZUF0dHJpYnV0ZXMgPSBmYWQuZHdGaWxlQXR0cmlidXRlczsKCQkJCQl3MzJmZGF0YS0+ZnRDcmVhdGlvblRpbWUgPSBmYWQuZnRDcmVhdGlvblRpbWU7CgkJCQkJdzMyZmRhdGEtPmZ0TGFzdEFjY2Vzc1RpbWUgPSBmYWQuZnRMYXN0QWNjZXNzVGltZTsKCQkJCQl3MzJmZGF0YS0+ZnRMYXN0V3JpdGVUaW1lID0gZmFkLmZ0TGFzdFdyaXRlVGltZTsKCgkJCQkJaWYgKCEoZmFkLmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpKSB7CgkJCQkJCXczMmZkYXRhLT5uRmlsZVNpemVMb3cgPSBmYWQubkZpbGVTaXplTG93OwoJCQkJCQl3MzJmZGF0YS0+bkZpbGVTaXplSGlnaCA9IGZhZC5uRmlsZVNpemVIaWdoOwoJCQkJCX0KCQkJCX0KCgkJCQlTZXRFcnJvck1vZGUoc2VtX29yZyk7CgoJCQkJR2xvYmFsVW5sb2NrKG1lZGl1bS5VTklPTl9NRU1CRVIoaEdsb2JhbCkpOwoJCQkJR2xvYmFsRnJlZShtZWRpdW0uVU5JT05fTUVNQkVSKGhHbG9iYWwpKTsKCQkJfQoJCX0KCX0KCglpZiAoYXR0cmlicyAmIChTRkdBT19GT0xERVJ8U0ZHQU9fSEFTU1VCRk9MREVSKSkKCQl3MzJmZGF0YS0+ZHdGaWxlQXR0cmlidXRlcyB8PSBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk7CgoJaWYgKGF0dHJpYnMgJiBTRkdBT19SRUFET05MWSkKCQl3MzJmZGF0YS0+ZHdGaWxlQXR0cmlidXRlcyB8PSBGSUxFX0FUVFJJQlVURV9SRUFET05MWTsKCglpZiAoYXR0cmlicyAmIFNGR0FPX0NPTVBSRVNTRUQpCgkJdzMyZmRhdGEtPmR3RmlsZUF0dHJpYnV0ZXMgfD0gRklMRV9BVFRSSUJVVEVfQ09NUFJFU1NFRDsKfQoKCnN0YXRpYyB2b2lkIHJlYWRfZGlyZWN0b3J5X3NoZWxsKEVudHJ5KiBkaXIsIEhXTkQgaHduZCkKewoJSVNoZWxsRm9sZGVyKiBmb2xkZXIgPSBkaXItPmZvbGRlcjsKCWludCBsZXZlbCA9IGRpci0+bGV2ZWwgKyAxOwoJSFJFU1VMVCBocjsKCglJU2hlbGxGb2xkZXIqIGNoaWxkOwoJSUVudW1JRExpc3QqIGlkbGlzdDsKCglFbnRyeSogZmlyc3RfZW50cnkgPSBOVUxMOwoJRW50cnkqIGxhc3QgPSBOVUxMOwoJRW50cnkqIGVudHJ5OwoKCWlmICghZm9sZGVyKQoJCXJldHVybjsKCglociA9ICgqZm9sZGVyLT5scFZ0YmwtPkVudW1PYmplY3RzKShmb2xkZXIsIGh3bmQsIFNIQ09OVEZfRk9MREVSU3xTSENPTlRGX05PTkZPTERFUlN8U0hDT05URl9JTkNMVURFSElEREVOfFNIQ09OVEZfU0hBUkVBQkxFfFNIQ09OVEZfU1RPUkFHRSwgJmlkbGlzdCk7CgoJaWYgKFNVQ0NFRURFRChocikpIHsKCQlmb3IoOzspIHsKI2RlZmluZQlGRVRDSF9JVEVNX0NPVU5UCTMyCgkJCUxQSVRFTUlETElTVCBwaWRsc1tGRVRDSF9JVEVNX0NPVU5UXTsKCQkJU0ZHQU9GIGF0dHJpYnM7CgkJCVVMT05HIGNudCA9IDA7CgkJCVVMT05HIG47CgoJCQltZW1zZXQocGlkbHMsIDAsIHNpemVvZihwaWRscykpOwoKCQkJaHIgPSAoKmlkbGlzdC0+bHBWdGJsLT5OZXh0KShpZGxpc3QsIEZFVENIX0lURU1fQ09VTlQsIHBpZGxzLCAmY250KTsKCQkJaWYgKCFTVUNDRUVERUQoaHIpKQoJCQkJYnJlYWs7CgoJCQlpZiAoaHIgPT0gU19GQUxTRSkKCQkJCWJyZWFrOwoKCQkJZm9yKG49MDsgbjxjbnQ7ICsrbikgewoJCQkJZW50cnkgPSBhbGxvY19lbnRyeSgpOwoKCQkJCWlmICghZmlyc3RfZW50cnkpCgkJCQkJZmlyc3RfZW50cnkgPSBlbnRyeTsKCgkJCQlpZiAobGFzdCkKCQkJCQlsYXN0LT5uZXh0ID0gZW50cnk7CgoJCQkJbWVtc2V0KCZlbnRyeS0+ZGF0YSwgMCwgc2l6ZW9mKFdJTjMyX0ZJTkRfREFUQSkpOwoJCQkJZW50cnktPmJoZmlfdmFsaWQgPSBGQUxTRTsKCgkJCQlhdHRyaWJzID0gflNGR0FPX0ZJTEVTWVNURU07CS8qU0ZHQU9fSEFTU1VCRk9MREVSfFNGR0FPX0ZPTERFUjsgU0ZHQU9fRklMRVNZU1RFTSBzb3JndCBkYWb8ciwgZGHfICJNeSBEb2N1bWVudHMiIGFuc3RhdHQgdm9uICJNYXJ0aW4ncyBEb2N1bWVudHMiIGFuZ2V6ZWlndCB3aXJkICovCgoJCQkJaHIgPSAoKmZvbGRlci0+bHBWdGJsLT5HZXRBdHRyaWJ1dGVzT2YpKGZvbGRlciwgMSwgKExQQ0lURU1JRExJU1QqKSZwaWRsc1tuXSwgJmF0dHJpYnMpOwoKCQkJCWlmIChTVUNDRUVERUQoaHIpKSB7CgkJCQkJaWYgKGF0dHJpYnMgIT0gKFNGR0FPRil+U0ZHQU9fRklMRVNZU1RFTSkgewoJCQkJCQlmaWxsX3czMmZkYXRhX3NoZWxsKGZvbGRlciwgcGlkbHNbbl0sIGF0dHJpYnMsICZlbnRyeS0+ZGF0YSk7CgoJCQkJCQllbnRyeS0+YmhmaV92YWxpZCA9IFRSVUU7CgkJCQkJfSBlbHNlCgkJCQkJCWF0dHJpYnMgPSAwOwoJCQkJfSBlbHNlCgkJCQkJYXR0cmlicyA9IDA7CgoJCQkJZW50cnktPnBpZGwgPSBwaWRsc1tuXTsKCgkJCQlpZiAoZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkgewoJCQkJCWhyID0gKCpmb2xkZXItPmxwVnRibC0+QmluZFRvT2JqZWN0KShmb2xkZXIsIHBpZGxzW25dLCAwLCAmSUlEX0lTaGVsbEZvbGRlciwgKHZvaWQqKikmY2hpbGQpOwoKCQkJCQlpZiAoU1VDQ0VFREVEKGhyKSkKCQkJCQkJZW50cnktPmZvbGRlciA9IGNoaWxkOwoJCQkJCWVsc2UKCQkJCQkJZW50cnktPmZvbGRlciA9IE5VTEw7CgkJCQl9CgkJCQllbHNlCgkJCQkJZW50cnktPmZvbGRlciA9IE5VTEw7CgoJCQkJaWYgKCFlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMF0pCgkJCQkJLypociA9ICovbmFtZV9mcm9tX3BpZGwoZm9sZGVyLCBwaWRsc1tuXSwgZW50cnktPmRhdGEuY0ZpbGVOYW1lLCBNQVhfUEFUSCwgLypTSEdETl9JTkZPTERFUiovMHgyMDAwLyoweDIwMDA9U0hHRE5fSU5DTFVERV9OT05GSUxFU1lTKi8pOwoKCQkJCSAvKiBnZXQgZGlzcGxheSBpY29ucyBmb3IgZmlsZXMgYW5kIHZpcnR1YWwgb2JqZWN0cyAqLwoJCQkJaWYgKCEoZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkgfHwKCQkJCQkhKGF0dHJpYnMgJiBTRkdBT19GSUxFU1lTVEVNKSkgewoJCQkJCWVudHJ5LT5oaWNvbiA9IGV4dHJhY3RfaWNvbihmb2xkZXIsIHBpZGxzW25dKTsKCgkJCQkJaWYgKCFlbnRyeS0+aGljb24pCgkJCQkJCWVudHJ5LT5oaWNvbiA9IChISUNPTiktMTsJLyogZG9uJ3QgdHJ5IGFnYWluIGxhdGVyICovCgkJCQl9CgoJCQkJZW50cnktPmRvd24gPSBOVUxMOwoJCQkJZW50cnktPnVwID0gZGlyOwoJCQkJZW50cnktPmV4cGFuZGVkID0gRkFMU0U7CgkJCQllbnRyeS0+c2Nhbm5lZCA9IEZBTFNFOwoJCQkJZW50cnktPmxldmVsID0gbGV2ZWw7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQllbnRyeS0+ZXR5cGUgPSBFVF9TSEVMTDsKCQkJCWVudHJ5LT5iaGZpX3ZhbGlkID0gRkFMU0U7CiNlbmRpZgoKCQkJCWxhc3QgPSBlbnRyeTsKCQkJfQoJCX0KCgkJKCppZGxpc3QtPmxwVnRibC0+UmVsZWFzZSkoaWRsaXN0KTsKCX0KCglpZiAobGFzdCkKCQlsYXN0LT5uZXh0ID0gTlVMTDsKCglkaXItPmRvd24gPSBmaXJzdF9lbnRyeTsKCWRpci0+c2Nhbm5lZCA9IFRSVUU7Cn0KCiNlbmRpZiAvKiBfU0hFTExfRk9MREVSUyAqLwoKCi8qIHNvcnQgb3JkZXIgZm9yIGRpZmZlcmVudCBkaXJlY3RvcnkvZmlsZSB0eXBlcyAqLwplbnVtIFRZUEVfT1JERVIgewoJVE9fRElSID0gMCwKCVRPX0RPVCA9IDEsCglUT19ET1RET1QgPSAyLAoJVE9fT1RIRVJfRElSID0gMywKCVRPX0ZJTEUgPSA0Cn07CgovKiBkaXN0aW5ndWlzaCBiZXR3ZWVuICIuIiwgIi4uIiBhbmQgYW55IG90aGVyIGRpcmVjdG9yeSBuYW1lcyAqLwpzdGF0aWMgaW50IFR5cGVPcmRlckZyb21EaXJuYW1lKExQQ1RTVFIgbmFtZSkKewoJaWYgKG5hbWVbMF0gPT0gJy4nKSB7CgkJaWYgKG5hbWVbMV0gPT0gJ1wwJykKCQkJcmV0dXJuIFRPX0RPVDsJLyogIi4iICovCgoJCWlmIChuYW1lWzFdPT0nLicgJiYgbmFtZVsyXT09J1wwJykKCQkJcmV0dXJuIFRPX0RPVERPVDsJLyogIi4uIiAqLwoJfQoKCXJldHVybiBUT19PVEhFUl9ESVI7CS8qIGFueXRoaW5nIGVsc2UgKi8KfQoKLyogZGlyZWN0b3JpZXMgZmlyc3QuLi4gKi8Kc3RhdGljIGludCBjb21wYXJlVHlwZShjb25zdCBXSU4zMl9GSU5EX0RBVEEqIGZkMSwgY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDIpCnsKCWludCBvcmRlcjEgPSBmZDEtPmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk/IFRPX0RJUjogVE9fRklMRTsKCWludCBvcmRlcjIgPSBmZDItPmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk/IFRPX0RJUjogVE9fRklMRTsKCgkvKiBIYW5kbGUgIi4iIGFuZCAiLi4iIGFzIHNwZWNpYWwgY2FzZSBhbmQgbW92ZSB0aGVtIGF0IHRoZSB2ZXJ5IGZpcnN0IGJlZ2lubmluZy4gKi8KCWlmIChvcmRlcjE9PVRPX0RJUiAmJiBvcmRlcjI9PVRPX0RJUikgewoJCW9yZGVyMSA9IFR5cGVPcmRlckZyb21EaXJuYW1lKGZkMS0+Y0ZpbGVOYW1lKTsKCQlvcmRlcjIgPSBUeXBlT3JkZXJGcm9tRGlybmFtZShmZDItPmNGaWxlTmFtZSk7Cgl9CgoJcmV0dXJuIG9yZGVyMj09b3JkZXIxPyAwOiBvcmRlcjE8b3JkZXIyPyAtMTogMTsKfQoKCnN0YXRpYyBpbnQgY29tcGFyZU5hbWUoY29uc3Qgdm9pZCogYXJnMSwgY29uc3Qgdm9pZCogYXJnMikKewoJY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDEgPSAmKCooY29uc3QgRW50cnkqIGNvbnN0KilhcmcxKS0+ZGF0YTsKCWNvbnN0IFdJTjMyX0ZJTkRfREFUQSogZmQyID0gJigqKGNvbnN0IEVudHJ5KiBjb25zdCopYXJnMiktPmRhdGE7CgoJaW50IGNtcCA9IGNvbXBhcmVUeXBlKGZkMSwgZmQyKTsKCWlmIChjbXApCgkJcmV0dXJuIGNtcDsKCglyZXR1cm4gbHN0cmNtcGkoZmQxLT5jRmlsZU5hbWUsIGZkMi0+Y0ZpbGVOYW1lKTsKfQoKc3RhdGljIGludCBjb21wYXJlRXh0KGNvbnN0IHZvaWQqIGFyZzEsIGNvbnN0IHZvaWQqIGFyZzIpCnsKCWNvbnN0IFdJTjMyX0ZJTkRfREFUQSogZmQxID0gJigqKGNvbnN0IEVudHJ5KiBjb25zdCopYXJnMSktPmRhdGE7Cgljb25zdCBXSU4zMl9GSU5EX0RBVEEqIGZkMiA9ICYoKihjb25zdCBFbnRyeSogY29uc3QqKWFyZzIpLT5kYXRhOwoJY29uc3QgVENIQVIgKm5hbWUxLCAqbmFtZTIsICpleHQxLCAqZXh0MjsKCglpbnQgY21wID0gY29tcGFyZVR5cGUoZmQxLCBmZDIpOwoJaWYgKGNtcCkKCQlyZXR1cm4gY21wOwoKCW5hbWUxID0gZmQxLT5jRmlsZU5hbWU7CgluYW1lMiA9IGZkMi0+Y0ZpbGVOYW1lOwoKCWV4dDEgPSBfdGNzcmNocihuYW1lMSwgVEVYVCgnLicpKTsKCWV4dDIgPSBfdGNzcmNocihuYW1lMiwgVEVYVCgnLicpKTsKCglpZiAoZXh0MSkKCQlleHQxKys7CgllbHNlCgkJZXh0MSA9IHNFbXB0eTsKCglpZiAoZXh0MikKCQlleHQyKys7CgllbHNlCgkJZXh0MiA9IHNFbXB0eTsKCgljbXAgPSBsc3RyY21waShleHQxLCBleHQyKTsKCWlmIChjbXApCgkJcmV0dXJuIGNtcDsKCglyZXR1cm4gbHN0cmNtcGkobmFtZTEsIG5hbWUyKTsKfQoKc3RhdGljIGludCBjb21wYXJlU2l6ZShjb25zdCB2b2lkKiBhcmcxLCBjb25zdCB2b2lkKiBhcmcyKQp7Cgljb25zdCBXSU4zMl9GSU5EX0RBVEEqIGZkMSA9ICYoKihjb25zdCBFbnRyeSogY29uc3QqKWFyZzEpLT5kYXRhOwoJY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDIgPSAmKCooY29uc3QgRW50cnkqIGNvbnN0KilhcmcyKS0+ZGF0YTsKCglpbnQgY21wID0gY29tcGFyZVR5cGUoZmQxLCBmZDIpOwoJaWYgKGNtcCkKCQlyZXR1cm4gY21wOwoKCWNtcCA9IGZkMi0+bkZpbGVTaXplSGlnaCAtIGZkMS0+bkZpbGVTaXplSGlnaDsKCglpZiAoY21wIDwgMCkKCQlyZXR1cm4gLTE7CgllbHNlIGlmIChjbXAgPiAwKQoJCXJldHVybiAxOwoKCWNtcCA9IGZkMi0+bkZpbGVTaXplTG93IC0gZmQxLT5uRmlsZVNpemVMb3c7CgoJcmV0dXJuIGNtcDwwPyAtMTogY21wPjA/IDE6IDA7Cn0KCnN0YXRpYyBpbnQgY29tcGFyZURhdGUoY29uc3Qgdm9pZCogYXJnMSwgY29uc3Qgdm9pZCogYXJnMikKewoJY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDEgPSAmKCooY29uc3QgRW50cnkqIGNvbnN0KilhcmcxKS0+ZGF0YTsKCWNvbnN0IFdJTjMyX0ZJTkRfREFUQSogZmQyID0gJigqKGNvbnN0IEVudHJ5KiBjb25zdCopYXJnMiktPmRhdGE7CgoJaW50IGNtcCA9IGNvbXBhcmVUeXBlKGZkMSwgZmQyKTsKCWlmIChjbXApCgkJcmV0dXJuIGNtcDsKCglyZXR1cm4gQ29tcGFyZUZpbGVUaW1lKCZmZDItPmZ0TGFzdFdyaXRlVGltZSwgJmZkMS0+ZnRMYXN0V3JpdGVUaW1lKTsKfQoKCnN0YXRpYyBpbnQgKCpzb3J0RnVuY3Rpb25zW10pKGNvbnN0IHZvaWQqIGFyZzEsIGNvbnN0IHZvaWQqIGFyZzIpID0gewoJY29tcGFyZU5hbWUsCS8qIFNPUlRfTkFNRSAqLwoJY29tcGFyZUV4dCwJCS8qIFNPUlRfRVhUICovCgljb21wYXJlU2l6ZSwJLyogU09SVF9TSVpFICovCgljb21wYXJlRGF0ZQkJLyogU09SVF9EQVRFICovCn07CgoKc3RhdGljIHZvaWQgU29ydERpcmVjdG9yeShFbnRyeSogZGlyLCBTT1JUX09SREVSIHNvcnRPcmRlcikKewoJRW50cnkqIGVudHJ5ID0gZGlyLT5kb3duOwoJRW50cnkqKiBhcnJheSwgKipwOwoJaW50IGxlbjsKCglsZW4gPSAwOwoJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KQoJCWxlbisrOwoKCWlmIChsZW4pIHsKCQlhcnJheSA9IEhlYXBBbGxvYyhHZXRQcm9jZXNzSGVhcCgpLCAwLCBsZW4qc2l6ZW9mKEVudHJ5KikpOwoKCQlwID0gYXJyYXk7CgkJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KQoJCQkqcCsrID0gZW50cnk7CgoJCS8qIGNhbGwgcXNvcnQgd2l0aCB0aGUgYXBwcm9wcmlhdGUgY29tcGFyZSBmdW5jdGlvbiAqLwoJCXFzb3J0KGFycmF5LCBsZW4sIHNpemVvZihhcnJheVswXSksIHNvcnRGdW5jdGlvbnNbc29ydE9yZGVyXSk7CgoJCWRpci0+ZG93biA9IGFycmF5WzBdOwoKCQlmb3IocD1hcnJheTsgLS1sZW47IHArKykKCQkJcFswXS0+bmV4dCA9IHBbMV07CgoJCSgqcCktPm5leHQgPSAwOwogICAgICAgICAgICAgICAgSGVhcEZyZWUoIEdldFByb2Nlc3NIZWFwKCksIDAsIGFycmF5ICk7Cgl9Cn0KCgpzdGF0aWMgdm9pZCByZWFkX2RpcmVjdG9yeShFbnRyeSogZGlyLCBMUENUU1RSIHBhdGgsIFNPUlRfT1JERVIgc29ydE9yZGVyLCBIV05EIGh3bmQpCnsKCVRDSEFSIGJ1ZmZlcltNQVhfUEFUSF07CglFbnRyeSogZW50cnk7CglMUENUU1RSIHM7CglQVFNUUiBkOwoKI2lmZGVmIF9TSEVMTF9GT0xERVJTCglpZiAoZGlyLT5ldHlwZSA9PSBFVF9TSEVMTCkKCXsKCQlyZWFkX2RpcmVjdG9yeV9zaGVsbChkaXIsIGh3bmQpOwoKCQlpZiAoR2xvYmFscy5wcmVzY2FuX25vZGUpIHsKCQkJcyA9IHBhdGg7CgkJCWQgPSBidWZmZXI7CgoJCQl3aGlsZSgqcykKCQkJCSpkKysgPSAqcysrOwoKCQkJKmQrKyA9IFRFWFQoJ1xcJyk7CgoJCQlmb3IoZW50cnk9ZGlyLT5kb3duOyBlbnRyeTsgZW50cnk9ZW50cnktPm5leHQpCgkJCQlpZiAoZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkgewoJCQkJCXJlYWRfZGlyZWN0b3J5X3NoZWxsKGVudHJ5LCBod25kKTsKCQkJCQlTb3J0RGlyZWN0b3J5KGVudHJ5LCBzb3J0T3JkZXIpOwoJCQkJfQoJCX0KCX0KCWVsc2UKI2VuZGlmCiNpZiAhZGVmaW5lZChfTk9fRVhURU5TSU9OUykgJiYgZGVmaW5lZChfX1dJTkVfXykKCWlmIChkaXItPmV0eXBlID09IEVUX1VOSVgpCgl7CgkJcmVhZF9kaXJlY3RvcnlfdW5peChkaXIsIHBhdGgpOwoKCQlpZiAoR2xvYmFscy5wcmVzY2FuX25vZGUpIHsKCQkJcyA9IHBhdGg7CgkJCWQgPSBidWZmZXI7CgoJCQl3aGlsZSgqcykKCQkJCSpkKysgPSAqcysrOwoKCQkJKmQrKyA9IFRFWFQoJy8nKTsKCgkJCWZvcihlbnRyeT1kaXItPmRvd247IGVudHJ5OyBlbnRyeT1lbnRyeS0+bmV4dCkKCQkJCWlmIChlbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSB7CgkJCQkJbHN0cmNweShkLCBlbnRyeS0+ZGF0YS5jRmlsZU5hbWUpOwoJCQkJCXJlYWRfZGlyZWN0b3J5X3VuaXgoZW50cnksIGJ1ZmZlcik7CgkJCQkJU29ydERpcmVjdG9yeShlbnRyeSwgc29ydE9yZGVyKTsKCQkJCX0KCQl9Cgl9CgllbHNlCiNlbmRpZgoJewoJCXJlYWRfZGlyZWN0b3J5X3dpbihkaXIsIHBhdGgpOwoKCQlpZiAoR2xvYmFscy5wcmVzY2FuX25vZGUpIHsKCQkJcyA9IHBhdGg7CgkJCWQgPSBidWZmZXI7CgoJCQl3aGlsZSgqcykKCQkJCSpkKysgPSAqcysrOwoKCQkJKmQrKyA9IFRFWFQoJ1xcJyk7CgoJCQlmb3IoZW50cnk9ZGlyLT5kb3duOyBlbnRyeTsgZW50cnk9ZW50cnktPm5leHQpCgkJCQlpZiAoZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkgewoJCQkJCWxzdHJjcHkoZCwgZW50cnktPmRhdGEuY0ZpbGVOYW1lKTsKCQkJCQlyZWFkX2RpcmVjdG9yeV93aW4oZW50cnksIGJ1ZmZlcik7CgkJCQkJU29ydERpcmVjdG9yeShlbnRyeSwgc29ydE9yZGVyKTsKCQkJCX0KCQl9Cgl9CgoJU29ydERpcmVjdG9yeShkaXIsIHNvcnRPcmRlcik7Cn0KCgpzdGF0aWMgRW50cnkqIHJlYWRfdHJlZShSb290KiByb290LCBMUENUU1RSIHBhdGgsIExQSVRFTUlETElTVCBwaWRsLCBMUFRTVFIgZHJ2LCBTT1JUX09SREVSIHNvcnRPcmRlciwgSFdORCBod25kKQp7CiNpZiAhZGVmaW5lZChfTk9fRVhURU5TSU9OUykgJiYgZGVmaW5lZChfX1dJTkVfXykKCWNvbnN0IHN0YXRpYyBUQ0hBUiBzU2xhc2hbXSA9IHsnLycsICdcMCd9OwojZW5kaWYKCWNvbnN0IHN0YXRpYyBUQ0hBUiBzQmFja3NsYXNoW10gPSB7J1xcJywgJ1wwJ307CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCWlmIChwaWRsKQoJewoJCSAvKiByZWFkIHNoZWxsIG5hbWVzcGFjZSB0cmVlICovCgkJcm9vdC0+ZHJpdmVfdHlwZSA9IERSSVZFX1VOS05PV047CgkJZHJ2WzBdID0gJ1xcJzsKCQlkcnZbMV0gPSAnXDAnOwoJCWxvYWRfc3RyaW5nKHJvb3QtPnZvbG5hbWUsIElEU19ERVNLVE9QKTsKCQlyb290LT5mc19mbGFncyA9IDA7CgkJbG9hZF9zdHJpbmcocm9vdC0+ZnMsIElEU19TSEVMTCk7CgoJCXJldHVybiByZWFkX3RyZWVfc2hlbGwocm9vdCwgcGlkbCwgc29ydE9yZGVyLCBod25kKTsKCX0KCWVsc2UKI2VuZGlmCiNpZiAhZGVmaW5lZChfTk9fRVhURU5TSU9OUykgJiYgZGVmaW5lZChfX1dJTkVfXykKCWlmICgqcGF0aCA9PSAnLycpCgl7CgkJIC8qIHJlYWQgdW5peCBmaWxlIHN5c3RlbSB0cmVlICovCgkJcm9vdC0+ZHJpdmVfdHlwZSA9IEdldERyaXZlVHlwZShwYXRoKTsKCgkJbHN0cmNhdChkcnYsIHNTbGFzaCk7CgkJbG9hZF9zdHJpbmcocm9vdC0+dm9sbmFtZSwgSURTX1JPT1RfRlMpOwoJCXJvb3QtPmZzX2ZsYWdzID0gMDsKCQlsb2FkX3N0cmluZyhyb290LT5mcywgSURTX1VOSVhGUyk7CgoJCWxzdHJjcHkocm9vdC0+cGF0aCwgc1NsYXNoKTsKCgkJcmV0dXJuIHJlYWRfdHJlZV91bml4KHJvb3QsIHBhdGgsIHNvcnRPcmRlciwgaHduZCk7Cgl9CiNlbmRpZgoKCSAvKiByZWFkIFdJTjMyIGZpbGUgc3lzdGVtIHRyZWUgKi8KCXJvb3QtPmRyaXZlX3R5cGUgPSBHZXREcml2ZVR5cGUocGF0aCk7CgoJbHN0cmNhdChkcnYsIHNCYWNrc2xhc2gpOwoJR2V0Vm9sdW1lSW5mb3JtYXRpb24oZHJ2LCByb290LT52b2xuYW1lLCBfTUFYX0ZOQU1FLCAwLCAwLCAmcm9vdC0+ZnNfZmxhZ3MsIHJvb3QtPmZzLCBfTUFYX0RJUik7CgoJbHN0cmNweShyb290LT5wYXRoLCBkcnYpOwoKCXJldHVybiByZWFkX3RyZWVfd2luKHJvb3QsIHBhdGgsIHNvcnRPcmRlciwgaHduZCk7Cn0KCgpzdGF0aWMgQ2hpbGRXbmQqIGFsbG9jX2NoaWxkX3dpbmRvdyhMUENUU1RSIHBhdGgsIExQSVRFTUlETElTVCBwaWRsLCBIV05EIGh3bmQpCnsKCVRDSEFSIGRydltfTUFYX0RSSVZFKzFdLCBkaXJbX01BWF9ESVJdLCBuYW1lW19NQVhfRk5BTUVdLCBleHRbX01BWF9FWFRdOwoJVENIQVIgYjFbQlVGRkVSX0xFTl07CgoJQ2hpbGRXbmQqIGNoaWxkID0gKENoaWxkV25kKikgbWFsbG9jKHNpemVvZihDaGlsZFduZCkpOwoJUm9vdCogcm9vdCA9ICZjaGlsZC0+cm9vdDsKCUVudHJ5KiBlbnRyeTsKCgltZW1zZXQoY2hpbGQsIDAsIHNpemVvZihDaGlsZFduZCkpOwoKCWNoaWxkLT5sZWZ0LnRyZWVQYW5lID0gVFJVRTsKCWNoaWxkLT5sZWZ0LnZpc2libGVfY29scyA9IDA7CgoJY2hpbGQtPnJpZ2h0LnRyZWVQYW5lID0gRkFMU0U7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCWNoaWxkLT5yaWdodC52aXNpYmxlX2NvbHMgPSBDT0xfU0laRXxDT0xfREFURXxDT0xfVElNRXxDT0xfQVRUUklCVVRFU3xDT0xfSU5ERVh8Q09MX0xJTktTOwojZWxzZQoJY2hpbGQtPnJpZ2h0LnZpc2libGVfY29scyA9IENPTF9TSVpFfENPTF9EQVRFfENPTF9USU1FfENPTF9BVFRSSUJVVEVTOwojZW5kaWYKCgljaGlsZC0+cG9zLmxlbmd0aCA9IHNpemVvZihXSU5ET1dQTEFDRU1FTlQpOwoJY2hpbGQtPnBvcy5mbGFncyA9IDA7CgljaGlsZC0+cG9zLnNob3dDbWQgPSBTV19TSE9XTk9STUFMOwoJY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLmxlZnQgPSBDV19VU0VERUZBVUxUOwoJY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLnRvcCA9IENXX1VTRURFRkFVTFQ7CgljaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24ucmlnaHQgPSBDV19VU0VERUZBVUxUOwoJY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLmJvdHRvbSA9IENXX1VTRURFRkFVTFQ7CgoJY2hpbGQtPmZvY3VzX3BhbmUgPSAwOwoJY2hpbGQtPnNwbGl0X3BvcyA9IERFRkFVTFRfU1BMSVRfUE9TOwoJY2hpbGQtPnNvcnRPcmRlciA9IFNPUlRfTkFNRTsKCWNoaWxkLT5oZWFkZXJfd2R0aHNfb2sgPSBGQUxTRTsKCglpZiAocGF0aCkKCXsKCQlsc3RyY3B5KGNoaWxkLT5wYXRoLCBwYXRoKTsKCgkJX3RzcGxpdHBhdGgocGF0aCwgZHJ2LCBkaXIsIG5hbWUsIGV4dCk7Cgl9CgoJcm9vdC0+ZW50cnkubGV2ZWwgPSAwOwoKCWVudHJ5ID0gcmVhZF90cmVlKHJvb3QsIHBhdGgsIHBpZGwsIGRydiwgY2hpbGQtPnNvcnRPcmRlciwgaHduZCk7CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCWlmIChyb290LT5lbnRyeS5ldHlwZSA9PSBFVF9TSEVMTCkKCQlsb2FkX3N0cmluZyhyb290LT5lbnRyeS5kYXRhLmNGaWxlTmFtZSwgSURTX0RFU0tUT1ApOwoJZWxzZQojZW5kaWYKCQl3c3ByaW50Zihyb290LT5lbnRyeS5kYXRhLmNGaWxlTmFtZSwgUlMoYjEsSURTX1RJVExFRk1UKSwgZHJ2LCByb290LT5mcyk7CgoJcm9vdC0+ZW50cnkuZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzID0gRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZOwoKCWNoaWxkLT5sZWZ0LnJvb3QgPSAmcm9vdC0+ZW50cnk7CgljaGlsZC0+cmlnaHQucm9vdCA9IE5VTEw7CgoJc2V0X2N1cmRpcihjaGlsZCwgZW50cnksIDAsIGh3bmQpOwoKCXJldHVybiBjaGlsZDsKfQoKCi8qIGZyZWUgYWxsIG1lbW9yeSBhc3NvY2lhdGVkIHdpdGggYSBjaGlsZCB3aW5kb3cgKi8Kc3RhdGljIHZvaWQgZnJlZV9jaGlsZF93aW5kb3coQ2hpbGRXbmQqIGNoaWxkKQp7CglmcmVlX2VudHJpZXMoJmNoaWxkLT5yb290LmVudHJ5KTsKCWZyZWUoY2hpbGQpOwp9CgoKLyogZ2V0IGZ1bGwgcGF0aCBvZiBzcGVjaWZpZWQgZGlyZWN0b3J5IGVudHJ5ICovCnN0YXRpYyB2b2lkIGdldF9wYXRoKEVudHJ5KiBkaXIsIFBUU1RSIHBhdGgpCnsKCUVudHJ5KiBlbnRyeTsKCWludCBsZW4gPSAwOwoJaW50IGxldmVsID0gMDsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKGRpci0+ZXR5cGUgPT0gRVRfU0hFTEwpCgl7CgkJU0ZHQU9GIGF0dHJpYnM7CgkJSFJFU1VMVCBociA9IFNfT0s7CgoJCXBhdGhbMF0gPSBURVhUKCdcMCcpOwoKCQlhdHRyaWJzID0gMDsKCgkJaWYgKGRpci0+Zm9sZGVyKQoJCQlociA9ICgqZGlyLT5mb2xkZXItPmxwVnRibC0+R2V0QXR0cmlidXRlc09mKShkaXItPmZvbGRlciwgMSwgKExQQ0lURU1JRExJU1QqKSZkaXItPnBpZGwsICZhdHRyaWJzKTsKCgkJaWYgKFNVQ0NFRURFRChocikgJiYgKGF0dHJpYnMmU0ZHQU9fRklMRVNZU1RFTSkpIHsKCQkJSVNoZWxsRm9sZGVyKiBwYXJlbnQgPSBkaXItPnVwPyBkaXItPnVwLT5mb2xkZXI6IEdsb2JhbHMuaURlc2t0b3A7CgoJCQlociA9IHBhdGhfZnJvbV9waWRsKHBhcmVudCwgZGlyLT5waWRsLCBwYXRoLCBNQVhfUEFUSCk7CgkJfQoJfQoJZWxzZQojZW5kaWYKCXsKCQlmb3IoZW50cnk9ZGlyOyBlbnRyeTsgbGV2ZWwrKykgewoJCQlMUENUU1RSIG5hbWU7CgkJCWludCBsOwoKCQkJewoJCQkJTFBDVFNUUiBzOwoJCQkJbmFtZSA9IGVudHJ5LT5kYXRhLmNGaWxlTmFtZTsKCQkJCXMgPSBuYW1lOwoKCQkJCWZvcihsPTA7ICpzICYmICpzIT1URVhUKCcvJykgJiYgKnMhPVRFWFQoJ1xcJyk7IHMrKykKCQkJCQlsKys7CgkJCX0KCgkJCWlmIChlbnRyeS0+dXApIHsKCQkJCWlmIChsID4gMCkgewoJCQkJCW1lbW1vdmUocGF0aCtsKzEsIHBhdGgsIGxlbipzaXplb2YoVENIQVIpKTsKCQkJCQltZW1jcHkocGF0aCsxLCBuYW1lLCBsKnNpemVvZihUQ0hBUikpOwoJCQkJCWxlbiArPSBsKzE7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQkJaWYgKGVudHJ5LT5ldHlwZSA9PSBFVF9VTklYKQoJCQkJCQlwYXRoWzBdID0gVEVYVCgnLycpOwoJCQkJCWVsc2UKI2VuZGlmCgkJCQkJcGF0aFswXSA9IFRFWFQoJ1xcJyk7CgkJCQl9CgoJCQkJZW50cnkgPSBlbnRyeS0+dXA7CgkJCX0gZWxzZSB7CgkJCQltZW1tb3ZlKHBhdGgrbCwgcGF0aCwgbGVuKnNpemVvZihUQ0hBUikpOwoJCQkJbWVtY3B5KHBhdGgsIG5hbWUsIGwqc2l6ZW9mKFRDSEFSKSk7CgkJCQlsZW4gKz0gbDsKCQkJCWJyZWFrOwoJCQl9CgkJfQoKCQlpZiAoIWxldmVsKSB7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQkJaWYgKGVudHJ5LT5ldHlwZSA9PSBFVF9VTklYKQoJCQkJcGF0aFtsZW4rK10gPSBURVhUKCcvJyk7CgkJCWVsc2UKI2VuZGlmCgkJCQlwYXRoW2xlbisrXSA9IFRFWFQoJ1xcJyk7CgkJfQoKCQlwYXRoW2xlbl0gPSBURVhUKCdcMCcpOwoJfQp9CgoKc3RhdGljIHZvaWQgcmVzaXplX2ZyYW1lX3JlY3QoSFdORCBod25kLCBQUkVDVCBwcmVjdCkKewoJaW50IG5ld190b3A7CglSRUNUIHJ0OwoKCWlmIChJc1dpbmRvd1Zpc2libGUoR2xvYmFscy5odG9vbGJhcikpIHsKCQlTZW5kTWVzc2FnZShHbG9iYWxzLmh0b29sYmFyLCBXTV9TSVpFLCAwLCAwKTsKCQlHZXRDbGllbnRSZWN0KEdsb2JhbHMuaHRvb2xiYXIsICZydCk7CgkJcHJlY3QtPnRvcCA9IHJ0LmJvdHRvbSszOwoJCXByZWN0LT5ib3R0b20gLT0gcnQuYm90dG9tKzM7Cgl9CgoJaWYgKElzV2luZG93VmlzaWJsZShHbG9iYWxzLmhkcml2ZWJhcikpIHsKCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhkcml2ZWJhciwgV01fU0laRSwgMCwgMCk7CgkJR2V0Q2xpZW50UmVjdChHbG9iYWxzLmhkcml2ZWJhciwgJnJ0KTsKCQluZXdfdG9wID0gLS1wcmVjdC0+dG9wICsgcnQuYm90dG9tKzM7CgkJTW92ZVdpbmRvdyhHbG9iYWxzLmhkcml2ZWJhciwgMCwgcHJlY3QtPnRvcCwgcnQucmlnaHQsIG5ld190b3AsIFRSVUUpOwoJCXByZWN0LT50b3AgPSBuZXdfdG9wOwoJCXByZWN0LT5ib3R0b20gLT0gcnQuYm90dG9tKzI7Cgl9CgoJaWYgKElzV2luZG93VmlzaWJsZShHbG9iYWxzLmhzdGF0dXNiYXIpKSB7CgkJaW50IHBhcnRzW10gPSB7MzAwLCA1MDB9OwoKCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhzdGF0dXNiYXIsIFdNX1NJWkUsIDAsIDApOwoJCVNlbmRNZXNzYWdlKEdsb2JhbHMuaHN0YXR1c2JhciwgU0JfU0VUUEFSVFMsIDIsIChMUEFSQU0pJnBhcnRzKTsKCQlHZXRDbGllbnRSZWN0KEdsb2JhbHMuaHN0YXR1c2JhciwgJnJ0KTsKCQlwcmVjdC0+Ym90dG9tIC09IHJ0LmJvdHRvbTsKCX0KCglNb3ZlV2luZG93KEdsb2JhbHMuaG1kaWNsaWVudCwgcHJlY3QtPmxlZnQtMSxwcmVjdC0+dG9wLTEscHJlY3QtPnJpZ2h0KzIscHJlY3QtPmJvdHRvbSsxLCBUUlVFKTsKfQoKc3RhdGljIHZvaWQgcmVzaXplX2ZyYW1lKEhXTkQgaHduZCwgaW50IGN4LCBpbnQgY3kpCnsKCVJFQ1QgcmVjdDsKCglyZWN0LmxlZnQgICA9IDA7CglyZWN0LnRvcCAgICA9IDA7CglyZWN0LnJpZ2h0ICA9IGN4OwoJcmVjdC5ib3R0b20gPSBjeTsKCglyZXNpemVfZnJhbWVfcmVjdChod25kLCAmcmVjdCk7Cn0KCnN0YXRpYyB2b2lkIHJlc2l6ZV9mcmFtZV9jbGllbnQoSFdORCBod25kKQp7CglSRUNUIHJlY3Q7CgoJR2V0Q2xpZW50UmVjdChod25kLCAmcmVjdCk7CgoJcmVzaXplX2ZyYW1lX3JlY3QoaHduZCwgJnJlY3QpOwp9CgoKc3RhdGljIEhIT09LIGhjYnRob29rOwpzdGF0aWMgQ2hpbGRXbmQqIG5ld2NoaWxkID0gTlVMTDsKCkxSRVNVTFQgQ0FMTEJBQ0sgQ0JUUHJvYyhpbnQgY29kZSwgV1BBUkFNIHdwYXJhbSwgTFBBUkFNIGxwYXJhbSkKewoJaWYgKGNvZGU9PUhDQlRfQ1JFQVRFV05EICYmIG5ld2NoaWxkKSB7CgkJQ2hpbGRXbmQqIGNoaWxkID0gbmV3Y2hpbGQ7CgkJbmV3Y2hpbGQgPSBOVUxMOwoKCQljaGlsZC0+aHduZCA9IChIV05EKSB3cGFyYW07CgkJU2V0V2luZG93TG9uZyhjaGlsZC0+aHduZCwgR1dMX1VTRVJEQVRBLCAoTFBBUkFNKWNoaWxkKTsKCX0KCglyZXR1cm4gQ2FsbE5leHRIb29rRXgoaGNidGhvb2ssIGNvZGUsIHdwYXJhbSwgbHBhcmFtKTsKfQoKc3RhdGljIEhXTkQgY3JlYXRlX2NoaWxkX3dpbmRvdyhDaGlsZFduZCogY2hpbGQpCnsKCU1ESUNSRUFURVNUUlVDVCBtY3M7CglpbnQgaWR4OwoKCW1jcy5zekNsYXNzID0gc1dJTkVGSUxFVFJFRTsKCW1jcy5zelRpdGxlID0gKExQVFNUUiljaGlsZC0+cGF0aDsKCW1jcy5oT3duZXIgID0gR2xvYmFscy5oSW5zdGFuY2U7CgltY3MueCAgICAgICA9IGNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi5sZWZ0OwoJbWNzLnkgICAgICAgPSBjaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24udG9wOwoJbWNzLmN4ICAgICAgPSBjaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24ucmlnaHQtY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLmxlZnQ7CgltY3MuY3kgICAgICA9IGNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi5ib3R0b20tY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLnRvcDsKCW1jcy5zdHlsZSAgID0gMDsKCW1jcy5sUGFyYW0gID0gMDsKCgloY2J0aG9vayA9IFNldFdpbmRvd3NIb29rRXgoV0hfQ0JULCBDQlRQcm9jLCAwLCBHZXRDdXJyZW50VGhyZWFkSWQoKSk7CgoJbmV3Y2hpbGQgPSBjaGlsZDsKCWNoaWxkLT5od25kID0gKEhXTkQpIFNlbmRNZXNzYWdlKEdsb2JhbHMuaG1kaWNsaWVudCwgV01fTURJQ1JFQVRFLCAwLCAoTFBBUkFNKSZtY3MpOwoJaWYgKCFjaGlsZC0+aHduZCkgewoJCVVuaG9va1dpbmRvd3NIb29rRXgoaGNidGhvb2spOwoJCXJldHVybiAwOwoJfQoKCVVuaG9va1dpbmRvd3NIb29rRXgoaGNidGhvb2spOwoKCUxpc3RCb3hfU2V0SXRlbUhlaWdodChjaGlsZC0+bGVmdC5od25kLCAxLCBtYXgoR2xvYmFscy5zcGFjZVNpemUuY3ksSU1BR0VfSEVJR0hUKzMpKTsKCUxpc3RCb3hfU2V0SXRlbUhlaWdodChjaGlsZC0+cmlnaHQuaHduZCwgMSwgbWF4KEdsb2JhbHMuc3BhY2VTaXplLmN5LElNQUdFX0hFSUdIVCszKSk7CgoJaWR4ID0gTGlzdEJveF9GaW5kSXRlbURhdGEoY2hpbGQtPmxlZnQuaHduZCwgMCwgY2hpbGQtPmxlZnQuY3VyKTsKCUxpc3RCb3hfU2V0Q3VyU2VsKGNoaWxkLT5sZWZ0Lmh3bmQsIGlkeCk7CgoJcmV0dXJuIGNoaWxkLT5od25kOwp9CgoKc3RydWN0IEV4ZWN1dGVEaWFsb2cgewoJVENIQVIJY21kW01BWF9QQVRIXTsKCWludAkJY21kc2hvdzsKfTsKCgpzdGF0aWMgSU5UX1BUUiBDQUxMQkFDSyBFeGVjdXRlRGlhbG9nV25kUHJvZyhIV05EIGh3bmQsIFVJTlQgbm1zZywgV1BBUkFNIHdwYXJhbSwgTFBBUkFNIGxwYXJhbSkKewoJc3RhdGljIHN0cnVjdCBFeGVjdXRlRGlhbG9nKiBkbGc7CgoJc3dpdGNoKG5tc2cpIHsKCQljYXNlIFdNX0lOSVRESUFMT0c6CgkJCWRsZyA9IChzdHJ1Y3QgRXhlY3V0ZURpYWxvZyopIGxwYXJhbTsKCQkJcmV0dXJuIDE7CgoJCWNhc2UgV01fQ09NTUFORDogewoJCQlpbnQgaWQgPSAoaW50KXdwYXJhbTsKCgkJCWlmIChpZCA9PSBJRE9LKSB7CgkJCQlHZXRXaW5kb3dUZXh0KEdldERsZ0l0ZW0oaHduZCwgMjAxKSwgZGxnLT5jbWQsIE1BWF9QQVRIKTsKCQkJCWRsZy0+Y21kc2hvdyA9IEJ1dHRvbl9HZXRTdGF0ZShHZXREbGdJdGVtKGh3bmQsMjE0KSkmQlNUX0NIRUNLRUQ/CgkJCQkJCQkJCQkJCVNXX1NIT1dNSU5JTUlaRUQ6IFNXX1NIT1dOT1JNQUw7CgkJCQlFbmREaWFsb2coaHduZCwgaWQpOwoJCQl9IGVsc2UgaWYgKGlkID09IElEQ0FOQ0VMKQoJCQkJRW5kRGlhbG9nKGh3bmQsIGlkKTsKCgkJCXJldHVybiAxO30KCX0KCglyZXR1cm4gMDsKfQoKc3RhdGljIElOVF9QVFIgQ0FMTEJBQ0sgRGVzdGluYXRpb25EbGdQcm9jKEhXTkQgaHduZCwgVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKQp7CglUQ0hBUiBiMVtCVUZGRVJfTEVOXSwgYjJbQlVGRkVSX0xFTl07CgoJc3dpdGNoKG5tc2cpIHsKCQljYXNlIFdNX0lOSVRESUFMT0c6CgkJCVNldFdpbmRvd0xvbmcoaHduZCwgR1dMX1VTRVJEQVRBLCBscGFyYW0pOwoJCQlTZXRXaW5kb3dUZXh0KEdldERsZ0l0ZW0oaHduZCwgMjAxKSwgKExQQ1RTVFIpbHBhcmFtKTsKCQkJcmV0dXJuIDE7CgoJCWNhc2UgV01fQ09NTUFORDogewoJCQlpbnQgaWQgPSAoaW50KXdwYXJhbTsKCgkJCXN3aXRjaChpZCkgewoJCQkgIGNhc2UgSURPSzogewoJCQkJTFBUU1RSIGRlc3QgPSAoTFBUU1RSKSBHZXRXaW5kb3dMb25nKGh3bmQsIEdXTF9VU0VSREFUQSk7CgkJCQlHZXRXaW5kb3dUZXh0KEdldERsZ0l0ZW0oaHduZCwgMjAxKSwgZGVzdCwgTUFYX1BBVEgpOwoJCQkJRW5kRGlhbG9nKGh3bmQsIGlkKTsKCQkJCWJyZWFrO30KCgkJCSAgY2FzZSBJRENBTkNFTDoKCQkJCUVuZERpYWxvZyhod25kLCBpZCk7CgkJCQlicmVhazsKCgkJCSAgY2FzZSAyNTQ6CgkJCQlNZXNzYWdlQm94KGh3bmQsIFJTKGIxLElEU19OT19JTVBMKSwgUlMoYjIsSURTX1dJTkVGSUxFKSwgTUJfT0spOwoJCQkJYnJlYWs7CgkJCX0KCgkJCXJldHVybiAxOwoJCX0KCX0KCglyZXR1cm4gMDsKfQoKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCnN0YXRpYyBzdHJ1Y3QgRnVsbFNjcmVlblBhcmFtZXRlcnMgewoJQk9PTAltb2RlOwoJUkVDVAlvcmdQb3M7CglCT09MCXdhc1pvb21lZDsKfSBnX2Z1bGxzY3JlZW4gPSB7CiAgICBGQUxTRSwJLyogbW9kZSAqLwoJezAsIDAsIDAsIDB9LAoJRkFMU0UKfTsKCnZvaWQgZnJhbWVfZ2V0X2NsaWVudHNwYWNlKEhXTkQgaHduZCwgUFJFQ1QgcHJlY3QpCnsKCVJFQ1QgcnQ7CgoJaWYgKCFJc0ljb25pYyhod25kKSkKCQlHZXRDbGllbnRSZWN0KGh3bmQsIHByZWN0KTsKCWVsc2UgewoJCVdJTkRPV1BMQUNFTUVOVCB3cDsKCgkJR2V0V2luZG93UGxhY2VtZW50KGh3bmQsICZ3cCk7CgoJCXByZWN0LT5sZWZ0ID0gcHJlY3QtPnRvcCA9IDA7CgkJcHJlY3QtPnJpZ2h0ID0gd3AucmNOb3JtYWxQb3NpdGlvbi5yaWdodC13cC5yY05vcm1hbFBvc2l0aW9uLmxlZnQtCgkJCQkJCTIqKEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFRlJBTUUpK0dldFN5c3RlbU1ldHJpY3MoU01fQ1hFREdFKSk7CgkJcHJlY3QtPmJvdHRvbSA9IHdwLnJjTm9ybWFsUG9zaXRpb24uYm90dG9tLXdwLnJjTm9ybWFsUG9zaXRpb24udG9wLQoJCQkJCQkyKihHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0laRUZSQU1FKStHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRURHRSkpLQoJCQkJCQlHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQ0FQVElPTiktR2V0U3lzdGVtTWV0cmljcyhTTV9DWU1FTlVTSVpFKTsKCX0KCglpZiAoSXNXaW5kb3dWaXNpYmxlKEdsb2JhbHMuaHRvb2xiYXIpKSB7CgkJR2V0Q2xpZW50UmVjdChHbG9iYWxzLmh0b29sYmFyLCAmcnQpOwoJCXByZWN0LT50b3AgKz0gcnQuYm90dG9tKzI7Cgl9CgoJaWYgKElzV2luZG93VmlzaWJsZShHbG9iYWxzLmhkcml2ZWJhcikpIHsKCQlHZXRDbGllbnRSZWN0KEdsb2JhbHMuaGRyaXZlYmFyLCAmcnQpOwoJCXByZWN0LT50b3AgKz0gcnQuYm90dG9tKzI7Cgl9CgoJaWYgKElzV2luZG93VmlzaWJsZShHbG9iYWxzLmhzdGF0dXNiYXIpKSB7CgkJR2V0Q2xpZW50UmVjdChHbG9iYWxzLmhzdGF0dXNiYXIsICZydCk7CgkJcHJlY3QtPmJvdHRvbSAtPSBydC5ib3R0b207Cgl9Cn0KCnN0YXRpYyBCT09MIHRvZ2dsZV9mdWxsc2NyZWVuKEhXTkQgaHduZCkKewoJUkVDVCBydDsKCglpZiAoKGdfZnVsbHNjcmVlbi5tb2RlPSFnX2Z1bGxzY3JlZW4ubW9kZSkpIHsKCQlHZXRXaW5kb3dSZWN0KGh3bmQsICZnX2Z1bGxzY3JlZW4ub3JnUG9zKTsKCQlnX2Z1bGxzY3JlZW4ud2FzWm9vbWVkID0gSXNab29tZWQoaHduZCk7CgoJCUZyYW1lX0NhbGNGcmFtZUNsaWVudChod25kLCAmcnQpOwoJCUNsaWVudFRvU2NyZWVuKGh3bmQsIChMUFBPSU5UKSZydC5sZWZ0KTsKCQlDbGllbnRUb1NjcmVlbihod25kLCAoTFBQT0lOVCkmcnQucmlnaHQpOwoKCQlydC5sZWZ0ID0gZ19mdWxsc2NyZWVuLm9yZ1Bvcy5sZWZ0LXJ0LmxlZnQ7CgkJcnQudG9wID0gZ19mdWxsc2NyZWVuLm9yZ1Bvcy50b3AtcnQudG9wOwoJCXJ0LnJpZ2h0ID0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNDUkVFTikrZ19mdWxsc2NyZWVuLm9yZ1Bvcy5yaWdodC1ydC5yaWdodDsKCQlydC5ib3R0b20gPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0NSRUVOKStnX2Z1bGxzY3JlZW4ub3JnUG9zLmJvdHRvbS1ydC5ib3R0b207CgoJCU1vdmVXaW5kb3coaHduZCwgcnQubGVmdCwgcnQudG9wLCBydC5yaWdodC1ydC5sZWZ0LCBydC5ib3R0b20tcnQudG9wLCBUUlVFKTsKCX0gZWxzZSB7CgkJTW92ZVdpbmRvdyhod25kLCBnX2Z1bGxzY3JlZW4ub3JnUG9zLmxlZnQsIGdfZnVsbHNjcmVlbi5vcmdQb3MudG9wLAoJCQkJCQkJZ19mdWxsc2NyZWVuLm9yZ1Bvcy5yaWdodC1nX2Z1bGxzY3JlZW4ub3JnUG9zLmxlZnQsCgkJCQkJCQlnX2Z1bGxzY3JlZW4ub3JnUG9zLmJvdHRvbS1nX2Z1bGxzY3JlZW4ub3JnUG9zLnRvcCwgVFJVRSk7CgoJCWlmIChnX2Z1bGxzY3JlZW4ud2FzWm9vbWVkKQoJCQlTaG93V2luZG93KGh3bmQsIFdTX01BWElNSVpFKTsKCX0KCglyZXR1cm4gZ19mdWxsc2NyZWVuLm1vZGU7Cn0KCnN0YXRpYyB2b2lkIGZ1bGxzY3JlZW5fbW92ZShIV05EIGh3bmQpCnsKCVJFQ1QgcnQsIHBvczsKCUdldFdpbmRvd1JlY3QoaHduZCwgJnBvcyk7CgoJRnJhbWVfQ2FsY0ZyYW1lQ2xpZW50KGh3bmQsICZydCk7CglDbGllbnRUb1NjcmVlbihod25kLCAoTFBQT0lOVCkmcnQubGVmdCk7CglDbGllbnRUb1NjcmVlbihod25kLCAoTFBQT0lOVCkmcnQucmlnaHQpOwoKCXJ0LmxlZnQgPSBwb3MubGVmdC1ydC5sZWZ0OwoJcnQudG9wID0gcG9zLnRvcC1ydC50b3A7CglydC5yaWdodCA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTQ1JFRU4pK3Bvcy5yaWdodC1ydC5yaWdodDsKCXJ0LmJvdHRvbSA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTQ1JFRU4pK3Bvcy5ib3R0b20tcnQuYm90dG9tOwoKCU1vdmVXaW5kb3coaHduZCwgcnQubGVmdCwgcnQudG9wLCBydC5yaWdodC1ydC5sZWZ0LCBydC5ib3R0b20tcnQudG9wLCBUUlVFKTsKfQoKI2VuZGlmCgoKc3RhdGljIHZvaWQgdG9nZ2xlX2NoaWxkKEhXTkQgaHduZCwgVUlOVCBjbWQsIEhXTkQgaGNoaWxkKQp7CglCT09MIHZpcyA9IElzV2luZG93VmlzaWJsZShoY2hpbGQpOwoKCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudU9wdGlvbnMsIGNtZCwgdmlzP01GX0JZQ09NTUFORDpNRl9CWUNPTU1BTkR8TUZfQ0hFQ0tFRCk7CgoJU2hvd1dpbmRvdyhoY2hpbGQsIHZpcz9TV19ISURFOlNXX1NIT1cpOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJaWYgKGdfZnVsbHNjcmVlbi5tb2RlKQoJCWZ1bGxzY3JlZW5fbW92ZShod25kKTsKI2VuZGlmCgoJcmVzaXplX2ZyYW1lX2NsaWVudChod25kKTsKfQoKQk9PTCBhY3RpdmF0ZV9kcml2ZV93aW5kb3coTFBDVFNUUiBwYXRoKQp7CglUQ0hBUiBkcnYxW19NQVhfRFJJVkVdLCBkcnYyW19NQVhfRFJJVkVdOwoJSFdORCBjaGlsZF93bmQ7CgoJX3RzcGxpdHBhdGgocGF0aCwgZHJ2MSwgMCwgMCwgMCk7CgoJLyogc2VhcmNoIGZvciBhIGFscmVhZHkgb3BlbiB3aW5kb3cgZm9yIHRoZSBzYW1lIGRyaXZlICovCglmb3IoY2hpbGRfd25kPUdldE5leHRXaW5kb3coR2xvYmFscy5obWRpY2xpZW50LEdXX0NISUxEKTsgY2hpbGRfd25kOyBjaGlsZF93bmQ9R2V0TmV4dFdpbmRvdyhjaGlsZF93bmQsIEdXX0hXTkRORVhUKSkgewoJCUNoaWxkV25kKiBjaGlsZCA9IChDaGlsZFduZCopIEdldFdpbmRvd0xvbmcoY2hpbGRfd25kLCBHV0xfVVNFUkRBVEEpOwoKCQlpZiAoY2hpbGQpIHsKCQkJX3RzcGxpdHBhdGgoY2hpbGQtPnJvb3QucGF0aCwgZHJ2MiwgMCwgMCwgMCk7CgoJCQlpZiAoIWxzdHJjbXBpKGRydjIsIGRydjEpKSB7CgkJCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESUFDVElWQVRFLCAoV1BBUkFNKWNoaWxkX3duZCwgMCk7CgoJCQkJaWYgKElzTWluaW1pemVkKGNoaWxkX3duZCkpCgkJCQkJU2hvd1dpbmRvdyhjaGlsZF93bmQsIFNXX1NIT1dOT1JNQUwpOwoKCQkJCXJldHVybiBUUlVFOwoJCQl9CgkJfQoJfQoKCXJldHVybiBGQUxTRTsKfQoKQk9PTCBhY3RpdmF0ZV9mc193aW5kb3coTFBDVFNUUiBmaWxlc3lzKQp7CglIV05EIGNoaWxkX3duZDsKCgkvKiBzZWFyY2ggZm9yIGEgYWxyZWFkeSBvcGVuIHdpbmRvdyBvZiB0aGUgZ2l2ZW4gZmlsZSBzeXN0ZW0gbmFtZSAqLwoJZm9yKGNoaWxkX3duZD1HZXROZXh0V2luZG93KEdsb2JhbHMuaG1kaWNsaWVudCxHV19DSElMRCk7IGNoaWxkX3duZDsgY2hpbGRfd25kPUdldE5leHRXaW5kb3coY2hpbGRfd25kLCBHV19IV05ETkVYVCkpIHsKCQlDaGlsZFduZCogY2hpbGQgPSAoQ2hpbGRXbmQqKSBHZXRXaW5kb3dMb25nKGNoaWxkX3duZCwgR1dMX1VTRVJEQVRBKTsKCgkJaWYgKGNoaWxkKSB7CgkJCWlmICghbHN0cmNtcGkoY2hpbGQtPnJvb3QuZnMsIGZpbGVzeXMpKSB7CgkJCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESUFDVElWQVRFLCAoV1BBUkFNKWNoaWxkX3duZCwgMCk7CgoJCQkJaWYgKElzTWluaW1pemVkKGNoaWxkX3duZCkpCgkJCQkJU2hvd1dpbmRvdyhjaGlsZF93bmQsIFNXX1NIT1dOT1JNQUwpOwoKCQkJCXJldHVybiBUUlVFOwoJCQl9CgkJfQoJfQoKCXJldHVybiBGQUxTRTsKfQoKTFJFU1VMVCBDQUxMQkFDSyBGcmFtZVduZFByb2MoSFdORCBod25kLCBVSU5UIG5tc2csIFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pCnsKCVRDSEFSIGIxW0JVRkZFUl9MRU5dLCBiMltCVUZGRVJfTEVOXTsKCglzd2l0Y2gobm1zZykgewoJCWNhc2UgV01fQ0xPU0U6CgkJCURlc3Ryb3lXaW5kb3coaHduZCk7CgoJCQkgLyogY2xlYXIgaGFuZGxlIHZhcmlhYmxlcyAqLwoJCQlHbG9iYWxzLmhNZW51RnJhbWUgPSAwOwoJCQlHbG9iYWxzLmhNZW51VmlldyA9IDA7CgkJCUdsb2JhbHMuaE1lbnVPcHRpb25zID0gMDsKCQkJR2xvYmFscy5oTWFpblduZCA9IDA7CgkJCUdsb2JhbHMuaG1kaWNsaWVudCA9IDA7CgkJCUdsb2JhbHMuaGRyaXZlYmFyID0gMDsKCQkJYnJlYWs7CgoJCWNhc2UgV01fREVTVFJPWToKCQkJIC8qIGRvbid0IGV4aXQgZGVza3RvcCB3aGVuIGNsb3NpbmcgZmlsZSBtYW5hZ2VyIHdpbmRvdyAqLwoJCQlpZiAoIUdsb2JhbHMuaHduZFBhcmVudCkKCQkJCVBvc3RRdWl0TWVzc2FnZSgwKTsKCQkJYnJlYWs7CgoJCWNhc2UgV01fSU5JVE1FTlVQT1BVUDogewoJCQlIV05EIGh3bmRDbGllbnQgPSAoSFdORCkgU2VuZE1lc3NhZ2UoR2xvYmFscy5obWRpY2xpZW50LCBXTV9NRElHRVRBQ1RJVkUsIDAsIDApOwoKCQkJaWYgKCFTZW5kTWVzc2FnZShod25kQ2xpZW50LCBXTV9JTklUTUVOVVBPUFVQLCB3cGFyYW0sIGxwYXJhbSkpCgkJCQlyZXR1cm4gMDsKCQkJYnJlYWs7fQoKCQljYXNlIFdNX0NPTU1BTkQ6IHsKCQkJVUlOVCBjbWQgPSBMT1dPUkQod3BhcmFtKTsKCQkJSFdORCBod25kQ2xpZW50ID0gKEhXTkQpIFNlbmRNZXNzYWdlKEdsb2JhbHMuaG1kaWNsaWVudCwgV01fTURJR0VUQUNUSVZFLCAwLCAwKTsKCgkJCWlmIChTZW5kTWVzc2FnZShod25kQ2xpZW50LCBXTV9ESVNQQVRDSF9DT01NQU5ELCB3cGFyYW0sIGxwYXJhbSkpCgkJCQlicmVhazsKCgkJCWlmIChjbWQ+PUlEX0RSSVZFX0ZJUlNUICYmIGNtZDw9SURfRFJJVkVfRklSU1QrMHhGRikgewoJCQkJVENIQVIgZHJ2W19NQVhfRFJJVkVdLCBwYXRoW01BWF9QQVRIXTsKCQkJCUNoaWxkV25kKiBjaGlsZDsKCQkJCUxQQ1RTVFIgcm9vdCA9IEdsb2JhbHMuZHJpdmVzOwoJCQkJaW50IGk7CgoJCQkJZm9yKGk9Y21kLUlEX0RSSVZFX0ZJUlNUOyBpLS07IHJvb3QrKykKCQkJCQl3aGlsZSgqcm9vdCkKCQkJCQkJcm9vdCsrOwoKCQkJCWlmIChhY3RpdmF0ZV9kcml2ZV93aW5kb3cocm9vdCkpCgkJCQkJcmV0dXJuIDA7CgoJCQkJX3RzcGxpdHBhdGgocm9vdCwgZHJ2LCAwLCAwLCAwKTsKCgkJCQlpZiAoIVNldEN1cnJlbnREaXJlY3RvcnkoZHJ2KSkgewoJCQkJCWRpc3BsYXlfZXJyb3IoaHduZCwgR2V0TGFzdEVycm9yKCkpOwoJCQkJCXJldHVybiAwOwoJCQkJfQoKCQkJCUdldEN1cnJlbnREaXJlY3RvcnkoTUFYX1BBVEgsIHBhdGgpOyAvKlRPRE86IHN0b3JlIGxhc3QgZGlyZWN0b3J5IHBlciBkcml2ZSAqLwoJCQkJY2hpbGQgPSBhbGxvY19jaGlsZF93aW5kb3cocGF0aCwgTlVMTCwgaHduZCk7CgoJCQkJaWYgKCFjcmVhdGVfY2hpbGRfd2luZG93KGNoaWxkKSkKCQkJCQlmcmVlKGNoaWxkKTsKCQkJfSBlbHNlIHN3aXRjaChjbWQpIHsKCQkJCWNhc2UgSURfRklMRV9FWElUOgoJCQkJCVNlbmRNZXNzYWdlKGh3bmQsIFdNX0NMT1NFLCAwLCAwKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX1dJTkRPV19ORVc6IHsKCQkJCQlUQ0hBUiBwYXRoW01BWF9QQVRIXTsKCQkJCQlDaGlsZFduZCogY2hpbGQ7CgoJCQkJCUdldEN1cnJlbnREaXJlY3RvcnkoTUFYX1BBVEgsIHBhdGgpOwoJCQkJCWNoaWxkID0gYWxsb2NfY2hpbGRfd2luZG93KHBhdGgsIE5VTEwsIGh3bmQpOwoKCQkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3coY2hpbGQpKQoJCQkJCQlmcmVlKGNoaWxkKTsKCQkJCQlicmVhazt9CgoJCQkJY2FzZSBJRF9SRUZSRVNIOgoJCQkJCXJlZnJlc2hfZHJpdmVzKCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9XSU5ET1dfQ0FTQ0FERToKCQkJCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESUNBU0NBREUsIDAsIDApOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfV0lORE9XX1RJTEVfSE9SWjoKCQkJCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESVRJTEUsIE1ESVRJTEVfSE9SSVpPTlRBTCwgMCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9XSU5ET1dfVElMRV9WRVJUOgoJCQkJCVNlbmRNZXNzYWdlKEdsb2JhbHMuaG1kaWNsaWVudCwgV01fTURJVElMRSwgTURJVElMRV9WRVJUSUNBTCwgMCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9XSU5ET1dfQVJSQU5HRToKCQkJCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESUlDT05BUlJBTkdFLCAwLCAwKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX1NFTEVDVF9GT05UOiB7CgkJCQkJVENIQVIgZGxnX25hbWVbQlVGRkVSX0xFTl0sIGRsZ19pbmZvW0JVRkZFUl9MRU5dOwoJCQkJCUNIT09TRUZPTlQgY2hGb250OwoJCQkJCUxPR0ZPTlQgbEZvbnQ7CgoJCQkJCUhEQyBoZGMgPSBHZXREQyhod25kKTsKCQkJCQljaEZvbnQubFN0cnVjdFNpemUgPSBzaXplb2YoQ0hPT1NFRk9OVCk7CgkJCQkJY2hGb250Lmh3bmRPd25lciA9IGh3bmQ7CgkJCQkJY2hGb250LmhEQyA9IE5VTEw7CgkJCQkJY2hGb250LmxwTG9nRm9udCA9ICZsRm9udDsKCQkJCQljaEZvbnQuRmxhZ3MgPSBDRl9TQ1JFRU5GT05UUyB8IENGX0ZPUkNFRk9OVEVYSVNUIHwgQ0ZfTElNSVRTSVpFIHwgQ0ZfTk9TQ1JJUFRTRUw7CgkJCQkJY2hGb250LnJnYkNvbG9ycyA9IFJHQigwLDAsMCk7CgkJCQkJY2hGb250LmxDdXN0RGF0YSA9IDA7CgkJCQkJY2hGb250LmxwZm5Ib29rID0gTlVMTDsKCQkJCQljaEZvbnQubHBUZW1wbGF0ZU5hbWUgPSBOVUxMOwoJCQkJCWNoRm9udC5oSW5zdGFuY2UgPSBHbG9iYWxzLmhJbnN0YW5jZTsKCQkJCQljaEZvbnQubHBzelN0eWxlID0gTlVMTDsKCQkJCQljaEZvbnQubkZvbnRUeXBlID0gU0lNVUxBVEVEX0ZPTlRUWVBFOwoJCQkJCWNoRm9udC5uU2l6ZU1pbiA9IDA7CgkJCQkJY2hGb250Lm5TaXplTWF4ID0gMjQ7CgoJCQkJCWlmIChDaG9vc2VGb250KCZjaEZvbnQpKSB7CgkJCQkJCUhXTkQgY2hpbGRXbmQ7CgoJCQkJCQlHbG9iYWxzLmhmb250ID0gQ3JlYXRlRm9udEluZGlyZWN0KCZsRm9udCk7CgkJCQkJCVNlbGVjdEZvbnQoaGRjLCBHbG9iYWxzLmhmb250KTsKCQkJCQkJR2V0VGV4dEV4dGVudFBvaW50MzIoaGRjLCBzU3BhY2UsIDEsICZHbG9iYWxzLnNwYWNlU2l6ZSk7CgoJCQkJCQkvKiBjaGFuZ2UgZm9udCBpbiBhbGwgb3BlbiBjaGlsZCB3aW5kb3dzICovCgkJCQkJCWZvcihjaGlsZFduZD1HZXRXaW5kb3coR2xvYmFscy5obWRpY2xpZW50LEdXX0NISUxEKTsgY2hpbGRXbmQ7IGNoaWxkV25kPUdldE5leHRXaW5kb3coY2hpbGRXbmQsR1dfSFdORE5FWFQpKSB7CgkJCQkJCQlDaGlsZFduZCogY2hpbGQgPSAoQ2hpbGRXbmQqKSBHZXRXaW5kb3dMb25nKGNoaWxkV25kLCBHV0xfVVNFUkRBVEEpOwoJCQkJCQkJU2V0V2luZG93Rm9udChjaGlsZC0+bGVmdC5od25kLCBHbG9iYWxzLmhmb250LCBUUlVFKTsKCQkJCQkJCVNldFdpbmRvd0ZvbnQoY2hpbGQtPnJpZ2h0Lmh3bmQsIEdsb2JhbHMuaGZvbnQsIFRSVUUpOwoJCQkJCQkJTGlzdEJveF9TZXRJdGVtSGVpZ2h0KGNoaWxkLT5sZWZ0Lmh3bmQsIDEsIG1heChHbG9iYWxzLnNwYWNlU2l6ZS5jeSxJTUFHRV9IRUlHSFQrMykpOwoJCQkJCQkJTGlzdEJveF9TZXRJdGVtSGVpZ2h0KGNoaWxkLT5yaWdodC5od25kLCAxLCBtYXgoR2xvYmFscy5zcGFjZVNpemUuY3ksSU1BR0VfSEVJR0hUKzMpKTsKCQkJCQkJCUludmFsaWRhdGVSZWN0KGNoaWxkLT5sZWZ0Lmh3bmQsIE5VTEwsIFRSVUUpOwoJCQkJCQkJSW52YWxpZGF0ZVJlY3QoY2hpbGQtPnJpZ2h0Lmh3bmQsIE5VTEwsIFRSVUUpOwoJCQkJCQl9CgkJCQkJfQoJCQkJCWVsc2UgaWYgKENvbW1EbGdFeHRlbmRlZEVycm9yKCkpIHsKCQkJCQkJTG9hZFN0cmluZyhHbG9iYWxzLmhJbnN0YW5jZSwgSURTX0ZPTlRfU0VMX0RMR19OQU1FLCBkbGdfbmFtZSwgQlVGRkVSX0xFTik7CgkJCQkJCUxvYWRTdHJpbmcoR2xvYmFscy5oSW5zdGFuY2UsIElEU19GT05UX1NFTF9FUlJPUiwgZGxnX2luZm8sIEJVRkZFUl9MRU4pOwoJCQkJCQlNZXNzYWdlQm94KGh3bmQsIGRsZ19pbmZvLCBkbGdfbmFtZSwgTUJfT0spOwoJCQkJCX0KCgkJCQkJUmVsZWFzZURDKGh3bmQsIGhkYyk7CgkJCQkJYnJlYWs7CgkJCQl9CgoJCQkJY2FzZSBJRF9WSUVXX1RPT0xfQkFSOgoJCQkJCXRvZ2dsZV9jaGlsZChod25kLCBjbWQsIEdsb2JhbHMuaHRvb2xiYXIpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfVklFV19EUklWRV9CQVI6CgkJCQkJdG9nZ2xlX2NoaWxkKGh3bmQsIGNtZCwgR2xvYmFscy5oZHJpdmViYXIpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfVklFV19TVEFUVVNCQVI6CgkJCQkJdG9nZ2xlX2NoaWxkKGh3bmQsIGNtZCwgR2xvYmFscy5oc3RhdHVzYmFyKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX0VYRUNVVEU6IHsKCQkJCQlzdHJ1Y3QgRXhlY3V0ZURpYWxvZyBkbGc7CgoJCQkJCW1lbXNldCgmZGxnLCAwLCBzaXplb2Yoc3RydWN0IEV4ZWN1dGVEaWFsb2cpKTsKCgkJCQkJaWYgKERpYWxvZ0JveFBhcmFtKEdsb2JhbHMuaEluc3RhbmNlLCBNQUtFSU5UUkVTT1VSQ0UoSUREX0VYRUNVVEUpLCBod25kLCBFeGVjdXRlRGlhbG9nV25kUHJvZywgKExQQVJBTSkmZGxnKSA9PSBJRE9LKSB7CgkJCQkJCUhJTlNUQU5DRSBoaW5zdCA9IFNoZWxsRXhlY3V0ZShod25kLCBOVUxMLypvcGVyYXRpb24qLywgZGxnLmNtZC8qZmlsZSovLCBOVUxMLypwYXJhbWV0ZXJzKi8sIE5VTEwvKmRpciovLCBkbGcuY21kc2hvdyk7CgoJCQkJCQlpZiAoKGludCloaW5zdCA8PSAzMikKCQkJCQkJCWRpc3BsYXlfZXJyb3IoaHduZCwgR2V0TGFzdEVycm9yKCkpOwoJCQkJCX0KCQkJCQlicmVhazt9CgoJCQkJY2FzZSBJRF9DT05ORUNUX05FVFdPUktfRFJJVkU6IHsKCQkJCQlEV09SRCByZXQgPSBXTmV0Q29ubmVjdGlvbkRpYWxvZyhod25kLCBSRVNPVVJDRVRZUEVfRElTSyk7CgkJCQkJaWYgKHJldCA9PSBOT19FUlJPUikKCQkJCQkJcmVmcmVzaF9kcml2ZXMoKTsKCQkJCQllbHNlIGlmIChyZXQgIT0gKERXT1JEKS0xKSB7CgkJCQkJCWlmIChyZXQgPT0gRVJST1JfRVhURU5ERURfRVJST1IpCgkJCQkJCQlkaXNwbGF5X25ldHdvcmtfZXJyb3IoaHduZCk7CgkJCQkJCWVsc2UKCQkJCQkJCWRpc3BsYXlfZXJyb3IoaHduZCwgcmV0KTsKCQkJCQl9CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgSURfRElTQ09OTkVDVF9ORVRXT1JLX0RSSVZFOiB7CgkJCQkJRFdPUkQgcmV0ID0gV05ldERpc2Nvbm5lY3REaWFsb2coaHduZCwgUkVTT1VSQ0VUWVBFX0RJU0spOwoJCQkJCWlmIChyZXQgPT0gTk9fRVJST1IpCgkJCQkJCXJlZnJlc2hfZHJpdmVzKCk7CgkJCQkJZWxzZSBpZiAocmV0ICE9IChEV09SRCktMSkgewoJCQkJCQlpZiAocmV0ID09IEVSUk9SX0VYVEVOREVEX0VSUk9SKQoJCQkJCQkJZGlzcGxheV9uZXR3b3JrX2Vycm9yKGh3bmQpOwoJCQkJCQllbHNlCgkJCQkJCQlkaXNwbGF5X2Vycm9yKGh3bmQsIHJldCk7CgkJCQkJfQoJCQkJCWJyZWFrO30KCgkJCQljYXNlIElEX0ZPUk1BVF9ESVNLOiB7CgkJCQkJVUlOVCBzZW1fb3JnID0gU2V0RXJyb3JNb2RlKDApOyAvKiBHZXQgdGhlIGN1cnJlbnQgRXJyb3IgTW9kZSBzZXR0aW5ncy4gKi8KCQkJCQlTZXRFcnJvck1vZGUoc2VtX29yZyAmIH5TRU1fRkFJTENSSVRJQ0FMRVJST1JTKTsgLyogRm9yY2UgTy9TIHRvIGhhbmRsZSAqLwoJCQkJCVNIRm9ybWF0RHJpdmUoaHduZCwgMCAvKiBBOiAqLywgU0hGTVRfSURfREVGQVVMVCwgMCk7CgkJCQkJU2V0RXJyb3JNb2RlKHNlbV9vcmcpOyAvKiBQdXQgaXQgYmFjayB0aGUgd2F5IGl0IHdhcy4gKi8KCQkJCQlicmVhazt9CgoJCQkJY2FzZSBJRF9IRUxQOgoJCQkJCVdpbkhlbHAoaHduZCwgUlMoYjEsSURTX1dJTkVGSUxFKSwgSEVMUF9JTkRFWCwgMCk7CgkJCQkJYnJlYWs7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQljYXNlIElEX1ZJRVdfRlVMTFNDUkVFTjoKCQkJCQlDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVPcHRpb25zLCBjbWQsIHRvZ2dsZV9mdWxsc2NyZWVuKGh3bmQpP01GX0NIRUNLRUQ6MCk7CgkJCQkJYnJlYWs7CgojaWZkZWYgX19XSU5FX18KCQkJCWNhc2UgSURfRFJJVkVfVU5JWF9GUzogewoJCQkJCVRDSEFSIHBhdGhbTUFYX1BBVEhdOwoJCQkJCUNoaWxkV25kKiBjaGlsZDsKCgkJCQkJaWYgKGFjdGl2YXRlX2ZzX3dpbmRvdyhSUyhiMSxJRFNfVU5JWEZTKSkpCgkJCQkJCWJyZWFrOwoKCQkJCQlnZXRjd2QocGF0aCwgTUFYX1BBVEgpOwoJCQkJCWNoaWxkID0gYWxsb2NfY2hpbGRfd2luZG93KHBhdGgsIE5VTEwsIGh3bmQpOwoKCQkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3coY2hpbGQpKQoJCQkJCQlmcmVlKGNoaWxkKTsKCQkJCQlicmVhazt9CiNlbmRpZgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCQkJCWNhc2UgSURfRFJJVkVfU0hFTExfTlM6IHsKCQkJCQlUQ0hBUiBwYXRoW01BWF9QQVRIXTsKCQkJCQlDaGlsZFduZCogY2hpbGQ7CgoJCQkJCWlmIChhY3RpdmF0ZV9mc193aW5kb3coUlMoYjEsSURTX1NIRUxMKSkpCgkJCQkJCWJyZWFrOwoKCQkJCQlHZXRDdXJyZW50RGlyZWN0b3J5KE1BWF9QQVRILCBwYXRoKTsKCQkJCQljaGlsZCA9IGFsbG9jX2NoaWxkX3dpbmRvdyhwYXRoLCBnZXRfcGF0aF9waWRsKHBhdGgsaHduZCksIGh3bmQpOwoKCQkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3coY2hpbGQpKQoJCQkJCQlmcmVlKGNoaWxkKTsKCQkJCQlicmVhazt9CiNlbmRpZgojZW5kaWYKCgkJCQkvKlRPRE86IFRoZXJlIGFyZSBldmVuIG1vcmUgbWVudSBpdGVtcyEgKi8KCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKI2lmZGVmIF9fV0lORV9fCgkJCQljYXNlIElEX0xJQ0VOU0U6CgkJCQkJV2luZUxpY2Vuc2UoR2xvYmFscy5oTWFpblduZCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9OT19XQVJSQU5UWToKCQkJCQlXaW5lV2FycmFudHkoR2xvYmFscy5oTWFpblduZCk7CgkJCQkJYnJlYWs7CiNlbmRpZgoKCQkJCWNhc2UgSURfQUJPVVRfV0lORToKCQkJCQlTaGVsbEFib3V0KGh3bmQsIFJTKGIyLElEU19XSU5FKSwgUlMoYjEsSURTX1dJTkVGSUxFKSwgMCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9BQk9VVDoJLypJRF9BQk9VVF9XSU5FOiAqLwoJCQkJCVNoZWxsQWJvdXQoaHduZCwgUlMoYjEsSURTX1dJTkVGSUxFKSwgTlVMTCwgMCk7CgkJCQkJYnJlYWs7CiNlbmRpZgkvKiBfTk9fRVhURU5TSU9OUyAqLwoKCQkJCWRlZmF1bHQ6CgkJCQkJLypUT0RPOiBpZiAod1BhcmFtID49IFBNX0ZJUlNUX0xBTkdVQUdFICYmIHdQYXJhbSA8PSBQTV9MQVNUX0xBTkdVQUdFKQoJCQkJCQlTVFJJTkdfU2VsZWN0TGFuZ3VhZ2VCeU51bWJlcih3UGFyYW0gLSBQTV9GSVJTVF9MQU5HVUFHRSk7CgkJCQkJZWxzZSAqL2lmICgoY21kPElEV19GSVJTVF9DSElMRCB8fCBjbWQ+PUlEV19GSVJTVF9DSElMRCsweDEwMCkgJiYKCQkJCQkJKGNtZDxTQ19TSVpFIHx8IGNtZD5TQ19SRVNUT1JFKSkKCQkJCQkJTWVzc2FnZUJveChod25kLCBSUyhiMixJRFNfTk9fSU1QTCksIFJTKGIxLElEU19XSU5FRklMRSksIE1CX09LKTsKCgkJCQkJcmV0dXJuIERlZkZyYW1lUHJvYyhod25kLCBHbG9iYWxzLmhtZGljbGllbnQsIG5tc2csIHdwYXJhbSwgbHBhcmFtKTsKCQkJfQoJCQlicmVhazt9CgoJCWNhc2UgV01fU0laRToKCQkJcmVzaXplX2ZyYW1lKGh3bmQsIExPV09SRChscGFyYW0pLCBISVdPUkQobHBhcmFtKSk7CgkJCWJyZWFrOwkvKiBkbyBub3QgcGFzcyBtZXNzYWdlIHRvIERlZkZyYW1lUHJvYyAqLwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgV01fR0VUTUlOTUFYSU5GTzogewoJCQlMUE1JTk1BWElORk8gbHBtbWkgPSAoTFBNSU5NQVhJTkZPKWxwYXJhbTsKCgkJCWxwbW1pLT5wdE1heFRyYWNrU2l6ZS54IDw8PSAxOy8qMipHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOKSAvIFNNX0NYVklSVFVBTFNDUkVFTiAqLwoJCQlscG1taS0+cHRNYXhUcmFja1NpemUueSA8PD0gMTsvKjIqR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNDUkVFTikgLyBTTV9DWVZJUlRVQUxTQ1JFRU4gKi8KCQkJYnJlYWs7fQoKCQljYXNlIEZSTV9DQUxDX0NMSUVOVDoKCQkJZnJhbWVfZ2V0X2NsaWVudHNwYWNlKGh3bmQsIChQUkVDVClscGFyYW0pOwoJCQlyZXR1cm4gVFJVRTsKI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgoJCWRlZmF1bHQ6CgkJCXJldHVybiBEZWZGcmFtZVByb2MoaHduZCwgR2xvYmFscy5obWRpY2xpZW50LCBubXNnLCB3cGFyYW0sIGxwYXJhbSk7Cgl9CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgVENIQVIgZ19wb3NfbmFtZXNbQ09MVU1OU11bMjBdID0gewoJeydcMCd9CS8qIHN5bWJvbCAqLwp9OwoKc3RhdGljIGNvbnN0IGludCBnX3Bvc19hbGlnbltdID0gewoJMCwKCUhERl9MRUZULAkvKiBOYW1lICovCglIREZfUklHSFQsCS8qIFNpemUgKi8KCUhERl9MRUZULAkvKiBDRGF0ZSAqLwojaWZuZGVmIF9OT19FWFRFTlNJT05TCglIREZfTEVGVCwJLyogQURhdGUgKi8KCUhERl9MRUZULAkvKiBNRGF0ZSAqLwoJSERGX0xFRlQsCS8qIEluZGV4ICovCglIREZfQ0VOVEVSLAkvKiBMaW5rcyAqLwojZW5kaWYKCUhERl9DRU5URVIsCS8qIEF0dHJpYnV0ZXMgKi8KI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJSERGX0xFRlQJLyogU2VjdXJpdHkgKi8KI2VuZGlmCn07CgpzdGF0aWMgdm9pZCByZXNpemVfdHJlZShDaGlsZFduZCogY2hpbGQsIGludCBjeCwgaW50IGN5KQp7CglIRFdQIGhkd3AgPSBCZWdpbkRlZmVyV2luZG93UG9zKDQpOwoJUkVDVCBydDsKCglydC5sZWZ0ICAgPSAwOwoJcnQudG9wICAgID0gMDsKCXJ0LnJpZ2h0ICA9IGN4OwoJcnQuYm90dG9tID0gY3k7CgoJY3ggPSBjaGlsZC0+c3BsaXRfcG9zICsgU1BMSVRfV0lEVEgvMjsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCXsKCQlXSU5ET1dQT1Mgd3A7CgkJSERfTEFZT1VUIGhkbDsKCgkJaGRsLnByYyAgID0gJnJ0OwoJCWhkbC5wd3BvcyA9ICZ3cDsKCgkJSGVhZGVyX0xheW91dChjaGlsZC0+bGVmdC5od25kSGVhZGVyLCAmaGRsKTsKCgkJRGVmZXJXaW5kb3dQb3MoaGR3cCwgY2hpbGQtPmxlZnQuaHduZEhlYWRlciwgd3AuaHduZEluc2VydEFmdGVyLAoJCQkJCQl3cC54LTEsIHdwLnksIGNoaWxkLT5zcGxpdF9wb3MtU1BMSVRfV0lEVEgvMisxLCB3cC5jeSwgd3AuZmxhZ3MpOwoJCURlZmVyV2luZG93UG9zKGhkd3AsIGNoaWxkLT5yaWdodC5od25kSGVhZGVyLCB3cC5od25kSW5zZXJ0QWZ0ZXIsCgkJCQkJCXJ0LmxlZnQrY3grMSwgd3AueSwgd3AuY3gtY3grMiwgd3AuY3ksIHdwLmZsYWdzKTsKCX0KI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgoJRGVmZXJXaW5kb3dQb3MoaGR3cCwgY2hpbGQtPmxlZnQuaHduZCwgMCwgcnQubGVmdCwgcnQudG9wLCBjaGlsZC0+c3BsaXRfcG9zLVNQTElUX1dJRFRILzItcnQubGVmdCwgcnQuYm90dG9tLXJ0LnRvcCwgU1dQX05PWk9SREVSfFNXUF9OT0FDVElWQVRFKTsKCURlZmVyV2luZG93UG9zKGhkd3AsIGNoaWxkLT5yaWdodC5od25kLCAwLCBydC5sZWZ0K2N4KzEsIHJ0LnRvcCwgcnQucmlnaHQtY3gsIHJ0LmJvdHRvbS1ydC50b3AsIFNXUF9OT1pPUkRFUnxTV1BfTk9BQ1RJVkFURSk7CgoJRW5kRGVmZXJXaW5kb3dQb3MoaGR3cCk7Cn0KCgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgpzdGF0aWMgSFdORCBjcmVhdGVfaGVhZGVyKEhXTkQgcGFyZW50LCBQYW5lKiBwYW5lLCBpbnQgaWQpCnsKCUhEX0lURU0gaGRpOwoJaW50IGlkeDsKCglIV05EIGh3bmQgPSBDcmVhdGVXaW5kb3coV0NfSEVBREVSLCAwLCBXU19DSElMRHxXU19WSVNJQkxFfEhEU19IT1JaLypUT0RPOiB8SERTX0JVVFRPTlMgKyBzb3J0IG9yZGVycyovLAoJCQkJCQkJCTAsIDAsIDAsIDAsIHBhcmVudCwgKEhNRU5VKWlkLCBHbG9iYWxzLmhJbnN0YW5jZSwgMCk7CglpZiAoIWh3bmQpCgkJcmV0dXJuIDA7CgoJU2V0V2luZG93Rm9udChod25kLCBHZXRTdG9ja09iamVjdChERUZBVUxUX0dVSV9GT05UKSwgRkFMU0UpOwoKCWhkaS5tYXNrID0gSERJX1RFWFR8SERJX1dJRFRIfEhESV9GT1JNQVQ7CgoJZm9yKGlkeD0wOyBpZHg8Q09MVU1OUzsgaWR4KyspIHsKCQloZGkucHN6VGV4dCA9IGdfcG9zX25hbWVzW2lkeF07CgkJaGRpLmZtdCA9IEhERl9TVFJJTkcgfCBnX3Bvc19hbGlnbltpZHhdOwoJCWhkaS5jeHkgPSBwYW5lLT53aWR0aHNbaWR4XTsKCQlIZWFkZXJfSW5zZXJ0SXRlbShod25kLCBpZHgsICZoZGkpOwoJfQoKCXJldHVybiBod25kOwp9CgojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCgpzdGF0aWMgdm9pZCBpbml0X291dHB1dChIV05EIGh3bmQpCnsKCWNvbnN0IHN0YXRpYyBUQ0hBUiBzMTAwMFtdID0geycxJywnMCcsJzAnLCcwJywnXDAnfTsKCglUQ0hBUiBiWzE2XTsKCUhGT05UIG9sZF9mb250OwoJSERDIGhkYyA9IEdldERDKGh3bmQpOwoKCWlmIChHZXROdW1iZXJGb3JtYXQoTE9DQUxFX1VTRVJfREVGQVVMVCwgMCwgczEwMDAsIDAsIGIsIDE2KSA+IDQpCgkJR2xvYmFscy5udW1fc2VwID0gYlsxXTsKCWVsc2UKCQlHbG9iYWxzLm51bV9zZXAgPSBURVhUKCcuJyk7CgoJb2xkX2ZvbnQgPSBTZWxlY3RGb250KGhkYywgR2xvYmFscy5oZm9udCk7CglHZXRUZXh0RXh0ZW50UG9pbnQzMihoZGMsIHNTcGFjZSwgMSwgJkdsb2JhbHMuc3BhY2VTaXplKTsKCVNlbGVjdEZvbnQoaGRjLCBvbGRfZm9udCk7CglSZWxlYXNlREMoaHduZCwgaGRjKTsKfQoKc3RhdGljIHZvaWQgZHJhd19pdGVtKFBhbmUqIHBhbmUsIExQRFJBV0lURU1TVFJVQ1QgZGlzLCBFbnRyeSogZW50cnksIGludCBjYWxjV2lkdGhDb2wpOwoKCi8qIGNhbGN1bGF0ZSBwcmVmZXJyZWQgd2lkdGggZm9yIGFsbCB2aXNpYmxlIGNvbHVtbnMgKi8KCnN0YXRpYyBCT09MIGNhbGNfd2lkdGhzKFBhbmUqIHBhbmUsIEJPT0wgYW55d2F5KQp7CglpbnQgY29sLCB4LCBjeCwgc3BjPTMqR2xvYmFscy5zcGFjZVNpemUuY3g7CglpbnQgZW50cmllcyA9IExpc3RCb3hfR2V0Q291bnQocGFuZS0+aHduZCk7CglpbnQgb3JnV2lkdGhzW0NPTFVNTlNdOwoJaW50IG9yZ1Bvc2l0aW9uc1tDT0xVTU5TKzFdOwoJSEZPTlQgaGZvbnRPbGQ7CglIREMgaGRjOwoJaW50IGNudDsKCglpZiAoIWFueXdheSkgewoJCW1lbWNweShvcmdXaWR0aHMsIHBhbmUtPndpZHRocywgc2l6ZW9mKG9yZ1dpZHRocykpOwoJCW1lbWNweShvcmdQb3NpdGlvbnMsIHBhbmUtPnBvc2l0aW9ucywgc2l6ZW9mKG9yZ1Bvc2l0aW9ucykpOwoJfQoKCWZvcihjb2w9MDsgY29sPENPTFVNTlM7IGNvbCsrKQoJCXBhbmUtPndpZHRoc1tjb2xdID0gMDsKCgloZGMgPSBHZXREQyhwYW5lLT5od25kKTsKCWhmb250T2xkID0gU2VsZWN0Rm9udChoZGMsIEdsb2JhbHMuaGZvbnQpOwoKCWZvcihjbnQ9MDsgY250PGVudHJpZXM7IGNudCsrKSB7CgkJRW50cnkqIGVudHJ5ID0gKEVudHJ5KikgTGlzdEJveF9HZXRJdGVtRGF0YShwYW5lLT5od25kLCBjbnQpOwoKCQlEUkFXSVRFTVNUUlVDVCBkaXM7CgoJCWRpcy5DdGxUeXBlCQkgID0gMDsKCQlkaXMuQ3RsSUQJCSAgPSAwOwoJCWRpcy5pdGVtSUQJCSAgPSAwOwoJCWRpcy5pdGVtQWN0aW9uCSAgPSAwOwoJCWRpcy5pdGVtU3RhdGUJICA9IDA7CgkJZGlzLmh3bmRJdGVtCSAgPSBwYW5lLT5od25kOwoJCWRpcy5oREMJCQkgID0gaGRjOwoJCWRpcy5yY0l0ZW0ubGVmdAkgID0gMDsKCQlkaXMucmNJdGVtLnRvcCAgICA9IDA7CgkJZGlzLnJjSXRlbS5yaWdodCAgPSAwOwoJCWRpcy5yY0l0ZW0uYm90dG9tID0gMDsKCQkvKmRpcy5pdGVtRGF0YQkgID0gMDsgKi8KCgkJZHJhd19pdGVtKHBhbmUsICZkaXMsIGVudHJ5LCBDT0xVTU5TKTsKCX0KCglTZWxlY3RPYmplY3QoaGRjLCBoZm9udE9sZCk7CglSZWxlYXNlREMocGFuZS0+aHduZCwgaGRjKTsKCgl4ID0gMDsKCWZvcihjb2w9MDsgY29sPENPTFVNTlM7IGNvbCsrKSB7CgkJcGFuZS0+cG9zaXRpb25zW2NvbF0gPSB4OwoJCWN4ID0gcGFuZS0+d2lkdGhzW2NvbF07CgoJCWlmIChjeCkgewoJCQljeCArPSBzcGM7CgoJCQlpZiAoY3ggPCBJTUFHRV9XSURUSCkKCQkJCWN4ID0gSU1BR0VfV0lEVEg7CgoJCQlwYW5lLT53aWR0aHNbY29sXSA9IGN4OwoJCX0KCgkJeCArPSBjeDsKCX0KCglwYW5lLT5wb3NpdGlvbnNbQ09MVU1OU10gPSB4OwoKCUxpc3RCb3hfU2V0SG9yaXpvbnRhbEV4dGVudChwYW5lLT5od25kLCB4KTsKCgkvKiBubyBjaGFuZ2U/ICovCglpZiAoIW1lbWNtcChvcmdXaWR0aHMsIHBhbmUtPndpZHRocywgc2l6ZW9mKG9yZ1dpZHRocykpKQoJCXJldHVybiBGQUxTRTsKCgkvKiBkb24ndCBtb3ZlLCBpZiBvbmx5IGNvbGxhcHNpbmcgYW4gZW50cnkgKi8KCWlmICghYW55d2F5ICYmIHBhbmUtPndpZHRoc1swXTxvcmdXaWR0aHNbMF0gJiYKCQkhbWVtY21wKG9yZ1dpZHRocysxLCBwYW5lLT53aWR0aHMrMSwgc2l6ZW9mKG9yZ1dpZHRocyktc2l6ZW9mKGludCkpKSB7CgkJcGFuZS0+d2lkdGhzWzBdID0gb3JnV2lkdGhzWzBdOwoJCW1lbWNweShwYW5lLT5wb3NpdGlvbnMsIG9yZ1Bvc2l0aW9ucywgc2l6ZW9mKG9yZ1Bvc2l0aW9ucykpOwoKCQlyZXR1cm4gRkFMU0U7Cgl9CgoJSW52YWxpZGF0ZVJlY3QocGFuZS0+aHduZCwgMCwgVFJVRSk7CgoJcmV0dXJuIFRSVUU7Cn0KCgovKiBjYWxjdWxhdGUgb25lIHByZWZlcnJlZCBjb2x1bW4gd2lkdGggKi8KCnN0YXRpYyB2b2lkIGNhbGNfc2luZ2xlX3dpZHRoKFBhbmUqIHBhbmUsIGludCBjb2wpCnsKCUhGT05UIGhmb250T2xkOwoJaW50IHgsIGN4OwoJaW50IGVudHJpZXMgPSBMaXN0Qm94X0dldENvdW50KHBhbmUtPmh3bmQpOwoJaW50IGNudDsKCUhEQyBoZGM7CgoJcGFuZS0+d2lkdGhzW2NvbF0gPSAwOwoKCWhkYyA9IEdldERDKHBhbmUtPmh3bmQpOwoJaGZvbnRPbGQgPSBTZWxlY3RGb250KGhkYywgR2xvYmFscy5oZm9udCk7CgoJZm9yKGNudD0wOyBjbnQ8ZW50cmllczsgY250KyspIHsKCQlFbnRyeSogZW50cnkgPSAoRW50cnkqKSBMaXN0Qm94X0dldEl0ZW1EYXRhKHBhbmUtPmh3bmQsIGNudCk7CgkJRFJBV0lURU1TVFJVQ1QgZGlzOwoKCQlkaXMuQ3RsVHlwZQkJICA9IDA7CgkJZGlzLkN0bElECQkgID0gMDsKCQlkaXMuaXRlbUlECQkgID0gMDsKCQlkaXMuaXRlbUFjdGlvbgkgID0gMDsKCQlkaXMuaXRlbVN0YXRlCSAgPSAwOwoJCWRpcy5od25kSXRlbQkgID0gcGFuZS0+aHduZDsKCQlkaXMuaERDCQkJICA9IGhkYzsKCQlkaXMucmNJdGVtLmxlZnQJICA9IDA7CgkJZGlzLnJjSXRlbS50b3AgICAgPSAwOwoJCWRpcy5yY0l0ZW0ucmlnaHQgID0gMDsKCQlkaXMucmNJdGVtLmJvdHRvbSA9IDA7CgkJLypkaXMuaXRlbURhdGEJICA9IDA7ICovCgoJCWRyYXdfaXRlbShwYW5lLCAmZGlzLCBlbnRyeSwgY29sKTsKCX0KCglTZWxlY3RPYmplY3QoaGRjLCBoZm9udE9sZCk7CglSZWxlYXNlREMocGFuZS0+aHduZCwgaGRjKTsKCgljeCA9IHBhbmUtPndpZHRoc1tjb2xdOwoKCWlmIChjeCkgewoJCWN4ICs9IDMqR2xvYmFscy5zcGFjZVNpemUuY3g7CgoJCWlmIChjeCA8IElNQUdFX1dJRFRIKQoJCQljeCA9IElNQUdFX1dJRFRIOwoJfQoKCXBhbmUtPndpZHRoc1tjb2xdID0gY3g7CgoJeCA9IHBhbmUtPnBvc2l0aW9uc1tjb2xdICsgY3g7CgoJZm9yKDsgY29sPENPTFVNTlM7ICkgewoJCXBhbmUtPnBvc2l0aW9uc1srK2NvbF0gPSB4OwoJCXggKz0gcGFuZS0+d2lkdGhzW2NvbF07Cgl9CgoJTGlzdEJveF9TZXRIb3Jpem9udGFsRXh0ZW50KHBhbmUtPmh3bmQsIHgpOwp9CgoKLyogaW5zZXJ0IGxpc3Rib3ggZW50cmllcyBhZnRlciBpbmRleCBpZHggKi8KCnN0YXRpYyBpbnQgaW5zZXJ0X2VudHJpZXMoUGFuZSogcGFuZSwgRW50cnkqIGRpciwgaW50IGlkeCkKewoJRW50cnkqIGVudHJ5ID0gZGlyOwoKCWlmICghZW50cnkpCgkJcmV0dXJuIGlkeDsKCglTaG93V2luZG93KHBhbmUtPmh3bmQsIFNXX0hJREUpOwoKCWZvcig7IGVudHJ5OyBlbnRyeT1lbnRyeS0+bmV4dCkgewojaWZuZGVmIF9MRUZUX0ZJTEVTCgkJaWYgKHBhbmUtPnRyZWVQYW5lICYmICEoZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyZGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpKQoJCQljb250aW51ZTsKI2VuZGlmCgoJCS8qIGRvbid0IGRpc3BsYXkgZW50cmllcyAiLiIgYW5kICIuLiIgaW4gdGhlIGxlZnQgcGFuZSAqLwoJCWlmIChwYW5lLT50cmVlUGFuZSAmJiAoZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyZGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpCgkJCQkmJiBlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMF09PVRFWFQoJy4nKSkKCQkJaWYgKAojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQllbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMV09PVRFWFQoJ1wwJykgfHwKI2VuZGlmCgkJCQkoZW50cnktPmRhdGEuY0ZpbGVOYW1lWzFdPT1URVhUKCcuJykgJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzJdPT1URVhUKCdcMCcpKSkKCQkJCWNvbnRpbnVlOwoKCQlpZiAoaWR4ICE9IC0xKQoJCQlpZHgrKzsKCgkJTGlzdEJveF9JbnNlcnRJdGVtRGF0YShwYW5lLT5od25kLCBpZHgsIGVudHJ5KTsKCgkJaWYgKHBhbmUtPnRyZWVQYW5lICYmIGVudHJ5LT5leHBhbmRlZCkKCQkJaWR4ID0gaW5zZXJ0X2VudHJpZXMocGFuZSwgZW50cnktPmRvd24sIGlkeCk7Cgl9CgoJU2hvd1dpbmRvdyhwYW5lLT5od25kLCBTV19TSE9XKTsKCglyZXR1cm4gaWR4Owp9CgoKc3RhdGljIHZvaWQgZm9ybWF0X2J5dGVzKExQVFNUUiBidWZmZXIsIExPTkdMT05HIGJ5dGVzKQp7Cgljb25zdCBzdGF0aWMgVENIQVIgc0ZtdEdCW10gPSB7JyUnLCAnLicsICcxJywgJ2YnLCAnICcsICdHJywgJ0InLCAnXDAnfTsKCWNvbnN0IHN0YXRpYyBUQ0hBUiBzRm10TUJbXSA9IHsnJScsICcuJywgJzEnLCAnZicsICcgJywgJ00nLCAnQicsICdcMCd9OwoJY29uc3Qgc3RhdGljIFRDSEFSIHNGbXRrQltdID0geyclJywgJy4nLCAnMScsICdmJywgJyAnLCAnaycsICdCJywgJ1wwJ307CgoJZmxvYXQgZkJ5dGVzID0gKGZsb2F0KWJ5dGVzOwoKCWlmIChieXRlcyA+PSAxMDczNzQxODI0KQkvKiAxIEdCICovCgkJX3N0cHJpbnRmKGJ1ZmZlciwgc0ZtdEdCLCBmQnl0ZXMvMTA3Mzc0MTgyNC5mKy41Zik7CgllbHNlIGlmIChieXRlcyA+PSAxMDQ4NTc2KQkvKiAxIE1CICovCgkJX3N0cHJpbnRmKGJ1ZmZlciwgc0ZtdE1CLCBmQnl0ZXMvMTA0ODU3Ni5mKy41Zik7CgllbHNlIGlmIChieXRlcyA+PSAxMDI0KQkJLyogMSBrQiAqLwoJCV9zdHByaW50ZihidWZmZXIsIHNGbXRrQiwgZkJ5dGVzLzEwMjQuZisuNWYpOwoJZWxzZQoJCV9zdHByaW50ZihidWZmZXIsIHNMb25nTnVtRm10LCBieXRlcyk7Cn0KCnN0YXRpYyB2b2lkIHNldF9zcGFjZV9zdGF0dXMoKQp7CglVTEFSR0VfSU5URUdFUiB1bEZyZWVCeXRlc1RvQ2FsbGVyLCB1bFRvdGFsQnl0ZXMsIHVsRnJlZUJ5dGVzOwoJVENIQVIgZm10WzY0XSwgYjFbNjRdLCBiMls2NF0sIGJ1ZmZlcltCVUZGRVJfTEVOXTsKCglpZiAoR2V0RGlza0ZyZWVTcGFjZUV4KE5VTEwsICZ1bEZyZWVCeXRlc1RvQ2FsbGVyLCAmdWxUb3RhbEJ5dGVzLCAmdWxGcmVlQnl0ZXMpKSB7CgkJZm9ybWF0X2J5dGVzKGIxLCB1bEZyZWVCeXRlc1RvQ2FsbGVyLlF1YWRQYXJ0KTsKCQlmb3JtYXRfYnl0ZXMoYjIsIHVsVG90YWxCeXRlcy5RdWFkUGFydCk7CgkJX3N0cHJpbnRmKGJ1ZmZlciwgUlMoZm10LElEU19GUkVFX1NQQUNFX0ZNVCksIGIxLCBiMik7Cgl9IGVsc2UKCQlfdGNzY3B5KGJ1ZmZlciwgc1FNYXJrcyk7CgoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oc3RhdHVzYmFyLCBTQl9TRVRURVhULCAwLCAoTFBBUkFNKWJ1ZmZlcik7Cn0KCgpzdGF0aWMgV05EUFJPQyBnX29yZ1RyZWVXbmRQcm9jOwoKc3RhdGljIHZvaWQgY3JlYXRlX3RyZWVfd2luZG93KEhXTkQgcGFyZW50LCBQYW5lKiBwYW5lLCBpbnQgaWQsIGludCBpZF9oZWFkZXIpCnsKCWNvbnN0IHN0YXRpYyBUQ0hBUiBzTGlzdEJveFtdID0geydMJywnaScsJ3MnLCd0JywnQicsJ28nLCd4JywnXDAnfTsKCglzdGF0aWMgaW50IHNfaW5pdCA9IDA7CglFbnRyeSogZW50cnkgPSBwYW5lLT5yb290OwoKCXBhbmUtPmh3bmQgPSBDcmVhdGVXaW5kb3coc0xpc3RCb3gsIHNFbXB0eSwgV1NfQ0hJTER8V1NfVklTSUJMRXxXU19IU0NST0xMfFdTX1ZTQ1JPTEx8CgkJCQkJCQkJTEJTX0RJU0FCTEVOT1NDUk9MTHxMQlNfTk9JTlRFR1JBTEhFSUdIVHxMQlNfT1dORVJEUkFXRklYRUR8TEJTX05PVElGWSwKCQkJCQkJCQkwLCAwLCAwLCAwLCBwYXJlbnQsIChITUVOVSlpZCwgR2xvYmFscy5oSW5zdGFuY2UsIDApOwoKCVNldFdpbmRvd0xvbmcocGFuZS0+aHduZCwgR1dMX1VTRVJEQVRBLCAoTFBBUkFNKXBhbmUpOwoJZ19vcmdUcmVlV25kUHJvYyA9IFN1YmNsYXNzV2luZG93KHBhbmUtPmh3bmQsIFRyZWVXbmRQcm9jKTsKCglTZXRXaW5kb3dGb250KHBhbmUtPmh3bmQsIEdsb2JhbHMuaGZvbnQsIEZBTFNFKTsKCgkvKiBpbnNlcnQgZW50cmllcyBpbnRvIGxpc3Rib3ggKi8KCWlmIChlbnRyeSkKCQlpbnNlcnRfZW50cmllcyhwYW5lLCBlbnRyeSwgLTEpOwoKCS8qIGNhbGN1bGF0ZSBjb2x1bW4gd2lkdGhzICovCglpZiAoIXNfaW5pdCkgewoJCXNfaW5pdCA9IDE7CgkJaW5pdF9vdXRwdXQocGFuZS0+aHduZCk7Cgl9CgoJY2FsY193aWR0aHMocGFuZSwgVFJVRSk7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCglwYW5lLT5od25kSGVhZGVyID0gY3JlYXRlX2hlYWRlcihwYXJlbnQsIHBhbmUsIGlkX2hlYWRlcik7CiNlbmRpZgp9CgoKc3RhdGljIHZvaWQgSW5pdENoaWxkV2luZG93KENoaWxkV25kKiBjaGlsZCkKewoJY3JlYXRlX3RyZWVfd2luZG93KGNoaWxkLT5od25kLCAmY2hpbGQtPmxlZnQsIElEV19UUkVFX0xFRlQsIElEV19IRUFERVJfTEVGVCk7CgljcmVhdGVfdHJlZV93aW5kb3coY2hpbGQtPmh3bmQsICZjaGlsZC0+cmlnaHQsIElEV19UUkVFX1JJR0hULCBJRFdfSEVBREVSX1JJR0hUKTsKfQoKCnN0YXRpYyB2b2lkIGZvcm1hdF9kYXRlKGNvbnN0IEZJTEVUSU1FKiBmdCwgVENIQVIqIGJ1ZmZlciwgaW50IHZpc2libGVfY29scykKewoJU1lTVEVNVElNRSBzeXN0aW1lOwoJRklMRVRJTUUgbGZ0OwoJaW50IGxlbiA9IDA7CgoJKmJ1ZmZlciA9IFRFWFQoJ1wwJyk7CgoJaWYgKCFmdC0+ZHdMb3dEYXRlVGltZSAmJiAhZnQtPmR3SGlnaERhdGVUaW1lKQoJCXJldHVybjsKCglpZiAoIUZpbGVUaW1lVG9Mb2NhbEZpbGVUaW1lKGZ0LCAmbGZ0KSkKCQl7ZXJyOiBfdGNzY3B5KGJ1ZmZlcixzUU1hcmtzKTsgcmV0dXJuO30KCglpZiAoIUZpbGVUaW1lVG9TeXN0ZW1UaW1lKCZsZnQsICZzeXN0aW1lKSkKCQlnb3RvIGVycjsKCglpZiAodmlzaWJsZV9jb2xzICYgQ09MX0RBVEUpIHsKCQlsZW4gPSBHZXREYXRlRm9ybWF0KExPQ0FMRV9VU0VSX0RFRkFVTFQsIDAsICZzeXN0aW1lLCAwLCBidWZmZXIsIEJVRkZFUl9MRU4pOwoJCWlmICghbGVuKQoJCQlnb3RvIGVycjsKCX0KCglpZiAodmlzaWJsZV9jb2xzICYgQ09MX1RJTUUpIHsKCQlpZiAobGVuKQoJCQlidWZmZXJbbGVuLTFdID0gJyAnOwoKCQlidWZmZXJbbGVuKytdID0gJyAnOwoKCQlpZiAoIUdldFRpbWVGb3JtYXQoTE9DQUxFX1VTRVJfREVGQVVMVCwgMCwgJnN5c3RpbWUsIDAsIGJ1ZmZlcitsZW4sIEJVRkZFUl9MRU4tbGVuKSkKCQkJYnVmZmVyW2xlbl0gPSBURVhUKCdcMCcpOwoJfQp9CgoKc3RhdGljIHZvaWQgY2FsY193aWR0aChQYW5lKiBwYW5lLCBMUERSQVdJVEVNU1RSVUNUIGRpcywgaW50IGNvbCwgTFBDVFNUUiBzdHIpCnsKCVJFQ1QgcnQgPSB7MCwgMCwgMCwgMH07CgoJRHJhd1RleHQoZGlzLT5oREMsIChMUFRTVFIpc3RyLCAtMSwgJnJ0LCBEVF9DQUxDUkVDVHxEVF9TSU5HTEVMSU5FfERUX05PUFJFRklYKTsKCglpZiAocnQucmlnaHQgPiBwYW5lLT53aWR0aHNbY29sXSkKCQlwYW5lLT53aWR0aHNbY29sXSA9IHJ0LnJpZ2h0Owp9CgpzdGF0aWMgdm9pZCBjYWxjX3RhYmJlZF93aWR0aChQYW5lKiBwYW5lLCBMUERSQVdJVEVNU1RSVUNUIGRpcywgaW50IGNvbCwgTFBDVFNUUiBzdHIpCnsKCVJFQ1QgcnQgPSB7MCwgMCwgMCwgMH07CgovKglEUkFXVEVYVFBBUkFNUyBkdHAgPSB7c2l6ZW9mKERSQVdURVhUUEFSQU1TKSwgMn07CglEcmF3VGV4dEV4KGRpcy0+aERDLCAoTFBUU1RSKXN0ciwgLTEsICZydCwgRFRfQ0FMQ1JFQ1R8RFRfU0lOR0xFTElORXxEVF9OT1BSRUZJWHxEVF9FWFBBTkRUQUJTfERUX1RBQlNUT1AsICZkdHApOyovCgoJRHJhd1RleHQoZGlzLT5oREMsIChMUFRTVFIpc3RyLCAtMSwgJnJ0LCBEVF9DQUxDUkVDVHxEVF9TSU5HTEVMSU5FfERUX0VYUEFORFRBQlN8RFRfVEFCU1RPUHwoMjw8OCkpOwoJLypGSVhNRSBydCAoMCwwKSA/Pz8gKi8KCglpZiAocnQucmlnaHQgPiBwYW5lLT53aWR0aHNbY29sXSkKCQlwYW5lLT53aWR0aHNbY29sXSA9IHJ0LnJpZ2h0Owp9CgoKc3RhdGljIHZvaWQgb3V0cHV0X3RleHQoUGFuZSogcGFuZSwgTFBEUkFXSVRFTVNUUlVDVCBkaXMsIGludCBjb2wsIExQQ1RTVFIgc3RyLCBEV09SRCBmbGFncykKewoJaW50IHggPSBkaXMtPnJjSXRlbS5sZWZ0OwoJUkVDVCBydDsKCglydC5sZWZ0ICAgPSB4K3BhbmUtPnBvc2l0aW9uc1tjb2xdK0dsb2JhbHMuc3BhY2VTaXplLmN4OwoJcnQudG9wICAgID0gZGlzLT5yY0l0ZW0udG9wOwoJcnQucmlnaHQgID0geCtwYW5lLT5wb3NpdGlvbnNbY29sKzFdLUdsb2JhbHMuc3BhY2VTaXplLmN4OwoJcnQuYm90dG9tID0gZGlzLT5yY0l0ZW0uYm90dG9tOwoKCURyYXdUZXh0KGRpcy0+aERDLCAoTFBUU1RSKXN0ciwgLTEsICZydCwgRFRfU0lOR0xFTElORXxEVF9OT1BSRUZJWHxmbGFncyk7Cn0KCnN0YXRpYyB2b2lkIG91dHB1dF90YWJiZWRfdGV4dChQYW5lKiBwYW5lLCBMUERSQVdJVEVNU1RSVUNUIGRpcywgaW50IGNvbCwgTFBDVFNUUiBzdHIpCnsKCWludCB4ID0gZGlzLT5yY0l0ZW0ubGVmdDsKCVJFQ1QgcnQ7CgoJcnQubGVmdCAgID0geCtwYW5lLT5wb3NpdGlvbnNbY29sXStHbG9iYWxzLnNwYWNlU2l6ZS5jeDsKCXJ0LnRvcCAgICA9IGRpcy0+cmNJdGVtLnRvcDsKCXJ0LnJpZ2h0ICA9IHgrcGFuZS0+cG9zaXRpb25zW2NvbCsxXS1HbG9iYWxzLnNwYWNlU2l6ZS5jeDsKCXJ0LmJvdHRvbSA9IGRpcy0+cmNJdGVtLmJvdHRvbTsKCi8qCURSQVdURVhUUEFSQU1TIGR0cCA9IHtzaXplb2YoRFJBV1RFWFRQQVJBTVMpLCAyfTsKCURyYXdUZXh0RXgoZGlzLT5oREMsIChMUFRTVFIpc3RyLCAtMSwgJnJ0LCBEVF9TSU5HTEVMSU5FfERUX05PUFJFRklYfERUX0VYUEFORFRBQlN8RFRfVEFCU1RPUCwgJmR0cCk7Ki8KCglEcmF3VGV4dChkaXMtPmhEQywgKExQVFNUUilzdHIsIC0xLCAmcnQsIERUX1NJTkdMRUxJTkV8RFRfRVhQQU5EVEFCU3xEVF9UQUJTVE9QfCgyPDw4KSk7Cn0KCnN0YXRpYyB2b2lkIG91dHB1dF9udW1iZXIoUGFuZSogcGFuZSwgTFBEUkFXSVRFTVNUUlVDVCBkaXMsIGludCBjb2wsIExQQ1RTVFIgc3RyKQp7CglpbnQgeCA9IGRpcy0+cmNJdGVtLmxlZnQ7CglSRUNUIHJ0OwoJTFBDVFNUUiBzID0gc3RyOwoJVENIQVIgYlsxMjhdOwoJTFBUU1RSIGQgPSBiOwoJaW50IHBvczsKCglydC5sZWZ0ICAgPSB4K3BhbmUtPnBvc2l0aW9uc1tjb2xdK0dsb2JhbHMuc3BhY2VTaXplLmN4OwoJcnQudG9wICAgID0gZGlzLT5yY0l0ZW0udG9wOwoJcnQucmlnaHQgID0geCtwYW5lLT5wb3NpdGlvbnNbY29sKzFdLUdsb2JhbHMuc3BhY2VTaXplLmN4OwoJcnQuYm90dG9tID0gZGlzLT5yY0l0ZW0uYm90dG9tOwoKCWlmICgqcykKCQkqZCsrID0gKnMrKzsKCgkvKiBpbnNlcnQgbnVtYmVyIHNlcGFyYXRvciBjaGFyYWN0ZXJzICovCglwb3MgPSBsc3RybGVuKHMpICUgMzsKCgl3aGlsZSgqcykKCQlpZiAocG9zLS0pCgkJCSpkKysgPSAqcysrOwoJCWVsc2UgewoJCQkqZCsrID0gR2xvYmFscy5udW1fc2VwOwoJCQlwb3MgPSAzOwoJCX0KCglEcmF3VGV4dChkaXMtPmhEQywgYiwgZC1iLCAmcnQsIERUX1JJR0hUfERUX1NJTkdMRUxJTkV8RFRfTk9QUkVGSVh8RFRfRU5EX0VMTElQU0lTKTsKfQoKCnN0YXRpYyBpbnQgaXNfZXhlX2ZpbGUoTFBDVFNUUiBleHQpCnsKCXN0YXRpYyBjb25zdCBUQ0hBUiBleGVjdXRhYmxlX2V4dGVuc2lvbnNbXVs0XSA9IHsKCQl7J0MnLCdPJywnTScsJ1wwJ30sCgkJeydFJywnWCcsJ0UnLCdcMCd9LAoJCXsnQicsJ0EnLCdUJywnXDAnfSwKCQl7J0MnLCdNJywnRCcsJ1wwJ30sCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQl7J0MnLCdNJywnTScsJ1wwJ30sCgkJeydCJywnVCcsJ00nLCdcMCd9LAoJCXsnQScsJ1cnLCdLJywnXDAnfSwKI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgkJeydcMCd9Cgl9OwoKCVRDSEFSIGV4dF9idWZmZXJbX01BWF9FWFRdOwoJY29uc3QgVENIQVIgKCpwKVs0XTsKCUxQQ1RTVFIgczsKCUxQVFNUUiBkOwoKCWZvcihzPWV4dCsxLGQ9ZXh0X2J1ZmZlcjsgKCpkPXRvbG93ZXIoKnMpKTsgcysrKQoJCWQrKzsKCglmb3IocD1leGVjdXRhYmxlX2V4dGVuc2lvbnM7ICgqcClbMF07IHArKykKCQlpZiAoIV90Y3NjbXAoZXh0X2J1ZmZlciwgKnApKQoJCQlyZXR1cm4gMTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBpc19yZWdpc3RlcmVkX3R5cGUoTFBDVFNUUiBleHQpCnsKICAgICAgICAvKiBUT0RPICovCgoJcmV0dXJuIDE7Cn0KCgpzdGF0aWMgdm9pZCBkcmF3X2l0ZW0oUGFuZSogcGFuZSwgTFBEUkFXSVRFTVNUUlVDVCBkaXMsIEVudHJ5KiBlbnRyeSwgaW50IGNhbGNXaWR0aENvbCkKewoJVENIQVIgYnVmZmVyW0JVRkZFUl9MRU5dOwoJRFdPUkQgYXR0cnM7CglpbnQgdmlzaWJsZV9jb2xzID0gcGFuZS0+dmlzaWJsZV9jb2xzOwoJQ09MT1JSRUYgYmtjb2xvciwgdGV4dGNvbG9yOwoJUkVDVCBmb2N1c1JlY3QgPSBkaXMtPnJjSXRlbTsKCUhCUlVTSCBoYnJ1c2g7CgllbnVtIElNQUdFIGltZzsKCWludCBpbWdfcG9zLCBjeDsKCWludCBjb2wgPSAwOwoKCWlmIChlbnRyeSkgewoJCWF0dHJzID0gZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlczsKCgkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSB7CgkJCWlmIChlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMF09PVRFWFQoJy4nKSAmJiBlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMV09PVRFWFQoJy4nKQoJCQkJCSYmIGVudHJ5LT5kYXRhLmNGaWxlTmFtZVsyXT09VEVYVCgnXDAnKSkKCQkJCWltZyA9IElNR19GT0xERVJfVVA7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQkJZWxzZSBpZiAoZW50cnktPmRhdGEuY0ZpbGVOYW1lWzBdPT1URVhUKCcuJykgJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzFdPT1URVhUKCdcMCcpKQoJCQkJaW1nID0gSU1HX0ZPTERFUl9DVVI7CiNlbmRpZgoJCQllbHNlIGlmICgKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJCQkJIGVudHJ5LT5leHBhbmRlZCB8fAojZW5kaWYKCQkJCQkgKHBhbmUtPnRyZWVQYW5lICYmIChkaXMtPml0ZW1TdGF0ZSZPRFNfRk9DVVMpKSkKCQkJCWltZyA9IElNR19PUEVOX0ZPTERFUjsKCQkJZWxzZQoJCQkJaW1nID0gSU1HX0ZPTERFUjsKCQl9IGVsc2UgewoJCQlMUENUU1RSIGV4dCA9IF90Y3NyY2hyKGVudHJ5LT5kYXRhLmNGaWxlTmFtZSwgJy4nKTsKCQkJaWYgKCFleHQpCgkJCQlleHQgPSBzRW1wdHk7CgoJCQlpZiAoaXNfZXhlX2ZpbGUoZXh0KSkKCQkJCWltZyA9IElNR19FWEVDVVRBQkxFOwoJCQllbHNlIGlmIChpc19yZWdpc3RlcmVkX3R5cGUoZXh0KSkKCQkJCWltZyA9IElNR19ET0NVTUVOVDsKCQkJZWxzZQoJCQkJaW1nID0gSU1HX0ZJTEU7CgkJfQoJfSBlbHNlIHsKCQlhdHRycyA9IDA7CgkJaW1nID0gSU1HX05PTkU7Cgl9CgoJaWYgKHBhbmUtPnRyZWVQYW5lKSB7CgkJaWYgKGVudHJ5KSB7CgkJCWltZ19wb3MgPSBkaXMtPnJjSXRlbS5sZWZ0ICsgZW50cnktPmxldmVsKihJTUFHRV9XSURUSCtUUkVFX0xJTkVfRFgpOwoKCQkJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkgewoJCQkJaW50IHg7CgkJCQlpbnQgeSA9IGRpcy0+cmNJdGVtLnRvcCArIElNQUdFX0hFSUdIVC8yOwoJCQkJRW50cnkqIHVwOwoJCQkJUkVDVCBydF9jbGlwOwoJCQkJSFJHTiBocmduX29yZyA9IENyZWF0ZVJlY3RSZ24oMCwgMCwgMCwgMCk7CgkJCQlIUkdOIGhyZ247CgoJCQkJcnRfY2xpcC5sZWZ0ICAgPSBkaXMtPnJjSXRlbS5sZWZ0OwoJCQkJcnRfY2xpcC50b3AgICAgPSBkaXMtPnJjSXRlbS50b3A7CgkJCQlydF9jbGlwLnJpZ2h0ICA9IGRpcy0+cmNJdGVtLmxlZnQrcGFuZS0+d2lkdGhzW2NvbF07CgkJCQlydF9jbGlwLmJvdHRvbSA9IGRpcy0+cmNJdGVtLmJvdHRvbTsKCgkJCQlocmduID0gQ3JlYXRlUmVjdFJnbkluZGlyZWN0KCZydF9jbGlwKTsKCgkJCQlpZiAoIUdldENsaXBSZ24oZGlzLT5oREMsIGhyZ25fb3JnKSkgewoJCQkJCURlbGV0ZU9iamVjdChocmduX29yZyk7CgkJCQkJaHJnbl9vcmcgPSAwOwoJCQkJfQoKCQkJCS8qIEhHRElPQkogaG9sZFBlbiA9IFNlbGVjdE9iamVjdChkaXMtPmhEQywgR2V0U3RvY2tPYmplY3QoQkxBQ0tfUEVOKSk7ICovCgkJCQlFeHRTZWxlY3RDbGlwUmduKGRpcy0+aERDLCBocmduLCBSR05fQU5EKTsKCQkJCURlbGV0ZU9iamVjdChocmduKTsKCgkJCQlpZiAoKHVwPWVudHJ5LT51cCkgIT0gTlVMTCkgewoJCQkJCU1vdmVUb0V4KGRpcy0+aERDLCBpbWdfcG9zLUlNQUdFX1dJRFRILzIsIHksIDApOwoJCQkJCUxpbmVUbyhkaXMtPmhEQywgaW1nX3Bvcy0yLCB5KTsKCgkJCQkJeCA9IGltZ19wb3MgLSBJTUFHRV9XSURUSC8yOwoKCQkJCQlkbyB7CgkJCQkJCXggLT0gSU1BR0VfV0lEVEgrVFJFRV9MSU5FX0RYOwoKCQkJCQkJaWYgKHVwLT5uZXh0CiNpZm5kZWYgX0xFRlRfRklMRVMKCQkJCQkJCSYmICh1cC0+bmV4dC0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKQojZW5kaWYKCQkJCQkJCSkgewoJCQkJCQkJTW92ZVRvRXgoZGlzLT5oREMsIHgsIGRpcy0+cmNJdGVtLnRvcCwgMCk7CgkJCQkJCQlMaW5lVG8oZGlzLT5oREMsIHgsIGRpcy0+cmNJdGVtLmJvdHRvbSk7CgkJCQkJCX0KCQkJCQl9IHdoaWxlKCh1cD11cC0+dXApICE9IE5VTEwpOwoJCQkJfQoKCQkJCXggPSBpbWdfcG9zIC0gSU1BR0VfV0lEVEgvMjsKCgkJCQlNb3ZlVG9FeChkaXMtPmhEQywgeCwgZGlzLT5yY0l0ZW0udG9wLCAwKTsKCQkJCUxpbmVUbyhkaXMtPmhEQywgeCwgeSk7CgoJCQkJaWYgKGVudHJ5LT5uZXh0CiNpZm5kZWYgX0xFRlRfRklMRVMKCQkJCQkmJiAoZW50cnktPm5leHQtPmRhdGEuZHdGaWxlQXR0cmlidXRlcyZGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpCiNlbmRpZgoJCQkJCSkKCQkJCQlMaW5lVG8oZGlzLT5oREMsIHgsIGRpcy0+cmNJdGVtLmJvdHRvbSk7CgoJCQkJaWYgKGVudHJ5LT5kb3duICYmIGVudHJ5LT5leHBhbmRlZCkgewoJCQkJCXggKz0gSU1BR0VfV0lEVEgrVFJFRV9MSU5FX0RYOwoJCQkJCU1vdmVUb0V4KGRpcy0+aERDLCB4LCBkaXMtPnJjSXRlbS50b3ArSU1BR0VfSEVJR0hUKzIsIDApOwoJCQkJCUxpbmVUbyhkaXMtPmhEQywgeCwgZGlzLT5yY0l0ZW0uYm90dG9tKTsKCQkJCX0KCgkJCQlTZWxlY3RDbGlwUmduKGRpcy0+aERDLCBocmduX29yZyk7CgkJCQlpZiAoaHJnbl9vcmcpIERlbGV0ZU9iamVjdChocmduX29yZyk7CgkJCQkvKiBTZWxlY3RPYmplY3QoZGlzLT5oREMsIGhvbGRQZW4pOyAqLwoJCQl9IGVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykgewoJCQkJaW50IHJpZ2h0ID0gaW1nX3BvcyArIElNQUdFX1dJRFRIIC0gVFJFRV9MSU5FX0RYOwoKCQkJCWlmIChyaWdodCA+IHBhbmUtPndpZHRoc1tjb2xdKQoJCQkJCXBhbmUtPndpZHRoc1tjb2xdID0gcmlnaHQ7CgkJCX0KCQl9IGVsc2UgIHsKCQkJaW1nX3BvcyA9IGRpcy0+cmNJdGVtLmxlZnQ7CgkJfQoJfSBlbHNlIHsKCQlpbWdfcG9zID0gZGlzLT5yY0l0ZW0ubGVmdDsKCgkJaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQkJcGFuZS0+d2lkdGhzW2NvbF0gPSBJTUFHRV9XSURUSDsKCX0KCglpZiAoY2FsY1dpZHRoQ29sID09IC0xKSB7CgkJZm9jdXNSZWN0LmxlZnQgPSBpbWdfcG9zIC0yOwoKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJaWYgKHBhbmUtPnRyZWVQYW5lICYmIGVudHJ5KSB7CgkJCVJFQ1QgcnQgPSB7MH07CgoJCQlEcmF3VGV4dChkaXMtPmhEQywgZW50cnktPmRhdGEuY0ZpbGVOYW1lLCAtMSwgJnJ0LCBEVF9DQUxDUkVDVHxEVF9TSU5HTEVMSU5FfERUX05PUFJFRklYKTsKCgkJCWZvY3VzUmVjdC5yaWdodCA9IGRpcy0+cmNJdGVtLmxlZnQrcGFuZS0+cG9zaXRpb25zW2NvbCsxXStUUkVFX0xJTkVfRFggKyBydC5yaWdodCArMjsKCQl9CiNlbHNlCgoJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX0NPTVBSRVNTRUQpCgkJCXRleHRjb2xvciA9IENPTE9SX0NPTVBSRVNTRUQ7CgkJZWxzZQojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCQkJdGV4dGNvbG9yID0gUkdCKDAsMCwwKTsKCgkJaWYgKGRpcy0+aXRlbVN0YXRlICYgT0RTX0ZPQ1VTKSB7CgkJCXRleHRjb2xvciA9IFJHQigyNTUsMjU1LDI1NSk7CgkJCWJrY29sb3IgPSBDT0xPUl9TRUxFQ1RJT047CgkJfSBlbHNlIHsKCQkJYmtjb2xvciA9IFJHQigyNTUsMjU1LDI1NSk7CgkJfQoKCQloYnJ1c2ggPSBDcmVhdGVTb2xpZEJydXNoKGJrY29sb3IpOwoJCUZpbGxSZWN0KGRpcy0+aERDLCAmZm9jdXNSZWN0LCBoYnJ1c2gpOwoJCURlbGV0ZU9iamVjdChoYnJ1c2gpOwoKCQlTZXRCa01vZGUoZGlzLT5oREMsIFRSQU5TUEFSRU5UKTsKCQlTZXRUZXh0Q29sb3IoZGlzLT5oREMsIHRleHRjb2xvcik7CgoJCWN4ID0gcGFuZS0+d2lkdGhzW2NvbF07CgoJCWlmIChjeCAmJiBpbWchPUlNR19OT05FKSB7CgoJCQlpZiAoY3ggPiBJTUFHRV9XSURUSCkKCQkJCWN4ID0gSU1BR0VfV0lEVEg7CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCQkJaWYgKGVudHJ5LT5oaWNvbiAmJiBlbnRyeS0+aGljb24hPShISUNPTiktMSkKCQkJCURyYXdJY29uRXgoZGlzLT5oREMsIGltZ19wb3MsIGRpcy0+cmNJdGVtLnRvcCwgZW50cnktPmhpY29uLCBjeCwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNNSUNPTiksIDAsIDAsIERJX05PUk1BTCk7CgkJCWVsc2UKI2VuZGlmCgkJCQlJbWFnZUxpc3RfRHJhd0V4KEdsb2JhbHMuaGltbCwgaW1nLCBkaXMtPmhEQywKCQkJCQkJCQkgaW1nX3BvcywgZGlzLT5yY0l0ZW0udG9wLCBjeCwKCQkJCQkJCQkgSU1BR0VfSEVJR0hULCBia2NvbG9yLCBDTFJfREVGQVVMVCwgSUxEX05PUk1BTCk7CgkJfQoJfQoKCWlmICghZW50cnkpCgkJcmV0dXJuOwoKI2lmZGVmIF9OT19FWFRFTlNJT05TCglpZiAoaW1nID49IElNR19GT0xERVJfVVApCgkJcmV0dXJuOwojZW5kaWYKCgljb2wrKzsKCgkvKiBvdXB1dCBmaWxlIG5hbWUgKi8KCWlmIChjYWxjV2lkdGhDb2wgPT0gLTEpCgkJb3V0cHV0X3RleHQocGFuZSwgZGlzLCBjb2wsIGVudHJ5LT5kYXRhLmNGaWxlTmFtZSwgMCk7CgllbHNlIGlmIChjYWxjV2lkdGhDb2w9PWNvbCB8fCBjYWxjV2lkdGhDb2w9PUNPTFVNTlMpCgkJY2FsY193aWR0aChwYW5lLCBkaXMsIGNvbCwgZW50cnktPmRhdGEuY0ZpbGVOYW1lKTsKCgljb2wrKzsKCiNpZmRlZiBfTk9fRVhURU5TSU9OUwogIGlmICghcGFuZS0+dHJlZVBhbmUpIHsKI2VuZGlmCgogICAgICAgIC8qIGRpc3BsYXkgZmlsZSBzaXplICovCglpZiAodmlzaWJsZV9jb2xzICYgQ09MX1NJWkUpIHsKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJaWYgKCEoYXR0cnMmRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSkKI2VuZGlmCgkJewoJCQlVTE9OR0xPTkcgc2l6ZTsKCiAgICAgICAgICAgICAgICAgICAgICAgIHNpemUgPSAoKFVMT05HTE9ORyllbnRyeS0+ZGF0YS5uRmlsZVNpemVIaWdoIDw8IDMyKSB8IGVudHJ5LT5kYXRhLm5GaWxlU2l6ZUxvdzsKCgkJCV9zdHByaW50ZihidWZmZXIsIHNMb25nTnVtRm10LCBzaXplKTsKCgkJCWlmIChjYWxjV2lkdGhDb2wgPT0gLTEpCgkJCQlvdXRwdXRfbnVtYmVyKHBhbmUsIGRpcywgY29sLCBidWZmZXIpOwoJCQllbHNlIGlmIChjYWxjV2lkdGhDb2w9PWNvbCB8fCBjYWxjV2lkdGhDb2w9PUNPTFVNTlMpCgkJCQljYWxjX3dpZHRoKHBhbmUsIGRpcywgY29sLCBidWZmZXIpOy8qVE9ETzogbm90IGV2ZXIgdGltZSBlbm91Z2ggKi8KCQl9CgoJCWNvbCsrOwoJfQoKCS8qIGRpc3BsYXkgZmlsZSBkYXRlICovCglpZiAodmlzaWJsZV9jb2xzICYgKENPTF9EQVRFfENPTF9USU1FKSkgewojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJZm9ybWF0X2RhdGUoJmVudHJ5LT5kYXRhLmZ0Q3JlYXRpb25UaW1lLCBidWZmZXIsIHZpc2libGVfY29scyk7CgkJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkKCQkJb3V0cHV0X3RleHQocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlciwgMCk7CgkJZWxzZSBpZiAoY2FsY1dpZHRoQ29sPT1jb2wgfHwgY2FsY1dpZHRoQ29sPT1DT0xVTU5TKQoJCQljYWxjX3dpZHRoKHBhbmUsIGRpcywgY29sLCBidWZmZXIpOwoJCWNvbCsrOwoKCQlmb3JtYXRfZGF0ZSgmZW50cnktPmRhdGEuZnRMYXN0QWNjZXNzVGltZSwgYnVmZmVyLCB2aXNpYmxlX2NvbHMpOwoJCWlmIChjYWxjV2lkdGhDb2wgPT0gLTEpCgkJCW91dHB1dF90ZXh0KHBhbmUsIGRpcywgY29sLCBidWZmZXIsIDApOwoJCWVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQkJY2FsY193aWR0aChwYW5lLCBkaXMsIGNvbCwgYnVmZmVyKTsKCQljb2wrKzsKI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgoJCWZvcm1hdF9kYXRlKCZlbnRyeS0+ZGF0YS5mdExhc3RXcml0ZVRpbWUsIGJ1ZmZlciwgdmlzaWJsZV9jb2xzKTsKCQlpZiAoY2FsY1dpZHRoQ29sID09IC0xKQoJCQlvdXRwdXRfdGV4dChwYW5lLCBkaXMsIGNvbCwgYnVmZmVyLCAwKTsKCQllbHNlIGlmIChjYWxjV2lkdGhDb2w9PWNvbCB8fCBjYWxjV2lkdGhDb2w9PUNPTFVNTlMpCgkJCWNhbGNfd2lkdGgocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlcik7CgkJY29sKys7Cgl9CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCglpZiAoZW50cnktPmJoZmlfdmFsaWQpIHsKICAgICAgICAgICAgVUxPTkdMT05HIGluZGV4ID0gKChVTE9OR0xPTkcpZW50cnktPmJoZmkubkZpbGVJbmRleEhpZ2ggPDwgMzIpIHwgZW50cnktPmJoZmkubkZpbGVJbmRleExvdzsKCgkJaWYgKHZpc2libGVfY29scyAmIENPTF9JTkRFWCkgewoJCQlfc3RwcmludGYoYnVmZmVyLCBzTG9uZ0hleEZtdCwgaW5kZXgpOwoKCQkJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkKCQkJCW91dHB1dF90ZXh0KHBhbmUsIGRpcywgY29sLCBidWZmZXIsIERUX1JJR0hUKTsKCQkJZWxzZSBpZiAoY2FsY1dpZHRoQ29sPT1jb2wgfHwgY2FsY1dpZHRoQ29sPT1DT0xVTU5TKQoJCQkJY2FsY193aWR0aChwYW5lLCBkaXMsIGNvbCwgYnVmZmVyKTsKCgkJCWNvbCsrOwoJCX0KCgkJaWYgKHZpc2libGVfY29scyAmIENPTF9MSU5LUykgewoJCQl3c3ByaW50ZihidWZmZXIsIHNOdW1GbXQsIGVudHJ5LT5iaGZpLm5OdW1iZXJPZkxpbmtzKTsKCgkJCWlmIChjYWxjV2lkdGhDb2wgPT0gLTEpCgkJCQlvdXRwdXRfdGV4dChwYW5lLCBkaXMsIGNvbCwgYnVmZmVyLCBEVF9DRU5URVIpOwoJCQllbHNlIGlmIChjYWxjV2lkdGhDb2w9PWNvbCB8fCBjYWxjV2lkdGhDb2w9PUNPTFVNTlMpCgkJCQljYWxjX3dpZHRoKHBhbmUsIGRpcywgY29sLCBidWZmZXIpOwoKCQkJY29sKys7CgkJfQoJfSBlbHNlCgkJY29sICs9IDI7CiNlbmRpZiAvKiBfTk9fRVhURU5TSU9OUyAqLwoKCS8qIHNob3cgZmlsZSBhdHRyaWJ1dGVzICovCglpZiAodmlzaWJsZV9jb2xzICYgQ09MX0FUVFJJQlVURVMpIHsKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJY29uc3Qgc3RhdGljIFRDSEFSIHM0VGFic1tdID0geycgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXDAnfTsKCQlfdGNzY3B5KGJ1ZmZlciwgczRUYWJzKTsKI2Vsc2UKCQljb25zdCBzdGF0aWMgVENIQVIgczExVGFic1tdID0geycgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywnXDAnfTsKCQlfdGNzY3B5KGJ1ZmZlciwgczExVGFicyk7CiNlbmRpZgoKCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9OT1JNQUwpCQkJCQlidWZmZXJbIDBdID0gJ04nOwoJCWVsc2UgewoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9SRUFET05MWSkJCQlidWZmZXJbIDJdID0gJ1InOwoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9ISURERU4pCQkJCWJ1ZmZlclsgNF0gPSAnSCc7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX1NZU1RFTSkJCQkJYnVmZmVyWyA2XSA9ICdTJzsKCQkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfQVJDSElWRSkJCQkJYnVmZmVyWyA4XSA9ICdBJzsKCQkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfQ09NUFJFU1NFRCkJCQlidWZmZXJbMTBdID0gJ0MnOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkJCQlidWZmZXJbMTJdID0gJ0QnOwoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9FTkNSWVBURUQpCQkJYnVmZmVyWzE0XSA9ICdFJzsKCQkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfVEVNUE9SQVJZKQkJCWJ1ZmZlclsxNl0gPSAnVCc7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX1NQQVJTRV9GSUxFKQkJCWJ1ZmZlclsxOF0gPSAnUCc7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX1JFUEFSU0VfUE9JTlQpCQlidWZmZXJbMjBdID0gJ1EnOwoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9PRkZMSU5FKQkJCQlidWZmZXJbMjJdID0gJ08nOwoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9OT1RfQ09OVEVOVF9JTkRFWEVEKQlidWZmZXJbMjRdID0gJ1gnOwojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCQl9CgoJCWlmIChjYWxjV2lkdGhDb2wgPT0gLTEpCgkJCW91dHB1dF90YWJiZWRfdGV4dChwYW5lLCBkaXMsIGNvbCwgYnVmZmVyKTsKCQllbHNlIGlmIChjYWxjV2lkdGhDb2w9PWNvbCB8fCBjYWxjV2lkdGhDb2w9PUNPTFVNTlMpCgkJCWNhbGNfdGFiYmVkX3dpZHRoKHBhbmUsIGRpcywgY29sLCBidWZmZXIpOwoKCQljb2wrKzsKCX0KCi8qVE9ETwoJaWYgKGZsYWdzLnNlY3VyaXR5KSB7CgkJY29uc3Qgc3RhdGljIFRDSEFSIHNTZWNUYWJzW10gPSB7CgkJCScgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywKCQkJJyAnLCdcdCcsJyAnLAoJCQknICcsJ1x0JywnICcsJ1x0JywnICcsJ1x0JywnICcsCgkJCScgJywnXHQnLCcgJywKCQkJJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLAoJCQknXDAnCgkJfTsKCgkJRFdPUkQgcmlnaHRzID0gZ2V0X2FjY2Vzc19tYXNrKCk7CgoJCXRjc2NweShidWZmZXIsIHNTZWNUYWJzKTsKCgkJaWYgKHJpZ2h0cyAmIEZJTEVfUkVBRF9EQVRBKQkJCWJ1ZmZlclsgMF0gPSAnUic7CgkJaWYgKHJpZ2h0cyAmIEZJTEVfV1JJVEVfREFUQSkJCQlidWZmZXJbIDJdID0gJ1cnOwoJCWlmIChyaWdodHMgJiBGSUxFX0FQUEVORF9EQVRBKQkJCWJ1ZmZlclsgNF0gPSAnQSc7CgkJaWYgKHJpZ2h0cyAmIEZJTEVfUkVBRF9FQSkJCQkJe2J1ZmZlcls2XSA9ICdlbnRyeSc7IGJ1ZmZlclsgN10gPSAnUic7fQoJCWlmIChyaWdodHMgJiBGSUxFX1dSSVRFX0VBKQkJCQl7YnVmZmVyWzldID0gJ2VudHJ5JzsgYnVmZmVyWzEwXSA9ICdXJzt9CgkJaWYgKHJpZ2h0cyAmIEZJTEVfRVhFQ1VURSkJCQkJYnVmZmVyWzEyXSA9ICdYJzsKCQlpZiAocmlnaHRzICYgRklMRV9ERUxFVEVfQ0hJTEQpCQkJYnVmZmVyWzE0XSA9ICdEJzsKCQlpZiAocmlnaHRzICYgRklMRV9SRUFEX0FUVFJJQlVURVMpCQl7YnVmZmVyWzE2XSA9ICdhJzsgYnVmZmVyWzE3XSA9ICdSJzt9CgkJaWYgKHJpZ2h0cyAmIEZJTEVfV1JJVEVfQVRUUklCVVRFUykJCXtidWZmZXJbMTldID0gJ2EnOyBidWZmZXJbMjBdID0gJ1cnO30KCQlpZiAocmlnaHRzICYgV1JJVEVfREFDKQkJCQkJYnVmZmVyWzIyXSA9ICdDJzsKCQlpZiAocmlnaHRzICYgV1JJVEVfT1dORVIpCQkJCWJ1ZmZlclsyNF0gPSAnTyc7CgkJaWYgKHJpZ2h0cyAmIFNZTkNIUk9OSVpFKQkJCQlidWZmZXJbMjZdID0gJ1MnOwoKCQlvdXRwdXRfdGV4dChkaXMsIGNvbCsrLCBidWZmZXIsIERUX0xFRlQsIDMsIHBzaXplKTsKCX0KCglpZiAoZmxhZ3MuZGVzY3JpcHRpb24pIHsKCQlnZXRfZGVzY3JpcHRpb24oYnVmZmVyKTsKCQlvdXRwdXRfdGV4dChkaXMsIGNvbCsrLCBidWZmZXIsIDAsIHBzaXplKTsKCX0KKi8KCiNpZmRlZiBfTk9fRVhURU5TSU9OUwogIH0KCiAgICAgICAgLyogZHJhdyBmb2N1cyBmcmFtZSAqLwoJaWYgKChkaXMtPml0ZW1TdGF0ZSZPRFNfRk9DVVMpICYmIGNhbGNXaWR0aENvbD09LTEpIHsKCSAgICAgICAgLyogQ3VycmVudGx5IFswNC8yMDAwXSBXaW5lIG5laXRoZXIgYmVoYXZlcyBleGFjdGx5IHRoZSBzYW1lICovCgkgICAgICAgIC8qIHdheSBhcyBXSU4gOTUgbm9yIGxpa2UgV2luZG93cyBOVC4uLiAqLwoJCUhHRElPQkogbGFzdEJydXNoOwoJCUhQRU4gbGFzdFBlbjsKCQlIUEVOIGhwZW47CgoJCWlmICghKEdldFZlcnNpb24oKSAmIDB4ODAwMDAwMDApKSB7CS8qIFdpbmRvd3MgTlQ/ICovCgkJCUxPR0JSVVNIIGxiID0ge1BTX1NPTElELCBSR0IoMjU1LDI1NSwyNTUpfTsKCQkJaHBlbiA9IEV4dENyZWF0ZVBlbihQU19DT1NNRVRJQ3xQU19BTFRFUk5BVEUsIDEsICZsYiwgMCwgMCk7CgkJfSBlbHNlCgkJCWhwZW4gPSBDcmVhdGVQZW4oUFNfRE9ULCAwLCBSR0IoMjU1LDI1NSwyNTUpKTsKCgkJbGFzdFBlbiA9IFNlbGVjdFBlbihkaXMtPmhEQywgaHBlbik7CgkJbGFzdEJydXNoID0gU2VsZWN0T2JqZWN0KGRpcy0+aERDLCBHZXRTdG9ja09iamVjdChIT0xMT1dfQlJVU0gpKTsKCQlTZXRST1AyKGRpcy0+aERDLCBSMl9YT1JQRU4pOwoJCVJlY3RhbmdsZShkaXMtPmhEQywgZm9jdXNSZWN0LmxlZnQsIGZvY3VzUmVjdC50b3AsIGZvY3VzUmVjdC5yaWdodCwgZm9jdXNSZWN0LmJvdHRvbSk7CgkJU2VsZWN0T2JqZWN0KGRpcy0+aERDLCBsYXN0QnJ1c2gpOwoJCVNlbGVjdE9iamVjdChkaXMtPmhEQywgbGFzdFBlbik7CgkJRGVsZXRlT2JqZWN0KGhwZW4pOwoJfQojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KfQoKCiNpZmRlZiBfTk9fRVhURU5TSU9OUwoKc3RhdGljIHZvaWQgZHJhd19zcGxpdGJhcihIV05EIGh3bmQsIGludCB4KQp7CglSRUNUIHJ0OwoJSERDIGhkYyA9IEdldERDKGh3bmQpOwoKCUdldENsaWVudFJlY3QoaHduZCwgJnJ0KTsKCglydC5sZWZ0ID0geCAtIFNQTElUX1dJRFRILzI7CglydC5yaWdodCA9IHggKyBTUExJVF9XSURUSC8yKzE7CgoJSW52ZXJ0UmVjdChoZGMsICZydCk7CgoJUmVsZWFzZURDKGh3bmQsIGhkYyk7Cn0KCiNlbmRpZiAvKiBfTk9fRVhURU5TSU9OUyAqLwoKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCnN0YXRpYyB2b2lkIHNldF9oZWFkZXIoUGFuZSogcGFuZSkKewoJSERfSVRFTSBpdGVtOwoJaW50IHNjcm9sbF9wb3MgPSBHZXRTY3JvbGxQb3MocGFuZS0+aHduZCwgU0JfSE9SWik7CglpbnQgaT0wLCB4PTA7CgoJaXRlbS5tYXNrID0gSERJX1dJRFRIOwoJaXRlbS5jeHkgPSAwOwoKCWZvcig7IHgrcGFuZS0+d2lkdGhzW2ldPHNjcm9sbF9wb3MgJiYgaTxDT0xVTU5TOyBpKyspIHsKCQl4ICs9IHBhbmUtPndpZHRoc1tpXTsKCQlIZWFkZXJfU2V0SXRlbShwYW5lLT5od25kSGVhZGVyLCBpLCAmaXRlbSk7Cgl9CgoJaWYgKGkgPCBDT0xVTU5TKSB7CgkJeCArPSBwYW5lLT53aWR0aHNbaV07CgkJaXRlbS5jeHkgPSB4IC0gc2Nyb2xsX3BvczsKCQlIZWFkZXJfU2V0SXRlbShwYW5lLT5od25kSGVhZGVyLCBpKyssICZpdGVtKTsKCgkJZm9yKDsgaTxDT0xVTU5TOyBpKyspIHsKCQkJaXRlbS5jeHkgPSBwYW5lLT53aWR0aHNbaV07CgkJCXggKz0gcGFuZS0+d2lkdGhzW2ldOwoJCQlIZWFkZXJfU2V0SXRlbShwYW5lLT5od25kSGVhZGVyLCBpLCAmaXRlbSk7CgkJfQoJfQp9CgpzdGF0aWMgTFJFU1VMVCBwYW5lX25vdGlmeShQYW5lKiBwYW5lLCBOTUhEUiogcG5taCkKewoJc3dpdGNoKHBubWgtPmNvZGUpIHsKCQljYXNlIEhETl9UUkFDSzoKCQljYXNlIEhETl9FTkRUUkFDSzogewoJCQlIRF9OT1RJRlkqIHBoZG4gPSAoSERfTk9USUZZKikgcG5taDsKCQkJaW50IGlkeCA9IHBoZG4tPmlJdGVtOwoJCQlpbnQgZHggPSBwaGRuLT5waXRlbS0+Y3h5IC0gcGFuZS0+d2lkdGhzW2lkeF07CgkJCWludCBpOwoKCQkJUkVDVCBjbG50OwoJCQlHZXRDbGllbnRSZWN0KHBhbmUtPmh3bmQsICZjbG50KTsKCgkJCS8qIG1vdmUgaW1tZWRpYXRlIHRvIHNpbXVsYXRlIEhEU19GVUxMRFJBRyAoZm9yIG5vdyBbMDQvMjAwMF0gbm90IHJlYWxseSBuZWVkZWQgd2l0aCBXSU5FTElCKSAqLwoJCQlIZWFkZXJfU2V0SXRlbShwYW5lLT5od25kSGVhZGVyLCBpZHgsIHBoZG4tPnBpdGVtKTsKCgkJCXBhbmUtPndpZHRoc1tpZHhdICs9IGR4OwoKCQkJZm9yKGk9aWR4OyArK2k8PUNPTFVNTlM7ICkKCQkJCXBhbmUtPnBvc2l0aW9uc1tpXSArPSBkeDsKCgkJCXsKCQkJCWludCBzY3JvbGxfcG9zID0gR2V0U2Nyb2xsUG9zKHBhbmUtPmh3bmQsIFNCX0hPUlopOwoJCQkJUkVDVCBydF9zY3I7CgkJCQlSRUNUIHJ0X2NsaXA7CgoJCQkJcnRfc2NyLmxlZnQgICA9IHBhbmUtPnBvc2l0aW9uc1tpZHgrMV0tc2Nyb2xsX3BvczsKCQkJCXJ0X3Njci50b3AgICAgPSAwOwoJCQkJcnRfc2NyLnJpZ2h0ICA9IGNsbnQucmlnaHQ7CgkJCQlydF9zY3IuYm90dG9tID0gY2xudC5ib3R0b207CgoJCQkJcnRfY2xpcC5sZWZ0ICAgPSBwYW5lLT5wb3NpdGlvbnNbaWR4XS1zY3JvbGxfcG9zOwoJCQkJcnRfY2xpcC50b3AgICAgPSAwOwoJCQkJcnRfY2xpcC5yaWdodCAgPSBjbG50LnJpZ2h0OwoJCQkJcnRfY2xpcC5ib3R0b20gPSBjbG50LmJvdHRvbTsKCgkJCQlpZiAocnRfc2NyLmxlZnQgPCAwKSBydF9zY3IubGVmdCA9IDA7CgkJCQlpZiAocnRfY2xpcC5sZWZ0IDwgMCkgcnRfY2xpcC5sZWZ0ID0gMDsKCgkJCQlTY3JvbGxXaW5kb3dFeChwYW5lLT5od25kLCBkeCwgMCwgJnJ0X3NjciwgJnJ0X2NsaXAsIDAsIDAsIFNXX0lOVkFMSURBVEUpOwoKCQkJCXJ0X2NsaXAucmlnaHQgPSBwYW5lLT5wb3NpdGlvbnNbaWR4KzFdOwoJCQkJUmVkcmF3V2luZG93KHBhbmUtPmh3bmQsICZydF9jbGlwLCAwLCBSRFdfSU5WQUxJREFURXxSRFdfVVBEQVRFTk9XKTsKCgkJCQlpZiAocG5taC0+Y29kZSA9PSBIRE5fRU5EVFJBQ0spIHsKCQkJCQlMaXN0Qm94X1NldEhvcml6b250YWxFeHRlbnQocGFuZS0+aHduZCwgcGFuZS0+cG9zaXRpb25zW0NPTFVNTlNdKTsKCgkJCQkJaWYgKEdldFNjcm9sbFBvcyhwYW5lLT5od25kLCBTQl9IT1JaKSAhPSBzY3JvbGxfcG9zKQoJCQkJCQlzZXRfaGVhZGVyKHBhbmUpOwoJCQkJfQoJCQl9CgoJCQlyZXR1cm4gRkFMU0U7CgkJfQoKCQljYXNlIEhETl9ESVZJREVSREJMQ0xJQ0s6IHsKCQkJSERfTk9USUZZKiBwaGRuID0gKEhEX05PVElGWSopIHBubWg7CgkJCUhEX0lURU0gaXRlbTsKCgkJCWNhbGNfc2luZ2xlX3dpZHRoKHBhbmUsIHBoZG4tPmlJdGVtKTsKCQkJaXRlbS5tYXNrID0gSERJX1dJRFRIOwoJCQlpdGVtLmN4eSA9IHBhbmUtPndpZHRoc1twaGRuLT5pSXRlbV07CgoJCQlIZWFkZXJfU2V0SXRlbShwYW5lLT5od25kSGVhZGVyLCBwaGRuLT5pSXRlbSwgJml0ZW0pOwoJCQlJbnZhbGlkYXRlUmVjdChwYW5lLT5od25kLCAwLCBUUlVFKTsKCQkJYnJlYWs7fQoJfQoKCXJldHVybiAwOwp9CgojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCgpzdGF0aWMgdm9pZCBzY2FuX2VudHJ5KENoaWxkV25kKiBjaGlsZCwgRW50cnkqIGVudHJ5LCBpbnQgaWR4LCBIV05EIGh3bmQpCnsKCVRDSEFSIHBhdGhbTUFYX1BBVEhdOwoJSENVUlNPUiBvbGRfY3Vyc29yID0gU2V0Q3Vyc29yKExvYWRDdXJzb3IoMCwgSURDX1dBSVQpKTsKCgkvKiBkZWxldGUgc3ViIGVudHJpZXMgaW4gbGVmdCBwYW5lICovCglmb3IoOzspIHsKCQlMUkVTVUxUIHJlcyA9IExpc3RCb3hfR2V0SXRlbURhdGEoY2hpbGQtPmxlZnQuaHduZCwgaWR4KzEpOwoJCUVudHJ5KiBzdWIgPSAoRW50cnkqKSByZXM7CgoJCWlmIChyZXM9PUxCX0VSUiB8fCAhc3ViIHx8IHN1Yi0+bGV2ZWw8PWVudHJ5LT5sZXZlbCkKCQkJYnJlYWs7CgoJCUxpc3RCb3hfRGVsZXRlU3RyaW5nKGNoaWxkLT5sZWZ0Lmh3bmQsIGlkeCsxKTsKCX0KCgkvKiBlbXB0eSByaWdodCBwYW5lICovCglMaXN0Qm94X1Jlc2V0Q29udGVudChjaGlsZC0+cmlnaHQuaHduZCk7CgoJLyogcmVsZWFzZSBtZW1vcnkgKi8KCWZyZWVfZW50cmllcyhlbnRyeSk7CgoJLyogcmVhZCBjb250ZW50cyBmcm9tIGRpc2sgKi8KI2lmZGVmIF9TSEVMTF9GT0xERVJTCglpZiAoZW50cnktPmV0eXBlID09IEVUX1NIRUxMKQoJewoJCXJlYWRfZGlyZWN0b3J5KGVudHJ5LCBOVUxMLCBjaGlsZC0+c29ydE9yZGVyLCBod25kKTsKCX0KCWVsc2UKI2VuZGlmCgl7CgkJZ2V0X3BhdGgoZW50cnksIHBhdGgpOwoJCXJlYWRfZGlyZWN0b3J5KGVudHJ5LCBwYXRoLCBjaGlsZC0+c29ydE9yZGVyLCBod25kKTsKCX0KCgkvKiBpbnNlcnQgZm91bmQgZW50cmllcyBpbiByaWdodCBwYW5lICovCglpbnNlcnRfZW50cmllcygmY2hpbGQtPnJpZ2h0LCBlbnRyeS0+ZG93biwgLTEpOwoJY2FsY193aWR0aHMoJmNoaWxkLT5yaWdodCwgRkFMU0UpOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCglzZXRfaGVhZGVyKCZjaGlsZC0+cmlnaHQpOwojZW5kaWYKCgljaGlsZC0+aGVhZGVyX3dkdGhzX29rID0gRkFMU0U7CgoJU2V0Q3Vyc29yKG9sZF9jdXJzb3IpOwp9CgoKLyogZXhwYW5kIGEgZGlyZWN0b3J5IGVudHJ5ICovCgpzdGF0aWMgQk9PTCBleHBhbmRfZW50cnkoQ2hpbGRXbmQqIGNoaWxkLCBFbnRyeSogZGlyKQp7CglpbnQgaWR4OwoJRW50cnkqIHA7CgoJaWYgKCFkaXIgfHwgZGlyLT5leHBhbmRlZCB8fCAhZGlyLT5kb3duKQoJCXJldHVybiBGQUxTRTsKCglwID0gZGlyLT5kb3duOwoKCWlmIChwLT5kYXRhLmNGaWxlTmFtZVswXT09Jy4nICYmIHAtPmRhdGEuY0ZpbGVOYW1lWzFdPT0nXDAnICYmIHAtPm5leHQpIHsKCQlwID0gcC0+bmV4dDsKCgkJaWYgKHAtPmRhdGEuY0ZpbGVOYW1lWzBdPT0nLicgJiYgcC0+ZGF0YS5jRmlsZU5hbWVbMV09PScuJyAmJgoJCQkJcC0+ZGF0YS5jRmlsZU5hbWVbMl09PSdcMCcgJiYgcC0+bmV4dCkKCQkJcCA9IHAtPm5leHQ7Cgl9CgoJLyogbm8gc3ViZGlyZWN0b3JpZXMgPyAqLwoJaWYgKCEocC0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzJkZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkpCgkJcmV0dXJuIEZBTFNFOwoKCWlkeCA9IExpc3RCb3hfRmluZEl0ZW1EYXRhKGNoaWxkLT5sZWZ0Lmh3bmQsIDAsIGRpcik7CgoJZGlyLT5leHBhbmRlZCA9IFRSVUU7CgoJLyogaW5zZXJ0IGVudHJpZXMgaW4gbGVmdCBwYW5lICovCglpbnNlcnRfZW50cmllcygmY2hpbGQtPmxlZnQsIHAsIGlkeCk7CgoJaWYgKCFjaGlsZC0+aGVhZGVyX3dkdGhzX29rKSB7CgkJaWYgKGNhbGNfd2lkdGhzKCZjaGlsZC0+bGVmdCwgRkFMU0UpKSB7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQkJc2V0X2hlYWRlcigmY2hpbGQtPmxlZnQpOwojZW5kaWYKCgkJCWNoaWxkLT5oZWFkZXJfd2R0aHNfb2sgPSBUUlVFOwoJCX0KCX0KCglyZXR1cm4gVFJVRTsKfQoKCnN0YXRpYyB2b2lkIGNvbGxhcHNlX2VudHJ5KFBhbmUqIHBhbmUsIEVudHJ5KiBkaXIpCnsKCWludCBpZHggPSBMaXN0Qm94X0ZpbmRJdGVtRGF0YShwYW5lLT5od25kLCAwLCBkaXIpOwoKCVNob3dXaW5kb3cocGFuZS0+aHduZCwgU1dfSElERSk7CgoJLyogaGlkZSBzdWIgZW50cmllcyAqLwoJZm9yKDs7KSB7CgkJTFJFU1VMVCByZXMgPSBMaXN0Qm94X0dldEl0ZW1EYXRhKHBhbmUtPmh3bmQsIGlkeCsxKTsKCQlFbnRyeSogc3ViID0gKEVudHJ5KikgcmVzOwoKCQlpZiAocmVzPT1MQl9FUlIgfHwgIXN1YiB8fCBzdWItPmxldmVsPD1kaXItPmxldmVsKQoJCQlicmVhazsKCgkJTGlzdEJveF9EZWxldGVTdHJpbmcocGFuZS0+aHduZCwgaWR4KzEpOwoJfQoKCWRpci0+ZXhwYW5kZWQgPSBGQUxTRTsKCglTaG93V2luZG93KHBhbmUtPmh3bmQsIFNXX1NIT1cpOwp9CgoKc3RhdGljIHZvaWQgc2V0X2N1cmRpcihDaGlsZFduZCogY2hpbGQsIEVudHJ5KiBlbnRyeSwgaW50IGlkeCwgSFdORCBod25kKQp7CglUQ0hBUiBwYXRoW01BWF9QQVRIXTsKCglwYXRoWzBdID0gJ1wwJzsKCgljaGlsZC0+bGVmdC5jdXIgPSBlbnRyeTsKCWNoaWxkLT5yaWdodC5yb290ID0gZW50cnktPmRvd24/IGVudHJ5LT5kb3duOiBlbnRyeTsKCWNoaWxkLT5yaWdodC5jdXIgPSBlbnRyeTsKCglpZiAoIWVudHJ5LT5zY2FubmVkKQoJCXNjYW5fZW50cnkoY2hpbGQsIGVudHJ5LCBpZHgsIGh3bmQpOwoJZWxzZSB7CgkJTGlzdEJveF9SZXNldENvbnRlbnQoY2hpbGQtPnJpZ2h0Lmh3bmQpOwoJCWluc2VydF9lbnRyaWVzKCZjaGlsZC0+cmlnaHQsIGVudHJ5LT5kb3duLCAtMSk7CgkJY2FsY193aWR0aHMoJmNoaWxkLT5yaWdodCwgRkFMU0UpOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJc2V0X2hlYWRlcigmY2hpbGQtPnJpZ2h0KTsKI2VuZGlmCgl9CgoJZ2V0X3BhdGgoZW50cnksIHBhdGgpOwoJbHN0cmNweShjaGlsZC0+cGF0aCwgcGF0aCk7CgoJaWYgKGNoaWxkLT5od25kKQkvKiBvbmx5IGNoYW5nZSB3aW5kb3cgdGl0bGUsIGlmIHRoZSB3aW5kb3cgYWxyZWFkeSBleGlzdHMgKi8KCQlTZXRXaW5kb3dUZXh0KGNoaWxkLT5od25kLCBwYXRoKTsKCglpZiAocGF0aFswXSkKCQlpZiAoU2V0Q3VycmVudERpcmVjdG9yeShwYXRoKSkKCQkJc2V0X3NwYWNlX3N0YXR1cygpOwp9CgoKc3RhdGljIHZvaWQgcmVmcmVzaF9jaGlsZChDaGlsZFduZCogY2hpbGQpCnsKCVRDSEFSIHBhdGhbTUFYX1BBVEhdLCBkcnZbX01BWF9EUklWRSsxXTsKCUVudHJ5KiBlbnRyeTsKCWludCBpZHg7CgoJZ2V0X3BhdGgoY2hpbGQtPmxlZnQuY3VyLCBwYXRoKTsKCV90c3BsaXRwYXRoKHBhdGgsIGRydiwgTlVMTCwgTlVMTCwgTlVMTCk7CgoJY2hpbGQtPnJpZ2h0LnJvb3QgPSBOVUxMOwoKCXNjYW5fZW50cnkoY2hpbGQsICZjaGlsZC0+cm9vdC5lbnRyeSwgMCwgY2hpbGQtPmh3bmQpOwoKCWVudHJ5ID0gcmVhZF90cmVlKCZjaGlsZC0+cm9vdCwgcGF0aCwgTlVMTCwgZHJ2LCBjaGlsZC0+c29ydE9yZGVyLCBjaGlsZC0+aHduZCk7CgoJaW5zZXJ0X2VudHJpZXMoJmNoaWxkLT5sZWZ0LCBjaGlsZC0+cm9vdC5lbnRyeS5kb3duLCAwKTsKCglzZXRfY3VyZGlyKGNoaWxkLCBlbnRyeSwgMCwgY2hpbGQtPmh3bmQpOwoKCWlkeCA9IExpc3RCb3hfRmluZEl0ZW1EYXRhKGNoaWxkLT5sZWZ0Lmh3bmQsIDAsIGNoaWxkLT5sZWZ0LmN1cik7CglMaXN0Qm94X1NldEN1clNlbChjaGlsZC0+bGVmdC5od25kLCBpZHgpOwp9CgoKc3RhdGljIHZvaWQgY3JlYXRlX2RyaXZlX2JhcigpCnsKCVRCQlVUVE9OIGRyaXZlYmFyQnRuID0gezAsIDAsIFRCU1RBVEVfRU5BQkxFRCwgQlROU19CVVRUT04sIHswLCAwfSwgMCwgMH07CglUQ0hBUiBiMVtCVUZGRVJfTEVOXTsKCWludCBidG4gPSAxOwoJUFRTVFIgcDsKCglHZXRMb2dpY2FsRHJpdmVTdHJpbmdzKEJVRkZFUl9MRU4sIEdsb2JhbHMuZHJpdmVzKTsKCglHbG9iYWxzLmhkcml2ZWJhciA9IENyZWF0ZVRvb2xiYXJFeChHbG9iYWxzLmhNYWluV25kLCBXU19DSElMRHxXU19WSVNJQkxFfENDU19OT01PVkVZfFRCU1RZTEVfTElTVCwKCQkJCUlEV19EUklWRUJBUiwgMiwgR2xvYmFscy5oSW5zdGFuY2UsIElEQl9EUklWRUJBUiwgJmRyaXZlYmFyQnRuLAoJCQkJMSwgMTYsIDEzLCAxNiwgMTMsIHNpemVvZihUQkJVVFRPTikpOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwojaWZkZWYgX19XSU5FX18KCS8qIGluc2VydCB1bml4IGZpbGUgc3lzdGVtIGJ1dHRvbiAqLwoJYjFbMF0gPSAnLyc7CgliMVsxXSA9ICdcMCc7CgliMVsyXSA9ICdcMCc7CglTZW5kTWVzc2FnZShHbG9iYWxzLmhkcml2ZWJhciwgVEJfQUREU1RSSU5HLCAwLCAoTFBBUkFNKWIxKTsKCglkcml2ZWJhckJ0bi5pZENvbW1hbmQgPSBJRF9EUklWRV9VTklYX0ZTOwoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0lOU0VSVEJVVFRPTiwgYnRuKyssIChMUEFSQU0pJmRyaXZlYmFyQnRuKTsKCWRyaXZlYmFyQnRuLmlTdHJpbmcrKzsKI2VuZGlmCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJLyogaW5zZXJ0IHNoZWxsIG5hbWVzcGFjZSBidXR0b24gKi8KCWxvYWRfc3RyaW5nKGIxLCBJRFNfU0hFTEwpOwoJYjFbbHN0cmxlbihiMSkrMV0gPSAnXDAnOwoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0FERFNUUklORywgMCwgKExQQVJBTSliMSk7CgoJZHJpdmViYXJCdG4uaWRDb21tYW5kID0gSURfRFJJVkVfU0hFTExfTlM7CglTZW5kTWVzc2FnZShHbG9iYWxzLmhkcml2ZWJhciwgVEJfSU5TRVJUQlVUVE9OLCBidG4rKywgKExQQVJBTSkmZHJpdmViYXJCdG4pOwoJZHJpdmViYXJCdG4uaVN0cmluZysrOwojZW5kaWYKCgkvKiByZWdpc3RlciB3aW5kb3dzIGRyaXZlIHJvb3Qgc3RyaW5ncyAqLwoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0FERFNUUklORywgMCwgKExQQVJBTSlHbG9iYWxzLmRyaXZlcyk7CiNlbmRpZgoKCWRyaXZlYmFyQnRuLmlkQ29tbWFuZCA9IElEX0RSSVZFX0ZJUlNUOwoKCWZvcihwPUdsb2JhbHMuZHJpdmVzOyAqcDsgKSB7CiNpZmRlZiBfTk9fRVhURU5TSU9OUwoJCS8qIGluc2VydCBkcml2ZSBsZXR0ZXIgKi8KCQlUQ0hBUiBiWzNdID0ge3RvbG93ZXIoKnApfTsKCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhkcml2ZWJhciwgVEJfQUREU1RSSU5HLCAwLCAoTFBBUkFNKWIpOwojZW5kaWYKCQlzd2l0Y2goR2V0RHJpdmVUeXBlKHApKSB7CgkJCWNhc2UgRFJJVkVfUkVNT1ZBQkxFOglkcml2ZWJhckJ0bi5pQml0bWFwID0gMTsJYnJlYWs7CgkJCWNhc2UgRFJJVkVfQ0RST006CQlkcml2ZWJhckJ0bi5pQml0bWFwID0gMzsJYnJlYWs7CgkJCWNhc2UgRFJJVkVfUkVNT1RFOgkJZHJpdmViYXJCdG4uaUJpdG1hcCA9IDQ7CWJyZWFrOwoJCQljYXNlIERSSVZFX1JBTURJU0s6CQlkcml2ZWJhckJ0bi5pQml0bWFwID0gNTsJYnJlYWs7CgkJCWRlZmF1bHQ6LypEUklWRV9GSVhFRCovCWRyaXZlYmFyQnRuLmlCaXRtYXAgPSAyOwoJCX0KCgkJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0lOU0VSVEJVVFRPTiwgYnRuKyssIChMUEFSQU0pJmRyaXZlYmFyQnRuKTsKCQlkcml2ZWJhckJ0bi5pZENvbW1hbmQrKzsKCQlkcml2ZWJhckJ0bi5pU3RyaW5nKys7CgoJCXdoaWxlKCpwKyspOwoJfQp9CgpzdGF0aWMgdm9pZCByZWZyZXNoX2RyaXZlcygpCnsKCVJFQ1QgcmVjdDsKCgkvKiBkZXN0cm95IGRyaXZlIGJhciAqLwoJRGVzdHJveVdpbmRvdyhHbG9iYWxzLmhkcml2ZWJhcik7CglHbG9iYWxzLmhkcml2ZWJhciA9IDA7CgoJLyogcmUtY3JlYXRlIGRyaXZlIGJhciAqLwoJY3JlYXRlX2RyaXZlX2JhcigpOwoKCS8qIHVwZGF0ZSB3aW5kb3cgbGF5b3V0ICovCglHZXRDbGllbnRSZWN0KEdsb2JhbHMuaE1haW5XbmQsICZyZWN0KTsKCVNlbmRNZXNzYWdlKEdsb2JhbHMuaE1haW5XbmQsIFdNX1NJWkUsIDAsIE1BS0VMT05HKHJlY3QucmlnaHQsIHJlY3QuYm90dG9tKSk7Cn0KCgpCT09MIGxhdW5jaF9maWxlKEhXTkQgaHduZCwgTFBDVFNUUiBjbWQsIFVJTlQgbkNtZFNob3cpCnsKCUhJTlNUQU5DRSBoaW5zdCA9IFNoZWxsRXhlY3V0ZShod25kLCBOVUxMLypvcGVyYXRpb24qLywgY21kLCBOVUxMLypwYXJhbWV0ZXJzKi8sIE5VTEwvKmRpciovLCBuQ21kU2hvdyk7CgoJaWYgKChpbnQpaGluc3QgPD0gMzIpIHsKCQlkaXNwbGF5X2Vycm9yKGh3bmQsIEdldExhc3RFcnJvcigpKTsKCQlyZXR1cm4gRkFMU0U7Cgl9CgoJcmV0dXJuIFRSVUU7Cn0KCiNpZmRlZiBVTklDT0RFCkJPT0wgbGF1bmNoX2ZpbGVBKEhXTkQgaHduZCwgTFBTVFIgY21kLCBVSU5UIG5DbWRTaG93KQp7CglISU5TVEFOQ0UgaGluc3QgPSBTaGVsbEV4ZWN1dGVBKGh3bmQsIE5VTEwvKm9wZXJhdGlvbiovLCBjbWQsIE5VTEwvKnBhcmFtZXRlcnMqLywgTlVMTC8qZGlyKi8sIG5DbWRTaG93KTsKCglpZiAoKGludCloaW5zdCA8PSAzMikgewoJCWRpc3BsYXlfZXJyb3IoaHduZCwgR2V0TGFzdEVycm9yKCkpOwoJCXJldHVybiBGQUxTRTsKCX0KCglyZXR1cm4gVFJVRTsKfQojZW5kaWYKCgpCT09MIGxhdW5jaF9lbnRyeShFbnRyeSogZW50cnksIEhXTkQgaHduZCwgVUlOVCBuQ21kU2hvdykKewoJVENIQVIgY21kW01BWF9QQVRIXTsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKGVudHJ5LT5ldHlwZSA9PSBFVF9TSEVMTCkgewoJCUJPT0wgcmV0ID0gVFJVRTsKCgkJU0hFTExFWEVDVVRFSU5GTyBzaGV4aW5mbzsKCgkJc2hleGluZm8uY2JTaXplID0gc2l6ZW9mKFNIRUxMRVhFQ1VURUlORk8pOwoJCXNoZXhpbmZvLmZNYXNrID0gU0VFX01BU0tfSURMSVNUOwoJCXNoZXhpbmZvLmh3bmQgPSBod25kOwoJCXNoZXhpbmZvLmxwVmVyYiA9IE5VTEw7CgkJc2hleGluZm8ubHBGaWxlID0gTlVMTDsKCQlzaGV4aW5mby5scFBhcmFtZXRlcnMgPSBOVUxMOwoJCXNoZXhpbmZvLmxwRGlyZWN0b3J5ID0gTlVMTDsKCQlzaGV4aW5mby5uU2hvdyA9IG5DbWRTaG93OwoJCXNoZXhpbmZvLmxwSURMaXN0ID0gZ2V0X3RvX2Fic29sdXRlX3BpZGwoZW50cnksIGh3bmQpOwoKCQlpZiAoIVNoZWxsRXhlY3V0ZUV4KCZzaGV4aW5mbykpIHsKCQkJZGlzcGxheV9lcnJvcihod25kLCBHZXRMYXN0RXJyb3IoKSk7CgkJCXJldCA9IEZBTFNFOwoJCX0KCgkJaWYgKHNoZXhpbmZvLmxwSURMaXN0ICE9IGVudHJ5LT5waWRsKQoJCQkoKkdsb2JhbHMuaU1hbGxvYy0+bHBWdGJsLT5GcmVlKShHbG9iYWxzLmlNYWxsb2MsIHNoZXhpbmZvLmxwSURMaXN0KTsKCgkJcmV0dXJuIHJldDsKCX0KI2VuZGlmCgoJZ2V0X3BhdGgoZW50cnksIGNtZCk7CgoJIC8qIHN0YXJ0IHByb2dyYW0sIG9wZW4gZG9jdW1lbnQuLi4gKi8KCXJldHVybiBsYXVuY2hfZmlsZShod25kLCBjbWQsIG5DbWRTaG93KTsKfQoKCnN0YXRpYyB2b2lkIGFjdGl2YXRlX2VudHJ5KENoaWxkV25kKiBjaGlsZCwgUGFuZSogcGFuZSwgSFdORCBod25kKQp7CglFbnRyeSogZW50cnkgPSBwYW5lLT5jdXI7CgoJaWYgKCFlbnRyeSkKCQlyZXR1cm47CgoJaWYgKGVudHJ5LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpIHsKCQlpbnQgc2Nhbm5lZF9vbGQgPSBlbnRyeS0+c2Nhbm5lZDsKCgkJaWYgKCFzY2FubmVkX29sZCkKCQkJc2Nhbl9lbnRyeShjaGlsZCwgZW50cnksIExpc3RCb3hfR2V0Q3VyU2VsKGNoaWxkLT5sZWZ0Lmh3bmQpLCBod25kKTsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQlpZiAoZW50cnktPmRhdGEuY0ZpbGVOYW1lWzBdPT0nLicgJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzFdPT0nXDAnKQoJCQlyZXR1cm47CiNlbmRpZgoKCQlpZiAoZW50cnktPmRhdGEuY0ZpbGVOYW1lWzBdPT0nLicgJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzFdPT0nLicgJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzJdPT0nXDAnKSB7CgkJCWVudHJ5ID0gY2hpbGQtPmxlZnQuY3VyLT51cDsKCQkJY29sbGFwc2VfZW50cnkoJmNoaWxkLT5sZWZ0LCBlbnRyeSk7CgkJCWdvdG8gZm9jdXNfZW50cnk7CgkJfSBlbHNlIGlmIChlbnRyeS0+ZXhwYW5kZWQpCgkJCWNvbGxhcHNlX2VudHJ5KHBhbmUsIGNoaWxkLT5sZWZ0LmN1cik7CgkJZWxzZSB7CgkJCWV4cGFuZF9lbnRyeShjaGlsZCwgY2hpbGQtPmxlZnQuY3VyKTsKCgkJCWlmICghcGFuZS0+dHJlZVBhbmUpIGZvY3VzX2VudHJ5OiB7CgkJCQlpbnQgaWR4ID0gTGlzdEJveF9GaW5kSXRlbURhdGEoY2hpbGQtPmxlZnQuaHduZCwgTGlzdEJveF9HZXRDdXJTZWwoY2hpbGQtPmxlZnQuaHduZCksIGVudHJ5KTsKCQkJCUxpc3RCb3hfU2V0Q3VyU2VsKGNoaWxkLT5sZWZ0Lmh3bmQsIGlkeCk7CgkJCQlzZXRfY3VyZGlyKGNoaWxkLCBlbnRyeSwgaWR4LCBod25kKTsKCQkJfQoJCX0KCgkJaWYgKCFzY2FubmVkX29sZCkgewoJCQljYWxjX3dpZHRocyhwYW5lLCBGQUxTRSk7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCXNldF9oZWFkZXIocGFuZSk7CiNlbmRpZgoJCX0KCX0gZWxzZSB7CgkJbGF1bmNoX2VudHJ5KGVudHJ5LCBjaGlsZC0+aHduZCwgU1dfU0hPV05PUk1BTCk7Cgl9Cn0KCgpzdGF0aWMgQk9PTCBwYW5lX2NvbW1hbmQoUGFuZSogcGFuZSwgVUlOVCBjbWQpCnsKCXN3aXRjaChjbWQpIHsKCQljYXNlIElEX1ZJRVdfTkFNRToKCQkJaWYgKHBhbmUtPnZpc2libGVfY29scykgewoJCQkJcGFuZS0+dmlzaWJsZV9jb2xzID0gMDsKCQkJCWNhbGNfd2lkdGhzKHBhbmUsIFRSVUUpOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQlzZXRfaGVhZGVyKHBhbmUpOwojZW5kaWYKCQkJCUludmFsaWRhdGVSZWN0KHBhbmUtPmh3bmQsIDAsIFRSVUUpOwoJCQkJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19OQU1FLCBNRl9CWUNPTU1BTkR8TUZfQ0hFQ0tFRCk7CgkJCQlDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVWaWV3LCBJRF9WSUVXX0FMTF9BVFRSSUJVVEVTLCBNRl9CWUNPTU1BTkQpOwoJCQkJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19TRUxFQ1RFRF9BVFRSSUJVVEVTLCBNRl9CWUNPTU1BTkQpOwoJCQl9CgkJCWJyZWFrOwoKCQljYXNlIElEX1ZJRVdfQUxMX0FUVFJJQlVURVM6CgkJCWlmIChwYW5lLT52aXNpYmxlX2NvbHMgIT0gQ09MX0FMTCkgewoJCQkJcGFuZS0+dmlzaWJsZV9jb2xzID0gQ09MX0FMTDsKCQkJCWNhbGNfd2lkdGhzKHBhbmUsIFRSVUUpOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQlzZXRfaGVhZGVyKHBhbmUpOwojZW5kaWYKCQkJCUludmFsaWRhdGVSZWN0KHBhbmUtPmh3bmQsIDAsIFRSVUUpOwoJCQkJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19OQU1FLCBNRl9CWUNPTU1BTkQpOwoJCQkJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19BTExfQVRUUklCVVRFUywgTUZfQllDT01NQU5EfE1GX0NIRUNLRUQpOwoJCQkJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19TRUxFQ1RFRF9BVFRSSUJVVEVTLCBNRl9CWUNPTU1BTkQpOwoJCQl9CgkJCWJyZWFrOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgSURfUFJFRkVSUkVEX1NJWkVTOiB7CgkJCWNhbGNfd2lkdGhzKHBhbmUsIFRSVUUpOwoJCQlzZXRfaGVhZGVyKHBhbmUpOwoJCQlJbnZhbGlkYXRlUmVjdChwYW5lLT5od25kLCAwLCBUUlVFKTsKCQkJYnJlYWs7fQojZW5kaWYKCgkJICAgICAgICAvKiBUT0RPOiBtb3JlIGNvbW1hbmQgaWRzLi4uICovCgoJCWRlZmF1bHQ6CgkJCXJldHVybiBGQUxTRTsKCX0KCglyZXR1cm4gVFJVRTsKfQoKCnN0YXRpYyB2b2lkIHNldF9zb3J0X29yZGVyKENoaWxkV25kKiBjaGlsZCwgU09SVF9PUkRFUiBzb3J0T3JkZXIpCnsKCWlmIChjaGlsZC0+c29ydE9yZGVyICE9IHNvcnRPcmRlcikgewoJCWNoaWxkLT5zb3J0T3JkZXIgPSBzb3J0T3JkZXI7CgkJcmVmcmVzaF9jaGlsZChjaGlsZCk7Cgl9Cn0KCnN0YXRpYyB2b2lkIHVwZGF0ZV92aWV3X21lbnUoQ2hpbGRXbmQqIGNoaWxkKQp7CglDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVWaWV3LCBJRF9WSUVXX1NPUlRfTkFNRSwgY2hpbGQtPnNvcnRPcmRlcj09U09SVF9OQU1FPyBNRl9DSEVDS0VEOiBNRl9VTkNIRUNLRUQpOwoJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19TT1JUX1RZUEUsIGNoaWxkLT5zb3J0T3JkZXI9PVNPUlRfRVhUPyBNRl9DSEVDS0VEOiBNRl9VTkNIRUNLRUQpOwoJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19TT1JUX1NJWkUsIGNoaWxkLT5zb3J0T3JkZXI9PVNPUlRfU0laRT8gTUZfQ0hFQ0tFRDogTUZfVU5DSEVDS0VEKTsKCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfU09SVF9EQVRFLCBjaGlsZC0+c29ydE9yZGVyPT1TT1JUX0RBVEU/IE1GX0NIRUNLRUQ6IE1GX1VOQ0hFQ0tFRCk7Cn0KCgpzdGF0aWMgSUNvbnRleHRNZW51Miogc19wY3R4bWVudTIgPSBOVUxMOwpzdGF0aWMgSUNvbnRleHRNZW51Myogc19wY3R4bWVudTMgPSBOVUxMOwoKc3RhdGljIHZvaWQgQ3R4TWVudV9yZXNldCgpCnsKCXNfcGN0eG1lbnUyID0gTlVMTDsKCXNfcGN0eG1lbnUzID0gTlVMTDsKfQoKSUNvbnRleHRNZW51KiBDdHhNZW51X3F1ZXJ5X2ludGVyZmFjZXMoSUNvbnRleHRNZW51KiBwY20xKQp7CglJQ29udGV4dE1lbnUqIHBjbSA9IE5VTEw7CgoJQ3R4TWVudV9yZXNldCgpOwoKCWlmICgoKnBjbTEtPmxwVnRibC0+UXVlcnlJbnRlcmZhY2UpKHBjbTEsICZJSURfSUNvbnRleHRNZW51MywgKHZvaWQqKikmcGNtKSA9PSBOT0VSUk9SKQoJCXNfcGN0eG1lbnUzID0gKExQQ09OVEVYVE1FTlUzKXBjbTsKCWVsc2UgaWYgKCgqcGNtMS0+bHBWdGJsLT5RdWVyeUludGVyZmFjZSkocGNtMSwgJklJRF9JQ29udGV4dE1lbnUyLCAodm9pZCoqKSZwY20pID09IE5PRVJST1IpCgkJc19wY3R4bWVudTIgPSAoTFBDT05URVhUTUVOVTIpcGNtOwoKCWlmIChwY20pIHsKCQkoKnBjbTEtPmxwVnRibC0+UmVsZWFzZSkocGNtMSk7CgkJcmV0dXJuIHBjbTsKCX0gZWxzZQoJCXJldHVybiBwY20xOwp9CgpzdGF0aWMgQk9PTCBDdHhNZW51X0hhbmRsZU1lbnVNc2coVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKQp7CglpZiAoc19wY3R4bWVudTMpIHsKCQlpZiAoU1VDQ0VFREVEKCgqc19wY3R4bWVudTMtPmxwVnRibC0+SGFuZGxlTWVudU1zZykoc19wY3R4bWVudTMsIG5tc2csIHdwYXJhbSwgbHBhcmFtKSkpCgkJCXJldHVybiBUUlVFOwoJfQoKCWlmIChzX3BjdHhtZW51MikKCQlpZiAoU1VDQ0VFREVEKCgqc19wY3R4bWVudTItPmxwVnRibC0+SGFuZGxlTWVudU1zZykoc19wY3R4bWVudTIsIG5tc2csIHdwYXJhbSwgbHBhcmFtKSkpCgkJCXJldHVybiBUUlVFOwoKCXJldHVybiBGQUxTRTsKfQoKCnN0YXRpYyBIUkVTVUxUIFNoZWxsRm9sZGVyQ29udGV4dE1lbnUoSVNoZWxsRm9sZGVyKiBzaGVsbF9mb2xkZXIsIEhXTkQgaHduZFBhcmVudCwgaW50IGNpZGwsIExQQ0lURU1JRExJU1QqIGFwaWRsLCBpbnQgeCwgaW50IHkpCnsKCUlDb250ZXh0TWVudSogcGNtOwoKCUhSRVNVTFQgaHIgPSAoKnNoZWxsX2ZvbGRlci0+bHBWdGJsLT5HZXRVSU9iamVjdE9mKShzaGVsbF9mb2xkZXIsIGh3bmRQYXJlbnQsIGNpZGwsIGFwaWRsLCAmSUlEX0lDb250ZXh0TWVudSwgTlVMTCwgKExQVk9JRCopJnBjbSk7Ci8qCUhSRVNVTFQgaHIgPSBDRGVmRm9sZGVyTWVudV9DcmVhdGUyKGRpcj9kaXItPl9waWRsOkRlc2t0b3BGb2xkZXIoKSwgaHduZFBhcmVudCwgMSwgJnBpZGwsIHNoZWxsX2ZvbGRlciwgTlVMTCwgMCwgTlVMTCwgJnBjbSk7ICovCgoJaWYgKFNVQ0NFRURFRChocikpIHsKCQlITUVOVSBobWVudSA9IENyZWF0ZVBvcHVwTWVudSgpOwoKCQlwY20gPSBDdHhNZW51X3F1ZXJ5X2ludGVyZmFjZXMocGNtKTsKCgkJaWYgKGhtZW51KSB7CgkJCWhyID0gKCpwY20tPmxwVnRibC0+UXVlcnlDb250ZXh0TWVudSkocGNtLCBobWVudSwgMCwgRkNJRE1fU0hWSUVXRklSU1QsIEZDSURNX1NIVklFV0xBU1QsIENNRl9OT1JNQUwpOwoKCQkJaWYgKFNVQ0NFRURFRChocikpIHsKCQkJCVVJTlQgaWRDbWQgPSBUcmFja1BvcHVwTWVudShobWVudSwgVFBNX0xFRlRBTElHTnxUUE1fUkVUVVJOQ01EfFRQTV9SSUdIVEJVVFRPTiwgeCwgeSwgMCwgaHduZFBhcmVudCwgTlVMTCk7CgoJCQkJQ3R4TWVudV9yZXNldCgpOwoKCQkJCWlmIChpZENtZCkgewoJCQkJICBDTUlOVk9LRUNPTU1BTkRJTkZPIGNtaTsKCgkJCQkgIGNtaS5jYlNpemUgPSBzaXplb2YoQ01JTlZPS0VDT01NQU5ESU5GTyk7CgkJCQkgIGNtaS5mTWFzayA9IDA7CgkJCQkgIGNtaS5od25kID0gaHduZFBhcmVudDsKCQkJCSAgY21pLmxwVmVyYiA9IChMUENTVFIpKElOVF9QVFIpKGlkQ21kIC0gRkNJRE1fU0hWSUVXRklSU1QpOwoJCQkJICBjbWkubHBQYXJhbWV0ZXJzID0gTlVMTDsKCQkJCSAgY21pLmxwRGlyZWN0b3J5ID0gTlVMTDsKCQkJCSAgY21pLm5TaG93ID0gU1dfU0hPV05PUk1BTDsKCQkJCSAgY21pLmR3SG90S2V5ID0gMDsKCQkJCSAgY21pLmhJY29uID0gMDsKCgkJCQkgIGhyID0gKCpwY20tPmxwVnRibC0+SW52b2tlQ29tbWFuZCkocGNtLCAmY21pKTsKCQkJCX0KCQkJfQoJCX0KCgkJKCpwY20tPmxwVnRibC0+UmVsZWFzZSkocGNtKTsKCX0KCglyZXR1cm4gaHI7Cn0KCgpMUkVTVUxUIENBTExCQUNLIENoaWxkV25kUHJvYyhIV05EIGh3bmQsIFVJTlQgbm1zZywgV1BBUkFNIHdwYXJhbSwgTFBBUkFNIGxwYXJhbSkKewoJc3RhdGljIGludCBsYXN0X3NwbGl0OwoKCUNoaWxkV25kKiBjaGlsZCA9IChDaGlsZFduZCopIEdldFdpbmRvd0xvbmcoaHduZCwgR1dMX1VTRVJEQVRBKTsKCUFTU0VSVChjaGlsZCk7CgoJc3dpdGNoKG5tc2cpIHsKCQljYXNlIFdNX0RSQVdJVEVNOiB7CgkJCUxQRFJBV0lURU1TVFJVQ1QgZGlzID0gKExQRFJBV0lURU1TVFJVQ1QpbHBhcmFtOwoJCQlFbnRyeSogZW50cnkgPSAoRW50cnkqKSBkaXMtPml0ZW1EYXRhOwoKCQkJaWYgKGRpcy0+Q3RsSUQgPT0gSURXX1RSRUVfTEVGVCkKCQkJCWRyYXdfaXRlbSgmY2hpbGQtPmxlZnQsIGRpcywgZW50cnksIC0xKTsKCQkJZWxzZSBpZiAoZGlzLT5DdGxJRCA9PSBJRFdfVFJFRV9SSUdIVCkKCQkJCWRyYXdfaXRlbSgmY2hpbGQtPnJpZ2h0LCBkaXMsIGVudHJ5LCAtMSk7CgkJCWVsc2UKCQkJCWdvdG8gZHJhd19tZW51X2l0ZW07CgoJCQlyZXR1cm4gVFJVRTt9CgoJCWNhc2UgV01fQ1JFQVRFOgoJCQlJbml0Q2hpbGRXaW5kb3coY2hpbGQpOwoJCQlicmVhazsKCgkJY2FzZSBXTV9OQ0RFU1RST1k6CgkJCWZyZWVfY2hpbGRfd2luZG93KGNoaWxkKTsKCQkJU2V0V2luZG93TG9uZyhod25kLCBHV0xfVVNFUkRBVEEsIDApOwoJCQlicmVhazsKCgkJY2FzZSBXTV9QQUlOVDogewoJCQlQQUlOVFNUUlVDVCBwczsKCQkJSEJSVVNIIGxhc3RCcnVzaDsKCQkJUkVDVCBydDsKCQkJR2V0Q2xpZW50UmVjdChod25kLCAmcnQpOwoJCQlCZWdpblBhaW50KGh3bmQsICZwcyk7CgkJCXJ0LmxlZnQgPSBjaGlsZC0+c3BsaXRfcG9zLVNQTElUX1dJRFRILzI7CgkJCXJ0LnJpZ2h0ID0gY2hpbGQtPnNwbGl0X3BvcytTUExJVF9XSURUSC8yKzE7CgkJCWxhc3RCcnVzaCA9IFNlbGVjdEJydXNoKHBzLmhkYywgKEhCUlVTSClHZXRTdG9ja09iamVjdChDT0xPUl9TUExJVEJBUikpOwoJCQlSZWN0YW5nbGUocHMuaGRjLCBydC5sZWZ0LCBydC50b3AtMSwgcnQucmlnaHQsIHJ0LmJvdHRvbSsxKTsKCQkJU2VsZWN0T2JqZWN0KHBzLmhkYywgbGFzdEJydXNoKTsKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJCXJ0LnRvcCA9IHJ0LmJvdHRvbSAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lIU0NST0xMKTsKCQkJRmlsbFJlY3QocHMuaGRjLCAmcnQsIEdldFN0b2NrT2JqZWN0KEJMQUNLX0JSVVNIKSk7CiNlbmRpZgoJCQlFbmRQYWludChod25kLCAmcHMpOwoJCQlicmVhazt9CgoJCWNhc2UgV01fU0VUQ1VSU09SOgoJCQlpZiAoTE9XT1JEKGxwYXJhbSkgPT0gSFRDTElFTlQpIHsKCQkJCVBPSU5UIHB0OwoJCQkJR2V0Q3Vyc29yUG9zKCZwdCk7CgkJCQlTY3JlZW5Ub0NsaWVudChod25kLCAmcHQpOwoKCQkJCWlmIChwdC54Pj1jaGlsZC0+c3BsaXRfcG9zLVNQTElUX1dJRFRILzIgJiYgcHQueDxjaGlsZC0+c3BsaXRfcG9zK1NQTElUX1dJRFRILzIrMSkgewoJCQkJCVNldEN1cnNvcihMb2FkQ3Vyc29yKDAsIElEQ19TSVpFV0UpKTsKCQkJCQlyZXR1cm4gVFJVRTsKCQkJCX0KCQkJfQoJCQlnb3RvIGRlZjsKCgkJY2FzZSBXTV9MQlVUVE9ORE9XTjogewoJCQlSRUNUIHJ0OwoJCQlpbnQgeCA9IEdFVF9YX0xQQVJBTShscGFyYW0pOwoKCQkJR2V0Q2xpZW50UmVjdChod25kLCAmcnQpOwoKCQkJaWYgKHg+PWNoaWxkLT5zcGxpdF9wb3MtU1BMSVRfV0lEVEgvMiAmJiB4PGNoaWxkLT5zcGxpdF9wb3MrU1BMSVRfV0lEVEgvMisxKSB7CgkJCQlsYXN0X3NwbGl0ID0gY2hpbGQtPnNwbGl0X3BvczsKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJCQlkcmF3X3NwbGl0YmFyKGh3bmQsIGxhc3Rfc3BsaXQpOwojZW5kaWYKCQkJCVNldENhcHR1cmUoaHduZCk7CgkJCX0KCgkJCWJyZWFrO30KCgkJY2FzZSBXTV9MQlVUVE9OVVA6CgkJCWlmIChHZXRDYXB0dXJlKCkgPT0gaHduZCkgewojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJCVJFQ1QgcnQ7CgkJCQlpbnQgeCA9IExPV09SRChscGFyYW0pOwoJCQkJZHJhd19zcGxpdGJhcihod25kLCBsYXN0X3NwbGl0KTsKCQkJCWxhc3Rfc3BsaXQgPSAtMTsKCQkJCUdldENsaWVudFJlY3QoaHduZCwgJnJ0KTsKCQkJCWNoaWxkLT5zcGxpdF9wb3MgPSB4OwoJCQkJcmVzaXplX3RyZWUoY2hpbGQsIHJ0LnJpZ2h0LCBydC5ib3R0b20pOwojZW5kaWYKCQkJCVJlbGVhc2VDYXB0dXJlKCk7CgkJCX0KCQkJYnJlYWs7CgojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQljYXNlIFdNX0NBUFRVUkVDSEFOR0VEOgoJCQlpZiAoR2V0Q2FwdHVyZSgpPT1od25kICYmIGxhc3Rfc3BsaXQ+PTApCgkJCQlkcmF3X3NwbGl0YmFyKGh3bmQsIGxhc3Rfc3BsaXQpOwoJCQlicmVhazsKI2VuZGlmCgoJCWNhc2UgV01fS0VZRE9XTjoKCQkJaWYgKHdwYXJhbSA9PSBWS19FU0NBUEUpCgkJCQlpZiAoR2V0Q2FwdHVyZSgpID09IGh3bmQpIHsKCQkJCQlSRUNUIHJ0OwojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJCQlkcmF3X3NwbGl0YmFyKGh3bmQsIGxhc3Rfc3BsaXQpOwojZWxzZQoJCQkJCWNoaWxkLT5zcGxpdF9wb3MgPSBsYXN0X3NwbGl0OwojZW5kaWYKCQkJCQlHZXRDbGllbnRSZWN0KGh3bmQsICZydCk7CgkJCQkJcmVzaXplX3RyZWUoY2hpbGQsIHJ0LnJpZ2h0LCBydC5ib3R0b20pOwoJCQkJCWxhc3Rfc3BsaXQgPSAtMTsKCQkJCQlSZWxlYXNlQ2FwdHVyZSgpOwoJCQkJCVNldEN1cnNvcihMb2FkQ3Vyc29yKDAsIElEQ19BUlJPVykpOwoJCQkJfQoJCQlicmVhazsKCgkJY2FzZSBXTV9NT1VTRU1PVkU6CgkJCWlmIChHZXRDYXB0dXJlKCkgPT0gaHduZCkgewoJCQkJUkVDVCBydDsKCQkJCWludCB4ID0gTE9XT1JEKGxwYXJhbSk7CgojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJCUhEQyBoZGMgPSBHZXREQyhod25kKTsKCQkJCUdldENsaWVudFJlY3QoaHduZCwgJnJ0KTsKCgkJCQlydC5sZWZ0ID0gbGFzdF9zcGxpdC1TUExJVF9XSURUSC8yOwoJCQkJcnQucmlnaHQgPSBsYXN0X3NwbGl0K1NQTElUX1dJRFRILzIrMTsKCQkJCUludmVydFJlY3QoaGRjLCAmcnQpOwoKCQkJCWxhc3Rfc3BsaXQgPSB4OwoJCQkJcnQubGVmdCA9IHgtU1BMSVRfV0lEVEgvMjsKCQkJCXJ0LnJpZ2h0ID0geCtTUExJVF9XSURUSC8yKzE7CgkJCQlJbnZlcnRSZWN0KGhkYywgJnJ0KTsKCgkJCQlSZWxlYXNlREMoaHduZCwgaGRjKTsKI2Vsc2UKCQkJCUdldENsaWVudFJlY3QoaHduZCwgJnJ0KTsKCgkJCQlpZiAoeD49MCAmJiB4PHJ0LnJpZ2h0KSB7CgkJCQkJY2hpbGQtPnNwbGl0X3BvcyA9IHg7CgkJCQkJcmVzaXplX3RyZWUoY2hpbGQsIHJ0LnJpZ2h0LCBydC5ib3R0b20pOwoJCQkJCXJ0LmxlZnQgPSB4LVNQTElUX1dJRFRILzI7CgkJCQkJcnQucmlnaHQgPSB4K1NQTElUX1dJRFRILzIrMTsKCQkJCQlJbnZhbGlkYXRlUmVjdChod25kLCAmcnQsIEZBTFNFKTsKCQkJCQlVcGRhdGVXaW5kb3coY2hpbGQtPmxlZnQuaHduZCk7CgkJCQkJVXBkYXRlV2luZG93KGh3bmQpOwoJCQkJCVVwZGF0ZVdpbmRvdyhjaGlsZC0+cmlnaHQuaHduZCk7CgkJCQl9CiNlbmRpZgoJCQl9CgkJCWJyZWFrOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgV01fR0VUTUlOTUFYSU5GTzoKCQkJRGVmTURJQ2hpbGRQcm9jKGh3bmQsIG5tc2csIHdwYXJhbSwgbHBhcmFtKTsKCgkJCXtMUE1JTk1BWElORk8gbHBtbWkgPSAoTFBNSU5NQVhJTkZPKWxwYXJhbTsKCgkJCWxwbW1pLT5wdE1heFRyYWNrU2l6ZS54IDw8PSAxOy8qMipHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOKSAvIFNNX0NYVklSVFVBTFNDUkVFTiAqLwoJCQlscG1taS0+cHRNYXhUcmFja1NpemUueSA8PD0gMTsvKjIqR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNDUkVFTikgLyBTTV9DWVZJUlRVQUxTQ1JFRU4gKi8KCQkJYnJlYWs7fQojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCgkJY2FzZSBXTV9TRVRGT0NVUzoKCQkJaWYgKFNldEN1cnJlbnREaXJlY3RvcnkoY2hpbGQtPnBhdGgpKQoJCQkJc2V0X3NwYWNlX3N0YXR1cygpOwoJCQlTZXRGb2N1cyhjaGlsZC0+Zm9jdXNfcGFuZT8gY2hpbGQtPnJpZ2h0Lmh3bmQ6IGNoaWxkLT5sZWZ0Lmh3bmQpOwoJCQlicmVhazsKCgkJY2FzZSBXTV9ESVNQQVRDSF9DT01NQU5EOiB7CgkJCVBhbmUqIHBhbmUgPSBHZXRGb2N1cygpPT1jaGlsZC0+bGVmdC5od25kPyAmY2hpbGQtPmxlZnQ6ICZjaGlsZC0+cmlnaHQ7CgoJCQlzd2l0Y2goTE9XT1JEKHdwYXJhbSkpIHsKCQkJCWNhc2UgSURfV0lORE9XX05FVzogewoJCQkJCUNoaWxkV25kKiBuZXdfY2hpbGQgPSBhbGxvY19jaGlsZF93aW5kb3coY2hpbGQtPnBhdGgsIE5VTEwsIGh3bmQpOwoKCQkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3cobmV3X2NoaWxkKSkKCQkJCQkJZnJlZShuZXdfY2hpbGQpOwoKCQkJCQlicmVhazt9CgoJCQkJY2FzZSBJRF9SRUZSRVNIOgoJCQkJCXJlZnJlc2hfZHJpdmVzKCk7CgkJCQkJcmVmcmVzaF9jaGlsZChjaGlsZCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9BQ1RJVkFURToKCQkJCQlhY3RpdmF0ZV9lbnRyeShjaGlsZCwgcGFuZSwgaHduZCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9GSUxFX01PVkU6IHsKCQkJCQlUQ0hBUiBuZXdfbmFtZVtCVUZGRVJfTEVOXSwgb2xkX25hbWVbQlVGRkVSX0xFTl07CgkJCQkJaW50IGxlbiwgcmV0OwoKCQkJCQlnZXRfcGF0aChwYW5lLT5jdXIsIG5ld19uYW1lKTsKCgkJCQkJcmV0ID0gRGlhbG9nQm94UGFyYW0oR2xvYmFscy5oSW5zdGFuY2UsIE1BS0VJTlRSRVNPVVJDRShJRERfU0VMRUNUX0RFU1RJTkFUSU9OKSwgaHduZCwgRGVzdGluYXRpb25EbGdQcm9jLCAoTFBBUkFNKW5ld19uYW1lKTsKCQkJCQlpZiAocmV0ICE9IElET0spCgkJCQkJCWJyZWFrOwoKCQkJCQlpZiAobmV3X25hbWVbMF0hPScvJyAmJiBuZXdfbmFtZVsxXSE9JzonKSB7CgkJCQkJCWdldF9wYXRoKHBhbmUtPmN1ci0+dXAsIG9sZF9uYW1lKTsKCQkJCQkJbGVuID0gbHN0cmxlbihvbGRfbmFtZSk7CgoJCQkJCQlpZiAob2xkX25hbWVbbGVuLTFdIT0nXFwnICYmIG9sZF9uYW1lW2xlbi0xXSE9Jy8nKQoJCQkJCQkJb2xkX25hbWVbbGVuKytdID0gJy8nOwoKCQkJCQkJbHN0cmNweShvbGRfbmFtZStsZW4sIG5ld19uYW1lKTsKCQkJCQkJbHN0cmNweShuZXdfbmFtZSwgb2xkX25hbWUpOwoJCQkJCX0KCgkJCQkJZ2V0X3BhdGgocGFuZS0+Y3VyLCBvbGRfbmFtZSk7CgoJCQkJCWlmIChNb3ZlRmlsZUV4KG9sZF9uYW1lLCBuZXdfbmFtZSwgTU9WRUZJTEVfQ09QWV9BTExPV0VEKSkgewoJCQkJCQlpZiAocGFuZS0+dHJlZVBhbmUpIHsKCQkJCQkJCXBhbmUtPnJvb3QtPnNjYW5uZWQgPSBGQUxTRTsKCQkJCQkJCXBhbmUtPmN1ciA9IHBhbmUtPnJvb3Q7CgkJCQkJCQlhY3RpdmF0ZV9lbnRyeShjaGlsZCwgcGFuZSwgaHduZCk7CgkJCQkJCX0KCQkJCQkJZWxzZQoJCQkJCQkJcmVmcmVzaF9jaGlsZChjaGlsZCk7CgkJCQkJfQoJCQkJCWVsc2UKCQkJCQkJZGlzcGxheV9lcnJvcihod25kLCBHZXRMYXN0RXJyb3IoKSk7CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgSURfVklFV19TT1JUX05BTUU6CgkJCQkJc2V0X3NvcnRfb3JkZXIoY2hpbGQsIFNPUlRfTkFNRSk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9WSUVXX1NPUlRfVFlQRToKCQkJCQlzZXRfc29ydF9vcmRlcihjaGlsZCwgU09SVF9FWFQpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfVklFV19TT1JUX1NJWkU6CgkJCQkJc2V0X3NvcnRfb3JkZXIoY2hpbGQsIFNPUlRfU0laRSk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9WSUVXX1NPUlRfREFURToKCQkJCQlzZXRfc29ydF9vcmRlcihjaGlsZCwgU09SVF9EQVRFKTsKCQkJCQlicmVhazsKCgkJCQlkZWZhdWx0OgoJCQkJCXJldHVybiBwYW5lX2NvbW1hbmQocGFuZSwgTE9XT1JEKHdwYXJhbSkpOwoJCQl9CgoJCQlyZXR1cm4gVFJVRTt9CgoJCWNhc2UgV01fQ09NTUFORDogewoJCQlQYW5lKiBwYW5lID0gR2V0Rm9jdXMoKT09Y2hpbGQtPmxlZnQuaHduZD8gJmNoaWxkLT5sZWZ0OiAmY2hpbGQtPnJpZ2h0OwoKCQkJc3dpdGNoKEhJV09SRCh3cGFyYW0pKSB7CgkJCQljYXNlIExCTl9TRUxDSEFOR0U6IHsKCQkJCQlpbnQgaWR4ID0gTGlzdEJveF9HZXRDdXJTZWwocGFuZS0+aHduZCk7CgkJCQkJRW50cnkqIGVudHJ5ID0gKEVudHJ5KikgTGlzdEJveF9HZXRJdGVtRGF0YShwYW5lLT5od25kLCBpZHgpOwoKCQkJCQlpZiAocGFuZSA9PSAmY2hpbGQtPmxlZnQpCgkJCQkJCXNldF9jdXJkaXIoY2hpbGQsIGVudHJ5LCBpZHgsIGh3bmQpOwoJCQkJCWVsc2UKCQkJCQkJcGFuZS0+Y3VyID0gZW50cnk7CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgTEJOX0RCTENMSzoKCQkJCQlhY3RpdmF0ZV9lbnRyeShjaGlsZCwgcGFuZSwgaHduZCk7CgkJCQkJYnJlYWs7CgkJCX0KCQkJYnJlYWs7fQoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgV01fTk9USUZZOiB7CgkJCU5NSERSKiBwbm1oID0gKE5NSERSKikgbHBhcmFtOwoJCQlyZXR1cm4gcGFuZV9ub3RpZnkocG5taC0+aWRGcm9tPT1JRFdfSEVBREVSX0xFRlQ/ICZjaGlsZC0+bGVmdDogJmNoaWxkLT5yaWdodCwgcG5taCk7fQojZW5kaWYKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJCWNhc2UgV01fQ09OVEVYVE1FTlU6IHsKCQkJUGFuZSogcGFuZTsKCQkJaW50IGlkeDsKCgkJCSAvKiBmaXJzdCBzZWxlY3QgdGhlIGN1cnJlbnQgaXRlbSBpbiB0aGUgbGlzdGJveCAqLwoJCQlIV05EIGhwYW5lbCA9IChIV05EKSB3cGFyYW07CgkJCVBPSU5UIHB0OwoJCQlwdC54ID0gKHNob3J0KUxPV09SRChscGFyYW0pOwoJCQlwdC55ID0gKHNob3J0KUhJV09SRChscGFyYW0pOwoJCQlTY3JlZW5Ub0NsaWVudChocGFuZWwsICZwdCk7CgkJCVNlbmRNZXNzYWdlKGhwYW5lbCwgV01fTEJVVFRPTkRPV04sIDAsIE1BS0VMT05HKHB0LngsIHB0LnkpKTsKCQkJU2VuZE1lc3NhZ2UoaHBhbmVsLCBXTV9MQlVUVE9OVVAsIDAsIE1BS0VMT05HKHB0LngsIHB0LnkpKTsKCgkJCSAvKiBub3cgY3JlYXRlIHRoZSBwb3B1cCBtZW51IHVzaW5nIHNoZWxsIG5hbWVzcGFjZSBhbmQgSUNvbnRleHRNZW51ICovCgkJCXBhbmUgPSBHZXRGb2N1cygpPT1jaGlsZC0+bGVmdC5od25kPyAmY2hpbGQtPmxlZnQ6ICZjaGlsZC0+cmlnaHQ7CgkJCWlkeCA9IExpc3RCb3hfR2V0Q3VyU2VsKHBhbmUtPmh3bmQpOwoKCQkJaWYgKGlkeCAhPSAtMSkgewoJCQkJSFJFU1VMVCBocjsKCQkJCUVudHJ5KiBlbnRyeSA9IChFbnRyeSopIExpc3RCb3hfR2V0SXRlbURhdGEocGFuZS0+aHduZCwgaWR4KTsKCgkJCQlMUElURU1JRExJU1QgcGlkbF9hYnMgPSBnZXRfdG9fYWJzb2x1dGVfcGlkbChlbnRyeSwgaHduZCk7CgoJCQkJaWYgKHBpZGxfYWJzKSB7CgkJCQkJSVNoZWxsRm9sZGVyKiBwYXJlbnRGb2xkZXI7CgkJCQkJTFBDSVRFTUlETElTVCBwaWRsTGFzdDsKCgkJCQkJIC8qIGdldCBhbmQgdXNlIHRoZSBwYXJlbnQgZm9sZGVyIHRvIGRpc3BsYXkgY29ycmVjdCBjb250ZXh0IG1lbnUgaW4gYWxsIGNhc2VzICovCgkJCQkJaWYgKFNVQ0NFRURFRChTSEJpbmRUb1BhcmVudChwaWRsX2FicywgJklJRF9JU2hlbGxGb2xkZXIsIChMUFZPSUQqKSZwYXJlbnRGb2xkZXIsICZwaWRsTGFzdCkpKSB7CgkJCQkJCWhyID0gU2hlbGxGb2xkZXJDb250ZXh0TWVudShwYXJlbnRGb2xkZXIsIGh3bmQsIDEsICZwaWRsTGFzdCwgcHQueCwgcHQueSk7CgoJCQkJCQkoKnBhcmVudEZvbGRlci0+bHBWdGJsLT5SZWxlYXNlKShwYXJlbnRGb2xkZXIpOwoJCQkJCX0KCgkJCQkJKCpHbG9iYWxzLmlNYWxsb2MtPmxwVnRibC0+RnJlZSkoR2xvYmFscy5pTWFsbG9jLCBwaWRsX2Ficyk7CgkJCQl9CgkJCX0KCQkJYnJlYWs7fQojZW5kaWYKCgkJICBjYXNlIFdNX01FQVNVUkVJVEVNOgoJCSAgZHJhd19tZW51X2l0ZW06CgkJCWlmICghd3BhcmFtKQkvKiBJcyB0aGUgbWVzc2FnZSBtZW51LXJlbGF0ZWQ/ICovCgkJCQlpZiAoQ3R4TWVudV9IYW5kbGVNZW51TXNnKG5tc2csIHdwYXJhbSwgbHBhcmFtKSkKCQkJCQlyZXR1cm4gVFJVRTsKCgkJCWJyZWFrOwoKCQkgIGNhc2UgV01fSU5JVE1FTlVQT1BVUDoKCQkJaWYgKEN0eE1lbnVfSGFuZGxlTWVudU1zZyhubXNnLCB3cGFyYW0sIGxwYXJhbSkpCgkJCQlyZXR1cm4gMDsKCgkJCXVwZGF0ZV92aWV3X21lbnUoY2hpbGQpOwoJCQlicmVhazsKCgkJICBjYXNlIFdNX01FTlVDSEFSOgkvKiBvbmx5IHN1cHBvcnRlZCBieSBJQ29udGV4dE1lbnUzICovCgkJICAgaWYgKHNfcGN0eG1lbnUzKSB7CgkJCSAgIExSRVNVTFQgbFJlc3VsdCA9IDA7CgoJCQkgICAoKnNfcGN0eG1lbnUzLT5scFZ0YmwtPkhhbmRsZU1lbnVNc2cyKShzX3BjdHhtZW51Mywgbm1zZywgd3BhcmFtLCBscGFyYW0sICZsUmVzdWx0KTsKCgkJCSAgIHJldHVybiBsUmVzdWx0OwoJCSAgIH0KCgkJICAgYnJlYWs7CgoJCWNhc2UgV01fU0laRToKCQkJaWYgKHdwYXJhbSAhPSBTSVpFX01JTklNSVpFRCkKCQkJCXJlc2l6ZV90cmVlKGNoaWxkLCBMT1dPUkQobHBhcmFtKSwgSElXT1JEKGxwYXJhbSkpOwoJCQkvKiBmYWxsIHRocm91Z2ggKi8KCgkJZGVmYXVsdDogZGVmOgoJCQlyZXR1cm4gRGVmTURJQ2hpbGRQcm9jKGh3bmQsIG5tc2csIHdwYXJhbSwgbHBhcmFtKTsKCX0KCglyZXR1cm4gMDsKfQoKCkxSRVNVTFQgQ0FMTEJBQ0sgVHJlZVduZFByb2MoSFdORCBod25kLCBVSU5UIG5tc2csIFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pCnsKCUNoaWxkV25kKiBjaGlsZCA9IChDaGlsZFduZCopIEdldFdpbmRvd0xvbmcoR2V0UGFyZW50KGh3bmQpLCBHV0xfVVNFUkRBVEEpOwoJUGFuZSogcGFuZSA9IChQYW5lKikgR2V0V2luZG93TG9uZyhod25kLCBHV0xfVVNFUkRBVEEpOwoJQVNTRVJUKGNoaWxkKTsKCglzd2l0Y2gobm1zZykgewojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJY2FzZSBXTV9IU0NST0xMOgoJCQlzZXRfaGVhZGVyKHBhbmUpOwoJCQlicmVhazsKI2VuZGlmCgoJCWNhc2UgV01fU0VURk9DVVM6CgkJCWNoaWxkLT5mb2N1c19wYW5lID0gcGFuZT09JmNoaWxkLT5yaWdodD8gMTogMDsKCQkJTGlzdEJveF9TZXRTZWwoaHduZCwgVFJVRSwgMSk7CgkJCS8qVE9ETzogY2hlY2sgbWVudSBpdGVtcyAqLwoJCQlicmVhazsKCgkJY2FzZSBXTV9LRVlET1dOOgoJCQlpZiAod3BhcmFtID09IFZLX1RBQikgewoJCQkJLypUT0RPOiBTZXRGb2N1cyhHbG9iYWxzLmhkcml2ZWJhcikgKi8KCQkJCVNldEZvY3VzKGNoaWxkLT5mb2N1c19wYW5lPyBjaGlsZC0+bGVmdC5od25kOiBjaGlsZC0+cmlnaHQuaHduZCk7CgkJCX0KCX0KCglyZXR1cm4gQ2FsbFdpbmRvd1Byb2MoZ19vcmdUcmVlV25kUHJvYywgaHduZCwgbm1zZywgd3BhcmFtLCBscGFyYW0pOwp9CgoKc3RhdGljIHZvaWQgSW5pdEluc3RhbmNlKEhJTlNUQU5DRSBoaW5zdGFuY2UpCnsKCWNvbnN0IHN0YXRpYyBUQ0hBUiBzRm9udFtdID0geydNJywnaScsJ2MnLCdyJywnbycsJ3MnLCdvJywnZicsJ3QnLCcgJywnUycsJ2EnLCduJywncycsJyAnLCdTJywnZScsJ3InLCdpJywnZicsJ1wwJ307CgoJV05EQ0xBU1NFWCB3Y0ZyYW1lOwoJV05EQ0xBU1Mgd2NDaGlsZDsKCUFUT00gaENoaWxkQ2xhc3M7CglpbnQgY29sOwoKCUlOSVRDT01NT05DT05UUk9MU0VYIGljYyA9IHsKCQlzaXplb2YoSU5JVENPTU1PTkNPTlRST0xTRVgpLAoJCUlDQ19CQVJfQ0xBU1NFUwoJfTsKCglIREMgaGRjID0gR2V0REMoMCk7CgoJc2V0bG9jYWxlKExDX0NPTExBVEUsICIiKTsJLyogc2V0IGNvbGxhdGluZyBydWxlcyB0byBsb2NhbCBzZXR0aW5ncyBmb3IgY29tcGFyZU5hbWUgKi8KCglJbml0Q29tbW9uQ29udHJvbHNFeCgmaWNjKTsKCgoJLyogcmVnaXN0ZXIgZnJhbWUgd2luZG93IGNsYXNzICovCgoJd2NGcmFtZS5jYlNpemUgICAgICAgID0gc2l6ZW9mKFdORENMQVNTRVgpOwoJd2NGcmFtZS5zdHlsZSAgICAgICAgID0gMDsKCXdjRnJhbWUubHBmblduZFByb2MgICA9IEZyYW1lV25kUHJvYzsKCXdjRnJhbWUuY2JDbHNFeHRyYSAgICA9IDA7Cgl3Y0ZyYW1lLmNiV25kRXh0cmEgICAgPSAwOwoJd2NGcmFtZS5oSW5zdGFuY2UgICAgID0gaGluc3RhbmNlOwoJd2NGcmFtZS5oSWNvbiAgICAgICAgID0gTG9hZEljb24oaGluc3RhbmNlLCBNQUtFSU5UUkVTT1VSQ0UoSURJX1dJTkVGSUxFKSk7Cgl3Y0ZyYW1lLmhDdXJzb3IgICAgICAgPSBMb2FkQ3Vyc29yKDAsIElEQ19BUlJPVyk7Cgl3Y0ZyYW1lLmhickJhY2tncm91bmQgPSAwOwoJd2NGcmFtZS5scHN6TWVudU5hbWUgID0gMDsKCXdjRnJhbWUubHBzekNsYXNzTmFtZSA9IHNXSU5FRklMRUZSQU1FOwoJd2NGcmFtZS5oSWNvblNtICAgICAgID0gKEhJQ09OKUxvYWRJbWFnZShoaW5zdGFuY2UsCgkJCQkJCQkJCQkJIE1BS0VJTlRSRVNPVVJDRShJRElfV0lORUZJTEUpLAoJCQkJCQkJCQkJCSBJTUFHRV9JQ09OLAoJCQkJCQkJCQkJCSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU01JQ09OKSwKCQkJCQkJCQkJCQkgR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNNSUNPTiksCgkJCQkJCQkJCQkJIExSX1NIQVJFRCk7CgoJR2xvYmFscy5oZnJhbWVDbGFzcyA9IFJlZ2lzdGVyQ2xhc3NFeCgmd2NGcmFtZSk7CgoKCS8qIHJlZ2lzdGVyIHRyZWUgd2luZG93cyBjbGFzcyAqLwoKCXdjQ2hpbGQuc3R5bGUgICAgICAgICA9IENTX0NMQVNTREN8Q1NfREJMQ0xLU3xDU19WUkVEUkFXOwoJd2NDaGlsZC5scGZuV25kUHJvYyAgID0gQ2hpbGRXbmRQcm9jOwoJd2NDaGlsZC5jYkNsc0V4dHJhICAgID0gMDsKCXdjQ2hpbGQuY2JXbmRFeHRyYSAgICA9IDA7Cgl3Y0NoaWxkLmhJbnN0YW5jZSAgICAgPSBoaW5zdGFuY2U7Cgl3Y0NoaWxkLmhJY29uICAgICAgICAgPSAwOwoJd2NDaGlsZC5oQ3Vyc29yICAgICAgID0gTG9hZEN1cnNvcigwLCBJRENfQVJST1cpOwoJd2NDaGlsZC5oYnJCYWNrZ3JvdW5kID0gMDsKCXdjQ2hpbGQubHBzek1lbnVOYW1lICA9IDA7Cgl3Y0NoaWxkLmxwc3pDbGFzc05hbWUgPSBzV0lORUZJTEVUUkVFOwoKCWhDaGlsZENsYXNzID0gUmVnaXN0ZXJDbGFzcygmd2NDaGlsZCk7CgoKCUdsb2JhbHMuaGFjY2VsID0gTG9hZEFjY2VsZXJhdG9ycyhoaW5zdGFuY2UsIE1BS0VJTlRSRVNPVVJDRShJREFfV0lORUZJTEUpKTsKCglHbG9iYWxzLmhmb250ID0gQ3JlYXRlRm9udCgtTXVsRGl2KDgsR2V0RGV2aWNlQ2FwcyhoZGMsTE9HUElYRUxTWSksNzIpLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCBzRm9udCk7CgoJUmVsZWFzZURDKDAsIGhkYyk7CgoJR2xvYmFscy5oSW5zdGFuY2UgPSBoaW5zdGFuY2U7CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCUNvSW5pdGlhbGl6ZShOVUxMKTsKCUNvR2V0TWFsbG9jKE1FTUNUWF9UQVNLLCAmR2xvYmFscy5pTWFsbG9jKTsKCVNIR2V0RGVza3RvcEZvbGRlcigmR2xvYmFscy5pRGVza3RvcCk7CiNpZmRlZiBfX1dJTkVfXwoJR2xvYmFscy5jZlN0ckZOYW1lID0gUmVnaXN0ZXJDbGlwYm9hcmRGb3JtYXRBKENGU1RSX0ZJTEVOQU1FKTsKI2Vsc2UKCUdsb2JhbHMuY2ZTdHJGTmFtZSA9IFJlZ2lzdGVyQ2xpcGJvYXJkRm9ybWF0KENGU1RSX0ZJTEVOQU1FKTsKI2VuZGlmCiNlbmRpZgoKCS8qIGxvYWQgY29sdW1uIHN0cmluZ3MgKi8KCWNvbCA9IDA7CgoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX05BTUUpOwoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX1NJWkUpOwoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX0NEQVRFKTsKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX0FEQVRFKTsKCWxvYWRfc3RyaW5nKGdfcG9zX25hbWVzW2NvbCsrXSwgSURTX0NPTF9NREFURSk7Cglsb2FkX3N0cmluZyhnX3Bvc19uYW1lc1tjb2wrK10sIElEU19DT0xfSURYKTsKCWxvYWRfc3RyaW5nKGdfcG9zX25hbWVzW2NvbCsrXSwgSURTX0NPTF9MSU5LUyk7CiNlbmRpZgoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX0FUVFIpOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCglsb2FkX3N0cmluZyhnX3Bvc19uYW1lc1tjb2wrK10sIElEU19DT0xfU0VDKTsKI2VuZGlmCn0KCgp2b2lkIHNob3dfZnJhbWUoSFdORCBod25kUGFyZW50LCBpbnQgY21kc2hvdykKewoJY29uc3Qgc3RhdGljIFRDSEFSIHNNRElDTElFTlRbXSA9IHsnTScsJ0QnLCdJJywnQycsJ0wnLCdJJywnRScsJ04nLCdUJywnXDAnfTsKCglUQ0hBUiBwYXRoW01BWF9QQVRIXSwgYjFbQlVGRkVSX0xFTl07CglDaGlsZFduZCogY2hpbGQ7CglITUVOVSBoTWVudUZyYW1lLCBoTWVudVdpbmRvdzsKCglDTElFTlRDUkVBVEVTVFJVQ1QgY2NzOwoKCWlmIChHbG9iYWxzLmhNYWluV25kKQoJCXJldHVybjsKCglHbG9iYWxzLmh3bmRQYXJlbnQgPSBod25kUGFyZW50OwoKCWhNZW51RnJhbWUgPSBMb2FkTWVudShHbG9iYWxzLmhJbnN0YW5jZSwgTUFLRUlOVFJFU09VUkNFKElETV9XSU5FRklMRSkpOwoJaE1lbnVXaW5kb3cgPSBHZXRTdWJNZW51KGhNZW51RnJhbWUsIEdldE1lbnVJdGVtQ291bnQoaE1lbnVGcmFtZSktMik7CgoJR2xvYmFscy5oTWVudUZyYW1lID0gaE1lbnVGcmFtZTsKCUdsb2JhbHMuaE1lbnVWaWV3ID0gR2V0U3ViTWVudShoTWVudUZyYW1lLCAzKTsKCUdsb2JhbHMuaE1lbnVPcHRpb25zID0gR2V0U3ViTWVudShoTWVudUZyYW1lLCA0KTsKCgljY3MuaFdpbmRvd01lbnUgID0gaE1lbnVXaW5kb3c7CgljY3MuaWRGaXJzdENoaWxkID0gSURXX0ZJUlNUX0NISUxEOwoKCgkvKiBjcmVhdGUgbWFpbiB3aW5kb3cgKi8KCUdsb2JhbHMuaE1haW5XbmQgPSBDcmVhdGVXaW5kb3dFeCgwLCAoTFBDVFNUUikoaW50KUdsb2JhbHMuaGZyYW1lQ2xhc3MsIFJTKGIxLElEU19XSU5FX0ZJTEUpLCBXU19PVkVSTEFQUEVEV0lORE9XLAoJCQkJCUNXX1VTRURFRkFVTFQsIENXX1VTRURFRkFVTFQsIENXX1VTRURFRkFVTFQsIENXX1VTRURFRkFVTFQsCgkJCQkJaHduZFBhcmVudCwgR2xvYmFscy5oTWVudUZyYW1lLCBHbG9iYWxzLmhJbnN0YW5jZSwgMC8qbHBQYXJhbSovKTsKCgoJR2xvYmFscy5obWRpY2xpZW50ID0gQ3JlYXRlV2luZG93RXgoMCwgc01ESUNMSUVOVCwgTlVMTCwKCQkJCQlXU19DSElMRHxXU19DTElQQ0hJTERSRU58V1NfVlNDUk9MTHxXU19IU0NST0xMfFdTX1ZJU0lCTEV8V1NfQk9SREVSLAoJCQkJCTAsIDAsIDAsIDAsCgkJCQkJR2xvYmFscy5oTWFpblduZCwgMCwgR2xvYmFscy5oSW5zdGFuY2UsICZjY3MpOwoKCglDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVPcHRpb25zLCBJRF9WSUVXX0RSSVZFX0JBUiwgTUZfQllDT01NQU5EfE1GX0NIRUNLRUQpOwoKCWNyZWF0ZV9kcml2ZV9iYXIoKTsKCgl7CgkJVEJCVVRUT04gdG9vbGJhckJ0bnNbXSA9IHsKCQkJezAsIDAsIDAsIEJUTlNfU0VQLCB7MCwgMH0sIDAsIDB9LAoJCQl7MCwgSURfV0lORE9XX05FVywgVEJTVEFURV9FTkFCTEVELCBCVE5TX0JVVFRPTiwgezAsIDB9LCAwLCAwfSwKCQkJezEsIElEX1dJTkRPV19DQVNDQURFLCBUQlNUQVRFX0VOQUJMRUQsIEJUTlNfQlVUVE9OLCB7MCwgMH0sIDAsIDB9LAoJCQl7MiwgSURfV0lORE9XX1RJTEVfSE9SWiwgVEJTVEFURV9FTkFCTEVELCBCVE5TX0JVVFRPTiwgezAsIDB9LCAwLCAwfSwKCQkJezMsIElEX1dJTkRPV19USUxFX1ZFUlQsIFRCU1RBVEVfRU5BQkxFRCwgQlROU19CVVRUT04sIHswLCAwfSwgMCwgMH0sCi8qVE9ETwoJCQl7NCwgSURfLi4uICwgVEJTVEFURV9FTkFCTEVELCBCVE5TX0JVVFRPTiwgezAsIDB9LCAwLCAwfSwKCQkJezUsIElEXy4uLiAsIFRCU1RBVEVfRU5BQkxFRCwgQlROU19CVVRUT04sIHswLCAwfSwgMCwgMH0sCiovCQl9OwoKCQlHbG9iYWxzLmh0b29sYmFyID0gQ3JlYXRlVG9vbGJhckV4KEdsb2JhbHMuaE1haW5XbmQsIFdTX0NISUxEfFdTX1ZJU0lCTEUsCgkJCUlEV19UT09MQkFSLCAyLCBHbG9iYWxzLmhJbnN0YW5jZSwgSURCX1RPT0xCQVIsIHRvb2xiYXJCdG5zLAoJCQlzaXplb2YodG9vbGJhckJ0bnMpL3NpemVvZihUQkJVVFRPTiksIDE2LCAxNSwgMTYsIDE1LCBzaXplb2YoVEJCVVRUT04pKTsKCQlDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVPcHRpb25zLCBJRF9WSUVXX1RPT0xfQkFSLCBNRl9CWUNPTU1BTkR8TUZfQ0hFQ0tFRCk7Cgl9CgoJR2xvYmFscy5oc3RhdHVzYmFyID0gQ3JlYXRlU3RhdHVzV2luZG93KFdTX0NISUxEfFdTX1ZJU0lCTEUsIDAsIEdsb2JhbHMuaE1haW5XbmQsIElEV19TVEFUVVNCQVIpOwoJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51T3B0aW9ucywgSURfVklFV19TVEFUVVNCQVIsIE1GX0JZQ09NTUFORHxNRl9DSEVDS0VEKTsKCi8qIENyZWF0ZVN0YXR1c1dpbmRvdyBkb2VzIG5vdCBhY2NlcHQgV1NfQk9SREVSCglHbG9iYWxzLmhzdGF0dXNiYXIgPSBDcmVhdGVXaW5kb3dFeChXU19FWF9OT1BBUkVOVE5PVElGWSwgU1RBVFVTQ0xBU1NOQU1FLCAwLAoJCQkJCVdTX0NISUxEfFdTX1ZJU0lCTEV8V1NfQ0xJUFNJQkxJTkdTfFdTX0JPUkRFUnxDQ1NfTk9ESVZJREVSLCAwLDAsMCwwLAoJCQkJCUdsb2JhbHMuaE1haW5XbmQsIChITUVOVSlJRFdfU1RBVFVTQkFSLCBoaW5zdGFuY2UsIDApOyovCgoJLypUT0RPOiByZWFkIHBhdGhzIGFuZCB3aW5kb3cgcGxhY2VtZW50cyBmcm9tIHJlZ2lzdHJ5ICovCglHZXRDdXJyZW50RGlyZWN0b3J5KE1BWF9QQVRILCBwYXRoKTsKCglTaG93V2luZG93KEdsb2JhbHMuaE1haW5XbmQsIGNtZHNob3cpOwoKI2lmIGRlZmluZWQoX1NIRUxMX0ZPTERFUlMpICYmICFkZWZpbmVkKF9fV0lORV9fKQoJIC8qIFNoZWxsIE5hbWVzcGFjZSBhcyBkZWZhdWx0OiAqLwoJY2hpbGQgPSBhbGxvY19jaGlsZF93aW5kb3cocGF0aCwgZ2V0X3BhdGhfcGlkbChwYXRoLEdsb2JhbHMuaE1haW5XbmQpLCBHbG9iYWxzLmhNYWluV25kKTsKI2Vsc2UKCWNoaWxkID0gYWxsb2NfY2hpbGRfd2luZG93KHBhdGgsIE5VTEwsIEdsb2JhbHMuaE1haW5XbmQpOwojZW5kaWYKCgljaGlsZC0+cG9zLnNob3dDbWQgPSBTV19TSE9XTUFYSU1JWkVEOwoJY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLmxlZnQgPSAwOwoJY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLnRvcCA9IDA7CgljaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24ucmlnaHQgPSAzMjA7CgljaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24uYm90dG9tID0gMjgwOwoKCWlmICghY3JlYXRlX2NoaWxkX3dpbmRvdyhjaGlsZCkpCgkJZnJlZShjaGlsZCk7CgoJU2V0V2luZG93UGxhY2VtZW50KGNoaWxkLT5od25kLCAmY2hpbGQtPnBvcyk7CgoJR2xvYmFscy5oaW1sID0gSW1hZ2VMaXN0X0xvYWRCaXRtYXAoR2xvYmFscy5oSW5zdGFuY2UsIE1BS0VJTlRSRVNPVVJDRShJREJfSU1BR0VTKSwgMTYsIDAsIFJHQigwLDI1NSwwKSk7CgoJR2xvYmFscy5wcmVzY2FuX25vZGUgPSBGQUxTRTsKCglVcGRhdGVXaW5kb3coR2xvYmFscy5oTWFpblduZCk7Cn0KCnZvaWQgRXhpdEluc3RhbmNlKCkKewojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCSgqR2xvYmFscy5pRGVza3RvcC0+bHBWdGJsLT5SZWxlYXNlKShHbG9iYWxzLmlEZXNrdG9wKTsKCSgqR2xvYmFscy5pTWFsbG9jLT5scFZ0YmwtPlJlbGVhc2UpKEdsb2JhbHMuaU1hbGxvYyk7CglDb1VuaW5pdGlhbGl6ZSgpOwojZW5kaWYKCglJbWFnZUxpc3RfRGVzdHJveShHbG9iYWxzLmhpbWwpOwp9CgoKLyogc2VhcmNoIGZvciBhbHJlYWR5IHJ1bm5pbmcgd2luW2VdZmlsZXMgKi8KCnN0YXRpYyBpbnQgZ19mb3VuZFByZXZJbnN0YW5jZSA9IDA7CgpzdGF0aWMgQk9PTCBDQUxMQkFDSyBFbnVtV25kUHJvYyhIV05EIGh3bmQsIExQQVJBTSBscGFyYW0pCnsKCVRDSEFSIGNsc1sxMjhdOwoKCUdldENsYXNzTmFtZShod25kLCBjbHMsIDEyOCk7CgoJaWYgKCFsc3RyY21wKGNscywgKExQQ1RTVFIpbHBhcmFtKSkgewoJCWdfZm91bmRQcmV2SW5zdGFuY2UrKzsKCQlyZXR1cm4gRkFMU0U7Cgl9CgoJcmV0dXJuIFRSVUU7Cn0KCi8qIHNlYXJjaCBmb3Igd2luZG93IG9mIGdpdmVuIGNsYXNzIG5hbWUgdG8gYWxsb3cgb25seSBvbmUgcnVubmluZyBpbnN0YW5jZSAqLwppbnQgZmluZF93aW5kb3dfY2xhc3MoTFBDVFNUUiBjbGFzc25hbWUpCnsKCUVudW1XaW5kb3dzKEVudW1XbmRQcm9jLCAoTFBBUkFNKWNsYXNzbmFtZSk7CgoJaWYgKGdfZm91bmRQcmV2SW5zdGFuY2UpCgkJcmV0dXJuIDE7CgoJcmV0dXJuIDA7Cn0KCgppbnQgd2luZWZpbGVfbWFpbihISU5TVEFOQ0UgaGluc3RhbmNlLCBIV05EIGh3bmRQYXJlbnQsIGludCBjbWRzaG93KQp7CglNU0cgbXNnOwoKCUluaXRJbnN0YW5jZShoaW5zdGFuY2UpOwoKCWlmIChjbWRzaG93ID09IFNXX1NIT1dOT1JNQUwpCgkgICAgICAgIC8qVE9ETzogcmVhZCB3aW5kb3cgcGxhY2VtZW50IGZyb20gcmVnaXN0cnkgKi8KCQljbWRzaG93ID0gU1dfTUFYSU1JWkU7CgoJc2hvd19mcmFtZShod25kUGFyZW50LCBjbWRzaG93KTsKCgl3aGlsZShHZXRNZXNzYWdlKCZtc2csIDAsIDAsIDApKSB7CgkJaWYgKEdsb2JhbHMuaG1kaWNsaWVudCAmJiBUcmFuc2xhdGVNRElTeXNBY2NlbChHbG9iYWxzLmhtZGljbGllbnQsICZtc2cpKQoJCQljb250aW51ZTsKCgkJaWYgKEdsb2JhbHMuaE1haW5XbmQgJiYgVHJhbnNsYXRlQWNjZWxlcmF0b3IoR2xvYmFscy5oTWFpblduZCwgR2xvYmFscy5oYWNjZWwsICZtc2cpKQoJCQljb250aW51ZTsKCgkJVHJhbnNsYXRlTWVzc2FnZSgmbXNnKTsKCQlEaXNwYXRjaE1lc3NhZ2UoJm1zZyk7Cgl9CgoJRXhpdEluc3RhbmNlKCk7CgoJcmV0dXJuIG1zZy53UGFyYW07Cn0KCgppbnQgQVBJRU5UUlkgV2luTWFpbihISU5TVEFOQ0UgaGluc3RhbmNlLAoJCQkJCSBISU5TVEFOQ0UgcHJldmluc3RhbmNlLAoJCQkJCSBMUFNUUgkgICBjbWRsaW5lLAoJCQkJCSBpbnQJICAgY21kc2hvdykKewojaWZkZWYgX05PX0VYVEVOU0lPTlMKCWlmIChmaW5kX3dpbmRvd19jbGFzcyhzV0lORUZJTEVGUkFNRSkpCgkJcmV0dXJuIDE7CiNlbmRpZgoKCXdpbmVmaWxlX21haW4oaGluc3RhbmNlLCAwLCBjbWRzaG93KTsKCglyZXR1cm4gMDsKfQo=