LyoKICogV2luZWZpbGUKICoKICogQ29weXJpZ2h0IDIwMDAsIDIwMDMsIDIwMDQsIDIwMDUgTWFydGluIEZ1Y2hzCiAqIENvcHlyaWdodCAyMDA2IEphc29uIEdyZWVuCiAqCiAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICogbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwogKiBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieSB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIKICogdmVyc2lvbiAyLjEgb2YgdGhlIExpY2Vuc2UsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCiAqCiAqIFRoaXMgbGlicmFyeSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAogKiBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQogKiBMZXNzZXIgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgogKgogKiBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCiAqIExpY2Vuc2UgYWxvbmcgd2l0aCB0aGlzIGxpYnJhcnk7IGlmIG5vdCwgd3JpdGUgdG8gdGhlIEZyZWUgU29mdHdhcmUKICogRm91bmRhdGlvbiwgSW5jLiwgNTEgRnJhbmtsaW4gU3QsIEZpZnRoIEZsb29yLCBCb3N0b24sIE1BIDAyMTEwLTEzMDEsIFVTQQogKi8KCiNpZmRlZiBfX1dJTkVfXwojaW5jbHVkZSAiY29uZmlnLmgiCiNpbmNsdWRlICJ3aW5lL3BvcnQuaCIKCi8qIGZvciB1bml4IGZpbGVzeXN0ZW0gZnVuY3Rpb24gY2FsbHMgKi8KI2luY2x1ZGUgPHN5cy9zdGF0Lmg+CiNpbmNsdWRlIDxzeXMvdHlwZXMuaD4KI2luY2x1ZGUgPGRpcmVudC5oPgojZW5kaWYKCiNkZWZpbmUgQ09CSk1BQ1JPUwoKI2luY2x1ZGUgIndpbmVmaWxlLmgiCiNpbmNsdWRlICJyZXNvdXJjZS5oIgoKI2lmZGVmIF9OT19FWFRFTlNJT05TCiN1bmRlZiBfTEVGVF9GSUxFUwojZW5kaWYKCiNpZm5kZWYgX01BWF9QQVRICiNkZWZpbmUgX01BWF9EUklWRSAgICAgICAgICAzCiNkZWZpbmUgX01BWF9GTkFNRSAgICAgICAgICAyNTYKI2RlZmluZSBfTUFYX0RJUiAgICAgICAgICAgIF9NQVhfRk5BTUUKI2RlZmluZSBfTUFYX0VYVCAgICAgICAgICAgIF9NQVhfRk5BTUUKI2RlZmluZSBfTUFYX1BBVEggICAgICAgICAgIDI2MAojZW5kaWYKCiNpZmRlZiBOT05BTUVMRVNTVU5JT04KI2RlZmluZQlVTklPTl9NRU1CRVIoeCkgRFVNTVlVTklPTk5BTUUueAojZWxzZQojZGVmaW5lCVVOSU9OX01FTUJFUih4KSB4CiNlbmRpZgoKCiNpZmRlZiBfU0hFTExfRk9MREVSUwojZGVmaW5lCURFRkFVTFRfU1BMSVRfUE9TCTMwMAojZWxzZQojZGVmaW5lCURFRkFVTFRfU1BMSVRfUE9TCTIwMAojZW5kaWYKCnN0YXRpYyBjb25zdCBXQ0hBUiByZWdpc3RyeV9rZXlbXSA9IHsgJ1MnLCdvJywnZicsJ3QnLCd3JywnYScsJ3InLCdlJywnXFwnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdXJywnaScsJ24nLCdlJywnXFwnLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdXJywnaScsJ24nLCdlJywnRicsJ2knLCdsJywnZScsJ1wwJ307CnN0YXRpYyBjb25zdCBXQ0hBUiByZWdfc3RhcnRfeFtdID0geyAncycsJ3QnLCdhJywncicsJ3QnLCdYJywnXDAnfTsKc3RhdGljIGNvbnN0IFdDSEFSIHJlZ19zdGFydF95W10gPSB7ICdzJywndCcsJ2EnLCdyJywndCcsJ1knLCdcMCd9OwpzdGF0aWMgY29uc3QgV0NIQVIgcmVnX3dpZHRoW10gPSB7ICd3JywnaScsJ2QnLCd0JywnaCcsJ1wwJ307CnN0YXRpYyBjb25zdCBXQ0hBUiByZWdfaGVpZ2h0W10gPSB7ICdoJywnZScsJ2knLCdnJywnaCcsJ3QnLCdcMCd9OwoKZW51bSBFTlRSWV9UWVBFIHsKCUVUX1dJTkRPV1MsCglFVF9VTklYLAojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCUVUX1NIRUxMCiNlbmRpZgp9OwoKdHlwZWRlZiBzdHJ1Y3QgX0VudHJ5IHsKCXN0cnVjdCBfRW50cnkqCW5leHQ7CglzdHJ1Y3QgX0VudHJ5Kglkb3duOwoJc3RydWN0IF9FbnRyeSoJdXA7CgoJQk9PTAkJCWV4cGFuZGVkOwoJQk9PTAkJCXNjYW5uZWQ7CglpbnQJCQkJbGV2ZWw7CgoJV0lOMzJfRklORF9EQVRBCWRhdGE7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCglCWV9IQU5ETEVfRklMRV9JTkZPUk1BVElPTiBiaGZpOwoJQk9PTAkJCWJoZmlfdmFsaWQ7CgllbnVtIEVOVFJZX1RZUEUJZXR5cGU7CiNlbmRpZgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCUxQSVRFTUlETElTVAlwaWRsOwoJSVNoZWxsRm9sZGVyKglmb2xkZXI7CglISUNPTgkJCWhpY29uOwojZW5kaWYKfSBFbnRyeTsKCnR5cGVkZWYgc3RydWN0IHsKCUVudHJ5CWVudHJ5OwoJVENIQVIJcGF0aFtNQVhfUEFUSF07CglUQ0hBUgl2b2xuYW1lW19NQVhfRk5BTUVdOwoJVENIQVIJZnNbX01BWF9ESVJdOwoJRFdPUkQJZHJpdmVfdHlwZTsKCURXT1JECWZzX2ZsYWdzOwp9IFJvb3Q7CgplbnVtIENPTFVNTl9GTEFHUyB7CglDT0xfU0laRQkJPSAweDAxLAoJQ09MX0RBVEUJCT0gMHgwMiwKCUNPTF9USU1FCQk9IDB4MDQsCglDT0xfQVRUUklCVVRFUwk9IDB4MDgsCglDT0xfRE9TTkFNRVMJPSAweDEwLAojaWZkZWYgX05PX0VYVEVOU0lPTlMKCUNPTF9BTEwgPSBDT0xfU0laRXxDT0xfREFURXxDT0xfVElNRXxDT0xfQVRUUklCVVRFU3xDT0xfRE9TTkFNRVMKI2Vsc2UKCUNPTF9JTkRFWAkJPSAweDIwLAoJQ09MX0xJTktTCQk9IDB4NDAsCglDT0xfQUxMID0gQ09MX1NJWkV8Q09MX0RBVEV8Q09MX1RJTUV8Q09MX0FUVFJJQlVURVN8Q09MX0RPU05BTUVTfENPTF9JTkRFWHxDT0xfTElOS1MKI2VuZGlmCn07Cgp0eXBlZGVmIGVudW0gewoJU09SVF9OQU1FLAoJU09SVF9FWFQsCglTT1JUX1NJWkUsCglTT1JUX0RBVEUKfSBTT1JUX09SREVSOwoKdHlwZWRlZiBzdHJ1Y3QgewoJSFdORAlod25kOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCglIV05ECWh3bmRIZWFkZXI7CiNlbmRpZgoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwojZGVmaW5lCUNPTFVNTlMJMTAKI2Vsc2UKI2RlZmluZQlDT0xVTU5TCTUKI2VuZGlmCglpbnQJCXdpZHRoc1tDT0xVTU5TXTsKCWludAkJcG9zaXRpb25zW0NPTFVNTlMrMV07CgoJQk9PTAl0cmVlUGFuZTsKCWludAkJdmlzaWJsZV9jb2xzOwoJRW50cnkqCXJvb3Q7CglFbnRyeSoJY3VyOwp9IFBhbmU7Cgp0eXBlZGVmIHN0cnVjdCB7CglIV05ECWh3bmQ7CglQYW5lCWxlZnQ7CglQYW5lCXJpZ2h0OwoJaW50CQlmb2N1c19wYW5lOwkJLyogMDogbGVmdCAgMTogcmlnaHQgKi8KCVdJTkRPV1BMQUNFTUVOVCBwb3M7CglpbnQJCXNwbGl0X3BvczsKCUJPT0wJaGVhZGVyX3dkdGhzX29rOwoKCVRDSEFSCXBhdGhbTUFYX1BBVEhdOwoJVENIQVIJZmlsdGVyX3BhdHRlcm5bTUFYX1BBVEhdOwoJaW50CQlmaWx0ZXJfZmxhZ3M7CglSb290CXJvb3Q7CgoJU09SVF9PUkRFUiBzb3J0T3JkZXI7Cn0gQ2hpbGRXbmQ7CgoKCnN0YXRpYyB2b2lkIHJlYWRfZGlyZWN0b3J5KEVudHJ5KiBkaXIsIExQQ1RTVFIgcGF0aCwgU09SVF9PUkRFUiBzb3J0T3JkZXIsIEhXTkQgaHduZCk7CnN0YXRpYyB2b2lkIHNldF9jdXJkaXIoQ2hpbGRXbmQqIGNoaWxkLCBFbnRyeSogZW50cnksIGludCBpZHgsIEhXTkQgaHduZCk7CnN0YXRpYyB2b2lkIHJlZnJlc2hfY2hpbGQoQ2hpbGRXbmQqIGNoaWxkKTsKc3RhdGljIHZvaWQgcmVmcmVzaF9kcml2ZXModm9pZCk7CnN0YXRpYyB2b2lkIGdldF9wYXRoKEVudHJ5KiBkaXIsIFBUU1RSIHBhdGgpOwpzdGF0aWMgdm9pZCBmb3JtYXRfZGF0ZShjb25zdCBGSUxFVElNRSogZnQsIFRDSEFSKiBidWZmZXIsIGludCB2aXNpYmxlX2NvbHMpOwoKc3RhdGljIExSRVNVTFQgQ0FMTEJBQ0sgRnJhbWVXbmRQcm9jKEhXTkQgaHduZCwgVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKTsKc3RhdGljIExSRVNVTFQgQ0FMTEJBQ0sgQ2hpbGRXbmRQcm9jKEhXTkQgaHduZCwgVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKTsKc3RhdGljIExSRVNVTFQgQ0FMTEJBQ0sgVHJlZVduZFByb2MoSFdORCBod25kLCBVSU5UIG5tc2csIFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pOwoKCi8qIGdsb2JhbHMgKi8KV0lORUZJTEVfR0xPQkFMUyBHbG9iYWxzOwoKc3RhdGljIGludCBsYXN0X3NwbGl0OwoKLyogc29tZSBjb21tb24gc3RyaW5nIGNvbnN0YW50cyAqLwpzdGF0aWMgY29uc3QgVENIQVIgc0VtcHR5W10gPSB7J1wwJ307CnN0YXRpYyBjb25zdCBXQ0hBUiBzU3BhY2VbXSA9IHsnICcsICdcMCd9OwpzdGF0aWMgY29uc3QgVENIQVIgc051bUZtdFtdID0geyclJywnZCcsJ1wwJ307CnN0YXRpYyBjb25zdCBUQ0hBUiBzUU1hcmtzW10gPSB7Jz8nLCc/JywnPycsJ1wwJ307CgovKiB3aW5kb3cgY2xhc3MgbmFtZXMgKi8Kc3RhdGljIGNvbnN0IFRDSEFSIHNXSU5FRklMRUZSQU1FW10gPSB7J1cnLCdGJywnUycsJ18nLCdGJywncicsJ2EnLCdtJywnZScsJ1wwJ307CnN0YXRpYyBjb25zdCBUQ0hBUiBzV0lORUZJTEVUUkVFW10gPSB7J1cnLCdGJywnUycsJ18nLCdUJywncicsJ2UnLCdlJywnXDAnfTsKCiNpZmRlZiBfTVNDX1ZFUgovKiAjZGVmaW5lIExPTkdMT05HQVJHIF9UKCJJNjQiKSAqLwpzdGF0aWMgY29uc3QgVENIQVIgc0xvbmdIZXhGbXRbXSA9IHsnJScsJ0knLCc2JywnNCcsJ1gnLCdcMCd9OwpzdGF0aWMgY29uc3QgVENIQVIgc0xvbmdOdW1GbXRbXSA9IHsnJScsJ0knLCc2JywnNCcsJ2QnLCdcMCd9OwojZWxzZQovKiAjZGVmaW5lIExPTkdMT05HQVJHIF9UKCJMIikgKi8Kc3RhdGljIGNvbnN0IFRDSEFSIHNMb25nSGV4Rm10W10gPSB7JyUnLCdMJywnWCcsJ1wwJ307CnN0YXRpYyBjb25zdCBUQ0hBUiBzTG9uZ051bUZtdFtdID0geyclJywnTCcsJ2QnLCdcMCd9OwojZW5kaWYKCgovKiBsb2FkIHJlc291cmNlIHN0cmluZyAqLwpzdGF0aWMgTFBUU1RSIGxvYWRfc3RyaW5nKExQVFNUUiBidWZmZXIsIFVJTlQgaWQpCnsKCUxvYWRTdHJpbmcoR2xvYmFscy5oSW5zdGFuY2UsIGlkLCBidWZmZXIsIEJVRkZFUl9MRU4pOwoKCXJldHVybiBidWZmZXI7Cn0KCiNkZWZpbmUgUlMoYiwgaSkgbG9hZF9zdHJpbmcoYiwgaSkKCgovKiBkaXNwbGF5IGVycm9yIG1lc3NhZ2UgZm9yIHRoZSBzcGVjaWZpZWQgV0lOMzIgZXJyb3IgY29kZSAqLwpzdGF0aWMgdm9pZCBkaXNwbGF5X2Vycm9yKEhXTkQgaHduZCwgRFdPUkQgZXJyb3IpCnsKCVRDSEFSIGIxW0JVRkZFUl9MRU5dLCBiMltCVUZGRVJfTEVOXTsKCVBUU1RSIG1zZzsKCglpZiAoRm9ybWF0TWVzc2FnZShGT1JNQVRfTUVTU0FHRV9BTExPQ0FURV9CVUZGRVJ8Rk9STUFUX01FU1NBR0VfRlJPTV9TWVNURU0sCgkJMCwgZXJyb3IsIE1BS0VMQU5HSUQoTEFOR19ORVVUUkFMLFNVQkxBTkdfREVGQVVMVCksIChQVFNUUikmbXNnLCAwLCBOVUxMKSkKCQlNZXNzYWdlQm94KGh3bmQsIG1zZywgUlMoYjIsSURTX1dJTkVGSUxFKSwgTUJfT0spOwoJZWxzZQoJCU1lc3NhZ2VCb3goaHduZCwgUlMoYjEsSURTX0VSUk9SKSwgUlMoYjIsSURTX1dJTkVGSUxFKSwgTUJfT0spOwoKCUxvY2FsRnJlZShtc2cpOwp9CgoKLyogZGlzcGxheSBuZXR3b3JrIGVycm9yIG1lc3NhZ2UgdXNpbmcgV05ldEdldExhc3RFcnJvcigpICovCnN0YXRpYyB2b2lkIGRpc3BsYXlfbmV0d29ya19lcnJvcihIV05EIGh3bmQpCnsKCVRDSEFSIG1zZ1tCVUZGRVJfTEVOXSwgcHJvdmlkZXJbQlVGRkVSX0xFTl0sIGIyW0JVRkZFUl9MRU5dOwoJRFdPUkQgZXJyb3I7CgoJaWYgKFdOZXRHZXRMYXN0RXJyb3IoJmVycm9yLCBtc2csIEJVRkZFUl9MRU4sIHByb3ZpZGVyLCBCVUZGRVJfTEVOKSA9PSBOT19FUlJPUikKCQlNZXNzYWdlQm94KGh3bmQsIG1zZywgUlMoYjIsSURTX1dJTkVGSUxFKSwgTUJfT0spOwp9CgpzdGF0aWMgVk9JRCBXaW5lTGljZW5zZShIV05EIFduZCkKewoJV0NIQVIgY2FwWzIwXSwgdGV4dFsxMDI0XTsKCUxvYWRTdHJpbmdXKEdsb2JhbHMuaEluc3RhbmNlLCBJRFNfTElDRU5TRSwgdGV4dCwgMTAyNCk7CglMb2FkU3RyaW5nVyhHbG9iYWxzLmhJbnN0YW5jZSwgSURTX0xJQ0VOU0VfQ0FQVElPTiwgY2FwLCAyMCk7CglNZXNzYWdlQm94VyhXbmQsIHRleHQsIGNhcCwgTUJfSUNPTklORk9STUFUSU9OIHwgTUJfT0spOwp9CgpzdGF0aWMgVk9JRCBXaW5lV2FycmFudHkoSFdORCBXbmQpCnsKCVdDSEFSIGNhcFsyMF0sIHRleHRbMTAyNF07CglMb2FkU3RyaW5nVyhHbG9iYWxzLmhJbnN0YW5jZSwgSURTX1dBUlJBTlRZLCB0ZXh0LCAxMDI0KTsKCUxvYWRTdHJpbmdXKEdsb2JhbHMuaEluc3RhbmNlLCBJRFNfV0FSUkFOVFlfQ0FQVElPTiwgY2FwLCAyMCk7CglNZXNzYWdlQm94VyhXbmQsIHRleHQsIGNhcCwgTUJfSUNPTkVYQ0xBTUFUSU9OIHwgTUJfT0spOwp9CgpzdGF0aWMgaW5saW5lIEJPT0wgZ2V0X2NoZWNrKEhXTkQgaHduZCwgSU5UIGlkKQp7CglyZXR1cm4gQlNUX0NIRUNLRUQmU2VuZE1lc3NhZ2VXKEdldERsZ0l0ZW0oaHduZCwgaWQpLCBCTV9HRVRTVEFURSwgMCwgMCk7Cn0KCnN0YXRpYyBpbmxpbmUgSU5UIHNldF9jaGVjayhIV05EIGh3bmQsIElOVCBpZCwgQk9PTCBvbikKewoJcmV0dXJuIFNlbmRNZXNzYWdlVyhHZXREbGdJdGVtKGh3bmQsIGlkKSwgQk1fU0VUQ0hFQ0ssIG9uP0JTVF9DSEVDS0VEOkJTVF9VTkNIRUNLRUQsIDApOwp9CgpzdGF0aWMgaW5saW5lIHZvaWQgY2hvb3NlX2ZvbnQoSFdORCBod25kKQp7CiAgICAgICAgV0NIQVIgZGxnX25hbWVbQlVGRkVSX0xFTl0sIGRsZ19pbmZvW0JVRkZFUl9MRU5dOwogICAgICAgIENIT09TRUZPTlRXIGNoRm9udDsKICAgICAgICBMT0dGT05UVyBsRm9udDsKCiAgICAgICAgSERDIGhkYyA9IEdldERDKGh3bmQpOwogICAgICAgIGNoRm9udC5sU3RydWN0U2l6ZSA9IHNpemVvZihDSE9PU0VGT05UKTsKICAgICAgICBjaEZvbnQuaHduZE93bmVyID0gaHduZDsKICAgICAgICBjaEZvbnQuaERDID0gTlVMTDsKICAgICAgICBjaEZvbnQubHBMb2dGb250ID0gJmxGb250OwogICAgICAgIGNoRm9udC5GbGFncyA9IENGX1NDUkVFTkZPTlRTIHwgQ0ZfRk9SQ0VGT05URVhJU1QgfCBDRl9MSU1JVFNJWkUgfCBDRl9OT1NDUklQVFNFTDsKICAgICAgICBjaEZvbnQucmdiQ29sb3JzID0gUkdCKDAsMCwwKTsKICAgICAgICBjaEZvbnQubEN1c3REYXRhID0gMDsKICAgICAgICBjaEZvbnQubHBmbkhvb2sgPSBOVUxMOwogICAgICAgIGNoRm9udC5scFRlbXBsYXRlTmFtZSA9IE5VTEw7CiAgICAgICAgY2hGb250LmhJbnN0YW5jZSA9IEdsb2JhbHMuaEluc3RhbmNlOwogICAgICAgIGNoRm9udC5scHN6U3R5bGUgPSBOVUxMOwogICAgICAgIGNoRm9udC5uRm9udFR5cGUgPSBTSU1VTEFURURfRk9OVFRZUEU7CiAgICAgICAgY2hGb250Lm5TaXplTWluID0gMDsKICAgICAgICBjaEZvbnQublNpemVNYXggPSAyNDsKCiAgICAgICAgaWYgKENob29zZUZvbnRXKCZjaEZvbnQpKSB7CiAgICAgICAgICAgICAgICBIV05EIGNoaWxkV25kOwogICAgICAgICAgICAgICAgSEZPTlQgaEZvbnRPbGQ7CgogICAgICAgICAgICAgICAgRGVsZXRlT2JqZWN0KEdsb2JhbHMuaGZvbnQpOwogICAgICAgICAgICAgICAgR2xvYmFscy5oZm9udCA9IENyZWF0ZUZvbnRJbmRpcmVjdFcoJmxGb250KTsKICAgICAgICAgICAgICAgIGhGb250T2xkID0gU2VsZWN0T2JqZWN0KGhkYywgR2xvYmFscy5oZm9udCk7CiAgICAgICAgICAgICAgICBHZXRUZXh0RXh0ZW50UG9pbnQzMlcoaGRjLCBzU3BhY2UsIDEsICZHbG9iYWxzLnNwYWNlU2l6ZSk7CgogICAgICAgICAgICAgICAgLyogY2hhbmdlIGZvbnQgaW4gYWxsIG9wZW4gY2hpbGQgd2luZG93cyAqLwogICAgICAgICAgICAgICAgZm9yKGNoaWxkV25kPUdldFdpbmRvdyhHbG9iYWxzLmhtZGljbGllbnQsR1dfQ0hJTEQpOyBjaGlsZFduZDsgY2hpbGRXbmQ9R2V0TmV4dFdpbmRvdyhjaGlsZFduZCxHV19IV05ETkVYVCkpIHsKICAgICAgICAgICAgICAgICAgICAgICAgQ2hpbGRXbmQqIGNoaWxkID0gKENoaWxkV25kKikgR2V0V2luZG93TG9uZ1B0clcoY2hpbGRXbmQsIEdXTFBfVVNFUkRBVEEpOwogICAgICAgICAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoY2hpbGQtPmxlZnQuaHduZCwgV01fU0VURk9OVCwgKFdQQVJBTSlHbG9iYWxzLmhmb250LCBUUlVFKTsKICAgICAgICAgICAgICAgICAgICAgICAgU2VuZE1lc3NhZ2VXKGNoaWxkLT5yaWdodC5od25kLCBXTV9TRVRGT05ULCAoV1BBUkFNKUdsb2JhbHMuaGZvbnQsIFRSVUUpOwogICAgICAgICAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoY2hpbGQtPmxlZnQuaHduZCwgTEJfU0VUSVRFTUhFSUdIVCwgMSwgbWF4KEdsb2JhbHMuc3BhY2VTaXplLmN5LElNQUdFX0hFSUdIVCszKSk7CiAgICAgICAgICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyhjaGlsZC0+cmlnaHQuaHduZCwgTEJfU0VUSVRFTUhFSUdIVCwgMSwgbWF4KEdsb2JhbHMuc3BhY2VTaXplLmN5LElNQUdFX0hFSUdIVCszKSk7CiAgICAgICAgICAgICAgICAgICAgICAgIEludmFsaWRhdGVSZWN0KGNoaWxkLT5sZWZ0Lmh3bmQsIE5VTEwsIFRSVUUpOwogICAgICAgICAgICAgICAgICAgICAgICBJbnZhbGlkYXRlUmVjdChjaGlsZC0+cmlnaHQuaHduZCwgTlVMTCwgVFJVRSk7CiAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgU2VsZWN0T2JqZWN0KGhkYywgaEZvbnRPbGQpOwogICAgICAgIH0KICAgICAgICBlbHNlIGlmIChDb21tRGxnRXh0ZW5kZWRFcnJvcigpKSB7CiAgICAgICAgICAgICAgICBMb2FkU3RyaW5nVyhHbG9iYWxzLmhJbnN0YW5jZSwgSURTX0ZPTlRfU0VMX0RMR19OQU1FLCBkbGdfbmFtZSwgQlVGRkVSX0xFTik7CiAgICAgICAgICAgICAgICBMb2FkU3RyaW5nVyhHbG9iYWxzLmhJbnN0YW5jZSwgSURTX0ZPTlRfU0VMX0VSUk9SLCBkbGdfaW5mbywgQlVGRkVSX0xFTik7CiAgICAgICAgICAgICAgICBNZXNzYWdlQm94Vyhod25kLCBkbGdfaW5mbywgZGxnX25hbWUsIE1CX09LKTsKICAgICAgICB9CgogICAgICAgIFJlbGVhc2VEQyhod25kLCBoZGMpOwp9CgojaWZkZWYgX19XSU5FX18KCiNpZmRlZiBVTklDT0RFCgovKiBjYWxsIHZzd3ByaW50ZigpIGluIG1zdmNydC5kbGwgKi8KLypUT0RPOiBmaXggc3dwcmludGYoKSBpbiBub24tbXN2Y3J0IG1vZGUsIHNvIHRoYXQgdGhpcyBkeW5hbWljIGxpbmtpbmcgZnVuY3Rpb24gY2FuIGJlIHJlbW92ZWQgKi8Kc3RhdGljIGludCBtc3ZjcnRfc3dwcmludGYoV0NIQVIqIGJ1ZmZlciwgY29uc3QgV0NIQVIqIGZtdCwgLi4uKQp7CglzdGF0aWMgaW50IChfX2NkZWNsICpwdnN3cHJpbnRmKShXQ0hBUiosIGNvbnN0IFdDSEFSKiwgdmFfbGlzdCkgPSBOVUxMOwoJdmFfbGlzdCBhcDsKCWludCByZXQ7CgoJaWYgKCFwdnN3cHJpbnRmKSB7CgkJSE1PRFVMRSBoTW9kTXN2Y3J0ID0gTG9hZExpYnJhcnlBKCJtc3ZjcnQiKTsKCQlwdnN3cHJpbnRmID0gKGludChfX2NkZWNsKikoV0NIQVIqLGNvbnN0IFdDSEFSKix2YV9saXN0KSkgR2V0UHJvY0FkZHJlc3MoaE1vZE1zdmNydCwgInZzd3ByaW50ZiIpOwoJfQoKCXZhX3N0YXJ0KGFwLCBmbXQpOwoJcmV0ID0gKCpwdnN3cHJpbnRmKShidWZmZXIsIGZtdCwgYXApOwoJdmFfZW5kKGFwKTsKCglyZXR1cm4gcmV0Owp9CgpzdGF0aWMgTFBDV1NUUiBteV93Y3NyY2hyKExQQ1dTVFIgc3RyLCBXQ0hBUiBjKQp7CglMUENXU1RSIHAgPSBzdHI7CgoJd2hpbGUoKnApCgkJKytwOwoKCWRvIHsKCQlpZiAoLS1wIDwgc3RyKQoJCQlyZXR1cm4gTlVMTDsKCX0gd2hpbGUoKnAgIT0gYyk7CgoJcmV0dXJuIHA7Cn0KCiNkZWZpbmUgX3Rjc3JjaHIgbXlfd2NzcmNocgojZWxzZQkvKiBVTklDT0RFICovCiNkZWZpbmUgX3Rjc3JjaHIgc3RycmNocgojZW5kaWYJLyogVU5JQ09ERSAqLwoKI2VuZGlmCS8qIF9fV0lORV9fICovCgoKLyogYWxsb2NhdGUgYW5kIGluaXRpYWxpc2UgYSBkaXJlY3RvcnkgZW50cnkgKi8Kc3RhdGljIEVudHJ5KiBhbGxvY19lbnRyeSh2b2lkKQp7CglFbnRyeSogZW50cnkgPSBIZWFwQWxsb2MoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgc2l6ZW9mKEVudHJ5KSk7CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCWVudHJ5LT5waWRsID0gTlVMTDsKCWVudHJ5LT5mb2xkZXIgPSBOVUxMOwoJZW50cnktPmhpY29uID0gMDsKI2VuZGlmCgoJcmV0dXJuIGVudHJ5Owp9CgovKiBmcmVlIGEgZGlyZWN0b3J5IGVudHJ5ICovCnN0YXRpYyB2b2lkIGZyZWVfZW50cnkoRW50cnkqIGVudHJ5KQp7CiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKGVudHJ5LT5oaWNvbiAmJiBlbnRyeS0+aGljb24hPShISUNPTiktMSkKCQlEZXN0cm95SWNvbihlbnRyeS0+aGljb24pOwoKCWlmIChlbnRyeS0+Zm9sZGVyICYmIGVudHJ5LT5mb2xkZXIhPUdsb2JhbHMuaURlc2t0b3ApCgkJSVNoZWxsRm9sZGVyX1JlbGVhc2UoZW50cnktPmZvbGRlcik7CgoJaWYgKGVudHJ5LT5waWRsKQoJCUlNYWxsb2NfRnJlZShHbG9iYWxzLmlNYWxsb2MsIGVudHJ5LT5waWRsKTsKI2VuZGlmCgoJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgZW50cnkpOwp9CgovKiByZWN1cnNpdmVseSBmcmVlIGFsbCBjaGlsZCBlbnRyaWVzICovCnN0YXRpYyB2b2lkIGZyZWVfZW50cmllcyhFbnRyeSogZGlyKQp7CglFbnRyeSAqZW50cnksICpuZXh0PWRpci0+ZG93bjsKCglpZiAobmV4dCkgewoJCWRpci0+ZG93biA9IDA7CgoJCWRvIHsKCQkJZW50cnkgPSBuZXh0OwoJCQluZXh0ID0gZW50cnktPm5leHQ7CgoJCQlmcmVlX2VudHJpZXMoZW50cnkpOwoJCQlmcmVlX2VudHJ5KGVudHJ5KTsKCQl9IHdoaWxlKG5leHQpOwoJfQp9CgoKc3RhdGljIHZvaWQgcmVhZF9kaXJlY3Rvcnlfd2luKEVudHJ5KiBkaXIsIExQQ1RTVFIgcGF0aCkKewoJRW50cnkqIGZpcnN0X2VudHJ5ID0gTlVMTDsKCUVudHJ5KiBsYXN0ID0gTlVMTDsKCUVudHJ5KiBlbnRyeTsKCglpbnQgbGV2ZWwgPSBkaXItPmxldmVsICsgMTsKCVdJTjMyX0ZJTkRfREFUQSB3MzJmZDsKCUhBTkRMRSBoRmluZDsKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJSEFORExFIGhGaWxlOwojZW5kaWYKCglUQ0hBUiBidWZmZXJbTUFYX1BBVEhdLCAqcDsKCWZvcihwPWJ1ZmZlcjsgKnBhdGg7ICkKCQkqcCsrID0gKnBhdGgrKzsKCgkqcCsrID0gJ1xcJzsKCXBbMF0gPSAnKic7CglwWzFdID0gJ1wwJzsKCgloRmluZCA9IEZpbmRGaXJzdEZpbGUoYnVmZmVyLCAmdzMyZmQpOwoKCWlmIChoRmluZCAhPSBJTlZBTElEX0hBTkRMRV9WQUxVRSkgewoJCWRvIHsKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJCS8qIGhpZGUgZGlyZWN0b3J5IGVudHJ5ICIuIiAqLwoJCQlpZiAodzMyZmQuZHdGaWxlQXR0cmlidXRlcyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkgewoJCQkJTFBDVFNUUiBuYW1lID0gdzMyZmQuY0ZpbGVOYW1lOwoKCQkJCWlmIChuYW1lWzBdPT0nLicgJiYgbmFtZVsxXT09J1wwJykKCQkJCQljb250aW51ZTsKCQkJfQojZW5kaWYKCQkJZW50cnkgPSBhbGxvY19lbnRyeSgpOwoKCQkJaWYgKCFmaXJzdF9lbnRyeSkKCQkJCWZpcnN0X2VudHJ5ID0gZW50cnk7CgoJCQlpZiAobGFzdCkKCQkJCWxhc3QtPm5leHQgPSBlbnRyeTsKCgkJCW1lbWNweSgmZW50cnktPmRhdGEsICZ3MzJmZCwgc2l6ZW9mKFdJTjMyX0ZJTkRfREFUQSkpOwoJCQllbnRyeS0+ZG93biA9IE5VTEw7CgkJCWVudHJ5LT51cCA9IGRpcjsKCQkJZW50cnktPmV4cGFuZGVkID0gRkFMU0U7CgkJCWVudHJ5LT5zY2FubmVkID0gRkFMU0U7CgkJCWVudHJ5LT5sZXZlbCA9IGxldmVsOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCQllbnRyeS0+ZXR5cGUgPSBFVF9XSU5ET1dTOwoJCQllbnRyeS0+YmhmaV92YWxpZCA9IEZBTFNFOwoKCQkJbHN0cmNweShwLCBlbnRyeS0+ZGF0YS5jRmlsZU5hbWUpOwoKCQkJaEZpbGUgPSBDcmVhdGVGaWxlKGJ1ZmZlciwgR0VORVJJQ19SRUFELCBGSUxFX1NIQVJFX1JFQUR8RklMRV9TSEFSRV9XUklURXxGSUxFX1NIQVJFX0RFTEVURSwKCQkJCQkJCQkwLCBPUEVOX0VYSVNUSU5HLCBGSUxFX0ZMQUdfQkFDS1VQX1NFTUFOVElDUywgMCk7CgoJCQlpZiAoaEZpbGUgIT0gSU5WQUxJRF9IQU5ETEVfVkFMVUUpIHsKCQkJCWlmIChHZXRGaWxlSW5mb3JtYXRpb25CeUhhbmRsZShoRmlsZSwgJmVudHJ5LT5iaGZpKSkKCQkJCQllbnRyeS0+YmhmaV92YWxpZCA9IFRSVUU7CgoJCQkJQ2xvc2VIYW5kbGUoaEZpbGUpOwoJCQl9CiNlbmRpZgoKCQkJbGFzdCA9IGVudHJ5OwoJCX0gd2hpbGUoRmluZE5leHRGaWxlKGhGaW5kLCAmdzMyZmQpKTsKCgkJaWYgKGxhc3QpCgkJCWxhc3QtPm5leHQgPSBOVUxMOwoKCQlGaW5kQ2xvc2UoaEZpbmQpOwoJfQoKCWRpci0+ZG93biA9IGZpcnN0X2VudHJ5OwoJZGlyLT5zY2FubmVkID0gVFJVRTsKfQoKCnN0YXRpYyBFbnRyeSogZmluZF9lbnRyeV93aW4oRW50cnkqIGRpciwgTFBDVFNUUiBuYW1lKQp7CglFbnRyeSogZW50cnk7CgoJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KSB7CgkJTFBDVFNUUiBwID0gbmFtZTsKCQlMUENUU1RSIHEgPSBlbnRyeS0+ZGF0YS5jRmlsZU5hbWU7CgoJCWRvIHsKCQkJaWYgKCEqcCB8fCAqcCA9PSAnXFwnIHx8ICpwID09ICcvJykKCQkJCXJldHVybiBlbnRyeTsKCQl9IHdoaWxlKHRvbG93ZXIoKnArKykgPT0gdG9sb3dlcigqcSsrKSk7CgoJCXAgPSBuYW1lOwoJCXEgPSBlbnRyeS0+ZGF0YS5jQWx0ZXJuYXRlRmlsZU5hbWU7CgoJCWRvIHsKCQkJaWYgKCEqcCB8fCAqcCA9PSAnXFwnIHx8ICpwID09ICcvJykKCQkJCXJldHVybiBlbnRyeTsKCQl9IHdoaWxlKHRvbG93ZXIoKnArKykgPT0gdG9sb3dlcigqcSsrKSk7Cgl9CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgRW50cnkqIHJlYWRfdHJlZV93aW4oUm9vdCogcm9vdCwgTFBDVFNUUiBwYXRoLCBTT1JUX09SREVSIHNvcnRPcmRlciwgSFdORCBod25kKQp7CglUQ0hBUiBidWZmZXJbTUFYX1BBVEhdOwoJRW50cnkqIGVudHJ5ID0gJnJvb3QtPmVudHJ5OwoJTFBDVFNUUiBzID0gcGF0aDsKCVBUU1RSIGQgPSBidWZmZXI7CgoJSENVUlNPUiBvbGRfY3Vyc29yID0gU2V0Q3Vyc29yKExvYWRDdXJzb3IoMCwgSURDX1dBSVQpKTsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCWVudHJ5LT5ldHlwZSA9IEVUX1dJTkRPV1M7CiNlbmRpZgoKCXdoaWxlKGVudHJ5KSB7CgkJd2hpbGUoKnMgJiYgKnMgIT0gJ1xcJyAmJiAqcyAhPSAnLycpCgkJCSpkKysgPSAqcysrOwoKCQl3aGlsZSgqcyA9PSAnXFwnIHx8ICpzID09ICcvJykKCQkJcysrOwoKCQkqZCsrID0gJ1xcJzsKCQkqZCA9ICdcMCc7CgoJCXJlYWRfZGlyZWN0b3J5KGVudHJ5LCBidWZmZXIsIHNvcnRPcmRlciwgaHduZCk7CgoJCWlmIChlbnRyeS0+ZG93bikKCQkJZW50cnktPmV4cGFuZGVkID0gVFJVRTsKCgkJaWYgKCEqcykKCQkJYnJlYWs7CgoJCWVudHJ5ID0gZmluZF9lbnRyeV93aW4oZW50cnksIHMpOwoJfQoKCVNldEN1cnNvcihvbGRfY3Vyc29yKTsKCglyZXR1cm4gZW50cnk7Cn0KCgojaWYgIWRlZmluZWQoX05PX0VYVEVOU0lPTlMpICYmIGRlZmluZWQoX19XSU5FX18pCgpzdGF0aWMgQk9PTCB0aW1lX3RvX2ZpbGV0aW1lKGNvbnN0IHRpbWVfdCogdCwgRklMRVRJTUUqIGZ0aW1lKQp7CglzdHJ1Y3QgdG0qIHRtID0gZ210aW1lKHQpOwoJU1lTVEVNVElNRSBzdGltZTsKCglpZiAoIXRtKQoJCXJldHVybiBGQUxTRTsKCglzdGltZS53WWVhciA9IHRtLT50bV95ZWFyKzE5MDA7CglzdGltZS53TW9udGggPSB0bS0+dG1fbW9uKzE7CgkvKglzdGltZS53RGF5T2ZXZWVrICovCglzdGltZS53RGF5ID0gdG0tPnRtX21kYXk7CglzdGltZS53SG91ciA9IHRtLT50bV9ob3VyOwoJc3RpbWUud01pbnV0ZSA9IHRtLT50bV9taW47CglzdGltZS53U2Vjb25kID0gdG0tPnRtX3NlYzsKCglyZXR1cm4gU3lzdGVtVGltZVRvRmlsZVRpbWUoJnN0aW1lLCBmdGltZSk7Cn0KCnN0YXRpYyB2b2lkIHJlYWRfZGlyZWN0b3J5X3VuaXgoRW50cnkqIGRpciwgTFBDVFNUUiBwYXRoKQp7CglFbnRyeSogZmlyc3RfZW50cnkgPSBOVUxMOwoJRW50cnkqIGxhc3QgPSBOVUxMOwoJRW50cnkqIGVudHJ5OwoJRElSKiBwZGlyOwoKCWludCBsZXZlbCA9IGRpci0+bGV2ZWwgKyAxOwojaWZkZWYgVU5JQ09ERQoJY2hhciBjcGF0aFtNQVhfUEFUSF07CgoJV2lkZUNoYXJUb011bHRpQnl0ZShDUF9VTklYQ1AsIDAsIHBhdGgsIC0xLCBjcGF0aCwgTUFYX1BBVEgsIE5VTEwsIE5VTEwpOwojZWxzZQoJY29uc3QgY2hhciogY3BhdGggPSBwYXRoOwojZW5kaWYKCglwZGlyID0gb3BlbmRpcihjcGF0aCk7CgoJaWYgKHBkaXIpIHsKCQlzdHJ1Y3Qgc3RhdCBzdDsKCQlzdHJ1Y3QgZGlyZW50KiBlbnQ7CgkJY2hhciBidWZmZXJbTUFYX1BBVEhdLCAqcDsKCQljb25zdCBjaGFyKiBzOwoKCQlmb3IocD1idWZmZXIscz1jcGF0aDsgKnM7ICkKCQkJKnArKyA9ICpzKys7CgoJCWlmIChwPT1idWZmZXIgfHwgcFstMV0hPScvJykKCQkJKnArKyA9ICcvJzsKCgkJd2hpbGUoKGVudD1yZWFkZGlyKHBkaXIpKSkgewoJCQllbnRyeSA9IGFsbG9jX2VudHJ5KCk7CgoJCQlpZiAoIWZpcnN0X2VudHJ5KQoJCQkJZmlyc3RfZW50cnkgPSBlbnRyeTsKCgkJCWlmIChsYXN0KQoJCQkJbGFzdC0+bmV4dCA9IGVudHJ5OwoKCQkJZW50cnktPmV0eXBlID0gRVRfVU5JWDsKCgkJCXN0cmNweShwLCBlbnQtPmRfbmFtZSk7CiNpZmRlZiBVTklDT0RFCgkJCU11bHRpQnl0ZVRvV2lkZUNoYXIoQ1BfVU5JWENQLCAwLCBwLCAtMSwgZW50cnktPmRhdGEuY0ZpbGVOYW1lLCBNQVhfUEFUSCk7CiNlbHNlCgkJCWxzdHJjcHkoZW50cnktPmRhdGEuY0ZpbGVOYW1lLCBwKTsKI2VuZGlmCgoJCQlpZiAoIXN0YXQoYnVmZmVyLCAmc3QpKSB7CgkJCQllbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzID0gcFswXT09Jy4nPyBGSUxFX0FUVFJJQlVURV9ISURERU46IDA7CgoJCQkJaWYgKFNfSVNESVIoc3Quc3RfbW9kZSkpCgkJCQkJZW50cnktPmRhdGEuZHdGaWxlQXR0cmlidXRlcyB8PSBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk7CgoJCQkJZW50cnktPmRhdGEubkZpbGVTaXplTG93ID0gc3Quc3Rfc2l6ZSAmIDB4RkZGRkZGRkY7CgkJCQllbnRyeS0+ZGF0YS5uRmlsZVNpemVIaWdoID0gc3Quc3Rfc2l6ZSA+PiAzMjsKCgkJCQltZW1zZXQoJmVudHJ5LT5kYXRhLmZ0Q3JlYXRpb25UaW1lLCAwLCBzaXplb2YoRklMRVRJTUUpKTsKCQkJCXRpbWVfdG9fZmlsZXRpbWUoJnN0LnN0X2F0aW1lLCAmZW50cnktPmRhdGEuZnRMYXN0QWNjZXNzVGltZSk7CgkJCQl0aW1lX3RvX2ZpbGV0aW1lKCZzdC5zdF9tdGltZSwgJmVudHJ5LT5kYXRhLmZ0TGFzdFdyaXRlVGltZSk7CgoJCQkJZW50cnktPmJoZmkubkZpbGVJbmRleExvdyA9IGVudC0+ZF9pbm87CgkJCQllbnRyeS0+YmhmaS5uRmlsZUluZGV4SGlnaCA9IDA7CgoJCQkJZW50cnktPmJoZmkubk51bWJlck9mTGlua3MgPSBzdC5zdF9ubGluazsKCgkJCQllbnRyeS0+YmhmaV92YWxpZCA9IFRSVUU7CgkJCX0gZWxzZSB7CgkJCQllbnRyeS0+ZGF0YS5uRmlsZVNpemVMb3cgPSAwOwoJCQkJZW50cnktPmRhdGEubkZpbGVTaXplSGlnaCA9IDA7CgkJCQllbnRyeS0+YmhmaV92YWxpZCA9IEZBTFNFOwoJCQl9CgoJCQllbnRyeS0+ZG93biA9IE5VTEw7CgkJCWVudHJ5LT51cCA9IGRpcjsKCQkJZW50cnktPmV4cGFuZGVkID0gRkFMU0U7CgkJCWVudHJ5LT5zY2FubmVkID0gRkFMU0U7CgkJCWVudHJ5LT5sZXZlbCA9IGxldmVsOwoKCQkJbGFzdCA9IGVudHJ5OwoJCX0KCgkJaWYgKGxhc3QpCgkJCWxhc3QtPm5leHQgPSBOVUxMOwoKCQljbG9zZWRpcihwZGlyKTsKCX0KCglkaXItPmRvd24gPSBmaXJzdF9lbnRyeTsKCWRpci0+c2Nhbm5lZCA9IFRSVUU7Cn0KCnN0YXRpYyBFbnRyeSogZmluZF9lbnRyeV91bml4KEVudHJ5KiBkaXIsIExQQ1RTVFIgbmFtZSkKewoJRW50cnkqIGVudHJ5OwoKCWZvcihlbnRyeT1kaXItPmRvd247IGVudHJ5OyBlbnRyeT1lbnRyeS0+bmV4dCkgewoJCUxQQ1RTVFIgcCA9IG5hbWU7CgkJTFBDVFNUUiBxID0gZW50cnktPmRhdGEuY0ZpbGVOYW1lOwoKCQlkbyB7CgkJCWlmICghKnAgfHwgKnAgPT0gJy8nKQoJCQkJcmV0dXJuIGVudHJ5OwoJCX0gd2hpbGUoKnArKyA9PSAqcSsrKTsKCX0KCglyZXR1cm4gMDsKfQoKc3RhdGljIEVudHJ5KiByZWFkX3RyZWVfdW5peChSb290KiByb290LCBMUENUU1RSIHBhdGgsIFNPUlRfT1JERVIgc29ydE9yZGVyLCBIV05EIGh3bmQpCnsKCVRDSEFSIGJ1ZmZlcltNQVhfUEFUSF07CglFbnRyeSogZW50cnkgPSAmcm9vdC0+ZW50cnk7CglMUENUU1RSIHMgPSBwYXRoOwoJUFRTVFIgZCA9IGJ1ZmZlcjsKCglIQ1VSU09SIG9sZF9jdXJzb3IgPSBTZXRDdXJzb3IoTG9hZEN1cnNvcigwLCBJRENfV0FJVCkpOwoKCWVudHJ5LT5ldHlwZSA9IEVUX1VOSVg7CgoJd2hpbGUoZW50cnkpIHsKCQl3aGlsZSgqcyAmJiAqcyAhPSAnLycpCgkJCSpkKysgPSAqcysrOwoKCQl3aGlsZSgqcyA9PSAnLycpCgkJCXMrKzsKCgkJKmQrKyA9ICcvJzsKCQkqZCA9ICdcMCc7CgoJCXJlYWRfZGlyZWN0b3J5KGVudHJ5LCBidWZmZXIsIHNvcnRPcmRlciwgaHduZCk7CgoJCWlmIChlbnRyeS0+ZG93bikKCQkJZW50cnktPmV4cGFuZGVkID0gVFJVRTsKCgkJaWYgKCEqcykKCQkJYnJlYWs7CgoJCWVudHJ5ID0gZmluZF9lbnRyeV91bml4KGVudHJ5LCBzKTsKCX0KCglTZXRDdXJzb3Iob2xkX2N1cnNvcik7CgoJcmV0dXJuIGVudHJ5Owp9CgojZW5kaWYgLyogIWRlZmluZWQoX05PX0VYVEVOU0lPTlMpICYmIGRlZmluZWQoX19XSU5FX18pICovCgoKI2lmZGVmIF9TSEVMTF9GT0xERVJTCgojaWZkZWYgVU5JQ09ERQojZGVmaW5lCWdldF9zdHJyZXQgZ2V0X3N0cnJldFcKI2RlZmluZQlwYXRoX2Zyb21fcGlkbCBwYXRoX2Zyb21fcGlkbFcKI2Vsc2UKI2RlZmluZQlnZXRfc3RycmV0IGdldF9zdHJyZXRBCiNkZWZpbmUJcGF0aF9mcm9tX3BpZGwgcGF0aF9mcm9tX3BpZGxBCiNlbmRpZgoKCnN0YXRpYyB2b2lkIGZyZWVfc3RycmV0KFNUUlJFVCogc3RyKQp7CglpZiAoc3RyLT51VHlwZSA9PSBTVFJSRVRfV1NUUikKCQlJTWFsbG9jX0ZyZWUoR2xvYmFscy5pTWFsbG9jLCBzdHItPlVOSU9OX01FTUJFUihwT2xlU3RyKSk7Cn0KCgojaWZuZGVmIFVOSUNPREUKCnN0YXRpYyBMUFNUUiBzdHJjcHluKExQU1RSIGRlc3QsIExQQ1NUUiBzb3VyY2UsIHNpemVfdCBjb3VudCkKewogTFBDU1RSIHM7CiBMUFNUUiBkID0gZGVzdDsKCiBmb3Iocz1zb3VyY2U7IGNvdW50JiYoKmQrKz0qcysrKTsgKQogIGNvdW50LS07CgogcmV0dXJuIGRlc3Q7Cn0KCnN0YXRpYyB2b2lkIGdldF9zdHJyZXRBKFNUUlJFVCogc3RyLCBjb25zdCBTSElURU1JRCogc2hpaWQsIExQU1RSIGJ1ZmZlciwgaW50IGxlbikKewogc3dpdGNoKHN0ci0+dVR5cGUpIHsKICBjYXNlIFNUUlJFVF9XU1RSOgoJV2lkZUNoYXJUb011bHRpQnl0ZShDUF9BQ1AsIDAsIHN0ci0+VU5JT05fTUVNQkVSKHBPbGVTdHIpLCAtMSwgYnVmZmVyLCBsZW4sIE5VTEwsIE5VTEwpOwoJYnJlYWs7CgogIGNhc2UgU1RSUkVUX09GRlNFVDoKCXN0cmNweW4oYnVmZmVyLCAoTFBDU1RSKXNoaWlkK3N0ci0+VU5JT05fTUVNQkVSKHVPZmZzZXQpLCBsZW4pOwoJYnJlYWs7CgogIGNhc2UgU1RSUkVUX0NTVFI6CglzdHJjcHluKGJ1ZmZlciwgc3RyLT5VTklPTl9NRU1CRVIoY1N0ciksIGxlbik7CiB9Cn0KCnN0YXRpYyBIUkVTVUxUIHBhdGhfZnJvbV9waWRsQShJU2hlbGxGb2xkZXIqIGZvbGRlciwgTFBJVEVNSURMSVNUIHBpZGwsIExQU1RSIGJ1ZmZlciwgaW50IGxlbikKewoJU1RSUkVUIHN0cjsKCgkgLyogU0hHRE5fRk9SUEFSU0lORzogZ2V0IGZ1bGwgcGF0aCBvZiBpZCBsaXN0ICovCglIUkVTVUxUIGhyID0gSVNoZWxsRm9sZGVyX0dldERpc3BsYXlOYW1lT2YoZm9sZGVyLCBwaWRsLCBTSEdETl9GT1JQQVJTSU5HLCAmc3RyKTsKCglpZiAoU1VDQ0VFREVEKGhyKSkgewoJCWdldF9zdHJyZXRBKCZzdHIsICZwaWRsLT5ta2lkLCBidWZmZXIsIGxlbik7CgkJZnJlZV9zdHJyZXQoJnN0cik7Cgl9IGVsc2UKCQlidWZmZXJbMF0gPSAnXDAnOwoKCXJldHVybiBocjsKfQoKI2VuZGlmCgpzdGF0aWMgTFBXU1RSIHdjc2NweW4oTFBXU1RSIGRlc3QsIExQQ1dTVFIgc291cmNlLCBzaXplX3QgY291bnQpCnsKIExQQ1dTVFIgczsKIExQV1NUUiBkID0gZGVzdDsKCiBmb3Iocz1zb3VyY2U7IGNvdW50JiYoKmQrKz0qcysrKTsgKQogIGNvdW50LS07CgogcmV0dXJuIGRlc3Q7Cn0KCnN0YXRpYyB2b2lkIGdldF9zdHJyZXRXKFNUUlJFVCogc3RyLCBjb25zdCBTSElURU1JRCogc2hpaWQsIExQV1NUUiBidWZmZXIsIGludCBsZW4pCnsKIHN3aXRjaChzdHItPnVUeXBlKSB7CiAgY2FzZSBTVFJSRVRfV1NUUjoKCXdjc2NweW4oYnVmZmVyLCBzdHItPlVOSU9OX01FTUJFUihwT2xlU3RyKSwgbGVuKTsKCWJyZWFrOwoKICBjYXNlIFNUUlJFVF9PRkZTRVQ6CglNdWx0aUJ5dGVUb1dpZGVDaGFyKENQX0FDUCwgMCwgKExQQ1NUUilzaGlpZCtzdHItPlVOSU9OX01FTUJFUih1T2Zmc2V0KSwgLTEsIGJ1ZmZlciwgbGVuKTsKCWJyZWFrOwoKICBjYXNlIFNUUlJFVF9DU1RSOgoJTXVsdGlCeXRlVG9XaWRlQ2hhcihDUF9BQ1AsIDAsIHN0ci0+VU5JT05fTUVNQkVSKGNTdHIpLCAtMSwgYnVmZmVyLCBsZW4pOwogfQp9CgoKc3RhdGljIEhSRVNVTFQgbmFtZV9mcm9tX3BpZGwoSVNoZWxsRm9sZGVyKiBmb2xkZXIsIExQSVRFTUlETElTVCBwaWRsLCBMUFRTVFIgYnVmZmVyLCBpbnQgbGVuLCBTSEdETkYgZmxhZ3MpCnsKCVNUUlJFVCBzdHI7CgoJSFJFU1VMVCBociA9IElTaGVsbEZvbGRlcl9HZXREaXNwbGF5TmFtZU9mKGZvbGRlciwgcGlkbCwgZmxhZ3MsICZzdHIpOwoKCWlmIChTVUNDRUVERUQoaHIpKSB7CgkJZ2V0X3N0cnJldCgmc3RyLCAmcGlkbC0+bWtpZCwgYnVmZmVyLCBsZW4pOwoJCWZyZWVfc3RycmV0KCZzdHIpOwoJfSBlbHNlCgkJYnVmZmVyWzBdID0gJ1wwJzsKCglyZXR1cm4gaHI7Cn0KCgpzdGF0aWMgSFJFU1VMVCBwYXRoX2Zyb21fcGlkbFcoSVNoZWxsRm9sZGVyKiBmb2xkZXIsIExQSVRFTUlETElTVCBwaWRsLCBMUFdTVFIgYnVmZmVyLCBpbnQgbGVuKQp7CglTVFJSRVQgc3RyOwoKCSAvKiBTSEdETl9GT1JQQVJTSU5HOiBnZXQgZnVsbCBwYXRoIG9mIGlkIGxpc3QgKi8KCUhSRVNVTFQgaHIgPSBJU2hlbGxGb2xkZXJfR2V0RGlzcGxheU5hbWVPZihmb2xkZXIsIHBpZGwsIFNIR0ROX0ZPUlBBUlNJTkcsICZzdHIpOwoKCWlmIChTVUNDRUVERUQoaHIpKSB7CgkJZ2V0X3N0cnJldFcoJnN0ciwgJnBpZGwtPm1raWQsIGJ1ZmZlciwgbGVuKTsKCQlmcmVlX3N0cnJldCgmc3RyKTsKCX0gZWxzZQoJCWJ1ZmZlclswXSA9ICdcMCc7CgoJcmV0dXJuIGhyOwp9CgoKIC8qIGNyZWF0ZSBhbiBpdGVtIGlkIGxpc3QgZnJvbSBhIGZpbGUgc3lzdGVtIHBhdGggKi8KCnN0YXRpYyBMUElURU1JRExJU1QgZ2V0X3BhdGhfcGlkbChMUFRTVFIgcGF0aCwgSFdORCBod25kKQp7CglMUElURU1JRExJU1QgcGlkbDsKCUhSRVNVTFQgaHI7CglVTE9ORyBsZW47CgojaWZkZWYgVU5JQ09ERQoJTFBXU1RSIGJ1ZmZlciA9IHBhdGg7CiNlbHNlCglXQ0hBUiBidWZmZXJbTUFYX1BBVEhdOwoJTXVsdGlCeXRlVG9XaWRlQ2hhcihDUF9BQ1AsIDAsIHBhdGgsIC0xLCBidWZmZXIsIE1BWF9QQVRIKTsKI2VuZGlmCgoJaHIgPSBJU2hlbGxGb2xkZXJfUGFyc2VEaXNwbGF5TmFtZShHbG9iYWxzLmlEZXNrdG9wLCBod25kLCBOVUxMLCBidWZmZXIsICZsZW4sICZwaWRsLCBOVUxMKTsKCWlmIChGQUlMRUQoaHIpKQoJCXJldHVybiBOVUxMOwoKCXJldHVybiBwaWRsOwp9CgoKIC8qIGNvbnZlcnQgYW4gaXRlbSBpZCBsaXN0IGZyb20gcmVsYXRpdmUgdG8gYWJzb2x1dGUgKD1yZWxhdGl2ZSB0byB0aGUgZGVza3RvcCkgZm9ybWF0ICovCgpzdGF0aWMgTFBJVEVNSURMSVNUIGdldF90b19hYnNvbHV0ZV9waWRsKEVudHJ5KiBlbnRyeSwgSFdORCBod25kKQp7CglpZiAoZW50cnktPnVwICYmIGVudHJ5LT51cC0+ZXR5cGU9PUVUX1NIRUxMKSB7CgkJSVNoZWxsRm9sZGVyKiBmb2xkZXIgPSBlbnRyeS0+dXAtPmZvbGRlcjsKCQlXQ0hBUiBidWZmZXJbTUFYX1BBVEhdOwoKCQlIUkVTVUxUIGhyID0gcGF0aF9mcm9tX3BpZGxXKGZvbGRlciwgZW50cnktPnBpZGwsIGJ1ZmZlciwgTUFYX1BBVEgpOwoKCQlpZiAoU1VDQ0VFREVEKGhyKSkgewoJCQlMUElURU1JRExJU1QgcGlkbDsKCQkJVUxPTkcgbGVuOwoKCQkJaHIgPSBJU2hlbGxGb2xkZXJfUGFyc2VEaXNwbGF5TmFtZShHbG9iYWxzLmlEZXNrdG9wLCBod25kLCBOVUxMLCBidWZmZXIsICZsZW4sICZwaWRsLCBOVUxMKTsKCgkJCWlmIChTVUNDRUVERUQoaHIpKQoJCQkJcmV0dXJuIHBpZGw7CgkJfQoJfSBlbHNlIGlmIChlbnRyeS0+ZXR5cGUgPT0gRVRfV0lORE9XUykgewoJCVRDSEFSIHBhdGhbTUFYX1BBVEhdOwoKCQlnZXRfcGF0aChlbnRyeSwgcGF0aCk7CgoJCXJldHVybiBnZXRfcGF0aF9waWRsKHBhdGgsIGh3bmQpOwoJfSBlbHNlIGlmIChlbnRyeS0+cGlkbCkKCQlyZXR1cm4gSUxDbG9uZShlbnRyeS0+cGlkbCk7CgoJcmV0dXJuIE5VTEw7Cn0KCgpzdGF0aWMgSElDT04gZXh0cmFjdF9pY29uKElTaGVsbEZvbGRlciogZm9sZGVyLCBMUENJVEVNSURMSVNUIHBpZGwpCnsKCUlFeHRyYWN0SWNvbiogcEV4dHJhY3Q7CgoJaWYgKFNVQ0NFRURFRChJU2hlbGxGb2xkZXJfR2V0VUlPYmplY3RPZihmb2xkZXIsIDAsIDEsIChMUENJVEVNSURMSVNUKikmcGlkbCwgJklJRF9JRXh0cmFjdEljb24sIDAsIChMUFZPSUQqKSZwRXh0cmFjdCkpKSB7CgkJVENIQVIgcGF0aFtfTUFYX1BBVEhdOwoJCXVuc2lnbmVkIGZsYWdzOwoJCUhJQ09OIGhpY29uOwoJCWludCBpZHg7CgoJCWlmIChTVUNDRUVERUQoSUV4dHJhY3RJY29uV19HZXRJY29uTG9jYXRpb24ocEV4dHJhY3QsIEdJTF9GT1JTSEVMTCwgcGF0aCwgX01BWF9QQVRILCAmaWR4LCAmZmxhZ3MpKSkgewoJCQlpZiAoIShmbGFncyAmIEdJTF9OT1RGSUxFTkFNRSkpIHsKCQkJCWlmIChpZHggPT0gLTEpCgkJCQkJaWR4ID0gMDsJLyogc3BlY2lhbCBjYXNlIGZvciBzb21lIGNvbnRyb2wgcGFuZWwgYXBwbGljYXRpb25zICovCgoJCQkJaWYgKChpbnQpRXh0cmFjdEljb25FeChwYXRoLCBpZHgsIDAsICZoaWNvbiwgMSkgPiAwKQoJCQkJCWZsYWdzICY9IH5HSUxfRE9OVENBQ0hFOwoJCQl9IGVsc2UgewoJCQkJSElDT04gaEljb25MYXJnZSA9IDA7CgoJCQkJSFJFU1VMVCBociA9IElFeHRyYWN0SWNvbldfRXh0cmFjdChwRXh0cmFjdCwgcGF0aCwgaWR4LCAmaEljb25MYXJnZSwgJmhpY29uLCBNQUtFTE9ORygwLypHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYSUNPTikqLyxHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU01JQ09OKSkpOwoKCQkJCWlmIChTVUNDRUVERUQoaHIpKQoJCQkJCURlc3Ryb3lJY29uKGhJY29uTGFyZ2UpOwoJCQl9CgoJCQlyZXR1cm4gaGljb247CgkJfQoJfQoKCXJldHVybiAwOwp9CgoKc3RhdGljIEVudHJ5KiBmaW5kX2VudHJ5X3NoZWxsKEVudHJ5KiBkaXIsIExQQ0lURU1JRExJU1QgcGlkbCkKewoJRW50cnkqIGVudHJ5OwoKCWZvcihlbnRyeT1kaXItPmRvd247IGVudHJ5OyBlbnRyeT1lbnRyeS0+bmV4dCkgewoJCWlmIChlbnRyeS0+cGlkbC0+bWtpZC5jYiA9PSBwaWRsLT5ta2lkLmNiICYmCgkJCSFtZW1jbXAoZW50cnktPnBpZGwsIHBpZGwsIGVudHJ5LT5waWRsLT5ta2lkLmNiKSkKCQkJcmV0dXJuIGVudHJ5OwoJfQoKCXJldHVybiAwOwp9CgpzdGF0aWMgRW50cnkqIHJlYWRfdHJlZV9zaGVsbChSb290KiByb290LCBMUElURU1JRExJU1QgcGlkbCwgU09SVF9PUkRFUiBzb3J0T3JkZXIsIEhXTkQgaHduZCkKewoJRW50cnkqIGVudHJ5ID0gJnJvb3QtPmVudHJ5OwoJRW50cnkqIG5leHQ7CglMUElURU1JRExJU1QgbmV4dF9waWRsID0gcGlkbDsKCUlTaGVsbEZvbGRlciogZm9sZGVyOwoJSVNoZWxsRm9sZGVyKiBjaGlsZCA9IE5VTEw7CglIUkVTVUxUIGhyOwoKCUhDVVJTT1Igb2xkX2N1cnNvciA9IFNldEN1cnNvcihMb2FkQ3Vyc29yKDAsIElEQ19XQUlUKSk7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgllbnRyeS0+ZXR5cGUgPSBFVF9TSEVMTDsKI2VuZGlmCgoJZm9sZGVyID0gR2xvYmFscy5pRGVza3RvcDsKCgl3aGlsZShlbnRyeSkgewoJCWVudHJ5LT5waWRsID0gbmV4dF9waWRsOwoJCWVudHJ5LT5mb2xkZXIgPSBmb2xkZXI7CgoJCWlmICghcGlkbC0+bWtpZC5jYikKCQkJYnJlYWs7CgoJCSAvKiBjb3B5IGZpcnN0IGVsZW1lbnQgb2YgaXRlbSBpZGxpc3QgKi8KCQluZXh0X3BpZGwgPSBJTWFsbG9jX0FsbG9jKEdsb2JhbHMuaU1hbGxvYywgcGlkbC0+bWtpZC5jYitzaXplb2YoVVNIT1JUKSk7CgkJbWVtY3B5KG5leHRfcGlkbCwgcGlkbCwgcGlkbC0+bWtpZC5jYik7CgkJKChMUElURU1JRExJU1QpKChMUEJZVEUpbmV4dF9waWRsK3BpZGwtPm1raWQuY2IpKS0+bWtpZC5jYiA9IDA7CgoJCWhyID0gSVNoZWxsRm9sZGVyX0JpbmRUb09iamVjdChmb2xkZXIsIG5leHRfcGlkbCwgMCwgJklJRF9JU2hlbGxGb2xkZXIsICh2b2lkKiopJmNoaWxkKTsKCQlpZiAoIVNVQ0NFRURFRChocikpCgkJCWJyZWFrOwoKCQlyZWFkX2RpcmVjdG9yeShlbnRyeSwgTlVMTCwgc29ydE9yZGVyLCBod25kKTsKCgkJaWYgKGVudHJ5LT5kb3duKQoJCQllbnRyeS0+ZXhwYW5kZWQgPSBUUlVFOwoKCQluZXh0ID0gZmluZF9lbnRyeV9zaGVsbChlbnRyeSwgbmV4dF9waWRsKTsKCQlpZiAoIW5leHQpCgkJCWJyZWFrOwoKCQlmb2xkZXIgPSBjaGlsZDsKCQllbnRyeSA9IG5leHQ7CgoJCSAvKiBnbyB0byBuZXh0IGVsZW1lbnQgKi8KCQlwaWRsID0gKExQSVRFTUlETElTVCkgKChMUEJZVEUpcGlkbCtwaWRsLT5ta2lkLmNiKTsKCX0KCglTZXRDdXJzb3Iob2xkX2N1cnNvcik7CgoJcmV0dXJuIGVudHJ5Owp9CgoKc3RhdGljIHZvaWQgZmlsbF93MzJmZGF0YV9zaGVsbChJU2hlbGxGb2xkZXIqIGZvbGRlciwgTFBDSVRFTUlETElTVCBwaWRsLCBTRkdBT0YgYXR0cmlicywgV0lOMzJfRklORF9EQVRBKiB3MzJmZGF0YSkKewoJaWYgKCEoYXR0cmlicyAmIFNGR0FPX0ZJTEVTWVNURU0pIHx8CgkJICBGQUlMRUQoU0hHZXREYXRhRnJvbUlETGlzdChmb2xkZXIsIHBpZGwsIFNIR0RGSUxfRklORERBVEEsIHczMmZkYXRhLCBzaXplb2YoV0lOMzJfRklORF9EQVRBKSkpKSB7CgkJV0lOMzJfRklMRV9BVFRSSUJVVEVfREFUQSBmYWQ7CgkJSURhdGFPYmplY3QqIHBEYXRhT2JqOwoKCQlTVEdNRURJVU0gbWVkaXVtID0gezAsIHswfSwgMH07CgkJRk9STUFURVRDIGZtdCA9IHtHbG9iYWxzLmNmU3RyRk5hbWUsIDAsIERWQVNQRUNUX0NPTlRFTlQsIC0xLCBUWU1FRF9IR0xPQkFMfTsKCgkJSFJFU1VMVCBociA9IElTaGVsbEZvbGRlcl9HZXRVSU9iamVjdE9mKGZvbGRlciwgMCwgMSwgJnBpZGwsICZJSURfSURhdGFPYmplY3QsIDAsIChMUFZPSUQqKSZwRGF0YU9iaik7CgoJCWlmIChTVUNDRUVERUQoaHIpKSB7CgkJCWhyID0gSURhdGFPYmplY3RfR2V0RGF0YShwRGF0YU9iaiwgJmZtdCwgJm1lZGl1bSk7CgoJCQlJRGF0YU9iamVjdF9SZWxlYXNlKHBEYXRhT2JqKTsKCgkJCWlmIChTVUNDRUVERUQoaHIpKSB7CgkJCQlMUENUU1RSIHBhdGggPSAoTFBDVFNUUilHbG9iYWxMb2NrKG1lZGl1bS5VTklPTl9NRU1CRVIoaEdsb2JhbCkpOwoJCQkJVUlOVCBzZW1fb3JnID0gU2V0RXJyb3JNb2RlKFNFTV9GQUlMQ1JJVElDQUxFUlJPUlMpOwoKCQkJCWlmIChHZXRGaWxlQXR0cmlidXRlc0V4KHBhdGgsIEdldEZpbGVFeEluZm9TdGFuZGFyZCwgJmZhZCkpIHsKCQkJCQl3MzJmZGF0YS0+ZHdGaWxlQXR0cmlidXRlcyA9IGZhZC5kd0ZpbGVBdHRyaWJ1dGVzOwoJCQkJCXczMmZkYXRhLT5mdENyZWF0aW9uVGltZSA9IGZhZC5mdENyZWF0aW9uVGltZTsKCQkJCQl3MzJmZGF0YS0+ZnRMYXN0QWNjZXNzVGltZSA9IGZhZC5mdExhc3RBY2Nlc3NUaW1lOwoJCQkJCXczMmZkYXRhLT5mdExhc3RXcml0ZVRpbWUgPSBmYWQuZnRMYXN0V3JpdGVUaW1lOwoKCQkJCQlpZiAoIShmYWQuZHdGaWxlQXR0cmlidXRlcyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkpIHsKCQkJCQkJdzMyZmRhdGEtPm5GaWxlU2l6ZUxvdyA9IGZhZC5uRmlsZVNpemVMb3c7CgkJCQkJCXczMmZkYXRhLT5uRmlsZVNpemVIaWdoID0gZmFkLm5GaWxlU2l6ZUhpZ2g7CgkJCQkJfQoJCQkJfQoKCQkJCVNldEVycm9yTW9kZShzZW1fb3JnKTsKCgkJCQlHbG9iYWxVbmxvY2sobWVkaXVtLlVOSU9OX01FTUJFUihoR2xvYmFsKSk7CgkJCQlHbG9iYWxGcmVlKG1lZGl1bS5VTklPTl9NRU1CRVIoaEdsb2JhbCkpOwoJCQl9CgkJfQoJfQoKCWlmIChhdHRyaWJzICYgKFNGR0FPX0ZPTERFUnxTRkdBT19IQVNTVUJGT0xERVIpKQoJCXczMmZkYXRhLT5kd0ZpbGVBdHRyaWJ1dGVzIHw9IEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWTsKCglpZiAoYXR0cmlicyAmIFNGR0FPX1JFQURPTkxZKQoJCXczMmZkYXRhLT5kd0ZpbGVBdHRyaWJ1dGVzIHw9IEZJTEVfQVRUUklCVVRFX1JFQURPTkxZOwoKCWlmIChhdHRyaWJzICYgU0ZHQU9fQ09NUFJFU1NFRCkKCQl3MzJmZGF0YS0+ZHdGaWxlQXR0cmlidXRlcyB8PSBGSUxFX0FUVFJJQlVURV9DT01QUkVTU0VEOwp9CgoKc3RhdGljIHZvaWQgcmVhZF9kaXJlY3Rvcnlfc2hlbGwoRW50cnkqIGRpciwgSFdORCBod25kKQp7CglJU2hlbGxGb2xkZXIqIGZvbGRlciA9IGRpci0+Zm9sZGVyOwoJaW50IGxldmVsID0gZGlyLT5sZXZlbCArIDE7CglIUkVTVUxUIGhyOwoKCUlTaGVsbEZvbGRlciogY2hpbGQ7CglJRW51bUlETGlzdCogaWRsaXN0OwoKCUVudHJ5KiBmaXJzdF9lbnRyeSA9IE5VTEw7CglFbnRyeSogbGFzdCA9IE5VTEw7CglFbnRyeSogZW50cnk7CgoJaWYgKCFmb2xkZXIpCgkJcmV0dXJuOwoKCWhyID0gSVNoZWxsRm9sZGVyX0VudW1PYmplY3RzKGZvbGRlciwgaHduZCwgU0hDT05URl9GT0xERVJTfFNIQ09OVEZfTk9ORk9MREVSU3xTSENPTlRGX0lOQ0xVREVISURERU58U0hDT05URl9TSEFSRUFCTEV8U0hDT05URl9TVE9SQUdFLCAmaWRsaXN0KTsKCglpZiAoU1VDQ0VFREVEKGhyKSkgewoJCWZvcig7OykgewojZGVmaW5lCUZFVENIX0lURU1fQ09VTlQJMzIKCQkJTFBJVEVNSURMSVNUIHBpZGxzW0ZFVENIX0lURU1fQ09VTlRdOwoJCQlTRkdBT0YgYXR0cmliczsKCQkJVUxPTkcgY250ID0gMDsKCQkJVUxPTkcgbjsKCgkJCW1lbXNldChwaWRscywgMCwgc2l6ZW9mKHBpZGxzKSk7CgoJCQlociA9IElFbnVtSURMaXN0X05leHQoaWRsaXN0LCBGRVRDSF9JVEVNX0NPVU5ULCBwaWRscywgJmNudCk7CgkJCWlmICghU1VDQ0VFREVEKGhyKSkKCQkJCWJyZWFrOwoKCQkJaWYgKGhyID09IFNfRkFMU0UpCgkJCQlicmVhazsKCgkJCWZvcihuPTA7IG48Y250OyArK24pIHsKCQkJCWVudHJ5ID0gYWxsb2NfZW50cnkoKTsKCgkJCQlpZiAoIWZpcnN0X2VudHJ5KQoJCQkJCWZpcnN0X2VudHJ5ID0gZW50cnk7CgoJCQkJaWYgKGxhc3QpCgkJCQkJbGFzdC0+bmV4dCA9IGVudHJ5OwoKCQkJCW1lbXNldCgmZW50cnktPmRhdGEsIDAsIHNpemVvZihXSU4zMl9GSU5EX0RBVEEpKTsKCQkJCWVudHJ5LT5iaGZpX3ZhbGlkID0gRkFMU0U7CgoJCQkJYXR0cmlicyA9IH5TRkdBT19GSUxFU1lTVEVNOwkvKlNGR0FPX0hBU1NVQkZPTERFUnxTRkdBT19GT0xERVI7IFNGR0FPX0ZJTEVTWVNURU0gc29yZ3QgZGFm/HIsIGRh3yAiTXkgRG9jdW1lbnRzIiBhbnN0YXR0IHZvbiAiTWFydGluJ3MgRG9jdW1lbnRzIiBhbmdlemVpZ3Qgd2lyZCAqLwoKCQkJCWhyID0gSVNoZWxsRm9sZGVyX0dldEF0dHJpYnV0ZXNPZihmb2xkZXIsIDEsIChMUENJVEVNSURMSVNUKikmcGlkbHNbbl0sICZhdHRyaWJzKTsKCgkJCQlpZiAoU1VDQ0VFREVEKGhyKSkgewoJCQkJCWlmIChhdHRyaWJzICE9IChTRkdBT0YpflNGR0FPX0ZJTEVTWVNURU0pIHsKCQkJCQkJZmlsbF93MzJmZGF0YV9zaGVsbChmb2xkZXIsIHBpZGxzW25dLCBhdHRyaWJzLCAmZW50cnktPmRhdGEpOwoKCQkJCQkJZW50cnktPmJoZmlfdmFsaWQgPSBUUlVFOwoJCQkJCX0gZWxzZQoJCQkJCQlhdHRyaWJzID0gMDsKCQkJCX0gZWxzZQoJCQkJCWF0dHJpYnMgPSAwOwoKCQkJCWVudHJ5LT5waWRsID0gcGlkbHNbbl07CgoJCQkJaWYgKGVudHJ5LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpIHsKCQkJCQlociA9IElTaGVsbEZvbGRlcl9CaW5kVG9PYmplY3QoZm9sZGVyLCBwaWRsc1tuXSwgMCwgJklJRF9JU2hlbGxGb2xkZXIsICh2b2lkKiopJmNoaWxkKTsKCgkJCQkJaWYgKFNVQ0NFRURFRChocikpCgkJCQkJCWVudHJ5LT5mb2xkZXIgPSBjaGlsZDsKCQkJCQllbHNlCgkJCQkJCWVudHJ5LT5mb2xkZXIgPSBOVUxMOwoJCQkJfQoJCQkJZWxzZQoJCQkJCWVudHJ5LT5mb2xkZXIgPSBOVUxMOwoKCQkJCWlmICghZW50cnktPmRhdGEuY0ZpbGVOYW1lWzBdKQoJCQkJCS8qaHIgPSAqL25hbWVfZnJvbV9waWRsKGZvbGRlciwgcGlkbHNbbl0sIGVudHJ5LT5kYXRhLmNGaWxlTmFtZSwgTUFYX1BBVEgsIC8qU0hHRE5fSU5GT0xERVIqLzB4MjAwMC8qMHgyMDAwPVNIR0ROX0lOQ0xVREVfTk9ORklMRVNZUyovKTsKCgkJCQkgLyogZ2V0IGRpc3BsYXkgaWNvbnMgZm9yIGZpbGVzIGFuZCB2aXJ0dWFsIG9iamVjdHMgKi8KCQkJCWlmICghKGVudHJ5LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpIHx8CgkJCQkJIShhdHRyaWJzICYgU0ZHQU9fRklMRVNZU1RFTSkpIHsKCQkJCQllbnRyeS0+aGljb24gPSBleHRyYWN0X2ljb24oZm9sZGVyLCBwaWRsc1tuXSk7CgoJCQkJCWlmICghZW50cnktPmhpY29uKQoJCQkJCQllbnRyeS0+aGljb24gPSAoSElDT04pLTE7CS8qIGRvbid0IHRyeSBhZ2FpbiBsYXRlciAqLwoJCQkJfQoKCQkJCWVudHJ5LT5kb3duID0gTlVMTDsKCQkJCWVudHJ5LT51cCA9IGRpcjsKCQkJCWVudHJ5LT5leHBhbmRlZCA9IEZBTFNFOwoJCQkJZW50cnktPnNjYW5uZWQgPSBGQUxTRTsKCQkJCWVudHJ5LT5sZXZlbCA9IGxldmVsOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCQkJZW50cnktPmV0eXBlID0gRVRfU0hFTEw7CgkJCQllbnRyeS0+YmhmaV92YWxpZCA9IEZBTFNFOwojZW5kaWYKCgkJCQlsYXN0ID0gZW50cnk7CgkJCX0KCQl9CgoJCUlFbnVtSURMaXN0X1JlbGVhc2UoaWRsaXN0KTsKCX0KCglpZiAobGFzdCkKCQlsYXN0LT5uZXh0ID0gTlVMTDsKCglkaXItPmRvd24gPSBmaXJzdF9lbnRyeTsKCWRpci0+c2Nhbm5lZCA9IFRSVUU7Cn0KCiNlbmRpZiAvKiBfU0hFTExfRk9MREVSUyAqLwoKCi8qIHNvcnQgb3JkZXIgZm9yIGRpZmZlcmVudCBkaXJlY3RvcnkvZmlsZSB0eXBlcyAqLwplbnVtIFRZUEVfT1JERVIgewoJVE9fRElSID0gMCwKCVRPX0RPVCA9IDEsCglUT19ET1RET1QgPSAyLAoJVE9fT1RIRVJfRElSID0gMywKCVRPX0ZJTEUgPSA0Cn07CgovKiBkaXN0aW5ndWlzaCBiZXR3ZWVuICIuIiwgIi4uIiBhbmQgYW55IG90aGVyIGRpcmVjdG9yeSBuYW1lcyAqLwpzdGF0aWMgaW50IFR5cGVPcmRlckZyb21EaXJuYW1lKExQQ1RTVFIgbmFtZSkKewoJaWYgKG5hbWVbMF0gPT0gJy4nKSB7CgkJaWYgKG5hbWVbMV0gPT0gJ1wwJykKCQkJcmV0dXJuIFRPX0RPVDsJLyogIi4iICovCgoJCWlmIChuYW1lWzFdPT0nLicgJiYgbmFtZVsyXT09J1wwJykKCQkJcmV0dXJuIFRPX0RPVERPVDsJLyogIi4uIiAqLwoJfQoKCXJldHVybiBUT19PVEhFUl9ESVI7CS8qIGFueXRoaW5nIGVsc2UgKi8KfQoKLyogZGlyZWN0b3JpZXMgZmlyc3QuLi4gKi8Kc3RhdGljIGludCBjb21wYXJlVHlwZShjb25zdCBXSU4zMl9GSU5EX0RBVEEqIGZkMSwgY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDIpCnsKCWludCBvcmRlcjEgPSBmZDEtPmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk/IFRPX0RJUjogVE9fRklMRTsKCWludCBvcmRlcjIgPSBmZDItPmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk/IFRPX0RJUjogVE9fRklMRTsKCgkvKiBIYW5kbGUgIi4iIGFuZCAiLi4iIGFzIHNwZWNpYWwgY2FzZSBhbmQgbW92ZSB0aGVtIGF0IHRoZSB2ZXJ5IGZpcnN0IGJlZ2lubmluZy4gKi8KCWlmIChvcmRlcjE9PVRPX0RJUiAmJiBvcmRlcjI9PVRPX0RJUikgewoJCW9yZGVyMSA9IFR5cGVPcmRlckZyb21EaXJuYW1lKGZkMS0+Y0ZpbGVOYW1lKTsKCQlvcmRlcjIgPSBUeXBlT3JkZXJGcm9tRGlybmFtZShmZDItPmNGaWxlTmFtZSk7Cgl9CgoJcmV0dXJuIG9yZGVyMj09b3JkZXIxPyAwOiBvcmRlcjE8b3JkZXIyPyAtMTogMTsKfQoKCnN0YXRpYyBpbnQgY29tcGFyZU5hbWUoY29uc3Qgdm9pZCogYXJnMSwgY29uc3Qgdm9pZCogYXJnMikKewoJY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDEgPSAmKCooY29uc3QgRW50cnkqIGNvbnN0KilhcmcxKS0+ZGF0YTsKCWNvbnN0IFdJTjMyX0ZJTkRfREFUQSogZmQyID0gJigqKGNvbnN0IEVudHJ5KiBjb25zdCopYXJnMiktPmRhdGE7CgoJaW50IGNtcCA9IGNvbXBhcmVUeXBlKGZkMSwgZmQyKTsKCWlmIChjbXApCgkJcmV0dXJuIGNtcDsKCglyZXR1cm4gbHN0cmNtcGkoZmQxLT5jRmlsZU5hbWUsIGZkMi0+Y0ZpbGVOYW1lKTsKfQoKc3RhdGljIGludCBjb21wYXJlRXh0KGNvbnN0IHZvaWQqIGFyZzEsIGNvbnN0IHZvaWQqIGFyZzIpCnsKCWNvbnN0IFdJTjMyX0ZJTkRfREFUQSogZmQxID0gJigqKGNvbnN0IEVudHJ5KiBjb25zdCopYXJnMSktPmRhdGE7Cgljb25zdCBXSU4zMl9GSU5EX0RBVEEqIGZkMiA9ICYoKihjb25zdCBFbnRyeSogY29uc3QqKWFyZzIpLT5kYXRhOwoJY29uc3QgVENIQVIgKm5hbWUxLCAqbmFtZTIsICpleHQxLCAqZXh0MjsKCglpbnQgY21wID0gY29tcGFyZVR5cGUoZmQxLCBmZDIpOwoJaWYgKGNtcCkKCQlyZXR1cm4gY21wOwoKCW5hbWUxID0gZmQxLT5jRmlsZU5hbWU7CgluYW1lMiA9IGZkMi0+Y0ZpbGVOYW1lOwoKCWV4dDEgPSBfdGNzcmNocihuYW1lMSwgJy4nKTsKCWV4dDIgPSBfdGNzcmNocihuYW1lMiwgJy4nKTsKCglpZiAoZXh0MSkKCQlleHQxKys7CgllbHNlCgkJZXh0MSA9IHNFbXB0eTsKCglpZiAoZXh0MikKCQlleHQyKys7CgllbHNlCgkJZXh0MiA9IHNFbXB0eTsKCgljbXAgPSBsc3RyY21waShleHQxLCBleHQyKTsKCWlmIChjbXApCgkJcmV0dXJuIGNtcDsKCglyZXR1cm4gbHN0cmNtcGkobmFtZTEsIG5hbWUyKTsKfQoKc3RhdGljIGludCBjb21wYXJlU2l6ZShjb25zdCB2b2lkKiBhcmcxLCBjb25zdCB2b2lkKiBhcmcyKQp7Cgljb25zdCBXSU4zMl9GSU5EX0RBVEEqIGZkMSA9ICYoKihjb25zdCBFbnRyeSogY29uc3QqKWFyZzEpLT5kYXRhOwoJY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDIgPSAmKCooY29uc3QgRW50cnkqIGNvbnN0KilhcmcyKS0+ZGF0YTsKCglpbnQgY21wID0gY29tcGFyZVR5cGUoZmQxLCBmZDIpOwoJaWYgKGNtcCkKCQlyZXR1cm4gY21wOwoKCWNtcCA9IGZkMi0+bkZpbGVTaXplSGlnaCAtIGZkMS0+bkZpbGVTaXplSGlnaDsKCglpZiAoY21wIDwgMCkKCQlyZXR1cm4gLTE7CgllbHNlIGlmIChjbXAgPiAwKQoJCXJldHVybiAxOwoKCWNtcCA9IGZkMi0+bkZpbGVTaXplTG93IC0gZmQxLT5uRmlsZVNpemVMb3c7CgoJcmV0dXJuIGNtcDwwPyAtMTogY21wPjA/IDE6IDA7Cn0KCnN0YXRpYyBpbnQgY29tcGFyZURhdGUoY29uc3Qgdm9pZCogYXJnMSwgY29uc3Qgdm9pZCogYXJnMikKewoJY29uc3QgV0lOMzJfRklORF9EQVRBKiBmZDEgPSAmKCooY29uc3QgRW50cnkqIGNvbnN0KilhcmcxKS0+ZGF0YTsKCWNvbnN0IFdJTjMyX0ZJTkRfREFUQSogZmQyID0gJigqKGNvbnN0IEVudHJ5KiBjb25zdCopYXJnMiktPmRhdGE7CgoJaW50IGNtcCA9IGNvbXBhcmVUeXBlKGZkMSwgZmQyKTsKCWlmIChjbXApCgkJcmV0dXJuIGNtcDsKCglyZXR1cm4gQ29tcGFyZUZpbGVUaW1lKCZmZDItPmZ0TGFzdFdyaXRlVGltZSwgJmZkMS0+ZnRMYXN0V3JpdGVUaW1lKTsKfQoKCnN0YXRpYyBpbnQgKCpzb3J0RnVuY3Rpb25zW10pKGNvbnN0IHZvaWQqIGFyZzEsIGNvbnN0IHZvaWQqIGFyZzIpID0gewoJY29tcGFyZU5hbWUsCS8qIFNPUlRfTkFNRSAqLwoJY29tcGFyZUV4dCwJCS8qIFNPUlRfRVhUICovCgljb21wYXJlU2l6ZSwJLyogU09SVF9TSVpFICovCgljb21wYXJlRGF0ZQkJLyogU09SVF9EQVRFICovCn07CgoKc3RhdGljIHZvaWQgU29ydERpcmVjdG9yeShFbnRyeSogZGlyLCBTT1JUX09SREVSIHNvcnRPcmRlcikKewoJRW50cnkqIGVudHJ5ID0gZGlyLT5kb3duOwoJRW50cnkqKiBhcnJheSwgKipwOwoJaW50IGxlbjsKCglsZW4gPSAwOwoJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KQoJCWxlbisrOwoKCWlmIChsZW4pIHsKCQlhcnJheSA9IEhlYXBBbGxvYyhHZXRQcm9jZXNzSGVhcCgpLCAwLCBsZW4qc2l6ZW9mKEVudHJ5KikpOwoKCQlwID0gYXJyYXk7CgkJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KQoJCQkqcCsrID0gZW50cnk7CgoJCS8qIGNhbGwgcXNvcnQgd2l0aCB0aGUgYXBwcm9wcmlhdGUgY29tcGFyZSBmdW5jdGlvbiAqLwoJCXFzb3J0KGFycmF5LCBsZW4sIHNpemVvZihhcnJheVswXSksIHNvcnRGdW5jdGlvbnNbc29ydE9yZGVyXSk7CgoJCWRpci0+ZG93biA9IGFycmF5WzBdOwoKCQlmb3IocD1hcnJheTsgLS1sZW47IHArKykKCQkJcFswXS0+bmV4dCA9IHBbMV07CgoJCSgqcCktPm5leHQgPSAwOwoKICAgICAgICAgICAgICAgIEhlYXBGcmVlKEdldFByb2Nlc3NIZWFwKCksIDAsIGFycmF5KTsKCX0KfQoKCnN0YXRpYyB2b2lkIHJlYWRfZGlyZWN0b3J5KEVudHJ5KiBkaXIsIExQQ1RTVFIgcGF0aCwgU09SVF9PUkRFUiBzb3J0T3JkZXIsIEhXTkQgaHduZCkKewoJVENIQVIgYnVmZmVyW01BWF9QQVRIXTsKCUVudHJ5KiBlbnRyeTsKCUxQQ1RTVFIgczsKCVBUU1RSIGQ7CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCWlmIChkaXItPmV0eXBlID09IEVUX1NIRUxMKQoJewoJCXJlYWRfZGlyZWN0b3J5X3NoZWxsKGRpciwgaHduZCk7CgoJCWlmIChHbG9iYWxzLnByZXNjYW5fbm9kZSkgewoJCQlzID0gcGF0aDsKCQkJZCA9IGJ1ZmZlcjsKCgkJCXdoaWxlKCpzKQoJCQkJKmQrKyA9ICpzKys7CgoJCQkqZCsrID0gJ1xcJzsKCgkJCWZvcihlbnRyeT1kaXItPmRvd247IGVudHJ5OyBlbnRyeT1lbnRyeS0+bmV4dCkKCQkJCWlmIChlbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSB7CgkJCQkJcmVhZF9kaXJlY3Rvcnlfc2hlbGwoZW50cnksIGh3bmQpOwoJCQkJCVNvcnREaXJlY3RvcnkoZW50cnksIHNvcnRPcmRlcik7CgkJCQl9CgkJfQoJfQoJZWxzZQojZW5kaWYKI2lmICFkZWZpbmVkKF9OT19FWFRFTlNJT05TKSAmJiBkZWZpbmVkKF9fV0lORV9fKQoJaWYgKGRpci0+ZXR5cGUgPT0gRVRfVU5JWCkKCXsKCQlyZWFkX2RpcmVjdG9yeV91bml4KGRpciwgcGF0aCk7CgoJCWlmIChHbG9iYWxzLnByZXNjYW5fbm9kZSkgewoJCQlzID0gcGF0aDsKCQkJZCA9IGJ1ZmZlcjsKCgkJCXdoaWxlKCpzKQoJCQkJKmQrKyA9ICpzKys7CgoJCQkqZCsrID0gJy8nOwoKCQkJZm9yKGVudHJ5PWRpci0+ZG93bjsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KQoJCQkJaWYgKGVudHJ5LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpIHsKCQkJCQlsc3RyY3B5KGQsIGVudHJ5LT5kYXRhLmNGaWxlTmFtZSk7CgkJCQkJcmVhZF9kaXJlY3RvcnlfdW5peChlbnRyeSwgYnVmZmVyKTsKCQkJCQlTb3J0RGlyZWN0b3J5KGVudHJ5LCBzb3J0T3JkZXIpOwoJCQkJfQoJCX0KCX0KCWVsc2UKI2VuZGlmCgl7CgkJcmVhZF9kaXJlY3Rvcnlfd2luKGRpciwgcGF0aCk7CgoJCWlmIChHbG9iYWxzLnByZXNjYW5fbm9kZSkgewoJCQlzID0gcGF0aDsKCQkJZCA9IGJ1ZmZlcjsKCgkJCXdoaWxlKCpzKQoJCQkJKmQrKyA9ICpzKys7CgoJCQkqZCsrID0gJ1xcJzsKCgkJCWZvcihlbnRyeT1kaXItPmRvd247IGVudHJ5OyBlbnRyeT1lbnRyeS0+bmV4dCkKCQkJCWlmIChlbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSB7CgkJCQkJbHN0cmNweShkLCBlbnRyeS0+ZGF0YS5jRmlsZU5hbWUpOwoJCQkJCXJlYWRfZGlyZWN0b3J5X3dpbihlbnRyeSwgYnVmZmVyKTsKCQkJCQlTb3J0RGlyZWN0b3J5KGVudHJ5LCBzb3J0T3JkZXIpOwoJCQkJfQoJCX0KCX0KCglTb3J0RGlyZWN0b3J5KGRpciwgc29ydE9yZGVyKTsKfQoKCnN0YXRpYyBFbnRyeSogcmVhZF90cmVlKFJvb3QqIHJvb3QsIExQQ1RTVFIgcGF0aCwgTFBJVEVNSURMSVNUIHBpZGwsIExQVFNUUiBkcnYsIFNPUlRfT1JERVIgc29ydE9yZGVyLCBIV05EIGh3bmQpCnsKI2lmICFkZWZpbmVkKF9OT19FWFRFTlNJT05TKSAmJiBkZWZpbmVkKF9fV0lORV9fKQoJc3RhdGljIGNvbnN0IFRDSEFSIHNTbGFzaFtdID0geycvJywgJ1wwJ307CiNlbmRpZgoJc3RhdGljIGNvbnN0IFRDSEFSIHNCYWNrc2xhc2hbXSA9IHsnXFwnLCAnXDAnfTsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKHBpZGwpCgl7CgkJIC8qIHJlYWQgc2hlbGwgbmFtZXNwYWNlIHRyZWUgKi8KCQlyb290LT5kcml2ZV90eXBlID0gRFJJVkVfVU5LTk9XTjsKCQlkcnZbMF0gPSAnXFwnOwoJCWRydlsxXSA9ICdcMCc7CgkJbG9hZF9zdHJpbmcocm9vdC0+dm9sbmFtZSwgSURTX0RFU0tUT1ApOwoJCXJvb3QtPmZzX2ZsYWdzID0gMDsKCQlsb2FkX3N0cmluZyhyb290LT5mcywgSURTX1NIRUxMKTsKCgkJcmV0dXJuIHJlYWRfdHJlZV9zaGVsbChyb290LCBwaWRsLCBzb3J0T3JkZXIsIGh3bmQpOwoJfQoJZWxzZQojZW5kaWYKI2lmICFkZWZpbmVkKF9OT19FWFRFTlNJT05TKSAmJiBkZWZpbmVkKF9fV0lORV9fKQoJaWYgKCpwYXRoID09ICcvJykKCXsKCQkgLyogcmVhZCB1bml4IGZpbGUgc3lzdGVtIHRyZWUgKi8KCQlyb290LT5kcml2ZV90eXBlID0gR2V0RHJpdmVUeXBlKHBhdGgpOwoKCQlsc3RyY2F0KGRydiwgc1NsYXNoKTsKCQlsb2FkX3N0cmluZyhyb290LT52b2xuYW1lLCBJRFNfUk9PVF9GUyk7CgkJcm9vdC0+ZnNfZmxhZ3MgPSAwOwoJCWxvYWRfc3RyaW5nKHJvb3QtPmZzLCBJRFNfVU5JWEZTKTsKCgkJbHN0cmNweShyb290LT5wYXRoLCBzU2xhc2gpOwoKCQlyZXR1cm4gcmVhZF90cmVlX3VuaXgocm9vdCwgcGF0aCwgc29ydE9yZGVyLCBod25kKTsKCX0KI2VuZGlmCgoJIC8qIHJlYWQgV0lOMzIgZmlsZSBzeXN0ZW0gdHJlZSAqLwoJcm9vdC0+ZHJpdmVfdHlwZSA9IEdldERyaXZlVHlwZShwYXRoKTsKCglsc3RyY2F0KGRydiwgc0JhY2tzbGFzaCk7CglHZXRWb2x1bWVJbmZvcm1hdGlvbihkcnYsIHJvb3QtPnZvbG5hbWUsIF9NQVhfRk5BTUUsIDAsIDAsICZyb290LT5mc19mbGFncywgcm9vdC0+ZnMsIF9NQVhfRElSKTsKCglsc3RyY3B5KHJvb3QtPnBhdGgsIGRydik7CgoJcmV0dXJuIHJlYWRfdHJlZV93aW4ocm9vdCwgcGF0aCwgc29ydE9yZGVyLCBod25kKTsKfQoKCi8qIGZsYWdzIHRvIGZpbHRlciBkaWZmZXJlbnQgZmlsZSB0eXBlcyAqLwplbnVtIFRZUEVfRklMVEVSIHsKCVRGX0RJUkVDVE9SSUVTCT0gMHgwMSwKCVRGX1BST0dSQU1TCQk9IDB4MDIsCglURl9ET0NVTUVOVFMJPSAweDA0LAoJVEZfT1RIRVJTCQk9IDB4MDgsCglURl9ISURERU4JCT0gMHgxMCwKCVRGX0FMTAkJCT0gMHgxRgp9OwoKCnN0YXRpYyBDaGlsZFduZCogYWxsb2NfY2hpbGRfd2luZG93KExQQ1RTVFIgcGF0aCwgTFBJVEVNSURMSVNUIHBpZGwsIEhXTkQgaHduZCkKewoJVENIQVIgZHJ2W19NQVhfRFJJVkUrMV0sIGRpcltfTUFYX0RJUl0sIG5hbWVbX01BWF9GTkFNRV0sIGV4dFtfTUFYX0VYVF07CglUQ0hBUiBkaXJfcGF0aFtNQVhfUEFUSF07CglUQ0hBUiBiMVtCVUZGRVJfTEVOXTsKCXN0YXRpYyBjb25zdCBUQ0hBUiBzQXN0ZXJpY3NbXSA9IHsnKicsICdcMCd9OwoKCUNoaWxkV25kKiBjaGlsZCA9IEhlYXBBbGxvYyhHZXRQcm9jZXNzSGVhcCgpLCAwLCBzaXplb2YoQ2hpbGRXbmQpKTsKCVJvb3QqIHJvb3QgPSAmY2hpbGQtPnJvb3Q7CglFbnRyeSogZW50cnk7CgoJbWVtc2V0KGNoaWxkLCAwLCBzaXplb2YoQ2hpbGRXbmQpKTsKCgljaGlsZC0+bGVmdC50cmVlUGFuZSA9IFRSVUU7CgljaGlsZC0+bGVmdC52aXNpYmxlX2NvbHMgPSAwOwoKCWNoaWxkLT5yaWdodC50cmVlUGFuZSA9IEZBTFNFOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCgljaGlsZC0+cmlnaHQudmlzaWJsZV9jb2xzID0gQ09MX1NJWkV8Q09MX0RBVEV8Q09MX1RJTUV8Q09MX0FUVFJJQlVURVN8Q09MX0lOREVYfENPTF9MSU5LUzsKI2Vsc2UKCWNoaWxkLT5yaWdodC52aXNpYmxlX2NvbHMgPSBDT0xfU0laRXxDT0xfREFURXxDT0xfVElNRXxDT0xfQVRUUklCVVRFUzsKI2VuZGlmCgoJY2hpbGQtPnBvcy5sZW5ndGggPSBzaXplb2YoV0lORE9XUExBQ0VNRU5UKTsKCWNoaWxkLT5wb3MuZmxhZ3MgPSAwOwoJY2hpbGQtPnBvcy5zaG93Q21kID0gU1dfU0hPV05PUk1BTDsKCWNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi5sZWZ0ID0gQ1dfVVNFREVGQVVMVDsKCWNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi50b3AgPSBDV19VU0VERUZBVUxUOwoJY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLnJpZ2h0ID0gQ1dfVVNFREVGQVVMVDsKCWNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi5ib3R0b20gPSBDV19VU0VERUZBVUxUOwoKCWNoaWxkLT5mb2N1c19wYW5lID0gMDsKCWNoaWxkLT5zcGxpdF9wb3MgPSBERUZBVUxUX1NQTElUX1BPUzsKCWNoaWxkLT5zb3J0T3JkZXIgPSBTT1JUX05BTUU7CgljaGlsZC0+aGVhZGVyX3dkdGhzX29rID0gRkFMU0U7CgoJaWYgKHBhdGgpCgl7CgkJbHN0cmNweShjaGlsZC0+cGF0aCwgcGF0aCk7CgoJCV90c3BsaXRwYXRoKHBhdGgsIGRydiwgZGlyLCBuYW1lLCBleHQpOwoJfQoKCWxzdHJjcHkoY2hpbGQtPmZpbHRlcl9wYXR0ZXJuLCBzQXN0ZXJpY3MpOwoJY2hpbGQtPmZpbHRlcl9mbGFncyA9IFRGX0FMTDsKCglyb290LT5lbnRyeS5sZXZlbCA9IDA7CgoJbHN0cmNweShkaXJfcGF0aCwgZHJ2KTsKCWxzdHJjYXQoZGlyX3BhdGgsIGRpcik7CgllbnRyeSA9IHJlYWRfdHJlZShyb290LCBkaXJfcGF0aCwgcGlkbCwgZHJ2LCBjaGlsZC0+c29ydE9yZGVyLCBod25kKTsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKHJvb3QtPmVudHJ5LmV0eXBlID09IEVUX1NIRUxMKQoJCWxvYWRfc3RyaW5nKHJvb3QtPmVudHJ5LmRhdGEuY0ZpbGVOYW1lLCBJRFNfREVTS1RPUCk7CgllbHNlCiNlbmRpZgoJCXdzcHJpbnRmKHJvb3QtPmVudHJ5LmRhdGEuY0ZpbGVOYW1lLCBSUyhiMSxJRFNfVElUTEVGTVQpLCBkcnYsIHJvb3QtPmZzKTsKCglyb290LT5lbnRyeS5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgPSBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlk7CgoJY2hpbGQtPmxlZnQucm9vdCA9ICZyb290LT5lbnRyeTsKCWNoaWxkLT5yaWdodC5yb290ID0gTlVMTDsKCglzZXRfY3VyZGlyKGNoaWxkLCBlbnRyeSwgMCwgaHduZCk7CgoJcmV0dXJuIGNoaWxkOwp9CgoKLyogZnJlZSBhbGwgbWVtb3J5IGFzc29jaWF0ZWQgd2l0aCBhIGNoaWxkIHdpbmRvdyAqLwpzdGF0aWMgdm9pZCBmcmVlX2NoaWxkX3dpbmRvdyhDaGlsZFduZCogY2hpbGQpCnsKCWZyZWVfZW50cmllcygmY2hpbGQtPnJvb3QuZW50cnkpOwoJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgY2hpbGQpOwp9CgoKLyogZ2V0IGZ1bGwgcGF0aCBvZiBzcGVjaWZpZWQgZGlyZWN0b3J5IGVudHJ5ICovCnN0YXRpYyB2b2lkIGdldF9wYXRoKEVudHJ5KiBkaXIsIFBUU1RSIHBhdGgpCnsKCUVudHJ5KiBlbnRyeTsKCWludCBsZW4gPSAwOwoJaW50IGxldmVsID0gMDsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKGRpci0+ZXR5cGUgPT0gRVRfU0hFTEwpCgl7CgkJU0ZHQU9GIGF0dHJpYnM7CgkJSFJFU1VMVCBociA9IFNfT0s7CgoJCXBhdGhbMF0gPSAnXDAnOwoKCQlhdHRyaWJzID0gMDsKCgkJaWYgKGRpci0+Zm9sZGVyKQoJCQlociA9IElTaGVsbEZvbGRlcl9HZXRBdHRyaWJ1dGVzT2YoZGlyLT5mb2xkZXIsIDEsIChMUENJVEVNSURMSVNUKikmZGlyLT5waWRsLCAmYXR0cmlicyk7CgoJCWlmIChTVUNDRUVERUQoaHIpICYmIChhdHRyaWJzJlNGR0FPX0ZJTEVTWVNURU0pKSB7CgkJCUlTaGVsbEZvbGRlciogcGFyZW50ID0gZGlyLT51cD8gZGlyLT51cC0+Zm9sZGVyOiBHbG9iYWxzLmlEZXNrdG9wOwoKCQkJaHIgPSBwYXRoX2Zyb21fcGlkbChwYXJlbnQsIGRpci0+cGlkbCwgcGF0aCwgTUFYX1BBVEgpOwoJCX0KCX0KCWVsc2UKI2VuZGlmCgl7CgkJZm9yKGVudHJ5PWRpcjsgZW50cnk7IGxldmVsKyspIHsKCQkJTFBDVFNUUiBuYW1lOwoJCQlpbnQgbDsKCgkJCXsKCQkJCUxQQ1RTVFIgczsKCQkJCW5hbWUgPSBlbnRyeS0+ZGF0YS5jRmlsZU5hbWU7CgkJCQlzID0gbmFtZTsKCgkJCQlmb3IobD0wOyAqcyAmJiAqcyAhPSAnLycgJiYgKnMgIT0gJ1xcJzsgcysrKQoJCQkJCWwrKzsKCQkJfQoKCQkJaWYgKGVudHJ5LT51cCkgewoJCQkJaWYgKGwgPiAwKSB7CgkJCQkJbWVtbW92ZShwYXRoK2wrMSwgcGF0aCwgbGVuKnNpemVvZihUQ0hBUikpOwoJCQkJCW1lbWNweShwYXRoKzEsIG5hbWUsIGwqc2l6ZW9mKFRDSEFSKSk7CgkJCQkJbGVuICs9IGwrMTsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQkJCQlpZiAoZW50cnktPmV0eXBlID09IEVUX1VOSVgpCgkJCQkJCXBhdGhbMF0gPSAnLyc7CgkJCQkJZWxzZQojZW5kaWYKCQkJCQlwYXRoWzBdID0gJ1xcJzsKCQkJCX0KCgkJCQllbnRyeSA9IGVudHJ5LT51cDsKCQkJfSBlbHNlIHsKCQkJCW1lbW1vdmUocGF0aCtsLCBwYXRoLCBsZW4qc2l6ZW9mKFRDSEFSKSk7CgkJCQltZW1jcHkocGF0aCwgbmFtZSwgbCpzaXplb2YoVENIQVIpKTsKCQkJCWxlbiArPSBsOwoJCQkJYnJlYWs7CgkJCX0KCQl9CgoJCWlmICghbGV2ZWwpIHsKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCQlpZiAoZW50cnktPmV0eXBlID09IEVUX1VOSVgpCgkJCQlwYXRoW2xlbisrXSA9ICcvJzsKCQkJZWxzZQojZW5kaWYKCQkJCXBhdGhbbGVuKytdID0gJ1xcJzsKCQl9CgoJCXBhdGhbbGVuXSA9ICdcMCc7Cgl9Cn0KCnN0YXRpYyB3aW5kb3dPcHRpb25zIGxvYWRfcmVnaXN0cnlfc2V0dGluZ3Modm9pZCkKewoJRFdPUkQgc2l6ZTsKCURXT1JEIHR5cGU7CglIS0VZIGhLZXk7Cgl3aW5kb3dPcHRpb25zIG9wdHM7CgogICAgICAgIFJlZ09wZW5LZXlFeFcoIEhLRVlfQ1VSUkVOVF9VU0VSLCByZWdpc3RyeV9rZXksCiAgICAgICAgICAgICAgICAgICAgICAgMCwgS0VZX1FVRVJZX1ZBTFVFLCAmaEtleSApOwoKCXNpemUgPSBzaXplb2YoRFdPUkQpOwoKICAgICAgICBpZiggUmVnUXVlcnlWYWx1ZUV4VyggaEtleSwgcmVnX3N0YXJ0X3gsIE5VTEwsICZ0eXBlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoTFBCWVRFKSAmb3B0cy5zdGFydF94LCAmc2l6ZSApICE9IEVSUk9SX1NVQ0NFU1MgKQoJCW9wdHMuc3RhcnRfeCA9IENXX1VTRURFRkFVTFQ7CgogICAgICAgIGlmKCBSZWdRdWVyeVZhbHVlRXhXKCBoS2V5LCByZWdfc3RhcnRfeSwgTlVMTCwgJnR5cGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUEJZVEUpICZvcHRzLnN0YXJ0X3ksICZzaXplICkgIT0gRVJST1JfU1VDQ0VTUyApCgkJb3B0cy5zdGFydF95ID0gQ1dfVVNFREVGQVVMVDsKCiAgICAgICAgaWYoIFJlZ1F1ZXJ5VmFsdWVFeFcoIGhLZXksIHJlZ193aWR0aCwgTlVMTCwgJnR5cGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUEJZVEUpICZvcHRzLndpZHRoLCAmc2l6ZSApICE9IEVSUk9SX1NVQ0NFU1MgKQoJCW9wdHMud2lkdGggPSBDV19VU0VERUZBVUxUOwoKICAgICAgICBpZiggUmVnUXVlcnlWYWx1ZUV4VyggaEtleSwgcmVnX2hlaWdodCwgTlVMTCwgJnR5cGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUEJZVEUpICZvcHRzLmhlaWdodCwgJnNpemUgKSAhPSBFUlJPUl9TVUNDRVNTICkKCQlvcHRzLmhlaWdodCA9IENXX1VTRURFRkFVTFQ7CgoJUmVnQ2xvc2VLZXkoIGhLZXkgKTsKCglyZXR1cm4gb3B0czsKfQoKc3RhdGljIHZvaWQgc2F2ZV9yZWdpc3RyeV9zZXR0aW5ncyh2b2lkKQp7CglXSU5ET1dJTkZPIHdpOwoJSEtFWSBoS2V5OwoJSU5UIHdpZHRoLCBoZWlnaHQ7CgoJd2kuY2JTaXplID0gc2l6ZW9mKCBXSU5ET1dJTkZPICk7CglHZXRXaW5kb3dJbmZvKEdsb2JhbHMuaE1haW5XbmQsICZ3aSk7Cgl3aWR0aCA9IHdpLnJjV2luZG93LnJpZ2h0IC0gd2kucmNXaW5kb3cubGVmdDsKCWhlaWdodCA9IHdpLnJjV2luZG93LmJvdHRvbSAtIHdpLnJjV2luZG93LnRvcDsKCglpZiAoIFJlZ09wZW5LZXlFeFcoIEhLRVlfQ1VSUkVOVF9VU0VSLCByZWdpc3RyeV9rZXksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAwLCBLRVlfU0VUX1ZBTFVFLCAmaEtleSApICE9IEVSUk9SX1NVQ0NFU1MgKQoJewoJCS8qIFVuYWJsZSB0byBzYXZlIHJlZ2lzdHJ5IHNldHRpbmdzIC0gdHJ5IHRvIGNyZWF0ZSBrZXkgKi8KICAgICAgICAgICAgICAgIGlmICggUmVnQ3JlYXRlS2V5RXhXKCBIS0VZX0NVUlJFTlRfVVNFUiwgcmVnaXN0cnlfa2V5LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAsIE5VTEwsIFJFR19PUFRJT05fTk9OX1ZPTEFUSUxFLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEtFWV9TRVRfVkFMVUUsIE5VTEwsICZoS2V5LCBOVUxMICkgIT0gRVJST1JfU1VDQ0VTUyApCgkJewoJCQkvKiBGSVhNRTogQ2Fubm90IGNyZWF0ZSBrZXkgKi8KCQkJcmV0dXJuOwoJCX0KCX0KCS8qIFNhdmUgYWxsIG9mIHRoZSBzZXR0aW5ncyAqLwogICAgICAgIFJlZ1NldFZhbHVlRXhXKCBoS2V5LCByZWdfc3RhcnRfeCwgMCwgUkVHX0RXT1JELAogICAgICAgICAgICAgICAgICAgICAgICAoTFBCWVRFKSAmd2kucmNXaW5kb3cubGVmdCwgc2l6ZW9mKERXT1JEKSApOwogICAgICAgIFJlZ1NldFZhbHVlRXhXKCBoS2V5LCByZWdfc3RhcnRfeSwgMCwgUkVHX0RXT1JELAogICAgICAgICAgICAgICAgICAgICAgICAoTFBCWVRFKSAmd2kucmNXaW5kb3cudG9wLCBzaXplb2YoRFdPUkQpICk7CiAgICAgICAgUmVnU2V0VmFsdWVFeFcoIGhLZXksIHJlZ193aWR0aCwgMCwgUkVHX0RXT1JELAogICAgICAgICAgICAgICAgICAgICAgICAoTFBCWVRFKSAmd2lkdGgsIHNpemVvZihEV09SRCkgKTsKICAgICAgICBSZWdTZXRWYWx1ZUV4VyggaEtleSwgcmVnX2hlaWdodCwgMCwgUkVHX0RXT1JELAogICAgICAgICAgICAgICAgICAgICAgICAoTFBCWVRFKSAmaGVpZ2h0LCBzaXplb2YoRFdPUkQpICk7CgoJLyogVE9ETzogU2F2ZSBtb3JlIHNldHRpbmdzIGhlcmUgKExpc3QgdnMuIERldGFpbGVkIFZpZXcsIGV0Yy4pICovCglSZWdDbG9zZUtleSggaEtleSApOwp9CgpzdGF0aWMgdm9pZCByZXNpemVfZnJhbWVfcmVjdChIV05EIGh3bmQsIFBSRUNUIHByZWN0KQp7CglpbnQgbmV3X3RvcDsKCVJFQ1QgcnQ7CgoJaWYgKElzV2luZG93VmlzaWJsZShHbG9iYWxzLmh0b29sYmFyKSkgewoJCVNlbmRNZXNzYWdlKEdsb2JhbHMuaHRvb2xiYXIsIFdNX1NJWkUsIDAsIDApOwoJCUdldENsaWVudFJlY3QoR2xvYmFscy5odG9vbGJhciwgJnJ0KTsKCQlwcmVjdC0+dG9wID0gcnQuYm90dG9tKzM7CgkJcHJlY3QtPmJvdHRvbSAtPSBydC5ib3R0b20rMzsKCX0KCglpZiAoSXNXaW5kb3dWaXNpYmxlKEdsb2JhbHMuaGRyaXZlYmFyKSkgewoJCVNlbmRNZXNzYWdlKEdsb2JhbHMuaGRyaXZlYmFyLCBXTV9TSVpFLCAwLCAwKTsKCQlHZXRDbGllbnRSZWN0KEdsb2JhbHMuaGRyaXZlYmFyLCAmcnQpOwoJCW5ld190b3AgPSAtLXByZWN0LT50b3AgKyBydC5ib3R0b20rMzsKCQlNb3ZlV2luZG93KEdsb2JhbHMuaGRyaXZlYmFyLCAwLCBwcmVjdC0+dG9wLCBydC5yaWdodCwgbmV3X3RvcCwgVFJVRSk7CgkJcHJlY3QtPnRvcCA9IG5ld190b3A7CgkJcHJlY3QtPmJvdHRvbSAtPSBydC5ib3R0b20rMjsKCX0KCglpZiAoSXNXaW5kb3dWaXNpYmxlKEdsb2JhbHMuaHN0YXR1c2JhcikpIHsKCQlpbnQgcGFydHNbXSA9IHszMDAsIDUwMH07CgoJCVNlbmRNZXNzYWdlKEdsb2JhbHMuaHN0YXR1c2JhciwgV01fU0laRSwgMCwgMCk7CgkJU2VuZE1lc3NhZ2UoR2xvYmFscy5oc3RhdHVzYmFyLCBTQl9TRVRQQVJUUywgMiwgKExQQVJBTSkmcGFydHMpOwoJCUdldENsaWVudFJlY3QoR2xvYmFscy5oc3RhdHVzYmFyLCAmcnQpOwoJCXByZWN0LT5ib3R0b20gLT0gcnQuYm90dG9tOwoJfQoKCU1vdmVXaW5kb3coR2xvYmFscy5obWRpY2xpZW50LCBwcmVjdC0+bGVmdC0xLHByZWN0LT50b3AtMSxwcmVjdC0+cmlnaHQrMixwcmVjdC0+Ym90dG9tKzEsIFRSVUUpOwp9CgpzdGF0aWMgdm9pZCByZXNpemVfZnJhbWUoSFdORCBod25kLCBpbnQgY3gsIGludCBjeSkKewoJUkVDVCByZWN0OwoKCXJlY3QubGVmdCAgID0gMDsKCXJlY3QudG9wICAgID0gMDsKCXJlY3QucmlnaHQgID0gY3g7CglyZWN0LmJvdHRvbSA9IGN5OwoKCXJlc2l6ZV9mcmFtZV9yZWN0KGh3bmQsICZyZWN0KTsKfQoKc3RhdGljIHZvaWQgcmVzaXplX2ZyYW1lX2NsaWVudChIV05EIGh3bmQpCnsKCVJFQ1QgcmVjdDsKCglHZXRDbGllbnRSZWN0KGh3bmQsICZyZWN0KTsKCglyZXNpemVfZnJhbWVfcmVjdChod25kLCAmcmVjdCk7Cn0KCgpzdGF0aWMgSEhPT0sgaGNidGhvb2s7CnN0YXRpYyBDaGlsZFduZCogbmV3Y2hpbGQgPSBOVUxMOwoKc3RhdGljIExSRVNVTFQgQ0FMTEJBQ0sgQ0JUUHJvYyhpbnQgY29kZSwgV1BBUkFNIHdwYXJhbSwgTFBBUkFNIGxwYXJhbSkKewoJaWYgKGNvZGU9PUhDQlRfQ1JFQVRFV05EICYmIG5ld2NoaWxkKSB7CgkJQ2hpbGRXbmQqIGNoaWxkID0gbmV3Y2hpbGQ7CgkJbmV3Y2hpbGQgPSBOVUxMOwoKCQljaGlsZC0+aHduZCA9IChIV05EKSB3cGFyYW07CgkJU2V0V2luZG93TG9uZ1B0cihjaGlsZC0+aHduZCwgR1dMUF9VU0VSREFUQSwgKExQQVJBTSljaGlsZCk7Cgl9CgoJcmV0dXJuIENhbGxOZXh0SG9va0V4KGhjYnRob29rLCBjb2RlLCB3cGFyYW0sIGxwYXJhbSk7Cn0KCnN0YXRpYyBIV05EIGNyZWF0ZV9jaGlsZF93aW5kb3coQ2hpbGRXbmQqIGNoaWxkKQp7CglNRElDUkVBVEVTVFJVQ1QgbWNzOwoJaW50IGlkeDsKCgltY3Muc3pDbGFzcyA9IHNXSU5FRklMRVRSRUU7CgltY3Muc3pUaXRsZSA9IChMUFRTVFIpY2hpbGQtPnBhdGg7CgltY3MuaE93bmVyICA9IEdsb2JhbHMuaEluc3RhbmNlOwoJbWNzLnggICAgICAgPSBjaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24ubGVmdDsKCW1jcy55ICAgICAgID0gY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLnRvcDsKCW1jcy5jeCAgICAgID0gY2hpbGQtPnBvcy5yY05vcm1hbFBvc2l0aW9uLnJpZ2h0LWNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi5sZWZ0OwoJbWNzLmN5ICAgICAgPSBjaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24uYm90dG9tLWNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi50b3A7CgltY3Muc3R5bGUgICA9IDA7CgltY3MubFBhcmFtICA9IDA7CgoJaGNidGhvb2sgPSBTZXRXaW5kb3dzSG9va0V4KFdIX0NCVCwgQ0JUUHJvYywgMCwgR2V0Q3VycmVudFRocmVhZElkKCkpOwoKCW5ld2NoaWxkID0gY2hpbGQ7CgljaGlsZC0+aHduZCA9IChIV05EKSBTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESUNSRUFURSwgMCwgKExQQVJBTSkmbWNzKTsKCWlmICghY2hpbGQtPmh3bmQpIHsKCQlVbmhvb2tXaW5kb3dzSG9va0V4KGhjYnRob29rKTsKCQlyZXR1cm4gMDsKCX0KCglVbmhvb2tXaW5kb3dzSG9va0V4KGhjYnRob29rKTsKCglTZW5kTWVzc2FnZShjaGlsZC0+bGVmdC5od25kLCBMQl9TRVRJVEVNSEVJR0hULCAxLCBtYXgoR2xvYmFscy5zcGFjZVNpemUuY3ksSU1BR0VfSEVJR0hUKzMpKTsKCVNlbmRNZXNzYWdlKGNoaWxkLT5yaWdodC5od25kLCBMQl9TRVRJVEVNSEVJR0hULCAxLCBtYXgoR2xvYmFscy5zcGFjZVNpemUuY3ksSU1BR0VfSEVJR0hUKzMpKTsKCglpZHggPSBTZW5kTWVzc2FnZShjaGlsZC0+bGVmdC5od25kLCBMQl9GSU5EU1RSSU5HLCAwLCAoTFBBUkFNKWNoaWxkLT5sZWZ0LmN1cik7CglTZW5kTWVzc2FnZShjaGlsZC0+bGVmdC5od25kLCBMQl9TRVRDVVJTRUwsIGlkeCwgMCk7CgoJcmV0dXJuIGNoaWxkLT5od25kOwp9CgoKc3RydWN0IEV4ZWN1dGVEaWFsb2cgewoJVENIQVIJY21kW01BWF9QQVRIXTsKCWludAkJY21kc2hvdzsKfTsKCnN0YXRpYyBJTlRfUFRSIENBTExCQUNLIEV4ZWN1dGVEaWFsb2dEbGdQcm9jKEhXTkQgaHduZCwgVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKQp7CglzdGF0aWMgc3RydWN0IEV4ZWN1dGVEaWFsb2cqIGRsZzsKCglzd2l0Y2gobm1zZykgewoJCWNhc2UgV01fSU5JVERJQUxPRzoKCQkJZGxnID0gKHN0cnVjdCBFeGVjdXRlRGlhbG9nKikgbHBhcmFtOwoJCQlyZXR1cm4gMTsKCgkJY2FzZSBXTV9DT01NQU5EOiB7CgkJCWludCBpZCA9IChpbnQpd3BhcmFtOwoKCQkJaWYgKGlkID09IElET0spIHsKCQkJCUdldFdpbmRvd1RleHQoR2V0RGxnSXRlbShod25kLCAyMDEpLCBkbGctPmNtZCwgTUFYX1BBVEgpOwoJCQkJZGxnLT5jbWRzaG93ID0gZ2V0X2NoZWNrKGh3bmQsMjE0KSA/IFNXX1NIT1dNSU5JTUlaRUQgOiBTV19TSE9XTk9STUFMOwoJCQkJRW5kRGlhbG9nKGh3bmQsIGlkKTsKCQkJfSBlbHNlIGlmIChpZCA9PSBJRENBTkNFTCkKCQkJCUVuZERpYWxvZyhod25kLCBpZCk7CgoJCQlyZXR1cm4gMTt9Cgl9CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgSU5UX1BUUiBDQUxMQkFDSyBEZXN0aW5hdGlvbkRsZ1Byb2MoSFdORCBod25kLCBVSU5UIG5tc2csIFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pCnsKCVRDSEFSIGIxW0JVRkZFUl9MRU5dLCBiMltCVUZGRVJfTEVOXTsKCglzd2l0Y2gobm1zZykgewoJCWNhc2UgV01fSU5JVERJQUxPRzoKCQkJU2V0V2luZG93TG9uZ1B0cihod25kLCBHV0xQX1VTRVJEQVRBLCBscGFyYW0pOwoJCQlTZXRXaW5kb3dUZXh0KEdldERsZ0l0ZW0oaHduZCwgMjAxKSwgKExQQ1RTVFIpbHBhcmFtKTsKCQkJcmV0dXJuIDE7CgoJCWNhc2UgV01fQ09NTUFORDogewoJCQlpbnQgaWQgPSAoaW50KXdwYXJhbTsKCgkJCXN3aXRjaChpZCkgewoJCQkgIGNhc2UgSURPSzogewoJCQkJTFBUU1RSIGRlc3QgPSAoTFBUU1RSKSBHZXRXaW5kb3dMb25nUHRyKGh3bmQsIEdXTFBfVVNFUkRBVEEpOwoJCQkJR2V0V2luZG93VGV4dChHZXREbGdJdGVtKGh3bmQsIDIwMSksIGRlc3QsIE1BWF9QQVRIKTsKCQkJCUVuZERpYWxvZyhod25kLCBpZCk7CgkJCQlicmVhazt9CgoJCQkgIGNhc2UgSURDQU5DRUw6CgkJCQlFbmREaWFsb2coaHduZCwgaWQpOwoJCQkJYnJlYWs7CgoJCQkgIGNhc2UgMjU0OgoJCQkJTWVzc2FnZUJveChod25kLCBSUyhiMSxJRFNfTk9fSU1QTCksIFJTKGIyLElEU19XSU5FRklMRSksIE1CX09LKTsKCQkJCWJyZWFrOwoJCQl9CgoJCQlyZXR1cm4gMTsKCQl9Cgl9CgoJcmV0dXJuIDA7Cn0KCgpzdHJ1Y3QgRmlsdGVyRGlhbG9nIHsKCVRDSEFSCXBhdHRlcm5bTUFYX1BBVEhdOwoJaW50CQlmbGFnczsKfTsKCnN0YXRpYyBJTlRfUFRSIENBTExCQUNLIEZpbHRlckRpYWxvZ0RsZ1Byb2MoSFdORCBod25kLCBVSU5UIG5tc2csIFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pCnsKCXN0YXRpYyBzdHJ1Y3QgRmlsdGVyRGlhbG9nKiBkbGc7CgoJc3dpdGNoKG5tc2cpIHsKCQljYXNlIFdNX0lOSVRESUFMT0c6CgkJCWRsZyA9IChzdHJ1Y3QgRmlsdGVyRGlhbG9nKikgbHBhcmFtOwoJCQlTZXRXaW5kb3dUZXh0KEdldERsZ0l0ZW0oaHduZCwgSURDX1ZJRVdfUEFUVEVSTiksIGRsZy0+cGF0dGVybik7CgkJCXNldF9jaGVjayhod25kLCBJRENfVklFV19UWVBFX0RJUkVDVE9SSUVTLCBkbGctPmZsYWdzJlRGX0RJUkVDVE9SSUVTKTsKCQkJc2V0X2NoZWNrKGh3bmQsIElEQ19WSUVXX1RZUEVfUFJPR1JBTVMsIGRsZy0+ZmxhZ3MmVEZfUFJPR1JBTVMpOwoJCQlzZXRfY2hlY2soaHduZCwgSURDX1ZJRVdfVFlQRV9ET0NVTUVOVFMsIGRsZy0+ZmxhZ3MmVEZfRE9DVU1FTlRTKTsKCQkJc2V0X2NoZWNrKGh3bmQsIElEQ19WSUVXX1RZUEVfT1RIRVJTLCBkbGctPmZsYWdzJlRGX09USEVSUyk7CgkJCXNldF9jaGVjayhod25kLCBJRENfVklFV19UWVBFX0hJRERFTiwgZGxnLT5mbGFncyZURl9ISURERU4pOwoJCQlyZXR1cm4gMTsKCgkJY2FzZSBXTV9DT01NQU5EOiB7CgkJCWludCBpZCA9IChpbnQpd3BhcmFtOwoKCQkJaWYgKGlkID09IElET0spIHsKCQkJCWludCBmbGFncyA9IDA7CgoJCQkJR2V0V2luZG93VGV4dChHZXREbGdJdGVtKGh3bmQsIElEQ19WSUVXX1BBVFRFUk4pLCBkbGctPnBhdHRlcm4sIE1BWF9QQVRIKTsKCgkJCQlmbGFncyB8PSBnZXRfY2hlY2soaHduZCwgSURDX1ZJRVdfVFlQRV9ESVJFQ1RPUklFUykgPyBURl9ESVJFQ1RPUklFUyA6IDA7CgkJCQlmbGFncyB8PSBnZXRfY2hlY2soaHduZCwgSURDX1ZJRVdfVFlQRV9QUk9HUkFNUykgPyBURl9QUk9HUkFNUyA6IDA7CgkJCQlmbGFncyB8PSBnZXRfY2hlY2soaHduZCwgSURDX1ZJRVdfVFlQRV9ET0NVTUVOVFMpID8gVEZfRE9DVU1FTlRTIDogMDsKCQkJCWZsYWdzIHw9IGdldF9jaGVjayhod25kLCBJRENfVklFV19UWVBFX09USEVSUykgPyBURl9PVEhFUlMgOiAwOwoJCQkJZmxhZ3MgfD0gZ2V0X2NoZWNrKGh3bmQsIElEQ19WSUVXX1RZUEVfSElEREVOKSA/IFRGX0hJRERFTiA6IDA7CgoJCQkJZGxnLT5mbGFncyA9IGZsYWdzOwoKCQkJCUVuZERpYWxvZyhod25kLCBpZCk7CgkJCX0gZWxzZSBpZiAoaWQgPT0gSURDQU5DRUwpCgkJCQlFbmREaWFsb2coaHduZCwgaWQpOwoKCQkJcmV0dXJuIDE7fQoJfQoKCXJldHVybiAwOwp9CgoKc3RydWN0IFByb3BlcnRpZXNEaWFsb2cgewoJVENIQVIJcGF0aFtNQVhfUEFUSF07CglFbnRyeQllbnRyeTsKCXZvaWQqCXBWZXJzaW9uRGF0YTsKfTsKCi8qIFN0cnVjdHVyZSB1c2VkIHRvIHN0b3JlIGVudW1lcmF0ZWQgbGFuZ3VhZ2VzIGFuZCBjb2RlIHBhZ2VzLiAqLwpzdHJ1Y3QgTEFOR0FORENPREVQQUdFIHsKCVdPUkQgd0xhbmd1YWdlOwoJV09SRCB3Q29kZVBhZ2U7Cn0gKmxwVHJhbnNsYXRlOwoKc3RhdGljIExQQ1NUUiBJbmZvU3RyaW5nc1tdID0gewoJIkNvbW1lbnRzIiwKCSJDb21wYW55TmFtZSIsCgkiRmlsZURlc2NyaXB0aW9uIiwKCSJGaWxlVmVyc2lvbiIsCgkiSW50ZXJuYWxOYW1lIiwKCSJMZWdhbENvcHlyaWdodCIsCgkiTGVnYWxUcmFkZW1hcmtzIiwKCSJPcmlnaW5hbEZpbGVuYW1lIiwKCSJQcml2YXRlQnVpbGQiLAoJIlByb2R1Y3ROYW1lIiwKCSJQcm9kdWN0VmVyc2lvbiIsCgkiU3BlY2lhbEJ1aWxkIiwKCU5VTEwKfTsKCnN0YXRpYyB2b2lkIFByb3BEbGdfRGlzcGxheVZhbHVlKEhXTkQgaGxib3gsIEhXTkQgaGVkaXQpCnsKCWludCBpZHggPSBTZW5kTWVzc2FnZShobGJveCwgTEJfR0VUQ1VSU0VMLCAwLCAwKTsKCglpZiAoaWR4ICE9IExCX0VSUikgewoJCUxQQ1RTVFIgcFZhbHVlID0gKExQQ1RTVFIpIFNlbmRNZXNzYWdlKGhsYm94LCBMQl9HRVRJVEVNREFUQSwgaWR4LCAwKTsKCgkJaWYgKHBWYWx1ZSkKCQkJU2V0V2luZG93VGV4dChoZWRpdCwgcFZhbHVlKTsKCX0KfQoKc3RhdGljIHZvaWQgQ2hlY2tGb3JGaWxlSW5mbyhzdHJ1Y3QgUHJvcGVydGllc0RpYWxvZyogZGxnLCBIV05EIGh3bmQsIExQQ1RTVFIgc3RyRmlsZW5hbWUpCnsKCXN0YXRpYyBUQ0hBUiBzQmFja1NsYXNoW10gPSB7J1xcJywnXDAnfTsKCXN0YXRpYyBUQ0hBUiBzVHJhbnNsYXRpb25bXSA9IHsnXFwnLCdWJywnYScsJ3InLCdGJywnaScsJ2wnLCdlJywnSScsJ24nLCdmJywnbycsJ1xcJywnVCcsJ3InLCdhJywnbicsJ3MnLCdsJywnYScsJ3QnLCdpJywnbycsJ24nLCdcMCd9OwoJc3RhdGljIFRDSEFSIHNTdHJpbmdGaWxlSW5mb1tdID0geydcXCcsJ1MnLCd0JywncicsJ2knLCduJywnZycsJ0YnLCdpJywnbCcsJ2UnLCdJJywnbicsJ2YnLCdvJywnXFwnLAoJCQkJCQkJCQkJJyUnLCcwJywnNCcsJ3gnLCclJywnMCcsJzQnLCd4JywnXFwnLCclJywncycsJ1wwJ307CglEV09SRCBkd1ZlcnNpb25EYXRhTGVuID0gR2V0RmlsZVZlcnNpb25JbmZvU2l6ZShzdHJGaWxlbmFtZSwgTlVMTCk7CgoJaWYgKGR3VmVyc2lvbkRhdGFMZW4pIHsKCQlkbGctPnBWZXJzaW9uRGF0YSA9IEhlYXBBbGxvYyhHZXRQcm9jZXNzSGVhcCgpLCAwLCBkd1ZlcnNpb25EYXRhTGVuKTsKCgkJaWYgKEdldEZpbGVWZXJzaW9uSW5mbyhzdHJGaWxlbmFtZSwgMCwgZHdWZXJzaW9uRGF0YUxlbiwgZGxnLT5wVmVyc2lvbkRhdGEpKSB7CgkJCUxQVk9JRCBwVmFsOwoJCQlVSU5UIG5WYWxMZW47CgoJCQlpZiAoVmVyUXVlcnlWYWx1ZShkbGctPnBWZXJzaW9uRGF0YSwgc0JhY2tTbGFzaCwgJnBWYWwsICZuVmFsTGVuKSkgewoJCQkJaWYgKG5WYWxMZW4gPT0gc2l6ZW9mKFZTX0ZJWEVERklMRUlORk8pKSB7CgkJCQkJVlNfRklYRURGSUxFSU5GTyogcEZpeGVkRmlsZUluZm8gPSAoVlNfRklYRURGSUxFSU5GTyopcFZhbDsKCQkJCQljaGFyIGJ1ZmZlcltCVUZGRVJfTEVOXTsKCgkJCQkJc3ByaW50ZihidWZmZXIsICIlZC4lZC4lZC4lZCIsCgkJCQkJCUhJV09SRChwRml4ZWRGaWxlSW5mby0+ZHdGaWxlVmVyc2lvbk1TKSwgTE9XT1JEKHBGaXhlZEZpbGVJbmZvLT5kd0ZpbGVWZXJzaW9uTVMpLAoJCQkJCQlISVdPUkQocEZpeGVkRmlsZUluZm8tPmR3RmlsZVZlcnNpb25MUyksIExPV09SRChwRml4ZWRGaWxlSW5mby0+ZHdGaWxlVmVyc2lvbkxTKSk7CgoJCQkJCVNldERsZ0l0ZW1UZXh0QShod25kLCBJRENfU1RBVElDX1BST1BfVkVSU0lPTiwgYnVmZmVyKTsKCQkJCX0KCQkJfQoKCQkJLyogUmVhZCB0aGUgbGlzdCBvZiBsYW5ndWFnZXMgYW5kIGNvZGUgcGFnZXMuICovCgkJCWlmIChWZXJRdWVyeVZhbHVlKGRsZy0+cFZlcnNpb25EYXRhLCBzVHJhbnNsYXRpb24sICZwVmFsLCAmblZhbExlbikpIHsKCQkJCXN0cnVjdCBMQU5HQU5EQ09ERVBBR0UqIHBUcmFuc2xhdGUgPSAoc3RydWN0IExBTkdBTkRDT0RFUEFHRSopcFZhbDsKCQkJCXN0cnVjdCBMQU5HQU5EQ09ERVBBR0UqIHBFbmQgPSAoc3RydWN0IExBTkdBTkRDT0RFUEFHRSopKChMUEJZVEUpcFZhbCtuVmFsTGVuKTsKCgkJCQlIV05EIGhsYm94ID0gR2V0RGxnSXRlbShod25kLCBJRENfTElTVF9QUk9QX1ZFUlNJT05fVFlQRVMpOwoKCQkJCS8qIFJlYWQgdGhlIGZpbGUgZGVzY3JpcHRpb24gZm9yIGVhY2ggbGFuZ3VhZ2UgYW5kIGNvZGUgcGFnZS4gKi8KCQkJCWZvcig7IHBUcmFuc2xhdGU8cEVuZDsgKytwVHJhbnNsYXRlKSB7CgkJCQkJTFBDU1RSKiBwOwoKCQkJCQlmb3IocD1JbmZvU3RyaW5nczsgKnA7ICsrcCkgewoJCQkJCQlUQ0hBUiBzdWJibG9ja1syMDBdOwojaWZkZWYgVU5JQ09ERQoJCQkJCQlUQ0hBUiBpbmZvU3RyWzEwMF07CiNlbmRpZgoJCQkJCQlMUENUU1RSIHBUeHQ7CgkJCQkJCVVJTlQgblZhbExlbjsKCgkJCQkJCUxQQ1NUUiBwSW5mb1N0cmluZyA9ICpwOwojaWZkZWYgVU5JQ09ERQoJCQkJCQlNdWx0aUJ5dGVUb1dpZGVDaGFyKENQX0FDUCwgMCwgcEluZm9TdHJpbmcsIC0xLCBpbmZvU3RyLCAxMDApOwojZWxzZQojZGVmaW5lCWluZm9TdHIgcEluZm9TdHJpbmcKI2VuZGlmCgkJCQkJCXdzcHJpbnRmKHN1YmJsb2NrLCBzU3RyaW5nRmlsZUluZm8sIHBUcmFuc2xhdGUtPndMYW5ndWFnZSwgcFRyYW5zbGF0ZS0+d0NvZGVQYWdlLCBpbmZvU3RyKTsKCgkJCQkJCS8qIFJldHJpZXZlIGZpbGUgZGVzY3JpcHRpb24gZm9yIGxhbmd1YWdlIGFuZCBjb2RlIHBhZ2UgKi8KCQkJCQkJaWYgKFZlclF1ZXJ5VmFsdWUoZGxnLT5wVmVyc2lvbkRhdGEsIHN1YmJsb2NrLCAoUFZPSUQpJnBUeHQsICZuVmFsTGVuKSkgewoJCQkJCQkJaW50IGlkeCA9IFNlbmRNZXNzYWdlKGhsYm94LCBMQl9BRERTVFJJTkcsIDBMLCAoTFBBUkFNKWluZm9TdHIpOwoJCQkJCQkJU2VuZE1lc3NhZ2UoaGxib3gsIExCX1NFVElURU1EQVRBLCBpZHgsIChMUEFSQU0pIHBUeHQpOwoJCQkJCQl9CgkJCQkJfQoJCQkJfQoKCQkJCVNlbmRNZXNzYWdlKGhsYm94LCBMQl9TRVRDVVJTRUwsIDAsIDApOwoKCQkJCVByb3BEbGdfRGlzcGxheVZhbHVlKGhsYm94LCBHZXREbGdJdGVtKGh3bmQsSURDX0xJU1RfUFJPUF9WRVJTSU9OX1ZBTFVFUykpOwoJCQl9CgkJfQoJfQp9CgpzdGF0aWMgSU5UX1BUUiBDQUxMQkFDSyBQcm9wZXJ0aWVzRGlhbG9nRGxnUHJvYyhIV05EIGh3bmQsIFVJTlQgbm1zZywgV1BBUkFNIHdwYXJhbSwgTFBBUkFNIGxwYXJhbSkKewoJc3RhdGljIHN0cnVjdCBQcm9wZXJ0aWVzRGlhbG9nKiBkbGc7CgoJc3dpdGNoKG5tc2cpIHsKCQljYXNlIFdNX0lOSVRESUFMT0c6IHsKCQkJc3RhdGljIGNvbnN0IFRDSEFSIHNCeXRlRm10W10gPSB7JyUnLCdzJywnICcsJ0InLCd5JywndCcsJ2UnLCdzJywnXDAnfTsKCQkJVENIQVIgYjFbQlVGRkVSX0xFTl0sIGIyW0JVRkZFUl9MRU5dOwoJCQlMUFdJTjMyX0ZJTkRfREFUQSBwV0ZEOwoJCQlVTE9OR0xPTkcgc2l6ZTsKCgkJCWRsZyA9IChzdHJ1Y3QgUHJvcGVydGllc0RpYWxvZyopIGxwYXJhbTsKCQkJcFdGRCA9IChMUFdJTjMyX0ZJTkRfREFUQSkgJmRsZy0+ZW50cnkuZGF0YTsKCgkJCUdldFdpbmRvd1RleHQoaHduZCwgYjEsIE1BWF9QQVRIKTsKCQkJd3NwcmludGYoYjIsIGIxLCBwV0ZELT5jRmlsZU5hbWUpOwoJCQlTZXRXaW5kb3dUZXh0KGh3bmQsIGIyKTsKCgkJCWZvcm1hdF9kYXRlKCZwV0ZELT5mdExhc3RXcml0ZVRpbWUsIGIxLCBDT0xfREFURXxDT0xfVElNRSk7CgkJCVNldFdpbmRvd1RleHQoR2V0RGxnSXRlbShod25kLCBJRENfU1RBVElDX1BST1BfTEFTVENIQU5HRSksIGIxKTsKCgkJCXNpemUgPSAoKFVMT05HTE9ORylwV0ZELT5uRmlsZVNpemVIaWdoIDw8IDMyKSB8IHBXRkQtPm5GaWxlU2l6ZUxvdzsKCQkJX3N0cHJpbnRmKGIxLCBzTG9uZ051bUZtdCwgc2l6ZSk7CgkJCXdzcHJpbnRmKGIyLCBzQnl0ZUZtdCwgYjEpOwoJCQlTZXRXaW5kb3dUZXh0KEdldERsZ0l0ZW0oaHduZCwgSURDX1NUQVRJQ19QUk9QX1NJWkUpLCBiMik7CgoJCQlTZXRXaW5kb3dUZXh0KEdldERsZ0l0ZW0oaHduZCwgSURDX1NUQVRJQ19QUk9QX0ZJTEVOQU1FKSwgcFdGRC0+Y0ZpbGVOYW1lKTsKCQkJU2V0V2luZG93VGV4dChHZXREbGdJdGVtKGh3bmQsIElEQ19TVEFUSUNfUFJPUF9QQVRIKSwgZGxnLT5wYXRoKTsKCgkJCXNldF9jaGVjayhod25kLCBJRENfQ0hFQ0tfUkVBRE9OTFksIHBXRkQtPmR3RmlsZUF0dHJpYnV0ZXMmRklMRV9BVFRSSUJVVEVfUkVBRE9OTFkpOwoJCQlzZXRfY2hlY2soaHduZCwgSURDX0NIRUNLX0FSQ0hJVkUsIHBXRkQtPmR3RmlsZUF0dHJpYnV0ZXMmRklMRV9BVFRSSUJVVEVfQVJDSElWRSk7CgkJCXNldF9jaGVjayhod25kLCBJRENfQ0hFQ0tfQ09NUFJFU1NFRCwgcFdGRC0+ZHdGaWxlQXR0cmlidXRlcyZGSUxFX0FUVFJJQlVURV9DT01QUkVTU0VEKTsKCQkJc2V0X2NoZWNrKGh3bmQsIElEQ19DSEVDS19ISURERU4sIHBXRkQtPmR3RmlsZUF0dHJpYnV0ZXMmRklMRV9BVFRSSUJVVEVfSElEREVOKTsKCQkJc2V0X2NoZWNrKGh3bmQsIElEQ19DSEVDS19TWVNURU0sIHBXRkQtPmR3RmlsZUF0dHJpYnV0ZXMmRklMRV9BVFRSSUJVVEVfU1lTVEVNKTsKCgkJCUNoZWNrRm9yRmlsZUluZm8oZGxnLCBod25kLCBkbGctPnBhdGgpOwoJCQlyZXR1cm4gMTt9CgoJCWNhc2UgV01fQ09NTUFORDogewoJCQlpbnQgaWQgPSAoaW50KXdwYXJhbTsKCgkJCXN3aXRjaChISVdPUkQod3BhcmFtKSkgewoJCQkgIGNhc2UgTEJOX1NFTENIQU5HRTogewoJCQkJSFdORCBobGJveCA9IEdldERsZ0l0ZW0oaHduZCwgSURDX0xJU1RfUFJPUF9WRVJTSU9OX1RZUEVTKTsKCQkJCVByb3BEbGdfRGlzcGxheVZhbHVlKGhsYm94LCBHZXREbGdJdGVtKGh3bmQsSURDX0xJU1RfUFJPUF9WRVJTSU9OX1ZBTFVFUykpOwoJCQkJYnJlYWs7CgkJCSAgfQoKCQkJICBjYXNlIEJOX0NMSUNLRUQ6CgkJCQlpZiAoaWQ9PUlET0sgfHwgaWQ9PUlEQ0FOQ0VMKQoJCQkJCUVuZERpYWxvZyhod25kLCBpZCk7CgkJCX0KCgkJCXJldHVybiAxO30KCgkJY2FzZSBXTV9OQ0RFU1RST1k6CgkJCUhlYXBGcmVlKEdldFByb2Nlc3NIZWFwKCksIDAsIGRsZy0+cFZlcnNpb25EYXRhKTsKCQkJZGxnLT5wVmVyc2lvbkRhdGEgPSBOVUxMOwoJCQlicmVhazsKCX0KCglyZXR1cm4gMDsKfQoKc3RhdGljIHZvaWQgc2hvd19wcm9wZXJ0aWVzX2RsZyhFbnRyeSogZW50cnksIEhXTkQgaHduZCkKewoJc3RydWN0IFByb3BlcnRpZXNEaWFsb2cgZGxnOwoKCW1lbXNldCgmZGxnLCAwLCBzaXplb2Yoc3RydWN0IFByb3BlcnRpZXNEaWFsb2cpKTsKCWdldF9wYXRoKGVudHJ5LCBkbGcucGF0aCk7CgltZW1jcHkoJmRsZy5lbnRyeSwgZW50cnksIHNpemVvZihFbnRyeSkpOwoKCURpYWxvZ0JveFBhcmFtKEdsb2JhbHMuaEluc3RhbmNlLCBNQUtFSU5UUkVTT1VSQ0UoSUREX0RJQUxPR19QUk9QRVJUSUVTKSwgaHduZCwgUHJvcGVydGllc0RpYWxvZ0RsZ1Byb2MsIChMUEFSQU0pJmRsZyk7Cn0KCgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgpzdGF0aWMgc3RydWN0IEZ1bGxTY3JlZW5QYXJhbWV0ZXJzIHsKCUJPT0wJbW9kZTsKCVJFQ1QJb3JnUG9zOwoJQk9PTAl3YXNab29tZWQ7Cn0gZ19mdWxsc2NyZWVuID0gewogICAgRkFMU0UsCS8qIG1vZGUgKi8KCXswLCAwLCAwLCAwfSwKCUZBTFNFCn07CgpzdGF0aWMgdm9pZCBmcmFtZV9nZXRfY2xpZW50c3BhY2UoSFdORCBod25kLCBQUkVDVCBwcmVjdCkKewoJUkVDVCBydDsKCglpZiAoIUlzSWNvbmljKGh3bmQpKQoJCUdldENsaWVudFJlY3QoaHduZCwgcHJlY3QpOwoJZWxzZSB7CgkJV0lORE9XUExBQ0VNRU5UIHdwOwoKCQlHZXRXaW5kb3dQbGFjZW1lbnQoaHduZCwgJndwKTsKCgkJcHJlY3QtPmxlZnQgPSBwcmVjdC0+dG9wID0gMDsKCQlwcmVjdC0+cmlnaHQgPSB3cC5yY05vcm1hbFBvc2l0aW9uLnJpZ2h0LXdwLnJjTm9ybWFsUG9zaXRpb24ubGVmdC0KCQkJCQkJMiooR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkVGUkFNRSkrR2V0U3lzdGVtTWV0cmljcyhTTV9DWEVER0UpKTsKCQlwcmVjdC0+Ym90dG9tID0gd3AucmNOb3JtYWxQb3NpdGlvbi5ib3R0b20td3AucmNOb3JtYWxQb3NpdGlvbi50b3AtCgkJCQkJCTIqKEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFRlJBTUUpK0dldFN5c3RlbU1ldHJpY3MoU01fQ1lFREdFKSktCgkJCQkJCUdldFN5c3RlbU1ldHJpY3MoU01fQ1lDQVBUSU9OKS1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVVNJWkUpOwoJfQoKCWlmIChJc1dpbmRvd1Zpc2libGUoR2xvYmFscy5odG9vbGJhcikpIHsKCQlHZXRDbGllbnRSZWN0KEdsb2JhbHMuaHRvb2xiYXIsICZydCk7CgkJcHJlY3QtPnRvcCArPSBydC5ib3R0b20rMjsKCX0KCglpZiAoSXNXaW5kb3dWaXNpYmxlKEdsb2JhbHMuaGRyaXZlYmFyKSkgewoJCUdldENsaWVudFJlY3QoR2xvYmFscy5oZHJpdmViYXIsICZydCk7CgkJcHJlY3QtPnRvcCArPSBydC5ib3R0b20rMjsKCX0KCglpZiAoSXNXaW5kb3dWaXNpYmxlKEdsb2JhbHMuaHN0YXR1c2JhcikpIHsKCQlHZXRDbGllbnRSZWN0KEdsb2JhbHMuaHN0YXR1c2JhciwgJnJ0KTsKCQlwcmVjdC0+Ym90dG9tIC09IHJ0LmJvdHRvbTsKCX0KfQoKc3RhdGljIEJPT0wgdG9nZ2xlX2Z1bGxzY3JlZW4oSFdORCBod25kKQp7CglSRUNUIHJ0OwoKCWlmICgoZ19mdWxsc2NyZWVuLm1vZGU9IWdfZnVsbHNjcmVlbi5tb2RlKSkgewoJCUdldFdpbmRvd1JlY3QoaHduZCwgJmdfZnVsbHNjcmVlbi5vcmdQb3MpOwoJCWdfZnVsbHNjcmVlbi53YXNab29tZWQgPSBJc1pvb21lZChod25kKTsKCgkJRnJhbWVfQ2FsY0ZyYW1lQ2xpZW50KGh3bmQsICZydCk7CgkJQ2xpZW50VG9TY3JlZW4oaHduZCwgKExQUE9JTlQpJnJ0LmxlZnQpOwoJCUNsaWVudFRvU2NyZWVuKGh3bmQsIChMUFBPSU5UKSZydC5yaWdodCk7CgoJCXJ0LmxlZnQgPSBnX2Z1bGxzY3JlZW4ub3JnUG9zLmxlZnQtcnQubGVmdDsKCQlydC50b3AgPSBnX2Z1bGxzY3JlZW4ub3JnUG9zLnRvcC1ydC50b3A7CgkJcnQucmlnaHQgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOKStnX2Z1bGxzY3JlZW4ub3JnUG9zLnJpZ2h0LXJ0LnJpZ2h0OwoJCXJ0LmJvdHRvbSA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTQ1JFRU4pK2dfZnVsbHNjcmVlbi5vcmdQb3MuYm90dG9tLXJ0LmJvdHRvbTsKCgkJTW92ZVdpbmRvdyhod25kLCBydC5sZWZ0LCBydC50b3AsIHJ0LnJpZ2h0LXJ0LmxlZnQsIHJ0LmJvdHRvbS1ydC50b3AsIFRSVUUpOwoJfSBlbHNlIHsKCQlNb3ZlV2luZG93KGh3bmQsIGdfZnVsbHNjcmVlbi5vcmdQb3MubGVmdCwgZ19mdWxsc2NyZWVuLm9yZ1Bvcy50b3AsCgkJCQkJCQlnX2Z1bGxzY3JlZW4ub3JnUG9zLnJpZ2h0LWdfZnVsbHNjcmVlbi5vcmdQb3MubGVmdCwKCQkJCQkJCWdfZnVsbHNjcmVlbi5vcmdQb3MuYm90dG9tLWdfZnVsbHNjcmVlbi5vcmdQb3MudG9wLCBUUlVFKTsKCgkJaWYgKGdfZnVsbHNjcmVlbi53YXNab29tZWQpCgkJCVNob3dXaW5kb3coaHduZCwgV1NfTUFYSU1JWkUpOwoJfQoKCXJldHVybiBnX2Z1bGxzY3JlZW4ubW9kZTsKfQoKc3RhdGljIHZvaWQgZnVsbHNjcmVlbl9tb3ZlKEhXTkQgaHduZCkKewoJUkVDVCBydCwgcG9zOwoJR2V0V2luZG93UmVjdChod25kLCAmcG9zKTsKCglGcmFtZV9DYWxjRnJhbWVDbGllbnQoaHduZCwgJnJ0KTsKCUNsaWVudFRvU2NyZWVuKGh3bmQsIChMUFBPSU5UKSZydC5sZWZ0KTsKCUNsaWVudFRvU2NyZWVuKGh3bmQsIChMUFBPSU5UKSZydC5yaWdodCk7CgoJcnQubGVmdCA9IHBvcy5sZWZ0LXJ0LmxlZnQ7CglydC50b3AgPSBwb3MudG9wLXJ0LnRvcDsKCXJ0LnJpZ2h0ID0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNDUkVFTikrcG9zLnJpZ2h0LXJ0LnJpZ2h0OwoJcnQuYm90dG9tID0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNDUkVFTikrcG9zLmJvdHRvbS1ydC5ib3R0b207CgoJTW92ZVdpbmRvdyhod25kLCBydC5sZWZ0LCBydC50b3AsIHJ0LnJpZ2h0LXJ0LmxlZnQsIHJ0LmJvdHRvbS1ydC50b3AsIFRSVUUpOwp9CgojZW5kaWYKCgpzdGF0aWMgdm9pZCB0b2dnbGVfY2hpbGQoSFdORCBod25kLCBVSU5UIGNtZCwgSFdORCBoY2hpbGQpCnsKCUJPT0wgdmlzID0gSXNXaW5kb3dWaXNpYmxlKGhjaGlsZCk7CgoJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51T3B0aW9ucywgY21kLCB2aXM/TUZfQllDT01NQU5EOk1GX0JZQ09NTUFORHxNRl9DSEVDS0VEKTsKCglTaG93V2luZG93KGhjaGlsZCwgdmlzP1NXX0hJREU6U1dfU0hPVyk7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCglpZiAoZ19mdWxsc2NyZWVuLm1vZGUpCgkJZnVsbHNjcmVlbl9tb3ZlKGh3bmQpOwojZW5kaWYKCglyZXNpemVfZnJhbWVfY2xpZW50KGh3bmQpOwp9CgpzdGF0aWMgQk9PTCBhY3RpdmF0ZV9kcml2ZV93aW5kb3coTFBDVFNUUiBwYXRoKQp7CglUQ0hBUiBkcnYxW19NQVhfRFJJVkVdLCBkcnYyW19NQVhfRFJJVkVdOwoJSFdORCBjaGlsZF93bmQ7CgoJX3RzcGxpdHBhdGgocGF0aCwgZHJ2MSwgMCwgMCwgMCk7CgoJLyogc2VhcmNoIGZvciBhIGFscmVhZHkgb3BlbiB3aW5kb3cgZm9yIHRoZSBzYW1lIGRyaXZlICovCglmb3IoY2hpbGRfd25kPUdldE5leHRXaW5kb3coR2xvYmFscy5obWRpY2xpZW50LEdXX0NISUxEKTsgY2hpbGRfd25kOyBjaGlsZF93bmQ9R2V0TmV4dFdpbmRvdyhjaGlsZF93bmQsIEdXX0hXTkRORVhUKSkgewoJCUNoaWxkV25kKiBjaGlsZCA9IChDaGlsZFduZCopIEdldFdpbmRvd0xvbmdQdHIoY2hpbGRfd25kLCBHV0xQX1VTRVJEQVRBKTsKCgkJaWYgKGNoaWxkKSB7CgkJCV90c3BsaXRwYXRoKGNoaWxkLT5yb290LnBhdGgsIGRydjIsIDAsIDAsIDApOwoKCQkJaWYgKCFsc3RyY21waShkcnYyLCBkcnYxKSkgewoJCQkJU2VuZE1lc3NhZ2UoR2xvYmFscy5obWRpY2xpZW50LCBXTV9NRElBQ1RJVkFURSwgKFdQQVJBTSljaGlsZF93bmQsIDApOwoKCQkJCWlmIChJc0ljb25pYyhjaGlsZF93bmQpKQoJCQkJCVNob3dXaW5kb3coY2hpbGRfd25kLCBTV19TSE9XTk9STUFMKTsKCgkJCQlyZXR1cm4gVFJVRTsKCQkJfQoJCX0KCX0KCglyZXR1cm4gRkFMU0U7Cn0KCnN0YXRpYyBCT09MIGFjdGl2YXRlX2ZzX3dpbmRvdyhMUENUU1RSIGZpbGVzeXMpCnsKCUhXTkQgY2hpbGRfd25kOwoKCS8qIHNlYXJjaCBmb3IgYSBhbHJlYWR5IG9wZW4gd2luZG93IG9mIHRoZSBnaXZlbiBmaWxlIHN5c3RlbSBuYW1lICovCglmb3IoY2hpbGRfd25kPUdldE5leHRXaW5kb3coR2xvYmFscy5obWRpY2xpZW50LEdXX0NISUxEKTsgY2hpbGRfd25kOyBjaGlsZF93bmQ9R2V0TmV4dFdpbmRvdyhjaGlsZF93bmQsIEdXX0hXTkRORVhUKSkgewoJCUNoaWxkV25kKiBjaGlsZCA9IChDaGlsZFduZCopIEdldFdpbmRvd0xvbmdQdHIoY2hpbGRfd25kLCBHV0xQX1VTRVJEQVRBKTsKCgkJaWYgKGNoaWxkKSB7CgkJCWlmICghbHN0cmNtcGkoY2hpbGQtPnJvb3QuZnMsIGZpbGVzeXMpKSB7CgkJCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESUFDVElWQVRFLCAoV1BBUkFNKWNoaWxkX3duZCwgMCk7CgoJCQkJaWYgKElzSWNvbmljKGNoaWxkX3duZCkpCgkJCQkJU2hvd1dpbmRvdyhjaGlsZF93bmQsIFNXX1NIT1dOT1JNQUwpOwoKCQkJCXJldHVybiBUUlVFOwoJCQl9CgkJfQoJfQoKCXJldHVybiBGQUxTRTsKfQoKc3RhdGljIExSRVNVTFQgQ0FMTEJBQ0sgRnJhbWVXbmRQcm9jKEhXTkQgaHduZCwgVUlOVCBubXNnLCBXUEFSQU0gd3BhcmFtLCBMUEFSQU0gbHBhcmFtKQp7CglUQ0hBUiBiMVtCVUZGRVJfTEVOXSwgYjJbQlVGRkVSX0xFTl07CgoJc3dpdGNoKG5tc2cpIHsKCQljYXNlIFdNX0NMT1NFOgoJCQlpZiAoR2xvYmFscy5zYXZlU2V0dGluZ3MpCgkJCQlzYXZlX3JlZ2lzdHJ5X3NldHRpbmdzKCk7ICAKCQkJCgkJCURlc3Ryb3lXaW5kb3coaHduZCk7CgoJCQkgLyogY2xlYXIgaGFuZGxlIHZhcmlhYmxlcyAqLwoJCQlHbG9iYWxzLmhNZW51RnJhbWUgPSAwOwoJCQlHbG9iYWxzLmhNZW51VmlldyA9IDA7CgkJCUdsb2JhbHMuaE1lbnVPcHRpb25zID0gMDsKCQkJR2xvYmFscy5oTWFpblduZCA9IDA7CgkJCUdsb2JhbHMuaG1kaWNsaWVudCA9IDA7CgkJCUdsb2JhbHMuaGRyaXZlYmFyID0gMDsKCQkJYnJlYWs7CgoJCWNhc2UgV01fREVTVFJPWToKCQkJUG9zdFF1aXRNZXNzYWdlKDApOwoJCQlicmVhazsKCgkJY2FzZSBXTV9JTklUTUVOVVBPUFVQOiB7CgkJCUhXTkQgaHduZENsaWVudCA9IChIV05EKSBTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESUdFVEFDVElWRSwgMCwgMCk7CgoJCQlpZiAoIVNlbmRNZXNzYWdlKGh3bmRDbGllbnQsIFdNX0lOSVRNRU5VUE9QVVAsIHdwYXJhbSwgbHBhcmFtKSkKCQkJCXJldHVybiAwOwoJCQlicmVhazt9CgoJCWNhc2UgV01fQ09NTUFORDogewoJCQlVSU5UIGNtZCA9IExPV09SRCh3cGFyYW0pOwoJCQlIV05EIGh3bmRDbGllbnQgPSAoSFdORCkgU2VuZE1lc3NhZ2UoR2xvYmFscy5obWRpY2xpZW50LCBXTV9NRElHRVRBQ1RJVkUsIDAsIDApOwoKCQkJaWYgKFNlbmRNZXNzYWdlKGh3bmRDbGllbnQsIFdNX0RJU1BBVENIX0NPTU1BTkQsIHdwYXJhbSwgbHBhcmFtKSkKCQkJCWJyZWFrOwoKCQkJaWYgKGNtZD49SURfRFJJVkVfRklSU1QgJiYgY21kPD1JRF9EUklWRV9GSVJTVCsweEZGKSB7CgkJCQlUQ0hBUiBkcnZbX01BWF9EUklWRV0sIHBhdGhbTUFYX1BBVEhdOwoJCQkJQ2hpbGRXbmQqIGNoaWxkOwoJCQkJTFBDVFNUUiByb290ID0gR2xvYmFscy5kcml2ZXM7CgkJCQlpbnQgaTsKCgkJCQlmb3IoaT1jbWQtSURfRFJJVkVfRklSU1Q7IGktLTsgcm9vdCsrKQoJCQkJCXdoaWxlKCpyb290KQoJCQkJCQlyb290Kys7CgoJCQkJaWYgKGFjdGl2YXRlX2RyaXZlX3dpbmRvdyhyb290KSkKCQkJCQlyZXR1cm4gMDsKCgkJCQlfdHNwbGl0cGF0aChyb290LCBkcnYsIDAsIDAsIDApOwoKCQkJCWlmICghU2V0Q3VycmVudERpcmVjdG9yeShkcnYpKSB7CgkJCQkJZGlzcGxheV9lcnJvcihod25kLCBHZXRMYXN0RXJyb3IoKSk7CgkJCQkJcmV0dXJuIDA7CgkJCQl9CgoJCQkJR2V0Q3VycmVudERpcmVjdG9yeShNQVhfUEFUSCwgcGF0aCk7IC8qVE9ETzogc3RvcmUgbGFzdCBkaXJlY3RvcnkgcGVyIGRyaXZlICovCgkJCQljaGlsZCA9IGFsbG9jX2NoaWxkX3dpbmRvdyhwYXRoLCBOVUxMLCBod25kKTsKCgkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3coY2hpbGQpKQoJCQkJCUhlYXBGcmVlKEdldFByb2Nlc3NIZWFwKCksIDAsIGNoaWxkKTsKCQkJfSBlbHNlIHN3aXRjaChjbWQpIHsKCQkJCWNhc2UgSURfRklMRV9FWElUOgoJCQkJCVNlbmRNZXNzYWdlKGh3bmQsIFdNX0NMT1NFLCAwLCAwKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX1dJTkRPV19ORVc6IHsKCQkJCQlUQ0hBUiBwYXRoW01BWF9QQVRIXTsKCQkJCQlDaGlsZFduZCogY2hpbGQ7CgoJCQkJCUdldEN1cnJlbnREaXJlY3RvcnkoTUFYX1BBVEgsIHBhdGgpOwoJCQkJCWNoaWxkID0gYWxsb2NfY2hpbGRfd2luZG93KHBhdGgsIE5VTEwsIGh3bmQpOwoKCQkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3coY2hpbGQpKQoJCQkJCQlIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBjaGlsZCk7CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgSURfUkVGUkVTSDoKCQkJCQlyZWZyZXNoX2RyaXZlcygpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfV0lORE9XX0NBU0NBREU6CgkJCQkJU2VuZE1lc3NhZ2UoR2xvYmFscy5obWRpY2xpZW50LCBXTV9NRElDQVNDQURFLCAwLCAwKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX1dJTkRPV19USUxFX0hPUlo6CgkJCQkJU2VuZE1lc3NhZ2UoR2xvYmFscy5obWRpY2xpZW50LCBXTV9NRElUSUxFLCBNRElUSUxFX0hPUklaT05UQUwsIDApOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfV0lORE9XX1RJTEVfVkVSVDoKCQkJCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhtZGljbGllbnQsIFdNX01ESVRJTEUsIE1ESVRJTEVfVkVSVElDQUwsIDApOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfV0lORE9XX0FSUkFOR0U6CgkJCQkJU2VuZE1lc3NhZ2UoR2xvYmFscy5obWRpY2xpZW50LCBXTV9NRElJQ09OQVJSQU5HRSwgMCwgMCk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9TRUxFQ1RfRk9OVDoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNob29zZV9mb250KGh3bmQpOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWs7CgoJCQkJY2FzZSBJRF9WSUVXX1RPT0xfQkFSOgoJCQkJCXRvZ2dsZV9jaGlsZChod25kLCBjbWQsIEdsb2JhbHMuaHRvb2xiYXIpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfVklFV19EUklWRV9CQVI6CgkJCQkJdG9nZ2xlX2NoaWxkKGh3bmQsIGNtZCwgR2xvYmFscy5oZHJpdmViYXIpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfVklFV19TVEFUVVNCQVI6CgkJCQkJdG9nZ2xlX2NoaWxkKGh3bmQsIGNtZCwgR2xvYmFscy5oc3RhdHVzYmFyKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX1ZJRVdfU0FWRVNFVFRJTkdTOgoJCQkJCUdsb2JhbHMuc2F2ZVNldHRpbmdzID0gIUdsb2JhbHMuc2F2ZVNldHRpbmdzOwoJCQkJCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudU9wdGlvbnMsIElEX1ZJRVdfU0FWRVNFVFRJTkdTLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHbG9iYWxzLnNhdmVTZXR0aW5ncyA/IE1GX0NIRUNLRUQgOiBNRl9VTkNIRUNLRUQgKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX0VYRUNVVEU6IHsKCQkJCQlzdHJ1Y3QgRXhlY3V0ZURpYWxvZyBkbGc7CgoJCQkJCW1lbXNldCgmZGxnLCAwLCBzaXplb2Yoc3RydWN0IEV4ZWN1dGVEaWFsb2cpKTsKCgkJCQkJaWYgKERpYWxvZ0JveFBhcmFtKEdsb2JhbHMuaEluc3RhbmNlLCBNQUtFSU5UUkVTT1VSQ0UoSUREX0VYRUNVVEUpLCBod25kLCBFeGVjdXRlRGlhbG9nRGxnUHJvYywgKExQQVJBTSkmZGxnKSA9PSBJRE9LKSB7CgkJCQkJCUhJTlNUQU5DRSBoaW5zdCA9IFNoZWxsRXhlY3V0ZShod25kLCBOVUxMLypvcGVyYXRpb24qLywgZGxnLmNtZC8qZmlsZSovLCBOVUxMLypwYXJhbWV0ZXJzKi8sIE5VTEwvKmRpciovLCBkbGcuY21kc2hvdyk7CgoJCQkJCQlpZiAoKGludCloaW5zdCA8PSAzMikKCQkJCQkJCWRpc3BsYXlfZXJyb3IoaHduZCwgR2V0TGFzdEVycm9yKCkpOwoJCQkJCX0KCQkJCQlicmVhazt9CgoJCQkJY2FzZSBJRF9DT05ORUNUX05FVFdPUktfRFJJVkU6IHsKCQkJCQlEV09SRCByZXQgPSBXTmV0Q29ubmVjdGlvbkRpYWxvZyhod25kLCBSRVNPVVJDRVRZUEVfRElTSyk7CgkJCQkJaWYgKHJldCA9PSBOT19FUlJPUikKCQkJCQkJcmVmcmVzaF9kcml2ZXMoKTsKCQkJCQllbHNlIGlmIChyZXQgIT0gKERXT1JEKS0xKSB7CgkJCQkJCWlmIChyZXQgPT0gRVJST1JfRVhURU5ERURfRVJST1IpCgkJCQkJCQlkaXNwbGF5X25ldHdvcmtfZXJyb3IoaHduZCk7CgkJCQkJCWVsc2UKCQkJCQkJCWRpc3BsYXlfZXJyb3IoaHduZCwgcmV0KTsKCQkJCQl9CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgSURfRElTQ09OTkVDVF9ORVRXT1JLX0RSSVZFOiB7CgkJCQkJRFdPUkQgcmV0ID0gV05ldERpc2Nvbm5lY3REaWFsb2coaHduZCwgUkVTT1VSQ0VUWVBFX0RJU0spOwoJCQkJCWlmIChyZXQgPT0gTk9fRVJST1IpCgkJCQkJCXJlZnJlc2hfZHJpdmVzKCk7CgkJCQkJZWxzZSBpZiAocmV0ICE9IChEV09SRCktMSkgewoJCQkJCQlpZiAocmV0ID09IEVSUk9SX0VYVEVOREVEX0VSUk9SKQoJCQkJCQkJZGlzcGxheV9uZXR3b3JrX2Vycm9yKGh3bmQpOwoJCQkJCQllbHNlCgkJCQkJCQlkaXNwbGF5X2Vycm9yKGh3bmQsIHJldCk7CgkJCQkJfQoJCQkJCWJyZWFrO30KCgkJCQljYXNlIElEX0ZPUk1BVF9ESVNLOiB7CgkJCQkJVUlOVCBzZW1fb3JnID0gU2V0RXJyb3JNb2RlKDApOyAvKiBHZXQgdGhlIGN1cnJlbnQgRXJyb3IgTW9kZSBzZXR0aW5ncy4gKi8KCQkJCQlTZXRFcnJvck1vZGUoc2VtX29yZyAmIH5TRU1fRkFJTENSSVRJQ0FMRVJST1JTKTsgLyogRm9yY2UgTy9TIHRvIGhhbmRsZSAqLwoJCQkJCVNIRm9ybWF0RHJpdmUoaHduZCwgMCAvKiBBOiAqLywgU0hGTVRfSURfREVGQVVMVCwgMCk7CgkJCQkJU2V0RXJyb3JNb2RlKHNlbV9vcmcpOyAvKiBQdXQgaXQgYmFjayB0aGUgd2F5IGl0IHdhcy4gKi8KCQkJCQlicmVhazt9CgoJCQkJY2FzZSBJRF9IRUxQOgoJCQkJCVdpbkhlbHAoaHduZCwgUlMoYjEsSURTX1dJTkVGSUxFKSwgSEVMUF9JTkRFWCwgMCk7CgkJCQkJYnJlYWs7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQljYXNlIElEX1ZJRVdfRlVMTFNDUkVFTjoKCQkJCQlDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVPcHRpb25zLCBjbWQsIHRvZ2dsZV9mdWxsc2NyZWVuKGh3bmQpP01GX0NIRUNLRUQ6MCk7CgkJCQkJYnJlYWs7CgojaWZkZWYgX19XSU5FX18KCQkJCWNhc2UgSURfRFJJVkVfVU5JWF9GUzogewoJCQkJCVRDSEFSIHBhdGhbTUFYX1BBVEhdOwojaWZkZWYgVU5JQ09ERQoJCQkJCWNoYXIgY3BhdGhbTUFYX1BBVEhdOwojZW5kaWYKCQkJCQlDaGlsZFduZCogY2hpbGQ7CgoJCQkJCWlmIChhY3RpdmF0ZV9mc193aW5kb3coUlMoYjEsSURTX1VOSVhGUykpKQoJCQkJCQlicmVhazsKCiNpZmRlZiBVTklDT0RFCgkJCQkJZ2V0Y3dkKGNwYXRoLCBNQVhfUEFUSCk7CgkJCQkJTXVsdGlCeXRlVG9XaWRlQ2hhcihDUF9VTklYQ1AsIDAsIGNwYXRoLCAtMSwgcGF0aCwgTUFYX1BBVEgpOwojZWxzZQoJCQkJCWdldGN3ZChwYXRoLCBNQVhfUEFUSCk7CiNlbmRpZgoJCQkJCWNoaWxkID0gYWxsb2NfY2hpbGRfd2luZG93KHBhdGgsIE5VTEwsIGh3bmQpOwoKCQkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3coY2hpbGQpKQoJCQkJCQlIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBjaGlsZCk7CgkJCQkJYnJlYWs7fQojZW5kaWYKI2lmZGVmIF9TSEVMTF9GT0xERVJTCgkJCQljYXNlIElEX0RSSVZFX1NIRUxMX05TOiB7CgkJCQkJVENIQVIgcGF0aFtNQVhfUEFUSF07CgkJCQkJQ2hpbGRXbmQqIGNoaWxkOwoKCQkJCQlpZiAoYWN0aXZhdGVfZnNfd2luZG93KFJTKGIxLElEU19TSEVMTCkpKQoJCQkJCQlicmVhazsKCgkJCQkJR2V0Q3VycmVudERpcmVjdG9yeShNQVhfUEFUSCwgcGF0aCk7CgkJCQkJY2hpbGQgPSBhbGxvY19jaGlsZF93aW5kb3cocGF0aCwgZ2V0X3BhdGhfcGlkbChwYXRoLGh3bmQpLCBod25kKTsKCgkJCQkJaWYgKCFjcmVhdGVfY2hpbGRfd2luZG93KGNoaWxkKSkKCQkJCQkJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgY2hpbGQpOwoJCQkJCWJyZWFrO30KI2VuZGlmCiNlbmRpZgoKCQkJCS8qVE9ETzogVGhlcmUgYXJlIGV2ZW4gbW9yZSBtZW51IGl0ZW1zISAqLwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwojaWZkZWYgX19XSU5FX18KCQkJCWNhc2UgSURfTElDRU5TRToKCQkJCQlXaW5lTGljZW5zZShHbG9iYWxzLmhNYWluV25kKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX05PX1dBUlJBTlRZOgoJCQkJCVdpbmVXYXJyYW50eShHbG9iYWxzLmhNYWluV25kKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX0FCT1VUX1dJTkU6CgkJCQkJU2hlbGxBYm91dChod25kLCBSUyhiMixJRFNfV0lORSksIFJTKGIxLElEU19XSU5FRklMRSksIDApOwoJCQkJCWJyZWFrOwojZW5kaWYKCgkJCQljYXNlIElEX0FCT1VUOgoJCQkJCVNoZWxsQWJvdXQoaHduZCwgUlMoYjEsSURTX1dJTkVGSUxFKSwgTlVMTCwgMCk7CgkJCQkJYnJlYWs7CiNlbmRpZgkvKiBfTk9fRVhURU5TSU9OUyAqLwoKCQkJCWRlZmF1bHQ6CgkJCQkJLypUT0RPOiBpZiAod1BhcmFtID49IFBNX0ZJUlNUX0xBTkdVQUdFICYmIHdQYXJhbSA8PSBQTV9MQVNUX0xBTkdVQUdFKQoJCQkJCQlTVFJJTkdfU2VsZWN0TGFuZ3VhZ2VCeU51bWJlcih3UGFyYW0gLSBQTV9GSVJTVF9MQU5HVUFHRSk7CgkJCQkJZWxzZSAqL2lmICgoY21kPElEV19GSVJTVF9DSElMRCB8fCBjbWQ+PUlEV19GSVJTVF9DSElMRCsweDEwMCkgJiYKCQkJCQkJKGNtZDxTQ19TSVpFIHx8IGNtZD5TQ19SRVNUT1JFKSkKCQkJCQkJTWVzc2FnZUJveChod25kLCBSUyhiMixJRFNfTk9fSU1QTCksIFJTKGIxLElEU19XSU5FRklMRSksIE1CX09LKTsKCgkJCQkJcmV0dXJuIERlZkZyYW1lUHJvYyhod25kLCBHbG9iYWxzLmhtZGljbGllbnQsIG5tc2csIHdwYXJhbSwgbHBhcmFtKTsKCQkJfQoJCQlicmVhazt9CgoJCWNhc2UgV01fU0laRToKCQkJcmVzaXplX2ZyYW1lKGh3bmQsIExPV09SRChscGFyYW0pLCBISVdPUkQobHBhcmFtKSk7CgkJCWJyZWFrOwkvKiBkbyBub3QgcGFzcyBtZXNzYWdlIHRvIERlZkZyYW1lUHJvYyAqLwoKCQljYXNlIFdNX0RFVklDRUNIQU5HRToKCQkJU2VuZE1lc3NhZ2UoaHduZCwgV01fQ09NTUFORCwgTUFLRUxPTkcoSURfUkVGUkVTSCwwKSwgMCk7CgkJCWJyZWFrOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgV01fR0VUTUlOTUFYSU5GTzogewoJCQlMUE1JTk1BWElORk8gbHBtbWkgPSAoTFBNSU5NQVhJTkZPKWxwYXJhbTsKCgkJCWxwbW1pLT5wdE1heFRyYWNrU2l6ZS54IDw8PSAxOy8qMipHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOKSAvIFNNX0NYVklSVFVBTFNDUkVFTiAqLwoJCQlscG1taS0+cHRNYXhUcmFja1NpemUueSA8PD0gMTsvKjIqR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNDUkVFTikgLyBTTV9DWVZJUlRVQUxTQ1JFRU4gKi8KCQkJYnJlYWs7fQoKCQljYXNlIEZSTV9DQUxDX0NMSUVOVDoKCQkJZnJhbWVfZ2V0X2NsaWVudHNwYWNlKGh3bmQsIChQUkVDVClscGFyYW0pOwoJCQlyZXR1cm4gVFJVRTsKI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgoJCWRlZmF1bHQ6CgkJCXJldHVybiBEZWZGcmFtZVByb2MoaHduZCwgR2xvYmFscy5obWRpY2xpZW50LCBubXNnLCB3cGFyYW0sIGxwYXJhbSk7Cgl9CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgVENIQVIgZ19wb3NfbmFtZXNbQ09MVU1OU11bMjBdID0gewoJeydcMCd9CS8qIHN5bWJvbCAqLwp9OwoKc3RhdGljIGNvbnN0IGludCBnX3Bvc19hbGlnbltdID0gewoJMCwKCUhERl9MRUZULAkvKiBOYW1lICovCglIREZfUklHSFQsCS8qIFNpemUgKi8KCUhERl9MRUZULAkvKiBDRGF0ZSAqLwojaWZuZGVmIF9OT19FWFRFTlNJT05TCglIREZfTEVGVCwJLyogQURhdGUgKi8KCUhERl9MRUZULAkvKiBNRGF0ZSAqLwoJSERGX0xFRlQsCS8qIEluZGV4ICovCglIREZfQ0VOVEVSLAkvKiBMaW5rcyAqLwojZW5kaWYKCUhERl9DRU5URVIsCS8qIEF0dHJpYnV0ZXMgKi8KI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJSERGX0xFRlQJLyogU2VjdXJpdHkgKi8KI2VuZGlmCn07CgpzdGF0aWMgdm9pZCByZXNpemVfdHJlZShDaGlsZFduZCogY2hpbGQsIGludCBjeCwgaW50IGN5KQp7CglIRFdQIGhkd3AgPSBCZWdpbkRlZmVyV2luZG93UG9zKDQpOwoJUkVDVCBydDsKCglydC5sZWZ0ICAgPSAwOwoJcnQudG9wICAgID0gMDsKCXJ0LnJpZ2h0ICA9IGN4OwoJcnQuYm90dG9tID0gY3k7CgoJY3ggPSBjaGlsZC0+c3BsaXRfcG9zICsgU1BMSVRfV0lEVEgvMjsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCXsKCQlXSU5ET1dQT1Mgd3A7CgkJSERfTEFZT1VUIGhkbDsKCgkJaGRsLnByYyAgID0gJnJ0OwoJCWhkbC5wd3BvcyA9ICZ3cDsKCgkJU2VuZE1lc3NhZ2UoY2hpbGQtPmxlZnQuaHduZEhlYWRlciwgSERNX0xBWU9VVCwgMCwgKExQQVJBTSkmaGRsKTsKCgkJRGVmZXJXaW5kb3dQb3MoaGR3cCwgY2hpbGQtPmxlZnQuaHduZEhlYWRlciwgd3AuaHduZEluc2VydEFmdGVyLAoJCQkJCQl3cC54LTEsIHdwLnksIGNoaWxkLT5zcGxpdF9wb3MtU1BMSVRfV0lEVEgvMisxLCB3cC5jeSwgd3AuZmxhZ3MpOwoJCURlZmVyV2luZG93UG9zKGhkd3AsIGNoaWxkLT5yaWdodC5od25kSGVhZGVyLCB3cC5od25kSW5zZXJ0QWZ0ZXIsCgkJCQkJCXJ0LmxlZnQrY3grMSwgd3AueSwgd3AuY3gtY3grMiwgd3AuY3ksIHdwLmZsYWdzKTsKCX0KI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgoJRGVmZXJXaW5kb3dQb3MoaGR3cCwgY2hpbGQtPmxlZnQuaHduZCwgMCwgcnQubGVmdCwgcnQudG9wLCBjaGlsZC0+c3BsaXRfcG9zLVNQTElUX1dJRFRILzItcnQubGVmdCwgcnQuYm90dG9tLXJ0LnRvcCwgU1dQX05PWk9SREVSfFNXUF9OT0FDVElWQVRFKTsKCURlZmVyV2luZG93UG9zKGhkd3AsIGNoaWxkLT5yaWdodC5od25kLCAwLCBydC5sZWZ0K2N4KzEsIHJ0LnRvcCwgcnQucmlnaHQtY3gsIHJ0LmJvdHRvbS1ydC50b3AsIFNXUF9OT1pPUkRFUnxTV1BfTk9BQ1RJVkFURSk7CgoJRW5kRGVmZXJXaW5kb3dQb3MoaGR3cCk7Cn0KCgojaWZuZGVmIF9OT19FWFRFTlNJT05TCgpzdGF0aWMgSFdORCBjcmVhdGVfaGVhZGVyKEhXTkQgcGFyZW50LCBQYW5lKiBwYW5lLCBpbnQgaWQpCnsKCUhEX0lURU0gaGRpOwoJaW50IGlkeDsKCglIV05EIGh3bmQgPSBDcmVhdGVXaW5kb3coV0NfSEVBREVSLCAwLCBXU19DSElMRHxXU19WSVNJQkxFfEhEU19IT1JafEhEU19GVUxMRFJBRy8qVE9ETzogfEhEU19CVVRUT05TICsgc29ydCBvcmRlcnMqLywKCQkJCQkJCQkwLCAwLCAwLCAwLCBwYXJlbnQsIChITUVOVSlpZCwgR2xvYmFscy5oSW5zdGFuY2UsIDApOwoJaWYgKCFod25kKQoJCXJldHVybiAwOwoKCVNlbmRNZXNzYWdlKGh3bmQsIFdNX1NFVEZPTlQsIChXUEFSQU0pR2V0U3RvY2tPYmplY3QoREVGQVVMVF9HVUlfRk9OVCksIEZBTFNFKTsKCgloZGkubWFzayA9IEhESV9URVhUfEhESV9XSURUSHxIRElfRk9STUFUOwoKCWZvcihpZHg9MDsgaWR4PENPTFVNTlM7IGlkeCsrKSB7CgkJaGRpLnBzelRleHQgPSBnX3Bvc19uYW1lc1tpZHhdOwoJCWhkaS5mbXQgPSBIREZfU1RSSU5HIHwgZ19wb3NfYWxpZ25baWR4XTsKCQloZGkuY3h5ID0gcGFuZS0+d2lkdGhzW2lkeF07CgkJU2VuZE1lc3NhZ2UoaHduZCwgSERNX0lOU0VSVElURU0sIGlkeCwgKExQQVJBTSkgJmhkaSk7Cgl9CgoJcmV0dXJuIGh3bmQ7Cn0KCiNlbmRpZiAvKiBfTk9fRVhURU5TSU9OUyAqLwoKCnN0YXRpYyB2b2lkIGluaXRfb3V0cHV0KEhXTkQgaHduZCkKewoJc3RhdGljIGNvbnN0IFdDSEFSIHMxMDAwW10gPSB7JzEnLCcwJywnMCcsJzAnLCdcMCd9OwoJV0NIQVIgYlsxNl07CglIRk9OVCBvbGRfZm9udDsKCUhEQyBoZGMgPSBHZXREQyhod25kKTsKCglpZiAoR2V0TnVtYmVyRm9ybWF0VyhMT0NBTEVfVVNFUl9ERUZBVUxULCAwLCBzMTAwMCwgMCwgYiwgMTYpID4gNCkKCQlHbG9iYWxzLm51bV9zZXAgPSBiWzFdOwoJZWxzZQoJCUdsb2JhbHMubnVtX3NlcCA9ICcuJzsKCglvbGRfZm9udCA9IFNlbGVjdE9iamVjdChoZGMsIEdsb2JhbHMuaGZvbnQpOwoJR2V0VGV4dEV4dGVudFBvaW50MzJXKGhkYywgc1NwYWNlLCAxLCAmR2xvYmFscy5zcGFjZVNpemUpOwoJU2VsZWN0T2JqZWN0KGhkYywgb2xkX2ZvbnQpOwoJUmVsZWFzZURDKGh3bmQsIGhkYyk7Cn0KCnN0YXRpYyB2b2lkIGRyYXdfaXRlbShQYW5lKiBwYW5lLCBMUERSQVdJVEVNU1RSVUNUIGRpcywgRW50cnkqIGVudHJ5LCBpbnQgY2FsY1dpZHRoQ29sKTsKCgovKiBjYWxjdWxhdGUgcHJlZmVycmVkIHdpZHRoIGZvciBhbGwgdmlzaWJsZSBjb2x1bW5zICovCgpzdGF0aWMgQk9PTCBjYWxjX3dpZHRocyhQYW5lKiBwYW5lLCBCT09MIGFueXdheSkKewoJaW50IGNvbCwgeCwgY3gsIHNwYz0zKkdsb2JhbHMuc3BhY2VTaXplLmN4OwoJaW50IGVudHJpZXMgPSBTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9HRVRDT1VOVCwgMCwgMCk7CglpbnQgb3JnV2lkdGhzW0NPTFVNTlNdOwoJaW50IG9yZ1Bvc2l0aW9uc1tDT0xVTU5TKzFdOwoJSEZPTlQgaGZvbnRPbGQ7CglIREMgaGRjOwoJaW50IGNudDsKCglpZiAoIWFueXdheSkgewoJCW1lbWNweShvcmdXaWR0aHMsIHBhbmUtPndpZHRocywgc2l6ZW9mKG9yZ1dpZHRocykpOwoJCW1lbWNweShvcmdQb3NpdGlvbnMsIHBhbmUtPnBvc2l0aW9ucywgc2l6ZW9mKG9yZ1Bvc2l0aW9ucykpOwoJfQoKCWZvcihjb2w9MDsgY29sPENPTFVNTlM7IGNvbCsrKQoJCXBhbmUtPndpZHRoc1tjb2xdID0gMDsKCgloZGMgPSBHZXREQyhwYW5lLT5od25kKTsKCWhmb250T2xkID0gU2VsZWN0T2JqZWN0KGhkYywgR2xvYmFscy5oZm9udCk7CgoJZm9yKGNudD0wOyBjbnQ8ZW50cmllczsgY250KyspIHsKCQlFbnRyeSogZW50cnkgPSAoRW50cnkqKSBTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9HRVRJVEVNREFUQSwgY250LCAwKTsKCgkJRFJBV0lURU1TVFJVQ1QgZGlzOwoKCQlkaXMuQ3RsVHlwZQkJICA9IDA7CgkJZGlzLkN0bElECQkgID0gMDsKCQlkaXMuaXRlbUlECQkgID0gMDsKCQlkaXMuaXRlbUFjdGlvbgkgID0gMDsKCQlkaXMuaXRlbVN0YXRlCSAgPSAwOwoJCWRpcy5od25kSXRlbQkgID0gcGFuZS0+aHduZDsKCQlkaXMuaERDCQkJICA9IGhkYzsKCQlkaXMucmNJdGVtLmxlZnQJICA9IDA7CgkJZGlzLnJjSXRlbS50b3AgICAgPSAwOwoJCWRpcy5yY0l0ZW0ucmlnaHQgID0gMDsKCQlkaXMucmNJdGVtLmJvdHRvbSA9IDA7CgkJLypkaXMuaXRlbURhdGEJICA9IDA7ICovCgoJCWRyYXdfaXRlbShwYW5lLCAmZGlzLCBlbnRyeSwgQ09MVU1OUyk7Cgl9CgoJU2VsZWN0T2JqZWN0KGhkYywgaGZvbnRPbGQpOwoJUmVsZWFzZURDKHBhbmUtPmh3bmQsIGhkYyk7CgoJeCA9IDA7Cglmb3IoY29sPTA7IGNvbDxDT0xVTU5TOyBjb2wrKykgewoJCXBhbmUtPnBvc2l0aW9uc1tjb2xdID0geDsKCQljeCA9IHBhbmUtPndpZHRoc1tjb2xdOwoKCQlpZiAoY3gpIHsKCQkJY3ggKz0gc3BjOwoKCQkJaWYgKGN4IDwgSU1BR0VfV0lEVEgpCgkJCQljeCA9IElNQUdFX1dJRFRIOwoKCQkJcGFuZS0+d2lkdGhzW2NvbF0gPSBjeDsKCQl9CgoJCXggKz0gY3g7Cgl9CgoJcGFuZS0+cG9zaXRpb25zW0NPTFVNTlNdID0geDsKCglTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9TRVRIT1JJWk9OVEFMRVhURU5ULCB4LCAwKTsKCgkvKiBubyBjaGFuZ2U/ICovCglpZiAoIW1lbWNtcChvcmdXaWR0aHMsIHBhbmUtPndpZHRocywgc2l6ZW9mKG9yZ1dpZHRocykpKQoJCXJldHVybiBGQUxTRTsKCgkvKiBkb24ndCBtb3ZlLCBpZiBvbmx5IGNvbGxhcHNpbmcgYW4gZW50cnkgKi8KCWlmICghYW55d2F5ICYmIHBhbmUtPndpZHRoc1swXTxvcmdXaWR0aHNbMF0gJiYKCQkhbWVtY21wKG9yZ1dpZHRocysxLCBwYW5lLT53aWR0aHMrMSwgc2l6ZW9mKG9yZ1dpZHRocyktc2l6ZW9mKGludCkpKSB7CgkJcGFuZS0+d2lkdGhzWzBdID0gb3JnV2lkdGhzWzBdOwoJCW1lbWNweShwYW5lLT5wb3NpdGlvbnMsIG9yZ1Bvc2l0aW9ucywgc2l6ZW9mKG9yZ1Bvc2l0aW9ucykpOwoKCQlyZXR1cm4gRkFMU0U7Cgl9CgoJSW52YWxpZGF0ZVJlY3QocGFuZS0+aHduZCwgMCwgVFJVRSk7CgoJcmV0dXJuIFRSVUU7Cn0KCgovKiBjYWxjdWxhdGUgb25lIHByZWZlcnJlZCBjb2x1bW4gd2lkdGggKi8KCnN0YXRpYyB2b2lkIGNhbGNfc2luZ2xlX3dpZHRoKFBhbmUqIHBhbmUsIGludCBjb2wpCnsKCUhGT05UIGhmb250T2xkOwoJaW50IHgsIGN4OwoJaW50IGVudHJpZXMgPSBTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9HRVRDT1VOVCwgMCwgMCk7CglpbnQgY250OwoJSERDIGhkYzsKCglwYW5lLT53aWR0aHNbY29sXSA9IDA7CgoJaGRjID0gR2V0REMocGFuZS0+aHduZCk7CgloZm9udE9sZCA9IFNlbGVjdE9iamVjdChoZGMsIEdsb2JhbHMuaGZvbnQpOwoKCWZvcihjbnQ9MDsgY250PGVudHJpZXM7IGNudCsrKSB7CgkJRW50cnkqIGVudHJ5ID0gKEVudHJ5KikgU2VuZE1lc3NhZ2UocGFuZS0+aHduZCwgTEJfR0VUSVRFTURBVEEsIGNudCwgMCk7CgkJRFJBV0lURU1TVFJVQ1QgZGlzOwoKCQlkaXMuQ3RsVHlwZQkJICA9IDA7CgkJZGlzLkN0bElECQkgID0gMDsKCQlkaXMuaXRlbUlECQkgID0gMDsKCQlkaXMuaXRlbUFjdGlvbgkgID0gMDsKCQlkaXMuaXRlbVN0YXRlCSAgPSAwOwoJCWRpcy5od25kSXRlbQkgID0gcGFuZS0+aHduZDsKCQlkaXMuaERDCQkJICA9IGhkYzsKCQlkaXMucmNJdGVtLmxlZnQJICA9IDA7CgkJZGlzLnJjSXRlbS50b3AgICAgPSAwOwoJCWRpcy5yY0l0ZW0ucmlnaHQgID0gMDsKCQlkaXMucmNJdGVtLmJvdHRvbSA9IDA7CgkJLypkaXMuaXRlbURhdGEJICA9IDA7ICovCgoJCWRyYXdfaXRlbShwYW5lLCAmZGlzLCBlbnRyeSwgY29sKTsKCX0KCglTZWxlY3RPYmplY3QoaGRjLCBoZm9udE9sZCk7CglSZWxlYXNlREMocGFuZS0+aHduZCwgaGRjKTsKCgljeCA9IHBhbmUtPndpZHRoc1tjb2xdOwoKCWlmIChjeCkgewoJCWN4ICs9IDMqR2xvYmFscy5zcGFjZVNpemUuY3g7CgoJCWlmIChjeCA8IElNQUdFX1dJRFRIKQoJCQljeCA9IElNQUdFX1dJRFRIOwoJfQoKCXBhbmUtPndpZHRoc1tjb2xdID0gY3g7CgoJeCA9IHBhbmUtPnBvc2l0aW9uc1tjb2xdICsgY3g7CgoJZm9yKDsgY29sPENPTFVNTlM7ICkgewoJCXBhbmUtPnBvc2l0aW9uc1srK2NvbF0gPSB4OwoJCXggKz0gcGFuZS0+d2lkdGhzW2NvbF07Cgl9CgoJU2VuZE1lc3NhZ2UocGFuZS0+aHduZCwgTEJfU0VUSE9SSVpPTlRBTEVYVEVOVCwgeCwgMCk7Cn0KCgpzdGF0aWMgQk9PTCBwYXR0ZXJuX21hdGNoKExQQ1RTVFIgc3RyLCBMUENUU1RSIHBhdHRlcm4pCnsKCWZvciggOyAqc3RyJiYqcGF0dGVybjsgc3RyKysscGF0dGVybisrKSB7CgkJaWYgKCpwYXR0ZXJuID09ICcqJykgewoJCQlkbyBwYXR0ZXJuKys7CgkJCXdoaWxlKCpwYXR0ZXJuID09ICcqJyk7CgoJCQlpZiAoISpwYXR0ZXJuKQoJCQkJcmV0dXJuIFRSVUU7CgoJCQlmb3IoOyAqc3RyOyBzdHIrKykKCQkJCWlmICgqc3RyPT0qcGF0dGVybiAmJiBwYXR0ZXJuX21hdGNoKHN0ciwgcGF0dGVybikpCgkJCQkJcmV0dXJuIFRSVUU7CgoJCQlyZXR1cm4gRkFMU0U7CgkJfQoJCWVsc2UgaWYgKCpzdHIhPSpwYXR0ZXJuICYmICpwYXR0ZXJuIT0nPycpCgkJCXJldHVybiBGQUxTRTsKCX0KCglpZiAoKnN0ciB8fCAqcGF0dGVybikKCQlpZiAoKnBhdHRlcm4hPScqJyB8fCBwYXR0ZXJuWzFdIT0nXDAnKQoJCQlyZXR1cm4gRkFMU0U7CgoJcmV0dXJuIFRSVUU7Cn0KCnN0YXRpYyBCT09MIHBhdHRlcm5faW1hdGNoKExQQ1RTVFIgc3RyLCBMUENUU1RSIHBhdHRlcm4pCnsKCVRDSEFSIGIxW0JVRkZFUl9MRU5dLCBiMltCVUZGRVJfTEVOXTsKCglsc3RyY3B5KGIxLCBzdHIpOwoJbHN0cmNweShiMiwgcGF0dGVybik7CglDaGFyVXBwZXIoYjEpOwoJQ2hhclVwcGVyKGIyKTsKCglyZXR1cm4gcGF0dGVybl9tYXRjaChiMSwgYjIpOwp9CgoKZW51bSBGSUxFX1RZUEUgewoJRlRfT1RIRVIJCT0gMCwKCUZUX0VYRUNVVEFCTEUJPSAxLAoJRlRfRE9DVU1FTlQJCT0gMgp9OwoKc3RhdGljIGVudW0gRklMRV9UWVBFIGdldF9maWxlX3R5cGUoTFBDVFNUUiBmaWxlbmFtZSk7CgoKLyogaW5zZXJ0IGxpc3Rib3ggZW50cmllcyBhZnRlciBpbmRleCBpZHggKi8KCnN0YXRpYyBpbnQgaW5zZXJ0X2VudHJpZXMoUGFuZSogcGFuZSwgRW50cnkqIGRpciwgTFBDVFNUUiBwYXR0ZXJuLCBpbnQgZmlsdGVyX2ZsYWdzLCBpbnQgaWR4KQp7CglFbnRyeSogZW50cnkgPSBkaXI7CgoJaWYgKCFlbnRyeSkKCQlyZXR1cm4gaWR4OwoKCVNob3dXaW5kb3cocGFuZS0+aHduZCwgU1dfSElERSk7CgoJZm9yKDsgZW50cnk7IGVudHJ5PWVudHJ5LT5uZXh0KSB7CiNpZm5kZWYgX0xFRlRfRklMRVMKCQlpZiAocGFuZS0+dHJlZVBhbmUgJiYgIShlbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzJkZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkpCgkJCWNvbnRpbnVlOwojZW5kaWYKCgkJaWYgKGVudHJ5LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpIHsKCQkJLyogZG9uJ3QgZGlzcGxheSBlbnRyaWVzICIuIiBhbmQgIi4uIiBpbiB0aGUgbGVmdCBwYW5lICovCgkJCWlmIChwYW5lLT50cmVlUGFuZSAmJiBlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMF0gPT0gJy4nKQoJCQkJaWYgKAojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCQkJZW50cnktPmRhdGEuY0ZpbGVOYW1lWzFdID09ICdcMCcgfHwKI2VuZGlmCgkJCQkJKGVudHJ5LT5kYXRhLmNGaWxlTmFtZVsxXSA9PSAnLicgJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzJdID09ICdcMCcpKQoJCQkJCWNvbnRpbnVlOwoKCQkJLyogZmlsdGVyIGRpcmVjdG9yaWVzIGluIHJpZ2h0IHBhbmUgKi8KCQkJaWYgKCFwYW5lLT50cmVlUGFuZSAmJiAhKGZpbHRlcl9mbGFncyZURl9ESVJFQ1RPUklFUykpCgkJCQljb250aW51ZTsKCQl9CgoJCS8qIGZpbHRlciB1c2luZyB0aGUgZmlsZSBuYW1lIHBhdHRlcm4gKi8KCQlpZiAocGF0dGVybikKCQkJaWYgKCFwYXR0ZXJuX2ltYXRjaChlbnRyeS0+ZGF0YS5jRmlsZU5hbWUsIHBhdHRlcm4pKQoJCQkJY29udGludWU7CgoJCS8qIGZpbHRlciBzeXN0ZW0gYW5kIGhpZGRlbiBmaWxlcyAqLwoJCWlmICghKGZpbHRlcl9mbGFncyZURl9ISURERU4pICYmIChlbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzJihGSUxFX0FUVFJJQlVURV9ISURERU58RklMRV9BVFRSSUJVVEVfU1lTVEVNKSkpCgkJCWNvbnRpbnVlOwoKCQkvKiBmaWx0ZXIgbG9va2luZyBhdCB0aGUgZmlsZSB0eXBlICovCgkJaWYgKChmaWx0ZXJfZmxhZ3MmKFRGX1BST0dSQU1TfFRGX0RPQ1VNRU5UU3xURl9PVEhFUlMpKSAhPSAoVEZfUFJPR1JBTVN8VEZfRE9DVU1FTlRTfFRGX09USEVSUykpCgkJCXN3aXRjaChnZXRfZmlsZV90eXBlKGVudHJ5LT5kYXRhLmNGaWxlTmFtZSkpIHsKCQkJICBjYXNlIEZUX0VYRUNVVEFCTEU6CgkJCSAgCWlmICghKGZpbHRlcl9mbGFncyAmIFRGX1BST0dSQU1TKSkKCQkJCQljb250aW51ZTsKCQkJCWJyZWFrOwoKCQkJICBjYXNlIEZUX0RPQ1VNRU5UOgoJCQkJaWYgKCEoZmlsdGVyX2ZsYWdzICYgVEZfRE9DVU1FTlRTKSkKCQkJCQljb250aW51ZTsKCQkJCWJyZWFrOwoKCQkJICBkZWZhdWx0OiAvKiBURl9PVEhFUlMgKi8KCQkJCWlmICghKGZpbHRlcl9mbGFncyAmIFRGX09USEVSUykpCgkJCQkJY29udGludWU7CgkJCX0KCgkJaWYgKGlkeCAhPSAtMSkKCQkJaWR4Kys7CgoJCVNlbmRNZXNzYWdlKHBhbmUtPmh3bmQsIExCX0lOU0VSVFNUUklORywgaWR4LCAoTFBBUkFNKSBlbnRyeSk7CgoJCWlmIChwYW5lLT50cmVlUGFuZSAmJiBlbnRyeS0+ZXhwYW5kZWQpCgkJCWlkeCA9IGluc2VydF9lbnRyaWVzKHBhbmUsIGVudHJ5LT5kb3duLCBwYXR0ZXJuLCBmaWx0ZXJfZmxhZ3MsIGlkeCk7Cgl9CgoJU2hvd1dpbmRvdyhwYW5lLT5od25kLCBTV19TSE9XKTsKCglyZXR1cm4gaWR4Owp9CgoKc3RhdGljIHZvaWQgZm9ybWF0X2J5dGVzKExQVFNUUiBidWZmZXIsIExPTkdMT05HIGJ5dGVzKQp7CglzdGF0aWMgY29uc3QgVENIQVIgc0ZtdEdCW10gPSB7JyUnLCAnLicsICcxJywgJ2YnLCAnICcsICdHJywgJ0InLCAnXDAnfTsKCXN0YXRpYyBjb25zdCBUQ0hBUiBzRm10TUJbXSA9IHsnJScsICcuJywgJzEnLCAnZicsICcgJywgJ00nLCAnQicsICdcMCd9OwoJc3RhdGljIGNvbnN0IFRDSEFSIHNGbXRrQltdID0geyclJywgJy4nLCAnMScsICdmJywgJyAnLCAnaycsICdCJywgJ1wwJ307CgoJZmxvYXQgZkJ5dGVzID0gKGZsb2F0KWJ5dGVzOwoKCWlmIChieXRlcyA+PSAxMDczNzQxODI0KQkvKiAxIEdCICovCgkJX3N0cHJpbnRmKGJ1ZmZlciwgc0ZtdEdCLCBmQnl0ZXMvMTA3Mzc0MTgyNC5mKy41Zik7CgllbHNlIGlmIChieXRlcyA+PSAxMDQ4NTc2KQkvKiAxIE1CICovCgkJX3N0cHJpbnRmKGJ1ZmZlciwgc0ZtdE1CLCBmQnl0ZXMvMTA0ODU3Ni5mKy41Zik7CgllbHNlIGlmIChieXRlcyA+PSAxMDI0KQkJLyogMSBrQiAqLwoJCV9zdHByaW50ZihidWZmZXIsIHNGbXRrQiwgZkJ5dGVzLzEwMjQuZisuNWYpOwoJZWxzZQoJCV9zdHByaW50ZihidWZmZXIsIHNMb25nTnVtRm10LCBieXRlcyk7Cn0KCnN0YXRpYyB2b2lkIHNldF9zcGFjZV9zdGF0dXModm9pZCkKewoJVUxBUkdFX0lOVEVHRVIgdWxGcmVlQnl0ZXNUb0NhbGxlciwgdWxUb3RhbEJ5dGVzLCB1bEZyZWVCeXRlczsKCVRDSEFSIGZtdFs2NF0sIGIxWzY0XSwgYjJbNjRdLCBidWZmZXJbQlVGRkVSX0xFTl07CgoJaWYgKEdldERpc2tGcmVlU3BhY2VFeChOVUxMLCAmdWxGcmVlQnl0ZXNUb0NhbGxlciwgJnVsVG90YWxCeXRlcywgJnVsRnJlZUJ5dGVzKSkgewoJCWZvcm1hdF9ieXRlcyhiMSwgdWxGcmVlQnl0ZXNUb0NhbGxlci5RdWFkUGFydCk7CgkJZm9ybWF0X2J5dGVzKGIyLCB1bFRvdGFsQnl0ZXMuUXVhZFBhcnQpOwoJCXdzcHJpbnRmKGJ1ZmZlciwgUlMoZm10LElEU19GUkVFX1NQQUNFX0ZNVCksIGIxLCBiMik7Cgl9IGVsc2UKCQlsc3RyY3B5KGJ1ZmZlciwgc1FNYXJrcyk7CgoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oc3RhdHVzYmFyLCBTQl9TRVRURVhULCAwLCAoTFBBUkFNKWJ1ZmZlcik7Cn0KCgpzdGF0aWMgV05EUFJPQyBnX29yZ1RyZWVXbmRQcm9jOwoKc3RhdGljIHZvaWQgY3JlYXRlX3RyZWVfd2luZG93KEhXTkQgcGFyZW50LCBQYW5lKiBwYW5lLCBpbnQgaWQsIGludCBpZF9oZWFkZXIsIExQQ1RTVFIgcGF0dGVybiwgaW50IGZpbHRlcl9mbGFncykKewoJc3RhdGljIGNvbnN0IFRDSEFSIHNMaXN0Qm94W10gPSB7J0wnLCdpJywncycsJ3QnLCdCJywnbycsJ3gnLCdcMCd9OwoKCXN0YXRpYyBpbnQgc19pbml0ID0gMDsKCUVudHJ5KiBlbnRyeSA9IHBhbmUtPnJvb3Q7CgoJcGFuZS0+aHduZCA9IENyZWF0ZVdpbmRvdyhzTGlzdEJveCwgc0VtcHR5LCBXU19DSElMRHxXU19WSVNJQkxFfFdTX0hTQ1JPTEx8V1NfVlNDUk9MTHwKCQkJCQkJCQlMQlNfRElTQUJMRU5PU0NST0xMfExCU19OT0lOVEVHUkFMSEVJR0hUfExCU19PV05FUkRSQVdGSVhFRHxMQlNfTk9USUZZLAoJCQkJCQkJCTAsIDAsIDAsIDAsIHBhcmVudCwgKEhNRU5VKWlkLCBHbG9iYWxzLmhJbnN0YW5jZSwgMCk7CgoJU2V0V2luZG93TG9uZ1B0cihwYW5lLT5od25kLCBHV0xQX1VTRVJEQVRBLCAoTFBBUkFNKXBhbmUpOwoJZ19vcmdUcmVlV25kUHJvYyA9IChXTkRQUk9DKSBTZXRXaW5kb3dMb25nUHRyKHBhbmUtPmh3bmQsIEdXTFBfV05EUFJPQywgKExQQVJBTSlUcmVlV25kUHJvYyk7CgoJU2VuZE1lc3NhZ2UocGFuZS0+aHduZCwgV01fU0VURk9OVCwgKFdQQVJBTSlHbG9iYWxzLmhmb250LCBGQUxTRSk7CgoJLyogaW5zZXJ0IGVudHJpZXMgaW50byBsaXN0Ym94ICovCglpZiAoZW50cnkpCgkJaW5zZXJ0X2VudHJpZXMocGFuZSwgZW50cnksIHBhdHRlcm4sIGZpbHRlcl9mbGFncywgLTEpOwoKCS8qIGNhbGN1bGF0ZSBjb2x1bW4gd2lkdGhzICovCglpZiAoIXNfaW5pdCkgewoJCXNfaW5pdCA9IDE7CgkJaW5pdF9vdXRwdXQocGFuZS0+aHduZCk7Cgl9CgoJY2FsY193aWR0aHMocGFuZSwgVFJVRSk7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCglwYW5lLT5od25kSGVhZGVyID0gY3JlYXRlX2hlYWRlcihwYXJlbnQsIHBhbmUsIGlkX2hlYWRlcik7CiNlbmRpZgp9CgoKc3RhdGljIHZvaWQgSW5pdENoaWxkV2luZG93KENoaWxkV25kKiBjaGlsZCkKewoJY3JlYXRlX3RyZWVfd2luZG93KGNoaWxkLT5od25kLCAmY2hpbGQtPmxlZnQsIElEV19UUkVFX0xFRlQsIElEV19IRUFERVJfTEVGVCwgTlVMTCwgVEZfQUxMKTsKCWNyZWF0ZV90cmVlX3dpbmRvdyhjaGlsZC0+aHduZCwgJmNoaWxkLT5yaWdodCwgSURXX1RSRUVfUklHSFQsIElEV19IRUFERVJfUklHSFQsIGNoaWxkLT5maWx0ZXJfcGF0dGVybiwgY2hpbGQtPmZpbHRlcl9mbGFncyk7Cn0KCgpzdGF0aWMgdm9pZCBmb3JtYXRfZGF0ZShjb25zdCBGSUxFVElNRSogZnQsIFRDSEFSKiBidWZmZXIsIGludCB2aXNpYmxlX2NvbHMpCnsKCVNZU1RFTVRJTUUgc3lzdGltZTsKCUZJTEVUSU1FIGxmdDsKCWludCBsZW4gPSAwOwoKCSpidWZmZXIgPSAnXDAnOwoKCWlmICghZnQtPmR3TG93RGF0ZVRpbWUgJiYgIWZ0LT5kd0hpZ2hEYXRlVGltZSkKCQlyZXR1cm47CgoJaWYgKCFGaWxlVGltZVRvTG9jYWxGaWxlVGltZShmdCwgJmxmdCkpCgkJe2VycjogbHN0cmNweShidWZmZXIsc1FNYXJrcyk7IHJldHVybjt9CgoJaWYgKCFGaWxlVGltZVRvU3lzdGVtVGltZSgmbGZ0LCAmc3lzdGltZSkpCgkJZ290byBlcnI7CgoJaWYgKHZpc2libGVfY29scyAmIENPTF9EQVRFKSB7CgkJbGVuID0gR2V0RGF0ZUZvcm1hdChMT0NBTEVfVVNFUl9ERUZBVUxULCAwLCAmc3lzdGltZSwgMCwgYnVmZmVyLCBCVUZGRVJfTEVOKTsKCQlpZiAoIWxlbikKCQkJZ290byBlcnI7Cgl9CgoJaWYgKHZpc2libGVfY29scyAmIENPTF9USU1FKSB7CgkJaWYgKGxlbikKCQkJYnVmZmVyW2xlbi0xXSA9ICcgJzsKCgkJYnVmZmVyW2xlbisrXSA9ICcgJzsKCgkJaWYgKCFHZXRUaW1lRm9ybWF0KExPQ0FMRV9VU0VSX0RFRkFVTFQsIDAsICZzeXN0aW1lLCAwLCBidWZmZXIrbGVuLCBCVUZGRVJfTEVOLWxlbikpCgkJCWJ1ZmZlcltsZW5dID0gJ1wwJzsKCX0KfQoKCnN0YXRpYyB2b2lkIGNhbGNfd2lkdGgoUGFuZSogcGFuZSwgTFBEUkFXSVRFTVNUUlVDVCBkaXMsIGludCBjb2wsIExQQ1RTVFIgc3RyKQp7CglSRUNUIHJ0ID0gezAsIDAsIDAsIDB9OwoKCURyYXdUZXh0KGRpcy0+aERDLCBzdHIsIC0xLCAmcnQsIERUX0NBTENSRUNUfERUX1NJTkdMRUxJTkV8RFRfTk9QUkVGSVgpOwoKCWlmIChydC5yaWdodCA+IHBhbmUtPndpZHRoc1tjb2xdKQoJCXBhbmUtPndpZHRoc1tjb2xdID0gcnQucmlnaHQ7Cn0KCnN0YXRpYyB2b2lkIGNhbGNfdGFiYmVkX3dpZHRoKFBhbmUqIHBhbmUsIExQRFJBV0lURU1TVFJVQ1QgZGlzLCBpbnQgY29sLCBMUENUU1RSIHN0cikKewoJUkVDVCBydCA9IHswLCAwLCAwLCAwfTsKCi8qCURSQVdURVhUUEFSQU1TIGR0cCA9IHtzaXplb2YoRFJBV1RFWFRQQVJBTVMpLCAyfTsKCURyYXdUZXh0RXgoZGlzLT5oREMsIChMUFRTVFIpc3RyLCAtMSwgJnJ0LCBEVF9DQUxDUkVDVHxEVF9TSU5HTEVMSU5FfERUX05PUFJFRklYfERUX0VYUEFORFRBQlN8RFRfVEFCU1RPUCwgJmR0cCk7Ki8KCglEcmF3VGV4dChkaXMtPmhEQywgc3RyLCAtMSwgJnJ0LCBEVF9DQUxDUkVDVHxEVF9TSU5HTEVMSU5FfERUX0VYUEFORFRBQlN8RFRfVEFCU1RPUHwoMjw8OCkpOwoJLypGSVhNRSBydCAoMCwwKSA/Pz8gKi8KCglpZiAocnQucmlnaHQgPiBwYW5lLT53aWR0aHNbY29sXSkKCQlwYW5lLT53aWR0aHNbY29sXSA9IHJ0LnJpZ2h0Owp9CgoKc3RhdGljIHZvaWQgb3V0cHV0X3RleHQoUGFuZSogcGFuZSwgTFBEUkFXSVRFTVNUUlVDVCBkaXMsIGludCBjb2wsIExQQ1RTVFIgc3RyLCBEV09SRCBmbGFncykKewoJaW50IHggPSBkaXMtPnJjSXRlbS5sZWZ0OwoJUkVDVCBydDsKCglydC5sZWZ0ICAgPSB4K3BhbmUtPnBvc2l0aW9uc1tjb2xdK0dsb2JhbHMuc3BhY2VTaXplLmN4OwoJcnQudG9wICAgID0gZGlzLT5yY0l0ZW0udG9wOwoJcnQucmlnaHQgID0geCtwYW5lLT5wb3NpdGlvbnNbY29sKzFdLUdsb2JhbHMuc3BhY2VTaXplLmN4OwoJcnQuYm90dG9tID0gZGlzLT5yY0l0ZW0uYm90dG9tOwoKCURyYXdUZXh0KGRpcy0+aERDLCBzdHIsIC0xLCAmcnQsIERUX1NJTkdMRUxJTkV8RFRfTk9QUkVGSVh8ZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZCBvdXRwdXRfdGFiYmVkX3RleHQoUGFuZSogcGFuZSwgTFBEUkFXSVRFTVNUUlVDVCBkaXMsIGludCBjb2wsIExQQ1RTVFIgc3RyKQp7CglpbnQgeCA9IGRpcy0+cmNJdGVtLmxlZnQ7CglSRUNUIHJ0OwoKCXJ0LmxlZnQgICA9IHgrcGFuZS0+cG9zaXRpb25zW2NvbF0rR2xvYmFscy5zcGFjZVNpemUuY3g7CglydC50b3AgICAgPSBkaXMtPnJjSXRlbS50b3A7CglydC5yaWdodCAgPSB4K3BhbmUtPnBvc2l0aW9uc1tjb2wrMV0tR2xvYmFscy5zcGFjZVNpemUuY3g7CglydC5ib3R0b20gPSBkaXMtPnJjSXRlbS5ib3R0b207CgovKglEUkFXVEVYVFBBUkFNUyBkdHAgPSB7c2l6ZW9mKERSQVdURVhUUEFSQU1TKSwgMn07CglEcmF3VGV4dEV4KGRpcy0+aERDLCAoTFBUU1RSKXN0ciwgLTEsICZydCwgRFRfU0lOR0xFTElORXxEVF9OT1BSRUZJWHxEVF9FWFBBTkRUQUJTfERUX1RBQlNUT1AsICZkdHApOyovCgoJRHJhd1RleHQoZGlzLT5oREMsIHN0ciwgLTEsICZydCwgRFRfU0lOR0xFTElORXxEVF9FWFBBTkRUQUJTfERUX1RBQlNUT1B8KDI8PDgpKTsKfQoKc3RhdGljIHZvaWQgb3V0cHV0X251bWJlcihQYW5lKiBwYW5lLCBMUERSQVdJVEVNU1RSVUNUIGRpcywgaW50IGNvbCwgTFBDVFNUUiBzdHIpCnsKCWludCB4ID0gZGlzLT5yY0l0ZW0ubGVmdDsKCVJFQ1QgcnQ7CglMUENUU1RSIHMgPSBzdHI7CglUQ0hBUiBiWzEyOF07CglMUFRTVFIgZCA9IGI7CglpbnQgcG9zOwoKCXJ0LmxlZnQgICA9IHgrcGFuZS0+cG9zaXRpb25zW2NvbF0rR2xvYmFscy5zcGFjZVNpemUuY3g7CglydC50b3AgICAgPSBkaXMtPnJjSXRlbS50b3A7CglydC5yaWdodCAgPSB4K3BhbmUtPnBvc2l0aW9uc1tjb2wrMV0tR2xvYmFscy5zcGFjZVNpemUuY3g7CglydC5ib3R0b20gPSBkaXMtPnJjSXRlbS5ib3R0b207CgoJaWYgKCpzKQoJCSpkKysgPSAqcysrOwoKCS8qIGluc2VydCBudW1iZXIgc2VwYXJhdG9yIGNoYXJhY3RlcnMgKi8KCXBvcyA9IGxzdHJsZW4ocykgJSAzOwoKCXdoaWxlKCpzKQoJCWlmIChwb3MtLSkKCQkJKmQrKyA9ICpzKys7CgkJZWxzZSB7CgkJCSpkKysgPSBHbG9iYWxzLm51bV9zZXA7CgkJCXBvcyA9IDM7CgkJfQoKCURyYXdUZXh0KGRpcy0+aERDLCBiLCBkLWIsICZydCwgRFRfUklHSFR8RFRfU0lOR0xFTElORXxEVF9OT1BSRUZJWHxEVF9FTkRfRUxMSVBTSVMpOwp9CgoKc3RhdGljIEJPT0wgaXNfZXhlX2ZpbGUoTFBDVFNUUiBleHQpCnsKCXN0YXRpYyBjb25zdCBUQ0hBUiBleGVjdXRhYmxlX2V4dGVuc2lvbnNbXVs0XSA9IHsKCQl7J0MnLCdPJywnTScsJ1wwJ30sCgkJeydFJywnWCcsJ0UnLCdcMCd9LAoJCXsnQicsJ0EnLCdUJywnXDAnfSwKCQl7J0MnLCdNJywnRCcsJ1wwJ30sCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQl7J0MnLCdNJywnTScsJ1wwJ30sCgkJeydCJywnVCcsJ00nLCdcMCd9LAoJCXsnQScsJ1cnLCdLJywnXDAnfSwKI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgkJeydcMCd9Cgl9OwoKCVRDSEFSIGV4dF9idWZmZXJbX01BWF9FWFRdOwoJY29uc3QgVENIQVIgKCpwKVs0XTsKCUxQQ1RTVFIgczsKCUxQVFNUUiBkOwoKCWZvcihzPWV4dCsxLGQ9ZXh0X2J1ZmZlcjsgKCpkPXRvbG93ZXIoKnMpKTsgcysrKQoJCWQrKzsKCglmb3IocD1leGVjdXRhYmxlX2V4dGVuc2lvbnM7ICgqcClbMF07IHArKykKCQlpZiAoIWxzdHJjbXBpKGV4dF9idWZmZXIsICpwKSkKCQkJcmV0dXJuIFRSVUU7CgoJcmV0dXJuIEZBTFNFOwp9CgpzdGF0aWMgQk9PTCBpc19yZWdpc3RlcmVkX3R5cGUoTFBDVFNUUiBleHQpCnsKCS8qIGNoZWNrIGlmIHRoZXJlIGV4aXN0cyBhIGNsYXNzbmFtZSBmb3IgdGhpcyBmaWxlIGV4dGVuc2lvbiBpbiB0aGUgcmVnaXN0cnkgKi8KCWlmICghUmVnUXVlcnlWYWx1ZShIS0VZX0NMQVNTRVNfUk9PVCwgZXh0LCBOVUxMLCBOVUxMKSkKCQlyZXR1cm4gVFJVRTsKCglyZXR1cm4gRkFMU0U7Cn0KCnN0YXRpYyBlbnVtIEZJTEVfVFlQRSBnZXRfZmlsZV90eXBlKExQQ1RTVFIgZmlsZW5hbWUpCnsKCUxQQ1RTVFIgZXh0ID0gX3Rjc3JjaHIoZmlsZW5hbWUsICcuJyk7CglpZiAoIWV4dCkKCQlleHQgPSBzRW1wdHk7CgoJaWYgKGlzX2V4ZV9maWxlKGV4dCkpCgkJcmV0dXJuIEZUX0VYRUNVVEFCTEU7CgllbHNlIGlmIChpc19yZWdpc3RlcmVkX3R5cGUoZXh0KSkKCQlyZXR1cm4gRlRfRE9DVU1FTlQ7CgllbHNlCgkJcmV0dXJuIEZUX09USEVSOwp9CgoKc3RhdGljIHZvaWQgZHJhd19pdGVtKFBhbmUqIHBhbmUsIExQRFJBV0lURU1TVFJVQ1QgZGlzLCBFbnRyeSogZW50cnksIGludCBjYWxjV2lkdGhDb2wpCnsKCVRDSEFSIGJ1ZmZlcltCVUZGRVJfTEVOXTsKCURXT1JEIGF0dHJzOwoJaW50IHZpc2libGVfY29scyA9IHBhbmUtPnZpc2libGVfY29sczsKCUNPTE9SUkVGIGJrY29sb3IsIHRleHRjb2xvcjsKCVJFQ1QgZm9jdXNSZWN0ID0gZGlzLT5yY0l0ZW07CglIQlJVU0ggaGJydXNoOwoJZW51bSBJTUFHRSBpbWc7CglpbnQgaW1nX3BvcywgY3g7CglpbnQgY29sID0gMDsKCglpZiAoZW50cnkpIHsKCQlhdHRycyA9IGVudHJ5LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXM7CgoJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkgewoJCQlpZiAoZW50cnktPmRhdGEuY0ZpbGVOYW1lWzBdID09ICcuJyAmJiBlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMV0gPT0gJy4nCgkJCQkJJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzJdID09ICdcMCcpCgkJCQlpbWcgPSBJTUdfRk9MREVSX1VQOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCgkJCWVsc2UgaWYgKGVudHJ5LT5kYXRhLmNGaWxlTmFtZVswXSA9PSAnLicgJiYgZW50cnktPmRhdGEuY0ZpbGVOYW1lWzFdID09ICdcMCcpCgkJCQlpbWcgPSBJTUdfRk9MREVSX0NVUjsKI2VuZGlmCgkJCWVsc2UgaWYgKAojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJCQkgZW50cnktPmV4cGFuZGVkIHx8CiNlbmRpZgoJCQkJCSAocGFuZS0+dHJlZVBhbmUgJiYgKGRpcy0+aXRlbVN0YXRlJk9EU19GT0NVUykpKQoJCQkJaW1nID0gSU1HX09QRU5fRk9MREVSOwoJCQllbHNlCgkJCQlpbWcgPSBJTUdfRk9MREVSOwoJCX0gZWxzZSB7CgkJCXN3aXRjaChnZXRfZmlsZV90eXBlKGVudHJ5LT5kYXRhLmNGaWxlTmFtZSkpIHsKCQkJICBjYXNlIEZUX0VYRUNVVEFCTEU6CWltZyA9IElNR19FWEVDVVRBQkxFOwlicmVhazsKCQkJICBjYXNlIEZUX0RPQ1VNRU5UOgkJaW1nID0gSU1HX0RPQ1VNRU5UOwkJYnJlYWs7CgkJCSAgZGVmYXVsdDoJCQkJaW1nID0gSU1HX0ZJTEU7CgkJCX0KCQl9Cgl9IGVsc2UgewoJCWF0dHJzID0gMDsKCQlpbWcgPSBJTUdfTk9ORTsKCX0KCglpZiAocGFuZS0+dHJlZVBhbmUpIHsKCQlpZiAoZW50cnkpIHsKCQkJaW1nX3BvcyA9IGRpcy0+cmNJdGVtLmxlZnQgKyBlbnRyeS0+bGV2ZWwqKElNQUdFX1dJRFRIK1RSRUVfTElORV9EWCk7CgoJCQlpZiAoY2FsY1dpZHRoQ29sID09IC0xKSB7CgkJCQlpbnQgeDsKCQkJCWludCB5ID0gZGlzLT5yY0l0ZW0udG9wICsgSU1BR0VfSEVJR0hULzI7CgkJCQlFbnRyeSogdXA7CgkJCQlSRUNUIHJ0X2NsaXA7CgkJCQlIUkdOIGhyZ25fb3JnID0gQ3JlYXRlUmVjdFJnbigwLCAwLCAwLCAwKTsKCQkJCUhSR04gaHJnbjsKCgkJCQlydF9jbGlwLmxlZnQgICA9IGRpcy0+cmNJdGVtLmxlZnQ7CgkJCQlydF9jbGlwLnRvcCAgICA9IGRpcy0+cmNJdGVtLnRvcDsKCQkJCXJ0X2NsaXAucmlnaHQgID0gZGlzLT5yY0l0ZW0ubGVmdCtwYW5lLT53aWR0aHNbY29sXTsKCQkJCXJ0X2NsaXAuYm90dG9tID0gZGlzLT5yY0l0ZW0uYm90dG9tOwoKCQkJCWhyZ24gPSBDcmVhdGVSZWN0UmduSW5kaXJlY3QoJnJ0X2NsaXApOwoKCQkJCWlmICghR2V0Q2xpcFJnbihkaXMtPmhEQywgaHJnbl9vcmcpKSB7CgkJCQkJRGVsZXRlT2JqZWN0KGhyZ25fb3JnKTsKCQkJCQlocmduX29yZyA9IDA7CgkJCQl9CgoJCQkJLyogSEdESU9CSiBob2xkUGVuID0gU2VsZWN0T2JqZWN0KGRpcy0+aERDLCBHZXRTdG9ja09iamVjdChCTEFDS19QRU4pKTsgKi8KCQkJCUV4dFNlbGVjdENsaXBSZ24oZGlzLT5oREMsIGhyZ24sIFJHTl9BTkQpOwoJCQkJRGVsZXRlT2JqZWN0KGhyZ24pOwoKCQkJCWlmICgodXA9ZW50cnktPnVwKSAhPSBOVUxMKSB7CgkJCQkJTW92ZVRvRXgoZGlzLT5oREMsIGltZ19wb3MtSU1BR0VfV0lEVEgvMiwgeSwgMCk7CgkJCQkJTGluZVRvKGRpcy0+aERDLCBpbWdfcG9zLTIsIHkpOwoKCQkJCQl4ID0gaW1nX3BvcyAtIElNQUdFX1dJRFRILzI7CgoJCQkJCWRvIHsKCQkJCQkJeCAtPSBJTUFHRV9XSURUSCtUUkVFX0xJTkVfRFg7CgoJCQkJCQlpZiAodXAtPm5leHQKI2lmbmRlZiBfTEVGVF9GSUxFUwoJCQkJCQkJJiYgKHVwLT5uZXh0LT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMgJiBGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpCiNlbmRpZgoJCQkJCQkJKSB7CgkJCQkJCQlNb3ZlVG9FeChkaXMtPmhEQywgeCwgZGlzLT5yY0l0ZW0udG9wLCAwKTsKCQkJCQkJCUxpbmVUbyhkaXMtPmhEQywgeCwgZGlzLT5yY0l0ZW0uYm90dG9tKTsKCQkJCQkJfQoJCQkJCX0gd2hpbGUoKHVwPXVwLT51cCkgIT0gTlVMTCk7CgkJCQl9CgoJCQkJeCA9IGltZ19wb3MgLSBJTUFHRV9XSURUSC8yOwoKCQkJCU1vdmVUb0V4KGRpcy0+aERDLCB4LCBkaXMtPnJjSXRlbS50b3AsIDApOwoJCQkJTGluZVRvKGRpcy0+aERDLCB4LCB5KTsKCgkJCQlpZiAoZW50cnktPm5leHQKI2lmbmRlZiBfTEVGVF9GSUxFUwoJCQkJCSYmIChlbnRyeS0+bmV4dC0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzJkZJTEVfQVRUUklCVVRFX0RJUkVDVE9SWSkKI2VuZGlmCgkJCQkJKQoJCQkJCUxpbmVUbyhkaXMtPmhEQywgeCwgZGlzLT5yY0l0ZW0uYm90dG9tKTsKCgkJCQlTZWxlY3RDbGlwUmduKGRpcy0+aERDLCBocmduX29yZyk7CgkJCQlpZiAoaHJnbl9vcmcpIERlbGV0ZU9iamVjdChocmduX29yZyk7CgkJCQkvKiBTZWxlY3RPYmplY3QoZGlzLT5oREMsIGhvbGRQZW4pOyAqLwoJCQl9IGVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykgewoJCQkJaW50IHJpZ2h0ID0gaW1nX3BvcyArIElNQUdFX1dJRFRIIC0gVFJFRV9MSU5FX0RYOwoKCQkJCWlmIChyaWdodCA+IHBhbmUtPndpZHRoc1tjb2xdKQoJCQkJCXBhbmUtPndpZHRoc1tjb2xdID0gcmlnaHQ7CgkJCX0KCQl9IGVsc2UgIHsKCQkJaW1nX3BvcyA9IGRpcy0+cmNJdGVtLmxlZnQ7CgkJfQoJfSBlbHNlIHsKCQlpbWdfcG9zID0gZGlzLT5yY0l0ZW0ubGVmdDsKCgkJaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQkJcGFuZS0+d2lkdGhzW2NvbF0gPSBJTUFHRV9XSURUSDsKCX0KCglpZiAoY2FsY1dpZHRoQ29sID09IC0xKSB7CgkJZm9jdXNSZWN0LmxlZnQgPSBpbWdfcG9zIC0yOwoKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJaWYgKHBhbmUtPnRyZWVQYW5lICYmIGVudHJ5KSB7CgkJCVJFQ1QgcnQgPSB7MH07CgoJCQlEcmF3VGV4dChkaXMtPmhEQywgZW50cnktPmRhdGEuY0ZpbGVOYW1lLCAtMSwgJnJ0LCBEVF9DQUxDUkVDVHxEVF9TSU5HTEVMSU5FfERUX05PUFJFRklYKTsKCgkJCWZvY3VzUmVjdC5yaWdodCA9IGRpcy0+cmNJdGVtLmxlZnQrcGFuZS0+cG9zaXRpb25zW2NvbCsxXStUUkVFX0xJTkVfRFggKyBydC5yaWdodCArMjsKCQl9CiNlbHNlCgoJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX0NPTVBSRVNTRUQpCgkJCXRleHRjb2xvciA9IENPTE9SX0NPTVBSRVNTRUQ7CgkJZWxzZQojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCQkJdGV4dGNvbG9yID0gUkdCKDAsMCwwKTsKCgkJaWYgKGRpcy0+aXRlbVN0YXRlICYgT0RTX0ZPQ1VTKSB7CgkJCXRleHRjb2xvciA9IFJHQigyNTUsMjU1LDI1NSk7CgkJCWJrY29sb3IgPSBDT0xPUl9TRUxFQ1RJT047CgkJfSBlbHNlIHsKCQkJYmtjb2xvciA9IFJHQigyNTUsMjU1LDI1NSk7CgkJfQoKCQloYnJ1c2ggPSBDcmVhdGVTb2xpZEJydXNoKGJrY29sb3IpOwoJCUZpbGxSZWN0KGRpcy0+aERDLCAmZm9jdXNSZWN0LCBoYnJ1c2gpOwoJCURlbGV0ZU9iamVjdChoYnJ1c2gpOwoKCQlTZXRCa01vZGUoZGlzLT5oREMsIFRSQU5TUEFSRU5UKTsKCQlTZXRUZXh0Q29sb3IoZGlzLT5oREMsIHRleHRjb2xvcik7CgoJCWN4ID0gcGFuZS0+d2lkdGhzW2NvbF07CgoJCWlmIChjeCAmJiBpbWchPUlNR19OT05FKSB7CgkJCWlmIChjeCA+IElNQUdFX1dJRFRIKQoJCQkJY3ggPSBJTUFHRV9XSURUSDsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJCQlpZiAoZW50cnktPmhpY29uICYmIGVudHJ5LT5oaWNvbiE9KEhJQ09OKS0xKQoJCQkJRHJhd0ljb25FeChkaXMtPmhEQywgaW1nX3BvcywgZGlzLT5yY0l0ZW0udG9wLCBlbnRyeS0+aGljb24sIGN4LCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU01JQ09OKSwgMCwgMCwgRElfTk9STUFMKTsKCQkJZWxzZQojZW5kaWYKCQkJCUltYWdlTGlzdF9EcmF3RXgoR2xvYmFscy5oaW1sLCBpbWcsIGRpcy0+aERDLAoJCQkJCQkJCSBpbWdfcG9zLCBkaXMtPnJjSXRlbS50b3AsIGN4LAoJCQkJCQkJCSBJTUFHRV9IRUlHSFQsIGJrY29sb3IsIENMUl9ERUZBVUxULCBJTERfTk9STUFMKTsKCQl9Cgl9CgoJaWYgKCFlbnRyeSkKCQlyZXR1cm47CgojaWZkZWYgX05PX0VYVEVOU0lPTlMKCWlmIChpbWcgPj0gSU1HX0ZPTERFUl9VUCkKCQlyZXR1cm47CiNlbmRpZgoKCWNvbCsrOwoKCS8qIG91cHV0IGZpbGUgbmFtZSAqLwoJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkKCQlvdXRwdXRfdGV4dChwYW5lLCBkaXMsIGNvbCwgZW50cnktPmRhdGEuY0ZpbGVOYW1lLCAwKTsKCWVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQljYWxjX3dpZHRoKHBhbmUsIGRpcywgY29sLCBlbnRyeS0+ZGF0YS5jRmlsZU5hbWUpOwoKCWNvbCsrOwoKI2lmZGVmIF9OT19FWFRFTlNJT05TCiAgaWYgKCFwYW5lLT50cmVlUGFuZSkgewojZW5kaWYKCiAgICAgICAgLyogZGlzcGxheSBmaWxlIHNpemUgKi8KCWlmICh2aXNpYmxlX2NvbHMgJiBDT0xfU0laRSkgewojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQlpZiAoIShhdHRycyZGSUxFX0FUVFJJQlVURV9ESVJFQ1RPUlkpKQojZW5kaWYKCQl7CgkJCVVMT05HTE9ORyBzaXplOwoKICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZSA9ICgoVUxPTkdMT05HKWVudHJ5LT5kYXRhLm5GaWxlU2l6ZUhpZ2ggPDwgMzIpIHwgZW50cnktPmRhdGEubkZpbGVTaXplTG93OwoKCQkJX3N0cHJpbnRmKGJ1ZmZlciwgc0xvbmdOdW1GbXQsIHNpemUpOwoKCQkJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkKCQkJCW91dHB1dF9udW1iZXIocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlcik7CgkJCWVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQkJCWNhbGNfd2lkdGgocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlcik7LypUT0RPOiBub3QgZXZlciB0aW1lIGVub3VnaCAqLwoJCX0KCgkJY29sKys7Cgl9CgoJLyogZGlzcGxheSBmaWxlIGRhdGUgKi8KCWlmICh2aXNpYmxlX2NvbHMgJiAoQ09MX0RBVEV8Q09MX1RJTUUpKSB7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQlmb3JtYXRfZGF0ZSgmZW50cnktPmRhdGEuZnRDcmVhdGlvblRpbWUsIGJ1ZmZlciwgdmlzaWJsZV9jb2xzKTsKCQlpZiAoY2FsY1dpZHRoQ29sID09IC0xKQoJCQlvdXRwdXRfdGV4dChwYW5lLCBkaXMsIGNvbCwgYnVmZmVyLCAwKTsKCQllbHNlIGlmIChjYWxjV2lkdGhDb2w9PWNvbCB8fCBjYWxjV2lkdGhDb2w9PUNPTFVNTlMpCgkJCWNhbGNfd2lkdGgocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlcik7CgkJY29sKys7CgoJCWZvcm1hdF9kYXRlKCZlbnRyeS0+ZGF0YS5mdExhc3RBY2Nlc3NUaW1lLCBidWZmZXIsIHZpc2libGVfY29scyk7CgkJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkKCQkJb3V0cHV0X3RleHQocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlciwgMCk7CgkJZWxzZSBpZiAoY2FsY1dpZHRoQ29sPT1jb2wgfHwgY2FsY1dpZHRoQ29sPT1DT0xVTU5TKQoJCQljYWxjX3dpZHRoKHBhbmUsIGRpcywgY29sLCBidWZmZXIpOwoJCWNvbCsrOwojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCgkJZm9ybWF0X2RhdGUoJmVudHJ5LT5kYXRhLmZ0TGFzdFdyaXRlVGltZSwgYnVmZmVyLCB2aXNpYmxlX2NvbHMpOwoJCWlmIChjYWxjV2lkdGhDb2wgPT0gLTEpCgkJCW91dHB1dF90ZXh0KHBhbmUsIGRpcywgY29sLCBidWZmZXIsIDApOwoJCWVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQkJY2FsY193aWR0aChwYW5lLCBkaXMsIGNvbCwgYnVmZmVyKTsKCQljb2wrKzsKCX0KCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCWlmIChlbnRyeS0+YmhmaV92YWxpZCkgewogICAgICAgICAgICBVTE9OR0xPTkcgaW5kZXggPSAoKFVMT05HTE9ORyllbnRyeS0+YmhmaS5uRmlsZUluZGV4SGlnaCA8PCAzMikgfCBlbnRyeS0+YmhmaS5uRmlsZUluZGV4TG93OwoKCQlpZiAodmlzaWJsZV9jb2xzICYgQ09MX0lOREVYKSB7CgkJCV9zdHByaW50ZihidWZmZXIsIHNMb25nSGV4Rm10LCBpbmRleCk7CgoJCQlpZiAoY2FsY1dpZHRoQ29sID09IC0xKQoJCQkJb3V0cHV0X3RleHQocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlciwgRFRfUklHSFQpOwoJCQllbHNlIGlmIChjYWxjV2lkdGhDb2w9PWNvbCB8fCBjYWxjV2lkdGhDb2w9PUNPTFVNTlMpCgkJCQljYWxjX3dpZHRoKHBhbmUsIGRpcywgY29sLCBidWZmZXIpOwoKCQkJY29sKys7CgkJfQoKCQlpZiAodmlzaWJsZV9jb2xzICYgQ09MX0xJTktTKSB7CgkJCXdzcHJpbnRmKGJ1ZmZlciwgc051bUZtdCwgZW50cnktPmJoZmkubk51bWJlck9mTGlua3MpOwoKCQkJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkKCQkJCW91dHB1dF90ZXh0KHBhbmUsIGRpcywgY29sLCBidWZmZXIsIERUX0NFTlRFUik7CgkJCWVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQkJCWNhbGNfd2lkdGgocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlcik7CgoJCQljb2wrKzsKCQl9Cgl9IGVsc2UKCQljb2wgKz0gMjsKI2VuZGlmIC8qIF9OT19FWFRFTlNJT05TICovCgoJLyogc2hvdyBmaWxlIGF0dHJpYnV0ZXMgKi8KCWlmICh2aXNpYmxlX2NvbHMgJiBDT0xfQVRUUklCVVRFUykgewojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQlzdGF0aWMgY29uc3QgVENIQVIgczRUYWJzW10gPSB7JyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcMCd9OwoJCWxzdHJjcHkoYnVmZmVyLCBzNFRhYnMpOwojZWxzZQoJCXN0YXRpYyBjb25zdCBUQ0hBUiBzMTFUYWJzW10gPSB7JyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcMCd9OwoJCWxzdHJjcHkoYnVmZmVyLCBzMTFUYWJzKTsKI2VuZGlmCgoJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX05PUk1BTCkJCQkJCWJ1ZmZlclsgMF0gPSAnTic7CgkJZWxzZSB7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX1JFQURPTkxZKQkJCWJ1ZmZlclsgMl0gPSAnUic7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX0hJRERFTikJCQkJYnVmZmVyWyA0XSA9ICdIJzsKCQkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfU1lTVEVNKQkJCQlidWZmZXJbIDZdID0gJ1MnOwoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9BUkNISVZFKQkJCQlidWZmZXJbIDhdID0gJ0EnOwoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9DT01QUkVTU0VEKQkJCWJ1ZmZlclsxMF0gPSAnQyc7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKQkJCWJ1ZmZlclsxMl0gPSAnRCc7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX0VOQ1JZUFRFRCkJCQlidWZmZXJbMTRdID0gJ0UnOwoJCQlpZiAoYXR0cnMgJiBGSUxFX0FUVFJJQlVURV9URU1QT1JBUlkpCQkJYnVmZmVyWzE2XSA9ICdUJzsKCQkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfU1BBUlNFX0ZJTEUpCQkJYnVmZmVyWzE4XSA9ICdQJzsKCQkJaWYgKGF0dHJzICYgRklMRV9BVFRSSUJVVEVfUkVQQVJTRV9QT0lOVCkJCWJ1ZmZlclsyMF0gPSAnUSc7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX09GRkxJTkUpCQkJCWJ1ZmZlclsyMl0gPSAnTyc7CgkJCWlmIChhdHRycyAmIEZJTEVfQVRUUklCVVRFX05PVF9DT05URU5UX0lOREVYRUQpCWJ1ZmZlclsyNF0gPSAnWCc7CiNlbmRpZiAvKiBfTk9fRVhURU5TSU9OUyAqLwoJCX0KCgkJaWYgKGNhbGNXaWR0aENvbCA9PSAtMSkKCQkJb3V0cHV0X3RhYmJlZF90ZXh0KHBhbmUsIGRpcywgY29sLCBidWZmZXIpOwoJCWVsc2UgaWYgKGNhbGNXaWR0aENvbD09Y29sIHx8IGNhbGNXaWR0aENvbD09Q09MVU1OUykKCQkJY2FsY190YWJiZWRfd2lkdGgocGFuZSwgZGlzLCBjb2wsIGJ1ZmZlcik7CgoJCWNvbCsrOwoJfQoKLypUT0RPCglpZiAoZmxhZ3Muc2VjdXJpdHkpIHsKCQlzdGF0aWMgY29uc3QgVENIQVIgc1NlY1RhYnNbXSA9IHsKCQkJJyAnLCdcdCcsJyAnLCdcdCcsJyAnLCdcdCcsJyAnLAoJCQknICcsJ1x0JywnICcsCgkJCScgJywnXHQnLCcgJywnXHQnLCcgJywnXHQnLCcgJywKCQkJJyAnLCdcdCcsJyAnLAoJCQknICcsJ1x0JywnICcsJ1x0JywnICcsJ1x0JywnICcsCgkJCSdcMCcKCQl9OwoKCQlEV09SRCByaWdodHMgPSBnZXRfYWNjZXNzX21hc2soKTsKCgkJbHN0cmNweShidWZmZXIsIHNTZWNUYWJzKTsKCgkJaWYgKHJpZ2h0cyAmIEZJTEVfUkVBRF9EQVRBKQkJCWJ1ZmZlclsgMF0gPSAnUic7CgkJaWYgKHJpZ2h0cyAmIEZJTEVfV1JJVEVfREFUQSkJCQlidWZmZXJbIDJdID0gJ1cnOwoJCWlmIChyaWdodHMgJiBGSUxFX0FQUEVORF9EQVRBKQkJCWJ1ZmZlclsgNF0gPSAnQSc7CgkJaWYgKHJpZ2h0cyAmIEZJTEVfUkVBRF9FQSkJCQkJe2J1ZmZlcls2XSA9ICdlbnRyeSc7IGJ1ZmZlclsgN10gPSAnUic7fQoJCWlmIChyaWdodHMgJiBGSUxFX1dSSVRFX0VBKQkJCQl7YnVmZmVyWzldID0gJ2VudHJ5JzsgYnVmZmVyWzEwXSA9ICdXJzt9CgkJaWYgKHJpZ2h0cyAmIEZJTEVfRVhFQ1VURSkJCQkJYnVmZmVyWzEyXSA9ICdYJzsKCQlpZiAocmlnaHRzICYgRklMRV9ERUxFVEVfQ0hJTEQpCQkJYnVmZmVyWzE0XSA9ICdEJzsKCQlpZiAocmlnaHRzICYgRklMRV9SRUFEX0FUVFJJQlVURVMpCQl7YnVmZmVyWzE2XSA9ICdhJzsgYnVmZmVyWzE3XSA9ICdSJzt9CgkJaWYgKHJpZ2h0cyAmIEZJTEVfV1JJVEVfQVRUUklCVVRFUykJCXtidWZmZXJbMTldID0gJ2EnOyBidWZmZXJbMjBdID0gJ1cnO30KCQlpZiAocmlnaHRzICYgV1JJVEVfREFDKQkJCQkJYnVmZmVyWzIyXSA9ICdDJzsKCQlpZiAocmlnaHRzICYgV1JJVEVfT1dORVIpCQkJCWJ1ZmZlclsyNF0gPSAnTyc7CgkJaWYgKHJpZ2h0cyAmIFNZTkNIUk9OSVpFKQkJCQlidWZmZXJbMjZdID0gJ1MnOwoKCQlvdXRwdXRfdGV4dChkaXMsIGNvbCsrLCBidWZmZXIsIERUX0xFRlQsIDMsIHBzaXplKTsKCX0KCglpZiAoZmxhZ3MuZGVzY3JpcHRpb24pIHsKCQlnZXRfZGVzY3JpcHRpb24oYnVmZmVyKTsKCQlvdXRwdXRfdGV4dChkaXMsIGNvbCsrLCBidWZmZXIsIDAsIHBzaXplKTsKCX0KKi8KCiNpZmRlZiBfTk9fRVhURU5TSU9OUwogIH0KCiAgICAgICAgLyogZHJhdyBmb2N1cyBmcmFtZSAqLwoJaWYgKChkaXMtPml0ZW1TdGF0ZSZPRFNfRk9DVVMpICYmIGNhbGNXaWR0aENvbD09LTEpIHsKCSAgICAgICAgLyogQ3VycmVudGx5IFswNC8yMDAwXSBXaW5lIG5laXRoZXIgYmVoYXZlcyBleGFjdGx5IHRoZSBzYW1lICovCgkgICAgICAgIC8qIHdheSBhcyBXSU4gOTUgbm9yIGxpa2UgV2luZG93cyBOVC4uLiAqLwoJCUhHRElPQkogbGFzdEJydXNoOwoJCUhQRU4gbGFzdFBlbjsKCQlIUEVOIGhwZW47CgoJCWlmICghKEdldFZlcnNpb24oKSAmIDB4ODAwMDAwMDApKSB7CS8qIFdpbmRvd3MgTlQ/ICovCgkJCUxPR0JSVVNIIGxiID0ge1BTX1NPTElELCBSR0IoMjU1LDI1NSwyNTUpfTsKCQkJaHBlbiA9IEV4dENyZWF0ZVBlbihQU19DT1NNRVRJQ3xQU19BTFRFUk5BVEUsIDEsICZsYiwgMCwgMCk7CgkJfSBlbHNlCgkJCWhwZW4gPSBDcmVhdGVQZW4oUFNfRE9ULCAwLCBSR0IoMjU1LDI1NSwyNTUpKTsKCgkJbGFzdFBlbiA9IFNlbGVjdFBlbihkaXMtPmhEQywgaHBlbik7CgkJbGFzdEJydXNoID0gU2VsZWN0T2JqZWN0KGRpcy0+aERDLCBHZXRTdG9ja09iamVjdChIT0xMT1dfQlJVU0gpKTsKCQlTZXRST1AyKGRpcy0+aERDLCBSMl9YT1JQRU4pOwoJCVJlY3RhbmdsZShkaXMtPmhEQywgZm9jdXNSZWN0LmxlZnQsIGZvY3VzUmVjdC50b3AsIGZvY3VzUmVjdC5yaWdodCwgZm9jdXNSZWN0LmJvdHRvbSk7CgkJU2VsZWN0T2JqZWN0KGRpcy0+aERDLCBsYXN0QnJ1c2gpOwoJCVNlbGVjdE9iamVjdChkaXMtPmhEQywgbGFzdFBlbik7CgkJRGVsZXRlT2JqZWN0KGhwZW4pOwoJfQojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KfQoKCiNpZmRlZiBfTk9fRVhURU5TSU9OUwoKc3RhdGljIHZvaWQgZHJhd19zcGxpdGJhcihIV05EIGh3bmQsIGludCB4KQp7CglSRUNUIHJ0OwoJSERDIGhkYyA9IEdldERDKGh3bmQpOwoKCUdldENsaWVudFJlY3QoaHduZCwgJnJ0KTsKCglydC5sZWZ0ID0geCAtIFNQTElUX1dJRFRILzI7CglydC5yaWdodCA9IHggKyBTUExJVF9XSURUSC8yKzE7CgoJSW52ZXJ0UmVjdChoZGMsICZydCk7CgoJUmVsZWFzZURDKGh3bmQsIGhkYyk7Cn0KCiNlbmRpZiAvKiBfTk9fRVhURU5TSU9OUyAqLwoKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCnN0YXRpYyB2b2lkIHNldF9oZWFkZXIoUGFuZSogcGFuZSkKewoJSERfSVRFTSBpdGVtOwoJaW50IHNjcm9sbF9wb3MgPSBHZXRTY3JvbGxQb3MocGFuZS0+aHduZCwgU0JfSE9SWik7CglpbnQgaT0wLCB4PTA7CgoJaXRlbS5tYXNrID0gSERJX1dJRFRIOwoJaXRlbS5jeHkgPSAwOwoKCWZvcig7IHgrcGFuZS0+d2lkdGhzW2ldPHNjcm9sbF9wb3MgJiYgaTxDT0xVTU5TOyBpKyspIHsKCQl4ICs9IHBhbmUtPndpZHRoc1tpXTsKCQlTZW5kTWVzc2FnZShwYW5lLT5od25kSGVhZGVyLCBIRE1fU0VUSVRFTSwgaSwgKExQQVJBTSkgJml0ZW0pOwoJfQoKCWlmIChpIDwgQ09MVU1OUykgewoJCXggKz0gcGFuZS0+d2lkdGhzW2ldOwoJCWl0ZW0uY3h5ID0geCAtIHNjcm9sbF9wb3M7CgkJU2VuZE1lc3NhZ2UocGFuZS0+aHduZEhlYWRlciwgSERNX1NFVElURU0sIGkrKywgKExQQVJBTSkgJml0ZW0pOwoKCQlmb3IoOyBpPENPTFVNTlM7IGkrKykgewoJCQlpdGVtLmN4eSA9IHBhbmUtPndpZHRoc1tpXTsKCQkJeCArPSBwYW5lLT53aWR0aHNbaV07CgkJCVNlbmRNZXNzYWdlKHBhbmUtPmh3bmRIZWFkZXIsIEhETV9TRVRJVEVNLCBpLCAoTFBBUkFNKSAmaXRlbSk7CgkJfQoJfQp9CgpzdGF0aWMgTFJFU1VMVCBwYW5lX25vdGlmeShQYW5lKiBwYW5lLCBOTUhEUiogcG5taCkKewoJc3dpdGNoKHBubWgtPmNvZGUpIHsKCQljYXNlIEhETl9JVEVNQ0hBTkdFRDogewoJCQlIRF9OT1RJRlkqIHBoZG4gPSAoSERfTk9USUZZKikgcG5taDsKCQkJaW50IGlkeCA9IHBoZG4tPmlJdGVtOwoJCQlpbnQgZHggPSBwaGRuLT5waXRlbS0+Y3h5IC0gcGFuZS0+d2lkdGhzW2lkeF07CgkJCWludCBpOwoKCQkJUkVDVCBjbG50OwoJCQlHZXRDbGllbnRSZWN0KHBhbmUtPmh3bmQsICZjbG50KTsKCgkJCXBhbmUtPndpZHRoc1tpZHhdICs9IGR4OwoKCQkJZm9yKGk9aWR4OyArK2k8PUNPTFVNTlM7ICkKCQkJCXBhbmUtPnBvc2l0aW9uc1tpXSArPSBkeDsKCgkJCXsKCQkJCWludCBzY3JvbGxfcG9zID0gR2V0U2Nyb2xsUG9zKHBhbmUtPmh3bmQsIFNCX0hPUlopOwoJCQkJUkVDVCBydF9zY3I7CgkJCQlSRUNUIHJ0X2NsaXA7CgoJCQkJcnRfc2NyLmxlZnQgICA9IHBhbmUtPnBvc2l0aW9uc1tpZHgrMV0tc2Nyb2xsX3BvczsKCQkJCXJ0X3Njci50b3AgICAgPSAwOwoJCQkJcnRfc2NyLnJpZ2h0ICA9IGNsbnQucmlnaHQ7CgkJCQlydF9zY3IuYm90dG9tID0gY2xudC5ib3R0b207CgoJCQkJcnRfY2xpcC5sZWZ0ICAgPSBwYW5lLT5wb3NpdGlvbnNbaWR4XS1zY3JvbGxfcG9zOwoJCQkJcnRfY2xpcC50b3AgICAgPSAwOwoJCQkJcnRfY2xpcC5yaWdodCAgPSBjbG50LnJpZ2h0OwoJCQkJcnRfY2xpcC5ib3R0b20gPSBjbG50LmJvdHRvbTsKCgkJCQlpZiAocnRfc2NyLmxlZnQgPCAwKSBydF9zY3IubGVmdCA9IDA7CgkJCQlpZiAocnRfY2xpcC5sZWZ0IDwgMCkgcnRfY2xpcC5sZWZ0ID0gMDsKCgkJCQlTY3JvbGxXaW5kb3dFeChwYW5lLT5od25kLCBkeCwgMCwgJnJ0X3NjciwgJnJ0X2NsaXAsIDAsIDAsIFNXX0lOVkFMSURBVEUpOwoKCQkJCXJ0X2NsaXAucmlnaHQgPSBwYW5lLT5wb3NpdGlvbnNbaWR4KzFdOwoJCQkJUmVkcmF3V2luZG93KHBhbmUtPmh3bmQsICZydF9jbGlwLCAwLCBSRFdfSU5WQUxJREFURXxSRFdfVVBEQVRFTk9XKTsKCgkJCQlpZiAocG5taC0+Y29kZSA9PSBIRE5fRU5EVFJBQ0spIHsKCQkJCQlTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9TRVRIT1JJWk9OVEFMRVhURU5ULCBwYW5lLT5wb3NpdGlvbnNbQ09MVU1OU10sIDApOwoKCQkJCQlpZiAoR2V0U2Nyb2xsUG9zKHBhbmUtPmh3bmQsIFNCX0hPUlopICE9IHNjcm9sbF9wb3MpCgkJCQkJCXNldF9oZWFkZXIocGFuZSk7CgkJCQl9CgkJCX0KCgkJCXJldHVybiBGQUxTRTsKCQl9CgoJCWNhc2UgSEROX0RJVklERVJEQkxDTElDSzogewoJCQlIRF9OT1RJRlkqIHBoZG4gPSAoSERfTk9USUZZKikgcG5taDsKCQkJSERfSVRFTSBpdGVtOwoKCQkJY2FsY19zaW5nbGVfd2lkdGgocGFuZSwgcGhkbi0+aUl0ZW0pOwoJCQlpdGVtLm1hc2sgPSBIRElfV0lEVEg7CgkJCWl0ZW0uY3h5ID0gcGFuZS0+d2lkdGhzW3BoZG4tPmlJdGVtXTsKCgkJCVNlbmRNZXNzYWdlKHBhbmUtPmh3bmRIZWFkZXIsIEhETV9TRVRJVEVNLCBwaGRuLT5pSXRlbSwgKExQQVJBTSkgJml0ZW0pOwoJCQlJbnZhbGlkYXRlUmVjdChwYW5lLT5od25kLCAwLCBUUlVFKTsKCQkJYnJlYWs7fQoJfQoKCXJldHVybiAwOwp9CgojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCgpzdGF0aWMgdm9pZCBzY2FuX2VudHJ5KENoaWxkV25kKiBjaGlsZCwgRW50cnkqIGVudHJ5LCBpbnQgaWR4LCBIV05EIGh3bmQpCnsKCVRDSEFSIHBhdGhbTUFYX1BBVEhdOwoJSENVUlNPUiBvbGRfY3Vyc29yID0gU2V0Q3Vyc29yKExvYWRDdXJzb3IoMCwgSURDX1dBSVQpKTsKCgkvKiBkZWxldGUgc3ViIGVudHJpZXMgaW4gbGVmdCBwYW5lICovCglmb3IoOzspIHsKCQlMUkVTVUxUIHJlcyA9IFNlbmRNZXNzYWdlKGNoaWxkLT5sZWZ0Lmh3bmQsIExCX0dFVElURU1EQVRBLCBpZHgrMSwgMCk7CgkJRW50cnkqIHN1YiA9IChFbnRyeSopIHJlczsKCgkJaWYgKHJlcz09TEJfRVJSIHx8ICFzdWIgfHwgc3ViLT5sZXZlbDw9ZW50cnktPmxldmVsKQoJCQlicmVhazsKCgkJU2VuZE1lc3NhZ2UoY2hpbGQtPmxlZnQuaHduZCwgTEJfREVMRVRFU1RSSU5HLCBpZHgrMSwgMCk7Cgl9CgoJLyogZW1wdHkgcmlnaHQgcGFuZSAqLwoJU2VuZE1lc3NhZ2UoY2hpbGQtPnJpZ2h0Lmh3bmQsIExCX1JFU0VUQ09OVEVOVCwgMCwgMCk7CgoJLyogcmVsZWFzZSBtZW1vcnkgKi8KCWZyZWVfZW50cmllcyhlbnRyeSk7CgoJLyogcmVhZCBjb250ZW50cyBmcm9tIGRpc2sgKi8KI2lmZGVmIF9TSEVMTF9GT0xERVJTCglpZiAoZW50cnktPmV0eXBlID09IEVUX1NIRUxMKQoJewoJCXJlYWRfZGlyZWN0b3J5KGVudHJ5LCBOVUxMLCBjaGlsZC0+c29ydE9yZGVyLCBod25kKTsKCX0KCWVsc2UKI2VuZGlmCgl7CgkJZ2V0X3BhdGgoZW50cnksIHBhdGgpOwoJCXJlYWRfZGlyZWN0b3J5KGVudHJ5LCBwYXRoLCBjaGlsZC0+c29ydE9yZGVyLCBod25kKTsKCX0KCgkvKiBpbnNlcnQgZm91bmQgZW50cmllcyBpbiByaWdodCBwYW5lICovCglpbnNlcnRfZW50cmllcygmY2hpbGQtPnJpZ2h0LCBlbnRyeS0+ZG93biwgY2hpbGQtPmZpbHRlcl9wYXR0ZXJuLCBjaGlsZC0+ZmlsdGVyX2ZsYWdzLCAtMSk7CgljYWxjX3dpZHRocygmY2hpbGQtPnJpZ2h0LCBGQUxTRSk7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCXNldF9oZWFkZXIoJmNoaWxkLT5yaWdodCk7CiNlbmRpZgoKCWNoaWxkLT5oZWFkZXJfd2R0aHNfb2sgPSBGQUxTRTsKCglTZXRDdXJzb3Iob2xkX2N1cnNvcik7Cn0KCgovKiBleHBhbmQgYSBkaXJlY3RvcnkgZW50cnkgKi8KCnN0YXRpYyBCT09MIGV4cGFuZF9lbnRyeShDaGlsZFduZCogY2hpbGQsIEVudHJ5KiBkaXIpCnsKCWludCBpZHg7CglFbnRyeSogcDsKCglpZiAoIWRpciB8fCBkaXItPmV4cGFuZGVkIHx8ICFkaXItPmRvd24pCgkJcmV0dXJuIEZBTFNFOwoKCXAgPSBkaXItPmRvd247CgoJaWYgKHAtPmRhdGEuY0ZpbGVOYW1lWzBdPT0nLicgJiYgcC0+ZGF0YS5jRmlsZU5hbWVbMV09PSdcMCcgJiYgcC0+bmV4dCkgewoJCXAgPSBwLT5uZXh0OwoKCQlpZiAocC0+ZGF0YS5jRmlsZU5hbWVbMF09PScuJyAmJiBwLT5kYXRhLmNGaWxlTmFtZVsxXT09Jy4nICYmCgkJCQlwLT5kYXRhLmNGaWxlTmFtZVsyXT09J1wwJyAmJiBwLT5uZXh0KQoJCQlwID0gcC0+bmV4dDsKCX0KCgkvKiBubyBzdWJkaXJlY3RvcmllcyA/ICovCglpZiAoIShwLT5kYXRhLmR3RmlsZUF0dHJpYnV0ZXMmRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSkKCQlyZXR1cm4gRkFMU0U7CgoJaWR4ID0gU2VuZE1lc3NhZ2UoY2hpbGQtPmxlZnQuaHduZCwgTEJfRklORFNUUklORywgMCwgKExQQVJBTSlkaXIpOwoKCWRpci0+ZXhwYW5kZWQgPSBUUlVFOwoKCS8qIGluc2VydCBlbnRyaWVzIGluIGxlZnQgcGFuZSAqLwoJaW5zZXJ0X2VudHJpZXMoJmNoaWxkLT5sZWZ0LCBwLCBOVUxMLCBURl9BTEwsIGlkeCk7CgoJaWYgKCFjaGlsZC0+aGVhZGVyX3dkdGhzX29rKSB7CgkJaWYgKGNhbGNfd2lkdGhzKCZjaGlsZC0+bGVmdCwgRkFMU0UpKSB7CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQkJc2V0X2hlYWRlcigmY2hpbGQtPmxlZnQpOwojZW5kaWYKCgkJCWNoaWxkLT5oZWFkZXJfd2R0aHNfb2sgPSBUUlVFOwoJCX0KCX0KCglyZXR1cm4gVFJVRTsKfQoKCnN0YXRpYyB2b2lkIGNvbGxhcHNlX2VudHJ5KFBhbmUqIHBhbmUsIEVudHJ5KiBkaXIpCnsKCWludCBpZHggPSBTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9GSU5EU1RSSU5HLCAwLCAoTFBBUkFNKWRpcik7CgoJU2hvd1dpbmRvdyhwYW5lLT5od25kLCBTV19ISURFKTsKCgkvKiBoaWRlIHN1YiBlbnRyaWVzICovCglmb3IoOzspIHsKCQlMUkVTVUxUIHJlcyA9IFNlbmRNZXNzYWdlKHBhbmUtPmh3bmQsIExCX0dFVElURU1EQVRBLCBpZHgrMSwgMCk7CgkJRW50cnkqIHN1YiA9IChFbnRyeSopIHJlczsKCgkJaWYgKHJlcz09TEJfRVJSIHx8ICFzdWIgfHwgc3ViLT5sZXZlbDw9ZGlyLT5sZXZlbCkKCQkJYnJlYWs7CgoJCVNlbmRNZXNzYWdlKHBhbmUtPmh3bmQsIExCX0RFTEVURVNUUklORywgaWR4KzEsIDApOwoJfQoKCWRpci0+ZXhwYW5kZWQgPSBGQUxTRTsKCglTaG93V2luZG93KHBhbmUtPmh3bmQsIFNXX1NIT1cpOwp9CgoKc3RhdGljIHZvaWQgcmVmcmVzaF9yaWdodF9wYW5lKENoaWxkV25kKiBjaGlsZCkKewoJU2VuZE1lc3NhZ2UoY2hpbGQtPnJpZ2h0Lmh3bmQsIExCX1JFU0VUQ09OVEVOVCwgMCwgMCk7CglpbnNlcnRfZW50cmllcygmY2hpbGQtPnJpZ2h0LCBjaGlsZC0+cmlnaHQucm9vdCwgY2hpbGQtPmZpbHRlcl9wYXR0ZXJuLCBjaGlsZC0+ZmlsdGVyX2ZsYWdzLCAtMSk7CgljYWxjX3dpZHRocygmY2hpbGQtPnJpZ2h0LCBGQUxTRSk7CgojaWZuZGVmIF9OT19FWFRFTlNJT05TCglzZXRfaGVhZGVyKCZjaGlsZC0+cmlnaHQpOwojZW5kaWYKfQoKc3RhdGljIHZvaWQgc2V0X2N1cmRpcihDaGlsZFduZCogY2hpbGQsIEVudHJ5KiBlbnRyeSwgaW50IGlkeCwgSFdORCBod25kKQp7CglUQ0hBUiBwYXRoW01BWF9QQVRIXTsKCglpZiAoIWVudHJ5KQoJCXJldHVybjsKCglwYXRoWzBdID0gJ1wwJzsKCgljaGlsZC0+bGVmdC5jdXIgPSBlbnRyeTsKCgljaGlsZC0+cmlnaHQucm9vdCA9IGVudHJ5LT5kb3duPyBlbnRyeS0+ZG93bjogZW50cnk7CgljaGlsZC0+cmlnaHQuY3VyID0gZW50cnk7CgoJaWYgKCFlbnRyeS0+c2Nhbm5lZCkKCQlzY2FuX2VudHJ5KGNoaWxkLCBlbnRyeSwgaWR4LCBod25kKTsKCWVsc2UKCQlyZWZyZXNoX3JpZ2h0X3BhbmUoY2hpbGQpOwoKCWdldF9wYXRoKGVudHJ5LCBwYXRoKTsKCWxzdHJjcHkoY2hpbGQtPnBhdGgsIHBhdGgpOwoKCWlmIChjaGlsZC0+aHduZCkJLyogb25seSBjaGFuZ2Ugd2luZG93IHRpdGxlLCBpZiB0aGUgd2luZG93IGFscmVhZHkgZXhpc3RzICovCgkJU2V0V2luZG93VGV4dChjaGlsZC0+aHduZCwgcGF0aCk7CgoJaWYgKHBhdGhbMF0pCgkJaWYgKFNldEN1cnJlbnREaXJlY3RvcnkocGF0aCkpCgkJCXNldF9zcGFjZV9zdGF0dXMoKTsKfQoKCnN0YXRpYyB2b2lkIHJlZnJlc2hfY2hpbGQoQ2hpbGRXbmQqIGNoaWxkKQp7CglUQ0hBUiBwYXRoW01BWF9QQVRIXSwgZHJ2W19NQVhfRFJJVkUrMV07CglFbnRyeSogZW50cnk7CglpbnQgaWR4OwoKCWdldF9wYXRoKGNoaWxkLT5sZWZ0LmN1ciwgcGF0aCk7CglfdHNwbGl0cGF0aChwYXRoLCBkcnYsIE5VTEwsIE5VTEwsIE5VTEwpOwoKCWNoaWxkLT5yaWdodC5yb290ID0gTlVMTDsKCglzY2FuX2VudHJ5KGNoaWxkLCAmY2hpbGQtPnJvb3QuZW50cnksIDAsIGNoaWxkLT5od25kKTsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKGNoaWxkLT5yb290LmVudHJ5LmV0eXBlID09IEVUX1NIRUxMKQoJCWVudHJ5ID0gcmVhZF90cmVlKCZjaGlsZC0+cm9vdCwgTlVMTCwgZ2V0X3BhdGhfcGlkbChwYXRoLGNoaWxkLT5od25kKSwgZHJ2LCBjaGlsZC0+c29ydE9yZGVyLCBjaGlsZC0+aHduZCk7CgllbHNlCiNlbmRpZgoJCWVudHJ5ID0gcmVhZF90cmVlKCZjaGlsZC0+cm9vdCwgcGF0aCwgTlVMTCwgZHJ2LCBjaGlsZC0+c29ydE9yZGVyLCBjaGlsZC0+aHduZCk7CgoJaWYgKCFlbnRyeSkKCQllbnRyeSA9ICZjaGlsZC0+cm9vdC5lbnRyeTsKCglpbnNlcnRfZW50cmllcygmY2hpbGQtPmxlZnQsIGNoaWxkLT5yb290LmVudHJ5LmRvd24sIE5VTEwsIFRGX0FMTCwgMCk7CgoJc2V0X2N1cmRpcihjaGlsZCwgZW50cnksIDAsIGNoaWxkLT5od25kKTsKCglpZHggPSBTZW5kTWVzc2FnZShjaGlsZC0+bGVmdC5od25kLCBMQl9GSU5EU1RSSU5HLCAwLCAoTFBBUkFNKWNoaWxkLT5sZWZ0LmN1cik7CglTZW5kTWVzc2FnZShjaGlsZC0+bGVmdC5od25kLCBMQl9TRVRDVVJTRUwsIGlkeCwgMCk7Cn0KCgpzdGF0aWMgdm9pZCBjcmVhdGVfZHJpdmVfYmFyKHZvaWQpCnsKCVRCQlVUVE9OIGRyaXZlYmFyQnRuID0gezAsIDAsIFRCU1RBVEVfRU5BQkxFRCwgQlROU19CVVRUT04sIHswLCAwfSwgMCwgMH07CiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCVRDSEFSIGIxW0JVRkZFUl9MRU5dOwojZW5kaWYKCWludCBidG4gPSAxOwoJUFRTVFIgcDsKCglHZXRMb2dpY2FsRHJpdmVTdHJpbmdzKEJVRkZFUl9MRU4sIEdsb2JhbHMuZHJpdmVzKTsKCglHbG9iYWxzLmhkcml2ZWJhciA9IENyZWF0ZVRvb2xiYXJFeChHbG9iYWxzLmhNYWluV25kLCBXU19DSElMRHxXU19WSVNJQkxFfENDU19OT01PVkVZfFRCU1RZTEVfTElTVCwKCQkJCUlEV19EUklWRUJBUiwgMiwgR2xvYmFscy5oSW5zdGFuY2UsIElEQl9EUklWRUJBUiwgJmRyaXZlYmFyQnRuLAoJCQkJMCwgMTYsIDEzLCAxNiwgMTMsIHNpemVvZihUQkJVVFRPTikpOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwojaWZkZWYgX19XSU5FX18KCS8qIGluc2VydCB1bml4IGZpbGUgc3lzdGVtIGJ1dHRvbiAqLwoJYjFbMF0gPSAnLyc7CgliMVsxXSA9ICdcMCc7CgliMVsyXSA9ICdcMCc7CglTZW5kTWVzc2FnZShHbG9iYWxzLmhkcml2ZWJhciwgVEJfQUREU1RSSU5HLCAwLCAoTFBBUkFNKWIxKTsKCglkcml2ZWJhckJ0bi5pZENvbW1hbmQgPSBJRF9EUklWRV9VTklYX0ZTOwoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0lOU0VSVEJVVFRPTiwgYnRuKyssIChMUEFSQU0pJmRyaXZlYmFyQnRuKTsKCWRyaXZlYmFyQnRuLmlTdHJpbmcrKzsKI2VuZGlmCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJLyogaW5zZXJ0IHNoZWxsIG5hbWVzcGFjZSBidXR0b24gKi8KCWxvYWRfc3RyaW5nKGIxLCBJRFNfU0hFTEwpOwoJYjFbbHN0cmxlbihiMSkrMV0gPSAnXDAnOwoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0FERFNUUklORywgMCwgKExQQVJBTSliMSk7CgoJZHJpdmViYXJCdG4uaWRDb21tYW5kID0gSURfRFJJVkVfU0hFTExfTlM7CglTZW5kTWVzc2FnZShHbG9iYWxzLmhkcml2ZWJhciwgVEJfSU5TRVJUQlVUVE9OLCBidG4rKywgKExQQVJBTSkmZHJpdmViYXJCdG4pOwoJZHJpdmViYXJCdG4uaVN0cmluZysrOwojZW5kaWYKCgkvKiByZWdpc3RlciB3aW5kb3dzIGRyaXZlIHJvb3Qgc3RyaW5ncyAqLwoJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0FERFNUUklORywgMCwgKExQQVJBTSlHbG9iYWxzLmRyaXZlcyk7CiNlbmRpZgoKCWRyaXZlYmFyQnRuLmlkQ29tbWFuZCA9IElEX0RSSVZFX0ZJUlNUOwoKCWZvcihwPUdsb2JhbHMuZHJpdmVzOyAqcDsgKSB7CiNpZmRlZiBfTk9fRVhURU5TSU9OUwoJCS8qIGluc2VydCBkcml2ZSBsZXR0ZXIgKi8KCQlUQ0hBUiBiWzNdID0ge3RvbG93ZXIoKnApfTsKCQlTZW5kTWVzc2FnZShHbG9iYWxzLmhkcml2ZWJhciwgVEJfQUREU1RSSU5HLCAwLCAoTFBBUkFNKWIpOwojZW5kaWYKCQlzd2l0Y2goR2V0RHJpdmVUeXBlKHApKSB7CgkJCWNhc2UgRFJJVkVfUkVNT1ZBQkxFOglkcml2ZWJhckJ0bi5pQml0bWFwID0gMTsJYnJlYWs7CgkJCWNhc2UgRFJJVkVfQ0RST006CQlkcml2ZWJhckJ0bi5pQml0bWFwID0gMzsJYnJlYWs7CgkJCWNhc2UgRFJJVkVfUkVNT1RFOgkJZHJpdmViYXJCdG4uaUJpdG1hcCA9IDQ7CWJyZWFrOwoJCQljYXNlIERSSVZFX1JBTURJU0s6CQlkcml2ZWJhckJ0bi5pQml0bWFwID0gNTsJYnJlYWs7CgkJCWRlZmF1bHQ6LypEUklWRV9GSVhFRCovCWRyaXZlYmFyQnRuLmlCaXRtYXAgPSAyOwoJCX0KCgkJU2VuZE1lc3NhZ2UoR2xvYmFscy5oZHJpdmViYXIsIFRCX0lOU0VSVEJVVFRPTiwgYnRuKyssIChMUEFSQU0pJmRyaXZlYmFyQnRuKTsKCQlkcml2ZWJhckJ0bi5pZENvbW1hbmQrKzsKCQlkcml2ZWJhckJ0bi5pU3RyaW5nKys7CgoJCXdoaWxlKCpwKyspOwoJfQp9CgpzdGF0aWMgdm9pZCByZWZyZXNoX2RyaXZlcyh2b2lkKQp7CglSRUNUIHJlY3Q7CgoJLyogZGVzdHJveSBkcml2ZSBiYXIgKi8KCURlc3Ryb3lXaW5kb3coR2xvYmFscy5oZHJpdmViYXIpOwoJR2xvYmFscy5oZHJpdmViYXIgPSAwOwoKCS8qIHJlLWNyZWF0ZSBkcml2ZSBiYXIgKi8KCWNyZWF0ZV9kcml2ZV9iYXIoKTsKCgkvKiB1cGRhdGUgd2luZG93IGxheW91dCAqLwoJR2V0Q2xpZW50UmVjdChHbG9iYWxzLmhNYWluV25kLCAmcmVjdCk7CglTZW5kTWVzc2FnZShHbG9iYWxzLmhNYWluV25kLCBXTV9TSVpFLCAwLCBNQUtFTE9ORyhyZWN0LnJpZ2h0LCByZWN0LmJvdHRvbSkpOwp9CgoKc3RhdGljIEJPT0wgbGF1bmNoX2ZpbGUoSFdORCBod25kLCBMUENUU1RSIGNtZCwgVUlOVCBuQ21kU2hvdykKewoJSElOU1RBTkNFIGhpbnN0ID0gU2hlbGxFeGVjdXRlKGh3bmQsIE5VTEwvKm9wZXJhdGlvbiovLCBjbWQsIE5VTEwvKnBhcmFtZXRlcnMqLywgTlVMTC8qZGlyKi8sIG5DbWRTaG93KTsKCglpZiAoKGludCloaW5zdCA8PSAzMikgewoJCWRpc3BsYXlfZXJyb3IoaHduZCwgR2V0TGFzdEVycm9yKCkpOwoJCXJldHVybiBGQUxTRTsKCX0KCglyZXR1cm4gVFJVRTsKfQoKCnN0YXRpYyBCT09MIGxhdW5jaF9lbnRyeShFbnRyeSogZW50cnksIEhXTkQgaHduZCwgVUlOVCBuQ21kU2hvdykKewoJVENIQVIgY21kW01BWF9QQVRIXTsKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJaWYgKGVudHJ5LT5ldHlwZSA9PSBFVF9TSEVMTCkgewoJCUJPT0wgcmV0ID0gVFJVRTsKCgkJU0hFTExFWEVDVVRFSU5GTyBzaGV4aW5mbzsKCgkJc2hleGluZm8uY2JTaXplID0gc2l6ZW9mKFNIRUxMRVhFQ1VURUlORk8pOwoJCXNoZXhpbmZvLmZNYXNrID0gU0VFX01BU0tfSURMSVNUOwoJCXNoZXhpbmZvLmh3bmQgPSBod25kOwoJCXNoZXhpbmZvLmxwVmVyYiA9IE5VTEw7CgkJc2hleGluZm8ubHBGaWxlID0gTlVMTDsKCQlzaGV4aW5mby5scFBhcmFtZXRlcnMgPSBOVUxMOwoJCXNoZXhpbmZvLmxwRGlyZWN0b3J5ID0gTlVMTDsKCQlzaGV4aW5mby5uU2hvdyA9IG5DbWRTaG93OwoJCXNoZXhpbmZvLmxwSURMaXN0ID0gZ2V0X3RvX2Fic29sdXRlX3BpZGwoZW50cnksIGh3bmQpOwoKCQlpZiAoIVNoZWxsRXhlY3V0ZUV4KCZzaGV4aW5mbykpIHsKCQkJZGlzcGxheV9lcnJvcihod25kLCBHZXRMYXN0RXJyb3IoKSk7CgkJCXJldCA9IEZBTFNFOwoJCX0KCgkJaWYgKHNoZXhpbmZvLmxwSURMaXN0ICE9IGVudHJ5LT5waWRsKQoJCQlJTWFsbG9jX0ZyZWUoR2xvYmFscy5pTWFsbG9jLCBzaGV4aW5mby5scElETGlzdCk7CgoJCXJldHVybiByZXQ7Cgl9CiNlbmRpZgoKCWdldF9wYXRoKGVudHJ5LCBjbWQpOwoKCSAvKiBzdGFydCBwcm9ncmFtLCBvcGVuIGRvY3VtZW50Li4uICovCglyZXR1cm4gbGF1bmNoX2ZpbGUoaHduZCwgY21kLCBuQ21kU2hvdyk7Cn0KCgpzdGF0aWMgdm9pZCBhY3RpdmF0ZV9lbnRyeShDaGlsZFduZCogY2hpbGQsIFBhbmUqIHBhbmUsIEhXTkQgaHduZCkKewoJRW50cnkqIGVudHJ5ID0gcGFuZS0+Y3VyOwoKCWlmICghZW50cnkpCgkJcmV0dXJuOwoKCWlmIChlbnRyeS0+ZGF0YS5kd0ZpbGVBdHRyaWJ1dGVzICYgRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZKSB7CgkJaW50IHNjYW5uZWRfb2xkID0gZW50cnktPnNjYW5uZWQ7CgoJCWlmICghc2Nhbm5lZF9vbGQpCgkJewoJCQlpbnQgaWR4ID0gU2VuZE1lc3NhZ2UoY2hpbGQtPmxlZnQuaHduZCwgTEJfR0VUQ1VSU0VMLCAwLCAwKTsKCQkJc2Nhbl9lbnRyeShjaGlsZCwgZW50cnksIGlkeCwgaHduZCk7CgkJfQoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWlmIChlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMF09PScuJyAmJiBlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMV09PSdcMCcpCgkJCXJldHVybjsKI2VuZGlmCgoJCWlmIChlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMF09PScuJyAmJiBlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMV09PScuJyAmJiBlbnRyeS0+ZGF0YS5jRmlsZU5hbWVbMl09PSdcMCcpIHsKCQkJZW50cnkgPSBjaGlsZC0+bGVmdC5jdXItPnVwOwoJCQljb2xsYXBzZV9lbnRyeSgmY2hpbGQtPmxlZnQsIGVudHJ5KTsKCQkJZ290byBmb2N1c19lbnRyeTsKCQl9IGVsc2UgaWYgKGVudHJ5LT5leHBhbmRlZCkKCQkJY29sbGFwc2VfZW50cnkocGFuZSwgY2hpbGQtPmxlZnQuY3VyKTsKCQllbHNlIHsKCQkJZXhwYW5kX2VudHJ5KGNoaWxkLCBjaGlsZC0+bGVmdC5jdXIpOwoKCQkJaWYgKCFwYW5lLT50cmVlUGFuZSkgZm9jdXNfZW50cnk6IHsKCQkJCWludCBpZHhzdGFydCA9IFNlbmRNZXNzYWdlKGNoaWxkLT5sZWZ0Lmh3bmQsIExCX0dFVENVUlNFTCwgMCwgMCk7CgkJCQlpbnQgaWR4ID0gU2VuZE1lc3NhZ2UoY2hpbGQtPmxlZnQuaHduZCwgTEJfRklORFNUUklORywgaWR4c3RhcnQsIChMUEFSQU0pZW50cnkpOwoJCQkJU2VuZE1lc3NhZ2UoY2hpbGQtPmxlZnQuaHduZCwgTEJfU0VUQ1VSU0VMLCBpZHgsIDApOwoJCQkJc2V0X2N1cmRpcihjaGlsZCwgZW50cnksIGlkeCwgaHduZCk7CgkJCX0KCQl9CgoJCWlmICghc2Nhbm5lZF9vbGQpIHsKCQkJY2FsY193aWR0aHMocGFuZSwgRkFMU0UpOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCQlzZXRfaGVhZGVyKHBhbmUpOwojZW5kaWYKCQl9Cgl9IGVsc2UgewoJCWlmIChHZXRLZXlTdGF0ZShWS19NRU5VKSA8IDApCgkJCXNob3dfcHJvcGVydGllc19kbGcoZW50cnksIGNoaWxkLT5od25kKTsKCQllbHNlCgkJCWxhdW5jaF9lbnRyeShlbnRyeSwgY2hpbGQtPmh3bmQsIFNXX1NIT1dOT1JNQUwpOwoJfQp9CgoKc3RhdGljIEJPT0wgcGFuZV9jb21tYW5kKFBhbmUqIHBhbmUsIFVJTlQgY21kKQp7Cglzd2l0Y2goY21kKSB7CgkJY2FzZSBJRF9WSUVXX05BTUU6CgkJCWlmIChwYW5lLT52aXNpYmxlX2NvbHMpIHsKCQkJCXBhbmUtPnZpc2libGVfY29scyA9IDA7CgkJCQljYWxjX3dpZHRocyhwYW5lLCBUUlVFKTsKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCQkJc2V0X2hlYWRlcihwYW5lKTsKI2VuZGlmCgkJCQlJbnZhbGlkYXRlUmVjdChwYW5lLT5od25kLCAwLCBUUlVFKTsKCQkJCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfTkFNRSwgTUZfQllDT01NQU5EfE1GX0NIRUNLRUQpOwoJCQkJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19BTExfQVRUUklCVVRFUywgTUZfQllDT01NQU5EKTsKCQkJCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfU0VMRUNURURfQVRUUklCVVRFUywgTUZfQllDT01NQU5EKTsKCQkJfQoJCQlicmVhazsKCgkJY2FzZSBJRF9WSUVXX0FMTF9BVFRSSUJVVEVTOgoJCQlpZiAocGFuZS0+dmlzaWJsZV9jb2xzICE9IENPTF9BTEwpIHsKCQkJCXBhbmUtPnZpc2libGVfY29scyA9IENPTF9BTEw7CgkJCQljYWxjX3dpZHRocyhwYW5lLCBUUlVFKTsKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCQkJc2V0X2hlYWRlcihwYW5lKTsKI2VuZGlmCgkJCQlJbnZhbGlkYXRlUmVjdChwYW5lLT5od25kLCAwLCBUUlVFKTsKCQkJCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfTkFNRSwgTUZfQllDT01NQU5EKTsKCQkJCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfQUxMX0FUVFJJQlVURVMsIE1GX0JZQ09NTUFORHxNRl9DSEVDS0VEKTsKCQkJCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfU0VMRUNURURfQVRUUklCVVRFUywgTUZfQllDT01NQU5EKTsKCQkJfQoJCQlicmVhazsKCiNpZm5kZWYgX05PX0VYVEVOU0lPTlMKCQljYXNlIElEX1BSRUZFUlJFRF9TSVpFUzogewoJCQljYWxjX3dpZHRocyhwYW5lLCBUUlVFKTsKCQkJc2V0X2hlYWRlcihwYW5lKTsKCQkJSW52YWxpZGF0ZVJlY3QocGFuZS0+aHduZCwgMCwgVFJVRSk7CgkJCWJyZWFrO30KI2VuZGlmCgoJCSAgICAgICAgLyogVE9ETzogbW9yZSBjb21tYW5kIGlkcy4uLiAqLwoKCQlkZWZhdWx0OgoJCQlyZXR1cm4gRkFMU0U7Cgl9CgoJcmV0dXJuIFRSVUU7Cn0KCgpzdGF0aWMgdm9pZCBzZXRfc29ydF9vcmRlcihDaGlsZFduZCogY2hpbGQsIFNPUlRfT1JERVIgc29ydE9yZGVyKQp7CglpZiAoY2hpbGQtPnNvcnRPcmRlciAhPSBzb3J0T3JkZXIpIHsKCQljaGlsZC0+c29ydE9yZGVyID0gc29ydE9yZGVyOwoJCXJlZnJlc2hfY2hpbGQoY2hpbGQpOwoJfQp9CgpzdGF0aWMgdm9pZCB1cGRhdGVfdmlld19tZW51KENoaWxkV25kKiBjaGlsZCkKewoJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51VmlldywgSURfVklFV19TT1JUX05BTUUsIGNoaWxkLT5zb3J0T3JkZXI9PVNPUlRfTkFNRT8gTUZfQ0hFQ0tFRDogTUZfVU5DSEVDS0VEKTsKCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfU09SVF9UWVBFLCBjaGlsZC0+c29ydE9yZGVyPT1TT1JUX0VYVD8gTUZfQ0hFQ0tFRDogTUZfVU5DSEVDS0VEKTsKCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudVZpZXcsIElEX1ZJRVdfU09SVF9TSVpFLCBjaGlsZC0+c29ydE9yZGVyPT1TT1JUX1NJWkU/IE1GX0NIRUNLRUQ6IE1GX1VOQ0hFQ0tFRCk7CglDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVWaWV3LCBJRF9WSUVXX1NPUlRfREFURSwgY2hpbGQtPnNvcnRPcmRlcj09U09SVF9EQVRFPyBNRl9DSEVDS0VEOiBNRl9VTkNIRUNLRUQpOwp9CgoKc3RhdGljIEJPT0wgaXNfZGlyZWN0b3J5KExQQ1RTVFIgdGFyZ2V0KQp7CgkvKlRPRE8gY29ycmVjdGx5IGhhbmRsZSBVTklYIHBhdGhzICovCglEV09SRCB0YXJnZXRfYXR0ciA9IEdldEZpbGVBdHRyaWJ1dGVzKHRhcmdldCk7CgoJaWYgKHRhcmdldF9hdHRyID09IElOVkFMSURfRklMRV9BVFRSSUJVVEVTKQoJCXJldHVybiBGQUxTRTsKCglyZXR1cm4gdGFyZ2V0X2F0dHImRklMRV9BVFRSSUJVVEVfRElSRUNUT1JZPyBUUlVFOiBGQUxTRTsKfQoJCnN0YXRpYyBCT09MIHByb21wdF90YXJnZXQoUGFuZSogcGFuZSwgTFBUU1RSIHNvdXJjZSwgTFBUU1RSIHRhcmdldCkKewoJVENIQVIgcGF0aFtNQVhfUEFUSF07CglpbnQgbGVuOwoKCWdldF9wYXRoKHBhbmUtPmN1ciwgcGF0aCk7CgoJaWYgKERpYWxvZ0JveFBhcmFtKEdsb2JhbHMuaEluc3RhbmNlLCBNQUtFSU5UUkVTT1VSQ0UoSUREX1NFTEVDVF9ERVNUSU5BVElPTiksIHBhbmUtPmh3bmQsIERlc3RpbmF0aW9uRGxnUHJvYywgKExQQVJBTSlwYXRoKSAhPSBJRE9LKQoJCXJldHVybiBGQUxTRTsKCglnZXRfcGF0aChwYW5lLT5jdXIsIHNvdXJjZSk7CgoJLyogY29udmVydCByZWxhdGl2ZSB0YXJnZXRzIHRvIGFic29sdXRlIHBhdGhzICovCglpZiAocGF0aFswXSE9Jy8nICYmIHBhdGhbMV0hPSc6JykgewoJCWdldF9wYXRoKHBhbmUtPmN1ci0+dXAsIHRhcmdldCk7CgkJbGVuID0gbHN0cmxlbih0YXJnZXQpOwoKCQlpZiAodGFyZ2V0W2xlbi0xXSE9J1xcJyAmJiB0YXJnZXRbbGVuLTFdIT0nLycpCgkJCXRhcmdldFtsZW4rK10gPSAnLyc7CgoJCWxzdHJjcHkodGFyZ2V0K2xlbiwgcGF0aCk7Cgl9IGVsc2UKCQlsc3RyY3B5KHRhcmdldCwgcGF0aCk7CgoJLyogSWYgdGhlIHRhcmdldCBhbHJlYWR5IGV4aXN0cyBhcyBkaXJlY3RvcnksIGNyZWF0ZSBhIG5ldyB0YXJnZXQgYmVsb3cgdGhpcy4gKi8KCWlmIChpc19kaXJlY3RvcnkocGF0aCkpIHsKCQlUQ0hBUiBmbmFtZVtfTUFYX0ZOQU1FXSwgZXh0W19NQVhfRVhUXTsKCQlzdGF0aWMgY29uc3QgVENIQVIgc0FwcGVuZFtdID0geyclJywncycsJy8nLCclJywncycsJyUnLCdzJywnXDAnfTsKCgkJX3RzcGxpdHBhdGgoc291cmNlLCBOVUxMLCBOVUxMLCBmbmFtZSwgZXh0KTsKCgkJd3NwcmludGYodGFyZ2V0LCBzQXBwZW5kLCBwYXRoLCBmbmFtZSwgZXh0KTsKCX0KCglyZXR1cm4gVFJVRTsKfQoKCnN0YXRpYyBJQ29udGV4dE1lbnUyKiBzX3BjdHhtZW51MiA9IE5VTEw7CnN0YXRpYyBJQ29udGV4dE1lbnUzKiBzX3BjdHhtZW51MyA9IE5VTEw7CgpzdGF0aWMgdm9pZCBDdHhNZW51X3Jlc2V0KHZvaWQpCnsKCXNfcGN0eG1lbnUyID0gTlVMTDsKCXNfcGN0eG1lbnUzID0gTlVMTDsKfQoKc3RhdGljIElDb250ZXh0TWVudSogQ3R4TWVudV9xdWVyeV9pbnRlcmZhY2VzKElDb250ZXh0TWVudSogcGNtMSkKewoJSUNvbnRleHRNZW51KiBwY20gPSBOVUxMOwoKCUN0eE1lbnVfcmVzZXQoKTsKCglpZiAoSUNvbnRleHRNZW51X1F1ZXJ5SW50ZXJmYWNlKHBjbTEsICZJSURfSUNvbnRleHRNZW51MywgKHZvaWQqKikmcGNtKSA9PSBOT0VSUk9SKQoJCXNfcGN0eG1lbnUzID0gKExQQ09OVEVYVE1FTlUzKXBjbTsKCWVsc2UgaWYgKElDb250ZXh0TWVudV9RdWVyeUludGVyZmFjZShwY20xLCAmSUlEX0lDb250ZXh0TWVudTIsICh2b2lkKiopJnBjbSkgPT0gTk9FUlJPUikKCQlzX3BjdHhtZW51MiA9IChMUENPTlRFWFRNRU5VMilwY207CgoJaWYgKHBjbSkgewoJCUlDb250ZXh0TWVudV9SZWxlYXNlKHBjbTEpOwoJCXJldHVybiBwY207Cgl9IGVsc2UKCQlyZXR1cm4gcGNtMTsKfQoKc3RhdGljIEJPT0wgQ3R4TWVudV9IYW5kbGVNZW51TXNnKFVJTlQgbm1zZywgV1BBUkFNIHdwYXJhbSwgTFBBUkFNIGxwYXJhbSkKewoJaWYgKHNfcGN0eG1lbnUzKSB7CgkJaWYgKFNVQ0NFRURFRChJQ29udGV4dE1lbnUzX0hhbmRsZU1lbnVNc2coc19wY3R4bWVudTMsIG5tc2csIHdwYXJhbSwgbHBhcmFtKSkpCgkJCXJldHVybiBUUlVFOwoJfQoKCWlmIChzX3BjdHhtZW51MikKCQlpZiAoU1VDQ0VFREVEKElDb250ZXh0TWVudTJfSGFuZGxlTWVudU1zZyhzX3BjdHhtZW51Miwgbm1zZywgd3BhcmFtLCBscGFyYW0pKSkKCQkJcmV0dXJuIFRSVUU7CgoJcmV0dXJuIEZBTFNFOwp9CgoKc3RhdGljIEhSRVNVTFQgU2hlbGxGb2xkZXJDb250ZXh0TWVudShJU2hlbGxGb2xkZXIqIHNoZWxsX2ZvbGRlciwgSFdORCBod25kUGFyZW50LCBpbnQgY2lkbCwgTFBDSVRFTUlETElTVCogYXBpZGwsIGludCB4LCBpbnQgeSkKewoJSUNvbnRleHRNZW51KiBwY207CglCT09MIGV4ZWN1dGVkID0gRkFMU0U7CgoJSFJFU1VMVCBociA9IElTaGVsbEZvbGRlcl9HZXRVSU9iamVjdE9mKHNoZWxsX2ZvbGRlciwgaHduZFBhcmVudCwgY2lkbCwgYXBpZGwsICZJSURfSUNvbnRleHRNZW51LCBOVUxMLCAoTFBWT0lEKikmcGNtKTsKLyoJSFJFU1VMVCBociA9IENEZWZGb2xkZXJNZW51X0NyZWF0ZTIoZGlyP2Rpci0+X3BpZGw6RGVza3RvcEZvbGRlcigpLCBod25kUGFyZW50LCAxLCAmcGlkbCwgc2hlbGxfZm9sZGVyLCBOVUxMLCAwLCBOVUxMLCAmcGNtKTsgKi8KCglpZiAoU1VDQ0VFREVEKGhyKSkgewoJCUhNRU5VIGhtZW51ID0gQ3JlYXRlUG9wdXBNZW51KCk7CgoJCXBjbSA9IEN0eE1lbnVfcXVlcnlfaW50ZXJmYWNlcyhwY20pOwoKCQlpZiAoaG1lbnUpIHsKCQkJaHIgPSBJQ29udGV4dE1lbnVfUXVlcnlDb250ZXh0TWVudShwY20sIGhtZW51LCAwLCBGQ0lETV9TSFZJRVdGSVJTVCwgRkNJRE1fU0hWSUVXTEFTVCwgQ01GX05PUk1BTCk7CgoJCQlpZiAoU1VDQ0VFREVEKGhyKSkgewoJCQkJVUlOVCBpZENtZCA9IFRyYWNrUG9wdXBNZW51KGhtZW51LCBUUE1fTEVGVEFMSUdOfFRQTV9SRVRVUk5DTUR8VFBNX1JJR0hUQlVUVE9OLCB4LCB5LCAwLCBod25kUGFyZW50LCBOVUxMKTsKCgkJCQlDdHhNZW51X3Jlc2V0KCk7CgoJCQkJaWYgKGlkQ21kKSB7CgkJCQkgIENNSU5WT0tFQ09NTUFORElORk8gY21pOwoKCQkJCSAgY21pLmNiU2l6ZSA9IHNpemVvZihDTUlOVk9LRUNPTU1BTkRJTkZPKTsKCQkJCSAgY21pLmZNYXNrID0gMDsKCQkJCSAgY21pLmh3bmQgPSBod25kUGFyZW50OwoJCQkJICBjbWkubHBWZXJiID0gKExQQ1NUUikoSU5UX1BUUikoaWRDbWQgLSBGQ0lETV9TSFZJRVdGSVJTVCk7CgkJCQkgIGNtaS5scFBhcmFtZXRlcnMgPSBOVUxMOwoJCQkJICBjbWkubHBEaXJlY3RvcnkgPSBOVUxMOwoJCQkJICBjbWkublNob3cgPSBTV19TSE9XTk9STUFMOwoJCQkJICBjbWkuZHdIb3RLZXkgPSAwOwoJCQkJICBjbWkuaEljb24gPSAwOwoKCQkJCSAgaHIgPSBJQ29udGV4dE1lbnVfSW52b2tlQ29tbWFuZChwY20sICZjbWkpOwoJCQkJCWV4ZWN1dGVkID0gVFJVRTsKCQkJCX0KCQkJfSBlbHNlCgkJCQlDdHhNZW51X3Jlc2V0KCk7CgkJfQoKCQlJQ29udGV4dE1lbnVfUmVsZWFzZShwY20pOwoJfQoKCXJldHVybiBGQUlMRUQoaHIpPyBocjogZXhlY3V0ZWQ/IFNfT0s6IFNfRkFMU0U7Cn0KCgpzdGF0aWMgTFJFU1VMVCBDQUxMQkFDSyBDaGlsZFduZFByb2MoSFdORCBod25kLCBVSU5UIG5tc2csIFdQQVJBTSB3cGFyYW0sIExQQVJBTSBscGFyYW0pCnsKCUNoaWxkV25kKiBjaGlsZCA9IChDaGlsZFduZCopIEdldFdpbmRvd0xvbmdQdHIoaHduZCwgR1dMUF9VU0VSREFUQSk7CglBU1NFUlQoY2hpbGQpOwoKCXN3aXRjaChubXNnKSB7CgkJY2FzZSBXTV9EUkFXSVRFTTogewoJCQlMUERSQVdJVEVNU1RSVUNUIGRpcyA9IChMUERSQVdJVEVNU1RSVUNUKWxwYXJhbTsKCQkJRW50cnkqIGVudHJ5ID0gKEVudHJ5KikgZGlzLT5pdGVtRGF0YTsKCgkJCWlmIChkaXMtPkN0bElEID09IElEV19UUkVFX0xFRlQpCgkJCQlkcmF3X2l0ZW0oJmNoaWxkLT5sZWZ0LCBkaXMsIGVudHJ5LCAtMSk7CgkJCWVsc2UgaWYgKGRpcy0+Q3RsSUQgPT0gSURXX1RSRUVfUklHSFQpCgkJCQlkcmF3X2l0ZW0oJmNoaWxkLT5yaWdodCwgZGlzLCBlbnRyeSwgLTEpOwoJCQllbHNlCgkJCQlnb3RvIGRyYXdfbWVudV9pdGVtOwoKCQkJcmV0dXJuIFRSVUU7fQoKCQljYXNlIFdNX0NSRUFURToKCQkJSW5pdENoaWxkV2luZG93KGNoaWxkKTsKCQkJYnJlYWs7CgoJCWNhc2UgV01fTkNERVNUUk9ZOgoJCQlmcmVlX2NoaWxkX3dpbmRvdyhjaGlsZCk7CgkJCVNldFdpbmRvd0xvbmdQdHIoaHduZCwgR1dMUF9VU0VSREFUQSwgMCk7CgkJCWJyZWFrOwoKCQljYXNlIFdNX1BBSU5UOiB7CgkJCVBBSU5UU1RSVUNUIHBzOwoJCQlIQlJVU0ggbGFzdEJydXNoOwoJCQlSRUNUIHJ0OwoJCQlHZXRDbGllbnRSZWN0KGh3bmQsICZydCk7CgkJCUJlZ2luUGFpbnQoaHduZCwgJnBzKTsKCQkJcnQubGVmdCA9IGNoaWxkLT5zcGxpdF9wb3MtU1BMSVRfV0lEVEgvMjsKCQkJcnQucmlnaHQgPSBjaGlsZC0+c3BsaXRfcG9zK1NQTElUX1dJRFRILzIrMTsKCQkJbGFzdEJydXNoID0gU2VsZWN0T2JqZWN0KHBzLmhkYywgR2V0U3RvY2tPYmplY3QoQ09MT1JfU1BMSVRCQVIpKTsKCQkJUmVjdGFuZ2xlKHBzLmhkYywgcnQubGVmdCwgcnQudG9wLTEsIHJ0LnJpZ2h0LCBydC5ib3R0b20rMSk7CgkJCVNlbGVjdE9iamVjdChwcy5oZGMsIGxhc3RCcnVzaCk7CiNpZmRlZiBfTk9fRVhURU5TSU9OUwoJCQlydC50b3AgPSBydC5ib3R0b20gLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZSFNDUk9MTCk7CgkJCUZpbGxSZWN0KHBzLmhkYywgJnJ0LCBHZXRTdG9ja09iamVjdChCTEFDS19CUlVTSCkpOwojZW5kaWYKCQkJRW5kUGFpbnQoaHduZCwgJnBzKTsKCQkJYnJlYWs7fQoKCQljYXNlIFdNX1NFVENVUlNPUjoKCQkJaWYgKExPV09SRChscGFyYW0pID09IEhUQ0xJRU5UKSB7CgkJCQlQT0lOVCBwdDsKCQkJCUdldEN1cnNvclBvcygmcHQpOwoJCQkJU2NyZWVuVG9DbGllbnQoaHduZCwgJnB0KTsKCgkJCQlpZiAocHQueD49Y2hpbGQtPnNwbGl0X3Bvcy1TUExJVF9XSURUSC8yICYmIHB0Lng8Y2hpbGQtPnNwbGl0X3BvcytTUExJVF9XSURUSC8yKzEpIHsKCQkJCQlTZXRDdXJzb3IoTG9hZEN1cnNvcigwLCBJRENfU0laRVdFKSk7CgkJCQkJcmV0dXJuIFRSVUU7CgkJCQl9CgkJCX0KCQkJZ290byBkZWY7CgoJCWNhc2UgV01fTEJVVFRPTkRPV046IHsKCQkJUkVDVCBydDsKICAgICAgICAgICAgICAgICAgICAgICAgaW50IHggPSAoc2hvcnQpTE9XT1JEKGxwYXJhbSk7CgoJCQlHZXRDbGllbnRSZWN0KGh3bmQsICZydCk7CgoJCQlpZiAoeD49Y2hpbGQtPnNwbGl0X3Bvcy1TUExJVF9XSURUSC8yICYmIHg8Y2hpbGQtPnNwbGl0X3BvcytTUExJVF9XSURUSC8yKzEpIHsKCQkJCWxhc3Rfc3BsaXQgPSBjaGlsZC0+c3BsaXRfcG9zOwojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJCWRyYXdfc3BsaXRiYXIoaHduZCwgbGFzdF9zcGxpdCk7CiNlbmRpZgoJCQkJU2V0Q2FwdHVyZShod25kKTsKCQkJfQoKCQkJYnJlYWs7fQoKCQljYXNlIFdNX0xCVVRUT05VUDoKCQkJaWYgKEdldENhcHR1cmUoKSA9PSBod25kKSB7CiNpZmRlZiBfTk9fRVhURU5TSU9OUwoJCQkJUkVDVCBydDsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgeCA9IChzaG9ydClMT1dPUkQobHBhcmFtKTsKCQkJCWRyYXdfc3BsaXRiYXIoaHduZCwgbGFzdF9zcGxpdCk7CgkJCQlsYXN0X3NwbGl0ID0gLTE7CgkJCQlHZXRDbGllbnRSZWN0KGh3bmQsICZydCk7CgkJCQljaGlsZC0+c3BsaXRfcG9zID0geDsKCQkJCXJlc2l6ZV90cmVlKGNoaWxkLCBydC5yaWdodCwgcnQuYm90dG9tKTsKI2VuZGlmCgkJCQlSZWxlYXNlQ2FwdHVyZSgpOwoJCQl9CgkJCWJyZWFrOwoKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJY2FzZSBXTV9DQVBUVVJFQ0hBTkdFRDoKCQkJaWYgKEdldENhcHR1cmUoKT09aHduZCAmJiBsYXN0X3NwbGl0Pj0wKQoJCQkJZHJhd19zcGxpdGJhcihod25kLCBsYXN0X3NwbGl0KTsKCQkJYnJlYWs7CiNlbmRpZgoKCQljYXNlIFdNX0tFWURPV046CgkJCWlmICh3cGFyYW0gPT0gVktfRVNDQVBFKQoJCQkJaWYgKEdldENhcHR1cmUoKSA9PSBod25kKSB7CgkJCQkJUkVDVCBydDsKI2lmZGVmIF9OT19FWFRFTlNJT05TCgkJCQkJZHJhd19zcGxpdGJhcihod25kLCBsYXN0X3NwbGl0KTsKI2Vsc2UKCQkJCQljaGlsZC0+c3BsaXRfcG9zID0gbGFzdF9zcGxpdDsKI2VuZGlmCgkJCQkJR2V0Q2xpZW50UmVjdChod25kLCAmcnQpOwoJCQkJCXJlc2l6ZV90cmVlKGNoaWxkLCBydC5yaWdodCwgcnQuYm90dG9tKTsKCQkJCQlsYXN0X3NwbGl0ID0gLTE7CgkJCQkJUmVsZWFzZUNhcHR1cmUoKTsKCQkJCQlTZXRDdXJzb3IoTG9hZEN1cnNvcigwLCBJRENfQVJST1cpKTsKCQkJCX0KCQkJYnJlYWs7CgoJCWNhc2UgV01fTU9VU0VNT1ZFOgoJCQlpZiAoR2V0Q2FwdHVyZSgpID09IGh3bmQpIHsKCQkJCVJFQ1QgcnQ7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50IHggPSAoc2hvcnQpTE9XT1JEKGxwYXJhbSk7CgojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJCUhEQyBoZGMgPSBHZXREQyhod25kKTsKCQkJCUdldENsaWVudFJlY3QoaHduZCwgJnJ0KTsKCgkJCQlydC5sZWZ0ID0gbGFzdF9zcGxpdC1TUExJVF9XSURUSC8yOwoJCQkJcnQucmlnaHQgPSBsYXN0X3NwbGl0K1NQTElUX1dJRFRILzIrMTsKCQkJCUludmVydFJlY3QoaGRjLCAmcnQpOwoKCQkJCWxhc3Rfc3BsaXQgPSB4OwoJCQkJcnQubGVmdCA9IHgtU1BMSVRfV0lEVEgvMjsKCQkJCXJ0LnJpZ2h0ID0geCtTUExJVF9XSURUSC8yKzE7CgkJCQlJbnZlcnRSZWN0KGhkYywgJnJ0KTsKCgkJCQlSZWxlYXNlREMoaHduZCwgaGRjKTsKI2Vsc2UKCQkJCUdldENsaWVudFJlY3QoaHduZCwgJnJ0KTsKCgkJCQlpZiAoeD49MCAmJiB4PHJ0LnJpZ2h0KSB7CgkJCQkJY2hpbGQtPnNwbGl0X3BvcyA9IHg7CgkJCQkJcmVzaXplX3RyZWUoY2hpbGQsIHJ0LnJpZ2h0LCBydC5ib3R0b20pOwoJCQkJCXJ0LmxlZnQgPSB4LVNQTElUX1dJRFRILzI7CgkJCQkJcnQucmlnaHQgPSB4K1NQTElUX1dJRFRILzIrMTsKCQkJCQlJbnZhbGlkYXRlUmVjdChod25kLCAmcnQsIEZBTFNFKTsKCQkJCQlVcGRhdGVXaW5kb3coY2hpbGQtPmxlZnQuaHduZCk7CgkJCQkJVXBkYXRlV2luZG93KGh3bmQpOwoJCQkJCVVwZGF0ZVdpbmRvdyhjaGlsZC0+cmlnaHQuaHduZCk7CgkJCQl9CiNlbmRpZgoJCQl9CgkJCWJyZWFrOwoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgV01fR0VUTUlOTUFYSU5GTzoKCQkJRGVmTURJQ2hpbGRQcm9jKGh3bmQsIG5tc2csIHdwYXJhbSwgbHBhcmFtKTsKCgkJCXtMUE1JTk1BWElORk8gbHBtbWkgPSAoTFBNSU5NQVhJTkZPKWxwYXJhbTsKCgkJCWxwbW1pLT5wdE1heFRyYWNrU2l6ZS54IDw8PSAxOy8qMipHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOKSAvIFNNX0NYVklSVFVBTFNDUkVFTiAqLwoJCQlscG1taS0+cHRNYXhUcmFja1NpemUueSA8PD0gMTsvKjIqR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNDUkVFTikgLyBTTV9DWVZJUlRVQUxTQ1JFRU4gKi8KCQkJYnJlYWs7fQojZW5kaWYgLyogX05PX0VYVEVOU0lPTlMgKi8KCgkJY2FzZSBXTV9TRVRGT0NVUzoKCQkJaWYgKFNldEN1cnJlbnREaXJlY3RvcnkoY2hpbGQtPnBhdGgpKQoJCQkJc2V0X3NwYWNlX3N0YXR1cygpOwoJCQlTZXRGb2N1cyhjaGlsZC0+Zm9jdXNfcGFuZT8gY2hpbGQtPnJpZ2h0Lmh3bmQ6IGNoaWxkLT5sZWZ0Lmh3bmQpOwoJCQlicmVhazsKCgkJY2FzZSBXTV9ESVNQQVRDSF9DT01NQU5EOiB7CgkJCVBhbmUqIHBhbmUgPSBHZXRGb2N1cygpPT1jaGlsZC0+bGVmdC5od25kPyAmY2hpbGQtPmxlZnQ6ICZjaGlsZC0+cmlnaHQ7CgoJCQlzd2l0Y2goTE9XT1JEKHdwYXJhbSkpIHsKCQkJCWNhc2UgSURfV0lORE9XX05FVzogewoJCQkJCUNoaWxkV25kKiBuZXdfY2hpbGQgPSBhbGxvY19jaGlsZF93aW5kb3coY2hpbGQtPnBhdGgsIE5VTEwsIGh3bmQpOwoKCQkJCQlpZiAoIWNyZWF0ZV9jaGlsZF93aW5kb3cobmV3X2NoaWxkKSkKCQkJCQkJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbmV3X2NoaWxkKTsKCgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgSURfUkVGUkVTSDoKCQkJCQlyZWZyZXNoX2RyaXZlcygpOwoJCQkJCXJlZnJlc2hfY2hpbGQoY2hpbGQpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfQUNUSVZBVEU6CgkJCQkJYWN0aXZhdGVfZW50cnkoY2hpbGQsIHBhbmUsIGh3bmQpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfRklMRV9NT1ZFOiB7CgkJCQkJVENIQVIgc291cmNlW0JVRkZFUl9MRU5dLCB0YXJnZXRbQlVGRkVSX0xFTl07CgoJCQkJCWlmIChwcm9tcHRfdGFyZ2V0KHBhbmUsIHNvdXJjZSwgdGFyZ2V0KSkgewoJCQkJCQlTSEZJTEVPUFNUUlVDVCBzaGZvID0ge2h3bmQsIEZPX01PVkUsIHNvdXJjZSwgdGFyZ2V0fTsKCgkJCQkJCXNvdXJjZVtsc3RybGVuKHNvdXJjZSkrMV0gPSAnXDAnOwoJCQkJCQl0YXJnZXRbbHN0cmxlbih0YXJnZXQpKzFdID0gJ1wwJzsKCgkJCQkJCWlmICghU0hGaWxlT3BlcmF0aW9uKCZzaGZvKSkKCQkJCQkJCXJlZnJlc2hfY2hpbGQoY2hpbGQpOwoJCQkJCX0KCQkJCQlicmVhazt9CgoJCQkJY2FzZSBJRF9GSUxFX0NPUFk6IHsKCQkJCQlUQ0hBUiBzb3VyY2VbQlVGRkVSX0xFTl0sIHRhcmdldFtCVUZGRVJfTEVOXTsKCgkJCQkJaWYgKHByb21wdF90YXJnZXQocGFuZSwgc291cmNlLCB0YXJnZXQpKSB7CgkJCQkJCVNIRklMRU9QU1RSVUNUIHNoZm8gPSB7aHduZCwgRk9fQ09QWSwgc291cmNlLCB0YXJnZXR9OwoKCQkJCQkJc291cmNlW2xzdHJsZW4oc291cmNlKSsxXSA9ICdcMCc7CgkJCQkJCXRhcmdldFtsc3RybGVuKHRhcmdldCkrMV0gPSAnXDAnOwoKCQkJCQkJaWYgKCFTSEZpbGVPcGVyYXRpb24oJnNoZm8pKQoJCQkJCQkJcmVmcmVzaF9jaGlsZChjaGlsZCk7CgkJCQkJfQoJCQkJCWJyZWFrO30KCgkJCQljYXNlIElEX0ZJTEVfREVMRVRFOiB7CgkJCQkJVENIQVIgcGF0aFtCVUZGRVJfTEVOXTsKCQkJCQlTSEZJTEVPUFNUUlVDVCBzaGZvID0ge2h3bmQsIEZPX0RFTEVURSwgcGF0aH07CgoJCQkJCWdldF9wYXRoKHBhbmUtPmN1ciwgcGF0aCk7CgoJCQkJCXBhdGhbbHN0cmxlbihwYXRoKSsxXSA9ICdcMCc7CgoJCQkJCWlmICghU0hGaWxlT3BlcmF0aW9uKCZzaGZvKSkKCQkJCQkJcmVmcmVzaF9jaGlsZChjaGlsZCk7CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgSURfVklFV19TT1JUX05BTUU6CgkJCQkJc2V0X3NvcnRfb3JkZXIoY2hpbGQsIFNPUlRfTkFNRSk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9WSUVXX1NPUlRfVFlQRToKCQkJCQlzZXRfc29ydF9vcmRlcihjaGlsZCwgU09SVF9FWFQpOwoJCQkJCWJyZWFrOwoKCQkJCWNhc2UgSURfVklFV19TT1JUX1NJWkU6CgkJCQkJc2V0X3NvcnRfb3JkZXIoY2hpbGQsIFNPUlRfU0laRSk7CgkJCQkJYnJlYWs7CgoJCQkJY2FzZSBJRF9WSUVXX1NPUlRfREFURToKCQkJCQlzZXRfc29ydF9vcmRlcihjaGlsZCwgU09SVF9EQVRFKTsKCQkJCQlicmVhazsKCgkJCQljYXNlIElEX1ZJRVdfRklMVEVSOiB7CgkJCQkJc3RydWN0IEZpbHRlckRpYWxvZyBkbGc7CgoJCQkJCW1lbXNldCgmZGxnLCAwLCBzaXplb2Yoc3RydWN0IEZpbHRlckRpYWxvZykpOwoJCQkJCWxzdHJjcHkoZGxnLnBhdHRlcm4sIGNoaWxkLT5maWx0ZXJfcGF0dGVybik7CgkJCQkJZGxnLmZsYWdzID0gY2hpbGQtPmZpbHRlcl9mbGFnczsKCgkJCQkJaWYgKERpYWxvZ0JveFBhcmFtKEdsb2JhbHMuaEluc3RhbmNlLCBNQUtFSU5UUkVTT1VSQ0UoSUREX0RJQUxPR19WSUVXX1RZUEUpLCBod25kLCBGaWx0ZXJEaWFsb2dEbGdQcm9jLCAoTFBBUkFNKSZkbGcpID09IElET0spIHsKCQkJCQkJbHN0cmNweShjaGlsZC0+ZmlsdGVyX3BhdHRlcm4sIGRsZy5wYXR0ZXJuKTsKCQkJCQkJY2hpbGQtPmZpbHRlcl9mbGFncyA9IGRsZy5mbGFnczsKCQkJCQkJcmVmcmVzaF9yaWdodF9wYW5lKGNoaWxkKTsKCQkJCQl9CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgSURfVklFV19TUExJVDogewoJCQkJCWxhc3Rfc3BsaXQgPSBjaGlsZC0+c3BsaXRfcG9zOwojaWZkZWYgX05PX0VYVEVOU0lPTlMKCQkJCQlkcmF3X3NwbGl0YmFyKGh3bmQsIGxhc3Rfc3BsaXQpOwojZW5kaWYKCQkJCQlTZXRDYXB0dXJlKGh3bmQpOwoJCQkJCWJyZWFrO30KCgkJCQljYXNlIElEX0VESVRfUFJPUEVSVElFUzoKCQkJCQlzaG93X3Byb3BlcnRpZXNfZGxnKHBhbmUtPmN1ciwgY2hpbGQtPmh3bmQpOwoJCQkJCWJyZWFrOwoKCQkJCWRlZmF1bHQ6CgkJCQkJcmV0dXJuIHBhbmVfY29tbWFuZChwYW5lLCBMT1dPUkQod3BhcmFtKSk7CgkJCX0KCgkJCXJldHVybiBUUlVFO30KCgkJY2FzZSBXTV9DT01NQU5EOiB7CgkJCVBhbmUqIHBhbmUgPSBHZXRGb2N1cygpPT1jaGlsZC0+bGVmdC5od25kPyAmY2hpbGQtPmxlZnQ6ICZjaGlsZC0+cmlnaHQ7CgoJCQlzd2l0Y2goSElXT1JEKHdwYXJhbSkpIHsKCQkJCWNhc2UgTEJOX1NFTENIQU5HRTogewoJCQkJCWludCBpZHggPSBTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9HRVRDVVJTRUwsIDAsIDApOwoJCQkJCUVudHJ5KiBlbnRyeSA9IChFbnRyeSopIFNlbmRNZXNzYWdlKHBhbmUtPmh3bmQsIExCX0dFVElURU1EQVRBLCBpZHgsIDApOwoKCQkJCQlpZiAocGFuZSA9PSAmY2hpbGQtPmxlZnQpCgkJCQkJCXNldF9jdXJkaXIoY2hpbGQsIGVudHJ5LCBpZHgsIGh3bmQpOwoJCQkJCWVsc2UKCQkJCQkJcGFuZS0+Y3VyID0gZW50cnk7CgkJCQkJYnJlYWs7fQoKCQkJCWNhc2UgTEJOX0RCTENMSzoKCQkJCQlhY3RpdmF0ZV9lbnRyeShjaGlsZCwgcGFuZSwgaHduZCk7CgkJCQkJYnJlYWs7CgkJCX0KCQkJYnJlYWs7fQoKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgV01fTk9USUZZOiB7CgkJCU5NSERSKiBwbm1oID0gKE5NSERSKikgbHBhcmFtOwoJCQlyZXR1cm4gcGFuZV9ub3RpZnkocG5taC0+aWRGcm9tPT1JRFdfSEVBREVSX0xFRlQ/ICZjaGlsZC0+bGVmdDogJmNoaWxkLT5yaWdodCwgcG5taCk7fQojZW5kaWYKCiNpZmRlZiBfU0hFTExfRk9MREVSUwoJCWNhc2UgV01fQ09OVEVYVE1FTlU6IHsKCQkJUE9JTlQgcHQsIHB0X2NsbnQ7CgkJCVBhbmUqIHBhbmU7CgkJCWludCBpZHg7CgoJCQkgLyogZmlyc3Qgc2VsZWN0IHRoZSBjdXJyZW50IGl0ZW0gaW4gdGhlIGxpc3Rib3ggKi8KCQkJSFdORCBocGFuZWwgPSAoSFdORCkgd3BhcmFtOwoJCQlwdF9jbG50LnggPSBwdC54ID0gKHNob3J0KUxPV09SRChscGFyYW0pOwoJCQlwdF9jbG50LnkgPSBwdC55ID0gKHNob3J0KUhJV09SRChscGFyYW0pOwoJCQlTY3JlZW5Ub0NsaWVudChocGFuZWwsICZwdF9jbG50KTsKCQkJU2VuZE1lc3NhZ2UoaHBhbmVsLCBXTV9MQlVUVE9ORE9XTiwgMCwgTUFLRUxPTkcocHRfY2xudC54LCBwdF9jbG50LnkpKTsKCQkJU2VuZE1lc3NhZ2UoaHBhbmVsLCBXTV9MQlVUVE9OVVAsIDAsIE1BS0VMT05HKHB0X2NsbnQueCwgcHRfY2xudC55KSk7CgoJCQkgLyogbm93IGNyZWF0ZSB0aGUgcG9wdXAgbWVudSB1c2luZyBzaGVsbCBuYW1lc3BhY2UgYW5kIElDb250ZXh0TWVudSAqLwoJCQlwYW5lID0gR2V0Rm9jdXMoKT09Y2hpbGQtPmxlZnQuaHduZD8gJmNoaWxkLT5sZWZ0OiAmY2hpbGQtPnJpZ2h0OwoJCQlpZHggPSBTZW5kTWVzc2FnZShwYW5lLT5od25kLCBMQl9HRVRDVVJTRUwsIDAsIDApOwoKCQkJaWYgKGlkeCAhPSAtMSkgewoJCQkJRW50cnkqIGVudHJ5ID0gKEVudHJ5KikgU2VuZE1lc3NhZ2UocGFuZS0+aHduZCwgTEJfR0VUSVRFTURBVEEsIGlkeCwgMCk7CgoJCQkJTFBJVEVNSURMSVNUIHBpZGxfYWJzID0gZ2V0X3RvX2Fic29sdXRlX3BpZGwoZW50cnksIGh3bmQpOwoKCQkJCWlmIChwaWRsX2FicykgewoJCQkJCUlTaGVsbEZvbGRlciogcGFyZW50Rm9sZGVyOwoJCQkJCUxQQ0lURU1JRExJU1QgcGlkbExhc3Q7CgoJCQkJCSAvKiBnZXQgYW5kIHVzZSB0aGUgcGFyZW50IGZvbGRlciB0byBkaXNwbGF5IGNvcnJlY3QgY29udGV4dCBtZW51IGluIGFsbCBjYXNlcyAqLwoJCQkJCWlmIChTVUNDRUVERUQoU0hCaW5kVG9QYXJlbnQocGlkbF9hYnMsICZJSURfSVNoZWxsRm9sZGVyLCAoTFBWT0lEKikmcGFyZW50Rm9sZGVyLCAmcGlkbExhc3QpKSkgewoJCQkJCQlpZiAoU2hlbGxGb2xkZXJDb250ZXh0TWVudShwYXJlbnRGb2xkZXIsIGh3bmQsIDEsICZwaWRsTGFzdCwgcHQueCwgcHQueSkgPT0gU19PSykKCQkJCQkJCXJlZnJlc2hfY2hpbGQoY2hpbGQpOwoKCQkJCQkJSVNoZWxsRm9sZGVyX1JlbGVhc2UocGFyZW50Rm9sZGVyKTsKCQkJCQl9CgoJCQkJCUlNYWxsb2NfRnJlZShHbG9iYWxzLmlNYWxsb2MsIHBpZGxfYWJzKTsKCQkJCX0KCQkJfQoJCQlicmVhazt9CiNlbmRpZgoKCQkgIGNhc2UgV01fTUVBU1VSRUlURU06CgkJICBkcmF3X21lbnVfaXRlbToKCQkJaWYgKCF3cGFyYW0pCS8qIElzIHRoZSBtZXNzYWdlIG1lbnUtcmVsYXRlZD8gKi8KCQkJCWlmIChDdHhNZW51X0hhbmRsZU1lbnVNc2cobm1zZywgd3BhcmFtLCBscGFyYW0pKQoJCQkJCXJldHVybiBUUlVFOwoKCQkJYnJlYWs7CgoJCSAgY2FzZSBXTV9JTklUTUVOVVBPUFVQOgoJCQlpZiAoQ3R4TWVudV9IYW5kbGVNZW51TXNnKG5tc2csIHdwYXJhbSwgbHBhcmFtKSkKCQkJCXJldHVybiAwOwoKCQkJdXBkYXRlX3ZpZXdfbWVudShjaGlsZCk7CgkJCWJyZWFrOwoKCQkgIGNhc2UgV01fTUVOVUNIQVI6CS8qIG9ubHkgc3VwcG9ydGVkIGJ5IElDb250ZXh0TWVudTMgKi8KCQkgICBpZiAoc19wY3R4bWVudTMpIHsKCQkJICAgTFJFU1VMVCBsUmVzdWx0ID0gMDsKCgkJCSAgIElDb250ZXh0TWVudTNfSGFuZGxlTWVudU1zZzIoc19wY3R4bWVudTMsIG5tc2csIHdwYXJhbSwgbHBhcmFtLCAmbFJlc3VsdCk7CgoJCQkgICByZXR1cm4gbFJlc3VsdDsKCQkgICB9CgoJCSAgIGJyZWFrOwoKCQljYXNlIFdNX1NJWkU6CgkJCWlmICh3cGFyYW0gIT0gU0laRV9NSU5JTUlaRUQpCgkJCQlyZXNpemVfdHJlZShjaGlsZCwgTE9XT1JEKGxwYXJhbSksIEhJV09SRChscGFyYW0pKTsKCQkJLyogZmFsbCB0aHJvdWdoICovCgoJCWRlZmF1bHQ6IGRlZjoKCQkJcmV0dXJuIERlZk1ESUNoaWxkUHJvYyhod25kLCBubXNnLCB3cGFyYW0sIGxwYXJhbSk7Cgl9CgoJcmV0dXJuIDA7Cn0KCgpzdGF0aWMgTFJFU1VMVCBDQUxMQkFDSyBUcmVlV25kUHJvYyhIV05EIGh3bmQsIFVJTlQgbm1zZywgV1BBUkFNIHdwYXJhbSwgTFBBUkFNIGxwYXJhbSkKewoJQ2hpbGRXbmQqIGNoaWxkID0gKENoaWxkV25kKikgR2V0V2luZG93TG9uZ1B0cihHZXRQYXJlbnQoaHduZCksIEdXTFBfVVNFUkRBVEEpOwoJUGFuZSogcGFuZSA9IChQYW5lKikgR2V0V2luZG93TG9uZ1B0cihod25kLCBHV0xQX1VTRVJEQVRBKTsKCUFTU0VSVChjaGlsZCk7CgoJc3dpdGNoKG5tc2cpIHsKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJCWNhc2UgV01fSFNDUk9MTDoKCQkJc2V0X2hlYWRlcihwYW5lKTsKCQkJYnJlYWs7CiNlbmRpZgoKCQljYXNlIFdNX1NFVEZPQ1VTOgoJCQljaGlsZC0+Zm9jdXNfcGFuZSA9IHBhbmU9PSZjaGlsZC0+cmlnaHQ/IDE6IDA7CgkJCVNlbmRNZXNzYWdlKGh3bmQsIExCX1NFVFNFTCwgVFJVRSwgMSk7CgkJCS8qVE9ETzogY2hlY2sgbWVudSBpdGVtcyAqLwoJCQlicmVhazsKCgkJY2FzZSBXTV9LRVlET1dOOgoJCQlpZiAod3BhcmFtID09IFZLX1RBQikgewoJCQkJLypUT0RPOiBTZXRGb2N1cyhHbG9iYWxzLmhkcml2ZWJhcikgKi8KCQkJCVNldEZvY3VzKGNoaWxkLT5mb2N1c19wYW5lPyBjaGlsZC0+bGVmdC5od25kOiBjaGlsZC0+cmlnaHQuaHduZCk7CgkJCX0KCX0KCglyZXR1cm4gQ2FsbFdpbmRvd1Byb2MoZ19vcmdUcmVlV25kUHJvYywgaHduZCwgbm1zZywgd3BhcmFtLCBscGFyYW0pOwp9CgoKc3RhdGljIHZvaWQgSW5pdEluc3RhbmNlKEhJTlNUQU5DRSBoaW5zdGFuY2UpCnsKCXN0YXRpYyBjb25zdCBUQ0hBUiBzRm9udFtdID0geydNJywnaScsJ2MnLCdyJywnbycsJ3MnLCdvJywnZicsJ3QnLCcgJywnUycsJ2EnLCduJywncycsJyAnLCdTJywnZScsJ3InLCdpJywnZicsJ1wwJ307CgoJV05EQ0xBU1NFWCB3Y0ZyYW1lOwoJV05EQ0xBU1Mgd2NDaGlsZDsKCUFUT00gaENoaWxkQ2xhc3M7CglpbnQgY29sOwoKCUlOSVRDT01NT05DT05UUk9MU0VYIGljYyA9IHsKCQlzaXplb2YoSU5JVENPTU1PTkNPTlRST0xTRVgpLAoJCUlDQ19CQVJfQ0xBU1NFUwoJfTsKCglIREMgaGRjID0gR2V0REMoMCk7CgoJc2V0bG9jYWxlKExDX0NPTExBVEUsICIiKTsJLyogc2V0IGNvbGxhdGluZyBydWxlcyB0byBsb2NhbCBzZXR0aW5ncyBmb3IgY29tcGFyZU5hbWUgKi8KCglJbml0Q29tbW9uQ29udHJvbHNFeCgmaWNjKTsKCgoJLyogcmVnaXN0ZXIgZnJhbWUgd2luZG93IGNsYXNzICovCgoJd2NGcmFtZS5jYlNpemUgICAgICAgID0gc2l6ZW9mKFdORENMQVNTRVgpOwoJd2NGcmFtZS5zdHlsZSAgICAgICAgID0gMDsKCXdjRnJhbWUubHBmblduZFByb2MgICA9IEZyYW1lV25kUHJvYzsKCXdjRnJhbWUuY2JDbHNFeHRyYSAgICA9IDA7Cgl3Y0ZyYW1lLmNiV25kRXh0cmEgICAgPSAwOwoJd2NGcmFtZS5oSW5zdGFuY2UgICAgID0gaGluc3RhbmNlOwoJd2NGcmFtZS5oSWNvbiAgICAgICAgID0gTG9hZEljb24oaGluc3RhbmNlLCBNQUtFSU5UUkVTT1VSQ0UoSURJX1dJTkVGSUxFKSk7Cgl3Y0ZyYW1lLmhDdXJzb3IgICAgICAgPSBMb2FkQ3Vyc29yKDAsIElEQ19BUlJPVyk7Cgl3Y0ZyYW1lLmhickJhY2tncm91bmQgPSAwOwoJd2NGcmFtZS5scHN6TWVudU5hbWUgID0gMDsKCXdjRnJhbWUubHBzekNsYXNzTmFtZSA9IHNXSU5FRklMRUZSQU1FOwoJd2NGcmFtZS5oSWNvblNtICAgICAgID0gKEhJQ09OKUxvYWRJbWFnZShoaW5zdGFuY2UsCgkJCQkJCQkJCQkJIE1BS0VJTlRSRVNPVVJDRShJRElfV0lORUZJTEUpLAoJCQkJCQkJCQkJCSBJTUFHRV9JQ09OLAoJCQkJCQkJCQkJCSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU01JQ09OKSwKCQkJCQkJCQkJCQkgR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNNSUNPTiksCgkJCQkJCQkJCQkJIExSX1NIQVJFRCk7CgoJR2xvYmFscy5oZnJhbWVDbGFzcyA9IFJlZ2lzdGVyQ2xhc3NFeCgmd2NGcmFtZSk7CgoKCS8qIHJlZ2lzdGVyIHRyZWUgd2luZG93cyBjbGFzcyAqLwoKCXdjQ2hpbGQuc3R5bGUgICAgICAgICA9IENTX0NMQVNTREN8Q1NfREJMQ0xLU3xDU19WUkVEUkFXOwoJd2NDaGlsZC5scGZuV25kUHJvYyAgID0gQ2hpbGRXbmRQcm9jOwoJd2NDaGlsZC5jYkNsc0V4dHJhICAgID0gMDsKCXdjQ2hpbGQuY2JXbmRFeHRyYSAgICA9IDA7Cgl3Y0NoaWxkLmhJbnN0YW5jZSAgICAgPSBoaW5zdGFuY2U7Cgl3Y0NoaWxkLmhJY29uICAgICAgICAgPSAwOwoJd2NDaGlsZC5oQ3Vyc29yICAgICAgID0gTG9hZEN1cnNvcigwLCBJRENfQVJST1cpOwoJd2NDaGlsZC5oYnJCYWNrZ3JvdW5kID0gMDsKCXdjQ2hpbGQubHBzek1lbnVOYW1lICA9IDA7Cgl3Y0NoaWxkLmxwc3pDbGFzc05hbWUgPSBzV0lORUZJTEVUUkVFOwoKCWhDaGlsZENsYXNzID0gUmVnaXN0ZXJDbGFzcygmd2NDaGlsZCk7CgoKCUdsb2JhbHMuaGFjY2VsID0gTG9hZEFjY2VsZXJhdG9ycyhoaW5zdGFuY2UsIE1BS0VJTlRSRVNPVVJDRShJREFfV0lORUZJTEUpKTsKCglHbG9iYWxzLmhmb250ID0gQ3JlYXRlRm9udCgtTXVsRGl2KDgsR2V0RGV2aWNlQ2FwcyhoZGMsTE9HUElYRUxTWSksNzIpLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCAwLCBzRm9udCk7CgoJUmVsZWFzZURDKDAsIGhkYyk7CgoJR2xvYmFscy5oSW5zdGFuY2UgPSBoaW5zdGFuY2U7CgojaWZkZWYgX1NIRUxMX0ZPTERFUlMKCUNvSW5pdGlhbGl6ZShOVUxMKTsKCUNvR2V0TWFsbG9jKE1FTUNUWF9UQVNLLCAmR2xvYmFscy5pTWFsbG9jKTsKCVNIR2V0RGVza3RvcEZvbGRlcigmR2xvYmFscy5pRGVza3RvcCk7CiNpZmRlZiBfX1dJTkVfXwoJR2xvYmFscy5jZlN0ckZOYW1lID0gUmVnaXN0ZXJDbGlwYm9hcmRGb3JtYXRBKENGU1RSX0ZJTEVOQU1FKTsKI2Vsc2UKCUdsb2JhbHMuY2ZTdHJGTmFtZSA9IFJlZ2lzdGVyQ2xpcGJvYXJkRm9ybWF0KENGU1RSX0ZJTEVOQU1FKTsKI2VuZGlmCiNlbmRpZgoKCS8qIGxvYWQgY29sdW1uIHN0cmluZ3MgKi8KCWNvbCA9IDE7CgoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX05BTUUpOwoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX1NJWkUpOwoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX0NEQVRFKTsKI2lmbmRlZiBfTk9fRVhURU5TSU9OUwoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX0FEQVRFKTsKCWxvYWRfc3RyaW5nKGdfcG9zX25hbWVzW2NvbCsrXSwgSURTX0NPTF9NREFURSk7Cglsb2FkX3N0cmluZyhnX3Bvc19uYW1lc1tjb2wrK10sIElEU19DT0xfSURYKTsKCWxvYWRfc3RyaW5nKGdfcG9zX25hbWVzW2NvbCsrXSwgSURTX0NPTF9MSU5LUyk7CiNlbmRpZgoJbG9hZF9zdHJpbmcoZ19wb3NfbmFtZXNbY29sKytdLCBJRFNfQ09MX0FUVFIpOwojaWZuZGVmIF9OT19FWFRFTlNJT05TCglsb2FkX3N0cmluZyhnX3Bvc19uYW1lc1tjb2wrK10sIElEU19DT0xfU0VDKTsKI2VuZGlmCn0KCgpzdGF0aWMgdm9pZCBzaG93X2ZyYW1lKEhXTkQgaHduZFBhcmVudCwgaW50IGNtZHNob3csIExQQ1RTVFIgcGF0aCkKewoJc3RhdGljIGNvbnN0IFRDSEFSIHNNRElDTElFTlRbXSA9IHsnTScsJ0QnLCdJJywnQycsJ0wnLCdJJywnRScsJ04nLCdUJywnXDAnfTsKCglUQ0hBUiBidWZmZXJbTUFYX1BBVEhdLCBiMVtCVUZGRVJfTEVOXTsKCUNoaWxkV25kKiBjaGlsZDsKCUhNRU5VIGhNZW51RnJhbWUsIGhNZW51V2luZG93OwoJd2luZG93T3B0aW9ucyBvcHRzOwoKCUNMSUVOVENSRUFURVNUUlVDVCBjY3M7CgoJaWYgKEdsb2JhbHMuaE1haW5XbmQpCgkJcmV0dXJuOwoKCW9wdHMgPSBsb2FkX3JlZ2lzdHJ5X3NldHRpbmdzKCk7CgloTWVudUZyYW1lID0gTG9hZE1lbnUoR2xvYmFscy5oSW5zdGFuY2UsIE1BS0VJTlRSRVNPVVJDRShJRE1fV0lORUZJTEUpKTsKCWhNZW51V2luZG93ID0gR2V0U3ViTWVudShoTWVudUZyYW1lLCBHZXRNZW51SXRlbUNvdW50KGhNZW51RnJhbWUpLTIpOwoKCUdsb2JhbHMuaE1lbnVGcmFtZSA9IGhNZW51RnJhbWU7CglHbG9iYWxzLmhNZW51VmlldyA9IEdldFN1Yk1lbnUoaE1lbnVGcmFtZSwgMyk7CglHbG9iYWxzLmhNZW51T3B0aW9ucyA9IEdldFN1Yk1lbnUoaE1lbnVGcmFtZSwgNCk7CgoJY2NzLmhXaW5kb3dNZW51ICA9IGhNZW51V2luZG93OwoJY2NzLmlkRmlyc3RDaGlsZCA9IElEV19GSVJTVF9DSElMRDsKCgoJLyogY3JlYXRlIG1haW4gd2luZG93ICovCglHbG9iYWxzLmhNYWluV25kID0gQ3JlYXRlV2luZG93RXgoMCwgKExQQ1RTVFIpKGludClHbG9iYWxzLmhmcmFtZUNsYXNzLCBSUyhiMSxJRFNfV0lORV9GSUxFKSwgV1NfT1ZFUkxBUFBFRFdJTkRPVywKCQkJCQlvcHRzLnN0YXJ0X3gsIG9wdHMuc3RhcnRfeSwgb3B0cy53aWR0aCwgb3B0cy5oZWlnaHQsCgkJCQkJaHduZFBhcmVudCwgR2xvYmFscy5oTWVudUZyYW1lLCBHbG9iYWxzLmhJbnN0YW5jZSwgMC8qbHBQYXJhbSovKTsKCgoJR2xvYmFscy5obWRpY2xpZW50ID0gQ3JlYXRlV2luZG93RXgoMCwgc01ESUNMSUVOVCwgTlVMTCwKCQkJCQlXU19DSElMRHxXU19DTElQQ0hJTERSRU58V1NfVlNDUk9MTHxXU19IU0NST0xMfFdTX1ZJU0lCTEV8V1NfQk9SREVSLAoJCQkJCTAsIDAsIDAsIDAsCgkJCQkJR2xvYmFscy5oTWFpblduZCwgMCwgR2xvYmFscy5oSW5zdGFuY2UsICZjY3MpOwogIAoJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51T3B0aW9ucywgSURfVklFV19EUklWRV9CQVIsIE1GX0JZQ09NTUFORHxNRl9DSEVDS0VEKTsKCUNoZWNrTWVudUl0ZW0oR2xvYmFscy5oTWVudU9wdGlvbnMsIElEX1ZJRVdfU0FWRVNFVFRJTkdTLCBNRl9CWUNPTU1BTkQpOwoKCWNyZWF0ZV9kcml2ZV9iYXIoKTsKCgl7CgkJVEJCVVRUT04gdG9vbGJhckJ0bnNbXSA9IHsKCQkJezAsIDAsIDAsIEJUTlNfU0VQLCB7MCwgMH0sIDAsIDB9LAoJCQl7MCwgSURfV0lORE9XX05FVywgVEJTVEFURV9FTkFCTEVELCBCVE5TX0JVVFRPTiwgezAsIDB9LCAwLCAwfSwKCQkJezEsIElEX1dJTkRPV19DQVNDQURFLCBUQlNUQVRFX0VOQUJMRUQsIEJUTlNfQlVUVE9OLCB7MCwgMH0sIDAsIDB9LAoJCQl7MiwgSURfV0lORE9XX1RJTEVfSE9SWiwgVEJTVEFURV9FTkFCTEVELCBCVE5TX0JVVFRPTiwgezAsIDB9LCAwLCAwfSwKCQkJezMsIElEX1dJTkRPV19USUxFX1ZFUlQsIFRCU1RBVEVfRU5BQkxFRCwgQlROU19CVVRUT04sIHswLCAwfSwgMCwgMH0sCi8qVE9ETwoJCQl7NCwgSURfLi4uICwgVEJTVEFURV9FTkFCTEVELCBCVE5TX0JVVFRPTiwgezAsIDB9LCAwLCAwfSwKCQkJezUsIElEXy4uLiAsIFRCU1RBVEVfRU5BQkxFRCwgQlROU19CVVRUT04sIHswLCAwfSwgMCwgMH0sCiovCQl9OwoKCQlHbG9iYWxzLmh0b29sYmFyID0gQ3JlYXRlVG9vbGJhckV4KEdsb2JhbHMuaE1haW5XbmQsIFdTX0NISUxEfFdTX1ZJU0lCTEUsCgkJCUlEV19UT09MQkFSLCAyLCBHbG9iYWxzLmhJbnN0YW5jZSwgSURCX1RPT0xCQVIsIHRvb2xiYXJCdG5zLAoJCQlzaXplb2YodG9vbGJhckJ0bnMpL3NpemVvZihUQkJVVFRPTiksIDE2LCAxNSwgMTYsIDE1LCBzaXplb2YoVEJCVVRUT04pKTsKCQlDaGVja01lbnVJdGVtKEdsb2JhbHMuaE1lbnVPcHRpb25zLCBJRF9WSUVXX1RPT0xfQkFSLCBNRl9CWUNPTU1BTkR8TUZfQ0hFQ0tFRCk7Cgl9CgoJR2xvYmFscy5oc3RhdHVzYmFyID0gQ3JlYXRlU3RhdHVzV2luZG93KFdTX0NISUxEfFdTX1ZJU0lCTEUsIDAsIEdsb2JhbHMuaE1haW5XbmQsIElEV19TVEFUVVNCQVIpOwoJQ2hlY2tNZW51SXRlbShHbG9iYWxzLmhNZW51T3B0aW9ucywgSURfVklFV19TVEFUVVNCQVIsIE1GX0JZQ09NTUFORHxNRl9DSEVDS0VEKTsKCi8qIENyZWF0ZVN0YXR1c1dpbmRvdyBkb2VzIG5vdCBhY2NlcHQgV1NfQk9SREVSCglHbG9iYWxzLmhzdGF0dXNiYXIgPSBDcmVhdGVXaW5kb3dFeChXU19FWF9OT1BBUkVOVE5PVElGWSwgU1RBVFVTQ0xBU1NOQU1FLCAwLAoJCQkJCVdTX0NISUxEfFdTX1ZJU0lCTEV8V1NfQ0xJUFNJQkxJTkdTfFdTX0JPUkRFUnxDQ1NfTk9ESVZJREVSLCAwLDAsMCwwLAoJCQkJCUdsb2JhbHMuaE1haW5XbmQsIChITUVOVSlJRFdfU1RBVFVTQkFSLCBoaW5zdGFuY2UsIDApOyovCgoJLypUT0RPOiByZWFkIHBhdGhzIGZyb20gcmVnaXN0cnkgKi8KCglpZiAoIXBhdGggfHwgISpwYXRoKSB7CgkJR2V0Q3VycmVudERpcmVjdG9yeShNQVhfUEFUSCwgYnVmZmVyKTsKCQlwYXRoID0gYnVmZmVyOwoJfQoKCVNob3dXaW5kb3coR2xvYmFscy5oTWFpblduZCwgY21kc2hvdyk7CgojaWYgZGVmaW5lZChfU0hFTExfRk9MREVSUykgJiYgIWRlZmluZWQoX19XSU5FX18pCgkgLyogU2hlbGwgTmFtZXNwYWNlIGFzIGRlZmF1bHQ6ICovCgljaGlsZCA9IGFsbG9jX2NoaWxkX3dpbmRvdyhwYXRoLCBnZXRfcGF0aF9waWRsKHBhdGgsR2xvYmFscy5oTWFpblduZCksIEdsb2JhbHMuaE1haW5XbmQpOwojZWxzZQoJY2hpbGQgPSBhbGxvY19jaGlsZF93aW5kb3cocGF0aCwgTlVMTCwgR2xvYmFscy5oTWFpblduZCk7CiNlbmRpZgoKCWNoaWxkLT5wb3Muc2hvd0NtZCA9IFNXX1NIT1dNQVhJTUlaRUQ7CgljaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24ubGVmdCA9IDA7CgljaGlsZC0+cG9zLnJjTm9ybWFsUG9zaXRpb24udG9wID0gMDsKCWNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi5yaWdodCA9IDMyMDsKCWNoaWxkLT5wb3MucmNOb3JtYWxQb3NpdGlvbi5ib3R0b20gPSAyODA7CgoJaWYgKCFjcmVhdGVfY2hpbGRfd2luZG93KGNoaWxkKSkKCQlIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBjaGlsZCk7CgoJU2V0V2luZG93UGxhY2VtZW50KGNoaWxkLT5od25kLCAmY2hpbGQtPnBvcyk7CgoJR2xvYmFscy5oaW1sID0gSW1hZ2VMaXN0X0xvYWRCaXRtYXAoR2xvYmFscy5oSW5zdGFuY2UsIE1BS0VJTlRSRVNPVVJDRShJREJfSU1BR0VTKSwgMTYsIDAsIFJHQigwLDI1NSwwKSk7CgoJR2xvYmFscy5wcmVzY2FuX25vZGUgPSBGQUxTRTsKCglVcGRhdGVXaW5kb3coR2xvYmFscy5oTWFpblduZCk7CgoJaWYgKHBhdGggJiYgcGF0aFswXSkKCXsKCQlpbnQgaW5kZXgsY291bnQ7CgkJVENIQVIgZHJ2W19NQVhfRFJJVkUrMV0sIGRpcltfTUFYX0RJUl0sIG5hbWVbX01BWF9GTkFNRV0sIGV4dFtfTUFYX0VYVF07CgkJVENIQVIgZnVsbG5hbWVbX01BWF9GTkFNRStfTUFYX0VYVCsxXTsKCgkJbWVtc2V0KG5hbWUsMCxzaXplb2YobmFtZSkpOwoJCW1lbXNldChuYW1lLDAsc2l6ZW9mKGV4dCkpOwoJCV90c3BsaXRwYXRoKHBhdGgsIGRydiwgZGlyLCBuYW1lLCBleHQpOwoJCWlmIChuYW1lWzBdKQoJCXsKCQkJY291bnQgPSBTZW5kTWVzc2FnZShjaGlsZC0+cmlnaHQuaHduZCwgTEJfR0VUQ09VTlQsIDAsIDApOwoJCQlsc3RyY3B5KGZ1bGxuYW1lLG5hbWUpOwoJCQlsc3RyY2F0KGZ1bGxuYW1lLGV4dCk7CgoJCQlmb3IgKGluZGV4ID0gMDsgaW5kZXggPCBjb3VudDsgaW5kZXggKyspCgkJCXsKCQkJCUVudHJ5KiBlbnRyeSA9IChFbnRyeSopIFNlbmRNZXNzYWdlKGNoaWxkLT5yaWdodC5od25kLCBMQl9HRVRJVEVNREFUQSwgaW5kZXgsIDApOwoJCQkJaWYgKGxzdHJjbXAoZW50cnktPmRhdGEuY0ZpbGVOYW1lLGZ1bGxuYW1lKT09MCB8fAoJCQkJCQlsc3RyY21wKGVudHJ5LT5kYXRhLmNBbHRlcm5hdGVGaWxlTmFtZSxmdWxsbmFtZSk9PTApCgkJCQl7CgkJCQkJU2VuZE1lc3NhZ2UoY2hpbGQtPnJpZ2h0Lmh3bmQsIExCX1NFVENVUlNFTCwgaW5kZXgsIDApOwoJCQkJCVNldEZvY3VzKGNoaWxkLT5yaWdodC5od25kKTsKCQkJCQlicmVhazsKCQkJCX0KCQkJfQoJCX0KCX0KfQoKc3RhdGljIHZvaWQgRXhpdEluc3RhbmNlKHZvaWQpCnsKI2lmZGVmIF9TSEVMTF9GT0xERVJTCglJU2hlbGxGb2xkZXJfUmVsZWFzZShHbG9iYWxzLmlEZXNrdG9wKTsKCUlNYWxsb2NfUmVsZWFzZShHbG9iYWxzLmlNYWxsb2MpOwoJQ29VbmluaXRpYWxpemUoKTsKI2VuZGlmCgoJRGVsZXRlT2JqZWN0KEdsb2JhbHMuaGZvbnQpOwoJSW1hZ2VMaXN0X0Rlc3Ryb3koR2xvYmFscy5oaW1sKTsKfQoKI2lmZGVmIF9OT19FWFRFTlNJT05TCgovKiBzZWFyY2ggZm9yIGFscmVhZHkgcnVubmluZyB3aW5bZV1maWxlcyAqLwoKc3RhdGljIGludCBnX2ZvdW5kUHJldkluc3RhbmNlID0gMDsKCnN0YXRpYyBCT09MIENBTExCQUNLIEVudW1XbmRQcm9jKEhXTkQgaHduZCwgTFBBUkFNIGxwYXJhbSkKewoJVENIQVIgY2xzWzEyOF07CgoJR2V0Q2xhc3NOYW1lKGh3bmQsIGNscywgMTI4KTsKCglpZiAoIWxzdHJjbXAoY2xzLCAoTFBDVFNUUilscGFyYW0pKSB7CgkJZ19mb3VuZFByZXZJbnN0YW5jZSsrOwoJCXJldHVybiBGQUxTRTsKCX0KCglyZXR1cm4gVFJVRTsKfQoKLyogc2VhcmNoIGZvciB3aW5kb3cgb2YgZ2l2ZW4gY2xhc3MgbmFtZSB0byBhbGxvdyBvbmx5IG9uZSBydW5uaW5nIGluc3RhbmNlICovCnN0YXRpYyBpbnQgZmluZF93aW5kb3dfY2xhc3MoTFBDVFNUUiBjbGFzc25hbWUpCnsKCUVudW1XaW5kb3dzKEVudW1XbmRQcm9jLCAoTFBBUkFNKWNsYXNzbmFtZSk7CgoJaWYgKGdfZm91bmRQcmV2SW5zdGFuY2UpCgkJcmV0dXJuIDE7CgoJcmV0dXJuIDA7Cn0KCiNlbmRpZgoKc3RhdGljIGludCB3aW5lZmlsZV9tYWluKEhJTlNUQU5DRSBoaW5zdGFuY2UsIGludCBjbWRzaG93LCBMUENUU1RSIHBhdGgpCnsKCU1TRyBtc2c7CiAgCglJbml0SW5zdGFuY2UoaGluc3RhbmNlKTsKCglzaG93X2ZyYW1lKDAsIGNtZHNob3csIHBhdGgpOwoKCXdoaWxlKEdldE1lc3NhZ2UoJm1zZywgMCwgMCwgMCkpIHsKCQlpZiAoR2xvYmFscy5obWRpY2xpZW50ICYmIFRyYW5zbGF0ZU1ESVN5c0FjY2VsKEdsb2JhbHMuaG1kaWNsaWVudCwgJm1zZykpCgkJCWNvbnRpbnVlOwoKCQlpZiAoR2xvYmFscy5oTWFpblduZCAmJiBUcmFuc2xhdGVBY2NlbGVyYXRvcihHbG9iYWxzLmhNYWluV25kLCBHbG9iYWxzLmhhY2NlbCwgJm1zZykpCgkJCWNvbnRpbnVlOwoKCQlUcmFuc2xhdGVNZXNzYWdlKCZtc2cpOwoJCURpc3BhdGNoTWVzc2FnZSgmbXNnKTsKCX0KCglFeGl0SW5zdGFuY2UoKTsKCglyZXR1cm4gbXNnLndQYXJhbTsKfQoKCiNpZiBkZWZpbmVkKFVOSUNPREUpICYmIGRlZmluZWQoX01TQ19WRVIpCmludCBBUElFTlRSWSB3V2luTWFpbihISU5TVEFOQ0UgaGluc3RhbmNlLCBISU5TVEFOQ0UgcHJldmluc3RhbmNlLCBMUFdTVFIgY21kbGluZSwgaW50IGNtZHNob3cpCiNlbHNlCmludCBBUElFTlRSWSBXaW5NYWluKEhJTlNUQU5DRSBoaW5zdGFuY2UsIEhJTlNUQU5DRSBwcmV2aW5zdGFuY2UsIExQU1RSIGNtZGxpbmUsIGludCBjbWRzaG93KQojZW5kaWYKewojaWZkZWYgX05PX0VYVEVOU0lPTlMKCWlmIChmaW5kX3dpbmRvd19jbGFzcyhzV0lORUZJTEVGUkFNRSkpCgkJcmV0dXJuIDE7CiNlbmRpZgoKI2lmIGRlZmluZWQoVU5JQ09ERSkgJiYgIWRlZmluZWQoX01TQ19WRVIpCgl7IC8qIGNvbnZlcnQgQU5TSSBjbWRsaW5lIGludG8gV0NTIHBhdGggc3RyaW5nICovCglUQ0hBUiBidWZmZXJbTUFYX1BBVEhdOwoJTXVsdGlCeXRlVG9XaWRlQ2hhcihDUF9BQ1AsIDAsIGNtZGxpbmUsIC0xLCBidWZmZXIsIE1BWF9QQVRIKTsKCXdpbmVmaWxlX21haW4oaGluc3RhbmNlLCBjbWRzaG93LCBidWZmZXIpOwoJfQojZWxzZQoJd2luZWZpbGVfbWFpbihoaW5zdGFuY2UsIGNtZHNob3csIGNtZGxpbmUpOwojZW5kaWYKCglyZXR1cm4gMDsKfQo=